add parallel_rdp

CONTRIBUTING.md

···
 - Write unit tests for all public functions containing business logic, data transformations, or state management. They go in a `#[cfg(test)] mod tests` at the bottom of each file. GUI/rendering code does not require unit tests.
 - Write integration tests using `egui_kittest` for GUI code. Binary crates (like `kammy`) cannot use the `tests/` directory at the crate root because there is no library target to import. Instead, use a `src/tests.rs` module gated behind `#[cfg(test)]`, with submodules in `src/tests/` organized by feature (e.g. `src/tests/undo.rs`). Shared test utilities go in `src/tests.rs`. Library crates should use the standard `tests/` directory at the crate root.
 - Prefer module-level inner doc comments (`//!`) at the top of a file over outer doc comments (`///`) on the `mod` declaration. This keeps the documentation next to the code it describes.
+- Avoid just `#[expect]` or `#[allow]`ing lines. The checks are there for a reason. For example, `as` should usually be `.into()`.
 
 ## Error handling
 
···
 - Use `anyhow` to attach context to errors as they bubble up the stack.
 - Never ignore an error: either pass it on, or log it.
 - If a problem is recoverable, use `ka_log::warn!` and recover.
+- UI code should never panic. Do not use `#[expect(clippy::expect_used)]` etc. in UI code - warn and have a fallback.
 
 Strive to encode code invariants and contracts in the type system as much as possible. [Parse, don't validate.](https://lexi-lambda.github.io/blog/2019/11/05/parse-don-t-validate/) If you can't enforce a contract in the type system, enforce them using `assert` and in documentation (if its part of a public API).
 

Cargo.lock

···
 checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
 [[package]]
+name = "bindgen"
+version = "0.72.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895"
+dependencies = [
+ "bitflags 2.11.0",
+ "cexpr",
+ "clang-sys",
+ "itertools 0.12.1",
+ "log",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash 2.1.1",
+ "shlex",
+ "syn 2.0.117",
+]
+
+[[package]]
 name = "bit-set"
 version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c"
 
 [[package]]
+name = "cexpr"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
+dependencies = [
+ "nom",
+]
+
+[[package]]
 name = "cfg-if"
 version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
 
 [[package]]
-name = "cgl"
-version = "0.3.2"
+name = "clang-sys"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ced0551234e87afee12411d535648dd89d2e7f34c78b753395567aff3d447ff"
+checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
 dependencies = [
+ "glob",
  "libc",
+ "libloading",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
-name = "eframe"
-version = "0.33.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "457481173e6db5ca9fa2be93a58df8f4c7be639587aeb4853b526c6cf87db4e6"
-dependencies = [
- "ahash",
- "bytemuck",
- "document-features",
- "egui",
- "egui-wgpu",
- "egui-winit",
- "egui_glow",
- "glow",
- "glutin",
- "glutin-winit",
- "image",
- "js-sys",
- "log",
- "objc2 0.5.2",
- "objc2-app-kit 0.2.2",
- "objc2-foundation 0.2.2",
- "parking_lot",
- "percent-encoding",
- "profiling",
- "raw-window-handle",
- "static_assertions",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-sys",
- "web-time",
- "windows-sys 0.61.2",
- "winit",
-]
-
-[[package]]
 name = "egui"
 version = "0.33.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "type-map",
  "web-time",
  "wgpu",
- "winit",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
-name = "egui_glow"
-version = "0.33.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6420863ea1d90e750f75075231a260030ad8a9f30a7cef82cdc966492dc4c4eb"
-dependencies = [
- "bytemuck",
- "egui",
- "glow",
- "log",
- "memoffset",
- "profiling",
- "wasm-bindgen",
- "web-sys",
- "winit",
-]
-
-[[package]]
 name = "egui_kittest"
 version = "0.33.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "43afb5f968dfa9e6c8f5e609ab9039e11a2c4af79a326f4cb1b99cf6875cb6a0"
 dependencies = [
- "eframe",
  "egui",
  "kittest",
 ]
···
 ]
 
 [[package]]
+name = "glob"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+
+[[package]]
 name = "glow"
 version = "0.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
-name = "glutin"
-version = "0.32.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12124de845cacfebedff80e877bb37b5b75c34c5a4c89e47e1cdd67fb6041325"
-dependencies = [
- "bitflags 2.11.0",
- "cfg_aliases",
- "cgl",
- "dispatch2",
- "glutin_egl_sys",
- "glutin_glx_sys",
- "glutin_wgl_sys",
- "libloading",
- "objc2 0.6.3",
- "objc2-app-kit 0.3.2",
- "objc2-core-foundation",
- "objc2-foundation 0.3.2",
- "once_cell",
- "raw-window-handle",
- "wayland-sys",
- "windows-sys 0.52.0",
- "x11-dl",
-]
-
-[[package]]
-name = "glutin-winit"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85edca7075f8fc728f28cb8fbb111a96c3b89e930574369e3e9c27eb75d3788f"
-dependencies = [
- "cfg_aliases",
- "glutin",
- "raw-window-handle",
- "winit",
-]
-
-[[package]]
-name = "glutin_egl_sys"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c4680ba6195f424febdc3ba46e7a42a0e58743f2edb115297b86d7f8ecc02d2"
-dependencies = [
- "gl_generator",
- "windows-sys 0.52.0",
-]
-
-[[package]]
-name = "glutin_glx_sys"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a7bb2938045a88b612499fbcba375a77198e01306f52272e692f8c1f3751185"
-dependencies = [
- "gl_generator",
- "x11-dl",
-]
-
-[[package]]
 name = "glutin_wgl_sys"
 version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 name = "kammy"
 version = "0.1.0"
 dependencies = [
+ "anyhow",
+ "ash",
  "dioxus-devtools",
- "eframe",
+ "egui",
  "egui-phosphor",
+ "egui-wgpu",
+ "egui-winit",
  "egui_kittest",
  "egui_tiles",
  "loro",
  "loroscope",
+ "parallel_rdp",
+ "raw-window-handle",
  "subsecond",
  "tracing",
  "tracing-subscriber",
+ "wgpu",
+ "winit",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
+[[package]]
 name = "miniz_oxide"
 version = "0.8.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451"
 
 [[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
 name = "nonmax"
 version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "bitflags 2.11.0",
  "objc2 0.6.3",
- "objc2-core-foundation",
  "objc2-core-graphics",
  "objc2-foundation 0.3.2",
 ]
···
 ]
 
 [[package]]
+name = "parallel_rdp"
+version = "0.1.0"
+dependencies = [
+ "ash",
+ "bindgen",
+ "cc",
+ "thiserror 2.0.18",
+ "tracing",
+]
+
+[[package]]
 name = "parking"
 version = "2.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "prettyplease"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.117",
+]
+
+[[package]]
 name = "proc-macro-crate"
 version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "35985aa610addc02e24fc232012c86fd11f14111180f902b67e2d5331f8ebf2b"
 dependencies = [
  "bitflags 2.11.0",
+]
+
+[[package]]
+name = "regex"
+version = "1.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "zbus"
-version = "5.13.2"
+version = "5.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bfeff997a0aaa3eb20c4652baf788d2dfa6d2839a0ead0b3ff69ce2f9c4bdd1"
+checksum = "ca82f95dbd3943a40a53cfded6c2d0a2ca26192011846a1810c4256ef92c60bc"
 dependencies = [
  "async-broadcast",
  "async-executor",
···
 
 [[package]]
 name = "zbus_macros"
-version = "5.13.2"
+version = "5.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0bbd5a90dbe8feee5b13def448427ae314ccd26a49cac47905cafefb9ff846f1"
+checksum = "897e79616e84aac4b2c46e9132a4f63b93105d54fe8c0e8f6bffc21fa8d49222"
 dependencies = [
  "proc-macro-crate",
  "proc-macro2",
···
 
 [[package]]
 name = "zvariant"
-version = "5.9.2"
+version = "5.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68b64ef4f40c7951337ddc7023dd03528a57a3ce3408ee9da5e948bd29b232c4"
+checksum = "5708299b21903bbe348e94729f22c49c55d04720a004aa350f1f9c122fd2540b"
 dependencies = [
  "endi",
  "enumflags2",
···
 
 [[package]]
 name = "zvariant_derive"
-version = "5.9.2"
+version = "5.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "484d5d975eb7afb52cc6b929c13d3719a20ad650fea4120e6310de3fc55e415c"
+checksum = "5b59b012ebe9c46656f9cc08d8da8b4c726510aef12559da3e5f1bf72780752c"
 dependencies = [
  "proc-macro-crate",
  "proc-macro2",

Cargo.toml

···
 
 [workspace.dependencies]
 loro = { version = "1.10", features = ["counter"] }
-eframe = { version = "0.33", features = ["accesskit"] }
+winit = "0.30"
+egui = "0.33"
+egui-winit = { version = "0.33", features = ["accesskit"] }
+egui-wgpu = "0.33"
+wgpu = { version = "27", features = ["vulkan"] }
 egui_tiles = "0.14"
 egui-phosphor = { version = "0.11", default-features = false, features = ["regular"] }
-egui_kittest = { version = "0.33", features = ["eframe"] }
+egui_kittest = "0.33"
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 subsecond = "0.7"
 dioxus-devtools = "0.7"
+ash = "0.38"
+raw-window-handle = "0.6"
+thiserror = "2"
+anyhow = "1"
 
 [workspace.lints.rust]
 missing_debug_implementations = "warn"
···
 wildcard_imports = "deny"
 mod_module_files = "deny"
 multiple_crate_versions = "allow" # Noisy with transitive deps
+single_component_path_imports = "deny"
 
 # nursery
 use_self = "deny"

crates/kammy/Cargo.toml

···
 edition = "2024"
 
 [dependencies]
+parallel_rdp = { path = "../parallel_rdp" }
 loroscope = { path = "../loroscope" }
 loro = { workspace = true }
-eframe = { workspace = true }
+winit = { workspace = true }
+egui = { workspace = true }
+egui-winit = { workspace = true }
+egui-wgpu = { workspace = true }
+wgpu = { workspace = true }
+ash = { workspace = true }
+raw-window-handle = { workspace = true }
 egui-phosphor = { workspace = true }
 egui_tiles = { workspace = true }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 subsecond = { workspace = true }
 dioxus-devtools = { workspace = true }
+anyhow = { workspace = true }
 
 [dev-dependencies]
 egui_kittest = { workspace = true }

crates/kammy/src/app.rs

···
 use std::cell::Cell;
 use std::collections::HashMap;
 
-use eframe::egui;
-
 use crate::Project;
 use crate::dock::{Dock, DockPosition};
+use crate::editor::display_list::DisplayListEditor;
 use crate::editor::todo::TodoEditor;
 use crate::editor::{Editor, EditorId, Inspect, TileBehavior, UndoBehavior};
+use crate::gpu::GpuState;
 use crate::tool::ToolContext;
 use crate::tool::assets::AssetsTool;
 use crate::tool::hierarchy::HierarchyTool;
···
         }
     }
 
-    /// Returns the tile ID of an `Own` pane that is not the currently active
-    /// one, or `None` if no other document pane exists.
-    #[cfg(test)]
-    pub fn find_other_pane(&self) -> Option<egui_tiles::TileId> {
-        self.tree.tiles.iter().find_map(|(id, tile)| {
-            if let egui_tiles::Tile::Pane(editor) = tile {
-                (Some(*id) != self.active_document
-                    && matches!(
-                        self.undo_behaviors.get(&editor.id()),
-                        Some(UndoBehavior::Own { .. })
-                    ))
-                .then_some(*id)
-            } else {
-                None
-            }
-        })
-    }
-
     /// Finds the tabs container that directly holds the given tile ID.
     fn find_parent_tabs(&self, tile_id: egui_tiles::TileId) -> Option<egui_tiles::TileId> {
         self.tree.tiles.iter().find_map(|(id, tile)| {
···
         })
     }
 
-    /// Switches focus to the pane with the given tile ID. Updates both the
-    /// internal active-document tracking and the editor tabs' visible tab.
-    #[cfg(test)]
-    pub fn switch_to_pane(&mut self, tile_id: egui_tiles::TileId) {
-        self.active_document = Some(tile_id);
-        if let Some(egui_tiles::Tile::Pane(editor)) = self.tree.tiles.get(tile_id) {
-            self.active_editor_id = Some(editor.id());
-        }
-        if let Some(parent_id) = self.find_parent_tabs(tile_id)
-            && let Some(egui_tiles::Tile::Container(egui_tiles::Container::Tabs(tabs))) =
-                self.tree.tiles.get_mut(parent_id)
-        {
-            tabs.set_active(tile_id);
-        }
-    }
-
-    fn add_editor(&mut self) {
+    /// Inserts a new editor into the tile tree with its own undo manager.
+    ///
+    /// If `setup_crdt` is provided, it is called after the editor ID is
+    /// allocated and before the undo manager is created. Use this to
+    /// initialise CRDT data for editors that need it.
+    fn add_editor(
+        &mut self,
+        make_editor: impl FnOnce(EditorId) -> Box<dyn Editor>,
+        setup_crdt: Option<&dyn Fn(EditorId, &Project)>,
+    ) {
         let editor_id = self.alloc_editor_id();
 
-        // Insert editor into tree first to obtain the TileId
-        let pane_id = self.tree.tiles.insert_pane({
-            let editor: Box<dyn Editor> = Box::new(TodoEditor::new(editor_id));
-            editor
-        });
+        let pane_id = self.tree.tiles.insert_pane(make_editor(editor_id));
 
-        // Create CRDT data keyed by stable editor id
-        let key = editor_id.to_string();
-        let data = self.project.tabs().get_or_create(&key);
-        let _ = data.items();
-        self.project.doc().set_next_commit_origin("meta");
-        self.project.doc().commit();
+        if let Some(setup) = setup_crdt {
+            setup(editor_id, &self.project);
+        }
 
         // Create undo manager with mutual exclusion against all existing editors
         let origin = format!("e{}/", editor_id.0);
···
         }
     }
 
+    fn add_todo_editor(&mut self) {
+        self.add_editor(
+            |id| Box::new(TodoEditor::new(id)),
+            Some(&|id, project| {
+                let key = id.to_string();
+                let data = project.tabs().get_or_create(&key);
+                let _ = data.items();
+                project.doc().set_next_commit_origin("meta");
+                project.doc().commit();
+            }),
+        );
+    }
+
+    fn add_display_list_editor(&mut self) {
+        self.add_editor(|id| Box::new(DisplayListEditor::new(id)), None);
+    }
+
     /// Returns the [`EditorId`] for the active document, if any.
     fn active_editor_id(&self) -> Option<EditorId> {
         self.active_editor_id
···
 
                 ui.separator();
 
-                if ui.button("+ New Tab").clicked() {
-                    self.add_editor();
+                if ui.button("+ Todo").clicked() {
+                    self.add_todo_editor();
+                }
+                if ui.button("+ Display List").clicked() {
+                    self.add_display_list_editor();
                 }
             });
         });
···
         }
     }
 
