Update parallel-rdp

Update to Rust 1.94.0 (#672 )
upload unzipped artifact (#670 )
2026-07-11 01:25:20 +02:00 · 2026-03-05 20:42:24 +01:00 · 2026-03-05 20:37:50 +01:00 · 2026-02-27 19:11:00 +01:00 · 2026-02-22 08:12:10 +01:00 · 2026-02-15 21:41:10 +01:00
85 changed files with 4985 additions and 12601 deletions
@@ -1,8 +1,8 @@
-[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(target_os = "windows")']
-rustflags = ["-C", "linker=lld-link", "-C", "link-arg=-fuse-ld=lld-link"]
+linker = "rust-lld"

 [target.'cfg(target_arch = "x86_64")']
 rustflags = ["-C", "target-cpu=x86-64-v3"]
@@ -13,3 +13,4 @@ rustflags = ["-C", "target-cpu=cortex-a76"]
 [env]
 CC = "clang"
 CXX = "clang++"
+AR = "llvm-ar"
@@ -3,8 +3,12 @@ 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"
@@ -5,12 +5,13 @@ permissions:
 on:
  push:
    branches: ["main"]
+    tags:
+      - "v*"
  pull_request:
    branches: ["main"]

 env:
  CARGO_TERM_COLOR: always
-  LLVM_VERSION: "20.1"

 jobs:
  build-linux:
@@ -22,17 +23,21 @@ 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
      - uses: actions-rust-lang/setup-rust-toolchain@v1
        with:
          target: ${{ matrix.target }}
          rustflags: ""
+      - 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
@@ -43,22 +48,26 @@ jobs:
            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
+            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

  build-windows:
    runs-on: ${{ matrix.os }}
@@ -69,21 +78,28 @@ jobs:
          - os: windows-2025
            target: x86_64-pc-windows-msvc
            arch: windows-x86_64
+            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
      - uses: actions-rust-lang/setup-rust-toolchain@v1
        with:
          target: ${{ matrix.target }}
          rustflags: ""
+      - 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,12 +108,25 @@ 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: false
+      - name: SignPath
+        if: ${{ github.ref_type == 'tag' }}
+        uses: signpath/github-action-submit-signing-request@v2.0
+        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: false

  build-macos:
    if: false
@@ -111,7 +140,7 @@ jobs:
          - target: aarch64-apple-darwin
            arch: mac-aarch64
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
        with:
          submodules: recursive
      - uses: actions-rust-lang/setup-rust-toolchain@v1
@@ -123,8 +152,12 @@ jobs:
          cargo build --release -v --target=${{ matrix.target }}
          mkdir output
          cp target/${{ matrix.target }}/release/gopher64 output/gopher64-${{ matrix.arch }}
+        env:
+          AR: ar
+          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
@@ -11,18 +11,19 @@ permissions:

 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
@@ -33,12 +34,13 @@ jobs:
            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
+            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
@@ -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
@@ -1,3 +1,7 @@
 [submodule "parallel-rdp/parallel-rdp-standalone"]
 	path = parallel-rdp/parallel-rdp-standalone
-	url = https://github.com/Themaister/parallel-rdp-standalone.git
+	url = https://github.com/gopher64/parallel-rdp-standalone.git
+	branch = gopher64
+[submodule "src/compat/sse2neon"]
+	path = src/compat/sse2neon
+	url = https://github.com/DLTcollab/sse2neon.git
@@ -1,40 +1,40 @@
 [package]
 name = "gopher64"
-version = "1.1.0"
+version = "1.1.15"
 edition = "2024"
-rust-version = "1.88"
+rust-version = "1.94.0"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
 dirs = "6.0"
-zip = "4.3"
+zip = "8.0"
 governor = "0.10"
-sevenz-rust2 = { version = "0.16", default-features = false }
+sevenz-rust2 = "0.20"
 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.15", default-features = false, features = ["compat-1-2", "std", "backend-winit", "renderer-skia"] }
 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"] }
+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 = "0.17"
+tokio = {version = "1.46", features = ["rt-multi-thread", "macros", "fs"] }
 spin_sleep = "1.3"
 encoding_rs = "0.8"
 mimalloc = "0.1"
 regex = "1.11"
-tokio-tungstenite = "0.27"
+tokio-tungstenite = "0.28"
 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"
@@ -45,3 +45,10 @@ 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"
@@ -17,13 +17,9 @@ https://discord.gg/9RGXq8W8JQ

 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,12 +33,6 @@ 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
@@ -59,3 +49,9 @@ 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.
+
+## 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.
@@ -8,11 +8,13 @@ fn main() {
    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++23")
        .flag("-Wno-unused-parameter")
        .flag("-Wno-missing-field-initializers")
        .file("parallel-rdp/parallel-rdp-standalone/parallel-rdp/command_ring.cpp")
@@ -34,9 +36,11 @@ fn main() {
        .file("parallel-rdp/parallel-rdp-standalone/vulkan/image.cpp")
        .file("parallel-rdp/parallel-rdp-standalone/vulkan/indirect_layout.cpp")
        .file("parallel-rdp/parallel-rdp-standalone/vulkan/memory_allocator.cpp")
+        .file("parallel-rdp/parallel-rdp-standalone/vulkan/pipeline_cache.cpp")
        .file("parallel-rdp/parallel-rdp-standalone/vulkan/pipeline_event.cpp")
        .file("parallel-rdp/parallel-rdp-standalone/vulkan/query_pool.cpp")
        .file("parallel-rdp/parallel-rdp-standalone/vulkan/render_pass.cpp")
+        .file("parallel-rdp/parallel-rdp-standalone/vulkan/rtas.cpp")
        .file("parallel-rdp/parallel-rdp-standalone/vulkan/sampler.cpp")
        .file("parallel-rdp/parallel-rdp-standalone/vulkan/semaphore.cpp")
        .file("parallel-rdp/parallel-rdp-standalone/vulkan/semaphore_manager.cpp")
@@ -51,6 +55,7 @@ fn main() {
        .file("parallel-rdp/parallel-rdp-standalone/util/timeline_trace_file.cpp")
        .file("parallel-rdp/parallel-rdp-standalone/util/environment.cpp")
        .file("parallel-rdp/parallel-rdp-standalone/util/thread_name.cpp")
+        .file("parallel-rdp/parallel-rdp-standalone/util/slab_allocator.cpp")
        .file("parallel-rdp/interface.cpp")
        .file("parallel-rdp/wsi_platform.cpp")
        .include("parallel-rdp/parallel-rdp-standalone/parallel-rdp")
@@ -61,11 +66,14 @@ fn main() {
        .include(
            std::path::PathBuf::from(std::env::var("DEP_SDL3_OUT_DIR").to_owned().unwrap())
                .join("include"),
+        )
+        .include(
+            std::path::PathBuf::from(std::env::var("DEP_SDL3_TTF_OUT_DIR").to_owned().unwrap())
+                .join("include"),
        );

    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" {
@@ -73,6 +81,7 @@ fn main() {
    } else {
        panic!("unknown arch")
    };
+
    volk_build.flag(opt_flag);
    rdp_build.flag(opt_flag);
    simd_build.flag(opt_flag);
@@ -82,16 +91,15 @@ fn main() {
        rdp_build.flag("-DVK_USE_PLATFORM_WIN32_KHR");

        winresource::WindowsResource::new()
-            .set_icon("data/icon.ico")
+            .set_icon("data/icon/icon.ico")
            .compile()
            .unwrap();
    }

-    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");
+
    volk_build.compile("volk");
    rdp_build.compile("parallel-rdp");

@@ -103,9 +111,12 @@ fn main() {
        .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")
@@ -119,7 +130,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 +164,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,11 +176,14 @@ 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")
@@ -179,5 +194,8 @@ fn main() {
    let git_hash = String::from_utf8(git_output.stdout).unwrap();
    println!("cargo:rustc-env=GIT_HASH={git_hash}");

+    let netplay_id = std::env::var("NETPLAY_ID").unwrap_or("gopher64".to_string());
+    println!("cargo:rustc-env=NETPLAY_ID={netplay_id}");
+
    println!("cargo:rustc-env=N64_STACK_SIZE={}", 8 * 1024 * 1024);
 }
@@ -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
@@ -5,6 +5,7 @@
 #include "spirv.hpp"
 #include "spirv_crt.hpp"
 #include <SDL3/SDL_vulkan.h>
+#include <SDL3_ttf/SDL_ttf.h>

 using namespace Vulkan;

@@ -52,14 +53,27 @@ enum vi_registers
 	VI_REGS_COUNT
 };

+typedef struct
+{
+	uint32_t depthbuffer_address;
+	uint32_t framebuffer_address;
+	uint32_t framebuffer_y_offset;
+	uint32_t texture_address;
+	uint32_t framebuffer_pixel_size;
+	uint32_t framebuffer_width;
+	uint32_t texture_pixel_size;
+	uint32_t texture_width;
+	uint32_t framebuffer_height;
+	bool depth_buffer_enabled;
+} FrameBufferInfo;
+
 typedef struct
 {
 	uint32_t cmd_data[0x00040000 >> 2];
 	int cmd_cur;
 	int cmd_ptr;
 	uint32_t region;
-	uint64_t vi_counter;
-	uint64_t last_sync;
+	FrameBufferInfo frame_buffer_info;
 } RDP_DEVICE;

 static SDL_Window *window;
@@ -74,6 +88,15 @@ static GFX_INFO gfx_info;
 static const uint32_t *fragment_spirv;
 static size_t fragment_size;

+std::vector<bool> rdram_dirty;
+uint64_t sync_signal;
+
+static TTF_Font *message_font;
+static std::queue<std::string> messages;
+static uint64_t message_timer;
+
+#define MESSAGE_TIME 3000 // 3 seconds
+
 typedef struct
 {
 	float SourceSize[4];
@@ -151,6 +174,7 @@ bool sdl_event_filter(void *userdata, SDL_Event *event)
 {
 	if (event->type == SDL_EVENT_WINDOW_CLOSE_REQUESTED)
 	{
+		callback.paused = false;
 		callback.emu_running = false;
 	}
 	else if (event->type == SDL_EVENT_WINDOW_RESIZED && callback.emu_running)
@@ -174,6 +198,12 @@ bool sdl_event_filter(void *userdata, SDL_Event *event)
 				callback.enable_speedlimiter = !callback.enable_speedlimiter;
 			}
 			break;
+		case SDL_SCANCODE_P:
+			if (event->key.mod & SDL_KMOD_ALT)
+			{
+				callback.paused = !callback.paused;
+			}
+			break;
 		case SDL_SCANCODE_ESCAPE:
 			if (gfx_info.fullscreen)
 				callback.emu_running = false;
@@ -193,6 +223,27 @@ bool sdl_event_filter(void *userdata, SDL_Event *event)
 		case SDL_SCANCODE_RIGHTBRACKET:
 			callback.raise_volume = true;
 			break;
+		case SDL_SCANCODE_SLASH:
+			callback.frame_advance = true;
+			break;
+		case SDL_SCANCODE_0:
+		case SDL_SCANCODE_1:
+		case SDL_SCANCODE_2:
+		case SDL_SCANCODE_3:
+		case SDL_SCANCODE_4:
+		case SDL_SCANCODE_5:
+		case SDL_SCANCODE_6:
+		case SDL_SCANCODE_7:
+		case SDL_SCANCODE_8:
+		case SDL_SCANCODE_9:
+			if (event->key.mod & SDL_KMOD_ALT)
+			{
+				if (event->key.scancode == SDL_SCANCODE_0)
+					callback.save_state_slot = 0;
+				else
+					callback.save_state_slot = event->key.scancode - SDL_SCANCODE_1 + 1;
+			}
+			break;
 		default:
 			break;
 		}
@@ -205,6 +256,9 @@ void rdp_new_processor(GFX_INFO _gfx_info)
 {
 	gfx_info = _gfx_info;

+	sync_signal = 0;
+	rdram_dirty.assign(gfx_info.RDRAM_SIZE >> 3, false);
+
 	if (processor)
 	{
 		delete processor;
@@ -221,11 +275,32 @@ void rdp_new_processor(GFX_INFO _gfx_info)
 		flags |= RDP::COMMAND_PROCESSOR_FLAG_SUPER_SAMPLED_DITHER_BIT;
 		flags |= RDP::COMMAND_PROCESSOR_FLAG_UPSCALING_4X_BIT;
 	}
+	else if (gfx_info.upscale == 8)
+	{
+		flags |= RDP::COMMAND_PROCESSOR_FLAG_SUPER_SAMPLED_DITHER_BIT;
+		flags |= RDP::COMMAND_PROCESSOR_FLAG_UPSCALING_8X_BIT;
+	}

 	processor = new RDP::CommandProcessor(wsi->get_device(), gfx_info.RDRAM, 0, gfx_info.RDRAM_SIZE, gfx_info.RDRAM_SIZE / 2, flags);
 }

-void rdp_init(void *_window, GFX_INFO _gfx_info)
+static ImageHandle create_message_image(Vulkan::Device &device, int width, const char *message)
+{
+	SDL_Color fg = {255, 255, 255, 255};
+	SDL_Color bg = {0, 0, 0, 0};
+	SDL_Surface *surface = TTF_RenderText_LCD_Wrapped(message_font, message, 0, fg, bg, width);
+	ImageCreateInfo info = ImageCreateInfo::immutable_2d_image(surface->w, surface->h, VK_FORMAT_B8G8R8A8_UNORM, false);
+	ImageInitialData initial_data = {};
+	initial_data.data = surface->pixels;
+	initial_data.row_length = surface->pitch / 4;
+	initial_data.image_height = surface->h;
+
+	ImageHandle handle = device.create_image(info, &initial_data);
+	SDL_DestroySurface(surface);
+	return handle;
+}
+
+void rdp_init(void *_window, GFX_INFO _gfx_info, const void *font, size_t font_size)
 {
 	memset(&rdp_device, 0, sizeof(RDP_DEVICE));

@@ -262,32 +337,51 @@ void rdp_init(void *_window, GFX_INFO _gfx_info)
 	if (!::Vulkan::Context::init_loader((PFN_vkGetInstanceProcAddr)SDL_Vulkan_GetVkGetInstanceProcAddr()))
 	{
 		rdp_close();
+		return;
 	}
 	if (!wsi->init_simple(1, handles))
 	{
 		rdp_close();
+		return;
 	}

 	rdp_new_processor(gfx_info);

 	if (!processor->device_is_supported())
 	{
-		delete processor;
-		delete wsi;
-		processor = nullptr;
 		rdp_close();
+		return;
 	}
+
+	message_font = TTF_OpenFontIO(SDL_IOFromConstMem(font, font_size), true, 30.0);
+	if (!message_font)
+	{
+		rdp_close();
+		return;
+	}
+
 	wsi->begin_frame();

 	callback.emu_running = true;
 	callback.enable_speedlimiter = true;
+	callback.paused = false;
+	callback.save_state_slot = 0;
 	crop_letterbox = false;
+
+	messages = std::queue<std::string>();
+	message_timer = 0;
 }

 void rdp_close()
 {
-	wsi->end_frame();
+	if (wsi)
+		wsi->end_frame();

+	if (message_font)
+	{
+		TTF_CloseFont(message_font);
+		message_font = nullptr;
+	}
 	if (processor)
 	{
 		delete processor;
@@ -417,11 +511,30 @@ static void render_frame(Vulkan::Device &device)
 				cmd->push_constants(&push, 0, sizeof(push));
 			}

-			cmd->set_texture(0, 0, image->get_view(), Vulkan::StockSampler::LinearClamp);
+			cmd->set_texture(0, 0, image->get_view(), Vulkan::StockSampler::NearestClamp);
 			cmd->set_viewport(vp);
 			// The vertices are constants in the shader.
 			// Draws fullscreen quad using oversized triangle.
 			cmd->draw(3);
+
+			if (!messages.empty())
+			{
+				Vulkan::ImageHandle message_image = create_message_image(device, vp.width, messages.front().c_str());
+				cmd->set_texture(0, 0, message_image->get_view(), Vulkan::StockSampler::NearestClamp);
+				vp.x = vp.x + (vp.width - message_image->get_width()) / 2;
+				vp.y = vp.y + vp.height - message_image->get_height();
+				vp.height = message_image->get_height();
+				vp.width = message_image->get_width();
+				cmd->set_viewport(vp);
+
+				cmd->draw(3);
+
+				if (SDL_GetTicks() > message_timer)
+				{
+					messages.pop();
+					message_timer = SDL_GetTicks() + MESSAGE_TIME;
+				}
+			}
 		}

 		cmd->end_render_pass();
@@ -434,13 +547,16 @@ void rdp_set_vi_register(uint32_t reg, uint32_t value)
 	processor->set_vi_register(RDP::VIRegister(reg), value);
 }

-void rdp_update_screen()
+void rdp_render_frame()
 {
 	auto &device = wsi->get_device();
 	render_frame(device);
+}
+
+void rdp_update_screen()
+{
 	wsi->end_frame();
 	wsi->begin_frame();
-	rdp_device.vi_counter += 1;
 }

 CALL_BACK rdp_check_callback()
@@ -450,9 +566,32 @@ CALL_BACK rdp_check_callback()
 	callback.load_state = false;
 	callback.lower_volume = false;
 	callback.raise_volume = false;
+	callback.frame_advance = false;
 	return return_value;
 }

+void rdp_check_framebuffers(uint32_t address, uint32_t length)
+{
+	if (sync_signal)
+	{
+		address >>= 3;
+		length = (length + 7) >> 3;
+
+		if (address >= rdram_dirty.size())
+			return;
+
+		uint32_t end_addr = std::min(address + length, static_cast<uint32_t>(rdram_dirty.size()));
+
+		auto it = std::find(rdram_dirty.begin() + address, rdram_dirty.begin() + end_addr, true);
+		if (it != rdram_dirty.begin() + end_addr)
+		{
+			processor->wait_for_timeline(sync_signal);
+			rdram_dirty.assign(gfx_info.RDRAM_SIZE >> 3, false);
+			sync_signal = 0;
+		}
+	}
+}
+
 size_t rdp_state_size()
 {
 	return sizeof(RDP_DEVICE);
@@ -460,6 +599,7 @@ size_t rdp_state_size()

 void rdp_save_state(uint8_t *state)
 {
+	processor->wait_for_timeline(processor->signal_timeline());
 	memcpy(state, &rdp_device, sizeof(RDP_DEVICE));
 }

@@ -468,6 +608,31 @@ void rdp_load_state(const uint8_t *state)
 	memcpy(&rdp_device, state, sizeof(RDP_DEVICE));
 }

+void rdp_onscreen_message(const char *_message)
+{
+	if (messages.empty())
+		message_timer = SDL_GetTicks() + MESSAGE_TIME;
+	messages.push(_message);
+}
+
+uint32_t pixel_size(uint32_t pixel_type, uint32_t area)
+{
+	switch (pixel_type)
+	{
+	case 0:
+		return area / 2;
+	case 1:
+		return area;
+	case 2:
+		return area * 2;
+	case 3:
+		return area * 4;
+	default:
+		printf("Invalid pixel size: %u\n", pixel_type);
+		return 0;
+	}
+}
+
 uint64_t rdp_process_commands()
 {
 	uint64_t interrupt_timer = 0;
@@ -531,6 +696,75 @@ uint64_t rdp_process_commands()

 		switch (RDP::Op(command))
 		{
+		case RDP::Op::FillTriangle:
+		case RDP::Op::FillZBufferTriangle:
+		case RDP::Op::TextureTriangle:
+		case RDP::Op::TextureZBufferTriangle:
+		case RDP::Op::ShadeTriangle:
+		case RDP::Op::ShadeZBufferTriangle:
+		case RDP::Op::ShadeTextureTriangle:
+		case RDP::Op::ShadeTextureZBufferTriangle:
+		case RDP::Op::TextureRectangle:
+		case RDP::Op::TextureRectangleFlip:
+		case RDP::Op::FillRectangle:
+		{
+			uint32_t offset_address = (rdp_device.frame_buffer_info.framebuffer_address + pixel_size(rdp_device.frame_buffer_info.framebuffer_pixel_size, rdp_device.frame_buffer_info.framebuffer_y_offset * rdp_device.frame_buffer_info.framebuffer_width)) >> 3;
+			if (offset_address < rdram_dirty.size() && !rdram_dirty[offset_address])
+			{
+				uint32_t end_addr = std::min(offset_address + ((pixel_size(rdp_device.frame_buffer_info.framebuffer_pixel_size, rdp_device.frame_buffer_info.framebuffer_width * rdp_device.frame_buffer_info.framebuffer_height) + 7) >> 3), static_cast<uint32_t>(rdram_dirty.size()));
+				std::fill(rdram_dirty.begin() + offset_address, rdram_dirty.begin() + end_addr, true);
+			}
+
+			if (rdp_device.frame_buffer_info.depth_buffer_enabled)
+			{
+				offset_address = (rdp_device.frame_buffer_info.depthbuffer_address + pixel_size(2, rdp_device.frame_buffer_info.framebuffer_y_offset * rdp_device.frame_buffer_info.framebuffer_width)) >> 3;
+				if (offset_address < rdram_dirty.size() && !rdram_dirty[offset_address])
+				{
+					uint32_t end_addr = std::min(offset_address + ((pixel_size(2, rdp_device.frame_buffer_info.framebuffer_width * rdp_device.frame_buffer_info.framebuffer_height) + 7) >> 3), static_cast<uint32_t>(rdram_dirty.size()));
+					std::fill(rdram_dirty.begin() + offset_address, rdram_dirty.begin() + end_addr, true);
+				}
+			}
+		}
+		break;
+		case RDP::Op::LoadTLut:
+		case RDP::Op::LoadTile:
+		{
+			uint32_t upper_left_t = (w1 & 0xFFF) >> 2;
+			uint32_t offset_address = (rdp_device.frame_buffer_info.texture_address + pixel_size(rdp_device.frame_buffer_info.texture_pixel_size, upper_left_t * rdp_device.frame_buffer_info.texture_width)) >> 3;
+			if (offset_address < rdram_dirty.size() && !rdram_dirty[offset_address])
+			{
+				uint32_t lower_right_t = (w2 & 0xFFF) >> 2;
+				uint32_t end_addr = std::min(offset_address + ((pixel_size(rdp_device.frame_buffer_info.texture_pixel_size, (lower_right_t - upper_left_t) * rdp_device.frame_buffer_info.texture_width) + 7) >> 3), static_cast<uint32_t>(rdram_dirty.size()));
+				std::fill(rdram_dirty.begin() + offset_address, rdram_dirty.begin() + end_addr, true);
+			}
+		}
+		break;
+		case RDP::Op::LoadBlock:
+		{
+			uint32_t upper_left_s = ((w1 >> 12) & 0xFFF);
+			uint32_t upper_left_t = (w1 & 0xFFF);
+			uint32_t offset_address = (rdp_device.frame_buffer_info.texture_address + pixel_size(rdp_device.frame_buffer_info.texture_pixel_size, upper_left_s + upper_left_t * rdp_device.frame_buffer_info.texture_width)) >> 3;
+			if (offset_address < rdram_dirty.size() && !rdram_dirty[offset_address])
+			{
+				uint32_t lower_right_s = ((w2 >> 12) & 0xFFF);
+				uint32_t end_addr = std::min(offset_address + ((pixel_size(rdp_device.frame_buffer_info.texture_pixel_size, lower_right_s - upper_left_s) + 7) >> 3), static_cast<uint32_t>(rdram_dirty.size()));
+				std::fill(rdram_dirty.begin() + offset_address, rdram_dirty.begin() + end_addr, true);
+			}
+		}
+		break;
+		case RDP::Op::SetColorImage:
+			rdp_device.frame_buffer_info.framebuffer_address = (w2 & 0x00FFFFFF);
+			rdp_device.frame_buffer_info.framebuffer_pixel_size = (w1 >> 19) & 0x3;
+			rdp_device.frame_buffer_info.framebuffer_width = (w1 & 0x3FF) + 1;
+			break;
+		case RDP::Op::SetMaskImage:
+			rdp_device.frame_buffer_info.depthbuffer_address = (w2 & 0x00FFFFFF);
+			break;
+		case RDP::Op::SetTextureImage:
+			rdp_device.frame_buffer_info.texture_address = (w2 & 0x00FFFFFF);
+			rdp_device.frame_buffer_info.texture_pixel_size = (w1 >> 19) & 0x3;
+			rdp_device.frame_buffer_info.texture_width = (w1 & 0x3FF) + 1;
+			break;
 		case RDP::Op::SetScissor:
 		{
 			uint32_t upper_left_x = ((w1 >> 12) & 0xFFF) >> 2;
@@ -545,14 +779,21 @@ uint64_t rdp_process_commands()
 			{
 				rdp_device.region = 0;
 			}
-			break;
+
+			rdp_device.frame_buffer_info.framebuffer_y_offset = upper_left_y;
+			rdp_device.frame_buffer_info.framebuffer_height = lower_right_y - upper_left_y;
 		}
+		break;
+		case RDP::Op::SetOtherModes:
+		{
+			uint8_t cycle_type = (w1 >> 20) & 3;
+			uint8_t depth_read_write = (w2 >> 4) & 3;
+			rdp_device.frame_buffer_info.depth_buffer_enabled = ((cycle_type & 2) == 0) && (depth_read_write != 0);
+		}
+		break;
 		case RDP::Op::SyncFull:
-			if (rdp_device.last_sync != rdp_device.vi_counter)
-			{
-				processor->wait_for_timeline(processor->signal_timeline());
-				rdp_device.last_sync = rdp_device.vi_counter;
-			}
+			sync_signal = processor->signal_timeline();
+
 			interrupt_timer = rdp_device.region;
 			if (interrupt_timer == 0)
 				interrupt_timer = 5000;
@@ -33,15 +33,21 @@ extern "C"
 		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_init(void *_window, GFX_INFO _gfx_info, const void *font, size_t font_size);
 	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);
 	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);
@@ -1,2 +1,2 @@
 [toolchain]
-channel = "1.88.0"
+channel = "1.94.0"
@@ -71,7 +71,7 @@ pub fn init(

    if !device.cheats.cheats.is_empty() {
        device.cheats.enabled = true;
-        ui::audio::play_cheat_event(&device.ui);
+        ui::video::onscreen_message(&device.ui, "Cheats enabled");
    }
 }

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

 // Static wrappers

@@ -10,7 +10,7 @@ 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 std::{collections::HashMap, fs, io::Read};
@@ -87,21 +87,20 @@ pub fn run_game(device: &mut Device, rom_contents: Vec<u8>, game_settings: ui::g
    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>> {
@@ -207,9 +206,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,
 }
@@ -347,6 +345,7 @@ impl Device {
                    sector: 0,
                    buffer: vec![0; 8192],
                    writeback_sector: vec![0; 256],
+                    usb_buffer: vec![],
                },
                flashram: cart::sram::Flashram {
                    status: 0,
@@ -482,10 +481,6 @@ impl Device {
                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,
@@ -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) {
@@ -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,
@@ -157,7 +147,7 @@ fn eeprom_write_block(device: &mut device::Device, block: usize, offset: usize,

    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) {
@@ -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)
@@ -139,8 +136,7 @@ pub fn dma_write(
 pub fn init(device: &mut device::Device, rom_file: Vec<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 {
@@ -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
@@ -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;
@@ -275,7 +405,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(
@@ -299,7 +429,7 @@ pub fn dma_read(
    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 +439,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)
@@ -344,7 +474,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;
    }
@@ -107,7 +107,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) {
@@ -151,7 +151,14 @@ fn dma_read_sram(device: &mut device::Device, mut cart_addr: u32, mut dram_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,7 +167,7 @@ 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) {
@@ -217,7 +224,14 @@ fn dma_write_sram(
            .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;
    }
@@ -317,12 +331,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 +356,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;
@@ -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 input = if let Some(netplay) = &mut device.netplay {
+                if netplay.player_number as usize == channel {
                    let local_input = ui::input::get(&device.ui, 0);
-                    netplay::send_input(device.netplay.as_ref().unwrap(), local_input);
+                    netplay::send_input(netplay, local_input);
                }
-
                netplay::get_input(device, channel)
+            } else {
+                ui::input::get(&device.ui, channel)
            };

            device.pif.ram[offset..offset + 4].copy_from_slice(&input.data.to_ne_bytes());
@@ -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,22 @@ pub fn pak_switch_event(device: &mut device::Device) {
                    write: device::controller::mempak::write,
                    pak_type: new_pak_type,
                });
+                ui::video::onscreen_message(&device.ui, "MemPak selected");
            } 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(&device.ui, "RumblePak selected");
            } 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(&device.ui, "TransferPak selected");
            }
-            ui::audio::play_pak_switch(&device.ui, new_pak_type);
            channel.change_pak = PakType::None;
        }
    }
@@ -1,4 +1,5 @@
 use crate::device;
+use crate::ui;

 pub const MEMPAK_SIZE: usize = 0x8000;
 const MPK_PAGE_SIZE: usize = 256;
@@ -96,6 +97,6 @@ pub fn write(device: &mut device::Device, channel: usize, address: u16, data: us
        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);
    }
 }
@@ -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);
        }
    }
 }
