cache apt packages in github workflow (#194)

* use TCP_RECEIVE_SAVE_WITH_SIZE for netplay

* more

* more

* more

.github/workflows/build.yml

@@ -11,11 +11,15 @@ env:
 
 jobs:
   build-linux:
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
       matrix:
-        target: [x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu]
+        include:
+          - os: ubuntu-24.04
+            target: x86_64-unknown-linux-gnu
+          - os: ubuntu-24.04-arm
+            target: aarch64-unknown-linux-gnu
     steps:
       - uses: actions/checkout@v4
         with:
@@ -26,86 +30,16 @@ jobs:
           rustflags: ""
       - name: Install SDL Dependencies
         # https://wiki.libsdl.org/SDL3/README/linux#build-dependencies
-        if: matrix.target == 'aarch64-unknown-linux-gnu'
-        run: |
-          cat <<EOF > deb822sources
-          Types: deb
-          URIs: http://archive.ubuntu.com/ubuntu/
-          Suites: noble
-          Components: main multiverse universe
-          Architectures: amd64
-
-          Types: deb
-          URIs: http://security.ubuntu.com/ubuntu/
-          Suites: noble-security
-          Components: main multiverse universe
-          Architectures: amd64
-
-          Types: deb
-          URIs: http://archive.ubuntu.com/ubuntu/
-          Suites: noble-updates
-          Components: main multiverse universe
-          Architectures: amd64
-
-          Types: deb
-          URIs: http://archive.ubuntu.com/ubuntu/
-          Suites: noble-backports
-          Components: main multiverse universe
-          Architectures: amd64
-
-          Types: deb
-          URIs: http://ports.ubuntu.com/
-          Suites: noble
-          Components: main multiverse universe
-          Architectures: arm64
-
-          Types: deb
-          URIs: http://ports.ubuntu.com/
-          Suites: noble-security
-          Components: main multiverse universe
-          Architectures: arm64
-
-          Types: deb
-          URIs: http://ports.ubuntu.com/
-          Suites: noble-updates
-          Components: main multiverse universe
-          Architectures: arm64
-
-          Types: deb
-          URIs: http://ports.ubuntu.com/
-          Suites: noble-backports
-          Components: main multiverse universe
-          Architectures: arm64
-          EOF
-
-          sudo mv deb822sources /etc/apt/sources.list.d/ubuntu.sources
-          sudo dpkg --add-architecture arm64
-          sudo apt-get update
-          sudo apt-get -y dist-upgrade
-          sudo apt-get -y install aptitude
-          sudo aptitude -y install build-essential:arm64 git:arm64 make:arm64 \
-          pkg-config:arm64 cmake:arm64 ninja-build:arm64 gnome-desktop-testing:arm64 libasound2-dev:arm64 libpulse-dev:arm64 \
-          libaudio-dev:arm64 libjack-dev:arm64 libsndio-dev:arm64 libx11-dev:arm64 libxext-dev:arm64 \
-          libxrandr-dev:arm64 libxcursor-dev:arm64 libxfixes-dev:arm64 libxi-dev:arm64 libxss-dev:arm64 \
-          libxkbcommon-dev:arm64 libdrm-dev:arm64 libgbm-dev:arm64 libgl1-mesa-dev:arm64 libgles2-mesa-dev:arm64 \
-          libegl1-mesa-dev:arm64 libdbus-1-dev:arm64 libibus-1.0-dev:arm64 libudev-dev:arm64 fcitx-libs-dev:arm64 \
-          libpipewire-0.3-dev:arm64 libwayland-dev:arm64 libdecor-0-dev:arm64 liburing-dev:arm64 g++-aarch64-linux-gnu
-      - name: Install SDL Dependencies
-        # https://wiki.libsdl.org/SDL3/README/linux#build-dependencies
-        if: matrix.target == 'x86_64-unknown-linux-gnu'
-        run: |
-          sudo apt-get update
-          sudo apt-get -y dist-upgrade
-          sudo apt-get -y install build-essential git make \
-          pkg-config cmake ninja-build gnome-desktop-testing libasound2-dev libpulse-dev \
-          libaudio-dev libjack-dev libsndio-dev libx11-dev libxext-dev \
-          libxrandr-dev libxcursor-dev libxfixes-dev libxi-dev libxss-dev \
-          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
-      - name: Set aarch64 linker
-        if: matrix.target == 'aarch64-unknown-linux-gnu'
-        run: echo "CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc" >> $GITHUB_ENV
+        uses: awalsh128/cache-apt-pkgs-action@latest
+        with:
+          packages: build-essential git make \
+            pkg-config cmake ninja-build gnome-desktop-testing libasound2-dev libpulse-dev \
+            libaudio-dev libjack-dev libsndio-dev libx11-dev libxext-dev \
+            libxrandr-dev libxcursor-dev libxfixes-dev libxi-dev libxss-dev \
+            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
+          version: 1.0
       - name: Build
         run: |
           cargo build --release -v --target=${{ matrix.target }}
@@ -139,7 +73,7 @@ jobs:
           path: target/${{ matrix.target }}/release/gopher64.exe
 
   build-macos:
-    runs-on: macos-latest
+    runs-on: macos-14
     strategy:
       fail-fast: false
       matrix:

.github/workflows/lint.yml

@@ -21,15 +21,16 @@ jobs:
           components: clippy, rustfmt
       - name: Install SDL Dependencies
         # https://wiki.libsdl.org/SDL3/README/linux#build-dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get -y install build-essential git make \
-          pkg-config cmake ninja-build gnome-desktop-testing libasound2-dev libpulse-dev \
-          libaudio-dev libjack-dev libsndio-dev libx11-dev libxext-dev \
-          libxrandr-dev libxcursor-dev libxfixes-dev libxi-dev libxss-dev \
-          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
+        uses: awalsh128/cache-apt-pkgs-action@latest
+        with:
+          packages: build-essential git make \
+            pkg-config cmake ninja-build gnome-desktop-testing libasound2-dev libpulse-dev \
+            libaudio-dev libjack-dev libsndio-dev libx11-dev libxext-dev \
+            libxrandr-dev libxcursor-dev libxfixes-dev libxi-dev libxss-dev \
+            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
+          version: 1.0
       - name: Rustfmt Check
         uses: actions-rust-lang/rustfmt@v1
       - name: Lint

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "gopher64"
-version = "0.1.22"
+version = "0.1.24"
 edition = "2021"
 rust-version = "1.82"
 
@@ -17,25 +17,21 @@ serde_json = "1.0"
 eframe = "0.30"
 sha2 = "0.10"
 rusttype = "0.9"
-tokio = { version = "1.43", features = ["rt-multi-thread", "macros"] }
 sdl3-sys = { version = "0.4", features = ["build-from-source-static"] }
+rfd = "0.15"
 spin_sleep = "1.3"
 encoding_rs = "0.8"
 mimalloc = "0.1"
 regex = "1.11"
 tungstenite = "0.26"
 socket2 = "0.5"
+postcard = { version = "1.1", features = ["use-std"] }
 clap = { version = "4.4", features = ["derive"] }
 
 [dependencies.reqwest]
 version = "0.12"
 default-features = false
-features = ["http2","rustls-tls","charset","json"]
-
-[dependencies.rfd]
-version = "0.15"
-default-features = false
-features = ["xdg-portal","tokio"]
+features = ["http2","rustls-tls","charset","json","blocking"]
 
 [build-dependencies]
 winres = "0.1"

build.rs

@@ -109,7 +109,7 @@ fn main() {
 
     if arch == "aarch64" {
         let simd_bindings = bindgen::Builder::default()
-            .header("src/compat/sse2neon.h")
+            .header("src/compat/sse2neon/v1.8.0/sse2neon.h")
             .allowlist_function("_mm_setzero_si128")
             .allowlist_function("_mm_set_epi8")
             .allowlist_function("_mm_movemask_epi8")

parallel-rdp/interface.cpp

@@ -3,6 +3,7 @@
 #include "rdp_device.hpp"
 #include "interface.hpp"
 #include "spirv.hpp"
+#include <SDL3/SDL_vulkan.h>
 
 using namespace Vulkan;
 
@@ -175,7 +176,7 @@ void rdp_init(void *_window, GFX_INFO _gfx_info, bool _upscale, bool _integer_sc
 	wsi->set_present_mode(window_vsync ? PresentMode::SyncToVBlank : PresentMode::UnlockedMaybeTear);
 	wsi->set_backbuffer_srgb(false);
 	Context::SystemHandles handles = {};
-	if (!::Vulkan::Context::init_loader(nullptr))
+	if (!::Vulkan::Context::init_loader((PFN_vkGetInstanceProcAddr)SDL_Vulkan_GetVkGetInstanceProcAddr()))
 	{
 		rdp_close();
 	}

src/compat/aarch64.c

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

src/device.rs

@@ -47,12 +47,7 @@ pub mod tlb;
 pub mod unmapped;
 pub mod vi;
 
-pub fn run_game(
-    rom_contents: Vec<u8>,
-    data_dir: std::path::PathBuf,
-    device: &mut Device,
-    fullscreen: bool,
-) {
+pub fn run_game(rom_contents: Vec<u8>, device: &mut Device, fullscreen: bool) {
     cart_rom::init(device, rom_contents); // cart needs to come before rdram
 
     // rdram pointer is shared with parallel-rdp
@@ -73,7 +68,7 @@ pub fn run_game(
     vi::init(device);
     cpu::init(device);
 
-    ui::storage::init(&mut device.ui, data_dir);
+    ui::storage::init(&mut device.ui);
     ui::storage::load_saves(&mut device.ui, &mut device.netplay);
     cart_rom::load_rom_save(device);
 
@@ -184,7 +179,7 @@ pub struct Device {
 }
 
 impl Device {
-    pub fn new(config_dir: std::path::PathBuf) -> Device {
+    pub fn new() -> Device {
         let mut byte_swap: usize = 0;
         let test: [u8; 4] = [1, 2, 3, 4];
         // if the host computer is little endian, that means the RDRAM will be stored as little endian
@@ -194,7 +189,7 @@ impl Device {
         }
         Device {
             netplay: None,
-            ui: ui::Ui::new(config_dir),
+            ui: ui::Ui::new(),
             byte_swap,
             cpu: cpu::Cpu {
                 cop0: cop0::Cop0 {

src/device/cart_rom.rs

@@ -85,9 +85,8 @@ pub fn dma_read(
                 device.rdram.mem[(dram_addr + i) as usize ^ device.byte_swap];
 
             device.ui.saves.romsave.0.insert(
-                (cart_addr + i).to_string(),
-                serde_json::to_value(device.rdram.mem[(dram_addr + i) as usize ^ device.byte_swap])
-                    .unwrap(),
+                cart_addr + i,
+                device.rdram.mem[(dram_addr + i) as usize ^ device.byte_swap],
             );
         }
     }
@@ -139,8 +138,7 @@ pub fn load_rom_save(device: &mut device::Device) {
         return;
     }
     for (key, value) in device.ui.saves.romsave.0.iter() {
-        device.cart.rom[key.parse::<usize>().unwrap()] =
-            serde_json::from_value(value.clone()).unwrap()
+        device.cart.rom[*key as usize] = *value
     }
 }
 

src/device/controller/vru.rs

@@ -26,8 +26,8 @@ pub struct Vru {
     pub words: Vec<String>,
     pub talking: bool,
     pub word_mappings: HashMap<String, String>,
-    pub window_notifier: Option<tokio::sync::mpsc::Sender<Vec<String>>>,
-    pub word_receiver: Option<tokio::sync::mpsc::Receiver<String>>,
+    pub window_notifier: Option<std::sync::mpsc::Sender<Vec<String>>>,
+    pub word_receiver: Option<std::sync::mpsc::Receiver<String>>,
     pub gui_ctx: Option<egui::Context>,
 }
 
@@ -187,7 +187,7 @@ pub fn process(device: &mut device::Device, channel: usize) {
                 ui::vru::prompt_for_match(
                     &device.vru.words,
                     device.vru.window_notifier.as_ref().unwrap(),
-                    device.vru.word_receiver.as_mut().unwrap(),
+                    device.vru.word_receiver.as_ref().unwrap(),
                     device.vru.gui_ctx.as_ref().unwrap(),
                 )
             } else {
@@ -288,10 +288,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("03A50024000303CF00A80003035D001200F900EA"),
             String::from("pikachu"),
         ),
-        (
-            String::from("040801740024"),
-            String::from("hey!"),
-        ),
+        (String::from("040801740024"), String::from("hey!")),
         (
             String::from("03CF00C603360405000F0234"),
             String::from("come-here"),
@@ -324,10 +321,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("02E2006903FC000303B402E2018F"),
             String::from("lets-play"),
         ),
-        (
-            String::from("040B00C002EB0213"),
-            String::from("hello"),
-        ),
+        (String::from("040B00C002EB0213"), String::from("hello")),
         (
             String::from("043B0213000303AB00A5034803FC006903FC00A503270024"),
             String::from("open-sesame"),
@@ -356,14 +350,8 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("042F01AD033603FC012602F10024"),
             String::from("im-sorry"),
         ),
-        (
-            String::from("03FC023A0024"),
-            String::from("sorry"),
-        ),
-        (
-            String::from("03FC012602F10024"),
-            String::from("sorry"),
-        ),
+        (String::from("03FC023A0024"), String::from("sorry")),
+        (String::from("03FC012602F10024"), String::from("sorry")),
         (
             String::from("042F01B00003036000ED03DB030C00EA"),
             String::from("i-choose-you"),
@@ -392,10 +380,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("03A50024000303D8000303CF00C9"),
             String::from("pikka"),
         ),
-        (
-            String::from("03A50024000303CF00A8"),
-            String::from("pika"),
-        ),
+        (String::from("03A50024000303CF00A8"), String::from("pika")),
         (
             String::from("03A50024000303CF00A8000303A50024000303CF00A8"),
             String::from("pikapika"),
@@ -440,10 +425,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("03F600C60348000603870234"),
             String::from("thunder"),
         ),
-        (
-            String::from("03F600C6033F0234"),
-            String::from("thunder"),
-        ),
+        (String::from("03F600C6033F0234"), String::from("thunder")),
         (
             String::from("0432009F02E20066000303D8000303C602F10045000303D802F40087000303C6"),
             String::from("electric-rat"),
@@ -489,7 +471,9 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("boing-boing"),
         ),
         (
-            String::from("043801290348000303C000ED036C00A5033C0066000303D803FC000303C603FC000303BA018F00060366"),
+            String::from(
+                "043801290348000303C000ED036C00A5033C0066000303D803FC000303C603FC000303BA018F00060366",
+            ),
             String::from("on-to-the-next-stage!"),
         ),
         (
@@ -516,10 +500,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("039F020A02EE0006038700A5033C0087000303AB009F02EE"),
             String::from("golden-apple"),
         ),
-        (
-            String::from("03A5002400030360"),
-            String::from("peach"),
-        ),
+        (String::from("03A5002400030360"), String::from("peach")),
         (
             String::from("03FC000303C602FD012C00060372029D0024"),
             String::from("strawberry"),
@@ -556,10 +537,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("032101A702EE00060390040B02340006037E"),
             String::from("wild-herb"),
         ),
-        (
-            String::from("03D502D60348"),
-            String::from("corn"),
-        ),
+        (String::from("03D502D60348"), String::from("corn")),
         (
             String::from("03B1014D000303B4000303D502D60348"),
             String::from("popcorn"),
@@ -592,18 +570,12 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("03CC008102F700A8000303C6"),
             String::from("carrot"),
         ),
-        (
-            String::from("03CC02A300A8000303C6"),
-            String::from("carrot"),
-        ),
+        (String::from("03CC02A300A8000303C6"), String::from("carrot")),
         (
             String::from("043200C60339030900A50348"),
             String::from("onion"),
         ),
-        (
-            String::from("043200A5033F00A50348"),
-            String::from("onion"),
-        ),
+        (String::from("043200A5033F00A50348"), String::from("onion")),
         (
             String::from("043501080339030900A50348"),
             String::from("onion"),
@@ -621,7 +593,9 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("sweet-potato"),
         ),
         (
-            String::from("0411014D000303C603FC03150024000303C6000303AB00C9000303BA018F0006038D0213"),
+            String::from(
+                "0411014D000303C603FC03150024000303C6000303AB00C9000303BA018F0006038D0213",
+            ),
             String::from("hot-sweet-potato"),
         ),
         (
@@ -732,10 +706,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("03CF00C9000303B4000303CC018F000303D8"),
             String::from("cupcake"),
         ),
-        (
-            String::from("03840174002703DB0024"),
-            String::from("daisy"),
-        ),
+        (String::from("03840174002703DB0024"), String::from("daisy")),
         (
             String::from("03A50045000303C000E70339030900A8"),
             String::from("petunia"),
@@ -768,10 +739,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("03FC00C6034803F002EB01DD0234"),
             String::from("sunflower"),
         ),
-        (
-            String::from("02DF003C02DF0024"),
-            String::from("lily"),
-        ),
+        (String::from("02DF003C02DF0024"), String::from("lily")),
         (
             String::from("02FD021603DE0006037500C900060390"),
             String::from("rose-bud"),
@@ -852,10 +820,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("03D5014D000303AB0234000303D501CE0348"),
             String::from("copper-coin"),
         ),
-        (
-            String::from("02FA00EA0006036F0024"),
-            String::from("ruby"),
-        ),
+        (String::from("02FA00EA0006036F0024"), String::from("ruby")),
         (
             String::from("03FC008A03F001AA0300"),
             String::from("sapphire"),
@@ -904,10 +869,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("037502340006039003F00069036C0234"),
             String::from("bird-feather"),
         ),
-        (
-            String::from("037B020A02EE000303C6"),
-            String::from("bolt"),
-        ),
+        (String::from("037B020A02EE000303C6"), String::from("bolt")),
         (
             String::from("032A0087000603A203390045000303C6"),
             String::from("magnet"),
@@ -920,10 +882,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("0333025500060375009F02EE"),
             String::from("marble"),
         ),
-        (
-            String::from("03D802F4018F000303C6"),
-            String::from("crate"),
-        ),
+        (String::from("03D802F4018F000303C6"), String::from("crate")),
         (
             String::from("03D50255000603900006037B02D9000603900006037B014D000303D803FC"),
             String::from("cardboard-box"),
@@ -936,10 +895,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("043B021603EA022804050297"),
             String::from("over-here"),
         ),
-        (
-            String::from("040B009F02EB0213"),
-            String::from("hello"),
-        ),
+        (String::from("040B009F02EB0213"), String::from("hello")),
         (
             String::from("039C010B00060390034501950024000303C6"),
             String::from("good-night"),
@@ -972,18 +928,9 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("036C0087000303C603FC03F001AD0348"),
             String::from("thats-fine"),
         ),
-        (
-            String::from("043B0213000303CC01740024"),
-            String::from("ok"),
-        ),
-        (
-            String::from("04020276"),
-            String::from("sure"),
-        ),
-        (
-            String::from("02FD01B0000303C6"),
-            String::from("right"),
-        ),
+        (String::from("043B0213000303CC01740024"), String::from("ok")),
+        (String::from("04020276"), String::from("sure")),
+        (String::from("02FD01B0000303C6"), String::from("right")),
         (
             String::from("02E2006903FC0006038A00ED036C0087000303C6"),
             String::from("lets-do-that"),
@@ -1012,18 +959,12 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("03CF00C9000303BD00A8000303C301F2000303C6"),
             String::from("cut-it-out"),
         ),
-        (
-            String::from("03450213"),
-            String::from("no"),
-        ),
+        (String::from("03450213"), String::from("no")),
         (
             String::from("0318018F0006038700A80006039F0213"),
             String::from("way-to-go"),
         ),
-        (
-            String::from("03F002EB01DD0234"),
-            String::from("flower"),
-        ),
+        (String::from("03F002EB01DD0234"), String::from("flower")),
         (
             String::from("038400840348000303C603FC"),
             String::from("dance"),
@@ -1104,14 +1045,8 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("03F90009030C00E102E2018F000303BD0234"),
             String::from("see-you-later"),
         ),
-        (
-            String::from("03F90009030C00EA"),
-            String::from("see-you"),
-        ),
-        (
-            String::from("037B01B0"),
-            String::from("bye"),
-        ),
+        (String::from("03F90009030C00EA"), String::from("see-you")),
+        (String::from("037B01B0"), String::from("bye")),
         (
             String::from("0411031B00A8000303BD0219030900A80006038A00CF0042035A"),
             String::from("what-are-you-doing?"),
@@ -1164,10 +1099,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("04290045000303C603FC021603EA0237036C02B8"),
             String::from("its-over-there"),
         ),
-        (
-            String::from("02DF003C02DF0024"),
-            String::from("lily"),
-        ),
+        (String::from("02DF003C02DF0024"), String::from("lily")),
         (
             String::from("03FC00C6034803F002EB01DD0234"),
             String::from("sunflower"),
@@ -1188,10 +1120,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("0438012C0006038100480402"),
             String::from("oddish"),
         ),
-        (
-            String::from("03A202E800E70336"),
-            String::from("gloom"),
-        ),
+        (String::from("03A202E800E70336"), String::from("gloom")),
         (
             String::from("03EA01A702EE000303B402E800E70336"),
             String::from("vileplume"),
@@ -1200,14 +1129,8 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("042F01AD033603FC02BE0024"),
             String::from("im-sorry"),
         ),
-        (
-            String::from("03FC02BE0024"),
-            String::from("sorry"),
-        ),
-        (
-            String::from("03CC0084033F00A50348"),
-            String::from("cannon"),
-        ),
+        (String::from("03FC02BE0024"), String::from("sorry")),
+        (String::from("03CC0084033F00A50348"), String::from("cannon")),
         (
             String::from("03810045000603930045000303C301F2000303C6"),
             String::from("dig-it-out"),
@@ -1216,18 +1139,9 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("03810045000603A2036C017A0234"),
             String::from("dig-there"),
         ),
-        (
-            String::from("03810045000603A2"),
-            String::from("dig"),
-        ),
-        (
-            String::from("03AE010202EE"),
-            String::from("pull"),
-        ),
-        (
-            String::from("033F00C9000303C6"),
-            String::from("nut"),
-        ),
+        (String::from("03810045000603A2"), String::from("dig")),
+        (String::from("03AE010202EE"), String::from("pull")),
+        (String::from("033F00C9000303C6"), String::from("nut")),
         (
             String::from("03780108033C0084033F00C9"),
             String::from("banana"),
@@ -1244,10 +1158,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("0372029D002400060390000303C602F4006903E40234"),
             String::from("buried-treasure"),
         ),
-        (
-            String::from("0408005D02EB0213"),
-            String::from("hello"),
-        ),
+        (String::from("0408005D02EB0213"), String::from("hello")),
         (
             String::from("042F01A702E500CC03E7030C00EA"),
             String::from("i-love-you"),
@@ -1312,26 +1223,17 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("041101290348000303BD0234"),
             String::from("haunter"),
         ),
-        (
-            String::from("02FD0129035A"),
-            String::from("wrong"),
-        ),
+        (String::from("02FD0129035A"), String::from("wrong")),
         (
             String::from("036C0087000303C603DE02FD0129035A"),
             String::from("thats-wrong"),
         ),
-        (
-            String::from("03D503150045000303C6"),
-            String::from("quit"),
-        ),
+        (String::from("03D503150045000303C6"), String::from("quit")),
         (
             String::from("03CF00C9000303B700450006038D01F2000303C6"),
             String::from("cut-it-out"),
         ),
-        (
-            String::from("03CF00A503270297"),
-            String::from("c-mere"),
-        ),
+        (String::from("03CF00A503270297"), String::from("c-mere")),
         (
             String::from("03CF00A5033604050297"),
             String::from("come-here"),
@@ -1348,26 +1250,17 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("0321012C0003036001F2000303C6"),
             String::from("watch-out"),
         ),
-        (
-            String::from("036C02B8"),
-            String::from("there"),
-        ),
+        (String::from("036C02B8"), String::from("there")),
         (
             String::from("03FC03150042035A034501F2"),
             String::from("swing-now"),
         ),
-        (
-            String::from("03FC03150042035A"),
-            String::from("swing"),
-        ),
+        (String::from("03FC03150042035A"), String::from("swing")),
         (
             String::from("039F020D02FD01B0000303C6"),
             String::from("go-right"),
         ),
-        (
-            String::from("02FD01B0000303C6"),
-            String::from("right"),
-        ),
+        (String::from("02FD01B0000303C6"), String::from("right")),
         (
             String::from("03F00258036C022E02FD01B0000303C6"),
             String::from("farther-right"),
@@ -1376,10 +1269,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("039F020A02E2006903F0000303C6"),
             String::from("go-left"),
         ),
-        (
-            String::from("02E2006903F0000303C6"),
-            String::from("left"),
-        ),
+        (String::from("02E2006903F0000303C6"), String::from("left")),
         (
             String::from("03F00258036C022B02E2006903F0000303C6"),
             String::from("farther-left"),
@@ -1472,10 +1362,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("02DF004803F900420348000303BD00A503270024"),
             String::from("listen-to-me"),
         ),
-        (
-            String::from("03F002FA00EA000303C6"),
-            String::from("fruit"),
-        ),
+        (String::from("03F002FA00EA000303C6"), String::from("fruit")),
         (
             String::from("03450213000303C6000303A8008700060390"),
             String::from("notepad"),
@@ -1500,14 +1387,8 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("0411014D000303C603FC03150024000303B4000303BA018F0006038D0213"),
             String::from("hot-sweet-potato"),
         ),
-        (
-            String::from("03D200E102EE"),
-            String::from("cool"),
-        ),
-        (
-            String::from("03F001AD0348"),
-            String::from("fine"),
-        ),
+        (String::from("03D200E102EE"), String::from("cool")),
+        (String::from("03F001AD0348"), String::from("fine")),
         (
             String::from("0309023703FC0213000303C9030C00EA000303C6"),
             String::from("youre-so-cute"),
@@ -1572,14 +1453,8 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("032A0087000603A2033F00A8000303C6"),
             String::from("magnet"),
         ),
-        (
-            String::from("03D501CE0348"),
-            String::from("coin"),
-        ),
-        (
-            String::from("036600D5009F02EE"),
-            String::from("jewel"),
-        ),
+        (String::from("03D501CE0348"), String::from("coin")),
+        (String::from("036600D5009F02EE"), String::from("jewel")),
         (
             String::from("0333025500060375009F02EE"),
             String::from("marble"),
@@ -1596,10 +1471,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("03D50315004803DE000303C301AD0336"),
             String::from("quiz-time"),
         ),
-        (
-            String::from("03B7002703E70024"),
-            String::from("tv"),
-        ),
+        (String::from("03B7002703E70024"), String::from("tv")),
         (
             String::from("042F01B0000303D503150045000303C6"),
             String::from("i-quit"),
@@ -1616,10 +1488,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("03150024000303CF00A50348000303B402E2018F"),
             String::from("we-can-play"),
         ),
-        (
-            String::from("0372008700060390"),
-            String::from("bad"),
-        ),
+        (String::from("0372008700060390"), String::from("bad")),
         (
             String::from("0345014D000303C90045000303C3012F03F0"),
             String::from("knock-it-off"),
@@ -1636,10 +1505,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("042F01AD03360345014D000303C6000303B402E201740042035A"),
             String::from("im-not-playing"),
         ),
-        (
-            String::from("03D503150045000303C6"),
-            String::from("quit"),
-        ),
+        (String::from("03D503150045000303C6"), String::from("quit")),
         (
             String::from("03FC000303C3014D000303B4036C0087000303C6"),
             String::from("stop-that"),
@@ -1660,10 +1526,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("03D802DF00210348036C0087000303BD00C9000303B4"),
             String::from("clean-that-up"),
         ),
-        (
-            String::from("03B70048040200EA"),
-            String::from("tissue"),
-        ),
+        (String::from("03B70048040200EA"), String::from("tissue")),
         (
             String::from("037500C002EE0006037500AB03FC02D9"),
             String::from("bulbasaur"),
@@ -1768,10 +1631,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("03FC000303A502880213"),
             String::from("spearow"),
         ),
-        (
-            String::from("03ED02880213"),
-            String::from("fearow"),
-        ),
+        (String::from("03ED02880213"), String::from("fearow")),
         (
             String::from("04260024000303CF00A5034803DE"),
             String::from("ekans"),
@@ -1788,10 +1648,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("03A50024000303CF00A80003036000EA"),
             String::from("pikachu"),
         ),
-        (
-            String::from("02FD01B00003036000EA"),
-            String::from("raichu"),
-        ),
+        (String::from("02FD01B00003036000EA"), String::from("raichu")),
         (
             String::from("03FC00840348040202FA00EA"),
             String::from("sandshrew"),
@@ -1884,22 +1741,13 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("0438012C0006038100480402"),
             String::from("oddish"),
         ),
-        (
-            String::from("03A202E800E70336"),
-            String::from("gloom"),
-        ),
+        (String::from("03A202E800E70336"), String::from("gloom")),
         (
             String::from("03EA01A702EE000303B402E800E70336"),
             String::from("vileplume"),
         ),
-        (
-            String::from("03B1024000AB03FC"),
-            String::from("paras"),
-        ),
-        (
-            String::from("03A802A300AB03FC"),
-            String::from("paras"),
-        ),
+        (String::from("03B1024000AB03FC"), String::from("paras")),
+        (String::from("03A802A300AB03FC"), String::from("paras")),
         (
             String::from("03B1024000AB03FC0066000303D8000303C6"),
             String::from("parasect"),
@@ -1920,10 +1768,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("03810045000603A202E500A8000303C6"),
             String::from("diglett"),
         ),
-        (
-            String::from("0327001501F503F6"),
-            String::from("meowth"),
-        ),
+        (String::from("0327001501F503F6"), String::from("meowth")),
         (
             String::from("03AB023703E400A50348"),
             String::from("persian"),
@@ -2024,14 +1869,8 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("03A202F4008A03EA02E50234"),
             String::from("graveler"),
         ),
-        (
-            String::from("039F020A02E500A50336"),
-            String::from("golem"),
-        ),
-        (
-            String::from("039F014402EE0336"),
-            String::from("golem"),
-        ),
+        (String::from("039F020A02E500A50336"), String::from("golem")),
+        (String::from("039F014402EE0336"), String::from("golem")),
         (
             String::from("03B1021003390024000303BD00A8"),
             String::from("ponyta"),
@@ -2060,18 +1899,12 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("032A0087000603A2033F00A8000303C3014A0348"),
             String::from("magneton"),
         ),
-        (
-            String::from("0008"),
-            String::from("farfetch"),
-        ),
+        (String::from("0008"), String::from("farfetch")),
         (
             String::from("038D02130006039002F100150213"),
             String::from("dodrio"),
         ),
-        (
-            String::from("03F9001B02EE"),
-            String::from("seel"),
-        ),
+        (String::from("03F9001B02EE"), String::from("seel")),
         (
             String::from("038A00EA0006039F014A035A"),
             String::from("dewgong"),
@@ -2080,14 +1913,8 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("038A00EA0006039F014A0348"),
             String::from("dewgong"),
         ),
-        (
-            String::from("03A202FD01AD032D0234"),
-            String::from("grimer"),
-        ),
-        (
-            String::from("032D00C9000303D8"),
-            String::from("muk"),
-        ),
+        (String::from("03A202FD01AD032D0234"), String::from("grimer")),
+        (String::from("032D00C9000303D8"), String::from("muk")),
         (
             String::from("0402005D02EE000603870234"),
             String::from("shellder"),
@@ -2100,10 +1927,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("0396008A03FC000303C602DF00"),
             String::from("gastly"),
         ),
-        (
-            String::from("0396008A03FC02DF0024"),
-            String::from("gastly"),
-        ),
+        (String::from("0396008A03FC02DF0024"), String::from("gastly")),
         (
             String::from("041101290348000303BD0234"),
             String::from("haunter"),
@@ -2232,10 +2056,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("03CC018C035A0006039900AB03FC000303D5014A0348"),
             String::from("kangaskhan"),
         ),
-        (
-            String::from("041102DC03F90024"),
-            String::from("horsea"),
-        ),
+        (String::from("041102DC03F90024"), String::from("horsea")),
         (
             String::from("03F900240006039002F700A8"),
             String::from("seadra"),
@@ -2260,10 +2081,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("0327004803FC000303BD0231033301AD0336"),
             String::from("mr.mime"),
         ),
-        (
-            String::from("03FC01B3036C0234"),
-            String::from("scyther"),
-        ),
+        (String::from("03FC01B3036C0234"), String::from("scyther")),
         (
             String::from("03630042035A000303D803FC"),
             String::from("jynx"),
@@ -2280,18 +2098,9 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("032A0087000603A203330255"),
             String::from("magmar"),
         ),
-        (
-            String::from("03A50042034803FC0234"),
-            String::from("pinsir"),
-        ),
-        (
-            String::from("03C3020D02FD012F03FC"),
-            String::from("tauros"),
-        ),
-        (
-            String::from("03C30246021603FC"),
-            String::from("tauros"),
-        ),
+        (String::from("03A50042034803FC0234"), String::from("pinsir")),
+        (String::from("03C3020D02FD012F03FC"), String::from("tauros")),
+        (String::from("03C30246021603FC"), String::from("tauros")),
         (
             String::from("032A0087000603630045000303D50255000303B4"),
             String::from("magikarp"),
@@ -2312,14 +2121,8 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("02E20087000303B402F700AB03FC"),
             String::from("lapras"),
         ),
-        (
-            String::from("03810045000303C30213"),
-            String::from("ditto"),
-        ),
-        (
-            String::from("0426002703E70024"),
-            String::from("eevee"),
-        ),
+        (String::from("03810045000303C30213"), String::from("ditto")),
+        (String::from("0426002703E70024"), String::from("eevee")),
         (
             String::from("03EA018F000303B102BE0015014A0348"),
             String::from("vaporeon"),
@@ -2416,10 +2219,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("0327030C00EA000303C000EA"),
             String::from("mewtwo"),
         ),
-        (
-            String::from("0327030C00EA"),
-            String::from("mew"),
-        ),
+        (String::from("0327030C00EA"), String::from("mew")),
         (
             String::from("03C3014D000303AB00AB03EA000603630045000603A202DF0024000303AB00AB03F0"),
             String::from("top-of-jigglypuff"),
@@ -2456,10 +2256,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("038700C9000603A2000303C602F100150213"),
             String::from("dugtrio"),
         ),
-        (
-            String::from("03A50045000603630024"),
-            String::from("pidgey"),
-        ),
+        (String::from("03A50045000603630024"), String::from("pidgey")),
         (
             String::from("038D02130006038A00DB0213"),
             String::from("doduo"),
@@ -2528,30 +2325,18 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("02E2006903FC000303B402E2018F"),
             String::from("lets-play"),
         ),
-        (
-            String::from("02FD0129035A"),
-            String::from("wrong"),
-        ),
+        (String::from("02FD0129035A"), String::from("wrong")),
         (
             String::from("0372008700060390000303A50024000303CF00A80003036000EA"),
             String::from("bad-pikachu"),
         ),
-        (
-            String::from("0327004803FC"),
-            String::from("miss"),
-        ),
+        (String::from("0327004803FC"), String::from("miss")),
         (
             String::from("038D02100348000303C6000303D5012302DF0045000303C6"),
             String::from("dont-call-it"),
         ),
-        (
-            String::from("041101F503FC"),
-            String::from("house"),
-        ),
-        (
-            String::from("041102100336"),
-            String::from("home"),
-        ),
+        (String::from("041101F503FC"), String::from("house")),
+        (String::from("041102100336"), String::from("home")),
         (
             String::from("03EA00A202F1004500060381000F00C60348"),
             String::from("viridian"),
@@ -2560,10 +2345,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("03EA00A202F1004500060381000F00C6034803F002C400AB03FC000303C6"),
             String::from("viridian-forest"),
         ),
-        (
-            String::from("043B0213000303CF0234"),
-            String::from("ochre"),
-        ),
+        (String::from("043B0213000303CF0234"), String::from("ochre")),
         (
             String::from("043B0213000303CF0225031E010B0006039003DE"),
             String::from("ochre-woods"),
@@ -2604,10 +2386,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("03D502130006037E03ED004803FF0042035A0411020A02EE"),
             String::from("cobalt-fishing-hole"),
         ),
-        (
-            String::from("03D5021603FC000303C6"),
-            String::from("coast"),
-        ),
+        (String::from("03D5021603FC000303C6"), String::from("coast")),
         (
             String::from("03D502130006037B012302EE000303C6000303D5021603FC000303C6"),
             String::from("cobalt-coast"),
@@ -2620,16 +2399,15 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("03BD0231033F00A8000303B4"),
             String::from("turnip"),
         ),
-        (
-            String::from("03BD02310348000303B4"),
-            String::from("turnip"),
-        ),
+        (String::from("03BD02310348000303B4"), String::from("turnip")),
         (
             String::from("03FC03150024000303C6000303AB00A8000303BA018F0006038D0213"),
             String::from("sweet-potato"),
         ),
         (
-            String::from("0411014D000303C603FC03150024000303C6000303AE010B000303BA018F0006038D0213"),
+            String::from(
+                "0411014D000303C603FC03150024000303C6000303AE010B000303BA018F0006038D0213",
+            ),
             String::from("hot-sweet-potato"),
         ),
         (
@@ -2640,18 +2418,12 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("04080084034B00420348036C02B8"),
             String::from("hang-in-there"),
         ),
-        (
-            String::from("03AE010202EE"),
-            String::from("pull"),
-        ),
+        (String::from("03AE010202EE"), String::from("pull")),
         (
             String::from("02F1001B02DF0045000303B700420348"),
             String::from("reel-it-in"),
         ),
-        (
-            String::from("034501F2"),
-            String::from("now"),
-        ),
+        (String::from("034501F2"), String::from("now")),
         (
             String::from("03CC00870003035D0045000303C6"),
             String::from("catch-it"),
@@ -2676,14 +2448,8 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("02F1003C02DF002703F90045000303C6"),
             String::from("release-it"),
         ),
-        (
-            String::from("02E500C6034800030360"),
-            String::from("lunch"),
-        ),
-        (
-            String::from("03FC033C0087000303D8"),
-            String::from("snack"),
-        ),
+        (String::from("02E500C6034800030360"), String::from("lunch")),
+        (String::from("03FC033C0087000303D8"), String::from("snack")),
         (
             String::from("02E2006903F90024000303C6"),
             String::from("lets-eat"),
@@ -2700,10 +2466,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("042F01B0000603930045000303B70045000303C6"),
             String::from("i-get-it"),
         ),
-        (
-            String::from("0411032101B0"),
-            String::from("why?"),
-        ),
+        (String::from("0411032101B0"), String::from("why?")),
         (
             String::from("041101F2000303CF00C60336"),
             String::from("how-come?"),
@@ -2728,10 +2491,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("03FC000303C3014D000303B4036C0087000303C6"),
             String::from("stop-that"),
         ),
-        (
-            String::from("03D503150045000303C6"),
-            String::from("quit"),
-        ),
+        (String::from("03D503150045000303C6"), String::from("quit")),
         (
             String::from("03CF00C9000303B70045000303C301F2000303C6"),
             String::from("cut-it-out"),
@@ -2744,10 +2504,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("02E20066000303C603DE0006039F0213"),
             String::from("lets-go"),
         ),
-        (
-            String::from("031B0225012F03F0"),
-            String::from("we-re-off"),
-        ),
+        (String::from("031B0225012F03F0"), String::from("we-re-off")),
         (
             String::from("03BA008700060393030902190045000303C6"),
             String::from("tag-youre-it"),
@@ -2804,18 +2561,12 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("039F0213000303BD00C6033302460213"),
             String::from("go-tomorrow"),
         ),
-        (
-            String::from("02FD014D000303D8"),
-            String::from("rock"),
-        ),
+        (String::from("02FD014D000303D8"), String::from("rock")),
         (
             String::from("03F9004803DE023703FC"),
             String::from("scissors"),
         ),
-        (
-            String::from("03A8018F000303AB0234"),
-            String::from("paper"),
-        ),
+        (String::from("03A8018F000303AB0234"), String::from("paper")),
         (
             String::from("0381002A000303B10255000303C6"),
             String::from("depart"),
@@ -2872,10 +2623,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("03450213000602E50042032A002A000303C6"),
             String::from("no-limit"),
         ),
-        (
-            String::from("03B7005A0348"),
-            String::from("ten"),
-        ),
+        (String::from("03B7005A0348"), String::from("ten")),
         (
             String::from("03E7002A03F6000303B700090348"),
             String::from("fifteen"),
@@ -2888,18 +2636,12 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("03C30318004B0339038A002403EA019E03EA"),
             String::from("twenty-five"),
         ),
-        (
-            String::from("036C02AC03BA0027"),
-            String::from("thirty"),
-        ),
+        (String::from("036C02AC03BA0027"), String::from("thirty")),
         (
             String::from("036C02AC03BA002703EA019E03EA"),
             String::from("thirty-five"),
         ),
-        (
-            String::from("03EA02D6000603900048"),
-            String::from("forty"),
-        ),
+        (String::from("03EA02D6000603900048"), String::from("forty")),
         (
             String::from("03EA02D600060390004803EA019E03EA"),
             String::from("forty-five"),
@@ -2928,10 +2670,7 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("03FC004B036C00630348000303B7000903EA019E03EA"),
             String::from("seventy-five"),
         ),
-        (
-            String::from("042C018C03B70009"),
-            String::from("eighty"),
-        ),
+        (String::from("042C018C03B70009"), String::from("eighty")),
         (
             String::from("042C018C03B7000903EA019E03EA"),
             String::from("eighty-five"),

src/device/pi.rs

@@ -149,10 +149,15 @@ pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u
                 device.pi.regs[PI_STATUS_REG as usize] = 0
             }
         }
-        PI_BSD_DOM1_LAT_REG | PI_BSD_DOM1_PWD_REG | PI_BSD_DOM1_PGS_REG | PI_BSD_DOM1_RLS_REG
-        | PI_BSD_DOM2_LAT_REG | PI_BSD_DOM2_PWD_REG | PI_BSD_DOM2_PGS_REG | PI_BSD_DOM2_RLS_REG => {
+        PI_BSD_DOM1_LAT_REG | PI_BSD_DOM1_PWD_REG | PI_BSD_DOM2_LAT_REG | PI_BSD_DOM2_PWD_REG => {
             device::memory::masked_write_32(&mut device.pi.regs[reg as usize], value & 0xFF, mask)
         }
+        PI_BSD_DOM1_PGS_REG | PI_BSD_DOM2_PGS_REG => {
+            device::memory::masked_write_32(&mut device.pi.regs[reg as usize], value & 0xF, mask)
+        }
+        PI_BSD_DOM1_RLS_REG | PI_BSD_DOM2_RLS_REG => {
+            device::memory::masked_write_32(&mut device.pi.regs[reg as usize], value & 0x3, mask)
+        }
         _ => device::memory::masked_write_32(&mut device.pi.regs[reg as usize], value, mask),
     }
 }

src/device/rdram.rs

@@ -73,16 +73,17 @@ pub fn read_regs(
     address: u64,
     _access_size: device::memory::AccessSize,
 ) -> u32 {
-    let chip_id = address >> 13 & 3;
+    let chip_id = (address >> 13) & 3;
     let reg = (address & 0x3FF) >> 2;
     match reg as u32 {
         RDRAM_MODE_REG => device.pi.regs[reg as usize] ^ 0xc0c0c0c0,
+        0x80 => 0x00000000, //Row, needed for libdragon
         _ => device.rdram.regs[chip_id as usize][reg as usize],
     }
 }
 
 pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u32) {
-    let chip_id = address >> 13 & 3;
+    let chip_id = (address >> 13) & 3;
     let reg = (address & 0x3FF) >> 2;
     device::memory::masked_write_32(
         &mut device.rdram.regs[chip_id as usize][reg as usize],

src/device/rsp_su_instructions.rs

@@ -721,7 +721,7 @@ pub fn lsv(device: &mut device::Device, opcode: u32) {
         modify_vpr16(
             &mut device.rsp.cpu.vpr[rt(opcode) as usize],
             element / 2,
-            (device.rsp.mem[(address & 0xFFF) as usize] as u16) << 8
+            ((device.rsp.mem[(address & 0xFFF) as usize] as u16) << 8)
                 | (device.rsp.mem[((address + 1) & 0xFFF) as usize] as u16),
         );
     } else {

src/main.rs

@@ -64,37 +64,22 @@ struct Args {
     clear_input_bindings: bool,
 }
 
-#[tokio::main]
-async fn main() {
-    let exe_path = std::env::current_exe().unwrap();
-    let portable_dir = exe_path.parent();
-    let portable = portable_dir.unwrap().join("portable.txt").exists();
-    let config_dir;
-    let cache_dir;
-    let data_dir;
-    if portable {
-        config_dir = portable_dir.unwrap().join("portable_data").join("config");
-        cache_dir = portable_dir.unwrap().join("portable_data").join("cache");
-        data_dir = portable_dir.unwrap().join("portable_data").join("data");
-    } else {
-        config_dir = dirs::config_dir().unwrap().join("gopher64");
-        cache_dir = dirs::cache_dir().unwrap().join("gopher64");
-        data_dir = dirs::data_dir().unwrap().join("gopher64");
-    };
+fn main() {
+    let dirs = ui::get_dirs();
 
-    let mut result = std::fs::create_dir_all(config_dir.clone());
+    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(cache_dir.clone());
+    result = std::fs::create_dir_all(dirs.cache_dir.clone());
     if result.is_err() {
         panic!("could not create cache dir: {}", result.err().unwrap())
     }
-    result = std::fs::create_dir_all(data_dir.clone().join("saves"));
+    result = std::fs::create_dir_all(dirs.data_dir.join("saves"));
     if result.is_err() {
         panic!("could not create data dir: {}", result.err().unwrap())
     }
-    let running_file = cache_dir.join("game_running");
+    let running_file = dirs.cache_dir.join("game_running");
     if running_file.exists() {
         result = std::fs::remove_file(running_file);
         if result.is_err() {
@@ -106,7 +91,7 @@ async fn main() {
     let args_as_strings: Vec<String> = std::env::args().collect();
     let args_count = args_as_strings.len();
     if args_count > 1 {
-        let mut device = device::Device::new(config_dir);
+        let mut device = device::Device::new();
 
         if args.clear_input_bindings {
             ui::input::clear_bindings(&mut device.ui);
@@ -166,7 +151,7 @@ async fn main() {
                 println!("Could not read rom file");
                 return;
             }
-            device::run_game(rom_contents, data_dir, &mut device, args.fullscreen);
+            device::run_game(rom_contents, &mut device, args.fullscreen);
         }
     } else {
         let options = eframe::NativeOptions {
@@ -178,12 +163,22 @@ async fn main() {
                 ),
             ..Default::default()
         };
+
+        let controllers_paths;
+        let controller_names;
+        {
+            let game_ui = ui::Ui::new();
+            controllers_paths = gui::get_controller_paths(&game_ui);
+            controller_names = gui::get_controller_names(&game_ui);
+        }
         eframe::run_native(
             "gopher64",
             options,
             Box::new(|cc| {
                 Ok(Box::new(ui::gui::GopherEguiApp::new(
-                    cc, config_dir, cache_dir, data_dir,
+                    cc,
+                    controllers_paths,
+                    controller_names,
                 )))
             }),
         )

src/netplay.rs

@@ -11,12 +11,13 @@ const UDP_SYNC_DATA: u8 = 4;
 
 //TCP packet formats
 const TCP_SEND_SAVE: u8 = 1;
-const TCP_RECEIVE_SAVE: u8 = 2;
+//const TCP_RECEIVE_SAVE: u8 = 2;
 //const TCP_SEND_SETTINGS: u8 = 3;
 //const TCP_RECEIVE_SETTINGS: u8 = 4;
 const TCP_REGISTER_PLAYER: u8 = 5;
 const TCP_GET_REGISTRATION: u8 = 6;
 const TCP_DISCONNECT_NOTICE: u8 = 7;
+const TCP_RECEIVE_SAVE_WITH_SIZE: u8 = 8;
 
 const CS4: u32 = 32;
 
@@ -29,7 +30,7 @@ pub struct Netplay {
     status: u8,
     buffer_target: u8,
     pub fast_forward: bool,
-    pub error_notifier: tokio::sync::mpsc::Sender<String>,
+    pub error_notifier: std::sync::mpsc::Sender<String>,
     pub gui_ctx: egui::Context,
 }
 
@@ -46,7 +47,7 @@ struct InputEvent {
 }
 
 fn send_error(netplay: &mut Netplay, error: String) {
-    netplay.error_notifier.try_send(error).unwrap();
+    netplay.error_notifier.send(error).unwrap();
 
     netplay.gui_ctx.request_repaint(); // this is so the window pops up right away
 }
@@ -57,19 +58,21 @@ pub fn send_save(netplay: &mut Netplay, save_type: &str, save_data: &[u8], size:
     request.push(0); // null terminate string
     request.extend_from_slice(&(size as u32).to_be_bytes());
 
-    let mut send_data = save_data.to_owned();
-    send_data.resize(size, 0); // pad with zeros if needed
-    request.extend(send_data);
+    if size > 0 {
+        request.extend(save_data.to_owned());
+    }
     netplay.tcp_stream.write_all(&request).unwrap();
 }
 
-pub fn receive_save(netplay: &mut Netplay, save_type: &str, save_data: &mut Vec<u8>, size: usize) {
-    let mut request: Vec<u8> = [TCP_RECEIVE_SAVE].to_vec();
+pub fn receive_save(netplay: &mut Netplay, save_type: &str, save_data: &mut Vec<u8>) {
+    let mut request: Vec<u8> = [TCP_RECEIVE_SAVE_WITH_SIZE].to_vec();
     request.extend_from_slice(save_type.as_bytes());
     request.push(0); // null terminate string
     netplay.tcp_stream.write_all(&request).unwrap();
 
-    let mut response: Vec<u8> = vec![0; size];
+    let mut size: [u8; 4] = [0; 4];
+    netplay.tcp_stream.read_exact(&mut size).unwrap();
+    let mut response: Vec<u8> = vec![0; u32::from_be_bytes(size) as usize];
     netplay.tcp_stream.read_exact(&mut response).unwrap();
     *save_data = response;
 }
@@ -216,7 +219,7 @@ pub fn init(
     mut peer_addr: std::net::SocketAddr,
     session: ui::gui::gui_netplay::NetplayRoom,
     player_number: u8,
-    error_notifier: tokio::sync::mpsc::Sender<String>,
+    error_notifier: std::sync::mpsc::Sender<String>,
     gui_ctx: egui::Context,
 ) -> Netplay {
     peer_addr.set_port(session.port.unwrap() as u16);

src/ui.rs

@@ -6,10 +6,16 @@ pub mod storage;
 pub mod video;
 pub mod vru;
 
+pub struct Dirs {
+    pub config_dir: std::path::PathBuf,
+    pub cache_dir: std::path::PathBuf,
+    pub data_dir: std::path::PathBuf,
+}
+
 pub struct Ui {
+    pub dirs: Dirs,
     pub keyboard_state: *const bool,
     pub controllers: [input::Controllers; 4],
-    pub config_file_path: std::path::PathBuf,
     pub config: config::Config,
     pub save_type: Vec<storage::SaveTypes>,
     pub game_id: String,
@@ -32,26 +38,47 @@ impl Drop for Ui {
             sdl3_sys::stdinc::SDL_free(self.joysticks as *mut std::ffi::c_void);
             sdl3_sys::init::SDL_Quit();
         }
-        write_config(self);
     }
 }
 
-fn write_config(ui: &Ui) {
-    let f = std::fs::File::create(ui.config_file_path.clone()).unwrap();
-    serde_json::to_writer_pretty(f, &ui.config).unwrap();
-}
-
 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) {
-            panic!("Could not initialize SDL subsystem: {}", flag);
+            let err = std::ffi::CStr::from_ptr(sdl3_sys::error::SDL_GetError())
+                .to_str()
+                .unwrap();
+            panic!("Could not initialize SDL subsystem: {}, {}", flag, err);
         }
     }
 }
 
+pub fn get_dirs() -> Dirs {
+    let exe_path = std::env::current_exe().unwrap();
+    let portable_dir = exe_path.parent();
+    let portable = portable_dir.unwrap().join("portable.txt").exists();
+    let config_dir;
+    let cache_dir;
+    let data_dir;
+    if portable {
+        config_dir = portable_dir.unwrap().join("portable_data").join("config");
+        cache_dir = portable_dir.unwrap().join("portable_data").join("cache");
+        data_dir = portable_dir.unwrap().join("portable_data").join("data");
+    } else {
+        config_dir = dirs::config_dir().unwrap().join("gopher64");
+        cache_dir = dirs::cache_dir().unwrap().join("gopher64");
+        data_dir = dirs::data_dir().unwrap().join("gopher64");
+    };
+
+    Dirs {
+        config_dir,
+        cache_dir,
+        data_dir,
+    }
+}
+
 impl Ui {
-    pub fn new(config_dir: std::path::PathBuf) -> Ui {
+    pub fn new() -> Ui {
         sdl_init(sdl3_sys::init::SDL_INIT_GAMEPAD);
         let mut num_joysticks = 0;
         let joysticks = unsafe { sdl3_sys::joystick::SDL_GetJoysticks(&mut num_joysticks) };
@@ -59,15 +86,7 @@ impl Ui {
             panic!("Could not get joystick list");
         }
 
-        let config_file_path = config_dir.join("config.json");
-        let config_file = std::fs::read(config_file_path.clone());
-        let mut config_map = config::Config::new();
-        if config_file.is_ok() {
-            let result = serde_json::from_slice(config_file.unwrap().as_ref());
-            if result.is_ok() {
-                config_map = result.unwrap();
-            }
-        }
+        let dirs = get_dirs();
 
         Ui {
             controllers: [
@@ -93,8 +112,7 @@ impl Ui {
                 },
             ],
             keyboard_state: std::ptr::null_mut(),
-            config_file_path,
-            config: config_map,
+            config: config::Config::new(),
             save_type: vec![],
             game_id: String::new(),
             game_hash: String::new(),
@@ -110,7 +128,7 @@ impl Ui {
                 sram: (Vec::new(), false),
                 flash: (Vec::new(), false),
                 mempak: (Vec::new(), false),
-                romsave: (serde_json::Map::new(), false),
+                romsave: (std::collections::HashMap::new(), false),
             },
             pak_audio: audio::PakAudio {
                 mempak: include_bytes!("../data/mempak.wav").to_vec(),
@@ -123,6 +141,7 @@ impl Ui {
             audio_device: 0,
             num_joysticks,
             joysticks,
+            dirs,
         }
     }
 }

src/ui/config.rs

@@ -31,8 +31,30 @@ pub struct Config {
     pub video: Video,
 }
 
+impl Drop for Config {
+    fn drop(&mut self) {
+        write_config(self);
+    }
+}
+
+fn write_config(config: &Config) {
+    let dirs = ui::get_dirs();
+    let file_path = dirs.config_dir.join("config.json");
+    let f = std::fs::File::create(file_path).unwrap();
+    serde_json::to_writer_pretty(f, &config).unwrap();
+}
+
 impl Config {
     pub fn new() -> Config {
+        let dirs = ui::get_dirs();
+        let file_path = dirs.config_dir.join("config.json");
+        let config_file = std::fs::read(file_path);
+        if config_file.is_ok() {
+            let result = serde_json::from_slice(config_file.unwrap().as_ref());
+            if let Ok(result) = result {
+                return result;
+            }
+        }
         let mut input_profiles = std::collections::HashMap::new();
         input_profiles.insert("default".to_string(), ui::input::get_default_profile());
         Config {

src/ui/gui.rs

@@ -2,12 +2,11 @@ use crate::device;
 use crate::netplay;
 use crate::ui;
 use eframe::egui;
+
 pub mod gui_netplay;
 
 pub struct GopherEguiApp {
-    config_dir: std::path::PathBuf,
-    cache_dir: std::path::PathBuf,
-    data_dir: std::path::PathBuf,
+    dirs: ui::Dirs,
     configure_profile: bool,
     profile_name: String,
     controller_names: Vec<String>,
@@ -15,15 +14,16 @@ pub struct GopherEguiApp {
     selected_profile: [String; 4],
     input_profiles: Vec<String>,
     controller_enabled: [bool; 4],
+    controller_paths: Vec<String>,
     upscale: bool,
     integer_scaling: bool,
     fullscreen: bool,
     emulate_vru: bool,
     dinput: bool,
     show_vru_dialog: bool,
-    vru_window_receiver: Option<tokio::sync::mpsc::Receiver<Vec<String>>>,
-    netplay_error_receiver: Option<tokio::sync::mpsc::Receiver<String>>,
-    vru_word_notifier: Option<tokio::sync::mpsc::Sender<String>>,
+    vru_window_receiver: Option<std::sync::mpsc::Receiver<Vec<String>>>,
+    netplay_error_receiver: Option<std::sync::mpsc::Receiver<String>>,
+    vru_word_notifier: Option<std::sync::mpsc::Sender<String>>,
     vru_word_list: Vec<String>,
     pub netplay: gui_netplay::GuiNetplay,
 }
@@ -38,10 +38,10 @@ struct SaveConfig {
     emulate_vru: bool,
 }
 
-fn get_input_profiles(game_ui: &ui::Ui) -> Vec<String> {
+fn get_input_profiles(config: &ui::config::Config) -> Vec<String> {
     let mut profiles = vec![];
-    for key in game_ui.config.input.input_profiles.keys() {
-        profiles.push((*key).clone())
+    for key in config.input.input_profiles.keys() {
+        profiles.push(key.clone())
     }
     profiles
 }
@@ -81,22 +81,14 @@ pub fn get_controller_paths(game_ui: &ui::Ui) -> Vec<String> {
 impl GopherEguiApp {
     pub fn new(
         cc: &eframe::CreationContext<'_>,
-        config_dir: std::path::PathBuf,
-        cache_dir: std::path::PathBuf,
-        data_dir: std::path::PathBuf,
+        controller_paths: Vec<String>,
+        controller_names: Vec<String>,
     ) -> GopherEguiApp {
         add_japanese_font(&cc.egui_ctx);
-        let game_ui = ui::Ui::new(config_dir.clone());
-        let controller_paths = get_controller_paths(&game_ui);
+        let config = ui::config::Config::new();
 
         let mut selected_controller = [-1, -1, -1, -1];
-        for (pos, item) in game_ui
-            .config
-            .input
-            .controller_assignment
-            .iter()
-            .enumerate()
-        {
+        for (pos, item) in config.input.controller_assignment.iter().enumerate() {
             if item.is_some() {
                 for (path_pos, path) in controller_paths.iter().enumerate() {
                     if item.as_deref().unwrap() == *path {
@@ -107,54 +99,55 @@ impl GopherEguiApp {
             }
         }
         GopherEguiApp {
-            cache_dir: cache_dir.clone(),
-            config_dir: config_dir.clone(),
-            data_dir: data_dir.clone(),
             configure_profile: false,
             profile_name: "".to_string(),
-            selected_profile: game_ui.config.input.input_profile_binding.clone(),
+            selected_profile: config.input.input_profile_binding.clone(),
             selected_controller,
-            controller_names: get_controller_names(&game_ui),
-            input_profiles: get_input_profiles(&game_ui),
-            controller_enabled: game_ui.config.input.controller_enabled,
-            upscale: game_ui.config.video.upscale,
-            integer_scaling: game_ui.config.video.integer_scaling,
-            fullscreen: game_ui.config.video.fullscreen,
-            emulate_vru: game_ui.config.input.emulate_vru,
+            controller_names,
+            input_profiles: get_input_profiles(&config),
+            controller_enabled: config.input.controller_enabled,
+            upscale: config.video.upscale,
+            integer_scaling: config.video.integer_scaling,
+            fullscreen: config.video.fullscreen,
+            emulate_vru: config.input.emulate_vru,
             show_vru_dialog: false,
             dinput: false,
+            controller_paths,
             netplay_error_receiver: None,
             vru_window_receiver: None,
             vru_word_notifier: None,
             vru_word_list: Vec::new(),
             netplay: Default::default(),
+            dirs: ui::get_dirs(),
         }
     }
 }
 
-fn save_config(game_ui: &mut ui::Ui, save_config_items: SaveConfig) {
-    let controller_paths = get_controller_paths(game_ui);
+fn save_config(
+    config: &mut ui::config::Config,
+    controller_paths: Vec<String>,
+    save_config_items: SaveConfig,
+) {
     for (pos, item) in save_config_items.selected_controller.iter().enumerate() {
         if *item != -1 {
-            game_ui.config.input.controller_assignment[pos] =
+            config.input.controller_assignment[pos] =
                 Some(controller_paths[*item as usize].clone());
         } else {
-            game_ui.config.input.controller_assignment[pos] = None
+            config.input.controller_assignment[pos] = None
         }
     }
 
-    game_ui.config.input.input_profile_binding = save_config_items.selected_profile;
-    game_ui.config.input.controller_enabled = save_config_items.controller_enabled;
+    config.input.input_profile_binding = save_config_items.selected_profile;
+    config.input.controller_enabled = save_config_items.controller_enabled;
 
-    game_ui.config.video.upscale = save_config_items.upscale;
-    game_ui.config.video.integer_scaling = save_config_items.integer_scaling;
-    game_ui.config.video.fullscreen = save_config_items.fullscreen;
-    game_ui.config.input.emulate_vru = save_config_items.emulate_vru;
+    config.video.upscale = save_config_items.upscale;
+    config.video.integer_scaling = save_config_items.integer_scaling;
+    config.video.fullscreen = save_config_items.fullscreen;
+    config.input.emulate_vru = save_config_items.emulate_vru;
 }
 
 impl Drop for GopherEguiApp {
     fn drop(&mut self) {
-        let mut game_ui = ui::Ui::new(self.config_dir.clone());
         let save_config_items = SaveConfig {
             selected_controller: self.selected_controller,
             selected_profile: self.selected_profile.clone(),
@@ -164,7 +157,12 @@ impl Drop for GopherEguiApp {
             fullscreen: self.fullscreen,
             emulate_vru: self.emulate_vru,
         };
-        save_config(&mut game_ui, save_config_items);
+        let mut config = ui::config::Config::new();
+        save_config(
+            &mut config,
+            self.controller_paths.clone(),
+            save_config_items,
+        );
     }
 }
 
@@ -181,11 +179,25 @@ fn configure_profile(app: &mut GopherEguiApp, ctx: &egui::Context) {
             ui.horizontal(|ui| {
                 if ui.button("Configure Profile").clicked() {
                     let profile_name = app.profile_name.clone();
-                    let config_dir = app.config_dir.clone();
                     let dinput = app.dinput;
-                    tokio::spawn(async move {
-                        let mut game_ui = ui::Ui::new(config_dir);
-                        ui::input::configure_input_profile(&mut game_ui, profile_name, dinput);
+                    std::thread::spawn(move || {
+                        if cfg!(target_os = "macos") {
+                            let mut command =
+                                std::process::Command::new(std::env::current_exe().unwrap());
+                            if dinput {
+                                command.arg("--use-dinput");
+                            }
+                            command.arg("--configure-input-profile");
+                            command.arg(profile_name);
+
+                            let status = command.status().expect("failed to execute process");
+                            if !status.success() {
+                                panic!("process exited with: {}", status);
+                            }
+                        } else {
+                            let mut game_ui = ui::Ui::new();
+                            ui::input::configure_input_profile(&mut game_ui, profile_name, dinput);
+                        }
                     });
                     app.configure_profile = false;
                     if !app.profile_name.is_empty()
@@ -224,7 +236,7 @@ fn show_vru_dialog(app: &mut GopherEguiApp, ctx: &egui::Context) {
                             app.vru_word_notifier
                                 .as_ref()
                                 .unwrap()
-                                .try_send(v.clone())
+                                .send(v.clone())
                                 .unwrap();
                             app.show_vru_dialog = false;
                         }
@@ -236,7 +248,7 @@ fn show_vru_dialog(app: &mut GopherEguiApp, ctx: &egui::Context) {
                 app.vru_word_notifier
                     .as_ref()
                     .unwrap()
-                    .try_send(String::from(""))
+                    .send(String::from(""))
                     .unwrap();
                 app.show_vru_dialog = false;
             }
@@ -245,7 +257,6 @@ fn show_vru_dialog(app: &mut GopherEguiApp, ctx: &egui::Context) {
 }
 
 pub fn open_rom(app: &mut GopherEguiApp, ctx: &egui::Context) {
-    let task;
     let netplay;
 
     let selected_controller = app.selected_controller;
@@ -255,21 +266,18 @@ pub fn open_rom(app: &mut GopherEguiApp, ctx: &egui::Context) {
     let integer_scaling = app.integer_scaling;
     let fullscreen = app.fullscreen;
     let emulate_vru = app.emulate_vru;
-    let config_dir = app.config_dir.clone();
-    let cache_dir = app.cache_dir.clone();
-    let data_dir = app.data_dir.clone();
     let peer_addr;
     let session;
     let player_number;
+    let cache_dir = app.dirs.cache_dir.clone();
+    let controller_paths = app.controller_paths.clone();
 
     if app.netplay.player_name.is_empty() {
-        task = Some(rfd::AsyncFileDialog::new().pick_file());
         netplay = false;
         peer_addr = None;
         session = None;
         player_number = None;
     } else {
-        task = None;
         netplay = true;
         peer_addr = app.netplay.peer_addr;
         session = app.netplay.waiting_session.clone();
@@ -277,19 +285,19 @@ pub fn open_rom(app: &mut GopherEguiApp, ctx: &egui::Context) {
     }
 
     let (netplay_error_notifier, netplay_error_receiver): (
-        tokio::sync::mpsc::Sender<String>,
-        tokio::sync::mpsc::Receiver<String>,
-    ) = tokio::sync::mpsc::channel(8);
+        std::sync::mpsc::Sender<String>,
+        std::sync::mpsc::Receiver<String>,
+    ) = std::sync::mpsc::channel();
 
     let (vru_window_notifier, vru_window_receiver): (
-        tokio::sync::mpsc::Sender<Vec<String>>,
-        tokio::sync::mpsc::Receiver<Vec<String>>,
-    ) = tokio::sync::mpsc::channel(1);
+        std::sync::mpsc::Sender<Vec<String>>,
+        std::sync::mpsc::Receiver<Vec<String>>,
+    ) = std::sync::mpsc::channel();
 
     let (vru_word_notifier, vru_word_receiver): (
-        tokio::sync::mpsc::Sender<String>,
-        tokio::sync::mpsc::Receiver<String>,
-    ) = tokio::sync::mpsc::channel(1);
+        std::sync::mpsc::Sender<String>,
+        std::sync::mpsc::Receiver<String>,
+    ) = std::sync::mpsc::channel();
 
     if netplay {
         app.netplay_error_receiver = Some(netplay_error_receiver);
@@ -304,10 +312,41 @@ pub fn open_rom(app: &mut GopherEguiApp, ctx: &egui::Context) {
 
     let rom_contents = app.netplay.rom_contents.clone();
     let gui_ctx = ctx.clone();
-    tokio::spawn(async move {
-        let file = if !netplay { task.unwrap().await } else { None };
+    std::thread::spawn(move || {
+        let file = if !netplay {
+            rfd::FileDialog::new().pick_file()
+        } else {
+            None
+        };
 
-        if file.is_some() || netplay {
+        let save_config_items = SaveConfig {
+            selected_controller,
+            selected_profile,
+            controller_enabled,
+            upscale,
+            integer_scaling,
+            fullscreen,
+            emulate_vru,
+        };
+
+        if cfg!(target_os = "macos") && file.is_some() {
+            // mac os requires the process to be started on the main thread
+            // this means that netplay and VRU emulation will not work on mac os
+            {
+                let mut config = ui::config::Config::new();
+                save_config(&mut config, controller_paths, save_config_items);
+            }
+            let mut command = std::process::Command::new(std::env::current_exe().unwrap());
+            if fullscreen {
+                command.arg("--fullscreen");
+            }
+            command.arg(file.unwrap().as_path());
+
+            let status = command.status().expect("failed to execute process");
+            if !status.success() {
+                panic!("process exited with: {}", status);
+            }
+        } else if file.is_some() || netplay {
             let running_file = cache_dir.join("game_running");
             if running_file.exists() {
                 println!("Game already running");
@@ -317,18 +356,9 @@ pub fn open_rom(app: &mut GopherEguiApp, ctx: &egui::Context) {
             if result.is_err() {
                 panic!("could not create running file: {}", result.err().unwrap())
             }
-            let mut device = device::Device::new(config_dir);
 
-            let save_config_items = SaveConfig {
-                selected_controller,
-                selected_profile,
-                controller_enabled,
-                upscale,
-                integer_scaling,
-                fullscreen,
-                emulate_vru,
-            };
-            save_config(&mut device.ui, save_config_items);
+            let mut device = device::Device::new();
+            save_config(&mut device.ui.config, controller_paths, save_config_items);
 
             if netplay {
                 device.netplay = Some(netplay::init(
@@ -338,7 +368,7 @@ pub fn open_rom(app: &mut GopherEguiApp, ctx: &egui::Context) {
                     netplay_error_notifier,
                     gui_ctx,
                 ));
-                device::run_game(rom_contents, data_dir, &mut device, fullscreen);
+                device::run_game(rom_contents, &mut device, fullscreen);
                 netplay::close(&mut device);
             } else {
                 if emulate_vru {
@@ -347,14 +377,14 @@ pub fn open_rom(app: &mut GopherEguiApp, ctx: &egui::Context) {
                     device.vru.gui_ctx = Some(gui_ctx);
                 }
 
-                let rom_contents = device::get_rom_contents(file.unwrap().path());
+                let rom_contents = device::get_rom_contents(file.unwrap().as_path());
                 if rom_contents.is_empty() {
                     println!("Could not read rom file");
                 } else {
-                    device::run_game(rom_contents, data_dir, &mut device, fullscreen);
+                    device::run_game(rom_contents, &mut device, fullscreen);
                 }
             }
-            let result = std::fs::remove_file(running_file.clone());
+            let result = std::fs::remove_file(running_file);
             if result.is_err() {
                 panic!("could not remove running file: {}", result.err().unwrap())
             }
@@ -377,7 +407,7 @@ impl eframe::App for GopherEguiApp {
         }
 
         if self.netplay_error_receiver.is_some() {
-            let result = self.netplay_error_receiver.as_mut().unwrap().try_recv();
+            let result = self.netplay_error_receiver.as_ref().unwrap().try_recv();
             if result.is_ok() {
                 self.netplay.error = result.unwrap();
             }
@@ -401,9 +431,9 @@ impl eframe::App for GopherEguiApp {
                     if ui.button("Open ROM").clicked() {
                         open_rom(self, ctx);
                     }
-
-                    if ui.button("Netplay: Create Session").clicked()
-                        && !self.cache_dir.join("game_running").exists()
+                    if !cfg!(target_os = "macos")
+                        && ui.button("Netplay: Create Session").clicked()
+                        && !self.dirs.cache_dir.join("game_running").exists()
                     {
                         self.netplay.create = true;
                     }
@@ -411,13 +441,14 @@ impl eframe::App for GopherEguiApp {
                     ui.end_row();
 
                     if ui.button("Configure Input Profile").clicked()
-                        && !self.cache_dir.join("game_running").exists()
+                        && !self.dirs.cache_dir.join("game_running").exists()
                     {
                         self.configure_profile = true;
                     }
 
-                    if ui.button("Netplay: Join Session").clicked()
-                        && !self.cache_dir.join("game_running").exists()
+                    if !cfg!(target_os = "macos")
+                        && ui.button("Netplay: Join Session").clicked()
+                        && !self.dirs.cache_dir.join("game_running").exists()
                     {
                         self.netplay.join = true;
                     }
@@ -476,16 +507,18 @@ impl eframe::App for GopherEguiApp {
             ui.checkbox(&mut self.integer_scaling, "Integer Scaling");
             ui.checkbox(&mut self.fullscreen, "Fullscreen (Esc closes game)");
             ui.add_space(32.0);
-            ui.checkbox(
-                &mut self.emulate_vru,
-                "Emulate VRU (connects VRU to controller port 4)",
-            );
+            if !cfg!(target_os = "macos") {
+                ui.checkbox(
+                    &mut self.emulate_vru,
+                    "Emulate VRU (connects VRU to controller port 4)",
+                );
+            }
             ui.add_space(32.0);
             ui.label(format!("Version: {}", env!("CARGO_PKG_VERSION")));
         });
 
         if self.emulate_vru && self.vru_window_receiver.is_some() {
-            let result = self.vru_window_receiver.as_mut().unwrap().try_recv();
+            let result = self.vru_window_receiver.as_ref().unwrap().try_recv();
             if result.is_ok() {
                 self.show_vru_dialog = true;
                 self.vru_word_list = result.unwrap();

src/ui/gui/gui_netplay.rs

@@ -41,8 +41,8 @@ pub struct GuiNetplay {
     pub socket:
         Option<tungstenite::WebSocket<tungstenite::stream::MaybeTlsStream<std::net::TcpStream>>>,
     pub server_receiver:
-        Option<tokio::sync::mpsc::Receiver<std::collections::HashMap<String, String>>>,
-    pub game_info_receiver: Option<tokio::sync::mpsc::Receiver<GameInfo>>,
+        Option<std::sync::mpsc::Receiver<std::collections::HashMap<String, String>>>,
+    pub game_info_receiver: Option<std::sync::mpsc::Receiver<GameInfo>>,
     pub broadcast_socket: Option<std::net::UdpSocket>,
     pub broadcast_timer: Option<std::time::Instant>,
 }
@@ -99,20 +99,17 @@ fn get_servers(app: &mut GopherEguiApp, ctx: &egui::Context) {
             ctx.request_repaint();
         }
         if app.netplay.server_receiver.is_none() {
-            let (tx, rx) = tokio::sync::mpsc::channel(1);
+            let (tx, rx) = std::sync::mpsc::channel();
             app.netplay.server_receiver = Some(rx);
             let gui_ctx = ctx.clone();
-            tokio::spawn(async move {
+            std::thread::spawn(move || {
                 if let Ok(response) =
-                    reqwest::get("https://m64p.s3.amazonaws.com/servers.json").await
-                {
-                    if let Ok(servers) = response
+                    reqwest::blocking::get("https://m64p.s3.amazonaws.com/servers.json")
+                        .unwrap()
                         .json::<std::collections::HashMap<String, String>>()
-                        .await
-                    {
-                        let _ = tx.send(servers).await;
-                        gui_ctx.request_repaint();
-                    }
+                {
+                    tx.send(response).unwrap();
+                    gui_ctx.request_repaint();
                 }
             });
         }
@@ -146,7 +143,7 @@ fn get_servers(app: &mut GopherEguiApp, ctx: &egui::Context) {
         ctx.request_repaint();
     }
     if app.netplay.server_receiver.is_some() {
-        let result = app.netplay.server_receiver.as_mut().unwrap().try_recv();
+        let result = app.netplay.server_receiver.as_ref().unwrap().try_recv();
         if result.is_ok() {
             app.netplay.servers.extend(result.unwrap());
             app.netplay.server_receiver = None;
@@ -184,25 +181,23 @@ pub fn netplay_create(app: &mut GopherEguiApp, ctx: &egui::Context) {
                 app.netplay.create_rom_label = "Open ROM".to_string();
             }
             if ui.button(&app.netplay.create_rom_label).clicked() {
-                let task = rfd::AsyncFileDialog::new().pick_file();
-                let (tx, rx) = tokio::sync::mpsc::channel(1);
+                let (tx, rx) = std::sync::mpsc::channel();
                 app.netplay.game_info_receiver = Some(rx);
                 let gui_ctx = ctx.clone();
                 app.netplay.create_rom_label = "Inspecting ROM".to_string();
-                tokio::spawn(async move {
-                    let file = task.await;
+                std::thread::spawn(move || {
+                    let file = rfd::FileDialog::new().pick_file();
 
                     if let Some(file) = file {
-                        parse_rom_file(file, tx).await
+                        parse_rom_file(file, tx);
                     } else {
-                        let _ = tx
-                            .send((
-                                "".to_string(),
-                                "".to_string(),
-                                "Open ROM".to_string(),
-                                vec![],
-                            ))
-                            .await;
+                        tx.send((
+                            "".to_string(),
+                            "".to_string(),
+                            "Open ROM".to_string(),
+                            vec![],
+                        ))
+                        .unwrap();
                     }
                     gui_ctx.request_repaint();
                 });
@@ -222,7 +217,7 @@ pub fn netplay_create(app: &mut GopherEguiApp, ctx: &egui::Context) {
             get_servers(app, ctx);
 
             if app.netplay.game_info_receiver.is_some() {
-                let result = app.netplay.game_info_receiver.as_mut().unwrap().try_recv();
+                let result = app.netplay.game_info_receiver.as_ref().unwrap().try_recv();
                 if result.is_ok() {
                     app.netplay.game_info_receiver = None;
                     let data = result.unwrap();
@@ -347,7 +342,7 @@ pub fn netplay_create(app: &mut GopherEguiApp, ctx: &egui::Context) {
 
 fn get_sessions(app: &mut GopherEguiApp, ctx: &egui::Context) {
     if app.netplay.have_sessions.is_some()
-        && app.netplay.server != app.netplay.have_sessions.as_ref().unwrap().clone()
+        && app.netplay.server != *app.netplay.have_sessions.as_ref().unwrap()
     {
         // User has changed the server
         app.netplay.have_sessions = None;
@@ -396,8 +391,8 @@ fn get_sessions(app: &mut GopherEguiApp, ctx: &egui::Context) {
     }
 }
 
-async fn parse_rom_file(file: rfd::FileHandle, tx: tokio::sync::mpsc::Sender<GameInfo>) {
-    let rom_contents = device::get_rom_contents(file.path());
+fn parse_rom_file(file: std::path::PathBuf, tx: std::sync::mpsc::Sender<GameInfo>) {
+    let rom_contents = device::get_rom_contents(file.as_path());
     if !rom_contents.is_empty() {
         let hash = device::cart_rom::calculate_hash(&rom_contents);
         let game_name = std::str::from_utf8(&rom_contents[0x20..0x20 + 0x14])
@@ -405,18 +400,21 @@ async fn parse_rom_file(file: rfd::FileHandle, tx: tokio::sync::mpsc::Sender<Gam
             .trim()
             .replace('\0', "")
             .to_string();
-        let _ = tx
-            .send((hash, game_name, file.file_name(), rom_contents))
-            .await;
+        tx.send((
+            hash,
+            game_name,
+            file.file_name().unwrap().to_string_lossy().to_string(),
+            rom_contents,
+        ))
+        .unwrap();
     } else {
-        let _ = tx
-            .send((
-                "".to_string(),
-                "".to_string(),
-                "Invalid ROM".to_string(),
-                vec![],
-            ))
-            .await;
+        tx.send((
+            "".to_string(),
+            "".to_string(),
+            "Invalid ROM".to_string(),
+            vec![],
+        ))
+        .unwrap();
     }
 }
 
@@ -446,7 +444,7 @@ pub fn netplay_join(app: &mut GopherEguiApp, ctx: &egui::Context) {
         ctx.request_repaint();
     }
     if app.netplay.game_info_receiver.is_some() {
-        let result = app.netplay.game_info_receiver.as_mut().unwrap().try_recv();
+        let result = app.netplay.game_info_receiver.as_ref().unwrap().try_recv();
         if result.is_ok() {
             app.netplay.game_info_receiver = None;
             let data = result.unwrap();
@@ -587,25 +585,23 @@ pub fn netplay_join(app: &mut GopherEguiApp, ctx: &egui::Context) {
                     {
                         app.netplay.error = "Session requires a password".to_string();
                     } else {
-                        let task = rfd::AsyncFileDialog::new().pick_file();
-                        let (tx, rx) = tokio::sync::mpsc::channel(1);
+                        let (tx, rx) = std::sync::mpsc::channel();
                         app.netplay.game_info_receiver = Some(rx);
                         let gui_ctx = ctx.clone();
                         app.netplay.join_rom_label = "Inspecting ROM".to_string();
-                        tokio::spawn(async move {
-                            let file = task.await;
+                        std::thread::spawn(move || {
+                            let file = rfd::FileDialog::new().pick_file();
 
                             if let Some(file) = file {
-                                parse_rom_file(file, tx).await
+                                parse_rom_file(file, tx);
                             } else {
-                                let _ = tx
-                                    .send((
-                                        "".to_string(),
-                                        "".to_string(),
-                                        "No ROM selected".to_string(),
-                                        vec![],
-                                    ))
-                                    .await;
+                                tx.send((
+                                    "".to_string(),
+                                    "".to_string(),
+                                    "No ROM selected".to_string(),
+                                    vec![],
+                                ))
+                                .unwrap();
                             }
                             gui_ctx.request_repaint();
                         });
@@ -757,17 +753,22 @@ pub fn netplay_wait(app: &mut GopherEguiApp, ctx: &egui::Context) {
                         }
                     }
                     app.netplay.player_number = player as u8;
-                    socket.close(None).unwrap();
-                    loop {
-                        match socket.read() {
-                            Err(tungstenite::Error::ConnectionClosed) => break,
-                            _ => continue,
-                        };
-                    }
 
-                    gui::open_rom(app, ctx);
-                    app.netplay = Default::default();
-                    return;
+                    if message.accept.unwrap() == 0 {
+                        socket.close(None).unwrap();
+                        loop {
+                            match socket.read() {
+                                Err(tungstenite::Error::ConnectionClosed) => break,
+                                _ => continue,
+                            };
+                        }
+
+                        gui::open_rom(app, ctx);
+                        app.netplay = Default::default();
+                        return;
+                    } else {
+                        app.netplay.error = message.message.unwrap();
+                    }
                 }
             } else {
                 app.netplay.error = message.message.unwrap();

src/ui/storage.rs

@@ -1,4 +1,3 @@
-use crate::device;
 use crate::netplay;
 use crate::ui;
 
@@ -27,7 +26,7 @@ pub struct Saves {
     pub sram: (Vec<u8>, bool),
     pub flash: (Vec<u8>, bool),
     pub mempak: (Vec<u8>, bool),
-    pub romsave: (serde_json::Map<String, serde_json::Value>, bool),
+    pub romsave: (std::collections::HashMap<u32, u8>, bool),
 }
 
 fn get_save_type(game_id: &str) -> Vec<SaveTypes> {
@@ -88,11 +87,11 @@ fn get_save_type(game_id: &str) -> Vec<SaveTypes> {
     }
 }
 
-pub fn init(ui: &mut ui::Ui, data_dir: std::path::PathBuf) {
+pub fn init(ui: &mut ui::Ui) {
     let id = ui.game_id.as_str();
     ui.save_type = get_save_type(id);
 
-    let base_path = data_dir.join("saves");
+    let base_path = ui.dirs.data_dir.join("saves");
 
     ui.paths.eep_file_path.clone_from(&base_path);
     ui.paths
@@ -138,12 +137,9 @@ pub fn load_saves(ui: &mut ui::Ui, netplay: &mut Option<netplay::Netplay>) {
         if mempak.is_ok() {
             ui.saves.mempak.0 = mempak.unwrap();
         }
-        if netplay.is_none() {
-            // can't do romsaves with the current netplay implementation
-            let romsave = std::fs::read(&mut ui.paths.romsave_file_path);
-            if romsave.is_ok() {
-                ui.saves.romsave.0 = serde_json::from_slice(romsave.unwrap().as_ref()).unwrap();
-            }
+        let romsave = std::fs::read(&mut ui.paths.romsave_file_path);
+        if romsave.is_ok() {
+            ui.saves.romsave.0 = postcard::from_bytes(romsave.unwrap().as_ref()).unwrap();
         }
     }
 
@@ -153,58 +149,53 @@ pub fn load_saves(ui: &mut ui::Ui, netplay: &mut Option<netplay::Netplay>) {
                 netplay.as_mut().unwrap(),
                 "eep",
                 &ui.saves.eeprom.0,
-                device::cart::EEPROM_MAX_SIZE,
+                ui.saves.eeprom.0.len(),
             );
             netplay::send_save(
                 netplay.as_mut().unwrap(),
                 "sra",
                 &ui.saves.sram.0,
-                device::sram::SRAM_SIZE,
+                ui.saves.sram.0.len(),
             );
             netplay::send_save(
                 netplay.as_mut().unwrap(),
                 "fla",
                 &ui.saves.flash.0,
-                device::sram::FLASHRAM_SIZE,
+                ui.saves.flash.0.len(),
             );
             netplay::send_save(
                 netplay.as_mut().unwrap(),
                 "mpk",
                 &ui.saves.mempak.0,
-                device::controller::mempak::MEMPAK_SIZE * 4,
+                ui.saves.mempak.0.len(),
+            );
+            let mut romsave_bytes: Vec<u8> = vec![];
+            if !ui.saves.romsave.0.is_empty() {
+                romsave_bytes = postcard::to_stdvec(&ui.saves.romsave.0).unwrap();
+            }
+            netplay::send_save(
+                netplay.as_mut().unwrap(),
+                "rom",
+                &romsave_bytes,
+                romsave_bytes.len(),
             );
         } else {
-            netplay::receive_save(
-                netplay.as_mut().unwrap(),
-                "eep",
-                &mut ui.saves.eeprom.0,
-                device::cart::EEPROM_MAX_SIZE,
-            );
-            netplay::receive_save(
-                netplay.as_mut().unwrap(),
-                "sra",
-                &mut ui.saves.sram.0,
-                device::sram::SRAM_SIZE,
-            );
-            netplay::receive_save(
-                netplay.as_mut().unwrap(),
-                "fla",
-                &mut ui.saves.flash.0,
-                device::sram::FLASHRAM_SIZE,
-            );
-            netplay::receive_save(
-                netplay.as_mut().unwrap(),
-                "mpk",
-                &mut ui.saves.mempak.0,
-                device::controller::mempak::MEMPAK_SIZE * 4,
-            );
+            netplay::receive_save(netplay.as_mut().unwrap(), "eep", &mut ui.saves.eeprom.0);
+            netplay::receive_save(netplay.as_mut().unwrap(), "sra", &mut ui.saves.sram.0);
+            netplay::receive_save(netplay.as_mut().unwrap(), "fla", &mut ui.saves.flash.0);
+            netplay::receive_save(netplay.as_mut().unwrap(), "mpk", &mut ui.saves.mempak.0);
+            let mut romsave_bytes: Vec<u8> = vec![];
+            netplay::receive_save(netplay.as_mut().unwrap(), "rom", &mut romsave_bytes);
+            if !romsave_bytes.is_empty() {
+                ui.saves.romsave.0 = postcard::from_bytes(&romsave_bytes).unwrap();
+            }
         }
     }
 }
 
 fn write_rom_save(ui: &ui::Ui) {
-    let f = std::fs::File::create(ui.paths.romsave_file_path.clone()).unwrap();
-    serde_json::to_writer(f, &ui.saves.romsave.0).unwrap();
+    let data = postcard::to_stdvec(&ui.saves.romsave.0).unwrap();
+    std::fs::write(ui.paths.romsave_file_path.clone(), data).unwrap();
 }
 
 pub fn write_saves(ui: &ui::Ui, netplay: &Option<netplay::Netplay>) {
@@ -221,7 +212,7 @@ pub fn write_saves(ui: &ui::Ui, netplay: &Option<netplay::Netplay>) {
         if ui.saves.mempak.1 {
             write_save(ui, SaveTypes::Mempak)
         }
-        if ui.saves.romsave.1 && netplay.is_none() {
+        if ui.saves.romsave.1 {
             write_save(ui, SaveTypes::Romsave)
         }
     }

src/ui/vru.rs

@@ -4,14 +4,14 @@ use crate::ui;
 
 pub fn prompt_for_match(
     words: &[String],
-    window_notifier: &tokio::sync::mpsc::Sender<Vec<String>>,
-    word_index_receiver: &mut tokio::sync::mpsc::Receiver<String>,
+    window_notifier: &std::sync::mpsc::Sender<Vec<String>>,
+    word_index_receiver: &std::sync::mpsc::Receiver<String>,
     gui_ctx: &egui::Context,
 ) -> u16 {
     let mut dedup_words = words.to_owned();
     dedup_words.sort();
     dedup_words.dedup();
-    window_notifier.try_send(dedup_words).unwrap();
+    window_notifier.send(dedup_words).unwrap();
     gui_ctx.request_repaint(); // this is so the window pops up right away
     let mut result = word_index_receiver.try_recv();
     while result.is_err() {