-    fn content_ui(&mut self, ctx: &egui::Context) {
+    fn content_ui(&mut self, ctx: &egui::Context, gpu: Option<&mut GpuState>) {
         egui::CentralPanel::default().show(ctx, |ui| {
             // Snapshot each tabs container's children and active tab so we can
             // detect removals after tree.ui() and activate the left neighbor.
···
             let inspect_cell = Cell::new(self.inspect.take());
             let mut behavior = TileBehavior {
                 project: &self.project,
+                gpu,
                 undo_behaviors: &self.undo_behaviors,
                 active_document: &mut self.active_document,
                 active_editor_id: &mut self.active_editor_id,
···
     }
 }
 
-impl eframe::App for KammyApp {
-    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+impl KammyApp {
+    /// Main UI update, called each frame from the winit event loop.
+    ///
+    /// `gpu` is `None` only in headless test environments.
+    pub fn update(&mut self, ctx: &egui::Context, gpu: Option<&mut GpuState>) {
         self.handle_keyboard(ctx);
         subsecond::call(|| self.toolbar_ui(ctx));
         subsecond::call(|| self.status_bar_ui(ctx));
         subsecond::call(|| self.render_docks(ctx));
-        subsecond::call(|| self.content_ui(ctx));
+        // content_ui needs &mut GpuState which can't be moved into subsecond's FnMut
+        self.content_ui(ctx, gpu);
     }
 }

crates/kammy/src/dock.rs

···
 
 mod icon;
 
-use eframe::egui;
-
 use crate::tool::{Tool, ToolContext};
 use icon::DockIcon;
 
···
 mod tests {
     use super::*;
 
-    use eframe::egui;
+    use egui;
 
     #[derive(Debug)]
     struct DummyTool {

crates/kammy/src/dock/icon.rs

···
 
 //! A custom icon button for dock tools in the status bar.
 
-use eframe::egui;
-
 /// An icon button that shows active state via color and hover/press via
 /// translucent background fill.
 pub struct DockIcon {

crates/kammy/src/editor.rs

···
 
 //! Editor trait, built-in editor implementations, and tile-tree dispatch.
 
+pub mod display_list;
 pub mod todo;
 
 use std::cell::Cell;
 use std::collections::HashMap;
 use std::fmt;
 
-use eframe::egui;
 use tracing::debug;
 
 use crate::Project;
+use crate::gpu::GpuState;
 
 /// Trait for objects that provide property-editing UI in the Inspector panel.
 ///
···
     /// The display title for the editor's tab.
     fn title(&self) -> String;
     /// Renders the editor UI.
-    fn ui(&mut self, ui: &mut egui::Ui, ctx: &EditorContext);
+    fn ui(&mut self, ui: &mut egui::Ui, ctx: &mut EditorContext);
 }
 
 /// Context passed to each editor during rendering.
 pub struct EditorContext<'a> {
     /// The shared project data.
     pub project: &'a Project,
+    /// GPU state for registering textures and accessing the RDP context.
+    /// `None` in headless/test environments.
+    pub gpu: Option<&'a mut GpuState>,
     /// This editor's tile ID.
     pub tile_id: egui_tiles::TileId,
 }
···
 /// handles focus tracking and auto-commit.
 pub struct TileBehavior<'a> {
     pub project: &'a Project,
+    pub gpu: Option<&'a mut GpuState>,
     pub undo_behaviors: &'a HashMap<EditorId, UndoBehavior>,
     pub active_document: &'a mut Option<egui_tiles::TileId>,
     pub active_editor_id: &'a mut Option<EditorId>,
···
         let project = self.project;
 
         subsecond::call(|| {
-            let ctx = EditorContext { project, tile_id };
-            editor.ui(ui, &ctx);
+            let mut ctx = EditorContext {
+                project,
+                gpu: self.gpu.as_deref_mut(),
+                tile_id,
+            };
+            editor.ui(ui, &mut ctx);
         });
 
         // Auto-commit under this editor's origin.

crates/kammy/src/editor/display_list.rs

···
+// SPDX-FileCopyrightText: 2026 Alex Bates <[e-mail]>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+//! Display list editor: renders N64 display lists via parallel-rdp.
+//!
+//! Currently renders a solid-color test pattern to verify the full pipeline:
+//! RDRAM write -> RDP command submit -> scanout -> wgpu texture -> egui display.
+
+use super::{Editor, EditorContext, EditorId};
+use crate::widget::rdp_viewport::{DisplayList, RdpViewport, ViConfig};
+
+/// An editor that renders N64 display lists via the RDP.
+pub struct DisplayListEditor {
+    id: EditorId,
+    viewport: RdpViewport,
+    frame_count: u32,
+}
+
+impl std::fmt::Debug for DisplayListEditor {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("DisplayListEditor")
+            .field("id", &self.id)
+            .field("frame_count", &self.frame_count)
+            .finish_non_exhaustive()
+    }
+}
+
+impl DisplayListEditor {
+    /// Creates a new display list editor with the given stable ID.
+    pub fn new(id: EditorId) -> Self {
+        Self {
+            id,
+            viewport: RdpViewport::new(4 * 1024 * 1024),
+            frame_count: 0,
+        }
+    }
+}
+
+/// Build an RDP display list that fills the framebuffer with a solid color.
+///
+/// The color cycles through red, green, blue based on the frame counter,
+/// producing a simple animated test pattern.
+fn build_fill_rect_display_list(frame: u32) -> DisplayList {
+    // Framebuffer: 320x240, 16-bit (5/5/5/1)
+    const FB_WIDTH: u32 = 320;
+    const FB_HEIGHT: u32 = 240;
+    const FB_ORIGIN: u32 = 0x100; // Non-zero: parallel-rdp treats origin 0 as blank
+
+    let phase = frame / 60 % 3;
+    let fill_color: u32 = match phase {
+        0 => 0xF801_F801, // Red (16-bit 5551: R=31, G=0, B=0, A=1), packed twice
+        1 => 0x07C1_07C1, // Green
+        _ => 0x003F_003F, // Blue
+    };
+
+    // RDP commands (each command is 64 bits = 2 words)
+    let commands: Vec<u32> = vec![
+        // Set Color Image: format=RGBA, size=16-bit, width=320, address=0
+        // Command byte: 0x3F (Set Color Image)
+        // Bits: [63:56]=0x3F, [55:53]=format(0=RGBA), [52:51]=size(1=16-bit),
+        //       [41:32]=width-1, [25:0]=address
+        0x3F10_0000 | ((FB_WIDTH - 1) & 0x3FF),
+        FB_ORIGIN,
+        // Set Scissor: XH=0, YH=0, XL=320<<2, YL=240<<2
+        // Command byte: 0x2D
+        0x2D00_0000,
+        ((FB_WIDTH << 2) << 12) | (FB_HEIGHT << 2),
+        // Set Other Modes: cycle_type=Fill
+        // Command byte: 0x2F, bit 55-52 = cycle type (3=Fill)
+        0x2F30_0000,
+        0x0000_0000,
+        // Set Fill Color
+        // Command byte: 0x37
+        0x3700_0000,
+        fill_color,
+        // Fill Rectangle: covers entire framebuffer
+        // Command byte: 0x36
+        // Bits: XL=320<<2, YL=240<<2 (word 0), XH=0, YH=0 (word 1)
+        0x3600_0000 | ((FB_WIDTH << 2) << 12) | (FB_HEIGHT << 2),
+        0x0000_0000,
+        // Sync Full: wait for all rendering to complete
+        // Command byte: 0x29
+        0x2900_0000,
+        0x0000_0000,
+    ];
+
+    let vi = ViConfig {
+        // Control: 16-bit color (bits 1:0 = 2), anti-alias + resample (bits 9:8 = 3)
+        control: 0x0000_0302,
+        origin: FB_ORIGIN,
+        width: FB_WIDTH,
+        v_sync: 525,                       // NTSC: 525 lines
+        h_start: (0x006C << 16) | 0x02EC,  // Typical NTSC H range
+        v_start: (0x0025 << 16) | 0x01FF,  // Typical NTSC V range
+        x_scale: (FB_WIDTH * 1024 / 640),  // Scale to fill 640 output
+        y_scale: (FB_HEIGHT * 1024 / 480), // Scale to fill 480 output
+    };
+
+    DisplayList { commands, vi }
+}
+
+impl Editor for DisplayListEditor {
+    fn id(&self) -> EditorId {
+        self.id
+    }
+
+    fn title(&self) -> String {
+        "Display List".to_owned()
+    }
+
+    fn ui(&mut self, ui: &mut egui::Ui, ctx: &mut EditorContext) {
+        let display_list = build_fill_rect_display_list(self.frame_count);
+        self.frame_count = self.frame_count.wrapping_add(1);
+
+        self.viewport
+            .ui(ui, ctx.gpu.as_deref_mut(), &display_list, |_| {});
+
+        ui.ctx().request_repaint();
+    }
+}

crates/kammy/src/editor/todo.rs

···
 
 //! Todo-list editor.
 
-use eframe::egui;
-
 use super::{Editor, EditorContext, EditorId};
 
 /// A simple todo-list editor.
···
         subsecond::call(|| "Todos".to_owned())
     }
 
-    fn ui(&mut self, ui: &mut egui::Ui, ctx: &EditorContext) {
+    fn ui(&mut self, ui: &mut egui::Ui, ctx: &mut EditorContext) {
         let key = self.id.to_string();
         let tab_data = ctx.project.tabs().get_or_create(&key);
 

crates/kammy/src/gpu.rs

···
+// SPDX-FileCopyrightText: 2026 Alex Bates <[e-mail]>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+#![allow(
+    unsafe_code,
+    reason = "wgpu HAL interop requires unsafe for wrapping raw Vulkan handles from Granite"
+)]
+
+//! GPU state: shared Vulkan device (Granite + wgpu) and egui renderer.
+//!
+//! Granite (via parallel-rdp) creates the Vulkan instance and device. wgpu
+//! wraps them via `from_hal` so both RDP compute and egui rendering share a
+//! single `VkDevice`. Scanout images are imported directly as wgpu textures
+//! with no CPU readback.
+
+use std::ffi::CStr;
+use std::sync::Arc;
+
+use anyhow::{Context, Result};
+use raw_window_handle::HasDisplayHandle;
+use winit::window::Window;
+
+/// GPU state shared across the application.
+pub struct GpuState {
+    /// The parallel-rdp Vulkan context (owns the `VkInstance` + `VkDevice`).
+    pub rdp_context: parallel_rdp::VulkanContext,
+    /// wgpu device wrapping Granite's `VkDevice`.
+    pub device: wgpu::Device,
+    /// wgpu queue wrapping Granite's graphics queue.
+    pub queue: wgpu::Queue,
+    /// Window surface for presentation.
+    surface: wgpu::Surface<'static>,
+    /// Current surface configuration.
+    surface_config: wgpu::SurfaceConfiguration,
+    /// egui renderer (draws egui primitives via wgpu).
+    pub renderer: egui_wgpu::Renderer,
+    /// Prevents the wgpu Instance from being dropped prematurely.
+    _instance: wgpu::Instance,
+}
+
+impl std::fmt::Debug for GpuState {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("GpuState").finish_non_exhaustive()
+    }
+}
+
+/// Returns the Vulkan instance extensions required for window surface
+/// presentation on the current platform.
+fn required_instance_extensions(
+    display: raw_window_handle::RawDisplayHandle,
+) -> Vec<&'static CStr> {
+    use raw_window_handle::RawDisplayHandle;
+    let mut exts = vec![ash::khr::surface::NAME];
+    match display {
+        RawDisplayHandle::Xlib(_) => exts.push(ash::khr::xlib_surface::NAME),
+        RawDisplayHandle::Xcb(_) => exts.push(ash::khr::xcb_surface::NAME),
+        RawDisplayHandle::Wayland(_) => exts.push(ash::khr::wayland_surface::NAME),
+        _ => {}
+    }
+    exts
+}
+
+/// Creates a wgpu Instance + Adapter wrapping Granite's Vulkan handles.
+fn create_wgpu_instance_and_adapter(
+    rdp_context: &parallel_rdp::VulkanContext,
+    instance_extensions: Vec<&'static CStr>,
+) -> Result<(wgpu::Instance, wgpu::Adapter)> {
+    use wgpu::hal::Instance as _;
+
+    let entry = unsafe { ash::Entry::load() }.context("failed to load Vulkan loader")?;
+    let ash_instance = unsafe { ash::Instance::load(entry.static_fn(), rdp_context.vk_instance()) };
+    let api_version = unsafe { entry.try_enumerate_instance_version() }
+        .context("failed to query Vulkan version")?
+        .unwrap_or(ash::vk::API_VERSION_1_0);
+
+    // No-op drop callback: Granite owns the VkInstance
+    let hal_instance = unsafe {
+        wgpu::hal::vulkan::Instance::from_raw(
+            entry,
+            ash_instance,
+            api_version,
+            0,
+            None,
+            instance_extensions,
+            wgpu::InstanceFlags::empty(),
+            wgpu::MemoryBudgetThresholds::default(),
+            false,
+            Some(Box::new(|| {})),
+        )
+    }
+    .map_err(|e| anyhow::anyhow!("{e:?}"))
+    .context("failed to create wgpu HAL instance")?;
+
+    // Find the adapter matching Granite's physical device
+    let target_phys_dev = rdp_context.vk_physical_device();
+    let mut hal_adapters = unsafe { hal_instance.enumerate_adapters(None) };
+    let adapter_idx = hal_adapters
+        .iter()
+        .position(|a| a.adapter.raw_physical_device() == target_phys_dev)
+        .context("Granite's physical device not found by wgpu")?;
+    let hal_exposed_adapter = hal_adapters.swap_remove(adapter_idx);
+    drop(hal_adapters);
+
+    let instance = unsafe { wgpu::Instance::from_hal::<wgpu::hal::api::Vulkan>(hal_instance) };
+    let adapter =
+        unsafe { instance.create_adapter_from_hal::<wgpu::hal::api::Vulkan>(hal_exposed_adapter) };
+
+    Ok((instance, adapter))
+}
+
+/// Wraps Granite's `VkDevice` into a wgpu Device + Queue.
+fn create_wgpu_device(
+    rdp_context: &parallel_rdp::VulkanContext,
+    adapter: &wgpu::Adapter,
+) -> Result<(wgpu::Device, wgpu::Queue)> {
+    // Reload ash handles (the previous ones were consumed by the HAL instance)
+    let entry = unsafe { ash::Entry::load() }.context("failed to load Vulkan loader")?;
+    let ash_instance = unsafe { ash::Instance::load(entry.static_fn(), rdp_context.vk_instance()) };
+    let ash_device = unsafe { ash::Device::load(ash_instance.fp_v1_0(), rdp_context.vk_device()) };
+    let (_, queue_family) = rdp_context.vk_queue();
+
+    // No-op drop callback: Granite owns the VkDevice
+    let open_device = {
+        let hal_adapter_guard = unsafe { adapter.as_hal::<wgpu::hal::api::Vulkan>() }
+            .context("adapter is not Vulkan")?;
+        unsafe {
+            hal_adapter_guard.device_from_raw(
+                ash_device,
+                Some(Box::new(|| {})),
+                &[ash::khr::swapchain::NAME],
+                wgpu::Features::empty(),
+                &wgpu::MemoryHints::Performance,
+                queue_family,
+                0,
+            )
+        }
+        .map_err(|e| anyhow::anyhow!("{e:?}"))
+        .context("failed to wrap Granite VkDevice")?
+    };
+
+    unsafe {
+        adapter.create_device_from_hal::<wgpu::hal::api::Vulkan>(
+            open_device,
+            &wgpu::DeviceDescriptor {
+                label: Some("kammy"),
+                required_features: wgpu::Features::empty(),
+                required_limits: wgpu::Limits::default(),
+                memory_hints: wgpu::MemoryHints::Performance,
+                trace: wgpu::Trace::Off,
+                experimental_features: wgpu::ExperimentalFeatures::default(),
+            },
+        )
+    }
+    .context("failed to create wgpu device from HAL")
+}
+
+impl GpuState {
+    /// Creates GPU state sharing a single Vulkan device between parallel-rdp
+    /// and wgpu.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if Vulkan context creation, wgpu HAL wrapping, or
+    /// surface configuration fails.
+    pub fn new(window: &Arc<Window>) -> Result<Self> {
+        let display_handle = window
+            .display_handle()
+            .map_err(|e| anyhow::anyhow!("{e}"))
+            .context("failed to get display handle")?
+            .as_raw();
+        let instance_extensions = required_instance_extensions(display_handle);
+        let device_extensions: Vec<&CStr> = vec![ash::khr::swapchain::NAME];
+
+        let rdp_context =
+            parallel_rdp::VulkanContext::new(&instance_extensions, &device_extensions)
+                .context("failed to create parallel-rdp Vulkan context")?;
+
+        let (instance, adapter) =
+            create_wgpu_instance_and_adapter(&rdp_context, instance_extensions)?;
+
+        let surface = instance
+            .create_surface(window.clone())
+            .context("failed to create wgpu surface")?;
+
+        let (device, queue) = create_wgpu_device(&rdp_context, &adapter)?;
+
+        let size = window.inner_size();
+        let surface_caps = surface.get_capabilities(&adapter);
+        let surface_format = surface_caps
+            .formats
+            .iter()
+            .find(|f| !f.is_srgb())
+            .or(surface_caps.formats.first())
+            .copied()
+            .context("no surface formats available")?;
+
+        let surface_config = wgpu::SurfaceConfiguration {
+            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
+            format: surface_format,
+            width: size.width.max(1),
+            height: size.height.max(1),
+            present_mode: wgpu::PresentMode::AutoVsync,
+            alpha_mode: *surface_caps
+                .alpha_modes
+                .first()
+                .context("no alpha modes available")?,
+            view_formats: vec![],
+            desired_maximum_frame_latency: 2,
+        };
+        surface.configure(&device, &surface_config);
+
+        let renderer = egui_wgpu::Renderer::new(
+            &device,
+            surface_format,
+            egui_wgpu::RendererOptions::default(),
+        );
+
+        Ok(Self {
+            rdp_context,
+            device,
+            queue,
+            surface,
+            surface_config,
+            renderer,
+            _instance: instance,
+        })
+    }
+
+    /// Resizes the surface when the window size changes.
+    pub fn resize(&mut self, width: u32, height: u32) {
+        if width > 0 && height > 0 {
+            self.surface_config.width = width;
+            self.surface_config.height = height;
+            self.surface.configure(&self.device, &self.surface_config);
+        }
+    }
+
+    /// Renders an egui frame to the surface.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if surface texture acquisition fails.
+    pub fn render(
+        &mut self,
+        textures_delta: &egui::TexturesDelta,
+        clipped_primitives: &[egui::ClippedPrimitive],
+        pixels_per_point: f32,
+    ) -> Result<()> {
+        let output = match self.surface.get_current_texture() {
+            Ok(output) => output,
+            Err(wgpu::SurfaceError::Outdated | wgpu::SurfaceError::Lost) => {
+                self.surface.configure(&self.device, &self.surface_config);
+                self.surface
+                    .get_current_texture()
+                    .context("failed to acquire surface texture after reconfigure")?
+            }
+            Err(e) => return Err(e).context("failed to acquire surface texture"),
+        };
+        let view = output
+            .texture
+            .create_view(&wgpu::TextureViewDescriptor::default());
+
+        for (id, delta) in &textures_delta.set {
+            self.renderer
+                .update_texture(&self.device, &self.queue, *id, delta);
+        }
+
+        let screen_descriptor = egui_wgpu::ScreenDescriptor {
+            size_in_pixels: [self.surface_config.width, self.surface_config.height],
+            pixels_per_point,
+        };
+
+        let mut encoder = self
+            .device
+            .create_command_encoder(&wgpu::CommandEncoderDescriptor {
+                label: Some("egui_encoder"),
+            });
+
+        let extra_commands = self.renderer.update_buffers(
+            &self.device,
+            &self.queue,
+            &mut encoder,
+            clipped_primitives,
+            &screen_descriptor,
+        );
+
+        {
+            let render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                label: Some("egui_render_pass"),
+                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                    view: &view,
+                    resolve_target: None,
+                    ops: wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(wgpu::Color {
+                            r: 0.1,
+                            g: 0.1,
+                            b: 0.1,
+                            a: 1.0,
+                        }),
+                        store: wgpu::StoreOp::Store,
+                    },
+                    depth_slice: None,
+                })],
+                depth_stencil_attachment: None,
+                timestamp_writes: None,
+                occlusion_query_set: None,
+            });
+
+            let mut render_pass = render_pass.forget_lifetime();
+            self.renderer
+                .render(&mut render_pass, clipped_primitives, &screen_descriptor);
+        }
+
+        self.queue.submit(
+            extra_commands
+                .into_iter()
+                .chain(std::iter::once(encoder.finish())),
+        );
+        output.present();
+
+        for id in &textures_delta.free {
+            self.renderer.free_texture(id);
+        }
+
+        Ok(())
+    }
+}