@@ -29,14 +29,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,12 +179,8 @@ 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(),
-                )
+            let index = if let Some(weak) = &device.ui.weak {
+                ui::vru::prompt_for_match(&device.vru.words, weak, device.vi.frame_time)
            } else {
                0x7FFF
            };
@@ -179,6 +179,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,
@@ -261,38 +263,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 = [
@@ -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(
+            &device.ui,
+            "Overclocking enabled, setting clock rate to 125 MHz",
+        );
        125000000
    };

@@ -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,8 @@ 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_COUNT: usize = 13;

 #[derive(PartialEq, Copy, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Event {
@@ -60,6 +62,7 @@ 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,
        _ => dummy_event,
    }
 }
@@ -18,7 +18,6 @@ pub fn check_pending_interrupts(device: &mut device::Device) {
        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;
    }

    if (device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize]
@@ -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(
@@ -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)
 }
@@ -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 {
@@ -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
 }

@@ -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);
        }
    }
@@ -268,16 +268,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() {
@@ -1,4 +1,5 @@
 use crate::device;
+use crate::ui;
 use std::alloc::{Layout, alloc_zeroed};

 //const RDRAM_CONFIG_REG: u32 = 0;
@@ -33,7 +34,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 +51,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 +85,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,
@@ -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 {
@@ -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 {
@@ -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());
@@ -70,10 +70,9 @@ 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
+        device.vi.regs[VI_CURRENT_REG as usize] = ((device.vi.delay
            - (next_vi.count - device.cpu.cop0.regs[device::cop0::COP0_COUNT_REG as usize]))
            / device.vi.count_per_scanline)
            as u32;
@@ -137,21 +136,31 @@ 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 (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();
+    device.vi.vi_counter += 1;
+
+    if device.netplay.is_none() && paused {
+        ui::video::pause_loop(device.vi.frame_time);
+    }
+
+    unsafe { sdl3_sys::events::SDL_PumpEvents() };

    /*
    let vis = if device.cart.pal { 50 } else { 60 };
@@ -182,8 +191,7 @@ 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 {
+    if let Err(outcome) = device.vi.limiter.as_ref().unwrap().check() {
        let dur = outcome.wait_time_from(governor::clock::DefaultClock::default().now());
        spin_sleep::sleep(dur);
        if dur < device.vi.min_wait_time {
@@ -9,6 +9,7 @@ mod netplay;
 mod savestates;
 mod ui;
 use clap::Parser;
+use std::io::Error;
 use ui::gui;

 /// N64 emulator
@@ -22,15 +23,22 @@ struct Args {
        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."
+        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(
        short,
        long,
@@ -66,112 +74,97 @@ struct Args {
    clear_input_bindings: bool,
 }

-#[tokio::main]
-async fn main() {
+fn main() -> std::io::Result<()> {
+    let runtime = tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .worker_threads(4)
+        .thread_name("n64")
+        .thread_stack_size(env!("N64_STACK_SIZE").parse().unwrap())
+        .build()
+        .unwrap();
+
    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.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() {
+    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()
+            )));
+        };
+
+        let handle = runtime.spawn(async 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,
+                },
+            );
+        });
+        runtime.block_on(handle).unwrap()
+    } else if std::env::args().count() > 1 {
        let mut ui = ui::Ui::new();

        if args.clear_input_bindings {
            ui::input::clear_bindings(&mut ui);
-            return;
+            return Ok(());
        }
-        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 let Some(port) = args.port
+            && !(1..=4).contains(&port)
+        {
+            return Err(Error::other("Port must be between 1 and 4"));
        }
        if args.list_controllers {
            let controllers = ui::input::get_controller_names(&ui);
            for (i, controller) in controllers.iter().enumerate() {
                println!("Controller {i}: {controller}");
            }
-            return;
+            return Ok(());
        }
-        if args.configure_input_profile.is_some() {
+        if let Some(profile) = args.configure_input_profile {
            ui::input::configure_input_profile(
                &mut ui,
-                args.configure_input_profile.unwrap(),
+                profile,
                args.use_dinput,
+                args.deadzone.unwrap_or(ui::input::DEADZONE_DEFAULT),
            );
-            return;
+            return Ok(());
        }
-        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 let Some(assign_controller) = args.assign_controller {
+            let Some(port) = args.port else {
+                return Err(Error::other("Must specify port number"));
+            };
+            ui::input::assign_controller(&mut ui, assign_controller, port);
        }
-        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();
-
-            handle.join().unwrap();
-        } else {
-            println!("Could not read rom file");
-            return;
+        if let Some(profile) = args.bind_input_profile {
+            let Some(port) = args.port else {
+                return Err(Error::other("Must specify port number"));
+            };
+            ui::input::bind_input_profile(&mut ui, profile, port);
        }
    } else {
-        gui::app_window();
+        runtime.block_on(async {
+            gui::app_window();
+        });
    }
+    runtime.shutdown_timeout(std::time::Duration::from_secs(1));
+    Ok(())
 }
@@ -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;
@@ -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();
@@ -155,7 +146,7 @@ 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(&device.ui, "Lost connection to netplay server");
            input = Some(InputEvent {
                input: 0,
                plugin: 0,
@@ -200,15 +191,13 @@ 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(ui, "Netplay desync detected");
+                        ui::video::onscreen_message(ui, "Netplay desync detected"); // queue this message twice to ensure they see it
                    }
                    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(ui, &format!("Player {dis} disconnected"));
                        }
                    }
                    netplay.status = current_status;
@@ -1,4 +1,4 @@
-use crate::{device, ui};
+use crate::{cheats, device, ui};
 #[cfg(target_arch = "aarch64")]
 use device::__m128i;
 use serde::de::{Deserialize, Deserializer, SeqAccess, Visitor};
@@ -87,9 +87,12 @@ pub fn create_savestate(device: &device::Device) {
        compressed_file,
    )
    .unwrap();
-    println!(
-        "Savestate created at {}",
-        device.ui.storage.paths.savestate_file_path.display()
+    ui::video::onscreen_message(
+        &device.ui,
+        &format!(
+            "Savestate created in slot {}",
+            device.ui.storage.save_state_slot
+        ),
    );
 }

@@ -195,12 +198,26 @@ 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::video::load_state(device, rdp_state.as_ptr());
-            println!(
-                "Savestate loaded from {}",
-                device.ui.storage.paths.savestate_file_path.display()
+
+            if device.cheats.enabled {
+                cheats::execute_cheats(device, device.cheats.cheats.clone());
+            }
+
+            ui::video::onscreen_message(
+                &device.ui,
+                &format!(
+                    "Savestate loaded from slot {}",
+                    device.ui.storage.save_state_slot
+                ),
            );
        } else {
-            println!("Failed to load savestate");
+            ui::video::onscreen_message(
+                &device.ui,
+                &format!(
+                    "Failed to load savestate from slot {}",
+                    device.ui.storage.save_state_slot
+                ),
+            );
        }
    }
 }
@@ -5,6 +5,7 @@ pub mod gui;
 pub mod input;
 pub mod netplay;
 pub mod storage;
+pub mod usb;
 pub mod video;
 pub mod vru;

@@ -14,11 +15,7 @@ pub struct Dirs {
 }

 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,
 }

@@ -32,6 +29,7 @@ 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 {
@@ -39,6 +37,11 @@ pub struct Video {
    pub fullscreen: bool,
 }

+pub struct Usb {
+    pub usb_tx: Option<tokio::sync::broadcast::Sender<usb::UsbData>>,
+    pub cart_rx: Option<tokio::sync::broadcast::Receiver<usb::UsbData>>,
+}
+
 pub struct Ui {
    pub dirs: Dirs,
    pub config: config::Config,
@@ -49,12 +52,15 @@ pub struct Ui {
    pub input: Input,
    pub storage: Storage,
    pub video: Video,
+    pub usb: Usb,
+    pub weak: Option<slint::Weak<gui::AppWindow>>,
 }

 impl Drop for Ui {
    fn drop(&mut self) {
        if self.with_sdl {
            unsafe {
+                sdl3_ttf_sys::ttf::TTF_Quit();
                sdl3_sys::init::SDL_Quit();
            }
        }
@@ -63,12 +69,23 @@ impl Drop for Ui {

 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) {
+        if sdl3_sys::init::SDL_WasInit(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}");
+            panic!(
+                "Could not initialize SDL subsystem: {}, {}",
+                u32::from(flag),
+                err
+            );
+        }
+    }
+}
+
+pub fn ttf_init() {
+    unsafe {
+        if !sdl3_ttf_sys::ttf::TTF_Init() {
+            panic!("Could not initialize TTF");
        }
    }
 }
@@ -94,7 +111,7 @@ pub fn get_dirs() -> Dirs {
 }

 impl Ui {
-    fn construct_ui(joysticks: Vec<u32>, with_sdl: bool) -> Ui {
+    fn construct_ui(joysticks: Vec<sdl3_sys::everything::SDL_JoystickID>, with_sdl: bool) -> Ui {
        let dirs = get_dirs();

        Ui {
@@ -125,6 +142,7 @@ impl Ui {
                joysticks,
            },
            storage: Storage {
+                save_state_slot: 0,
                save_type: vec![],
                paths: storage::Paths {
                    eep_file_path: std::path::PathBuf::new(),
@@ -139,27 +157,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,31 +185,18 @@ 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,
            },
+            usb: Usb {
+                usb_tx: None,
+                cart_rx: None,
+            },
+            weak: None,
            dirs,
            with_sdl,
        }
@@ -1,63 +1,8 @@
 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>,
-}
-
 pub fn init(ui: &mut ui::Ui, frequency: u64) {
    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);
 }

@@ -69,29 +14,26 @@ pub fn init_game_audio(ui: &mut ui::Ui, frequency: u64) {
    };

    ui.audio.audio_stream = unsafe {
-        sdl3_sys::audio::SDL_CreateAudioStream(&game_audio_spec, &ui.audio.audio_device_spec)
+        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;
+        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_ResumeAudioStreamDevice(ui.audio.audio_stream)
    } {
-        panic!("Could not bind audio stream");
+        panic!("Could not resume audio stream");
    }
 }

 pub fn close(ui: &mut ui::Ui) {
    close_game_audio(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;
-    }
 }

 pub fn close_game_audio(ui: &mut ui::Ui) {
@@ -110,8 +52,8 @@ 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(ui, &format!("Audio volume: {:.0}%", ui.audio.gain * 100.0));
 }

 pub fn raise_audio_volume(ui: &mut ui::Ui) {
@@ -121,77 +63,28 @@ 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(ui, &format!("Audio volume: {:.0}%", ui.audio.gain * 100.0));
 }

-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");
-    }
-}
-
-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(device: &device::Device, frequency: f32) {
+    if !device.vi.enable_speed_limiter {
        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");
+    unsafe {
+        let current_ratio =
+            sdl3_sys::everything::SDL_GetAudioStreamFrequencyRatio(device.ui.audio.audio_stream);
+        sdl3_sys::everything::SDL_SetAudioStreamFrequencyRatio(
+            device.ui.audio.audio_stream,
+            (current_ratio + frequency).clamp(0.995, 1.005),
+        );
+        /*
+        println!(
+            "Adjusted audio frequency ratio to {}",
+            sdl3_sys::everything::SDL_GetAudioStreamFrequencyRatio(device.ui.audio.audio_stream)
+        );
+        */
    }
 }

@@ -215,11 +108,11 @@ 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;
+    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 < min_latency {
-        let silence_buffer: Vec<u8> = vec![0; min_latency as usize & !3];
+    if audio_queued < samples_per_frame {
+        let silence_buffer: Vec<u8> = vec![0; samples_per_frame as usize & !3];
        if !unsafe {
            sdl3_sys::audio::SDL_PutAudioStreamData(
                device.ui.audio.audio_stream,
@@ -229,17 +122,32 @@ pub fn play_audio(device: &device::Device, dram_addr: usize, length: u64) {
        } {
            panic!("Could not play audio");
        }
+        /*
+        println!(
+            "Audio underrun: queued {} samples, expected at least {} samples",
+            audio_queued, samples_per_frame
+        );
+        */
+        adjust_audio_frequency(device, -0.0005);
    }

-    if audio_queued < acceptable_latency
-        && !unsafe {
+    if audio_queued < max_latency {
+        if !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");
        }
-    {
-        panic!("Could not play audio");
+    } else {
+        /*
+        println!(
+            "Audio overrun: queued {} samples, expected at most {} samples",
+            audio_queued, max_latency
+        );
+        */
+        adjust_audio_frequency(device, 0.0005);
    }
 }
@@ -15,10 +15,18 @@ pub type Cheats = std::collections::BTreeMap<String, std::collections::BTreeMap<

 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()
+            && let Ok(exists) = std::fs::exists(&rom_dir)
+            && exists
+        {
+            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
@@ -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)]
@@ -54,6 +55,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 +69,7 @@ pub struct Config {
    pub input: Input,
    pub video: Video,
    pub emulation: Emulation,
+    pub rom_dir: std::path::PathBuf,
 }

 impl Drop for Cheats {
@@ -149,7 +152,9 @@ impl Config {
            emulation: Emulation {
                overclock: false,
                disable_expansion_pak: false,
+                usb: false,
            },
+            rom_dir: std::path::PathBuf::new(),
        }
    }
 }
@@ -5,6 +5,10 @@ use slint::Model;

 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,
@@ -20,11 +24,6 @@ pub struct GbPaths {
    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,
@@ -60,15 +59,23 @@ fn check_latest_version(weak: slint::Weak<AppWindow>) {
    });
 }

-fn local_game_window(app: &AppWindow, controller_paths: &[Option<String>]) {
+fn local_game_window(app: &AppWindow, controller_paths: &[Option<String>], usb: ui::Usb) {
    let dirs = ui::get_dirs();
    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();
+        let mut usb_tx = None;
+        if let Some(usb_tx_inner) = usb.usb_tx.as_ref() {
+            usb_tx = Some(usb_tx_inner.clone());
+        }
+        let mut cart_rx = None;
+        if let Some(cart_rx_inner) = usb.cart_rx.as_ref() {
+            cart_rx = Some(cart_rx_inner.resubscribe());
+        }
        weak.upgrade_in_event_loop(move |handle| {
            save_settings(&handle, &controller_paths);
-            open_rom(&handle)
+            open_rom(&handle, ui::Usb { usb_tx, cart_rx })
        })
        .unwrap();
    });
@@ -94,13 +101,19 @@ fn settings_window(app: &AppWindow, config: &ui::config::Config) {
    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) {
@@ -173,6 +186,7 @@ fn controller_window(
        std::rc::Rc::new(controllers);
    app.set_controller_names(slint::ModelRc::from(controller_names_model));

+    let controller_changed = slint::VecModel::default();
    let selected_controllers = slint::VecModel::default();
    for selected in config.input.controller_assignment.iter() {
        let mut found = false;
@@ -186,14 +200,20 @@ fn controller_window(
        if !found {
            selected_controllers.push(0);
        }
+        controller_changed.push(false);
    }
    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 controller_changed_model: std::rc::Rc<slint::VecModel<bool>> =
+        std::rc::Rc::new(controller_changed);
+    app.set_controller_changed(slint::ModelRc::from(controller_changed_model));
+
    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 || {
@@ -203,10 +223,16 @@ fn controller_window(
                    handle.hide().unwrap();
                    let profile_name = handle.get_profile_name().into();
                    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);
+                        ui::input::configure_input_profile(
+                            &mut game_ui,
+                            profile_name,
+                            dinput,
+                            deadzone,
+                        );
                        update_input_profiles(&weak_app, &game_ui.config);
                    });
                })
@@ -224,7 +250,8 @@ pub fn save_settings(app: &AppWindow, controller_paths: &[Option<String>]) {
    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();
@@ -243,8 +270,10 @@ 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) {
+            config.input.controller_assignment[i] =
+                controller_paths[selected_controller as usize].clone();
+        }
    }
 }

