chore: add minimum zig version

still not ideal imo

.github/workflows/main.yml

@@ -4,6 +4,7 @@ on:
   push:
     paths:
       - "**.zig"
+      - "dl_sdl2.ps1"
     branches:
       - main
   schedule:
@@ -14,13 +15,17 @@ jobs:
   build:
     strategy:
       matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
+        os: [ubuntu-latest, windows-latest] # TODO: Figure out Apple Silicon macOS
-        # os: [ubuntu-latest, windows-latest]
     runs-on: ${{matrix.os}}
     steps:
       - uses: goto-bus-stop/setup-zig@v2
         with:
-          version: 0.11.0-dev.3395+1e7dcaa3a
+          version: 0.13.0
+      - run: |
+            git config --global core.autocrlf false
+      - uses: actions/checkout@v3
+        with:
+          submodules: recursive
       - name: prepare-linux
         if: runner.os == 'Linux'
         run: |
@@ -29,26 +34,19 @@ jobs:
       - name: prepare-windows
         if: runner.os == 'Windows'
         run: |
-            vcpkg integrate install
+            .\dl_sdl2.ps1
-            vcpkg install sdl2:x64-windows
-            git config --global core.autocrlf false
       - name: prepare-macos
         if: runner.os == 'macOS'
         run: |
             brew install sdl2
-      - uses: actions/checkout@v3
-        with:
-          submodules: recursive
       - name: build 
         run: zig build -Doptimize=ReleaseSafe -Dcpu=baseline
-      - name: prepare-executable
-        run: |
-            mv zig-out/lib/* zig-out/bin
       - name: upload
         uses: actions/upload-artifact@v3
         with:
           name: zba-${{matrix.os}}
-          path: zig-out/bin
+          path: zig-out
+
   lint:
     runs-on: ubuntu-latest
     steps: 
@@ -57,6 +55,5 @@ jobs:
           submodules: recursive
       - uses: goto-bus-stop/setup-zig@v2
         with:
-          version: 0.11.0-dev.3395+1e7dcaa3a
+          version: 0.13.0
-      - run: zig fmt src/**/*.zig
+      - run: zig fmt --check {src,lib}/**/*.zig build.zig build.zig.zon
-  

.gitignore

@@ -1,6 +1,7 @@
 /.vscode
 /bin
 **/zig-cache
+**/.zig-cache
 **/zig-out
 /docs
 **/*.log
@@ -15,4 +16,4 @@
 
 
 # Dear ImGui
-**/imgui.ini
+**/imgui.ini

.gitmodules

@@ -1,6 +1,3 @@
 [submodule "lib/SDL.zig"]
 	path = lib/SDL.zig
-	url = https://github.com/MasterQ32/SDL.zig
+	url = https://github.com/paoda/SDL.zig
-[submodule "lib/zgui"]
-	path = lib/zgui
-	url = https://git.musuka.dev/paoda/zgui

README.md

@@ -27,7 +27,7 @@ Finally it's worth noting that ZBA uses a TOML config file it'll store in your O
 
 ## Compiling
 