crates/kammy/src/main.rs

···
 mod app;
 mod dock;
 mod editor;
+mod gpu;
 #[cfg(test)]
 mod tests;
 mod theme;
 mod tool;
+mod widget;
 
 use std::sync::Arc;
 
-use eframe::egui;
+use egui::ViewportId;
 use loroscope::loroscope;
 use tracing_subscriber::EnvFilter;
+use winit::application::ApplicationHandler;
+use winit::event::WindowEvent;
+use winit::event_loop::{ActiveEventLoop, EventLoop};
+use winit::window::{Window, WindowAttributes, WindowId};
 
 /// A single todo item with a title and completion status.
 #[loroscope]
···
     pub tabs: Map<TabData>,
 }
 
-fn main() -> eframe::Result {
+/// Application wrapper that implements [`winit::application::ApplicationHandler`].
+struct WinitApp {
+    /// Set once the window is created in `resumed`.
+    state: Option<AppState>,
+}
+
+/// Runtime state created after the window is available.
+struct AppState {
+    window: Arc<Window>,
+    gpu: gpu::GpuState,
+    egui_ctx: egui::Context,
+    egui_state: egui_winit::State,
+    app: app::KammyApp,
+}
+
+impl ApplicationHandler for WinitApp {
+    #[expect(
+        clippy::expect_used,
+        reason = "startup-critical: window and GPU are required to run"
+    )]
+    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+        if self.state.is_some() {
+            return;
+        }
+
+        let window = Arc::new(
+            event_loop
+                .create_window(
+                    WindowAttributes::default()
+                        .with_title("Kammy")
+                        .with_inner_size(winit::dpi::LogicalSize::new(500.0_f64, 600.0)),
+                )
+                .expect("failed to create window"),
+        );
+
+        let gpu = gpu::GpuState::new(&window).expect("failed to initialize GPU");
+
+        let egui_ctx = egui::Context::default();
+        theme::apply(&egui_ctx);
+
+        let egui_state = egui_winit::State::new(
+            egui_ctx.clone(),
+            ViewportId::ROOT,
+            &window,
+            None,
+            None,
+            None,
+        );
+
+        // Register subsecond handler to request repaints on hot-reload
+        let repaint_window = window.clone();
+        subsecond::register_handler(Arc::new(move || {
+            repaint_window.request_redraw();
+        }));
+
+        let app = app::KammyApp::new();
+
+        self.state = Some(AppState {
+            window,
+            gpu,
+            egui_ctx,
+            egui_state,
+            app,
+        });
+    }
+
+    fn window_event(
+        &mut self,
+        event_loop: &ActiveEventLoop,
+        _window_id: WindowId,
+        event: WindowEvent,
+    ) {
+        let Some(state) = &mut self.state else {
+            return;
+        };
+
+        let response = state.egui_state.on_window_event(&state.window, &event);
+        if response.repaint {
+            state.window.request_redraw();
+        }
+        if response.consumed {
+            return;
+        }
+
+        match event {
+            WindowEvent::CloseRequested => {
+                event_loop.exit();
+            }
+            WindowEvent::Resized(size) => {
+                state.gpu.resize(size.width, size.height);
+                state.window.request_redraw();
+            }
+            WindowEvent::ScaleFactorChanged { .. } => {
+                let size = state.window.inner_size();
+                state.gpu.resize(size.width, size.height);
+                state.window.request_redraw();
+            }
+            WindowEvent::RedrawRequested => {
+                let raw_input = state.egui_state.take_egui_input(&state.window);
+                let full_output = state.egui_ctx.run(raw_input, |ctx| {
+                    subsecond::call(|| state.app.update(ctx, Some(&mut state.gpu)));
+                });
+
+                state
+                    .egui_state
+                    .handle_platform_output(&state.window, full_output.platform_output);
+
+                let clipped_primitives = state
+                    .egui_ctx
+                    .tessellate(full_output.shapes, full_output.pixels_per_point);
+
+                if let Err(e) = state.gpu.render(
+                    &full_output.textures_delta,
+                    &clipped_primitives,
+                    full_output.pixels_per_point,
+                ) {
+                    tracing::error!("render error: {e:?}");
+                }
+
+                if full_output
+                    .viewport_output
+                    .values()
+                    .any(|v| v.repaint_delay < std::time::Duration::from_secs(1))
+                {
+                    state.window.request_redraw();
+                }
+            }
+            _ => {}
+        }
+    }
+}
+
+#[expect(
+    clippy::expect_used,
+    reason = "startup-critical: no way to recover if event loop creation fails"
+)]
+fn main() {
     tracing_subscriber::fmt()
-        .with_env_filter(EnvFilter::from_default_env())
+        .with_env_filter(EnvFilter::try_from_default_env().unwrap_or_else(|_| {
+            // Default: show everything except parallel-rdp's chatty Granite warnings.
+            EnvFilter::new("warn,kammy=info,parallel_rdp=error")
+        }))
         .init();
 
     dioxus_devtools::connect_subsecond();
 
     subsecond::call(|| {
-        let options = eframe::NativeOptions {
-            viewport: egui::ViewportBuilder::default().with_inner_size([500.0, 600.0]),
-            ..Default::default()
-        };
-        eframe::run_native(
-            "Kammy",
-            options,
-            Box::new(|cc| {
-                let ctx = cc.egui_ctx.clone();
-                theme::apply(&ctx);
-                subsecond::register_handler(Arc::new(move || {
-                    ctx.request_repaint();
-                }));
-                Ok(Box::new(app::KammyApp::new()))
-            }),
-        )
-    })
+        let event_loop = EventLoop::new().expect("failed to create event loop");
+        event_loop.set_control_flow(winit::event_loop::ControlFlow::Wait);
+
+        let mut app = WinitApp { state: None };
+        event_loop
+            .run_app(&mut app)
+            .expect("event loop exited with error");
+    });
 }