@@ -274,6 +303,11 @@ fn about_window(app: &AppWindow) {
 pub fn app_window() {
    let app = AppWindow::new().unwrap();
    about_window(&app);
+    let mut usb = ui::Usb {
+        usb_tx: None,
+        cart_rx: None,
+    };
+    let mut shutdown_tx = None;
    let mut controller_paths;
    {
        let game_ui = ui::Ui::new();
@@ -283,123 +317,96 @@ pub fn app_window() {
        controller_paths.insert(0, None);
        settings_window(&app, &game_ui.config);
        controller_window(&app, &game_ui.config, &controller_names, &controller_paths);
+
+        if game_ui.config.emulation.usb {
+            (shutdown_tx, usb) = ui::usb::init(app.as_weak());
+        }
    }
-    local_game_window(&app, &controller_paths);
+    local_game_window(&app, &controller_paths, usb);
    ui::netplay::netplay_window(&app, &controller_paths);
    ui::cheats::cheats_window(&app);
    app.run().unwrap();
+    if let Some(shutdown_tx) = &shutdown_tx {
+        ui::usb::close(shutdown_tx);
+    }
    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;
-            }
-        }
-    });
-}
-
 pub fn run_rom(
    gb_paths: GbPaths,
    file_path: std::path::PathBuf,
    mut game_settings: GameSettings,
-    vru_channel: VruChannel,
    netplay: Option<NetplayDevice>,
+    usb: ui::Usb,
    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 mut device = device::Device::new();
+        device.ui.config.rom_dir = file_path.parent().unwrap().to_path_buf();

-            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();
+        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();
-                }
+                device.transferpaks[i].cart.ram =
+                    std::fs::read(gb_paths.ram[i].as_ref().unwrap()).unwrap();
            }
