fix: implement Ace Lightning (2002) obscure behaviour

fix: reimplement grabbing ROM title if provided via cmd arg
chore: update zgui
2023-04-01 01:23:18 -05:00 · 2023-03-27 16:22:07 -05:00 · 2023-03-26 23:23:34 -05:00 · 2023-03-26 23:23:34 -05:00 · 2023-03-17 11:34:38 -05:00 · 2023-03-17 11:26:14 -05:00
47 changed files with 907 additions and 618 deletions
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -14,7 +14,8 @@ jobs:
  build:
    strategy:
      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
+        # os: [ubuntu-latest, windows-latest, macos-latest]
+        os: [ubuntu-latest, windows-latest]
    runs-on: ${{matrix.os}}
    steps:
      - uses: goto-bus-stop/setup-zig@v2
@@ -23,8 +24,8 @@ jobs:
      - name: prepare-linux
        if: runner.os == 'Linux'
        run: |
-            sudo apt-get update
-            sudo apt-get install libsdl2-dev
+            sudo apt update
+            sudo apt install libgtk-3-dev libsdl2-dev
      - name: prepare-windows
        if: runner.os == 'Windows'
        run: |
@@ -37,9 +38,9 @@ jobs:
            brew install sdl2
      - uses: actions/checkout@v3
        with:
-          submodules: true
+          submodules: recursive
      - name: build 
-        run: zig build -Doptimize=ReleaseSafe
+        run: zig build -Doptimize=ReleaseSafe -Dcpu=baseline
      - name: upload
        uses: actions/upload-artifact@v3
        with:
@@ -50,7 +51,7 @@ jobs:
    steps: 
      - uses: actions/checkout@v3
        with:
-          submodules: true
+          submodules: recursive
      - uses: goto-bus-stop/setup-zig@v2
        with:
          version: master
--- a/.gitmodules
+++ b/.gitmodules
@@ -13,9 +13,15 @@
 [submodule "lib/zig-toml"]
 	path = lib/zig-toml
 	url = https://github.com/aeronavery/zig-toml
+[submodule "lib/zba-gdbstub"]
+	path = lib/zba-gdbstub
+	url = https://git.musuka.dev/paoda/zba-gdbstub
 [submodule "lib/zgui"]
 	path = lib/zgui
 	url = https://git.musuka.dev/paoda/zgui
 [submodule "lib/nfd-zig"]
 	path = lib/nfd-zig
 	url = https://github.com/fabioarnold/nfd-zig
+[submodule "lib/zba-util"]
+	path = lib/zba-util
+	url = https://git.musuka.dev/paoda/zba-util.git
--- a/README.md
+++ b/README.md
@@ -2,6 +2,8 @@

 A Game Boy Advance Emulator written in Zig ⚡!