crates/kammy/src/tests.rs

···
 
 mod undo;
 
-use eframe::egui;
-
 use crate::app::KammyApp;
 
-pub fn make_harness() -> egui_kittest::Harness<'static, KammyApp> {
+pub fn make_harness() -> egui_kittest::Harness<'static> {
+    let mut app = KammyApp::new();
     egui_kittest::Harness::builder()
         .with_size(egui::Vec2::new(1000.0, 600.0))
-        .build_eframe(|_cc| KammyApp::new())
+        .build(move |ctx| app.update(ctx, None))
 }

crates/kammy/src/tests/undo.rs

···
 //
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-//! Tests for undo/redo behavior across single and multiple editor tabs.
+//! Tests for undo/redo behavior.
 
-use eframe::egui;
 use egui_kittest::kittest::Queryable;
 
-use crate::app::KammyApp;
-
 /// Helper: type text into the todo input and click Add.
-fn add_todo(harness: &mut egui_kittest::Harness<'_, KammyApp>, text: &str) {
+fn add_todo(harness: &mut egui_kittest::Harness<'_>, text: &str) {
     harness
         .get_by_role(egui::accesskit::Role::TextInput)
         .click();
···
     harness.run();
 }
 
-/// Helper: switch the visible tab and `active_document` to a different pane.
-fn switch_to_other_pane(harness: &mut egui_kittest::Harness<'_, KammyApp>) {
-    let app = harness.state_mut();
-    let other = app.find_other_pane().expect("should find another pane");
-    app.switch_to_pane(other);
-}
-
 #[test]
 fn single_tab_undo_redo() {
     let mut harness = super::make_harness();
···
         "item should reappear after redo"
     );
 }
-
-#[test]
-fn undo_is_scoped_to_editor() {
-    let mut harness = super::make_harness();
-
-    // Add item to editor 1
-    add_todo(&mut harness, "from editor 1");
-    assert!(harness.query_by_label("from editor 1").is_some());
-
-    // Create editor 2 and switch to it
-    harness.get_by_label("+ New Tab").click();
-    harness.run();
-    switch_to_other_pane(&mut harness);
-    harness.run();
-
-    // Add item to editor 2
-    add_todo(&mut harness, "from editor 2");
-    assert!(harness.query_by_label("from editor 2").is_some());
-
-    // Undo on editor 2: should remove "from editor 2" only
-    harness.get_by_label("⟲ Undo").click();
-    harness.run();
-    assert!(
-        harness.query_by_label("from editor 2").is_none(),
-        "editor 2's item should be gone after undo"
-    );
-
-    // Redo on editor 2, then switch back to editor 1 and undo there
-    harness.get_by_label("⟳ Redo").click();
-    harness.run();
-
-    switch_to_other_pane(&mut harness);
-    harness.run();
-
-    // Editor 1's item should still be visible
-    assert!(
-        harness.query_by_label("from editor 1").is_some(),
-        "editor 1's item should still be visible"
-    );
-
-    // Undo on editor 1
-    harness.get_by_label("⟲ Undo").click();
-    harness.run();
-    assert!(
-        harness.query_by_label("from editor 1").is_none(),
-        "editor 1's item should be gone after undo on editor 1"
-    );
-
-    // Switch to editor 2 and verify its item survived
-    switch_to_other_pane(&mut harness);
-    harness.run();
-    assert!(
-        harness.query_by_label("from editor 2").is_some(),
-        "editor 2's item should survive editor 1's undo"
-    );
-}

crates/kammy/src/theme.rs

···
 
 use std::sync::Arc;
 