+        }

-            device.vru_window.window_notifier = vru_channel.vru_window_notifier;
-            device.vru_window.word_receiver = vru_channel.vru_word_receiver;
+        device.ui.usb.usb_tx = usb.usb_tx;
+        device.ui.usb.cart_rx = usb.cart_rx;

-            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);
-                }
+        device.ui.weak = Some(weak.clone());
+
+        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 {
-                println!("Could not read rom file");
+                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()
+                };
            }
-
-            if let Some(vru_window_notifier) = device.vru_window.window_notifier {
-                vru_window_notifier.try_send(None).unwrap();
+            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");
+        }

-            weak.upgrade_in_event_loop(move |handle| handle.set_game_running(false))
-                .unwrap();
+        let rom_dir = device.ui.config.rom_dir.clone();
+        weak.upgrade_in_event_loop(move |handle| {
+            if let Some(rom_dir_str) = rom_dir.to_str() {
+                handle.set_rom_dir(rom_dir_str.into());
+            }
+            handle.set_game_running(false);
        })
        .unwrap();
+    });
 }

-fn open_rom(app: &AppWindow) {
-    let select_rom = rfd::AsyncFileDialog::new()
-        .set_title("Select ROM")
-        .pick_file();
+fn open_rom(app: &AppWindow, usb: ui::Usb) {
+    let rom_dir = app.get_rom_dir();
+    let select_rom = if !rom_dir.is_empty()
+        && let Ok(exists) = std::fs::exists(&rom_dir)
+        && exists
+    {
+        rfd::AsyncFileDialog::new().set_directory(rom_dir)
+    } else {
+        rfd::AsyncFileDialog::new()
+    }
+    .set_title("Select ROM")
+    .add_filter("ROM files", &N64_EXTENSIONS)
+    .pick_file();
    let mut select_gb_rom = [None, None, None, None];
    let mut select_gb_ram = [None, None, None, None];

@@ -408,35 +415,22 @@ fn open_rom(app: &AppWindow) {
            select_gb_rom[i] = Some(
                rfd::AsyncFileDialog::new()
                    .set_title(format!("GB ROM P{}", i + 1))
+                    .add_filter("GB ROM files", &["gb", "gbc", "GB", "GBC"])
                    .pick_file(),
            );
            select_gb_ram[i] = Some(
                rfd::AsyncFileDialog::new()
                    .set_title(format!("GB RAM P{}", i + 1))
+                    .add_filter("GB RAM files", &["sav", "ram", "srm", "SAV", "RAM", "SRM"])
                    .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();

-    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 {
@@ -465,18 +459,8 @@ fn open_rom(app: &AppWindow) {
                    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,
-                    }
-                },
                None,
+                usb,
                weak,
            );
        }
@@ -14,6 +14,8 @@ 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;
@@ -29,7 +31,7 @@ export component AppWindow inherits Window {
    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);
    in property version <=> AboutData.version;
@@ -41,8 +43,11 @@ export component AppWindow inherits Window {
    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 selected_profile_binding <=> ControllerData.selected_profile_binding;
    in-out property input_profiles <=> ControllerData.input_profiles;
@@ -56,7 +61,7 @@ export component AppWindow inherits Window {
    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 {
@@ -102,8 +107,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();
@@ -3,6 +3,7 @@

 import { ListView, HorizontalBox, VerticalBox, Button, GroupBox, 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 {
@@ -13,6 +13,7 @@ export global ControllerData {
    in-out property <[string]> input_profiles;
    in-out property <[string]> controller_names;
    in-out property <[int]> selected_controller;
+    in-out property <[bool]> controller_changed;
    in-out property <bool> blank_profiles;
 }

@@ -89,10 +90,12 @@ export component ControllerConfig inherits Page {

            if !ControllerData.blank_profiles: 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 +106,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;
                        }
                    }
                }
@@ -1,8 +1,9 @@
-import { StandardButton, HorizontalBox, VerticalBox, Button, LineEdit, CheckBox } from "std-widgets.slint";
+import { StandardButton, HorizontalBox, VerticalBox, Button, LineEdit, CheckBox, 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 {
@@ -10,6 +11,7 @@ export component InputProfileDialog inherits Window {
    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 {
@@ -21,6 +23,28 @@ export component InputProfileDialog inherits Window {
            }
        }

+        HorizontalBox {
+            alignment: center;
+            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;
            CheckBox {
@@ -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 {
@@ -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.";
+    }
+}
@@ -5,20 +5,23 @@ 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 {
@@ -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]);
                }
            }
        }
@@ -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);
+        }
+    }
+}
@@ -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 {
@@ -12,6 +12,8 @@ export global SettingsData {
    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 +29,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;
@@ -79,7 +81,9 @@ export component Settings inherits Page {
            }
        }

-        Rectangle { }
+        Rectangle {
+            height: 20px;
+        }

        HorizontalBox {
            alignment: start;
@@ -102,5 +106,16 @@ export component Settings inherits Page {
                }
            }
        }
+
+        HorizontalBox {
+            alignment: start;
+            CheckBox {
+                text: @tr("Emulate UNFLoader (reload emulator after changing)");
+                checked: SettingsData.emulate_usb;
+                toggled => {
+                    SettingsData.emulate_usb = self.checked;
+                }
+            }
+        }
    }
 }
