bump to 1.1.20 (#849)

* move sdl init

* more

* more

* more

* more

.cargo/config.toml

@@ -1,15 +1,23 @@
-[target.'cfg(not(target_os = "windows"))']
-rustflags = ["-C", "linker=clang", "-C", "link-arg=-fuse-ld=lld"]
+[target.'cfg(all(target_arch = "aarch64", target_os = "linux"))']
+rustflags = ["-C", "link-arg=-fuse-ld=lld"]
+
+[target.'cfg(any(target_os = "windows", target_os = "macos"))']
+linker = "rust-lld"
 
 [target.'cfg(target_os = "windows")']
-rustflags = ["-C", "linker=lld-link", "-C", "link-arg=-fuse-ld=lld-link"]
+rustflags = ["-C", "link-arg=/STACK:8388608"]
 
 [target.'cfg(target_arch = "x86_64")']
 rustflags = ["-C", "target-cpu=x86-64-v3"]
 
-[target.'cfg(target_arch = "aarch64")']
+[target.'cfg(all(target_arch = "aarch64", target_os = "macos"))']
+rustflags = ["-C", "target-cpu=apple-m1"]
+
+[target.'cfg(all(target_arch = "aarch64", not(target_os = "macos")))']
 rustflags = ["-C", "target-cpu=cortex-a76"]
 
 [env]
 CC = "clang"
 CXX = "clang++"
+AR = "llvm-ar"
+SDKROOT = "/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk"

.github/dependabot.yml

@@ -3,8 +3,13 @@ updates:
   - package-ecosystem: "github-actions"
     directory: "/"
     schedule:
-      interval: "daily"
-  - package-ecosystem: "cargo"
+      interval: "weekly"
+  - package-ecosystem: "rust-toolchain"
     directory: "/"
     schedule:
-      interval: "daily"
+      interval: "weekly"
+
+# - package-ecosystem: "cargo"
+#   directory: "/"
+#   schedule:
+#     interval: "daily"

.github/workflows/build.yml

@@ -4,13 +4,16 @@ permissions:
 
 on:
   push:
-    branches: ["main"]
+    branches: [ "main" ]
+    tags:
+      - "v*"
   pull_request:
-    branches: ["main"]
+    branches: [ "main" ]
+  merge_group:
 
 env:
   CARGO_TERM_COLOR: always
-  LLVM_VERSION: "20.1"
+  RA_HARDCORE: ${{ github.ref_type == 'tag' && 'true' || 'false' }}
 
 jobs:
   build-linux:
@@ -22,43 +25,66 @@ jobs:
           - os: ubuntu-24.04
             target: x86_64-unknown-linux-gnu
             arch: linux-x86_64
+            llvm: X64
           - os: ubuntu-24.04-arm
             target: aarch64-unknown-linux-gnu
             arch: linux-aarch64
+            llvm: ARM64
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           submodules: recursive
+          fetch-depth: 0
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
           target: ${{ matrix.target }}
           rustflags: ""
+          cache: ${{ github.ref_type != 'tag' }}
+      - name: Set LLVM_VERSION
+        run: echo "LLVM_VERSION=$(rustc --version --verbose | grep "LLVM version" | cut
+          -d':' -f2 | xargs)" >> $GITHUB_ENV
       - name: Install SDL Dependencies
         # https://wiki.libsdl.org/SDL3/README-linux#build-dependencies
         uses: awalsh128/cache-apt-pkgs-action@v1
         with:
-          packages: build-essential git make \
-            pkg-config cmake ninja-build gnome-desktop-testing libasound2-dev libpulse-dev \
-            libaudio-dev libjack-dev libsndio-dev libx11-dev libxext-dev \
-            libxrandr-dev libxcursor-dev libxfixes-dev libxi-dev libxss-dev libxtst-dev \
-            libxkbcommon-dev libdrm-dev libgbm-dev libgl1-mesa-dev libgles2-mesa-dev \
-            libegl1-mesa-dev libdbus-1-dev libibus-1.0-dev libudev-dev fcitx-libs-dev \
-            libpipewire-0.3-dev libwayland-dev libdecor-0-dev liburing-dev
+          packages: build-essential git make pkg-config cmake ninja-build
+            gnome-desktop-testing libasound2-dev libpulse-dev libaudio-dev
+            libfribidi-dev libjack-dev libsndio-dev libx11-dev libxext-dev
+            libxrandr-dev libxcursor-dev libxfixes-dev libxi-dev libxss-dev
+            libxtst-dev libxkbcommon-dev libdrm-dev libgbm-dev libgl1-mesa-dev
+            libgles2-mesa-dev libegl1-mesa-dev libdbus-1-dev libibus-1.0-dev
+            libudev-dev libthai-dev libpipewire-0.3-dev libwayland-dev
+            libdecor-0-dev liburing-dev libfreetype-dev libfontconfig-dev
           version: ${{ matrix.target }}-1.0
       - name: Install LLVM and Clang
         uses: KyleMayes/install-llvm-action@v2
         with:
-          version: "${{ env.LLVM_VERSION }}"
+          version: ${{ env.LLVM_VERSION }}
+          force-url: https://github.com/llvm/llvm-project/releases/download/llvmorg-${{
+            env.LLVM_VERSION }}/LLVM-${{ env.LLVM_VERSION }}-Linux-${{
+            matrix.llvm }}.tar.xz
       - name: Build
         run: |
           cargo build --release -v --target=${{ matrix.target }}
           mkdir output
           cp target/${{ matrix.target }}/release/gopher64 output/gopher64-${{ matrix.arch }}
+        env:
+          NETPLAY_ID: ${{ secrets.NETPLAY_ID }}
       - name: Upload file
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: gopher64-${{ matrix.arch }}
           path: output/gopher64-${{ matrix.arch }}
+          archive: false
+      - name: Setup butler
+        if: ${{ github.ref_type == 'tag' }}
+        uses: remarkablegames/setup-butler@v3
+      - name: Upload to itch.io
+        if: ${{ github.ref_type == 'tag' }}
+        run: |
+          butler push output/gopher64-${{ matrix.arch }} loganmc10/gopher64:${{ matrix.arch }} --userversion ${GITHUB_REF_NAME#v}
+        env:
+          BUTLER_API_KEY: ${{ secrets.BUTLER_API_KEY }}
 
   build-windows:
     runs-on: ${{ matrix.os }}
@@ -69,21 +95,32 @@ jobs:
           - os: windows-2025
             target: x86_64-pc-windows-msvc
             arch: windows-x86_64
-          #- os: windows-11-arm
-          #  target: aarch64-pc-windows-msvc
-          #  arch: windows-aarch64
+            llvm: win64
+          - os: windows-11-arm
+            target: aarch64-pc-windows-msvc
+            arch: windows-aarch64
+            llvm: woa64
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           submodules: recursive
+          fetch-depth: 0
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
           target: ${{ matrix.target }}
           rustflags: ""
+          cache: ${{ github.ref_type != 'tag' }}
+      - name: Set LLVM_VERSION
+        run: |
+          $llvm_version = rustc --version --verbose | Select-String "LLVM version" | ForEach-Object { $_.Line.Split(":")[1].Trim() }
+          echo "LLVM_VERSION=$llvm_version" >> $env:GITHUB_ENV
       - name: Install LLVM and Clang
         uses: KyleMayes/install-llvm-action@v2
         with:
-          version: "${{ env.LLVM_VERSION }}"
+          version: ${{ env.LLVM_VERSION }}
+          force-url: https://github.com/llvm/llvm-project/releases/download/llvmorg-${{
+            env.LLVM_VERSION }}/LLVM-${{ env.LLVM_VERSION }}-${{ matrix.llvm
+            }}.exe
       - name: Build
         run: |
           cargo build --release -v --target=${{ matrix.target }}
@@ -92,39 +129,124 @@ jobs:
         env:
           CC: clang-cl
           CXX: clang-cl
-          AR: llvm-lib
-      - name: Upload file
-        uses: actions/upload-artifact@v4
+          NETPLAY_ID: ${{ secrets.NETPLAY_ID }}
+      - name: Upload unsigned artifact
+        id: upload-unsigned-artifact
+        uses: actions/upload-artifact@v7
         with:
           name: gopher64-${{ matrix.arch }}
           path: output/gopher64-${{ matrix.arch }}.exe
+          archive: ${{ github.ref_type == 'tag' && true || false }}
+      - name: SignPath
+        if: ${{ github.ref_type == 'tag' }}
+        uses: signpath/github-action-submit-signing-request@v2
+        with:
+          api-token: "${{ secrets.SIGNPATH_API_TOKEN }}"
+          organization-id: "${{ secrets.SIGNPATH_ORG_ID }}"
+          project-slug: "gopher64"
+          artifact-configuration-slug: "gopher64-${{ matrix.arch }}"
+          signing-policy-slug: "release-signing"
+          github-artifact-id: "${{ steps.upload-unsigned-artifact.outputs.artifact-id }}"
+          wait-for-completion: true
+          wait-for-completion-timeout-in-seconds: 3600
+          output-artifact-directory: output-signed
+      - name: Upload signed artifact
+        if: ${{ github.ref_type == 'tag' }}
+        uses: actions/upload-artifact@v7
+        with:
+          name: gopher64-${{ matrix.arch }}
+          path: output-signed/gopher64-${{ matrix.arch }}.exe
+          archive: false
+          overwrite: true
+      - name: Setup butler
+        if: ${{ github.ref_type == 'tag' }}
+        uses: remarkablegames/setup-butler@v3
+      - name: Upload to itch.io
+        if: ${{ github.ref_type == 'tag' }}
+        shell: bash
+        run: |
+          butler push output-signed/gopher64-${{ matrix.arch }}.exe loganmc10/gopher64:${{ matrix.arch }} --userversion ${GITHUB_REF_NAME#v}
+        env:
+          BUTLER_API_KEY: ${{ secrets.BUTLER_API_KEY }}
 
   build-macos:
-    if: false
     runs-on: macos-15
     strategy:
       fail-fast: false
       matrix:
         include:
-          - target: x86_64-apple-darwin
-            arch: mac-x86_64
           - target: aarch64-apple-darwin
-            arch: mac-aarch64
+            arch: macos-aarch64
+            llvm: ARM64
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           submodules: recursive
+          fetch-depth: 0
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
           target: ${{ matrix.target }}
           rustflags: ""
+          cache: ${{ github.ref_type != 'tag' }}
+      - name: Set LLVM_VERSION
+        run: echo "LLVM_VERSION=$(rustc --version --verbose | grep "LLVM version" | cut
+          -d':' -f2 | xargs)" >> $GITHUB_ENV
+      - name: Install LLVM and Clang
+        uses: KyleMayes/install-llvm-action@v2
+        with:
+          version: ${{ env.LLVM_VERSION }}
+          force-url: https://github.com/llvm/llvm-project/releases/download/llvmorg-${{
+            env.LLVM_VERSION }}/LLVM-${{ env.LLVM_VERSION }}-macOS-${{
+            matrix.llvm }}.tar.xz
       - name: Build
         run: |
-          cargo build --release -v --target=${{ matrix.target }}
-          mkdir output
-          cp target/${{ matrix.target }}/release/gopher64 output/gopher64-${{ matrix.arch }}
+          cargo install cargo-bundle
+          brew install molten-vk
+          cargo build --release --no-default-features -v --target=${{ matrix.target }}
+          mv target/${{ matrix.target }}/release/gopher64 target/${{ matrix.target }}/release/gopher64-cli
+          cargo bundle --release --target=${{ matrix.target }} --format osx
+          cp target/${{ matrix.target }}/release/gopher64-cli target/${{ matrix.target }}/release/bundle/osx/Gopher64.app/Contents/MacOS/gopher64-cli
+          install_name_tool -change /opt/homebrew/opt/freetype/lib/libfreetype.6.dylib \
+            @executable_path/../Frameworks/libfreetype.6.dylib target/${{ matrix.target }}/release/bundle/osx/Gopher64.app/Contents/MacOS/gopher64
+          install_name_tool -change /opt/homebrew/opt/freetype/lib/libfreetype.6.dylib \
+            @executable_path/../Frameworks/libfreetype.6.dylib target/${{ matrix.target }}/release/bundle/osx/Gopher64.app/Contents/MacOS/gopher64-cli
+          install_name_tool -change /opt/homebrew/opt/libpng/lib/libpng16.16.dylib \
+            @executable_path/../Frameworks/libpng16.16.dylib target/${{ matrix.target }}/release/bundle/osx/Gopher64.app/Contents/Frameworks/libfreetype.6.dylib
+        env:
+          NETPLAY_ID: ${{ secrets.NETPLAY_ID }}
+          MACOSX_DEPLOYMENT_TARGET: "15.0"
+      - name: Sign Bundle Dev
+        if: ${{ github.ref_type != 'tag' }}
+        run: |
+          codesign -f --entitlements data/macos/entitlements_dev.plist --deep --timestamp --options runtime -s - target/${{ matrix.target }}/release/bundle/osx/Gopher64.app
+      - name: Import Codesign Certs
+        if: ${{ github.ref_type == 'tag' }}
+        uses: apple-actions/import-codesign-certs@v7
+        with:
+          p12-file-base64: ${{ secrets.APPLE_CERTIFICATES_FILE_BASE64 }}
+          p12-password: ${{ secrets.APPLE_CERTIFICATES_PASSWORD }}
+      - name: Sign Bundle Release
+        if: ${{ github.ref_type == 'tag' }}
+        run: |
+          codesign -f --timestamp --options runtime -s "${{ secrets.APPLE_DEVELOPER_ID }}" target/${{ matrix.target }}/release/bundle/osx/Gopher64.app/Contents/Frameworks/libpng16.16.dylib
+          codesign -f --timestamp --options runtime -s "${{ secrets.APPLE_DEVELOPER_ID }}" target/${{ matrix.target }}/release/bundle/osx/Gopher64.app/Contents/Frameworks/libfreetype.6.dylib
+          codesign -f --timestamp --options runtime -s "${{ secrets.APPLE_DEVELOPER_ID }}" target/${{ matrix.target }}/release/bundle/osx/Gopher64.app/Contents/Frameworks/libMoltenVK.dylib
+          codesign -f --entitlements data/macos/entitlements_child.plist --timestamp --options runtime -s "${{ secrets.APPLE_DEVELOPER_ID }}" target/${{ matrix.target }}/release/bundle/osx/Gopher64.app/Contents/MacOS/gopher64-cli
+          codesign -f --entitlements data/macos/entitlements_prod.plist --timestamp --options runtime -s "${{ secrets.APPLE_DEVELOPER_ID }}" target/${{ matrix.target }}/release/bundle/osx/Gopher64.app
+          zip -r gopher64-${{ matrix.arch }}.zip target/${{ matrix.target }}/release/bundle/osx/Gopher64.app
+          xcrun notarytool submit --wait --apple-id "${{ secrets.APPLE_ID }}" --team-id "${{ secrets.APPLE_DEVELOPER_ID }}" --password "${{ secrets.APPLE_APP_PASSWORD }}" gopher64-${{ matrix.arch }}.zip
+          xcrun stapler staple target/${{ matrix.target }}/release/bundle/osx/Gopher64.app
       - name: Upload file
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: gopher64-${{ matrix.arch }}
-          path: output/gopher64-${{ matrix.arch }}
+          path: target/${{ matrix.target }}/release/bundle/osx
+      - name: Setup butler
+        if: ${{ github.ref_type == 'tag' }}
+        uses: remarkablegames/setup-butler@v3
+      - name: Upload to itch.io
+        if: ${{ github.ref_type == 'tag' }}
+        run: |
+          butler push target/${{ matrix.target }}/release/bundle/osx/Gopher64.app loganmc10/gopher64:${{ matrix.arch }} --userversion ${GITHUB_REF_NAME#v}
+        env:
+          BUTLER_API_KEY: ${{ secrets.BUTLER_API_KEY }}

.github/workflows/lint.yml

@@ -2,45 +2,52 @@ name: Rust-lint
 
 on:
   push:
-    branches: ["main"]
+    branches: [ "main" ]
   pull_request:
-    branches: ["main"]
+    branches: [ "main" ]
+  merge_group:
 
 permissions:
   contents: read
 
 env:
   CARGO_TERM_COLOR: always
-  LLVM_VERSION: "20.1"
 
 jobs:
   lint-linux:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           submodules: recursive
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
           components: clippy, rustfmt
+      - name: Set LLVM_VERSION
+        run: echo "LLVM_VERSION=$(rustc --version --verbose | grep "LLVM version" | cut
+          -d':' -f2 | xargs)" >> $GITHUB_ENV
       - name: Install SDL Dependencies
         # https://wiki.libsdl.org/SDL3/README-linux#build-dependencies
         uses: awalsh128/cache-apt-pkgs-action@v1
         with:
-          packages: build-essential git make \
-            pkg-config cmake ninja-build gnome-desktop-testing libasound2-dev libpulse-dev \
-            libaudio-dev libjack-dev libsndio-dev libx11-dev libxext-dev \
-            libxrandr-dev libxcursor-dev libxfixes-dev libxi-dev libxss-dev libxtst-dev \
-            libxkbcommon-dev libdrm-dev libgbm-dev libgl1-mesa-dev libgles2-mesa-dev \
-            libegl1-mesa-dev libdbus-1-dev libibus-1.0-dev libudev-dev fcitx-libs-dev \
-            libpipewire-0.3-dev libwayland-dev libdecor-0-dev liburing-dev
+          packages: build-essential git make pkg-config cmake ninja-build
+            gnome-desktop-testing libasound2-dev libpulse-dev libaudio-dev
+            libfribidi-dev libjack-dev libsndio-dev libx11-dev libxext-dev
+            libxrandr-dev libxcursor-dev libxfixes-dev libxi-dev libxss-dev
+            libxtst-dev libxkbcommon-dev libdrm-dev libgbm-dev libgl1-mesa-dev
+            libgles2-mesa-dev libegl1-mesa-dev libdbus-1-dev libibus-1.0-dev
+            libudev-dev libthai-dev libpipewire-0.3-dev libwayland-dev
+            libdecor-0-dev liburing-dev libfreetype-dev libfontconfig-dev
           version: lint-1.0
       - name: Install LLVM and Clang
         uses: KyleMayes/install-llvm-action@v2
         with:
-          version: "${{ env.LLVM_VERSION }}"
+          version: ${{ env.LLVM_VERSION }}
+          force-url: https://github.com/llvm/llvm-project/releases/download/llvmorg-${{
+            env.LLVM_VERSION }}/LLVM-${{ env.LLVM_VERSION }}-Linux-X64.tar.xz
       - name: Rustfmt Check
         uses: actions-rust-lang/rustfmt@v1
       - name: Lint
         run: |
           cargo clippy -- -Dwarnings
+          cargo clippy --no-default-features -- -Dwarnings

.github/workflows/sec.yml

@@ -10,7 +10,7 @@ jobs:
       checks: write
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           submodules: recursive
       - uses: rustsec/audit-check@v2

.gitmodules

@@ -1,3 +1,11 @@
 [submodule "parallel-rdp/parallel-rdp-standalone"]
 	path = parallel-rdp/parallel-rdp-standalone
 	url = https://github.com/Themaister/parallel-rdp-standalone.git
+	branch = master
+[submodule "src/compat/sse2neon"]
+	path = src/compat/sse2neon
+	url = https://github.com/DLTcollab/sse2neon.git
+	branch = master
+[submodule "retroachievements/rcheevos"]
+	path = retroachievements/rcheevos
+	url = https://github.com/RetroAchievements/rcheevos.git

Cargo.toml

@@ -1,47 +1,63 @@
 [package]
 name = "gopher64"
-version = "1.1.0"
+version = "1.1.20"
 edition = "2024"
-rust-version = "1.88"
+rust-version = "1.95.0"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[features]
+default = ["gui"]
+gui = ["dep:rfd", "dep:slint", "dep:slint-build"]
 
 [dependencies]
 dirs = "6.0"
-zip = "4.3"
-governor = "0.10"
-sevenz-rust2 = { version = "0.16", default-features = false }
+zip = "8.0"
+sevenz-rust2 = "0.21"
 chrono = "0.4"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 serde-big-array = "0.5"
-slint = { version = "1.12", default-features = false, features = ["compat-1-2", "std", "backend-winit", "renderer-femtovg"] }
+slint = { version = "1.16", default-features = false, features = ["compat-1-2", "std", "unstable-winit-030", "backend-winit", "renderer-skia", "accessibility"], optional = true }
 open = "5.3"
-sha2 = "0.10"
-ab_glyph = "0.2"
-sdl3-sys = { version = "0.5", features = ["build-from-source-static"] }
-rfd = { version = "0.15", default-features = false, features = ["xdg-portal", "tokio"] }
-tokio = {version = "1.46", features = ["rt-multi-thread", "macros"] }
+sha2 = "0.11"
+sdl3-sys = { version = "0.6", features = ["build-from-source-static"] }
+sdl3-ttf-sys = { version = "0.6", features = ["build-from-source-static", "no-sdlttf-harfbuzz", "no-sdlttf-plutosvg"] }
+rfd = {version = "0.17", optional = true }
+tokio = {version = "1.46", features = ["rt-multi-thread", "macros", "fs", "process"] }
 spin_sleep = "1.3"
 encoding_rs = "0.8"
 mimalloc = "0.1"
 regex = "1.11"
-tokio-tungstenite = "0.27"
+tokio-tungstenite = "0.29"
 futures = "0.3"
 socket2 = { version = "0.6", features = ["all"] }
-rand_chacha = "0.9"
+rand = "0.10"
 fatfs = "0.3"
 semver = "1.0"
 postcard = { version = "1.1", features = ["use-std"] }
 clap = { version = "4.5", features = ["derive"] }
-reqwest = { version = "0.12", default-features = false, features = ["http2","rustls-tls","charset","json"] }
+reqwest = { version = "0.13", features = ["json", "query"] }
 
 [build-dependencies]
 winresource = "0.1"
 bindgen = "0.72"
-slint-build = "1.12"
+slint-build = { version = "1.12", optional = true }
 cc = { version = "1.2", features = ["parallel"] }
 
 [profile.release]
 panic = "abort"
 lto = "thin"
+strip = true
+
+[profile.release-with-debug]
+inherits = "release"
+debug = true
+strip = false
+panic = "unwind"
+
+[package.metadata.bundle]
+name = "Gopher64"
+identifier = "io.github.gopher64.gopher64"
+category = "public.app-category.games"
+icon = ["data/icon/gopher64_128x128.png","data/icon/gopher64_256x256.png","data/icon/gopher64_512x512.png"]
+osx_frameworks = ["/opt/homebrew/opt/molten-vk/lib/libMoltenVK.dylib","/opt/homebrew/opt/freetype/lib/libfreetype.6.dylib","/opt/homebrew/opt/libpng/lib/libpng16.16.dylib"]
+osx_minimum_system_version = "15.0"

README.md

@@ -1,9 +1,28 @@
 # gopher64
+Gopher64 is a cross-platform N64 emulator. Some notable features:
+* Netplay
+* Homebrew support
+* Upscaling
+* CRT shader
+* Emulate CPU overclocking
+* Cheats
+* Savestates
+* RetroAchievements
+
 ## download
 
-Windows: https://github.com/gopher64/gopher64/releases/latest/download/gopher64-windows-x86_64.exe
+<a href="https://loganmc10.itch.io/gopher64"><img src="https://static.itch.io/images/badge.svg" width="200" ></a>
 
-Linux: https://flathub.org/apps/io.github.gopher64.gopher64
+Windows:
+* Standalone executable: [gopher64-windows-x86_64.exe](https://github.com/gopher64/gopher64/releases/latest/download/gopher64-windows-x86_64.exe)
+
+MacOS:
+* App Bundle: [gopher64-macos-aarch64.zip](https://github.com/gopher64/gopher64/releases/latest/download/gopher64-macos-aarch64.zip)
+* Homebrew: `brew install --cask gopher64`
+
+Linux:
+* Standalone executable: [gopher64-linux-x86_64](https://github.com/gopher64/gopher64/releases/latest/download/gopher64-linux-x86_64)
+* Flatpak: `flatpak install flathub io.github.gopher64.gopher64`
 
 ## wiki
 
@@ -11,19 +30,15 @@ https://github.com/gopher64/gopher64/wiki
 
 ## discord
 
-https://discord.gg/9RGXq8W8JQ
+[Discord invite link](https://discord.gg/9RGXq8W8JQ)
 
 ## controls
 
 Keys are mapped according to [these defaults](https://github.com/gopher64/gopher64/wiki/Default-Keyboard-Setup). Xbox-style controllers also have a [default mapping applied](https://github.com/gopher64/gopher64/wiki/Default-Gamepad-Setup).
 
-You can create your mappings by running `./gopher64 --configure-input-profile my_profile`. You then bind that profile to a port: `./gopher64 --bind-input-profile my_profile --port 1`
-
-To use a controller (for example, an Xbox controller), run `./gopher64 --list-controllers` to get a list of attached controllers, and then assign it by doing `./gopher64 --assign-controller <controller_number> --port 1`
-
 ## netplay
 
-Gopher64 supports netplay (online play with others). It has a few public netplay servers. If you are interested in running a public netplay server, please let me know (open an issue or discussion or contact me on Discord). You can also run the server (https://github.com/gopher64/gopher64-netplay-server) yourself on a LAN.
+Gopher64 supports netplay (online play with others) via cloud hosted servers. You can also run the [server](https://github.com/gopher64/gopher64-netplay-server) yourself on a LAN.
 
 ## portable mode
 
@@ -37,16 +52,10 @@ If you want to run the flatpak from the command line, you need to add the `--fil
 flatpak run --filesystem=host:ro io.github.gopher64.gopher64 /path/to/rom.z64
 ```
 
-## goals
-
-1. Performance. I want to be able to use this emulator on my laptop.
-2. Easy to use.
-3. Easy to work on. Dynamic recompilers perform well, but they are very hard to read and understand. This emulator will only have interpreters for the CPU and RSP. Additionally, it is completely written in Rust (besides Parallel-RDP), a modern programming language with a growing user base. I've tried to avoid the use of macros, which can reduce some repetitiveness in the code but also reduce readability.
-
 ## building and usage
 
-1. Linux only: install the SDL3 dependencies: https://wiki.libsdl.org/SDL3/README-linux#build-dependencies
-2. Install rust: https://www.rust-lang.org/tools/install
+1. Linux only: [install the SDL3 dependencies](https://wiki.libsdl.org/SDL3/README-linux#build-dependencies)
+2. [Install rust](https://www.rust-lang.org/tools/install)
 3. `git clone --recursive https://github.com/gopher64/gopher64.git`
 4. `cd gopher64`
 5. `cargo build --release`
@@ -58,4 +67,12 @@ I am very open to contributions! Please contact me via a GitHub issue or Discord
 
 ## license
 
-Gopher64 is licensed under the GPLv3 license. Many portions of gopher64 have been adapted from mupen64plus and/or ares. The license for mupen64plus can be found here: https://github.com/mupen64plus/mupen64plus-core/blob/master/LICENSES. The license for ares can be found here: https://github.com/ares-emulator/ares/blob/master/LICENSE.
+Gopher64 is licensed under the GPLv3 license. Many portions of gopher64 have been adapted from mupen64plus and/or ares. The license for mupen64plus can be found [here](https://github.com/mupen64plus/mupen64plus-core/blob/master/LICENSES). The license for ares can be found [here](https://github.com/ares-emulator/ares/blob/master/LICENSE).
+
+## privacy and code signing policy
+
+Free code signing for the Windows release is provided by [SignPath.io](https://about.signpath.io), certificate by [SignPath Foundation](https://signpath.org).
+
+During online netplay sessions, the server logs your IP address and basic session information (game title and session name) for operational purposes. No additional personal data is collected or stored.
+
+If you enable the RetroAchievements feature, some data is sent to their systems. Please see their terms [here](https://retroachievements.org/terms).

build.rs

@@ -1,18 +1,24 @@
 fn main() {
     println!("cargo::rerun-if-changed=parallel-rdp");
+    println!("cargo::rerun-if-changed=retroachievements");
     println!("cargo::rerun-if-changed=src/compat");
 
-    let slint_config = slint_build::CompilerConfiguration::new().with_style("cosmic".into());
-    slint_build::compile_with_config("src/ui/gui/appwindow.slint", slint_config).unwrap();
+    #[cfg(feature = "gui")]
+    {
+        let slint_config = slint_build::CompilerConfiguration::new();
+        slint_build::compile_with_config("src/ui/gui/appwindow.slint", slint_config).unwrap();
+    }
 
     let mut simd_build = cc::Build::new();
     let mut volk_build = cc::Build::new();
     volk_build
+        .std("c17")
         .include("parallel-rdp/parallel-rdp-standalone/vulkan-headers/include")
         .file("parallel-rdp/parallel-rdp-standalone/volk/volk.c");
     let mut rdp_build = cc::Build::new();
     rdp_build
         .cpp(true)
+        .std("c++20")
         .flag("-Wno-unused-parameter")
         .flag("-Wno-missing-field-initializers")
         .file("parallel-rdp/parallel-rdp-standalone/parallel-rdp/command_ring.cpp")
@@ -59,56 +65,153 @@ fn main() {
         .include("parallel-rdp/parallel-rdp-standalone/vulkan-headers/include")
         .include("parallel-rdp/parallel-rdp-standalone/util")
         .include(
-            std::path::PathBuf::from(std::env::var("DEP_SDL3_OUT_DIR").to_owned().unwrap())
+            std::path::PathBuf::from(std::env::var("DEP_SDL3_OUT_DIR").unwrap()).join("include"),
+        )
+        .include(
+            std::path::PathBuf::from(std::env::var("DEP_SDL3_TTF_OUT_DIR").unwrap())
                 .join("include"),
         );
 
+    let mut retroachievements_build = cc::Build::new();
+    retroachievements_build
+        .flag("-Wno-unused-parameter")
+        .include("retroachievements/rcheevos/include")
+        .flag("-DRC_CLIENT_SUPPORTS_HASH")
+        .file("retroachievements/rcheevos/src/rc_client.c")
+        .file("retroachievements/rcheevos/src/rc_compat.c")
+        .file("retroachievements/rcheevos/src/rc_util.c")
+        .file("retroachievements/rcheevos/src/rcheevos/alloc.c")
+        .file("retroachievements/rcheevos/src/rcheevos/condition.c")
+        .file("retroachievements/rcheevos/src/rcheevos/condset.c")
+        .file("retroachievements/rcheevos/src/rcheevos/consoleinfo.c")
+        .file("retroachievements/rcheevos/src/rcheevos/format.c")
+        .file("retroachievements/rcheevos/src/rcheevos/lboard.c")
+        .file("retroachievements/rcheevos/src/rcheevos/memref.c")
+        .file("retroachievements/rcheevos/src/rcheevos/operand.c")
+        .file("retroachievements/rcheevos/src/rcheevos/richpresence.c")
+        .file("retroachievements/rcheevos/src/rcheevos/runtime.c")
+        .file("retroachievements/rcheevos/src/rcheevos/runtime_progress.c")
+        .file("retroachievements/rcheevos/src/rcheevos/trigger.c")
+        .file("retroachievements/rcheevos/src/rcheevos/value.c")
+        .file("retroachievements/rcheevos/src/rapi/rc_api_common.c")
+        .file("retroachievements/rcheevos/src/rapi/rc_api_info.c")
+        .file("retroachievements/rcheevos/src/rapi/rc_api_runtime.c")
+        .file("retroachievements/rcheevos/src/rapi/rc_api_user.c")
+        .file("retroachievements/rcheevos/src/rhash/aes.c")
+        .file("retroachievements/rcheevos/src/rhash/cdreader.c")
+        .file("retroachievements/rcheevos/src/rhash/md5.c")
+        .file("retroachievements/rcheevos/src/rhash/hash.c")
+        .file("retroachievements/rcheevos/src/rhash/hash_disc.c")
+        .file("retroachievements/rcheevos/src/rhash/hash_encrypted.c")
+        .file("retroachievements/rcheevos/src/rhash/hash_rom.c")
+        .file("retroachievements/rcheevos/src/rhash/hash_zip.c")
+        .file("retroachievements/retroachievements.c");
+
     let os = std::env::var("CARGO_CFG_TARGET_OS").unwrap();
     let arch = std::env::var("CARGO_CFG_TARGET_ARCH").unwrap();
-    let profile = std::env::var("PROFILE").unwrap();
     let opt_flag = if arch == "x86_64" {
         "-march=x86-64-v3"
-    } else if arch == "aarch64" {
+    } else if arch == "aarch64" && os == "macos" {
+        "-march=armv8.4-a"
+    } else if arch == "aarch64" && os != "macos" {
         "-march=armv8.2-a"
     } else {
         panic!("unknown arch")
     };
+
     volk_build.flag(opt_flag);
     rdp_build.flag(opt_flag);
     simd_build.flag(opt_flag);
+    retroachievements_build.flag(opt_flag);
 
     if os == "windows" {
         volk_build.flag("-DVK_USE_PLATFORM_WIN32_KHR");
         rdp_build.flag("-DVK_USE_PLATFORM_WIN32_KHR");
 
         winresource::WindowsResource::new()
-            .set_icon("data/icon.ico")
+            .set_icon("data/icon/icon.ico")
             .compile()
             .unwrap();
+    } else if os == "macos" {
+        println!("cargo:rustc-link-search=native=/opt/homebrew/opt/freetype/lib");
+        println!("cargo:rustc-link-lib=dylib=freetype");
+
+        let output = std::process::Command::new("clang")
+            .args(["--print-runtime-dir"])
+            .output()
+            .unwrap();
+
+        let runtime_dir = String::from_utf8_lossy(&output.stdout).trim().to_string();
+
+        println!("cargo:rustc-link-search=native={}", runtime_dir);
+        println!("cargo:rustc-link-lib=static=clang_rt.osx");
+    }
+    if cfg!(not(feature = "gui")) && os == "linux" {
+        println!("cargo:rustc-link-lib=dylib=freetype");
     }
 
-    if profile == "release" {
-        volk_build.flag("-flto=thin");
-        rdp_build.flag("-flto=thin");
-        simd_build.flag("-flto=thin");
-    }
+    volk_build.flag("-flto=thin");
+    rdp_build.flag("-flto=thin");
+    simd_build.flag("-flto=thin");
+    retroachievements_build.flag("-flto=thin");
+
     volk_build.compile("volk");
     rdp_build.compile("parallel-rdp");
+    retroachievements_build.compile("retroachievements");
 
     let out_path = std::path::PathBuf::from(std::env::var("OUT_DIR").unwrap());
 
+    let mut retroachievements_builder = bindgen::Builder::default()
+        .header("retroachievements/retroachievements.h")
+        .allowlist_function("ra_init_client")
+        .allowlist_function("ra_welcome")
+        .allowlist_function("ra_shutdown_client")
+        .allowlist_function("ra_get_hardcore")
+        .allowlist_function("ra_load_game")
+        .allowlist_function("ra_unload_game")
+        .allowlist_function("ra_set_dmem")
+        .allowlist_function("ra_do_frame")
+        .allowlist_function("ra_do_idle")
+        .allowlist_function("ra_http_callback")
+        .allowlist_function("ra_login_user")
+        .allowlist_function("ra_login_token_user")
+        .allowlist_function("ra_state_size")
+        .allowlist_function("ra_save_state")
+        .allowlist_function("ra_load_state");
+
+    if cfg!(feature = "gui") {
+        retroachievements_builder = retroachievements_builder
+            .allowlist_function("ra_logout_user")
+            .allowlist_function("ra_get_username")
+            .allowlist_function("ra_get_token");
+    }
+
+    let retroachievements_bindings = retroachievements_builder
+        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
+        .generate()
+        .expect("Unable to generate bindings");
+
+    retroachievements_bindings
+        .write_to_file(out_path.join("retroachievements_bindings.rs"))
+        .expect("Couldn't write bindings!");
+
     let parallel_bindings = bindgen::Builder::default()
         .header("parallel-rdp/interface.hpp")
         .allowlist_function("rdp_init")
         .allowlist_function("rdp_close")
         .allowlist_function("rdp_set_vi_register")
         .allowlist_function("rdp_update_screen")
+        .allowlist_function("rdp_render_frame")
         .allowlist_function("rdp_process_commands")
+        .allowlist_function("rdp_onscreen_message")
         .allowlist_function("rdp_check_callback")
         .allowlist_function("rdp_new_processor")
+        .allowlist_function("rdp_check_framebuffers")
         .allowlist_function("rdp_state_size")
         .allowlist_function("rdp_save_state")
         .allowlist_function("rdp_load_state")
+        .allowlist_function("rdp_set_fps")
+        .allowlist_function("get_joystick_event")
         .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
         .generate()
         .expect("Unable to generate bindings");
@@ -119,7 +222,7 @@ fn main() {
 
     if arch == "aarch64" {
         let simd_bindings = bindgen::Builder::default()
-            .header("src/compat/sse2neon/v1.8.0/sse2neon.h")
+            .header("src/compat/sse2neon/sse2neon.h")
             .allowlist_function("_mm_setzero_si128")
             .allowlist_function("_mm_set_epi8")
             .allowlist_function("_mm_movemask_epi8")
@@ -153,6 +256,7 @@ fn main() {
             .allowlist_function("_mm_cmplt_epi16")
             .allowlist_function("_mm_subs_epu16")
             .allowlist_function("_mm_set1_epi32")
+            .allowlist_function("_mm_set1_epi16")
             .blocklist_type("__m128i")
             .blocklist_type("int64x2_t")
             .wrap_static_fns(true)
@@ -164,20 +268,45 @@ fn main() {
             .write_to_file(out_path.join("simd_bindings.rs"))
             .expect("Couldn't write bindings!");
 
-        simd_build.flag("-DSSE2NEON_SUPPRESS_WARNINGS");
-        simd_build.file("src/compat/aarch64.c");
-        simd_build.file(std::env::temp_dir().join("bindgen").join("extern.c"));
-        simd_build.include(".");
-        simd_build.compile("simd");
+        simd_build
+            .std("c17")
+            .flag("-D_POSIX_C_SOURCE=200112L")
+            .flag("-DSSE2NEON_SUPPRESS_WARNINGS")
+            .file("src/compat/aarch64.c")
+            .file(std::env::temp_dir().join("bindgen").join("extern.c"))
+            .include(".")
+            .compile("simd");
     }
 
-    let git_output = std::process::Command::new("git")
-        .args(["rev-parse", "HEAD"])
-        .output()
-        .unwrap();
+    let mut git_output = std::process::Command::new("git");
+    git_output.args(["describe", "--dirty"]);
 
-    let git_hash = String::from_utf8(git_output.stdout).unwrap();
-    println!("cargo:rustc-env=GIT_HASH={git_hash}");
+    let git_describe = if let Ok(git_output) = git_output.output()
+        && git_output.status.success()
+    {
+        String::from_utf8(git_output.stdout).unwrap()
+    } else if let Ok(git_output) = git_output.args(["--always"]).output()
+        && git_output.status.success()
+    {
+        format!(
+            "v{}-{}",
+            env!("CARGO_PKG_VERSION"),
+            String::from_utf8(git_output.stdout).unwrap()
+        )
+    } else {
+        panic!("Failed to get git describe");
+    };
+    println!("cargo:rustc-env=GIT_DESCRIBE={git_describe}");
 
-    println!("cargo:rustc-env=N64_STACK_SIZE={}", 8 * 1024 * 1024);
+    println!("cargo:rerun-if-env-changed=NETPLAY_ID");
+    let netplay_id = std::env::var("NETPLAY_ID").unwrap_or("gopher64".to_string());
+    println!("cargo:rustc-env=NETPLAY_ID={netplay_id}");
+
+    println!("cargo:rerun-if-env-changed=RA_HARDCORE");
+    println!("cargo:rustc-check-cfg=cfg(ra_hardcore_enabled)");
+    if let Ok(ra_hardcore) = std::env::var("RA_HARDCORE")
+        && ra_hardcore.to_lowercase() == "true"
+    {
+        println!("cargo:rustc-cfg=ra_hardcore_enabled");
+    }
 }

data/icon/generate.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+magick gopher64.png -resize 512x512 gopher64_512x512.png
+magick gopher64.png -resize 256x256 gopher64_256x256.png
+magick gopher64.png -resize 128x128 gopher64_128x128.png
+magick gopher64.png -resize 256x256 icon.ico

data/macos/entitlements_child.plist

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>com.apple.security.app-sandbox</key>
+	<true/>
+	<key>com.apple.security.inherit</key>
+	<true/>
+</dict>
+</plist>

data/macos/entitlements_dev.plist

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>com.apple.security.cs.disable-library-validation</key>
+	<true/>
+</dict>
+</plist>

data/macos/entitlements_prod.plist

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>com.apple.security.app-sandbox</key>
+	<true/>
+	<key>com.apple.security.network.client</key>
+	<true/>
+	<key>com.apple.security.network.server</key>
+	<true/>
+	<key>com.apple.security.device.usb</key>
+	<true/>
+	<key>com.apple.security.device.bluetooth</key>
+	<true/>
+	<key>com.apple.security.files.user-selected.read-write</key>
+	<true/>
+</dict>
+</plist>

parallel-rdp/interface.hpp

@@ -4,47 +4,77 @@
 #include <cstdint>
 #include <stddef.h>
 
-extern "C"
-{
+extern "C" {
 #endif
 
-	typedef struct
-	{
-		uint8_t *RDRAM;
-		uint8_t *DMEM;
-		uint32_t RDRAM_SIZE;
-		uint32_t *DPC_CURRENT_REG;
-		uint32_t *DPC_START_REG;
-		uint32_t *DPC_END_REG;
-		uint32_t *DPC_STATUS_REG;
-		bool PAL;
-		bool widescreen;
-		bool fullscreen;
-		bool integer_scaling;
-		uint32_t upscale;
-		bool crt;
-	} GFX_INFO;
+typedef struct {
+  uint8_t *RDRAM;
+  uint8_t *DMEM;
+  uint32_t RDRAM_SIZE;
+  uint32_t *DPC_CURRENT_REG;
+  uint32_t *DPC_START_REG;
+  uint32_t *DPC_END_REG;
+  uint32_t *DPC_STATUS_REG;
+  bool PAL;
+  bool widescreen;
+  bool fullscreen;
+  bool vsync;
+  bool integer_scaling;
+  uint32_t upscale;
+  bool ssaa;
+  bool crt;
+} GFX_INFO;
 
-	typedef struct
-	{
-		bool emu_running;
-		bool save_state;
-		bool load_state;
-		bool enable_speedlimiter;
-		bool lower_volume;
-		bool raise_volume;
-	} CALL_BACK;
+typedef struct {
+  bool emu_running;
+  bool save_state;
+  bool load_state;
+  bool reset_game;
+  bool enable_speedlimiter;
+  bool lower_volume;
+  bool raise_volume;
+  bool paused;
+  bool frame_advance;
+  uint32_t save_state_slot;
+} CALL_BACK;
 
-	void rdp_init(void *_window, GFX_INFO _gfx_info);
-	void rdp_close();
-	void rdp_set_vi_register(uint32_t reg, uint32_t value);
-	void rdp_update_screen();
-	CALL_BACK rdp_check_callback();
-	uint64_t rdp_process_commands();
-	void rdp_new_processor(GFX_INFO _gfx_info);
-	size_t rdp_state_size();
-	void rdp_save_state(uint8_t *state);
-	void rdp_load_state(const uint8_t *state);
+typedef struct {
+  uint32_t joystick_id;
+  bool connected;
+} JoystickEvent;
+
+typedef enum {
+  MESSAGE_VERY_SHORT = 500,
+  MESSAGE_SHORT = 3000,
+  MESSAGE_LONG = 6000,
+} MESSAGE_LENGTH;
+
+void rdp_init(void *_window, GFX_INFO _gfx_info, const void *font,
+              size_t font_size, uint32_t save_state_slot);
+void rdp_close();
+void rdp_set_vi_register(uint32_t reg, uint32_t value);
+void rdp_update_screen();
+void rdp_render_frame();
+CALL_BACK rdp_check_callback();
+uint64_t rdp_process_commands();
+void rdp_onscreen_message(const char *message, MESSAGE_LENGTH milliseconds);
+void rdp_new_processor(GFX_INFO _gfx_info);
+void rdp_check_framebuffers(uint32_t address, uint32_t length);
+size_t rdp_state_size();
+void rdp_save_state(uint8_t *state);
+void rdp_load_state(const uint8_t *state);
+void rdp_set_fps(uint32_t fps, uint32_t vis);
+
+JoystickEvent get_joystick_event();
+
+void achievement_challenge_indicator_add(const char *achievement_title);
+void achievement_challenge_indicator_remove(const char *achievement_title);
+void achievement_progress_add(const char *achievement_title,
+                              const char *progress);
+void achievement_progress_remove();
+void leaderboard_tracker_add(uint32_t id, const char *title,
+                             const char *display);
+void leaderboard_tracker_remove(uint32_t id);
 
 #ifdef __cplusplus
 }

parallel-rdp/wsi_platform.cpp

@@ -1,73 +1,55 @@
 #include "wsi_platform.hpp"
 #include <SDL3/SDL_vulkan.h>
 
-VkSurfaceKHR SDL_WSIPlatform::create_surface(VkInstance instance, VkPhysicalDevice gpu)
-{
-	VkSurfaceKHR surface = nullptr;
-	bool result = SDL_Vulkan_CreateSurface(window, instance, NULL, &surface);
-	if (result != true)
-	{
-		printf("Error creating surface\n");
-	}
-	return surface;
+VkSurfaceKHR SDL_WSIPlatform::create_surface(VkInstance instance,
+                                             VkPhysicalDevice gpu) {
+  VkSurfaceKHR surface = nullptr;
+  bool result = SDL_Vulkan_CreateSurface(window, instance, NULL, &surface);
+  if (result != true) {
+    printf("Error creating surface\n");
+  }
+  return surface;
 }
 
-void SDL_WSIPlatform::destroy_surface(VkInstance instance, VkSurfaceKHR surface)
-{
-	SDL_Vulkan_DestroySurface(instance, surface, NULL);
+void SDL_WSIPlatform::destroy_surface(VkInstance instance,
+                                      VkSurfaceKHR surface) {
+  SDL_Vulkan_DestroySurface(instance, surface, NULL);
 }
 
-std::vector<const char *> SDL_WSIPlatform::get_instance_extensions()
-{
+std::vector<const char *> SDL_WSIPlatform::get_instance_extensions() {
 
-	unsigned int extensionCount = 0;
-	char const *const *extensions = SDL_Vulkan_GetInstanceExtensions(&extensionCount);
-	if (extensions == NULL)
-	{
-		printf("Error getting instance extensions\n");
-	}
+  unsigned int extensionCount = 0;
+  char const *const *extensions =
+      SDL_Vulkan_GetInstanceExtensions(&extensionCount);
+  if (extensions == NULL) {
+    printf("Error getting instance extensions\n");
+  }
 
-	std::vector<const char *> extensionNames;
-	for (unsigned int i = 0; i < extensionCount; ++i)
-	{
-		extensionNames.push_back(extensions[i]);
-	}
-	return extensionNames;
+  std::vector<const char *> extensionNames;
+  for (unsigned int i = 0; i < extensionCount; ++i) {
+    extensionNames.push_back(extensions[i]);
+  }
+  return extensionNames;
 }
 
-uint32_t SDL_WSIPlatform::get_surface_width()
-{
-	int w, h;
-	SDL_GetWindowSize(window, &w, &h);
-	return w;
+uint32_t SDL_WSIPlatform::get_surface_width() {
+  int w, h;
+  SDL_GetWindowSize(window, &w, &h);
+  return w;
 }
 
-uint32_t SDL_WSIPlatform::get_surface_height()
-{
-	int w, h;
-	SDL_GetWindowSize(window, &w, &h);
-	return h;
+uint32_t SDL_WSIPlatform::get_surface_height() {
+  int w, h;
+  SDL_GetWindowSize(window, &w, &h);
+  return h;
 }
 
-bool SDL_WSIPlatform::alive(Vulkan::WSI &wsi)
-{
-	return true;
-}
+bool SDL_WSIPlatform::alive(Vulkan::WSI &wsi) { return true; }
 
-void SDL_WSIPlatform::poll_input()
-{
-}
+void SDL_WSIPlatform::poll_input() {}
 
-void SDL_WSIPlatform::poll_input_async(Granite::InputTrackerHandler *handler)
-{
-}
+void SDL_WSIPlatform::poll_input_async(Granite::InputTrackerHandler *handler) {}
 
-void SDL_WSIPlatform::set_window(SDL_Window *_window)
-{
-	window = _window;
-}
+void SDL_WSIPlatform::set_window(SDL_Window *_window) { window = _window; }
 
-void SDL_WSIPlatform::do_resize()
-{
-	resize = true;
-}
+void SDL_WSIPlatform::do_resize() { resize = true; }

parallel-rdp/wsi_platform.hpp

@@ -3,20 +3,20 @@
 #include "wsi.hpp"
 #include <SDL3/SDL.h>
 
-class SDL_WSIPlatform : public Vulkan::WSIPlatform
-{
+class SDL_WSIPlatform : public Vulkan::WSIPlatform {
 public:
-	VkSurfaceKHR create_surface(VkInstance instance, VkPhysicalDevice gpu) override;
-	void destroy_surface(VkInstance instance, VkSurfaceKHR surface) override;
-	std::vector<const char *> get_instance_extensions() override;
-	uint32_t get_surface_width() override;
-	uint32_t get_surface_height() override;
-	bool alive(Vulkan::WSI &wsi) override;
-	void poll_input() override;
-	void poll_input_async(Granite::InputTrackerHandler *handler) override;
-	void set_window(SDL_Window *_window);
-	void do_resize();
+  VkSurfaceKHR create_surface(VkInstance instance,
+                              VkPhysicalDevice gpu) override;
+  void destroy_surface(VkInstance instance, VkSurfaceKHR surface) override;
+  std::vector<const char *> get_instance_extensions() override;
+  uint32_t get_surface_width() override;
+  uint32_t get_surface_height() override;
+  bool alive(Vulkan::WSI &wsi) override;
+  void poll_input() override;
+  void poll_input_async(Granite::InputTrackerHandler *handler) override;
+  void set_window(SDL_Window *_window);
+  void do_resize();
 
 private:
-	SDL_Window *window;
+  SDL_Window *window;
 };

retroachievements/retroachievements.c

@@ -0,0 +1,399 @@
+#include "retroachievements.h"
+#include "../parallel-rdp/interface.hpp"
+#include <rc_client.h>
+#include <rc_consoles.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+void rust_server_call(const char *url, const char *post_data,
+                      const char *content_type,
+                      rc_client_server_callback_t callback,
+                      void *callback_data);
+void store_retroachievements_credentials(const char *username,
+                                         const char *token, void *userdata);
+
+void notify_load_game(void *userdata);
+
+static rc_client_t *g_client = NULL;
+static const uint8_t *g_dmem = NULL;
+static size_t g_dmem_size = 0;
+static bool g_challenge = false;
+static bool g_leaderboard = false;
+static rc_client_leaderboard_list_t *g_leaderboard_list = NULL;
+
+static uint32_t read_memory(uint32_t address, uint8_t *buffer,
+                            uint32_t num_bytes, rc_client_t *client) {
+  if (address + num_bytes > g_dmem_size)
+    memset(buffer, 0, num_bytes);
+  else
+    memcpy(buffer, &g_dmem[address], num_bytes);
+  return num_bytes;
+}
+
+static void server_call(const rc_api_request_t *request,
+                        rc_client_server_callback_t callback,
+                        void *callback_data, rc_client_t *client) {
+  rust_server_call(request->url, request->post_data, request->content_type,
+                   callback, callback_data);
+}
+
+void ra_http_callback(const char *content, size_t content_size, int status_code,
+                      void *callback, void *callback_data) {
+  // Prepare a data object to pass the HTTP response to the callback
+  rc_api_server_response_t server_response;
+  memset(&server_response, 0, sizeof(server_response));
+  server_response.body = content;
+  server_response.body_length = content_size;
+  server_response.http_status_code = status_code;
+
+  // handle non-http errors (socket timeout, no internet available, etc)
+  if (status_code == 0) {
+    // Let rc_client know the error was not catastrophic and could be retried.
+    // It may decide to retry or just immediately pass the error to the
+    // callback. To prevent possible retries, use
+    // RC_API_SERVER_RESPONSE_CLIENT_ERROR.
+    server_response.http_status_code =
+        RC_API_SERVER_RESPONSE_RETRYABLE_CLIENT_ERROR;
+  }
+
+  ((rc_client_server_callback_t)callback)(&server_response, callback_data);
+}
+
+static void log_message(const char *message, const rc_client_t *client) {
+  printf("RetroAchievements: %s\n", message);
+}
+
+static void login_callback(int result, const char *error_message,
+                           rc_client_t *client, void *userdata) {
+  // If not successful, just report the error and bail.
+  if (result != RC_OK) {
+    if (client && !rc_client_get_userdata(client))
+      rc_client_set_userdata(client, strdup(error_message));
+    store_retroachievements_credentials(NULL, NULL, userdata);
+    return;
+  }
+
+  // Login was successful. Capture the token for future logins so we don't have
+  // to store the password anywhere.
+  const rc_client_user_t *user = rc_client_get_user_info(client);
+  store_retroachievements_credentials(user->username, user->token, userdata);
+}
+
+const char *ra_get_username() {
+  const rc_client_user_t *user = rc_client_get_user_info(g_client);
+  return user ? user->username : NULL;
+}
+const char *ra_get_token() {
+  const rc_client_user_t *user = rc_client_get_user_info(g_client);
+  return user ? user->token : NULL;
+}
+
+void ra_logout_user() { rc_client_logout(g_client); }
+
+void ra_login_user(const char *username, const char *password, void *userdata) {
+  // This will generate an HTTP payload and call the server_call chain above.
+  // Eventually, login_callback will be called to let us know if the login was
+  // successful.
+  rc_client_begin_login_with_password(g_client, username, password,
+                                      login_callback, userdata);
+}
+
+void ra_login_token_user(const char *username, const char *token,
+                         void *userdata) {
+  // This is exactly the same functionality as
+  // rc_client_begin_login_with_password, but uses the token captured from the
+  // first login instead of a password. Note that it uses the same callback.
+  rc_client_begin_login_with_token(g_client, username, token, login_callback,
+                                   userdata);
+}
+
+static void load_game_callback(int result, const char *error_message,
+                               rc_client_t *client, void *userdata) {
+  if (result != RC_OK) {
+    if (client && !rc_client_get_userdata(client))
+      rc_client_set_userdata(client, strdup(error_message));
+    rc_client_set_hardcore_enabled(client, false);
+    notify_load_game(userdata);
+    return;
+  }
+
+  if (!rc_client_is_processing_required(client)) {
+    rc_client_set_hardcore_enabled(client, false);
+  }
+
+  g_leaderboard_list = rc_client_create_leaderboard_list(
+      client, RC_CLIENT_LEADERBOARD_LIST_GROUPING_NONE);
+
+  notify_load_game(userdata);
+}
+
+void ra_welcome() {
+  if (!g_client)
+    return;
+
+  char buffer[512];
+
+  char *error_message = rc_client_get_userdata(g_client);
+  if (error_message) {
+    snprintf(buffer, sizeof(buffer), "RA Error: %s", error_message);
+    rdp_onscreen_message(buffer, MESSAGE_LONG);
+    free(error_message);
+    rc_client_set_userdata(g_client, NULL);
+    return;
+  }
+
+  const rc_client_game_t *game = rc_client_get_game_info(g_client);
+
+  rc_client_user_game_summary_t summary;
+  rc_client_get_user_game_summary(g_client, &summary);
+
+  int message_length = snprintf(
+      buffer, sizeof(buffer), "%s\nMode: %s\n", game->title,
+      rc_client_get_hardcore_enabled(g_client) ? "Hardcore" : "Softcore");
+
+  if (summary.num_core_achievements != 0) {
+    snprintf(buffer + message_length, sizeof(buffer) - message_length,
+             "%u/%u achievements unlocked", summary.num_unlocked_achievements,
+             summary.num_core_achievements);
+  } else {
+    snprintf(buffer + message_length, sizeof(buffer) - message_length,
+             "Game has no achievements");
+  }
+  rdp_onscreen_message(buffer, MESSAGE_LONG);
+}
+
+void ra_load_game(const uint8_t *rom, size_t rom_size, void *userdata) {
+  rc_client_begin_identify_and_load_game(g_client, RC_CONSOLE_NINTENDO_64, NULL,
+                                         rom, rom_size, load_game_callback,
+                                         userdata);
+}
+
+void ra_unload_game() {
+  if (g_leaderboard_list) {
+    rc_client_destroy_leaderboard_list(g_leaderboard_list);
+    g_leaderboard_list = NULL;
+  }
+  rc_client_unload_game(g_client);
+}
+
+void ra_set_dmem(const uint8_t *dmem, size_t dmem_size) {
+  g_dmem = dmem;
+  g_dmem_size = dmem_size;
+}
+
+static void leaderboard_submitted(const rc_client_leaderboard_t *leaderboard) {
+  char buffer[512];
+
+  snprintf(buffer, sizeof(buffer), "Leaderboard submitted: %s - %s",
+           leaderboard->title, leaderboard->tracker_value);
+  rdp_onscreen_message(buffer, MESSAGE_SHORT);
+}
+
+static void achievement_triggered(const rc_client_achievement_t *achievement) {
+  char buffer[512];
+
+  snprintf(buffer, sizeof(buffer), "Unlocked: %s", achievement->title);
+  rdp_onscreen_message(buffer, MESSAGE_SHORT);
+}
+
+static void game_completed(rc_client_t *client) {
+  char buffer[512];
+  const rc_client_game_t *game = rc_client_get_game_info(client);
+
+  snprintf(buffer, sizeof(buffer), "%s: %s",
+           rc_client_get_hardcore_enabled(client) ? "Mastered" : "Completed",
+           game->title);
+  rdp_onscreen_message(buffer, MESSAGE_SHORT);
+}
+
+static void subset_completed(const rc_client_subset_t *subset,
+                             rc_client_t *client) {
+  char buffer[512];
+
+  snprintf(buffer, sizeof(buffer), "Subset %s: %s",
+           rc_client_get_hardcore_enabled(client) ? "mastered" : "completed",
+           subset->title);
+  rdp_onscreen_message(buffer, MESSAGE_SHORT);
+}
+
+static void server_error(const rc_client_server_error_t *server_error) {
+  char buffer[512];
+
+  snprintf(buffer, sizeof(buffer), "RA server error: %s",
+           server_error->error_message);
+  rdp_onscreen_message(buffer, MESSAGE_SHORT);
+}
+
+static const char *get_leaderboard_title(const char *display) {
+  if (g_leaderboard_list == NULL)
+    return NULL;
+
+  for (uint32_t i = 0; i < g_leaderboard_list->num_buckets; i++) {
+    for (uint32_t j = 0; j < g_leaderboard_list->buckets[i].num_leaderboards;
+         j++) {
+      // this looks like a mistake, but it is intentional.
+      // Leaderboard trackers don't contain the title,
+      // but we take advantage of the fact that tracker_value and display point
+      // to the same char* to find a matching leaderboard.
+      if (g_leaderboard_list->buckets[i].leaderboards[j]->tracker_value ==
+          display) {
+        return g_leaderboard_list->buckets[i].leaderboards[j]->title;
+      }
+    }
+  }
+  return NULL;
+}
+
+static void event_handler(const rc_client_event_t *event, rc_client_t *client) {
+  switch (event->type) {
+  case RC_CLIENT_EVENT_ACHIEVEMENT_TRIGGERED:
+    achievement_triggered(event->achievement);
+    break;
+  case RC_CLIENT_EVENT_LEADERBOARD_STARTED:
+    break;
+  case RC_CLIENT_EVENT_LEADERBOARD_FAILED:
+    break;
+  case RC_CLIENT_EVENT_LEADERBOARD_SUBMITTED:
+    if (g_leaderboard)
+      leaderboard_submitted(event->leaderboard);
+    break;
+  case RC_CLIENT_EVENT_ACHIEVEMENT_CHALLENGE_INDICATOR_SHOW:
+    if (g_challenge)
+      achievement_challenge_indicator_add(event->achievement->title);
+    break;
+  case RC_CLIENT_EVENT_ACHIEVEMENT_CHALLENGE_INDICATOR_HIDE:
+    if (g_challenge)
+      achievement_challenge_indicator_remove(event->achievement->title);
+    break;
+  case RC_CLIENT_EVENT_ACHIEVEMENT_PROGRESS_INDICATOR_SHOW:
+    achievement_progress_add(event->achievement->title,
+                             event->achievement->measured_progress);
+    break;
+  case RC_CLIENT_EVENT_ACHIEVEMENT_PROGRESS_INDICATOR_HIDE:
+    achievement_progress_remove();
+    break;
+  case RC_CLIENT_EVENT_ACHIEVEMENT_PROGRESS_INDICATOR_UPDATE:
+    achievement_progress_add(event->achievement->title,
+                             event->achievement->measured_progress);
+    break;
+  case RC_CLIENT_EVENT_LEADERBOARD_TRACKER_SHOW:
+    if (g_leaderboard)
+      leaderboard_tracker_add(
+          event->leaderboard_tracker->id,
+          get_leaderboard_title(event->leaderboard_tracker->display),
+          event->leaderboard_tracker->display);
+    break;
+  case RC_CLIENT_EVENT_LEADERBOARD_TRACKER_HIDE:
+    if (g_leaderboard)
+      leaderboard_tracker_remove(event->leaderboard_tracker->id);
+    break;
+  case RC_CLIENT_EVENT_LEADERBOARD_TRACKER_UPDATE:
+    if (g_leaderboard)
+      leaderboard_tracker_add(
+          event->leaderboard_tracker->id,
+          get_leaderboard_title(event->leaderboard_tracker->display),
+          event->leaderboard_tracker->display);
+    break;
+  case RC_CLIENT_EVENT_LEADERBOARD_SCOREBOARD:
+    break;
+  case RC_CLIENT_EVENT_GAME_COMPLETED:
+    game_completed(client);
+    break;
+  case RC_CLIENT_EVENT_SUBSET_COMPLETED:
+    subset_completed(event->subset, client);
+    break;
+  case RC_CLIENT_EVENT_SERVER_ERROR:
+    server_error(event->server_error);
+    break;
+  default:
+    printf("RetroAchievements: Unhandled event %d\n", event->type);
+    break;
+  }
+}
+
+void ra_init_client(bool hardcore, bool challenge, bool leaderboard) {
+  // Create the client instance (using a global variable simplifies this
+  // example)
+  g_client = rc_client_create(read_memory, server_call);
+  g_dmem = NULL;
+  g_dmem_size = 0;
+
+  // Provide a logging function to simplify debugging
+  rc_client_enable_logging(g_client, RC_CLIENT_LOG_LEVEL_WARN, log_message);
+
+  rc_client_set_event_handler(g_client, event_handler);
+
+  rc_client_set_hardcore_enabled(g_client, hardcore);
+
+  g_challenge = challenge;
+  g_leaderboard = leaderboard;
+}
+
+bool ra_get_hardcore() { return rc_client_get_hardcore_enabled(g_client); }
+
+void ra_shutdown_client() {
+  if (g_client) {
+    // Release resources associated to the client instance
+    rc_client_destroy(g_client);
+    g_client = NULL;
+  }
+}
+
+void ra_do_frame() { rc_client_do_frame(g_client); }
+
+void ra_do_idle() { rc_client_idle(g_client); }
+
+size_t ra_state_size() { return rc_client_progress_size(g_client); }
+
+void ra_save_state(uint8_t *state, size_t state_size) {
+  if (!rc_client_is_game_loaded(g_client))
+    return;
+
+  if (rc_client_serialize_progress_sized(g_client, state, state_size) !=
+      RC_OK) {
+    printf("RetroAchievements: Failed to serialize progress\n");
+  }
+}
+
+void ra_load_state(const uint8_t *state, size_t state_size) {
+  if (!rc_client_is_game_loaded(g_client))
+    return;
+
+  if (rc_client_deserialize_progress_sized(g_client, state, state_size) !=
+      RC_OK) {
+    printf("RetroAchievements: Failed to deserialize progress\n");
+  }
+}
+
+void ra_display_inprogress_achievements(void *userdata) {
+  if (!rc_client_is_game_loaded(g_client))
+    return;
+
+  rc_client_achievement_list_t *list = rc_client_create_achievement_list(
+      g_client, RC_CLIENT_ACHIEVEMENT_CATEGORY_CORE,
+      RC_CLIENT_ACHIEVEMENT_LIST_GROUPING_LOCK_STATE);
+
+  char buffer[1024] = {0};
+  size_t buffer_length = 0;
+
+  for (uint32_t i = 0; i < list->num_buckets; i++) {
+    if (list->buckets[i].bucket_type == RC_CLIENT_ACHIEVEMENT_BUCKET_LOCKED) {
+      for (uint32_t j = 0; j < list->buckets[i].num_achievements; j++) {
+        const rc_client_achievement_t *achievement =
+            list->buckets[i].achievements[j];
+        if (achievement->measured_percent > 0.0f) {
+          if (buffer_length < sizeof(buffer) - 1) {
+            buffer_length += snprintf(
+                buffer + buffer_length, sizeof(buffer) - buffer_length,
+                "%s: %s\n", achievement->title, achievement->measured_progress);
+          }
+        }
+      }
+    }
+  }
+  if (buffer_length > 0) {
+    rdp_onscreen_message(buffer, MESSAGE_SHORT);
+  }
+  rc_client_destroy_achievement_list(list);
+}

retroachievements/retroachievements.h

@@ -0,0 +1,32 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+void ra_init_client(bool hardcore, bool challenge, bool leaderboard);
+void ra_shutdown_client();
+void ra_welcome();
+bool ra_get_hardcore();
+void ra_load_game(const uint8_t *rom, size_t rom_size, void *userdata);
+void ra_unload_game();
+void ra_set_dmem(const uint8_t *dmem, size_t dmem_size);
+void ra_do_frame();
+void ra_do_idle();
+void ra_http_callback(const char *content, size_t content_size, int status_code,
+                      void *callback, void *callback_data);
+void ra_logout_user();
+void ra_login_user(const char *username, const char *password, void *userdata);
+void ra_login_token_user(const char *username, const char *token,
+                         void *userdata);
+const char *ra_get_username();
+const char *ra_get_token();
+size_t ra_state_size();
+void ra_save_state(uint8_t *state, size_t state_size);
+void ra_load_state(const uint8_t *state, size_t state_size);
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+void ra_display_inprogress_achievements(void *userdata);
+#ifdef __cplusplus
+}
+#endif

rust-toolchain.toml

@@ -1,2 +1,2 @@
 [toolchain]
-channel = "1.88.0"
+channel = "1.95.0"

src/cheats.rs

@@ -15,16 +15,24 @@ pub struct Cheats {
     pub enabled: bool,
 }
 
+#[derive(serde::Serialize, serde::Deserialize, Clone)]
+pub struct CheatData {
+    pub note: String,
+    pub data: Vec<String>,
+    pub options: Option<std::collections::BTreeMap<String, String>>,
+}
+
+pub type Cheat = std::collections::BTreeMap<String, std::collections::BTreeMap<String, CheatData>>;
+
 pub fn init(
     device: &mut device::Device,
     cheat_settings: std::collections::HashMap<String, Option<String>>,
 ) {
-    let cheats =
-        serde_json::from_slice::<ui::cheats::Cheats>(include_bytes!("../data/cheats.json"))
-            .unwrap()
-            .get(&ui::storage::get_game_crc(&device.cart.rom))
-            .cloned()
-            .unwrap_or_default();
+    let cheats = serde_json::from_slice::<Cheat>(include_bytes!("../data/cheats.json"))
+        .unwrap()
+        .get(&ui::storage::get_game_crc(&device.cart.rom))
+        .cloned()
+        .unwrap_or_default();
 
     let re = regex::Regex::new(r"\?+").unwrap();
     for cheat_setting in cheat_settings.iter() {
@@ -40,7 +48,8 @@ pub fn init(
                 {
                     option_value = Some(found_option_value.to_string());
                 } else {
-                    panic!("Cheat option: {option} not found");
+                    eprintln!("Cheat option: {option} not found");
+                    continue;
                 }
             }
 
@@ -57,21 +66,27 @@ pub fn init(
                 }
                 let mut split = result.split_whitespace();
                 let first_part = u32::from_str_radix(split.next().unwrap(), 16).unwrap();
-                decoded_cheat.push(DecodedCheat {
-                    code_type: (first_part >> 24) as u8,
-                    address: first_part & 0x00FFFFFF,
-                    data: u16::from_str_radix(split.next().unwrap(), 16).unwrap(),
-                });
+                if let Ok(data) = u16::from_str_radix(split.next().unwrap(), 16) {
+                    decoded_cheat.push(DecodedCheat {
+                        code_type: (first_part >> 24) as u8,
+                        address: first_part & 0x00FFFFFF,
+                        data,
+                    })
+                } else {
+                    eprintln!("Could not parse data for: {}", cheat_setting.0);
+                };
+            }
+            if !decoded_cheat.is_empty() {
+                device.cheats.cheats.push(decoded_cheat);
             }
-            device.cheats.cheats.push(decoded_cheat);
         } else {
-            println!("Could not find cheat: {}", cheat_setting.0);
+            eprintln!("Could not find cheat: {}", cheat_setting.0);
         }
     }
 
     if !device.cheats.cheats.is_empty() {
         device.cheats.enabled = true;
-        ui::audio::play_cheat_event(&device.ui);
+        ui::video::onscreen_message("Cheats enabled", ui::video::MESSAGE_LENGTH_MESSAGE_SHORT);
     }
 }
 

src/compat/aarch64.c

@@ -1,4 +1,4 @@
-#include "src/compat/sse2neon/v1.8.0/sse2neon.h"
+#include "src/compat/sse2neon/sse2neon.h"
 
 // Static wrappers
 

src/device.rs

@@ -10,9 +10,9 @@ include!(concat!(env!("OUT_DIR"), "/simd_bindings.rs"));
 #[cfg(target_arch = "x86_64")]
 use std::arch::x86_64::*;
 
-use rand_chacha::rand_core::{RngCore, SeedableRng};
+use rand::{Rng, SeedableRng};
 
-use crate::{cheats, netplay, ui};
+use crate::{cheats, netplay, retroachievements, ui};
 use std::{collections::HashMap, fs, io::Read};
 
 pub mod ai;
@@ -44,24 +44,30 @@ pub mod tlb;
 pub mod unmapped;
 pub mod vi;
 
-pub fn run_game(device: &mut Device, rom_contents: Vec<u8>, game_settings: ui::gui::GameSettings) {
-    device.ui.video.fullscreen = game_settings.fullscreen;
+pub fn run_game(device: &mut Device, rom_contents: &[u8], game_settings: ui::GameSettings) {
     device.cpu.overclock = game_settings.overclock;
     if game_settings.disable_expansion_pak {
         device.rdram.size = 0x400000;
     }
+    if let Some(slot) = game_settings.load_savestate_slot {
+        device.ui.storage.save_state_slot = slot;
+        device.load_state = true;
+    }
 
     init_rng(device);
 
     cart::rom::init(device, rom_contents); // cart needs to come before rdram
 
-    // rdram pointer is shared with parallel-rdp
+    // rdram pointer is shared with parallel-rdp and retroachievements
     rdram::init(device);
 
     ui::video::init(device);
-    ui::audio::init(&mut device.ui, device.ai.freq);
+    ui::audio::init(device);
     ui::input::init(&mut device.ui);
 
+    // must be after video init
+    retroachievements::welcome();
+
     mi::init(device);
     pif::init(device);
     if device.ui.config.input.emulate_vru && device.netplay.is_none() {
@@ -76,32 +82,36 @@ pub fn run_game(device: &mut Device, rom_contents: Vec<u8>, game_settings: ui::g
 
     ui::storage::init(&mut device.ui, &device.cart.rom);
     ui::storage::load_saves(&mut device.ui, &mut device.netplay);
+    ui::storage::format_saves(device);
 
-    cheats::init(device, game_settings.cheats);
+    if !retroachievements::get_hardcore() {
+        cheats::init(device, game_settings.cheats);
+    }
 
     cpu::run(device);
 
+    retroachievements::unload_game();
+
     ui::storage::write_saves(device);
     ui::input::close(&mut device.ui);
     ui::audio::close(&mut device.ui);
     ui::video::close(&device.ui);
 }
 
-fn set_rng() -> rand_chacha::ChaCha8Rng {
-    rand_chacha::ChaCha8Rng::from_os_rng()
+fn set_rng() -> rand::rngs::Xoshiro256PlusPlus {
+    rand::rngs::Xoshiro256PlusPlus::try_from_rng(&mut rand::rngs::SysRng).unwrap()
 }
 
 fn init_rng(device: &mut Device) {
     let mut rng_seed = set_rng().next_u64();
-    if device.netplay.is_some() {
-        let netplay = device.netplay.as_mut().unwrap();
+    if let Some(netplay) = &mut device.netplay {
         if netplay.player_number == 0 {
             netplay::send_rng(netplay, rng_seed);
         } else {
             rng_seed = netplay::receive_rng(netplay);
         }
     }
-    device.rng = rand_chacha::ChaCha8Rng::seed_from_u64(rng_seed);
+    device.rng = rand::rngs::Xoshiro256PlusPlus::seed_from_u64(rng_seed);
 }
 
 fn swap_rom(contents: Vec<u8>) -> Option<Vec<u8>> {
@@ -132,7 +142,11 @@ fn swap_rom(contents: Vec<u8>) -> Option<Vec<u8>> {
 
 pub fn get_rom_contents(file_path: &std::path::Path) -> Option<Vec<u8>> {
     let mut contents = vec![];
-    if file_path.extension().unwrap().eq_ignore_ascii_case("zip") {
+    if file_path
+        .extension()
+        .unwrap_or_default()
+        .eq_ignore_ascii_case("zip")
+    {
         let zip_file = fs::File::open(file_path).unwrap();
         let mut archive = zip::ZipArchive::new(zip_file).unwrap();
         for i in 0..archive.len() {
@@ -149,7 +163,11 @@ pub fn get_rom_contents(file_path: &std::path::Path) -> Option<Vec<u8>> {
                 break;
             }
         }
-    } else if file_path.extension().unwrap().eq_ignore_ascii_case("7z") {
+    } else if file_path
+        .extension()
+        .unwrap_or_default()
+        .eq_ignore_ascii_case("7z")
+    {
         let mut archive =
             sevenz_rust2::ArchiveReader::open(file_path, sevenz_rust2::Password::empty()).unwrap();
 
@@ -174,7 +192,8 @@ pub fn get_rom_contents(file_path: &std::path::Path) -> Option<Vec<u8>> {
             )
             .expect("ok");
     } else {
-        contents = fs::read(file_path).expect("Should have been able to read the file");
+        contents = fs::read(file_path)
+            .unwrap_or_else(|_| panic!("Could not read ROM file: {}", file_path.display()));
     }
 
     if contents.is_empty() {
@@ -188,7 +207,7 @@ pub fn get_rom_contents(file_path: &std::path::Path) -> Option<Vec<u8>> {
 pub struct Device {
     #[serde(skip)]
     pub netplay: Option<netplay::Netplay>,
-    #[serde(skip, default = "ui::Ui::default")]
+    #[serde(skip, default = "ui::Ui::new")]
     pub ui: ui::Ui,
     pub byte_swap: usize,
     pub save_state: bool,
@@ -207,9 +226,8 @@ pub struct Device {
     pub si: si::Si,
     pub ri: ri::Ri,
     #[serde(skip, default = "set_rng")]
-    pub rng: rand_chacha::ChaCha8Rng,
+    pub rng: rand::rngs::Xoshiro256PlusPlus,
     pub vru: controller::vru::Vru,
-    pub vru_window: controller::vru::VruWindow,
     pub transferpaks: [controller::transferpak::TransferPak; 4],
     pub cheats: cheats::Cheats,
 }
@@ -239,7 +257,6 @@ impl Device {
                     reg_write_masks: [0; cop0::COP0_REGS_COUNT as usize],
                     reg_latch: 0,
                     is_event: false,
-                    pending_compare_interrupt: false,
                     instrs: [cop0::reserved; 32],
                     instrs2: [cop0::reserved; 32],
                     tlb_lut_w: vec![
@@ -347,6 +364,7 @@ impl Device {
                     sector: 0,
                     buffer: vec![0; 8192],
                     writeback_sector: vec![0; 256],
+                    usb_buffer: vec![],
                 },
                 flashram: cart::sram::Flashram {
                     status: 0,
@@ -473,19 +491,13 @@ impl Device {
                 delay: 0,
                 count_per_scanline: 0,
                 enable_speed_limiter: true,
-                limiter: None,
+                next_pace_deadline: None,
                 vi_counter: 0,
-                last_origin: 0,
-                internal_frame_counter: 0,
                 min_wait_time: std::time::Duration::from_secs(1),
                 frame_time: 0.0,
                 limit_freq: 2,
                 limit_freq_check: std::time::Instant::now(),
             },
-            vru_window: controller::vru::VruWindow {
-                window_notifier: None,
-                word_receiver: None,
-            },
             vru: controller::vru::Vru {
                 status: 0,
                 voice_state: 0,

src/device/ai.rs

@@ -3,12 +3,12 @@ use crate::{device, ui};
 const AI_DRAM_ADDR_REG: u32 = 0;
 const AI_LEN_REG: u32 = 1;
 // const AI_CONTROL_REG: u32 = 2;
-const AI_STATUS_REG: u32 = 3;
+pub const AI_STATUS_REG: u32 = 3;
 const AI_DACRATE_REG: u32 = 4;
 // const AI_BITRATE_REG: u32 = 5;
 pub const AI_REGS_COUNT: u32 = 6;
 
-const AI_STATUS_BUSY: u32 = 0x40000000;
+pub const AI_STATUS_BUSY: u32 = 0x40000000;
 const AI_STATUS_FULL: u32 = 0x80000000;
 
 #[derive(serde::Serialize, serde::Deserialize)]
@@ -45,11 +45,10 @@ fn get_remaining_dma_length(device: &device::Device) -> u64 {
 }
 
 fn get_dma_duration(device: &device::Device) -> u64 {
-    let samples_per_sec = device.vi.clock / (1 + device.ai.regs[AI_DACRATE_REG as usize]) as u64;
     let bytes_per_sample = 4; /* XXX: assume 16bit stereo - should depends on bitrate instead */
     let length = (device.ai.regs[AI_LEN_REG as usize] & !7) as u64;
 
-    length * (device.cpu.clock_rate / (bytes_per_sample * samples_per_sec))
+    (length * device.cpu.clock_rate) / (bytes_per_sample * device.ai.freq)
 }
 
 fn do_dma(device: &mut device::Device) {
@@ -88,6 +87,7 @@ fn fifo_push(device: &mut device::Device) {
         device.ai.regs[AI_STATUS_REG as usize] |= AI_STATUS_BUSY;
 
         do_dma(device);
+        ui::audio::resume_game_audio(&mut device.ui);
     }
 }
 
@@ -102,6 +102,7 @@ fn fifo_pop(device: &mut device::Device) {
     } else {
         device.ai.regs[AI_STATUS_REG as usize] &= !AI_STATUS_BUSY;
         device.ai.delayed_carry = false;
+        ui::audio::pause_game_audio(&mut device.ui);
     }
 }
 
@@ -147,7 +148,7 @@ pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u
             if device.ai.regs[reg as usize] != value & mask {
                 device.ai.freq = device.vi.clock / (1 + (value & mask)) as u64;
                 ui::audio::close_game_audio(&mut device.ui);
-                ui::audio::init_game_audio(&mut device.ui, device.ai.freq)
+                ui::audio::init_game_audio(device)
             }
             device::memory::masked_write_32(&mut device.ai.regs[reg as usize], value, mask)
         }

src/device/cart.rs

@@ -21,16 +21,6 @@ const JDT_EEPROM_16K: u16 = 0xc000; /* 16k EEPROM */
 const EEPROM_BLOCK_SIZE: usize = 8;
 pub const EEPROM_MAX_SIZE: usize = 0x800;
 
-#[derive(serde::Serialize, serde::Deserialize)]
-pub enum CicType {
-    CicNus6101,
-    CicNus6102,
-    CicNus6103,
-    CicNus6105,
-    CicNus6106,
-    CicNus5167,
-}
-
 #[derive(serde::Serialize, serde::Deserialize)]
 pub struct AfRtc {
     pub control: u16,
@@ -140,8 +130,6 @@ pub fn format_eeprom(device: &mut device::Device) {
 fn eeprom_read_block(device: &mut device::Device, block: usize, offset: usize) {
     let address = device.pif.ram[block] as usize * EEPROM_BLOCK_SIZE;
 
-    format_eeprom(device);
-
     device.pif.ram[offset..offset + EEPROM_BLOCK_SIZE].copy_from_slice(
         &device.ui.storage.saves.eeprom.data[address..address + EEPROM_BLOCK_SIZE],
     );
@@ -150,14 +138,12 @@ fn eeprom_read_block(device: &mut device::Device, block: usize, offset: usize) {
 fn eeprom_write_block(device: &mut device::Device, block: usize, offset: usize, status: usize) {
     let address = device.pif.ram[block] as usize * EEPROM_BLOCK_SIZE;
 
-    format_eeprom(device);
-
     device.ui.storage.saves.eeprom.data[address..address + EEPROM_BLOCK_SIZE]
         .copy_from_slice(&device.pif.ram[offset..offset + EEPROM_BLOCK_SIZE]);
 
     device.pif.ram[status] = 0x00;
 
-    device.ui.storage.saves.eeprom.written = true
+    ui::storage::schedule_save(device, ui::storage::SaveTypes::Eeprom4k);
 }
 
 fn time2data(device: &mut device::Device, offset: usize) {

src/device/cart/rom.rs

@@ -1,8 +1,9 @@
 use crate::device;
 use crate::netplay;
+use crate::ui;
 use sha2::{Digest, Sha256};
 
-const CART_MASK: usize = 0xFFFFFFF;
+pub const CART_MASK: usize = 0xFFFFFFF;
 
 fn read_cart_word(device: &device::Device, address: usize) -> u32 {
     let mut data: [u8; 4] = [0; 4];
@@ -50,9 +51,7 @@ pub fn read_mem(
 }
 
 pub fn write_mem(device: &mut device::Device, address: u64, value: u32, mask: u32) {
-    if device.cart.sc64.cfg[device::cart::sc64::SC64_ROM_WRITE_ENABLE as usize] != 0
-        && device.cart.sc64.cfg[device::cart::sc64::SC64_BOOTLOADER_SWITCH as usize] == 0
-    {
+    if device.cart.sc64.cfg[device::cart::sc64::SC64_ROM_WRITE_ENABLE as usize] != 0 {
         let masked_address = address as usize & CART_MASK;
         let mut data = read_cart_word(device, masked_address);
         device::memory::masked_write_32(&mut data, value, mask);
@@ -65,7 +64,7 @@ pub fn write_mem(device: &mut device::Device, address: u64, value: u32, mask: u3
                 .data
                 .insert((masked_address + i) as u32, *item);
         }
-        device.ui.storage.saves.romsave.written = true;
+        ui::storage::schedule_save(device, ui::storage::SaveTypes::Romsave);
     }
 
     device.cart.latch = value & mask;
@@ -82,9 +81,7 @@ pub fn dma_read(
     mut dram_addr: u32,
     length: u32,
 ) -> u64 {
-    if device.cart.sc64.cfg[device::cart::sc64::SC64_ROM_WRITE_ENABLE as usize] != 0
-        && device.cart.sc64.cfg[device::cart::sc64::SC64_BOOTLOADER_SWITCH as usize] == 0
-    {
+    if device.cart.sc64.cfg[device::cart::sc64::SC64_ROM_WRITE_ENABLE as usize] != 0 {
         dram_addr &= device::rdram::RDRAM_MASK as u32;
         cart_addr &= CART_MASK as u32;
 
@@ -98,7 +95,7 @@ pub fn dma_read(
                     .unwrap_or(&0),
             );
         }
-        device.ui.storage.saves.romsave.written = true;
+        ui::storage::schedule_save(device, ui::storage::SaveTypes::Romsave);
     }
 
     device::pi::calculate_cycles(device, 1, length)
@@ -136,11 +133,10 @@ pub fn dma_write(
     device::pi::calculate_cycles(device, 1, length)
 }
 
-pub fn init(device: &mut device::Device, rom_file: Vec<u8>) {
+pub fn init(device: &mut device::Device, rom_file: &[u8]) {
     let now: chrono::DateTime<chrono::Local> = chrono::Local::now();
     device.cart.rtc_timestamp = now.naive_local().and_utc().timestamp();
-    if device.netplay.is_some() {
-        let netplay = device.netplay.as_mut().unwrap();
+    if let Some(netplay) = &mut device.netplay {
         if netplay.player_number == 0 {
             netplay::send_rtc(netplay, device.cart.rtc_timestamp);
         } else {
@@ -150,7 +146,7 @@ pub fn init(device: &mut device::Device, rom_file: Vec<u8>) {
 
     device.cart.sc64.cfg[device::cart::sc64::SC64_BOOTLOADER_SWITCH as usize] = 1;
 
-    device.cart.rom = rom_file;
+    device.cart.rom = rom_file.to_vec();
     device.cart.pal = is_system_pal(device.cart.rom[0x3E]);
     set_cic(device);
 
@@ -193,7 +189,6 @@ fn set_cic(device: &mut device::Device) {
         "53C0088FB777870D0AF32F0251E964030E2E8B72E830C26042FD191169508C05" => {
             device.cart.cic_seed = 0xdd; // CicNus5167
             device.cart.sc64.cfg[device::cart::sc64::SC64_ROM_WRITE_ENABLE as usize] = 1;
-            device.cart.sc64.cfg[device::cart::sc64::SC64_BOOTLOADER_SWITCH as usize] = 0;
         }
         _ => {
             device.cart.cic_seed = 0x3F; // CicNus6102
@@ -205,5 +200,9 @@ fn set_cic(device: &mut device::Device) {
 pub fn calculate_hash(data: &[u8]) -> String {
     let mut hasher = Sha256::new();
     hasher.update(data);
-    format!("{:X}", hasher.finalize())
+    hasher
+        .finalize()
+        .iter()
+        .map(|b| format!("{:02X}", b))
+        .collect()
 }

src/device/cart/sc64.rs

@@ -28,6 +28,7 @@ pub struct Sc64 {
     pub cfg: [u32; SC64_CFG_COUNT as usize],
     pub sector: u32,
     pub writeback_sector: Vec<u32>,
+    pub usb_buffer: Vec<u8>,
 }
 
 fn format_sdcard(device: &mut device::Device) {
@@ -155,24 +156,26 @@ pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u
                         let mut i = 0;
 
                         while i < length {
-                            if offset + i < device.ui.storage.saves.sdcard.data.len() {
-                                let data = u32::from_be_bytes(
-                                    device.ui.storage.saves.sdcard.data
-                                        [(offset + i)..(offset + i + 4)]
-                                        .try_into()
-                                        .unwrap(),
-                                );
+                            let data = u32::from_be_bytes(
+                                device
+                                    .ui
+                                    .storage
+                                    .saves
+                                    .sdcard
+                                    .data
+                                    .get((offset + i)..(offset + i + 4))
+                                    .unwrap_or(&[0; 4])
+                                    .try_into()
+                                    .unwrap_or_default(),
+                            );
 
-                                device::memory::data_write(
-                                    device,
-                                    address + i as u64,
-                                    data,
-                                    0xFFFFFFFF,
-                                    false,
-                                );
-                            } else {
-                                panic!("sd card read out of bounds")
-                            }
+                            device::memory::data_write(
+                                device,
+                                address + i as u64,
+                                data,
+                                0xFFFFFFFF,
+                                false,
+                            );
                             i += 4;
                         }
                     }
@@ -187,25 +190,152 @@ pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u
                         let mut i = 0;
 
                         while i < length {
-                            if offset + i < device.ui.storage.saves.sdcard.data.len() {
-                                let data = device::memory::data_read(
-                                    device,
-                                    address + i as u64,
-                                    device::memory::AccessSize::Word,
-                                    false,
-                                )
-                                .to_be_bytes();
-                                device.ui.storage.saves.sdcard.data[(offset + i)..(offset + i + 4)]
-                                    .copy_from_slice(&data);
-                            } else {
-                                panic!("sd card write out of bounds")
-                            }
+                            let data = device::memory::data_read(
+                                device,
+                                address + i as u64,
+                                device::memory::AccessSize::Word,
+                                false,
+                            )
+                            .to_be_bytes();
+                            device
+                                .ui
+                                .storage
+                                .saves
+                                .sdcard
+                                .data
+                                .get_mut((offset + i)..(offset + i + 4))
+                                .unwrap_or(&mut [0; 4])
+                                .copy_from_slice(&data);
                             i += 4;
                         }
-                        device.ui.storage.saves.sdcard.written = true;
+                        ui::storage::schedule_save(device, ui::storage::SaveTypes::Sdcard);
+                    }
+                    'U' => {
+                        device.cart.sc64.regs[SC64_DATA0_REG as usize] = 0;
+                    }
+                    'u' => {
+                        // used to notify the game that there is data to read
+                        if let Some(cart_rx) = device.ui.usb.cart_rx.as_mut() {
+                            match cart_rx.try_recv() {
+                                Ok(data) => {
+                                    device.cart.sc64.regs[SC64_DATA0_REG as usize] =
+                                        data.data_type & 0xFF; // read_status/type
+                                    device.cart.sc64.regs[SC64_DATA1_REG as usize] =
+                                        data.data_size & 0xFFFFFF; // length
+                                    device.cart.sc64.usb_buffer = data.data; // store the data to be read
+                                }
+                                Err(err) => {
+                                    match err {
+                                        tokio::sync::broadcast::error::TryRecvError::Lagged(_) => {
+                                            panic!("cart_rx lagged: {err}");
+                                        }
+                                        _ => {
+                                            device.cart.sc64.regs[SC64_DATA0_REG as usize] = 0; // read_status/type
+                                            device.cart.sc64.regs[SC64_DATA1_REG as usize] = 0; // length
+                                        }
+                                    }
+                                }
+                            }
+                        } else {
+                            device.cart.sc64.regs[SC64_DATA0_REG as usize] = 0; // read_status/type
+                            device.cart.sc64.regs[SC64_DATA1_REG as usize] = 0; // length
+                        }
+                    }
+                    'M' => {
+                        // Send data from from flashcart to USB
+                        let address =
+                            device.cart.sc64.regs[SC64_DATA0_REG as usize] as u64 & 0x1FFFFFFF;
+                        let length =
+                            device.cart.sc64.regs[SC64_DATA1_REG as usize] as usize & 0xFFFFFF;
+
+                        if let Some(usb_tx) = device.ui.usb.usb_tx.as_mut() {
+                            let mut usb_buffer = vec![0; length];
+
+                            let mut i = 0;
+
+                            if address < device.rdram.size as u64 {
+                                while i < length {
+                                    *usb_buffer.get_mut(i).unwrap_or(&mut 0) = *device
+                                        .rdram
+                                        .mem
+                                        .get((address as usize + i) ^ device.byte_swap)
+                                        .unwrap_or(&0);
+                                    i += 1;
+                                }
+                            } else if address >= device::memory::MM_CART_ROM as u64
+                                && address < device::memory::MM_PIF_MEM as u64
+                            {
+                                while i < length {
+                                    *usb_buffer.get_mut(i).unwrap_or(&mut 0) = *device
+                                        .ui
+                                        .storage
+                                        .saves
+                                        .romsave
+                                        .data
+                                        .get(
+                                            &(((address as usize + i)
+                                                & device::cart::rom::CART_MASK)
+                                                as u32),
+                                        )
+                                        .unwrap_or(
+                                            device
+                                                .cart
+                                                .rom
+                                                .get(
+                                                    (address as usize + i)
+                                                        & device::cart::rom::CART_MASK,
+                                                )
+                                                .unwrap_or(&0),
+                                        );
+                                    i += 1;
+                                }
+                            } else {
+                                panic!("Unknown address {address:#x} for SC64 M command");
+                            }
+
+                            ui::usb::send_to_usb(
+                                usb_tx,
+                                ui::usb::UsbData {
+                                    data: usb_buffer,
+                                    data_type: device.cart.sc64.regs[SC64_DATA1_REG as usize] >> 24,
+                                    data_size: device.cart.sc64.regs[SC64_DATA1_REG as usize]
+                                        & 0xFFFFFF,
+                                },
+                            );
+                        }
+                    }
+                    'm' => {
+                        // Receive data from USB to flashcart
+                        let address =
+                            device.cart.sc64.regs[SC64_DATA0_REG as usize] as u64 & 0x1FFFFFFF;
+                        let length = device.cart.sc64.regs[SC64_DATA1_REG as usize] as usize;
+
+                        let mut i = 0;
+
+                        if address < device.rdram.size as u64 {
+                            while i < length {
+                                *device
+                                    .rdram
+                                    .mem
+                                    .get_mut((address as usize + i) ^ device.byte_swap)
+                                    .unwrap_or(&mut 0) =
+                                    *device.cart.sc64.usb_buffer.get(i).unwrap_or(&0);
+                                i += 1;
+                            }
+                        } else if address >= device::memory::MM_CART_ROM as u64
+                            && address < device::memory::MM_PIF_MEM as u64
+                        {
+                            while i < length {
+                                device.ui.storage.saves.romsave.data.insert(
+                                    ((address as usize + i) & device::cart::rom::CART_MASK) as u32,
+                                    *device.cart.sc64.usb_buffer.get(i).unwrap_or(&0),
+                                );
+                                i += 1;
+                            }
+                        } else {
+                            panic!("Unknown address {address:#x} for SC64 m command");
+                        }
                     }
-                    'U' | 'u' => {} // USB status, ignored
-                    'M' | 'm' => {} // USB read/write, ignored
                     'w' => {
                         // SD card writeback pending
                         device.cart.sc64.regs[SC64_DATA0_REG as usize] = 0;
@@ -246,7 +376,6 @@ pub fn read_mem(
     _access_size: device::memory::AccessSize,
 ) -> u32 {
     if address & 0x2000 != 0 {
-        device::cart::format_eeprom(device);
         let masked_address = address as usize & SC64_EEPROM_MASK;
         u32::from_be_bytes(
             device.ui.storage.saves.eeprom.data[masked_address..masked_address + 4]
@@ -265,7 +394,6 @@ pub fn read_mem(
 
 pub fn write_mem(device: &mut device::Device, address: u64, value: u32, mask: u32) {
     if address & 0x2000 != 0 {
-        device::cart::format_eeprom(device);
         let masked_address = address as usize & SC64_EEPROM_MASK;
         let mut data = u32::from_be_bytes(
             device.ui.storage.saves.eeprom.data[masked_address..masked_address + 4]
@@ -275,7 +403,7 @@ pub fn write_mem(device: &mut device::Device, address: u64, value: u32, mask: u3
         device::memory::masked_write_32(&mut data, value, mask);
         device.ui.storage.saves.eeprom.data[masked_address..masked_address + 4]
             .copy_from_slice(&data.to_be_bytes());
-        device.ui.storage.saves.eeprom.written = true
+        ui::storage::schedule_save(device, ui::storage::SaveTypes::Eeprom4k);
     } else {
         let masked_address = address as usize & SC64_BUFFER_MASK;
         let mut data = u32::from_be_bytes(
@@ -297,9 +425,8 @@ pub fn dma_read(
 ) -> u64 {
     dram_addr &= device::rdram::RDRAM_MASK as u32;
     let buffer = if cart_addr & 0x2000 != 0 {
-        device::cart::format_eeprom(device);
         cart_addr &= SC64_EEPROM_MASK as u32;
-        device.ui.storage.saves.eeprom.written = true;
+        ui::storage::schedule_save(device, ui::storage::SaveTypes::Eeprom4k);
         &mut device.ui.storage.saves.eeprom.data
     } else {
         cart_addr &= SC64_BUFFER_MASK as u32;
@@ -309,7 +436,7 @@ pub fn dma_read(
     let mut j = cart_addr;
 
     while i < dram_addr + length {
-        buffer[j as usize] = *device
+        *buffer.get_mut(j as usize).unwrap_or(&mut 0) = *device
             .rdram
             .mem
             .get(i as usize ^ device.byte_swap)
@@ -329,7 +456,6 @@ pub fn dma_write(
 ) -> u64 {
     dram_addr &= device::rdram::RDRAM_MASK as u32;
     let buffer = if cart_addr & 0x2000 != 0 {
-        device::cart::format_eeprom(device);
         cart_addr &= SC64_EEPROM_MASK as u32;
         &device.ui.storage.saves.eeprom.data
     } else {
@@ -344,7 +470,7 @@ pub fn dma_write(
             .rdram
             .mem
             .get_mut(i as usize ^ device.byte_swap)
-            .unwrap_or(&mut 0) = buffer[j as usize];
+            .unwrap_or(&mut 0) = *buffer.get(j as usize).unwrap_or(&0);
         i += 1;
         j += 1;
     }

src/device/cart/sram.rs

@@ -28,13 +28,13 @@ pub struct Flashram {
     pub silicon_id: [u32; 2],
 }
 
-fn format_sram(device: &mut device::Device) {
+pub fn format_sram(device: &mut device::Device) {
     if device.ui.storage.saves.sram.data.len() < SRAM_SIZE {
         device.ui.storage.saves.sram.data.resize(SRAM_SIZE, 0xFF)
     }
 }
 
-fn format_flash(device: &mut device::Device) {
+pub fn format_flash(device: &mut device::Device) {
     if device.ui.storage.saves.flash.data.len() < FLASHRAM_SIZE {
         device
             .ui
@@ -49,8 +49,6 @@ fn format_flash(device: &mut device::Device) {
 fn read_mem_sram(device: &mut device::Device, address: u64) -> u32 {
     let masked_address = address as usize & SRAM_MASK;
 
-    format_sram(device);
-
     u32::from_be_bytes(
         device.ui.storage.saves.sram.data[masked_address..masked_address + 4]
             .try_into()
@@ -96,8 +94,6 @@ pub fn read_mem(
 fn write_mem_sram(device: &mut device::Device, address: u64, value: u32, mask: u32) {
     let masked_address = address as usize & SRAM_MASK;
 
-    format_sram(device);
-
     let mut data = u32::from_be_bytes(
         device.ui.storage.saves.sram.data[masked_address..masked_address + 4]
             .try_into()
@@ -107,7 +103,7 @@ fn write_mem_sram(device: &mut device::Device, address: u64, value: u32, mask: u
     device.ui.storage.saves.sram.data[masked_address..masked_address + 4]
         .copy_from_slice(&data.to_be_bytes());
 
-    device.ui.storage.saves.sram.written = true
+    ui::storage::schedule_save(device, ui::storage::SaveTypes::Sram);
 }
 
 fn write_mem_flash(device: &mut device::Device, address: u64, value: u32, mask: u32) {
@@ -116,7 +112,6 @@ fn write_mem_flash(device: &mut device::Device, address: u64, value: u32, mask:
         device.cart.flashram.status = (value & mask) & 0xff;
     } else if (address & 0x1ffff) == 0x10000 {
         /* set command */
-        format_flash(device);
         flashram_command(device, value & mask);
     } else {
         /* other accesses are not implemented */
@@ -148,10 +143,15 @@ fn dma_read_sram(device: &mut device::Device, mut cart_addr: u32, mut dram_addr:
     let mut i = dram_addr;
     let mut j = cart_addr;
 
-    format_sram(device);
-
     while i < dram_addr + length {
-        device.ui.storage.saves.sram.data[j as usize] = *device
+        *device
+            .ui
+            .storage
+            .saves
+            .sram
+            .data
+            .get_mut(j as usize)
+            .unwrap_or(&mut 0) = *device
             .rdram
             .mem
             .get(i as usize ^ device.byte_swap)
@@ -160,12 +160,10 @@ fn dma_read_sram(device: &mut device::Device, mut cart_addr: u32, mut dram_addr:
         j += 1;
     }
 
-    device.ui.storage.saves.sram.written = true
+    ui::storage::schedule_save(device, ui::storage::SaveTypes::Sram);
 }
 
 fn dma_read_flash(device: &mut device::Device, cart_addr: u32, dram_addr: u32, length: u32) {
-    format_flash(device);
-
     if (cart_addr & 0x1ffff) == 0x00000
         && length == 128
         && device.cart.flashram.mode == FlashramMode::PageProgram
@@ -210,14 +208,19 @@ fn dma_write_sram(
     let mut i = dram_addr;
     let mut j = cart_addr;
 
-    format_sram(device);
-
     while i < dram_addr + length {
         *device
             .rdram
             .mem
             .get_mut(i as usize ^ device.byte_swap)
-            .unwrap_or(&mut 0) = device.ui.storage.saves.sram.data[j as usize];
+            .unwrap_or(&mut 0) = *device
+            .ui
+            .storage
+            .saves
+            .sram
+            .data
+            .get(j as usize)
+            .unwrap_or(&0);
         i += 1;
         j += 1;
     }
@@ -252,7 +255,6 @@ fn dma_write_flash(
     } else if (cart_addr & 0x1ffff) < 0x10000
         && device.cart.flashram.mode == FlashramMode::ReadArray
     {
-        format_flash(device);
         /* adjust flashram address before starting DMA. */
         if device.cart.flashram.silicon_id[1] == MX29L1100_ID
             || device.cart.flashram.silicon_id[1] == MX29L0000_ID
@@ -317,12 +319,12 @@ fn flashram_command(device: &mut device::Device, command: u32) {
                 for i in 0..128 * 128 {
                     device.ui.storage.saves.flash.data[offset + i] = 0xFF;
                 }
-                device.ui.storage.saves.flash.written = true
+                ui::storage::schedule_save(device, ui::storage::SaveTypes::Flash);
             } else if device.cart.flashram.mode == FlashramMode::ChipErase {
                 for i in 0..FLASHRAM_SIZE {
                     device.ui.storage.saves.flash.data[i] = 0xFF;
                 }
-                device.ui.storage.saves.flash.written = true
+                ui::storage::schedule_save(device, ui::storage::SaveTypes::Flash);
             } else {
                 panic!("Unexpected flash erase command")
             }
@@ -342,7 +344,7 @@ fn flashram_command(device: &mut device::Device, command: u32) {
             for i in 0..128 {
                 device.ui.storage.saves.flash.data[offset + i] = device.cart.flashram.page_buf[i];
             }
-            device.ui.storage.saves.flash.written = true;
+            ui::storage::schedule_save(device, ui::storage::SaveTypes::Flash);
 
             /* clear program busy flag, set program success flag, transition to status mode */
             device.cart.flashram.status &= !0x01;

src/device/controller.rs

@@ -56,15 +56,14 @@ pub fn process(device: &mut device::Device, channel: usize) {
         }
         JCMD_CONTROLLER_READ => {
             let offset = device.pif.channels[channel].rx_buf.unwrap();
-            let input = if device.netplay.is_none() {
-                ui::input::get(&device.ui, channel)
-            } else {
-                if device.netplay.as_ref().unwrap().player_number as usize == channel {
-                    let local_input = ui::input::get(&device.ui, 0);
-                    netplay::send_input(device.netplay.as_ref().unwrap(), local_input);
+            let input = if let Some(netplay) = &mut device.netplay {
+                if netplay.player_number as usize == channel {
+                    let local_input = ui::input::get(&mut device.ui, 0);
+                    netplay::send_input(netplay, local_input);
                 }
-
                 netplay::get_input(device, channel)
+            } else {
+                ui::input::get(&mut device.ui, channel)
             };
 
             device.pif.ram[offset..offset + 4].copy_from_slice(&input.data.to_ne_bytes());
@@ -96,7 +95,7 @@ pub fn process(device: &mut device::Device, channel: usize) {
             device.pif.channels[channel].rx_buf.unwrap(),
             channel,
         ),
-        _ => println!("unknown controller command {cmd}"),
+        _ => eprintln!("unknown controller command {cmd}"),
     }
 }
 
@@ -162,10 +161,12 @@ pub fn pak_switch_event(device: &mut device::Device) {
     for (i, channel) in device.pif.channels.iter_mut().enumerate() {
         if channel.change_pak != PakType::None {
             //stop rumble if it is on
-            if device.netplay.is_none() {
+            if let Some(netplay) = &device.netplay {
+                if netplay.player_number as usize == i {
+                    device::ui::input::set_rumble(&device.ui, 0, 0);
+                }
+            } else {
                 device::ui::input::set_rumble(&device.ui, i, 0);
-            } else if device.netplay.as_ref().unwrap().player_number as usize == i {
-                device::ui::input::set_rumble(&device.ui, 0, 0);
             }
 
             let new_pak_type = match channel.change_pak {
@@ -189,20 +190,31 @@ pub fn pak_switch_event(device: &mut device::Device) {
                     write: device::controller::mempak::write,
                     pak_type: new_pak_type,
                 });
+                ui::video::onscreen_message(
+                    &format!("P{} MemPak selected", i + 1),
+                    ui::video::MESSAGE_LENGTH_MESSAGE_SHORT,
+                );
             } else if new_pak_type == PakType::RumblePak {
                 channel.pak_handler = Some(device::controller::PakHandler {
                     read: device::controller::rumble::read,
                     write: device::controller::rumble::write,
                     pak_type: new_pak_type,
                 });
+                ui::video::onscreen_message(
+                    &format!("P{} RumblePak selected", i + 1),
+                    ui::video::MESSAGE_LENGTH_MESSAGE_SHORT,
+                );
             } else if new_pak_type == PakType::TransferPak {
                 channel.pak_handler = Some(device::controller::PakHandler {
                     read: device::controller::transferpak::read,
                     write: device::controller::transferpak::write,
                     pak_type: new_pak_type,
                 });
+                ui::video::onscreen_message(
+                    &format!("P{} TransferPak selected", i + 1),
+                    ui::video::MESSAGE_LENGTH_MESSAGE_SHORT,
+                );
             }
-            ui::audio::play_pak_switch(&device.ui, new_pak_type);
             channel.change_pak = PakType::None;
         }
     }

src/device/controller/gbcart.rs

@@ -110,7 +110,7 @@ fn write_mbc3(
     if address < 0x2000 {
         cart.ram_enabled = value & 0xf == 0xa;
     } else if address < 0x4000 {
-        let bank = value & 0x7f;
+        let bank = value & if cart.rom.len() > 2097152 { 0xff } else { 0x7f };
         cart.rom_bank = bank as u32;
         if cart.rom_bank == 0 {
             cart.rom_bank = 1;
@@ -182,16 +182,12 @@ fn read_mbc3(
             return;
         }
         if cart.ram_bank < 0x8 {
-            if cart.ram_bank > 3 {
-                for i in 0..size {
-                    pif_ram[data + i] = 0;
-                }
-            } else {
-                let banked_address = address - 0xA000 + (cart.ram_bank * 0x2000);
-                pif_ram[data..data + size].copy_from_slice(
-                    &cart.ram[banked_address as usize..banked_address as usize + size],
-                );
-            }
+            let banked_address = address - 0xA000 + (cart.ram_bank * 0x2000);
+            pif_ram[data..data + size].copy_from_slice(
+                cart.ram
+                    .get(banked_address as usize..banked_address as usize + size)
+                    .unwrap_or(&vec![0; size]),
+            );
         } else {
             let latch = match cart.ram_bank {
                 0x8 => cart.latch_second,
@@ -231,7 +227,7 @@ fn write_mbc5(
     } else if address < 0x6000 {
         cart.ram_bank = (value & 0xf) as u16;
     } else if address < 0xa000 {
-        println!("Unknown MBC5 write address {address:x}");
+        eprintln!("Unknown MBC5 write address {address:x}");
     } else if (0xa000..0xc000).contains(&address) {
         if !cart.ram_enabled {
             return;

src/device/controller/mempak.rs

@@ -1,9 +1,10 @@
 use crate::device;
+use crate::ui;
 
 pub const MEMPAK_SIZE: usize = 0x8000;
 const MPK_PAGE_SIZE: usize = 256;
 
-fn format_mempak(device: &mut device::Device) {
+pub fn format_mempak(device: &mut device::Device) {
     if device.ui.storage.saves.mempak.data.len() < MEMPAK_SIZE * 4 {
         device
             .ui
@@ -42,6 +43,11 @@ fn format_mempak(device: &mut device::Device) {
         ];
         for i in 0..4 {
             let offset = i * MEMPAK_SIZE;
+            if device.ui.storage.saves.mempak.data[offset..offset + MEMPAK_SIZE] != [0; MEMPAK_SIZE]
+            {
+                // don't overwrite existing data
+                continue;
+            }
 
             /* Fill Page 0 with pre-initialized content */
             device.ui.storage.saves.mempak.data[offset..offset + MPK_PAGE_SIZE]
@@ -76,8 +82,6 @@ fn format_mempak(device: &mut device::Device) {
 
 pub fn read(device: &mut device::Device, channel: usize, address: u16, data: usize, size: usize) {
     if (address as usize) < MEMPAK_SIZE {
-        format_mempak(device);
-
         let offset = (channel * MEMPAK_SIZE) + address as usize;
         device.pif.ram[data..data + size]
             .copy_from_slice(&device.ui.storage.saves.mempak.data[offset..offset + size])
@@ -90,12 +94,10 @@ pub fn read(device: &mut device::Device, channel: usize, address: u16, data: usi
 
 pub fn write(device: &mut device::Device, channel: usize, address: u16, data: usize, size: usize) {
     if (address as usize) < MEMPAK_SIZE {
-        format_mempak(device);
-
         let offset = (channel * MEMPAK_SIZE) + address as usize;
         device.ui.storage.saves.mempak.data[offset..offset + size]
             .copy_from_slice(&device.pif.ram[data..data + size]);
 
-        device.ui.storage.saves.mempak.written = true
+        ui::storage::schedule_save(device, ui::storage::SaveTypes::Mempak);
     }
 }

src/device/controller/rumble.rs

@@ -15,10 +15,13 @@ pub fn read(device: &mut device::Device, _channel: usize, address: u16, data: us
 pub fn write(device: &mut device::Device, channel: usize, address: u16, data: usize, size: usize) {
     if address == 0xc000 {
         let rumble = device.pif.ram[data + size - 1];
-        if device.netplay.is_none() {
+
+        if let Some(netplay) = &device.netplay {
+            if netplay.player_number as usize == channel {
+                device::ui::input::set_rumble(&device.ui, 0, rumble);
+            }
+        } else {
             device::ui::input::set_rumble(&device.ui, channel, rumble);
-        } else if device.netplay.as_ref().unwrap().player_number as usize == channel {
-            device::ui::input::set_rumble(&device.ui, 0, rumble);
         }
     }
 }

src/device/controller/transferpak.rs

@@ -61,7 +61,7 @@ pub fn read(device: &mut device::Device, channel: usize, address: u16, data: usi
             );
         }
         _ => {
-            println!("unknown transfer pak read {:x}", address >> 12);
+            eprintln!("unknown transfer pak read {:x}", address >> 12);
         }
     }
 }
@@ -84,7 +84,7 @@ pub fn write(device: &mut device::Device, channel: usize, address: u16, data: us
                     }
                     pak.enabled = true;
                 }
-                _ => println!("unknown transfer pak value"),
+                _ => eprintln!("unknown transfer pak value"),
             }
             return;
         }
@@ -127,7 +127,7 @@ pub fn write(device: &mut device::Device, channel: usize, address: u16, data: us
             );
         }
         _ => {
-            println!("unknown transfer pak write {:x}", address >> 12);
+            eprintln!("unknown transfer pak write {:x}", address >> 12);
         }
     }
 }

src/device/controller/vru.rs

@@ -1,4 +1,6 @@
-use crate::{device, ui};
+use crate::device;
+#[cfg(feature = "gui")]
+use crate::ui;
 use std::collections::HashMap;
 
 const JCMD_VRU_READ: u8 = 0x09;
@@ -29,14 +31,6 @@ pub struct Vru {
     pub word_mappings: HashMap<String, String>,
 }
 
-#[derive(serde::Serialize, serde::Deserialize)]
-pub struct VruWindow {
-    #[serde(skip)]
-    pub window_notifier: Option<tokio::sync::mpsc::Sender<Option<Vec<String>>>>,
-    #[serde(skip)]
-    pub word_receiver: Option<tokio::sync::mpsc::Receiver<String>>,
-}
-
 pub fn init(device: &mut device::Device) {
     reset_vru(device);
     create_word_mappings(device);
@@ -187,15 +181,10 @@ pub fn process(device: &mut device::Device, channel: usize) {
             device.pif.ram[device.pif.channels[channel].rx_buf.unwrap()] = 0;
         }
         JCMD_VRU_READ => {
-            let index = if device.vru_window.window_notifier.is_some() {
-                ui::vru::prompt_for_match(
-                    &device.vru.words,
-                    device.vru_window.window_notifier.as_ref().unwrap(),
-                    device.vru_window.word_receiver.as_mut().unwrap(),
-                )
-            } else {
-                0x7FFF
-            };
+            #[cfg(feature = "gui")]
+            let index = ui::vru::prompt_for_match(&device.vru.words, device.vi.frame_time);
+            #[cfg(not(feature = "gui"))]
+            let index = 0x7FFF;
             let num_results = if index == 0x7FFF { 0 } else { 1 };
             let data: HashMap<usize, u16> = HashMap::from([
                 (0, 0x8000),

src/device/cop0.rs

@@ -30,13 +30,15 @@ pub const COP0_XCONTEXT_REG: u32 = 20;
 //const COP0_CACHEERR_REG: u32 = 27;
 pub const COP0_TAGLO_REG: u32 = 28;
 //const COP0_TAGHI_REG: u32 = 29;
-const COP0_ERROREPC_REG: u32 = 30;
+pub const COP0_ERROREPC_REG: u32 = 30;
 //const COP0_UNUSED_31: u32 = 31;
 pub const COP0_REGS_COUNT: u32 = 32;
 
 pub const COP0_STATUS_IE: u64 = 1 << 0;
 pub const COP0_STATUS_EXL: u64 = 1 << 1;
 pub const COP0_STATUS_ERL: u64 = 1 << 2;
+pub const COP0_STATUS_SR: u64 = 1 << 20;
+pub const COP0_STATUS_TS: u64 = 1 << 21;
 pub const COP0_STATUS_BEV: u64 = 1 << 22;
 pub const COP0_STATUS_FR: u64 = 1 << 26;
 pub const COP0_STATUS_CU1: u64 = 1 << 29;
@@ -55,6 +57,7 @@ pub const COP0_CAUSE_EXCCODE_CPU: u64 = 11 << 2;
 pub const COP0_CAUSE_EXCCODE_TR: u64 = 13 << 2;
 pub const COP0_CAUSE_EXCCODE_FPE: u64 = 15 << 2;
 pub const COP0_CAUSE_IP2: u64 = 1 << 10;
+pub const COP0_CAUSE_IP4: u64 = 1 << 12;
 pub const COP0_CAUSE_IP7: u64 = 1 << 15;
 pub const COP0_CAUSE_BD: u64 = 1 << 31;
 
@@ -62,7 +65,7 @@ pub const COP0_CAUSE_CE1: u64 = 1 << 28;
 pub const COP0_CAUSE_CE2: u64 = 1 << 29;
 
 pub const COP0_CAUSE_IP_MASK: u64 = 0b00000000000000001111111100000000;
-//pub const COP0_CAUSE_EXCCODE_MASK: u64 = 0x1F << 2;
+pub const COP0_CAUSE_EXCCODE_MASK: u64 = 0x1F << 2;
 pub const COP0_CONTEXT_BADVPN2_MASK: u64 = 0b00000000011111111111111111110000;
 pub const COP0_XCONTEXT_BADVPN2_MASK: u64 = 0b01111111111111111111111111110000;
 pub const COP0_XCONTEXT_REGION_MASK: u64 = 0b110000000000000000000000000000000;
@@ -101,7 +104,6 @@ pub struct Cop0 {
     pub tlb_lut_w: Vec<device::tlb::TlbLut>,
     pub tlb_entries: [device::tlb::TlbEntry; 32],
     pub is_event: bool,
-    pub pending_compare_interrupt: bool,
 }
 
 fn mfc0(device: &mut device::Device, opcode: u32) {
@@ -179,6 +181,8 @@ pub fn reserved(device: &mut device::Device, _opcode: u32) {
     device::exceptions::reserved_exception(device, 0);
 }
 
+pub fn emux_xdetect(_device: &mut device::Device, _opcode: u32) {}
+
 fn get_control_registers(device: &device::Device, index: u32) -> u64 {
     match index {
         COP0_COUNT_REG => device.cpu.cop0.regs[index as usize] >> 1,
@@ -218,12 +222,11 @@ fn set_control_registers(device: &mut device::Device, index: u32, mut data: u64)
                 (compare_event_diff as u64) << 1,
             );
             device.cpu.cop0.regs[COP0_CAUSE_REG as usize] &= !COP0_CAUSE_IP7;
-            device.cpu.cop0.pending_compare_interrupt = false;
         }
-        COP0_STATUS_REG => {
-            if data & COP0_STATUS_FR != device.cpu.cop0.regs[index as usize] & COP0_STATUS_FR {
-                device::cop1::set_fgr_registers(device, data)
-            }
+        COP0_STATUS_REG
+            if data & COP0_STATUS_FR != device.cpu.cop0.regs[index as usize] & COP0_STATUS_FR =>
+        {
+            device::cop1::set_fgr_registers(device, data)
         }
         _ => {}
     }
@@ -236,7 +239,10 @@ fn set_control_registers(device: &mut device::Device, index: u32, mut data: u64)
 }
 
 pub fn compare_event(device: &mut device::Device) {
-    device.cpu.cop0.pending_compare_interrupt = true;
+    device.cpu.cop0.regs[device::cop0::COP0_CAUSE_REG as usize] |= device::cop0::COP0_CAUSE_IP7;
+    device.cpu.cop0.regs[device::cop0::COP0_CAUSE_REG as usize] &=
+        !device::cop0::COP0_CAUSE_EXCCODE_MASK;
+
     device::events::create_event_at(
         device,
         device::events::EVENT_TYPE_COMPARE,
@@ -261,38 +267,38 @@ pub fn add_cycles(device: &mut device::Device, cycles: u64) {
 
 pub fn map_instructions(device: &mut device::Device) {
     device.cpu.cop0.instrs = [
-        device::cop0::mfc0,        // 0
-        device::cop0::dmfc0,       // 1
-        device::cop0::reserved,    // 2
-        device::cop0::reserved,    // 3
-        device::cop0::mtc0,        // 4
-        device::cop0::dmtc0,       // 5
-        device::cop0::reserved,    // 6
-        device::cop0::reserved,    // 7
-        device::cop0::reserved,    // 8
-        device::cop0::reserved,    // 9
-        device::cop0::reserved,    // 10
-        device::cop0::reserved,    // 11
-        device::cop0::reserved,    // 12
-        device::cop0::reserved,    // 13
-        device::cop0::reserved,    // 14
-        device::cop0::reserved,    // 15
-        device::cop0::execute_cp0, // 16
-        device::cop0::reserved,    // 17
-        device::cop0::reserved,    // 18
-        device::cop0::reserved,    // 19
-        device::cop0::reserved,    // 20
-        device::cop0::reserved,    // 21
-        device::cop0::reserved,    // 22
-        device::cop0::reserved,    // 23
-        device::cop0::reserved,    // 24
-        device::cop0::reserved,    // 25
-        device::cop0::reserved,    // 26
-        device::cop0::reserved,    // 27
-        device::cop0::reserved,    // 28
-        device::cop0::reserved,    // 29
-        device::cop0::reserved,    // 30
-        device::cop0::reserved,    // 31
+        device::cop0::mfc0,         // 0
+        device::cop0::dmfc0,        // 1
+        device::cop0::reserved,     // 2
+        device::cop0::reserved,     // 3
+        device::cop0::mtc0,         // 4
+        device::cop0::dmtc0,        // 5
+        device::cop0::reserved,     // 6
+        device::cop0::reserved,     // 7
+        device::cop0::reserved,     // 8
+        device::cop0::reserved,     // 9
+        device::cop0::reserved,     // 10
+        device::cop0::reserved,     // 11
+        device::cop0::reserved,     // 12
+        device::cop0::reserved,     // 13
+        device::cop0::reserved,     // 14
+        device::cop0::reserved,     // 15
+        device::cop0::execute_cp0,  // 16
+        device::cop0::reserved,     // 17
+        device::cop0::reserved,     // 18
+        device::cop0::reserved,     // 19
+        device::cop0::emux_xdetect, // 20
+        device::cop0::reserved,     // 21
+        device::cop0::reserved,     // 22
+        device::cop0::reserved,     // 23
+        device::cop0::reserved,     // 24
+        device::cop0::reserved,     // 25
+        device::cop0::reserved,     // 26
+        device::cop0::reserved,     // 27
+        device::cop0::reserved,     // 28
+        device::cop0::reserved,     // 29
+        device::cop0::reserved,     // 30
+        device::cop0::reserved,     // 31
     ];
 
     device.cpu.cop0.instrs2 = [

src/device/cpu.rs

@@ -1,4 +1,4 @@
-use crate::{device, savestates};
+use crate::{device, savestates, ui};
 
 #[derive(PartialEq, serde::Serialize, serde::Deserialize)]
 pub enum State {
@@ -227,7 +227,10 @@ pub fn init(device: &mut device::Device) {
     device.cpu.clock_rate = if !device.cpu.overclock {
         93750000
     } else {
-        println!("Overclocking enabled, setting clock rate to 125 MHz");
+        ui::video::onscreen_message(
+            "Overclocking enabled, setting clock rate to 125 MHz",
+            ui::video::MESSAGE_LENGTH_MESSAGE_SHORT,
+        );
         125000000
     };
 

src/device/events.rs

@@ -1,4 +1,5 @@
 use crate::device;
+use crate::ui;
 
 pub const EVENT_TYPE_NONE: usize = 0;
 pub const EVENT_TYPE_AI: usize = 1;
@@ -12,7 +13,9 @@ pub const EVENT_TYPE_SPDMA: usize = 8;
 pub const EVENT_TYPE_COMPARE: usize = 9;
 pub const EVENT_TYPE_VRU: usize = 10;
 pub const EVENT_TYPE_PAK: usize = 11;
-pub const EVENT_TYPE_COUNT: usize = 12;
+pub const EVENT_TYPE_SAVE: usize = 12;
+pub const EVENT_TYPE_NMI: usize = 13;
+pub const EVENT_TYPE_COUNT: usize = 14;
 
 #[derive(PartialEq, Copy, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Event {
@@ -60,6 +63,8 @@ fn get_event_handler(name: usize) -> fn(&mut device::Device) {
         EVENT_TYPE_COMPARE => device::cop0::compare_event,
         EVENT_TYPE_VRU => device::controller::vru::vru_talking_event,
         EVENT_TYPE_PAK => device::controller::pak_switch_event,
+        EVENT_TYPE_SAVE => ui::storage::save_event,
+        EVENT_TYPE_NMI => device::exceptions::reset_event,
         _ => dummy_event,
     }
 }

src/device/exceptions.rs

@@ -1,4 +1,5 @@
 use crate::device;
+use crate::ui;
 
 pub fn check_pending_interrupts(device: &mut device::Device) {
     if (device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize]
@@ -15,10 +16,9 @@ pub fn check_pending_interrupts(device: &mut device::Device) {
         & device.mi.regs[device::mi::MI_INTR_MASK_REG as usize]
         != 0
     {
-        device.cpu.cop0.regs[device::cop0::COP0_CAUSE_REG as usize] = device::cop0::COP0_CAUSE_IP2;
-    } else if device.cpu.cop0.pending_compare_interrupt {
-        device.cpu.cop0.regs[device::cop0::COP0_CAUSE_REG as usize] = device::cop0::COP0_CAUSE_IP7;
-        device.cpu.cop0.pending_compare_interrupt = false;
+        device.cpu.cop0.regs[device::cop0::COP0_CAUSE_REG as usize] |= device::cop0::COP0_CAUSE_IP2;
+        device.cpu.cop0.regs[device::cop0::COP0_CAUSE_REG as usize] &=
+            !device::cop0::COP0_CAUSE_EXCCODE_MASK;
     }
 
     if (device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize]
@@ -151,6 +151,24 @@ pub fn tlb_miss_exception(
     exception_general(device, vector_offset)
 }
 
+pub fn reset_event(device: &mut device::Device) {
+    device.cpu.cop0.regs[device::cop0::COP0_CAUSE_REG as usize] &= !device::cop0::COP0_CAUSE_IP4;
+
+    device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] |= device::cop0::COP0_STATUS_ERL
+        | device::cop0::COP0_STATUS_SR
+        | device::cop0::COP0_STATUS_BEV;
+    device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] &= !device::cop0::COP0_STATUS_TS;
+
+    device.cpu.cop0.regs[device::cop0::COP0_ERROREPC_REG as usize] = device.cpu.pc;
+    device.cpu.pc = 0xBFC00000;
+    device.cpu.branch_state.state = device::cpu::State::Step;
+    device.rsp.regs2[device::rsp_interface::SP_PC_REG as usize] = 0;
+
+    device::pif::reset_pif(device, true);
+
+    ui::video::onscreen_message("Game reset", ui::video::MESSAGE_LENGTH_MESSAGE_SHORT);
+}
+
 fn exception_general(device: &mut device::Device, vector_offset: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_EXL
         == 0

src/device/is_viewer.rs

@@ -22,8 +22,8 @@ pub fn write_mem(device: &mut device::Device, address: u64, value: u32, mask: u3
         let data = std::str::from_utf8(
             &device.cart.is_viewer_buffer[0x20_usize..(0x20 + length) as usize],
         );
-        if data.is_ok() {
-            print!("{}", data.unwrap());
+        if let Ok(data) = data {
+            print!("{}", data);
         }
     } else {
         let mut data = u32::from_be_bytes(

src/device/memory.rs

@@ -62,11 +62,16 @@ pub fn masked_write_64(dst: &mut u64, value: u64, mask: u64) {
 
 pub fn translate_address(
     device: &mut device::Device,
-    address: u64,
+    mut address: u64,
     access_type: AccessType,
 ) -> (u64, bool, bool) {
     if (address & 0xc0000000) != 0x80000000 {
-        return device::tlb::get_physical_address(device, address, access_type);
+        if (address & 0xFFFFFFFF00000000) == 0x9000000000000000 {
+            // this is a hack to support 64-bit addresses used by some homebrew
+            address |= 0xA0000000;
+        } else {
+            return device::tlb::get_physical_address(device, address, access_type);
+        }
     }
     (address & 0x1FFFFFFF, address & 0x20000000 == 0, false)
 }

src/device/mi.rs

@@ -1,6 +1,6 @@
 use crate::device;
 
-const MI_INIT_MODE_REG: u32 = 0;
+pub const MI_INIT_MODE_REG: u32 = 0;
 const MI_VERSION_REG: u32 = 1;
 pub const MI_INTR_REG: u32 = 2;
 pub const MI_INTR_MASK_REG: u32 = 3;
@@ -29,7 +29,7 @@ const MI_CLR_DP: u32 = 1 << 10;
 const MI_SET_DP: u32 = 1 << 11;
 
 /* mode read */
-const MI_INIT_MODE: u32 = 1 << 7;
+pub const MI_INIT_MODE: u32 = 1 << 7;
 const MI_EBUS_MODE: u32 = 1 << 8;
 const MI_RDRAM_MODE: u32 = 1 << 9;
 
@@ -42,7 +42,7 @@ const MI_CLR_DP_INTR: u32 = 1 << 11;
 const MI_CLR_RDRAM: u32 = 1 << 12;
 const MI_SET_RDRAM: u32 = 1 << 13;
 
-const MI_INIT_LENGTH_MASK: u32 = 0b1111111;
+pub const MI_INIT_LENGTH_MASK: u32 = 0b1111111;
 
 #[derive(serde::Serialize, serde::Deserialize)]
 pub struct Mi {
@@ -78,9 +78,15 @@ fn update_init_mode(device: &mut device::Device, w: u32) {
     device.mi.regs[MI_INIT_MODE_REG as usize] |= w & MI_INIT_LENGTH_MASK;
 
     if w & MI_CLR_INIT != 0 {
+        for i in 0..(0x3F00000 >> 16) {
+            device.memory.memory_map_write[i] = device::rdram::write_mem;
+        }
         device.mi.regs[MI_INIT_MODE_REG as usize] &= !MI_INIT_MODE
     }
     if w & MI_SET_INIT != 0 {
+        for i in 0..(0x3F00000 >> 16) {
+            device.memory.memory_map_write[i] = device::rdram::write_mem_repeat;
+        }
         device.mi.regs[MI_INIT_MODE_REG as usize] |= MI_INIT_MODE
     }
     if w & MI_CLR_EBUS != 0 {

src/device/pi.rs

@@ -1,5 +1,6 @@
 use crate::device;
-use rand_chacha::rand_core::RngCore;
+use crate::ui;
+use rand::Rng;
 
 const PI_DRAM_ADDR_REG: u32 = 0;
 const PI_CART_ADDR_REG: u32 = 1;
@@ -92,6 +93,9 @@ fn dma_write(device: &mut device::Device) {
         length -= dram_addr & 0x7;
     }
 
+    // check RDP before PI writes to RDRAM
+    ui::video::check_framebuffers(dram_addr, length);
+
     let cycles = (handler.write)(device, cart_addr, dram_addr, length);
 
     device::events::create_event(device, device::events::EVENT_TYPE_PI, cycles);
@@ -165,7 +169,7 @@ pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u
     }
 }
 
-fn randomize_interrupt_time(rng: &mut rand_chacha::ChaCha8Rng) -> u64 {
+fn randomize_interrupt_time(rng: &mut rand::rngs::Xoshiro256PlusPlus) -> u64 {
     rng.next_u64() % 0x10
 }
 

src/device/pif.rs

@@ -218,11 +218,11 @@ pub fn process_ram(device: &mut device::Device) {
 
 pub fn connect_pif_channels(device: &mut device::Device) {
     for i in 0..4 {
-        if device.netplay.is_none() {
-            if device.ui.config.input.controller_enabled[i] {
+        if let Some(netplay) = &device.netplay {
+            if netplay.player_data[i].reg_id != 0 {
                 device.pif.channels[i].process = Some(device::controller::process);
             }
-        } else if device.netplay.as_ref().unwrap().player_data[i].reg_id != 0 {
+        } else if device.ui.config.input.controller_enabled[i] {
             device.pif.channels[i].process = Some(device::controller::process);
         }
     }
@@ -249,14 +249,23 @@ fn get_default_handler(device: &device::Device) -> device::controller::PakHandle
     }
 }
 
-pub fn init(device: &mut device::Device) {
+pub fn reset_pif(device: &mut device::Device, is_nmi_reset: bool) {
     if device.cart.pal {
         device.pif.rom = rom::PAL_PIF_ROM;
     } else {
         device.pif.rom = rom::NTSC_PIF_ROM;
     }
-    device.pif.ram[0x26] = device.cart.cic_seed;
-    device.pif.ram[0x27] = device.cart.cic_seed;
+
+    let reset_type = u32::from(is_nmi_reset);
+    let rom_type = 0u32;
+    let s7 = 0u32;
+    let cic = u32::from(device.cart.cic_seed);
+    let word = (rom_type << 19) | (s7 << 18) | (reset_type << 17) | (cic << 8) | 0x3f;
+    device.pif.ram[0x24..0x28].copy_from_slice(&word.to_be_bytes());
+}
+
+pub fn init(device: &mut device::Device) {
+    reset_pif(device, false);
 
     let default_handler = get_default_handler(device);
     let tpak_handler = device::controller::PakHandler {
@@ -268,16 +277,16 @@ pub fn init(device: &mut device::Device) {
     connect_pif_channels(device);
 
     for i in 0..4 {
-        if device.netplay.is_none() {
-            if device.ui.config.input.controller_enabled[i] {
-                if device.transferpaks[i].cart.rom.is_empty() {
-                    device.pif.channels[i].pak_handler = Some(default_handler);
-                } else {
-                    device.pif.channels[i].pak_handler = Some(tpak_handler);
-                }
+        if let Some(netplay) = &device.netplay {
+            if netplay.player_data[i].reg_id != 0 {
+                device.pif.channels[i].pak_handler = Some(default_handler);
+            }
+        } else if device.ui.config.input.controller_enabled[i] {
+            if device.transferpaks[i].cart.rom.is_empty() {
+                device.pif.channels[i].pak_handler = Some(default_handler);
+            } else {
+                device.pif.channels[i].pak_handler = Some(tpak_handler);
             }
-        } else if device.netplay.as_ref().unwrap().player_data[i].reg_id != 0 {
-            device.pif.channels[i].pak_handler = Some(default_handler);
         }
     }
     if device.ui.config.input.emulate_vru && device.netplay.is_none() {

src/device/rdram.rs

@@ -1,4 +1,6 @@
 use crate::device;
+use crate::retroachievements;
+use crate::ui;
 use std::alloc::{Layout, alloc_zeroed};
 
 //const RDRAM_CONFIG_REG: u32 = 0;
@@ -33,7 +35,7 @@ pub fn read_mem_fast(
             .rdram
             .mem
             .get(masked_address..masked_address + 4)
-            .unwrap_or_default()
+            .unwrap_or(&[0; 4])
             .try_into()
             .unwrap_or_default(),
     )
@@ -50,24 +52,28 @@ pub fn read_mem(
     );
     let masked_address = address as usize & RDRAM_MASK;
 
+    ui::video::check_framebuffers(masked_address as u32, 4);
+
     u32::from_ne_bytes(
         device
             .rdram
             .mem
             .get(masked_address..masked_address + 4)
-            .unwrap_or_default()
+            .unwrap_or(&[0; 4])
             .try_into()
             .unwrap_or_default(),
     )
 }
 
 pub fn write_mem(device: &mut device::Device, address: u64, value: u32, mask: u32) {
+    ui::video::check_framebuffers(address as u32, 4);
+
     let mut data = u32::from_ne_bytes(
         device
             .rdram
             .mem
             .get(address as usize..(address + 4) as usize)
-            .unwrap_or_default()
+            .unwrap_or(&[0; 4])
             .try_into()
             .unwrap_or_default(),
     );
@@ -80,6 +86,39 @@ pub fn write_mem(device: &mut device::Device, address: u64, value: u32, mask: u3
         .copy_from_slice(&data.to_ne_bytes());
 }
 
+pub fn write_mem_repeat(device: &mut device::Device, address: u64, value: u32, mask: u32) {
+    if mask != 0xFFFFFFFF {
+        panic!("RDRAM write_mem_repeat called with mask {:#x}", mask);
+    }
+
+    let repeat_length = (device.mi.regs[device::mi::MI_INIT_MODE_REG as usize]
+        & device::mi::MI_INIT_LENGTH_MASK)
+        + 1;
+
+    if !repeat_length.is_multiple_of(4) {
+        panic!(
+            "RDRAM write_mem_repeat called with non-word-aligned length {}",
+            repeat_length
+        );
+    }
+
+    ui::video::check_framebuffers(address as u32, repeat_length);
+
+    for i in (0..repeat_length as u64).step_by(4) {
+        device
+            .rdram
+            .mem
+            .get_mut((address + i) as usize..(address + i) as usize + 4)
+            .unwrap_or(&mut [0; 4])
+            .copy_from_slice(&value.to_ne_bytes());
+    }
+
+    device.mi.regs[device::mi::MI_INIT_MODE_REG as usize] &= !device::mi::MI_INIT_MODE;
+    for i in 0..(0x3F00000 >> 16) {
+        device.memory.memory_map_write[i] = device::rdram::write_mem;
+    }
+}
+
 pub fn read_regs(
     device: &mut device::Device,
     address: u64,
@@ -113,6 +152,8 @@ pub fn init(device: &mut device::Device) {
     device.rdram.mem =
         unsafe { Vec::from_raw_parts(ptr, device.rdram.size as usize, device.rdram.size as usize) };
 
+    retroachievements::set_dmem(device.rdram.mem.as_ptr(), device.rdram.size as usize);
+
     // hack, skip RDRAM initialization
     device
         .rdram

src/device/rsp_interface.rs

@@ -1,4 +1,5 @@
 use crate::device;
+use crate::ui;
 
 const SP_MEM_ADDR_REG: u32 = 0;
 const SP_DRAM_ADDR_REG: u32 = 1;
@@ -146,6 +147,7 @@ fn do_dma(device: &mut device::Device, dma: RspDma) {
     let mut dram_addr = dma.dramaddr & 0xfffff8;
     let offset = dma.memaddr & 0x1000;
 
+    ui::video::check_framebuffers(dram_addr, count * (length + skip) - skip);
     if dma.dir == DmaDir::Read {
         let mut j = 0;
         while j < count {
@@ -180,7 +182,7 @@ fn do_dma(device: &mut device::Device, dma: RspDma) {
                         .rdram
                         .mem
                         .get(dram_addr as usize..dram_addr as usize + 4)
-                        .unwrap_or_default()
+                        .unwrap_or(&[0; 4])
                         .try_into()
                         .unwrap_or_default(),
                 );
@@ -219,6 +221,8 @@ fn fifo_push(device: &mut device::Device, dir: DmaDir) {
         panic!("RSP DMA already full")
     }
 
+    device.rsp.cpu.sync_point = true;
+
     if device.rsp.regs[SP_DMA_BUSY_REG as usize] != 0 {
         device.rsp.fifo[1].dir = dir;
         if dir == DmaDir::Read {
@@ -276,21 +280,20 @@ pub fn read_regs(
     }
     let reg = (address & 0xFFFF) >> 2;
     match reg as u32 {
-        SP_DMA_BUSY_REG | SP_DMA_FULL_REG => {
-            if device.rsp.regs[reg as usize] != 0 {
-                device.rsp.cpu.sync_point = true;
-            }
-            device.rsp.regs[reg as usize]
-        }
         SP_STATUS_REG => {
             let value = device.rsp.regs[reg as usize]
-                & !(SP_STATUS_HALT | SP_STATUS_BROKE | SP_STATUS_INTR_BREAK);
+                & (SP_STATUS_SIG0
+                    | SP_STATUS_SIG1
+                    | SP_STATUS_SIG2
+                    | SP_STATUS_SIG3
+                    | SP_STATUS_SIG4
+                    | SP_STATUS_SIG5
+                    | SP_STATUS_SIG6
+                    | SP_STATUS_SIG7);
             if value == device.rsp.last_status_value && value != 0 {
                 device.rsp.cpu.sync_point = true;
             }
-            if value & (SP_STATUS_DMA_BUSY | SP_STATUS_DMA_FULL) != 0 {
-                device.rsp.cpu.sync_point = true;
-            }
+
             device.rsp.last_status_value = value;
             device.rsp.regs[reg as usize]
         }
@@ -464,6 +467,7 @@ fn update_sp_status(device: &mut device::Device, w: u32) {
 fn do_task(device: &mut device::Device) {
     device.rsp.cpu.sync_point = false;
     device.rsp.last_status_value = 0;
+    device.rdp.last_status_value = 0;
     if device.rsp.regs[SP_DMA_BUSY_REG as usize] == 1 {
         device.rsp.run_after_dma = true
     } else {

src/device/rsp_su_instructions.rs

@@ -304,25 +304,44 @@ pub fn lh(device: &mut device::Device, opcode: u32) {
     let address =
         device.rsp.cpu.gpr[rs(opcode) as usize].wrapping_add(imm(opcode) as i16 as i32 as u32);
 
-    let mut w = [0; 2];
-    w[0] = device.rsp.mem[address as usize & 0xFFF];
-    w[1] = device.rsp.mem[(address as usize + 1) & 0xFFF];
+    // Optimize for aligned access when possible
+    let addr_masked = address as usize & 0xFFF;
+    let value = if addr_masked <= 0xFFE {
+        u16::from_be_bytes(
+            device.rsp.mem[addr_masked..addr_masked + 2]
+                .try_into()
+                .unwrap(),
+        )
+    } else {
+        let w0 = device.rsp.mem[addr_masked];
+        let w1 = device.rsp.mem[(addr_masked + 1) & 0xFFF];
+        ((w0 as u16) << 8) | w1 as u16
+    };
 
-    device.rsp.cpu.gpr[rt(opcode) as usize] =
-        (((w[0] as u16) << 8) | w[1] as u16) as i16 as i32 as u32
+    device.rsp.cpu.gpr[rt(opcode) as usize] = value as i16 as i32 as u32;
 }
 
 pub fn lw(device: &mut device::Device, opcode: u32) {
     let address =
         device.rsp.cpu.gpr[rs(opcode) as usize].wrapping_add(imm(opcode) as i16 as i32 as u32);
 
-    let mut w = [0; 4];
-    for (i, item) in w.iter_mut().enumerate() {
-        *item = device.rsp.mem[(address as usize + i) & 0xFFF];
-    }
+    // Optimize for aligned access when possible
+    let addr_masked = address as usize & 0xFFF;
+    let value = if addr_masked <= 0xFFC {
+        u32::from_be_bytes(
+            device.rsp.mem[addr_masked..addr_masked + 4]
+                .try_into()
+                .unwrap(),
+        )
+    } else {
+        let mut value = 0;
+        for i in 0..4 {
+            value |= (device.rsp.mem[(addr_masked + i) & 0xFFF] as u32) << (8 * (3 - i));
+        }
+        value
+    };
 
-    device.rsp.cpu.gpr[rt(opcode) as usize] =
-        ((w[0] as u32) << 24) | ((w[1] as u32) << 16) | ((w[2] as u32) << 8) | (w[3] as u32)
+    device.rsp.cpu.gpr[rt(opcode) as usize] = value;
 }
 
 pub fn lbu(device: &mut device::Device, opcode: u32) {
@@ -336,24 +355,44 @@ pub fn lhu(device: &mut device::Device, opcode: u32) {
     let address =
         device.rsp.cpu.gpr[rs(opcode) as usize].wrapping_add(imm(opcode) as i16 as i32 as u32);
 
-    let mut w = [0; 2];
-    w[0] = device.rsp.mem[address as usize & 0xFFF];
-    w[1] = device.rsp.mem[(address as usize + 1) & 0xFFF];
+    // Optimize for aligned access when possible
+    let addr_masked = address as usize & 0xFFF;
+    let value = if addr_masked <= 0xFFE {
+        u16::from_be_bytes(
+            device.rsp.mem[addr_masked..addr_masked + 2]
+                .try_into()
+                .unwrap(),
+        )
+    } else {
+        let w0 = device.rsp.mem[addr_masked];
+        let w1 = device.rsp.mem[(addr_masked + 1) & 0xFFF];
+        ((w0 as u16) << 8) | w1 as u16
+    };
 
-    device.rsp.cpu.gpr[rt(opcode) as usize] = (((w[0] as u16) << 8) | w[1] as u16) as u32
+    device.rsp.cpu.gpr[rt(opcode) as usize] = value as u32;
 }
 
 pub fn lwu(device: &mut device::Device, opcode: u32) {
     let address =
         device.rsp.cpu.gpr[rs(opcode) as usize].wrapping_add(imm(opcode) as i16 as i32 as u32);
 
-    let mut w = [0; 4];
-    for (i, item) in w.iter_mut().enumerate() {
-        *item = device.rsp.mem[(address as usize + i) & 0xFFF];
-    }
+    // Optimize for aligned access when possible
+    let addr_masked = address as usize & 0xFFF;
+    let value = if addr_masked <= 0xFFC {
+        u32::from_be_bytes(
+            device.rsp.mem[addr_masked..addr_masked + 4]
+                .try_into()
+                .unwrap(),
+        )
+    } else {
+        let mut value = 0;
+        for i in 0..4 {
+            value |= (device.rsp.mem[(addr_masked + i) & 0xFFF] as u32) << (8 * (3 - i));
+        }
+        value
+    };
 
-    device.rsp.cpu.gpr[rt(opcode) as usize] =
-        ((w[0] as u32) << 24) | ((w[1] as u32) << 16) | ((w[2] as u32) << 8) | (w[3] as u32)
+    device.rsp.cpu.gpr[rt(opcode) as usize] = value;
 }
 
 pub fn sb(device: &mut device::Device, opcode: u32) {
@@ -367,18 +406,30 @@ pub fn sh(device: &mut device::Device, opcode: u32) {
     let address =
         device.rsp.cpu.gpr[rs(opcode) as usize].wrapping_add(imm(opcode) as i16 as i32 as u32);
 
-    device.rsp.mem[address as usize & 0xFFF] = (device.rsp.cpu.gpr[rt(opcode) as usize] >> 8) as u8;
-    device.rsp.mem[(address as usize + 1) & 0xFFF] =
-        (device.rsp.cpu.gpr[rt(opcode) as usize]) as u8;
+    let addr_masked = address as usize & 0xFFF;
+    let value = device.rsp.cpu.gpr[rt(opcode) as usize] as u16;
+    // Optimize for aligned access when possible
+    if addr_masked <= 0xFFE {
+        device.rsp.mem[addr_masked..addr_masked + 2].copy_from_slice(&value.to_be_bytes());
+    } else {
+        device.rsp.mem[addr_masked] = (value >> 8) as u8;
+        device.rsp.mem[(addr_masked + 1) & 0xFFF] = value as u8;
+    }
 }
 
 pub fn sw(device: &mut device::Device, opcode: u32) {
     let address =
         device.rsp.cpu.gpr[rs(opcode) as usize].wrapping_add(imm(opcode) as i16 as i32 as u32);
 
-    for i in 0..4 {
-        device.rsp.mem[(address as usize + i) & 0xFFF] =
-            (device.rsp.cpu.gpr[rt(opcode) as usize] >> ((3 - i) * 8)) as u8;
+    let addr_masked = address as usize & 0xFFF;
+    let value = device.rsp.cpu.gpr[rt(opcode) as usize];
+    // Optimize for aligned access when possible
+    if addr_masked <= 0xFFC {
+        device.rsp.mem[addr_masked..addr_masked + 4].copy_from_slice(&value.to_be_bytes());
+    } else {
+        for i in 0..4 {
+            device.rsp.mem[(addr_masked + i) & 0xFFF] = (value >> ((3 - i) * 8)) as u8;
+        }
     }
 }
 
@@ -737,10 +788,21 @@ pub fn llv(device: &mut device::Device, opcode: u32) {
     let mut element = velement(opcode);
 
     if element.is_multiple_of(4) {
-        let mut value = 0;
-        for i in 0..4 {
-            value |= (device.rsp.mem[((address + i) & 0xFFF) as usize] as u32) << (8 * (3 - i));
-        }
+        // Optimize for aligned access when possible
+        let addr_masked = address as usize & 0xFFF;
+        let value = if addr_masked <= 0xFFC {
+            u32::from_be_bytes(
+                device.rsp.mem[addr_masked..addr_masked + 4]
+                    .try_into()
+                    .unwrap(),
+            )
+        } else {
+            let mut value = 0;
+            for i in 0..4 {
+                value |= (device.rsp.mem[(addr_masked + i) & 0xFFF] as u32) << (8 * (3 - i));
+            }
+            value
+        };
         modify_vpr32(
             &mut device.rsp.cpu.vpr[rt(opcode) as usize],
             element / 4,
@@ -767,10 +829,21 @@ pub fn ldv(device: &mut device::Device, opcode: u32) {
     let mut element = velement(opcode);
 
     if element.is_multiple_of(8) {
-        let mut value = 0;
-        for i in 0..8 {
-            value |= (device.rsp.mem[((address + i) & 0xFFF) as usize] as u64) << (8 * (7 - i));
-        }
+        // Optimize for aligned access when possible
+        let addr_masked = address as usize & 0xFFF;
+        let value = if addr_masked <= 0xFF8 {
+            u64::from_be_bytes(
+                device.rsp.mem[addr_masked..addr_masked + 8]
+                    .try_into()
+                    .unwrap(),
+            )
+        } else {
+            let mut value = 0;
+            for i in 0..8 {
+                value |= (device.rsp.mem[(addr_masked + i) & 0xFFF] as u64) << (8 * (7 - i));
+            }
+            value
+        };
         modify_vpr64(
             &mut device.rsp.cpu.vpr[rt(opcode) as usize],
             element / 8,
@@ -797,10 +870,21 @@ pub fn lqv(device: &mut device::Device, opcode: u32) {
     let mut element = velement(opcode);
 
     if element == 0 && address.is_multiple_of(16) {
-        let mut value = 0;
-        for i in 0..16 {
-            value |= (device.rsp.mem[((address + i) & 0xFFF) as usize] as u128) << (8 * (15 - i));
-        }
+        // Optimize for aligned 16-byte access
+        let addr_masked = address as usize & 0xFFF;
+        let value = if addr_masked <= 0xFF0 {
+            u128::from_be_bytes(
+                device.rsp.mem[addr_masked..addr_masked + 16]
+                    .try_into()
+                    .unwrap(),
+            )
+        } else {
+            let mut value = 0;
+            for i in 0..16 {
+                value |= (device.rsp.mem[(addr_masked + i) & 0xFFF] as u128) << (8 * (15 - i));
+            }
+            value
+        };
         modify_vpr128(&mut device.rsp.cpu.vpr[rt(opcode) as usize], value);
     } else {
         let end = std::cmp::min(16 + element - ((address & 15) as u8), 16);
@@ -823,10 +907,21 @@ pub fn lrv(device: &mut device::Device, opcode: u32) {
     let mut element = 16u8.wrapping_sub(((address & 15) as u8).wrapping_sub(velement(opcode)));
     address &= !15;
     if element == 0 {
-        let mut value = 0;
-        for i in 0..16 {
-            value |= (device.rsp.mem[((address + i) & 0xFFF) as usize] as u128) << (8 * (15 - i));
-        }
+        // Optimize for aligned 16-byte access
+        let addr_masked = address as usize & 0xFFF;
+        let value = if addr_masked <= 0xFF0 {
+            u128::from_be_bytes(
+                device.rsp.mem[addr_masked..addr_masked + 16]
+                    .try_into()
+                    .unwrap(),
+            )
+        } else {
+            let mut value = 0;
+            for i in 0..16 {
+                value |= (device.rsp.mem[(addr_masked + i) & 0xFFF] as u128) << (8 * (15 - i));
+            }
+            value
+        };
         modify_vpr128(&mut device.rsp.cpu.vpr[rt(opcode) as usize], value);
     } else {
         while element < 16 {

src/device/si.rs

@@ -1,6 +1,6 @@
-use rand_chacha::rand_core::RngCore;
-
 use crate::device;
+use crate::ui;
+use rand::Rng;
 
 const SI_DRAM_ADDR_REG: u32 = 0;
 const SI_PIF_ADDR_RD64B_REG: u32 = 1;
@@ -38,7 +38,7 @@ pub fn read_regs(
     device.si.regs[((address & 0xFFFF) >> 2) as usize]
 }
 
-fn randomize_interrupt_time(rng: &mut rand_chacha::ChaCha8Rng) -> u64 {
+fn randomize_interrupt_time(rng: &mut rand::rngs::Xoshiro256PlusPlus) -> u64 {
     rng.next_u64() % 0x100
 }
 
@@ -90,7 +90,7 @@ fn copy_pif_rdram(device: &mut device::Device) {
                     .rdram
                     .mem
                     .get(dram_addr + i..dram_addr + i + 4)
-                    .unwrap_or_default()
+                    .unwrap_or(&[0; 4])
                     .try_into()
                     .unwrap_or_default(),
             );
@@ -98,6 +98,8 @@ fn copy_pif_rdram(device: &mut device::Device) {
             i += 4;
         }
     } else if device.si.dma_dir == DmaDir::Read {
+        // check RDP before SI writes to RDRAM
+        ui::video::check_framebuffers(dram_addr as u32, device::pif::PIF_RAM_SIZE as u32);
         let mut i = 0;
         while i < device::pif::PIF_RAM_SIZE {
             let data = u32::from_be_bytes(device.pif.ram[i..i + 4].try_into().unwrap());

src/device/vi.rs

@@ -1,5 +1,4 @@
-use crate::{cheats, device, netplay, ui};
-use governor::clock::Clock;
+use crate::{cheats, device, netplay, retroachievements, ui};
 
 const VI_STATUS_REG: u32 = 0;
 const VI_ORIGIN_REG: u32 = 1;
@@ -24,12 +23,10 @@ pub struct Vi {
     pub delay: u64,
     pub field: u32,
     #[serde(skip)]
-    pub limiter: Option<governor::DefaultDirectRateLimiter>,
+    pub next_pace_deadline: Option<std::time::Instant>,
     pub count_per_scanline: u64,
     pub enable_speed_limiter: bool,
     pub vi_counter: u64,
-    pub last_origin: u32,
-    pub internal_frame_counter: u64,
     pub min_wait_time: std::time::Duration,
     pub frame_time: f64,
     pub limit_freq: u64,
@@ -50,17 +47,11 @@ pub fn set_expected_refresh_rate(device: &mut device::Device) {
     device.vi.count_per_scanline =
         device.vi.delay / (device.vi.regs[VI_V_SYNC_REG as usize] + 1) as u64;
 
-    create_limiter(device);
+    reset_pace_deadline(device);
 }
 
-fn create_limiter(device: &mut device::Device) {
-    let quota = governor::Quota::with_period(std::time::Duration::from_secs_f64(
-        device.vi.frame_time * device.vi.limit_freq as f64,
-    ))
-    .unwrap();
-    device.vi.limiter = Some(governor::RateLimiter::direct(quota));
-    let _ = device.vi.limiter.as_ref().unwrap().check();
-    //println!("new limit freq: {}", device.vi.limit_freq);
+fn reset_pace_deadline(device: &mut device::Device) {
+    device.vi.next_pace_deadline = None;
 }
 
 fn set_vertical_interrupt(device: &mut device::Device) {
@@ -70,13 +61,10 @@ fn set_vertical_interrupt(device: &mut device::Device) {
 }
 
 fn set_current_line(device: &mut device::Device) {
-    let delay = device.vi.delay;
-    let next_vi = device::events::get_event(device, device::events::EVENT_TYPE_VI);
-    if let Some(next_vi) = next_vi {
-        device.vi.regs[VI_CURRENT_REG as usize] = ((delay
-            - (next_vi.count - device.cpu.cop0.regs[device::cop0::COP0_COUNT_REG as usize]))
-            / device.vi.count_per_scanline)
-            as u32;
+    if let Some(next_vi) = device::events::get_event(device, device::events::EVENT_TYPE_VI) {
+        device.vi.regs[VI_CURRENT_REG as usize] = ((device.vi.delay.saturating_sub(
+            next_vi.count - device.cpu.cop0.regs[device::cop0::COP0_COUNT_REG as usize],
+        )) / device.vi.count_per_scanline) as u32;
 
         // wrap around VI_CURRENT_REG if needed
         if device.vi.regs[VI_CURRENT_REG as usize] >= device.vi.regs[VI_V_SYNC_REG as usize] {
@@ -120,10 +108,10 @@ pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u
             }
         }
         VI_ORIGIN_REG => {
+            let current_origin = device.vi.regs[reg as usize];
             device::memory::masked_write_32(&mut device.vi.regs[reg as usize], value, mask);
-            if device.vi.regs[reg as usize] != device.vi.last_origin {
-                device.vi.last_origin = device.vi.regs[reg as usize];
-                device.vi.internal_frame_counter += 1;
+            if current_origin != device.vi.regs[reg as usize] {
+                let _ = device.ui.video.fps_tx.try_send(true);
             }
         }
         _ => {
@@ -137,29 +125,41 @@ pub fn vertical_interrupt_event(device: &mut device::Device) {
     if device.cheats.enabled {
         cheats::execute_cheats(device, device.cheats.cheats.clone());
     }
-    let mut speed_limiter_toggled = ui::video::check_callback(device);
 
-    if device.netplay.is_some() {
-        netplay::send_sync_check(device);
-        if device.vi.enable_speed_limiter == device.netplay.as_ref().unwrap().fast_forward {
+    ui::video::render_frame();
+    let _ = device.ui.video.vis_tx.try_send(true);
+
+    retroachievements::do_frame();
+
+    let (mut speed_limiter_toggled, paused) = ui::video::check_callback(device);
+
+    if let Some(netplay) = &mut device.netplay {
+        netplay::send_sync_check(netplay, device.cpu.cop0.regs.as_ref());
+        if device.vi.enable_speed_limiter == netplay.fast_forward {
             speed_limiter_toggled = true;
-            device.vi.enable_speed_limiter = !device.netplay.as_ref().unwrap().fast_forward;
+            device.vi.enable_speed_limiter = !netplay.fast_forward;
         }
     }
 
-    device.vi.vi_counter += 1;
     if device.vi.vi_counter.is_multiple_of(device.vi.limit_freq) && device.vi.enable_speed_limiter {
         speed_limiter(device, speed_limiter_toggled);
     }
-    ui::video::update_screen();
 
-    /*
-    let vis = if device.cart.pal { 50 } else { 60 };
-    if device.vi.vi_counter % vis == 0 {
-        println!("FPS: {}", device.vi.internal_frame_counter);
-        device.vi.internal_frame_counter = 0;
+    ui::video::update_screen();
+    device.vi.vi_counter += 1;
+
+    if device.netplay.is_none() && paused {
+        if retroachievements::get_hardcore() {
+            ui::video::onscreen_message(
+                "Cannot pause in RA hardcore mode",
+                ui::video::MESSAGE_LENGTH_MESSAGE_SHORT,
+            );
+        } else {
+            ui::video::pause_loop(device.vi.frame_time);
+        }
     }
-    */
+
+    unsafe { sdl3_sys::events::SDL_PumpEvents() };
 
     /* toggle vi field if in interlaced mode */
     device.vi.field ^= (device.vi.regs[VI_STATUS_REG as usize] >> 6) & 0x1;
@@ -181,35 +181,51 @@ pub fn init(device: &mut device::Device) {
     }
 }
 
-fn speed_limiter(device: &mut device::Device, speed_limiter_toggled: bool) {
-    let result = device.vi.limiter.as_ref().unwrap().check();
-    if let Err(outcome) = result {
-        let dur = outcome.wait_time_from(governor::clock::DefaultClock::default().now());
-        spin_sleep::sleep(dur);
-        if dur < device.vi.min_wait_time {
-            device.vi.min_wait_time = dur;
-        }
+fn speed_limiter(device: &mut device::Device, mut speed_limiter_toggled: bool) {
+    let interval =
+        std::time::Duration::from_secs_f64(device.vi.frame_time * device.vi.limit_freq as f64);
 
-        let _ = device.vi.limiter.as_ref().unwrap().check();
-    } else {
-        device.vi.min_wait_time = std::time::Duration::from_secs(0);
+    let now = std::time::Instant::now();
+    match device.vi.next_pace_deadline {
+        None => {
+            device.vi.next_pace_deadline = Some(now + interval);
+            speed_limiter_toggled = true;
+        }
+        Some(deadline) => {
+            if now < deadline {
+                let dur = deadline - now;
+                spin_sleep::sleep(dur);
+                if dur < device.vi.min_wait_time {
+                    device.vi.min_wait_time = dur;
+                }
+            } else {
+                //println!("did not sleep");
+                device.vi.min_wait_time = std::time::Duration::from_secs(0);
+            }
+            let mut next = deadline + interval;
+            let t = std::time::Instant::now();
+            while next <= t {
+                next += interval;
+            }
+            device.vi.next_pace_deadline = Some(next);
+        }
     }
 
-    if std::time::Instant::now()
-        .duration_since(device.vi.limit_freq_check)
-        .as_secs_f64()
-        > 1.0
+    if std::time::Instant::now().duration_since(device.vi.limit_freq_check)
+        > std::time::Duration::from_secs(1)
     {
         if !speed_limiter_toggled {
-            if device.vi.min_wait_time.as_secs_f64() == 0.0 && device.vi.limit_freq < MAX_LIMIT_FREQ
+            if device.vi.min_wait_time == std::time::Duration::from_secs(0)
+                && device.vi.limit_freq < MAX_LIMIT_FREQ
             {
                 device.vi.limit_freq += 1;
-                create_limiter(device);
-            } else if device.vi.min_wait_time.as_secs_f64() > device.vi.frame_time
+                reset_pace_deadline(device);
+            } else if device.vi.min_wait_time
+                > std::time::Duration::from_secs_f64(device.vi.frame_time)
                 && device.vi.limit_freq > 1
             {
                 device.vi.limit_freq -= 1;
-                create_limiter(device);
+                reset_pace_deadline(device);
             }
         }
 

src/main.rs

@@ -6,172 +6,305 @@ static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 mod cheats;
 mod device;
 mod netplay;
+mod retroachievements;
 mod savestates;
 mod ui;
 use clap::Parser;
-use ui::gui;
+use std::io::Error;
 
 /// N64 emulator
 #[derive(Parser, Debug)]
-#[command(author, version, about, long_about = None)]
+#[command(author, version=env!("GIT_DESCRIBE"), about, long_about = None, arg_required_else_help = if cfg!(feature = "gui") { false } else { true })]
 struct Args {
     game: Option<String>,
     #[arg(short, long)]
     fullscreen: bool,
+    #[arg(long)]
+    overclock: Option<bool>,
+    #[arg(long)]
+    disable_expansion_pak: Option<bool>,
+    #[arg(long, value_name = "CHEATS_FILE", hide = true)]
+    cheats: Option<String>,
+    #[arg(long, value_name = "NETPLAY_PEER_ADDR", hide = true)]
+    netplay_peer_addr: Option<String>,
+    #[arg(long, value_name = "NETPLAY_PLAYER_NUMBER", hide = true)]
+    netplay_player_number: Option<u8>,
     #[arg(
-        short,
         long,
         value_name = "PROFILE_NAME",
-        help = "Create a new input profile (keyboard/gamepad mappings)."
+        help = "Create a new input profile (keyboard/gamepad mappings)"
     )]
     configure_input_profile: Option<String>,
-    #[arg(
-        short,
-        long,
-        help = "Use DirectInput when configuring a new input profile."
-    )]
+    #[arg(long, help = "Use DirectInput when configuring a new input profile")]
     use_dinput: bool,
     #[arg(
-        short,
+        long,
+        value_name = "DEADZONE_PERCENTAGE",
+        help = "Used along with --configure-input-profile to set the deadzone for analog sticks"
+    )]
+    deadzone: Option<i32>,
+    #[arg(
         long,
         value_name = "PROFILE_NAME",
         help = "Must also specify --port. Used to bind a previously created profile to a port"
     )]
     bind_input_profile: Option<String>,
     #[arg(
-        short,
         long,
         help = "Lists connected controllers which can be used in --assign-controller"
     )]
     list_controllers: bool,
     #[arg(
-        short,
         long,
         value_name = "CONTROLLER_NUMBER",
         help = "Must also specify --port. Used to assign a controller listed in --list-controllers to a port"
     )]
     assign_controller: Option<i32>,
     #[arg(
-        short,
         long,
         value_name = "PORT",
         help = "Valid values: 1-4. To be used alongside --bind-input-profile and --assign-controller"
     )]
     port: Option<usize>,
     #[arg(
-        short = 'z',
         long,
         help = "Clear all input profile bindings and controller assignments"
     )]
     clear_input_bindings: bool,
+    #[arg(
+        long,
+        value_name = "SLOT",
+        help = "Load savestate from slot 0-9 when starting the game"
+    )]
+    load_state: Option<u32>,
+    #[arg(
+        long = "ra-username",
+        value_name = "USERNAME",
+        help = "Username for RetroAchievements"
+    )]
+    ra_username: Option<String>,
+    #[arg(
+        long = "ra-token",
+        value_name = "TOKEN",
+        help = "Token for RetroAchievements",
+        hide = true
+    )]
+    ra_token: Option<String>,
+    #[arg(
+        long = "ra-password",
+        value_name = "PASSWORD",
+        help = "Password for RetroAchievements"
+    )]
+    ra_password: Option<String>,
+    #[arg(
+        long = "ra-hardcore",
+        help = "Enable Hardcore mode for RetroAchievements"
+    )]
+    ra_hardcore: bool,
+    #[arg(
+        long = "ra-challenge",
+        help = "Enable Challenge Indicators for RetroAchievements"
+    )]
+    ra_challenge: bool,
+    #[arg(
+        long = "ra-leaderboard",
+        help = "Enable Leaderboard Trackers for RetroAchievements"
+    )]
+    ra_leaderboard: bool,
 }
 
-#[tokio::main]
-async fn main() {
+#[tokio::main(worker_threads = 4)]
+async fn main() -> std::io::Result<()> {
     let dirs = ui::get_dirs();
 
-    let mut result = std::fs::create_dir_all(dirs.config_dir);
-    if result.is_err() {
-        panic!("could not create config dir: {}", result.err().unwrap())
-    }
-    result = std::fs::create_dir_all(dirs.data_dir.join("saves"));
-    if result.is_err() {
-        panic!("could not create save dir: {}", result.err().unwrap())
-    }
-    result = std::fs::create_dir_all(dirs.data_dir.join("states"));
-    if result.is_err() {
-        panic!("could not create state dir: {}", result.err().unwrap())
-    }
-
+    std::fs::create_dir_all(dirs.config_dir)?;
+    std::fs::create_dir_all(dirs.cache_dir)?;
+    std::fs::create_dir_all(dirs.data_dir.join("saves"))?;
+    std::fs::create_dir_all(dirs.data_dir.join("states"))?;
     let args = Args::parse();
-    let args_as_strings: Vec<String> = std::env::args().collect();
-    let args_count = args_as_strings.len();
-    if args_count > 1 && args.game.is_none() {
-        let mut ui = ui::Ui::new();
+    if let Some(game) = args.game {
+        let file_path = std::path::Path::new(&game);
+        let Some(rom_contents) = device::get_rom_contents(file_path) else {
+            return Err(Error::other(format!(
+                "Could not read ROM file: {}",
+                file_path.display()
+            )));
+        };
 
-        if args.clear_input_bindings {
-            ui::input::clear_bindings(&mut ui);
-            return;
+        if let Some(slot) = args.load_state
+            && slot > 9
+        {
+            return Err(Error::other("Savestate slot must be between 0 and 9"));
         }
-        if args.port.is_some() {
-            let port = args.port.unwrap();
-            if !(1..=4).contains(&port) {
-                println!("Port must be betwen 1 and 4");
-                return;
-            }
-        }
-        if args.list_controllers {
-            let controllers = ui::input::get_controller_names(&ui);
-            for (i, controller) in controllers.iter().enumerate() {
-                println!("Controller {i}: {controller}");
-            }
-            return;
-        }
-        if args.configure_input_profile.is_some() {
-            ui::input::configure_input_profile(
-                &mut ui,
-                args.configure_input_profile.unwrap(),
-                args.use_dinput,
-            );
-            return;
-        }
-        if args.assign_controller.is_some() {
-            if args.port.is_none() {
-                println!("Must specify port number");
-                return;
-            }
-            ui::input::assign_controller(
-                &mut ui,
-                args.assign_controller.unwrap(),
-                args.port.unwrap(),
-            );
-        }
-        if args.bind_input_profile.is_some() {
-            if args.port.is_none() {
-                println!("Must specify port number");
-                return;
-            }
-            ui::input::bind_input_profile(
-                &mut ui,
-                args.bind_input_profile.unwrap(),
-                args.port.unwrap(),
-            );
-        }
-    } else if args.game.is_some() {
-        let file_path = std::path::Path::new(args.game.as_ref().unwrap());
-        if let Some(rom_contents) = device::get_rom_contents(file_path) {
-            let handle = std::thread::Builder::new()
-                .name("n64".to_string())
-                .stack_size(env!("N64_STACK_SIZE").parse().unwrap())
-                .spawn(move || {
-                    let mut device = device::Device::new();
-                    let overclock = device.ui.config.emulation.overclock;
-                    let disable_expansion_pak = device.ui.config.emulation.disable_expansion_pak;
 
-                    let game_cheats = {
-                        let game_crc = ui::storage::get_game_crc(&rom_contents);
-                        let cheats = ui::config::Cheats::new();
-                        cheats.cheats.get(&game_crc).cloned().unwrap_or_default()
-                    };
-                    device::run_game(
-                        &mut device,
-                        rom_contents,
-                        ui::gui::GameSettings {
-                            fullscreen: args.fullscreen,
-                            overclock,
-                            disable_expansion_pak,
-                            cheats: game_cheats,
-                        },
-                    );
-                })
-                .unwrap();
+        let mut device = device::Device::new();
 
-            handle.join().unwrap();
+        device.ui.config.recent_roms.retain(|x| *x != game);
+        device.ui.config.recent_roms.insert(0, game);
+        device.ui.config.recent_roms.truncate(5);
+
+        if args.fullscreen {
+            device.ui.video.fullscreen = true;
         } else {
-            println!("Could not read rom file");
-            return;
+            device.ui.video.fullscreen = device.ui.config.video.fullscreen;
+        }
+        let overclock = args
+            .overclock
+            .unwrap_or(device.ui.config.emulation.overclock);
+        let disable_expansion_pak = args
+            .disable_expansion_pak
+            .unwrap_or(device.ui.config.emulation.disable_expansion_pak);
+        let cheats = if let Some(cheats_file) = args.cheats
+            && let Ok(data) = std::fs::read(cheats_file)
+            && let Ok(cheats) = serde_json::from_slice(&data)
+        {
+            cheats
+        } else {
+            let game_crc = ui::storage::get_game_crc(&rom_contents);
+            ui::config::Cheats::new()
+                .cheats
+                .get(&game_crc)
+                .cloned()
+                .unwrap_or_default()
+        };
+
+        let mut shutdown_tx = None;
+
+        if let Some(peer_addr) = args.netplay_peer_addr
+            && let Some(player_number) = args.netplay_player_number
+        {
+            device.netplay = Some(netplay::init(peer_addr.parse().unwrap(), player_number));
+        } else {
+            for i in 0..4 {
+                if device.ui.config.input.transfer_pak[i]
+                    && !device.ui.config.input.gb_rom_path[i].is_empty()
+                    && !device.ui.config.input.gb_ram_path[i].is_empty()
+                    && let Ok(rom) = std::fs::read(&device.ui.config.input.gb_rom_path[i])
+                    && let Ok(ram) = std::fs::read(&device.ui.config.input.gb_ram_path[i])
+                {
+                    device.transferpaks[i].cart.rom = rom;
+                    device.transferpaks[i].cart.ram = ram;
+                }
+            }
+
+            if device.ui.config.emulation.usb {
+                (shutdown_tx, device.ui.usb) = ui::usb::init();
+            }
+
+            if let Some(username) = args.ra_username {
+                retroachievements::init_client(
+                    if cfg!(ra_hardcore_enabled) {
+                        args.ra_hardcore
+                    } else {
+                        false
+                    },
+                    args.ra_challenge,
+                    args.ra_leaderboard,
+                );
+
+                let (tx, rx) = tokio::sync::oneshot::channel::<bool>();
+                if let Some(password) = args.ra_password {
+                    retroachievements::login_user(username, password, tx);
+                } else if let Some(token) = args.ra_token {
+                    retroachievements::login_token_user(username, token, tx);
+                } else {
+                    tx.send(false).unwrap();
+                }
+
+                rx.await.unwrap();
+            }
+        }
+
+        retroachievements::load_game(&rom_contents, rom_contents.len()).await;
+        device::run_game(
+            &mut device,
+            &rom_contents,
+            ui::GameSettings {
+                overclock,
+                disable_expansion_pak,
+                cheats,
+                load_savestate_slot: args.load_state,
+            },
+        );
+        retroachievements::shutdown_client();
+
+        if device.netplay.is_some() {
+            netplay::close(&mut device);
+        } else {
+            for i in 0..4 {
+                if device.ui.config.input.transfer_pak[i]
+                    && !device.ui.config.input.gb_ram_path[i].is_empty()
+                    && !device.transferpaks[i].cart.ram.is_empty()
+                    && let Err(e) = tokio::fs::write(
+                        &device.ui.config.input.gb_ram_path[i],
+                        &device.transferpaks[i].cart.ram,
+                    )
+                    .await
+                {
+                    eprintln!("Error writing GB RAM: {}", e);
+                }
+            }
+        }
+        if let Some(shutdown_tx) = &shutdown_tx {
+            ui::usb::close(shutdown_tx);
+        }
+    } else if std::env::args().count() > 1 {
+        let mut config = ui::config::Config::new();
+
+        if let Some(profile) = args.configure_input_profile {
+            ui::input::configure_input_profile(
+                &mut config,
+                profile,
+                args.use_dinput,
+                args.deadzone.unwrap_or(ui::input::DEADZONE_DEFAULT),
+            );
+
+            ui::sdl_close();
+            return Ok(());
+        } else {
+            if args.clear_input_bindings {
+                ui::input::clear_bindings(&mut config);
+                return Ok(());
+            }
+            if let Some(port) = args.port
+                && !(1..=4).contains(&port)
+            {
+                return Err(Error::other("Port must be between 1 and 4"));
+            }
+
+            ui::sdl_init(sdl3_sys::init::SDL_INIT_GAMEPAD);
+
+            if args.list_controllers {
+                let controllers = ui::input::get_controller_names();
+                for (i, controller) in controllers.iter().enumerate() {
+                    println!("Controller {i}: {controller}");
+                }
+            } else {
+                if let Some(assign_controller) = args.assign_controller {
+                    let Some(port) = args.port else {
+                        ui::sdl_close();
+                        return Err(Error::other("Must specify port number"));
+                    };
+                    ui::input::assign_controller(&mut config, assign_controller - 1, port);
+                }
+                if let Some(profile) = args.bind_input_profile {
+                    let Some(port) = args.port else {
+                        ui::sdl_close();
+                        return Err(Error::other("Must specify port number"));
+                    };
+                    ui::input::bind_input_profile(&mut config, profile, port);
+                }
+            }
         }
     } else {
-        gui::app_window();
+        #[cfg(feature = "gui")]
+        {
+            retroachievements::init_client(false, false, false);
+            ui::gui::app_window();
+            retroachievements::shutdown_client();
+        }
     }
+
+    ui::sdl_close();
+    Ok(())
 }

src/netplay.rs

@@ -46,14 +46,6 @@ struct InputEvent {
     plugin: u8,
 }
 
-pub const NETPLAY_ERROR_DESYNC: u32 = 0;
-pub const NETPLAY_ERROR_LOST_CONNECTION: u32 = 1;
-pub const NETPLAY_ERROR_PLAYER_DISCONNECTED: u32 = 2;
-pub const NETPLAY_ERROR_PLAYER_1_DISCONNECTED: u32 = 3;
-pub const NETPLAY_ERROR_PLAYER_2_DISCONNECTED: u32 = 4;
-pub const NETPLAY_ERROR_PLAYER_3_DISCONNECTED: u32 = 5;
-pub const NETPLAY_ERROR_PLAYER_4_DISCONNECTED: u32 = 6;
-
 pub fn send_rtc(netplay: &mut Netplay, rtc: i64) {
     let mut request: Vec<u8> = [TCP_SEND_RTC].to_vec();
     let size: u32 = 8;
@@ -93,7 +85,7 @@ pub fn send_save(netplay: &mut Netplay, save_type: &str, save_data: &[u8], size:
     request.extend_from_slice(&(size as u32).to_be_bytes());
 
     if size > 0 {
-        request.extend(save_data.to_owned());
+        request.extend_from_slice(save_data);
     }
     netplay.tcp_stream.write_all(&request).unwrap();
 }
@@ -111,14 +103,13 @@ pub fn receive_save(netplay: &mut Netplay, save_type: &str, save_data: &mut Vec<
     *save_data = response;
 }
 
-pub fn send_sync_check(device: &mut device::Device) {
-    let netplay = device.netplay.as_mut().unwrap();
+pub fn send_sync_check(netplay: &mut Netplay, regs: &[u64]) {
     if netplay.vi_counter.is_multiple_of(600) {
         let mut request: Vec<u8> = [UDP_SYNC_DATA].to_vec();
         request.extend_from_slice(&(netplay.vi_counter).to_be_bytes());
 
-        for i in 0..device::cop0::COP0_REGS_COUNT as usize {
-            request.extend_from_slice(&(device.cpu.cop0.regs[i] as u32).to_be_bytes());
+        for item in regs.iter() {
+            request.extend_from_slice(&(*item as u32).to_be_bytes());
         }
 
         netplay.udp_socket.send(&request).unwrap();
@@ -144,7 +135,7 @@ pub fn get_input(device: &mut device::Device, channel: usize) -> ui::input::Inpu
     let timeout = std::time::Instant::now() + std::time::Duration::from_secs(10);
     let mut request_timer = std::time::Instant::now() - std::time::Duration::from_millis(5);
     while input.is_none() {
-        process_incoming(netplay, &device.ui); // we execute process_incoming before request_input so that we send an accurate buffer count
+        process_incoming(netplay); // we execute process_incoming before request_input so that we send an accurate buffer count
         if std::time::Instant::now() > request_timer {
             // sends a request packet every 5ms
             request_input(netplay, channel);
@@ -155,7 +146,10 @@ pub fn get_input(device: &mut device::Device, channel: usize) -> ui::input::Inpu
             .remove(&netplay.player_data[channel].count);
 
         if std::time::Instant::now() > timeout {
-            ui::audio::play_netplay_audio(&device.ui, NETPLAY_ERROR_LOST_CONNECTION);
+            ui::video::onscreen_message(
+                "Lost connection to netplay server",
+                ui::video::MESSAGE_LENGTH_MESSAGE_SHORT,
+            );
             input = Some(InputEvent {
                 input: 0,
                 plugin: 0,
@@ -186,9 +180,9 @@ fn request_input(netplay: &Netplay, channel: usize) {
     netplay.udp_socket.send(&request).unwrap();
 }
 
-fn process_incoming(netplay: &mut Netplay, ui: &ui::Ui) {
+fn process_incoming(netplay: &mut Netplay) {
     let mut buf: [u8; 1024] = [0; 1024];
-    while let Ok(_incoming) = netplay.udp_socket.recv(&mut buf) {
+    while netplay.udp_socket.recv(&mut buf).is_ok() {
         match buf[0] {
             UDP_RECEIVE_KEY_INFO | UDP_RECEIVE_KEY_INFO_GRATUITOUS => {
                 let player = buf[1] as usize;
@@ -200,14 +194,17 @@ fn process_incoming(netplay: &mut Netplay, ui: &ui::Ui) {
                 }
                 if current_status != netplay.status {
                     if ((current_status & 0x1) ^ (netplay.status & 0x1)) != 0 {
-                        ui::audio::play_netplay_audio(ui, NETPLAY_ERROR_DESYNC);
+                        ui::video::onscreen_message(
+                            "Netplay desync detected",
+                            ui::video::MESSAGE_LENGTH_MESSAGE_LONG,
+                        );
                     }
                     for dis in 1..5 {
                         if ((current_status & (0x1 << dis)) ^ (netplay.status & (0x1 << dis))) != 0
                         {
-                            ui::audio::play_netplay_audio(
-                                ui,
-                                NETPLAY_ERROR_PLAYER_DISCONNECTED + dis,
+                            ui::video::onscreen_message(
+                                &format!("Player {dis} disconnected"),
+                                ui::video::MESSAGE_LENGTH_MESSAGE_SHORT,
                             );
                         }
                     }

src/retroachievements.rs

@@ -0,0 +1,239 @@
+include!(concat!(env!("OUT_DIR"), "/retroachievements_bindings.rs"));
+
+use crate::ui;
+
+#[derive(serde::Serialize, serde::Deserialize)]
+pub struct RAConfig {
+    pub username: String,
+    pub token: String,
+    pub enabled: bool,
+    pub hardcore: bool,
+    pub challenge: bool,
+    pub leaderboard: bool,
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn notify_load_game(ctx: *mut std::ffi::c_void) {
+    let tx = unsafe { Box::from_raw(ctx as *mut tokio::sync::oneshot::Sender<bool>) };
+    tx.send(true).unwrap();
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn store_retroachievements_credentials(
+    c_username: *const std::ffi::c_char,
+    c_token: *const std::ffi::c_char,
+    ctx: *mut std::ffi::c_void,
+) {
+    let tx = unsafe { Box::from_raw(ctx as *mut tokio::sync::oneshot::Sender<bool>) };
+
+    if c_username.is_null() || c_token.is_null() {
+        tx.send(false).unwrap();
+        return;
+    }
+
+    let file_path = ui::get_dirs().config_dir.join("retroachievements.json");
+    let raconfig = if let Ok(ra_config) = std::fs::read(&file_path)
+        && let Ok(result) = serde_json::from_slice::<RAConfig>(ra_config.as_ref())
+    {
+        RAConfig {
+            username: unsafe { std::ffi::CStr::from_ptr(c_username).to_str().unwrap() }.to_string(),
+            token: unsafe { std::ffi::CStr::from_ptr(c_token).to_str().unwrap() }.to_string(),
+            enabled: result.enabled,
+            hardcore: result.hardcore,
+            challenge: result.challenge,
+            leaderboard: result.leaderboard,
+        }
+    } else {
+        RAConfig {
+            username: unsafe { std::ffi::CStr::from_ptr(c_username).to_str().unwrap() }.to_string(),
+            token: unsafe { std::ffi::CStr::from_ptr(c_token).to_str().unwrap() }.to_string(),
+            enabled: false,
+            hardcore: false,
+            challenge: false,
+            leaderboard: false,
+        }
+    };
+    let f = std::fs::File::create(&file_path).unwrap();
+    serde_json::to_writer_pretty(f, &raconfig).unwrap();
+
+    tx.send(true).unwrap();
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn rust_server_call(
+    c_url: *const std::ffi::c_char,
+    c_post_data: *const std::ffi::c_char,
+    c_content_type: *const std::ffi::c_char,
+    c_callback: *mut std::ffi::c_void,
+    c_callback_data: *mut std::ffi::c_void,
+) {
+    let url = unsafe { std::ffi::CStr::from_ptr(c_url).to_str().unwrap() }.to_string();
+
+    let task = if !c_post_data.is_null() {
+        let post_data =
+            unsafe { std::ffi::CStr::from_ptr(c_post_data).to_str().unwrap() }.to_string();
+        let content_type =
+            unsafe { std::ffi::CStr::from_ptr(c_content_type).to_str().unwrap() }.to_string();
+        ui::WEB_CLIENT
+            .post(url)
+            .body(post_data)
+            .header(reqwest::header::CONTENT_TYPE, content_type)
+            .send()
+    } else {
+        ui::WEB_CLIENT.get(url).send()
+    };
+    let callback = c_callback.addr();
+    let callback_data = c_callback_data.addr();
+    tokio::spawn(async move {
+        let response = task.await;
+        match response {
+            Ok(response) => {
+                let status = response.status().as_u16() as i32;
+                match response.text().await {
+                    Ok(text) => {
+                        let c_text = std::ffi::CString::new(text).unwrap();
+                        unsafe {
+                            ra_http_callback(
+                                c_text.as_ptr(),
+                                c_text.count_bytes(),
+                                status,
+                                callback as *mut std::ffi::c_void,
+                                callback_data as *mut std::ffi::c_void,
+                            )
+                        };
+                    }
+                    Err(error) => {
+                        let c_error = std::ffi::CString::new(error.to_string()).unwrap();
+                        unsafe {
+                            ra_http_callback(
+                                c_error.as_ptr(),
+                                c_error.count_bytes(),
+                                status,
+                                callback as *mut std::ffi::c_void,
+                                callback_data as *mut std::ffi::c_void,
+                            )
+                        };
+                    }
+                }
+            }
+            Err(error) => {
+                let c_error = std::ffi::CString::new(error.to_string()).unwrap();
+                unsafe {
+                    ra_http_callback(
+                        c_error.as_ptr(),
+                        c_error.count_bytes(),
+                        0,
+                        callback as *mut std::ffi::c_void,
+                        callback_data as *mut std::ffi::c_void,
+                    )
+                };
+            }
+        }
+    });
+}
+
+pub async fn load_game(rom: &[u8], rom_size: usize) {
+    let (tx, rx) = tokio::sync::oneshot::channel::<bool>();
+    unsafe {
+        let tx_ptr = Box::into_raw(Box::new(tx)) as *mut std::ffi::c_void;
+        ra_load_game(rom.as_ptr(), rom_size, tx_ptr);
+    };
+    rx.await.unwrap();
+}
+
+pub fn unload_game() {
+    unsafe { ra_unload_game() };
+}
+
+pub fn welcome() {
+    unsafe { ra_welcome() };
+}
+
+pub fn set_dmem(dmem: *const u8, dmem_size: usize) {
+    unsafe { ra_set_dmem(dmem, dmem_size) };
+}
+
+pub fn do_frame() {
+    unsafe { ra_do_frame() };
+}
+
+pub fn do_idle() {
+    unsafe { ra_do_idle() };
+}
+
+pub fn init_client(hardcore: bool, challenge: bool, leaderboard: bool) {
+    unsafe { ra_init_client(hardcore, challenge, leaderboard) };
+}
+
+pub fn shutdown_client() {
+    unsafe { ra_shutdown_client() };
+}
+
+pub fn get_hardcore() -> bool {
+    unsafe { ra_get_hardcore() }
+}
+
+pub fn login_user(username: String, password: String, tx: tokio::sync::oneshot::Sender<bool>) {
+    unsafe {
+        let tx_ptr = Box::into_raw(Box::new(tx)) as *mut std::ffi::c_void;
+        let c_username = std::ffi::CString::new(username).unwrap();
+        let c_password = std::ffi::CString::new(password).unwrap();
+        ra_login_user(c_username.as_ptr(), c_password.as_ptr(), tx_ptr)
+    };
+}
+
+#[cfg(feature = "gui")]
+pub fn logout_user() {
+    unsafe { ra_logout_user() };
+}
+
+pub fn login_token_user(username: String, token: String, tx: tokio::sync::oneshot::Sender<bool>) {
+    unsafe {
+        let tx_ptr = Box::into_raw(Box::new(tx)) as *mut std::ffi::c_void;
+        let c_username = std::ffi::CString::new(username).unwrap();
+        let c_token = std::ffi::CString::new(token).unwrap();
+        ra_login_token_user(c_username.as_ptr(), c_token.as_ptr(), tx_ptr)
+    };
+}
+
+#[cfg(feature = "gui")]
+pub fn get_username() -> Option<String> {
+    let c_username = unsafe { ra_get_username() };
+    if c_username.is_null() {
+        None
+    } else {
+        Some(
+            unsafe { std::ffi::CStr::from_ptr(c_username) }
+                .to_str()
+                .unwrap()
+                .to_string(),
+        )
+    }
+}
+
+#[cfg(feature = "gui")]
+pub fn get_token() -> Option<String> {
+    let c_token = unsafe { ra_get_token() };
+    if c_token.is_null() {
+        None
+    } else {
+        Some(
+            unsafe { std::ffi::CStr::from_ptr(c_token) }
+                .to_str()
+                .unwrap()
+                .to_string(),
+        )
+    }
+}
+
+pub fn state_size() -> usize {
+    unsafe { ra_state_size() }
+}
+
+pub fn save_state(state: *mut u8, state_size: usize) {
+    unsafe { ra_save_state(state, state_size) };
+}
+
+pub fn load_state(state: *const u8, state_size: usize) {
+    unsafe { ra_load_state(state, state_size) };
+}

src/savestates.rs

@@ -1,4 +1,4 @@
-use crate::{device, ui};
+use crate::{cheats, device, retroachievements, ui};
 #[cfg(target_arch = "aarch64")]
 use device::__m128i;
 use serde::de::{Deserialize, Deserializer, SeqAccess, Visitor};
@@ -20,7 +20,7 @@ impl<'de, const N: usize> Visitor<'de> for M128iArrayVisitor<N> {
         A: SeqAccess<'de>,
     {
         let mut arr: [__m128i; N] = [device::zero_m128i(); N];
-        for (index, item) in arr.iter_mut().enumerate().take(N) {
+        for (index, item) in arr.iter_mut().enumerate() {
             match seq.next_element::<u128>()? {
                 Some(value) => *item = unsafe { std::mem::transmute::<u128, __m128i>(value) },
                 None => return Err(serde::de::Error::invalid_length(index, &self)),
@@ -73,34 +73,61 @@ pub fn create_savestate(device: &device::Device) {
     let mut rdp_state: Vec<u8> = vec![0; ui::video::state_size()];
     ui::video::save_state(rdp_state.as_mut_ptr());
 
-    let data: &[(&[u8], &str)] = &[
-        (&postcard::to_stdvec(device).unwrap(), "device"),
-        (
-            &postcard::to_stdvec(&device.ui.storage.saves).unwrap(),
-            "saves",
-        ),
-        (&rdp_state, "rdp_state"),
-    ];
-    let compressed_file = ui::storage::compress_file(data);
-    std::fs::write(
-        device.ui.storage.paths.savestate_file_path.clone(),
-        compressed_file,
-    )
-    .unwrap();
-    println!(
-        "Savestate created at {}",
-        device.ui.storage.paths.savestate_file_path.display()
-    );
+    let mut ra_state: Vec<u8> = vec![0; retroachievements::state_size()];
+    retroachievements::save_state(ra_state.as_mut_ptr(), ra_state.len());
+
+    let save_path = device.ui.storage.paths.savestate_file_path.clone();
+
+    if let Ok(device_data) = postcard::to_stdvec(device)
+        && let Ok(saves_data) = postcard::to_stdvec(&device.ui.storage.saves)
+        && let Ok(compressed_file) = ui::storage::compress_file(&[
+            (&device_data, "device"),
+            (&saves_data, "saves"),
+            (&rdp_state, "rdp_state"),
+            (&ra_state, "ra_state"),
+        ])
+    {
+        tokio::spawn(async move {
+            if let Err(e) = tokio::fs::write(save_path, compressed_file).await {
+                eprintln!("Error writing savestate: {}", e);
+            }
+        });
+        ui::video::onscreen_message(
+            &format!(
+                "Savestate created in slot {}",
+                device.ui.storage.save_state_slot
+            ),
+            ui::video::MESSAGE_LENGTH_MESSAGE_SHORT,
+        );
+    } else {
+        ui::video::onscreen_message(
+            &format!(
+                "Failed to create savestate in slot {}",
+                device.ui.storage.save_state_slot
+            ),
+            ui::video::MESSAGE_LENGTH_MESSAGE_SHORT,
+        );
+    }
 }
 
 pub fn load_savestate(device: &mut device::Device) {
+    if retroachievements::get_hardcore() {
+        ui::video::onscreen_message(
+            "Cannot load savestate in RA hardcore mode",
+            ui::video::MESSAGE_LENGTH_MESSAGE_SHORT,
+        );
+        return;
+    }
     let savestate = std::fs::read(&device.ui.storage.paths.savestate_file_path);
     if let Ok(savestate) = &savestate {
-        let device_bytes = ui::storage::decompress_file(savestate, "device");
-        let save_bytes = ui::storage::decompress_file(savestate, "saves");
-        let rdp_state = ui::storage::decompress_file(savestate, "rdp_state");
-        if let Ok(state) = postcard::from_bytes::<device::Device>(&device_bytes) {
-            device.ui.storage.saves = postcard::from_bytes(&save_bytes).unwrap();
+        if let Ok(device_bytes) = ui::storage::decompress_file(savestate, "device")
+            && let Ok(save_bytes) = ui::storage::decompress_file(savestate, "saves")
+            && let Ok(rdp_state) = ui::storage::decompress_file(savestate, "rdp_state")
+            && let Ok(ra_state) = ui::storage::decompress_file(savestate, "ra_state")
+            && let Ok(state) = postcard::from_bytes::<device::Device>(&device_bytes)
+            && let Ok(saves) = postcard::from_bytes(&save_bytes)
+        {
+            device.ui.storage.saves = saves;
 
             device.cpu = state.cpu;
             device.pif = state.pif;
@@ -160,28 +187,22 @@ pub fn load_savestate(device: &mut device::Device) {
 
             device::pif::connect_pif_channels(device);
             for i in 0..4 {
-                if device.pif.channels[i].pak_handler.is_some() {
-                    if device.pif.channels[i].pak_handler.unwrap().pak_type
-                        == device::controller::PakType::RumblePak
-                    {
+                if let Some(handler) = device.pif.channels[i].pak_handler {
+                    if handler.pak_type == device::controller::PakType::RumblePak {
                         let rumblepak_handler = device::controller::PakHandler {
                             read: device::controller::rumble::read,
                             write: device::controller::rumble::write,
                             pak_type: device::controller::PakType::RumblePak,
                         };
                         device.pif.channels[i].pak_handler = Some(rumblepak_handler);
-                    } else if device.pif.channels[i].pak_handler.unwrap().pak_type
-                        == device::controller::PakType::MemPak
-                    {
+                    } else if handler.pak_type == device::controller::PakType::MemPak {
                         let mempak_handler = device::controller::PakHandler {
                             read: device::controller::mempak::read,
                             write: device::controller::mempak::write,
                             pak_type: device::controller::PakType::MemPak,
                         };
                         device.pif.channels[i].pak_handler = Some(mempak_handler);
-                    } else if device.pif.channels[i].pak_handler.unwrap().pak_type
-                        == device::controller::PakType::TransferPak
-                    {
+                    } else if handler.pak_type == device::controller::PakType::TransferPak {
                         let tpak_handler = device::controller::PakHandler {
                             read: device::controller::transferpak::read,
                             write: device::controller::transferpak::write,
@@ -193,15 +214,43 @@ pub fn load_savestate(device: &mut device::Device) {
             }
 
             ui::audio::close_game_audio(&mut device.ui);
-            ui::audio::init_game_audio(&mut device.ui, device.ai.freq);
+            ui::audio::init_game_audio(device);
             ui::video::load_state(device, rdp_state.as_ptr());
-            println!(
-                "Savestate loaded from {}",
-                device.ui.storage.paths.savestate_file_path.display()
+
+            if !ra_state.is_empty() {
+                retroachievements::load_state(ra_state.as_ptr(), ra_state.len());
+            } else {
+                retroachievements::load_state(std::ptr::null(), 0);
+            }
+
+            if device.cheats.enabled {
+                cheats::execute_cheats(device, device.cheats.cheats.clone());
+            }
+
+            ui::video::onscreen_message(
+                &format!(
+                    "Savestate loaded from slot {}",
+                    device.ui.storage.save_state_slot
+                ),
+                ui::video::MESSAGE_LENGTH_MESSAGE_SHORT,
             );
         } else {
-            println!("Failed to load savestate");
+            ui::video::onscreen_message(
+                &format!(
+                    "Failed to load savestate from slot {}",
+                    device.ui.storage.save_state_slot
+                ),
+                ui::video::MESSAGE_LENGTH_MESSAGE_SHORT,
+            );
         }
+    } else {
+        ui::video::onscreen_message(
+            &format!(
+                "Could not find savestate in slot {}",
+                device.ui.storage.save_state_slot
+            ),
+            ui::video::MESSAGE_LENGTH_MESSAGE_SHORT,
+        );
     }
 }
 

src/ui.rs

@@ -1,29 +1,43 @@
 pub mod audio;
+#[cfg(feature = "gui")]
 pub mod cheats;
 pub mod config;
+#[cfg(feature = "gui")]
 pub mod gui;
 pub mod input;
+#[cfg(feature = "gui")]
 pub mod netplay;
+#[cfg(feature = "gui")]
+pub mod retroachievements;
 pub mod storage;
+pub mod usb;
 pub mod video;
+#[cfg(feature = "gui")]
 pub mod vru;
 
+pub static WEB_CLIENT: std::sync::LazyLock<reqwest::Client> = std::sync::LazyLock::new(|| {
+    reqwest::Client::builder()
+        .user_agent(format!(
+            "{}/{}",
+            env!("CARGO_PKG_NAME"),
+            env!("GIT_DESCRIBE")
+        ))
+        .build()
+        .unwrap()
+});
+
 pub struct Dirs {
     pub config_dir: std::path::PathBuf,
     pub data_dir: std::path::PathBuf,
+    pub cache_dir: std::path::PathBuf,
 }
 
 pub struct Audio {
-    pub audio_device_spec: sdl3_sys::audio::SDL_AudioSpec,
     pub audio_stream: *mut sdl3_sys::audio::SDL_AudioStream,
-    pub event_audio_stream: *mut sdl3_sys::audio::SDL_AudioStream,
-    pub audio_device: u32,
-    pub event_audio: audio::EventAudio,
     pub gain: f32,
 }
 
 pub struct Input {
-    pub joysticks: Vec<sdl3_sys::joystick::SDL_JoystickID>,
     pub keyboard_state: *const bool,
     pub controllers: [input::Controllers; 4],
 }
@@ -32,11 +46,29 @@ pub struct Storage {
     pub save_type: Vec<storage::SaveTypes>,
     pub paths: storage::Paths,
     pub saves: storage::Saves,
+    pub save_state_slot: u32,
 }
 
 pub struct Video {
     pub window: *mut sdl3_sys::video::SDL_Window,
     pub fullscreen: bool,
+    pub fps_tx: tokio::sync::mpsc::Sender<bool>,
+    pub fps_rx: Option<tokio::sync::mpsc::Receiver<bool>>,
+    pub vis_tx: tokio::sync::mpsc::Sender<bool>,
+    pub vis_rx: Option<tokio::sync::mpsc::Receiver<bool>>,
+}
+
+pub struct Usb {
+    pub usb_tx: Option<tokio::sync::broadcast::Sender<usb::UsbData>>,
+    pub cart_rx: Option<tokio::sync::broadcast::Receiver<usb::UsbData>>,
+}
+
+#[derive(Clone)]
+pub struct GameSettings {
+    pub overclock: bool,
+    pub disable_expansion_pak: bool,
+    pub cheats: std::collections::HashMap<String, Option<String>>,
+    pub load_savestate_slot: Option<u32>,
 }
 
 pub struct Ui {
@@ -44,59 +76,70 @@ pub struct Ui {
     pub config: config::Config,
     pub game_id: String,
     pub game_hash: String,
-    pub with_sdl: bool,
     pub audio: Audio,
     pub input: Input,
     pub storage: Storage,
     pub video: Video,
-}
-
-impl Drop for Ui {
-    fn drop(&mut self) {
-        if self.with_sdl {
-            unsafe {
-                sdl3_sys::init::SDL_Quit();
-            }
-        }
-    }
+    pub usb: Usb,
 }
 
 pub fn sdl_init(flag: sdl3_sys::init::SDL_InitFlags) {
     unsafe {
-        let init = sdl3_sys::init::SDL_WasInit(0);
-        if init & flag == 0 && !sdl3_sys::init::SDL_InitSubSystem(flag) {
-            let err = std::ffi::CStr::from_ptr(sdl3_sys::error::SDL_GetError())
-                .to_str()
-                .unwrap();
-            panic!("Could not initialize SDL subsystem: {flag}, {err}");
+        if sdl3_sys::init::SDL_WasInit(flag) == 0 && !sdl3_sys::init::SDL_InitSubSystem(flag) {
+            let err = sdl3_sys::error::SDL_GetError();
+            panic!(
+                "Could not initialize SDL subsystem: {}, {}",
+                u32::from(flag),
+                if err.is_null() {
+                    "Unknown error"
+                } else {
+                    std::ffi::CStr::from_ptr(err).to_str().unwrap()
+                }
+            );
         }
     }
 }
 
+pub fn ttf_init() {
+    unsafe {
+        if !sdl3_ttf_sys::ttf::TTF_Init() {
+            panic!("Could not initialize TTF");
+        }
+    }
+}
+
+pub fn sdl_close() {
+    unsafe {
+        sdl3_ttf_sys::ttf::TTF_Quit();
+        sdl3_sys::init::SDL_Quit();
+    }
+}
+
 pub fn get_dirs() -> Dirs {
     let exe_path = std::env::current_exe().unwrap();
     let portable_dir = exe_path.parent();
     let portable = portable_dir.unwrap().join("portable.txt").exists();
-    let config_dir;
-    let data_dir;
     if portable {
-        config_dir = portable_dir.unwrap().join("portable_data").join("config");
-        data_dir = portable_dir.unwrap().join("portable_data").join("data");
+        Dirs {
+            config_dir: portable_dir.unwrap().join("portable_data").join("config"),
+            data_dir: portable_dir.unwrap().join("portable_data").join("data"),
+            cache_dir: portable_dir.unwrap().join("portable_data").join("cache"),
+        }
     } else {
-        config_dir = dirs::config_dir().unwrap().join("gopher64");
-        data_dir = dirs::data_dir().unwrap().join("gopher64");
-    };
-
-    Dirs {
-        config_dir,
-        data_dir,
+        Dirs {
+            config_dir: dirs::config_dir().unwrap().join("gopher64"),
+            data_dir: dirs::data_dir().unwrap().join("gopher64"),
+            cache_dir: dirs::cache_dir().unwrap().join("gopher64"),
+        }
     }
 }
 
 impl Ui {
-    fn construct_ui(joysticks: Vec<u32>, with_sdl: bool) -> Ui {
+    pub fn new() -> Ui {
         let dirs = get_dirs();
 
+        let (fps_tx, fps_rx) = tokio::sync::mpsc::channel(1000);
+        let (vis_tx, vis_rx) = tokio::sync::mpsc::channel(1000);
         Ui {
             input: Input {
                 controllers: [
@@ -104,27 +147,35 @@ impl Ui {
                         game_controller: std::ptr::null_mut(),
                         joystick: std::ptr::null_mut(),
                         rumble: false,
+                        guid: sdl3_sys::guid::SDL_GUID::default(),
+                        last_key_state: 0,
                     },
                     input::Controllers {
                         game_controller: std::ptr::null_mut(),
                         joystick: std::ptr::null_mut(),
                         rumble: false,
+                        guid: sdl3_sys::guid::SDL_GUID::default(),
+                        last_key_state: 0,
                     },
                     input::Controllers {
                         game_controller: std::ptr::null_mut(),
                         joystick: std::ptr::null_mut(),
                         rumble: false,
+                        guid: sdl3_sys::guid::SDL_GUID::default(),
+                        last_key_state: 0,
                     },
                     input::Controllers {
                         game_controller: std::ptr::null_mut(),
                         joystick: std::ptr::null_mut(),
                         rumble: false,
+                        guid: sdl3_sys::guid::SDL_GUID::default(),
+                        last_key_state: 0,
                     },
                 ],
                 keyboard_state: std::ptr::null_mut(),
-                joysticks,
             },
             storage: Storage {
+                save_state_slot: 0,
                 save_type: vec![],
                 paths: storage::Paths {
                     eep_file_path: std::path::PathBuf::new(),
@@ -139,27 +190,27 @@ impl Ui {
                     write_to_disk: true,
                     eeprom: storage::Save {
                         data: Vec::new(),
-                        written: false,
+                        write_pending: false,
                     },
                     sram: storage::Save {
                         data: Vec::new(),
-                        written: false,
+                        write_pending: false,
                     },
                     flash: storage::Save {
                         data: Vec::new(),
-                        written: false,
+                        write_pending: false,
                     },
                     mempak: storage::Save {
                         data: Vec::new(),
-                        written: false,
+                        write_pending: false,
                     },
                     sdcard: storage::Save {
                         data: Vec::new(),
-                        written: false,
+                        write_pending: false,
                     },
                     romsave: storage::RomSave {
                         data: std::collections::HashMap::new(),
-                        written: false,
+                        write_pending: false,
                     },
                 },
             },
@@ -167,52 +218,22 @@ impl Ui {
             game_id: String::new(),
             game_hash: String::new(),
             audio: Audio {
-                event_audio: audio::EventAudio {
-                    mempak: include_bytes!("../data/mempak.wav").to_vec(),
-                    rumblepak: include_bytes!("../data/rumblepak.wav").to_vec(),
-                    transferpak: include_bytes!("../data/transferpak.wav").to_vec(),
-                    netplay_desync: include_bytes!("../data/netplay_desync.wav").to_vec(),
-                    netplay_lost_connection: include_bytes!("../data/netplay_lost_connection.wav")
-                        .to_vec(),
-                    netplay_disconnected: [
-                        include_bytes!("../data/netplay_p1_disconnected.wav").to_vec(),
-                        include_bytes!("../data/netplay_p2_disconnected.wav").to_vec(),
-                        include_bytes!("../data/netplay_p3_disconnected.wav").to_vec(),
-                        include_bytes!("../data/netplay_p4_disconnected.wav").to_vec(),
-                    ],
-                    cheats_enabled: include_bytes!("../data/cheats_enabled.wav").to_vec(),
-                },
-                audio_device_spec: Default::default(),
                 audio_stream: std::ptr::null_mut(),
-                event_audio_stream: std::ptr::null_mut(),
-                audio_device: 0,
                 gain: 1.0,
             },
             video: Video {
                 window: std::ptr::null_mut(),
                 fullscreen: false,
+                fps_tx,
+                fps_rx: Some(fps_rx),
+                vis_tx,
+                vis_rx: Some(vis_rx),
+            },
+            usb: Usb {
+                usb_tx: None,
+                cart_rx: None,
             },
             dirs,
-            with_sdl,
         }
     }
-
-    pub fn default() -> Ui {
-        Self::construct_ui(vec![], false)
-    }
-
-    pub fn new() -> Ui {
-        sdl_init(sdl3_sys::init::SDL_INIT_GAMEPAD);
-        let mut num_joysticks = 0;
-        let joysticks = unsafe { sdl3_sys::joystick::SDL_GetJoysticks(&mut num_joysticks) };
-        if joysticks.is_null() {
-            panic!("Could not get joystick list");
-        }
-        let mut joystick_vec = vec![];
-        for i in 0..num_joysticks {
-            joystick_vec.push(unsafe { *joysticks.add(i as usize) });
-        }
-        unsafe { sdl3_sys::stdinc::SDL_free(joysticks as *mut std::ffi::c_void) }
-        Self::construct_ui(joystick_vec, true)
-    }
 }

src/ui/audio.rs

@@ -1,96 +1,80 @@
 use crate::device;
-use crate::netplay;
 use crate::ui;
 
-pub struct EventAudio {
-    pub mempak: Vec<u8>,
-    pub rumblepak: Vec<u8>,
-    pub transferpak: Vec<u8>,
-    pub netplay_desync: Vec<u8>,
-    pub netplay_lost_connection: Vec<u8>,
-    pub netplay_disconnected: [Vec<u8>; 4],
-    pub cheats_enabled: Vec<u8>,
-}
+static ADJUST_LOCKED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
 
-pub fn init(ui: &mut ui::Ui, frequency: u64) {
+pub fn init(device: &mut device::Device) {
     ui::sdl_init(sdl3_sys::init::SDL_INIT_AUDIO);
-
-    let device_audio_spec = sdl3_sys::audio::SDL_AudioSpec {
-        format: sdl3_sys::audio::SDL_AUDIO_S16LE,
-        freq: 48000,
-        channels: 2,
-    };
-    ui.audio.audio_device = unsafe {
-        sdl3_sys::audio::SDL_OpenAudioDevice(
-            sdl3_sys::audio::SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK,
-            &device_audio_spec,
-        )
-    };
-    if ui.audio.audio_device == 0 {
-        panic!("Could not open audio device");
-    }
-
-    if !unsafe {
-        sdl3_sys::audio::SDL_GetAudioDeviceFormat(
-            ui.audio.audio_device,
-            &mut ui.audio.audio_device_spec,
-            std::ptr::null_mut(),
-        )
-    } {
-        panic!("Could not get audio device format");
-    }
-
-    let wav_audio_spec = sdl3_sys::audio::SDL_AudioSpec {
-        format: sdl3_sys::audio::SDL_AUDIO_S16LE,
-        freq: 24000,
-        channels: 1,
-    };
-
-    ui.audio.event_audio_stream = unsafe {
-        sdl3_sys::audio::SDL_CreateAudioStream(&wav_audio_spec, &ui.audio.audio_device_spec)
-    };
-    if !unsafe {
-        sdl3_sys::audio::SDL_SetAudioStreamGain(ui.audio.event_audio_stream, ui.audio.gain)
-            && sdl3_sys::audio::SDL_BindAudioStream(
-                ui.audio.audio_device,
-                ui.audio.event_audio_stream,
-            )
-    } {
-        panic!("Could not bind audio stream");
-    }
-    init_game_audio(ui, frequency);
+    init_game_audio(device);
 }
 
-pub fn init_game_audio(ui: &mut ui::Ui, frequency: u64) {
+unsafe extern "C" fn audio_callback(
+    _userdata: *mut std::ffi::c_void,
+    audio_stream: *mut sdl3_sys::audio::SDL_AudioStream,
+    additional_amount: i32,
+    _total_amount: i32,
+) {
+    if additional_amount > 0 {
+        unsafe {
+            sdl3_sys::audio::SDL_PutAudioStreamData(
+                audio_stream,
+                vec![0; additional_amount as usize].as_ptr() as *const std::ffi::c_void,
+                additional_amount,
+            )
+        };
+
+        adjust_audio_frequency(audio_stream, -0.0005);
+    }
+}
+
+pub fn init_game_audio(device: &mut device::Device) {
     let game_audio_spec = sdl3_sys::audio::SDL_AudioSpec {
         format: sdl3_sys::audio::SDL_AUDIO_S16LE,
-        freq: frequency as i32,
+        freq: device.ai.freq as i32,
         channels: 2,
     };
 
-    ui.audio.audio_stream = unsafe {
-        sdl3_sys::audio::SDL_CreateAudioStream(&game_audio_spec, &ui.audio.audio_device_spec)
+    device.ui.audio.audio_stream = unsafe {
+        sdl3_sys::audio::SDL_OpenAudioDeviceStream(
+            sdl3_sys::audio::SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK,
+            &game_audio_spec,
+            None,
+            std::ptr::null_mut(),
+        )
     };
-    if ui.audio.audio_stream.is_null() {
-        return;
+    if device.ui.audio.audio_stream.is_null() {
+        panic!("Could not create audio stream");
     }
     if !unsafe {
-        sdl3_sys::audio::SDL_SetAudioStreamGain(ui.audio.audio_stream, ui.audio.gain)
-            && sdl3_sys::audio::SDL_BindAudioStream(ui.audio.audio_device, ui.audio.audio_stream)
+        sdl3_sys::audio::SDL_SetAudioStreamGain(device.ui.audio.audio_stream, device.ui.audio.gain)
+            && sdl3_sys::audio::SDL_SetAudioStreamGetCallback(
+                device.ui.audio.audio_stream,
+                Some(audio_callback),
+                std::ptr::null_mut(),
+            )
     } {
-        panic!("Could not bind audio stream");
+        panic!("Could not initialize audio stream");
+    }
+    if device.ai.regs[device::ai::AI_STATUS_REG as usize] & device::ai::AI_STATUS_BUSY != 0 {
+        resume_game_audio(&mut device.ui);
+    } else {
+        pause_game_audio(&mut device.ui);
     }
 }
 
 pub fn close(ui: &mut ui::Ui) {
     close_game_audio(ui);
+}
+
+pub fn resume_game_audio(ui: &mut ui::Ui) {
     unsafe {
-        if !ui.audio.event_audio_stream.is_null() {
-            sdl3_sys::audio::SDL_DestroyAudioStream(ui.audio.event_audio_stream);
-            ui.audio.event_audio_stream = std::ptr::null_mut();
-        }
-        sdl3_sys::audio::SDL_CloseAudioDevice(ui.audio.audio_device);
-        ui.audio.audio_device = 0;
+        sdl3_sys::audio::SDL_ResumeAudioStreamDevice(ui.audio.audio_stream);
+    }
+}
+
+pub fn pause_game_audio(ui: &mut ui::Ui) {
+    unsafe {
+        sdl3_sys::audio::SDL_PauseAudioStreamDevice(ui.audio.audio_stream);
     }
 }
 
@@ -110,8 +94,11 @@ pub fn lower_audio_volume(ui: &mut ui::Ui) {
             ui.audio.gain = 0.0;
         }
         sdl3_sys::audio::SDL_SetAudioStreamGain(ui.audio.audio_stream, ui.audio.gain);
-        sdl3_sys::audio::SDL_SetAudioStreamGain(ui.audio.event_audio_stream, ui.audio.gain);
     }
+    ui::video::onscreen_message(
+        &format!("Audio volume: {:.0}%", ui.audio.gain * 100.0),
+        ui::video::MESSAGE_LENGTH_MESSAGE_VERY_SHORT,
+    );
 }
 
 pub fn raise_audio_volume(ui: &mut ui::Ui) {
@@ -121,77 +108,43 @@ pub fn raise_audio_volume(ui: &mut ui::Ui) {
             ui.audio.gain = 2.0;
         }
         sdl3_sys::audio::SDL_SetAudioStreamGain(ui.audio.audio_stream, ui.audio.gain);
-        sdl3_sys::audio::SDL_SetAudioStreamGain(ui.audio.event_audio_stream, ui.audio.gain);
     }
+    ui::video::onscreen_message(
+        &format!("Audio volume: {:.0}%", ui.audio.gain * 100.0),
+        ui::video::MESSAGE_LENGTH_MESSAGE_VERY_SHORT,
+    );
 }
 
-pub fn play_cheat_event(ui: &ui::Ui) {
-    if ui.audio.event_audio_stream.is_null() {
-        return;
-    }
-    let sound = &ui.audio.event_audio.cheats_enabled;
-    if !unsafe {
-        sdl3_sys::audio::SDL_PutAudioStreamData(
-            ui.audio.event_audio_stream,
-            sound.as_ptr() as *const std::ffi::c_void,
-            sound.len() as i32,
-        )
-    } {
-        panic!("Could not play audio");
-    }
+unsafe extern "C" fn lock_callback(
+    _userdata: *mut std::ffi::c_void,
+    _id: sdl3_sys::timer::SDL_TimerID,
+    _interval: u32,
+) -> u32 {
+    ADJUST_LOCKED.store(false, std::sync::atomic::Ordering::Relaxed);
+    0
 }
 
-pub fn play_netplay_audio(ui: &ui::Ui, error: u32) {
-    if ui.audio.event_audio_stream.is_null() {
-        return;
-    }
-    let sound = match error {
-        netplay::NETPLAY_ERROR_DESYNC => &ui.audio.event_audio.netplay_desync,
-        netplay::NETPLAY_ERROR_LOST_CONNECTION => &ui.audio.event_audio.netplay_lost_connection,
-        netplay::NETPLAY_ERROR_PLAYER_1_DISCONNECTED => {
-            &ui.audio.event_audio.netplay_disconnected[0]
-        }
-        netplay::NETPLAY_ERROR_PLAYER_2_DISCONNECTED => {
-            &ui.audio.event_audio.netplay_disconnected[1]
-        }
-        netplay::NETPLAY_ERROR_PLAYER_3_DISCONNECTED => {
-            &ui.audio.event_audio.netplay_disconnected[2]
-        }
-        netplay::NETPLAY_ERROR_PLAYER_4_DISCONNECTED => {
-            &ui.audio.event_audio.netplay_disconnected[3]
-        }
-        _ => panic!("Invalid netplay error"),
-    };
-    if !unsafe {
-        sdl3_sys::audio::SDL_PutAudioStreamData(
-            ui.audio.event_audio_stream,
-            sound.as_ptr() as *const std::ffi::c_void,
-            sound.len() as i32,
-        )
-    } {
-        panic!("Could not play audio");
-    }
-}
-
-pub fn play_pak_switch(ui: &ui::Ui, pak: device::controller::PakType) {
-    if ui.audio.event_audio_stream.is_null() {
+fn adjust_audio_frequency(audio_stream: *mut sdl3_sys::audio::SDL_AudioStream, frequency: f32) {
+    if ADJUST_LOCKED.load(std::sync::atomic::Ordering::Relaxed) {
         return;
     }
 
-    let sound = match pak {
-        device::controller::PakType::RumblePak => &ui.audio.event_audio.rumblepak,
-        device::controller::PakType::MemPak => &ui.audio.event_audio.mempak,
-        device::controller::PakType::TransferPak => &ui.audio.event_audio.transferpak,
-        _ => panic!("Invalid pak type"),
-    };
-    if !unsafe {
-        sdl3_sys::audio::SDL_PutAudioStreamData(
-            ui.audio.event_audio_stream,
-            sound.as_ptr() as *const std::ffi::c_void,
-            sound.len() as i32,
-        )
-    } {
-        panic!("Could not play audio");
+    ADJUST_LOCKED.store(true, std::sync::atomic::Ordering::Relaxed);
+
+    unsafe {
+        sdl3_sys::timer::SDL_AddTimer(1000, Some(lock_callback), std::ptr::null_mut());
+        let current_ratio = sdl3_sys::everything::SDL_GetAudioStreamFrequencyRatio(audio_stream);
+        sdl3_sys::everything::SDL_SetAudioStreamFrequencyRatio(
+            audio_stream,
+            (current_ratio + frequency).clamp(0.995, 1.005),
+        );
+
+        /*
+        println!(
+            "Adjusted audio frequency ratio to {}",
+            sdl3_sys::everything::SDL_GetAudioStreamFrequencyRatio(audio_stream)
+        );
+        */
     }
 }
 
@@ -215,31 +168,17 @@ pub fn play_audio(device: &device::Device, dram_addr: usize, length: u64) {
 
     let audio_queued =
         unsafe { sdl3_sys::audio::SDL_GetAudioStreamQueued(device.ui.audio.audio_stream) } as f64;
-    let acceptable_latency = (device.ai.freq as f64 * 0.2) * 4.0;
-    let min_latency = (device.ai.freq as f64 * 0.02) * 4.0;
-
-    if audio_queued < min_latency {
-        let silence_buffer: Vec<u8> = vec![0; min_latency as usize & !3];
-        if !unsafe {
-            sdl3_sys::audio::SDL_PutAudioStreamData(
-                device.ui.audio.audio_stream,
-                silence_buffer.as_ptr() as *const std::ffi::c_void,
-                silence_buffer.len() as i32,
-            )
-        } {
-            panic!("Could not play audio");
-        }
-    }
-
-    if audio_queued < acceptable_latency
-        && !unsafe {
+    let samples_per_frame = device.ai.freq as f64 * device.vi.frame_time * 4.0;
+    let max_latency = samples_per_frame * 8.0;
+    if audio_queued < max_latency {
+        unsafe {
             sdl3_sys::audio::SDL_PutAudioStreamData(
                 device.ui.audio.audio_stream,
                 primary_buffer.as_ptr() as *const std::ffi::c_void,
                 primary_buffer.len() as i32 * 2,
             )
-        }
-    {
-        panic!("Could not play audio");
+        };
+    } else if device.vi.enable_speed_limiter {
+        adjust_audio_frequency(device.ui.audio.audio_stream, 0.0005);
     }
 }

src/ui/cheats.rs

@@ -1,24 +1,21 @@
+use crate::cheats;
 use crate::device;
 use crate::ui;
 use crate::ui::gui::AppWindow;
 use crate::ui::gui::ErrorDialog;
 use slint::ComponentHandle;
 
-#[derive(serde::Serialize, serde::Deserialize, Clone)]
-pub struct CheatData {
-    note: String,
-    pub data: Vec<String>,
-    pub options: Option<std::collections::BTreeMap<String, String>>,
-}
-
-pub type Cheats = std::collections::BTreeMap<String, std::collections::BTreeMap<String, CheatData>>;
-
 pub fn cheats_window(app: &AppWindow) {
     let weak = app.as_weak();
-    app.on_cheats_select_rom_clicked(move || {
-        let select_rom = rfd::AsyncFileDialog::new()
-            .set_title("Select ROM")
-            .pick_file();
+    app.on_cheats_select_rom_clicked(move |rom_dir| {
+        let select_rom = if !rom_dir.is_empty() && std::fs::exists(&rom_dir).unwrap_or(false) {
+            rfd::AsyncFileDialog::new().set_directory(rom_dir)
+        } else {
+            rfd::AsyncFileDialog::new()
+        }
+        .set_title("Select ROM")
+        .add_filter("ROM files", &ui::gui::N64_EXTENSIONS)
+        .pick_file();
         let weak = weak.clone();
         tokio::spawn(async move {
             if let Some(file) = select_rom.await
@@ -30,7 +27,7 @@ pub fn cheats_window(app: &AppWindow) {
                     handle.set_cheat_game_name(game_name.into());
                 })
                 .unwrap();
-                let cheats: Cheats =
+                let cheats: cheats::Cheat =
                     serde_json::from_slice(include_bytes!("../../data/cheats.json")).unwrap();
                 if let Some(cheat) = cheats.get(&game_crc) {
                     let cheat = cheat.clone();
@@ -69,16 +66,7 @@ pub fn cheats_window(app: &AppWindow) {
                                 options,
                             ));
                         }
-                        #[allow(clippy::type_complexity)]
-                        let cheats_model: std::rc::Rc<
-                            slint::VecModel<(
-                                slint::SharedString,
-                                bool,
-                                slint::SharedString,
-                                slint::ModelRc<(bool, slint::SharedString)>,
-                            )>,
-                        > = std::rc::Rc::new(cheats_vec);
-                        handle.set_cheats(slint::ModelRc::from(cheats_model));
+                        handle.set_cheats(slint::ModelRc::from(std::rc::Rc::new(cheats_vec)));
                     })
                     .unwrap();
                 } else {
@@ -129,19 +117,11 @@ pub fn cheats_window(app: &AppWindow) {
 
 fn clear_cheats(weak: &slint::Weak<AppWindow>, clear_name: bool) {
     weak.upgrade_in_event_loop(move |handle| {
-        let cheats_vec = slint::VecModel::default();
-        #[allow(clippy::type_complexity)]
-        let cheats_model: std::rc::Rc<
-            slint::VecModel<(
-                slint::SharedString,
-                bool,
-                slint::SharedString,
-                slint::ModelRc<(bool, slint::SharedString)>,
-            )>,
-        > = std::rc::Rc::new(cheats_vec);
-        handle.set_cheats(slint::ModelRc::from(cheats_model));
+        handle.set_cheats(slint::ModelRc::from(std::rc::Rc::new(
+            slint::VecModel::default(),
+        )));
         if clear_name {
-            handle.set_cheat_game_name("".into());
+            handle.set_cheat_game_name(String::new().into());
         }
     })
     .unwrap();

src/ui/config.rs

@@ -29,6 +29,7 @@ pub struct InputProfile {
     pub joystick_hat: [InputJoystickHat; ui::input::PROFILE_SIZE],
     pub joystick_axis: [InputControllerAxis; ui::input::PROFILE_SIZE],
     pub dinput: bool,
+    pub deadzone: i32,
 }
 
 #[derive(serde::Serialize, serde::Deserialize)]
@@ -38,15 +39,19 @@ pub struct Input {
     pub controller_assignment: [Option<String>; 4],
     pub controller_enabled: [bool; 4],
     pub transfer_pak: [bool; 4],
+    pub gb_rom_path: [String; 4],
+    pub gb_ram_path: [String; 4],
     pub emulate_vru: bool,
 }
 
 #[derive(serde::Serialize, serde::Deserialize)]
 pub struct Video {
     pub upscale: u32,
+    pub ssaa: bool,
     pub integer_scaling: bool,
     pub fullscreen: bool,
     pub widescreen: bool,
+    pub vsync: bool,
     pub crt: bool,
 }
 
@@ -54,6 +59,7 @@ pub struct Video {
 pub struct Emulation {
     pub overclock: bool,
     pub disable_expansion_pak: bool,
+    pub usb: bool,
 }
 
 #[derive(serde::Serialize, serde::Deserialize)]
@@ -67,6 +73,8 @@ pub struct Config {
     pub input: Input,
     pub video: Video,
     pub emulation: Emulation,
+    pub rom_dir: std::path::PathBuf,
+    pub recent_roms: Vec<String>,
 }
 
 impl Drop for Cheats {
@@ -78,8 +86,11 @@ impl Drop for Cheats {
 fn write_cheats(cheats: &Cheats) {
     let dirs = ui::get_dirs();
     let file_path = dirs.config_dir.join("cheats.json");
-    let f = std::fs::File::create(file_path).unwrap();
-    serde_json::to_writer_pretty(f, &cheats).unwrap();
+    if let Ok(f) = std::fs::File::create(file_path)
+        && let Err(e) = serde_json::to_writer_pretty(f, &cheats)
+    {
+        eprintln!("Error writing cheats: {}", e);
+    }
 }
 
 impl Cheats {
@@ -108,8 +119,11 @@ impl Drop for Config {
 fn write_config(config: &Config) {
     let dirs = ui::get_dirs();
     let file_path = dirs.config_dir.join("config.json");
-    let f = std::fs::File::create(file_path).unwrap();
-    serde_json::to_writer_pretty(f, &config).unwrap();
+    if let Ok(f) = std::fs::File::create(file_path)
+        && let Err(e) = serde_json::to_writer_pretty(f, &config)
+    {
+        eprintln!("Error writing config: {}", e);
+    }
 }
 
 impl Config {
@@ -137,19 +151,26 @@ impl Config {
                 input_profiles,
                 controller_enabled: [true, false, false, false],
                 transfer_pak: [false, false, false, false],
+                gb_rom_path: [String::new(), String::new(), String::new(), String::new()],
+                gb_ram_path: [String::new(), String::new(), String::new(), String::new()],
                 emulate_vru: false,
             },
             video: Video {
                 upscale: 1,
+                ssaa: false,
                 integer_scaling: false,
                 fullscreen: false,
                 widescreen: false,
+                vsync: true,
                 crt: false,
             },
             emulation: Emulation {
                 overclock: false,
                 disable_expansion_pak: false,
+                usb: false,
             },
+            rom_dir: std::path::PathBuf::new(),
+            recent_roms: Vec::new(),
         }
     }
 }

src/ui/gui.rs

@@ -1,10 +1,14 @@
-use crate::device;
-use crate::netplay;
+use crate::retroachievements;
 use crate::ui;
 use slint::Model;
+use slint::winit_030::WinitWindowAccessor;
 
 slint::include_modules!();
 
+pub const N64_EXTENSIONS: [&str; 12] = [
+    "n64", "v64", "z64", "7z", "zip", "bin", "N64", "V64", "Z64", "7Z", "ZIP", "BIN",
+];
+
 #[derive(serde::Deserialize)]
 struct GithubData {
     tag_name: String,
@@ -15,30 +19,16 @@ pub struct NetplayDevice {
     pub player_number: u8,
 }
 
-pub struct GbPaths {
-    pub rom: [Option<std::path::PathBuf>; 4],
-    pub ram: [Option<std::path::PathBuf>; 4],
-}
-
-pub struct VruChannel {
-    pub vru_window_notifier: Option<tokio::sync::mpsc::Sender<Option<Vec<String>>>>,
-    pub vru_word_receiver: Option<tokio::sync::mpsc::Receiver<String>>,
-}
-
 #[derive(Clone)]
-pub struct GameSettings {
-    pub fullscreen: bool,
-    pub overclock: bool,
-    pub disable_expansion_pak: bool,
-    pub cheats: std::collections::HashMap<String, Option<String>>,
+pub struct RASettings {
+    pub enabled: bool,
+    pub hardcore: bool,
+    pub challenge: bool,
+    pub leaderboard: bool,
 }
 
 fn check_latest_version(weak: slint::Weak<AppWindow>) {
-    let client = reqwest::Client::builder()
-        .user_agent(env!("CARGO_PKG_NAME"))
-        .build()
-        .unwrap();
-    let task = client
+    let task = ui::WEB_CLIENT
         .get("https://api.github.com/repos/gopher64/gopher64/releases/latest")
         .send();
     tokio::spawn(async move {
@@ -46,9 +36,12 @@ fn check_latest_version(weak: slint::Weak<AppWindow>) {
         if let Ok(response) = response {
             let data: Result<GithubData, reqwest::Error> = response.json().await;
 
-            let latest_version = if let Ok(data) = data {
-                semver::Version::parse(&data.tag_name[1..]).unwrap()
+            let latest_version = if let Ok(data) = data
+                && let Ok(github_version) = semver::Version::parse(&data.tag_name[1..])
+            {
+                github_version
             } else {
+                eprintln!("Error getting latest version from GitHub");
                 semver::Version::parse(env!("CARGO_PKG_VERSION")).unwrap()
             };
             let current_version = semver::Version::parse(env!("CARGO_PKG_VERSION")).unwrap();
@@ -60,23 +53,94 @@ fn check_latest_version(weak: slint::Weak<AppWindow>) {
     });
 }
 
-fn local_game_window(app: &AppWindow, controller_paths: &[Option<String>]) {
-    let dirs = ui::get_dirs();
+fn run_with_path(weak: slint::Weak<AppWindow>, path: std::path::PathBuf) {
+    let weak2 = weak.clone();
+    weak.upgrade_in_event_loop(move |handle| {
+        if handle.get_game_running() {
+            return;
+        }
+        save_settings(&handle);
+
+        run_rom(
+            path,
+            ui::GameSettings {
+                overclock: handle.get_overclock_n64_cpu(),
+                disable_expansion_pak: handle.get_disable_expansion_pak(),
+                cheats: std::collections::HashMap::new(), // will be filled in later
+                load_savestate_slot: None,
+            },
+            None,
+            RASettings {
+                enabled: handle.get_ra_enabled(),
+                hardcore: handle.get_ra_hardcore(),
+                challenge: handle.get_ra_challenge(),
+                leaderboard: handle.get_ra_leaderboard(),
+            },
+            weak2,
+        );
+    })
+    .unwrap();
+}
+
+fn file_dropped(app: &AppWindow) {
+    let weak = app.as_weak();
+    app.window()
+        .on_winit_window_event(move |_winit_window, event| {
+            if let slint::winit_030::winit::event::WindowEvent::DroppedFile(path) = event {
+                run_with_path(weak.clone(), path.to_path_buf());
+            }
+            slint::winit_030::EventResult::Propagate
+        });
+}
+
+fn local_game_window(app: &AppWindow, config: &ui::config::Config) {
+    let dirs = ui::get_dirs();
+
+    app.set_recent_roms(slint::ModelRc::from(std::rc::Rc::new(
+        slint::VecModel::from(
+            config
+                .recent_roms
+                .iter()
+                .filter(|x| std::fs::exists(x).unwrap_or(false))
+                .map(|x| {
+                    (
+                        x.into(),
+                        std::path::Path::new(x)
+                            .file_name()
+                            .unwrap()
+                            .to_str()
+                            .unwrap()
+                            .into(),
+                    )
+                })
+                .collect::<Vec<(slint::SharedString, slint::SharedString)>>(),
+        ),
+    )));
+
     let weak = app.as_weak();
-    let controller_paths = controller_paths.to_owned();
     app.on_open_rom_button_clicked(move || {
-        let controller_paths = controller_paths.clone();
         weak.upgrade_in_event_loop(move |handle| {
-            save_settings(&handle, &controller_paths);
+            save_settings(&handle);
             open_rom(&handle)
         })
         .unwrap();
     });
 
+    let weak = app.as_weak();
+    app.on_recent_rom_button_clicked(move |rom| {
+        weak.upgrade_in_event_loop(move |handle| {
+            run_with_path(handle.as_weak(), std::path::PathBuf::from(rom.to_string()));
+        })
+        .unwrap();
+    });
+
     let saves_path = dirs.data_dir.join("saves");
     app.on_saves_folder_button_clicked(move || {
-        open::that_detached(saves_path.clone()).unwrap();
+        if let Err(e) = open::that_detached(saves_path.clone()) {
+            eprintln!("Error opening saves folder: {}", e);
+        }
     });
+    file_dropped(app);
 }
 
 fn input_profiles(config: &ui::config::Config) -> Vec<String> {
@@ -89,24 +153,31 @@ fn input_profiles(config: &ui::config::Config) -> Vec<String> {
 
 fn settings_window(app: &AppWindow, config: &ui::config::Config) {
     app.set_integer_scaling(config.video.integer_scaling);
+    app.set_ssaa(config.video.ssaa);
     app.set_fullscreen(config.video.fullscreen);
     app.set_widescreen(config.video.widescreen);
+    app.set_vsync(config.video.vsync);
     app.set_apply_crt_shader(config.video.crt);
     app.set_overclock_n64_cpu(config.emulation.overclock);
     app.set_disable_expansion_pak(config.emulation.disable_expansion_pak);
+    app.set_emulate_usb(config.emulation.usb);
     let combobox_value = match config.video.upscale {
         1 => 0,
         2 => 1,
         4 => 2,
+        8 => 3,
         _ => 0,
     };
     app.set_resolution(combobox_value);
+
+    if let Some(rom_dir_str) = config.rom_dir.to_str() {
+        app.set_rom_dir(rom_dir_str.into());
+    }
 }
 
 fn update_input_profiles(weak: &slint::Weak<AppWindow>, config: &ui::config::Config) {
     let profiles = input_profiles(config);
     let config_bindings = config.input.input_profile_binding.clone();
-    let weak2 = weak.clone();
     weak.upgrade_in_event_loop(move |handle| {
         let profile_bindings = slint::VecModel::default();
         for (i, input_profile_binding) in handle.get_selected_profile_binding().iter().enumerate() {
@@ -118,82 +189,138 @@ fn update_input_profiles(weak: &slint::Weak<AppWindow>, config: &ui::config::Con
             let position = profiles
                 .iter()
                 .position(|profile| *profile == currently_selected);
-            profile_bindings.push(position.unwrap() as i32);
+            profile_bindings.push(position.unwrap_or(0) as i32);
         }
 
-        let input_profiles = slint::VecModel::default();
-        for profile in profiles {
-            input_profiles.push(profile.into());
-        }
-        let input_profiles_model: std::rc::Rc<slint::VecModel<slint::SharedString>> =
-            std::rc::Rc::new(input_profiles);
-        handle.set_input_profiles(slint::ModelRc::from(input_profiles_model));
+        handle.set_input_profiles(slint::ModelRc::from(std::rc::Rc::new(
+            slint::VecModel::from(
+                profiles
+                    .iter()
+                    .map(|x| x.into())
+                    .collect::<Vec<slint::SharedString>>(),
+            ),
+        )));
 
-        let input_profile_binding_model: std::rc::Rc<slint::VecModel<i32>> =
-            std::rc::Rc::new(profile_bindings);
-        handle.set_selected_profile_binding(slint::ModelRc::from(input_profile_binding_model));
-
-        // this is a workaround to make the input profile combobox update
-        handle.set_blank_profiles(true);
-        slint::Timer::single_shot(std::time::Duration::from_millis(200), move || {
-            weak2
-                .upgrade_in_event_loop(move |handle| {
-                    handle.set_blank_profiles(false);
-                })
-                .unwrap();
-        });
+        handle
+            .set_selected_profile_binding(slint::ModelRc::from(std::rc::Rc::new(profile_bindings)));
     })
     .unwrap();
 }
 
-fn controller_window(
-    app: &AppWindow,
-    config: &ui::config::Config,
-    controller_names: &Vec<String>,
-    controller_paths: &[Option<String>],
-) {
-    let controller_enabled_model: std::rc::Rc<slint::VecModel<bool>> = std::rc::Rc::new(
-        slint::VecModel::from(config.input.controller_enabled.to_vec()),
-    );
+fn clear_gb_paths(weak: &slint::Weak<AppWindow>, player: i32) {
+    weak.upgrade_in_event_loop(move |handle| {
+        let rom_paths = handle.get_gb_rom_paths();
+        let ram_paths = handle.get_gb_ram_paths();
+        rom_paths.set_row_data(player as usize, String::new().into());
+        ram_paths.set_row_data(player as usize, String::new().into());
+        handle.set_gb_rom_paths(rom_paths);
+        handle.set_gb_ram_paths(ram_paths);
+    })
+    .unwrap();
+}
+
+fn controller_window(app: &AppWindow, config: &ui::config::Config) {
+    ui::sdl_init(sdl3_sys::init::SDL_INIT_GAMEPAD);
+
     app.set_emulate_vru(config.input.emulate_vru);
 
-    app.set_controller_enabled(slint::ModelRc::from(controller_enabled_model));
+    app.set_controller_enabled(slint::ModelRc::from(std::rc::Rc::new(
+        slint::VecModel::from(config.input.controller_enabled.to_vec()),
+    )));
 
-    let transferpak_enabled_model: std::rc::Rc<slint::VecModel<bool>> =
-        std::rc::Rc::new(slint::VecModel::from(config.input.transfer_pak.to_vec()));
-    app.set_transferpak(slint::ModelRc::from(transferpak_enabled_model));
+    app.set_transferpak(slint::ModelRc::from(std::rc::Rc::new(
+        slint::VecModel::from(config.input.transfer_pak.to_vec()),
+    )));
+
+    app.set_gb_rom_paths(slint::ModelRc::from(std::rc::Rc::new(
+        slint::VecModel::from(
+            config
+                .input
+                .gb_rom_path
+                .iter()
+                .map(|x| x.into())
+                .collect::<Vec<slint::SharedString>>(),
+        ),
+    )));
+
+    app.set_gb_ram_paths(slint::ModelRc::from(std::rc::Rc::new(
+        slint::VecModel::from(
+            config
+                .input
+                .gb_ram_path
+                .iter()
+                .map(|x| x.into())
+                .collect::<Vec<slint::SharedString>>(),
+        ),
+    )));
 
     update_input_profiles(&app.as_weak(), config);
 
-    let controllers = slint::VecModel::default();
-    for controller in controller_names {
-        controllers.push(controller.into());
-    }
-    let controller_names_model: std::rc::Rc<slint::VecModel<slint::SharedString>> =
-        std::rc::Rc::new(controllers);
-    app.set_controller_names(slint::ModelRc::from(controller_names_model));
+    app.set_controller_changed(slint::ModelRc::from(std::rc::Rc::new(
+        slint::VecModel::from(vec![false, false, false, false]),
+    )));
 
-    let selected_controllers = slint::VecModel::default();
-    for selected in config.input.controller_assignment.iter() {
-        let mut found = false;
-        for (i, path) in controller_paths.iter().enumerate() {
-            if selected == path {
-                selected_controllers.push(i as i32);
-                found = true;
-                continue;
-            }
-        }
-        if !found {
-            selected_controllers.push(0);
-        }
-    }
-    let selected_controllers_model: std::rc::Rc<slint::VecModel<i32>> =
-        std::rc::Rc::new(selected_controllers);
-    app.set_selected_controller(slint::ModelRc::from(selected_controllers_model));
+    let config_controller_assignment = config.input.controller_assignment.clone();
+    let weak_app = app.as_weak();
+    app.on_controller_window_created(move || {
+        let controller_assignment = config_controller_assignment.clone();
+        weak_app
+            .upgrade_in_event_loop(move |handle| {
+                let mut current_selected_paths = vec![None; 4];
+                for (i, selected_controller) in handle.get_selected_controller().iter().enumerate()
+                {
+                    current_selected_paths[i] = handle
+                        .get_controller_paths()
+                        .row_data(selected_controller as usize);
+                }
+
+                let controller_names = ui::input::get_controller_names();
+                handle.set_controller_names(slint::ModelRc::from(std::rc::Rc::new(
+                    slint::VecModel::from(
+                        controller_names
+                            .iter()
+                            .map(|x| x.into())
+                            .collect::<Vec<slint::SharedString>>(),
+                    ),
+                )));
+
+                let controller_paths = ui::input::get_controller_paths();
+                handle.set_controller_paths(slint::ModelRc::from(std::rc::Rc::new(
+                    slint::VecModel::from(
+                        controller_paths
+                            .iter()
+                            .map(|x| x.into())
+                            .collect::<Vec<slint::SharedString>>(),
+                    ),
+                )));
+
+                let selected_controllers = slint::VecModel::default();
+                for i in 0..4 {
+                    let assigned_path =
+                        if let Some(current_selected_path) = &current_selected_paths[i] {
+                            current_selected_path.to_string()
+                        } else if let Some(config_assigned_path) = &controller_assignment[i] {
+                            config_assigned_path.to_string()
+                        } else {
+                            String::new()
+                        };
+                    let selected_index = controller_paths
+                        .iter()
+                        .position(|controller_path| assigned_path == *controller_path)
+                        .unwrap_or(0) as i32;
+                    selected_controllers.push(selected_index);
+                }
+                handle.set_selected_controller(slint::ModelRc::from(std::rc::Rc::new(
+                    selected_controllers,
+                )));
+            })
+            .unwrap();
+    });
 
     let weak_app = app.as_weak();
     app.on_input_profile_button_clicked(move || {
         let dialog = InputProfileDialog::new().unwrap();
+        dialog.set_deadzone(ui::input::DEADZONE_DEFAULT);
         let weak_dialog = dialog.as_weak();
         let weak_app = weak_app.clone();
         dialog.on_profile_creation_button_clicked(move || {
@@ -201,30 +328,109 @@ fn controller_window(
             weak_dialog
                 .upgrade_in_event_loop(move |handle| {
                     handle.hide().unwrap();
-                    let profile_name = handle.get_profile_name().into();
+                    let profile_name = handle.get_profile_name();
                     let dinput = handle.get_dinput();
+                    let deadzone = handle.get_deadzone();
 
                     tokio::spawn(async move {
-                        let mut game_ui = ui::Ui::new();
-                        ui::input::configure_input_profile(&mut game_ui, profile_name, dinput);
-                        update_input_profiles(&weak_app, &game_ui.config);
+                        let cli_path = std::env::current_exe()
+                            .unwrap()
+                            .parent()
+                            .unwrap()
+                            .join(format!("{}-cli", env!("CARGO_PKG_NAME")));
+                        let cmd_path = if cfg!(target_os = "macos") && cli_path.exists() {
+                            cli_path
+                        } else {
+                            std::env::current_exe().unwrap()
+                        };
+                        let mut command = tokio::process::Command::new(cmd_path);
+                        command.args([
+                            "--configure-input-profile",
+                            &profile_name,
+                            "--deadzone",
+                            &deadzone.to_string(),
+                        ]);
+                        if dinput {
+                            command.arg("--use-dinput");
+                        }
+                        if !command.status().await.unwrap().success() {
+                            eprintln!("Failed to configure input profile");
+                        }
+                        let config = ui::config::Config::new();
+                        update_input_profiles(&weak_app, &config);
                     });
                 })
                 .unwrap();
         });
         dialog.show().unwrap();
     });
+    let weak_app2 = app.as_weak();
+    app.on_transferpak_toggled(move |player, enabled| {
+        if enabled {
+            let select_gb_rom = rfd::AsyncFileDialog::new()
+                .set_title(format!("GB ROM P{}", player + 1))
+                .add_filter("GB ROM files", &["gb", "gbc", "GB", "GBC"])
+                .pick_file();
+
+            let weak_app3 = weak_app2.clone();
+            tokio::spawn(async move {
+                if let Some(gb_rom) = select_gb_rom.await {
+                    let weak_app4 = weak_app3.clone();
+                    weak_app3
+                        .upgrade_in_event_loop(move |_handle| {
+                            let select_gb_ram = rfd::AsyncFileDialog::new()
+                                .set_title(format!("GB RAM P{}", player + 1))
+                                .add_filter(
+                                    "GB RAM files",
+                                    &["sav", "ram", "srm", "SAV", "RAM", "SRM"],
+                                )
+                                .pick_file();
+
+                            tokio::spawn(async move {
+                                if let Some(gb_ram) = select_gb_ram.await {
+                                    weak_app4
+                                        .upgrade_in_event_loop(move |handle| {
+                                            let rom_paths = handle.get_gb_rom_paths();
+                                            let ram_paths = handle.get_gb_ram_paths();
+                                            rom_paths.set_row_data(
+                                                player as usize,
+                                                gb_rom.path().to_str().unwrap().into(),
+                                            );
+                                            ram_paths.set_row_data(
+                                                player as usize,
+                                                gb_ram.path().to_str().unwrap().into(),
+                                            );
+                                            handle.set_gb_rom_paths(rom_paths);
+                                            handle.set_gb_ram_paths(ram_paths);
+                                        })
+                                        .unwrap();
+                                } else {
+                                    clear_gb_paths(&weak_app4, player);
+                                }
+                            });
+                        })
+                        .unwrap();
+                } else {
+                    clear_gb_paths(&weak_app3, player);
+                }
+            });
+        }
+    });
 }
 
-pub fn save_settings(app: &AppWindow, controller_paths: &[Option<String>]) {
+pub fn save_settings(app: &AppWindow) {
     let mut config = ui::config::Config::new();
+    config.rom_dir = app.get_rom_dir().to_string().into();
     config.video.integer_scaling = app.get_integer_scaling();
+    config.video.ssaa = app.get_ssaa();
     config.video.fullscreen = app.get_fullscreen();
     config.video.widescreen = app.get_widescreen();
+    config.video.vsync = app.get_vsync();
     config.video.crt = app.get_apply_crt_shader();
     config.emulation.overclock = app.get_overclock_n64_cpu();
     config.emulation.disable_expansion_pak = app.get_disable_expansion_pak();
-    let upscale_values = [1, 2, 4];
+    config.emulation.usb = app.get_emulate_usb();
+    let upscale_values = [1, 2, 4, 8];
     config.video.upscale = upscale_values[app.get_resolution() as usize];
 
     config.input.emulate_vru = app.get_emulate_vru();
@@ -233,6 +439,8 @@ pub fn save_settings(app: &AppWindow, controller_paths: &[Option<String>]) {
     }
     for (i, transferpak_enabled) in app.get_transferpak().iter().enumerate() {
         config.input.transfer_pak[i] = transferpak_enabled;
+        config.input.gb_rom_path[i] = app.get_gb_rom_paths().row_data(i).unwrap().to_string();
+        config.input.gb_ram_path[i] = app.get_gb_ram_paths().row_data(i).unwrap().to_string();
     }
     for (i, input_profile_binding) in app.get_selected_profile_binding().iter().enumerate() {
         config.input.input_profile_binding[i] = app
@@ -243,240 +451,213 @@ pub fn save_settings(app: &AppWindow, controller_paths: &[Option<String>]) {
     }
 
     for (i, selected_controller) in app.get_selected_controller().iter().enumerate() {
-        config.input.controller_assignment[i] =
-            controller_paths[selected_controller as usize].clone();
+        if app.get_controller_changed().row_data(i).unwrap_or(false) {
+            let controller_path = app
+                .get_controller_paths()
+                .row_data(selected_controller as usize)
+                .unwrap()
+                .to_string();
+            if controller_path.is_empty() {
+                config.input.controller_assignment[i] = None;
+            } else {
+                config.input.controller_assignment[i] = Some(controller_path);
+            }
+        }
     }
 }
 
 fn about_window(app: &AppWindow) {
     app.on_wiki_button_clicked(move || {
-        open::that_detached("https://github.com/gopher64/gopher64/wiki").unwrap();
+        if let Err(e) = open::that_detached("https://github.com/gopher64/gopher64/wiki") {
+            eprintln!("Error opening wiki: {}", e);
+        }
     });
     app.on_discord_button_clicked(move || {
-        open::that_detached("https://discord.gg/9RGXq8W8JQ").unwrap();
+        if let Err(e) = open::that_detached("https://discord.gg/9RGXq8W8JQ") {
+            eprintln!("Error opening Discord: {}", e);
+        }
     });
     app.on_patreon_button_clicked(move || {
-        open::that_detached("https://patreon.com/loganmc10").unwrap();
+        if let Err(e) = open::that_detached("https://patreon.com/loganmc10") {
+            eprintln!("Error opening Patreon: {}", e);
+        }
     });
     app.on_github_sponsors_button_clicked(move || {
-        open::that_detached("https://github.com/sponsors/loganmc10").unwrap();
+        if let Err(e) = open::that_detached("https://github.com/sponsors/loganmc10") {
+            eprintln!("Error opening GitHub Sponsors: {}", e);
+        }
     });
     app.on_source_code_button_clicked(move || {
-        open::that_detached("https://github.com/gopher64/gopher64").unwrap();
+        if let Err(e) = open::that_detached("https://github.com/gopher64/gopher64") {
+            eprintln!("Error opening source code: {}", e);
+        }
     });
     app.on_newversion_button_clicked(move || {
-        open::that_detached("https://github.com/gopher64/gopher64/releases/latest").unwrap();
+        if let Err(e) = open::that_detached("https://github.com/gopher64/gopher64/releases/latest")
+        {
+            eprintln!("Error opening new version: {}", e);
+        }
     });
-    app.set_version(format!("Version: {}", env!("CARGO_PKG_VERSION")).into());
-    check_latest_version(app.as_weak());
+    app.set_version(format!("Version: {}", env!("GIT_DESCRIBE")).into());
+
+    //flatpak and itch.io have their own update checking mechanism
+    if std::env::var("FLATPAK_ID").is_err() && std::env::var("ITCHIO_APP").is_err() {
+        check_latest_version(app.as_weak());
+    }
 }
 
 pub fn app_window() {
     let app = AppWindow::new().unwrap();
     about_window(&app);
-    let mut controller_paths;
+    ui::retroachievements::ra_window(&app);
     {
-        let game_ui = ui::Ui::new();
-        let mut controller_names = ui::input::get_controller_names(&game_ui);
-        controller_names.insert(0, "None".into());
-        controller_paths = ui::input::get_controller_paths(&game_ui);
-        controller_paths.insert(0, None);
-        settings_window(&app, &game_ui.config);
-        controller_window(&app, &game_ui.config, &controller_names, &controller_paths);
+        let config = ui::config::Config::new();
+        settings_window(&app, &config);
+        controller_window(&app, &config);
+        local_game_window(&app, &config);
     }
-    local_game_window(&app, &controller_paths);
-    ui::netplay::netplay_window(&app, &controller_paths);
+    ui::netplay::netplay_window(&app);
     ui::cheats::cheats_window(&app);
     app.run().unwrap();
-    save_settings(&app, &controller_paths);
-}
-
-fn setup_vru_word_watcher(
-    weak_vru: slint::Weak<AppWindow>,
-    vru_word_notifier: tokio::sync::mpsc::Sender<String>,
-    mut vru_window_receiver: tokio::sync::mpsc::Receiver<Option<Vec<String>>>,
-) {
-    tokio::spawn(async move {
-        loop {
-            let notifier = vru_word_notifier.clone();
-            let notifier_closed = vru_word_notifier.clone();
-            let result = vru_window_receiver.recv().await;
-            if let Some(Some(words)) = result {
-                weak_vru
-                    .upgrade_in_event_loop(move |_handle| {
-                        let vru_dialog = VruDialog::new().unwrap();
-                        let vru_dialog_weak = vru_dialog.as_weak();
-
-                        vru_dialog.on_vru_button_clicked(move |chosen_word| {
-                            notifier.try_send(chosen_word.to_string()).unwrap();
-                            vru_dialog_weak.unwrap().window().hide().unwrap();
-                        });
-
-                        vru_dialog.window().on_close_requested(move || {
-                            notifier_closed.try_send("".to_string()).unwrap();
-                            slint::CloseRequestResponse::HideWindow
-                        });
-
-                        let words_vec = slint::VecModel::default();
-                        for word in words {
-                            words_vec.push(word.into());
-                        }
-                        let words_model: std::rc::Rc<slint::VecModel<slint::SharedString>> =
-                            std::rc::Rc::new(words_vec);
-                        vru_dialog.set_words(slint::ModelRc::from(words_model));
-
-                        vru_dialog.show().unwrap();
-                    })
-                    .unwrap();
-            } else {
-                return;
-            }
-        }
-    });
+    save_settings(&app);
 }
 
 pub fn run_rom(
-    gb_paths: GbPaths,
     file_path: std::path::PathBuf,
-    mut game_settings: GameSettings,
-    vru_channel: VruChannel,
+    game_settings: ui::GameSettings,
     netplay: Option<NetplayDevice>,
+    ra_settings: RASettings,
     weak: slint::Weak<AppWindow>,
 ) {
-    std::thread::Builder::new()
-        .name("n64".to_string())
-        .stack_size(env!("N64_STACK_SIZE").parse().unwrap())
-        .spawn(move || {
-            weak.upgrade_in_event_loop(move |handle| handle.set_game_running(true))
-                .unwrap();
+    tokio::spawn(async move {
+        weak.upgrade_in_event_loop(move |handle| handle.set_game_running(true))
+            .unwrap();
 
-            let mut device = device::Device::new();
+        let cli_path = std::env::current_exe()
+            .unwrap()
+            .parent()
+            .unwrap()
+            .join(format!("{}-cli", env!("CARGO_PKG_NAME")));
+        let cmd_path = if cfg!(target_os = "macos") && cli_path.exists() {
+            cli_path
+        } else {
+            std::env::current_exe().unwrap()
+        };
+        let mut command = tokio::process::Command::new(cmd_path);
+        command.args([
+            "--overclock",
+            &game_settings.overclock.to_string(),
+            "--disable-expansion-pak",
+            &game_settings.disable_expansion_pak.to_string(),
+        ]);
+        let cheats_path = ui::get_dirs().cache_dir.join("cheats.json");
+        if let Some(netplay_device) = netplay {
+            let f = std::fs::File::create(cheats_path.to_str().unwrap()).unwrap();
+            serde_json::to_writer_pretty(f, &game_settings.cheats).unwrap();
 
-            for i in 0..4 {
-                if gb_paths.rom[i].is_some() && gb_paths.ram[i].is_some() {
-                    device.transferpaks[i].cart.rom =
-                        std::fs::read(gb_paths.rom[i].as_ref().unwrap()).unwrap();
-
-                    device.transferpaks[i].cart.ram =
-                        std::fs::read(gb_paths.ram[i].as_ref().unwrap()).unwrap();
-                }
+            command.args([
+                "--netplay-peer-addr",
+                &netplay_device.peer_addr.to_string(),
+                "--netplay-player-number",
+                &netplay_device.player_number.to_string(),
+                "--cheats",
+                cheats_path.to_str().unwrap(),
+            ]);
+        }
+        if ra_settings.enabled {
+            command.args([
+                "--ra-username",
+                &retroachievements::get_username().unwrap_or("unknown".into()),
+                "--ra-token",
+                &retroachievements::get_token().unwrap_or("unknown".into()),
+            ]);
+            if ra_settings.hardcore {
+                command.args(["--ra-hardcore"]);
             }
-
-            device.vru_window.window_notifier = vru_channel.vru_window_notifier;
-            device.vru_window.word_receiver = vru_channel.vru_word_receiver;
-
-            if let Some(rom_contents) = device::get_rom_contents(file_path.as_path()) {
-                if let Some(netplay_device) = netplay {
-                    device.netplay = Some(netplay::init(
-                        netplay_device.peer_addr,
-                        netplay_device.player_number,
-                    ));
-                } else {
-                    game_settings.cheats = {
-                        let game_crc = ui::storage::get_game_crc(&rom_contents);
-                        let cheats = ui::config::Cheats::new();
-                        cheats.cheats.get(&game_crc).cloned().unwrap_or_default()
-                    };
-                }
-                device::run_game(&mut device, rom_contents, game_settings);
-                if device.netplay.is_some() {
-                    netplay::close(&mut device);
-                }
-            } else {
-                println!("Could not read rom file");
+            if ra_settings.challenge {
+                command.args(["--ra-challenge"]);
             }
-
-            if let Some(vru_window_notifier) = device.vru_window.window_notifier {
-                vru_window_notifier.try_send(None).unwrap();
+            if ra_settings.leaderboard {
+                command.args(["--ra-leaderboard"]);
             }
+        }
 
-            weak.upgrade_in_event_loop(move |handle| handle.set_game_running(false))
-                .unwrap();
+        let success = command
+            .arg(file_path.to_str().unwrap())
+            .status()
+            .await
+            .unwrap()
+            .success();
+
+        if !success {
+            eprintln!("Failed to run game");
+        }
+
+        let _ = std::fs::remove_file(cheats_path.to_str().unwrap());
+
+        weak.upgrade_in_event_loop(move |handle| {
+            if let Some(rom_dir) = file_path.parent().unwrap().to_str() {
+                handle.set_rom_dir(rom_dir.into());
+            }
+            if success {
+                let recent_roms = slint::VecModel::default();
+                recent_roms.push((
+                    file_path.to_str().unwrap().into(),
+                    file_path.file_name().unwrap().to_str().unwrap().into(),
+                ));
+
+                for rom in handle.get_recent_roms().iter() {
+                    if rom.0 != file_path.to_str().unwrap()
+                        && recent_roms.row_count() < 5
+                        && std::fs::exists(&rom.0).unwrap_or(false)
+                    {
+                        recent_roms.push(rom);
+                    }
+                }
+                handle.set_recent_roms(slint::ModelRc::from(std::rc::Rc::new(recent_roms)));
+            }
+            handle.set_game_running(false);
         })
         .unwrap();
+    });
 }
 
 fn open_rom(app: &AppWindow) {
-    let select_rom = rfd::AsyncFileDialog::new()
-        .set_title("Select ROM")
-        .pick_file();
-    let mut select_gb_rom = [None, None, None, None];
-    let mut select_gb_ram = [None, None, None, None];
-
-    for (i, transfer_pak_enabled) in app.get_transferpak().iter().enumerate() {
-        if transfer_pak_enabled {
-            select_gb_rom[i] = Some(
-                rfd::AsyncFileDialog::new()
-                    .set_title(format!("GB ROM P{}", i + 1))
-                    .pick_file(),
-            );
-            select_gb_ram[i] = Some(
-                rfd::AsyncFileDialog::new()
-                    .set_title(format!("GB RAM P{}", i + 1))
-                    .pick_file(),
-            );
-        }
+    let rom_dir = app.get_rom_dir();
+    let select_rom = if !rom_dir.is_empty() && std::fs::exists(&rom_dir).unwrap_or(false) {
+        rfd::AsyncFileDialog::new().set_directory(rom_dir)
+    } else {
+        rfd::AsyncFileDialog::new()
     }
+    .set_title("Select ROM")
+    .add_filter("ROM files", &N64_EXTENSIONS)
+    .pick_file();
 
-    #[allow(clippy::type_complexity)]
-    let (vru_window_notifier, vru_window_receiver): (
-        tokio::sync::mpsc::Sender<Option<Vec<String>>>,
-        tokio::sync::mpsc::Receiver<Option<Vec<String>>>,
-    ) = tokio::sync::mpsc::channel(5);
-
-    let (vru_word_notifier, vru_word_receiver): (
-        tokio::sync::mpsc::Sender<String>,
-        tokio::sync::mpsc::Receiver<String>,
-    ) = tokio::sync::mpsc::channel(5);
-
-    let fullscreen = app.get_fullscreen();
     let overclock = app.get_overclock_n64_cpu();
-    let emulate_vru = app.get_emulate_vru();
     let disable_expansion_pak = app.get_disable_expansion_pak();
+    let ra_enabled = app.get_ra_enabled();
+    let ra_hardcore = app.get_ra_hardcore();
+    let ra_challenge = app.get_ra_challenge();
+    let ra_leaderboard = app.get_ra_leaderboard();
 
-    if emulate_vru {
-        setup_vru_word_watcher(app.as_weak(), vru_word_notifier, vru_window_receiver);
-    }
     let weak = app.as_weak();
     tokio::spawn(async move {
         if let Some(file) = select_rom.await {
-            let mut gb_rom_path = [None, None, None, None];
-            let mut gb_ram_path = [None, None, None, None];
-
-            for i in 0..4 {
-                if let (Some(gb_rom), Some(gb_ram)) =
-                    (select_gb_rom[i].as_mut(), select_gb_ram[i].as_mut())
-                    && let (Some(gb_rom), Some(gb_ram)) = (gb_rom.await, gb_ram.await)
-                {
-                    gb_rom_path[i] = Some(gb_rom.path().to_path_buf());
-                    gb_ram_path[i] = Some(gb_ram.path().to_path_buf());
-                }
-            }
-
             run_rom(
-                GbPaths {
-                    rom: gb_rom_path,
-                    ram: gb_ram_path,
-                },
                 file.path().to_path_buf(),
-                GameSettings {
-                    fullscreen,
+                ui::GameSettings {
                     overclock,
                     disable_expansion_pak,
                     cheats: std::collections::HashMap::new(), // will be filled in later
-                },
-                if emulate_vru {
-                    VruChannel {
-                        vru_window_notifier: Some(vru_window_notifier),
-                        vru_word_receiver: Some(vru_word_receiver),
-                    }
-                } else {
-                    VruChannel {
-                        vru_window_notifier: None,
-                        vru_word_receiver: None,
-                    }
+                    load_savestate_slot: None,
                 },
                 None,
+                RASettings {
+                    enabled: ra_enabled,
+                    hardcore: ra_hardcore,
+                    challenge: ra_challenge,
+                    leaderboard: ra_leaderboard,
+                },
                 weak,
             );
         }

src/ui/gui/appwindow.slint

@@ -2,9 +2,10 @@
 // SPDX-License-Identifier: MIT
 
 import { StandardButton } from "std-widgets.slint";
-import { LocalGame, ControllerConfig, Netplay, Cheats, Settings, About } from "pages.slint";
+import { LocalGame, ControllerConfig, Netplay, Cheats, RetroAchievements, Settings, About } from "pages.slint";
 import { SideBar } from "side_bar.slint";
 import { SettingsData } from "settings_page.slint";
+import { RAData } from "retroachievements_page.slint";
 import { AboutData } from "about_page.slint";
 import { ControllerData } from "controller_page.slint";
 import { State } from "localgame_page.slint";
@@ -14,49 +15,76 @@ export { VruDialog } from "vru_dialog.slint";
 export { NetplayCreate } from "netplay_create.slint";
 export { NetplayJoin } from "netplay_join.slint";
 export { NetplayWait } from "netplay_wait.slint";
+export { CustomNetplayServer } from "netplay_page.slint";
+export { DispatcherDialog } from "netplay_create.slint";
 
 export component AppWindow inherits Window {
     callback wiki_button_clicked;
     callback discord_button_clicked;
     callback newversion_button_clicked;
+    callback recent_rom_button_clicked(string);
     callback patreon_button_clicked;
     callback github_sponsors_button_clicked;
     callback source_code_button_clicked;
     callback open_rom_button_clicked;
     callback saves_folder_button_clicked;
     callback input_profile_button_clicked;
+    callback transferpak_toggled(int,bool);
     callback create_session_button_clicked;
     callback join_session_button_clicked;
     callback netplay_discord_button_clicked;
     callback netplay_feedback_button_clicked;
-    callback cheats_select_rom_clicked;
+    callback cheats_select_rom_clicked(string);
     callback cheats_clear_clicked;
     callback cheat_toggled(string, string, string, bool);
+    callback ra_button_clicked(string);
+    callback ra_games_clicked;
+    callback ra_show_profile_clicked;
+    callback ra_toggled(bool,bool,bool,bool);
+    callback controller_window_created;
     in property version <=> AboutData.version;
     in property has_update <=> AboutData.has_update;
+    in-out property ra_username <=> RAData.ra_username;
+    in-out property ra_password <=> RAData.ra_password;
+    in-out property ra_logging_in <=> RAData.ra_logging_in;
+    in-out property ra_show_profile <=> RAData.ra_show_profile;
+    in-out property ra_current_user_message <=> RAData.current_user_message;
+    in-out property ra_enabled <=> RAData.enabled;
+    in-out property ra_hardcore <=> RAData.hardcore;
+    in-out property ra_challenge <=> RAData.challenge;
+    in-out property ra_leaderboard <=> RAData.leaderboard;
+    in-out property ra_softcore_only <=> RAData.ra_softcore_only;
     in-out property integer_scaling <=> SettingsData.integer_scaling;
+    in-out property ssaa <=> SettingsData.ssaa;
     in-out property fullscreen <=> SettingsData.fullscreen;
     in-out property widescreen <=> SettingsData.widescreen;
+    in-out property vsync <=> SettingsData.vsync;
     in-out property apply_crt_shader <=> SettingsData.apply_crt_shader;
     in-out property overclock_n64_cpu <=> SettingsData.overclock_n64_cpu;
     in-out property disable_expansion_pak <=> SettingsData.disable_expansion_pak;
     in-out property resolution <=> SettingsData.resolution;
+    in-out property emulate_usb <=> SettingsData.emulate_usb;
+    in-out property rom_dir <=> SettingsData.rom_dir;
     in-out property emulate_vru <=> ControllerData.emulate_vru;
     in-out property controller_enabled <=> ControllerData.controller_enabled;
+    in-out property controller_changed <=> ControllerData.controller_changed;
     in-out property transferpak <=> ControllerData.transferpak;
+    in-out property gb_rom_paths <=> ControllerData.gb_rom_paths;
+    in-out property gb_ram_paths <=> ControllerData.gb_ram_paths;
     in-out property selected_profile_binding <=> ControllerData.selected_profile_binding;
     in-out property input_profiles <=> ControllerData.input_profiles;
     in-out property controller_names <=> ControllerData.controller_names;
+    in-out property controller_paths <=> ControllerData.controller_paths;
     in-out property selected_controller <=> ControllerData.selected_controller;
     in-out property game_running <=> State.game_running;
-    in-out property blank_profiles <=> ControllerData.blank_profiles;
+    in-out property recent_roms <=> State.recent_roms;
     in-out property cheat_game_name <=> CheatsData.cheat_game_name;
     in-out property cheat_game_crc <=> CheatsData.cheat_game_crc;
     in-out property cheats <=> CheatsData.cheats;
     preferred-width: 700px;
     preferred-height: 500px;
     title: @tr("Gopher64");
-    icon: @image-url("../../../data/gopher64.png");
+    icon: @image-url("../../../data/icon/gopher64.png");
 
     HorizontalLayout {
         side-bar := SideBar {
@@ -66,6 +94,7 @@ export component AppWindow inherits Window {
                 @tr("Menu" => "Controller Config"),
                 @tr("Menu" => "Netplay"),
                 @tr("Menu" => "Cheats"),
+                @tr("Menu" => "RetroAchievements"),
                 @tr("Menu" => "Settings"),
                 @tr("Menu" => "About")
             ];
@@ -81,11 +110,20 @@ export component AppWindow inherits Window {
             newversion_button_clicked => {
                 newversion_button_clicked();
             }
+            recent_rom_button_clicked(rom) => {
+                recent_rom_button_clicked(rom);
+            }
         }
         if(side-bar.current-item == 1): ControllerConfig {
             input_profile_button_clicked => {
                 input_profile_button_clicked();
             }
+            transferpak_toggled(player,enabled) => {
+                transferpak_toggled(player,enabled);
+            }
+            controller_window_created => {
+                controller_window_created();
+            }
         }
         if(side-bar.current-item == 2): Netplay {
             create_session_button_clicked => {
@@ -102,8 +140,8 @@ export component AppWindow inherits Window {
             }
         }
         if(side-bar.current-item == 3): Cheats {
-            cheats_select_rom_clicked => {
-                cheats_select_rom_clicked();
+            cheats_select_rom_clicked(rom_dir) => {
+                cheats_select_rom_clicked(rom_dir);
             }
             cheats_clear_clicked => {
                 cheats_clear_clicked();
@@ -112,8 +150,22 @@ export component AppWindow inherits Window {
                 cheat_toggled(game_crc,cheat_name,option,enabled);
             }
         }
-        if(side-bar.current-item == 4): Settings { }
-        if(side-bar.current-item == 5): About {
+        if(side-bar.current-item == 4): RetroAchievements {
+            ra_button_clicked(password) => {
+                ra_button_clicked(password);
+            }
+            ra_toggled(enabled,hardcore,challenge,leaderboard) => {
+                ra_toggled(enabled,hardcore,challenge,leaderboard);
+            }
+            ra_games_clicked => {
+                ra_games_clicked();
+            }
+            ra_show_profile_clicked => {
+                ra_show_profile_clicked();
+            }
+         }
+        if(side-bar.current-item == 5): Settings { }
+        if(side-bar.current-item == 6): About {
             wiki_button_clicked => {
                 wiki_button_clicked();
             }

src/ui/gui/cheat_page.slint

@@ -1,8 +1,9 @@
 // Copyright © SixtyFPS GmbH <info@slint.dev>
 // SPDX-License-Identifier: MIT
 
-import { ListView, HorizontalBox, VerticalBox, Button, GroupBox, CheckBox } from "std-widgets.slint";
+import { ListView, HorizontalBox, VerticalBox, Button, GroupBox, Switch, CheckBox } from "std-widgets.slint";
 import { Page } from "page.slint";
+import { SettingsData } from "settings_page.slint";
 
 export global CheatsData {
     in-out property <string> cheat_game_name;
@@ -12,7 +13,7 @@ export global CheatsData {
 
 export component Cheats inherits Page {
     title: @tr("Cheats");
-    callback cheats_select_rom_clicked;
+    callback cheats_select_rom_clicked(string);
     callback cheats_clear_clicked;
     callback cheat_toggled(string, string, string, bool);
 
@@ -23,13 +24,13 @@ export component Cheats inherits Page {
             if CheatsData.cheat_game_name == "": Button {
                 text: @tr("Select ROM");
                 clicked => {
-                    cheats_select_rom_clicked();
+                    cheats_select_rom_clicked(SettingsData.rom_dir);
                 }
             }
             if CheatsData.cheat_game_name != "": Button {
                 text: CheatsData.cheat_game_name;
                 clicked => {
-                    cheats_select_rom_clicked();
+                    cheats_select_rom_clicked(SettingsData.rom_dir);
                 }
             }
             Rectangle {
@@ -61,15 +62,14 @@ export component Cheats inherits Page {
                     wrap: word-wrap;
                 }
 
-                if data.options.length == 0: CheckBox {
-                    text: @tr("Enabled");
+                if data.options.length == 0: Switch {
                     checked: data.enabled;
                     toggled => {
                         data.enabled = self.checked;
                         cheat_toggled(CheatsData.cheat_game_crc,data.cheat_name,"",self.checked);
                     }
                 }
-                for item[index] in data.options: CheckBox {
+                for item in data.options: CheckBox {
                     text: item.option;
                     enabled: !data.enabled || (data.enabled && item.enabled);
                     checked: item.enabled;

src/ui/gui/controller_page.slint

@@ -1,7 +1,7 @@
 // Copyright © SixtyFPS GmbH <info@slint.dev>
 // SPDX-License-Identifier: MIT
 
-import { CheckBox, ComboBox, Button, HorizontalBox, VerticalBox, GroupBox } from "std-widgets.slint";
+import { Switch, ComboBox, Button, HorizontalBox, VerticalBox, GroupBox } from "std-widgets.slint";
 import { Page } from "page.slint";
 import { State } from "localgame_page.slint";
 
@@ -9,17 +9,26 @@ export global ControllerData {
     in-out property <bool> emulate_vru;
     in-out property <[bool]> controller_enabled;
     in-out property <[bool]> transferpak;
+    in-out property <[string]> gb_rom_paths;
+    in-out property <[string]> gb_ram_paths;
     in-out property <[int]> selected_profile_binding: [-1, -1, -1, -1];
     in-out property <[string]> input_profiles;
     in-out property <[string]> controller_names;
+    in-out property <[string]> controller_paths;
     in-out property <[int]> selected_controller;
-    in-out property <bool> blank_profiles;
+    in-out property <[bool]> controller_changed;
 }
 
 export component ControllerConfig inherits Page {
     callback input_profile_button_clicked;
+    callback transferpak_toggled(int,bool);
+    callback controller_window_created;
     title: @tr("Controller Configuration");
 
+    init => {
+        controller_window_created();
+    }
+
     VerticalBox {
         alignment: start;
         HorizontalBox {
@@ -51,7 +60,7 @@ export component ControllerConfig inherits Page {
                 title: @tr("Enabled");
                 VerticalLayout {
                     alignment: space-between;
-                    for player in [0, 1, 2, 3]: CheckBox {
+                    for player in [0, 1, 2, 3]: Switch {
                         checked: ControllerData.controller_enabled[player];
                         toggled => {
                             ControllerData.controller_enabled[player] = self.checked;
@@ -64,7 +73,7 @@ export component ControllerConfig inherits Page {
                 title: @tr("Emulate VRU");
                 VerticalLayout {
                     alignment: space-between;
-                    for valid in [false, false, false, true]: CheckBox {
+                    for valid in [false, false, false, true]: Switch {
                         enabled: valid;
                         checked: valid && ControllerData.emulate_vru;
                         toggled => {
@@ -78,21 +87,24 @@ export component ControllerConfig inherits Page {
                 title: @tr("Transfer Pak");
                 VerticalLayout {
                     alignment: space-between;
-                    for player in [0, 1, 2, 3]: CheckBox {
+                    for player in [0, 1, 2, 3]: Switch {
                         checked: ControllerData.transferpak[player];
                         toggled => {
                             ControllerData.transferpak[player] = self.checked;
+                            transferpak_toggled(player,self.checked);
                         }
                     }
                 }
             }
 
-            if !ControllerData.blank_profiles: GroupBox {
+            GroupBox {
                 title: @tr("Profile");
+                horizontal-stretch: 0.25;
                 VerticalLayout {
                     alignment: space-between;
                     for player in [0, 1, 2, 3]: ComboBox {
                         model: ControllerData.input_profiles;
+                        min-width: self.preferred-width > 150px ? self.preferred-width : 150px;
                         current-index: ControllerData.selected_profile_binding[player];
                         selected => {
                             ControllerData.selected_profile_binding[player] = self.current-index;
@@ -103,14 +115,16 @@ export component ControllerConfig inherits Page {
 
             GroupBox {
                 title: @tr("Controller");
+                horizontal-stretch: 0.75;
                 VerticalLayout {
                     alignment: space-between;
                     for player in [0, 1, 2, 3]: ComboBox {
                         model: ControllerData.controller_names;
-                        width: self.preferred-width;
+                        min-width: self.preferred-width > 300px ? self.preferred-width : 300px;
                         current-index: ControllerData.selected_controller[player];
                         selected => {
                             ControllerData.selected_controller[player] = self.current-index;
+                            ControllerData.controller_changed[player] = true;
                         }
                     }
                 }

src/ui/gui/input_profile.slint

@@ -1,19 +1,21 @@
-import { StandardButton, HorizontalBox, VerticalBox, Button, LineEdit, CheckBox } from "std-widgets.slint";
+import { StandardButton, HorizontalBox, VerticalBox, Button, LineEdit, Switch, Slider } from "std-widgets.slint";
 
 export global InputProfileData {
     in-out property <bool> dinput;
     in-out property <string> profile_name;
+    in-out property <int> deadzone;
 }
 
 export component InputProfileDialog inherits Window {
-    title: @tr("Create Input Profile");
+    title: @tr("Create/Modify Input Profile");
     callback profile_creation_button_clicked;
     in-out property dinput <=> InputProfileData.dinput;
     in-out property profile_name <=> InputProfileData.profile_name;
+    in-out property deadzone <=> InputProfileData.deadzone;
     VerticalBox {
         HorizontalBox {
             LineEdit {
-                placeholder-text: @tr("Enter profile name");
+                placeholder-text: @tr("Enter profile name to create or modify");
                 preferred-width: 300px;
                 edited(text) => {
                     InputProfileData.profile_name = text;
@@ -23,7 +25,29 @@ export component InputProfileDialog inherits Window {
 
         HorizontalBox {
             alignment: center;
-            CheckBox {
+            Text {
+                text: @tr("Deadzone Percentage");
+                vertical-alignment: center;
+            }
+
+            Slider {
+                min-width: 160px;
+                maximum: 99;
+                value: InputProfileData.deadzone;
+                changed(value) => {
+                    InputProfileData.deadzone = value;
+                }
+            }
+
+            Text {
+                text: InputProfileData.deadzone + "%";
+                vertical-alignment: center;
+            }
+        }
+
+        HorizontalBox {
+            alignment: center;
+            Switch {
                 text: @tr("Use DirectInput");
                 checked: InputProfileData.dinput;
                 toggled => {

src/ui/gui/localgame_page.slint

@@ -1,18 +1,20 @@
 // Copyright © SixtyFPS GmbH <info@slint.dev>
 // SPDX-License-Identifier: MIT
 
-import { Button, HorizontalBox, VerticalBox } from "std-widgets.slint";
+import { Button, HorizontalBox, VerticalBox, GroupBox } from "std-widgets.slint";
 import { Page } from "page.slint";
 import { AboutData, NewVersionButton } from "about_page.slint";
 
 export global State {
     in-out property <bool> game_running;
+    in-out property <[{a:string, b:string}]> recent_roms;
 }
 
 export component LocalGame inherits Page {
     callback open_rom_button_clicked;
     callback saves_folder_button_clicked;
     callback newversion_button_clicked;
+    callback recent_rom_button_clicked(string);
     title: @tr("Local Game");
 
     VerticalBox {
@@ -44,5 +46,22 @@ export component LocalGame inherits Page {
             }
         }
         Rectangle { }
+
+        if State.recent_roms.length>0:HorizontalBox {
+            alignment: center;
+            GroupBox {
+                title: @tr("Recent ROMs");
+                VerticalLayout {
+                    alignment: space-between;
+                    for rom in State.recent_roms: Button {
+                        text: rom.b;
+                        enabled: !State.game_running;
+                        clicked => {
+                            recent_rom_button_clicked(rom.a);
+                        }
+                    }
+                }
+            }
+        }
     }
 }

src/ui/gui/netplay_create.slint

@@ -5,15 +5,16 @@ export component NetplayCreate inherits Window {
     title: @tr("Netplay: Create Session");
     in-out property server_names <=> NetplayData.server_names;
     in-out property server_urls <=> NetplayData.server_urls;
-    in-out property ping <=> NetplayData.ping;
+    in-out property custom_server_url <=> NetplayData.custom_server_url;
     in-out property game_name <=> NetplayData.game_name;
     in-out property game_hash <=> NetplayData.game_hash;
     in-out property game_cheats <=> NetplayData.game_cheats;
     in-out property pending_session <=> NetplayData.pending_session;
     in-out property rom_path <=> NetplayData.rom_path;
     in-out property peer_addr <=> NetplayData.peer_addr;
-    callback get_ping(string);
-    callback select_rom;
+    in-out property rom_dir <=> NetplayData.rom_dir;
+    callback get_custom_url();
+    callback select_rom(string);
     callback create_session(string, string, string, string, string, string, string);
 
     VerticalBox {
@@ -24,7 +25,7 @@ export component NetplayCreate inherits Window {
                 }
 
                 LineEdit {
-                    placeholder_text: @tr("Enter session name");
+                    placeholder-text: @tr("Enter session name");
                     edited(text) => {
                         NetplayData.session_name = text;
                     }
@@ -37,7 +38,7 @@ export component NetplayCreate inherits Window {
                 }
 
                 LineEdit {
-                    placeholder_text: @tr("Enter session password");
+                    placeholder-text: @tr("Enter session password");
                     edited(text) => {
                         NetplayData.password = text;
                     }
@@ -51,7 +52,7 @@ export component NetplayCreate inherits Window {
             }
 
             LineEdit {
-                placeholder_text: @tr("Enter player name");
+                placeholder-text: @tr("Enter player name");
                 edited(text) => {
                     NetplayData.player_name = text;
                 }
@@ -68,28 +69,25 @@ export component NetplayCreate inherits Window {
                     model: NetplayData.server_names;
                     selected => {
                         if (self.current-index >= 0) {
-                            get_ping(NetplayData.server_urls[self.current-index]);
+                            if (self.current-value == "Custom") {
+                                get_custom_url();
+                            }
                         }
                     }
                 }
-
-                Text {
-                    vertical-alignment: center;
-                    text: NetplayData.ping;
-                }
             }
         }
 
         if NetplayData.game_name == "": Button {
             text: @tr("Select ROM");
             clicked => {
-                select_rom();
+                select_rom(NetplayData.rom_dir);
             }
         }
         if NetplayData.game_name != "": Button {
             text: NetplayData.game_name;
             clicked => {
-                select_rom();
+                select_rom(NetplayData.rom_dir);
             }
         }
 
@@ -101,12 +99,18 @@ export component NetplayCreate inherits Window {
         Rectangle { }
 
         Button {
+            property <string> server_url;
             text: @tr("Create Session");
             enabled: NetplayData.session_name != "" && NetplayData.player_name != "" && NetplayData.game_name != "" && !NetplayData.pending_session;
             clicked => {
                 NetplayData.pending_session = true;
+                if (server.current-value == "Custom") {
+                    server_url = "ws://" + NetplayData.custom_server_url;
+                } else {
+                    server_url = NetplayData.server_urls[server.current-index];
+                }
                 create_session(
-                    NetplayData.server_urls[server.current-index],
+                    server_url,
                     NetplayData.session_name,
                     NetplayData.player_name,
                     NetplayData.game_name,
@@ -117,3 +121,10 @@ export component NetplayCreate inherits Window {
         }
     }
 }
+
+export component DispatcherDialog inherits Dialog {
+    title: @tr("Creating Server");
+    Text {
+        text: "Creating server, please wait...This may take about 30 seconds.";
+    }
+}

src/ui/gui/netplay_join.slint

@@ -5,30 +5,33 @@ export component NetplayJoin inherits Window {
     title: @tr("Netplay: Join Session");
     in-out property server_names <=> NetplayData.server_names;
     in-out property server_urls <=> NetplayData.server_urls;
-    in-out property ping <=> NetplayData.ping;
+    in-out property custom_server_url <=> NetplayData.custom_server_url;
     in-out property sessions <=> NetplayData.sessions;
     in-out property current_session <=> NetplayData.current_session;
-    in-out property ports <=> NetplayData.ports;
+    in-out property room_urls <=> NetplayData.room_urls;
+    in-out property room_ports <=> NetplayData.room_ports;
     in-out property game_name <=> NetplayData.game_name;
     in-out property game_hash <=> NetplayData.game_hash;
     in-out property game_cheats <=> NetplayData.game_cheats;
     in-out property peer_addr <=> NetplayData.peer_addr;
     in-out property pending_session <=> NetplayData.pending_session;
+    in-out property pending_refresh <=> NetplayData.pending_refresh;
     in-out property rom_path <=> NetplayData.rom_path;
-    callback get_ping(string);
-    callback refresh_session(string);
-    callback select_rom;
-    callback join_session(string, string, string, int);
+    in-out property rom_dir <=> NetplayData.rom_dir;
+    callback refresh_session();
+    callback select_rom(string);
+    callback join_session(string, string, string, string, int);
+    preferred-width: 700px;
 
     VerticalBox {
         HorizontalBox {
             VerticalBox {
                 Text {
-                    text: @tr("Player Name:");
+                    text: @tr("Player Name (required):");
                 }
 
                 LineEdit {
-                    placeholder_text: @tr("Enter player name");
+                    placeholder-text: @tr("Enter player name");
                     edited(text) => {
                         NetplayData.player_name = text;
                     }
@@ -37,39 +40,37 @@ export component NetplayJoin inherits Window {
 
             VerticalBox {
                 Text {
-                    text: @tr("Server:");
+                    text: @tr("Custom Server URL (optional):");
                 }
 
-                HorizontalBox {
-                    server := ComboBox {
-                        model: NetplayData.server_names;
-                        selected => {
-                            if (self.current-index >= 0) {
-                                get_ping(NetplayData.server_urls[self.current-index]);
-                            }
-                        }
-                    }
-
-                    Text {
-                        vertical-alignment: center;
-                        text: NetplayData.ping;
+                LineEdit {
+                    placeholder-text: @tr("example.com:45000");
+                    text: NetplayData.custom_server_url;
+                    edited(text) => {
+                        NetplayData.custom_server_url = text;
                     }
                 }
             }
         }
 
-        if NetplayData.sessions.length > 0: Text {
+        if NetplayData.pending_refresh: Text {
+            text: @tr("Refreshing session list, please wait...");
+            horizontal-alignment: center;
+            vertical-alignment: center;
+        }
+        if !NetplayData.pending_refresh && NetplayData.sessions.length > 0: Text {
             text: @tr("Click on a session below to select it");
             horizontal-alignment: center;
             vertical-alignment: center;
         }
-        if NetplayData.sessions.length == 0: Text {
-            text: @tr("No sessions available. Please refresh or try a different server.");
+        if !NetplayData.pending_refresh && NetplayData.sessions.length == 0: Text {
+            text: @tr("No sessions available. Please refresh to check again.");
             horizontal-alignment: center;
             vertical-alignment: center;
         }
         StandardTableView {
             columns: [
+                { title: "Server" },
                 { title: "Session Name" },
                 { title: "Game Name" },
                 { title: "Password" },
@@ -86,9 +87,15 @@ export component NetplayJoin inherits Window {
             Rectangle { }
 
             Button {
+                enabled: !NetplayData.pending_refresh;
                 text: @tr("Refresh Session List");
                 clicked => {
-                    refresh_session(NetplayData.server_urls[server.current-index]);
+                    NetplayData.pending_refresh = true;
+                    NetplayData.current_session = -1;
+                    NetplayData.sessions = [];
+                    NetplayData.room_urls = [];
+                    NetplayData.room_ports = [];
+                    refresh_session();
                 }
             }
         }
@@ -104,13 +111,13 @@ export component NetplayJoin inherits Window {
             if NetplayData.game_name == "": Button {
                 text: @tr("Select ROM");
                 clicked => {
-                    select_rom();
+                    select_rom(NetplayData.rom_dir);
                 }
             }
             if NetplayData.game_name != "": Button {
                 text: NetplayData.game_name;
                 clicked => {
-                    select_rom();
+                    select_rom(NetplayData.rom_dir);
                 }
             }
 
@@ -123,7 +130,8 @@ export component NetplayJoin inherits Window {
                     NetplayData.player_name,
                     NetplayData.game_hash,
                     NetplayData.password,
-                    NetplayData.ports[NetplayData.current_session]);
+                    NetplayData.room_urls[NetplayData.current_session],
+                    NetplayData.room_ports[NetplayData.current_session]);
                 }
             }
         }

src/ui/gui/netplay_page.slint

@@ -1,13 +1,12 @@
 // Copyright © SixtyFPS GmbH <info@slint.dev>
 // SPDX-License-Identifier: MIT
 
-import { VerticalBox, HorizontalBox, Button } from "std-widgets.slint";
+import { StandardButton, VerticalBox, HorizontalBox, Button, LineEdit } from "std-widgets.slint";
 import { Page } from "page.slint";
 
 export global NetplayData {
     in-out property <[string]> server_names;
     in-out property <[string]> server_urls;
-    in-out property <string> ping: "Ping: Unknown";
     in-out property <string> player_name;
     in-out property <string> game_name;
     in-out property <string> game_hash;
@@ -16,10 +15,14 @@ export global NetplayData {
     in-out property <string> password;
     in-out property <string> peer_addr;
     in-out property <bool> pending_session;
+    in-out property <bool> pending_refresh;
     in-out property <string> session_name;
     in-out property <[[StandardListViewItem]]> sessions;
-    in-out property <[int]> ports;
+    in-out property <[string]> room_urls;
+    in-out property <[int]> room_ports;
     in-out property <int> current_session: -1;
+    in-out property <string> rom_dir;
+    in-out property <string> custom_server_url;
 }
 
 export component Netplay inherits Page {
@@ -73,3 +76,22 @@ export component Netplay inherits Page {
         }
     }
 }
+
+export component CustomNetplayServer inherits Dialog {
+    in-out property custom_server_url <=> NetplayData.custom_server_url;
+    title: @tr("Custom Netplay Server");
+    preferred-width: 400px;
+    callback ok_clicked(string);
+    server_url := LineEdit {
+        text: NetplayData.custom_server_url;
+        placeholder-text: "example.com:45000";
+    }
+
+    StandardButton {
+        kind: ok;
+        clicked => {
+            NetplayData.custom_server_url = server_url.text;
+            ok_clicked(NetplayData.custom_server_url);
+        }
+    }
+}

src/ui/gui/netplay_wait.slint

@@ -7,6 +7,7 @@ export global NetplayWaitData {
     in-out property <int> port;
     in-out property <bool> can_start;
     in-out property <string> chat_text;
+    in-out property <string> ping;
 }
 
 export component NetplayWait inherits Window {
@@ -21,6 +22,7 @@ export component NetplayWait inherits Window {
     in-out property port <=> NetplayWaitData.port;
     in-out property can_start <=> NetplayWaitData.can_start;
     in-out property chat_text <=> NetplayWaitData.chat_text;
+    in-out property ping <=> NetplayWaitData.ping;
     callback send_chat_message(string);
     callback begin_game;
 
@@ -37,6 +39,11 @@ export component NetplayWait inherits Window {
             horizontal-alignment: center;
         }
 
+        Text {
+            text: @tr("Ping: ") + NetplayWaitData.ping;
+            horizontal-alignment: center;
+        }
+
         GridBox {
             Row {
                 Text {
@@ -66,7 +73,7 @@ export component NetplayWait inherits Window {
 
         HorizontalBox {
             chat_message := LineEdit {
-                placeholder_text: @tr("Enter chat message");
+                placeholder-text: @tr("Enter chat message");
                 key-released(event) => {
                     if (event.text == Key.Return && chat_message.text != "") {
                         send_chat_message(chat_message.text);

src/ui/gui/pages.slint

@@ -2,5 +2,6 @@ export { LocalGame } from "localgame_page.slint";
 export { ControllerConfig } from "controller_page.slint";
 export { Netplay } from "netplay_page.slint";
 export { Cheats } from "cheat_page.slint";
+export { RetroAchievements } from "retroachievements_page.slint";
 export { Settings } from "settings_page.slint";
 export { About } from "about_page.slint";

src/ui/gui/retroachievements_page.slint

@@ -0,0 +1,143 @@
+// Copyright © SixtyFPS GmbH <info@slint.dev>
+// SPDX-License-Identifier: MIT
+
+import { LineEdit, Switch, Button, HorizontalBox, VerticalBox } from "std-widgets.slint";
+import { Page } from "page.slint";
+
+export global RAData {
+    in-out property <bool> enabled;
+    in-out property <bool> hardcore;
+    in-out property <bool> challenge;
+    in-out property <bool> leaderboard;
+    in-out property <bool> ra_logging_in;
+    in-out property <bool> ra_show_profile;
+    in-out property <bool> ra_softcore_only;
+    in-out property <string> ra_username;
+    in-out property <string> ra_password;
+    in-out property <string> current_user_message;
+}
+
+export component RetroAchievements inherits Page {
+    callback ra_button_clicked(string);
+    callback ra_toggled(bool,bool,bool,bool);
+    callback ra_games_clicked;
+    callback ra_show_profile_clicked;
+    title: @tr("RetroAchievements");
+
+    VerticalBox {
+        alignment: start;
+        HorizontalBox {
+            alignment: start;
+            Switch {
+                text: @tr("Enabled");
+                checked: RAData.enabled;
+                toggled => {
+                    RAData.enabled = self.checked;
+                    if (!RAData.enabled) {
+                        RAData.ra_username = "";
+                        username_widget.text = "";
+                        password_widget.text = "";
+                        RAData.current_user_message = "Not currently logged in";
+                        RAData.ra_show_profile = false;
+                    }
+                    ra_toggled(RAData.enabled,RAData.hardcore,RAData.challenge,RAData.leaderboard);
+                }
+            }
+        }
+        if !RAData.ra_softcore_only:HorizontalBox {
+            alignment: start;
+            Switch {
+                text: @tr("Hardcore mode");
+                checked: RAData.hardcore;
+                enabled: RAData.enabled;
+                toggled => {
+                    RAData.hardcore = self.checked;
+                    ra_toggled(RAData.enabled,RAData.hardcore,RAData.challenge,RAData.leaderboard);
+                }
+            }
+        }
+        HorizontalBox {
+            alignment: start;
+            Switch {
+                text: @tr("Challenge Indicators");
+                checked: RAData.challenge;
+                enabled: RAData.enabled;
+                toggled => {
+                    RAData.challenge = self.checked;
+                    ra_toggled(RAData.enabled,RAData.hardcore,RAData.challenge,RAData.leaderboard);
+                }
+            }
+        }
+        HorizontalBox {
+            alignment: start;
+            Switch {
+                text: @tr("Leaderboard Trackers");
+                checked: RAData.leaderboard;
+                enabled: RAData.enabled;
+                toggled => {
+                    RAData.leaderboard = self.checked;
+                    ra_toggled(RAData.enabled,RAData.hardcore,RAData.challenge,RAData.leaderboard);
+                }
+            }
+        }
+        HorizontalBox {
+            alignment: center;
+            Text {
+                text: RAData.current_user_message;
+                vertical-alignment: center;
+            }
+            if RAData.ra_show_profile:Button {
+                enabled: RAData.enabled;
+                text: @tr("View Profile");
+                clicked => {
+                    ra_show_profile_clicked();
+                }
+            }
+        }
+        HorizontalBox {
+            alignment: center;
+            username_widget := LineEdit {
+                enabled: RAData.enabled;
+                placeholder-text: @tr("Username");
+                text: RAData.ra_username;
+                edited(text) => {
+                    RAData.ra_username = text;
+                }
+                
+            }
+            password_widget := LineEdit {
+                enabled: RAData.enabled;
+                input-type: password;
+                placeholder-text: @tr("Password");
+                edited(text) => {
+                    RAData.ra_password = text;
+                }
+            }
+        }
+        HorizontalBox {
+            alignment: center;
+            Button {
+                text: @tr("Login");
+                enabled: RAData.enabled && !RAData.ra_logging_in && RAData.ra_username != "" && RAData.ra_password != "";
+                clicked => {
+                    RAData.ra_logging_in = true;
+                    ra_button_clicked(RAData.ra_password);
+                    RAData.ra_password = "";
+                    password_widget.text = "";
+                }
+            }
+        }
+        Rectangle {
+            height: 20px;
+        }
+        HorizontalBox {
+            alignment: center;
+            Button {
+                text: @tr("View Supported Games");
+                clicked => {
+                    ra_games_clicked();
+                }
+            }
+        }
+    }
+}

src/ui/gui/settings_page.slint

@@ -1,17 +1,21 @@
 // Copyright © SixtyFPS GmbH <info@slint.dev>
 // SPDX-License-Identifier: MIT
 
-import { ComboBox, HorizontalBox, VerticalBox, CheckBox } from "std-widgets.slint";
+import { ComboBox, HorizontalBox, VerticalBox, Switch } from "std-widgets.slint";
 import { Page } from "page.slint";
 
 export global SettingsData {
     in-out property <bool> integer_scaling;
+    in-out property <bool> ssaa;
     in-out property <bool> fullscreen;
     in-out property <bool> widescreen;
+    in-out property <bool> vsync;
     in-out property <bool> apply_crt_shader;
     in-out property <bool> overclock_n64_cpu;
     in-out property <bool> disable_expansion_pak;
     in-out property <int> resolution;
+    in-out property <bool> emulate_usb;
+    in-out property <string> rom_dir;
 }
 
 export component Settings inherits Page {
@@ -27,7 +31,7 @@ export component Settings inherits Page {
             }
 
             ComboBox {
-                model: ["1x", "2x", "4x"];
+                model: ["1x", "2x", "4x", "8x"];
                 current-index: SettingsData.resolution;
                 selected => {
                     SettingsData.resolution = self.current-index;
@@ -37,7 +41,18 @@ export component Settings inherits Page {
 
         HorizontalBox {
             alignment: start;
-            CheckBox {
+            Switch {
+                text: @tr("SSAA downscaling");
+                checked: SettingsData.ssaa;
+                toggled => {
+                    SettingsData.ssaa = self.checked;
+                }
+            }
+        }
+
+        HorizontalBox {
+            alignment: start;
+            Switch {
                 text: @tr("Integer Scaling");
                 checked: SettingsData.integer_scaling;
                 toggled => {
@@ -48,8 +63,8 @@ export component Settings inherits Page {
 
         HorizontalBox {
             alignment: start;
-            CheckBox {
-                text: @tr("Fullscreen (Esc closes game)");
+            Switch {
+                text: @tr("Fullscreen");
                 checked: SettingsData.fullscreen;
                 toggled => {
                     SettingsData.fullscreen = self.checked;
@@ -59,8 +74,8 @@ export component Settings inherits Page {
 
         HorizontalBox {
             alignment: start;
-            CheckBox {
-                text: @tr("Widescreen (strech)");
+            Switch {
+                text: @tr("Widescreen (stretch)");
                 checked: SettingsData.widescreen;
                 toggled => {
                     SettingsData.widescreen = self.checked;
@@ -70,7 +85,18 @@ export component Settings inherits Page {
 
         HorizontalBox {
             alignment: start;
-            CheckBox {
+            Switch {
+                text: @tr("VSync");
+                checked: SettingsData.vsync;
+                toggled => {
+                    SettingsData.vsync = self.checked;
+                }
+            }
+        }
+
+        HorizontalBox {
+            alignment: start;
+            Switch {
                 text: @tr("Apply CRT shader");
                 checked: SettingsData.apply_crt_shader;
                 toggled => {
@@ -79,11 +105,13 @@ export component Settings inherits Page {
             }
         }
 
-        Rectangle { }
+        Rectangle {
+            height: 20px;
+        }
 
         HorizontalBox {
             alignment: start;
-            CheckBox {
+            Switch {
                 text: @tr("Overclock N64 CPU (may cause bugs)");
                 checked: SettingsData.overclock_n64_cpu;
                 toggled => {
@@ -94,7 +122,7 @@ export component Settings inherits Page {
 
         HorizontalBox {
             alignment: start;
-            CheckBox {
+            Switch {
                 text: @tr("Disable Expansion Pak");
                 checked: SettingsData.disable_expansion_pak;
                 toggled => {
@@ -102,5 +130,16 @@ export component Settings inherits Page {
                 }
             }
         }
+
+        HorizontalBox {
+            alignment: start;
+            Switch {
+                text: @tr("Emulate UNFLoader");
+                checked: SettingsData.emulate_usb;
+                toggled => {
+                    SettingsData.emulate_usb = self.checked;
+                }
+            }
+        }
     }
 }

src/ui/input.rs

@@ -20,7 +20,7 @@ const AXIS_LEFT: usize = 14;
 const AXIS_RIGHT: usize = 15;
 const AXIS_UP: usize = 16;
 const AXIS_DOWN: usize = 17;
-const CHANGE_PAK: usize = 18;
+const HOTKEY: usize = 18;
 pub const PROFILE_SIZE: usize = 19;
 
 const X_AXIS_SHIFT: usize = 16;
@@ -28,10 +28,14 @@ const Y_AXIS_SHIFT: usize = 24;
 
 const MAX_AXIS_VALUE: f64 = 85.0;
 
+pub const DEADZONE_DEFAULT: i32 = 5;
+
 pub struct Controllers {
     pub rumble: bool,
     pub game_controller: *mut sdl3_sys::gamepad::SDL_Gamepad,
     pub joystick: *mut sdl3_sys::joystick::SDL_Joystick,
+    pub guid: sdl3_sys::guid::SDL_GUID,
+    pub last_key_state: u32,
 }
 
 pub struct InputData {
@@ -40,7 +44,7 @@ pub struct InputData {
 }
 
 fn bound_axis(x: &mut f64, y: &mut f64) {
-    let radius = 95.0; // this is roughly the maxium diagonal distance of the controller
+    let radius = f64::sqrt(70.0 * 70.0 + 70.0 * 70.0); // this is roughly the maximum diagonal distance of the controller
 
     // Calculate the distance from the origin (0, 0)
     let distance = f64::sqrt((*x) * (*x) + (*y) * (*y));
@@ -53,6 +57,28 @@ fn bound_axis(x: &mut f64, y: &mut f64) {
     }
 }
 
+fn apply_deadzone(x: &mut f64, y: &mut f64, deadzone: i32) {
+    let axis_deadzone = MAX_AXIS_VALUE * (deadzone as f64 / 100.0);
+
+    // Calculate the distance from the origin (0, 0)
+    let distance = f64::sqrt((*x) * (*x) + (*y) * (*y));
+
+    if distance <= axis_deadzone {
+        *x = 0.0;
+        *y = 0.0;
+        return;
+    }
+
+    let new_distance =
+        (distance - axis_deadzone) * MAX_AXIS_VALUE / (MAX_AXIS_VALUE - axis_deadzone);
+    *x = *x / distance * new_distance;
+    *y = *y / distance * new_distance;
+}
+
+fn normalize_axis_position(axis_position: i16) -> f64 {
+    axis_position as f64 * MAX_AXIS_VALUE / i16::MAX as f64
+}
+
 fn set_axis_from_joystick(
     profile: &ui::config::InputProfile,
     joystick: *mut sdl3_sys::joystick::SDL_Joystick,
@@ -64,7 +90,7 @@ fn set_axis_from_joystick(
             sdl3_sys::joystick::SDL_GetJoystickAxis(joystick, profile.joystick_axis[AXIS_LEFT].id)
         };
         if axis_position as isize * profile.joystick_axis[AXIS_LEFT].axis as isize > 0 {
-            x = axis_position as f64 * MAX_AXIS_VALUE / i16::MAX as f64;
+            x = normalize_axis_position(axis_position);
         }
     }
     if profile.joystick_axis[AXIS_RIGHT].enabled {
@@ -72,7 +98,7 @@ fn set_axis_from_joystick(
             sdl3_sys::joystick::SDL_GetJoystickAxis(joystick, profile.joystick_axis[AXIS_RIGHT].id)
         };
         if axis_position as isize * profile.joystick_axis[AXIS_RIGHT].axis as isize > 0 {
-            x = axis_position as f64 * MAX_AXIS_VALUE / i16::MAX as f64;
+            x = normalize_axis_position(axis_position);
         }
     }
     if profile.joystick_axis[AXIS_DOWN].enabled {
@@ -80,7 +106,7 @@ fn set_axis_from_joystick(
             sdl3_sys::joystick::SDL_GetJoystickAxis(joystick, profile.joystick_axis[AXIS_DOWN].id)
         };
         if axis_position as isize * profile.joystick_axis[AXIS_DOWN].axis as isize > 0 {
-            y = (axis_position as f64 * MAX_AXIS_VALUE / i16::MAX as f64).neg();
+            y = normalize_axis_position(axis_position).neg();
         }
     }
     if profile.joystick_axis[AXIS_UP].enabled {
@@ -88,45 +114,12 @@ fn set_axis_from_joystick(
             sdl3_sys::joystick::SDL_GetJoystickAxis(joystick, profile.joystick_axis[AXIS_UP].id)
         };
         if axis_position as isize * profile.joystick_axis[AXIS_UP].axis as isize > 0 {
-            y = (axis_position as f64 * MAX_AXIS_VALUE / i16::MAX as f64).neg();
+            y = normalize_axis_position(axis_position).neg();
         }
     }
     (x, y)
 }
 
-fn get_axis_from_i32(axis: i32) -> sdl3_sys::gamepad::SDL_GamepadAxis {
-    match axis {
-        0 => sdl3_sys::gamepad::SDL_GamepadAxis::LEFTX,
-        1 => sdl3_sys::gamepad::SDL_GamepadAxis::LEFTY,
-        2 => sdl3_sys::gamepad::SDL_GamepadAxis::RIGHTX,
-        3 => sdl3_sys::gamepad::SDL_GamepadAxis::RIGHTY,
-        4 => sdl3_sys::gamepad::SDL_GamepadAxis::LEFT_TRIGGER,
-        5 => sdl3_sys::gamepad::SDL_GamepadAxis::RIGHT_TRIGGER,
-        _ => panic!("Invalid axis"),
-    }
-}
-
-fn get_button_from_i32(button: i32) -> sdl3_sys::gamepad::SDL_GamepadButton {
-    match button {
-        0 => sdl3_sys::gamepad::SDL_GamepadButton::SOUTH,
-        1 => sdl3_sys::gamepad::SDL_GamepadButton::EAST,
-        2 => sdl3_sys::gamepad::SDL_GamepadButton::WEST,
-        3 => sdl3_sys::gamepad::SDL_GamepadButton::NORTH,
-        4 => sdl3_sys::gamepad::SDL_GamepadButton::BACK,
-        5 => sdl3_sys::gamepad::SDL_GamepadButton::GUIDE,
-        6 => sdl3_sys::gamepad::SDL_GamepadButton::START,
-        7 => sdl3_sys::gamepad::SDL_GamepadButton::LEFT_STICK,
-        8 => sdl3_sys::gamepad::SDL_GamepadButton::RIGHT_STICK,
-        9 => sdl3_sys::gamepad::SDL_GamepadButton::LEFT_SHOULDER,
-        10 => sdl3_sys::gamepad::SDL_GamepadButton::RIGHT_SHOULDER,
-        11 => sdl3_sys::gamepad::SDL_GamepadButton::DPAD_UP,
-        12 => sdl3_sys::gamepad::SDL_GamepadButton::DPAD_DOWN,
-        13 => sdl3_sys::gamepad::SDL_GamepadButton::DPAD_LEFT,
-        14 => sdl3_sys::gamepad::SDL_GamepadButton::DPAD_RIGHT,
-        _ => panic!("Invalid button"),
-    }
-}
-
 fn set_axis_from_controller(
     profile: &ui::config::InputProfile,
     controller: *mut sdl3_sys::gamepad::SDL_Gamepad,
@@ -137,44 +130,44 @@ fn set_axis_from_controller(
         let axis_position = unsafe {
             sdl3_sys::gamepad::SDL_GetGamepadAxis(
                 controller,
-                get_axis_from_i32(profile.controller_axis[AXIS_LEFT].id),
+                sdl3_sys::gamepad::SDL_GamepadAxis(profile.controller_axis[AXIS_LEFT].id),
             )
         };
         if axis_position as isize * profile.controller_axis[AXIS_LEFT].axis as isize > 0 {
-            x = axis_position as f64 * MAX_AXIS_VALUE / i16::MAX as f64;
+            x = normalize_axis_position(axis_position);
         }
     }
     if profile.controller_axis[AXIS_RIGHT].enabled {
         let axis_position = unsafe {
             sdl3_sys::gamepad::SDL_GetGamepadAxis(
                 controller,
-                get_axis_from_i32(profile.controller_axis[AXIS_RIGHT].id),
+                sdl3_sys::gamepad::SDL_GamepadAxis(profile.controller_axis[AXIS_RIGHT].id),
             )
         };
         if axis_position as isize * profile.controller_axis[AXIS_RIGHT].axis as isize > 0 {
-            x = axis_position as f64 * MAX_AXIS_VALUE / i16::MAX as f64;
+            x = normalize_axis_position(axis_position);
         }
     }
     if profile.controller_axis[AXIS_DOWN].enabled {
         let axis_position = unsafe {
             sdl3_sys::gamepad::SDL_GetGamepadAxis(
                 controller,
-                get_axis_from_i32(profile.controller_axis[AXIS_DOWN].id),
+                sdl3_sys::gamepad::SDL_GamepadAxis(profile.controller_axis[AXIS_DOWN].id),
             )
         };
         if axis_position as isize * profile.controller_axis[AXIS_DOWN].axis as isize > 0 {
-            y = (axis_position as f64 * MAX_AXIS_VALUE / i16::MAX as f64).neg();
+            y = normalize_axis_position(axis_position).neg();
         }
     }
     if profile.controller_axis[AXIS_UP].enabled {
         let axis_position = unsafe {
             sdl3_sys::gamepad::SDL_GetGamepadAxis(
                 controller,
-                get_axis_from_i32(profile.controller_axis[AXIS_UP].id),
+                sdl3_sys::gamepad::SDL_GamepadAxis(profile.controller_axis[AXIS_UP].id),
             )
         };
         if axis_position as isize * profile.controller_axis[AXIS_UP].axis as isize > 0 {
-            y = (axis_position as f64 * MAX_AXIS_VALUE / i16::MAX as f64).neg();
+            y = normalize_axis_position(axis_position).neg();
         }
     }
     (x, y)
@@ -225,8 +218,9 @@ fn set_buttons_from_joystick(
 
     let profile_joystick_hat = profile.joystick_hat[i];
     if profile_joystick_hat.enabled
-        && unsafe { sdl3_sys::joystick::SDL_GetJoystickHat(joystick, profile_joystick_hat.id) }
-            == profile_joystick_hat.direction
+        && (unsafe { sdl3_sys::joystick::SDL_GetJoystickHat(joystick, profile_joystick_hat.id) }
+            & profile_joystick_hat.direction)
+            != 0
     {
         *keys |= 1 << i;
     }
@@ -254,7 +248,7 @@ fn set_buttons_from_controller(
         *keys |= (unsafe {
             sdl3_sys::gamepad::SDL_GetGamepadButton(
                 controller,
-                get_button_from_i32(profile_controller_button.id),
+                sdl3_sys::gamepad::SDL_GamepadButton(profile_controller_button.id),
             )
         } as u32)
             << i;
@@ -265,7 +259,7 @@ fn set_buttons_from_controller(
         let axis_position = unsafe {
             sdl3_sys::gamepad::SDL_GetGamepadAxis(
                 controller,
-                get_axis_from_i32(profile_controller_axis.id),
+                sdl3_sys::gamepad::SDL_GamepadAxis(profile_controller_axis.id),
             )
         };
         if axis_position as isize * profile_controller_axis.axis as isize > 0
@@ -288,7 +282,7 @@ pub fn set_rumble(ui: &ui::Ui, channel: usize, rumble: u8) {
                 controller,
                 (rumble & 1) as u16 * u16::MAX,
                 (rumble & 1) as u16 * u16::MAX,
-                (rumble & 1) as u32 * 60000,
+                (rumble & 1) as u32 * sdl3_sys::haptic::SDL_HAPTIC_INFINITY,
             )
         };
     } else if !joystick.is_null() {
@@ -297,76 +291,200 @@ pub fn set_rumble(ui: &ui::Ui, channel: usize, rumble: u8) {
                 joystick,
                 (rumble & 1) as u16 * u16::MAX,
                 (rumble & 1) as u16 * u16::MAX,
-                (rumble & 1) as u32 * 60000,
+                (rumble & 1) as u32 * sdl3_sys::haptic::SDL_HAPTIC_INFINITY,
             )
         };
     }
 }
 
-fn change_paks(
+fn hotkey_pressed(
     profile: &ui::config::InputProfile,
     joystick: *mut sdl3_sys::joystick::SDL_Joystick,
     controller: *mut sdl3_sys::gamepad::SDL_Gamepad,
-    keyboard_state: *const bool,
 ) -> bool {
-    let controller_button = profile.controller_buttons[CHANGE_PAK];
-    let joystick_button = profile.joystick_buttons[CHANGE_PAK];
-    let joystick_hat = profile.joystick_hat[CHANGE_PAK];
-    let key = profile.keys[CHANGE_PAK];
+    let controller_button = profile.controller_buttons[HOTKEY];
+    let controller_axis = profile.controller_axis[HOTKEY];
+    let joystick_button = profile.joystick_buttons[HOTKEY];
+    let joystick_hat = profile.joystick_hat[HOTKEY];
+    let joystick_axis = profile.joystick_axis[HOTKEY];
 
     let mut pressed = false;
     if controller_button.enabled && !controller.is_null() {
         pressed = unsafe {
             sdl3_sys::gamepad::SDL_GetGamepadButton(
                 controller,
-                get_button_from_i32(controller_button.id),
+                sdl3_sys::gamepad::SDL_GamepadButton(controller_button.id),
             )
         };
+    } else if controller_axis.enabled && !controller.is_null() {
+        let axis_position = unsafe {
+            sdl3_sys::gamepad::SDL_GetGamepadAxis(
+                controller,
+                sdl3_sys::gamepad::SDL_GamepadAxis(controller_axis.id),
+            )
+        };
+        pressed = axis_position as isize * controller_axis.axis as isize > 0
+            && axis_position.saturating_abs() > i16::MAX / 2
     } else if joystick_button.enabled && !joystick.is_null() {
         pressed =
             unsafe { sdl3_sys::joystick::SDL_GetJoystickButton(joystick, joystick_button.id) };
     } else if joystick_hat.enabled && !joystick.is_null() {
-        pressed = unsafe { sdl3_sys::joystick::SDL_GetJoystickHat(joystick, joystick_hat.id) }
-            == joystick_hat.direction;
-    } else if key.enabled {
-        pressed = unsafe { *keyboard_state.offset(key.id as isize) };
+        pressed = (unsafe { sdl3_sys::joystick::SDL_GetJoystickHat(joystick, joystick_hat.id) }
+            & joystick_hat.direction)
+            != 0;
+    } else if joystick_axis.enabled && !joystick.is_null() {
+        let axis_position =
+            unsafe { sdl3_sys::joystick::SDL_GetJoystickAxis(joystick, joystick_axis.id) };
+        pressed = axis_position as isize * joystick_axis.axis as isize > 0
+            && axis_position.saturating_abs() > i16::MAX / 2
     }
     pressed
 }
 
-pub fn get_controller_names(game_ui: &ui::Ui) -> Vec<String> {
+pub fn get_controller_names() -> Vec<String> {
     let mut controllers: Vec<String> = vec![];
 
-    for joystick in game_ui.input.joysticks.iter() {
-        let name = unsafe {
-            std::ffi::CStr::from_ptr(sdl3_sys::joystick::SDL_GetJoystickNameForID(*joystick))
-        };
-        controllers.push(name.to_string_lossy().to_string());
+    for joystick in get_joysticks().iter() {
+        let name = unsafe { sdl3_sys::joystick::SDL_GetJoystickNameForID(*joystick) };
+        controllers.push(if name.is_null() {
+            "Unknown controller".to_string()
+        } else {
+            unsafe { std::ffi::CStr::from_ptr(name).to_str().unwrap() }.to_string()
+        });
     }
+    controllers.insert(0, "None".into());
 
     controllers
 }
 
-pub fn get_controller_paths(game_ui: &ui::Ui) -> Vec<Option<String>> {
-    let mut controller_paths: Vec<Option<String>> = vec![];
+#[cfg(feature = "gui")]
+pub fn get_controller_paths() -> Vec<String> {
+    let mut controller_paths: Vec<String> = vec![];
 
-    for joystick in game_ui.input.joysticks.iter() {
-        let path = unsafe {
-            std::ffi::CStr::from_ptr(sdl3_sys::joystick::SDL_GetJoystickPathForID(*joystick))
-                .to_string_lossy()
-                .to_string()
-        };
-        controller_paths.push(Some(path));
+    for joystick in get_joysticks().iter() {
+        let path = unsafe { sdl3_sys::joystick::SDL_GetJoystickPathForID(*joystick) };
+        controller_paths.push(if path.is_null() {
+            String::new()
+        } else {
+            unsafe { std::ffi::CStr::from_ptr(path).to_str().unwrap() }.to_string()
+        });
     }
+    controller_paths.insert(0, String::new());
 
     controller_paths
 }
 
-pub fn get(ui: &ui::Ui, channel: usize) -> InputData {
-    unsafe { sdl3_sys::events::SDL_PumpEvents() };
+fn handle_joystick_events(ui: &mut ui::Ui) {
+    let joystick_event = unsafe { ui::video::get_joystick_event() };
+    if joystick_event.joystick_id != 0 {
+        let joystick_id = sdl3_sys::joystick::SDL_JoystickID(joystick_event.joystick_id);
+        for (i, controller) in ui.input.controllers.iter_mut().enumerate() {
+            if joystick_event.connected {
+                if let Some(profile) = ui
+                    .config
+                    .input
+                    .input_profiles
+                    .get(&ui.config.input.input_profile_binding[i])
+                {
+                    if profile.dinput {
+                        if controller.joystick.is_null()
+                            && controller.guid
+                                == unsafe {
+                                    sdl3_sys::joystick::SDL_GetJoystickGUIDForID(joystick_id)
+                                }
+                        {
+                            controller.joystick =
+                                unsafe { sdl3_sys::joystick::SDL_OpenJoystick(joystick_id) };
+                        }
+                    } else {
+                        if controller.game_controller.is_null()
+                            && controller.guid
+                                == unsafe {
+                                    sdl3_sys::gamepad::SDL_GetGamepadGUIDForID(joystick_id)
+                                }
+                        {
+                            controller.game_controller =
+                                unsafe { sdl3_sys::gamepad::SDL_OpenGamepad(joystick_id) };
+                        }
+                    }
+                }
+            } else {
+                if !controller.joystick.is_null()
+                    && controller.joystick
+                        == unsafe { sdl3_sys::joystick::SDL_GetJoystickFromID(joystick_id) }
+                {
+                    unsafe { sdl3_sys::joystick::SDL_CloseJoystick(controller.joystick) };
+                    controller.joystick = std::ptr::null_mut();
+                } else if !controller.game_controller.is_null()
+                    && controller.game_controller
+                        == unsafe { sdl3_sys::gamepad::SDL_GetGamepadFromID(joystick_id) }
+                {
+                    unsafe { sdl3_sys::gamepad::SDL_CloseGamepad(controller.game_controller) };
+                    controller.game_controller = std::ptr::null_mut();
+                }
+            }
+        }
+    }
+}
 
-    let profile_name = ui.config.input.input_profile_binding[channel].clone();
-    let profile = ui.config.input.input_profiles.get(&profile_name).unwrap();
+fn handle_hotkeys(keys: u32, last_key_state: u32) {
+    if keys & (1 << L_TRIG) != 0 && last_key_state & (1 << L_TRIG) == 0 {
+        unsafe {
+            sdl3_sys::events::SDL_PushEvent(&mut sdl3_sys::events::SDL_Event {
+                user: sdl3_sys::events::SDL_UserEvent {
+                    r#type: u32::from(sdl3_sys::events::SDL_EVENT_USER),
+                    code: 1, //save state
+                    ..Default::default()
+                },
+            })
+        };
+    }
+    if keys & (1 << R_TRIG) != 0 && last_key_state & (1 << R_TRIG) == 0 {
+        unsafe {
+            sdl3_sys::events::SDL_PushEvent(&mut sdl3_sys::events::SDL_Event {
+                user: sdl3_sys::events::SDL_UserEvent {
+                    r#type: u32::from(sdl3_sys::events::SDL_EVENT_USER),
+                    code: 2, //load state
+                    ..Default::default()
+                },
+            })
+        };
+    }
+    if keys & (1 << START_BUTTON) != 0 && last_key_state & (1 << START_BUTTON) == 0 {
+        unsafe {
+            sdl3_sys::events::SDL_PushEvent(&mut sdl3_sys::events::SDL_Event {
+                user: sdl3_sys::events::SDL_UserEvent {
+                    r#type: u32::from(sdl3_sys::events::SDL_EVENT_USER),
+                    code: 3, //exit game
+                    ..Default::default()
+                },
+            })
+        };
+    }
+    if keys & (1 << Z_TRIG) != 0 && last_key_state & (1 << Z_TRIG) == 0 {
+        unsafe {
+            sdl3_sys::events::SDL_PushEvent(&mut sdl3_sys::events::SDL_Event {
+                user: sdl3_sys::events::SDL_UserEvent {
+                    r#type: u32::from(sdl3_sys::events::SDL_EVENT_USER),
+                    code: 4, //fast forward
+                    ..Default::default()
+                },
+            })
+        };
+    }
+}
+
+pub fn get(ui: &mut ui::Ui, channel: usize) -> InputData {
+    handle_joystick_events(ui);
+
+    let profile_name = &ui.config.input.input_profile_binding[channel];
+    let Some(profile) = ui.config.input.input_profiles.get(profile_name) else {
+        eprintln!("Invalid profile name: {profile_name}");
+        return InputData {
+            data: 0,
+            pak_change_pressed: false,
+        };
+    };
     let mut keys = 0;
     let controller = ui.input.controllers[channel].game_controller;
     let joystick = ui.input.controllers[channel].joystick;
@@ -407,54 +525,76 @@ pub fn get(ui: &ui::Ui, channel: usize) -> InputData {
     }
 
     if !controller.is_null() {
-        (x, y) = set_axis_from_controller(profile, controller)
+        (x, y) = set_axis_from_controller(profile, controller);
+        apply_deadzone(&mut x, &mut y, profile.deadzone);
     } else if !joystick.is_null() {
-        (x, y) = set_axis_from_joystick(profile, joystick)
+        (x, y) = set_axis_from_joystick(profile, joystick);
+        apply_deadzone(&mut x, &mut y, profile.deadzone);
     }
     bound_axis(&mut x, &mut y);
 
     keys |= (x.round() as i8 as u8 as u32) << X_AXIS_SHIFT;
     keys |= (y.round() as i8 as u8 as u32) << Y_AXIS_SHIFT;
 
-    InputData {
-        data: keys,
-        pak_change_pressed: change_paks(profile, joystick, controller, ui.input.keyboard_state),
-    }
-}
+    let last_key_state = ui.input.controllers[channel].last_key_state;
+    ui.input.controllers[channel].last_key_state = keys;
 
-pub fn assign_controller(ui: &mut ui::Ui, controller: i32, port: usize) {
-    if controller < ui.input.joysticks.len() as i32 {
-        let path = unsafe {
-            std::ffi::CStr::from_ptr(sdl3_sys::joystick::SDL_GetJoystickPathForID(
-                ui.input.joysticks[controller as usize],
-            ))
-            .to_string_lossy()
-            .to_string()
-        };
-        ui.config.input.controller_assignment[port - 1] = Some(path);
+    if hotkey_pressed(profile, joystick, controller) {
+        handle_hotkeys(keys, last_key_state);
+        InputData {
+            data: 0,
+            pak_change_pressed: keys & (1 << B_BUTTON) != 0,
+        }
     } else {
-        println!("Invalid controller number")
+        let key = profile.keys[HOTKEY];
+        InputData {
+            data: keys,
+            pak_change_pressed: key.enabled
+                && unsafe { *ui.input.keyboard_state.offset(key.id as isize) },
+        }
     }
 }
 
-pub fn bind_input_profile(ui: &mut ui::Ui, profile: String, port: usize) {
-    if ui.config.input.input_profiles.contains_key(&profile) {
-        ui.config.input.input_profile_binding[port - 1] = profile;
+pub fn assign_controller(config: &mut ui::config::Config, controller: i32, port: usize) {
+    let joysticks = get_joysticks();
+    if controller < 0 {
+        config.input.controller_assignment[port - 1] = None;
+    } else if controller < joysticks.len() as i32 {
+        let path =
+            unsafe { sdl3_sys::joystick::SDL_GetJoystickPathForID(joysticks[controller as usize]) };
+        if !path.is_null() {
+            config.input.controller_assignment[port - 1] =
+                Some(unsafe { std::ffi::CStr::from_ptr(path).to_str().unwrap().to_string() });
+        } else {
+            eprintln!("Invalid controller path for controller {controller}");
+        }
     } else {
-        println!("Invalid profile name")
+        eprintln!("Invalid controller number")
     }
 }
 
-pub fn clear_bindings(ui: &mut ui::Ui) {
+pub fn bind_input_profile(config: &mut ui::config::Config, profile: String, port: usize) {
+    if config.input.input_profiles.contains_key(&profile) {
+        config.input.input_profile_binding[port - 1] = profile;
+    } else {
+        eprintln!("Invalid profile name")
+    }
+}
+
+pub fn clear_bindings(config: &mut ui::config::Config) {
     for i in 0..4 {
-        ui.config.input.controller_assignment[i] = None;
-        ui.config.input.input_profile_binding[i] = "default".to_string();
+        config.input.controller_assignment[i] = None;
+        config.input.input_profile_binding[i] = "default".to_string();
     }
 }
 
-fn close_controllers(
+fn close_input_profile_window(
     open_joysticks: Vec<*mut sdl3_sys::joystick::SDL_Joystick>,
     open_controllers: Vec<*mut sdl3_sys::gamepad::SDL_Gamepad>,
+    renderer: *mut sdl3_sys::render::SDL_Renderer,
+    text_engine: *mut sdl3_ttf_sys::ttf::TTF_TextEngine,
+    font: *mut sdl3_ttf_sys::ttf::TTF_Font,
+    window: *mut sdl3_sys::video::SDL_Window,
 ) {
     for joystick in open_joysticks {
         unsafe { sdl3_sys::joystick::SDL_CloseJoystick(joystick) }
@@ -462,23 +602,37 @@ fn close_controllers(
     for controller in open_controllers {
         unsafe { sdl3_sys::gamepad::SDL_CloseGamepad(controller) }
     }
+
+    unsafe {
+        sdl3_ttf_sys::ttf::TTF_CloseFont(font);
+        sdl3_ttf_sys::ttf::TTF_DestroyRendererTextEngine(text_engine);
+        sdl3_sys::render::SDL_DestroyRenderer(renderer);
+        sdl3_sys::video::SDL_DestroyWindow(window);
+    }
 }
 
-pub fn configure_input_profile(ui: &mut ui::Ui, profile: String, dinput: bool) {
+pub fn configure_input_profile(
+    config: &mut ui::config::Config,
+    profile: String,
+    dinput: bool,
+    deadzone: i32,
+) {
     ui::sdl_init(sdl3_sys::init::SDL_INIT_VIDEO);
+    ui::sdl_init(sdl3_sys::init::SDL_INIT_GAMEPAD);
+    ui::ttf_init();
 
     if profile == "default" {
-        println!("Profile name cannot be default");
+        eprintln!("Profile name cannot be default");
         return;
     }
     if profile.is_empty() {
-        println!("Profile name cannot be empty");
+        eprintln!("Profile name cannot be empty");
         return;
     }
     let mut open_joysticks: Vec<*mut sdl3_sys::joystick::SDL_Joystick> = Vec::new();
     let mut open_controllers: Vec<*mut sdl3_sys::gamepad::SDL_Gamepad> = Vec::new();
 
-    for joystick in ui.input.joysticks.iter() {
+    for joystick in get_joysticks().iter() {
         if !dinput {
             let controller = unsafe { sdl3_sys::gamepad::SDL_OpenGamepad(*joystick) };
             if !controller.is_null() {
@@ -498,9 +652,9 @@ pub fn configure_input_profile(ui: &mut ui::Ui, profile: String, dinput: bool) {
     if !unsafe {
         sdl3_sys::render::SDL_CreateWindowAndRenderer(
             title.as_ptr(),
-            640,
+            852,
             480,
-            0,
+            sdl3_sys::video::SDL_WindowFlags(0),
             &mut window,
             &mut renderer,
         )
@@ -530,7 +684,7 @@ pub fn configure_input_profile(ui: &mut ui::Ui, profile: String, dinput: bool) {
         ("Control Stick Down", AXIS_DOWN),
         ("Control Stick Left", AXIS_LEFT),
         ("Control Stick Right", AXIS_RIGHT),
-        ("Change Pak", CHANGE_PAK),
+        ("Hotkey Activator", HOTKEY),
     ];
 
     let mut new_keys = [ui::config::InputKeyButton {
@@ -567,28 +721,44 @@ pub fn configure_input_profile(ui: &mut ui::Ui, profile: String, dinput: bool) {
         axis: 0,
     };
 
-    let font =
-        ab_glyph::FontRef::try_from_slice(include_bytes!("../../data/Roboto-Regular.ttf")).unwrap();
+    let text_engine = unsafe { sdl3_ttf_sys::ttf::TTF_CreateRendererTextEngine(renderer) };
+    let font = unsafe {
+        let font_bytes = include_bytes!("../../data/RobotoMono-Regular.ttf");
+        sdl3_ttf_sys::ttf::TTF_OpenFontIO(
+            sdl3_sys::everything::SDL_IOFromConstMem(
+                font_bytes.as_ptr() as *const std::ffi::c_void,
+                font_bytes.len(),
+            ),
+            true,
+            35.0,
+        )
+    };
 
     for (key, value) in key_labels.iter() {
         let mut event: sdl3_sys::events::SDL_Event = Default::default();
         while unsafe { sdl3_sys::events::SDL_PollEvent(&mut event) } {} // clear events
 
-        ui::video::draw_text(
-            format!("Select binding for: {key}").as_str(),
-            renderer,
-            &font,
-        );
-
         let mut key_set = false;
         while !key_set {
+            ui::video::draw_text(
+                format!("Select binding for: {key}").as_str(),
+                renderer,
+                text_engine,
+                font,
+            );
             std::thread::sleep(std::time::Duration::from_millis(100));
             while unsafe { sdl3_sys::events::SDL_PollEvent(&mut event) } {
-                let event_type = unsafe { event.r#type };
-                if event_type == u32::from(sdl3_sys::events::SDL_EVENT_WINDOW_CLOSE_REQUESTED) {
-                    close_controllers(open_joysticks, open_controllers);
+                if event.event_type() == sdl3_sys::events::SDL_EVENT_WINDOW_CLOSE_REQUESTED {
+                    close_input_profile_window(
+                        open_joysticks,
+                        open_controllers,
+                        renderer,
+                        text_engine,
+                        font,
+                        window,
+                    );
                     return;
-                } else if event_type == u32::from(sdl3_sys::events::SDL_EVENT_KEY_DOWN) {
+                } else if event.event_type() == sdl3_sys::events::SDL_EVENT_KEY_DOWN {
                     if unsafe {
                         !event.key.repeat
                             && event.key.scancode != sdl3_sys::scancode::SDL_SCANCODE_LALT
@@ -600,7 +770,7 @@ pub fn configure_input_profile(ui: &mut ui::Ui, profile: String, dinput: bool) {
                         };
                         key_set = true
                     }
-                } else if event_type == u32::from(sdl3_sys::events::SDL_EVENT_GAMEPAD_BUTTON_DOWN) {
+                } else if event.event_type() == sdl3_sys::events::SDL_EVENT_GAMEPAD_BUTTON_DOWN {
                     if !open_controllers.is_empty() {
                         new_controller_buttons[*value] = ui::config::InputKeyButton {
                             enabled: true,
@@ -608,10 +778,12 @@ pub fn configure_input_profile(ui: &mut ui::Ui, profile: String, dinput: bool) {
                         };
                         key_set = true
                     }
-                } else if event_type == u32::from(sdl3_sys::events::SDL_EVENT_GAMEPAD_AXIS_MOTION) {
+                } else if event.event_type() == sdl3_sys::events::SDL_EVENT_GAMEPAD_AXIS_MOTION {
                     let axis_value = unsafe { event.gaxis.value };
                     let axis = unsafe { event.gaxis.axis };
-                    if !open_controllers.is_empty() && axis_value.saturating_abs() > i16::MAX / 2 {
+                    if !open_controllers.is_empty()
+                        && axis_value.saturating_abs() > (i16::MAX as i32 * 3 / 4) as i16
+                    {
                         let result = ui::config::InputControllerAxis {
                             enabled: true,
                             id: axis as i32,
@@ -623,8 +795,7 @@ pub fn configure_input_profile(ui: &mut ui::Ui, profile: String, dinput: bool) {
                             key_set = true
                         }
                     }
-                } else if event_type == u32::from(sdl3_sys::events::SDL_EVENT_JOYSTICK_BUTTON_DOWN)
-                {
+                } else if event.event_type() == sdl3_sys::events::SDL_EVENT_JOYSTICK_BUTTON_DOWN {
                     if !open_joysticks.is_empty() {
                         new_joystick_buttons[*value] = ui::config::InputKeyButton {
                             enabled: true,
@@ -632,7 +803,7 @@ pub fn configure_input_profile(ui: &mut ui::Ui, profile: String, dinput: bool) {
                         };
                         key_set = true
                     }
-                } else if event_type == u32::from(sdl3_sys::events::SDL_EVENT_JOYSTICK_HAT_MOTION) {
+                } else if event.event_type() == sdl3_sys::events::SDL_EVENT_JOYSTICK_HAT_MOTION {
                     let state = unsafe { event.jhat.value };
                     let hat = unsafe { event.jhat.hat };
                     if !open_joysticks.is_empty() && state != sdl3_sys::joystick::SDL_HAT_CENTERED {
@@ -643,11 +814,12 @@ pub fn configure_input_profile(ui: &mut ui::Ui, profile: String, dinput: bool) {
                         };
                         key_set = true
                     }
-                } else if event_type == u32::from(sdl3_sys::events::SDL_EVENT_JOYSTICK_AXIS_MOTION)
-                {
+                } else if event.event_type() == sdl3_sys::events::SDL_EVENT_JOYSTICK_AXIS_MOTION {
                     let axis_value = unsafe { event.jaxis.value };
                     let axis = unsafe { event.jaxis.axis };
-                    if !open_joysticks.is_empty() && axis_value.saturating_abs() > i16::MAX / 2 {
+                    if !open_joysticks.is_empty()
+                        && axis_value.saturating_abs() > (i16::MAX as i32 * 3 / 4) as i16
+                    {
                         let result = ui::config::InputControllerAxis {
                             enabled: true,
                             id: axis as i32,
@@ -662,14 +834,18 @@ pub fn configure_input_profile(ui: &mut ui::Ui, profile: String, dinput: bool) {
                 }
             }
         }
+        ui::video::draw_text("Binding set, please wait...", renderer, text_engine, font);
+        std::thread::sleep(std::time::Duration::from_millis(500));
     }
 
-    close_controllers(open_joysticks, open_controllers);
-
-    unsafe {
-        sdl3_sys::render::SDL_DestroyRenderer(renderer);
-        sdl3_sys::video::SDL_DestroyWindow(window);
-    }
+    close_input_profile_window(
+        open_joysticks,
+        open_controllers,
+        renderer,
+        text_engine,
+        font,
+        window,
+    );
 
     let new_profile = ui::config::InputProfile {
         keys: new_keys,
@@ -679,8 +855,9 @@ pub fn configure_input_profile(ui: &mut ui::Ui, profile: String, dinput: bool) {
         joystick_hat: new_joystick_hat,
         joystick_axis: new_joystick_axis,
         dinput,
+        deadzone,
     };
-    ui.config.input.input_profiles.insert(profile, new_profile);
+    config.input.input_profiles.insert(profile, new_profile);
 }
 
 pub fn get_default_profile() -> ui::config::InputProfile {
@@ -769,7 +946,7 @@ pub fn get_default_profile() -> ui::config::InputProfile {
         enabled: true,
         id: i32::from(sdl3_sys::scancode::SDL_SCANCODE_DOWN),
     };
-    default_keys[CHANGE_PAK] = ui::config::InputKeyButton {
+    default_keys[HOTKEY] = ui::config::InputKeyButton {
         enabled: true,
         id: i32::from(sdl3_sys::scancode::SDL_SCANCODE_COMMA),
     };
@@ -855,7 +1032,7 @@ pub fn get_default_profile() -> ui::config::InputProfile {
         id: i32::from(sdl3_sys::gamepad::SDL_GAMEPAD_AXIS_LEFTY),
         axis: 1,
     };
-    default_controller_buttons[CHANGE_PAK] = ui::config::InputKeyButton {
+    default_controller_buttons[HOTKEY] = ui::config::InputKeyButton {
         enabled: true,
         id: i32::from(sdl3_sys::gamepad::SDL_GAMEPAD_BUTTON_BACK),
     };
@@ -879,10 +1056,28 @@ pub fn get_default_profile() -> ui::config::InputProfile {
             axis: 0,
         }; PROFILE_SIZE],
         dinput: false,
+        deadzone: DEADZONE_DEFAULT,
+    }
+}
+
+fn get_joysticks() -> Vec<sdl3_sys::joystick::SDL_JoystickID> {
+    unsafe { sdl3_sys::events::SDL_PumpEvents() };
+    let mut num_joysticks = 0;
+    let sdl_joysticks = unsafe { sdl3_sys::joystick::SDL_GetJoysticks(&mut num_joysticks) };
+    if !sdl_joysticks.is_null() {
+        let parts =
+            unsafe { std::slice::from_raw_parts(sdl_joysticks, num_joysticks as usize) }.to_vec();
+        unsafe { sdl3_sys::stdinc::SDL_free(sdl_joysticks as *mut std::ffi::c_void) };
+        parts
+    } else {
+        eprintln!("Could not get joysticks");
+        vec![]
     }
 }
 
 pub fn init(ui: &mut ui::Ui) {
+    ui::sdl_init(sdl3_sys::init::SDL_INIT_GAMEPAD);
+
     ui.input.keyboard_state =
         unsafe { sdl3_sys::keyboard::SDL_GetKeyboardState(std::ptr::null_mut()) };
     if ui.input.keyboard_state.is_null() {
@@ -890,20 +1085,16 @@ pub fn init(ui: &mut ui::Ui) {
     }
 
     for i in 0..4 {
-        let controller_assignment = &ui.config.input.controller_assignment[i];
-        if controller_assignment.is_some() && ui.config.input.controller_enabled[i] {
-            let mut joystick_id = 0;
-            let assigned_path = controller_assignment.as_ref().unwrap();
+        if let Some(controller_assignment) = &ui.config.input.controller_assignment[i]
+            && ui.config.input.controller_enabled[i]
+        {
+            let mut joystick_id = sdl3_sys::everything::SDL_JoystickID(0);
 
-            for joystick in ui.input.joysticks.iter() {
-                let path = unsafe {
-                    std::ffi::CStr::from_ptr(sdl3_sys::joystick::SDL_GetJoystickPathForID(
-                        *joystick,
-                    ))
-                    .to_string_lossy()
-                    .to_string()
-                };
-                if path == *assigned_path
+            for joystick in get_joysticks().iter() {
+                let path = unsafe { sdl3_sys::joystick::SDL_GetJoystickPathForID(*joystick) };
+                if !path.is_null()
+                    && unsafe { std::ffi::CStr::from_ptr(path).to_str().unwrap() }
+                        == controller_assignment
                     && unsafe { sdl3_sys::joystick::SDL_GetJoystickFromID(*joystick) }.is_null()
                     && unsafe { sdl3_sys::gamepad::SDL_GetGamepadFromID(*joystick) }.is_null()
                 {
@@ -912,20 +1103,25 @@ pub fn init(ui: &mut ui::Ui) {
                 }
             }
 
-            if joystick_id != 0 {
-                let profile_name = ui.config.input.input_profile_binding[i].clone();
-                let profile = ui.config.input.input_profiles.get(&profile_name).unwrap();
-
+            if joystick_id != 0
+                && let Some(profile) = ui
+                    .config
+                    .input
+                    .input_profiles
+                    .get(&ui.config.input.input_profile_binding[i])
+            {
                 if !profile.dinput {
                     let gamepad = unsafe { sdl3_sys::gamepad::SDL_OpenGamepad(joystick_id) };
                     if gamepad.is_null() {
-                        println!("could not connect gamepad: {joystick_id}")
+                        eprintln!("could not connect gamepad: {}", u32::from(joystick_id))
                     } else {
                         ui.input.controllers[i].game_controller = gamepad;
+                        ui.input.controllers[i].guid =
+                            unsafe { sdl3_sys::gamepad::SDL_GetGamepadGUIDForID(joystick_id) };
                         let properties =
                             unsafe { sdl3_sys::gamepad::SDL_GetGamepadProperties(gamepad) };
                         if properties == 0 {
-                            println!("could not get gamepad properties");
+                            eprintln!("could not get gamepad properties");
                         }
                         ui.input.controllers[i].rumble = unsafe {
                             sdl3_sys::properties::SDL_GetBooleanProperty(
@@ -938,13 +1134,15 @@ pub fn init(ui: &mut ui::Ui) {
                 } else {
                     let joystick = unsafe { sdl3_sys::joystick::SDL_OpenJoystick(joystick_id) };
                     if joystick.is_null() {
-                        println!("could not connect joystick: {joystick_id}")
+                        eprintln!("could not connect joystick: {}", u32::from(joystick_id))
                     } else {
                         ui.input.controllers[i].joystick = joystick;
+                        ui.input.controllers[i].guid =
+                            unsafe { sdl3_sys::joystick::SDL_GetJoystickGUIDForID(joystick_id) };
                         let properties =
                             unsafe { sdl3_sys::joystick::SDL_GetJoystickProperties(joystick) };
                         if properties == 0 {
-                            println!("could not get joystick properties");
+                            eprintln!("could not get joystick properties");
                         }
                         ui.input.controllers[i].rumble = unsafe {
                             sdl3_sys::properties::SDL_GetBooleanProperty(
@@ -956,7 +1154,7 @@ pub fn init(ui: &mut ui::Ui) {
                     }
                 }
             } else {
-                println!("Could not bind assigned controller");
+                eprintln!("Could not bind assigned controller");
             }
         }
     }

src/ui/retroachievements.rs

@@ -0,0 +1,128 @@
+use crate::retroachievements;
+use crate::ui;
+use slint::ComponentHandle;
+
+pub fn ra_window(app: &ui::gui::AppWindow) {
+    let mut token = String::new();
+    if let Ok(ra_config) = std::fs::read(ui::get_dirs().config_dir.join("retroachievements.json"))
+        && let Ok(result) =
+            serde_json::from_slice::<retroachievements::RAConfig>(ra_config.as_ref())
+    {
+        app.set_ra_username(result.username.into());
+        app.set_ra_enabled(result.enabled);
+        app.set_ra_hardcore(result.hardcore);
+        app.set_ra_challenge(result.challenge);
+        app.set_ra_leaderboard(result.leaderboard);
+        token = result.token;
+    } else {
+        app.set_ra_hardcore(true);
+    }
+
+    if !cfg!(ra_hardcore_enabled) {
+        app.set_ra_softcore_only(true);
+    }
+
+    if app.get_ra_enabled() && !app.get_ra_username().is_empty() {
+        let (tx, rx) = tokio::sync::oneshot::channel::<bool>();
+        retroachievements::login_token_user(app.get_ra_username().to_string(), token, tx);
+        set_current_user_message(app, rx);
+    } else {
+        app.set_ra_current_user_message("Not currently logged in".into());
+    }
+
+    let weak_app2 = app.as_weak();
+    app.on_ra_button_clicked(move |password| {
+        weak_app2
+            .upgrade_in_event_loop(move |handle| {
+                let (tx, rx) = tokio::sync::oneshot::channel::<bool>();
+                retroachievements::login_user(
+                    handle.get_ra_username().to_string(),
+                    password.to_string(),
+                    tx,
+                );
+
+                set_current_user_message(&handle, rx);
+            })
+            .unwrap();
+    });
+
+    app.on_ra_toggled(move |enabled, hardcore, challenge, leaderboard| {
+        let file_path = ui::get_dirs().config_dir.join("retroachievements.json");
+        let raconfig = if let Ok(ra_config) = std::fs::read(&file_path)
+            && let Ok(result) =
+                serde_json::from_slice::<retroachievements::RAConfig>(ra_config.as_ref())
+        {
+            if !enabled {
+                retroachievements::logout_user();
+                retroachievements::RAConfig {
+                    username: String::new(),
+                    token: String::new(),
+                    enabled,
+                    hardcore,
+                    challenge,
+                    leaderboard,
+                }
+            } else {
+                retroachievements::RAConfig {
+                    username: result.username,
+                    token: result.token,
+                    enabled,
+                    hardcore,
+                    challenge,
+                    leaderboard,
+                }
+            }
+        } else {
+            retroachievements::RAConfig {
+                username: String::new(),
+                token: String::new(),
+                enabled,
+                hardcore,
+                challenge,
+                leaderboard,
+            }
+        };
+        if let Ok(f) = std::fs::File::create(&file_path)
+            && let Err(e) = serde_json::to_writer_pretty(f, &raconfig)
+        {
+            eprintln!("Error writing RA config: {}", e);
+        }
+    });
+
+    app.on_ra_games_clicked(move || {
+        if let Err(e) =
+            open::that_detached("https://retroachievements.org/system/2-nintendo-64/games")
+        {
+            eprintln!("Error opening games: {}", e);
+        }
+    });
+
+    app.on_ra_show_profile_clicked(move || {
+        if let Err(e) = open::that_detached(format!(
+            "https://retroachievements.org/user/{}",
+            retroachievements::get_username().unwrap_or_default()
+        )) {
+            eprintln!("Error opening profile: {}", e);
+        }
+    });
+}
+
+fn set_current_user_message(app: &ui::gui::AppWindow, rx: tokio::sync::oneshot::Receiver<bool>) {
+    app.set_ra_current_user_message("Logging in...".into());
+    let weak_app = app.as_weak();
+    tokio::spawn(async move {
+        rx.await.unwrap();
+        weak_app
+            .upgrade_in_event_loop(move |handle| {
+                if let Some(username) = retroachievements::get_username() {
+                    handle.set_ra_current_user_message(format!("Logged in as {}", username).into());
+                    handle.set_ra_show_profile(true);
+                } else {
+                    handle.set_ra_current_user_message("Login failed".into());
+                    handle.set_ra_show_profile(false);
+                }
+                handle.set_ra_logging_in(false);
+            })
+            .unwrap();
+    });
+}

src/ui/storage.rs

@@ -28,13 +28,13 @@ pub struct Paths {
 #[derive(serde::Serialize, serde::Deserialize)]
 pub struct Save {
     pub data: Vec<u8>,
-    pub written: bool,
+    pub write_pending: bool,
 }
 
 #[derive(serde::Serialize, serde::Deserialize)]
 pub struct RomSave {
     pub data: std::collections::HashMap<u32, u8>,
-    pub written: bool,
+    pub write_pending: bool,
 }
 
 #[derive(serde::Serialize, serde::Deserialize)]
@@ -49,8 +49,9 @@ pub struct Saves {
 }
 
 fn get_save_type(rom: &[u8], game_id: &str) -> Vec<SaveTypes> {
-    let header_type = std::str::from_utf8(rom[0x3C..0x3E].try_into().unwrap());
-    if header_type.is_ok() && header_type.unwrap() == "ED" {
+    if let Ok(header_type) = std::str::from_utf8(rom[0x3C..0x3E].try_into().unwrap())
+        && header_type == "ED"
+    {
         let save_type = rom[0x3F] >> 4;
         match save_type {
             0 => return vec![],
@@ -135,13 +136,13 @@ pub fn get_game_crc(rom: &[u8]) -> String {
 }
 
 pub fn get_game_name(rom: &[u8]) -> String {
-    let mut game_name = "".to_owned();
     let header_value = std::str::from_utf8(&rom[0x20..0x34]);
     if let Ok(header_value) = header_value {
         let re = regex::Regex::new(r"[^a-zA-Z0-9_ -]").unwrap();
-        game_name = re.replace_all(header_value, "").trim().replace('\0', "");
+        re.replace_all(header_value, "").trim().replace('\0', "")
+    } else {
+        String::new()
     }
-    game_name
 }
 
 pub fn init(ui: &mut ui::Ui, rom: &[u8]) {
@@ -163,46 +164,46 @@ pub fn init(ui: &mut ui::Ui, rom: &[u8]) {
     ui.storage
         .paths
         .eep_file_path
-        .push(prefix.to_owned() + "-" + &ui.game_hash + ".eep");
+        .push(format!("{}-{}.eep", prefix, ui.game_hash));
 
     ui.storage.paths.sra_file_path.clone_from(&saves_path);
     ui.storage
         .paths
         .sra_file_path
-        .push(prefix.to_owned() + "-" + &ui.game_hash + ".sra");
+        .push(format!("{}-{}.sra", prefix, ui.game_hash));
 
     ui.storage.paths.fla_file_path.clone_from(&saves_path);
     ui.storage
         .paths
         .fla_file_path
-        .push(prefix.to_owned() + "-" + &ui.game_hash + ".fla");
+        .push(format!("{}-{}.fla", prefix, ui.game_hash));
 
     ui.storage.paths.pak_file_path.clone_from(&saves_path);
     ui.storage
         .paths
         .pak_file_path
-        .push(prefix.to_owned() + "-" + &ui.game_hash + ".mpk");
+        .push(format!("{}-{}.mpk", prefix, ui.game_hash));
 
     ui.storage.paths.sdcard_file_path.clone_from(&saves_path);
     ui.storage
         .paths
         .sdcard_file_path
-        .push(prefix.to_owned() + "-" + &ui.game_hash + ".img");
+        .push(format!("{}-{}.img", prefix, ui.game_hash));
 
     ui.storage.paths.romsave_file_path.clone_from(&saves_path);
     ui.storage
         .paths
         .romsave_file_path
-        .push(prefix.to_owned() + "-" + &ui.game_hash + ".romsave");
+        .push(format!("{}-{}.romsave", prefix, ui.game_hash));
 
     ui.storage
         .paths
         .savestate_file_path
         .clone_from(&states_path);
-    ui.storage
-        .paths
-        .savestate_file_path
-        .push(prefix.to_owned() + "-" + &ui.game_hash + ".state");
+    ui.storage.paths.savestate_file_path.push(format!(
+        "{}-{}.state{}",
+        prefix, ui.game_hash, ui.storage.save_state_slot
+    ));
 }
 
 pub fn load_saves(ui: &mut ui::Ui, netplay: &mut Option<netplay::Netplay>) {
@@ -228,8 +229,10 @@ pub fn load_saves(ui: &mut ui::Ui, netplay: &mut Option<netplay::Netplay>) {
             ui.storage.saves.sdcard.data = sdcard;
         }
         let romsave = std::fs::read(&ui.storage.paths.romsave_file_path);
-        if let Ok(romsave) = romsave {
-            ui.storage.saves.romsave.data = postcard::from_bytes(romsave.as_ref()).unwrap();
+        if let Ok(romsave) = romsave
+            && let Ok(romsave_data) = postcard::from_bytes(romsave.as_ref())
+        {
+            ui.storage.saves.romsave.data = romsave_data;
         }
     }
 
@@ -261,8 +264,10 @@ pub fn load_saves(ui: &mut ui::Ui, netplay: &mut Option<netplay::Netplay>) {
             );
 
             let mut compressed_sd = Vec::new();
-            if !ui.storage.saves.sdcard.data.is_empty() {
-                compressed_sd = compress_file(&[(&ui.storage.saves.sdcard.data, "save")]);
+            if !ui.storage.saves.sdcard.data.is_empty()
+                && let Ok(file_data) = compress_file(&[(&ui.storage.saves.sdcard.data, "save")])
+            {
+                compressed_sd = file_data;
             }
             netplay::send_save(
                 netplay.as_mut().unwrap(),
@@ -272,11 +277,11 @@ pub fn load_saves(ui: &mut ui::Ui, netplay: &mut Option<netplay::Netplay>) {
             );
 
             let mut compressed_romsave = Vec::new();
-            if !ui.storage.saves.romsave.data.is_empty() {
-                compressed_romsave = compress_file(&[(
-                    &postcard::to_stdvec(&ui.storage.saves.romsave.data).unwrap(),
-                    "save",
-                )]);
+            if !ui.storage.saves.romsave.data.is_empty()
+                && let Ok(file_data) = postcard::to_stdvec(&ui.storage.saves.romsave.data)
+                && let Ok(compressed_file_data) = compress_file(&[(&file_data, "save")])
+            {
+                compressed_romsave = compressed_file_data;
             }
             netplay::send_save(
                 netplay.as_mut().unwrap(),
@@ -308,58 +313,70 @@ pub fn load_saves(ui: &mut ui::Ui, netplay: &mut Option<netplay::Netplay>) {
 
             let mut compressed_sd = Vec::new();
             netplay::receive_save(netplay.as_mut().unwrap(), "img", &mut compressed_sd);
-            if !compressed_sd.is_empty() {
-                ui.storage.saves.sdcard.data = decompress_file(&compressed_sd, "save");
+            if !compressed_sd.is_empty()
+                && let Ok(file_data) = decompress_file(&compressed_sd, "save")
+            {
+                ui.storage.saves.sdcard.data = file_data;
             }
 
             let mut compressed_romsave = Vec::new();
             netplay::receive_save(netplay.as_mut().unwrap(), "rom", &mut compressed_romsave);
-            if !compressed_romsave.is_empty() {
-                let romsave_bytes = decompress_file(&compressed_romsave, "save");
-                ui.storage.saves.romsave.data = postcard::from_bytes(&romsave_bytes).unwrap();
+            if !compressed_romsave.is_empty()
+                && let Ok(romsave_bytes) = decompress_file(&compressed_romsave, "save")
+                && let Ok(romsave_data) = postcard::from_bytes(&romsave_bytes)
+            {
+                ui.storage.saves.romsave.data = romsave_data;
             }
         }
     }
 }
 
-pub fn decompress_file(input: &[u8], name: &str) -> Vec<u8> {
-    let mut decompressed_file = Vec::new();
-    {
-        let mut reader = zip::ZipArchive::new(std::io::Cursor::new(input)).unwrap();
-        let mut file = reader.by_name(name).unwrap();
-        file.read_to_end(&mut decompressed_file).unwrap();
-    }
-    decompressed_file
+pub fn format_saves(device: &mut device::Device) {
+    device::cart::format_eeprom(device);
+    device::cart::sram::format_sram(device);
+    device::cart::sram::format_flash(device);
+    device::controller::mempak::format_mempak(device);
 }
 
-pub fn compress_file(data: &[(&[u8], &str)]) -> Vec<u8> {
+pub fn decompress_file(input: &[u8], name: &str) -> Result<Vec<u8>, zip::result::ZipError> {
+    let mut decompressed_file = Vec::new();
+    {
+        if let Ok(mut reader) = zip::ZipArchive::new(std::io::Cursor::new(input))
+            && let Ok(mut file) = reader.by_name(name)
+            && file.read_to_end(&mut decompressed_file).is_ok()
+        {
+            return Ok(decompressed_file);
+        }
+    }
+    Err(zip::result::ZipError::FileNotFound)
+}
+
+pub fn compress_file(data: &[(&[u8], &str)]) -> Result<Vec<u8>, zip::result::ZipError> {
     let mut compressed_file = Vec::new();
     {
         let mut writer = zip::ZipWriter::new(std::io::Cursor::new(&mut compressed_file));
         for item in data {
-            writer
+            if writer
                 .start_file(
                     item.1,
                     zip::write::SimpleFileOptions::default()
                         .compression_method(zip::CompressionMethod::Zstd)
                         .compression_level(Some(1)),
                 )
-                .unwrap();
-            writer.write_all(item.0).unwrap();
+                .is_err()
+                || writer.write_all(item.0).is_err()
+            {
+                return Err(zip::result::ZipError::FileNotFound);
+            }
         }
     }
-    compressed_file
-}
-
-fn write_rom_save(ui: &ui::Ui) {
-    let data = postcard::to_stdvec(&ui.storage.saves.romsave.data).unwrap();
-    std::fs::write(ui.storage.paths.romsave_file_path.clone(), data).unwrap();
+    Ok(compressed_file)
 }
 
 fn writeback_sdcard(device: &mut device::Device) {
     let length;
     let save_data: &[u8];
-    if device.ui.storage.saves.eeprom.written {
+    if device.ui.storage.saves.eeprom.write_pending {
         if device
             .ui
             .storage
@@ -371,12 +388,15 @@ fn writeback_sdcard(device: &mut device::Device) {
             length = 4;
         }
         save_data = device.ui.storage.saves.eeprom.data.as_ref();
-    } else if device.ui.storage.saves.sram.written {
+        device.ui.storage.saves.eeprom.write_pending = false;
+    } else if device.ui.storage.saves.sram.write_pending {
         length = device.ui.storage.saves.sram.data.len() / 512;
         save_data = device.ui.storage.saves.sram.data.as_ref();
-    } else if device.ui.storage.saves.flash.written {
+        device.ui.storage.saves.sram.write_pending = false;
+    } else if device.ui.storage.saves.flash.write_pending {
         length = device.ui.storage.saves.flash.data.len() / 512;
         save_data = device.ui.storage.saves.flash.data.as_ref();
+        device.ui.storage.saves.flash.write_pending = false;
     } else {
         return;
     }
@@ -386,71 +406,111 @@ fn writeback_sdcard(device: &mut device::Device) {
         device.ui.storage.saves.sdcard.data[offset..offset + 512]
             .copy_from_slice(&save_data[i * 512..(i + 1) * 512]);
     }
-    device.ui.storage.saves.sdcard.written = true;
+    device.ui.storage.saves.sdcard.write_pending = true;
 }
 
 pub fn write_saves(device: &mut device::Device) {
     if device.netplay.is_none() || device.netplay.as_ref().unwrap().player_number == 0 {
         if device.ui.storage.saves.write_to_disk {
-            if device.ui.storage.saves.eeprom.written {
-                write_save(&device.ui, SaveTypes::Eeprom16k)
+            if device.ui.storage.saves.eeprom.write_pending {
+                write_save(&mut device.ui, SaveTypes::Eeprom16k)
             }
-            if device.ui.storage.saves.sram.written {
-                write_save(&device.ui, SaveTypes::Sram)
+            if device.ui.storage.saves.sram.write_pending {
+                write_save(&mut device.ui, SaveTypes::Sram)
             }
-            if device.ui.storage.saves.flash.written {
-                write_save(&device.ui, SaveTypes::Flash)
+            if device.ui.storage.saves.flash.write_pending {
+                write_save(&mut device.ui, SaveTypes::Flash)
             }
-            if device.ui.storage.saves.romsave.written {
-                write_save(&device.ui, SaveTypes::Romsave)
+            if device.ui.storage.saves.romsave.write_pending {
+                write_save(&mut device.ui, SaveTypes::Romsave)
             }
         } else {
             writeback_sdcard(device)
         }
-        if device.ui.storage.saves.mempak.written {
-            write_save(&device.ui, SaveTypes::Mempak)
+        if device.ui.storage.saves.mempak.write_pending {
+            write_save(&mut device.ui, SaveTypes::Mempak)
         }
-        if device.ui.storage.saves.sdcard.written {
-            write_save(&device.ui, SaveTypes::Sdcard)
+        if device.ui.storage.saves.sdcard.write_pending {
+            write_save(&mut device.ui, SaveTypes::Sdcard)
         }
     }
 }
 
-fn write_save(ui: &ui::Ui, save_type: SaveTypes) {
-    let path: &std::path::Path;
-    let data: &Vec<u8>;
+pub fn save_event(device: &mut device::Device) {
+    write_saves(device);
+}
+
+pub fn schedule_save(device: &mut device::Device, save_type: SaveTypes) {
     match save_type {
         SaveTypes::Eeprom4k | SaveTypes::Eeprom16k => {
-            path = ui.storage.paths.eep_file_path.as_ref();
-            data = ui.storage.saves.eeprom.data.as_ref();
+            device.ui.storage.saves.eeprom.write_pending = true;
         }
         SaveTypes::Sram => {
-            path = ui.storage.paths.sra_file_path.as_ref();
-            data = ui.storage.saves.sram.data.as_ref();
+            device.ui.storage.saves.sram.write_pending = true;
         }
         SaveTypes::Flash => {
-            path = ui.storage.paths.fla_file_path.as_ref();
-            data = ui.storage.saves.flash.data.as_ref();
+            device.ui.storage.saves.flash.write_pending = true;
         }
         SaveTypes::Mempak => {
-            path = ui.storage.paths.pak_file_path.as_ref();
-            data = ui.storage.saves.mempak.data.as_ref();
+            device.ui.storage.saves.mempak.write_pending = true;
         }
         SaveTypes::Sdcard => {
-            path = ui.storage.paths.sdcard_file_path.as_ref();
-            data = ui.storage.saves.sdcard.data.as_ref();
+            device.ui.storage.saves.sdcard.write_pending = true;
         }
         SaveTypes::Romsave => {
-            write_rom_save(ui);
-            return;
+            device.ui.storage.saves.romsave.write_pending = true;
         }
     }
-    let result = std::fs::write(path, data);
-    if result.is_err() {
-        panic!(
-            "could not save {} {}",
-            path.display(),
-            result.err().unwrap()
-        )
-    }
+    device::events::create_event(
+        device,
+        device::events::EVENT_TYPE_SAVE,
+        device.cpu.clock_rate, // 1 second
+    );
+}
+
+fn write_save(ui: &mut ui::Ui, save_type: SaveTypes) {
+    let save_path: std::path::PathBuf;
+    let save_data: Vec<u8>;
+    match save_type {
+        SaveTypes::Eeprom4k | SaveTypes::Eeprom16k => {
+            save_path = ui.storage.paths.eep_file_path.clone();
+            save_data = ui.storage.saves.eeprom.data.clone();
+            ui.storage.saves.eeprom.write_pending = false;
+        }
+        SaveTypes::Sram => {
+            save_path = ui.storage.paths.sra_file_path.clone();
+            save_data = ui.storage.saves.sram.data.clone();
+            ui.storage.saves.sram.write_pending = false;
+        }
+        SaveTypes::Flash => {
+            save_path = ui.storage.paths.fla_file_path.clone();
+            save_data = ui.storage.saves.flash.data.clone();
+            ui.storage.saves.flash.write_pending = false;
+        }
+        SaveTypes::Mempak => {
+            save_path = ui.storage.paths.pak_file_path.clone();
+            save_data = ui.storage.saves.mempak.data.clone();
+            ui.storage.saves.mempak.write_pending = false;
+        }
+        SaveTypes::Sdcard => {
+            save_path = ui.storage.paths.sdcard_file_path.clone();
+            save_data = ui.storage.saves.sdcard.data.clone();
+            ui.storage.saves.sdcard.write_pending = false;
+        }
+        SaveTypes::Romsave => {
+            save_path = ui.storage.paths.romsave_file_path.clone();
+            ui.storage.saves.romsave.write_pending = false;
+            if let Ok(rom_save) = postcard::to_stdvec(&ui.storage.saves.romsave.data) {
+                save_data = rom_save;
+            } else {
+                eprintln!("Error serializing rom save data");
+                return;
+            };
+        }
+    }
+    tokio::spawn(async move {
+        if let Err(e) = tokio::fs::write(save_path, save_data).await {
+            eprintln!("Error writing save: {}", e);
+        }
+    });
 }

src/ui/usb.rs

@@ -0,0 +1,178 @@
+use crate::ui;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+const DATATYPE_TCPTEST: u32 = 0x07;
+const DATATYPE_ROMUPLOAD: u32 = 0x08;
+
+#[derive(Clone, Debug)]
+pub struct UsbData {
+    pub data: Vec<u8>,
+    pub data_type: u32,
+    pub data_size: u32,
+}
+
+fn respond_to_handshake(usb_tx: &tokio::sync::broadcast::Sender<UsbData>, data: Vec<u8>) {
+    if let Ok(data) = String::from_utf8(data)
+        && data == "N64"
+    {
+        ui::usb::send_to_usb(
+            usb_tx,
+            ui::usb::UsbData {
+                data: [b'N', b'6', b'4'].to_vec(),
+                data_type: DATATYPE_TCPTEST,
+                data_size: 3,
+            },
+        );
+    }
+}
+
+async fn handle_connection(
+    conn: tokio::net::TcpStream,
+    mut shutdown_rx: tokio::sync::watch::Receiver<()>,
+    mut usb_rx: tokio::sync::broadcast::Receiver<UsbData>,
+    usb_tx: tokio::sync::broadcast::Sender<UsbData>,
+    cart_tx: tokio::sync::broadcast::Sender<UsbData>,
+) {
+    let (mut incoming, mut outgoing) = conn.into_split();
+
+    let mut shutdown_rx_clone = shutdown_rx.clone();
+    tokio::spawn(async move {
+        loop {
+            tokio::select! {
+                data = usb_rx.recv() => {
+                    match data {
+                        Ok(data) => {
+                            let mut output: Vec<u8> = vec![];
+                            output.extend_from_slice(&data.data_type.to_be_bytes());
+                            output.extend_from_slice(&data.data_size.to_be_bytes());
+                            output.extend_from_slice(&data.data);
+                            if outgoing.write_all(&output).await.is_err() {
+                                break;
+                            }
+                        }
+                        Err(tokio::sync::broadcast::error::RecvError::Lagged(_)) => {
+                            panic!("usb_rx lagged");
+                        }
+                        Err(tokio::sync::broadcast::error::RecvError::Closed) => {
+                          break;
+                        }
+                    }
+                }
+                _ = shutdown_rx_clone.changed() => {
+                    break;
+                }
+            }
+        }
+    });
+
+    let mut incoming_buffer = vec![0u8; 4096];
+    let mut data_type: Option<u32> = None;
+    let mut data_size: Option<u32> = None;
+    let mut usb_buffer: Vec<u8> = vec![];
+    loop {
+        tokio::select! {
+            result = incoming.read(&mut incoming_buffer) => {
+                match result {
+                    Ok(0) => {
+                        break;
+                    }
+                    Ok(n) => {
+                        usb_buffer.extend_from_slice(&incoming_buffer[0..n]);
+                        if data_type.is_none() {
+                            if usb_buffer.len() < 4 {
+                                continue;
+                            } else {
+                                data_type = Some(u32::from_be_bytes(usb_buffer[0..4].try_into().unwrap()));
+                                usb_buffer.drain(0..4);
+                            }
+                        }
+                        if data_type.is_some() && data_size.is_none() {
+                            if usb_buffer.len() < 4 {
+                                continue;
+                            } else {
+                                data_size = Some(u32::from_be_bytes(usb_buffer[0..4].try_into().unwrap()));
+                                usb_buffer.drain(0..4);
+                            }
+                        }
+                        if let Some(d_type) = data_type && let Some(d_size) = data_size {
+                            let length = d_size as usize;
+                            if usb_buffer.len() >= length {
+                                let usb_data = UsbData {
+                                    data: usb_buffer[0..length].to_vec(),
+                                    data_type: d_type,
+                                    data_size: d_size,
+                                };
+                                usb_buffer.drain(0..length);
+                                if usb_data.data_type == DATATYPE_TCPTEST {
+                                    respond_to_handshake(&usb_tx,usb_data.data);
+                                } else if usb_data.data_type == DATATYPE_ROMUPLOAD {
+                                    panic!("ROM upload not supported");
+                                } else {
+                                    cart_tx.send(usb_data).unwrap();
+                                }
+                                data_type = None;
+                                data_size = None;
+                            }
+                        }
+                    }
+                    Err(_e) => {
+                        break;
+                    }
+                }
+            }
+            _ = shutdown_rx.changed() => {
+                break;
+            }
+        }
+    }
+}
+
+pub fn init() -> (Option<tokio::sync::watch::Sender<()>>, ui::Usb) {
+    let (shutdown_tx, mut shutdown_rx) = tokio::sync::watch::channel(());
+    let (usb_tx, usb_rx): (
+        tokio::sync::broadcast::Sender<UsbData>,
+        tokio::sync::broadcast::Receiver<UsbData>,
+    ) = tokio::sync::broadcast::channel(1024);
+    let (cart_tx, cart_rx): (
+        tokio::sync::broadcast::Sender<UsbData>,
+        tokio::sync::broadcast::Receiver<UsbData>,
+    ) = tokio::sync::broadcast::channel(1024);
+
+    let usb_tx_clone = usb_tx.clone();
+    let cart_rx_clone = cart_rx.resubscribe();
+    tokio::spawn(async move {
+        let listener = tokio::net::TcpListener::bind("localhost:64000")
+            .await
+            .unwrap();
+
+        loop {
+            tokio::select! {
+                res = listener.accept() => {
+                    if let Ok((c,_)) = res {
+                        handle_connection(c,shutdown_rx.clone(),usb_rx.resubscribe(),usb_tx.clone(),cart_tx.clone()).await;
+                    } else {
+                        break;
+                    }
+                }
+                _ = shutdown_rx.changed() => {
+                    break;
+                }
+            }
+        }
+    });
+    (
+        Some(shutdown_tx),
+        ui::Usb {
+            usb_tx: Some(usb_tx_clone),
+            cart_rx: Some(cart_rx_clone),
+        },
+    )
+}
+
+pub fn close(shutdown_tx: &tokio::sync::watch::Sender<()>) {
+    let _ = shutdown_tx.send(());
+}
+
+pub fn send_to_usb(usb_tx: &tokio::sync::broadcast::Sender<UsbData>, buffer: UsbData) {
+    usb_tx.send(buffer).unwrap();
+}