-use eframe::egui;
-
 /// A named font family for medium-weight text (headings, labels).
 pub fn medium() -> egui::FontFamily {
     egui::FontFamily::Name("Medium".into())

crates/kammy/src/tool.rs

···
 pub mod hierarchy;
 pub mod inspector;
 
-use eframe::egui;
-
 use crate::Project;
 use crate::editor::{EditorId, Inspect};
 

crates/kammy/src/tool/assets.rs

···
 
 //! Assets tool: browse and manage project assets.
 
-use eframe::egui;
-
 use super::{Tool, ToolContext};
 
 /// A file browser for project assets.

crates/kammy/src/tool/hierarchy.rs

···
 
 //! Hierarchy tool: tree view of the document's structure.
 
-use eframe::egui;
-
 use super::{Tool, ToolContext};
 
 /// A tree view showing the active document's structure.

crates/kammy/src/tool/inspector.rs

···
 //! Inspector tool: displays property UI provided by editors via the
 //! [`Inspect`](crate::editor::Inspect) trait.
 
-use eframe::egui;
-
 use super::{Tool, ToolContext};
 
 /// A tool that renders the current [`Inspect`](crate::editor::Inspect)

crates/kammy/src/widget.rs

···
+// SPDX-FileCopyrightText: 2026 Alex Bates <[e-mail]>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+//! Reusable egui widgets for kammy.
+
+pub mod rdp_viewport;

crates/kammy/src/widget/rdp_viewport.rs

···
+// SPDX-FileCopyrightText: 2026 Alex Bates <[e-mail]>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+#![allow(unsafe_code, reason = "wgpu HAL interop for importing scanout VkImage")]
+
+//! An egui widget that renders N64 display lists using parallel-rdp.
+
+use crate::gpu::GpuState;
+
+/// N64 Video Interface register configuration for scanout.
+#[derive(Debug, Clone)]
+pub struct ViConfig {
+    /// VI control register (format, anti-alias mode, etc.).
+    pub control: u32,
+    /// Framebuffer origin in RDRAM (byte offset).
+    pub origin: u32,
+    /// Framebuffer width in pixels.
+    pub width: u32,
+    /// Vertical sync period (total lines per frame).
+    pub v_sync: u32,
+    /// Horizontal video start/end (visible region).
+    pub h_start: u32,
+    /// Vertical video start/end (visible region).
+    pub v_start: u32,
+    /// Horizontal scale factor (2.10 fixed point).
+    pub x_scale: u32,
+    /// Vertical scale factor (2.10 fixed point).
+    pub y_scale: u32,
+}
+
+/// A display list to be rendered by the RDP.
+#[derive(Debug, Clone)]
+pub struct DisplayList {
+    /// RDP command words (big-endian 32-bit).
+    pub commands: Vec<u32>,
+    /// Video Interface configuration for scanout.
+    pub vi: ViConfig,
+}
+
+/// Reusable egui widget that renders N64 display lists via parallel-rdp.
+///
+/// Each instance owns its own [`parallel_rdp::Renderer`] (command processor +
+/// RDRAM). The widget submits display list commands, performs scanout, and
+/// displays the result as an egui image.
+///
+/// The renderer is created lazily on the first [`show`](Self::show) call that
+/// receives a GPU context.
+pub struct RdpViewport {
+    renderer: Option<parallel_rdp::Renderer>,
+    rdram_size: u32,
+    /// Registered egui texture ID (reused across frames).
+    texture_id: Option<egui::TextureId>,
+    /// The current frame's scanout texture wrapper. Kept alive so egui can
+    /// reference it during the render pass (which runs after `show()`).
+    current_texture: Option<wgpu::Texture>,
+}
+
+impl std::fmt::Debug for RdpViewport {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("RdpViewport")
+            .field("texture_id", &self.texture_id)
+            .finish_non_exhaustive()
+    }
+}
+
+impl RdpViewport {
+    /// Creates a new viewport.
+    ///
+    /// `rdram_size` is the RDRAM capacity in bytes (typically 4 MiB). The
+    /// underlying renderer is created lazily when [`show`](Self::show) is
+    /// first called with a GPU context.
+    pub fn new(rdram_size: u32) -> Self {
+        Self {
+            renderer: None,
+            rdram_size,
+            texture_id: None,
+            current_texture: None,
+        }
+    }
+
+    /// Renders the display list and shows the result in the UI.
+    ///
+    /// The closure receives the renderer's RDRAM for direct writes (textures,
+    /// framebuffer data, etc.) before commands are submitted.
+    ///
+    /// If `gpu` is `None` (headless/test), displays a placeholder label.
+    pub fn ui(
+        &mut self,
+        ui: &mut egui::Ui,
+        gpu: Option<&mut GpuState>,
+        display_list: &DisplayList,
+        write_rdram: impl FnOnce(&mut [u8]),
+    ) -> egui::Response {
+        let Some(gpu) = gpu else {
+            return ui.label("GPU not available");
+        };
+
+        let renderer = match &mut self.renderer {
+            Some(r) => r,
+            None => match parallel_rdp::Renderer::new(&gpu.rdp_context, self.rdram_size, 0) {
+                Ok(r) => self.renderer.insert(r),
+                Err(e) => {
+                    tracing::warn!("failed to create RDP renderer: {e:?}");
+                    return ui.label("RDP renderer unavailable");
+                }
+            },
+        };
+
+        write_rdram(renderer.rdram_mut());
+        renderer.begin_frame();
+        Self::set_vi_registers(renderer, &display_list.vi);
+        renderer.enqueue_commands(&display_list.commands);
+
+        let Some((vk_image, width, height)) = renderer.scanout() else {
+            return ui.label("No scanout output");
+        };
+        if width == 0 || height == 0 {
+            return ui.label("No scanout output");
+        }
+
+        // Ensure all GPU scanout work is complete before wgpu reads the image
+        renderer.flush();
+
+        // SAFETY: flush() was called above, and the VkImage from scanout()
+        // remains valid until the wgpu::Texture is dropped (next frame at earliest).
+        let Some(texture) = (unsafe { import_scanout_image(&gpu.device, vk_image, width, height) })
+        else {
+            tracing::warn!("failed to import scanout VkImage into wgpu");
+            return ui.label("Scanout import failed");
+        };
+        let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
+
+        // Register or update the egui texture binding
+        if let Some(id) = self.texture_id {
+            gpu.renderer.update_egui_texture_from_wgpu_texture(
+                &gpu.device,
+                &view,
+                wgpu::FilterMode::Nearest,
+                id,
+            );
+        } else {
+            let id =
+                gpu.renderer
+                    .register_native_texture(&gpu.device, &view, wgpu::FilterMode::Nearest);
+            self.texture_id = Some(id);
+        }
+
+        // Keep texture alive until the render pass uses it
+        self.current_texture = Some(texture);
+
+        let (Ok(w), Ok(h)) = (u16::try_from(width), u16::try_from(height)) else {
+            tracing::warn!("scanout dimensions too large for display: {width}x{height}");
+            return ui.label("Scanout too large");
+        };
+        let size = egui::vec2(f32::from(w), f32::from(h));
+
+        let Some(texture_id) = self.texture_id else {
+            return ui.label("Texture not ready");
+        };
+        ui.image(egui::load::SizedTexture::new(texture_id, size))
+    }
+
+    fn set_vi_registers(renderer: &mut parallel_rdp::Renderer, vi: &ViConfig) {
+        use parallel_rdp::ViRegister;
+        renderer.set_vi_register(ViRegister::Control, vi.control);
+        renderer.set_vi_register(ViRegister::Origin, vi.origin);
+        renderer.set_vi_register(ViRegister::Width, vi.width);
+        renderer.set_vi_register(ViRegister::VSync, vi.v_sync);
+        renderer.set_vi_register(ViRegister::HStart, vi.h_start);
+        renderer.set_vi_register(ViRegister::VStart, vi.v_start);
+        renderer.set_vi_register(ViRegister::XScale, vi.x_scale);
+        renderer.set_vi_register(ViRegister::YScale, vi.y_scale);
+    }
+}
+
+/// Imports a parallel-rdp scanout `VkImage` into wgpu as a texture.
+///
+/// # Safety
+///
+/// The `VkImage` must be valid and fully rendered (call `flush()` first).
+/// It must remain valid until the wgpu texture is dropped.
+unsafe fn import_scanout_image(
+    device: &wgpu::Device,
+    vk_image: ash::vk::Image,
+    width: u32,
+    height: u32,
+) -> Option<wgpu::Texture> {
+    let hal_texture = {
+        let hal_device = unsafe { device.as_hal::<wgpu::hal::api::Vulkan>() }?;
+        unsafe {
+            hal_device.texture_from_raw(
+                vk_image,
+                &wgpu::hal::TextureDescriptor {
+                    label: None,
+                    size: wgpu::Extent3d {
+                        width,
+                        height,
+                        depth_or_array_layers: 1,
+                    },
+                    mip_level_count: 1,
+                    sample_count: 1,
+                    dimension: wgpu::TextureDimension::D2,
+                    format: wgpu::TextureFormat::Rgba8Unorm,
+                    usage: wgpu::TextureUses::RESOURCE,
+                    memory_flags: wgpu::hal::MemoryFlags::empty(),
+                    view_formats: vec![],
+                },
+                // No-op drop callback: Granite owns the VkImage
+                Some(Box::new(|| {})),
+            )
+        }
+    };
+
+    Some(unsafe {
+        device.create_texture_from_hal::<wgpu::hal::api::Vulkan>(
+            hal_texture,
+            &wgpu::TextureDescriptor {
+                label: Some("rdp_scanout"),
+                size: wgpu::Extent3d {
+                    width,
+                    height,
+                    depth_or_array_layers: 1,
+                },
+                mip_level_count: 1,
+                sample_count: 1,
+                dimension: wgpu::TextureDimension::D2,
+                format: wgpu::TextureFormat::Rgba8Unorm,
+                usage: wgpu::TextureUsages::TEXTURE_BINDING,
+                view_formats: &[],
+            },
+        )
+    })
+}

crates/parallel_rdp/Cargo.toml

···
+# SPDX-FileCopyrightText: 2026 Alex Bates <[e-mail]>
+#
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+[package]
+name = "parallel_rdp"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+ash = { workspace = true }
+thiserror = { workspace = true }
+tracing = { workspace = true }
+
+[build-dependencies]
+cc = "1"
+bindgen = "0.72"
+
+[lints]
+workspace = true

crates/parallel_rdp/build.rs

···
+// SPDX-FileCopyrightText: 2026 Alex Bates <[e-mail]>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+//! Build script: compiles parallel-rdp C++ sources and generates Rust FFI bindings.
+
+#![allow(clippy::expect_used)]
+
+use std::path::PathBuf;
+
+fn main() {
+    let rdp_dir =
+        PathBuf::from(std::env::var("PARALLEL_RDP_DIR").expect("PARALLEL_RDP_DIR must be set"));
+    let out_dir = PathBuf::from(std::env::var("OUT_DIR").expect("OUT_DIR must be set"));
+
+    println!("cargo::rerun-if-changed=src/bridge.cpp");
+    println!("cargo::rerun-if-changed=src/bridge.hpp");
+    println!("cargo::rerun-if-changed=src/logging.cpp");
+    println!("cargo::rerun-if-env-changed=PARALLEL_RDP_DIR");
+
+    // Must be compiled BEFORE volk so that the linker sees parallel-rdp's
+    // unresolved volk symbols first, then resolves them with libvolk.a.
+    let mut rdp_build = cc::Build::new();
+    rdp_build
+        .cpp(true)
+        .std("c++23")
+        .opt_level(2)
+        .flag("-Wno-unused-parameter")
+        .flag("-Wno-missing-field-initializers");
+
+    // parallel-rdp core
+    for file in &[
+        "parallel-rdp/command_ring.cpp",
+        "parallel-rdp/rdp_device.cpp",
+        "parallel-rdp/rdp_dump_write.cpp",
+        "parallel-rdp/rdp_renderer.cpp",
+        "parallel-rdp/video_interface.cpp",
+    ] {
+        rdp_build.file(rdp_dir.join(file));
+    }
+
+    // Granite Vulkan abstraction
+    for file in &[
+        "vulkan/buffer.cpp",
+        "vulkan/buffer_pool.cpp",
+        "vulkan/command_buffer.cpp",
+        "vulkan/command_pool.cpp",
+        "vulkan/context.cpp",
+        "vulkan/cookie.cpp",
+        "vulkan/descriptor_set.cpp",
+        "vulkan/device.cpp",
+        "vulkan/event_manager.cpp",
+        "vulkan/fence.cpp",
+        "vulkan/fence_manager.cpp",
+        "vulkan/image.cpp",
+        "vulkan/indirect_layout.cpp",
+        "vulkan/memory_allocator.cpp",
+        "vulkan/pipeline_cache.cpp",
+        "vulkan/pipeline_event.cpp",
+        "vulkan/query_pool.cpp",
+        "vulkan/render_pass.cpp",
+        "vulkan/rtas.cpp",
+        "vulkan/sampler.cpp",
+        "vulkan/semaphore.cpp",
+        "vulkan/semaphore_manager.cpp",
+        "vulkan/shader.cpp",
+        "vulkan/texture/texture_format.cpp",
+        "vulkan/wsi.cpp",
+    ] {
+        rdp_build.file(rdp_dir.join(file));
+    }
+
+    // Utilities (logging.cpp is replaced by our src/logging.cpp which uses a
+    // global instead of thread-local, so the command ring thread is covered)
+    for file in &[
+        "util/aligned_alloc.cpp",
+        "util/arena_allocator.cpp",
+        "util/environment.cpp",
+        "util/slab_allocator.cpp",
+        "util/thread_id.cpp",
+        "util/thread_name.cpp",
+        "util/timer.cpp",
+        "util/timeline_trace_file.cpp",
+    ] {
+        rdp_build.file(rdp_dir.join(file));
+    }
+
+    // Our bridge + logging replacement
+    rdp_build.file("src/bridge.cpp");
+    rdp_build.file("src/logging.cpp");
+
+    rdp_build
+        .include(rdp_dir.join("parallel-rdp"))
+        .include(rdp_dir.join("volk"))
+        .include(rdp_dir.join("vulkan"))
+        .include(rdp_dir.join("vulkan-headers/include"))
+        .include(rdp_dir.join("util"))
+        .include("src"); // For bridge.hpp
+
+    rdp_build.compile("parallel-rdp");
+
+    // Compiled after parallel-rdp so the linker sees volk last and can
+    // resolve the Vulkan function pointer symbols that Granite references.
+    cc::Build::new()
+        .std("c17")
+        .opt_level(2)
+        .include(rdp_dir.join("vulkan-headers/include"))
+        .file(rdp_dir.join("volk/volk.c"))
+        .compile("volk");
+
+    println!("cargo::rustc-link-lib=stdc++");
+
+    let bindings = bindgen::Builder::default()
+        .header("src/bridge.hpp")
+        .allowlist_function("rdp_.*")
+        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
+        .generate()
+        .expect("failed to generate bindings");
+
+    bindings
+        .write_to_file(out_dir.join("ffi.rs"))
+        .expect("failed to write bindings");
+}

crates/parallel_rdp/src/bridge.cpp