@@ -28,6 +28,8 @@ 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,
@@ -40,7 +42,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 maxium diagonal distance of the controller

    // Calculate the distance from the origin (0, 0)
    let distance = f64::sqrt((*x) * (*x) + (*y) * (*y));
@@ -53,6 +55,24 @@ 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 set_axis_from_joystick(
    profile: &ui::config::InputProfile,
    joystick: *mut sdl3_sys::joystick::SDL_Joystick,
@@ -123,6 +143,17 @@ fn get_button_from_i32(button: i32) -> sdl3_sys::gamepad::SDL_GamepadButton {
        12 => sdl3_sys::gamepad::SDL_GamepadButton::DPAD_DOWN,
        13 => sdl3_sys::gamepad::SDL_GamepadButton::DPAD_LEFT,
        14 => sdl3_sys::gamepad::SDL_GamepadButton::DPAD_RIGHT,
+        15 => sdl3_sys::gamepad::SDL_GamepadButton::MISC1,
+        16 => sdl3_sys::gamepad::SDL_GamepadButton::RIGHT_PADDLE1,
+        17 => sdl3_sys::gamepad::SDL_GamepadButton::LEFT_PADDLE1,
+        18 => sdl3_sys::gamepad::SDL_GamepadButton::RIGHT_PADDLE2,
+        19 => sdl3_sys::gamepad::SDL_GamepadButton::LEFT_PADDLE2,
+        20 => sdl3_sys::gamepad::SDL_GamepadButton::TOUCHPAD,
+        21 => sdl3_sys::gamepad::SDL_GamepadButton::MISC2,
+        22 => sdl3_sys::gamepad::SDL_GamepadButton::MISC3,
+        23 => sdl3_sys::gamepad::SDL_GamepadButton::MISC4,
+        24 => sdl3_sys::gamepad::SDL_GamepadButton::MISC5,
+        25 => sdl3_sys::gamepad::SDL_GamepadButton::MISC6,
        _ => panic!("Invalid button"),
    }
 }
@@ -225,8 +256,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;
    }
@@ -288,7 +320,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,7 +329,7 @@ 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,
            )
        };
    }
@@ -326,8 +358,9 @@ fn change_paks(
        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;
+        pressed = (unsafe { sdl3_sys::joystick::SDL_GetJoystickHat(joystick, joystick_hat.id) }
+            & joystick_hat.direction)
+            != 0;
    } else if key.enabled {
        pressed = unsafe { *keyboard_state.offset(key.id as isize) };
    }
@@ -363,8 +396,6 @@ pub fn get_controller_paths(game_ui: &ui::Ui) -> Vec<Option<String>> {
 }

 pub fn get(ui: &ui::Ui, channel: usize) -> InputData {
-    unsafe { sdl3_sys::events::SDL_PumpEvents() };
-
    let profile_name = ui.config.input.input_profile_binding[channel].clone();
    let profile = ui.config.input.input_profiles.get(&profile_name).unwrap();
    let mut keys = 0;
@@ -407,9 +438,11 @@ 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);

@@ -464,8 +497,9 @@ fn close_controllers(
    }
 }

-pub fn configure_input_profile(ui: &mut ui::Ui, profile: String, dinput: bool) {
+pub fn configure_input_profile(ui: &mut ui::Ui, profile: String, dinput: bool, deadzone: i32) {
    ui::sdl_init(sdl3_sys::init::SDL_INIT_VIDEO);
+    ui::ttf_init();

    if profile == "default" {
        println!("Profile name cannot be default");
@@ -500,7 +534,7 @@ pub fn configure_input_profile(ui: &mut ui::Ui, profile: String, dinput: bool) {
            title.as_ptr(),
            640,
            480,
-            0,
+            sdl3_sys::video::SDL_WindowFlags(0),
            &mut window,
            &mut renderer,
        )
@@ -567,8 +601,18 @@ 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/Roboto-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();
@@ -577,7 +621,8 @@ pub fn configure_input_profile(ui: &mut ui::Ui, profile: String, dinput: bool) {
        ui::video::draw_text(
            format!("Select binding for: {key}").as_str(),
            renderer,
-            &font,
+            text_engine,
+            font,
        );

        let mut key_set = false;
@@ -611,7 +656,9 @@ pub fn configure_input_profile(ui: &mut ui::Ui, profile: String, dinput: bool) {
                } else if event_type == u32::from(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,
@@ -647,7 +694,9 @@ pub fn configure_input_profile(ui: &mut ui::Ui, profile: String, dinput: bool) {
                {
                    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,11 +711,20 @@ pub fn configure_input_profile(ui: &mut ui::Ui, profile: String, dinput: bool) {
                }
            }
        }
+        ui::video::draw_text(
+            format!("Binding set for {key}").as_str(),
+            renderer,
+            text_engine,
+            font,
+        );
+        std::thread::sleep(std::time::Duration::from_millis(200));
    }

    close_controllers(open_joysticks, open_controllers);

    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);
    }
@@ -679,6 +737,7 @@ 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);
 }
@@ -879,6 +938,7 @@ pub fn get_default_profile() -> ui::config::InputProfile {
            axis: 0,
        }; PROFILE_SIZE],
        dinput: false,
+        deadzone: DEADZONE_DEFAULT,
    }
 }

@@ -892,7 +952,7 @@ 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 mut joystick_id = sdl3_sys::everything::SDL_JoystickID(0);
            let assigned_path = controller_assignment.as_ref().unwrap();

            for joystick in ui.input.joysticks.iter() {
@@ -919,7 +979,7 @@ pub fn init(ui: &mut ui::Ui) {
                if !profile.dinput {
                    let gamepad = unsafe { sdl3_sys::gamepad::SDL_OpenGamepad(joystick_id) };
                    if gamepad.is_null() {
-                        println!("could not connect gamepad: {joystick_id}")
+                        println!("could not connect gamepad: {}", u32::from(joystick_id))
                    } else {
                        ui.input.controllers[i].game_controller = gamepad;
                        let properties =
@@ -938,7 +998,7 @@ 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}")
+                        println!("could not connect joystick: {}", u32::from(joystick_id))
                    } else {
                        ui.input.controllers[i].joystick = joystick;
                        let properties =
@@ -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)]
@@ -199,10 +199,13 @@ pub fn init(ui: &mut ui::Ui, rom: &[u8]) {
        .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(
+        prefix.to_owned()
+            + "-"
+            + &ui.game_hash
+            + ".state"
+            + ui.storage.save_state_slot.to_string().as_str(),
+    );
 }

 pub fn load_saves(ui: &mut ui::Ui, netplay: &mut Option<netplay::Netplay>) {
@@ -351,15 +354,10 @@ pub fn compress_file(data: &[(&[u8], &str)]) -> Vec<u8> {
    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();
-}
-
 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 +369,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 +387,108 @@ 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) {
+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 => {
+            device.ui.storage.saves.eeprom.write_pending = true;
+        }
+        SaveTypes::Sram => {
+            device.ui.storage.saves.sram.write_pending = true;
+        }
+        SaveTypes::Flash => {
+            device.ui.storage.saves.flash.write_pending = true;
+        }
+        SaveTypes::Mempak => {
+            device.ui.storage.saves.mempak.write_pending = true;
+        }
+        SaveTypes::Sdcard => {
+            device.ui.storage.saves.sdcard.write_pending = true;
+        }
+        SaveTypes::Romsave => {
+            device.ui.storage.saves.romsave.write_pending = true;
+        }
+    }
+    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 path: &std::path::Path;
    let data: &Vec<u8>;
+    let rom_save_data: Vec<u8>;
    match save_type {
        SaveTypes::Eeprom4k | SaveTypes::Eeprom16k => {
            path = ui.storage.paths.eep_file_path.as_ref();
            data = ui.storage.saves.eeprom.data.as_ref();
+            ui.storage.saves.eeprom.write_pending = false;
        }
        SaveTypes::Sram => {
            path = ui.storage.paths.sra_file_path.as_ref();
            data = ui.storage.saves.sram.data.as_ref();
+            ui.storage.saves.sram.write_pending = false;
        }
        SaveTypes::Flash => {
            path = ui.storage.paths.fla_file_path.as_ref();
            data = ui.storage.saves.flash.data.as_ref();
+            ui.storage.saves.flash.write_pending = false;
        }
        SaveTypes::Mempak => {
            path = ui.storage.paths.pak_file_path.as_ref();
            data = ui.storage.saves.mempak.data.as_ref();
+            ui.storage.saves.mempak.write_pending = false;
        }
        SaveTypes::Sdcard => {
            path = ui.storage.paths.sdcard_file_path.as_ref();
            data = ui.storage.saves.sdcard.data.as_ref();
+            ui.storage.saves.sdcard.write_pending = false;
        }
        SaveTypes::Romsave => {
-            write_rom_save(ui);
-            return;
+            path = ui.storage.paths.romsave_file_path.as_ref();
+            rom_save_data = postcard::to_stdvec(&ui.storage.saves.romsave.data).unwrap();
+            data = rom_save_data.as_ref();
+            ui.storage.saves.romsave.write_pending = false;
        }
    }
-    let result = std::fs::write(path, data);
-    if result.is_err() {
-        panic!(
-            "could not save {} {}",
-            path.display(),
-            result.err().unwrap()
-        )
-    }
+    let save_data = data.clone();
+    let save_path = path.to_path_buf();
+    tokio::spawn(async move {
+        tokio::fs::write(save_path, save_data).await.unwrap();
+    });
 }