+![ZBA running リズム天国](assets/screenshot.png)
+
 ## Scope

 I'm hardly the first to write a Game Boy Advance Emulator nor will I be the last. This project isn't going to compete with the GOATs like [mGBA](https://github.com/mgba-emu) or [NanoBoyAdvance](https://github.com/nba-emu/NanoBoyAdvance). There aren't any interesting ideas either like in [DSHBA](https://github.com/DenSinH/DSHBA).
@@ -13,14 +15,13 @@ This is a simple (read: incomplete) for-fun long-term project. I hope to get "mo
 - [x] Affine Sprites
 - [ ] Windowing (see [this branch](https://git.musuka.dev/paoda/zba/src/branch/window))
 - [ ] Audio Resampler (Having issues with SDL2's)
- [x] Immediate Mode GUI (see [this branch](https://git.musuka.dev/paoda/zba/src/branch/imgui))
 - [ ] Refactoring for easy-ish perf boosts

 ## Usage

 As it currently exists, ZBA is run from the terminal. In your console of choice, type `./zba --help` to see what you can do.

-I typically find myself typing `./zba -b ./bin/bios.bin ./bin/test/suite.gba` to see how badly my "cool new feature" broke everything else.
+I typically find myself typing `./zba -b ./bin/bios.bin` and then going to File -> Insert ROM to load the title of my choice.

 Need a BIOS? Why not try using the open-source [Cult-Of-GBA BIOS](https://github.com/Cult-of-GBA/BIOS) written by [fleroviux](https://github.com/fleroviux) and [DenSinH](https://github.com/DenSinH)?

@@ -77,7 +78,7 @@ arm7wrestler GBA Fixed | [destoer](https://github.com/destoer)

 ## Compiling

-Most recently built on Zig [v0.11.0-dev.1557+03cdb4fb5](https://github.com/ziglang/zig/tree/03cdb4fb5)
+Most recently built on Zig [v0.11.0-dev.2168+322ace70f](https://github.com/ziglang/zig/tree/322ace70f)

 ### Dependencies

@@ -98,7 +99,7 @@ Use `git submodule update --init` from the project root to pull the git relevant
 Be sure to provide SDL2 using:

 - Linux: Your distro's package manager
- MacOS: `brew` (install [this formula](https://formulae.brew.sh/formula/sdl2))
+- macOS: ¯\\\_(ツ)_/¯ (try [this formula](https://formulae.brew.sh/formula/sdl2)?)
 - Windows: [`vcpkg`](https://github.com/Microsoft/vcpkg) (install `sdl2:x64-windows`)

 `SDL.zig` will provide a helpful compile error if the zig compiler is unable to find SDL2.
--- a/assets/screenshot.png
+++ b/assets/screenshot.png
--- a/build.zig
+++ b/build.zig
@@ -2,12 +2,13 @@ const std = @import("std");
 const builtin = @import("builtin");

 const Sdk = @import("lib/SDL.zig/Sdk.zig");
+const gdbstub = @import("lib/zba-gdbstub/build.zig");
 const zgui = @import("lib/zgui/build.zig");
 const nfd = @import("lib/nfd-zig/build.zig");

-pub fn build(b: *std.build.Builder) void {
+pub fn build(b: *std.Build) void {
    // Minimum Zig Version
-    const min_ver = std.SemanticVersion.parse("0.11.0-dev.1557+03cdb4fb5") catch return; // https://github.com/ziglang/zig/commit/03cdb4fb5
+    const min_ver = std.SemanticVersion.parse("0.11.0-dev.2168+322ace70f") catch return; // https://github.com/ziglang/zig/commit/322ace70f
    if (builtin.zig_version.order(min_ver).compare(.lt)) {
        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);
@@ -32,7 +33,7 @@ pub fn build(b: *std.build.Builder) void {
    exe.addAnonymousModule("datetime", .{ .source_file = .{ .path = "lib/zig-datetime/src/main.zig" } });

    // Bitfield type from FlorenceOS: https://github.com/FlorenceOS/
-    exe.addAnonymousModule("bitfield", .{ .source_file = .{ .path = "lib/util/bitfield.zig" } });
+    exe.addAnonymousModule("bitfield", .{ .source_file = .{ .path = "lib/bitfield.zig" } });

    // Argument Parsing Library
    exe.addAnonymousModule("clap", .{ .source_file = .{ .path = "lib/zig-clap/clap.zig" } });
@@ -43,6 +44,12 @@ pub fn build(b: *std.build.Builder) void {
    // OpenGL 3.3 Bindings
    exe.addAnonymousModule("gl", .{ .source_file = .{ .path = "lib/gl.zig" } });

+    // ZBA utility code
+    exe.addAnonymousModule("zba-util", .{ .source_file = .{ .path = "lib/zba-util/src/lib.zig" } });
+
+    // gdbstub
+    exe.addModule("gdbstub", gdbstub.getModule(b));
+
    // NativeFileDialog(ue) Bindings
    exe.linkLibrary(nfd.makeLib(b, target, optimize));
    exe.addModule("nfd", nfd.getModule(b));
@@ -53,9 +60,10 @@ pub fn build(b: *std.build.Builder) void {
    exe.addModule("sdl2", sdk.getNativeModule());

    // Dear ImGui bindings
-    const zgui_pkg = zgui.package(b, .{ .options = .{ .backend = .sdl2_opengl3 } });
-    exe.addModule("zgui", zgui_pkg.module);
-    zgui.link(exe, zgui_pkg.options);
+
+    // .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.install();

--- a/lib/SDL.zig
+++ b/lib/SDL.zig
--- a/lib/util/bitfield.zig
+++ b/lib/util/bitfield.zig
--- a/lib/known-folders
+++ b/lib/known-folders
--- a/lib/zba-gdbstub
+++ b/lib/zba-gdbstub
--- a/lib/zba-util
+++ b/lib/zba-util
--- a/lib/zgui
+++ b/lib/zgui
--- a/lib/zig-clap
+++ b/lib/zig-clap
--- a/lib/zig-datetime
+++ b/lib/zig-datetime
--- a/src/core/Bus.zig
+++ b/src/core/Bus.zig
@@ -19,7 +19,7 @@ const log = std.log.scoped(.Bus);

 const createDmaTuple = @import("bus/dma.zig").create;
 const createTimerTuple = @import("bus/timer.zig").create;
-const rotr = @import("../util.zig").rotr;
+const rotr = @import("zba-util").rotr;

 const timings: [2][0x10]u8 = [_][0x10]u8{
    // BIOS, Unused, EWRAM, IWRAM, I/0, PALRAM, VRAM, OAM, ROM0, ROM0, ROM1, ROM1, ROM2, ROM2, SRAM, Unused
@@ -102,10 +102,51 @@ pub fn deinit(self: *Self) void {
    self.* = undefined;
 }

+pub fn reset(self: *Self) void {
+    self.bios.reset();
+    self.ppu.reset();
+    self.apu.reset();
+    self.iwram.reset();
+    self.ewram.reset();
+
+    // https://github.com/ziglang/zig/issues/14705
+    {
+        comptime var i: usize = 0;
+        inline while (i < self.dma.len) : (i += 1) {
+            self.dma[0].reset();
+        }
+    }
+
+    // https://github.com/ziglang/zig/issues/14705
+    {
+        comptime var i: usize = 0;
+        inline while (i < self.tim.len) : (i += 1) {
+            self.tim[0].reset();
+        }
+    }
+
+    self.io.reset();
+}
+
+pub fn replaceGamepak(self: *Self, file_path: []const u8) !void {
+    // Note: `save_path` isn't owned by `Backup`
+    const save_path = self.pak.backup.save_path;
+    self.pak.deinit();
+
+    self.pak = try GamePak.init(self.allocator, self.cpu, file_path, save_path);
+
+    const read_ptr: *[table_len]?*const anyopaque = @constCast(self.read_table);
+    const write_ptrs: [2]*[table_len]?*anyopaque = .{ @constCast(self.write_tables[0]), @constCast(self.write_tables[1]) };
+
+    self.fillReadTable(read_ptr);
+    self.fillWriteTable(u32, write_ptrs[0]);
+    self.fillWriteTable(u8, write_ptrs[1]);
+}
+
 fn fillReadTable(self: *Self, table: *[table_len]?*const anyopaque) void {
    const vramMirror = @import("ppu/Vram.zig").mirror;

-    for (table) |*ptr, i| {
+    for (table, 0..) |*ptr, i| {
        const addr = @intCast(u32, page_size * i);

        ptr.* = switch (addr) {
@@ -132,7 +173,7 @@ fn fillWriteTable(self: *Self, comptime T: type, table: *[table_len]?*const anyo
    comptime std.debug.assert(T == u32 or T == u16 or T == u8);
    const vramMirror = @import("ppu/Vram.zig").mirror;

-    for (table) |*ptr, i| {
+    for (table, 0..) |*ptr, i| {
        const addr = @intCast(u32, page_size * i);

        ptr.* = switch (addr) {
@@ -198,55 +239,6 @@ fn fillReadTableExternal(self: *Self, addr: u32) ?*anyopaque {
    return &self.pak.buf[masked_addr];
 }

-pub fn dbgRead(self: *const Self, comptime T: type, unaligned_address: u32) T {
-    const bits = @typeInfo(std.math.IntFittingRange(0, page_size - 1)).Int.bits;
-    const page = unaligned_address >> bits;
-    const offset = unaligned_address & (page_size - 1);
-
-    // 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 = @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
-        return ptr[forceAlign(T, offset) / @sizeOf(T)];
-    }
-
-    return self.dbgSlowRead(T, unaligned_address);
-}
-
-fn dbgSlowRead(self: *const Self, comptime T: type, unaligned_address: u32) T {
-    const page = @truncate(u8, unaligned_address >> 24);
-    const address = forceAlign(T, unaligned_address);
-
-    return switch (page) {
-        // General Internal Memory
-        0x00 => blk: {
-            if (address < Bios.size)
-                break :blk self.bios.dbgRead(T, self.cpu.r[15], unaligned_address);
-
-            break :blk self.openBus(T, address);
-        },
-        0x02 => unreachable, // handled by fastmem
-        0x03 => unreachable, // handled by fastmem
-        0x04 => self.readIo(T, address),
-
-        // Internal Display Memory
-        0x05 => unreachable, // handled by fastmem
-        0x06 => unreachable, // handled by fastmem
-        0x07 => unreachable, // handled by fastmem
-
-        // External Memory (Game Pak)
-        0x08...0x0D => self.pak.dbgRead(T, address),
-        0x0E...0x0F => self.readBackup(T, unaligned_address),
-        else => self.openBus(T, address),
-    };
-}
-
 fn readIo(self: *const Self, comptime T: type, address: u32) T {
    return io.read(self, T, address) orelse self.openBus(T, address);
 }
@@ -336,6 +328,27 @@ pub fn read(self: *Self, comptime T: type, unaligned_address: u32) T {
    return self.slowRead(T, unaligned_address);
 }

+pub fn dbgRead(self: *const Self, comptime T: type, unaligned_address: u32) T {
+    const bits = @typeInfo(std.math.IntFittingRange(0, page_size - 1)).Int.bits;
+    const page = unaligned_address >> bits;
+    const offset = unaligned_address & (page_size - 1);
+
+    // 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 = @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
+        return ptr[forceAlign(T, offset) / @sizeOf(T)];
+    }
+
+    return self.dbgSlowRead(T, unaligned_address);
+}
+
 fn slowRead(self: *Self, comptime T: type, unaligned_address: u32) T {
    @setCold(true);

@@ -366,6 +379,34 @@ 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 address = forceAlign(T, unaligned_address);
+
+    return switch (page) {
+        // General Internal Memory
+        0x00 => blk: {
+            if (address < Bios.size)
+                break :blk self.bios.dbgRead(T, self.cpu.r[15], unaligned_address);
+
+            break :blk self.openBus(T, address);
+        },
+        0x02 => unreachable, // handled by fastmem
+        0x03 => unreachable, // handled by fastmem
+        0x04 => self.readIo(T, address),
+
+        // Internal Display Memory
+        0x05 => unreachable, // handled by fastmem
+        0x06 => unreachable, // handled by fastmem
+        0x07 => unreachable, // handled by fastmem
+
+        // External Memory (Game Pak)
+        0x08...0x0D => self.pak.dbgRead(T, address),
+        0x0E...0x0F => self.readBackup(T, unaligned_address),
+        else => self.openBus(T, address),
+    };
+}
+
 fn readBackup(self: *const Self, comptime T: type, unaligned_address: u32) T {
    const value = self.pak.backup.read(unaligned_address);

@@ -406,6 +447,31 @@ pub fn write(self: *Self, comptime T: type, unaligned_address: u32, value: T) vo
    }
 }

+/// Mostly Identical to `Bus.write`, slowmeme is handled by `Bus.dbgSlowWrite`
+pub fn dbgWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T) void {
+    const bits = @typeInfo(std.math.IntFittingRange(0, page_size - 1)).Int.bits;
+    const page = unaligned_address >> bits;
+    const offset = unaligned_address & (page_size - 1);
+
+    // 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| {
+        // We have a pointer to a page, cast the pointer to it's underlying type
+        const Ptr = [*]T;
+        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;
+
+        self.dbgSlowWrite(T, unaligned_address, value);
+    }
+}
+
 fn slowWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T) void {
    @setCold(true);

@@ -431,6 +497,31 @@ 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 address = forceAlign(T, unaligned_address);
+
+    switch (page) {
+        // General Internal Memory
+        0x00 => self.bios.write(T, address, value),
+        0x02 => unreachable, // completely handled by fastmem
+        0x03 => unreachable, // completely handled by fastmem
+        0x04 => return, // FIXME: Let debug writes mess with I/O
+
+        // Internal Display Memory
+        0x05 => self.ppu.palette.write(T, address, value),
+        0x06 => self.ppu.vram.write(T, self.ppu.dispcnt, address, value),
+        0x07 => unreachable, // completely handled by fastmem
+
+        // External Memory (Game Pak)
+        0x08...0x0D => return, // FIXME: Debug Write to Backup/GPIO w/out messing with state
+        0x0E...0x0F => return, // FIXME: Debug Write to Backup w/out messing with state
+        else => {},
+    }
+}
+
 inline fn rotateBy(comptime T: type, address: u32) u32 {
    return switch (T) {
        u32 => address & 3,
--- a/src/core/apu.zig
+++ b/src/core/apu.zig
@@ -14,7 +14,6 @@ const SoundFifo = std.fifo.LinearFifo(u8, .{ .Static = 0x20 });

 const getHalf = util.getHalf;
 const setHalf = util.setHalf;
-const intToBytes = util.intToBytes;

 const log = std.log.scoped(.APU);

@@ -279,17 +278,44 @@ pub const Apu = struct {
            .is_buffer_full = false,
        };

-        sched.push(.SampleAudio, apu.interval());
-        sched.push(.{ .ApuChannel = 0 }, @import("apu/signal/Square.zig").interval);
-        sched.push(.{ .ApuChannel = 1 }, @import("apu/signal/Square.zig").interval);
-        sched.push(.{ .ApuChannel = 2 }, @import("apu/signal/Wave.zig").interval);
-        sched.push(.{ .ApuChannel = 3 }, @import("apu/signal/Lfsr.zig").interval);
-        sched.push(.FrameSequencer, FrameSequencer.interval);
+        Self.initEvents(apu.sched, apu.interval());

        return apu;
    }

-    fn reset(self: *Self) void {
+    fn initEvents(scheduler: *Scheduler, apu_interval: u64) void {
+        scheduler.push(.SampleAudio, apu_interval);
+        scheduler.push(.{ .ApuChannel = 0 }, @import("apu/signal/Square.zig").interval);
+        scheduler.push(.{ .ApuChannel = 1 }, @import("apu/signal/Square.zig").interval);
+        scheduler.push(.{ .ApuChannel = 2 }, @import("apu/signal/Wave.zig").interval);
+        scheduler.push(.{ .ApuChannel = 3 }, @import("apu/signal/Lfsr.zig").interval);
+        scheduler.push(.FrameSequencer, FrameSequencer.interval);
+    }
+
+    /// Used when resetting the emulator
+    pub fn reset(self: *Self) void {
+        // FIXME: These reset functions are meant to emulate obscure APU behaviour. Write proper emu reset fns
+        self.ch1.reset();
+        self.ch2.reset();
+        self.ch3.reset();
+        self.ch4.reset();
+
+        self.chA.reset();
+        self.chB.reset();
+
+        self.psg_cnt = .{ .raw = 0 };
+        self.dma_cnt = .{ .raw = 0 };
+        self.cnt = .{ .raw = 0 };
+        self.bias = .{ .raw = 0x200 };
+
+        self.sampling_cycle = 0;
+        self.fs.reset();
+
+        Self.initEvents(self.sched, self.interval());
+    }
+
+    /// Emulates the reset behaviour of the APU
+    fn _reset(self: *Self) void {
        // All PSG Registers between 0x0400_0060..0x0400_0081 are zeroed
        // 0x0400_0082 and 0x0400_0088 retain their values
        self.ch1.reset();
@@ -351,7 +377,7 @@ pub const Apu = struct {
            // Rest Noise
            self.ch4.lfsr.reset();
        } else {
-            self.reset();
+            self._reset();
        }
    }

@@ -528,10 +554,15 @@ pub fn DmaSound(comptime kind: DmaSoundKind) type {
            };
        }

+        /// Used when resetting hte emulator (not emulation code)
+        fn reset(self: *Self) void {
+            self.* = Self.init();
+        }
+
        pub fn push(self: *Self, value: u32) void {
            if (!self.enabled) self.enable();

-            self.fifo.write(&intToBytes(u32, value)) catch |e| log.err("{} Error: {}", .{ kind, e });
+            self.fifo.write(std.mem.asBytes(&value)) catch |e| log.err("{} Error: {}", .{ kind, e });
        }

        fn enable(self: *Self) void {
@@ -562,10 +593,14 @@ pub const FrameSequencer = struct {
    const Self = @This();
    pub const interval = (1 << 24) / 512;

-    step: u3,
+    step: u3 = 0,

    pub fn init() Self {
-        return .{ .step = 0 };
+        return .{};
+    }
+
+    pub fn reset(self: *Self) void {
+        self.* = .{};
    }

    pub fn tick(self: *Self) void {
--- a/src/core/apu/device/Envelope.zig
+++ b/src/core/apu/device/Envelope.zig
@@ -3,17 +3,16 @@ const io = @import("../../bus/io.zig");
 const Self = @This();

 /// Period Timer
-timer: u3,
+timer: u3 = 0,
 /// Current Volume
-vol: u4,
+vol: u4 = 0,

 pub fn create() Self {
-    return .{ .timer = 0, .vol = 0 };
+    return .{};
 }

 pub fn reset(self: *Self) void {
-    self.timer = 0;
-    self.vol = 0;
+    self.* = .{};
 }

 pub fn tick(self: *Self, nrx2: io.Envelope) void {
--- a/src/core/apu/device/Length.zig
+++ b/src/core/apu/device/Length.zig
@@ -1,13 +1,13 @@
 const Self = @This();

-timer: u9,
+timer: u9 = 0,

 pub fn create() Self {
-    return .{ .timer = 0 };
+    return .{};
 }

 pub fn reset(self: *Self) void {
-    self.timer = 0;
+    self.* = .{};
 }

 pub fn tick(self: *Self, enabled: bool, ch_enable: *bool) void {
--- a/src/core/apu/device/Sweep.zig
+++ b/src/core/apu/device/Sweep.zig
@@ -3,26 +3,18 @@ const ToneSweep = @import("../ToneSweep.zig");

 const Self = @This();

-timer: u8,
-enabled: bool,
-shadow: u11,
+timer: u8 = 0,
+enabled: bool = false,
+shadow: u11 = 0,

-calc_performed: bool,
+calc_performed: bool = false,

 pub fn create() Self {
-    return .{
-        .timer = 0,
-        .enabled = false,
-        .shadow = 0,
-        .calc_performed = false,
-    };
+    return .{};
 }

 pub fn reset(self: *Self) void {
-    self.timer = 0;
-    self.enabled = false;
-    self.shadow = 0;
-    self.calc_performed = false;
+    self.* = .{};
 }

 pub fn tick(self: *Self, ch1: *ToneSweep) void {
--- a/src/core/bus/Bios.zig
+++ b/src/core/bus/Bios.zig
@@ -3,7 +3,7 @@ const std = @import("std");
 const Allocator = std.mem.Allocator;
 const log = std.log.scoped(.Bios);

-const rotr = @import("../../util.zig").rotr;
+const rotr = @import("zba-util").rotr;
 const forceAlign = @import("../Bus.zig").forceAlign;

 /// Size of the BIOS in bytes
@@ -77,6 +77,10 @@ pub fn init(allocator: Allocator, maybe_path: ?[]const u8) !Self {
    return Self{ .buf = buf, .allocator = allocator };
 }

+pub fn reset(self: *Self) void {
+    self.addr_latch = 0;
+}
+
 pub fn deinit(self: *Self) void {
    if (self.buf) |buf| self.allocator.free(buf);
    self.* = undefined;
--- a/src/core/bus/Ewram.zig
+++ b/src/core/bus/Ewram.zig
@@ -35,6 +35,10 @@ pub fn init(allocator: Allocator) !Self {
    };
 }

+pub fn reset(self: *Self) void {
+    std.mem.set(u8, self.buf, 0);
+}
+
 pub fn deinit(self: *Self) void {
    self.allocator.free(self.buf);
    self.* = undefined;
--- a/src/core/bus/GamePak.zig
+++ b/src/core/bus/GamePak.zig
@@ -179,23 +179,30 @@ pub fn write(self: *Self, comptime T: type, word_count: u16, address: u32, value
    }
 }

-pub fn init(allocator: Allocator, cpu: *Arm7tdmi, rom_path: []const u8, save_path: ?[]const u8) !Self {
-    const file = try std.fs.cwd().openFile(rom_path, .{});
-    defer file.close();
+pub fn init(allocator: Allocator, cpu: *Arm7tdmi, maybe_rom: ?[]const u8, maybe_save: ?[]const u8) !Self {
+    const Device = Gpio.Device;

-    const file_buf = try file.readToEndAlloc(allocator, try file.getEndPos());
-    const title = file_buf[0xA0..0xAC].*;
-    const kind = Backup.guess(file_buf);
-    const device = if (config.config().guest.force_rtc) .Rtc else guessDevice(file_buf);
+    const items: struct { []u8, [12]u8, Backup.Kind, Device.Kind } = if (maybe_rom) |file_path| blk: {
+        const file = try std.fs.cwd().openFile(file_path, .{});
+        defer file.close();

-    logHeader(file_buf, title);
+        const buffer = try file.readToEndAlloc(allocator, try file.getEndPos());
+        const title = buffer[0xA0..0xAC];
+        logHeader(buffer, title);
+
+        const device_kind = if (config.config().guest.force_rtc) .Rtc else guessDevice(buffer);
+
+        break :blk .{ buffer, title.*, Backup.guess(buffer), device_kind };
+    } else .{ try allocator.alloc(u8, 0), [_]u8{0} ** 12, .None, .None };
+
+    const title = items[1];

    return .{
-        .buf = file_buf,
+        .buf = items[0],
        .allocator = allocator,
        .title = title,
-        .backup = try Backup.init(allocator, kind, title, save_path),
-        .gpio = try Gpio.init(allocator, cpu, device),
+        .backup = try Backup.init(allocator, items[2], title, maybe_save),
+        .gpio = try Gpio.init(allocator, cpu, items[3]),
    };
 }

@@ -213,6 +220,7 @@ fn guessDevice(buf: []const u8) Gpio.Device.Kind {
    // Try to Guess if ROM uses RTC
    const needle = "RTC_V"; // I was told SIIRTC_V, though Pokemen Firered (USA) is a false negative

+    // TODO: Use new for loop syntax?
    var i: usize = 0;
    while ((i + needle.len) < buf.len) : (i += 1) {
        if (std.mem.eql(u8, needle, buf[i..(i + needle.len)])) return .Rtc;
@@ -222,11 +230,11 @@ fn guessDevice(buf: []const u8) Gpio.Device.Kind {
    return .None;
 }

-fn logHeader(buf: []const u8, title: [12]u8) void {
-    const ver = buf[0xBC];
+fn logHeader(buf: []const u8, title: *const [12]u8) void {
+    const version = buf[0xBC];

    log.info("Title: {s}", .{title});
-    if (ver != 0) log.info("Version: {}", .{ver});
+    if (version != 0) log.info("Version: {}", .{version});

    log.info("Game Code: {s}", .{buf[0xAC..0xB0]});
    log.info("Maker Code: {s}", .{buf[0xB0..0xB2]});
--- a/src/core/bus/Iwram.zig
+++ b/src/core/bus/Iwram.zig
@@ -35,6 +35,10 @@ pub fn init(allocator: Allocator) !Self {
    };
 }

+pub fn reset(self: *Self) void {
+    std.mem.set(u8, self.buf, 0);
+}
+
 pub fn deinit(self: *Self) void {
    self.allocator.free(self.buf);
    self.* = undefined;
--- a/src/core/bus/backup.zig
+++ b/src/core/bus/backup.zig
@@ -32,7 +32,7 @@ pub const Backup = struct {
    flash: Flash,
    eeprom: Eeprom,

-    const Kind = enum {
+    pub const Kind = enum {
        Eeprom,
        Sram,
        Flash,
@@ -137,6 +137,7 @@ pub const Backup = struct {
        for (backup_kinds) |needle| {
            const needle_len = needle.str.len;

+            // TODO: Use new for loop syntax?
            var i: usize = 0;
            while ((i + needle_len) < rom.len) : (i += 1) {
                if (std.mem.eql(u8, needle.str, rom[i..][0..needle_len])) return needle.kind;
@@ -204,6 +205,10 @@ pub const Backup = struct {
        const file_path = try self.savePath(allocator, path);
        defer allocator.free(file_path);

+        // FIXME: communicate edge case to the user?
+        if (std.mem.eql(u8, &self.title, "ACE LIGHTNIN"))
+            return;
+
        switch (self.kind) {
            .Sram, .Flash, .Flash1M, .Eeprom => {
                const file = try std.fs.createFileAbsolute(file_path, .{});
--- a/src/core/bus/dma.zig
+++ b/src/core/bus/dma.zig
@@ -12,7 +12,7 @@ const getHalf = util.getHalf;
 const setHalf = util.setHalf;
 const setQuart = util.setQuart;

-const rotr = @import("../../util.zig").rotr;
+const rotr = @import("zba-util").rotr;

 pub fn create() DmaTuple {
    return .{ DmaController(0).init(), DmaController(1).init(), DmaController(2).init(), DmaController(3).init() };
@@ -195,6 +195,10 @@ fn DmaController(comptime id: u2) type {
            };
        }

+        pub fn reset(self: *Self) void {
+            self.* = Self.init();
+        }
+
        pub fn setDmasad(self: *Self, addr: u32) void {
            self.sad = addr & sad_mask;
        }
@@ -339,10 +343,7 @@ fn DmaController(comptime id: u2) type {
 }

 pub fn onBlanking(bus: *Bus, comptime kind: DmaKind) void {
-    comptime var i: usize = 0;
-    inline while (i < 4) : (i += 1) {
-        bus.dma[i].poll(kind);
-    }
+    inline for (0..4) |i| bus.dma[i].poll(kind);
 }

 const Adjustment = enum(u2) {
--- a/src/core/bus/gpio.zig
+++ b/src/core/bus/gpio.zig
@@ -293,13 +293,13 @@ pub const Clock = struct {
        self.cpu.sched.push(.RealTimeClock, (1 << 24) -| late); // Reschedule

        const now = DateTime.now();
-        self.year = bcd(u8, @intCast(u8, now.date.year - 2000));
-        self.month = bcd(u5, now.date.month);
-        self.day = bcd(u6, now.date.day);
-        self.weekday = bcd(u3, (now.date.weekday() + 1) % 7); // API is Monday = 0, Sunday = 6. We want Sunday = 0, Saturday = 6
-        self.hour = bcd(u6, now.time.hour);
-        self.minute = bcd(u7, now.time.minute);
-        self.second = bcd(u7, now.time.second);
+        self.year = bcd(@intCast(u8, now.date.year - 2000));
+        self.month = @truncate(u5, bcd(now.date.month));
+        self.day = @truncate(u6, 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.hour = @truncate(u6, bcd(now.time.hour));
+        self.minute = @truncate(u7, bcd(now.time.minute));
+        self.second = @truncate(u7, bcd(now.time.second));
    }

    fn step(self: *Self, value: Data) u4 {
@@ -449,16 +449,8 @@ pub const Clock = struct {
    }
 };

-fn bcd(comptime T: type, value: u8) T {
-    var input = value;
-    var ret: u8 = 0;
-    var shift: u3 = 0;
-
-    while (input > 0) {
-        ret |= (input % 10) << (shift << 2);
-        shift += 1;
-        input /= 10;
-    }
-
-    return @truncate(T, ret);
+/// Converts an 8-bit unsigned integer to its BCD representation.
+/// Note: Algorithm only works for values between 0 and 99 inclusive.
+fn bcd(value: u8) u8 {
+    return ((value / 10) << 4) + (value % 10);
 }
--- a/src/core/bus/io.zig
+++ b/src/core/bus/io.zig
@@ -38,6 +38,10 @@ pub const Io = struct {
        };
    }

+    pub fn reset(self: *Self) void {
+        self.* = Self.init();
+    }
+
    fn setIrqs(self: *Io, word: u32) void {
        self.ie.raw = @truncate(u16, word);
        self.irq.raw &= ~@truncate(u16, word >> 16);
--- a/src/core/bus/timer.zig
+++ b/src/core/bus/timer.zig
@@ -128,6 +128,12 @@ fn Timer(comptime id: u2) type {
            };
        }

+        pub fn reset(self: *Self) void {
+            const scheduler = self.sched;
+
+            self.* = Self.init(scheduler);
+        }
+
        /// TIMCNT_L Getter
        pub fn timcntL(self: *const Self) u16 {
            if (self.cnt.cascade.read() or !self.cnt.enabled.read()) return self._counter;
--- a/src/core/cpu.zig
+++ b/src/core/cpu.zig
@@ -39,13 +39,12 @@ pub const arm = struct {
    }

    fn populate() [0x1000]InstrFn {
-        return comptime {
+        comptime {
            @setEvalBranchQuota(0xE000);
-            var ret = [_]InstrFn{und} ** 0x1000;
+            var table = [_]InstrFn{und} ** 0x1000;

-            var i: usize = 0;
-            while (i < ret.len) : (i += 1) {
-                ret[i] = switch (@as(u2, i >> 10)) {
+            for (&table, 0..) |*handler, i| {
+                handler.* = switch (@as(u2, i >> 10)) {
                    0b00 => if (i == 0x121) blk: {
                        break :blk branchExchange;
                    } else if (i & 0xFCF == 0x009) blk: {
@@ -107,8 +106,8 @@ pub const arm = struct {
                };
            }

-            return ret;
-        };
+            return table;
+        }
    }
 };

@@ -136,13 +135,12 @@ pub const thumb = struct {
    }

    fn populate() [0x400]InstrFn {
-        return comptime {
+        comptime {
            @setEvalBranchQuota(5025); // This is exact
-            var ret = [_]InstrFn{und} ** 0x400;
+            var table = [_]InstrFn{und} ** 0x400;

-            var i: usize = 0;
-            while (i < ret.len) : (i += 1) {
-                ret[i] = switch (@as(u3, i >> 7 & 0x7)) {
+            for (&table, 0..) |*handler, i| {
+                handler.* = switch (@as(u3, i >> 7 & 0x7)) {
                    0b000 => if (i >> 5 & 0x3 == 0b11) blk: {
                        const I = i >> 4 & 1 == 1;
                        const is_sub = i >> 3 & 1 == 1;
@@ -230,8 +228,8 @@ pub const thumb = struct {
                };
            }

-            return ret;
-        };
+            return table;
+        }
    }
 };

@@ -316,6 +314,14 @@ pub const Arm7tdmi = struct {
        };
    }

+    // FIXME: Resetting disables logging (if enabled)
+    pub fn reset(self: *Self) void {
+        const bus_ptr = self.bus;
+        const scheduler_ptr = self.sched;
+
+        self.* = Self.init(scheduler_ptr, bus_ptr, null);
+    }
+
    pub inline fn hasSPSR(self: *const Self) bool {
        const mode = getModeChecked(self, self.cpsr.mode.read());
        return switch (mode) {
@@ -385,8 +391,7 @@ pub const Arm7tdmi = struct {
        const now = getModeChecked(self, self.cpsr.mode.read());

        // Bank R8 -> r12
-        var i: usize = 0;
-        while (i < 5) : (i += 1) {
+        for (0..5) |i| {
            self.bank.fiq[Bank.fiqIdx(i, now)] = self.r[8 + i];
        }

@@ -404,8 +409,7 @@ pub const Arm7tdmi = struct {
        }

        // Grab R8 -> R12
-        i = 0;
-        while (i < 5) : (i += 1) {
+        for (0..5) |i| {
            self.r[8 + i] = self.bank.fiq[Bank.fiqIdx(i, next)];
        }

@@ -470,8 +474,7 @@ pub const Arm7tdmi = struct {
    }

    pub fn stepDmaTransfer(self: *Self) bool {
-        comptime var i: usize = 0;
-        inline while (i < 4) : (i += 1) {
+        inline for (0..4) |i| {
            if (self.bus.dma[i].in_progress) {
                self.bus.dma[i].step(self);
                return true;
--- a/src/core/cpu/arm/branch.zig
+++ b/src/core/cpu/arm/branch.zig
@@ -2,7 +2,7 @@ const Bus = @import("../../Bus.zig");
 const Arm7tdmi = @import("../../cpu.zig").Arm7tdmi;
 const InstrFn = @import("../../cpu.zig").arm.InstrFn;

-const sext = @import("../../../util.zig").sext;
+const sext = @import("zba-util").sext;

 pub fn branch(comptime L: bool) InstrFn {
    return struct {
--- a/src/core/cpu/arm/half_signed_data_transfer.zig
+++ b/src/core/cpu/arm/half_signed_data_transfer.zig
@@ -2,8 +2,8 @@ const Bus = @import("../../Bus.zig");
 const Arm7tdmi = @import("../../cpu.zig").Arm7tdmi;
 const InstrFn = @import("../../cpu.zig").arm.InstrFn;

-const sext = @import("../../../util.zig").sext;
-const rotr = @import("../../../util.zig").rotr;
+const sext = @import("zba-util").sext;
+const rotr = @import("zba-util").rotr;

 pub fn halfAndSignedDataTransfer(comptime P: bool, comptime U: bool, comptime I: bool, comptime W: bool, comptime L: bool) InstrFn {
    return struct {
--- a/src/core/cpu/arm/psr_transfer.zig
+++ b/src/core/cpu/arm/psr_transfer.zig
@@ -7,7 +7,7 @@ const PSR = @import("../../cpu.zig").PSR;

 const log = std.log.scoped(.PsrTransfer);

-const rotr = @import("../../../util.zig").rotr;
+const rotr = @import("zba-util").rotr;

 pub fn psrTransfer(comptime I: bool, comptime R: bool, comptime kind: u2) InstrFn {
    return struct {
--- a/src/core/cpu/arm/single_data_swap.zig
+++ b/src/core/cpu/arm/single_data_swap.zig
@@ -2,7 +2,7 @@ const Bus = @import("../../Bus.zig");
 const Arm7tdmi = @import("../../cpu.zig").Arm7tdmi;
 const InstrFn = @import("../../cpu.zig").arm.InstrFn;

-const rotr = @import("../../../util.zig").rotr;
+const rotr = @import("zba-util").rotr;

 pub fn singleDataSwap(comptime B: bool) InstrFn {
    return struct {
--- a/src/core/cpu/arm/single_data_transfer.zig
+++ b/src/core/cpu/arm/single_data_transfer.zig
@@ -3,7 +3,7 @@ const Bus = @import("../../Bus.zig");
 const Arm7tdmi = @import("../../cpu.zig").Arm7tdmi;
 const InstrFn = @import("../../cpu.zig").arm.InstrFn;

-const rotr = @import("../../../util.zig").rotr;
+const rotr = @import("zba-util").rotr;

 pub fn singleDataTransfer(comptime I: bool, comptime P: bool, comptime U: bool, comptime B: bool, comptime W: bool, comptime L: bool) InstrFn {
    return struct {
--- a/src/core/cpu/barrel_shifter.zig
+++ b/src/core/cpu/barrel_shifter.zig
@@ -1,7 +1,7 @@
 const Arm7tdmi = @import("../cpu.zig").Arm7tdmi;
 const CPSR = @import("../cpu.zig").PSR;

-const rotr = @import("../../util.zig").rotr;
+const rotr = @import("zba-util").rotr;

 pub fn exec(comptime S: bool, cpu: *Arm7tdmi, opcode: u32) u32 {
    var result: u32 = undefined;
--- a/src/core/cpu/thumb/block_data_transfer.zig
+++ b/src/core/cpu/thumb/block_data_transfer.zig
@@ -92,8 +92,7 @@ pub fn fmt15(comptime L: bool, comptime rb: u3) InstrFn {
 inline fn countRlist(opcode: u16) u32 {
    var count: u32 = 0;

-    comptime var i: u4 = 0;
-    inline while (i < 8) : (i += 1) {
+    inline for (0..8) |i| {
        if (opcode >> (7 - i) & 1 == 1) count += 1;
    }

--- a/src/core/cpu/thumb/branch.zig
+++ b/src/core/cpu/thumb/branch.zig
@@ -3,7 +3,7 @@ const Arm7tdmi = @import("../../cpu.zig").Arm7tdmi;
 const InstrFn = @import("../../cpu.zig").thumb.InstrFn;

 const checkCond = @import("../../cpu.zig").checkCond;
-const sext = @import("../../../util.zig").sext;
+const sext = @import("zba-util").sext;

 pub fn fmt16(comptime cond: u4) InstrFn {
    return struct {
--- a/src/core/cpu/thumb/data_transfer.zig
+++ b/src/core/cpu/thumb/data_transfer.zig
@@ -2,8 +2,8 @@ const Bus = @import("../../Bus.zig");
 const Arm7tdmi = @import("../../cpu.zig").Arm7tdmi;
 const InstrFn = @import("../../cpu.zig").thumb.InstrFn;

-const rotr = @import("../../../util.zig").rotr;
-const sext = @import("../../../util.zig").sext;
+const rotr = @import("zba-util").rotr;
+const sext = @import("zba-util").sext;

 pub fn fmt6(comptime rd: u3) InstrFn {
    return struct {
--- a/src/core/emu.zig
+++ b/src/core/emu.zig
@@ -5,9 +5,9 @@ const config = @import("../config.zig");
 const Scheduler = @import("scheduler.zig").Scheduler;
 const Arm7tdmi = @import("cpu.zig").Arm7tdmi;
 const Tracker = @import("../util.zig").FpsTracker;
+const TwoWayChannel = @import("zba-util").TwoWayChannel;

 const Timer = std.time.Timer;
-const Atomic = std.atomic.Atomic;

 /// 4 Cycles in 1 dot
 const cycles_per_dot = 4;
@@ -35,29 +35,40 @@ const RunKind = enum {
    LimitedFPS,
 };

-pub fn run(quit: *Atomic(bool), pause: *Atomic(bool), cpu: *Arm7tdmi, scheduler: *Scheduler, tracker: *Tracker) void {
+pub fn run(cpu: *Arm7tdmi, scheduler: *Scheduler, tracker: *Tracker, channel: *TwoWayChannel) 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, quit, pause, cpu, scheduler, tracker);
+        inner(.LimitedFPS, audio_sync, cpu, scheduler, tracker, channel);
    } else {
-        inner(.UnlimitedFPS, audio_sync, quit, pause, cpu, scheduler, tracker);
+        inner(.UnlimitedFPS, audio_sync, cpu, scheduler, tracker, channel);
    }
 }

-fn inner(comptime kind: RunKind, audio_sync: bool, quit: *Atomic(bool), pause: *Atomic(bool), cpu: *Arm7tdmi, scheduler: *Scheduler, tracker: ?*Tracker) void {
+fn inner(comptime kind: RunKind, audio_sync: bool, cpu: *Arm7tdmi, scheduler: *Scheduler, tracker: ?*Tracker, channel: *TwoWayChannel) void {
    if (kind == .UnlimitedFPS or kind == .LimitedFPS) {
        std.debug.assert(tracker != null);
        log.info("FPS tracking enabled", .{});
    }

+    var paused: bool = false;
+
    switch (kind) {
        .Unlimited, .UnlimitedFPS => {
            log.info("Emulation w/out video sync", .{});

-            while (!quit.load(.Monotonic)) {
-                if (pause.load(.Monotonic)) continue;
+            while (true) {
+                if (channel.emu.pop()) |e| switch (e) {
+                    .Quit => break,
+                    .Resume => paused = false,
+                    .Pause => {
+                        paused = true;
+                        channel.gui.push(.Paused);
+                    },
+                };
+
+                if (paused) continue;

                runFrame(scheduler, cpu);
                audioSync(audio_sync, cpu.bus.apu.stream, &cpu.bus.apu.is_buffer_full);
@@ -70,8 +81,17 @@ fn inner(comptime kind: RunKind, audio_sync: bool, quit: *Atomic(bool), pause: *
            var timer = Timer.start() catch @panic("failed to initalize std.timer.Timer");
            var wake_time: u64 = frame_period;

-            while (!quit.load(.Monotonic)) {
-                if (pause.load(.Monotonic)) continue;
+            while (true) {
+                if (channel.emu.pop()) |e| switch (e) {
+                    .Quit => break,
+                    .Resume => paused = false,
+                    .Pause => {
+                        paused = true;
+                        channel.gui.push(.Paused);
+                    },
+                };
+
+                if (paused) continue;

                runFrame(scheduler, cpu);
                const new_wake_time = videoSync(&timer, wake_time);
@@ -150,9 +170,8 @@ fn sleep(timer: *Timer, wake_time: u64) ?u64 {

    const step = 2 * std.time.ns_per_ms; // Granularity of 2ms
    const times = sleep_for / step;
-    var i: usize = 0;

-    while (i < times) : (i += 1) {
+    for (0..times) |_| {
        std.time.sleep(step);

        // Upon wakeup, check to see if this particular sleep was longer than expected
@@ -167,3 +186,71 @@ fn sleep(timer: *Timer, wake_time: u64) ?u64 {
 fn spinLoop(timer: *Timer, wake_time: u64) void {
    while (true) if (timer.read() > wake_time) break;
 }
+
+pub const EmuThing = struct {
+    const Self = @This();
+    const Interface = @import("gdbstub").Emulator;
+    const Allocator = std.mem.Allocator;
+
+    cpu: *Arm7tdmi,
+    scheduler: *Scheduler,
+
+    pub fn init(cpu: *Arm7tdmi, scheduler: *Scheduler) Self {
+        return .{ .cpu = cpu, .scheduler = scheduler };
+    }
+
+    pub fn interface(self: *Self, allocator: Allocator) Interface {
+        return Interface.init(allocator, self);
+    }
+
+    pub fn read(self: *const Self, addr: u32) u8 {
+        return self.cpu.bus.dbgRead(u8, addr);
+    }
+
+    pub fn write(self: *Self, addr: u32, value: u8) void {
+        self.cpu.bus.dbgWrite(u8, addr, value);
+    }
+
+    pub fn registers(self: *const Self) *[16]u32 {
+        return &self.cpu.r;
+    }
+
+    pub fn cpsr(self: *const Self) u32 {
+        return self.cpu.cpsr.raw;
+    }
+
+    pub fn step(self: *Self) void {
+        const cpu = self.cpu;
+        const sched = self.scheduler;
+
+        // Is true when we have executed one (1) instruction
+        var did_step: bool = false;
+
+        // TODO: How can I make it easier to keep this in lock-step with runFrame?
+        while (!did_step) {
+            if (!cpu.stepDmaTransfer()) {
+                if (cpu.isHalted()) {
+                    // Fast-forward to next Event
+                    sched.tick = sched.queue.peek().?.tick;
+                } else {
+                    cpu.step();
+                    did_step = true;
+                }
+            }
+
+            if (sched.tick >= sched.nextTimestamp()) sched.handleEvent(cpu);
+        }
+    }
+};
+
+pub 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 {
+    try cpu.bus.replaceGamepak(file_path);
+    reset(cpu);
+}
--- a/src/core/ppu.zig
+++ b/src/core/ppu.zig
@@ -290,6 +290,26 @@ pub const Ppu = struct {
        };
    }

+    pub fn reset(self: *Self) void {
+        self.sched.push(.Draw, 240 * 4);
+
+        self.vram.reset();
+        self.palette.reset();
+        self.oam.reset();
+        self.framebuf.reset();
+
+        self.win = Window.init();
+        self.bg = [_]Background{Background.init()} ** 4;
+        self.aff_bg = [_]AffineBackground{AffineBackground.init()} ** 2;
+        self.bld = Blend.create();
+        self.dispcnt = .{ .raw = 0x0000 };
+        self.dispstat = .{ .raw = 0x0000 };
+        self.vcount = .{ .raw = 0x0000 };
+
+        self.scanline.reset();
+        std.mem.set(?Sprite, self.scanline_sprites, null);
+    }
+
    pub fn deinit(self: *Self) void {
        self.allocator.destroy(self.scanline_sprites);
        self.framebuf.deinit();
@@ -625,8 +645,7 @@ pub const Ppu = struct {
                const framebuf_base = width * @as(usize, scanline);
                if (obj_enable) self.fetchSprites();

-                var layer: usize = 0;
-                while (layer < 4) : (layer += 1) {
+                for (0..4) |layer| {
                    self.drawSprites(@truncate(u2, 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);
@@ -640,8 +659,7 @@ pub const Ppu = struct {
                const framebuf_base = width * @as(usize, scanline);
                if (obj_enable) self.fetchSprites();

-                var layer: usize = 0;
-                while (layer < 4) : (layer += 1) {
+                for (0..4) |layer| {
                    self.drawSprites(@truncate(u2, 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);
@@ -654,8 +672,7 @@ pub const Ppu = struct {
                const framebuf_base = width * @as(usize, scanline);
                if (obj_enable) self.fetchSprites();

-                var layer: usize = 0;
-                while (layer < 4) : (layer += 1) {
+                for (0..4) |layer| {
                    self.drawSprites(@truncate(u2, 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);
@@ -671,7 +688,7 @@ pub const Ppu = struct {
                const vram_buf = @ptrCast([*]const u16, @alignCast(@alignOf(u16), self.vram.buf));
                const framebuf = @ptrCast([*]u32, @alignCast(@alignOf(u32), self.framebuf.get(.Emulator)));

-                for (vram_buf[vram_base .. vram_base + width]) |bgr555, i| {
+                for (vram_buf[vram_base .. vram_base + width], 0..) |bgr555, i| {
                    framebuf[framebuf_base + i] = rgba888(bgr555);
                }
            },
@@ -685,7 +702,7 @@ pub const Ppu = struct {
                const pal_buf = @ptrCast([*]const u16, @alignCast(@alignOf(u16), self.palette.buf));
                const framebuf = @ptrCast([*]u32, @alignCast(@alignOf(u32), self.framebuf.get(.Emulator)));

-                for (self.vram.buf[vram_base .. vram_base + width]) |pal_id, i| {
+                for (self.vram.buf[vram_base .. vram_base + width], 0..) |pal_id, i| {
                    framebuf[framebuf_base + i] = rgba888(pal_buf[pal_id]);
                }
            },
@@ -701,8 +718,7 @@ pub const Ppu = struct {
                const vram_buf = @ptrCast([*]const u16, @alignCast(@alignOf(u16), self.vram.buf));
                const framebuf = @ptrCast([*]u32, @alignCast(@alignOf(u32), self.framebuf.get(.Emulator)));

-                var i: usize = 0;
-                while (i < width) : (i += 1) {
+                for (0..width) |i| {
                    const bgr555 = if (scanline < m5_height and i < m5_width) vram_buf[vram_base + i] else self.palette.backdrop();
                    framebuf[framebuf_base + i] = rgba888(bgr555);
                }
@@ -718,7 +734,7 @@ pub const Ppu = struct {
        // FIXME: @ptrCast between slices changing the length isn't implemented yet
        const framebuf = @ptrCast([*]u32, @alignCast(@alignOf(u32), self.framebuf.get(.Emulator)));

-        for (self.scanline.top()) |maybe_top, i| {
+        for (self.scanline.top(), 0..) |maybe_top, i| {
            const maybe_btm = self.scanline.btm()[i];

            const bgr555 = self.getBgr555(maybe_top, maybe_btm);
@@ -990,8 +1006,7 @@ pub const Ppu = struct {
            cpu.handleInterrupt();
        }

-        // See if HBlank DMA is present and not enabled
-
+        // If we're not also in VBlank, attempt to run any pending DMA Reqs
        if (!self.dispstat.vblank.read())
            dma.onBlanking(cpu.bus, .HBlank);

--- a/src/core/ppu/Oam.zig
+++ b/src/core/ppu/Oam.zig
@@ -34,6 +34,10 @@ pub fn init(allocator: Allocator) !Self {
    return Self{ .buf = buf, .allocator = allocator };
 }

+pub fn reset(self: *Self) void {
+    std.mem.set(u8, self.buf, 0);
+}
+
 pub fn deinit(self: *Self) void {
    self.allocator.free(self.buf);
    self.* = undefined;
--- a/src/core/ppu/Palette.zig
+++ b/src/core/ppu/Palette.zig
@@ -37,6 +37,10 @@ pub fn init(allocator: Allocator) !Self {
    return Self{ .buf = buf, .allocator = allocator };
 }

+pub fn reset(self: *Self) void {
+    std.mem.set(u8, self.buf, 0);
+}
+
 pub fn deinit(self: *Self) void {
    self.allocator.free(self.buf);
    self.* = undefined;
--- a/src/core/ppu/Vram.zig
+++ b/src/core/ppu/Vram.zig
@@ -45,6 +45,10 @@ pub fn init(allocator: Allocator) !Self {
    return Self{ .buf = buf, .allocator = allocator };
 }

+pub fn reset(self: *Self) void {
+    std.mem.set(u8, self.buf, 0);
+}
+
 pub fn deinit(self: *Self) void {
    self.allocator.free(self.buf);
    self.* = undefined;
--- a/src/core/scheduler.zig
+++ b/src/core/scheduler.zig
@@ -11,11 +11,11 @@ const log = std.log.scoped(.Scheduler);
 pub const Scheduler = struct {
    const Self = @This();

-    tick: u64,
+    tick: u64 = 0,
    queue: PriorityQueue(Event, void, lessThan),

    pub fn init(allocator: Allocator) Self {
-        var sched = Self{ .tick = 0, .queue = PriorityQueue(Event, void, lessThan).init(allocator, {}) };
+        var sched = Self{ .queue = PriorityQueue(Event, void, lessThan).init(allocator, {}) };
        sched.queue.add(.{ .kind = .HeatDeath, .tick = std.math.maxInt(u64) }) catch unreachable;

        return sched;
@@ -26,6 +26,17 @@ pub const Scheduler = struct {
        self.* = undefined;
    }

+    pub fn reset(self: *Self) void {
+        // `std.PriorityQueue` provides no reset function, so we will just create a new one
+        const allocator = self.queue.allocator;
+        self.queue.deinit();
+
+        var new_queue = PriorityQueue(Event, void, lessThan).init(allocator, {});
+        new_queue.add(.{ .kind = .HeatDeath, .tick = std.math.maxInt(u64) }) catch unreachable;
+
+        self.* = .{ .queue = new_queue };
+    }
+
    pub inline fn now(self: *const Self) u64 {
        return self.tick;
    }
@@ -73,7 +84,7 @@ pub const Scheduler = struct {

    /// Removes the **first** scheduled event of type `needle`
    pub fn removeScheduledEvent(self: *Self, needle: EventKind) void {
-        for (self.queue.items) |event, i| {
+        for (self.queue.items, 0..) |event, i| {
            if (std.meta.eql(event.kind, needle)) {

                // invalidates the slice we're iterating over
--- a/src/imgui.zig
+++ b/src/imgui.zig
@@ -0,0 +1,307 @@
+//! Namespace for dealing with ZBA's immediate-mode GUI
+//! Currently, ZBA uses zgui from https://github.com/michal-z/zig-gamedev
+//! which provides Zig bindings for https://github.com/ocornut/imgui under the hood
+
+const std = @import("std");
+const zgui = @import("zgui");
+const gl = @import("gl");
+const nfd = @import("nfd");
+const config = @import("config.zig");
+const emu = @import("core/emu.zig");
+
+const Gui = @import("platform.zig").Gui;
+const Arm7tdmi = @import("core/cpu.zig").Arm7tdmi;
+const RingBuffer = @import("zba-util").RingBuffer;
+
+const Allocator = std.mem.Allocator;
+const GLuint = gl.GLuint;
+
+const gba_width = @import("core/ppu.zig").width;
+const gba_height = @import("core/ppu.zig").height;
+
+const log = std.log.scoped(.Imgui);
+
+// two seconds worth of fps values into the past
+const histogram_len = 0x80;
+
+/// Immediate-Mode GUI State
+pub const State = struct {
+    title: [12:0]u8,
+
+    fps_hist: RingBuffer(u32),
+    should_quit: bool = false,
+
+    /// if zba is initialized with a ROM already provided, this initializer should be called
+    /// with `title_opt` being non-null
+    pub fn init(allocator: Allocator, title_opt: ?*const [12]u8) !@This() {
+        const history = try allocator.alloc(u32, histogram_len);
+
+        const title: [12:0]u8 = if (title_opt) |t| t.* ++ [_:0]u8{} else "[No Title]\x00\x00".*;
+        return .{ .title = title, .fps_hist = RingBuffer(u32).init(history) };
+    }
+
+    pub fn deinit(self: *@This(), allocator: Allocator) void {
+        allocator.free(self.fps_hist.buf);
+        self.* = undefined;
+    }
+};
+
+pub fn draw(state: *State, tex_id: GLuint, cpu: *Arm7tdmi) void {
+    const win_scale = config.config().host.win_scale;
+
+    {
+        _ = zgui.beginMainMenuBar();
+        defer zgui.endMainMenuBar();
+
+        if (zgui.beginMenu("File", true)) {
+            defer zgui.endMenu();
+
+            if (zgui.menuItem("Quit", .{})) state.should_quit = true;
+
+            if (zgui.menuItem("Insert ROM", .{})) blk: {
+                const maybe_path = nfd.openFileDialog("gba", null) catch |e| {
+                    log.err("failed to open file dialog: {}", .{e});
+                    break :blk;
+                };
+
+                const file_path = maybe_path orelse {
+                    log.warn("did not receive a file path", .{});
+                    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});
+                    break :blk;
+                };
+
+                state.title = cpu.bus.pak.title ++ [_:0]u8{};
+            }
+        }
+
+        if (zgui.beginMenu("Emulation", true)) {
+            defer zgui.endMenu();
+
+            if (zgui.menuItem("Restart", .{})) {
+                emu.reset(cpu);
+            }
+        }
+    }
+
+    {
+        const w = @intToFloat(f32, gba_width * win_scale);
+        const h = @intToFloat(f32, gba_height * win_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.begin("Information", .{});
+        defer zgui.end();
+
+        for (0..8) |i| {
+            zgui.text("R{}: 0x{X:0>8}", .{ i, cpu.r[i] });
+
+            zgui.sameLine(.{});
+
+            const padding = if (8 + i < 10) " " else "";
+            zgui.text("{s}R{}: 0x{X:0>8}", .{ padding, 8 + i, cpu.r[8 + i] });
+        }
+
+        zgui.separator();
+
+        widgets.psr("CPSR", cpu.cpsr);
+        widgets.psr("SPSR", cpu.spsr);
+
+        zgui.separator();
+
+        widgets.interrupts(" IE", cpu.bus.io.ie);
+        widgets.interrupts("IRQ", cpu.bus.io.irq);
+    }
+
+    {
+        _ = zgui.begin("Performance", .{});
+        defer zgui.end();
+
+        const tmp = blk: {
+            var buf: [histogram_len]u32 = undefined;
+            const len = state.fps_hist.copy(&buf);
+
+            break :blk .{ buf, len };
+        };
+        const values = tmp[0];
+        const len = tmp[1];
+
+        if (len == values.len) _ = state.fps_hist.pop();
+
+        const sorted = blk: {
+            var buf: @TypeOf(values) = undefined;
+
+            std.mem.copy(u32, buf[0..len], values[0..len]);
+            std.sort.sort(u32, buf[0..len], {}, std.sort.asc(u32));
+
+            break :blk buf;
+        };
+
+        const y_max = 2 * if (len != 0) @intToFloat(f64, sorted[len - 1]) else emu.frame_rate;
+        const x_max = @intToFloat(f64, 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 } };
+
+        if (zgui.plot.beginPlot("Emulation FPS", .{ .w = 0.0, .flags = .{ .no_title = true, .no_frame = true } })) {
+            defer zgui.plot.endPlot();
+
+            zgui.plot.setupLegend(.{ .north = true, .east = true }, .{});
+            zgui.plot.setupAxis(.x1, x_args);
+            zgui.plot.setupAxis(.y1, y_args);
+            zgui.plot.setupAxisLimits(.y1, .{ .min = 0.0, .max = y_max, .cond = .always });
+            zgui.plot.setupAxisLimits(.x1, .{ .min = 0.0, .max = x_max, .cond = .always });
+            zgui.plot.setupFinish();
+
+            zgui.plot.plotLineValues("FPS", u32, .{ .v = values[0..len] });
+        }
+
+        const stats: struct { u32, u32, u32 } = blk: {
+            if (len == 0) break :blk .{ 0, 0, 0 };
+
+            const average = average: {
+                var sum: u32 = 0;
+                for (sorted[0..len]) |value| sum += value;
+
+                break :average @intCast(u32, sum / len);
+            };
+            const median = sorted[len / 2];
+            const low = sorted[len / 100]; // 1% Low
+
+            break :blk .{ average, median, low };
+        };
+
+        zgui.text("Average: {:0>3} fps", .{stats[0]});
+        zgui.text(" Median: {:0>3} fps", .{stats[1]});
+        zgui.text(" 1% Low: {:0>3} fps", .{stats[2]});
+    }
+
+    {
+        _ = zgui.begin("Scheduler", .{});
+        defer zgui.end();
+
+        const scheduler = cpu.sched;
+
+        zgui.text("tick: {X:0>16}", .{scheduler.tick});
+        zgui.separator();
+
+        const Event = std.meta.Child(@TypeOf(scheduler.queue.items));
+
+        var items: [20]Event = undefined;
+        const len = scheduler.queue.len;
+
+        std.mem.copy(Event, &items, scheduler.queue.items);
+        std.sort.sort(Event, items[0..len], {}, widgets.eventDesc(Event));
+
+        for (items[0..len]) |event| {
+            zgui.text("{X:0>16} | {?}", .{ event.tick, event.kind });
+        }
+    }
+
+    // {
+    //     zgui.showDemoWindow(null);
+    // }
+}
+
+const widgets = struct {
+    fn interrupts(comptime label: []const u8, int: anytype) void {
+        const h = 15.0;
+        const w = 9.0 * 2 + 3.5;
+        const ww = 9.0 * 3;
+
+        {
+            zgui.text(label ++ ":", .{});
+
+            zgui.sameLine(.{});
+            _ = zgui.selectable("VBL", .{ .w = w, .h = h, .selected = int.vblank.read() });
+
+            zgui.sameLine(.{});
+            _ = zgui.selectable("HBL", .{ .w = w, .h = h, .selected = int.hblank.read() });
+
+            zgui.sameLine(.{});
+            _ = zgui.selectable("VCT", .{ .w = w, .h = h, .selected = int.coincidence.read() });
+
+            {
+                zgui.sameLine(.{});
+                _ = zgui.selectable("TIM0", .{ .w = ww, .h = h, .selected = int.tim0.read() });
+
+                zgui.sameLine(.{});
+                _ = zgui.selectable("TIM1", .{ .w = ww, .h = h, .selected = int.tim1.read() });
+
+                zgui.sameLine(.{});
+                _ = zgui.selectable("TIM2", .{ .w = ww, .h = h, .selected = int.tim2.read() });
+
+                zgui.sameLine(.{});
+                _ = zgui.selectable("TIM3", .{ .w = ww, .h = h, .selected = int.tim3.read() });
+            }
+
+            zgui.sameLine(.{});
+            _ = zgui.selectable("SRL", .{ .w = w, .h = h, .selected = int.serial.read() });
+
+            {
+                zgui.sameLine(.{});
+                _ = zgui.selectable("DMA0", .{ .w = ww, .h = h, .selected = int.dma0.read() });
+
+                zgui.sameLine(.{});
+                _ = zgui.selectable("DMA1", .{ .w = ww, .h = h, .selected = int.dma1.read() });
+
+                zgui.sameLine(.{});
+                _ = zgui.selectable("DMA2", .{ .w = ww, .h = h, .selected = int.dma2.read() });
+
+                zgui.sameLine(.{});
+                _ = zgui.selectable("DMA3", .{ .w = ww, .h = h, .selected = int.dma3.read() });
+            }
+
+            zgui.sameLine(.{});
+            _ = zgui.selectable("KPD", .{ .w = w, .h = h, .selected = int.keypad.read() });
+
+            zgui.sameLine(.{});
+            _ = zgui.selectable("GPK", .{ .w = w, .h = h, .selected = int.game_pak.read() });
+        }
+    }
+
+    fn psr(comptime label: []const u8, register: anytype) void {
+        const Mode = @import("core/cpu.zig").Mode;
+
+        const maybe_mode = std.meta.intToEnum(Mode, register.mode.read()) catch null;
+        const mode = if (maybe_mode) |mode| mode.toString() else "???";
+        const w = 9.0;
+        const h = 15.0;
+
+        zgui.text(label ++ ": 0x{X:0>8}", .{register.raw});
+
+        zgui.sameLine(.{});
+        _ = zgui.selectable("N", .{ .w = w, .h = h, .selected = register.n.read() });
+
+        zgui.sameLine(.{});
+        _ = zgui.selectable("Z", .{ .w = w, .h = h, .selected = register.z.read() });
+
+        zgui.sameLine(.{});
+        _ = zgui.selectable("C", .{ .w = w, .h = h, .selected = register.c.read() });
+
+        zgui.sameLine(.{});
+        _ = zgui.selectable("V", .{ .w = w, .h = h, .selected = register.v.read() });
+
+        zgui.sameLine(.{});
+        zgui.text("{s}", .{mode});
+    }
+
+    fn eventDesc(comptime T: type) fn (void, T, T) bool {
+        return struct {
+            fn inner(_: void, left: T, right: T) bool {
+                return left.tick > right.tick;
+            }
+        }.inner;
+    }
+};
--- a/src/main.zig
+++ b/src/main.zig
@@ -4,14 +4,17 @@ const known_folders = @import("known_folders");
 const clap = @import("clap");

 const config = @import("config.zig");
+const emu = @import("core/emu.zig");

+const TwoWayChannel = @import("zba-util").TwoWayChannel;
 const Gui = @import("platform.zig").Gui;
 const Bus = @import("core/Bus.zig");
 const Arm7tdmi = @import("core/cpu.zig").Arm7tdmi;
 const Scheduler = @import("core/scheduler.zig").Scheduler;
 const FilePaths = @import("util.zig").FilePaths;
-
+const FpsTracker = @import("util.zig").FpsTracker;
 const Allocator = std.mem.Allocator;
+
 const log = std.log.scoped(.Cli);
 pub const log_level = if (builtin.mode != .Debug) .info else std.log.default_level;

@@ -20,6 +23,7 @@ const params = clap.parseParamsComptime(
    \\-h, --help            Display this help and exit.
    \\-s, --skip            Skip BIOS.
    \\-b, --bios <str>      Optional path to a GBA BIOS ROM.
+    \\ --gdb                Run ZBA from the context of a GDB Server
    \\<str>                 Path to the GBA GamePak ROM.
    \\
 );
@@ -66,9 +70,10 @@ pub fn main() void {
    const paths = handleArguments(allocator, data_path, &result) catch |e| exitln("failed to handle cli arguments: {}", .{e});
    defer if (paths.save) |path| allocator.free(path);

-    const log_file = if (config.config().debug.cpu_trace) blk: {
-        break :blk std.fs.cwd().createFile("zba.log", .{}) catch |e| exitln("failed to create trace log file: {}", .{e});
-    } else null;
+    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}),
+        false => null,
+    };
    defer if (log_file) |file| file.close();

    // TODO: Take Emulator Init Code out of main.zig
@@ -85,16 +90,58 @@ pub fn main() void {
        cpu.fastBoot();
    }

+    const title_ptr = if (paths.rom != null) &bus.pak.title else null;
+
    // TODO: Just copy the title instead of grabbing a pointer to it
-    var gui = Gui.init(allocator, bus.pak.title, &bus.apu) catch |e| exitln("failed to init gui: {}", .{e});
+    var gui = Gui.init(allocator, &bus.apu, title_ptr) catch |e| exitln("failed to init gui: {}", .{e});
    defer gui.deinit();

-    gui.run(&cpu, &scheduler) catch |e| exitln("failed to run gui thread: {}", .{e});
+    var quit = std.atomic.Atomic(bool).init(false);
+
+    var items: [0x100]u8 = undefined;
+    var channel = TwoWayChannel.init(&items);
+
+    if (result.args.gdb) {
+        const Server = @import("gdbstub").Server;
+        const EmuThing = @import("core/emu.zig").EmuThing;
+
+        var wrapper = EmuThing.init(&cpu, &scheduler);
+        var emulator = wrapper.interface(allocator);
+        defer emulator.deinit();
+
+        log.info("Ready to connect", .{});
+
+        var server = Server.init(emulator) 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});
+        defer thread.join();
+
+        gui.run(.{
+            .cpu = &cpu,
+            .scheduler = &scheduler,
+            .channel = &channel,
+        }) catch |e| exitln("main thread panicked: {}", .{e});
+    } else {
+        var tracker = FpsTracker.init();
+
+        const thread = std.Thread.spawn(.{}, emu.run, .{ &cpu, &scheduler, &tracker, &channel }) catch |e| exitln("emu thread panicked: {}", .{e});
+        defer thread.join();
+
+        gui.run(.{
+            .cpu = &cpu,
+            .scheduler = &scheduler,
+            .channel = &channel,
+            .tracker = &tracker,
+        }) catch |e| exitln("main thread panicked: {}", .{e});
+    }
 }

-pub fn handleArguments(allocator: Allocator, data_path: []const u8, result: *const clap.Result(clap.Help, &params, clap.parsers.default)) !FilePaths {
+fn handleArguments(allocator: Allocator, data_path: []const u8, result: *const clap.Result(clap.Help, &params, clap.parsers.default)) !FilePaths {
    const rom_path = romPath(result);
-    log.info("ROM path: {s}", .{rom_path});
+    log.info("ROM path: {?s}", .{rom_path});

    const bios_path = result.args.bios;
    if (bios_path) |path| log.info("BIOS path: {s}", .{path}) else log.warn("No BIOS provided", .{});
@@ -143,10 +190,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(result: *const clap.Result(clap.Help, &params, clap.parsers.default)) ?[]const u8 {
    return switch (result.positionals.len) {
+        0 => null,
        1 => result.positionals[0],
-        0 => exitln("ZBA requires a path to a GamePak ROM", .{}),
        else => exitln("ZBA received too many positional arguments.", .{}),
    };
 }
--- a/src/platform.zig
+++ b/src/platform.zig
@@ -2,16 +2,16 @@ const std = @import("std");
 const SDL = @import("sdl2");
 const gl = @import("gl");
 const zgui = @import("zgui");
-const nfd = @import("nfd");

 const emu = @import("core/emu.zig");
 const config = @import("config.zig");
+const imgui = @import("imgui.zig");

 const Apu = @import("core/apu.zig").Apu;
 const Arm7tdmi = @import("core/cpu.zig").Arm7tdmi;
 const Scheduler = @import("core/scheduler.zig").Scheduler;
 const FpsTracker = @import("util.zig").FpsTracker;
-const RingBuffer = @import("util.zig").RingBuffer;
+const TwoWayChannel = @import("zba-util").TwoWayChannel;

 const gba_width = @import("core/ppu.zig").width;
 const gba_height = @import("core/ppu.zig").height;
@@ -27,27 +27,12 @@ const height = 720;
 pub const sample_rate = 1 << 15;
 pub const sample_format = SDL.AUDIO_U16;

-const default_title = "ZBA";
+const window_title = "ZBA";

 pub const Gui = struct {
    const Self = @This();
    const log = std.log.scoped(.Gui);

-    const State = struct {
-        fps_hist: RingBuffer(u32),
-        should_quit: bool = false,
-
-        pub fn init(allocator: Allocator) !@This() {
-            const history = try allocator.alloc(u32, 0x400);
-            return .{ .fps_hist = RingBuffer(u32).init(history) };
-        }
-
-        fn deinit(self: *@This(), allocator: Allocator) void {
-            self.fps_hist.deinit(allocator);
-            self.* = undefined;
-        }
-    };
-
    // zig fmt: off
    const vertices: [32]f32 = [_]f32{
        // Positions        // Colours      // Texture Coords
@@ -65,22 +50,21 @@ pub const Gui = struct {

    window: *SDL.SDL_Window,
    ctx: SDL_GLContext,
-    title: [:0]const u8,
    audio: Audio,

-    state: State,
+    state: imgui.State,

    allocator: Allocator,
    program_id: gl.GLuint,

-    pub fn init(allocator: Allocator, title: [12]u8, apu: *Apu) !Self {
+    pub fn init(allocator: Allocator, apu: *Apu, title_opt: ?*const [12]u8) !Self {
        if (SDL.SDL_Init(SDL.SDL_INIT_VIDEO | SDL.SDL_INIT_EVENTS | SDL.SDL_INIT_AUDIO) < 0) panic();
        if (SDL.SDL_GL_SetAttribute(SDL.SDL_GL_CONTEXT_PROFILE_MASK, SDL.SDL_GL_CONTEXT_PROFILE_CORE) < 0) panic();
        if (SDL.SDL_GL_SetAttribute(SDL.SDL_GL_CONTEXT_MAJOR_VERSION, 3) < 0) panic();
        if (SDL.SDL_GL_SetAttribute(SDL.SDL_GL_CONTEXT_MAJOR_VERSION, 3) < 0) panic();

        const window = SDL.SDL_CreateWindow(
-            default_title,
+            window_title,
            SDL.SDL_WINDOWPOS_CENTERED,
            SDL.SDL_WINDOWPOS_CENTERED,
            width,
@@ -102,13 +86,12 @@ pub const Gui = struct {

        return Self{
            .window = window,
-            .title = try allocator.dupeZ(u8, &title),
            .ctx = ctx,
            .program_id = try compileShaders(),
            .audio = Audio.init(apu),

            .allocator = allocator,
-            .state = try State.init(allocator),
+            .state = try imgui.State.init(allocator, title_opt),
        };
    }

@@ -125,7 +108,6 @@ pub const Gui = struct {
        SDL.SDL_DestroyWindow(self.window);
        SDL.SDL_Quit();

-        self.allocator.free(self.title);
        self.* = undefined;
    }

@@ -200,7 +182,7 @@ pub const Gui = struct {
        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), @intToPtr(?*anyopaque, 0)); // lmao
+        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))));
@@ -260,167 +242,18 @@ pub const Gui = struct {
        return fbo_id;
    }

-    fn draw(self: *Self, tex_id: GLuint, cpu: *const Arm7tdmi) void {
-        const win_scale = config.config().host.win_scale;
+    const RunOptions = struct {
+        channel: *TwoWayChannel,
+        tracker: ?*FpsTracker = null,
+        cpu: *Arm7tdmi,
+        scheduler: *Scheduler,
+    };

-        {
-            _ = zgui.beginMainMenuBar();
-            defer zgui.endMainMenuBar();
+    pub fn run(self: *Self, opt: RunOptions) !void {
+        const cpu = opt.cpu;
+        const tracker = opt.tracker;
+        const channel = opt.channel;

-            if (zgui.beginMenu("File", true)) {
-                defer zgui.endMenu();
-
-                if (zgui.menuItem("Quit", .{})) self.state.should_quit = true;
-                if (zgui.menuItem("Insert ROM", .{})) blk: {
-                    const maybe_path = nfd.openFileDialog("gba", null) catch |e| {
-                        log.err("failed to open file dialog: {?}", .{e});
-                        break :blk;
-                    };
-
-                    if (maybe_path) |file_path| {
-                        defer nfd.freePath(file_path);
-                        log.info("user chose: \"{s}\"", .{file_path});
-
-                        // emu.loadRom(cpu, file_path);
-                    }
-                }
-            }
-
-            if (zgui.beginMenu("Emulation", true)) {
-                defer zgui.endMenu();
-
-                if (zgui.menuItem("Restart", .{})) log.warn("TODO: Restart Emulator", .{});
-            }
-        }
-
-        {
-            const w = @intToFloat(f32, gba_width * win_scale);
-            const h = @intToFloat(f32, gba_height * win_scale);
-
-            _ = zgui.begin(self.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.begin("Information", .{});
-            defer zgui.end();
-
-            {
-                var i: usize = 0;
-                while (i < 8) : (i += 1) {
-                    zgui.text("R{}: 0x{X:0>8}", .{ i, cpu.r[i] });
-
-                    zgui.sameLine(.{});
-
-                    const prefix = if (8 + i < 10) " " else "";
-                    zgui.text("{s}R{}: 0x{X:0>8}", .{ prefix, 8 + i, cpu.r[8 + i] });
-                }
-            }
-
-            zgui.separator();
-
-            widgets.psr("CPSR", cpu.cpsr);
-            widgets.psr("SPSR", cpu.spsr);
-
-            zgui.separator();
-
-            widgets.interrupts(" IE", cpu.bus.io.ie); // space is for padding
-            widgets.interrupts("IRQ", cpu.bus.io.irq);
-        }
-
-        {
-            _ = zgui.begin("Performance", .{});
-            defer zgui.end();
-
-            const tmp = blk: {
-                var buf: [0x400]u32 = undefined;
-                const len = self.state.fps_hist.copy(&buf);
-
-                break :blk .{ buf, len };
-            };
-            const values = tmp[0];
-            const len = tmp[1];
-
-            if (len == values.len) _ = self.state.fps_hist.pop();
-
-            const sorted = blk: {
-                var buf: @TypeOf(values) = undefined;
-
-                std.mem.copy(u32, buf[0..len], values[0..len]);
-                std.sort.sort(u32, buf[0..len], {}, std.sort.asc(u32));
-
-                break :blk buf;
-            };
-
-            const y_max = 2 * if (len != 0) @intToFloat(f64, sorted[len - 1]) else emu.frame_rate;
-            const x_max = @intToFloat(f64, 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 } };
-
-            if (zgui.plot.beginPlot("Emulation FPS", .{ .w = 0.0, .flags = .{ .no_title = true, .no_frame = true } })) {
-                defer zgui.plot.endPlot();
-
-                zgui.plot.setupLegend(.{ .north = true, .east = true }, .{});
-                zgui.plot.setupAxis(.x1, x_args);
-                zgui.plot.setupAxis(.y1, y_args);
-                zgui.plot.setupAxisLimits(.y1, .{ .min = 0.0, .max = y_max, .cond = .always });
-                zgui.plot.setupAxisLimits(.x1, .{ .min = 0.0, .max = x_max, .cond = .always });
-                zgui.plot.setupFinish();
-
-                zgui.plot.plotLineValues("FPS", u32, .{ .v = values[0..len] });
-            }
-
-            const stats: struct { u32, u32, u32 } = blk: {
-                if (len == 0) break :blk .{ 0, 0, 0 };
-
-                const average = average: {
-                    var sum: u32 = 0;
-                    for (sorted[0..len]) |value| sum += value;
-
-                    break :average @intCast(u32, sum / len);
-                };
-                const median = sorted[len / 2];
-                const low = sorted[len / 100]; // 1% Low
-
-                break :blk .{ average, median, low };
-            };
-
-            zgui.text("Average: {:0>3} fps", .{stats[0]});
-            zgui.text(" Median: {:0>3} fps", .{stats[1]});
-            zgui.text(" 1% Low: {:0>3} fps", .{stats[2]});
-        }
-
-        {
-            _ = zgui.begin("Scheduler", .{});
-            defer zgui.end();
-
-            const scheduler = cpu.sched;
-
-            zgui.text("tick: {X:0>16}", .{scheduler.tick});
-            zgui.separator();
-
-            const Event = std.meta.Child(@TypeOf(scheduler.queue.items));
-
-            var items: [20]Event = undefined;
-            const len = scheduler.queue.len;
-
-            std.mem.copy(Event, &items, scheduler.queue.items);
-            std.sort.sort(Event, items[0..len], {}, widgets.eventDesc(Event));
-
-            for (items[0..len]) |event| {
-                zgui.text("{X:0>16} | {?}", .{ event.tick, event.kind });
-            }
-        }
-
-        {
-            zgui.showDemoWindow(null);
-        }
-    }
-
-    pub fn run(self: *Self, cpu: *Arm7tdmi, scheduler: *Scheduler) !void {
        const obj_ids = Self.genBufferObjects();
        defer gl.deleteBuffers(3, @as(*const [3]c_uint, &obj_ids));

@@ -431,20 +264,19 @@ pub const Gui = struct {
        const fbo_id = try Self.genFrameBufObject(out_tex);
        defer gl.deleteFramebuffers(1, &fbo_id);

-        var tracker = FpsTracker.init();
-        var quit = std.atomic.Atomic(bool).init(false);
-        var pause = std.atomic.Atomic(bool).init(false);
-
-        const thread = try std.Thread.spawn(.{}, emu.run, .{ &quit, &pause, cpu, scheduler, &tracker });
-        defer thread.join();
-        defer quit.store(true, .Monotonic); // Terminate Emulator Thread
-
        emu_loop: while (true) {
-            var event: SDL.SDL_Event = undefined;
+            // `quit` from RunOptions may be modified by the GDBSTUB thread,
+            // so we want to recognize that it may change to `true` and exit the GUI thread
+            if (channel.gui.pop()) |event| switch (event) {
+                .Quit => break :emu_loop,
+                .Paused => @panic("TODO: We want to peek (and then pop if it's .Quit), not always pop"),
+            };

-            // Quit Signal from Dear Imgui
+            // 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;

+            var event: SDL.SDL_Event = undefined;
            while (SDL.SDL_PollEvent(&event) != 0) {
                _ = zgui.backend.processEvent(&event);

@@ -494,12 +326,18 @@ pub const Gui = struct {
                }
            }

-            // We Access non-atomic parts of the Emulator here
            {
-                pause.store(true, .Monotonic);
-                defer pause.store(false, .Monotonic);
+                channel.emu.push(.Pause);
+                defer channel.emu.push(.Resume);

-                self.state.fps_hist.push(tracker.value()) catch {};
+                // Spin Loop until we know that the emu is paused
+                wait: while (true) switch (channel.gui.pop() orelse continue) {
+                    .Paused => break :wait,
+                    else => |any| std.debug.panic("[Gui/Channel]: Unhandled Event: {}", .{any}),
+                };
+
+                // Add FPS count to the histogram
+                if (tracker) |t| self.state.fps_hist.push(t.value()) catch {};

                // Draw GBA Screen to Texture
                {
@@ -518,12 +356,14 @@ pub const Gui = struct {
                gl.clear(gl.COLOR_BUFFER_BIT);

                zgui.backend.newFrame(width, height);
-                self.draw(out_tex, cpu);
+                imgui.draw(&self.state, out_tex, cpu);
                zgui.backend.draw();
            }

            SDL.SDL_GL_SwapWindow(self.window);
        }
+
+        channel.emu.push(.Quit);
    }

    fn glGetProcAddress(ctx: SDL.SDL_GLContext, proc: [:0]const u8) ?*anyopaque {
@@ -601,95 +441,3 @@ fn panic() noreturn {
    const str = @as(?[*:0]const u8, SDL.SDL_GetError()) orelse "unknown error";
    @panic(std.mem.sliceTo(str, 0));
 }
-
-const widgets = struct {
-    fn interrupts(comptime label: []const u8, int: anytype) void {
-        const h = 15.0;
-        const w = 9.0 * 2 + 3.5;
-        const ww = 9.0 * 3;
-
-        {
-            zgui.text(label ++ ":", .{});
-
-            zgui.sameLine(.{});
-            _ = zgui.selectable("VBL", .{ .w = w, .h = h, .selected = int.vblank.read() });
-
-            zgui.sameLine(.{});
-            _ = zgui.selectable("HBL", .{ .w = w, .h = h, .selected = int.hblank.read() });
-
-            zgui.sameLine(.{});
-            _ = zgui.selectable("VCT", .{ .w = w, .h = h, .selected = int.coincidence.read() });
-
-            {
-                zgui.sameLine(.{});
-                _ = zgui.selectable("TIM0", .{ .w = ww, .h = h, .selected = int.tim0.read() });
-
-                zgui.sameLine(.{});
-                _ = zgui.selectable("TIM1", .{ .w = ww, .h = h, .selected = int.tim1.read() });
-
-                zgui.sameLine(.{});
-                _ = zgui.selectable("TIM2", .{ .w = ww, .h = h, .selected = int.tim2.read() });
-
-                zgui.sameLine(.{});
-                _ = zgui.selectable("TIM3", .{ .w = ww, .h = h, .selected = int.tim3.read() });
-            }
-
-            zgui.sameLine(.{});
-            _ = zgui.selectable("SRL", .{ .w = w, .h = h, .selected = int.serial.read() });
-
-            {
-                zgui.sameLine(.{});
-                _ = zgui.selectable("DMA0", .{ .w = ww, .h = h, .selected = int.dma0.read() });
-
-                zgui.sameLine(.{});
-                _ = zgui.selectable("DMA1", .{ .w = ww, .h = h, .selected = int.dma1.read() });
-
-                zgui.sameLine(.{});
-                _ = zgui.selectable("DMA2", .{ .w = ww, .h = h, .selected = int.dma2.read() });
-
-                zgui.sameLine(.{});
-                _ = zgui.selectable("DMA3", .{ .w = ww, .h = h, .selected = int.dma3.read() });
-            }
-
-            zgui.sameLine(.{});
-            _ = zgui.selectable("KPD", .{ .w = w, .h = h, .selected = int.keypad.read() });
-
-            zgui.sameLine(.{});
-            _ = zgui.selectable("GPK", .{ .w = w, .h = h, .selected = int.game_pak.read() });
-        }
-    }
-
-    fn psr(comptime label: []const u8, register: anytype) void {
-        const Mode = @import("core/cpu.zig").Mode;
-
-        const maybe_mode = std.meta.intToEnum(Mode, register.mode.read()) catch null;
-        const mode = if (maybe_mode) |mode| mode.toString() else "???";
-        const w = 9.0;
-        const h = 15.0;
-
-        zgui.text(label ++ ": 0x{X:0>8}", .{register.raw});
-
-        zgui.sameLine(.{});
-        _ = zgui.selectable("N", .{ .w = w, .h = h, .selected = register.n.read() });
-
-        zgui.sameLine(.{});
-        _ = zgui.selectable("Z", .{ .w = w, .h = h, .selected = register.z.read() });
-
-        zgui.sameLine(.{});
-        _ = zgui.selectable("C", .{ .w = w, .h = h, .selected = register.c.read() });
-
-        zgui.sameLine(.{});
-        _ = zgui.selectable("V", .{ .w = w, .h = h, .selected = register.v.read() });
-
-        zgui.sameLine(.{});
-        zgui.text("{s}", .{mode});
-    }
-
-    fn eventDesc(comptime T: type) fn (void, T, T) bool {
-        return struct {
-            fn inner(_: void, left: T, right: T) bool {
-                return left.tick > right.tick;
-            }
-        }.inner;
-    }
-};
--- a/src/util.zig
+++ b/src/util.zig
@@ -7,27 +7,6 @@ const Arm7tdmi = @import("core/cpu.zig").Arm7tdmi;

 const Allocator = std.mem.Allocator;

-// Sign-Extend value of type `T` to type `U`
-pub fn sext(comptime T: type, comptime U: type, value: T) T {
-    // U must have less bits than T
-    comptime std.debug.assert(@typeInfo(U).Int.bits <= @typeInfo(T).Int.bits);
-
-    const iT = std.meta.Int(.signed, @typeInfo(T).Int.bits);
-    const ExtU = if (@typeInfo(U).Int.signedness == .unsigned) T else iT;
-    const shift_amt = @intCast(Log2Int(T), @typeInfo(T).Int.bits - @typeInfo(U).Int.bits);
-
-    return @bitCast(T, @bitCast(iT, @as(ExtU, @truncate(U, value)) << shift_amt) >> shift_amt);
-}
-
-/// See https://godbolt.org/z/W3en9Eche
-pub inline fn rotr(comptime T: type, x: T, r: anytype) T {
-    if (@typeInfo(T).Int.signedness == .signed)
-        @compileError("cannot rotate signed integer");
-
-    const ar = @intCast(Log2Int(T), @mod(r, @typeInfo(T).Int.bits));
-    return x >> ar | x << (1 +% ~ar);
-}
-
 pub const FpsTracker = struct {
    const Self = @This();

@@ -57,17 +36,6 @@ pub const FpsTracker = struct {
    }
 };

-pub fn intToBytes(comptime T: type, value: anytype) [@sizeOf(T)]u8 {
-    comptime std.debug.assert(@typeInfo(T) == .Int);
-
-    var result: [@sizeOf(T)]u8 = undefined;
-
-    var i: Log2Int(T) = 0;
-    while (i < result.len) : (i += 1) result[i] = @truncate(u8, value >> i * @bitSizeOf(u8));
-
-    return result;
-}
-
 /// Creates a copy of a title with all Filesystem-invalid characters replaced
 ///
 /// e.g. POKEPIN R/S to POKEPIN R_S
@@ -82,7 +50,7 @@ pub fn escape(title: [12]u8) [12]u8 {
 }

 pub const FilePaths = struct {
-    rom: []const u8,
+    rom: ?[]const u8,
    bios: ?[]const u8,
    save: ?[]const u8,
 };
@@ -283,7 +251,7 @@ pub const FrameBuffer = struct {

    layers: [2][]u8,
    buf: []u8,
-    current: u1,
+    current: u1 = 0,

    allocator: Allocator,

@@ -298,12 +266,16 @@ pub const FrameBuffer = struct {
            // Front and Back Framebuffers
            .layers = [_][]u8{ buf[0..][0..len], buf[len..][0..len] },
            .buf = buf,
-            .current = 0,

            .allocator = allocator,
        };
    }

+    pub fn reset(self: *Self) void {
+        std.mem.set(u8, self.buf, 0);
+        self.current = 0;
+    }
+
    pub fn deinit(self: *Self) void {
        self.allocator.free(self.buf);
        self.* = undefined;
@@ -317,78 +289,3 @@ pub const FrameBuffer = struct {
        return self.layers[if (dev == .Emulator) self.current else ~self.current];
    }
 };
-
-pub fn RingBuffer(comptime T: type) type {
-    return struct {
-        const Self = @This();
-        const Index = usize;
-        const max_capacity = (@as(Index, 1) << @typeInfo(Index).Int.bits - 1) - 1; // half the range of index type
-
-        const log = std.log.scoped(.RingBuffer);
-
-        read: Index,
-        write: Index,
-        buf: []T,
-
-        const Error = error{buffer_full};
-
-        pub fn init(buf: []T) Self {
-            std.debug.assert(std.math.isPowerOfTwo(buf.len)); // capacity must be a power of two
-            std.debug.assert(buf.len <= max_capacity);
-
-            std.mem.set(T, buf, 0);
-
-            return .{ .read = 0, .write = 0, .buf = buf };
-        }
-
-        pub fn deinit(self: *Self, allocator: Allocator) void {
-            allocator.free(self.buf);
-            self.* = undefined;
-        }
-
-        pub fn push(self: *Self, value: T) Error!void {
-            if (self.isFull()) return error.buffer_full;
-            defer self.write += 1;
-
-            self.buf[self.mask(self.write)] = value;
-        }
-
-        pub fn pop(self: *Self) ?T {
-            if (self.isEmpty()) return null;
-            defer self.read += 1;
-
-            return self.buf[self.mask(self.read)];
-        }
-
-        /// Returns the number of entries read
-        pub fn copy(self: *const Self, cpy: []T) Index {
-            const count = std.math.min(self.len(), cpy.len);
-            var start: Index = self.read;
-
-            for (cpy) |*v, i| {
-                if (i >= count) break;
-
-                v.* = self.buf[self.mask(start)];
-                start += 1;
-            }
-
-            return count;
-        }
-
-        fn len(self: *const Self) Index {
-            return self.write - self.read;
-        }
-
-        fn isFull(self: *const Self) bool {
-            return self.len() == self.buf.len;
-        }
-
-        fn isEmpty(self: *const Self) bool {
-            return self.read == self.write;
-        }
-
-        fn mask(self: *const Self, idx: Index) Index {
-            return idx & (self.buf.len - 1);
-        }
-    };
-}
Author	SHA1	Message	Date
Rekai Musuka	9844d657b0	fix: implement Ace Lightning (2002) obscure behaviour	2023-04-01 01:23:18 -05:00
Rekai Musuka	1d8b21d6b4	fix: reimplement grabbing ROM title if provided via cmd arg	2023-03-27 16:22:07 -05:00
Rekai Musuka	b879c76510	chore: update zgui	2023-03-26 23:23:34 -05:00
Rekai Musuka	0dbba2fb9a	chore: update to 0.11.0-dev.2168+322ace70f	2023-03-26 23:23:34 -05:00
Rekai Musuka	49b0620c48	style(imgui): use orelse instead of if () \|\|	2023-03-17 11:34:38 -05:00
Rekai Musuka	a6a9e3ac72	chore(imgui): change size of histogram	2023-03-17 11:26:14 -05:00
Rekai Musuka	aeefff86f8	chore: update dependencies	2023-03-16 00:27:08 -05:00
Rekai Musuka	91aa98eef7	chore: copy array instead of calling memcpy	2023-03-11 00:30:34 -06:00
Rekai Musuka	f3b6c4f3fe	Merge branch 'ci-suffering'	2023-03-11 00:29:56 -06:00
Rekai Musuka	5aa5ac2a8b	ci: update github actions config	2023-03-11 00:09:14 -06:00
Rekai Nyangadzayi Musuka	b1827ccea0	Merge pull request 'Add a GUI to ZBA' (#7 ) from imgui into main Reviewed-on: #7	2023-03-11 03:18:14 +00:00
Rekai Musuka	2629d15e2f	feat: don't require path to ROM in CLI	2023-03-10 21:16:06 -06:00
Rekai Musuka	c7b62d3202	chore: dynamically update window title on ROM replace	2023-03-10 20:41:49 -06:00
Rekai Musuka	85ec9a84c4	chore: add screenshot to README.md	2023-03-10 19:37:28 -06:00
Rekai Musuka	5adbc354d6	feat: replace Gamepak	2023-03-10 02:50:31 -06:00
Rekai Musuka	f8477714ae	feat: implement resetting	2023-03-10 02:28:03 -06:00
Rekai Musuka	bd872ee1c0	fix: drop select atomics in favour of a thread-safe channel	2023-03-10 02:02:34 -06:00
Rekai Musuka	11eae091db	chore: introduce zba-util In an effort to reuse code between zba and zba-gdbstub, move common util code (like the SPSC Channel I implemented in this commit) in a new lib	2023-03-10 00:05:31 -06:00
Rekai Musuka	72b702cb21	fix: handle null GBA ROM titles when passing to imgui	2023-03-04 18:02:12 -06:00
Rekai Musuka	d985eac0fc	tmp: implement mechanisms for a emu reset fn (currently crashes)	2023-02-23 23:49:56 -06:00
Rekai Musuka	3fff4fd742	chore: move imgui-specific code to its own file	2023-02-23 18:25:05 -06:00
Rekai Musuka	e90d5a17ba	fix: ensure code builds + works the gdbstub branch got merged into main, rebasing on top of main led to a bunch of merge conflicts that had to be resolved. Unfortunately some things got missed, and this commit covers the immediate problems that the rebase caused	2023-02-23 17:27:42 -06:00
Rekai Musuka	54143332ab	chore: update for loop in RingBuffer impl	2023-02-23 17:27:42 -06:00
Rekai Musuka	baa3fb7905	chore: update gui libs to latest zig master	2023-02-23 17:27:42 -06:00
Rekai Musuka	57c7437f77	chore: add gui deps to README.md	2023-02-23 17:27:42 -06:00
Rekai Musuka	eef5a238a0	chore: update nfd-zig respond to build.zig changes in zig master	2023-02-23 17:27:42 -06:00
Rekai Musuka	6048458f9b	feat: implement menu bar + add file picker dep	2023-02-23 17:27:42 -06:00
Rekai Musuka	ff609c85ba	feat: show game title as imgui screen title	2023-02-23 17:27:42 -06:00
Rekai Musuka	3e98f4053a	chore: update zgui	2023-02-23 17:27:42 -06:00
Rekai Musuka	1d601dba39	feat: add scheduler ui	2023-02-23 17:27:42 -06:00
Rekai Musuka	a8fac5f3c6	feat: pause emu when UI reads emu state	2023-02-23 17:27:42 -06:00
Rekai Musuka	ae78588b80	feat: implement ui for register, interrupt	2023-02-23 17:27:42 -06:00
Rekai Musuka	fe6fc0e517	feat: add system information window	2023-02-23 17:27:42 -06:00
Rekai Musuka	3dcc4cb385	fix: update zgui to work with sdl2 vcpkg package	2023-02-23 17:27:42 -06:00
Rekai Musuka	5e94cbfbea	feat: add imgui support using zgui	2023-02-23 17:27:42 -06:00
Rekai Musuka	3b13102abb	ci: ensure that submodules are updated recursively	2023-02-23 17:26:59 -06:00
Rekai Nyangadzayi Musuka	7234ecab37	Merge pull request 'Implement a GDBSTUB Server' (#6 ) from gdbstub into main Reviewed-on: #6	2023-02-23 22:18:26 +00:00
Rekai Musuka	ddf4599162	chore: update dependencies	2023-02-23 02:45:59 -06:00
Rekai Musuka	01f5410180	feat: allow gui and gdbstub to run in parallel	2023-02-23 02:40:24 -06:00
Rekai Musuka	49706842af	fix: run more than just the CPU when stepping via gdb	2023-02-23 02:40:24 -06:00
Rekai Musuka	2798a90d83	chore: update zba-gdbstub to zig master	2023-02-23 02:40:24 -06:00
Rekai Musuka	518b868249	feat: respond to API changes for software bkpts	2023-02-23 02:40:24 -06:00
Rekai Musuka	755115660b	feat: allow gdb writes to certain mem regions	2023-02-23 02:40:24 -06:00
Rekai Musuka	6709f8c551	chore: update gdbstub lib	2023-02-23 02:40:24 -06:00
Rekai Musuka	1f3cdd9513	feat: add gdb support to zba	2023-02-23 02:40:24 -06:00
Rekai Musuka	65af6aa499	feat: add gdbstub library	2023-02-23 02:40:23 -06:00
Rekai Musuka	024151a5c1	chore: update to latest zig master	2023-02-22 14:46:46 -06:00
Rekai Musuka	e380af7056	chore: use a more efficient decimal->bcd algorithm This will not improve perf in any way because this code only gets run one time a second orz	2023-02-21 23:22:42 -06:00
Rekai Musuka	e654abfd1d	ci: don't assume any cpu features	2023-02-18 23:52:51 -06:00
Rekai Musuka	3510a6cff8	chore: drop macOS support CI is currently broken and I don't have the $$$ for macOS	2023-02-18 23:34:59 -06:00
Rekai Musuka	3fb351e762	chore: update SDL.zig	2023-02-17 00:05:42 -06:00
Rekai Musuka	a11b96b84e	chore: update minimum zig version	2023-02-07 17:52:16 -06:00