fix issue with emux_xdetect

Update to rust 1.93.0 (#659 )
flush saves to disk (#658 )
2026-07-11 09:35:21 +02:00 · 2026-01-22 20:44:17 +01:00 · 2026-01-22 20:24:41 +01:00 · 2026-01-22 20:09:13 +01:00 · 2026-01-22 09:22:47 +01:00 · 2026-01-21 19:01:50 +01:00
54 changed files with 2978 additions and 2306 deletions
@@ -1,4 +1,4 @@
-[target.'cfg(target_os = "linux")']
+[target.'cfg(all(target_arch = "aarch64", target_os = "linux"))']
 rustflags = ["-C", "link-arg=-fuse-ld=lld"]

 [target.'cfg(target_os = "windows")']
@@ -29,7 +29,7 @@ jobs:
            arch: linux-aarch64
            llvm: ARM64
    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
        with:
          submodules: recursive
      - uses: actions-rust-lang/setup-rust-toolchain@v1
@@ -48,7 +48,7 @@ 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
@@ -60,8 +60,10 @@ jobs:
          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@v6
        with:
          name: gopher64-${{ matrix.arch }}
          path: output/gopher64-${{ matrix.arch }}
@@ -81,7 +83,7 @@ jobs:
          #  arch: windows-aarch64
          #  llvm: woa64
    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
        with:
          submodules: recursive
      - uses: actions-rust-lang/setup-rust-toolchain@v1
@@ -102,15 +104,19 @@ jobs:
          cargo build --release -v --target=${{ matrix.target }}
          mkdir output
          cp target/${{ matrix.target }}/release/gopher64.exe output/gopher64-${{ matrix.arch }}.exe
+        env:
+          CC: clang-cl
+          CXX: clang-cl
+          NETPLAY_ID: ${{ secrets.NETPLAY_ID }}
      - name: Upload unsigned artifact
        id: upload-unsigned-artifact
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v6
        with:
          name: gopher64-${{ matrix.arch }}
          path: output/gopher64-${{ matrix.arch }}.exe
      - name: SignPath
        if: ${{ github.ref_type == 'tag' }}
-        uses: signpath/github-action-submit-signing-request@v1.3
+        uses: signpath/github-action-submit-signing-request@v2.0
        with:
          api-token: "${{ secrets.SIGNPATH_API_TOKEN }}"
          organization-id: "${{ secrets.SIGNPATH_ORG_ID }}"
@@ -121,6 +127,7 @@ jobs:
          wait-for-completion: false

  build-macos:
+    if: false
    runs-on: macos-15
    strategy:
      fail-fast: false
@@ -131,7 +138,7 @@ jobs:
          - target: aarch64-apple-darwin
            arch: mac-aarch64
    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
        with:
          submodules: recursive
      - uses: actions-rust-lang/setup-rust-toolchain@v1
@@ -145,8 +152,9 @@ jobs:
          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@v6
        with:
          name: gopher64-${{ matrix.arch }}
          path: output/gopher64-${{ matrix.arch }}
@@ -16,7 +16,7 @@ jobs:
  lint-linux:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
        with:
          submodules: recursive
      - uses: actions-rust-lang/setup-rust-toolchain@v1
@@ -34,7 +34,7 @@ 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
@@ -10,7 +10,7 @@ jobs:
      checks: write
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
        with:
          submodules: recursive
      - uses: rustsec/audit-check@v2
@@ -1,32 +1,32 @@
 [package]
 name = "gopher64"
-version = "1.1.4"
+version = "1.1.12"
 edition = "2024"
-rust-version = "1.89"
+rust-version = "1.93.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 = "7.0"
 governor = "0.10"
-sevenz-rust2 = { version = "0.17", default-features = false }
+sevenz-rust2 = { version = "0.20", default-features = false }
 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.12", default-features = false, features = ["compat-1-2", "std", "backend-winit", "renderer-skia-vulkan"] }
 open = "5.3"
 sha2 = "0.10"
-sdl3-sys = { version = "0.5", features = ["build-from-source-static"] }
-sdl3-ttf-sys = { version = "0.2", features = ["build-static-vendored", "no-sdlttf-harfbuzz", "no-sdlttf-plutosvg"] }
-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"
@@ -34,7 +34,7 @@ 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", default-features = false, features = ["http2","rustls","charset","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"
@@ -40,6 +40,7 @@ fn main() {
        .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")
@@ -54,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")
@@ -72,7 +74,6 @@ fn main() {

    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" {
@@ -95,11 +96,10 @@ fn main() {
            .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");

@@ -111,10 +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")
@@ -162,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)
@@ -191,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);
 }
@@ -53,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;
@@ -75,6 +88,9 @@ 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;
@@ -240,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;
@@ -256,6 +275,11 @@ 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);
 }