@@ -0,0 +1,220 @@
+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,
+            },
+        );
+    }
+}
+
+fn upload_rom(
+    weak: slint::Weak<ui::gui::AppWindow>,
+    rom: Vec<u8>,
+    usb_tx: &tokio::sync::broadcast::Sender<UsbData>,
+    cart_rx: &tokio::sync::broadcast::Receiver<UsbData>,
+) {
+    let weak_clone = weak.clone();
+    let usb_tx = usb_tx.clone();
+    let cart_rx = cart_rx.resubscribe();
+
+    weak.upgrade_in_event_loop(move |handle| {
+        let dir = std::env::temp_dir();
+        let rom_path = dir.join("rom_upload.bin");
+        std::fs::write(rom_path.clone(), rom).unwrap();
+
+        ui::gui::run_rom(
+            ui::gui::GbPaths {
+                rom: [None, None, None, None],
+                ram: [None, None, None, None],
+            },
+            rom_path,
+            ui::gui::GameSettings {
+                fullscreen: handle.get_fullscreen(),
+                overclock: handle.get_overclock_n64_cpu(),
+                disable_expansion_pak: handle.get_disable_expansion_pak(),
+                cheats: std::collections::HashMap::new(), // will be filled in later
+            },
+            None,
+            ui::Usb {
+                usb_tx: Some(usb_tx),
+                cart_rx: Some(cart_rx),
+            },
+            weak_clone,
+        );
+    })
+    .unwrap();
+}
+
+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>,
+    cart_rx: tokio::sync::broadcast::Receiver<UsbData>,
+    weak: slint::Weak<ui::gui::AppWindow>,
+) {
+    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 {
+                                    upload_rom(weak.clone(), usb_data.data,&usb_tx,&cart_rx);
+                                } else {
+                                    cart_tx.send(usb_data).unwrap();
+                                }
+                                data_type = None;
+                                data_size = None;
+                            }
+                        }
+                    }
+                    Err(_e) => {
+                        break;
+                    }
+                }
+            }
+            _ = shutdown_rx.changed() => {
+                break;
+            }
+        }
+    }
+}
+
+pub fn init(
+    weak: slint::Weak<ui::gui::AppWindow>,
+) -> (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(),cart_rx.resubscribe(),weak.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();
+}
@@ -1,10 +1,10 @@
 #![allow(non_snake_case)]
 include!(concat!(env!("OUT_DIR"), "/parallel_bindings.rs"));
 use crate::{device, ui};
-use ab_glyph::{Font, ScaleFont};

 pub fn init(device: &mut device::Device) {
    ui::sdl_init(sdl3_sys::init::SDL_INIT_VIDEO);
+    ui::ttf_init();

    let title = std::ffi::CString::new("gopher64").unwrap();

@@ -74,7 +74,15 @@ pub fn init(device: &mut device::Device) {
        crt: device.ui.config.video.crt,
    };

-    unsafe { rdp_init(device.ui.video.window as *mut std::ffi::c_void, gfx_info) }
+    unsafe {
+        let font_bytes = include_bytes!("../../data/Roboto-Regular.ttf");
+        rdp_init(
+            device.ui.video.window as *mut std::ffi::c_void,
+            gfx_info,
+            font_bytes.as_ptr() as *const std::ffi::c_void,
+            font_bytes.len(),
+        )
+    }
 }

 pub fn close(ui: &ui::Ui) {
@@ -85,10 +93,13 @@ pub fn close(ui: &ui::Ui) {
 }

 pub fn update_screen() {
-    // when the window is closed, running is set to false
    unsafe { rdp_update_screen() }
 }

+pub fn render_frame() {
+    unsafe { rdp_render_frame() }
+}
+
 pub fn state_size() -> usize {
    unsafe { rdp_state_size() }
 }
@@ -122,7 +133,19 @@ pub fn load_state(device: &mut device::Device, rdp_state: *const u8) {
    }
 }

