chore: update for loop in RingBuffer impl

chore: update gui libs to latest zig master
chore: add gui deps to README.md
2023-02-22 16:45:06 -06:00 · 2023-02-22 16:43:08 -06:00 · 2023-02-22 16:43:08 -06:00 · 2023-02-22 16:43:08 -06:00 · 2023-02-22 16:43:08 -06:00 · 2023-02-22 16:43:08 -06:00
36 changed files with 3597 additions and 2935 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
@@ -39,7 +40,7 @@ jobs:
        with:
          submodules: true
      - name: build 
-        run: zig build -Drelease-safe
+        run: zig build -Doptimize=ReleaseSafe -Dcpu=baseline
      - name: upload
        uses: actions/upload-artifact@v3
        with:
--- a/.gitignore
+++ b/.gitignore
@@ -11,4 +11,8 @@
 /lib/SDL2

 # Any Custom Scripts for Debugging purposes
-*.sh
+*.sh
+
+
+# Dear ImGui
+**/imgui.ini
--- a/.gitmodules
+++ b/.gitmodules
@@ -13,3 +13,9 @@
 [submodule "lib/zig-toml"]
 	path = lib/zig-toml
 	url = https://github.com/aeronavery/zig-toml
+[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
--- a/.vscode/extensions.json
+++ b/.vscode/extensions.json
@@ -1,8 +0,0 @@
-{
-    "recommendations": [
-        "augusterame.zls-vscode",
-        "usernamehw.errorlens",
-        "vadimcn.vscode-lldb",
-        "dan-c-underwood.arm"
-    ]
-}
--- a/README.md
+++ b/README.md
@@ -10,10 +10,10 @@ This is a simple (read: incomplete) for-fun long-term project. I hope to get "mo

 ### TODO

- [ ] Affine Sprites
+- [x] Affine Sprites
 - [ ] Windowing (see [this branch](https://git.musuka.dev/paoda/zba/src/branch/window))
 - [ ] Audio Resampler (Having issues with SDL2's)
- [ ] Immediate Mode GUI
+- [x] Immediate Mode GUI (see [this branch](https://git.musuka.dev/paoda/zba/src/branch/imgui))
 - [ ] Refactoring for easy-ish perf boosts

 ## Usage
@@ -77,31 +77,33 @@ arm7wrestler GBA Fixed | [destoer](https://github.com/destoer)

 ## Compiling

-Most recently built on Zig [0.11.0-dev.368+1829b6eab](https://github.com/ziglang/zig/tree/1829b6eab)
+Most recently built on Zig [v0.11.0-dev.1580+a5b34a61a](https://github.com/ziglang/zig/tree/a5b34a61a)

 ### Dependencies

 Dependency | Source
 --- | ---
 SDL.zig | <https://github.com/MasterQ32/SDL.zig>
-zig-clap | <https://github.com/Hejsil/zig-clap>
 known-folders | <https://github.com/ziglibs/known-folders>
-zig-toml | <https://github.com/aeronavery/zig-toml>
+nfd-zig | <https://github.com/fabioarnold/nfd-zig>
+zgui | <https://github.com/michal-z/zig-gamedev/tree/main/libs/zgui>
+zig-clap | <https://github.com/Hejsil/zig-clap>
 zig-datetime | <https://github.com/frmdstryr/zig-datetime>
+zig-toml | <https://github.com/aeronavery/zig-toml>
 `bitfields.zig` | [https://github.com/FlorenceOS/Florence](https://github.com/FlorenceOS/Florence/blob/aaa5a9e568/lib/util/bitfields.zig)
 `gl.zig` | <https://github.com/MasterQ32/zig-opengl>

-Use `git submodule update --init` from the project root to pull the git submodules `SDL.zig`, `zig-clap`, `known-folders`, `zig-toml` and `zig-datetime`
+Use `git submodule update --init` from the project root to pull the git relevant git submodules

 Be sure to provide SDL2 using:

 - Linux: Your distro's package manager
- MacOS: ¯\\\_(ツ)_/¯
+- 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.

-Once you've got all the dependencies, execute `zig build -Drelease-fast`. The executable is located at `zig-out/bin/`.
+Once you've got all the dependencies, execute `zig build -Doptimize=ReleaseSafe`. The executable is located at `zig-out/bin/`.

 ## Controls

--- a/build.zig
+++ b/build.zig
@@ -1,54 +1,62 @@
 const std = @import("std");
 const builtin = @import("builtin");
+
 const Sdk = @import("lib/SDL.zig/Sdk.zig");
+const zgui = @import("lib/zgui/build.zig");
+const nfd = @import("lib/nfd-zig/build.zig");

 pub fn build(b: *std.build.Builder) void {
    // Minimum Zig Version
-    const min_ver = std.SemanticVersion.parse("0.11.0-dev.323+30eb2a175") catch return; // https://github.com/ziglang/zig/commit/30eb2a175
+    const min_ver = std.SemanticVersion.parse("0.11.0-dev.1580+a5b34a61a") catch return; // https://github.com/ziglang/zig/commit/a5b34a61a
    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);
    }

-    // Standard target options allows the person running `zig build` to choose
-    // what target to build for. Here we do not override the defaults, which
-    // means any target is allowed, and the default is native. Other options
-    // for restricting supported target set are available.
    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});

-    // Standard release options allow the person running `zig build` to select
-    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
-    const mode = b.standardReleaseOptions();
+    const exe = b.addExecutable(.{
+        .name = "zba",
+        .root_source_file = .{ .path = "src/main.zig" },
+        .target = target,
+        .optimize = optimize,
+    });

-    const exe = b.addExecutable("zba", "src/main.zig");
    exe.setMainPkgPath("."); // Necessary so that src/main.zig can embed example.toml
-    exe.setTarget(target);

    // Known Folders (%APPDATA%, XDG, etc.)
-    exe.addPackagePath("known_folders", "lib/known-folders/known-folders.zig");
+    exe.addAnonymousModule("known_folders", .{ .source_file = .{ .path = "lib/known-folders/known-folders.zig" } });

    // DateTime Library
-    exe.addPackagePath("datetime", "lib/zig-datetime/src/main.zig");
+    exe.addAnonymousModule("datetime", .{ .source_file = .{ .path = "lib/zig-datetime/src/main.zig" } });

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

    // Argument Parsing Library
-    exe.addPackagePath("clap", "lib/zig-clap/clap.zig");
+    exe.addAnonymousModule("clap", .{ .source_file = .{ .path = "lib/zig-clap/clap.zig" } });

    // TOML Library
-    exe.addPackagePath("toml", "lib/zig-toml/src/toml.zig");
+    exe.addAnonymousModule("toml", .{ .source_file = .{ .path = "lib/zig-toml/src/toml.zig" } });

    // OpenGL 3.3 Bindings
-    exe.addPackagePath("gl", "lib/gl.zig");
+    exe.addAnonymousModule("gl", .{ .source_file = .{ .path = "lib/gl.zig" } });
+
+    // NativeFileDialog(ue) Bindings
+    exe.linkLibrary(nfd.makeLib(b, target, optimize));
+    exe.addModule("nfd", nfd.getModule(b));

    // Zig SDL Bindings: https://github.com/MasterQ32/SDL.zig
-    const sdk = Sdk.init(b);
+    const sdk = Sdk.init(b, null);
    sdk.link(exe, .dynamic);
-    exe.addPackage(sdk.getNativePackage("sdl2"));
+    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);

-    exe.setBuildMode(mode);
    exe.install();

    const run_cmd = exe.run();
@@ -60,9 +68,11 @@ pub fn build(b: *std.build.Builder) void {
    const run_step = b.step("run", "Run the app");
    run_step.dependOn(&run_cmd.step);

-    const exe_tests = b.addTest("src/main.zig");
-    exe_tests.setTarget(target);
-    exe_tests.setBuildMode(mode);
+    const exe_tests = b.addTest(.{
+        .root_source_file = .{ .path = "src/main.zig" },
+        .target = target,
+        .optimize = optimize,
+    });

    const test_step = b.step("test", "Run unit tests");
    test_step.dependOn(&exe_tests.step);
--- a/lib/SDL.zig
+++ b/lib/SDL.zig
--- a/lib/gl.zig
+++ b/lib/gl.zig
--- a/lib/known-folders
+++ b/lib/known-folders
--- a/lib/nfd-zig
+++ b/lib/nfd-zig
--- 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
@@ -60,9 +60,8 @@ allocator: Allocator,
 pub fn init(self: *Self, allocator: Allocator, sched: *Scheduler, cpu: *Arm7tdmi, paths: FilePaths) !void {
    const tables = try allocator.alloc(?*anyopaque, 3 * table_len); // Allocate all tables

-    const read_table: *[table_len]?*const anyopaque = tables[0..table_len];
-    const left_write: *[table_len]?*anyopaque = tables[table_len .. 2 * table_len];
-    const right_write: *[table_len]?*anyopaque = tables[2 * table_len .. 3 * table_len];
+    const read_table = tables[0..table_len];
+    const write_tables = .{ tables[table_len .. 2 * table_len], tables[2 * table_len .. 3 * table_len] };

    self.* = .{
        .pak = try GamePak.init(allocator, cpu, paths.rom, paths.save),
@@ -78,18 +77,15 @@ pub fn init(self: *Self, allocator: Allocator, sched: *Scheduler, cpu: *Arm7tdmi
        .sched = sched,

        .read_table = read_table,
-        .write_tables = .{ left_write, right_write },
+        .write_tables = write_tables,
        .allocator = allocator,
    };

-    // read_table, write_tables, and *Self are not restricted to the lifetime
-    // of this init function so we can initialize our tables here
-    fillReadTable(self, read_table);
+    self.fillReadTable(read_table);

-    // Internal Display Memory behavious unusually on 8-bit reads
-    // so we have two different tables depending on whether there's an 8-bit read or not
-    fillWriteTable(u32, self, left_write);
-    fillWriteTable(u8, self, right_write);
+    // Internal Display Memory behaves differently on 8-bit reads
+    self.fillWriteTable(u32, write_tables[0]);
+    self.fillWriteTable(u8, write_tables[1]);
 }

 pub fn deinit(self: *Self) void {
@@ -106,50 +102,50 @@ pub fn deinit(self: *Self) void {
    self.* = undefined;
 }

-fn fillReadTable(bus: *Self, table: *[table_len]?*const anyopaque) void {
-    const vramMirror = @import("ppu.zig").Vram.mirror;
+fn fillReadTable(self: *Self, table: *[table_len]?*const anyopaque) void {
+    const vramMirror = @import("ppu/Vram.zig").mirror;

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

        ptr.* = switch (addr) {
            // General Internal Memory
            0x0000_0000...0x0000_3FFF => null, // BIOS has it's own checks
-            0x0200_0000...0x02FF_FFFF => &bus.ewram.buf[addr & 0x3FFFF],
-            0x0300_0000...0x03FF_FFFF => &bus.iwram.buf[addr & 0x7FFF],
+            0x0200_0000...0x02FF_FFFF => &self.ewram.buf[addr & 0x3FFFF],
+            0x0300_0000...0x03FF_FFFF => &self.iwram.buf[addr & 0x7FFF],
            0x0400_0000...0x0400_03FF => null, // I/O

            // Internal Display Memory
-            0x0500_0000...0x05FF_FFFF => &bus.ppu.palette.buf[addr & 0x3FF],
-            0x0600_0000...0x06FF_FFFF => &bus.ppu.vram.buf[vramMirror(addr)],
-            0x0700_0000...0x07FF_FFFF => &bus.ppu.oam.buf[addr & 0x3FF],
+            0x0500_0000...0x05FF_FFFF => &self.ppu.palette.buf[addr & 0x3FF],
+            0x0600_0000...0x06FF_FFFF => &self.ppu.vram.buf[vramMirror(addr)],
+            0x0700_0000...0x07FF_FFFF => &self.ppu.oam.buf[addr & 0x3FF],

            // External Memory (Game Pak)
-            0x0800_0000...0x0DFF_FFFF => fillTableExternalMemory(bus, addr),
+            0x0800_0000...0x0DFF_FFFF => self.fillReadTableExternal(addr),
            0x0E00_0000...0x0FFF_FFFF => null, // SRAM
            else => null,
        };
    }
 }

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

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

        ptr.* = switch (addr) {
            // General Internal Memory
            0x0000_0000...0x0000_3FFF => null, // BIOS has it's own checks
-            0x0200_0000...0x02FF_FFFF => &bus.ewram.buf[addr & 0x3FFFF],
-            0x0300_0000...0x03FF_FFFF => &bus.iwram.buf[addr & 0x7FFF],
+            0x0200_0000...0x02FF_FFFF => &self.ewram.buf[addr & 0x3FFFF],
+            0x0300_0000...0x03FF_FFFF => &self.iwram.buf[addr & 0x7FFF],
            0x0400_0000...0x0400_03FF => null, // I/O

            // Internal Display Memory
-            0x0500_0000...0x05FF_FFFF => if (T != u8) &bus.ppu.palette.buf[addr & 0x3FF] else null,
-            0x0600_0000...0x06FF_FFFF => if (T != u8) &bus.ppu.vram.buf[vramMirror(addr)] else null,
-            0x0700_0000...0x07FF_FFFF => if (T != u8) &bus.ppu.oam.buf[addr & 0x3FF] else null,
+            0x0500_0000...0x05FF_FFFF => if (T != u8) &self.ppu.palette.buf[addr & 0x3FF] else null,
+            0x0600_0000...0x06FF_FFFF => if (T != u8) &self.ppu.vram.buf[vramMirror(addr)] else null,
+            0x0700_0000...0x07FF_FFFF => if (T != u8) &self.ppu.oam.buf[addr & 0x3FF] else null,

            // External Memory (Game Pak)
            0x0800_0000...0x0DFF_FFFF => null, // ROM
@@ -159,24 +155,29 @@ fn fillWriteTable(comptime T: type, bus: *Self, table: *[table_len]?*const anyop
    }
 }

-fn fillTableExternalMemory(bus: *Self, addr: usize) ?*anyopaque {
+fn fillReadTableExternal(self: *Self, addr: u32) ?*anyopaque {
    // see `GamePak.zig` for more information about what conditions need to be true
    // so that a simple pointer dereference isn't possible

+    std.debug.assert(addr & @as(u32, page_size - 1) == 0); // addr is guaranteed to be page-aligned
+
    const start_addr = addr;
-    const end_addr = addr + page_size;
+    const end_addr = start_addr + page_size;

-    const gpio_data = start_addr <= 0x0800_00C4 and 0x0800_00C4 < end_addr;
-    const gpio_direction = start_addr <= 0x0800_00C6 and 0x0800_00C6 < end_addr;
-    const gpio_control = start_addr <= 0x0800_00C8 and 0x0800_00C8 < end_addr;
+    {
+        const data = start_addr <= 0x0800_00C4 and 0x0800_00C4 < end_addr; // GPIO Data
+        const direction = start_addr <= 0x0800_00C6 and 0x0800_00C6 < end_addr; // GPIO Direction
+        const control = start_addr <= 0x0800_00C8 and 0x0800_00C8 < end_addr; // GPIO Control

-    if (bus.pak.gpio.device.kind != .None and (gpio_data or gpio_direction or gpio_control)) {
-        // We found a GPIO device, and this page a GPIO register. We want to handle this in slowmem
-        return null;
+        const has_gpio = data or direction or control;
+        const gpio_kind = self.pak.gpio.device.kind;
+
+        // There is a GPIO Device, and the current page contains at least one memory-mapped GPIO register
+        if (gpio_kind != .None and has_gpio) return null;
    }

-    if (bus.pak.backup.kind == .Eeprom) {
-        if (bus.pak.buf.len > 0x100_000) {
+    if (self.pak.backup.kind == .Eeprom) {
+        if (self.pak.buf.len > 0x100_000) {
            // We are using a "large" EEPROM which means that if the below check is true
            // this page has an address that's reserved for the EEPROM and therefore must
            // be handled in slowmem
@@ -192,13 +193,33 @@ fn fillTableExternalMemory(bus: *Self, addr: usize) ?*anyopaque {
    // Finally, the GamePak has some unique behaviour for reads past the end of the ROM,
    // so those will be handled by slowmem as well
    const masked_addr = addr & 0x1FF_FFFF;
-    if (masked_addr >= bus.pak.buf.len) return null;
+    if (masked_addr >= self.pak.buf.len) return null;

-    return &bus.pak.buf[masked_addr];
+    return &self.pak.buf[masked_addr];
 }

-// TODO: Take advantage of fastmem here too?
 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);

@@ -206,33 +227,22 @@ pub fn dbgRead(self: *const Self, comptime T: type, unaligned_address: u32) T {
        // General Internal Memory
        0x00 => blk: {
            if (address < Bios.size)
-                break :blk self.bios.dbgRead(T, self.cpu.r[15], address);
+                break :blk self.bios.dbgRead(T, self.cpu.r[15], unaligned_address);

            break :blk self.openBus(T, address);
        },
-        0x02 => self.ewram.read(T, address),
-        0x03 => self.iwram.read(T, address),
+        0x02 => unreachable, // handled by fastmem
+        0x03 => unreachable, // handled by fastmem
        0x04 => self.readIo(T, address),

        // Internal Display Memory
-        0x05 => self.ppu.palette.read(T, address),
-        0x06 => self.ppu.vram.read(T, address),
-        0x07 => self.ppu.oam.read(T, address),
+        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 => blk: {
-            const value = self.pak.backup.read(unaligned_address);
-
-            const multiplier = switch (T) {
-                u32 => 0x01010101,
-                u16 => 0x0101,
-                u8 => 1,
-                else => @compileError("Backup: Unsupported read width"),
-            };
-
-            break :blk @as(T, value) * multiplier;
-        },
+        0x0E...0x0F => self.readBackup(T, unaligned_address),
        else => self.openBus(T, address),
    };
 }
@@ -316,8 +326,7 @@ pub fn read(self: *Self, comptime T: type, unaligned_address: u32) T {
    if (self.read_table[page]) |some_ptr| {
        // We have a pointer to a page, cast the pointer to it's underlying type
        const Ptr = [*]const T;
-        const alignment = @alignOf(std.meta.Child(Ptr));
-        const ptr = @ptrCast(Ptr, @alignCast(alignment, some_ptr));
+        const ptr = @ptrCast(Ptr, @alignCast(@alignOf(std.meta.Child(Ptr)), some_ptr));

        // Note: We don't check array length, since we force align the
        // lower bits of the address as the GBA would
@@ -337,7 +346,7 @@ fn slowRead(self: *Self, comptime T: type, unaligned_address: u32) T {
        // General Internal Memory
        0x00 => blk: {
            if (address < Bios.size)
-                break :blk self.bios.read(T, self.cpu.r[15], address);
+                break :blk self.bios.read(T, self.cpu.r[15], unaligned_address);

            break :blk self.openBus(T, address);
        },
@@ -352,22 +361,24 @@ fn slowRead(self: *Self, comptime T: type, unaligned_address: u32) T {

        // External Memory (Game Pak)
        0x08...0x0D => self.pak.read(T, address),
-        0x0E...0x0F => blk: {
-            const value = self.pak.backup.read(unaligned_address);
-
-            const multiplier = switch (T) {
-                u32 => 0x01010101,
-                u16 => 0x0101,
-                u8 => 1,
-                else => @compileError("Backup: Unsupported read width"),
-            };
-
-            break :blk @as(T, value) * multiplier;
-        },
+        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);
+
+    const multiplier = switch (T) {
+        u32 => 0x01010101,
+        u16 => 0x0101,
+        u8 => 1,
+        else => @compileError("Backup: Unsupported read width"),
+    };
+
+    return @as(T, value) * multiplier;
+}
+
 pub fn write(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;
@@ -382,8 +393,7 @@ pub fn write(self: *Self, comptime T: type, unaligned_address: u32, value: T) vo
    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 alignment = @alignOf(std.meta.Child(Ptr));
-        const ptr = @ptrCast(Ptr, @alignCast(alignment, some_ptr));
+        const ptr = @ptrCast(Ptr, @alignCast(@alignOf(std.meta.Child(Ptr)), some_ptr));

        // Note: We don't check array length, since we force align the
        // lower bits of the address as the GBA would
@@ -396,8 +406,9 @@ pub fn write(self: *Self, comptime T: type, unaligned_address: u32, value: T) vo
    }
 }

-pub fn slowWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T) void {
-    // @setCold(true);
+fn slowWrite(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);

@@ -425,11 +436,11 @@ inline fn rotateBy(comptime T: type, address: u32) u32 {
        u32 => address & 3,
        u16 => address & 1,
        u8 => 0,
-        else => @compileError("Backup: Unsupported write width"),
+        else => @compileError("Unsupported write width"),
    };
 }

-inline fn forceAlign(comptime T: type, address: u32) u32 {
+pub inline fn forceAlign(comptime T: type, address: u32) u32 {
    return switch (T) {
        u32 => address & ~@as(u32, 3),
        u16 => address & ~@as(u32, 1),
--- a/src/core/apu.zig
+++ b/src/core/apu.zig
@@ -15,10 +15,12 @@ const SoundFifo = std.fifo.LinearFifo(u8, .{ .Static = 0x20 });
 const getHalf = util.getHalf;
 const setHalf = util.setHalf;
 const intToBytes = util.intToBytes;
-const RingBuffer = util.RingBuffer;

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

+pub const host_rate = @import("../platform.zig").sample_rate;
+pub const host_format = @import("../platform.zig").sample_format;
+
 pub fn read(comptime T: type, apu: *const Apu, addr: u32) ?T {
    const byte_addr = @truncate(u8, addr);

@@ -244,20 +246,17 @@ pub const Apu = struct {

    sampling_cycle: u2,

-    sample_queue: RingBuffer(u16),
+    stream: *SDL.SDL_AudioStream,
    sched: *Scheduler,

    fs: FrameSequencer,
    capacitor: f32,

+    is_buffer_full: bool,
+
    pub const Tick = enum { Length, Envelope, Sweep };

    pub fn init(sched: *Scheduler) Self {
-        const NUM_CHANNELS: usize = 2;
-
-        const allocator = std.heap.c_allocator;
-        const sample_buf = allocator.alloc(u16, 0x800 * NUM_CHANNELS) catch @panic("failed to allocate sample buffer");
-
        const apu: Self = .{
            .ch1 = ToneSweep.init(sched),
            .ch2 = Tone.init(sched),
@@ -272,11 +271,12 @@ pub const Apu = struct {
            .bias = .{ .raw = 0x0200 },

            .sampling_cycle = 0b00,
-            .sample_queue = RingBuffer(u16).init(sample_buf),
+            .stream = SDL.SDL_NewAudioStream(SDL.AUDIO_U16, 2, 1 << 15, host_format, 2, host_rate).?,
            .sched = sched,

            .capacitor = 0,
            .fs = FrameSequencer.init(),
+            .is_buffer_full = false,
        };

        sched.push(.SampleAudio, apu.interval());
@@ -370,6 +370,11 @@ pub const Apu = struct {
    pub fn sampleAudio(self: *Self, late: u64) void {
        self.sched.push(.SampleAudio, self.interval() -| late);

+        // Whether the APU is busy or not is determined  by the main loop in emu.zig
+        // This should only ever be true (because this side of the emu is single threaded)
+        // When audio sync is disaabled
+        if (self.is_buffer_full) return;
+
        var left: i16 = 0;
        var right: i16 = 0;

@@ -425,7 +430,23 @@ pub const Apu = struct {
        const ext_left = (clamped_left << 5) | (clamped_left >> 6);
        const ext_right = (clamped_right << 5) | (clamped_right >> 6);

-        self.sample_queue.push(ext_left, ext_right) catch {};
+        if (self.sampling_cycle != self.bias.sampling_cycle.read()) self.replaceSDLResampler();
+
+        _ = SDL.SDL_AudioStreamPut(self.stream, &[2]u16{ ext_left, ext_right }, 2 * @sizeOf(u16));
+    }
+
+    fn replaceSDLResampler(self: *Self) void {
+        @setCold(true);
+        const sample_rate = Self.sampleRate(self.bias.sampling_cycle.read());
+        log.info("Sample Rate changed from {}Hz to {}Hz", .{ Self.sampleRate(self.sampling_cycle), sample_rate });
+
+        // Sampling Cycle (Sample Rate) changed, Craete a new SDL Audio Resampler
+        // FIXME: Replace SDL's Audio Resampler with either a custom or more reliable one
+        const old_stream = self.stream;
+        defer SDL.SDL_FreeAudioStream(old_stream);
+
+        self.sampling_cycle = self.bias.sampling_cycle.read();
+        self.stream = SDL.SDL_NewAudioStream(SDL.AUDIO_U16, 2, @intCast(c_int, sample_rate), host_format, 2, host_rate).?;
    }

    fn interval(self: *const Self) u64 {
--- a/src/core/bus/Bios.zig
+++ b/src/core/bus/Bios.zig
@@ -3,6 +3,9 @@ const std = @import("std");
 const Allocator = std.mem.Allocator;
 const log = std.log.scoped(.Bios);

+const rotr = @import("../../util.zig").rotr;
+const forceAlign = @import("../Bus.zig").forceAlign;
+
 /// Size of the BIOS in bytes
 pub const size = 0x4000;
 const Self = @This();
@@ -10,21 +13,37 @@ const Self = @This();
 buf: ?[]u8,
 allocator: Allocator,

-addr_latch: u32,
+addr_latch: u32 = 0,

-pub fn read(self: *Self, comptime T: type, r15: u32, addr: u32) T {
+// https://github.com/ITotalJustice/notorious_beeg/issues/106
+pub fn read(self: *Self, comptime T: type, r15: u32, address: u32) T {
    if (r15 < Self.size) {
+        const addr = forceAlign(T, address);
+
        self.addr_latch = addr;
        return self._read(T, addr);
    }

-    log.debug("Rejected read since r15=0x{X:0>8}", .{r15});
-    return @truncate(T, self._read(T, self.addr_latch));
+    log.warn("Open Bus! Read from 0x{X:0>8}, but PC was 0x{X:0>8}", .{ address, r15 });
+    const value = self._read(u32, self.addr_latch);
+
+    return @truncate(T, rotr(u32, value, 8 * rotateBy(T, address)));
 }

-pub fn dbgRead(self: *const Self, comptime T: type, r15: u32, addr: u32) T {
-    if (r15 < Self.size) return self._read(T, addr);
-    return @truncate(T, self._read(T, self.addr_latch + 8));
+fn rotateBy(comptime T: type, address: u32) u32 {
+    return switch (T) {
+        u8 => address & 3,
+        u16 => address & 2,
+        u32 => 0,
+        else => @compileError("bios: unsupported read width"),
+    };
+}
+
+pub fn dbgRead(self: *const Self, comptime T: type, r15: u32, address: u32) T {
+    if (r15 < Self.size) return self._read(T, forceAlign(T, address));
+
+    const value = self._read(u32, self.addr_latch);
+    return @truncate(T, rotr(u32, value, 8 * rotateBy(T, address)));
 }

 /// Read without the GBA safety checks
@@ -43,18 +62,19 @@ pub fn write(_: *Self, comptime T: type, addr: u32, value: T) void {
 }

 pub fn init(allocator: Allocator, maybe_path: ?[]const u8) !Self {
-    const buf: ?[]u8 = if (maybe_path) |path| blk: {
-        const file = try std.fs.cwd().openFile(path, .{});
-        defer file.close();
+    if (maybe_path == null) return .{ .buf = null, .allocator = allocator };
+    const path = maybe_path.?;

-        break :blk try file.readToEndAlloc(allocator, try file.getEndPos());
-    } else null;
+    const buf = try allocator.alloc(u8, Self.size);
+    errdefer allocator.free(buf);

-    return Self{
-        .buf = buf,
-        .allocator = allocator,
-        .addr_latch = 0,
-    };
+    const file = try std.fs.cwd().openFile(path, .{});
+    defer file.close();
+
+    const file_len = try file.readAll(buf);
+    if (file_len != Self.size) log.err("Expected BIOS to be {}B, was {}B", .{ Self.size, file_len });
+
+    return Self{ .buf = buf, .allocator = allocator };
 }

 pub fn deinit(self: *Self) void {
--- a/src/core/bus/GamePak.zig
+++ b/src/core/bus/GamePak.zig
@@ -188,7 +188,7 @@ pub fn init(allocator: Allocator, cpu: *Arm7tdmi, rom_path: []const u8, save_pat
    const kind = Backup.guess(file_buf);
    const device = if (config.config().guest.force_rtc) .Rtc else guessDevice(file_buf);

-    logHeader(file_buf, &title);
+    logHeader(file_buf, title);

    return .{
        .buf = file_buf,
@@ -213,25 +213,24 @@ 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;
    }

    // TODO: Detect other GPIO devices
-
    return .None;
 }

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

    log.info("Title: {s}", .{title});
-    if (version != 0) log.info("Version: {}", .{version});
-    log.info("Game Code: {s}", .{code});
-    log.info("Maker Code: {s}", .{maker});
+    if (ver != 0) log.info("Version: {}", .{ver});
+
+    log.info("Game Code: {s}", .{buf[0xAC..0xB0]});
+    log.info("Maker Code: {s}", .{buf[0xB0..0xB2]});
 }

 test "OOB Access" {
--- a/src/core/bus/backup.zig
+++ b/src/core/bus/backup.zig
@@ -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;
--- a/src/core/bus/dma.zig
+++ b/src/core/bus/dma.zig
@@ -338,11 +338,8 @@ fn DmaController(comptime id: u2) type {
    };
 }

-pub fn pollDmaOnBlank(bus: *Bus, comptime kind: DmaKind) void {
-    comptime var i: usize = 0;
-    inline while (i < 4) : (i += 1) {
-        bus.dma[i].poll(kind);
-    }
+pub fn onBlanking(bus: *Bus, comptime kind: DmaKind) void {
+    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
@@ -346,10 +346,10 @@ const InterruptEnable = extern union {
    vblank: Bit(u16, 0),
    hblank: Bit(u16, 1),
    coincidence: Bit(u16, 2),
-    tm0_overflow: Bit(u16, 3),
-    tm1_overflow: Bit(u16, 4),
-    tm2_overflow: Bit(u16, 5),
-    tm3_overflow: Bit(u16, 6),
+    tim0: Bit(u16, 3),
+    tim1: Bit(u16, 4),
+    tim2: Bit(u16, 5),
+    tim3: Bit(u16, 6),
    serial: Bit(u16, 7),
    dma0: Bit(u16, 8),
    dma1: Bit(u16, 9),
@@ -449,6 +449,8 @@ pub const BldY = extern union {
    raw: u16,
 };

+const u8WriteKind = enum { Hi, Lo };
+
 /// Write-only
 pub const WinH = extern union {
    x2: Bitfield(u16, 0, 8),
@@ -458,6 +460,8 @@ pub const WinH = extern union {

 /// Write-only
 pub const WinV = extern union {
+    const Self = @This();
+
    y2: Bitfield(u16, 0, 8),
    y1: Bitfield(u16, 8, 8),
    raw: u16,
@@ -466,20 +470,20 @@ pub const WinV = extern union {
 pub const WinIn = extern union {
    w0_bg: Bitfield(u16, 0, 4),
    w0_obj: Bit(u16, 4),
-    w0_colour: Bit(u16, 5),
+    w0_bld: Bit(u16, 5),
    w1_bg: Bitfield(u16, 8, 4),
    w1_obj: Bit(u16, 12),
-    w1_colour: Bit(u16, 13),
+    w1_bld: Bit(u16, 13),
    raw: u16,
 };

 pub const WinOut = extern union {
    out_bg: Bitfield(u16, 0, 4),
    out_obj: Bit(u16, 4),
-    out_colour: Bit(u16, 5),
+    out_bld: Bit(u16, 5),
    obj_bg: Bitfield(u16, 8, 4),
    obj_obj: Bit(u16, 12),
-    obj_colour: Bit(u16, 13),
+    obj_bld: Bit(u16, 13),
    raw: u16,
 };

--- 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;
+        }
    }
 };

@@ -385,8 +383,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 +401,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 +466,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;
@@ -647,7 +642,7 @@ pub const PSR = extern union {
    }
 };

-const Mode = enum(u5) {
+pub const Mode = enum(u5) {
    User = 0b10000,
    Fiq = 0b10001,
    Irq = 0b10010,
@@ -656,7 +651,7 @@ const Mode = enum(u5) {
    Undefined = 0b11011,
    System = 0b11111,

-    fn toString(self: Mode) []const u8 {
+    pub fn toString(self: Mode) []const u8 {
        return switch (self) {
            .User => "usr",
            .Fiq => "fiq",
--- a/src/core/cpu/arm/data_processing.zig
+++ b/src/core/cpu/arm/data_processing.zig
@@ -24,7 +24,7 @@ pub fn dataProcessing(comptime I: bool, comptime S: bool, comptime kind: u4) Ins
            if (!I and opcode >> 4 & 1 == 1) cpu.r[15] -= 4;

            var result: u32 = undefined;
-            var overflow: bool = undefined;
+            var overflow: u1 = undefined;

            // Perform Data Processing Logic
            switch (kind) {
@@ -62,7 +62,9 @@ pub fn dataProcessing(comptime I: bool, comptime S: bool, comptime kind: u4) Ins
                    if (rd == 0xF)
                        return undefinedTestBehaviour(cpu);

-                    overflow = @addWithOverflow(u32, op1, op2, &result);
+                    const tmp = @addWithOverflow(op1, op2);
+                    result = tmp[0];
+                    overflow = tmp[1];
                },
                0xC => result = op1 | op2, // ORR
                0xD => result = op2, // MOV
@@ -110,7 +112,7 @@ pub fn dataProcessing(comptime I: bool, comptime S: bool, comptime kind: u4) Ins
                    // ADD, ADC Flags
                    cpu.cpsr.n.write(result >> 31 & 1 == 1);
                    cpu.cpsr.z.write(result == 0);
-                    cpu.cpsr.c.write(overflow);
+                    cpu.cpsr.c.write(overflow == 0b1);
                    cpu.cpsr.v.write(((op1 ^ result) & (op2 ^ result)) >> 31 & 1 == 1);
                },
                0x6, 0x7 => if (S and rd != 0xF) {
@@ -141,7 +143,7 @@ pub fn dataProcessing(comptime I: bool, comptime S: bool, comptime kind: u4) Ins
                        cpu.cpsr.v.write(((op1 ^ result) & (~op2 ^ result)) >> 31 & 1 == 1);
                    } else if (kind == 0xB) {
                        // CMN specific
-                        cpu.cpsr.c.write(overflow);
+                        cpu.cpsr.c.write(overflow == 0b1);
                        cpu.cpsr.v.write(((op1 ^ result) & (op2 ^ result)) >> 31 & 1 == 1);
                    } else {
                        // TST, TEQ specific
@@ -162,19 +164,19 @@ pub fn sbc(left: u32, right: u32, old_carry: u1) u32 {
    return ret;
 }

-pub fn add(overflow: *bool, left: u32, right: u32) u32 {
-    var ret: u32 = undefined;
-    overflow.* = @addWithOverflow(u32, left, right, &ret);
-    return ret;
+pub fn add(overflow: *u1, left: u32, right: u32) u32 {
+    const ret = @addWithOverflow(left, right);
+    overflow.* = ret[1];
+
+    return ret[0];
 }

-pub fn adc(overflow: *bool, left: u32, right: u32, old_carry: u1) u32 {
-    var ret: u32 = undefined;
-    const first = @addWithOverflow(u32, left, right, &ret);
-    const second = @addWithOverflow(u32, ret, old_carry, &ret);
+pub fn adc(overflow: *u1, left: u32, right: u32, old_carry: u1) u32 {
+    const tmp = @addWithOverflow(left, right);
+    const ret = @addWithOverflow(tmp[0], old_carry);
+    overflow.* = tmp[1] | ret[1];

-    overflow.* = first or second;
-    return ret;
+    return ret[0];
 }

 fn undefinedTestBehaviour(cpu: *Arm7tdmi) void {
--- a/src/core/cpu/arm/single_data_transfer.zig
+++ b/src/core/cpu/arm/single_data_transfer.zig
@@ -11,9 +11,7 @@ pub fn singleDataTransfer(comptime I: bool, comptime P: bool, comptime U: bool,
            const rn = opcode >> 16 & 0xF;
            const rd = opcode >> 12 & 0xF;

-            // rn is r15 and L is not set, the PC is 12 ahead
-            const base = cpu.r[rn] + if (!L and rn == 0xF) 4 else @as(u32, 0);
-
+            const base = cpu.r[rn];
            const offset = if (I) shifter.immediate(false, cpu, opcode) else opcode & 0xFFF;

            const modified_base = if (U) base +% offset else base -% offset;
--- a/src/core/cpu/thumb/alu.zig
+++ b/src/core/cpu/thumb/alu.zig
@@ -21,7 +21,8 @@ pub fn fmt4(comptime op: u4) InstrFn {
            const op2 = cpu.r[rs];

            var result: u32 = undefined;
-            var overflow: bool = undefined;
+            var overflow: u1 = undefined;
+
            switch (op) {
                0x0 => result = op1 & op2, // AND
                0x1 => result = op1 ^ op2, // EOR
@@ -34,7 +35,12 @@ pub fn fmt4(comptime op: u4) InstrFn {
                0x8 => result = op1 & op2, // TST
                0x9 => result = 0 -% op2, // NEG
                0xA => result = op1 -% op2, // CMP
-                0xB => overflow = @addWithOverflow(u32, op1, op2, &result), // CMN
+                0xB => {
+                    // CMN
+                    const tmp = @addWithOverflow(op1, op2);
+                    result = tmp[0];
+                    overflow = tmp[1];
+                },
                0xC => result = op1 | op2, // ORR
                0xD => result = @truncate(u32, @as(u64, op2) * @as(u64, op1)),
                0xE => result = op1 & ~op2,
@@ -71,7 +77,7 @@ pub fn fmt4(comptime op: u4) InstrFn {
                    // ADC, CMN
                    cpu.cpsr.n.write(result >> 31 & 1 == 1);
                    cpu.cpsr.z.write(result == 0);
-                    cpu.cpsr.c.write(overflow);
+                    cpu.cpsr.c.write(overflow == 0b1);
                    cpu.cpsr.v.write(((op1 ^ result) & (op2 ^ result)) >> 31 & 1 == 1);
                },
                0x6 => {
--- 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/data_processing.zig
+++ b/src/core/cpu/thumb/data_processing.zig
@@ -64,7 +64,7 @@ pub fn fmt5(comptime op: u2, comptime h1: u1, comptime h2: u1) InstrFn {
            const op2 = cpu.r[rs];

            var result: u32 = undefined;
-            var overflow: bool = undefined;
+            var overflow: u1 = undefined;
            switch (op) {
                0b00 => result = add(&overflow, op1, op2), // ADD
                0b01 => result = op1 -% op2, // CMP
@@ -126,13 +126,13 @@ pub fn fmt2(comptime I: bool, is_sub: bool, rn: u3) InstrFn {
                cpu.cpsr.v.write(((op1 ^ result) & (~op2 ^ result)) >> 31 & 1 == 1);
            } else {
                // ADD
-                var overflow: bool = undefined;
+                var overflow: u1 = undefined;
                const result = add(&overflow, op1, op2);
                cpu.r[rd] = result;

                cpu.cpsr.n.write(result >> 31 & 1 == 1);
                cpu.cpsr.z.write(result == 0);
-                cpu.cpsr.c.write(overflow);
+                cpu.cpsr.c.write(overflow == 0b1);
                cpu.cpsr.v.write(((op1 ^ result) & (op2 ^ result)) >> 31 & 1 == 1);
            }
        }
@@ -145,7 +145,7 @@ pub fn fmt3(comptime op: u2, comptime rd: u3) InstrFn {
            const op1 = cpu.r[rd];
            const op2: u32 = opcode & 0xFF; // Offset

-            var overflow: bool = undefined;
+            var overflow: u1 = undefined;
            const result: u32 = switch (op) {
                0b00 => op2, // MOV
                0b01 => op1 -% op2, // CMP
@@ -169,7 +169,7 @@ pub fn fmt3(comptime op: u2, comptime rd: u3) InstrFn {
                },
                0b10 => {
                    // ADD
-                    cpu.cpsr.c.write(overflow);
+                    cpu.cpsr.c.write(overflow == 0b1);
                    cpu.cpsr.v.write(((op1 ^ result) & (op2 ^ result)) >> 31 & 1 == 1);
                },
            }
--- a/src/core/emu.zig
+++ b/src/core/emu.zig
@@ -4,8 +4,7 @@ const config = @import("../config.zig");

 const Scheduler = @import("scheduler.zig").Scheduler;
 const Arm7tdmi = @import("cpu.zig").Arm7tdmi;
-const FpsTracker = @import("../util.zig").FpsTracker;
-const RingBuffer = @import("../util.zig").RingBuffer;
+const Tracker = @import("../util.zig").FpsTracker;

 const Timer = std.time.Timer;
 const Atomic = std.atomic.Atomic;
@@ -36,18 +35,18 @@ const RunKind = enum {
    LimitedFPS,
 };

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

-fn inner(comptime kind: RunKind, audio_sync: bool, quit: *Atomic(bool), scheduler: *Scheduler, cpu: *Arm7tdmi, tracker: ?*FpsTracker) void {
+fn inner(comptime kind: RunKind, audio_sync: bool, quit: *Atomic(bool), pause: *Atomic(bool), cpu: *Arm7tdmi, scheduler: *Scheduler, tracker: ?*Tracker) void {
    if (kind == .UnlimitedFPS or kind == .LimitedFPS) {
        std.debug.assert(tracker != null);
        log.info("FPS tracking enabled", .{});
@@ -58,8 +57,10 @@ fn inner(comptime kind: RunKind, audio_sync: bool, quit: *Atomic(bool), schedule
            log.info("Emulation w/out video sync", .{});

            while (!quit.load(.Monotonic)) {
+                if (pause.load(.Monotonic)) continue;
+
                runFrame(scheduler, cpu);
-                audioSync(audio_sync, &cpu.bus.apu.sample_queue);
+                audioSync(audio_sync, cpu.bus.apu.stream, &cpu.bus.apu.is_buffer_full);

                if (kind == .UnlimitedFPS) tracker.?.tick();
            }
@@ -70,6 +71,8 @@ fn inner(comptime kind: RunKind, audio_sync: bool, quit: *Atomic(bool), schedule
            var wake_time: u64 = frame_period;

            while (!quit.load(.Monotonic)) {
+                if (pause.load(.Monotonic)) continue;
+
                runFrame(scheduler, cpu);
                const new_wake_time = videoSync(&timer, wake_time);

@@ -78,7 +81,7 @@ fn inner(comptime kind: RunKind, audio_sync: bool, quit: *Atomic(bool), schedule
                // the amount of time needed for audio to catch up rather than
                // our expected wake-up time

-                audioSync(audio_sync, &cpu.bus.apu.sample_queue);
+                audioSync(audio_sync, cpu.bus.apu.stream, &cpu.bus.apu.is_buffer_full);
                if (!audio_sync) spinLoop(&timer, wake_time);
                wake_time = new_wake_time;

@@ -95,7 +98,7 @@ pub fn runFrame(sched: *Scheduler, cpu: *Arm7tdmi) void {
        if (!cpu.stepDmaTransfer()) {
            if (cpu.isHalted()) {
                // Fast-forward to next Event
-                sched.tick = sched.queue.peek().?.tick;
+                sched.tick = sched.nextTimestamp();
            } else {
                cpu.step();
            }
@@ -105,13 +108,22 @@ pub fn runFrame(sched: *Scheduler, cpu: *Arm7tdmi) void {
    }
 }

-fn audioSync(audio_sync: bool, sample_queue: *RingBuffer(u16)) void {
+fn audioSync(audio_sync: bool, stream: *SDL.SDL_AudioStream, is_buffer_full: *bool) void {
    comptime std.debug.assert(@import("../platform.zig").sample_format == SDL.AUDIO_U16);
-    // const sample_size = 2 * @sizeOf(u16);
-    // const max_buf_size: c_int = 0x400;
+    const sample_size = 2 * @sizeOf(u16);
+    const max_buf_size: c_int = 0x400;

-    _ = audio_sync;
-    _ = sample_queue;
+    // Determine whether the APU is busy right at this moment
+    var still_full: bool = SDL.SDL_AudioStreamAvailable(stream) > sample_size * if (is_buffer_full.*) max_buf_size >> 1 else max_buf_size;
+    defer is_buffer_full.* = still_full; // Update APU Busy status right before exiting scope
+
+    // If Busy is false, there's no need to sync here
+    if (!still_full) return;
+
+    while (true) {
+        still_full = SDL.SDL_AudioStreamAvailable(stream) > sample_size * max_buf_size >> 1;
+        if (!audio_sync or !still_full) break;
+    }
 }

 fn videoSync(timer: *Timer, wake_time: u64) u64 {
@@ -138,9 +150,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
--- a/src/core/ppu.zig
+++ b/src/core/ppu.zig
--- a/src/core/ppu/Oam.zig
+++ b/src/core/ppu/Oam.zig
@@ -0,0 +1,40 @@
+const std = @import("std");
+
+const Allocator = std.mem.Allocator;
+
+const buf_len = 0x400;
+const Self = @This();
+
+buf: []u8,
+allocator: Allocator,
+
+pub fn read(self: *const Self, comptime T: type, address: usize) T {
+    const addr = address & 0x3FF;
+
+    return switch (T) {
+        u32, u16, u8 => std.mem.readIntSliceLittle(T, self.buf[addr..][0..@sizeOf(T)]),
+        else => @compileError("OAM: Unsupported read width"),
+    };
+}
+
+pub fn write(self: *Self, comptime T: type, address: usize, value: T) void {
+    const addr = address & 0x3FF;
+
+    switch (T) {
+        u32, u16 => std.mem.writeIntSliceLittle(T, self.buf[addr..][0..@sizeOf(T)], value),
+        u8 => return, // 8-bit writes are explicitly ignored
+        else => @compileError("OAM: Unsupported write width"),
+    }
+}
+
+pub fn init(allocator: Allocator) !Self {
+    const buf = try allocator.alloc(u8, buf_len);
+    std.mem.set(u8, buf, 0);
+
+    return Self{ .buf = buf, .allocator = allocator };
+}
+
+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
@@ -0,0 +1,47 @@
+const std = @import("std");
+
+const Allocator = std.mem.Allocator;
+
+const buf_len = 0x400;
+const Self = @This();
+
+buf: []u8,
+allocator: Allocator,
+
+pub fn read(self: *const Self, comptime T: type, address: usize) T {
+    const addr = address & 0x3FF;
+
+    return switch (T) {
+        u32, u16, u8 => std.mem.readIntSliceLittle(T, self.buf[addr..][0..@sizeOf(T)]),
+        else => @compileError("PALRAM: Unsupported read width"),
+    };
+}
+
+pub fn write(self: *Self, comptime T: type, address: usize, value: T) void {
+    const addr = address & 0x3FF;
+
+    switch (T) {
+        u32, u16 => std.mem.writeIntSliceLittle(T, self.buf[addr..][0..@sizeOf(T)], value),
+        u8 => {
+            const align_addr = addr & ~@as(u32, 1); // Aligned to Halfword boundary
+            std.mem.writeIntSliceLittle(u16, self.buf[align_addr..][0..@sizeOf(u16)], @as(u16, value) * 0x101);
+        },
+        else => @compileError("PALRAM: Unsupported write width"),
+    }
+}
+
+pub fn init(allocator: Allocator) !Self {
+    const buf = try allocator.alloc(u8, buf_len);
+    std.mem.set(u8, buf, 0);
+
+    return Self{ .buf = buf, .allocator = allocator };
+}
+
+pub fn deinit(self: *Self) void {
+    self.allocator.free(self.buf);
+    self.* = undefined;
+}
+
+pub inline fn backdrop(self: *const Self) u16 {
+    return std.mem.readIntNative(u16, self.buf[0..2]);
+}
--- a/src/core/ppu/Vram.zig
+++ b/src/core/ppu/Vram.zig
@@ -0,0 +1,60 @@
+const std = @import("std");
+const io = @import("../bus/io.zig");
+
+const Allocator = std.mem.Allocator;
+
+const buf_len = 0x18000;
+const Self = @This();
+
+buf: []u8,
+allocator: Allocator,
+
+pub fn read(self: *const Self, comptime T: type, address: usize) T {
+    const addr = Self.mirror(address);
+
+    return switch (T) {
+        u32, u16, u8 => std.mem.readIntSliceLittle(T, self.buf[addr..][0..@sizeOf(T)]),
+        else => @compileError("VRAM: Unsupported read width"),
+    };
+}
+
+pub fn write(self: *Self, comptime T: type, dispcnt: io.DisplayControl, address: usize, value: T) void {
+    const mode: u3 = dispcnt.bg_mode.read();
+    const idx = Self.mirror(address);
+
+    switch (T) {
+        u32, u16 => std.mem.writeIntSliceLittle(T, self.buf[idx..][0..@sizeOf(T)], value),
+        u8 => {
+            // Ignore write if it falls within the boundaries of OBJ VRAM
+            switch (mode) {
+                0, 1, 2 => if (0x0001_0000 <= idx) return,
+                else => if (0x0001_4000 <= idx) return,
+            }
+
+            const align_idx = idx & ~@as(u32, 1); // Aligned to a halfword boundary
+            std.mem.writeIntSliceLittle(u16, self.buf[align_idx..][0..@sizeOf(u16)], @as(u16, value) * 0x101);
+        },
+        else => @compileError("VRAM: Unsupported write width"),
+    }
+}
+
+pub fn init(allocator: Allocator) !Self {
+    const buf = try allocator.alloc(u8, buf_len);
+    std.mem.set(u8, buf, 0);
+
+    return Self{ .buf = buf, .allocator = allocator };
+}
+
+pub fn deinit(self: *Self) void {
+    self.allocator.free(self.buf);
+    self.* = undefined;
+}
+
+pub fn mirror(address: usize) usize {
+    // Mirrored in steps of 128K (64K + 32K + 32K) (abcc)
+    const addr = address & 0x1FFFF;
+
+    // If the address is within 96K we don't do anything,
+    // otherwise we want to mirror the last 32K (addresses between 64K and 96K)
+    return if (addr < buf_len) addr else 0x10000 + (addr & 0x7FFF);
+}
--- a/src/core/scheduler.zig
+++ b/src/core/scheduler.zig
@@ -31,61 +31,55 @@ pub const Scheduler = struct {
    }

    pub fn handleEvent(self: *Self, cpu: *Arm7tdmi) void {
-        if (self.queue.removeOrNull()) |event| {
-            const late = self.tick - event.tick;
+        const event = self.queue.remove();
+        const late = self.tick - event.tick;

-            switch (event.kind) {
-                .HeatDeath => {
-                    log.err("u64 overflow. This *actually* should never happen.", .{});
-                    unreachable;
-                },
-                .Draw => {
-                    // The end of a VDraw
-                    cpu.bus.ppu.drawScanline();
-                    cpu.bus.ppu.onHdrawEnd(cpu, late);
-                },
-                .TimerOverflow => |id| {
-                    switch (id) {
-                        inline 0...3 => |idx| cpu.bus.tim[idx].onTimerExpire(cpu, late),
-                    }
-                },
-                .ApuChannel => |id| {
-                    switch (id) {
-                        0 => cpu.bus.apu.ch1.onToneSweepEvent(late),
-                        1 => cpu.bus.apu.ch2.onToneEvent(late),
-                        2 => cpu.bus.apu.ch3.onWaveEvent(late),
-                        3 => cpu.bus.apu.ch4.onNoiseEvent(late),
-                    }
-                },
-                .RealTimeClock => {
-                    const device = &cpu.bus.pak.gpio.device;
-                    if (device.kind != .Rtc or device.ptr == null) return;
+        switch (event.kind) {
+            .HeatDeath => {
+                log.err("u64 overflow. This *actually* should never happen.", .{});
+                unreachable;
+            },
+            .Draw => {
+                // The end of a VDraw
+                cpu.bus.ppu.drawScanline();
+                cpu.bus.ppu.onHdrawEnd(cpu, late);
+            },
+            .TimerOverflow => |id| {
+                switch (id) {
+                    inline 0...3 => |idx| cpu.bus.tim[idx].onTimerExpire(cpu, late),
+                }
+            },
+            .ApuChannel => |id| {
+                switch (id) {
+                    0 => cpu.bus.apu.ch1.onToneSweepEvent(late),
+                    1 => cpu.bus.apu.ch2.onToneEvent(late),
+                    2 => cpu.bus.apu.ch3.onWaveEvent(late),
+                    3 => cpu.bus.apu.ch4.onNoiseEvent(late),
+                }
+            },
+            .RealTimeClock => {
+                const device = &cpu.bus.pak.gpio.device;
+                if (device.kind != .Rtc or device.ptr == null) return;

-                    const clock = @ptrCast(*Clock, @alignCast(@alignOf(*Clock), device.ptr.?));
-                    clock.onClockUpdate(late);
-                },
-                .FrameSequencer => cpu.bus.apu.onSequencerTick(late),
-                .SampleAudio => cpu.bus.apu.sampleAudio(late),
-                .HBlank => cpu.bus.ppu.onHblankEnd(cpu, late), // The end of a HBlank
-                .VBlank => cpu.bus.ppu.onHdrawEnd(cpu, late), // The end of a VBlank
-            }
+                const clock = @ptrCast(*Clock, @alignCast(@alignOf(*Clock), device.ptr.?));
+                clock.onClockUpdate(late);
+            },
+            .FrameSequencer => cpu.bus.apu.onSequencerTick(late),
+            .SampleAudio => cpu.bus.apu.sampleAudio(late),
+            .HBlank => cpu.bus.ppu.onHblankEnd(cpu, late), // The end of a HBlank
+            .VBlank => cpu.bus.ppu.onHdrawEnd(cpu, late), // The end of a VBlank
        }
    }

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

-                // This invalidates the iterator
+                // invalidates the slice we're iterating over
                _ = self.queue.removeIndex(i);

-                // Since removing something from the PQ invalidates the iterator,
-                // this implementation can safely only remove the first instance of
-                // a Scheduled Event. Exit Early
+                log.debug("Removed {?}@{}", .{ event.kind, event.tick });
                break;
            }
        }
--- a/src/main.zig
+++ b/src/main.zig
@@ -13,8 +13,6 @@ const FilePaths = @import("util.zig").FilePaths;

 const Allocator = std.mem.Allocator;
 const log = std.log.scoped(.Cli);
-const width = @import("core/ppu.zig").width;
-const height = @import("core/ppu.zig").height;
 pub const log_level = if (builtin.mode != .Debug) .info else std.log.default_level;

 // CLI Arguments + Help Text
@@ -87,13 +85,14 @@ pub fn main() void {
        cpu.fastBoot();
    }

-    var gui = Gui.init(&bus.pak.title, &bus.apu, width, height) catch |e| exitln("failed to init gui: {}", .{e});
+    // 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});
    defer gui.deinit();

    gui.run(&cpu, &scheduler) catch |e| exitln("failed to run gui thread: {}", .{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});

--- a/src/platform.zig
+++ b/src/platform.zig
@@ -1,6 +1,9 @@
 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");

@@ -8,20 +11,43 @@ 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 gba_width = @import("core/ppu.zig").width;
 const gba_height = @import("core/ppu.zig").height;

-pub const sample_rate = 1 << 16;
+const GLuint = gl.GLuint;
+const GLsizei = gl.GLsizei;
+const SDL_GLContext = *anyopaque;
+const Allocator = std.mem.Allocator;
+
+const width = 1280;
+const height = 720;
+
+pub const sample_rate = 1 << 15;
 pub const sample_format = SDL.AUDIO_U16;

 const default_title = "ZBA";

 pub const Gui = struct {
    const Self = @This();
-    const SDL_GLContext = *anyopaque; // SDL.SDL_GLContext is a ?*anyopaque
    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
@@ -39,47 +65,91 @@ pub const Gui = struct {

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

+    state: State,
+
+    allocator: Allocator,
    program_id: gl.GLuint,

-    pub fn init(title: *const [12]u8, apu: *Apu, width: i32, height: i32) !Self {
+    pub fn init(allocator: Allocator, title: [12]u8, apu: *Apu) !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 win_scale = @intCast(c_int, config.config().host.win_scale);
-
        const window = SDL.SDL_CreateWindow(
            default_title,
            SDL.SDL_WINDOWPOS_CENTERED,
            SDL.SDL_WINDOWPOS_CENTERED,
-            @as(c_int, width * win_scale),
-            @as(c_int, height * win_scale),
+            width,
+            height,
            SDL.SDL_WINDOW_OPENGL | SDL.SDL_WINDOW_SHOWN,
        ) orelse panic();

        const ctx = SDL.SDL_GL_CreateContext(window) orelse panic();
        if (SDL.SDL_GL_MakeCurrent(window, ctx) < 0) panic();

-        try gl.load(ctx, Self.glGetProcAddress);
+        gl.load(ctx, Self.glGetProcAddress) catch {};
        if (SDL.SDL_GL_SetSwapInterval(@boolToInt(config.config().host.vsync)) < 0) panic();

-        const program_id = try compileShaders();
+        zgui.init(allocator);
+        zgui.plot.init();
+        zgui.backend.init(window, ctx, "#version 330 core");
+
+        // zgui.io.setIniFilename(null);

        return Self{
            .window = window,
-            .title = std.mem.sliceTo(title, 0),
+            .title = try allocator.dupeZ(u8, &title),
            .ctx = ctx,
-            .program_id = program_id,
+            .program_id = try compileShaders(),
            .audio = Audio.init(apu),
+
+            .allocator = allocator,
+            .state = try State.init(allocator),
        };
    }

-    fn compileShaders() !gl.GLuint {
-        // TODO: Panic on Shader Compiler Failure + Error Message
+    pub fn deinit(self: *Self) void {
+        self.audio.deinit();
+        self.state.deinit(self.allocator);
+
+        zgui.backend.deinit();
+        zgui.plot.deinit();
+        zgui.deinit();
+
+        gl.deleteProgram(self.program_id);
+        SDL.SDL_GL_DeleteContext(self.ctx);
+        SDL.SDL_DestroyWindow(self.window);
+        SDL.SDL_Quit();
+
+        self.allocator.free(self.title);
+        self.* = undefined;
+    }
+
+    fn drawGbaTexture(self: *const Self, obj_ids: struct { GLuint, GLuint, GLuint }, tex_id: GLuint, buf: []const u8) void {
+        gl.bindTexture(gl.TEXTURE_2D, tex_id);
+        defer gl.bindTexture(gl.TEXTURE_2D, 0);
+
+        gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, gba_width, gba_height, gl.RGBA, gl.UNSIGNED_INT_8_8_8_8, buf.ptr);
+
+        // Bind VAO, EBO. VBO not bound
+        gl.bindVertexArray(obj_ids[0]); // VAO
+        defer gl.bindVertexArray(0);
+
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, obj_ids[2]); // EBO
+        defer gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, 0);
+
+        // Use compiled frag + vertex shader
+        gl.useProgram(self.program_id);
+        defer gl.useProgram(0);
+
+        gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, null);
+    }
+
+    fn compileShaders() !GLuint {
        const vert_shader = @embedFile("shader/pixelbuf.vert");
        const frag_shader = @embedFile("shader/pixelbuf.frag");

@@ -108,20 +178,25 @@ pub const Gui = struct {
    }

    // Returns the VAO ID since it's used in run()
-    fn generateBuffers() struct { c_uint, c_uint, c_uint } {
-        var vao_id: c_uint = undefined;
-        var vbo_id: c_uint = undefined;
-        var ebo_id: c_uint = undefined;
+    fn genBufferObjects() struct { GLuint, GLuint, GLuint } {
+        var vao_id: GLuint = undefined;
+        var vbo_id: GLuint = undefined;
+        var ebo_id: GLuint = undefined;
+
        gl.genVertexArrays(1, &vao_id);
        gl.genBuffers(1, &vbo_id);
        gl.genBuffers(1, &ebo_id);

        gl.bindVertexArray(vao_id);
+        defer gl.bindVertexArray(0);

        gl.bindBuffer(gl.ARRAY_BUFFER, vbo_id);
-        gl.bufferData(gl.ARRAY_BUFFER, @sizeOf(@TypeOf(vertices)), &vertices, gl.STATIC_DRAW);
+        defer gl.bindBuffer(gl.ARRAY_BUFFER, 0);

        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ebo_id);
+        defer gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, 0);
+
+        gl.bufferData(gl.ARRAY_BUFFER, @sizeOf(@TypeOf(vertices)), &vertices, gl.STATIC_DRAW);
        gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, @sizeOf(@TypeOf(indices)), &indices, gl.STATIC_DRAW);

        // Position
@@ -137,46 +212,242 @@ pub const Gui = struct {
        return .{ vao_id, vbo_id, ebo_id };
    }

-    fn generateTexture(buf: []const u8) c_uint {
-        var tex_id: c_uint = undefined;
+    fn genGbaTexture(buf: []const u8) GLuint {
+        var tex_id: GLuint = undefined;
        gl.genTextures(1, &tex_id);
-        gl.bindTexture(gl.TEXTURE_2D, tex_id);

-        // gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-        // gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        gl.bindTexture(gl.TEXTURE_2D, tex_id);
+        defer gl.bindTexture(gl.TEXTURE_2D, 0);

        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);

        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gba_width, gba_height, 0, gl.RGBA, gl.UNSIGNED_INT_8_8_8_8, buf.ptr);
-        // gl.generateMipmap(gl.TEXTURE_2D); // TODO: Remove?

        return tex_id;
    }

-    pub fn run(self: *Self, cpu: *Arm7tdmi, scheduler: *Scheduler) !void {
-        var quit = std.atomic.Atomic(bool).init(false);
-        var tracker = FpsTracker.init();
+    fn genOutTexture() GLuint {
+        var tex_id: GLuint = undefined;
+        gl.genTextures(1, &tex_id);

-        var buffer_ids = Self.generateBuffers();
-        defer {
-            gl.deleteBuffers(1, &buffer_ids[2]); // EBO
-            gl.deleteBuffers(1, &buffer_ids[1]); // VBO
-            gl.deleteVertexArrays(1, &buffer_ids[0]); // VAO
+        gl.bindTexture(gl.TEXTURE_2D, tex_id);
+        defer gl.bindTexture(gl.TEXTURE_2D, 0);
+
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gba_width, gba_height, 0, gl.RGBA, gl.UNSIGNED_INT_8_8_8_8, null);
+
+        return tex_id;
+    }
+
+    fn genFrameBufObject(tex_id: c_uint) !GLuint {
+        var fbo_id: GLuint = undefined;
+        gl.genFramebuffers(1, &fbo_id);
+
+        gl.bindFramebuffer(gl.FRAMEBUFFER, fbo_id);
+        defer gl.bindFramebuffer(gl.FRAMEBUFFER, 0);
+
+        gl.framebufferTexture(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, tex_id, 0);
+
+        const draw_buffers: [1]GLuint = .{gl.COLOR_ATTACHMENT0};
+        gl.drawBuffers(1, &draw_buffers);
+
+        if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) != gl.FRAMEBUFFER_COMPLETE)
+            return error.FrameBufferObejctInitFailed;
+
+        return fbo_id;
+    }
+
+    fn draw(self: *Self, tex_id: GLuint, cpu: *const 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", .{})) 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 vao_id = buffer_ids[0];

-        const tex_id = Self.generateTexture(cpu.bus.ppu.framebuf.get(.Renderer));
-        defer gl.deleteTextures(1, &tex_id);
+        {
+            const w = @intToFloat(f32, gba_width * win_scale);
+            const h = @intToFloat(f32, gba_height * win_scale);

-        const thread = try std.Thread.spawn(.{}, emu.run, .{ &quit, scheduler, cpu, &tracker });
+            _ = 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));
+
+        const emu_tex = Self.genGbaTexture(cpu.bus.ppu.framebuf.get(.Renderer));
+        const out_tex = Self.genOutTexture();
+        defer gl.deleteTextures(2, &[_]c_uint{ emu_tex, out_tex });
+
+        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();
-
-        var title_buf: [0x100]u8 = undefined;
+        defer quit.store(true, .Monotonic); // Terminate Emulator Thread

        emu_loop: while (true) {
            var event: SDL.SDL_Event = undefined;
+
+            // Quit Signal from Dear Imgui
+            if (self.state.should_quit) break :emu_loop;
+
            while (SDL.SDL_PollEvent(&event) != 0) {
+                _ = zgui.backend.processEvent(&event);
+
                switch (event.type) {
                    SDL.SDL_QUIT => break :emu_loop,
                    SDL.SDL_KEYDOWN => {
@@ -214,12 +485,6 @@ pub const Gui = struct {
                            SDL.SDLK_s => keyinput.shoulder_r.set(),
                            SDL.SDLK_RETURN => keyinput.start.set(),
                            SDL.SDLK_RSHIFT => keyinput.select.set(),
-                            SDL.SDLK_i => {
-                                comptime std.debug.assert(sample_format == SDL.AUDIO_U16);
-                                log.err("Sample Count: {}", .{cpu.bus.apu.sample_queue.len() / 2});
-                            },
-                            // SDL.SDLK_j => log.err("Scheduler Capacity: {} | Scheduler Event Count: {}", .{ scheduler.queue.capacity(), scheduler.queue.count() }),
-                            SDL.SDLK_k => {},
                            else => {},
                        }

@@ -229,29 +494,36 @@ pub const Gui = struct {
                }
            }

-            // Emulator has an internal Double Buffer
-            const framebuf = cpu.bus.ppu.framebuf.get(.Renderer);
-            gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, gba_width, gba_height, gl.RGBA, gl.UNSIGNED_INT_8_8_8_8, framebuf.ptr);
+            // We Access non-atomic parts of the Emulator here
+            {
+                pause.store(true, .Monotonic);
+                defer pause.store(false, .Monotonic);
+
+                self.state.fps_hist.push(tracker.value()) catch {};
+
+                // Draw GBA Screen to Texture
+                {
+                    gl.bindFramebuffer(gl.FRAMEBUFFER, fbo_id);
+                    defer gl.bindFramebuffer(gl.FRAMEBUFFER, 0);
+
+                    const buf = cpu.bus.ppu.framebuf.get(.Renderer);
+                    gl.viewport(0, 0, gba_width, gba_height);
+                    self.drawGbaTexture(obj_ids, emu_tex, buf);
+                }
+
+                // Background Colour
+                const size = zgui.io.getDisplaySize();
+                gl.viewport(0, 0, @floatToInt(c_int, size[0]), @floatToInt(c_int, size[1]));
+                gl.clearColor(0, 0, 0, 1.0);
+                gl.clear(gl.COLOR_BUFFER_BIT);
+
+                zgui.backend.newFrame(width, height);
+                self.draw(out_tex, cpu);
+                zgui.backend.draw();
+            }

-            gl.useProgram(self.program_id);
-            gl.bindVertexArray(vao_id);
-            gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, null);
            SDL.SDL_GL_SwapWindow(self.window);
-
-            const dyn_title = std.fmt.bufPrintZ(&title_buf, "ZBA | {s} [Emu: {}fps] ", .{ self.title, tracker.value() }) catch unreachable;
-            SDL.SDL_SetWindowTitle(self.window, dyn_title.ptr);
        }
-
-        quit.store(true, .Monotonic); // Terminate Emulator Thread
-    }
-
-    pub fn deinit(self: *Self) void {
-        self.audio.deinit();
-        gl.deleteProgram(self.program_id);
-        SDL.SDL_GL_DeleteContext(self.ctx);
-        SDL.SDL_DestroyWindow(self.window);
-        SDL.SDL_Quit();
-        self.* = undefined;
    }

    fn glGetProcAddress(ctx: SDL.SDL_GLContext, proc: [:0]const u8) ?*anyopaque {
@@ -299,15 +571,7 @@ const Audio = struct {
        const T = *Apu;
        const apu = @ptrCast(T, @alignCast(@alignOf(T), userdata));

-        comptime std.debug.assert(sample_format == SDL.AUDIO_U16);
-        const sample_buf = @ptrCast([*]u16, @alignCast(@alignOf(u16), stream))[0 .. @intCast(u32, len) / @sizeOf(u16)];
-
-        var previous: u16 = 0x8000;
-        for (sample_buf) |*sample| {
-            if (apu.sample_queue.pop()) |value| previous = value;
-
-            sample.* = previous;
-        }
+        _ = SDL.SDL_AudioStreamGet(apu.stream, stream, len);
    }
 };

@@ -337,3 +601,95 @@ 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
@@ -5,6 +5,8 @@ const config = @import("config.zig");
 const Log2Int = std.math.Log2Int;
 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
@@ -123,6 +125,7 @@ pub const io = struct {

 pub const Logger = struct {
    const Self = @This();
+    const FmtArgTuple = std.meta.Tuple(&.{ u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32 });

    buf: std.io.BufferedWriter(4096 << 2, std.fs.File.Writer),

@@ -181,8 +184,6 @@ pub const Logger = struct {
    }
 };

-const FmtArgTuple = struct { u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32 };
-
 pub const audio = struct {
    const _io = @import("core/bus/io.zig");

@@ -276,7 +277,46 @@ fn HalfInt(comptime T: type) type {
    return std.meta.Int(type_info.Int.signedness, type_info.Int.bits >> 1);
 }

-const Mutex = std.Thread.Mutex;
+/// Double Buffering Implementation
+pub const FrameBuffer = struct {
+    const Self = @This();
+
+    layers: [2][]u8,
+    buf: []u8,
+    current: u1,
+
+    allocator: Allocator,
+
+    // TODO: Rename
+    const Device = enum { Emulator, Renderer };
+
+    pub fn init(allocator: Allocator, comptime len: comptime_int) !Self {
+        const buf = try allocator.alloc(u8, len * 2);
+        std.mem.set(u8, buf, 0);
+
+        return .{
+            // Front and Back Framebuffers
+            .layers = [_][]u8{ buf[0..][0..len], buf[len..][0..len] },
+            .buf = buf,
+            .current = 0,
+
+            .allocator = allocator,
+        };
+    }
+
+    pub fn deinit(self: *Self) void {
+        self.allocator.free(self.buf);
+        self.* = undefined;
+    }
+
+    pub fn swap(self: *Self) void {
+        self.current = ~self.current;
+    }
+
+    pub fn get(self: *Self, comptime dev: Device) []u8 {
+        return self.layers[if (dev == .Emulator) self.current else ~self.current];
+    }
+};

 pub fn RingBuffer(comptime T: type) type {
    return struct {
@@ -288,67 +328,59 @@ pub fn RingBuffer(comptime T: type) type {

        read: Index,
        write: Index,
-
        buf: []T,

-        mutex: Mutex,
-
        const Error = error{buffer_full};

        pub fn init(buf: []T) Self {
-            std.mem.set(T, buf, 0);
-
            std.debug.assert(std.math.isPowerOfTwo(buf.len)); // capacity must be a power of two
            std.debug.assert(buf.len <= max_capacity);

-            return .{ .read = 0, .write = 0, .buf = buf, .mutex = .{} };
+            std.mem.set(T, buf, 0);
+
+            return .{ .read = 0, .write = 0, .buf = buf };
        }

-        pub fn push(self: *Self, left: T, right: T) Error!void {
-            self.mutex.lock();
-            defer self.mutex.unlock();
-
-            try self._push(left);
-            self._push(right) catch |e| {
-                self.write -= 1; // undo the previous write;
-                return e;
-            };
+        pub fn deinit(self: *Self, allocator: Allocator) void {
+            allocator.free(self.buf);
+            self.* = undefined;
        }

-        pub fn pop(self: *Self) ?T {
-            self.mutex.lock();
-            defer self.mutex.unlock();
-
-            return self._pop();
-        }
-
-        pub fn len(self: *Self) Index {
-            self.mutex.lock();
-            defer self.mutex.unlock();
-
-            return self._len();
-        }
-
-        fn _push(self: *Self, value: T) Error!void {
+        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;
        }

-        fn _pop(self: *Self) ?T {
+        pub fn pop(self: *Self) ?T {
            if (self.isEmpty()) return null;
            defer self.read += 1;

            return self.buf[self.mask(self.read)];
        }

-        fn _len(self: *const Self) Index {
+        /// 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, 0..) |*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;
+            return self.len() == self.buf.len;
        }

        fn isEmpty(self: *const Self) bool {
@@ -360,25 +392,3 @@ pub fn RingBuffer(comptime T: type) type {
        }
    };
 }
-
-test "RingBuffer" {
-    const Queue = RingBuffer(u8);
-
-    var buf: [4]u8 = undefined;
-    var queue = Queue.init(&buf);
-
-    try queue.push(1, 2);
-    try std.testing.expectEqual(@as(?u8, 1), queue.pop());
-
-    try queue.push(3, 4);
-    try std.testing.expectError(Queue.Error.buffer_full, queue.push(5, 6));
-    try std.testing.expectEqual(@as(?u8, 2), queue.pop());
-
-    try queue.push(7, 8);
-
-    try std.testing.expectEqual(@as(?u8, 3), queue.pop());
-    try std.testing.expectEqual(@as(?u8, 4), queue.pop());
-    try std.testing.expectEqual(@as(?u8, 7), queue.pop());
-    try std.testing.expectEqual(@as(?u8, 8), queue.pop());
-    try std.testing.expectEqual(@as(?u8, null), queue.pop());
-}
Author	SHA1	Message	Date
Rekai Musuka	61a869f0c5	chore: update for loop in RingBuffer impl	2023-02-22 16:45:06 -06:00
Rekai Musuka	5f0eb995bd	chore: update gui libs to latest zig master	2023-02-22 16:43:08 -06:00
Rekai Musuka	3f2a19c890	chore: add gui deps to README.md	2023-02-22 16:43:08 -06:00
Rekai Musuka	cef2c83485	chore: update nfd-zig respond to build.zig changes in zig master	2023-02-22 16:43:08 -06:00
Rekai Musuka	1a794d0bd4	feat: implement menu bar + add file picker dep	2023-02-22 16:43:08 -06:00
Rekai Musuka	396f81ed1f	feat: show game title as imgui screen title	2023-02-22 16:43:08 -06:00
Rekai Musuka	37ebc88d89	chore: update zgui	2023-02-22 16:43:08 -06:00
Rekai Musuka	ff1cceed0c	feat: add scheduler ui	2023-02-22 16:43:08 -06:00
Rekai Musuka	8656392276	feat: pause emu when UI reads emu state	2023-02-22 16:43:08 -06:00
Rekai Musuka	24f1125ee8	feat: implement ui for register, interrupt	2023-02-22 16:43:08 -06:00
Rekai Musuka	cc78e7ecf0	feat: add system information window	2023-02-22 16:43:08 -06:00
Rekai Musuka	6484bb5285	fix: update zgui to work with sdl2 vcpkg package	2023-02-22 16:43:08 -06:00
Rekai Musuka	4401fe2aae	feat: add imgui support using zgui	2023-02-22 16:43:08 -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
Rekai Musuka	c3be1c0a67	chore: update to latest zig build system I feel like I'm misusing addAnonymousModule	2023-02-07 16:00:06 -06:00
Rekai Musuka	fdf7399e52	chore: update README.md	2023-02-04 19:30:05 -06:00
Rekai Musuka	ed8155139a	chore: update CI	2023-02-04 18:22:50 -06:00
Rekai Musuka	8112b1aab2	chore: update zig to latest master	2023-02-04 18:15:10 -06:00
Rekai Musuka	c0e583d20d	fix: resolve off-by-one error in `str` addr when r15 is involved I seem to have made up this rule (I was thinking about when r15 was a source register). `rn` is the destination register.... whoops	2023-01-29 08:58:41 -06:00
Rekai Musuka	3f72367aaf	chore: remove .vscode folder	2023-01-21 19:01:44 -06:00
Rekai Musuka	c27f487bf0	chore: update dependencies	2023-01-16 02:57:50 -06:00
Rekai Musuka	ae3bb94036	fix(ppu): draw file select sprites in amazing mirror	2023-01-08 01:36:58 -06:00
Rekai Musuka	ddc54e2977	fix: ignore missing opengl proc addresses is this really a fix? the error never happens with mach-glfw	2023-01-01 15:56:18 -06:00
Rekai Musuka	ed49d7c460	chore: update lib/gl.zig	2023-01-01 13:41:53 -06:00
Rekai Musuka	59baa14bde	Merge branch 'main' of ssh://musuka.dev:2222/paoda/zba	2022-12-30 19:47:24 -06:00
Rekai Musuka	6bf1c44961	chore: refactor sprite rendering code	2022-12-30 19:47:01 -06:00
Rekai Musuka	94702b9b51	chore: update min zig version	2022-12-28 16:26:51 -06:00
Rekai Musuka	0f148507e4	fix: respond to `@addWithOverflow` changes in latest zig	2022-12-28 15:20:44 -06:00
Rekai Musuka	0cec779545	chore: misc style changes	2022-12-28 07:29:07 -06:00
Rekai Musuka	1ecbbc7d29	chore: cleanup BIOS struct init code	2022-12-27 06:42:06 -06:00
Rekai Musuka	caaa60d1a8	fix: rotate unaligned reads on BIOS open-bus	2022-12-27 06:25:12 -06:00
Rekai Musuka	39d50466c9	chore: update min zig version	2022-12-22 13:21:59 -06:00
Rekai Musuka	5a452d85c1	feat: update dependencies	2022-12-21 00:24:55 -06:00
Rekai Musuka	4326ae7a0a	fix: resolve broken affine bg in mario kart	2022-12-18 08:59:19 -04:00
Rekai Musuka	905c4448d0	feat: kind-of account for 1/4th of obj mode	2022-12-18 08:35:14 -04:00
Rekai Musuka	0de44835e5	fix: properly implement black/white blending for sprites There's unique rules to handle for BLDY w/r/t sprites, I didn't know about them (shown in bld_demo.gba). I'm sure I haven't ironed out every rule but bld_demo.gba now actually passes	2022-12-18 07:44:01 -04:00
Rekai Musuka	5aac04faf5	tmp: disable buggy window emulation I'd like to merge my affine sprite impl into main, which will require merging a lot of the rewrites I did in this branch. My plan is to merge the buggy ppu window impl to main, but keep it disabled. This is technically a regression but the current impl barely worked anyways so....	2022-12-17 09:58:15 -04:00
Rekai Musuka	f98a1700e0	feat: implement affine sprites	2022-12-17 09:47:10 -04:00
Rekai Musuka	acdb270793	chore: reimplement alpha blending	2022-12-16 22:16:37 -04:00
Rekai Musuka	4ceed382ed	chore(ppu): use @ptrCast in drawTextMode	2022-12-16 22:16:37 -04:00
Rekai Musuka	52ce4f3d20	chore(ppu): reimplement modes 3, 4, and 5	2022-12-16 22:16:37 -04:00
Rekai Musuka	c1c8cac6e4	style(ppu): move text mode drawing to unique fn	2022-12-16 22:16:37 -04:00
Rekai Musuka	be7a34f719	fix(window): proper inRange impl for window window wrap now works (it's pretty slow though?)	2022-12-16 22:16:37 -04:00
Rekai Musuka	f7a94634f9	chore: improve readability of sprite drawing code a bit	2022-12-16 22:16:37 -04:00
Rekai Musuka	7d4ab6db2c	style: remove unused imports	2022-12-16 22:16:37 -04:00
Rekai Musuka	0a78587d8e	chore: dont allocate not-small ?Sprite array on stack use memset like most other allocations in this emu	2022-12-16 22:16:37 -04:00
Rekai Musuka	b753ceef8e	chore: move FrameBuffer struct to util.zig	2022-12-16 22:16:37 -04:00
Rekai Musuka	8963fe205b	chore: move OAM, PALRAM and VRAM structs to separate files	2022-12-16 22:16:37 -04:00
paoda	e906506e16	fix: 8-bit writes to WIN PPU registers Advance Wars depends on these registers similar to Mario Kart's 8-bit writes to Affine Background registers:	2022-12-16 22:16:37 -04:00
Rekai Musuka	3195a45e3d	chore: refactor window	2022-12-16 22:16:37 -04:00
Rekai Musuka	6aad911985	chore: crude background window impl (no affine)	2022-12-16 22:16:37 -04:00
Rekai Musuka	e3b45ef794	chore: rename function (misspelt until now somehow)	2022-12-16 22:16:37 -04:00
Rekai Musuka	8e1a539e70	chore: debug read takes advantage of fastmem deduplicate slowmem backup read handler	2022-12-15 23:18:54 -04:00
Rekai Musuka	63fa972afa	chore: update dependencies in response to zig master deprecations	2022-12-14 22:57:51 -04:00