···
+// SPDX-FileCopyrightText: 2026 Alex Bates <[e-mail]>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+/// C bridge implementation for parallel-rdp's Granite Vulkan context and RDP
+/// command processor.
+
+#include "bridge.hpp"
+#include "context.hpp"
+#include "device.hpp"
+#include "logging.hpp"
+#include "rdp_device.hpp"
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <memory>
+#include <vector>
+
+using namespace Vulkan;
+
+// -- Logging --
+
+static void (*s_log_callback)(uint32_t level, const char *msg) = nullptr;
+
+/// Routes Granite log messages to a Rust callback.
+class RdpLoggingInterface final : public Util::LoggingInterface {
+public:
+    bool log(const char *tag, const char *fmt, va_list va) override
+    {
+        if (!s_log_callback)
+            return false;
+
+        uint32_t level;
+        if (strncmp(tag, "[ERROR]", 7) == 0)
+            level = RDP_LOG_LEVEL_ERROR;
+        else if (strncmp(tag, "[WARN]", 6) == 0)
+            level = RDP_LOG_LEVEL_WARN;
+        else
+            level = RDP_LOG_LEVEL_INFO;
+
+        char buf[1024];
+        vsnprintf(buf, sizeof(buf), fmt, va);
+
+        // Strip trailing newline (tracing adds its own).
+        size_t len = strlen(buf);
+        if (len > 0 && buf[len - 1] == '\n')
+            buf[len - 1] = '\0';
+
+        s_log_callback(level, buf);
+        return true;
+    }
+};
+
+static RdpLoggingInterface s_logging_interface;
+
+void rdp_set_log_callback(void (*callback)(uint32_t level, const char *msg))
+{
+    s_log_callback = callback;
+    Util::set_thread_logging_interface(callback ? &s_logging_interface : nullptr);
+}
+
+// -- Internal types --
+
+struct RdpContext {
+    std::unique_ptr<Context> context;
+    std::unique_ptr<Device> device;
+};
+
+struct RdpRenderer {
+    RdpContext *ctx;
+    std::unique_ptr<RDP::CommandProcessor> processor;
+    uint32_t rdram_size;
+};
+
+// -- Vulkan context --
+
+void *rdp_context_create(
+    const char *const *instance_ext, uint32_t num_instance_ext,
+    const char *const *device_ext, uint32_t num_device_ext)
+{
+    if (!Context::init_loader(nullptr))
+        return nullptr;
+
+    auto context = std::make_unique<Context>();
+    if (!context->init_instance_and_device(
+            instance_ext, num_instance_ext,
+            device_ext, num_device_ext, 0))
+        return nullptr;
+
+    auto device = std::make_unique<Device>();
+    device->set_context(*context);
+
+    auto *ctx = new RdpContext();
+    ctx->context = std::move(context);
+    ctx->device = std::move(device);
+    return ctx;
+}
+
+void rdp_context_destroy(void *ctx)
+{
+    delete static_cast<RdpContext *>(ctx);
+}
+
+void *rdp_context_get_instance(void *ctx)
+{
+    return static_cast<RdpContext *>(ctx)->context->get_instance();
+}
+
+void *rdp_context_get_physical_device(void *ctx)
+{
+    return static_cast<RdpContext *>(ctx)->context->get_gpu();
+}
+
+void *rdp_context_get_device(void *ctx)
+{
+    return static_cast<RdpContext *>(ctx)->context->get_device();
+}
+
+void *rdp_context_get_queue(void *ctx, uint32_t *family_index)
+{
+    auto &info = static_cast<RdpContext *>(ctx)->context->get_queue_info();
+    // Use the graphics queue (QUEUE_INDEX_GRAPHICS = 0)
+    if (family_index)
+        *family_index = info.family_indices[0];
+    return info.queues[0];
+}
+
+// -- Renderer --
+
+void *rdp_renderer_create(void *ctx, uint32_t rdram_size, uint32_t flags)
+{
+    auto *context = static_cast<RdpContext *>(ctx);
+
+    auto renderer = std::make_unique<RdpRenderer>();
+    renderer->ctx = context;
+    renderer->rdram_size = rdram_size;
+
+    // Pass nullptr for rdram_ptr so the CommandProcessor allocates its own
+    // host-coherent GPU buffer. This avoids the non-coherent path where
+    // host-to-GPU uploads during scanout can overwrite GPU-rendered data.
+    renderer->processor = std::make_unique<RDP::CommandProcessor>(
+        *context->device,
+        nullptr,
+        0,                  // rdram_offset
+        rdram_size,
+        rdram_size / 2,     // hidden_rdram_size
+        static_cast<RDP::CommandProcessorFlags>(flags));
+
+    if (!renderer->processor->device_is_supported()) {
+        return nullptr;
+    }
+
+    auto *ptr = renderer.release();
+    return ptr;
+}
+
+void rdp_renderer_destroy(void *renderer)
+{
+    delete static_cast<RdpRenderer *>(renderer);
+}
+
+uint8_t *rdp_renderer_get_rdram(void *renderer)
+{
+    auto *r = static_cast<RdpRenderer *>(renderer);
+    // The CommandProcessor's RDRAM is a host-coherent GPU buffer.
+    // begin_read_rdram() maps it for host access (persistent on coherent buffers).
+    return static_cast<uint8_t *>(r->processor->begin_read_rdram());
+}
+
+uint32_t rdp_renderer_get_rdram_size(void *renderer)
+{
+    return static_cast<RdpRenderer *>(renderer)->rdram_size;
+}
+
+void rdp_renderer_begin_frame(void *renderer)
+{
+    static_cast<RdpRenderer *>(renderer)->processor->begin_frame_context();
+}
+
+void rdp_renderer_enqueue(void *renderer, const uint32_t *words, uint32_t num_words)
+{
+    // RDP command lengths in 64-bit words, indexed by command byte (bits [29:24]).
+    // Most commands are 1 word (= 2 x 32-bit words). Triangle commands are larger.
+    static const unsigned cmd_len_lut[64] = {
+        1, 1, 1, 1, 1, 1, 1, 1,        // 0x00-0x07: nop/invalid
+        4, 6, 12, 14, 12, 14, 20, 22,   // 0x08-0x0F: triangles
+        1, 1, 1, 1, 1, 1, 1, 1,        // 0x10-0x17: unused
+        1, 1, 1, 1, 1, 1, 1, 1,        // 0x18-0x1F: unused
+        1, 1, 1, 1, 2, 2, 1, 1,        // 0x20-0x27: tex rect (0x24,0x25) = 2
+        1, 1, 1, 1, 1, 1, 1, 1,        // 0x28-0x2F: sync/scissor/modes
+        1, 1, 1, 1, 1, 1, 1, 1,        // 0x30-0x37: load/tile/fill/color
+        1, 1, 1, 1, 1, 1, 1, 1,        // 0x38-0x3F: color regs/combine/images
+    };
+
+    auto *proc = static_cast<RdpRenderer *>(renderer)->processor.get();
+
+    // Parse the word stream and enqueue each command individually.
+    // parallel-rdp's enqueue_command_direct() processes exactly one command
+    // per call, so we must split the stream ourselves.
+    uint32_t i = 0;
+    while (i < num_words) {
+        uint32_t cmd = (words[i] >> 24) & 63;
+        uint32_t len_64 = cmd_len_lut[cmd];
+        uint32_t len_32 = len_64 * 2;
+
+        if (i + len_32 > num_words)
+            break;
+
+        proc->enqueue_command(len_32, &words[i]);
+        i += len_32;
+    }
+}
+
+void rdp_renderer_set_vi_register(void *renderer, uint32_t reg, uint32_t value)
+{
+    static_cast<RdpRenderer *>(renderer)->processor->set_vi_register(
+        static_cast<RDP::VIRegister>(reg), value);
+}
+
+void *rdp_renderer_scanout(void *renderer, uint32_t *width, uint32_t *height)
+{
+    auto *r = static_cast<RdpRenderer *>(renderer);
+
+    RDP::ScanoutOptions options = {};
+    options.persist_frame_on_invalid_input = true;
+    options.blend_previous_frame = true;
+    options.upscale_deinterlacing = false;
+
+    Vulkan::ImageHandle image = r->processor->scanout(options);
+    if (!image) {
+        *width = 0;
+        *height = 0;
+        return nullptr;
+    }
+
+    *width = image->get_width();
+    *height = image->get_height();
+
+    // Return the raw VkImage handle.
+    // The ImageHandle (ref-counted) keeps the image alive as long as the
+    // CommandProcessor holds its internal reference (until next scanout).
+    return image->get_image();
+}
+
+int rdp_renderer_scanout_sync(
+    void *renderer,
+    uint8_t *buffer, uint32_t buffer_size,
+    uint32_t *width, uint32_t *height)
+{
+    auto *r = static_cast<RdpRenderer *>(renderer);
+
+    std::vector<RDP::RGBA> colors;
+    unsigned w = 0, h = 0;
+
+    RDP::ScanoutOptions options = {};
+    options.persist_frame_on_invalid_input = true;
+    options.blend_previous_frame = true;
+    options.upscale_deinterlacing = false;
+
+    r->processor->scanout_sync(colors, w, h, options);
+
+    if (w == 0 || h == 0 || colors.empty()) {
+        *width = 0;
+        *height = 0;
+        return 0;
+    }
+
+    *width = w;
+    *height = h;
+
+    uint32_t needed = w * h * 4;
+    if (buffer_size < needed)
+        return 0;
+
+    std::memcpy(buffer, colors.data(), needed);
+    return 1;
+}
+
+void rdp_renderer_flush(void *renderer)
+{
+    auto *r = static_cast<RdpRenderer *>(renderer);
+    uint64_t timeline = r->processor->signal_timeline();
+    r->processor->wait_for_timeline(timeline);
+}

crates/parallel_rdp/src/bridge.hpp

···
+// SPDX-FileCopyrightText: 2026 Alex Bates <[e-mail]>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+/// C bridge for parallel-rdp's Granite Vulkan context and RDP command processor.
+///
+/// Provides a headless Vulkan context (no WSI/window) suitable for sharing the
+/// VkDevice with wgpu, plus per-editor RDP renderers that submit display list
+/// commands and produce scanout images.
+
+#pragma once
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// -- Logging --
+
+/// Log level constants for `rdp_set_log_callback`.
+#define RDP_LOG_LEVEL_ERROR 0
+#define RDP_LOG_LEVEL_WARN  1
+#define RDP_LOG_LEVEL_INFO  2
+
+/// Set a callback to receive log messages from parallel-rdp's Granite backend.
+///
+/// Must be called before `rdp_context_create` on the thread that will call
+/// the bridge functions. The callback receives a log level and a
+/// null-terminated message string.
+///
+/// Pass NULL to disable the callback and fall back to stderr.
+void rdp_set_log_callback(void (*callback)(uint32_t level, const char *msg));
+
+// -- Vulkan context (Granite-owned headless device) --
+
+/// Create a headless Vulkan context via Granite.
+///
+/// The caller may request additional instance/device extensions (e.g. those
+/// required by wgpu) which Granite will enable alongside its own requirements.
+///
+/// Returns an opaque pointer, or NULL on failure.
+void *rdp_context_create(
+    const char *const *instance_ext, uint32_t num_instance_ext,
+    const char *const *device_ext, uint32_t num_device_ext);
+
+/// Destroy a Vulkan context created by `rdp_context_create`.
+void rdp_context_destroy(void *ctx);
+
+/// Get the VkInstance handle from the context.
+void *rdp_context_get_instance(void *ctx);
+
+/// Get the VkPhysicalDevice handle from the context.
+void *rdp_context_get_physical_device(void *ctx);
+
+/// Get the VkDevice handle from the context.
+void *rdp_context_get_device(void *ctx);
+
+/// Get a graphics/compute queue and its family index.
+void *rdp_context_get_queue(void *ctx, uint32_t *family_index);
+
+// -- Renderer (one per editor, owns CommandProcessor + RDRAM) --
+
+/// Create an RDP renderer.
+///
+/// Each renderer has its own CommandProcessor and RDRAM allocation, so
+/// multiple editors can render independently.
+///
+/// `rdram_size` is typically 4 or 8 MiB.
+/// `flags` is a bitmask of `RDP::CommandProcessorFlagBits`.
+void *rdp_renderer_create(void *ctx, uint32_t rdram_size, uint32_t flags);
+
+/// Destroy an RDP renderer.
+void rdp_renderer_destroy(void *renderer);
+
+/// Get a mutable pointer to the renderer's RDRAM.
+uint8_t *rdp_renderer_get_rdram(void *renderer);
+
+/// Get the RDRAM size in bytes.
+uint32_t rdp_renderer_get_rdram_size(void *renderer);
+
+/// Begin a new frame context.
+///
+/// Flushes pending work, drains the command ring, and advances Granite's
+/// per-frame resource tracking. Must be called once per frame before
+/// enqueuing commands.
+void rdp_renderer_begin_frame(void *renderer);
+
+/// Enqueue RDP commands for processing.
+///
+/// `words` points to an array of 32-bit words (big-endian command data).
+/// `num_words` is the total number of words.
+void rdp_renderer_enqueue(void *renderer, const uint32_t *words, uint32_t num_words);
+
+/// Set a VI (Video Interface) register.
+///
+/// `reg` is the VIRegister index (0 = Control, 1 = Origin, etc.)
+void rdp_renderer_set_vi_register(void *renderer, uint32_t reg, uint32_t value);
+
+/// Perform scanout: read the framebuffer via the Video Interface and produce
+/// an output image.
+///
+/// Returns the VkImage handle for the scanout result. The image format is
+/// R8G8B8A8_UNORM (or SRGB depending on Granite configuration).
+/// `width` and `height` are set to the scanout dimensions.
+///
+/// Returns NULL if scanout produced no valid image.
+void *rdp_renderer_scanout(void *renderer, uint32_t *width, uint32_t *height);
+
+/// Perform scanout and copy the result to a CPU buffer as RGBA8 pixels.
+///
+/// `buffer` must point to at least `width * height * 4` bytes.
+/// `width` and `height` are outputs set to the scanout dimensions.
+/// Returns 1 on success, 0 if scanout produced no valid image.
+int rdp_renderer_scanout_sync(
+    void *renderer,
+    uint8_t *buffer, uint32_t buffer_size,
+    uint32_t *width, uint32_t *height);
+
+/// Signal the renderer's timeline and wait for all previous work to complete.
+void rdp_renderer_flush(void *renderer);
+
+#ifdef __cplusplus
+}
+#endif