-pub fn check_callback(device: &mut device::Device) -> bool {
+pub fn pause_loop(frame_time: f64) {
+    let mut paused = true;
+    let mut frame_advance = false;
+    while paused && !frame_advance {
+        std::thread::sleep(std::time::Duration::from_secs_f64(frame_time));
+        unsafe { sdl3_sys::events::SDL_PumpEvents() };
+        let callback = unsafe { rdp_check_callback() };
+        paused = callback.paused;
+        frame_advance = callback.frame_advance;
+    }
+}
+
+pub fn check_callback(device: &mut device::Device) -> (bool, bool) {
    let mut speed_limiter_toggled = false;
    let callback = unsafe { rdp_check_callback() };
    device.cpu.running = callback.emu_running;
@@ -138,12 +161,25 @@ pub fn check_callback(device: &mut device::Device) -> bool {
        }
    }

+    if device.ui.storage.save_state_slot != callback.save_state_slot {
+        ui::video::onscreen_message(
+            &device.ui,
+            &format!("Switching savestate slot to {}", callback.save_state_slot,),
+        );
+        device.ui.storage.save_state_slot = callback.save_state_slot;
+        device
+            .ui
+            .storage
+            .paths
+            .savestate_file_path
+            .set_extension("state".to_owned() + callback.save_state_slot.to_string().as_str());
+    }
    if callback.lower_volume {
        ui::audio::lower_audio_volume(&mut device.ui);
    } else if callback.raise_volume {
        ui::audio::raise_audio_volume(&mut device.ui);
    }
-    speed_limiter_toggled
+    (speed_limiter_toggled, callback.paused)
 }

 pub fn set_register(reg: u32, value: u32) {
@@ -156,60 +192,34 @@ pub fn process_rdp_list() -> u64 {
    unsafe { rdp_process_commands() }
 }

+pub fn check_framebuffers(address: u32, length: u32) {
+    unsafe { rdp_check_framebuffers(address, length) }
+}
+
+pub fn onscreen_message(_ui: &ui::Ui, message: &str) {
+    unsafe { rdp_onscreen_message(std::ffi::CString::new(message).unwrap().as_ptr()) };
+}
+
 pub fn draw_text(
    text: &str,
    renderer: *mut sdl3_sys::render::SDL_Renderer,
-    font: &ab_glyph::FontRef,
+    text_engine: *mut sdl3_ttf_sys::ttf::TTF_TextEngine,
+    font: *mut sdl3_ttf_sys::ttf::TTF_Font,
 ) {
-    // Clear the canvas
    unsafe {
-        sdl3_sys::render::SDL_SetRenderDrawColor(
-            renderer,
+        let (mut w, mut h) = (0, 0);
+        sdl3_sys::render::SDL_GetRenderOutputSize(renderer, &mut w, &mut h);
+
+        let ttf_text = sdl3_ttf_sys::ttf::TTF_CreateText(
+            text_engine,
+            font,
+            std::ffi::CString::new(text).unwrap().as_ptr(),
            0,
-            0,
-            0,
-            sdl3_sys::pixels::SDL_ALPHA_OPAQUE,
        );
-        sdl3_sys::render::SDL_RenderClear(renderer);
-    };

-    let text_size = 40.0;
-    let (mut w, mut h) = (0, 0);
-    unsafe { sdl3_sys::render::SDL_GetRenderOutputSize(renderer, &mut w, &mut h) };
-    let x_start = 20.0;
-    let y_start = (h / 2) as f32;
-
-    let mut x_offset = 0.0;
-    for c in text.chars() {
-        let q_glyph_id = font.glyph_id(c);
-        let q_glyph = q_glyph_id.with_scale(text_size);
-
-        if let Some(q) = font.outline_glyph(q_glyph) {
-            q.draw(|x, y, c| {
-                if c > 0.5 {
-                    unsafe {
-                        sdl3_sys::render::SDL_SetRenderDrawColor(
-                            renderer,
-                            255,
-                            255,
-                            255,
-                            sdl3_sys::pixels::SDL_ALPHA_OPAQUE,
-                        );
-                        sdl3_sys::render::SDL_RenderPoint(
-                            renderer,
-                            x_start + x_offset + x as f32 - q.px_bounds().width()
-                                + q.px_bounds().max.x,
-                            y_start + y as f32 - q.px_bounds().height() + q.px_bounds().max.y,
-                        );
-                    };
-                }
-            });
-        }
-        x_offset += font.as_scaled(text_size).h_advance(q_glyph_id);
-    }
-
-    // Present the canvas
-    if !unsafe { sdl3_sys::render::SDL_RenderPresent(renderer) } {
-        panic!("Could not present renderer");
+        sdl3_sys::everything::SDL_RenderClear(renderer);
+        sdl3_ttf_sys::ttf::TTF_DrawRendererText(ttf_text, 20.0, h as f32 / 2.0);
+        sdl3_sys::render::SDL_RenderPresent(renderer);
+        sdl3_ttf_sys::ttf::TTF_DestroyText(ttf_text);
    }
 }
@@ -1,16 +1,50 @@
+use crate::gui;
+use slint::ComponentHandle;
+
 pub fn prompt_for_match(
    words: &[String],
-    window_notifier: &tokio::sync::mpsc::Sender<Option<Vec<String>>>,
-    word_index_receiver: &mut tokio::sync::mpsc::Receiver<String>,
+    weak_vru: &slint::Weak<gui::AppWindow>,
+    frame_time: f64,
 ) -> u16 {
    let mut dedup_words = words.to_owned();
    dedup_words.sort();
    dedup_words.dedup();
-    window_notifier.try_send(Some(dedup_words)).unwrap();
-    let mut result = word_index_receiver.try_recv();
+
+    let (tx, mut rx) = tokio::sync::mpsc::channel(1);
+
+    weak_vru
+        .upgrade_in_event_loop(move |_handle| {
+            let vru_dialog = gui::VruDialog::new().unwrap();
+            let vru_dialog_weak = vru_dialog.as_weak();
+
+            let tx_clicked = tx.clone();
+
+            vru_dialog.on_vru_button_clicked(move |chosen_word| {
+                tx_clicked.try_send(chosen_word.to_string()).unwrap();
+                vru_dialog_weak.unwrap().window().hide().unwrap();
+            });
+
+            vru_dialog.window().on_close_requested(move || {
+                tx.try_send("".to_string()).unwrap();
+                slint::CloseRequestResponse::HideWindow
+            });
+
+            let words_vec = slint::VecModel::default();
+            for word in dedup_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();
+
+    let mut result = rx.try_recv();
    while result.is_err() {
-        result = word_index_receiver.try_recv();
-        std::thread::sleep(std::time::Duration::from_secs_f64(1.0 / 60.0));
+        result = rx.try_recv();
+        std::thread::sleep(std::time::Duration::from_secs_f64(frame_time));
        unsafe { sdl3_sys::events::SDL_PumpEvents() }; // so the OS doesn't complain about the game window being frozen
    }
    for (i, v) in words.iter().enumerate() {
Author	SHA1	Message	Date
Logan McNaughton	1c6e23b7f2	Update parallel-rdp	2026-03-05 20:42:24 +01:00
Logan McNaughton	b4ae7db3dd	Update to Rust 1.94.0 (#672 )	2026-03-05 20:37:50 +01:00
Logan McNaughton	e750b6eed1	upload unzipped artifact (#670 )	2026-02-27 19:11:00 +01:00
Logan McNaughton	f8b777248a	update sdl	2026-02-22 08:12:10 +01:00
Logan McNaughton	51e9b3aa55	cargo update	2026-02-15 21:41:10 +01:00
Logan McNaughton	efbeaeab88	rust 1.93.1	2026-02-12 22:49:42 +01:00
Logan McNaughton	f24a5e7f05	reapply cheats when loading save state	2026-02-11 16:13:36 +01:00
Logan McNaughton	55170fcca3	use Xoshiro256PlusPlus (#668 )	2026-02-09 12:16:10 +01:00
Logan McNaughton	b952c45e0b	cargo update	2026-02-09 10:44:19 +01:00
Logan McNaughton	b13f37baf8	bump to 1.1.15	2026-02-06 09:53:09 +01:00
Logan McNaughton	db40ec5034	cargo update (rand)	2026-02-06 09:51:12 +01:00
Logan McNaughton	cedb2d5c22	update slint	2026-02-04 18:05:03 +01:00
Logan McNaughton	22d57677cb	cargo update	2026-02-03 20:49:46 +01:00
Logan McNaughton	f29f497405	bump to 1.1.14	2026-01-29 21:58:40 +01:00
Logan McNaughton	0aab9f71e1	cargo update	2026-01-29 21:58:06 +01:00
Logan McNaughton	7f84eb2aff	add missing gamepad button types	2026-01-26 21:44:03 +01:00
Logan McNaughton	b460d55714	use SDL_HAPTIC_INFINITY	2026-01-25 13:35:59 +01:00
Logan McNaughton	ceaf56c563	bump to 1.1.13	2026-01-22 21:00:26 +01:00
Logan McNaughton	5937922558	fix issue with emux_xdetect	2026-01-22 20:44:17 +01:00
Logan McNaughton	e9e71a6e02	Update to rust 1.93.0 (#659 )	2026-01-22 20:24:41 +01:00
Logan McNaughton	9775f103e0	flush saves to disk (#658 ) * flush saves to disk * more * more * more * more * more * more * more * more	2026-01-22 20:09:13 +01:00
Logan McNaughton	bf01898c6f	remove extra function	2026-01-22 09:22:47 +01:00
Logan McNaughton	ce3b12bba9	print message for audio volume	2026-01-21 19:01:50 +01:00
Logan McNaughton	56ff2b260c	adjust audio ratios	2026-01-21 12:13:19 +01:00
Logan McNaughton	367c22877b	add system for micro adjustments to audio pitch	2026-01-21 11:47:33 +01:00
Logan McNaughton	befbacc5b3	remove un-needed var	2026-01-20 15:31:03 +01:00
Logan McNaughton	e1a6663bb5	remove needless copy	2026-01-20 13:21:44 +01:00
Logan McNaughton	c5185e60c6	tweak ai dma calculation	2026-01-20 13:19:14 +01:00
Logan McNaughton	1aa879d759	tweak audio queue formula	2026-01-20 13:05:32 +01:00
Logan McNaughton	bfad71f09f	Update parallel-rdp (#656 ) * Update parallel-rdp * update cargo	2026-01-19 13:32:06 +01:00
Logan McNaughton	431b787998	update rfd	2026-01-05 19:27:16 +01:00
Logan McNaughton	d48e3dc106	update rfd	2026-01-05 09:54:42 +01:00
Logan McNaughton	8be1ac7740	update SDL crate (#648 ) * update SDL crate * more	2026-01-03 10:07:27 +01:00
Logan McNaughton	56d0b1b2e2	update sse2neon to v1.9.1	2026-01-02 14:41:00 +01:00
Logan McNaughton	7f63bf1fde	Update sse2neon to v1.9.0 (#642 )	2025-12-22 10:08:09 +01:00
Logan McNaughton	05be960358	cargo update	2025-12-21 16:23:23 +01:00
dependabot[bot]	38a5079acf	Bump actions/upload-artifact from 5 to 6 (#641 ) Bumps [actions/upload-artifact](https://github.com/actions/upload-artifact) from 5 to 6. - [Release notes](https://github.com/actions/upload-artifact/releases) - [Commits](https://github.com/actions/upload-artifact/compare/v5...v6) --- updated-dependencies: - dependency-name: actions/upload-artifact dependency-version: '6' dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2025-12-15 06:36:17 +01:00
Logan McNaughton	144e31c7fc	bump to 1.1.12	2025-12-11 22:08:08 +01:00
Logan McNaughton	e7a21171f4	fix windows build (#636 )	2025-12-11 21:48:28 +01:00
Logan McNaughton	413da0178e	update parallel rdp	2025-12-11 17:57:59 +01:00
Logan McNaughton	d8c6669da1	Update to Rust 1.92.0 (#634 )	2025-12-11 17:46:50 +01:00
Logan McNaughton	c6fcfddf8c	some cleanup	2025-12-10 15:12:56 +01:00
Logan McNaughton	0aa5c3e63a	cleanup variable	2025-12-10 12:35:22 +01:00
Logan McNaughton	6f8433138d	clippy fixes (#632 ) * clippy fixes * fix netplay browser	2025-12-10 10:00:42 +01:00
Logan McNaughton	ea5bbfb218	only update controller assignment after user input (#629 )	2025-12-06 13:42:10 +01:00
Logan McNaughton	10af598223	cargo update	2025-11-26 16:48:39 +01:00
dependabot[bot]	c08511adc5	Bump actions/checkout from 5 to 6 (#622 ) Bumps [actions/checkout](https://github.com/actions/checkout) from 5 to 6. - [Release notes](https://github.com/actions/checkout/releases) - [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md) - [Commits](https://github.com/actions/checkout/compare/v5...v6) --- updated-dependencies: - dependency-name: actions/checkout dependency-version: '6' dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2025-11-24 04:24:48 +01:00
Logan McNaughton	f116617ac3	remove redundant SDL_PumpEvents	2025-11-22 14:31:08 +01:00
Logan McNaughton	1141095b65	some code cleanup	2025-11-22 14:14:22 +01:00
Logan McNaughton	162a6df56d	move if statement for better performance	2025-11-22 13:40:26 +01:00
Logan McNaughton	72f47e5aff	addressing hack to fix compatibility with latest libdragon (#620 )	2025-11-22 10:04:31 +01:00
Logan McNaughton	6d40f5a12d	cargo update	2025-11-21 10:44:52 +01:00
Logan McNaughton	64e6d75db1	Update Granite (#618 ) * Update Granite * add file	2025-11-21 10:44:09 +01:00
Logan McNaughton	20761faf8c	rust 1.91.1	2025-11-11 12:43:54 +01:00
Adam Steinberg	79eb34d83d	unsolicited main.rs refactor (#614 ) * main.rs refactor * remove anyhow * forgive me clippy, for I have sinned	2025-11-08 21:34:35 +01:00
Logan McNaughton	c4057c2f21	bump to 1.1.11	2025-11-05 15:29:56 +01:00
Logan McNaughton	581cc0b9aa	cargo update	2025-11-05 15:16:57 +01:00
Logan McNaughton	6f6e21c718	tweak build options	2025-11-05 15:12:12 +01:00
Logan McNaughton	181774a1de	pass netplay_id to workflow	2025-11-04 15:38:30 +01:00
Logan McNaughton	002fbbe8a4	set netplay id from environment (#606 )	2025-11-04 08:27:32 +01:00
Logan McNaughton	ab630cc8cb	Use skia backend for gui (#605 ) * Use skia backend for gui * more * use clang-cl * more * more	2025-11-03 23:07:10 +01:00
Logan McNaughton	06f9c56a79	bump to 1.1.10	2025-10-30 22:52:34 +01:00
Logan McNaughton	c3f4b11519	update sdl3	2025-10-30 22:47:45 +01:00
Logan McNaughton	921a0d5362	Rust 1.91 (#599 )	2025-10-30 20:14:39 +01:00
Logan McNaughton	24fc5b9638	update parallel-rdp	2025-10-30 13:59:20 +01:00
dependabot[bot]	1559856483	Bump signpath/github-action-submit-signing-request from 1.3 to 2.0 (#597 ) Bumps [signpath/github-action-submit-signing-request](https://github.com/signpath/github-action-submit-signing-request) from 1.3 to 2.0. - [Release notes](https://github.com/signpath/github-action-submit-signing-request/releases) - [Commits](https://github.com/signpath/github-action-submit-signing-request/compare/v1.3...v2.0) --- updated-dependencies: - dependency-name: signpath/github-action-submit-signing-request dependency-version: '2.0' dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2025-10-27 08:36:02 +01:00
dependabot[bot]	1deb91fc1e	Bump actions/upload-artifact from 4 to 5 (#596 ) Bumps [actions/upload-artifact](https://github.com/actions/upload-artifact) from 4 to 5. - [Release notes](https://github.com/actions/upload-artifact/releases) - [Commits](https://github.com/actions/upload-artifact/compare/v4...v5) --- updated-dependencies: - dependency-name: actions/upload-artifact dependency-version: '5' dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2025-10-27 06:01:31 +01:00
Logan McNaughton	726a58f854	cargo update	2025-10-26 13:45:56 +01:00
Logan McNaughton	fe0297690f	pump events during vi (#593 ) * pump events during vi * add var * more * more	2025-10-26 13:42:25 +01:00
Logan McNaughton	847df61526	Add pause between key bindings (#594 )	2025-10-26 13:33:40 +01:00
Logan McNaughton	6de8128f5b	cargo update	2025-10-12 12:30:57 +02:00
Logan McNaughton	6c09176d12	add .srm for GB saves	2025-10-11 19:32:35 +02:00
Logan McNaughton	2050098735	fix out of bounds access (#590 )	2025-10-06 09:02:50 +02:00
Logan McNaughton	d3ecc37da6	fix compare interrupt issue (#588 )	2025-10-01 10:05:03 +02:00
Logan McNaughton	a0237e9f7d	bump to 1.1.9	2025-09-28 10:00:37 +02:00
Logan McNaughton	d6d608b674	Revert "more audio cleanup" This reverts commit `f3271cba63`.	2025-09-28 09:59:02 +02:00
Logan McNaughton	f254bec968	bump to 1.1.8	2025-09-27 21:33:21 +02:00
Logan McNaughton	bd4aff2b2c	cargo update	2025-09-27 21:32:27 +02:00
Logan McNaughton	0bf70a77ea	correct load block size	2025-09-26 18:52:27 +02:00
Logan McNaughton	e23e7f33c1	Re-add wgpu I didn't see any evidence of crashing	2025-09-26 07:23:48 +02:00
Logan McNaughton	9d0516545e	reorder items	2025-09-25 16:14:48 +02:00
Logan McNaughton	e3023a902f	further depth buffer tracking tweaks (#583 )	2025-09-25 15:59:58 +02:00
Logan McNaughton	431c7c2a8d	cargo update	2025-09-25 13:32:23 +02:00
Logan McNaughton	cf99539f85	remove wgpu (#576 )	2025-09-25 07:36:23 +02:00
Logan McNaughton	c2493b829e	watch z-buffer reads as well (#581 )	2025-09-24 23:00:39 +02:00
Logan McNaughton	2f25de55d7	change depth buffer tracking (#580 )	2025-09-24 20:06:39 +02:00
Logan McNaughton	116ffe9845	fix clippy warning	2025-09-22 09:15:41 +02:00
Logan McNaughton	f3271cba63	more audio cleanup	2025-09-21 18:36:03 +02:00
Logan McNaughton	9037680cda	cleanup audio code (#579 )	2025-09-21 16:30:11 +02:00
Logan McNaughton	fc41e26a6d	expose 8x resolution (#578 )	2025-09-21 13:36:13 +02:00
Logan McNaughton	d1f28bb7a8	optimize rdp_check_framebuffers (#577 )	2025-09-21 10:43:49 +02:00
Logan McNaughton	9db831fdef	disable repeat mode on MI_CLR_INIT	2025-09-20 17:21:06 +02:00
Logan McNaughton	004b603e96	support basic mi repeat mode (#575 ) * support basic mi repeat mode * more * more	2025-09-20 17:09:30 +02:00
Logan McNaughton	8661e2c9b1	always enable lto	2025-09-20 08:37:55 +02:00
Logan McNaughton	c712f2a288	bump to 1.1.7	2025-09-19 12:57:05 +02:00
Logan McNaughton	366162e6fe	cargo update	2025-09-19 12:56:07 +02:00
Logan McNaughton	2b93fb8aa1	re-add framebuffer tracking (#573 )	2025-09-19 11:32:48 +02:00
Logan McNaughton	a191701610	update to rust 1.90 (#574 ) * update to rust 1.90 * more	2025-09-18 22:46:22 +02:00
Logan McNaughton	0605967c28	modify rsp sync points	2025-09-16 11:39:23 +02:00
Logan McNaughton	d6e6a16814	reset device.rdp.last_status_value	2025-09-16 10:02:07 +02:00
Logan McNaughton	e374825d5e	add release-with-debug profile	2025-09-15 19:23:21 +02:00
Logan McNaughton	f6d6746207	use addr_masked	2025-09-15 18:32:25 +02:00
Logan McNaughton	100238f198	optimize some reads/writes (#571 )	2025-09-15 18:26:45 +02:00
Logan McNaughton	daee53a626	Optimize VU instructions (#570 )	2025-09-15 15:50:28 +02:00
Logan McNaughton	018d8ca3e3	fix parallel-rdp build	2025-09-15 12:28:54 +02:00
Logan McNaughton	24d26d864e	update parallel-rdp	2025-09-15 12:21:26 +02:00
Logan McNaughton	7b8c549e8e	remove rdp sync speed hack (#567 )	2025-09-15 09:50:23 +02:00
Logan McNaughton	f6c7e3d3c0	use wgpu for gui	2025-09-12 14:16:46 +02:00
Logan McNaughton	374b01dccf	cargo update	2025-09-12 13:58:21 +02:00
Logan McNaughton	569b26a067	panic on attempted use of mi repeat mode	2025-09-10 13:16:57 +02:00
Logan McNaughton	380d196ae7	cargo update	2025-09-05 10:54:03 +02:00
Logan McNaughton	4fa1a8ad39	remove redundant get_rooms netplay call (#563 ) * remove redundant get_rooms netplay call * unwrap	2025-09-05 09:32:17 +02:00
Logan McNaughton	8acf3b9de8	bump to 1.1.6	2025-08-24 10:58:58 +02:00
Logan McNaughton	b3297f82b2	cargo update	2025-08-24 10:58:01 +02:00
Logan McNaughton	2127705e7b	set deadzon max to 99	2025-08-24 07:29:07 +02:00
Logan McNaughton	cccb079d63	cleanup deadzone code (#558 )	2025-08-24 00:05:03 +02:00
Logan McNaughton	c52b680753	use saturating abs for deadzone (#557 )	2025-08-23 22:52:04 +02:00
Logan McNaughton	8799650245	add deadzone option (#554 ) * add deadzone option * add deadzone calc * more	2025-08-23 15:36:03 +02:00
Logan McNaughton	90be2130c1	move cheats back	2025-08-23 09:36:47 +02:00
Logan McNaughton	96af33c434	Split render frame and update screen, move pause loop (#556 ) * split render and update screen functions * move pause loop	2025-08-23 08:54:47 +02:00
Logan McNaughton	0a42152bcb	move cheats	2025-08-22 22:42:09 +02:00
Logan McNaughton	db335e24d2	render frame before speed limiter (#555 )	2025-08-22 07:59:28 +02:00
Logan McNaughton	4857b86897	bump to 1.1.5 (#553 )	2025-08-21 15:22:19 +02:00
Logan McNaughton	26022fff72	cargo update	2025-08-21 15:03:50 +02:00
Logan McNaughton	658dede9e9	use dependabot to update rust (#552 )	2025-08-20 10:26:26 +02:00
Logan McNaughton	6ad1a31e34	correct joystick hat diagonal input (#551 )	2025-08-20 09:15:41 +02:00
Logan McNaughton	4476d476de	add frame advance (#549 )	2025-08-18 10:42:29 +02:00
Logan McNaughton	8037fb426e	UNF loader support (#526 )	2025-08-18 08:44:12 +02:00
Logan McNaughton	f0381a2cd1	add uppercase file extensions (#548 )	2025-08-17 21:01:23 +02:00
Logan McNaughton	c8e70e6125	cargo update	2025-08-17 20:56:02 +02:00
dependabot[bot]	e9664b1087	Bump actions/checkout from 4 to 5 (#545 ) Bumps [actions/checkout](https://github.com/actions/checkout) from 4 to 5. - [Release notes](https://github.com/actions/checkout/releases) - [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md) - [Commits](https://github.com/actions/checkout/compare/v4...v5) --- updated-dependencies: - dependency-name: actions/checkout dependency-version: '5' dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2025-08-12 13:02:31 +02:00
Logan McNaughton	3f72700da0	bump to 1.1.4 (#541 )	2025-08-07 19:21:54 +02:00
Logan McNaughton	9fcd2835eb	Update to rust 1.89.0 (#540 )	2025-08-07 13:17:39 +02:00
Logan McNaughton	c6767c94a6	move sse2neon to submodule (#539 )	2025-08-07 12:17:50 +02:00
Logan McNaughton	f1968e3a58	use NearestClamp for image	2025-08-06 23:02:08 +02:00
Logan McNaughton	23fdfff1ac	some clippy fixes (#538 ) * some clippy fixes * more	2025-08-06 12:18:40 +02:00
Logan McNaughton	fc512d9517	fix netplay for unknown ROMs	2025-08-06 09:12:35 +02:00
dependabot[bot]	3c317460fd	Bump signpath/github-action-submit-signing-request from 1.2 to 1.3 (#537 ) Bumps [signpath/github-action-submit-signing-request](https://github.com/signpath/github-action-submit-signing-request) from 1.2 to 1.3. - [Commits](https://github.com/signpath/github-action-submit-signing-request/compare/v1.2...v1.3) --- updated-dependencies: - dependency-name: signpath/github-action-submit-signing-request dependency-version: '1.3' dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2025-08-06 08:56:09 +02:00
Logan McNaughton	b1fcaa5cf4	add minimum size to combobox	2025-08-05 21:55:41 +02:00
Logan McNaughton	98c9cf142d	slight improvment to combobox sizes	2025-08-05 21:40:31 +02:00
Logan McNaughton	1eb1503981	Onscreen drawing (#536 ) * onscreen messages * more * more * more * more * use sdl_ttf * more * more * more * more * test * mroe * more * more * more * more * more * more * more * more * more * more * more * more * more * more * more * more * more	2025-08-05 15:59:49 +02:00
Logan McNaughton	5aa9a65e7b	add support for save state slots (#534 ) * add support for save state slots * add log	2025-08-04 14:59:50 +02:00
Logan McNaughton	71f1d98132	bump to 1.1.3 (#533 )	2025-08-03 13:30:27 +02:00
Logan McNaughton	0037c0f344	Don't wait for signpath completion	2025-08-03 11:56:12 +02:00
Logan McNaughton	752e804101	refreshing session message	2025-08-03 09:38:23 +02:00
Logan McNaughton	73354246f3	netplay dispatcher (#532 ) * netplay dispatcher * more * more * more * more * more * more * more * more * more * more * more * more * more * more * more * more * more * more * more * more * more * more * more	2025-08-03 09:25:57 +02:00
Logan McNaughton	a2d23c2f41	Fix crash in netplay windows (#530 ) * Fix crash in netplay windows * more	2025-07-29 23:02:07 +02:00
dependabot[bot]	6e652c7dbd	Bump signpath/github-action-submit-signing-request from 1.1 to 1.2 (#529 ) Bumps [signpath/github-action-submit-signing-request](https://github.com/signpath/github-action-submit-signing-request) from 1.1 to 1.2. - [Commits](https://github.com/signpath/github-action-submit-signing-request/compare/v1.1...v1.2) --- updated-dependencies: - dependency-name: signpath/github-action-submit-signing-request dependency-version: '1.2' dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2025-07-28 08:50:59 +02:00
Logan McNaughton	20749cf036	bump to 1.1.2 (#528 )	2025-07-25 21:45:52 +02:00
Logan McNaughton	d7f656cd6a	update cargo packages	2025-07-25 21:26:54 +02:00
Logan McNaughton	8558334391	Add code signing policy	2025-07-25 16:23:46 +02:00
Logan McNaughton	b6de872d78	Sign code using SignPath (#525 ) * Sign code using SignPath * more * more * more * more * more * use release-signing	2025-07-25 11:45:11 +02:00
Logan McNaughton	712dc10c65	cleanup netplay error checking	2025-07-25 07:20:50 +02:00
Logan McNaughton	cd2b5b4e92	error checking for netplay ui channels (#527 ) * error checking for netplay ui channels * more	2025-07-25 07:00:45 +02:00
Logan McNaughton	98b5d6506e	add spacing in settings	2025-07-20 23:12:01 +02:00
Logan McNaughton	f2e8bc6356	data access fixes	2025-07-20 21:33:07 +02:00
Logan McNaughton	328e1730a0	Update parallel-rdp (#523 )	2025-07-20 09:55:36 +02:00
Logan McNaughton	8010a6211c	Use default AR on windows (#522 ) * Use default AR on windows * use llvm-ar * more	2025-07-20 08:16:04 +02:00
Logan McNaughton	41b1fd05be	build without clang-cl on Windows (#521 )	2025-07-20 07:51:00 +02:00
Logan McNaughton	c5da2a795f	use specific llvm version (#520 ) * use specific llvm version * more * more * more * more	2025-07-19 18:30:17 +02:00
Logan McNaughton	7361a9bd5c	remove unneeded flag (#519 )	2025-07-19 16:45:27 +02:00
Logan McNaughton	d4e8933352	Use rust-lld on Windows (#518 )	2025-07-19 16:31:58 +02:00
Logan McNaughton	fff376db5e	cargo update	2025-07-19 15:51:57 +02:00
Logan McNaughton	d7f1c8415a	disable cargo dependabot	2025-07-19 15:51:23 +02:00
Logan McNaughton	ac09be4202	Increase axis movement requirement when configuring controller (#514 )	2025-07-17 15:22:21 +02:00
Logan McNaughton	022190384a	Add support for custom netplay server url (#511 ) * Add support for custom netplay server url * more * more * more * more * more * more * more * more * more * more	2025-07-16 15:42:54 +02:00
Logan McNaughton	e4dd5c2dee	Fix crash in wrestlemania (#510 )	2025-07-16 12:13:12 +02:00
Logan McNaughton	3e95059ec7	add pause hotkey (#509 )	2025-07-15 20:43:31 +02:00
Logan McNaughton	abc39e74ef	Remember ROM dir (#508 ) * Remember ROM dir * more * more * more * more * more	2025-07-15 20:05:46 +02:00
Logan McNaughton	7109d28223	update c standard (#507 ) * update c standard * more * more	2025-07-15 15:28:34 +02:00
Logan McNaughton	1d1e3829e4	Update icon	2025-07-14 15:47:11 +02:00
Logan McNaughton	a46e4f505b	re-enable mac build	2025-07-13 17:51:37 +02:00
Logan McNaughton	03fbe658f2	Update netplay server url (#491 )	2025-07-12 15:01:59 +02:00
Logan McNaughton	b96c9e4cdc	bump to 1.1.1 (#490 )	2025-07-11 21:28:53 +02:00