-Most recently built on Zig [v0.11.0-dev.3395+1e7dcaa3a](https://github.com/ziglang/zig/tree/1e7dcaa3a)
+Most recently built on Zig [v0.11.0](https://github.com/ziglang/zig/tree/0.11.0)
 
 ### Dependencies
 

build.zig

@@ -1,15 +1,16 @@
 const std = @import("std");
 const builtin = @import("builtin");
 
-const Sdk = @import("lib/SDL.zig/Sdk.zig");
+const sdl = @import("lib/SDL.zig/build.zig");
-const zgui = @import("lib/zgui/build.zig");
+
+const SemVer = std.SemanticVersion;
+
+const target_version = "0.13.0";
 
 pub fn build(b: *std.Build) void {
-    // Minimum Zig Version
+    const actual_version = builtin.zig_version;
-    const min_ver = std.SemanticVersion.parse("0.11.0-dev.3395+1e7dcaa3a") catch return; // https://github.com/ziglang/zig/commit/34865d693
+    if (comptime actual_version.order(SemVer.parse(target_version) catch unreachable) != .eq) {
-    if (builtin.zig_version.order(min_ver).compare(.lt)) {
+        @compileError("ZBA must be built with Zig v" ++ target_version ++ ".");
-        std.log.err("{s}", .{b.fmt("Zig v{} does not meet the minimum version requirement. (Zig v{})", .{ builtin.zig_version, min_ver })});
-        std.os.exit(1);
     }
 
     const target = b.standardTargetOptions(.{});
@@ -17,52 +18,45 @@ pub fn build(b: *std.Build) void {
 
     const exe = b.addExecutable(.{
         .name = "zba",
-        .root_source_file = .{ .path = "src/main.zig" },
+        .root_source_file = b.path("src/main.zig"),
         .target = target,
         .optimize = optimize,
     });
 
-    exe.setMainPkgPath("."); // Necessary so that src/main.zig can embed example.toml
+    const sdk = sdl.init(b, null, null);
+    const zgui = b.dependency("zgui", .{ .shared = false, .with_implot = true, .backend = .sdl2_opengl3 });
+    const imgui = zgui.artifact("imgui");
 
-    exe.addModule("known_folders", b.dependency("known-folders", .{}).module("known-folders")); // https://github.com/ziglibs/known-folders
+    exe.root_module.addImport("known_folders", b.dependency("known-folders", .{}).module("known-folders")); // https://github.com/ziglibs/known-folders
-    exe.addModule("datetime", b.dependency("zig-datetime", .{}).module("zig-datetime")); // https://github.com/frmdstryr/zig-datetime
+    exe.root_module.addImport("datetime", b.dependency("zig-datetime", .{}).module("zig-datetime")); // https://github.com/frmdstryr/zig-datetime
-    exe.addModule("clap", b.dependency("zig-clap", .{}).module("clap")); // https://github.com/Hejsil/zig-clap
+    exe.root_module.addImport("clap", b.dependency("zig-clap", .{}).module("clap")); // https://github.com/Hejsil/zig-clap
-    exe.addModule("gdbstub", b.dependency("zba-gdbstub", .{}).module("gdbstub")); // https://git.musuka.dev/paoda/zba-gdbstub
+    exe.root_module.addImport("zba-util", b.dependency("zba-util", .{}).module("zba-util")); // https://git.musuka.dev/paoda/zba-util
-    exe.addModule("zba-util", b.dependency("zba-util", .{}).module("zba-util")); // https://git.musuka.dev/paoda/zba-util
+    exe.root_module.addImport("tomlz", b.dependency("tomlz", .{}).module("tomlz")); // https://github.com/mattyhall/tomlz
-    exe.addModule("tomlz", b.dependency("tomlz", .{}).module("tomlz")); // https://github.com/mattyhall/tomlz
+    exe.root_module.addImport("arm32", b.dependency("arm32", .{}).module("arm32")); // https://git.musuka.dev/paoda/arm32
-    exe.addModule("arm32", b.dependency("arm32", .{}).module("arm32")); // https://git.musuka.dev/paoda/arm32
+    exe.root_module.addImport("gdbstub", b.dependency("zba-gdbstub", .{}).module("zba-gdbstub")); // https://git.musuka.dev/paoda/gdbstub
+    exe.root_module.addImport("nfd", b.dependency("nfd", .{}).module("nfd")); // https://github.com/fabioarnold/nfd-zig
+    exe.root_module.addImport("zgui", zgui.module("root")); // https://git.musuka.dev/paoda/zgui
+    exe.root_module.addImport("sdl2", sdk.getNativeModule()); // https://github.com/MasterQ32/SDL.zig
 
-    // https://github.com/fabioarnold/nfd-zig
+    exe.root_module.addAnonymousImport("bitfield", .{ .root_source_file = b.path("lib/bitfield.zig") }); // https://github.com/FlorenceOS/
-    const nfd_dep = b.dependency("nfd", .{ .target = target, .optimize = optimize });
+    exe.root_module.addAnonymousImport("gl", .{ .root_source_file = b.path("lib/gl.zig") }); // https://github.com/MasterQ32/zig-opengl
-    exe.linkLibrary(nfd_dep.artifact("nfd"));
+    exe.root_module.addAnonymousImport("example.toml", .{ .root_source_file = b.path("example.toml") });
-    exe.addModule("nfd", nfd_dep.module("nfd"));
 
-    // https://github.com/MasterQ32/SDL.zig
+    sdk.link(exe, .dynamic, .SDL2);
-    const sdk = Sdk.init(b, null);
+    sdk.link(imgui, .dynamic, .SDL2);
-    sdk.link(exe, .dynamic);
+    exe.linkLibrary(imgui);
-    exe.addModule("sdl2", sdk.getNativeModule());
-
-    // https://git.musuka.dev/paoda/zgui
-    // .shared option should stay in sync with SDL.zig call above where true == .dynamic, and false == .static
-    const zgui_pkg = zgui.package(b, target, optimize, .{ .options = .{ .backend = .sdl2_opengl3, .shared = true } });
-    zgui_pkg.link(exe);
-
-    exe.addAnonymousModule("bitfield", .{ .source_file = .{ .path = "lib/bitfield.zig" } }); // https://github.com/FlorenceOS/
-    exe.addAnonymousModule("gl", .{ .source_file = .{ .path = "lib/gl.zig" } }); // https://github.com/MasterQ32/zig-opengl
 
     b.installArtifact(exe);
 
     const run_cmd = b.addRunArtifact(exe);
     run_cmd.step.dependOn(b.getInstallStep());
-    if (b.args) |args| {
+    if (b.args) |args| run_cmd.addArgs(args);
-        run_cmd.addArgs(args);
-    }
 
     const run_step = b.step("run", "Run the app");
     run_step.dependOn(&run_cmd.step);
 
     const exe_tests = b.addTest(.{
-        .root_source_file = .{ .path = "src/main.zig" },
+        .root_source_file = b.path("src/main.zig"),
         .target = target,
         .optimize = optimize,
     });

build.zig.zon

@@ -1,38 +1,50 @@
 .{
     .name = "zba",
     .version = "0.1.0",
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "lib/bitfield.zig",
+        "lib/gl.zig",
+        "src",
+    },
+    .minimum_zig_version = "0.13.0",
     .dependencies = .{
         .nfd = .{
-            .url = "https://github.com/fabioarnold/nfd-zig/archive/8520a6807f046a23ecf3143e22fc49d2a9d1c189.tar.gz",
+            .url = "git+https://github.com/paoda/nfd-zig#ad81729d33da30d5f4fd23718debec48245121ca",
-            .hash = "122089e0f5ab5e4729a09aed48d721b98ed2b362923ead797c6af3b54ef9a725203f",
+            .hash = "1220a679380847513262c8c5c474d4a415f9ecc4921c8c6aefbdbdce66cf2aa19ceb",
         },
         .@"known-folders" = .{
-            .url = "https://github.com/ziglibs/known-folders/archive/d13ba6137084e55f873f6afb67447fe8906cc951.tar.gz",
+            .url = "git+https://github.com/ziglibs/known-folders#1cceeb70e77dec941a4178160ff6c8d05a74de6f",
-            .hash = "122028c00915d9b37296059be8a3883c718dbb5bd174350caedf152fed1f46f99607",
+            .hash = "12205f5e7505c96573f6fc5144592ec38942fb0a326d692f9cddc0c7dd38f9028f29",
         },
         .@"zig-datetime" = .{
-            .url = "https://github.com/frmdstryr/zig-datetime/archive/e4a2bc92b3771a745145c9a6961f0b5277a48335.tar.gz",
+            .url = "git+https://github.com/frmdstryr/zig-datetime#70aebf28fb3e137cd84123a9349d157a74708721",
-            .hash = "12209fc05ecb5add8f87152f03f99243a419c9dd5a04c6b4a359d6b4f13426fede0c",
+            .hash = "122077215ce36e125a490e59ec1748ffd4f6ba00d4d14f7308978e5360711d72d77f",
         },
         .@"zig-clap" = .{
-            .url = "https://github.com/Hejsil/zig-clap/archive/a1b7a7301b0006bb4c8daaaf5ade8a6df8ec13ae.tar.gz",
+            .url = "git+https://github.com/Hejsil/zig-clap#c0193e9247335a6c1688b946325060289405de2a",
-            .hash = "12205aeff59f41f96033d280471730c171c9a825d8758743249bed834e1590f593e3",
+            .hash = "12207ee987ce045596cb992cfb15b0d6d9456e50d4721c3061c69dabc2962053644d",
-        },
-        .@"zba-gdbstub" = .{
-            .url = "https://git.musuka.dev/paoda/zba-gdbstub/archive/39a4260ffd83bae7bb44bb098872c96382fb5ba3.tar.gz",
-            .hash = "1220b87e4c519f28dce7380ed83f936a4aea2d81046209b18a23eb6c0738b156ca16",
         },
         .@"zba-util" = .{
-            .url = "https://git.musuka.dev/paoda/zba-util/archive/e616cf09e53f5c402c8f040d14baa211683e70e3.tar.gz",
+            .url = "git+https://git.musuka.dev/paoda/zba-util#bf0e744047ce1ec90172dbcc0c72bfcc29a063e3",
-            .hash = "1220b80b2c0989dcc47275ab9d7d70da4858ef3c1fe1f934e8d838e65028127f6ef3",
+            .hash = "1220d044ecfbeacc3b3cebeff131d587e24167d61435a3cb96dffd4d4521bb06aed0",
+        },
+        .@"zba-gdbstub" = .{
+            .url = "git+https://git.musuka.dev/paoda/zba-gdbstub#9a50607d5f48293f950a4e823344f2bc24582a5a",
+            .hash = "1220ac267744ed2a735f03c4620d7c6210fbd36d7bfb2b376ddc3436faebadee0f61",
         },
         .tomlz = .{
-            .url = "https://github.com/mattyhall/tomlz/archive/4928d38e9bb682a9966ffe7f41230435d0111b1e.tar.gz",
+            .url = "git+https://github.com/paoda/tomlz#9a16dd53927ef2012478b6494bafb4475e44f4c9",
-            .hash = "12202b57d7b46fff8d16a17371c4f9b711a56b866f0cd11844e4243c09343a2c4c6d",
+            .hash = "12204f922cab84980e36b5c058d354ec0ee169bda401c8e0e80a463580349b476569",
         },
         .arm32 = .{
-            .url = "https://git.musuka.dev/paoda/arm32/archive/3c8a87c14dfa2501bd0a7f2236259e2d8d0fbcd9.tar.gz",
+            .url = "git+https://git.musuka.dev/paoda/arm32#814d081ea0983bc48841a6baad7158c157b17ad6",
-            .hash = "12202a06a5d20d0da9ab6596a04821431d261c9900c7916a87148619dcb77c745044",
+            .hash = "12203c3dacf3a7aa7aee5fc5763dd7b40399bd1c34d1483330b6bd5a76bffef22d82",
+        },
+        .zgui = .{
+            .url = "git+https://git.musuka.dev/paoda/zgui#7f8d05101e96c64314d7926c80ee157dcb89da4e",
+            .hash = "1220bd81a1c7734892b1d4233ed047710487787873c85dd5fc76d1764a331ed2ff43",
         },
     },
 }

dl_sdl2.ps1

@@ -0,0 +1,36 @@
+$SDL2Version = "2.30.0"
+$ArchiveFile = ".\SDL2-devel-mingw.zip"
+$Json = @"
+{
+	"x86_64-windows-gnu": {
+		"include": ".build_config\\SDL2\\include",
+		"libs": ".build_config\\SDL2\\lib",
+		"bin": ".build_config\\SDL2\\bin"
+	}
+}	
+"@
+
+New-Item -Force -ItemType Directory -Path .\.build_config
+Set-Location -Path .build_config -PassThru
+
+if (!(Test-Path -PathType Leaf $ArchiveFile)) {
+	Invoke-WebRequest "https://github.com/libsdl-org/SDL/releases/download/release-$SDL2Version/SDL2-devel-$SDL2Version-mingw.zip" -OutFile $ArchiveFile
+}
+
+Expand-Archive $ArchiveFile
+
+if (Test-Path -PathType Container .\SDL2) {
+	Remove-Item -Recurse .\SDL2
+}
+
+New-Item -Force -ItemType Directory -Path .\SDL2 
+Get-ChildItem -Path ".\SDL2-devel-mingw\SDL2-$SDL2Version\x86_64-w64-mingw32" | Move-Item -Destination .\SDL2
+
+# #include <SDL.h>
+Move-Item -Force -Path .\SDL2\include\SDL2\* -Destination .\SDL2\include
+Remove-Item -Force .\SDL2\include\SDL2
+
+New-Item -Force .\sdl.json -Value $Json
+
+Remove-Item -Recurse .\SDL2-devel-mingw
+Set-Location -Path .. -PassThru

lib/bitfield.zig

@@ -26,13 +26,13 @@ fn BitType(comptime FieldType: type, comptime ValueType: type, comptime shamt: u
         }
 
         pub fn read(self: anytype) ValueType {
-            return @bitCast(ValueType, @truncate(u1, self.bits.field().* >> shamt));
+            return @bitCast(@as(u1, @truncate(self.bits.field().* >> shamt)));
         }
 
         // Since these are mostly used with MMIO, I want to avoid
         // reading the memory just to write it again, also races
         pub fn write(self: anytype, val: ValueType) void {
-            if (@bitCast(bool, val)) {
+            if (@as(bool, @bitCast(val))) {
                 self.set();
             } else {
                 self.unset();
@@ -67,17 +67,17 @@ pub fn Bitfield(comptime FieldType: type, comptime shamt: usize, comptime num_bi
         dummy: FieldType,
 
         fn field(self: anytype) PtrCastPreserveCV(@This(), @TypeOf(self), FieldType) {
-            return @ptrCast(PtrCastPreserveCV(@This(), @TypeOf(self), FieldType), self);
+            return @ptrCast(self);
         }
 
         pub fn write(self: anytype, val: ValueType) void {
             self.field().* &= ~self_mask;
-            self.field().* |= @intCast(FieldType, val) << shamt;
+            self.field().* |= @as(FieldType, @intCast(val)) << shamt;
         }
 
         pub fn read(self: anytype) ValueType {
             const val: FieldType = self.field().*;
-            return @intCast(ValueType, (val & self_mask) >> shamt);
+            return @intCast((val & self_mask) >> shamt);
         }
     };
 }

src/core/Bus.zig

@@ -98,7 +98,7 @@ pub fn deinit(self: *Self) void {
     // This is so I can deallocate the original `allocator.alloc`. I have to re-make the type
     // since I'm not keeping it around, This is very jank and bad though
     // FIXME: please figure out another way
-    self.allocator.free(@ptrCast([*]const ?*anyopaque, self.read_table[0..])[0 .. 3 * table_len]);
+    self.allocator.free(@as([*]const ?*anyopaque, @ptrCast(self.read_table[0..]))[0 .. 3 * table_len]);
     self.* = undefined;
 }
 
@@ -147,7 +147,7 @@ fn fillReadTable(self: *Self, table: *[table_len]?*const anyopaque) void {
     const vramMirror = @import("ppu/Vram.zig").mirror;
 
     for (table, 0..) |*ptr, i| {
-        const addr = @intCast(u32, page_size * i);
+        const addr: u32 = @intCast(page_size * i);
 
         ptr.* = switch (addr) {
             // General Internal Memory
@@ -174,7 +174,7 @@ fn fillWriteTable(self: *Self, comptime T: type, table: *[table_len]?*const anyo
     const vramMirror = @import("ppu/Vram.zig").mirror;
 
     for (table, 0..) |*ptr, i| {
-        const addr = @intCast(u32, page_size * i);
+        const addr: u32 = @intCast(page_size * i);
 
         ptr.* = switch (addr) {
             // General Internal Memory
@@ -227,7 +227,7 @@ fn fillReadTableExternal(self: *Self, addr: u32) ?*anyopaque {
             // We are using a "small" EEPROM which means that if the below check is true
             // (that is, we're in the 0xD address page) then we must handle at least one
             // address in this page in slowmem
-            if (@truncate(u4, addr >> 24) == 0xD) return null;
+            if (@as(u4, @truncate(addr >> 24)) == 0xD) return null;
         }
     }
 
@@ -257,7 +257,7 @@ fn openBus(self: *const Self, comptime T: type, address: u32) T {
         // the most recently fetched instruction by the pipeline
         if (!self.cpu.cpsr.t.read()) break :blk self.cpu.pipe.stage[1].?;
 
-        const page = @truncate(u8, r15 >> 24);
+        const page: u8 = @truncate(r15 >> 24);
 
         // PC + 2 = stage[0]
         // PC + 4 = stage[1]
@@ -266,7 +266,7 @@ fn openBus(self: *const Self, comptime T: type, address: u32) T {
         switch (page) {
             // EWRAM, PALRAM, VRAM, and Game ROM (16-bit)
             0x02, 0x05, 0x06, 0x08...0x0D => {
-                const halfword: u32 = @truncate(u16, self.cpu.pipe.stage[1].?);
+                const halfword: u32 = @as(u16, @truncate(self.cpu.pipe.stage[1].?));
                 break :blk halfword << 16 | halfword;
             },
 
@@ -277,8 +277,8 @@ fn openBus(self: *const Self, comptime T: type, address: u32) T {
                 const aligned = address & 3 == 0b00;
 
                 // TODO: What to do on PC + 6?
-                const high: u32 = if (aligned) self.dbgRead(u16, r15 + 4) else @truncate(u16, self.cpu.pipe.stage[1].?);
+                const high: u32 = if (aligned) self.dbgRead(u16, r15 + 4) else @as(u16, @truncate(self.cpu.pipe.stage[1].?));
-                const low: u32 = @truncate(u16, self.cpu.pipe.stage[@boolToInt(aligned)].?);
+                const low: u32 = @as(u16, @truncate(self.cpu.pipe.stage[@intFromBool(aligned)].?));
 
                 break :blk high << 16 | low;
             },
@@ -289,8 +289,8 @@ fn openBus(self: *const Self, comptime T: type, address: u32) T {
                 // Unaligned: (PC + 4) | (PC + 2)
                 const aligned = address & 3 == 0b00;
 
-                const high: u32 = @truncate(u16, self.cpu.pipe.stage[1 - @boolToInt(aligned)].?);
+                const high: u32 = @as(u16, @truncate(self.cpu.pipe.stage[1 - @intFromBool(aligned)].?));
-                const low: u32 = @truncate(u16, self.cpu.pipe.stage[@boolToInt(aligned)].?);
+                const low: u32 = @as(u16, @truncate(self.cpu.pipe.stage[@intFromBool(aligned)].?));
 
                 break :blk high << 16 | low;
             },
@@ -301,7 +301,7 @@ fn openBus(self: *const Self, comptime T: type, address: u32) T {
         }
     };
 
-    return @truncate(T, word);
+    return @truncate(word);
 }
 
 pub fn read(self: *Self, comptime T: type, unaligned_address: u32) T {
@@ -310,15 +310,14 @@ pub fn read(self: *Self, comptime T: type, unaligned_address: u32) T {
     const offset = unaligned_address & (page_size - 1);
 
     // whether or not we do this in slowmem or fastmem, we should advance the scheduler
-    self.sched.tick += timings[@boolToInt(T == u32)][@truncate(u4, unaligned_address >> 24)];
+    self.sched.tick += timings[@intFromBool(T == u32)][@as(u4, @truncate(unaligned_address >> 24))];
 
     // We're doing some serious out-of-bounds open-bus reads
     if (page >= table_len) return self.openBus(T, unaligned_address);
 
     if (self.read_table[page]) |some_ptr| {
         // We have a pointer to a page, cast the pointer to it's underlying type
-        const Ptr = [*]const T;
+        const ptr: [*]const T = @ptrCast(@alignCast(some_ptr));
-        const ptr = @ptrCast(Ptr, @alignCast(@alignOf(std.meta.Child(Ptr)), some_ptr));
 
         // Note: We don't check array length, since we force align the
         // lower bits of the address as the GBA would
@@ -338,8 +337,7 @@ pub fn dbgRead(self: *const Self, comptime T: type, unaligned_address: u32) T {
 
     if (self.read_table[page]) |some_ptr| {
         // We have a pointer to a page, cast the pointer to it's underlying type
-        const Ptr = [*]const T;
+        const ptr: [*]const T = @ptrCast(@alignCast(some_ptr));
-        const ptr = @ptrCast(Ptr, @alignCast(@alignOf(std.meta.Child(Ptr)), some_ptr));
 
         // Note: We don't check array length, since we force align the
         // lower bits of the address as the GBA would
@@ -352,7 +350,7 @@ pub fn dbgRead(self: *const Self, comptime T: type, unaligned_address: u32) T {
 fn slowRead(self: *Self, comptime T: type, unaligned_address: u32) T {
     @setCold(true);
 
-    const page = @truncate(u8, unaligned_address >> 24);
+    const page: u8 = @truncate(unaligned_address >> 24);
     const address = forceAlign(T, unaligned_address);
 
     return switch (page) {
@@ -380,7 +378,7 @@ fn slowRead(self: *Self, comptime T: type, unaligned_address: u32) T {
 }
 
 fn dbgSlowRead(self: *const Self, comptime T: type, unaligned_address: u32) T {
-    const page = @truncate(u8, unaligned_address >> 24);
+    const page: u8 = @truncate(unaligned_address >> 24);
     const address = forceAlign(T, unaligned_address);
 
     return switch (page) {
@@ -426,22 +424,21 @@ pub fn write(self: *Self, comptime T: type, unaligned_address: u32, value: T) vo
     const offset = unaligned_address & (page_size - 1);
 
     // whether or not we do this in slowmem or fastmem, we should advance the scheduler
-    self.sched.tick += timings[@boolToInt(T == u32)][@truncate(u4, unaligned_address >> 24)];
+    self.sched.tick += timings[@intFromBool(T == u32)][@as(u4, @truncate(unaligned_address >> 24))];
 
     // We're doing some serious out-of-bounds open-bus writes, they do nothing though
     if (page >= table_len) return;
 
-    if (self.write_tables[@boolToInt(T == u8)][page]) |some_ptr| {
+    if (self.write_tables[@intFromBool(T == u8)][page]) |some_ptr| {
         // We have a pointer to a page, cast the pointer to it's underlying type
-        const Ptr = [*]T;
+        const ptr: [*]T = @ptrCast(@alignCast(some_ptr));
-        const ptr = @ptrCast(Ptr, @alignCast(@alignOf(std.meta.Child(Ptr)), some_ptr));
 
         // Note: We don't check array length, since we force align the
         // lower bits of the address as the GBA would
         ptr[forceAlign(T, offset) / @sizeOf(T)] = value;
     } else {
         // we can return early if this is an 8-bit OAM write
-        if (T == u8 and @truncate(u8, unaligned_address >> 24) == 0x07) return;
+        if (T == u8 and @as(u8, @truncate(unaligned_address >> 24)) == 0x07) return;
 
         self.slowWrite(T, unaligned_address, value);
     }
@@ -456,17 +453,16 @@ pub fn dbgWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T)
     // We're doing some serious out-of-bounds open-bus writes, they do nothing though
     if (page >= table_len) return;
 
-    if (self.write_tables[@boolToInt(T == u8)][page]) |some_ptr| {
+    if (self.write_tables[@intFromBool(T == u8)][page]) |some_ptr| {
         // We have a pointer to a page, cast the pointer to it's underlying type
-        const Ptr = [*]T;
+        const ptr: [*]T = @ptrCast(@alignCast(some_ptr));
-        const ptr = @ptrCast(Ptr, @alignCast(@alignOf(std.meta.Child(Ptr)), some_ptr));
 
         // Note: We don't check array length, since we force align the
         // lower bits of the address as the GBA would
         ptr[forceAlign(T, offset) / @sizeOf(T)] = value;
     } else {
         // we can return early if this is an 8-bit OAM write
-        if (T == u8 and @truncate(u8, unaligned_address >> 24) == 0x07) return;
+        if (T == u8 and @as(u8, @truncate(unaligned_address >> 24)) == 0x07) return;
 
         self.dbgSlowWrite(T, unaligned_address, value);
     }
@@ -475,7 +471,7 @@ pub fn dbgWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T)
 fn slowWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T) void {
     @setCold(true);
 
-    const page = @truncate(u8, unaligned_address >> 24);
+    const page: u8 = @truncate(unaligned_address >> 24);
     const address = forceAlign(T, unaligned_address);
 
     switch (page) {
@@ -492,7 +488,7 @@ fn slowWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T) vo
 
         // External Memory (Game Pak)
         0x08...0x0D => self.pak.write(T, self.dma[3].word_count, address, value),
-        0x0E...0x0F => self.pak.backup.write(unaligned_address, @truncate(u8, rotr(T, value, 8 * rotateBy(T, unaligned_address)))),
+        0x0E...0x0F => self.pak.backup.write(unaligned_address, @truncate(rotr(T, value, 8 * rotateBy(T, unaligned_address)))),
         else => {},
     }
 }
@@ -500,7 +496,7 @@ fn slowWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T) vo
 fn dbgSlowWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T) void {
     @setCold(true);
 
-    const page = @truncate(u8, unaligned_address >> 24);
+    const page: u8 = @truncate(unaligned_address >> 24);
     const address = forceAlign(T, unaligned_address);
 
     switch (page) {

src/core/apu.zig

@@ -22,7 +22,7 @@ pub const host_rate = @import("../platform.zig").sample_rate;
 pub const host_format = @import("../platform.zig").sample_format;
 
 pub fn read(comptime T: type, apu: *const Apu, addr: u32) ?T {
-    const byte_addr = @truncate(u8, addr);
+    const byte_addr: u8 = @truncate(addr);
 
     return switch (T) {
         u32 => switch (byte_addr) {
@@ -73,27 +73,27 @@ pub fn read(comptime T: type, apu: *const Apu, addr: u32) ?T {
             else => util.io.read.err(T, log, "unaligned {} read from 0x{X:0>8}", .{ T, addr }),
         },
         u8 => switch (byte_addr) {
-            0x60, 0x61 => @truncate(T, @as(u16, apu.ch1.sound1CntL()) >> getHalf(byte_addr)),
+            0x60, 0x61 => @truncate(@as(u16, apu.ch1.sound1CntL()) >> getHalf(byte_addr)),
-            0x62, 0x63 => @truncate(T, apu.ch1.sound1CntH() >> getHalf(byte_addr)),
+            0x62, 0x63 => @truncate(apu.ch1.sound1CntH() >> getHalf(byte_addr)),
-            0x64, 0x65 => @truncate(T, apu.ch1.sound1CntX() >> getHalf(byte_addr)),
+            0x64, 0x65 => @truncate(apu.ch1.sound1CntX() >> getHalf(byte_addr)),
             0x66, 0x67 => 0x00, // assuming behaviour is identical to that of 16-bit reads
-            0x68, 0x69 => @truncate(T, apu.ch2.sound2CntL() >> getHalf(byte_addr)),
+            0x68, 0x69 => @truncate(apu.ch2.sound2CntL() >> getHalf(byte_addr)),
             0x6A, 0x6B => 0x00,
-            0x6C, 0x6D => @truncate(T, apu.ch2.sound2CntH() >> getHalf(byte_addr)),
+            0x6C, 0x6D => @truncate(apu.ch2.sound2CntH() >> getHalf(byte_addr)),
             0x6E, 0x6F => 0x00,
-            0x70, 0x71 => @truncate(T, @as(u16, apu.ch3.sound3CntL()) >> getHalf(byte_addr)), // SOUND3CNT_L
+            0x70, 0x71 => @truncate(@as(u16, apu.ch3.sound3CntL()) >> getHalf(byte_addr)), // SOUND3CNT_L
-            0x72, 0x73 => @truncate(T, apu.ch3.sound3CntH() >> getHalf(byte_addr)),
+            0x72, 0x73 => @truncate(apu.ch3.sound3CntH() >> getHalf(byte_addr)),
-            0x74, 0x75 => @truncate(T, apu.ch3.sound3CntX() >> getHalf(byte_addr)), // SOUND3CNT_L
+            0x74, 0x75 => @truncate(apu.ch3.sound3CntX() >> getHalf(byte_addr)), // SOUND3CNT_L
             0x76, 0x77 => 0x00,
-            0x78, 0x79 => @truncate(T, apu.ch4.sound4CntL() >> getHalf(byte_addr)),
+            0x78, 0x79 => @truncate(apu.ch4.sound4CntL() >> getHalf(byte_addr)),
             0x7A, 0x7B => 0x00,
-            0x7C, 0x7D => @truncate(T, apu.ch4.sound4CntH() >> getHalf(byte_addr)),
+            0x7C, 0x7D => @truncate(apu.ch4.sound4CntH() >> getHalf(byte_addr)),
             0x7E, 0x7F => 0x00,
-            0x80, 0x81 => @truncate(T, apu.soundCntL() >> getHalf(byte_addr)), // SOUNDCNT_L
+            0x80, 0x81 => @truncate(apu.soundCntL() >> getHalf(byte_addr)), // SOUNDCNT_L
-            0x82, 0x83 => @truncate(T, apu.soundCntH() >> getHalf(byte_addr)), // SOUNDCNT_H
+            0x82, 0x83 => @truncate(apu.soundCntH() >> getHalf(byte_addr)), // SOUNDCNT_H
-            0x84, 0x85 => @truncate(T, @as(u16, apu.soundCntX()) >> getHalf(byte_addr)),
+            0x84, 0x85 => @truncate(@as(u16, apu.soundCntX()) >> getHalf(byte_addr)),
             0x86, 0x87 => 0x00,
-            0x88, 0x89 => @truncate(T, apu.bias.raw >> getHalf(byte_addr)), // SOUNDBIAS
+            0x88, 0x89 => @truncate(apu.bias.raw >> getHalf(byte_addr)), // SOUNDBIAS
             0x8A, 0x8B => 0x00,
             0x8C...0x8F => null,
             0x90...0x9F => apu.ch3.wave_dev.read(T, apu.ch3.select, addr),
@@ -106,7 +106,7 @@ pub fn read(comptime T: type, apu: *const Apu, addr: u32) ?T {
 }
 
 pub fn write(comptime T: type, apu: *Apu, addr: u32, value: T) void {
-    const byte_addr = @truncate(u8, addr);
+    const byte_addr: u8 = @truncate(addr);
 
     if (byte_addr <= 0x81 and !apu.cnt.apu_enable.read()) return;
 
@@ -117,20 +117,20 @@ pub fn write(comptime T: type, apu: *Apu, addr: u32, value: T) void {
 
             switch (byte_addr) {
                 0x60 => apu.ch1.setSound1Cnt(value),
-                0x64 => apu.ch1.setSound1CntX(&apu.fs, @truncate(u16, value)),
+                0x64 => apu.ch1.setSound1CntX(&apu.fs, @truncate(value)),
 
-                0x68 => apu.ch2.setSound2CntL(@truncate(u16, value)),
+                0x68 => apu.ch2.setSound2CntL(@truncate(value)),
-                0x6C => apu.ch2.setSound2CntH(&apu.fs, @truncate(u16, value)),
+                0x6C => apu.ch2.setSound2CntH(&apu.fs, @truncate(value)),
 
                 0x70 => apu.ch3.setSound3Cnt(value),
-                0x74 => apu.ch3.setSound3CntX(&apu.fs, @truncate(u16, value)),
+                0x74 => apu.ch3.setSound3CntX(&apu.fs, @truncate(value)),
 
-                0x78 => apu.ch4.setSound4CntL(@truncate(u16, value)),
+                0x78 => apu.ch4.setSound4CntL(@truncate(value)),
-                0x7C => apu.ch4.setSound4CntH(&apu.fs, @truncate(u16, value)),
+                0x7C => apu.ch4.setSound4CntH(&apu.fs, @truncate(value)),
 
                 0x80 => apu.setSoundCnt(value),
                 0x84 => apu.setSoundCntX(value >> 7 & 1 == 1),
-                0x88 => apu.bias.raw = @truncate(u16, value),
+                0x88 => apu.bias.raw = @truncate(value),
                 0x8C => {},
 
                 0x90, 0x94, 0x98, 0x9C => apu.ch3.wave_dev.write(T, apu.ch3.select, addr, value),
@@ -143,7 +143,7 @@ pub fn write(comptime T: type, apu: *Apu, addr: u32, value: T) void {
             if (byte_addr <= 0x81 and !apu.cnt.apu_enable.read()) return;
 
             switch (byte_addr) {
-                0x60 => apu.ch1.setSound1CntL(@truncate(u8, value)), // SOUND1CNT_L
+                0x60 => apu.ch1.setSound1CntL(@truncate(value)), // SOUND1CNT_L
                 0x62 => apu.ch1.setSound1CntH(value),
                 0x64 => apu.ch1.setSound1CntX(&apu.fs, value),
                 0x66 => {},
@@ -153,7 +153,7 @@ pub fn write(comptime T: type, apu: *Apu, addr: u32, value: T) void {
                 0x6C => apu.ch2.setSound2CntH(&apu.fs, value),
                 0x6E => {},
 
-                0x70 => apu.ch3.setSound3CntL(@truncate(u8, value)),
+                0x70 => apu.ch3.setSound3CntL(@truncate(value)),
                 0x72 => apu.ch3.setSound3CntH(value),
                 0x74 => apu.ch3.setSound3CntX(&apu.fs, value),
                 0x76 => {},
@@ -330,8 +330,8 @@ pub const Apu = struct {
 
     /// SOUNDCNT
     fn setSoundCnt(self: *Self, value: u32) void {
-        if (self.cnt.apu_enable.read()) self.setSoundCntL(@truncate(u16, value));
+        if (self.cnt.apu_enable.read()) self.setSoundCntL(@truncate(value));
-        self.setSoundCntH(@truncate(u16, value >> 16));
+        self.setSoundCntH(@truncate(value >> 16));
     }
 
     /// SOUNDCNT_L
@@ -384,12 +384,12 @@ pub const Apu = struct {
 
     /// NR52
     pub fn soundCntX(self: *const Self) u8 {
-        const apu_enable: u8 = @boolToInt(self.cnt.apu_enable.read());
+        const apu_enable: u8 = @intFromBool(self.cnt.apu_enable.read());
 
-        const ch1_enable: u8 = @boolToInt(self.ch1.enabled);
+        const ch1_enable: u8 = @intFromBool(self.ch1.enabled);
-        const ch2_enable: u8 = @boolToInt(self.ch2.enabled);
+        const ch2_enable: u8 = @intFromBool(self.ch2.enabled);
-        const ch3_enable: u8 = @boolToInt(self.ch3.enabled);
+        const ch3_enable: u8 = @intFromBool(self.ch3.enabled);
-        const ch4_enable: u8 = @boolToInt(self.ch4.enabled);
+        const ch4_enable: u8 = @intFromBool(self.ch4.enabled);
 
         return apu_enable << 7 | ch4_enable << 3 | ch3_enable << 2 | ch2_enable << 1 | ch1_enable;
     }
@@ -450,8 +450,8 @@ pub const Apu = struct {
         left += bias;
         right += bias;
 
-        const clamped_left = std.math.clamp(@bitCast(u16, left), std.math.minInt(u11), std.math.maxInt(u11));
+        const clamped_left = std.math.clamp(@as(u16, @bitCast(left)), 0, std.math.maxInt(u11));
-        const clamped_right = std.math.clamp(@bitCast(u16, right), std.math.minInt(u11), std.math.maxInt(u11));
+        const clamped_right = std.math.clamp(@as(u16, @bitCast(right)), 0, std.math.maxInt(u11));
 
         // Extend to 16-bit signed audio samples
         const ext_left = (clamped_left << 5) | (clamped_left >> 6);
@@ -473,7 +473,7 @@ pub const Apu = struct {
         defer SDL.SDL_FreeAudioStream(old_stream);
 
         self.sampling_cycle = self.bias.sampling_cycle.read();
-        self.stream = SDL.SDL_NewAudioStream(SDL.AUDIO_U16, 2, @intCast(c_int, sample_rate), host_format, 2, host_rate).?;
+        self.stream = SDL.SDL_NewAudioStream(SDL.AUDIO_U16, 2, @intCast(sample_rate), host_format, 2, host_rate).?;
     }
 
     fn interval(self: *const Self) u64 {
@@ -521,16 +521,16 @@ pub const Apu = struct {
     pub fn onDmaAudioSampleRequest(self: *Self, cpu: *Arm7tdmi, tim_id: u3) void {
         if (!self.cnt.apu_enable.read()) return;
 
-        const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
+        const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
 
-        if (@boolToInt(self.dma_cnt.chA_timer.read()) == tim_id) {
+        if (@intFromBool(self.dma_cnt.chA_timer.read()) == tim_id) {
             if (!self.chA.enabled) return;
 
             self.chA.updateSample();
             if (self.chA.len() <= 15) bus_ptr.dma[1].requestAudio(0x0400_00A0);
         }
 
-        if (@boolToInt(self.dma_cnt.chB_timer.read()) == tim_id) {
+        if (@intFromBool(self.dma_cnt.chB_timer.read()) == tim_id) {
             if (!self.chB.enabled) return;
 
             self.chB.updateSample();
@@ -578,11 +578,11 @@ pub fn DmaSound(comptime kind: DmaSoundKind) type {
         }
 
         pub fn updateSample(self: *Self) void {
-            if (self.fifo.readItem()) |sample| self.sample = @bitCast(i8, sample);
+            if (self.fifo.readItem()) |sample| self.sample = @bitCast(sample);
         }
 
         pub fn amplitude(self: *const Self) i16 {
-            return @as(i16, self.sample);
+            return self.sample;
         }
     };
 }

src/core/apu/Noise.zig

@@ -76,14 +76,14 @@ pub fn sound4CntL(self: *const Self) u16 {
 
 /// NR41, NR42
 pub fn setSound4CntL(self: *Self, value: u16) void {
-    self.setNr41(@truncate(u8, value));
+    self.setNr41(@truncate(value));
-    self.setNr42(@truncate(u8, value >> 8));
+    self.setNr42(@truncate(value >> 8));
 }
 
 /// NR41
 pub fn setNr41(self: *Self, len: u8) void {
-    self.len = @truncate(u6, len);
+    self.len = @truncate(len);
-    self.len_dev.timer = @as(u7, 64) - @truncate(u6, len);
+    self.len_dev.timer = @as(u7, 64) - self.len;
 }
 
 /// NR42
@@ -99,8 +99,8 @@ pub fn sound4CntH(self: *const Self) u16 {
 
 /// NR43, NR44
 pub fn setSound4CntH(self: *Self, fs: *const FrameSequencer, value: u16) void {
-    self.poly.raw = @truncate(u8, value);
+    self.poly.raw = @truncate(value);
-    self.setNr44(fs, @truncate(u8, value >> 8));
+    self.setNr44(fs, @truncate(value >> 8));
 }
 
 /// NR44

src/core/apu/Tone.zig

@@ -77,14 +77,14 @@ pub fn sound2CntL(self: *const Self) u16 {
 
 /// NR21, NR22
 pub fn setSound2CntL(self: *Self, value: u16) void {
-    self.setNr21(@truncate(u8, value));
+    self.setNr21(@truncate(value));
-    self.setNr22(@truncate(u8, value >> 8));
+    self.setNr22(@truncate(value >> 8));
 }
 
 /// NR21
 pub fn setNr21(self: *Self, value: u8) void {
     self.duty.raw = value;
-    self.len_dev.timer = @as(u7, 64) - @truncate(u6, value);
+    self.len_dev.timer = @as(u7, 64) - @as(u6, @truncate(value));
 }
 
 /// NR22
@@ -100,8 +100,8 @@ pub fn sound2CntH(self: *const Self) u16 {
 
 /// NR23, NR24
 pub fn setSound2CntH(self: *Self, fs: *const FrameSequencer, value: u16) void {
-    self.setNr23(@truncate(u8, value));
+    self.setNr23(@truncate(value));
-    self.setNr24(fs, @truncate(u8, value >> 8));
+    self.setNr24(fs, @truncate(value >> 8));
 }
 
 /// NR23

src/core/apu/ToneSweep.zig

@@ -81,8 +81,8 @@ pub fn onToneSweepEvent(self: *Self, late: u64) void {
 
 /// NR10, NR11, NR12
 pub fn setSound1Cnt(self: *Self, value: u32) void {
-    self.setSound1CntL(@truncate(u8, value));
+    self.setSound1CntL(@truncate(value));
-    self.setSound1CntH(@truncate(u16, value >> 16));
+    self.setSound1CntH(@truncate(value >> 16));
 }
 
 /// NR10
@@ -111,14 +111,14 @@ pub fn sound1CntH(self: *const Self) u16 {
 
 /// NR11, NR12
 pub fn setSound1CntH(self: *Self, value: u16) void {
-    self.setNr11(@truncate(u8, value));
+    self.setNr11(@truncate(value));
-    self.setNr12(@truncate(u8, value >> 8));
+    self.setNr12(@truncate(value >> 8));
 }
 
 /// NR11
 pub fn setNr11(self: *Self, value: u8) void {
     self.duty.raw = value;
-    self.len_dev.timer = @as(u7, 64) - @truncate(u6, value);
+    self.len_dev.timer = @as(u7, 64) - @as(u6, @truncate(value));
 }
 
 /// NR12
@@ -134,8 +134,8 @@ pub fn sound1CntX(self: *const Self) u16 {
 
 /// NR13, NR14
 pub fn setSound1CntX(self: *Self, fs: *const FrameSequencer, value: u16) void {
-    self.setNr13(@truncate(u8, value));
+    self.setNr13(@truncate(value));
-    self.setNr14(fs, @truncate(u8, value >> 8));
+    self.setNr14(fs, @truncate(value >> 8));
 }
 
 /// NR13

src/core/apu/Wave.zig

@@ -64,8 +64,8 @@ pub fn tick(self: *Self, comptime kind: Tick) void {
 
 /// NR30, NR31, NR32
 pub fn setSound3Cnt(self: *Self, value: u32) void {
-    self.setSound3CntL(@truncate(u8, value));
+    self.setSound3CntL(@truncate(value));
-    self.setSound3CntH(@truncate(u16, value >> 16));
+    self.setSound3CntH(@truncate(value >> 16));
 }
 
 /// NR30
@@ -86,8 +86,8 @@ pub fn sound3CntH(self: *const Self) u16 {
 
 /// NR31, NR32
 pub fn setSound3CntH(self: *Self, value: u16) void {
-    self.setNr31(@truncate(u8, value));
+    self.setNr31(@truncate(value));
-    self.vol.raw = (@truncate(u8, value >> 8));
+    self.vol.raw = @truncate(value >> 8);
 }
 
 /// NR31
@@ -98,8 +98,8 @@ pub fn setNr31(self: *Self, len: u8) void {
 
 /// NR33, NR34
 pub fn setSound3CntX(self: *Self, fs: *const FrameSequencer, value: u16) void {
-    self.setNr33(@truncate(u8, value));
+    self.setNr33(@truncate(value));
-    self.setNr34(fs, @truncate(u8, value >> 8));
+    self.setNr34(fs, @truncate(value >> 8));
 }
 
 /// NR33, NR34

src/core/apu/device/Sweep.zig

@@ -28,8 +28,8 @@ pub fn tick(self: *Self, ch1: *ToneSweep) void {
             const new_freq = self.calculate(ch1.sweep, &ch1.enabled);
 
             if (new_freq <= 0x7FF and ch1.sweep.shift.read() != 0) {
-                ch1.freq.frequency.write(@truncate(u11, new_freq));
+                ch1.freq.frequency.write(@as(u11, @truncate(new_freq)));
-                self.shadow = @truncate(u11, new_freq);
+                self.shadow = @truncate(new_freq);
 
                 _ = self.calculate(ch1.sweep, &ch1.enabled);
             }

src/core/apu/signal/Wave.zig

@@ -18,7 +18,7 @@ pub fn read(self: *const Self, comptime T: type, nr30: io.WaveSelect, addr: u32)
     const base = if (!nr30.bank.read()) @as(u32, 0x10) else 0; // Read from the Opposite Bank in Use
 
     const i = base + addr - 0x0400_0090;
-    return std.mem.readIntSliceLittle(T, self.buf[i..][0..@sizeOf(T)]);
+    return std.mem.readInt(T, self.buf[i..][0..@sizeOf(T)], .little);
 }
 
 pub fn write(self: *Self, comptime T: type, nr30: io.WaveSelect, addr: u32, value: T) void {
@@ -26,7 +26,7 @@ pub fn write(self: *Self, comptime T: type, nr30: io.WaveSelect, addr: u32, valu
     const base = if (!nr30.bank.read()) @as(u32, 0x10) else 0; // Write to the Opposite Bank in Use
 
     const i = base + addr - 0x0400_0090;
-    std.mem.writeIntSliceLittle(T, self.buf[i..][0..@sizeOf(T)], value);
+    std.mem.writeInt(T, self.buf[i..][0..@sizeOf(T)], value, .little);
 }
 
 pub fn init(sched: *Scheduler) Self {
@@ -70,7 +70,7 @@ pub fn sample(self: *const Self, nr30: io.WaveSelect) u4 {
     const base = if (nr30.bank.read()) @as(u32, 0x10) else 0;
 
     const value = self.buf[base + self.offset / 2];
-    return if (self.offset & 1 == 0) @truncate(u4, value >> 4) else @truncate(u4, value);
+    return if (self.offset & 1 == 0) @truncate(value >> 4) else @truncate(value);
 }
 
 /// TODO: Write comment

src/core/bus/Bios.zig

@@ -27,7 +27,7 @@ pub fn read(self: *Self, comptime T: type, r15: u32, address: u32) T {
     log.warn("Open Bus! Read from 0x{X:0>8}, but PC was 0x{X:0>8}", .{ address, r15 });
     const value = self._read(u32, self.addr_latch);
 
-    return @truncate(T, rotr(u32, value, 8 * rotateBy(T, address)));
+    return @truncate(rotr(u32, value, 8 * rotateBy(T, address)));
 }
 
 fn rotateBy(comptime T: type, address: u32) u32 {
@@ -43,7 +43,7 @@ pub fn dbgRead(self: *const Self, comptime T: type, r15: u32, address: u32) T {
     if (r15 < Self.size) return self._read(T, forceAlign(T, address));
 
     const value = self._read(u32, self.addr_latch);
-    return @truncate(T, rotr(u32, value, 8 * rotateBy(T, address)));
+    return @truncate(rotr(u32, value, 8 * rotateBy(T, address)));
 }
 
 /// Read without the GBA safety checks
@@ -51,7 +51,7 @@ fn _read(self: *const Self, comptime T: type, addr: u32) T {
     const buf = self.buf orelse std.debug.panic("[BIOS] ZBA tried to read {} from 0x{X:0>8} but not BIOS was present", .{ T, addr });
 
     return switch (T) {
-        u32, u16, u8 => std.mem.readIntSliceLittle(T, buf[addr..][0..@sizeOf(T)]),
+        u32, u16, u8 => std.mem.readInt(T, buf[addr..][0..@sizeOf(T)], .little),
         else => @compileError("BIOS: Unsupported read width"),
     };
 }

src/core/bus/Ewram.zig

@@ -11,7 +11,7 @@ pub fn read(self: *const Self, comptime T: type, address: usize) T {
     const addr = address & 0x3FFFF;
 
     return switch (T) {
-        u32, u16, u8 => std.mem.readIntSliceLittle(T, self.buf[addr..][0..@sizeOf(T)]),
+        u32, u16, u8 => std.mem.readInt(T, self.buf[addr..][0..@sizeOf(T)], .little),
         else => @compileError("EWRAM: Unsupported read width"),
     };
 }
@@ -20,7 +20,7 @@ pub fn write(self: *const Self, comptime T: type, address: usize, value: T) void
     const addr = address & 0x3FFFF;
 
     return switch (T) {
-        u32, u16, u8 => std.mem.writeIntSliceLittle(T, self.buf[addr..][0..@sizeOf(T)], value),
+        u32, u16, u8 => std.mem.writeInt(T, self.buf[addr..][0..@sizeOf(T)], value, .little),
         else => @compileError("EWRAM: Unsupported write width"),
     };
 }

src/core/bus/GamePak.zig

@@ -30,7 +30,7 @@ pub fn read(self: *Self, comptime T: type, address: u32) T {
             // Addresses 0x0D00_0000 to 0x0DFF_FFFF are reserved for EEPROM accesses if
             // * Backup type is EEPROM
             // * Small ROM (less than 16MB)
-            if (@truncate(u8, address >> 24) == 0x0D)
+            if (@as(u8, @truncate(address >> 24)) == 0x0D)
                 return self.backup.eeprom.read();
         }
     }
@@ -77,7 +77,7 @@ inline fn get(self: *const Self, i: u32) u8 {
     if (i < self.buf.len) return self.buf[i];
 
     const lhs = i >> 1 & 0xFFFF;
-    return @truncate(u8, lhs >> 8 * @truncate(u5, i & 1));
+    return @truncate(lhs >> 8 * @as(u5, @truncate(i & 1)));
 }
 
 pub fn dbgRead(self: *const Self, comptime T: type, address: u32) T {
@@ -94,7 +94,7 @@ pub fn dbgRead(self: *const Self, comptime T: type, address: u32) T {
             // Addresses 0x0D00_0000 to 0x0DFF_FFFF are reserved for EEPROM accesses if
             // * Backup type is EEPROM
             // * Small ROM (less than 16MB)
-            if (@truncate(u8, address >> 24) == 0x0D)
+            if (@as(u8, @truncate(address >> 24)) == 0x0D)
                 return self.backup.eeprom.dbgRead();
         }
     }
@@ -139,7 +139,7 @@ pub fn write(self: *Self, comptime T: type, word_count: u16, address: u32, value
     const addr = address & 0x1FF_FFFF;
 
     if (self.backup.kind == .Eeprom) {
-        const bit = @truncate(u1, value);
+        const bit: u1 = @truncate(value);
 
         if (self.buf.len > 0x100_0000) { // Large
             // Addresses 0x1FF_FF00 to 0x1FF_FFFF are reserved from EEPROM accesses if
@@ -151,7 +151,7 @@ pub fn write(self: *Self, comptime T: type, word_count: u16, address: u32, value
             // Addresses 0x0D00_0000 to 0x0DFF_FFFF are reserved for EEPROM accesses if
             // * Backup type is EEPROM
             // * Small ROM (less than 16MB)
-            if (@truncate(u8, address >> 24) == 0x0D)
+            if (@as(u8, @truncate(address >> 24)) == 0x0D)
                 return self.backup.eeprom.write(word_count, &self.backup.buf, bit);
         }
     }
@@ -159,19 +159,19 @@ pub fn write(self: *Self, comptime T: type, word_count: u16, address: u32, value
     switch (T) {
         u32 => switch (address) {
             0x0800_00C4 => {
-                self.gpio.write(.Data, @truncate(u4, value));
+                self.gpio.write(.Data, @as(u4, @truncate(value)));
-                self.gpio.write(.Direction, @truncate(u4, value >> 16));
+                self.gpio.write(.Direction, @as(u4, @truncate(value >> 16)));
             },
             0x0800_00C6 => {
-                self.gpio.write(.Direction, @truncate(u4, value));
+                self.gpio.write(.Direction, @as(u4, @truncate(value)));
-                self.gpio.write(.Control, @truncate(u1, value >> 16));
+                self.gpio.write(.Control, @as(u1, @truncate(value >> 16)));
             },
             else => log.err("Wrote {} 0x{X:0>8} to 0x{X:0>8}, Unhandled", .{ T, value, address }),
         },
         u16 => switch (address) {
-            0x0800_00C4 => self.gpio.write(.Data, @truncate(u4, value)),
+            0x0800_00C4 => self.gpio.write(.Data, @as(u4, @truncate(value))),
-            0x0800_00C6 => self.gpio.write(.Direction, @truncate(u4, value)),
+            0x0800_00C6 => self.gpio.write(.Direction, @as(u4, @truncate(value))),
-            0x0800_00C8 => self.gpio.write(.Control, @truncate(u1, value)),
+            0x0800_00C8 => self.gpio.write(.Control, @as(u1, @truncate(value))),
             else => log.err("Wrote {} 0x{X:0>4} to 0x{X:0>8}, Unhandled", .{ T, value, address }),
         },
         u8 => log.debug("Wrote {} 0x{X:0>2} to 0x{X:0>8}, Ignored.", .{ T, value, address }),

src/core/bus/Iwram.zig

@@ -11,7 +11,7 @@ pub fn read(self: *const Self, comptime T: type, address: usize) T {
     const addr = address & 0x7FFF;
 
     return switch (T) {
-        u32, u16, u8 => std.mem.readIntSliceLittle(T, self.buf[addr..][0..@sizeOf(T)]),
+        u32, u16, u8 => std.mem.readInt(T, self.buf[addr..][0..@sizeOf(T)], .little),
         else => @compileError("IWRAM: Unsupported read width"),
     };
 }
@@ -20,7 +20,7 @@ pub fn write(self: *const Self, comptime T: type, address: usize, value: T) void
     const addr = address & 0x7FFF;
 
     return switch (T) {
-        u32, u16, u8 => std.mem.writeIntSliceLittle(T, self.buf[addr..][0..@sizeOf(T)], value),
+        u32, u16, u8 => std.mem.writeInt(T, self.buf[addr..][0..@sizeOf(T)], value, .little),
         else => @compileError("IWRAM: Unsupported write width"),
     };
 }

src/core/bus/backup.zig

@@ -77,7 +77,7 @@ pub const Backup = struct {
 
                 switch (addr) {
                     0x0000 => if (self.kind == .Flash1M and self.flash.set_bank) {
-                        self.flash.bank = @truncate(u1, byte);
+                        self.flash.bank = @truncate(byte);
                     },
                     0x5555 => {
                         if (self.flash.state == .Command) {

src/core/bus/backup/eeprom.zig

@@ -108,7 +108,7 @@ pub const Eeprom = struct {
         switch (self.state) {
             .Ready => {
                 if (self.writer.len() == 2) {
-                    const req = @intCast(u2, self.writer.finish());
+                    const req: u2 = @intCast(self.writer.finish());
                     switch (req) {
                         0b11 => self.state = .Read,
                         0b10 => self.state = .Write,
@@ -120,8 +120,8 @@ pub const Eeprom = struct {
                 switch (self.kind) {
                     .Large => {
                         if (self.writer.len() == 14) {
-                            const addr = @intCast(u10, self.writer.finish());
+                            const addr: u10 = @intCast(self.writer.finish());
-                            const value = std.mem.readIntSliceLittle(u64, buf[@as(u13, addr) * 8 ..][0..8]);
+                            const value = std.mem.readInt(u64, buf[@as(u13, addr) * 8 ..][0..8], .little);
 
                             self.reader.configure(value);
                             self.state = .RequestEnd;
@@ -130,8 +130,8 @@ pub const Eeprom = struct {
                     .Small => {
                         if (self.writer.len() == 6) {
                             // FIXME: Duplicated code from above
-                            const addr = @intCast(u6, self.writer.finish());
+                            const addr: u6 = @intCast(self.writer.finish());
-                            const value = std.mem.readIntSliceLittle(u64, buf[@as(u13, addr) * 8 ..][0..8]);
+                            const value = std.mem.readInt(u64, buf[@as(u13, addr) * 8 ..][0..8], .little);
 
                             self.reader.configure(value);
                             self.state = .RequestEnd;
@@ -144,13 +144,13 @@ pub const Eeprom = struct {
                 switch (self.kind) {
                     .Large => {
                         if (self.writer.len() == 14) {
-                            self.addr = @intCast(u10, self.writer.finish());
+                            self.addr = @as(u10, @intCast(self.writer.finish()));
                             self.state = .WriteTransfer;
                         }
                     },
                     .Small => {
                         if (self.writer.len() == 6) {
-                            self.addr = @intCast(u6, self.writer.finish());
+                            self.addr = @as(u6, @intCast(self.writer.finish()));
                             self.state = .WriteTransfer;
                         }
                     },
@@ -159,7 +159,7 @@ pub const Eeprom = struct {
             },
             .WriteTransfer => {
                 if (self.writer.len() == 64) {
-                    std.mem.writeIntSliceLittle(u64, buf[self.addr * 8 ..][0..8], self.writer.finish());
+                    std.mem.writeInt(u64, buf[self.addr * 8 ..][0..8], self.writer.finish(), .little);
                     self.state = .RequestEnd;
                 }
             },
@@ -186,11 +186,9 @@ const Reader = struct {
     fn read(self: *Self) u1 {
         if (!self.enabled) return 1;
 
-        const bit = if (self.i < 4) blk: {
+        const bit: u1 = if (self.i < 4) 0 else blk: {
-            break :blk 0;
+            const idx: u6 = @intCast(63 - (self.i - 4));
-        } else blk: {
+            break :blk @truncate(self.data >> idx);
-            const idx = @intCast(u6, 63 - (self.i - 4));
-            break :blk @truncate(u1, self.data >> idx);
         };
 
         self.i = (self.i + 1) % (64 + 4);
@@ -202,11 +200,11 @@ const Reader = struct {
     fn dbgRead(self: *const Self) u1 {
         if (!self.enabled) return 1;
 
-        const bit = if (self.i < 4) blk: {
+        const bit: u1 = if (self.i < 4) blk: {
             break :blk 0;
         } else blk: {
-            const idx = @intCast(u6, 63 - (self.i - 4));
+            const idx: u6 = @intCast(63 - (self.i - 4));
-            break :blk @truncate(u1, self.data >> idx);
+            break :blk @truncate(self.data >> idx);
         };
 
         return bit;
@@ -230,7 +228,7 @@ const Writer = struct {
     }
 
     fn requestWrite(self: *Self, bit: u1) void {
-        const idx = @intCast(u1, 1 - self.i);
+        const idx: u1 = @intCast(1 - self.i);
         self.data = (self.data & ~(@as(u64, 1) << idx)) | (@as(u64, bit) << idx);
         self.i += 1;
     }
@@ -244,13 +242,13 @@ const Writer = struct {
             .Unknown => unreachable,
         };
 
-        const idx = @intCast(u4, size - self.i);
+        const idx: u4 = @intCast(size - self.i);
         self.data = (self.data & ~(@as(u64, 1) << idx)) | (@as(u64, bit) << idx);
         self.i += 1;
     }
 
     fn dataWrite(self: *Self, bit: u1) void {
-        const idx = @intCast(u6, 63 - self.i);
+        const idx: u6 = @intCast(63 - self.i);
         self.data = (self.data & ~(@as(u64, 1) << idx)) | (@as(u64, bit) << idx);
         self.i += 1;
     }

src/core/bus/dma.zig

@@ -20,7 +20,7 @@ pub fn create() DmaTuple {
 }
 
 pub fn read(comptime T: type, dma: *const DmaTuple, addr: u32) ?T {
-    const byte_addr = @truncate(u8, addr);
+    const byte_addr: u8 = @truncate(addr);
 
     return switch (T) {
         u32 => switch (byte_addr) {
@@ -55,19 +55,19 @@ pub fn read(comptime T: type, dma: *const DmaTuple, addr: u32) ?T {
         u8 => switch (byte_addr) {
             0xB0...0xB7 => null, // DMA0SAD, DMA0DAD
             0xB8, 0xB9 => 0x00, // DMA0CNT_L
-            0xBA, 0xBB => @truncate(T, dma.*[0].dmacntH() >> getHalf(byte_addr)),
+            0xBA, 0xBB => @truncate(dma.*[0].dmacntH() >> getHalf(byte_addr)),
 
             0xBC...0xC3 => null, // DMA1SAD, DMA1DAD
             0xC4, 0xC5 => 0x00, // DMA1CNT_L
-            0xC6, 0xC7 => @truncate(T, dma.*[1].dmacntH() >> getHalf(byte_addr)),
+            0xC6, 0xC7 => @truncate(dma.*[1].dmacntH() >> getHalf(byte_addr)),
 
             0xC8...0xCF => null, // DMA2SAD, DMA2DAD
             0xD0, 0xD1 => 0x00, // DMA2CNT_L
-            0xD2, 0xD3 => @truncate(T, dma.*[2].dmacntH() >> getHalf(byte_addr)),
+            0xD2, 0xD3 => @truncate(dma.*[2].dmacntH() >> getHalf(byte_addr)),
 
             0xD4...0xDB => null, // DMA3SAD, DMA3DAD
             0xDC, 0xDD => 0x00, // DMA3CNT_L
-            0xDE, 0xDF => @truncate(T, dma.*[3].dmacntH() >> getHalf(byte_addr)),
+            0xDE, 0xDF => @truncate(dma.*[3].dmacntH() >> getHalf(byte_addr)),
             else => util.io.read.err(T, log, "unexpected {} read from 0x{X:0>8}", .{ T, addr }),
         },
         else => @compileError("DMA: Unsupported read width"),
@@ -75,7 +75,7 @@ pub fn read(comptime T: type, dma: *const DmaTuple, addr: u32) ?T {
 }
 
 pub fn write(comptime T: type, dma: *DmaTuple, addr: u32, value: T) void {
-    const byte_addr = @truncate(u8, addr);
+    const byte_addr: u8 = @truncate(addr);
 
     switch (T) {
         u32 => switch (byte_addr) {
@@ -209,7 +209,7 @@ fn DmaController(comptime id: u2) type {
         }
 
         pub fn setDmacntL(self: *Self, halfword: u16) void {
-            self.word_count = @truncate(@TypeOf(self.word_count), halfword);
+            self.word_count = @truncate(halfword);
         }
 
         pub fn dmacntH(self: *const Self) u16 {
@@ -233,16 +233,16 @@ fn DmaController(comptime id: u2) type {
         }
 
         pub fn setDmacnt(self: *Self, word: u32) void {
-            self.setDmacntL(@truncate(u16, word));
+            self.setDmacntL(@truncate(word));
-            self.setDmacntH(@truncate(u16, word >> 16));
+            self.setDmacntH(@truncate(word >> 16));
         }
 
         pub fn step(self: *Self, cpu: *Arm7tdmi) void {
-            const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
+            const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
 
             const is_fifo = (id == 1 or id == 2) and self.cnt.start_timing.read() == 0b11;
-            const sad_adj = @intToEnum(Adjustment, self.cnt.sad_adj.read());
+            const sad_adj: Adjustment = @enumFromInt(self.cnt.sad_adj.read());
-            const dad_adj = if (is_fifo) .Fixed else @intToEnum(Adjustment, self.cnt.dad_adj.read());
+            const dad_adj: Adjustment = if (is_fifo) .Fixed else @enumFromInt(self.cnt.dad_adj.read());
 
             const transfer_type = is_fifo or self.cnt.transfer_type.read();
             const offset: u32 = if (transfer_type) @sizeOf(u32) else @sizeOf(u16);
@@ -260,10 +260,10 @@ fn DmaController(comptime id: u2) type {
                     self.data_latch = value << 16 | value;
                 }
 
-                cpu.bus.write(u16, dad_addr, @truncate(u16, rotr(u32, self.data_latch, 8 * (dad_addr & 3))));
+                cpu.bus.write(u16, dad_addr, @as(u16, @truncate(rotr(u32, self.data_latch, 8 * (dad_addr & 3)))));
             }
 
-            switch (@truncate(u8, sad_addr >> 24)) {
+            switch (@as(u8, @truncate(sad_addr >> 24))) {
                 // according to fleroviux, DMAs with a source address in ROM misbehave
                 // the resultant behaviour is that the source address will increment despite what DMAXCNT says
                 0x08...0x0D => self.sad_latch +%= offset, // obscure behaviour
@@ -321,7 +321,7 @@ fn DmaController(comptime id: u2) type {
             // Reload internal DAD latch if we are in IncrementRelaod
             if (self.in_progress) {
                 self._word_count = if (self.word_count == 0) std.math.maxInt(@TypeOf(self._word_count)) else self.word_count;
-                if (@intToEnum(Adjustment, self.cnt.dad_adj.read()) == .IncrementReload) self.dad_latch = self.dad;
+                if (@as(Adjustment, @enumFromInt(self.cnt.dad_adj.read())) == .IncrementReload) self.dad_latch = self.dad;
             }
         }
 

src/core/bus/gpio.zig

@@ -31,8 +31,8 @@ pub const Gpio = struct {
         fn step(self: *Device, value: u4) u4 {
             return switch (self.kind) {
                 .Rtc => blk: {
-                    const clock = @ptrCast(*Clock, @alignCast(@alignOf(*Clock), self.ptr.?));
+                    const clock: *Clock = @ptrCast(@alignCast(self.ptr.?));
-                    break :blk clock.step(Clock.Data{ .raw = value });
+                    break :blk clock.step(.{ .raw = value });
                 },
                 .None => value,
             };
@@ -94,7 +94,7 @@ pub const Gpio = struct {
 
     pub fn deinit(self: *Self, allocator: Allocator) void {
         switch (self.device.kind) {
-            .Rtc => allocator.destroy(@ptrCast(*Clock, @alignCast(@alignOf(*Clock), self.device.ptr.?))),
+            .Rtc => allocator.destroy(@as(*Clock, @ptrCast(@alignCast(self.device.ptr.?)))),
             .None => {},
         }
 
@@ -146,16 +146,16 @@ pub const Clock = struct {
         /// 2. A `count`, which keeps track of which byte is currently being read
         /// 3. An index, which keeps track of which bit of the byte determined by `count` is being read
         fn read(self: *Reader, clock: *const Clock, register: Register) u1 {
-            const idx = @intCast(u3, self.i);
+            const idx: u3 = @intCast(self.i);
             defer self.i += 1;
 
             // FIXME: What do I do about the unused bits?
             return switch (register) {
-                .Control => @truncate(u1, switch (self.count) {
+                .Control => @truncate(switch (self.count) {
                     0 => clock.cnt.raw >> idx,
                     else => std.debug.panic("Tried to read from byte #{} of {} (hint: there's only 1 byte)", .{ self.count, register }),
                 }),
-                .DateTime => @truncate(u1, switch (self.count) {
+                .DateTime => @truncate(switch (self.count) {
                     // Date
                     0 => clock.year >> idx,
                     1 => @as(u8, clock.month) >> idx,
@@ -168,7 +168,7 @@ pub const Clock = struct {
                     6 => @as(u8, clock.second) >> idx,
                     else => std.debug.panic("Tried to read from byte #{} of {} (hint: there's only 7 bytes)", .{ self.count, register }),
                 }),
-                .Time => @truncate(u1, switch (self.count) {
+                .Time => @truncate(switch (self.count) {
                     0 => @as(u8, clock.hour) >> idx,
                     1 => @as(u8, clock.minute) >> idx,
                     2 => @as(u8, clock.second) >> idx,
@@ -207,7 +207,7 @@ pub const Clock = struct {
 
         /// Append a bit to the internal bit buffer (aka an integer)
         fn push(self: *Writer, value: u1) void {
-            const idx = @intCast(u3, self.i);
+            const idx: u3 = @intCast(self.i);
             self.buf = (self.buf & ~(@as(u8, 1) << idx)) | @as(u8, value) << idx;
             self.i += 1;
         }
@@ -290,22 +290,22 @@ pub const Clock = struct {
             .gpio = gpio, // Can't use Arm7tdmi ptr b/c not initialized yet
         };
 
-        const sched_ptr = @ptrCast(*Scheduler, @alignCast(@alignOf(Scheduler), cpu.sched.ptr));
+        const sched_ptr: *Scheduler = @ptrCast(@alignCast(cpu.sched.ptr));
         sched_ptr.push(.RealTimeClock, 1 << 24); // Every Second
     }
 
     pub fn onClockUpdate(self: *Self, late: u64) void {
-        const sched_ptr = @ptrCast(*Scheduler, @alignCast(@alignOf(Scheduler), self.cpu.sched.ptr));
+        const sched_ptr: *Scheduler = @ptrCast(@alignCast(self.cpu.sched.ptr));
         sched_ptr.push(.RealTimeClock, (1 << 24) -| late); // Reschedule
 
         const now = DateTime.now();
-        self.year = bcd(@intCast(u8, now.date.year - 2000));
+        self.year = bcd(@intCast(now.date.year - 2000));
-        self.month = @truncate(u5, bcd(now.date.month));
+        self.month = @truncate(bcd(now.date.month));
-        self.day = @truncate(u6, bcd(now.date.day));
+        self.day = @truncate(bcd(now.date.day));
-        self.weekday = @truncate(u3, bcd((now.date.weekday() + 1) % 7)); // API is Monday = 0, Sunday = 6. We want Sunday = 0, Saturday = 6
+        self.weekday = @truncate(bcd((now.date.weekday() + 1) % 7)); // API is Monday = 0, Sunday = 6. We want Sunday = 0, Saturday = 6
-        self.hour = @truncate(u6, bcd(now.time.hour));
+        self.hour = @truncate(bcd(now.time.hour));
-        self.minute = @truncate(u7, bcd(now.time.minute));
+        self.minute = @truncate(bcd(now.time.minute));
-        self.second = @truncate(u7, bcd(now.time.second));
+        self.second = @truncate(bcd(now.time.second));
     }
 
     fn step(self: *Self, value: Data) u4 {
@@ -321,14 +321,14 @@ pub const Clock = struct {
                     }
                 }
 
-                break :blk @truncate(u4, value.raw);
+                break :blk @truncate(value.raw);
             },
             .Command => blk: {
                 if (!value.cs.read()) log.err("Expected CS to be set during {}, however CS was cleared", .{self.state});
 
                 // If SCK rises, sample SIO
                 if (!cache.sck.read() and value.sck.read()) {
-                    self.writer.push(@boolToInt(value.sio.read()));
+                    self.writer.push(@intFromBool(value.sio.read()));
 
                     if (self.writer.finished()) {
                         self.state = self.processCommand(self.writer.buf);
@@ -338,14 +338,14 @@ pub const Clock = struct {
                     }
                 }
 
-                break :blk @truncate(u4, value.raw);
+                break :blk @truncate(value.raw);
             },
             .Write => |register| blk: {
                 if (!value.cs.read()) log.err("Expected CS to be set during {}, however CS was cleared", .{self.state});
 
                 // If SCK rises, sample SIO
                 if (!cache.sck.read() and value.sck.read()) {
-                    self.writer.push(@boolToInt(value.sio.read()));
+                    self.writer.push(@intFromBool(value.sio.read()));
 
                     const register_width: u32 = switch (register) {
                         .Control => 1,
@@ -364,7 +364,7 @@ pub const Clock = struct {
                     }
                 }
 
-                break :blk @truncate(u4, value.raw);
+                break :blk @truncate(value.raw);
             },
             .Read => |register| blk: {
                 if (!value.cs.read()) log.err("Expected CS to be set during {}, however CS was cleared", .{self.state});
@@ -390,7 +390,7 @@ pub const Clock = struct {
                     }
                 }
 
-                break :blk @truncate(u4, ret.raw);
+                break :blk @truncate(ret.raw);
             },
         };
     }
@@ -403,7 +403,7 @@ pub const Clock = struct {
     }
 
     fn irq(self: *Self) void {
-        const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), self.cpu.bus.ptr));
+        const bus_ptr: *Bus = @ptrCast(@alignCast(self.cpu.bus.ptr));
 
         // TODO: Confirm that this is the right behaviour
         log.debug("Force GamePak IRQ", .{});
@@ -429,7 +429,7 @@ pub const Clock = struct {
         log.debug("Handling Command 0x{X:0>2} [0b{b:0>8}]", .{ command, command });
 
         const is_write = command & 1 == 0;
-        const rtc_register = @truncate(u3, command >> 1 & 0x7);
+        const rtc_register: u3 = @truncate(command >> 1 & 0x7);
 
         if (is_write) {
             return switch (rtc_register) {

src/core/bus/io.zig

@@ -43,8 +43,8 @@ pub const Io = struct {
     }
 
     fn setIrqs(self: *Io, word: u32) void {
-        self.ie.raw = @truncate(u16, word);
+        self.ie.raw = @truncate(word);
-        self.irq.raw &= ~@truncate(u16, word >> 16);
+        self.irq.raw &= ~@as(u16, @truncate(word >> 16));
     }
 };
 
@@ -75,8 +75,8 @@ pub fn read(bus: *const Bus, comptime T: type, address: u32) ?T {
             // Interrupts
             0x0400_0200 => @as(u32, bus.io.irq.raw) << 16 | bus.io.ie.raw,
             0x0400_0204 => bus.io.waitcnt.raw,
-            0x0400_0208 => @boolToInt(bus.io.ime),
+            0x0400_0208 => @intFromBool(bus.io.ime),
-            0x0400_0300 => @enumToInt(bus.io.postflg),
+            0x0400_0300 => @intFromEnum(bus.io.postflg),
             else => util.io.read.undef(T, log, "Tried to perform a {} read to 0x{X:0>8}", .{ T, address }),
         },
         u16 => switch (address) {
@@ -96,7 +96,7 @@ pub fn read(bus: *const Bus, comptime T: type, address: u32) ?T {
             0x0400_0128 => util.io.read.todo(log, "Read {} from SIOCNT", .{T}),
 
             // Keypad Input
-            0x0400_0130 => bus.io.keyinput.load(.Monotonic),
+            0x0400_0130 => bus.io.keyinput.load(.monotonic),
 
             // Serial Communication 2
             0x0400_0134 => util.io.read.todo(log, "Read {} from RCNT", .{T}),
@@ -109,9 +109,9 @@ pub fn read(bus: *const Bus, comptime T: type, address: u32) ?T {
             0x0400_0202 => bus.io.irq.raw,
             0x0400_0204 => bus.io.waitcnt.raw,
             0x0400_0206 => 0x0000,
-            0x0400_0208 => @boolToInt(bus.io.ime),
+            0x0400_0208 => @intFromBool(bus.io.ime),
             0x0400_020A => 0x0000,
-            0x0400_0300 => @enumToInt(bus.io.postflg),
+            0x0400_0300 => @intFromEnum(bus.io.postflg),
             0x0400_0302 => 0x0000,
             else => util.io.read.undef(T, log, "Tried to perform a {} read to 0x{X:0>8}", .{ T, address }),
         },
@@ -141,13 +141,13 @@ pub fn read(bus: *const Bus, comptime T: type, address: u32) ?T {
             0x0400_015A, 0x0400_015B => 0x00,
 
             // Interrupts
-            0x0400_0200, 0x0400_0201 => @truncate(T, bus.io.ie.raw >> getHalf(@truncate(u8, address))),
+            0x0400_0200, 0x0400_0201 => @truncate(bus.io.ie.raw >> getHalf(@truncate(address))),
-            0x0400_0202, 0x0400_0203 => @truncate(T, bus.io.irq.raw >> getHalf(@truncate(u8, address))),
+            0x0400_0202, 0x0400_0203 => @truncate(bus.io.irq.raw >> getHalf(@truncate(address))),
-            0x0400_0204, 0x0400_0205 => @truncate(T, bus.io.waitcnt.raw >> getHalf(@truncate(u8, address))),
+            0x0400_0204, 0x0400_0205 => @truncate(bus.io.waitcnt.raw >> getHalf(@truncate(address))),
             0x0400_0206, 0x0400_0207 => 0x00,
-            0x0400_0208, 0x0400_0209 => @truncate(T, @as(u16, @boolToInt(bus.io.ime)) >> getHalf(@truncate(u8, address))),
+            0x0400_0208, 0x0400_0209 => @truncate(@as(u16, @intFromBool(bus.io.ime)) >> getHalf(@truncate(address))),
             0x0400_020A, 0x0400_020B => 0x00,
-            0x0400_0300 => @enumToInt(bus.io.postflg),
+            0x0400_0300 => @intFromEnum(bus.io.postflg),
             0x0400_0301 => null,
             0x0400_0302, 0x0400_0303 => 0x00,
             else => util.io.read.undef(T, log, "Tried to perform a {} read to 0x{X:0>8}", .{ T, address }),
@@ -196,10 +196,10 @@ pub fn write(bus: *Bus, comptime T: type, address: u32, value: T) void {
 
             // Interrupts
             0x0400_0200 => bus.io.setIrqs(value),
-            0x0400_0204 => bus.io.waitcnt.set(@truncate(u16, value)),
+            0x0400_0204 => bus.io.waitcnt.set(@truncate(value)),
             0x0400_0208 => bus.io.ime = value & 1 == 1,
             0x0400_0300 => {
-                bus.io.postflg = @intToEnum(PostFlag, value & 1);
+                bus.io.postflg = @enumFromInt(value & 1);
                 bus.io.haltcnt = if (value >> 15 & 1 == 0) .Halt else @panic("TODO: Implement STOP");
             },
             else => util.io.write.undef(log, "Tried to write 0x{X:0>8}{} to 0x{X:0>8}", .{ value, T, address }),
@@ -246,7 +246,7 @@ pub fn write(bus: *Bus, comptime T: type, address: u32, value: T) void {
             0x0400_0208 => bus.io.ime = value & 1 == 1,
             0x0400_020A => {},
             0x0400_0300 => {
-                bus.io.postflg = @intToEnum(PostFlag, value & 1);
+                bus.io.postflg = @enumFromInt(value & 1);
                 bus.io.haltcnt = if (value >> 15 & 1 == 0) .Halt else @panic("TODO: Implement STOP");
             },
             else => util.io.write.undef(log, "Tried to write 0x{X:0>4}{} to 0x{X:0>8}", .{ value, T, address }),
@@ -273,16 +273,16 @@ pub fn write(bus: *Bus, comptime T: type, address: u32, value: T) void {
             0x0400_0140 => log.debug("Wrote 0x{X:0>2} to JOYCNT_L", .{value}),
 
             // Interrupts
-            0x0400_0200, 0x0400_0201 => bus.io.ie.raw = setHalf(u16, bus.io.ie.raw, @truncate(u8, address), value),
+            0x0400_0200, 0x0400_0201 => bus.io.ie.raw = setHalf(u16, bus.io.ie.raw, @truncate(address), value),
             0x0400_0202 => bus.io.irq.raw &= ~@as(u16, value),
             0x0400_0203 => bus.io.irq.raw &= ~@as(u16, value) << 8, // TODO: Is this good?
-            0x0400_0204, 0x0400_0205 => bus.io.waitcnt.set(setHalf(u16, @truncate(u16, bus.io.waitcnt.raw), @truncate(u8, address), value)),
+            0x0400_0204, 0x0400_0205 => bus.io.waitcnt.set(setHalf(u16, bus.io.waitcnt.raw, @truncate(address), value)),
             0x0400_0206, 0x0400_0207 => {},
             0x0400_0208 => bus.io.ime = value & 1 == 1,
             0x0400_0209 => {},
             0x0400_020A, 0x0400_020B => {},
 
-            0x0400_0300 => bus.io.postflg = @intToEnum(PostFlag, value & 1),
+            0x0400_0300 => bus.io.postflg = @enumFromInt(value & 1),
             0x0400_0301 => bus.io.haltcnt = if (value >> 7 & 1 == 0) .Halt else std.debug.panic("TODO: Implement STOP", .{}),
 
             0x0400_0410 => log.debug("Wrote 0x{X:0>2} to the common yet undocumented 0x{X:0>8}", .{ value, address }),
@@ -382,7 +382,7 @@ pub const KeyInput = extern union {
 
 const AtomicKeyInput = struct {
     const Self = @This();
-    const Ordering = std.atomic.Ordering;
+    const AtomicOrder = std.builtin.AtomicOrder;
 
     inner: KeyInput,
 
@@ -390,18 +390,18 @@ const AtomicKeyInput = struct {
         return .{ .inner = value };
     }
 
-    pub inline fn load(self: *const Self, comptime ordering: Ordering) u16 {
+    pub inline fn load(self: *const Self, comptime ordering: AtomicOrder) u16 {
         return switch (ordering) {
-            .AcqRel, .Release => @compileError("not supported for atomic loads"),
+            .acq_rel, .release => @compileError("not supported for atomic loads"),
             else => @atomicLoad(u16, &self.inner.raw, ordering),
         };
     }
 
-    pub inline fn fetchOr(self: *Self, value: u16, comptime ordering: Ordering) void {
+    pub inline fn fetchOr(self: *Self, value: u16, comptime ordering: AtomicOrder) void {
         _ = @atomicRmw(u16, &self.inner.raw, .Or, value, ordering);
     }
 
-    pub inline fn fetchAnd(self: *Self, value: u16, comptime ordering: Ordering) void {
+    pub inline fn fetchAnd(self: *Self, value: u16, comptime ordering: AtomicOrder) void {
         _ = @atomicRmw(u16, &self.inner.raw, .And, value, ordering);
     }
 };

src/core/bus/timer.zig

@@ -19,7 +19,7 @@ pub fn create(sched: *Scheduler) TimerTuple {
 }
 
 pub fn read(comptime T: type, tim: *const TimerTuple, addr: u32) ?T {
-    const nybble_addr = @truncate(u4, addr);
+    const nybble_addr: u4 = @truncate(addr);
 
     return switch (T) {
         u32 => switch (nybble_addr) {
@@ -44,24 +44,24 @@ pub fn read(comptime T: type, tim: *const TimerTuple, addr: u32) ?T {
             else => util.io.read.err(T, log, "unaligned {} read from 0x{X:0>8}", .{ T, addr }),
         },
         u8 => switch (nybble_addr) {
-            0x0, 0x1 => @truncate(T, tim.*[0].timcntL() >> getHalf(nybble_addr)),
+            0x0, 0x1 => @truncate(tim.*[0].timcntL() >> getHalf(nybble_addr)),
-            0x2, 0x3 => @truncate(T, tim.*[0].cnt.raw >> getHalf(nybble_addr)),
+            0x2, 0x3 => @truncate(tim.*[0].cnt.raw >> getHalf(nybble_addr)),
 
-            0x4, 0x5 => @truncate(T, tim.*[1].timcntL() >> getHalf(nybble_addr)),
+            0x4, 0x5 => @truncate(tim.*[1].timcntL() >> getHalf(nybble_addr)),
-            0x6, 0x7 => @truncate(T, tim.*[1].cnt.raw >> getHalf(nybble_addr)),
+            0x6, 0x7 => @truncate(tim.*[1].cnt.raw >> getHalf(nybble_addr)),
 
-            0x8, 0x9 => @truncate(T, tim.*[2].timcntL() >> getHalf(nybble_addr)),
+            0x8, 0x9 => @truncate(tim.*[2].timcntL() >> getHalf(nybble_addr)),
-            0xA, 0xB => @truncate(T, tim.*[2].cnt.raw >> getHalf(nybble_addr)),
+            0xA, 0xB => @truncate(tim.*[2].cnt.raw >> getHalf(nybble_addr)),
 
-            0xC, 0xD => @truncate(T, tim.*[3].timcntL() >> getHalf(nybble_addr)),
+            0xC, 0xD => @truncate(tim.*[3].timcntL() >> getHalf(nybble_addr)),
-            0xE, 0xF => @truncate(T, tim.*[3].cnt.raw >> getHalf(nybble_addr)),
+            0xE, 0xF => @truncate(tim.*[3].cnt.raw >> getHalf(nybble_addr)),
         },
         else => @compileError("TIM: Unsupported read width"),
     };
 }
 
 pub fn write(comptime T: type, tim: *TimerTuple, addr: u32, value: T) void {
-    const nybble_addr = @truncate(u4, addr);
+    const nybble_addr: u4 = @truncate(addr);
 
     return switch (T) {
         u32 => switch (nybble_addr) {
@@ -141,7 +141,7 @@ fn Timer(comptime id: u2) type {
         pub fn timcntL(self: *const Self) u16 {
             if (self.cnt.cascade.read() or !self.cnt.enabled.read()) return self._counter;
 
-            return self._counter +% @truncate(u16, (self.sched.now() - self._start_timestamp) / self.frequency());
+            return self._counter +% @as(u16, @truncate((self.sched.now() - self._start_timestamp) / self.frequency()));
         }
 
         /// TIMCNT_L Setter
@@ -151,8 +151,8 @@ fn Timer(comptime id: u2) type {
 
         /// TIMCNT_L & TIMCNT_H
         pub fn setTimcnt(self: *Self, word: u32) void {
-            self.setTimcntL(@truncate(u16, word));
+            self.setTimcntL(@truncate(word));
-            self.setTimcntH(@truncate(u16, word >> 16));
+            self.setTimcntH(@truncate(word >> 16));
         }
 
         /// TIMCNT_H
@@ -167,7 +167,7 @@ fn Timer(comptime id: u2) type {
                     self.sched.removeScheduledEvent(.{ .TimerOverflow = id });
 
                     // Counter should hold the value it stopped at meaning we have to calculate it now
-                    self._counter +%= @truncate(u16, (self.sched.now() - self._start_timestamp) / self.frequency());
+                    self._counter +%= @truncate((self.sched.now() - self._start_timestamp) / self.frequency());
                 }
 
                 // the timer has always been enabled, but the cascade bit which was blocking the timer has been unset
@@ -194,7 +194,7 @@ fn Timer(comptime id: u2) type {
 
         pub fn onTimerExpire(self: *Self, cpu: *Arm7tdmi, late: u64) void {
             // Fire IRQ if enabled
-            const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
+            const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
 
             const io = &bus_ptr.io;
 

src/core/cpu_util.zig

@@ -5,13 +5,13 @@ const Bank = @import("arm32").Arm7tdmi.Bank;
 const Bus = @import("Bus.zig");
 
 pub inline fn isHalted(cpu: *const Arm7tdmi) bool {
-    const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
+    const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
 
     return bus_ptr.io.haltcnt == .Halt;
 }
 
 pub fn stepDmaTransfer(cpu: *Arm7tdmi) bool {
-    const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
+    const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
 
     inline for (0..4) |i| {
         if (bus_ptr.dma[i].in_progress) {
@@ -24,7 +24,7 @@ pub fn stepDmaTransfer(cpu: *Arm7tdmi) bool {
 }
 
 pub fn handleInterrupt(cpu: *Arm7tdmi) void {
-    const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
+    const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
     const should_handle = bus_ptr.io.ie.raw & bus_ptr.io.irq.raw;
 
     // Return if IME is disabled, CPSR I is set or there is nothing to handle
@@ -57,7 +57,7 @@ pub fn handleInterrupt(cpu: *Arm7tdmi) void {
 ///
 /// TODO: Make above notice impossible to do in code
 pub fn fastBoot(cpu: *Arm7tdmi) void {
-    const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
+    const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
     cpu.r = std.mem.zeroes([16]u32);
 
     // cpu.r[0] = 0x08000000;

src/core/emu.zig

@@ -6,15 +6,39 @@ const Scheduler = @import("scheduler.zig").Scheduler;
 const Arm7tdmi = @import("arm32").Arm7tdmi;
 const Bus = @import("Bus.zig");
 const Tracker = @import("../util.zig").FpsTracker;
-const Channel = @import("zba-util").Channel(Message, 0x100);
+const Channel = @import("../util.zig").Queue;
-
-pub const Message = enum { Pause, Resume, Quit };
 
 const stepDmaTransfer = @import("cpu_util.zig").stepDmaTransfer;
 const isHalted = @import("cpu_util.zig").isHalted;
 
 const Timer = std.time.Timer;
 
+pub const Synchro = struct {
+    const AtomicBool = std.atomic.Value(bool);
+
+    // FIXME: This Enum ends up being really LARGE!!!
+    pub const Message = union(enum) {
+        rom_path: [std.fs.MAX_PATH_BYTES]u8,
+        bios_path: [std.fs.MAX_PATH_BYTES]u8,
+        restart: void,
+    };
+
+    paused: AtomicBool = AtomicBool.init(true), // FIXME: can ui_busy and paused be the same?
+    should_quit: AtomicBool = AtomicBool.init(false),
+
+    ch: Channel(Message),
+
+    pub fn init(allocator: std.mem.Allocator) !@This() {
+        const msg_buf = try allocator.alloc(Message, 1);
+        return .{ .ch = Channel(Message).init(msg_buf) };
+    }
+
+    pub fn deinit(self: *@This(), allocator: std.mem.Allocator) void {
+        allocator.free(self.ch.inner.buf);
+        self.* = undefined;
+    }
+};
+
 /// 4 Cycles in 1 dot
 const cycles_per_dot = 4;
 
@@ -30,7 +54,7 @@ const frame_period = (std.time.ns_per_s * cycles_per_frame) / clock_rate;
 
 /// Exact Value:  59.7275005696Hz
 /// The inverse of the frame period
-pub const frame_rate: f64 = @intToFloat(f64, clock_rate) / cycles_per_frame;
+pub const frame_rate: f64 = @as(f64, @floatFromInt(clock_rate)) / cycles_per_frame;
 
 const log = std.log.scoped(.Emulation);
 
@@ -41,38 +65,34 @@ const RunKind = enum {
     LimitedFPS,
 };
 
-pub fn run(cpu: *Arm7tdmi, scheduler: *Scheduler, tracker: *Tracker, rx: Channel.Receiver) void {
+pub fn run(cpu: *Arm7tdmi, scheduler: *Scheduler, tracker: *Tracker, sync: *Synchro) void {
     const audio_sync = config.config().guest.audio_sync and !config.config().host.mute;
     if (audio_sync) log.info("Audio sync enabled", .{});
 
     if (config.config().guest.video_sync) {
-        inner(.LimitedFPS, audio_sync, cpu, scheduler, tracker, rx);
+        inner(.LimitedFPS, audio_sync, cpu, scheduler, tracker, sync);
     } else {
-        inner(.UnlimitedFPS, audio_sync, cpu, scheduler, tracker, rx);
+        inner(.UnlimitedFPS, audio_sync, cpu, scheduler, tracker, sync);
     }
 }
 
-fn inner(comptime kind: RunKind, audio_sync: bool, cpu: *Arm7tdmi, scheduler: *Scheduler, tracker: ?*Tracker, rx: Channel.Receiver) void {
+fn inner(comptime kind: RunKind, audio_sync: bool, cpu: *Arm7tdmi, scheduler: *Scheduler, tracker: ?*Tracker, sync: *Synchro) void {
     if (kind == .UnlimitedFPS or kind == .LimitedFPS) {
         std.debug.assert(tracker != null);
         log.info("FPS tracking enabled", .{});
     }
 
-    const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
+    const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
 
-    var paused: bool = false;
+    // FIXME: audioSync accesses emulator state without any guarantees
 
     switch (kind) {
         .Unlimited, .UnlimitedFPS => {
             log.info("Emulation w/out video sync", .{});
 
-            while (true) {
+            while (!sync.should_quit.load(.monotonic)) {
-                if (rx.recv()) |m| switch (m) {
+                handleChannel(cpu, &sync.ch);
-                    .Quit => break,
+                if (sync.paused.load(.monotonic)) continue;
-                    .Resume, .Pause => paused = m == .Pause,
-                };
-
-                if (paused) continue;
 
                 runFrame(scheduler, cpu);
                 audioSync(audio_sync, bus_ptr.apu.stream, &bus_ptr.apu.is_buffer_full);
@@ -85,13 +105,9 @@ fn inner(comptime kind: RunKind, audio_sync: bool, cpu: *Arm7tdmi, scheduler: *S
             var timer = Timer.start() catch @panic("failed to initalize std.timer.Timer");
             var wake_time: u64 = frame_period;
 
-            while (true) {
+            while (!sync.should_quit.load(.monotonic)) {
-                if (rx.recv()) |m| switch (m) {
+                handleChannel(cpu, &sync.ch);
-                    .Quit => break,
+                if (sync.paused.load(.monotonic)) continue;
-                    .Resume, .Pause => paused = m == .Pause,
-                };
-
-                if (paused) continue;
 
                 runFrame(scheduler, cpu);
                 const new_wake_time = videoSync(&timer, wake_time);
@@ -111,6 +127,22 @@ fn inner(comptime kind: RunKind, audio_sync: bool, cpu: *Arm7tdmi, scheduler: *S
     }
 }
 
+inline fn handleChannel(cpu: *Arm7tdmi, channel: *Channel(Synchro.Message)) void {
+    const message = channel.pop() orelse return;
+
+    switch (message) {
+        .rom_path => |path_buf| {
+            const path = std.mem.sliceTo(&path_buf, 0);
+            replaceGamepak(cpu, path) catch |e| log.err("failed to replace GamePak: {}", .{e});
+        },
+        .bios_path => |path_buf| {
+            const path = std.mem.sliceTo(&path_buf, 0);
+            replaceBios(cpu, path) catch |e| log.err("failed to replace BIOS: {}", .{e});
+        },
+        .restart => reset(cpu),
+    }
+}
+
 pub fn runFrame(sched: *Scheduler, cpu: *Arm7tdmi) void {
     const frame_end = sched.tick + cycles_per_frame;
 
@@ -197,6 +229,49 @@ pub const EmuThing = struct {
     const Interface = @import("gdbstub").Emulator;
     const Allocator = std.mem.Allocator;
 
+    pub const target =
+        \\<target version="1.0">
+        \\    <architecture>armv4t</architecture>
+        \\    <feature name="org.gnu.gdb.arm.core">
+        \\        <reg name="r0" bitsize="32" type="uint32"/>
+        \\        <reg name="r1" bitsize="32" type="uint32"/>
+        \\        <reg name="r2" bitsize="32" type="uint32"/>
+        \\        <reg name="r3" bitsize="32" type="uint32"/>
+        \\        <reg name="r4" bitsize="32" type="uint32"/>
+        \\        <reg name="r5" bitsize="32" type="uint32"/>
+        \\        <reg name="r6" bitsize="32" type="uint32"/>
+        \\        <reg name="r7" bitsize="32" type="uint32"/>
+        \\        <reg name="r8" bitsize="32" type="uint32"/>
+        \\        <reg name="r9" bitsize="32" type="uint32"/>
+        \\        <reg name="r10" bitsize="32" type="uint32"/>
+        \\        <reg name="r11" bitsize="32" type="uint32"/>
+        \\        <reg name="r12" bitsize="32" type="uint32"/>
+        \\        <reg name="sp" bitsize="32" type="data_ptr"/>
+        \\        <reg name="lr" bitsize="32"/>
+        \\        <reg name="pc" bitsize="32" type="code_ptr"/>
+        \\
+        \\        <reg name="cpsr" bitsize="32" regnum="25"/>
+        \\    </feature>
+        \\</target>
+    ;
+
+    // Game Pak SRAM isn't included
+    // TODO: Can i be more specific here?
+    pub const map =
+        \\ <memory-map version="1.0">
+        \\     <memory type="rom" start="0x00000000" length="0x00004000"/>
+        \\     <memory type="ram" start="0x02000000" length="0x00040000"/>
+        \\     <memory type="ram" start="0x03000000" length="0x00008000"/>
+        \\     <memory type="ram" start="0x04000000" length="0x00000400"/>
+        \\     <memory type="ram" start="0x05000000" length="0x00000400"/>
+        \\     <memory type="ram" start="0x06000000" length="0x00018000"/>
+        \\     <memory type="ram" start="0x07000000" length="0x00000400"/>
+        \\     <memory type="rom" start="0x08000000" length="0x02000000"/>
+        \\     <memory type="rom" start="0x0A000000" length="0x02000000"/>
+        \\     <memory type="rom" start="0x0C000000" length="0x02000000"/>
+        \\ </memory-map>
+    ;
+
     cpu: *Arm7tdmi,
     scheduler: *Scheduler,
 
@@ -248,22 +323,22 @@ pub const EmuThing = struct {
     }
 };
 
-pub fn reset(cpu: *Arm7tdmi) void {
+fn reset(cpu: *Arm7tdmi) void {
     // @breakpoint();
     cpu.sched.reset(); // Yes this is order sensitive, see the PPU reset for why
     cpu.bus.reset();
     cpu.reset();
 }
 
-pub fn replaceGamepak(cpu: *Arm7tdmi, file_path: []const u8) !void {
+fn replaceGamepak(cpu: *Arm7tdmi, file_path: []const u8) !void {
-    const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
+    const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
 
     try bus_ptr.replaceGamepak(file_path);
     reset(cpu);
 }
 
-pub fn replaceBios(cpu: *Arm7tdmi, file_path: []const u8) !void {
+fn replaceBios(cpu: *Arm7tdmi, file_path: []const u8) !void {
-    const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
+    const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
 
     const allocator = bus_ptr.bios.allocator;
     const bios_len = 0x4000;

src/core/ppu.zig

@@ -28,7 +28,7 @@ pub const height = 160;
 pub const framebuf_pitch = width * @sizeOf(u32);
 
 pub fn read(comptime T: type, ppu: *const Ppu, addr: u32) ?T {
-    const byte_addr = @truncate(u8, addr);
+    const byte_addr: u8 = @truncate(addr);
 
     return switch (T) {
         u32 => switch (byte_addr) {
@@ -69,24 +69,24 @@ pub fn read(comptime T: type, ppu: *const Ppu, addr: u32) ?T {
             else => util.io.read.err(T, log, "unaligned {} read from 0x{X:0>8}", .{ T, addr }),
         },
         u8 => switch (byte_addr) {
-            0x00, 0x01 => @truncate(T, ppu.dispcnt.raw >> getHalf(byte_addr)),
+            0x00, 0x01 => @truncate(ppu.dispcnt.raw >> getHalf(byte_addr)),
             0x02, 0x03 => null,
-            0x04, 0x05 => @truncate(T, ppu.dispstat.raw >> getHalf(byte_addr)),
+            0x04, 0x05 => @truncate(ppu.dispstat.raw >> getHalf(byte_addr)),
-            0x06, 0x07 => @truncate(T, ppu.vcount.raw >> getHalf(byte_addr)),
+            0x06, 0x07 => @truncate(ppu.vcount.raw >> getHalf(byte_addr)),
-            0x08, 0x09 => @truncate(T, ppu.bg[0].bg0Cnt() >> getHalf(byte_addr)),
+            0x08, 0x09 => @truncate(ppu.bg[0].bg0Cnt() >> getHalf(byte_addr)),
-            0x0A, 0x0B => @truncate(T, ppu.bg[1].bg1Cnt() >> getHalf(byte_addr)),
+            0x0A, 0x0B => @truncate(ppu.bg[1].bg1Cnt() >> getHalf(byte_addr)),
-            0x0C, 0x0D => @truncate(T, ppu.bg[2].cnt.raw >> getHalf(byte_addr)),
+            0x0C, 0x0D => @truncate(ppu.bg[2].cnt.raw >> getHalf(byte_addr)),
-            0x0E, 0x0F => @truncate(T, ppu.bg[3].cnt.raw >> getHalf(byte_addr)),
+            0x0E, 0x0F => @truncate(ppu.bg[3].cnt.raw >> getHalf(byte_addr)),
             0x10...0x1F => null, // BGXHOFS/VOFS
             0x20...0x2F => null, // BG2 Rot/Scaling
             0x30...0x3F => null, // BG3 Rot/Scaling
             0x40...0x47 => null, // WINXH/V Registers
-            0x48, 0x49 => @truncate(T, ppu.win.getIn() >> getHalf(byte_addr)),
+            0x48, 0x49 => @truncate(ppu.win.getIn() >> getHalf(byte_addr)),
-            0x4A, 0x4B => @truncate(T, ppu.win.getOut() >> getHalf(byte_addr)),
+            0x4A, 0x4B => @truncate(ppu.win.getOut() >> getHalf(byte_addr)),
             0x4C, 0x4D => null, // MOSAIC
             0x4E, 0x4F => null,
-            0x50, 0x51 => @truncate(T, ppu.bld.getCnt() >> getHalf(byte_addr)),
+            0x50, 0x51 => @truncate(ppu.bld.getCnt() >> getHalf(byte_addr)),
-            0x52, 0x53 => @truncate(T, ppu.bld.getAlpha() >> getHalf(byte_addr)),
+            0x52, 0x53 => @truncate(ppu.bld.getAlpha() >> getHalf(byte_addr)),
             0x54, 0x55 => null, // BLDY
             else => util.io.read.err(T, log, "unexpected {} read from 0x{X:0>8}", .{ T, addr }),
         },
@@ -95,14 +95,14 @@ pub fn read(comptime T: type, ppu: *const Ppu, addr: u32) ?T {
 }
 
 pub fn write(comptime T: type, ppu: *Ppu, addr: u32, value: T) void {
-    const byte_addr = @truncate(u8, addr); // prefixed with 0x0400_00
+    const byte_addr: u8 = @truncate(addr); // prefixed with 0x0400_00
 
     switch (T) {
         u32 => switch (byte_addr) {
-            0x00 => ppu.dispcnt.raw = @truncate(u16, value),
+            0x00 => ppu.dispcnt.raw = @truncate(value),
             0x04 => {
-                ppu.dispstat.set(@truncate(u16, value));
+                ppu.dispstat.set(@truncate(value));
-                ppu.vcount.raw = @truncate(u16, value >> 16);
+                ppu.vcount.raw = @truncate(value >> 16);
             },
             0x08 => ppu.setAdjCnts(0, value),
             0x0C => ppu.setAdjCnts(2, value),
@@ -128,10 +128,10 @@ pub fn write(comptime T: type, ppu: *Ppu, addr: u32, value: T) void {
             0x4C => log.debug("Wrote 0x{X:0>8} to MOSAIC", .{value}),
 
             0x50 => {
-                ppu.bld.cnt.raw = @truncate(u16, value);
+                ppu.bld.cnt.raw = @truncate(value);
-                ppu.bld.alpha.raw = @truncate(u16, value >> 16);
+                ppu.bld.alpha.raw = @truncate(value >> 16);
             },
-            0x54 => ppu.bld.y.raw = @truncate(u16, value),
+            0x54 => ppu.bld.y.raw = @truncate(value),
             else => util.io.write.undef(log, "Tried to write 0x{X:0>8}{} to 0x{X:0>8}", .{ value, T, addr }),
         },
         u16 => switch (byte_addr) {
@@ -154,19 +154,19 @@ pub fn write(comptime T: type, ppu: *Ppu, addr: u32, value: T) void {
             0x1C => ppu.bg[3].hofs.raw = value,
             0x1E => ppu.bg[3].vofs.raw = value,
 
-            0x20 => ppu.aff_bg[0].pa = @bitCast(i16, value),
+            0x20 => ppu.aff_bg[0].pa = @bitCast(value),
-            0x22 => ppu.aff_bg[0].pb = @bitCast(i16, value),
+            0x22 => ppu.aff_bg[0].pb = @bitCast(value),
-            0x24 => ppu.aff_bg[0].pc = @bitCast(i16, value),
+            0x24 => ppu.aff_bg[0].pc = @bitCast(value),
-            0x26 => ppu.aff_bg[0].pd = @bitCast(i16, value),
+            0x26 => ppu.aff_bg[0].pd = @bitCast(value),
-            0x28, 0x2A => ppu.aff_bg[0].x = @bitCast(i32, setHalf(u32, @bitCast(u32, ppu.aff_bg[0].x), byte_addr, value)),
+            0x28, 0x2A => ppu.aff_bg[0].x = @bitCast(setHalf(u32, @as(u32, @bitCast(ppu.aff_bg[0].x)), byte_addr, value)),
-            0x2C, 0x2E => ppu.aff_bg[0].y = @bitCast(i32, setHalf(u32, @bitCast(u32, ppu.aff_bg[0].y), byte_addr, value)),
+            0x2C, 0x2E => ppu.aff_bg[0].y = @bitCast(setHalf(u32, @as(u32, @bitCast(ppu.aff_bg[0].y)), byte_addr, value)),
 
-            0x30 => ppu.aff_bg[1].pa = @bitCast(i16, value),
+            0x30 => ppu.aff_bg[1].pa = @bitCast(value),
-            0x32 => ppu.aff_bg[1].pb = @bitCast(i16, value),
+            0x32 => ppu.aff_bg[1].pb = @bitCast(value),
-            0x34 => ppu.aff_bg[1].pc = @bitCast(i16, value),
+            0x34 => ppu.aff_bg[1].pc = @bitCast(value),
-            0x36 => ppu.aff_bg[1].pd = @bitCast(i16, value),
+            0x36 => ppu.aff_bg[1].pd = @bitCast(value),
-            0x38, 0x3A => ppu.aff_bg[1].x = @bitCast(i32, setHalf(u32, @bitCast(u32, ppu.aff_bg[1].x), byte_addr, value)),
+            0x38, 0x3A => ppu.aff_bg[1].x = @bitCast(setHalf(u32, @as(u32, @bitCast(ppu.aff_bg[1].x)), byte_addr, value)),
-            0x3C, 0x3E => ppu.aff_bg[1].y = @bitCast(i32, setHalf(u32, @bitCast(u32, ppu.aff_bg[1].y), byte_addr, value)),
+            0x3C, 0x3E => ppu.aff_bg[1].y = @bitCast(setHalf(u32, @as(u32, @bitCast(ppu.aff_bg[1].y)), byte_addr, value)),
 
             0x40 => ppu.win.h[0].raw = value,
             0x42 => ppu.win.h[1].raw = value,
@@ -205,20 +205,20 @@ pub fn write(comptime T: type, ppu: *Ppu, addr: u32, value: T) void {
             0x1E, 0x1F => ppu.bg[3].vofs.raw = setHalf(u16, ppu.bg[3].vofs.raw, byte_addr, value),
 
             // BG2 Rot/Scaling
-            0x20, 0x21 => ppu.aff_bg[0].pa = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[0].pa), byte_addr, value)),
+            0x20, 0x21 => ppu.aff_bg[0].pa = @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[0].pa)), byte_addr, value)),
-            0x22, 0x23 => ppu.aff_bg[0].pb = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[0].pb), byte_addr, value)),
+            0x22, 0x23 => ppu.aff_bg[0].pb = @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[0].pb)), byte_addr, value)),
-            0x24, 0x25 => ppu.aff_bg[0].pc = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[0].pc), byte_addr, value)),
+            0x24, 0x25 => ppu.aff_bg[0].pc = @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[0].pc)), byte_addr, value)),
-            0x26, 0x27 => ppu.aff_bg[0].pd = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[0].pd), byte_addr, value)),
+            0x26, 0x27 => ppu.aff_bg[0].pd = @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[0].pd)), byte_addr, value)),
-            0x28, 0x29, 0x2A, 0x2B => ppu.aff_bg[0].x = @bitCast(i32, setQuart(@bitCast(u32, ppu.aff_bg[0].x), byte_addr, value)),
+            0x28, 0x29, 0x2A, 0x2B => ppu.aff_bg[0].x = @bitCast(setQuart(@bitCast(ppu.aff_bg[0].x), byte_addr, value)),
-            0x2C, 0x2D, 0x2E, 0x2F => ppu.aff_bg[0].y = @bitCast(i32, setQuart(@bitCast(u32, ppu.aff_bg[0].y), byte_addr, value)),
+            0x2C, 0x2D, 0x2E, 0x2F => ppu.aff_bg[0].y = @bitCast(setQuart(@bitCast(ppu.aff_bg[0].y), byte_addr, value)),
 
             // BG3 Rot/Scaling
-            0x30, 0x31 => ppu.aff_bg[1].pa = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[1].pa), byte_addr, value)),
+            0x30, 0x31 => ppu.aff_bg[1].pa = @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[1].pa)), byte_addr, value)),
-            0x32, 0x33 => ppu.aff_bg[1].pb = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[1].pb), byte_addr, value)),
+            0x32, 0x33 => ppu.aff_bg[1].pb = @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[1].pb)), byte_addr, value)),
-            0x34, 0x35 => ppu.aff_bg[1].pc = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[1].pc), byte_addr, value)),
+            0x34, 0x35 => ppu.aff_bg[1].pc = @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[1].pc)), byte_addr, value)),
-            0x36, 0x37 => ppu.aff_bg[1].pd = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[1].pd), byte_addr, value)),
+            0x36, 0x37 => ppu.aff_bg[1].pd = @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[1].pd)), byte_addr, value)),
-            0x38, 0x39, 0x3A, 0x3B => ppu.aff_bg[1].x = @bitCast(i32, setQuart(@bitCast(u32, ppu.aff_bg[1].x), byte_addr, value)),
+            0x38, 0x39, 0x3A, 0x3B => ppu.aff_bg[1].x = @bitCast(setQuart(@bitCast(ppu.aff_bg[1].x), byte_addr, value)),
-            0x3C, 0x3D, 0x3E, 0x3F => ppu.aff_bg[1].y = @bitCast(i32, setQuart(@bitCast(u32, ppu.aff_bg[1].y), byte_addr, value)),
+            0x3C, 0x3D, 0x3E, 0x3F => ppu.aff_bg[1].y = @bitCast(setQuart(@bitCast(ppu.aff_bg[1].y), byte_addr, value)),
 
             // Window
             0x40, 0x41 => ppu.win.h[0].raw = setHalf(u16, ppu.win.h[0].raw, byte_addr, value),
@@ -324,13 +324,13 @@ pub const Ppu = struct {
     }
 
     pub fn setBgOffsets(self: *Self, comptime n: u2, word: u32) void {
-        self.bg[n].hofs.raw = @truncate(u16, word);
+        self.bg[n].hofs.raw = @truncate(word);
-        self.bg[n].vofs.raw = @truncate(u16, word >> 16);
+        self.bg[n].vofs.raw = @truncate(word >> 16);
     }
 
     pub fn setAdjCnts(self: *Self, comptime n: u2, word: u32) void {
-        self.bg[n].cnt.raw = @truncate(u16, word);
+        self.bg[n].cnt.raw = @truncate(word);
-        self.bg[n + 1].cnt.raw = @truncate(u16, word >> 16);
+        self.bg[n + 1].cnt.raw = @truncate(word >> 16);
     }
 
     /// Search OAM for Sprites that might be rendered on this scanline
@@ -341,11 +341,11 @@ pub const Ppu = struct {
         search: while (i < self.oam.buf.len) : (i += 8) {
             // Attributes in OAM are 6 bytes long, with 2 bytes of padding
             // Grab Attributes from OAM
-            const attr0 = @bitCast(Attr0, self.oam.read(u16, i));
+            const attr0: Attr0 = @bitCast(self.oam.read(u16, i));
 
             // Only consider enabled Sprites
             if (attr0.is_affine.read() or !attr0.disabled.read()) {
-                const attr1 = @bitCast(Attr1, self.oam.read(u16, i + 2));
+                const attr1: Attr1 = @bitCast(self.oam.read(u16, i + 2));
                 const d = spriteDimensions(attr0.shape.read(), attr1.size.read());
 
                 // Account for double-size affine sprites
@@ -368,7 +368,7 @@ pub const Ppu = struct {
                 if (y_pos <= y and y < (y_pos + sprite_height)) {
                     for (self.scanline_sprites) |*maybe_sprite| {
                         if (maybe_sprite.* == null) {
-                            maybe_sprite.* = Sprite.init(attr0, attr1, @bitCast(Attr2, self.oam.read(u16, i + 4)));
+                            maybe_sprite.* = Sprite.init(attr0, attr1, @bitCast(self.oam.read(u16, i + 4)));
                             continue :search;
                         }
                     }
@@ -414,7 +414,7 @@ pub const Ppu = struct {
         const pc = self.oam.read(u16, base + 11 * @sizeOf(u16));
         const pd = self.oam.read(u16, base + 15 * @sizeOf(u16));
 
-        const matrix = @bitCast([4]i16, [_]u16{ pa, pb, pc, pd });
+        const matrix: [4]i16 = @bitCast([_]u16{ pa, pb, pc, pd });
 
         const sprite_width = sprite.width << if (double_size) 1 else 0;
         const sprite_height = sprite.height << if (double_size) 1 else 0;
@@ -425,7 +425,7 @@ pub const Ppu = struct {
         var i: u9 = 0;
         while (i < sprite_width) : (i += 1) {
             // TODO: Something is wrong here
-            const x = @truncate(u9, @bitCast(u16, sprite_x + i));
+            const x: u9 = @truncate(@as(u16, @bitCast(sprite_x + i)));
             if (x >= width) continue;
 
             if (!shouldDrawSprite(self.bld.cnt, &self.scanline, x)) continue;
@@ -447,11 +447,11 @@ pub const Ppu = struct {
             // Maybe this is the necessary check?
             if (rot_x >= sprite.width or rot_y >= sprite.height or rot_x < 0 or rot_y < 0) continue;
 
-            const tile_x = @bitCast(u16, rot_x);
+            const tile_x: u16 = @bitCast(rot_x);
-            const tile_y = @bitCast(u16, rot_y);
+            const tile_y: u16 = @bitCast(rot_y);
 
-            const col = @truncate(u3, tile_x);
+            const col: u3 = @truncate(tile_x);
-            const row = @truncate(u3, tile_y);
+            const row: u3 = @truncate(tile_y);
 
             // TODO: Finish that 2D Sprites Test ROM
             const tile_base = char_base + (tile_id * 0x20) + (row * tile_row_offset) + if (is_8bpp) col else col >> 1;
@@ -461,12 +461,12 @@ pub const Ppu = struct {
             const tile = self.vram.buf[tile_base + tile_offset];
             const pal_id: u16 = if (!is_8bpp) get4bppTilePalette(sprite.palBank(), col, tile) else tile;
 
-            const global_x = @truncate(u9, @bitCast(u16, local_x + sprite_x));
+            const global_x: u9 = @truncate(@as(u16, @bitCast(local_x + sprite_x)));
 
             // Sprite Palette starts at 0x0500_0200
             if (pal_id != 0) {
                 const bgr555 = self.palette.read(u16, 0x200 + pal_id * 2);
-                drawSpritePixel(self.bld.cnt, &self.scanline, @bitCast(Attr0, sprite.attr0), global_x, bgr555);
+                drawSpritePixel(self.bld.cnt, &self.scanline, @as(Attr0, @bitCast(sprite.attr0)), global_x, bgr555);
             }
         }
     }
@@ -490,7 +490,7 @@ pub const Ppu = struct {
         var i: u9 = 0;
         while (i < sprite.width) : (i += 1) {
             // TODO: Something is Wrong Here
-            const x = @truncate(u9, @bitCast(u16, sprite_x + i));
+            const x = @as(u9, @truncate(@as(u16, @bitCast(sprite_x + i))));
             if (x >= width) continue;
 
             if (!shouldDrawSprite(self.bld.cnt, &self.scanline, x)) continue;
@@ -504,11 +504,11 @@ pub const Ppu = struct {
             // Note that we flip the tile_pos not the (tile_pos % 8) like we do for
             // Background Tiles. By doing this we mirror the entire sprite instead of
             // just a specific tile (see how sprite.width and sprite.height are involved)
-            const tile_x = @intCast(u9, local_x) ^ if (sprite.hFlip()) (sprite.width - 1) else 0;
+            const tile_x = @as(u9, @intCast(local_x)) ^ if (sprite.hFlip()) (sprite.width - 1) else 0;
-            const tile_y = @intCast(u8, local_y) ^ if (sprite.vFlip()) (sprite.height - 1) else 0;
+            const tile_y = @as(u8, @intCast(local_y)) ^ if (sprite.vFlip()) (sprite.height - 1) else 0;
 
-            const col = @truncate(u3, tile_x);
+            const col: u3 = @truncate(tile_x);
-            const row = @truncate(u3, tile_y);
+            const row: u3 = @truncate(tile_y);
 
             // TODO: Finish that 2D Sprites Test ROM
             const tile_base = char_base + (tile_id * 0x20) + (row * tile_row_offset) + if (is_8bpp) col else col >> 1;
@@ -518,7 +518,7 @@ pub const Ppu = struct {
             const tile = self.vram.buf[tile_base + tile_offset];
             const pal_id: u16 = if (!is_8bpp) get4bppTilePalette(sprite.palBank(), col, tile) else tile;
 
-            const global_x = @truncate(u9, @bitCast(u16, local_x + sprite_x));
+            const global_x: u9 = @truncate(@as(u16, @bitCast(local_x + sprite_x)));
 
             // Sprite Palette starts at 0x0500_0200
             if (pal_id != 0) {
@@ -550,8 +550,8 @@ pub const Ppu = struct {
             aff_x += self.aff_bg[n - 2].pa;
             aff_y += self.aff_bg[n - 2].pc;
 
-            const _x = @truncate(u9, @bitCast(u32, ix));
+            const _x: u9 = @truncate(@as(u32, @bitCast(ix)));
-            const _y = @truncate(u8, @bitCast(u32, iy));
+            const _y: u8 = @truncate(@as(u32, @bitCast(iy)));
 
             const win_bounds = self.windowBounds(_x, _y);
             if (!shouldDrawBackground(self, n, win_bounds, i)) continue;
@@ -561,10 +561,10 @@ pub const Ppu = struct {
                 iy = if (iy > px_height) @rem(iy, px_height) else if (iy < 0) px_height + @rem(iy, px_height) else iy;
             } else if (ix > px_width or iy > px_height or ix < 0 or iy < 0) continue;
 
-            const x = @bitCast(u32, ix);
+            const x: u32 = @bitCast(ix);
-            const y = @bitCast(u32, iy);
+            const y: u32 = @bitCast(iy);
 
-            const tile_id: u32 = self.vram.read(u8, screen_base + ((y / 8) * @bitCast(u32, tile_width) + (x / 8)));
+            const tile_id: u32 = self.vram.read(u8, screen_base + ((y / 8) * @as(u32, @bitCast(tile_width)) + (x / 8)));
             const row = y & 7;
             const col = x & 7;
 
@@ -601,12 +601,12 @@ pub const Ppu = struct {
         while (i < width) : (i += 1) {
             const x = hofs + i;
 
-            const win_bounds = self.windowBounds(@truncate(u9, x), @truncate(u8, y));
+            const win_bounds = self.windowBounds(@truncate(x), @truncate(y));
             if (!shouldDrawBackground(self, n, win_bounds, i)) continue;
 
             // Grab the Screen Entry from VRAM
             const entry_addr = screen_base + tilemapOffset(size, x, y);
-            const entry = @bitCast(ScreenEntry, self.vram.read(u16, entry_addr));
+            const entry: ScreenEntry = @bitCast(self.vram.read(u16, entry_addr));
 
             // Calculate the Address of the Tile in the designated Charblock
             // We also take this opportunity to flip tiles if necessary
@@ -615,8 +615,8 @@ pub const Ppu = struct {
             // Calculate row and column offsets. Understand that
             // `tile_len`, `tile_row_offset` and `col` are subject to different
             // values depending on whether we are in 4bpp or 8bpp mode.
-            const row = @truncate(u3, y) ^ if (entry.v_flip.read()) 7 else @as(u3, 0);
+            const row = @as(u3, @truncate(y)) ^ if (entry.v_flip.read()) 7 else @as(u3, 0);
-            const col = @truncate(u3, x) ^ if (entry.h_flip.read()) 7 else @as(u3, 0);
+            const col = @as(u3, @truncate(x)) ^ if (entry.h_flip.read()) 7 else @as(u3, 0);
             const tile_addr = char_base + (tile_id * tile_len) + (row * tile_row_offset) + if (is_8bpp) col else col >> 1;
 
             const tile = self.vram.buf[tile_addr];
@@ -649,7 +649,7 @@ pub const Ppu = struct {
                 if (obj_enable) self.fetchSprites();
 
                 for (0..4) |layer| {
-                    self.drawSprites(@truncate(u2, layer));
+                    self.drawSprites(@truncate(layer));
                     if (layer == self.bg[0].cnt.priority.read() and bg_enable & 1 == 1) self.drawBackground(0);
                     if (layer == self.bg[1].cnt.priority.read() and bg_enable >> 1 & 1 == 1) self.drawBackground(1);
                     if (layer == self.bg[2].cnt.priority.read() and bg_enable >> 2 & 1 == 1) self.drawBackground(2);
@@ -663,7 +663,7 @@ pub const Ppu = struct {
                 if (obj_enable) self.fetchSprites();
 
                 for (0..4) |layer| {
-                    self.drawSprites(@truncate(u2, layer));
+                    self.drawSprites(@as(u2, @truncate(layer)));
                     if (layer == self.bg[0].cnt.priority.read() and bg_enable & 1 == 1) self.drawBackground(0);
                     if (layer == self.bg[1].cnt.priority.read() and bg_enable >> 1 & 1 == 1) self.drawBackground(1);
                     if (layer == self.bg[2].cnt.priority.read() and bg_enable >> 2 & 1 == 1) self.drawAffineBackground(2);
@@ -676,7 +676,7 @@ pub const Ppu = struct {
                 if (obj_enable) self.fetchSprites();
 
                 for (0..4) |layer| {
-                    self.drawSprites(@truncate(u2, layer));
+                    self.drawSprites(@truncate(layer));
                     if (layer == self.bg[2].cnt.priority.read() and bg_enable >> 2 & 1 == 1) self.drawAffineBackground(2);
                     if (layer == self.bg[3].cnt.priority.read() and bg_enable >> 3 & 1 == 1) self.drawAffineBackground(3);
                 }
@@ -688,8 +688,8 @@ pub const Ppu = struct {
                 const framebuf_base = width * @as(usize, scanline);
 
                 // FIXME: @ptrCast between slices changing the length isn't implemented yet
-                const vram_buf = @ptrCast([*]const u16, @alignCast(@alignOf(u16), self.vram.buf));
+                const vram_buf: [*]const u16 = @ptrCast(@alignCast(self.vram.buf));
-                const framebuf = @ptrCast([*]u32, @alignCast(@alignOf(u32), self.framebuf.get(.Emulator)));
+                const framebuf: [*]u32 = @ptrCast(@alignCast(self.framebuf.get(.Emulator)));
 
                 for (vram_buf[vram_base .. vram_base + width], 0..) |bgr555, i| {
                     framebuf[framebuf_base + i] = rgba888(bgr555);
@@ -702,8 +702,8 @@ pub const Ppu = struct {
                 const framebuf_base = width * @as(usize, scanline);
 
                 // FIXME: @ptrCast between slices changing the length isn't implemented yet
-                const pal_buf = @ptrCast([*]const u16, @alignCast(@alignOf(u16), self.palette.buf));
+                const pal_buf: [*]const u16 = @ptrCast(@alignCast(self.palette.buf));
-                const framebuf = @ptrCast([*]u32, @alignCast(@alignOf(u32), self.framebuf.get(.Emulator)));
+                const framebuf: [*]u32 = @ptrCast(@alignCast(self.framebuf.get(.Emulator)));
 
                 for (self.vram.buf[vram_base .. vram_base + width], 0..) |pal_id, i| {
                     framebuf[framebuf_base + i] = rgba888(pal_buf[pal_id]);
@@ -718,8 +718,8 @@ pub const Ppu = struct {
                 const framebuf_base = width * @as(usize, scanline);
 
                 // FIXME: @ptrCast between slices changing the length isn't implemented yet
-                const vram_buf = @ptrCast([*]const u16, @alignCast(@alignOf(u16), self.vram.buf));
+                const vram_buf: [*]const u16 = @ptrCast(@alignCast(self.vram.buf));
-                const framebuf = @ptrCast([*]u32, @alignCast(@alignOf(u32), self.framebuf.get(.Emulator)));
+                const framebuf: [*]u32 = @ptrCast(@alignCast(self.framebuf.get(.Emulator)));
 
                 for (0..width) |i| {
                     const bgr555 = if (scanline < m5_height and i < m5_width) vram_buf[vram_base + i] else self.palette.backdrop();
@@ -735,7 +735,7 @@ pub const Ppu = struct {
         // If there are any nulls present in self.scanline.top() it means that no background drew a pixel there, so draw backdrop
 
         // FIXME: @ptrCast between slices changing the length isn't implemented yet
-        const framebuf = @ptrCast([*]u32, @alignCast(@alignOf(u32), self.framebuf.get(.Emulator)));
+        const framebuf: [*]u32 = @ptrCast(@alignCast(self.framebuf.get(.Emulator)));
 
         for (self.scanline.top(), 0..) |maybe_top, i| {
             const maybe_btm = self.scanline.btm()[i];
@@ -1003,7 +1003,7 @@ pub const Ppu = struct {
     }
 
     pub fn onHdrawEnd(self: *Self, cpu: *Arm7tdmi, late: u64) void {
-        const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
+        const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
 
         // Transitioning to a Hblank
         if (self.dispstat.hblank_irq.read()) {
@@ -1020,7 +1020,7 @@ pub const Ppu = struct {
     }
 
     pub fn onHblankEnd(self: *Self, cpu: *Arm7tdmi, late: u64) void {
-        const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
+        const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
 
         // The End of a Hblank (During Draw or Vblank)
         const old_scanline = self.vcount.scanline.read();
@@ -1148,18 +1148,18 @@ const Window = struct {
     }
 
     pub fn setH(self: *Self, value: u32) void {
-        self.h[0].raw = @truncate(u16, value);
+        self.h[0].raw = @truncate(value);
-        self.h[1].raw = @truncate(u16, value >> 16);
+        self.h[1].raw = @truncate(value >> 16);
     }
 
     pub fn setV(self: *Self, value: u32) void {
-        self.v[0].raw = @truncate(u16, value);
+        self.v[0].raw = @truncate(value);
-        self.v[1].raw = @truncate(u16, value >> 16);
+        self.v[1].raw = @truncate(value >> 16);
     }
 
     pub fn setIo(self: *Self, value: u32) void {
-        self.in.raw = @truncate(u16, value);
+        self.in.raw = @truncate(value);
-        self.out.raw = @truncate(u16, value >> 16);
+        self.out.raw = @truncate(value >> 16);
     }
 };
 
@@ -1222,23 +1222,23 @@ const AffineBackground = struct {
     }
 
     pub fn setX(self: *Self, is_vblank: bool, value: u32) void {
-        self.x = @bitCast(i32, value);
+        self.x = @bitCast(value);
-        if (!is_vblank) self.x_latch = @bitCast(i32, value);
+        if (!is_vblank) self.x_latch = @bitCast(value);
     }
 
     pub fn setY(self: *Self, is_vblank: bool, value: u32) void {
-        self.y = @bitCast(i32, value);
+        self.y = @bitCast(value);
-        if (!is_vblank) self.y_latch = @bitCast(i32, value);
+        if (!is_vblank) self.y_latch = @bitCast(value);
     }
 
     pub fn writePaPb(self: *Self, value: u32) void {
-        self.pa = @bitCast(i16, @truncate(u16, value));
+        self.pa = @bitCast(@as(u16, @truncate(value)));
-        self.pb = @bitCast(i16, @truncate(u16, value >> 16));
+        self.pb = @bitCast(@as(u16, @truncate(value >> 16)));
     }
 
     pub fn writePcPd(self: *Self, value: u32) void {
-        self.pc = @bitCast(i16, @truncate(u16, value));
+        self.pc = @bitCast(@as(u16, @truncate(value)));
-        self.pd = @bitCast(i16, @truncate(u16, value >> 16));
+        self.pd = @bitCast(@as(u16, @truncate(value >> 16)));
     }
 
     // Every Vblank BG?X/Y registers are latched
@@ -1447,9 +1447,9 @@ fn alphaBlend(top: u16, btm: u16, bldalpha: io.BldAlpha) u16 {
     const btm_g = (btm >> 5) & 0x1F;
     const btm_b = (btm >> 10) & 0x1F;
 
-    const bld_r = std.math.min(31, (top_r * eva + btm_r * evb) >> 4);
+    const bld_r: u16 = @min(31, (top_r * eva + btm_r * evb) >> 4);
-    const bld_g = std.math.min(31, (top_g * eva + btm_g * evb) >> 4);
+    const bld_g: u16 = @min(31, (top_g * eva + btm_g * evb) >> 4);
-    const bld_b = std.math.min(31, (top_b * eva + btm_b * evb) >> 4);
+    const bld_b: u16 = @min(31, (top_b * eva + btm_b * evb) >> 4);
 
     return (bld_b << 10) | (bld_g << 5) | bld_r;
 }

src/core/ppu/Oam.zig

@@ -12,7 +12,7 @@ pub fn read(self: *const Self, comptime T: type, address: usize) T {
     const addr = address & 0x3FF;
 
     return switch (T) {
-        u32, u16, u8 => std.mem.readIntSliceLittle(T, self.buf[addr..][0..@sizeOf(T)]),
+        u32, u16, u8 => std.mem.readInt(T, self.buf[addr..][0..@sizeOf(T)], .little),
         else => @compileError("OAM: Unsupported read width"),
     };
 }
@@ -21,7 +21,7 @@ pub fn write(self: *Self, comptime T: type, address: usize, value: T) void {
     const addr = address & 0x3FF;
 
     switch (T) {
-        u32, u16 => std.mem.writeIntSliceLittle(T, self.buf[addr..][0..@sizeOf(T)], value),
+        u32, u16 => std.mem.writeInt(T, self.buf[addr..][0..@sizeOf(T)], value, .little),
         u8 => return, // 8-bit writes are explicitly ignored
         else => @compileError("OAM: Unsupported write width"),
     }

src/core/ppu/Palette.zig

@@ -12,7 +12,7 @@ pub fn read(self: *const Self, comptime T: type, address: usize) T {
     const addr = address & 0x3FF;
 
     return switch (T) {
-        u32, u16, u8 => std.mem.readIntSliceLittle(T, self.buf[addr..][0..@sizeOf(T)]),
+        u32, u16, u8 => std.mem.readInt(T, self.buf[addr..][0..@sizeOf(T)], .little),
         else => @compileError("PALRAM: Unsupported read width"),
     };
 }
@@ -21,10 +21,10 @@ pub fn write(self: *Self, comptime T: type, address: usize, value: T) void {
     const addr = address & 0x3FF;
 
     switch (T) {
-        u32, u16 => std.mem.writeIntSliceLittle(T, self.buf[addr..][0..@sizeOf(T)], value),
+        u32, u16 => std.mem.writeInt(T, self.buf[addr..][0..@sizeOf(T)], value, .little),
         u8 => {
             const align_addr = addr & ~@as(u32, 1); // Aligned to Halfword boundary
-            std.mem.writeIntSliceLittle(u16, self.buf[align_addr..][0..@sizeOf(u16)], @as(u16, value) * 0x101);
+            std.mem.writeInt(u16, self.buf[align_addr..][0..@sizeOf(u16)], @as(u16, value) * 0x101, .little);
         },
         else => @compileError("PALRAM: Unsupported write width"),
     }
@@ -47,5 +47,5 @@ pub fn deinit(self: *Self) void {
 }
 
 pub inline fn backdrop(self: *const Self) u16 {
-    return std.mem.readIntNative(u16, self.buf[0..2]);
+    return std.mem.readInt(u16, self.buf[0..2], .little);
 }

src/core/ppu/Vram.zig

@@ -13,7 +13,7 @@ pub fn read(self: *const Self, comptime T: type, address: usize) T {
     const addr = Self.mirror(address);
 
     return switch (T) {
-        u32, u16, u8 => std.mem.readIntSliceLittle(T, self.buf[addr..][0..@sizeOf(T)]),
+        u32, u16, u8 => std.mem.readInt(T, self.buf[addr..][0..@sizeOf(T)], .little),
         else => @compileError("VRAM: Unsupported read width"),
     };
 }
@@ -23,7 +23,7 @@ pub fn write(self: *Self, comptime T: type, dispcnt: io.DisplayControl, address:
     const idx = Self.mirror(address);
 
     switch (T) {
-        u32, u16 => std.mem.writeIntSliceLittle(T, self.buf[idx..][0..@sizeOf(T)], value),
+        u32, u16 => std.mem.writeInt(T, self.buf[idx..][0..@sizeOf(T)], value, .little),
         u8 => {
             // Ignore write if it falls within the boundaries of OBJ VRAM
             switch (mode) {
@@ -32,7 +32,7 @@ pub fn write(self: *Self, comptime T: type, dispcnt: io.DisplayControl, address:
             }
 
             const align_idx = idx & ~@as(u32, 1); // Aligned to a halfword boundary
-            std.mem.writeIntSliceLittle(u16, self.buf[align_idx..][0..@sizeOf(u16)], @as(u16, value) * 0x101);
+            std.mem.writeInt(u16, self.buf[align_idx..][0..@sizeOf(u16)], @as(u16, value) * 0x101, .little);
         },
         else => @compileError("VRAM: Unsupported write width"),
     }

src/core/scheduler.zig

@@ -46,7 +46,7 @@ pub const Scheduler = struct {
         const event = self.queue.remove();
         const late = self.tick - event.tick;
 
-        const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
+        const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
 
         switch (event.kind) {
             .HeatDeath => {
@@ -75,7 +75,7 @@ pub const Scheduler = struct {
                 const device = &bus_ptr.pak.gpio.device;
                 if (device.kind != .Rtc or device.ptr == null) return;
 
-                const clock = @ptrCast(*Clock, @alignCast(@alignOf(*Clock), device.ptr.?));
+                const clock: *Clock = @ptrCast(@alignCast(device.ptr.?));
                 clock.onClockUpdate(late);
             },
             .FrameSequencer => bus_ptr.apu.onSequencerTick(late),
@@ -93,7 +93,7 @@ pub const Scheduler = struct {
                 // invalidates the slice we're iterating over
                 _ = self.queue.removeIndex(i);
 
-                log.debug("Removed {?}@{}", .{ event.kind, event.tick });
+                // log.debug("Removed {?}@{}", .{ event.kind, event.tick });
                 break;
             }
         }

src/imgui.zig

@@ -13,6 +13,7 @@ const Gui = @import("platform.zig").Gui;
 const Arm7tdmi = @import("arm32").Arm7tdmi;
 const Scheduler = @import("core/scheduler.zig").Scheduler;
 const Bus = @import("core/Bus.zig");
+const Synchro = @import("core/emu.zig").Synchro;
 
 const RingBuffer = @import("zba-util").RingBuffer;
 const Dimensions = @import("platform.zig").Dimensions;
@@ -70,11 +71,13 @@ pub const State = struct {
     }
 };
 
-pub fn draw(state: *State, win_dim: Dimensions, tex_id: GLuint, cpu: *Arm7tdmi) bool {
+pub fn draw(state: *State, sync: *Synchro, dim: Dimensions, cpu: *const Arm7tdmi, tex_id: GLuint) bool {
     const scn_scale = config.config().host.win_scale;
-    const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
+    const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
 
-    zgui.backend.newFrame(@intToFloat(f32, win_dim.width), @intToFloat(f32, win_dim.height));
+    zgui.backend.newFrame(@floatFromInt(dim.width), @floatFromInt(dim.height));
+
+    state.title = handleTitle(&bus_ptr.pak.title);
 
     {
         _ = zgui.beginMainMenuBar();
@@ -87,42 +90,59 @@ pub fn draw(state: *State, win_dim: Dimensions, tex_id: GLuint, cpu: *Arm7tdmi)
                 state.should_quit = true;
 
             if (zgui.menuItem("Insert ROM", .{})) blk: {
-                const maybe_path = nfd.openFileDialog("gba", null) catch |e| {
+                const file_path = tmp: {
-                    log.err("failed to open file dialog: {}", .{e});
+                    const path_opt = nfd.openFileDialog("gba", null) catch |e| {
-                    break :blk;
+                        log.err("file dialog failed to open: {}", .{e});
-                };
+                        break :blk;
+                    };
 
-                const file_path = maybe_path orelse {
+                    break :tmp path_opt orelse {
-                    log.warn("did not receive a file path", .{});
+                        log.warn("did not receive a file path", .{});
-                    break :blk;
+                        break :blk;
+                    };
                 };
                 defer nfd.freePath(file_path);
 
                 log.info("user chose: \"{s}\"", .{file_path});
-                emu.replaceGamepak(cpu, file_path) catch |e| {
+
-                    log.err("failed to replace GamePak: {}", .{e});
+                const message = tmp: {
+                    var msg: Synchro.Message = .{ .rom_path = undefined };
+                    @memcpy(msg.rom_path[0..file_path.len], file_path);
+                    break :tmp msg;
+                };
+
+                sync.ch.push(message) catch |e| {
+                    log.err("failed to send file path to emu thread: {}", .{e});
                     break :blk;
                 };
 
-                state.title = handleTitle(&bus_ptr.pak.title);
                 state.emulation = .{ .Transition = .Active };
             }
 
             if (zgui.menuItem("Load BIOS", .{})) blk: {
-                const maybe_path = nfd.openFileDialog("bin", null) catch |e| {
+                const file_path = tmp: {
-                    log.err("failed to open file dialog: {}", .{e});
+                    const path_opt = nfd.openFileDialog("bin", null) catch |e| {
-                    break :blk;
+                        log.err("file dialog failed to open: {}", .{e});
-                };
+                        break :blk;
+                    };
 
-                const file_path = maybe_path orelse {
+                    break :tmp path_opt orelse {
-                    log.warn("did not receive a file path", .{});
+                        log.warn("did not receive a file path", .{});
-                    break :blk;
+                        break :blk;
+                    };
                 };
                 defer nfd.freePath(file_path);
 
                 log.info("user chose: \"{s}\"", .{file_path});
-                emu.replaceBios(cpu, file_path) catch |e| {
+
-                    log.err("failed to replace BIOS: {}", .{e});
+                const message = tmp: {
+                    var msg: Synchro.Message = .{ .bios_path = undefined };
+                    @memcpy(msg.bios_path[0..file_path.len], file_path);
+                    break :tmp msg;
+                };
+
+                sync.ch.push(message) catch |e| {
+                    log.err("failed to send file path to emu thread: {}", .{e});
                     break :blk;
                 };
             }
@@ -149,7 +169,7 @@ pub fn draw(state: *State, win_dim: Dimensions, tex_id: GLuint, cpu: *Arm7tdmi)
             }
 
             if (zgui.menuItem("Restart", .{}))
-                emu.reset(cpu);
+                sync.ch.push(.restart) catch |e| log.err("failed to send restart req to emu thread: {}", .{e});
         }
 
         if (zgui.beginMenu("Stats", true)) {
@@ -168,14 +188,14 @@ pub fn draw(state: *State, win_dim: Dimensions, tex_id: GLuint, cpu: *Arm7tdmi)
     }
 
     {
-        const w = @intToFloat(f32, gba_width * scn_scale);
+        const w: f32 = @floatFromInt(gba_width * scn_scale);
-        const h = @intToFloat(f32, gba_height * scn_scale);
+        const h: f32 = @floatFromInt(gba_height * scn_scale);
 
         const window_title = std.mem.sliceTo(&state.title, 0);
         _ = zgui.begin(window_title, .{ .flags = .{ .no_resize = true, .always_auto_resize = true } });
         defer zgui.end();
 
-        zgui.image(@intToPtr(*anyopaque, tex_id), .{ .w = w, .h = h, .uv0 = .{ 0, 1 }, .uv1 = .{ 1, 0 } });
+        zgui.image(@ptrFromInt(tex_id), .{ .w = w, .h = h });
     }
 
     // TODO: Any other steps to respect the copyright of the libraries I use?
@@ -272,8 +292,8 @@ pub fn draw(state: *State, win_dim: Dimensions, tex_id: GLuint, cpu: *Arm7tdmi)
             break :blk buf;
         };
 
-        const y_max = 2 * if (len != 0) @intToFloat(f64, sorted[len - 1]) else emu.frame_rate;
+        const y_max: f64 = 2 * if (len != 0) @as(f64, @floatFromInt(sorted[len - 1])) else emu.frame_rate;
-        const x_max = @intToFloat(f64, values.len);
+        const x_max: f64 = @floatFromInt(values.len);
 
         const y_args = .{ .flags = .{ .no_grid_lines = true } };
         const x_args = .{ .flags = .{ .no_grid_lines = true, .no_tick_labels = true, .no_tick_marks = true } };
@@ -294,11 +314,11 @@ pub fn draw(state: *State, win_dim: Dimensions, tex_id: GLuint, cpu: *Arm7tdmi)
         const stats: struct { u32, u32, u32 } = blk: {
             if (len == 0) break :blk .{ 0, 0, 0 };
 
-            const average = average: {
+            const average: u32 = average: {
                 var sum: u32 = 0;
                 for (sorted[0..len]) |value| sum += value;
 
-                break :average @intCast(u32, sum / len);
+                break :average @intCast(sum / len);
             };
             const median = sorted[len / 2];
             const low = sorted[len / 100]; // 1% Low
@@ -320,13 +340,13 @@ pub fn draw(state: *State, win_dim: Dimensions, tex_id: GLuint, cpu: *Arm7tdmi)
         zgui.text("tick: {X:0>16}", .{scheduler.now()});
         zgui.separator();
 
-        const sched_ptr = @ptrCast(*Scheduler, @alignCast(@alignOf(Scheduler), cpu.sched.ptr));
+        const sched_ptr: *Scheduler = @ptrCast(@alignCast(cpu.sched.ptr));
         const Event = std.meta.Child(@TypeOf(sched_ptr.queue.items));
 
         var items: [20]Event = undefined;
-        const len = sched_ptr.queue.len;
+        const len = @min(sched_ptr.queue.items.len, items.len);
 
-        @memcpy(&items, sched_ptr.queue.items);
+        @memcpy(items[0..len], sched_ptr.queue.items[0..len]);
         std.mem.sort(Event, items[0..len], {}, widgets.eventDesc(Event));
 
         for (items[0..len]) |event| {
@@ -345,9 +365,9 @@ pub fn draw(state: *State, win_dim: Dimensions, tex_id: GLuint, cpu: *Arm7tdmi)
         widgets.paletteGrid(.Object, cpu);
     }
 
-    {
+    // {
-        zgui.showDemoWindow(null);
+    //     zgui.showDemoWindow(null);
-    }
+    // }
 
     return true; // request redraw
 }
@@ -365,7 +385,7 @@ const widgets = struct {
         };
 
         for (0..0x100) |i| {
-            const offset = @truncate(u32, i);
+            const offset: u32 = @truncate(i);
             const bgr555 = cpu.bus.dbgRead(u16, address + offset * @sizeOf(u16));
             widgets.colourSquare(bgr555);
 
@@ -378,11 +398,11 @@ const widgets = struct {
         // FIXME: working with the packed struct enum is currently broken :pensive:
         const ImguiColorEditFlags_NoInputs: u32 = 1 << 5;
         const ImguiColorEditFlags_NoPicker: u32 = 1 << 2;
-        const flags = @bitCast(zgui.ColorEditFlags, ImguiColorEditFlags_NoInputs | ImguiColorEditFlags_NoPicker);
+        const flags: zgui.ColorEditFlags = @bitCast(ImguiColorEditFlags_NoInputs | ImguiColorEditFlags_NoPicker);
 
-        const b = @intToFloat(f32, bgr555 >> 10 & 0x1f);
+        const b: f32 = @floatFromInt(bgr555 >> 10 & 0x1f);
-        const g = @intToFloat(f32, bgr555 >> 5 & 0x1F);
+        const g: f32 = @floatFromInt(bgr555 >> 5 & 0x1F);
-        const r = @intToFloat(f32, bgr555 & 0x1F);
+        const r: f32 = @floatFromInt(bgr555 & 0x1F);
 
         var col = [_]f32{ r / 31.0, g / 31.0, b / 31.0 };
 

src/main.zig

@@ -6,7 +6,7 @@ const clap = @import("clap");
 const config = @import("config.zig");
 const emu = @import("core/emu.zig");
 
-const Channel = @import("zba-util").Channel(emu.Message, 0x100);
+const Synchro = @import("core/emu.zig").Synchro;
 const Gui = @import("platform.zig").Gui;
 const Bus = @import("core/Bus.zig");
 const Scheduler = @import("core/scheduler.zig").Scheduler;
@@ -61,7 +61,8 @@ pub fn main() void {
     defer allocator.free(config_path);
 
     // Parse CLI
-    const result = clap.parse(clap.Help, &params, clap.parsers.default, .{}) catch |e| exitln("failed to parse cli: {}", .{e});
+
+    const result = clap.parse(clap.Help, &params, clap.parsers.default, .{ .allocator = allocator }) catch |e| exitln("failed to parse cli: {}", .{e});
     defer result.deinit();
 
     // TODO: Move config file to XDG Config directory?
@@ -70,8 +71,24 @@ pub fn main() void {
 
     config.load(allocator, cfg_file_path) catch |e| exitln("failed to load config file: {}", .{e});
 
-    const paths = handleArguments(allocator, data_path, &result) catch |e| exitln("failed to handle cli arguments: {}", .{e});
+    var paths = handleArguments(allocator, data_path, &result) catch |e| exitln("failed to handle cli arguments: {}", .{e});
-    defer if (paths.save) |path| allocator.free(path);
+    defer paths.deinit(allocator);
+
+    // if paths.bios is null, then we want to see if it's in the data directory
+    if (paths.bios == null) blk: {
+        const bios_path = std.mem.join(allocator, "/", &.{ data_path, "zba", "gba_bios.bin" }) catch |e| exitln("failed to allocate backup bios dir path: {}", .{e});
+        defer allocator.free(bios_path);
+
+        _ = std.fs.cwd().statFile(bios_path) catch |e| switch (e) {
+            error.FileNotFound => { // ZBA will crash on attempt to read BIOS but that's fine
+                log.err("file located at {s} was not found", .{bios_path});
+                break :blk;
+            },
+            else => exitln("error when checking \"{s}\": {}", .{ bios_path, e }),
+        };
+
+        paths.bios = allocator.dupe(u8, bios_path) catch |e| exitln("failed to duplicate path to bios: {}", .{e});
+    }
 
     const log_file = switch (config.config().debug.cpu_trace) {
         true => std.fs.cwd().createFile("zba.log", .{}) catch |e| exitln("failed to create trace log file: {}", .{e}),
@@ -85,8 +102,8 @@ pub fn main() void {
 
     var bus: Bus = undefined;
 
-    var ischeduler = IScheduler.init(&scheduler);
+    const ischeduler = IScheduler.init(&scheduler);
-    var ibus = IBus.init(&bus);
+    const ibus = IBus.init(&bus);
 
     var cpu = Arm7tdmi.init(ischeduler, ibus);
 
@@ -103,10 +120,8 @@ pub fn main() void {
     var gui = Gui.init(allocator, &bus.apu, title_ptr) catch |e| exitln("failed to init gui: {}", .{e});
     defer gui.deinit();
 
-    var quit = std.atomic.Atomic(bool).init(false);
+    var sync = Synchro.init(allocator) catch |e| exitln("failed to allocate sync types: {}", .{e});
-
+    defer sync.deinit(allocator);
-    var ch = Channel.init(allocator) catch |e| exitln("failed to initialize ui -> emu thread message channel: {}", .{e});
-    defer ch.deinit(allocator);
 
     if (result.args.gdb != 0) {
         const Server = @import("gdbstub").Server;
@@ -118,46 +133,48 @@ pub fn main() void {
 
         log.info("Ready to connect", .{});
 
-        var server = Server.init(emulator) catch |e| exitln("failed to init gdb server: {}", .{e});
+        var server = Server.init(
+            emulator,
+            .{ .memory_map = EmuThing.map, .target = EmuThing.target },
+        ) catch |e| exitln("failed to init gdb server: {}", .{e});
         defer server.deinit(allocator);
 
         log.info("Starting GDB Server Thread", .{});
 
-        const thread = std.Thread.spawn(.{}, Server.run, .{ &server, allocator, &quit }) catch |e| exitln("gdb server thread crashed: {}", .{e});
+        const thread = std.Thread.spawn(.{}, Server.run, .{ &server, allocator, &sync.should_quit }) catch |e| exitln("gdb server thread crashed: {}", .{e});
         defer thread.join();
 
-        gui.run(.Debug, .{
+        gui.run(.{
             .cpu = &cpu,
             .scheduler = &scheduler,
-            .ch = ch.tx,
+            .sync = &sync,
         }) catch |e| exitln("main thread panicked: {}", .{e});
     } else {
         var tracker = FpsTracker.init();
 
-        // emu should start paused if there's no ROM to run
+        const thread = std.Thread.spawn(.{}, emu.run, .{ &cpu, &scheduler, &tracker, &sync }) catch |e| exitln("emu thread panicked: {}", .{e});
-        if (paths.rom == null)
-            ch.tx.send(.Pause);
-
-        const thread = std.Thread.spawn(.{}, emu.run, .{ &cpu, &scheduler, &tracker, ch.rx }) catch |e| exitln("emu thread panicked: {}", .{e});
         defer thread.join();
 
-        gui.run(.Standard, .{
+        gui.run(.{
             .cpu = &cpu,
             .scheduler = &scheduler,
-            .ch = ch.tx,
             .tracker = &tracker,
+            .sync = &sync,
         }) catch |e| exitln("main thread panicked: {}", .{e});
     }
 }
 
 fn handleArguments(allocator: Allocator, data_path: []const u8, result: *const clap.Result(clap.Help, &params, clap.parsers.default)) !FilePaths {
-    const rom_path = romPath(result);
+    const rom_path = try romPath(allocator, result);
-    log.info("ROM path: {?s}", .{rom_path});
+    errdefer if (rom_path) |path| allocator.free(path);
 
-    const bios_path = result.args.bios;
+    const bios_path: ?[]const u8 = if (result.args.bios) |path| try allocator.dupe(u8, path) else null;
-    if (bios_path) |path| log.info("BIOS path: {s}", .{path}) else log.warn("No BIOS provided", .{});
+    errdefer if (bios_path) |path| allocator.free(path);
 
     const save_path = try std.fs.path.join(allocator, &[_][]const u8{ data_path, "zba", "save" });
+
+    log.info("ROM path: {?s}", .{rom_path});
+    log.info("BIOS path: {?s}", .{bios_path});
     log.info("Save path: {s}", .{save_path});
 
     return .{
@@ -180,7 +197,7 @@ fn configFilePath(allocator: Allocator, config_path: []const u8) ![]const u8 {
         const config_file = std.fs.createFileAbsolute(path, .{}) catch |err| exitln("failed to create \"{s}\": {}", .{ path, err });
         defer config_file.close();
 
-        try config_file.writeAll(@embedFile("../example.toml"));
+        try config_file.writeAll(@embedFile("example.toml"));
     };
 
     return path;
@@ -201,10 +218,10 @@ fn ensureConfigDirExists(config_path: []const u8) !void {
     try dir.makePath("zba");
 }
 
-fn romPath(result: *const clap.Result(clap.Help, &params, clap.parsers.default)) ?[]const u8 {
+fn romPath(allocator: Allocator, result: *const clap.Result(clap.Help, &params, clap.parsers.default)) !?[]const u8 {
     return switch (result.positionals.len) {
         0 => null,
-        1 => result.positionals[0],
+        1 => try allocator.dupe(u8, result.positionals[0]),
         else => exitln("ZBA received too many positional arguments.", .{}),
     };
 }
@@ -213,5 +230,5 @@ fn exitln(comptime format: []const u8, args: anytype) noreturn {
     const stderr = std.io.getStdErr().writer();
     stderr.print(format, args) catch {}; // Just exit already...
     stderr.writeByte('\n') catch {};
-    std.os.exit(1);
+    std.process.exit(1);
 }

src/platform.zig

@@ -12,7 +12,7 @@ const Arm7tdmi = @import("arm32").Arm7tdmi;
 const Bus = @import("core/Bus.zig");
 const Scheduler = @import("core/scheduler.zig").Scheduler;
 const FpsTracker = @import("util.zig").FpsTracker;
-const Channel = @import("zba-util").Channel(emu.Message, 0x100);
+const Synchro = @import("core/emu.zig").Synchro;
 const KeyInput = @import("core/bus/io.zig").KeyInput;
 
 const gba_width = @import("core/ppu.zig").width;
@@ -61,7 +61,7 @@ pub const Gui = struct {
         if (SDL.SDL_GL_MakeCurrent(window, ctx) < 0) panic();
 
         gl.load(ctx, Self.glGetProcAddress) catch {};
-        if (SDL.SDL_GL_SetSwapInterval(@boolToInt(config.config().host.vsync)) < 0) panic();
+        if (SDL.SDL_GL_SetSwapInterval(@intFromBool(config.config().host.vsync)) < 0) panic();
 
         zgui.init(allocator);
         zgui.plot.init();
@@ -95,33 +95,30 @@ pub const Gui = struct {
     }
 
     const RunOptions = struct {
-        ch: Channel.Sender,
+        sync: *Synchro,
         tracker: ?*FpsTracker = null,
         cpu: *Arm7tdmi,
         scheduler: *Scheduler,
     };
 
-    const RunMode = enum { Standard, Debug };
+    pub fn run(self: *Self, opt: RunOptions) !void {
-
-    pub fn run(self: *Self, comptime mode: RunMode, opt: RunOptions) !void {
         const cpu = opt.cpu;
         const tracker = opt.tracker;
-        const ch = opt.ch;
+        const sync = opt.sync;
 
-        const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
+        const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
 
-        const objects = opengl_impl.createObjects();
+        const vao_id = opengl_impl.vao();
-        defer gl.deleteBuffers(3, @as(*const [3]GLuint, &.{ objects.vao, objects.vbo, objects.ebo }));
+        defer gl.deleteVertexArrays(1, &[_]GLuint{vao_id});
 
-        const emu_tex = opengl_impl.createScreenTexture(bus_ptr.ppu.framebuf.get(.Renderer));
+        const emu_tex = opengl_impl.screenTex(bus_ptr.ppu.framebuf.get(.Renderer));
-        const out_tex = opengl_impl.createOutputTexture();
+        const out_tex = opengl_impl.outTex();
         defer gl.deleteTextures(2, &[_]GLuint{ emu_tex, out_tex });
 
-        const fbo_id = try opengl_impl.createFrameBuffer(out_tex);
+        const fbo_id = try opengl_impl.frameBuffer(out_tex);
         defer gl.deleteFramebuffers(1, &fbo_id);
 
-        // TODO: Support dynamically switching shaders?
+        const prog_id = try opengl_impl.program(); // Dynamic Shaders?
-        const prog_id = try opengl_impl.compileShaders();
         defer gl.deleteProgram(prog_id);
 
         var win_dim: Dimensions = default_dim;
@@ -129,7 +126,7 @@ pub const Gui = struct {
         emu_loop: while (true) {
             // Outside of `SDL.SDL_QUIT` below, the DearImgui UI might signal that the program
             // should exit, in which case we should also handle this
-            if (self.state.should_quit) break :emu_loop;
+            if (self.state.should_quit or sync.should_quit.load(.monotonic)) break :emu_loop;
 
             var event: SDL.SDL_Event = undefined;
             while (SDL.SDL_PollEvent(&event) != 0) {
@@ -156,7 +153,7 @@ pub const Gui = struct {
                             else => {},
                         }
 
-                        bus_ptr.io.keyinput.fetchAnd(~keyinput.raw, .Monotonic);
+                        bus_ptr.io.keyinput.fetchAnd(~keyinput.raw, .monotonic);
                     },
                     SDL.SDL_KEYUP => {
                         // TODO: Make use of compare_and_xor?
@@ -177,14 +174,14 @@ pub const Gui = struct {
                             else => {},
                         }
 
-                        bus_ptr.io.keyinput.fetchOr(keyinput.raw, .Monotonic);
+                        bus_ptr.io.keyinput.fetchOr(keyinput.raw, .monotonic);
                     },
                     SDL.SDL_WINDOWEVENT => {
                         if (event.window.event == SDL.SDL_WINDOWEVENT_RESIZED) {
                             log.debug("window resized to: {}x{}", .{ event.window.data1, event.window.data2 });
 
-                            win_dim.width = @intCast(u32, event.window.data1);
+                            win_dim.width = @intCast(event.window.data1);
-                            win_dim.height = @intCast(u32, event.window.data2);
+                            win_dim.height = @intCast(event.window.data2);
                         }
                     },
                     else => {},
@@ -196,51 +193,20 @@ pub const Gui = struct {
             switch (self.state.emulation) {
                 .Transition => |inner| switch (inner) {
                     .Active => {
-                        ch.send(.Resume);
+                        sync.paused.store(false, .monotonic);
                         if (!config.config().host.mute) SDL.SDL_PauseAudioDevice(self.audio.device, 0);
 
                         self.state.emulation = .Active;
                     },
                     .Inactive => {
                         // Assert that double pausing is impossible
-
                         SDL.SDL_PauseAudioDevice(self.audio.device, 1);
-                        ch.send(.Pause);
+                        sync.paused.store(true, .monotonic);
 
                         self.state.emulation = .Inactive;
                     },
                 },
                 .Active => {
-                    const is_std = mode == .Standard;
-
-                    if (is_std) ch.send(.Pause);
-                    defer if (is_std) ch.send(.Resume);
-
-                    // switch (mode) {
-                    //     .Standard => blk: {
-                    //         const limit = 15; // TODO: What should this be?
-
-                    //         // TODO: learn more about std.atomic.spinLoopHint();
-                    //         for (0..limit) |_| {
-                    //             const message = channel.gui.pop() orelse continue;
-
-                    //             switch (message) {
-                    //                 .Paused => break :blk,
-                    //                 .Quit => unreachable,
-                    //             }
-                    //         }
-
-                    //         log.info("timed out waiting for emu thread to pause (limit: {})", .{limit});
-                    //         break :skip_draw;
-                    //     },
-                    //     .Debug => blk: {
-                    //         switch (channel.gui.pop() orelse break :blk) {
-                    //             .Paused => unreachable, // only in standard mode
-                    //             .Quit => break :emu_loop, // FIXME: gdb side of emu is seriously out-of-date...
-                    //         }
-                    //     },
-                    // }
-
                     // Add FPS count to the histogram
                     if (tracker) |t| self.state.fps_hist.push(t.value()) catch {};
 
@@ -249,9 +215,8 @@ pub const Gui = struct {
                         gl.bindFramebuffer(gl.FRAMEBUFFER, fbo_id);
                         defer gl.bindFramebuffer(gl.FRAMEBUFFER, 0);
 
-                        const buf = bus_ptr.ppu.framebuf.get(.Renderer);
                         gl.viewport(0, 0, gba_width, gba_height);
-                        opengl_impl.drawScreenTexture(emu_tex, prog_id, objects, buf);
+                        opengl_impl.drawScreen(emu_tex, prog_id, vao_id, bus_ptr.ppu.framebuf.get(.Renderer));
                     }
 
                     // FIXME: We only really care about locking the audio device (and therefore writing silence)
@@ -260,15 +225,15 @@ pub const Gui = struct {
                     SDL.SDL_LockAudioDevice(self.audio.device);
                     defer SDL.SDL_UnlockAudioDevice(self.audio.device);
 
-                    zgui_redraw = imgui.draw(&self.state, win_dim, out_tex, cpu);
+                    zgui_redraw = imgui.draw(&self.state, sync, win_dim, cpu, out_tex);
                 },
-                .Inactive => zgui_redraw = imgui.draw(&self.state, win_dim, out_tex, cpu),
+                .Inactive => zgui_redraw = imgui.draw(&self.state, sync, win_dim, cpu, out_tex),
             }
 
             if (zgui_redraw) {
                 // Background Colour
                 const size = zgui.io.getDisplaySize();
-                gl.viewport(0, 0, @floatToInt(GLsizei, size[0]), @floatToInt(GLsizei, size[1]));
+                gl.viewport(0, 0, @intFromFloat(size[0]), @intFromFloat(size[1]));
                 gl.clearColor(0, 0, 0, 1.0);
                 gl.clear(gl.COLOR_BUFFER_BIT);
 
@@ -278,7 +243,7 @@ pub const Gui = struct {
             SDL.SDL_GL_SwapWindow(self.window);
         }
 
-        ch.send(.Quit);
+        sync.should_quit.store(true, .monotonic);
     }
 
     fn glGetProcAddress(ctx: SDL.SDL_GLContext, proc: [:0]const u8) ?*anyopaque {
@@ -318,8 +283,7 @@ const Audio = struct {
     }
 
     export fn callback(userdata: ?*anyopaque, stream: [*c]u8, len: c_int) void {
-        const T = *Apu;
+        const apu: *Apu = @ptrCast(@alignCast(userdata));
-        const apu = @ptrCast(T, @alignCast(@alignOf(T), userdata));
 
         _ = SDL.SDL_AudioStreamGet(apu.stream, stream, len);
     }
@@ -331,44 +295,24 @@ fn panic() noreturn {
 }
 
 const opengl_impl = struct {
-    // zig fmt: off
+    fn drawScreen(tex_id: GLuint, prog_id: GLuint, vao_id: GLuint, buf: []const u8) void {
-    const vertices: [32]f32 = [_]f32{
-        // Positions        // Colours      // Texture Coords
-         1.0, -1.0, 0.0,    1.0, 0.0, 0.0,  1.0, 1.0, // Top Right
-         1.0,  1.0, 0.0,    0.0, 1.0, 0.0,  1.0, 0.0, // Bottom Right
-        -1.0,  1.0, 0.0,    0.0, 0.0, 1.0,  0.0, 0.0, // Bottom Left
-        -1.0, -1.0, 0.0,    1.0, 1.0, 0.0,  0.0, 1.0, // Top Left
-    };
-
-    const indices: [6]u32 = [_]u32{
-        0, 1, 3, // First Triangle
-        1, 2, 3, // Second Triangle
-    };
-    // zig fmt: on
-
-    const Objects = struct { vao: GLuint, vbo: GLuint, ebo: GLuint };
-
-    fn drawScreenTexture(tex_id: GLuint, prog_id: GLuint, ids: Objects, buf: []const u8) void {
         gl.bindTexture(gl.TEXTURE_2D, tex_id);
         defer gl.bindTexture(gl.TEXTURE_2D, 0);
 
         gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, gba_width, gba_height, gl.RGBA, gl.UNSIGNED_INT_8_8_8_8, buf.ptr);
 
-        // Bind VAO, EBO. VBO not bound
+        // Bind VAO
-        gl.bindVertexArray(ids.vao); // VAO
+        gl.bindVertexArray(vao_id);
         defer gl.bindVertexArray(0);
 
-        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ids.ebo); // EBO
-        defer gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, 0);
-
         // Use compiled frag + vertex shader
         gl.useProgram(prog_id);
         defer gl.useProgram(0);
 
-        gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, null);
+        gl.drawArrays(gl.TRIANGLE_STRIP, 0, 3);
     }
 
-    fn compileShaders() !GLuint {
+    fn program() !GLuint {
         const vert_shader = @embedFile("shader/pixelbuf.vert");
         const frag_shader = @embedFile("shader/pixelbuf.frag");
 
@@ -388,50 +332,22 @@ const opengl_impl = struct {
 
         if (!shader.didCompile(fs)) return error.FragmentCompileError;
 
-        const program = gl.createProgram();
+        const prog = gl.createProgram();
-        gl.attachShader(program, vs);
+        gl.attachShader(prog, vs);
-        gl.attachShader(program, fs);
+        gl.attachShader(prog, fs);
-        gl.linkProgram(program);
+        gl.linkProgram(prog);
 
-        return program;
+        return prog;
     }
 
-    // Returns the VAO ID since it's used in run()
+    fn vao() GLuint {
-    fn createObjects() Objects {
         var vao_id: GLuint = undefined;
-        var vbo_id: GLuint = undefined;
-        var ebo_id: GLuint = undefined;
-
         gl.genVertexArrays(1, &vao_id);
-        gl.genBuffers(1, &vbo_id);
-        gl.genBuffers(1, &ebo_id);
 
-        gl.bindVertexArray(vao_id);
+        return vao_id;
-        defer gl.bindVertexArray(0);
-
-        gl.bindBuffer(gl.ARRAY_BUFFER, vbo_id);
-        defer gl.bindBuffer(gl.ARRAY_BUFFER, 0);
-
-        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ebo_id);
-        defer gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, 0);
-
-        gl.bufferData(gl.ARRAY_BUFFER, @sizeOf(@TypeOf(vertices)), &vertices, gl.STATIC_DRAW);
-        gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, @sizeOf(@TypeOf(indices)), &indices, gl.STATIC_DRAW);
-
-        // Position
-        gl.vertexAttribPointer(0, 3, gl.FLOAT, gl.FALSE, 8 * @sizeOf(f32), null); // lmao
-        gl.enableVertexAttribArray(0);
-        // Colour
-        gl.vertexAttribPointer(1, 3, gl.FLOAT, gl.FALSE, 8 * @sizeOf(f32), @intToPtr(?*anyopaque, (3 * @sizeOf(f32))));
-        gl.enableVertexAttribArray(1);
-        // Texture Coord
-        gl.vertexAttribPointer(2, 2, gl.FLOAT, gl.FALSE, 8 * @sizeOf(f32), @intToPtr(?*anyopaque, (6 * @sizeOf(f32))));
-        gl.enableVertexAttribArray(2);
-
-        return .{ .vao = vao_id, .vbo = vbo_id, .ebo = ebo_id };
     }
 
-    fn createScreenTexture(buf: []const u8) GLuint {
+    fn screenTex(buf: []const u8) GLuint {
         var tex_id: GLuint = undefined;
         gl.genTextures(1, &tex_id);
 
@@ -446,7 +362,7 @@ const opengl_impl = struct {
         return tex_id;
     }
 
-    fn createOutputTexture() GLuint {
+    fn outTex() GLuint {
         var tex_id: GLuint = undefined;
         gl.genTextures(1, &tex_id);
 
@@ -461,7 +377,7 @@ const opengl_impl = struct {
         return tex_id;
     }
 
-    fn createFrameBuffer(tex_id: GLuint) !GLuint {
+    fn frameBuffer(tex_id: GLuint) !GLuint {
         var fbo_id: GLuint = undefined;
         gl.genFramebuffers(1, &fbo_id);
 
@@ -469,9 +385,7 @@ const opengl_impl = struct {
         defer gl.bindFramebuffer(gl.FRAMEBUFFER, 0);
 
         gl.framebufferTexture(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, tex_id, 0);
-
+        gl.drawBuffers(1, &@as(GLuint, gl.COLOR_ATTACHMENT0));
-        const draw_buffers: [1]GLuint = .{gl.COLOR_ATTACHMENT0};
-        gl.drawBuffers(1, &draw_buffers);
 
         if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) != gl.FRAMEBUFFER_COMPLETE)
             return error.FrameBufferObejctInitFailed;
@@ -480,8 +394,7 @@ const opengl_impl = struct {
     }
 
     const shader = struct {
-        const Kind = enum { vertex, fragment };
+        const log = std.log.scoped(.shader);
-        const log = std.log.scoped(.Shader);
 
         fn didCompile(id: gl.GLuint) bool {
             var success: gl.GLint = undefined;

src/shader/pixelbuf.frag

@@ -1,7 +1,6 @@
 #version 330 core
 out vec4 frag_color;
 
-in vec3 color;
 in vec2 uv;
 
 uniform sampler2D screen;

src/shader/pixelbuf.vert

@@ -1,13 +1,10 @@
 #version 330 core
-layout (location = 0) in vec3 pos;
-layout (location = 1) in vec3 in_color;
-layout (location = 2) in vec2 in_uv;
-
-out vec3 color;
 out vec2 uv;
 
+const vec2 pos[3] = vec2[3](vec2(-1.0f, -1.0f), vec2(-1.0f, 3.0f), vec2(3.0f, -1.0f));
+const vec2 uvs[3] = vec2[3](vec2( 0.0f,  0.0f), vec2( 0.0f, 2.0f), vec2(2.0f,  0.0f));
+
 void main() {
-	color = in_color;
+	uv = uvs[gl_VertexID];
-	uv = in_uv;
+	gl_Position = vec4(pos[gl_VertexID], 0.0, 1.0);
-	gl_Position = vec4(pos, 1.0);
+}
-}

src/util.zig

@@ -11,24 +11,24 @@ pub const FpsTracker = struct {
     const Self = @This();
 
     fps: u32,
-    count: std.atomic.Atomic(u32),
+    count: std.atomic.Value(u32),
     timer: std.time.Timer,
 
     pub fn init() Self {
         return .{
             .fps = 0,
-            .count = std.atomic.Atomic(u32).init(0),
+            .count = std.atomic.Value(u32).init(0),
             .timer = std.time.Timer.start() catch unreachable,
         };
     }
 
     pub fn tick(self: *Self) void {
-        _ = self.count.fetchAdd(1, .Monotonic);
+        _ = self.count.fetchAdd(1, .monotonic);
     }
 
     pub fn value(self: *Self) u32 {
         if (self.timer.read() >= std.time.ns_per_s) {
-            self.fps = self.count.swap(0, .Monotonic);
+            self.fps = self.count.swap(0, .monotonic);
             self.timer.reset();
         }
 
@@ -52,7 +52,13 @@ pub fn escape(title: [12]u8) [12]u8 {
 pub const FilePaths = struct {
     rom: ?[]const u8,
     bios: ?[]const u8,
-    save: ?[]const u8,
+    save: []const u8,
+
+    pub fn deinit(self: @This(), allocator: Allocator) void {
+        if (self.rom) |path| allocator.free(path);
+        if (self.bios) |path| allocator.free(path);
+        allocator.free(self.save);
+    }
 };
 
 pub const io = struct {
@@ -203,7 +209,7 @@ pub const audio = struct {
 
 /// Sets a quarter (8) of the bits of the u32 `left` to the value of u8 `right`
 pub inline fn setQuart(left: u32, addr: u8, right: u8) u32 {
-    const offset = @truncate(u2, addr);
+    const offset: u2 = @truncate(addr);
 
     return switch (offset) {
         0b00 => (left & 0xFFFF_FF00) | right,
@@ -217,11 +223,11 @@ pub inline fn setQuart(left: u32, addr: u8, right: u8) u32 {
 ///
 /// TODO: Support u16 reads of u32 values?
 pub inline fn getHalf(byte: u8) u4 {
-    return @truncate(u4, byte & 1) << 3;
+    return @as(u4, @truncate(byte & 1)) << 3;
 }
 
 pub inline fn setHalf(comptime T: type, left: T, addr: u8, right: HalfInt(T)) T {
-    const offset = @truncate(u1, addr >> if (T == u32) 1 else 0);
+    const offset: u1 = @truncate(addr >> if (T == u32) 1 else 0);
 
     return switch (T) {
         u32 => switch (offset) {
@@ -289,3 +295,31 @@ pub const FrameBuffer = struct {
         return self.layers[if (dev == .Emulator) self.current else ~self.current];
     }
 };
+
+const RingBuffer = @import("zba-util").RingBuffer;
+
+// TODO: Lock Free Queue?
+pub fn Queue(comptime T: type) type {
+    return struct {
+        inner: RingBuffer(T),
+        mtx: std.Thread.Mutex = .{},
+
+        pub fn init(buf: []T) @This() {
+            return .{ .inner = RingBuffer(T).init(buf) };
+        }
+
+        pub fn push(self: *@This(), value: T) !void {
+            self.mtx.lock();
+            defer self.mtx.unlock();
+
+            try self.inner.push(value);
+        }
+
+        pub fn pop(self: *@This()) ?T {
+            self.mtx.lock();
+            defer self.mtx.unlock();
+
+            return self.inner.pop();
+        }
+    };
+}