diff --git a/.gitignore b/.gitignore
index 25062cc..8089f12 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,3 +4,4 @@ zig-pkg
 .claude
 CLAUDE.md
 *.log
+*.wav
diff --git a/LICENSE.zitrus b/LICENSE.zitrus
new file mode 100644
index 0000000..f18b392
--- /dev/null
+++ b/LICENSE.zitrus
@@ -0,0 +1,9 @@
+This project's 3DS backend uses components from Zitrus:
+
+Copyright © 2025 GasInfinity
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/README.md b/README.md
index 6d491e4..946f511 100644
--- a/README.md
+++ b/README.md
@@ -67,11 +67,6 @@ pub fn build(b: *std.Build) void {
         .overrides = overrides,
     });
 
-    // Compile a Slang shader for the selected backend and embed it at compile time
-    Aether.addShader(ae_dep.builder, b, exe, config, "basic", .{
-        .slang = b.path("shaders/basic.slang"),
-    });
-
     // Export the artifact (produces EBOOT.PBP for PSP, install artifact otherwise)
     Aether.exportArtifact(ae_dep.builder, b, exe, config, .{
         .title = "My Game",
@@ -83,7 +78,7 @@ pub fn build(b: *std.Build) void {
 }
 ```
 
-The first argument to `addGame`, `addShader`, and `exportArtifact` is the
+The first argument to `addGame` and `exportArtifact` is the
 dependency's builder (`ae_dep.builder`), and the second is your project's
 builder (`b`). This lets Aether resolve its own internal dependencies (GLFW,
 Vulkan, Slang, pspsdk) from its `build.zig.zon` while building artifacts that
@@ -117,11 +112,12 @@ const MyState = struct {
 };
 
 pub fn main(init: std.process.Init) !void {
-    const memory = try init.arena.allocator().alloc(u8, 32 * 1024 * 1024);
+    const memory = try init.gpa.alignedAlloc(u8, .fromByteUnits(16), 32 * 1024 * 1024);
+    defer init.gpa.free(memory);
 
     var my_state: MyState = undefined;
     var engine: ae.Engine = undefined;
-    try engine.init(init.io, memory, .{
+    try engine.init(init.io, init.environ_map, memory, .{
         .memory = .{
             .render = 8 * 1024 * 1024,
             .audio = 2 * 1024 * 1024,
@@ -159,10 +155,17 @@ zig build run -Dgfx=opengl
 # Build for PSP
 zig build -Dtarget=mipsel-psp
 
+# Build for 3DS
+zig build -Dtarget=arm-3ds-eabihf
+
 # Build in release mode
 zig build -Doptimize=ReleaseFast
 ```
 
+3DS builds default to a 4 MiB regular libctru/newlib heap and a 60 MiB
+linear heap. Aether's process allocator uses linear memory on 3DS, so engine
+pool allocations and GPU upload buffers come from the same memory class.
+
 ## Input System
 
 Actions are registered by name and bound to one or more input sources:
@@ -190,11 +193,9 @@ const Vertex = struct {
     });
     pub const Layout = Rendering.Pipeline.layout_from_struct(@This(), &Attributes);
 };
-
-const MyMesh = Rendering.Mesh(Vertex);
 ```
 
-Shaders are written in [Slang](https://shader-slang.com/) (`.slang` files), compiled at build time via `addShader`, and embedded into the binary. Vulkan consumes SPIR-V; OpenGL consumes GLSL 4.50. PSP targets ignore shaders entirely (fixed-function pipeline); the build system generates empty stubs.
+Aether owns its built-in pipeline shaders as backend internals. Downstream games create pipelines from vertex layouts; the selected backend compiles and embeds the shader code it needs.
 
 ## Build API Reference
 
@@ -210,15 +211,6 @@ Creates a game executable with the engine module and platform dependencies wired
 | `optimize` | `OptimizeMode` | Optimization level (default: `.Debug`) |
 | `overrides` | `Config.Overrides` | Graphics/display mode overrides (default: `.{}`) |
 
-### `Aether.addShader(owner, b, exe, config, name, paths)`
-
-Compiles a Slang shader for the selected backend and embeds it into the executable. Vulkan gets SPIR-V, OpenGL gets GLSL 4.50, and PSP targets get empty stubs.
-
-| Option | Type | Description |
-|--------|------|-------------|
-| `name` | `[]const u8` | Shader name (used for `@embedFile` lookup) |
-| `paths.slang` | `LazyPath` | Path to the `.slang` source file |
-
 ### `Aether.exportArtifact(owner, b, exe, config, opts)`
 
 Exports the build artifact. For PSP targets, produces an `EBOOT.PBP`. For desktop, installs the artifact normally.
@@ -233,7 +225,7 @@ Exports the build artifact. For PSP targets, produces an `EBOOT.PBP`. For deskto
 
 ### `Aether.Config.resolve(target, overrides) -> Config`
 
-Resolves the full engine configuration (platform, graphics backend, audio, input) from the build target and any user overrides. Pass the result to `addShader` and `exportArtifact`.
+Resolves the full engine configuration (platform, graphics backend, audio, input) from the build target and any user overrides. Pass the result to `exportArtifact`.
 
 ### `Aether.Config.Overrides`
 
diff --git a/build.zig b/build.zig
index 03b5eb5..ed712c0 100644
--- a/build.zig
+++ b/build.zig
@@ -1,17 +1,32 @@
 const std = @import("std");
 const pspsdk = @import("pspsdk");
 
+const DEFAULT_3DS_HEAP_SIZE: u32 = 4 * 1024 * 1024;
+const DEFAULT_3DS_LINEAR_HEAP_SIZE: u32 = 60 * 1024 * 1024;
+
 pub const Platform = enum {
     windows,
     linux,
     macos,
+    wasm,
     psp,
+    /// Nintendo 3DS. Builtin os tag is `.@"3ds"`, but the Zig options
+    /// serializer can't emit `.@"3ds"` as an enum value literal, so the
+    /// internal Aether tag uses a leading-letter form.
+    nintendo_3ds,
+    /// Nintendo Switch. Zig 0.16 has no `switch`/`horizon` OS tag, so the
+    /// canonical target is `aarch64-freestanding-none` and we can't infer
+    /// the platform from `target.os.tag` alone. Opt in with
+    /// `-Dnintendo-switch=true`; `Config.resolve` then promotes a
+    /// freestanding aarch64 target to this variant.
+    nintendo_switch,
 };
 
 pub const Gfx = enum {
     default,
     opengl,
     vulkan,
+    webgl,
     headless,
 };
 
@@ -39,6 +54,10 @@ pub const Config = struct {
     /// levels for the texture. Off by default since the extra VRAM cost
     /// only pays off for textures sampled at a wide range of distances.
     psp_mipmaps: bool = false,
+    /// 3DS: small regular heap reserved for libctru/newlib internals.
+    nintendo_3ds_heap_size: u32 = DEFAULT_3DS_HEAP_SIZE,
+    /// 3DS: linear heap used by Aether's process allocator and GPU uploads.
+    nintendo_3ds_linear_heap_size: u32 = DEFAULT_3DS_LINEAR_HEAP_SIZE,
     /// When true, `Core.paths.resolve` returns CWD for both resources
     /// and data, bypassing the platform-specific layout (.app Resources
     /// on mac, APPDATA on Windows, XDG on Linux).
@@ -52,32 +71,43 @@ pub const Config = struct {
     ///   - Debug builds of unpackaged binaries on macOS, where resources
     ///     aren't inside a .app yet.
     use_cwd: bool = false,
+    /// Flush the file log after every message. Useful for diagnosing hard
+    /// hangs on consoles where normal shutdown never reaches logger.deinit.
+    flush_logs: bool = false,
 
     pub fn resolve(target: std.Build.ResolvedTarget, overrides: Overrides) Config {
-        const plat: Platform = switch (target.result.os.tag) {
-            .windows => .windows,
-            .macos => .macos,
-            .linux => .linux,
-            .psp => .psp,
-            else => |t| {
-                std.debug.panic("Unsupported OS! {}\n", .{t});
-            },
+        const plat: Platform = blk: {
+            if (overrides.nintendo_switch == true) {
+                if (target.result.cpu.arch != .aarch64 or target.result.os.tag != .freestanding) {
+                    std.debug.panic(
+                        "-Dnintendo-switch=true requires -Dtarget=aarch64-freestanding-none (got {s}-{s})\n",
+                        .{ @tagName(target.result.cpu.arch), @tagName(target.result.os.tag) },
+                    );
+                }
+                break :blk .nintendo_switch;
+            }
+            break :blk switch (target.result.os.tag) {
+                .windows => .windows,
+                .macos => .macos,
+                .linux => .linux,
+                .wasi => .wasm,
+                .psp => .psp,
+                .@"3ds" => .nintendo_3ds,
+                else => |t| {
+                    std.debug.panic("Unsupported OS! {}\n", .{t});
+                },
+            };
         };
 
         const default_gfx: Gfx = switch (target.result.os.tag) {
             .windows => .vulkan,
             .macos => .vulkan,
             .linux => .vulkan,
+            .wasi => .webgl,
             else => .default,
         };
 
-        // macOS default is `.none` because the current miniaudio build is
-        // bugged there. Flip back to `.default` with `-Daudio=default` once
-        // that's fixed.
-        const default_audio: Audio = switch (target.result.os.tag) {
-            .macos => .none,
-            else => .default,
-        };
+        const default_audio: Audio = .default;
 
         return .{
             .platform = plat,
@@ -85,7 +115,10 @@ pub const Config = struct {
             .audio = overrides.audio orelse default_audio,
             .psp_display_mode = overrides.psp_display_mode orelse .rgba8888,
             .psp_mipmaps = overrides.psp_mipmaps orelse false,
+            .nintendo_3ds_heap_size = overrides.nintendo_3ds_heap_size orelse DEFAULT_3DS_HEAP_SIZE,
+            .nintendo_3ds_linear_heap_size = overrides.nintendo_3ds_linear_heap_size orelse DEFAULT_3DS_LINEAR_HEAP_SIZE,
             .use_cwd = overrides.use_cwd orelse false,
+            .flush_logs = overrides.flush_logs orelse false,
         };
     }
 
@@ -94,7 +127,13 @@ pub const Config = struct {
         audio: ?Audio = null,
         psp_display_mode: ?PspDisplayMode = null,
         psp_mipmaps: ?bool = null,
+        nintendo_3ds_heap_size: ?u32 = null,
+        nintendo_3ds_linear_heap_size: ?u32 = null,
         use_cwd: ?bool = null,
+        flush_logs: ?bool = null,
+        /// Promotes an `aarch64-freestanding-none` target to the
+        /// `nintendo_switch` platform. No effect when null/false.
+        nintendo_switch: ?bool = null,
     };
 };
 
@@ -114,10 +153,17 @@ pub const HeadlessOptions = struct {
     overrides: Config.Overrides = .{},
 };
 
-pub const ShaderPaths = struct {
-    slang: std.Build.LazyPath,
+const ShaderStagePaths = struct {
+    vert: std.Build.LazyPath,
+    frag: std.Build.LazyPath,
 };
 
+const user_root_import_name = "aether_user_root";
+
+pub fn userRootModule(exe: *std.Build.Step.Compile) *std.Build.Module {
+    return exe.root_module.import_table.get(user_root_import_name) orelse exe.root_module;
+}
+
 // Cached per-build user options. b.option panics on second declaration, so
 // these getters declare once and memoize. Accessed from both addGame (for
 // linking) and exportArtifact (for bundle packaging). Module-level mutable
@@ -141,6 +187,79 @@ fn macosGlfwPath(b: *std.Build) []const u8 {
     return p;
 }
 
+var devkitpro_path_cached: ?[]const u8 = null;
+fn devkitProPath(b: *std.Build) []const u8 {
+    if (devkitpro_path_cached) |p| return p;
+    const opt = b.option([]const u8, "devkitpro-path", "3DS: devkitPro install root (default: $DEVKITPRO or /opt/devkitpro)");
+    const p = opt orelse b.graph.environ_map.get("DEVKITPRO") orelse "/opt/devkitpro";
+    devkitpro_path_cached = p;
+    return p;
+}
+
+var spirv_cross_path_cached: ?[]const u8 = null;
+fn spirvCrossPath(b: *std.Build) []const u8 {
+    if (spirv_cross_path_cached) |p| return p;
+    const p = b.option([]const u8, "spirv-cross-path", "WASM/browser: spirv-cross executable path (default: spirv-cross)") orelse "spirv-cross";
+    spirv_cross_path_cached = p;
+    return p;
+}
+
+pub fn webTarget(b: *std.Build) std.Build.ResolvedTarget {
+    return b.resolveTargetQuery(.{
+        .cpu_arch = .wasm32,
+        .os_tag = .wasi,
+        .abi = .musl,
+        .cpu_features_add = std.Target.wasm.featureSet(&.{ .atomics, .bulk_memory }),
+    });
+}
+
+fn addNintendoCImportPaths(owner: *std.Build, mod: *std.Build.Module, config: Config, dkp: []const u8) void {
+    const b = mod.owner;
+    mod.addIncludePath(owner.path("src/platform"));
+    switch (config.platform) {
+        .nintendo_3ds => {
+            // Keep newlib before libctru so libctru's include_next sys wrappers
+            // resolve during Zig's C translation of SDK headers.
+            //
+            // Zig's 3DS C import can otherwise see newlib's fortified unistd
+            // wrappers and emit references to __ssp_real_* symbols. devkitARM is
+            // built without libssp, so keep fortify off for translated SDK calls.
+            mod.addCMacro("_FORTIFY_SOURCE", "0");
+            mod.addIncludePath(.{ .cwd_relative = b.pathJoin(&.{ dkp, "devkitARM/arm-none-eabi/include" }) });
+            mod.addIncludePath(.{ .cwd_relative = b.pathJoin(&.{ dkp, "libctru/include" }) });
+        },
+        .nintendo_switch => {
+            // Zig's Switch C import can otherwise see newlib's fortified
+            // wrappers and emit references to __ssp_real_* symbols.
+            mod.addCMacro("_FORTIFY_SOURCE", "0");
+            mod.addIncludePath(.{ .cwd_relative = b.pathJoin(&.{ dkp, "devkitA64/aarch64-none-elf/include" }) });
+            mod.addIncludePath(.{ .cwd_relative = b.pathJoin(&.{ dkp, "libnx/include" }) });
+        },
+        else => {},
+    }
+}
+
+/// Creates a `3dslink` command for pushing an installed `.3dsx` to a
+/// networked 3DS. Reuses Aether's devkitPro option/cache so downstream
+/// builds do not need to redeclare `-Ddevkitpro-path`.
+pub fn add3dslink(b: *std.Build, threedsx_path: []const u8) *std.Build.Step.Run {
+    const dkp = devkitProPath(b);
+    const link_cmd = b.addSystemCommand(&.{b.pathJoin(&.{ dkp, "tools/bin/3dslink" })});
+    if (b.option([]const u8, "3dslink-address", "3DS: target IP for 3dslink push (default: mDNS auto-discover)")) |ip| {
+        link_cmd.addArgs(&.{ "-a", ip });
+    }
+    if (b.option(u32, "3dslink-retries", "3DS: 3dslink retry count (default: 10)")) |n| {
+        link_cmd.addArgs(&.{ "-r", b.fmt("{d}", .{n}) });
+    }
+    if (b.option(bool, "3dslink-server", "3DS: pass -s so 3dslink stays listening after the upload (useful for some Rosalina versions and for stdout relay)") orelse false) {
+        link_cmd.addArg("-s");
+    }
+    link_cmd.addArg(threedsx_path);
+    link_cmd.step.dependOn(b.getInstallStep());
+    if (b.args) |args| link_cmd.addArgs(args);
+    return link_cmd;
+}
+
 /// Creates an executable with the Aether engine module and all platform
 /// dependencies wired up. Returns the compile step so the caller can
 /// further customize it (install, add run steps, etc.).
@@ -156,6 +275,17 @@ fn macosGlfwPath(b: *std.Build) []const u8 {
 /// the actual build steps and executable.
 pub fn addGame(owner: *std.Build, b: *std.Build, opts: GameOptions) *std.Build.Step.Compile {
     const config = Config.resolve(opts.target, opts.overrides);
+    const uses_nintendo_c_io = config.platform == .nintendo_3ds or config.platform == .nintendo_switch;
+
+    // 3DS and Switch force ofmt=c — there's no Zig-native backend for
+    // either Horizon target yet, so we emit C and let an external
+    // toolchain (devkitARM/libctru on 3DS, devkitA64/libnx on Switch)
+    // compile the result.
+    const target = if (uses_nintendo_c_io) blk: {
+        var q = opts.target.query;
+        q.ofmt = .c;
+        break :blk b.resolveTargetQuery(q);
+    } else opts.target;
 
     const options = b.addOptions();
     options.addOption(Config, "config", config);
@@ -163,7 +293,8 @@ pub fn addGame(owner: *std.Build, b: *std.Build, opts: GameOptions) *std.Build.S
 
     const mod = b.addModule("Aether", .{
         .root_source_file = owner.path("src/root.zig"),
-        .target = opts.target,
+        .target = target,
+        .link_libc = if (uses_nintendo_c_io) true else null,
         .imports = &.{
             .{ .name = "options", .module = options_module },
         },
@@ -171,20 +302,27 @@ pub fn addGame(owner: *std.Build, b: *std.Build, opts: GameOptions) *std.Build.S
 
     // --- platform-specific engine dependencies ---
     const psp_dep = if (config.platform == .psp) owner.dependency("pspsdk", .{
-        .target = opts.target,
+        .target = target,
         .optimize = opts.optimize,
     }) else null;
 
     if (psp_dep) |pd| {
         mod.addImport("pspsdk", pd.module("pspsdk"));
+    } else if (config.platform == .nintendo_3ds or config.platform == .nintendo_switch) {
+        // Console SDK symbols are declared as backend-local externs and
+        // resolved by the export pipeline's devkitPro link step.
+    } else if (config.platform == .wasm) {
+        // Browser builds use host imports for WebGL/Web Audio/input and WASI
+        // imports for files, clocks, stdio, random, and environment. They do
+        // not link desktop windowing/audio dependencies.
     } else {
         const zglfw = owner.dependency("zglfw", .{
-            .target = opts.target,
+            .target = target,
             .optimize = opts.optimize,
         });
 
         const glfw = owner.dependency("glfw_zig", .{
-            .target = opts.target,
+            .target = target,
             .optimize = opts.optimize,
         });
 
@@ -203,15 +341,33 @@ pub fn addGame(owner: *std.Build, b: *std.Build, opts: GameOptions) *std.Build.S
         mod.addImport("vulkan", vulkan);
 
         if (config.audio != .none) {
-            const zaudio_dep = owner.dependency("zaudio", .{
-                .target = opts.target,
+            const sdl3_dep = owner.lazyDependency("sdl3", .{
+                .target = target,
                 .optimize = opts.optimize,
-            });
-            mod.addImport("zaudio", zaudio_dep.module("root"));
-            mod.linkLibrary(zaudio_dep.artifact("miniaudio"));
+                .main = false,
+                .ext_image = false,
+                .ext_net = false,
+                .ext_ttf = false,
+                // Static SDL3 and static GLFW both embed generated Wayland
+                // protocol objects on Linux. Keep SDL dynamic there since
+                // Aether only uses its audio subsystem.
+                .c_sdl_preferred_linkage = @as(
+                    std.builtin.LinkMode,
+                    if (target.result.os.tag == .linux) .dynamic else .static,
+                ),
+            }) orelse @panic("sdl3 dependency is required when desktop audio is enabled");
+            mod.addImport("sdl3", sdl3_dep.module("sdl3"));
+
+            if (target.result.os.tag == .linux) {
+                mod.addRPathSpecial("$ORIGIN");
+                const install_sdl3 = b.addInstallArtifact(sdl3_dep.artifact("SDL3"), .{
+                    .dest_dir = .{ .override = .bin },
+                });
+                b.getInstallStep().dependOn(&install_sdl3.step);
+            }
         }
 
-        if (opts.target.result.os.tag == .macos) {
+        if (target.result.os.tag == .macos) {
             // Link MoltenVK directly as the Vulkan ICD -- no loader. Feeds
             // its vkGetInstanceProcAddr into GLFW via glfwInitVulkanLoader
             // in platform/glfw/surface.zig so GLFW doesn't dlopen libvulkan
@@ -236,26 +392,54 @@ pub fn addGame(owner: *std.Build, b: *std.Build, opts: GameOptions) *std.Build.S
         }
     }
 
+    if (uses_nintendo_c_io) {
+        addNintendoCImportPaths(owner, mod, config, devkitProPath(b));
+    }
+    if (config.platform == .nintendo_3ds and config.gfx == .default) {
+        add3dsMangoImport(owner, b, mod, target, opts.optimize);
+    }
+
+    addInternalShaderModule(owner, b, mod, config);
+
     // --- user executable ---
+    const user_mod = b.createModule(.{
+        .root_source_file = opts.root_source_file,
+        .target = target,
+        .optimize = opts.optimize,
+        .strip = if (config.platform == .psp) false else null,
+        .link_libc = if (uses_nintendo_c_io) true else null,
+        .imports = &.{
+            .{ .name = "aether", .module = mod },
+        },
+    });
+
+    const root_mod = if (uses_nintendo_c_io) b.createModule(.{
+        .root_source_file = owner.path(switch (config.platform) {
+            .nintendo_3ds => "src/platform/3ds/services.zig",
+            .nintendo_switch => "src/platform/switch/services.zig",
+            else => unreachable,
+        }),
+        .target = target,
+        .optimize = opts.optimize,
+        .link_libc = true,
+        .imports = &.{
+            .{ .name = "aether", .module = mod },
+            .{ .name = user_root_import_name, .module = user_mod },
+            .{ .name = "options", .module = options_module },
+        },
+    }) else user_mod;
+
     const exe = b.addExecutable(.{
         .name = opts.name,
-        .root_module = b.createModule(.{
-            .root_source_file = opts.root_source_file,
-            .target = opts.target,
-            .optimize = opts.optimize,
-            .strip = if (config.platform == .psp) false else null,
-            .imports = &.{
-                .{ .name = "aether", .module = mod },
-            },
-        }),
+        .root_module = root_mod,
     });
 
     if (psp_dep) |pd| {
         // Inline PSP config -- pspsdk.configurePspExecutable uses
         // dependencyFromBuildZig on exe.step.owner which fails when
         // the exe is owned by a downstream builder.
-        if (exe.root_module.import_table.get("pspsdk") == null) {
-            exe.root_module.addImport("pspsdk", mod.import_table.get("pspsdk").?);
+        if (userRootModule(exe).import_table.get("pspsdk") == null) {
+            userRootModule(exe).addImport("pspsdk", mod.import_table.get("pspsdk").?);
         }
         exe.link_eh_frame_hdr = true;
         exe.link_emit_relocs = true;
@@ -267,6 +451,21 @@ pub fn addGame(owner: *std.Build, b: *std.Build, opts: GameOptions) *std.Build.S
         exe.subsystem = .windows;
     }
 
+    if (uses_nintendo_c_io) {
+        // The platform shim exports C `main` itself. Keeping std/start's
+        // libc main wrapper disabled avoids pulling in unsupported
+        // freestanding libc/thread startup paths while still preserving the
+        // exported shim in the emitted C.
+        exe.entry = .disabled;
+    } else if (config.platform == .wasm) {
+        exe.entry = .disabled;
+        exe.rdynamic = true;
+        exe.wasi_exec_model = .reactor;
+        exe.shared_memory = true;
+        exe.initial_memory = 64 * 1024 * 1024;
+        exe.max_memory = 256 * 1024 * 1024;
+    }
+
     return exe;
 }
 
@@ -285,6 +484,14 @@ pub fn addHeadless(owner: *std.Build, b: *std.Build, opts: HeadlessOptions) *std
     var config = Config.resolve(opts.target, opts.overrides);
     config.gfx = .headless;
     config.audio = .none;
+    const uses_nintendo_c_io = config.platform == .nintendo_3ds or config.platform == .nintendo_switch;
+
+    // 3DS and Switch force ofmt=c (see addGame for details).
+    const target = if (uses_nintendo_c_io) blk: {
+        var q = opts.target.query;
+        q.ofmt = .c;
+        break :blk b.resolveTargetQuery(q);
+    } else opts.target;
 
     const options = b.addOptions();
     options.addOption(Config, "config", config);
@@ -292,14 +499,15 @@ pub fn addHeadless(owner: *std.Build, b: *std.Build, opts: HeadlessOptions) *std
 
     const mod = b.addModule("Aether", .{
         .root_source_file = owner.path("src/root.zig"),
-        .target = opts.target,
+        .target = target,
+        .link_libc = if (uses_nintendo_c_io) true else null,
         .imports = &.{
             .{ .name = "options", .module = options_module },
         },
     });
 
     const psp_dep = if (config.platform == .psp) owner.dependency("pspsdk", .{
-        .target = opts.target,
+        .target = target,
         .optimize = opts.optimize,
     }) else null;
 
@@ -307,22 +515,45 @@ pub fn addHeadless(owner: *std.Build, b: *std.Build, opts: HeadlessOptions) *std
         mod.addImport("pspsdk", pd.module("pspsdk"));
     }
 
+    if (uses_nintendo_c_io) {
+        addNintendoCImportPaths(owner, mod, config, devkitProPath(b));
+    }
+
+    const user_mod = b.createModule(.{
+        .root_source_file = opts.root_source_file,
+        .target = target,
+        .optimize = opts.optimize,
+        .strip = if (config.platform == .psp) false else null,
+        .link_libc = if (uses_nintendo_c_io) true else null,
+        .imports = &.{
+            .{ .name = "aether", .module = mod },
+        },
+    });
+
+    const root_mod = if (uses_nintendo_c_io) b.createModule(.{
+        .root_source_file = owner.path(switch (config.platform) {
+            .nintendo_3ds => "src/platform/3ds/services.zig",
+            .nintendo_switch => "src/platform/switch/services.zig",
+            else => unreachable,
+        }),
+        .target = target,
+        .optimize = opts.optimize,
+        .link_libc = true,
+        .imports = &.{
+            .{ .name = "aether", .module = mod },
+            .{ .name = user_root_import_name, .module = user_mod },
+            .{ .name = "options", .module = options_module },
+        },
+    }) else user_mod;
+
     const exe = b.addExecutable(.{
         .name = opts.name,
-        .root_module = b.createModule(.{
-            .root_source_file = opts.root_source_file,
-            .target = opts.target,
-            .optimize = opts.optimize,
-            .strip = if (config.platform == .psp) false else null,
-            .imports = &.{
-                .{ .name = "aether", .module = mod },
-            },
-        }),
+        .root_module = root_mod,
     });
 
     if (psp_dep) |pd| {
-        if (exe.root_module.import_table.get("pspsdk") == null) {
-            exe.root_module.addImport("pspsdk", mod.import_table.get("pspsdk").?);
+        if (userRootModule(exe).import_table.get("pspsdk") == null) {
+            userRootModule(exe).addImport("pspsdk", mod.import_table.get("pspsdk").?);
         }
         exe.link_eh_frame_hdr = true;
         exe.link_emit_relocs = true;
@@ -330,6 +561,17 @@ pub fn addHeadless(owner: *std.Build, b: *std.Build, opts: HeadlessOptions) *std
         exe.setLinkerScript(pd.path("tools/linkfile.ld"));
     }
 
+    if (uses_nintendo_c_io) {
+        exe.entry = .disabled;
+    } else if (config.platform == .wasm) {
+        exe.entry = .disabled;
+        exe.rdynamic = true;
+        exe.wasi_exec_model = .reactor;
+        exe.shared_memory = true;
+        exe.initial_memory = 64 * 1024 * 1024;
+        exe.max_memory = 256 * 1024 * 1024;
+    }
+
     return exe;
 }
 
@@ -356,10 +598,13 @@ fn slangcPath(owner: *std.Build) ?std.Build.LazyPath {
     return dep.path(exe_name);
 }
 
-fn addSlangStep(b: *std.Build, slangc: ?std.Build.LazyPath, args: []const []const u8, comptime output_name: []const u8, input: std.Build.LazyPath) ?std.Build.LazyPath {
-    const sc = slangc orelse return null;
+fn requireSlangcPath(owner: *std.Build) std.Build.LazyPath {
+    return slangcPath(owner) orelse @panic("slangc dependency unavailable; run zig build --fetch");
+}
+
+fn addSlangStep(b: *std.Build, slangc: std.Build.LazyPath, args: []const []const u8, comptime output_name: []const u8, input: std.Build.LazyPath) std.Build.LazyPath {
     const run = std.Build.Step.Run.create(b, "slangc " ++ output_name);
-    run.addFileArg(sc);
+    run.addFileArg(slangc);
     run.addArgs(args);
     run.addArg("-o");
     const output = run.addOutputFileArg(output_name);
@@ -367,6 +612,202 @@ fn addSlangStep(b: *std.Build, slangc: ?std.Build.LazyPath, args: []const []cons
     return output;
 }
 
+fn addSpirvCrossStep(b: *std.Build, spirv_cross: []const u8, args: []const []const u8, comptime output_name: []const u8, input: std.Build.LazyPath) std.Build.LazyPath {
+    const run = b.addSystemCommand(&.{spirv_cross});
+    run.setName("spirv-cross " ++ output_name);
+    run.addFileArg(input);
+    run.addArgs(args);
+    run.addArg("--output");
+    return run.addOutputFileArg(output_name);
+}
+
+fn addUamStep(b: *std.Build, uam: []const u8, stage: []const u8, comptime output_name: []const u8, input: std.Build.LazyPath) std.Build.LazyPath {
+    const run = b.addSystemCommand(&.{ uam, "-s", stage, "-o" });
+    const output = run.addOutputFileArg(output_name);
+    run.addFileArg(input);
+    return output;
+}
+
+fn addPicassoStep(b: *std.Build, picasso: []const u8, comptime output_name: []const u8, input: std.Build.LazyPath) std.Build.LazyPath {
+    const run = b.addSystemCommand(&.{ picasso, "-o" });
+    const output = run.addOutputFileArg(output_name);
+    run.addFileArg(input);
+    return output;
+}
+
+fn add3dsMangoImport(owner: *std.Build, b: *std.Build, mod: *std.Build.Module, target: std.Build.ResolvedTarget, optimize: std.builtin.OptimizeMode) void {
+    const zsflt = owner.dependency("zsflt", .{}).module("zsflt");
+    const dkp = devkitProPath(owner);
+    const zitrus_mod = b.createModule(.{
+        .root_source_file = owner.path("src/platform/3ds/mango/zitrus.zig"),
+        .target = target,
+        .optimize = optimize,
+        .imports = &.{
+            .{ .name = "zsflt", .module = zsflt },
+        },
+    });
+    zitrus_mod.addImport("zitrus", zitrus_mod);
+    zitrus_mod.addIncludePath(owner.path("src/platform"));
+    zitrus_mod.addCMacro("_FORTIFY_SOURCE", "0");
+    zitrus_mod.addIncludePath(.{ .cwd_relative = b.pathJoin(&.{ dkp, "devkitARM/arm-none-eabi/include" }) });
+    zitrus_mod.addIncludePath(.{ .cwd_relative = b.pathJoin(&.{ dkp, "libctru/include" }) });
+    mod.addImport("zitrus", zitrus_mod);
+}
+
+fn addMangoPsmStep(owner: *std.Build, b: *std.Build, comptime output_name: []const u8, input: std.Build.LazyPath) std.Build.LazyPath {
+    const zsflt = owner.dependency("zsflt", .{}).module("zsflt");
+    const host_target = b.resolveTargetQuery(.{});
+    const zitrus_mod = b.createModule(.{
+        .root_source_file = owner.path("src/platform/3ds/mango/zitrus_tools.zig"),
+        .target = host_target,
+        .optimize = .Debug,
+        .imports = &.{
+            .{ .name = "zsflt", .module = zsflt },
+        },
+    });
+    zitrus_mod.addImport("zitrus", zitrus_mod);
+
+    const tool = b.addExecutable(.{
+        .name = "aether-psm-to-zpsh",
+        .root_module = b.createModule(.{
+            .root_source_file = owner.path("src/platform/3ds/mango/tools/psm_to_zpsh.zig"),
+            .target = host_target,
+            .optimize = .Debug,
+            .imports = &.{
+                .{ .name = "zitrus", .module = zitrus_mod },
+            },
+        }),
+    });
+
+    const run = b.addRunArtifact(tool);
+    run.setName("assemble 3ds mango shader");
+    run.addFileArg(input);
+    return run.addOutputFileArg(output_name);
+}
+
+fn addInternalShaderModule(owner: *std.Build, b: *std.Build, mod: *std.Build.Module, config: Config) void {
+    const stages = internalShaderStages(owner, b, config) orelse return;
+
+    const files = b.addWriteFiles();
+    _ = files.addCopyFile(stages.vert, "basic.vert");
+    _ = files.addCopyFile(stages.frag, "basic.frag");
+    const root = files.add("aether_shaders.zig",
+        \\pub const basic_vert align(@alignOf(u32)) = @embedFile("basic.vert").*;
+        \\pub const basic_frag align(@alignOf(u32)) = @embedFile("basic.frag").*;
+        \\
+    );
+
+    mod.addImport("aether_shaders", b.createModule(.{
+        .root_source_file = root,
+    }));
+}
+
+fn internalShaderStages(owner: *std.Build, b: *std.Build, config: Config) ?ShaderStagePaths {
+    if (config.platform == .nintendo_3ds and config.gfx == .default) {
+        const vert = addMangoPsmStep(owner, b, "basic.psh", owner.path("src/platform/3ds/shaders/basic.psm"));
+        const files = b.addWriteFiles();
+        const frag = files.add("basic.frag.stub", "");
+        return .{ .vert = vert, .frag = frag };
+    }
+
+    if (config.platform == .nintendo_switch and config.gfx == .default) {
+        const uam = b.pathJoin(&.{ devkitProPath(b), "tools/bin/uam" });
+        const slangc = requireSlangcPath(owner);
+        const source = owner.path("src/rendering/shaders/basic.slang");
+        const vert_glsl = addSlangStep(b, slangc, &.{
+            "-target",    "glsl",     "-matrix-layout-column-major",
+            "-profile",   "glsl_450", "-entry",
+            "vertexMain", "-stage",   "vertex",
+        }, "basic.vert.switch.glsl", source);
+        const frag_glsl = addSlangStep(b, slangc, &.{
+            "-target",      "glsl",     "-matrix-layout-column-major",
+            "-profile",     "glsl_450", "-entry",
+            "fragmentMain", "-stage",   "fragment",
+        }, "basic.frag.switch.glsl", source);
+        return .{
+            .vert = addUamStep(
+                b,
+                uam,
+                "vert",
+                "basic.vert.dksh",
+                vert_glsl,
+            ),
+            .frag = addUamStep(
+                b,
+                uam,
+                "frag",
+                "basic.frag.dksh",
+                frag_glsl,
+            ),
+        };
+    }
+
+    switch (config.gfx) {
+        .vulkan => {
+            const slangc = requireSlangcPath(owner);
+            const source = owner.path("src/rendering/shaders/basic.slang");
+            return .{
+                .vert = addSlangStep(b, slangc, &.{
+                    "-target",  "spirv",  "-emit-spirv-directly", "-matrix-layout-column-major",
+                    "-DVULKAN", "-entry", "vertexMain",           "-stage",
+                    "vertex",
+                }, "basic.vert.spv", source),
+                .frag = addSlangStep(b, slangc, &.{
+                    "-target",  "spirv",  "-emit-spirv-directly", "-matrix-layout-column-major",
+                    "-DVULKAN", "-entry", "fragmentMain",         "-stage",
+                    "fragment",
+                }, "basic.frag.spv", source),
+            };
+        },
+        .opengl => {
+            const slangc = requireSlangcPath(owner);
+            const source = owner.path("src/rendering/shaders/basic.slang");
+            return .{
+                .vert = addSlangStep(b, slangc, &.{
+                    "-target",    "glsl",     "-matrix-layout-column-major",
+                    "-profile",   "glsl_450", "-entry",
+                    "vertexMain", "-stage",   "vertex",
+                }, "basic.vert.glsl", source),
+                .frag = addSlangStep(b, slangc, &.{
+                    "-target",      "glsl",     "-matrix-layout-column-major",
+                    "-profile",     "glsl_450", "-entry",
+                    "fragmentMain", "-stage",   "fragment",
+                }, "basic.frag.glsl", source),
+            };
+        },
+        .webgl => {
+            const slangc = requireSlangcPath(owner);
+            const spirv_cross = spirvCrossPath(b);
+            const source = owner.path("src/rendering/shaders/basic.slang");
+            const vert_spv = addSlangStep(b, slangc, &.{
+                "-entry",   "vertexMain", "-stage",               "vertex",
+                "-profile", "glsl_330",   "-emit-spirv-via-glsl", "-matrix-layout-column-major",
+            }, "basic.vert.webgl.spv", source);
+            const frag_spv = addSlangStep(b, slangc, &.{
+                "-entry",   "fragmentMain", "-stage",               "fragment",
+                "-profile", "glsl_330",     "-emit-spirv-via-glsl", "-matrix-layout-column-major",
+            }, "basic.frag.webgl.spv", source);
+            return .{
+                .vert = addSpirvCrossStep(b, spirv_cross, &.{
+                    "--es",                        "--version",                   "300",
+                    "--rename-interface-variable", "out",                         "0",
+                    "v_uv",                        "--rename-interface-variable", "out",
+                    "1",                           "v_color",                     "--rename-interface-variable",
+                    "out",                         "2",                           "v_viewDepth",
+                }, "basic.vert.webgl.glsl", vert_spv),
+                .frag = addSpirvCrossStep(b, spirv_cross, &.{
+                    "--es",                        "--version",                   "300",
+                    "--rename-interface-variable", "in",                          "0",
+                    "v_uv",                        "--rename-interface-variable", "in",
+                    "1",                           "v_color",                     "--rename-interface-variable",
+                    "in",                          "2",                           "v_viewDepth",
+                }, "basic.frag.webgl.glsl", frag_spv),
+            };
+        },
+        .default, .headless => return null,
+    }
+}
+
 pub const ExportOptions = struct {
     /// PSP/macOS: human-readable name shown to the OS (XMB title on PSP,
     /// CFBundleName on macOS). Ignored elsewhere.
@@ -391,8 +832,41 @@ pub const ExportOptions = struct {
     icon_png: ?std.Build.LazyPath = null,
     /// Files to install into the app bundle. On macOS they land under
     /// `Contents/Resources/<name>`. On desktop non-macOS they are copied
-    /// alongside the exe in `zig-out/bin/`. Ignored on PSP.
+    /// alongside the exe in `zig-out/bin/`. Ignored on PSP and 3DS.
     resources: []const Resource = &.{},
+    /// WASM/browser: directory copied into the web artifact root and exposed
+    /// through `resources.manifest` for the JavaScript WASI preloader.
+    web_resources: ?std.Build.LazyPath = null,
+    /// WASM/browser: individual files copied into the web artifact root.
+    web_resource_files: []const Resource = &.{},
+    /// WASM/browser: newline-delimited resource paths relative to
+    /// `web_resources`.
+    web_resource_manifest: []const u8 = "",
+    /// WASM/browser: destination wasm filename. Defaults to the name expected
+    /// by the stock Aether web loader.
+    web_wasm_name: []const u8 = "Aether.wasm",
+    /// 3DS: SMDH long description (the second line shown in the HOME
+    /// menu detail panel). Falls back to "Built with Aether" when empty.
+    smdh_long_description: []const u8 = "",
+    /// 3DS: SMDH author string. Empty leaves the field blank.
+    smdh_author: []const u8 = "",
+    /// 3DS: 48x48 PNG icon embedded in the SMDH. When null, libctru's
+    /// `default_icon.png` is used.
+    smdh_icon: ?std.Build.LazyPath = null,
+    /// 3DS: directory (or pre-built `.romfs`) embedded into the 3DSX.
+    romfs: ?std.Build.LazyPath = null,
+    /// Switch: NACP author string (shows under the title in the HOME
+    /// menu). Empty falls back to "Aether".
+    switch_author: []const u8 = "",
+    /// Switch: NACP version string (e.g. "1.0.0"). Empty falls back to
+    /// "1.0.0".
+    switch_version: []const u8 = "",
+    /// Switch: 256x256 JPEG icon embedded in the NRO. When null, libnx's
+    /// `default_icon.jpg` is used.
+    switch_icon: ?std.Build.LazyPath = null,
+    /// Switch: directory embedded into the NRO as RomFS. When null, no
+    /// RomFS is attached.
+    switch_romfs: ?std.Build.LazyPath = null,
 
     pub const Resource = struct {
         /// Source file to copy.
@@ -416,6 +890,13 @@ pub fn exportArtifact(owner: *std.Build, b: *std.Build, exe: *std.Build.Step.Com
         // register on the downstream project's builder.
         const psp_dep = owner.dependency("pspsdk", .{});
         _ = pspEbootPipeline(b, exe, psp_dep, opts);
+    } else if (config.platform == .nintendo_3ds) {
+        threedsxPipeline(b, exe, opts);
+    } else if (config.platform == .nintendo_switch) {
+        switchNroPipeline(b, exe, opts);
+    } else if (config.platform == .wasm) {
+        const install = addWebBundle(owner, b, exe, opts);
+        b.getInstallStep().dependOn(&install.step);
     } else if (config.platform == .macos) {
         macosAppBundle(b, exe, opts);
     } else {
@@ -427,6 +908,50 @@ pub fn exportArtifact(owner: *std.Build, b: *std.Build, exe: *std.Build.Step.Com
     }
 }
 
+pub fn addWebBundle(owner: *std.Build, b: *std.Build, exe: *std.Build.Step.Compile, opts: ExportOptions) *std.Build.Step.InstallDir {
+    const web = b.addWriteFiles();
+    _ = web.addCopyFile(exe.getEmittedBin(), opts.web_wasm_name);
+    _ = web.addCopyFile(owner.path("web/index.html"), "index.html");
+    _ = web.addCopyFile(owner.path("web/aether.js"), "aether.js");
+    _ = web.add("resources.manifest", opts.web_resource_manifest);
+    if (opts.web_resources) |resource_dir| {
+        _ = web.addCopyDirectory(resource_dir, "", .{});
+    }
+    for (opts.web_resource_files) |res| {
+        _ = web.addCopyFile(res.path, res.name);
+    }
+
+    return b.addInstallDirectory(.{
+        .source_dir = web.getDirectory(),
+        .install_dir = .prefix,
+        .install_subdir = "web",
+    });
+}
+
+pub fn addServeWebStep(
+    owner: *std.Build,
+    b: *std.Build,
+    name: []const u8,
+    web_install: *std.Build.Step.InstallDir,
+    host: []const u8,
+    port: u16,
+) *std.Build.Step.Run {
+    const serve_web_exe = b.addExecutable(.{
+        .name = name,
+        .root_module = b.createModule(.{
+            .root_source_file = owner.path("tools/serve_web.zig"),
+            .target = b.resolveTargetQuery(.{}),
+            .optimize = .Debug,
+        }),
+    });
+    const serve_web_cmd = b.addRunArtifact(serve_web_exe);
+    serve_web_cmd.step.dependOn(&web_install.step);
+    serve_web_cmd.addArg(b.getInstallPath(.prefix, "web"));
+    serve_web_cmd.addArg(host);
+    serve_web_cmd.addArg(b.fmt("{d}", .{port}));
+    return serve_web_cmd;
+}
+
 /// Builds a `<exe.name>.app` directory under zig-out/bin/ with:
 ///   Contents/MacOS/<exe>                   -- patched load commands
 ///   Contents/Frameworks/libMoltenVK.dylib  -- id rewritten to @rpath
@@ -660,73 +1185,495 @@ fn pspEbootPipeline(b: *std.Build, exe: *std.Build.Step.Compile, psp_dep: *std.B
     return result;
 }
 
-/// Registers a shader pair for the game executable. Slang sources are
-/// compiled to SPIR-V (Vulkan) or GLSL (OpenGL) via slangc. On
-/// shaderless platforms (PSP), empty stubs are provided.
-///
-/// When called from Aether's own build, use `addShader(b, b, ...)`.
-/// From a downstream project:
-///
-///     Aether.addShader(ae_dep.builder, b, exe, config, "basic", .{ ... });
-///
-pub fn addShader(owner: *std.Build, b: *std.Build, exe: *std.Build.Step.Compile, config: Config, comptime name: []const u8, paths: ShaderPaths) void {
-    switch (config.gfx) {
-        .vulkan => {
-            const slangc = slangcPath(owner);
-            const vert = addSlangStep(b, slangc, &.{
-                "-target",  "spirv",  "-emit-spirv-directly", "-matrix-layout-column-major",
-                "-DVULKAN", "-entry", "vertexMain",           "-stage",
-                "vertex",
-            }, name ++ ".vert.spv", paths.slang);
-            const frag = addSlangStep(b, slangc, &.{
-                "-target",  "spirv",  "-emit-spirv-directly", "-matrix-layout-column-major",
-                "-DVULKAN", "-entry", "fragmentMain",         "-stage",
-                "fragment",
-            }, name ++ ".frag.spv", paths.slang);
-            if (vert) |v| exe.root_module.addAnonymousImport(name ++ "_vert", .{ .root_source_file = v });
-            if (frag) |f| exe.root_module.addAnonymousImport(name ++ "_frag", .{ .root_source_file = f });
-        },
-        .opengl => {
-            const slangc = slangcPath(owner);
-            const vert = addSlangStep(b, slangc, &.{
-                "-target",    "glsl",     "-matrix-layout-column-major",
-                "-profile",   "glsl_450", "-entry",
-                "vertexMain", "-stage",   "vertex",
-            }, name ++ ".vert.glsl", paths.slang);
-            const frag = addSlangStep(b, slangc, &.{
-                "-target",      "glsl",     "-matrix-layout-column-major",
-                "-profile",     "glsl_450", "-entry",
-                "fragmentMain", "-stage",   "fragment",
-            }, name ++ ".frag.glsl", paths.slang);
-            if (vert) |v| exe.root_module.addAnonymousImport(name ++ "_vert", .{ .root_source_file = v });
-            if (frag) |f| exe.root_module.addAnonymousImport(name ++ "_frag", .{ .root_source_file = f });
-        },
-        .default, .headless => {
-            // Provide empty stubs so @embedFile(name ++ "_vert") still compiles.
-            const empty = b.addWriteFiles();
-            const stub = empty.add(name ++ "_stub", "");
-            exe.root_module.addAnonymousImport(name ++ "_vert", .{
-                .root_source_file = stub,
-            });
-            exe.root_module.addAnonymousImport(name ++ "_frag", .{
-                .root_source_file = stub,
-            });
-        },
+fn patch3dsGeneratedC(b: *std.Build, exe: *std.Build.Step.Compile) std.Build.LazyPath {
+    const patch = b.addSystemCommand(&.{
+        "perl", "-e",
+        \\local $/;
+        \\my $src = <>;
+        \\my %align16 = ();
+        \\while ($src =~ /zig_static_assert\(_Alignof \(struct ([A-Za-z0-9_]+)\) == 16,/g) {
+        \\    $align16{$1} = 1;
+        \\}
+        \\my $pending = "";
+        \\for my $line (split /(?<=\n)/, $src) {
+        \\    if ($pending ne "") {
+        \\        if ($line =~ s/^};/} __attribute__((aligned(16)));/) {
+        \\            $pending = "";
+        \\        }
+        \\    } elsif ($line =~ /^struct\s+([A-Za-z0-9_]+)\s*\{/) {
+        \\        my $name = $1;
+        \\        if ($align16{$name}) {
+        \\            if ($line !~ s/\};/} __attribute__((aligned(16)));/) {
+        \\                $pending = $name;
+        \\            }
+        \\        }
+        \\    }
+        \\    print $line;
+        \\}
+    });
+    patch.addArtifactArg(exe);
+    return patch.captureStdOut(.{ .basename = b.fmt("{s}.3ds.c", .{exe.name}) });
+}
+
+fn cBackendOptimizeMode(exe: *std.Build.Step.Compile) std.builtin.OptimizeMode {
+    return exe.root_module.optimize orelse .Debug;
+}
+
+fn cBackendGccOptimizeArg(optimize: std.builtin.OptimizeMode) []const u8 {
+    return switch (optimize) {
+        .Debug => "-O0",
+        .ReleaseSafe, .ReleaseFast => "-O2",
+        .ReleaseSmall => "-Os",
+    };
+}
+
+fn cBackendGccDebugArg(optimize: std.builtin.OptimizeMode) []const u8 {
+    return if (optimize == .Debug or optimize == .ReleaseSafe) "-g" else "-g0";
+}
+
+/// Compiles the zig-emitted C with devkitARM, links against libctru, and
+/// packages the ELF (plus an SMDH and optional RomFS) into a `.3dsx`
+/// homebrew bundle. Mirrors `pspEbootPipeline` for the PSP toolchain.
+fn threedsxPipeline(b: *std.Build, exe: *std.Build.Step.Compile, opts: ExportOptions) void {
+    // Derive a sibling target for compiler_rt: same cpu/abi/endianness
+    // as the game (so the calling conventions and float ABI match
+    // libctru), but os=freestanding (sidesteps the 3DS-specific posix
+    // dependencies in std) and the default object format (so this
+    // module compiles natively to an ELF object the gcc driver can
+    // consume, rather than .c). devkitARM's libgcc.a doesn't ship the
+    // 128-bit-int compiler-rt entry points (`__multi3`/`__divti3`/etc.),
+    // so we provide them ourselves from zig's compiler_rt.
+    const game_target = exe.root_module.resolved_target.?;
+    var crt_query = game_target.query;
+    crt_query.os_tag = .freestanding;
+    crt_query.ofmt = null;
+    // Explicitly pin the cpu model to whatever the game target
+    // resolved to (arm.mpcore for the 3DS). Without this, swapping
+    // os_tag to .freestanding loses the os-derived cpu choice and
+    // zig falls back to a generic baseline that emits ARMv6T2+
+    // instructions (e.g. `mls`) the ARMv6K MPCore doesn't decode —
+    // crashes show up as "undefined instruction" in compiler_rt
+    // helpers like `__udivmodsi4`.
+    crt_query.cpu_model = .{ .explicit = game_target.result.cpu.model };
+    const crt_target = b.resolveTargetQuery(crt_query);
+
+    const compiler_rt_path = b.pathJoin(&.{
+        b.graph.zig_lib_directory.path orelse ".",
+        "compiler_rt.zig",
+    });
+    const crt_obj = b.addObject(.{
+        .name = "aether_3ds_compiler_rt",
+        .root_module = b.createModule(.{
+            .root_source_file = .{ .cwd_relative = compiler_rt_path },
+            .target = crt_target,
+            .optimize = .ReleaseSmall,
+            .strip = true,
+        }),
+    });
+
+    const dkp = devkitProPath(b);
+
+    // Strip the libc-overlap symbols from the compiler_rt object.
+    // zig's compiler_rt re-exports `memset`/`memcpy`/`memmove` and
+    // their `__aeabi_*` shims as WEAK; the `__aeabi_memset` and
+    // `memset` versions form a recursive `bl` cycle that blows the
+    // stack on 32-bit ARM. Newlib has real implementations, but the
+    // linker won't reach for them while compiler_rt's weak version
+    // already resolves the reference. `--strip-symbol` drops the
+    // exports so the references stay unresolved at compiler_rt and
+    // the linker pulls newlib's strong implementations from libc.a.
+    const strip_libc = b.addSystemCommand(&.{
+        b.pathJoin(&.{ dkp, "devkitARM/bin/arm-none-eabi-objcopy" }),
+        "--localize-symbol=memset",
+        "--localize-symbol=memcpy",
+        "--localize-symbol=memmove",
+        "--localize-symbol=memcmp",
+        "--localize-symbol=__memset",
+        "--localize-symbol=__memcpy",
+        "--localize-symbol=__memmove",
+        "--localize-symbol=__memcpy_chk",
+        "--localize-symbol=__aeabi_memset",
+        "--localize-symbol=__aeabi_memset4",
+        "--localize-symbol=__aeabi_memset8",
+        "--localize-symbol=__aeabi_memcpy",
+        "--localize-symbol=__aeabi_memcpy4",
+        "--localize-symbol=__aeabi_memcpy8",
+        "--localize-symbol=__aeabi_memmove",
+        "--localize-symbol=__aeabi_memmove4",
+        "--localize-symbol=__aeabi_memmove8",
+        "--localize-symbol=strlen",
+        "--localize-symbol=bcmp",
+    });
+    strip_libc.addArtifactArg(crt_obj);
+    const crt_clean = strip_libc.addOutputFileArg("aether_3ds_compiler_rt.o");
+    const gcc = b.pathJoin(&.{ dkp, "devkitARM/bin/arm-none-eabi-gcc" });
+    const tool_3dsx = b.pathJoin(&.{ dkp, "tools/bin/3dsxtool" });
+    const tool_smdh = b.pathJoin(&.{ dkp, "tools/bin/smdhtool" });
+    const ctru_inc = b.pathJoin(&.{ dkp, "libctru/include" });
+    const ctru_lib = b.pathJoin(&.{ dkp, "libctru/lib" });
+    const default_icon = b.pathJoin(&.{ dkp, "libctru/default_icon.png" });
+    const zig_h_src = b.pathJoin(&.{ b.graph.zig_lib_directory.path orelse ".", "zig.h" });
+
+    // zig.h hardcodes `zig_align(16)` for its `zig_i128`/`zig_u128`
+    // struct fallback (used when `__int128` isn't supported by the C
+    // compiler -- gcc on 32-bit ARM is one such target). Zig's ARM
+    // layout uses 8-byte alignment for those integer types, while f128
+    // still needs 16-byte alignment. Patch only the integer fallback
+    // typedefs, then route unsupported ARM f128 through zig.h's vector
+    // fallback with explicit 16-byte alignment.
+    const patch = b.addSystemCommand(&.{"perl"});
+    patch.addArgs(&.{
+        "-0pe",
+        \\s/typedef struct \{ zig_align\(16\) uint64_t lo; uint64_t hi; \} zig_u128;/typedef struct { zig_align(8) uint64_t lo; uint64_t hi; } zig_u128;/g;
+        \\s/typedef struct \{ zig_align\(16\) uint64_t lo;  int64_t hi; \} zig_i128;/typedef struct { zig_align(8) uint64_t lo;  int64_t hi; } zig_i128;/g;
+        \\s/typedef struct \{ zig_align\(16\) uint64_t hi; uint64_t lo; \} zig_u128;/typedef struct { zig_align(8) uint64_t hi; uint64_t lo; } zig_u128;/g;
+        \\s/typedef struct \{ zig_align\(16\)  int64_t hi; uint64_t lo; \} zig_i128;/typedef struct { zig_align(8)  int64_t hi; uint64_t lo; } zig_i128;/g;
+        \\s/#if defined\(zig_darwin\) \|\| defined\(zig_aarch64\)/#if defined(zig_darwin) || defined(zig_aarch64) || defined(zig_arm)/;
+        \\s/typedef __attribute__\(\(__vector_size__\(2 \* sizeof\(uint64_t\)\)\)\) uint64_t zig_v2u64;/typedef __attribute__((__vector_size__(2 * sizeof(uint64_t)), aligned(16))) uint64_t zig_v2u64;/;
+    });
+    patch.addFileArg(.{ .cwd_relative = zig_h_src });
+    const patched_zig_h = patch.captureStdOut(.{ .basename = "zig.h" });
+
+    const include_wf = b.addWriteFiles();
+    _ = include_wf.addCopyFile(patched_zig_h, "zig.h");
+
+    const shim_wf = b.addWriteFiles();
+    const exception_shim = shim_wf.add("aether_3ds_exception.c",
+        \\#include <3ds.h>
+        \\
+        \\extern void aether3dsExceptionHandler(ERRF_ExceptionInfo *excep, CpuRegisters *regs);
+        \\
+        \\void aether3dsInstallExceptionHandler(void *stack_top) {
+        \\    threadOnException(aether3dsExceptionHandler, stack_top, WRITE_DATA_TO_HANDLER_STACK);
+        \\}
+        \\
+    );
+
+    // Small linker script fragment providing accurate .text bounds as
+    // link-time constants. This lets the panic unwinder in services.zig
+    // use real section start/end (via ADDR/SIZEOF) instead of any
+    // hardcoded/sketchy ranges for isLikelyReturnAddress text checks.
+    const syms_wf = b.addWriteFiles();
+    const text_syms_ld = syms_wf.add("aether_3ds_text_syms.ld",
+        \\/* Zig C backend (for 3DS ofmt=c) mangles extern names with zig_e_ prefix. */
+        \\/* Provide both for the isLikelyReturnAddress range checks + any debug. */
+        \\zig_e___text_start = ADDR(.text);
+        \\zig_e___text_end = ADDR(.text) + SIZEOF(.text);
+        \\__text_start = zig_e___text_start;
+        \\__text_end = zig_e___text_end;
+    );
+
+    // Standard 3DS arch flags from devkitPro's template Makefile.
+    const arch = [_][]const u8{
+        "-march=armv6k",           "-mtune=mpcore", "-mfloat-abi=hard", "-mtp=soft",
+        // Keep frame pointers so manual r11-based stack walk in panic handler
+        // can produce useful unwind (otherwise gcc -O* uses r11 as temp and
+        // chains are absent or clobbered, leading to data aborts in the walker).
+        "-fno-omit-frame-pointer",
+    };
+
+    // Single-shot compile + link via the gcc driver. 3dsx.specs pulls
+    // in `_3dsx_crt0` (which calls our exported `main`) and the 3DSX
+    // linker script. We also supply a tiny -T fragment for accurate
+    // __text_* symbols (see text_syms_ld above).
+    const exe_optimize = cBackendOptimizeMode(exe);
+
+    const link = b.addSystemCommand(&.{gcc});
+    link.addArgs(&arch);
+    link.addArgs(&.{
+        "-mword-relocations",
+        "-ffunction-sections",
+        "-D_FORTIFY_SOURCE=0",
+        "-D__3DS__",
+        "-DARM11",
+        cBackendGccOptimizeArg(exe_optimize),
+        cBackendGccDebugArg(exe_optimize),
+        "-specs=3dsx.specs",
+        "-T",
+    });
+    link.addFileArg(text_syms_ld);
+    link.addArgs(&.{
+        "-Wl,--wrap=threadCreate",
+        "-Wl,--no-warn-execstack",
+    });
+    link.addArgs(&.{
+        // Pin the C standard to C11. zig.h picks `[[noreturn]]` under
+        // C23 but emits it in attribute-list position that gcc rejects;
+        // C11's `_Noreturn` is what zig's emitter actually targets.
+        "-std=gnu11",
+    });
+    link.addArgs(&.{
+        // zig's -ofmt=c emitter treats `uintptr_t` and `uint32_t` as
+        // interchangeable on 32-bit ARM (they ARE the same width) but
+        // gcc 14+ promotes the resulting pointer-type mismatch from a
+        // warning to an error. Demote it and a couple of related
+        // chatters; we don't author this C and there's nothing
+        // actionable in the warnings.
+        "-fno-strict-aliasing",
+        "-Wno-incompatible-pointer-types",
+        "-Wno-int-conversion",
+        "-Wno-builtin-declaration-mismatch",
+    });
+    link.addArg(b.fmt("-I{s}", .{ctru_inc}));
+    link.addPrefixedDirectoryArg("-I", include_wf.getDirectory());
+    link.addArg("-x");
+    link.addArg("c");
+    link.addFileArg(patch3dsGeneratedC(b, exe));
+    link.addFileArg(exception_shim);
+    // Reset language so gcc treats subsequent inputs by extension; the
+    // compiler_rt object is ELF arm and `-x c` would mis-parse it.
+    link.addArg("-x");
+    link.addArg("none");
+    link.addFileArg(crt_clean);
+    link.addArg(b.fmt("-L{s}", .{ctru_lib}));
+    link.addArgs(&.{ "-lctru", "-lm" });
+    link.addArg("-o");
+    const elf = link.addOutputFileArg(b.fmt("{s}.elf", .{exe.name}));
+
+    // SMDH metadata (HOME-menu name, description, author, icon).
+    const smdh_run = b.addSystemCommand(&.{ tool_smdh, "--create" });
+    smdh_run.addArg(if (opts.title.len > 0) opts.title else exe.name);
+    smdh_run.addArg(if (opts.smdh_long_description.len > 0)
+        opts.smdh_long_description
+    else
+        "Built with Aether");
+    smdh_run.addArg(opts.smdh_author);
+    if (opts.smdh_icon) |icon|
+        smdh_run.addFileArg(icon)
+    else
+        smdh_run.addArg(default_icon);
+    const smdh = smdh_run.addOutputFileArg(b.fmt("{s}.smdh", .{exe.name}));
+
+    // ELF -> 3DSX. The smdh and (optional) romfs ride in via the
+    // `--smdh=` / `--romfs=` flag-form args.
+    const pack = b.addSystemCommand(&.{tool_3dsx});
+    pack.addFileArg(elf);
+    const threedsx = pack.addOutputFileArg(b.fmt("{s}.3dsx", .{exe.name}));
+    pack.addPrefixedFileArg("--smdh=", smdh);
+    if (opts.romfs) |r| pack.addPrefixedDirectoryArg("--romfs=", r);
+
+    if (opts.output_dir) |dir| {
+        const alloc = b.allocator;
+        b.getInstallStep().dependOn(&b.addInstallBinFile(
+            threedsx,
+            std.mem.concat(alloc, u8, &.{ dir, "/", exe.name, ".3dsx" }) catch @panic("OOM"),
+        ).step);
+        b.getInstallStep().dependOn(&b.addInstallBinFile(
+            elf,
+            std.mem.concat(alloc, u8, &.{ dir, "/", exe.name, ".elf" }) catch @panic("OOM"),
+        ).step);
+    } else {
+        b.getInstallStep().dependOn(&b.addInstallBinFile(
+            threedsx,
+            b.fmt("{s}.3dsx", .{exe.name}),
+        ).step);
+    }
+}
+
+/// Compiles the zig-emitted C with devkitA64, links against libnx, and
+/// packages the ELF (plus a NACP and optional RomFS) into a `.nro`
+/// homebrew bundle. Mirrors `threedsxPipeline` for the Switch toolchain.
+fn switchNroPipeline(b: *std.Build, exe: *std.Build.Step.Compile, opts: ExportOptions) void {
+    // aarch64 GCC supports __int128 natively, so we don't need the
+    // `zig.h` align(16) -> align(8) patch the 3DS pipeline applies.
+    //
+    // We do still need a compiler_rt object: zig.h calls helpers like
+    // `__floatunsisf` / `__floatundidf` / `__floatdisf` unconditionally,
+    // but devkitA64's libgcc doesn't ship them — gcc on aarch64 with
+    // hardware FP inlines these casts as `ucvtf`/`scvtf`, so the
+    // helpers are dead code in normal compilations. Zig's emitted C
+    // takes the slow path, so we drop in zig's own compiler_rt to
+    // satisfy the references. Like the 3DS pipeline we localize
+    // symbols that overlap newlib (memset/memcpy/...) so the linker
+    // pulls newlib's strong implementations.
+    const game_target = exe.root_module.resolved_target.?;
+    var crt_query = game_target.query;
+    crt_query.os_tag = .freestanding;
+    crt_query.ofmt = null;
+    crt_query.cpu_model = .{ .explicit = game_target.result.cpu.model };
+    const crt_target = b.resolveTargetQuery(crt_query);
+
+    const compiler_rt_path = b.pathJoin(&.{
+        b.graph.zig_lib_directory.path orelse ".",
+        "compiler_rt.zig",
+    });
+    const crt_obj = b.addObject(.{
+        .name = "aether_switch_compiler_rt",
+        .root_module = b.createModule(.{
+            .root_source_file = .{ .cwd_relative = compiler_rt_path },
+            .target = crt_target,
+            .optimize = .ReleaseSmall,
+            .strip = true,
+            // Switch homebrew uses libnx's switch.specs which links
+            // with `-z text`. PIC is mandatory for any object that
+            // ends up in the read-only .text segment, otherwise the
+            // linker rejects the dynamic absolute relocations.
+            .pic = true,
+        }),
+    });
+
+    const dkp = devkitProPath(b);
+
+    const strip_libc = b.addSystemCommand(&.{
+        b.pathJoin(&.{ dkp, "devkitA64/bin/aarch64-none-elf-objcopy" }),
+        "--localize-symbol=memset",
+        "--localize-symbol=memcpy",
+        "--localize-symbol=memmove",
+        "--localize-symbol=memcmp",
+        "--localize-symbol=strlen",
+        "--localize-symbol=bcmp",
+    });
+    strip_libc.addArtifactArg(crt_obj);
+    const crt_clean = strip_libc.addOutputFileArg("aether_switch_compiler_rt.o");
+    const gcc = b.pathJoin(&.{ dkp, "devkitA64/bin/aarch64-none-elf-gcc" });
+    const tool_elf2nro = b.pathJoin(&.{ dkp, "tools/bin/elf2nro" });
+    const tool_nacp = b.pathJoin(&.{ dkp, "tools/bin/nacptool" });
+    const libnx_inc = b.pathJoin(&.{ dkp, "libnx/include" });
+    const libnx_lib = b.pathJoin(&.{ dkp, "libnx/lib" });
+    const libnx_specs = b.pathJoin(&.{ dkp, "libnx/switch.specs" });
+    const default_icon = b.pathJoin(&.{ dkp, "libnx/default_icon.jpg" });
+
+    const syms_wf = b.addWriteFiles();
+    const text_syms_ld = syms_wf.add("aether_switch_text_syms.ld",
+        \\/* Zig C backend (for Switch ofmt=c) mangles extern names with zig_e_ prefix. */
+        \\zig_e___text_start = ADDR(.text);
+        \\zig_e___text_end = ADDR(.text) + SIZEOF(.text);
+        \\__text_start = zig_e___text_start;
+        \\__text_end = zig_e___text_end;
+    );
+
+    // Standard Switch arch flags from devkitPro's switch_rules /
+    // example Makefiles. `-mtp=soft` matches what libnx is built
+    // against; mismatching the TLS access mode crashes on the first
+    // thread-local read.
+    const arch = [_][]const u8{
+        "-march=armv8-a+crc+crypto", "-mtune=cortex-a57", "-mtp=soft", "-fPIE", "-fno-omit-frame-pointer",
+    };
+
+    const exe_optimize = cBackendOptimizeMode(exe);
+
+    const link = b.addSystemCommand(&.{gcc});
+    link.addArgs(&arch);
+    link.addArgs(&.{
+        "-ffunction-sections",
+        "-fdata-sections",
+        "-D_FORTIFY_SOURCE=0",
+        "-D__SWITCH__",
+        cBackendGccOptimizeArg(exe_optimize),
+        cBackendGccDebugArg(exe_optimize),
+        b.fmt("-specs={s}", .{libnx_specs}),
+        "-T",
+        // Pin the C standard to C11 (zig.h targets `_Noreturn`, not
+        // C23's `[[noreturn]]`).
+    });
+    link.addFileArg(text_syms_ld);
+    link.addArgs(&.{
+        "-std=gnu11",
+        // zig's -ofmt=c emitter has known pointer/int-conversion
+        // mismatches that gcc 14+ promotes to errors. We don't author
+        // the C, so demote them.
+        "-fno-strict-aliasing",
+        "-Wno-incompatible-pointer-types",
+        "-Wno-int-conversion",
+        "-Wno-builtin-declaration-mismatch",
+    });
+    link.addArg(b.fmt("-I{s}", .{libnx_inc}));
+    // zig's emitted C `#include "zig.h"`. The header lives in zig's
+    // own lib directory; point gcc at it. aarch64 GCC's __int128
+    // alignment matches zig's, so no patching is needed (unlike 3DS).
+    link.addArg(b.fmt("-I{s}", .{b.graph.zig_lib_directory.path orelse "."}));
+    link.addArg("-x");
+    link.addArg("c");
+    link.addArtifactArg(exe);
+    link.addArg("-x");
+    link.addArg("none");
+    link.addFileArg(crt_clean);
+    link.addArg(b.fmt("-L{s}", .{libnx_lib}));
+    link.addArgs(&.{ "-ldeko3d", "-lnx", "-lm" });
+    link.addArg("-o");
+    const elf = link.addOutputFileArg(b.fmt("{s}.elf", .{exe.name}));
+
+    // NACP metadata (HOME-menu title, author, version).
+    const nacp_run = b.addSystemCommand(&.{ tool_nacp, "--create" });
+    nacp_run.addArg(if (opts.title.len > 0) opts.title else exe.name);
+    nacp_run.addArg(if (opts.switch_author.len > 0) opts.switch_author else "Aether");
+    nacp_run.addArg(if (opts.switch_version.len > 0) opts.switch_version else "1.0.0");
+    const nacp = nacp_run.addOutputFileArg(b.fmt("{s}.nacp", .{exe.name}));
+
+    // ELF -> NRO. The icon, NACP, and (optional) romfs ride in via
+    // flag-form args.
+    const pack = b.addSystemCommand(&.{tool_elf2nro});
+    pack.addFileArg(elf);
+    const nro = pack.addOutputFileArg(b.fmt("{s}.nro", .{exe.name}));
+    if (opts.switch_icon) |icon|
+        pack.addPrefixedFileArg("--icon=", icon)
+    else
+        pack.addArg(b.fmt("--icon={s}", .{default_icon}));
+    pack.addPrefixedFileArg("--nacp=", nacp);
+    if (opts.switch_romfs) |r| pack.addPrefixedDirectoryArg("--romfsdir=", r);
+
+    if (opts.output_dir) |dir| {
+        const alloc = b.allocator;
+        b.getInstallStep().dependOn(&b.addInstallBinFile(
+            nro,
+            std.mem.concat(alloc, u8, &.{ dir, "/", exe.name, ".nro" }) catch @panic("OOM"),
+        ).step);
+        b.getInstallStep().dependOn(&b.addInstallBinFile(
+            elf,
+            std.mem.concat(alloc, u8, &.{ dir, "/", exe.name, ".elf" }) catch @panic("OOM"),
+        ).step);
+    } else {
+        b.getInstallStep().dependOn(&b.addInstallBinFile(
+            nro,
+            b.fmt("{s}.nro", .{exe.name}),
+        ).step);
     }
 }
 
 // --- Aether's own build (test app + engine tests) ---
 
+fn makeResourceManifest(b: *std.Build, resource_dir_path: []const u8) []const u8 {
+    const io = b.graph.io;
+    const full_resource_dir_path = b.pathFromRoot(resource_dir_path);
+    var dir = std.Io.Dir.cwd().openDir(io, full_resource_dir_path, .{ .iterate = true }) catch |err| {
+        std.debug.panic("unable to open web resource directory '{s}': {s}", .{ resource_dir_path, @errorName(err) });
+    };
+    defer dir.close(io);
+
+    var walker = dir.walk(b.allocator) catch @panic("OOM");
+    defer walker.deinit();
+
+    var manifest: std.ArrayList(u8) = .empty;
+    while (walker.next(io) catch |err| {
+        std.debug.panic("unable to walk web resource directory '{s}': {s}", .{ resource_dir_path, @errorName(err) });
+    }) |entry| {
+        if (entry.kind != .file) continue;
+        if (std.mem.eql(u8, entry.path, "resources.manifest")) continue;
+        manifest.appendSlice(b.allocator, entry.path) catch @panic("OOM");
+        manifest.append(b.allocator, '\n') catch @panic("OOM");
+    }
+    return manifest.toOwnedSlice(b.allocator) catch @panic("OOM");
+}
+
 pub fn build(b: *std.Build) void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
+    const threeds_heap_mib = b.option(u32, "3ds-heap-mib", "3DS: regular libctru/newlib heap size in MiB (default: 4)");
+    const threeds_linear_heap_mib = b.option(u32, "3ds-linear-heap-mib", "3DS: linear heap size in MiB (default: 60)");
+    const web_resources_path = b.option([]const u8, "web-resources", "WASM/browser: directory to copy into zig-out/web and preload via resources.manifest (default: test)") orelse "test";
+    const web_host = b.option([]const u8, "web-host", "serve-web: bind host (default: 127.0.0.1)") orelse "127.0.0.1";
+    const web_port = b.option(u16, "web-port", "serve-web: bind port (default: 8080)") orelse 8080;
 
     const overrides: Config.Overrides = .{
         .gfx = b.option(Gfx, "gfx", "Graphics backend override (default: auto-detect from target)"),
-        .audio = b.option(Audio, "audio", "Audio backend override (default: .none on macOS, .default elsewhere)"),
+        .audio = b.option(Audio, "audio", "Audio backend override (default: platform default)"),
         .psp_display_mode = b.option(PspDisplayMode, "psp-display", "PSP display mode: rgba8888 (32-bit, default) or rgb565 (16-bit)"),
         .psp_mipmaps = b.option(bool, "psp-mipmaps", "PSP: generate mip levels for VRAM-resident textures (default: false)"),
+        .nintendo_3ds_heap_size = if (threeds_heap_mib) |mib| mib * 1024 * 1024 else null,
+        .nintendo_3ds_linear_heap_size = if (threeds_linear_heap_mib) |mib| mib * 1024 * 1024 else null,
         .use_cwd = b.option(bool, "use-cwd", "Force resources+data dirs to CWD (debug/CI convenience; default: false)"),
+        .flush_logs = b.option(bool, "flush-logs", "Flush aether.log after every log message (debugging hard hangs; default: false)"),
+        .nintendo_switch = b.option(bool, "nintendo-switch", "Build for Nintendo Switch (requires -Dtarget=aarch64-freestanding-none and devkitA64/libnx)"),
     };
 
     const config = Config.resolve(target, overrides);
@@ -739,26 +1686,107 @@ pub fn build(b: *std.Build) void {
         .overrides = overrides,
     });
 
-    addShader(b, b, exe, config, "basic", .{
-        .slang = b.path("test/shaders/basic.slang"),
-    });
+    const nintendo_romfs = b.addWriteFiles();
+    _ = nintendo_romfs.addCopyFile(b.path("test/test.png"), "test.png");
+    _ = nintendo_romfs.addCopyFile(b.path("test/calm1.wav"), "calm1.wav");
+    _ = nintendo_romfs.addCopyFile(b.path("test/grass1.wav"), "grass1.wav");
 
     exportArtifact(b, b, exe, config, .{
         .title = "Aether",
-        .output_dir = "Aether-PSP",
+        .output_dir = switch (config.platform) {
+            .psp => "Aether-PSP",
+            .nintendo_3ds => "Aether-3DS",
+            .nintendo_switch => "Aether-Switch",
+            else => null,
+        },
+        .smdh_long_description = "Aether engine test app",
+        .smdh_author = "Aether",
+        .resources = &.{
+            .{ .path = b.path("test/test.png"), .name = "test.png" },
+            .{ .path = b.path("test/calm1.wav"), .name = "calm1.wav" },
+            .{ .path = b.path("test/grass1.wav"), .name = "grass1.wav" },
+        },
+        .romfs = if (config.platform == .nintendo_3ds) nintendo_romfs.getDirectory() else null,
+        .switch_romfs = if (config.platform == .nintendo_switch) nintendo_romfs.getDirectory() else null,
     });
 
+    const web_target = webTarget(b);
+    const web_overrides: Config.Overrides = .{
+        .gfx = .webgl,
+        .use_cwd = true,
+    };
+    const web_exe = addGame(b, b, .{
+        .name = "Aether",
+        .root_source_file = b.path("test/web_main.zig"),
+        .target = web_target,
+        .optimize = optimize,
+        .overrides = web_overrides,
+    });
+    const web_install = addWebBundle(b, b, web_exe, .{
+        .web_resources = b.path(web_resources_path),
+        .web_resource_manifest = makeResourceManifest(b, web_resources_path),
+    });
+
+    const web_step = b.step("web", "Build the browser-playable WASM site in zig-out/web");
+    web_step.dependOn(&web_install.step);
+
+    const serve_web_cmd = addServeWebStep(b, b, "aether-serve-web", web_install, web_host, web_port);
+
+    const serve_web_step = b.step("serve-web", "Serve zig-out/web with WASM MIME and COOP/COEP headers");
+    serve_web_step.dependOn(&serve_web_cmd.step);
+
     const run_step = b.step("run", "Run the app");
-    const run_cmd = b.addRunArtifact(exe);
-    run_step.dependOn(&run_cmd.step);
+    if (config.platform == .nintendo_3ds) {
+        // 3DS can't run natively on the host. The 3DS-side homebrew
+        // launcher listens for incoming .3dsx pushes on port 17491;
+        // `3dslink` finds it via mDNS or accepts an explicit IP.
+        const link_cmd = add3dslink(b, b.getInstallPath(.bin, "Aether-3DS/Aether.3dsx"));
+
+        const link_step = b.step("3dslink", "Push the 3dsx to a networked 3DS via 3dslink");
+        link_step.dependOn(&link_cmd.step);
+
+        // `zig build run` aliases to 3dslink for 3DS so the same
+        // command works across host/PSP/3DS workflows.
+        run_step.dependOn(&link_cmd.step);
+    } else if (config.platform == .nintendo_switch) {
+        // Switch can't run natively on the host. nxlink pushes the
+        // .nro to nx-hbloader on a networked Switch (mDNS by default,
+        // explicit IP via -a).
+        const dkp = devkitProPath(b);
+        const link_cmd = b.addSystemCommand(&.{b.pathJoin(&.{ dkp, "tools/bin/nxlink" })});
+        if (b.option([]const u8, "nxlink-address", "Switch: target IP for nxlink push (default: mDNS auto-discover)")) |ip| {
+            link_cmd.addArgs(&.{ "-a", ip });
+        }
+        if (b.option(u32, "nxlink-retries", "Switch: nxlink retry count (default: 10)")) |n| {
+            link_cmd.addArgs(&.{ "-r", b.fmt("{d}", .{n}) });
+        }
+        if (b.option(bool, "nxlink-server", "Switch: pass -s so nxlink stays listening after upload (relays stdout/stderr from nro)") orelse false) {
+            link_cmd.addArg("-s");
+        }
+        link_cmd.addArg(b.getInstallPath(.bin, "Aether-Switch/Aether.nro"));
+        link_cmd.step.dependOn(b.getInstallStep());
+        if (b.args) |args| {
+            // nxlink takes nro args after a `--args` separator.
+            link_cmd.addArg("--args");
+            link_cmd.addArgs(args);
+        }
+
+        const link_step = b.step("nxlink", "Push the nro to a networked Switch via nxlink");
+        link_step.dependOn(&link_cmd.step);
 
-    run_cmd.step.dependOn(b.getInstallStep());
-    if (b.args) |args| {
-        run_cmd.addArgs(args);
+        // `zig build run` aliases to nxlink for Switch so the same
+        // command works across host/PSP/3DS/Switch workflows.
+        run_step.dependOn(&link_cmd.step);
+    } else {
+        const run_cmd = b.addRunArtifact(exe);
+        run_cmd.step.dependOn(b.getInstallStep());
+        if (b.args) |args| run_cmd.addArgs(args);
+        run_step.dependOn(&run_cmd.step);
     }
 
-    // Engine unit tests (desktop only)
-    if (config.platform != .psp) {
+    // Engine unit tests (desktop only — PSP/3DS/Switch pull in symbols
+    // that can't be linked or analyzed under the test runner)
+    if (config.platform != .psp and config.platform != .nintendo_3ds and config.platform != .nintendo_switch) {
         const mod_tests = b.addTest(.{
             .root_module = exe.root_module.import_table.get("aether").?,
         });
diff --git a/build.zig.zon b/build.zig.zon
index c6b279c..5c1b89c 100644
--- a/build.zig.zon
+++ b/build.zig.zon
@@ -76,15 +76,20 @@
             .url = "git+https://github.com/Snektron/vulkan-zig#3adbeefbc833c12656791d304b37a6315b357745",
             .hash = "vulkan-0.0.0-r7YtxyBsAwD35FvkFhT2xruTNdCByD3TtGw44XWtfun8",
         },
-        .zaudio = .{
-            .url = "git+https://github.com/IridescentRose/zaudio?ref=update_zig_16#54e45e002005448623bff0ba06baa919bd036e03",
-            .hash = "zaudio-0.11.0-dev-_M-91l8yQQDTAb3Hk8V-lyP88DGgLzS9QNUkmpbCN_PK",
-        },
         .system_sdk = .{
             .url = "https://github.com/zig-gamedev/system_sdk/archive/c0dbf11cdc17da5904ea8a17eadc54dee26567ec.tar.gz",
             .hash = "system_sdk-0.3.0-dev-alwUNnYaaAJAtIdE2fg4NQfDqEKs7QCXy_qYukAOBfmF",
             .lazy = true,
         },
+        .sdl3 = .{
+            .url = "git+https://codeberg.org/7Games/zig-sdl3?ref=master#40c2e4b579aa556db37a502c936426aa1c8b5c95",
+            .hash = "sdl3-0.2.0-NmT1Q0mFJwBi9kZmArzh2rfJ_mFshydV0zPGULVlpACc",
+            .lazy = true,
+        },
+        .zsflt = .{
+            .url = "git+https://github.com/GasInfinity/zsflt.git#1929cbae9d41c7e1178e494e42aa7b349a68cd8a",
+            .hash = "zsflt-0.0.1-_pCibQ4wAABnfZskVOk2Y14F056VNJtuqVpAEzUNBGfl",
+        },
     },
     .paths = .{
         "build.zig",
diff --git a/src/audio/audio.zig b/src/audio/audio.zig
index 98cd9c2..8892733 100644
--- a/src/audio/audio.zig
+++ b/src/audio/audio.zig
@@ -1,6 +1,7 @@
 const std = @import("std");
 const Vec3 = @import("../math/math.zig").Vec3;
 const platform_audio = @import("../platform/audio.zig");
+const options = @import("options");
 
 // -- types -------------------------------------------------------------------
 
@@ -13,6 +14,7 @@ pub const mixer_mod = @import("mixer.zig");
 pub const SoundHandle = mixer_mod.SoundHandle;
 pub const PlayOptions = mixer_mod.PlayOptions;
 pub const Priority = mixer_mod.Priority;
+pub const enabled = options.config.audio != .none;
 
 // -- forwarding to the instantiated mixer ------------------------------------
 
diff --git a/src/core/input/input.zig b/src/core/input/input.zig
index 9d23303..978655a 100644
--- a/src/core/input/input.zig
+++ b/src/core/input/input.zig
@@ -277,7 +277,7 @@ pub fn register_action_set(name: []const u8) !ActionSetHandle {
 
 pub fn add_action(set: ActionSetHandle, name: []const u8, kind: ActionKind) !void {
     const s = set_ptr(set) orelse return error.UnknownActionSet;
-    if (s.actions.contains(name)) return error.ActionAlreadyExists;
+    if (action_ptr(s, name) != null) return error.ActionAlreadyExists;
     try s.actions.put(alloc, name, .{
         .kind = kind,
         .bindings = .empty,
@@ -288,7 +288,7 @@ pub fn add_action(set: ActionSetHandle, name: []const u8, kind: ActionKind) !voi
 
 pub fn bind_action(set: ActionSetHandle, action_name: []const u8, b: Binding) !void {
     const s = set_ptr(set) orelse return error.UnknownActionSet;
-    const a = s.actions.getPtr(action_name) orelse return error.ActionNotFound;
+    const a = action_ptr(s, action_name) orelse return error.ActionNotFound;
     if (a.kind == .vector2 and b.component == .none) return error.Vector2BindingNeedsComponent;
     try a.bindings.append(alloc, b);
 }
@@ -310,7 +310,7 @@ pub fn get_action(name: []const u8) ?ActionValue {
     const top = stack.top() orelse return null;
     const s = set_ptr(top.actions) orelse return null;
     if (!s.installed) return null;
-    const a = s.actions.getPtr(name) orelse return null;
+    const a = action_ptr(s, name) orelse return null;
     return a.current_value;
 }
 
@@ -479,6 +479,16 @@ fn set_ptr_or_null(handle: ActionSetHandle) ?*ActionSet {
     return set_ptr(handle);
 }
 
+fn action_ptr(set: *ActionSet, name: []const u8) ?*Action {
+    if (set.actions.getPtr(name)) |action| return action;
+
+    var it = set.actions.iterator();
+    while (it.next()) |entry| {
+        if (std.mem.eql(u8, entry.key_ptr.*, name)) return entry.value_ptr;
+    }
+    return null;
+}
+
 fn route_text_to_session(text: []const u8) void {
     const top = stack.top() orelse return;
     if (!top.consumes_text) return;
diff --git a/src/core/paths.zig b/src/core/paths.zig
index 79c488d..96538a1 100644
--- a/src/core/paths.zig
+++ b/src/core/paths.zig
@@ -24,10 +24,13 @@
 //! per project style guide they go through `std.Io` / `std.process`.
 
 const std = @import("std");
-const builtin = @import("builtin");
 const options = @import("options");
 
 const Io = std.Io;
+const NintendoIo = if (options.config.platform == .nintendo_3ds or options.config.platform == .nintendo_switch)
+    @import("../platform/c_io.zig")
+else
+    void;
 
 /// Engine-owned directory handles. Cleared via `close()` at engine shutdown.
 pub const Dirs = struct {
@@ -48,6 +51,8 @@ pub const Dirs = struct {
         if (self.resources.handle != cwd_handle) self.resources.close(io);
         if (self.data.handle != cwd_handle and self.data.handle != self.resources.handle)
             self.data.close(io);
+
+        if (NintendoIo != void) NintendoIo.deinitAppDirs();
     }
 };
 
@@ -82,13 +87,15 @@ pub fn resolve(
     // and debug/CI builds where state co-located with the binary is a
     // feature, not a bug.
     if (options.config.use_cwd) {
+        if (NintendoIo != void) NintendoIo.useCwdDirs();
         return .{ .resources = Io.Dir.cwd(), .data = Io.Dir.cwd() };
     }
 
-    return switch (builtin.os.tag) {
+    return switch (options.config.platform) {
         .macos => resolve_macos(io, environ_map, app_name),
         .windows => resolve_windows(io, environ_map, app_name),
         .linux => resolve_linux(io, environ_map, app_name),
+        .nintendo_3ds, .nintendo_switch => resolve_nintendo(io, app_name),
         // PSP: both dirs collapse to CWD. The EBOOT and its siblings all
         // live under `ms0:/PSP/GAME/<id>/`; the runtime sets CWD there
         // before main. No separation to enforce.
@@ -100,6 +107,23 @@ pub fn resolve(
     };
 }
 
+fn resolve_nintendo(io: Io, app_name: []const u8) Error!Dirs {
+    NintendoIo.mountData();
+    errdefer NintendoIo.deinitAppDirs();
+
+    var data_buf: [Io.Dir.max_path_bytes]u8 = undefined;
+    const data_path = NintendoIo.dataRoot(&data_buf, app_name) catch return error.PathTooLong;
+    const data = try Io.Dir.cwd().createDirPathOpen(io, data_path, .{ .open_options = .{ .iterate = true } });
+    errdefer data.close(io);
+
+    const resources = if (NintendoIo.mountResources())
+        Io.Dir.cwd().openDir(io, "romfs:/", .{}) catch data
+    else
+        data;
+
+    return .{ .resources = resources, .data = data };
+}
+
 // -- macOS --------------------------------------------------------------------
 
 fn resolve_macos(
diff --git a/src/engine.zig b/src/engine.zig
index c94645c..fc4a22b 100644
--- a/src/engine.zig
+++ b/src/engine.zig
@@ -1,5 +1,4 @@
 const std = @import("std");
-const builtin = @import("builtin");
 const assert = std.debug.assert;
 
 const Util = @import("util/util.zig");
@@ -87,8 +86,30 @@ pub const Engine = struct {
     trackers: [TRACKER_COUNT]CategoryTracker,
     running: bool,
     vsync: bool,
-    state: *const Core.State,
+    state: Core.State,
     dirs: Core.paths.Dirs,
+    debug_trace_loops: u8,
+    debug_trace_loop_index: u32,
+    run_loop: RunLoop,
+
+    const RunLoop = struct {
+        run_start_ns: i96 = 0,
+        last_us: i64 = 0,
+        update_accum: i64 = 0,
+        tick_accum: i64 = 0,
+        fps_count: u32 = 0,
+        fps_window_end: i64 = std.time.us_per_s,
+        initialized: bool = false,
+
+        fn reset(self: *RunLoop, io: std.Io) void {
+            var clock = std.Io.Clock.boot;
+            self.* = .{
+                .run_start_ns = clock.now(io).toNanoseconds(),
+                .fps_window_end = std.time.us_per_s,
+                .initialized = true,
+            };
+        }
+    };
 
     pub const Config = struct {
         memory: MemoryConfig,
@@ -127,7 +148,10 @@ pub const Engine = struct {
         self.io = sys_io;
         self.running = true;
         self.vsync = config.vsync;
-        self.state = state;
+        self.state = state.*;
+        self.debug_trace_loops = 0;
+        self.debug_trace_loop_index = 0;
+        self.run_loop = .{};
 
         self.pool = memory.PoolAlloc.init(mem, "main");
         const inner = self.pool.allocator();
@@ -148,9 +172,20 @@ pub const Engine = struct {
 
         try logger.init(sys_io, self.dirs.data);
 
-        try Platform.init(self, config.width, config.height, config.title, config.fullscreen, config.vsync, config.resizable);
-        try Rendering.Texture.init_defaults(self.allocator(.render));
-        try Core.state_machine.init(self, state);
+        Platform.init(self, config.width, config.height, config.title, config.fullscreen, config.vsync, config.resizable) catch |err| switch (err) {
+            error.OutOfMemory => return error.PlatformInitOutOfMemory,
+            else => return err,
+        };
+        errdefer Platform.deinit();
+
+        Rendering.Texture.init_defaults(self.allocator(.render)) catch |err| switch (err) {
+            error.OutOfMemory => return error.DefaultTexturesOutOfMemory,
+            else => return err,
+        };
+        Core.state_machine.init(self, &self.state) catch |err| switch (err) {
+            error.OutOfMemory => return error.StateInitOutOfMemory,
+            else => return err,
+        };
     }
 
     pub fn deinit(self: *Engine) void {
@@ -174,6 +209,11 @@ pub const Engine = struct {
         Platform.gfx.set_vsync(v);
     }
 
+    pub fn trace_next_loops(self: *Engine, count: u8) void {
+        self.debug_trace_loops = count;
+        self.debug_trace_loop_index = 0;
+    }
+
     pub fn pool_used(self: *const Engine, p: Pool) usize {
         return self.trackers[@intFromEnum(p)].used;
     }
@@ -191,158 +231,412 @@ pub const Engine = struct {
     }
 
     pub fn total_used(self: *const Engine) usize {
-        return self.pool.used;
+        var total: usize = 0;
+        for (self.trackers) |tracker| total += tracker.used;
+        return total;
     }
 
     pub fn total_budget(self: *const Engine) usize {
-        return self.pool.budget;
+        var total: usize = 0;
+        for (self.trackers) |tracker| total += tracker.budget;
+        return total;
     }
 
     pub fn report(self: *const Engine) void {
-        const mib = 1024.0 * 1024.0;
         Util.engine_logger.info("--- memory pools ---", .{});
         inline for (std.meta.fields(Pool)) |f| {
             const p: Pool = @enumFromInt(f.value);
             const used = self.pool_used(p);
             const budget = self.pool_budget(p);
             const remaining = self.pool_remaining(p);
-            Util.engine_logger.info("  {s}: {}/{} bytes ({d:.3}/{d:.3} MiB, {} remaining)", .{
+            Util.engine_logger.info("  {s}: {}/{} bytes ({}/{} KiB, {} remaining)", .{
                 f.name,
                 used,
                 budget,
-                @as(f64, @floatFromInt(used)) / mib,
-                @as(f64, @floatFromInt(budget)) / mib,
+                used / 1024,
+                budget / 1024,
                 remaining,
             });
         }
-        Util.engine_logger.info("  total: {}/{} bytes ({d:.3}/{d:.3} MiB)", .{
-            self.pool.used,
-            self.pool.budget,
-            @as(f64, @floatFromInt(self.pool.used)) / mib,
-            @as(f64, @floatFromInt(self.pool.budget)) / mib,
+        Util.engine_logger.info("  total: {}/{} bytes ({}/{} KiB)", .{
+            self.total_used(),
+            self.total_budget(),
+            self.total_used() / 1024,
+            self.total_budget() / 1024,
         });
         Util.engine_logger.info("--------------------", .{});
     }
 
+    pub fn beginRun(self: *Engine) void {
+        self.run_loop.reset(self.io);
+    }
+
+    pub fn stepFrame(self: *Engine) !bool {
+        if (!self.run_loop.initialized) self.beginRun();
+        if (options.config.platform == .nintendo_3ds) {
+            @compileError("Engine.stepFrame is not implemented for the Nintendo 3DS fixed-vblank loop");
+        }
+        try self.stepFrameInternal(false);
+        return self.running;
+    }
+
     pub fn run(self: *Engine) !void {
+        if (options.config.platform == .nintendo_3ds) {
+            return self.runNintendo3ds();
+        }
+
+        self.beginRun();
+        while (self.running) {
+            try self.stepFrameInternal(true);
+        }
+    }
+
+    fn stepFrameInternal(self: *Engine, allow_sleep: bool) !void {
+        if (options.config.platform == .nintendo_3ds) unreachable;
+
         const US_PER_S: u64 = std.time.us_per_s;
         const NS_PER_US: i64 = 1000;
 
-        // Fixed-step rates -- PSP targets 60 Hz display
+        // Fixed-step rates -- handheld backends target 60 Hz displays.
         const UPDATES_HZ: u32 = if (options.config.platform == .psp) 60 else 144;
         const TICKS_HZ: u32 = 20;
         const UPDATE_US: u64 = US_PER_S / UPDATES_HZ;
         const TICK_US: u64 = US_PER_S / TICKS_HZ;
-
         const update_budget_ns: i64 = @as(i64, @intCast(UPDATE_US)) * NS_PER_US;
 
-        var clock = std.Io.Clock.real;
+        var clock = std.Io.Clock.boot;
+        const fps_window_us: i64 = @intCast(US_PER_S);
+
+        const report_fps = options.config.gfx != .headless and !options.config.flush_logs;
+
+        const trace_loop = self.debug_trace_loops > 0;
+        const trace_loop_index = self.debug_trace_loop_index + 1;
+        if (trace_loop) {
+            Util.engine_logger.info("trace: engine loop {d} begin update_us={d} tick_us={d}", .{
+                trace_loop_index,
+                UPDATE_US,
+                TICK_US,
+            });
+        }
+
+        var now_us = elapsedUsSince(self.run_loop.run_start_ns, clock.now(self.io).toNanoseconds());
+        var frame_dt_us = saturatingSubI64(now_us, self.run_loop.last_us);
+
+        if (frame_dt_us <= 0) {
+            if (allow_sleep) {
+                try std.Io.sleep(self.io, .fromNanoseconds(std.time.ns_per_ms), clock);
+            }
+            now_us = elapsedUsSince(self.run_loop.run_start_ns, clock.now(self.io).toNanoseconds());
+            frame_dt_us = @max(0, saturatingSubI64(now_us, self.run_loop.last_us));
+            if (frame_dt_us <= 0) {
+                frame_dt_us = 1000;
+            }
+        }
+
+        if (frame_dt_us > 500_000) frame_dt_us = 500_000;
+        self.run_loop.last_us = now_us;
+
+        self.run_loop.update_accum = saturatingAddI64(self.run_loop.update_accum, frame_dt_us);
+        self.run_loop.tick_accum = saturatingAddI64(self.run_loop.tick_accum, frame_dt_us);
+        if (trace_loop) {
+            Util.engine_logger.info("trace: engine loop {d} time now_us={d} frame_dt_us={d} last_us={d} update_accum={d} tick_accum={d}", .{
+                trace_loop_index,
+                now_us,
+                frame_dt_us,
+                self.run_loop.last_us,
+                self.run_loop.update_accum,
+                self.run_loop.tick_accum,
+            });
+            Util.engine_logger.info("trace: engine loop {d} platform begin", .{trace_loop_index});
+        }
+
+        const platform_start_ns = clock.now(self.io).toNanoseconds();
+        Platform.update(self);
+        const platform_done_ns = clock.now(self.io).toNanoseconds();
+        var pre_update_elapsed_ns = elapsedNsBetween(platform_start_ns, platform_done_ns);
+        if (trace_loop) {
+            Util.engine_logger.info("trace: engine loop {d} platform end running={}", .{ trace_loop_index, self.running });
+        }
+        if (!self.running) return;
+
+        // ---- fixed-rate TICK steps (e.g., 20 Hz logic) ----
+        var is_tick_frame = false;
+        var tick_cost_ns: i64 = 0;
+        const tick_us: i64 = @intCast(TICK_US);
+        var tick_steps: u32 = 0;
+        while (self.run_loop.tick_accum >= tick_us) {
+            @branchHint(.unpredictable);
+            is_tick_frame = true;
+            if (trace_loop) {
+                Util.engine_logger.info("trace: engine loop {d} tick {d} begin accum={d}", .{
+                    trace_loop_index,
+                    tick_steps + 1,
+                    self.run_loop.tick_accum,
+                });
+            }
+            const tick_start_ns = clock.now(self.io).toNanoseconds();
+            try Core.state_machine.tick(self);
+            const tick_end_ns = clock.now(self.io).toNanoseconds();
+            tick_cost_ns = saturatingAddI64(tick_cost_ns, elapsedNsBetween(tick_start_ns, tick_end_ns));
+            self.run_loop.tick_accum -= tick_us;
+            tick_steps += 1;
+            if (trace_loop) {
+                Util.engine_logger.info("trace: engine loop {d} tick {d} end accum={d}", .{
+                    trace_loop_index,
+                    tick_steps,
+                    self.run_loop.tick_accum,
+                });
+            }
+        }
+
+        // ---- fixed-rate UPDATE steps (simulation & interpolation) ----
+        const UPDATE_DT_S: f32 = @as(f32, @floatFromInt(UPDATE_US)) / @as(f32, US_PER_S);
+        var update_steps: u32 = 0;
+        while (self.run_loop.update_accum >= UPDATE_US) {
+            @branchHint(.unpredictable);
+
+            if (trace_loop) {
+                Util.engine_logger.info("trace: engine loop {d} input begin update_accum={d}", .{
+                    trace_loop_index,
+                    self.run_loop.update_accum,
+                });
+            }
+            const input_start_ns = clock.now(self.io).toNanoseconds();
+            Platform.input.update();
+            Core.input.update();
+            const input_done_ns = clock.now(self.io).toNanoseconds();
+            const engine_elapsed_ns = saturatingAddI64(pre_update_elapsed_ns, elapsedNsBetween(input_start_ns, input_done_ns));
+            if (trace_loop) {
+                Util.engine_logger.info("trace: engine loop {d} input end running={}", .{ trace_loop_index, self.running });
+            }
+            if (!self.running) return;
+
+            const budget = Util.BudgetContext{
+                .phase_budget_ns = update_budget_ns,
+                .engine_elapsed_ns = engine_elapsed_ns,
+                .remaining_ns = update_budget_ns - engine_elapsed_ns,
+                .is_tick_frame = is_tick_frame,
+                .tick_cost_ns = tick_cost_ns,
+                .safety_margin_ns = Util.BudgetContext.DEFAULT_SAFETY_MARGIN_NS,
+            };
+
+            if (trace_loop) {
+                Util.engine_logger.info("trace: engine loop {d} update {d} begin dt_bits=0x{x}", .{
+                    trace_loop_index,
+                    update_steps + 1,
+                    @as(u32, @bitCast(UPDATE_DT_S)),
+                });
+            }
+            try Core.state_machine.update(self, UPDATE_DT_S, &budget);
+            pre_update_elapsed_ns = 0;
+            self.run_loop.update_accum -= UPDATE_US;
+            update_steps += 1;
+            if (trace_loop) {
+                Util.engine_logger.info("trace: engine loop {d} update {d} end accum={d}", .{
+                    trace_loop_index,
+                    update_steps,
+                    self.run_loop.update_accum,
+                });
+            }
+        }
+
+        // ---- render ASAP (uncapped when vsync == false) ----
+        const frame_dt_s: f32 = @as(f32, @floatFromInt(frame_dt_us)) / @as(f32, US_PER_S);
+        if (trace_loop) {
+            Util.engine_logger.info("trace: engine loop {d} start_frame begin frame_dt_us={d}", .{
+                trace_loop_index,
+                frame_dt_us,
+            });
+        }
+        const drew_frame = Platform.gfx.api.start_frame();
+        if (trace_loop) {
+            Util.engine_logger.info("trace: engine loop {d} start_frame end drew={}", .{ trace_loop_index, drew_frame });
+        }
+        if (drew_frame) {
+            const draw_start_ns = clock.now(self.io).toNanoseconds();
+            // Time until next update step is due
+            const slack_us: i64 = @as(i64, @intCast(UPDATE_US)) - @max(0, self.run_loop.update_accum);
+            const draw_budget_ns: i64 = if (self.vsync)
+                slack_us * NS_PER_US
+            else
+                std.math.maxInt(i64);
+
+            const draw_budget = Util.BudgetContext{
+                .phase_budget_ns = draw_budget_ns,
+                .engine_elapsed_ns = 0,
+                .remaining_ns = draw_budget_ns,
+                .is_tick_frame = is_tick_frame,
+                .tick_cost_ns = tick_cost_ns,
+                .safety_margin_ns = Util.BudgetContext.DEFAULT_SAFETY_MARGIN_NS,
+            };
+
+            if (trace_loop) {
+                Util.engine_logger.info("trace: engine loop {d} draw begin", .{trace_loop_index});
+            }
+            try Core.state_machine.draw(self, frame_dt_s, &draw_budget);
+            if (trace_loop) {
+                Util.engine_logger.info("trace: engine loop {d} draw end", .{trace_loop_index});
+            }
+            _ = draw_start_ns;
+            if (trace_loop) {
+                Util.engine_logger.info("trace: engine loop {d} end_frame begin", .{trace_loop_index});
+            }
+            Platform.gfx.api.end_frame();
+            if (trace_loop) {
+                Util.engine_logger.info("trace: engine loop {d} end_frame end", .{trace_loop_index});
+            }
+        } else {
+            @branchHint(.unlikely);
+            if (allow_sleep) {
+                if (options.config.gfx == .headless) {
+                    const next_update = @as(i64, @intCast(UPDATE_US)) - self.run_loop.update_accum;
+                    const next_tick = @as(i64, @intCast(TICK_US)) - self.run_loop.tick_accum;
+                    const sleep_us = @max(0, @min(next_update, next_tick));
+                    if (sleep_us > 0) {
+                        const sleep_ns = sleep_us * NS_PER_US;
+                        try std.Io.sleep(self.io, .fromNanoseconds(@intCast(sleep_ns)), clock);
+                    }
+                } else if (options.config.platform != .psp) {
+                    try std.Io.sleep(self.io, .fromNanoseconds(50 * std.time.ns_per_ms), clock);
+                }
+            }
+        }
+        if (trace_loop) {
+            Util.engine_logger.info("trace: engine loop {d} end ticks={d} updates={d}", .{
+                trace_loop_index,
+                tick_steps,
+                update_steps,
+            });
+            self.debug_trace_loop_index = trace_loop_index;
+            self.debug_trace_loops -= 1;
+        }
+
+        // ---- FPS counting ----
+        if (report_fps) {
+            if (drew_frame) self.run_loop.fps_count += 1;
+            const end_us = elapsedUsSince(self.run_loop.run_start_ns, clock.now(self.io).toNanoseconds());
+            if (end_us >= self.run_loop.fps_window_end) {
+                Util.engine_logger.info("FPS: {}", .{self.run_loop.fps_count});
+                self.run_loop.fps_count = 0;
+                self.run_loop.fps_window_end = saturatingAddI64(end_us, fps_window_us);
+            }
+        }
+    }
+
+    fn runNintendo3ds(self: *Engine) !void {
+        const US_PER_S: u64 = std.time.us_per_s;
+        const NS_PER_US: i64 = 1000;
+        const FRAMES_HZ: u32 = 60;
+        const TICKS_HZ: u32 = 20;
+        const TICK_FRAME_INTERVAL: u32 = FRAMES_HZ / TICKS_HZ;
+        const FRAME_US: u64 = US_PER_S / FRAMES_HZ;
+        const FRAME_DT_S: f32 = @as(f32, @floatFromInt(FRAME_US)) / @as(f32, US_PER_S);
+        const frame_budget_ns: i64 = @as(i64, @intCast(FRAME_US)) * NS_PER_US;
 
-        var last_us: i64 = @truncate(@divTrunc(clock.now(self.io).toNanoseconds(), 1000));
-        var update_accum: i64 = 0;
-        var tick_accum: i64 = 0;
+        comptime assert(FRAMES_HZ % TICKS_HZ == 0);
 
-        const report_fps = options.config.gfx != .headless;
-        var fps_count: u32 = 0;
-        var fps_window_end: i64 = last_us + US_PER_S;
+        if (!self.vsync) self.set_vsync(true);
 
+        var frame_count: u32 = 0;
         while (self.running) {
-            const now_us: i64 = @truncate(@divTrunc(clock.now(self.io).toNanoseconds(), 1000));
-            var frame_dt_us: i64 = now_us - last_us;
-            last_us = now_us;
-
-            if (frame_dt_us > 500_000) frame_dt_us = 500_000;
-
-            update_accum += frame_dt_us;
-            tick_accum += frame_dt_us;
-
-            // ---- fixed-rate TICK steps (e.g., 20 Hz logic) ----
-            var is_tick_frame = false;
-            var tick_cost_ns: i64 = 0;
-            const tick_us: i64 = @intCast(TICK_US);
-            while (tick_accum >= tick_us) {
-                @branchHint(.unpredictable);
-                is_tick_frame = true;
-                const tick_start_ns: i64 = @truncate(clock.now(self.io).toNanoseconds());
-                try Core.state_machine.tick(self);
-                const tick_end_ns: i64 = @truncate(clock.now(self.io).toNanoseconds());
-                tick_cost_ns += tick_end_ns - tick_start_ns;
-                tick_accum -= tick_us;
+            const trace_loop = self.debug_trace_loops > 0;
+            const trace_loop_index = self.debug_trace_loop_index + 1;
+            const is_tick_frame = frame_count % TICK_FRAME_INTERVAL == 0;
+
+            if (trace_loop) {
+                Util.engine_logger.info("trace: 3ds loop {d} begin frame={d} dt_bits=0x{x} tick_frame={}", .{
+                    trace_loop_index,
+                    frame_count,
+                    @as(u32, @bitCast(FRAME_DT_S)),
+                    is_tick_frame,
+                });
+                Util.engine_logger.info("trace: 3ds loop {d} platform begin", .{trace_loop_index});
             }
 
-            // ---- fixed-rate UPDATE steps (input update & interpolation) ----
-            const UPDATE_DT_S: f32 = @as(f32, @floatFromInt(UPDATE_US)) / @as(f32, US_PER_S);
-            while (update_accum >= UPDATE_US) {
-                @branchHint(.unpredictable);
-
-                const step_start_ns: i64 = @truncate(clock.now(self.io).toNanoseconds());
-                Platform.input.update();
-                Platform.update(self);
-                Core.input.update();
-                const engine_done_ns: i64 = @truncate(clock.now(self.io).toNanoseconds());
-                const engine_elapsed_ns = engine_done_ns - step_start_ns;
-
-                const budget = Util.BudgetContext{
-                    .phase_budget_ns = update_budget_ns,
-                    .engine_elapsed_ns = engine_elapsed_ns,
-                    .remaining_ns = update_budget_ns - engine_elapsed_ns,
-                    .is_tick_frame = is_tick_frame,
-                    .tick_cost_ns = tick_cost_ns,
-                    .safety_margin_ns = Util.BudgetContext.DEFAULT_SAFETY_MARGIN_NS,
-                };
+            Platform.update(self);
+            if (trace_loop) {
+                Util.engine_logger.info("trace: 3ds loop {d} platform end running={}", .{ trace_loop_index, self.running });
+            }
+            if (!self.running) break;
 
-                try Core.state_machine.update(self, UPDATE_DT_S, &budget);
-                update_accum -= UPDATE_US;
+            if (is_tick_frame) {
+                if (trace_loop) Util.engine_logger.info("trace: 3ds loop {d} tick begin", .{trace_loop_index});
+                try Core.state_machine.tick(self);
+                if (trace_loop) Util.engine_logger.info("trace: 3ds loop {d} tick end", .{trace_loop_index});
             }
 
-            // ---- render ASAP (uncapped when vsync == false) ----
-            const frame_dt_s: f32 = @as(f32, @floatFromInt(frame_dt_us)) / @as(f32, US_PER_S);
+            if (trace_loop) Util.engine_logger.info("trace: 3ds loop {d} input begin", .{trace_loop_index});
+            Platform.input.update();
+            Core.input.update();
+            if (trace_loop) Util.engine_logger.info("trace: 3ds loop {d} input end running={}", .{ trace_loop_index, self.running });
+            if (!self.running) break;
+
+            const budget = Util.BudgetContext{
+                .phase_budget_ns = frame_budget_ns,
+                .engine_elapsed_ns = 0,
+                .remaining_ns = frame_budget_ns,
+                .is_tick_frame = is_tick_frame,
+                .tick_cost_ns = 0,
+                .safety_margin_ns = Util.BudgetContext.DEFAULT_SAFETY_MARGIN_NS,
+            };
+
+            if (trace_loop) Util.engine_logger.info("trace: 3ds loop {d} update begin", .{trace_loop_index});
+            try Core.state_machine.update(self, FRAME_DT_S, &budget);
+            if (trace_loop) Util.engine_logger.info("trace: 3ds loop {d} update end", .{trace_loop_index});
+
+            if (trace_loop) Util.engine_logger.info("trace: 3ds loop {d} start_frame begin", .{trace_loop_index});
             const drew_frame = Platform.gfx.api.start_frame();
+            if (trace_loop) Util.engine_logger.info("trace: 3ds loop {d} start_frame end drew={}", .{ trace_loop_index, drew_frame });
             if (drew_frame) {
-                const draw_start_ns: i64 = @truncate(clock.now(self.io).toNanoseconds());
-                // Time until next update step is due
-                const slack_us: i64 = @as(i64, @intCast(UPDATE_US)) - @max(0, update_accum);
-                const draw_budget_ns: i64 = if (self.vsync)
-                    slack_us * NS_PER_US
-                else
-                    std.math.maxInt(i64);
-
                 const draw_budget = Util.BudgetContext{
-                    .phase_budget_ns = draw_budget_ns,
+                    .phase_budget_ns = frame_budget_ns,
                     .engine_elapsed_ns = 0,
-                    .remaining_ns = draw_budget_ns,
+                    .remaining_ns = frame_budget_ns,
                     .is_tick_frame = is_tick_frame,
-                    .tick_cost_ns = tick_cost_ns,
+                    .tick_cost_ns = 0,
                     .safety_margin_ns = Util.BudgetContext.DEFAULT_SAFETY_MARGIN_NS,
                 };
 
-                try Core.state_machine.draw(self, frame_dt_s, &draw_budget);
-                _ = draw_start_ns;
+                if (trace_loop) Util.engine_logger.info("trace: 3ds loop {d} draw begin", .{trace_loop_index});
+                try Core.state_machine.draw(self, FRAME_DT_S, &draw_budget);
+                if (trace_loop) Util.engine_logger.info("trace: 3ds loop {d} draw end", .{trace_loop_index});
+
+                if (trace_loop) Util.engine_logger.info("trace: 3ds loop {d} end_frame begin", .{trace_loop_index});
                 Platform.gfx.api.end_frame();
-            } else {
-                @branchHint(.unlikely);
-                if (options.config.gfx == .headless) {
-                    const next_update = @as(i64, @intCast(UPDATE_US)) - update_accum;
-                    const next_tick = @as(i64, @intCast(TICK_US)) - tick_accum;
-                    const sleep_us = @max(0, @min(next_update, next_tick));
-                    if (sleep_us > 0) {
-                        try std.Io.sleep(self.io, .fromMicroseconds(sleep_us), clock);
-                    }
-                } else if (options.config.platform != .psp) {
-                    try std.Io.sleep(self.io, .fromMilliseconds(50), clock);
-                }
+                if (trace_loop) Util.engine_logger.info("trace: 3ds loop {d} end_frame end", .{trace_loop_index});
             }
 
-            // ---- FPS counting ----
-            if (report_fps) {
-                if (drew_frame) fps_count += 1;
-                const end_us: i64 = @truncate(@divTrunc(clock.now(self.io).toNanoseconds(), 1000));
-                if (end_us >= fps_window_end) {
-                    Util.engine_logger.info("FPS: {}", .{fps_count});
-                    fps_count = 0;
-                    fps_window_end = end_us + US_PER_S;
-                }
+            if (trace_loop) {
+                Util.engine_logger.info("trace: 3ds loop {d} end drew={}", .{ trace_loop_index, drew_frame });
+                self.debug_trace_loop_index = trace_loop_index;
+                self.debug_trace_loops -= 1;
             }
+
+            frame_count +%= 1;
         }
     }
 };
+
+fn elapsedNsBetween(start_ns: i96, end_ns: i96) i64 {
+    return clampI96ToI64(end_ns - start_ns);
+}
+
+fn elapsedUsSince(start_ns: i96, end_ns: i96) i64 {
+    return @divTrunc(elapsedNsBetween(start_ns, end_ns), std.time.ns_per_us);
+}
+
+fn saturatingAddI64(a: i64, b: i64) i64 {
+    return clampI96ToI64(@as(i96, a) + @as(i96, b));
+}
+
+fn saturatingSubI64(a: i64, b: i64) i64 {
+    return clampI96ToI64(@as(i96, a) - @as(i96, b));
+}
+
+fn clampI96ToI64(value: i96) i64 {
+    const max: i96 = std.math.maxInt(i64);
+    const min: i96 = std.math.minInt(i64);
+    if (value > max) return std.math.maxInt(i64);
+    if (value < min) return std.math.minInt(i64);
+    return @intCast(value);
+}
diff --git a/src/platform/3ds/3ds_audio.zig b/src/platform/3ds/3ds_audio.zig
new file mode 100644
index 0000000..e61e0e3
--- /dev/null
+++ b/src/platform/3ds/3ds_audio.zig
@@ -0,0 +1,266 @@
+//! 3DS audio backend -- NDSP hardware voices.
+//!
+//! Each Aether mixer slot maps to one NDSP channel. The game thread refills
+//! double-buffered linear-memory wave buffers from the Stream reader in
+//! `update`; NDSP handles sample-rate conversion and channel mixing.
+
+const std = @import("std");
+const surface = @import("surface.zig");
+const Stream = @import("../../audio/stream.zig").Stream;
+const PcmFormat = @import("../../audio/stream.zig").PcmFormat;
+
+const NUM_SLOTS: usize = 24;
+const BUFFERS_PER_SLOT: usize = 2;
+const SAMPLES_PER_BUF: usize = 4096;
+const MAX_CHANNELS: usize = 2;
+const MAX_BYTES_PER_SAMPLE: usize = 2;
+const MAX_BYTES_PER_BUF: usize = SAMPLES_PER_BUF * MAX_CHANNELS * MAX_BYTES_PER_SAMPLE;
+const TOTAL_AUDIO_BYTES: usize = NUM_SLOTS * BUFFERS_PER_SLOT * MAX_BYTES_PER_BUF;
+
+const NDSP_OUTPUT_STEREO: c_int = 1;
+const NDSP_INTERP_LINEAR: c_int = 1;
+const NDSP_FORMAT_MONO_PCM16: u16 = 5;
+const NDSP_FORMAT_STEREO_PCM16: u16 = 6;
+const NDSP_WBUF_DONE: u8 = 3;
+
+const Result = c_int;
+
+const NdspAdpcmData = extern struct {
+    index: u16,
+    history0: i16,
+    history1: i16,
+};
+
+const NdspWaveBuf = extern struct {
+    data_vaddr: ?*const anyopaque,
+    nsamples: u32,
+    adpcm_data: ?*NdspAdpcmData,
+    offset: u32,
+    looping: bool,
+    status: u8,
+    sequence_id: u16,
+    next: ?*NdspWaveBuf,
+};
+
+extern fn ndspInit() Result;
+extern fn ndspExit() void;
+extern fn ndspSetOutputMode(mode: c_int) void;
+extern fn ndspChnReset(id: c_int) void;
+extern fn ndspChnSetInterp(id: c_int, interp: c_int) void;
+extern fn ndspChnSetRate(id: c_int, rate: f32) void;
+extern fn ndspChnSetFormat(id: c_int, format: u16) void;
+extern fn ndspChnSetMix(id: c_int, mix: *[12]f32) void;
+extern fn ndspChnWaveBufClear(id: c_int) void;
+extern fn ndspChnWaveBufAdd(id: c_int, buf: *NdspWaveBuf) void;
+extern fn DSP_FlushDataCache(address: *const anyopaque, size: u32) Result;
+extern fn linearAlloc(size: usize) ?*anyopaque;
+extern fn linearFree(mem: ?*anyopaque) void;
+
+const SlotState = enum(u8) {
+    inactive = 0,
+    pending = 1,
+    active = 2,
+    finished = 3,
+};
+
+const Slot = struct {
+    state: SlotState = .inactive,
+    gain: f32 = 0,
+    pan: f32 = 0,
+    stream: Stream = undefined,
+    format: PcmFormat = .{ .sample_rate = 44_100, .channels = 1, .bit_depth = 16 },
+    wave_bufs: [BUFFERS_PER_SLOT]NdspWaveBuf = undefined,
+};
+
+var slots: [NUM_SLOTS]Slot = init_slots();
+var audio_alloc: std.mem.Allocator = undefined;
+var audio_io: std.Io = undefined;
+var audio_data: ?[*]u8 = null;
+
+fn init_slots() [NUM_SLOTS]Slot {
+    var s: [NUM_SLOTS]Slot = undefined;
+    for (&s) |*slot| {
+        slot.* = .{};
+    }
+    return s;
+}
+
+pub fn setup(alloc: std.mem.Allocator, io: std.Io) void {
+    audio_alloc = alloc;
+    audio_io = io;
+}
+
+pub fn init() anyerror!void {
+    _ = audio_alloc;
+    _ = audio_io;
+
+    audio_data = @ptrCast(linearAlloc(TOTAL_AUDIO_BYTES) orelse return error.AudioLinearAllocFailed);
+
+    if (ndspInit() != 0) {
+        linearFree(audio_data);
+        audio_data = null;
+        return error.NdspInitFailed;
+    }
+
+    ndspSetOutputMode(NDSP_OUTPUT_STEREO);
+
+    for (0..NUM_SLOTS) |i| {
+        ndspChnReset(@intCast(i));
+        slots[i] = .{};
+        init_wave_bufs(i);
+    }
+}
+
+pub fn deinit() void {
+    if (surface.is_system_closing()) {
+        slots = init_slots();
+        audio_data = null;
+        return;
+    }
+
+    for (0..NUM_SLOTS) |i| {
+        ndspChnWaveBufClear(@intCast(i));
+        ndspChnReset(@intCast(i));
+        slots[i].state = .inactive;
+    }
+
+    ndspExit();
+
+    if (audio_data) |data| {
+        linearFree(data);
+        audio_data = null;
+    }
+}
+
+pub fn update() void {
+    if (audio_data == null) return;
+
+    for (&slots, 0..) |*slot, i| {
+        switch (slot.state) {
+            .inactive, .finished => {},
+            .pending => start_slot(slot, i) catch {
+                slot.state = .finished;
+            },
+            .active => refill_done_buffers(slot, i),
+        }
+    }
+}
+
+pub fn max_voices() u32 {
+    return NUM_SLOTS;
+}
+
+pub fn play_slot(slot: u8, stream: Stream) anyerror!void {
+    if (surface.is_system_closing()) return error.SystemClosing;
+    if (slot >= NUM_SLOTS) return error.InvalidArgs;
+    if (!format_supported(stream.format)) return error.UnsupportedFormat;
+
+    const i: usize = slot;
+    ndspChnWaveBufClear(slot);
+    slots[i].stream = stream;
+    slots[i].format = stream.format;
+    slots[i].state = .pending;
+}
+
+pub fn stop_slot(slot: u8) void {
+    if (surface.is_system_closing()) return;
+    if (slot >= NUM_SLOTS) return;
+    ndspChnWaveBufClear(slot);
+    slots[slot].state = .inactive;
+}
+
+pub fn set_slot_gain_pan(slot: u8, gain: f32, pan: f32) void {
+    if (surface.is_system_closing()) return;
+    if (slot >= NUM_SLOTS) return;
+    slots[slot].gain = gain;
+    slots[slot].pan = pan;
+    if (slots[slot].state == .active) apply_mix(slot, &slots[slot]);
+}
+
+pub fn is_slot_active(slot: u8) bool {
+    if (slot >= NUM_SLOTS) return false;
+    return slots[slot].state != .inactive and slots[slot].state != .finished;
+}
+
+fn init_wave_bufs(slot_index: usize) void {
+    const base = audio_data.?;
+    const slot_base = slot_index * BUFFERS_PER_SLOT * MAX_BYTES_PER_BUF;
+
+    for (&slots[slot_index].wave_bufs, 0..) |*buf, b| {
+        buf.* = .{
+            .data_vaddr = @ptrCast(base + slot_base + b * MAX_BYTES_PER_BUF),
+            .nsamples = SAMPLES_PER_BUF,
+            .adpcm_data = null,
+            .offset = 0,
+            .looping = false,
+            .status = NDSP_WBUF_DONE,
+            .sequence_id = 0,
+            .next = null,
+        };
+    }
+}
+
+fn start_slot(slot: *Slot, slot_index: usize) !void {
+    const id: c_int = @intCast(slot_index);
+
+    ndspChnWaveBufClear(id);
+    ndspChnReset(id);
+    ndspChnSetInterp(id, NDSP_INTERP_LINEAR);
+    ndspChnSetRate(id, @floatFromInt(slot.format.sample_rate));
+    ndspChnSetFormat(id, if (slot.format.channels == 1) NDSP_FORMAT_MONO_PCM16 else NDSP_FORMAT_STEREO_PCM16);
+    apply_mix(@intCast(slot_index), slot);
+
+    var queued: bool = false;
+    for (&slot.wave_bufs) |*buf| {
+        if (fill_wave_buf(slot, buf)) {
+            ndspChnWaveBufAdd(id, buf);
+            queued = true;
+        } else break;
+    }
+
+    slot.state = if (queued) .active else .finished;
+}
+
+fn refill_done_buffers(slot: *Slot, slot_index: usize) void {
+    const id: c_int = @intCast(slot_index);
+
+    for (&slot.wave_bufs) |*buf| {
+        if (buf.status != NDSP_WBUF_DONE) continue;
+        if (!fill_wave_buf(slot, buf)) {
+            slot.state = .finished;
+            return;
+        }
+        ndspChnWaveBufAdd(id, buf);
+    }
+}
+
+fn fill_wave_buf(slot: *Slot, buf: *NdspWaveBuf) bool {
+    const byte_count = SAMPLES_PER_BUF * slot.format.frame_size();
+    if (byte_count > MAX_BYTES_PER_BUF) return false;
+
+    const raw: [*]u8 = @ptrCast(@constCast(buf.data_vaddr.?));
+    const dst = raw[0..byte_count];
+
+    slot.stream.reader.readSliceAll(dst) catch return false;
+    _ = DSP_FlushDataCache(buf.data_vaddr.?, @intCast(byte_count));
+
+    buf.nsamples = SAMPLES_PER_BUF;
+    buf.offset = 0;
+    buf.looping = false;
+    buf.status = NDSP_WBUF_DONE;
+    buf.next = null;
+    return true;
+}
+
+fn apply_mix(slot: u8, s: *const Slot) void {
+    const left = s.gain * std.math.clamp(1.0 - s.pan, 0.0, 1.0);
+    const right = s.gain * std.math.clamp(1.0 + s.pan, 0.0, 1.0);
+    var mix: [12]f32 = @splat(0);
+    mix[0] = std.math.clamp(left, 0.0, 1.0);
+    mix[1] = std.math.clamp(right, 0.0, 1.0);
+    ndspChnSetMix(slot, &mix);
+}
+
+fn format_supported(fmt: PcmFormat) bool {
+    return fmt.bit_depth == 16 and (fmt.channels == 1 or fmt.channels == 2);
+}
diff --git a/src/platform/3ds/3ds_gfx.zig b/src/platform/3ds/3ds_gfx.zig
new file mode 100644
index 0000000..391d155
--- /dev/null
+++ b/src/platform/3ds/3ds_gfx.zig
@@ -0,0 +1,1284 @@
+//! Mango/libctru graphics backend for Nintendo 3DS.
+
+const std = @import("std");
+const Util = @import("../../util/util.zig");
+const Mat4 = @import("../../math/math.zig").Mat4;
+const Rendering = @import("../../rendering/rendering.zig");
+const Mesh = Rendering.mesh;
+const Texture = Rendering.Texture;
+const surface = @import("surface.zig");
+const shaders = @import("aether_shaders");
+const zitrus = @import("zitrus");
+const mango = zitrus.mango;
+const pica = zitrus.hardware.pica;
+const log = std.log.scoped(.gfx);
+
+const c = @cImport({
+    @cDefine("wint_t", "unsigned int");
+    @cInclude("3ds/types.h");
+    @cInclude("3ds/gpu/enums.h");
+    @cInclude("3ds/gpu/gpu.h");
+    @cInclude("3ds/gpu/gx.h");
+    @cInclude("3ds/os.h");
+    @cInclude("3ds/services/gspgpu.h");
+    @cInclude("3ds/gfx.h");
+    @cInclude("3ds/allocator/vram.h");
+});
+
+var render_alloc: std.mem.Allocator = undefined;
+var render_io: std.Io = undefined;
+
+pub fn setup(alloc: std.mem.Allocator, io: std.Io) void {
+    render_alloc = alloc;
+    render_io = io;
+}
+
+const SCREEN_WIDTH: u32 = 800;
+const SCREEN_HEIGHT: u32 = 240;
+const TARGET_WIDTH: u16 = 240;
+const TARGET_HEIGHT: u16 = 800;
+const MAX_DEFERRED_MESH_FREES: usize = 4096;
+const MAX_TEXTURE_SIZE: u32 = 1024;
+const MIN_TEXTURE_SIZE: u32 = 8;
+const TEX_BPP: usize = 4;
+const CACHE_LINE_SIZE: usize = 32;
+const OS_FCRAM_VADDR: usize = 0x30000000;
+const OS_FCRAM_SIZE: usize = 0x10000000;
+const OS_OLD_FCRAM_VADDR: usize = 0x14000000;
+const OS_OLD_FCRAM_SIZE: usize = 0x08000000;
+
+const DISPLAY_TRANSFER_FLAGS: u32 = @intCast(
+    c.GX_TRANSFER_FLIP_VERT(0) |
+        c.GX_TRANSFER_OUT_TILED(0) |
+        c.GX_TRANSFER_RAW_COPY(0) |
+        c.GX_TRANSFER_IN_FORMAT(c.GX_TRANSFER_FMT_RGBA8) |
+        c.GX_TRANSFER_OUT_FORMAT(c.GX_TRANSFER_FMT_RGB8) |
+        c.GX_TRANSFER_SCALING(c.GX_TRANSFER_SCALE_NO),
+);
+
+fn gx_buffer_dim(width: u16, height: u16) u32 {
+    return (@as(u32, height) << 16) | @as(u32, width);
+}
+
+const VERTEX_STRIDE: usize = @sizeOf(Rendering.Vertex);
+const POS_SCALE: [4]f32 = .{ snorm16_scale(), snorm16_scale(), snorm16_scale(), 1.0 };
+const UV_SCALE: [2]f32 = .{ snorm16_scale(), snorm16_scale() };
+const COLOR_SCALE: [4]f32 = .{ unorm8_scale(), unorm8_scale(), unorm8_scale(), unorm8_scale() };
+const ALPHA_TEST_REFERENCE: u8 = 25;
+const FOG_LUT_NEAR: f32 = 0.01;
+
+comptime {
+    std.debug.assert(VERTEX_STRIDE == 16);
+    std.debug.assert(@offsetOf(Rendering.Vertex, "pos") == 0);
+    std.debug.assert(@offsetOf(Rendering.Vertex, "color") == 8);
+    std.debug.assert(@offsetOf(Rendering.Vertex, "uv") == 12);
+}
+
+const PipelineData = struct {
+    shader: mango.Shader,
+    vertex_input: mango.VertexInputLayout,
+    sampler: mango.Sampler,
+};
+
+const RenderTargetData = struct {
+    color_memory: mango.DeviceMemory,
+    depth_memory: mango.DeviceMemory,
+    color_image: mango.Image,
+    depth_image: mango.Image,
+    color_view: mango.ImageView,
+    depth_view: mango.ImageView,
+    color_pixels: []u8,
+};
+
+const MeshData = struct {
+    memory: mango.DeviceMemory = .null,
+    buffer: mango.Buffer = .null,
+    mapped: []u8 = &.{},
+    len: usize = 0,
+    capacity: usize = 0,
+};
+
+const DeferredMeshFree = struct {
+    memory: mango.DeviceMemory,
+    buffer: mango.Buffer,
+};
+
+const TextureData = struct {
+    width: u32,
+    height: u32,
+    upload_mode: TextureUploadMode,
+    memory: mango.DeviceMemory,
+    image: mango.Image,
+    view: mango.ImageView,
+};
+
+const TextureUploadMode = enum {
+    cpu_tiled,
+    transfer_tiled,
+};
+
+const texenv_primary: mango.TextureCombinerUnit = .{
+    .color_src = @splat(.primary_color),
+    .alpha_src = @splat(.primary_color),
+    .color_factor = @splat(.src_color),
+    .alpha_factor = @splat(.src_alpha),
+    .color_op = .replace,
+    .alpha_op = .replace,
+    .color_scale = .@"1x",
+    .alpha_scale = .@"1x",
+    .constant = @splat(0xFF),
+};
+
+const texenv_texture_modulate_primary: mango.TextureCombinerUnit = .{
+    .color_src = .{ .primary_color, .texture_0, .primary_color },
+    .alpha_src = .{ .primary_color, .texture_0, .primary_color },
+    .color_factor = @splat(.src_color),
+    .alpha_factor = @splat(.src_alpha),
+    .color_op = .modulate,
+    .alpha_op = .modulate,
+    .color_scale = .@"1x",
+    .alpha_scale = .@"1x",
+    .constant = @splat(0xFF),
+};
+
+const texenv_untextured = [_]mango.TextureCombinerUnit{
+    texenv_primary,
+    mango.TextureCombinerUnit.previous,
+    mango.TextureCombinerUnit.previous,
+    mango.TextureCombinerUnit.previous,
+    mango.TextureCombinerUnit.previous,
+    mango.TextureCombinerUnit.previous,
+};
+
+const texenv_textured = [_]mango.TextureCombinerUnit{
+    texenv_primary,
+    mango.TextureCombinerUnit.previous,
+    mango.TextureCombinerUnit.previous,
+    mango.TextureCombinerUnit.previous,
+    mango.TextureCombinerUnit.previous,
+    texenv_texture_modulate_primary,
+};
+
+const texenv_buffer_sources = [_]mango.TextureCombinerUnit.BufferSources{
+    .previous,
+    .previous,
+    .previous,
+    .previous,
+};
+
+const FogState = struct {
+    enabled: bool = false,
+    start: f32 = 0.0,
+    end: f32 = 1.0,
+    color: [4]u8 = .{ 0, 0, 0, 255 },
+    table: [128]u32 = @splat(0),
+};
+
+var meshes = Util.CircularBuffer(MeshData, 2048).init();
+var deferred_mesh_frees = Util.CircularBuffer(DeferredMeshFree, MAX_DEFERRED_MESH_FREES + 1).init();
+var textures = Util.CircularBuffer(TextureData, 64).init();
+
+var device: mango.Device = .null;
+var submit_queue: mango.Queue = .null;
+var fill_queue: mango.Queue = .null;
+var command_pool: mango.CommandPool = .null;
+var command_buffer: mango.CommandBuffer = .null;
+var render_pipeline: PipelineData = undefined;
+var render_target: RenderTargetData = undefined;
+var render_pipeline_initialized = false;
+var render_target_initialized = false;
+var command_resources_initialized = false;
+
+var projection_transform: Mat4 = Mat4.identity();
+var initialized = false;
+var frame_started = false;
+var trace_frames_remaining: u8 = 0;
+var trace_frame_active = false;
+var trace_frame_index: u8 = 0;
+var trace_submit_index: u8 = 0;
+var vsync_enabled = true;
+var clear_color: [4]u8 = .{ 0, 0, 0, 255 };
+var alpha_blend_enabled = true;
+var depth_write_enabled = true;
+var cull_face_enabled = true;
+var fog_state: FogState = .{};
+var uv_offset: [2]f32 = .{ 0.0, 0.0 };
+var proj_matrix: Mat4 = Mat4.identity();
+var view_matrix: Mat4 = Mat4.identity();
+var default_texture: Texture.Handle = 0;
+var bound_texture: Texture.Handle = 0;
+var bound_mesh: Mesh.Handle = 0;
+
+pub fn init() anyerror!void {
+    _ = render_io;
+
+    c.gfxInitDefault();
+    errdefer c.gfxExit();
+    c.gfxSetWide(true);
+
+    device = try mango.createAetherCtruBackedDevice(.{ .linear_gpa = render_alloc }, render_alloc);
+    errdefer {
+        device.destroy();
+        device = .null;
+    }
+
+    submit_queue = device.getQueue(.submit);
+    fill_queue = device.getQueue(.fill);
+
+    try init_command_resources();
+    errdefer deinit_command_resources();
+
+    try init_render_target();
+    errdefer deinit_render_target();
+
+    render_pipeline = try init_pipeline();
+    render_pipeline_initialized = true;
+    errdefer {
+        deinit_pipeline(&render_pipeline);
+        render_pipeline_initialized = false;
+    }
+
+    init_projection_transform();
+    initialized = true;
+    frame_started = false;
+}
+
+pub fn deinit() void {
+    if (surface.is_system_closing()) {
+        abandon_service_resources();
+        return;
+    }
+
+    frame_started = false;
+    if (initialized and device != .null) device.waitIdle();
+    free_deferred_mesh_resources();
+
+    for (1..textures.buffer.len) |i| {
+        if (textures.buffer[i]) |*tex| free_texture(tex);
+    }
+    textures.clear();
+
+    if (render_pipeline_initialized) {
+        deinit_pipeline(&render_pipeline);
+        render_pipeline_initialized = false;
+    }
+
+    for (1..meshes.buffer.len) |i| {
+        if (meshes.buffer[i]) |*mesh| free_mesh(mesh);
+    }
+    meshes.clear();
+
+    deinit_render_target();
+    deinit_command_resources();
+
+    if (device != .null) {
+        device.destroy();
+        device = .null;
+    }
+
+    if (initialized) {
+        c.gfxExit();
+        initialized = false;
+    }
+}
+
+pub fn set_clear_color(r: f32, g: f32, b: f32, a: f32) void {
+    const next = [4]u8{
+        float_to_u8(r),
+        float_to_u8(g),
+        float_to_u8(b),
+        float_to_u8(a),
+    };
+    if (std.mem.eql(u8, &clear_color, &next)) return;
+    clear_color = next;
+}
+
+pub fn set_alpha_blend(enabled: bool) void {
+    if (alpha_blend_enabled == enabled) return;
+    alpha_blend_enabled = enabled;
+    if (frame_started) apply_dynamic_state();
+}
+
+pub fn set_depth_write(enabled: bool) void {
+    if (depth_write_enabled == enabled) return;
+    depth_write_enabled = enabled;
+    if (frame_started) apply_dynamic_state();
+}
+
+pub fn set_fog(enabled: bool, start: f32, end: f32, r: f32, g: f32, b: f32) void {
+    const color = [4]u8{ float_to_u8(r), float_to_u8(g), float_to_u8(b), 255 };
+    if (fog_state.enabled == enabled and float_bits_equal(fog_state.start, start) and float_bits_equal(fog_state.end, end) and std.mem.eql(u8, &fog_state.color, &color)) return;
+
+    fog_state.enabled = enabled;
+    fog_state.start = start;
+    fog_state.end = end;
+    fog_state.color = color;
+    rebuild_fog_table();
+    if (frame_started) apply_fog_state();
+}
+
+pub fn set_clip_planes(_: bool) void {}
+
+pub fn set_culling(enabled: bool) void {
+    if (cull_face_enabled == enabled) return;
+    cull_face_enabled = enabled;
+    if (frame_started) apply_dynamic_state();
+}
+
+pub fn set_uv_offset(u: f32, v: f32) void {
+    if (float_bits_equal(uv_offset[0], u) and float_bits_equal(uv_offset[1], v)) return;
+    uv_offset = .{ u, v };
+    if (frame_started) upload_frame_uniforms();
+}
+
+pub fn trace_next_frames(count: u8) void {
+    trace_frames_remaining = count;
+}
+
+pub fn set_proj_matrix(mat: *const Mat4) void {
+    if (mat4_bits_equal(&proj_matrix, mat)) return;
+    proj_matrix = mat.*;
+    if (frame_started) upload_frame_uniforms();
+}
+
+pub fn set_view_matrix(mat: *const Mat4) void {
+    if (mat4_bits_equal(&view_matrix, mat)) return;
+    view_matrix = mat.*;
+}
+
+pub fn start_frame() bool {
+    if (surface.is_system_closing()) return false;
+    if (!initialized or frame_started) return false;
+
+    trace_frame_active = trace_frames_remaining > 0;
+    if (trace_frame_active) {
+        trace_frame_index += 1;
+        trace_submit_index = 0;
+        log.info("trace: 3ds frame {d} start_frame begin", .{trace_frame_index});
+    }
+
+    free_deferred_mesh_resources();
+
+    frame_started = true;
+    clear_frame_targets() catch {
+        if (trace_frame_active) log.info("trace: 3ds frame {d} clear targets failed", .{trace_frame_index});
+        frame_started = false;
+        trace_frame_active = false;
+        return false;
+    };
+    if (trace_frame_active) log.info("trace: 3ds frame {d} clear targets done", .{trace_frame_index});
+    begin_command_buffer() catch {
+        if (trace_frame_active) log.info("trace: 3ds frame {d} begin command buffer failed", .{trace_frame_index});
+        frame_started = false;
+        trace_frame_active = false;
+        return false;
+    };
+    if (trace_frame_active) log.info("trace: 3ds frame {d} start_frame end", .{trace_frame_index});
+    return true;
+}
+
+pub fn end_frame() void {
+    if (!frame_started) return;
+    if (trace_frame_active) log.info("trace: 3ds frame {d} end_frame begin", .{trace_frame_index});
+    if (surface.is_system_closing()) {
+        frame_started = false;
+        trace_frame_active = false;
+        return;
+    }
+
+    finish_command_buffer() catch {
+        if (trace_frame_active) log.info("trace: 3ds frame {d} finish command buffer failed", .{trace_frame_index});
+        frame_started = false;
+        trace_frame_active = false;
+        return;
+    };
+    if (trace_frame_active) log.info("trace: 3ds frame {d} command buffer finished", .{trace_frame_index});
+    if (surface.is_system_closing()) {
+        frame_started = false;
+        trace_frame_active = false;
+        return;
+    }
+    if (trace_frame_active) log.info("trace: 3ds frame {d} present begin", .{trace_frame_index});
+    present_render_target();
+    if (trace_frame_active) {
+        log.info("trace: 3ds frame {d} present end", .{trace_frame_index});
+        trace_frames_remaining -= 1;
+    }
+    frame_started = false;
+    trace_frame_active = false;
+}
+
+pub fn clear_depth() void {
+    if (!frame_started) return;
+
+    finish_command_buffer() catch {
+        frame_started = false;
+        return;
+    };
+    clear_depth_target() catch {
+        frame_started = false;
+        return;
+    };
+    begin_command_buffer() catch {
+        frame_started = false;
+        return;
+    };
+}
+
+pub fn set_vsync(v: bool) void {
+    vsync_enabled = v;
+}
+
+pub fn create_mesh() anyerror!Mesh.Handle {
+    const handle = meshes.add_element(.{}) orelse return error.OutOfMeshes;
+
+    return @intCast(handle);
+}
+
+pub fn destroy_mesh(handle: Mesh.Handle) void {
+    if (surface.is_system_closing()) {
+        _ = meshes.remove_element(handle);
+        return;
+    }
+
+    if (mesh_slot(handle)) |mesh| free_mesh(mesh);
+    if (bound_mesh == handle) bound_mesh = 0;
+    _ = meshes.remove_element(handle);
+}
+
+pub fn update_mesh(handle: Mesh.Handle, data: []const u8) void {
+    if (surface.is_system_closing()) return;
+
+    const mesh = mesh_slot(handle) orelse return;
+    if (data.len > std.math.maxInt(u32)) {
+        std.debug.panic("3ds_gfx: mesh vertex data is too large to flush", .{});
+    }
+
+    if (data.len == 0) {
+        mesh.len = 0;
+        return;
+    }
+
+    if (is_linear_fcram(data.ptr, data.len)) {
+        bind_mesh_to_linear_slice(mesh, data) catch
+            std.debug.panic("3ds_gfx: out of memory for mesh buffer handle", .{});
+        flush_linear_memory(data.ptr, data.len) catch {};
+        if (frame_started and bound_mesh == handle) bound_mesh = 0;
+        return;
+    }
+
+    ensure_mesh_capacity(mesh, data.len) catch
+        std.debug.panic("3ds_gfx: out of linear memory for mesh upload", .{});
+
+    @memcpy(mesh.mapped[0..data.len], data);
+    mesh.len = data.len;
+    flush_memory(mesh.memory, data.len) catch {};
+    if (frame_started and bound_mesh == handle) bound_mesh = 0;
+}
+
+pub fn draw_mesh(handle: Mesh.Handle, model: *const Mat4, count: usize) void {
+    if (surface.is_system_closing()) return;
+    if (!frame_started or !render_pipeline_initialized) return;
+
+    const mesh = mesh_slot(handle) orelse return;
+    if (count == 0 or mesh.len == 0 or mesh.buffer == .null) return;
+
+    const needed = mesh_draw_bytes_needed(count) orelse return;
+    if (needed > mesh.len) return;
+
+    upload_draw_uniforms(model);
+
+    if (bound_mesh != handle) {
+        command_buffer.bindVertexBuffersSlice(0, &.{mesh.buffer}, &.{0});
+        bound_mesh = handle;
+    }
+
+    command_buffer.draw(@intCast(@min(count, std.math.maxInt(u32))), 0);
+}
+
+pub fn create_texture(width: u32, height: u32, data: []align(16) u8) anyerror!Texture.Handle {
+    try validate_texture(width, height, data);
+
+    var tex = try create_texture_resources(width, height);
+    errdefer free_texture(&tex);
+
+    try upload_texture_data(&tex, data[0..texture_size(width, height)]);
+
+    const handle: Texture.Handle = @intCast(textures.add_element(tex) orelse return error.OutOfTextures);
+    if (default_texture == 0) default_texture = handle;
+    return handle;
+}
+
+pub fn update_texture(handle: Texture.Handle, data: []align(16) u8) void {
+    if (surface.is_system_closing()) return;
+
+    const tex = texture_slot(handle) orelse return;
+    const size = texture_size(tex.width, tex.height);
+    if (data.len < size) return;
+
+    upload_texture_data(tex, data[0..size]) catch return;
+    if (frame_started and bound_texture == handle) bind_current_texture();
+}
+
+pub fn bind_texture(handle: Texture.Handle) void {
+    if (surface.is_system_closing()) return;
+    if (bound_texture == handle) return;
+    bound_texture = handle;
+    if (frame_started) bind_current_texture();
+}
+
+pub fn destroy_texture(handle: Texture.Handle) void {
+    if (surface.is_system_closing()) {
+        if (bound_texture == handle) bound_texture = 0;
+        if (default_texture == handle) default_texture = 0;
+        _ = textures.remove_element(handle);
+        return;
+    }
+
+    if (texture_slot(handle)) |tex| free_texture(tex);
+    if (bound_texture == handle) bound_texture = 0;
+    if (default_texture == handle) default_texture = 0;
+    _ = textures.remove_element(handle);
+    if (frame_started) bind_current_texture();
+}
+
+pub fn force_texture_resident(_: Texture.Handle) void {}
+
+fn init_command_resources() !void {
+    command_pool = try device.createCommandPool(.no_preheat, null);
+    errdefer {
+        device.destroyCommandPool(command_pool, null);
+        command_pool = .null;
+    }
+
+    var buffers: [1]mango.CommandBuffer = undefined;
+    try device.allocateCommandBuffers(.{
+        .pool = command_pool,
+        .command_buffer_count = buffers.len,
+    }, &buffers);
+    command_buffer = buffers[0];
+    command_resources_initialized = true;
+}
+
+fn deinit_command_resources() void {
+    if (!command_resources_initialized or device == .null) return;
+    if (command_buffer != .null) {
+        device.freeCommandBuffers(command_pool, &.{command_buffer});
+        command_buffer = .null;
+    }
+    if (command_pool != .null) {
+        device.destroyCommandPool(command_pool, null);
+        command_pool = .null;
+    }
+    command_resources_initialized = false;
+}
+
+fn init_render_target() !void {
+    const color_size = mango.Format.a8b8g8r8_unorm.scale(@as(usize, TARGET_WIDTH) * TARGET_HEIGHT);
+    const depth_size = mango.Format.d24_unorm_s8_uint.scale(@as(usize, TARGET_WIDTH) * TARGET_HEIGHT);
+
+    const color_memory = try device.allocateMemory(.{
+        .memory_type = .vram_a,
+        .allocation_size = .size(@intCast(color_size)),
+    }, null);
+    errdefer device.freeMemory(color_memory, null);
+
+    const depth_memory = try device.allocateMemory(.{
+        .memory_type = .vram_b,
+        .allocation_size = .size(@intCast(depth_size)),
+    }, null);
+    errdefer device.freeMemory(depth_memory, null);
+
+    const color_image = try device.createImage(.{
+        .flags = .{},
+        .type = .@"2d",
+        .tiling = .optimal,
+        .usage = .{ .transfer_src = true, .color_attachment = true },
+        .extent = .{ .width = TARGET_WIDTH, .height = TARGET_HEIGHT },
+        .format = .a8b8g8r8_unorm,
+        .mip_levels = .@"1",
+        .array_layers = .@"1",
+    }, null);
+    errdefer device.destroyImage(color_image, null);
+    try device.bindImageMemory(color_image, color_memory, .size(0));
+
+    const depth_image = try device.createImage(.{
+        .flags = .{},
+        .type = .@"2d",
+        .tiling = .optimal,
+        .usage = .{ .depth_stencil_attachment = true },
+        .extent = .{ .width = TARGET_WIDTH, .height = TARGET_HEIGHT },
+        .format = .d24_unorm_s8_uint,
+        .mip_levels = .@"1",
+        .array_layers = .@"1",
+    }, null);
+    errdefer device.destroyImage(depth_image, null);
+    try device.bindImageMemory(depth_image, depth_memory, .size(0));
+
+    const color_view = try device.createImageView(.{
+        .type = .@"2d",
+        .format = .a8b8g8r8_unorm,
+        .image = color_image,
+        .subresource_range = .full,
+    }, null);
+    errdefer device.destroyImageView(color_view, null);
+
+    const depth_view = try device.createImageView(.{
+        .type = .@"2d",
+        .format = .d24_unorm_s8_uint,
+        .image = depth_image,
+        .subresource_range = .full,
+    }, null);
+    errdefer device.destroyImageView(depth_view, null);
+
+    const color_pixels = try device.mapMemory(color_memory, .size(0), .whole);
+
+    render_target = .{
+        .color_memory = color_memory,
+        .depth_memory = depth_memory,
+        .color_image = color_image,
+        .depth_image = depth_image,
+        .color_view = color_view,
+        .depth_view = depth_view,
+        .color_pixels = color_pixels,
+    };
+    render_target_initialized = true;
+}
+
+fn deinit_render_target() void {
+    if (!render_target_initialized or device == .null) return;
+    device.unmapMemory(render_target.color_memory);
+    device.destroyImageView(render_target.depth_view, null);
+    device.destroyImageView(render_target.color_view, null);
+    device.destroyImage(render_target.depth_image, null);
+    device.destroyImage(render_target.color_image, null);
+    device.freeMemory(render_target.depth_memory, null);
+    device.freeMemory(render_target.color_memory, null);
+    render_target_initialized = false;
+}
+
+fn init_pipeline() !PipelineData {
+    const code: []const u8 = &shaders.basic_vert;
+    const shader = try device.createShader(.init(.psh, code, "main"), null);
+    errdefer device.destroyShader(shader, null);
+
+    const bindings = [_]mango.VertexInputBindingDescription{
+        .{ .stride = VERTEX_STRIDE },
+    };
+    const attributes = [_]mango.VertexInputAttributeDescription{
+        .{ .location = .v0, .binding = .@"0", .format = .r16g16b16a16_sscaled, .offset = 0 },
+        .{ .location = .v1, .binding = .@"0", .format = .r8g8b8a8_uscaled, .offset = 8 },
+        .{ .location = .v2, .binding = .@"0", .format = .r16g16_sscaled, .offset = 12 },
+    };
+    const vertex_input = try device.createVertexInputLayout(.init(&bindings, &attributes, &.{}), null);
+    errdefer device.destroyVertexInputLayout(vertex_input, null);
+
+    const sampler = try device.createSampler(.{
+        .mag_filter = .nearest,
+        .min_filter = .nearest,
+        .mip_filter = .nearest,
+        .address_mode_u = .repeat,
+        .address_mode_v = .repeat,
+        .lod_bias = 0.0,
+        .min_lod = 0,
+        .max_lod = 0,
+        .border_color = .{ 0, 0, 0, 0 },
+    }, null);
+
+    return .{
+        .shader = shader,
+        .vertex_input = vertex_input,
+        .sampler = sampler,
+    };
+}
+
+fn deinit_pipeline(pl: *PipelineData) void {
+    device.destroySampler(pl.sampler, null);
+    device.destroyVertexInputLayout(pl.vertex_input, null);
+    device.destroyShader(pl.shader, null);
+}
+
+fn clear_frame_targets() !void {
+    try fill_queue.clearColorImage(.{
+        .image = render_target.color_image,
+        .color = clear_color,
+        .subresource_range = .full,
+    });
+    try clear_depth_target();
+}
+
+fn clear_depth_target() !void {
+    try fill_queue.clearDepthStencilImage(.{
+        .image = render_target.depth_image,
+        .depth = 1.0,
+        .stencil = 0,
+        .subresource_range = .full,
+    });
+    // device.waitIdle();
+}
+
+fn begin_command_buffer() !void {
+    bound_mesh = 0;
+
+    try command_buffer.begin();
+    command_buffer.bindShaders(&.{.vertex}, &.{render_pipeline.shader});
+    command_buffer.setVertexInput(render_pipeline.vertex_input);
+    command_buffer.setLightingEnable(false);
+    command_buffer.setLightEnvironmentEnable(.{});
+    command_buffer.setLogicOpEnable(false);
+    command_buffer.setAlphaTestCompareOp(.gt);
+    command_buffer.setAlphaTestReference(ALPHA_TEST_REFERENCE);
+    command_buffer.setStencilTestEnable(false);
+    command_buffer.setDepthTestEnable(true);
+    command_buffer.setDepthMode(.z_buffer);
+    command_buffer.setDepthCompareOp(.lt);
+    command_buffer.setPrimitiveTopology(.triangle_list);
+    command_buffer.setFrontFace(.ccw);
+    command_buffer.setColorWriteMask(.rgba);
+    command_buffer.setViewport(.{
+        .rect = .{ .offset = .{ .x = 0, .y = 0 }, .extent = .{ .width = TARGET_WIDTH, .height = TARGET_HEIGHT } },
+        .min_depth = 0.0,
+        .max_depth = 1.0,
+    });
+    command_buffer.setScissor(.inside(.{
+        .offset = .{ .x = 0, .y = 0 },
+        .extent = .{ .width = TARGET_WIDTH, .height = TARGET_HEIGHT },
+    }));
+    apply_dynamic_state();
+    bind_current_texture();
+    apply_fog_state();
+    upload_frame_uniforms();
+    command_buffer.beginRendering(.{
+        .color_attachment = render_target.color_view,
+        .depth_stencil_attachment = render_target.depth_view,
+    });
+}
+
+fn finish_command_buffer() !void {
+    if (trace_frame_active) {
+        trace_submit_index += 1;
+        log.info("trace: 3ds frame {d} submit {d} begin", .{ trace_frame_index, trace_submit_index });
+    }
+    command_buffer.endRendering();
+    if (trace_frame_active) log.info("trace: 3ds frame {d} submit {d} end rendering done", .{ trace_frame_index, trace_submit_index });
+    try command_buffer.end();
+    if (trace_frame_active) log.info("trace: 3ds frame {d} submit {d} command buffer end done", .{ trace_frame_index, trace_submit_index });
+    if (surface.is_system_closing()) return;
+    try submit_queue.submit(.{ .command_buffer = command_buffer });
+    if (trace_frame_active) log.info("trace: 3ds frame {d} submit {d} queued", .{ trace_frame_index, trace_submit_index });
+}
+
+fn present_render_target() void {
+    if (surface.is_system_closing()) return;
+    var fb_width: u16 = 0;
+    var fb_height: u16 = 0;
+    const framebuffer = c.gfxGetFramebuffer(c.GFX_TOP, c.GFX_LEFT, &fb_width, &fb_height) orelse return;
+    if (surface.is_system_closing()) return;
+
+    _ = c.GX_DisplayTransfer(
+        @ptrCast(@alignCast(render_target.color_pixels.ptr)),
+        gx_buffer_dim(TARGET_WIDTH, TARGET_HEIGHT),
+        @ptrCast(@alignCast(framebuffer)),
+        gx_buffer_dim(TARGET_WIDTH, TARGET_HEIGHT),
+        DISPLAY_TRANSFER_FLAGS,
+    );
+    if (surface.is_system_closing()) return;
+    if (trace_frame_active) log.info("trace: 3ds frame {d} present wait ppf begin", .{trace_frame_index});
+    c.gspWaitForEvent(c.GSPGPU_EVENT_PPF, false);
+    if (trace_frame_active) log.info("trace: 3ds frame {d} present wait ppf end", .{trace_frame_index});
+    if (surface.is_system_closing()) return;
+    c.gfxSwapBuffers();
+    if (trace_frame_active) log.info("trace: 3ds frame {d} swap buffers done", .{trace_frame_index});
+    if (surface.is_system_closing()) return;
+    if (trace_frame_active and vsync_enabled) log.info("trace: 3ds frame {d} wait vblank begin", .{trace_frame_index});
+    // PPF can cross VBlank. Waiting for the "next" VBlank here would discard
+    // that event and force an extra display interval, effectively capping at
+    // 30 FPS when the frame finishes near the refresh boundary.
+    if (vsync_enabled) c.gspWaitForEvent(c.GSPGPU_EVENT_VBlank0, false);
+    if (trace_frame_active and vsync_enabled) log.info("trace: 3ds frame {d} wait vblank end", .{trace_frame_index});
+}
+
+fn apply_dynamic_state() void {
+    command_buffer.setDepthWriteEnable(depth_write_enabled);
+    command_buffer.setCullMode(if (cull_face_enabled) .back else .none);
+    command_buffer.setAlphaTestEnable(alpha_blend_enabled);
+    command_buffer.setBlendEquation(if (alpha_blend_enabled) .{
+        .src_color_factor = .src_alpha,
+        .dst_color_factor = .one_minus_src_alpha,
+        .color_op = .add,
+        .src_alpha_factor = .one,
+        .dst_alpha_factor = .one_minus_src_alpha,
+        .alpha_op = .add,
+    } else .{
+        .src_color_factor = .one,
+        .dst_color_factor = .zero,
+        .color_op = .add,
+        .src_alpha_factor = .one,
+        .dst_alpha_factor = .zero,
+        .alpha_op = .add,
+    });
+}
+
+fn bind_current_texture() void {
+    if (!frame_started) return;
+
+    const effective_texture = if (bound_texture != 0) bound_texture else default_texture;
+    if (effective_texture == 0) {
+        command_buffer.bindCombinedImageSamplers(0, &.{mango.CombinedImageSampler.none});
+        bind_texenv(false);
+        return;
+    }
+
+    const tex = texture_slot(effective_texture) orelse {
+        command_buffer.bindCombinedImageSamplers(0, &.{mango.CombinedImageSampler.none});
+        bind_texenv(false);
+        return;
+    };
+
+    command_buffer.bindCombinedImageSamplers(0, &.{.{
+        .image = tex.view,
+        .sampler = render_pipeline.sampler,
+    }});
+    bind_texenv(true);
+}
+
+fn bind_texenv(textured: bool) void {
+    const stages = if (textured) &texenv_textured else &texenv_untextured;
+    command_buffer.setTextureCombiners(stages, &texenv_buffer_sources);
+}
+
+fn apply_fog_state() void {
+    command_buffer.setAetherFog(fog_state.enabled, fog_state.color, if (fog_state.enabled) &fog_state.table else &.{});
+}
+
+fn upload_frame_uniforms() void {
+    const projection_rows = mat4_to_uniform_rows(Mat4.mul(proj_matrix, projection_transform));
+    const constants = [3][4]f32{
+        POS_SCALE,
+        .{ UV_SCALE[0], UV_SCALE[1], uv_offset[0], uv_offset[1] },
+        COLOR_SCALE,
+    };
+
+    command_buffer.bindFloatUniforms(.vertex, 0, &projection_rows);
+    command_buffer.bindFloatUniforms(.vertex, 8, &constants);
+}
+
+fn upload_draw_uniforms(model: *const Mat4) void {
+    const model_view_rows = mat4_to_uniform_rows(Mat4.mul(model.*, view_matrix));
+    command_buffer.bindFloatUniforms(.vertex, 4, &model_view_rows);
+}
+
+fn mat4_to_uniform_rows(mat: Mat4) [4][4]f32 {
+    var out: [4][4]f32 = undefined;
+    inline for (0..4) |row| {
+        out[row] = .{ mat.data[0][row], mat.data[1][row], mat.data[2][row], mat.data[3][row] };
+    }
+    return out;
+}
+
+fn mat4_bits_equal(a: *const Mat4, b: *const Mat4) bool {
+    return std.mem.eql(u8, std.mem.asBytes(a), std.mem.asBytes(b));
+}
+
+fn float_bits_equal(a: f32, b: f32) bool {
+    return @as(u32, @bitCast(a)) == @as(u32, @bitCast(b));
+}
+
+fn init_projection_transform() void {
+    projection_transform = Mat4.mul(logical_viewport_transform(), ortho_tilt(0.0, @floatFromInt(SCREEN_WIDTH), 0.0, @floatFromInt(SCREEN_HEIGHT), 0.0, 1.0));
+}
+
+fn logical_viewport_transform() Mat4 {
+    return .{ .data = .{
+        .{ @as(f32, @floatFromInt(SCREEN_WIDTH)) * 0.5, 0.0, 0.0, 0.0 },
+        .{ 0.0, @as(f32, @floatFromInt(SCREEN_HEIGHT)) * 0.5, 0.0, 0.0 },
+        .{ 0.0, 0.0, -1.0, 0.0 },
+        .{ @as(f32, @floatFromInt(SCREEN_WIDTH)) * 0.5, @as(f32, @floatFromInt(SCREEN_HEIGHT)) * 0.5, 1.0, 1.0 },
+    } };
+}
+
+// Aether Mat4 uses row-vector multiplication. This is Citro3D's
+// Mtx_OrthoTilt transposed into that convention; mat4_to_uniform_rows()
+// transposes it back for the PICA shader's matrix * vector dp4 sequence.
+fn ortho_tilt(left: f32, right: f32, bottom: f32, top: f32, near: f32, far: f32) Mat4 {
+    const rl = right - left;
+    const tb = top - bottom;
+    const fnv = far - near;
+    return .{ .data = .{
+        .{ 0.0, -2.0 / rl, 0.0, 0.0 },
+        .{ 2.0 / tb, 0.0, 0.0, 0.0 },
+        .{ 0.0, 0.0, 1.0 / fnv, 0.0 },
+        .{ -((top + bottom) / tb), (right + left) / rl, 0.5 * ((near + far) / (near - far)) - 0.5, 1.0 },
+    } };
+}
+
+fn ensure_mesh_capacity(mesh: *MeshData, len: usize) !void {
+    if (mesh.memory != .null and mesh.capacity >= len and mesh.buffer != .null) return;
+
+    free_mesh(mesh);
+
+    const cap = std.mem.alignForward(usize, @max(len, 256), CACHE_LINE_SIZE);
+    const memory = try device.allocateMemory(.{
+        .memory_type = .fcram_cached,
+        .allocation_size = .size(@intCast(cap)),
+    }, null);
+    errdefer device.freeMemory(memory, null);
+
+    const buffer = try device.createBuffer(.{
+        .size = .size(@intCast(cap)),
+        .usage = .{ .vertex_buffer = true },
+    }, null);
+    errdefer device.destroyBuffer(buffer, null);
+
+    try device.bindBufferMemory(buffer, memory, .size(0));
+    const mapped = try device.mapMemory(memory, .size(0), .whole);
+    if (!is_linear_fcram(mapped.ptr, mapped.len)) {
+        std.debug.panic("3ds_gfx: mesh upload buffer must be allocated in linear FCRAM", .{});
+    }
+
+    mesh.* = .{
+        .memory = memory,
+        .buffer = buffer,
+        .mapped = mapped,
+        .capacity = cap,
+        .len = 0,
+    };
+}
+
+fn bind_mesh_to_linear_slice(mesh: *MeshData, data: []const u8) !void {
+    if (mesh.memory != .null) free_mesh(mesh);
+
+    const buffer = if (mesh.buffer != .null)
+        mesh.buffer
+    else
+        try create_external_vertex_buffer();
+
+    mango.updateAetherLinearVertexBuffer(buffer, data.ptr, data.len, @intCast(c.osConvertVirtToPhys(data.ptr)));
+
+    mesh.* = .{
+        .memory = .null,
+        .buffer = buffer,
+        .mapped = &.{},
+        .len = data.len,
+        .capacity = data.len,
+    };
+}
+
+fn create_external_vertex_buffer() !mango.Buffer {
+    return mango.createAetherLinearVertexBuffer(render_alloc);
+}
+
+fn free_mesh(mesh: *MeshData) void {
+    if (mesh.buffer != .null or mesh.memory != .null) {
+        if (frame_started) {
+            defer_mesh_free(.{ .memory = mesh.memory, .buffer = mesh.buffer });
+        } else {
+            destroy_mesh_resources(mesh.memory, mesh.buffer);
+        }
+    }
+    mesh.* = .{};
+}
+
+fn destroy_mesh_resources(memory: mango.DeviceMemory, buffer: mango.Buffer) void {
+    if (buffer != .null) device.destroyBuffer(buffer, null);
+    if (memory != .null) {
+        device.unmapMemory(memory);
+        device.freeMemory(memory, null);
+    }
+}
+
+fn defer_mesh_free(free: DeferredMeshFree) void {
+    if (deferred_mesh_frees.add_element(free) != null) return;
+    std.debug.panic("3ds_gfx: deferred mesh free queue exhausted", .{});
+}
+
+fn free_deferred_mesh_resources() void {
+    for (1..deferred_mesh_frees.buffer.len) |i| {
+        if (deferred_mesh_frees.buffer[i]) |free| {
+            destroy_mesh_resources(free.memory, free.buffer);
+        }
+    }
+    deferred_mesh_frees.clear();
+}
+
+fn abandon_service_resources() void {
+    frame_started = false;
+    initialized = false;
+    render_pipeline_initialized = false;
+    render_target_initialized = false;
+    command_resources_initialized = false;
+    device = .null;
+    submit_queue = .null;
+    fill_queue = .null;
+    default_texture = 0;
+    bound_texture = 0;
+    meshes.clear();
+    textures.clear();
+    deferred_mesh_frees.clear();
+}
+
+fn mesh_draw_bytes_needed(count: usize) ?usize {
+    if (count == 0) return 0;
+    if (count > std.math.maxInt(usize) / VERTEX_STRIDE) return null;
+    return count * VERTEX_STRIDE;
+}
+
+fn create_texture_resources(width: u32, height: u32) !TextureData {
+    const size = texture_size(width, height);
+    const upload_mode = texture_upload_mode(width, height);
+    // 3DSX launchers can map VRAM read-only for the CPU. Keep texture
+    // storage in linear FCRAM; PICA can still sample it by physical address,
+    // and the transfer queue can still write tiled output here.
+    const memory = try device.allocateMemory(.{
+        .memory_type = .fcram_cached,
+        .allocation_size = .size(size),
+    }, null);
+    errdefer device.freeMemory(memory, null);
+
+    const image = try device.createImage(.{
+        .flags = .{},
+        .type = .@"2d",
+        .tiling = .optimal,
+        .usage = .{ .sampled = true, .transfer_dst = true },
+        .extent = .{ .width = @intCast(width), .height = @intCast(height) },
+        .format = .a8b8g8r8_unorm,
+        .mip_levels = .@"1",
+        .array_layers = .@"1",
+    }, null);
+    errdefer device.destroyImage(image, null);
+    try device.bindImageMemory(image, memory, .size(0));
+
+    const view = try device.createImageView(.{
+        .type = .@"2d",
+        .format = .a8b8g8r8_unorm,
+        .image = image,
+        .subresource_range = .full,
+    }, null);
+
+    return .{
+        .width = width,
+        .height = height,
+        .upload_mode = upload_mode,
+        .memory = memory,
+        .image = image,
+        .view = view,
+    };
+}
+
+fn free_texture(tex: *TextureData) void {
+    device.destroyImageView(tex.view, null);
+    device.destroyImage(tex.image, null);
+    device.freeMemory(tex.memory, null);
+}
+
+fn validate_texture(width: u32, height: u32, data: []align(16) u8) !void {
+    if (width < MIN_TEXTURE_SIZE or height < MIN_TEXTURE_SIZE) {
+        Util.engine_logger.err("3ds_gfx: texture {d}x{d} is too small; 3DS requires at least {d}x{d}", .{
+            width,
+            height,
+            MIN_TEXTURE_SIZE,
+            MIN_TEXTURE_SIZE,
+        });
+        return error.TextureTooSmall;
+    }
+    if (width > MAX_TEXTURE_SIZE or height > MAX_TEXTURE_SIZE) {
+        Util.engine_logger.err("3ds_gfx: texture {d}x{d} is too large; 3DS limit is {d}x{d}", .{
+            width,
+            height,
+            MAX_TEXTURE_SIZE,
+            MAX_TEXTURE_SIZE,
+        });
+        return error.TextureTooLarge;
+    }
+    if (!std.math.isPowerOfTwo(width) or !std.math.isPowerOfTwo(height)) {
+        Util.engine_logger.err("3ds_gfx: texture {d}x{d} is unsupported; 3DS textures require power-of-two dimensions", .{ width, height });
+        return error.UnsupportedTextureSize;
+    }
+
+    const size = texture_size(width, height);
+    if (data.len < size) return error.InsufficientData;
+}
+
+fn upload_texture_data(tex: *TextureData, data: []align(16) const u8) !void {
+    switch (tex.upload_mode) {
+        .cpu_tiled => return upload_texture_data_cpu(tex, data),
+        .transfer_tiled => return upload_texture_data_transfer(tex, data),
+    }
+}
+
+fn upload_texture_data_cpu(tex: *TextureData, data: []align(16) const u8) !void {
+    const mapped = try device.mapMemory(tex.memory, .size(0), .whole);
+    defer device.unmapMemory(tex.memory);
+
+    @memset(mapped, 0);
+    convert_texture_data_tiled_abgr(mapped, data, tex.width, tex.height);
+    try flush_memory(tex.memory, mapped.len);
+    device.waitIdle();
+}
+
+fn upload_texture_data_transfer(tex: *TextureData, data: []align(16) const u8) !void {
+    const size = texture_size(tex.width, tex.height);
+
+    const staging_memory = try device.allocateMemory(.{
+        .memory_type = .fcram_cached,
+        .allocation_size = .size(size),
+    }, null);
+    defer device.freeMemory(staging_memory, null);
+
+    const staging_buffer = try device.createBuffer(.{
+        .size = .size(size),
+        .usage = .{ .transfer_src = true },
+    }, null);
+    defer device.destroyBuffer(staging_buffer, null);
+    try device.bindBufferMemory(staging_buffer, staging_memory, .size(0));
+
+    const mapped = try device.mapMemory(staging_memory, .size(0), .size(size));
+    defer device.unmapMemory(staging_memory);
+
+    convert_texture_data_linear_abgr(mapped, data, tex.width, tex.height);
+    try flush_memory(staging_memory, mapped.len);
+
+    try device.getQueue(.transfer).copyBufferToImage(.{
+        .src_buffer = staging_buffer,
+        .src_offset = .size(0),
+        .dst_image = tex.image,
+        .dst_subresource = .full,
+    });
+    device.waitIdle();
+}
+
+fn convert_texture_data_tiled_abgr(dst: []u8, src: []align(16) const u8, width: u32, height: u32) void {
+    for (0..height) |y| {
+        const yu: u32 = @intCast(y);
+        const dst_y = height - 1 - yu;
+        for (0..width) |x| {
+            const xu: u32 = @intCast(x);
+            const src_off = (@as(usize, yu) * width + xu) * TEX_BPP;
+            const dst_off = tiled_pixel_offset(width, xu, dst_y);
+            write_abgr8888(dst[dst_off..][0..TEX_BPP], src[src_off..][0..TEX_BPP]);
+        }
+    }
+}
+
+fn convert_texture_data_linear_abgr(dst: []u8, src: []align(16) const u8, width: u32, height: u32) void {
+    for (0..height) |y| {
+        const yu: u32 = @intCast(y);
+        const src_y = height - 1 - yu;
+        for (0..width) |x| {
+            const xu: u32 = @intCast(x);
+            const src_off = (@as(usize, src_y) * width + xu) * TEX_BPP;
+            const dst_off = (@as(usize, yu) * width + xu) * TEX_BPP;
+            write_abgr8888(dst[dst_off..][0..TEX_BPP], src[src_off..][0..TEX_BPP]);
+        }
+    }
+}
+
+fn write_abgr8888(dst: []u8, src_rgba: []const u8) void {
+    dst[0] = src_rgba[3];
+    dst[1] = src_rgba[2];
+    dst[2] = src_rgba[1];
+    dst[3] = src_rgba[0];
+}
+
+fn tiled_pixel_offset(width: u32, x: u32, y: u32) usize {
+    const tile_size = 8;
+    const tile_pixels = tile_size * tile_size;
+    const tile_x = x / tile_size;
+    const tile_y = y / tile_size;
+    const tiles_per_row = width / tile_size;
+    const subtile_x: u3 = @intCast(x & (tile_size - 1));
+    const subtile_y: u3 = @intCast(y & (tile_size - 1));
+    const subtile = pica.morton.toIndex(u3, 2, .{ subtile_x, subtile_y });
+    const pixel = (tile_y * tiles_per_row + tile_x) * tile_pixels + subtile;
+    return @as(usize, pixel) * TEX_BPP;
+}
+
+fn texture_upload_mode(width: u32, height: u32) TextureUploadMode {
+    // GX_DisplayTransfer needs at least 64x16 for linear<->tiled transfers.
+    // Smaller textures are still valid sampled images, so keep them on the
+    // CPU Morton path.
+    return if (width >= 64 and height >= 16) .transfer_tiled else .cpu_tiled;
+}
+
+fn texture_size(width: u32, height: u32) u32 {
+    return @intCast(@as(usize, width) * height * TEX_BPP);
+}
+
+fn rebuild_fog_table() void {
+    const safe_end = if (fog_state.end <= fog_state.start) fog_state.start + 0.001 else fog_state.end;
+    const lut_near = @min(FOG_LUT_NEAR, safe_end * 0.5);
+    const lut_far = @max(safe_end, lut_near + 0.001);
+
+    var values: [129]f32 = undefined;
+    for (&values, 0..) |*value, i| {
+        const t = @as(f32, @floatFromInt(i)) / 128.0;
+        const distance = fog_lut_calc_z(1.0 - t, lut_near, lut_far);
+        const factor = std.math.clamp((safe_end - distance) / (safe_end - fog_state.start), 0.0, 1.0);
+        value.* = factor;
+    }
+
+    for (&fog_state.table, 0..) |*raw, i| {
+        const current = values[i];
+        const next = values[i + 1];
+        const lut_value = pica.Graphics.TextureCombiners.FogLutValue{
+            .value = .ofSaturating(current),
+            .next_difference = .ofSaturating(next - current),
+        };
+        raw.* = @bitCast(zitrus.hardware.LsbRegister(pica.Graphics.TextureCombiners.FogLutValue).init(lut_value));
+    }
+}
+
+fn fog_lut_calc_z(depth: f32, near: f32, far: f32) f32 {
+    return far * near / (depth * (far - near) + near);
+}
+
+fn flush_memory(memory: mango.DeviceMemory, len: usize) !void {
+    try device.flushMappedMemoryRanges(&.{.{
+        .memory = memory,
+        .offset = .size(0),
+        .size = .size(@intCast(len)),
+    }});
+}
+
+fn flush_linear_memory(ptr: [*]const u8, len: usize) !void {
+    if (len == 0) return;
+    if (c.GSPGPU_FlushDataCache(ptr, @intCast(len)) != 0) return error.Unexpected;
+}
+
+fn mesh_slot(handle: Mesh.Handle) ?*MeshData {
+    const idx: usize = handle;
+    if (idx == 0 or idx >= meshes.buffer.len) return null;
+    if (meshes.buffer[idx]) |*mesh| return mesh;
+    return null;
+}
+
+fn texture_slot(handle: Texture.Handle) ?*TextureData {
+    const idx: usize = handle;
+    if (idx == 0 or idx >= textures.buffer.len) return null;
+    if (textures.buffer[idx]) |*tex| return tex;
+    return null;
+}
+
+fn unorm8_scale() f32 {
+    return 1.0 / 255.0;
+}
+
+fn snorm16_scale() f32 {
+    return 1.0 / 32767.0;
+}
+
+fn float_to_u8(v: f32) u8 {
+    return @intFromFloat(std.math.clamp(v, 0.0, 1.0) * 255.0);
+}
+
+fn is_linear_fcram(ptr: [*]const u8, len: usize) bool {
+    const start = @intFromPtr(ptr);
+    return in_range(start, len, OS_FCRAM_VADDR, OS_FCRAM_SIZE) or
+        in_range(start, len, OS_OLD_FCRAM_VADDR, OS_OLD_FCRAM_SIZE);
+}
+
+fn in_range(start: usize, len: usize, base: usize, size: usize) bool {
+    if (start < base) return false;
+    const offset = start - base;
+    return offset <= size and len <= size - offset;
+}
diff --git a/src/platform/3ds/3ds_thread.zig b/src/platform/3ds/3ds_thread.zig
new file mode 100644
index 0000000..1231f84
--- /dev/null
+++ b/src/platform/3ds/3ds_thread.zig
@@ -0,0 +1,84 @@
+//! 3DS thread backend -- wraps libctru's `threadCreate`/`threadJoin`.
+
+const std = @import("std");
+const c = @import("../nintendo_c.zig").c;
+const api = @import("../thread_api.zig");
+
+pub const Handle = c.Thread;
+
+fn priority_to_3ds(p: api.Priority) c_int {
+    return switch (p) {
+        .highest => 0x18,
+        .high => 0x20,
+        .normal => 0x30,
+        .low => 0x38,
+        .lowest => 0x3f,
+    };
+}
+
+fn priority_from_3ds(v: c_int) api.Priority {
+    if (v <= 0x18) return .highest;
+    if (v <= 0x20) return .high;
+    if (v <= 0x30) return .normal;
+    if (v <= 0x38) return .low;
+    return .lowest;
+}
+
+pub fn spawn(cfg: api.Config, comptime func: anytype, args: anytype) !Handle {
+    const alloc = cfg.allocator orelse return error.AllocatorRequired;
+
+    const Args = @TypeOf(args);
+    const Instance = struct {
+        fn_args: Args,
+        allocator: std.mem.Allocator,
+
+        fn entry(raw: ?*anyopaque) callconv(.c) void {
+            const self: *@This() = @ptrCast(@alignCast(raw.?));
+            const a = self.allocator;
+            const Ret = @typeInfo(@TypeOf(func)).@"fn".return_type.?;
+
+            switch (@typeInfo(Ret)) {
+                .void, .noreturn => @call(.auto, func, self.fn_args),
+                .error_union => @call(.auto, func, self.fn_args) catch |e| {
+                    std.log.err("aether thread errored: {s}", .{@errorName(e)});
+                },
+                else => @compileError("thread fn must return void, !void, or noreturn"),
+            }
+            a.destroy(self);
+        }
+    };
+
+    const inst = try alloc.create(Instance);
+    errdefer alloc.destroy(inst);
+    inst.* = .{ .fn_args = args, .allocator = alloc };
+
+    const thread = c.threadCreate(
+        Instance.entry,
+        inst,
+        cfg.stack_size,
+        priority_to_3ds(cfg.priority),
+        -2,
+        false,
+    ) orelse return error.SystemResources;
+
+    return thread;
+}
+
+pub fn join(thread: Handle) void {
+    _ = c.threadJoin(thread, std.math.maxInt(u64));
+    c.threadFree(thread);
+}
+
+pub fn set_priority(thread: Handle, p: api.Priority) anyerror!void {
+    const handle = c.threadGetHandle(thread);
+    if (c.svcSetThreadPriority(handle, priority_to_3ds(p)) != 0)
+        return error.SystemResources;
+}
+
+pub fn current_priority() api.Priority {
+    var p: c.s32 = priority_to_3ds(.normal);
+    const current = c.threadGetCurrent() orelse return .normal;
+    const handle = c.threadGetHandle(current);
+    if (c.svcGetThreadPriority(&p, handle) != 0) return .normal;
+    return priority_from_3ds(p);
+}
diff --git a/src/platform/3ds/input.zig b/src/platform/3ds/input.zig
new file mode 100644
index 0000000..a93abe7
--- /dev/null
+++ b/src/platform/3ds/input.zig
@@ -0,0 +1,253 @@
+//! 3DS input backend. Polls libctru HID once per engine update and
+//! translates button, circle-pad, C-stick, trigger, touch, and software
+//! keyboard state into Aether's core input events.
+
+const std = @import("std");
+const core = @import("../../core/input/input.zig");
+const surface = @import("surface.zig");
+
+const Result = c_int;
+
+const TouchPosition = extern struct {
+    px: u16,
+    py: u16,
+};
+
+const CirclePosition = extern struct {
+    dx: i16,
+    dy: i16,
+};
+
+extern fn hidInit() Result;
+extern fn hidExit() void;
+extern fn hidScanInput() void;
+extern fn hidKeysHeld() u32;
+extern fn hidTouchRead(pos: *TouchPosition) void;
+extern fn hidCircleRead(pos: *CirclePosition) void;
+
+extern fn swkbdInit(swkbd: *anyopaque, typ: c_int, num_buttons: c_int, max_text_length: c_int) void;
+extern fn swkbdSetFeatures(swkbd: *anyopaque, features: u32) void;
+extern fn swkbdSetHintText(swkbd: *anyopaque, text: [*:0]const u8) void;
+extern fn swkbdSetButton(swkbd: *anyopaque, button: c_int, text: [*:0]const u8, submit: bool) void;
+extern fn swkbdSetInitialText(swkbd: *anyopaque, text: [*:0]const u8) void;
+extern fn swkbdInputText(swkbd: *anyopaque, buf: [*]u8, bufsize: usize) c_int;
+
+const KEY_A: u32 = 1 << 0;
+const KEY_B: u32 = 1 << 1;
+const KEY_SELECT: u32 = 1 << 2;
+const KEY_START: u32 = 1 << 3;
+const KEY_DRIGHT: u32 = 1 << 4;
+const KEY_DLEFT: u32 = 1 << 5;
+const KEY_DUP: u32 = 1 << 6;
+const KEY_DDOWN: u32 = 1 << 7;
+const KEY_R: u32 = 1 << 8;
+const KEY_L: u32 = 1 << 9;
+const KEY_X: u32 = 1 << 10;
+const KEY_Y: u32 = 1 << 11;
+const KEY_ZL: u32 = 1 << 14;
+const KEY_ZR: u32 = 1 << 15;
+const KEY_TOUCH: u32 = 1 << 20;
+const KEY_CSTICK_RIGHT: u32 = 1 << 24;
+const KEY_CSTICK_LEFT: u32 = 1 << 25;
+const KEY_CSTICK_UP: u32 = 1 << 26;
+const KEY_CSTICK_DOWN: u32 = 1 << 27;
+
+const CIRCLE_PAD_MAX: f32 = 156.0;
+const MAX_TEXT_BYTES: usize = 1024;
+const SWKBD_STATE_BYTES: usize = 0x1000;
+const SWKBD_TYPE_NORMAL: c_int = 0;
+const SWKBD_BUTTON_LEFT: c_int = 0;
+const SWKBD_BUTTON_RIGHT: c_int = 2;
+const SWKBD_DARKEN_TOP_SCREEN: u32 = 1 << 1;
+const SWKBD_MULTILINE: u32 = 1 << 3;
+const SWKBD_DEFAULT_QWERTY: u32 = 1 << 9;
+
+const axis_count = @typeInfo(core.Axis).@"enum".fields.len;
+
+var initialized: bool = false;
+var prev_keys: u32 = 0;
+var prev_axes: [axis_count]f32 = @splat(0.0);
+var prev_touch_down: bool = false;
+var prev_touch_pos: core.Vec2 = .{};
+
+pub fn setup(_: std.mem.Allocator, _: std.Io) void {
+    initialized = false;
+    prev_keys = 0;
+    prev_axes = @splat(0.0);
+    prev_touch_down = false;
+    prev_touch_pos = .{};
+}
+
+pub fn init() anyerror!void {
+    if (hidInit() != 0) return error.InputInitFailed;
+    initialized = true;
+}
+
+pub fn deinit() void {
+    if (!initialized) return;
+    if (surface.is_system_closing()) {
+        initialized = false;
+        return;
+    }
+    hidExit();
+    initialized = false;
+}
+
+pub fn pump() void {
+    hidScanInput();
+    const keys = hidKeysHeld();
+
+    diff_buttons(keys);
+    pump_axes(keys);
+    pump_touch(keys);
+
+    prev_keys = keys;
+    core.signal_frame_boundary();
+}
+
+pub fn apply_cursor_mode(_: core.CursorMode) void {}
+
+pub fn begin_text_input_session(target: core.TextInputTarget, options: core.TextInputOptions) anyerror!void {
+    var state_buf: [SWKBD_STATE_BYTES]u8 align(8) = @splat(0);
+    const state: *anyopaque = @ptrCast(&state_buf);
+
+    var initial_buf: [MAX_TEXT_BYTES:0]u8 = @splat(0);
+    const initial_len = copy_current_text(&initial_buf);
+    const initial = initial_buf[0..initial_len :0];
+
+    var hint_buf: [128:0]u8 = @splat(0);
+    const hint = copy_z(&hint_buf, target.id);
+
+    const max_text_len = text_limit_c_int(options.max_bytes);
+    swkbdInit(state, SWKBD_TYPE_NORMAL, 2, max_text_len);
+    swkbdSetInitialText(state, initial.ptr);
+    swkbdSetHintText(state, hint.ptr);
+    swkbdSetButton(state, SWKBD_BUTTON_LEFT, "Cancel", false);
+    swkbdSetButton(state, SWKBD_BUTTON_RIGHT, "OK", true);
+
+    var features = SWKBD_DARKEN_TOP_SCREEN | SWKBD_DEFAULT_QWERTY;
+    if (options.multiline) features |= SWKBD_MULTILINE;
+    swkbdSetFeatures(state, features);
+
+    var out_buf: [MAX_TEXT_BYTES:0]u8 = @splat(0);
+    const out_size = output_buffer_size(options.max_bytes);
+    const button = swkbdInputText(state, out_buf[0..].ptr, out_size);
+    if (button == SWKBD_BUTTON_RIGHT) {
+        const len = bounded_z_len(out_buf[0..out_size]);
+        core.write_text_session_buffer(out_buf[0..len], .submitted);
+    } else {
+        core.write_text_session_buffer(initial_buf[0..initial_len], .cancelled);
+    }
+}
+
+pub fn end_text_input_session() void {}
+
+fn diff_buttons(keys: u32) void {
+    const Pair = struct { mask: u32, button: core.Button };
+    const map = [_]Pair{
+        .{ .mask = KEY_A, .button = .A },
+        .{ .mask = KEY_B, .button = .B },
+        .{ .mask = KEY_X, .button = .X },
+        .{ .mask = KEY_Y, .button = .Y },
+        .{ .mask = KEY_L, .button = .LButton },
+        .{ .mask = KEY_R, .button = .RButton },
+        .{ .mask = KEY_SELECT, .button = .Back },
+        .{ .mask = KEY_START, .button = .Start },
+        .{ .mask = KEY_DUP, .button = .DpadUp },
+        .{ .mask = KEY_DRIGHT, .button = .DpadRight },
+        .{ .mask = KEY_DDOWN, .button = .DpadDown },
+        .{ .mask = KEY_DLEFT, .button = .DpadLeft },
+    };
+
+    inline for (map) |entry| {
+        const now = keys & entry.mask != 0;
+        const prev = prev_keys & entry.mask != 0;
+        if (now != prev) {
+            core.deliver_gamepad_button(entry.button, if (now) .pressed else .released);
+        }
+    }
+}
+
+fn pump_axes(keys: u32) void {
+    var circle: CirclePosition = .{ .dx = 0, .dy = 0 };
+    hidCircleRead(&circle);
+
+    deliver_axis(.LeftX, normalize_signed(circle.dx, CIRCLE_PAD_MAX));
+    deliver_axis(.LeftY, -normalize_signed(circle.dy, CIRCLE_PAD_MAX));
+    deliver_axis(.RightX, digital_axis(keys, KEY_CSTICK_RIGHT, KEY_CSTICK_LEFT));
+    deliver_axis(.RightY, digital_axis(keys, KEY_CSTICK_DOWN, KEY_CSTICK_UP));
+    deliver_axis(.LeftTrigger, if (keys & KEY_ZL != 0) 1.0 else 0.0);
+    deliver_axis(.RightTrigger, if (keys & KEY_ZR != 0) 1.0 else 0.0);
+}
+
+fn pump_touch(keys: u32) void {
+    const touch_down = keys & KEY_TOUCH != 0;
+    if (touch_down) {
+        var touch: TouchPosition = .{ .px = 0, .py = 0 };
+        hidTouchRead(&touch);
+        const pos: core.Vec2 = .{
+            .x = @floatFromInt(touch.px),
+            .y = @floatFromInt(touch.py),
+        };
+        const delta: core.Vec2 = if (prev_touch_down)
+            .{ .x = pos.x - prev_touch_pos.x, .y = pos.y - prev_touch_pos.y }
+        else
+            .{};
+
+        core.deliver_mouse_move(pos, delta);
+        if (!prev_touch_down) core.deliver_mouse_button(.Left, .pressed, pos);
+        prev_touch_pos = pos;
+    } else if (prev_touch_down) {
+        core.deliver_mouse_button(.Left, .released, prev_touch_pos);
+    }
+
+    prev_touch_down = touch_down;
+}
+
+fn deliver_axis(axis: core.Axis, value: f32) void {
+    const idx = @intFromEnum(axis);
+    const prev = prev_axes[idx];
+    if (value != 0.0 or prev != 0.0) core.deliver_gamepad_axis(axis, value);
+    prev_axes[idx] = value;
+}
+
+fn normalize_signed(raw: anytype, max_value: f32) f32 {
+    const value = @as(f32, @floatFromInt(raw)) / max_value;
+    return std.math.clamp(value, -1.0, 1.0);
+}
+
+fn digital_axis(keys: u32, positive_mask: u32, negative_mask: u32) f32 {
+    var value: f32 = 0.0;
+    if (keys & positive_mask != 0) value += 1.0;
+    if (keys & negative_mask != 0) value -= 1.0;
+    return value;
+}
+
+fn output_buffer_size(limit: ?usize) usize {
+    const max = @min(limit orelse (MAX_TEXT_BYTES - 1), MAX_TEXT_BYTES - 1);
+    return max + 1;
+}
+
+fn text_limit_c_int(limit: ?usize) c_int {
+    const max = @min(limit orelse (MAX_TEXT_BYTES - 1), MAX_TEXT_BYTES - 1);
+    return @intCast(@max(max, 1));
+}
+
+fn copy_current_text(dst: []u8) usize {
+    const s = core.current_text_session() orelse return 0;
+    const n = @min(dst.len - 1, s.buffer.items.len);
+    @memcpy(dst[0..n], s.buffer.items[0..n]);
+    dst[n] = 0;
+    return n;
+}
+
+fn copy_z(dst: []u8, text: []const u8) [:0]const u8 {
+    const n = @min(dst.len - 1, text.len);
+    @memcpy(dst[0..n], text[0..n]);
+    dst[n] = 0;
+    return dst[0..n :0];
+}
+
+fn bounded_z_len(buf: []const u8) usize {
+    return std.mem.indexOfScalar(u8, buf, 0) orelse buf.len;
+}
diff --git a/src/platform/3ds/mango/fmt.zig b/src/platform/3ds/mango/fmt.zig
new file mode 100644
index 0000000..5dfd04f
--- /dev/null
+++ b/src/platform/3ds/mango/fmt.zig
@@ -0,0 +1,2 @@
+pub const zpsh = @import("fmt/zpsh.zig");
+
diff --git a/src/platform/3ds/mango/fmt/zpsh.zig b/src/platform/3ds/mango/fmt/zpsh.zig
new file mode 100644
index 0000000..0b41066
--- /dev/null
+++ b/src/platform/3ds/mango/fmt/zpsh.zig
@@ -0,0 +1,430 @@
+//! Zitrus PICA200 shader
+//!
+//! A simple shader format which omits the need for positional reads and has an overall simpler structure.
+//! It omits numerous things that are not used or cannot be used by zitrus.
+//!
+//! Even if things are tightly packed, all sections are aligned to 32-bits.
+
+pub const magic = "ZPSH";
+
+pub const Header = extern struct {
+    pub const Shader = packed struct(u32) {
+        entrypoints: u12,
+        instructions_minus_one: u12,
+        descriptors: u8,
+
+        pub fn init(entrypoints: usize, instructions_size: usize, descriptors: usize) Shader {
+            return .{
+                .entrypoints = @intCast(entrypoints),
+                .instructions_minus_one = @intCast(instructions_size - 1),
+                .descriptors = @intCast(descriptors),
+            };
+        }
+
+        pub fn instructions(size: Shader) usize {
+            return @as(usize, size.instructions_minus_one) + 1;
+        }
+    };
+
+    pub const Flags = packed struct(u8) { _: u8 = 0 };
+
+    magic: [magic.len]u8 = magic.*,
+    shader: Shader,
+    /// In `u32`s
+    entry_string_table_size: u16,
+    flags: Flags = .{},
+    /// In `u32`s
+    header_size: u8 = @divExact(@sizeOf(Header), @sizeOf(u32)),
+    /// A xxHash32 hash of instructions and operand descriptors, in the described order.
+    /// Seed is 67
+    code_hash: u32,
+
+    pub const CheckError = error{ NotZpsh, InvalidZpsh };
+
+    pub fn check(hdr: Header) CheckError!void {
+        if (!std.mem.eql(u8, &hdr.magic, magic)) return error.NotZpsh;
+    }
+};
+
+pub const EntrypointHeader = extern struct {
+    pub const Flags = packed struct(u16) {
+        _: u16 = 0,
+    };
+
+    pub const ShaderInfo = packed struct(u16) {
+        pub const vertex: ShaderInfo = .{ .type = .vertex };
+        pub const Type = enum(u2) { vertex, geometry_point, geometry_variable, geometry_fixed };
+
+        pub const Geometry = packed union(u14) {
+            pub const empty: Geometry = .{ .point = std.mem.zeroes(Geometry.Point) };
+
+            pub const Point = packed struct(u14) {
+                inputs_minus_one: u4,
+                _: u10 = 0,
+            };
+
+            pub const Variable = packed struct(u14) {
+                full_vertices: u5,
+                _: u9 = 0,
+            };
+
+            pub const Fixed = packed struct(u14) {
+                vertices_minus_one: u4,
+                uniform_start: FloatingRegister,
+                _: u3 = 0,
+            };
+
+            point: Point,
+            fixed: Fixed,
+            variable: Variable,
+
+            pub fn initPoint(inputs: u5) Geometry {
+                return .{ .point = .{ .inputs_minus_one = @intCast(inputs - 1) } };
+            }
+
+            pub fn initVariable(full_vertices: u5) Geometry {
+                return .{ .variable = .{ .full_vertices = full_vertices } };
+            }
+
+            pub fn initFixed(vertices: u5, uniform_start: FloatingRegister) Geometry {
+                return .{ .fixed = .{ .vertices_minus_one = @intCast(vertices - 1), .uniform_start = uniform_start } };
+            }
+        };
+
+        type: Type,
+        geometry: Geometry = .empty,
+    };
+
+    pub const BooleanConstantMask = packed struct(u16) {
+        // zig fmt: off
+        b0: bool, b1: bool, b2: bool, b3: bool, b4: bool, b5: bool, b6: bool, b7: bool,
+        b8: bool, b9: bool, b10: bool, b11: bool, b12: bool, b13: bool, b14: bool, b15: bool,
+        // zig fmt: on
+
+        pub fn fromSet(set: std.EnumSet(BooleanRegister)) BooleanConstantMask {
+            var mask: BooleanConstantMask = std.mem.zeroes(BooleanConstantMask);
+
+            for (std.enums.values(BooleanRegister)) |b| {
+                std.mem.writePackedInt(u1, std.mem.asBytes(&mask), @intFromEnum(b), @intFromBool(set.contains(b)), .little);
+            }
+
+            return mask;
+        }
+
+        pub fn toSet(mask: BooleanConstantMask) std.EnumSet(BooleanRegister) {
+            var set: std.EnumSet(BooleanRegister) = .initEmpty();
+
+            for (std.enums.values(BooleanRegister)) |b| {
+                set.setPresent(b, std.mem.readPackedInt(u1, std.mem.asBytes(&mask), @intFromEnum(b), .little) != 0);
+            }
+
+            return set;
+        }
+    };
+
+    pub const IntegerConstantMask = packed struct(u16) {
+        // zig fmt: off
+        i0: bool, i1: bool,
+        i2: bool, i3: bool,
+        // zig fmt: on
+        _: u12,
+
+        pub fn fromSet(set: std.EnumSet(IntegerRegister)) IntegerConstantMask {
+            var mask: IntegerConstantMask = std.mem.zeroes(IntegerConstantMask);
+
+            for (std.enums.values(IntegerRegister)) |i| {
+                std.mem.writePackedInt(u1, std.mem.asBytes(&mask), @intFromEnum(i), @intFromBool(set.contains(i)), .little);
+            }
+
+            return mask;
+        }
+
+        pub fn toSet(mask: IntegerConstantMask) std.EnumSet(IntegerRegister) {
+            var set: std.EnumSet(IntegerRegister) = .initEmpty();
+
+            for (std.enums.values(IntegerRegister)) |i| {
+                set.setPresent(i, std.mem.readPackedInt(u1, std.mem.asBytes(&mask), @intFromEnum(i), .little) != 0);
+            }
+
+            return set;
+        }
+    };
+
+    pub const FloatingConstantMask = extern struct {
+        // zig fmt: off
+        pub const Low = packed struct(u32) {
+            f0: bool, f1: bool, f2: bool, f3: bool, f4: bool, f5: bool, f6: bool, f7: bool,
+            f8: bool, f9: bool, f10: bool, f11: bool, f12: bool, f13: bool, f14: bool, f15: bool,
+            f16: bool, f17: bool, f18: bool, f19: bool, f20: bool, f21: bool, f22: bool, f23: bool,
+            f24: bool, f25: bool, f26: bool, f27: bool, f28: bool, f29: bool, f30: bool, f31: bool, 
+        };
+
+        pub const Mid = packed struct(u32) {
+            f32: bool, f33: bool, f34: bool, f35: bool, f36: bool, f37: bool, f38: bool, f39: bool,
+            f40: bool, f41: bool, f42: bool, f43: bool, f44: bool, f45: bool, f46: bool, f47: bool,
+            f48: bool, f49: bool, f50: bool, f51: bool, f52: bool, f53: bool, f54: bool, f55: bool,
+            f56: bool, f57: bool, f58: bool, f59: bool, f60: bool, f61: bool, f62: bool, f63: bool, 
+        };
+
+        pub const High = packed struct(u32) {
+            f64: bool, f65: bool, f66: bool, f67: bool, f68: bool, f69: bool, f70: bool, f71: bool,
+            f72: bool, f73: bool, f74: bool, f75: bool, f76: bool, f77: bool, f78: bool, f79: bool,
+            f80: bool, f81: bool, f82: bool, f83: bool, f84: bool, f85: bool, f86: bool, f87: bool,
+            f88: bool, f89: bool, f90: bool, f91: bool, f92: bool, f93: bool, f94: bool, f95: bool,
+        };
+        // zig fmt: on
+
+        low: Low,
+        mid: Mid,
+        high: High,
+
+        pub fn fromSet(set: std.EnumSet(FloatingRegister)) FloatingConstantMask {
+            var mask: FloatingConstantMask = std.mem.zeroes(FloatingConstantMask);
+
+            for (std.enums.values(FloatingRegister)) |f| {
+                std.mem.writePackedInt(u1, std.mem.asBytes(&mask), @intFromEnum(f), @intFromBool(set.contains(f)), .little);
+            }
+
+            return mask;
+        }
+
+        pub fn toSet(mask: FloatingConstantMask) std.EnumSet(FloatingRegister) {
+            var set: std.EnumSet(FloatingRegister) = .initEmpty();
+
+            for (std.enums.values(FloatingRegister)) |f| {
+                set.setPresent(f, std.mem.readPackedInt(u1, std.mem.asBytes(&mask), @intFromEnum(f), .little) != 0);
+            }
+
+            return set;
+        }
+    };
+
+    pub const OutputMask = packed struct(u32) {
+        // zig fmt: off
+        o0: bool, o1: bool, o2: bool, o3: bool, o4: bool, o5: bool, o6: bool, o7: bool,
+        o8: bool, o9: bool, o10: bool, o11: bool, o12: bool, o13: bool, o14: bool, o15: bool,
+        _: u16 = 0,
+        // zig fmt: on
+
+        pub fn fromSet(set: std.EnumSet(OutputRegister)) OutputMask {
+            var mask: OutputMask = std.mem.zeroes(OutputMask);
+
+            for (std.enums.values(OutputRegister)) |o| {
+                std.mem.writePackedInt(u1, std.mem.asBytes(&mask), @intFromEnum(o), @intFromBool(set.contains(o)), .little);
+            }
+
+            return mask;
+        }
+
+        pub fn toSet(mask: OutputMask) std.EnumSet(OutputRegister) {
+            var set: std.EnumSet(OutputRegister) = .initEmpty();
+
+            for (std.enums.values(OutputRegister)) |o| {
+                set.setPresent(o, std.mem.readPackedInt(u1, std.mem.asBytes(&mask), @intFromEnum(o), .little) != 0);
+            }
+
+            return set;
+        }
+    };
+
+    name_string_offset: u32,
+    instruction_offset: u16,
+    info: ShaderInfo,
+    flags: Flags,
+    header_size: u16 = @divExact(@sizeOf(EntrypointHeader), @sizeOf(u32)),
+
+    // NOTE: Constants are sorted, that is, e.g: f0 = true, f1 = false, f2 = true then in memory there will be two floating constant entries that correspond to f0 and f2. Same for integers and same for outputs.
+    boolean_constant_mask: BooleanConstantMask,
+    integer_constant_mask: IntegerConstantMask,
+    floating_constant_mask: FloatingConstantMask,
+    output_mask: OutputMask,
+};
+
+pub const Parsed = struct {
+    code_hash: u32,
+    instructions: []const shader.encoding.Instruction,
+    operand_descriptors: []const shader.encoding.OperandDescriptor,
+    string_table: []const u8,
+    entrypoint_offsets: []const u8,
+    entrypoint_data: []const u8,
+    entrypoints: usize,
+
+    pub fn initBuffer(buffer: []const u8) Header.CheckError!Parsed {
+        const header = try checkedSlice(buffer, 0, @sizeOf(Header));
+        if (!std.mem.eql(u8, header[0..magic.len], magic)) return error.NotZpsh;
+
+        const shader_word = try readLittle(u32, header, 4);
+        const entrypoints: usize = @intCast(shader_word & 0xfff);
+        const instructions_minus_one: u16 = @intCast((shader_word >> 12) & 0xfff);
+        const descriptors: u8 = @intCast(shader_word >> 24);
+        const instructions_count = @as(usize, instructions_minus_one) + 1;
+        const entry_string_table_size = try readLittle(u16, header, 8);
+        const header_size_words = try readLittle(u8, header, 11);
+        const code_hash = try readLittle(u32, header, 12);
+
+        const header_size = try checkedMul(@as(usize, header_size_words), @sizeOf(u32));
+        if (header_size < @sizeOf(Header)) return error.InvalidZpsh;
+        const entrypoint_offsets_start = header_size;
+        const entrypoint_offsets_size = try checkedMul(@as(usize, entrypoints), @sizeOf(u32));
+        const code_start = try checkedAdd(entrypoint_offsets_start, entrypoint_offsets_size);
+        const code_size = try checkedMul(@sizeOf(shader.encoding.Instruction), instructions_count);
+        const operands_start = try checkedAdd(code_start, code_size);
+        const operands_size = try checkedMul(@sizeOf(shader.encoding.OperandDescriptor), @as(usize, descriptors));
+        const string_table_start = try checkedAdd(operands_start, operands_size);
+        const string_table_size = try checkedMul(@as(usize, entry_string_table_size), @sizeOf(u32));
+        const entrypoints_start = try checkedAdd(string_table_start, string_table_size);
+
+        if (entrypoints_start > buffer.len) return error.InvalidZpsh;
+
+        return .{
+            .code_hash = code_hash,
+            .instructions = @alignCast(std.mem.bytesAsSlice(pica.shader.encoding.Instruction, try checkedSlice(buffer, code_start, code_size))),
+            .operand_descriptors = @alignCast(std.mem.bytesAsSlice(pica.shader.encoding.OperandDescriptor, try checkedSlice(buffer, operands_start, operands_size))),
+            .string_table = try checkedSlice(buffer, string_table_start, string_table_size),
+            .entrypoint_offsets = try checkedSlice(buffer, entrypoint_offsets_start, entrypoint_offsets_size),
+            .entrypoint_data = buffer[entrypoints_start..],
+            .entrypoints = entrypoints,
+        };
+    }
+
+    pub fn iterator(parsed: *const Parsed) EntrypointIterator {
+        return .{
+            .parsed = parsed,
+            .offset_cursor = 0,
+        };
+    }
+
+    // TODO: This assumes a proper ZPSH (as we're the only ones who currently use them we're allowed to not care :p)
+    pub const EntrypointIterator = struct {
+        pub const Entry = struct {
+            info: EntrypointHeader.ShaderInfo,
+            offset: u16,
+
+            name: [:0]const u8,
+            boolean_constant_set: std.enums.EnumSet(BooleanRegister),
+            integer_constant_set: std.enums.EnumSet(IntegerRegister),
+            floating_constant_set: std.enums.EnumSet(FloatingRegister),
+            output_set: std.enums.EnumSet(OutputRegister),
+
+            integer_constants: []const [4]u8,
+            floating_constants: []const pica.F7_16x4,
+            output_map: []const pica.OutputMap,
+        };
+
+        parsed: *const Parsed,
+        offset_cursor: usize,
+
+        pub fn next(it: *EntrypointIterator) Header.CheckError!?Entry {
+            if (it.offset_cursor >= it.parsed.entrypoint_offsets.len) return null;
+
+            const offset = try readLittle(u32, it.parsed.entrypoint_offsets, it.offset_cursor);
+            it.offset_cursor +%= @sizeOf(u32);
+
+            const entry_offset: usize = @intCast(offset);
+            if (entry_offset > it.parsed.entrypoint_data.len) return error.InvalidZpsh;
+            const entry_start = it.parsed.entrypoint_data[entry_offset..];
+            _ = try checkedSlice(entry_start, 0, @sizeOf(EntrypointHeader));
+
+            const name_string_offset = try readLittle(u32, entry_start, 0);
+            const instruction_offset = try readLittle(u16, entry_start, 4);
+            const info: EntrypointHeader.ShaderInfo = @bitCast(try readLittle(u16, entry_start, 6));
+            const boolean_constant_set = enumSetFromMask(BooleanRegister, u16, try readLittle(u16, entry_start, 12));
+            const integer_constant_set = enumSetFromMask(IntegerRegister, u16, try readLittle(u16, entry_start, 14));
+            const floating_constant_set = floatingSetFromMask(
+                try readLittle(u32, entry_start, 16),
+                try readLittle(u32, entry_start, 20),
+                try readLittle(u32, entry_start, 24),
+            );
+            const output_map_set = enumSetFromMask(OutputRegister, u32, try readLittle(u32, entry_start, 28));
+
+            const integer_constants_byte_size = try checkedMul(integer_constant_set.count(), @sizeOf([4]u8));
+            const floating_constants_byte_size = try checkedMul(floating_constant_set.count(), @sizeOf(pica.F7_16x4));
+            const output_map_byte_size = try checkedMul(output_map_set.count(), @sizeOf(pica.OutputMap));
+            const integer_constants_start = @sizeOf(EntrypointHeader);
+            const floating_constants_start = try checkedAdd(integer_constants_start, integer_constants_byte_size);
+            const output_map_start = try checkedAdd(floating_constants_start, floating_constants_byte_size);
+
+            if (instruction_offset > std.math.maxInt(u12)) return error.InvalidZpsh;
+            if (name_string_offset > it.parsed.string_table.len) return error.InvalidZpsh;
+            const name_tail = it.parsed.string_table[name_string_offset..];
+            const name_end = std.mem.indexOfScalar(u8, name_tail, 0) orelse return error.InvalidZpsh;
+
+            return .{
+                .info = info,
+                .offset = @intCast(instruction_offset),
+
+                .name = name_tail[0..name_end :0],
+                .boolean_constant_set = boolean_constant_set,
+                .integer_constant_set = integer_constant_set,
+                .floating_constant_set = floating_constant_set,
+                .output_set = output_map_set,
+
+                .integer_constants = @alignCast(std.mem.bytesAsSlice([4]u8, try checkedSlice(entry_start, integer_constants_start, integer_constants_byte_size))),
+                .floating_constants = @alignCast(std.mem.bytesAsSlice(pica.F7_16x4, try checkedSlice(entry_start, floating_constants_start, floating_constants_byte_size))),
+                .output_map = @alignCast(std.mem.bytesAsSlice(pica.OutputMap, try checkedSlice(entry_start, output_map_start, output_map_byte_size))),
+            };
+        }
+    };
+};
+
+fn checkedAdd(a: usize, b: usize) Header.CheckError!usize {
+    if (a > std.math.maxInt(usize) - b) return error.InvalidZpsh;
+    return a + b;
+}
+
+fn checkedMul(a: usize, b: usize) Header.CheckError!usize {
+    if (b != 0 and a > std.math.maxInt(usize) / b) return error.InvalidZpsh;
+    return a * b;
+}
+
+fn checkedSlice(buffer: []const u8, start: usize, len: usize) Header.CheckError![]const u8 {
+    const end = try checkedAdd(start, len);
+    if (end > buffer.len) return error.InvalidZpsh;
+    return buffer[start..end];
+}
+
+fn readLittle(comptime T: type, buffer: []const u8, offset: usize) Header.CheckError!T {
+    const bytes = try checkedSlice(buffer, offset, @sizeOf(T));
+    return std.mem.readInt(T, bytes[0..@sizeOf(T)], .little);
+}
+
+fn enumSetFromMask(comptime E: type, comptime T: type, mask: T) std.EnumSet(E) {
+    var set: std.EnumSet(E) = .initEmpty();
+    for (std.enums.values(E)) |value| {
+        const bit: std.math.Log2Int(T) = @intCast(@intFromEnum(value));
+        set.setPresent(value, ((mask >> bit) & 1) != 0);
+    }
+    return set;
+}
+
+fn floatingSetFromMask(low: u32, mid: u32, high: u32) std.EnumSet(FloatingRegister) {
+    var set: std.EnumSet(FloatingRegister) = .initEmpty();
+    for (std.enums.values(FloatingRegister)) |value| {
+        const index = @intFromEnum(value);
+        const word = switch (index / 32) {
+            0 => low,
+            1 => mid,
+            2 => high,
+            else => unreachable,
+        };
+        const bit: u5 = @intCast(index & 31);
+        set.setPresent(value, ((word >> bit) & 1) != 0);
+    }
+    return set;
+}
+
+comptime {
+    std.debug.assert(std.mem.isAligned(@sizeOf(Header), @sizeOf(u32)));
+    std.debug.assert(std.mem.isAligned(@sizeOf(EntrypointHeader), @sizeOf(u32)));
+}
+
+const builtin = @import("builtin");
+const std = @import("std");
+const zitrus = @import("zitrus");
+const pica = zitrus.hardware.pica;
+const shader = pica.shader;
+
+const BooleanRegister = shader.register.Integral.Boolean;
+const IntegerRegister = shader.register.Integral.Integer;
+const FloatingRegister = shader.register.Source.Constant;
+const OutputRegister = shader.register.Destination.Output;
diff --git a/src/platform/3ds/mango/hardware.zig b/src/platform/3ds/mango/hardware.zig
new file mode 100644
index 0000000..9613ef4
--- /dev/null
+++ b/src/platform/3ds/mango/hardware.zig
@@ -0,0 +1,201 @@
+//! Definitions for 3DS hardware
+
+pub const cpu = @import("hardware/cpu.zig");
+pub const pica = @import("hardware/pica.zig");
+pub const csnd = @import("hardware/csnd.zig");
+pub const pxi = @import("hardware/pxi.zig");
+pub const dsp = @import("hardware/dsp.zig");
+pub const hid = @import("hardware/hid.zig");
+pub const lgy = @import("hardware/lgy.zig");
+pub const i2c = @import("hardware/i2c.zig");
+pub const lcd = @import("hardware/lcd.zig");
+
+/// Represents a register which is triggered by writing a value to it.
+pub const Trigger = enum(u1) { trigger = 1 };
+
+/// Represents an `AlignedPhysicalAddress` with no alignment.
+pub const PhysicalAddress = AlignedPhysicalAddress(.@"1", .@"1");
+
+/// Represents a `PhysicalAddress` which is aligned to `address_alignment` and stored with `address_shift`
+pub fn AlignedPhysicalAddress(comptime address_alignment: std.mem.Alignment, comptime address_shift: std.mem.Alignment) type {
+    std.debug.assert(address_alignment.order(address_shift) != .lt);
+
+    return enum(u32) {
+        zero = 0x00,
+        _,
+
+        const AlignedPhysAddr = @This();
+        pub const alignment = address_alignment;
+        pub const shift = address_shift;
+
+        pub inline fn fromAddress(address: u32) AlignedPhysAddr {
+            return .fromPhysical(@as(PhysicalAddress, @enumFromInt(address)));
+        }
+
+        pub fn fromPhysical(aligned_address: anytype) AlignedPhysAddr {
+            const OtherAlignedPhysAddr = @TypeOf(aligned_address);
+
+            if (@typeInfo(OtherAlignedPhysAddr) != .@"enum" or !@hasDecl(OtherAlignedPhysAddr, "alignment") or !@hasDecl(OtherAlignedPhysAddr, "shift"))
+                @compileError("please provide a valid AlignedPhysicalAddress to .of()");
+
+            const other_alignment = @field(OtherAlignedPhysAddr, "alignment");
+            const other_shift = @field(OtherAlignedPhysAddr, "shift");
+
+            if (@TypeOf(other_alignment) != std.mem.Alignment or @TypeOf(other_shift) != std.mem.Alignment or OtherAlignedPhysAddr != AlignedPhysicalAddress(other_alignment, other_shift))
+                @compileError("please provide a valid AlignedPhysicalAddress to .of()");
+
+            const address = @intFromEnum(aligned_address) << @intCast(std.math.log2(other_shift.toByteUnits()));
+
+            if (alignment.order(other_alignment) != .lt) {
+                std.debug.assert(alignment.check(address));
+            }
+
+            return @enumFromInt(address >> @intCast(std.math.log2(shift.toByteUnits())));
+        }
+    };
+}
+
+/// Represents a a register which only spans the LSb of a word, leaving the others unused.
+pub fn LsbRegister(comptime T: type) type {
+    std.debug.assert(@bitSizeOf(T) < @bitSizeOf(u32));
+
+    return packed struct(u32) {
+        const Lsb = @This();
+
+        value: T,
+        _: std.meta.Int(.unsigned, @bitSizeOf(u32) - @bitSizeOf(T)) = 0,
+
+        pub inline fn init(value: T) Lsb {
+            return .{ .value = value };
+        }
+
+        pub fn format(lsb: Lsb, w: *std.Io.Writer) std.Io.Writer.Error!void {
+            try w.print(if (std.meta.hasFn(T, "format")) "{f}" else "{any}", .{lsb.value});
+        }
+    };
+}
+
+/// Represents a a register which only spans the MSb of a word, leaving the others unused.
+pub fn MsbRegister(comptime T: type) type {
+    std.debug.assert(@bitSizeOf(T) < @bitSizeOf(u32));
+
+    return packed struct(u32) {
+        const Msb = @This();
+
+        _: std.meta.Int(.unsigned, @bitSizeOf(u32) - @bitSizeOf(T)) = 0,
+        value: T,
+
+        pub inline fn init(value: T) Msb {
+            return .{ .value = value };
+        }
+
+        pub fn format(msb: Msb, w: *std.Io.Writer) std.Io.Writer.Error!void {
+            try w.print(if (std.meta.hasFn(T, "format")) "{f}" else "{any}", .{msb.value});
+        }
+    };
+}
+
+/// Represents a bitpacked array of `n` elements of `T`.
+/// Stored in native endian.
+///
+/// A `BitpackedArray` is stored from LSb (0) to MSb (n - 1).
+pub fn BitpackedArray(comptime T: type, comptime n: usize) type {
+    const total_bit_size = @bitSizeOf(T) * n;
+    const ArrayInt = @Int(.unsigned, total_bit_size);
+    const ElementInt = @Int(.unsigned, @bitSizeOf(T));
+
+    return packed struct(ArrayInt) {
+        pub const Int = ArrayInt;
+
+        raw: ArrayInt,
+
+        pub inline fn init(value: [n]T) Self {
+            // NOTE: Cannot be `undefined`, any `undefined` bits make the entire value `undefined`.
+            var bt: Self = std.mem.zeroes(Self);
+            inline for (0..n) |i| bt.set(i, value[i]);
+            return bt;
+        }
+
+        pub inline fn splat(value: T) Self {
+            // NOTE: Cannot be `undefined`, any `undefined` bits make the entire value `undefined`.
+            var bt: Self = std.mem.zeroes(Self);
+            inline for (0..n) |i| bt.set(i, value);
+            return bt;
+        }
+
+        pub inline fn slice(bt: Self, index: usize, comptime len: usize) BitpackedArray(T, len) {
+            std.debug.assert(index + len <= n);
+
+            const NewBitpacked = BitpackedArray(T, len);
+            const bt_int: Int = @bitCast(bt);
+            const new_bt_int: NewBitpacked.Int = @truncate(bt_int >> (index * @bitSizeOf(T)));
+            return @bitCast(new_bt_int);
+        }
+
+        pub inline fn get(bt: Self, index: usize) T {
+            const value = std.mem.readPackedInt(ElementInt, @ptrCast(&bt.raw), index * @bitSizeOf(ElementInt), .native);
+
+            return switch (@typeInfo(T)) {
+                .@"enum" => @enumFromInt(value),
+                else => @bitCast(value),
+            };
+        }
+
+        pub inline fn copyWith(bt: Self, comptime index: usize, value: T) Self {
+            var new_bt: Self = bt;
+            new_bt.set(index, value);
+            return new_bt;
+        }
+
+        pub inline fn set(bt: *Self, index: usize, value: T) void {
+            std.mem.writePackedInt(ElementInt, @ptrCast(&bt.raw), index * @bitSizeOf(ElementInt), switch (@typeInfo(T)) {
+                .@"enum" => @intFromEnum(value),
+                else => @bitCast(value),
+            }, .native);
+        }
+
+        pub fn format(bt: Self, w: *std.Io.Writer) std.Io.Writer.Error!void {
+            try w.writeAll("{ ");
+            for (0..n) |i| {
+                try w.print(if (std.meta.hasFn(T, "format")) "{f}" else "{any}", .{bt.get(i)});
+                if (i != n - 1) try w.writeAll(", ");
+            }
+            try w.writeAll(" }");
+        }
+
+        const Self = @This();
+    };
+}
+
+comptime {
+    _ = pica;
+    _ = csnd;
+    _ = pxi;
+    _ = dsp;
+    _ = lgy;
+    _ = i2c;
+}
+
+const testing = std.testing;
+
+test BitpackedArray {
+    const Thing = enum(u1) { foo, bar };
+    const ThingArray = BitpackedArray(Thing, 4);
+
+    var bt: ThingArray = .splat(.foo);
+
+    bt.set(3, .bar);
+
+    try testing.expect(bt.get(3) == .bar);
+
+    bt.set(3, .foo);
+
+    try testing.expect(bt.get(3) == .foo);
+
+    bt.set(0, .bar);
+
+    try testing.expect(bt.get(0) == .bar);
+}
+
+const builtin = @import("builtin");
+const std = @import("std");
diff --git a/src/platform/3ds/mango/hardware/cpu.zig b/src/platform/3ds/mango/hardware/cpu.zig
new file mode 100644
index 0000000..32ea21a
--- /dev/null
+++ b/src/platform/3ds/mango/hardware/cpu.zig
@@ -0,0 +1,194 @@
+//! Definitions for ARM instructions and MMIO registers
+//! which are common to both CPUs.
+//!
+//! See `arm9` and `arm11` for cpu-specific things.
+//!
+//! Based on the technical reference manuals of both.
+
+// TODO: Not tested
+
+pub const arm9 = @import("cpu/arm9.zig");
+pub const arm11 = @import("cpu/arm11.zig");
+
+pub const Register = enum(u4) {
+    pub const sp: Register = .r13;
+    pub const lr: Register = .r14;
+    pub const pc: Register = .r15;
+
+    r0,
+    r1,
+    r2,
+    r3,
+    r4,
+    r5,
+    r6,
+    r7,
+    r8,
+    r9,
+    r10,
+    r11,
+    r12,
+    r13,
+    r14,
+    r15,
+};
+
+// CP15 c0 c0 0 -> ID
+// CP15 c0 c0 1 -> Cache Type
+
+pub inline fn waitForInterrupt() void {
+    asm volatile ("mcr p15, 0, %[sbz], c7, c0, 4"
+        :
+        : [sbz] "r" (0),
+    );
+}
+
+pub const cache = struct {
+    pub const SetWay = packed struct(u32) {
+        _reserved0: u4 = 0,
+        /// Depends on cache size
+        set: u13,
+        _reserved1: u13,
+        way: u2,
+
+        pub inline fn invalidateInstruction(set_way: SetWay) void {
+            asm volatile ("mcr p15, 0, %[sw], c7, c5, 2"
+                :
+                : [sw] "r" (set_way),
+            );
+        }
+
+        pub inline fn invalidateData(set_way: SetWay) void {
+            asm volatile ("mcr p15, 0, %[sw], c7, c6, 2"
+                :
+                : [sw] "r" (set_way),
+            );
+        }
+
+        pub inline fn cleanData(set_way: SetWay) void {
+            asm volatile ("mcr p15, 0, %[sw], c7, c10, 2"
+                :
+                : [sw] "r" (set_way),
+            );
+        }
+
+        pub inline fn flushData(set_way: SetWay) void {
+            asm volatile ("mcr p15, 0, %[sw], c7, c14, 2"
+                :
+                : [sw] "r" (set_way),
+            );
+        }
+    };
+
+    pub const Address = packed struct(u32) {
+        virtual: u32,
+
+        pub inline fn invalidateInstruction(address: Address) void {
+            asm volatile ("mcr p15, 0, %[addr], c7, c5, 1"
+                :
+                : [addr] "r" (address),
+            );
+        }
+
+        pub inline fn invalidateData(address: Address) void {
+            asm volatile ("mcr p15, 0, %[addr], c7, c6, 1"
+                :
+                : [addr] "r" (address),
+            );
+        }
+
+        pub inline fn cleanData(address: Address) void {
+            asm volatile ("mcr p15, 0, %[addr], c7, c10, 1"
+                :
+                : [addr] "r" (address),
+            );
+        }
+
+        pub inline fn flushData(address: Address) void {
+            asm volatile ("mcr p15, 0, %[addr], c7, c14, 1"
+                :
+                : [addr] "r" (address),
+            );
+        }
+
+        pub inline fn flushBranchPredictor(address: Address) void {
+            asm volatile ("mcr p15, 0, %[addr], c7, c5, 7"
+                :
+                : [addr] "r" (address),
+            );
+        }
+    };
+
+    pub inline fn flushPrefetchBuffer() void {
+        asm volatile ("mcr p15, 0, %[sbz], c7, c5, 4"
+            :
+            : [sbz] "r" (0),
+        );
+    }
+
+    pub inline fn dataSynchronizationBarrier() void {
+        asm volatile ("mcr p15, 0, %[sbz], c7, c10, 4"
+            :
+            : [sbz] "r" (0),
+        );
+    }
+
+    pub inline fn dataMemoryBarrier() void {
+        asm volatile ("mcr p15, 0, %[sbz], c7, c10, 5"
+            :
+            : [sbz] "r" (0),
+        );
+    }
+
+    pub inline fn flushBranchPredictor() void {
+        asm volatile ("mcr p15, 0, %[sbz], c7, c5, 6"
+            :
+            : [sbz] "r" (0),
+        );
+    }
+
+    /// Also flushes branch predictor cache
+    pub inline fn invalidateInstruction() void {
+        asm volatile ("mcr p15, 0, %[sbz], c7, c5, 0"
+            :
+            : [sbz] "r" (0),
+        );
+    }
+
+    pub inline fn invalidateData() void {
+        asm volatile ("mcr p15, 0, %[sbz], c7, c6, 0"
+            :
+            : [sbz] "r" (0),
+        );
+    }
+
+    /// Also flushes branch predictor cache
+    pub inline fn invalidate() void {
+        asm volatile ("mcr p15, 0, %[sbz], c7, c7, 0"
+            :
+            : [sbz] "r" (0),
+        );
+    }
+
+    pub inline fn cleanData() void {
+        asm volatile ("mcr p15, 0, %[sbz], c7, c10, 0"
+            :
+            : [sbz] "r" (0),
+        );
+    }
+
+    pub inline fn flushData() void {
+        asm volatile ("mcr p15, 0, %[sbz], c7, c14, 0"
+            :
+            : [sbz] "r" (0),
+        );
+    }
+};
+
+comptime {
+    _ = arm11;
+    _ = arm9;
+}
+
+const std = @import("std");
+const zitrus = @import("zitrus");
diff --git a/src/platform/3ds/mango/hardware/cpu/arm11.zig b/src/platform/3ds/mango/hardware/cpu/arm11.zig
new file mode 100644
index 0000000..4393460
--- /dev/null
+++ b/src/platform/3ds/mango/hardware/cpu/arm11.zig
@@ -0,0 +1,324 @@
+//! Based on the ARM11 MPCore r2p0 Technical Reference Manual
+
+// CP15 c0 c0 3 -> TLB Type
+// CP15 c0 c0 5 -> CPUID
+// CP15 c0 c1 -> Feature Registers
+// CP15 c0 c2 -> ISA Attributes Registers
+
+pub const Control = packed struct(u32) {
+    pub const Auxiliary = packed struct(u32) {
+        pub const Multiprocessing = enum(u1) { amp, smp };
+
+        return_stack: bool = false,
+        dynamic_branch_prediction: bool = false,
+        static_branch_prediction: bool = false,
+        instruction_folding: bool = false,
+        exclusive_caches: bool = false,
+        multiprocessing: Multiprocessing,
+        l1_parity_errors: bool = false,
+        _reserved0: u25 = 0,
+
+        pub inline fn read() Auxiliary {
+            return asm volatile ("mrc p15, 0, %[cnt], c1, c0, 1"
+                : [cnt] "=r" (-> Auxiliary),
+            );
+        }
+
+        pub inline fn write(cnt: Auxiliary) void {
+            return asm volatile ("mcr p15, 0, %[cnt], c1, c0, 1"
+                :
+                : [cnt] "r" (cnt),
+            );
+        }
+    };
+
+    mmu: bool = false,
+    /// Data abort on unaligned loads/stores
+    strict_alignment: bool = false,
+    l1_data_cache: bool = false,
+    _reserved0: u4 = std.math.maxInt(u4),
+    _reserved1: u1 = 0,
+    /// Deprecated
+    system_protection: bool = false,
+    /// Deprecated
+    rom_protection: bool = false,
+    _reserved2: u1 = 0,
+    branch_prediction: bool = false,
+    l1_instruction_cache: bool = false,
+    alternate_exception_vectors: bool = false,
+    _reserved3: u1 = 1,
+    disable_thumb_by_pc_loads: bool = false,
+    _unused0: u6 = 0,
+    unaligned_access: bool = false,
+    subpage_access_permissions: bool = false,
+    _reserved4: u1 = 0,
+    set_cpsr_e_on_exception: bool = false,
+    _reserved5: u1 = 0,
+    non_maskable_fast_irq: bool = false,
+    tex_remap: bool = false,
+    force_access_permissions: bool = false,
+    _reserved6: u2 = 0,
+
+    pub inline fn read() Control {
+        return asm volatile ("mrc p15, 0, %[cnt], c1, c0, 0"
+            : [cnt] "=r" (-> Control),
+        );
+    }
+
+    pub inline fn write(cnt: Control) void {
+        return asm volatile ("mcr p15, 0, %[cnt], c1, c0, 0"
+            :
+            : [cnt] "r" (cnt),
+        );
+    }
+};
+
+pub const CoprocessorAccess = packed struct(u32) {
+    pub const Mode = enum(u2) { denied, supervisor, full = 3 };
+
+    _reserved0: u20 = 0,
+    @"10": Mode = .denied,
+    @"11": Mode = .denied,
+    _reserved1: u8 = 0,
+
+    pub inline fn read() CoprocessorAccess {
+        return asm volatile ("mrc p15, 0, %[acc], c1, c0, 2"
+            : [acc] "=r" (-> CoprocessorAccess),
+        );
+    }
+
+    pub inline fn write(acc: CoprocessorAccess) void {
+        return asm volatile ("mcr p15, 0, %[acc], c1, c0, 2"
+            :
+            : [acc] "r" (acc),
+        );
+    }
+};
+
+pub const TranslationTable = extern struct {
+    pub const Cachable = enum(u2) {
+        none,
+        write_back_allocate,
+        write_through,
+        write_back,
+    };
+
+    pub const Base = packed struct(u32) {
+        _reserved0: u1 = 0,
+        shared: bool = false,
+        _reserved1: u1 = 0,
+        region: Cachable = .none,
+        /// TTBL 0 base depends on `Control.separate_table_boundary` and TTBL 1 is restricted to 16KB pages
+        base: u27,
+
+        pub inline fn read(comptime table: u1) Base {
+            return asm volatile ("mrc p15, 0, %[base], c2, c0, %[reg]"
+                : [base] "=r" (-> Base),
+                : [reg] "i" (table),
+            );
+        }
+
+        pub inline fn write(base: Base, comptime table: u1) void {
+            return asm volatile ("mcr p15, 0, %[base], c2, c0, %[reg]"
+                :
+                : [base] "r" (base),
+                  [reg] "i" (table),
+            );
+        }
+    };
+
+    pub const Control = packed struct(u32) {
+        pub const Boundary = enum(u3) {
+            @"16KB",
+            @"8KB",
+            @"4KB",
+            @"2KB",
+            @"1KB",
+            @"512B",
+            @"256B",
+            @"128B",
+        };
+
+        separate_table_boundary: Boundary,
+        _reserved0: u29 = 0,
+
+        pub inline fn read() TranslationTable.Control {
+            return asm volatile ("mrc p15, 0, %[cnt], c2, c0, 2"
+                : [cnt] "=r" (-> TranslationTable.Control),
+            );
+        }
+
+        pub inline fn write(cnt: TranslationTable.Control) void {
+            return asm volatile ("mcr p15, 0, %[cnt], c2, c0, 2"
+                :
+                : [cnt] "r" (cnt),
+            );
+        }
+    };
+};
+
+pub const DomainAccess = packed struct(u32) {
+    pub const Mode = enum(u2) { none, client, manager = 3 };
+
+    access: BitpackedArray(Mode, 16),
+
+    pub inline fn read() DomainAccess {
+        return asm volatile ("mrc p15, 0, %[acc], c3, c0, 0"
+            : [acc] "=r" (-> DomainAccess),
+        );
+    }
+
+    pub inline fn write(acc: DomainAccess) void {
+        return asm volatile ("mcr p15, 0, %[acc], c3, c0, 0"
+            :
+            : [acc] "r" (acc),
+        );
+    }
+};
+
+pub const Fault = packed struct(u32) {
+    pub const Kind = enum(u1) { data, instruction };
+    pub const Operation = enum(u1) { read, write };
+    pub const Status = enum(u5) {
+        alignment = 0b00001,
+        instruction_cache_maintenance = 0b00100,
+        first_level_external_abort = 0b01100,
+        second_level_external_abort = 0b01110,
+        section_translation = 0b00101,
+        page_translation = 0b00111,
+        section_access = 0b00011,
+        page_access = 0b00110,
+        section_domain = 0b01001,
+        page_domain = 0b01011,
+        section_permission = 0b01101,
+        page_permission = 0b01111,
+        precise_external_abort = 0b01000,
+        imprecise_external_abort = 0b10110,
+        debug = 0b00010,
+        _,
+    };
+
+    status_lo: u4,
+    domain: u4,
+    _reserved0: u2 = 0,
+    status_hi: u1,
+    operation: Operation,
+    external_abort: bool,
+    _reserved1: u19,
+
+    pub fn status(fault: Fault) Status {
+        return @enumFromInt(fault.status_lo | (@as(u5, fault.status_hi) << 4));
+    }
+
+    pub inline fn read(comptime kind: Kind) Fault {
+        return asm volatile ("mrc p15, 0, %[st], c5, c0, %[kind]"
+            : [st] "=r" (-> DomainAccess),
+            : [kind] "i" (@intFromEnum(kind)),
+        );
+    }
+
+    pub inline fn write(st: Fault, comptime kind: Kind) void {
+        return asm volatile ("mcr p15, 0, %[st], c5, c0, %[kind]"
+            :
+            : [st] "r" (st),
+              [kind] "i" (@intFromEnum(kind)),
+        );
+    }
+
+    pub const Address = packed struct(u32) {
+        pub const Kind = enum(u1) { default, watchpoint };
+
+        virtual: u32,
+
+        pub inline fn read(comptime kind: Address.Kind) u32 {
+            return asm volatile ("mrc p15, 0, %[addr], c6, c0, %[kind]"
+                : [addr] "=r" (-> Address),
+                : [kind] "i" (@intFromEnum(kind)),
+            );
+        }
+
+        pub inline fn write(addr: Address, comptime kind: Address.Kind) void {
+            return asm volatile ("mcr p15, 0, %[addr], c6, c0, %[kind]"
+                :
+                : [addr] "r" (addr),
+                  [kind] "i" (@intFromEnum(kind)),
+            );
+        }
+    };
+};
+
+pub fn Monitor(comptime T: type) type {
+    return extern struct {
+        raw: T,
+
+        pub fn init(value: T) MonitorSelf {
+            return .{ .raw = value };
+        }
+
+        /// Performs a load, putting the monitor into a exclusive access state.
+        pub fn load(mon: *const MonitorSelf) T {
+            return switch (@bitSizeOf(T)) {
+                8 => @bitCast(asm volatile ("ldrexb %[to], %[ptr]"
+                    : [to] "=r" (-> u8),
+                    : [ptr] "p" (&mon.raw),
+                )),
+                16 => @bitCast(asm volatile ("ldrexh %[to], %[ptr]"
+                    : [to] "=r" (-> u16),
+                    : [ptr] "p" (&mon.raw),
+                )),
+                32 => @bitCast(asm volatile ("ldrex %[to], %[ptr]"
+                    : [to] "=r" (-> u32),
+                    : [ptr] "p" (&mon.raw),
+                )),
+                64 => asm volatile ("ldrexd %[to:Q], %[to:R], %[ptr]"
+                    : [to] "=r" (-> u64),
+                    : [ptr] "p" (&mon.raw),
+                ),
+                else => @compileError("Unsupported Monitor(" ++ @typeName(T) ++ ")"),
+            };
+        }
+
+        /// Tries to perform a store. If the monitor is still in exclusive access after a
+        /// `load`, the store succeeds and returns `false` putting the monitor into an
+        /// open state again.
+        ///
+        /// Spurious changes to an open state may happen.
+        pub fn store(mon: *MonitorSelf, value: T) bool {
+            return switch (@bitSizeOf(T)) {
+                8 => asm volatile ("strexb %[fail], %[value], %[ptr]"
+                    : [fail] "=&r" (-> bool),
+                    : [ptr] "p" (&mon.raw),
+                      [value] "r" (value),
+                    : .{ .memory = true }),
+                16 => asm volatile ("strexh %[fail], %[value], %[ptr]"
+                    : [fail] "=&r" (-> bool),
+                    : [ptr] "p" (&mon.raw),
+                      [value] "r" (value),
+                    : .{ .memory = true }),
+                32 => asm volatile ("strex %[fail], %[value], %[ptr]"
+                    : [fail] "=&r" (-> bool),
+                    : [ptr] "p" (&mon.raw),
+                      [value] "r" (value),
+                    : .{ .memory = true }),
+                64 => asm volatile ("strexd %[fail], %[value:Q], %[value:R], %[ptr]"
+                    : [fail] "=&r" (-> bool),
+                    : [ptr] "p" (&mon.raw),
+                      [value] "r" (value),
+                    : .{ .memory = true }),
+                else => @compileError("Unsupported Monitor(" ++ @typeName(T) ++ ")"),
+            };
+        }
+
+        /// Puts the monitor into an open state.
+        pub fn clear(_: *MonitorSelf) void {
+            asm volatile ("clrex");
+        }
+
+        const MonitorSelf = @This();
+    };
+}
+
+const std = @import("std");
+const zitrus = @import("zitrus");
+const hardware = zitrus.hardware;
+const BitpackedArray = hardware.BitpackedArray;
diff --git a/src/platform/3ds/mango/hardware/cpu/arm9.zig b/src/platform/3ds/mango/hardware/cpu/arm9.zig
new file mode 100644
index 0000000..7d93d74
--- /dev/null
+++ b/src/platform/3ds/mango/hardware/cpu/arm9.zig
@@ -0,0 +1,83 @@
+pub const Control = packed struct(u32) {
+    mmu: bool = false,
+    _reserved0: u1 = 0,
+    data_cache: bool = false,
+    _reserved1: u4 = std.math.maxInt(u4),
+    big_endian: bool = false,
+    _reserved2: u4 = 0,
+    instruction_cache: bool = false,
+    alternate_exception_vectors: bool = false,
+    cache_round_robin_replacement: bool = false,
+    disable_thumb_by_pc_loads: bool = false,
+    data_tcm: bool = false,
+    data_tcm_load_mode: bool = false,
+    instruction_tcm: bool = false,
+    instruction_tcm_load_mode: bool = false,
+    _reserved3: u12 = 0,
+
+    pub inline fn read() Control {
+        return asm volatile ("mrc p15, 0, %[cnt], c1, c0, 0"
+            : [cnt] "=r" (-> Control),
+        );
+    }
+
+    pub inline fn write(cnt: Control) void {
+        return asm volatile ("mcr p15, 0, %[cnt], c1, c0, 0"
+            :
+            : [cnt] "r" (cnt),
+        );
+    }
+};
+
+pub const Interrupt = packed struct(u32) {
+    pub const Registers = extern struct {
+        enable: Interrupt,
+        flags: Interrupt,
+    };
+
+    pub const Pxi = packed struct(u3) {
+        sync: bool,
+        send_emoty: bool,
+        receive_full: bool,
+    };
+
+    pub const Sdio = packed struct(u2) {
+        controller: bool,
+        async: bool,
+    };
+
+    pub const Debug = packed struct(u2) {
+        receive: bool,
+        send: bool,
+    };
+
+    pub const Gamecard = packed struct(u2) {
+        power_off: bool,
+        insert: bool,
+    };
+
+    pub const Xdma = packed struct(u2) {
+        event: bool,
+        fault: bool,
+    };
+
+    ndma: BitpackedArray(bool, 8),
+    timer: BitpackedArray(bool, 4),
+    pxi: Pxi,
+    aes: bool,
+    sdio: BitpackedArray(Sdio, 2),
+    debug: Debug,
+    rsa: bool,
+    ctr_card: BitpackedArray(bool, 2),
+    gamecard: Gamecard,
+    ntr_card: bool,
+    xdma: Xdma,
+    _unused0: u2 = 0,
+};
+
+// CP15 c0 c0 2 -> TCM size
+
+const std = @import("std");
+const zitrus = @import("zitrus");
+const hardware = zitrus.hardware;
+const BitpackedArray = hardware.BitpackedArray;
diff --git a/src/platform/3ds/mango/hardware/csnd.zig b/src/platform/3ds/mango/hardware/csnd.zig
new file mode 100644
index 0000000..fa59fe9
--- /dev/null
+++ b/src/platform/3ds/mango/hardware/csnd.zig
@@ -0,0 +1,116 @@
+//! Definitions for MMIO `CSND` registers.
+//!
+//! Based on the documentation found in GBATEK and 3dbrew:
+//! - https://problemkaputt.de/gbatek.htm#3dssoundandmicrophone
+//! - https://www.3dbrew.org/wiki/CSND_Registers
+
+pub const Volume = enum(u16) {
+    pub const min: Volume = .volume(0);
+    pub const max: Volume = .volume(0);
+
+    _,
+
+    pub fn volume(value: u16) Volume {
+        return @enumFromInt(@min(value, 0x8000));
+    }
+};
+
+pub const SampleRate = enum(u16) {
+    pub const min: SampleRate = .rate(0);
+    pub const max: SampleRate = .rate(0xFFBE);
+
+    _,
+
+    pub fn rate(value: u16) SampleRate {
+        std.debug.assert(value <= 0xFFBE);
+        return @enumFromInt(value);
+    }
+};
+
+pub const MasterControl = packed struct(u32) {
+    volume: Volume,
+    mute: bool,
+    _unused0: u13,
+    dissonant_disable: bool,
+    /// When this is not true, some registers won't be written.
+    read_write: bool,
+};
+
+pub const Channel = extern struct {
+    pub const WaveDuty = enum(u3) { _ };
+    pub const Format = enum(u2) { pcm8, pcm16, ima_adpcm, psg };
+    pub const Repeat = enum(u2) { manual, loop, one_shot, loop_constant };
+
+    pub const Control = packed struct(u32) {
+        wave_duty: WaveDuty,
+        _unused0: u2 = 0,
+        interpolate_linearly: bool,
+        hold_last: bool,
+        _unused1: u2 = 0,
+        repeat: Repeat,
+        format: Format,
+        pause_disable: bool,
+        busy: bool,
+        sample_rate: SampleRate,
+    };
+
+    pub const ImaAdPcm = packed struct(u32) {
+        value: i16,
+        index_value: u7,
+        _unused0: u8,
+        reload_second_buffer_state: bool,
+    };
+
+    pub const Volume = packed struct(u32) {
+        right: csnd.Volume,
+        left: csnd.Volume,
+    };
+
+    control: Control,
+    output_volume: Channel.Volume,
+    capture_volume: Channel.Volume,
+    start_address: PhysicalAddress,
+    total_size: hardware.LsbRegister(u27),
+    // So you can start with some sound and then loop with another? If true cool.
+    // XXX: 3dbrew says this is the other channel? When this is 0x0 then mono audio is played. Name is not accurate
+    loop_restart_address: PhysicalAddress,
+    start_ima_state: ImaAdPcm,
+    restart_ima_state: ImaAdPcm,
+};
+
+pub const Capture = extern struct {
+    pub const Format = enum(u1) { pcm16, pcm8 };
+
+    pub const Control = packed struct(u32) {
+        one_shot: bool,
+        format: Format,
+        _unknown0: u1,
+        _unused0: u12 = 0,
+        busy: bool,
+        _unused1: u16 = 0,
+    };
+
+    control: Control,
+    sample_rate: LsbRegister(SampleRate),
+    length: LsbRegister(u24),
+    address: PhysicalAddress,
+};
+
+pub const Registers = extern struct {
+    master: MasterControl,
+    _unused0: [0x3FC]u8,
+    channels: [32]Channel,
+    captures: [2]Capture,
+};
+
+const csnd = @This();
+
+const std = @import("std");
+
+const zitrus = @import("zitrus");
+const hardware = zitrus.hardware;
+
+const LsbRegister = hardware.LsbRegister;
+const MsbRegister = hardware.MsbRegister;
+
+const PhysicalAddress = hardware.PhysicalAddress;
diff --git a/src/platform/3ds/mango/hardware/dsp.zig b/src/platform/3ds/mango/hardware/dsp.zig
new file mode 100644
index 0000000..15c9578
--- /dev/null
+++ b/src/platform/3ds/mango/hardware/dsp.zig
@@ -0,0 +1,90 @@
+//! Definitions for MMIO `DSP` registers.
+//!
+//! Used for **D**igital **S**ignal **P**rocessing, a.k.a: sound.
+//! Its an independent processor named *TeakLite II* from XpertTeak.
+//!
+//!
+//! Based on the documentation found in GBATEK and 3dbrew:
+//! - https://problemkaputt.de/gbatek.htm#3dssoundandmicrophone
+
+pub const Address = enum(u16) {
+    _,
+
+    pub fn init(address: u16) Address {
+        return @enumFromInt(address);
+    }
+};
+
+pub const Configuration = packed struct(u16) {
+    pub const Region = enum(u2) { data, mmio, code, ahbm };
+    pub const Length = enum(u2) { @"1", @"8", @"16", free };
+
+    reset: bool,
+    auto_increment_transfer_address: bool,
+    read_length: Length,
+    read_start: bool,
+    irq_read_fifo_full: bool,
+    irq_read_fifo_not_empty: bool,
+    irq_write_fifo_full: bool,
+    irq_write_fifo_empty: bool,
+    irq_reply_register: BitpackedArray(bool, 3),
+    transfer_region: Region,
+};
+
+pub const Status = packed struct(u16) {
+    reading: bool,
+    writing: bool,
+    resetting: bool,
+    _unused0: u2,
+    read_fifo_full: bool,
+    read_fifo_not_empty: bool,
+    write_fifo_full: bool,
+    write_fifo_empty: bool,
+    semaphore_irq: bool,
+    reply_register_unwritten: BitpackedArray(bool, 3),
+    command_register_unread: BitpackedArray(bool, 3),
+};
+
+pub const Semaphore = extern struct {
+    send: BitpackedArray(bool, 16),
+    _unused0: [2]u8,
+    irq_disable: BitpackedArray(bool, 16),
+    _unused1: [2]u8,
+    send_clear: BitpackedArray(bool, 16),
+    _unused2: [2]u8,
+    receive: BitpackedArray(bool, 16),
+    _unused3: [2]u8,
+};
+
+pub const Registers = extern struct {
+    fifo: u16,
+    _unused0: [2]u8,
+    transfer_address: Address,
+    _unused1: [2]u8,
+    config: Configuration,
+    _unused2: [2]u8,
+    status: Status,
+    _unused3: [2]u8,
+    semaphore: Semaphore,
+    command0: u16,
+    _unused4: [2]u8,
+    reply0: u16,
+    _unused5: [2]u8,
+    command1: u16,
+    _unused6: [2]u8,
+    reply1: u16,
+    _unused7: [2]u8,
+    command2: u16,
+    _unused8: [2]u8,
+    reply2: u16,
+    _unused9: [2]u8,
+};
+
+const dsp = @This();
+
+const std = @import("std");
+
+const zitrus = @import("zitrus");
+const hardware = zitrus.hardware;
+
+const BitpackedArray = hardware.BitpackedArray;
diff --git a/src/platform/3ds/mango/hardware/hid.zig b/src/platform/3ds/mango/hardware/hid.zig
new file mode 100644
index 0000000..45adc62
--- /dev/null
+++ b/src/platform/3ds/mango/hardware/hid.zig
@@ -0,0 +1,54 @@
+//! Definitions for MMIO `HID` registers.
+//!
+//! Used only for main PAD buttons (Cicle Pad + New3DS buttons not included)
+//!
+//! Based on the documentation found in GBATEK: https://problemkaputt.de/gbatek.htm#3dsmiscregisters
+
+pub const State = packed struct(u16) {
+    a: bool,
+    b: bool,
+    select: bool,
+    start: bool,
+    right: bool,
+    left: bool,
+    up: bool,
+    down: bool,
+    r: bool,
+    l: bool,
+    x: bool,
+    y: bool,
+    _unused0: u3 = 0,
+};
+
+pub const Interrupt = packed struct(u16) {
+    pub const Condition = enum(u1) { @"or", @"and" };
+
+    pub const Source = packed struct(u12) {
+        a: bool,
+        b: bool,
+        select: bool,
+        start: bool,
+        right: bool,
+        left: bool,
+        up: bool,
+        down: bool,
+        r: bool,
+        l: bool,
+        x: bool,
+        y: bool,
+    };
+
+    source: Source,
+    _unused0: u2 = 0,
+    enable: bool,
+    condition: Condition,
+};
+
+pub const Registers = extern struct {
+    released: State,
+    irq: Interrupt,
+};
+
+const hid = @This();
+
+const zitrus = @import("zitrus");
diff --git a/src/platform/3ds/mango/hardware/i2c.zig b/src/platform/3ds/mango/hardware/i2c.zig
new file mode 100644
index 0000000..0a4e128
--- /dev/null
+++ b/src/platform/3ds/mango/hardware/i2c.zig
@@ -0,0 +1,45 @@
+//! Definitions for MMIO `HID` registers.
+//!
+//! Used for numerous things.
+//!
+//! Based on the documentation found in GBATEK: https://problemkaputt.de/gbatek.htm#3dsi2cregisters
+
+pub const Direction = enum(u1) { write, read };
+
+pub const Control = packed struct(u8) {
+    stop: bool,
+    start: bool,
+    pause: bool,
+    _unknown0: u1 = 0,
+    ack: bool,
+    direction: Direction,
+    irq_enable: bool,
+    busy: bool,
+};
+
+pub const ControlExtended = packed struct(u16) {
+    clock: bool,
+    wait_if_clock_low: bool,
+    _unused0: u13 = 0,
+    _unknown1: u1 = 0,
+};
+
+pub const Speed = enum(u6) {
+    _,
+};
+
+pub const Bus = extern struct {
+    pub const Clock = packed struct(u16) {
+        low: Speed,
+        _unused0: u2 = 0,
+        high: Speed,
+        _unused1: u2 = 0,
+    };
+
+    data: u8,
+    control: Control,
+    control_extended: ControlExtended,
+    clock: Clock,
+};
+
+const std = @import("std");
diff --git a/src/platform/3ds/mango/hardware/lcd.zig b/src/platform/3ds/mango/hardware/lcd.zig
new file mode 100644
index 0000000..2629c48
--- /dev/null
+++ b/src/platform/3ds/mango/hardware/lcd.zig
@@ -0,0 +1,92 @@
+//! Definitions for MMIO `LCD` registers.
+//!
+//! Based on the documentation found in GBATEK: https://problemkaputt.de/gbatek.htm#3dsvideolcdregisters
+
+pub const Parallax = extern struct {
+    pub const Control = packed struct(u32) {
+        pub const Enable = enum(u2) { off, enable, _ };
+
+        tp27_enable: Enable,
+        tp27_invert_output: bool,
+        _unused0: u13 = 0,
+        tp29_enable: Enable,
+        tp29_invert_output: bool,
+        _unused1: u13 = 0,
+    };
+
+    pub const Duty = packed struct(u32) {
+        /// (off + 1) * 0.9us
+        off: u16,
+        /// (on + 1) * 0.9us
+        on: u16,
+    };
+
+    control: Control,
+    /// Controls the TP27 parallax PWM
+    duty: Duty,
+};
+
+pub const Screen = extern struct {
+    pub const Flags = packed struct(u32) {
+        abl_enable: bool,
+        _unused0: u7 = 0,
+        dither_related: BitpackedArray(bool, 2),
+        _unused1: u22 = 0,
+    };
+
+    pub const Fill = packed struct(u32) {
+        r: u8,
+        g: u8,
+        b: u8,
+        enable: bool,
+        _unused0: u7 = 0,
+    };
+
+    pub const AdaptiveBacklight = extern struct {
+        // TODO: lazy
+        _todo: [0x5F8]u8,
+    };
+
+    flags: Flags,
+    fill: Fill,
+    adaptive_backlight: AdaptiveBacklight,
+
+    comptime {
+        std.debug.assert(@sizeOf(Screen) == 0x600);
+    }
+};
+
+pub const Clock = packed struct(u32) {
+    top_disable: bool = false,
+    _unused0: u15 = 0,
+    bottom_disable: bool = false,
+    _unused1: u15 = 0,
+};
+
+pub const Status = packed struct(u32) {
+    _: u32 = 0,
+};
+
+pub const Reset = enum(u1) { reset, enable };
+
+pub const Registers = extern struct {
+    parallax: Parallax,
+    status: Status,
+    clock: Clock,
+    _unknown0: u32,
+    reset: LsbRegister(Reset),
+    _unused0: [122]u32,
+    top: Screen,
+    _unused1: [128]u32,
+    bottom: Screen,
+};
+
+const lcd = @This();
+
+const std = @import("std");
+
+const zitrus = @import("zitrus");
+const hardware = zitrus.hardware;
+
+const LsbRegister = hardware.LsbRegister;
+const BitpackedArray = hardware.BitpackedArray;
diff --git a/src/platform/3ds/mango/hardware/lgy.zig b/src/platform/3ds/mango/hardware/lgy.zig
new file mode 100644
index 0000000..f3def32
--- /dev/null
+++ b/src/platform/3ds/mango/hardware/lgy.zig
@@ -0,0 +1,138 @@
+//! Definitions for MMIO `LGY` registers.
+//!
+//! Used for **L**e**g**ac**y** framebuffer conversion, NDS/GBA -> 3DS.
+//!
+//! Based on the documentation found in GBATEK: https://problemkaputt.de/gbatek.htm#3dsvideolgyregisterslegacygbandsvideotoframebuffer
+
+pub const Framebuffer = extern struct {
+    pub const Format = enum(u2) { abgr8888, bgr888, rgb5551, rgb565 };
+    pub const Rotate = enum(u2) { none, @"90", @"180", @"270" };
+
+    pub const Control = packed struct(u32) {
+        start: bool,
+        enable_vertical_scaling: bool,
+        enable_horizontal_scaling: bool,
+        _unused0: u1 = 0,
+        brightness_dither_enable: bool,
+        _brigness_dither_enable_too: bool,
+        _unused1: u2 = 0,
+        format: Format,
+        /// Clockwise rotation
+        rotate: Rotate,
+        swizzle: bool,
+        _unused2: u2 = 0,
+        dma: bool,
+        _unused3: u16 = 0,
+    };
+
+    pub const Dimensions = packed struct(u32) {
+        width_minus_one: u9,
+        _unused0: u7,
+        height_minus_one: u9,
+        _unused1: u7,
+
+        pub fn init(width: u9, height: u9) Dimensions {
+            return .{ .width_minus_one = width - 1, .height_minus_one = height - 1 };
+        }
+    };
+
+    pub const InterruptStatus = packed struct(u32) {
+        first_block: bool,
+        next_block: bool,
+        last_line: bool,
+        _unused0: u13 = 0,
+        current_block_line: u8,
+        _unused1: u8 = 0,
+    };
+
+    pub const InterruptEnable = packed struct(u32) {
+        first_block: bool,
+        next_block: bool,
+        last_line: bool,
+        _unused0: u29 = 0,
+    };
+
+    pub const Scaling = extern struct {
+        /// Scale according `length` output pixels.
+        ///
+        /// `bits` tell which input pixels get used, effectively making it `length` / `bits`
+        pub const Pattern = extern struct {
+            pub const @"1x": Pattern = .init(1, .splat(1));
+            pub const @"1.16x": Pattern = .init(7, .init(.{ 1, 1, 0, 1, 1, 0, 1, 0 }));
+            pub const @"1.2x": Pattern = .init(6, .init(.{ 1, 1, 1, 0, 1, 1, 0, 0 }));
+            pub const @"1.25x": Pattern = .init(5, .init(.{ 1, 1, 0, 1, 1, 0, 0, 0 }));
+            pub const @"1.33x": Pattern = .init(4, .init(.{ 1, 1, 1, 0, 0, 0, 0, 0 }));
+            pub const @"1.4x": Pattern = .init(7, .init(.{ 1, 1, 1, 1, 1, 0, 0, 0 }));
+            pub const @"1.5x": Pattern = .init(3, .init(.{ 1, 1, 0, 0, 0, 0, 0, 0 }));
+            pub const @"1.66x": Pattern = .init(5, .init(.{ 1, 1, 1, 0, 1, 0, 0, 0 }));
+            pub const @"1.75x": Pattern = .init(7, .init(.{ 1, 0, 1, 0, 1, 0, 1, 0 }));
+            pub const @"2x": Pattern = .init(2, .init(.{ 1, 0, 0, 0, 0, 0, 0, 0 }));
+            pub const @"2.33x": Pattern = .init(7, .init(.{ 1, 0, 0, 1, 0, 0, 1, 0 }));
+            pub const @"2.5x": Pattern = .init(5, .init(.{ 1, 0, 1, 0, 0, 0, 0, 0 }));
+            pub const @"2.66x": Pattern = .init(8, .init(.{ 1, 0, 0, 1, 0, 0, 0, 1 }));
+            pub const @"3x": Pattern = .init(3, .init(.{ 1, 0, 0, 0, 0, 0, 0, 0 }));
+            pub const @"3.5x": Pattern = .init(7, .init(.{ 1, 0, 0, 1, 0, 0, 0, 0 }));
+
+            length: LsbRegister(u3),
+            bits: LsbRegister(BitpackedArray(u1, 8)),
+
+            pub fn init(length: u3, bits: BitpackedArray(u1, 8)) Pattern {
+                return .{ .length = length, .bits = bits };
+            }
+        };
+
+        pub const Brightness = enum(u16) { _ };
+
+        pattern: Pattern,
+        _unused0: [0x38]u8,
+        brightness: [6][8]LsbRegister(Brightness),
+
+        comptime {
+            std.debug.assert(@sizeOf(Scaling) == 0x100);
+        }
+    };
+
+    control: Control,
+    size: Dimensions,
+    irq_status: InterruptStatus,
+    irq_enable: InterruptEnable,
+    _unused0: [0x10]u8,
+    alpha: LsbRegister(u8),
+    _unused1: [0xCC]u8,
+    prefetch: LsbRegister(u4),
+    _unused2: [0x0C]u8,
+    dither: [4]u64,
+    _unused3: [0xE0]u8,
+    vertical_scaling: Scaling,
+    horizontal_scaling: Scaling,
+
+    comptime {
+        std.debug.assert(@sizeOf(Framebuffer) == 0x400);
+    }
+};
+
+pub const Config = extern struct {
+    bottom: Framebuffer,
+    _unused0: [0xC00]u8,
+    top: Framebuffer,
+};
+
+pub const Fifo = extern struct {
+    bottom: [0x1000]u8,
+    top: [0x1000]u8,
+};
+
+comptime {
+    _ = Config;
+    _ = Fifo;
+}
+
+const lgy = @This();
+
+const std = @import("std");
+
+const zitrus = @import("zitrus");
+const hardware = zitrus.hardware;
+
+const LsbRegister = hardware.LsbRegister;
+const BitpackedArray = hardware.BitpackedArray;
diff --git a/src/platform/3ds/mango/hardware/pica.zig b/src/platform/3ds/mango/hardware/pica.zig
new file mode 100644
index 0000000..9fa5859
--- /dev/null
+++ b/src/platform/3ds/mango/hardware/pica.zig
@@ -0,0 +1,2940 @@
+//! Definitions for MMIO `PICA200` registers.
+//!
+//! - LCD screens are physically rotated 90º CCW from how the devices are held (i.e: bottom is not 320x240, is 240x320)
+//! - NDC clipping volume:
+//!     - X: [-W, W]
+//!     - Y: [-W, W]
+//!     - Z: [0, -W]
+//! - Framebuffer origin can be changed so `-1` in NDC could mean bottom-left (GL) or top-left (D3D, Metal, VK)
+//! - Texture Origin is Bottom-Left, they are sampled from bottom (0, 0) to top (1, 1).
+//!
+//! WARNING: zitrus has opinionated register naming that suit better their usage!
+//!
+//! Based on the documentation found in GBATEK and 3dbrew:
+//! - https://problemkaputt.de/gbatek.htm#3dsgpuinternalregisteroverview
+//! - https://www.3dbrew.org/wiki/GPU/External_Registers
+//! - https://www.3dbrew.org/wiki/GPU/Internal_Registers
+
+pub const command = @import("pica/command.zig");
+pub const shader = @import("pica/shader.zig");
+
+pub const UQ0_11 = zsflt.Fixed(.unsigned, 0, 11);
+pub const UQ0_12 = zsflt.Fixed(.unsigned, 0, 12);
+pub const UQ0_23 = zsflt.Fixed(.unsigned, 0, 23);
+pub const Q4_8 = zsflt.Fixed(.signed, 4, 8);
+pub const Q0_11 = zsflt.Fixed(.signed, 0, 11);
+pub const Q1_11 = zsflt.Fixed(.signed, 1, 11);
+
+pub const F5_10 = zsflt.Float(5, 10);
+pub const F3_12 = zsflt.Float(3, 12);
+pub const F7_12 = zsflt.Float(7, 12);
+pub const F7_16 = zsflt.Float(7, 16);
+pub const F7_23 = zsflt.Float(7, 23);
+pub const F8_23 = zsflt.Float(8, 23);
+
+pub const Q1_11x2 = packed struct(u32) {
+    x: Q1_11,
+    _unused0: u3 = 0,
+    y: Q1_11,
+    _unused1: u3 = 0,
+
+    pub fn init(x: Q1_11, y: Q1_11) Q1_11x2 {
+        return .{ .x = x, .y = y };
+    }
+};
+
+pub const F5_10x2 = packed struct(u32) {
+    x: F5_10,
+    y: F5_10,
+
+    pub fn init(x: F5_10, y: F5_10) F5_10x2 {
+        return .{ .x = x, .y = y };
+    }
+};
+
+pub const F7_16x4 = extern struct {
+    pub const Unpacked = struct { x: F7_16, y: F7_16, z: F7_16, w: F7_16 };
+
+    data: [@divExact(@bitSizeOf(F7_16) * 4, @bitSizeOf(u32))]u32,
+
+    pub fn pack(x: F7_16, y: F7_16, z: F7_16, w: F7_16) F7_16x4 {
+        var vec: F7_16x4 = undefined;
+        const vec_bytes = std.mem.asBytes(&vec.data);
+
+        std.mem.writePackedInt(u24, vec_bytes, 0, @bitCast(x), .little);
+        std.mem.writePackedInt(u24, vec_bytes, @bitSizeOf(F7_16), @bitCast(y), .little);
+        std.mem.writePackedInt(u24, vec_bytes, @bitSizeOf(F7_16) * 2, @bitCast(z), .little);
+        std.mem.writePackedInt(u24, vec_bytes, @bitSizeOf(F7_16) * 3, @bitCast(w), .little);
+        std.mem.swap(u32, &vec.data[0], &vec.data[2]);
+
+        return vec;
+    }
+
+    pub fn unpack(value: F7_16x4) [4]F7_16 {
+        var unpacked: [3]u32 = value.data;
+        std.mem.swap(u32, &unpacked[0], &unpacked[2]);
+
+        return .{
+            @bitCast(std.mem.readPackedInt(u24, @ptrCast(&unpacked), 0, .little)),
+            @bitCast(std.mem.readPackedInt(u24, @ptrCast(&unpacked), @bitSizeOf(F7_16), .little)),
+            @bitCast(std.mem.readPackedInt(u24, @ptrCast(&unpacked), @bitSizeOf(F7_16) * 2, .little)),
+            @bitCast(std.mem.readPackedInt(u24, @ptrCast(&unpacked), @bitSizeOf(F7_16) * 3, .little)),
+        };
+    }
+};
+
+pub const morton = struct {
+    /// Returns the morton/z-order coordinates for `value`
+    pub fn toDimensions(comptime T: type, comptime dimensions: usize, value: T) [dimensions]std.meta.Int(.unsigned, @divExact(@bitSizeOf(T), dimensions)) {
+        std.debug.assert(@typeInfo(T) == .int);
+        const DecomposedInt = std.meta.Int(.unsigned, @divExact(@bitSizeOf(T), dimensions));
+
+        // Basically bits are interleaved
+        // 2-dimensional 8-bits example: yxyxyxyx
+        var values: [dimensions]DecomposedInt = @splat(0);
+        var current_value = value;
+        inline for (0..@bitSizeOf(T)) |i| {
+            const shift = i / dimensions;
+            const set = &values[i % dimensions];
+
+            set.* |= @intCast((current_value & 0b1) << shift);
+            current_value >>= 1;
+        }
+
+        return values;
+    }
+
+    test toDimensions {
+        try testing.expectEqual([2]u3{ 0b001, 0b001 }, toDimensions(u6, 2, 0b000011));
+        try testing.expectEqual([2]u3{ 0b010, 0b010 }, toDimensions(u6, 2, 0b001100));
+        try testing.expectEqual([2]u3{ 0b011, 0b011 }, toDimensions(u6, 2, 0b001111));
+        try testing.expectEqual([2]u3{ 0b111, 0b111 }, toDimensions(u6, 2, 0b111111));
+    }
+
+    /// Returns the morton linear index for the coordinates.
+    pub fn toIndex(comptime T: type, comptime dimensions: usize, value: [dimensions]T) std.meta.Int(.unsigned, dimensions * @bitSizeOf(T)) {
+        std.debug.assert(@typeInfo(T) == .int);
+
+        const IndexType = std.meta.Int(.unsigned, dimensions * @bitSizeOf(T));
+        const max_index = dimensions * @bitSizeOf(T);
+        var index: IndexType = 0;
+
+        inline for (0..max_index) |i| {
+            const dimension = i % dimensions;
+            const dimension_bit = i / dimensions;
+
+            index |= (@as(IndexType, value[dimension]) << (i - dimension_bit)) & (@as(IndexType, 1) << i);
+        }
+
+        return index;
+    }
+
+    test toIndex {
+        try testing.expectEqual(0b000011, toIndex(u3, 2, .{ 1, 1 }));
+        try testing.expectEqual(0b001100, toIndex(u3, 2, .{ 2, 2 }));
+        try testing.expectEqual(0b001111, toIndex(u3, 2, .{ 3, 3 }));
+        try testing.expectEqual(0b110000, toIndex(u3, 2, .{ 4, 4 }));
+        try testing.expectEqual(0b111111, toIndex(u3, 2, .{ 7, 7 }));
+
+        try testing.expectEqual(0b101011, toIndex(u3, 2, .{ 1, 7 }));
+        try testing.expectEqual(0b011101, toIndex(u3, 2, .{ 7, 2 }));
+    }
+
+    // TODO: We could test fuzzing (zig 0.16.0) value -> toDimensions -> toIndex -> value, as it must always be idempotent
+
+    pub const Strategy = enum {
+        /// Linear -> Morton
+        tile,
+        /// Morton -> Linear
+        untile,
+    };
+
+    pub const ConversionOptions = struct {
+        input_x: usize,
+        input_y: usize,
+        input_stride: usize,
+
+        output_x: usize,
+        output_y: usize,
+        output_stride: usize,
+
+        width: usize,
+        height: usize,
+
+        pixel_size: usize,
+
+        pub fn full(width: usize, height: usize, pixel_size: usize) ConversionOptions {
+            return .{
+                .input_x = 0,
+                .input_y = 0,
+                .input_stride = width * pixel_size,
+
+                .output_x = 0,
+                .output_y = 0,
+                .output_stride = width * pixel_size,
+
+                .width = width,
+                .height = height,
+
+                .pixel_size = pixel_size,
+            };
+        }
+    };
+
+    /// Asserts that the Morton-tiled Image is divisible by the `tile_size`
+    pub fn convert2(comptime strategy: Strategy, comptime tile_size: usize, dst_pixels: []u8, src_pixels: []const u8, opts: ConversionOptions) void {
+        comptime std.debug.assert(std.math.isPowerOfTwo(tile_size)); // We depend on this and the PICA only supports 2x2 (ETC), 8x8 and 32x32 tile sizes.
+
+        const tile_pixels = (tile_size * tile_size);
+        const subtile_mask = (tile_size - 1);
+        const tile_shift = comptime std.math.log2(tile_size);
+
+        const output_real_width = opts.output_stride / opts.pixel_size;
+
+        for (0..opts.height) |current_y| {
+            const input_y = current_y + opts.input_y;
+            const output_y = current_y + opts.output_y;
+
+            for (0..opts.width) |current_x| {
+                const input_x = current_x + opts.input_x;
+                const output_x = current_x + opts.output_x;
+
+                const src_pixel, const dst_pixel = pxl: switch (strategy) {
+                    .tile => {
+                        const src_index = input_y * opts.input_stride + input_x * opts.pixel_size;
+
+                        std.debug.assert((output_real_width & subtile_mask) == 0);
+                        const dst_tile_pixels_per_line = (output_real_width >> tile_shift) * tile_pixels;
+
+                        const dst_tile_y = output_y >> tile_shift;
+                        const dst_tile_x = output_x >> tile_shift;
+
+                        const dst_subtile_y: u3 = @intCast(output_y & subtile_mask);
+                        const dst_subtile_x: u3 = @intCast(output_x & subtile_mask);
+                        const dst_subtile_morton = toIndex(u3, 2, .{ dst_subtile_x, dst_subtile_y });
+
+                        const dst_pixel_start = (dst_tile_y * dst_tile_pixels_per_line) + (dst_tile_x * tile_pixels);
+                        const dst_index = (dst_pixel_start + dst_subtile_morton) * opts.pixel_size;
+
+                        break :pxl .{ src_pixels[src_index..][0..opts.pixel_size], dst_pixels[dst_index..][0..opts.pixel_size] };
+                    },
+                    .untile => {
+                        comptime unreachable; // TODO
+                    },
+                };
+
+                @memcpy(dst_pixel, src_pixel);
+            }
+        }
+    }
+
+    pub fn convert(comptime strategy: Strategy, comptime tile_size: usize, width: usize, pixel_size: usize, dst_pixels: []u8, src_pixels: []const u8) void {
+        std.debug.assert(dst_pixels.len == src_pixels.len);
+        const max_tile_subindex = (tile_size * tile_size);
+        const SubindexInt = std.math.IntFittingRange(0, max_tile_subindex - 1);
+
+        const height = @divExact(@divExact(src_pixels.len, pixel_size), width);
+        const width_tiles = @divExact(width, tile_size);
+        const height_tiles = @divExact(height, tile_size);
+        const stride = width * pixel_size;
+
+        var i: usize = 0;
+        for (0..height_tiles) |y_tile| {
+            const y_start = y_tile * tile_size;
+
+            for (0..width_tiles) |x_tile| {
+                const x_start = x_tile * tile_size;
+
+                for (0..max_tile_subindex) |tile| {
+                    const x, const y = toDimensions(SubindexInt, 2, @intCast(tile));
+
+                    const linear_index = i;
+                    const morton_index = (y_start + y) * stride + (x_start + x) * pixel_size;
+
+                    const src_pixel, const dst_pixel = switch (strategy) {
+                        .tile => .{ src_pixels[morton_index..][0..pixel_size], dst_pixels[linear_index..][0..pixel_size] },
+                        .untile => .{ src_pixels[linear_index..][0..pixel_size], dst_pixels[morton_index..][0..pixel_size] },
+                    };
+
+                    @memcpy(dst_pixel, src_pixel);
+                    i += pixel_size;
+                }
+            }
+        }
+    }
+
+    pub fn convertNibbles(comptime strategy: Strategy, comptime tile_size: usize, width: usize, dst_pixels: []u8, src_pixels: []const u8) void {
+        std.debug.assert(dst_pixels.len == src_pixels.len);
+        const max_tile_subindex = (tile_size * tile_size);
+        const SubindexInt = std.math.IntFittingRange(0, max_tile_subindex - 1);
+
+        const height = @divExact(src_pixels.len << 1, width);
+        const width_tiles = @divExact(width, tile_size);
+        const height_tiles = @divExact(height, tile_size);
+        const stride = @divExact(width, 2);
+
+        var i: usize = 0;
+        for (0..height_tiles) |y_tile| {
+            const y_start = y_tile * tile_size;
+
+            for (0..width_tiles) |x_tile| {
+                const x_start = x_tile * tile_size;
+
+                for (0..max_tile_subindex) |tile| {
+                    const x, const y = toDimensions(SubindexInt, 2, @intCast(tile));
+
+                    const linear_index = i >> 1;
+                    const second_linear_nibble = (i & 1) != 0;
+
+                    const morton_x = (x_start + x);
+                    const morton_index = (y_start + y) * stride + (morton_x >> 1);
+                    const second_morton_nibble = (morton_x & 1) != 0;
+
+                    const src_pixel, const dst_pixel, const second_src_nibble, const second_dst_nibble = switch (strategy) {
+                        .tile => .{ &src_pixels[morton_index], &dst_pixels[linear_index], second_morton_nibble, second_linear_nibble },
+                        .untile => .{ &src_pixels[linear_index], &dst_pixels[morton_index], second_linear_nibble, second_morton_nibble },
+                    };
+
+                    const src_nibble = if (second_src_nibble) (src_pixel.* >> 4) else (src_pixel.* & 0xF);
+                    const last_dst_pixel = dst_pixel.*;
+
+                    dst_pixel.* = if (second_dst_nibble) (last_dst_pixel & 0xF) | (src_nibble << 4) else (last_dst_pixel & 0xF0) | src_nibble;
+                    i += 1;
+                }
+            }
+        }
+    }
+};
+
+pub const Screen = enum(u1) {
+    pub const width_po2 = 256;
+
+    top,
+    bottom,
+
+    pub fn other(screen: Screen) Screen {
+        return switch (screen) {
+            .top => .bottom,
+            .bottom => .top,
+        };
+    }
+
+    pub inline fn width(_: Screen) usize {
+        return 240;
+    }
+
+    pub inline fn height(screen: Screen) usize {
+        return switch (screen) {
+            .top => 400,
+            .bottom => 320,
+        };
+    }
+};
+
+/// Deprecated: DisplayController.Framebuffer.Pixel.Size
+pub const PixelSize = DisplayController.Framebuffer.Pixel.Size;
+
+/// Deprecated: DisplayController.Framebuffer.Pixel
+pub const ColorFormat = DisplayController.Framebuffer.Pixel;
+
+/// Depth values are stored as normalized integers.
+pub const DepthStencilFormat = enum(u2) {
+    /// 2 bytes for depth, `0xDDDD`.
+    d16,
+    /// 3 bytes for depthm `0xDDDDDD`.
+    d24 = 2,
+    /// 3 bytes for depth and 1 byte for stencil `0xSSDDDDDD`.
+    d24_s8,
+
+    pub fn bytesPerPixel(format: DepthStencilFormat) usize {
+        return switch (format) {
+            .d16 => @sizeOf(u16),
+            .d24 => 3,
+            .d24_s8 => @sizeOf(u32),
+        };
+    }
+};
+
+/// Deprecated: use DisplayController.Framebuffer.Interlacing
+pub const FramebufferInterlacingMode = DisplayController.Framebuffer.Interlacing;
+
+/// Deprecated: use DisplayController.Framebuffer.Dma
+pub const DmaSize = DisplayController.Framebuffer.Dma;
+
+pub const TextureUnit = enum(u2) {
+    pub const main: TextureUnit = .@"0";
+    pub const procedural: TextureUnit = .@"3";
+
+    @"0",
+    @"1",
+    @"2",
+    @"3",
+};
+
+/// The front face is always counter-clockwise and cannot be changed.
+pub const CullMode = enum(u2) {
+    /// No triangles are discarded.
+    none,
+    /// Triangles with a counter-clockwise winding order are culled.
+    ccw,
+    /// Triangles with a clockwise winding order are culled.
+    cw,
+};
+
+pub const ScissorMode = enum(u2) {
+    /// No pixels will be discarded.
+    disable,
+    /// The pixels outside the scissor area will be rendered.
+    outside,
+    /// The pixels inside the scissor area will be rendered.
+    inside = 3,
+};
+
+pub const EarlyDepthCompareOperation = enum(u2) {
+    ge,
+    gt,
+    le,
+    lt,
+};
+
+pub const OutputMap = packed struct(u32) {
+    pub const Semantic = enum(u5) {
+        position_x,
+        position_y,
+        position_z,
+        position_w,
+
+        normal_quaternion_x,
+        normal_quaternion_y,
+        normal_quaternion_z,
+        normal_quaternion_w,
+
+        color_r,
+        color_g,
+        color_b,
+        color_a,
+
+        texture_coordinates_0_u,
+        texture_coordinates_0_v,
+        texture_coordinates_1_u,
+        texture_coordinates_1_v,
+        texture_coordinates_0_w,
+
+        view_x = 0x12,
+        view_y,
+        view_z,
+
+        texture_coordinates_2_u,
+        texture_coordinates_2_v,
+
+        unused = 0x1F,
+        _,
+
+        pub fn isNormalQuaternion(semantic: Semantic) bool {
+            return switch (semantic) {
+                .normal_quaternion_x, .normal_quaternion_y, .normal_quaternion_z, .normal_quaternion_w => true,
+                else => false,
+            };
+        }
+
+        pub fn isColor(semantic: Semantic) bool {
+            return switch (semantic) {
+                .color_r, .color_g, .color_b, .color_a => true,
+                else => false,
+            };
+        }
+
+        pub fn isTextureCoordinates0(semantic: Semantic) bool {
+            return switch (semantic) {
+                .texture_coordinates_0_u, .texture_coordinates_0_v, .texture_coordinates_0_w => true,
+                else => false,
+            };
+        }
+
+        pub fn isTextureCoordinates1(semantic: Semantic) bool {
+            return switch (semantic) {
+                .texture_coordinates_1_u, .texture_coordinates_1_v => true,
+                else => false,
+            };
+        }
+
+        pub fn isTextureCoordinates2(semantic: Semantic) bool {
+            return switch (semantic) {
+                .texture_coordinates_2_u, .texture_coordinates_2_v => true,
+                else => false,
+            };
+        }
+
+        pub fn isView(semantic: Semantic) bool {
+            return switch (semantic) {
+                .view_x, .view_y, .view_z => true,
+                else => false,
+            };
+        }
+    };
+
+    x: Semantic,
+    _unusd0: u3 = 0,
+    y: Semantic,
+    _unusd1: u3 = 0,
+    z: Semantic,
+    _unusd2: u3 = 0,
+    w: Semantic,
+    _unusd3: u3 = 0,
+
+    pub fn format(map: OutputMap, w: *std.Io.Writer) std.Io.Writer.Error!void {
+        try w.print("({}, {}, {}, {})", .{ map.x, map.y, map.z, map.w });
+    }
+};
+
+pub const BlendOperation = enum(u3) {
+    /// `src_factor * src + dst_factor * dst`
+    add,
+    /// `src_factor * src - dst_factor * dst`
+    sub,
+    /// `dst_factor * dst - src_factor * src`
+    reverse_sub,
+    /// `min(src_factor * src, dst_factor * dst)`
+    min,
+    /// `max(src_factor * src, dst_factor * dst)`
+    max,
+};
+
+pub const BlendFactor = enum(u4) {
+    zero,
+    one,
+    src_color,
+    one_minus_src_color,
+    dst_color,
+    one_minus_dst_color,
+    src_alpha,
+    one_minus_src_alpha,
+    dst_alpha,
+    one_minus_dst_alpha,
+    constant_color,
+    one_minus_constant_color,
+    constant_alpha,
+    one_minus_constant_alpha,
+    src_alpha_saturate,
+};
+
+pub const LogicOperation = enum(u4) {
+    clear,
+    @"and",
+    reverse_and,
+    copy,
+    set,
+    copy_inverted,
+    nop,
+    invert,
+    nand,
+    @"or",
+    nor,
+    xor,
+    equivalent,
+    and_inverted,
+    or_reverse,
+    or_inverted,
+};
+
+pub const CompareOperation = enum(u3) {
+    never,
+    always,
+    eq,
+    neq,
+    lt,
+    le,
+    gt,
+    ge,
+};
+
+pub const StencilOperation = enum(u3) {
+    /// Keep the current value.
+    keep,
+    /// Sets the value to `0`.
+    zero,
+    /// Sets the value to `reference`.
+    replace,
+    /// Increments the current value and clamps to the maximum representable unsigned value.
+    increment,
+    /// Decrements the current value and clamps to `0`.
+    decrement,
+    /// Bitwise-inverts the current value.
+    invert,
+    /// Increments the current value and clamps to `0` when the maximum value would have exceeded.
+    increment_wrap,
+    /// Decrements the current value and clamps to the maximum possible value when the value would go below `0`.
+    decrement_wrap,
+};
+
+/// The PICA200 supports only triangle-based primitive topologies.
+pub const PrimitiveTopology = enum(u2) {
+    /// Specifies a series of separate triangle primitives.
+    /// The number of primitives generated is `(vertexCount / 3)`
+    triangle_list,
+    /// Specifies a series of connected triangle primitives with consecutive triangles sharing an edge.
+    /// The number of primitives generated is `max(0, vertexCount - 2)`
+    triangle_strip,
+    /// Specifies a series of connected triangle primitives with all triangles sharing a common vertex.
+    /// The number of primitives generated is `max(0, vertexCount - 2)`
+    triangle_fan,
+    /// Specifies a series of triangle primitives which are to be defined by the geometry shader.
+    /// The number of primitives generated depends on the shader implementation.
+    geometry,
+
+    /// Another PICA200 classic. For `drawIndexed` (`drawElements` as GL people call it) you set
+    /// the primitive topology to `geometry`.
+    ///
+    /// Why? Ask the DMP engineers
+    pub fn indexedTopology(topology: PrimitiveTopology) PrimitiveTopology {
+        return switch (topology) {
+            .triangle_list => .geometry,
+            else => |topo| topo,
+        };
+    }
+};
+
+pub const IndexFormat = enum(u1) {
+    /// Specifies that indices are unsigned 8-bit numbers.
+    u8,
+    /// Specifies that indices are unsigned 16-bit numbers.
+    u16,
+};
+
+pub const TextureUnitFilter = enum(u1) {
+    nearest,
+    linear,
+};
+
+pub const TextureUnitAddressMode = enum(u3) {
+    clamp_to_edge,
+    clamp_to_border,
+    repeat,
+    mirrored_repeat,
+};
+
+pub const TextureUnitType = enum(u3) {
+    @"2d",
+    cube_map,
+    shadow_2d,
+    projection,
+    shadow_cube,
+    disabled,
+};
+
+pub const TextureUnitFormat = enum(u4) {
+    pub const Hilo88 = extern struct { g: u8, r: u8 };
+    pub const I8 = packed struct(u8) { i: u8 };
+    pub const A8 = packed struct(u8) { a: u8 };
+    pub const Ia88 = packed struct(u16) { i: u8, a: u8 };
+    pub const I4 = packed struct(u8) { i: u8 };
+    pub const A4 = packed struct(u8) { i: u8 };
+    pub const Ia44 = packed struct(u8) { i: u4, a: u4 };
+
+    abgr8888,
+    bgr888,
+    rgba5551,
+    rgb565,
+    rgba4444,
+    ia88,
+    hilo88,
+    i8,
+    a8,
+    ia44,
+    i4,
+    a4,
+    etc1,
+    etc1a4,
+
+    pub fn scale(format: TextureUnitFormat, size: usize) usize {
+        return switch (format) {
+            .abgr8888 => size << 2,
+            .bgr888 => size * 3,
+            .rgba5551, .rgb565, .rgba4444, .ia88, .hilo88 => size << 1,
+            .i8, .a8, .ia44, .etc1a4 => size,
+            .i4, .a4, .etc1 => size >> 1,
+        };
+    }
+};
+
+pub const TextureUnitTexture2Coordinates = enum(u1) {
+    @"2",
+    @"1",
+};
+
+pub const TextureUnitTexture3Coordinates = enum(u2) {
+    @"0",
+    @"1",
+    @"2",
+};
+
+pub const MemoryFill = extern struct {
+    pub const Control = packed struct(u32) {
+        pub const none: Control = .{ .busy = false, .width = .@"16" };
+
+        busy: bool,
+        finished: bool = false,
+        _unused0: u6 = 0,
+        width: PixelSize,
+        _unused1: u6 = 0,
+        _unknown0: u5 = 0,
+        _unused2: u11 = 0,
+
+        pub fn init(width: PixelSize) Control {
+            return .{ .busy = true, .width = width };
+        }
+    };
+
+    start: AlignedPhysicalAddress(.@"16", .@"8"),
+    end: AlignedPhysicalAddress(.@"16", .@"8"),
+    value: u32,
+    control: Control,
+};
+
+pub const PictureFormatter = extern struct {
+    pub const Dimensions = packed struct(u32) { width: u16, height: u16 };
+
+    pub const Copy = extern struct {
+        pub const Line = packed struct(u32) { width: u16, gap: u16 };
+
+        size: u32,
+        src: Line,
+        dst: Line,
+    };
+
+    pub const Flags = packed struct(u32) {
+        pub const Downscale = enum(u2) { none, @"2x1", @"2x2" };
+
+        flip_v: bool,
+        linear_tiled: bool,
+        output_width_less_than_input: bool,
+        copy: bool,
+        _unwritable0: u1 = 0,
+        tiled_tiled: bool,
+        _unwritable1: u2 = 0,
+        src_format: ColorFormat,
+        _unwritable2: u1 = 0,
+        dst_format: ColorFormat,
+        _unwritable3: u1 = 0,
+        use_32x32_tiles: bool,
+        _unwritable4: u7 = 0,
+        downscale: Downscale,
+        _unwritable5: u6 = 0,
+    };
+
+    pub const Control = packed struct(u32) {
+        start: bool,
+        _unused0: u7 = 0,
+        finished: bool,
+        _unused1: u23 = 0,
+    };
+
+    src: AlignedPhysicalAddress(.@"16", .@"8"),
+    dst: AlignedPhysicalAddress(.@"16", .@"8"),
+    dst_dimensions: Dimensions,
+    src_dimensions: Dimensions,
+    flags: Flags,
+    write_0_before_display_transfer: u32,
+    control: Control,
+    _unknown0: u32 = 0,
+    copy: Copy,
+};
+
+pub const Graphics = extern struct {
+    pub const AttributeIndex = enum(u4) { @"0", @"1", @"2", @"3", @"4", @"5", @"6", @"7", @"8", @"9", @"10", @"11" };
+    pub const ArrayComponentIndex = enum(u4) { @"0", @"1", @"2", @"3", @"4", @"5", @"6", @"7", @"8", @"9", @"10", @"11" };
+
+    pub const Interrupt = extern struct {
+        pub const Mask = extern struct {
+            disabled_low: BitpackedArray(bool, 32),
+            disabled_high: BitpackedArray(bool, 32),
+        };
+
+        pub const Stat = extern struct {
+            match_low: BitpackedArray(bool, 32),
+            match_high: BitpackedArray(bool, 32),
+        };
+
+        /// 0x000
+        ack: [64]u8,
+        /// 0x040
+        req: [64]u8,
+        /// 0x080
+        cmp: [64]u8,
+        /// 0x0C0
+        mask: Mask,
+        /// 0x0C8
+        stat: Stat,
+        /// 0x0D0
+        // XXX: Does this really work? Specifiying an invalid size
+        // (a.k.a bigger than it is will hang the GPU), even adding multiple
+        // req/finalize commands WILL hang the GPU (or GSP?)! This either means:
+        // - This doesn't work
+        // - Somehow something else has to be set?
+        autostop: LsbRegister(bool),
+        /// 0x0D4
+        fixed_0x00010002: u32,
+
+        comptime {
+            std.debug.assert(@sizeOf(Interrupt) == 0xD8);
+        }
+    };
+
+    pub const Rasterizer = extern struct {
+        pub const Mode = enum(u2) { normal, interlace, wireframe, normal_2 };
+        pub const ClippingPlane = extern struct {
+            /// Enable the clipping plane
+            /// 0x11C
+            enable: LsbRegister(bool),
+            /// Coefficients of the clipping plane.
+            /// 0x120
+            coefficients: [4]LsbRegister(F7_16),
+        };
+
+        pub const Statistics = extern struct {
+            /// 0x168
+            vertices_received: u32,
+            /// 0x16C
+            triangles_received: u32,
+            /// 0x170
+            triangles_displayed: u32,
+        };
+
+        pub const Scissor = extern struct {
+            /// 0x194
+            mode: LsbRegister(ScissorMode),
+            /// The start of the scissor region, origin bottom-left.
+            /// 0x198
+            start: [2]u16,
+            /// The end of the scissor region (inclusive), origin bottom-left.
+            /// 0x19C
+            end: [2]u16,
+        };
+
+        pub const InputMode = packed struct(u32) {
+            /// XXX: Textures still work when setting this to false...?
+            use_texture_coordinates: bool = false,
+            _: u31 = 0,
+        };
+
+        pub const Clock = packed struct(u32) {
+            position_z: bool = false,
+            color: bool = false,
+            _unused0: u6 = 0,
+            texture_coordinates: BitpackedArray(bool, 3) = .splat(false),
+            _unused1: u5 = 0,
+            texture_coordinates_0_w: bool = false,
+            _unused2: u7 = 0,
+            normal_or_view: bool = false,
+            _unused3: u7 = 0,
+        };
+
+        pub const DepthMap = extern struct {
+            pub const Mode = enum(u1) {
+                /// Precision is evenly distributed.
+                w,
+                /// Precision is higher close to the near plane.
+                z,
+            };
+
+            /// Scale to map depth from [0, -1] to [0, 1].
+            /// 0x134
+            scale: LsbRegister(F7_16),
+            /// Bias to map depth from [0, -1] to [0, 1].
+            /// 0x138
+            bias: LsbRegister(F7_16),
+        };
+
+        pub const UndocumentedConfig0 = packed struct(u32) {
+            _unknown0: bool = false,
+            _unused0: u7 = 0,
+            /// Sometimes interlaces, sometimes skips pixels.
+            /// Depends on how the GPU feels that day.
+            dirty_interlace_skip: bool = false,
+            /// Weird, it "enables" some sort of wireframe in the rasterizer,
+            /// it does NOT convert triangles to lines as clipped triangles will
+            /// be correctly splitted, is purely a rasterizer thing.
+            dirty_wireframe: bool,
+            _unused1: u22 = 0,
+        };
+
+        /// 0x100
+        cull_config: LsbRegister(CullMode),
+        /// `Width / 2.0`, used for scaling vertex coordinates.
+        /// 0x104
+        viewport_h_scale: LsbRegister(F7_16),
+        /// `2.0 / Width`, supposedly used for stepping colors and texture coordinates.
+        /// 0x108
+        viewport_h_step: MsbRegister(F7_23),
+        /// `Height / 2.0`, used for scaling vertex coordinates.
+        /// 0x10C
+        viewport_v_scale: LsbRegister(F7_16),
+        /// `2.0 / Height`, supposedly used for stepping colors and texture coordinates.
+        /// 0x110
+        viewport_v_step: MsbRegister(F7_23),
+        /// 0x114
+        _unknown0: [2]u32,
+        /// Extra user-defined clipping plane.
+        /// 0x11C
+        extra_clipping_plane: ClippingPlane,
+        /// 0x130
+        _unknown1: [1]u32,
+        /// Maps depth from NDC [0, -1] to framebuffer [0, 1].
+        /// 0x134
+        depth_map: DepthMap,
+        /// 0x13C
+        num_inputs: LsbRegister(u3),
+        /// 0x140
+        inputs: [7]OutputMap,
+        /// 0x15C
+        _unknown2: u32,
+        /// 0x160
+        shader_output_map_qualifiers: u32, // According to GBATEK this allows you to use the flat qualifier in output colors.
+        /// 0x164
+        _unknown3: u32,
+        /// 0x168
+        statistics: Statistics,
+        /// 0x174
+        _unknown4: [3]u32,
+        /// 0x180
+        config: UndocumentedConfig0,
+        /// So early depth somehow has a separate internal buffer that must be cleared.
+        /// From tests it looks like it has MUCH LESS precision and literally breaks with anything,
+        /// 32x32 is needed. Overall, is it really needed?
+        ///
+        /// I don't know what engineers were smoking but it has too many false fails, discarding lots of fragments.
+        /// XXX: No more can be said, this is vaulted until new info comes out.
+        /// 0x184
+        early_depth_function: LsbRegister(EarlyDepthCompareOperation),
+        /// 0x188
+        early_depth_test_enable: LsbRegister(bool),
+        /// 0x18C
+        early_depth_clear: LsbRegister(Trigger),
+        /// 0x190
+        input_mode: InputMode,
+        /// 0x194
+        scissor: Scissor,
+        /// Viewport origin, origin is bottom-left.
+        /// 0x1A0
+        viewport_xy: [2]u16,
+        /// 0x1A4
+        _unknown8: u32,
+        /// 0x1A8
+        early_depth_data: LsbRegister(u24),
+        /// 0x1AC
+        _unknown9: [2]u32,
+        /// 0x1B4
+        depth_map_mode: LsbRegister(DepthMap.Mode),
+        /// Does not seem to have an effect but it's still documented like this
+        /// 0x1B8
+        _unused_render_buffer_dimensions: u32, // XXX: Why would the rasterizer need output dimensions?
+        /// The clock driving inputs to the rasterizer from the shader.
+        ///
+        /// If a shader outputs a value which the rasterizer doesn't clock,
+        /// the rasterizer reads a default value; e.g color will read (1, 1, 1, 1)
+        /// 0x1BC
+        input_clock: Clock,
+    };
+
+    pub const TextureUnits = extern struct {
+        pub const Config = packed struct(u32) {
+            texture_enabled: BitpackedArray(bool, 3),
+            _unused0: u5 = 0,
+            texture_3_coordinates: TextureUnitTexture3Coordinates,
+            texture_3_enabled: bool,
+            _unused1: u1 = 0,
+            _unused2: u1 = 1,
+            texture_2_coordinates: TextureUnitTexture2Coordinates,
+            _unused3: u2 = 0,
+            clear_texture_cache: bool,
+            _unused4: u15 = 0,
+
+            pub fn format(cfg: Config, w: *std.Io.Writer) std.Io.Writer.Error!void {
+                try w.print("Enable: {f}, Enable procedural: {} | T2 source: {}, T3 source: {} | Clear cache: {}", .{
+                    cfg.texture_enabled,
+                    cfg.texture_3_enabled,
+                    cfg.texture_2_coordinates,
+                    cfg.texture_3_coordinates,
+                    cfg.clear_texture_cache,
+                });
+            }
+        };
+
+        pub const Parameters = packed struct(u32) {
+            pub const Etc1Flag = enum(u2) { none, etc1 = 2 };
+
+            _unknown0: u1 = 0,
+            mag_filter: TextureUnitFilter,
+            min_filter: TextureUnitFilter,
+            _unknown1: u1 = 0,
+            etc1: Etc1Flag,
+            _unknown2: u2 = 0,
+            address_mode_v: TextureUnitAddressMode,
+            _unknown3: u1 = 0,
+            address_mode_u: TextureUnitAddressMode,
+            _unknown4: u5 = 0,
+            is_shadow: bool,
+            _unknown5: u3 = 0,
+            mip_filter: TextureUnitFilter,
+            _unused0: u3 = 0,
+            type: TextureUnitType,
+            _unused1: u1 = 0,
+
+            pub fn format(params: Parameters, w: *std.Io.Writer) std.Io.Writer.Error!void {
+                try w.print("Type: {} | Min: {}, Mag: {}, Mip: {} | U: {}, V: {}", .{
+                    params.type,
+                    params.min_filter,
+                    params.mag_filter,
+                    params.mip_filter,
+                    params.address_mode_u,
+                    params.address_mode_v,
+                });
+            }
+        };
+
+        pub const LevelOfDetail = packed struct(u32) {
+            bias: Q4_8,
+            _unknown0: u3 = 0,
+            max_level_of_detail: u4,
+            _unknown1: u4 = 0,
+            min_level_of_detail: u4,
+            _unused0: u4 = 0,
+        };
+
+        pub const Shadow = packed struct(u32) {
+            orthogonal: bool,
+            // XXX: Documented as "the higher 23-bits of an UQ0.24": Bro, thats just an UQ0.23?
+            z_bias: UQ0_23,
+            _unknown0: u8 = 0,
+        };
+
+        pub const Primary = extern struct {
+            border_color: [4]u8,
+            /// Height and WIdth, NOT Width and Height!
+            dimensions: [2]u16,
+            parameters: Parameters,
+            lod: LevelOfDetail,
+            address: [6]AlignedPhysicalAddress(.@"8", .@"8"),
+            shadow: Shadow,
+            _unknown0: u32,
+            _unknown1: u32,
+            format: LsbRegister(TextureUnitFormat),
+        };
+
+        pub const Secondary = extern struct {
+            border_color: [4]u8,
+            /// Height and WIdth, NOT Width and Height!
+            dimensions: [2]u16,
+            /// WARNING: Type is ignored in secondary texture units, they're always 2d according to 3dbrew.
+            parameters: Parameters,
+            lod: LevelOfDetail,
+            address: AlignedPhysicalAddress(.@"8", .@"8"),
+            format: LsbRegister(TextureUnitFormat),
+        };
+
+        config: Config,
+        @"0": Primary,
+        lighting_enable: LsbRegister(bool),
+        _unknown0: u32,
+        @"1": Secondary,
+        _unknown1: [2]u32,
+        @"2": Secondary,
+    };
+
+    pub const ProceduralTextureUnit = extern struct {
+        pub const Main = extern struct {
+            procedural_texture: [5]u32,
+            procedural_texture_5_low: u32,
+            procedural_texture_5_high: u32,
+        };
+
+        @"3": Main,
+        lut_index: u32,
+        lut_data: [8]u32,
+    };
+
+    pub const TextureCombiners = extern struct {
+        pub const FogMode = enum(u3) { disabled, fog = 5, gas = 7 };
+        pub const ShadingDensity = enum(u1) { plain, depth };
+        pub const BufferSource = enum(u1) { previous_buffer, previous };
+        pub const Multiplier = enum(u2) { @"1x", @"2x", @"4x" };
+        pub const Source = enum(u4) {
+            primary_color,
+            fragment_primary_color,
+            fragment_secondary_color,
+            texture_0,
+            texture_1,
+            texture_2,
+            texture_3,
+            previous_buffer = 0xD,
+            constant,
+            previous,
+        };
+
+        pub const ColorFactor = enum(u4) {
+            src_color,
+            one_minus_src_color,
+            src_alpha,
+            one_minus_src_alpha,
+            src_red,
+            one_minus_src_red,
+            src_green = 8,
+            one_minus_src_green,
+            src_blue = 12,
+            one_minus_src_blue,
+        };
+
+        pub const AlphaFactor = enum(u3) {
+            src_alpha,
+            one_minus_src_alpha,
+            src_red,
+            one_minus_src_red,
+            src_green,
+            one_minus_src_green,
+            src_blue,
+            one_minus_src_blue,
+        };
+
+        pub const Operation = enum(u4) {
+            /// `src0`
+            replace,
+            /// `src0 * src1`
+            modulate,
+            /// `src0 + src1`
+            add,
+            /// `src0 + src1 - 0.5`
+            add_signed,
+            /// `src0 * src2 + src1 * (1 - src2)`
+            interpolate,
+            /// `src0 - src1`
+            subtract,
+            /// `4 * ((src0r − 0.5) * (src1r − 0.5) + (src0g − 0.5) * (src1g − 0.5) + (src0b − 0.5) * (src1b − 0.5))`
+            dot3_rgb,
+            /// `4 * ((src0r − 0.5) * (src1r − 0.5) + (src0g − 0.5) * (src1g − 0.5) + (src0b − 0.5) * (src1b − 0.5))`
+            dot3_rgba,
+            /// `src0 * src1 + src2` (?)
+            multiply_add,
+            /// `src0 + src1 * src2` (?)
+            add_multiply,
+        };
+
+        pub const Config = packed struct(u32) {
+            fog_mode: FogMode,
+            shading_density_source: ShadingDensity,
+            _unused0: u4 = 0,
+            combiner_color_buffer_src: BitpackedArray(BufferSource, 4),
+            combiner_alpha_buffer_src: BitpackedArray(BufferSource, 4),
+            z_flip: bool,
+            _unused1: u7 = 0,
+            _unknown0: u2 = 0,
+            _unused2: u6 = 0,
+
+            pub const BufferIndex = enum(u3) { @"1", @"2", @"3", @"4" };
+
+            pub fn setColorBufferSource(update_buffer: *Config, index: BufferIndex, buffer_src: BufferSource) void {
+                std.mem.writePackedIntNative(u1, std.mem.asBytes(update_buffer), @as(usize, @bitOffsetOf(Config, "combiner_color_buffer_src")) + @intFromEnum(index), @intFromEnum(buffer_src));
+            }
+
+            pub fn setAlphaBufferSource(update_buffer: *Config, index: BufferIndex, buffer_src: BufferSource) void {
+                std.mem.writePackedIntNative(u1, std.mem.asBytes(update_buffer), @as(usize, @bitOffsetOf(Config, "combiner_alpha_buffer_src")) + @intFromEnum(index), @intFromEnum(buffer_src));
+            }
+
+            pub fn format(cfg: Config, w: *std.Io.Writer) std.Io.Writer.Error!void {
+                try w.print("Fog Mode: {}, Shading Density: {}, Flip Z: {} | Color Buffer Src: {}, Alpha Buffer Src: {}", .{
+                    cfg.fog_mode,
+                    cfg.shading_density_source,
+                    cfg.z_flip,
+                    cfg.combiner_color_buffer_src,
+                    cfg.combiner_alpha_buffer_src,
+                });
+            }
+        };
+
+        pub const Unit = extern struct {
+            pub const Sources = packed struct(u32) {
+                color_src: BitpackedArray(Source, 3),
+                _unused0: u4 = 0,
+                alpha_src: BitpackedArray(Source, 3),
+                _unused1: u4 = 0,
+            };
+
+            pub const Factors = packed struct(u32) {
+                color_factor: BitpackedArray(ColorFactor, 3),
+                alpha_factor: BitpackedArray(AlphaFactor, 3),
+                _unused0: u11 = 0,
+            };
+
+            pub const Operations = packed struct(u32) {
+                color: Operation,
+                _unused0: u12 = 0,
+                alpha: Operation,
+                _unused1: u12 = 0,
+
+                pub fn format(operations: Operations, w: *std.Io.Writer) std.Io.Writer.Error!void {
+                    try w.print("Color: {}, Alpha: {}", .{
+                        operations.color,
+                        operations.alpha,
+                    });
+                }
+            };
+
+            pub const Scales = packed struct(u32) {
+                color: Multiplier,
+                _unused0: u14 = 0,
+                alpha: Multiplier,
+                _unused1: u14 = 0,
+
+                pub fn format(scales: Scales, w: *std.Io.Writer) std.Io.Writer.Error!void {
+                    try w.print("Color: {}, Alpha: {}", .{
+                        scales.color,
+                        scales.alpha,
+                    });
+                }
+            };
+
+            sources: Sources,
+            factors: Factors,
+            operations: Operations,
+            color: [4]u8,
+            scales: Scales,
+        };
+
+        pub const FogLutValue = packed struct(u24) {
+            next_difference: Q1_11,
+            value: UQ0_11,
+        };
+
+        /// 0x200
+        @"0": Unit,
+        _unknown0: [3]u32,
+        @"1": Unit,
+        _unknown1: [3]u32,
+        @"2": Unit,
+        _unknown2: [3]u32,
+        @"3": Unit,
+        _unknown3: [3]u32,
+        config: Config,
+        fog_color: [4]u8,
+        _unknown4: [2]u32,
+        gas_attenuation: LsbRegister(F5_10),
+        gas_accumulation_max: LsbRegister(F5_10),
+        fog_lut_index: LsbRegister(u16),
+        _unknown5: u32,
+        fog_lut_data: [8]LsbRegister(FogLutValue),
+        @"4": Unit,
+        _unknown6: [3]u32,
+        @"5": Unit,
+        buffer_color: [4]u8,
+    };
+
+    pub const OutputMerger = extern struct {
+        pub const Pixel = DisplayController.Framebuffer.Pixel;
+        pub const Blend = enum(u1) { logic, blend };
+        pub const Mode = enum(u2) { default, gas, shadow = 3 };
+        pub const Interlace = enum(u1) { disable, even };
+        pub const BlockSize = enum(u1) { @"8x8", @"32x32" };
+
+        pub const Config = packed struct(u32) {
+            mode: Mode,
+            _unused0: u6 = 0,
+
+            blend: Blend,
+            _unused1: u7 = 0,
+            _unknown0: u8 = 0xE4, // (?) Not setting this doesn't have an effect visually (?)
+            /// Isn't this similar to interlace? I mean rendering each 2nd line is literally that. There should be something for odd lines maybe?
+            interlace: Interlace = .disable,
+            /// Can this be some sort of primitive discard or is literally render nothing?
+            disable_rendering: bool = false,
+            _unused2: u6 = 0,
+        };
+
+        pub const BlendConfig = packed struct(u32) {
+            color_op: BlendOperation,
+            _unused0: u5 = 0,
+            alpha_op: BlendOperation,
+            _unused1: u5 = 0,
+            src_color_factor: BlendFactor,
+            dst_color_factor: BlendFactor,
+            src_alpha_factor: BlendFactor,
+            dst_alpha_factor: BlendFactor,
+        };
+
+        pub const AlphaTest = packed struct(u32) {
+            enable: bool,
+            _unused0: u3 = 0,
+            op: CompareOperation,
+            _unused1: u1 = 0,
+            reference: u8,
+            _unused3: u16 = 0,
+
+            pub fn format(cfg: AlphaTest, w: *std.Io.Writer) std.Io.Writer.Error!void {
+                try w.print("Enable: {}, Operation: {}, Reference: {}", .{
+                    cfg.enable,
+                    cfg.op,
+                    cfg.reference,
+                });
+            }
+        };
+
+        pub const StencilTest = extern struct {
+            pub const Config = packed struct(u32) {
+                enable: bool,
+                _unused0: u3 = 0,
+                op: CompareOperation,
+                _unused1: u1 = 0,
+                compare_mask: u8,
+                reference: u8,
+                write_mask: u8,
+
+                pub fn format(cfg: StencilTest.Config, w: *std.Io.Writer) std.Io.Writer.Error!void {
+                    try w.print("Enable: {}, Operation: {}, Reference: {}, Compare Mask: 0x{X:0>2}, Write Mask: 0x{X:0>2}", .{
+                        cfg.enable,
+                        cfg.op,
+                        cfg.reference,
+                        cfg.compare_mask,
+                        cfg.write_mask,
+                    });
+                }
+            };
+
+            pub const Operation = packed struct(u32) {
+                fail: StencilOperation,
+                _unused0: u1 = 0,
+                depth_fail: StencilOperation,
+                _unused1: u1 = 0,
+                pass: StencilOperation,
+                _unused2: u21 = 0,
+
+                pub fn format(op: StencilTest.Operation, w: *std.Io.Writer) std.Io.Writer.Error!void {
+                    try w.print("Fail: {}, Depth Fail: {}, Pass: {}", .{
+                        op.fail,
+                        op.depth_fail,
+                        op.pass,
+                    });
+                }
+            };
+
+            config: StencilTest.Config,
+            operation: StencilTest.Operation,
+        };
+
+        pub const DepthTestColorConfig = packed struct(u32) {
+            enable_depth_test: bool,
+            _unused0: u3 = 0,
+            depth_op: CompareOperation,
+            _unused1: u1 = 0,
+            enable_r_write: bool,
+            enable_g_write: bool,
+            enable_b_write: bool,
+            enable_a_write: bool,
+            enable_depth_write: bool,
+            _unused2: u19 = 0,
+
+            pub fn format(cfg: DepthTestColorConfig, w: *std.Io.Writer) std.Io.Writer.Error!void {
+                try w.print("Depth [Test: {}, Operation: {}, Write: {}] | Color {c}{c}{c}{c}", .{
+                    cfg.enable_depth_test,
+                    cfg.depth_op,
+                    cfg.enable_depth_write,
+                    @as(u8, if (cfg.enable_r_write) 'r' else '_'),
+                    @as(u8, if (cfg.enable_g_write) 'g' else '_'),
+                    @as(u8, if (cfg.enable_b_write) 'b' else '_'),
+                    @as(u8, if (cfg.enable_a_write) 'a' else '_'),
+                });
+            }
+        };
+
+        pub const ColorAccess = enum(u4) { disable, all = 0xF };
+        pub const DepthStencilAccess = enum(u2) { disable, stencil, depth, all };
+
+        pub const RenderBufferDimensions = packed struct(u32) {
+            width: u11,
+            _unused0: u1 = 0,
+            height_end: u10,
+            _unused1: u2 = 0,
+            flip_vertically: bool = false,
+            _unused2: u7 = 0,
+
+            pub fn init(width: u11, height: u10, flip_vertically: bool) RenderBufferDimensions {
+                return .{ .width = width, .height_end = height - 1, .flip_vertically = flip_vertically };
+            }
+
+            pub fn format(dim: RenderBufferDimensions, w: *std.Io.Writer) std.Io.Writer.Error!void {
+                try w.print("{}x{} (flip: {})", .{ dim.width, @as(u32, dim.height_end) + 1, dim.flip_vertically });
+            }
+        };
+
+        pub const ColorBufferFormat = packed struct(u32) {
+            pixel_size: Pixel.Size,
+            _unused0: u14 = 0,
+            pixel_format: Pixel,
+            _unused1: u13 = 0,
+
+            pub fn init(pixel_format: Pixel) ColorBufferFormat {
+                return .{
+                    .pixel_size = pixel_format.pixelSize(),
+                    .pixel_format = pixel_format,
+                };
+            }
+
+            pub fn format(fmt: ColorBufferFormat, w: *std.Io.Writer) std.Io.Writer.Error!void {
+                try w.print("{} ({} bits)", .{ fmt.pixel_format, fmt.pixel_size });
+            }
+        };
+
+        config: Config,
+        blend_config: BlendConfig,
+        logic_config: LsbRegister(LogicOperation),
+        blend_color: [4]u8,
+        alpha_test: AlphaTest,
+        stencil_test: StencilTest,
+        depth_color_config: DepthTestColorConfig,
+        _unknown0: [8]u32,
+        invalidate: LsbRegister(Trigger),
+        /// Flushing without issuing a drawcall before-hand in the same submitted command queue
+        /// will hang the GPU
+        ///
+        /// Don't ask me why
+        flush: LsbRegister(Trigger),
+        color_read: LsbRegister(ColorAccess),
+        color_write: LsbRegister(ColorAccess),
+        depth_read: LsbRegister(DepthStencilAccess),
+        depth_write: LsbRegister(DepthStencilAccess),
+        depth_format: LsbRegister(DepthStencilFormat),
+        color_format: ColorBufferFormat,
+        early_depth_test_enable: LsbRegister(bool),
+        _unknown1: [2]u32,
+        block_size: LsbRegister(BlockSize),
+        depth_location: AlignedPhysicalAddress(.@"64", .@"8"),
+        color_location: AlignedPhysicalAddress(.@"64", .@"8"),
+        dimensions: RenderBufferDimensions,
+        _unknown2: u32,
+        gas_light_xy: u32,
+        gas_light_z: u32,
+        gas_light_z_color: u32,
+        gas_lut_index: u32,
+        gas_lut_data: u32,
+        _unknown3: u32,
+        gas_delta_z_depth: u32,
+        _unknown4: [9]u32,
+        fragment_operation_shadow: u32,
+        _unknown5: [15]u32,
+    };
+
+    /// Fragment lighting in the PICA200 is done primarily through 1D lookup tables and quaternion interpolation.
+    ///
+    /// The vertex shader (or geometry if used) must output a Quaternion representing the rotation from the z-axis
+    /// to the normal. This can be done in different ways, with the standard RotationFromTo(.{0, 0, 1}, Normal) or
+    /// the approach in the 'Shading by Quaternion Interpolation' paper.
+    ///
+    /// It must also output a View position that is optionally used for positional lights to calculate the
+    /// light vector, as directional lights are not affected by it.
+    ///
+    /// There are 22 `LookupTable`s available:
+    ///     - 2 distribution tables for specular: D0 and D1
+    ///     - 1 fresnel table: Fr
+    ///     - 3 reflection tables for each color channel for reflection (D1): Rr, Rg and Rb
+    ///     - 8 spotlight tables: Sp0 to Sp7
+    ///     - 8 distance attenuation tables: Da0 to Da7
+    ///
+    /// The relevant lighting formulas are these (sources below):
+    ///     Cp -> primary color, also called diffuse / Cs -> secondary color, also called specular
+    ///
+    /// Cp = ambient + foreach light ( Da*i*(*sd*) * Sp*i*(*in*) * H * (ambient*i* + diffuse*i* * f(L * N)) )
+    ///
+    /// Cs = foreach light ( Da*i*(*sd*) * Sp*i*(*in*) * H * (specular*i*0**x** * D0(*in*) * G + specular*i*1**x** * R**x**(*in*) * D1(*in*) * G) )
+    ///
+    /// where:
+    ///     - H -> shadow attenuation factor
+    ///     - *i* -> For light *i*
+    ///     - **x** -> Color channel (r, g or b)
+    ///     - *sd* -> Scaled distance, clip(`bias`*i* + `scale`*i* * distance, 0, 1)
+    ///     - *in* -> One of the `LookupTable.Input`s
+    ///     - G -> Geometric factor, when enabled is `(L * N) / lengthSqr(L + N)`, `1.0` otherwise
+    ///
+    /// Lookup tables (except Da) can have an input domain of [-1.0, 1.0] or [0.0, 1.0] depending on the `LookupTable.Absolute` flags.
+    /// Da always has an input domain of [0.0, 1.0]. The mapping of input to index is:
+    /// - [0.0, 1.0] -> [0, 255]
+    /// - [-1.0, 1.0] -> [0.0, 1.0] is [0, 127] and [-1.0, 0.0] is [128, 255]
+    ///
+    ///
+    /// With all of that, the PICA200 can do both PBR and NPBR, for example a Blinn-Phong shading model can be done with:
+    /// - D0 enabled (absolute) with input N * H where each entry is `(N * H)^s` and `s` is the *shininess* of the surface.
+    ///
+    /// Sources:
+    /// - 3dbrew
+    /// - 'Primitive Processing and Advanced Shading Architecture for Embedded Space' by Max Kazakov & Eisaku Ohbuchi.
+    ///     - Both slides and paper are useful!
+    /// - 'A Real-Time Configurable Shader Based on Lookup Tables' by Eisaku Ohbuchi & Hiroshi Unno.
+    ///     - Warning: Paywalled, you must pay or access it through an institution (e.g: university)
+    /// - 'Shading by Quaternion Interpolation' by Anders Hast.
+    pub const FragmentLighting = extern struct {
+        pub const Color = packed struct(u32) {
+            b: u8,
+            _unused0: u2 = 0,
+            g: u8,
+            _unused1: u2 = 0,
+            r: u8,
+            _unused2: u4 = 0,
+
+            pub fn init(r: u8, g: u8, b: u8) Color {
+                return .{ .r = r, .g = g, .b = b };
+            }
+
+            pub fn initBuffer(rgb: [3]u8) Color {
+                return .init(rgb[0], rgb[1], rgb[2]);
+            }
+
+            pub fn splat(v: u8) Color {
+                return .init(v, v, v);
+            }
+
+            pub fn format(color: Color, w: *std.Io.Writer) std.Io.Writer.Error!void {
+                try w.print("({}, {}, {})", .{
+                    color.r,
+                    color.g,
+                    color.b,
+                });
+            }
+        };
+
+        pub const FresnelSelector = enum(u2) { none, primary, secondary, both };
+        pub const LookupTable = enum(u5) {
+            pub const Enabled = enum(u4) {
+                d0_rr_sp_da,
+                fr_rr_sp_da,
+                d0_d1_rr_da,
+                d0_d1_fr_da,
+                d0_d1_rx_sp_da,
+                d0_fr_rx_sp_da,
+                d0_d1_fr_rr_sp_da,
+                all = 8,
+            };
+
+            pub const Index = packed struct(u32) {
+                index: u8,
+                table: LookupTable,
+                _unused0: u19 = 0,
+
+                pub fn init(table: LookupTable, index: u8) Index {
+                    return .{ .table = table, .index = index };
+                }
+
+                pub fn format(idx: Index, w: *std.Io.Writer) std.Io.Writer.Error!void {
+                    try w.print("{}[{d}]", .{
+                        idx.table,
+                        idx.index,
+                    });
+                }
+            };
+
+            pub const Absolute = packed struct(u32) {
+                _unused0: u1 = 0,
+                disable_d0: bool = false,
+                _unused1: u3 = 0,
+                disable_d1: bool = false,
+                _unused2: u3 = 0,
+                disable_sp: bool = false,
+                _unused3: u3 = 0,
+                disable_fr: bool = false,
+                _unused4: u3 = 0,
+                disable_rb: bool = false,
+                _unused5: u3 = 0,
+                disable_rg: bool = false,
+                _unused6: u3 = 0,
+                disable_rr: bool = false,
+                _unused7: u6 = 0,
+
+                pub fn format(absolute: Absolute, w: *std.Io.Writer) std.Io.Writer.Error!void {
+                    try w.print("D0: {}, D1: {}, SP: {}, FR: {}, RR: {}, RG: {}, RB: {}", .{
+                        !absolute.disable_d0,
+                        !absolute.disable_d1,
+                        !absolute.disable_sp,
+                        !absolute.disable_fr,
+                        !absolute.disable_rr,
+                        !absolute.disable_rg,
+                        !absolute.disable_rb,
+                    });
+                }
+            };
+
+            pub const Input = enum(u3) { @"N * H", @"V * H", @"N * V", @"L * N", @"-L * P", @"cos(phi)" };
+            pub const Select = packed struct(u32) {
+                d0: Input = .@"N * H",
+                _unused0: u1 = 0,
+                d1: Input = .@"N * H",
+                _unused1: u1 = 0,
+                sp: Input = .@"N * H",
+                _unused2: u1 = 0,
+                fr: Input = .@"N * H",
+                _unused3: u1 = 0,
+                rb: Input = .@"N * H",
+                _unused4: u1 = 0,
+                rg: Input = .@"N * H",
+                _unused5: u1 = 0,
+                rr: Input = .@"N * H",
+                _unused6: u5 = 0,
+
+                pub fn format(select: Select, w: *std.Io.Writer) std.Io.Writer.Error!void {
+                    try w.print("D0: {}, D1: {}, SP: {}, FR: {}, RR: {}, RG: {}, RB: {}", .{
+                        select.d0,
+                        select.d1,
+                        select.sp,
+                        select.fr,
+                        select.rr,
+                        select.rg,
+                        select.rb,
+                    });
+                }
+            };
+
+            pub const Multiplier = enum(u3) { @"1x", @"2x", @"4x", @"8x", @"0.25x" = 6, @"0.5x" };
+            pub const Scale = packed struct(u32) {
+                d0: Multiplier = .@"1x",
+                _unused0: u1 = 0,
+                d1: Multiplier = .@"1x",
+                _unused1: u1 = 0,
+                sp: Multiplier = .@"1x",
+                _unused2: u1 = 0,
+                fr: Multiplier = .@"1x",
+                _unused3: u1 = 0,
+                rb: Multiplier = .@"1x",
+                _unused4: u1 = 0,
+                rg: Multiplier = .@"1x",
+                _unused5: u1 = 0,
+                rr: Multiplier = .@"1x",
+                _unused6: u5 = 0,
+
+                pub fn format(scale: Scale, w: *std.Io.Writer) std.Io.Writer.Error!void {
+                    try w.print("D0: {}, D1: {}, SP: {}, FR: {}, RR: {}, RG: {}, RB: {}", .{
+                        scale.d0,
+                        scale.d1,
+                        scale.sp,
+                        scale.fr,
+                        scale.rr,
+                        scale.rg,
+                        scale.rb,
+                    });
+                }
+            };
+
+            pub const Data = packed struct(u32) {
+                entry: UQ0_12,
+                next_absolute_difference: Q0_11,
+                _unused0: u8 = 0,
+
+                // TODO: initBuffer
+
+                pub fn initContext(
+                    context: anytype,
+                    absolute: bool,
+                ) [256]Data {
+                    var lut: [256]Data = undefined;
+
+                    const absolute_unit: f32 = @floatFromInt(@intFromBool(absolute));
+                    const negated_unit = 1 - absolute_unit;
+
+                    const msb_multiplier: f32 = (absolute_unit * 2 - 1) * 128;
+                    const max = 256.0 - (negated_unit * 128.0);
+
+                    var last: f32 = context.value(0.0);
+                    for (1..lut.len) |i| {
+                        const input = (@as(f32, @floatFromInt(i & 0x7F)) + @as(f32, @floatFromInt((i >> 7) & 0b1)) * msb_multiplier) / max;
+
+                        const current: f32 = context.value(input);
+                        defer last = current;
+
+                        lut[i - 1] = .{
+                            .entry = .ofSaturating(last),
+                            .next_absolute_difference = .ofSaturating(@abs(current - last)),
+                        };
+                    }
+
+                    lut[255] = .{ .entry = .ofSaturating(last), .next_absolute_difference = .ofSaturating(context.value(absolute_unit) - last) };
+                    return lut;
+                }
+
+                pub fn format(data: Data, w: *std.Io.Writer) std.Io.Writer.Error!void {
+                    try w.print("Entry: {}, Diff: {}", .{ data.entry, data.next_absolute_difference });
+                }
+            };
+
+            // zig fmt: off
+            d0, d1,
+            fr = 3,
+            rb, rg, rr,
+            sp0 = 8, sp1, sp2, sp3, sp4, sp5, sp6, sp7,
+            da0, da1, da2, da3, da4, da5, da6, da7,
+            // zig fmt: on
+        };
+
+        pub const BumpMode = enum(u2) { none, bump, tangent };
+
+        pub const Control = extern struct {
+            pub const Environment = packed struct(u32) {
+                enable_shadow_factor: bool,
+                _unused0: u1 = 0,
+                fresnel: FresnelSelector,
+                enabled_lookup_tables: LookupTable.Enabled,
+                _unknown0: u4 = 0x4,
+                _unused1: u4 = 0,
+                apply_shadow_attenuation_to_primary_color: bool,
+                apply_shadow_attenuation_to_secondary_color: bool,
+                invert_shadow_attenuation: bool,
+                apply_shadow_attenuation_to_alpha: bool,
+                _unused2: u2 = 0,
+                bump_map_unit: TextureUnit,
+                /// BIG BRAIN TIME, lets configure the shadow map unit........
+                /// Only unit 0 supports them?
+                shadow_map_unit: TextureUnit,
+                _unused3: u1 = 0,
+                clamp_highlights: bool,
+                bump_mode: BumpMode,
+                disable_bump_recalculation: bool,
+                _unknown1: u1 = 0x1,
+
+                pub fn format(env: Environment, w: *std.Io.Writer) std.Io.Writer.Error!void {
+                    try w.print("Enabled Tables: {}, Fresnel: {}, Shadow: {} | Shadow to primary: {}, Shadow to secondary: {}, Shadow to alpha: {}, Invert Shadow: {} | Bump Unit: {}, Shadow Unit: {} | Clamp Highlights: {}, Bump Mode: {}, Bump Recalculation: {}", .{
+                        env.enabled_lookup_tables,
+                        env.fresnel,
+                        env.enable_shadow_factor,
+                        env.apply_shadow_attenuation_to_primary_color,
+                        env.apply_shadow_attenuation_to_secondary_color,
+                        env.apply_shadow_attenuation_to_alpha,
+                        env.invert_shadow_attenuation,
+                        env.bump_map_unit,
+                        env.shadow_map_unit,
+                        env.clamp_highlights,
+                        env.bump_mode,
+                        !env.disable_bump_recalculation,
+                    });
+                }
+            };
+
+            pub const Lights = packed struct(u32) {
+                shadows_disabled: BitpackedArray(bool, 8),
+                spotlight_disabled: BitpackedArray(bool, 8),
+                disable_d0: bool,
+                disable_d1: bool,
+                _unknown0: u1 = 0x1,
+                disable_fr: bool,
+                disable_rb: bool,
+                disable_rg: bool,
+                disable_rr: bool,
+                _unknown1: u1 = 0x1,
+                distance_attenuation_disabled: BitpackedArray(bool, 8),
+
+                pub fn format(lights: Lights, w: *std.Io.Writer) std.Io.Writer.Error!void {
+                    try w.print("D0: {}, D1: {}, FR: {}, RR: {}, RG: {}, RB: {} | Shadow Disabled: {f}, Spotlight Disabled: {f}, Distance Attenuation Disabled: {f}", .{
+                        !lights.disable_d0,
+                        !lights.disable_d1,
+                        !lights.disable_fr,
+                        !lights.disable_rr,
+                        !lights.disable_rg,
+                        !lights.disable_rb,
+                        lights.shadows_disabled,
+                        lights.spotlight_disabled,
+                        lights.distance_attenuation_disabled,
+                    });
+                }
+            };
+
+            environment: Environment,
+            lights: Lights,
+        };
+
+        pub const Light = extern struct {
+            pub const Id = enum(u4) {
+                _,
+
+                pub fn init(value: u3) Id {
+                    return @enumFromInt(value);
+                }
+            };
+
+            pub const Type = enum(u1) { positional, directional };
+            pub const DiffuseSides = enum(u1) { one, both };
+
+            pub const Factors = extern struct {
+                specular: [2]Color,
+                diffuse: Color,
+                ambient: Color,
+            };
+
+            pub const Parameters = extern struct {
+                /// Its `xy` position if positional, otherwise its `xy` direction (unitary).
+                ///
+                /// If it is a directional light, the direction vector is Object -> Light,
+                xy: F5_10x2,
+                /// Its `z` position if positional, otherwise its `z` direction (unitary).
+                z: LsbRegister(F5_10),
+                /// Its `xy` spot (for spotlights) direction (unitary).
+                spot_xy: Q1_11x2,
+                /// Its `z` spot (for spotlights) direction (unitary).
+                spot_z: LsbRegister(Q1_11),
+            };
+
+            pub const Config = packed struct(u32) {
+                type: Type,
+                diffuse_sides: DiffuseSides,
+                geometric_factor_enable: BitpackedArray(bool, 2),
+                _unused0: u28 = 0,
+            };
+
+            pub const Attenuation = extern struct {
+                bias: LsbRegister(F7_12),
+                scale: LsbRegister(F7_12),
+            };
+
+            /// Color factors for primary and secondary colors.
+            factors: Factors,
+            parameters: Parameters,
+            _unknown0: u32,
+            config: Config,
+            /// Distance attenuation coefficients for the lookup input:
+            ///
+            /// `DA(clamp(distance * scale + bias, 0.0, 1.0))`
+            attenuation: Attenuation,
+        };
+
+        light: [8]Light,
+        _unknown0: [32]u32,
+        /// Scene/Global ambient color.
+        ambient: Color,
+        _unknown1: u32,
+        /// Number of active lights minus one.
+        num_lights_min_one: LsbRegister(u3),
+        control: Control,
+        lut_index: LookupTable.Index,
+        disable: LsbRegister(bool),
+        _unknown2: u32,
+        lut_data: [8]LookupTable.Data,
+        lut_input_absolute: LookupTable.Absolute,
+        lut_input_select: LookupTable.Select,
+        lut_input_scale: LookupTable.Scale,
+        _unknown3: [6]u32,
+        /// Maps enabled light index to its configuration. e.g: you can have 3 lights enabled but have those 3 lights be 0, 4 and 7 for example.
+        light_permutation: BitpackedArray(Light.Id, 8),
+    };
+
+    pub const PrimitiveEngine = extern struct {
+        pub const Mode = enum(u1) { drawing, config };
+
+        pub const PrimitiveConfig = packed struct(u32) {
+            total_vertex_outputs: u4,
+            _unused0: u4 = 0,
+            topology: PrimitiveTopology,
+            _unused1: u6 = 0,
+            _unknown0: u1 = 0,
+            _unused2: u15 = 0,
+
+            pub fn format(cfg: PrimitiveConfig, w: *std.Io.Writer) std.Io.Writer.Error!void {
+                try w.print("Topology: {} | Vertex Outputs: {}", .{
+                    cfg.topology,
+                    cfg.total_vertex_outputs,
+                });
+            }
+        };
+
+        pub const PipelineConfig = packed struct(u32) {
+            pub const GeometryUsage = enum(u2) { disabled, enabled = 2 };
+
+            geometry_shader_usage: GeometryUsage = .disabled,
+            _unused0: u6 = 0,
+            drawing_triangles: bool = false,
+            _unknown0: u1 = 0,
+            _unused1: u6 = 0,
+            _unknown1: u4 = 0,
+            _unused2: u11 = 0,
+            variable_geometry_inputs: bool = false,
+        };
+
+        pub const State = packed struct(u32) {
+            inputting_vertices_or_draw_arrays: bool = false,
+            _unused0: u7 = 0,
+            drawing_triangles: bool = false,
+            _unused1: u23 = 0,
+        };
+
+        pub const GeometryShader = packed struct(u32) {
+            pub const Mode = enum(u2) {
+                /// Vertex shader outputs begin filling geometry shader inputs (`point_vertices_minus_one`) until all slots are filled,
+                /// in which case a geometry shader invocation is performed.
+                point,
+                /// Vertex shader ouputs are buffered into uniform registers starting at `f1`,
+                /// `f0` stores the number of vertices in the batch.
+                ///
+                /// All drawcalls must be indexed while using this geometry shader mode.
+                ///
+                /// The first index signifies how many vertices to process, two kinds of vertices
+                /// are batched: main and secondary vertices; main vertices passthrough all outputs
+                /// while secondary ones only the first.
+                variable,
+                /// Vertex shader outputs are buffered into geometry shader uniform registers (up to `fixed_vertices_minus_one`) starting
+                /// at `uniform_start`.
+                fixed,
+            };
+
+            mode: GeometryShader.Mode,
+            _unused0: u6 = 0,
+            fixed_vertices_minus_one: u4,
+            point_inputs_minus_one: u4,
+            uniform_start: shader.register.Source.Constant,
+            _unused1: u1 = 0,
+            /// Unknown, but it is said that must be set when mode is fixed in both 3dbrew and GBATEK.
+            fixed: bool,
+            _unused2: u7 = 0,
+        };
+
+        pub const Attribute = extern struct {
+            pub const Format = packed struct(u4) {
+                pub const i8x1: Format = .{ .type = .i8, .size = .x };
+                pub const i8x2: Format = .{ .type = .i8, .size = .xy };
+                pub const i8x3: Format = .{ .type = .i8, .size = .xyz };
+                pub const i8x4: Format = .{ .type = .i8, .size = .xyzw };
+
+                pub const u8x1: Format = .{ .type = .u8, .size = .x };
+                pub const u8x2: Format = .{ .type = .u8, .size = .xy };
+                pub const u8x3: Format = .{ .type = .u8, .size = .xyz };
+                pub const u8x4: Format = .{ .type = .u8, .size = .xyzw };
+
+                pub const i16x1: Format = .{ .type = .i16, .size = .x };
+                pub const i16x2: Format = .{ .type = .i16, .size = .xy };
+                pub const i16x3: Format = .{ .type = .i16, .size = .xyz };
+                pub const i16x4: Format = .{ .type = .i16, .size = .xyzw };
+
+                pub const f32x1: Format = .{ .type = .f32, .size = .x };
+                pub const f32x2: Format = .{ .type = .f32, .size = .xy };
+                pub const f32x3: Format = .{ .type = .f32, .size = .xyz };
+                pub const f32x4: Format = .{ .type = .f32, .size = .xyzw };
+
+                pub const Type = enum(u2) {
+                    i8,
+                    u8,
+                    i16,
+                    f32,
+
+                    pub fn byteSize(typ: Type) usize {
+                        return switch (typ) {
+                            .i8, .u8 => @sizeOf(u8),
+                            .i16 => @sizeOf(i16),
+                            .f32 => @sizeOf(f32),
+                        };
+                    }
+                };
+
+                pub const Size = enum(u2) { x, xy, xyz, xyzw };
+
+                type: Type = .i8,
+                size: Size = .x,
+
+                pub fn byteSize(fmt: Format) usize {
+                    return fmt.type.byteSize() * (@as(usize, @intFromEnum(fmt.size)) + 1);
+                }
+            };
+
+            pub const Config = extern struct {
+                pub const Flags = enum(u1) { array, fixed };
+
+                pub const Low = packed struct(u32) { attributes: BitpackedArray(Format, 8) = .splat(.{}) };
+                pub const High = packed struct(u32) {
+                    remaining_attributes: BitpackedArray(Format, 4) = .splat(.{}),
+                    flags: BitpackedArray(Flags, 12) = .splat(.array),
+                    attributes_end: u4,
+                };
+
+                low: Low,
+                high: High,
+
+                pub fn setAttribute(config: *Config, index: AttributeIndex, value: Format) void {
+                    std.mem.writePackedInt(u4, std.mem.asBytes(config), @as(usize, @intFromEnum(index)) * @bitSizeOf(Format), @bitCast(value), .little);
+                }
+
+                pub fn getAttribute(config: *const Config, index: AttributeIndex) Format {
+                    return @bitCast(std.mem.readPackedInt(u4, std.mem.asBytes(config), @as(usize, @intFromEnum(index)) * @bitSizeOf(Format), .little));
+                }
+
+                pub fn setFlag(config: *Config, index: AttributeIndex, value: Flags) void {
+                    std.mem.writePackedInt(u1, std.mem.asBytes(config), (@as(usize, 12) * @bitSizeOf(Format)) + @intFromEnum(index) * @bitSizeOf(Flags), @intFromEnum(value), .little);
+                }
+
+                pub fn getFlag(config: *const Config, index: AttributeIndex) Flags {
+                    return @enumFromInt(std.mem.readPackedInt(u1, std.mem.asBytes(config), (@as(usize, 12) * @bitSizeOf(Format)) + @intFromEnum(index) * @bitSizeOf(Flags), .little));
+                }
+            };
+
+            pub const VertexBuffer = extern struct {
+                pub const Config = extern struct {
+                    pub const ArrayComponent = enum(u4) {
+                        attribute_0,
+                        attribute_1,
+                        attribute_2,
+                        attribute_3,
+                        attribute_4,
+                        attribute_5,
+                        attribute_6,
+                        attribute_7,
+                        attribute_8,
+                        attribute_9,
+                        attribute_10,
+                        attribute_11,
+
+                        padding_4,
+                        padding_8,
+                        padding_12,
+                        padding_16,
+                    };
+
+                    pub const Low = packed struct(u32) {
+                        components: BitpackedArray(ArrayComponent, 8) = .init(.{
+                            .attribute_0,
+                            .attribute_1,
+                            .attribute_2,
+                            .attribute_3,
+                            .attribute_4,
+                            .attribute_5,
+                            .attribute_6,
+                            .attribute_7,
+                        }),
+                    };
+
+                    pub const High = packed struct(u32) {
+                        components: BitpackedArray(ArrayComponent, 4) = .init(.{
+                            .attribute_8,
+                            .attribute_9,
+                            .attribute_10,
+                            .attribute_11,
+                        }),
+
+                        bytes_per_vertex: u8,
+                        _unused0: u4 = 0,
+                        num_components: u4,
+                    };
+
+                    low: Low,
+                    high: High,
+
+                    pub fn setComponent(config: *VertexBuffer.Config, index: ArrayComponentIndex, value: ArrayComponent) void {
+                        std.mem.writePackedInt(u4, std.mem.asBytes(config), @as(usize, @intFromEnum(index)) * @bitSizeOf(ArrayComponent), @intFromEnum(value), .little);
+                    }
+
+                    pub fn getComponent(config: *const VertexBuffer.Config, index: ArrayComponentIndex) ArrayComponent {
+                        return @enumFromInt(std.mem.readPackedInt(u4, std.mem.asBytes(config), @as(usize, @intFromEnum(index)) * @bitSizeOf(ArrayComponent), .little));
+                    }
+                };
+
+                offset: LsbRegister(u28),
+                config: VertexBuffer.Config,
+            };
+
+            pub const IndexBuffer = packed struct(u32) {
+                offset: u28,
+                _unused0: u3 = 0,
+                fmt: IndexFormat,
+
+                pub fn init(base_offset: u28, fmt: IndexFormat) IndexBuffer {
+                    return .{ .offset = base_offset, .fmt = fmt };
+                }
+
+                pub fn format(idx: IndexBuffer, w: *std.Io.Writer) std.Io.Writer.Error!void {
+                    try w.print("0x{X} ({t})", .{
+                        idx.offset,
+                        idx.fmt,
+                    });
+                }
+            };
+
+            base: AlignedPhysicalAddress(.@"16", .@"8"),
+            config: Config,
+            vertex_buffers: [12]VertexBuffer,
+            index_buffer: IndexBuffer,
+        };
+
+        pub const FixedAttribute = extern struct {
+            pub const Index = packed struct(u32) {
+                /// Begin immediate submission of vertex attributes.
+                pub const immediate: Index = .{ .index = 0xF };
+
+                index: u4,
+                _: u28 = 0,
+
+                pub fn register(input: u4) Index {
+                    std.debug.assert(input < 12);
+                    return .{ .index = input };
+                }
+            };
+
+            /// If `Index.immediate` the written `value`s will begin filling shader inputs
+            /// and drawing primitives. Otherwise it is an index representing the attribute
+            /// whose `value` will be set.
+            index: Index,
+
+            /// The value to write to a shader input or attribute.
+            value: F7_16x4,
+        };
+
+        pub const CommandBuffer = extern struct {
+            /// Shifted to the left by 3.
+            size: [2]LsbRegister(u22),
+            address: [2]AlignedPhysicalAddress(.@"16", .@"8"),
+            jump: [2]LsbRegister(Trigger),
+        };
+
+        /// Attribute info used when issuing drawcalls via `draw` or `draw_indexed`.
+        attributes: Attribute,
+        /// The amount of vertices that will be processed by a drawcall.
+        draw_vertex_count: u32,
+        config: PipelineConfig,
+        /// The first index used by drawcalls. Only used in `draw`, ignored by `draw_indexed`.
+        draw_first_index: u32,
+        _unknown0: [2]u32,
+        post_vertex_cache: LsbRegister(u8),
+        /// Triggers a non-indexed drawcall, will begin reading from `draw_first_index`
+        /// until `draw_vertex_count` vertices are processed.
+        draw: LsbRegister(Trigger),
+        /// Triggers an indexed drawcall,
+        draw_indexed: LsbRegister(Trigger),
+        _unknown1: u32,
+        clear_post_vertex_cache: LsbRegister(Trigger),
+        fixed_attribute: FixedAttribute,
+        _unknown2: [2]u32,
+        command_buffer: CommandBuffer,
+        _unknown3: [4]u32,
+        vertex_shader_input_attributes: LsbRegister(u4),
+        _unknown4: u32,
+        /// updates to the vertex shader unit will not be propagated to the geometry shader if true.
+        exclusive_shader_configuration: LsbRegister(bool),
+        mode: LsbRegister(Mode),
+        _unknown5: [4]u32,
+        vertex_shader_output_map_total_2: LsbRegister(u4),
+        _unknown6: [6]u32,
+        vertex_shader_output_map_total_1: LsbRegister(u4),
+        geometry_shader: GeometryShader,
+        state: State,
+        geometry_shader_full_vertices_minus_one: LsbRegister(u5),
+        _unknown7: u32,
+        _unknown8: [8]u32,
+        primitive_config: PrimitiveConfig,
+        restart_primitive: LsbRegister(Trigger),
+    };
+
+    pub const Shader = extern struct {
+        pub const Entry = packed struct(u32) {
+            entry: u16,
+            _: u16 = 0x7FFF,
+
+            pub fn initEntry(entry: u16) Entry {
+                return .{ .entry = entry };
+            }
+        };
+
+        pub const Input = packed struct(u32) {
+            /// Amount of input registers
+            inputs: u4,
+            _unused0: u4 = 0,
+            /// When true, inputs will fill uniform registers instead of input ones.
+            /// Used for variable and fixed geometry shader modes.
+            uniform: bool = false,
+            _unused1: u18 = 0,
+            enabled_for_geometry_0: bool = false,
+            _unknown0: u1 = 0,
+            enabled_for_vertex_0: bool = false,
+            _unused2: u1 = 0,
+            enabled_for_vertex_1: bool = false,
+
+            pub fn format(input: Input, w: *std.Io.Writer) std.Io.Writer.Error!void {
+                try w.print("Inputs: {d} | Uniform: {}", .{
+                    input.inputs,
+                    input.uniform,
+                });
+            }
+        };
+
+        pub const FloatUniformConfig = packed struct(u32) {
+            pub const Mode = enum(u1) { f7_16, f8_23 };
+
+            index: FloatConstantRegister,
+            _unused0: u24 = 0,
+            mode: Mode,
+
+            pub fn format(cfg: FloatUniformConfig, w: *std.Io.Writer) std.Io.Writer.Error!void {
+                try w.print("{d} ({t})", .{
+                    cfg.index,
+                    cfg.mode,
+                });
+            }
+        };
+
+        pub const AttributePermutation = extern struct {
+            pub const Low = packed struct(u32) {
+                attributes: BitpackedArray(InputRegister, 8) = .init(.{ .v0, .v1, .v2, .v3, .v4, .v5, .v6, .v7 }),
+            };
+
+            pub const High = packed struct(u32) {
+                remaining_attribute: BitpackedArray(InputRegister, 8) = .init(.{ .v8, .v9, .v10, .v11, .v12, .v13, .v14, .v15 }),
+            };
+
+            low: Low = .{},
+            high: High = .{},
+
+            pub fn setAttribute(config: *AttributePermutation, index: AttributeIndex, value: InputRegister) void {
+                std.mem.writePackedInt(u4, std.mem.asBytes(config), @intFromEnum(index) * @bitSizeOf(InputRegister), @intFromEnum(value), .little);
+            }
+
+            pub fn getAttribute(config: *AttributePermutation, index: AttributeIndex) InputRegister {
+                return @enumFromInt(std.mem.readPackedInt(u4, std.mem.asBytes(config), @intFromEnum(index) * @bitSizeOf(InputRegister), .little));
+            }
+        };
+
+        pub const BooleanUniformMask = packed struct(u32) {
+            mask: BitpackedArray(bool, 16),
+            _unused0: u16 = 0x7FFF,
+
+            pub fn init(mask: BitpackedArray(bool, 16)) BooleanUniformMask {
+                return .{ .mask = mask };
+            }
+        };
+
+        bool_uniforms: BooleanUniformMask,
+        int_uniforms: [4][4]u8,
+        _unused0: [4]u32,
+        input: Input,
+        entrypoint: Entry,
+        attribute_permutation: AttributePermutation,
+        output_map_mask: LsbRegister(BitpackedArray(bool, 16)),
+        _unused1: u32,
+        code_transfer_end: LsbRegister(Trigger),
+        float_uniform_index: FloatUniformConfig,
+        float_uniform_data: [8]u32,
+        _unused2: [2]u32,
+        code_transfer_index: LsbRegister(u12),
+        code_transfer_data: [8]Instruction,
+        _unused3: u32,
+        operand_descriptors_index: LsbRegister(u7),
+        operand_descriptors_data: [8]OperandDescriptor,
+    };
+
+    /// 0x000
+    irq: Interrupt,
+    /// 0x0D8
+    _unused0: [40]u8,
+    /// 0x100
+    rasterizer: Rasterizer,
+    /// 0x1C0
+    _unused1: [64]u8,
+    /// 0x200
+    texture_units: TextureUnits,
+    _unused2: [36]u8,
+    /// 0x2A0
+    procedural_texture_unit: ProceduralTextureUnit,
+    _unused3: [32]u8,
+    /// 0x300
+    texture_combiners: TextureCombiners,
+    _unused4: [8]u8,
+    /// 0x400
+    output_merger: OutputMerger,
+    /// 0x500
+    fragment_lighting: FragmentLighting,
+    _unused5: [152]u8,
+    /// 0x800
+    primitive_engine: PrimitiveEngine,
+    _unused6: [128]u8,
+    /// 0xA00
+    geometry_shader: Shader,
+    _unused7: [8]u8,
+    /// 0xAC0
+    vertex_shader: Shader,
+
+    comptime {
+        std.debug.assert(@offsetOf(Graphics, "irq") == 0x000);
+        std.debug.assert(@offsetOf(Graphics, "rasterizer") == 0x100);
+        std.debug.assert(@offsetOf(Graphics, "texture_units") == 0x200);
+        std.debug.assert(@offsetOf(Graphics, "procedural_texture_unit") == 0x2A0);
+        std.debug.assert(@offsetOf(Graphics, "texture_combiners") == 0x300);
+        std.debug.assert(@offsetOf(Graphics, "output_merger") == 0x400);
+        std.debug.assert(@offsetOf(Graphics, "fragment_lighting") == 0x500);
+        std.debug.assert(@offsetOf(Graphics, "primitive_engine") == 0x800);
+        std.debug.assert(@offsetOf(Graphics, "geometry_shader") == 0xA00);
+        std.debug.assert(@offsetOf(Graphics, "vertex_shader") == 0xAC0);
+    }
+};
+
+/// There are 3 main points where LCDs are configured:
+/// * I2C (TODO: I2C in general)
+/// * LCD registers (`zitrus.hardware.lcd`)
+/// * These
+///
+/// The GPU `DisplayController` is what drives the LCD, pushing pixels and is in charge
+/// of the timing of each display (along with the IRQs).
+///
+/// With these, looks like it's possible to:
+/// * Change the Hz of the display itself
+/// * Change the size of the displayed area, display it anywhere and set a
+/// configurable border color in the non-displayed area.
+///
+/// It also looks like the pixel clock is the main clock divided by 24, i.e `268111856 / 24`
+///
+/// All of this has been synthetized from 3dbrew and GBATEK, both sources have wildly different
+/// register naming but as everywhere else, the naming is different and reflects what I've seen
+/// and think.
+///
+/// WARNING: Modifying these registers CAN damage hardware in some LCDs: o3DS (burn-in) and IPS (new ones).
+/// Thanks to @sono3 in the godmode9 discord who told me this.
+/// Use the decls in `Preset` as those values are taken from what OFW use.
+pub const DisplayController = extern struct {
+    pub const Color = packed struct(u32) {
+        r: u8,
+        g: u8,
+        b: u8,
+        _unused0: u8 = 0,
+    };
+
+    pub const Framebuffer = extern struct {
+        pub const Control = packed struct(u32) {
+            enable: bool,
+            _unused0: u7 = 0,
+            disable_horizontal_sync_irq: bool,
+            disable_vertical_sync_irq: bool,
+            disable_error_irq: bool,
+            _unused1: u5 = 0,
+            maybe_output_enable: bool = true,
+            _unused2: u15 = 0,
+        };
+
+        pub const Select = packed struct(u32) {
+            select: u1,
+            _unused0: u3 = 0,
+            current: u1 = 0,
+            _unused1: u3 = 0,
+            reset_fifo: bool = false,
+            _unused2: u7 = 0,
+            horizontal_ack: bool = false,
+            vertical_ack: bool = false,
+            error_ack: bool = false,
+            _unused3: u13 = 0,
+        };
+
+        pub const Status = packed struct(u32) {
+            horizontal_irq: bool,
+            vertical_irq: bool,
+            _unused0: u2 = 0,
+            bit: bool,
+            _unused1: u3 = 0,
+            horizontal_sync: bool,
+            horizontal_blank: bool,
+            horizontal_drawing: bool,
+            _unused2: u1 = 0,
+            vertical_sync: bool,
+            vertical_blank: bool,
+            vertical_drawing: bool,
+            _unknown0: bool,
+            _unused3: u16 = 0,
+        };
+
+        pub const Pixel = enum(u3) {
+            pub const Size = enum(u2) {
+                @"16",
+                @"24",
+                @"32",
+                _,
+            };
+
+            pub const Abgr8888 = extern struct { a: u8, b: u8, g: u8, r: u8 };
+            pub const Bgr888 = extern struct { b: u8, g: u8, r: u8 };
+            pub const Rgb565 = packed struct(u16) { b: u5, g: u6, r: u5 };
+            pub const Rgba5551 = packed struct(u16) { a: u1, b: u5, g: u5, r: u5 };
+            pub const Rgba4444 = packed struct(u16) { a: u4, b: u4, g: u4, r: u4 };
+
+            /// 4 bytes, `A B G R`.
+            abgr8888,
+            /// 3 bytes, `B G R`.
+            bgr888,
+            /// Packed, 2 bytes, `RRRRRGGGGGGBBBBB`.
+            rgb565,
+            /// Packed, 2 bytes, `RRRRRGGGGGBBBBBA`.
+            rgba5551,
+            /// Packed, 2 bytes, `RRRRGGGGBBBBAAAA`.
+            rgba4444,
+
+            pub inline fn Data(comptime format: Pixel) type {
+                return switch (format) {
+                    .abgr8888 => Abgr8888,
+                    .bgr888 => Bgr888,
+                    .rgb565 => Rgb565,
+                    .rgba5551 => Rgba5551,
+                    .rgba4444 => Rgba4444,
+                };
+            }
+
+            pub fn pixelSize(format: Pixel) Size {
+                return switch (format.bytesPerPixel()) {
+                    2 => .@"16",
+                    3 => .@"24",
+                    4 => .@"32",
+                    else => unreachable,
+                };
+            }
+
+            pub fn bytesPerPixel(format: Pixel) usize {
+                return switch (format) {
+                    inline else => |f| @sizeOf(f.Data()),
+                };
+            }
+
+            pub fn components(format: Pixel) usize {
+                return switch (format) {
+                    inline else => |f| @typeInfo(f.Data()).@"struct".fields.len,
+                };
+            }
+        };
+
+        pub const Interlacing = enum(u2) {
+            none,
+            scanline_doubling,
+            enable,
+            enable_inverted,
+        };
+
+        pub const Dma = enum(u2) {
+            @"32",
+            @"64",
+            @"128",
+            vram,
+        };
+
+        pub const Format = packed struct(u32) {
+            pixel_format: Pixel,
+            _unused0: u1 = 0,
+            interlacing: Interlacing,
+            /// Should only be used on the top screen.
+            ///
+            /// Makes the display controller reuse the same fetched pixel twice.
+            ///
+            /// Halves the pixel rate (?)
+            ///
+            /// NOTE: this is just synthetized from testing and above docs, still needs more testing
+            half_rate: bool,
+            _unused1: bool = false,
+            dma_size: Dma,
+            _unused2: u6 = 0,
+            unknown0: u16 = 8,
+        };
+
+        left_address: [2]AlignedPhysicalAddress(.@"16", .@"1"),
+        format: Format,
+        control: Control,
+        select: Select,
+        status: Status,
+        color_lookup_index: LsbRegister(u8),
+        color_lookup_data: Color,
+        _unused0: [2]u32,
+        stride: u32,
+        right_address: [2]AlignedPhysicalAddress(.@"16", .@"1"),
+    };
+
+    pub const SynchronizationPolarity = packed struct(u32) {
+        horizontal_active_high: bool,
+        _unused0: u3 = 0,
+        vertical_active_high: bool,
+        _unused1: u27 = 0,
+    };
+
+    /// Total = Back Porch Start -> Back Porch Mid (Left/Upper Border Start) -> Display Start/Back Porch End
+    /// -> Front Porch Start (Right/Lower Border End) -> Front Porch Mid (Supposedly Bugged) -> Front Porch End -> IRQ
+    ///
+    /// The LCDs are sensitive, look at the comment in `DisplayController`.
+    pub const Timing = extern struct {
+        pub const Display = packed struct(u32) {
+            back_porch_mid: u12,
+            _unused0: u4 = 0,
+            front_porch_start: u12,
+            _unused1: u4 = 0,
+        };
+
+        pub const Range = packed struct(u32) {
+            start: u12,
+            _unused0: u4 = 0,
+            end: u12,
+            _unused1: u4 = 0,
+        };
+
+        /// 0x00
+        total: LsbRegister(u12),
+        /// 0x04
+        back_porch_end: LsbRegister(u12),
+        /// 0x08
+        front_porch_mid: LsbRegister(u12),
+        /// 0x0C
+        front_porch_end: LsbRegister(u12),
+        /// 0x10
+        sync_start: LsbRegister(u12),
+        /// 0x14
+        sync_end: LsbRegister(u12),
+        /// 0x18
+        back_porch_start: LsbRegister(u12),
+        /// 0x1C
+        interrupt: Range,
+        /// 0x20
+        unknown: u32,
+
+        comptime {
+            std.debug.assert(@sizeOf(Timing) == 0x24);
+        }
+    };
+
+    pub const DisplaySize = packed struct(u32) {
+        width: u12,
+        _unused0: u4 = 0,
+        height: u12,
+        _unused1: u4 = 0,
+    };
+
+    pub const LatchingPoint = packed struct(u32) {
+        horizontal: u12,
+        _unused0: u4 = 0,
+        vertical: u12,
+        _unused1: u4 = 0,
+    };
+
+    pub const Preset = struct {
+        /// Top with half rate
+        pub const @"top_240x400@60Hz": Preset = .{
+            .display_size = .{ .width = 240, .height = 400 },
+            .horizontal_timing = .{
+                .total = .init(450),
+                .back_porch_end = .init(209),
+                .front_porch_mid = .init(449),
+                .front_porch_end = .init(449),
+                .sync_start = .init(0),
+                .sync_end = .init(207),
+                .back_porch_start = .init(209),
+                .interrupt = .{
+                    .start = 449,
+                    .end = 453,
+                },
+                .unknown = 0x10000,
+            },
+            .horizontal_display_timing = .{
+                .back_porch_mid = 209,
+                .front_porch_start = 449,
+            },
+            .vertical_timing = .{
+                .total = .init(413),
+                .back_porch_end = .init(2),
+                .front_porch_mid = .init(402),
+                .front_porch_end = .init(402),
+                .sync_start = .init(402),
+                .sync_end = .init(1),
+                .back_porch_start = .init(2),
+                .interrupt = .{
+                    .start = 402,
+                    .end = 406,
+                },
+                .unknown = 0,
+            },
+            .vertical_display_timing = .{
+                .back_porch_mid = 2,
+                .front_porch_start = 402,
+            },
+        };
+
+        /// Top with interlace enabled
+        pub const @"top_2x240x400@60Hz": Preset = .{
+            .display_size = .{ .width = 240, .height = 400 },
+            .horizontal_timing = .{
+                .total = .init(450),
+                .back_porch_end = .init(209),
+                .front_porch_mid = .init(449),
+                .front_porch_end = .init(449),
+                .sync_start = .init(0),
+                .sync_end = .init(207),
+                .back_porch_start = .init(209),
+                .interrupt = .{
+                    .start = 449,
+                    .end = 453,
+                },
+                .unknown = 0x10000,
+            },
+            .horizontal_display_timing = .{
+                .back_porch_mid = 209,
+                .front_porch_start = 449,
+            },
+            .vertical_timing = .{
+                .total = .init(827),
+                .back_porch_end = .init(2),
+                .front_porch_mid = .init(802),
+                .front_porch_end = .init(802),
+                .sync_start = .init(802),
+                .sync_end = .init(1),
+                .back_porch_start = .init(2),
+                .interrupt = .{
+                    .start = 802,
+                    .end = 806,
+                },
+                .unknown = 0,
+            },
+            .vertical_display_timing = .{
+                .back_porch_mid = 2,
+                .front_porch_start = 802,
+            },
+        };
+
+        /// Top
+        pub const @"top_240x800@60Hz": Preset = .{
+            .display_size = .{ .width = 240, .height = 800 },
+            .horizontal_timing = .{
+                .total = .init(450),
+                .back_porch_end = .init(209),
+                .front_porch_mid = .init(449),
+                .front_porch_end = .init(449),
+                .sync_start = .init(0),
+                .sync_end = .init(207),
+                .back_porch_start = .init(209),
+                .interrupt = .{
+                    .start = 449,
+                    .end = 453,
+                },
+                .unknown = 0x10000,
+            },
+            .horizontal_display_timing = .{
+                .back_porch_mid = 209,
+                .front_porch_start = 449,
+            },
+            .vertical_timing = .{
+                .total = .init(827),
+                .back_porch_end = .init(2),
+                .front_porch_mid = .init(802),
+                .front_porch_end = .init(802),
+                .sync_start = .init(802),
+                .sync_end = .init(1),
+                .back_porch_start = .init(2),
+                .interrupt = .{
+                    .start = 802,
+                    .end = 806,
+                },
+                .unknown = 0,
+            },
+            .vertical_display_timing = .{
+                .back_porch_mid = 2,
+                .front_porch_start = 802,
+            },
+        };
+
+        /// Bottom
+        pub const @"bottom_240x320@60Hz": Preset = .{
+            .display_size = .{ .width = 240, .height = 320 },
+            .horizontal_timing = .{
+                .total = .init(450),
+                .back_porch_end = .init(209),
+                .front_porch_mid = .init(449),
+                .front_porch_end = .init(449),
+                .sync_start = .init(205),
+                .sync_end = .init(207),
+                .back_porch_start = .init(209),
+                .interrupt = .{
+                    .start = 449,
+                    .end = 453,
+                },
+                .unknown = 0x10000,
+            },
+            .horizontal_display_timing = .{
+                .back_porch_mid = 209,
+                .front_porch_start = 449,
+            },
+            .vertical_timing = .{
+                .total = .init(413),
+                .back_porch_end = .init(82),
+                .front_porch_mid = .init(402),
+                .front_porch_end = .init(402),
+                .sync_start = .init(79),
+                .sync_end = .init(80),
+                .back_porch_start = .init(82),
+                .interrupt = .{
+                    .start = 403,
+                    .end = 407,
+                },
+                .unknown = 0x00,
+            },
+            .vertical_display_timing = .{
+                .back_porch_mid = 82,
+                .front_porch_start = 402,
+            },
+        };
+
+        display_size: DisplaySize,
+        horizontal_timing: Timing,
+        horizontal_display_timing: Timing.Display,
+        vertical_timing: Timing,
+        vertical_display_timing: Timing.Display,
+
+        /// Tries to compute timing parameters for the specified LCD configuration, returning `null` if no
+        /// configuration exists.
+        ///
+        /// WARNING: THIS HAS ONLY BEEN TESTED ON A o2DS!
+        pub fn init(screen: Screen, half_rate: bool, x: u12, y: u12, width: u12, height: u12, refresh: f32) ?Preset {
+            std.debug.assert(x + width <= screen.width() and y + height <= screen.height());
+
+            // WARNING: changing this has (unsafe) implications, read above
+            const h_total = 450;
+
+            const multiplier = if (half_rate) 1 else 2;
+            const remaining: f32 = @floatFromInt((zitrus.time.arm11_ticks_per_s / 24) * multiplier / (h_total + 1));
+            const unbounded_v_total: u32 = @ceil(remaining / refresh) - 1;
+
+            // We won't modify h_total so we're cooked.
+            if (unbounded_v_total > std.math.maxInt(u12) or unbounded_v_total < screen.height() + 12) return null;
+
+            const v_total: u12 = @intCast(unbounded_v_total);
+            const v_unused_total = v_total - screen.height() - 12;
+
+            // - First Border is Mid->End
+            // - Second Border is Start->Mid
+            const v_sync_end = v_unused_total + 2;
+            const v_back_porch_start = v_sync_end + 2;
+            const v_back_porch_mid = v_back_porch_start;
+            const v_back_porch_end = v_back_porch_mid + y;
+
+            const v_front_porch_start = v_back_porch_end + height;
+            const v_front_porch_mid = v_back_porch_end + (screen.height() - y);
+            const v_front_porch_end = v_front_porch_mid;
+            const v_sync_start = switch (screen) {
+                // Yes... totally makes sense!
+                .top => v_front_porch_end,
+                // When Sync Start -> End takes more than 1 tick,
+                // the screen directly desyncs/fades lmao (o2DS)
+                .bottom => v_sync_end - 1,
+            };
+
+            const v_irq_start = v_front_porch_end + 1;
+            const v_irq_end = v_irq_start + 4;
+
+            return .{
+                .display_size = .{ .width = @intCast(width), .height = @intCast(height) },
+                // NOTE: as HTotal is hardcoded, we don't have to calculate things (unlike with V)
+                .horizontal_timing = .{
+                    .total = .init(450),
+                    .back_porch_end = .init(209 + x),
+                    .front_porch_mid = .init(449),
+                    .front_porch_end = .init(449),
+                    .sync_start = .init(205),
+                    .sync_end = .init(207),
+                    .back_porch_start = .init(209),
+                    .interrupt = .{
+                        .start = 449,
+                        .end = 453,
+                    },
+                    .unknown = 0x10000,
+                },
+                .horizontal_display_timing = .{
+                    .back_porch_mid = 209,
+                    .front_porch_start = 209 + x + width,
+                },
+                .vertical_timing = .{
+                    .total = .init(v_total),
+                    .back_porch_end = .init(v_back_porch_end),
+                    .front_porch_mid = .init(v_front_porch_mid),
+                    .front_porch_end = .init(v_front_porch_end),
+                    .sync_start = .init(v_sync_start),
+                    .sync_end = .init(v_sync_end),
+                    .back_porch_start = .init(v_back_porch_start),
+                    .interrupt = .{
+                        .start = v_irq_start,
+                        .end = v_irq_end,
+                    },
+                    .unknown = 0x00,
+                },
+                .vertical_display_timing = .{
+                    .back_porch_mid = v_back_porch_mid,
+                    .front_porch_start = v_front_porch_start,
+                },
+            };
+        }
+    };
+
+    /// 0x00
+    horizontal_timing: Timing,
+    /// 0x24
+    vertical_timing: Timing,
+    /// 0x48
+    synchronization_polarity: SynchronizationPolarity,
+    /// 0x4C
+    border_color: Color,
+    /// 0x50
+    horizontal_position: LsbRegister(u12),
+    /// 0x54
+    vertical_position: LsbRegister(u12),
+    /// 0x58
+    _unused0: u32,
+    /// 0x5C
+    display_size: DisplaySize,
+    /// 0x60
+    horizontal_display_timing: Timing.Display,
+    /// 0x64
+    vertical_display_timing: Timing.Display,
+    /// 0x68
+    framebuffer: Framebuffer,
+    /// 0x9C
+    latching_point: LatchingPoint,
+    /// 0xA0
+    _unused2: [24]u32,
+
+    comptime {
+        std.debug.assert(@sizeOf(DisplayController) == 0x100);
+    }
+};
+
+// TODO: Properly finish this
+pub const Registers = extern struct {
+    pub const VRamPower = packed struct(u32) {
+        _unknown0: u8 = std.math.maxInt(u8),
+        power_off_a_low: bool,
+        power_off_a_high: bool,
+        power_off_b_low: bool,
+        power_off_b_high: bool,
+        _unknown1: u20 = std.math.maxInt(u20),
+    };
+
+    pub const InterruptFlags = packed struct(u32) {
+        _unknown0: u1 = 0,
+        _unknown1: u1 = 0,
+        _unused0: u24 = 0,
+        psc0: bool,
+        psc1: bool,
+        pdc0: bool,
+        pdc1: bool,
+        ppf: bool,
+        p3d: bool,
+    };
+
+    pub const Busy = packed struct(u32) {
+        // NOTE: THESE CHANGE ON P3D. TESTTESTTEST
+        // WHEN THE GPU HANGS SOME BITS STAY ON (AND THEY'RE ALMOST ALWAYS THE SAME ONES!!!!!)
+        _unknown0: bool,
+        _unknown1: bool,
+        _unknown2: bool,
+        _unknown3: bool,
+        _unknown4: bool,
+        _unknown5: bool,
+        _unknown6: bool,
+        _unknown7: bool,
+        _unknown8: bool,
+        _unknown9: bool,
+        _unknown10: bool,
+        _unknown11: bool,
+        _unknown12: bool,
+        _unknown13: bool,
+        _unknown14: bool,
+        _unknown15: bool,
+        _unknown_vram_power_0: bool,
+        _unknown_vram_power_1: bool,
+        memory_fill_busy: bool,
+        memory_copy_busy: bool,
+        _unused2: u12,
+    };
+
+    pub const TrafficStatistics = extern struct {
+        non_vram_reads: u32,
+        non_vram_writes: u32,
+        vram_a_reads: u32,
+        vram_a_writes: u32,
+        vram_b_reads: u32,
+        vram_b_writes: u32,
+        input_assembly_reads: u32,
+        sampled_texture_reads: u32,
+        depth_buffer_reads: u32,
+        depth_buffer_writes: u32,
+        color_buffer_reads: u32,
+        color_buffer_writes: u32,
+        top_lcd_reads: u32,
+        bottom_lcd_reads: u32,
+        memory_copy_reads: u32,
+        memory_copy_writes: u32,
+        memory_fill_writes: [2]u32,
+        cpu_vram_reads: u32,
+        cpu_vram_writes: u32,
+    };
+
+    hardware_id: u32,
+    clock: u32,
+    _unknown0: u32,
+    _unused0: u32,
+    psc: [2]MemoryFill,
+    vram_power: VRamPower,
+    irq: InterruptFlags,
+    _something: u32,
+    _make_something: u32,
+    _backlight_or_so_0: u32,
+    /// 0x044
+    _unknown1: u32,
+    /// 0x048
+    _unknown2: u32,
+    /// 0x04C
+    _unused1: u32,
+    /// 0x050
+    timing_control: [2]u32,
+    /// 0x058
+    busy: Busy,
+    /// 0x05C
+    _unknown3: u32,
+    /// 0x060
+    _unknown4: u32,
+    /// 0x064
+    _unknown5: u32,
+    /// 0x068
+    _unknown6: u32,
+    _unused2: u32,
+    traffic_statistics: TrafficStatistics,
+    _backlight_or_so_1: u32,
+    vram_a_base_address: [*]u8,
+    vram_b_base_address: [*]u8,
+    _backlight_or_so_2: u32,
+    _unknown7: u32,
+    _unused3: [0x2C]u8,
+    _unused4: [0x300]u8,
+    pdc: [2]DisplayController,
+    _unused5: [0x600]u8 = @splat(0),
+    ppf: PictureFormatter,
+    _unknown8: [0xF5]u32 = @splat(0),
+    p3d: Graphics,
+
+    comptime {
+        if (builtin.cpu.arch.isArm()) {
+            if (@offsetOf(Registers, "timing_control") != 0x50) @compileError(std.fmt.comptimePrint("found 0x{X}", .{@offsetOf(Registers, "timing_control")}));
+            if (@offsetOf(Registers, "traffic_statistics") != 0x70) @compileError(std.fmt.comptimePrint("found 0x{X}", .{@offsetOf(Registers, "traffic_statistics")}));
+            if (@offsetOf(Registers, "pdc") != 0x400) @compileError(std.fmt.comptimePrint("found 0x{X}", .{@offsetOf(Registers, "pdc")}));
+            if (@offsetOf(Registers, "ppf") != 0xC00) @compileError(std.fmt.comptimePrint("found 0x{X}", .{@offsetOf(Registers, "ppf")}));
+            if (@offsetOf(Registers, "p3d") != 0x1000) @compileError(std.fmt.comptimePrint("found 0x{X}", .{@offsetOf(Registers, "p3d")}));
+        }
+    }
+};
+
+comptime {
+    if (@sizeOf(MemoryFill) != 0x10)
+        @compileError(std.fmt.comptimePrint("(@sizeOf(MemoryFill) == 0x{X}) and 0x{X} != 0x10!", .{ @sizeOf(MemoryFill), @sizeOf(MemoryFill) }));
+
+    if (@sizeOf(PictureFormatter) != 0x2C)
+        @compileError(std.fmt.comptimePrint("(@sizeOf(MemoryCopy) == 0x{X}) and 0x{X} != 0x2C!", .{ @sizeOf(PictureFormatter), @sizeOf(PictureFormatter) }));
+
+    _ = morton;
+    _ = shader;
+}
+
+const testing = std.testing;
+
+const builtin = @import("builtin");
+
+const std = @import("std");
+const zsflt = @import("zsflt");
+const zitrus = @import("zitrus");
+const hardware = zitrus.hardware;
+
+const Trigger = hardware.Trigger;
+const LsbRegister = hardware.LsbRegister;
+const MsbRegister = hardware.MsbRegister;
+const BitpackedArray = hardware.BitpackedArray;
+const AlignedPhysicalAddress = hardware.AlignedPhysicalAddress;
+const PhysicalAddress = hardware.PhysicalAddress;
+
+const OperandDescriptor = shader.encoding.OperandDescriptor;
+const Instruction = shader.encoding.Instruction;
+const FloatConstantRegister = shader.register.Source.Constant;
+const InputRegister = shader.register.Source.Input;
diff --git a/src/platform/3ds/mango/hardware/pica/command.zig b/src/platform/3ds/mango/hardware/pica/command.zig
new file mode 100644
index 0000000..f52fcfa
--- /dev/null
+++ b/src/platform/3ds/mango/hardware/pica/command.zig
@@ -0,0 +1,544 @@
+//! Type-safe PICA200 `pica.Graphics` command wrappers and types.
+//!
+//! Address and Size of command queues/buffers/lists must be aligned to 16 bytes
+//! Commands are aligned to 8 bytes
+
+pub const Header = packed struct(u32) {
+    pub const Mode = enum(u1) { consecutive, incremental };
+
+    id: Id,
+    mask: u4,
+    extra: u8,
+    _unused0: u3 = 0,
+    mode: Mode,
+};
+
+pub const Id = enum(u16) {
+    _,
+
+    pub fn fromRegister(comptime base: *volatile pica.Graphics, register: *volatile anyopaque) Id {
+        std.debug.assert(@intFromPtr(register) >= @intFromPtr(base) and @intFromPtr(register) < (@intFromPtr(base) + @sizeOf(pica.Graphics))); // invalid internal register, pointer is not within the valid range
+
+        const offset = @intFromPtr(register) - @intFromPtr(base);
+
+        std.debug.assert((offset % @alignOf(u32)) == 0); // invalid internal register, it must be aligned to 4 bytes
+
+        return @enumFromInt(@divExact(offset, @alignOf(u32)));
+    }
+};
+
+/// WARNING: using this will bloat your binary!
+pub const Dump = struct {
+    pub const Iterator = struct {
+        words: []const u32,
+        current: u32,
+
+        pub fn init(words: []const u32) Iterator {
+            return .{ .words = words, .current = 0 };
+        }
+
+        pub fn next(it: *Iterator) ?Dump {
+            if (it.current + 1 >= it.words.len) return null;
+            const hdr: Header = @bitCast(it.words[it.current + 1]);
+            const full_len = 2 + @as(u32, hdr.extra);
+            defer it.current += std.mem.alignForward(u32, full_len, 2);
+
+            return .{ .words = it.words[it.current..][0..@min(full_len, it.words.len - it.current)] };
+        }
+    };
+
+    pub const Single = struct {
+        // XXX: This is quite bad, a rewrite would be good
+        pub const Info = struct {
+            /// Fully qualified name
+            name: []const u8,
+            type: type,
+
+            pub fn findName(id: Id) []const u8 {
+                return switch (@intFromEnum(id)) {
+                    (@sizeOf(pica.Graphics) / @sizeOf(u32))...0xFFFF => "<not found>",
+                    inline else => |word_offset| find(word_offset * @sizeOf(u32)).name,
+                };
+            }
+
+            pub fn find(comptime offset: u32) Info {
+                @setEvalBranchQuota(200000);
+
+                var current = Search.find(pica.Graphics, offset);
+                var current_offset = offset - @offsetOf(pica.Graphics, current.name);
+                var fully_qualified_name = current.name;
+                while (@sizeOf(current.type) > @sizeOf(u32)) switch (@typeInfo(current.type)) {
+                    .@"struct" => |st| switch (st.layout) {
+                        .auto => unreachable,
+                        .@"packed" => unreachable, // Hitting this means you have an invalid packed struct in there.
+                        .@"extern" => {
+                            const next = Search.find(current.type, current_offset);
+
+                            current_offset -= @offsetOf(current.type, next.name);
+                            current = next;
+
+                            fully_qualified_name = fully_qualified_name ++ "." ++ next.name;
+                        },
+                    },
+                    .array => |array| switch (std.math.order(@sizeOf(array.child), @sizeOf(u32))) {
+                        .lt => current.type = [@divExact(@sizeOf(u32), @sizeOf(array.child))]array.child,
+                        .eq, .gt => {
+                            fully_qualified_name = fully_qualified_name ++ std.fmt.comptimePrint("[{d}]", .{current_offset / @sizeOf(array.child)});
+                            current_offset %= @sizeOf(array.child);
+                            current.type = array.child;
+                        },
+                    },
+                    else => @compileError("TODO"),
+                };
+
+                return .{ .name = fully_qualified_name, .type = current.type };
+            }
+
+            const Search = struct {
+                parent: type,
+                offset: u32,
+
+                pub fn find(comptime T: type, comptime offset: u32) Info {
+                    const fields = @typeInfo(T).@"struct".fields;
+                    const ctx: Search = .{ .parent = T, .offset = offset };
+                    const index = std.sort.binarySearch(std.builtin.Type.StructField, fields, ctx, Search.compare) orelse unreachable;
+                    return .{ .name = fields[index].name, .type = fields[index].type };
+                }
+
+                pub fn compare(ctx: Search, field: std.builtin.Type.StructField) std.math.Order {
+                    const field_offset = @offsetOf(ctx.parent, field.name);
+                    if (ctx.offset < field_offset) return .lt;
+                    if (ctx.offset >= field_offset + @sizeOf(field.type)) return .gt;
+                    return .eq;
+                }
+            };
+        };
+
+        mode: Header.Mode,
+        id: Id,
+        raw: u32,
+
+        pub fn format(single: Single, w: *std.Io.Writer) std.Io.Writer.Error!void {
+            switch (@intFromEnum(single.id)) {
+                (@sizeOf(pica.Graphics) / @sizeOf(u32))...0xFFFF => try w.print("{X:0>8}", .{single.raw}),
+                inline else => |word_offset| {
+                    const info: Info = .find(word_offset * @sizeOf(u32));
+
+                    switch (single.mode) {
+                        .incremental => {
+                            try w.print("{s} ({X:0>3}) -> ", .{ info.name, single.id });
+                            try printValue(info.type, single.raw, w);
+                        },
+                        .consecutive => try printValue(info.type, single.raw, w),
+                    }
+                },
+            }
+        }
+
+        pub fn printValue(comptime T: type, raw: u32, w: *std.Io.Writer) std.Io.Writer.Error!void {
+            const typed: T = switch (@typeInfo(T)) {
+                .@"enum" => @enumFromInt(raw),
+                else => @bitCast(raw),
+            };
+
+            try w.print(if (std.meta.hasFn(T, "format")) "{f}" else if (T == u32) "{X:0>8}" else "{any}", .{typed});
+        }
+    };
+
+    words: []const u32,
+
+    pub fn format(dump: Dump, w: *std.Io.Writer) std.Io.Writer.Error!void {
+        const hdr: Header = @bitCast(dump.words[1]);
+
+        switch (hdr.mode) {
+            .incremental => try w.print("{t} ({b:0>4})", .{ hdr.mode, hdr.mask }),
+            .consecutive => try w.print("{t}: {s} ({X:0>3}, {b:0>4})", .{ hdr.mode, Single.Info.findName(hdr.id), hdr.id, hdr.mask }),
+        }
+
+        if (hdr.extra > 0) try w.writeByte('\n');
+
+        var single: Single = .{
+            .mode = hdr.mode,
+            .id = hdr.id,
+            .raw = dump.words[0],
+        };
+
+        var i: u32 = 0;
+        while (true) {
+            try w.print("... {f}", .{single});
+
+            if (i >= hdr.extra) break;
+            try w.writeByte('\n');
+            single = .{
+                .mode = hdr.mode,
+                .raw = dump.words[2 + i],
+                .id = switch (hdr.mode) {
+                    .consecutive => single.id,
+                    .incremental => @enumFromInt(@intFromEnum(single.id) + 1),
+                },
+            };
+            i += 1;
+        }
+    }
+};
+
+pub const Queue = struct {
+    pub const empty: Queue = .{ .buffer = .empty, .end = 0 };
+
+    buffer: []align(16) u32,
+    end: u32,
+
+    pub fn initBuffer(buffer: []align(16) u32) Queue {
+        return .{
+            .buffer = buffer,
+            .end = 0,
+        };
+    }
+
+    pub fn slice(queue: Queue) []align(16) u32 {
+        return queue.buffer[0..queue.end];
+    }
+
+    pub fn unusedCapacitySlice(queue: Queue) []align(8) u32 {
+        return @alignCast(queue.buffer[queue.end..]);
+    }
+
+    pub fn reset(queue: *Queue) void {
+        queue.end = 0;
+    }
+
+    pub inline fn add(queue: *Queue, comptime base: *volatile pica.Graphics, register: anytype, value: std.meta.Child(@TypeOf(register))) void {
+        return queue.addMasked(base, register, value, 0xF);
+    }
+
+    pub fn addMasked(queue: *Queue, comptime base: *volatile pica.Graphics, register: anytype, value: std.meta.Child(@TypeOf(register)), mask: u4) void {
+        comptime std.debug.assert(@typeInfo(@TypeOf(register)) == .pointer);
+
+        const Child = std.meta.Child(@TypeOf(register));
+        const child_info = @typeInfo(Child);
+
+        const id: Id = .fromRegister(base, register);
+
+        switch (comptime std.math.order(@bitSizeOf(Child), @bitSizeOf(u32))) {
+            .eq => queue.addMaskedBuffer(id, &.{switch (child_info) {
+                .@"enum" => @intFromEnum(value),
+                else => @bitCast(value),
+            }}, mask, .consecutive),
+            .gt => {
+                const as_u32_array = switch (child_info) {
+                    .array => |a| if (@bitSizeOf(a.child) != @bitSizeOf(u32))
+                        @compileError("only arrays of 32-bit types are supported for incremental writes")
+                    else
+                        @as([a.len]u32, @bitCast(value)),
+                    .@"struct" => |s| if (s.layout == .auto or (@bitSizeOf(Child) % @bitSizeOf(u32)) != 0)
+                        @compileError("only non-auto structs with a bitSize multiple of 32 are supported")
+                    else
+                        @as([@divExact(@bitSizeOf(Child), @bitSizeOf(u32))]u32, @bitCast(value)),
+                    else => @compileError("unsupported type for incremental write"),
+                };
+
+                queue.addMaskedBuffer(id, &as_u32_array, mask, .incremental);
+            },
+            .lt => @compileError("commands only support writing full 32-bit values (which you can mask!)"),
+        }
+    }
+
+    fn IncrementalWritesTuple(comptime base: *volatile pica.Graphics, comptime registers: anytype) type {
+        const RegistersType = @TypeOf(registers);
+
+        comptime std.debug.assert(@typeInfo(RegistersType) == .@"struct");
+        const st_ty = @typeInfo(RegistersType).@"struct";
+
+        comptime std.debug.assert(st_ty.is_tuple);
+
+        var needed_field_types: [st_ty.fields.len]type = undefined;
+
+        @setEvalBranchQuota(st_ty.fields.len * 2000);
+        for (st_ty.fields, 0..) |field, i| {
+            std.debug.assert(@typeInfo(field.type) == .pointer);
+
+            const f_ty = @typeInfo(field.type).pointer;
+            const current = registers[i];
+            const current_id: Id = .fromRegister(base, current);
+
+            if (@bitSizeOf(f_ty.child) != @bitSizeOf(u32)) @compileLog("only values with a @bitSizeOf(u32) are supported.");
+
+            if (i > 0) {
+                const last_id: Id = .fromRegister(base, registers[i - 1]);
+
+                comptime std.debug.assert(std.math.order(@intFromEnum(current_id), @intFromEnum(last_id)) == .gt);
+                comptime std.debug.assert((@intFromEnum(current_id) - @intFromEnum(last_id)) == 1);
+            }
+
+            needed_field_types[i] = f_ty.child;
+        }
+
+        return @Tuple(&needed_field_types);
+    }
+
+    pub inline fn addIncremental(queue: *Queue, comptime base: *volatile pica.Graphics, comptime registers: anytype, values: IncrementalWritesTuple(base, registers)) void {
+        return queue.addIncrementalMasked(base, registers, values, 0b1111);
+    }
+
+    pub fn addIncrementalMasked(queue: *Queue, comptime base: *volatile pica.Graphics, comptime registers: anytype, values: IncrementalWritesTuple(base, registers), mask: u4) void {
+        if (registers.len == 0) return;
+
+        comptime std.debug.assert(values.len <= 256);
+        const first_id: Id = .fromRegister(base, registers[0]);
+
+        var u32_values: [values.len]u32 = undefined;
+        inline for (&u32_values, 0..) |*v, i| v.* = switch (@typeInfo(@TypeOf(values[i]))) {
+            .@"enum" => @intFromEnum(values[i]),
+            else => @bitCast(values[i]),
+        };
+
+        return queue.addMaskedBuffer(first_id, &u32_values, mask, .incremental);
+    }
+
+    pub inline fn addConsecutive(queue: *Queue, comptime base: *volatile pica.Graphics, register: anytype, values: []const std.meta.Child(@TypeOf(register))) void {
+        return queue.addConsecutiveMasked(base, register, values, 0b1111);
+    }
+
+    pub fn addConsecutiveMasked(queue: *Queue, comptime base: *volatile pica.Graphics, register: anytype, values: []const std.meta.Child(@TypeOf(register)), mask: u4) void {
+        comptime std.debug.assert(@typeInfo(@TypeOf(register)) == .pointer);
+
+        const Child = std.meta.Child(@TypeOf(register));
+        const id: Id = .fromRegister(base, register);
+
+        comptime std.debug.assert(@bitSizeOf(Child) == @bitSizeOf(u32));
+
+        return queue.addMaskedBuffer(id, @ptrCast(values), mask, .consecutive);
+    }
+
+    pub fn addMaskedBuffer(queue: *Queue, id: Id, values: []const u32, mask: u4, mode: Header.Mode) void {
+        if (values.len == 0) return;
+
+        var current_id: Id = id;
+        var current: usize = 0;
+        var remaining: usize = values.len;
+
+        while (remaining > 0) {
+            const len = @min(remaining, 256);
+            defer {
+                current += len;
+                remaining -= len;
+            }
+
+            const remaining_slice = values[current..][0..len];
+
+            queue.buffer[queue.end] = remaining_slice[0];
+            queue.buffer[queue.end + 1] = @bitCast(Header{
+                .id = id,
+                .mask = mask,
+                .extra = @intCast(len - 1),
+                .mode = mode,
+            });
+            queue.end += 2;
+
+            @memcpy(queue.buffer[queue.end..][0..(len - 1)], remaining_slice[1..len]);
+            queue.end += std.mem.alignForward(usize, len - 1, 2); // commands must be aligned to 8 bytes
+            if (mode == .incremental) current_id = @enumFromInt(@intFromEnum(current_id) + len);
+        }
+    }
+
+    pub fn chain(queue: *Queue, address: zitrus.hardware.AlignedPhysicalAddress(.@"16", .@"8")) *zitrus.hardware.LsbRegister(u22) {
+        const p3d = &zitrus.memory.arm11.pica.p3d;
+
+        const size = &queue.buffer[queue.end];
+        queue.add(p3d, &p3d.primitive_engine.command_buffer.size[0], .init(0));
+        queue.add(p3d, &p3d.primitive_engine.command_buffer.address[0], address);
+        queue.add(p3d, &p3d.primitive_engine.command_buffer.jump[0], .init(.trigger));
+
+        if (!std.mem.isAligned(queue.end, 4)) {
+            queue.add(p3d, &p3d.primitive_engine.command_buffer.jump[0], .init(.trigger));
+        }
+
+        return @ptrCast(size);
+    }
+
+    pub fn finalize(queue: *Queue) void {
+        const p3d = &zitrus.memory.arm11.pica.p3d;
+
+        queue.add(p3d, &p3d.irq.req[0..4].*, @bitCast(@as(u32, 0x12345678)));
+
+        if (!std.mem.isAligned(queue.end, 4)) {
+            queue.add(p3d, &p3d.irq.req[0..4].*, @bitCast(@as(u32, 0x12345678)));
+        }
+    }
+};
+
+/// Represents a growable command stream (multiple chained command queues)
+pub const stream = struct {
+    pub const StreamResetMode = enum { free_all, retain_largest };
+    pub const Segment = struct {
+        queue: Queue,
+        node: std.SinglyLinkedList.Node,
+
+        comptime {
+            std.debug.assert(@sizeOf(Segment) == 16);
+        }
+
+        pub fn data(segment: *Segment) []align(16) u32 {
+            return @as([*]align(16) u32, @ptrCast(@alignCast(segment)))[0 .. @divExact(@sizeOf(Segment), @sizeOf(u32)) + segment.queue.buffer.len];
+        }
+    };
+
+    /// Context must have a field called `use_jumps` which toggles whether the stream
+    /// is a single command queue or multiple chained ones (when growing it)
+    ///
+    /// If `use_jumps` is not comptime-known or is `true`, it must also implement
+    /// `fn virtualToPhysical(ctx, virtual: *align(4096) const anyopaque) zitrus.hardware.PhysicalAddress`.
+    pub fn Custom(comptime Context: type) type {
+        return struct {
+            pub const empty: Stream = .{ .list = .{}, .last_chain_size = null, .initial_chunk = &.{}, .start = 0 };
+
+            list: std.SinglyLinkedList,
+            last_chain_size: ?*zitrus.hardware.LsbRegister(u22),
+            initial_chunk: []align(16) const u32,
+            /// This is intended to be modified directly, must be aligned to 4 words (16 bytes)
+            ///
+            /// Changes when finalizing or chaining queues (e.g when growing)
+            start: u32,
+
+            pub fn deinit(strm: *Stream, gpa: std.mem.Allocator) void {
+                strm.reset(gpa, .free_all);
+                strm.* = undefined;
+            }
+
+            pub fn first(strm: *Stream) ?*Queue {
+                const head = strm.list.first orelse return null;
+                const segment: *Segment = @fieldParentPtr("node", head);
+                return &segment.queue;
+            }
+
+            /// Grows the stream exponentially, i.e 4096->8192->16384; starting from `min_len`
+            pub fn grow(
+                strm: *Stream,
+                gpa: std.mem.Allocator,
+                /// Length of the first queue *in `u32`*s
+                min_len: u32,
+                ctx: Context,
+            ) !void {
+                std.debug.assert(min_len >= @sizeOf(Segment)); // You're crazy, please bump the len A LOT.
+                std.debug.assert(std.mem.isAligned(strm.start, 4));
+
+                const segment = if (strm.list.first) |node| blk: {
+                    const first_segment: *Segment = @alignCast(@fieldParentPtr("node", node));
+                    const first_que: *Queue = &first_segment.queue;
+                    const first_data = first_segment.data();
+                    const next_len = first_data.len << 1;
+
+                    if (!ctx.use_jumps) {
+                        std.debug.assert(first_segment.node.next == null);
+
+                        const new_len = first_data.len + next_len;
+                        const new = if (gpa.remap(first_data, new_len)) |remapped| remapped else remapped: {
+                            const new = try gpa.alignedAlloc(u32, .@"16", new_len);
+                            defer gpa.free(first_data);
+
+                            const copying = first_data[0 .. @divExact(@sizeOf(Segment), @sizeOf(u32)) + first_segment.queue.end];
+                            @memcpy(new[0..copying.len], copying);
+                            break :remapped new;
+                        };
+
+                        const new_segment: *Segment = @ptrCast(new);
+                        // NOTE: we copied all commands above
+                        new_segment.queue.buffer = new[@divExact(@sizeOf(Segment), @sizeOf(u32))..];
+                        strm.list.first = &new_segment.node;
+                        return;
+                    }
+
+                    const new_segment = try allocSegment(gpa, next_len);
+                    const had_last_chain = strm.last_chain_size != null;
+
+                    if (strm.last_chain_size) |last_size| {
+                        const len = (first_que.end - strm.start);
+                        last_size.* = .init(@intCast((len * @sizeOf(u32)) >> 3));
+                    }
+
+                    strm.last_chain_size = first_que.chain(.fromPhysical(ctx.virtualToPhysical(new_segment.queue.buffer.ptr)));
+
+                    if (!had_last_chain) {
+                        strm.initial_chunk = @alignCast(first_que.buffer[strm.start..first_que.end]);
+                    }
+
+                    strm.start = 0;
+                    break :blk new_segment;
+                } else try allocSegment(gpa, min_len);
+
+                strm.list.prepend(&segment.node);
+            }
+
+            /// Finalizes and returns the initial chunk of the stream or null if none.
+            pub fn finalize(strm: *Stream) ?[]align(16) const u32 {
+                std.debug.assert(std.mem.isAligned(strm.start, 4));
+
+                const que = strm.first() orelse return null;
+
+                // Nothing to finalize
+                if (strm.start == que.end and strm.last_chain_size == null) return null;
+                que.finalize();
+
+                const initial_chunk: []align(16) const u32 = if (strm.last_chain_size) |last_size| blk: {
+                    last_size.* = .init(@intCast(((que.end - strm.start) * @sizeOf(u32)) >> 3));
+                    break :blk strm.initial_chunk;
+                } else @alignCast(que.buffer[strm.start..que.end]);
+
+                strm.last_chain_size = null;
+                strm.start = que.end;
+                return initial_chunk;
+            }
+
+            pub fn reset(strm: *Stream, gpa: std.mem.Allocator, mode: StreamResetMode) void {
+                const first_node = strm.list.first orelse return;
+                strm.last_chain_size = null;
+                strm.initial_chunk = &.{};
+                strm.start = 0;
+
+                var freeing = switch (mode) {
+                    .free_all => blk: {
+                        strm.list.first = null;
+                        break :blk first_node;
+                    },
+                    .retain_largest => blk: {
+                        first_node.next = null;
+
+                        const first_segment: *Segment = @fieldParentPtr("node", first_node);
+                        first_segment.queue.end = 0;
+                        break :blk first_node.next;
+                    },
+                };
+
+                while (freeing) |node| {
+                    freeing = node.next;
+
+                    const segment: *Segment = @alignCast(@fieldParentPtr("node", node));
+                    const segment_data = segment.data();
+                    gpa.free(segment_data);
+                }
+            }
+
+            fn allocSegment(gpa: std.mem.Allocator, len: u32) !*Segment {
+                const data = try gpa.alignedAlloc(u32, .@"16", len);
+                const segment: *Segment = @ptrCast(data);
+
+                segment.* = .{
+                    .queue = .{
+                        .buffer = data[@divExact(@sizeOf(Segment), @sizeOf(u32))..],
+                        .end = 0,
+                    },
+                    .node = .{},
+                };
+
+                return segment;
+            }
+
+            const Stream = @This();
+        };
+    }
+};
+
+const std = @import("std");
+
+const zitrus = @import("zitrus");
+const pica = zitrus.hardware.pica;
diff --git a/src/platform/3ds/mango/hardware/pica/shader.zig b/src/platform/3ds/mango/hardware/pica/shader.zig
new file mode 100644
index 0000000..beafe10
--- /dev/null
+++ b/src/platform/3ds/mango/hardware/pica/shader.zig
@@ -0,0 +1,70 @@
+//! PICA200 shader ISA encoder, assembler and (TODO) disassembler.
+//!
+//! * `as` - zitrus PICA200 shader assembler / disassebler.
+//! * `register` - register enums for everything shader related
+//! * `encoding` - single instruction encoding
+//! * `spirv` - ?? :) (TODO)
+//!
+//! * `Encoder` - Type-safe PICA200 shader ISA encoder
+
+pub const Type = enum(u1) {
+    vertex,
+    geometry,
+};
+
+pub const Geometry = union(Kind) {
+    pub const Kind = enum {
+        point,
+        variable,
+        fixed,
+    };
+
+    pub const Point = struct {
+        inputs: u5,
+    };
+
+    pub const Variable = struct {
+        full_vertices: u5,
+    };
+
+    pub const Fixed = struct {
+        vertices: u5,
+        uniform_start: register.Source.Constant,
+    };
+
+    point: Point,
+    variable: Variable,
+    fixed: Fixed,
+
+    pub fn initPoint(inputs: u5) Geometry {
+        return .{ .point = .{ .inputs = inputs } };
+    }
+
+    pub fn initVariable(full_vertices: u5) Geometry {
+        return .{ .variable = .{ .full_vertices = full_vertices } };
+    }
+
+    pub fn initFixed(vertices: u5, uniform_start: register.Source.Constant) Geometry {
+        return .{ .fixed = .{ .vertices = vertices, .uniform_start = uniform_start } };
+    }
+};
+
+pub const as = @import("shader/as.zig");
+pub const Encoder = @import("shader/Encoder.zig");
+
+pub const register = @import("shader/register.zig");
+pub const encoding = @import("shader/encoding.zig");
+
+pub const spirv = @import("shader/spirv.zig");
+
+comptime {
+    _ = as;
+    _ = Encoder;
+
+    _ = register;
+    _ = encoding;
+
+    _ = spirv;
+}
+
+const std = @import("std");
diff --git a/src/platform/3ds/mango/hardware/pica/shader/Encoder.zig b/src/platform/3ds/mango/hardware/pica/shader/Encoder.zig
new file mode 100644
index 0000000..8a0c35f
--- /dev/null
+++ b/src/platform/3ds/mango/hardware/pica/shader/Encoder.zig
@@ -0,0 +1,428 @@
+//! Type-safe PICA200 shader ISA encoder
+
+pub const OperandDescriptorAllocationError = error{OutOfDescriptors};
+pub const InstructionEncodingError = error{InvalidSourceRegisterCombination};
+
+const max_descriptors = std.math.maxInt(u7);
+
+instructions: std.ArrayList(Instruction),
+descriptors: [max_descriptors]OperandDescriptor,
+masks: [max_descriptors]OperandDescriptor.Mask,
+allocated_descriptors: u8,
+
+pub const init: Encoder = .{
+    .instructions = .empty,
+    .descriptors = undefined,
+    .masks = undefined,
+    .allocated_descriptors = 0,
+};
+
+pub fn move(encoder: *Encoder) Encoder {
+    defer encoder.* = .init;
+    return encoder.*;
+}
+
+pub fn deinit(encoder: *Encoder, allocator: Allocator) void {
+    encoder.instructions.deinit(allocator);
+    encoder.* = undefined;
+}
+
+pub fn constDescriptorSlice(encoder: *const Encoder) []const OperandDescriptor {
+    return encoder.descriptors[0..encoder.allocated_descriptors];
+}
+
+pub fn descriptorSlice(encoder: *Encoder) []OperandDescriptor {
+    return encoder.descriptors[0..encoder.allocated_descriptors];
+}
+
+pub fn getOrAllocateOperandDescriptor(encoder: *Encoder, comptime T: type, comptime descriptor_mask: OperandDescriptor.Mask, operand_descriptor: OperandDescriptor) OperandDescriptorAllocationError!T {
+    std.debug.assert(T == u5 or T == u7);
+
+    for (encoder.descriptors[0..encoder.allocated_descriptors], encoder.masks[0..encoder.allocated_descriptors], 0..) |*descriptor, *mask, i| {
+        if (mask.*.contains(descriptor_mask) and operand_descriptor.equalsMasked(descriptor_mask, descriptor.*)) {
+            // Reuse the descriptor
+            return @intCast(i);
+        }
+
+        if (descriptor_mask.contains(mask.*) and operand_descriptor.equalsMasked(mask.*, descriptor.*)) {
+            // Reuse and expand the descriptor
+            descriptor.* = operand_descriptor;
+            mask.* = descriptor_mask;
+            return @intCast(i);
+        }
+    }
+
+    if (encoder.descriptors.len == encoder.allocated_descriptors) {
+        return error.OutOfDescriptors;
+    }
+
+    if (encoder.allocated_descriptors < std.math.maxInt(T)) {
+        encoder.descriptors[encoder.allocated_descriptors] = operand_descriptor;
+        encoder.masks[encoder.allocated_descriptors] = descriptor_mask;
+        encoder.allocated_descriptors += 1;
+        return @intCast(encoder.allocated_descriptors - 1);
+    }
+
+    // TODO:
+    // Swap a non-reduced descriptor or return error
+    return error.OutOfDescriptors;
+}
+
+pub fn addInstruction(encoder: *Encoder, allocator: Allocator, instruction: Instruction) !void {
+    try encoder.instructions.append(allocator, instruction);
+}
+
+pub fn unparametized(encoder: *Encoder, alloc: Allocator, opcode: Instruction.Opcode) !void {
+    return encoder.addInstruction(alloc, .{ .unparametized = .{ .opcode = opcode } });
+}
+
+pub fn unary(encoder: *Encoder, alloc: Allocator, opcode: Instruction.Opcode, dest: DestinationRegister, dst_mask: Mask, src1_neg: Negation, src1: SourceRegister, src1_selector: Selector, src_rel: RelativeComponent) !void {
+    const descriptor_id = try encoder.getOrAllocateOperandDescriptor(u7, .unary, .{
+        .dst_mask = dst_mask,
+        .src1_neg = src1_neg,
+        .src1_selector = src1_selector,
+    });
+
+    return encoder.addInstruction(alloc, .{ .register = .{
+        .operand_descriptor_id = descriptor_id,
+        .src1 = src1,
+        .src2 = .v0,
+        .address_component = src_rel,
+        .dst = dest,
+        .opcode = opcode,
+    } });
+}
+
+pub fn binary(encoder: *Encoder, alloc: Allocator, opcode: Instruction.Opcode, dest: DestinationRegister, dst_mask: Mask, src1_neg: Negation, src1: SourceRegister, src1_selector: Selector, src2_neg: Negation, src2: SourceRegister, src2_selector: Selector, src_rel: RelativeComponent) !void {
+    if (!src1.isLimited() and !src2.isLimited()) {
+        return error.InvalidSourceRegisterCombination;
+    }
+
+    if (src1.isLimited() != src2.isLimited() and !src2.isLimited()) {
+        if (!opcode.isCommutative()) {
+            if (opcode.invert()) |opcode_i| {
+                const descriptor_id = try encoder.getOrAllocateOperandDescriptor(u7, .binary, .{
+                    .dst_mask = dst_mask,
+                    .src1_neg = src1_neg,
+                    .src1_selector = src1_selector,
+                    .src2_neg = src2_neg,
+                    .src2_selector = src2_selector,
+                });
+
+                return encoder.addInstruction(alloc, .{ .register_inverted = .{ .operand_descriptor_id = descriptor_id, .src2 = src2, .src1 = src1.toLimited().?, .address_component = src_rel, .dst = dest, .opcode = opcode_i } });
+            }
+
+            return error.InvalidSourceRegisterCombination;
+        }
+
+        const descriptor_id = try encoder.getOrAllocateOperandDescriptor(u7, .binary, .{
+            .dst_mask = dst_mask,
+            .src1_neg = src2_neg,
+            .src1_selector = src2_selector,
+            .src2_neg = src1_neg,
+            .src2_selector = src1_selector,
+        });
+
+        return encoder.addInstruction(alloc, .{ .register = .{ .operand_descriptor_id = descriptor_id, .src2 = src1.toLimited().?, .src1 = src2, .address_component = src_rel, .dst = dest, .opcode = opcode } });
+    }
+
+    // TODO: If commutative we could search and reuse an operand descriptor with swapped src1 <=> src2
+    const descriptor_id = try encoder.getOrAllocateOperandDescriptor(u7, .binary, .{
+        .dst_mask = dst_mask,
+        .src1_neg = src1_neg,
+        .src1_selector = src1_selector,
+        .src2_neg = src2_neg,
+        .src2_selector = src2_selector,
+    });
+
+    return encoder.addInstruction(alloc, .{ .register = .{ .operand_descriptor_id = descriptor_id, .src2 = src2.toLimited().?, .src1 = src1, .address_component = src_rel, .dst = dest, .opcode = opcode } });
+}
+
+pub fn flow(encoder: *Encoder, alloc: Allocator, opcode: Instruction.Opcode, num: u8, dest: u12, condition: Condition, x: bool, y: bool) !void {
+    return encoder.addInstruction(alloc, .{ .control_flow = .{
+        .num = num,
+        .dst = dest,
+        .condition = condition,
+        .ref_x = x,
+        .ref_y = y,
+        .opcode = opcode,
+    } });
+}
+
+pub fn flowConstant(encoder: *Encoder, alloc: Allocator, opcode: Instruction.Opcode, num: u8, dest: u12, constant: IntegralRegister) !void {
+    return encoder.addInstruction(alloc, .{ .constant_control_flow = .{
+        .num = num,
+        .dst = dest,
+        .src = constant,
+        .opcode = opcode,
+    } });
+}
+
+pub fn add(encoder: *Encoder, alloc: Allocator, dest: DestinationRegister, dst_mask: Mask, src1_neg: Negation, src1: SourceRegister, src1_selector: Selector, src2_neg: Negation, src2: SourceRegister, src2_selector: Selector, src_rel: RelativeComponent) !void {
+    return encoder.binary(alloc, .add, dest, dst_mask, src1_neg, src1, src1_selector, src2_neg, src2, src2_selector, src_rel);
+}
+
+pub fn dp3(encoder: *Encoder, alloc: Allocator, dest: DestinationRegister, dst_mask: Mask, src1_neg: Negation, src1: SourceRegister, src1_selector: Selector, src2_neg: Negation, src2: SourceRegister, src2_selector: Selector, src_rel: RelativeComponent) !void {
+    return encoder.binary(alloc, .dp3, dest, dst_mask, src1_neg, src1, src1_selector, src2_neg, src2, src2_selector, src_rel);
+}
+
+pub fn dp4(encoder: *Encoder, alloc: Allocator, dest: DestinationRegister, dst_mask: Mask, src1_neg: Negation, src1: SourceRegister, src1_selector: Selector, src2_neg: Negation, src2: SourceRegister, src2_selector: Selector, src_rel: RelativeComponent) !void {
+    return encoder.binary(alloc, .dp4, dest, dst_mask, src1_neg, src1, src1_selector, src2_neg, src2, src2_selector, src_rel);
+}
+
+pub fn dph(encoder: *Encoder, alloc: Allocator, dest: DestinationRegister, dst_mask: Mask, src1_neg: Negation, src1: SourceRegister, src1_selector: Selector, src2_neg: Negation, src2: SourceRegister, src2_selector: Selector, src_rel: RelativeComponent) !void {
+    return encoder.binary(alloc, .dph, dest, dst_mask, src1_neg, src1, src1_selector, src2_neg, src2, src2_selector, src_rel);
+}
+
+pub fn dst(encoder: *Encoder, alloc: Allocator, dest: DestinationRegister, dst_mask: Mask, src1_neg: Negation, src1: SourceRegister, src1_selector: Selector, src2_neg: Negation, src2: SourceRegister, src2_selector: Selector, src_rel: RelativeComponent) !void {
+    return encoder.binary(alloc, .dst, dest, dst_mask, src1_neg, src1, src1_selector, src2_neg, src2, src2_selector, src_rel);
+}
+
+pub fn ex2(encoder: *Encoder, alloc: Allocator, dest: DestinationRegister, dst_mask: Mask, src1_neg: Negation, src1: SourceRegister, src1_selector: Selector, src_rel: RelativeComponent) !void {
+    return encoder.unary(alloc, .ex2, dest, dst_mask, src1_neg, src1, src1_selector, src_rel);
+}
+
+pub fn lg2(encoder: *Encoder, alloc: Allocator, dest: DestinationRegister, dst_mask: Mask, src1_neg: Negation, src1: SourceRegister, src1_selector: Selector, src_rel: RelativeComponent) !void {
+    return encoder.unary(alloc, .lg2, dest, dst_mask, src1_neg, src1, src1_selector, src_rel);
+}
+
+pub fn litp(encoder: *Encoder, alloc: Allocator, dest: DestinationRegister, dst_mask: Mask, src1_neg: Negation, src1: SourceRegister, src1_selector: Selector, src_rel: RelativeComponent) !void {
+    return encoder.unary(alloc, .litp, dest, dst_mask, src1_neg, src1, src1_selector, src_rel);
+}
+
+pub fn mul(encoder: *Encoder, alloc: Allocator, dest: DestinationRegister, dst_mask: Mask, src1_neg: Negation, src1: SourceRegister, src1_selector: Selector, src2_neg: Negation, src2: SourceRegister, src2_selector: Selector, src_rel: RelativeComponent) !void {
+    return encoder.binary(alloc, .mul, dest, dst_mask, src1_neg, src1, src1_selector, src2_neg, src2, src2_selector, src_rel);
+}
+
+pub fn sge(encoder: *Encoder, alloc: Allocator, dest: DestinationRegister, dst_mask: Mask, src1_neg: Negation, src1: SourceRegister, src1_selector: Selector, src2_neg: Negation, src2: SourceRegister, src2_selector: Selector, src_rel: RelativeComponent) !void {
+    return encoder.binary(alloc, .sge, dest, dst_mask, src1_neg, src1, src1_selector, src2_neg, src2, src2_selector, src_rel);
+}
+
+pub fn slt(encoder: *Encoder, alloc: Allocator, dest: DestinationRegister, dst_mask: Mask, src1_neg: Negation, src1: SourceRegister, src1_selector: Selector, src2_neg: Negation, src2: SourceRegister, src2_selector: Selector, src_rel: RelativeComponent) !void {
+    return encoder.binary(alloc, .slt, dest, dst_mask, src1_neg, src1, src1_selector, src2_neg, src2, src2_selector, src_rel);
+}
+
+pub fn flr(encoder: *Encoder, alloc: Allocator, dest: DestinationRegister, dst_mask: Mask, src1_neg: Negation, src1: SourceRegister, src1_selector: Selector, src_rel: RelativeComponent) !void {
+    return encoder.unary(alloc, .flr, dest, dst_mask, src1_neg, src1, src1_selector, src_rel);
+}
+
+pub fn max(encoder: *Encoder, alloc: Allocator, dest: DestinationRegister, dst_mask: Mask, src1_neg: Negation, src1: SourceRegister, src1_selector: Selector, src2_neg: Negation, src2: SourceRegister, src2_selector: Selector, src_rel: RelativeComponent) !void {
+    return encoder.binary(alloc, .max, dest, dst_mask, src1_neg, src1, src1_selector, src2_neg, src2, src2_selector, src_rel);
+}
+
+pub fn min(encoder: *Encoder, alloc: Allocator, dest: DestinationRegister, dst_mask: Mask, src1_neg: Negation, src1: SourceRegister, src1_selector: Selector, src2_neg: Negation, src2: SourceRegister, src2_selector: Selector, src_rel: RelativeComponent) !void {
+    return encoder.binary(alloc, .min, dest, dst_mask, src1_neg, src1, src1_selector, src2_neg, src2, src2_selector, src_rel);
+}
+
+pub fn rcp(encoder: *Encoder, alloc: Allocator, dest: DestinationRegister, dst_mask: Mask, src1_neg: Negation, src1: SourceRegister, src1_selector: Selector, src_rel: RelativeComponent) !void {
+    return encoder.unary(alloc, .rcp, dest, dst_mask, src1_neg, src1, src1_selector, src_rel);
+}
+
+pub fn rsq(encoder: *Encoder, alloc: Allocator, dest: DestinationRegister, dst_mask: Mask, src1_neg: Negation, src1: SourceRegister, src1_selector: Selector, src_rel: RelativeComponent) !void {
+    return encoder.unary(alloc, .rsq, dest, dst_mask, src1_neg, src1, src1_selector, src_rel);
+}
+
+pub fn mova(encoder: *Encoder, alloc: Allocator, a_mask: register.AddressComponent.Mask, src1_neg: Negation, src1: SourceRegister, src1_selector: Selector, src_rel: RelativeComponent) !void {
+    return encoder.unary(alloc, .mova, .o0, .{ .enable_x = a_mask.enable_x, .enable_y = a_mask.enable_y }, src1_neg, src1, src1_selector, src_rel);
+}
+
+pub fn mov(encoder: *Encoder, alloc: Allocator, dest: DestinationRegister, dst_mask: Mask, src1_neg: Negation, src1: SourceRegister, src1_selector: Selector, src_rel: RelativeComponent) !void {
+    return encoder.unary(alloc, .mov, dest, dst_mask, src1_neg, src1, src1_selector, src_rel);
+}
+
+// dphi handled by dph
+// dsti handled by dst
+// sgei handled by sge
+// slti handled by slt
+
+pub fn @"break"(encoder: *Encoder, alloc: Allocator) !void {
+    return encoder.unparametized(alloc, .@"break");
+}
+
+pub fn nop(encoder: *Encoder, alloc: Allocator) !void {
+    return encoder.unparametized(alloc, .nop);
+}
+
+pub fn end(encoder: *Encoder, alloc: Allocator) !void {
+    return encoder.unparametized(alloc, .end);
+}
+
+pub fn breakc(encoder: *Encoder, alloc: Allocator, condition: Condition, x: bool, y: bool) !void {
+    return encoder.flow(alloc, .breakc, 0, 0, condition, x, y);
+}
+
+pub fn call(encoder: *Encoder, alloc: Allocator, dest: u12, num: u8) !void {
+    return encoder.flow(alloc, .call, num, dest, .@"and", false, false);
+}
+
+pub fn callc(encoder: *Encoder, alloc: Allocator, condition: Condition, x: bool, y: bool, dest: u12, num: u8) !void {
+    return encoder.flow(alloc, .callc, num, dest, condition, x, y);
+}
+
+pub fn callu(encoder: *Encoder, alloc: Allocator, b: BooleanRegister, dest: u12, num: u8) !void {
+    return encoder.flowConstant(alloc, .callu, num, dest, .{ .bool = b });
+}
+
+pub fn ifu(encoder: *Encoder, alloc: Allocator, b: BooleanRegister, dest: u12, num: u8) !void {
+    return encoder.flowConstant(alloc, .ifu, num, dest, .{ .bool = b });
+}
+
+pub fn ifc(encoder: *Encoder, alloc: Allocator, condition: Condition, x: bool, y: bool, dest: u12, num: u8) !void {
+    return encoder.flow(alloc, .ifc, num, dest, condition, x, y);
+}
+
+pub fn loop(encoder: *Encoder, alloc: Allocator, i: IntegerRegister, dest: u12) !void {
+    return encoder.flowConstant(alloc, .loop, 0, dest, .{ .int = .{ .used = i } });
+}
+
+pub fn setemit(encoder: *Encoder, alloc: Allocator, vertex_id: u2, primitive: Primitive, winding: Winding) !void {
+    return encoder.addInstruction(alloc, .{ .set_emit = .{
+        .winding = winding,
+        .primitive_emit = primitive,
+        .vertex_id = vertex_id,
+        .opcode = .setemit,
+    } });
+}
+
+pub fn emit(encoder: *Encoder, alloc: Allocator) !void {
+    return encoder.unparametized(alloc, .emit);
+}
+
+pub fn jmpc(encoder: *Encoder, alloc: Allocator, condition: Condition, x: bool, y: bool, dest: u12) !void {
+    return encoder.flow(alloc, .jmpc, 0, dest, condition, x, y);
+}
+
+pub fn jmpu(encoder: *Encoder, alloc: Allocator, b: BooleanRegister, if_true: bool, dest: u12) !void {
+    return encoder.flowConstant(alloc, .jmpu, @intFromBool(!if_true), dest, .{ .bool = b });
+}
+
+pub fn cmp(encoder: *Encoder, alloc: Allocator, src1_neg: Negation, src1: SourceRegister, src1_selector: Selector, x: Comparison, y: Comparison, src2_neg: Negation, src2: SourceRegister, src2_selector: Selector, src_rel: RelativeComponent) !void {
+    if (!src1.isLimited() and !src2.isLimited()) {
+        return error.InvalidSourceRegisterCombination;
+    }
+
+    const descriptor_id, const i_src1, const i_src2, const x_cmp, const y_cmp = if (!src2.isLimited())
+        .{ try encoder.getOrAllocateOperandDescriptor(u7, .comparison, .{
+            .src1_neg = src2_neg,
+            .src1_selector = src2_selector,
+            .src2_neg = src1_neg,
+            .src2_selector = src1_selector,
+        }), src2, src1.toLimited().?, x.invert(), y.invert() }
+    else
+        .{ try encoder.getOrAllocateOperandDescriptor(u7, .comparison, .{
+            .src1_neg = src1_neg,
+            .src1_selector = src1_selector,
+            .src2_neg = src2_neg,
+            .src2_selector = src2_selector,
+        }), src1, src2.toLimited().?, x, y };
+
+    return encoder.addInstruction(alloc, .{ .comparison = .{
+        .operand_descriptor_id = descriptor_id,
+        .src2 = i_src2,
+        .src1 = i_src1,
+        .address_component = src_rel,
+        .x_operation = x_cmp,
+        .y_operation = y_cmp,
+        .opcode = Instruction.Opcode.cmp0.toComparison().?,
+    } });
+}
+
+// madi handled by mad
+
+pub fn mad(encoder: *Encoder, alloc: Allocator, dest: DestinationRegister, dst_mask: Mask, src1_neg: Negation, src1: SourceRegister.Limited, src1_selector: Selector, src2_neg: Negation, src2: SourceRegister, src2_selector: Selector, src3_neg: Negation, src3: SourceRegister, src3_selector: Selector, src_rel: RelativeComponent) !void {
+    if (!src2.isLimited() and !src3.isLimited()) {
+        return error.InvalidSourceRegisterCombination;
+    }
+
+    const descriptor_id = try encoder.getOrAllocateOperandDescriptor(u5, .full, .{
+        .dst_mask = dst_mask,
+        .src1_neg = src1_neg,
+        .src1_selector = src1_selector,
+        .src2_neg = src2_neg,
+        .src2_selector = src2_selector,
+        .src3_neg = src3_neg,
+        .src3_selector = src3_selector,
+    });
+
+    if (src2.isLimited() != src3.isLimited() and src2.isLimited()) {
+        return try encoder.addInstruction(alloc, .{ .mad_inverted = .{
+            .operand_descriptor_id = descriptor_id,
+            .src1 = src1,
+            .src2 = src2.toLimited().?,
+            .src3 = src3,
+            .address_component = src_rel,
+            .dst = dest,
+            .opcode = Instruction.Opcode.madi0.toMad().?,
+        } });
+    }
+
+    return try encoder.addInstruction(alloc, .{ .mad = .{
+        .operand_descriptor_id = descriptor_id,
+        .src1 = src1,
+        .src2 = src2,
+        .src3 = src3.toLimited().?,
+        .address_component = src_rel,
+        .dst = dest,
+        .opcode = Instruction.Opcode.mad0.toMad().?,
+    } });
+}
+
+test "test?" {
+    var fixed: [256]u8 = undefined;
+    var fba: std.heap.FixedBufferAllocator = .init(&fixed);
+    const alloc = fba.allocator();
+
+    const expected_output: []const u32 = &.{
+        0b000000_10000_00_0000000_00001_0000000,
+        0b001011_10001_00_0010000_00000_0000000,
+        0b001000_10001_00_0000011_01000_0000001,
+    };
+
+    var encoder: Encoder = .init;
+    defer encoder.deinit(alloc);
+
+    try encoder.add(alloc, .r0, .x, .@"+", .v0, .xyzw, .@"+", .v1, .xyzw, .none);
+
+    // Must have same descriptor as the previous instruction
+    try encoder.flr(alloc, .r1, .x, .@"+", .r0, .xyzw, .none);
+
+    // Should create a new descriptor
+    try encoder.mul(alloc, .r1, .x, .@"+", .v3, .wyxz, .@"+", .v8, .xxxx, .none);
+
+    // FIXME: Regression, cannot use this on the 3DS test runner.
+    // try testing.expectEqualSlices(u32, expected_output, std.mem.bytesAsSlice(u32, std.mem.sliceAsBytes(encoder.instructions.items)));
+    for (expected_output, encoder.instructions.items) |expected, output| {
+        try testing.expect(expected == @as(u32, @bitCast(output)));
+    }
+}
+
+const Encoder = @This();
+
+const std = @import("std");
+const testing = std.testing;
+
+const Allocator = std.mem.Allocator;
+
+const zitrus = @import("zitrus");
+const shader = zitrus.hardware.pica.shader;
+
+const encoding = shader.encoding;
+const Instruction = encoding.Instruction;
+const OperandDescriptor = encoding.OperandDescriptor;
+const Negation = OperandDescriptor.Negation;
+const Condition = encoding.Condition;
+const Comparison = encoding.ComparisonOperation;
+const Winding = encoding.Winding;
+const Primitive = encoding.Primitive;
+
+const Mask = encoding.Component.Mask;
+const Selector = encoding.Component.Selector;
+
+const register = shader.register;
+const RelativeComponent = register.AddressComponent;
+const SourceRegister = register.Source;
+const DestinationRegister = register.Destination;
+
+const IntegralRegister = register.Integral;
+const BooleanRegister = IntegralRegister.Boolean;
+const IntegerRegister = IntegralRegister.Integer;
diff --git a/src/platform/3ds/mango/hardware/pica/shader/as.zig b/src/platform/3ds/mango/hardware/pica/shader/as.zig
new file mode 100644
index 0000000..f926eda
--- /dev/null
+++ b/src/platform/3ds/mango/hardware/pica/shader/as.zig
@@ -0,0 +1,13 @@
+//! Zitrus PICA200 shader assembler / disassembler.
+
+pub const Tokenizer = tokenizer.Tokenizer;
+pub const Token = tokenizer.Token;
+pub const Assembler = @import("as/Assembler.zig");
+
+comptime {
+    _ = Tokenizer;
+    _ = Token;
+    _ = Assembler;
+}
+
+const tokenizer = @import("as/tokenizer.zig");
diff --git a/src/platform/3ds/mango/hardware/pica/shader/as/Assembler.zig b/src/platform/3ds/mango/hardware/pica/shader/as/Assembler.zig
new file mode 100644
index 0000000..dd5e2ea
--- /dev/null
+++ b/src/platform/3ds/mango/hardware/pica/shader/as/Assembler.zig
@@ -0,0 +1,1468 @@
+//! Zitrus PICA200 shader assembler.
+
+// TODO: Last one, we're missing a proper diagnostic for using two floating constant registers (one must be limited) but that is easy!
+
+pub const TokenList = std.MultiArrayList(struct {
+    tag: Token.Tag,
+    start: u32,
+});
+
+pub const LabelMap = std.StringArrayHashMapUnmanaged(u12);
+pub const Outputs = std.EnumMap(register.Destination.Output, pica.OutputMap);
+
+pub const FloatingConstants = std.EnumMap(register.Source.Constant, pica.F7_16x4);
+pub const IntegerConstants = std.EnumMap(register.Integral.Integer, [4]u8);
+pub const BooleanConstants = std.EnumSet(register.Integral.Boolean);
+
+pub const Assembled = struct {
+    pub const Entrypoint = struct {
+        pub const Map = std.StringArrayHashMapUnmanaged(Assembled.Entrypoint);
+        pub const Info = union(pica.shader.Type) {
+            vertex,
+            geometry: pica.shader.Geometry,
+        };
+
+        pub const Constants = struct {
+            pub const empty: Constants = .{
+                .float = .init(.{}),
+                .int = .init(.{}),
+                .bool = .init(.{}),
+            };
+
+            float: FloatingConstants,
+            int: IntegerConstants,
+            bool: BooleanConstants,
+        };
+
+        info: Info,
+        constants: Constants,
+        outputs: Outputs,
+        offset: u16,
+    };
+
+    source: [:0]const u8,
+    tokens: TokenList.Slice,
+    entrypoints: Assembled.Entrypoint.Map,
+    encoded: Encoder,
+
+    errors: []const Error,
+
+    pub fn deinit(assembled: *Assembled, gpa: std.mem.Allocator) void {
+        assembled.tokens.deinit(gpa);
+        assembled.entrypoints.deinit(gpa);
+        assembled.encoded.deinit(gpa);
+        gpa.free(assembled.errors);
+        assembled.* = undefined;
+    }
+
+    pub fn tokenTag(a: Assembled, tok_index: usize) Token.Tag {
+        return a.tokens.items(.tag)[tok_index];
+    }
+
+    pub fn tokenStart(a: Assembled, tok_index: usize) u32 {
+        return a.tokens.items(.start)[tok_index];
+    }
+
+    pub fn tokenSlice(a: Assembled, tok_index: usize) []const u8 {
+        const tok_tag = a.tokenTag(tok_index);
+
+        if (tok_tag.lexeme()) |lexeme| {
+            return lexeme;
+        }
+
+        const tok_start = a.tokenStart(tok_index);
+        var tokenizer: shader.as.Tokenizer = .{
+            .buffer = a.source,
+            .index = tok_start,
+        };
+
+        const tok = tokenizer.next();
+        std.debug.assert(tok.tag == tok_tag);
+        return a.source[tok.loc.start..tok.loc.end];
+    }
+
+    pub fn assemble(gpa: std.mem.Allocator, source: [:0]const u8) !Assembled {
+        var tokens = TokenList{};
+        defer tokens.deinit(gpa);
+
+        {
+            var tokenizer: shader.as.Tokenizer = .init(source);
+
+            while (true) {
+                const tok = tokenizer.next();
+
+                try tokens.append(gpa, .{
+                    .tag = tok.tag,
+                    .start = @intCast(tok.loc.start),
+                });
+
+                if (tok.tag == .eof) {
+                    break;
+                }
+            }
+        }
+
+        var assembler: Assembler = .{
+            .gpa = gpa,
+            .aliases = .empty,
+            .errors = .empty,
+            .source = source,
+            .tokens = tokens.toOwnedSlice(),
+            .encoder = .init,
+            .labels = .empty,
+            .entrypoints = .empty,
+            .tok_i = 0,
+            .inst_i = 0,
+        };
+        defer assembler.deinit(gpa);
+
+        assembler.passRoot() catch |e| switch (e) {
+            error.ParseError => {},
+            else => return e,
+        };
+
+        var entrypoints: Assembled.Entrypoint.Map = .empty;
+        errdefer entrypoints.deinit(gpa);
+
+        if (assembler.errors.items.len == 0) assemble: {
+            assembler.passAssemble() catch |e| switch (e) {
+                error.ParseError => break :assemble,
+                else => return e,
+            };
+
+            var it = assembler.entrypoints.iterator();
+            while (it.next()) |entry| {
+                const label_offset = assembler.labels.get(entry.key_ptr.*) orelse {
+                    try assembler.warnMsg(.{
+                        .tag = .undefined_label,
+                        .tok_i = entry.value_ptr.*.tok_i,
+                    });
+
+                    continue;
+                };
+
+                try entrypoints.put(gpa, entry.key_ptr.*, .{
+                    .info = entry.value_ptr.info,
+                    .constants = entry.value_ptr.constants,
+                    .outputs = entry.value_ptr.outputs,
+                    .offset = label_offset,
+                });
+            }
+        }
+
+        return .{
+            .source = assembler.source,
+            .tokens = assembler.tokens,
+            .encoded = assembler.encoder.move(),
+            .entrypoints = entrypoints,
+            .errors = try assembler.errors.toOwnedSlice(gpa),
+        };
+    }
+};
+
+pub const Error = struct {
+    tag: Tag,
+    tok_i: u32,
+    expected_tok: Token.Tag = .invalid,
+
+    pub const Tag = enum {
+        unknown_directive,
+        invalid_register,
+        expected_address_register,
+        invalid_address_register_mask,
+        expected_address_component,
+        cannot_address_relative,
+
+        expected_condition_register,
+        invalid_condition_register_mask,
+
+        expected_src_register,
+        expected_limited_src_register,
+        expected_dst_register,
+        expected_bool_register,
+        expected_int_register,
+        expected_float_register,
+        expected_output_register,
+        expected_uniform_register,
+
+        invalid_mask,
+        swizzled_mask,
+        invalid_swizzle,
+        cannot_swizzle,
+
+        expected_number,
+        number_too_small,
+        number_too_big,
+
+        expected_semantic,
+        invalid_semantic_component,
+        output_has_semantic,
+
+        expected_primitive,
+        expected_winding,
+        expected_comparison,
+        expected_condition,
+        expected_boolean,
+        expected_shader_type,
+        expected_geometry_kind,
+
+        redefined_label,
+        undefined_label,
+        label_range_too_big,
+
+        redefined_entry,
+        undefined_entry,
+
+        expected_directive_or_label_or_mnemonic,
+        expected_token,
+    };
+};
+
+const Entrypoint = struct {
+    pub const Map = std.StringArrayHashMapUnmanaged(Entrypoint);
+
+    info: Assembled.Entrypoint.Info,
+    constants: Assembled.Entrypoint.Constants,
+    outputs: Outputs,
+    tok_i: u32,
+};
+
+const Directive = enum {
+    /// .entry <label> <vertex/geometry> [point/variable/fixed] [inputs/full_vertices/vertices uniform_start(fX)]
+    entry,
+    /// .out oX[.mask] <semantic>[.swizzle]
+    out,
+    /// .alias <name> dX[.swizzle]
+    alias,
+    /// .set <f/i/b>X <(X, Y, Z, W)/X>
+    set,
+};
+
+const Mnemonic = enum {
+    pub const Kind = enum {
+        unparametized,
+        unary,
+        binary,
+        flow_conditional,
+        flow_uniform,
+        comparison,
+        setemit,
+        mad,
+    };
+
+    add,
+    dp3,
+    dp4,
+    dph,
+    dst,
+    ex2,
+    lg2,
+    litp,
+    mul,
+    sge,
+    slt,
+    flr,
+    max,
+    min,
+    rcp,
+    rsq,
+    mova,
+    mov,
+    @"break",
+    nop,
+    end,
+    breakc,
+    call,
+    callc,
+    callu,
+    ifu,
+    ifc,
+    loop,
+    emit,
+    setemit,
+    jmpc,
+    jmpu,
+    cmp,
+    mad,
+
+    pub fn kind(mnemonic: Mnemonic) Kind {
+        return switch (mnemonic) {
+            .@"break", .nop, .emit, .end => .unparametized,
+            .add, .dp3, .dp4, .dph, .dst, .mul, .sge, .slt, .max, .min => .binary,
+            .ex2, .lg2, .litp, .flr, .rcp, .rsq, .mova, .mov => .unary,
+            .breakc, .call, .callc, .ifc, .jmpc => .flow_conditional,
+            .callu, .ifu, .jmpu, .loop => .flow_uniform,
+            .cmp => .comparison,
+            .setemit => .setemit,
+            .mad => .mad,
+        };
+    }
+
+    pub fn toOpcode(mnemonic: Mnemonic) ?encoding.Instruction.Opcode {
+        return switch (mnemonic) {
+            .add => .add,
+            .dp3 => .dp3,
+            .dp4 => .dp4,
+            .dph => .dph,
+            .dst => .dst,
+            .ex2 => .ex2,
+            .lg2 => .lg2,
+            .litp => .litp,
+            .mul => .mul,
+            .sge => .sge,
+            .slt => .slt,
+            .flr => .flr,
+            .max => .max,
+            .min => .min,
+            .rcp => .rcp,
+            .rsq => .rsq,
+            .mova => .mova,
+            .mov => .mov,
+            .@"break" => .@"break",
+            .nop => .nop,
+            .end => .end,
+            .breakc => .breakc,
+            .call => .call,
+            .callc => .callc,
+            .callu => .callu,
+            .ifu => .ifu,
+            .ifc => .ifc,
+            .loop => .loop,
+            .emit => .emit,
+            .setemit => .setemit,
+            .jmpc => .jmpc,
+            .jmpu => .jmpu,
+            .cmp => .cmp0,
+            .mad => .mad0,
+        };
+    }
+
+    pub fn fromToken(tag: Token.Tag) Mnemonic {
+        return switch (tag) {
+            .mnemonic_add => .add,
+            .mnemonic_dp3 => .dp3,
+            .mnemonic_dp4 => .dp4,
+            .mnemonic_dph => .dph,
+            .mnemonic_dst => .dst,
+            .mnemonic_ex2 => .ex2,
+            .mnemonic_lg2 => .lg2,
+            .mnemonic_litp => .litp,
+            .mnemonic_mul => .mul,
+            .mnemonic_sge => .sge,
+            .mnemonic_slt => .slt,
+            .mnemonic_flr => .flr,
+            .mnemonic_max => .max,
+            .mnemonic_min => .min,
+            .mnemonic_rcp => .rcp,
+            .mnemonic_rsq => .rsq,
+            .mnemonic_mova => .mova,
+            .mnemonic_mov => .mov,
+            .mnemonic_break => .@"break",
+            .mnemonic_nop => .nop,
+            .mnemonic_end => .end,
+            .mnemonic_breakc => .breakc,
+            .mnemonic_call => .call,
+            .mnemonic_callc => .callc,
+            .mnemonic_callu => .callu,
+            .mnemonic_ifu => .ifu,
+            .mnemonic_ifc => .ifc,
+            .mnemonic_loop => .loop,
+            .mnemonic_emit => .emit,
+            .mnemonic_setemit => .setemit,
+            .mnemonic_jmpc => .jmpc,
+            .mnemonic_jmpu => .jmpu,
+            .mnemonic_cmp => .cmp,
+            .mnemonic_mad => .mad,
+            else => unreachable,
+        };
+    }
+};
+
+const UniformRegister = enum(u8) {
+    // zig fmt: off
+    f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15,
+    f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, f29,
+    f30, f31, f32, f33, f34, f35, f36, f37, f38, f39, f40, f41, f42, f43,
+    f44, f45, f46, f47, f48, f49, f50, f51, f52, f53, f54, f55, f56, f57,
+    f58, f59, f60, f61, f62, f63, f64, f65, f66, f67, f68, f69, f70, f71,
+    f72, f73, f74, f75, f76, f77, f78, f79, f80, f81, f82, f83, f84, f85,
+    f86, f87, f88, f89, f90, f91, f92, f93, f94, f95,
+    i0, i1, i2, i3,
+    b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15,
+    // zig fmt: on
+};
+
+const Semantic = enum {
+    /// xyzw
+    position,
+    /// xyzw
+    normal_quaternion,
+    /// xyzw
+    color,
+    /// xyz
+    texture_coordinates_0,
+    /// xy
+    texture_coordinates_1,
+    /// xy
+    texture_coordinates_2,
+    /// xyzw
+    view,
+    /// xyzw
+    dummy,
+
+    pub fn native(semantic: Semantic) [4]pica.OutputMap.Semantic {
+        return switch (semantic) {
+            .position => .{ .position_x, .position_y, .position_z, .position_w },
+            .normal_quaternion => .{ .normal_quaternion_x, .normal_quaternion_y, .normal_quaternion_z, .normal_quaternion_w },
+            .color => .{ .color_r, .color_g, .color_b, .color_a },
+            .texture_coordinates_0 => .{ .texture_coordinates_0_u, .texture_coordinates_0_v, .texture_coordinates_0_w, .unused },
+            .texture_coordinates_1 => .{ .texture_coordinates_1_u, .texture_coordinates_1_v, .unused, .unused },
+            .texture_coordinates_2 => .{ .texture_coordinates_2_u, .texture_coordinates_2_v, .unused, .unused },
+            .view => .{ .view_x, .view_y, .view_z, .unused },
+            .dummy => .{ .unused, .unused, .unused, .unused },
+        };
+    }
+};
+
+const Alias = packed struct(u16) {
+    pub const Map = std.StringArrayHashMapUnmanaged(Alias);
+
+    pub const Register = enum(u8) {
+        // zig fmt: off
+        v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
+        r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15,
+
+        f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15,
+        f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, f29,
+        f30, f31, f32, f33, f34, f35, f36, f37, f38, f39, f40, f41, f42, f43,
+        f44, f45, f46, f47, f48, f49, f50, f51, f52, f53, f54, f55, f56, f57,
+        f58, f59, f60, f61, f62, f63, f64, f65, f66, f67, f68, f69, f70, f71,
+        f72, f73, f74, f75, f76, f77, f78, f79, f80, f81, f82, f83, f84, f85,
+        f86, f87, f88, f89, f90, f91, f92, f93, f94, f95,
+
+        i0, i1, i2, i3, 
+        b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15,
+
+        o0, o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, o11, o12, o13, o14, o15,
+        // zig fmt: on
+    };
+
+    register: Register,
+    swizzle: Component.Selector,
+
+    pub const SourceSwizzlePair = struct { register.Source, Component.Selector };
+
+    pub fn toSourceRegister(aliased: Alias) ?SourceSwizzlePair {
+        return switch (@intFromEnum(aliased.register)) {
+            @intFromEnum(Register.v0)...@intFromEnum(Register.v15) => .{ .initInput(@enumFromInt(@intFromEnum(aliased.register) - @intFromEnum(Register.v0))), aliased.swizzle },
+            @intFromEnum(Register.r0)...@intFromEnum(Register.r15) => .{ .initTemporary(@enumFromInt(@intFromEnum(aliased.register) - @intFromEnum(Register.r0))), aliased.swizzle },
+            @intFromEnum(Register.f0)...@intFromEnum(Register.f95) => .{ .initConstant(@enumFromInt(@intFromEnum(aliased.register) - @intFromEnum(Register.f0))), aliased.swizzle },
+            else => null,
+        };
+    }
+
+    pub fn toDestinationRegister(aliased: Alias) ?register.Destination {
+        return switch (@intFromEnum(aliased.register)) {
+            @intFromEnum(Register.o0)...@intFromEnum(Register.o15) => .initOutput(@enumFromInt(@intFromEnum(aliased.register) - @intFromEnum(Register.o0))),
+            @intFromEnum(Register.r0)...@intFromEnum(Register.r15) => if (aliased.swizzle != Component.Selector.xyzw) null else .initTemporary(@enumFromInt(@intFromEnum(aliased.register) - @intFromEnum(Register.r0))),
+            else => null,
+        };
+    }
+
+    pub fn toIntegerRegister(aliased: Alias) ?register.Integral.Integer {
+        return switch (@intFromEnum(aliased.register)) {
+            @intFromEnum(Register.i0)...@intFromEnum(Register.i3) => @enumFromInt(@intFromEnum(aliased.register) - @intFromEnum(Register.i0)),
+            else => null,
+        };
+    }
+
+    pub fn toBooleanRegister(aliased: Alias) ?register.Integral.Boolean {
+        return switch (@intFromEnum(aliased.register)) {
+            @intFromEnum(Register.b0)...@intFromEnum(Register.b15) => @enumFromInt(@intFromEnum(aliased.register) - @intFromEnum(Register.b0)),
+            else => null,
+        };
+    }
+};
+
+gpa: std.mem.Allocator,
+aliases: Alias.Map,
+errors: std.ArrayList(Error),
+source: [:0]const u8,
+tokens: TokenList.Slice,
+encoder: Encoder,
+labels: LabelMap,
+entrypoints: Entrypoint.Map,
+tok_i: u32,
+inst_i: u12,
+
+pub fn deinit(a: *Assembler, gpa: std.mem.Allocator) void {
+    a.errors.deinit(gpa);
+    a.labels.deinit(gpa);
+    a.entrypoints.deinit(gpa);
+    a.encoder.deinit(gpa);
+    a.aliases.deinit(gpa);
+    a.* = undefined;
+}
+
+pub fn tokenTag(a: Assembler, tok_index: usize) Token.Tag {
+    return a.tokens.items(.tag)[tok_index];
+}
+
+pub fn tokenStart(a: Assembler, tok_index: usize) u32 {
+    return a.tokens.items(.start)[tok_index];
+}
+
+pub fn tokenSlice(a: Assembler, tok_index: usize) []const u8 {
+    const tok_tag = a.tokenTag(tok_index);
+
+    if (tok_tag.lexeme()) |lexeme| {
+        return lexeme;
+    }
+
+    const tok_start = a.tokenStart(tok_index);
+    var tokenizer: shader.as.Tokenizer = .{
+        .buffer = a.source,
+        .index = tok_start,
+    };
+
+    const tok = tokenizer.next();
+    std.debug.assert(tok.tag == tok_tag);
+    return a.source[tok.loc.start..tok.loc.end];
+}
+
+/// Does a pass to process labels and directives.
+pub fn passRoot(a: *Assembler) !void {
+    a.tok_i = 0;
+    a.inst_i = 0;
+
+    root: switch (a.tokenTag(a.tok_i)) {
+        .eof => {},
+        .newline => {
+            _ = a.nextToken();
+            continue :root a.tokenTag(a.tok_i);
+        },
+        .invalid, .minus, .number_literal, .comma, .l_paren, .r_paren, .l_square, .r_square, .colon, .true, .false => {
+            _ = try a.warn(.expected_directive_or_label_or_mnemonic);
+            _ = a.nextToken();
+            continue :root a.tokenTag(a.tok_i);
+        },
+        .identifier => {
+            try a.processLabel();
+            continue :root a.tokenTag(a.tok_i);
+        },
+        .dot => {
+            a.processDirective() catch |e| switch (e) {
+                error.ParseError => a.eatUntil(.newline),
+                else => return e,
+            };
+            continue :root a.tokenTag(a.tok_i);
+        },
+        .mnemonic_add,
+        .mnemonic_dp3,
+        .mnemonic_dp4,
+        .mnemonic_dph,
+        .mnemonic_dst,
+        .mnemonic_ex2,
+        .mnemonic_lg2,
+        .mnemonic_litp,
+        .mnemonic_mul,
+        .mnemonic_sge,
+        .mnemonic_slt,
+        .mnemonic_flr,
+        .mnemonic_max,
+        .mnemonic_min,
+        .mnemonic_rcp,
+        .mnemonic_rsq,
+        .mnemonic_mova,
+        .mnemonic_mov,
+        .mnemonic_break,
+        .mnemonic_nop,
+        .mnemonic_end,
+        .mnemonic_breakc,
+        .mnemonic_call,
+        .mnemonic_callc,
+        .mnemonic_callu,
+        .mnemonic_ifu,
+        .mnemonic_ifc,
+        .mnemonic_loop,
+        .mnemonic_emit,
+        .mnemonic_setemit,
+        .mnemonic_jmpc,
+        .mnemonic_jmpu,
+        .mnemonic_cmp,
+        .mnemonic_mad,
+        => {
+            a.inst_i += 1;
+            a.eatUntil(.newline);
+            continue :root a.tokenTag(a.tok_i);
+        },
+    }
+}
+
+/// Does a second pass to encode all mnemonics
+pub fn passAssemble(a: *Assembler) !void {
+    a.tok_i = 0;
+    a.inst_i = 0;
+
+    root: switch (a.tokenTag(a.tok_i)) {
+        .eof => {},
+        .newline => {
+            _ = a.nextToken();
+            continue :root a.tokenTag(a.tok_i);
+        },
+        .invalid, .minus, .number_literal, .comma, .l_paren, .r_paren, .l_square, .r_square, .colon, .true, .false => unreachable,
+        .identifier => {
+            _ = a.nextToken();
+            _ = a.nextToken();
+            continue :root a.tokenTag(a.tok_i);
+        },
+        .dot => {
+            a.eatUntil(.newline);
+            continue :root a.tokenTag(a.tok_i);
+        },
+        .mnemonic_add,
+        .mnemonic_dp3,
+        .mnemonic_dp4,
+        .mnemonic_dph,
+        .mnemonic_dst,
+        .mnemonic_ex2,
+        .mnemonic_lg2,
+        .mnemonic_litp,
+        .mnemonic_mul,
+        .mnemonic_sge,
+        .mnemonic_slt,
+        .mnemonic_flr,
+        .mnemonic_max,
+        .mnemonic_min,
+        .mnemonic_rcp,
+        .mnemonic_rsq,
+        .mnemonic_mova,
+        .mnemonic_mov,
+        .mnemonic_break,
+        .mnemonic_nop,
+        .mnemonic_end,
+        .mnemonic_breakc,
+        .mnemonic_call,
+        .mnemonic_callc,
+        .mnemonic_callu,
+        .mnemonic_ifu,
+        .mnemonic_ifc,
+        .mnemonic_loop,
+        .mnemonic_emit,
+        .mnemonic_setemit,
+        .mnemonic_jmpc,
+        .mnemonic_jmpu,
+        .mnemonic_cmp,
+        .mnemonic_mad,
+        => |mne_tok| {
+            defer a.inst_i += 1;
+            _ = a.nextToken();
+
+            a.assembleMnemonic(.fromToken(mne_tok)) catch |e| switch (e) {
+                error.ParseError => a.eatUntil(.newline),
+                else => return e,
+            };
+
+            if (a.tokenTag(a.tok_i) != .eof) {
+                _ = try a.expectToken(.newline);
+            }
+
+            continue :root a.tokenTag(a.tok_i);
+        },
+    }
+}
+
+// TODO: relative component handling
+fn assembleMnemonic(a: *Assembler, mnemonic: Mnemonic) !void {
+    const opcode = mnemonic.toOpcode();
+    const mnemonic_kind = mnemonic.kind();
+
+    switch (mnemonic_kind) {
+        .unparametized => try a.encoder.unparametized(a.gpa, opcode.?),
+        .unary => {
+            const dest: register.Destination, const dst_mask: Component.Mask, const src1_neg: Negation, const src1: register.Source, const src1_selector: Component.Selector, const src_rel: register.AddressComponent = switch (opcode.?) {
+                .mova => mova: {
+                    const address_reg = try a.parseMaskedIdentifier();
+                    const address_slice = a.tokenSlice(address_reg.identifier_tok_i);
+
+                    if (!std.mem.eql(u8, address_slice, "a")) {
+                        return a.failMsg(.{ .tag = .expected_address_register, .tok_i = address_reg.identifier_tok_i });
+                    }
+
+                    if (address_reg.mask.enable_z or address_reg.mask.enable_w) {
+                        return a.failMsg(.{ .tag = .invalid_address_register_mask, .tok_i = address_reg.identifier_tok_i });
+                    }
+
+                    _ = try a.expectToken(.comma);
+
+                    const src_info = try a.parseSourceRegister();
+
+                    break :mova .{ .o0, address_reg.mask, src_info.negated, src_info.src, src_info.swizzle, src_info.address orelse .none };
+                },
+                else => unary: {
+                    const dst_info = try a.parseDestinationRegister();
+                    _ = try a.expectToken(.comma);
+                    const src_info = try a.parseSourceRegister();
+
+                    break :unary .{ dst_info.dst, dst_info.mask, src_info.negated, src_info.src, src_info.swizzle, src_info.address orelse .none };
+                },
+            };
+
+            try a.encoder.unary(a.gpa, opcode.?, dest, dst_mask, src1_neg, src1, src1_selector, src_rel);
+        },
+        .binary => {
+            const dst_info = try a.parseDestinationRegister();
+            _ = try a.expectToken(.comma);
+            const src1_info = try a.parseSourceRegister();
+            _ = try a.expectToken(.comma);
+            const src2_info = try a.parseSourceRegister();
+
+            try a.encoder.binary(a.gpa, opcode.?, dst_info.dst, dst_info.mask, src1_info.negated, src1_info.src, src1_info.swizzle, src2_info.negated, src2_info.src, src2_info.swizzle, src1_info.address orelse src2_info.address orelse .none);
+        },
+        .flow_conditional => {
+            const num: u8, const dest: u12, const condition: encoding.Condition, const x: bool, const y: bool = values: switch (opcode.?) {
+                .breakc => {
+                    const condition = try a.parseEnum(encoding.Condition, .expected_condition);
+                    _ = try a.expectToken(.comma);
+                    const x = try a.parseBoolean();
+                    _ = try a.expectToken(.comma);
+                    const y = try a.parseBoolean();
+
+                    break :values .{ 0, 0, condition, x, y };
+                },
+                .call => {
+                    const label_range = try a.parseLabelRange();
+                    break :values .{ label_range.num, label_range.dest, .@"and", false, false };
+                },
+                .jmpc => {
+                    const condition = try a.parseEnum(encoding.Condition, .expected_condition);
+                    _ = try a.expectToken(.comma);
+                    const x = try a.parseBoolean();
+                    _ = try a.expectToken(.comma);
+                    const y = try a.parseBoolean();
+                    _ = try a.expectToken(.comma);
+                    const dest = try a.parseLabel();
+
+                    break :values .{ 0, dest.offset, condition, x, y };
+                },
+                else => {
+                    const condition = try a.parseEnum(encoding.Condition, .expected_condition);
+                    _ = try a.expectToken(.comma);
+                    const x = try a.parseBoolean();
+                    _ = try a.expectToken(.comma);
+                    const y = try a.parseBoolean();
+                    _ = try a.expectToken(.comma);
+                    const label_range = try a.parseLabelRange();
+
+                    break :values .{ label_range.num, label_range.dest, condition, x, y };
+                },
+            };
+
+            try a.encoder.flow(a.gpa, opcode.?, num, dest, condition, x, y);
+        },
+        .flow_uniform => {
+            const i_reg: register.Integral, const num: u8, const dest: u12 = values: switch (opcode.?) {
+                .loop => {
+                    const int_info = try a.parseIntegerRegister();
+                    _ = try a.expectToken(.comma);
+                    const end = try a.parseLabel();
+
+                    break :values .{ .{ .int = .{ .used = int_info.int } }, 0, (end.offset - @sizeOf(encoding.Instruction)) };
+                },
+                .jmpu => {
+                    const b_info = try a.parseBooleanRegister();
+                    _ = try a.expectToken(.comma);
+                    const if_true = try a.parseBoolean();
+                    _ = try a.expectToken(.comma);
+                    const dest = try a.parseLabel();
+
+                    break :values .{ .{ .bool = b_info.bool }, @intFromBool(!if_true), dest.offset };
+                },
+                else => {
+                    const b_info = try a.parseBooleanRegister();
+                    _ = try a.expectToken(.comma);
+                    const label_range = try a.parseLabelRange();
+
+                    break :values .{ .{ .bool = b_info.bool }, label_range.num, label_range.dest };
+                },
+            };
+
+            try a.encoder.flowConstant(a.gpa, opcode.?, num, dest, i_reg);
+        },
+        .comparison => {
+            const src1_info = try a.parseSourceRegister();
+            _ = try a.expectToken(.comma);
+            const x = try a.parseEnum(encoding.ComparisonOperation, .expected_comparison);
+            _ = try a.expectToken(.comma);
+            const y = try a.parseEnum(encoding.ComparisonOperation, .expected_comparison);
+            _ = try a.expectToken(.comma);
+            const src2_info = try a.parseSourceRegister();
+
+            try a.encoder.cmp(a.gpa, src1_info.negated, src1_info.src, src1_info.swizzle, x, y, src2_info.negated, src2_info.src, src2_info.swizzle, src1_info.address orelse src2_info.address orelse .none);
+        },
+        .setemit => {
+            const vtx_id = try a.parseInt(u2, 2);
+            _ = try a.expectToken(.comma);
+            const primitive = try a.parseEnum(encoding.Primitive, .expected_primitive);
+            _ = try a.expectToken(.comma);
+            const winding = try a.parseEnum(encoding.Winding, .expected_winding);
+
+            try a.encoder.setemit(a.gpa, vtx_id, primitive, winding);
+        },
+        .mad => {
+            const dst_info = try a.parseDestinationRegister();
+            _ = try a.expectToken(.comma);
+            const src1_info = try a.parseSourceRegister();
+            _ = try a.expectToken(.comma);
+            const src2_info = try a.parseSourceRegister();
+            _ = try a.expectToken(.comma);
+            const src3_info = try a.parseSourceRegister();
+
+            const src1_limited = if (src1_info.src.toLimited()) |src1_lim|
+                src1_lim
+            else
+                return a.failMsg(.{ .tag = .expected_limited_src_register, .tok_i = src1_info.register_tok_i });
+
+            try a.encoder.mad(a.gpa, dst_info.dst, dst_info.mask, src1_info.negated, src1_limited, src1_info.swizzle, src2_info.negated, src2_info.src, src2_info.swizzle, src3_info.negated, src3_info.src, src3_info.swizzle, src1_info.address orelse src2_info.address orelse src3_info.address orelse .none);
+        },
+    }
+}
+
+fn processLabel(a: *Assembler) !void {
+    const label = a.tokenSlice(a.tok_i);
+
+    if (a.labels.get(label) != null) {
+        try a.warn(.redefined_label);
+    }
+
+    _ = a.nextToken();
+    _ = try a.expectToken(.colon);
+
+    try a.labels.put(a.gpa, label, a.inst_i);
+}
+
+fn processDirective(a: *Assembler) !void {
+    _ = a.nextToken();
+    const directive_tok_i = try a.expectToken(.identifier);
+    const directive_slice = a.tokenSlice(directive_tok_i);
+
+    if (std.meta.stringToEnum(Directive, directive_slice)) |directive| {
+        switch (directive) {
+            .entry => {
+                const entry_label_tok_i = try a.expectToken(.identifier);
+                const entry_label = a.tokenSlice(entry_label_tok_i);
+
+                const entry_type = try a.parseEnum(shader.Type, .expected_shader_type);
+
+                const info: Assembled.Entrypoint.Info = switch (entry_type) {
+                    .vertex => .vertex,
+                    .geometry => .{ .geometry = blk: {
+                        const kind = try a.parseEnum(shader.Geometry.Kind, .expected_geometry_kind);
+
+                        break :blk switch (kind) {
+                            .point => .initPoint(try a.parseIntBounded(u5, 1, 16)),
+                            .variable => .initVariable(try a.parseIntBounded(u5, 0, std.math.maxInt(u5))),
+                            .fixed => .initFixed(try a.parseIntBounded(u5, 1, 16), try a.parseEnum(register.Source.Constant, .expected_float_register)),
+                        };
+                    } },
+                };
+
+                const gop = try a.entrypoints.getOrPut(a.gpa, entry_label);
+
+                if (gop.found_existing) {
+                    return a.failMsg(.{
+                        .tag = .redefined_entry,
+                        .tok_i = entry_label_tok_i,
+                    });
+                }
+
+                gop.value_ptr.* = .{
+                    .info = info,
+                    .constants = .empty,
+                    .outputs = .init(.{}),
+                    .tok_i = entry_label_tok_i,
+                };
+            },
+            .out => {
+                const entry_label_tok_i = try a.expectToken(.identifier);
+                const entry_label = a.tokenSlice(entry_label_tok_i);
+
+                const entry = a.entrypoints.getPtr(entry_label) orelse return a.failMsg(.{
+                    .tag = .undefined_entry,
+                    .tok_i = entry_label_tok_i,
+                });
+
+                const output_masked = try a.parseMaskedIdentifier();
+                const output_slice = a.tokenSlice(output_masked.identifier_tok_i);
+
+                const output_reg = std.meta.stringToEnum(register.Destination.Output, output_slice) orelse return a.failMsg(.{
+                    .tag = .expected_output_register,
+                    .tok_i = output_masked.identifier_tok_i,
+                });
+
+                const semantic_swizzled = try a.parseSwizzledAddressedIdentifier();
+                const semantic_slice = a.tokenSlice(semantic_swizzled.identifier_tok_i);
+
+                const semantic = std.meta.stringToEnum(Semantic, semantic_slice) orelse return a.failMsg(.{
+                    .tag = .expected_semantic,
+                    .tok_i = semantic_swizzled.identifier_tok_i,
+                });
+
+                const native_semantics = semantic.native();
+                const swizzled_semantics = sw: {
+                    var sw: [4]pica.OutputMap.Semantic = undefined;
+
+                    inline for (&.{ semantic_swizzled.swizzle.@"0", semantic_swizzled.swizzle.@"1", semantic_swizzled.swizzle.@"2", semantic_swizzled.swizzle.@"3" }, 0..) |f, i| {
+                        sw[i] = native_semantics[@intFromEnum(f)];
+                    }
+
+                    break :sw sw;
+                };
+
+                var current_output_map: pica.OutputMap = entry.outputs.get(output_reg) orelse .{
+                    .x = .unused,
+                    .y = .unused,
+                    .z = .unused,
+                    .w = .unused,
+                };
+
+                var current_semantic: usize = 0;
+                inline for (0..4) |i| {
+                    const output, const enabled = switch (i) {
+                        0 => .{ &current_output_map.x, output_masked.mask.enable_x },
+                        1 => .{ &current_output_map.y, output_masked.mask.enable_y },
+                        2 => .{ &current_output_map.z, output_masked.mask.enable_z },
+                        3 => .{ &current_output_map.w, output_masked.mask.enable_w },
+                        else => unreachable,
+                    };
+
+                    if (enabled) {
+                        if (native_semantics[current_semantic] != swizzled_semantics[current_semantic] and swizzled_semantics[current_semantic] == .unused) {
+                            return a.failMsg(.{
+                                .tag = .invalid_semantic_component,
+                                .tok_i = semantic_swizzled.identifier_tok_i,
+                            });
+                        } else if (output.* != .unused) {
+                            return a.failMsg(.{
+                                .tag = .output_has_semantic,
+                                .tok_i = output_masked.identifier_tok_i,
+                            });
+                        }
+
+                        output.* = swizzled_semantics[current_semantic];
+                        current_semantic += 1;
+                    }
+                }
+
+                entry.outputs.put(output_reg, current_output_map);
+            },
+            .set => {
+                const entry_label_tok_i = try a.expectToken(.identifier);
+                const entry_label = a.tokenSlice(entry_label_tok_i);
+
+                const entry = a.entrypoints.getPtr(entry_label) orelse return a.warnMsg(.{
+                    .tag = .undefined_entry,
+                    .tok_i = entry_label_tok_i,
+                });
+
+                const uniform_reg = try a.parseEnum(UniformRegister, .expected_uniform_register);
+
+                switch (@intFromEnum(uniform_reg)) {
+                    @intFromEnum(UniformRegister.f0)...@intFromEnum(UniformRegister.f95) => {
+                        _ = try a.expectToken(.l_paren);
+                        const x = try a.parseFloat();
+                        _ = try a.expectToken(.comma);
+                        const y = try a.parseFloat();
+                        _ = try a.expectToken(.comma);
+                        const z = try a.parseFloat();
+                        _ = try a.expectToken(.comma);
+                        const w = try a.parseFloat();
+                        _ = try a.expectToken(.r_paren);
+
+                        const f_reg: register.Source.Constant = @enumFromInt(@intFromEnum(uniform_reg) - @intFromEnum(UniformRegister.f0));
+                        entry.constants.float.put(f_reg, .pack(.of(x), .of(y), .of(z), .of(w)));
+                    },
+                    @intFromEnum(UniformRegister.i0)...@intFromEnum(UniformRegister.i3) => {
+                        _ = try a.expectToken(.l_paren);
+                        const x = try a.parseInt(u8, std.math.maxInt(u8));
+                        _ = try a.expectToken(.comma);
+                        const y = try a.parseInt(u8, std.math.maxInt(u8));
+                        _ = try a.expectToken(.comma);
+                        const z = try a.parseInt(u8, std.math.maxInt(u8));
+                        _ = try a.expectToken(.comma);
+                        const w = try a.parseInt(u8, std.math.maxInt(u8));
+                        _ = try a.expectToken(.r_paren);
+
+                        const i_reg: register.Integral.Integer = @enumFromInt(@intFromEnum(uniform_reg) - @intFromEnum(UniformRegister.i0));
+                        entry.constants.int.put(i_reg, .{ x, y, z, w });
+                    },
+                    @intFromEnum(UniformRegister.b0)...@intFromEnum(UniformRegister.b15) => {
+                        const b_reg: register.Integral.Boolean = @enumFromInt(@intFromEnum(uniform_reg) - @intFromEnum(UniformRegister.b0));
+                        const b_value = try a.parseBoolean();
+
+                        entry.constants.bool.setPresent(b_reg, b_value);
+                    },
+                    else => unreachable,
+                }
+            },
+            .alias => {
+                const alias_identifier_tok_i = try a.expectToken(.identifier);
+                const alias_slice = a.tokenSlice(alias_identifier_tok_i);
+
+                const swizzled_identifier = try a.parseSwizzledAddressedIdentifier();
+                const aliased_slice = a.tokenSlice(swizzled_identifier.identifier_tok_i);
+
+                const aliased_reg: Alias.Register = std.meta.stringToEnum(Alias.Register, aliased_slice) orelse {
+                    try a.warnMsg(.{
+                        .tag = .invalid_register,
+                        .tok_i = swizzled_identifier.identifier_tok_i,
+                    });
+
+                    return a.eatUntil(.newline);
+                };
+
+                if (swizzled_identifier.swizzle != Component.Selector.xyzw) switch (@intFromEnum(aliased_reg)) {
+                    @intFromEnum(Alias.Register.o0)...@intFromEnum(Alias.Register.o15), @intFromEnum(Alias.Register.i0)...@intFromEnum(Alias.Register.i3), @intFromEnum(Alias.Register.b0)...@intFromEnum(Alias.Register.b15) => {
+                        try a.warnMsg(.{
+                            .tag = .cannot_swizzle,
+                            .tok_i = swizzled_identifier.identifier_tok_i,
+                        });
+
+                        return a.eatUntil(.newline);
+                    },
+                    else => {},
+                };
+
+                try a.aliases.put(a.gpa, alias_slice, .{
+                    .register = aliased_reg,
+                    .swizzle = swizzled_identifier.swizzle,
+                });
+            },
+        }
+    } else {
+        try a.warn(.unknown_directive);
+        a.eatUntil(.newline);
+    }
+}
+
+const SourceRegisterInfo = struct {
+    register_tok_i: u32,
+
+    negated: Negation,
+    src: register.Source,
+    swizzle: Component.Selector,
+    address: ?register.AddressComponent,
+};
+
+fn parseSourceRegister(a: *Assembler) !SourceRegisterInfo {
+    const negated: Negation = if (a.tokenTag(a.tok_i) == .minus) negated: {
+        _ = a.nextToken();
+        break :negated .@"-";
+    } else .@"+";
+
+    const parsed_src = try a.parseSwizzledAddressedIdentifier();
+    const src_slice = a.tokenSlice(parsed_src.identifier_tok_i);
+
+    const src: register.Source, const initial_swizzle: Component.Selector = if (a.aliases.get(src_slice)) |alias| aliased: {
+        if (alias.toSourceRegister()) |src_pair| {
+            break :aliased src_pair;
+        } else return a.failMsg(.{ .tag = .expected_src_register, .tok_i = parsed_src.identifier_tok_i });
+    } else .{ register.Source.parse(src_slice) catch return a.failMsg(.{ .tag = .expected_src_register, .tok_i = parsed_src.identifier_tok_i }), .xyzw };
+
+    if (src.kind() != .constant and parsed_src.address != null) return a.failMsg(.{
+        .tok_i = parsed_src.identifier_tok_i,
+        .tag = .cannot_address_relative,
+    });
+
+    return .{
+        .register_tok_i = parsed_src.identifier_tok_i,
+        .negated = negated,
+        .src = src,
+        .swizzle = initial_swizzle.swizzle(parsed_src.swizzle),
+        .address = parsed_src.address,
+    };
+}
+
+fn parseRelativeAddressing(a: *Assembler) !?register.AddressComponent {
+    if (a.tokenTag(a.tok_i) != .l_square) return null;
+
+    _ = a.nextToken();
+    const address_reg_tok_i = try a.expectToken(.identifier);
+    const address_reg_iden = a.tokenSlice(address_reg_tok_i);
+
+    if (!std.mem.eql(u8, address_reg_iden, "a")) return a.failMsg(.{
+        .tok_i = address_reg_tok_i,
+        .tag = .expected_address_component,
+    });
+
+    _ = try a.expectToken(.dot);
+
+    const address_component_tok_i = try a.expectToken(.identifier);
+    const address_component_iden = a.tokenSlice(address_component_tok_i);
+
+    if (!std.mem.eql(u8, address_component_iden, "x") and !std.mem.eql(u8, address_component_iden, "y") and !std.mem.eql(u8, address_component_iden, "l")) return a.failMsg(.{
+        .tok_i = address_component_tok_i,
+        .tag = .expected_address_component,
+    });
+
+    const component = std.meta.stringToEnum(register.AddressComponent, address_component_iden) orelse unreachable;
+
+    _ = try a.expectToken(.r_square);
+    return component;
+}
+
+const DestinationRegisterInfo = struct {
+    register_tok_i: u32,
+
+    dst: register.Destination,
+    mask: Component.Mask,
+};
+
+fn parseDestinationRegister(a: *Assembler) !DestinationRegisterInfo {
+    const parsed_dst = try a.parseMaskedIdentifier();
+    const dst_slice = a.tokenSlice(parsed_dst.identifier_tok_i);
+
+    const dst: register.Destination = if (a.aliases.get(dst_slice)) |alias| aliased: {
+        if (alias.toDestinationRegister()) |dst| {
+            break :aliased dst;
+        } else return a.failMsg(.{ .tag = .expected_dst_register, .tok_i = parsed_dst.identifier_tok_i });
+    } else register.Destination.parse(dst_slice) catch return a.failMsg(.{ .tag = .expected_dst_register, .tok_i = parsed_dst.identifier_tok_i });
+
+    return .{
+        .register_tok_i = parsed_dst.identifier_tok_i,
+        .dst = dst,
+        .mask = parsed_dst.mask,
+    };
+}
+
+const BooleanRegisterInfo = struct {
+    register_tok_i: u32,
+    bool: register.Integral.Boolean,
+};
+
+fn parseBooleanRegister(a: *Assembler) !BooleanRegisterInfo {
+    const b_tok_i = try a.expectToken(.identifier);
+    const b_slice = a.tokenSlice(b_tok_i);
+
+    const b: register.Integral.Boolean = if (a.aliases.get(b_slice)) |alias| aliased: {
+        if (alias.toBooleanRegister()) |b| {
+            break :aliased b;
+        } else return a.failMsg(.{ .tag = .expected_bool_register, .tok_i = b_tok_i });
+    } else std.meta.stringToEnum(register.Integral.Boolean, b_slice) orelse return a.failMsg(.{ .tag = .expected_bool_register, .tok_i = b_tok_i });
+
+    return .{
+        .register_tok_i = b_tok_i,
+        .bool = b,
+    };
+}
+
+const IntegerRegisterInfo = struct {
+    register_tok_i: u32,
+    int: register.Integral.Integer,
+};
+
+fn parseIntegerRegister(a: *Assembler) !IntegerRegisterInfo {
+    const int_tok_i = try a.expectToken(.identifier);
+    const int_slice = a.tokenSlice(int_tok_i);
+
+    const int: register.Integral.Integer = if (a.aliases.get(int_slice)) |alias| aliased: {
+        if (alias.toIntegerRegister()) |int| {
+            break :aliased int;
+        } else return a.failMsg(.{ .tag = .expected_int_register, .tok_i = int_tok_i });
+    } else std.meta.stringToEnum(register.Integral.Integer, int_slice) orelse return a.failMsg(.{ .tag = .expected_int_register, .tok_i = int_tok_i });
+
+    return .{
+        .register_tok_i = int_tok_i,
+        .int = int,
+    };
+}
+
+const MaskedIdentifier = struct {
+    identifier_tok_i: u32,
+    mask: Component.Mask,
+};
+
+fn parseMaskedIdentifier(a: *Assembler) !MaskedIdentifier {
+    const idenfier_tok_i = try a.expectToken(.identifier);
+
+    const mask: Component.Mask = if (a.tokenTag(a.tok_i) == .dot) mask: {
+        _ = a.nextToken();
+
+        const mask_tok_i = try a.expectToken(.identifier);
+        const mask_slice = a.tokenSlice(mask_tok_i);
+        const mask = Component.Mask.parse(mask_slice) catch |e| {
+            return a.failMsg(.{
+                .tag = switch (e) {
+                    error.Syntax, error.InvalidComponent => .invalid_mask,
+                    error.InvalidMask => .swizzled_mask,
+                },
+                .tok_i = mask_tok_i,
+            });
+        };
+
+        break :mask mask;
+    } else .xyzw;
+
+    return .{
+        .identifier_tok_i = idenfier_tok_i,
+        .mask = mask,
+    };
+}
+
+const SwizzledIdentifier = struct {
+    identifier_tok_i: u32,
+    swizzle: Component.Selector,
+    address: ?register.AddressComponent,
+};
+
+fn parseSwizzledAddressedIdentifier(a: *Assembler) !SwizzledIdentifier {
+    const idenfier_tok_i = try a.expectToken(.identifier);
+    var swizzle: Component.Selector = .xyzw;
+
+    const address_component = try a.parseRelativeAddressing();
+
+    while (a.tokenTag(a.tok_i) == .dot) {
+        _ = a.nextToken();
+
+        const swizzle_tok_i = try a.expectToken(.identifier);
+        const swizzle_slice = a.tokenSlice(swizzle_tok_i);
+        const new_swizzle = Component.Selector.parse(swizzle_slice) catch |e| {
+            return a.failMsg(.{
+                .tag = switch (e) {
+                    error.Syntax, error.InvalidComponent => .invalid_swizzle,
+                },
+                .tok_i = swizzle_tok_i,
+            });
+        };
+
+        swizzle = swizzle.swizzle(new_swizzle);
+    }
+
+    return .{
+        .identifier_tok_i = idenfier_tok_i,
+        .swizzle = swizzle,
+        .address = address_component,
+    };
+}
+
+pub const LabelInfo = struct {
+    tok_i: u32,
+    offset: u12,
+};
+
+fn parseLabel(a: *Assembler) !LabelInfo {
+    const label_tok_i = try a.expectToken(.identifier);
+    const label_slice = a.tokenSlice(label_tok_i);
+
+    if (a.labels.get(label_slice)) |offset| {
+        return .{
+            .tok_i = label_tok_i,
+            .offset = offset,
+        };
+    }
+
+    return a.failMsg(.{
+        .tag = .undefined_label,
+        .tok_i = label_tok_i,
+    });
+}
+
+pub const LabelRangeInfo = struct {
+    dest: u12,
+    num: u8,
+};
+
+fn parseLabelRange(a: *Assembler) !LabelRangeInfo {
+    const start_info = try a.parseLabel();
+    _ = try a.expectToken(.comma);
+    const end_info = try a.parseLabel();
+
+    const num_instructions = end_info.offset - start_info.offset;
+
+    if (num_instructions > std.math.maxInt(u8)) {
+        return a.failMsg(.{
+            .tag = .label_range_too_big,
+            .tok_i = end_info.tok_i,
+        });
+    }
+
+    return .{
+        .dest = @intCast(start_info.offset),
+        .num = @intCast(num_instructions),
+    };
+}
+
+fn parseIntBounded(a: *Assembler, comptime T: type, min_value: T, max_value: T) !T {
+    const negate: i2 = if (a.tokenTag(a.tok_i) == .minus) neg: {
+        if (@typeInfo(T).int.signedness == .unsigned) return a.fail(.expected_number);
+
+        _ = a.nextToken();
+        break :neg -1;
+    } else 1;
+
+    const number_literal_tok = try a.expectToken(.number_literal);
+    const number_literal_slice = a.tokenSlice(number_literal_tok);
+
+    const int = std.fmt.parseInt(T, number_literal_slice, 0) catch |e| return a.failMsg(.{
+        .tag = switch (e) {
+            error.InvalidCharacter => .expected_number,
+            error.Overflow => .number_too_big,
+        },
+        .tok_i = number_literal_tok,
+    });
+
+    if (int > max_value) {
+        return a.failMsg(.{
+            .tag = .number_too_big,
+            .tok_i = number_literal_tok,
+        });
+    } else if (int < min_value) {
+        return a.failMsg(.{
+            .tag = .number_too_small,
+            .tok_i = number_literal_tok,
+        });
+    }
+
+    return @intCast(int * negate);
+}
+
+fn parseInt(a: *Assembler, comptime T: type, max_value: T) !T {
+    return a.parseIntBounded(T, std.math.minInt(T), max_value);
+}
+
+fn parseFloat(a: *Assembler) !f32 {
+    const negate: f32 = if (a.tokenTag(a.tok_i) == .minus) neg: {
+        _ = a.nextToken();
+        break :neg -1.0;
+    } else 1.0;
+
+    const number_literal_tok = try a.expectToken(.number_literal);
+    const number_literal_slice = a.tokenSlice(number_literal_tok);
+
+    return negate * (std.fmt.parseFloat(f32, number_literal_slice) catch |e| switch (e) {
+        error.InvalidCharacter => return a.failMsg(.{
+            .tag = .expected_number,
+            .tok_i = number_literal_tok,
+        }),
+    });
+}
+
+fn parseEnum(a: *Assembler, comptime T: type, error_tag: Error.Tag) !T {
+    const enum_tok_i = try a.expectToken(.identifier);
+
+    return if (std.meta.stringToEnum(T, a.tokenSlice(enum_tok_i))) |enum_value|
+        enum_value
+    else
+        return a.failMsg(.{ .tag = error_tag, .tok_i = enum_tok_i });
+}
+
+fn parseBoolean(a: *Assembler) !bool {
+    return switch (a.tokenTag(a.tok_i)) {
+        .true => {
+            _ = a.nextToken();
+            return true;
+        },
+        .false => {
+            _ = a.nextToken();
+            return false;
+        },
+        else => a.failMsg(.{
+            .tag = .expected_boolean,
+            .tok_i = a.tok_i,
+        }),
+    };
+}
+
+fn fail(a: *Assembler, tag: Error.Tag) error{ OutOfMemory, ParseError } {
+    @branchHint(.cold);
+    return a.failMsg(.{ .tag = tag, .tok_i = a.tok_i });
+}
+
+fn failMsg(a: *Assembler, msg: Error) error{ OutOfMemory, ParseError } {
+    @branchHint(.cold);
+    try a.errors.append(a.gpa, msg);
+    return error.ParseError;
+}
+
+fn warn(a: *Assembler, tag: Error.Tag) !void {
+    @branchHint(.cold);
+    try a.warnMsg(.{ .tag = tag, .tok_i = a.tok_i });
+}
+
+fn warnMsg(a: *Assembler, msg: Error) !void {
+    @branchHint(.cold);
+    try a.errors.append(a.gpa, msg);
+}
+
+fn eatUntil(a: *Assembler, tag: Token.Tag) void {
+    while (true) {
+        const current_tag = a.tokenTag(a.tok_i);
+
+        switch (current_tag) {
+            .eof => break,
+            else => |non_eof| if (non_eof == tag)
+                break
+            else {
+                _ = a.nextToken();
+            },
+        }
+    }
+}
+
+fn expectToken(a: *Assembler, tag: Token.Tag) !u32 {
+    if (a.tokenTag(a.tok_i) != tag) {
+        return a.failMsg(.{
+            .tag = .expected_token,
+            .tok_i = a.tok_i,
+            .expected_tok = tag,
+        });
+    }
+
+    return a.nextToken();
+}
+
+fn nextToken(a: *Assembler) u32 {
+    defer a.tok_i += 1;
+    return a.tok_i;
+}
+
+test "assemble" {
+    var fba: [4096]u8 = undefined;
+    var fba_instance: std.heap.FixedBufferAllocator = .init(&fba);
+    const alloc = fba_instance.allocator();
+
+    var assembled: Assembled = try .assemble(alloc,
+        \\ main:
+        \\   mov o0, v1
+        \\   mov r0, v2
+        \\   end
+    );
+    defer assembled.deinit(alloc);
+
+    for (assembled.errors) |err| {
+        _ = err;
+        // if (err.tag == .expected_token) {
+        //     std.debug.print("Error: {s} (token value: '{s}', expected: {s})\n{s}", .{ @tagName(err.tag), assembled.tokenSlice(err.tok_i), @tagName(err.expected_tok), assembled.source[assembled.tokenStart(err.tok_i)..] });
+        // } else std.debug.print("Error: {s} (token value: {s})\n{s}", .{ @tagName(err.tag), assembled.tokenSlice(err.tok_i), assembled.source[assembled.tokenStart(err.tok_i)..] });
+    }
+
+    if (assembled.errors.len > 0) {
+        return error.ParseError;
+    }
+}
+
+const Assembler = @This();
+
+const std = @import("std");
+const zitrus = @import("zitrus");
+const pica = zitrus.hardware.pica;
+const shader = pica.shader;
+
+const encoding = shader.encoding;
+const Negation = encoding.OperandDescriptor.Negation;
+const Component = encoding.Component;
+
+const register = shader.register;
+
+const Encoder = shader.Encoder;
+const Token = shader.as.Token;
diff --git a/src/platform/3ds/mango/hardware/pica/shader/as/tokenizer.zig b/src/platform/3ds/mango/hardware/pica/shader/as/tokenizer.zig
new file mode 100644
index 0000000..b1eddab
--- /dev/null
+++ b/src/platform/3ds/mango/hardware/pica/shader/as/tokenizer.zig
@@ -0,0 +1,414 @@
+//! Tokenizer of the zitrus PICA200 shader assembler.
+
+// This simple tokenizer has been greatly inspired by the zig tokenizer
+
+pub const Token = struct {
+    tag: Tag,
+    loc: Loc,
+
+    pub const Loc = struct {
+        start: usize,
+        end: usize,
+    };
+
+    pub const keywords = std.StaticStringMap(Tag).initComptime(.{
+        .{ "add", .mnemonic_add },
+        .{ "dp3", .mnemonic_dp3 },
+        .{ "dp4", .mnemonic_dp4 },
+        .{ "dph", .mnemonic_dph },
+        .{ "dst", .mnemonic_dst },
+        .{ "ex2", .mnemonic_ex2 },
+        .{ "lg2", .mnemonic_lg2 },
+        .{ "litp", .mnemonic_litp },
+        .{ "mul", .mnemonic_mul },
+        .{ "sge", .mnemonic_sge },
+        .{ "slt", .mnemonic_slt },
+        .{ "flr", .mnemonic_flr },
+        .{ "max", .mnemonic_max },
+        .{ "min", .mnemonic_min },
+        .{ "rcp", .mnemonic_rcp },
+        .{ "rsq", .mnemonic_rsq },
+        .{ "mova", .mnemonic_mova },
+        .{ "mov", .mnemonic_mov },
+        .{ "break", .mnemonic_break },
+        .{ "nop", .mnemonic_nop },
+        .{ "end", .mnemonic_end },
+        .{ "breakc", .mnemonic_breakc },
+        .{ "call", .mnemonic_call },
+        .{ "callc", .mnemonic_callc },
+        .{ "callu", .mnemonic_callu },
+        .{ "ifu", .mnemonic_ifu },
+        .{ "ifc", .mnemonic_ifc },
+        .{ "loop", .mnemonic_loop },
+        .{ "emit", .mnemonic_emit },
+        .{ "setemit", .mnemonic_setemit },
+        .{ "jmpc", .mnemonic_jmpc },
+        .{ "jmpu", .mnemonic_jmpu },
+        .{ "cmp", .mnemonic_cmp },
+        .{ "mad", .mnemonic_mad },
+        .{ "true", .true },
+        .{ "false", .false },
+    });
+
+    pub fn getKeyword(str: []const u8) ?Tag {
+        return keywords.get(str);
+    }
+
+    pub const Tag = enum {
+        invalid,
+        eof,
+        identifier,
+        minus,
+        number_literal,
+        comma,
+        l_paren,
+        r_paren,
+        l_square,
+        r_square,
+        colon,
+        dot,
+        newline,
+        true,
+        false,
+
+        mnemonic_add,
+        mnemonic_dp3,
+        mnemonic_dp4,
+        mnemonic_dph,
+        mnemonic_dst,
+        mnemonic_ex2,
+        mnemonic_lg2,
+        mnemonic_litp,
+        mnemonic_mul,
+        mnemonic_sge,
+        mnemonic_slt,
+        mnemonic_flr,
+        mnemonic_max,
+        mnemonic_min,
+        mnemonic_rcp,
+        mnemonic_rsq,
+        mnemonic_mova,
+        mnemonic_mov,
+        mnemonic_break,
+        mnemonic_nop,
+        mnemonic_end,
+        mnemonic_breakc,
+        mnemonic_call,
+        mnemonic_callc,
+        mnemonic_callu,
+        mnemonic_ifu,
+        mnemonic_ifc,
+        mnemonic_loop,
+        mnemonic_emit,
+        mnemonic_setemit,
+        mnemonic_jmpc,
+        mnemonic_jmpu,
+        mnemonic_cmp,
+        mnemonic_mad,
+
+        pub fn lexeme(tag: Tag) ?[:0]const u8 {
+            return switch (tag) {
+                .comma => ",",
+                .minus => "-",
+                .l_paren => "(",
+                .r_paren => ")",
+                .l_square => "[",
+                .r_square => "]",
+                .colon => ":",
+                .dot => ".",
+                .true => "true",
+                .false => "false",
+
+                else => null,
+            };
+        }
+    };
+};
+
+pub const Tokenizer = struct {
+    buffer: [:0]const u8,
+    index: usize,
+
+    pub fn dump(tok: Tokenizer, tk: Token) void {
+        std.debug.print("{s}: '{s}'\n", .{ @tagName(tk.tag), tok.buffer[tk.loc.start..tk.loc.end] });
+    }
+
+    pub fn init(buffer: [:0]const u8) Tokenizer {
+        return .{
+            .buffer = buffer,
+            // Skip UTF-8 BOM if present
+            .index = if (std.mem.startsWith(u8, buffer, "\xEF\xBB\xBF")) 3 else 0,
+        };
+    }
+
+    const State = enum {
+        start,
+        invalid,
+        expect_newline,
+        line_comment,
+        identifier,
+        int,
+        int_period,
+        int_exponent,
+        float,
+        float_exponent,
+    };
+
+    pub fn next(tok: *Tokenizer) Token {
+        var result: Token = .{ .tag = undefined, .loc = .{
+            .start = tok.index,
+            .end = undefined,
+        } };
+
+        state: switch (State.start) {
+            .start => switch (tok.buffer[tok.index]) {
+                0 => {
+                    if (tok.index == tok.buffer.len) {
+                        return .{
+                            .tag = .eof,
+                            .loc = .{ .start = tok.index, .end = tok.index },
+                        };
+                    } else {
+                        continue :state .invalid;
+                    }
+                },
+                'A'...'Z', 'a'...'z', '_' => {
+                    result.tag = .identifier;
+                    continue :state .identifier;
+                },
+                '0'...'9' => {
+                    result.tag = .number_literal;
+                    tok.index += 1;
+                    continue :state .int;
+                },
+                '\n' => continue :state .expect_newline,
+                '\r' => {
+                    tok.index += 1;
+                    continue :state .expect_newline;
+                },
+                ' ', '\t' => {
+                    tok.index += 1;
+                    result.loc.start = tok.index;
+                    continue :state .start;
+                },
+                ':' => {
+                    tok.index += 1;
+                    result.tag = .colon;
+                },
+                '-' => {
+                    tok.index += 1;
+                    result.tag = .minus;
+                },
+                ',' => {
+                    tok.index += 1;
+                    result.tag = .comma;
+                },
+                '(' => {
+                    tok.index += 1;
+                    result.tag = .l_paren;
+                },
+                ')' => {
+                    tok.index += 1;
+                    result.tag = .r_paren;
+                },
+                '[' => {
+                    tok.index += 1;
+                    result.tag = .l_square;
+                },
+                ']' => {
+                    tok.index += 1;
+                    result.tag = .r_square;
+                },
+                ';' => {
+                    tok.index += 1;
+                    continue :state .line_comment;
+                },
+                '.' => {
+                    tok.index += 1;
+                    result.tag = .dot;
+                },
+                else => continue :state .invalid,
+            },
+            .invalid => {
+                tok.index += 1;
+
+                switch (tok.buffer[tok.index]) {
+                    0 => if (tok.index == tok.buffer.len) {
+                        result.tag = .invalid;
+                    } else {
+                        continue :state .invalid;
+                    },
+                    '\n' => result.tag = .invalid,
+                    else => continue :state .invalid,
+                }
+            },
+            .expect_newline => switch (tok.buffer[tok.index]) {
+                0 => if (tok.index == tok.buffer.len) {
+                    result.tag = .invalid;
+                } else {
+                    continue :state .invalid;
+                },
+                '\n' => {
+                    result.loc.start = tok.index;
+                    tok.index += 1;
+                    result.tag = .newline;
+                },
+                else => continue :state .invalid,
+            },
+            .line_comment => {
+                tok.index += 1;
+                switch (tok.buffer[tok.index]) {
+                    0 => if (tok.index != tok.buffer.len) {
+                        continue :state .invalid;
+                    } else return .{ .tag = .eof, .loc = .{ .start = tok.index, .end = tok.index } },
+                    '\n' => continue :state .expect_newline,
+                    '\r' => {
+                        tok.index += 1;
+                        continue :state .expect_newline;
+                    },
+                    else => continue :state .line_comment,
+                }
+            },
+            .identifier => {
+                tok.index += 1;
+
+                switch (tok.buffer[tok.index]) {
+                    'A'...'Z', 'a'...'z', '_', '0'...'9' => continue :state .identifier,
+                    else => {
+                        if (Token.getKeyword(tok.buffer[result.loc.start..tok.index])) |tag| {
+                            result.tag = tag;
+                        }
+                    },
+                }
+            },
+            // ensure we tokenize integers/floats the same way the tokenizer does to reuse std.zig.parseNumberLiteral
+            .int => switch (tok.buffer[tok.index]) {
+                '.' => continue :state .int_period,
+                '_', 'a'...'d', 'f'...'o', 'q'...'z', 'A'...'D', 'F'...'O', 'Q'...'Z', '0'...'9' => {
+                    tok.index += 1;
+                    continue :state .int;
+                },
+                'e', 'E', 'p', 'P' => {
+                    continue :state .int_exponent;
+                },
+                else => {},
+            },
+            .int_exponent => {
+                tok.index += 1;
+                switch (tok.buffer[tok.index]) {
+                    '-', '+' => {
+                        tok.index += 1;
+                        continue :state .float;
+                    },
+                    else => continue :state .int,
+                }
+            },
+            .int_period => {
+                tok.index += 1;
+                switch (tok.buffer[tok.index]) {
+                    '_', 'a'...'d', 'f'...'o', 'q'...'z', 'A'...'D', 'F'...'O', 'Q'...'Z', '0'...'9' => {
+                        tok.index += 1;
+                        continue :state .float;
+                    },
+                    'e', 'E', 'p', 'P' => {
+                        continue :state .float_exponent;
+                    },
+                    else => tok.index -= 1,
+                }
+            },
+            .float => switch (tok.buffer[tok.index]) {
+                '_', 'a'...'d', 'f'...'o', 'q'...'z', 'A'...'D', 'F'...'O', 'Q'...'Z', '0'...'9' => {
+                    tok.index += 1;
+                    continue :state .float;
+                },
+                'e', 'E', 'p', 'P' => {
+                    continue :state .float_exponent;
+                },
+                else => {},
+            },
+            .float_exponent => {
+                tok.index += 1;
+                switch (tok.buffer[tok.index]) {
+                    '-', '+' => {
+                        tok.index += 1;
+                        continue :state .float;
+                    },
+                    else => continue :state .float,
+                }
+            },
+        }
+
+        result.loc.end = tok.index;
+        return result;
+    }
+};
+
+const testing = std.testing;
+
+test "tokenize label" {
+    try testTokenize("a_label:", &.{ .identifier, .colon });
+}
+
+test "tokenize directive" {
+    try testTokenize(".directive_with an_identifier_parameter 0b10", &.{ .dot, .identifier, .identifier, .number_literal });
+}
+
+test "tokenize 'mov r0, v0'" {
+    try testTokenize("mov r0, v0", &.{ .mnemonic_mov, .identifier, .comma, .identifier });
+}
+
+test "tokenize multiple instructions" {
+    try testTokenize(
+        \\ mov r0, v0
+        \\ add r0, v1
+    , &.{
+        // zig fmt: off
+        .mnemonic_mov, .identifier, .comma, .identifier, .newline,
+        .mnemonic_add, .identifier, .comma, .identifier,
+        // zig fmt: on
+    });
+}
+
+test "tokenize multiple instructions with comments in-between" {
+    try testTokenize(
+        \\ mov r0, v0 ; this is a comment
+        \\ ; this is a comment in-between
+        \\ add r0, v1 ; this is another comment
+    , &.{
+        // zig fmt: off
+        .mnemonic_mov, .identifier, .comma, .identifier, .newline,
+        .newline,
+        .mnemonic_add, .identifier, .comma, .identifier,
+        // zig fmt: on
+    });
+}
+
+test "tokenize number literals" {
+    try testTokenize("0", &.{.number_literal});
+    try testTokenize("1", &.{.number_literal});
+    try testTokenize("3.1415926535", &.{.number_literal});
+    try testTokenize("0x200", &.{.number_literal});
+    try testTokenize("0b11", &.{.number_literal});
+    try testTokenize("0.1", &.{.number_literal});
+    try testTokenize("2e+20", &.{.number_literal});
+    try testTokenize("2e-1", &.{.number_literal});
+}
+
+// TODO: fuzz, look how it works and how the zig tokenizer is being fuzzed
+
+fn testTokenize(source: [:0]const u8, expected_token_tags: []const Token.Tag) !void {
+    var tokenizer = Tokenizer.init(source);
+
+    for (expected_token_tags) |expected_tag| {
+        const tk = tokenizer.next();
+
+        try testing.expect(expected_tag == tk.tag);
+    }
+
+    const last = tokenizer.next();
+    try testing.expect(Token.Tag.eof == last.tag);
+    try testing.expect(source.len == last.loc.start);
+    try testing.expect(source.len == last.loc.end);
+}
+
+const std = @import("std");
diff --git a/src/platform/3ds/mango/hardware/pica/shader/encoding.zig b/src/platform/3ds/mango/hardware/pica/shader/encoding.zig
new file mode 100644
index 0000000..d6a6733
--- /dev/null
+++ b/src/platform/3ds/mango/hardware/pica/shader/encoding.zig
@@ -0,0 +1,915 @@
+//! PICA200 instruction encodings
+
+pub const Component = enum(u2) {
+    const span = "xyzw";
+
+    x,
+    y,
+    z,
+    w,
+
+    pub const Mask = packed struct(u4) {
+        pub const x: Mask = .{ .enable_x = true };
+        pub const y: Mask = .{ .enable_y = true };
+        pub const z: Mask = .{ .enable_z = true };
+        pub const w: Mask = .{ .enable_w = true };
+        pub const xy: Mask = .{ .enable_x = true, .enable_y = true };
+        pub const xz: Mask = .{ .enable_x = true, .enable_z = true };
+        pub const xw: Mask = .{ .enable_x = true, .enable_w = true };
+        pub const yz: Mask = .{ .enable_y = true, .enable_z = true };
+        pub const yw: Mask = .{ .enable_y = true, .enable_w = true };
+        pub const zw: Mask = .{ .enable_z = true, .enable_w = true };
+        pub const xyz: Mask = .{ .enable_x = true, .enable_y = true, .enable_z = true };
+        pub const xzw: Mask = .{ .enable_x = true, .enable_z = true, .enable_w = true };
+        pub const yzw: Mask = .{ .enable_y = true, .enable_z = true, .enable_w = true };
+        pub const xyzw: Mask = .{ .enable_x = true, .enable_y = true, .enable_z = true, .enable_w = true };
+
+        enable_w: bool = false,
+        enable_z: bool = false,
+        enable_y: bool = false,
+        enable_x: bool = false,
+
+        pub fn copyWith(mask: Mask, i: u2, value: bool) Mask {
+            const bit_mask = @as(u4, 0b1000) >> i;
+            const bit = (@as(u4, @intFromBool(value)) << 3) >> i;
+
+            return @bitCast((@as(u4, @bitCast(mask)) & ~bit_mask) | bit);
+        }
+
+        pub fn size(mask: Mask) usize {
+            return (((@as(usize, @intFromBool(mask.enable_x)) + @intFromBool(mask.enable_y)) + @intFromBool(mask.enable_z)) + @intFromBool(mask.enable_w));
+        }
+
+        pub const ParseError = error{
+            Syntax,
+            InvalidMask,
+            InvalidComponent,
+        };
+
+        pub fn format(mask: Mask, writer: *std.Io.Writer) std.Io.Writer.Error!void {
+            const enabled: []const bool = &.{ mask.enable_x, mask.enable_y, mask.enable_z, mask.enable_w };
+
+            for (enabled, span) |e, c| if (e) {
+                try writer.writeByte(c);
+            };
+        }
+
+        pub fn parse(expression: []const u8) ParseError!Mask {
+            if (expression.len == 0 or expression.len > 4) {
+                return error.Syntax;
+            }
+
+            var last: ?usize = null;
+            var mask: u4 = 0;
+            for (expression) |c| {
+                const component = std.mem.indexOf(u8, span, &.{c}) orelse return error.InvalidComponent;
+
+                if (last) |l| {
+                    if (component <= l) {
+                        return error.InvalidMask;
+                    }
+                }
+
+                mask |= @as(u4, 1) << @intCast(span.len - 1 - component);
+                last = component;
+            }
+
+            return @bitCast(mask);
+        }
+
+        test parse {
+            try testing.expect(Mask.xyzw == try parse("xyzw"));
+            try testing.expect(Mask.w == try parse("w"));
+            try testing.expect(Mask.yw == try parse("yw"));
+            try testing.expect(Mask.yzw == try parse("yzw"));
+            try testing.expect(error.InvalidMask == parse("zyx"));
+            try testing.expect(error.InvalidMask == parse("wy"));
+            try testing.expect(error.InvalidMask == parse("xxxx"));
+            try testing.expect(error.InvalidMask == parse("wyxz"));
+        }
+    };
+
+    pub const Selector = packed struct(u8) {
+        pub const x: Selector = .xxxx;
+        pub const y: Selector = .yyyy;
+        pub const z: Selector = .zzzz;
+        pub const w: Selector = .wwww;
+        pub const xx: Selector = .xxxx;
+        pub const xy: Selector = .xyyy;
+        pub const xz: Selector = .xzzz;
+        pub const xw: Selector = .xwww;
+        pub const yx: Selector = .yxxx;
+        pub const yy: Selector = .yyyy;
+        pub const yz: Selector = .yzzz;
+        pub const yw: Selector = .ywww;
+        pub const zx: Selector = .zxxx;
+        pub const zy: Selector = .zyyy;
+        pub const zz: Selector = .zzzz;
+        pub const zw: Selector = .zwww;
+        pub const wx: Selector = .wxxx;
+        pub const wy: Selector = .wyyy;
+        pub const wz: Selector = .wzzz;
+        pub const ww: Selector = .wwww;
+        pub const xxx: Selector = .xxxx;
+        pub const xxy: Selector = .xxyy;
+        pub const xxz: Selector = .xxzz;
+        pub const xxw: Selector = .xxww;
+        pub const xyx: Selector = .xyxx;
+        pub const xyy: Selector = .xyyy;
+        pub const xyz: Selector = .xyzz;
+        pub const xyw: Selector = .xyww;
+        pub const xzx: Selector = .xzxx;
+        pub const xzy: Selector = .xzyy;
+        pub const xzz: Selector = .xzzz;
+        pub const xzw: Selector = .xzww;
+        pub const xwx: Selector = .xwxx;
+        pub const xwy: Selector = .xwyy;
+        pub const xwz: Selector = .xwzz;
+        pub const xww: Selector = .xwww;
+        pub const yxx: Selector = .yxxx;
+        pub const yxy: Selector = .yxyy;
+        pub const yxz: Selector = .yxzz;
+        pub const yxw: Selector = .yxww;
+        pub const yyx: Selector = .yyxx;
+        pub const yyy: Selector = .yyyy;
+        pub const yyz: Selector = .yyzz;
+        pub const yyw: Selector = .yyww;
+        pub const yzx: Selector = .yzxx;
+        pub const yzy: Selector = .yzyy;
+        pub const yzz: Selector = .yzzz;
+        pub const yzw: Selector = .yzww;
+        pub const ywx: Selector = .ywxx;
+        pub const ywy: Selector = .ywyy;
+        pub const ywz: Selector = .ywzz;
+        pub const yww: Selector = .ywww;
+        pub const zxx: Selector = .zxxx;
+        pub const zxy: Selector = .zxyy;
+        pub const zxz: Selector = .zxzz;
+        pub const zxw: Selector = .zxww;
+        pub const zyx: Selector = .zyxx;
+        pub const zyy: Selector = .zyyy;
+        pub const zyz: Selector = .zyzz;
+        pub const zyw: Selector = .zyww;
+        pub const zzx: Selector = .zzxx;
+        pub const zzy: Selector = .zzyy;
+        pub const zzz: Selector = .zzzz;
+        pub const zzw: Selector = .zzww;
+        pub const zwx: Selector = .zwxx;
+        pub const zwy: Selector = .zwyy;
+        pub const zwz: Selector = .zwzz;
+        pub const zww: Selector = .zwww;
+        pub const wxx: Selector = .wxxx;
+        pub const wxy: Selector = .wxyy;
+        pub const wxz: Selector = .wxzz;
+        pub const wxw: Selector = .wxww;
+        pub const wyx: Selector = .wyxx;
+        pub const wyy: Selector = .wyyy;
+        pub const wyz: Selector = .wyzz;
+        pub const wyw: Selector = .wyww;
+        pub const wzx: Selector = .wzxx;
+        pub const wzy: Selector = .wzyy;
+        pub const wzz: Selector = .wzzz;
+        pub const wzw: Selector = .wzww;
+        pub const wwx: Selector = .wwxx;
+        pub const wwy: Selector = .wwyy;
+        pub const wwz: Selector = .wwzz;
+        pub const www: Selector = .wwww;
+        pub const xxxx: Selector = .{ .@"0" = .x, .@"1" = .x, .@"2" = .x, .@"3" = .x };
+        pub const xxxy: Selector = .{ .@"0" = .x, .@"1" = .x, .@"2" = .x, .@"3" = .y };
+        pub const xxxz: Selector = .{ .@"0" = .x, .@"1" = .x, .@"2" = .x, .@"3" = .z };
+        pub const xxxw: Selector = .{ .@"0" = .x, .@"1" = .x, .@"2" = .x, .@"3" = .w };
+        pub const xxyx: Selector = .{ .@"0" = .x, .@"1" = .x, .@"2" = .y, .@"3" = .x };
+        pub const xxyy: Selector = .{ .@"0" = .x, .@"1" = .x, .@"2" = .y, .@"3" = .y };
+        pub const xxyz: Selector = .{ .@"0" = .x, .@"1" = .x, .@"2" = .y, .@"3" = .z };
+        pub const xxyw: Selector = .{ .@"0" = .x, .@"1" = .x, .@"2" = .y, .@"3" = .w };
+        pub const xxzx: Selector = .{ .@"0" = .x, .@"1" = .x, .@"2" = .z, .@"3" = .x };
+        pub const xxzy: Selector = .{ .@"0" = .x, .@"1" = .x, .@"2" = .z, .@"3" = .y };
+        pub const xxzz: Selector = .{ .@"0" = .x, .@"1" = .x, .@"2" = .z, .@"3" = .z };
+        pub const xxzw: Selector = .{ .@"0" = .x, .@"1" = .x, .@"2" = .z, .@"3" = .w };
+        pub const xxwx: Selector = .{ .@"0" = .x, .@"1" = .x, .@"2" = .w, .@"3" = .x };
+        pub const xxwy: Selector = .{ .@"0" = .x, .@"1" = .x, .@"2" = .w, .@"3" = .y };
+        pub const xxwz: Selector = .{ .@"0" = .x, .@"1" = .x, .@"2" = .w, .@"3" = .z };
+        pub const xxww: Selector = .{ .@"0" = .x, .@"1" = .x, .@"2" = .w, .@"3" = .w };
+        pub const xyxx: Selector = .{ .@"0" = .x, .@"1" = .y, .@"2" = .x, .@"3" = .x };
+        pub const xyxy: Selector = .{ .@"0" = .x, .@"1" = .y, .@"2" = .x, .@"3" = .y };
+        pub const xyxz: Selector = .{ .@"0" = .x, .@"1" = .y, .@"2" = .x, .@"3" = .z };
+        pub const xyxw: Selector = .{ .@"0" = .x, .@"1" = .y, .@"2" = .x, .@"3" = .w };
+        pub const xyyx: Selector = .{ .@"0" = .x, .@"1" = .y, .@"2" = .y, .@"3" = .x };
+        pub const xyyy: Selector = .{ .@"0" = .x, .@"1" = .y, .@"2" = .y, .@"3" = .y };
+        pub const xyyz: Selector = .{ .@"0" = .x, .@"1" = .y, .@"2" = .y, .@"3" = .z };
+        pub const xyyw: Selector = .{ .@"0" = .x, .@"1" = .y, .@"2" = .y, .@"3" = .w };
+        pub const xyzx: Selector = .{ .@"0" = .x, .@"1" = .y, .@"2" = .z, .@"3" = .x };
+        pub const xyzy: Selector = .{ .@"0" = .x, .@"1" = .y, .@"2" = .z, .@"3" = .y };
+        pub const xyzz: Selector = .{ .@"0" = .x, .@"1" = .y, .@"2" = .z, .@"3" = .z };
+        pub const xyzw: Selector = .{ .@"0" = .x, .@"1" = .y, .@"2" = .z, .@"3" = .w };
+        pub const xywx: Selector = .{ .@"0" = .x, .@"1" = .y, .@"2" = .w, .@"3" = .x };
+        pub const xywy: Selector = .{ .@"0" = .x, .@"1" = .y, .@"2" = .w, .@"3" = .y };
+        pub const xywz: Selector = .{ .@"0" = .x, .@"1" = .y, .@"2" = .w, .@"3" = .z };
+        pub const xyww: Selector = .{ .@"0" = .x, .@"1" = .y, .@"2" = .w, .@"3" = .w };
+        pub const xzxx: Selector = .{ .@"0" = .x, .@"1" = .z, .@"2" = .x, .@"3" = .x };
+        pub const xzxy: Selector = .{ .@"0" = .x, .@"1" = .z, .@"2" = .x, .@"3" = .y };
+        pub const xzxz: Selector = .{ .@"0" = .x, .@"1" = .z, .@"2" = .x, .@"3" = .z };
+        pub const xzxw: Selector = .{ .@"0" = .x, .@"1" = .z, .@"2" = .x, .@"3" = .w };
+        pub const xzyx: Selector = .{ .@"0" = .x, .@"1" = .z, .@"2" = .y, .@"3" = .x };
+        pub const xzyy: Selector = .{ .@"0" = .x, .@"1" = .z, .@"2" = .y, .@"3" = .y };
+        pub const xzyz: Selector = .{ .@"0" = .x, .@"1" = .z, .@"2" = .y, .@"3" = .z };
+        pub const xzyw: Selector = .{ .@"0" = .x, .@"1" = .z, .@"2" = .y, .@"3" = .w };
+        pub const xzzx: Selector = .{ .@"0" = .x, .@"1" = .z, .@"2" = .z, .@"3" = .x };
+        pub const xzzy: Selector = .{ .@"0" = .x, .@"1" = .z, .@"2" = .z, .@"3" = .y };
+        pub const xzzz: Selector = .{ .@"0" = .x, .@"1" = .z, .@"2" = .z, .@"3" = .z };
+        pub const xzzw: Selector = .{ .@"0" = .x, .@"1" = .z, .@"2" = .z, .@"3" = .w };
+        pub const xzwx: Selector = .{ .@"0" = .x, .@"1" = .z, .@"2" = .w, .@"3" = .x };
+        pub const xzwy: Selector = .{ .@"0" = .x, .@"1" = .z, .@"2" = .w, .@"3" = .y };
+        pub const xzwz: Selector = .{ .@"0" = .x, .@"1" = .z, .@"2" = .w, .@"3" = .z };
+        pub const xzww: Selector = .{ .@"0" = .x, .@"1" = .z, .@"2" = .w, .@"3" = .w };
+        pub const xwxx: Selector = .{ .@"0" = .x, .@"1" = .w, .@"2" = .x, .@"3" = .x };
+        pub const xwxy: Selector = .{ .@"0" = .x, .@"1" = .w, .@"2" = .x, .@"3" = .y };
+        pub const xwxz: Selector = .{ .@"0" = .x, .@"1" = .w, .@"2" = .x, .@"3" = .z };
+        pub const xwxw: Selector = .{ .@"0" = .x, .@"1" = .w, .@"2" = .x, .@"3" = .w };
+        pub const xwyx: Selector = .{ .@"0" = .x, .@"1" = .w, .@"2" = .y, .@"3" = .x };
+        pub const xwyy: Selector = .{ .@"0" = .x, .@"1" = .w, .@"2" = .y, .@"3" = .y };
+        pub const xwyz: Selector = .{ .@"0" = .x, .@"1" = .w, .@"2" = .y, .@"3" = .z };
+        pub const xwyw: Selector = .{ .@"0" = .x, .@"1" = .w, .@"2" = .y, .@"3" = .w };
+        pub const xwzx: Selector = .{ .@"0" = .x, .@"1" = .w, .@"2" = .z, .@"3" = .x };
+        pub const xwzy: Selector = .{ .@"0" = .x, .@"1" = .w, .@"2" = .z, .@"3" = .y };
+        pub const xwzz: Selector = .{ .@"0" = .x, .@"1" = .w, .@"2" = .z, .@"3" = .z };
+        pub const xwzw: Selector = .{ .@"0" = .x, .@"1" = .w, .@"2" = .z, .@"3" = .w };
+        pub const xwwx: Selector = .{ .@"0" = .x, .@"1" = .w, .@"2" = .w, .@"3" = .x };
+        pub const xwwy: Selector = .{ .@"0" = .x, .@"1" = .w, .@"2" = .w, .@"3" = .y };
+        pub const xwwz: Selector = .{ .@"0" = .x, .@"1" = .w, .@"2" = .w, .@"3" = .z };
+        pub const xwww: Selector = .{ .@"0" = .x, .@"1" = .w, .@"2" = .w, .@"3" = .w };
+        pub const yxxx: Selector = .{ .@"0" = .y, .@"1" = .x, .@"2" = .x, .@"3" = .x };
+        pub const yxxy: Selector = .{ .@"0" = .y, .@"1" = .x, .@"2" = .x, .@"3" = .y };
+        pub const yxxz: Selector = .{ .@"0" = .y, .@"1" = .x, .@"2" = .x, .@"3" = .z };
+        pub const yxxw: Selector = .{ .@"0" = .y, .@"1" = .x, .@"2" = .x, .@"3" = .w };
+        pub const yxyx: Selector = .{ .@"0" = .y, .@"1" = .x, .@"2" = .y, .@"3" = .x };
+        pub const yxyy: Selector = .{ .@"0" = .y, .@"1" = .x, .@"2" = .y, .@"3" = .y };
+        pub const yxyz: Selector = .{ .@"0" = .y, .@"1" = .x, .@"2" = .y, .@"3" = .z };
+        pub const yxyw: Selector = .{ .@"0" = .y, .@"1" = .x, .@"2" = .y, .@"3" = .w };
+        pub const yxzx: Selector = .{ .@"0" = .y, .@"1" = .x, .@"2" = .z, .@"3" = .x };
+        pub const yxzy: Selector = .{ .@"0" = .y, .@"1" = .x, .@"2" = .z, .@"3" = .y };
+        pub const yxzz: Selector = .{ .@"0" = .y, .@"1" = .x, .@"2" = .z, .@"3" = .z };
+        pub const yxzw: Selector = .{ .@"0" = .y, .@"1" = .x, .@"2" = .z, .@"3" = .w };
+        pub const yxwx: Selector = .{ .@"0" = .y, .@"1" = .x, .@"2" = .w, .@"3" = .x };
+        pub const yxwy: Selector = .{ .@"0" = .y, .@"1" = .x, .@"2" = .w, .@"3" = .y };
+        pub const yxwz: Selector = .{ .@"0" = .y, .@"1" = .x, .@"2" = .w, .@"3" = .z };
+        pub const yxww: Selector = .{ .@"0" = .y, .@"1" = .x, .@"2" = .w, .@"3" = .w };
+        pub const yyxx: Selector = .{ .@"0" = .y, .@"1" = .y, .@"2" = .x, .@"3" = .x };
+        pub const yyxy: Selector = .{ .@"0" = .y, .@"1" = .y, .@"2" = .x, .@"3" = .y };
+        pub const yyxz: Selector = .{ .@"0" = .y, .@"1" = .y, .@"2" = .x, .@"3" = .z };
+        pub const yyxw: Selector = .{ .@"0" = .y, .@"1" = .y, .@"2" = .x, .@"3" = .w };
+        pub const yyyx: Selector = .{ .@"0" = .y, .@"1" = .y, .@"2" = .y, .@"3" = .x };
+        pub const yyyy: Selector = .{ .@"0" = .y, .@"1" = .y, .@"2" = .y, .@"3" = .y };
+        pub const yyyz: Selector = .{ .@"0" = .y, .@"1" = .y, .@"2" = .y, .@"3" = .z };
+        pub const yyyw: Selector = .{ .@"0" = .y, .@"1" = .y, .@"2" = .y, .@"3" = .w };
+        pub const yyzx: Selector = .{ .@"0" = .y, .@"1" = .y, .@"2" = .z, .@"3" = .x };
+        pub const yyzy: Selector = .{ .@"0" = .y, .@"1" = .y, .@"2" = .z, .@"3" = .y };
+        pub const yyzz: Selector = .{ .@"0" = .y, .@"1" = .y, .@"2" = .z, .@"3" = .z };
+        pub const yyzw: Selector = .{ .@"0" = .y, .@"1" = .y, .@"2" = .z, .@"3" = .w };
+        pub const yywx: Selector = .{ .@"0" = .y, .@"1" = .y, .@"2" = .w, .@"3" = .x };
+        pub const yywy: Selector = .{ .@"0" = .y, .@"1" = .y, .@"2" = .w, .@"3" = .y };
+        pub const yywz: Selector = .{ .@"0" = .y, .@"1" = .y, .@"2" = .w, .@"3" = .z };
+        pub const yyww: Selector = .{ .@"0" = .y, .@"1" = .y, .@"2" = .w, .@"3" = .w };
+        pub const yzxx: Selector = .{ .@"0" = .y, .@"1" = .z, .@"2" = .x, .@"3" = .x };
+        pub const yzxy: Selector = .{ .@"0" = .y, .@"1" = .z, .@"2" = .x, .@"3" = .y };
+        pub const yzxz: Selector = .{ .@"0" = .y, .@"1" = .z, .@"2" = .x, .@"3" = .z };
+        pub const yzxw: Selector = .{ .@"0" = .y, .@"1" = .z, .@"2" = .x, .@"3" = .w };
+        pub const yzyx: Selector = .{ .@"0" = .y, .@"1" = .z, .@"2" = .y, .@"3" = .x };
+        pub const yzyy: Selector = .{ .@"0" = .y, .@"1" = .z, .@"2" = .y, .@"3" = .y };
+        pub const yzyz: Selector = .{ .@"0" = .y, .@"1" = .z, .@"2" = .y, .@"3" = .z };
+        pub const yzyw: Selector = .{ .@"0" = .y, .@"1" = .z, .@"2" = .y, .@"3" = .w };
+        pub const yzzx: Selector = .{ .@"0" = .y, .@"1" = .z, .@"2" = .z, .@"3" = .x };
+        pub const yzzy: Selector = .{ .@"0" = .y, .@"1" = .z, .@"2" = .z, .@"3" = .y };
+        pub const yzzz: Selector = .{ .@"0" = .y, .@"1" = .z, .@"2" = .z, .@"3" = .z };
+        pub const yzzw: Selector = .{ .@"0" = .y, .@"1" = .z, .@"2" = .z, .@"3" = .w };
+        pub const yzwx: Selector = .{ .@"0" = .y, .@"1" = .z, .@"2" = .w, .@"3" = .x };
+        pub const yzwy: Selector = .{ .@"0" = .y, .@"1" = .z, .@"2" = .w, .@"3" = .y };
+        pub const yzwz: Selector = .{ .@"0" = .y, .@"1" = .z, .@"2" = .w, .@"3" = .z };
+        pub const yzww: Selector = .{ .@"0" = .y, .@"1" = .z, .@"2" = .w, .@"3" = .w };
+        pub const ywxx: Selector = .{ .@"0" = .y, .@"1" = .w, .@"2" = .x, .@"3" = .x };
+        pub const ywxy: Selector = .{ .@"0" = .y, .@"1" = .w, .@"2" = .x, .@"3" = .y };
+        pub const ywxz: Selector = .{ .@"0" = .y, .@"1" = .w, .@"2" = .x, .@"3" = .z };
+        pub const ywxw: Selector = .{ .@"0" = .y, .@"1" = .w, .@"2" = .x, .@"3" = .w };
+        pub const ywyx: Selector = .{ .@"0" = .y, .@"1" = .w, .@"2" = .y, .@"3" = .x };
+        pub const ywyy: Selector = .{ .@"0" = .y, .@"1" = .w, .@"2" = .y, .@"3" = .y };
+        pub const ywyz: Selector = .{ .@"0" = .y, .@"1" = .w, .@"2" = .y, .@"3" = .z };
+        pub const ywyw: Selector = .{ .@"0" = .y, .@"1" = .w, .@"2" = .y, .@"3" = .w };
+        pub const ywzx: Selector = .{ .@"0" = .y, .@"1" = .w, .@"2" = .z, .@"3" = .x };
+        pub const ywzy: Selector = .{ .@"0" = .y, .@"1" = .w, .@"2" = .z, .@"3" = .y };
+        pub const ywzz: Selector = .{ .@"0" = .y, .@"1" = .w, .@"2" = .z, .@"3" = .z };
+        pub const ywzw: Selector = .{ .@"0" = .y, .@"1" = .w, .@"2" = .z, .@"3" = .w };
+        pub const ywwx: Selector = .{ .@"0" = .y, .@"1" = .w, .@"2" = .w, .@"3" = .x };
+        pub const ywwy: Selector = .{ .@"0" = .y, .@"1" = .w, .@"2" = .w, .@"3" = .y };
+        pub const ywwz: Selector = .{ .@"0" = .y, .@"1" = .w, .@"2" = .w, .@"3" = .z };
+        pub const ywww: Selector = .{ .@"0" = .y, .@"1" = .w, .@"2" = .w, .@"3" = .w };
+        pub const zxxx: Selector = .{ .@"0" = .z, .@"1" = .x, .@"2" = .x, .@"3" = .x };
+        pub const zxxy: Selector = .{ .@"0" = .z, .@"1" = .x, .@"2" = .x, .@"3" = .y };
+        pub const zxxz: Selector = .{ .@"0" = .z, .@"1" = .x, .@"2" = .x, .@"3" = .z };
+        pub const zxxw: Selector = .{ .@"0" = .z, .@"1" = .x, .@"2" = .x, .@"3" = .w };
+        pub const zxyx: Selector = .{ .@"0" = .z, .@"1" = .x, .@"2" = .y, .@"3" = .x };
+        pub const zxyy: Selector = .{ .@"0" = .z, .@"1" = .x, .@"2" = .y, .@"3" = .y };
+        pub const zxyz: Selector = .{ .@"0" = .z, .@"1" = .x, .@"2" = .y, .@"3" = .z };
+        pub const zxyw: Selector = .{ .@"0" = .z, .@"1" = .x, .@"2" = .y, .@"3" = .w };
+        pub const zxzx: Selector = .{ .@"0" = .z, .@"1" = .x, .@"2" = .z, .@"3" = .x };
+        pub const zxzy: Selector = .{ .@"0" = .z, .@"1" = .x, .@"2" = .z, .@"3" = .y };
+        pub const zxzz: Selector = .{ .@"0" = .z, .@"1" = .x, .@"2" = .z, .@"3" = .z };
+        pub const zxzw: Selector = .{ .@"0" = .z, .@"1" = .x, .@"2" = .z, .@"3" = .w };
+        pub const zxwx: Selector = .{ .@"0" = .z, .@"1" = .x, .@"2" = .w, .@"3" = .x };
+        pub const zxwy: Selector = .{ .@"0" = .z, .@"1" = .x, .@"2" = .w, .@"3" = .y };
+        pub const zxwz: Selector = .{ .@"0" = .z, .@"1" = .x, .@"2" = .w, .@"3" = .z };
+        pub const zxww: Selector = .{ .@"0" = .z, .@"1" = .x, .@"2" = .w, .@"3" = .w };
+        pub const zyxx: Selector = .{ .@"0" = .z, .@"1" = .y, .@"2" = .x, .@"3" = .x };
+        pub const zyxy: Selector = .{ .@"0" = .z, .@"1" = .y, .@"2" = .x, .@"3" = .y };
+        pub const zyxz: Selector = .{ .@"0" = .z, .@"1" = .y, .@"2" = .x, .@"3" = .z };
+        pub const zyxw: Selector = .{ .@"0" = .z, .@"1" = .y, .@"2" = .x, .@"3" = .w };
+        pub const zyyx: Selector = .{ .@"0" = .z, .@"1" = .y, .@"2" = .y, .@"3" = .x };
+        pub const zyyy: Selector = .{ .@"0" = .z, .@"1" = .y, .@"2" = .y, .@"3" = .y };
+        pub const zyyz: Selector = .{ .@"0" = .z, .@"1" = .y, .@"2" = .y, .@"3" = .z };
+        pub const zyyw: Selector = .{ .@"0" = .z, .@"1" = .y, .@"2" = .y, .@"3" = .w };
+        pub const zyzx: Selector = .{ .@"0" = .z, .@"1" = .y, .@"2" = .z, .@"3" = .x };
+        pub const zyzy: Selector = .{ .@"0" = .z, .@"1" = .y, .@"2" = .z, .@"3" = .y };
+        pub const zyzz: Selector = .{ .@"0" = .z, .@"1" = .y, .@"2" = .z, .@"3" = .z };
+        pub const zyzw: Selector = .{ .@"0" = .z, .@"1" = .y, .@"2" = .z, .@"3" = .w };
+        pub const zywx: Selector = .{ .@"0" = .z, .@"1" = .y, .@"2" = .w, .@"3" = .x };
+        pub const zywy: Selector = .{ .@"0" = .z, .@"1" = .y, .@"2" = .w, .@"3" = .y };
+        pub const zywz: Selector = .{ .@"0" = .z, .@"1" = .y, .@"2" = .w, .@"3" = .z };
+        pub const zyww: Selector = .{ .@"0" = .z, .@"1" = .y, .@"2" = .w, .@"3" = .w };
+        pub const zzxx: Selector = .{ .@"0" = .z, .@"1" = .z, .@"2" = .x, .@"3" = .x };
+        pub const zzxy: Selector = .{ .@"0" = .z, .@"1" = .z, .@"2" = .x, .@"3" = .y };
+        pub const zzxz: Selector = .{ .@"0" = .z, .@"1" = .z, .@"2" = .x, .@"3" = .z };
+        pub const zzxw: Selector = .{ .@"0" = .z, .@"1" = .z, .@"2" = .x, .@"3" = .w };
+        pub const zzyx: Selector = .{ .@"0" = .z, .@"1" = .z, .@"2" = .y, .@"3" = .x };
+        pub const zzyy: Selector = .{ .@"0" = .z, .@"1" = .z, .@"2" = .y, .@"3" = .y };
+        pub const zzyz: Selector = .{ .@"0" = .z, .@"1" = .z, .@"2" = .y, .@"3" = .z };
+        pub const zzyw: Selector = .{ .@"0" = .z, .@"1" = .z, .@"2" = .y, .@"3" = .w };
+        pub const zzzx: Selector = .{ .@"0" = .z, .@"1" = .z, .@"2" = .z, .@"3" = .x };
+        pub const zzzy: Selector = .{ .@"0" = .z, .@"1" = .z, .@"2" = .z, .@"3" = .y };
+        pub const zzzz: Selector = .{ .@"0" = .z, .@"1" = .z, .@"2" = .z, .@"3" = .z };
+        pub const zzzw: Selector = .{ .@"0" = .z, .@"1" = .z, .@"2" = .z, .@"3" = .w };
+        pub const zzwx: Selector = .{ .@"0" = .z, .@"1" = .z, .@"2" = .w, .@"3" = .x };
+        pub const zzwy: Selector = .{ .@"0" = .z, .@"1" = .z, .@"2" = .w, .@"3" = .y };
+        pub const zzwz: Selector = .{ .@"0" = .z, .@"1" = .z, .@"2" = .w, .@"3" = .z };
+        pub const zzww: Selector = .{ .@"0" = .z, .@"1" = .z, .@"2" = .w, .@"3" = .w };
+        pub const zwxx: Selector = .{ .@"0" = .z, .@"1" = .w, .@"2" = .x, .@"3" = .x };
+        pub const zwxy: Selector = .{ .@"0" = .z, .@"1" = .w, .@"2" = .x, .@"3" = .y };
+        pub const zwxz: Selector = .{ .@"0" = .z, .@"1" = .w, .@"2" = .x, .@"3" = .z };
+        pub const zwxw: Selector = .{ .@"0" = .z, .@"1" = .w, .@"2" = .x, .@"3" = .w };
+        pub const zwyx: Selector = .{ .@"0" = .z, .@"1" = .w, .@"2" = .y, .@"3" = .x };
+        pub const zwyy: Selector = .{ .@"0" = .z, .@"1" = .w, .@"2" = .y, .@"3" = .y };
+        pub const zwyz: Selector = .{ .@"0" = .z, .@"1" = .w, .@"2" = .y, .@"3" = .z };
+        pub const zwyw: Selector = .{ .@"0" = .z, .@"1" = .w, .@"2" = .y, .@"3" = .w };
+        pub const zwzx: Selector = .{ .@"0" = .z, .@"1" = .w, .@"2" = .z, .@"3" = .x };
+        pub const zwzy: Selector = .{ .@"0" = .z, .@"1" = .w, .@"2" = .z, .@"3" = .y };
+        pub const zwzz: Selector = .{ .@"0" = .z, .@"1" = .w, .@"2" = .z, .@"3" = .z };
+        pub const zwzw: Selector = .{ .@"0" = .z, .@"1" = .w, .@"2" = .z, .@"3" = .w };
+        pub const zwwx: Selector = .{ .@"0" = .z, .@"1" = .w, .@"2" = .w, .@"3" = .x };
+        pub const zwwy: Selector = .{ .@"0" = .z, .@"1" = .w, .@"2" = .w, .@"3" = .y };
+        pub const zwwz: Selector = .{ .@"0" = .z, .@"1" = .w, .@"2" = .w, .@"3" = .z };
+        pub const zwww: Selector = .{ .@"0" = .z, .@"1" = .w, .@"2" = .w, .@"3" = .w };
+        pub const wxxx: Selector = .{ .@"0" = .w, .@"1" = .x, .@"2" = .x, .@"3" = .x };
+        pub const wxxy: Selector = .{ .@"0" = .w, .@"1" = .x, .@"2" = .x, .@"3" = .y };
+        pub const wxxz: Selector = .{ .@"0" = .w, .@"1" = .x, .@"2" = .x, .@"3" = .z };
+        pub const wxxw: Selector = .{ .@"0" = .w, .@"1" = .x, .@"2" = .x, .@"3" = .w };
+        pub const wxyx: Selector = .{ .@"0" = .w, .@"1" = .x, .@"2" = .y, .@"3" = .x };
+        pub const wxyy: Selector = .{ .@"0" = .w, .@"1" = .x, .@"2" = .y, .@"3" = .y };
+        pub const wxyz: Selector = .{ .@"0" = .w, .@"1" = .x, .@"2" = .y, .@"3" = .z };
+        pub const wxyw: Selector = .{ .@"0" = .w, .@"1" = .x, .@"2" = .y, .@"3" = .w };
+        pub const wxzx: Selector = .{ .@"0" = .w, .@"1" = .x, .@"2" = .z, .@"3" = .x };
+        pub const wxzy: Selector = .{ .@"0" = .w, .@"1" = .x, .@"2" = .z, .@"3" = .y };
+        pub const wxzz: Selector = .{ .@"0" = .w, .@"1" = .x, .@"2" = .z, .@"3" = .z };
+        pub const wxzw: Selector = .{ .@"0" = .w, .@"1" = .x, .@"2" = .z, .@"3" = .w };
+        pub const wxwx: Selector = .{ .@"0" = .w, .@"1" = .x, .@"2" = .w, .@"3" = .x };
+        pub const wxwy: Selector = .{ .@"0" = .w, .@"1" = .x, .@"2" = .w, .@"3" = .y };
+        pub const wxwz: Selector = .{ .@"0" = .w, .@"1" = .x, .@"2" = .w, .@"3" = .z };
+        pub const wxww: Selector = .{ .@"0" = .w, .@"1" = .x, .@"2" = .w, .@"3" = .w };
+        pub const wyxx: Selector = .{ .@"0" = .w, .@"1" = .y, .@"2" = .x, .@"3" = .x };
+        pub const wyxy: Selector = .{ .@"0" = .w, .@"1" = .y, .@"2" = .x, .@"3" = .y };
+        pub const wyxz: Selector = .{ .@"0" = .w, .@"1" = .y, .@"2" = .x, .@"3" = .z };
+        pub const wyxw: Selector = .{ .@"0" = .w, .@"1" = .y, .@"2" = .x, .@"3" = .w };
+        pub const wyyx: Selector = .{ .@"0" = .w, .@"1" = .y, .@"2" = .y, .@"3" = .x };
+        pub const wyyy: Selector = .{ .@"0" = .w, .@"1" = .y, .@"2" = .y, .@"3" = .y };
+        pub const wyyz: Selector = .{ .@"0" = .w, .@"1" = .y, .@"2" = .y, .@"3" = .z };
+        pub const wyyw: Selector = .{ .@"0" = .w, .@"1" = .y, .@"2" = .y, .@"3" = .w };
+        pub const wyzx: Selector = .{ .@"0" = .w, .@"1" = .y, .@"2" = .z, .@"3" = .x };
+        pub const wyzy: Selector = .{ .@"0" = .w, .@"1" = .y, .@"2" = .z, .@"3" = .y };
+        pub const wyzz: Selector = .{ .@"0" = .w, .@"1" = .y, .@"2" = .z, .@"3" = .z };
+        pub const wyzw: Selector = .{ .@"0" = .w, .@"1" = .y, .@"2" = .z, .@"3" = .w };
+        pub const wywx: Selector = .{ .@"0" = .w, .@"1" = .y, .@"2" = .w, .@"3" = .x };
+        pub const wywy: Selector = .{ .@"0" = .w, .@"1" = .y, .@"2" = .w, .@"3" = .y };
+        pub const wywz: Selector = .{ .@"0" = .w, .@"1" = .y, .@"2" = .w, .@"3" = .z };
+        pub const wyww: Selector = .{ .@"0" = .w, .@"1" = .y, .@"2" = .w, .@"3" = .w };
+        pub const wzxx: Selector = .{ .@"0" = .w, .@"1" = .z, .@"2" = .x, .@"3" = .x };
+        pub const wzxy: Selector = .{ .@"0" = .w, .@"1" = .z, .@"2" = .x, .@"3" = .y };
+        pub const wzxz: Selector = .{ .@"0" = .w, .@"1" = .z, .@"2" = .x, .@"3" = .z };
+        pub const wzxw: Selector = .{ .@"0" = .w, .@"1" = .z, .@"2" = .x, .@"3" = .w };
+        pub const wzyx: Selector = .{ .@"0" = .w, .@"1" = .z, .@"2" = .y, .@"3" = .x };
+        pub const wzyy: Selector = .{ .@"0" = .w, .@"1" = .z, .@"2" = .y, .@"3" = .y };
+        pub const wzyz: Selector = .{ .@"0" = .w, .@"1" = .z, .@"2" = .y, .@"3" = .z };
+        pub const wzyw: Selector = .{ .@"0" = .w, .@"1" = .z, .@"2" = .y, .@"3" = .w };
+        pub const wzzx: Selector = .{ .@"0" = .w, .@"1" = .z, .@"2" = .z, .@"3" = .x };
+        pub const wzzy: Selector = .{ .@"0" = .w, .@"1" = .z, .@"2" = .z, .@"3" = .y };
+        pub const wzzz: Selector = .{ .@"0" = .w, .@"1" = .z, .@"2" = .z, .@"3" = .z };
+        pub const wzzw: Selector = .{ .@"0" = .w, .@"1" = .z, .@"2" = .z, .@"3" = .w };
+        pub const wzwx: Selector = .{ .@"0" = .w, .@"1" = .z, .@"2" = .w, .@"3" = .x };
+        pub const wzwy: Selector = .{ .@"0" = .w, .@"1" = .z, .@"2" = .w, .@"3" = .y };
+        pub const wzwz: Selector = .{ .@"0" = .w, .@"1" = .z, .@"2" = .w, .@"3" = .z };
+        pub const wzww: Selector = .{ .@"0" = .w, .@"1" = .z, .@"2" = .w, .@"3" = .w };
+        pub const wwxx: Selector = .{ .@"0" = .w, .@"1" = .w, .@"2" = .x, .@"3" = .x };
+        pub const wwxy: Selector = .{ .@"0" = .w, .@"1" = .w, .@"2" = .x, .@"3" = .y };
+        pub const wwxz: Selector = .{ .@"0" = .w, .@"1" = .w, .@"2" = .x, .@"3" = .z };
+        pub const wwxw: Selector = .{ .@"0" = .w, .@"1" = .w, .@"2" = .x, .@"3" = .w };
+        pub const wwyx: Selector = .{ .@"0" = .w, .@"1" = .w, .@"2" = .y, .@"3" = .x };
+        pub const wwyy: Selector = .{ .@"0" = .w, .@"1" = .w, .@"2" = .y, .@"3" = .y };
+        pub const wwyz: Selector = .{ .@"0" = .w, .@"1" = .w, .@"2" = .y, .@"3" = .z };
+        pub const wwyw: Selector = .{ .@"0" = .w, .@"1" = .w, .@"2" = .y, .@"3" = .w };
+        pub const wwzx: Selector = .{ .@"0" = .w, .@"1" = .w, .@"2" = .z, .@"3" = .x };
+        pub const wwzy: Selector = .{ .@"0" = .w, .@"1" = .w, .@"2" = .z, .@"3" = .y };
+        pub const wwzz: Selector = .{ .@"0" = .w, .@"1" = .w, .@"2" = .z, .@"3" = .z };
+        pub const wwzw: Selector = .{ .@"0" = .w, .@"1" = .w, .@"2" = .z, .@"3" = .w };
+        pub const wwwx: Selector = .{ .@"0" = .w, .@"1" = .w, .@"2" = .w, .@"3" = .x };
+        pub const wwwy: Selector = .{ .@"0" = .w, .@"1" = .w, .@"2" = .w, .@"3" = .y };
+        pub const wwwz: Selector = .{ .@"0" = .w, .@"1" = .w, .@"2" = .w, .@"3" = .z };
+        pub const wwww: Selector = .{ .@"0" = .w, .@"1" = .w, .@"2" = .w, .@"3" = .w };
+
+        @"3": Component,
+        @"2": Component,
+        @"1": Component,
+        @"0": Component,
+
+        const indexes = "0123";
+
+        pub fn swizzle(selector: Selector, other: Selector) Selector {
+            var new_selector: Selector = undefined;
+            inline for (indexes) |f| {
+                const component = @field(other, std.mem.asBytes(&f));
+
+                @field(new_selector, std.mem.asBytes(&f)) = switch (component) {
+                    inline else => |v| @field(selector, std.mem.asBytes(&indexes[@intFromEnum(v)])),
+                };
+            }
+            return new_selector;
+        }
+
+        pub fn format(selector: Selector, writer: *std.Io.Writer) std.Io.Writer.Error!void {
+            try writer.print("{t}{t}{t}{t}", .{ selector.@"0", selector.@"1", selector.@"2", selector.@"3" });
+        }
+
+        pub const ParseError = error{
+            Syntax,
+            InvalidComponent,
+        };
+
+        pub fn parse(expression: []const u8) ParseError!Selector {
+            if (expression.len == 0 or expression.len > 4) {
+                return error.Syntax;
+            }
+
+            var last: Component = undefined;
+            var selector: Selector = undefined;
+            inline for ("0123", 0..) |f, i| {
+                const component: Component = if (i >= expression.len)
+                    last
+                else
+                    @enumFromInt(std.mem.indexOf(u8, span, &.{expression[i]}) orelse return error.InvalidComponent);
+
+                @field(selector, std.mem.asBytes(&f)) = component;
+                last = component;
+            }
+
+            return selector;
+        }
+
+        /// parses sequential swizzles with '.' as a separator, returns the final swizzle
+        pub fn parseSequential(expression: []const u8) ParseError!Selector {
+            var swizzles = std.mem.tokenizeScalar(u8, expression, '.');
+
+            var final_swizzle: Component.Selector = .xyzw;
+            while (swizzles.next()) |swizzle_str| {
+                const current_swizzle = try Component.Selector.parse(std.mem.trim(u8, swizzle_str, " \t"));
+                final_swizzle = final_swizzle.swizzle(current_swizzle);
+            }
+
+            return final_swizzle;
+        }
+
+        test parse {
+            try testing.expect(Selector.wwww == Selector.xyzw.swizzle(.wwww));
+            try testing.expect(Selector.yzww == Selector.xyzw.swizzle(.wzyx).swizzle(.zyxx));
+            try testing.expect(Selector.xyxy == Selector.xyzw.swizzle(.xxyy).swizzle(.xzyw));
+            try testing.expect(Selector.wzyy == Selector.xyzw.swizzle(.wzyx).swizzle(.xyzz));
+
+            try testing.expect(Selector.wxyz == try parse("wxyz"));
+            try testing.expect(Selector.wwww == try parse("wwww"));
+            try testing.expect(Selector.wxwx == try parse("wxwx"));
+            try testing.expect(Selector.xyzw == try parse("xyzw"));
+            try testing.expect(Selector.w == try parse("w"));
+            try testing.expect(Selector.yw == try parse("yw"));
+            try testing.expect(Selector.yzw == try parse("yzw"));
+            try testing.expect(error.InvalidComponent == parse("tzp"));
+        }
+    };
+};
+
+pub const OperandDescriptor = packed struct(u32) {
+    pub const Negation = enum(u1) {
+        @"+",
+        @"-",
+
+        pub fn negate(neg: Negation) Negation {
+            return switch (neg) {
+                .@"+" => .@"-",
+                .@"-" => .@"+",
+            };
+        }
+
+        pub fn format(neg: Negation, writer: *std.Io.Writer) std.Io.Writer.Error!void {
+            return switch (neg) {
+                .@"+" => {},
+                .@"-" => try writer.writeByte('-'),
+            };
+        }
+    };
+
+    pub const Mask = packed struct(u8) {
+        pub const unary: Mask = .{ .dst = true, .src1 = true };
+        pub const binary: Mask = .{ .dst = true, .src1 = true, .src2 = true };
+        pub const full: Mask = .{ .dst = true, .src1 = true, .src2 = true, .src3 = true };
+        pub const comparison: Mask = .{ .src1 = true, .src2 = true };
+
+        dst: bool = false,
+        src1: bool = false,
+        src2: bool = false,
+        src3: bool = false,
+        _: u4 = 0,
+
+        pub fn contains(mask: Mask, other: Mask) bool {
+            return @as(u8, @bitCast(mask)) <= @as(u8, @bitCast(other));
+        }
+    };
+
+    dst_mask: Component.Mask = .xyzw,
+    src1_neg: Negation = .@"+",
+    src1_selector: Component.Selector = .xyzw,
+    src2_neg: Negation = .@"+",
+    src2_selector: Component.Selector = .xyzw,
+    src3_neg: Negation = .@"+",
+    src3_selector: Component.Selector = .xyzw,
+    _unused0: u1 = 0,
+
+    pub fn format(desc: OperandDescriptor, w: *std.Io.Writer) std.Io.Writer.Error!void {
+        try w.print("{f} = {f}{f} | {f}{f} | {f}{f}", .{
+            desc.dst_mask,
+            desc.src1_neg,
+            desc.src1_selector,
+            desc.src2_neg,
+            desc.src2_selector,
+            desc.src3_neg,
+            desc.src3_selector,
+        });
+    }
+
+    pub fn equalsMasked(desc: OperandDescriptor, mask: Mask, other: OperandDescriptor) bool {
+        // zig fmt: off
+        return (!mask.dst  or (desc.dst_mask == other.dst_mask))
+           and (!mask.src1 or (desc.src1_neg == other.src1_neg and desc.src1_selector == other.src1_selector))
+           and (!mask.src2 or (desc.src2_neg == other.src2_neg and desc.src2_selector == other.src2_selector))
+           and (!mask.src3 or (desc.src3_neg == other.src3_neg and desc.src3_selector == other.src3_selector));
+        // zig fmt: on
+    }
+};
+
+pub const ComparisonOperation = enum(u3) {
+    eq,
+    ne,
+    lt,
+    le,
+    gt,
+    ge,
+    true_0,
+    true_1,
+
+    pub fn invert(op: ComparisonOperation) ComparisonOperation {
+        return switch (op) {
+            .lt => .ge,
+            .le => .gt,
+            .ge => .lt,
+            .gt => .le,
+            else => op,
+        };
+    }
+};
+
+pub const Condition = enum(u2) { @"or", @"and", x, y };
+pub const Primitive = enum(u1) { vertex, primitive };
+pub const Winding = enum(u1) { default, invert };
+
+pub const Instruction = packed union(u32) {
+    pub const Opcode = enum(u6) {
+        pub const Mad = enum(u3) { _ };
+        pub const Comparison = enum(u5) { _ };
+
+        add,
+        dp3,
+        dp4,
+        dph,
+        dst,
+        ex2,
+        lg2,
+        litp,
+        mul,
+        sge,
+        slt,
+        flr,
+        max,
+        min,
+        rcp,
+        rsq,
+
+        mova = 0x12,
+        mov,
+
+        dphi = 0x18,
+        dsti,
+        sgei,
+        slti,
+
+        @"break" = 0x20,
+        nop,
+        end,
+        breakc,
+        call,
+        callc,
+        callu,
+        ifu,
+        ifc,
+        loop,
+        emit,
+        setemit,
+        jmpc,
+        jmpu,
+        cmp0 = 0x2E,
+        cmp1 = 0x2F,
+        madi0 = 0x30,
+        madi1 = 0x31,
+        madi2 = 0x32,
+        madi3 = 0x33,
+        madi4 = 0x34,
+        madi5 = 0x35,
+        madi6 = 0x36,
+        madi7 = 0x37,
+        mad0 = 0x38,
+        mad1 = 0x39,
+        mad2 = 0x3A,
+        mad3 = 0x3B,
+        mad4 = 0x3C,
+        mad5 = 0x3D,
+        mad6 = 0x3E,
+        mad7 = 0x3F,
+        _,
+
+        pub fn isCommutative(opcode: Opcode) bool {
+            return switch (opcode) {
+                .add, .dp3, .dp4, .mul, .max, .min => true,
+                else => false,
+            };
+        }
+
+        pub fn invert(opcode: Opcode) ?Opcode {
+            return switch (opcode) {
+                .dph => .dphi,
+                .dst => .dsti,
+                .sge => .sgei,
+                .slt => .slti,
+                else => null,
+            };
+        }
+
+        pub fn toComparison(opcode: Opcode) ?Opcode.Comparison {
+            return switch (@intFromEnum(opcode)) {
+                @intFromEnum(Opcode.cmp0)...@intFromEnum(Opcode.cmp1) => @enumFromInt(@intFromEnum(Opcode.cmp0) >> 1),
+                else => null,
+            };
+        }
+
+        pub fn toMad(opcode: Opcode) ?Opcode.Mad {
+            return switch (@intFromEnum(opcode)) {
+                0x30...0x37 => @enumFromInt(@intFromEnum(Opcode.madi0) >> 3),
+                0x38...0x3F => @enumFromInt(@intFromEnum(Opcode.mad0) >> 3),
+                else => null,
+            };
+        }
+    };
+
+    pub const Unparametized = packed struct(u32) { _unused0: u26 = 0, opcode: Opcode };
+
+    pub fn Register(comptime inverted: bool) type {
+        return packed struct(u32) {
+            operand_descriptor_id: u7,
+            src2: (if (inverted) SourceRegister else SourceRegister.Limited) = .v0,
+            src1: (if (inverted) SourceRegister.Limited else SourceRegister),
+            address_component: AddressComponent = .none,
+            dst: DestinationRegister,
+            opcode: Opcode,
+        };
+    }
+
+    pub const Comparison = packed struct(u32) {
+        operand_descriptor_id: u7,
+        src2: SourceRegister.Limited,
+        src1: SourceRegister,
+        address_component: AddressComponent = .none,
+        x_operation: ComparisonOperation,
+        y_operation: ComparisonOperation,
+        opcode: Opcode.Comparison,
+    };
+
+    pub const ControlFlow = packed struct(u32) {
+        num: u8,
+        _unused0: u2 = 0,
+        dst: u12,
+        condition: Condition,
+        ref_y: bool,
+        ref_x: bool,
+        opcode: Opcode,
+    };
+
+    pub const ConstantControlFlow = packed struct(u32) {
+        num: u8,
+        _unused0: u2 = 0,
+        dst: u12,
+        src: IntegralRegister,
+        opcode: Opcode,
+    };
+
+    pub const SetEmit = packed struct(u32) {
+        _unused0: u22 = 0,
+        winding: Winding,
+        primitive_emit: Primitive,
+        vertex_id: u2,
+        opcode: Opcode,
+    };
+
+    pub fn Mad(comptime inverted: bool) type {
+        return packed struct(u32) {
+            operand_descriptor_id: u5,
+            src3: (if (inverted) SourceRegister else SourceRegister.Limited),
+            src2: (if (inverted) SourceRegister.Limited else SourceRegister),
+            src1: SourceRegister.Limited,
+            address_component: AddressComponent,
+            dst: DestinationRegister,
+            opcode: Opcode.Mad,
+        };
+    }
+
+    unparametized: Unparametized,
+    register: Register(false),
+    register_inverted: Register(true),
+    comparison: Comparison,
+    control_flow: ControlFlow,
+    constant_control_flow: ConstantControlFlow,
+    set_emit: SetEmit,
+    mad: Mad(false),
+    mad_inverted: Mad(true),
+
+    /// Disassembles this instruction without any `OperandDescriptor` context
+    ///
+    /// Use `fmtContext` if you have those
+    pub fn format(inst: Instruction, w: *std.Io.Writer) std.Io.Writer.Error!void {
+        try w.print("{f}", .{inst.fmtContext(&.{})});
+    }
+
+    /// Returns a formatter able to fully disassemble instructions.
+    ///
+    /// Tries to use `descriptors`, if a descriptor is not found the index will be printed
+    /// in a comment instead with '?' as the `OperandDescriptor` placeholder.
+    pub fn fmtContext(inst: Instruction, descriptors: []const OperandDescriptor) Format {
+        return .{ .inst = inst, .descriptors = descriptors };
+    }
+
+    pub const Format = struct {
+        inst: Instruction,
+        descriptors: []const OperandDescriptor,
+
+        pub fn format(fmt: Format, writer: *std.Io.Writer) std.Io.Writer.Error!void {
+            const inst = fmt.inst;
+            const descriptors = fmt.descriptors;
+
+            return switch (@intFromEnum(inst.unparametized.opcode)) {
+                @intFromEnum(Opcode.@"break"),
+                @intFromEnum(Opcode.nop),
+                @intFromEnum(Opcode.end),
+                @intFromEnum(Opcode.emit),
+                => try writer.print("{t}", .{inst.unparametized.opcode}),
+                @intFromEnum(Opcode.add),
+                @intFromEnum(Opcode.dp3),
+                @intFromEnum(Opcode.dp4),
+                @intFromEnum(Opcode.dph),
+                @intFromEnum(Opcode.dst),
+                @intFromEnum(Opcode.mul),
+                @intFromEnum(Opcode.sge),
+                @intFromEnum(Opcode.slt),
+                @intFromEnum(Opcode.max),
+                @intFromEnum(Opcode.min),
+                => {
+                    const binary = inst.register;
+
+                    if (binary.operand_descriptor_id < descriptors.len) {
+                        const desc = descriptors[binary.operand_descriptor_id];
+
+                        try writer.print("{t} {t}.{f}, {f}{t}{f}.{f}, {f}{t}.{f}", .{ binary.opcode, binary.dst, desc.dst_mask, desc.src1_neg, binary.src1, binary.address_component, desc.src1_selector, desc.src2_neg, binary.src2, desc.src2_selector });
+                    } else try writer.print("{t} {t}.????, ?{t}{f}.????, ?{t}.???? ; opdesc {d}", .{ binary.opcode, binary.dst, binary.src1, binary.address_component, binary.src2, binary.operand_descriptor_id });
+                },
+                @intFromEnum(Opcode.dphi),
+                @intFromEnum(Opcode.dsti),
+                @intFromEnum(Opcode.sgei),
+                @intFromEnum(Opcode.slti),
+                => {
+                    const binary = inst.register;
+
+                    if (binary.operand_descriptor_id < descriptors.len) {
+                        const desc = descriptors[binary.operand_descriptor_id];
+
+                        // NOTE: @tagName because we want to remove the `i` suffix.
+                        try writer.print("{s} {t}.{f}, {f}{t}.{f}, {f}{t}{f}.{f}", .{ @tagName(binary.opcode)[0..3], binary.dst, desc.dst_mask, desc.src1_neg, binary.src1, desc.src1_selector, desc.src2_neg, binary.src2, binary.address_component, desc.src2_selector });
+                    } else try writer.print("{s} {t}.????, ?{t}.????, ?{t}{f}.???? ; opdesc {d}", .{ @tagName(binary.opcode)[0..3], binary.dst, binary.src1, binary.src2, binary.address_component, binary.operand_descriptor_id });
+                },
+                @intFromEnum(Opcode.ex2),
+                @intFromEnum(Opcode.lg2),
+                @intFromEnum(Opcode.litp),
+                @intFromEnum(Opcode.flr),
+                @intFromEnum(Opcode.rcp),
+                @intFromEnum(Opcode.rsq),
+                @intFromEnum(Opcode.mova),
+                @intFromEnum(Opcode.mov),
+                => {
+                    const unary = inst.register;
+
+                    if (unary.operand_descriptor_id < descriptors.len) {
+                        const desc = descriptors[unary.operand_descriptor_id];
+
+                        try writer.print("{t} {t}.{f}, {f}{t}{f}.{f}", .{ unary.opcode, unary.dst, desc.dst_mask, desc.src1_neg, unary.src1, unary.address_component, desc.src1_selector });
+                    } else try writer.print("{t} {t}.????, ?{t}{f}.???? ; opdesc {d}", .{ unary.opcode, unary.dst, unary.src1, unary.address_component, unary.operand_descriptor_id });
+                },
+                @intFromEnum(Opcode.breakc),
+                => try writer.print("breakc {t}, {}, {}", .{ inst.control_flow.condition, inst.control_flow.ref_x, inst.control_flow.ref_y }),
+                @intFromEnum(Opcode.jmpc),
+                => try writer.print("jmpc {t}, {}, {}, L_{X:0>3}", .{ inst.control_flow.condition, inst.control_flow.ref_x, inst.control_flow.ref_y, inst.control_flow.dst }),
+                @intFromEnum(Opcode.call),
+                => try writer.print("call L_{X:0>3}, L_{X:0>3}", .{ inst.control_flow.dst, inst.control_flow.dst + inst.control_flow.num }),
+                @intFromEnum(Opcode.callc),
+                @intFromEnum(Opcode.ifc),
+                => try writer.print("{t} {t}, {}, {}, L_{X:0>3}, L_{X:0>3}", .{ inst.control_flow.opcode, inst.control_flow.condition, inst.control_flow.ref_x, inst.control_flow.ref_y, inst.control_flow.dst, inst.control_flow.dst + inst.control_flow.num }),
+                @intFromEnum(Opcode.callu),
+                @intFromEnum(Opcode.ifu),
+                => try writer.print("{t} {t}, L_{X:0>3}, L_{X:0>3}", .{ inst.constant_control_flow.opcode, inst.constant_control_flow.src.bool, inst.constant_control_flow.dst, inst.constant_control_flow.dst + inst.constant_control_flow.num }),
+                @intFromEnum(Opcode.jmpu),
+                => try writer.print("jmpu {t}, {}, L_{X:0>3}", .{ inst.constant_control_flow.src.bool, inst.constant_control_flow.num == 0, inst.constant_control_flow.dst }),
+                @intFromEnum(Opcode.loop),
+                => try writer.print("loop {t}, L_{X:0>3}", .{ inst.constant_control_flow.src.int.used, inst.constant_control_flow.dst + @sizeOf(Instruction) }),
+                @intFromEnum(Opcode.setemit),
+                => try writer.print("setemit {}, {t}, {t}", .{ inst.set_emit.vertex_id, inst.set_emit.primitive_emit, inst.set_emit.winding }),
+                @intFromEnum(Opcode.cmp0),
+                @intFromEnum(Opcode.cmp1),
+                => {
+                    const cmp = inst.comparison;
+
+                    if (cmp.operand_descriptor_id < descriptors.len) {
+                        const desc = descriptors[cmp.operand_descriptor_id];
+
+                        try writer.print("cmp {f}{t}{f}.{f}, {t}, {t}, {f}{t}.{f}", .{ desc.src1_neg, cmp.src1, cmp.address_component, desc.src1_selector, cmp.x_operation, cmp.y_operation, desc.src2_neg, cmp.src2, desc.src2_selector });
+                    } else try writer.print("cmp ?{t}{f}.????, {t}, {t}, ?{t}.???? ; opdesc {d}", .{ cmp.src1, cmp.address_component, cmp.x_operation, cmp.y_operation, cmp.src2, cmp.operand_descriptor_id });
+                },
+                @intFromEnum(Opcode.mad0)...@intFromEnum(Opcode.mad7) => {
+                    const mad = inst.mad;
+
+                    if (mad.operand_descriptor_id < descriptors.len) {
+                        const desc = descriptors[mad.operand_descriptor_id];
+
+                        try writer.print("mad {t}.{f}, {f}{t}.{f}, {f}{t}{f}.{f}, {f}{t}.{f}", .{ mad.dst, desc.dst_mask, desc.src1_neg, mad.src1, desc.src1_selector, desc.src2_neg, mad.src2, mad.address_component, desc.src2_selector, desc.src3_neg, mad.src3, desc.src3_selector });
+                    } else try writer.print("mad {t}.????, ?{t}.????, ?{t}{f}.????, ?{t}.???? ; opdesc {d}", .{ mad.dst, mad.src1, mad.src2, mad.address_component, mad.src3, mad.operand_descriptor_id });
+                },
+                @intFromEnum(Opcode.madi0)...@intFromEnum(Opcode.madi7) => {
+                    const mad = inst.mad_inverted;
+
+                    if (mad.operand_descriptor_id < descriptors.len) {
+                        const desc = descriptors[mad.operand_descriptor_id];
+
+                        try writer.print("mad {t}.{f}, {f}{t}.{f}, {f}{t}.{f}, {f}{t}{f}.{f}", .{ mad.dst, desc.dst_mask, desc.src1_neg, mad.src1, desc.src1_selector, desc.src2_neg, mad.src2, desc.src2_selector, desc.src3_neg, mad.src3, mad.address_component, desc.src3_selector });
+                    } else try writer.print("mad {t}.????, ?{t}.????, ?{t}.????, ?{t}{f}.???? ; opdesc {d}", .{ mad.dst, mad.src1, mad.src2, mad.src3, mad.address_component, mad.operand_descriptor_id });
+                },
+                else => try writer.print("??? (0x{X:0>8})", .{@as(u32, @bitCast(fmt.inst))}),
+            };
+        }
+    };
+};
+
+const std = @import("std");
+const testing = std.testing;
+
+const zitrus = @import("zitrus");
+const shader = zitrus.hardware.pica.shader;
+
+const AddressComponent = shader.register.AddressComponent;
+const SourceRegister = shader.register.Source;
+const DestinationRegister = shader.register.Destination;
+const IntegralRegister = shader.register.Integral;
diff --git a/src/platform/3ds/mango/hardware/pica/shader/register.zig b/src/platform/3ds/mango/hardware/pica/shader/register.zig
new file mode 100644
index 0000000..dc3a863
--- /dev/null
+++ b/src/platform/3ds/mango/hardware/pica/shader/register.zig
@@ -0,0 +1,248 @@
+pub const AddressComponent = enum(u2) {
+    pub const Mask = packed struct(u2) {
+        pub const x: Mask = .{ .enable_x = true };
+        pub const y: Mask = .{ .enable_y = true };
+        pub const xy: Mask = .{ .enable_x = true, .enable_y = true };
+
+        enable_x: bool = false,
+        enable_y: bool = false,
+    };
+
+    none,
+    x,
+    y,
+    l,
+
+    pub fn format(addr: AddressComponent, writer: *std.Io.Writer) std.Io.Writer.Error!void {
+        return switch (addr) {
+            .none => {},
+            .x, .y, .l => try writer.print("[a.{t}]", .{addr}),
+        };
+    }
+};
+
+pub const Temporary = enum(u4) { r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15 };
+
+pub const Source = enum(u7) {
+    pub const Kind = enum {
+        input,
+        temporary,
+        constant,
+
+        pub fn amount(k: Kind) usize {
+            return switch (k) {
+                .input, .temporary => 16,
+                .constant => 96,
+            };
+        }
+    };
+
+    pub const Input = enum(u4) { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 };
+
+    pub const Constant = enum(u7) {
+        // zig fmt: off
+        f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15,
+        f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, f29,
+        f30, f31, f32, f33, f34, f35, f36, f37, f38, f39, f40, f41, f42, f43,
+        f44, f45, f46, f47, f48, f49, f50, f51, f52, f53, f54, f55, f56, f57,
+        f58, f59, f60, f61, f62, f63, f64, f65, f66, f67, f68, f69, f70, f71,
+        f72, f73, f74, f75, f76, f77, f78, f79, f80, f81, f82, f83, f84, f85,
+        f86, f87, f88, f89, f90, f91, f92, f93, f94, f95, _,
+        // zig fmt: on
+    };
+
+    pub const Limited = enum(u5) {
+        // zig fmt: off
+        v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
+        r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15,
+        // zig fmt: on
+    };
+
+    // zig fmt: off
+    v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
+    r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15,
+    f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15,
+    f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, f29,
+    f30, f31, f32, f33, f34, f35, f36, f37, f38, f39, f40, f41, f42, f43,
+    f44, f45, f46, f47, f48, f49, f50, f51, f52, f53, f54, f55, f56, f57,
+    f58, f59, f60, f61, f62, f63, f64, f65, f66, f67, f68, f69, f70, f71,
+    f72, f73, f74, f75, f76, f77, f78, f79, f80, f81, f82, f83, f84, f85,
+    f86, f87, f88, f89, f90, f91, f92, f93, f94, f95, 
+    // zig fmt: on
+
+    pub fn initLimited(limited: Limited) Source {
+        return @enumFromInt(@intFromEnum(limited));
+    }
+
+    pub fn initInput(register: Input) Source {
+        return @enumFromInt(@intFromEnum(register));
+    }
+
+    pub fn initTemporary(register: Temporary) Source {
+        return @enumFromInt(@as(u5, 1 << 4) | @intFromEnum(register));
+    }
+
+    pub fn initConstant(register: Constant) Source {
+        return @enumFromInt(@intFromEnum(register) + 0x20);
+    }
+
+    pub fn initKind(k: Kind, index: u7) Source {
+        return switch (k) {
+            .input => .initInput(@enumFromInt(index)),
+            .temporary => .initTemporary(@enumFromInt(index)),
+            .constant => .initConstant(@enumFromInt(index)),
+        };
+    }
+
+    pub fn isLimited(register: Source) bool {
+        return @as(u7, @intFromEnum(register)) < 32;
+    }
+
+    pub fn toLimited(register: Source) ?Limited {
+        return if (register.isLimited()) @enumFromInt(@as(u5, @intCast(@intFromEnum(register)))) else null;
+    }
+
+    pub fn kind(register: Source) Kind {
+        return switch (@intFromEnum(register)) {
+            else => |r| if (r > 0x1F) .constant else (if ((r & (1 << 4)) != 0) .temporary else .input),
+        };
+    }
+
+    pub const ParseError = error{
+        Syntax,
+        InvalidRegister,
+        InvalidIndex,
+    };
+
+    pub fn parse(value: []const u8) ParseError!Source {
+        if (value.len < 2 or !std.ascii.isAlphabetic(value[0]) or !std.ascii.isDigit(value[1])) {
+            return error.Syntax;
+        }
+
+        const k: Kind = @enumFromInt(std.mem.indexOf(u8, "vrf", &.{value[0]}) orelse return error.InvalidRegister);
+
+        const index = std.fmt.parseUnsigned(u7, value[1..], 10) catch |err| switch (err) {
+            error.Overflow => return error.InvalidIndex,
+            error.InvalidCharacter => return error.Syntax,
+        };
+
+        if (index >= k.amount()) {
+            return error.InvalidIndex;
+        }
+
+        return Source.initKind(k, index);
+    }
+
+    test parse {
+        try testing.expect(Source.v0 == try parse("v0"));
+        try testing.expect(Source.v15 == try parse("v15"));
+        try testing.expect(Source.r0 == try parse("r0"));
+        try testing.expect(Source.r15 == try parse("r15"));
+        try testing.expect(Source.f95 == try parse("f95"));
+        try testing.expect(error.InvalidRegister == parse("o5"));
+        try testing.expect(error.InvalidIndex == parse("v16"));
+        try testing.expect(error.InvalidIndex == parse("f105"));
+    }
+};
+
+pub const Destination = enum(u5) {
+    pub const Kind = enum {
+        output,
+        temporary,
+
+        pub fn amount(_: Kind) usize {
+            return 16;
+        }
+    };
+
+    pub const Output = enum(u4) { o0, o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, o11, o12, o13, o14, o15 };
+
+    // zig fmt: off
+    o0, o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, o11, o12, o13, o14, o15,
+    r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, 
+    // zig fmt: on
+
+    pub fn initOutput(register: Output) Destination {
+        return @enumFromInt(@intFromEnum(register));
+    }
+
+    pub fn initTemporary(register: Temporary) Destination {
+        return @enumFromInt(@as(u5, 1 << 4) | @intFromEnum(register));
+    }
+
+    pub fn initKind(k: Kind, register: u4) Destination {
+        return switch (k) {
+            .output => .initOutput(@enumFromInt(register)),
+            .temporary => .initTemporary(@enumFromInt(register)),
+        };
+    }
+
+    pub fn kind(register: Destination) Kind {
+        return if ((@intFromEnum(register) & (1 << 4)) != 0) .temporary else .output;
+    }
+
+    pub const ParseError = error{
+        Syntax,
+        InvalidRegister,
+        InvalidIndex,
+    };
+
+    pub fn parse(value: []const u8) ParseError!Destination {
+        if (value.len < 2 or (!std.ascii.isAlphabetic(value[0]) or !std.ascii.isDigit(value[1]))) {
+            return error.Syntax;
+        }
+
+        const k: Kind = @enumFromInt(std.mem.indexOf(u8, "or", &.{value[0]}) orelse return error.InvalidRegister);
+
+        const index = std.fmt.parseUnsigned(u4, value[1..], 10) catch |err| switch (err) {
+            error.Overflow => return error.InvalidIndex,
+            error.InvalidCharacter => return error.Syntax,
+        };
+
+        if (index >= k.amount()) {
+            return error.InvalidIndex;
+        }
+
+        return Destination.initKind(k, index);
+    }
+
+    test parse {
+        try testing.expect(Destination.o0 == try parse("o0"));
+        try testing.expect(Destination.o15 == try parse("o15"));
+        try testing.expect(Destination.r0 == try parse("r0"));
+        try testing.expect(Destination.r15 == try parse("r15"));
+        try testing.expect(error.InvalidRegister == parse("i5"));
+        try testing.expect(error.InvalidIndex == parse("o16"));
+        try testing.expect(error.InvalidIndex == parse("r105"));
+    }
+};
+
+pub const Integral = packed union(u4) {
+    pub const Boolean = enum(u4) { b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15 };
+    pub const Integer = enum(u2) { i0, i1, i2, i3 };
+
+    bool: Boolean,
+
+    // See ziglang/zig#19754
+    int: packed struct(u4) {
+        used: Integer,
+        _: u2 = 0,
+    },
+};
+
+comptime {
+    std.debug.assert(@typeInfo(AddressComponent).@"enum".is_exhaustive);
+    std.debug.assert(@typeInfo(Source).@"enum".is_exhaustive);
+    std.debug.assert(@typeInfo(Destination).@"enum".is_exhaustive);
+    std.debug.assert(@typeInfo(Integral.Boolean).@"enum".is_exhaustive);
+    std.debug.assert(@typeInfo(Integral.Integer).@"enum".is_exhaustive);
+
+    std.debug.assert(@typeInfo(Source.Input).@"enum".fields.len == 16);
+    std.debug.assert(@typeInfo(Temporary).@"enum".fields.len == 16);
+    std.debug.assert(@typeInfo(Source.Constant).@"enum".fields.len == 96);
+
+    std.debug.assert(@typeInfo(Destination.Output).@"enum".fields.len == 16);
+}
+
+const std = @import("std");
+const testing = std.testing;
diff --git a/src/platform/3ds/mango/hardware/pica/shader/spirv.zig b/src/platform/3ds/mango/hardware/pica/shader/spirv.zig
new file mode 100644
index 0000000..a534d09
--- /dev/null
+++ b/src/platform/3ds/mango/hardware/pica/shader/spirv.zig
@@ -0,0 +1,119 @@
+//! TODO: So, here's the thing. SPIR-V -> PICA200 SH ISA:
+//! - Shader + Matrix + Geometry capabilities supported.
+//! - Logical addressing mode + Simple/GLSL450 memory model.
+//! - Output semantics are hardcoded to locations, which means:
+//!     - location: 0 -> color (vec4), 1 -> texture coordinate 0 (vec3 includes w, vec2 doesn't), 2 -> tc1 (vec2), 3 -> tc2 (vec2), 4 -> view (vec3) , 5 -> normal (vec4).
+//!     - gl_Position == position
+//! - TODO (GasInfinity): What do we do with Geometry Shaders? Currently not even the assembler supports geometry entrypoint, they need some investigation + testing!
+//!
+//!
+//! See https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html
+
+const spec = void; //@import("spirv/spec.zig");
+const Reader = void; //@import("spirv/Reader.zig");
+
+const testing = std.testing;
+
+test "embed spv" {
+    if (true) return;
+    const vtx_storage align(@sizeOf(u32)) = @embedFile("vtx.spv").*;
+    const vtx_spv: []const u32 = @ptrCast(&vtx_storage);
+
+    const mutable_vtx = try testing.allocator.dupe(u32, vtx_spv);
+    defer testing.allocator.free(mutable_vtx);
+
+    var fixed_reader: std.Io.Reader = .fixed(@ptrCast(mutable_vtx));
+    const spv_reader: Reader = try .init(&fixed_reader);
+
+    std.debug.print("Version: {}.{}\n", .{ spv_reader.version.major, spv_reader.version.minor });
+    std.debug.print("Bound: {}\n", .{spv_reader.bound});
+
+    while (try spv_reader.peekPrefix()) |pref| if (pref.opcode == .OpCapability) {
+        const inst = (try spv_reader.takeInstruction()).?;
+        const capability = try spv_reader.decodeInstruction(spec.instruction.OpCapability, inst);
+
+        switch (capability[0]) {
+            .Shader, .Matrix, .Geometry => {},
+            else => return error.UnsupportedCapability,
+        }
+    } else break;
+
+    while (try spv_reader.peekPrefix()) |pref| if (pref.opcode == .OpExtension) {
+        std.debug.print("OpExtension\n", .{});
+        _ = try spv_reader.takeInstruction();
+    } else break;
+
+    while (try spv_reader.peekPrefix()) |pref| if (pref.opcode == .OpExtInstImport) {
+        std.debug.print("OpExtInstImport\n", .{});
+        _ = try spv_reader.takeInstruction();
+    } else break;
+
+    const addressing_model, const memory_model = model: {
+        const pref = try spv_reader.peekPrefix();
+        if (pref == null) return error.ExpectedMemoryModel;
+
+        const memory_model_inst = (try spv_reader.takeInstruction()).?;
+
+        break :model try spv_reader.decodeInstruction(spec.instruction.OpMemoryModel, memory_model_inst);
+    };
+
+    std.debug.print("Memory Model: {t}, {t}\n", .{ addressing_model, memory_model });
+    if (addressing_model != .Logical or (memory_model != .Simple and memory_model != .GLSL450)) return error.InvalidMemoryModel;
+
+    while (try spv_reader.peekPrefix()) |pref| if (pref.opcode == .OpEntryPoint) {
+        const inst = (try spv_reader.takeInstruction()).?;
+        const entry = try spv_reader.decodeInstruction(spec.instruction.OpEntryPoint, inst);
+        std.debug.print("OpEntryPoint '{s}': {} ({any})\n", .{ entry.@"2", entry.@"0", entry.@"3" });
+    } else break;
+
+    // Debug instructions can be skipped safely.
+    while (try spv_reader.peekPrefix()) |pref| switch (pref.opcode) {
+        .OpString, .OpSourceExtension, .OpSource, .OpSourceContinued, .OpName, .OpMemberName, .OpModuleProcessed => _ = try spv_reader.takeInstruction(),
+        else => break,
+    };
+
+    while (try spv_reader.peekPrefix()) |pref| switch (pref.opcode) {
+        .OpDecorate, .OpMemberDecorate => {
+            const inst = try spv_reader.takeInstruction();
+            _ = inst;
+        },
+        else => break,
+    };
+
+    // We can safely ignore all other types as we'll never see them, we'll bail early in OpCapability.
+    while (try spv_reader.peekPrefix()) |pref| switch (pref.opcode) {
+        .OpUndef => _ = try spv_reader.takeInstruction(),
+        .OpTypeVoid => _ = try spv_reader.takeInstruction(),
+        .OpTypeBool => _ = try spv_reader.takeInstruction(),
+        .OpTypeInt => _ = try spv_reader.takeInstruction(),
+        .OpTypeFloat => _ = try spv_reader.takeInstruction(),
+        .OpTypeVector => _ = try spv_reader.takeInstruction(),
+        .OpTypeMatrix => _ = try spv_reader.takeInstruction(),
+        .OpTypeArray, .OpTypeRuntimeArray => _ = try spv_reader.takeInstruction(),
+        .OpTypePointer => _ = try spv_reader.takeInstruction(),
+
+        .OpVariable => _ = try spv_reader.takeInstruction(),
+        .OpConstantTrue, .OpConstantFalse => _ = try spv_reader.takeInstruction(),
+
+        .OpConstant => _ = try spv_reader.takeInstruction(),
+        .OpConstantComposite => _ = try spv_reader.takeInstruction(),
+        .OpConstantNull => _ = try spv_reader.takeInstruction(),
+
+        // XXX: Is this needed?
+        .OpSpecConstant, .OpSpecConstantTrue, .OpSpecConstantFalse => _ = try spv_reader.takeInstruction(),
+
+        // 100% unsupported types.
+        .OpTypeImage, .OpTypeSampler, .OpTypeSampledImage => return error.UnsupportedType,
+
+        // First time they appear and can be skipped safely.
+        .OpLine, .OpNoLine, .OpExtInst => try spv_reader.skipInstruction(),
+        else => break,
+    };
+
+    while (try spv_reader.peekPrefix()) |pref| switch (pref.opcode) {
+        else => break,
+    };
+}
+
+const builtin = @import("builtin");
+const std = @import("std");
diff --git a/src/platform/3ds/mango/hardware/pica/shader/spirv/Reader.zig b/src/platform/3ds/mango/hardware/pica/shader/spirv/Reader.zig
new file mode 100644
index 0000000..06d797c
--- /dev/null
+++ b/src/platform/3ds/mango/hardware/pica/shader/spirv/Reader.zig
@@ -0,0 +1,169 @@
+const spec = @import("spec.zig");
+
+pub const Version = packed struct(u32) {
+    _unused0: u8,
+    minor: u8,
+    major: u8,
+    _unused1: u8,
+};
+
+pub fn detectEndianness(magic: [4]u8) ?std.builtin.Endian {
+    const magic_word: u32 = @bitCast(magic);
+
+    return switch (magic_word) {
+        spec.magic_number => builtin.cpu.arch.endian(),
+        @byteSwap(spec.magic_number) => switch (builtin.cpu.arch.endian()) {
+            .little => .big,
+            .big => .little,
+        },
+        else => null,
+    };
+}
+
+pub const Instruction = struct {
+    op: spec.instruction.Opcode,
+
+    /// In SPIR-V endian
+    slice: []u32,
+};
+
+pub const InitError = error{InvalidMagic};
+
+parent: *std.Io.Reader,
+endian: std.builtin.Endian,
+
+version: Version,
+generator: u32,
+bound: u32,
+schema: u32,
+
+pub fn init(reader: *std.Io.Reader) !SpvReader {
+    const magic = try reader.takeArray(4);
+    const endianness = detectEndianness(magic.*) orelse return error.InvalidMagic;
+    const version = try reader.takeStruct(Version, endianness);
+
+    const generator = try reader.takeInt(u32, endianness);
+    const bound = try reader.takeInt(u32, endianness);
+    const schema = try reader.takeInt(u32, endianness);
+
+    return .{
+        .parent = reader,
+        .endian = endianness,
+
+        .version = version,
+        .generator = generator,
+        .bound = bound,
+        .schema = schema,
+    };
+}
+
+pub const Prefix = packed struct(u32) {
+    opcode: spec.instruction.Opcode,
+    word_count: u16,
+};
+
+pub fn peekPrefix(reader: SpvReader) !?Prefix {
+    return reader.parent.peekStruct(Prefix, reader.endian) catch |err| switch (err) {
+        error.EndOfStream => null,
+        else => return err,
+    };
+}
+
+/// Invalidates any previously taken or decoded instruction.
+pub fn takeInstruction(reader: SpvReader) !?Instruction {
+    const prefix = try reader.peekPrefix() orelse return null;
+    if (prefix.word_count >= reader.parent.buffer.len) return error.InstructionTooLong;
+
+    const instruction_bytes = try reader.parent.take(prefix.word_count * @as(usize, @sizeOf(u32)));
+    const instruction_words: []u32 = @ptrCast(@alignCast(instruction_bytes));
+
+    return .{
+        .op = prefix.opcode,
+        .slice = instruction_words[1..],
+    };
+}
+
+pub fn skipInstruction(reader: SpvReader) !void {
+    _ = try reader.takeInstruction();
+}
+
+pub fn decodeInstruction(reader: SpvReader, comptime T: type, instruction: Instruction) !T {
+    std.debug.assert(@typeInfo(T) == .@"struct");
+    var inst: T = undefined;
+
+    var remaining = instruction.slice;
+    inline for (@typeInfo(T).@"struct".fields) |field| {
+        const Operand = field.type;
+
+        @field(inst, field.name), const words_taken = try reader.decodeOperand(Operand, remaining);
+        remaining = remaining[words_taken..];
+    }
+
+    std.debug.assert(remaining.len == 0);
+    return inst;
+}
+
+pub fn decodeOperand(reader: SpvReader, comptime T: type, slice: []u32) !struct { T, u16 } {
+    return switch (@typeInfo(T)) {
+        .void => .{ {}, 0 },
+        .@"enum" => .{ reader.decodeEnum(T, slice), 1 },
+        .pointer => |p| {
+            if (p.is_const and p.child == u8) return reader.decodeString(slice);
+            if (@sizeOf(p.child) != @sizeOf(u32)) @compileError("TODO?");
+            const words, const taken = reader.decodeWordArray(slice);
+            return .{ @ptrCast(words), taken };
+        },
+        .@"union" => |u| {
+            std.debug.assert(u.tag_type != null);
+
+            const value = reader.decodeEnum(u.tag_type.?, slice);
+
+            switch (value) {
+                _ => return error.UnknownOperand,
+                inline else => |v| {
+                    const name = @tagName(v);
+                    const Case = @FieldType(T, name);
+
+                    const case_value, const words_taken = try reader.decodeOperand(Case, slice[1..]);
+                    return .{ @unionInit(T, name, case_value), 1 + words_taken };
+                },
+            }
+        },
+        else => @compileError("How do I deserialize the type? " ++ @typeName(T)),
+    };
+}
+
+pub fn decodeWordArray(reader: SpvReader, slice: []u32) struct { []const u32, u16 } {
+    if (reader.endian != std.builtin.Endian.native) std.mem.byteSwapAllElements(u32, slice);
+    return .{ slice, @intCast(slice.len) };
+}
+
+pub fn decodeEnum(reader: SpvReader, comptime T: type, slice: []u32) T {
+    return @enumFromInt(std.mem.readInt(@typeInfo(T).@"enum".tag_type, @ptrCast(&slice[0]), reader.endian));
+}
+
+pub fn decodeString(reader: SpvReader, slice: []u32) !struct { []const u8, u16 } {
+    const bytes: []u8 = @ptrCast(slice);
+    var i: usize = 0;
+
+    while (i < slice.len) {
+        slice[i] = switch (reader.endian) {
+            .little => slice[i],
+            .big => @byteSwap(slice[i]),
+        };
+        const word: [4]u8 = @bitCast(slice[i]);
+        i += 1;
+
+        for (&word, 0..) |c, s| if (c == 0) {
+            return .{ bytes[0..(i * @sizeOf(u32) + s)], @intCast(i) };
+        };
+    }
+
+    // Not null terminated?
+    return error.InvalidOperand;
+}
+
+const SpvReader = @This();
+
+const builtin = @import("builtin");
+const std = @import("std");
diff --git a/src/platform/3ds/mango/hardware/pxi.zig b/src/platform/3ds/mango/hardware/pxi.zig
new file mode 100644
index 0000000..06926fd
--- /dev/null
+++ b/src/platform/3ds/mango/hardware/pxi.zig
@@ -0,0 +1,57 @@
+//! Definitions for MMIO `PXI` registers. **P**rocessorE**X**change**I**nterface (?)
+//!
+//! Used for communication between the ARM11 and ARM9 cores in the 3DS.
+//!
+//! Based on the documentation found in GBATEK: https://problemkaputt.de/gbatek.htm#3dsmiscregisters
+
+pub const Pipe = extern struct {
+    pub const Synchronization = extern struct {
+        pub const Interrupt = packed struct(u8) {
+            _unused0: u4,
+            /// Sets bit 12 of IF in the ARM9
+            send_arm9: bool,
+            /// Triggers IRQ 0x50 and 0x51 in the ARM11
+            send_arm11: BitpackedArray(bool, 2),
+            enable_remote_irq: bool,
+        };
+
+        received: u8,
+        /// Write-only, reads as 0
+        sent: u8,
+        _unused0: u8,
+        irq: Interrupt,
+    };
+
+    pub const Control = packed struct(u16) {
+        send_empty: bool,
+        send_full: bool,
+        send_empty_irq_enable: bool,
+        send_flush: bool,
+        _unused0: u4,
+        receive_empty: bool,
+        receive_full: bool,
+        receive_not_empty_irq_enable: bool,
+        _unused1: u3,
+        @"error": bool,
+        enable: bool,
+    };
+
+    sync: Synchronization,
+    control: Control,
+    send: u32,
+    receive: u32,
+};
+
+pub const Registers = extern struct {
+    arm9: Pipe,
+    arm11: Pipe,
+};
+
+const pxi = @This();
+
+const std = @import("std");
+
+const zitrus = @import("zitrus");
+const hardware = zitrus.hardware;
+
+const BitpackedArray = hardware.BitpackedArray;
diff --git a/src/platform/3ds/mango/mango.zig b/src/platform/3ds/mango/mango.zig
new file mode 100644
index 0000000..0c9533a
--- /dev/null
+++ b/src/platform/3ds/mango/mango.zig
@@ -0,0 +1,1689 @@
+//! mango is a Vulkan-like abstraction around the PICA200.
+//!
+//! It is designed to be as lightweight as possible while abstracting all possibly useful hardware features, it means:
+//!     - No state caching, static pipeline state is pre-encoded in a hardware command buffer.
+//!
+//!       This also implies that the application is responsible for proper pipeline usage by minimizing binds and
+//!       using dynamic state when possible (which is also NOT cached) thus making the driver as lightweight
+//!       as possible.
+//!
+//!
+//! It has a **Zig** and a **C** API, to make the **C** API as painless as possible,
+//! structs and enums must be extern-compatible.
+//!
+//! For more info see the top-level comments of each resource.
+
+// TODO: Have validation-layer behaviour with a toggle at the expense of more checks and more memory usage.
+
+pub const DeviceSize = enum(u32) {
+    whole = std.math.maxInt(u32),
+    _,
+
+    pub fn size(value: u32) DeviceSize {
+        return @enumFromInt(value);
+    }
+};
+
+pub const ImageArrayLayer = enum(u8) {
+    // zig fmt: off
+    @"0", @"1", @"2", @"3", @"4", @"5", @"6", @"7",
+    // zig fmt: on
+
+    pub fn layer(index: u3) ImageArrayLayer {
+        return @enumFromInt(index);
+    }
+};
+
+pub const ImageArrayLayers = enum(u8) {
+    remaining = std.math.maxInt(u8),
+    // zig fmt: off
+    @"1" = 1, @"2", @"3", @"4", @"5", @"6", @"7", @"8",
+    // zig fmt: on
+
+    pub fn layers(amount: u3) ImageArrayLayers {
+        return @enumFromInt(amount);
+    }
+};
+
+pub const ImageMipLevel = enum(u8) {
+    // zig fmt: off
+    @"0", @"1", @"2", @"3", @"4", @"5", @"6", @"7",
+    // zig fmt: on
+
+    pub fn level(index: u3) ImageMipLevel {
+        return @enumFromInt(index);
+    }
+};
+
+pub const ImageMipLevels = enum(u8) {
+    remaining = std.math.maxInt(u8),
+    // zig fmt: off
+    @"1" = 1, @"2", @"3", @"4", @"5", @"6", @"7", @"8",
+    // zig fmt: on
+
+    pub fn levels(amount: u3) ImageArrayLayers {
+        return @enumFromInt(amount);
+    }
+};
+
+pub const Offset2D = extern struct { x: u16, y: u16 };
+pub const Extent2D = extern struct { width: u16, height: u16 };
+pub const Rect2D = extern struct { offset: Offset2D, extent: Extent2D };
+pub const ColorComponentFlags = packed struct(u8) {
+    pub const rgba: ColorComponentFlags = .{ .r_enable = true, .g_enable = true, .b_enable = true, .a_enable = true };
+    pub const rgb: ColorComponentFlags = .{ .r_enable = true, .g_enable = true, .b_enable = true };
+    pub const rg: ColorComponentFlags = .{ .r_enable = true, .g_enable = true };
+    pub const r: ColorComponentFlags = .{ .r_enable = true };
+
+    r_enable: bool = false,
+    g_enable: bool = false,
+    b_enable: bool = false,
+    a_enable: bool = false,
+    _: u4 = 0,
+};
+
+pub const PresentMode = enum(u8) {
+    mailbox,
+    fifo,
+};
+
+pub const QueueFamily = enum(u8) {
+    fill,
+    transfer,
+    submit,
+    present,
+};
+
+/// The 3DS always has 3 heaps.
+///     - FCRAM
+///     - VRAM (A, 3MiB always)
+///     - VRAM (B, 3MiB always)
+pub const MemoryHeap = extern struct {
+    pub const Flags = packed struct(u8) {
+        /// Access of this memory by the GPU *will* be faster
+        device_local: bool,
+        _: u7 = false,
+    };
+
+    size: DeviceSize,
+    flags: Flags,
+};
+
+pub const MemoryHeapIndex = enum(u8) {
+    fcram,
+    vram_a,
+    vram_b,
+};
+
+pub const KnownMemoryType = enum(u8) {
+    fcram_cached,
+    vram_a,
+    vram_b,
+};
+
+pub const MemoryType = extern struct {
+    pub const Flags = packed struct(u8) {
+        /// The memory is the most efficient to be accessed by the GPU. Set if and only if the heap is `device_local`.
+        device_local: bool,
+        /// The memory can be accessed by the host via `mapMemory` and `unmapMemory`.
+        host_visible: bool,
+        /// The memory must be flushed and invalidated via `flushMappedMemoryRanges` and `invalidateMappedMemoryRanges`.
+        host_cached: bool,
+        /// NOTE: Seems it's not supported by the Horizon kernel unless specified in the exheader, see https://github.com/LumaTeam/Luma3DS/issues/2166.
+        /// 3DSX homebrew loaded by Luma will have RO (coherent it seems?) VRAM access
+        host_coherent: bool,
+        _: u4 = 0,
+    };
+
+    heap_index: MemoryHeapIndex,
+    flags: Flags,
+};
+
+pub const MemoryAllocateInfo = extern struct {
+    allocation_size: DeviceSize,
+    memory_type: KnownMemoryType,
+};
+
+pub const MappedMemoryRange = extern struct {
+    memory: DeviceMemory,
+    offset: DeviceSize,
+    size: DeviceSize,
+};
+
+// Don't overlap ImageView formats with AttributeBuffer ones!
+// They're used for space optimization.
+pub const Format = enum(u8) {
+    undefined,
+
+    // ImageView Supported Formats. Could be unsupported depending on usage.
+    r5g6b5_unorm_pack16,
+    r5g5b5a1_unorm_pack16,
+    r4g4b4a4_unorm_pack16,
+
+    g8r8_unorm,
+    b8g8r8_unorm,
+    a8b8g8r8_unorm,
+
+    d16_unorm,
+    d24_unorm,
+    d24_unorm_s8_uint,
+    d24_unorm_i8_unorm,
+
+    i4_unorm,
+    a4_unorm,
+    i4a4_unorm,
+
+    i8_unorm,
+    a8_unorm,
+    i8a8_unorm,
+
+    etc1_unorm,
+    etc1a4_unorm,
+
+    // Attribute Input Supported Formats
+    r8_uscaled,
+    r8_sscaled,
+    r16_sscaled,
+    r32_sfloat,
+
+    r8g8_uscaled,
+    r8g8_sscaled,
+    r16g16_sscaled,
+    r32g32_sfloat,
+
+    r8g8b8_uscaled,
+    r8g8b8_sscaled,
+    r16g16b16_sscaled,
+    r32g32b32_sfloat,
+
+    r8g8b8a8_uscaled,
+    r8g8b8a8_sscaled,
+    r16g16b16a16_sscaled,
+    r32g32b32a32_sfloat,
+
+    pub fn scale(format: Format, size: usize) usize {
+        return switch (format) {
+            .r5g6b5_unorm_pack16,
+            .r5g5b5a1_unorm_pack16,
+            .r4g4b4a4_unorm_pack16,
+            .g8r8_unorm,
+            .d16_unorm,
+            .i8a8_unorm,
+            => size << 1,
+
+            .b8g8r8_unorm,
+            .d24_unorm,
+            => size * 3,
+
+            .a8b8g8r8_unorm,
+            .d24_unorm_s8_uint,
+            .d24_unorm_i8_unorm,
+            => size << 2,
+
+            .i4a4_unorm,
+            .i8_unorm,
+            .a8_unorm,
+            .etc1a4_unorm,
+            => size,
+
+            .i4_unorm,
+            .a4_unorm,
+            .etc1_unorm,
+            => size >> 1,
+
+            .undefined,
+            .r8_uscaled,
+            .r8_sscaled,
+            .r16_sscaled,
+            .r32_sfloat,
+            .r8g8_uscaled,
+            .r8g8_sscaled,
+            .r16g16_sscaled,
+            .r32g32_sfloat,
+            .r8g8b8_uscaled,
+            .r8g8b8_sscaled,
+            .r16g16b16_sscaled,
+            .r32g32b32_sfloat,
+            .r8g8b8a8_uscaled,
+            .r8g8b8a8_sscaled,
+            .r16g16b16a16_sscaled,
+            .r32g32b32a32_sfloat,
+            => unreachable,
+        };
+    }
+
+    pub fn nativeColorFormat(fmt: Format) pica.ColorFormat {
+        return switch (fmt) {
+            .a8b8g8r8_unorm => .abgr8888,
+            .b8g8r8_unorm => .bgr888,
+            .r5g6b5_unorm_pack16 => .rgb565,
+            .r5g5b5a1_unorm_pack16 => .rgba5551,
+            .r4g4b4a4_unorm_pack16 => .rgba4444,
+            else => unreachable,
+        };
+    }
+
+    pub fn nativeDepthStencilFormat(fmt: Format) pica.DepthStencilFormat {
+        return switch (fmt) {
+            .d16_unorm => .d16,
+            .d24_unorm => .d24,
+            .d24_unorm_s8_uint => .d24_s8,
+            else => unreachable,
+        };
+    }
+
+    pub fn nativeVertexFormat(fmt: Format) pica.Graphics.PrimitiveEngine.Attribute.Format {
+        return switch (fmt) {
+            .r8_sscaled => .i8x1,
+            .r8_uscaled => .u8x1,
+            .r16_sscaled => .i16x1,
+            .r32_sfloat => .f32x1,
+
+            .r8g8_sscaled => .i8x2,
+            .r8g8_uscaled => .u8x2,
+            .r16g16_sscaled => .i16x2,
+            .r32g32_sfloat => .f32x2,
+
+            .r8g8b8_sscaled => .i8x3,
+            .r8g8b8_uscaled => .u8x3,
+            .r16g16b16_sscaled => .i16x3,
+            .r32g32b32_sfloat => .f32x3,
+
+            .r8g8b8a8_sscaled => .i8x4,
+            .r8g8b8a8_uscaled => .u8x4,
+            .r16g16b16a16_sscaled => .i16x4,
+            .r32g32b32a32_sfloat => .f32x4,
+            else => unreachable,
+        };
+    }
+
+    pub fn nativeTextureUnitFormat(fmt: Format) pica.TextureUnitFormat {
+        return switch (fmt) {
+            .g8r8_unorm => .hilo88,
+            .a8b8g8r8_unorm => .abgr8888,
+            .b8g8r8_unorm => .bgr888,
+            .r5g6b5_unorm_pack16 => .rgb565,
+            .r5g5b5a1_unorm_pack16 => .rgba5551,
+            .r4g4b4a4_unorm_pack16 => .rgba4444,
+            .i4_unorm => .i4,
+            .a4_unorm => .a4,
+            .i4a4_unorm => .ia44,
+            .i8_unorm => .i8,
+            .a8_unorm => .a8,
+            .i8a8_unorm => .ia88,
+            .etc1_unorm => .etc1,
+            .etc1a4_unorm => .etc1a4,
+            else => unreachable,
+        };
+    }
+
+    comptime {
+        std.debug.assert(@intFromEnum(Format.undefined) == 0);
+    }
+};
+
+pub const PrimitiveTopology = enum(u8) {
+    /// Specifies a series of separate triangle primitives.
+    /// The number of primitives generated is `(vertexCount / 3)`
+    triangle_list,
+    /// Specifies a series of connected triangle primitives with consecutive triangles sharing an edge.
+    /// The number of primitives generated is `max(0, vertexCount - 2)`
+    triangle_strip,
+    /// Specifies a series of connected triangle primitives with all triangles sharing a common vertex.
+    /// The number of primitives generated is `max(0, vertexCount - 2)`
+    triangle_fan,
+    /// Specifies a series of triangle primitives which are to be defined by the geometry shader.
+    /// The number of primitives generated depends on the shader implementation.
+    geometry,
+
+    pub fn native(topology: PrimitiveTopology) pica.PrimitiveTopology {
+        return switch (topology) {
+            .triangle_list => .triangle_list,
+            .triangle_strip => .triangle_strip,
+            .triangle_fan => .triangle_fan,
+            .geometry => .geometry,
+        };
+    }
+};
+
+pub const IndexType = enum(u8) {
+    /// Specifies that indices are unsigned 8-bit numbers.
+    u8,
+    /// Specifies that indices are unsigned 16-bit numbers.
+    u16,
+
+    pub fn native(fmt: IndexType) pica.IndexFormat {
+        return switch (fmt) {
+            .u8 => .u8,
+            .u16 => .u16,
+        };
+    }
+};
+
+pub const CompareOperation = enum(u8) {
+    never,
+    always,
+    eq,
+    neq,
+    lt,
+    le,
+    gt,
+    ge,
+
+    pub fn nativeEarlyDepth(op: CompareOperation) pica.EarlyDepthCompareOperation {
+        return switch (op) {
+            .ge => .ge,
+            .gt => .gt,
+            .le => .le,
+            .lt => .lt,
+            else => unreachable,
+        };
+    }
+
+    pub fn native(op: CompareOperation) pica.CompareOperation {
+        return switch (op) {
+            .never => .never,
+            .always => .always,
+            .eq => .eq,
+            .neq => .neq,
+            .lt => .lt,
+            .le => .le,
+            .gt => .gt,
+            .ge => .ge,
+        };
+    }
+};
+
+pub const StencilOperation = enum(u8) {
+    /// Keep the current value.
+    keep,
+    /// Sets the value to `0`.
+    zero,
+    /// Sets the value to `reference`.
+    replace,
+    /// Increments the current value and clamps to the maximum representable unsigned value.
+    increment,
+    /// Decrements the current value and clamps to `0`.
+    decrement,
+    /// Bitwise-inverts the current value.
+    invert,
+    /// Increments the current value and clamps to `0` when the maximum value would have exceeded.
+    increment_wrap,
+    /// Decrements the current value and clamps to the maximum possible value when the value would go below `0`.
+    decrement_wrap,
+
+    pub fn native(op: StencilOperation) pica.StencilOperation {
+        return switch (op) {
+            .keep => .keep,
+            .zero => .zero,
+            .replace => .replace,
+            .increment => .increment,
+            .decrement => .decrement,
+            .invert => .invert,
+            .increment_wrap => .increment_wrap,
+            .decrement_wrap => .decrement_wrap,
+        };
+    }
+};
+
+pub const LogicOperation = enum(u8) {
+    clear,
+    @"and",
+    reverse_and,
+    copy,
+    set,
+    copy_inverted,
+    nop,
+    invert,
+    nand,
+    @"or",
+    nor,
+    xor,
+    equivalent,
+    and_inverted,
+    or_reverse,
+    or_inverted,
+
+    pub fn native(op: LogicOperation) pica.LogicOperation {
+        return switch (op) {
+            .clear => .clear,
+            .@"and" => .@"and",
+            .reverse_and => .reverse_and,
+            .copy => .copy,
+            .set => .set,
+            .copy_inverted => .copy_inverted,
+            .nop => .nop,
+            .invert => .invert,
+            .nand => .nand,
+            .@"or" => .@"or",
+            .nor => .nor,
+            .xor => .xor,
+            .equivalent => .equivalent,
+            .and_inverted => .and_inverted,
+            .or_reverse => .or_reverse,
+            .or_inverted => .or_inverted,
+        };
+    }
+};
+
+pub const DepthMode = enum(u8) {
+    /// Precision is evenly distributed.
+    w_buffer,
+
+    /// Precision is higher close to the near plane.
+    z_buffer,
+
+    pub fn native(mode: DepthMode) Graphics.Rasterizer.DepthMap.Mode {
+        return switch (mode) {
+            .w_buffer => .w,
+            .z_buffer => .z,
+        };
+    }
+};
+
+pub const BlendOperation = enum(u8) {
+    /// `src_factor * src + dst_factor * dst`
+    add,
+    /// `src_factor * src - dst_factor * dst`
+    sub,
+    /// `dst_factor * dst - src_factor * src`
+    reverse_sub,
+    /// `min(src_factor * src, dst_factor * dst)`
+    min,
+    /// `max(src_factor * src, dst_factor * dst)`
+    max,
+
+    pub fn native(op: BlendOperation) pica.BlendOperation {
+        return switch (op) {
+            .add => .add,
+            .sub => .sub,
+            .reverse_sub => .reverse_sub,
+            .min => .min,
+            .max => .max,
+        };
+    }
+};
+
+pub const BlendFactor = enum(u8) {
+    zero,
+    one,
+    src_color,
+    one_minus_src_color,
+    dst_color,
+    one_minus_dst_color,
+    src_alpha,
+    one_minus_src_alpha,
+    dst_alpha,
+    one_minus_dst_alpha,
+    constant_color,
+    one_minus_constant_color,
+    constant_alpha,
+    one_minus_constant_alpha,
+    src_alpha_saturate,
+
+    pub fn native(factor: BlendFactor) pica.BlendFactor {
+        return switch (factor) {
+            .zero => .zero,
+            .one => .one,
+            .src_color => .src_color,
+            .one_minus_src_color => .one_minus_src_color,
+            .dst_color => .dst_color,
+            .one_minus_dst_color => .one_minus_dst_color,
+            .src_alpha => .src_alpha,
+            .one_minus_src_alpha => .one_minus_src_alpha,
+            .dst_alpha => .dst_alpha,
+            .one_minus_dst_alpha => .one_minus_dst_alpha,
+            .constant_color => .constant_color,
+            .one_minus_constant_color => .one_minus_constant_color,
+            .constant_alpha => .constant_alpha,
+            .one_minus_constant_alpha => .one_minus_constant_alpha,
+            .src_alpha_saturate => .src_alpha_saturate,
+        };
+    }
+};
+
+pub const ColorBlendEquation = extern struct {
+    src_color_factor: BlendFactor,
+    dst_color_factor: BlendFactor,
+    color_op: BlendOperation,
+    src_alpha_factor: BlendFactor,
+    dst_alpha_factor: BlendFactor,
+    alpha_op: BlendOperation,
+
+    pub fn native(equation: ColorBlendEquation) Graphics.OutputMerger.BlendConfig {
+        return .{
+            .color_op = equation.color_op.native(),
+            .alpha_op = equation.alpha_op.native(),
+            .src_color_factor = equation.src_color_factor.native(),
+            .dst_color_factor = equation.dst_color_factor.native(),
+            .src_alpha_factor = equation.src_alpha_factor.native(),
+            .dst_alpha_factor = equation.dst_alpha_factor.native(),
+        };
+    }
+};
+
+pub const TextureCombinerSource = enum(u8) {
+    primary_color,
+    fragment_primary_color,
+    fragment_secondary_color,
+    texture_0,
+    texture_1,
+    texture_2,
+    texture_3,
+    previous_buffer = 0xD,
+    constant,
+    previous,
+
+    pub fn native(src: TextureCombinerSource) pica.Graphics.TextureCombiners.Source {
+        return switch (src) {
+            .primary_color => .primary_color,
+            .fragment_primary_color => .fragment_primary_color,
+            .fragment_secondary_color => .fragment_secondary_color,
+            .texture_0 => .texture_0,
+            .texture_1 => .texture_1,
+            .texture_2 => .texture_2,
+            .texture_3 => .texture_3,
+            .previous_buffer => .previous_buffer,
+            .constant => .constant,
+            .previous => .previous,
+        };
+    }
+};
+
+pub const TextureCombinerColorFactor = enum(u8) {
+    src_color,
+    one_minus_src_color,
+    src_alpha,
+    one_minus_src_alpha,
+    src_red,
+    one_minus_src_red,
+    src_green = 8,
+    one_minus_src_green,
+    src_blue = 12,
+    one_minus_src_blue,
+
+    pub fn native(factor: TextureCombinerColorFactor) pica.Graphics.TextureCombiners.ColorFactor {
+        return switch (factor) {
+            .src_color => .src_color,
+            .one_minus_src_color => .one_minus_src_color,
+            .src_alpha => .src_alpha,
+            .one_minus_src_alpha => .one_minus_src_alpha,
+            .src_red => .src_red,
+            .one_minus_src_red => .one_minus_src_red,
+            .src_green => .src_green,
+            .one_minus_src_green => .one_minus_src_green,
+            .src_blue => .src_blue,
+            .one_minus_src_blue => .one_minus_src_blue,
+        };
+    }
+};
+
+pub const TextureCombinerAlphaFactor = enum(u8) {
+    src_alpha,
+    one_minus_src_alpha,
+    src_red,
+    one_minus_src_red,
+    src_green,
+    one_minus_src_green,
+    src_blue,
+    one_minus_src_blue,
+
+    pub fn native(factor: TextureCombinerAlphaFactor) pica.Graphics.TextureCombiners.AlphaFactor {
+        return switch (factor) {
+            .src_alpha => .src_alpha,
+            .one_minus_src_alpha => .one_minus_src_alpha,
+            .src_red => .src_red,
+            .one_minus_src_red => .one_minus_src_red,
+            .src_green => .src_green,
+            .one_minus_src_green => .one_minus_src_green,
+            .src_blue => .src_blue,
+            .one_minus_src_blue => .one_minus_src_blue,
+        };
+    }
+};
+
+pub const TextureCombinerOperation = enum(u8) {
+    /// `src0`
+    replace,
+    /// `src0 * src1`
+    modulate,
+    /// `src0 + src1`
+    add,
+    /// `src0 + src1 - 0.5`
+    add_signed,
+    /// `src0 * src2 + src1 * (1 - src2)`
+    interpolate,
+    /// `src0 - src1`
+    subtract,
+    /// `4 * ((src0r − 0.5) * (src1r − 0.5) + (src0g − 0.5) * (src1g − 0.5) + (src0b − 0.5) * (src1b − 0.5))`
+    dot3_rgb,
+    /// `4 * ((src0r − 0.5) * (src1r − 0.5) + (src0g − 0.5) * (src1g − 0.5) + (src0b − 0.5) * (src1b − 0.5))`
+    dot3_rgba,
+    /// `src0 * src1 + src2` (?)
+    multiply_add,
+    /// `src0 + src1 * src2` (?)
+    add_multiply,
+
+    pub fn native(op: TextureCombinerOperation) pica.Graphics.TextureCombiners.Operation {
+        return switch (op) {
+            .replace => .replace,
+            .modulate => .modulate,
+            .add => .add,
+            .add_signed => .add_signed,
+            .interpolate => .interpolate,
+            .subtract => .subtract,
+            .dot3_rgb => .dot3_rgb,
+            .dot3_rgba => .dot3_rgba,
+            .multiply_add => .multiply_add,
+            .add_multiply => .add_multiply,
+        };
+    }
+};
+
+pub const Multiplier = enum(u8) {
+    // zig fmt: off
+    @"1x", @"2x", @"4x", @"8x", @"0.25x", @"0.5x",
+    // zig fmt: on
+
+    pub fn nativeTextureCombinerMultiplier(multiplier: Multiplier) pica.Graphics.TextureCombiners.Multiplier {
+        return switch (multiplier) {
+            .@"1x" => .@"1x",
+            .@"2x" => .@"2x",
+            .@"4x" => .@"4x",
+            else => unreachable,
+        };
+    }
+
+    pub fn nativeLightLookupMultiplier(multiplier: Multiplier) Graphics.FragmentLighting.LookupTable.Multiplier {
+        return switch (multiplier) {
+            .@"1x" => .@"1x",
+            .@"2x" => .@"2x",
+            .@"4x" => .@"4x",
+            .@"8x" => .@"8x",
+            .@"0.5x" => .@"0.5x",
+            .@"0.25x" => .@"0.25x",
+        };
+    }
+};
+
+pub const TextureCombinerBufferSource = enum(u8) {
+    /// Use previous combiner buffer output as this combiner's buffer input
+    previous_buffer,
+    /// Use previous combiner output as this combiner's buffer input
+    previous,
+
+    pub fn native(buffer_source: TextureCombinerBufferSource) pica.Graphics.TextureCombiners.BufferSource {
+        return switch (buffer_source) {
+            .previous_buffer => .previous_buffer,
+            .previous => .previous,
+        };
+    }
+};
+
+pub const FrontFace = enum(u8) {
+    /// Triangles with a positive area are considered to be front-facing.
+    ccw,
+    /// Triangles with a negative area are considered to be front-facing.
+    cw,
+};
+
+pub const CullMode = enum(u8) {
+    /// No triangles are discarded.
+    none,
+    /// The front-facing triangles are culled.
+    front,
+    /// The back-facing triangles are culled.
+    back,
+
+    pub fn native(mode: CullMode, front: FrontFace) pica.CullMode {
+        return switch (mode) {
+            .none => .none,
+            .front => switch (front) {
+                .ccw => .ccw,
+                .cw => .cw,
+            },
+            .back => switch (front) {
+                .ccw => .cw,
+                .cw => .ccw,
+            },
+        };
+    }
+};
+
+pub const PipelineBindPoint = enum(u8) {
+    graphics,
+};
+
+pub const SwapchainCreateInfo = extern struct {
+    pub const ImageMemoryInfo = extern struct {
+        memory: DeviceMemory,
+        memory_offset: DeviceSize,
+    };
+
+    surface: Surface,
+    present_mode: PresentMode,
+    image_usage: ImageCreateInfo.Usage,
+    image_format: Format,
+    image_array_layers: ImageArrayLayers,
+    image_count: u8,
+    image_memory_info: [*]const ImageMemoryInfo,
+};
+
+pub const SemaphoreCreateInfo = extern struct {
+    /// Create a semaphore with an initial value of `0`
+    pub const initial_zero: SemaphoreCreateInfo = .{};
+
+    /// The initial value the semaphore will have.
+    initial_value: u64 = 0,
+};
+
+pub const QueryType = enum(u32) {
+    /// A single `u64` value, signifying a nanosecond-precision timestamp
+    timestamp,
+    /// GPU counters, see `QueryStatistics`
+    statistics,
+    // TODO: GPU performance counters
+    // performance_counter,
+};
+
+pub const QueryResultFlags = packed struct(u32) {
+    pub const none: QueryResultFlags = .{};
+    _: u32 = 0,
+};
+
+pub const QueryStatistics = packed struct(u32) {
+    input_assembly_vertices: bool = false,
+    input_assembly_primitives: bool = false,
+    rasterizer_primitives: bool = false,
+
+    non_vram_reads: bool = false,
+    non_vram_writes: bool = false,
+
+    vram_a_reads: bool = false,
+    vram_a_writes: bool = false,
+    vram_b_reads: bool = false,
+    vram_b_writes: bool = false,
+
+    input_assembly_reads: bool = false,
+    sampled_texture_reads: bool = false,
+
+    depth_buffer_reads: bool = false,
+    depth_buffer_writes: bool = false,
+
+    color_buffer_reads: bool = false,
+    color_buffer_writes: bool = false,
+
+    top_lcd_reads: bool = false,
+    bottom_lcd_reads: bool = false,
+
+    memory_copy_reads: bool = false,
+    memory_copy_writes: bool = false,
+    memory_fill_0_writes: bool = false,
+    memory_fill_1_writes: bool = false,
+
+    cpu_vram_reads: bool = false,
+    cpu_vram_writes: bool = false,
+    _: u9 = 0,
+
+    pub fn anyTraffic(statistics: QueryStatistics) bool {
+        return (@as(u32, @bitCast(statistics)) >> 3) != 0;
+    }
+
+    pub fn anyRasterizer(statistics: QueryStatistics) bool {
+        return (@as(u32, @bitCast(statistics)) & 0b111) != 0;
+    }
+};
+
+pub const QueryPoolCreateInfo = extern struct {
+    count: u32,
+    type: QueryType,
+    statistics: QueryStatistics,
+};
+
+pub const CommandPoolCreateInfo = extern struct {
+    /// Create a command pool without preheating it.
+    pub const no_preheat: CommandPoolCreateInfo = .{};
+
+    /// Amount of command buffers to preallocate internally.
+    initial_command_buffers: u32 = 0,
+};
+
+pub const CommandBufferAllocateInfo = extern struct {
+    pool: CommandPool,
+    command_buffer_count: u32,
+};
+
+pub const CommandBufferResetFlags = packed struct(u8) {
+    pub const none: CommandBufferResetFlags = .{};
+
+    /// Release underlying native memory resources to the pool.
+    /// If not set the command buffer may hold onto resources
+    /// and reuse them after being reset.
+    release_resources: bool = false,
+    _: u7 = 0,
+};
+
+pub const BufferCreateInfo = extern struct {
+    pub const Usage = packed struct(u8) {
+        /// Specifies that the buffer can be used as the source of a transfer operation.
+        transfer_src: bool = false,
+        /// Specifies that the buffer can be used as the destination of a transfer operation.
+        transfer_dst: bool = false,
+        /// Specifies that the buffer can be used as an index buffer.
+        index_buffer: bool = false,
+        /// Specifies that the buffer can be used as a vertex buffer.
+        vertex_buffer: bool = false,
+        _: u4 = 0,
+    };
+
+    size: DeviceSize,
+    usage: Usage,
+};
+
+pub const ImageCreateInfo = extern struct {
+    pub const Type = enum(u8) {
+        @"2d",
+    };
+
+    pub const Tiling = enum(u8) {
+        /// The images are tiled in a PICA200 specific format (8x8 or 32x32 tiles).
+        optimal,
+        /// The images are linearly stored.
+        linear,
+    };
+
+    pub const Usage = packed struct(u8) {
+        /// Specifies that the image can be used as the source of a transfer operation.
+        transfer_src: bool = false,
+        /// Specifies that the image can be used as the destination of a transfer operation.
+        transfer_dst: bool = false,
+        /// Specifies that the image can be used to create an ImageView suitable for binding with a sampler.
+        sampled: bool = false,
+        /// Specifies that the image can be used to create an ImageView suitable for use as a color attachment.
+        color_attachment: bool = false,
+        /// Specifies that the image can be used to create an ImageView suitable for use as a depth-stencil attachment.
+        depth_stencil_attachment: bool = false,
+        /// Specifies that the image can be used to create an ImageView suitable for use as a shadow attachment.
+        shadow_attachment: bool = false,
+        _: u2 = 0,
+    };
+
+    pub const Flags = packed struct(u8) {
+        /// Specifies that the image can be used to create an ImageView with a different format from the image.
+        mutable_format: bool = false,
+        /// Specifies that the image can be used to create an ImageView of type `cube`
+        cube_compatible: bool = false,
+        _: u6 = 0,
+    };
+
+    flags: Flags,
+    type: Type,
+    tiling: Tiling,
+    usage: Usage,
+    extent: Extent2D,
+    format: Format,
+    mip_levels: ImageMipLevels,
+    array_layers: ImageArrayLayers,
+};
+
+pub const ImageViewCreateInfo = extern struct {
+    pub const Type = enum(u8) {
+        @"2d",
+        cube,
+    };
+
+    type: Type,
+    format: Format,
+    image: Image,
+    subresource_range: ImageSubresourceRange,
+};
+
+pub const AddressMode = enum(u8) {
+    clamp_to_edge,
+    clamp_to_border,
+    repeat,
+    mirrored_repeat,
+
+    pub fn native(address_mode: AddressMode) pica.TextureUnitAddressMode {
+        return switch (address_mode) {
+            .clamp_to_edge => .clamp_to_edge,
+            .clamp_to_border => .clamp_to_border,
+            .repeat => .repeat,
+            .mirrored_repeat => .mirrored_repeat,
+        };
+    }
+};
+
+pub const Filter = enum(u8) {
+    nearest,
+    linear,
+
+    pub fn native(filter: Filter) pica.TextureUnitFilter {
+        return switch (filter) {
+            .nearest => .nearest,
+            .linear => .linear,
+        };
+    }
+};
+
+pub const SamplerCreateInfo = extern struct {
+    mag_filter: Filter,
+    min_filter: Filter,
+    mip_filter: Filter,
+    address_mode_u: AddressMode,
+    address_mode_v: AddressMode,
+    lod_bias: f32,
+    min_lod: u8,
+    max_lod: u8,
+    border_color: [4]u8,
+};
+
+pub const ShaderCodeType = enum(u8) {
+    psh,
+    _,
+};
+
+pub const ShaderCreateInfo = extern struct {
+    code_type: ShaderCodeType,
+    code: [*]const u8,
+    code_len: u32,
+
+    name: [*]const u8,
+    name_len: u32,
+
+    pub fn init(typ: ShaderCodeType, code: []const u8, name: []const u8) ShaderCreateInfo {
+        return .{
+            .code_type = typ,
+            .code = code.ptr,
+            .code_len = code.len,
+
+            .name = name.ptr,
+            .name_len = name.len,
+        };
+    }
+};
+
+pub const TextureCoordinateSource = enum(u8) {
+    @"0",
+    @"1",
+    @"2",
+
+    pub fn nativeTexture2(src: TextureCoordinateSource) pica.TextureUnitTexture2Coordinates {
+        return switch (src) {
+            .@"0" => unreachable,
+            .@"1" => .@"1",
+            .@"2" => .@"2",
+        };
+    }
+
+    pub fn nativeTexture3(src: TextureCoordinateSource) pica.TextureUnitTexture3Coordinates {
+        return switch (src) {
+            .@"0" => .@"0",
+            .@"1" => .@"1",
+            .@"2" => .@"2",
+        };
+    }
+};
+
+pub const ShaderStage = enum(u8) {
+    vertex,
+    geometry,
+};
+
+pub const Scissor = extern struct {
+    pub const Mode = enum(u8) {
+        /// The pixels outside the scissor area will be rendered.
+        outside,
+        /// The pixels inside the scissor area will be rendered.
+        inside,
+
+        pub fn native(mode: Mode) pica.ScissorMode {
+            return switch (mode) {
+                .outside => .outside,
+                .inside => .inside,
+            };
+        }
+    };
+
+    rect: Rect2D,
+    mode: Mode,
+
+    pub fn outside(rect: Rect2D) Scissor {
+        return .{ .rect = rect, .mode = .outside };
+    }
+
+    pub fn inside(rect: Rect2D) Scissor {
+        return .{ .rect = rect, .mode = .inside };
+    }
+};
+
+pub const Viewport = extern struct {
+    rect: Rect2D,
+    min_depth: f32,
+    max_depth: f32,
+};
+
+pub const VertexAttributeBinding = enum(u8) { @"0", @"1", @"2", @"3", @"4", @"5", @"6", @"7", @"8", @"9", @"10", @"11" };
+pub const VertexAttributeLocation = enum(u8) { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11 };
+
+pub const VertexInputFixedAttributeDescription = extern struct {
+    value: [4]f32,
+    location: VertexAttributeLocation,
+};
+
+pub const VertexInputAttributeDescription = extern struct {
+    location: VertexAttributeLocation,
+    binding: VertexAttributeBinding,
+    format: Format,
+    /// TODO: This has special requirements. Document them
+    offset: u8,
+};
+
+pub const VertexInputBindingDescription = extern struct {
+    stride: u8,
+};
+
+pub const VertexInputLayoutCreateInfo = extern struct {
+    bindings: [*]const VertexInputBindingDescription,
+    attributes: [*]const VertexInputAttributeDescription,
+    fixed_attributes: [*]const VertexInputFixedAttributeDescription,
+
+    bindings_len: u32,
+    attributes_len: u32,
+    fixed_attributes_len: u32,
+
+    pub fn init(bindings: []const VertexInputBindingDescription, attributes: []const VertexInputAttributeDescription, fixed_attributes: []const VertexInputFixedAttributeDescription) VertexInputLayoutCreateInfo {
+        return .{
+            .bindings = bindings.ptr,
+            .attributes = attributes.ptr,
+            .fixed_attributes = fixed_attributes.ptr,
+
+            .bindings_len = bindings.len,
+            .attributes_len = attributes.len,
+            .fixed_attributes_len = fixed_attributes.len,
+        };
+    }
+};
+
+pub const MultiDrawInfo = extern struct {
+    first_vertex: u32,
+    vertex_count: u32,
+};
+
+pub const MultiDrawIndexedInfo = extern struct {
+    first_index: u32,
+    index_count: u32,
+    vertex_offset: i32,
+};
+
+pub const RenderingInfo = extern struct {
+    color_attachment: ImageView,
+    depth_stencil_attachment: ImageView,
+};
+
+pub const CombinedImageSampler = extern struct {
+    pub const none: CombinedImageSampler = .{ .image = .null, .sampler = .null };
+
+    image: ImageView,
+    sampler: Sampler,
+};
+
+pub const TextureCombinerUnit = extern struct {
+    pub const BufferSources = extern struct {
+        pub const previous_buffer: BufferSources = .init(.previous_buffer, .previous_buffer);
+        pub const previous: BufferSources = .init(.previous, .previous);
+
+        color_buffer_src: TextureCombinerBufferSource,
+        alpha_buffer_src: TextureCombinerBufferSource,
+
+        pub fn init(color: TextureCombinerBufferSource, alpha: TextureCombinerBufferSource) BufferSources {
+            return .{
+                .color_buffer_src = color,
+                .alpha_buffer_src = alpha,
+            };
+        }
+    };
+
+    pub const previous: TextureCombinerUnit = .{
+        .color_src = @splat(.previous),
+        .alpha_src = @splat(.previous),
+        .color_factor = @splat(.src_color),
+        .alpha_factor = @splat(.src_alpha),
+        .color_op = .replace,
+        .alpha_op = .replace,
+        .color_scale = .@"1x",
+        .alpha_scale = .@"1x",
+        .constant = @splat(0),
+    };
+
+    color_src: [3]TextureCombinerSource,
+    alpha_src: [3]TextureCombinerSource,
+    color_factor: [3]TextureCombinerColorFactor,
+    alpha_factor: [3]TextureCombinerAlphaFactor,
+    color_op: TextureCombinerOperation,
+    alpha_op: TextureCombinerOperation,
+
+    /// Only 1x, 2x and 4x multipliers supported.
+    color_scale: Multiplier,
+    /// Only 1x, 2x and 4x multipliers supported.
+    alpha_scale: Multiplier,
+
+    constant: [4]u8,
+
+    pub fn native(combiner: TextureCombinerUnit) Graphics.TextureCombiners.Unit {
+        return .{
+            .sources = .{
+                .color_src = .init(.{ combiner.color_src[0].native(), combiner.color_src[1].native(), combiner.color_src[2].native() }),
+                .alpha_src = .init(.{ combiner.alpha_src[0].native(), combiner.alpha_src[1].native(), combiner.alpha_src[2].native() }),
+            },
+            .factors = .{
+                .color_factor = .init(.{ combiner.color_factor[0].native(), combiner.color_factor[1].native(), combiner.color_factor[2].native() }),
+                .alpha_factor = .init(.{ combiner.alpha_factor[0].native(), combiner.alpha_factor[1].native(), combiner.alpha_factor[2].native() }),
+            },
+            .operations = .{
+                .color = combiner.color_op.native(),
+                .alpha = combiner.alpha_op.native(),
+            },
+            .color = combiner.constant,
+            .scales = .{
+                .color = combiner.color_scale.nativeTextureCombinerMultiplier(),
+                .alpha = combiner.alpha_scale.nativeTextureCombinerMultiplier(),
+            },
+        };
+    }
+};
+
+pub const CopyBufferInfo = extern struct {
+    wait_semaphore: ?*const SemaphoreQueueOperation = null,
+    src_buffer: Buffer,
+    src_offset: DeviceSize,
+    dst_buffer: Buffer,
+    dst_offset: DeviceSize,
+    size: DeviceSize,
+    signal_semaphore: ?*const SemaphoreQueueOperation = null,
+};
+
+pub const BufferCopy = extern struct {
+    src_offset: DeviceSize,
+    dst_offset: DeviceSize,
+    size: DeviceSize,
+};
+
+pub const FillPatternType = enum(u8) { u16, u24, u32 };
+
+pub const FillBufferInfo = extern struct {
+    wait_semaphore: ?*const SemaphoreQueueOperation = null,
+    buffer: Buffer,
+    offset: DeviceSize,
+    size: DeviceSize,
+    pattern_type: FillPatternType,
+    pattern: u32,
+    signal_semaphore: ?*const SemaphoreQueueOperation = null,
+};
+
+pub const CopyBufferToImageInfo = extern struct {
+    wait_semaphore: ?*const SemaphoreQueueOperation = null,
+    src_buffer: Buffer,
+    src_offset: DeviceSize,
+    dst_image: Image,
+    dst_subresource: ImageSubresourceLayers,
+    signal_semaphore: ?*const SemaphoreQueueOperation = null,
+};
+
+pub const BlitImageInfo = extern struct {
+    wait_semaphore: ?*const SemaphoreQueueOperation = null,
+    src_image: Image,
+    dst_image: Image,
+    src_subresource: ImageSubresourceLayers,
+    dst_subresource: ImageSubresourceLayers,
+    signal_semaphore: ?*const SemaphoreQueueOperation = null,
+};
+
+pub const ClearColorInfo = extern struct {
+    wait_semaphore: ?*const SemaphoreQueueOperation = null,
+    subresource_range: ImageSubresourceRange,
+    image: Image,
+    color: [4]u8,
+    signal_semaphore: ?*const SemaphoreQueueOperation = null,
+};
+
+pub const ClearDepthStencilInfo = extern struct {
+    wait_semaphore: ?*const SemaphoreQueueOperation = null,
+    subresource_range: ImageSubresourceRange,
+    image: Image,
+    depth: f32,
+    stencil: u8,
+    signal_semaphore: ?*const SemaphoreQueueOperation = null,
+};
+
+pub const SubmitInfo = extern struct {
+    wait_semaphore: ?*const SemaphoreQueueOperation = null,
+    command_buffer: CommandBuffer,
+    signal_semaphore: ?*const SemaphoreQueueOperation = null,
+};
+
+pub const ImageSubresourceRange = extern struct {
+    pub const full: ImageSubresourceRange = .{
+        .base_mip_level = .@"0",
+        .level_count = .remaining,
+        .base_array_layer = .@"0",
+        .layer_count = .remaining,
+    };
+
+    base_mip_level: ImageMipLevel,
+    level_count: ImageMipLevels,
+    base_array_layer: ImageArrayLayer,
+    layer_count: ImageArrayLayers,
+};
+
+pub const ImageSubresourceLayers = extern struct {
+    pub const full: ImageSubresourceLayers = .{
+        .mip_level = .@"0",
+        .base_array_layer = .@"0",
+        .layer_count = .remaining,
+    };
+
+    mip_level: ImageMipLevel,
+    base_array_layer: ImageArrayLayer,
+    layer_count: ImageArrayLayers,
+};
+
+pub const PresentInfo = extern struct {
+    pub const Flags = packed struct(u8) {
+        /// Ignore the array layers of presented swapchain images and present it as a non-stereoscopic image.
+        ignore_stereoscopic: bool = false,
+        _: u7 = 0,
+    };
+
+    wait_semaphore: ?*const SemaphoreQueueOperation = null,
+    swapchain: Swapchain,
+    image_index: u8,
+    flags: Flags,
+};
+
+pub const SemaphoreQueueOperation = extern struct {
+    value: u64,
+    semaphore: Semaphore,
+
+    pub fn init(semaphore: Semaphore, value: u64) SemaphoreQueueOperation {
+        return .{
+            .semaphore = semaphore,
+            .value = value,
+        };
+    }
+};
+
+pub const SemaphoreWaitInfo = extern struct {
+    semaphore_count: u32,
+    semaphores: [*]const Semaphore,
+    values: [*]const u64,
+
+    pub fn init(semaphores: []const Semaphore, values: []const u64) SemaphoreWaitInfo {
+        std.debug.assert(semaphores.len == values.len);
+
+        return .{
+            .semaphore_count = semaphores.len,
+            .semaphores = semaphores.ptr,
+            .values = values.ptr,
+        };
+    }
+};
+
+pub const SemaphoreSignalInfo = extern struct {
+    semaphore: Semaphore,
+    value: u64,
+};
+
+// So here's how mango somewhat *abstracts* the fragment lighting stage
+// of the PICA200:
+//
+// We divide each section into Per-Light and Per-Environment, as each light
+// has associated state which is inherently dynamic per-object or per-frame.
+//
+// The environment *could* be dynamic (and it is!) to a certain extent but it
+// benefits greatly from being static if it can (maybe you don't need lighting
+// or you only need a single configuration across a frame or pipeline).
+//
+// However as you may need to scale LUT outputs, *that* is also made dynamic
+// and should be the first thing you'd use.
+//
+// Lights obviously are dynamic per-frame and like textures are inherently
+// resources.
+//
+// Light factors however *are* per-object and not per-frame, each different model
+// may have a different material and you *need* to change them.
+
+pub const LightLookupRange = enum(u8) {
+    /// `[-1.0, 1.0]`
+    full,
+    /// `[0.0,  1.0]`
+    positive,
+};
+
+pub const LightLookupTableCreateInfo = extern struct {
+    /// A function which maps an input value *x* to its factor.
+    ///
+    /// If `null`, context is an array of *257* `f32` factors.
+    map: ?*const fn (?*anyopaque, f32) callconv(.c) f32,
+    /// If `map` is not null, this is the context passed to it.
+    ///
+    /// Otherwise it must an array of *257* `f32` factors.
+    context: ?*anyopaque,
+    /// Whether the input domain of the lookup table is `[0.0, 1.0]`
+    /// or `[-1.0, 1.0]`.
+    range: LightLookupRange,
+};
+
+pub const LightLookupInput = enum(u8) {
+    @"N * H",
+    @"V * H",
+    @"N * V",
+    @"L * N",
+    @"-L * P",
+    @"cos(phi)",
+
+    pub fn native(input: LightLookupInput) Graphics.FragmentLighting.LookupTable.Input {
+        return switch (input) {
+            .@"N * H" => .@"N * H",
+            .@"V * H" => .@"V * H",
+            .@"N * V" => .@"N * V",
+            .@"L * N" => .@"L * N",
+            .@"-L * P" => .@"-L * P",
+            .@"cos(phi)" => .@"cos(phi)",
+        };
+    }
+};
+
+pub const LightFresnelSelector = enum(u8) {
+    none,
+    primary,
+    secondary,
+    both,
+
+    pub fn native(selector: LightFresnelSelector) Graphics.FragmentLighting.FresnelSelector {
+        return switch (selector) {
+            .none => .none,
+            .primary => .primary,
+            .secondary => .secondary,
+            .both => .both,
+        };
+    }
+};
+
+pub const LightEnvironmentFactors = extern struct {
+    /// Ambient color of the entire environment.
+    ambient: [3]u8,
+};
+
+pub const LightEnvironmentLookupSlot = enum(u8) { d0, d1, rr, rg, rb, fr };
+pub const LightLookupSlot = enum(u8) { da, sp };
+
+pub const LightEnvironmentEnable = extern struct {
+    distribution: [2]bool = @splat(false),
+    reflection: [3]bool = @splat(false),
+    fresnel: LightFresnelSelector = .none,
+    /// It is forbidden to bind lights with spotlight parameters
+    /// when they are disabled.
+    spotlight: bool = false,
+
+    pub fn nativeEnabledLookupTables(enable: LightEnvironmentEnable) Graphics.FragmentLighting.LookupTable.Enabled {
+        const extended_reflection = enable.reflection[1] or enable.reflection[2];
+
+        // XXX: I don't really like this but this should NOT be a hot path.
+        return if (extended_reflection)
+            if (enable.distribution[1] and enable.fresnel != .none)
+                .all
+            else if (enable.distribution[1])
+                .d0_d1_rx_sp_da
+            else
+                .d0_fr_rx_sp_da
+        else if (enable.fresnel != .none)
+            if (enable.distribution[0] and enable.distribution[1] and !enable.reflection[0] and !enable.spotlight)
+                .d0_d1_fr_da
+            else if (enable.distribution[0] or enable.distribution[1])
+                .d0_d1_fr_rr_sp_da
+            else
+                .fr_rr_sp_da
+        else if (enable.distribution[1] and !enable.spotlight)
+            .d0_d1_rr_da
+        else if (enable.distribution[1])
+            .d0_d1_rx_sp_da // NOTE: can use either d0_d1_rx_sp_da or d0_d1_fr_rr_sp_da
+        else
+            .d0_rr_sp_da;
+    }
+};
+
+pub const LightEnvironmentInput = extern struct {
+    distribution: [2]LightLookupInput = @splat(.@"N * H"),
+    reflection: [3]LightLookupInput = @splat(.@"N * H"),
+    fresnel: LightLookupInput = .@"N * H",
+    spotlight: LightLookupInput = .@"N * H",
+};
+
+pub const LightEnvironmentRange = extern struct {
+    distribution: [2]LightLookupRange = @splat(.positive),
+    reflection: [3]LightLookupRange = @splat(.positive),
+    fresnel: LightLookupRange = .positive,
+    spotlight: LightLookupRange = .positive,
+};
+
+pub const LightEnvironmentScale = extern struct {
+    distribution: [2]Multiplier = @splat(.@"1x"),
+    reflection: [3]Multiplier = @splat(.@"1x"),
+    fresnel: Multiplier = .@"1x",
+    spotlight: Multiplier = .@"1x",
+};
+
+pub const LightEnvironmentCreateInfo = extern struct {
+    // TODO: Investigate shadow state and add it here.
+
+    enable_distribution: [2]bool = @splat(false),
+    enable_reflection: [4]bool = @splat(false),
+    enable_fresnel: LightFresnelSelector = .none,
+    /// It is forbidden to bind lights with spotlight parameters
+    /// if they are disabled.
+    enable_spotlight: bool = false,
+
+    distribution_tables: [2]LightLookupTable = @splat(.null),
+    reflection_tables: [3]LightLookupTable = @splat(.null),
+    fresnel_table: LightLookupTable = .null,
+
+    distribution_inputs: [2]LightLookupInput = @splat(.@"N * H"),
+    distribution_ranges: [2]LightLookupRange = @splat(.positive),
+    distribution_scales: [2]Multiplier = @splat(.@"1x"),
+
+    reflection_inputs: [3]LightLookupInput = @splat(.@"N * H"),
+    reflection_ranges: [3]LightLookupRange = @splat(.positive),
+    reflection_scales: [3]Multiplier = @splat(.@"1x"),
+
+    fresnel_input: LightLookupInput = .@"N * H",
+    fresnel_range: LightLookupRange = .positive,
+    fresnel_scale: Multiplier = .@"1x",
+    fresnel_selector: LightFresnelSelector = .none,
+
+    spotlight_input: LightLookupInput = .@"N * H",
+    spotlight_range: LightLookupRange = .full,
+    spotlight_scale: Multiplier = .@"1x",
+};
+
+pub const LightFactors = extern struct {
+    /// Ambient color this light contributes.
+    ambient: [3]u8,
+
+    /// Diffuse / Lambertian coefficient of this light.
+    ///
+    /// Final contribution is `f(dot(L, N)) * diffuse`
+    /// where f decides whether to apply diffuse lighting
+    /// to one or both sides of the surface, L is the light
+    /// vector and N the surface normal.
+    diffuse: [3]u8,
+
+    /// Specular / Distribution coefficients of this light.
+    ///
+    /// Final contribution is:
+    /// - 0 -> `D0 * specular[0] * G`
+    /// - 1 -> `D1 * specular[1] * G * Rx`
+    /// where *x* is a color channel.
+    specular: [2][3]u8,
+
+    /// Whether to light one or both sides of a surface.
+    sides: LightSides,
+
+    /// Whether to enable the Geometric factor
+    /// for each distribution table.
+    ///
+    /// If enabled `G = (L * N) / lengthSqr(L + N)`,
+    /// otherwise  `G = 1.0`.
+    geometric: LightGeometricFactor,
+};
+
+pub const LightType = enum(u8) {
+    /// The light has a position in space.
+    positional,
+    /// The light is infinitely far away and all
+    /// its rays follow a direction.
+    directional,
+
+    pub fn native(typ: LightType) Graphics.FragmentLighting.Light.Type {
+        return switch (typ) {
+            .positional => .positional,
+            .directional => .directional,
+        };
+    }
+};
+
+pub const LightSides = enum(u8) {
+    one,
+    both,
+
+    pub fn native(sides: LightSides) Graphics.FragmentLighting.Light.DiffuseSides {
+        return switch (sides) {
+            .one => .one,
+            .both => .both,
+        };
+    }
+};
+
+pub const LightGeometricFactor = enum(u8) {
+    none,
+    d0,
+    d1,
+    both,
+
+    pub fn native(factor: LightGeometricFactor) zitrus.hardware.BitpackedArray(bool, 2) {
+        return @bitCast(@as(u2, @intCast(@intFromEnum(factor))));
+    }
+};
+
+pub const Light = extern struct {
+    /// The position of the light if `type` is positional.
+    ///
+    /// Otherwise the direction of the light.
+    vector: [3]f32,
+    type: LightType,
+
+    /// Enable distance attenuation factor for this light.
+    ///
+    /// Ignored for directional lights.
+    enable_attenuation: bool = false,
+    /// Added to the distance after being multiplied with `attenuation_scale`.
+    attenuation_bias: f32 = 0.0,
+    /// Multiplied with the distance.
+    attenuation_scale: f32 = 0.0,
+    /// Lookup table providing coefficients with input range [0.0, 1.0].
+    /// It's input is `attenuation_scale` * distance + `attenuation_bias`.
+    ///
+    /// If the result is not in [0.0, 1.0] then the value `0.0` is used.
+    attenuation_table: LightLookupTable = .null,
+
+    /// Enable spotlight factor for this light.
+    /// *The light environment must have spotlights enabled*.
+    ///
+    /// Ignored for directional lights.
+    enable_spotlight: bool = false,
+    /// Spot direction of the light.
+    spotlight_direction: [3]f32 = @splat(0),
+    /// Lookup table providing the final spotlight factor, its input range
+    /// and input depends on `LightEnvironment`.
+    spotlight_table: LightLookupTable = .null,
+
+    /// Enables applying the shadow factor to this light.
+    enable_shadow: bool = false,
+};
+
+pub const AetherCtruDeviceCreateInfo = backend.AetherCtru.CreateInfo;
+
+/// Zig entrypoint for creating a device backed by Aether's libctru services.
+pub fn createAetherCtruBackedDevice(create_info: AetherCtruDeviceCreateInfo, gpa: std.mem.Allocator) !Device {
+    return (try backend.AetherCtru.create(create_info, gpa)).device.toHandle();
+}
+
+pub fn createAetherLinearVertexBuffer(gpa: std.mem.Allocator) !Buffer {
+    const buffer = try gpa.create(backend.Buffer);
+    buffer.* = .init(.{
+        .size = .size(0),
+        .usage = .{ .vertex_buffer = true },
+    });
+    return buffer.toHandle();
+}
+
+pub fn updateAetherLinearVertexBuffer(buffer: Buffer, ptr: [*]const u8, len: usize, physical: u32) void {
+    const virtual = @intFromPtr(ptr);
+    const byte_offset = virtual & 0xFFF;
+    std.debug.assert(byte_offset == (physical & 0xFFF));
+
+    backend.Buffer.fromHandleMutable(buffer).* = .{
+        .memory_info = .{
+            .virtual_page_shifted = @intCast(virtual >> 12),
+            .physical_page_shifted = @intCast(physical >> 12),
+            .byte_offset = @intCast(byte_offset),
+        },
+        .size = len,
+        .usage = .{ .vertex_buffer = true },
+    };
+}
+
+pub const Device = backend.Device.Handle;
+pub const Queue = backend.Queue.Handle;
+pub const DeviceMemory = backend.DeviceMemory.Handle;
+pub const Semaphore = backend.Semaphore.Handle;
+pub const Buffer = backend.Buffer.Handle;
+pub const Image = backend.Image.Handle;
+pub const ImageView = backend.ImageView.Handle;
+pub const Shader = backend.Shader.Handle;
+pub const QueryPool = backend.QueryPool.Handle;
+pub const CommandPool = backend.CommandPool.Handle;
+pub const CommandBuffer = backend.CommandBuffer.Handle;
+pub const VertexInputLayout = backend.VertexInputLayout.Handle;
+pub const Sampler = backend.Sampler.Handle;
+pub const Surface = backend.Surface.Handle;
+pub const Swapchain = backend.Swapchain.Handle;
+
+pub const LightLookupTable = backend.LightLookupTable.Handle;
+
+pub const ObjectCreationError = error{ ValidationFailed, OutOfMemory, Unexpected };
+pub const MapMemoryError = error{Unexpected};
+pub const FlushMemoryError = error{Unexpected};
+pub const InvalidateMemoryError = error{Unexpected};
+pub const BindMemoryError = error{Unexpected};
+pub const GetQueryResultsError = error{ NotReady, Unexpected };
+// TODO: Add error.DeviceLost on GPU hang.
+pub const AcquireNextImageError = error{ Timeout, Unexpected };
+pub const SignalSemaphoreError = error{Unexpected};
+pub const WaitSemaphoreError = error{ Timeout, Unexpected };
+pub const ReleaseDeviceError = error{Unexpected};
+pub const ReacquireDeviceError = error{Unexpected};
+pub const GetSwapchainImagesError = error{Unexpected};
+
+comptime {
+    _ = backend;
+}
+
+// NOTE: This is not pub as implementation details should not be exposed.
+const backend = @import("mango/backend.zig");
+
+const std = @import("std");
+const zitrus = @import("zitrus");
+const pica = zitrus.hardware.pica;
+
+const Graphics = pica.Graphics;
diff --git a/src/platform/3ds/mango/mango/Buffer.zig b/src/platform/3ds/mango/mango/Buffer.zig
new file mode 100644
index 0000000..40bcb08
--- /dev/null
+++ b/src/platform/3ds/mango/mango/Buffer.zig
@@ -0,0 +1,49 @@
+pub const Handle = enum(u32) {
+    null = 0,
+    _,
+};
+
+memory_info: DeviceMemory.BoundMemoryInfo,
+size: usize,
+usage: mango.BufferCreateInfo.Usage,
+
+pub fn init(create_info: mango.BufferCreateInfo) Buffer {
+    return .{
+        .memory_info = .empty,
+        .size = @intFromEnum(create_info.size),
+        .usage = create_info.usage,
+    };
+}
+
+pub fn sizeByAmount(buffer: Buffer, size: mango.DeviceSize, offset: mango.DeviceSize) usize {
+    return switch (size) {
+        .whole => blk: {
+            std.debug.assert(@intFromEnum(offset) <= buffer.size);
+            break :blk (buffer.size - @intFromEnum(offset));
+        },
+        _ => blk: {
+            std.debug.assert(@intFromEnum(offset) + @intFromEnum(size) <= buffer.size);
+            break :blk @intFromEnum(size);
+        },
+    };
+}
+
+pub fn toHandle(buffer: *Buffer) Handle {
+    return @enumFromInt(@intFromPtr(buffer));
+}
+
+pub fn fromHandleMutable(handle: Handle) *Buffer {
+    return @as(*Buffer, @ptrFromInt(@intFromEnum(handle)));
+}
+
+pub fn fromHandle(handle: Handle) Buffer {
+    return fromHandleMutable(handle).*;
+}
+
+const Buffer = @This();
+const backend = @import("backend.zig");
+const DeviceMemory = backend.DeviceMemory;
+
+const std = @import("std");
+const zitrus = @import("zitrus");
+const mango = zitrus.mango;
diff --git a/src/platform/3ds/mango/mango/CommandBuffer.zig b/src/platform/3ds/mango/mango/CommandBuffer.zig
new file mode 100644
index 0000000..ac01a19
--- /dev/null
+++ b/src/platform/3ds/mango/mango/CommandBuffer.zig
@@ -0,0 +1,1119 @@
+//! Records 3D commands to be submitted to the PICA200.
+//!
+//! As the PICA200 is limited to what it can do with 3D drawing commands,
+//! things like clearing an `Image` or copying data is done with the `Device`.
+//!
+//! ## Things to consider
+//!
+//! **mango** follows some assumptions about its state:
+//!
+//! * `config` (GPUREG_GEOSTAGE_CONFIG) and `config_2` (GPUREG_GEOSTAGE_CONFIG2) are
+//! initialized with `Drawing triangle elements` to `true` when binding a pipeline or changing primitive topology. Don't
+//! know the implications of this but currently works (Thanks DMP engineers!)
+//!
+//! * `primitive_config` (GPUREG_PRIMITIVE_CONFIG) is initialized to the primitive topology for `drawIndexed` (see `pica.PrimitiveTopology`)
+//! which means less register writes when using `drawIndexed` (which programs should use!).
+//!
+//! TODO: Document more assumptions made.
+
+pub const Handle = enum(u32) {
+    null = 0,
+    _,
+
+    pub fn begin(cmd: Handle) !void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.begin();
+    }
+
+    pub fn end(cmd: Handle) !void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.end();
+    }
+
+    pub fn bindShaders(cmd: Handle, stages: []const mango.ShaderStage, shaders: []const mango.Shader) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        b_cmd.bindShaders(stages, shaders);
+    }
+
+    pub fn bindVertexBuffersSlice(cmd: Handle, first_binding: u32, buffers: []const mango.Buffer, offsets: []const u32) void {
+        std.debug.assert(buffers.len == offsets.len);
+        return cmd.bindVertexBuffers(first_binding, buffers.len, buffers.ptr, offsets.ptr);
+    }
+
+    pub fn bindVertexBuffers(cmd: Handle, first_binding: u32, binding_count: u32, buffers: [*]const mango.Buffer, offsets: [*]const u32) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.bindVertexBuffers(first_binding, binding_count, buffers, offsets);
+    }
+
+    pub fn bindIndexBuffer(cmd: Handle, buffer: mango.Buffer, offset: u32, index_type: mango.IndexType) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.bindIndexBuffer(buffer, offset, index_type);
+    }
+
+    pub fn bindFloatUniforms(cmd: Handle, stage: mango.ShaderStage, first_uniform: u32, uniforms: []const [4]f32) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.bindFloatUniforms(stage, first_uniform, uniforms);
+    }
+
+    pub fn bindCombinedImageSamplers(cmd: Handle, first_combined: u32, combined_image_samplers: []const mango.CombinedImageSampler) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.bindCombinedImageSamplers(first_combined, combined_image_samplers);
+    }
+
+    pub fn setLightEnvironmentFactors(cmd: Handle, factors: mango.LightEnvironmentFactors) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setLightEnvironmentFactors(factors);
+    }
+
+    pub fn setLightsEnabled(cmd: Handle, first_light: u32, enable: []const bool) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setLightsEnabled(first_light, enable);
+    }
+
+    pub fn setLights(cmd: Handle, first_light: u32, lights: []const mango.Light) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setLights(first_light, lights);
+    }
+
+    pub fn setLightFactors(cmd: Handle, first_light: u32, light_factors: []const mango.LightFactors) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setLightFactors(first_light, light_factors);
+    }
+
+    pub fn bindLightTables(cmd: Handle, slot: mango.LightLookupSlot, first_light: u32, tables: []const mango.LightLookupTable) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.bindLightTables(slot, first_light, tables);
+    }
+
+    pub fn beginRendering(cmd: Handle, rendering_info: mango.RenderingInfo) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.beginRendering(rendering_info);
+    }
+
+    pub fn endRendering(cmd: Handle) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.endRendering();
+    }
+
+    pub fn draw(cmd: Handle, vertex_count: u32, first_vertex: u32) void {
+        return cmd.drawMultiSlice(&.{.{ .vertex_count = vertex_count, .first_vertex = first_vertex }});
+    }
+
+    pub fn drawMultiSlice(cmd: Handle, vertex_info: []const mango.MultiDrawInfo) void {
+        return cmd.drawMulti(vertex_info.len, vertex_info.ptr, @sizeOf(mango.MultiDrawInfo));
+    }
+
+    pub fn drawMulti(cmd: Handle, draw_count: u32, vertex_info: [*]const mango.MultiDrawInfo, stride: u32) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.drawMulti(draw_count, vertex_info, stride);
+    }
+
+    pub fn drawIndexed(cmd: Handle, index_count: u32, first_index: u32, vertex_offset: i32) void {
+        return cmd.drawMultiIndexedSlice(&.{.{ .first_index = first_index, .index_count = index_count, .vertex_offset = vertex_offset }});
+    }
+
+    pub fn drawMultiIndexedSlice(cmd: Handle, index_info: []const mango.MultiDrawIndexedInfo) void {
+        return cmd.drawMultiIndexed(index_info.len, index_info.ptr, @sizeOf(mango.MultiDrawIndexedInfo));
+    }
+
+    pub fn drawMultiIndexed(cmd: Handle, draw_count: u32, index_info: [*]const mango.MultiDrawIndexedInfo, stride: u32) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.drawMultiIndexed(draw_count, index_info, stride);
+    }
+
+    pub fn setDepthMode(cmd: Handle, mode: mango.DepthMode) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setDepthMode(mode);
+    }
+
+    pub fn setCullMode(cmd: Handle, cull_mode: mango.CullMode) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setCullMode(cull_mode);
+    }
+
+    pub fn setFrontFace(cmd: Handle, front_face: mango.FrontFace) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setFrontFace(front_face);
+    }
+
+    pub fn setPrimitiveTopology(cmd: Handle, primitive_topology: mango.PrimitiveTopology) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setPrimitiveTopology(primitive_topology);
+    }
+
+    pub fn setViewport(cmd: Handle, viewport: mango.Viewport) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setViewport(viewport);
+    }
+
+    pub fn setScissor(cmd: Handle, scissor: mango.Scissor) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setScissor(scissor);
+    }
+
+    pub fn setTextureCombiners(cmd: Handle, texture_combiners: []const mango.TextureCombinerUnit, texture_combiner_buffer_sources: []const mango.TextureCombinerUnit.BufferSources) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setTextureCombiners(texture_combiners, texture_combiner_buffer_sources);
+    }
+
+    pub fn setBlendEquation(cmd: Handle, blend_equation: mango.ColorBlendEquation) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setBlendEquation(blend_equation);
+    }
+
+    pub fn setColorWriteMask(cmd: Handle, write_mask: mango.ColorComponentFlags) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setColorWriteMask(write_mask);
+    }
+
+    pub fn setDepthTestEnable(cmd: Handle, enable: bool) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setDepthTestEnable(enable);
+    }
+
+    pub fn setDepthCompareOp(cmd: Handle, op: mango.CompareOperation) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setDepthCompareOp(op);
+    }
+
+    pub fn setDepthWriteEnable(cmd: Handle, enable: bool) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setDepthWriteEnable(enable);
+    }
+
+    pub fn setDepthBias(cmd: Handle, constant: f32) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        b_cmd.setDepthBias(constant);
+    }
+
+    pub fn setLogicOpEnable(cmd: Handle, enable: bool) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setLogicOpEnable(enable);
+    }
+
+    pub fn setLogicOp(cmd: Handle, logic_op: mango.LogicOperation) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setLogicOp(logic_op);
+    }
+
+    pub fn setAlphaTestEnable(cmd: Handle, enable: bool) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setAlphaTestEnable(enable);
+    }
+
+    pub fn setAlphaTestCompareOp(cmd: Handle, compare_op: mango.CompareOperation) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setAlphaTestCompareOp(compare_op);
+    }
+
+    pub fn setAlphaTestReference(cmd: Handle, reference: u8) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setAlphaTestReference(reference);
+    }
+
+    pub fn setStencilTestEnable(cmd: Handle, enable: bool) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setStencilTestEnable(enable);
+    }
+
+    pub fn setStencilOp(cmd: Handle, fail_op: mango.StencilOperation, pass_op: mango.StencilOperation, depth_fail_op: mango.StencilOperation, op: mango.CompareOperation) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setStencilOp(fail_op, pass_op, depth_fail_op, op);
+    }
+
+    pub fn setStencilCompareMask(cmd: Handle, compare_mask: u8) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setStencilCompareMask(compare_mask);
+    }
+
+    pub fn setStencilWriteMask(cmd: Handle, write_mask: u8) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setStencilWriteMask(write_mask);
+    }
+
+    pub fn setStencilReference(cmd: Handle, reference: u8) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setStencilReference(reference);
+    }
+
+    pub fn setTextureCoordinates(cmd: Handle, texture_2_coordinates: mango.TextureCoordinateSource, texture_3_coordinates: mango.TextureCoordinateSource) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.setTextureCoordinates(texture_2_coordinates, texture_3_coordinates);
+    }
+
+    pub fn setVertexInput(cmd: Handle, layout: mango.VertexInputLayout) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        b_cmd.setVertexInput(layout);
+    }
+
+    pub fn setAetherFog(cmd: Handle, enabled: bool, color: [4]u8, table: []const u32) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        b_cmd.setAetherFog(enabled, color, table);
+    }
+
+    pub fn setLightingEnable(cmd: Handle, enable: bool) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        b_cmd.setLightingEnable(enable);
+    }
+
+    pub fn setLightEnvironmentEnable(cmd: Handle, enable: mango.LightEnvironmentEnable) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        b_cmd.setLightEnvironmentEnable(enable);
+    }
+
+    pub fn setLightEnvironmentInput(cmd: Handle, input: mango.LightEnvironmentInput) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        b_cmd.setLightEnvironmentInput(input);
+    }
+
+    pub fn setLightEnvironmentRange(cmd: Handle, range: mango.LightEnvironmentRange) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        b_cmd.setLightEnvironmentRange(range);
+    }
+
+    pub fn setLightEnvironmentScale(cmd: Handle, scale: mango.LightEnvironmentScale) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        b_cmd.setLightEnvironmentScale(scale);
+    }
+
+    pub fn bindLightEnvironmentTable(cmd: Handle, slot: mango.LightEnvironmentLookupSlot, table: mango.LightLookupTable) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        b_cmd.bindLightEnvironmentTable(slot, table);
+    }
+
+    pub fn writeTimestamp(cmd: Handle, pool: mango.QueryPool, query: u32) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        b_cmd.writeTimestamp(pool, query);
+    }
+
+    pub fn beginQuery(cmd: Handle, pool: mango.QueryPool, query: u32) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        b_cmd.beginQuery(pool, query);
+    }
+
+    pub fn endQuery(cmd: Handle, pool: mango.QueryPool, query: u32) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        b_cmd.endQuery(pool, query);
+    }
+
+    pub fn reset(cmd: Handle, flags: mango.CommandBufferResetFlags) void {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(cmd);
+        return b_cmd.reset(flags);
+    }
+};
+
+pub const State = enum {
+    initial,
+    recording,
+    executable,
+    pending,
+    invalid,
+};
+
+pub const Scope = enum {
+    none,
+    render_pass,
+    immediate_draw,
+};
+
+pub const Error = error{OutOfMemory} || validation.Error;
+
+pub const operation = struct {
+    pub const Kind = enum(u3) {
+        graphics,
+        timestamp,
+        begin_query,
+        end_query,
+    };
+
+    // NOTE: as both address and size must be aligned to 16 bytes we can reuse some unused bits!
+    // This means this must always be aligned or UB will happen
+    pub const Node = packed struct(u32) {
+        /// Kind of THIS node, not the next one.
+        kind: Kind,
+        _: u1 = 0,
+        next: u28,
+
+        pub fn empty(kind: Kind) Node {
+            return .{ .kind = kind, .next = 0 };
+        }
+
+        pub fn nextPtr(node: Node) ?*Node {
+            return @ptrFromInt(@as(u32, node.next) << 4);
+        }
+    };
+
+    pub const Graphics = extern struct {
+        node: Node,
+        head: [*]align(16) const u32,
+        len: u32,
+    };
+
+    pub const Fill = extern struct {
+        pub const Size = pica.DisplayController.Framebuffer.Pixel.Size;
+
+        node: Node,
+        address: [*]align(16) u8,
+        value: u32,
+    };
+
+    pub const Copy = extern struct {
+        pub const Line = pica.PictureFormatter.Copy.Line;
+
+        node: Node,
+        src: [*]align(16) const u8,
+        dst: [*]align(16) u8,
+        src_line: Line,
+        dst_line: Line,
+        size: u32,
+    };
+
+    pub const Blit = extern struct {
+        pub const Dimensions = pica.PictureFormatter.Dimensions;
+        pub const Kind = enum(u2) { linear_tiled, tiled_linear, tiled_tiled };
+
+        node: Node,
+        src: [*]align(16) const u8,
+        dst: [*]align(16) u8,
+        src_dimensions: Dimensions,
+        dst_dimensions: Dimensions,
+    };
+
+    pub const Query = extern struct {
+        node: Node,
+        pool: *backend.QueryPool,
+        query: u32,
+    };
+};
+
+const Flags = packed struct(u8) {
+    pub const none: Flags = .{};
+
+    subsequent_emissions: bool = false,
+    drawcall_in_pass: bool = false,
+    _: u6 = 0,
+};
+
+const FogState = struct {
+    enabled: bool = false,
+    color: [4]u8 = .{ 0, 0, 0, 255 },
+    table: [128]u32 = @splat(0),
+    dirty: bool = true,
+};
+
+pool: *CommandPool,
+stream: Stream = .empty,
+
+// NOTE: no need to free these as they are embedded in the stream :p
+head: ?*operation.Node = null,
+last: ?*operation.Node = null,
+
+gfx_state: GraphicsState = .empty,
+rnd_state: RenderingState = .empty,
+current_error: ?Error = null,
+flags: Flags = .none,
+fog_state: FogState = .{},
+state: State = .initial,
+scope: Scope = .none,
+
+pub fn init(pool: *CommandPool) CommandBuffer {
+    return .{
+        .pool = pool,
+    };
+}
+
+pub fn deinit(cmd: *CommandBuffer) void {
+    defer cmd.* = undefined;
+    cmd.stream.deinit(cmd.pool.native_gpa);
+}
+
+pub fn begin(cmd: *CommandBuffer) !void {
+    std.debug.assert(cmd.state == .initial or cmd.state == .executable);
+    cmd.reset(.none);
+    cmd.state = .recording;
+}
+
+pub fn end(cmd: *CommandBuffer) !void {
+    std.debug.assert(cmd.state == .recording);
+
+    if (cmd.current_error) |err| {
+        cmd.state = .invalid;
+        return err;
+    }
+
+    cmd.finalizeCurrent() catch |err| {
+        cmd.state = .invalid;
+        cmd.current_error = err;
+        return err;
+    };
+
+    cmd.state = .executable;
+}
+
+pub fn reset(cmd: *CommandBuffer, flags: mango.CommandBufferResetFlags) void {
+    cmd.stream.reset(cmd.pool.native_gpa, if (flags.release_resources) .free_all else .retain_largest);
+    cmd.head = null;
+    cmd.last = null;
+    cmd.gfx_state = .empty;
+    cmd.rnd_state = .empty;
+    cmd.current_error = null;
+    cmd.flags = .none;
+    cmd.fog_state = .{};
+    cmd.scope = .none;
+    cmd.state = .initial;
+}
+
+pub fn bindShaders(cmd: *CommandBuffer, stages: []const mango.ShaderStage, shaders: []const mango.Shader) void {
+    cmd.gfx_state.bindShaders(stages, shaders);
+    cmd.rnd_state.bindShaders(stages, shaders);
+}
+
+pub fn bindVertexBuffers(cmd: *CommandBuffer, first_binding: u32, binding_count: u32, buffers: [*]const mango.Buffer, offsets: [*]const u32) void {
+    std.debug.assert(cmd.state == .recording);
+
+    return cmd.rnd_state.bindVertexBuffers(first_binding, binding_count, buffers, offsets);
+}
+
+pub fn bindIndexBuffer(cmd: *CommandBuffer, buffer: mango.Buffer, offset: u32, index_type: mango.IndexType) void {
+    std.debug.assert(cmd.state == .recording);
+
+    return cmd.rnd_state.bindIndexBuffer(buffer, offset, index_type);
+}
+
+pub fn bindFloatUniforms(cmd: *CommandBuffer, stage: mango.ShaderStage, first_uniform: u32, uniforms: []const [4]f32) void {
+    std.debug.assert(cmd.state == .recording);
+
+    return cmd.rnd_state.bindFloatUniforms(stage, first_uniform, uniforms);
+}
+
+pub fn bindCombinedImageSamplers(cmd: *CommandBuffer, first_combined: u32, combined_image_samplers: []const mango.CombinedImageSampler) void {
+    std.debug.assert(cmd.state == .recording);
+
+    return cmd.rnd_state.bindCombinedImageSamplers(first_combined, combined_image_samplers);
+}
+
+pub fn setLightEnvironmentFactors(cmd: *CommandBuffer, factors: mango.LightEnvironmentFactors) void {
+    std.debug.assert(cmd.state == .recording);
+
+    return cmd.rnd_state.setLightEnvironmentFactors(factors);
+}
+
+pub fn setLightsEnabled(cmd: *CommandBuffer, first_light: u32, enable: []const bool) void {
+    std.debug.assert(cmd.state == .recording);
+
+    return cmd.rnd_state.setLightsEnabled(first_light, enable);
+}
+
+pub fn setLights(cmd: *CommandBuffer, first_light: u32, lights: []const mango.Light) void {
+    std.debug.assert(cmd.state == .recording);
+
+    return cmd.rnd_state.setLights(first_light, lights);
+}
+
+pub fn setLightFactors(cmd: *CommandBuffer, first_light: u32, light_factors: []const mango.LightFactors) void {
+    std.debug.assert(cmd.state == .recording);
+
+    return cmd.rnd_state.setLightFactors(first_light, light_factors);
+}
+
+pub fn bindLightTables(cmd: *CommandBuffer, slot: mango.LightLookupSlot, first_light: u32, tables: []const mango.LightLookupTable) void {
+    std.debug.assert(cmd.state == .recording);
+
+    return cmd.rnd_state.bindLightTables(slot, first_light, tables);
+}
+
+pub fn beginRendering(cmd: *CommandBuffer, rendering_info: mango.RenderingInfo) void {
+    std.debug.assert(cmd.state == .recording);
+    std.debug.assert(cmd.scope == .none);
+    defer cmd.scope = .render_pass;
+
+    return cmd.rnd_state.beginRendering(rendering_info);
+}
+
+pub fn endRendering(cmd: *CommandBuffer) void {
+    std.debug.assert(cmd.state == .recording);
+    std.debug.assert(cmd.scope == .render_pass);
+    defer cmd.scope = .none;
+
+    const queue = cmd.stream.first().?;
+
+    if (cmd.flags.drawcall_in_pass) {
+        queue.add(p3d, &p3d.output_merger.flush, .init(.trigger));
+        cmd.flags.drawcall_in_pass = false;
+    }
+
+    return cmd.rnd_state.endRendering();
+}
+
+// TODO: beginShadowRendering, endShadowRendering for the shadow pass w/color op
+
+pub fn drawMulti(cmd: *CommandBuffer, draw_count: u32, vertex_info: [*]const mango.MultiDrawInfo, stride: u32) void {
+    std.debug.assert(cmd.state == .recording);
+    std.debug.assert(cmd.scope == .render_pass);
+
+    if (draw_count == 0) {
+        return;
+    }
+
+    std.debug.assert(stride >= @sizeOf(mango.MultiDrawInfo) and std.mem.isAligned(stride, 4));
+    std.debug.assertReadable(std.mem.asBytes(&vertex_info[0]));
+
+    if (!cmd.beforeDraw(draw_count)) {
+        return;
+    }
+
+    const queue = cmd.stream.first().?;
+
+    switch (cmd.gfx_state.misc.primitive_topology) {
+        .triangle_list => queue.addMasked(p3d, &p3d.primitive_engine.primitive_config, .{
+            .total_vertex_outputs = 0, // NOTE: Ignored by mask
+            .topology = cmd.gfx_state.misc.primitive_topology,
+        }, 0b0010),
+        else => {},
+    }
+    defer switch (cmd.gfx_state.misc.primitive_topology) {
+        .triangle_list => queue.addMasked(p3d, &p3d.primitive_engine.primitive_config, .{
+            .total_vertex_outputs = 0, // NOTE: Ignored by mask
+            .topology = cmd.gfx_state.misc.primitive_topology.indexedTopology(),
+        }, 0b0010),
+        else => {},
+    };
+
+    queue.add(p3d, &p3d.primitive_engine.mode, .init(.drawing));
+    defer queue.add(p3d, &p3d.primitive_engine.mode, .init(.config));
+
+    queue.addMasked(p3d, &p3d.primitive_engine.state, .{ .inputting_vertices_or_draw_arrays = true }, 0b0001);
+    defer queue.addMasked(p3d, &p3d.primitive_engine.state, .{ .inputting_vertices_or_draw_arrays = false }, 0b0001);
+
+    const first_draw = vertex_info[0];
+    queue.addIncremental(p3d, .{
+        &p3d.primitive_engine.attributes.index_buffer,
+        &p3d.primitive_engine.draw_vertex_count,
+    }, .{
+        .init(0x00, .u16), // NOTE: MUST be u16 for non-indexed draws
+        first_draw.vertex_count,
+    });
+
+    queue.add(p3d, &p3d.primitive_engine.draw_first_index, first_draw.first_vertex);
+    queue.add(p3d, &p3d.primitive_engine.restart_primitive, .init(.trigger));
+    queue.add(p3d, &p3d.primitive_engine.draw, .init(.trigger));
+    queue.add(p3d, &p3d.primitive_engine.clear_post_vertex_cache, .init(.trigger));
+
+    var last_vertex_info = first_draw;
+    var current_vertex_info_ptr: *const mango.MultiDrawInfo = @ptrCast(@alignCast(@as([*]const u8, @ptrCast(vertex_info)) + stride));
+
+    for (1..draw_count) |_| {
+        std.debug.assertReadable(std.mem.asBytes(current_vertex_info_ptr));
+
+        const current_vertex_info = current_vertex_info_ptr.*;
+
+        if (current_vertex_info.vertex_count != last_vertex_info.vertex_count) {
+            queue.add(p3d, &p3d.primitive_engine.draw_vertex_count, current_vertex_info.vertex_count);
+        }
+
+        if (current_vertex_info.first_vertex != last_vertex_info.first_vertex) {
+            queue.add(p3d, &p3d.primitive_engine.draw_first_index, current_vertex_info.first_vertex);
+        }
+
+        queue.add(p3d, &p3d.primitive_engine.restart_primitive, .init(.trigger));
+        queue.add(p3d, &p3d.primitive_engine.draw, .init(.trigger));
+        queue.add(p3d, &p3d.primitive_engine.clear_post_vertex_cache, .init(.trigger));
+
+        last_vertex_info = current_vertex_info;
+        current_vertex_info_ptr = @ptrCast(@alignCast(@as([*]const u8, @ptrCast(current_vertex_info_ptr)) + stride));
+    }
+
+    cmd.flags.drawcall_in_pass = true;
+}
+
+pub fn drawMultiIndexed(cmd: *CommandBuffer, draw_count: u32, index_info: [*]const mango.MultiDrawIndexedInfo, stride: u32) void {
+    std.debug.assert(cmd.state == .recording);
+    std.debug.assert(cmd.scope == .render_pass);
+
+    if (draw_count == 0) return;
+    std.debug.assert(stride >= @sizeOf(mango.MultiDrawIndexedInfo) and std.mem.isAligned(stride, 4));
+    std.debug.assertReadable(std.mem.asBytes(&index_info[0]));
+
+    if (!cmd.beforeDraw(draw_count)) {
+        return;
+    }
+
+    const queue = cmd.stream.first().?;
+    const dynamic_graphics_state = cmd.gfx_state;
+    const dynamic_rendering_state = cmd.rnd_state;
+
+    const first_draw = index_info[0];
+
+    queue.add(p3d, &p3d.primitive_engine.mode, .init(.drawing));
+    defer queue.add(p3d, &p3d.primitive_engine.mode, .init(.config));
+
+    queue.addIncremental(p3d, .{
+        &p3d.primitive_engine.attributes.index_buffer,
+        &p3d.primitive_engine.draw_vertex_count,
+    }, .{
+        .init(@intCast(dynamic_rendering_state.index_buffer_offset + first_draw.first_index), dynamic_rendering_state.misc.index_format),
+        first_draw.index_count,
+    });
+
+    if (first_draw.vertex_offset != 0) {
+        for (&dynamic_rendering_state.vertex_buffers_offset, &dynamic_graphics_state.vtx_input.buffer_config, 0..) |offset, buf_conf, i| {
+            const offset_from_bound: i32 = first_draw.vertex_offset * buf_conf.high.bytes_per_vertex;
+            const new_offset: u28 = @intCast(offset + offset_from_bound);
+
+            queue.add(p3d, &p3d.primitive_engine.attributes.vertex_buffers[i].offset, .init(new_offset));
+        }
+
+        cmd.rnd_state.dirty.vertex_buffers = true;
+    }
+
+    queue.add(p3d, &p3d.primitive_engine.restart_primitive, .init(.trigger));
+    queue.add(p3d, &p3d.primitive_engine.draw_indexed, .init(.trigger));
+    queue.add(p3d, &p3d.primitive_engine.clear_post_vertex_cache, .init(.trigger));
+
+    // NOTE: Seems to be needed, weird things happens if we don't write these?
+    queue.addMasked(p3d, &p3d.primitive_engine.primitive_config, .{ .total_vertex_outputs = 0, .topology = .triangle_list }, 0b1000);
+    queue.addMasked(p3d, &p3d.primitive_engine.primitive_config, .{ .total_vertex_outputs = 0, .topology = .triangle_list }, 0b1000);
+
+    var last_index_info = first_draw;
+    var current_index_info_ptr: *const mango.MultiDrawIndexedInfo = @ptrCast(@alignCast(@as([*]const u8, @ptrCast(index_info)) + stride));
+
+    for (1..draw_count) |_| {
+        std.debug.assertReadable(std.mem.asBytes(current_index_info_ptr));
+
+        const current_index_info = current_index_info_ptr.*;
+
+        if (current_index_info.index_count != last_index_info.index_count) {
+            queue.add(p3d, &p3d.primitive_engine.draw_vertex_count, current_index_info.index_count);
+        }
+
+        if (current_index_info.first_index != last_index_info.first_index) {
+            queue.add(p3d, &p3d.primitive_engine.attributes.index_buffer, .init(@intCast(dynamic_rendering_state.index_buffer_offset + current_index_info.first_index), dynamic_rendering_state.misc.index_format));
+        }
+
+        if (current_index_info.vertex_offset != last_index_info.vertex_offset) {
+            for (&dynamic_rendering_state.vertex_buffers_offset, &dynamic_graphics_state.vtx_input.buffer_config, 0..) |offset, buf_conf, i| {
+                const offset_from_bound: i32 = first_draw.vertex_offset * buf_conf.high.bytes_per_vertex;
+                const new_offset: u28 = @intCast(offset + offset_from_bound);
+
+                queue.add(p3d, &p3d.primitive_engine.attributes.vertex_buffers[i].offset, .init(new_offset));
+            }
+
+            cmd.rnd_state.dirty.vertex_buffers = true;
+        }
+
+        queue.add(p3d, &p3d.primitive_engine.restart_primitive, .init(.trigger));
+        queue.add(p3d, &p3d.primitive_engine.draw_indexed, .init(.trigger));
+        queue.add(p3d, &p3d.primitive_engine.clear_post_vertex_cache, .init(.trigger));
+
+        // NOTE: See above
+        queue.addMasked(p3d, &p3d.primitive_engine.primitive_config, .{ .total_vertex_outputs = 0, .topology = .triangle_list }, 0b1000);
+        queue.addMasked(p3d, &p3d.primitive_engine.primitive_config, .{ .total_vertex_outputs = 0, .topology = .triangle_list }, 0b1000);
+
+        last_index_info = current_index_info;
+        current_index_info_ptr = @ptrCast(@alignCast(@as([*]const u8, @ptrCast(current_index_info_ptr)) + stride));
+    }
+
+    cmd.flags.drawcall_in_pass = true;
+}
+
+// TODO: How should we approach immediate rendering, are 16 vertex attributes really needed?
+
+pub fn setDepthMode(cmd: *CommandBuffer, mode: mango.DepthMode) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setDepthMode(mode);
+}
+
+pub fn setCullMode(cmd: *CommandBuffer, cull_mode: mango.CullMode) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setCullMode(cull_mode);
+}
+
+pub fn setFrontFace(cmd: *CommandBuffer, front_face: mango.FrontFace) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setFrontFace(front_face);
+}
+
+pub fn setPrimitiveTopology(cmd: *CommandBuffer, primitive_topology: mango.PrimitiveTopology) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setPrimitiveTopology(primitive_topology);
+}
+
+pub fn setViewport(cmd: *CommandBuffer, viewport: mango.Viewport) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setViewport(viewport);
+}
+
+pub fn setScissor(cmd: *CommandBuffer, scissor: mango.Scissor) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setScissor(scissor);
+}
+
+pub fn setTextureCombiners(cmd: *CommandBuffer, texture_combiners: []const mango.TextureCombinerUnit, texture_combiner_buffer_sources: []const mango.TextureCombinerUnit.BufferSources) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setTextureCombiners(texture_combiners, texture_combiner_buffer_sources);
+}
+
+pub fn setBlendEquation(cmd: *CommandBuffer, blend_equation: mango.ColorBlendEquation) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setBlendEquation(blend_equation);
+}
+
+pub fn setColorWriteMask(cmd: *CommandBuffer, write_mask: mango.ColorComponentFlags) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setColorWriteMask(write_mask);
+}
+
+pub fn setDepthTestEnable(cmd: *CommandBuffer, enable: bool) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setDepthTestEnable(enable);
+}
+
+pub fn setDepthCompareOp(cmd: *CommandBuffer, op: mango.CompareOperation) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setDepthCompareOp(op);
+}
+
+pub fn setDepthWriteEnable(cmd: *CommandBuffer, enable: bool) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setDepthWriteEnable(enable);
+}
+
+pub fn setDepthBias(cmd: *CommandBuffer, constant: f32) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setDepthBias(constant);
+}
+
+pub fn setLogicOpEnable(cmd: *CommandBuffer, enable: bool) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setLogicOpEnable(enable);
+}
+
+pub fn setLogicOp(cmd: *CommandBuffer, logic_op: mango.LogicOperation) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setLogicOp(logic_op);
+}
+
+pub fn setAlphaTestEnable(cmd: *CommandBuffer, enable: bool) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setAlphaTestEnable(enable);
+}
+
+pub fn setAlphaTestCompareOp(cmd: *CommandBuffer, compare_op: mango.CompareOperation) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setAlphaTestCompareOp(compare_op);
+}
+
+pub fn setAlphaTestReference(cmd: *CommandBuffer, reference: u8) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setAlphaTestReference(reference);
+}
+
+pub fn setStencilTestEnable(cmd: *CommandBuffer, enable: bool) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setStencilTestEnable(enable);
+}
+
+pub fn setStencilOp(cmd: *CommandBuffer, fail_op: mango.StencilOperation, pass_op: mango.StencilOperation, depth_fail_op: mango.StencilOperation, op: mango.CompareOperation) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setStencilOp(fail_op, pass_op, depth_fail_op, op);
+}
+
+pub fn setStencilCompareMask(cmd: *CommandBuffer, compare_mask: u8) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setStencilCompareMask(compare_mask);
+}
+
+pub fn setStencilWriteMask(cmd: *CommandBuffer, write_mask: u8) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setStencilWriteMask(write_mask);
+}
+
+pub fn setStencilReference(cmd: *CommandBuffer, reference: u8) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setStencilReference(reference);
+}
+
+pub fn setTextureCoordinates(cmd: *CommandBuffer, texture_2_coordinates: mango.TextureCoordinateSource, texture_3_coordinates: mango.TextureCoordinateSource) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setTextureCoordinates(texture_2_coordinates, texture_3_coordinates);
+}
+
+pub fn setVertexInput(cmd: *CommandBuffer, layout: mango.VertexInputLayout) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setVertexInput(layout);
+}
+
+pub fn setAetherFog(cmd: *CommandBuffer, enabled: bool, color: [4]u8, table: []const u32) void {
+    std.debug.assert(cmd.state == .recording);
+    std.debug.assert(table.len == 0 or table.len == 128);
+
+    var next = FogState{
+        .enabled = enabled,
+        .color = color,
+        .dirty = true,
+    };
+
+    if (enabled) @memcpy(&next.table, table[0..128]);
+    cmd.fog_state = next;
+}
+
+pub fn setLightingEnable(cmd: *CommandBuffer, enable: bool) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setLightingEnable(enable);
+}
+
+pub fn setLightEnvironmentEnable(cmd: *CommandBuffer, enable: mango.LightEnvironmentEnable) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setLightEnvironmentEnable(enable);
+}
+
+pub fn setLightEnvironmentInput(cmd: *CommandBuffer, input: mango.LightEnvironmentInput) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setLightEnvironmentInput(input);
+}
+
+pub fn setLightEnvironmentRange(cmd: *CommandBuffer, range: mango.LightEnvironmentRange) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setLightEnvironmentRange(range);
+}
+
+pub fn setLightEnvironmentScale(cmd: *CommandBuffer, scale: mango.LightEnvironmentScale) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.setLightEnvironmentScale(scale);
+}
+
+pub fn bindLightEnvironmentTable(cmd: *CommandBuffer, slot: mango.LightEnvironmentLookupSlot, table: mango.LightLookupTable) void {
+    std.debug.assert(cmd.state == .recording);
+    cmd.gfx_state.bindLightEnvironmentTable(slot, table);
+}
+
+pub fn writeTimestamp(cmd: *CommandBuffer, pool: mango.QueryPool, query: u32) void {
+    cmd.doQuery(pool, query, .timestamp);
+}
+
+pub fn beginQuery(cmd: *CommandBuffer, pool: mango.QueryPool, query: u32) void {
+    cmd.doQuery(pool, query, .begin_query);
+}
+
+pub fn endQuery(cmd: *CommandBuffer, pool: mango.QueryPool, query: u32) void {
+    cmd.doQuery(pool, query, .end_query);
+}
+
+fn doQuery(cmd: *CommandBuffer, pool: mango.QueryPool, query: u32, kind: operation.Kind) void {
+    std.debug.assert(cmd.state == .recording);
+
+    if (cmd.current_error) |_| return;
+
+    cmd.finalizeCurrent() catch |err| {
+        cmd.current_error = err;
+        return;
+    };
+
+    const query_op = cmd.allocOperation(operation.Query) catch |err| {
+        cmd.current_error = err;
+        return;
+    };
+
+    query_op.* = .{
+        .pool = .fromHandleMutable(pool),
+        .query = query,
+        .node = .empty(kind),
+    };
+
+    cmd.pushOperation(&query_op.node);
+}
+
+fn beforeDraw(cmd: *CommandBuffer, draw_count: usize) bool {
+    if (cmd.current_error) |_| return false;
+
+    cmd.gfx_state.validate() catch |err| {
+        cmd.current_error = err;
+        return false;
+    };
+
+    cmd.emitDirty(backend.static_emission_cost + draw_count * backend.max_drawcall_emission_cost) catch |err| {
+        cmd.current_error = err;
+        return false;
+    };
+
+    return true;
+}
+
+fn emitDirty(cmd: *CommandBuffer, extra_cost: u32) !void {
+    const gfx_dirty = cmd.gfx_state.anyDirty();
+    const rnd_dirty = cmd.rnd_state.anyDirty();
+    const fog_dirty = cmd.fog_state.dirty;
+
+    if (!gfx_dirty and !rnd_dirty and !fog_dirty) return;
+
+    const max_graphics_emission_cost = if (gfx_dirty) cmd.gfx_state.maxEmitDirtyQueueLength() else 0;
+    const max_rendering_emission_cost = if (rnd_dirty) cmd.rnd_state.maxEmitDirtyQueueLength() else 0;
+    const max_emission_cost = backend.static_emission_cost + max_graphics_emission_cost + max_rendering_emission_cost + extra_cost;
+
+    try cmd.ensureUnusedCapacity(max_emission_cost);
+
+    const queue = cmd.stream.first().?;
+
+    if (!cmd.flags.subsequent_emissions) {
+        queue.add(p3d, &p3d.primitive_engine.mode, .init(.config));
+        cmd.flags.subsequent_emissions = true;
+    }
+
+    const gfx_start = queue.end;
+    cmd.gfx_state.emitDirty(queue);
+    const gfx_end = queue.end;
+    std.debug.assert((gfx_end - gfx_start) <= max_graphics_emission_cost);
+
+    const rnd_start = gfx_end;
+    cmd.rnd_state.emitDirty(queue);
+    const rnd_end = queue.end;
+    std.debug.assert((rnd_end - rnd_start) <= max_rendering_emission_cost);
+
+    if (gfx_dirty or cmd.fog_state.dirty) {
+        try cmd.emitAetherFog();
+    }
+}
+
+fn emitAetherFog(cmd: *CommandBuffer) !void {
+    const state = &cmd.fog_state;
+    try cmd.ensureUnusedCapacity(if (state.enabled) 256 else 4);
+    const queue = cmd.stream.first().?;
+
+    queue.addMasked(p3d, &p3d.texture_combiners.config, .{
+        .fog_mode = if (state.enabled) .fog else .disabled,
+        .shading_density_source = .plain,
+        .combiner_color_buffer_src = .splat(.previous_buffer),
+        .combiner_alpha_buffer_src = .splat(.previous_buffer),
+        .z_flip = false,
+    }, 0b0101);
+
+    if (!state.enabled) {
+        state.dirty = false;
+        return;
+    }
+
+    queue.add(p3d, &p3d.texture_combiners.fog_color, state.color);
+    for (0..16) |chunk| {
+        const start = chunk * 8;
+        queue.add(p3d, &p3d.texture_combiners.fog_lut_index, .init(@intCast(start)));
+        queue.addConsecutive(p3d, &p3d.texture_combiners.fog_lut_data[0], @ptrCast(state.table[start..][0..8]));
+    }
+    state.dirty = false;
+}
+
+/// Finalizes and pushes a graphics operation (if needed)
+fn finalizeCurrent(
+    cmd: *CommandBuffer,
+) !void {
+    if (cmd.stream.first()) |queue| if (cmd.flags.drawcall_in_pass) {
+        queue.add(p3d, &p3d.output_merger.flush, .init(.trigger));
+        cmd.flags.drawcall_in_pass = false;
+    };
+
+    if (cmd.stream.finalize()) |head| {
+        // NOTE: we're not "leaking" head, if this fails
+        // the command buffer must be left in an `invalid` state
+        // anyways.
+
+        const gfx_op = try cmd.allocOperation(operation.Graphics);
+
+        gfx_op.* = .{
+            .node = .empty(.graphics),
+            .head = head.ptr,
+            .len = head.len,
+        };
+
+        cmd.pushOperation(&gfx_op.node);
+    }
+}
+
+fn allocOperation(cmd: *CommandBuffer, comptime Operation: type) !*Operation {
+    const needed_size = std.mem.alignForward(usize, @sizeOf(operation.Graphics), 16);
+
+    try cmd.ensureUnusedCapacity(needed_size);
+
+    const que = cmd.stream.first().?;
+    const ptr: *Operation = @ptrCast(que.buffer.ptr[que.end..]);
+
+    que.end += needed_size;
+    cmd.stream.start = que.end;
+    return ptr;
+}
+
+fn pushOperation(cmd: *CommandBuffer, node: *operation.Node) void {
+    std.debug.assert(std.mem.isAligned(@intFromPtr(node), 16));
+    const maybe_last = cmd.last;
+
+    cmd.last = node;
+    if (maybe_last) |last| {
+        std.debug.assert(cmd.head != null);
+
+        last.next = @intCast(@intFromPtr(node) >> 4);
+    } else {
+        cmd.head = node;
+    }
+}
+
+fn ensureUnusedCapacity(cmd: *CommandBuffer, capacity: usize) !void {
+    const remaining = if (cmd.stream.first()) |que| que.unusedCapacitySlice().len else 0;
+
+    if (remaining < capacity) {
+        @branchHint(.unlikely);
+
+        // TODO: unregress linear memory pooling
+        try cmd.stream.grow(cmd.pool.native_gpa, min_stream_segment_size, .{
+            .pool = cmd.pool,
+        });
+    }
+}
+
+pub fn notifyPending(cmd: *CommandBuffer) void {
+    std.debug.assert(cmd.state == .executable);
+    @atomicStore(backend.CommandBuffer.State, &cmd.state, .pending, .monotonic);
+}
+
+/// NOTE: Should we have a one-time submit?
+pub fn notifyCompleted(cmd: *CommandBuffer) void {
+    std.debug.assert(cmd.state == .pending);
+    @atomicStore(backend.CommandBuffer.State, &cmd.state, .executable, .monotonic);
+}
+
+pub fn toHandle(image: *CommandBuffer) Handle {
+    return @enumFromInt(@intFromPtr(image));
+}
+
+pub fn fromHandleMutable(handle: Handle) *CommandBuffer {
+    return @as(*CommandBuffer, @ptrFromInt(@intFromEnum(handle)));
+}
+
+const StreamContext = struct {
+    comptime use_jumps: bool = true,
+    pool: *CommandPool,
+
+    pub fn virtualToPhysical(ctx: StreamContext, virtual: *const anyopaque) zitrus.hardware.PhysicalAddress {
+        return ctx.pool.device.vtable.virtualToPhysical(ctx.pool.device, virtual);
+    }
+};
+
+const min_stream_segment_size = CommandPool.native_min_size;
+const Stream = command.stream.Custom(StreamContext);
+
+const CommandBuffer = @This();
+const backend = @import("backend.zig");
+const validation = backend.validation;
+
+const log = validation.log;
+
+const CommandPool = backend.CommandPool;
+const GraphicsState = backend.GraphicsState;
+const RenderingState = backend.RenderingState;
+
+const std = @import("std");
+const zitrus = @import("zitrus");
+const mango = zitrus.mango;
+const pica = zitrus.hardware.pica;
+const PhysicalAddress = zitrus.hardware.PhysicalAddress;
+
+const command = pica.command;
+
+const p3d = &zitrus.memory.arm11.pica.p3d;
diff --git a/src/platform/3ds/mango/mango/CommandPool.zig b/src/platform/3ds/mango/mango/CommandPool.zig
new file mode 100644
index 0000000..d7c4992
--- /dev/null
+++ b/src/platform/3ds/mango/mango/CommandPool.zig
@@ -0,0 +1,238 @@
+//! A CommandBuffer's pool intended to be used within a single thread (not thread-safe!)
+//!
+//! Also handles buffer management of native gpu buffers (NOTE: Secondary CommandBuffers could go to VRAM if we know the user won't reset them individually)
+//!
+//! Command buffers are pooled with doubly linked lists for both allocated and freed.
+//! Native buffers are pooled with a free-list slab allocator.
+//!
+//! When trimming, freed command buffers are truly freed to the parent `allocator`, after that
+//! available and freed native buffers are deallocated to the parent `native_allocator`.
+
+pub const Handle = enum(u32) {
+    null = 0,
+    _,
+};
+
+// NOTE: With native buffers we're talking about `u32`s, not `u8`s!
+pub const native_min_size = 16 * 1024;
+pub const native_max_size = 256 * 1024;
+
+const native_min_class = std.math.log2(native_min_size);
+const native_max_class = std.math.log2(native_max_size);
+const native_size_classes = (native_max_class - native_min_class);
+
+pub const Node = struct {
+    /// Initializes a new node with an undefined `CommandBuffer`
+    pub const init_undefined: Node = .{
+        .node = .{},
+        .cmd_buffer = undefined,
+    };
+
+    node: std.DoublyLinkedList.Node,
+    cmd_buffer: CommandBuffer,
+};
+
+device: *backend.Device,
+gpa: std.mem.Allocator,
+native_gpa: std.mem.Allocator,
+
+allocated_command_buffers: std.DoublyLinkedList,
+free_command_buffers: std.DoublyLinkedList,
+
+free_native_buffers: [native_size_classes]usize,
+
+pub fn init(device: *backend.Device, create_info: mango.CommandPoolCreateInfo, native_gpa: std.mem.Allocator, gpa: std.mem.Allocator) !CommandPool {
+    var pool: CommandPool = .{
+        .device = device,
+        .gpa = gpa,
+        .native_gpa = native_gpa,
+        .allocated_command_buffers = .{},
+        .free_command_buffers = .{},
+
+        .free_native_buffers = @splat(0),
+    };
+    errdefer pool.deinit(gpa);
+
+    if (create_info.initial_command_buffers > 0) {
+        for (0..create_info.initial_command_buffers) |_| {
+            pool.recycle(try pool.create());
+        }
+    }
+
+    return pool;
+}
+
+pub fn deinit(pool: *CommandPool, gpa: std.mem.Allocator) void {
+    std.debug.assert(pool.gpa.vtable == gpa.vtable); // At least ensure the same VTable is used as we cannot compare the pointers
+
+    {
+        var maybe_current_allocated = pool.allocated_command_buffers.first;
+        while (maybe_current_allocated) |current| {
+            maybe_current_allocated = current.next;
+
+            const pool_node: *Node = @alignCast(@fieldParentPtr("node", current));
+
+            pool_node.cmd_buffer.deinit();
+            pool.gpa.destroy(pool_node);
+        }
+
+        pool.allocated_command_buffers = .{};
+    }
+
+    pool.trim();
+    pool.* = undefined;
+}
+
+pub fn allocate(pool: *CommandPool, buffers: []mango.CommandBuffer) !void {
+    var allocated_buffers: u32 = 0;
+    errdefer pool.free(buffers[0..allocated_buffers]);
+
+    for (buffers) |*buffer| {
+        const b_cmd: *CommandBuffer = try pool.create();
+        buffer.* = b_cmd.toHandle();
+        allocated_buffers += 1;
+    }
+}
+
+pub fn free(pool: *CommandPool, buffers: []const mango.CommandBuffer) void {
+    for (buffers) |buffer| {
+        const b_cmd: *CommandBuffer = .fromHandleMutable(buffer);
+        pool.recycle(b_cmd);
+    }
+}
+
+pub fn reset(pool: *CommandPool) void {
+    var maybe_current = pool.allocated_command_buffers.first;
+    while (maybe_current) |current| {
+        maybe_current = current.next;
+
+        const node: *Node = @alignCast(@fieldParentPtr("node", current));
+        node.cmd_buffer.reset(.none);
+    }
+}
+
+pub fn trim(pool: *CommandPool) void {
+    var maybe_current = pool.free_command_buffers.first;
+    while (maybe_current) |current| {
+        maybe_current = current.next;
+
+        const pool_node: *Node = @alignCast(@fieldParentPtr("node", current));
+
+        pool.gpa.destroy(pool_node); // NOTE: Freed command buffers don't have a native buffer.
+    }
+
+    for (0..native_size_classes) |class| {
+        var ptr = pool.free_native_buffers[class];
+
+        while (ptr != 0) {
+            const buffer: [*]align(8) u32 = @ptrFromInt(ptr);
+            ptr = buffer[0];
+
+            const slice = buffer[0..(@as(usize, 1) << @intCast(class + native_min_class))];
+            pool.native_gpa.free(slice);
+        }
+    }
+
+    pool.free_command_buffers = .{
+        .first = null,
+        .last = null,
+    };
+}
+
+/// Asserts that size_hint is not 0.
+pub fn allocateNative(pool: *CommandPool, size_hint: ?usize) ![]align(16) u32 {
+    const needed_class_size: usize = @intCast(@max(native_min_size, std.math.ceilPowerOfTwoPromote(usize, size_hint orelse native_min_size)));
+
+    var needed_class = nativeClassIndex(needed_class_size);
+
+    while (needed_class < native_size_classes) : (needed_class += 1) {
+        const ptr = pool.free_native_buffers[needed_class];
+
+        if (ptr != 0) {
+            const buffer: [*]align(16) u32 = @ptrFromInt(ptr);
+
+            pool.free_native_buffers[needed_class] = buffer[0];
+            return buffer[0..(@as(usize, 1) << @intCast(needed_class + native_min_class))];
+        }
+    }
+
+    return try pool.native_gpa.alignedAlloc(u32, .@"16", needed_class_size);
+}
+
+pub fn remapNative(pool: *CommandPool, buffer: []align(16) u32, used: usize, new_len: usize) ![]align(16) u32 {
+    if (buffer.len == 0) return try pool.allocateNative(null);
+
+    const next_class_len: usize = @intCast(std.math.ceilPowerOfTwoPromote(usize, new_len));
+
+    if (pool.gpa.remap(buffer, next_class_len)) |remapped| {
+        return remapped;
+    }
+
+    const new_buffer = try pool.allocateNative(next_class_len);
+    defer pool.recycleNative(buffer);
+
+    @memcpy(new_buffer[0..used], buffer[0..used]);
+    return new_buffer;
+}
+
+pub fn recycleNative(pool: *CommandPool, buffer: []align(16) u32) void {
+    if (buffer.len == 0) return;
+
+    const buffer_class = nativeClassIndex(buffer.len);
+
+    if (buffer_class >= native_size_classes) {
+        pool.native_gpa.free(buffer);
+        return;
+    }
+
+    buffer[0] = pool.free_native_buffers[buffer_class];
+    pool.free_native_buffers[buffer_class] = @intFromPtr(buffer.ptr);
+}
+
+fn nativeClassIndex(size: usize) usize {
+    return (std.math.log2(size) - native_min_class);
+}
+
+fn create(pool: *CommandPool) !*CommandBuffer {
+    const allocated_node = pool.free_command_buffers.popFirst() orelse blk: {
+        const gpa = pool.gpa;
+        const pool_node = try gpa.create(Node);
+        pool_node.* = .init_undefined;
+
+        break :blk &pool_node.node;
+    };
+
+    const pool_node: *Node = @alignCast(@fieldParentPtr("node", allocated_node));
+    errdefer pool.free_command_buffers.append(allocated_node); // Ensure we won't leak memory!
+
+    pool_node.cmd_buffer = .init(pool);
+    errdefer @compileError("If we return an error, this pool will have wrong state!");
+
+    pool.allocated_command_buffers.append(allocated_node);
+    return &pool_node.cmd_buffer;
+}
+
+fn recycle(pool: *CommandPool, cmd_buffer: *CommandBuffer) void {
+    const pool_node: *Node = @alignCast(@fieldParentPtr("cmd_buffer", cmd_buffer));
+
+    cmd_buffer.deinit();
+    pool.allocated_command_buffers.remove(&pool_node.node);
+    pool.free_command_buffers.append(&pool_node.node);
+}
+
+pub fn toHandle(image: *CommandPool) Handle {
+    return @enumFromInt(@intFromPtr(image));
+}
+
+pub fn fromHandleMutable(handle: Handle) *CommandPool {
+    return @as(*CommandPool, @ptrFromInt(@intFromEnum(handle)));
+}
+
+const CommandPool = @This();
+
+const backend = @import("backend.zig");
+const CommandBuffer = backend.CommandBuffer;
+
+const std = @import("std");
+const zitrus = @import("zitrus");
+const mango = zitrus.mango;
diff --git a/src/platform/3ds/mango/mango/Device.zig b/src/platform/3ds/mango/mango/Device.zig
new file mode 100644
index 0000000..7c96643
--- /dev/null
+++ b/src/platform/3ds/mango/mango/Device.zig
@@ -0,0 +1,677 @@
+//! Represents the PICA200 GPU as a whole.
+//!
+//! As the GPU is not a standard one, there are lots of simplifications made:
+//!     - Supports 3 separate queue families:
+//!         * Memory Fills: fillBuffer, clearColorImage, clearDepthStencilImage (they are queue operations instead of command buffer ones!)
+//!         * Transfer Engine / Display Transfer: present, copyBufferToImage, copyImageToBuffer, copyImageToImage, blitImage
+//!         * 3D Command List: submit
+
+pub const Handle = enum(u32) {
+    null = 0,
+    _,
+
+    pub fn destroy(device: Handle) void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        b_device.destroy();
+    }
+
+    pub fn reacquire(device: Handle) !void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return try b_device.reacquire();
+    }
+
+    pub fn release(device: Handle) !ScreenCapture {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return try b_device.release();
+    }
+
+    pub fn getQueue(device: Handle, family: mango.QueueFamily) mango.Queue {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.getQueue(family);
+    }
+
+    pub fn allocateMemory(device: Handle, allocate_info: mango.MemoryAllocateInfo, maybe_gpa: ?std.mem.Allocator) !mango.DeviceMemory {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.allocateMemory(allocate_info, maybe_gpa);
+    }
+
+    pub fn freeMemory(device: Handle, memory: mango.DeviceMemory, maybe_gpa: ?std.mem.Allocator) void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.freeMemory(memory, maybe_gpa);
+    }
+
+    pub fn mapMemory(device: Handle, memory: mango.DeviceMemory, offset: mango.DeviceSize, size: mango.DeviceSize) ![]u8 {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.mapMemory(memory, offset, size);
+    }
+
+    pub fn unmapMemory(device: Handle, memory: mango.DeviceMemory) void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.unmapMemory(memory);
+    }
+
+    pub fn flushMappedMemoryRanges(device: Handle, ranges: []const mango.MappedMemoryRange) !void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.flushMappedMemoryRanges(ranges);
+    }
+
+    pub fn invalidateMappedMemoryRanges(device: Handle, ranges: []const mango.MappedMemoryRange) !void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.invalidateMappedMemoryRanges(ranges);
+    }
+
+    pub fn createSemaphore(device: Handle, create_info: mango.SemaphoreCreateInfo, maybe_gpa: ?std.mem.Allocator) !mango.Semaphore {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.createSemaphore(create_info, maybe_gpa);
+    }
+
+    pub fn destroySemaphore(device: Handle, semaphore: mango.Semaphore, maybe_gpa: ?std.mem.Allocator) void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.destroySemaphore(semaphore, maybe_gpa);
+    }
+
+    pub fn createQueryPool(device: Handle, create_info: mango.QueryPoolCreateInfo, maybe_gpa: ?std.mem.Allocator) ObjectCreationError!mango.QueryPool {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.createQueryPool(create_info, maybe_gpa);
+    }
+
+    pub fn destroyQueryPool(device: Handle, query_pool: mango.QueryPool, maybe_gpa: ?std.mem.Allocator) void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.destroyQueryPool(query_pool, maybe_gpa);
+    }
+
+    pub fn resetQueryPool(device: Handle, query_pool: mango.QueryPool, first: u32, count: u32) void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.resetQueryPool(query_pool, first, count);
+    }
+
+    pub fn getQueryPoolResults(device: Handle, query_pool: mango.QueryPool, first: u32, count: u32, data: []u8, stride: u32, flags: mango.QueryResultFlags) mango.GetQueryResultsError!void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.getQueryPoolResults(query_pool, first, count, data, stride, flags);
+    }
+
+    pub fn createCommandPool(device: Handle, create_info: mango.CommandPoolCreateInfo, maybe_gpa: ?std.mem.Allocator) !mango.CommandPool {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.createCommandPool(create_info, maybe_gpa);
+    }
+
+    pub fn destroyCommandPool(device: Handle, command_pool: mango.CommandPool, maybe_gpa: ?std.mem.Allocator) void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.destroyCommandPool(command_pool, maybe_gpa);
+    }
+
+    pub fn resetCommandPool(device: Handle, command_pool: mango.CommandPool) void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.resetCommandPool(command_pool);
+    }
+
+    pub fn trimCommandPool(device: Handle, command_pool: mango.CommandPool) void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.trimCommandPool(command_pool);
+    }
+
+    pub fn allocateCommandBuffers(device: Handle, allocate_info: mango.CommandBufferAllocateInfo, buffers: []mango.CommandBuffer) !void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.allocateCommandBuffers(allocate_info, buffers);
+    }
+
+    pub fn freeCommandBuffers(device: Handle, command_pool: mango.CommandPool, buffers: []const mango.CommandBuffer) void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.freeCommandBuffers(command_pool, buffers);
+    }
+
+    pub fn createBuffer(device: Handle, create_info: mango.BufferCreateInfo, maybe_gpa: ?std.mem.Allocator) !mango.Buffer {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.createBuffer(create_info, maybe_gpa);
+    }
+
+    pub fn destroyBuffer(device: Handle, buffer: mango.Buffer, maybe_gpa: ?std.mem.Allocator) void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.destroyBuffer(buffer, maybe_gpa);
+    }
+
+    pub fn bindBufferMemory(device: Handle, buffer: mango.Buffer, memory: mango.DeviceMemory, memory_offset: mango.DeviceSize) !void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.bindBufferMemory(buffer, memory, memory_offset);
+    }
+
+    pub fn createImage(device: Handle, create_info: mango.ImageCreateInfo, maybe_gpa: ?std.mem.Allocator) !mango.Image {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.createImage(create_info, maybe_gpa);
+    }
+
+    pub fn destroyImage(device: Handle, image: mango.Image, maybe_gpa: ?std.mem.Allocator) void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.destroyImage(image, maybe_gpa);
+    }
+
+    pub fn bindImageMemory(device: Handle, image: mango.Image, memory: mango.DeviceMemory, memory_offset: mango.DeviceSize) !void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.bindImageMemory(image, memory, memory_offset);
+    }
+
+    pub fn createImageView(device: Handle, create_info: mango.ImageViewCreateInfo, maybe_gpa: ?std.mem.Allocator) !mango.ImageView {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.createImageView(create_info, maybe_gpa);
+    }
+
+    pub fn destroyImageView(device: Handle, image_view: mango.ImageView, maybe_gpa: ?std.mem.Allocator) void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.destroyImageView(image_view, maybe_gpa);
+    }
+
+    pub fn createSampler(device: Handle, create_info: mango.SamplerCreateInfo, maybe_gpa: ?std.mem.Allocator) !mango.Sampler {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.createSampler(create_info, maybe_gpa);
+    }
+
+    pub fn destroySampler(device: Handle, sampler: mango.Sampler, maybe_gpa: ?std.mem.Allocator) void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.destroySampler(sampler, maybe_gpa);
+    }
+
+    pub fn createShader(device: Handle, create_info: mango.ShaderCreateInfo, maybe_gpa: ?std.mem.Allocator) ObjectCreationError!mango.Shader {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.createShader(create_info, maybe_gpa);
+    }
+
+    pub fn destroyShader(device: Handle, shader: mango.Shader, maybe_gpa: ?std.mem.Allocator) void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        b_device.destroyShader(shader, maybe_gpa);
+    }
+
+    pub fn createVertexInputLayout(device: Handle, create_info: mango.VertexInputLayoutCreateInfo, maybe_gpa: ?std.mem.Allocator) ObjectCreationError!mango.VertexInputLayout {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.createVertexInputLayout(create_info, maybe_gpa);
+    }
+
+    pub fn destroyVertexInputLayout(device: Handle, layout: mango.VertexInputLayout, maybe_gpa: ?std.mem.Allocator) void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.destroyVertexInputLayout(layout, maybe_gpa);
+    }
+
+    pub fn createLightLookupTable(device: Handle, create_info: mango.LightLookupTableCreateInfo, maybe_gpa: ?std.mem.Allocator) !mango.LightLookupTable {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.createLightLookupTable(create_info, maybe_gpa);
+    }
+
+    pub fn destroyLightLookupTable(device: Handle, lut: mango.LightLookupTable, maybe_gpa: ?std.mem.Allocator) void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.destroyLightLookupTable(lut, maybe_gpa);
+    }
+
+    pub fn createSwapchain(device: Handle, create_info: mango.SwapchainCreateInfo, maybe_gpa: ?std.mem.Allocator) !mango.Swapchain {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.createSwapchain(create_info, maybe_gpa);
+    }
+
+    pub fn destroySwapchain(device: Handle, swapchain: mango.Swapchain, maybe_gpa: ?std.mem.Allocator) void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.destroySwapchain(swapchain, maybe_gpa);
+    }
+
+    pub fn getSwapchainImages(device: Handle, swapchain: mango.Swapchain, images: []mango.Image) !u8 {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.getSwapchainImages(swapchain, images);
+    }
+
+    pub fn acquireNextImage(device: Handle, swapchain: mango.Swapchain, timeout: u64) !u8 {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.acquireNextImage(swapchain, timeout);
+    }
+
+    pub fn signalSemaphore(device: Handle, signal_info: mango.SemaphoreSignalInfo) !void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.signalSemaphore(signal_info);
+    }
+
+    pub fn waitSemaphores(device: Handle, wait_info: mango.SemaphoreWaitInfo, timeout: u64) !void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.waitSemaphores(wait_info, timeout);
+    }
+
+    pub fn waitIdle(device: Handle) void {
+        const b_device: *Device = @ptrFromInt(@intFromEnum(device));
+        return b_device.waitIdle();
+    }
+};
+
+// TODO: restricted function types when they come!
+pub const VTable = struct {
+    destroy: *const fn (dev: *Device) void,
+
+    release: *const fn (dev: *Device) ReleaseDeviceError!ScreenCapture,
+    reacquire: *const fn (dev: *Device) ReacquireDeviceError!void,
+
+    waitIdleQueue: *const fn (dev: *Device, queue: Queue.Type) void,
+    wakeIdleQueue: *const fn (dev: *Device, queue: Queue.Type) void,
+
+    getShaderCode: *const fn (dev: *Device, key: backend.Shader.Code.Key) mango.ObjectCreationError!*backend.Shader.Code,
+    destroyShaderCode: *const fn (dev: *Device, code: *backend.Shader.Code) void,
+
+    allocateMemory: *const fn (dev: *Device, allocate_info: mango.MemoryAllocateInfo, gpa: std.mem.Allocator) mango.ObjectCreationError!mango.DeviceMemory,
+    freeMemory: *const fn (dev: *Device, memory: mango.DeviceMemory, gpa: std.mem.Allocator) void,
+    mapMemory: *const fn (dev: *Device, memory: mango.DeviceMemory, offset: mango.DeviceSize, size: mango.DeviceSize) MapMemoryError![]u8,
+    unmapMemory: *const fn (device: *Device, memory: mango.DeviceMemory) void,
+    flushMappedMemoryRanges: *const fn (dev: *Device, ranges: []const mango.MappedMemoryRange) FlushMemoryError!void,
+    invalidateMappedMemoryRanges: *const fn (dev: *Device, ranges: []const mango.MappedMemoryRange) InvalidateMemoryError!void,
+
+    createSwapchain: *const fn (dev: *Device, create_info: mango.SwapchainCreateInfo, gpa: std.mem.Allocator) ObjectCreationError!mango.Swapchain,
+    destroySwapchain: *const fn (dev: *Device, swapchain: mango.Swapchain, gpa: std.mem.Allocator) void,
+    getSwapchainImages: *const fn (dev: *Device, swapchain: mango.Swapchain, images: []mango.Image) GetSwapchainImagesError!u8,
+    acquireNextImage: *const fn (dev: *Device, swapchain: mango.Swapchain, timeout: u64) AcquireNextImageError!u8,
+
+    waitSemaphores: *const fn (dev: *Device, wait_info: mango.SemaphoreWaitInfo, timeout: u64) WaitSemaphoreError!void,
+    signalSemaphore: *const fn (dev: *Device, signal_info: mango.SemaphoreSignalInfo) SignalSemaphoreError!void,
+
+    virtualToPhysical: *const fn (dev: *Device, virtual: *const anyopaque) zitrus.hardware.PhysicalAddress,
+};
+
+const ObjectCreationError = mango.ObjectCreationError;
+const MapMemoryError = mango.MapMemoryError;
+const FlushMemoryError = mango.FlushMemoryError;
+const InvalidateMemoryError = mango.InvalidateMemoryError;
+const BindMemoryError = mango.BindMemoryError;
+const AcquireNextImageError = mango.AcquireNextImageError;
+const SignalSemaphoreError = mango.SignalSemaphoreError;
+const WaitSemaphoreError = mango.WaitSemaphoreError;
+const ReleaseDeviceError = mango.ReleaseDeviceError;
+const ReacquireDeviceError = mango.ReacquireDeviceError;
+const GetSwapchainImagesError = mango.GetSwapchainImagesError;
+
+vtable: VTable,
+
+gpa: std.mem.Allocator,
+linear_gpa: std.mem.Allocator,
+
+queues: std.EnumArray(Queue.Type, backend.Queue),
+
+/// Whether we're waiting for operations to complete or not.
+/// Waiting for a semaphore is NOT considered idle as we'll eventually wake.
+queue_statuses: std.EnumArray(Queue.Type, std.atomic.Value(Queue.Status)),
+
+pub fn destroy(device: *Device) void {
+    device.vtable.destroy(device);
+}
+
+pub fn reacquire(device: *Device) !void {
+    return try device.vtable.reacquire(device);
+}
+
+pub fn release(device: *Device) !ScreenCapture {
+    return try device.vtable.release(device);
+}
+
+pub fn getQueue(device: *Device, family: mango.QueueFamily) mango.Queue {
+    return switch (family) {
+        .transfer => device.queues.getPtr(.transfer).toHandle(),
+        .fill => device.queues.getPtr(.fill).toHandle(),
+        .submit => device.queues.getPtr(.submit).toHandle(),
+        .present => device.queues.getPtr(.present).toHandle(),
+    };
+}
+
+pub fn allocateMemory(device: *Device, allocate_info: mango.MemoryAllocateInfo, maybe_gpa: ?std.mem.Allocator) ObjectCreationError!mango.DeviceMemory {
+    const gpa = maybe_gpa orelse device.gpa;
+    return try device.vtable.allocateMemory(device, allocate_info, gpa);
+}
+
+pub fn freeMemory(device: *Device, memory: mango.DeviceMemory, maybe_gpa: ?std.mem.Allocator) void {
+    const gpa = maybe_gpa orelse device.gpa;
+    return device.vtable.freeMemory(device, memory, gpa);
+}
+
+pub fn mapMemory(device: *Device, memory: mango.DeviceMemory, offset: mango.DeviceSize, size: mango.DeviceSize) MapMemoryError![]u8 {
+    return try device.vtable.mapMemory(device, memory, offset, size);
+}
+
+pub fn unmapMemory(device: *Device, memory: mango.DeviceMemory) void {
+    return device.vtable.unmapMemory(device, memory);
+}
+
+pub fn flushMappedMemoryRanges(device: *Device, ranges: []const mango.MappedMemoryRange) FlushMemoryError!void {
+    return try device.vtable.flushMappedMemoryRanges(device, ranges);
+}
+
+pub fn invalidateMappedMemoryRanges(device: *Device, ranges: []const mango.MappedMemoryRange) InvalidateMemoryError!void {
+    return try device.vtable.invalidateMappedMemoryRanges(device, ranges);
+}
+
+pub fn createSemaphore(device: *Device, create_info: mango.SemaphoreCreateInfo, maybe_gpa: ?std.mem.Allocator) ObjectCreationError!mango.Semaphore {
+    const gpa = maybe_gpa orelse device.gpa;
+    const b_semaphore: *backend.Semaphore = try gpa.create(backend.Semaphore);
+    errdefer gpa.destroy(b_semaphore);
+    b_semaphore.* = .init(create_info);
+    return b_semaphore.toHandle();
+}
+
+pub fn destroySemaphore(device: *Device, semaphore: mango.Semaphore, maybe_gpa: ?std.mem.Allocator) void {
+    const gpa = maybe_gpa orelse device.gpa;
+    const b_semaphore: *backend.Semaphore = .fromHandleMutable(semaphore);
+    gpa.destroy(b_semaphore);
+}
+
+pub fn createQueryPool(device: *Device, create_info: mango.QueryPoolCreateInfo, maybe_gpa: ?std.mem.Allocator) ObjectCreationError!mango.QueryPool {
+    const gpa = maybe_gpa orelse device.gpa;
+    const b_query_pool: *backend.QueryPool = try gpa.create(backend.QueryPool);
+    errdefer gpa.destroy(b_query_pool);
+
+    b_query_pool.* = try .init(gpa, create_info);
+    return b_query_pool.toHandle();
+}
+
+pub fn destroyQueryPool(device: *Device, query_pool: mango.QueryPool, maybe_gpa: ?std.mem.Allocator) void {
+    const gpa = maybe_gpa orelse device.gpa;
+    const b_query_pool: *backend.QueryPool = .fromHandleMutable(query_pool);
+    b_query_pool.deinit(gpa);
+    gpa.destroy(b_query_pool);
+}
+
+pub fn resetQueryPool(device: *Device, query_pool: mango.QueryPool, first: u32, count: u32) void {
+    _ = device;
+
+    const b_query_pool: *backend.QueryPool = .fromHandleMutable(query_pool);
+    b_query_pool.reset(first, count);
+}
+
+pub fn getQueryPoolResults(device: *Device, query_pool: mango.QueryPool, first: u32, count: u32, data: []u8, stride: u32, flags: mango.QueryResultFlags) mango.GetQueryResultsError!void {
+    _ = device;
+
+    const b_query_pool: *backend.QueryPool = .fromHandleMutable(query_pool);
+    return b_query_pool.getResults(first, count, data, stride, flags);
+}
+
+pub fn createCommandPool(device: *Device, create_info: mango.CommandPoolCreateInfo, maybe_gpa: ?std.mem.Allocator) ObjectCreationError!mango.CommandPool {
+    const gpa = maybe_gpa orelse device.gpa;
+    const b_command_pool: *backend.CommandPool = try gpa.create(backend.CommandPool);
+    errdefer gpa.destroy(b_command_pool);
+    b_command_pool.* = try .init(device, create_info, device.linear_gpa, gpa);
+    return b_command_pool.toHandle();
+}
+
+pub fn destroyCommandPool(device: *Device, command_pool: mango.CommandPool, maybe_gpa: ?std.mem.Allocator) void {
+    const gpa = maybe_gpa orelse device.gpa;
+    const b_command_pool: *backend.CommandPool = .fromHandleMutable(command_pool);
+    b_command_pool.deinit(gpa);
+    gpa.destroy(b_command_pool);
+}
+
+pub fn resetCommandPool(device: *Device, command_pool: mango.CommandPool) void {
+    _ = device;
+    const b_command_pool: *backend.CommandPool = .fromHandleMutable(command_pool);
+    b_command_pool.reset();
+}
+
+pub fn trimCommandPool(device: *Device, command_pool: mango.CommandPool) void {
+    _ = device;
+    const b_command_pool: *backend.CommandPool = .fromHandleMutable(command_pool);
+    b_command_pool.trim();
+}
+
+pub fn allocateCommandBuffers(device: *Device, allocate_info: mango.CommandBufferAllocateInfo, buffers: []mango.CommandBuffer) ObjectCreationError!void {
+    _ = device;
+    const b_command_pool: *backend.CommandPool = .fromHandleMutable(allocate_info.pool);
+    return b_command_pool.allocate(buffers);
+}
+
+pub fn freeCommandBuffers(device: *Device, command_pool: mango.CommandPool, buffers: []const mango.CommandBuffer) void {
+    _ = device;
+    const b_command_pool: *backend.CommandPool = .fromHandleMutable(command_pool);
+    return b_command_pool.free(buffers);
+}
+
+pub fn createBuffer(device: *Device, create_info: mango.BufferCreateInfo, maybe_gpa: ?std.mem.Allocator) ObjectCreationError!mango.Buffer {
+    const gpa = maybe_gpa orelse device.gpa;
+    const buffer = try gpa.create(backend.Buffer);
+    errdefer gpa.destroy(buffer);
+
+    buffer.* = .init(create_info);
+    return buffer.toHandle();
+}
+
+pub fn destroyBuffer(device: *Device, buffer: mango.Buffer, maybe_gpa: ?std.mem.Allocator) void {
+    const gpa = maybe_gpa orelse device.gpa;
+    const b_buffer: *backend.Buffer = .fromHandleMutable(buffer);
+    gpa.destroy(b_buffer);
+}
+
+pub fn bindBufferMemory(device: *Device, buffer: mango.Buffer, memory: mango.DeviceMemory, memory_offset: mango.DeviceSize) BindMemoryError!void {
+    _ = device;
+
+    const b_buffer: *backend.Buffer = .fromHandleMutable(buffer);
+    const b_memory: backend.DeviceMemory = .fromHandle(memory);
+
+    std.debug.assert(b_buffer.memory_info.isUnbound());
+    std.debug.assert(@intFromEnum(memory_offset) + b_buffer.size <= b_memory.size());
+
+    b_buffer.memory_info = .init(b_memory, @intFromEnum(memory_offset));
+}
+
+pub fn createImage(device: *Device, create_info: mango.ImageCreateInfo, maybe_gpa: ?std.mem.Allocator) ObjectCreationError!mango.Image {
+    const gpa = maybe_gpa orelse device.gpa;
+    const image = try gpa.create(backend.Image);
+    errdefer gpa.destroy(image);
+
+    image.* = try .init(create_info);
+    return image.toHandle();
+}
+
+pub fn destroyImage(device: *Device, image: mango.Image, maybe_gpa: ?std.mem.Allocator) void {
+    const gpa = maybe_gpa orelse device.gpa;
+    const b_image: *backend.Image = .fromHandleMutable(image);
+    gpa.destroy(b_image);
+}
+
+pub fn bindImageMemory(device: *Device, image: mango.Image, memory: mango.DeviceMemory, memory_offset: mango.DeviceSize) BindMemoryError!void {
+    _ = device;
+
+    const b_image: *backend.Image = .fromHandleMutable(image);
+    const b_memory: backend.DeviceMemory = .fromHandle(memory);
+
+    std.debug.assert(b_image.memory_info.isUnbound());
+    std.debug.assert(@intFromEnum(memory_offset) + b_image.info.format.scale(b_image.info.size()) <= b_memory.size());
+
+    b_image.memory_info = .init(b_memory, @intFromEnum(memory_offset));
+}
+
+pub fn createImageView(device: *Device, create_info: mango.ImageViewCreateInfo, maybe_gpa: ?std.mem.Allocator) ObjectCreationError!mango.ImageView {
+    _ = device;
+    _ = maybe_gpa;
+
+    const b_image_view: backend.ImageView = .{
+        .data = try .init(create_info),
+    };
+
+    return b_image_view.toHandle();
+}
+
+pub fn destroyImageView(device: *Device, image_view: mango.ImageView, maybe_gpa: ?std.mem.Allocator) void {
+    _ = device;
+    _ = image_view;
+    _ = maybe_gpa;
+}
+
+pub fn createSampler(device: *Device, create_info: mango.SamplerCreateInfo, maybe_gpa: ?std.mem.Allocator) ObjectCreationError!mango.Sampler {
+    _ = device;
+    _ = maybe_gpa;
+
+    const b_image_sampler: backend.Sampler = .{
+        .data = .init(create_info),
+    };
+
+    return b_image_sampler.toHandle();
+}
+
+pub fn destroySampler(device: *Device, sampler: mango.Sampler, maybe_gpa: ?std.mem.Allocator) void {
+    _ = device;
+    _ = sampler;
+    _ = maybe_gpa;
+}
+
+pub fn createShader(device: *Device, create_info: mango.ShaderCreateInfo, maybe_gpa: ?std.mem.Allocator) ObjectCreationError!mango.Shader {
+    const gpa = maybe_gpa orelse device.gpa;
+    return switch (create_info.code_type) {
+        .psh => {
+            const parsed = zitrus.fmt.zpsh.Parsed.initBuffer(create_info.code[0..create_info.code_len]) catch return error.ValidationFailed;
+            const entrypoint_name = create_info.name[0..create_info.name_len];
+            const entry = blk: {
+                var it = parsed.iterator();
+                while (it.next() catch return error.ValidationFailed) |entry| if (std.mem.eql(u8, entry.name, entrypoint_name)) {
+                    break :blk entry;
+                };
+
+                try validation.assert(
+                    false,
+                    validation.shader.entry_not_found,
+                    .{entrypoint_name},
+                );
+                unreachable;
+            };
+
+            const code = try device.vtable.getShaderCode(device, .initZpsh(parsed));
+            errdefer device.vtable.destroyShaderCode(device, code);
+
+            const shader = try gpa.create(backend.Shader);
+            errdefer gpa.destroy(shader);
+
+            shader.* = try .init(gpa, code, entry);
+            errdefer shader.deinit(gpa);
+
+            return shader.toHandle();
+        },
+        else => |c| {
+            try validation.assert(
+                false,
+                validation.shader.unknown_code_type,
+                .{c},
+            );
+            unreachable;
+        },
+    };
+}
+
+pub fn destroyShader(device: *Device, shader: mango.Shader, maybe_gpa: ?std.mem.Allocator) void {
+    const gpa = maybe_gpa orelse device.gpa;
+    const b_shader = backend.Shader.fromHandleMutable(shader).?;
+    defer gpa.destroy(b_shader);
+    defer b_shader.deinit(gpa);
+
+    if (b_shader.code.ref.fetchSub(1, .monotonic) > 1) return;
+    device.vtable.destroyShaderCode(device, b_shader.code);
+}
+
+pub fn createVertexInputLayout(device: *Device, create_info: mango.VertexInputLayoutCreateInfo, maybe_gpa: ?std.mem.Allocator) ObjectCreationError!mango.VertexInputLayout {
+    const gpa = maybe_gpa orelse device.gpa;
+    const layout: *backend.VertexInputLayout = try gpa.create(backend.VertexInputLayout);
+    errdefer gpa.destroy(layout);
+
+    layout.* = try .compile(
+        create_info.bindings[0..create_info.bindings_len],
+        create_info.attributes[0..create_info.attributes_len],
+        create_info.fixed_attributes[0..create_info.fixed_attributes_len],
+    );
+    return layout.toHandle();
+}
+
+pub fn destroyVertexInputLayout(device: *Device, layout: mango.VertexInputLayout, maybe_gpa: ?std.mem.Allocator) void {
+    const gpa = maybe_gpa orelse device.gpa;
+    const b_layout: *const backend.VertexInputLayout = .fromHandleMutable(layout);
+    gpa.destroy(b_layout);
+}
+
+pub fn createLightLookupTable(device: *Device, create_info: mango.LightLookupTableCreateInfo, maybe_gpa: ?std.mem.Allocator) ObjectCreationError!mango.LightLookupTable {
+    const gpa = maybe_gpa orelse device.gpa;
+    const lut: *backend.LightLookupTable = try gpa.create(backend.LightLookupTable);
+    errdefer gpa.destroy(lut);
+
+    lut.* = .init(create_info);
+    return lut.toHandle();
+}
+
+pub fn destroyLightLookupTable(device: *Device, lut: mango.LightLookupTable, maybe_gpa: ?std.mem.Allocator) void {
+    const gpa = maybe_gpa orelse device.gpa;
+    const b_lut: *const backend.LightLookupTable = .fromHandleMutable(lut);
+    gpa.destroy(b_lut);
+}
+
+pub fn createSwapchain(device: *Device, create_info: mango.SwapchainCreateInfo, maybe_gpa: ?std.mem.Allocator) ObjectCreationError!mango.Swapchain {
+    return try device.vtable.createSwapchain(device, create_info, maybe_gpa orelse device.gpa);
+}
+
+pub fn destroySwapchain(device: *Device, swapchain: mango.Swapchain, maybe_gpa: ?std.mem.Allocator) void {
+    return device.vtable.destroySwapchain(device, swapchain, maybe_gpa orelse device.gpa);
+}
+
+pub fn getSwapchainImages(device: *Device, swapchain: mango.Swapchain, images: []mango.Image) !u8 {
+    return try device.vtable.getSwapchainImages(device, swapchain, images);
+}
+
+pub fn acquireNextImage(device: *Device, swapchain: mango.Swapchain, timeout: u64) AcquireNextImageError!u8 {
+    return try device.vtable.acquireNextImage(device, swapchain, timeout);
+}
+
+pub fn signalSemaphore(device: *Device, signal_info: mango.SemaphoreSignalInfo) SignalSemaphoreError!void {
+    return try device.vtable.signalSemaphore(device, signal_info);
+}
+
+pub fn waitSemaphores(device: *Device, wait_info: mango.SemaphoreWaitInfo, timeout: u64) WaitSemaphoreError!void {
+    var i: usize = 0;
+    while (i < wait_info.semaphore_count) : (i += 1) {
+        const sema = wait_info.semaphores[i];
+        const value = wait_info.values[i];
+
+        const b_sema: *backend.Semaphore = .fromHandleMutable(sema);
+        if (b_sema.counterValue() >= value) continue;
+
+        return try device.vtable.waitSemaphores(device, .{
+            .semaphore_count = wait_info.semaphore_count - i,
+            .semaphores = wait_info.semaphores[i..],
+            .values = wait_info.values[i..],
+        }, timeout);
+    }
+}
+
+pub fn waitIdle(device: *Device) void {
+    for (std.enums.values(Queue.Type)) |kind| {
+        const queue_status = device.queue_statuses.getPtr(kind);
+
+        while (true) switch (queue_status.load(.monotonic)) {
+            .idle => break,
+            // TODO: Make this return an error
+            .lost => break,
+            .waiting, .working, .work_completed => device.vtable.waitIdleQueue(device, kind),
+        };
+    }
+}
+
+pub fn wakeIdleQueue(device: *Device, reason: Queue.Type) void {
+    if (device.queue_statuses.getPtr(reason).load(.monotonic) == .idle) {
+        device.vtable.wakeIdleQueue(device, reason);
+    }
+}
+
+pub fn toHandle(device: *Device) Handle {
+    return @enumFromInt(@intFromPtr(device));
+}
+
+pub fn fromHandleMutable(handle: Handle) *Device {
+    return @as(*Device, @ptrFromInt(@intFromEnum(handle)));
+}
+
+const Device = @This();
+const backend = @import("backend.zig");
+
+const log = validation.log;
+const validation = backend.validation;
+
+const Queue = backend.Queue;
+
+const std = @import("std");
+const zitrus = @import("zitrus");
+
+const mango = zitrus.mango;
+const pica = zitrus.hardware.pica;
+
+const PhysicalAddress = zitrus.hardware.PhysicalAddress;
+
+pub const ScreenCapture = extern struct {};
diff --git a/src/platform/3ds/mango/mango/DeviceMemory.zig b/src/platform/3ds/mango/mango/DeviceMemory.zig
new file mode 100644
index 0000000..792373f
--- /dev/null
+++ b/src/platform/3ds/mango/mango/DeviceMemory.zig
@@ -0,0 +1,104 @@
+// XXX: This is not that great, the hardware can do MUCH more (coherent memory and persistently mapped buffers, hi?).
+// We could store one physical address only and map it but the kernel doesnt support that :(((
+
+pub const Handle = enum(u64) {
+    null = 0,
+    _,
+};
+
+pub const MemoryHeap = enum(u2) {
+    fcram,
+    vram_a,
+    vram_b,
+};
+
+pub const Data = packed struct(u64) {
+    valid: bool = true,
+    virtual_page_shifted: u20,
+    physical_page_shifted: u20,
+    size_page_shifted: u20,
+    heap: MemoryHeap,
+    _: u1 = 0,
+
+    pub fn init(virtual: [*]u8, physical: PhysicalAddress, memory_size: usize, heap: MemoryHeap) Data {
+        std.debug.assert(std.mem.isAligned(@intFromPtr(virtual), 4096));
+        std.debug.assert(std.mem.isAligned(@intFromEnum(physical), 4096));
+        std.debug.assert(std.mem.isAligned(memory_size, 4096));
+
+        return .{
+            .virtual_page_shifted = @intCast(@intFromPtr(virtual) >> 12),
+            .physical_page_shifted = @intCast(@intFromEnum(physical) >> 12),
+            .size_page_shifted = @intCast(memory_size >> 12),
+            .heap = heap,
+        };
+    }
+
+    pub fn size(data: Data) usize {
+        return @as(u32, data.size_page_shifted) << 12;
+    }
+};
+
+pub const BoundMemoryInfo = packed struct(u64) {
+    pub const empty: BoundMemoryInfo = .{ .virtual_page_shifted = 0, .physical_page_shifted = 0, .byte_offset = 0 };
+
+    virtual_page_shifted: u20,
+    physical_page_shifted: u20,
+    byte_offset: u12,
+    _: u12 = 0,
+
+    pub fn init(device_memory: DeviceMemory, offset: u32) BoundMemoryInfo {
+        const page_offset: u20 = @intCast(offset >> 12);
+        const byte_offset: u12 = @intCast(offset & 0xFFF);
+
+        return .{
+            .virtual_page_shifted = device_memory.data.virtual_page_shifted + page_offset,
+            .physical_page_shifted = device_memory.data.physical_page_shifted + page_offset,
+            .byte_offset = byte_offset,
+        };
+    }
+
+    pub fn boundVirtualAddress(info: BoundMemoryInfo) [*]u8 {
+        return @ptrFromInt((@as(u32, info.virtual_page_shifted) << 12) + info.byte_offset);
+    }
+
+    pub fn boundPhysicalAddress(info: BoundMemoryInfo) PhysicalAddress {
+        return .fromAddress((@as(u32, info.physical_page_shifted) << 12) + info.byte_offset);
+    }
+
+    pub fn isUnbound(info: BoundMemoryInfo) bool {
+        return info.virtual_page_shifted == info.physical_page_shifted and info.virtual_page_shifted == 0;
+    }
+};
+
+data: Data,
+
+pub fn virtualAddress(memory: DeviceMemory) [*]align(0x1000) u8 {
+    return @ptrFromInt((@as(u32, memory.data.virtual_page_shifted) << 12));
+}
+
+pub fn physicalAddress(memory: DeviceMemory) PhysicalAddress {
+    return .fromAddress((@as(u32, memory.data.physical_page_shifted) << 12));
+}
+
+pub fn size(memory: DeviceMemory) u32 {
+    return memory.data.size();
+}
+
+pub fn toHandle(memory: DeviceMemory) Handle {
+    return @enumFromInt(@as(u64, @bitCast(memory.data)));
+}
+
+pub fn fromHandle(handle: Handle) DeviceMemory {
+    return .{
+        .data = @bitCast(@intFromEnum(handle)),
+    };
+}
+
+const DeviceMemory = @This();
+
+const std = @import("std");
+const zitrus = @import("zitrus");
+const mango = zitrus.mango;
+const pica = zitrus.hardware.pica;
+
+const PhysicalAddress = zitrus.hardware.PhysicalAddress;
diff --git a/src/platform/3ds/mango/mango/GraphicsState.zig b/src/platform/3ds/mango/mango/GraphicsState.zig
new file mode 100644
index 0000000..666916d
--- /dev/null
+++ b/src/platform/3ds/mango/mango/GraphicsState.zig
@@ -0,0 +1,994 @@
+pub const Dirty = packed struct(u64) {
+    vertex_shader: bool = false,
+    vertex_shader_code: bool = false,
+    geometry_shader: bool = false,
+    geometry_shader_code: bool = false,
+    primitive_topology: bool = false,
+    cull_mode: bool = false,
+    depth_map_mode: bool = false,
+    depth_map_parameters: bool = false,
+    viewport_parameters: bool = false,
+    scissor_parameters: bool = false,
+    depth_test_masks: bool = false,
+    logic_blend_mode: bool = false,
+    blend_config: bool = false,
+    blend_constants: bool = false,
+    logic_operation: bool = false,
+    alpha_test: bool = false,
+    stencil_config: bool = false,
+    stencil_operation: bool = false,
+    combiners_config: bool = false,
+    combiners: hardware.BitpackedArray(bool, 6) = .splat(false),
+    vertex_input_layout: bool = false,
+    texture_config: bool = false,
+    lighting_enable: bool = false,
+    light_environment_control: bool = false,
+    light_environment_input: bool = false,
+    light_environment_scale: bool = false,
+    light_environment_absolute: bool = false,
+    light_luts: hardware.BitpackedArray(bool, 6) = .splat(false),
+    _: u26 = 0,
+};
+
+pub const DepthParameters = struct {
+    min_depth: f32,
+    max_depth: f32,
+    constant: f32 = 0,
+};
+
+pub const Viewport = packed struct(u40) {
+    x: u10,
+    y: u10,
+    width_minus_one: u10,
+    height_minus_one: u10,
+};
+
+pub const Scissor = packed struct(u40) {
+    x: u10,
+    y: u10,
+    end_x: u10,
+    end_y: u10,
+};
+
+pub const Misc = packed struct {
+    primitive_topology: pica.PrimitiveTopology,
+    cull_mode_ccw: pica.CullMode,
+    is_front_ccw: bool,
+    depth_mode: Graphics.Rasterizer.DepthMap.Mode,
+    is_scissor_inside: bool,
+    depth_test_enable: bool,
+    depth_test_op: pica.CompareOperation,
+    depth_write_enable: bool,
+
+    color_r_enable: bool,
+    color_g_enable: bool,
+    color_b_enable: bool,
+    color_a_enable: bool,
+
+    logic_op_enable: bool,
+    logic_op: pica.LogicOperation,
+
+    lighting_enable: bool,
+
+    alpha_test_enable: bool,
+    alpha_test_op: pica.CompareOperation,
+    alpha_test_reference: u8,
+
+    texture_2_coordinates: pica.TextureUnitTexture2Coordinates,
+    texture_3_coordinates: pica.TextureUnitTexture3Coordinates,
+};
+
+pub const Stencil = struct {
+    pub const empty: Stencil = .{ .state = std.mem.zeroes(State), .compare_mask = undefined, .write_mask = undefined, .reference = undefined };
+
+    pub const State = packed struct {
+        enable: bool,
+        op: pica.CompareOperation,
+        fail_op: pica.StencilOperation,
+        pass_op: pica.StencilOperation,
+        depth_fail_op: pica.StencilOperation,
+    };
+
+    state: State,
+    compare_mask: u8,
+    write_mask: u8,
+    reference: u8,
+};
+
+pub const LightEnvironment = struct {
+    control: FragmentLighting.Control,
+    lut_input_select: FragmentLighting.LookupTable.Select,
+    lut_input_abs: FragmentLighting.LookupTable.Absolute,
+    lut_input_scale: FragmentLighting.LookupTable.Scale,
+    // d0, d1, rr, rg, rb, fr. DA and SP are set per-light.
+    luts: [6]mango.LightLookupTable,
+};
+
+pub const Check = struct {
+    pub const Set = packed struct {
+        cull_mode: bool = false,
+        front_face: bool = false,
+        primitive_topology: bool = false,
+        viewport: bool = false,
+        scissor: bool = false,
+        texture_combiners: bool = false,
+        blend_equation: bool = false,
+        blend_constants: bool = false,
+        color_write_mask: bool = false,
+        depth_test_enable: bool = false,
+        depth_write_enable: bool = false,
+        depth_compare_op: bool = false,
+        depth_bias: bool = false,
+        depth_mode: bool = false,
+        logic_op_enable: bool = false,
+        logic_op: bool = false,
+        vertex_input: bool = false,
+        alpha_test_enable: bool = false,
+        alpha_test_op: bool = false,
+        alpha_test_reference: bool = false,
+        stencil_test_enable: bool = false,
+        lighting_enable: bool = false,
+    };
+
+    set: Set = .{},
+};
+
+pub const empty: GraphicsState = .{
+    .misc = std.mem.zeroes(Misc),
+    .stencil = .empty,
+    // NOTE: Always modified as a whole, can be `undefined`.
+    .blend_config = undefined,
+    .blend_constants = undefined,
+    .depth_map_parameters = undefined,
+    // NOTE: Always modified as a whole, can be `undefined`.
+    .viewport = undefined,
+    // NOTE: Always modified as a whole, can be `undefined`.
+    .scissor = undefined,
+    .combiners = undefined,
+    // NOTE: Always modified as a whole, can be `undefined`.
+    .vtx_input = undefined,
+    .light_environment = undefined,
+    .vertex_shader = null,
+    .geometry_shader = null,
+    .dirty = .{},
+};
+
+check: validation.Data(Check) = validation.init(Check, .{}),
+
+misc: Misc,
+stencil: Stencil,
+/// Always modify this as a whole or change `empty`
+blend_config: BlendConfig,
+blend_constants: [4]u8,
+depth_map_parameters: DepthParameters,
+/// Always modify this as a whole or change `empty`
+viewport: Viewport,
+/// Always modify this as a whole or change `empty`
+scissor: Scissor,
+combiners: TextureCombinerState = .empty,
+/// Always modify this as a whole or change `empty`
+vtx_input: VertexInputLayout,
+light_environment: LightEnvironment,
+vertex_shader: ?*backend.Shader,
+geometry_shader: ?*backend.Shader,
+dirty: Dirty,
+
+pub fn setDepthMode(state: *GraphicsState, mode: mango.DepthMode) void {
+    if (validation.enabled) state.check.set.depth_mode = true;
+
+    state.misc.depth_mode = mode.native();
+    state.dirty.depth_map_mode = true;
+}
+
+pub fn setCullMode(state: *GraphicsState, cull_mode: mango.CullMode) void {
+    if (validation.enabled) state.check.set.cull_mode = true;
+
+    const native_cull_mode_ccw = cull_mode.native(.ccw);
+
+    state.misc.cull_mode_ccw = native_cull_mode_ccw;
+    state.dirty.cull_mode = true;
+}
+
+pub fn setFrontFace(state: *GraphicsState, front_face: mango.FrontFace) void {
+    if (validation.enabled) state.check.set.front_face = true;
+
+    const front_ccw = switch (front_face) {
+        .ccw => true,
+        .cw => false,
+    };
+
+    state.misc.is_front_ccw = front_ccw;
+    state.dirty.cull_mode = true;
+}
+
+pub fn setPrimitiveTopology(state: *GraphicsState, primitive_topology: mango.PrimitiveTopology) void {
+    if (validation.enabled) state.check.set.primitive_topology = true;
+
+    const native_primitive_topology = primitive_topology.native();
+
+    state.misc.primitive_topology = native_primitive_topology;
+    state.dirty.primitive_topology = true;
+}
+
+pub fn setViewport(state: *GraphicsState, viewport: mango.Viewport) void {
+    if (validation.enabled) state.check.set.viewport = true;
+
+    const viewport_x: u10 = @intCast(viewport.rect.offset.x);
+    const viewport_y: u10 = @intCast(viewport.rect.offset.y);
+    const viewport_width_minus_one: u10 = @intCast(viewport.rect.extent.width - 1);
+    const viewport_height_minus_one: u10 = @intCast(viewport.rect.extent.height - 1);
+
+    state.viewport = .{
+        .x = viewport_x,
+        .y = viewport_y,
+        .width_minus_one = viewport_width_minus_one,
+        .height_minus_one = viewport_height_minus_one,
+    };
+    state.dirty.viewport_parameters = true;
+
+    state.depth_map_parameters.min_depth = viewport.min_depth;
+    state.depth_map_parameters.max_depth = viewport.max_depth;
+    state.dirty.depth_map_parameters = true;
+}
+
+pub fn setScissor(state: *GraphicsState, scissor: mango.Scissor) void {
+    if (validation.enabled) state.check.set.scissor = true;
+
+    const new_scissor: GraphicsState.Scissor = .{
+        .x = @intCast(scissor.rect.offset.x),
+        .y = @intCast(scissor.rect.offset.y),
+        .end_x = @intCast(scissor.rect.offset.x + @as(u10, @intCast(scissor.rect.extent.width - 1))),
+        .end_y = @intCast(scissor.rect.offset.y + @as(u10, @intCast(scissor.rect.extent.height - 1))),
+    };
+
+    const is_inside = switch (scissor.mode) {
+        .inside => true,
+        .outside => false,
+    };
+
+    state.scissor = new_scissor;
+    state.misc.is_scissor_inside = is_inside;
+    state.dirty.scissor_parameters = true;
+}
+
+pub fn setTextureCombiners(state: *GraphicsState, combiners: []const mango.TextureCombinerUnit, combiner_buffer_sources: []const mango.TextureCombinerUnit.BufferSources) void {
+    if (validation.enabled) state.check.set.texture_combiners = true;
+
+    state.combiners = .compile(combiners, combiner_buffer_sources);
+    state.dirty.combiners = comptime .splat(true);
+    state.dirty.combiners_config = true;
+}
+
+pub fn setBlendEquation(state: *GraphicsState, blend_equation: mango.ColorBlendEquation) void {
+    if (validation.enabled) state.check.set.blend_equation = true;
+
+    const native_blend_config = blend_equation.native();
+
+    state.blend_config = native_blend_config;
+    state.dirty.blend_config = true;
+}
+
+pub fn setBlendConstants(state: *GraphicsState, blend_constants: *const [4]u8) void {
+    if (validation.enabled) state.check.set.blend_constants = true;
+
+    state.blend_constants = blend_constants.*;
+    state.dirty.blend_constants = true;
+}
+
+pub fn setColorWriteMask(state: *GraphicsState, write_mask: mango.ColorComponentFlags) void {
+    if (validation.enabled) state.check.set.color_write_mask = true;
+
+    state.misc.color_r_enable = write_mask.r_enable;
+    state.misc.color_g_enable = write_mask.g_enable;
+    state.misc.color_b_enable = write_mask.b_enable;
+    state.misc.color_a_enable = write_mask.a_enable;
+    state.dirty.depth_test_masks = true;
+}
+
+pub fn setDepthTestEnable(state: *GraphicsState, enable: bool) void {
+    if (validation.enabled) state.check.set.depth_test_enable = true;
+
+    state.misc.depth_test_enable = enable;
+    state.dirty.depth_test_masks = true;
+}
+
+pub fn setDepthCompareOp(state: *GraphicsState, op: mango.CompareOperation) void {
+    if (validation.enabled) state.check.set.depth_compare_op = true;
+
+    const native_op = op.native();
+
+    state.misc.depth_test_op = native_op;
+    state.dirty.depth_test_masks = true;
+}
+
+pub fn setDepthWriteEnable(state: *GraphicsState, enable: bool) void {
+    if (validation.enabled) state.check.set.depth_write_enable = true;
+
+    state.misc.depth_write_enable = enable;
+    state.dirty.depth_test_masks = true;
+}
+
+pub fn setDepthBias(state: *GraphicsState, bias: f32) void {
+    if (validation.enabled) state.check.set.depth_bias = true;
+
+    state.depth_map_parameters.constant = bias;
+    state.dirty.depth_map_parameters = true;
+}
+
+pub fn setLogicOpEnable(state: *GraphicsState, enable: bool) void {
+    if (validation.enabled) state.check.set.logic_op_enable = true;
+
+    state.misc.logic_op_enable = enable;
+    state.dirty.logic_blend_mode = true;
+}
+
+pub fn setLogicOp(state: *GraphicsState, logic_op: mango.LogicOperation) void {
+    if (validation.enabled) state.check.set.logic_op = true;
+
+    const native_logic_op = logic_op.native();
+
+    state.misc.logic_op = native_logic_op;
+    state.dirty.logic_operation = true;
+}
+
+pub fn setAlphaTestEnable(state: *GraphicsState, enable: bool) void {
+    if (validation.enabled) state.check.set.alpha_test_enable = true;
+
+    state.misc.alpha_test_enable = enable;
+    state.dirty.alpha_test = true;
+}
+
+pub fn setAlphaTestCompareOp(state: *GraphicsState, compare_op: mango.CompareOperation) void {
+    if (validation.enabled) state.check.set.alpha_test_op = true;
+
+    const native = compare_op.native();
+
+    state.misc.alpha_test_op = native;
+    state.dirty.alpha_test = true;
+}
+
+pub fn setAlphaTestReference(state: *GraphicsState, reference: u8) void {
+    if (validation.enabled) state.check.set.alpha_test_reference = true;
+
+    state.misc.alpha_test_reference = reference;
+    state.dirty.alpha_test = true;
+}
+
+pub fn setStencilTestEnable(state: *GraphicsState, enable: bool) void {
+    if (validation.enabled) state.check.set.stencil_test_enable = true;
+
+    state.stencil.state.enable = enable;
+    state.dirty.stencil_config = true;
+}
+
+pub fn setStencilOp(state: *GraphicsState, fail_op: mango.StencilOperation, pass_op: mango.StencilOperation, depth_fail_op: mango.StencilOperation, op: mango.CompareOperation) void {
+    const native_fail = fail_op.native();
+    const native_pass = pass_op.native();
+    const native_depth_fail = depth_fail_op.native();
+    const native_op = op.native();
+
+    state.stencil.state.op = native_op;
+    state.stencil.state.fail_op = native_fail;
+    state.stencil.state.pass_op = native_pass;
+    state.stencil.state.depth_fail_op = native_depth_fail;
+    state.dirty.stencil_config = true;
+    state.dirty.stencil_operation = true;
+}
+
+pub fn setStencilCompareMask(state: *GraphicsState, compare_mask: u8) void {
+    state.stencil.compare_mask = compare_mask;
+    state.dirty.stencil_config = true;
+}
+
+pub fn setStencilWriteMask(state: *GraphicsState, write_mask: u8) void {
+    state.stencil.write_mask = write_mask;
+    state.dirty.stencil_config = true;
+}
+
+pub fn setStencilReference(state: *GraphicsState, reference: u8) void {
+    state.stencil.reference = reference;
+    state.dirty.stencil_config = true;
+}
+
+pub fn setVertexInput(state: *GraphicsState, layout: mango.VertexInputLayout) void {
+    if (validation.enabled) state.check.set.vertex_input = true;
+
+    state.vtx_input = backend.VertexInputLayout.fromHandleMutable(layout).*;
+    state.dirty.vertex_input_layout = true;
+}
+
+pub fn setTextureCoordinates(state: *GraphicsState, texture_2_coordinates: mango.TextureCoordinateSource, texture_3_coordinates: mango.TextureCoordinateSource) void {
+    state.misc.texture_2_coordinates = texture_2_coordinates.nativeTexture2();
+    state.misc.texture_3_coordinates = texture_3_coordinates.nativeTexture3();
+    state.dirty.texture_config = true;
+}
+
+pub fn setLightingEnable(state: *GraphicsState, enable: bool) void {
+    if (validation.enabled) state.check.set.lighting_enable = true;
+
+    state.misc.lighting_enable = enable;
+    state.dirty.lighting_enable = true;
+}
+
+pub fn setLightEnvironmentEnable(state: *GraphicsState, enable: mango.LightEnvironmentEnable) void {
+    state.light_environment.control = .{
+        .environment = .{
+            .enable_shadow_factor = false,
+            .fresnel = enable.fresnel.native(),
+            .enabled_lookup_tables = enable.nativeEnabledLookupTables(),
+            .apply_shadow_attenuation_to_primary_color = false,
+            .apply_shadow_attenuation_to_secondary_color = false,
+            .invert_shadow_attenuation = false,
+            .apply_shadow_attenuation_to_alpha = false,
+            .bump_map_unit = .@"0",
+            .shadow_map_unit = .@"0", // Not configurable, only unit 0 can use shadow textures...
+            .clamp_highlights = false,
+            .bump_mode = .none,
+            .disable_bump_recalculation = false,
+        },
+        .lights = .{
+            .shadows_disabled = .splat(true),
+            .spotlight_disabled = .splat(true),
+            .disable_d0 = !enable.distribution[0],
+            .disable_d1 = !enable.distribution[1],
+            .disable_fr = enable.fresnel == .none,
+            .disable_rb = !enable.reflection[2],
+            .disable_rg = !enable.reflection[1],
+            .disable_rr = !enable.reflection[0],
+            .distance_attenuation_disabled = .splat(true), // Set by lights
+        },
+    };
+
+    state.dirty.light_environment_control = true;
+}
+
+pub fn setLightEnvironmentInput(state: *GraphicsState, input: mango.LightEnvironmentInput) void {
+    state.light_environment.lut_input_select = .{
+        .d0 = input.distribution[0].native(),
+        .d1 = input.distribution[1].native(),
+        .sp = input.spotlight.native(),
+        .fr = input.fresnel.native(),
+        .rb = input.reflection[2].native(),
+        .rg = input.reflection[1].native(),
+        .rr = input.reflection[0].native(),
+    };
+
+    state.dirty.light_environment_input = true;
+}
+
+pub fn setLightEnvironmentRange(state: *GraphicsState, range: mango.LightEnvironmentRange) void {
+    state.light_environment.lut_input_abs = .{
+        .disable_d0 = range.distribution[0] == .full,
+        .disable_d1 = range.distribution[1] == .full,
+        .disable_sp = range.spotlight == .full,
+        .disable_fr = range.fresnel == .full,
+        .disable_rb = range.reflection[2] == .full,
+        .disable_rg = range.reflection[1] == .full,
+        .disable_rr = range.reflection[0] == .full,
+    };
+
+    state.dirty.light_environment_absolute = true;
+}
+
+pub fn setLightEnvironmentScale(state: *GraphicsState, scale: mango.LightEnvironmentScale) void {
+    state.light_environment.lut_input_scale = .{
+        .d0 = scale.distribution[0].nativeLightLookupMultiplier(),
+        .d1 = scale.distribution[1].nativeLightLookupMultiplier(),
+        .sp = scale.spotlight.nativeLightLookupMultiplier(),
+        .fr = scale.fresnel.nativeLightLookupMultiplier(),
+        .rb = scale.reflection[2].nativeLightLookupMultiplier(),
+        .rg = scale.reflection[1].nativeLightLookupMultiplier(),
+        .rr = scale.reflection[0].nativeLightLookupMultiplier(),
+    };
+
+    state.dirty.light_environment_scale = true;
+}
+
+pub fn bindLightEnvironmentTable(state: *GraphicsState, slot: mango.LightEnvironmentLookupSlot, table: mango.LightLookupTable) void {
+    state.light_environment.luts[@intFromEnum(slot)] = table;
+
+    // NOTE: we have to do this because we get a bit-pointer here
+    var luts = state.dirty.light_luts;
+    luts.set(@intFromEnum(slot), true);
+    state.dirty.light_luts = luts;
+}
+
+pub fn bindShaders(state: *GraphicsState, stages: []const mango.ShaderStage, shaders: []const mango.Shader) void {
+    std.debug.assert(stages.len == shaders.len and stages.len < 2);
+
+    for (stages, shaders) |stage, shader| {
+        const maybe_new: ?*backend.Shader = .fromHandleMutable(shader);
+
+        switch (stage) {
+            .vertex => if (maybe_new) |new| {
+                // NOTE: as it is invalid to do a drawcall without a vertex shader, we make binding a null one a NOP
+
+                if (state.vertex_shader) |vtx| {
+                    state.vertex_shader = new;
+                    state.dirty.vertex_shader = state.dirty.vertex_shader or new != vtx;
+                    state.dirty.vertex_shader_code = state.dirty.vertex_shader_code or new.code.uid != vtx.code.uid;
+                } else {
+                    state.vertex_shader = maybe_new;
+                    state.dirty.vertex_shader = true;
+                    state.dirty.vertex_shader_code = true;
+                }
+            },
+            .geometry => if (maybe_new) |new| {
+                if (state.geometry_shader) |gs| {
+                    state.geometry_shader = new;
+                    state.dirty.geometry_shader = state.dirty.geometry_shader or new != gs;
+                    state.dirty.geometry_shader_code = state.dirty.geometry_shader_code or new.code.uid != gs.code.uid;
+                } else {
+                    state.geometry_shader = new;
+                    state.dirty.geometry_shader = true;
+                    state.dirty.geometry_shader_code = true;
+                }
+            } else {
+                state.geometry_shader = null;
+                state.dirty.geometry_shader = true;
+                state.dirty.geometry_shader_code = false; // NOTE: must set this to false, binding null shouldn't change the uploaded code.
+            },
+        }
+    }
+}
+
+pub fn anyDirty(state: *GraphicsState) bool {
+    return @as(u64, @bitCast(state.dirty)) != 0;
+}
+
+/// Returns the maximum amount of words the next dirty emission will take.
+///
+/// Its a safe upper bound, not the exact amount needed.
+pub fn maxEmitDirtyQueueLength(state: *GraphicsState) usize {
+    // NOTE: This must be FAST as its always checked every drawcall!
+    var max: usize = (@as(usize, state.dirty.combiners.raw) * 9) + (@as(usize, state.dirty.light_luts.raw) * 300) + (@as(usize, @intFromBool(state.dirty.vertex_shader)) * 32) + (@as(usize, @intFromBool(state.dirty.geometry_shader)) * 32);
+
+    if (state.dirty.vertex_shader_code) max += if (state.vertex_shader) |vtx|
+        10 + vtx.code.instructions.len + vtx.code.descriptors.len
+    else
+        0;
+
+    if (state.dirty.geometry_shader_code) max += if (state.geometry_shader) |gs|
+        10 + gs.code.instructions.len + gs.code.descriptors.len
+    else
+        0;
+    return max + 72;
+}
+
+pub fn validate(state: *GraphicsState) !void {
+    if (!validation.enabled) return;
+
+    const check = state.check;
+
+    const conditions: []const bool = &.{
+        state.vertex_shader != null,
+        check.set.cull_mode,
+        check.set.front_face,
+        check.set.primitive_topology,
+        check.set.viewport,
+        check.set.scissor,
+        check.set.texture_combiners,
+        check.set.blend_equation,
+        check.set.color_write_mask,
+        check.set.depth_test_enable,
+        check.set.logic_op_enable,
+        check.set.vertex_input,
+        check.set.alpha_test_enable,
+        check.set.stencil_test_enable,
+        check.set.lighting_enable,
+    };
+
+    const kinds: []const []const u8 = &.{
+        "vertex shader",
+        "cull mode",
+        "front face",
+        "primitive topology",
+        "viewport",
+        "scissor",
+        "texture combiners",
+        "blend equation",
+        "color write mask",
+        "depth test enable",
+        "logic op enable",
+        "vertex input layout",
+        "alpha test enable",
+        "stencil test enable",
+        "lighting enable",
+    };
+
+    var success = true;
+
+    for (conditions, kinds) |condition, kind| {
+        success &= validation.check(condition, validation.graphics_state.must_be_set, .{kind});
+    }
+
+    if (!success) return error.ValidationFailed;
+}
+
+pub fn emitDirty(state: *GraphicsState, queue: *command.Queue) void {
+    // NOTE: Here we don't set uniforms, that belongs to `RenderingState`
+    if (state.dirty.vertex_shader or state.dirty.geometry_shader) {
+        // NOTE: a vertex shader must always be bound when drawing
+        const vtx = state.vertex_shader.?;
+        std.debug.assert(vtx.info.type == .vertex);
+
+        if (state.dirty.vertex_shader_code) {
+            // NOTE: when code is dirty a shader is always present
+            const common = (state.dirty.geometry_shader_code and vtx.code.uid == state.geometry_shader.?.code.uid) or state.geometry_shader == null;
+
+            if (common) {
+                queue.add(p3d, &p3d.primitive_engine.exclusive_shader_configuration, .init(false));
+                queue.addMasked(p3d, &p3d.primitive_engine.config, .{
+                    .geometry_shader_usage = .disabled,
+                    .variable_geometry_inputs = false,
+                }, 0b1101);
+                state.dirty.geometry_shader_code = false; // We're already uploading code to both so don't go through that path
+            }
+
+            state.emitCode(queue, &p3d.vertex_shader, vtx.code);
+        }
+
+        if (state.dirty.vertex_shader) {
+            queue.add(p3d, &p3d.vertex_shader.entrypoint, .{ .entry = vtx.entry });
+            queue.add(p3d, &p3d.vertex_shader.output_map_mask, .init(@bitCast(vtx.output_set.bits)));
+
+            const outputs_minus_one: u4 = @intCast(vtx.output_set.count() - 1);
+            queue.add(p3d, &p3d.primitive_engine.vertex_shader_output_map_total_1, .init(outputs_minus_one));
+            queue.add(p3d, &p3d.primitive_engine.vertex_shader_output_map_total_2, .init(outputs_minus_one));
+            queue.addMasked(p3d, &p3d.primitive_engine.primitive_config, .{
+                .total_vertex_outputs = outputs_minus_one,
+                .topology = .triangle_list, // NOTE: Ignored by mask
+            }, 0b0001);
+        }
+
+        if (state.dirty.geometry_shader and state.geometry_shader != null) {
+            const gs = state.geometry_shader.?;
+
+            queue.add(p3d, &p3d.primitive_engine.exclusive_shader_configuration, .init(true));
+            queue.addMasked(p3d, &p3d.primitive_engine.config, .{
+                .geometry_shader_usage = .enabled,
+                .variable_geometry_inputs = gs.info.type == .geometry_variable,
+            }, 0b1101);
+
+            if (state.dirty.geometry_shader_code) state.emitCode(queue, &p3d.geometry_shader, gs.code);
+
+            queue.add(p3d, &p3d.geometry_shader.entrypoint, .{ .entry = gs.entry });
+            queue.add(p3d, &p3d.geometry_shader.output_map_mask, .init(@bitCast(gs.output_set.bits)));
+
+            queue.add(p3d, &p3d.geometry_shader.input, .{
+                .inputs = switch (gs.info.type) {
+                    .vertex => unreachable,
+                    .geometry_point => gs.info.geometry.point.inputs_minus_one,
+                    .geometry_variable, .geometry_fixed => 0,
+                },
+                .enabled_for_geometry_0 = true,
+            });
+
+            queue.add(p3d, &p3d.vertex_shader.attribute_permutation, state.vtx_input.permutation);
+            queue.add(p3d, &p3d.primitive_engine.geometry_shader, .{
+                .mode = switch (gs.info.type) {
+                    .vertex => unreachable,
+                    .geometry_point => .point,
+                    .geometry_variable => .variable,
+                    .geometry_fixed => .fixed,
+                },
+                .fixed_vertices_minus_one = gs.info.geometry.fixed.vertices_minus_one,
+                .point_inputs_minus_one = gs.info.geometry.point.inputs_minus_one,
+                .uniform_start = gs.info.geometry.fixed.uniform_start,
+                .fixed = gs.info.type == .geometry_fixed,
+            });
+
+            queue.add(p3d, &p3d.primitive_engine.geometry_shader_full_vertices_minus_one, .init(gs.info.geometry.variable.full_vertices));
+        }
+
+        // NOTE: we don't have to change the output to the rasterizer if we have a geometry shader
+        // and ONLY a vertex shader has changed as the rasterizer will still get the outputs from the geometry shader.
+        if ((state.dirty.vertex_shader and state.geometry_shader == null) or state.dirty.geometry_shader) {
+            const output_set, const outputs = if (state.geometry_shader) |gs|
+                .{ gs.output_set, gs.output_map }
+            else
+                .{ vtx.output_set, vtx.output_map };
+
+            var attribute_clock: pica.Graphics.Rasterizer.Clock = .{};
+
+            var out_it = output_set.iterator();
+            var semantic_outputs: usize = 0;
+            while (out_it.next()) |o| {
+                const map = outputs[semantic_outputs];
+
+                if (@intFromEnum(o) >= @intFromEnum(pica.shader.register.Destination.Output.o7)) {
+                    std.debug.assert(map.x == .unused and map.y == .unused and map.z == .unused and map.w == .unused);
+                    continue;
+                }
+
+                const tex_coords_present = &attribute_clock.texture_coordinates;
+
+                attribute_clock.color = attribute_clock.color or (map.x.isColor() or map.y.isColor() or map.z.isColor() or map.w.isColor());
+                attribute_clock.position_z = attribute_clock.position_z or (map.x == .position_z or map.y == .position_z or map.z == .position_z or map.w == .position_z);
+                tex_coords_present.* = tex_coords_present.copyWith(0, tex_coords_present.get(0) or (map.x.isTextureCoordinates0() or map.y.isTextureCoordinates0() or map.z.isTextureCoordinates0() or map.w.isTextureCoordinates0()));
+                tex_coords_present.* = tex_coords_present.copyWith(1, tex_coords_present.get(1) or (map.x.isTextureCoordinates1() or map.y.isTextureCoordinates1() or map.z.isTextureCoordinates1() or map.w.isTextureCoordinates1()));
+                tex_coords_present.* = tex_coords_present.copyWith(2, tex_coords_present.get(2) or (map.x.isTextureCoordinates2() or map.y.isTextureCoordinates2() or map.z.isTextureCoordinates2() or map.w.isTextureCoordinates2()));
+                attribute_clock.texture_coordinates_0_w = attribute_clock.texture_coordinates_0_w or (map.x == .texture_coordinates_0_w or map.y == .texture_coordinates_0_w or map.z == .texture_coordinates_0_w or map.w == .texture_coordinates_0_w);
+                attribute_clock.normal_or_view = attribute_clock.normal_or_view or (map.x.isView() or map.x.isNormalQuaternion()) or (map.y.isView() or map.y.isNormalQuaternion()) or (map.z.isView() or map.z.isNormalQuaternion()) or (map.w.isView() or map.w.isNormalQuaternion());
+
+                queue.add(p3d, &p3d.rasterizer.inputs[semantic_outputs], map);
+                semantic_outputs += 1;
+            }
+
+            queue.add(p3d, &p3d.rasterizer.num_inputs, .init(@intCast(semantic_outputs)));
+            queue.add(p3d, &p3d.rasterizer.input_clock, attribute_clock);
+            queue.add(p3d, &p3d.rasterizer.input_mode, .{
+                .use_texture_coordinates = (attribute_clock.texture_coordinates.raw != 0) or attribute_clock.texture_coordinates_0_w,
+            });
+        }
+    }
+
+    if (state.dirty.cull_mode) {
+        // NOTE: emission takes 2 words
+        const cull_mode_ccw = state.misc.cull_mode_ccw;
+        const is_front_ccw = state.misc.is_front_ccw;
+
+        queue.add(p3d, &p3d.rasterizer.cull_config, .init(if (is_front_ccw)
+            cull_mode_ccw
+        else switch (cull_mode_ccw) {
+            .none => .none,
+            .ccw => .cw,
+            .cw => .ccw,
+        }));
+    }
+
+    if (state.dirty.viewport_parameters) {
+        // NOTE: emission takes 8 words
+
+        const flt_width = @as(f32, @floatFromInt(state.viewport.width_minus_one)) + 1.0;
+        const flt_height = @as(f32, @floatFromInt(state.viewport.height_minus_one)) + 1.0;
+
+        queue.addIncremental(p3d, .{
+            &p3d.rasterizer.viewport_h_scale,
+            &p3d.rasterizer.viewport_h_step,
+            &p3d.rasterizer.viewport_v_scale,
+            &p3d.rasterizer.viewport_v_step,
+        }, .{
+            .init(.of(flt_width / 2.0)),
+            .init(.of(2.0 / flt_width)),
+            .init(.of(flt_height / 2.0)),
+            .init(.of(2.0 / flt_height)),
+        });
+
+        queue.add(p3d, &p3d.rasterizer.viewport_xy, .{ state.viewport.x, state.viewport.y });
+    }
+
+    if (state.dirty.scissor_parameters) {
+        // NOTE: emission takes 4 words
+        queue.add(p3d, &p3d.rasterizer.scissor, .{
+            .mode = .init(if (state.misc.is_scissor_inside) .inside else .outside),
+            .start = .{ state.scissor.x, state.scissor.y },
+            .end = .{ state.scissor.end_x, state.scissor.end_y },
+        });
+    }
+
+    if (state.dirty.depth_map_mode) {
+        // NOTE: emission takes 2 words
+        queue.add(p3d, &p3d.rasterizer.depth_map_mode, .init(state.misc.depth_mode));
+    }
+
+    if (state.dirty.depth_map_parameters) {
+        // NOTE: emission takes 4 words
+        const depth_map_scale = (state.depth_map_parameters.min_depth - state.depth_map_parameters.max_depth);
+        const depth_map_bias = state.depth_map_parameters.min_depth + state.depth_map_parameters.constant;
+
+        queue.add(p3d, &p3d.rasterizer.depth_map, .{
+            .scale = .init(.of(depth_map_scale)),
+            .bias = .init(.of(depth_map_bias)),
+        });
+    }
+
+    if (state.dirty.primitive_topology) {
+        // NOTE: emission takes 6 words
+        const primitive_topology = state.misc.primitive_topology;
+
+        queue.addMasked(p3d, &p3d.primitive_engine.primitive_config, .{
+            .total_vertex_outputs = 0, // NOTE: Ignored by mask
+            .topology = primitive_topology.indexedTopology(),
+        }, 0b0010);
+
+        queue.addMasked(p3d, &p3d.primitive_engine.config, .{
+            .drawing_triangles = primitive_topology == .triangle_list,
+        }, 0b0010);
+
+        queue.addMasked(p3d, &p3d.primitive_engine.state, .{
+            .drawing_triangles = primitive_topology == .triangle_list,
+        }, 0b0010);
+    }
+
+    if (state.dirty.logic_blend_mode) {
+        // NOTE: emission takes 2 words
+        queue.addMasked(p3d, &p3d.output_merger.config, .{
+            .mode = .default,
+            .blend = if (state.misc.logic_op_enable) .logic else .blend,
+        }, 0b0110);
+    }
+
+    if (state.dirty.logic_operation) {
+        // NOTE: emission takes 2 words
+        queue.add(p3d, &p3d.output_merger.logic_config, .init(state.misc.logic_op));
+    }
+
+    if (state.dirty.depth_test_masks) {
+        queue.add(p3d, &p3d.rasterizer.early_depth_test_enable, .init(false));
+        queue.add(p3d, &p3d.output_merger.early_depth_test_enable, .init(false));
+
+        // NOTE: emission takes 2 words
+        queue.add(p3d, &p3d.output_merger.depth_color_config, .{
+            .enable_depth_test = state.misc.depth_test_enable,
+            .depth_op = state.misc.depth_test_op,
+            .enable_r_write = state.misc.color_r_enable,
+            .enable_g_write = state.misc.color_g_enable,
+            .enable_b_write = state.misc.color_b_enable,
+            .enable_a_write = state.misc.color_a_enable,
+            .enable_depth_write = state.misc.depth_test_enable and state.misc.depth_write_enable,
+        });
+    }
+
+    if (state.dirty.blend_config) {
+        // NOTE: emission takes 2 words
+        queue.add(p3d, &p3d.output_merger.blend_config, state.blend_config);
+    }
+
+    if (state.dirty.blend_constants) {
+        // NOTE: emission takes 2 words
+        queue.add(p3d, &p3d.output_merger.blend_color, state.blend_constants);
+    }
+
+    if (state.dirty.alpha_test) {
+        // NOTE: emission takes 2 words
+        queue.add(p3d, &p3d.output_merger.alpha_test, .{
+            .enable = state.misc.alpha_test_enable,
+            .op = state.misc.alpha_test_op,
+            .reference = state.misc.alpha_test_reference,
+        });
+    }
+
+    if (state.dirty.stencil_config) {
+        // NOTE: emission takes 2 words
+        queue.add(p3d, &p3d.output_merger.stencil_test.config, .{
+            .enable = state.stencil.state.enable,
+            .op = state.stencil.state.op,
+            .compare_mask = state.stencil.compare_mask,
+            .reference = state.stencil.reference,
+            .write_mask = state.stencil.write_mask,
+        });
+    }
+
+    if (state.dirty.stencil_operation) {
+        // NOTE: emission takes 2 words
+        queue.add(p3d, &p3d.output_merger.stencil_test.operation, .{
+            .fail = state.stencil.state.fail_op,
+            .depth_fail = state.stencil.state.depth_fail_op,
+            .pass = state.stencil.state.pass_op,
+        });
+    }
+
+    if (state.dirty.combiners_config) {
+        // NOTE: emission takes 2 words
+        queue.add(p3d, &p3d.texture_combiners.config, state.combiners.config);
+    }
+
+    if (state.dirty.combiners.raw != 0) {
+        // NOTE: emission takes 8 words per combiner
+        const combiner_regs = &p3d.texture_combiners;
+        const units: []const *volatile Graphics.TextureCombiners.Unit = &.{ &combiner_regs.@"0", &combiner_regs.@"1", &combiner_regs.@"2", &combiner_regs.@"3", &combiner_regs.@"4", &combiner_regs.@"5" };
+        const units_start: usize = units.len - state.combiners.configured;
+
+        var i: u8 = 0;
+        while (i < state.combiners.configured) : (i += 1) {
+            queue.add(p3d, units[units_start + i], state.combiners.units[i]);
+        }
+    }
+
+    if (state.dirty.vertex_input_layout) {
+        queue.addIncremental(p3d, .{
+            &p3d.primitive_engine.attributes.base,
+            &p3d.primitive_engine.attributes.config.low,
+            &p3d.primitive_engine.attributes.config.high,
+        }, .{
+            .fromPhysical(backend.global_attribute_buffer_base),
+            state.vtx_input.config.low,
+            state.vtx_input.config.high,
+        });
+
+        for (0..state.vtx_input.buffers_len) |i| {
+            queue.add(p3d, &p3d.primitive_engine.attributes.vertex_buffers[i].config, state.vtx_input.buffer_config[i]);
+        }
+
+        queue.add(p3d, &p3d.primitive_engine.vertex_shader_input_attributes, .init(state.vtx_input.config.high.attributes_end));
+
+        queue.add(p3d, &p3d.vertex_shader.input, .{
+            .inputs = (state.vtx_input.config.high.attributes_end),
+            .enabled_for_vertex_0 = true,
+            .enabled_for_vertex_1 = true,
+        });
+
+        queue.add(p3d, &p3d.vertex_shader.attribute_permutation, state.vtx_input.permutation);
+    }
+
+    if (state.dirty.texture_config) {
+        // NOTE: emission takes 2 words
+        queue.addMasked(p3d, &p3d.texture_units.config, .{
+            .texture_enabled = .splat(false),
+            .texture_3_coordinates = state.misc.texture_3_coordinates,
+            .texture_3_enabled = false, // TODO: Procedural texture support, should be part of gfx state, not rendering unlike normal textures!
+            .texture_2_coordinates = state.misc.texture_2_coordinates,
+            .clear_texture_cache = false,
+        }, 0b0010);
+    }
+
+    if (state.dirty.lighting_enable) {
+        queue.add(p3d, &p3d.texture_units.lighting_enable, .init(state.misc.lighting_enable));
+        queue.add(p3d, &p3d.fragment_lighting.disable, .init(!state.misc.lighting_enable));
+    }
+
+    if (state.dirty.light_environment_control) {
+        queue.add(p3d, &p3d.fragment_lighting.control.environment, state.light_environment.control.environment);
+        // NOTE: this only changes disabled LUTs
+        queue.addMasked(p3d, &p3d.fragment_lighting.control.lights, state.light_environment.control.lights, 0b0100);
+    }
+
+    if (state.dirty.light_environment_input) {
+        queue.add(p3d, &p3d.fragment_lighting.lut_input_select, state.light_environment.lut_input_select);
+    }
+
+    if (state.dirty.light_environment_absolute) {
+        queue.add(p3d, &p3d.fragment_lighting.lut_input_absolute, state.light_environment.lut_input_abs);
+    }
+
+    if (state.dirty.light_environment_scale) {
+        queue.add(p3d, &p3d.fragment_lighting.lut_input_scale, state.light_environment.lut_input_scale);
+    }
+
+    if (state.dirty.light_luts.raw != 0) {
+        const selectors: []const pica.Graphics.FragmentLighting.LookupTable = &.{ .d0, .d1, .rr, .rg, .rb, .fr };
+
+        for (0..6) |i| if (state.dirty.light_luts.get(i) and state.light_environment.luts[i] != .null) {
+            const b_table: *backend.LightLookupTable = .fromHandleMutable(state.light_environment.luts[i]);
+
+            queue.add(p3d, &p3d.fragment_lighting.lut_index, .init(selectors[i], 0));
+            queue.addConsecutive(p3d, &p3d.fragment_lighting.lut_data[0], &b_table.data);
+        };
+    }
+
+    state.dirty = .{};
+}
+
+fn emitCode(_: *GraphicsState, queue: *command.Queue, shader: *volatile pica.Graphics.Shader, code: *backend.Shader.Code) void {
+    queue.add(p3d, &shader.code_transfer_index, .init(0));
+    queue.addConsecutive(p3d, &shader.code_transfer_data[0], code.instructions);
+
+    queue.add(p3d, &shader.code_transfer_end, .init(.trigger));
+
+    queue.add(p3d, &shader.operand_descriptors_index, .init(0));
+    queue.addConsecutive(p3d, &shader.operand_descriptors_data[0], code.descriptors);
+}
+
+const GraphicsState = @This();
+
+const backend = @import("backend.zig");
+const validation = backend.validation;
+
+const TextureCombinerState = backend.TextureCombinerState;
+const VertexInputLayout = backend.VertexInputLayout;
+
+const std = @import("std");
+const zitrus = @import("zitrus");
+
+const hardware = zitrus.hardware;
+const mango = zitrus.mango;
+const pica = hardware.pica;
+
+const Graphics = pica.Graphics;
+const FragmentLighting = Graphics.FragmentLighting;
+const BlendConfig = Graphics.OutputMerger.BlendConfig;
+
+const command = pica.command;
+
+const p3d = &zitrus.memory.arm11.pica.p3d;
diff --git a/src/platform/3ds/mango/mango/Image.zig b/src/platform/3ds/mango/mango/Image.zig
new file mode 100644
index 0000000..5b8e9fc
--- /dev/null
+++ b/src/platform/3ds/mango/mango/Image.zig
@@ -0,0 +1,141 @@
+//! A PICA200 image
+//!
+//! Images have numerous usages and thus they can be sampled, rendered to, and presented as an LCD framebuffer.
+//!
+//! However the PICA200 imposes some limitations:
+//!     - Sampled images MUST be optimally tiled, powers of two and have a size of `[8, 1024]`.
+//!     - Color / Depth attachment images MUST be optimally tiled, divisible by the attachment render block size {8, 32} (TODO), be device local, and have a size `[8, 1024]`.
+//!
+//!
+//! There's one more limitation which is not imposed by the PICA200 but by the LCD framebuffers, images must be linearly tiled.
+
+pub const Handle = enum(u32) {
+    null = 0,
+    _,
+};
+
+pub const Info = packed struct(u64) {
+    width_minus_one: u10,
+    height_minus_one: u10,
+    format: mango.Format,
+    optimally_tiled: bool,
+    mutable_format: bool,
+    cube_compatible: bool,
+    // NOTE: Is not scaled by bpp. The maximum value that this value could be is `1398080`
+    /// Unscaled size of layers, scale it by the format bpp to get the total layer size.
+    layer_size: u22,
+    levels_minus_one: u3 = 0,
+    layers_minus_one: u3 = 0,
+    _: u5 = 0,
+
+    pub fn init(create_info: mango.ImageCreateInfo) Info {
+        return .{
+            .width_minus_one = @intCast(create_info.extent.width - 1),
+            .height_minus_one = @intCast(create_info.extent.height - 1),
+            .format = create_info.format,
+            .optimally_tiled = switch (create_info.tiling) {
+                .optimal => true,
+                .linear => false,
+            },
+            .mutable_format = create_info.flags.mutable_format,
+            .cube_compatible = create_info.flags.cube_compatible,
+            .layer_size = @intCast(backend.imageLayerSize(@as(usize, create_info.extent.width) * create_info.extent.height, @intFromEnum(create_info.mip_levels))),
+            .layers_minus_one = @intCast(@intFromEnum(create_info.array_layers) - 1),
+            .levels_minus_one = @intCast(@intFromEnum(create_info.mip_levels) - 1),
+        };
+    }
+
+    pub fn width(info: Info) u16 {
+        return @as(u16, info.width_minus_one) + 1;
+    }
+
+    pub fn height(info: Info) u16 {
+        return @as(u16, info.height_minus_one) + 1;
+    }
+
+    pub fn size(info: Info) usize {
+        return info.width() * @as(usize, info.height());
+    }
+
+    pub fn layers(info: Info) usize {
+        return @as(usize, info.layers_minus_one) + 1;
+    }
+
+    pub fn levels(info: Info) usize {
+        return @as(usize, info.levels_minus_one) + 1;
+    }
+
+    pub fn levelsByAmount(info: Info, amount: mango.ImageMipLevels, base: mango.ImageMipLevel) usize {
+        return switch (amount) {
+            .remaining => info.levels() - @intFromEnum(base),
+            else => @intFromEnum(amount),
+        };
+    }
+
+    pub fn layersByAmount(info: Info, amount: mango.ImageArrayLayers, base: mango.ImageArrayLayer) usize {
+        return switch (amount) {
+            .remaining => info.layers() - @intFromEnum(base),
+            else => @intFromEnum(amount),
+        };
+    }
+};
+
+pub fn init(create_info: mango.ImageCreateInfo) !Image {
+    try validation.assert(create_info.extent.width >= 8 and create_info.extent.width <= 1024 and std.mem.isAligned(create_info.extent.width, 8) and create_info.extent.height >= 8 and create_info.extent.height <= 1024 and std.mem.isAligned(create_info.extent.height, 8), validation.image.must_be_correct, .{
+        create_info.extent.width,
+        create_info.extent.height,
+        create_info.tiling,
+    });
+
+    if (create_info.usage.sampled) {
+        try validation.assert(std.math.isPowerOfTwo(create_info.extent.width) and std.math.isPowerOfTwo(create_info.extent.height) and create_info.tiling == .optimal, validation.image.sampled_must_be_correct, .{
+            create_info.extent.width,
+            create_info.extent.height,
+            create_info.tiling,
+        });
+    } else {
+        // NOTE: We could allow this but it doesn't make sense.
+        std.debug.assert(create_info.mip_levels == .@"1");
+    }
+
+    if (create_info.usage.color_attachment or create_info.usage.depth_stencil_attachment or create_info.usage.shadow_attachment) {
+        try validation.assert(create_info.tiling == .optimal, validation.image.attachment_must_be_correct, .{
+            create_info.extent.width,
+            create_info.extent.height,
+            create_info.tiling,
+        });
+    }
+
+    return .{
+        .info = .init(create_info),
+        .memory_info = .empty,
+    };
+}
+
+info: Info,
+memory_info: DeviceMemory.BoundMemoryInfo,
+
+pub fn toHandle(image: *Image) Handle {
+    return @enumFromInt(@intFromPtr(image));
+}
+
+pub fn fromHandleMutable(handle: Handle) *Image {
+    return @as(*Image, @ptrFromInt(@intFromEnum(handle)));
+}
+
+pub fn fromHandle(handle: Handle) Image {
+    return fromHandleMutable(handle).*;
+}
+
+const Image = @This();
+const backend = @import("backend.zig");
+const DeviceMemory = backend.DeviceMemory;
+
+const validation = backend.validation;
+
+const std = @import("std");
+const zitrus = @import("zitrus");
+const mango = zitrus.mango;
+const pica = zitrus.hardware.pica;
+
+const PhysicalAddress = zitrus.hardware.PhysicalAddress;
diff --git a/src/platform/3ds/mango/mango/ImageView.zig b/src/platform/3ds/mango/mango/ImageView.zig
new file mode 100644
index 0000000..4714b3e
--- /dev/null
+++ b/src/platform/3ds/mango/mango/ImageView.zig
@@ -0,0 +1,104 @@
+//! A PICA200 image view
+//!
+//! Represents a view of an Image which for example can be:
+//!     - A face of a cubemap or the cubemap itself.
+//!     - An a8_unorm image reinterpreted as an i8_unorm
+
+pub const Handle = enum(u64) {
+    null = 0,
+    _,
+};
+
+pub const Data = packed struct(u64) {
+    image: mango.Image,
+    valid: bool = true,
+    packed_format: u5,
+    is_cube: bool,
+    base_array_layer: u3,
+    base_mip_level: u3,
+    levels_minus_one: u3,
+    _: u16 = 0,
+
+    pub fn init(info: mango.ImageViewCreateInfo) !Data {
+        const b_image: *backend.Image = .fromHandleMutable(info.image);
+
+        if (!b_image.info.mutable_format) {
+            try validation.assert(b_image.info.format == info.format, validation.image_view.src_not_mutable_format, .{});
+        }
+
+        switch (info.type) {
+            .@"2d" => try validation.assert(b_image.info.layersByAmount(info.subresource_range.layer_count, info.subresource_range.base_array_layer) == 1, validation.image_view.invalid_2d, .{}),
+            .cube => try validation.assert(b_image.info.layersByAmount(info.subresource_range.layer_count, info.subresource_range.base_array_layer) == 6, validation.image_view.invalid_cube, .{}),
+        }
+
+        const mip_levels = b_image.info.levelsByAmount(info.subresource_range.level_count, info.subresource_range.base_mip_level);
+
+        return .{
+            .image = info.image,
+            .packed_format = @intCast(@intFromEnum(info.format) - 1),
+            .is_cube = info.type == .cube,
+            .base_array_layer = @intCast(@intFromEnum(info.subresource_range.base_array_layer)),
+            .base_mip_level = @intCast(@intFromEnum(info.subresource_range.base_mip_level)),
+            .levels_minus_one = @intCast(mip_levels - 1),
+        };
+    }
+
+    pub fn format(data: Data) mango.Format {
+        return @enumFromInt(@as(u8, data.packed_format) + 1);
+    }
+
+    pub fn levels(data: Data) usize {
+        return @as(usize, data.levels_minus_one) + 1;
+    }
+};
+
+pub const RenderingInfo = struct {
+    width: u16,
+    height: u16,
+    address: zitrus.hardware.PhysicalAddress,
+};
+
+data: Data,
+
+pub fn getRenderingInfo(view: ImageView) RenderingInfo {
+    std.debug.assert(view.data.levels() == 1);
+
+    const image: backend.Image = .fromHandle(view.data.image);
+    const fmt = image.info.format;
+
+    const img_width: usize = image.info.width();
+    const img_height: usize = image.info.height();
+
+    const view_width = backend.imageLevelDimension(img_width, view.data.base_mip_level);
+    const view_height = backend.imageLevelDimension(img_height, view.data.base_mip_level);
+
+    const unscaled_img_offset = (@as(usize, image.info.layer_size) * view.data.base_array_layer) + backend.imageLevelOffset(img_width * img_height, view_width * view_height);
+    const img_offset = fmt.scale(unscaled_img_offset);
+
+    return .{
+        .width = @intCast(view_width),
+        .height = @intCast(view_height),
+        .address = .fromAddress(@intFromEnum(image.memory_info.boundPhysicalAddress()) + img_offset),
+    };
+}
+
+pub fn toHandle(view: ImageView) Handle {
+    return @enumFromInt(@as(u64, @bitCast(view.data)));
+}
+
+pub fn fromHandle(handle: Handle) ImageView {
+    // TODO: With runtime safety the handle is a real pointer with some metadata
+    return .{
+        .data = @bitCast(@intFromEnum(handle)),
+    };
+}
+
+const ImageView = @This();
+const backend = @import("backend.zig");
+
+const validation = backend.validation;
+
+const std = @import("std");
+const zitrus = @import("zitrus");
+const mango = zitrus.mango;
+const pica = zitrus.hardware.pica;
diff --git a/src/platform/3ds/mango/mango/LightLookupTable.zig b/src/platform/3ds/mango/mango/LightLookupTable.zig
new file mode 100644
index 0000000..dbef118
--- /dev/null
+++ b/src/platform/3ds/mango/mango/LightLookupTable.zig
@@ -0,0 +1,46 @@
+pub const Handle = enum(u32) {
+    null = 0,
+    _,
+};
+
+const ExternAdapterContext = struct {
+    map: *const fn (?*anyopaque, f32) callconv(.c) f32,
+    ctx: ?*anyopaque,
+
+    pub fn value(ctx: ExternAdapterContext, x: f32) f32 {
+        return ctx.map(ctx.ctx, x);
+    }
+};
+
+data: [256]Data,
+
+pub fn init(create_info: mango.LightLookupTableCreateInfo) LightLookupTable {
+    return .{
+        .data = if (create_info.map) |map|
+            Data.initContext(ExternAdapterContext{
+                .map = map,
+                .ctx = create_info.context,
+            }, create_info.range == .positive)
+        else
+            @panic("TODO"),
+    };
+}
+
+pub fn toHandle(lut: *LightLookupTable) Handle {
+    return @enumFromInt(@intFromPtr(lut));
+}
+
+pub fn fromHandleMutable(handle: Handle) *LightLookupTable {
+    return @as(*LightLookupTable, @ptrFromInt(@intFromEnum(handle)));
+}
+
+const LightLookupTable = @This();
+const Data = pica.Graphics.FragmentLighting.LookupTable.Data;
+
+const backend = @import("backend.zig");
+
+const std = @import("std");
+const zitrus = @import("zitrus");
+const mango = zitrus.mango;
+
+const pica = zitrus.hardware.pica;
diff --git a/src/platform/3ds/mango/mango/QueryPool.zig b/src/platform/3ds/mango/mango/QueryPool.zig
new file mode 100644
index 0000000..e9487fd
--- /dev/null
+++ b/src/platform/3ds/mango/mango/QueryPool.zig
@@ -0,0 +1,122 @@
+pub const Handle = enum(u32) {
+    null = 0,
+    _,
+};
+
+type: mango.QueryType,
+statistics: mango.QueryStatistics,
+/// Size of a single query in `storage`
+query_size: u32,
+available: std.bit_set.DynamicBitSetUnmanaged,
+query_storage: []u8,
+
+pub fn init(gpa: std.mem.Allocator, create_info: mango.QueryPoolCreateInfo) !QueryPool {
+    const query_size: u32, const query_alignment: std.mem.Alignment = switch (create_info.type) {
+        .timestamp => .{ @sizeOf(u64), .of(u64) },
+        .statistics => .{ @as(u32, @sizeOf(u32)) * @popCount(@as(u32, @bitCast(create_info.statistics))), .of(u32) },
+        // .performance_counter => @panic("TODO"),
+    };
+
+    const alignment: std.mem.Alignment = .max(.of(u32), query_alignment);
+    const query_storage_size = query_size * create_info.count;
+    const available_start = std.mem.alignForward(u32, query_storage_size, @alignOf(std.bit_set.DynamicBitSetUnmanaged.MaskInt));
+    const available_size = std.mem.alignForward(u32, create_info.count, @bitSizeOf(u32)) / 8;
+    const needed_size = available_start + available_size;
+
+    // NOTE: make sure deinit is synced with this
+    const all = (gpa.rawAlloc(needed_size, alignment, @returnAddress()) orelse return error.OutOfMemory)[0..needed_size];
+    errdefer gpa.rawFree(all, alignment, @returnAddress());
+
+    return .{
+        .type = create_info.type,
+        .statistics = create_info.statistics,
+        .query_size = query_size,
+        .available = .{
+            .bit_length = create_info.count,
+            .masks = @ptrCast(@alignCast(all[available_start..])),
+        },
+        .query_storage = all[0..query_storage_size],
+    };
+}
+
+pub fn deinit(pool: *QueryPool, gpa: std.mem.Allocator) void {
+    const query_alignment: std.mem.Alignment = switch (pool.type) {
+        .timestamp => .of(u64),
+        .statistics => .of(u32),
+        // .performance_counter => @panic("TODO"),
+    };
+
+    const available_start = std.mem.alignForward(u32, pool.query_storage.len, @alignOf(std.bit_set.DynamicBitSetUnmanaged.MaskInt));
+    const available_size = std.mem.alignForward(u32, pool.available.bit_length, @bitSizeOf(u32)) / 8;
+    const needed_size = available_start + available_size;
+    const all = pool.query_storage.ptr[0..needed_size];
+    gpa.rawFree(all, .max(.of(u32), query_alignment), @returnAddress());
+}
+
+pub fn getQueryStorage(pool: *QueryPool, query: u32) []u8 {
+    std.debug.assert(query < @divExact(pool.query_storage.len, pool.query_size));
+    return pool.query_storage[query * pool.query_size ..][0..pool.query_size];
+}
+
+pub fn beginQuery(pool: *QueryPool, query: u32) void {
+    std.debug.assert(!pool.available.isSet(query)); // The query must not be available
+    @memset(pool.getQueryStorage(query), 0x00);
+}
+
+pub fn endQuery(pool: *QueryPool, query: u32) void {
+    pool.available.set(query);
+}
+
+// NOTE: why are timestamps 64 bits instead of 96? because we want this to be compatible
+// with C and C is unfortunately not based.
+pub fn writeTimestamp(pool: *QueryPool, query: u32, timestamp: u64) void {
+    std.debug.assert(pool.type == .timestamp);
+    std.debug.assert(pool.query_size == @sizeOf(u64));
+    std.debug.assert(query < @divExact(pool.query_storage.len, @sizeOf(u64)));
+    std.debug.assert(!pool.available.isSet(query)); // The query must not be available
+
+    const stored = pool.query_storage[query * @sizeOf(u64) ..][0..@sizeOf(u64)];
+    stored.* = @bitCast(timestamp);
+    pool.available.set(query);
+}
+
+pub fn reset(pool: *QueryPool, first: u32, count: u32) void {
+    std.debug.assert(first + count <= @divExact(pool.query_storage.len, pool.query_size));
+
+    @memset(pool.query_storage[(first * pool.query_size)..][0..(count * pool.query_size)], undefined);
+    pool.available.setRangeValue(.{
+        .start = first,
+        .end = first + count,
+    }, false);
+}
+
+pub fn getResults(pool: *QueryPool, first: u32, count: u32, data: []u8, stride: u32, flags: mango.QueryResultFlags) mango.GetQueryResultsError!void {
+    _ = flags;
+    std.debug.assert(first + count <= @divExact(pool.query_storage.len, pool.query_size));
+    if (count > 0) std.debug.assert(stride != 0);
+
+    var any_unavailable: bool = false;
+
+    for (0..count) |i| {
+        const available = pool.available.isSet(first + i);
+        if (available) @memcpy(data[stride * i ..][0..pool.query_size], pool.query_storage[(first + i) * pool.query_size ..][0..pool.query_size]);
+        any_unavailable |= !available;
+    }
+
+    return if (any_unavailable) error.NotReady;
+}
+
+pub fn toHandle(image: *QueryPool) Handle {
+    return @enumFromInt(@intFromPtr(image));
+}
+
+pub fn fromHandleMutable(handle: Handle) *QueryPool {
+    return @as(*QueryPool, @ptrFromInt(@intFromEnum(handle)));
+}
+
+const QueryPool = @This();
+
+const std = @import("std");
+
+const zitrus = @import("zitrus");
+const mango = zitrus.mango;
diff --git a/src/platform/3ds/mango/mango/Queue.zig b/src/platform/3ds/mango/mango/Queue.zig
new file mode 100644
index 0000000..9699851
--- /dev/null
+++ b/src/platform/3ds/mango/mango/Queue.zig
@@ -0,0 +1,620 @@
+//! Represents an independent PICA200 unit.
+//!
+//! The PICA200 has 3 independent units for Memory Fills, Transfers and Submits (Command Lists)
+//!
+//! Each queue independently manages state for waiting and signaling, allowing for inter-queue dependencies,
+//! the driver handles waiting and signaling those queue dependencies so the app is free to do anything else.
+//!
+//! Must not depend on anything Horizon related, that is handled by the `Device` which is environment-dependent.
+
+pub const Handle = enum(u32) {
+    null = 0,
+    _,
+
+    /// Copies the region specified onto the destination buffer.
+    ///
+    /// Valid Usage:
+    /// - Offsets must be aligned to 8 bytes.
+    pub fn copyBuffer(queue: Handle, info: mango.CopyBufferInfo) !void {
+        const transfer: *Queue = .fromHandleMutable(queue, .transfer);
+        const b_src_buffer: backend.Buffer = .fromHandle(info.src_buffer);
+        const b_dst_buffer: backend.Buffer = .fromHandle(info.dst_buffer);
+
+        const src_virt = b_src_buffer.memory_info.boundVirtualAddress();
+        const dst_virt = b_dst_buffer.memory_info.boundVirtualAddress();
+
+        const src_size = b_src_buffer.sizeByAmount(info.size, info.src_offset);
+        const dst_size = b_dst_buffer.sizeByAmount(info.size, info.dst_offset);
+        std.debug.assert(src_size == dst_size);
+
+        const src = src_virt[@intFromEnum(info.src_offset)..][0..src_size];
+        const dst = dst_virt[@intFromEnum(info.dst_offset)..][0..dst_size];
+
+        return transfer.pushFrontBounded(TransferItem, .{
+            .flags = .{
+                .kind = .copy,
+                .extra = .{
+                    // XXX: Yes this could fail but how can the size be higher than 2^29 really?
+                    .copy = @intCast(src_size),
+                },
+            },
+            .src = @alignCast(src.ptr),
+            .dst = @alignCast(dst.ptr),
+            .input_gap_size = @splat(0),
+            .output_gap_size = @splat(0),
+        }, .initSemaphoreOperation(info.wait_semaphore), .initSemaphoreOperation(info.signal_semaphore));
+    }
+
+    // TODO: Provide a software fallback for directly using host memory (akin to VK_EXT_host_image_copy)
+    pub fn copyBufferToImage(queue: Handle, info: mango.CopyBufferToImageInfo) !void {
+        const transfer: *Queue = .fromHandleMutable(queue, .transfer);
+        const b_src_buffer: *backend.Buffer = .fromHandleMutable(info.src_buffer);
+        const b_dst_image: *backend.Image = .fromHandleMutable(info.dst_image);
+
+        const src_memory: backend.DeviceMemory.BoundMemoryInfo = b_src_buffer.memory_info;
+        const dst_memory: backend.DeviceMemory.BoundMemoryInfo = b_dst_image.memory_info;
+
+        const native_fmt = b_dst_image.info.format.nativeColorFormat();
+        const pixel_size = native_fmt.bytesPerPixel();
+
+        const dst_width: usize = b_dst_image.info.width();
+        const dst_height: usize = b_dst_image.info.height();
+
+        const dst_mip_width = backend.imageLevelDimension(dst_width, @intFromEnum(info.dst_subresource.mip_level));
+        const dst_mip_height = backend.imageLevelDimension(dst_height, @intFromEnum(info.dst_subresource.mip_level));
+
+        std.debug.assert(dst_mip_width >= 64 and dst_mip_height >= 16);
+
+        const dst_mip_offset = pixel_size * backend.imageLevelOffset(dst_width * dst_height, dst_mip_width * dst_mip_height);
+        const dst_mip_size = pixel_size * dst_mip_width * dst_mip_height;
+
+        const dst_image_full_layer_size = @as(usize, b_dst_image.info.layer_size) * pixel_size;
+
+        const src_virt = src_memory.boundVirtualAddress();
+        const dst_virt = dst_memory.boundVirtualAddress();
+
+        const dst_blitting_layers = b_dst_image.info.layersByAmount(info.dst_subresource.layer_count, info.dst_subresource.base_array_layer);
+
+        var src_virt_offset = src_virt + @intFromEnum(info.src_offset);
+        var dst_image_layer_virt_offset = dst_virt + dst_image_full_layer_size * @intFromEnum(info.dst_subresource.base_array_layer) + dst_mip_offset;
+        var i: usize = 0;
+
+        // TODO: Add the memcpy flag again
+
+        while (i < dst_blitting_layers) : ({
+            i += 1;
+            dst_image_layer_virt_offset += dst_image_full_layer_size;
+            src_virt_offset += dst_mip_size;
+        }) {
+            // NOTE: Queue operations start and execute sequentially within a queue.
+            const wait_op: SemaphoreOperation = if (i == 0) .initSemaphoreOperation(info.wait_semaphore) else .none;
+            const signal_op: SemaphoreOperation = if (i == (dst_blitting_layers - 1)) .initSemaphoreOperation(info.signal_semaphore) else .none;
+
+            try transfer.pushFrontBounded(TransferItem, .{
+                .flags = .{
+                    .kind = .linear_tiled,
+                    .extra = .{
+                        .transfer = .{
+                            .src_fmt = native_fmt,
+                            .dst_fmt = native_fmt,
+                            .downscale = .none,
+                        },
+                    },
+                },
+                .src = @alignCast(src_virt_offset),
+                .dst = @alignCast(dst_image_layer_virt_offset),
+                .input_gap_size = .{ @intCast(dst_mip_width), @intCast(dst_mip_height) },
+                .output_gap_size = .{ @intCast(dst_mip_width), @intCast(dst_mip_height) },
+            }, wait_op, signal_op);
+        }
+    }
+
+    pub fn copyImageToBuffer(queue: Handle) void {
+        const transfer: *Queue = .fromHandleMutable(queue, .transfer);
+        _ = transfer;
+        @panic("TODO");
+    }
+
+    pub fn copyImageToImage(queue: Handle) void {
+        const transfer: *Queue = .fromHandleMutable(queue, .transfer);
+        _ = transfer;
+        @panic("TODO");
+    }
+
+    /// Blit an image onto another performing format conversion and scaling when appropiate.
+    ///
+    /// The operation is done layer by layer on the specified mip levels. When scaling is done,
+    /// a linear (also called box) filter is applied.
+    ///
+    /// Valid Usage:
+    /// The tiling of the source and destination images **must** not be both LINEAR.
+    ///
+    /// The sizes of the source and destination image dimensions **can** *only* differ when:
+    /// - The width of the destination is half the width of the source.
+    /// - The width and height of the destination is half the width of the source.
+    pub fn blitImage(queue: Handle, info: mango.BlitImageInfo) !void {
+        const transfer: *Queue = .fromHandleMutable(queue, .transfer);
+
+        const b_src_image: *backend.Image = .fromHandleMutable(info.src_image);
+        const b_dst_image: *backend.Image = .fromHandleMutable(info.dst_image);
+
+        const src_blitting_layers = b_src_image.info.layersByAmount(info.src_subresource.layer_count, info.src_subresource.base_array_layer);
+        const dst_blitting_layers = b_dst_image.info.layersByAmount(info.dst_subresource.layer_count, info.dst_subresource.base_array_layer);
+
+        std.debug.assert(src_blitting_layers == dst_blitting_layers); // Obvously, we must have matching layers to copy.
+
+        const src_color_format, const dst_color_format = switch (b_src_image.info.format) {
+            // NOTE: we can (ab)use the GPU DMA for unswizzling images of the same format.
+            .d16_unorm, .g8r8_unorm, .i8a8_unorm => |f| if (b_dst_image.info.format == f) .{ .rgb565, .rgb565 } else unreachable,
+            .d24_unorm => |f| if (b_dst_image.info.format == f) .{ .bgr888, .bgr888 } else unreachable,
+            .d24_unorm_s8_uint => |f| if (b_dst_image.info.format == f) .{ .abgr8888, .abgr8888 } else unreachable,
+            else => |fmt| .{ fmt.nativeColorFormat(), b_dst_image.info.format.nativeColorFormat() }, // it must be a valid color format if not
+        };
+
+        const src_width: usize = b_src_image.info.width();
+        const src_height: usize = b_src_image.info.height();
+
+        const src_mip_width = backend.imageLevelDimension(src_width, @intFromEnum(info.src_subresource.mip_level));
+        const src_mip_height = backend.imageLevelDimension(src_height, @intFromEnum(info.src_subresource.mip_level));
+
+        const dst_width: usize = b_dst_image.info.width();
+        const dst_height: usize = b_dst_image.info.height();
+
+        const dst_mip_width = backend.imageLevelDimension(dst_width, @intFromEnum(info.src_subresource.mip_level));
+        const dst_mip_height = backend.imageLevelDimension(dst_height, @intFromEnum(info.src_subresource.mip_level));
+
+        std.debug.assert(src_mip_width >= dst_mip_width and src_mip_height >= dst_mip_height); // Output must not be bigger than input.
+
+        // Only allow downscale of the X or XY axes. Otherwise sizes must match (for simplicity, the hardware allows bigger inputs than outputs, does that have an use-case?).
+        // TODO: Yes dummy, if you have a bigger input you're basically blitting subimages!
+        const downscale: pica.PictureFormatter.Flags.Downscale = if (dst_mip_width < src_mip_width and dst_mip_height < src_mip_height) blk: {
+            std.debug.assert(dst_mip_width == (src_mip_width >> 1) and dst_mip_height == (src_mip_height >> 1));
+            break :blk .@"2x2";
+        } else if (dst_mip_width < src_mip_width) blk: {
+            std.debug.assert(dst_mip_width == (src_mip_width >> 1) and dst_mip_height == (src_mip_height >> 1));
+            break :blk .@"2x1";
+        } else blk: {
+            @branchHint(.likely);
+            std.debug.assert(src_mip_width == dst_mip_width and src_mip_height == dst_mip_height and !(b_src_image.info.optimally_tiled and b_dst_image.info.optimally_tiled));
+            break :blk .none;
+        };
+
+        const kind: TransferItem.Flags.Kind = switch (b_src_image.info.optimally_tiled) {
+            false => switch (b_dst_image.info.optimally_tiled) {
+                false => unreachable, // NOTE: Blits are not supported between LINEAR -> LINEAR, hardware doesn't support it explicitly.
+                true => .linear_tiled,
+            },
+            true => switch (b_dst_image.info.optimally_tiled) {
+                false => .tiled_linear,
+                true => .tiled_tiled,
+            },
+        };
+
+        switch (kind) {
+            .linear_tiled, .tiled_linear => std.debug.assert(src_width >= 64 and src_height >= 16),
+            .tiled_tiled => std.debug.assert(src_width >= 64 and src_height >= 32),
+            .copy => unreachable,
+        }
+
+        const src_bpp = src_color_format.bytesPerPixel();
+        const dst_bpp = dst_color_format.bytesPerPixel();
+
+        const src_image_full_layer_size: usize = @as(usize, b_src_image.info.layer_size) * src_bpp;
+        const dst_image_full_layer_size: usize = @as(usize, b_dst_image.info.layer_size) * dst_bpp;
+
+        const src_virt = b_src_image.memory_info.boundVirtualAddress();
+        const dst_virt = b_dst_image.memory_info.boundVirtualAddress();
+
+        const src_mip_offset = src_bpp * backend.imageLevelOffset(src_width * src_height, src_mip_width * src_mip_height);
+        const dst_mip_offset = dst_bpp * backend.imageLevelOffset(dst_width * dst_height, dst_mip_width * dst_mip_height);
+
+        var i: usize = 0;
+        var src_image_layer_virt_offset = src_virt + src_image_full_layer_size * @intFromEnum(info.src_subresource.base_array_layer) + src_mip_offset;
+        var dst_image_layer_virt_offset = dst_virt + dst_image_full_layer_size * @intFromEnum(info.dst_subresource.base_array_layer) + dst_mip_offset;
+
+        while (i < dst_blitting_layers) : ({
+            i += 1;
+            src_image_layer_virt_offset += src_image_full_layer_size;
+            dst_image_layer_virt_offset += dst_image_full_layer_size;
+        }) {
+            // NOTE: Queue operations start and execute sequentially within a queue.
+            const wait_op: SemaphoreOperation = if (i == 0) .initSemaphoreOperation(info.wait_semaphore) else .none;
+            const signal_op: SemaphoreOperation = if (i == (dst_blitting_layers - 1)) .initSemaphoreOperation(info.signal_semaphore) else .none;
+
+            try transfer.pushFrontBounded(TransferItem, .{
+                .flags = .{
+                    .kind = kind,
+                    .extra = .{
+                        .transfer = .{
+                            .src_fmt = src_color_format,
+                            .dst_fmt = dst_color_format,
+                            .downscale = downscale,
+                            .use_32x32 = false,
+                        },
+                    },
+                },
+                .src = @alignCast(src_image_layer_virt_offset),
+                .dst = @alignCast(dst_image_layer_virt_offset),
+                .input_gap_size = .{ @intCast(src_mip_width), @intCast(src_mip_height) },
+                .output_gap_size = .{ @intCast(src_mip_width), @intCast(src_mip_height) },
+            }, wait_op, signal_op);
+        }
+    }
+
+    pub fn fillBuffer(queue: Handle, info: mango.FillBufferInfo) !void {
+        const fill: *Queue = .fromHandleMutable(queue, .fill);
+        const buffer: *backend.Buffer = .fromHandleMutable(info.buffer);
+
+        const virt = buffer.memory_info.boundVirtualAddress();
+        const size = buffer.sizeByAmount(info.size, info.offset);
+
+        const dst = virt[@intFromEnum(info.offset)..][0..size];
+
+        try fill.pushFrontBounded(FillItem, .{
+            .data = @alignCast(dst),
+            .value = switch (info.pattern_type) {
+                .u16 => .{ .fill16 = @truncate(info.pattern) },
+                .u24 => .{ .fill24 = @truncate(info.pattern) },
+                .u32 => .{ .fill32 = info.pattern },
+            },
+        }, .initSemaphoreOperation(info.wait_semaphore), .initSemaphoreOperation(info.signal_semaphore));
+    }
+
+    /// Clear one color attachment image.
+    pub fn clearColorImage(queue: Handle, info: mango.ClearColorInfo) !void {
+        const fill: *Queue = .fromHandleMutable(queue, .fill);
+        const color = info.color;
+        const b_image: *backend.Image = .fromHandleMutable(info.image);
+
+        const clear_scale: usize, const clear_value: FillValue = switch (b_image.info.format) {
+            .a8b8g8r8_unorm => .{
+                @sizeOf(u32),
+                .{ .fill32 = @bitCast(pica.ColorFormat.Abgr8888{
+                    .r = color[0],
+                    .g = color[1],
+                    .b = color[2],
+                    .a = color[3],
+                }) },
+            },
+            .b8g8r8_unorm => .{
+                3,
+                .{ .fill24 = @bitCast(pica.ColorFormat.Bgr888{
+                    .r = color[0],
+                    .g = color[1],
+                    .b = color[2],
+                }) },
+            },
+            // .a8b8g8r8_unorm =>,
+            .r5g6b5_unorm_pack16, .r5g5b5a1_unorm_pack16, .r4g4b4a4_unorm_pack16, .g8r8_unorm => .{
+                @sizeOf(u16),
+                .{ .fill16 = switch (b_image.info.format) {
+                    .r5g6b5_unorm_pack16 => @bitCast(pica.ColorFormat.Rgb565{
+                        .r = @intCast((@as(usize, color[0]) * std.math.maxInt(u5)) / std.math.maxInt(u8)),
+                        .g = @intCast((@as(usize, color[1]) * std.math.maxInt(u6)) / std.math.maxInt(u8)),
+                        .b = @intCast((@as(usize, color[2]) * std.math.maxInt(u5)) / std.math.maxInt(u8)),
+                    }),
+                    .r5g5b5a1_unorm_pack16 => @bitCast(pica.ColorFormat.Rgba5551{
+                        .r = @intCast((@as(usize, color[0]) * std.math.maxInt(u5)) / std.math.maxInt(u8)),
+                        .g = @intCast((@as(usize, color[1]) * std.math.maxInt(u5)) / std.math.maxInt(u8)),
+                        .b = @intCast((@as(usize, color[2]) * std.math.maxInt(u5)) / std.math.maxInt(u8)),
+                        .a = @intFromBool(color[3] != 0),
+                    }),
+                    .r4g4b4a4_unorm_pack16 => @bitCast(pica.ColorFormat.Rgba4444{
+                        .r = @intCast((@as(usize, color[0]) * std.math.maxInt(u4)) / std.math.maxInt(u8)),
+                        .g = @intCast((@as(usize, color[1]) * std.math.maxInt(u4)) / std.math.maxInt(u8)),
+                        .b = @intCast((@as(usize, color[2]) * std.math.maxInt(u4)) / std.math.maxInt(u8)),
+                        .a = @intCast((@as(usize, color[3]) * std.math.maxInt(u4)) / std.math.maxInt(u8)),
+                    }),
+                    .g8r8_unorm => @bitCast(pica.TextureUnitFormat.Hilo88{
+                        .r = color[0],
+                        .g = color[1],
+                    }),
+                    else => unreachable,
+                } },
+            },
+            else => unreachable,
+        };
+
+        const cleared_levels = b_image.info.levelsByAmount(info.subresource_range.level_count, info.subresource_range.base_mip_level);
+        const cleared_layers = b_image.info.layersByAmount(info.subresource_range.layer_count, info.subresource_range.base_array_layer);
+
+        const virt_start = b_image.memory_info.boundVirtualAddress();
+        const full_layer_size = clear_scale * b_image.info.layer_size;
+
+        // We can fully clear all the layers! This common case must be optimized!
+        if (info.subresource_range.base_mip_level == .@"0" and cleared_levels == b_image.info.levels()) {
+            return fill.pushFrontBounded(FillItem, .{
+                .data = @alignCast(virt_start[(full_layer_size * @intFromEnum(info.subresource_range.base_array_layer))..][0..(full_layer_size * cleared_layers)]),
+                .value = clear_value,
+            }, .initSemaphoreOperation(info.wait_semaphore), .initSemaphoreOperation(info.signal_semaphore));
+        }
+
+        const width: usize = b_image.info.width();
+        const height: usize = b_image.info.height();
+
+        const mip_width = backend.imageLevelDimension(width, @intFromEnum(info.subresource_range.base_mip_level));
+        const mip_height = backend.imageLevelDimension(height, @intFromEnum(info.subresource_range.base_mip_level));
+
+        const mip_offset = clear_scale * backend.imageLevelOffset(width * mip_height, mip_width * mip_height);
+        const full_cleared_size = clear_scale * backend.imageLayerSize(mip_width * mip_height, cleared_levels);
+
+        var current_virt_offset: [*]u8 = virt_start + full_layer_size * @intFromEnum(info.subresource_range.base_array_layer) + mip_offset;
+        var i: usize = 0;
+
+        while (i < cleared_layers) : ({
+            current_virt_offset += full_layer_size;
+            i += 1;
+        }) {
+            // NOTE: Queue operations start and execute sequentially within a queue.
+            const wait_op: SemaphoreOperation = if (i == 0) .initSemaphoreOperation(info.wait_semaphore) else .none;
+            const signal_op: SemaphoreOperation = if (i == (cleared_layers - 1)) .initSemaphoreOperation(info.signal_semaphore) else .none;
+
+            try fill.pushFrontBounded(FillItem, .{
+                .data = @alignCast(current_virt_offset[0..full_cleared_size]),
+                .value = clear_value,
+            }, wait_op, signal_op);
+        }
+    }
+
+    pub fn clearDepthStencilImage(queue: Handle, info: mango.ClearDepthStencilInfo) !void {
+        std.debug.assert(0.0 <= info.depth and info.depth <= 1.0);
+
+        // TODO: Subresource range
+        const fill: *Queue = .fromHandleMutable(queue, .fill);
+        const depth = info.depth;
+        const stencil = info.stencil;
+
+        const b_image: *backend.Image = .fromHandleMutable(info.image);
+        const bound_virtual = b_image.memory_info.boundVirtualAddress();
+
+        const clear_slice, const clear_value: FillValue = switch (b_image.info.format) {
+            .d16_unorm => .{ bound_virtual[0..(b_image.info.size() * @sizeOf(u16))], .{ .fill16 = @intFromFloat(@trunc(depth * std.math.maxInt(u16))) } },
+            .d24_unorm => .{ bound_virtual[0..(b_image.info.size() * 3)], .{ .fill24 = @intFromFloat(@trunc(depth * std.math.maxInt(u24))) } },
+            .d24_unorm_s8_uint => .{ bound_virtual[0..(b_image.info.size() * @sizeOf(u32))], .{ .fill32 = @as(u32, @intFromFloat(@trunc(depth * std.math.maxInt(u24)))) | (@as(u32, stencil) << 24) } },
+            else => unreachable,
+        };
+
+        return fill.pushFrontBounded(FillItem, .{
+            .data = @alignCast(clear_slice),
+            .value = clear_value,
+        }, .initSemaphoreOperation(info.wait_semaphore), .initSemaphoreOperation(info.signal_semaphore));
+    }
+
+    pub fn submit(queue: Handle, submit_info: mango.SubmitInfo) !void {
+        const submt: *Queue = .fromHandleMutable(queue, .submit);
+        const b_cmd: *backend.CommandBuffer = .fromHandleMutable(submit_info.command_buffer);
+        b_cmd.notifyPending();
+
+        return submt.pushFrontBounded(SubmitItem, .{
+            .cmd_buffer = b_cmd,
+        }, .initSemaphoreOperation(submit_info.wait_semaphore), .initSemaphoreOperation(submit_info.signal_semaphore));
+    }
+
+    pub fn present(queue: Handle, info: mango.PresentInfo) !void {
+        const prsent: *Queue = .fromHandleMutable(queue, .present);
+        const screen = backend.Swapchain.fromHandle(info.swapchain);
+
+        return prsent.pushFrontBounded(PresentationItem, .{
+            .misc = .{
+                .screen = screen,
+                .ignore_stereo = info.flags.ignore_stereoscopic,
+            },
+            .index = info.image_index,
+        }, .initSemaphoreOperation(info.wait_semaphore), .none);
+    }
+};
+
+pub const Type = enum {
+    fill,
+    transfer,
+    submit,
+    present,
+};
+
+pub const SemaphoreOperation = struct {
+    pub const none: SemaphoreOperation = .{ .sema = null, .value = 0 };
+
+    sema: ?*backend.Semaphore,
+    value: u64,
+
+    pub fn initSemaphoreOperation(maybe_op: ?*const mango.SemaphoreQueueOperation) SemaphoreOperation {
+        return if (maybe_op) |op| .{
+            .sema = .fromHandleMutable(op.semaphore),
+            .value = op.value,
+        } else .none;
+    }
+};
+
+pub const FillItem = struct {
+    data: []align(8) u8,
+    value: FillValue,
+};
+
+pub const FillValue = union(enum) {
+    fill16: u16,
+    fill24: u24,
+    fill32: u32,
+};
+
+pub const TransferItem = struct {
+    pub const Flags = packed struct(u32) {
+        pub const Kind = enum(u2) {
+            copy,
+            linear_tiled,
+            tiled_linear,
+            tiled_tiled,
+        };
+
+        kind: Kind,
+        extra: packed union(u30) {
+            copy: u30,
+            transfer: packed struct(u30) {
+                src_fmt: pica.ColorFormat,
+                dst_fmt: pica.ColorFormat,
+                downscale: pica.PictureFormatter.Flags.Downscale,
+                use_32x32: bool = false,
+                _: u21 = 0,
+            },
+        },
+    };
+
+    src: [*]align(8) const u8,
+    dst: [*]align(8) u8,
+    input_gap_size: [2]u16,
+    output_gap_size: [2]u16,
+    flags: Flags,
+};
+
+pub const SubmitItem = struct { cmd_buffer: *backend.CommandBuffer };
+
+pub const PresentationItem = struct {
+    pub const Misc = packed struct(u8) {
+        screen: pica.Screen,
+        ignore_stereo: bool,
+        _: u6 = 0,
+    };
+
+    misc: Misc,
+    index: u8,
+};
+
+pub const Status = enum(i32) {
+    /// The queue has submitted work and is waiting for the GPU
+    working = -2,
+    /// The GPU notified us, it'll either continue working,
+    /// waiting or stay idle.
+    work_completed = -1,
+    /// The queue is waiting for another queue to signal its semaphore
+    waiting = 0,
+    /// The queue doesn't have any outstanding operation
+    idle = 1,
+    /// The queue was lost, this is all or nothing. If a queue is lost, ALL queues are lost.
+    ///
+    /// Can happen when the driver loses the GPU (i.e it hangs)
+    /// The only thing you can do after this happens is destroying and recreating the device as `mango` will
+    /// try to reset the GPU to a known state; if that fails you're cooked.
+    lost = 2,
+};
+
+pub const Result = enum { empty, wait, ready };
+
+type: Type,
+device: *backend.Device,
+
+head: std.atomic.Value(u32) align(std.atomic.cache_line),
+tail: std.atomic.Value(u32) align(std.atomic.cache_line),
+
+// NOTE: we have to align the head & tail so we have plenty of storage...
+capacity: u32,
+size: u32,
+alignment: std.mem.Alignment,
+
+buffer: []u8,
+waits: []SemaphoreOperation,
+signals: []SemaphoreOperation,
+
+pub fn init(gpa: std.mem.Allocator, typ: Type, device: *backend.Device, capacity: u32, size: u32, alignment: std.mem.Alignment) !Queue {
+    const min_alignment: std.mem.Alignment = .max(alignment, .of(SemaphoreOperation));
+    const buffer_len = capacity * size;
+    const semas_start = std.mem.alignForward(usize, buffer_len, @alignOf(SemaphoreOperation));
+    const all = gpa.rawAlloc(
+        semas_start + (2 * capacity) * @sizeOf(SemaphoreOperation),
+        min_alignment,
+        @returnAddress(),
+    ) orelse return error.OutOfMemory;
+    errdefer gpa.rawFree(all, min_alignment, @returnAddress());
+
+    return .{
+        .type = typ,
+        .device = device,
+
+        .head = .init(0),
+        .tail = .init(0),
+        .capacity = capacity,
+        .size = size,
+        .alignment = alignment,
+
+        .buffer = all[0..buffer_len],
+        .waits = @ptrCast(@alignCast(all[semas_start..][0 .. capacity * @sizeOf(SemaphoreOperation)])),
+        .signals = @ptrCast(@alignCast(all[semas_start + (capacity * @sizeOf(SemaphoreOperation)) ..][0 .. capacity * @sizeOf(SemaphoreOperation)])),
+    };
+}
+
+pub fn deinit(queue: *Queue, gpa: std.mem.Allocator) void {
+    const min_alignment: std.mem.Alignment = .max(queue.alignment, .of(SemaphoreOperation));
+    const buffer_len = queue.capacity * queue.size;
+    const semas_start = std.mem.alignForward(usize, buffer_len, @alignOf(SemaphoreOperation));
+    const all = queue.buffer.ptr[0 .. semas_start + (2 * queue.capacity * @sizeOf(SemaphoreOperation))];
+
+    gpa.rawFree(all, min_alignment, @returnAddress());
+}
+
+pub fn pushFrontBounded(queue: *Queue, comptime T: type, value: T, wait: SemaphoreOperation, signal: SemaphoreOperation) !void {
+    return queue.pushFrontBufferBounded(@ptrCast(&value), wait, signal);
+}
+
+/// Asserts `item.len` is equal to the queue item size
+pub fn pushFrontBufferBounded(queue: *Queue, item: []const u8, wait: SemaphoreOperation, signal: SemaphoreOperation) !void {
+    std.debug.assert(queue.size == item.len);
+    defer queue.device.wakeIdleQueue(queue.type);
+
+    const tail = queue.tail.load(.monotonic);
+    const new_tail = (tail + 1) % queue.capacity;
+    if (new_tail == queue.head.load(.monotonic)) return error.OutOfMemory;
+    @memcpy(queue.buffer[(tail * queue.size)..][0..queue.size], item);
+    queue.waits[tail] = wait;
+    queue.signals[tail] = signal;
+    queue.tail.store(new_tail, .release);
+}
+
+pub fn peekBack(queue: *Queue) Result {
+    const head = queue.head.load(.monotonic);
+    if (head == queue.tail.load(.acquire)) return .empty;
+
+    const wait = queue.waits[head];
+
+    if (wait.sema) |sema| if (sema.counterValue() < wait.value) {
+        return .wait;
+    };
+
+    return .ready;
+}
+
+/// Assumes a previous call to `peekBack` returned `ready`
+///
+/// Returns the corresponding semaphore operation to signal
+pub fn popBackBufferAssumeReady(queue: *Queue, item: []u8) SemaphoreOperation {
+    std.debug.assert(queue.size == item.len);
+
+    const head = queue.head.load(.monotonic); // NOTE: no need for acquire or checking here, we already did in peekBack (and you must peek before popping)!
+    @memcpy(item, queue.buffer[(head * queue.size)..][0..queue.size]);
+    const signal = queue.signals[head];
+    queue.head.store((head + 1) % queue.capacity, .monotonic);
+    return signal;
+}
+
+pub fn popBackAssumeReady(queue: *Queue, comptime T: type) struct { T, SemaphoreOperation } {
+    var value: T = undefined;
+    const signal = queue.popBackBufferAssumeReady(@ptrCast(&value));
+    return .{ value, signal };
+}
+
+pub fn toHandle(queue: *Queue) Handle {
+    return @enumFromInt(@intFromPtr(queue));
+}
+
+pub fn fromHandleMutable(handle: Handle, typ: Type) *Queue {
+    const queue: *Queue = @ptrFromInt(@intFromEnum(handle));
+    std.debug.assert(queue.type == typ);
+    return queue;
+}
+
+const Queue = @This();
+
+const backend = @import("backend.zig");
+
+const std = @import("std");
+const zitrus = @import("zitrus");
+
+const mango = zitrus.mango;
+const pica = zitrus.hardware.pica;
diff --git a/src/platform/3ds/mango/mango/RenderingState.zig b/src/platform/3ds/mango/mango/RenderingState.zig
new file mode 100644
index 0000000..60151c9
--- /dev/null
+++ b/src/platform/3ds/mango/mango/RenderingState.zig
@@ -0,0 +1,790 @@
+pub const UniformLocation = enum {
+    float,
+    int,
+    bool,
+};
+
+pub const Dirty = packed struct(u32) {
+    // NOTE: by default dirty so we disable the `texture_enable` bits if none.
+    pub const init: Dirty = .{ .texture_units = std.math.maxInt(u3) };
+
+    begin_rendering: bool = false,
+    vertex_buffers: bool = false,
+    uniforms: u6 = 0,
+    texture_units: u3 = 0,
+    light_enable: bool = false,
+    light_environment_factors: bool = false,
+    light_parameters: bool = false,
+    light_factors: bool = false,
+    light_tables: bool = false,
+    _: u16 = 0,
+
+    pub fn setUniformsDirty(dirty: *Dirty, stage: mango.ShaderStage, location: UniformLocation) void {
+        dirty.uniforms |= (@as(u6, 1) << @intCast(@intFromEnum(stage) * std.enums.values(UniformLocation).len + @intFromEnum(location)));
+    }
+
+    pub fn setStageUniformsDirty(dirty: *Dirty, stage: mango.ShaderStage) void {
+        dirty.uniforms |= (@as(u6, 0b111) << @intCast(@intFromEnum(stage) * std.enums.values(UniformLocation).len));
+    }
+
+    pub fn clearDirtyStageUniforms(dirty: *Dirty, stage: mango.ShaderStage) void {
+        dirty.uniforms &= ~(@as(u6, 0b111) << @intCast(@intFromEnum(stage) * std.enums.values(UniformLocation).len));
+    }
+
+    pub fn isUniformsDirty(dirty: Dirty, stage: mango.ShaderStage, location: UniformLocation) bool {
+        return (dirty.uniforms & (@as(u6, 1) << @intCast(@intFromEnum(stage) * std.enums.values(UniformLocation).len + @intFromEnum(location)))) != 0;
+    }
+
+    pub fn isStageUniformsDirty(dirty: Dirty, stage: mango.ShaderStage) bool {
+        return (dirty.uniforms & (@as(u6, 0b111) << @intCast(@intFromEnum(stage) * std.enums.values(UniformLocation).len))) != 0;
+    }
+
+    pub fn isAnyUniformsDirty(dirty: Dirty) bool {
+        return dirty.uniforms != 0;
+    }
+
+    pub fn setTextureUnitDirty(dirty: *Dirty, unit: u2) void {
+        std.debug.assert(unit <= 2);
+        dirty.texture_units |= (@as(u3, 1) << unit);
+    }
+
+    pub fn isTextureUnitDirty(dirty: Dirty, unit: u2) bool {
+        std.debug.assert(unit <= 2);
+        return (dirty.texture_units & (@as(u3, 1) << unit)) != 0;
+    }
+
+    pub fn isAnyTextureUnitDirty(dirty: *Dirty) bool {
+        return dirty.texture_units != 0;
+    }
+};
+
+pub const Misc = packed struct {
+    pub const empty: Misc = .{};
+
+    vertex_buffers_dirty_start: u8 = 0,
+    vertex_buffers_dirty_end: u8 = 0,
+    index_format: pica.IndexFormat = .u8,
+};
+
+pub const UniformState = struct {
+    pub const empty: UniformState = .{
+        .shader_dirty = .initFill(null),
+        .floating_constants = undefined,
+        .integer_constants = undefined,
+        .boolean_constants = .initFill(.initEmpty()),
+    };
+
+    /// When not null, we must emit all floating point constants and set it to null.
+    /// All other constants have been copied into their respective arrays.
+    shader_dirty: std.EnumArray(mango.ShaderStage, ?*backend.Shader),
+
+    floating_dirty: std.EnumArray(mango.ShaderStage, std.EnumSet(pica.shader.register.Source.Constant)) = .initFill(.initEmpty()),
+
+    // Stored as XYZW
+    floating_constants: std.EnumArray(mango.ShaderStage, std.EnumArray(pica.shader.register.Source.Constant, [4]f32)),
+    // Stored as XYZW
+    integer_constants: std.EnumArray(mango.ShaderStage, std.EnumArray(pica.shader.register.Integral.Integer, [4]u8)),
+    boolean_constants: std.EnumArray(mango.ShaderStage, std.EnumSet(pica.shader.register.Integral.Boolean)),
+};
+
+pub const TextureUnitState = struct {
+    view: backend.ImageView,
+    sampler: backend.Sampler,
+};
+
+pub const LightingState = struct {
+    pub const empty: LightingState = .{
+        .ambient = undefined,
+        .light_enabled = .splat(false),
+        .light_types = .splat(.directional),
+        .light_attenuation_disabled = .splat(true),
+        .light_spotlight_disabled = .splat(true),
+        .light_shadows_disabled = .splat(true),
+
+        .light_parameters_dirty = .splat(false),
+        .light_parameters = undefined,
+
+        .light_factors_dirty = .splat(false),
+        .light_factors = undefined,
+
+        .light_attenuation_dirty = .splat(false),
+        .light_attenuation = @splat(.null),
+        .light_spotlight_dirty = .splat(false),
+        .light_spotlight = @splat(.null),
+    };
+
+    // TODO: separate some of this state
+    pub const LightParameters = struct {
+        vector: [3]f32,
+        spotlight_direction: [3]f32,
+
+        attenuation_bias: f32,
+        attenuation_scale: f32,
+    };
+
+    ambient: [3]u8,
+    light_enabled: BitpackedArray(bool, 8),
+    light_types: BitpackedArray(Graphics.FragmentLighting.Light.Type, 8),
+    light_attenuation_disabled: BitpackedArray(bool, 8),
+    light_spotlight_disabled: BitpackedArray(bool, 8),
+    light_shadows_disabled: BitpackedArray(bool, 8),
+
+    light_parameters_dirty: BitpackedArray(bool, 8),
+    light_parameters: [8]LightParameters,
+
+    light_factors_dirty: BitpackedArray(bool, 8),
+    light_factors: [8]mango.LightFactors,
+
+    light_attenuation_dirty: BitpackedArray(bool, 8),
+    light_attenuation: [8]mango.LightLookupTable,
+    light_spotlight_dirty: BitpackedArray(bool, 8),
+    light_spotlight: [8]mango.LightLookupTable,
+};
+
+pub const empty: RenderingState = .{
+    .misc = .empty,
+    .index_buffer_offset = undefined,
+    .vertex_buffers_offset = undefined,
+    .color_attachment = undefined,
+    .depth_stencil_attachment = undefined,
+    .uniform_state = .empty,
+    .texture_unit_enabled = @splat(false),
+    .texture_units = undefined,
+    .lighting_state = .empty,
+    .dirty = .init,
+};
+
+misc: Misc,
+index_buffer_offset: u28,
+vertex_buffers_offset: [12]u28,
+
+color_attachment: backend.ImageView,
+depth_stencil_attachment: backend.ImageView,
+
+uniform_state: UniformState,
+texture_unit_enabled: [3]bool,
+texture_units: [3]TextureUnitState,
+lighting_state: LightingState,
+dirty: Dirty,
+
+pub fn beginRendering(rnd: *RenderingState, rendering_info: mango.RenderingInfo) void {
+    rnd.color_attachment = .fromHandle(rendering_info.color_attachment);
+    rnd.depth_stencil_attachment = .fromHandle(rendering_info.depth_stencil_attachment);
+    rnd.dirty.begin_rendering = true;
+}
+
+pub fn endRendering(rnd: *RenderingState) void {
+    rnd.dirty.begin_rendering = false;
+}
+
+pub fn bindShaders(rnd: *RenderingState, stages: []const mango.ShaderStage, shaders: []const mango.Shader) void {
+    const dirty = &rnd.dirty;
+
+    for (stages, shaders) |stage, shader| {
+        const maybe_new: ?*backend.Shader = .fromHandleMutable(shader);
+
+        const boolean_constants = rnd.uniform_state.boolean_constants.getPtr(stage);
+        const integer_constants = rnd.uniform_state.integer_constants.getPtr(stage);
+        const shader_dirty = rnd.uniform_state.shader_dirty.getPtr(stage);
+
+        if (maybe_new) |new| {
+            boolean_constants.* = new.boolean_constant_set;
+
+            {
+                var i: usize = 0;
+                var it = new.integer_constant_set.iterator();
+
+                while (it.next()) |int| : (i += 1) {
+                    integer_constants.set(int, new.integer_constants[i]);
+                }
+            }
+
+            dirty.setUniformsDirty(stage, .bool);
+            if (new.integer_constants.len > 0) dirty.setUniformsDirty(stage, .int);
+            if (new.floating_constants.len > 0) dirty.setUniformsDirty(stage, .float);
+        } else switch (stage) {
+            .vertex => {}, // NOTE: binding a null vertex shader is a NOP as one must always be bound.
+            .geometry => dirty.clearDirtyStageUniforms(.geometry),
+        }
+
+        shader_dirty.* = maybe_new;
+    }
+}
+
+pub fn bindVertexBuffers(rnd: *RenderingState, first_binding: u32, binding_count: u32, buffers: [*]const mango.Buffer, offsets: [*]const u32) void {
+    if (binding_count == 0) return;
+
+    // NOTE: `comptime` here is needed even if the len is comptime? It somehow tries to read the array (which IS invalid as it shouldn't be accessed directly)
+    std.debug.assert(first_binding < (comptime p3d.primitive_engine.attributes.vertex_buffers.len) and first_binding + binding_count <= (comptime p3d.primitive_engine.attributes.vertex_buffers.len));
+    std.debug.assertReadable(std.mem.sliceAsBytes(buffers[0..binding_count]));
+    std.debug.assertReadable(std.mem.sliceAsBytes(offsets[0..binding_count]));
+
+    for (0..binding_count) |i| {
+        const current_binding = first_binding + i;
+        const offset = offsets[i];
+        const buffer: backend.Buffer = .fromHandle(buffers[i]);
+
+        std.debug.assert(offset <= buffer.size);
+        std.debug.assert(buffer.usage.vertex_buffer);
+
+        const buffer_physical_address = buffer.memory_info.boundPhysicalAddress();
+        const bound_vertex_offset = (@intFromEnum(buffer_physical_address) - @intFromEnum(backend.global_attribute_buffer_base)) + offset;
+
+        rnd.vertex_buffers_offset[current_binding] = @intCast(bound_vertex_offset);
+    }
+
+    rnd.misc.vertex_buffers_dirty_start, rnd.misc.vertex_buffers_dirty_end = if (rnd.dirty.vertex_buffers)
+        .{ @intCast(@min(first_binding, rnd.misc.vertex_buffers_dirty_start)), @intCast(@max(first_binding + binding_count, rnd.misc.vertex_buffers_dirty_end)) }
+    else
+        .{ @intCast(first_binding), @intCast(first_binding + binding_count) };
+
+    rnd.dirty.vertex_buffers = true;
+}
+
+pub fn bindIndexBuffer(rnd: *RenderingState, buffer: mango.Buffer, offset: u32, index_type: mango.IndexType) void {
+    const index_buffer: backend.Buffer = .fromHandle(buffer);
+
+    std.debug.assert(offset <= index_buffer.size);
+    std.debug.assert(index_buffer.usage.index_buffer);
+
+    const index_buffer_address: u32 = @intFromEnum(index_buffer.memory_info.boundPhysicalAddress()) + offset;
+
+    rnd.misc.index_format = index_type.native();
+    rnd.index_buffer_offset = @intCast(index_buffer_address - @intFromEnum(backend.global_attribute_buffer_base));
+}
+
+pub fn bindFloatUniforms(rnd: *RenderingState, stage: mango.ShaderStage, first_uniform: u32, uniforms: []const [4]f32) void {
+    std.debug.assert(first_uniform + uniforms.len <= 96);
+
+    if (uniforms.len == 0) return;
+
+    rnd.uniform_state.floating_dirty.getPtr(stage).bits.setRangeValue(.{
+        .start = first_uniform,
+        .end = first_uniform + @as(u32, @intCast(uniforms.len)),
+    }, true);
+
+    const flt_values = &rnd.uniform_state.floating_constants.getPtr(stage).values;
+    @memcpy(flt_values[first_uniform..][0..uniforms.len], uniforms);
+
+    rnd.dirty.setUniformsDirty(stage, .float);
+}
+
+pub fn bindCombinedImageSamplers(rnd: *RenderingState, first_combined: u32, combined_image_samplers: []const mango.CombinedImageSampler) void {
+    std.debug.assert(first_combined + combined_image_samplers.len <= 3);
+
+    for (combined_image_samplers, first_combined..) |unit, i| {
+        std.debug.assert((unit.image != .null and unit.sampler != .null) or (unit.sampler == .null and unit.image == .null));
+
+        rnd.dirty.setTextureUnitDirty(@intCast(i));
+        rnd.texture_unit_enabled[i] = unit.image != .null;
+
+        if (unit.image == .null) continue;
+
+        const b_image_view: backend.ImageView = .fromHandle(unit.image);
+        const b_sampler: backend.Sampler = .fromHandle(unit.sampler);
+
+        rnd.texture_units[i] = .{
+            .view = b_image_view,
+            .sampler = b_sampler,
+        };
+    }
+}
+
+pub fn setLightEnvironmentFactors(rnd: *RenderingState, factors: mango.LightEnvironmentFactors) void {
+    rnd.lighting_state.ambient = factors.ambient;
+    rnd.dirty.light_environment_factors = true;
+}
+
+pub fn bindLightTables(rnd: *RenderingState, slot: mango.LightLookupSlot, first_light: u32, tables: []const mango.LightLookupTable) void {
+    const stored, const dirty = switch (slot) {
+        .da => .{ &rnd.lighting_state.light_attenuation, &rnd.lighting_state.light_attenuation_dirty },
+        .sp => .{ &rnd.lighting_state.light_spotlight, &rnd.lighting_state.light_spotlight_dirty },
+    };
+
+    for (tables, 0..) |table, i| {
+        dirty.set(i, true);
+        stored[first_light + i] = table;
+    }
+
+    rnd.dirty.light_tables = true;
+}
+
+pub fn setLightsEnabled(rnd: *RenderingState, first_light: u32, enabled: []const bool) void {
+    std.debug.assert(first_light + enabled.len <= 8);
+    for (enabled, 0..) |enable, i| rnd.lighting_state.light_enabled.set(first_light + i, enable);
+    rnd.dirty.light_enable = true;
+}
+
+pub fn setLights(rnd: *RenderingState, first_light: u32, lights: []const mango.Light) void {
+    std.debug.assert(first_light + lights.len <= 8);
+
+    for (lights, 0..) |light, i| {
+        rnd.lighting_state.light_parameters_dirty.set(first_light + i, true);
+        rnd.lighting_state.light_types.set(first_light + i, light.type.native());
+        rnd.lighting_state.light_shadows_disabled.set(first_light + i, !light.enable_shadow);
+        rnd.lighting_state.light_attenuation_disabled.set(first_light + i, !light.enable_attenuation);
+        rnd.lighting_state.light_spotlight_disabled.set(first_light + i, !light.enable_spotlight);
+
+        rnd.lighting_state.light_parameters[first_light + i] = .{
+            .vector = light.vector,
+            .spotlight_direction = light.spotlight_direction,
+
+            .attenuation_bias = light.attenuation_bias,
+            .attenuation_scale = light.attenuation_scale,
+        };
+    }
+
+    rnd.dirty.light_parameters = true;
+}
+
+pub fn setLightFactors(rnd: *RenderingState, first_light: u32, light_factors: []const mango.LightFactors) void {
+    std.debug.assert(first_light + light_factors.len <= 8);
+
+    for (0..light_factors.len) |i| rnd.lighting_state.light_factors_dirty.set(first_light + i, true);
+    @memcpy(rnd.lighting_state.light_factors[first_light..][0..light_factors.len], light_factors);
+    rnd.dirty.light_factors = true;
+}
+
+pub fn anyDirty(state: *RenderingState) bool {
+    return @as(u32, @bitCast(state.dirty)) != 0;
+}
+
+/// Returns the maximum amount of words the next dirty emission will take.
+///
+/// Its a safe upper bound, not the exact amount needed.
+pub fn maxEmitDirtyQueueLength(rnd: *RenderingState) usize {
+    // NOTE: This must be FAST as its always checked every drawcall!
+    // TODO: Optimize this
+    const dirty = &rnd.dirty;
+
+    // zig fmt: off
+    var cost: usize = (@as(usize, @intFromBool(dirty.begin_rendering)) * 8)
+                    + (@as(usize, @intFromBool(dirty.light_environment_factors)) * 2)
+                    + @as(usize, @intFromBool(dirty.light_enable or dirty.light_factors or dirty.light_parameters)) * 30
+                    + (@as(usize, @intFromBool(dirty.vertex_buffers)) * (rnd.misc.vertex_buffers_dirty_end - rnd.misc.vertex_buffers_dirty_start)) * 6;
+    // zig fmt: on
+
+    for (std.enums.values(mango.ShaderStage)) |stage| {
+        if (dirty.isStageUniformsDirty(stage)) {
+            const bool_dirty: usize = @intFromBool(dirty.isUniformsDirty(stage, .bool));
+            const int_dirty: usize = @intFromBool(dirty.isUniformsDirty(stage, .int));
+
+            cost += (rnd.uniform_state.floating_dirty.getPtr(stage).count() * 8) + (int_dirty * 8) + (bool_dirty * 4);
+        }
+    }
+
+    if (dirty.isAnyTextureUnitDirty()) {
+        for (0..3) |i| {
+            cost += @as(usize, @intFromBool(dirty.isTextureUnitDirty(@intCast(i)))) * 10;
+        }
+    }
+
+    if (dirty.light_tables) {
+        for (0..8) |i| if (rnd.lighting_state.light_attenuation_dirty.get(i)) {
+            cost += 264;
+        };
+
+        for (0..8) |i| if (rnd.lighting_state.light_spotlight_dirty.get(i)) {
+            cost += 264;
+        };
+    }
+
+    return cost;
+}
+
+pub fn emitDirty(rnd: *RenderingState, queue: *command.Queue) void {
+    const dirty = &rnd.dirty;
+
+    if (dirty.isAnyUniformsDirty()) {
+        rnd.emitDirtyUniforms(queue);
+    }
+
+    if (dirty.isAnyTextureUnitDirty()) {
+        rnd.emitDirtyTextureUnits(queue);
+    }
+
+    if (dirty.light_environment_factors) {
+        queue.add(p3d, &p3d.fragment_lighting.ambient, .initBuffer(rnd.lighting_state.ambient));
+    }
+
+    if (dirty.light_tables) {
+        const tables: []const []const mango.LightLookupTable = &.{ &rnd.lighting_state.light_attenuation, &rnd.lighting_state.light_spotlight };
+        const dirty_tables: []const *BitpackedArray(bool, 8) = &.{ &rnd.lighting_state.light_attenuation_dirty, &rnd.lighting_state.light_spotlight_dirty };
+        const first_selectors: []const Graphics.FragmentLighting.LookupTable = &.{ .da0, .sp0 };
+
+        for (tables, dirty_tables, first_selectors) |table, dirty_table, first| for (0..8) |i| if (dirty_table.get(i)) {
+            if (table[i] == .null) continue;
+
+            const b_table: *backend.LightLookupTable = .fromHandleMutable(table[i]);
+            const selector: Graphics.FragmentLighting.LookupTable = @enumFromInt(@intFromEnum(first) + i);
+
+            queue.add(p3d, &p3d.fragment_lighting.lut_index, .init(selector, 0));
+            queue.addConsecutive(p3d, &p3d.fragment_lighting.lut_data[0], &b_table.data);
+        };
+    }
+
+    if (dirty.light_parameters) {
+        for (0..8) |i| if (rnd.lighting_state.light_parameters_dirty.get(i)) {
+            const params = rnd.lighting_state.light_parameters[i];
+            const factors = rnd.lighting_state.light_factors[i];
+
+            queue.add(p3d, &p3d.fragment_lighting.light[i].parameters, .{
+                .xy = .init(.of(params.vector[0]), .of(params.vector[1])),
+                .z = .init(.of(params.vector[2])),
+                .spot_xy = .init(.ofSaturating(params.spotlight_direction[0]), .ofSaturating(params.spotlight_direction[1])),
+                .spot_z = .init(.ofSaturating(params.spotlight_direction[2])),
+            });
+
+            queue.add(p3d, &p3d.fragment_lighting.light[i].config, .{
+                .type = rnd.lighting_state.light_types.get(i),
+                .diffuse_sides = factors.sides.native(),
+                .geometric_factor_enable = factors.geometric.native(),
+            });
+
+            if (!rnd.lighting_state.light_attenuation_disabled.get(i)) {
+                queue.add(p3d, &p3d.fragment_lighting.light[i].attenuation, .{
+                    .bias = .init(.of(params.attenuation_bias)),
+                    .scale = .init(.of(params.attenuation_scale)),
+                });
+            }
+        };
+
+        // Finally enable / disable da, sp and shadows per-light.
+        queue.addMasked(p3d, &p3d.fragment_lighting.control.lights, .{
+            .shadows_disabled = rnd.lighting_state.light_shadows_disabled,
+            .spotlight_disabled = rnd.lighting_state.light_spotlight_disabled,
+            .distance_attenuation_disabled = rnd.lighting_state.light_attenuation_disabled,
+            // NOTE: Ignored by mask
+            .disable_d0 = false,
+            .disable_d1 = false,
+            .disable_fr = false,
+            .disable_rb = false,
+            .disable_rg = false,
+            .disable_rr = false,
+        }, 0b1011);
+    }
+
+    if (dirty.light_factors) {
+        for (0..8) |i| if (rnd.lighting_state.light_factors_dirty.get(i)) {
+            const factors = rnd.lighting_state.light_factors[i];
+
+            // We already configured the light if we changed parameters.
+            if (!dirty.light_parameters) {
+                queue.add(p3d, &p3d.fragment_lighting.light[i].config, .{
+                    .type = rnd.lighting_state.light_types.get(i),
+                    .diffuse_sides = factors.sides.native(),
+                    .geometric_factor_enable = factors.geometric.native(),
+                });
+            }
+
+            queue.add(p3d, &p3d.fragment_lighting.light[i].factors, .{
+                .specular = .{ .initBuffer(factors.specular[0]), .initBuffer(factors.specular[1]) },
+                .diffuse = .initBuffer(factors.diffuse),
+                .ambient = .initBuffer(factors.ambient),
+            });
+        };
+    }
+
+    if (dirty.light_enable) {
+        const lights_enabled = rnd.lighting_state.light_enabled;
+
+        var enabled: u4 = 0;
+        var permutation: BitpackedArray(Graphics.FragmentLighting.Light.Id, 8) = .splat(@enumFromInt(0));
+
+        for (0..8) |i| if (lights_enabled.get(i)) {
+            permutation.set(enabled, @enumFromInt(i));
+            enabled += 1;
+        };
+
+        // TODO: validate a light is always enabled
+
+        std.debug.assert(enabled > 0);
+        queue.add(p3d, &p3d.fragment_lighting.light_permutation, permutation);
+        queue.add(p3d, &p3d.fragment_lighting.num_lights_min_one, .init(@intCast(enabled - 1)));
+    }
+
+    if (dirty.vertex_buffers) {
+        for (rnd.misc.vertex_buffers_dirty_start..rnd.misc.vertex_buffers_dirty_end) |current_binding| {
+            queue.add(p3d, &p3d.primitive_engine.attributes.vertex_buffers[current_binding].offset, .init(rnd.vertex_buffers_offset[current_binding]));
+        }
+    }
+
+    if (dirty.begin_rendering) {
+        const color_width: u16, const color_height: u16, const color_physical_address: PhysicalAddress, const color_format = if (rnd.color_attachment.data.valid) info: {
+            @branchHint(.likely);
+            const color_attachment: backend.ImageView = rnd.color_attachment;
+            const color_rendering_info = color_attachment.getRenderingInfo();
+
+            break :info .{
+                color_rendering_info.width,
+                color_rendering_info.height,
+                color_rendering_info.address,
+                color_attachment.data.format().nativeColorFormat(),
+            };
+        } else .{ 0, 0, .fromAddress(0), .abgr8888 };
+
+        const depth_stencil_width: u16, const depth_stencil_height: u16, const depth_stencil_physical_address: PhysicalAddress, const depth_format = if (rnd.depth_stencil_attachment.data.valid) info: {
+            const depth_stencil_attachment: backend.ImageView = rnd.depth_stencil_attachment;
+            const depth_stencil_rendering_info = depth_stencil_attachment.getRenderingInfo();
+
+            break :info .{
+                depth_stencil_rendering_info.width,
+                depth_stencil_rendering_info.height,
+                depth_stencil_rendering_info.address,
+                depth_stencil_attachment.data.format().nativeDepthStencilFormat(),
+            };
+        } else .{ 0, 0, .fromAddress(0), .d16 };
+
+        if (color_width != 0 and depth_stencil_width != 0) {
+            std.debug.assert(color_width == depth_stencil_width and color_height == depth_stencil_height);
+        }
+
+        const width, const height = if (color_width != 0)
+            .{ color_width, color_height }
+        else
+            .{ depth_stencil_width, depth_stencil_height };
+
+        queue.add(p3d, &p3d.output_merger.invalidate, .init(.trigger));
+        queue.addIncremental(p3d, .{
+            &p3d.output_merger.color_read,
+            &p3d.output_merger.color_write,
+            &p3d.output_merger.depth_read,
+            &p3d.output_merger.depth_write,
+            &p3d.output_merger.depth_format,
+            &p3d.output_merger.color_format,
+        }, .{
+            .init(if (color_physical_address == .zero) .disable else .all),
+            .init(if (color_physical_address == .zero) .disable else .all),
+            .init(if (depth_stencil_physical_address == .zero) .disable else .all),
+            .init(if (depth_stencil_physical_address == .zero) .disable else .all),
+            .init(depth_format),
+            .init(color_format),
+        });
+
+        queue.addIncremental(p3d, .{
+            &p3d.output_merger.depth_location,
+            &p3d.output_merger.color_location,
+            &p3d.output_merger.dimensions,
+        }, .{
+            .fromPhysical(depth_stencil_physical_address),
+            .fromPhysical(color_physical_address),
+            .{
+                .width = @intCast(width),
+                .height_end = @intCast(height - 1),
+                // TODO: Expose a flag for flipping?
+                .flip_vertically = true,
+            },
+        });
+    }
+
+    dirty.* = .{};
+}
+
+fn emitDirtyTextureUnits(rnd: *RenderingState, queue: *command.Queue) void {
+    const dirty = rnd.dirty;
+
+    // NOTE: The 0th or Primary texture unit is special as it can handle
+    // all possible texture types and are not limited to only 2D!
+    if (rnd.texture_unit_enabled[0] and dirty.isTextureUnitDirty(0)) {
+        // TODO: Cubemaps, Shadow, Projected textures, etc...
+
+        const image_view = rnd.texture_units[0].view;
+        const sampler = rnd.texture_units[0].sampler;
+
+        const image: *backend.Image = .fromHandleMutable(rnd.texture_units[0].view.data.image);
+
+        std.debug.assert(!image.memory_info.isUnbound());
+        const address = image.memory_info.boundPhysicalAddress();
+        const image_format = image.info.format.nativeTextureUnitFormat();
+        const format = image_view.data.format().nativeTextureUnitFormat();
+
+        const total_layer_size = image_format.scale(image.info.layer_size);
+        const base_address = @intFromEnum(address) + (total_layer_size * image_view.data.base_array_layer);
+
+        queue.addIncremental(p3d, .{
+            &p3d.texture_units.@"0".border_color,
+            &p3d.texture_units.@"0".dimensions,
+            &p3d.texture_units.@"0".parameters,
+            &p3d.texture_units.@"0".lod,
+            &p3d.texture_units.@"0".address[0],
+        }, .{
+            sampler.data.borderColor(),
+            .{ image.info.height(), image.info.width() },
+            .{
+                .mag_filter = sampler.data.mag_filter,
+                .min_filter = sampler.data.min_filter,
+                .etc1 = if (format == .etc1) .etc1 else .none,
+                .address_mode_v = sampler.data.address_mode_v,
+                .address_mode_u = sampler.data.address_mode_u,
+                .is_shadow = false, // TODO: shadow
+                .mip_filter = sampler.data.mip_filter,
+                .type = if (sampler.data.projected) // TODO: shadow 2d and shadow cube
+                    .projection
+                else if (image_view.data.is_cube)
+                    .cube_map
+                else
+                    .@"2d",
+            },
+            .{
+                .bias = sampler.data.lod_bias,
+                .max_level_of_detail = @min(image_view.data.levels_minus_one, sampler.data.max_lod),
+                .min_level_of_detail = @max(image_view.data.base_mip_level, sampler.data.min_lod),
+            },
+            .fromAddress(base_address),
+        });
+
+        if (image_view.data.is_cube) {
+            queue.addIncremental(p3d, .{
+                &p3d.texture_units.@"0".address[1],
+                &p3d.texture_units.@"0".address[2],
+                &p3d.texture_units.@"0".address[3],
+                &p3d.texture_units.@"0".address[4],
+                &p3d.texture_units.@"0".address[5],
+            }, .{
+                .fromAddress(base_address + total_layer_size),
+                .fromAddress(base_address + total_layer_size * 2),
+                .fromAddress(base_address + total_layer_size * 3),
+                .fromAddress(base_address + total_layer_size * 4),
+                .fromAddress(base_address + total_layer_size * 5),
+            });
+        }
+
+        queue.add(p3d, &p3d.texture_units.@"0".format, .init(format));
+    }
+
+    // NOTE: Remaining units are ONLY 2D, they ignore their type
+    for (1..3) |unit| {
+        if (!rnd.texture_unit_enabled[unit] or !dirty.isTextureUnitDirty(@intCast(unit))) continue;
+
+        const image_view = rnd.texture_units[unit].view;
+        const sampler = rnd.texture_units[unit].sampler;
+
+        const image: *backend.Image = .fromHandleMutable(rnd.texture_units[unit].view.data.image);
+
+        std.debug.assert(!image.memory_info.isUnbound());
+        const address = image.memory_info.boundPhysicalAddress();
+        const format = image_view.data.format().nativeTextureUnitFormat();
+
+        const unit_register = switch (unit) {
+            1 => &p3d.texture_units.@"1",
+            2 => &p3d.texture_units.@"2",
+            else => unreachable,
+        };
+
+        queue.add(p3d, unit_register, .{
+            .border_color = sampler.data.borderColor(),
+            .dimensions = .{ image.info.height(), image.info.width() },
+            .parameters = .{
+                .mag_filter = sampler.data.mag_filter,
+                .min_filter = sampler.data.min_filter,
+                .etc1 = if (format == .etc1) .etc1 else .none,
+                .address_mode_v = sampler.data.address_mode_v,
+                .address_mode_u = sampler.data.address_mode_u,
+                .is_shadow = false,
+                .mip_filter = sampler.data.mip_filter,
+                .type = .@"2d",
+            },
+            .lod = .{
+                .bias = sampler.data.lod_bias,
+                .max_level_of_detail = @min(image_view.data.levels_minus_one, sampler.data.max_lod),
+                .min_level_of_detail = @max(image_view.data.base_mip_level, sampler.data.min_lod),
+            },
+            .address = .fromPhysical(address),
+            .format = .init(format),
+        });
+    }
+
+    // NOTE: After updating textures we MUST clear the texture cache! (+ Set enabled/non-null units)
+    queue.addMasked(p3d, &p3d.texture_units.config, .{
+        .texture_enabled = .init(rnd.texture_unit_enabled), // NOTE: Not affected by the mask
+        .texture_3_coordinates = .@"0",
+        .texture_3_enabled = false,
+        .texture_2_coordinates = .@"1",
+        .clear_texture_cache = true, // NOTE: Not affected by the mask
+    }, 0b0101);
+}
+
+fn emitDirtyUniforms(rnd: *RenderingState, queue: *command.Queue) void {
+    const dirty = rnd.dirty;
+    const shader_registers: []const *volatile Graphics.Shader = &.{ &p3d.vertex_shader, &p3d.geometry_shader };
+    const shader_stages: []const mango.ShaderStage = &.{ mango.ShaderStage.vertex, mango.ShaderStage.geometry };
+
+    for (shader_registers, shader_stages) |registers, stage| {
+        const maybe_shader = rnd.uniform_state.shader_dirty.getPtr(stage);
+        defer maybe_shader.* = null;
+
+        const floating_dirty = rnd.uniform_state.floating_dirty.getPtr(stage);
+
+        if (maybe_shader.*) |shader| emitShaderUniforms(shader, registers, queue);
+
+        for (std.enums.values(UniformLocation)) |location| if (dirty.isUniformsDirty(stage, location)) switch (location) {
+            .bool => queue.add(p3d, &registers.bool_uniforms, .init(@bitCast(rnd.uniform_state.boolean_constants.get(stage).bits))),
+            .int => queue.add(p3d, &registers.int_uniforms[0..4].*, rnd.uniform_state.integer_constants.get(stage).values),
+            .float => emitFloatUniforms(floating_dirty, rnd.uniform_state.floating_constants.getPtr(stage), registers, queue),
+        };
+    }
+}
+
+fn emitShaderUniforms(shader: *backend.Shader, p3d_shader: *volatile pica.Graphics.Shader, queue: *command.Queue) void {
+    const floating_constants = shader.floating_constants;
+
+    var it = shader.floating_constant_set.iterator();
+    var current = it.next();
+    var i: usize = 0;
+    while (current) |initial| {
+        var seq_constants: usize = 1;
+        defer i += seq_constants;
+
+        while (true) : (seq_constants += 1) {
+            current = it.next();
+
+            const next = current orelse break;
+            if ((@intFromEnum(next) - @intFromEnum(initial)) != 1) break;
+        }
+
+        queue.add(p3d, &p3d_shader.float_uniform_index, .{ .index = initial, .mode = .f7_16 });
+        queue.addConsecutive(p3d, &p3d_shader.float_uniform_data[0], @ptrCast(floating_constants[i..][0..seq_constants]));
+    }
+}
+
+fn emitFloatUniforms(flt_dirty: *std.EnumSet(pica.shader.register.Source.Constant), flt_constants: *std.EnumArray(pica.shader.register.Source.Constant, [4]f32), p3d_shader: *volatile pica.Graphics.Shader, queue: *command.Queue) void {
+    var it = flt_dirty.iterator();
+    var current = it.next();
+    while (current) |initial| {
+        // NOTE: They were stored as XYZW but PICA expects WZYX
+        // We can modify in-place because we know it won't be used again until it gets dirty again!
+        std.mem.reverse(f32, flt_constants.getPtr(initial));
+
+        var seq_constants: usize = 1;
+        while (true) : (seq_constants += 1) {
+            current = it.next();
+
+            const next = current orelse break;
+            if ((@intFromEnum(next) - @intFromEnum(initial)) != 1) break;
+            std.mem.reverse(f32, flt_constants.getPtr(next));
+        }
+
+        queue.add(p3d, &p3d_shader.float_uniform_index, .{ .index = initial, .mode = .f8_23 });
+        queue.addConsecutive(p3d, &p3d_shader.float_uniform_data[0], @ptrCast(flt_constants.values[@intFromEnum(initial)..][0..seq_constants]));
+    }
+
+    flt_dirty.* = .initEmpty();
+}
+
+const RenderingState = @This();
+
+const backend = @import("backend.zig");
+
+const std = @import("std");
+const zitrus = @import("zitrus");
+const mango = zitrus.mango;
+
+const pica = zitrus.hardware.pica;
+const Graphics = pica.Graphics;
+
+const BitpackedArray = zitrus.hardware.BitpackedArray;
+const PhysicalAddress = zitrus.hardware.PhysicalAddress;
+
+const command = pica.command;
+
+const p3d = &zitrus.memory.arm11.pica.p3d;
diff --git a/src/platform/3ds/mango/mango/Sampler.zig b/src/platform/3ds/mango/mango/Sampler.zig
new file mode 100644
index 0000000..1299095
--- /dev/null
+++ b/src/platform/3ds/mango/mango/Sampler.zig
@@ -0,0 +1,67 @@
+//! Sampler parameters of a PICA200 texture unit.
+//!
+//! Samplers just configure the behaviour of the PICA200 when sampling it like projections
+
+pub const Handle = enum(u64) {
+    null = 0,
+    _,
+};
+
+pub const Data = packed struct(u64) {
+    // NOTE: This is to make a possibly valid `Handle` null.
+    valid: bool = true,
+    mag_filter: pica.TextureUnitFilter,
+    min_filter: pica.TextureUnitFilter,
+    mip_filter: pica.TextureUnitFilter,
+    address_mode_u: pica.TextureUnitAddressMode,
+    address_mode_v: pica.TextureUnitAddressMode,
+    min_lod: u4,
+    max_lod: u4,
+    lod_bias: pica.Q4_8,
+    projected: bool = false,
+    // NOTE: Don't move this, it IS like this to get the border color with just one bit shift.
+    border_color_r: u8,
+    border_color_g: u8,
+    border_color_b: u8,
+    border_color_a: u8,
+
+    pub fn init(create_info: mango.SamplerCreateInfo) Data {
+        return .{
+            .mag_filter = create_info.mag_filter.native(),
+            .min_filter = create_info.min_filter.native(),
+            .mip_filter = create_info.mip_filter.native(),
+            .address_mode_u = create_info.address_mode_u.native(),
+            .address_mode_v = create_info.address_mode_v.native(),
+            .min_lod = @intCast(create_info.min_lod),
+            .max_lod = @intCast(create_info.max_lod),
+            .lod_bias = .ofSaturating(create_info.lod_bias),
+            .border_color_r = create_info.border_color[0],
+            .border_color_g = create_info.border_color[1],
+            .border_color_b = create_info.border_color[2],
+            .border_color_a = create_info.border_color[3],
+        };
+    }
+
+    pub fn borderColor(data: Data) [4]u8 {
+        return @bitCast(@as(u32, @truncate(@as(u64, @bitCast(data)) >> 32)));
+    }
+};
+
+data: Data,
+
+pub fn toHandle(sampler: Sampler) Handle {
+    return @enumFromInt(@as(u64, @bitCast(sampler.data)));
+}
+
+pub fn fromHandle(handle: Handle) Sampler {
+    return .{ .data = @bitCast(@intFromEnum(handle)) };
+}
+
+const Sampler = @This();
+
+const std = @import("std");
+const zitrus = @import("zitrus");
+const mango = zitrus.mango;
+const pica = zitrus.hardware.pica;
+
+const PhysicalAddress = zitrus.hardware.PhysicalAddress;
diff --git a/src/platform/3ds/mango/mango/Semaphore.zig b/src/platform/3ds/mango/mango/Semaphore.zig
new file mode 100644
index 0000000..d7291fa
--- /dev/null
+++ b/src/platform/3ds/mango/mango/Semaphore.zig
@@ -0,0 +1,40 @@
+//! Semaphores in mango are basically timeline semaphores in vulkan, they have a monotonically increasing 64-bit value.
+
+pub const Handle = enum(u32) {
+    null = 0,
+    _,
+};
+
+value: u64,
+
+/// Wake cookie.
+wake: std.atomic.Value(i32) = .init(0),
+
+pub fn init(create_info: mango.SemaphoreCreateInfo) Semaphore {
+    return .{
+        .value = create_info.initial_value,
+    };
+}
+
+pub fn counterValue(sema: *Semaphore) u64 {
+    return sema.value;
+}
+
+pub fn signal(sema: *Semaphore, value: u64) bool {
+    sema.value = @max(sema.value, value);
+    return sema.wake.swap(0, .monotonic) < 0;
+}
+
+pub fn toHandle(image: *Semaphore) Handle {
+    return @enumFromInt(@intFromPtr(image));
+}
+
+pub fn fromHandleMutable(handle: Handle) *Semaphore {
+    return @as(*Semaphore, @ptrFromInt(@intFromEnum(handle)));
+}
+
+const Semaphore = @This();
+
+const std = @import("std");
+const zitrus = @import("zitrus");
+const mango = zitrus.mango;
diff --git a/src/platform/3ds/mango/mango/Shader.zig b/src/platform/3ds/mango/mango/Shader.zig
new file mode 100644
index 0000000..488aac7
--- /dev/null
+++ b/src/platform/3ds/mango/mango/Shader.zig
@@ -0,0 +1,116 @@
+pub const Handle = enum(u32) {
+    null = 0,
+    _,
+};
+
+/// Deduplicated on shader creation.
+pub const Code = struct {
+    pub const Key = struct {
+        hash: u32,
+
+        instructions: []const pica.shader.encoding.Instruction,
+        descriptors: []const pica.shader.encoding.OperandDescriptor,
+
+        pub fn initCode(code: *Code) Key {
+            return .{
+                .hash = code.hash,
+                .instructions = code.instructions,
+                .descriptors = code.descriptors,
+            };
+        }
+
+        pub fn initZpsh(parsed: zitrus.fmt.zpsh.Parsed) Key {
+            return .{
+                .hash = parsed.code_hash,
+                .instructions = parsed.instructions,
+                .descriptors = parsed.operand_descriptors,
+            };
+        }
+    };
+
+    ref: std.atomic.Value(u32),
+    hash: u32,
+    uid: u32,
+
+    instructions: []const pica.shader.encoding.Instruction,
+    descriptors: []const pica.shader.encoding.OperandDescriptor,
+
+    pub fn init(uid: u32, hash: u32, instructions: []const pica.shader.encoding.Instruction, descriptors: []const pica.shader.encoding.OperandDescriptor) Code {
+        return .{
+            .ref = .init(1),
+            .hash = hash,
+            .uid = uid,
+            .instructions = instructions,
+            .descriptors = descriptors,
+        };
+    }
+};
+
+code: *Code,
+
+entry: u16,
+info: zpsh.EntrypointHeader.ShaderInfo,
+
+boolean_constant_set: std.enums.EnumSet(BooleanRegister),
+integer_constant_set: std.enums.EnumSet(IntegerRegister),
+floating_constant_set: std.enums.EnumSet(FloatingRegister),
+output_set: std.enums.EnumSet(OutputRegister),
+
+integer_constants: []const [4]u8,
+floating_constants: []const pica.F7_16x4,
+output_map: []const pica.OutputMap,
+
+pub fn init(gpa: std.mem.Allocator, code: *Code, entry: zpsh.Parsed.EntrypointIterator.Entry) !Shader {
+    const all_data = try gpa.alloc(u32, entry.integer_constants.len + entry.output_map.len + entry.floating_constants.len * @divExact(@sizeOf(pica.F7_16x4), @sizeOf(u32)));
+    errdefer comptime unreachable;
+
+    const integer_constants: [][4]u8 = @ptrCast(all_data[0..entry.integer_constants.len]);
+    const output_map: []pica.OutputMap = @ptrCast(all_data[entry.integer_constants.len..][0..entry.output_map.len]);
+    const floating_constants: []pica.F7_16x4 = @ptrCast(all_data[entry.integer_constants.len + entry.output_map.len ..]);
+    @memcpy(integer_constants, entry.integer_constants);
+    @memcpy(output_map, entry.output_map);
+    @memcpy(floating_constants, entry.floating_constants);
+
+    return .{
+        .code = code,
+        .entry = entry.offset,
+        .info = entry.info,
+        .boolean_constant_set = entry.boolean_constant_set,
+        .integer_constant_set = entry.integer_constant_set,
+        .floating_constant_set = entry.floating_constant_set,
+        .output_set = entry.output_set,
+
+        .integer_constants = integer_constants,
+        .floating_constants = floating_constants,
+        .output_map = output_map,
+    };
+}
+
+pub fn deinit(shader: *Shader, gpa: std.mem.Allocator) void {
+    const data_start: [*]const u32 = @ptrCast(@alignCast(shader.integer_constants.ptr));
+    const all_data = data_start[0 .. shader.integer_constants.len + shader.output_map.len + shader.floating_constants.len * @divExact(@sizeOf(pica.F7_16x4), @sizeOf(u32))];
+
+    gpa.free(all_data);
+    shader.* = undefined;
+}
+
+pub fn toHandle(shader: *Shader) Handle {
+    return @enumFromInt(@intFromPtr(shader));
+}
+
+pub fn fromHandleMutable(handle: Handle) ?*Shader {
+    return @as(?*Shader, @ptrFromInt(@intFromEnum(handle)));
+}
+
+const Shader = @This();
+
+const std = @import("std");
+const zitrus = @import("zitrus");
+
+const zpsh = zitrus.fmt.zpsh;
+const pica = zitrus.hardware.pica;
+
+const BooleanRegister = pica.shader.register.Integral.Boolean;
+const IntegerRegister = pica.shader.register.Integral.Integer;
+const FloatingRegister = pica.shader.register.Source.Constant;
+const OutputRegister = pica.shader.register.Destination.Output;
diff --git a/src/platform/3ds/mango/mango/Surface.zig b/src/platform/3ds/mango/mango/Surface.zig
new file mode 100644
index 0000000..42b3fbd
--- /dev/null
+++ b/src/platform/3ds/mango/mango/Surface.zig
@@ -0,0 +1,11 @@
+//! Wraps an LCD screen
+//!
+//! Currently surfaces are hardcoded values as a fixed set of DisplayModes is supported.
+//! TODO: This could be augmented. Investigate lcd display modes.
+
+pub const Handle = enum(u32) {
+    null = 0,
+    top_240x400,
+    bottom_240x320,
+    top_240x800,
+};
diff --git a/src/platform/3ds/mango/mango/Swapchain.zig b/src/platform/3ds/mango/mango/Swapchain.zig
new file mode 100644
index 0000000..1af3b6f
--- /dev/null
+++ b/src/platform/3ds/mango/mango/Swapchain.zig
@@ -0,0 +1,29 @@
+//! Wraps LCD surfaces for PICA200 output for presentation.
+//!
+//! Swapchains don't allocate memory by themselves, they are linked with up to
+//! three linearly tiled `Image`s.
+//!
+//! As `Swapchain`s don't own its data, you're free to recreate swapchains with different formats dynamically.
+//! As only 2 swapchains can be created at the same time (top and bottom), their data is embedded in the presentation engine.
+
+pub const Handle = enum(u32) {
+    null = 0,
+    _,
+};
+
+pub fn toHandle(screen: pica.Screen) Handle {
+    return @enumFromInt(@as(u32, @intFromEnum(screen)) + 1);
+}
+
+pub fn fromHandle(handle: Handle) pica.Screen {
+    return @enumFromInt(@intFromEnum(handle) - 1);
+}
+
+const Swapchain = @This();
+const backend = @import("backend.zig");
+
+const std = @import("std");
+const zitrus = @import("zitrus");
+const mango = zitrus.mango;
+
+const pica = zitrus.hardware.pica;
diff --git a/src/platform/3ds/mango/mango/TextureCombinerState.zig b/src/platform/3ds/mango/mango/TextureCombinerState.zig
new file mode 100644
index 0000000..3c35161
--- /dev/null
+++ b/src/platform/3ds/mango/mango/TextureCombinerState.zig
@@ -0,0 +1,53 @@
+pub const empty: TextureCombinerState = .{
+    .config = std.mem.zeroes(pica.Graphics.TextureCombiners.Config),
+    .units = undefined,
+    .configured = 0,
+};
+
+config: PicaCombiners.Config,
+units: [6]PicaCombiners.Unit,
+configured: u8,
+
+pub fn compile(combiners: []const mango.TextureCombinerUnit, combiner_buffer_sources: []const mango.TextureCombinerUnit.BufferSources) TextureCombinerState {
+    std.debug.assert(combiners.len > 0 and combiners.len <= 6);
+    std.debug.assert(combiner_buffer_sources.len == expected_buffer_source_count(combiners.len));
+
+    var combiner_state: TextureCombinerState = .{
+        .config = std.mem.zeroes(PicaCombiners.Config),
+        .units = undefined,
+        .configured = @intCast(combiners.len),
+    };
+
+    for (combiner_buffer_sources, 0..) |buffer_sources, index| {
+        combiner_state.config.setColorBufferSource(@enumFromInt(index), buffer_sources.color_buffer_src.native());
+        combiner_state.config.setAlphaBufferSource(@enumFromInt(index), buffer_sources.alpha_buffer_src.native());
+    }
+
+    for (combiners, 0..) |combiner, i| {
+        combiner_state.units[i] = combiner.native();
+    }
+
+    for (combiners.len..combiner_state.units.len) |i| {
+        combiner_state.units[i] = mango.TextureCombinerUnit.previous.native();
+    }
+
+    return combiner_state;
+}
+
+const TextureCombinerState = @This();
+
+fn expected_buffer_source_count(combiner_count: usize) usize {
+    return switch (combiner_count) {
+        0 => 0,
+        1 => 0,
+        5, 6 => 4,
+        else => combiner_count - 1,
+    };
+}
+
+const std = @import("std");
+const zitrus = @import("zitrus");
+const mango = zitrus.mango;
+const pica = zitrus.hardware.pica;
+
+const PicaCombiners = pica.Graphics.TextureCombiners;
diff --git a/src/platform/3ds/mango/mango/VertexInputLayout.zig b/src/platform/3ds/mango/mango/VertexInputLayout.zig
new file mode 100644
index 0000000..539281f
--- /dev/null
+++ b/src/platform/3ds/mango/mango/VertexInputLayout.zig
@@ -0,0 +1,335 @@
+pub const Handle = enum(u32) {
+    null = 0,
+    _,
+};
+
+pub const CompileError = validation.Error;
+
+const GpuAttributeConfig = pica.Graphics.PrimitiveEngine.Attribute.Config;
+const GpuAttributeBufferConfig = pica.Graphics.PrimitiveEngine.Attribute.VertexBuffer.Config;
+const GpuArrayComponent = GpuAttributeBufferConfig.ArrayComponent;
+const GpuAttributePermutation = pica.Graphics.Shader.AttributePermutation;
+
+const gpu_array_paddings: []const GpuArrayComponent = &.{ GpuArrayComponent.padding_16, GpuArrayComponent.padding_12, GpuArrayComponent.padding_8, GpuArrayComponent.padding_4 };
+
+config: GpuAttributeConfig,
+buffer_config: [12]GpuAttributeBufferConfig,
+permutation: GpuAttributePermutation,
+buffers_len: u8,
+// TODO: we're missing fixed attributes
+
+const BindingAttributeInfo = struct {
+    offset: u8,
+    index_format: packed struct(u8) {
+        index: u4,
+        format: pica.Graphics.PrimitiveEngine.Attribute.Format,
+    },
+
+    pub fn lessThan(_: void, lhs: BindingAttributeInfo, rhs: BindingAttributeInfo) bool {
+        return lhs.offset < rhs.offset;
+    }
+};
+
+pub fn compile(bindings: []const mango.VertexInputBindingDescription, attributes: []const mango.VertexInputAttributeDescription, fixed_attributes: []const mango.VertexInputFixedAttributeDescription) CompileError!VertexInputLayout {
+    var layout: VertexInputLayout = .{
+        .config = .{
+            .low = .{},
+            .high = .{ .attributes_end = @intCast((attributes.len + fixed_attributes.len) - 1) },
+        },
+        .buffer_config = undefined,
+        .permutation = .{},
+        .buffers_len = @intCast(bindings.len),
+    };
+
+    var binding_attributes_end: [12]u8 = @splat(0);
+    var binding_attributes: [12][12]BindingAttributeInfo = undefined;
+
+    for (attributes, 0..) |attribute, i| {
+        const native_format = attribute.format.nativeVertexFormat();
+        const binding_index = @intFromEnum(attribute.binding);
+        const offset = attribute.offset;
+
+        layout.permutation.setAttribute(@enumFromInt(i), @enumFromInt(@intFromEnum(attribute.location)));
+        layout.config.setAttribute(@enumFromInt(i), native_format);
+        layout.config.setFlag(@enumFromInt(i), .array);
+
+        const end = &binding_attributes_end[binding_index];
+
+        binding_attributes[binding_index][end.*] = .{
+            .index_format = .{
+                .index = @intCast(i),
+                .format = native_format,
+            },
+            .offset = offset,
+        };
+
+        end.* += 1;
+    }
+
+    for (fixed_attributes, attributes.len..) |attribute, i| {
+        layout.config.setFlag(@enumFromInt(i), .fixed);
+        layout.permutation.setAttribute(@enumFromInt(i), @enumFromInt(@intFromEnum(attribute.location)));
+    }
+
+    if (fixed_attributes.len > 0) @panic("TODO: fixed attributes");
+
+    for (bindings, 0..) |binding, binding_index| {
+        layout.buffer_config[binding_index] = .{
+            .low = .{},
+            .high = .{
+                .bytes_per_vertex = binding.stride,
+                .num_components = 0, // Will be set later
+            },
+        };
+    }
+
+    for (&binding_attributes, &binding_attributes_end, 0..) |*binding_attributes_array, attributes_end, binding_i| {
+        const binding = &layout.buffer_config[binding_i];
+        const sorted_attributes = binding_attributes_array[0..attributes_end];
+
+        if (sorted_attributes.len == 0) {
+            binding.high.num_components = 0;
+            break;
+        }
+
+        std.sort.insertion(BindingAttributeInfo, sorted_attributes, {}, BindingAttributeInfo.lessThan);
+
+        const first_format = sorted_attributes[0].index_format.format;
+
+        try validation.assert(
+            sorted_attributes[0].offset == 0,
+            validation.vertex_input_layout.non_zero_initial_offset,
+            .{binding_i},
+        );
+
+        var current_alignment: usize = first_format.type.byteSize();
+        var current_offset: usize = first_format.type.byteSize() * (@as(usize, @intFromEnum(first_format.size)) + 1);
+        var current_attribute: u4 = 1;
+
+        binding.setComponent(.@"0", @enumFromInt(sorted_attributes[0].index_format.index));
+
+        for (sorted_attributes[1..], sorted_attributes[0 .. sorted_attributes.len - 1]) |attribute, last_attribute| {
+            const last_attribute_i = last_attribute.index_format.index;
+
+            const attribute_i = attribute.index_format.index;
+            const format = attribute.index_format.format;
+            const format_type_size = format.type.byteSize();
+            const format_size = format_type_size * (@as(usize, @intFromEnum(format.size)) + 1);
+            const assigned_offset = attribute.offset;
+            const next_natural_offset = std.mem.alignForward(usize, current_offset, format_type_size);
+
+            try validation.assert(
+                std.mem.isAligned(assigned_offset, format_type_size),
+                validation.vertex_input_layout.unaligned_offset,
+                .{ attribute_i, layout.permutation.getAttribute(@enumFromInt(attribute_i)), binding_i, format_type_size, assigned_offset },
+            );
+
+            try validation.assert(
+                assigned_offset >= next_natural_offset,
+                validation.vertex_input_layout.not_sequential,
+                .{
+                    last_attribute_i,
+                    layout.permutation.getAttribute(@enumFromInt(last_attribute_i)),
+                    attribute_i,
+                    layout.permutation.getAttribute(@enumFromInt(attribute_i)),
+                    binding_i,
+                    last_attribute.offset,
+                    last_attribute.offset + last_attribute.index_format.format.byteSize(),
+                    assigned_offset,
+                    assigned_offset + format_size,
+                },
+            );
+
+            const padding = assigned_offset - next_natural_offset;
+
+            if (padding > 0) {
+                @branchHint(.unlikely);
+
+                try validation.assert(
+                    std.mem.isAligned(padding, @sizeOf(f32)),
+                    validation.vertex_input_layout.attribute_gap,
+                    .{ attribute_i, layout.permutation.getAttribute(@enumFromInt(attribute_i)), binding_i, current_offset, assigned_offset, padding },
+                );
+
+                var remaining_padding = padding;
+                for (gpu_array_paddings) |pad_attrib| {
+                    appendPadAttributes(binding, &current_attribute, &remaining_padding, pad_attrib);
+                }
+            }
+
+            binding.setComponent(@enumFromInt(current_attribute), @enumFromInt(attribute.index_format.index));
+            current_attribute += 1;
+            current_offset = assigned_offset + format_size;
+            current_alignment = @max(current_alignment, format_type_size);
+        }
+
+        try validation.assert(
+            std.mem.isAligned(binding.high.bytes_per_vertex, current_alignment),
+            validation.vertex_input_layout.unaligned_stride,
+            .{ binding_i, current_alignment, binding.high.bytes_per_vertex },
+        );
+
+        const end_attribute_offset = std.mem.alignForward(usize, current_offset, current_alignment);
+
+        try validation.assert(
+            binding.high.bytes_per_vertex >= current_offset,
+            validation.vertex_input_layout.small_stride,
+            .{ binding_i, current_offset, binding.high.bytes_per_vertex },
+        );
+
+        const end_padding = binding.high.bytes_per_vertex - end_attribute_offset;
+
+        try validation.assert(
+            std.mem.isAligned(end_padding, @sizeOf(f32)),
+            validation.vertex_input_layout.end_gap,
+            .{ binding_i, end_padding },
+        );
+
+        var remaining_end_padding = end_padding;
+        for (gpu_array_paddings) |padding| {
+            appendPadAttributes(binding, &current_attribute, &remaining_end_padding, padding);
+        }
+
+        binding.high.num_components = current_attribute;
+    }
+
+    return layout;
+}
+
+fn appendPadAttributes(current_binding: *GpuAttributeBufferConfig, current_binding_attribute: *u4, remaining_padding: *usize, padding: GpuArrayComponent) void {
+    std.debug.assert(@intFromEnum(padding) >= @intFromEnum(GpuArrayComponent.padding_4));
+
+    const components: usize = (@as(usize, @intFromEnum(padding)) - @as(usize, @intFromEnum(GpuArrayComponent.padding_4))) + 1;
+    while (remaining_padding.* >= @sizeOf(f32) * components) : (remaining_padding.* -= @sizeOf(f32) * components) {
+        current_binding.setComponent(@enumFromInt(current_binding_attribute.*), padding);
+        current_binding_attribute.* += 1;
+    }
+}
+
+pub fn toHandle(layout: *VertexInputLayout) Handle {
+    return @enumFromInt(@intFromPtr(layout));
+}
+
+pub fn fromHandleMutable(handle: Handle) *VertexInputLayout {
+    return @as(*VertexInputLayout, @ptrFromInt(@intFromEnum(handle)));
+}
+
+test "smoke test" {
+    const layout: VertexInputLayout = try .compile(&.{
+        .{
+            .stride = 12,
+        },
+    }, &.{ .{
+        .offset = 0,
+        .binding = .@"0",
+        .location = .v0,
+        .format = .r32_sfloat,
+    }, .{
+        .offset = @sizeOf(f32) * 2,
+        .binding = .@"0",
+        .location = .v1,
+        .format = .r8_uscaled,
+    }, .{
+        .offset = @sizeOf(f32) * 2 + @sizeOf(u16),
+        .binding = .@"0",
+        .location = .v2,
+        .format = .r16_sscaled,
+    } }, &.{});
+
+    const u8x1: AttributeFormat = .u8x1;
+    const i16x1: AttributeFormat = .i16x1;
+    const f32x1: AttributeFormat = .f32x1;
+
+    try expectEqual(.array, layout.config.getFlag(.@"0"));
+    try expectEqual(f32x1, layout.config.getAttribute(.@"0"));
+    try expectEqual(u8x1, layout.config.getAttribute(.@"1"));
+    try expectEqual(i16x1, layout.config.getAttribute(.@"2"));
+    try expectEqual(.attribute_0, layout.buffer_config[0].getComponent(.@"0"));
+    try expectEqual(.padding_4, layout.buffer_config[0].getComponent(.@"1"));
+    try expectEqual(.attribute_1, layout.buffer_config[0].getComponent(.@"2"));
+    try expectEqual(.attribute_2, layout.buffer_config[0].getComponent(.@"3"));
+    try expectEqual(4, layout.buffer_config[0].high.num_components);
+    try expectEqual(12, layout.buffer_config[0].high.bytes_per_vertex);
+}
+
+test "gaps are filled with padding" {
+    const layout: VertexInputLayout = try .compile(&.{
+        .{
+            .stride = 44,
+        },
+    }, &.{
+        .{
+            .offset = 0,
+            .binding = .@"0",
+            .location = .v0,
+            .format = .r32_sfloat,
+        },
+        .{
+            .offset = 32,
+            .binding = .@"0",
+            .location = .v1,
+            .format = .r32_sfloat,
+        },
+        .{
+            .offset = 40,
+            .binding = .@"0",
+            .location = .v2,
+            .format = .r32_sfloat,
+        },
+    }, &.{});
+
+    const f32x1: AttributeFormat = .f32x1;
+    try expectEqual(.array, layout.config.getFlag(.@"0"));
+    try expectEqual(.array, layout.config.getFlag(.@"1"));
+    try expectEqual(f32x1, layout.config.getAttribute(.@"0"));
+    try expectEqual(f32x1, layout.config.getAttribute(.@"1"));
+    try expectEqual(.attribute_0, layout.buffer_config[0].getComponent(.@"0"));
+    try expectEqual(.padding_16, layout.buffer_config[0].getComponent(.@"1"));
+    try expectEqual(.padding_12, layout.buffer_config[0].getComponent(.@"2"));
+    try expectEqual(.attribute_1, layout.buffer_config[0].getComponent(.@"3"));
+    try expectEqual(.padding_4, layout.buffer_config[0].getComponent(.@"4"));
+    try expectEqual(.attribute_2, layout.buffer_config[0].getComponent(.@"5"));
+    try expectEqual(6, layout.buffer_config[0].high.num_components);
+    try expectEqual(44, layout.buffer_config[0].high.bytes_per_vertex);
+}
+
+test "gap at the end is filled with padding" {
+    const layout: VertexInputLayout = try .compile(&.{
+        .{
+            .stride = 36,
+        },
+    }, &.{
+        .{
+            .offset = 0,
+            .binding = .@"0",
+            .location = .v0,
+            .format = .r32_sfloat,
+        },
+    }, &.{});
+
+    const f32x1: AttributeFormat = .f32x1;
+    try expectEqual(.array, layout.config.getFlag(.@"0"));
+    try expectEqual(f32x1, layout.config.getAttribute(.@"0"));
+    try expectEqual(.attribute_0, layout.buffer_config[0].getComponent(.@"0"));
+    try expectEqual(.padding_16, layout.buffer_config[0].getComponent(.@"1"));
+    try expectEqual(.padding_16, layout.buffer_config[0].getComponent(.@"2"));
+    try expectEqual(3, layout.buffer_config[0].high.num_components);
+    try expectEqual(36, layout.buffer_config[0].high.bytes_per_vertex);
+}
+
+const testing = std.testing;
+const expectEqual = testing.expectEqual;
+
+const VertexInputLayout = @This();
+
+const validation = backend.validation;
+
+const std = @import("std");
+const zitrus = @import("zitrus");
+const backend = @import("backend.zig");
+
+const mango = zitrus.mango;
+const hardware = zitrus.hardware;
+const pica = hardware.pica;
+
+const AttributeFormat = pica.Graphics.PrimitiveEngine.Attribute.Format;
diff --git a/src/platform/3ds/mango/mango/backend.zig b/src/platform/3ds/mango/mango/backend.zig
new file mode 100644
index 0000000..1ae094e
--- /dev/null
+++ b/src/platform/3ds/mango/mango/backend.zig
@@ -0,0 +1,230 @@
+/// All index / vertex buffers provided to the gpu are relative to this address
+pub const global_attribute_buffer_base: zitrus.hardware.PhysicalAddress = .fromAddress(zitrus.memory.vram_begin);
+
+/// At most, this amount of commands can be buffered simultaneously by the driver.
+/// OutOfMemory will be returned if the driver can not queue more.
+pub const max_buffered_queue_items = 12;
+
+/// It is asserted that at most, this amount of swapchain image layers are supported.
+pub const max_swapchain_image_layers = 2;
+
+/// It is asserted that at most, this amount of swapchain images are supported.
+pub const max_swapchain_images = 3;
+
+pub const max_present_queue_items = max_swapchain_images * max_swapchain_image_layers;
+
+/// It is asserted that draw call emissions won't take more than this amount of words.
+pub const max_drawcall_emission_cost = 32;
+
+/// We want to reserve some space so we can finalize/chain/flush
+pub const static_emission_cost = 32;
+
+pub const AetherCtru = @import("backend/AetherCtru.zig");
+
+pub const log = std.log.scoped(.mango);
+pub const validation = @import("validation.zig");
+pub const debug = @import("debug.zig");
+
+pub const Device = @import("Device.zig");
+pub const Queue = @import("Queue.zig");
+pub const Semaphore = @import("Semaphore.zig");
+pub const DeviceMemory = @import("DeviceMemory.zig");
+pub const Buffer = @import("Buffer.zig");
+pub const Image = @import("Image.zig");
+pub const ImageView = @import("ImageView.zig");
+pub const Shader = @import("Shader.zig");
+pub const QueryPool = @import("QueryPool.zig");
+pub const CommandPool = @import("CommandPool.zig");
+pub const CommandBuffer = @import("CommandBuffer.zig");
+pub const Sampler = @import("Sampler.zig");
+pub const Surface = @import("Surface.zig");
+pub const Swapchain = @import("Swapchain.zig");
+pub const LightLookupTable = @import("LightLookupTable.zig");
+
+pub const GraphicsState = @import("GraphicsState.zig");
+pub const RenderingState = @import("RenderingState.zig");
+
+pub const TextureCombinerState = @import("TextureCombinerState.zig");
+pub const VertexInputLayout = @import("VertexInputLayout.zig");
+
+/// Calculates the dimension of a specific mip level.
+pub inline fn imageLevelDimension(size: usize, base_mip_level: usize) usize {
+    return @max(size >> @intCast(base_mip_level), 8);
+}
+
+/// Calculates the offset of a specific mip level.
+pub inline fn imageLevelOffset(size: usize, level_size: usize) usize {
+    return @divExact((size - level_size) << 2, 3);
+}
+
+/// Calculates the image size including all mip levels of the chain.
+pub fn imageLayerSize(size: usize, mip_levels: usize) usize {
+    return @divExact(((size << 2) - imageLevelDimension(size, (mip_levels - 1) << 1)), 3);
+}
+
+pub fn SingleProducerSingleConsumerBoundedQueue(comptime T: type, comptime capacity: u16) type {
+    return struct {
+        pub const Header = packed struct(u32) {
+            index: u16,
+            len: u16,
+        };
+
+        pub const init_empty: SpScQueue = .{
+            .header = .init(.{
+                .index = 0,
+                .len = 0,
+            }),
+            .items = undefined,
+        };
+
+        header: std.atomic.Value(Header),
+        items: [capacity]T,
+
+        pub fn pushFront(queue: *SpScQueue, item: T) !void {
+            const hdr = queue.header.load(.monotonic);
+
+            if (hdr.len == capacity) {
+                // NOTE: We're returning OutOfMemory even if we're not allocating memory.
+                return error.OutOfMemory;
+            }
+
+            return queue.pushFrontAssumeCapacity(item);
+        }
+
+        pub fn pushFrontAssumeCapacity(queue: *SpScQueue, item: T) void {
+            const hdr = queue.header.load(.monotonic);
+            std.debug.assert(hdr.len < capacity);
+
+            const next_index: u16 = @intCast((hdr.index + hdr.len) % capacity);
+            queue.items[next_index] = item;
+
+            // XXX: Workaround for https://github.com/ziglang/zig/issues/25715
+            const as_u16s: *[2]u16 = @ptrCast(&queue.header.raw);
+            _ = @atomicRmw(u16, &as_u16s[@divExact(@bitOffsetOf(Header, "len"), 16)], .Add, 1, .release);
+        }
+
+        pub fn peekBack(queue: *SpScQueue) ?T {
+            const initial_hdr = queue.header.load(.acquire);
+
+            if (initial_hdr.len == 0) {
+                return null;
+            }
+
+            return queue.items[initial_hdr.index];
+        }
+
+        pub fn popBack(queue: *SpScQueue) ?T {
+            const initial_hdr = queue.header.load(.acquire);
+
+            if (initial_hdr.len == 0) {
+                return null;
+            }
+
+            defer {
+                var hdr = initial_hdr;
+                while (queue.header.cmpxchgWeak(hdr, .{
+                    .index = if (hdr.index == (capacity - 1)) 0 else hdr.index + 1,
+                    .len = hdr.len - 1,
+                }, .monotonic, .monotonic) != null) {
+                    hdr = queue.header.load(.monotonic);
+                }
+            }
+
+            return queue.items[initial_hdr.index];
+        }
+
+        pub fn clear(queue: *SpScQueue) void {
+            queue.header.store(.{
+                .index = 0,
+                .len = 0,
+            }, .monotonic);
+        }
+
+        const SpScQueue = @This();
+    };
+}
+
+const testing = std.testing;
+const TestingSpScBoundedQueue = SingleProducerSingleConsumerBoundedQueue(u8, 4);
+
+test "SingleProducerSingleConsumerBoundedQueue pushFront -> popBack correct state" {
+    var bq: TestingSpScBoundedQueue = .init_empty;
+
+    bq.pushFrontAssumeCapacity(7);
+    try testing.expect(0 == bq.header.raw.index);
+    try testing.expect(1 == bq.header.raw.len);
+
+    const should_be_7 = bq.popBack();
+    try testing.expect(7 == should_be_7);
+
+    try testing.expect(1 == bq.header.raw.index);
+    try testing.expect(0 == bq.header.raw.len);
+}
+
+test "SingleProducerSingleConsumerBoundedQueue is a FIFO" {
+    var bq: TestingSpScBoundedQueue = .init_empty;
+
+    bq.pushFrontAssumeCapacity(7);
+    bq.pushFrontAssumeCapacity(8);
+    bq.pushFrontAssumeCapacity(2);
+    bq.pushFrontAssumeCapacity(1);
+
+    try testing.expect(0 == bq.header.raw.index);
+    try testing.expect(4 == bq.header.raw.len);
+
+    const should_be_7 = bq.popBack();
+    try testing.expect(7 == should_be_7);
+
+    const should_be_8 = bq.popBack();
+    try testing.expect(8 == should_be_8);
+
+    const should_be_2 = bq.popBack();
+    try testing.expect(2 == should_be_2);
+
+    const should_be_1 = bq.popBack();
+    try testing.expect(1 == should_be_1);
+
+    try testing.expect(0 == bq.header.raw.index);
+    try testing.expect(0 == bq.header.raw.len);
+}
+
+test imageLevelDimension {
+    try testing.expect(imageLevelDimension(256, 2) == 64);
+}
+
+test imageLevelOffset {
+    try testing.expect(imageLevelOffset(1024 * 1024, 512 * 512) == 1024 * 1024);
+    try testing.expect(imageLevelOffset(1024 * 1024, 128 * 128) == 1024 * 1024 + 512 * 512 + 256 * 256);
+}
+
+test imageLayerSize {
+    try testing.expect(imageLayerSize(1024 * 1024, 1) == 1024 * 1024);
+    try testing.expect(imageLayerSize(1024 * 1024, 2) == 1024 * 1024 + 512 * 512);
+    try testing.expect(imageLayerSize(1024 * 1024, 3) == 1024 * 1024 + 512 * 512 + 256 * 256);
+    try testing.expect(imageLayerSize(1024 * 1024, 4) == 1024 * 1024 + 512 * 512 + 256 * 256 + 128 * 128);
+    try testing.expect(imageLayerSize(1024 * 1024, 5) == 1024 * 1024 + 512 * 512 + 256 * 256 + 128 * 128 + 64 * 64);
+    try testing.expect(imageLayerSize(1024 * 1024, 6) == 1024 * 1024 + 512 * 512 + 256 * 256 + 128 * 128 + 64 * 64 + 32 * 32);
+    try testing.expect(imageLayerSize(1024 * 1024, 7) == 1024 * 1024 + 512 * 512 + 256 * 256 + 128 * 128 + 64 * 64 + 32 * 32 + 16 * 16);
+    try testing.expect(imageLayerSize(1024 * 1024, 8) == 1024 * 1024 + 512 * 512 + 256 * 256 + 128 * 128 + 64 * 64 + 32 * 32 + 16 * 16 + 8 * 8);
+}
+
+comptime {
+    _ = Device;
+    _ = Queue;
+    _ = Semaphore;
+    _ = DeviceMemory;
+    _ = Buffer;
+    _ = Image;
+    _ = ImageView;
+    _ = CommandPool;
+    _ = CommandBuffer;
+    _ = Shader;
+    _ = Sampler;
+    _ = Surface;
+    _ = Swapchain;
+    _ = VertexInputLayout;
+    _ = validation;
+}
+
+const std = @import("std");
+const zitrus = @import("zitrus");
diff --git a/src/platform/3ds/mango/mango/backend/AetherCtru.zig b/src/platform/3ds/mango/mango/backend/AetherCtru.zig
new file mode 100644
index 0000000..8c75984
--- /dev/null
+++ b/src/platform/3ds/mango/mango/backend/AetherCtru.zig
@@ -0,0 +1,486 @@
+pub const CreateInfo = struct {
+    linear_gpa: std.mem.Allocator,
+};
+
+const vtable: Device.VTable = .{
+    .destroy = destroy,
+
+    .reacquire = reacquire,
+    .release = release,
+
+    .waitIdleQueue = waitIdleQueue,
+    .wakeIdleQueue = wakeIdleQueue,
+
+    .getShaderCode = getShaderCode,
+    .destroyShaderCode = destroyShaderCode,
+
+    .allocateMemory = allocateMemory,
+    .freeMemory = freeMemory,
+    .mapMemory = mapMemory,
+    .unmapMemory = unmapMemory,
+    .flushMappedMemoryRanges = flushMappedMemoryRanges,
+    .invalidateMappedMemoryRanges = invalidateMappedMemoryRanges,
+
+    .createSwapchain = createSwapchain,
+    .destroySwapchain = destroySwapchain,
+    .getSwapchainImages = getSwapchainImages,
+    .acquireNextImage = acquireNextImage,
+
+    .waitSemaphores = waitSemaphores,
+    .signalSemaphore = signalSemaphore,
+
+    .virtualToPhysical = virtualToPhysical,
+};
+
+const CodeCache = struct {
+    const Key = backend.Shader.Code.Key;
+    const Context = struct {
+        pub fn eql(_: Context, a: Key, b: Key, _: usize) bool {
+            return a.hash == b.hash and
+                std.mem.eql(pica.shader.encoding.Instruction, a.instructions, b.instructions) and
+                std.mem.eql(pica.shader.encoding.OperandDescriptor, a.descriptors, b.descriptors);
+        }
+
+        pub fn hash(_: Context, key: Key) u32 {
+            return key.hash;
+        }
+    };
+
+    uid: u32 = 0,
+    entries: std.ArrayHashMapUnmanaged(Key, *backend.Shader.Code, Context, false) = .empty,
+
+    fn deinit(cache: *CodeCache, gpa: std.mem.Allocator) void {
+        var it = cache.entries.iterator();
+        while (it.next()) |entry| {
+            const code = entry.value_ptr.*;
+            gpa.free(code.instructions);
+            gpa.free(code.descriptors);
+            gpa.destroy(code);
+        }
+        cache.entries.deinit(gpa);
+        cache.* = .{};
+    }
+
+    fn getOrAdd(cache: *CodeCache, gpa: std.mem.Allocator, key: Key) !*backend.Shader.Code {
+        const entry = try cache.entries.getOrPut(gpa, key);
+        errdefer cache.entries.swapRemoveAt(entry.index);
+
+        if (entry.found_existing) {
+            const code = entry.value_ptr.*;
+            std.debug.assert(code.ref.fetchAdd(1, .monotonic) > 0);
+            return code;
+        }
+
+        const new_code = try gpa.create(backend.Shader.Code);
+        errdefer gpa.destroy(new_code);
+
+        const instructions = try gpa.dupe(pica.shader.encoding.Instruction, key.instructions);
+        errdefer gpa.free(instructions);
+
+        const descriptors = try gpa.dupe(pica.shader.encoding.OperandDescriptor, key.descriptors);
+        errdefer gpa.free(descriptors);
+
+        new_code.* = .init(cache.uid, key.hash, instructions, descriptors);
+        cache.uid +%= 1;
+        entry.value_ptr.* = new_code;
+        return new_code;
+    }
+
+    fn destroy(cache: *CodeCache, gpa: std.mem.Allocator, code: *backend.Shader.Code) void {
+        std.debug.assert(code.ref.load(.monotonic) == 0);
+        const key: Key = .initCode(code);
+        std.debug.assert(cache.entries.swapRemove(key));
+        gpa.free(code.instructions);
+        gpa.free(code.descriptors);
+        gpa.destroy(code);
+    }
+};
+
+device: Device,
+code_cache: CodeCache = .{},
+
+pub fn create(create_info: CreateInfo, gpa: std.mem.Allocator) !*AetherCtru {
+    const actru = try gpa.create(AetherCtru);
+    errdefer gpa.destroy(actru);
+
+    var fill_queue: Queue = try .init(gpa, .fill, &actru.device, backend.max_buffered_queue_items, @sizeOf(Queue.FillItem), .of(Queue.FillItem));
+    errdefer fill_queue.deinit(gpa);
+
+    var transfer_queue: Queue = try .init(gpa, .transfer, &actru.device, backend.max_buffered_queue_items, @sizeOf(Queue.TransferItem), .of(Queue.TransferItem));
+    errdefer transfer_queue.deinit(gpa);
+
+    var submit_queue: Queue = try .init(gpa, .submit, &actru.device, backend.max_buffered_queue_items, @sizeOf(Queue.SubmitItem), .of(Queue.SubmitItem));
+    errdefer submit_queue.deinit(gpa);
+
+    var present_queue: Queue = try .init(gpa, .present, &actru.device, backend.max_present_queue_items, @sizeOf(Queue.PresentationItem), .of(Queue.PresentationItem));
+    errdefer present_queue.deinit(gpa);
+
+    actru.* = .{
+        .device = .{
+            .gpa = gpa,
+            .linear_gpa = create_info.linear_gpa,
+            .vtable = vtable,
+            .queues = .init(.{
+                .fill = fill_queue,
+                .transfer = transfer_queue,
+                .submit = submit_queue,
+                .present = present_queue,
+            }),
+            .queue_statuses = .initDefault(.init(.idle), .{}),
+        },
+        .code_cache = .{},
+    };
+
+    return actru;
+}
+
+fn destroy(dev: *Device) void {
+    const gpa = dev.gpa;
+    const actru: *AetherCtru = @alignCast(@fieldParentPtr("device", dev));
+
+    _ = drainAll(actru);
+    actru.code_cache.deinit(gpa);
+    for (std.enums.values(Queue.Type)) |typ| actru.device.queues.getPtr(typ).deinit(gpa);
+    gpa.destroy(actru);
+}
+
+fn reacquire(_: *Device) mango.ReacquireDeviceError!void {}
+
+fn release(dev: *Device) mango.ReleaseDeviceError!Device.ScreenCapture {
+    dev.waitIdle();
+    return .{};
+}
+
+fn waitIdleQueue(dev: *Device, queue: Queue.Type) void {
+    const actru: *AetherCtru = @alignCast(@fieldParentPtr("device", dev));
+    _ = drainQueue(actru, queue);
+}
+
+fn wakeIdleQueue(dev: *Device, _: Queue.Type) void {
+    const actru: *AetherCtru = @alignCast(@fieldParentPtr("device", dev));
+    _ = drainAll(actru);
+}
+
+fn getShaderCode(dev: *Device, key: backend.Shader.Code.Key) mango.ObjectCreationError!*backend.Shader.Code {
+    const actru: *AetherCtru = @alignCast(@fieldParentPtr("device", dev));
+    return actru.code_cache.getOrAdd(dev.gpa, key) catch error.OutOfMemory;
+}
+
+fn destroyShaderCode(dev: *Device, code: *backend.Shader.Code) void {
+    const actru: *AetherCtru = @alignCast(@fieldParentPtr("device", dev));
+    actru.code_cache.destroy(dev.gpa, code);
+}
+
+fn allocateMemory(dev: *Device, allocate_info: mango.MemoryAllocateInfo, _: std.mem.Allocator) mango.ObjectCreationError!mango.DeviceMemory {
+    const size = std.mem.alignForward(usize, @intFromEnum(allocate_info.allocation_size), page_size);
+    const ptr: [*]align(page_size) u8 = switch (allocate_info.memory_type) {
+        .fcram_cached => fcram: {
+            const mem = dev.linear_gpa.alignedAlloc(u8, .fromByteUnits(page_size), size) catch return error.OutOfMemory;
+            break :fcram mem.ptr;
+        },
+        .vram_a, .vram_b => |bank| vram: {
+            const pos: c.vramAllocPos = @intCast(switch (bank) {
+                .vram_a => c.VRAM_ALLOC_A,
+                .vram_b => c.VRAM_ALLOC_B,
+                else => unreachable,
+            });
+            const mem = c.vramMemAlignAt(size, page_size, pos) orelse return error.OutOfMemory;
+            break :vram @ptrCast(@alignCast(mem));
+        },
+    };
+
+    const phys = virtualToPhysical(dev, ptr);
+    const heap: backend.DeviceMemory.MemoryHeap = switch (allocate_info.memory_type) {
+        .fcram_cached => .fcram,
+        .vram_a => .vram_a,
+        .vram_b => .vram_b,
+    };
+
+    return (backend.DeviceMemory{
+        .data = .init(ptr, phys, size, heap),
+    }).toHandle();
+}
+
+fn freeMemory(dev: *Device, memory: mango.DeviceMemory, _: std.mem.Allocator) void {
+    const b_memory: backend.DeviceMemory = .fromHandle(memory);
+    if (!b_memory.data.valid) return;
+
+    switch (b_memory.data.heap) {
+        .fcram => {
+            const ptr: [*]align(page_size) u8 = @alignCast(b_memory.virtualAddress());
+            dev.linear_gpa.free(ptr[0..b_memory.size()]);
+        },
+        .vram_a, .vram_b => c.vramFree(b_memory.virtualAddress()),
+    }
+}
+
+fn mapMemory(_: *Device, memory: mango.DeviceMemory, offset: mango.DeviceSize, size: mango.DeviceSize) mango.MapMemoryError![]u8 {
+    const b_memory: backend.DeviceMemory = .fromHandle(memory);
+    const b_offset = @intFromEnum(offset);
+    std.debug.assert(b_offset <= b_memory.size());
+
+    const len = switch (size) {
+        .whole => b_memory.size() - b_offset,
+        _ => |sz| @intFromEnum(sz),
+    };
+    std.debug.assert(b_offset + len <= b_memory.size());
+
+    return (b_memory.virtualAddress() + b_offset)[0..len];
+}
+
+fn unmapMemory(_: *Device, _: mango.DeviceMemory) void {}
+
+fn flushMappedMemoryRanges(_: *Device, ranges: []const mango.MappedMemoryRange) mango.FlushMemoryError!void {
+    for (ranges) |range| {
+        const bytes = mappedRange(range);
+        if (bytes.len == 0) continue;
+        if (c.GSPGPU_FlushDataCache(bytes.ptr, @intCast(bytes.len)) != 0) return error.Unexpected;
+    }
+}
+
+fn invalidateMappedMemoryRanges(_: *Device, ranges: []const mango.MappedMemoryRange) mango.InvalidateMemoryError!void {
+    for (ranges) |range| {
+        const bytes = mappedRange(range);
+        if (bytes.len == 0) continue;
+        if (c.GSPGPU_InvalidateDataCache(bytes.ptr, @intCast(bytes.len)) != 0) return error.Unexpected;
+    }
+}
+
+fn mappedRange(range: mango.MappedMemoryRange) []u8 {
+    const b_memory: backend.DeviceMemory = .fromHandle(range.memory);
+    const offset = @intFromEnum(range.offset);
+    const len = switch (range.size) {
+        .whole => b_memory.size() - offset,
+        _ => |sz| @intFromEnum(sz),
+    };
+    std.debug.assert(offset + len <= b_memory.size());
+    return (b_memory.virtualAddress() + offset)[0..len];
+}
+
+fn createSwapchain(_: *Device, _: mango.SwapchainCreateInfo, _: std.mem.Allocator) mango.ObjectCreationError!mango.Swapchain {
+    return error.Unexpected;
+}
+
+fn destroySwapchain(_: *Device, _: mango.Swapchain, _: std.mem.Allocator) void {}
+
+fn getSwapchainImages(_: *Device, _: mango.Swapchain, _: []mango.Image) mango.GetSwapchainImagesError!u8 {
+    return error.Unexpected;
+}
+
+fn acquireNextImage(_: *Device, _: mango.Swapchain, _: u64) mango.AcquireNextImageError!u8 {
+    return error.Unexpected;
+}
+
+fn waitSemaphores(dev: *Device, wait_info: mango.SemaphoreWaitInfo, _: u64) mango.WaitSemaphoreError!void {
+    const actru: *AetherCtru = @alignCast(@fieldParentPtr("device", dev));
+    const semaphores = wait_info.semaphores[0..wait_info.semaphore_count];
+    const values = wait_info.values[0..wait_info.semaphore_count];
+
+    while (true) {
+        var satisfied = true;
+        for (semaphores, values) |semaphore, value| {
+            const b_semaphore: *backend.Semaphore = .fromHandleMutable(semaphore);
+            if (b_semaphore.counterValue() < value) {
+                satisfied = false;
+                break;
+            }
+        }
+        if (satisfied) return;
+
+        if (!drainAll(actru)) return error.Timeout;
+    }
+}
+
+fn signalSemaphore(_: *Device, signal_info: mango.SemaphoreSignalInfo) mango.SignalSemaphoreError!void {
+    const b_semaphore: *backend.Semaphore = .fromHandleMutable(signal_info.semaphore);
+    _ = b_semaphore.signal(signal_info.value);
+}
+
+fn virtualToPhysical(_: *Device, virtual: *const anyopaque) zitrus.hardware.PhysicalAddress {
+    return .fromAddress(c.osConvertVirtToPhys(virtual));
+}
+
+fn drainAll(actru: *AetherCtru) bool {
+    var progressed = false;
+    while (true) {
+        var pass_progress = false;
+        inline for (.{ Queue.Type.submit, .fill, .transfer, .present }) |typ| {
+            pass_progress = drainQueue(actru, typ) or pass_progress;
+        }
+        if (!pass_progress) break;
+        progressed = true;
+    }
+    return progressed;
+}
+
+fn drainQueue(actru: *AetherCtru, typ: Queue.Type) bool {
+    const dev = &actru.device;
+    const queue = dev.queues.getPtr(typ);
+    var progressed = false;
+
+    while (true) switch (queue.peekBack()) {
+        .empty => {
+            dev.queue_statuses.getPtr(typ).store(.idle, .monotonic);
+            return progressed;
+        },
+        .wait => {
+            dev.queue_statuses.getPtr(typ).store(.waiting, .monotonic);
+            return progressed;
+        },
+        .ready => {
+            dev.queue_statuses.getPtr(typ).store(.working, .monotonic);
+            const signal = switch (typ) {
+                .fill => fill: {
+                    const item, const sig = queue.popBackAssumeReady(Queue.FillItem);
+                    processFill(item) catch dev.queue_statuses.getPtr(typ).store(.lost, .monotonic);
+                    break :fill sig;
+                },
+                .transfer => transfer: {
+                    const item, const sig = queue.popBackAssumeReady(Queue.TransferItem);
+                    processTransfer(item) catch dev.queue_statuses.getPtr(typ).store(.lost, .monotonic);
+                    break :transfer sig;
+                },
+                .submit => submit: {
+                    const item, const sig = queue.popBackAssumeReady(Queue.SubmitItem);
+                    processSubmit(item) catch dev.queue_statuses.getPtr(typ).store(.lost, .monotonic);
+                    item.cmd_buffer.notifyCompleted();
+                    break :submit sig;
+                },
+                .present => present: {
+                    const popped = queue.popBackAssumeReady(Queue.PresentationItem);
+                    break :present popped[1];
+                },
+            };
+
+            if (signal.sema) |sema| _ = sema.signal(signal.value);
+            dev.queue_statuses.getPtr(typ).store(.work_completed, .monotonic);
+            progressed = true;
+        },
+    };
+}
+
+fn processSubmit(item: Queue.SubmitItem) !void {
+    var maybe_node = item.cmd_buffer.head;
+    while (maybe_node) |node| {
+        switch (node.kind) {
+            .graphics => {
+                const gfx: *CommandBuffer.operation.Graphics = @alignCast(@fieldParentPtr("node", node));
+                if (gfx.len > 0) {
+                    if (c.GSPGPU_FlushDataCache(gfx.head, gfx.len * @sizeOf(u32)) != 0) return error.Unexpected;
+                    if (c.GX_ProcessCommandList(@ptrCast(@constCast(gfx.head)), gfx.len * @sizeOf(u32), c.GX_CMDLIST_FLUSH) != 0) return error.Unexpected;
+                    c.gspWaitForEvent(c.GSPGPU_EVENT_P3D, false);
+                }
+            },
+            .timestamp, .begin_query, .end_query => {},
+        }
+        maybe_node = node.nextPtr();
+    }
+}
+
+fn processFill(item: Queue.FillItem) !void {
+    if (item.data.len == 0) return;
+    const value, const control = fillValueControl(item.value);
+    const start: *u32 = @ptrCast(@alignCast(item.data.ptr));
+    const end: *u32 = @ptrCast(@alignCast(item.data.ptr + item.data.len));
+    if (c.GX_MemoryFill(start, value, end, control, null, 0, null, 0) != 0) return error.Unexpected;
+    // c.gspWaitForEvent(c.GSPGPU_EVENT_PSC0, false);
+}
+
+fn fillValueControl(value: Queue.FillValue) struct { u32, u16 } {
+    return switch (value) {
+        .fill16 => |v| .{ v, c.GX_FILL_TRIGGER | c.GX_FILL_16BIT_DEPTH },
+        .fill24 => |v| .{ v, c.GX_FILL_TRIGGER | c.GX_FILL_24BIT_DEPTH },
+        .fill32 => |v| .{ v, c.GX_FILL_TRIGGER | c.GX_FILL_32BIT_DEPTH },
+    };
+}
+
+fn processTransfer(item: Queue.TransferItem) !void {
+    switch (item.flags.kind) {
+        .copy => {
+            const size = item.flags.extra.copy;
+            if (size == 0) return;
+            if (c.GX_TextureCopy(
+                @ptrCast(@constCast(item.src)),
+                gxBufferDim(item.input_gap_size[0], item.input_gap_size[1]),
+                @ptrCast(item.dst),
+                gxBufferDim(item.output_gap_size[0], item.output_gap_size[1]),
+                size,
+                0,
+            ) != 0) return error.Unexpected;
+        },
+        .linear_tiled, .tiled_linear, .tiled_tiled => {
+            const flags = transferFlags(item);
+            if (c.GX_DisplayTransfer(
+                @ptrCast(@constCast(item.src)),
+                gxBufferDim(item.input_gap_size[0], item.input_gap_size[1]),
+                @ptrCast(item.dst),
+                gxBufferDim(item.output_gap_size[0], item.output_gap_size[1]),
+                flags,
+            ) != 0) return error.Unexpected;
+        },
+    }
+    c.gspWaitForEvent(c.GSPGPU_EVENT_PPF, false);
+}
+
+fn gxBufferDim(width: u16, height: u16) u32 {
+    return (@as(u32, height) << 16) | @as(u32, width);
+}
+
+fn transferFlags(item: Queue.TransferItem) u32 {
+    const transfer = item.flags.extra.transfer;
+    const mode = switch (item.flags.kind) {
+        .copy => unreachable,
+        .linear_tiled => .{ false, true, false },
+        .tiled_linear => .{ false, false, false },
+        .tiled_tiled => .{ false, true, true },
+    };
+
+    const flip_vert, const out_tiled, const raw_copy = mode;
+    return (@as(u32, @intFromBool(flip_vert)) << 0) |
+        (@as(u32, @intFromBool(out_tiled)) << 1) |
+        (@as(u32, @intFromBool(raw_copy)) << 3) |
+        (@as(u32, @intCast(gxFormat(transfer.src_fmt))) << 8) |
+        (@as(u32, @intCast(gxFormat(transfer.dst_fmt))) << 12) |
+        (@as(u32, @intCast(gxScale(transfer.downscale))) << 24);
+}
+
+fn gxFormat(format: pica.ColorFormat) c_int {
+    return switch (format) {
+        .abgr8888 => c.GX_TRANSFER_FMT_RGBA8,
+        .bgr888 => c.GX_TRANSFER_FMT_RGB8,
+        .rgb565 => c.GX_TRANSFER_FMT_RGB565,
+        .rgba5551 => c.GX_TRANSFER_FMT_RGB5A1,
+        .rgba4444 => c.GX_TRANSFER_FMT_RGBA4,
+    };
+}
+
+fn gxScale(scale: pica.PictureFormatter.Flags.Downscale) c_int {
+    return switch (scale) {
+        .none => c.GX_TRANSFER_SCALE_NO,
+        .@"2x1" => c.GX_TRANSFER_SCALE_X,
+        .@"2x2" => c.GX_TRANSFER_SCALE_XY,
+    };
+}
+
+const page_size = 0x1000;
+
+const AetherCtru = @This();
+
+const std = @import("std");
+const zitrus = @import("zitrus");
+const mango = zitrus.mango;
+const pica = zitrus.hardware.pica;
+const backend = @import("../backend.zig");
+
+const Device = backend.Device;
+const Queue = backend.Queue;
+const CommandBuffer = backend.CommandBuffer;
+
+const c = @cImport({
+    @cDefine("wint_t", "unsigned int");
+    @cInclude("3ds/types.h");
+    @cInclude("3ds/gpu/gx.h");
+    @cInclude("3ds/os.h");
+    @cInclude("3ds/services/gspgpu.h");
+    @cInclude("3ds/allocator/vram.h");
+});
diff --git a/src/platform/3ds/mango/mango/debug.zig b/src/platform/3ds/mango/mango/debug.zig
new file mode 100644
index 0000000..9bdaf92
--- /dev/null
+++ b/src/platform/3ds/mango/mango/debug.zig
@@ -0,0 +1,9 @@
+const backend = @import("backend.zig");
+
+const log = validation.log;
+const validation = backend.validation;
+
+const Queue = backend.Queue;
+
+const zitrus = @import("zitrus");
+const mango = zitrus.mango;
diff --git a/src/platform/3ds/mango/mango/validation.zig b/src/platform/3ds/mango/mango/validation.zig
new file mode 100644
index 0000000..3d25381
--- /dev/null
+++ b/src/platform/3ds/mango/mango/validation.zig
@@ -0,0 +1,160 @@
+pub const Error = error{ValidationFailed};
+
+pub const enabled = switch (builtin.mode) {
+    .Debug, .ReleaseSafe => true,
+    .ReleaseSmall, .ReleaseFast => false,
+};
+
+pub const image = struct {
+    pub const must_be_correct =
+        \\[Image] incorrect image: {d}x{d} ({t})
+        \\| image dimensions must be multiples of 8, between 8 and 1024
+    ;
+
+    pub const sampled_must_be_correct =
+        \\[Image] incorrect sampled image: {d}x{d} ({t})
+        \\| sampled images must be optimally tiled and have powers of two dimensions
+    ;
+
+    pub const attachment_must_be_correct =
+        \\[Image] incorrect attachment image: {d}x{d} ({t})
+        \\| attachment images must be optimally tiled
+    ;
+};
+
+pub const image_view = struct {
+    pub const src_not_mutable_format =
+        \\[ImageView] non-matching format
+        \\| set the mutable_format flag in the source image to allow this
+    ;
+
+    pub const invalid_2d =
+        \\[ImageView] invalid 2d view
+        \\| 2d views must be backed strictly by 1 image layer
+    ;
+
+    pub const invalid_cube =
+        \\[ImageView] invalid cube view
+        \\| cube views must be backed strictly by 6 image layers
+    ;
+};
+
+pub const graphics_state = struct {
+    /// what must be set
+    pub const must_be_set =
+        \\[CommandBuffer] {[0]s} must be set
+        \\| dynamic state is mandatory
+    ;
+};
+
+pub const shader = struct {
+    /// code type
+    pub const unknown_code_type =
+        \\[Shader] Code Type {}
+        \\| unknown code type
+    ;
+
+    /// entrypoint name
+    pub const entry_not_found =
+        \\[Shader] Entrypoint {s}
+        \\| entrypoint has not been found in the provided shader blob
+    ;
+};
+
+pub const vertex_input_layout = struct {
+    /// attribute binding,
+    pub const non_zero_initial_offset =
+        \\[VertexInputLayout] Binding {d}
+        \\| attributes must begin at offset 0
+    ;
+
+    /// attribute index, attribute location, attribute binding,
+    /// alignment, offset
+    pub const unaligned_offset =
+        \\[VertexInputLayout] Attribute {d} ({t}) at binding {d}
+        \\| unsatisfied type alignment ({d} byte(s)) of offset {d}
+    ;
+
+    /// previous attribute index, previous attribute location, attribute index, attribute location, attribute binding,
+    /// last offset, last end, assigned offset, current end
+    pub const not_sequential =
+        \\[VertexInputLayout] Attributes {d} ({t}) and {d} ({t}) at binding {d}
+        \\| overlapping offsets: [{d}, {d}) and [{d}, {d})
+    ;
+
+    /// attribute index, attribute location, attribute binding,
+    /// current offset, next offset, unaligned padding bytes
+    pub const attribute_gap =
+        \\[VertexInputLayout] Attribute {d} ({t}) at binding {d}
+        \\| unsatisfied padding alignment (4 bytes) requirement within offsets {d} - {d} ({d} byte(s))
+    ;
+
+    /// attribute index, attribute location, attribute binding,
+    /// unaligned padding bytes
+    pub const end_gap =
+        \\[VertexInputLayout] Binding {d}
+        \\| unsatisfied padding alignment (4 bytes) requirement at the end ({d} bytes)
+    ;
+
+    /// attribute index, attribute location, attribute binding,
+    /// alignment, stride
+    pub const unaligned_stride =
+        \\[VertexInputLayout] Binding {d}
+        \\| unsatisfied stride alignment ({d} bytes) requirement with {d} bytes
+    ;
+
+    /// attribute index, attribute location, attribute binding,
+    /// computed stride, stride
+    pub const small_stride =
+        \\[VertexInputLayout] Binding {d}
+        \\| unsatisfied stride size ({d} bytes) requirement with {d} bytes
+    ;
+};
+
+/// When validation is disabled returns a ZST
+pub fn Data(comptime T: type) type {
+    return if (enabled) T else void;
+}
+
+/// Initialize validation data which may be a ZST
+pub fn init(comptime T: type, value: T) Data(T) {
+    return if (enabled) value else {};
+}
+
+/// Emits an `error.ValidationFailed` when enabled, asserts on `ReleaseSmall` and `ReleaseFast` builds.
+pub fn assert(condition: bool, comptime format: []const u8, args: anytype) Error!void {
+    if (!check(condition, format, args)) {
+        if (enabled) return error.ValidationFailed;
+
+        // Basically: enable validation layers if you want to debug or have skill issues.
+        // If you don't enable them you won't pay a penny for them.
+        unreachable;
+    }
+}
+
+/// Checks a condition, emmiting a log when enabled.
+pub fn check(condition: bool, comptime format: []const u8, args: anytype) bool {
+    if (enabled and !condition) {
+        log.err(
+            \\Validation Failed
+            \\
+        ++ format, args);
+        return false;
+    }
+
+    return condition;
+}
+
+pub const log = blk: {
+    const base = std.log.scoped(.mango);
+
+    break :blk if (builtin.is_test) struct {
+        pub const debug = base.debug;
+        pub const info = base.info;
+        pub const warn = base.warn;
+        pub const err = base.warn;
+    } else base;
+};
+
+const builtin = @import("builtin");
+const std = @import("std");
diff --git a/src/platform/3ds/mango/memory.zig b/src/platform/3ds/mango/memory.zig
new file mode 100644
index 0000000..0585048
--- /dev/null
+++ b/src/platform/3ds/mango/memory.zig
@@ -0,0 +1,46 @@
+//! Physical memory map of both ARM11 and ARM9 CPUs.
+//!
+//! If something is specific to one core, it belongs to `arm9` or `arm11`,
+//! e.g: ARM9 *can't* access `arm11.pica` and ARM11 *can't* access
+
+pub const VRamBank = enum(u1) { a, b };
+
+pub const arm11 = struct {
+    pub const lcd: *volatile hardware.lcd.Registers = @ptrFromInt(io_begin + 0x202000);
+    pub const pica: *volatile hardware.pica.Registers = @ptrFromInt(io_begin + 0x400000);
+};
+
+pub const arm9 = struct {
+    pub const itcm_begin: usize = 0x00000000;
+    pub const wram_begin: usize = 0x08000000;
+    pub const pxi_begin: usize = io_begin + 0x8000;
+};
+
+pub const vram_size: usize = 0x00600000;
+pub const vram_bank_size: usize = @divExact(vram_size, 2);
+pub const vram_begin: usize = 0x18000000;
+pub const vram_a_begin: usize = 0x18000000;
+pub const vram_b_begin: usize = 0x18000000 + vram_bank_size;
+
+pub const io_begin: usize = 0x10000000;
+pub const csnd_begin: usize = io_begin + 0x103000;
+pub const csnd: *volatile zitrus.hardware.csnd.Registers = @ptrFromInt(csnd_begin);
+pub const hid_begin: usize = io_begin + 0x146000;
+pub const hid: *volatile zitrus.hardware.hid.Registers = @ptrFromInt(hid_begin);
+pub const pxi_begin: usize = io_begin + 0x163000;
+pub const pxi: *volatile zitrus.hardware.pxi.Registers = @ptrFromInt(pxi_begin);
+pub const i2c_bus_1_begin: usize = io_begin + 0x144000;
+pub const i2c_bus_1: *volatile zitrus.hardware.i2c.Bus = @ptrFromInt(i2c_bus_1_begin);
+pub const i2c_bus_2_begin: usize = io_begin + 0x148000;
+pub const i2c_bus_2: *volatile zitrus.hardware.i2c.Bus = @ptrFromInt(i2c_bus_2_begin);
+pub const i2c_bus_0_begin: usize = io_begin + 0x161000;
+pub const i2c_bus_0: *volatile zitrus.hardware.i2c.Bus = @ptrFromInt(i2c_bus_0_begin);
+pub const dsp_begin: usize = 0x1FF00000;
+pub const axiwram_begin: usize = 0x1FF80000;
+
+pub const fcram_begin: usize = 0x20000000;
+pub const fcram_end_o3ds: usize = fcram_begin + 0x08000000;
+pub const fcram_end_n3ds: usize = fcram_end_o3ds + 0x08000000;
+
+const zitrus = @import("zitrus");
+const hardware = zitrus.hardware;
diff --git a/src/platform/3ds/mango/tools/psm_to_zpsh.zig b/src/platform/3ds/mango/tools/psm_to_zpsh.zig
new file mode 100644
index 0000000..ac0cd65
--- /dev/null
+++ b/src/platform/3ds/mango/tools/psm_to_zpsh.zig
@@ -0,0 +1,158 @@
+pub fn main(init: std.process.Init) !u8 {
+    const io = init.io;
+    const arena = init.arena.allocator();
+    const args = try init.minimal.args.toSlice(arena);
+
+    if (args.len != 3) {
+        var stderr = std.Io.File.stderr().writer(io, &.{});
+        try stderr.interface.writeAll("usage: psm_to_zpsh <input.psm> <output.psh>\n");
+        try stderr.interface.flush();
+        return 1;
+    }
+
+    const cwd = std.Io.Dir.cwd();
+    const input = cwd.openFile(io, args[1], .{ .mode = .read_only }) catch |err| {
+        var stderr = std.Io.File.stderr().writer(io, &.{});
+        try stderr.interface.print("could not open {s}: {t}\n", .{ args[1], err });
+        try stderr.interface.flush();
+        return 1;
+    };
+    defer input.close(io);
+
+    var input_reader = input.readerStreaming(io, &.{});
+    var source: std.ArrayList(u8) = .empty;
+    try input_reader.interface.appendRemaining(arena, &source, .unlimited);
+    const source_z = try source.toOwnedSliceSentinel(arena, 0);
+
+    var assembled = Assembler.Assembled.assemble(arena, source_z) catch |err| {
+        var stderr = std.Io.File.stderr().writer(io, &.{});
+        try stderr.interface.print("shader assembly failed: {t}\n", .{err});
+        try stderr.interface.flush();
+        return 1;
+    };
+    defer assembled.deinit(arena);
+
+    if (assembled.errors.len != 0) {
+        var stderr = std.Io.File.stderr().writer(io, &.{});
+        for (assembled.errors) |err| {
+            const token = assembled.tokenSlice(err.tok_i);
+            try stderr.interface.print("{s}: assembler error {t} near '{s}'\n", .{ args[1], err.tag, token });
+        }
+        try stderr.interface.flush();
+        return 1;
+    }
+
+    const output = cwd.createFile(io, args[2], .{ .truncate = true }) catch |err| {
+        var stderr = std.Io.File.stderr().writer(io, &.{});
+        try stderr.interface.print("could not create {s}: {t}\n", .{ args[2], err });
+        try stderr.interface.flush();
+        return 1;
+    };
+    defer output.close(io);
+
+    var out_buf: [4096]u8 = undefined;
+    var output_writer = output.writer(io, &out_buf);
+    try writeZpsh(arena, &output_writer.interface, &assembled);
+    try output_writer.interface.flush();
+    return 0;
+}
+
+fn writeZpsh(gpa: std.mem.Allocator, out: *std.Io.Writer, assembled: *const Assembler.Assembled) !void {
+    if (assembled.encoded.instructions.items.len == 0) return error.EmptyShader;
+    if (assembled.encoded.instructions.items.len > std.math.maxInt(u12)) return error.ShaderTooLarge;
+    if (assembled.entrypoints.count() > std.math.maxInt(u12)) return error.TooManyEntrypoints;
+
+    const encoded = &assembled.encoded;
+
+    var padded_strings_size: usize = 0;
+    var entry_it = assembled.entrypoints.iterator();
+    while (entry_it.next()) |entrypoint| {
+        padded_strings_size += entrypoint.key_ptr.*.len + 1;
+    }
+    padded_strings_size = std.mem.alignForward(usize, padded_strings_size, @sizeOf(u32));
+
+    var string_table: std.ArrayList(u8) = try .initCapacity(gpa, padded_strings_size);
+    defer string_table.deinit(gpa);
+
+    var entrypoint_offsets: std.ArrayList(u32) = try .initCapacity(gpa, assembled.entrypoints.count());
+    defer entrypoint_offsets.deinit(gpa);
+
+    var current_entrypoint_offset: u32 = 0;
+    entry_it.reset();
+    while (entry_it.next()) |entrypoint| {
+        const info = entrypoint.value_ptr.*;
+        string_table.appendSliceAssumeCapacity(entrypoint.key_ptr.*);
+        string_table.appendAssumeCapacity(0);
+        entrypoint_offsets.appendAssumeCapacity(current_entrypoint_offset);
+        current_entrypoint_offset += @intCast(@sizeOf(zpsh.EntrypointHeader) +
+            info.constants.int.count() * @sizeOf([4]i8) +
+            info.constants.float.count() * @sizeOf(pica.F7_16x4) +
+            info.outputs.count() * @sizeOf(pica.OutputMap));
+    }
+    string_table.appendNTimesAssumeCapacity(0, padded_strings_size - string_table.items.len);
+
+    var code_hasher: std.hash.XxHash32 = .init(67);
+    code_hasher.update(@ptrCast(encoded.instructions.items));
+    code_hasher.update(@ptrCast(encoded.constDescriptorSlice()));
+
+    try out.writeStruct(zpsh.Header{
+        .shader = .init(assembled.entrypoints.count(), encoded.instructions.items.len, encoded.allocated_descriptors),
+        .entry_string_table_size = @intCast(@divExact(padded_strings_size, @sizeOf(u32))),
+        .code_hash = code_hasher.final(),
+    }, .little);
+
+    try out.writeSliceEndian(u32, entrypoint_offsets.items, .little);
+    try out.writeSliceEndian(u32, @ptrCast(encoded.instructions.items), .little);
+    try out.writeSliceEndian(u32, @ptrCast(encoded.constDescriptorSlice()), .little);
+    try out.writeAll(string_table.items);
+
+    var current_string_offset: u32 = 0;
+    entry_it.reset();
+    while (entry_it.next()) |entrypoint| {
+        const info = entrypoint.value_ptr;
+        try out.writeStruct(zpsh.EntrypointHeader{
+            .name_string_offset = @intCast(current_string_offset),
+            .instruction_offset = info.offset,
+            .info = switch (info.info) {
+                .vertex => .vertex,
+                .geometry => |g| switch (g) {
+                    .point => |p| .{
+                        .type = .geometry_point,
+                        .geometry = .initPoint(p.inputs),
+                    },
+                    .variable => |v| .{
+                        .type = .geometry_variable,
+                        .geometry = .initVariable(v.full_vertices),
+                    },
+                    .fixed => |f| .{
+                        .type = .geometry_fixed,
+                        .geometry = .initFixed(f.vertices, f.uniform_start),
+                    },
+                },
+            },
+            .flags = .{},
+            .boolean_constant_mask = .fromSet(.{ .bits = info.constants.bool.bits }),
+            .integer_constant_mask = .fromSet(.{ .bits = info.constants.int.bits }),
+            .floating_constant_mask = .fromSet(.{ .bits = info.constants.float.bits }),
+            .output_mask = .fromSet(.{ .bits = info.outputs.bits }),
+        }, .little);
+
+        current_string_offset += @intCast(entrypoint.key_ptr.len + 1);
+
+        var int_it = info.constants.int.iterator();
+        while (int_it.next()) |entry| try out.writeAll(entry.value);
+
+        var float_it = info.constants.float.iterator();
+        while (float_it.next()) |entry| try out.writeStruct(entry.value.*, .little);
+
+        var output_it = info.outputs.iterator();
+        while (output_it.next()) |entry| try out.writeStruct(entry.value.*, .little);
+    }
+}
+
+const std = @import("std");
+const zitrus = @import("zitrus");
+const pica = zitrus.hardware.pica;
+const zpsh = zitrus.fmt.zpsh;
+const Assembler = pica.shader.as.Assembler;
+
diff --git a/src/platform/3ds/mango/zitrus.zig b/src/platform/3ds/mango/zitrus.zig
new file mode 100644
index 0000000..6b76107
--- /dev/null
+++ b/src/platform/3ds/mango/zitrus.zig
@@ -0,0 +1,5 @@
+pub const hardware = @import("hardware.zig");
+pub const memory = @import("memory.zig");
+pub const fmt = @import("fmt.zig");
+pub const mango = @import("mango.zig");
+
diff --git a/src/platform/3ds/mango/zitrus_tools.zig b/src/platform/3ds/mango/zitrus_tools.zig
new file mode 100644
index 0000000..d4ca39a
--- /dev/null
+++ b/src/platform/3ds/mango/zitrus_tools.zig
@@ -0,0 +1,2 @@
+pub const hardware = @import("hardware.zig");
+pub const fmt = @import("fmt.zig");
diff --git a/src/platform/3ds/paths.zig b/src/platform/3ds/paths.zig
new file mode 100644
index 0000000..f5bbc68
--- /dev/null
+++ b/src/platform/3ds/paths.zig
@@ -0,0 +1,22 @@
+const std = @import("std");
+const c = @import("../nintendo_c.zig").c;
+
+pub fn mountData() bool {
+    return c.archiveMountSdmc() == 0;
+}
+
+pub fn unmountData() void {
+    _ = c.archiveUnmount("sdmc");
+}
+
+pub fn mountResources() bool {
+    return c.romfsMountSelf("romfs") == 0;
+}
+
+pub fn unmountResources() void {
+    _ = c.romfsUnmount("romfs");
+}
+
+pub fn dataRoot(buffer: []u8, app_name: []const u8) error{NameTooLong}![]const u8 {
+    return std.fmt.bufPrint(buffer, "sdmc:/3ds/{s}", .{app_name}) catch error.NameTooLong;
+}
diff --git a/src/platform/3ds/services.zig b/src/platform/3ds/services.zig
new file mode 100644
index 0000000..0684dce
--- /dev/null
+++ b/src/platform/3ds/services.zig
@@ -0,0 +1,541 @@
+//! 3DS system services / entry shim.
+//!
+//! Exports a C-callable `main` that hands control to the user's Zig
+//! `main`. The allocator and baseline `std.Io` pieces of `std.process.Init`
+//! are wired through newlib; deeper platform services remain TODO.
+//!
+//! Stack default: libctru's 32 KB is far too small for any std-using
+//! Zig code path. We override `__stacksize__` (a `WEAK` symbol in
+//! libctru) with a strong export. 1 MB is comfortable; bump if engine
+//! frames grow.
+//!
+//! libctru also exposes weak `__ctru_heap_size` and
+//! `__ctru_linear_heap_size` symbols. Aether keeps the regular heap small
+//! and routes its process allocator through linear memory, so export strong
+//! values from build config instead of asking libctru for its default split.
+//!
+//! libctru also creates service threads internally. NDSP currently asks for
+//! a 4 KB stack, which can underflow in its sound-frame worker before Aether
+//! code is on the stack. The 3DS link step wraps `threadCreate`, and the
+//! wrapper below raises tiny service-thread stacks to a conservative floor.
+
+const process_init = @import("aether").CProcessInit;
+const std = @import("std");
+const options = @import("options");
+
+pub const os = struct {
+    pub const PATH_MAX = 1024;
+    pub const NAME_MAX = 255;
+};
+
+fn AppRoot() type {
+    const root = @import("root");
+    return if (@hasDecl(root, "main")) root else @import("aether_user_root");
+}
+
+pub const std_options = if (@hasDecl(AppRoot(), "std_options")) AppRoot().std_options else std.Options{};
+pub const std_options_debug_threaded_io = if (@hasDecl(AppRoot(), "std_options_debug_threaded_io")) AppRoot().std_options_debug_threaded_io else null;
+pub const std_options_debug_io = if (@hasDecl(AppRoot(), "std_options_debug_io")) AppRoot().std_options_debug_io else std.Io.failing;
+const app_std_options_cwd: ?fn () std.Io.Dir = if (@hasDecl(AppRoot(), "std_options_cwd")) AppRoot().std_options_cwd else null;
+pub const std_options_cwd = app_std_options_cwd orelse @import("aether").Cio.cwd;
+
+const argv = [_][*:0]const u8{"Aether"};
+const min_service_thread_stack = 128 * 1024;
+const exception_stack_size = 16 * 1024;
+const fatal_result: c_int = -1;
+const USERBREAK_PANIC = 0;
+
+const Thread = ?*anyopaque;
+const ThreadFunc = *const fn (?*anyopaque) callconv(.c) void;
+const ExceptionInfo = extern struct {
+    typ: c_int,
+    reserved: [3]u8,
+    fsr: u32,
+    far: u32,
+    fpexc: u32,
+    fpinst: u32,
+    fpinst2: u32,
+};
+const CpuRegisters = extern struct {
+    r: [13]u32,
+    sp: u32,
+    lr: u32,
+    pc: u32,
+    cpsr: u32,
+};
+
+extern fn __real_threadCreate(
+    entrypoint: ThreadFunc,
+    arg: ?*anyopaque,
+    stack_size: usize,
+    prio: c_int,
+    core_id: c_int,
+    detached: bool,
+) Thread;
+
+extern fn aether3dsInstallExceptionHandler(stack_top: ?*anyopaque) void;
+extern fn errfInit() c_int;
+extern fn ERRF_SetUserString(user_string: [*:0]const u8) c_int;
+extern fn ERRF_ThrowResultWithMessage(failure: c_int, message: [*:0]const u8) c_int;
+extern fn ERRF_ExceptionHandler(excep: *ExceptionInfo, regs: *CpuRegisters) noreturn;
+extern fn svcBreak(break_reason: c_int) void;
+extern fn svcOutputDebugString(str: [*]const u8, length: i32) c_int;
+
+// .text bounds provided by the linker script fragment in build.zig
+// (using ADDR(.text) + SIZEOF(.text)) so the panic unwinder can
+// precisely know what is code vs data/rodata/string literals when
+// doing the low-confidence stack scan (and BL-prev check). This
+// replaces any sketchy hardcoded ranges for "is this value in .text?".
+extern const __text_start: u8;
+extern const __text_end: u8;
+
+comptime {
+    @export(&entry, .{ .name = "main" });
+    @export(&stack_size, .{ .name = "__stacksize__" });
+    @export(&heap_size, .{ .name = "__ctru_heap_size" });
+    @export(&linear_heap_size, .{ .name = "__ctru_linear_heap_size" });
+    @export(&threadCreateWrap, .{ .name = "__wrap_threadCreate" });
+    @export(&exceptionHandler, .{ .name = "aether3dsExceptionHandler" });
+}
+
+var stack_size: u32 = 1 * 1024 * 1024;
+var heap_size: u32 = options.config.nintendo_3ds_heap_size;
+var linear_heap_size: u32 = options.config.nintendo_3ds_linear_heap_size;
+var exception_stack: [exception_stack_size]u8 align(8) = undefined;
+var panic_stage: u8 = 0;
+/// Captured very early in entry() so that the panic walker can scan the full
+/// used stack up to the initial top (instead of an arbitrary small window).
+var program_stack_top: usize = 0;
+
+fn threadCreateWrap(
+    entrypoint: ThreadFunc,
+    arg: ?*anyopaque,
+    requested_stack_size: usize,
+    prio: c_int,
+    core_id: c_int,
+    detached: bool,
+) callconv(.c) Thread {
+    return __real_threadCreate(
+        entrypoint,
+        arg,
+        @max(requested_stack_size, min_service_thread_stack),
+        prio,
+        core_id,
+        detached,
+    );
+}
+
+fn entry() callconv(.c) c_int {
+    if (program_stack_top == 0) {
+        // Capture the SP as set by the 3DS crt0 / loader, before we push anything.
+        // This is the "stack top" (high address); the base is roughly top - stack_size.
+        program_stack_top = asm volatile ("mov %[top], sp" : [top] "=r" (-> usize));
+    }
+    installCrashHandlers();
+
+    const init = process_init.makeInit(.{ .vector = &argv });
+    AppRoot().main(init) catch |err| {
+        fatalMainError(err, @errorReturnTrace(), @returnAddress());
+    };
+    return 0;
+}
+
+fn getFramePointer() usize {
+    return asm volatile ("mov %[fp], r11" : [fp] "=r" (-> usize));
+}
+
+/// Returns true if `addr` looks like a plausible ARM return address (i.e. the
+/// address immediately after a `bl` / `blx` instruction in .text).
+/// Used to filter the low-confidence stack scan so we don't pollute the trace
+/// with string constants, literal pools, or random data that happen to be in
+/// the code address range.
+fn isLikelyReturnAddress(addr: usize) bool {
+    @setRuntimeSafety(false);
+    const ts = @intFromPtr(&__text_start);
+    const te = @intFromPtr(&__text_end);
+    if ((addr & 3) != 0 or addr < ts or addr >= te) return false;
+    const prev = addr -% 4;
+    if (prev < ts) return false;
+    const inst = @as(*const u32, @ptrFromInt(prev)).*;
+    // ARM branch with link (BL) encoding: bits [27:24] == 0b1011 (0xb)
+    // Covers unconditional and conditional BL.
+    const op = (inst >> 24) & 0xf;
+    if (op == 0xb) return true;
+    return false;
+}
+
+/// Manual frame-pointer walk to collect return addresses for panic reporting.
+/// Limited depth, best-effort (unsafe during crash is acceptable).
+/// On 3DS (C-emitted code via gcc, often with omitted frame pointers), r11
+/// may not be a valid FP; we defensively reject low/implausible values to
+/// avoid data aborts inside the panic handler itself (which would turn a
+/// nice panic into a CPU exception).
+///
+/// start_fp / start_lr (if provided) should be captured *very early* in the
+/// panic handler (before the function's own frame setup or calls) so that
+/// they reflect the caller's frame (the code that hit the panic/unreachable).
+fn collectStackAddresses(first_addr: usize, out: []usize, start_fp: ?usize, start_lr: ?usize, start_sp: ?usize) usize {
+    @setRuntimeSafety(false); // best-effort only; raw ptr walks can fault (caught by exception handler). Prevents safety checks here from causing recursive zig panic().
+    const min_valid_fp: usize = 0x100000; // below this is not plausible for user stack frames on 3DS
+    var count: usize = 0;
+    if (out.len > 0) {
+        out[0] = first_addr;
+        count = 1;
+    }
+    // Prefer the provided start_lr (often the return addr from the panicking bl site)
+    if (start_lr) |lr| {
+        if (lr > 1 and lr != first_addr and count < out.len and isLikelyReturnAddress(lr)) {
+            out[count] = lr;
+            count += 1;
+        }
+    }
+    var fp = start_fp orelse getFramePointer();
+    var guard: usize = 0;
+    while (count < out.len and guard < 64) : (guard += 1) {  // allow deeper for panic
+        if (fp < min_valid_fp or (fp & 3) != 0) break;
+        const saved_fp: *const u32 = @ptrFromInt(fp);
+        const saved_lr: *const u32 = @ptrFromInt(fp + 4);
+        const lr = saved_lr.*;
+        const next_fp = saved_fp.*;
+        if (lr > 1 and count < out.len and isLikelyReturnAddress(lr)) {
+            out[count] = lr;
+            count += 1;
+        }
+        // Downward-growing stack: outer (caller) frames have *higher* fp values than inner.
+        // Walk while next_fp > fp. Stop on invalid, zero, misaligned, or non-progress (next <= fp would be cycle or wrong dir).
+        if (next_fp < min_valid_fp or next_fp == 0 or next_fp <= fp or (next_fp & 3) != 0) break;
+        fp = next_fp;
+    }
+
+    // Low-confidence heuristic stack scan for more entries (even if FP chain is broken,
+    // which is common on 3DS C-backend). Scan for values that look like code addresses
+    // (aligned, in plausible .text range). Useful for deeper traces on null unwraps etc.
+    // We dedup and accept some noise because "crashing anyway". Larger window and
+    // looser filter to get more candidates as requested.
+    if (start_sp) |sp| {
+        var top = if (program_stack_top != 0) program_stack_top else sp +% (1024 * 1024);
+        // Extra sanity on top/sp to avoid absurdly large scans or bad windows if
+        // program_stack_top got clobbered or capture was off. Cap total scan to 2MB.
+        if (top <= sp or top -% sp > 2 * 1024 * 1024 or sp < 0x1000 or top > 0x30000000) {
+            top = sp +% (64 * 1024); // small safe fallback window
+        }
+        // Scan the entire used stack (from current SP up to the initial top).
+        // With isLikelyReturnAddress() this is safe and will only pick real RAs
+        // that were saved by bl instructions, even across the full stack depth.
+        // We still dedup and bound the number added.
+        var scan: usize = sp & ~@as(usize, 3);
+        const max_scan: usize = 2 * 1024 * 1024;
+        var scanned: usize = 0;
+        while (scan < top and count < out.len and scanned < max_scan) : ({
+            scan += 4;
+            scanned += 4;
+        }) {
+            if (scan < 0x1000 or scan > 0x30000000) break;
+            const val = @as(*const u32, @ptrFromInt(scan)).*;
+            if (isLikelyReturnAddress(val)) {
+                var have = false;
+                for (out[0..count]) |prev| if (prev == val) { have = true; break; };
+                if (!have) {
+                    out[count] = val;
+                    count += 1;
+                }
+            }
+        }
+    }
+
+    return count;
+}
+
+fn fatalMainError(err: anyerror, maybe_trace: ?*std.builtin.StackTrace, fallback_addr: usize) noreturn {
+    @branchHint(.cold);
+    @setRuntimeSafety(false); // best-effort crash reporting only; disables safety checks that could re-invoke panic() and produce "Aether recursive..." instead of the original info.
+
+    if (panic_stage != 0) {
+        fatalDisplay("Aether recursive error in main");
+    }
+    panic_stage = 1;
+
+    const main_pc = if (maybe_trace) |trace| blk: {
+        const nn = @min(trace.index, trace.instruction_addresses.len);
+        if (nn > 0) break :blk trace.instruction_addresses[0];
+        break :blk fallback_addr;
+    } else fallback_addr;
+
+    // Capture fp/lr/sp early for better starting point for walk (see panic() for details).
+    const entry_fp = asm volatile ("mov %[fp], r11" : [fp] "=r" (-> usize));
+    const entry_lr = asm volatile ("mov %[lr], lr" : [lr] "=r" (-> usize));
+    const entry_sp = asm volatile ("mov %[sp], sp" : [sp] "=r" (-> usize));
+
+    var addrs: [32]usize = undefined;
+    const n = collectStackAddresses(main_pc, &addrs, entry_fp, entry_lr, entry_sp);
+
+    var trace_buf: [512]u8 = undefined;
+    var fixed: std.Io.Writer = .fixed(&trace_buf);
+
+    fixed.print("Aether main returned error.{s} at 0x{x}\n", .{@errorName(err), main_pc}) catch {};
+    fixed.print("entry_fp=0x{x} entry_sp=0x{x}\n", .{entry_fp, entry_sp}) catch {};
+
+    if (maybe_trace) |trace| {
+        const nerr = @min(trace.index, trace.instruction_addresses.len);
+        if (nerr > 0) {
+            fixed.writeAll("error return trace:\n") catch {};
+            for (trace.instruction_addresses[0..nerr], 0..) |a, i| {
+                fixed.print("{d: >2}: 0x{x:0>8}\n", .{ i, a }) catch {};
+            }
+        }
+    }
+
+    // Current stack walk for more context (seeded from entry + heuristic)
+    fixed.writeAll("stack trace:\n") catch {};
+    const show = @min(n, 20);
+    for (addrs[0..show], 0..) |a, i| {
+        fixed.print("{d: >2}: 0x{x:0>8}\n", .{ i, a }) catch {};
+    }
+
+    fixed.writeAll("\n") catch {};
+    const text = fixed.buffered();
+
+    debugString(text);
+    debugString("\n");
+
+    // For ERRF_SetUserString (max ~256 bytes), compact version with PC + stack addrs.
+    var user_buf: [256:0]u8 = @splat(0);
+    var uw: std.Io.Writer = .fixed(&user_buf);
+    var hbuf: [96]u8 = undefined;
+    const h = std.fmt.bufPrint(&hbuf, "Aether main err at 0x{x}: {s}\n", .{main_pc, @errorName(err)}) catch "Aether main err\n";
+    uw.writeAll(h[0..@min(h.len, 70)]) catch {};
+    if (maybe_trace) |trace| {
+        const nerr = @min(trace.index, trace.instruction_addresses.len);
+        if (nerr > 0) {
+            uw.writeAll("err:") catch {};
+            for (trace.instruction_addresses[0..@min(nerr,3)], 0..) |a, i| {
+                uw.print(" {d}:0x{x}", .{i, a}) catch {};
+            }
+            uw.writeAll("\n") catch {};
+        }
+    }
+    uw.writeAll("stack:") catch {};
+    const nprint = @min(n, 24);
+    for (addrs[0..nprint], 0..) |a, i| {
+        uw.print(" {d}:0x{x}", .{i, a}) catch {};
+    }
+    uw.writeAll("\n") catch {};
+    const end = @min(uw.end, 255);
+    const user_str = user_buf[0..end :0];
+
+    _ = errfInit();
+    _ = ERRF_SetUserString(user_str.ptr);
+
+    // Compact message for the visible "Reason" (0x60 limit): include the PC + some stack.
+    var throw_buf: [0x60:0]u8 = @splat(0);
+    var w: std.Io.Writer = .fixed(&throw_buf);
+    w.print("Aether main err at 0x{x}: {s}", .{main_pc, @errorName(err)}) catch {};
+    if (n > 0) {
+        w.print(" [", .{}) catch {};
+        const max_short = 4;
+        for (addrs[0..@min(n, max_short)], 0..) |a, i| {
+            if (i > 0) w.print(" ", .{}) catch {};
+            w.print("{d}:0x{x}", .{i, a}) catch {};
+        }
+        if (n > max_short) w.print("..", .{}) catch {};
+        w.print("]", .{}) catch {};
+    }
+    _ = w.flush() catch {};
+    _ = ERRF_ThrowResultWithMessage(fatal_result, &throw_buf);
+
+    svcBreak(USERBREAK_PANIC);
+    while (true) {}
+}
+
+pub fn panic(msg: []const u8, _: ?*std.builtin.StackTrace, first_trace_addr: ?usize) noreturn {
+    @branchHint(.cold);
+    @setRuntimeSafety(false); // best-effort crash reporting only; disables safety checks that could re-invoke panic() and produce "Aether recursive..." instead of the original info.
+
+    if (panic_stage != 0) {
+        fatalDisplay("Aether recursive panic");
+    }
+    panic_stage = 1;
+
+    const first = first_trace_addr orelse @returnAddress();
+
+    // Capture fp/lr/sp *immediately* at entry (before any local stack alloc or calls
+    // that might clobber r11 in the generated prologue). This gives us the fp of
+    // the frame that called the panic handler (i.e. the function containing the
+    // unreachable/panic site). sp is used for low-conf heuristic scan.
+    const entry_fp = asm volatile ("mov %[fp], r11" : [fp] "=r" (-> usize));
+    const entry_lr = asm volatile ("mov %[lr], lr" : [lr] "=r" (-> usize));
+    const entry_sp = asm volatile ("mov %[sp], sp" : [sp] "=r" (-> usize));
+
+    // Collect early, passing the captured entry context so the walker starts
+    // from the caller's frame (not inside the panic handler). Larger array + sp
+    // scan for more (even low-confidence) frames.
+    var addrs: [64]usize = undefined;
+    const n = collectStackAddresses(first, &addrs, entry_fp, entry_lr, entry_sp);
+
+    var trace_buf: [512]u8 = undefined;
+    var fixed: std.Io.Writer = .fixed(&trace_buf);
+
+    fixed.print("Aether panic at 0x{x}: {s}\n", .{first, msg}) catch {};
+    // entry_fp / entry_sp are printed here for the svc debug output (3dslink etc.)
+    // They are omitted from the short user_str to keep the error screen clean.
+    fixed.print("entry_fp=0x{x} entry_sp=0x{x}\n", .{entry_fp, entry_sp}) catch {};
+
+    // error return trace (if any)
+    if (@errorReturnTrace()) |t| {
+        const nerr = @min(t.index, t.instruction_addresses.len);
+        if (nerr > 0) {
+            fixed.writeAll("error return trace:\n") catch {};
+            for (t.instruction_addresses[0..nerr], 0..) |a, i| {
+                fixed.print("{d: >2}: 0x{x:0>8}\n", .{ i, a }) catch {};
+            }
+        }
+    }
+
+    // current stack via manual fp walk (seeded from entry + walked from caller's fp)
+    // + heuristic scan (filtered to likely RAs). Skip internal safety panic
+    // handler frames (they are just noise in the trace).
+    fixed.writeAll("stack trace:\n") catch {};
+    const show = @min(n, 32);
+    for (addrs[0..show], 0..) |a, i| {
+        fixed.print("{d: >2}: 0x{x:0>8}\n", .{ i, a }) catch {};
+    }
+    if (n == 0) {
+        fixed.print("0: 0x{x:0>8}\n", .{first}) catch {};
+    }
+
+    const text = fixed.buffered();
+
+    debugString(text);
+    debugString("\n");
+
+    // For ERRF_SetUserString (max ~256 bytes per libctru), build a compact version
+    // that prioritizes the PC + as many stack addresses as will fit. This is what
+    // appears in CFW error screens / exception logs when the full Reason is limited.
+    // The pretty multi-line version above still goes to debugString (visible via 3dslink etc.).
+    var user_buf: [256:0]u8 = @splat(0);
+    var uw: std.Io.Writer = .fixed(&user_buf);
+    // Put the panic message first: ERRF surfaces have very little room, and
+    // diagnostics often carry the useful measurement in `msg`.
+    var hbuf: [96]u8 = undefined;
+    const h = std.fmt.bufPrint(&hbuf, "{s}\npc=0x{x}\n", .{msg, first}) catch "Aether panic\n";
+    uw.writeAll(h[0..@min(h.len, 70)]) catch {};
+    if (@errorReturnTrace()) |t| {
+        const nerr = @min(t.index, t.instruction_addresses.len);
+        if (nerr > 0) {
+            uw.writeAll("err:") catch {};
+            for (t.instruction_addresses[0..@min(nerr,3)], 0..) |a, i| {
+                uw.print(" {d}:0x{x}", .{i, a}) catch {};
+            }
+            uw.writeAll("\n") catch {};
+        }
+    }
+    uw.writeAll("stack:") catch {};
+    const nprint = @min(n, 30);
+    for (addrs[0..nprint], 0..) |a, i| {
+        uw.print(" {d}:0x{x}", .{i, a}) catch {};
+    }
+    if (nprint == 0) {
+        uw.print(" 0:0x{x}", .{first}) catch {};
+    }
+    uw.writeAll("\n") catch {};
+    const end = @min(uw.end, 255);
+    const user_str = user_buf[0..end :0];
+
+    _ = errfInit();
+    _ = ERRF_SetUserString(user_str.ptr);
+
+    // The failure message shown as "Reason" on the error screen is limited
+    // (~0x60 bytes), so prioritize the measurement text over the PC/stack.
+    var throw_buf: [0x60:0]u8 = @splat(0);
+    var w: std.Io.Writer = .fixed(&throw_buf);
+    w.print("{s} pc=0x{x}", .{msg, first}) catch {};
+    if (n > 0) {
+        w.print(" [", .{}) catch {};
+        const max_short = 4;
+        for (addrs[0..@min(n, max_short)], 0..) |a, i| {
+            if (i > 0) w.print(" ", .{}) catch {};
+            w.print("{d}:0x{x}", .{i, a}) catch {};
+        }
+        if (n > max_short) w.print("..", .{}) catch {};
+        w.print("]", .{}) catch {};
+    }
+    _ = w.flush() catch {};
+    _ = ERRF_ThrowResultWithMessage(fatal_result, &throw_buf);
+
+    svcBreak(USERBREAK_PANIC);
+    while (true) {}
+}
+
+fn installCrashHandlers() void {
+    const top: ?*anyopaque = @ptrFromInt(@intFromPtr(&exception_stack) + exception_stack.len);
+    aether3dsInstallExceptionHandler(top);
+}
+
+fn exceptionHandler(excep: *ExceptionInfo, regs: *CpuRegisters) callconv(.c) noreturn {
+    @branchHint(.cold);
+
+    var buf: [256:0]u8 = @splat(0);
+    const msg = std.fmt.bufPrintZ(&buf,
+        \\Aether {s}
+        \\PC=0x{x:0>8} LR=0x{x:0>8} SP=0x{x:0>8}
+        \\FAR=0x{x:0>8} FSR=0x{x:0>8} CPSR=0x{x:0>8}
+        \\R0=0x{x:0>8} R1=0x{x:0>8} R2=0x{x:0>8} R3=0x{x:0>8}
+    , .{
+        exceptionName(excep.typ),
+        regs.pc,
+        regs.lr,
+        regs.sp,
+        excep.far,
+        excep.fsr,
+        regs.cpsr,
+        regs.r[0],
+        regs.r[1],
+        regs.r[2],
+        regs.r[3],
+    }) catch fallback: {
+        @memcpy(buf[0.."Aether CPU exception".len], "Aether CPU exception");
+        break :fallback buf[0.."Aether CPU exception".len :0];
+    };
+
+    debugString(msg);
+    debugString("\n");
+    _ = errfInit();
+    _ = ERRF_SetUserString(msg.ptr);
+    ERRF_ExceptionHandler(excep, regs);
+}
+
+fn exceptionName(typ: c_int) []const u8 {
+    return switch (typ) {
+        0 => "Prefetch Abort",
+        1 => "Data Abort",
+        2 => "Undefined Instruction",
+        3 => "VFP Exception",
+        else => "CPU Exception",
+    };
+}
+
+fn fatal(comptime fmt: []const u8, args: anytype) noreturn {
+    var buf: [256:0]u8 = @splat(0);
+    const msg = std.fmt.bufPrintZ(&buf, fmt, args) catch fallback: {
+        @memcpy(buf[0.."Aether fatal error".len], "Aether fatal error");
+        break :fallback buf[0.."Aether fatal error".len :0];
+    };
+    fatalDisplay(msg);
+}
+
+fn fatalDisplay(message: [:0]const u8) noreturn {
+    debugString(message);
+    debugString("\n");
+
+    _ = errfInit();
+    _ = ERRF_SetUserString(message.ptr);
+    _ = ERRF_ThrowResultWithMessage(fatal_result, message.ptr);
+
+    svcBreak(USERBREAK_PANIC);
+    while (true) {}
+}
+
+fn debugString(message: []const u8) void {
+    if (message.len == 0) return;
+    _ = svcOutputDebugString(message.ptr, @intCast(@min(message.len, std.math.maxInt(i32))));
+}
diff --git a/src/platform/3ds/shaders/basic.psm b/src/platform/3ds/shaders/basic.psm
new file mode 100644
index 0000000..f44826a
--- /dev/null
+++ b/src/platform/3ds/shaders/basic.psm
@@ -0,0 +1,47 @@
+.entry main vertex
+.out main o0 position
+.out main o1.xy texture_coordinates_0.xy
+.out main o2 color
+.set main f11 (0.0, 1.0, 0.0, 0.0)
+
+.alias outpos o0
+.alias outtc0 o1
+.alias outclr o2
+
+.alias inpos v0
+.alias inclr v1
+.alias inuv v2
+
+.alias projection0 f0
+.alias projection1 f1
+.alias projection2 f2
+.alias projection3 f3
+.alias modelview0 f4
+.alias modelview1 f5
+.alias modelview2 f6
+.alias modelview3 f7
+.alias posscale f8
+.alias uvscaleoffset f9
+.alias colorscale f10
+.alias zeros f11.xxxx
+.alias ones f11.yyyy
+
+main:
+    mul r0.xyz, posscale, inpos
+    mov r0.w, ones
+
+    dp4 r1.x, modelview0, r0
+    dp4 r1.y, modelview1, r0
+    dp4 r1.z, modelview2, r0
+    dp4 r1.w, modelview3, r0
+
+    dp4 outpos.x, projection0, r1
+    dp4 outpos.y, projection1, r1
+    dp4 outpos.z, projection2, r1
+    dp4 outpos.w, projection3, r1
+
+    mul r2.xy, uvscaleoffset.xy, inuv.xy
+    add outtc0.xy, uvscaleoffset.zw, r2.xy
+    mov outtc0.zw, zeros
+    mul outclr, colorscale, inclr
+    end
diff --git a/src/platform/3ds/shaders/basic.v.pica b/src/platform/3ds/shaders/basic.v.pica
new file mode 100644
index 0000000..98e2204
--- /dev/null
+++ b/src/platform/3ds/shaders/basic.v.pica
@@ -0,0 +1,35 @@
+.fvec projection[4], modelView[4]
+.fvec posScale, uvScaleOffset, colorScale
+
+.constf myconst(0.0, 1.0, 0.0, 0.0)
+.alias zeros myconst.xxxx
+.alias ones myconst.yyyy
+
+.out outpos position
+.out outtc0 texcoord0
+.out outclr color
+
+.alias inpos v0
+.alias inclr v1
+.alias inuv v2
+
+.proc main
+    mul r0.xyz, posScale, inpos
+    mov r0.w, ones
+
+    dp4 r1.x, modelView[0], r0
+    dp4 r1.y, modelView[1], r0
+    dp4 r1.z, modelView[2], r0
+    dp4 r1.w, modelView[3], r0
+
+    dp4 outpos.x, projection[0], r1
+    dp4 outpos.y, projection[1], r1
+    dp4 outpos.z, projection[2], r1
+    dp4 outpos.w, projection[3], r1
+
+    mul outtc0.xy, uvScaleOffset.xy, inuv.xy
+    add outtc0.xy, uvScaleOffset.zw, outtc0.xy
+    mov outtc0.zw, zeros
+    mul outclr, colorScale, inclr
+    end
+.end
diff --git a/src/platform/3ds/surface.zig b/src/platform/3ds/surface.zig
new file mode 100644
index 0000000..ce670fe
--- /dev/null
+++ b/src/platform/3ds/surface.zig
@@ -0,0 +1,48 @@
+//! 3DS surface stub.
+//!
+//! Top screen is 400x240; bottom touch screen is 320x240. The real backend
+//! will likely expose the bottom one separately.
+
+const std = @import("std");
+const Self = @This();
+
+extern fn aptMainLoop() bool;
+extern fn aptShouldClose() bool;
+
+var system_closing = false;
+
+alloc: std.mem.Allocator,
+
+pub fn init(_: *Self, _: u32, _: u32, _: [:0]const u8, _: bool, _: bool, _: bool) anyerror!void {
+    system_closing = false;
+}
+
+pub fn deinit(_: *Self) void {}
+
+pub fn update(_: *Self) bool {
+    if (system_closing) return false;
+
+    const keep_running = aptMainLoop();
+    if (!keep_running or aptShouldClose()) {
+        system_closing = true;
+        return false;
+    }
+    return true;
+}
+
+pub fn draw(_: *Self) void {}
+
+pub fn is_system_closing() bool {
+    if (!system_closing and aptShouldClose()) {
+        system_closing = true;
+    }
+    return system_closing;
+}
+
+pub fn get_width(_: *Self) u32 {
+    return 400;
+}
+
+pub fn get_height(_: *Self) u32 {
+    return 240;
+}
diff --git a/src/platform/3ds/time.zig b/src/platform/3ds/time.zig
new file mode 100644
index 0000000..be4b264
--- /dev/null
+++ b/src/platform/3ds/time.zig
@@ -0,0 +1,53 @@
+const std = @import("std");
+
+extern fn osGetTime() u64;
+extern fn svcSleepThread(ns: i64) void;
+
+const ns_per_ms: u64 = std.time.ns_per_ms;
+const max_i64_ns: i64 = std.math.maxInt(i64);
+
+pub fn now(clock: std.Io.Clock) std.Io.Timestamp {
+    switch (clock) {
+        .real, .awake, .boot => return .fromNanoseconds(osTimeNanoseconds(osGetTime())),
+        else => std.debug.panic("3ds std.Io clock {s} is not implemented", .{@tagName(clock)}),
+    }
+}
+
+pub fn clockResolution(clock: std.Io.Clock) std.Io.Clock.ResolutionError!std.Io.Duration {
+    switch (clock) {
+        .real, .awake, .boot => return .fromNanoseconds(ns_per_ms),
+        else => return error.ClockUnavailable,
+    }
+}
+
+fn osTimeNanoseconds(ms: u64) i64 {
+    const ns = @as(u128, ms) * ns_per_ms;
+    return @intCast(@min(ns, @as(u128, @intCast(max_i64_ns))));
+}
+
+pub fn sleep(timeout: std.Io.Timeout) std.Io.Cancelable!void {
+    const ns = timeoutNanoseconds(timeout);
+    if (ns <= 0) return;
+    svcSleepThread(ns);
+}
+
+fn timeoutNanoseconds(timeout: std.Io.Timeout) i64 {
+    return switch (timeout) {
+        .none => 0,
+        .duration => |duration| clampNs(duration.raw.nanoseconds),
+        .deadline => |deadline| deadlineNanoseconds(deadline),
+    };
+}
+
+fn clampNs(ns: i96) i64 {
+    if (ns > std.math.maxInt(i64)) return std.math.maxInt(i64);
+    if (ns < std.math.minInt(i64)) return std.math.minInt(i64);
+    return @intCast(ns);
+}
+
+fn deadlineNanoseconds(deadline: std.Io.Clock.Timestamp) i64 {
+    const target = clampNs(deadline.raw.nanoseconds);
+    const current = clampNs(now(deadline.clock).nanoseconds);
+    if (target <= current) return 0;
+    return target - current;
+}
diff --git a/src/platform/audio.zig b/src/platform/audio.zig
index 6fc0568..1b8dd00 100644
--- a/src/platform/audio.zig
+++ b/src/platform/audio.zig
@@ -6,12 +6,18 @@ const audio_api = @import("audio_api.zig");
 const mixer_mod = @import("../audio/mixer.zig");
 
 /// Comptime-selected audio backend module (slot-based PCM output).
-/// `.none` routes to the silent backend -- used by headless builds and by
-/// the macOS default while miniaudio is bugged there.
+/// `.none` routes to the silent backend -- used by headless builds and
+/// explicit `-Daudio=none` builds.
 pub const Api = if (options.config.audio == .none)
     @import("headless/headless_audio.zig")
 else if (builtin.os.tag == .psp)
     @import("psp/psp_audio.zig")
+else if (builtin.os.tag == .@"3ds")
+    @import("3ds/3ds_audio.zig")
+else if (options.config.platform == .nintendo_switch)
+    @import("switch/switch_audio.zig")
+else if (options.config.platform == .wasm)
+    @import("wasm/browser_audio.zig")
 else
     @import("glfw/audio.zig");
 
diff --git a/src/platform/c_io.zig b/src/platform/c_io.zig
new file mode 100644
index 0000000..5428e9c
--- /dev/null
+++ b/src/platform/c_io.zig
@@ -0,0 +1,1302 @@
+const std = @import("std");
+const options = @import("options");
+
+const Io = std.Io;
+const Dir = Io.Dir;
+const File = Io.File;
+
+const platform_time = switch (options.config.platform) {
+    .nintendo_3ds => @import("3ds/time.zig"),
+    .nintendo_switch => @import("switch/time.zig"),
+    else => @compileError("platform/c_io.zig is only wired for Nintendo targets"),
+};
+const platform_paths = switch (options.config.platform) {
+    .nintendo_3ds => @import("3ds/paths.zig"),
+    .nintendo_switch => @import("switch/paths.zig"),
+    else => unreachable,
+};
+const platform_lifecycle = switch (options.config.platform) {
+    .nintendo_3ds => @import("3ds/surface.zig"),
+    else => struct {
+        pub fn is_system_closing() bool {
+            return false;
+        }
+    },
+};
+
+const c = @import("nintendo_c.zig").c;
+const max_path_bytes = 1024;
+const async_stack_size = 512 * 1024;
+
+const AT_FDCWD: c_int = -2;
+const O_RDONLY: c_int = c.O_RDONLY;
+const O_WRONLY: c_int = c.O_WRONLY;
+const O_RDWR: c_int = c.O_RDWR;
+const O_CREAT: c_int = c.O_CREAT;
+const O_TRUNC: c_int = c.O_TRUNC;
+const O_EXCL: c_int = c.O_EXCL;
+const O_BINARY: c_int = c.O_BINARY;
+const O_CLOEXEC: c_int = c.O_CLOEXEC;
+const O_NOFOLLOW: c_int = c.O_NOFOLLOW;
+const SEEK_SET: c_int = c.SEEK_SET;
+const SEEK_CUR: c_int = c.SEEK_CUR;
+const SEEK_END: c_int = c.SEEK_END;
+
+const DT_FIFO: u8 = c.DT_FIFO;
+const DT_CHR: u8 = c.DT_CHR;
+const DT_DIR: u8 = c.DT_DIR;
+const DT_BLK: u8 = c.DT_BLK;
+const DT_REG: u8 = c.DT_REG;
+const DT_LNK: u8 = c.DT_LNK;
+const DT_SOCK: u8 = c.DT_SOCK;
+const DT_WHT: u8 = c.DT_WHT;
+
+var read_fd: c_int = -1;
+var write_fd: c_int = -1;
+var stderr_writer: File.Writer = undefined;
+var stderr_writer_initialized = false;
+var empty_stderr_buffer: [0]u8 = .{};
+var resources_mounted = false;
+var data_mounted = false;
+var atomic_counter: u64 = 0x6165_7468_6572_0000;
+
+const max_dynamic_dirs = 32;
+const DirSlot = struct {
+    used: bool = false,
+    path: [max_path_bytes:0]u8 = @splat(0),
+    len: usize = 0,
+};
+var dir_slots: [max_dynamic_dirs]DirSlot = [_]DirSlot{.{}} ** max_dynamic_dirs;
+
+const vtable: Io.VTable = blk: {
+    var v = Io.failing.vtable.*;
+    v.crashHandler = crashHandler;
+    if (options.config.platform == .nintendo_3ds) {
+        v.async = threed_async.async;
+        v.concurrent = threed_async.concurrent;
+        v.await = threed_async.await;
+        v.cancel = threed_async.cancel;
+    } else {
+        v.async = Io.noAsync;
+    }
+    v.groupAsync = Io.noGroupAsync;
+    v.recancel = recancel;
+    v.swapCancelProtection = swapCancelProtection;
+    v.checkCancel = checkCancel;
+    v.operate = operate;
+    v.dirCreateDir = dirCreateDir;
+    v.dirCreateDirPath = dirCreateDirPath;
+    v.dirCreateDirPathOpen = dirCreateDirPathOpen;
+    v.dirOpenDir = dirOpenDir;
+    v.dirAccess = dirAccess;
+    v.dirCreateFile = dirCreateFile;
+    v.dirCreateFileAtomic = dirCreateFileAtomic;
+    v.dirOpenFile = dirOpenFile;
+    v.dirClose = dirClose;
+    v.dirRead = dirRead;
+    v.dirDeleteFile = dirDeleteFile;
+    v.dirDeleteDir = dirDeleteDir;
+    v.dirRename = dirRename;
+    v.dirRenamePreserve = dirRenamePreserve;
+    v.fileStat = fileStat;
+    v.fileLength = fileLength;
+    v.fileClose = fileClose;
+    v.fileWritePositional = fileWritePositional;
+    v.fileReadPositional = fileReadPositional;
+    v.fileSeekBy = fileSeekBy;
+    v.fileSeekTo = fileSeekTo;
+    v.fileSync = fileSync;
+    v.fileIsTty = fileIsTty;
+    v.fileEnableAnsiEscapeCodes = fileEnableAnsiEscapeCodes;
+    v.fileSupportsAnsiEscapeCodes = fileSupportsAnsiEscapeCodes;
+    v.fileSetLength = fileSetLength;
+    v.lockStderr = lockStderr;
+    v.tryLockStderr = tryLockStderr;
+    v.unlockStderr = unlockStderr;
+    v.processCurrentPath = processCurrentPath;
+    v.processSetCurrentPath = processSetCurrentPath;
+    v.now = now;
+    v.clockResolution = clockResolution;
+    v.sleep = sleep;
+    v.random = random;
+    break :blk v;
+};
+
+pub fn io() Io {
+    return .{ .userdata = null, .vtable = &vtable };
+}
+
+pub fn cwd() Dir {
+    return .{ .handle = AT_FDCWD };
+}
+
+pub fn mountData() void {
+    data_mounted = platform_paths.mountData();
+}
+
+pub fn mountResources() bool {
+    resources_mounted = platform_paths.mountResources();
+    return resources_mounted;
+}
+
+pub fn dataRoot(buffer: []u8, app_name: []const u8) error{NameTooLong}![]const u8 {
+    return platform_paths.dataRoot(buffer, app_name);
+}
+
+pub fn deinitAppDirs() void {
+    for (&dir_slots) |*slot| slot.used = false;
+    if (platform_lifecycle.is_system_closing()) {
+        resources_mounted = false;
+        data_mounted = false;
+        return;
+    }
+    if (resources_mounted) {
+        platform_paths.unmountResources();
+        resources_mounted = false;
+    }
+    if (data_mounted) {
+        platform_paths.unmountData();
+        data_mounted = false;
+    }
+}
+
+pub fn useCwdDirs() void {
+    deinitAppDirs();
+}
+
+fn crashHandler(_: ?*anyopaque) void {}
+
+fn recancel(_: ?*anyopaque) void {}
+
+fn swapCancelProtection(_: ?*anyopaque, new: Io.CancelProtection) Io.CancelProtection {
+    _ = new;
+    return .unblocked;
+}
+
+fn checkCancel(_: ?*anyopaque) Io.Cancelable!void {}
+
+const threed_async = if (options.config.platform == .nintendo_3ds) struct {
+    const AsyncFuture = struct {
+        thread: c.Thread,
+        result_len: usize,
+        result_offset: usize,
+        context_offset: usize,
+        start: *const fn (context: *const anyopaque, result: *anyopaque) void,
+
+        fn result(self: *AsyncFuture) []u8 {
+            const base: [*]u8 = @ptrCast(self);
+            return base[self.result_offset..][0..self.result_len];
+        }
+
+        fn context(self: *AsyncFuture) *const anyopaque {
+            const base: [*]u8 = @ptrCast(self);
+            return @ptrCast(base + self.context_offset);
+        }
+    };
+
+    fn allocFuture(
+        result_len: usize,
+        result_alignment: std.mem.Alignment,
+        context: []const u8,
+        context_alignment: std.mem.Alignment,
+        start: *const fn (context: *const anyopaque, result: *anyopaque) void,
+    ) ?*AsyncFuture {
+        const result_offset = result_alignment.forward(@sizeOf(AsyncFuture));
+        const context_offset = context_alignment.forward(result_offset + result_len);
+        const total = context_offset + context.len;
+
+        const raw = c.malloc(total) orelse return null;
+        const future: *AsyncFuture = @ptrCast(@alignCast(raw));
+        future.* = .{
+            .thread = null,
+            .result_len = result_len,
+            .result_offset = result_offset,
+            .context_offset = context_offset,
+            .start = start,
+        };
+
+        const base: [*]u8 = @ptrCast(future);
+        @memcpy(base[context_offset..][0..context.len], context);
+        return future;
+    }
+
+    fn freeFuture(future: *AsyncFuture) void {
+        c.free(future);
+    }
+
+    fn entry(raw: ?*anyopaque) callconv(.c) void {
+        const future: *AsyncFuture = @ptrCast(@alignCast(raw.?));
+        future.start(future.context(), future.result().ptr);
+    }
+
+    fn spawn(future: *AsyncFuture) bool {
+        future.thread = c.threadCreate(
+            entry,
+            future,
+            async_stack_size,
+            workerPriority(),
+            -2,
+            false,
+        ) orelse return false;
+        return true;
+    }
+
+    fn workerPriority() c_int {
+        var priority: c.s32 = 0x30;
+        if (c.threadGetCurrent()) |current| {
+            const handle = c.threadGetHandle(current);
+            _ = c.svcGetThreadPriority(&priority, handle);
+        }
+        return @min(priority + 1, 0x3f);
+    }
+
+    fn async(
+        _: ?*anyopaque,
+        result: []u8,
+        result_alignment: std.mem.Alignment,
+        context: []const u8,
+        context_alignment: std.mem.Alignment,
+        start: *const fn (context: *const anyopaque, result: *anyopaque) void,
+    ) ?*Io.AnyFuture {
+        const future = allocFuture(result.len, result_alignment, context, context_alignment, start) orelse {
+            start(context.ptr, result.ptr);
+            return null;
+        };
+        if (!spawn(future)) {
+            freeFuture(future);
+            start(context.ptr, result.ptr);
+            return null;
+        }
+        return @ptrCast(future);
+    }
+
+    fn concurrent(
+        _: ?*anyopaque,
+        result_len: usize,
+        result_alignment: std.mem.Alignment,
+        context: []const u8,
+        context_alignment: std.mem.Alignment,
+        start: *const fn (context: *const anyopaque, result: *anyopaque) void,
+    ) Io.ConcurrentError!*Io.AnyFuture {
+        const future = allocFuture(result_len, result_alignment, context, context_alignment, start) orelse
+            return error.ConcurrencyUnavailable;
+        errdefer freeFuture(future);
+        if (!spawn(future)) return error.ConcurrencyUnavailable;
+        return @ptrCast(future);
+    }
+
+    fn await(
+        _: ?*anyopaque,
+        any_future: *Io.AnyFuture,
+        result: []u8,
+        result_alignment: std.mem.Alignment,
+    ) void {
+        _ = result_alignment;
+        const future: *AsyncFuture = @ptrCast(@alignCast(any_future));
+        _ = c.threadJoin(future.thread, std.math.maxInt(u64));
+        c.threadFree(future.thread);
+        @memcpy(result, future.result());
+        freeFuture(future);
+    }
+
+    fn cancel(
+        userdata: ?*anyopaque,
+        any_future: *Io.AnyFuture,
+        result: []u8,
+        result_alignment: std.mem.Alignment,
+    ) void {
+        await(userdata, any_future, result, result_alignment);
+    }
+} else struct {};
+
+fn operate(_: ?*anyopaque, operation: Io.Operation) Io.Cancelable!Io.Operation.Result {
+    return switch (operation) {
+        .file_read_streaming => |op| .{ .file_read_streaming = fileReadStreaming(op.file, op.data) },
+        .file_write_streaming => |op| .{ .file_write_streaming = fileWriteStreaming(op.file, op.header, op.data, op.splat) },
+        .device_io_control => unsupported("device_io_control"),
+        .net_receive => .{ .net_receive = .{ error.NetworkDown, 0 } },
+    };
+}
+
+fn dirCreateDir(
+    _: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    permissions: Dir.Permissions,
+) Dir.CreateDirError!void {
+    var path_buffer: [max_path_bytes:0]u8 = undefined;
+    const path = try rootedPathForDir(&path_buffer, dir, sub_path);
+    const mode = permissionsMode(permissions, 0o777);
+    if (c.mkdir(path.ptr, mode) == 0) return;
+    return createDirError(errno());
+}
+
+fn dirCreateDirPath(
+    _: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    permissions: Dir.Permissions,
+) Dir.CreateDirPathError!Dir.CreatePathStatus {
+    return createDirPathAt(dir, sub_path, permissions);
+}
+
+fn dirCreateDirPathOpen(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    permissions: Dir.Permissions,
+    open_options: Dir.OpenOptions,
+) Dir.CreateDirPathOpenError!Dir {
+    _ = try dirCreateDirPath(userdata, dir, sub_path, permissions);
+    return dirOpenDir(userdata, dir, sub_path, open_options);
+}
+
+fn dirOpenDir(_: ?*anyopaque, dir: Dir, sub_path: []const u8, options_arg: Dir.OpenOptions) Dir.OpenError!Dir {
+    if (!options_arg.access_sub_paths) unsupported("dirOpenDir without sub-path access");
+
+    var path_buffer: [max_path_bytes:0]u8 = undefined;
+    const path = try rootedPathForDir(&path_buffer, dir, sub_path);
+    const stream = c.opendir(path.ptr) orelse return dirOpenError(errno());
+    _ = c.closedir(stream);
+
+    return registerDir(path);
+}
+
+fn dirAccess(_: ?*anyopaque, dir: Dir, sub_path: []const u8, opts: Dir.AccessOptions) Dir.AccessError!void {
+    if (!opts.follow_symlinks) unsupported("dirAccess without symlink following");
+
+    var path_buffer: [max_path_bytes:0]u8 = undefined;
+    const path = try rootedPathForDir(&path_buffer, dir, sub_path);
+    const fd = c.open(path.ptr, O_BINARY | O_RDONLY | O_CLOEXEC, @as(c.mode_t, 0));
+    if (fd < 0) return accessError(errno());
+    _ = c.close(fd);
+}
+
+fn dirOpenFile(_: ?*anyopaque, dir: Dir, sub_path: []const u8, flags: Dir.OpenFileOptions) File.OpenError!File {
+    if (flags.lock != .none) return error.FileLocksUnsupported;
+    if (flags.path_only) unsupported("path-only file open");
+    if (!flags.allow_ctty) {}
+
+    const role: FileRole = switch (flags.mode) {
+        .read_only => .read,
+        .write_only => .write,
+        .read_write => .read_write,
+    };
+
+    var path_buffer: [max_path_bytes:0]u8 = undefined;
+    var open_flags: c_int = O_BINARY | O_CLOEXEC | switch (flags.mode) {
+        .read_only => O_RDONLY,
+        .write_only => O_WRONLY,
+        .read_write => O_RDWR,
+    };
+    if (!flags.follow_symlinks) open_flags |= O_NOFOLLOW;
+
+    const path = try rootedPathForDir(&path_buffer, dir, sub_path);
+    const fd = c.open(path.ptr, open_flags, @as(c.mode_t, 0));
+    if (fd < 0) return openError(errno());
+    errdefer _ = c.close(fd);
+    return registerFile(fd, role);
+}
+
+fn dirCreateFile(_: ?*anyopaque, dir: Dir, sub_path: []const u8, flags: Dir.CreateFileOptions) File.OpenError!File {
+    if (flags.lock != .none) return error.FileLocksUnsupported;
+
+    var path_buffer: [max_path_bytes:0]u8 = undefined;
+    var open_flags: c_int = O_BINARY | O_CLOEXEC | if (flags.read) O_RDWR else O_WRONLY;
+    open_flags |= O_CREAT;
+    if (flags.truncate) open_flags |= O_TRUNC;
+    if (flags.exclusive) open_flags |= O_EXCL;
+
+    const mode = permissionsMode(flags.permissions, 0o666);
+    const path = try rootedPathForDir(&path_buffer, dir, sub_path);
+    const fd = c.open(path.ptr, open_flags, mode);
+    if (fd < 0) return openError(errno());
+    errdefer _ = c.close(fd);
+    return registerFile(fd, if (flags.read) .read_write else .write);
+}
+
+fn dirCreateFileAtomic(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    opts: Dir.CreateFileAtomicOptions,
+) Dir.CreateFileAtomicError!File.Atomic {
+    var target_dir = dir;
+    var close_target_dir = false;
+    var dest_sub_path = sub_path;
+    errdefer if (close_target_dir) target_dir.close(io());
+
+    if (std.fs.path.dirname(sub_path)) |parent| {
+        target_dir = if (opts.make_path)
+            dirCreateDirPathOpen(userdata, dir, parent, .default_dir, .{}) catch |err| return createFileAtomicDirError(err)
+        else
+            dirOpenDir(userdata, dir, parent, .{}) catch |err| return createFileAtomicDirError(err);
+        close_target_dir = true;
+        dest_sub_path = std.fs.path.basename(sub_path);
+    } else if (opts.make_path) {
+        _ = opts.make_path;
+    }
+
+    var attempts: u8 = 0;
+    while (attempts < 16) : (attempts += 1) {
+        atomic_counter +%= 1;
+        const basename_hex = atomic_counter;
+        const tmp_sub_path = std.fmt.hex(basename_hex);
+        const file = dirCreateFile(userdata, target_dir, &tmp_sub_path, .{
+            .read = true,
+            .exclusive = true,
+            .permissions = opts.permissions,
+        }) catch |err| switch (err) {
+            error.PathAlreadyExists => continue,
+            error.FileTooBig, error.IsDir, error.DeviceBusy, error.FileLocksUnsupported, error.PipeBusy => return error.Unexpected,
+            else => |e| return @errorCast(e),
+        };
+        errdefer file.close(io());
+
+        const result: File.Atomic = .{
+            .file = file,
+            .file_basename_hex = basename_hex,
+            .file_open = true,
+            .file_exists = true,
+            .dir = target_dir,
+            .close_dir_on_deinit = close_target_dir,
+            .dest_sub_path = dest_sub_path,
+        };
+        close_target_dir = false;
+        return result;
+    }
+
+    return error.SystemResources;
+}
+
+fn dirClose(_: ?*anyopaque, dirs: []const Dir) void {
+    for (dirs) |dir| {
+        if (dirSlotIndex(dir)) |i| dir_slots[i].used = false;
+    }
+}
+
+fn dirRead(_: ?*anyopaque, reader: *Dir.Reader, out: []Dir.Entry) Dir.Reader.Error!usize {
+    const Header = extern struct {
+        pos: c_long,
+    };
+    const header_end = @sizeOf(Header);
+    if (reader.index < header_end) {
+        reader.index = header_end;
+        reader.end = header_end;
+        const header: *Header = @ptrCast(@alignCast(reader.buffer.ptr));
+        header.* = .{ .pos = 0 };
+    }
+
+    const header: *Header = @ptrCast(@alignCast(reader.buffer.ptr));
+    if (reader.state == .reset) {
+        header.pos = 0;
+        reader.state = .reading;
+    }
+    if (reader.state == .finished) return 0;
+
+    var path_buffer: [max_path_bytes:0]u8 = undefined;
+    const root = dirRoot(reader.dir);
+    const path = zPath(&path_buffer, if (root.len == 0) "." else root) catch return error.Unexpected;
+    const stream = c.opendir(path.ptr) orelse return dirReadError(errno());
+    var stream_open = true;
+    defer if (stream_open) {
+        _ = c.closedir(stream);
+    };
+
+    const use_direct_dirnext = options.config.platform == .nintendo_3ds;
+    if (!use_direct_dirnext) c.seekdir(stream, header.pos);
+
+    const dir_dev = if (use_direct_dirnext) c.devoptab_list[@intCast(stream.*.dirData.*.device)] else null;
+    const dirnext = if (use_direct_dirnext) dir_dev.*.dirnext_r.? else {};
+    const reent = if (use_direct_dirnext) c.__syscall_getreent() else {};
+    var direct_name: [Dir.max_name_bytes + 1]u8 = @splat(0);
+    var direct_stat: c.struct_stat = undefined;
+    if (use_direct_dirnext) {
+        var skipped: c_long = 0;
+        while (skipped < header.pos) : (skipped += 1) {
+            if (dirnext(reent, stream.*.dirData, &direct_name, &direct_stat) != 0) {
+                reader.state = .finished;
+                return 0;
+            }
+        }
+    }
+
+    var count: usize = 0;
+    var name_end = reader.buffer.len;
+    while (count < out.len) {
+        const name, const kind, const inode = if (use_direct_dirnext) direct: {
+            @memset(&direct_name, 0);
+            direct_stat = undefined;
+            if (dirnext(reent, stream.*.dirData, &direct_name, &direct_stat) != 0) {
+                reader.state = .finished;
+                return count;
+            }
+            header.pos += 1;
+            const name = std.mem.span(@as([*:0]const u8, @ptrCast(&direct_name)));
+            break :direct .{ name, statKind(direct_stat.st_mode), @as(File.INode, @intCast(direct_stat.st_ino)) };
+        } else libc: {
+            c.__errno().* = 0;
+            const entry = c.readdir(stream) orelse {
+                if (errno() != 0) return dirReadError(errno());
+                reader.state = .finished;
+                return count;
+            };
+            header.pos = c.telldir(stream);
+            const name = std.mem.span(@as([*:0]const u8, @ptrCast(&entry.*.d_name)));
+            break :libc .{ name, direntKind(entry.*.d_type), @as(File.INode, @intCast(entry.*.d_ino)) };
+        };
+        if (std.mem.eql(u8, name, ".") or std.mem.eql(u8, name, "..")) continue;
+        if (name.len + 1 > name_end - header_end) {
+            if (count == 0) return error.Unexpected;
+            break;
+        }
+
+        name_end -= name.len + 1;
+        @memcpy(reader.buffer[name_end..][0..name.len], name);
+        reader.buffer[name_end + name.len] = 0;
+        out[count] = .{
+            .name = reader.buffer[name_end .. name_end + name.len],
+            .kind = kind,
+            .inode = inode,
+        };
+        count += 1;
+    }
+
+    stream_open = false;
+    _ = c.closedir(stream);
+    return count;
+}
+
+fn dirDeleteFile(_: ?*anyopaque, dir: Dir, sub_path: []const u8) Dir.DeleteFileError!void {
+    var path_buffer: [max_path_bytes:0]u8 = undefined;
+    const path = try rootedPathForDir(&path_buffer, dir, sub_path);
+    if (c.unlink(path.ptr) == 0) return;
+    return deleteFileError(errno());
+}
+
+fn dirDeleteDir(_: ?*anyopaque, dir: Dir, sub_path: []const u8) Dir.DeleteDirError!void {
+    var path_buffer: [max_path_bytes:0]u8 = undefined;
+    const path = try rootedPathForDir(&path_buffer, dir, sub_path);
+    if (c.rmdir(path.ptr) == 0) return;
+    return deleteDirError(errno());
+}
+
+fn dirRename(
+    _: ?*anyopaque,
+    old_dir: Dir,
+    old_sub_path: []const u8,
+    new_dir: Dir,
+    new_sub_path: []const u8,
+) Dir.RenameError!void {
+    var old_path_buffer: [max_path_bytes:0]u8 = undefined;
+    var new_path_buffer: [max_path_bytes:0]u8 = undefined;
+    const old_path = try rootedPathForDir(&old_path_buffer, old_dir, old_sub_path);
+    const new_path = try rootedPathForDir(&new_path_buffer, new_dir, new_sub_path);
+    if (c.rename(old_path.ptr, new_path.ptr) == 0) return;
+    return renameError(errno());
+}
+
+fn dirRenamePreserve(
+    userdata: ?*anyopaque,
+    old_dir: Dir,
+    old_sub_path: []const u8,
+    new_dir: Dir,
+    new_sub_path: []const u8,
+) Dir.RenamePreserveError!void {
+    dirAccess(userdata, new_dir, new_sub_path, .{}) catch |err| switch (err) {
+        error.FileNotFound => {},
+        else => |e| return @errorCast(e),
+    };
+    if (dirAccess(userdata, new_dir, new_sub_path, .{})) |_| return error.PathAlreadyExists else |err| switch (err) {
+        error.FileNotFound => {},
+        else => |e| return @errorCast(e),
+    }
+    return dirRename(userdata, old_dir, old_sub_path, new_dir, new_sub_path) catch |err| switch (err) {
+        error.DiskQuota, error.IsDir, error.LinkQuotaExceeded, error.NoDevice, error.PipeBusy, error.AntivirusInterference, error.HardwareFailure => return error.Unexpected,
+        else => |e| return @errorCast(e),
+    };
+}
+
+fn fileStat(_: ?*anyopaque, file: File) File.StatError!File.Stat {
+    return .{
+        .inode = zero(File.INode),
+        .nlink = zero(File.NLink),
+        .size = try fileLength(null, file),
+        .permissions = .default_file,
+        .kind = .file,
+        .atime = null,
+        .mtime = now(null, .real),
+        .ctime = now(null, .real),
+        .block_size = 1,
+    };
+}
+
+fn fileLength(_: ?*anyopaque, file: File) File.LengthError!u64 {
+    const fd = fdForRegular(file);
+    const current = c.lseek(fd, 0, SEEK_CUR);
+    if (current < 0) return seekToLengthError();
+    const end = c.lseek(fd, 0, SEEK_END);
+    if (end < 0) return seekToLengthError();
+    _ = c.lseek(fd, current, SEEK_SET);
+    return @intCast(end);
+}
+
+fn fileClose(_: ?*anyopaque, files: []const File) void {
+    for (files) |file| {
+        if (isStderrFile(file)) continue;
+        if (@sizeOf(File.Handle) != 0) {
+            const fd = fdFromFileHandle(file);
+            if (fd > 2) _ = c.close(fd);
+            continue;
+        }
+        if (read_fd >= 0 and read_fd == write_fd) {
+            _ = c.close(read_fd);
+            read_fd = -1;
+            write_fd = -1;
+        } else if (read_fd >= 0) {
+            _ = c.close(read_fd);
+            read_fd = -1;
+        } else if (write_fd >= 0) {
+            _ = c.close(write_fd);
+            write_fd = -1;
+        }
+    }
+}
+
+fn fileReadPositional(
+    _: ?*anyopaque,
+    file: File,
+    data: []const []u8,
+    offset: u64,
+) File.ReadPositionalError!usize {
+    const fd = fdForRead(file);
+    try seekToOffset(fd, offset);
+
+    var total: usize = 0;
+    for (data) |buf| {
+        var remaining = buf;
+        while (remaining.len > 0) {
+            const n = c.read(fd, remaining.ptr, remaining.len);
+            if (n < 0) return readError();
+            if (n == 0) return total;
+            const amt: usize = @intCast(n);
+            total += amt;
+            remaining = remaining[amt..];
+            if (amt == 0) return total;
+        }
+    }
+    return total;
+}
+
+fn fileReadStreaming(file: File, data: []const []u8) Io.Operation.FileReadStreaming.Result {
+    const fd = fdForRead(file);
+    var total: usize = 0;
+    for (data) |buf| {
+        var remaining = buf;
+        while (remaining.len > 0) {
+            const n = c.read(fd, remaining.ptr, remaining.len);
+            if (n < 0) return readStreamingError();
+            if (n == 0) return if (total == 0) error.EndOfStream else total;
+            const amt: usize = @intCast(n);
+            total += amt;
+            remaining = remaining[amt..];
+        }
+    }
+    return total;
+}
+
+fn fileWritePositional(
+    _: ?*anyopaque,
+    file: File,
+    header: []const u8,
+    data: []const []const u8,
+    splat: usize,
+    offset: u64,
+) File.WritePositionalError!usize {
+    const fd = fdForWrite(file);
+    try seekToOffset(fd, offset);
+    return writeVectors(fd, header, data, splat);
+}
+
+fn fileWriteStreaming(file: File, header: []const u8, data: []const []const u8, splat: usize) Io.Operation.FileWriteStreaming.Result {
+    return writeVectors(fdForWrite(file), header, data, splat) catch |err| switch (err) {
+        error.Canceled => unreachable,
+        error.Unseekable => error.InputOutput,
+        else => |e| @errorCast(e),
+    };
+}
+
+fn fileSeekBy(_: ?*anyopaque, file: File, relative_offset: i64) File.SeekError!void {
+    if (c.lseek(fdForRegular(file), @intCast(relative_offset), SEEK_CUR) < 0) return seekError();
+}
+
+fn fileSeekTo(_: ?*anyopaque, file: File, absolute_offset: u64) File.SeekError!void {
+    try seekToOffset(fdForRegular(file), absolute_offset);
+}
+
+fn fileSync(_: ?*anyopaque, file: File) File.SyncError!void {
+    if (isStderrFile(file)) return;
+    if (c.fsync(fdForRegular(file)) < 0) return syncError();
+}
+
+fn fileIsTty(_: ?*anyopaque, _: File) Io.Cancelable!bool {
+    return false;
+}
+
+fn fileEnableAnsiEscapeCodes(_: ?*anyopaque, _: File) File.EnableAnsiEscapeCodesError!void {
+    return error.NotTerminalDevice;
+}
+
+fn fileSupportsAnsiEscapeCodes(_: ?*anyopaque, _: File) Io.Cancelable!bool {
+    return false;
+}
+
+fn fileSetLength(_: ?*anyopaque, file: File, length: u64) File.SetLengthError!void {
+    if (length > std.math.maxInt(c.off_t)) return error.FileTooBig;
+    if (c.ftruncate(fdForRegular(file), @intCast(length)) < 0) return setLengthError();
+}
+
+fn lockStderr(_: ?*anyopaque, terminal_mode: ?Io.Terminal.Mode) Io.Cancelable!Io.LockedStderr {
+    if (!stderr_writer_initialized) {
+        var stderr_file: File = .{
+            .handle = if (@sizeOf(File.Handle) == 0) {} else @as(File.Handle, @intCast(2)),
+            .flags = .{ .nonblocking = true },
+        };
+        stderr_file.flags.nonblocking = true;
+        stderr_writer = stderr_file.writerStreaming(io(), &empty_stderr_buffer);
+        stderr_writer_initialized = true;
+    }
+    return .{
+        .file_writer = &stderr_writer,
+        .terminal_mode = terminal_mode orelse .no_color,
+    };
+}
+
+fn tryLockStderr(userdata: ?*anyopaque, terminal_mode: ?Io.Terminal.Mode) Io.Cancelable!?Io.LockedStderr {
+    return try lockStderr(userdata, terminal_mode);
+}
+
+fn unlockStderr(_: ?*anyopaque) void {
+    if (stderr_writer_initialized) stderr_writer.interface.flush() catch {};
+}
+
+fn processCurrentPath(_: ?*anyopaque, buffer: []u8) std.process.CurrentPathError!usize {
+    if (buffer.len == 0) return error.NameTooLong;
+    const ptr = c.getcwd(buffer.ptr, buffer.len) orelse return currentPathError();
+    _ = ptr;
+    return std.mem.indexOfScalar(u8, buffer, 0) orelse error.NameTooLong;
+}
+
+fn processSetCurrentPath(_: ?*anyopaque, path: []const u8) std.process.SetCurrentPathError!void {
+    var path_buffer: [max_path_bytes:0]u8 = undefined;
+    const z = zPath(&path_buffer, path) catch |err| switch (err) {
+        error.NameTooLong => return error.NameTooLong,
+        error.BadPathName => return error.BadPathName,
+    };
+    if (c.chdir(z.ptr) < 0) return setCurrentPathError();
+}
+
+fn now(_: ?*anyopaque, clock: Io.Clock) Io.Timestamp {
+    return platform_time.now(clock);
+}
+
+fn clockResolution(_: ?*anyopaque, clock: Io.Clock) Io.Clock.ResolutionError!Io.Duration {
+    return platform_time.clockResolution(clock);
+}
+
+fn sleep(_: ?*anyopaque, timeout: Io.Timeout) Io.Cancelable!void {
+    return platform_time.sleep(timeout);
+}
+
+fn random(_: ?*anyopaque, buffer: []u8) void {
+    @memset(buffer, 0);
+}
+
+const FileRole = enum { read, write, read_write };
+
+fn createDirPathAt(dir: Dir, sub_path: []const u8, permissions: Dir.Permissions) Dir.CreateDirPathError!Dir.CreatePathStatus {
+    if (sub_path.len == 0) return error.BadPathName;
+
+    var path_buffer: [max_path_bytes:0]u8 = undefined;
+    const full = rootedPathForDir(&path_buffer, dir, sub_path) catch |err| return err;
+    const full_len = full.len;
+    const full_ptr = path_buffer[0..].ptr;
+    const mode = permissionsMode(permissions, 0o777);
+
+    var status: Dir.CreatePathStatus = .existed;
+    const start = pathRootEnd(full);
+    var i = start;
+    while (i < full_len) : (i += 1) {
+        if (path_buffer[i] != '/') continue;
+        if (i == start) continue;
+        path_buffer[i] = 0;
+        if (try createSingleDirPath(full_ptr, mode) == .created) status = .created;
+        path_buffer[i] = '/';
+    }
+    if (try createSingleDirPath(full_ptr, mode) == .created) status = .created;
+    return status;
+}
+
+fn createSingleDirPath(path: [*:0]const u8, mode: c.mode_t) Dir.CreateDirPathError!Dir.CreatePathStatus {
+    if (c.mkdir(path, mode) == 0) return .created;
+    switch (errno()) {
+        17 => return .existed,
+        1 => return error.PermissionDenied,
+        2 => return error.FileNotFound,
+        6 => return error.NoDevice,
+        12 => return error.SystemResources,
+        13 => return error.AccessDenied,
+        20 => return error.NotDir,
+        28 => return error.NoSpaceLeft,
+        30 => return error.ReadOnlyFileSystem,
+        91 => return error.NameTooLong,
+        92 => return error.SymLinkLoop,
+        else => return error.Unexpected,
+    }
+}
+
+fn registerFile(fd: c_int, role: FileRole) File {
+    if (@sizeOf(File.Handle) == 0) {
+        switch (role) {
+            .read => {
+                if (read_fd >= 0) unsupported("more than one regular read file");
+                read_fd = fd;
+            },
+            .write => {
+                if (write_fd >= 0) unsupported("more than one regular write file");
+                write_fd = fd;
+            },
+            .read_write => {
+                if (read_fd >= 0) unsupported("more than one regular read file");
+                if (write_fd >= 0) unsupported("more than one regular write file");
+                read_fd = fd;
+                write_fd = fd;
+            },
+        }
+        return .{ .handle = {}, .flags = .{ .nonblocking = false } };
+    }
+    return .{
+        .handle = @intCast(fd),
+        .flags = .{ .nonblocking = false },
+    };
+}
+
+fn fdForRead(file: File) c_int {
+    if (@sizeOf(File.Handle) != 0) return fdFromFileHandle(file);
+    if (read_fd < 0) unsupported("read from unopened regular file");
+    return read_fd;
+}
+
+fn fdForWrite(file: File) c_int {
+    if (isStderrFile(file)) return 2;
+    if (@sizeOf(File.Handle) != 0) return fdFromFileHandle(file);
+    if (write_fd < 0) unsupported("write to unopened regular file");
+    return write_fd;
+}
+
+fn fdForRegular(file: File) c_int {
+    if (isStderrFile(file)) unsupported("regular file operation on stderr");
+    if (@sizeOf(File.Handle) != 0) return fdFromFileHandle(file);
+    if (read_fd >= 0) return read_fd;
+    if (write_fd >= 0) return write_fd;
+    unsupported("regular file operation with no open file");
+}
+
+fn fdFromFileHandle(file: File) c_int {
+    return @intCast(file.handle);
+}
+
+fn fdFromDirHandle(dir: Dir) c_int {
+    return @intCast(dir.handle);
+}
+
+fn permissionsMode(permissions: File.Permissions, default: c.mode_t) c.mode_t {
+    if (@bitSizeOf(File.Permissions) == 0) return default;
+    return @intCast(@intFromEnum(permissions));
+}
+
+fn isStderrFile(file: File) bool {
+    return file.flags.nonblocking;
+}
+
+fn registerDir(path: []const u8) Dir.OpenError!Dir {
+    for (&dir_slots, 0..) |*slot, i| {
+        if (slot.used) continue;
+        if (path.len >= max_path_bytes) return error.NameTooLong;
+        @memcpy(slot.path[0..path.len], path);
+        slot.path[path.len] = 0;
+        slot.len = path.len;
+        slot.used = true;
+        return .{ .handle = @intCast(i + 3) };
+    }
+    return error.SystemResources;
+}
+
+fn dirSlotIndex(dir: Dir) ?usize {
+    const handle = fdFromDirHandle(dir);
+    if (handle < 3) return null;
+    const index: usize = @intCast(handle - 3);
+    if (index >= dir_slots.len or !dir_slots[index].used) return null;
+    return index;
+}
+
+fn dirRoot(dir: Dir) []const u8 {
+    if (fdFromDirHandle(dir) == AT_FDCWD) return "";
+    const index = dirSlotIndex(dir) orelse unsupported("closed Nintendo dir handle");
+    return dir_slots[index].path[0..dir_slots[index].len];
+}
+
+fn rootedPath(buf: *[max_path_bytes:0]u8, path: []const u8, root: []const u8) error{ NameTooLong, BadPathName }![:0]const u8 {
+    if (isAbsoluteOrDevicePath(path) or root.len == 0) return zPath(buf, path);
+    if (std.mem.indexOfScalar(u8, path, 0) != null) return error.BadPathName;
+
+    const needs_sep = !std.mem.endsWith(u8, root, "/") and !std.mem.startsWith(u8, path, "/");
+    const len = root.len + @intFromBool(needs_sep) + path.len;
+    if (len >= max_path_bytes) return error.NameTooLong;
+
+    var i: usize = 0;
+    @memcpy(buf[i..][0..root.len], root);
+    i += root.len;
+    if (needs_sep) {
+        buf[i] = '/';
+        i += 1;
+    }
+    @memcpy(buf[i..][0..path.len], path);
+    buf[len] = 0;
+    return buf[0..len :0];
+}
+
+fn rootedPathForDir(buf: *[max_path_bytes:0]u8, dir: Dir, path: []const u8) error{ NameTooLong, BadPathName }![:0]const u8 {
+    return rootedPath(buf, path, dirRoot(dir));
+}
+
+fn direntKind(kind: u8) File.Kind {
+    return switch (kind) {
+        DT_BLK => .block_device,
+        DT_CHR => .character_device,
+        DT_DIR => .directory,
+        DT_FIFO => .named_pipe,
+        DT_LNK => .sym_link,
+        DT_REG => .file,
+        DT_SOCK => .unix_domain_socket,
+        DT_WHT => .whiteout,
+        else => .unknown,
+    };
+}
+
+fn statKind(mode: c.mode_t) File.Kind {
+    if (c.S_ISBLK(mode)) return .block_device;
+    if (c.S_ISCHR(mode)) return .character_device;
+    if (c.S_ISDIR(mode)) return .directory;
+    if (c.S_ISFIFO(mode)) return .named_pipe;
+    if (c.S_ISLNK(mode)) return .sym_link;
+    if (c.S_ISREG(mode)) return .file;
+    if (c.S_ISSOCK(mode)) return .unix_domain_socket;
+    return .unknown;
+}
+
+fn seekToOffset(fd: c_int, offset: u64) File.SeekError!void {
+    if (offset > std.math.maxInt(c.off_t)) return error.Unseekable;
+    if (c.lseek(fd, @intCast(offset), SEEK_SET) < 0) return seekError();
+}
+
+fn writeVectors(fd: c_int, header: []const u8, data: []const []const u8, splat: usize) File.WritePositionalError!usize {
+    var total: usize = 0;
+    total += try writeOne(fd, header);
+    for (0..splat) |_| {
+        for (data) |buf| {
+            total += try writeOne(fd, buf);
+        }
+    }
+    return total;
+}
+
+fn writeOne(fd: c_int, bytes: []const u8) File.WritePositionalError!usize {
+    var remaining = bytes;
+    var total: usize = 0;
+    while (remaining.len > 0) {
+        const n = c.write(fd, remaining.ptr, remaining.len);
+        if (n < 0) return writeError();
+        if (n == 0) return total;
+        const amt: usize = @intCast(n);
+        total += amt;
+        remaining = remaining[amt..];
+    }
+    return total;
+}
+
+fn zPath(buf: *[max_path_bytes:0]u8, path: []const u8) error{ NameTooLong, BadPathName }![:0]const u8 {
+    if (path.len >= max_path_bytes) return error.NameTooLong;
+    if (std.mem.indexOfScalar(u8, path, 0) != null) return error.BadPathName;
+    @memcpy(buf[0..path.len], path);
+    buf[path.len] = 0;
+    return buf[0..path.len :0];
+}
+
+fn isAbsoluteOrDevicePath(path: []const u8) bool {
+    if (path.len == 0) return false;
+    if (path[0] == '/') return true;
+    const colon = std.mem.indexOfScalar(u8, path, ':') orelse return false;
+    const slash = std.mem.indexOfAny(u8, path, "/\\") orelse path.len;
+    return colon < slash;
+}
+
+fn pathRootEnd(path: []const u8) usize {
+    if (std.mem.indexOfScalar(u8, path, ':')) |colon| {
+        if (colon + 1 < path.len and path[colon + 1] == '/') return colon + 2;
+        return colon + 1;
+    }
+    return if (path.len > 0 and path[0] == '/') 1 else 0;
+}
+
+fn createFileAtomicDirError(err: anyerror) Dir.CreateFileAtomicError {
+    return switch (err) {
+        error.PathAlreadyExists, error.NotDir => error.NotDir,
+        error.FileTooBig, error.IsDir, error.DeviceBusy, error.FileLocksUnsupported => error.Unexpected,
+        else => @errorCast(err),
+    };
+}
+
+fn errno() c_int {
+    return c.__errno().*;
+}
+
+fn createDirError(code: c_int) Dir.CreateDirError {
+    return switch (code) {
+        1 => error.PermissionDenied,
+        2 => error.FileNotFound,
+        6 => error.NoDevice,
+        12 => error.SystemResources,
+        13 => error.AccessDenied,
+        17 => error.PathAlreadyExists,
+        20 => error.NotDir,
+        28 => error.NoSpaceLeft,
+        30 => error.ReadOnlyFileSystem,
+        91 => error.NameTooLong,
+        92 => error.SymLinkLoop,
+        else => error.Unexpected,
+    };
+}
+
+fn accessError(code: c_int) Dir.AccessError {
+    return switch (code) {
+        1 => error.PermissionDenied,
+        2 => error.FileNotFound,
+        5 => error.InputOutput,
+        12 => error.SystemResources,
+        13 => error.AccessDenied,
+        16 => error.FileBusy,
+        30 => error.ReadOnlyFileSystem,
+        91 => error.NameTooLong,
+        92 => error.SymLinkLoop,
+        else => error.Unexpected,
+    };
+}
+
+fn dirOpenError(code: c_int) Dir.OpenError {
+    return switch (code) {
+        1 => error.PermissionDenied,
+        2 => error.FileNotFound,
+        6 => error.NoDevice,
+        12 => error.SystemResources,
+        13 => error.AccessDenied,
+        20 => error.NotDir,
+        23 => error.ProcessFdQuotaExceeded,
+        24 => error.SystemFdQuotaExceeded,
+        91 => error.NameTooLong,
+        92 => error.SymLinkLoop,
+        else => error.Unexpected,
+    };
+}
+
+fn openError(code: c_int) File.OpenError {
+    return switch (code) {
+        1 => error.PermissionDenied,
+        2 => error.FileNotFound,
+        6 => error.NoDevice,
+        12 => error.SystemResources,
+        13 => error.AccessDenied,
+        16 => error.DeviceBusy,
+        17 => error.PathAlreadyExists,
+        20 => error.NotDir,
+        21 => error.IsDir,
+        23 => error.SystemFdQuotaExceeded,
+        24 => error.ProcessFdQuotaExceeded,
+        26 => error.FileBusy,
+        27 => error.FileTooBig,
+        28 => error.NoSpaceLeft,
+        30 => error.ReadOnlyFileSystem,
+        91 => error.NameTooLong,
+        92 => error.SymLinkLoop,
+        else => error.Unexpected,
+    };
+}
+
+fn deleteFileError(code: c_int) Dir.DeleteFileError {
+    return switch (code) {
+        1 => error.PermissionDenied,
+        2 => error.FileNotFound,
+        12 => error.SystemResources,
+        13 => error.AccessDenied,
+        16 => error.FileBusy,
+        20 => error.NotDir,
+        21 => error.IsDir,
+        30 => error.ReadOnlyFileSystem,
+        91 => error.NameTooLong,
+        92 => error.SymLinkLoop,
+        else => error.Unexpected,
+    };
+}
+
+fn deleteDirError(code: c_int) Dir.DeleteDirError {
+    return switch (code) {
+        1 => error.PermissionDenied,
+        2 => error.FileNotFound,
+        12 => error.SystemResources,
+        13 => error.AccessDenied,
+        16 => error.FileBusy,
+        20 => error.NotDir,
+        30 => error.ReadOnlyFileSystem,
+        39 => error.DirNotEmpty,
+        91 => error.NameTooLong,
+        92 => error.SymLinkLoop,
+        else => error.Unexpected,
+    };
+}
+
+fn renameError(code: c_int) Dir.RenameError {
+    return switch (code) {
+        1 => error.PermissionDenied,
+        2 => error.FileNotFound,
+        5 => error.HardwareFailure,
+        6 => error.NoDevice,
+        12 => error.SystemResources,
+        13 => error.AccessDenied,
+        16 => error.FileBusy,
+        18 => error.CrossDevice,
+        20 => error.NotDir,
+        21 => error.IsDir,
+        28 => error.NoSpaceLeft,
+        30 => error.ReadOnlyFileSystem,
+        39 => error.DirNotEmpty,
+        91 => error.NameTooLong,
+        92 => error.SymLinkLoop,
+        else => error.Unexpected,
+    };
+}
+
+fn readError() File.ReadPositionalError {
+    return switch (errno()) {
+        5 => error.InputOutput,
+        11 => error.WouldBlock,
+        12 => error.SystemResources,
+        13 => error.AccessDenied,
+        21 => error.IsDir,
+        29 => error.Unseekable,
+        else => error.Unexpected,
+    };
+}
+
+fn readStreamingError() Io.Operation.FileReadStreaming.Error {
+    return switch (errno()) {
+        5 => error.InputOutput,
+        11 => error.WouldBlock,
+        12 => error.SystemResources,
+        13 => error.AccessDenied,
+        21 => error.IsDir,
+        else => error.Unexpected,
+    };
+}
+
+fn dirReadError(code: c_int) Dir.Reader.Error {
+    return switch (code) {
+        1 => error.PermissionDenied,
+        12 => error.SystemResources,
+        13 => error.AccessDenied,
+        else => error.Unexpected,
+    };
+}
+
+fn writeError() File.WritePositionalError {
+    return switch (errno()) {
+        5 => error.InputOutput,
+        6 => error.NoDevice,
+        11 => error.WouldBlock,
+        12 => error.SystemResources,
+        13 => error.AccessDenied,
+        27 => error.FileTooBig,
+        28 => error.NoSpaceLeft,
+        29 => error.Unseekable,
+        32 => error.BrokenPipe,
+        else => error.Unexpected,
+    };
+}
+
+fn seekError() File.SeekError {
+    return switch (errno()) {
+        13 => error.AccessDenied,
+        29 => error.Unseekable,
+        else => error.Unexpected,
+    };
+}
+
+fn seekToLengthError() File.LengthError {
+    return switch (errno()) {
+        5 => error.Unexpected,
+        13 => error.AccessDenied,
+        29 => error.Streaming,
+        else => error.Unexpected,
+    };
+}
+
+fn syncError() File.SyncError {
+    return switch (errno()) {
+        5 => error.InputOutput,
+        12 => error.Unexpected,
+        13 => error.AccessDenied,
+        28 => error.NoSpaceLeft,
+        132 => error.DiskQuota,
+        else => error.Unexpected,
+    };
+}
+
+fn setLengthError() File.SetLengthError {
+    return switch (errno()) {
+        5 => error.InputOutput,
+        13 => error.AccessDenied,
+        16 => error.FileBusy,
+        27 => error.FileTooBig,
+        29 => error.NonResizable,
+        else => error.Unexpected,
+    };
+}
+
+fn currentPathError() std.process.CurrentPathError {
+    return switch (errno()) {
+        12 => error.Unexpected,
+        91 => error.NameTooLong,
+        else => error.CurrentDirUnlinked,
+    };
+}
+
+fn setCurrentPathError() std.process.SetCurrentPathError {
+    return switch (errno()) {
+        2 => error.FileNotFound,
+        13 => error.AccessDenied,
+        20 => error.NotDir,
+        91 => error.NameTooLong,
+        else => error.Unexpected,
+    };
+}
+
+fn zero(comptime T: type) T {
+    return switch (@typeInfo(T)) {
+        .void => {},
+        .int, .comptime_int => 0,
+        else => @as(T, @intCast(0)),
+    };
+}
+
+fn unsupported(comptime name: []const u8) noreturn {
+    std.debug.panic("c std.Io baseline does not implement {s}", .{name});
+}
diff --git a/src/platform/c_process_init.zig b/src/platform/c_process_init.zig
new file mode 100644
index 0000000..9c1378f
--- /dev/null
+++ b/src/platform/c_process_init.zig
@@ -0,0 +1,105 @@
+const std = @import("std");
+const c_io = @import("c_io.zig");
+const c = @import("nintendo_c.zig").c;
+const options = @import("options");
+
+const ProcessHeap = if (options.config.platform == .nintendo_3ds) struct {
+    fn alloc(alignment: usize, size: usize) ?*anyopaque {
+        return c.linearMemAlign(size, alignment);
+    }
+
+    fn free(ptr: ?*anyopaque) void {
+        c.linearFree(ptr);
+    }
+} else struct {
+    fn alloc(alignment: usize, size: usize) ?*anyopaque {
+        return c.memalign(alignment, size);
+    }
+
+    fn free(ptr: ?*anyopaque) void {
+        c.free(ptr);
+    }
+};
+
+var arena_state: std.heap.ArenaAllocator = undefined;
+var environ_map_state: std.process.Environ.Map = undefined;
+
+const allocator_vtable: std.mem.Allocator.VTable = .{
+    .alloc = alloc,
+    .resize = resize,
+    .remap = remap,
+    .free = dealloc,
+};
+
+pub fn makeInit(args: std.process.Args) std.process.Init {
+    const gpa = allocator();
+    arena_state = std.heap.ArenaAllocator.init(gpa);
+    environ_map_state = std.process.Environ.Map.init(gpa);
+
+    return .{
+        .minimal = .{
+            .environ = std.process.Environ.empty,
+            .args = args,
+        },
+        .arena = &arena_state,
+        .gpa = gpa,
+        .io = c_io.io(),
+        .environ_map = &environ_map_state,
+        .preopens = std.process.Preopens.empty,
+    };
+}
+
+fn allocator() std.mem.Allocator {
+    return .{
+        .ptr = undefined,
+        .vtable = &allocator_vtable,
+    };
+}
+
+fn alloc(
+    _: *anyopaque,
+    len: usize,
+    alignment: std.mem.Alignment,
+    _: usize,
+) ?[*]u8 {
+    std.debug.assert(len > 0);
+
+    const effective_alignment = @max(alignment.toByteUnits(), @sizeOf(usize));
+    const ptr = ProcessHeap.alloc(effective_alignment, len) orelse return null;
+    std.debug.assert(alignment.check(@intFromPtr(ptr)));
+    return @ptrCast(ptr);
+}
+
+fn resize(
+    _: *anyopaque,
+    memory: []u8,
+    _: std.mem.Alignment,
+    new_len: usize,
+    _: usize,
+) bool {
+    std.debug.assert(memory.len > 0);
+    std.debug.assert(new_len > 0);
+    return new_len <= memory.len;
+}
+
+fn remap(
+    _: *anyopaque,
+    memory: []u8,
+    _: std.mem.Alignment,
+    new_len: usize,
+    _: usize,
+) ?[*]u8 {
+    std.debug.assert(memory.len > 0);
+    std.debug.assert(new_len > 0);
+    return if (new_len <= memory.len) memory.ptr else null;
+}
+
+fn dealloc(
+    _: *anyopaque,
+    memory: []u8,
+    _: std.mem.Alignment,
+    _: usize,
+) void {
+    std.debug.assert(memory.len > 0);
+    ProcessHeap.free(memory.ptr);
+}
diff --git a/src/platform/gfx.zig b/src/platform/gfx.zig
index 411938b..439acd6 100644
--- a/src/platform/gfx.zig
+++ b/src/platform/gfx.zig
@@ -10,9 +10,17 @@ const surface_iface = @import("surface.zig");
 /// `gfx.api.start_frame()` resolve to direct function calls with no
 /// indirection.
 pub const Api = switch (options.config.gfx) {
-    .default => @import("psp/psp_gfx_ge.zig"),
+    .default => if (builtin.os.tag == .@"3ds")
+        @import("3ds/3ds_gfx.zig")
+    else if (options.config.platform == .nintendo_switch)
+        @import("switch/switch_gfx.zig")
+    else if (options.config.platform == .wasm)
+        @import("wasm/webgl_gfx.zig")
+    else
+        @import("psp/psp_gfx_ge.zig"),
     .opengl => @import("glfw/opengl/opengl_gfx.zig"),
     .vulkan => @import("glfw/vulkan/vulkan_gfx.zig"),
+    .webgl => @import("wasm/webgl_gfx.zig"),
     .headless => @import("headless/headless_gfx.zig"),
 };
 
@@ -22,6 +30,12 @@ pub const Surface = if (options.config.gfx == .headless)
     @import("headless/surface.zig")
 else if (builtin.os.tag == .psp)
     @import("psp/surface.zig")
+else if (builtin.os.tag == .@"3ds")
+    @import("3ds/surface.zig")
+else if (options.config.platform == .nintendo_switch)
+    @import("switch/surface.zig")
+else if (options.config.platform == .wasm)
+    @import("wasm/surface.zig")
 else
     @import("glfw/surface.zig");
 
diff --git a/src/platform/gfx_api.zig b/src/platform/gfx_api.zig
index 0758e0c..0f84f5c 100644
--- a/src/platform/gfx_api.zig
+++ b/src/platform/gfx_api.zig
@@ -1,7 +1,6 @@
 const std = @import("std");
 const Mat4 = @import("../math/math.zig").Mat4;
 const Rendering = @import("../rendering/rendering.zig");
-const Pipeline = Rendering.Pipeline;
 const Mesh = Rendering.mesh;
 const Texture = Rendering.Texture;
 
@@ -31,14 +30,10 @@ pub const Interface = struct {
 
     set_vsync: fn (bool) void,
 
-    create_pipeline: fn (Pipeline.VertexLayout, ?[:0]align(4) const u8, ?[:0]align(4) const u8) anyerror!Pipeline.Handle,
-    destroy_pipeline: fn (Pipeline.Handle) void,
-    bind_pipeline: fn (Pipeline.Handle) void,
-
-    create_mesh: fn (Pipeline.Handle) anyerror!Mesh.Handle,
+    create_mesh: fn () anyerror!Mesh.Handle,
     destroy_mesh: fn (Mesh.Handle) void,
     update_mesh: fn (Mesh.Handle, []const u8) void,
-    draw_mesh: fn (Mesh.Handle, *const Mat4, usize, Mesh.Primitive) void,
+    draw_mesh: fn (Mesh.Handle, *const Mat4, usize) void,
 
     create_texture: fn (u32, u32, []align(16) u8) anyerror!Texture.Handle,
     update_texture: fn (Texture.Handle, []align(16) u8) void,
diff --git a/src/platform/glfw/audio.zig b/src/platform/glfw/audio.zig
index f0bbe09..cb75750 100644
--- a/src/platform/glfw/audio.zig
+++ b/src/platform/glfw/audio.zig
@@ -1,17 +1,19 @@
-//! Desktop audio backend -- uses zaudio (miniaudio) with a low-level device
+//! Desktop audio backend -- uses SDL3 audio with an on-demand stream
 //! callback. The audio thread pulls PCM from each slot's Stream reader,
-//! converts to float32 stereo, applies gain/pan from the mixer, and writes
-//! to the output device.
+//! converts to float32 stereo, applies gain/pan from the mixer, and queues
+//! mixed frames to SDL.
 
 const std = @import("std");
-const zaudio = @import("zaudio");
+const sdl3 = @import("sdl3");
 const Stream = @import("../../audio/stream.zig").Stream;
 const PcmFormat = @import("../../audio/stream.zig").PcmFormat;
 
-const DEVICE_SAMPLE_RATE: u32 = 44_100;
-const DEVICE_CHANNELS: u32 = 2;
+const SDL_AUDIO_FLAGS = sdl3.InitFlags{ .audio = true };
+const DEVICE_SAMPLE_RATE: usize = 44_100;
+const DEVICE_CHANNELS: usize = 2;
 const NUM_SLOTS: usize = 32;
-/// Maximum frames the device callback will request per invocation.
+const OUTPUT_FRAME_BYTES: usize = DEVICE_CHANNELS * @sizeOf(f32);
+/// Maximum frames mixed per callback chunk.
 const MAX_PERIOD_FRAMES: usize = 1024;
 /// Per-slot scratch buffer: room for MAX_PERIOD_FRAMES of stereo 32-bit PCM.
 const READ_BUF_SIZE: usize = MAX_PERIOD_FRAMES * 2 * 4;
@@ -48,35 +50,46 @@ fn init_slots() [NUM_SLOTS]Slot {
 
 // -- device ------------------------------------------------------------------
 
-var device: ?*zaudio.Device = null;
-var audio_alloc: std.mem.Allocator = undefined;
-var audio_io: std.Io = undefined;
+var device_stream: ?sdl3.audio.Stream = null;
+var sdl_audio_initialized = false;
+var output_buf: [MAX_PERIOD_FRAMES * DEVICE_CHANNELS]f32 = undefined;
 
-pub fn setup(alloc: std.mem.Allocator, io: std.Io) void {
-    audio_alloc = alloc;
-    audio_io = io;
-}
+pub fn setup(_: std.mem.Allocator, _: std.Io) void {}
 
 pub fn init() anyerror!void {
-    zaudio.init(audio_alloc);
+    try sdl3.init(SDL_AUDIO_FLAGS);
+    sdl_audio_initialized = true;
+    errdefer {
+        sdl3.quit(SDL_AUDIO_FLAGS);
+        sdl_audio_initialized = false;
+    }
 
-    var config = zaudio.Device.Config.init(.playback);
-    config.playback.format = .float32;
-    config.playback.channels = DEVICE_CHANNELS;
-    config.sample_rate = DEVICE_SAMPLE_RATE;
-    config.data_callback = data_callback;
+    const spec = sdl3.audio.Spec{
+        .format = .floating_32_bit,
+        .num_channels = DEVICE_CHANNELS,
+        .sample_rate = DEVICE_SAMPLE_RATE,
+    };
+
+    const stream = try sdl3.audio.Device.default_playback.openStream(spec, anyopaque, data_callback, null);
+    device_stream = stream;
+    errdefer {
+        stream.deinit();
+        device_stream = null;
+    }
 
-    device = try zaudio.Device.create(null, config);
-    try device.?.start();
+    try stream.resumeDevice();
 }
 
 pub fn deinit() void {
-    if (device) |d| {
-        d.stop() catch {};
-        d.destroy();
-        device = null;
+    if (device_stream) |stream| {
+        stream.pauseDevice() catch {};
+        stream.deinit();
+        device_stream = null;
+    }
+    if (sdl_audio_initialized) {
+        sdl3.quit(SDL_AUDIO_FLAGS);
+        sdl_audio_initialized = false;
     }
-    zaudio.deinit();
 }
 
 pub fn update() void {}
@@ -109,19 +122,33 @@ pub fn is_slot_active(slot: u8) bool {
     return state != .inactive and state != .finished;
 }
 
-// -- audio thread callback ---------------------------------------------------
+// -- audio stream callback ---------------------------------------------------
 
 fn data_callback(
-    _: *zaudio.Device,
-    raw_output: ?*anyopaque,
-    _: ?*const anyopaque,
-    frame_count: u32,
-) callconv(.c) void {
-    const out: [*]f32 = @ptrCast(@alignCast(raw_output orelse return));
-    const total_samples: usize = @as(usize, frame_count) * DEVICE_CHANNELS;
+    _: ?*anyopaque,
+    stream: sdl3.audio.Stream,
+    additional_amount: usize,
+    _: usize,
+) void {
+    var bytes_remaining = additional_amount;
+    while (bytes_remaining > 0) {
+        const frames = @min(
+            MAX_PERIOD_FRAMES,
+            (bytes_remaining + OUTPUT_FRAME_BYTES - 1) / OUTPUT_FRAME_BYTES,
+        );
+        const out = output_buf[0 .. frames * DEVICE_CHANNELS];
+        fill_output(out, frames);
+
+        const bytes = std.mem.sliceAsBytes(out);
+        stream.putData(bytes) catch return;
+
+        if (bytes_remaining <= bytes.len) break;
+        bytes_remaining -= bytes.len;
+    }
+}
 
-    // Start with silence.
-    @memset(out[0..total_samples], 0);
+fn fill_output(out: []f32, frame_count: usize) void {
+    @memset(out, 0);
 
     for (&slots) |*slot| {
         const raw_state = slot.state.load(.acquire);
@@ -141,7 +168,7 @@ fn data_callback(
         const right_gain = gain * std.math.clamp(1.0 + pan, 0.0, 1.0);
 
         const fmt = slot.stream.format;
-        const bytes_needed: usize = @as(usize, frame_count) * fmt.frame_size();
+        const bytes_needed: usize = frame_count * @as(usize, fmt.frame_size());
 
         if (bytes_needed > READ_BUF_SIZE) {
             slot.state.store(@intFromEnum(SlotState.finished), .release);
@@ -171,24 +198,22 @@ fn read_f32(buf: []const u8, index: usize) f32 {
 }
 
 fn mix_into(
-    out: [*]f32,
+    out: []f32,
     buf: []const u8,
     fmt: PcmFormat,
-    frame_count: u32,
+    frame_count: usize,
     left_gain: f32,
     right_gain: f32,
 ) void {
-    const frames: usize = frame_count;
-
     if (fmt.bit_depth == 16) {
         if (fmt.channels == 1) {
-            for (0..frames) |f| {
+            for (0..frame_count) |f| {
                 const s = read_i16(buf, f);
                 out[f * 2] += s * left_gain;
                 out[f * 2 + 1] += s * right_gain;
             }
         } else {
-            for (0..frames) |f| {
+            for (0..frame_count) |f| {
                 const l = read_i16(buf, f * 2);
                 const r = read_i16(buf, f * 2 + 1);
                 out[f * 2] += l * left_gain;
@@ -197,13 +222,13 @@ fn mix_into(
         }
     } else if (fmt.bit_depth == 32) {
         if (fmt.channels == 1) {
-            for (0..frames) |f| {
+            for (0..frame_count) |f| {
                 const s = read_f32(buf, f);
                 out[f * 2] += s * left_gain;
                 out[f * 2 + 1] += s * right_gain;
             }
         } else {
-            for (0..frames) |f| {
+            for (0..frame_count) |f| {
                 out[f * 2] += read_f32(buf, f * 2) * left_gain;
                 out[f * 2 + 1] += read_f32(buf, f * 2 + 1) * right_gain;
             }
diff --git a/src/platform/glfw/input.zig b/src/platform/glfw/input.zig
index 0241174..ad332c7 100644
--- a/src/platform/glfw/input.zig
+++ b/src/platform/glfw/input.zig
@@ -148,7 +148,10 @@ export fn cursor_pos_callback(window: *glfw.Window, xpos: f64, ypos: f64) callco
     prev_cursor_x = xpos;
     prev_cursor_y = ypos;
     have_prev_cursor = true;
-    // GLFW gives window coords; rest of the engine works in framebuffer pixels.
+    // GLFW positions are window coordinates, while rendering/UI picking uses
+    // framebuffer pixels. Keep the absolute position scaled, but leave the
+    // relative delta in GLFW cursor-motion units so mouse-look is not warped
+    // or quantized by DPI/content-scale changes.
     var win_w: c_int = 0;
     var win_h: c_int = 0;
     var fb_w: c_int = 0;
@@ -159,7 +162,7 @@ export fn cursor_pos_callback(window: *glfw.Window, xpos: f64, ypos: f64) callco
     const sy = @as(f64, @floatFromInt(fb_h)) / @as(f64, @floatFromInt(win_h));
     core.deliver_mouse_move(
         .{ .x = @floatCast(xpos * sx), .y = @floatCast(ypos * sy) },
-        .{ .x = @floatCast(dx * sx), .y = @floatCast(dy * sy) },
+        .{ .x = @floatCast(dx), .y = @floatCast(dy) },
     );
 }
 
diff --git a/src/platform/glfw/opengl/opengl_gfx.zig b/src/platform/glfw/opengl/opengl_gfx.zig
index 2d8fcc1..5a4405d 100644
--- a/src/platform/glfw/opengl/opengl_gfx.zig
+++ b/src/platform/glfw/opengl/opengl_gfx.zig
@@ -1,17 +1,18 @@
 const std = @import("std");
-const Util = @import("../../../util/util.zig");
 const glfw = @import("glfw");
 const gl = @import("gl");
 const Mat4 = @import("../../../math/math.zig").Mat4;
+const Util = @import("../../../util/util.zig");
 
 const shader = @import("shader.zig");
 const gfx = @import("../../gfx.zig");
 
 const Rendering = @import("../../../rendering/rendering.zig");
 const Mesh = Rendering.mesh;
-const Pipeline = Rendering.Pipeline;
+const vertex = Rendering.vertex;
 const Texture = Rendering.Texture;
 const GLFWSurface = @import("../surface.zig");
+const shaders = @import("aether_shaders");
 
 var render_alloc: std.mem.Allocator = undefined;
 var render_io: std.Io = undefined;
@@ -24,19 +25,19 @@ pub fn setup(alloc: std.mem.Allocator, io: std.Io) void {
 var procs: gl.ProcTable = undefined;
 var last_width: u32 = 0;
 var last_height: u32 = 0;
-var pipelines = Util.CircularBuffer(PipelineData, 16).init();
 var meshes = Util.CircularBuffer(MeshInternal, 8192).init();
 var alpha_blend_enabled: bool = true;
 var cull_face_enabled: bool = true;
+var pipeline: PipelineData = undefined;
+var pipeline_initialized: bool = false;
 
 const PipelineData = struct {
-    layout: Pipeline.VertexLayout,
+    layout: vertex.VertexLayout,
     vao: gl.uint,
     program: shader.Shader,
 };
 
 const MeshInternal = struct {
-    pipeline: Pipeline.Handle,
     vbo: gl.uint,
 };
 
@@ -60,14 +61,21 @@ pub fn init() anyerror!void {
     gl.LineWidth(5.0);
 
     try shader.init();
+    errdefer shader.deinit();
+
     shader.state.proj = Mat4.identity();
     shader.state.view = Mat4.identity();
     shader.update_ubo();
 
+    pipeline = try init_pipeline(vertex.Layout);
+    pipeline_initialized = true;
 }
 
 pub fn deinit() void {
-
+    if (pipeline_initialized) {
+        deinit_pipeline(&pipeline);
+        pipeline_initialized = false;
+    }
     shader.deinit();
 
     gl.makeProcTableCurrent(null);
@@ -162,11 +170,7 @@ pub fn set_view_matrix(mat: *const Mat4) void {
     shader.update_ubo();
 }
 
-pub fn create_pipeline(layout: Pipeline.VertexLayout, v_shader: ?[:0]align(4) const u8, f_shader: ?[:0]align(4) const u8) anyerror!Pipeline.Handle {
-    if (v_shader == null or f_shader == null) {
-        return error.InvalidShader;
-    }
-
+fn init_pipeline(layout: vertex.VertexLayout) !PipelineData {
     var vao: gl.uint = 0;
     gl.CreateVertexArrays(1, @ptrCast(&vao));
     for (layout.attributes) |a| {
@@ -184,41 +188,29 @@ pub fn create_pipeline(layout: Pipeline.VertexLayout, v_shader: ?[:0]align(4) co
         gl.VertexArrayAttribBinding(vao, a.location, a.binding);
     }
 
-    const program = try shader.Shader.init(v_shader.?, f_shader.?);
+    const v_shader: [:0]align(4) const u8 = &shaders.basic_vert;
+    const f_shader: [:0]align(4) const u8 = &shaders.basic_frag;
+    const program = try shader.Shader.init(v_shader, f_shader);
 
-    const pipeline = pipelines.add_element(.{
+    return .{
         .layout = layout,
         .vao = vao,
         .program = program,
-    }) orelse return error.OutOfPipelines;
-
-    return @intCast(pipeline);
+    };
 }
 
-pub fn bind_pipeline(pipeline: Pipeline.Handle) void {
-    const pl = pipelines.get_element(pipeline) orelse return;
-    gl.BindVertexArray(pl.vao);
-    gl.UseProgram(pl.program.shader_program);
-}
-
-pub fn destroy_pipeline(pipeline: Pipeline.Handle) void {
-    var pl = pipelines.get_element(pipeline) orelse return;
+fn deinit_pipeline(pl: *PipelineData) void {
     gl.DeleteVertexArrays(1, @ptrCast(&pl.vao));
     pl.vao = 0;
     pl.program.deinit();
-
-    _ = pipelines.remove_element(pipeline);
 }
 
-pub fn create_mesh(pipeline: Pipeline.Handle) anyerror!Mesh.Handle {
-    const pl = pipelines.get_element(pipeline).?;
+pub fn create_mesh() anyerror!Mesh.Handle {
     var vbo: gl.uint = 0;
     gl.CreateBuffers(1, @ptrCast(&vbo));
     gl.NamedBufferData(vbo, 0, null, gl.STATIC_DRAW);
-    gl.VertexArrayVertexBuffer(pl.vao, 0, vbo, 0, @intCast(pl.layout.stride));
 
     const mesh_idx = meshes.add_element(.{
-        .pipeline = pipeline,
         .vbo = vbo,
     }) orelse return error.OutOfMeshes;
 
@@ -240,16 +232,16 @@ pub fn update_mesh(handle: Mesh.Handle, data: []const u8) void {
     gl.NamedBufferSubData(mesh.vbo, 0, @intCast(data.len), data.ptr);
 }
 
-pub fn draw_mesh(handle: Mesh.Handle, model: *const Mat4, count: usize, primitive: Mesh.Primitive) void {
+pub fn draw_mesh(handle: Mesh.Handle, model: *const Mat4, count: usize) void {
+    if (!pipeline_initialized) return;
     const mesh = meshes.get_element(handle) orelse return;
-    const pl = pipelines.get_element(mesh.pipeline) orelse return;
+    const pl = &pipeline;
 
     shader.update_per_object(model);
+    gl.BindVertexArray(pl.vao);
+    gl.UseProgram(pl.program.shader_program);
     gl.VertexArrayVertexBuffer(pl.vao, 0, mesh.vbo, 0, @intCast(pl.layout.stride));
-    gl.DrawArrays(switch (primitive) {
-        .triangles => gl.TRIANGLES,
-        .lines => gl.LINES,
-    }, 0, @intCast(count));
+    gl.DrawArrays(gl.TRIANGLES, 0, @intCast(count));
 }
 
 pub fn create_texture(width: u32, height: u32, data: []align(16) u8) anyerror!Texture.Handle {
diff --git a/src/platform/glfw/vulkan/vulkan_gfx.zig b/src/platform/glfw/vulkan/vulkan_gfx.zig
index 4107ac2..083c859 100644
--- a/src/platform/glfw/vulkan/vulkan_gfx.zig
+++ b/src/platform/glfw/vulkan/vulkan_gfx.zig
@@ -15,9 +15,10 @@ const Mat4 = @import("../../../math/math.zig").Mat4;
 const vk = @import("vulkan");
 const gfx = @import("../../gfx.zig");
 const Rendering = @import("../../../rendering/rendering.zig");
-const Pipeline = Rendering.Pipeline;
+const vertex = Rendering.vertex;
 const Mesh = Rendering.mesh;
 const Texture = Rendering.Texture;
+const shaders = @import("aether_shaders");
 
 const Context = @import("context.zig");
 const Swapchain = @import("swapchain.zig");
@@ -33,9 +34,8 @@ pub fn setup(alloc: std.mem.Allocator, io: std.Io) void {
 }
 
 const PipelineData = struct {
-    layout: vk.PipelineLayout,
-    vert_layout: Pipeline.VertexLayout,
-    pipeline: vk.Pipeline,
+    layout: vk.PipelineLayout = .null_handle,
+    pipeline: vk.Pipeline = .null_handle,
 };
 
 const MAX_FRAMES = 3;
@@ -45,7 +45,6 @@ const MeshData = struct {
     memories: [MAX_FRAMES]vk.DeviceMemory = @splat(.null_handle),
     mapped: [MAX_FRAMES]?[*]u8 = @splat(null),
     capacity: usize = 0,
-    pipeline: Pipeline.Handle = 0,
     built: bool = false,
 };
 
@@ -115,8 +114,8 @@ var tex_sampler: vk.Sampler = .null_handle;
 const TextureRec = struct { image: vk.Image, memory: vk.DeviceMemory, view: vk.ImageView, width: u32, height: u32 };
 var textures = Util.CircularBuffer(TextureRec, TEXTURE_CAP).init();
 
-var pipelines = Util.CircularBuffer(PipelineData, 16).init();
 var meshes = Util.CircularBuffer(MeshData, 8192).init();
+var render_pipeline: PipelineData = .{};
 
 var swap_state: Swapchain.PresentState = .optimal;
 var alpha_blend_enabled: bool = true;
@@ -437,6 +436,7 @@ pub fn init() anyerror!void {
     try create_texture_set_layout();
     try create_texture_descriptor_pool_and_set(4096);
     try create_texture_sampler();
+    render_pipeline = try init_pipeline(vertex.Layout);
 
     GLFWSurface.on_resize = resize_flag;
 }
@@ -449,6 +449,7 @@ pub fn deinit() void {
     GLFWSurface.on_resize = null;
     context.logical_device.deviceWaitIdle() catch {};
 
+    deinit_pipeline(&render_pipeline);
     destroy_texture_sampler();
     destroy_texture_descriptor_pool_and_set();
     destroy_texture_set_layout();
@@ -751,8 +752,9 @@ fn flush_camera_if_dirty() void {
     camera_dirty = false;
 }
 
-pub fn create_pipeline(layout: Pipeline.VertexLayout, vs: ?[:0]align(4) const u8, fs: ?[:0]align(4) const u8) anyerror!Pipeline.Handle {
-    if (vs == null or fs == null) return error.InvalidShader;
+fn init_pipeline(layout: vertex.VertexLayout) !PipelineData {
+    const vs: [:0]align(4) const u8 = &shaders.basic_vert;
+    const fs: [:0]align(4) const u8 = &shaders.basic_frag;
 
     const set_layouts = [_]vk.DescriptorSetLayout{ descriptor_set_layout, tex_set_layout };
 
@@ -768,16 +770,19 @@ pub fn create_pipeline(layout: Pipeline.VertexLayout, vs: ?[:0]align(4) const u8
         .push_constant_range_count = 1,
         .p_push_constant_ranges = @ptrCast(&range),
     }, null);
+    errdefer context.logical_device.destroyPipelineLayout(pl, null);
 
     const vert = try context.logical_device.createShaderModule(&.{
-        .code_size = vs.?.len,
-        .p_code = @ptrCast(@alignCast(vs.?.ptr)),
+        .code_size = vs.len,
+        .p_code = @ptrCast(@alignCast(vs.ptr)),
     }, null);
+    defer context.logical_device.destroyShaderModule(vert, null);
 
     const frag = try context.logical_device.createShaderModule(&.{
-        .code_size = fs.?.len,
-        .p_code = @ptrCast(@alignCast(fs.?.ptr)),
+        .code_size = fs.len,
+        .p_code = @ptrCast(@alignCast(fs.ptr)),
     }, null);
+    defer context.logical_device.destroyShaderModule(frag, null);
 
     const pipeline_shade_stage_create_info = [_]vk.PipelineShaderStageCreateInfo{
         .{
@@ -954,38 +959,24 @@ pub fn create_pipeline(layout: Pipeline.VertexLayout, vs: ?[:0]align(4) const u8
         return error.PipelineCreationFailed;
     }
 
-    const p_handle = pipelines.add_element(.{
+    return .{
         .layout = pl,
-        .vert_layout = layout,
         .pipeline = pipeline,
-    }) orelse return error.OutOfPipelines;
-
-    return @intCast(p_handle);
-}
-
-pub fn destroy_pipeline(handle: Pipeline.Handle) void {
-    context.logical_device.deviceWaitIdle() catch {};
-    const pd = pipelines.get_element(handle) orelse return;
-
-    context.logical_device.destroyPipeline(pd.pipeline, null);
-    context.logical_device.destroyPipelineLayout(pd.layout, null);
-
-    _ = pipelines.remove_element(handle);
+    };
 }
 
-pub fn bind_pipeline(handle: Pipeline.Handle) void {
-    const pd = pipelines.get_element(handle) orelse return;
-
-    command_buffer.bindPipeline(.graphics, pd.pipeline);
-    // Descriptor sets are (re)bound per draw in draw_mesh because the
-    // dynamic UBO offset can change as the user swaps projection/view
-    // matrices mid-frame.
+fn deinit_pipeline(pd: *PipelineData) void {
+    if (pd.pipeline != .null_handle) {
+        context.logical_device.destroyPipeline(pd.pipeline, null);
+    }
+    if (pd.layout != .null_handle) {
+        context.logical_device.destroyPipelineLayout(pd.layout, null);
+    }
+    pd.* = .{};
 }
 
-pub fn create_mesh(pipeline: Pipeline.Handle) anyerror!Mesh.Handle {
-    const m_handle = meshes.add_element(.{
-        .pipeline = pipeline,
-    }) orelse return error.OutOfMeshes;
+pub fn create_mesh() anyerror!Mesh.Handle {
+    const m_handle = meshes.add_element(.{}) orelse return error.OutOfMeshes;
     return @intCast(m_handle);
 }
 
@@ -1056,13 +1047,15 @@ pub fn update_mesh(handle: Mesh.Handle, data: []const u8) void {
     meshes.update_element(handle, m_data);
 }
 
-pub fn draw_mesh(handle: Mesh.Handle, model: *const Mat4, count: usize, primitive: Mesh.Primitive) void {
+pub fn draw_mesh(handle: Mesh.Handle, model: *const Mat4, count: usize) void {
     draw_state.mat = model.*;
 
     const m_data = meshes.get_element(handle) orelse return;
-    const p_data = pipelines.get_element(m_data.pipeline) orelse return;
+    if (render_pipeline.pipeline == .null_handle) return;
+    const p_data = &render_pipeline;
 
     flush_camera_if_dirty();
+    command_buffer.bindPipeline(.graphics, p_data.pipeline);
 
     const sets = [_]vk.DescriptorSet{
         descriptor_sets[swapchain.image_index],
@@ -1071,10 +1064,7 @@ pub fn draw_mesh(handle: Mesh.Handle, model: *const Mat4, count: usize, primitiv
     const dyn_offsets = [_]u32{current_camera_slot * camera_rings[swapchain.image_index].slot_stride};
     command_buffer.bindDescriptorSets(.graphics, p_data.layout, 0, &sets, &dyn_offsets);
 
-    command_buffer.setPrimitiveTopology(switch (primitive) {
-        .triangles => .triangle_list,
-        .lines => .line_list,
-    });
+    command_buffer.setPrimitiveTopology(.triangle_list);
 
     const offset = [_]vk.DeviceSize{0};
     const frame_buf = m_data.buffers[swapchain.image_index];
diff --git a/src/platform/headless/headless_gfx.zig b/src/platform/headless/headless_gfx.zig
index 1e3d447..f976bf0 100644
--- a/src/platform/headless/headless_gfx.zig
+++ b/src/platform/headless/headless_gfx.zig
@@ -1,7 +1,6 @@
 const std = @import("std");
 const Mat4 = @import("../../math/math.zig").Mat4;
 const Rendering = @import("../../rendering/rendering.zig");
-const Pipeline = Rendering.Pipeline;
 const Mesh = Rendering.mesh;
 const Texture = Rendering.Texture;
 
@@ -34,20 +33,13 @@ pub fn end_frame() void {}
 pub fn clear_depth() void {}
 pub fn set_vsync(_: bool) void {}
 
-pub fn create_pipeline(_: Pipeline.VertexLayout, _: ?[:0]align(4) const u8, _: ?[:0]align(4) const u8) anyerror!Pipeline.Handle {
-    return 0;
-}
-
-pub fn destroy_pipeline(_: Pipeline.Handle) void {}
-pub fn bind_pipeline(_: Pipeline.Handle) void {}
-
-pub fn create_mesh(_: Pipeline.Handle) anyerror!Mesh.Handle {
+pub fn create_mesh() anyerror!Mesh.Handle {
     return 0;
 }
 
 pub fn destroy_mesh(_: Mesh.Handle) void {}
 pub fn update_mesh(_: Mesh.Handle, _: []const u8) void {}
-pub fn draw_mesh(_: Mesh.Handle, _: *const Mat4, _: usize, _: Mesh.Primitive) void {}
+pub fn draw_mesh(_: Mesh.Handle, _: *const Mat4, _: usize) void {}
 
 pub fn create_texture(_: u32, _: u32, _: []align(16) u8) anyerror!Texture.Handle {
     return 0;
diff --git a/src/platform/input.zig b/src/platform/input.zig
index 4fe0232..1205dcc 100644
--- a/src/platform/input.zig
+++ b/src/platform/input.zig
@@ -11,6 +11,12 @@ pub const Api = if (options.config.gfx == .headless)
     @import("headless/input.zig")
 else if (builtin.os.tag == .psp)
     @import("psp/input.zig")
+else if (builtin.os.tag == .@"3ds")
+    @import("3ds/input.zig")
+else if (options.config.platform == .nintendo_switch)
+    @import("switch/input.zig")
+else if (options.config.platform == .wasm)
+    @import("wasm/input.zig")
 else
     @import("glfw/input.zig");
 
diff --git a/src/platform/nintendo_c.zig b/src/platform/nintendo_c.zig
new file mode 100644
index 0000000..c0414c6
--- /dev/null
+++ b/src/platform/nintendo_c.zig
@@ -0,0 +1,42 @@
+const options = @import("options");
+
+pub const c = @cImport({
+    @cUndef("_GNU_SOURCE");
+    @cUndef("_DEFAULT_SOURCE");
+    @cDefine("_POSIX_C_SOURCE", "200809L");
+    @cDefine("wint_t", "__WINT_TYPE__");
+
+    switch (options.config.platform) {
+        .nintendo_3ds => {
+            @cDefine("__3DS__", "1");
+            @cDefine("ARM11", "1");
+        },
+        .nintendo_switch => {
+            @cDefine("__SWITCH__", "1");
+        },
+        else => @compileError("platform/nintendo_c.zig is only wired for Nintendo targets"),
+    }
+
+    @cInclude("errno.h");
+    @cInclude("fcntl.h");
+    @cInclude("dirent.h");
+    @cInclude("sys/stat.h");
+    @cInclude("unistd.h");
+    @cInclude("malloc.h");
+    @cInclude("stdio.h");
+
+    switch (options.config.platform) {
+        .nintendo_3ds => {
+            @cInclude("3ds/types.h");
+            @cInclude("3ds/thread.h");
+            @cInclude("3ds/allocator/linear.h");
+            @cInclude("3ds/archive.h");
+            @cInclude("3ds/romfs.h");
+            @cInclude("3ds/svc.h");
+        },
+        .nintendo_switch => {
+            @cInclude("switch/aether_switch_import.h");
+        },
+        else => unreachable,
+    }
+});
diff --git a/src/platform/platform.zig b/src/platform/platform.zig
index 4390ab6..4acd083 100644
--- a/src/platform/platform.zig
+++ b/src/platform/platform.zig
@@ -11,9 +11,18 @@ pub const GraphicsAPI = @import("options").@"build.Gfx";
 /// Initializes the platform subsystems: graphics, audio, then input.
 /// Order matters: input subscribes to surface callbacks created by gfx.
 pub fn init(engine: *Engine, width: u32, height: u32, title: [:0]const u8, fullscreen: bool, sync: bool, resizable: bool) !void {
-    try gfx.init(engine.allocator(.render), engine.io, width, height, title, fullscreen, sync, resizable);
-    try audio.init(engine.allocator(.audio), engine.io);
-    try input.init(engine.allocator(.game), engine.io);
+    gfx.init(engine.allocator(.render), engine.io, width, height, title, fullscreen, sync, resizable) catch |err| switch (err) {
+        error.OutOfMemory => return error.GfxInitOutOfMemory,
+        else => return err,
+    };
+    audio.init(engine.allocator(.audio), engine.io) catch |err| switch (err) {
+        error.OutOfMemory => return error.AudioInitOutOfMemory,
+        else => return err,
+    };
+    input.init(engine.allocator(.game), engine.io) catch |err| switch (err) {
+        error.OutOfMemory => return error.InputInitOutOfMemory,
+        else => return err,
+    };
 }
 
 /// Updates the platform subsystems. Must be called once per frame.
@@ -21,6 +30,7 @@ pub fn update(engine: *Engine) void {
     if (!gfx.surface.update()) {
         // Window should close
         engine.running = false;
+        return;
     }
     audio.update();
 }
diff --git a/src/platform/psp/psp_gfx_ge.zig b/src/platform/psp/psp_gfx_ge.zig
index c174a55..784b055 100644
--- a/src/platform/psp/psp_gfx_ge.zig
+++ b/src/platform/psp/psp_gfx_ge.zig
@@ -9,7 +9,7 @@ const std = @import("std");
 const Util = @import("../../util/util.zig");
 const Mat4 = @import("../../math/math.zig").Mat4;
 const Rendering = @import("../../rendering/rendering.zig");
-const Pipeline = Rendering.Pipeline;
+const vertex = Rendering.vertex;
 const Mesh = Rendering.mesh;
 const Texture = Rendering.Texture;
 
@@ -113,7 +113,7 @@ const frame_bpp: u32 = switch (options.config.psp_display_mode) {
 
 const VertexType = sdk.VertexType;
 
-// ---- pipeline cache --------------------------------------------------------
+// ---- vertex pipeline -------------------------------------------------------
 
 const PipelineData = struct {
     vertex_type: VertexType,
@@ -124,8 +124,7 @@ const PipelineData = struct {
     uv_unorm8: bool,
 };
 
-var pipelines = Util.CircularBuffer(PipelineData, 16).init();
-var bound_pipeline: Pipeline.Handle = 0;
+var render_pipeline: PipelineData = undefined;
 var alpha_blend_enabled: bool = true;
 var clip_planes_enabled: bool = false;
 var fog_enabled: bool = false;
@@ -545,6 +544,7 @@ fn emit_depth_range(near_value: u16, far_value: u16) void {
 // ---- engine state ----------------------------------------------------------
 
 pub fn init() anyerror!void {
+    render_pipeline = init_pipeline(vertex.Layout);
     clear_color = 0x000000;
 
     swapchain.init();
@@ -855,9 +855,9 @@ pub fn set_vsync(v: bool) void {
     gfx.surface.sync = v;
 }
 
-// ---- pipelines -------------------------------------------------------------
+// ---- meshes ---------------------------------------------------------------
 
-pub fn create_pipeline(layout: Pipeline.VertexLayout, _: ?[:0]align(4) const u8, _: ?[:0]align(4) const u8) anyerror!Pipeline.Handle {
+fn init_pipeline(layout: vertex.VertexLayout) PipelineData {
     var vtype = VertexType{
         .vertex = .Vertex32Bitf, // default, overridden by position attribute
         .transform = .Transform3D,
@@ -895,36 +895,22 @@ pub fn create_pipeline(layout: Pipeline.VertexLayout, _: ?[:0]align(4) const u8,
         }
     }
 
-    const handle = pipelines.add_element(.{
+    return .{
         .vertex_type = vtype,
         .stride = layout.stride,
         .uv_unorm8 = uv_unorm8,
-    }) orelse return error.OutOfPipelines;
-
-    return @intCast(handle);
-}
-
-pub fn destroy_pipeline(handle: Pipeline.Handle) void {
-    _ = pipelines.remove_element(handle);
-}
-
-pub fn bind_pipeline(handle: Pipeline.Handle) void {
-    bound_pipeline = handle;
+    };
 }
 
-// ---- meshes ---------------------------------------------------------------
-
 const MeshData = struct {
-    pipeline: Pipeline.Handle,
     data: ?[*]const u8,
     len: usize,
 };
 
 var meshes = Util.CircularBuffer(MeshData, 2048).init();
 
-pub fn create_mesh(pipeline: Pipeline.Handle) anyerror!Mesh.Handle {
+pub fn create_mesh() anyerror!Mesh.Handle {
     const handle = meshes.add_element(.{
-        .pipeline = pipeline,
         .data = null,
         .len = 0,
     }) orelse return error.OutOfMeshes;
@@ -946,9 +932,9 @@ pub fn update_mesh(handle: Mesh.Handle, data: []const u8) void {
     meshes.update_element(handle, mesh);
 }
 
-pub fn draw_mesh(handle: Mesh.Handle, model: *const Mat4, count: usize, primitive: Mesh.Primitive) void {
+pub fn draw_mesh(handle: Mesh.Handle, model: *const Mat4, count: usize) void {
     const mesh = meshes.get_element(handle) orelse return;
-    const pl = pipelines.get_element(mesh.pipeline) orelse return;
+    const pl = &render_pipeline;
     const data = mesh.data orelse return;
 
     must(cmd.world_matrix(mat4_as_floats(model)));
@@ -963,10 +949,7 @@ pub fn draw_mesh(handle: Mesh.Handle, model: *const Mat4, count: usize, primitiv
 
     must(cmd.vertex_type(@as(u24, @bitCast(pl.vertex_type))));
     must(cmd.vertex_address(@intFromPtr(data)));
-    must(cmd.primitive(switch (primitive) {
-        .triangles => .triangles,
-        .lines => .lines,
-    }, @intCast(count)));
+    must(cmd.primitive(.triangles, @intCast(count)));
     advance_stall();
 }
 
diff --git a/src/platform/switch/aether_switch_import.h b/src/platform/switch/aether_switch_import.h
new file mode 100644
index 0000000..6e9393d
--- /dev/null
+++ b/src/platform/switch/aether_switch_import.h
@@ -0,0 +1,118 @@
+#pragma once
+
+#include <stddef.h>
+#include <stdbool.h>
+#include <switch/types.h>
+
+Result fsdevMountSdmc(void);
+int fsdevUnmountDevice(const char *name);
+Result romfsMountSelf(const char *name);
+Result romfsUnmount(const char *name);
+
+u64 svcGetSystemTick(void);
+void svcSleepThread(s64 nano);
+
+bool appletMainLoop(void);
+
+typedef struct HidAnalogStickState {
+    s32 x;
+    s32 y;
+} HidAnalogStickState;
+
+typedef struct HidTouchState {
+    u64 delta_time;
+    u32 attributes;
+    u32 finger_id;
+    u32 x;
+    u32 y;
+    u32 diameter_x;
+    u32 diameter_y;
+    u32 rotation_angle;
+    u32 reserved;
+} HidTouchState;
+
+typedef struct HidTouchScreenState {
+    u64 sampling_number;
+    s32 count;
+    u32 reserved;
+    HidTouchState touches[16];
+} HidTouchScreenState;
+
+typedef struct PadState {
+    u8 id_mask;
+    u8 active_id_mask;
+    bool read_handheld;
+    bool active_handheld;
+    u32 style_set;
+    u32 attributes;
+    u64 buttons_cur;
+    u64 buttons_old;
+    HidAnalogStickState sticks[2];
+    u32 gc_triggers[2];
+} PadState;
+
+#define HidNpadStyleTag_NpadFullKey  BIT(0)
+#define HidNpadStyleTag_NpadHandheld BIT(1)
+#define HidNpadStyleTag_NpadJoyDual  BIT(2)
+#define HidNpadStyleTag_NpadJoyLeft  BIT(3)
+#define HidNpadStyleTag_NpadJoyRight BIT(4)
+
+#define HidNpadIdType_No1      0
+#define HidNpadIdType_Handheld 0x20
+
+#define HidNpadButton_A       BITL(0)
+#define HidNpadButton_B       BITL(1)
+#define HidNpadButton_X       BITL(2)
+#define HidNpadButton_Y       BITL(3)
+#define HidNpadButton_StickL  BITL(4)
+#define HidNpadButton_StickR  BITL(5)
+#define HidNpadButton_L       BITL(6)
+#define HidNpadButton_R       BITL(7)
+#define HidNpadButton_ZL      BITL(8)
+#define HidNpadButton_ZR      BITL(9)
+#define HidNpadButton_Plus    BITL(10)
+#define HidNpadButton_Minus   BITL(11)
+#define HidNpadButton_Left    BITL(12)
+#define HidNpadButton_Up      BITL(13)
+#define HidNpadButton_Right   BITL(14)
+#define HidNpadButton_Down    BITL(15)
+#define HidNpadButton_LeftSL  BITL(24)
+#define HidNpadButton_LeftSR  BITL(25)
+#define HidNpadButton_RightSL BITL(26)
+#define HidNpadButton_RightSR BITL(27)
+
+#define JOYSTICK_MAX 0x7FFF
+
+Result hidInitialize(void);
+void hidExit(void);
+void hidInitializeTouchScreen(void);
+size_t hidGetTouchScreenStates(HidTouchScreenState *states, size_t count);
+
+void padConfigureInput(u32 max_players, u32 style_set);
+void padInitializeWithMask(PadState *pad, u64 mask);
+void padUpdate(PadState *pad);
+
+Result swkbdCreate(void *c, s32 max_dictwords);
+void swkbdClose(void *c);
+void swkbdConfigMakePresetDefault(void *c);
+void swkbdConfigSetOkButtonText(void *c, const char *str);
+void swkbdConfigSetHeaderText(void *c, const char *str);
+void swkbdConfigSetGuideText(void *c, const char *str);
+void swkbdConfigSetInitialText(void *c, const char *str);
+Result swkbdShow(void *c, char *out_string, size_t out_string_size);
+
+typedef struct AudioOutBuffer AudioOutBuffer;
+struct AudioOutBuffer {
+    AudioOutBuffer *next;
+    void *buffer;
+    u64 buffer_size;
+    u64 data_size;
+    u64 data_offset;
+};
+
+Result audoutInitialize(void);
+void audoutExit(void);
+Result audoutStartAudioOut(void);
+Result audoutStopAudioOut(void);
+Result audoutAppendAudioOutBuffer(AudioOutBuffer *buffer);
+Result audoutGetReleasedAudioOutBuffer(AudioOutBuffer **buffer, u32 *released_count);
diff --git a/src/platform/switch/input.zig b/src/platform/switch/input.zig
new file mode 100644
index 0000000..0922bb4
--- /dev/null
+++ b/src/platform/switch/input.zig
@@ -0,0 +1,222 @@
+//! Switch input backend. Polls libnx's pad and touchscreen helpers once per
+//! engine update and translates them into Aether core input events.
+
+const std = @import("std");
+const core = @import("../../core/input/input.zig");
+const c = @import("../nintendo_c.zig").c;
+
+const HID_NPAD_STYLE_STANDARD: u32 = c.HidNpadStyleTag_NpadFullKey |
+    c.HidNpadStyleTag_NpadHandheld |
+    c.HidNpadStyleTag_NpadJoyDual |
+    c.HidNpadStyleTag_NpadJoyLeft |
+    c.HidNpadStyleTag_NpadJoyRight;
+
+const DEFAULT_PAD_MASK: u64 = (@as(u64, 1) << c.HidNpadIdType_No1) |
+    (@as(u64, 1) << c.HidNpadIdType_Handheld);
+
+const BUTTON_A: u64 = c.HidNpadButton_A;
+const BUTTON_B: u64 = c.HidNpadButton_B;
+const BUTTON_X: u64 = c.HidNpadButton_X;
+const BUTTON_Y: u64 = c.HidNpadButton_Y;
+const BUTTON_STICK_L: u64 = c.HidNpadButton_StickL;
+const BUTTON_STICK_R: u64 = c.HidNpadButton_StickR;
+const BUTTON_L: u64 = c.HidNpadButton_L;
+const BUTTON_R: u64 = c.HidNpadButton_R;
+const BUTTON_ZL: u64 = c.HidNpadButton_ZL;
+const BUTTON_ZR: u64 = c.HidNpadButton_ZR;
+const BUTTON_PLUS: u64 = c.HidNpadButton_Plus;
+const BUTTON_MINUS: u64 = c.HidNpadButton_Minus;
+const BUTTON_LEFT: u64 = c.HidNpadButton_Left;
+const BUTTON_UP: u64 = c.HidNpadButton_Up;
+const BUTTON_RIGHT: u64 = c.HidNpadButton_Right;
+const BUTTON_DOWN: u64 = c.HidNpadButton_Down;
+const BUTTON_LEFT_SL: u64 = c.HidNpadButton_LeftSL;
+const BUTTON_LEFT_SR: u64 = c.HidNpadButton_LeftSR;
+const BUTTON_RIGHT_SL: u64 = c.HidNpadButton_RightSL;
+const BUTTON_RIGHT_SR: u64 = c.HidNpadButton_RightSR;
+
+const JOYSTICK_MAX: f32 = @floatFromInt(c.JOYSTICK_MAX);
+const MAX_TEXT_BYTES: usize = 1024;
+const SWKBD_CONFIG_BYTES: usize = 0x600;
+
+const axis_count = @typeInfo(core.Axis).@"enum".fields.len;
+
+var initialized: bool = false;
+var pad: c.PadState = undefined;
+var prev_buttons: u64 = 0;
+var prev_axes: [axis_count]f32 = @splat(0.0);
+var prev_touch_down: bool = false;
+var prev_touch_pos: core.Vec2 = .{};
+
+pub fn setup(_: std.mem.Allocator, _: std.Io) void {
+    initialized = false;
+    pad = std.mem.zeroes(c.PadState);
+    prev_buttons = 0;
+    prev_axes = @splat(0.0);
+    prev_touch_down = false;
+    prev_touch_pos = .{};
+}
+
+pub fn init() anyerror!void {
+    if (c.hidInitialize() != 0) return error.InputInitFailed;
+    c.hidInitializeTouchScreen();
+    c.padConfigureInput(1, HID_NPAD_STYLE_STANDARD);
+    c.padInitializeWithMask(&pad, DEFAULT_PAD_MASK);
+    initialized = true;
+}
+
+pub fn deinit() void {
+    if (!initialized) return;
+    c.hidExit();
+    initialized = false;
+}
+
+pub fn pump() void {
+    c.padUpdate(&pad);
+
+    diff_buttons(pad.buttons_cur);
+    pump_axes(pad.buttons_cur);
+    pump_touch();
+
+    prev_buttons = pad.buttons_cur;
+    core.signal_frame_boundary();
+}
+
+pub fn apply_cursor_mode(_: core.CursorMode) void {}
+
+pub fn begin_text_input_session(target: core.TextInputTarget, options: core.TextInputOptions) anyerror!void {
+    var config_buf: [SWKBD_CONFIG_BYTES]u8 align(8) = @splat(0);
+    const config: *anyopaque = @ptrCast(&config_buf);
+
+    var initial_buf: [MAX_TEXT_BYTES:0]u8 = @splat(0);
+    const initial_len = copy_current_text(&initial_buf);
+    const initial = initial_buf[0..initial_len :0];
+
+    var target_buf: [128:0]u8 = @splat(0);
+    const target_text = copy_z(&target_buf, target.id);
+
+    if (c.swkbdCreate(config, 0) != 0) {
+        core.write_text_session_buffer(initial_buf[0..initial_len], .cancelled);
+        return;
+    }
+    defer c.swkbdClose(config);
+
+    c.swkbdConfigMakePresetDefault(config);
+    c.swkbdConfigSetOkButtonText(config, "OK");
+    c.swkbdConfigSetHeaderText(config, target_text.ptr);
+    c.swkbdConfigSetGuideText(config, target_text.ptr);
+    c.swkbdConfigSetInitialText(config, initial.ptr);
+
+    var out_buf: [MAX_TEXT_BYTES:0]u8 = @splat(0);
+    const out_size = output_buffer_size(options.max_bytes);
+    if (c.swkbdShow(config, out_buf[0..].ptr, out_size) == 0) {
+        const len = bounded_z_len(out_buf[0..out_size]);
+        core.write_text_session_buffer(out_buf[0..len], .submitted);
+    } else {
+        core.write_text_session_buffer(initial_buf[0..initial_len], .cancelled);
+    }
+}
+
+pub fn end_text_input_session() void {}
+
+fn diff_buttons(buttons: u64) void {
+    const Pair = struct { mask: u64, button: core.Button };
+    const map = [_]Pair{
+        .{ .mask = BUTTON_A, .button = .A },
+        .{ .mask = BUTTON_B, .button = .B },
+        .{ .mask = BUTTON_X, .button = .X },
+        .{ .mask = BUTTON_Y, .button = .Y },
+        .{ .mask = BUTTON_L | BUTTON_LEFT_SL | BUTTON_RIGHT_SL, .button = .LButton },
+        .{ .mask = BUTTON_R | BUTTON_LEFT_SR | BUTTON_RIGHT_SR, .button = .RButton },
+        .{ .mask = BUTTON_MINUS, .button = .Back },
+        .{ .mask = BUTTON_PLUS, .button = .Start },
+        .{ .mask = BUTTON_STICK_L, .button = .LeftThumb },
+        .{ .mask = BUTTON_STICK_R, .button = .RightThumb },
+        .{ .mask = BUTTON_UP, .button = .DpadUp },
+        .{ .mask = BUTTON_RIGHT, .button = .DpadRight },
+        .{ .mask = BUTTON_DOWN, .button = .DpadDown },
+        .{ .mask = BUTTON_LEFT, .button = .DpadLeft },
+    };
+
+    inline for (map) |entry| {
+        const now = buttons & entry.mask != 0;
+        const prev = prev_buttons & entry.mask != 0;
+        if (now != prev) {
+            core.deliver_gamepad_button(entry.button, if (now) .pressed else .released);
+        }
+    }
+}
+
+fn pump_axes(buttons: u64) void {
+    const left = pad.sticks[0];
+    const right = pad.sticks[1];
+
+    deliver_axis(.LeftX, normalize_stick(left.x));
+    deliver_axis(.LeftY, -normalize_stick(left.y));
+    deliver_axis(.RightX, normalize_stick(right.x));
+    deliver_axis(.RightY, -normalize_stick(right.y));
+    deliver_axis(.LeftTrigger, if (buttons & BUTTON_ZL != 0) 1.0 else 0.0);
+    deliver_axis(.RightTrigger, if (buttons & BUTTON_ZR != 0) 1.0 else 0.0);
+}
+
+fn pump_touch() void {
+    var states: [1]c.HidTouchScreenState = undefined;
+    const state_count = c.hidGetTouchScreenStates(&states, states.len);
+    const touch_down = state_count > 0 and states[0].count > 0;
+
+    if (touch_down) {
+        const touch = states[0].touches[0];
+        const pos: core.Vec2 = .{
+            .x = @floatFromInt(touch.x),
+            .y = @floatFromInt(touch.y),
+        };
+        const delta: core.Vec2 = if (prev_touch_down)
+            .{ .x = pos.x - prev_touch_pos.x, .y = pos.y - prev_touch_pos.y }
+        else
+            .{};
+
+        core.deliver_mouse_move(pos, delta);
+        if (!prev_touch_down) core.deliver_mouse_button(.Left, .pressed, pos);
+        prev_touch_pos = pos;
+    } else if (prev_touch_down) {
+        core.deliver_mouse_button(.Left, .released, prev_touch_pos);
+    }
+
+    prev_touch_down = touch_down;
+}
+
+fn deliver_axis(axis: core.Axis, value: f32) void {
+    const idx = @intFromEnum(axis);
+    const prev = prev_axes[idx];
+    if (value != 0.0 or prev != 0.0) core.deliver_gamepad_axis(axis, value);
+    prev_axes[idx] = value;
+}
+
+fn normalize_stick(raw: i32) f32 {
+    const value = @as(f32, @floatFromInt(raw)) / JOYSTICK_MAX;
+    return std.math.clamp(value, -1.0, 1.0);
+}
+
+fn output_buffer_size(limit: ?usize) usize {
+    const max = @min(limit orelse (MAX_TEXT_BYTES - 1), MAX_TEXT_BYTES - 1);
+    return max + 1;
+}
+
+fn copy_current_text(dst: []u8) usize {
+    const s = core.current_text_session() orelse return 0;
+    const n = @min(dst.len - 1, s.buffer.items.len);
+    @memcpy(dst[0..n], s.buffer.items[0..n]);
+    dst[n] = 0;
+    return n;
+}
+
+fn copy_z(dst: []u8, text: []const u8) [:0]const u8 {
+    const n = @min(dst.len - 1, text.len);
+    @memcpy(dst[0..n], text[0..n]);
+    dst[n] = 0;
+    return dst[0..n :0];
+}
+
+fn bounded_z_len(buf: []const u8) usize {
+    return std.mem.indexOfScalar(u8, buf, 0) orelse buf.len;
+}
diff --git a/src/platform/switch/paths.zig b/src/platform/switch/paths.zig
new file mode 100644
index 0000000..2267f6d
--- /dev/null
+++ b/src/platform/switch/paths.zig
@@ -0,0 +1,22 @@
+const std = @import("std");
+const c = @import("../nintendo_c.zig").c;
+
+pub fn mountData() bool {
+    return c.fsdevMountSdmc() == 0;
+}
+
+pub fn unmountData() void {
+    _ = c.fsdevUnmountDevice("sdmc");
+}
+
+pub fn mountResources() bool {
+    return c.romfsMountSelf("romfs") == 0;
+}
+
+pub fn unmountResources() void {
+    _ = c.romfsUnmount("romfs");
+}
+
+pub fn dataRoot(buffer: []u8, app_name: []const u8) error{NameTooLong}![]const u8 {
+    return std.fmt.bufPrint(buffer, "sdmc:/switch/{s}", .{app_name}) catch error.NameTooLong;
+}
diff --git a/src/platform/switch/services.zig b/src/platform/switch/services.zig
new file mode 100644
index 0000000..8a048b0
--- /dev/null
+++ b/src/platform/switch/services.zig
@@ -0,0 +1,427 @@
+//! Switch system services / entry shim.
+//!
+//! Exports a C-callable `main` that hands control to the user's Zig
+//! `main`. The allocator and baseline `std.Io` pieces of `std.process.Init`
+//! are wired through newlib; deeper platform services remain TODO.
+//!
+//! libnx's switch.specs links with `--require-defined=main`, which
+//! pulls a strong `main` from libnx's crt0 by default. We shadow it
+//! with this Zig export — same name, weakness doesn't matter since
+//! ld picks the first definition seen — to route the entry through
+//! Aether instead of libnx's nnMain wrapper.
+
+const process_init = @import("aether").CProcessInit;
+const std = @import("std");
+
+pub const os = struct {
+    pub const PATH_MAX = 1024;
+    pub const NAME_MAX = 255;
+};
+
+fn AppRoot() type {
+    const root = @import("root");
+    return if (@hasDecl(root, "main")) root else @import("aether_user_root");
+}
+
+pub const std_options = if (@hasDecl(AppRoot(), "std_options")) AppRoot().std_options else std.Options{};
+pub const std_options_debug_threaded_io = if (@hasDecl(AppRoot(), "std_options_debug_threaded_io")) AppRoot().std_options_debug_threaded_io else null;
+pub const std_options_debug_io = if (@hasDecl(AppRoot(), "std_options_debug_io")) AppRoot().std_options_debug_io else std.Io.failing;
+const app_std_options_cwd: ?fn () std.Io.Dir = if (@hasDecl(AppRoot(), "std_options_cwd")) AppRoot().std_options_cwd else null;
+pub const std_options_cwd = app_std_options_cwd orelse @import("aether").Cio.cwd;
+
+const fatal_result: u32 = 0xf801;
+const FatalPolicy_ErrorScreen: c_int = 2;
+const BreakReason_Panic: u32 = 0;
+
+const CpuRegister = extern union {
+    x: u64,
+    w: u32,
+    r: u32,
+};
+
+const FpuRegister = extern union {
+    v: u128,
+    d: f64,
+    s: f32,
+};
+
+const ThreadExceptionDump = extern struct {
+    error_desc: u32,
+    pad: [3]u32,
+    cpu_gprs: [29]CpuRegister,
+    fp: CpuRegister,
+    lr: CpuRegister,
+    sp: CpuRegister,
+    pc: CpuRegister,
+    padding: u64,
+    fpu_gprs: [32]FpuRegister,
+    pstate: u32,
+    afsr0: u32,
+    afsr1: u32,
+    esr: u32,
+    far: CpuRegister,
+};
+
+const FatalAarch64Context = extern struct {
+    x: [29]u64 = @splat(0),
+    fp: u64 = 0,
+    lr: u64 = 0,
+    sp: u64 = 0,
+    pc: u64 = 0,
+    pstate: u64 = 0,
+    afsr0: u64 = 0,
+    afsr1: u64 = 0,
+    esr: u64 = 0,
+    far: u64 = 0,
+    stack_trace: [32]u64 = @splat(0),
+    start_address: u64 = 0,
+    register_set_flags: u64 = 0,
+    stack_trace_size: u32 = 0,
+};
+
+const FatalCpuContext = extern struct {
+    aarch64_ctx: FatalAarch64Context = .{},
+    is_aarch32: bool = false,
+    typ: u32 = 0,
+};
+
+extern fn fatalThrowWithContext(err: u32, policy: c_int, ctx: *FatalCpuContext) void;
+extern fn svcBreak(break_reason: u32, address: usize, size: usize) u32;
+extern fn svcOutputDebugString(str: [*]const u8, size: u64) u32;
+extern fn write(fd: c_int, buf: *const anyopaque, count: usize) c_int;
+
+// .text bounds provided by the Switch link step. The Zig C backend references
+// these as externs, so build.zig provides both raw and zig_e_ names.
+extern const __text_start: u8;
+extern const __text_end: u8;
+
+comptime {
+    @export(&entry, .{ .name = "main" });
+    @export(&exceptionHandler, .{ .name = "__libnx_exception_handler" });
+}
+
+var panic_stage: u8 = 0;
+var program_stack_top: usize = 0;
+
+fn entry(_: c_int, _: [*c][*c]u8) callconv(.c) c_int {
+    if (program_stack_top == 0) {
+        program_stack_top = asm volatile ("mov %[top], sp"
+            : [top] "=r" (-> usize),
+        );
+    }
+
+    const init = process_init.makeInit(.{ .vector = {} });
+    AppRoot().main(init) catch |err| {
+        fatalMainError(err, @errorReturnTrace(), @returnAddress());
+    };
+    return 0;
+}
+
+fn getFramePointer() usize {
+    return asm volatile ("mov %[fp], x29"
+        : [fp] "=r" (-> usize),
+    );
+}
+
+fn isLikelyReturnAddress(addr: usize) bool {
+    @setRuntimeSafety(false);
+    const ts = @intFromPtr(&__text_start);
+    const te = @intFromPtr(&__text_end);
+    if ((addr & 3) != 0 or addr < ts or addr >= te) return false;
+    const prev = addr -% 4;
+    if (prev < ts) return false;
+    const inst = @as(*const u32, @ptrFromInt(prev)).*;
+    if ((inst & 0xfc000000) == 0x94000000) return true; // bl imm26
+    if ((inst & 0xfffffc1f) == 0xd63f0000) return true; // blr xn
+    return false;
+}
+
+fn collectStackAddresses(first_addr: usize, out: []usize, start_fp: ?usize, start_lr: ?usize, start_sp: ?usize) usize {
+    @setRuntimeSafety(false);
+    const min_valid_fp: usize = 0x100000;
+    var count: usize = 0;
+    if (out.len > 0) {
+        out[0] = first_addr;
+        count = 1;
+    }
+    if (start_lr) |lr| {
+        if (lr > 1 and lr != first_addr and count < out.len and isLikelyReturnAddress(lr)) {
+            out[count] = lr;
+            count += 1;
+        }
+    }
+
+    var fp = start_fp orelse getFramePointer();
+    var guard: usize = 0;
+    while (count < out.len and guard < 64) : (guard += 1) {
+        if (fp < min_valid_fp or (fp & 7) != 0) break;
+        const saved_fp: *const u64 = @ptrFromInt(fp);
+        const saved_lr: *const u64 = @ptrFromInt(fp + 8);
+        const lr: usize = @intCast(saved_lr.*);
+        const next_fp: usize = @intCast(saved_fp.*);
+        if (lr > 1 and count < out.len and isLikelyReturnAddress(lr)) {
+            out[count] = lr;
+            count += 1;
+        }
+        if (next_fp < min_valid_fp or next_fp == 0 or next_fp <= fp or (next_fp & 7) != 0) break;
+        fp = next_fp;
+    }
+
+    if (start_sp) |sp| {
+        var top = if (program_stack_top != 0) program_stack_top else sp +% (1024 * 1024);
+        if (top <= sp or top -% sp > 8 * 1024 * 1024 or sp < 0x1000) {
+            top = sp +% (64 * 1024);
+        }
+        var scan = sp & ~@as(usize, 7);
+        const max_scan: usize = 8 * 1024 * 1024;
+        var scanned: usize = 0;
+        while (scan < top and count < out.len and scanned < max_scan) : ({
+            scan += @sizeOf(usize);
+            scanned += @sizeOf(usize);
+        }) {
+            if (scan < 0x1000) break;
+            const val = @as(*const usize, @ptrFromInt(scan)).*;
+            if (isLikelyReturnAddress(val)) {
+                var have = false;
+                for (out[0..count]) |prev| if (prev == val) {
+                    have = true;
+                    break;
+                };
+                if (!have) {
+                    out[count] = val;
+                    count += 1;
+                }
+            }
+        }
+    }
+
+    return count;
+}
+
+fn fatalMainError(err: anyerror, maybe_trace: ?*std.builtin.StackTrace, fallback_addr: usize) noreturn {
+    @branchHint(.cold);
+    @setRuntimeSafety(false);
+
+    if (panic_stage != 0) {
+        fatalDisplay("Aether recursive error in main");
+    }
+    panic_stage = 1;
+
+    const main_pc = if (maybe_trace) |trace| blk: {
+        const nn = @min(trace.index, trace.instruction_addresses.len);
+        if (nn > 0) break :blk trace.instruction_addresses[0];
+        break :blk fallback_addr;
+    } else fallback_addr;
+
+    const entry_fp = asm volatile ("mov %[fp], x29"
+        : [fp] "=r" (-> usize),
+    );
+    const entry_lr = asm volatile ("mov %[lr], x30"
+        : [lr] "=r" (-> usize),
+    );
+    const entry_sp = asm volatile ("mov %[sp], sp"
+        : [sp] "=r" (-> usize),
+    );
+
+    var addrs: [32]usize = undefined;
+    const n = collectStackAddresses(main_pc, &addrs, entry_fp, entry_lr, entry_sp);
+
+    var trace_buf: [768]u8 = undefined;
+    var fixed: std.Io.Writer = .fixed(&trace_buf);
+
+    fixed.print("Aether main returned error.{s} at 0x{x}\n", .{ @errorName(err), main_pc }) catch {};
+    fixed.print("entry_fp=0x{x} entry_sp=0x{x}\n", .{ entry_fp, entry_sp }) catch {};
+
+    if (maybe_trace) |trace| {
+        const nerr = @min(trace.index, trace.instruction_addresses.len);
+        if (nerr > 0) {
+            fixed.writeAll("error return trace:\n") catch {};
+            for (trace.instruction_addresses[0..nerr], 0..) |a, i| {
+                fixed.print("{d: >2}: 0x{x:0>16}\n", .{ i, a }) catch {};
+            }
+        }
+    }
+
+    fixed.writeAll("stack trace:\n") catch {};
+    const show = @min(n, 24);
+    for (addrs[0..show], 0..) |a, i| {
+        fixed.print("{d: >2}: 0x{x:0>16}\n", .{ i, a }) catch {};
+    }
+
+    const text = fixed.buffered();
+    debugString(text);
+    debugString("\n");
+    fatalWithContext(main_pc, entry_fp, entry_lr, entry_sp, 0, 0, 0, 0, addrs[0..n], 0);
+}
+
+pub fn panic(msg: []const u8, _: ?*std.builtin.StackTrace, first_trace_addr: ?usize) noreturn {
+    @branchHint(.cold);
+    @setRuntimeSafety(false);
+
+    if (panic_stage != 0) {
+        fatalDisplay("Aether recursive panic");
+    }
+    panic_stage = 1;
+
+    const first = first_trace_addr orelse @returnAddress();
+    const entry_fp = asm volatile ("mov %[fp], x29"
+        : [fp] "=r" (-> usize),
+    );
+    const entry_lr = asm volatile ("mov %[lr], x30"
+        : [lr] "=r" (-> usize),
+    );
+    const entry_sp = asm volatile ("mov %[sp], sp"
+        : [sp] "=r" (-> usize),
+    );
+
+    var addrs: [64]usize = undefined;
+    const n = collectStackAddresses(first, &addrs, entry_fp, entry_lr, entry_sp);
+
+    var trace_buf: [768]u8 = undefined;
+    var fixed: std.Io.Writer = .fixed(&trace_buf);
+
+    fixed.print("Aether panic at 0x{x}: {s}\n", .{ first, msg }) catch {};
+    fixed.print("entry_fp=0x{x} entry_sp=0x{x}\n", .{ entry_fp, entry_sp }) catch {};
+
+    if (@errorReturnTrace()) |t| {
+        const nerr = @min(t.index, t.instruction_addresses.len);
+        if (nerr > 0) {
+            fixed.writeAll("error return trace:\n") catch {};
+            for (t.instruction_addresses[0..nerr], 0..) |a, i| {
+                fixed.print("{d: >2}: 0x{x:0>16}\n", .{ i, a }) catch {};
+            }
+        }
+    }
+
+    fixed.writeAll("stack trace:\n") catch {};
+    const show = @min(n, 32);
+    for (addrs[0..show], 0..) |a, i| {
+        fixed.print("{d: >2}: 0x{x:0>16}\n", .{ i, a }) catch {};
+    }
+    if (n == 0) {
+        fixed.print("0: 0x{x:0>16}\n", .{first}) catch {};
+    }
+
+    const text = fixed.buffered();
+    debugString(text);
+    debugString("\n");
+    fatalWithContext(first, entry_fp, entry_lr, entry_sp, 0, 0, 0, 0, addrs[0..n], 0);
+}
+
+fn exceptionHandler(dump: *ThreadExceptionDump) callconv(.c) noreturn {
+    @branchHint(.cold);
+    @setRuntimeSafety(false);
+
+    const pc: usize = @intCast(dump.pc.x);
+    const fp: usize = @intCast(dump.fp.x);
+    const lr: usize = @intCast(dump.lr.x);
+    const sp: usize = @intCast(dump.sp.x);
+
+    var addrs: [32]usize = undefined;
+    const n = collectStackAddresses(pc, &addrs, fp, lr, sp);
+
+    var buf: [768]u8 = undefined;
+    var fixed: std.Io.Writer = .fixed(&buf);
+    fixed.print(
+        \\Aether {s}
+        \\PC=0x{x:0>16} LR=0x{x:0>16} SP=0x{x:0>16}
+        \\FAR=0x{x:0>16} ESR=0x{x:0>8} PSTATE=0x{x:0>8}
+        \\X0=0x{x:0>16} X1=0x{x:0>16} X2=0x{x:0>16} X3=0x{x:0>16}
+        \\stack trace:
+        \\
+    , .{
+        exceptionName(dump.error_desc),
+        pc,
+        lr,
+        sp,
+        dump.far.x,
+        dump.esr,
+        dump.pstate,
+        dump.cpu_gprs[0].x,
+        dump.cpu_gprs[1].x,
+        dump.cpu_gprs[2].x,
+        dump.cpu_gprs[3].x,
+    }) catch {};
+    const show = @min(n, 24);
+    for (addrs[0..show], 0..) |a, i| {
+        fixed.print("{d: >2}: 0x{x:0>16}\n", .{ i, a }) catch {};
+    }
+
+    const text = fixed.buffered();
+    debugString(text);
+    debugString("\n");
+
+    fatalWithContext(
+        pc,
+        fp,
+        lr,
+        sp,
+        dump.pstate,
+        dump.afsr0,
+        dump.afsr1,
+        dump.esr,
+        addrs[0..n],
+        dump.error_desc,
+    );
+}
+
+fn exceptionName(desc: u32) []const u8 {
+    return switch (desc) {
+        0x100 => "Instruction Abort",
+        0x102 => "Misaligned PC",
+        0x103 => "Misaligned SP",
+        0x106 => "SError",
+        0x301 => "Bad SVC",
+        0x104 => "CPU Trap",
+        0x101 => "CPU Exception",
+        else => "CPU Exception",
+    };
+}
+
+fn fatalWithContext(
+    pc: usize,
+    fp: usize,
+    lr: usize,
+    sp: usize,
+    pstate: u32,
+    afsr0: u32,
+    afsr1: u32,
+    esr: u32,
+    stack: []const usize,
+    typ: u32,
+) noreturn {
+    var ctx: FatalCpuContext = .{};
+    ctx.typ = typ;
+    ctx.aarch64_ctx.fp = fp;
+    ctx.aarch64_ctx.lr = lr;
+    ctx.aarch64_ctx.sp = sp;
+    ctx.aarch64_ctx.pc = pc;
+    ctx.aarch64_ctx.pstate = pstate;
+    ctx.aarch64_ctx.afsr0 = afsr0;
+    ctx.aarch64_ctx.afsr1 = afsr1;
+    ctx.aarch64_ctx.esr = esr;
+    ctx.aarch64_ctx.register_set_flags = (@as(u64, 1) << 29) | (@as(u64, 1) << 30) | (@as(u64, 1) << 31);
+
+    const n = @min(stack.len, ctx.aarch64_ctx.stack_trace.len);
+    for (stack[0..n], 0..) |addr, i| {
+        ctx.aarch64_ctx.stack_trace[i] = @intCast(addr);
+    }
+    ctx.aarch64_ctx.stack_trace_size = @intCast(n);
+
+    fatalThrowWithContext(fatal_result, FatalPolicy_ErrorScreen, &ctx);
+    _ = svcBreak(BreakReason_Panic, 0, 0);
+    while (true) {}
+}
+
+fn fatalDisplay(message: [:0]const u8) noreturn {
+    debugString(message);
+    debugString("\n");
+    _ = svcBreak(BreakReason_Panic, @intFromPtr(message.ptr), message.len);
+    while (true) {}
+}
+
+fn debugString(message: []const u8) void {
+    if (message.len == 0) return;
+    _ = svcOutputDebugString(message.ptr, @intCast(message.len));
+    _ = write(2, @ptrCast(message.ptr), message.len);
+}
diff --git a/src/platform/switch/surface.zig b/src/platform/switch/surface.zig
new file mode 100644
index 0000000..80f8f10
--- /dev/null
+++ b/src/platform/switch/surface.zig
@@ -0,0 +1,30 @@
+//! Switch surface stub.
+//!
+//! Switch's framebuffer is 1280x720 in handheld mode and 1920x1080
+//! docked. We advertise 1280x720 so the engine has a sane default;
+//! a real backend will query `appletGetOperationMode` and resize on
+//! dock transitions.
+
+const std = @import("std");
+const Self = @This();
+const c = @import("../nintendo_c.zig").c;
+
+alloc: std.mem.Allocator,
+
+pub fn init(_: *Self, _: u32, _: u32, _: [:0]const u8, _: bool, _: bool, _: bool) anyerror!void {}
+
+pub fn deinit(_: *Self) void {}
+
+pub fn update(_: *Self) bool {
+    return c.appletMainLoop();
+}
+
+pub fn draw(_: *Self) void {}
+
+pub fn get_width(_: *Self) u32 {
+    return 1280;
+}
+
+pub fn get_height(_: *Self) u32 {
+    return 720;
+}
diff --git a/src/platform/switch/switch_audio.zig b/src/platform/switch/switch_audio.zig
new file mode 100644
index 0000000..358dd11
--- /dev/null
+++ b/src/platform/switch/switch_audio.zig
@@ -0,0 +1,242 @@
+//! Switch audio backend -- audout with software mixing.
+//!
+//! audout exposes one 48 kHz stereo i16 output stream, so this backend mixes
+//! Aether's slots into a ring of audout buffers. A small nearest-neighbor
+//! resampler keeps the existing 44.1 kHz test WAVs playable.
+
+const std = @import("std");
+const Stream = @import("../../audio/stream.zig").Stream;
+const PcmFormat = @import("../../audio/stream.zig").PcmFormat;
+const c = @import("../nintendo_c.zig").c;
+
+const DEVICE_SAMPLE_RATE: u32 = 48_000;
+const DEVICE_CHANNELS: usize = 2;
+const NUM_SLOTS: usize = 24;
+const BUFFER_COUNT: usize = 3;
+const SAMPLES_PER_BUF: usize = 2048;
+const OUTPUT_BYTES: usize = SAMPLES_PER_BUF * DEVICE_CHANNELS * @sizeOf(i16);
+const OUTPUT_BUFFER_BYTES: usize = std.mem.alignForward(usize, OUTPUT_BYTES, 0x1000);
+const TOTAL_OUTPUT_BYTES: usize = BUFFER_COUNT * OUTPUT_BUFFER_BYTES;
+const FP_ONE: u64 = 1 << 32;
+
+const SlotState = enum(u8) {
+    inactive = 0,
+    pending = 1,
+    active = 2,
+    finished = 3,
+};
+
+const Slot = struct {
+    state: SlotState = .inactive,
+    gain: f32 = 0,
+    pan: f32 = 0,
+    stream: Stream = undefined,
+    format: PcmFormat = .{ .sample_rate = 44_100, .channels = 1, .bit_depth = 16 },
+    step_fp: u64 = FP_ONE,
+    phase_fp: u64 = 0,
+    current_left: i16 = 0,
+    current_right: i16 = 0,
+};
+
+var slots: [NUM_SLOTS]Slot = init_slots();
+var audio_alloc: std.mem.Allocator = undefined;
+var audio_io: std.Io = undefined;
+var output_data: ?[*]u8 = null;
+var buffers: [BUFFER_COUNT]c.AudioOutBuffer = undefined;
+var initialized: bool = false;
+
+fn init_slots() [NUM_SLOTS]Slot {
+    var s: [NUM_SLOTS]Slot = undefined;
+    for (&s) |*slot| {
+        slot.* = .{};
+    }
+    return s;
+}
+
+pub fn setup(alloc: std.mem.Allocator, io: std.Io) void {
+    audio_alloc = alloc;
+    audio_io = io;
+}
+
+pub fn init() anyerror!void {
+    _ = audio_alloc;
+    _ = audio_io;
+
+    output_data = @ptrCast(c.memalign(0x1000, TOTAL_OUTPUT_BYTES) orelse return error.AudioInitFailed);
+    @memset(output_data.?[0..TOTAL_OUTPUT_BYTES], 0);
+
+    if (c.audoutInitialize() != 0) {
+        free_output();
+        return error.AudioInitFailed;
+    }
+
+    if (c.audoutStartAudioOut() != 0) {
+        c.audoutExit();
+        free_output();
+        return error.AudioInitFailed;
+    }
+
+    initialized = true;
+
+    for (&buffers, 0..) |*buf, i| {
+        buf.* = .{
+            .next = null,
+            .buffer = @ptrCast(output_data.? + i * OUTPUT_BUFFER_BYTES),
+            .buffer_size = OUTPUT_BUFFER_BYTES,
+            .data_size = OUTPUT_BYTES,
+            .data_offset = 0,
+        };
+        if (c.audoutAppendAudioOutBuffer(buf) != 0) {
+            _ = c.audoutStopAudioOut();
+            c.audoutExit();
+            initialized = false;
+            free_output();
+            return error.AudioInitFailed;
+        }
+    }
+}
+
+pub fn deinit() void {
+    if (initialized) {
+        _ = c.audoutStopAudioOut();
+        c.audoutExit();
+        initialized = false;
+    }
+
+    free_output();
+
+    for (&slots) |*slot| {
+        slot.state = .inactive;
+    }
+}
+
+pub fn update() void {
+    if (!initialized) return;
+
+    while (true) {
+        var released: ?*c.AudioOutBuffer = null;
+        var released_count: u32 = 0;
+        if (c.audoutGetReleasedAudioOutBuffer(&released, &released_count) != 0) return;
+        if (released_count == 0 or released == null) return;
+
+        const buf = released.?;
+        fill_output_buffer(buf);
+        _ = c.audoutAppendAudioOutBuffer(buf);
+    }
+}
+
+pub fn max_voices() u32 {
+    return NUM_SLOTS;
+}
+
+pub fn play_slot(slot: u8, stream: Stream) anyerror!void {
+    if (slot >= NUM_SLOTS) return error.InvalidArgs;
+    if (!format_supported(stream.format)) return error.UnsupportedFormat;
+
+    const i: usize = slot;
+    slots[i].stream = stream;
+    slots[i].format = stream.format;
+    slots[i].step_fp = (@as(u64, stream.format.sample_rate) << 32) / DEVICE_SAMPLE_RATE;
+    slots[i].phase_fp = 0;
+    slots[i].current_left = 0;
+    slots[i].current_right = 0;
+    slots[i].state = .pending;
+}
+
+pub fn stop_slot(slot: u8) void {
+    if (slot >= NUM_SLOTS) return;
+    slots[slot].state = .inactive;
+}
+
+pub fn set_slot_gain_pan(slot: u8, gain: f32, pan: f32) void {
+    if (slot >= NUM_SLOTS) return;
+    slots[slot].gain = gain;
+    slots[slot].pan = pan;
+}
+
+pub fn is_slot_active(slot: u8) bool {
+    if (slot >= NUM_SLOTS) return false;
+    return slots[slot].state != .inactive and slots[slot].state != .finished;
+}
+
+fn fill_output_buffer(buf: *c.AudioOutBuffer) void {
+    const out: [*]i16 = @ptrCast(@alignCast(buf.buffer.?));
+
+    for (0..SAMPLES_PER_BUF) |frame| {
+        var left_acc: i32 = 0;
+        var right_acc: i32 = 0;
+
+        for (&slots) |*slot| {
+            if (slot.state == .pending) {
+                if (read_next_sample(slot)) {
+                    slot.state = .active;
+                } else {
+                    slot.state = .finished;
+                }
+            }
+
+            if (slot.state != .active) continue;
+
+            const left_gain = slot.gain * std.math.clamp(1.0 - slot.pan, 0.0, 1.0);
+            const right_gain = slot.gain * std.math.clamp(1.0 + slot.pan, 0.0, 1.0);
+            const left_vol: i32 = @intFromFloat(std.math.clamp(left_gain, 0.0, 1.0) * 32768.0);
+            const right_vol: i32 = @intFromFloat(std.math.clamp(right_gain, 0.0, 1.0) * 32768.0);
+
+            left_acc += (@as(i32, slot.current_left) * left_vol) >> 15;
+            right_acc += (@as(i32, slot.current_right) * right_vol) >> 15;
+
+            advance_sample(slot);
+        }
+
+        out[frame * 2] = clamp_i16(left_acc);
+        out[frame * 2 + 1] = clamp_i16(right_acc);
+    }
+
+    buf.data_size = OUTPUT_BYTES;
+    buf.data_offset = 0;
+}
+
+fn advance_sample(slot: *Slot) void {
+    slot.phase_fp +%= slot.step_fp;
+    while (slot.phase_fp >= FP_ONE) {
+        slot.phase_fp -= FP_ONE;
+        if (!read_next_sample(slot)) {
+            slot.state = .finished;
+            return;
+        }
+    }
+}
+
+fn read_next_sample(slot: *Slot) bool {
+    var tmp: [4]u8 = undefined;
+    const frame_size = slot.format.frame_size();
+    if (frame_size > tmp.len) return false;
+
+    slot.stream.reader.readSliceAll(tmp[0..frame_size]) catch return false;
+
+    if (slot.format.channels == 1) {
+        const s = std.mem.readInt(i16, tmp[0..2], .little);
+        slot.current_left = s;
+        slot.current_right = s;
+    } else {
+        slot.current_left = std.mem.readInt(i16, tmp[0..2], .little);
+        slot.current_right = std.mem.readInt(i16, tmp[2..4], .little);
+    }
+
+    return true;
+}
+
+fn clamp_i16(v: i32) i16 {
+    return @intCast(std.math.clamp(v, std.math.minInt(i16), std.math.maxInt(i16)));
+}
+
+fn free_output() void {
+    if (output_data) |data| {
+        c.free(data);
+        output_data = null;
+    }
+}
+
+fn format_supported(fmt: PcmFormat) bool {
+    return fmt.bit_depth == 16 and (fmt.channels == 1 or fmt.channels == 2);
+}
diff --git a/src/platform/switch/switch_gfx.zig b/src/platform/switch/switch_gfx.zig
new file mode 100644
index 0000000..c6c2341
--- /dev/null
+++ b/src/platform/switch/switch_gfx.zig
@@ -0,0 +1,759 @@
+//! Minimal Nintendo Switch deko3d backend.
+//!
+//! This is the first bring-up milestone: render Aether's current colored
+//! demo mesh through deko3d and present it. Textures, matrices, and richer
+//! render state are intentionally left as no-ops until the full backend pass.
+
+const std = @import("std");
+const Util = @import("../../util/util.zig");
+const Mat4 = @import("../../math/math.zig").Mat4;
+const Rendering = @import("../../rendering/rendering.zig");
+const vertex = Rendering.vertex;
+const Mesh = Rendering.mesh;
+const Texture = Rendering.Texture;
+const gfx = @import("../gfx.zig");
+const shader_data = @import("aether_shaders");
+
+const DkDevice_T = opaque {};
+const DkMemBlock_T = opaque {};
+const DkCmdBuf_T = opaque {};
+const DkQueue_T = opaque {};
+const DkSwapchain_T = opaque {};
+
+const DkDevice = ?*DkDevice_T;
+const DkMemBlock = ?*DkMemBlock_T;
+const DkCmdBuf = ?*DkCmdBuf_T;
+const DkQueue = ?*DkQueue_T;
+const DkSwapchain = ?*DkSwapchain_T;
+const DkGpuAddr = u64;
+const DkCmdList = usize;
+
+const DkDeviceMaker = extern struct {
+    userData: ?*anyopaque,
+    cbDebug: ?*const anyopaque,
+    cbAlloc: ?*const anyopaque,
+    cbFree: ?*const anyopaque,
+    flags: u32,
+};
+
+const DkMemBlockMaker = extern struct {
+    device: DkDevice,
+    size: u32,
+    flags: u32,
+    storage: ?*anyopaque,
+};
+
+const DkCmdBufMaker = extern struct {
+    device: DkDevice,
+    userData: ?*anyopaque,
+    cbAddMem: ?*const anyopaque,
+};
+
+const DkQueueMaker = extern struct {
+    device: DkDevice,
+    flags: u32,
+    commandMemorySize: u32,
+    flushThreshold: u32,
+    perWarpScratchMemorySize: u32,
+    maxConcurrentComputeJobs: u32,
+};
+
+const DkShaderMaker = extern struct {
+    codeMem: DkMemBlock,
+    control: ?*const anyopaque,
+    codeOffset: u32,
+    programId: u32,
+};
+
+const DkImageLayoutMaker = extern struct {
+    device: DkDevice,
+    type: u32,
+    flags: u32,
+    format: u32,
+    msMode: u32,
+    dimensions: [3]u32,
+    mipLevels: u32,
+    pitchStride: u32,
+};
+
+const DkSwapchainMaker = extern struct {
+    device: DkDevice,
+    nativeWindow: ?*anyopaque,
+    pImages: [*]const *const DkImage,
+    numImages: u32,
+};
+
+const DkShader = extern struct {
+    storage: [16]u64,
+};
+
+const DkImageLayout = extern struct {
+    storage: [16]u64,
+};
+
+const DkImage = extern struct {
+    storage: [16]u64,
+};
+
+const DkImageView = extern struct {
+    pImage: *const DkImage,
+    type: u32,
+    format: u32,
+    swizzle: [4]u32,
+    dsSource: u32,
+    layerOffset: u16,
+    layerCount: u16,
+    mipLevelOffset: u8,
+    mipLevelCount: u8,
+};
+
+const DkViewport = extern struct {
+    x: f32,
+    y: f32,
+    width: f32,
+    height: f32,
+    near: f32,
+    far: f32,
+};
+
+const DkScissor = extern struct {
+    x: u32,
+    y: u32,
+    width: u32,
+    height: u32,
+};
+
+const DkRasterizerState = extern struct {
+    bits: u32,
+};
+
+const DkColorState = extern struct {
+    bits: u32,
+};
+
+const DkColorWriteState = extern struct {
+    masks: u32,
+};
+
+const DkDepthStencilState = extern struct {
+    bits0: u32,
+    bits1: u32,
+};
+
+const DkVtxAttribState = extern struct {
+    bits: u32,
+};
+
+const DkVtxBufferState = extern struct {
+    stride: u32,
+    divisor: u32,
+};
+
+const DkBufExtents = extern struct {
+    addr: DkGpuAddr,
+    size: u32,
+};
+
+extern fn nwindowGetDefault() ?*anyopaque;
+
+extern fn dkDeviceCreate(maker: *const DkDeviceMaker) DkDevice;
+extern fn dkDeviceDestroy(obj: DkDevice) void;
+
+extern fn dkMemBlockCreate(maker: *const DkMemBlockMaker) DkMemBlock;
+extern fn dkMemBlockDestroy(obj: DkMemBlock) void;
+extern fn dkMemBlockGetCpuAddr(obj: DkMemBlock) ?*anyopaque;
+extern fn dkMemBlockGetGpuAddr(obj: DkMemBlock) DkGpuAddr;
+extern fn dkMemBlockGetSize(obj: DkMemBlock) u32;
+extern fn dkMemBlockFlushCpuCache(obj: DkMemBlock, offset: u32, size: u32) u32;
+
+extern fn dkCmdBufCreate(maker: *const DkCmdBufMaker) DkCmdBuf;
+extern fn dkCmdBufDestroy(obj: DkCmdBuf) void;
+extern fn dkCmdBufAddMemory(obj: DkCmdBuf, mem: DkMemBlock, offset: u32, size: u32) void;
+extern fn dkCmdBufFinishList(obj: DkCmdBuf) DkCmdList;
+extern fn dkCmdBufClear(obj: DkCmdBuf) void;
+extern fn dkCmdBufBindShaders(obj: DkCmdBuf, stageMask: u32, shaders: [*]const *const DkShader, numShaders: u32) void;
+extern fn dkCmdBufBindRenderTargets(obj: DkCmdBuf, colorTargets: [*]const *const DkImageView, numColorTargets: u32, depthTarget: ?*const DkImageView) void;
+extern fn dkCmdBufBindRasterizerState(obj: DkCmdBuf, state: *const DkRasterizerState) void;
+extern fn dkCmdBufBindColorState(obj: DkCmdBuf, state: *const DkColorState) void;
+extern fn dkCmdBufBindColorWriteState(obj: DkCmdBuf, state: *const DkColorWriteState) void;
+extern fn dkCmdBufBindDepthStencilState(obj: DkCmdBuf, state: *const DkDepthStencilState) void;
+extern fn dkCmdBufBindVtxAttribState(obj: DkCmdBuf, attribs: [*]const DkVtxAttribState, numAttribs: u32) void;
+extern fn dkCmdBufBindVtxBufferState(obj: DkCmdBuf, buffers: [*]const DkVtxBufferState, numBuffers: u32) void;
+extern fn dkCmdBufBindVtxBuffers(obj: DkCmdBuf, firstId: u32, buffers: [*]const DkBufExtents, numBuffers: u32) void;
+extern fn dkCmdBufSetViewports(obj: DkCmdBuf, firstId: u32, viewports: [*]const DkViewport, numViewports: u32) void;
+extern fn dkCmdBufSetScissors(obj: DkCmdBuf, firstId: u32, scissors: [*]const DkScissor, numScissors: u32) void;
+extern fn dkCmdBufClearColor(obj: DkCmdBuf, targetId: u32, clearMask: u32, clearData: *const anyopaque) void;
+extern fn dkCmdBufDraw(obj: DkCmdBuf, prim: u32, vertexCount: u32, instanceCount: u32, firstVertex: u32, firstInstance: u32) void;
+
+extern fn dkQueueCreate(maker: *const DkQueueMaker) DkQueue;
+extern fn dkQueueDestroy(obj: DkQueue) void;
+extern fn dkQueueWaitIdle(obj: DkQueue) void;
+extern fn dkQueueSubmitCommands(obj: DkQueue, cmds: DkCmdList) void;
+extern fn dkQueueAcquireImage(obj: DkQueue, swapchain: DkSwapchain) c_int;
+extern fn dkQueuePresentImage(obj: DkQueue, swapchain: DkSwapchain, imageSlot: c_int) void;
+
+extern fn dkShaderInitialize(obj: *DkShader, maker: *const DkShaderMaker) void;
+extern fn dkShaderIsValid(obj: *const DkShader) bool;
+
+extern fn dkImageLayoutInitialize(obj: *DkImageLayout, maker: *const DkImageLayoutMaker) void;
+extern fn dkImageLayoutGetSize(obj: *const DkImageLayout) u64;
+extern fn dkImageLayoutGetAlignment(obj: *const DkImageLayout) u32;
+extern fn dkImageInitialize(obj: *DkImage, layout: *const DkImageLayout, memBlock: DkMemBlock, offset: u32) void;
+
+extern fn dkSwapchainCreate(maker: *const DkSwapchainMaker) DkSwapchain;
+extern fn dkSwapchainDestroy(obj: DkSwapchain) void;
+extern fn dkSwapchainSetSwapInterval(obj: DkSwapchain, interval: u32) void;
+
+const FB_COUNT = 2;
+const FB_WIDTH = 1280;
+const FB_HEIGHT = 720;
+const CODE_MEM_SIZE = 512 * 1024;
+const CMD_MEM_SIZE = 64 * 1024;
+const MAX_VERTEX_ATTRIBS = 32;
+const MAX_VERTEX_BUFFERS = 16;
+
+const DK_MEMBLOCK_ALIGNMENT = 0x1000;
+const DK_SHADER_CODE_ALIGNMENT = 0x100;
+
+const DK_MEM_CPU_UNCACHED = 1 << 0;
+const DK_MEM_GPU_CACHED = 2 << 2;
+const DK_MEM_CODE = 1 << 4;
+const DK_MEM_IMAGE = 1 << 5;
+
+const DK_QUEUE_GRAPHICS = 1 << 0;
+const DK_QUEUE_MEDIUM_PRIO = 0 << 2;
+const DK_QUEUE_ENABLE_ZCULL = 0 << 4;
+const DK_QUEUE_MIN_CMDMEM_SIZE = 0x10000;
+const DK_PER_WARP_SCRATCH_MEM_ALIGNMENT = 0x200;
+const DK_DEFAULT_MAX_COMPUTE_CONCURRENT_JOBS = 128;
+
+const DK_IMAGE_TYPE_NONE = 0;
+const DK_IMAGE_TYPE_2D = 2;
+const DK_IMAGE_RGBA8_UNORM = 28;
+const DK_IMAGE_USAGE_RENDER = 1 << 8;
+const DK_IMAGE_USAGE_PRESENT = 1 << 10;
+const DK_IMAGE_HW_COMPRESSION = 1 << 2;
+
+const DK_STAGE_GRAPHICS_MASK = (1 << 5) - 1;
+const DK_COLOR_MASK_RGBA = 0xF;
+
+const DK_PRIMITIVE_LINES = 1;
+const DK_PRIMITIVE_TRIANGLES = 4;
+
+const DK_ATTR_SIZE_2X32 = 0x04;
+const DK_ATTR_SIZE_3X32 = 0x02;
+const DK_ATTR_SIZE_2X16 = 0x0f;
+const DK_ATTR_SIZE_3X16 = 0x05;
+const DK_ATTR_SIZE_2X8 = 0x18;
+const DK_ATTR_SIZE_4X8 = 0x0a;
+
+const DK_ATTR_TYPE_SNORM = 1;
+const DK_ATTR_TYPE_UNORM = 2;
+const DK_ATTR_TYPE_FLOAT = 7;
+
+const DK_SWIZZLE_RED = 2;
+const DK_SWIZZLE_GREEN = 3;
+const DK_SWIZZLE_BLUE = 4;
+const DK_SWIZZLE_ALPHA = 5;
+const DK_DS_SOURCE_DEPTH = 0;
+
+const PipelineData = struct {
+    vertex_shader: DkShader,
+    fragment_shader: DkShader,
+    attribs: [MAX_VERTEX_ATTRIBS]DkVtxAttribState,
+    attrib_count: u32,
+    vtx_buffers: [MAX_VERTEX_BUFFERS]DkVtxBufferState,
+    vtx_buffer_count: u32,
+};
+
+const MeshData = struct {
+    mem_block: DkMemBlock = null,
+    gpu_addr: DkGpuAddr = 0,
+    capacity: u32 = 0,
+    size: u32 = 0,
+};
+
+var render_alloc: std.mem.Allocator = undefined;
+var render_io: std.Io = undefined;
+
+var device: DkDevice = null;
+var render_queue: DkQueue = null;
+var swapchain: DkSwapchain = null;
+var framebuffer_mem: DkMemBlock = null;
+var framebuffers: [FB_COUNT]DkImage = undefined;
+var command_mem: DkMemBlock = null;
+var command_buffer: DkCmdBuf = null;
+var code_mem: DkMemBlock = null;
+var code_offset: u32 = 0;
+
+var meshes = Util.CircularBuffer(MeshData, 8192).init();
+var render_pipeline: PipelineData = undefined;
+
+var render_pipeline_initialized = false;
+var current_slot: c_int = -1;
+var initialized: bool = false;
+var clear_color: [4]f32 = .{ 0.0, 0.0, 0.0, 1.0 };
+var vsync_enabled: bool = true;
+
+pub fn setup(alloc: std.mem.Allocator, io: std.Io) void {
+    render_alloc = alloc;
+    render_io = io;
+}
+
+pub fn init() anyerror!void {
+    _ = render_alloc;
+    _ = render_io;
+
+    var device_maker = DkDeviceMaker{
+        .userData = null,
+        .cbDebug = null,
+        .cbAlloc = null,
+        .cbFree = null,
+        .flags = 0,
+    };
+    device = dkDeviceCreate(&device_maker);
+    if (device == null) return error.GfxInitFailed;
+    errdefer {
+        dkDeviceDestroy(device);
+        device = null;
+    }
+
+    try create_framebuffers();
+    errdefer destroy_framebuffers();
+
+    try create_code_memory();
+    errdefer destroy_code_memory();
+
+    render_pipeline = try init_pipeline(vertex.Layout);
+    render_pipeline_initialized = true;
+
+    try create_command_buffer();
+    errdefer destroy_command_buffer();
+
+    var queue_maker = DkQueueMaker{
+        .device = device,
+        .flags = DK_QUEUE_GRAPHICS | DK_QUEUE_MEDIUM_PRIO | DK_QUEUE_ENABLE_ZCULL,
+        .commandMemorySize = DK_QUEUE_MIN_CMDMEM_SIZE,
+        .flushThreshold = DK_QUEUE_MIN_CMDMEM_SIZE / 8,
+        .perWarpScratchMemorySize = 4 * DK_PER_WARP_SCRATCH_MEM_ALIGNMENT,
+        .maxConcurrentComputeJobs = DK_DEFAULT_MAX_COMPUTE_CONCURRENT_JOBS,
+    };
+    render_queue = dkQueueCreate(&queue_maker);
+    if (render_queue == null) return error.GfxInitFailed;
+
+    initialized = true;
+    set_vsync(vsync_enabled);
+}
+
+pub fn deinit() void {
+    if (render_queue) |_| dkQueueWaitIdle(render_queue);
+
+    destroy_all_meshes();
+    render_pipeline_initialized = false;
+
+    if (render_queue) |_| {
+        dkQueueDestroy(render_queue);
+        render_queue = null;
+    }
+
+    destroy_command_buffer();
+    destroy_code_memory();
+    destroy_framebuffers();
+
+    if (device) |_| {
+        dkDeviceDestroy(device);
+        device = null;
+    }
+
+    initialized = false;
+}
+
+pub fn set_clear_color(r: f32, g: f32, b: f32, a: f32) void {
+    clear_color = .{ r, g, b, a };
+}
+
+pub fn set_alpha_blend(_: bool) void {}
+pub fn set_depth_write(_: bool) void {}
+pub fn set_fog(_: bool, _: f32, _: f32, _: f32, _: f32, _: f32) void {}
+pub fn set_clip_planes(_: bool) void {}
+pub fn set_culling(_: bool) void {}
+pub fn set_uv_offset(_: f32, _: f32) void {}
+pub fn set_proj_matrix(_: *const Mat4) void {}
+pub fn set_view_matrix(_: *const Mat4) void {}
+
+pub fn start_frame() bool {
+    if (!initialized or render_queue == null or swapchain == null or command_buffer == null) return false;
+
+    // Single command-memory arena for the bring-up path. Wait before reuse so
+    // the GPU cannot still be reading last frame's command list.
+    dkQueueWaitIdle(render_queue);
+
+    const slot = dkQueueAcquireImage(render_queue, swapchain);
+    if (slot < 0 or slot >= FB_COUNT) return false;
+    current_slot = slot;
+
+    dkCmdBufClear(command_buffer);
+    dkCmdBufAddMemory(command_buffer, command_mem, 0, CMD_MEM_SIZE);
+
+    var color_view = imageView(&framebuffers[@intCast(slot)]);
+    const color_targets = [_]*const DkImageView{&color_view};
+    dkCmdBufBindRenderTargets(command_buffer, color_targets[0..].ptr, 1, null);
+
+    const width = gfx.surface.get_width();
+    const height = gfx.surface.get_height();
+    if (width == 0 or height == 0) return false;
+
+    var viewport = DkViewport{
+        .x = 0.0,
+        .y = 0.0,
+        .width = @floatFromInt(width),
+        .height = @floatFromInt(height),
+        .near = 0.0,
+        .far = 1.0,
+    };
+    var scissor = DkScissor{
+        .x = 0,
+        .y = 0,
+        .width = width,
+        .height = height,
+    };
+    dkCmdBufSetViewports(command_buffer, 0, @ptrCast(&viewport), 1);
+    dkCmdBufSetScissors(command_buffer, 0, @ptrCast(&scissor), 1);
+    dkCmdBufClearColor(command_buffer, 0, DK_COLOR_MASK_RGBA, &clear_color);
+
+    bind_fixed_state();
+    return true;
+}
+
+pub fn end_frame() void {
+    if (!initialized or render_queue == null or swapchain == null or command_buffer == null or current_slot < 0) return;
+
+    const list = dkCmdBufFinishList(command_buffer);
+    dkQueueSubmitCommands(render_queue, list);
+    dkQueuePresentImage(render_queue, swapchain, current_slot);
+    current_slot = -1;
+}
+
+pub fn clear_depth() void {}
+
+pub fn set_vsync(v: bool) void {
+    vsync_enabled = v;
+    if (swapchain) |_| dkSwapchainSetSwapInterval(swapchain, @intFromBool(v));
+}
+
+fn init_pipeline(layout: vertex.VertexLayout) !PipelineData {
+    const vertex_code: [:0]align(4) const u8 = &shader_data.basic_vert;
+    const fragment_code: [:0]align(4) const u8 = &shader_data.basic_frag;
+
+    var data = PipelineData{
+        .vertex_shader = undefined,
+        .fragment_shader = undefined,
+        .attribs = @splat(.{ .bits = 0 }),
+        .attrib_count = 0,
+        .vtx_buffers = @splat(.{ .stride = 0, .divisor = 0 }),
+        .vtx_buffer_count = 0,
+    };
+
+    try init_layout(&data, layout);
+    try load_shader(&data.vertex_shader, vertex_code);
+    try load_shader(&data.fragment_shader, fragment_code);
+
+    return data;
+}
+
+pub fn create_mesh() anyerror!Mesh.Handle {
+    const mesh = meshes.add_element(.{}) orelse return error.OutOfMeshes;
+    return @intCast(mesh);
+}
+
+pub fn destroy_mesh(handle: Mesh.Handle) void {
+    const mesh = meshes.get_element(handle) orelse return;
+    if (mesh.mem_block) |_| dkMemBlockDestroy(mesh.mem_block);
+    _ = meshes.remove_element(handle);
+}
+
+pub fn update_mesh(handle: Mesh.Handle, data: []const u8) void {
+    var mesh = meshes.get_element(handle) orelse return;
+
+    if (data.len == 0) {
+        mesh.size = 0;
+        meshes.update_element(handle, mesh);
+        return;
+    }
+
+    const needed: u32 = @intCast(data.len);
+    if (mesh.mem_block == null or mesh.capacity < needed) {
+        if (mesh.mem_block) |_| dkMemBlockDestroy(mesh.mem_block);
+
+        const alloc_size = alignForward(needed, DK_MEMBLOCK_ALIGNMENT);
+        var maker = memBlockMaker(alloc_size, DK_MEM_CPU_UNCACHED | DK_MEM_GPU_CACHED);
+        mesh.mem_block = dkMemBlockCreate(&maker);
+        if (mesh.mem_block == null) {
+            mesh.capacity = 0;
+            mesh.size = 0;
+            meshes.update_element(handle, mesh);
+            return;
+        }
+        mesh.capacity = dkMemBlockGetSize(mesh.mem_block);
+        mesh.gpu_addr = dkMemBlockGetGpuAddr(mesh.mem_block);
+    }
+
+    const dst: [*]u8 = @ptrCast(dkMemBlockGetCpuAddr(mesh.mem_block) orelse return);
+    @memcpy(dst[0..data.len], data);
+    _ = dkMemBlockFlushCpuCache(mesh.mem_block, 0, needed);
+
+    mesh.size = needed;
+    meshes.update_element(handle, mesh);
+}
+
+pub fn draw_mesh(handle: Mesh.Handle, _: *const Mat4, count: usize) void {
+    if (!initialized or !render_pipeline_initialized or command_buffer == null) return;
+    const mesh = meshes.get_element(handle) orelse return;
+    if (mesh.mem_block == null or mesh.size == 0 or count == 0) return;
+
+    const pl = &render_pipeline;
+
+    const shaders = [_]*const DkShader{ &pl.vertex_shader, &pl.fragment_shader };
+    dkCmdBufBindShaders(command_buffer, DK_STAGE_GRAPHICS_MASK, shaders[0..].ptr, shaders.len);
+    dkCmdBufBindVtxAttribState(command_buffer, pl.attribs[0..].ptr, pl.attrib_count);
+    dkCmdBufBindVtxBufferState(command_buffer, pl.vtx_buffers[0..].ptr, pl.vtx_buffer_count);
+
+    var extents: [MAX_VERTEX_BUFFERS]DkBufExtents = undefined;
+    for (extents[0..pl.vtx_buffer_count]) |*extent| {
+        extent.* = .{ .addr = mesh.gpu_addr, .size = mesh.size };
+    }
+    dkCmdBufBindVtxBuffers(command_buffer, 0, extents[0..].ptr, pl.vtx_buffer_count);
+
+    dkCmdBufDraw(command_buffer, DK_PRIMITIVE_TRIANGLES, @intCast(count), 1, 0, 0);
+}
+
+pub fn create_texture(_: u32, _: u32, _: []align(16) u8) anyerror!Texture.Handle {
+    return 0;
+}
+
+pub fn update_texture(_: Texture.Handle, _: []align(16) u8) void {}
+pub fn bind_texture(_: Texture.Handle) void {}
+pub fn destroy_texture(_: Texture.Handle) void {}
+pub fn force_texture_resident(_: Texture.Handle) void {}
+
+fn create_framebuffers() !void {
+    var layout_maker = DkImageLayoutMaker{
+        .device = device,
+        .type = DK_IMAGE_TYPE_2D,
+        .flags = DK_IMAGE_USAGE_RENDER | DK_IMAGE_USAGE_PRESENT | DK_IMAGE_HW_COMPRESSION,
+        .format = DK_IMAGE_RGBA8_UNORM,
+        .msMode = 0,
+        .dimensions = .{ FB_WIDTH, FB_HEIGHT, 0 },
+        .mipLevels = 1,
+        .pitchStride = 0,
+    };
+
+    var framebuffer_layout: DkImageLayout = undefined;
+    dkImageLayoutInitialize(&framebuffer_layout, &layout_maker);
+
+    const fb_align = dkImageLayoutGetAlignment(&framebuffer_layout);
+    const fb_size = alignForward(@intCast(dkImageLayoutGetSize(&framebuffer_layout)), fb_align);
+    var mem_maker = memBlockMaker(FB_COUNT * fb_size, DK_MEM_GPU_CACHED | DK_MEM_IMAGE);
+    framebuffer_mem = dkMemBlockCreate(&mem_maker);
+    if (framebuffer_mem == null) return error.GfxInitFailed;
+    errdefer {
+        dkMemBlockDestroy(framebuffer_mem);
+        framebuffer_mem = null;
+    }
+
+    var swapchain_images: [FB_COUNT]*const DkImage = undefined;
+    for (&framebuffers, 0..) |*fb, i| {
+        dkImageInitialize(fb, &framebuffer_layout, framebuffer_mem, @intCast(i * fb_size));
+        swapchain_images[i] = fb;
+    }
+
+    var swapchain_maker = DkSwapchainMaker{
+        .device = device,
+        .nativeWindow = nwindowGetDefault(),
+        .pImages = swapchain_images[0..].ptr,
+        .numImages = FB_COUNT,
+    };
+    swapchain = dkSwapchainCreate(&swapchain_maker);
+    if (swapchain == null) return error.GfxInitFailed;
+}
+
+fn destroy_framebuffers() void {
+    if (swapchain) |_| {
+        dkSwapchainDestroy(swapchain);
+        swapchain = null;
+    }
+    if (framebuffer_mem) |_| {
+        dkMemBlockDestroy(framebuffer_mem);
+        framebuffer_mem = null;
+    }
+}
+
+fn create_code_memory() !void {
+    var maker = memBlockMaker(CODE_MEM_SIZE, DK_MEM_CPU_UNCACHED | DK_MEM_GPU_CACHED | DK_MEM_CODE);
+    code_mem = dkMemBlockCreate(&maker);
+    if (code_mem == null) return error.GfxInitFailed;
+    code_offset = 0;
+}
+
+fn destroy_code_memory() void {
+    if (code_mem) |_| {
+        dkMemBlockDestroy(code_mem);
+        code_mem = null;
+    }
+    code_offset = 0;
+}
+
+fn create_command_buffer() !void {
+    var mem_maker = memBlockMaker(CMD_MEM_SIZE, DK_MEM_CPU_UNCACHED | DK_MEM_GPU_CACHED);
+    command_mem = dkMemBlockCreate(&mem_maker);
+    if (command_mem == null) return error.GfxInitFailed;
+    errdefer {
+        dkMemBlockDestroy(command_mem);
+        command_mem = null;
+    }
+
+    var cmd_maker = DkCmdBufMaker{
+        .device = device,
+        .userData = null,
+        .cbAddMem = null,
+    };
+    command_buffer = dkCmdBufCreate(&cmd_maker);
+    if (command_buffer == null) return error.GfxInitFailed;
+}
+
+fn destroy_command_buffer() void {
+    if (command_buffer) |_| {
+        dkCmdBufDestroy(command_buffer);
+        command_buffer = null;
+    }
+    if (command_mem) |_| {
+        dkMemBlockDestroy(command_mem);
+        command_mem = null;
+    }
+}
+
+fn destroy_all_meshes() void {
+    for (&meshes.buffer) |*slot| {
+        if (slot.*) |mesh| {
+            if (mesh.mem_block) |_| dkMemBlockDestroy(mesh.mem_block);
+            slot.* = null;
+        }
+    }
+    meshes.clear();
+}
+
+fn memBlockMaker(size: u32, flags: u32) DkMemBlockMaker {
+    return .{
+        .device = device,
+        .size = alignForward(size, DK_MEMBLOCK_ALIGNMENT),
+        .flags = flags,
+        .storage = null,
+    };
+}
+
+fn load_shader(shader: *DkShader, code: []const u8) !void {
+    if (code_mem == null) return error.GfxInitFailed;
+
+    const offset = alignForward(code_offset, DK_SHADER_CODE_ALIGNMENT);
+    const end = offset + alignForward(@intCast(code.len), DK_SHADER_CODE_ALIGNMENT);
+    if (end > CODE_MEM_SIZE) return error.OutOfShaderMemory;
+
+    const base: [*]u8 = @ptrCast(dkMemBlockGetCpuAddr(code_mem) orelse return error.GfxInitFailed);
+    @memcpy(base[offset..][0..code.len], code);
+
+    var maker = DkShaderMaker{
+        .codeMem = code_mem,
+        .control = null,
+        .codeOffset = offset,
+        .programId = 0,
+    };
+    dkShaderInitialize(shader, &maker);
+    if (!dkShaderIsValid(shader)) return error.InvalidShader;
+
+    code_offset = end;
+}
+
+fn init_layout(data: *PipelineData, layout: vertex.VertexLayout) !void {
+    var max_location: u32 = 0;
+    var max_binding: u32 = 0;
+
+    for (layout.attributes) |attr| {
+        if (attr.location >= MAX_VERTEX_ATTRIBS or attr.binding >= MAX_VERTEX_BUFFERS) {
+            return error.UnsupportedVertexLayout;
+        }
+
+        const loc: usize = attr.location;
+        data.attribs[loc] = vtxAttrib(attr);
+        max_location = @max(max_location, attr.location + 1);
+        max_binding = @max(max_binding, attr.binding + 1);
+    }
+
+    for (data.vtx_buffers[0..max_binding]) |*buf| {
+        buf.* = .{ .stride = @intCast(layout.stride), .divisor = 0 };
+    }
+
+    data.attrib_count = max_location;
+    data.vtx_buffer_count = @max(max_binding, 1);
+}
+
+fn vtxAttrib(attr: vertex.Attribute) DkVtxAttribState {
+    const Format = struct {
+        size: u32,
+        kind: u32,
+    };
+    const fmt: Format = switch (attr.format) {
+        .f32x2 => .{ .size = DK_ATTR_SIZE_2X32, .kind = DK_ATTR_TYPE_FLOAT },
+        .f32x3 => .{ .size = DK_ATTR_SIZE_3X32, .kind = DK_ATTR_TYPE_FLOAT },
+        .unorm8x2 => .{ .size = DK_ATTR_SIZE_2X8, .kind = DK_ATTR_TYPE_UNORM },
+        .unorm8x4 => .{ .size = DK_ATTR_SIZE_4X8, .kind = DK_ATTR_TYPE_UNORM },
+        .unorm16x2 => .{ .size = DK_ATTR_SIZE_2X16, .kind = DK_ATTR_TYPE_UNORM },
+        .unorm16x3 => .{ .size = DK_ATTR_SIZE_3X16, .kind = DK_ATTR_TYPE_UNORM },
+        .snorm16x2 => .{ .size = DK_ATTR_SIZE_2X16, .kind = DK_ATTR_TYPE_SNORM },
+        .snorm16x3 => .{ .size = DK_ATTR_SIZE_3X16, .kind = DK_ATTR_TYPE_SNORM },
+    };
+
+    return .{ .bits = (@as(u32, attr.binding) & 0x1F) |
+        ((@as(u32, @intCast(attr.offset)) & 0x3FFF) << 7) |
+        ((fmt.size & 0x3F) << 21) |
+        ((fmt.kind & 0x7) << 27) };
+}
+
+fn bind_fixed_state() void {
+    const rasterizer = DkRasterizerState{
+        // rasterizer on, fill both faces, no culling, CCW front face.
+        .bits = 1 | (2 << 3) | (2 << 5) | (1 << 9) | (1 << 10),
+    };
+    const color = DkColorState{
+        // logicOp=Copy, alphaCompare=Always, blending disabled.
+        .bits = (3 << 8) | (8 << 16),
+    };
+    const color_write = DkColorWriteState{ .masks = 0xFFFF_FFFF };
+    const depth = DkDepthStencilState{
+        // No depth attachment in this milestone, so keep depth/stencil off.
+        .bits0 = 8 << 4,
+        .bits1 = 0,
+    };
+
+    dkCmdBufBindRasterizerState(command_buffer, &rasterizer);
+    dkCmdBufBindColorState(command_buffer, &color);
+    dkCmdBufBindColorWriteState(command_buffer, &color_write);
+    dkCmdBufBindDepthStencilState(command_buffer, &depth);
+}
+
+fn imageView(image: *const DkImage) DkImageView {
+    return .{
+        .pImage = image,
+        .type = DK_IMAGE_TYPE_NONE,
+        .format = 0,
+        .swizzle = .{ DK_SWIZZLE_RED, DK_SWIZZLE_GREEN, DK_SWIZZLE_BLUE, DK_SWIZZLE_ALPHA },
+        .dsSource = DK_DS_SOURCE_DEPTH,
+        .layerOffset = 0,
+        .layerCount = 0,
+        .mipLevelOffset = 0,
+        .mipLevelCount = 0,
+    };
+}
+
+fn alignForward(value: u32, alignment: u32) u32 {
+    return std.mem.alignForward(u32, value, alignment);
+}
diff --git a/src/platform/switch/switch_thread.zig b/src/platform/switch/switch_thread.zig
new file mode 100644
index 0000000..b133be7
--- /dev/null
+++ b/src/platform/switch/switch_thread.zig
@@ -0,0 +1,25 @@
+//! Switch thread backend stub.
+//!
+//! Real implementation will wrap libnx's `threadCreate`/`threadStart`/
+//! `threadWaitForExit`. Until then `spawn` returns `error.Unsupported`
+//! so callers fail fast instead of silently returning a bogus handle.
+
+const std = @import("std");
+const api = @import("../thread_api.zig");
+
+pub const Handle = u32;
+
+pub fn spawn(cfg: api.Config, comptime func: anytype, args: anytype) !Handle {
+    _ = cfg;
+    _ = func;
+    _ = args;
+    return error.Unsupported;
+}
+
+pub fn join(_: Handle) void {}
+
+pub fn set_priority(_: Handle, _: api.Priority) anyerror!void {}
+
+pub fn current_priority() api.Priority {
+    return .normal;
+}
diff --git a/src/platform/switch/time.zig b/src/platform/switch/time.zig
new file mode 100644
index 0000000..9ab8691
--- /dev/null
+++ b/src/platform/switch/time.zig
@@ -0,0 +1,35 @@
+const std = @import("std");
+const c = @import("../nintendo_c.zig").c;
+
+pub fn now(clock: std.Io.Clock) std.Io.Timestamp {
+    return switch (clock) {
+        .real, .awake, .boot => .fromNanoseconds(@intCast((@as(u128, c.svcGetSystemTick()) * 625) / 12)),
+        else => std.debug.panic("switch std.Io clock {s} is not implemented", .{@tagName(clock)}),
+    };
+}
+
+pub fn clockResolution(clock: std.Io.Clock) std.Io.Clock.ResolutionError!std.Io.Duration {
+    return switch (clock) {
+        .real, .awake, .boot => .fromNanoseconds(53),
+        else => error.ClockUnavailable,
+    };
+}
+
+pub fn sleep(timeout: std.Io.Timeout) std.Io.Cancelable!void {
+    const ns = timeoutNanoseconds(timeout);
+    if (ns <= 0) return;
+    c.svcSleepThread(clampNs(ns));
+}
+
+fn timeoutNanoseconds(timeout: std.Io.Timeout) i96 {
+    return switch (timeout) {
+        .none => 0,
+        .duration => |duration| duration.raw.nanoseconds,
+        .deadline => |deadline| deadline.raw.nanoseconds - now(deadline.clock).nanoseconds,
+    };
+}
+
+fn clampNs(ns: i96) i64 {
+    if (ns > std.math.maxInt(i64)) return std.math.maxInt(i64);
+    return @intCast(ns);
+}
diff --git a/src/platform/thread.zig b/src/platform/thread.zig
index d043677..48f1230 100644
--- a/src/platform/thread.zig
+++ b/src/platform/thread.zig
@@ -1,10 +1,17 @@
 //! Comptime-selected thread backend.
 
 const builtin = @import("builtin");
+const options = @import("options");
 const thread_api = @import("thread_api.zig");
 
 pub const Api = if (builtin.os.tag == .psp)
     @import("psp/psp_thread.zig")
+else if (builtin.os.tag == .@"3ds")
+    @import("3ds/3ds_thread.zig")
+else if (options.config.platform == .nintendo_switch)
+    @import("switch/switch_thread.zig")
+else if (options.config.platform == .wasm)
+    @import("wasm/wasm_thread.zig")
 else
     @import("std_thread.zig");
 
diff --git a/src/platform/thread_api.zig b/src/platform/thread_api.zig
index 586a495..f10a600 100644
--- a/src/platform/thread_api.zig
+++ b/src/platform/thread_api.zig
@@ -28,9 +28,8 @@ pub const Config = struct {
     /// thread-local so `current_priority()` round-trips, but does NOT change
     /// OS-level scheduling.
     priority: Priority = .normal,
-    /// Required on PSP (used to allocate the trampoline closure). Desktop
-    /// forwards it to `std.Thread.spawn`, which only consults it on platforms
-    /// that need to allocate a stack manually (e.g. WASI).
+    /// Required on PSP/3DS (used to allocate the trampoline closure). Desktop
+    /// forwards it to `std.Thread.spawn`.
     allocator: ?std.mem.Allocator = null,
 };
 
diff --git a/src/platform/wasm/browser_audio.zig b/src/platform/wasm/browser_audio.zig
new file mode 100644
index 0000000..f3d1cd1
--- /dev/null
+++ b/src/platform/wasm/browser_audio.zig
@@ -0,0 +1,65 @@
+const std = @import("std");
+const Stream = @import("../../audio/stream.zig").Stream;
+
+const MAX_SLOTS = 32;
+
+extern "aether_host" fn aether_audio_init(sample_rate: u32, max_slots: u32) void;
+extern "aether_host" fn aether_audio_deinit() void;
+extern "aether_host" fn aether_audio_update() void;
+extern "aether_host" fn aether_audio_play_slot(slot: u32, ptr: [*]const u8, len: usize, sample_rate: u32, channels: u32, bit_depth: u32) bool;
+extern "aether_host" fn aether_audio_stop_slot(slot: u32) void;
+extern "aether_host" fn aether_audio_set_slot_gain_pan(slot: u32, gain: f32, pan: f32) void;
+extern "aether_host" fn aether_audio_is_slot_active(slot: u32) bool;
+
+var audio_alloc: std.mem.Allocator = undefined;
+var audio_io: std.Io = undefined;
+
+pub fn setup(alloc: std.mem.Allocator, io: std.Io) void {
+    audio_alloc = alloc;
+    audio_io = io;
+    _ = audio_io;
+}
+
+pub fn init() anyerror!void {
+    aether_audio_init(48_000, MAX_SLOTS);
+}
+
+pub fn deinit() void {
+    aether_audio_deinit();
+}
+
+pub fn update() void {
+    aether_audio_update();
+}
+
+pub fn max_voices() u32 {
+    return MAX_SLOTS;
+}
+
+pub fn play_slot(slot: u8, stream: Stream) anyerror!void {
+    if (slot >= MAX_SLOTS) return;
+
+    const len = stream.byte_length orelse return error.UnknownStreamLength;
+    const data = try std.heap.wasm_allocator.alloc(u8, @intCast(len));
+    defer std.heap.wasm_allocator.free(data);
+    try stream.reader.readSliceAll(data);
+
+    if (!aether_audio_play_slot(slot, data.ptr, data.len, stream.format.sample_rate, stream.format.channels, stream.format.bit_depth)) {
+        return error.AudioHostRejectedStream;
+    }
+}
+
+pub fn stop_slot(slot: u8) void {
+    if (slot >= MAX_SLOTS) return;
+    aether_audio_stop_slot(slot);
+}
+
+pub fn set_slot_gain_pan(slot: u8, gain: f32, pan: f32) void {
+    if (slot >= MAX_SLOTS) return;
+    aether_audio_set_slot_gain_pan(slot, gain, pan);
+}
+
+pub fn is_slot_active(slot: u8) bool {
+    if (slot >= MAX_SLOTS) return false;
+    return aether_audio_is_slot_active(slot);
+}
diff --git a/src/platform/wasm/input.zig b/src/platform/wasm/input.zig
new file mode 100644
index 0000000..e04dcd2
--- /dev/null
+++ b/src/platform/wasm/input.zig
@@ -0,0 +1,76 @@
+//! Browser input backend. JavaScript event listeners translate DOM input into
+//! Aether enum integer values and call the exported delivery functions below.
+
+const std = @import("std");
+const core = @import("../../core/input/input.zig");
+
+extern "aether_host" fn aether_input_apply_cursor_mode(mode: u32) void;
+
+pub fn setup(_: std.mem.Allocator, _: std.Io) void {}
+
+pub fn init() anyerror!void {}
+
+pub fn deinit() void {}
+
+pub fn pump() void {
+    core.signal_frame_boundary();
+}
+
+pub fn apply_cursor_mode(mode: core.CursorMode) void {
+    aether_input_apply_cursor_mode(@intFromEnum(mode));
+}
+
+pub fn begin_text_input_session(_: core.TextInputTarget, _: core.TextInputOptions) anyerror!void {}
+
+pub fn end_text_input_session() void {}
+
+export fn aether_input_key(key_code: u32, pressed: bool, repeat: bool, mods_bits: u32) void {
+    const key: core.Key = std.enums.fromInt(core.Key, key_code) orelse return;
+    const mods = decodeMods(mods_bits);
+    if (pressed) {
+        core.deliver_key_down(key, mods, repeat);
+    } else {
+        core.deliver_key_up(key, mods);
+    }
+}
+
+export fn aether_input_text(ptr: [*]const u8, len: usize) void {
+    core.deliver_text(ptr[0..len]);
+}
+
+export fn aether_input_mouse_button(button_code: u32, pressed: bool, x: f32, y: f32) void {
+    if (button_code > @intFromEnum(core.MouseButton.Middle)) return;
+    const button: core.MouseButton = @enumFromInt(button_code);
+    core.deliver_mouse_button(button, if (pressed) .pressed else .released, .{ .x = x, .y = y });
+}
+
+export fn aether_input_mouse_move(x: f32, y: f32, dx: f32, dy: f32) void {
+    core.deliver_mouse_move(.{ .x = x, .y = y }, .{ .x = dx, .y = dy });
+}
+
+export fn aether_input_mouse_wheel(dx: f32, dy: f32) void {
+    core.deliver_mouse_wheel(.{ .x = dx, .y = dy });
+}
+
+export fn aether_input_focus(gained: bool) void {
+    core.deliver_focus_change(gained);
+}
+
+export fn aether_input_gamepad_button(button_code: u32, pressed: bool) void {
+    const button: core.Button = std.enums.fromInt(core.Button, button_code) orelse return;
+    core.deliver_gamepad_button(button, if (pressed) .pressed else .released);
+}
+
+export fn aether_input_gamepad_axis(axis_code: u32, value: f32) void {
+    const axis: core.Axis = std.enums.fromInt(core.Axis, axis_code) orelse return;
+    core.deliver_gamepad_axis(axis, value);
+}
+
+fn decodeMods(bits: u32) core.ModifierSet {
+    var mods: core.ModifierSet = .{};
+    if (bits & 0x1 != 0) mods.insert(.shift);
+    if (bits & 0x2 != 0) mods.insert(.ctrl);
+    if (bits & 0x4 != 0) mods.insert(.alt);
+    if (bits & 0x8 != 0) mods.insert(.super);
+    return mods;
+}
diff --git a/src/platform/wasm/surface.zig b/src/platform/wasm/surface.zig
new file mode 100644
index 0000000..9c1face
--- /dev/null
+++ b/src/platform/wasm/surface.zig
@@ -0,0 +1,31 @@
+const std = @import("std");
+const Self = @This();
+
+extern "aether_host" fn aether_canvas_width() u32;
+extern "aether_host" fn aether_canvas_height() u32;
+extern "aether_host" fn aether_surface_init(width: u32, height: u32, title_ptr: [*]const u8, title_len: usize, resizable: bool) void;
+extern "aether_host" fn aether_surface_present() void;
+
+alloc: std.mem.Allocator,
+
+pub fn init(_: *Self, width: u32, height: u32, title: [:0]const u8, _: bool, _: bool, resizable: bool) anyerror!void {
+    aether_surface_init(width, height, title.ptr, title.len, resizable);
+}
+
+pub fn deinit(_: *Self) void {}
+
+pub fn update(_: *Self) bool {
+    return true;
+}
+
+pub fn draw(_: *Self) void {
+    aether_surface_present();
+}
+
+pub fn get_width(_: *Self) u32 {
+    return aether_canvas_width();
+}
+
+pub fn get_height(_: *Self) u32 {
+    return aether_canvas_height();
+}
diff --git a/src/platform/wasm/wasm_thread.zig b/src/platform/wasm/wasm_thread.zig
new file mode 100644
index 0000000..148cb4d
--- /dev/null
+++ b/src/platform/wasm/wasm_thread.zig
@@ -0,0 +1,24 @@
+//! WASM/browser thread backend.
+//!
+//! Aether's current browser runtime runs on one JS event-loop thread. Expose a
+//! real backend type so generic code can name `Util.Thread`, but fail thread
+//! creation explicitly.
+
+const api = @import("../thread_api.zig");
+
+pub const Handle = void;
+
+pub fn spawn(cfg: api.Config, comptime func: anytype, args: anytype) !Handle {
+    _ = cfg;
+    _ = func;
+    _ = args;
+    return error.UnsupportedPlatform;
+}
+
+pub fn join(_: Handle) void {}
+
+pub fn set_priority(_: Handle, _: api.Priority) anyerror!void {}
+
+pub fn current_priority() api.Priority {
+    return .normal;
+}
diff --git a/src/platform/wasm/webgl_gfx.zig b/src/platform/wasm/webgl_gfx.zig
new file mode 100644
index 0000000..2228b34
--- /dev/null
+++ b/src/platform/wasm/webgl_gfx.zig
@@ -0,0 +1,149 @@
+const std = @import("std");
+const Mat4 = @import("../../math/math.zig").Mat4;
+const Util = @import("../../util/util.zig");
+
+const Rendering = @import("../../rendering/rendering.zig");
+const Mesh = Rendering.mesh;
+const Texture = Rendering.Texture;
+const shaders = @import("aether_shaders");
+
+const MAX_MESHES = 8192;
+
+extern "aether_host" fn aether_webgl_init(vert_ptr: [*]const u8, vert_len: usize, frag_ptr: [*]const u8, frag_len: usize) bool;
+extern "aether_host" fn aether_webgl_deinit() void;
+extern "aether_host" fn aether_webgl_set_clear_color(r: f32, g: f32, b: f32, a: f32) void;
+extern "aether_host" fn aether_webgl_set_alpha_blend(enabled: bool) void;
+extern "aether_host" fn aether_webgl_set_depth_write(enabled: bool) void;
+extern "aether_host" fn aether_webgl_set_culling(enabled: bool) void;
+extern "aether_host" fn aether_webgl_set_uv_offset(u: f32, v: f32) void;
+extern "aether_host" fn aether_webgl_set_fog(enabled: bool, start: f32, end: f32, r: f32, g: f32, b: f32) void;
+extern "aether_host" fn aether_webgl_set_proj_matrix(ptr: *const f32) void;
+extern "aether_host" fn aether_webgl_set_view_matrix(ptr: *const f32) void;
+extern "aether_host" fn aether_webgl_start_frame(width: u32, height: u32) bool;
+extern "aether_host" fn aether_webgl_end_frame() void;
+extern "aether_host" fn aether_webgl_clear_depth() void;
+extern "aether_host" fn aether_webgl_create_mesh() u32;
+extern "aether_host" fn aether_webgl_destroy_mesh(handle: u32) void;
+extern "aether_host" fn aether_webgl_update_mesh(handle: u32, ptr: [*]const u8, len: usize) void;
+extern "aether_host" fn aether_webgl_draw_mesh(handle: u32, model_ptr: *const f32, count: usize) void;
+extern "aether_host" fn aether_webgl_create_texture(width: u32, height: u32, ptr: [*]const u8, len: usize) u32;
+extern "aether_host" fn aether_webgl_update_texture(handle: u32, ptr: [*]const u8, len: usize) void;
+extern "aether_host" fn aether_webgl_bind_texture(handle: u32) void;
+extern "aether_host" fn aether_webgl_destroy_texture(handle: u32) void;
+extern "aether_host" fn aether_canvas_width() u32;
+extern "aether_host" fn aether_canvas_height() u32;
+
+var render_alloc: std.mem.Allocator = undefined;
+var render_io: std.Io = undefined;
+var meshes = Util.CircularBuffer(u32, MAX_MESHES).init();
+
+pub fn setup(alloc: std.mem.Allocator, io: std.Io) void {
+    render_alloc = alloc;
+    render_io = io;
+    _ = render_alloc;
+    _ = render_io;
+}
+
+pub fn init() anyerror!void {
+    if (!aether_webgl_init(&shaders.basic_vert, shaders.basic_vert.len, &shaders.basic_frag, shaders.basic_frag.len)) {
+        return error.WebGlInitFailed;
+    }
+}
+
+pub fn deinit() void {
+    aether_webgl_deinit();
+}
+
+pub fn set_clear_color(r: f32, g: f32, b: f32, a: f32) void {
+    aether_webgl_set_clear_color(r, g, b, a);
+}
+
+pub fn set_alpha_blend(enabled: bool) void {
+    aether_webgl_set_alpha_blend(enabled);
+}
+
+pub fn set_depth_write(enabled: bool) void {
+    aether_webgl_set_depth_write(enabled);
+}
+
+pub fn set_fog(enabled: bool, start: f32, end: f32, r: f32, g: f32, b: f32) void {
+    aether_webgl_set_fog(enabled, start, end, r, g, b);
+}
+
+pub fn set_clip_planes(_: bool) void {}
+
+pub fn set_culling(enabled: bool) void {
+    aether_webgl_set_culling(enabled);
+}
+
+pub fn set_uv_offset(u: f32, v: f32) void {
+    aether_webgl_set_uv_offset(u, v);
+}
+
+pub fn set_proj_matrix(mat: *const Mat4) void {
+    aether_webgl_set_proj_matrix(mat.ptr());
+}
+
+pub fn set_view_matrix(mat: *const Mat4) void {
+    aether_webgl_set_view_matrix(mat.ptr());
+}
+
+pub fn start_frame() bool {
+    const width = aether_canvas_width();
+    const height = aether_canvas_height();
+    if (width == 0 or height == 0) return false;
+    return aether_webgl_start_frame(width, height);
+}
+
+pub fn end_frame() void {
+    aether_webgl_end_frame();
+}
+
+pub fn clear_depth() void {
+    aether_webgl_clear_depth();
+}
+
+pub fn set_vsync(_: bool) void {}
+
+pub fn create_mesh() anyerror!Mesh.Handle {
+    const host_handle = aether_webgl_create_mesh();
+    if (host_handle == 0) return error.OutOfMeshes;
+    const idx = meshes.add_element(host_handle) orelse return error.OutOfMeshes;
+    return @intCast(idx);
+}
+
+pub fn destroy_mesh(handle: Mesh.Handle) void {
+    const host_handle = meshes.get_element(handle) orelse return;
+    aether_webgl_destroy_mesh(host_handle);
+    _ = meshes.remove_element(handle);
+}
+
+pub fn update_mesh(handle: Mesh.Handle, data: []const u8) void {
+    const host_handle = meshes.get_element(handle) orelse return;
+    aether_webgl_update_mesh(host_handle, data.ptr, data.len);
+}
+
+pub fn draw_mesh(handle: Mesh.Handle, model: *const Mat4, count: usize) void {
+    const host_handle = meshes.get_element(handle) orelse return;
+    aether_webgl_draw_mesh(host_handle, model.ptr(), count);
+}
+
+pub fn create_texture(width: u32, height: u32, data: []align(16) u8) anyerror!Texture.Handle {
+    const handle = aether_webgl_create_texture(width, height, data.ptr, data.len);
+    if (handle == 0) return error.TextureCreateFailed;
+    return handle;
+}
+
+pub fn update_texture(handle: Texture.Handle, data: []align(16) u8) void {
+    aether_webgl_update_texture(handle, data.ptr, data.len);
+}
+
+pub fn bind_texture(handle: Texture.Handle) void {
+    aether_webgl_bind_texture(handle);
+}
+
+pub fn destroy_texture(handle: Texture.Handle) void {
+    aether_webgl_destroy_texture(handle);
+}
+
+pub fn force_texture_resident(_: Texture.Handle) void {}
diff --git a/src/rendering/Vertex.zig b/src/rendering/Vertex.zig
new file mode 100644
index 0000000..f4adc5d
--- /dev/null
+++ b/src/rendering/Vertex.zig
@@ -0,0 +1,124 @@
+pub const Vertex = extern struct {
+    pos: [3]i16,
+    _pad: i16 = 0,
+    color: u32,
+    uv: [2]i16,
+};
+
+comptime {
+    if (@sizeOf(Vertex) != 16) @compileError("Rendering.Vertex must stay 16 bytes");
+    if (@offsetOf(Vertex, "pos") != 0) @compileError("Rendering.Vertex.pos must stay at byte offset 0");
+    if (@offsetOf(Vertex, "color") != 8) @compileError("Rendering.Vertex.color must stay at byte offset 8");
+    if (@offsetOf(Vertex, "uv") != 12) @compileError("Rendering.Vertex.uv must stay at byte offset 12");
+}
+
+pub const AttributeUsage = enum {
+    position,
+    uv,
+    color,
+    normal,
+};
+
+pub const AttributeFormat = enum(u8) {
+    f32x2,
+    f32x3,
+    unorm8x2,
+    unorm8x4,
+    unorm16x2,
+    unorm16x3,
+    snorm16x2,
+    snorm16x3,
+
+    fn infer(comptime T: type) AttributeFormat {
+        return switch (T) {
+            [2]f32 => .f32x2,
+            [3]f32 => .f32x3,
+            [2]u8 => .unorm8x2,
+            [4]u8, u32 => .unorm8x4,
+            [2]u16 => .unorm16x2,
+            [3]u16 => .unorm16x3,
+            [2]i16 => .snorm16x2,
+            [3]i16 => .snorm16x3,
+            else => @compileError("Unsupported vertex attribute field type: " ++ @typeName(T)),
+        };
+    }
+
+    pub fn count(self: AttributeFormat) usize {
+        return switch (self) {
+            .f32x2, .unorm8x2, .unorm16x2, .snorm16x2 => 2,
+            .f32x3, .unorm16x3, .snorm16x3 => 3,
+            .unorm8x4 => 4,
+        };
+    }
+};
+
+pub const Attribute = struct {
+    location: u8,
+    binding: u8 = 0,
+    offset: usize,
+    size: usize,
+    format: AttributeFormat,
+    usage: AttributeUsage,
+};
+
+pub const VertexLayout = struct {
+    stride: usize,
+    attributes: []const Attribute,
+};
+
+pub const Attributes = attributesFromVertex(Vertex);
+pub const Layout = VertexLayout{
+    .stride = @sizeOf(Vertex),
+    .attributes = &Attributes,
+};
+
+fn attributesFromVertex(comptime V: type) [3]Attribute {
+    return .{
+        makeAttribute(V, "pos", 0, .position, 3),
+        makeAttribute(V, "color", 1, .color, 4),
+        makeAttribute(V, "uv", 2, .uv, 2),
+    };
+}
+
+fn makeAttribute(
+    comptime V: type,
+    comptime field_name: []const u8,
+    comptime location: u8,
+    comptime usage: AttributeUsage,
+    comptime expected_count: usize,
+) Attribute {
+    if (!hasField(V, field_name)) {
+        @compileError("Rendering.Vertex is missing required field '" ++ field_name ++ "'");
+    }
+
+    const format = AttributeFormat.infer(@FieldType(V, field_name));
+    if (format.count() != expected_count) {
+        @compileError("Rendering.Vertex field '" ++ field_name ++ "' has the wrong component count");
+    }
+
+    return .{
+        .location = location,
+        .offset = @offsetOf(V, field_name),
+        .size = format.count(),
+        .format = format,
+        .usage = usage,
+    };
+}
+
+fn hasField(comptime T: type, comptime field_name: []const u8) bool {
+    const info = @typeInfo(T);
+    if (info != .@"struct") return false;
+
+    inline for (info.@"struct".fields) |field| {
+        if (comptime eql(field.name, field_name)) return true;
+    }
+    return false;
+}
+
+fn eql(comptime a: []const u8, comptime b: []const u8) bool {
+    if (a.len != b.len) return false;
+    inline for (a, 0..) |ch, i| {
+        if (ch != b[i]) return false;
+    }
+    return true;
+}
diff --git a/src/rendering/mesh.zig b/src/rendering/mesh.zig
index 1a2a10a..d8b60cf 100644
--- a/src/rendering/mesh.zig
+++ b/src/rendering/mesh.zig
@@ -1,17 +1,11 @@
 const std = @import("std");
 const Mat4 = @import("../math/math.zig").Mat4;
-const Pipeline = @import("pipeline.zig");
 const Util = @import("../util/util.zig");
 const Platform = @import("../platform/platform.zig");
 const gfx = Platform.gfx;
 
 pub const Handle = u32;
 
-pub const Primitive = enum {
-    triangles,
-    lines,
-};
-
 /// A generic mesh parameterised by vertex type `V`.
 ///
 /// Vertex data is stored in `vertices` (an unmanaged ArrayList backed by the
@@ -24,13 +18,12 @@ pub fn Mesh(comptime V: type) type {
 
         pub const Vertex = V;
 
-        handle:    Handle,
-        vertices:  std.ArrayList(Vertex),
-        primitive: Primitive = .triangles,
+        handle: Handle,
+        vertices: std.ArrayList(Vertex),
 
-        pub fn new(alloc: std.mem.Allocator, pipeline: Pipeline.Handle) !Self {
+        pub fn new(alloc: std.mem.Allocator) !Self {
             return .{
-                .handle   = try gfx.api.create_mesh(pipeline),
+                .handle = try gfx.api.create_mesh(),
                 .vertices = try std.ArrayList(V).initCapacity(alloc, 32),
             };
         }
@@ -57,7 +50,9 @@ pub fn Mesh(comptime V: type) type {
 
         pub fn draw(self: *Self, mat: *const Mat4) void {
             gfx.api.draw_mesh(
-                self.handle, mat, self.vertices.items.len, self.primitive,
+                self.handle,
+                mat,
+                self.vertices.items.len,
             );
         }
     };
diff --git a/src/rendering/pipeline.zig b/src/rendering/pipeline.zig
deleted file mode 100644
index f700e16..0000000
--- a/src/rendering/pipeline.zig
+++ /dev/null
@@ -1,101 +0,0 @@
-const Platform = @import("../platform/platform.zig");
-const gfx = Platform.gfx;
-
-pub const Handle = u32;
-
-pub const AttributeUsage = enum {
-    position,
-    uv,
-    color,
-    normal,
-};
-
-pub const AttributeFormat = enum(u8) {
-    f32x2,
-    f32x3,
-    unorm8x2,
-    unorm8x4,
-    unorm16x2,
-    unorm16x3,
-    snorm16x2,
-    snorm16x3,
-
-    fn infer(comptime T: type) AttributeFormat {
-        return switch (T) {
-            [2]f32 => .f32x2,
-            [3]f32 => .f32x3,
-            [2]u8 => .unorm8x2,
-            [4]u8, u32 => .unorm8x4,
-            [2]u16 => .unorm16x2,
-            [3]u16 => .unorm16x3,
-            [2]i16 => .snorm16x2,
-            [3]i16 => .snorm16x3,
-            else => @compileError("Unsupported attribute field type"),
-        };
-    }
-
-    pub fn count(self: AttributeFormat) usize {
-        return switch (self) {
-            .f32x2, .unorm8x2, .unorm16x2, .snorm16x2 => 2,
-            .f32x3, .unorm16x3, .snorm16x3 => 3,
-            .unorm8x4 => 4,
-        };
-    }
-};
-
-pub const Attribute = struct {
-    location: u8,
-    binding: u8 = 0,
-    offset: usize,
-    size: usize,
-    format: AttributeFormat,
-    usage: AttributeUsage,
-};
-
-pub const VertexLayout = struct {
-    stride: usize,
-    attributes: []const Attribute,
-};
-
-pub const AttributeSpec = struct {
-    field: []const u8,
-    location: u8,
-    binding: u8 = 0,
-    usage: AttributeUsage,
-};
-
-pub fn attributes_from_struct(comptime V: type, comptime specs: []const AttributeSpec) [specs.len]Attribute {
-    comptime var attrs: [specs.len]Attribute = undefined;
-
-    inline for (specs, 0..) |s, i| {
-        const format = AttributeFormat.infer(@FieldType(V, s.field));
-        attrs[i] = .{
-            .location = s.location,
-            .binding = s.binding,
-            .size = format.count(),
-            .offset = @offsetOf(V, s.field),
-            .format = format,
-            .usage = s.usage,
-        };
-    }
-
-    return attrs;
-}
-
-pub fn layout_from_struct(comptime V: type, comptime attrs: []const Attribute) VertexLayout {
-    return .{ .stride = @sizeOf(V), .attributes = attrs };
-}
-
-handle: Handle,
-
-pub fn new(layout: VertexLayout, vs: ?[:0]align(4) const u8, fs: ?[:0]align(4) const u8) !Handle {
-    return gfx.api.create_pipeline(layout, vs, fs);
-}
-
-pub fn deinit(handle: Handle) void {
-    gfx.api.destroy_pipeline(handle);
-}
-
-pub fn bind(handle: Handle) void {
-    gfx.api.bind_pipeline(handle);
-}
diff --git a/src/rendering/rendering.zig b/src/rendering/rendering.zig
index e173d0e..319f58e 100644
--- a/src/rendering/rendering.zig
+++ b/src/rendering/rendering.zig
@@ -1,8 +1,9 @@
 pub const mesh = @import("mesh.zig");
 pub const Mesh = mesh.Mesh;
+pub const vertex = @import("Vertex.zig");
+pub const Vertex = vertex.Vertex;
 pub const Transform = @import("transform.zig");
 pub const Camera = @import("camera.zig");
 pub const Texture = @import("texture.zig");
-pub const Pipeline = @import("pipeline.zig");
 
 pub const gfx = @import("../platform/platform.zig").gfx;
diff --git a/test/shaders/basic.slang b/src/rendering/shaders/basic.slang
similarity index 90%
rename from test/shaders/basic.slang
rename to src/rendering/shaders/basic.slang
index 71538cc..ef62bf8 100644
--- a/test/shaders/basic.slang
+++ b/src/rendering/shaders/basic.slang
@@ -51,6 +51,7 @@ SamplerState g_sampler;
 Texture2D g_textures[];
 
 float4x4 getModel() { return pc.model; }
+float2 getUvOffset() { return pc.uvOffset; }
 
 #else
 
@@ -68,6 +69,7 @@ ConstantBuffer<PerObject> perObject;
 Sampler2D u_combinedTexture;
 
 float4x4 getModel() { return perObject.model; }
+float2 getUvOffset() { return camera.uvOffset; }
 
 #endif
 
@@ -77,11 +79,7 @@ VertexOutput vertexMain(VertexInput input) {
     float4 viewPos = mul(camera.view, mul(getModel(), float4(input.position, 1.0)));
     output.position = mul(camera.proj, viewPos);
     output.viewDepth = -viewPos.z;
-#ifdef VULKAN
-    output.uv = input.uv + pc.uvOffset;
-#else
-    output.uv = input.uv + camera.uvOffset;
-#endif
+    output.uv = input.uv + getUvOffset();
     output.color = input.color;
     return output;
 }
@@ -106,6 +104,9 @@ float4 fragmentMain(VertexOutput input) : SV_Target {
     }
     if (pc.alphaBlendEnabled == 0) {
         color.a = 1.0;
+    } else {
+        if (color.a <= 0.1)
+            discard;
     }
 #else
     if (camera.fogEnabled != 0) {
@@ -114,6 +115,9 @@ float4 fragmentMain(VertexOutput input) : SV_Target {
     }
     if (camera.alphaBlendEnabled == 0) {
         color.a = 1.0;
+    } else {
+        if (color.a <= 0.1)
+            discard;
     }
 #endif
     return color;
diff --git a/src/rendering/texture.zig b/src/rendering/texture.zig
index d237d8c..e31a4e7 100644
--- a/src/rendering/texture.zig
+++ b/src/rendering/texture.zig
@@ -6,6 +6,7 @@ const Platform = @import("../platform/platform.zig");
 const gfx = Platform.gfx;
 const options = @import("options");
 const psp_gfx = if (builtin.os.tag == .psp) @import("../platform/psp/psp_gfx_ge.zig") else struct {};
+const use_streaming_file_reader = options.config.platform == .nintendo_3ds or options.config.platform == .nintendo_switch;
 
 pub const Handle = u32;
 
@@ -49,16 +50,16 @@ pub fn load_from_data(alloc: std.mem.Allocator, width: u32, height: u32, pixels:
     };
 }
 
-/// 4x4 solid white default texture, initialized by `init_defaults`.
+/// 8x8 solid white default texture, initialized by `init_defaults`.
 pub var Default: Texture = undefined;
 
 pub fn init_defaults(alloc: std.mem.Allocator) !void {
     const pixels = comptime blk: {
-        var data: [4 * 4 * 4]u8 = undefined;
+        var data: [8 * 8 * 4]u8 = undefined;
         @memset(&data, 0xFF);
         break :blk data;
     };
-    Default = try load_from_data(alloc, 4, 4, &pixels);
+    Default = try load_from_data(alloc, 8, 8, &pixels);
 }
 
 /// Loads a PNG from `path` (resolved against `dir`) into GPU memory.
@@ -68,12 +69,15 @@ pub fn init_defaults(alloc: std.mem.Allocator) !void {
 /// `engine.dirs.data` for user-provided ones. Do not use
 /// `std.Io.Dir.cwd()` -- CWD is not guaranteed to be the app root
 /// (Finder-launched `.app` bundles give CWD = `/`).
-pub fn load(io: std.Io, dir: std.Io.Dir, alloc: std.mem.Allocator, path: []const u8) !Texture {
+pub fn load(io: std.Io, dir: anytype, alloc: std.mem.Allocator, path: []const u8) !Texture {
     var file = try dir.openFile(io, path, .{});
     defer file.close(io);
 
     var temp: [4096]u8 = undefined;
-    var reader = file.reader(io, &temp);
+    var reader = if (use_streaming_file_reader)
+        file.readerStreaming(io, &temp)
+    else
+        file.reader(io, &temp);
 
     return load_from_reader(alloc, &reader.interface);
 }
diff --git a/src/root.zig b/src/root.zig
index 4b07796..1c6489c 100644
--- a/src/root.zig
+++ b/src/root.zig
@@ -12,6 +12,11 @@ pub const ctx_to_self = Util.ctx_to_self;
 /// PSP-exclusive system utility dialogs (OSK, network configuration).
 /// Only available when `platform == .psp`; evaluates to `void` otherwise.
 pub const Psp = if (platform == .psp) @import("platform/psp/psp_dialogs.zig") else void;
+pub const Cio = if (platform == .nintendo_3ds or platform == .nintendo_switch) @import("platform/c_io.zig") else void;
+pub const CProcessInit = if (platform == .nintendo_3ds or platform == .nintendo_switch) @import("platform/c_process_init.zig") else void;
+pub const ThreeDS = if (platform == .nintendo_3ds) struct {
+    pub const panic = @import("root").panic;
+} else void;
 
 /// Comptime-known platform and graphics backend, resolved from build options.
 /// User code can switch on these for per-platform configuration without
@@ -20,7 +25,9 @@ pub const Platform = options.@"build.Platform";
 pub const Gfx = options.@"build.Gfx";
 pub const platform: Platform = options.config.platform;
 pub const gfx: Gfx = options.config.gfx;
+pub const nintendo_3ds_heap_size: u32 = options.config.nintendo_3ds_heap_size;
+pub const nintendo_3ds_linear_heap_size: u32 = options.config.nintendo_3ds_linear_heap_size;
 
 comptime {
-    std.testing.refAllDecls(@This());
+    if (platform != .wasm) std.testing.refAllDecls(@This());
 }
diff --git a/src/util/estimator.zig b/src/util/estimator.zig
index f13d32b..fb382b1 100644
--- a/src/util/estimator.zig
+++ b/src/util/estimator.zig
@@ -10,7 +10,7 @@ pub const Estimator = struct {
     sorted: [CAPACITY]i64,
     head: usize,
     count: usize,
-    start_ns: i64,
+    start_ns: i96,
 
     cached_avg: i64,
     cached_min: i64,
@@ -30,14 +30,14 @@ pub const Estimator = struct {
     }
 
     pub fn begin(self: *Estimator, io: std.Io) void {
-        var clock = std.Io.Clock.real;
-        self.start_ns = @truncate(clock.now(io).toNanoseconds());
+        var clock = std.Io.Clock.boot;
+        self.start_ns = clock.now(io).toNanoseconds();
     }
 
     pub fn end(self: *Estimator, io: std.Io) void {
-        var clock = std.Io.Clock.real;
-        const now_ns: i64 = @truncate(clock.now(io).toNanoseconds());
-        const elapsed = now_ns - self.start_ns;
+        var clock = std.Io.Clock.boot;
+        const now_ns = clock.now(io).toNanoseconds();
+        const elapsed = clamp_i128_to_i64(@as(i128, now_ns) - @as(i128, self.start_ns));
         self.start_ns = 0;
         self.record(elapsed);
     }
@@ -53,9 +53,9 @@ pub const Estimator = struct {
         std.sort.insertion(i64, self.sorted[0..n], {}, std.sort.asc(i64));
 
         // Recompute cached stats
-        var sum: i64 = 0;
+        var sum: i128 = 0;
         for (self.sorted[0..n]) |s| sum += s;
-        self.cached_avg = @divTrunc(sum, @as(i64, @intCast(n)));
+        self.cached_avg = clamp_i128_to_i64(@divTrunc(sum, @as(i128, @intCast(n))));
         self.cached_min = self.sorted[0];
         self.cached_max = self.sorted[n - 1];
     }
@@ -128,3 +128,11 @@ pub const Estimator = struct {
         logger.info("----------------------------", .{});
     }
 };
+
+fn clamp_i128_to_i64(value: i128) i64 {
+    const max: i128 = std.math.maxInt(i64);
+    const min: i128 = std.math.minInt(i64);
+    if (value > max) return std.math.maxInt(i64);
+    if (value < min) return std.math.minInt(i64);
+    return @intCast(value);
+}
diff --git a/src/util/logger.zig b/src/util/logger.zig
index 5fd6357..a93f7b1 100644
--- a/src/util/logger.zig
+++ b/src/util/logger.zig
@@ -1,17 +1,19 @@
 const std = @import("std");
 const builtin = @import("builtin");
+const options = @import("options");
 
 var log_buffer: [4096]u8 = @splat(0);
 var file_log: std.Io.File = undefined;
 var file_writer: std.Io.File.Writer = undefined;
 var writer: *std.Io.Writer = undefined;
+var file_logging = false;
 
 /// PSP has no per-user data dir concept; the log sits at CWD (which is
 /// where the EBOOT lives) regardless of what `data_dir` points at. Every
 /// other platform routes through the engine-resolved data dir so
 /// Finder-launched `.app` bundles don't try to write into read-only
 /// bundle internals.
-pub fn init(io: std.Io, data_dir: std.Io.Dir) !void {
+pub fn init(io: std.Io, data_dir: anytype) !void {
     if (builtin.os.tag == .psp) {
         file_log = try std.Io.Dir.cwd().createFile(io, "ms0:/aether.log", .{ .truncate = true });
     } else {
@@ -19,11 +21,14 @@ pub fn init(io: std.Io, data_dir: std.Io.Dir) !void {
     }
     file_writer = file_log.writer(io, &log_buffer);
     writer = &file_writer.interface;
+    file_logging = true;
 }
 
 pub fn deinit(io: std.Io) void {
+    if (!file_logging) return;
     writer.flush() catch {};
     file_log.close(io);
+    file_logging = false;
 }
 
 pub fn aether_log_fn(
@@ -36,6 +41,10 @@ pub fn aether_log_fn(
 
     const prefix = scope_prefix ++ "[" ++ comptime level.asText() ++ "]: ";
 
-    writer.print(prefix ++ format ++ "\n", args) catch {};
-    std.debug.print(prefix ++ format ++ "\n", args);
+    if (file_logging) {
+        writer.print(prefix ++ format ++ "\n", args) catch {};
+        if (options.config.flush_logs) writer.flush() catch {};
+    }
+    const echo_stderr = !(options.config.platform == .nintendo_3ds and options.config.flush_logs);
+    if (echo_stderr) std.debug.print(prefix ++ format ++ "\n", args);
 }
diff --git a/src/util/pool_alloc.zig b/src/util/pool_alloc.zig
index 614b77f..69f261e 100644
--- a/src/util/pool_alloc.zig
+++ b/src/util/pool_alloc.zig
@@ -7,8 +7,9 @@
 //! L0 has one bit per block (1 = free, 0 = allocated).
 //! L1 has one bit per L0 word (1 = at least one free block in that group).
 //!
-//! Over-aligned requests (alignment > BLOCK_SIZE) are handled by constraining
-//! the starting block index to a multiple of (alignment / BLOCK_SIZE).
+//! Over-aligned requests (alignment > BLOCK_SIZE) are handled by aligning the
+//! actual data pointer for each candidate run, since the pool's data base is
+//! only guaranteed to be BLOCK_SIZE-aligned.
 //!
 //! alloc -- O(1) single-block via L1->L0 descent; O(n/32) multi-block scan
 //! free  -- O(1): set bits + update summary
@@ -42,6 +43,14 @@ inline fn roundup(n: usize, a: usize) usize {
     return (n + a - 1) & ~(a - 1);
 }
 
+inline fn block_index_for_aligned_address(data: [*]u8, block_idx: u32, alignment: usize) u32 {
+    if (alignment <= BLOCK_SIZE) return block_idx;
+
+    const candidate_addr = @intFromPtr(data + @as(usize, block_idx) * BLOCK_SIZE);
+    const aligned_addr = std.mem.alignForward(usize, candidate_addr, alignment);
+    return block_idx + @as(u32, @intCast((aligned_addr - candidate_addr) / BLOCK_SIZE));
+}
+
 // -- public allocator ---------------------------------------------------------
 
 pub const PoolAlloc = struct {
@@ -301,14 +310,12 @@ pub const PoolAlloc = struct {
     }
 
     /// Find `blocks_needed` contiguous free blocks with alignment constraint.
-    /// `align_blocks` must be a power of 2 (1 for no constraint).
-    fn find_run(self: *PoolAlloc, blocks_needed: u32, align_blocks: u32) ?u32 {
-        if (blocks_needed == 1 and align_blocks <= 1) {
+    /// `alignment` must be a power of 2.
+    fn find_run(self: *PoolAlloc, blocks_needed: u32, alignment: usize) ?u32 {
+        if (blocks_needed == 1 and alignment <= BLOCK_SIZE) {
             return self.find_single();
         }
 
-        const align_mask = align_blocks - 1;
-
         // Scan L0 from hint, then wrap around if needed.
         var start_wi = self.hint;
         var pass: u32 = 0;
@@ -331,7 +338,7 @@ pub const PoolAlloc = struct {
                     const word_base = wi * WORD_BITS;
                     if (run_len == 0) {
                         // Start a new run, aligned.
-                        run_start = (word_base + align_mask) & ~align_mask;
+                        run_start = block_index_for_aligned_address(self.data, word_base, alignment);
                         if (run_start >= word_base + WORD_BITS) {
                             // Alignment pushed past this word.
                             continue;
@@ -387,7 +394,7 @@ pub const PoolAlloc = struct {
                     // Count ones (free blocks).
                     const ones: u32 = @ctz(~remaining);
                     const candidate = word_base + bit_off;
-                    const aligned_start = (candidate + align_mask) & ~align_mask;
+                    const aligned_start = block_index_for_aligned_address(self.data, candidate, alignment);
 
                     if (aligned_start < candidate + ones) {
                         const effective = candidate + ones - aligned_start;
@@ -431,9 +438,8 @@ pub const PoolAlloc = struct {
 
         const blocks_needed: u32 = @intCast(div_ceil(n, BLOCK_SIZE));
         const align_bytes = alignment.toByteUnits();
-        const align_blocks: u32 = @intCast(@max(1, align_bytes / BLOCK_SIZE));
 
-        const block_idx = self.find_run(blocks_needed, align_blocks) orelse return null;
+        const block_idx = self.find_run(blocks_needed, align_bytes) orelse return null;
 
         self.clear_range(block_idx, blocks_needed);
         self.used += @as(usize, blocks_needed) * BLOCK_SIZE;
@@ -609,11 +615,12 @@ test "pool_alloc: resize shrink and grow" {
     var pa = PoolAlloc.init(buf[0..], "test");
     const ally = pa.allocator();
 
-    const a = try ally.alloc(u8, 64);
+    var a = try ally.alloc(u8, 64);
     const b = try ally.alloc(u8, 64);
 
     // Shrink: always succeeds (wastes the tail within the block)
     try testing.expect(ally.resize(a, 32));
+    a = a[0..32];
 
     // Grow with occupied next block: must fail
     try testing.expect(!ally.resize(a, 256));
@@ -621,6 +628,7 @@ test "pool_alloc: resize shrink and grow" {
     // Free the next block, now growth can absorb it
     ally.free(b);
     try testing.expect(ally.resize(a, 100));
+    a = a.ptr[0..100];
 
     ally.free(a);
     try testing.expectEqual(@as(usize, 0), pa.used);
@@ -676,6 +684,32 @@ test "pool_alloc: over-alignment" {
     try testing.expectEqual(@as(usize, 0), pa.used);
 }
 
+test "pool_alloc: over-alignment respects misaligned data base" {
+    const page_size = 4096;
+    var backing: [page_size * 4]u8 align(BLOCK_SIZE) = undefined;
+
+    var pa = PoolAlloc.init(backing[0..], "test");
+    var found_misaligned_data = false;
+    var offset: usize = 0;
+    while (offset < page_size) : (offset += BLOCK_SIZE) {
+        pa = PoolAlloc.init(backing[offset..], "test");
+        if (@intFromPtr(pa.data) % page_size != 0) {
+            found_misaligned_data = true;
+            break;
+        }
+    }
+    try testing.expect(found_misaligned_data);
+
+    const ally = pa.allocator();
+    const page_align = comptime std.mem.Alignment.fromByteUnits(page_size);
+    const raw = ally.vtable.alloc(ally.ptr, 64, page_align, 0) orelse
+        return error.TestUnexpectedResult;
+
+    try testing.expectEqual(@as(usize, 0), @intFromPtr(raw) % page_size);
+    ally.vtable.free(ally.ptr, raw[0..64], page_align, 0);
+    try testing.expectEqual(@as(usize, 0), pa.used);
+}
+
 test "pool_alloc: OOM returns error" {
     var buf: [512]u8 align(BLOCK_SIZE) = undefined;
     var pa = PoolAlloc.init(buf[0..], "test");
diff --git a/src/util/thread.zig b/src/util/thread.zig
index be1ef3c..820ca05 100644
--- a/src/util/thread.zig
+++ b/src/util/thread.zig
@@ -4,10 +4,9 @@
 //! struct extends `std.Thread.SpawnConfig` with `name` and `priority` -- the
 //! two PSP-only knobs that motivated this layer.
 //!
-//! On PSP, `Config.allocator` is **required**: it owns the trampoline
+//! On PSP/3DS, `Config.allocator` is **required**: it owns the trampoline
 //! closure that lives until the thread function returns. On desktop the
-//! allocator is forwarded to `std.Thread.spawn` and only consulted on
-//! platforms that need to allocate a stack manually (e.g. WASI).
+//! allocator is forwarded to `std.Thread.spawn`.
 
 const std = @import("std");
 const builtin = @import("builtin");
@@ -75,4 +74,3 @@ test "spawned thread sees its requested priority" {
     t.join();
     try std.testing.expectEqual(@as(i8, @intFromEnum(Priority.high)), seen.load(.seq_cst));
 }
-
diff --git a/src/util/util.zig b/src/util/util.zig
index 700c857..183e934 100644
--- a/src/util/util.zig
+++ b/src/util/util.zig
@@ -21,6 +21,8 @@ comptime {
 pub const std_options: std.Options = .{
     .log_level = if (builtin.mode == .Debug) .debug else .info,
     .logFn = logger.aether_log_fn,
+    .page_size_min = if (builtin.os.tag == .@"3ds" or builtin.os.tag == .freestanding) 4096 else null,
+    .page_size_max = if (builtin.os.tag == .@"3ds" or builtin.os.tag == .freestanding) 4096 else null,
 };
 
 pub const engine_logger = std.log.scoped(.engine);
diff --git a/test/main.zig b/test/main.zig
index faf8d18..cabed93 100644
--- a/test/main.zig
+++ b/test/main.zig
@@ -18,51 +18,260 @@ comptime {
 
 pub const psp_stack_size: u32 = 256 * 1024;
 
-// PSP: override panic/IO handlers that would otherwise pull in posix symbols.
-pub const panic = if (ae.platform == .psp) sdk.extra.debug.panic else std.debug.FullPanic(std.debug.defaultPanic);
-pub const std_options_debug_threaded_io = if (ae.platform == .psp) null else std.Io.Threaded.global_single_threaded;
-pub const std_options_debug_io = if (ae.platform == .psp) sdk.extra.Io.psp_io else std.Io.Threaded.global_single_threaded.io();
-pub const std_options_cwd = if (ae.platform == .psp) psp_cwd else null;
+const ThreeDSLinearHeap = if (ae.platform == .nintendo_3ds) struct {
+    extern fn linearSpaceFree() u32;
+
+    fn spaceFree() usize {
+        return linearSpaceFree();
+    }
+} else struct {
+    fn spaceFree() usize {
+        return 0;
+    }
+};
+
+// PSP, 3DS, and Switch override panic/IO handlers that would otherwise
+// pull in posix symbols (Io.Threaded references std.posix decls that
+// don't exist for these targets). 3DS and Switch use Aether's newlib-backed
+// baseline so debug prints and file IO go through the backend instead of
+// dereferencing an undefined Io implementation.
+const is_freestanding_console = ae.platform == .psp or ae.platform == .nintendo_3ds or ae.platform == .nintendo_switch;
+// 3DS routes panics through err:f; Switch keeps `no_panic` while the debug IO
+// baseline is intentionally small.
+pub const panic = if (ae.platform == .psp) sdk.extra.debug.panic else if (ae.platform == .nintendo_3ds) ae.ThreeDS.panic else if (ae.platform == .nintendo_switch) std.debug.no_panic else std.debug.FullPanic(std.debug.defaultPanic);
+pub const std_options_debug_threaded_io = if (is_freestanding_console) null else std.Io.Threaded.global_single_threaded;
+pub const std_options_debug_io: std.Io =
+    if (ae.platform == .psp) sdk.extra.Io.psp_io else if (ae.platform == .nintendo_3ds or ae.platform == .nintendo_switch) ae.Cio.io() else std.Io.Threaded.global_single_threaded.io();
+pub const std_options_cwd =
+    if (ae.platform == .psp) psp_cwd else if (ae.platform == .nintendo_3ds or ae.platform == .nintendo_switch) ae.Cio.cwd else null;
 fn psp_cwd() std.Io.Dir {
     return .{ .handle = -1 };
 }
 
-const Vertex = extern struct {
-    uv: [2]i16,
-    color: u32,
-    pos: [3]i16,
-    _pad: i16 = 0,
-
-    pub const Attributes = Rendering.Pipeline.attributes_from_struct(@This(), &[_]Rendering.Pipeline.AttributeSpec{
-        .{ .field = "pos", .location = 0, .usage = .position },
-        .{ .field = "color", .location = 1, .usage = .color },
-        .{ .field = "uv", .location = 2, .usage = .uv },
-    });
-    pub const Layout = Rendering.Pipeline.layout_from_struct(@This(), &Attributes);
-};
-
+const Vertex = Rendering.Vertex;
 const MyMesh = Rendering.Mesh(Vertex);
 
+const BATCH_A_TRIANGLES = 61;
+const BATCH_B_TRIANGLES = 78;
 const MAX_GRASS_VOICES = 4;
 const Vec3 = Math.Vec3;
 
-const MyState = struct {
-    mesh: MyMesh,
-    transform: Rendering.Transform,
+fn rgba(r: u8, g: u8, b: u8) u32 {
+    return @as(u32, r) |
+        (@as(u32, g) << 8) |
+        (@as(u32, b) << 16) |
+        (@as(u32, 0xFF) << 24);
+}
+
+const BatchAColors = [_]u32{
+    rgba(255, 62, 62),
+    rgba(255, 170, 54),
+    rgba(245, 235, 80),
+    rgba(76, 210, 130),
+    rgba(58, 190, 235),
+    rgba(145, 105, 255),
+};
+
+const BatchBColors = [_]u32{
+    rgba(48, 110, 255),
+    rgba(56, 205, 190),
+    rgba(225, 88, 180),
+    rgba(240, 150, 70),
+    rgba(210, 230, 80),
+    rgba(255, 255, 255),
+};
+
+fn snorm16(v: f32) i16 {
+    return @intFromFloat(std.math.clamp(v, -1.0, 1.0) * 32767.0);
+}
+
+fn tenths(v: f32) i32 {
+    return @intFromFloat(v * 10.0);
+}
+
+fn vertex(x: f32, y: f32, color: u32, u: f32, v: f32) Vertex {
+    return .{
+        .pos = .{ snorm16(x), snorm16(y), 0 },
+        .color = color,
+        .uv = .{ snorm16(u), snorm16(v) },
+    };
+}
+
+fn appendTriangle(
+    alloc: std.mem.Allocator,
+    mesh: *MyMesh,
+    a: [2]f32,
+    b: [2]f32,
+    c: [2]f32,
+    ca: u32,
+    cb: u32,
+    cc: u32,
+) !void {
+    try mesh.append(alloc, &.{
+        vertex(a[0], a[1], ca, 0.5, 0.0),
+        vertex(b[0], b[1], cb, 0.0, 1.0),
+        vertex(c[0], c[1], cc, 1.0, 1.0),
+    });
+}
+
+fn orientedPoint(cx: f32, cy: f32, lx: f32, ly: f32, angle: f32) [2]f32 {
+    const c = @cos(angle);
+    const s = @sin(angle);
+    return .{
+        cx + lx * c - ly * s,
+        cy + lx * s + ly * c,
+    };
+}
+
+fn appendOrientedTriangle(
+    alloc: std.mem.Allocator,
+    mesh: *MyMesh,
+    cx: f32,
+    cy: f32,
+    sx: f32,
+    sy: f32,
+    angle: f32,
+    c0: u32,
+    c1: u32,
+    c2: u32,
+) !void {
+    try appendTriangle(
+        alloc,
+        mesh,
+        orientedPoint(cx, cy, 0.0, sy, angle),
+        orientedPoint(cx, cy, -sx, -sy, angle),
+        orientedPoint(cx, cy, sx, -sy, angle),
+        c0,
+        c1,
+        c2,
+    );
+}
+
+fn buildBatchA(alloc: std.mem.Allocator, mesh: *MyMesh) !void {
+    try mesh.vertices.ensureTotalCapacity(alloc, BATCH_A_TRIANGLES * 3);
+
+    try appendTriangle(alloc, mesh, .{ -0.44, -0.40 }, .{ 0.44, -0.40 }, .{ 0.0, 0.52 }, BatchAColors[0], BatchAColors[3], BatchAColors[5]);
+
+    const spoke_count = 36;
+    for (0..spoke_count) |i| {
+        const t = @as(f32, @floatFromInt(i)) / @as(f32, @floatFromInt(spoke_count));
+        const angle = t * std.math.pi * 2.0;
+        const tip_radius = 0.78 + @sin(angle * 3.0) * 0.04;
+        const base_radius = 0.31 + @cos(angle * 2.0) * 0.035;
+        const half_width = 0.075 + @sin(angle * 5.0) * 0.012;
+        const tip = [2]f32{ @cos(angle) * tip_radius, @sin(angle) * tip_radius };
+        const left = [2]f32{ @cos(angle - half_width) * base_radius, @sin(angle - half_width) * base_radius };
+        const right = [2]f32{ @cos(angle + half_width) * base_radius, @sin(angle + half_width) * base_radius };
+
+        try appendTriangle(
+            alloc,
+            mesh,
+            tip,
+            left,
+            right,
+            BatchAColors[i % BatchAColors.len],
+            BatchAColors[(i + 2) % BatchAColors.len],
+            BatchAColors[(i + 4) % BatchAColors.len],
+        );
+    }
+
+    const marker_count = 24;
+    for (0..marker_count) |i| {
+        const t = @as(f32, @floatFromInt(i)) / @as(f32, @floatFromInt(marker_count));
+        const angle = t * std.math.pi * 2.0;
+        const radius = 0.56 + if (i % 2 == 0) @as(f32, 0.045) else -0.025;
+        const size = 0.032 + @as(f32, @floatFromInt(i % 4)) * 0.006;
+        try appendOrientedTriangle(
+            alloc,
+            mesh,
+            @cos(angle) * radius,
+            @sin(angle) * radius,
+            size * 0.75,
+            size,
+            angle + std.math.pi * 0.5,
+            BatchAColors[(i + 1) % BatchAColors.len],
+            BatchAColors[(i + 3) % BatchAColors.len],
+            BatchAColors[(i + 5) % BatchAColors.len],
+        );
+    }
+}
+
+fn buildBatchB(alloc: std.mem.Allocator, mesh: *MyMesh) !void {
+    try mesh.vertices.ensureTotalCapacity(alloc, BATCH_B_TRIANGLES * 3);
+
+    const cols = 9;
+    const rows = 6;
+    for (0..rows) |row| {
+        for (0..cols) |col| {
+            const idx = row * cols + col;
+            const fx = @as(f32, @floatFromInt(col)) / @as(f32, @floatFromInt(cols - 1));
+            const fy = @as(f32, @floatFromInt(row)) / @as(f32, @floatFromInt(rows - 1));
+            const x = -0.88 + fx * 1.76;
+            const y = -0.67 + fy * 1.34;
+            const size = 0.04 + @as(f32, @floatFromInt((idx + row) % 5)) * 0.008;
+            const angle = @as(f32, @floatFromInt(idx)) * 0.43 + @sin(fy * std.math.pi) * 0.35;
+
+            try appendOrientedTriangle(
+                alloc,
+                mesh,
+                x,
+                y,
+                size * (0.72 + fx * 0.35),
+                size,
+                angle,
+                BatchBColors[idx % BatchBColors.len],
+                BatchBColors[(idx + 2) % BatchBColors.len],
+                BatchBColors[(idx + 4) % BatchBColors.len],
+            );
+        }
+    }
+
+    const wave_count = 24;
+    for (0..wave_count) |i| {
+        const t = @as(f32, @floatFromInt(i)) / @as(f32, @floatFromInt(wave_count - 1));
+        const x = -0.94 + t * 1.88;
+        const y = 0.78 + @sin(t * std.math.pi * 6.0) * 0.095;
+        const size = 0.035 + @as(f32, @floatFromInt(i % 3)) * 0.007;
+        const angle = t * std.math.pi * 4.0;
+
+        try appendOrientedTriangle(
+            alloc,
+            mesh,
+            x,
+            y,
+            size,
+            size * 1.6,
+            angle,
+            BatchBColors[(i + 5) % BatchBColors.len],
+            BatchBColors[(i + 1) % BatchBColors.len],
+            BatchBColors[(i + 3) % BatchBColors.len],
+        );
+    }
+}
+
+pub const MyState = struct {
+    batch_a: MyMesh,
+    batch_b: MyMesh,
+    batch_a_transform: Rendering.Transform,
+    batch_b_transform: Rendering.Transform,
     texture: Rendering.Texture,
-    music_data: []u8,
+    music_data: []const u8,
     music_reader: std.Io.Reader,
-    grass_data: []u8,
+    grass_data: []const u8,
     grass_readers: [MAX_GRASS_VOICES]std.Io.Reader,
     grass_tick: u32,
     grass_spawn: u32,
+    time: f32,
 
     fn load_wav(engine: *ae.Engine, path: []const u8) ![]u8 {
-        var file = try std.Io.Dir.cwd().openFile(engine.io, path, .{});
+        var file = try engine.dirs.resources.openFile(engine.io, path, .{});
         defer file.close(engine.io);
 
         var tmp: [4096]u8 = undefined;
-        var rdr = file.reader(engine.io, &tmp);
+        var rdr = if (ae.platform == .nintendo_3ds or ae.platform == .nintendo_switch)
+            file.readerStreaming(engine.io, &tmp)
+        else
+            file.reader(engine.io, &tmp);
 
         var riff_hdr: [8]u8 = undefined;
         try rdr.interface.readSliceAll(&riff_hdr);
@@ -76,22 +285,30 @@ const MyState = struct {
 
     fn init(ctx: *anyopaque, engine: *ae.Engine) anyerror!void {
         var self = ae.ctx_to_self(MyState, ctx);
-        const vert align(@alignOf(u32)) = @embedFile("basic_vert").*;
-        const frag align(@alignOf(u32)) = @embedFile("basic_frag").*;
-        pipeline = try Rendering.Pipeline.new(Vertex.Layout, &vert, &frag);
 
         const render = engine.allocator(.render);
 
-        self.mesh = try MyMesh.new(render, pipeline);
-        self.transform = Rendering.Transform.new();
+        self.batch_a = try MyMesh.new(render);
+        self.batch_b = try MyMesh.new(render);
+        self.batch_a_transform = Rendering.Transform.new();
+        self.batch_b_transform = Rendering.Transform.new();
 
         self.texture = try Rendering.Texture.load(engine.io, engine.dirs.resources, render, "test.png");
-        try self.mesh.append(render, &.{
-            Vertex{ .pos = .{ -16383, -16383, 0 }, .color = 0xFF0000FF, .uv = .{ 0, 32767 } },
-            Vertex{ .pos = .{ 16383, -16383, 0 }, .color = 0xFF00FF00, .uv = .{ 32767, 32767 } },
-            Vertex{ .pos = .{ 0, 16383, 0 }, .color = 0xFFFF0000, .uv = .{ 16383, 0 } },
-        });
-        self.mesh.update();
+
+        try buildBatchA(render, &self.batch_a);
+        try buildBatchB(render, &self.batch_b);
+        self.batch_a.update();
+        self.batch_b.update();
+
+        self.music_data = &.{};
+        self.music_reader = .fixed(&.{});
+        self.grass_data = &.{};
+        self.grass_readers = @splat(.fixed(&.{}));
+        self.grass_tick = 0;
+        self.grass_spawn = 0;
+        self.time = 0.0;
+
+        if (!Audio.enabled) return;
 
         // -- background music --
         self.music_data = try load_wav(engine, "calm1.wav");
@@ -101,9 +318,6 @@ const MyState = struct {
 
         // -- spatial SFX data --
         self.grass_data = try load_wav(engine, "grass1.wav");
-        self.grass_readers = @splat(.fixed(&.{}));
-        self.grass_tick = 0;
-        self.grass_spawn = 0;
 
         // Listener at origin, facing -Z
         Audio.set_listener(Vec3.zero(), Vec3.new(0, 0, -1), Vec3.new(0, 1, 0));
@@ -115,11 +329,13 @@ const MyState = struct {
         var self = ae.ctx_to_self(MyState, ctx);
         const render = engine.allocator(.render);
         self.texture.deinit(render);
-        self.mesh.deinit(render);
-        Rendering.Pipeline.deinit(pipeline);
+        self.batch_b.deinit(render);
+        self.batch_a.deinit(render);
     }
 
     fn tick(ctx: *anyopaque, _: *ae.Engine) anyerror!void {
+        if (!Audio.enabled) return;
+
         var self = ae.ctx_to_self(MyState, ctx);
         self.grass_tick += 1;
 
@@ -143,13 +359,28 @@ const MyState = struct {
                 .max_distance = 25.0,
             }) catch return;
 
-            Util.game_logger.info("grass at ({d:.1}, 0, {d:.1})  dist={d:.1}", .{ pos.x, pos.z, dist });
+            if (ae.platform == .nintendo_3ds) {
+                Util.game_logger.info("grass at x10={} z10={} dist10={}", .{ tenths(pos.x), tenths(pos.z), tenths(dist) });
+            } else {
+                Util.game_logger.info("grass at ({d:.1}, 0, {d:.1})  dist={d:.1}", .{ pos.x, pos.z, dist });
+            }
         }
     }
 
     fn update(ctx: *anyopaque, _: *ae.Engine, dt: f32, _: *const Util.BudgetContext) anyerror!void {
         var self = ae.ctx_to_self(MyState, ctx);
-        self.transform.rot.z += 60.0 * dt;
+        self.time += dt;
+
+        self.batch_a_transform.rot.z += 76.0 * dt;
+        self.batch_b_transform.rot.z -= 18.0 * dt;
+
+        const batch_a_pulse = 1.0 + @sin(self.time * 1.8) * 0.06;
+        const batch_b_x = 1.0 + @cos(self.time * 0.9) * 0.035;
+        const batch_b_y = 1.0 + @sin(self.time * 1.1) * 0.035;
+
+        self.batch_a_transform.scale = Vec3.new(batch_a_pulse, batch_a_pulse, 1.0);
+        self.batch_b_transform.scale = Vec3.new(batch_b_x, batch_b_y, 1.0);
+        self.batch_b_transform.pos = Vec3.new(@sin(self.time * 0.7) * 0.075, @cos(self.time * 0.5) * 0.04, 0.0);
     }
 
     fn draw(ctx: *anyopaque, _: *ae.Engine, _: f32, _: *const Util.BudgetContext) anyerror!void {
@@ -162,9 +393,11 @@ const MyState = struct {
             1,
         ));
 
-        Rendering.Pipeline.bind(pipeline);
+        Rendering.gfx.api.set_depth_write(false);
         self.texture.bind();
-        self.mesh.draw(&self.transform.get_matrix());
+        self.batch_b.draw(&self.batch_b_transform.get_matrix());
+        self.batch_a.draw(&self.batch_a_transform.get_matrix());
+        Rendering.gfx.api.set_depth_write(true);
     }
 
     pub fn state(self: *MyState) State {
@@ -178,22 +411,40 @@ const MyState = struct {
     }
 };
 
-var pipeline: Rendering.Pipeline.Handle = undefined;
-
 pub fn main(init: std.process.Init) !void {
-    const memory = try init.arena.allocator().alloc(u8, 32 * 1024 * 1024);
+    const mib = 1024 * 1024;
+    const memory_config: ae.Util.MemoryConfig = .{
+        .render = if (ae.platform == .nintendo_3ds) 28 * 1024 * 1024 else 12 * 1024 * 1024,
+        .audio = 10 * 1024 * 1024,
+        .game = 2 * 1024 * 1024,
+        .user = 8 * 1024 * 1024,
+    };
+    const main_memory_bytes = memory_config.total();
+    const memory = init.gpa.alignedAlloc(u8, .fromByteUnits(16), main_memory_bytes) catch |err| switch (err) {
+        error.OutOfMemory => std.debug.panic(
+            "MainOOMMiB m={} f={} h={} l={}",
+            .{
+                main_memory_bytes / mib,
+                ThreeDSLinearHeap.spaceFree() / mib,
+                ae.nintendo_3ds_heap_size / mib,
+                ae.nintendo_3ds_linear_heap_size / mib,
+            },
+        ),
+    };
+    defer init.gpa.free(memory);
 
     var state: MyState = undefined;
     var engine: ae.Engine = undefined;
-    try engine.init(init.io, init.environ_map, memory, .{
-        .memory = .{
-            .render = 12 * 1024 * 1024,
-            .audio = 10 * 1024 * 1024,
-            .game = 2 * 1024 * 1024,
-            .user = 8 * 1024 * 1024,
-        },
+    engine.init(init.io, init.environ_map, memory, .{
+        .memory = memory_config,
         .resizable = true,
-    }, &state.state());
+    }, &state.state()) catch |err| switch (err) {
+        error.OutOfMemory => return error.EngineInitOutOfMemory,
+        else => return err,
+    };
     defer engine.deinit();
-    try engine.run();
+    engine.run() catch |err| switch (err) {
+        error.OutOfMemory => return error.EngineRunOutOfMemory,
+        else => return err,
+    };
 }
diff --git a/test/test.png b/test/test.png
index c3cd43a..f3af608 100644
Binary files a/test/test.png and b/test/test.png differ
diff --git a/test/web_main.zig b/test/web_main.zig
new file mode 100644
index 0000000..d22ef47
--- /dev/null
+++ b/test/web_main.zig
@@ -0,0 +1,78 @@
+const std = @import("std");
+const ae = @import("aether");
+const Util = ae.Util;
+const test_app = @import("main.zig");
+
+pub const std_options = Util.std_options;
+pub const std_options_debug_threaded_io = std.Io.Threaded.global_single_threaded;
+pub const std_options_debug_io: std.Io = std.Io.Threaded.global_single_threaded.io();
+
+const gpa = std.heap.wasm_allocator;
+
+var env_map: std.process.Environ.Map = undefined;
+var env_map_initialized: bool = false;
+var memory: []u8 = &.{};
+var state: test_app.MyState = undefined;
+var engine: ae.Engine = undefined;
+var initialized: bool = false;
+
+export fn aether_wasm_init(width: u32, height: u32) bool {
+    if (initialized) return true;
+
+    env_map = std.process.Environ.Map.init(gpa);
+    env_map_initialized = true;
+
+    const memory_config = webMemoryConfig();
+    memory = gpa.alignedAlloc(u8, .fromByteUnits(16), memory_config.total()) catch return false;
+
+    engine.init(std.Io.Threaded.global_single_threaded.io(), &env_map, memory, .{
+        .memory = memory_config,
+        .width = width,
+        .height = height,
+        .resizable = true,
+    }, &state.state()) catch {
+        gpa.free(memory);
+        memory = &.{};
+        env_map.deinit();
+        env_map_initialized = false;
+        return false;
+    };
+    engine.beginRun();
+    initialized = true;
+    return true;
+}
+
+export fn aether_wasm_frame() bool {
+    if (!initialized) return false;
+    return engine.stepFrame() catch false;
+}
+
+export fn aether_wasm_deinit() void {
+    if (!initialized) return;
+    initialized = false;
+    engine.deinit();
+    gpa.free(memory);
+    memory = &.{};
+    if (env_map_initialized) {
+        env_map.deinit();
+        env_map_initialized = false;
+    }
+}
+
+export fn aether_wasm_alloc(len: usize) ?[*]u8 {
+    const buf = gpa.alloc(u8, len) catch return null;
+    return buf.ptr;
+}
+
+export fn aether_wasm_free(ptr: [*]u8, len: usize) void {
+    gpa.free(ptr[0..len]);
+}
+
+fn webMemoryConfig() ae.Util.MemoryConfig {
+    return .{
+        .render = 12 * 1024 * 1024,
+        .audio = 10 * 1024 * 1024,
+        .game = 2 * 1024 * 1024,
+        .user = 8 * 1024 * 1024,
+    };
+}
diff --git a/tools/serve_web.zig b/tools/serve_web.zig
new file mode 100644
index 0000000..374666b
--- /dev/null
+++ b/tools/serve_web.zig
@@ -0,0 +1,123 @@
+const std = @import("std");
+
+const Io = std.Io;
+const http = std.http;
+const net = std.Io.net;
+
+const max_file_size = 256 * 1024 * 1024;
+
+pub fn main(init: std.process.Init) !void {
+    const gpa = init.gpa;
+    const io = init.io;
+
+    var args = try std.process.Args.Iterator.initAllocator(init.minimal.args, gpa);
+    defer args.deinit();
+    _ = args.next();
+
+    const root_path = args.next() orelse "zig-out/web";
+    const host = args.next() orelse "127.0.0.1";
+    const port_text = args.next() orelse "8080";
+    const port = try std.fmt.parseInt(u16, port_text, 10);
+
+    var root_dir = try Io.Dir.cwd().openDir(io, root_path, .{});
+    defer root_dir.close(io);
+
+    var address = try net.IpAddress.parse(host, port);
+    var server = try address.listen(io, .{ .reuse_address = true });
+    defer server.deinit(io);
+
+    std.debug.print("Serving Aether web build at http://{s}:{d}/\n", .{ host, port });
+
+    while (true) {
+        const stream = try server.accept(io);
+        handleConnection(io, gpa, root_dir, stream) catch |err| {
+            std.debug.print("web connection error: {s}\n", .{@errorName(err)});
+        };
+    }
+}
+
+fn handleConnection(io: Io, gpa: std.mem.Allocator, root_dir: Io.Dir, stream: net.Stream) !void {
+    defer {
+        var s = stream;
+        s.close(io);
+    }
+
+    var send_buffer: [4096]u8 = undefined;
+    var recv_buffer: [4096]u8 = undefined;
+    var connection_reader = stream.reader(io, &recv_buffer);
+    var connection_writer = stream.writer(io, &send_buffer);
+    var server: http.Server = .init(&connection_reader.interface, &connection_writer.interface);
+
+    while (true) {
+        var request = server.receiveHead() catch |err| switch (err) {
+            error.HttpConnectionClosing => return,
+            else => return err,
+        };
+        try serveRequest(io, gpa, root_dir, &request);
+    }
+}
+
+fn serveRequest(io: Io, gpa: std.mem.Allocator, root_dir: Io.Dir, request: *http.Server.Request) !void {
+    const path = sanitizeTarget(request.head.target) orelse {
+        try respondText(request, .bad_request, "bad request");
+        return;
+    };
+
+    const file_contents = root_dir.readFileAlloc(io, path, gpa, .limited(max_file_size)) catch |err| switch (err) {
+        error.FileNotFound => {
+            try respondText(request, .not_found, "not found");
+            return;
+        },
+        else => return err,
+    };
+    defer gpa.free(file_contents);
+
+    const content_type = contentType(path);
+    const headers = commonHeaders(content_type);
+    try request.respond(file_contents, .{
+        .keep_alive = false,
+        .extra_headers = &headers,
+    });
+}
+
+fn respondText(request: *http.Server.Request, status: http.Status, text: []const u8) !void {
+    const headers = commonHeaders("text/plain; charset=utf-8");
+    try request.respond(text, .{
+        .status = status,
+        .keep_alive = false,
+        .extra_headers = &headers,
+    });
+}
+
+fn sanitizeTarget(target: []const u8) ?[]const u8 {
+    const no_query = if (std.mem.indexOfScalar(u8, target, '?')) |i| target[0..i] else target;
+    if (no_query.len == 0 or no_query[0] != '/') return null;
+    const path = if (std.mem.eql(u8, no_query, "/")) "index.html" else no_query[1..];
+    if (path.len == 0) return null;
+    if (std.mem.indexOf(u8, path, "..") != null) return null;
+    if (std.mem.indexOfScalar(u8, path, '\\') != null) return null;
+    if (std.mem.indexOfScalar(u8, path, 0) != null) return null;
+    return path;
+}
+
+fn contentType(path: []const u8) []const u8 {
+    if (std.mem.endsWith(u8, path, ".html")) return "text/html; charset=utf-8";
+    if (std.mem.endsWith(u8, path, ".js")) return "text/javascript; charset=utf-8";
+    if (std.mem.endsWith(u8, path, ".wasm")) return "application/wasm";
+    if (std.mem.endsWith(u8, path, ".png")) return "image/png";
+    if (std.mem.endsWith(u8, path, ".jpg") or std.mem.endsWith(u8, path, ".jpeg")) return "image/jpeg";
+    if (std.mem.endsWith(u8, path, ".wav")) return "audio/wav";
+    if (std.mem.endsWith(u8, path, ".manifest")) return "text/plain; charset=utf-8";
+    return "application/octet-stream";
+}
+
+fn commonHeaders(content_type: []const u8) [6]http.Header {
+    return .{
+        .{ .name = "Content-Type", .value = content_type },
+        .{ .name = "Content-Security-Policy", .value = "default-src 'self'; script-src 'self' 'wasm-unsafe-eval'; connect-src 'self'; img-src 'self' data:; media-src 'self'; style-src 'self' 'unsafe-inline'" },
+        .{ .name = "Cross-Origin-Opener-Policy", .value = "same-origin" },
+        .{ .name = "Cross-Origin-Embedder-Policy", .value = "require-corp" },
+        .{ .name = "Cross-Origin-Resource-Policy", .value = "same-origin" },
+        .{ .name = "Cache-Control", .value = "no-store" },
+    };
+}
diff --git a/web/aether.js b/web/aether.js
new file mode 100644
index 0000000..953a1fd
--- /dev/null
+++ b/web/aether.js
@@ -0,0 +1,1074 @@
+const canvas = document.getElementById("aether");
+const statusEl = document.getElementById("status");
+const textDecoder = new TextDecoder();
+const textEncoder = new TextEncoder();
+
+let instance = null;
+let memory = null;
+let gl = null;
+let program = null;
+let currentTexture = null;
+let cameraBuffer = null;
+let perObjectBuffer = null;
+let nextMeshHandle = 1;
+let nextTextureHandle = 1;
+const meshes = new Map();
+const textures = new Map();
+const audioSlots = new Map();
+let audioContext = null;
+let gainRoot = null;
+let audioSampleRate = 48000;
+let audioMaxSlots = 32;
+let requestedCursorMode = 3;
+let pointerLocked = false;
+let suppressNextPointerUnlock = false;
+let pendingSyntheticEscapeUp = false;
+let ignorePointerMoveCount = 0;
+
+const CURSOR_CAPTURED = 0;
+const CURSOR_FREE = 1;
+const CURSOR_HIDDEN = 2;
+const CURSOR_VISIBLE = 3;
+const KEY_ESCAPE = 256;
+
+const CAMERA_UBO_SIZE = 176;
+const PER_OBJECT_UBO_SIZE = 64;
+const cameraBytes = new Uint8Array(CAMERA_UBO_SIZE);
+const cameraData = new DataView(cameraBytes.buffer);
+const perObjectBytes = new Uint8Array(PER_OBJECT_UBO_SIZE);
+
+const files = new Map();
+const dirs = new Set(["."]);
+const fds = new Map([
+  [0, { kind: "stdio" }],
+  [1, { kind: "stdio" }],
+  [2, { kind: "stdio" }],
+  [3, { kind: "dir", path: "/" }],
+]);
+const stdioBuffers = new Map([
+  [1, ""],
+  [2, ""],
+]);
+let nextFd = 4;
+
+function bytes() {
+  return new Uint8Array(memory.buffer);
+}
+function view() {
+  return new DataView(memory.buffer);
+}
+function f32(ptr, count) {
+  return new Float32Array(memory.buffer, ptr, count);
+}
+function f32Copy(ptr, count) {
+  return Float32Array.from(f32(ptr, count));
+}
+function copyBytes(ptr, len) {
+  return Uint8Array.from(bytes().subarray(ptr, ptr + len));
+}
+function str(ptr, len) {
+  return textDecoder.decode(copyBytes(ptr, len));
+}
+function setStatus(text) {
+  statusEl.textContent = text;
+}
+
+async function preload(name) {
+  const response = await fetch(`./${name}`);
+  if (!response.ok) throw new Error(`missing resource ${name}`);
+  files.set(name, new Uint8Array(await response.arrayBuffer()));
+}
+
+async function preloadResourceDirectory() {
+  const manifestResponse = await fetch("./resources.manifest", {
+    cache: "no-store",
+  });
+  if (!manifestResponse.ok) return;
+  const manifest = await manifestResponse.text();
+  const entries = manifest
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line && !line.startsWith("#"));
+  await Promise.all(entries.map(preload));
+}
+
+function errno(code) {
+  return code;
+}
+const WASI = {
+  proc_exit(code) {
+    throw new Error(`WASI exited with ${code}`);
+  },
+  args_sizes_get(argcPtr, argvBufSizePtr) {
+    view().setUint32(argcPtr, 0, true);
+    view().setUint32(argvBufSizePtr, 0, true);
+    return 0;
+  },
+  args_get() {
+    return 0;
+  },
+  environ_sizes_get(countPtr, sizePtr) {
+    view().setUint32(countPtr, 0, true);
+    view().setUint32(sizePtr, 0, true);
+    return 0;
+  },
+  environ_get() {
+    return 0;
+  },
+  clock_time_get(id, precision, timePtr) {
+    const ns =
+      id === 1
+        ? BigInt(Math.floor(performance.now() * 1_000_000))
+        : BigInt(Date.now()) * 1_000_000n;
+    view().setBigUint64(timePtr, ns, true);
+    return 0;
+  },
+  clock_res_get(id, resolutionPtr) {
+    const ns = id === 1 ? 1_000_000n : 1_000_000n;
+    view().setBigUint64(resolutionPtr, ns, true);
+    return 0;
+  },
+  poll_oneoff(inPtr, outPtr, nsubscriptions, neventsPtr) {
+    view().setUint32(neventsPtr, 0, true);
+    return 0;
+  },
+  random_get(ptr, len) {
+    const random = new Uint8Array(len);
+    crypto.getRandomValues(random);
+    bytes().set(random, ptr);
+    return 0;
+  },
+  fd_prestat_get(fd, ptr) {
+    if (fd !== 3) return errno(8);
+    view().setUint8(ptr, 0);
+    view().setUint32(ptr + 4, 1, true);
+    return 0;
+  },
+  fd_prestat_dir_name(fd, ptr, len) {
+    if (fd !== 3) return errno(8);
+    bytes().set(textEncoder.encode("/").subarray(0, len), ptr);
+    return 0;
+  },
+  fd_fdstat_get(fd, ptr) {
+    const file = fds.get(fd);
+    if (!file) return errno(8);
+    view().setUint8(ptr, file.kind === "dir" ? 3 : 4);
+    view().setUint16(ptr + 2, 0, true);
+    view().setBigUint64(ptr + 8, 0xffff_ffffn, true);
+    view().setBigUint64(ptr + 16, 0xffff_ffffn, true);
+    return 0;
+  },
+  fd_close(fd) {
+    if (fd <= 3) return 0;
+    fds.delete(fd);
+    return 0;
+  },
+  fd_filestat_get(fd, ptr) {
+    const file = fds.get(fd);
+    if (!file) return errno(8);
+    const size = file.data ? file.data.length : 0;
+    for (let i = 0; i < 64; i++) view().setUint8(ptr + i, 0);
+    view().setUint8(ptr + 16, file.kind === "dir" ? 3 : 4);
+    view().setBigUint64(ptr + 32, BigInt(size), true);
+    return 0;
+  },
+  fd_filestat_set_times() {
+    return 0;
+  },
+  fd_filestat_set_size(fd, size) {
+    const file = fds.get(fd);
+    if (!file || file.kind !== "file") return errno(8);
+    const next = new Uint8Array(Number(size));
+    next.set(file.data.subarray(0, Math.min(file.data.length, next.length)));
+    file.data = next;
+    file.pos = Math.min(file.pos, next.length);
+    files.set(file.name, next);
+    return 0;
+  },
+  fd_sync() {
+    return 0;
+  },
+  path_filestat_get(fd, flags, pathPtr, pathLen, resultPtr) {
+    const name = resolvePath(fd, str(pathPtr, pathLen));
+    if (!name) return errno(8);
+    const data = files.get(name);
+    const isDir = dirs.has(name);
+    if (!data && !isDir) return errno(44);
+    for (let i = 0; i < 64; i++) view().setUint8(resultPtr + i, 0);
+    view().setUint8(resultPtr + 16, isDir ? 3 : 4);
+    view().setBigUint64(resultPtr + 32, BigInt(data ? data.length : 0), true);
+    return 0;
+  },
+  path_create_directory(fd, pathPtr, pathLen) {
+    const name = resolvePath(fd, str(pathPtr, pathLen));
+    if (!name) return errno(8);
+    dirs.add(name);
+    return 0;
+  },
+  path_link() {
+    return errno(52);
+  },
+  path_symlink() {
+    return errno(52);
+  },
+  path_readlink() {
+    return errno(52);
+  },
+  path_rename(oldFd, oldPathPtr, oldPathLen, newFd, newPathPtr, newPathLen) {
+    const oldName = resolvePath(oldFd, str(oldPathPtr, oldPathLen));
+    const newName = resolvePath(newFd, str(newPathPtr, newPathLen));
+    if (!oldName || !newName) return errno(8);
+    const data = files.get(oldName);
+    if (!data) return errno(44);
+    files.set(newName, data);
+    files.delete(oldName);
+    for (const file of fds.values()) {
+      if (file.name === oldName) file.name = newName;
+    }
+    return 0;
+  },
+  path_remove_directory() {
+    return 0;
+  },
+  path_unlink_file(fd, pathPtr, pathLen) {
+    const name = resolvePath(fd, str(pathPtr, pathLen));
+    if (!name) return errno(8);
+    files.delete(name);
+    return 0;
+  },
+  path_open(
+    fd,
+    dirflags,
+    pathPtr,
+    pathLen,
+    oflags,
+    rightsBase,
+    rightsInheriting,
+    fdflags,
+    openedFdPtr,
+  ) {
+    const name = resolvePath(fd, str(pathPtr, pathLen));
+    if (!name) return errno(8);
+    const create = (oflags & 1) !== 0;
+    const directory = (oflags & 2) !== 0;
+    const exclusive = (oflags & 4) !== 0;
+    const truncate = (oflags & 8) !== 0;
+    if (directory) {
+      if (!dirs.has(name)) return errno(44);
+      const newFd = nextFd++;
+      fds.set(newFd, { kind: "dir", path: name });
+      view().setUint32(openedFdPtr, newFd, true);
+      return 0;
+    }
+    let data = files.get(name);
+    if (!data) {
+      if (!create) return errno(44);
+      data = new Uint8Array(0);
+      files.set(name, data);
+    } else if (create && exclusive) {
+      return errno(20);
+    } else if (truncate) {
+      data = new Uint8Array(0);
+      files.set(name, data);
+    }
+    const newFd = nextFd++;
+    fds.set(newFd, { kind: "file", name, data, pos: 0, writable: true });
+    view().setUint32(openedFdPtr, newFd, true);
+    return 0;
+  },
+  fd_readdir(fd, bufPtr, bufLen, cookie, bufUsedPtr) {
+    const file = fds.get(fd);
+    if (!file || file.kind !== "dir") return errno(8);
+    const entries = directoryEntries(file.path || ".");
+    let out = 0;
+    const start = Number(cookie);
+    for (let i = start; i < entries.length; i++) {
+      const entry = entries[i];
+      const nameBytes = textEncoder.encode(entry.name);
+      const needed = 24 + nameBytes.length;
+      if (out + needed > bufLen) break;
+
+      const ptr = bufPtr + out;
+      view().setBigUint64(ptr, BigInt(i + 1), true);
+      view().setBigUint64(ptr + 8, BigInt(i + 1), true);
+      view().setUint32(ptr + 16, nameBytes.length, true);
+      view().setUint8(ptr + 20, entry.type);
+      view().setUint8(ptr + 21, 0);
+      view().setUint8(ptr + 22, 0);
+      view().setUint8(ptr + 23, 0);
+      bytes().set(nameBytes, ptr + 24);
+      out += needed;
+    }
+    view().setUint32(bufUsedPtr, out, true);
+    return 0;
+  },
+  fd_read(fd, iovsPtr, iovsLen, nreadPtr) {
+    const file = fds.get(fd);
+    if (!file || !file.data) return errno(8);
+    let total = 0;
+    for (let i = 0; i < iovsLen; i++) {
+      const ptr = view().getUint32(iovsPtr + i * 8, true);
+      const len = view().getUint32(iovsPtr + i * 8 + 4, true);
+      const chunk = file.data.subarray(file.pos, file.pos + len);
+      bytes().set(chunk, ptr);
+      file.pos += chunk.length;
+      total += chunk.length;
+      if (chunk.length < len) break;
+    }
+    view().setUint32(nreadPtr, total, true);
+    return 0;
+  },
+  fd_pread(fd, iovsPtr, iovsLen, offset, nreadPtr) {
+    const file = fds.get(fd);
+    if (!file || !file.data) return errno(8);
+    const oldPos = file.pos;
+    file.pos = Number(offset);
+    const result = WASI.fd_read(fd, iovsPtr, iovsLen, nreadPtr);
+    file.pos = oldPos;
+    return result;
+  },
+  fd_write(fd, iovsPtr, iovsLen, nwrittenPtr) {
+    const file = fds.get(fd);
+    let total = 0;
+    for (let i = 0; i < iovsLen; i++) {
+      const ptr = view().getUint32(iovsPtr + i * 8, true);
+      const len = view().getUint32(iovsPtr + i * 8 + 4, true);
+      const chunk = copyBytes(ptr, len);
+      total += len;
+      if (fd === 1 || fd === 2) {
+        writeStdio(fd, chunk);
+      } else if (file && file.kind === "file") {
+        const next = new Uint8Array(Math.max(file.data.length, file.pos + len));
+        next.set(file.data);
+        next.set(chunk, file.pos);
+        file.data = next;
+        file.pos += len;
+        files.set(file.name, next);
+      }
+    }
+    view().setUint32(nwrittenPtr, total, true);
+    return 0;
+  },
+  fd_pwrite(fd, iovsPtr, iovsLen, offset, nwrittenPtr) {
+    const file = fds.get(fd);
+    if (!file || file.kind !== "file") return errno(8);
+    const oldPos = file.pos;
+    file.pos = Number(offset);
+    const result = WASI.fd_write(fd, iovsPtr, iovsLen, nwrittenPtr);
+    file.pos = oldPos;
+    return result;
+  },
+  fd_seek(fd, offset, whence, newOffsetPtr) {
+    const file = fds.get(fd);
+    if (!file || !file.data) return errno(8);
+    const base = whence === 0 ? 0 : whence === 1 ? file.pos : file.data.length;
+    file.pos = Math.max(0, base + Number(offset));
+    view().setBigUint64(newOffsetPtr, BigInt(file.pos), true);
+    return 0;
+  },
+};
+
+function normalizePath(path) {
+  while (path.startsWith("/")) path = path.slice(1);
+  const parts = [];
+  for (const part of path.split("/")) {
+    if (!part || part === ".") continue;
+    if (part === "..") parts.pop();
+    else parts.push(part);
+  }
+  return parts.join("/") || ".";
+}
+
+function resolvePath(fd, path) {
+  const base = fds.get(fd);
+  if (!base || base.kind !== "dir") return null;
+  if (path.startsWith("/")) return normalizePath(path);
+  const prefix = normalizePath(base.path || ".");
+  return normalizePath(prefix === "." ? path : `${prefix}/${path}`);
+}
+
+function directoryEntries(path) {
+  const dir = normalizePath(path);
+  const byName = new Map();
+  const addChild = (fullPath, type) => {
+    const normalized = normalizePath(fullPath);
+    if (normalized === dir) return;
+    const prefix = dir === "." ? "" : `${dir}/`;
+    if (prefix && !normalized.startsWith(prefix)) return;
+    const rest = prefix ? normalized.slice(prefix.length) : normalized;
+    if (!rest || rest.includes("/")) return;
+    byName.set(rest, { name: rest, type });
+  };
+
+  for (const child of dirs) addChild(child, 3);
+  for (const child of files.keys()) addChild(child, 4);
+  return Array.from(byName.values()).sort((a, b) =>
+    a.name.localeCompare(b.name),
+  );
+}
+
+function writeStdio(fd, chunk) {
+  let text = (stdioBuffers.get(fd) || "") + textDecoder.decode(chunk);
+  const lines = text.split(/\r?\n/);
+  stdioBuffers.set(fd, lines.pop() || "");
+  const write = fd === 2 ? console.error : console.log;
+  for (const line of lines) {
+    if (line.length > 0) write(line);
+  }
+}
+
+function compileShader(type, source) {
+  const shader = gl.createShader(type);
+  gl.shaderSource(shader, normalizeSlangGlsl(source));
+  gl.compileShader(shader);
+  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+    throw new Error(gl.getShaderInfoLog(shader));
+  }
+  return shader;
+}
+
+function normalizeSlangGlsl(source) {
+  return source;
+}
+
+function setMat4Bytes(target, byteOffset, ptr) {
+  new Float32Array(target.buffer, byteOffset, 16).set(f32Copy(ptr, 16));
+}
+
+function uploadCameraUbo() {
+  gl.bindBuffer(gl.UNIFORM_BUFFER, cameraBuffer);
+  gl.bufferSubData(gl.UNIFORM_BUFFER, 0, cameraBytes);
+}
+
+function uploadPerObjectUbo(modelPtr) {
+  setMat4Bytes(perObjectBytes, 0, modelPtr);
+  gl.bindBuffer(gl.UNIFORM_BUFFER, perObjectBuffer);
+  gl.bufferSubData(gl.UNIFORM_BUFFER, 0, perObjectBytes);
+}
+
+function initUniformBlocks() {
+  cameraBuffer = gl.createBuffer();
+  perObjectBuffer = gl.createBuffer();
+
+  gl.bindBuffer(gl.UNIFORM_BUFFER, cameraBuffer);
+  gl.bufferData(gl.UNIFORM_BUFFER, cameraBytes, gl.DYNAMIC_DRAW);
+  gl.bindBufferBase(gl.UNIFORM_BUFFER, 0, cameraBuffer);
+
+  gl.bindBuffer(gl.UNIFORM_BUFFER, perObjectBuffer);
+  gl.bufferData(gl.UNIFORM_BUFFER, perObjectBytes, gl.DYNAMIC_DRAW);
+  gl.bindBufferBase(gl.UNIFORM_BUFFER, 1, perObjectBuffer);
+
+  const cameraBlock = gl.getUniformBlockIndex(program, "block_CameraState_0");
+  if (cameraBlock !== gl.INVALID_INDEX)
+    gl.uniformBlockBinding(program, cameraBlock, 0);
+  const perObjectBlock = gl.getUniformBlockIndex(program, "block_PerObject_0");
+  if (perObjectBlock !== gl.INVALID_INDEX)
+    gl.uniformBlockBinding(program, perObjectBlock, 1);
+
+  new Float32Array(cameraBytes.buffer, 0, 16).set([
+    1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1,
+  ]);
+  new Float32Array(cameraBytes.buffer, 64, 16).set([
+    1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1,
+  ]);
+  cameraData.setUint32(156, 1, true);
+  uploadCameraUbo();
+}
+
+const host = {
+  aether_input_apply_cursor_mode(mode) {
+    requestedCursorMode = mode;
+    if (mode === CURSOR_CAPTURED) {
+      canvas.style.cursor = "none";
+    } else {
+      if (document.pointerLockElement === canvas) {
+        suppressNextPointerUnlock = true;
+        document.exitPointerLock();
+      }
+      canvas.style.cursor = mode === CURSOR_HIDDEN ? "none" : "";
+    }
+  },
+  aether_canvas_width() {
+    return canvas.width;
+  },
+  aether_canvas_height() {
+    return canvas.height;
+  },
+  aether_surface_init(width, height, titlePtr, titleLen) {
+    document.title = str(titlePtr, titleLen);
+    resizeCanvas(width, height);
+    canvas.focus();
+  },
+  aether_surface_present() {},
+  aether_webgl_init(vp, vl, fp, fl) {
+    gl = canvas.getContext("webgl2", { alpha: false, antialias: false });
+    if (!gl) return false;
+    const vs = compileShader(gl.VERTEX_SHADER, str(vp, vl));
+    const fs = compileShader(gl.FRAGMENT_SHADER, str(fp, fl));
+    program = gl.createProgram();
+    gl.attachShader(program, vs);
+    gl.attachShader(program, fs);
+    gl.linkProgram(program);
+    if (!gl.getProgramParameter(program, gl.LINK_STATUS))
+      throw new Error(gl.getProgramInfoLog(program));
+    gl.useProgram(program);
+    initUniformBlocks();
+    const sampler = gl.getUniformLocation(program, "u_combinedTexture_0");
+    if (sampler) gl.uniform1i(sampler, 0);
+    gl.enable(gl.DEPTH_TEST);
+    gl.enable(gl.CULL_FACE);
+    gl.frontFace(gl.CCW);
+    gl.cullFace(gl.BACK);
+    gl.enable(gl.BLEND);
+    gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
+    return true;
+  },
+  aether_webgl_deinit() {
+    if (cameraBuffer) gl.deleteBuffer(cameraBuffer);
+    if (perObjectBuffer) gl.deleteBuffer(perObjectBuffer);
+    cameraBuffer = null;
+    perObjectBuffer = null;
+  },
+  aether_webgl_set_clear_color(r, g, b, a) {
+    gl.clearColor(r, g, b, a);
+  },
+  aether_webgl_set_alpha_blend(enabled) {
+    enabled ? gl.enable(gl.BLEND) : gl.disable(gl.BLEND);
+    cameraData.setUint32(156, enabled ? 1 : 0, true);
+    uploadCameraUbo();
+  },
+  aether_webgl_set_depth_write(enabled) {
+    gl.depthMask(enabled);
+  },
+  aether_webgl_set_culling(enabled) {
+    enabled ? gl.enable(gl.CULL_FACE) : gl.disable(gl.CULL_FACE);
+  },
+  aether_webgl_set_uv_offset(u, v) {
+    cameraData.setFloat32(160, u, true);
+    cameraData.setFloat32(164, v, true);
+    uploadCameraUbo();
+  },
+  aether_webgl_set_fog(enabled, start, end, r, g, b) {
+    cameraData.setUint32(128, enabled ? 1 : 0, true);
+    cameraData.setFloat32(132, start, true);
+    cameraData.setFloat32(136, end, true);
+    cameraData.setFloat32(144, r, true);
+    cameraData.setFloat32(148, g, true);
+    cameraData.setFloat32(152, b, true);
+    uploadCameraUbo();
+  },
+  aether_webgl_set_proj_matrix(ptr) {
+    setMat4Bytes(cameraBytes, 64, ptr);
+    uploadCameraUbo();
+  },
+  aether_webgl_set_view_matrix(ptr) {
+    setMat4Bytes(cameraBytes, 0, ptr);
+    uploadCameraUbo();
+  },
+  aether_webgl_start_frame(width, height) {
+    gl.viewport(0, 0, width, height);
+    gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
+    return true;
+  },
+  aether_webgl_end_frame() {},
+  aether_webgl_clear_depth() {
+    gl.clear(gl.DEPTH_BUFFER_BIT);
+  },
+  aether_webgl_create_mesh() {
+    const handle = nextMeshHandle++;
+    const buffer = gl.createBuffer();
+    const vao = gl.createVertexArray();
+    gl.bindVertexArray(vao);
+    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+    gl.enableVertexAttribArray(0);
+    gl.enableVertexAttribArray(1);
+    gl.enableVertexAttribArray(2);
+    gl.vertexAttribPointer(0, 3, gl.SHORT, true, 16, 0);
+    gl.vertexAttribPointer(1, 4, gl.UNSIGNED_BYTE, true, 16, 8);
+    gl.vertexAttribPointer(2, 2, gl.SHORT, true, 16, 12);
+    gl.bindVertexArray(null);
+    meshes.set(handle, { buffer, vao });
+    return handle;
+  },
+  aether_webgl_destroy_mesh(handle) {
+    const mesh = meshes.get(handle);
+    if (!mesh) return;
+    gl.deleteVertexArray(mesh.vao);
+    gl.deleteBuffer(mesh.buffer);
+    meshes.delete(handle);
+  },
+  aether_webgl_update_mesh(handle, ptr, len) {
+    const mesh = meshes.get(handle);
+    if (!mesh) return;
+    gl.bindBuffer(gl.ARRAY_BUFFER, mesh.buffer);
+    gl.bufferData(gl.ARRAY_BUFFER, copyBytes(ptr, len), gl.STATIC_DRAW);
+  },
+  aether_webgl_draw_mesh(handle, modelPtr, count) {
+    const mesh = meshes.get(handle);
+    if (!mesh) return;
+    gl.useProgram(program);
+    uploadPerObjectUbo(modelPtr);
+    gl.bindVertexArray(mesh.vao);
+    if (currentTexture) gl.bindTexture(gl.TEXTURE_2D, currentTexture);
+    gl.drawArrays(gl.TRIANGLES, 0, count);
+  },
+  aether_webgl_create_texture(width, height, ptr, len) {
+    const handle = nextTextureHandle++;
+    const tex = gl.createTexture();
+    textures.set(handle, { tex, width, height });
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT);
+    gl.texImage2D(
+      gl.TEXTURE_2D,
+      0,
+      gl.RGBA,
+      width,
+      height,
+      0,
+      gl.RGBA,
+      gl.UNSIGNED_BYTE,
+      copyBytes(ptr, len),
+    );
+    return handle;
+  },
+  aether_webgl_update_texture(handle, ptr, len) {
+    const texture = textures.get(handle);
+    if (!texture) return;
+    gl.bindTexture(gl.TEXTURE_2D, texture.tex);
+    gl.texSubImage2D(
+      gl.TEXTURE_2D,
+      0,
+      0,
+      0,
+      texture.width,
+      texture.height,
+      gl.RGBA,
+      gl.UNSIGNED_BYTE,
+      copyBytes(ptr, len),
+    );
+  },
+  aether_webgl_bind_texture(handle) {
+    const texture = textures.get(handle);
+    currentTexture = texture ? texture.tex : null;
+    gl.activeTexture(gl.TEXTURE0);
+    gl.bindTexture(gl.TEXTURE_2D, currentTexture);
+  },
+  aether_webgl_destroy_texture(handle) {
+    const texture = textures.get(handle);
+    if (texture) gl.deleteTexture(texture.tex);
+    textures.delete(handle);
+  },
+  aether_audio_init(sampleRate, maxSlots) {
+    audioSampleRate = sampleRate;
+    audioMaxSlots = maxSlots;
+  },
+  aether_audio_deinit() {
+    for (const slot of audioSlots.keys()) host.aether_audio_stop_slot(slot);
+    if (audioContext) audioContext.close();
+    audioContext = null;
+    gainRoot = null;
+  },
+  aether_audio_update() {},
+  aether_audio_play_slot(slot, ptr, len, sampleRate, channels, bitDepth) {
+    if (
+      slot >= audioMaxSlots ||
+      bitDepth !== 16 ||
+      channels < 1 ||
+      channels > 2
+    )
+      return false;
+    host.aether_audio_stop_slot(slot);
+    const rawBytes = copyBytes(ptr, len);
+    const state = {
+      rawBytes,
+      sampleRate: sampleRate || audioSampleRate,
+      channels,
+      bitDepth,
+      source: null,
+      gain: null,
+      pan: null,
+      gainValue: 1.0,
+      panValue: 0.0,
+      active: true,
+      started: false,
+    };
+    audioSlots.set(slot, state);
+    if (audioContext && audioContext.state === "running")
+      startAudioSlot(slot, state);
+    return true;
+  },
+  aether_audio_stop_slot(slot) {
+    const s = audioSlots.get(slot);
+    if (s) {
+      s.active = false;
+      if (s.source) tryStop(s.source);
+      audioSlots.delete(slot);
+    }
+  },
+  aether_audio_set_slot_gain_pan(slot, gain, pan) {
+    const s = audioSlots.get(slot);
+    if (!s) return;
+    s.gainValue = gain;
+    s.panValue = pan;
+    if (s.gain) s.gain.gain.value = gain;
+    if (s.pan) s.pan.pan.value = pan;
+  },
+  aether_audio_is_slot_active(slot) {
+    const s = audioSlots.get(slot);
+    return !!s && s.active;
+  },
+};
+
+function tryStop(source) {
+  if (source)
+    try {
+      source.stop();
+    } catch {}
+}
+
+function ensureAudioContext() {
+  if (audioContext) return true;
+  const AudioCtx = window.AudioContext || window.webkitAudioContext;
+  if (!AudioCtx) return false;
+  audioContext = new AudioCtx({ sampleRate: audioSampleRate });
+  gainRoot = audioContext.createGain();
+  gainRoot.connect(audioContext.destination);
+  return true;
+}
+
+function startAudioSlot(slot, state) {
+  if (!audioContext || !state.active || state.started) return;
+
+  const raw = new Int16Array(
+    state.rawBytes.buffer,
+    state.rawBytes.byteOffset,
+    Math.floor(state.rawBytes.byteLength / 2),
+  );
+  const frames = Math.floor(raw.length / state.channels);
+  const buffer = audioContext.createBuffer(
+    state.channels,
+    frames,
+    state.sampleRate,
+  );
+  for (let ch = 0; ch < state.channels; ch++) {
+    const out = buffer.getChannelData(ch);
+    for (let i = 0; i < frames; i++)
+      out[i] = raw[i * state.channels + ch] / 32768;
+  }
+
+  const source = audioContext.createBufferSource();
+  const gain = audioContext.createGain();
+  const pan = audioContext.createStereoPanner();
+  gain.gain.value = state.gainValue;
+  pan.pan.value = state.panValue;
+  source.buffer = buffer;
+  source.connect(gain).connect(pan).connect(gainRoot);
+  state.source = source;
+  state.gain = gain;
+  state.pan = pan;
+  state.started = true;
+  source.onended = () => {
+    const current = audioSlots.get(slot);
+    if (current === state) current.active = false;
+  };
+  try {
+    source.start();
+  } catch {}
+}
+
+function startQueuedAudio() {
+  for (const [slot, state] of audioSlots) startAudioSlot(slot, state);
+}
+
+function resizeCanvas(defaultWidth = 1280, defaultHeight = 720) {
+  const dpr = window.devicePixelRatio || 1;
+  const w = Math.max(1, Math.floor((canvas.clientWidth || defaultWidth) * dpr));
+  const h = Math.max(
+    1,
+    Math.floor((canvas.clientHeight || defaultHeight) * dpr),
+  );
+  if (canvas.width !== w || canvas.height !== h) {
+    canvas.width = w;
+    canvas.height = h;
+  }
+}
+
+function mods(e) {
+  return (
+    (e.shiftKey ? 1 : 0) |
+    (e.ctrlKey ? 2 : 0) |
+    (e.altKey ? 4 : 0) |
+    (e.metaKey ? 8 : 0)
+  );
+}
+
+function mouseButtonCode(button) {
+  switch (button) {
+    case 0:
+      return 0; // DOM left -> Aether Left
+    case 2:
+      return 1; // DOM right -> Aether Right
+    case 1:
+      return 2; // DOM middle -> Aether Middle
+    default:
+      return -1;
+  }
+}
+
+function cancelMouseDefault(e) {
+  e.preventDefault();
+  e.stopPropagation();
+}
+
+const keyMap = {
+  Space: 32,
+  Quote: 39,
+  Comma: 44,
+  Minus: 45,
+  Period: 46,
+  Slash: 47,
+  Semicolon: 59,
+  Equal: 61,
+  BracketLeft: 91,
+  Backslash: 92,
+  BracketRight: 93,
+  Backquote: 96,
+  Escape: 256,
+  Enter: 257,
+  Tab: 258,
+  Backspace: 259,
+  Insert: 260,
+  Delete: 261,
+  ArrowRight: 262,
+  ArrowLeft: 263,
+  ArrowDown: 264,
+  ArrowUp: 265,
+  PageUp: 266,
+  PageDown: 267,
+  Home: 268,
+  End: 269,
+  CapsLock: 280,
+  ScrollLock: 281,
+  NumLock: 282,
+  PrintScreen: 283,
+  Pause: 284,
+  F1: 290,
+  F2: 291,
+  F3: 292,
+  F4: 293,
+  F5: 294,
+  F6: 295,
+  F7: 296,
+  F8: 297,
+  F9: 298,
+  F10: 299,
+  F11: 300,
+  F12: 301,
+  Numpad0: 320,
+  Numpad1: 321,
+  Numpad2: 322,
+  Numpad3: 323,
+  Numpad4: 324,
+  Numpad5: 325,
+  Numpad6: 326,
+  Numpad7: 327,
+  Numpad8: 328,
+  Numpad9: 329,
+  NumpadDecimal: 330,
+  NumpadDivide: 331,
+  NumpadMultiply: 332,
+  NumpadSubtract: 333,
+  NumpadAdd: 334,
+  NumpadEnter: 335,
+  NumpadEqual: 336,
+  ShiftLeft: 340,
+  ControlLeft: 341,
+  AltLeft: 342,
+  MetaLeft: 343,
+  ShiftRight: 344,
+  ControlRight: 345,
+  AltRight: 346,
+  MetaRight: 347,
+  ContextMenu: 348,
+};
+for (let i = 0; i <= 9; i++) keyMap[`Digit${i}`] = 48 + i;
+for (let i = 0; i < 26; i++)
+  keyMap[`Key${String.fromCharCode(65 + i)}`] = 65 + i;
+
+function installInput() {
+  const sendText = (text) => {
+    const data = textEncoder.encode(text);
+    const ptr = instance.exports.aether_wasm_alloc(data.length);
+    if (!ptr) return;
+    bytes().set(data, ptr);
+    instance.exports.aether_input_text(ptr, data.length);
+    instance.exports.aether_wasm_free(ptr, data.length);
+  };
+  canvas.addEventListener("keydown", (e) => {
+    if (!e.ctrlKey && !e.altKey && !e.metaKey && e.key && e.key.length === 1) {
+      sendText(e.key);
+    }
+    const key = keyMap[e.code];
+    if (key !== undefined) {
+      instance.exports.aether_input_key(key, true, e.repeat, mods(e));
+      e.preventDefault();
+    }
+  });
+  canvas.addEventListener("keyup", (e) => {
+    const key = keyMap[e.code];
+    if (key !== undefined) {
+      instance.exports.aether_input_key(key, false, false, mods(e));
+      e.preventDefault();
+    }
+  });
+  const canvasPoint = (e) => {
+    if (document.pointerLockElement === canvas) {
+      return { x: canvas.width * 0.5, y: canvas.height * 0.5 };
+    }
+    const r = canvas.getBoundingClientRect();
+    const sx = canvas.width / r.width;
+    const sy = canvas.height / r.height;
+    return { x: (e.clientX - r.left) * sx, y: (e.clientY - r.top) * sy };
+  };
+  canvas.addEventListener("pointermove", (e) => {
+    const p = canvasPoint(e);
+    if (ignorePointerMoveCount > 0) {
+      ignorePointerMoveCount--;
+      instance.exports.aether_input_mouse_move(p.x, p.y, 0, 0);
+    } else {
+      instance.exports.aether_input_mouse_move(
+        p.x,
+        p.y,
+        e.movementX,
+        e.movementY,
+      );
+    }
+  });
+  canvas.addEventListener("pointerdown", (e) => {
+    cancelMouseDefault(e);
+    canvas.focus();
+    if (
+      requestedCursorMode === CURSOR_CAPTURED &&
+      document.pointerLockElement !== canvas
+    ) {
+      canvas.requestPointerLock();
+    }
+    const button = mouseButtonCode(e.button);
+    if (button < 0) return;
+    const p = canvasPoint(e);
+    instance.exports.aether_input_mouse_move(p.x, p.y, 0, 0);
+    instance.exports.aether_input_mouse_button(button, true, p.x, p.y);
+  });
+  canvas.addEventListener("pointerup", (e) => {
+    cancelMouseDefault(e);
+    const button = mouseButtonCode(e.button);
+    if (button < 0) return;
+    const p = canvasPoint(e);
+    instance.exports.aether_input_mouse_move(p.x, p.y, 0, 0);
+    instance.exports.aether_input_mouse_button(button, false, p.x, p.y);
+  });
+  canvas.addEventListener("auxclick", cancelMouseDefault);
+  canvas.addEventListener("contextmenu", cancelMouseDefault);
+  canvas.addEventListener(
+    "wheel",
+    (e) => {
+      instance.exports.aether_input_mouse_wheel(e.deltaX, -e.deltaY);
+      e.preventDefault();
+    },
+    { passive: false },
+  );
+  window.addEventListener("focus", () =>
+    instance.exports.aether_input_focus(true),
+  );
+  window.addEventListener("blur", () =>
+    instance.exports.aether_input_focus(false),
+  );
+  document.addEventListener("pointerlockchange", () => {
+    const wasLocked = pointerLocked;
+    pointerLocked = document.pointerLockElement === canvas;
+    ignorePointerMoveCount = 2;
+    if (
+      wasLocked &&
+      !pointerLocked &&
+      requestedCursorMode === CURSOR_CAPTURED
+    ) {
+      if (suppressNextPointerUnlock) {
+        suppressNextPointerUnlock = false;
+      } else {
+        instance.exports.aether_input_key(KEY_ESCAPE, true, false, 0);
+        pendingSyntheticEscapeUp = true;
+      }
+    }
+    canvas.style.cursor =
+      pointerLocked || requestedCursorMode === CURSOR_HIDDEN ? "none" : "";
+  });
+}
+
+function pollGamepads() {
+  const pads = navigator.getGamepads ? navigator.getGamepads() : [];
+  const pad = pads && pads[0];
+  if (pad) {
+    pad.buttons
+      .slice(0, 15)
+      .forEach((b, i) =>
+        instance.exports.aether_input_gamepad_button(i, b.pressed),
+      );
+    const axes = [
+      pad.axes[0] || 0,
+      pad.axes[1] || 0,
+      pad.axes[2] || 0,
+      pad.axes[3] || 0,
+      pad.buttons[6]?.value || 0,
+      pad.buttons[7]?.value || 0,
+    ];
+    axes.forEach((v, i) => instance.exports.aether_input_gamepad_axis(i, v));
+  }
+}
+
+async function main() {
+  try {
+    resizeCanvas();
+    await preloadResourceDirectory();
+    const wasm = await WebAssembly.instantiateStreaming(
+      fetch("./Aether.wasm"),
+      {
+        wasi_snapshot_preview1: WASI,
+        aether_host: host,
+      },
+    );
+    instance = wasm.instance;
+    memory = instance.exports.memory;
+    installInput();
+    if (!instance.exports.aether_wasm_init(canvas.width, canvas.height))
+      throw new Error("Aether init failed");
+    setStatus("Running");
+    const frame = () => {
+      resizeCanvas();
+      pollGamepads();
+      const keepRunning = instance.exports.aether_wasm_frame();
+      if (pendingSyntheticEscapeUp) {
+        instance.exports.aether_input_key(KEY_ESCAPE, false, false, 0);
+        pendingSyntheticEscapeUp = false;
+      }
+      if (keepRunning) requestAnimationFrame(frame);
+      else setStatus("Stopped");
+    };
+    requestAnimationFrame(frame);
+    window.addEventListener("resize", () => resizeCanvas());
+    const resumeAudio = async () => {
+      if (!ensureAudioContext()) return;
+      await audioContext.resume();
+      startQueuedAudio();
+    };
+    window.addEventListener("pointerdown", resumeAudio, { once: true });
+    window.addEventListener("keydown", resumeAudio, { once: true });
+  } catch (err) {
+    console.error(err);
+    setStatus(`Error: ${err.message}`);
+  }
+}
+
+main();
diff --git a/web/index.html b/web/index.html
new file mode 100644
index 0000000..96d5996
--- /dev/null
+++ b/web/index.html
@@ -0,0 +1,40 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Aether Web</title>
+  <style>
+    html, body {
+      margin: 0;
+      width: 100%;
+      height: 100%;
+      overflow: hidden;
+      background: #111318;
+      color: #e8edf2;
+      font-family: system-ui, sans-serif;
+    }
+    canvas {
+      display: block;
+      width: 100vw;
+      height: 100vh;
+      outline: none;
+      touch-action: none;
+    }
+    #status {
+      position: fixed;
+      left: 12px;
+      bottom: 10px;
+      padding: 6px 8px;
+      border-radius: 4px;
+      background: rgba(10, 12, 16, 0.72);
+      font-size: 13px;
+    }
+  </style>
+</head>
+<body>
+  <canvas id="aether" tabindex="0"></canvas>
+  <div id="status">Loading</div>
+  <script type="module" src="./aether.js"></script>
+</body>
+</html>