@@ -523,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()
@@ -543,6 +570,28 @@ CALL_BACK rdp_check_callback()
 	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);
@@ -550,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));
 }

@@ -565,6 +615,24 @@ void rdp_onscreen_message(const char *_message)
 	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;
@@ -628,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;
@@ -642,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;
@@ -42,10 +42,12 @@ extern "C"
 	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.89.0"
+channel = "1.93.0"
@@ -93,8 +93,7 @@ fn set_rng() -> rand_chacha::ChaCha8Rng {

 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 {
@@ -209,7 +208,6 @@ pub struct Device {
    #[serde(skip, default = "set_rng")]
    pub rng: rand_chacha::ChaCha8Rng,
    pub vru: controller::vru::Vru,
-    pub vru_window: controller::vru::VruWindow,
    pub transferpaks: [controller::transferpak::TransferPak; 4],
    pub cheats: cheats::Cheats,
 }
@@ -483,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) {
@@ -147,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,5 +1,6 @@
 use crate::device;
 use crate::netplay;
+use crate::ui;
 use sha2::{Digest, Sha256};

 pub const CART_MASK: usize = 0xFFFFFFF;
@@ -63,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;
@@ -94,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)
@@ -135,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 {
@@ -208,7 +208,7 @@ pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u
                                .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;
@@ -405,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(
@@ -429,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;
@@ -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) {
@@ -167,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) {
@@ -331,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")
            }
@@ -356,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 {
@@ -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,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,4 +1,5 @@
 use crate::device;
+use crate::ui;
 use rand_chacha::rand_core::RngCore;

 const PI_DRAM_ADDR_REG: u32 = 0;
@@ -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);
@@ -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;
@@ -50,6 +51,8 @@ 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
@@ -62,6 +65,8 @@ pub fn read_mem(
 }

 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
@@ -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 {
@@ -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,7 @@
 use rand_chacha::rand_core::RngCore;

 use crate::device;
+use crate::ui;

 const SI_DRAM_ADDR_REG: u32 = 0;
 const SI_PIF_ADDR_RD64B_REG: u32 = 1;
@@ -98,6 +99,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(())
 }
@@ -103,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();
@@ -15,9 +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 audio_device: u32,
    pub gain: f32,
 }

@@ -55,6 +53,7 @@ pub struct Ui {
    pub storage: Storage,
    pub video: Video,
    pub usb: Usb,
+    pub weak: Option<slint::Weak<gui::AppWindow>>,
 }

 impl Drop for Ui {
@@ -70,12 +69,15 @@ 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
+            );
        }
    }
 }
@@ -109,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 {
@@ -155,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,
                    },
                },
            },
@@ -183,9 +185,7 @@ impl Ui {
            game_id: String::new(),
            game_hash: String::new(),
            audio: Audio {
-                audio_device_spec: Default::default(),
                audio_stream: std::ptr::null_mut(),
-                audio_device: 0,
                gain: 1.0,
            },
            video: Video {
@@ -196,6 +196,7 @@ impl Ui {
                usb_tx: None,
                cart_rx: None,
            },
+            weak: None,
            dirs,
            with_sdl,
        }
@@ -3,32 +3,6 @@ use crate::ui;

 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");
-    }
-
    init_game_audio(ui, frequency);
 }

@@ -40,25 +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 {
-        sdl3_sys::audio::SDL_CloseAudioDevice(ui.audio.audio_device);
-        ui.audio.audio_device = 0;
-    }
 }

 pub fn close_game_audio(ui: &mut ui::Ui) {
@@ -78,6 +53,7 @@ pub fn lower_audio_volume(ui: &mut ui::Ui) {
        }
        sdl3_sys::audio::SDL_SetAudioStreamGain(ui.audio.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) {
@@ -88,6 +64,28 @@ pub fn raise_audio_volume(ui: &mut ui::Ui) {
        }
        sdl3_sys::audio::SDL_SetAudioStreamGain(ui.audio.audio_stream, ui.audio.gain);
    }
+    ui::video::onscreen_message(ui, &format!("Audio volume: {:.0}%", ui.audio.gain * 100.0));
+}
+
+fn adjust_audio_frequency(device: &device::Device, frequency: f32) {
+    if !device.vi.enable_speed_limiter {
+        return;
+    }
+
+    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)
+        );
+        */
+    }
 }

 pub fn play_audio(device: &device::Device, dram_addr: usize, length: u64) {
@@ -110,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,
@@ -124,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);
    }
 }