crates/parallel_rdp/src/ffi.rs

···
+// SPDX-FileCopyrightText: 2026 Alex Bates <[e-mail]>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+//! Raw FFI bindings generated by bindgen from `bridge.hpp`.
+
+#![allow(
+    unsafe_code,
+    non_upper_case_globals,
+    non_camel_case_types,
+    non_snake_case,
+    dead_code,
+    clippy::unreadable_literal,
+    clippy::doc_markdown,
+    missing_docs
+)]
+
+include!(concat!(env!("OUT_DIR"), "/ffi.rs"));

crates/parallel_rdp/src/lib.rs

···
+// SPDX-FileCopyrightText: 2026 Alex Bates <[e-mail]>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+#![allow(unsafe_code)]
+
+//! Safe Rust wrapper around parallel-rdp, providing headless N64 RDP rendering
+//! via Granite's Vulkan backend.
+//!
+//! # Architecture
+//!
+//! A single [`VulkanContext`] creates and owns the Vulkan instance and device
+//! (via Granite). Multiple [`Renderer`]s can be created from the same context,
+//! each with independent RDRAM and command processors. This allows multiple
+//! renders simultaneously.
+//!
+//! The raw Vulkan handles exposed by [`VulkanContext`] can be wrapped by wgpu
+//! (via `from_hal`) to share the same device for both RDP compute and egui
+//! rendering.
+
+mod ffi;
+
+use std::ffi::{CStr, c_void};
+use std::sync::Once;
+
+use ash::vk::Handle;
+
+/// Convert an opaque `*mut c_void` Vulkan handle to the `u64` representation
+/// expected by ash's `Handle::from_raw`.
+///
+/// `usize` → `u64` has no `From` impl (not lossless on hypothetical >64-bit
+/// platforms), but Vulkan only exists on 32/64-bit where this is a
+/// zero-extension.
+fn ptr_to_handle(ptr: *mut c_void) -> u64 {
+    #[expect(
+        clippy::as_conversions,
+        reason = "no From<usize> for u64; Vulkan targets are 32/64-bit"
+    )]
+    let handle = ptr.addr() as u64;
+    handle
+}
+
+/// Errors from parallel-rdp operations.
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    /// Vulkan context creation failed (device not supported, extensions
+    /// unavailable, etc.).
+    #[error("failed to create Vulkan context")]
+    ContextCreation,
+
+    /// Renderer creation failed (device not supported for RDP).
+    #[error("failed to create RDP renderer")]
+    RendererCreation,
+}
+
+/// C callback that routes Granite log messages to `tracing`.
+extern "C" fn granite_log_callback(level: u32, msg: *const std::ffi::c_char) {
+    let msg = unsafe { CStr::from_ptr(msg) }.to_string_lossy();
+    match level {
+        0 => tracing::error!(target: "parallel_rdp", "{msg}"),
+        1 => tracing::warn!(target: "parallel_rdp", "{msg}"),
+        _ => tracing::info!(target: "parallel_rdp", "{msg}"),
+    }
+}
+
+static LOG_INIT: Once = Once::new();
+
+/// Install the Granite → tracing log bridge (idempotent).
+fn init_logging() {
+    LOG_INIT.call_once(|| unsafe {
+        ffi::rdp_set_log_callback(Some(granite_log_callback));
+    });
+}
+
+/// A headless Vulkan context created by Granite.
+///
+/// Owns the `VkInstance`, `VkPhysicalDevice`, and `VkDevice`. The raw handles
+/// are accessible for wrapping by wgpu via `from_hal`.
+///
+/// # Safety
+///
+/// The Vulkan handles returned by accessor methods are valid for the lifetime
+/// of this struct. Do not destroy them externally.
+pub struct VulkanContext {
+    ptr: *mut c_void,
+}
+
+// SAFETY: The underlying Granite Context/Device are internally synchronized.
+unsafe impl Send for VulkanContext {}
+// SAFETY: All accessor methods return opaque handles; mutation goes through
+// Renderer which has &mut self.
+unsafe impl Sync for VulkanContext {}
+
+impl std::fmt::Debug for VulkanContext {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("VulkanContext")
+            .field("ptr", &self.ptr)
+            .finish()
+    }
+}
+
+impl VulkanContext {
+    /// Creates a new headless Vulkan context.
+    ///
+    /// `instance_extensions` and `device_extensions` are additional Vulkan
+    /// extensions to enable (e.g. those required by wgpu). Granite will enable
+    /// its own required extensions in addition to these.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`Error::ContextCreation`] if Vulkan initialization fails.
+    pub fn new(instance_extensions: &[&CStr], device_extensions: &[&CStr]) -> Result<Self, Error> {
+        init_logging();
+
+        let inst_ptrs: Vec<*const i8> = instance_extensions.iter().map(|s| s.as_ptr()).collect();
+        let dev_ptrs: Vec<*const i8> = device_extensions.iter().map(|s| s.as_ptr()).collect();
+
+        let ptr = unsafe {
+            ffi::rdp_context_create(
+                inst_ptrs.as_ptr().cast(),
+                u32::try_from(inst_ptrs.len()).unwrap_or(u32::MAX),
+                dev_ptrs.as_ptr().cast(),
+                u32::try_from(dev_ptrs.len()).unwrap_or(u32::MAX),
+            )
+        };
+
+        if ptr.is_null() {
+            return Err(Error::ContextCreation);
+        }
+
+        Ok(Self { ptr })
+    }
+
+    /// Returns the raw `VkInstance` handle.
+    pub fn vk_instance(&self) -> ash::vk::Instance {
+        let raw = unsafe { ffi::rdp_context_get_instance(self.ptr) };
+        ash::vk::Instance::from_raw(ptr_to_handle(raw))
+    }
+
+    /// Returns the raw `VkPhysicalDevice` handle.
+    pub fn vk_physical_device(&self) -> ash::vk::PhysicalDevice {
+        let raw = unsafe { ffi::rdp_context_get_physical_device(self.ptr) };
+        ash::vk::PhysicalDevice::from_raw(ptr_to_handle(raw))
+    }
+
+    /// Returns the raw `VkDevice` handle.
+    pub fn vk_device(&self) -> ash::vk::Device {
+        let raw = unsafe { ffi::rdp_context_get_device(self.ptr) };
+        ash::vk::Device::from_raw(ptr_to_handle(raw))
+    }
+
+    /// Returns the graphics queue handle and its family index.
+    pub fn vk_queue(&self) -> (ash::vk::Queue, u32) {
+        let mut family_index = 0u32;
+        let raw =
+            unsafe { ffi::rdp_context_get_queue(self.ptr, std::ptr::addr_of_mut!(family_index)) };
+        (ash::vk::Queue::from_raw(ptr_to_handle(raw)), family_index)
+    }
+}
+
+impl Drop for VulkanContext {
+    fn drop(&mut self) {
+        unsafe {
+            ffi::rdp_context_destroy(self.ptr);
+        }
+    }
+}
+
+/// An RDP renderer with its own RDRAM and command processor.
+///
+/// Each renderer is independent — multiple renderers can exist simultaneously
+/// for different display list editors, all sharing the same [`VulkanContext`].
+pub struct Renderer {
+    ptr: *mut c_void,
+}
+
+// SAFETY: The CommandProcessor is internally synchronized.
+unsafe impl Send for Renderer {}
+
+impl std::fmt::Debug for Renderer {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Renderer").field("ptr", &self.ptr).finish()
+    }
+}
+
+/// Flags for [`Renderer`] creation.
+///
+/// These correspond to `RDP::CommandProcessorFlagBits`.
+pub mod flags {
+    /// Make hidden RDRAM host-visible for debugging.
+    pub const HOST_VISIBLE_HIDDEN_RDRAM: u32 = 1 << 0;
+    /// Make TMEM host-visible for debugging.
+    pub const HOST_VISIBLE_TMEM: u32 = 1 << 1;
+    /// Enable 2x upscaling.
+    pub const UPSCALING_2X: u32 = 1 << 2;
+    /// Enable 4x upscaling.
+    pub const UPSCALING_4X: u32 = 1 << 3;
+    /// Enable 8x upscaling.
+    pub const UPSCALING_8X: u32 = 1 << 4;
+    /// Super-sampled readback.
+    pub const SUPER_SAMPLED_READ_BACK: u32 = 1 << 5;
+    /// Super-sampled dithering (improves upscaled dither patterns).
+    pub const SUPER_SAMPLED_DITHER: u32 = 1 << 6;
+}
+
+/// N64 Video Interface register indices.
+///
+/// These correspond to `RDP::VIRegister`.
+#[repr(u32)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ViRegister {
+    /// VI status/control register.
+    Control = 0,
+    /// Framebuffer origin in RDRAM.
+    Origin = 1,
+    /// Framebuffer width in pixels.
+    Width = 2,
+    /// Vertical interrupt line.
+    Intr = 3,
+    /// Current vertical scanline.
+    VCurrentLine = 4,
+    /// Video timing.
+    Timing = 5,
+    /// Vertical sync period.
+    VSync = 6,
+    /// Horizontal sync period.
+    HSync = 7,
+    /// Leap pattern.
+    Leap = 8,
+    /// Horizontal video start/end.
+    HStart = 9,
+    /// Vertical video start/end.
+    VStart = 10,
+    /// Vertical burst.
+    VBurst = 11,
+    /// Horizontal scale factor.
+    XScale = 12,
+    /// Vertical scale factor.
+    YScale = 13,
+}
+
+impl From<ViRegister> for u32 {
+    #[expect(
+        clippy::as_conversions,
+        reason = "only way to extract a #[repr(u32)] discriminant"
+    )]
+    fn from(reg: ViRegister) -> Self {
+        reg as Self
+    }
+}
+
+impl Renderer {
+    /// Creates a new RDP renderer.
+    ///
+    /// `rdram_size` is the RDRAM capacity in bytes (typically 4 or 8 MiB).
+    /// `flags` is a bitmask of values from [`flags`].
+    ///
+    /// # Errors
+    ///
+    /// Returns [`Error::RendererCreation`] if the GPU doesn't support the RDP
+    /// compute shaders.
+    pub fn new(ctx: &VulkanContext, rdram_size: u32, flags: u32) -> Result<Self, Error> {
+        let ptr = unsafe { ffi::rdp_renderer_create(ctx.ptr, rdram_size, flags) };
+        if ptr.is_null() {
+            return Err(Error::RendererCreation);
+        }
+        Ok(Self { ptr })
+    }
+
+    /// Returns a mutable slice over the renderer's RDRAM.
+    ///
+    /// Write display list data, textures, and framebuffer contents here before
+    /// calling [`enqueue_commands`](Self::enqueue_commands) and [`scanout`](Self::scanout).
+    pub fn rdram_mut(&mut self) -> &mut [u8] {
+        unsafe {
+            let ptr = ffi::rdp_renderer_get_rdram(self.ptr);
+            let size = ffi::rdp_renderer_get_rdram_size(self.ptr);
+            std::slice::from_raw_parts_mut(
+                ptr,
+                size.try_into()
+                    .expect("RDRAM size exceeds addressable memory"),
+            )
+        }
+    }
+
+    /// Begins a new frame context.
+    ///
+    /// Flushes pending work, drains the command ring, and advances Granite's
+    /// per-frame resource tracking. Must be called once per frame before
+    /// enqueuing commands.
+    pub fn begin_frame(&mut self) {
+        unsafe {
+            ffi::rdp_renderer_begin_frame(self.ptr);
+        }
+    }
+
+    /// Enqueues RDP commands for processing.
+    ///
+    /// `commands` is an array of 32-bit words containing RDP command data.
+    pub fn enqueue_commands(&mut self, commands: &[u32]) {
+        unsafe {
+            ffi::rdp_renderer_enqueue(
+                self.ptr,
+                commands.as_ptr(),
+                u32::try_from(commands.len()).unwrap_or(u32::MAX),
+            );
+        }
+    }
+
+    /// Sets a Video Interface register.
+    pub fn set_vi_register(&mut self, reg: ViRegister, value: u32) {
+        unsafe {
+            ffi::rdp_renderer_set_vi_register(self.ptr, reg.into(), value);
+        }
+    }
+
+    /// Performs scanout and returns the resulting image.
+    ///
+    /// Returns the raw `VkImage` handle along with its width and height.
+    /// Returns `None` if scanout produced no valid image (e.g. blank VI config).
+    ///
+    /// The returned `VkImage` is valid until the next call to `scanout` on this
+    /// renderer. Its format is `R8G8B8A8_UNORM`.
+    pub fn scanout(&mut self) -> Option<(ash::vk::Image, u32, u32)> {
+        let mut width = 0u32;
+        let mut height = 0u32;
+        let raw = unsafe {
+            ffi::rdp_renderer_scanout(
+                self.ptr,
+                std::ptr::addr_of_mut!(width),
+                std::ptr::addr_of_mut!(height),
+            )
+        };
+        if raw.is_null() {
+            return None;
+        }
+        Some((ash::vk::Image::from_raw(ptr_to_handle(raw)), width, height))
+    }
+
+    /// Performs scanout and copies the RGBA8 pixel data to `buffer`.
+    ///
+    /// Returns `Some((width, height))` on success, or `None` if scanout
+    /// produced no valid image. The buffer must be large enough for the
+    /// scanout dimensions (`width * height * 4` bytes). If the buffer is
+    /// too small, returns `None`.
+    pub fn scanout_sync(&mut self, buffer: &mut [u8]) -> Option<(u32, u32)> {
+        let mut width = 0u32;
+        let mut height = 0u32;
+        let ok = unsafe {
+            ffi::rdp_renderer_scanout_sync(
+                self.ptr,
+                buffer.as_mut_ptr(),
+                u32::try_from(buffer.len()).unwrap_or(u32::MAX),
+                std::ptr::addr_of_mut!(width),
+                std::ptr::addr_of_mut!(height),
+            )
+        };
+        if ok != 0 { Some((width, height)) } else { None }
+    }
+
+    /// Flushes all pending work and waits for completion.
+    pub fn flush(&mut self) {
+        unsafe {
+            ffi::rdp_renderer_flush(self.ptr);
+        }
+    }
+}
+
+impl Drop for Renderer {
+    fn drop(&mut self) {
+        unsafe {
+            ffi::rdp_renderer_destroy(self.ptr);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn context_creation() {
+        // This test requires a Vulkan-capable GPU.
+        // It verifies that the basic FFI plumbing works.
+        let ctx = VulkanContext::new(&[], &[]);
+        if let Ok(ctx) = ctx {
+            assert_ne!(ctx.vk_instance(), ash::vk::Instance::null());
+            assert_ne!(ctx.vk_physical_device(), ash::vk::PhysicalDevice::null());
+            assert_ne!(ctx.vk_device(), ash::vk::Device::null());
+
+            let (queue, _family) = ctx.vk_queue();
+            assert_ne!(queue, ash::vk::Queue::null());
+        }
+        // If no GPU is available, the test passes silently
+    }
+
+    #[test]
+    fn renderer_creation() {
+        let ctx = VulkanContext::new(&[], &[]);
+        let Ok(ctx) = ctx else { return };
+
+        let renderer = Renderer::new(&ctx, 4 * 1024 * 1024, 0);
+        if let Ok(mut renderer) = renderer {
+            let rdram = renderer.rdram_mut();
+            assert_eq!(rdram.len(), 4 * 1024 * 1024);
+        }
+    }
+
+    /// Submits a fill-rect display list that fills a 320x240 16-bit
+    /// framebuffer with solid red, then verifies the scanout pixels.
+    #[test]
+    fn fill_rect_scanout() {
+        let ctx = VulkanContext::new(&[], &[]);
+        let Ok(ctx) = ctx else { return };
+
+        let Ok(mut renderer) = Renderer::new(&ctx, 4 * 1024 * 1024, 0) else {
+            return;
+        };
+
+        const FB_WIDTH: u32 = 320;
+        const FB_HEIGHT: u32 = 240;
+        const FB_ORIGIN: u32 = 0x100; // Non-zero: parallel-rdp treats origin 0 as blank
+
+        // Red in 16-bit 5/5/5/1 format, packed twice for fill color register
+        let fill_color: u32 = 0xF801_F801;
+
+        let commands: Vec<u32> = vec![
+            // Set Color Image: RGBA 16-bit, width=320, address=FB_ORIGIN
+            0x3F10_0000 | ((FB_WIDTH - 1) & 0x3FF),
+            FB_ORIGIN,
+            // Set Scissor: (0,0) to (320,240) in 10.2 fixed point
+            0x2D00_0000,
+            ((FB_WIDTH << 2) << 12) | (FB_HEIGHT << 2),
+            // Set Other Modes: cycle_type=Fill (bits [21:20] = 11)
+            0x2F30_0000,
+            0x0000_0000,
+            // Set Fill Color
+            0x3700_0000,
+            fill_color,
+            // Fill Rectangle: (0,0) to (320,240) in 10.2 fixed point
+            0x3600_0000 | ((FB_WIDTH << 2) << 12) | (FB_HEIGHT << 2),
+            0x0000_0000,
+            // Sync Full
+            0x2900_0000,
+            0x0000_0000,
+        ];
+
+        // VI registers for 320x240 16-bit NTSC output
+        renderer.set_vi_register(ViRegister::Control, 0x0000_0302);
+        renderer.set_vi_register(ViRegister::Origin, FB_ORIGIN);
+        renderer.set_vi_register(ViRegister::Width, FB_WIDTH);
+        renderer.set_vi_register(ViRegister::VSync, 525);
+        renderer.set_vi_register(ViRegister::HStart, (0x006C << 16) | 0x02EC);
+        renderer.set_vi_register(ViRegister::VStart, (0x0025 << 16) | 0x01FF);
+        renderer.set_vi_register(ViRegister::XScale, FB_WIDTH * 1024 / 640);
+        renderer.set_vi_register(ViRegister::YScale, FB_HEIGHT * 1024 / 480);
+
+        renderer.begin_frame();
+        renderer.enqueue_commands(&commands);
+
+        let mut buffer = vec![0u8; 640 * 480 * 4];
+        let Some((w, h)) = renderer.scanout_sync(&mut buffer) else {
+            panic!("scanout_sync returned None — no valid output");
+        };
+
+        assert!(w > 0 && h > 0, "scanout dimensions should be non-zero");
+
+        // Check the center pixel is red (RGBA8).
+        // The VI applies filtering so we check approximate values — 5-bit
+        // red (31) scales to ~248 in 8-bit.
+        let w: usize = w.try_into().unwrap();
+        let h: usize = h.try_into().unwrap();
+        let idx = (h / 2 * w + w / 2) * 4;
+        let (r, g, b) = (buffer[idx], buffer[idx + 1], buffer[idx + 2]);
+
+        assert!(
+            r > 200 && g < 50 && b < 50,
+            "center pixel should be red, got ({r}, {g}, {b})",
+        );
+    }
+}

crates/parallel_rdp/src/logging.cpp

···
+// SPDX-FileCopyrightText: 2017-2026 Hans-Kristian Arntzen
+// SPDX-FileCopyrightText: 2026 Alex Bates <[e-mail]>
+//
+// SPDX-License-Identifier: MIT
+//
+// Replacement for Granite's util/logging.cpp that uses a global (not
+// thread-local) LoggingInterface, so the command ring worker thread's
+// messages are also routed through the Rust tracing callback.
+
+#include "logging.hpp"
+#include <atomic>
+
+namespace Util
+{
+
+static std::atomic<LoggingInterface *> logging_iface{nullptr};
+
+bool interface_log(const char *tag, const char *fmt, ...)
+{
+    auto *iface = logging_iface.load(std::memory_order_acquire);
+    if (!iface)
+        return false;
+
+    va_list va;
+    va_start(va, fmt);
+    bool ret = iface->log(tag, fmt, va);
+    va_end(va);
+    return ret;
+}
+
+void set_thread_logging_interface(LoggingInterface *iface)
+{
+    logging_iface.store(iface, std::memory_order_release);
+}
+
+}

flake.lock

···
         "type": "github"
       }
     },