@@ -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)]
@@ -24,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,
@@ -111,6 +106,7 @@ fn settings_window(app: &AppWindow, config: &ui::config::Config) {
        1 => 0,
        2 => 1,
        4 => 2,
+        8 => 3,
        _ => 0,
    };
    app.set_resolution(combobox_value);
@@ -190,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;
@@ -203,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 || {
@@ -220,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);
                    });
                })
@@ -242,7 +251,7 @@ pub fn save_settings(app: &AppWindow, controller_paths: &[Option<String>]) {
    config.emulation.overclock = app.get_overclock_n64_cpu();
    config.emulation.disable_expansion_pak = app.get_disable_expansion_pak();
    config.emulation.usb = app.get_emulate_usb();
-    let upscale_values = [1, 2, 4];
+    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();
@@ -261,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();
+        }
    }
 }

@@ -321,120 +332,66 @@ pub fn app_window() {
    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();
-
-            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();
-
-                    device.transferpaks[i].cart.ram =
-                        std::fs::read(gb_paths.ram[i].as_ref().unwrap()).unwrap();
-                }
-            }
-
-            device.ui.usb.usb_tx = usb.usb_tx;
-            device.ui.usb.cart_rx = usb.cart_rx;
-
-            device.vru_window.window_notifier = vru_channel.vru_window_notifier;
-            device.vru_window.word_receiver = vru_channel.vru_word_receiver;
-
-            if let Some(rom_contents) = device::get_rom_contents(file_path.as_path()) {
-                if let Some(netplay_device) = netplay {
-                    device.netplay = Some(netplay::init(
-                        netplay_device.peer_addr,
-                        netplay_device.player_number,
-                    ));
-                } else {
-                    game_settings.cheats = {
-                        let game_crc = ui::storage::get_game_crc(&rom_contents);
-                        let cheats = ui::config::Cheats::new();
-                        cheats.cheats.get(&game_crc).cloned().unwrap_or_default()
-                    };
-                }
-                device::run_game(&mut device, rom_contents, game_settings);
-                if device.netplay.is_some() {
-                    netplay::close(&mut device);
-                }
-            } else {
-                println!("Could not read rom file");
-            }
-
-            if let Some(vru_window_notifier) = device.vru_window.window_notifier {
-                vru_window_notifier.try_send(None).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);
-            })
+    tokio::spawn(async move {
+        weak.upgrade_in_event_loop(move |handle| handle.set_game_running(true))
            .unwrap();
+
+        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();
+
+                device.transferpaks[i].cart.ram =
+                    std::fs::read(gb_paths.ram[i].as_ref().unwrap()).unwrap();
+            }
+        }
+
+        device.ui.usb.usb_tx = usb.usb_tx;
+        device.ui.usb.cart_rx = usb.cart_rx;
+
+        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 {
+                game_settings.cheats = {
+                    let game_crc = ui::storage::get_game_crc(&rom_contents);
+                    let cheats = ui::config::Cheats::new();
+                    cheats.cheats.get(&game_crc).cloned().unwrap_or_default()
+                };
+            }
+            device::run_game(&mut device, rom_contents, game_settings);
+            if device.netplay.is_some() {
+                netplay::close(&mut device);
+            }
+        } else {
+            println!("Could not read rom file");
+        }
+
+        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, usb: ui::Usb) {
@@ -464,31 +421,16 @@ fn open_rom(app: &AppWindow, usb: ui::Usb) {
            select_gb_ram[i] = Some(
                rfd::AsyncFileDialog::new()
                    .set_title(format!("GB RAM P{}", i + 1))
-                    .add_filter("GB RAM files", &["sav", "ram", "SAV", "RAM"])
+                    .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 {
@@ -517,17 +459,6 @@ fn open_rom(app: &AppWindow, usb: ui::Usb) {
                    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,
@@ -47,6 +47,7 @@ export component AppWindow inherits Window {
    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;
@@ -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;
 }

@@ -114,6 +115,7 @@ export component ControllerConfig inherits Page {
                        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 {
@@ -9,6 +9,7 @@ export component NetplayJoin inherits Window {
    in-out property sessions <=> NetplayData.sessions;
    in-out property current_session <=> NetplayData.current_session;
    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;
@@ -19,7 +20,7 @@ export component NetplayJoin inherits Window {
    in-out property rom_dir <=> NetplayData.rom_dir;
    callback refresh_session();
    callback select_rom(string);
-    callback join_session(string, string, string, string, string);
+    callback join_session(string, string, string, string, int);
    preferred-width: 700px;

    VerticalBox {
@@ -93,6 +94,7 @@ export component NetplayJoin inherits Window {
                    NetplayData.current_session = -1;
                    NetplayData.sessions = [];
                    NetplayData.room_urls = [];
+                    NetplayData.room_ports = [];
                    refresh_session();
                }
            }
@@ -129,7 +131,7 @@ export component NetplayJoin inherits Window {
                    NetplayData.game_hash,
                    NetplayData.password,
                    NetplayData.room_urls[NetplayData.current_session],
-                    NetplayData.sessions[NetplayData.current_session][1].text);
+                    NetplayData.room_ports[NetplayData.current_session]);
                }
            }
        }
@@ -19,6 +19,7 @@ export global NetplayData {
    in-out property <string> session_name;
    in-out property <[[StandardListViewItem]]> sessions;
    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;
@@ -29,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;
@@ -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,
@@ -365,8 +385,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;
@@ -409,9 +427,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);

@@ -466,7 +486,7 @@ 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();

@@ -503,7 +523,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,
        )
@@ -680,6 +700,13 @@ 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);
@@ -699,6 +726,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);
 }
@@ -899,6 +927,7 @@ pub fn get_default_profile() -> ui::config::InputProfile {
            axis: 0,
        }; PROFILE_SIZE],
        dinput: false,
+        deadzone: DEADZONE_DEFAULT,
    }
 }

@@ -912,7 +941,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() {
@@ -939,7 +968,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 =
@@ -958,7 +987,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 =
@@ -2,7 +2,7 @@ use crate::device;
 use crate::ui;
 use crate::ui::gui::{
    AppWindow, CustomNetplayServer, DispatcherDialog, ErrorDialog, GameSettings, GbPaths,
-    NetplayCreate, NetplayDevice, NetplayJoin, NetplayWait, VruChannel, run_rom, save_settings,
+    NetplayCreate, NetplayDevice, NetplayJoin, NetplayWait, run_rom, save_settings,
 };
 use futures::{SinkExt, StreamExt};
 use sha2::{Digest, Sha256};
@@ -111,7 +111,7 @@ impl NetplayPages for NetplayJoin {
 fn populate_server_names<T: ComponentHandle + NetplayPages + 'static>(weak: slint::Weak<T>) {
    let task = reqwest::Client::new()
        .get("https://dispatch.gopher64.com/getRegions")
-        .header("netplay-id", EMU_NAME)
+        .header("netplay-id", env!("NETPLAY_ID"))
        .send();
    tokio::spawn(async move {
        let mut local_servers: Vec<(String, String)> = vec![];
@@ -140,31 +140,34 @@ fn populate_server_names<T: ComponentHandle + NetplayPages + 'static>(weak: slin
        }

        let response = task.await;
-        if let Ok(response) = response
+        let public_servers = if let Ok(response) = response
            && let Ok(servers) = response.json::<Vec<String>>().await
        {
-            weak.upgrade_in_event_loop(move |handle| {
-                let server_names: slint::VecModel<slint::SharedString> = slint::VecModel::default();
-                let server_urls: slint::VecModel<slint::SharedString> = slint::VecModel::default();
-                for local_server in local_servers {
-                    server_names.push(local_server.0.into());
-                    server_urls.push(local_server.1.into());
-                }
-                for server in servers {
-                    server_names.push(server.clone().into());
-                    server_urls.push(format!("dispatcher:{server}").into());
-                }
-                server_names.push("Custom".into());
-                handle.refresh_sessions();
-                let server_names_model: std::rc::Rc<slint::VecModel<slint::SharedString>> =
-                    std::rc::Rc::new(server_names);
-                let server_urls_model: std::rc::Rc<slint::VecModel<slint::SharedString>> =
-                    std::rc::Rc::new(server_urls);
-                handle.set_server_names(slint::ModelRc::from(server_names_model));
-                handle.set_server_urls(slint::ModelRc::from(server_urls_model));
-            })
-            .unwrap();
-        }
+            servers
+        } else {
+            vec![]
+        };
+        weak.upgrade_in_event_loop(move |handle| {
+            let server_names: slint::VecModel<slint::SharedString> = slint::VecModel::default();
+            let server_urls: slint::VecModel<slint::SharedString> = slint::VecModel::default();
+            for local_server in local_servers {
+                server_names.push(local_server.0.into());
+                server_urls.push(local_server.1.into());
+            }
+            for server in public_servers {
+                server_names.push(server.clone().into());
+                server_urls.push(format!("dispatcher:{server}").into());
+            }
+            server_names.push("Custom".into());
+            handle.refresh_sessions();
+            let server_names_model: std::rc::Rc<slint::VecModel<slint::SharedString>> =
+                std::rc::Rc::new(server_names);
+            let server_urls_model: std::rc::Rc<slint::VecModel<slint::SharedString>> =
+                std::rc::Rc::new(server_urls);
+            handle.set_server_names(slint::ModelRc::from(server_names_model));
+            handle.set_server_urls(slint::ModelRc::from(server_urls_model));
+        })
+        .unwrap();
    });
 }