+    "parallel-rdp-standalone": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1768824906,
+        "narHash": "sha256-NGSeApMa8mTk0YcsrMPwvDcrBvie3YLWm1bxsE7ylbw=",
+        "owner": "gopher64",
+        "repo": "parallel-rdp-standalone",
+        "rev": "c177532a0a24767c33b386ba9aac6c4610795401",
+        "type": "github"
+      },
+      "original": {
+        "owner": "gopher64",
+        "ref": "gopher64",
+        "repo": "parallel-rdp-standalone",
+        "type": "github"
+      }
+    },
     "root": {
       "inputs": {
         "flake-parts": "flake-parts",
         "font-switzer": "font-switzer",
         "nixpkgs": "nixpkgs",
+        "parallel-rdp-standalone": "parallel-rdp-standalone",
         "treefmt-nix": "treefmt-nix"
       }
     },

flake.nix

···
       url = "https://api.fontshare.com/v2/fonts/download/switzer";
       flake = false;
     };
+    parallel-rdp-standalone = {
+      url = "github:gopher64/parallel-rdp-standalone/gopher64";
+      flake = false;
+    };
   };
 
   outputs =
···
               pkgs.pkg-config
               pkgs.dioxus-cli
               pkgs.just
+              pkgs.clang
+            ];
+
+            nativeBuildInputs = [
+              pkgs.rustPlatform.bindgenHook
             ];
 
             buildInputs = with pkgs; [
               wayland
               libxkbcommon
-              libGL
+              vulkan-headers
+              vulkan-loader
               libx11
               libxcursor
               libxrandr
···
             ];
 
             SWITZER_FONT_DIR = "${font-switzer}";
+            PARALLEL_RDP_DIR = "${inputs.parallel-rdp-standalone}";
             RUST_BACKTRACE = "1";
 
             # https://github.com/DioxusLabs/dioxus/issues/4962
···
             LD_LIBRARY_PATH = pkgs.lib.makeLibraryPath [
               pkgs.wayland
               pkgs.libxkbcommon
-              pkgs.libGL
+              pkgs.vulkan-loader
               pkgs.libx11
               pkgs.libxcursor
               pkgs.libxrandr