@@ -296,7 +299,7 @@ pub fn setup_create_window(
                let task = reqwest::Client::new()
                    .get("https://dispatch.gopher64.com/createServer")
                    .query(&[("region", server_url.strip_prefix("dispatcher:").unwrap())])
-                    .header("netplay-id", EMU_NAME)
+                    .header("netplay-id", env!("NETPLAY_ID"))
                    .send();
                let netplay_read_sender = netplay_read_sender.clone();
                let netplay_write_receiver = netplay_write_receiver.resubscribe();
@@ -448,7 +451,7 @@ fn show_netplay_error(message: String) {
 fn update_sessions(weak: slint::Weak<NetplayJoin>) {
    let task = reqwest::Client::new()
        .get("https://dispatch.gopher64.com/getServers")
-        .header("netplay-id", EMU_NAME)
+        .header("netplay-id", env!("NETPLAY_ID"))
        .send();
    tokio::spawn(async move {
        let mut dispatcher_servers = std::collections::HashMap::new();
@@ -491,6 +494,7 @@ fn update_sessions(weak: slint::Weak<NetplayJoin>) {
            tokio::spawn(async move {
                let mut sessions = vec![];
                let mut room_urls = vec![];
+                let mut room_ports = vec![];
                for (server_name, server_url) in servers.iter() {
                    if let Ok(Ok((socket, _response))) = tokio::time::timeout(
                        std::time::Duration::from_secs(2),
@@ -533,6 +537,7 @@ fn update_sessions(weak: slint::Weak<NetplayJoin>) {
                            for room in rooms {
                                let mut session = vec![];
                                room_urls.push(server_url.into());
+                                room_ports.push(room.port.unwrap());

                                session.push(slint::StandardListViewItem::from(
                                    slint::SharedString::from(server_name),
@@ -585,6 +590,11 @@ fn update_sessions(weak: slint::Weak<NetplayJoin>) {
                            std::rc::Rc::new(room_urls_vec);
                        handle.set_room_urls(slint::ModelRc::from(room_urls_model));

+                        let room_ports_vec = slint::VecModel::from(room_ports.to_vec());
+                        let room_ports_model: std::rc::Rc<slint::VecModel<i32>> =
+                            std::rc::Rc::new(room_ports_vec);
+                        handle.set_room_ports(slint::ModelRc::from(room_ports_model));
+
                        handle.set_current_session(-1);
                        handle.set_pending_refresh(false);
                    })
@@ -732,7 +742,7 @@ fn join_session(
    player_name: String,
    game_hash: String,
    password: String,
-    room_name: String,
+    room_port: i32,
    fullscreen: bool,
    weak_app: slint::Weak<AppWindow>,
    weak: slint::Weak<NetplayJoin>,
@@ -740,73 +750,26 @@ fn join_session(
    tokio::spawn(async move {
        let now_utc = chrono::Utc::now().timestamp_millis().to_string();
        let hasher = Sha256::new().chain_update(&now_utc).chain_update(EMU_NAME);
-        let request_rooms = NetplayMessage {
-            message_type: "request_get_rooms".to_string(),
-            player_name: None,
-            client_sha: None,
-            netplay_version: Some(NETPLAY_VERSION),
-            player_names: None,
-            emulator: Some(EMU_NAME.to_string()),
-            accept: None,
-            rooms: None,
-            message: None,
-            auth_time: Some(now_utc),
-            auth: Some(format!("{:x}", hasher.finalize())),
-            room: None,
-        };
-
-        netplay_write_sender.send(Some(request_rooms)).unwrap();
-
-        let mut port = 0;
-        match tokio::time::timeout(
-            std::time::Duration::from_secs(2),
-            netplay_read_receiver.recv(),
-        )
-        .await
-        {
-            Ok(Ok(message)) => {
-                if message.message_type == "reply_get_rooms"
-                    && message.accept.unwrap() == 0
-                    && let Some(rooms) = message.rooms
-                {
-                    for room in rooms {
-                        if room.room_name.unwrap() == room_name {
-                            port = room.port.unwrap_or(0);
-                        }
-                    }
-                }
-            }
-            Ok(Err(err)) => {
-                panic!("netplay_read_receiver error: {err}");
-            }
-            Err(_) => {
-                weak.upgrade_in_event_loop(move |handle| {
-                    handle.set_pending_session(false);
-                    show_netplay_error("Server did not respond".to_string());
-                })
-                .unwrap();
-            }
-        }

        let join_room = NetplayMessage {
            message_type: "request_join_room".to_string(),
            player_name: Some(player_name),
            client_sha: Some(env!("GIT_HASH").to_string()),
-            netplay_version: None,
-            emulator: None,
+            netplay_version: Some(NETPLAY_VERSION),
+            emulator: Some(EMU_NAME.to_string()),
            accept: None,
            message: None,
            rooms: None,
-            auth_time: None,
            player_names: None,
-            auth: None,
+            auth_time: Some(now_utc),
+            auth: Some(format!("{:x}", hasher.finalize())),
            room: Some(NetplayRoom {
                room_name: None,
                password: Some(password),
                game_name: None,
                md5: Some(game_hash),
                protected: None,
-                port: Some(port),
+                port: Some(room_port),
                features: None,
                buffer_target: None,
            }),
@@ -1121,10 +1084,6 @@ fn setup_wait_window(
                                        disable_expansion_pak: game_settings.disable_expansion_pak,
                                        cheats: game_settings.cheats,
                                    },
-                                    VruChannel {
-                                        vru_window_notifier: None,
-                                        vru_word_receiver: None,
-                                    },
                                    Some(NetplayDevice {
                                        peer_addr: socket_addr,
                                        player_number: player_number as u8,
@@ -1200,7 +1159,7 @@ pub fn setup_join_window(
    });
    let weak = join_window.as_weak();
    join_window.on_join_session(
-        move |player_name, game_hash, password, room_url, room_name| {
+        move |player_name, game_hash, password, room_url, room_port| {
            let _ = netplay_write_sender.send(None); // close current websocket if any
            manage_websocket(
                room_url.to_string(),
@@ -1215,7 +1174,7 @@ pub fn setup_join_window(
                player_name.to_string(),
                game_hash.to_string(),
                password.to_string(),
-                room_name.to_string(),
+                room_port,
                fullscreen,
                weak_app.clone(),
                weak.clone(),
@@ -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)]
@@ -354,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
@@ -374,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;
    }
@@ -389,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();
+    });
 }
@@ -53,10 +53,6 @@ fn upload_rom(
                disable_expansion_pak: handle.get_disable_expansion_pak(),
                cheats: std::collections::HashMap::new(), // will be filled in later
            },
-            ui::gui::VruChannel {
-                vru_window_notifier: None,
-                vru_word_receiver: None,
-            },
            None,
            ui::Usb {
                usb_tx: Some(usb_tx),
@@ -93,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() }
 }
@@ -130,9 +133,21 @@ 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 mut callback = unsafe { rdp_check_callback() };
+    let callback = unsafe { rdp_check_callback() };
    device.cpu.running = callback.emu_running;
    if device.netplay.is_none() {
        if callback.save_state {
@@ -144,11 +159,6 @@ pub fn check_callback(device: &mut device::Device) -> bool {
            speed_limiter_toggled = true;
            device.vi.enable_speed_limiter = callback.enable_speedlimiter;
        }
-        while callback.paused && !callback.frame_advance {
-            std::thread::sleep(std::time::Duration::from_secs_f64(1.0 / 60.0));
-            unsafe { sdl3_sys::events::SDL_PumpEvents() };
-            callback = unsafe { rdp_check_callback() };
-        }
    }

    if device.ui.storage.save_state_slot != callback.save_state_slot {
@@ -169,7 +179,7 @@ pub fn check_callback(device: &mut device::Device) -> bool {
    } 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) {
@@ -182,6 +192,10 @@ 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()) };
 }
@@ -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	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