diff --git a/Cargo.toml b/Cargo.toml
index b889f49b..9ccd7f5a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,7 +15,7 @@ resolver = "2"
 [workspace.dependencies]
 async-channel = "1.8"
 bytemuck = { version = "1.13.0", features = ["derive"] }
-crabslab = { version = "0.1.3", default-features = false }
+crabslab = { version = "0.2.0", default-features = false }
 futures-lite = "1.13"
 gltf = { git = 'https://github.com/gltf-rs/gltf.git', features = ["KHR_lights_punctual", "KHR_materials_unlit", "KHR_materials_emissive_strength", "extras"] }
 image = "0.24"
diff --git a/DEVLOG.md b/DEVLOG.md
index 78392845..5feefe16 100644
--- a/DEVLOG.md
+++ b/DEVLOG.md
@@ -1,5 +1,15 @@
 # devlog
 
+## Mon Jan 8, 2024
+
+I added another ty var to `crabslab::Offset` to help with pointer math.
+
+I've also added yet another layer of indirection around rendering.
+Now the top level unit of rendering is `Rendering`, which is an enum of
+`Id`s that point to different renderable things. There's an uber-vertex-shader
+that tracks this and proxies to the correct sub-shader. This is in anticipation
+of adding SDF rendering.
+
 ## Fri Jan 5, 2024
 
 The slab implementation in this repo has been spun off into its own thing.
diff --git a/crates/renderling-gpui/Cargo.toml b/crates/renderling-gpui/Cargo.toml
index b5a11821..201af6e2 100644
--- a/crates/renderling-gpui/Cargo.toml
+++ b/crates/renderling-gpui/Cargo.toml
@@ -10,14 +10,16 @@ default = ["winit"]
 winit = ["renderling/winit", "dep:winit"]
 
 [dependencies]
+ab_glyph = { version = "0.2" }
+crabslab = "0.1.3"
+glam = { workspace = true, default-features = false, features = ["bytemuck", "libm"] }
+glyph_brush = { version = "0.7" }
 image = { version = "^0.24" }
 log = "^0.4"
-renderling = { path = "../renderling", default-features = false, features = ["text"] }
+renderling = { path = "../renderling" }
 snafu = "^0.7"
-winit = { version = "^0.27", optional = true }
-
-glam = { workspace = true, default-features = false, features = ["bytemuck", "libm"] }
 wgpu = { workspace = true }
+winit = { version = "^0.27", optional = true }
 
 [dev-dependencies]
 env_logger = "^0.10"
diff --git a/crates/renderling-gpui/src/elements.rs b/crates/renderling-gpui/src/elements.rs
index 2536a1ac..7b3b755b 100644
--- a/crates/renderling-gpui/src/elements.rs
+++ b/crates/renderling-gpui/src/elements.rs
@@ -1,35 +1,70 @@
 //! User interface elements.
+use crabslab::{GrowableSlab, Slab};
+use glam::Vec3;
+use renderling::shader::{
+    gltf::{GltfMesh, GltfNode, GltfPrimitive},
+    pbr::Material,
+    stage::{RenderUnit, Transform, Vertex},
+};
+
 pub use super::*;
 
-#[derive(Default)]
+#[derive(Clone)]
 pub struct Rectangle {
     aabb: AABB,
-    color: Vec4,
-    draw_object: Option<UiDrawObject>,
+    primitive: Id<GltfPrimitive>,
+    material: Id<Material>,
+    render_unit: Id<RenderUnit>,
+    updates: Stage,
 }
 
 impl Rectangle {
     // Create a new rectangle.
-    pub fn new() -> Self {
+    pub fn new(gpui: &Gpui) -> Self {
+        let mut stage = gpui.stage.clone();
+        let material = Id::NONE;
+        let primitive = stage.new_primitive(Self::vertices(), None, material);
+        let primitives = stage.append_array(&[primitive]);
+        let mesh = stage.append(&GltfMesh {
+            primitives,
+            ..Default::default()
+        });
+        let node = stage.append(&GltfNode {
+            mesh,
+            ..Default::default()
+        });
+        let node_path = stage.append_array(&[node]);
+        let render_unit = stage.draw_unit(&RenderUnit {
+            node_path,
+            camera: gpui.camera,
+            vertex_count: 6,
+            ..Default::default()
+        });
         Self {
             aabb: AABB {
                 min: Vec2::ZERO,
                 max: Vec2::splat(100.0),
             },
-            color: Vec4::ONE,
-            draw_object: None,
+            primitive: primitives.at(0),
+            material,
+            render_unit,
+            stage,
         }
     }
 
+    /// Set the upper left corner of the rectangle.
     pub fn set_origin(&mut self, origin: impl Into<Vec2>) {
         let origin = origin.into();
         if self.aabb.min != origin {
             let delta = origin - self.aabb.min;
             self.aabb.min += delta;
             self.aabb.max += delta;
-            if let Some(obj) = self.draw_object.as_mut() {
-                obj.set_position(self.aabb.min);
-            }
+            self.stage.write(
+                self.render_unit
+                    + RenderUnit::offset_of_transform()
+                    + Transform::offset_of_translation(),
+                &Vec3::new(self.aabb.min.x, self.aabb.min.y, 0.0),
+            );
         }
     }
 
@@ -54,594 +89,564 @@ impl Rectangle {
         self
     }
 
-    // Get the color of the rectangle.
-    pub fn get_color(&self) -> Vec4 {
-        self.color
-    }
-
-    // Set the color of the rectangle.
-    pub fn set_color(&mut self, color: impl Into<Vec4>) {
-        let color = color.into();
-        if self.color != color {
-            self.color = color;
-            let vertices = self.vertices();
-            if let Some(obj) = self.draw_object.as_mut() {
-                obj.set_vertices(vertices);
-            }
-        }
-    }
-
-    pub fn with_color(mut self, color: impl Into<Vec4>) -> Self {
-        self.set_color(color);
-        self
-    }
-
-    fn vertices(&self) -> [UiVertex; 6] {
-        let tl = UiVertex::default()
-            .with_position(Vec2::ZERO)
-            .with_color(self.color);
-        let tr = UiVertex::default()
-            .with_position(Vec2::new(1.0, 0.0))
-            .with_color(self.color);
-        let bl = UiVertex::default()
-            .with_position(Vec2::new(0.0, 1.0))
-            .with_color(self.color);
-        let br = UiVertex::default()
-            .with_position(Vec2::ONE)
-            .with_color(self.color);
+    fn vertices() -> [Vertex; 6] {
+        let tl = Vertex::default().with_position(Vec3::ZERO);
+        let tr = Vertex::default().with_position(Vec3::new(1.0, 0.0, 0.0));
+        let bl = Vertex::default().with_position(Vec3::new(0.0, 1.0, 0.0));
+        let br = Vertex::default().with_position(Vec3::new(1.0, 1.0, 0.0));
         [tl, bl, br, tl, br, tr]
     }
+
+    //fn allocate(&mut self, gpui: &mut Gpui) -> {
+    //    let origin = self.aabb.min;
+    //    let size = self.aabb.size();
+    //    if self.draw_object.is_none() {
+    //        let obj = UiDrawObjectBuilder::new(device)
+    //            .with_draw_mode(UiMode::DEFAULT)
+    //            .with_position(origin)
+    //            .with_scale(size)
+    //            .with_vertices(self.vertices())
+    //            .build();
+    //        self.draw_object = Some(obj);
+    //    }
+    //    let draw_obj = self.draw_object.as_mut().unwrap();
+
+    //    if origin != draw_obj.get_position() {
+    //        draw_obj.set_position(origin);
+    //    }
+    //    if size != draw_obj.get_scale() {
+    //        draw_obj.set_scale(size);
+    //    }
+
+    //    draw_obj.update(device, queue).unwrap();
+    //    vec![Paint::drawing(|render_pass, default_texture_bindgroup| {
+    //        draw_obj.draw(render_pass, default_texture_bindgroup);
+    //    })]
+    //}
 }
 
 impl Element for Rectangle {
     type OutputEvent = ();
 
-    fn layout(&mut self, constraint: AABB) -> AABB {
-        self.aabb = AABB {
+    fn update(&mut self, gpui: &mut Gpui, constraint: AABB) -> AABB {
+        let aabb = AABB {
             min: self.aabb.min.max(constraint.min),
             max: self.aabb.max.min(constraint.max),
         };
-
-        self.aabb
-    }
-
-    fn paint<'a, 'b: 'a>(
-        &'b mut self,
-        device: &wgpu::Device,
-        queue: &wgpu::Queue,
-    ) -> Vec<Paint<'a, 'b>> {
-        let origin = self.aabb.min;
-        let size = self.aabb.size();
-        if self.draw_object.is_none() {
-            let obj = UiDrawObjectBuilder::new(device)
-                .with_draw_mode(UiMode::DEFAULT)
-                .with_position(origin)
-                .with_scale(size)
-                .with_vertices(self.vertices())
-                .build();
-            self.draw_object = Some(obj);
-        }
-        let draw_obj = self.draw_object.as_mut().unwrap();
-
-        if origin != draw_obj.get_position() {
-            draw_obj.set_position(origin);
-        }
-        if size != draw_obj.get_scale() {
-            draw_obj.set_scale(size);
-        }
-
-        draw_obj.update(device, queue).unwrap();
-        vec![Paint::drawing(|render_pass, default_texture_bindgroup| {
-            draw_obj.draw(render_pass, default_texture_bindgroup);
-        })]
-    }
-
-    fn event(&mut self, _event: Event) {}
-}
-
-pub struct Text {
-    cache: GlyphCache,
-    section: OwnedSection,
-    aabb: AABB,
-    updated: bool,
-    draw_object: Option<UiDrawObject>,
-}
-
-impl Text {
-    pub fn new(font: &FontArc) -> Self {
-        let cache = GlyphCache::new(vec![font.clone()]);
-        Text {
-            section: OwnedSection::default().add_text(OwnedText::new("").with_scale(12.0)),
-            cache,
-            aabb: AABB::default(),
-            updated: true,
-            draw_object: None,
-        }
-    }
-
-    pub fn set_font(&mut self, font: FontArc) {
-        self.cache = GlyphCache::new(vec![font]);
-        self.updated = true;
-    }
-
-    pub fn with_font(mut self, font: FontArc) -> Self {
-        self.set_font(font);
-        self
-    }
-
-    pub fn set_text(&mut self, text: impl Into<String>) {
-        self.section.text.resize_with(1, Default::default);
-        self.section.text[0].text = text.into();
-        self.updated = true;
-    }
-
-    pub fn with_text(mut self, text: impl Into<String>) -> Self {
-        self.set_text(text);
-        self
-    }
-
-    pub fn set_scale(&mut self, scale: f32) {
-        self.section
-            .text
-            .iter_mut()
-            .for_each(|t| t.scale = scale.into());
-        self.updated = true;
-    }
-
-    pub fn with_scale(mut self, scale: f32) -> Self {
-        self.set_scale(scale);
-        self
-    }
-
-    pub fn set_color(&mut self, color: impl Into<Vec4>) {
-        let color: Vec4 = color.into();
-        self.section
-            .text
-            .iter_mut()
-            .for_each(|t| t.extra.color = color.to_array());
-        self.updated = true;
-    }
-
-    pub fn with_color(mut self, color: impl Into<Vec4>) -> Self {
-        self.set_color(color);
-        self
-    }
-
-    /// Return the bounding box for this text.
-    ///
-    /// This will return `AABB::default` until [`Rectangle::layout`] is called.
-    pub fn aabb(&self) -> AABB {
-        self.aabb
-    }
-}
-
-impl Element for Text {
-    type OutputEvent = ();
-
-    fn layout(&mut self, constraint: AABB) -> AABB {
-        use renderling::GlyphCruncher;
-        let max_size = constraint.size();
-        let max_size: (f32, f32) = max_size.into();
-        if self.section.bounds != max_size {
-            self.section.bounds = max_size;
-            self.updated = true;
-        }
-
-        if self.updated {
-            self.aabb = AABB {
-                min: constraint.min,
-                max: constraint.min,
-            };
-            if let Some(rect) = self.cache.brush.glyph_bounds(&self.section) {
-                self.aabb.max = self.aabb.min + Vec2::new(rect.width(), rect.height());
-            }
-        }
-        self.aabb
-    }
-
-    fn paint<'a, 'b: 'a>(
-        &'b mut self,
-        device: &wgpu::Device,
-        queue: &wgpu::Queue,
-    ) -> Vec<Paint<'a, 'b>> {
-        let origin = self.aabb.min;
-        if self.draw_object.is_none() {
-            self.draw_object = Some(
-                UiDrawObjectBuilder::new(device)
-                    .with_draw_mode(UiMode::TEXT)
-                    .with_position(origin)
-                    .build(),
-            );
-        }
-        let draw_obj = self.draw_object.as_mut().unwrap();
-        if self.updated {
-            self.updated = false;
-            self.cache.queue(&self.section);
-        }
-
-        let (may_vertices, may_texture) = self.cache.get_updated(device, queue);
-        if let Some(verts) = may_vertices {
-            draw_obj.set_vertices(verts);
-        }
-        if let Some(texture) = may_texture {
-            draw_obj.set_texture(&texture);
-        }
-        if origin != draw_obj.get_position() {
-            draw_obj.set_position(origin);
-        }
-
-        draw_obj.update(device, queue).unwrap();
-        vec![Paint::drawing(|render_pass, default_texture_bindgroup| {
-            draw_obj.draw(render_pass, default_texture_bindgroup);
-        })]
-    }
-
-    fn event(&mut self, _: Event) {}
-}
-
-#[derive(Clone, Copy, Debug, Default, PartialEq)]
-pub enum ButtonState {
-    #[default]
-    Normal,
-    Over,
-    Down,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum ButtonEvent {
-    Over,
-    Out,
-    Down,
-    Up,
-}
-
-pub struct Button {
-    foreground: Rectangle,
-    background: Rectangle,
-    text: Text,
-    aabb: AABB,
-    state: ButtonState,
-}
-
-impl Button {
-    const TEXT_COLOR_NORMAL: Vec4 = Vec4::new(0.1, 0.1, 0.1, 1.0);
-    const TEXT_COLOR_OVER: Vec4 = Vec4::new(0.7, 0.13, 0.13, 1.0);
-    const TEXT_COLOR_DOWN: Vec4 = Vec4::new(1.0, 0.0, 0.0, 1.0);
-    const PX_OFFSET: f32 = 8.0;
-    const PX_BORDER: f32 = 4.0;
-
-    pub fn new(font: &FontArc) -> Self {
-        let mut btn = Button {
-            foreground: Rectangle::new(),
-            background: Rectangle::new().with_color(Vec4::new(0.0, 0.0, 0.0, 0.5)),
-            text: Text::new(font)
-                .with_text("Button")
-                .with_scale(16.0)
-                .with_color(Self::TEXT_COLOR_NORMAL),
-            aabb: AABB::default(),
-            state: ButtonState::default(),
-        };
-        btn.set_normal();
-        btn
-    }
-
-    pub fn set_text(&mut self, text: impl Into<String>) {
-        self.text.set_text(text);
-    }
-
-    pub fn with_text(mut self, text: impl Into<String>) -> Self {
-        self.text.set_text(text);
-        self
-    }
-
-    pub fn get_text(&self) -> String {
-        self.text
-            .section
-            .text
-            .iter()
-            .map(|t| t.text.clone())
-            .collect::<Vec<_>>()
-            .concat()
-    }
-
-    pub fn get_text_field(&self) -> &Text {
-        &self.text
-    }
-
-    pub fn get_text_field_mut(&mut self) -> &mut Text {
-        &mut self.text
-    }
-
-    pub fn set_scale(&mut self, scale: f32) {
-        self.text.set_scale(scale)
-    }
-
-    pub fn with_scale(mut self, scale: f32) -> Self {
-        self.text.set_scale(scale);
-        self
-    }
-
-    fn set_over(&mut self) {
-        if self.state == ButtonState::Over {
-            return;
-        }
-        self.state = ButtonState::Over;
-        self.text.section.text.iter_mut().for_each(|text| {
-            *text = std::mem::take(text).with_color(Self::TEXT_COLOR_OVER);
-        });
-        self.text.updated = true;
-    }
-
-    fn set_normal(&mut self) {
-        if self.state == ButtonState::Normal {
-            return;
+        if aabb != self.aabb {
+            self.aabb = aabb;
         }
-        self.state = ButtonState::Normal;
-        self.text.section.text.iter_mut().for_each(|text| {
-            *text = std::mem::take(text).with_color(Self::TEXT_COLOR_NORMAL);
-        });
-        self.text.updated = true;
-    }
 
-    fn set_down(&mut self) {
-        if self.state == ButtonState::Down {
-            return;
-        }
-        self.state = ButtonState::Down;
-        self.text.section.text.iter_mut().for_each(|text| {
-            *text = std::mem::take(text).with_color(Self::TEXT_COLOR_DOWN);
-        });
-        self.text.updated = true;
-    }
-}
-
-impl Element for Button {
-    type OutputEvent = Option<ButtonEvent>;
-
-    fn layout(&mut self, constraint: AABB) -> AABB {
-        let border = Vec2::splat(Self::PX_BORDER);
-        let offset = Vec2::splat(Self::PX_OFFSET);
-        let down_offset = if self.state == ButtonState::Down {
-            offset * 0.5
-        } else {
-            Vec2::ZERO
-        };
-        let text_aabb = self.text.layout(AABB {
-            min: constraint.min + border + down_offset,
-            max: constraint.max,
-        });
-
-        let bg_size = text_aabb.size() + border * 2.0;
-        self.foreground.set_origin(constraint.min + down_offset);
-        self.foreground.set_size(bg_size);
-        self.background
-            .set_origin(self.foreground.aabb.min - down_offset + offset);
-        self.background.set_size(bg_size);
-
-        let fg_aabb = self.foreground.layout(constraint);
-        let bg_aabb = self.background.layout(constraint);
-        self.aabb = text_aabb.union(fg_aabb).union(bg_aabb);
         self.aabb
     }
 
-    fn paint<'a, 'b: 'a>(
-        &'b mut self,
-        device: &wgpu::Device,
-        queue: &wgpu::Queue,
-    ) -> Vec<Paint<'a, 'b>> {
-        let mut ps = vec![];
-        ps.extend(self.background.paint(device, queue));
-        ps.extend(self.foreground.paint(device, queue));
-        ps.extend(self.text.paint(device, queue));
-        ps
-    }
-
-    fn event(&mut self, event: Event) -> Option<ButtonEvent> {
-        let from_state = self.state;
-        match event {
-            Event::MouseMoved { position, is_down } => {
-                let position = Vec2::new(position.x as f32, position.y as f32);
-                if self.aabb.contains(position) {
-                    if is_down {
-                        self.set_down();
-                    } else {
-                        self.set_over();
-                    }
-                } else {
-                    self.set_normal();
-                }
-            }
-            Event::MouseButton { position, is_down } => {
-                let position = Vec2::new(position.x as f32, position.y as f32);
-                if self.aabb.contains(position) {
-                    if is_down {
-                        self.set_down();
-                    } else {
-                        self.set_over();
-                    }
-                } else {
-                    self.set_normal();
-                }
-            }
-            Event::WindowResized { .. } => {}
-        };
-        match (from_state, self.state) {
-            (ButtonState::Normal, ButtonState::Normal) => None,
-            (ButtonState::Normal, ButtonState::Over) => Some(ButtonEvent::Over),
-            (ButtonState::Normal, ButtonState::Down) => None,
-            (ButtonState::Over, ButtonState::Normal) => Some(ButtonEvent::Out),
-            (ButtonState::Over, ButtonState::Over) => None,
-            (ButtonState::Over, ButtonState::Down) => Some(ButtonEvent::Down),
-            (ButtonState::Down, ButtonState::Normal) => None,
-            (ButtonState::Down, ButtonState::Over) => Some(ButtonEvent::Up),
-            (ButtonState::Down, ButtonState::Down) => None,
-        }
-    }
-}
-
-pub struct Dropdown<T> {
-    selections: Vec<(String, T)>,
-    label_font: FontArc,
-    scale: f32,
-    is_open: bool,
-    text_label: Text,
-    button_open: Button,
-    buttons: Vec<Button>,
-}
-
-impl<T> Dropdown<T> {
-    pub fn new(label_font: &FontArc, icon_font: &FontArc) -> Self {
-        let mut dropdown = Self {
-            selections: vec![],
-            is_open: false,
-            scale: 32.0,
-            button_open: Button::new(icon_font).with_scale(32.0).with_text("  "),
-            text_label: Text::new(label_font)
-                .with_scale(32.0)
-                .with_text("No selection"),
-            buttons: vec![],
-            label_font: label_font.clone(),
-        };
-        dropdown.set_selected_index(None);
-        dropdown
-    }
-
-    pub fn get_label(&self) -> &Text {
-        &self.text_label
-    }
-
-    pub fn get_label_mut(&mut self) -> &mut Text {
-        &mut self.text_label
-    }
-
-    pub fn with_label_builder(mut self, f: impl FnOnce(&mut Text)) -> Self {
-        f(&mut self.text_label);
-        self
-    }
-
-    pub fn set_scale(&mut self, scale: f32) {
-        self.button_open.set_scale(scale);
-        self.text_label.set_scale(scale);
-        for button in self.buttons.iter_mut() {
-            button.set_scale(scale);
-        }
-    }
-
-    pub fn with_scale(mut self, scale: f32) -> Self {
-        self.set_scale(scale);
-        self
-    }
-
-    pub fn set_selections(&mut self, selections: impl IntoIterator<Item = (String, T)>) {
-        self.selections = selections.into_iter().collect();
-        self.buttons = self
-            .selections
-            .iter()
-            .map(|(name, _)| {
-                Button::new(&self.label_font)
-                    .with_scale(self.scale)
-                    .with_text(name)
-            })
-            .collect();
-        self.text_label.set_text("");
-    }
-
-    pub fn with_selections(mut self, selections: impl IntoIterator<Item = (String, T)>) -> Self {
-        self.set_selections(selections);
-        self
-    }
-
-    pub fn set_selected_index(&mut self, may_index: Option<usize>) {
-        if let Some(index) = may_index {
-            if let Some((name, _)) = self.selections.get(index) {
-                self.text_label.set_text(name);
-            }
-        } else {
-            self.text_label.set_text("No selection");
-        }
-    }
-
-    pub fn with_selected_index(mut self, may_index: Option<usize>) -> Self {
-        self.set_selected_index(may_index);
-        self
-    }
-}
-
-pub enum DropdownEvent<T> {
-    Selected(T),
+    fn event(&mut self, _event: Event) {}
 }
 
-impl<T: Clone> Element for Dropdown<T> {
-    type OutputEvent = Option<DropdownEvent<T>>;
-
-    fn layout(&mut self, mut constraint: AABB) -> AABB {
-        let spacing = 4.0;
-
-        let btn_aabb = self.button_open.layout(constraint);
-
-        constraint.min.x += btn_aabb.max.x + spacing;
-        let label_aabb = self.text_label.layout(constraint);
-
-        let mut out = btn_aabb.union(label_aabb);
-        if self.is_open {
-            constraint.min.y = out.max.y + spacing;
-            for button in self.buttons.iter_mut() {
-                out.add(button.layout(constraint));
-                constraint.min.y = out.max.y + spacing;
-            }
-        }
-        out
-    }
-
-    fn paint<'a, 'b: 'a>(
-        &'b mut self,
-        device: &wgpu::Device,
-        queue: &wgpu::Queue,
-    ) -> Vec<Paint<'a, 'b>> {
-        let mut ps = self.button_open.paint(device, queue);
-        ps.extend(self.text_label.paint(device, queue));
-        if self.is_open {
-            for button in self.buttons.iter_mut() {
-                ps.extend(button.paint(device, queue));
-            }
-        }
-        ps
-    }
-
-    fn event(&mut self, event: Event) -> Self::OutputEvent {
-        match self.button_open.event(event) {
-            Some(ev) => match ev {
-                ButtonEvent::Over => {}
-                ButtonEvent::Out => {}
-                ButtonEvent::Down => {
-                    self.is_open = !self.is_open;
-                }
-                ButtonEvent::Up => {}
-            },
-            None => {}
-        }
-
-        if self.is_open {
-            let may_selected: Option<(usize, T)> = self
-                .buttons
-                .iter_mut()
-                .zip(self.selections.iter())
-                .enumerate()
-                .find_map(|(i, (button, (_, t)))| {
-                    button.event(event).map(|ev| {
-                        if let ButtonEvent::Down = ev {
-                            Some((i, t.clone()))
-                        } else {
-                            None
-                        }
-                    })?
-                });
-            if let Some((i, t)) = may_selected {
-                self.set_selected_index(Some(i));
-                self.is_open = false;
-                return Some(DropdownEvent::Selected(t));
-            }
-        }
-        None
-    }
-}
+//pub struct Text {
+//    cache: GlyphCache,
+//    section: OwnedSection,
+//    aabb: AABB,
+//    updated: bool,
+//    draw_object: Option<UiDrawObject>,
+//}
+//
+//impl Text {
+//    pub fn new(font: &FontArc) -> Self {
+//        let cache = GlyphCache::new(vec![font.clone()]);
+//        Text {
+//            section:
+// OwnedSection::default().add_text(OwnedText::new("").with_scale(12.0)),
+//            cache,
+//            aabb: AABB::default(),
+//            updated: true,
+//            draw_object: None,
+//        }
+//    }
+//
+//    pub fn set_font(&mut self, font: FontArc) {
+//        self.cache = GlyphCache::new(vec![font]);
+//        self.updated = true;
+//    }
+//
+//    pub fn with_font(mut self, font: FontArc) -> Self {
+//        self.set_font(font);
+//        self
+//    }
+//
+//    pub fn set_text(&mut self, text: impl Into<String>) {
+//        self.section.text.resize_with(1, Default::default);
+//        self.section.text[0].text = text.into();
+//        self.updated = true;
+//    }
+//
+//    pub fn with_text(mut self, text: impl Into<String>) -> Self {
+//        self.set_text(text);
+//        self
+//    }
+//
+//    pub fn set_scale(&mut self, scale: f32) {
+//        self.section
+//            .text
+//            .iter_mut()
+//            .for_each(|t| t.scale = scale.into());
+//        self.updated = true;
+//    }
+//
+//    pub fn with_scale(mut self, scale: f32) -> Self {
+//        self.set_scale(scale);
+//        self
+//    }
+//
+//    pub fn set_color(&mut self, color: impl Into<Vec4>) {
+//        let color: Vec4 = color.into();
+//        self.section
+//            .text
+//            .iter_mut()
+//            .for_each(|t| t.extra.color = color.to_array());
+//        self.updated = true;
+//    }
+//
+//    pub fn with_color(mut self, color: impl Into<Vec4>) -> Self {
+//        self.set_color(color);
+//        self
+//    }
+//
+//    /// Return the bounding box for this text.
+//    ///
+//    /// This will return `AABB::default` until [`Rectangle::layout`] is
+// called.    pub fn aabb(&self) -> AABB {
+//        self.aabb
+//    }
+//}
+//
+//impl Element for Text {
+//    type OutputEvent = ();
+//
+//    fn layout(&mut self, constraint: AABB) -> AABB {
+//        use renderling::GlyphCruncher;
+//        let max_size = constraint.size();
+//        let max_size: (f32, f32) = max_size.into();
+//        if self.section.bounds != max_size {
+//            self.section.bounds = max_size;
+//            self.updated = true;
+//        }
+//
+//        if self.updated {
+//            self.aabb = AABB {
+//                min: constraint.min,
+//                max: constraint.min,
+//            };
+//            if let Some(rect) = self.cache.brush.glyph_bounds(&self.section) {
+//                self.aabb.max = self.aabb.min + Vec2::new(rect.width(),
+// rect.height());            }
+//        }
+//        self.aabb
+//    }
+//
+//    fn paint<'a, 'b: 'a>(
+//        &'b mut self,
+//        device: &wgpu::Device,
+//        queue: &wgpu::Queue,
+//    ) -> Vec<Paint<'a, 'b>> {
+//        let origin = self.aabb.min;
+//        if self.draw_object.is_none() {
+//            self.draw_object = Some(
+//                UiDrawObjectBuilder::new(device)
+//                    .with_draw_mode(UiMode::TEXT)
+//                    .with_position(origin)
+//                    .build(),
+//            );
+//        }
+//        let draw_obj = self.draw_object.as_mut().unwrap();
+//        if self.updated {
+//            self.updated = false;
+//            self.cache.queue(&self.section);
+//        }
+//
+//        let (may_vertices, may_texture) = self.cache.get_updated(device,
+// queue);        if let Some(verts) = may_vertices {
+//            draw_obj.set_vertices(verts);
+//        }
+//        if let Some(texture) = may_texture {
+//            draw_obj.set_texture(&texture);
+//        }
+//        if origin != draw_obj.get_position() {
+//            draw_obj.set_position(origin);
+//        }
+//
+//        draw_obj.update(device, queue).unwrap();
+//        vec![Paint::drawing(|render_pass, default_texture_bindgroup| {
+//            draw_obj.draw(render_pass, default_texture_bindgroup);
+//        })]
+//    }
+//
+//    fn event(&mut self, _: Event) {}
+//}
+//
+//#[derive(Clone, Copy, Debug, Default, PartialEq)]
+//pub enum ButtonState {
+//    #[default]
+//    Normal,
+//    Over,
+//    Down,
+//}
+//
+//#[derive(Clone, Copy, Debug, PartialEq)]
+//pub enum ButtonEvent {
+//    Over,
+//    Out,
+//    Down,
+//    Up,
+//}
+//
+//pub struct Button {
+//    foreground: Rectangle,
+//    background: Rectangle,
+//    text: Text,
+//    aabb: AABB,
+//    state: ButtonState,
+//}
+//
+//impl Button {
+//    const TEXT_COLOR_NORMAL: Vec4 = Vec4::new(0.1, 0.1, 0.1, 1.0);
+//    const TEXT_COLOR_OVER: Vec4 = Vec4::new(0.7, 0.13, 0.13, 1.0);
+//    const TEXT_COLOR_DOWN: Vec4 = Vec4::new(1.0, 0.0, 0.0, 1.0);
+//    const PX_OFFSET: f32 = 8.0;
+//    const PX_BORDER: f32 = 4.0;
+//
+//    pub fn new(font: &FontArc) -> Self {
+//        let mut btn = Button {
+//            foreground: Rectangle::new(),
+//            background: Rectangle::new().with_color(Vec4::new(0.0, 0.0, 0.0,
+// 0.5)),            text: Text::new(font)
+//                .with_text("Button")
+//                .with_scale(16.0)
+//                .with_color(Self::TEXT_COLOR_NORMAL),
+//            aabb: AABB::default(),
+//            state: ButtonState::default(),
+//        };
+//        btn.set_normal();
+//        btn
+//    }
+//
+//    pub fn set_text(&mut self, text: impl Into<String>) {
+//        self.text.set_text(text);
+//    }
+//
+//    pub fn with_text(mut self, text: impl Into<String>) -> Self {
+//        self.text.set_text(text);
+//        self
+//    }
+//
+//    pub fn get_text(&self) -> String {
+//        self.text
+//            .section
+//            .text
+//            .iter()
+//            .map(|t| t.text.clone())
+//            .collect::<Vec<_>>()
+//            .concat()
+//    }
+//
+//    pub fn get_text_field(&self) -> &Text {
+//        &self.text
+//    }
+//
+//    pub fn get_text_field_mut(&mut self) -> &mut Text {
+//        &mut self.text
+//    }
+//
+//    pub fn set_scale(&mut self, scale: f32) {
+//        self.text.set_scale(scale)
+//    }
+//
+//    pub fn with_scale(mut self, scale: f32) -> Self {
+//        self.text.set_scale(scale);
+//        self
+//    }
+//
+//    fn set_over(&mut self) {
+//        if self.state == ButtonState::Over {
+//            return;
+//        }
+//        self.state = ButtonState::Over;
+//        self.text.section.text.iter_mut().for_each(|text| {
+//            *text = std::mem::take(text).with_color(Self::TEXT_COLOR_OVER);
+//        });
+//        self.text.updated = true;
+//    }
+//
+//    fn set_normal(&mut self) {
+//        if self.state == ButtonState::Normal {
+//            return;
+//        }
+//        self.state = ButtonState::Normal;
+//        self.text.section.text.iter_mut().for_each(|text| {
+//            *text = std::mem::take(text).with_color(Self::TEXT_COLOR_NORMAL);
+//        });
+//        self.text.updated = true;
+//    }
+//
+//    fn set_down(&mut self) {
+//        if self.state == ButtonState::Down {
+//            return;
+//        }
+//        self.state = ButtonState::Down;
+//        self.text.section.text.iter_mut().for_each(|text| {
+//            *text = std::mem::take(text).with_color(Self::TEXT_COLOR_DOWN);
+//        });
+//        self.text.updated = true;
+//    }
+//}
+//
+//impl Element for Button {
+//    type OutputEvent = Option<ButtonEvent>;
+//
+//    fn layout(&mut self, constraint: AABB) -> AABB {
+//        let border = Vec2::splat(Self::PX_BORDER);
+//        let offset = Vec2::splat(Self::PX_OFFSET);
+//        let down_offset = if self.state == ButtonState::Down {
+//            offset * 0.5
+//        } else {
+//            Vec2::ZERO
+//        };
+//        let text_aabb = self.text.layout(AABB {
+//            min: constraint.min + border + down_offset,
+//            max: constraint.max,
+//        });
+//
+//        let bg_size = text_aabb.size() + border * 2.0;
+//        self.foreground.set_origin(constraint.min + down_offset);
+//        self.foreground.set_size(bg_size);
+//        self.background
+//            .set_origin(self.foreground.aabb.min - down_offset + offset);
+//        self.background.set_size(bg_size);
+//
+//        let fg_aabb = self.foreground.layout(constraint);
+//        let bg_aabb = self.background.layout(constraint);
+//        self.aabb = text_aabb.union(fg_aabb).union(bg_aabb);
+//        self.aabb
+//    }
+//
+//    fn paint<'a, 'b: 'a>(
+//        &'b mut self,
+//        device: &wgpu::Device,
+//        queue: &wgpu::Queue,
+//    ) -> Vec<Paint<'a, 'b>> {
+//        let mut ps = vec![];
+//        ps.extend(self.background.paint(device, queue));
+//        ps.extend(self.foreground.paint(device, queue));
+//        ps.extend(self.text.paint(device, queue));
+//        ps
+//    }
+//
+//    fn event(&mut self, event: Event) -> Option<ButtonEvent> {
+//        let from_state = self.state;
+//        match event {
+//            Event::MouseMoved { position, is_down } => {
+//                let position = Vec2::new(position.x as f32, position.y as
+// f32);                if self.aabb.contains(position) {
+//                    if is_down {
+//                        self.set_down();
+//                    } else {
+//                        self.set_over();
+//                    }
+//                } else {
+//                    self.set_normal();
+//                }
+//            }
+//            Event::MouseButton { position, is_down } => {
+//                let position = Vec2::new(position.x as f32, position.y as
+// f32);                if self.aabb.contains(position) {
+//                    if is_down {
+//                        self.set_down();
+//                    } else {
+//                        self.set_over();
+//                    }
+//                } else {
+//                    self.set_normal();
+//                }
+//            }
+//            Event::WindowResized { .. } => {}
+//        };
+//        match (from_state, self.state) {
+//            (ButtonState::Normal, ButtonState::Normal) => None,
+//            (ButtonState::Normal, ButtonState::Over) =>
+// Some(ButtonEvent::Over),            (ButtonState::Normal, ButtonState::Down)
+// => None,            (ButtonState::Over, ButtonState::Normal) =>
+// Some(ButtonEvent::Out),            (ButtonState::Over, ButtonState::Over) =>
+// None,            (ButtonState::Over, ButtonState::Down) =>
+// Some(ButtonEvent::Down),            (ButtonState::Down, ButtonState::Normal)
+// => None,            (ButtonState::Down, ButtonState::Over) =>
+// Some(ButtonEvent::Up),            (ButtonState::Down, ButtonState::Down) =>
+// None,        }
+//    }
+//}
+//
+//pub struct Dropdown<T> {
+//    selections: Vec<(String, T)>,
+//    label_font: FontArc,
+//    scale: f32,
+//    is_open: bool,
+//    text_label: Text,
+//    button_open: Button,
+//    buttons: Vec<Button>,
+//}
+//
+//impl<T> Dropdown<T> {
+//    pub fn new(label_font: &FontArc, icon_font: &FontArc) -> Self {
+//        let mut dropdown = Self {
+//            selections: vec![],
+//            is_open: false,
+//            scale: 32.0,
+//            button_open: Button::new(icon_font).with_scale(32.0).with_text(" 
+// "),            text_label: Text::new(label_font)
+//                .with_scale(32.0)
+//                .with_text("No selection"),
+//            buttons: vec![],
+//            label_font: label_font.clone(),
+//        };
+//        dropdown.set_selected_index(None);
+//        dropdown
+//    }
+//
+//    pub fn get_label(&self) -> &Text {
+//        &self.text_label
+//    }
+//
+//    pub fn get_label_mut(&mut self) -> &mut Text {
+//        &mut self.text_label
+//    }
+//
+//    pub fn with_label_builder(mut self, f: impl FnOnce(&mut Text)) -> Self {
+//        f(&mut self.text_label);
+//        self
+//    }
+//
+//    pub fn set_scale(&mut self, scale: f32) {
+//        self.button_open.set_scale(scale);
+//        self.text_label.set_scale(scale);
+//        for button in self.buttons.iter_mut() {
+//            button.set_scale(scale);
+//        }
+//    }
+//
+//    pub fn with_scale(mut self, scale: f32) -> Self {
+//        self.set_scale(scale);
+//        self
+//    }
+//
+//    pub fn set_selections(&mut self, selections: impl IntoIterator<Item =
+// (String, T)>) {        self.selections = selections.into_iter().collect();
+//        self.buttons = self
+//            .selections
+//            .iter()
+//            .map(|(name, _)| {
+//                Button::new(&self.label_font)
+//                    .with_scale(self.scale)
+//                    .with_text(name)
+//            })
+//            .collect();
+//        self.text_label.set_text("");
+//    }
+//
+//    pub fn with_selections(mut self, selections: impl IntoIterator<Item =
+// (String, T)>) -> Self {        self.set_selections(selections);
+//        self
+//    }
+//
+//    pub fn set_selected_index(&mut self, may_index: Option<usize>) {
+//        if let Some(index) = may_index {
+//            if let Some((name, _)) = self.selections.get(index) {
+//                self.text_label.set_text(name);
+//            }
+//        } else {
+//            self.text_label.set_text("No selection");
+//        }
+//    }
+//
+//    pub fn with_selected_index(mut self, may_index: Option<usize>) -> Self {
+//        self.set_selected_index(may_index);
+//        self
+//    }
+//}
+//
+//pub enum DropdownEvent<T> {
+//    Selected(T),
+//}
+//
+//impl<T: Clone> Element for Dropdown<T> {
+//    type OutputEvent = Option<DropdownEvent<T>>;
+//
+//    fn layout(&mut self, mut constraint: AABB) -> AABB {
+//        let spacing = 4.0;
+//
+//        let btn_aabb = self.button_open.layout(constraint);
+//
+//        constraint.min.x += btn_aabb.max.x + spacing;
+//        let label_aabb = self.text_label.layout(constraint);
+//
+//        let mut out = btn_aabb.union(label_aabb);
+//        if self.is_open {
+//            constraint.min.y = out.max.y + spacing;
+//            for button in self.buttons.iter_mut() {
+//                out.add(button.layout(constraint));
+//                constraint.min.y = out.max.y + spacing;
+//            }
+//        }
+//        out
+//    }
+//
+//    fn paint<'a, 'b: 'a>(
+//        &'b mut self,
+//        device: &wgpu::Device,
+//        queue: &wgpu::Queue,
+//    ) -> Vec<Paint<'a, 'b>> {
+//        let mut ps = self.button_open.paint(device, queue);
+//        ps.extend(self.text_label.paint(device, queue));
+//        if self.is_open {
+//            for button in self.buttons.iter_mut() {
+//                ps.extend(button.paint(device, queue));
+//            }
+//        }
+//        ps
+//    }
+//
+//    fn event(&mut self, event: Event) -> Self::OutputEvent {
+//        match self.button_open.event(event) {
+//            Some(ev) => match ev {
+//                ButtonEvent::Over => {}
+//                ButtonEvent::Out => {}
+//                ButtonEvent::Down => {
+//                    self.is_open = !self.is_open;
+//                }
+//                ButtonEvent::Up => {}
+//            },
+//            None => {}
+//        }
+//
+//        if self.is_open {
+//            let may_selected: Option<(usize, T)> = self
+//                .buttons
+//                .iter_mut()
+//                .zip(self.selections.iter())
+//                .enumerate()
+//                .find_map(|(i, (button, (_, t)))| {
+//                    button.event(event).map(|ev| {
+//                        if let ButtonEvent::Down = ev {
+//                            Some((i, t.clone()))
+//                        } else {
+//                            None
+//                        }
+//                    })?
+//                });
+//            if let Some((i, t)) = may_selected {
+//                self.set_selected_index(Some(i));
+//                self.is_open = false;
+//                return Some(DropdownEvent::Selected(t));
+//            }
+//        }
+//        None
+//    }
+//}
diff --git a/crates/renderling-gpui/src/lib.rs b/crates/renderling-gpui/src/lib.rs
index 28bb2e4f..46a91049 100644
--- a/crates/renderling-gpui/src/lib.rs
+++ b/crates/renderling-gpui/src/lib.rs
@@ -1,18 +1,29 @@
 //! GPU user interface.
+use crabslab::{GrowableSlab, Slab, SlabItem};
 use snafu::prelude::*;
-use std::sync::Arc;
+use std::{
+    ops::{Deref, DerefMut},
+    sync::Arc,
+};
 
 use renderling::{
-    frame::FrameTextureView, Device, FontArc, Frame, GlyphCache, Id, OwnedSection, OwnedText,
-    Queue, RenderTarget, Renderling, UiDrawObject, UiDrawObjectBuilder, UiMode, UiRenderPipeline,
-    UiScene, UiSceneError, UiVertex, View, ViewMut, WgpuStateError,
+    shader::stage::{Camera, RenderUnit},
+    Device, Frame, Id, Queue, RenderTarget, Renderling, Stage, View, ViewMut, WgpuStateError,
 };
 
+/*
+UiDrawObject,
+UiDrawObjectBuilder, UiMode, UiRenderPipeline, UiScene, UiSceneError, UiVertex,
+*/
+
 pub use renderling::math::{UVec2, Vec2, Vec4};
 
 mod elements;
 pub use elements::*;
 
+mod text;
+pub use text::*;
+
 #[derive(Debug, Snafu)]
 pub enum GpuiError {}
 
@@ -177,48 +188,16 @@ impl EventState {
     }
 }
 
-pub enum Paint<'a, 'b> {
-    Drawing(Box<dyn FnOnce(&mut wgpu::RenderPass<'a>, &'a wgpu::BindGroup) + 'b>),
-    Overlay(Box<dyn FnOnce(&mut wgpu::RenderPass<'a>, &'a wgpu::BindGroup) + 'b>),
-}
-
-impl<'a, 'b> Paint<'a, 'b> {
-    pub fn drawing(f: impl FnOnce(&mut wgpu::RenderPass<'a>, &'a wgpu::BindGroup) + 'b) -> Self {
-        Paint::Drawing(Box::new(f))
-    }
-
-    pub fn overlay(f: impl FnOnce(&mut wgpu::RenderPass<'a>, &'a wgpu::BindGroup) + 'b) -> Self {
-        Paint::Overlay(Box::new(f))
-    }
-
-    fn draw(
-        self,
-        render_pass: &mut wgpu::RenderPass<'a>,
-        default_texture_bindgroup: &'a wgpu::BindGroup,
-    ) {
-        (match self {
-            Paint::Drawing(f) => f,
-            Paint::Overlay(f) => f,
-        })(render_pass, default_texture_bindgroup)
-    }
-}
-
 /// Implemented by every user interface element.
 pub trait Element {
     type OutputEvent;
-
-    /// Layout the element within the constraining bounding box, returning the
+    /// Update the element within the constraining bounding box, returning the
     /// element's actual bounding box.
-    fn layout(&mut self, constraint: AABB) -> AABB;
-
-    /// 'Paint' the element into the given render pass.
-    fn paint<'a, 'b: 'a>(
-        &'b mut self,
-        device: &wgpu::Device,
-        queue: &wgpu::Queue,
-        // render_pass: &mut wgpu::RenderPass<'a>,
-        // default_texture_bindgroup: &'a wgpu::BindGroup,
-    ) -> Vec<Paint<'a, 'b>>;
+    ///
+    /// The element is responsible for updating its own state on the GPU
+    /// and the state of its children.
+    fn update(&mut self, gpui: &mut Gpui, constraint: AABB) -> AABB;
+    //fn delete(self, gpui: &mut Gpui);
 
     /// Handle a global event and react with a local event.
     fn event(&mut self, event: Event) -> Self::OutputEvent;
@@ -227,223 +206,119 @@ pub trait Element {
 impl<A: Element, B: Element> Element for (A, B) {
     type OutputEvent = (A::OutputEvent, B::OutputEvent);
 
-    fn layout(&mut self, constraint: AABB) -> AABB {
+    fn update(&mut self, gpui: &mut Gpui, constraint: AABB) -> AABB {
         let mut aabb = AABB::default();
-        aabb = aabb.union(self.0.layout(constraint));
-        aabb = aabb.union(self.1.layout(constraint));
+        aabb = aabb.union(self.0.update(gpui, constraint));
+        aabb = aabb.union(self.1.update(gpui, constraint));
         aabb
     }
 
-    fn paint<'a, 'b: 'a>(
-        &'b mut self,
-        device: &wgpu::Device,
-        queue: &wgpu::Queue,
-        // render_pass: &mut wgpu::RenderPass<'a>,
-        // default_texture_bindgroup: &'a wgpu::BindGroup,
-    ) -> Vec<Paint<'a, 'b>> {
-        let mut ps = self.0.paint(device, queue);
-        ps.extend(self.1.paint(device, queue));
-        ps
-    }
-
     fn event(&mut self, event: Event) -> Self::OutputEvent {
         (self.0.event(event), self.1.event(event))
     }
 }
 
-type RenderParams = (
-    View<Device>,
-    View<Queue>,
-    View<UiScene>,
-    View<UiRenderPipeline>,
-    View<FrameTextureView>,
-);
+/// Helper for writing new interface elements.
+struct ElementUpdates {
+    writes: Vec<(usize, Vec<u32>)>,
+}
+
+impl ElementUpdates {
+    pub fn write<T: Default + SlabItem>(&mut self, id: Id<T>, t: &T) {
+        self.writes.push((id.index(), {
+            let mut v = vec![0; T::slab_size()];
+            let _index = v.write_indexed(t, 0);
+            v
+        }))
+    }
+
+    pub fn apply(&mut self, slab: &mut impl Slab) {
+        for (index, data) in std::mem::take(&mut self.writes).into_iter() {
+            let _ = slab.write_indexed_slice(data.as_slice(), index);
+        }
+    }
+}
 
 /// User interface renderer.
-pub struct Gpui(pub Renderling);
+pub struct Gpui {
+    pub stage: Stage,
+    pub renderling: Renderling,
+    pub fonts: Vec<FontArc>,
+    pub camera: Id<Camera>,
+}
 
-impl Gpui {
-    /// Create a new UI renderer.
-    pub fn new(width: u32, height: u32) -> Self {
-        let r = Renderling::headless(width, height);
-        Self::new_from(&r)
-    }
-
-    /// Create a new UI renderer linked to the device and queue of another
-    /// [`Renderling`].
-    pub fn new_from(r: &renderling::Renderling) -> Self {
-        let adapter = r.get_adapter_owned();
-        let (device, queue) = r.get_device_and_queue_owned();
-        let (width, height) = r.get_screen_size();
-        let target = RenderTarget::Texture {
-            texture: device
-                .create_texture(&wgpu::TextureDescriptor {
-                    size: wgpu::Extent3d {
-                        width,
-                        height,
-                        depth_or_array_layers: 1,
-                    },
-                    mip_level_count: 1,
-                    sample_count: 1,
-                    dimension: wgpu::TextureDimension::D2,
-                    format: wgpu::TextureFormat::Rgba8UnormSrgb,
-                    usage: wgpu::TextureUsages::COPY_SRC
-                        | wgpu::TextureUsages::RENDER_ATTACHMENT
-                        | wgpu::TextureUsages::TEXTURE_BINDING,
-                    label: None,
-                    view_formats: &[],
-                })
-                .into(),
-        };
-        let depth_texture = renderling::Texture::create_depth_texture(&device, width, height);
-        let mut r = Renderling::new(
-            target,
-            depth_texture,
-            adapter.0.clone(),
-            device.0.clone(),
-            queue.0.clone(),
-            (width, height),
-        );
+impl Deref for Gpui {
+    type Target = Renderling;
 
-        r.graph.add_resource({
-            let fonts: Vec<FontArc> = vec![];
-            fonts
-        });
-        let scene = r.new_ui_scene().with_canvas_size(width, height).build();
-        r.graph.add_resource(scene);
+    fn deref(&self) -> &Self::Target {
+        &self.renderling
+    }
+}
 
-        let pipeline = renderling::UiRenderPipeline(
-            r.graph
-                .visit(|(device, target): (View<Device>, View<RenderTarget>)| {
-                    renderling::create_ui_pipeline(&device, target.format())
-                })
-                .unwrap(),
-        );
-        r.graph.add_resource(pipeline);
+impl DerefMut for Gpui {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.renderling
+    }
+}
 
-        fn update_scene(
-            (mut scene, device, queue): (ViewMut<UiScene>, View<Device>, View<Queue>),
-        ) -> Result<(), WgpuStateError> {
-            scene.update(&device, &queue, []).unwrap();
-            Ok(())
-        }
+impl crabslab::Slab for Gpui {
+    fn len(&self) -> usize {
+        self.stage.len()
+    }
 
-        use renderling::{
-            frame::{clear_frame_and_depth, create_frame},
-            graph, Graph,
-        };
-        r.graph
-            .add_subgraph(graph!(create_frame, clear_frame_and_depth, update_scene));
-        r.graph.add_barrier();
-        r.graph.add_local::<RenderParams, ()>("render");
-        Self(r)
+    fn read<T: crabslab::SlabItem + Default>(&self, id: Id<T>) -> T {
+        self.stage.read(id)
     }
 
-    /// Resize the interface's "surface" texture.
-    ///
-    /// Returns the new interface texture.
-    pub fn resize(&mut self, width: u32, height: u32) -> renderling::Texture {
-        self.0.resize(width, height);
-        self.0
-            .graph
-            .visit(|mut ui_scene: ViewMut<UiScene>| {
-                ui_scene.set_canvas_size(width, height);
-            })
-            .unwrap();
-        let wgpu_tex = self.get_frame_texture();
-        self.0.texture_from_wgpu_tex(wgpu_tex, None)
+    fn write_indexed<T: crabslab::SlabItem>(&mut self, t: &T, index: usize) -> usize {
+        self.stage.write_indexed(t, index)
     }
 
-    pub fn set_background_color(&mut self, color: impl Into<Vec4>) {
-        self.0.set_background_color(color)
+    fn write_indexed_slice<T: crabslab::SlabItem>(&mut self, t: &[T], index: usize) -> usize {
+        self.stage.write_indexed_slice(t, index)
     }
+}
 
-    pub fn with_background_color(mut self, color: impl Into<Vec4>) -> Self {
-        self.set_background_color(color);
-        self
+impl crabslab::GrowableSlab for Gpui {
+    fn capacity(&self) -> usize {
+        self.stage.capacity()
     }
 
-    /// Render to an image.
-    pub fn render_image(&mut self, root: &mut impl Element) -> image::DynamicImage {
-        self.render_image_with_srgb(root, false)
-    }
-
-    /// Render to an image.
-    pub fn render_image_srgb(&mut self, root: &mut impl Element) -> image::DynamicImage {
-        self.render_image_with_srgb(root, true)
-    }
-
-    /// Render to an image.
-    pub fn render_image_with_srgb(
-        &mut self,
-        root: &mut impl Element,
-        as_srgb: bool,
-    ) -> image::DynamicImage {
-        self.render(root);
-        let (width, height) = self.0.get_screen_size();
-        let frame = self.0.graph.remove_resource::<Frame>().unwrap().unwrap();
-        let device = self.0.get_device();
-        let buffer = frame.copy_to_buffer(device, self.0.get_queue(), width, height);
-        if as_srgb {
-            // pack as srgb8
-            buffer.into_image::<image::Rgba<u8>>(device).unwrap().into()
-        } else {
-            // pack as linear rgba8
-            buffer.into_rgba(device).unwrap().into()
-        }
+    fn reserve_capacity(&mut self, capacity: usize) {
+        self.stage.reserve_capacity(capacity)
     }
 
-    /// Layout the root element with the internal screen size.
-    pub fn layout(&self, root: &mut impl Element) {
-        let (ww, wh) = self.0.get_screen_size();
-        let _ = root.layout(AABB {
-            min: Vec2::ZERO,
-            max: Vec2::new(ww as f32, wh as f32),
-        });
+    fn increment_len(&mut self, n: usize) -> usize {
+        self.stage.increment_len(n)
     }
+}
 
-    /// Render to the internal texture.
-    pub fn render(&mut self, root: &mut impl Element) {
-        let _ = self.0.graph.remove_resource::<Frame>();
-
-        self.0.graph.run_with_local(
-            |(device, queue, scene, pipeline, frame): RenderParams| -> Result<(), UiSceneError> {
-                let label = Some("gpui scene render");
-                let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label });
-                let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-                    label,
-                    color_attachments: &[Some(wgpu::RenderPassColorAttachment {
-                        view: &frame,
-                        resolve_target: None,
-                        ops: wgpu::Operations {
-                            load: wgpu::LoadOp::Load,
-                            store: wgpu::StoreOp::Store,
-                        },
-                    })],
-                    depth_stencil_attachment: None,
-                });
-                render_pass.set_pipeline(&pipeline.0);
-                render_pass.set_bind_group(0, scene.constants_bindgroup(), &[]);
-
-                let paintings = root.paint(
-                    &device,
-                    &queue,
-                    //&mut render_pass,
-                    //scene.default_texture_bindgroup()
-                );
-
-                let (paintings, overlaid_paintings): (Vec<_>, Vec<_>) = paintings.into_iter().partition(|p| match p {
-                    Paint::Drawing(_) => true,
-                    Paint::Overlay(_) => false,
-                });
-
-                paintings.into_iter().for_each(|p| p.draw(&mut render_pass, scene.default_texture_bindgroup()));
-                overlaid_paintings.into_iter().for_each(|p| p.draw(&mut render_pass, scene.default_texture_bindgroup()));
-
-                drop(render_pass);
-                queue.submit(std::iter::once(encoder.finish()));
-                Ok(())
-        }).unwrap();
+impl Gpui {
+    /// Create a new UI renderer.
+    pub fn new(width: u32, height: u32) -> Self {
+        let mut r = Renderling::headless(width, height);
+        let mut stage = r.new_stage();
+        stage.configure_graph(&mut r, true);
+        let (projection, view) = renderling::default_ortho2d(width as f32, height as f32);
+        let camera = stage.append(&Camera::new(projection, view));
+        Gpui {
+            stage,
+            renderling: r,
+            fonts: vec![],
+            camera,
+        }
+    }
+
+    /// Layout the root element with the internal screen size.
+    pub fn layout(&mut self, root: &mut impl Element) {
+        let (ww, wh) = self.renderling.get_screen_size();
+        let _ = root.update(
+            self,
+            AABB {
+                min: Vec2::ZERO,
+                max: Vec2::new(ww as f32, wh as f32),
+            },
+        );
     }
 
     /// Get a clone of the internal render target texture.
@@ -458,24 +333,12 @@ impl Gpui {
     }
 
     fn get_fonts(&self) -> &[FontArc] {
-        let fonts = self
-            .0
-            .graph
-            .get_resource::<Vec<FontArc>>()
-            .unwrap()
-            .unwrap();
-        &fonts
+        &self.fonts
     }
 
     pub fn add_font(&mut self, font: FontArc) -> Id<FontArc> {
-        let fonts = self
-            .0
-            .graph
-            .get_resource_mut::<Vec<FontArc>>()
-            .unwrap()
-            .unwrap();
-        let id = Id::new(fonts.len() as u32);
-        fonts.push(font);
+        let id = Id::new(self.fonts.len() as u32);
+        self.fonts.push(font);
         id
     }
 
@@ -528,11 +391,14 @@ mod test {
         let mut ui = Gpui::new(50, 50);
         ui.set_background_color(Vec4::new(0.0, 0.0, 0.0, 1.0));
         let mut rect = ui.new_rectangle().with_color(Vec4::ONE);
-        rect.layout(AABB {
-            min: Vec2::ZERO,
-            max: Vec2::new(25.0, 25.0),
-        });
-        let img = ui.render_image(&mut rect);
+        rect.layout(
+            &mut ui,
+            AABB {
+                min: Vec2::ZERO,
+                max: Vec2::new(25.0, 25.0),
+            },
+        );
+        let img = ui.render_image().unwrap();
         img_diff::assert_img_eq("gpui_rectangle.png", img);
         rect.set_color(Vec4::new(1.0, 0.0, 0.0, 1.0));
         let img = ui.render_image(&mut rect);
diff --git a/crates/renderling-gpui/src/text.rs b/crates/renderling-gpui/src/text.rs
new file mode 100644
index 00000000..8be21daa
--- /dev/null
+++ b/crates/renderling-gpui/src/text.rs
@@ -0,0 +1,293 @@
+//! Text rasterizing capabilities.
+use std::{
+    borrow::Cow,
+    ops::{Deref, DerefMut},
+};
+
+use ::ab_glyph::Rect;
+use glyph_brush::*;
+
+pub use ::ab_glyph::FontArc;
+use glyph_brush::{GlyphCruncher, Section};
+
+use renderling::{shader::stage::Vertex, Texture};
+
+/// A text cache maintained mostly by ab_glyph.
+pub struct Cache {
+    pub(crate) texture: Texture,
+}
+
+impl Cache {
+    pub fn new(device: &wgpu::Device, width: u32, height: u32) -> Cache {
+        let texture = device.create_texture(&wgpu::TextureDescriptor {
+            label: Some("systems::text::cache::Cache"),
+            size: wgpu::Extent3d {
+                width,
+                height,
+                depth_or_array_layers: 1,
+            },
+            dimension: wgpu::TextureDimension::D2,
+            format: wgpu::TextureFormat::R8Unorm,
+            usage: wgpu::TextureUsages::COPY_SRC
+                | wgpu::TextureUsages::COPY_DST
+                | wgpu::TextureUsages::TEXTURE_BINDING,
+            mip_level_count: 1,
+            sample_count: 1,
+            view_formats: &[],
+        });
+
+        let texture = Texture::from_wgpu_tex(
+            device,
+            texture,
+            Some(wgpu::SamplerDescriptor {
+                address_mode_u: wgpu::AddressMode::ClampToEdge,
+                address_mode_v: wgpu::AddressMode::ClampToEdge,
+                address_mode_w: wgpu::AddressMode::ClampToEdge,
+                mag_filter: wgpu::FilterMode::Nearest,
+                min_filter: wgpu::FilterMode::Nearest,
+                mipmap_filter: wgpu::FilterMode::Nearest,
+                ..Default::default()
+            }),
+            None,
+        );
+
+        Cache { texture }
+    }
+
+    pub fn update(&mut self, queue: &wgpu::Queue, offset: [u16; 2], size: [u16; 2], data: &[u8]) {
+        let width = size[0] as usize;
+        let height = size[1] as usize;
+
+        queue.write_texture(
+            wgpu::ImageCopyTexture {
+                texture: &self.texture.texture,
+                mip_level: 0,
+                origin: wgpu::Origin3d {
+                    x: u32::from(offset[0]),
+                    y: u32::from(offset[1]),
+                    z: 0,
+                },
+                aspect: wgpu::TextureAspect::All,
+            },
+            &data,
+            wgpu::ImageDataLayout {
+                offset: 0,
+                bytes_per_row: Some(width as u32),
+                rows_per_image: Some(height as u32),
+            },
+            wgpu::Extent3d {
+                width: size[0] as u32,
+                height: size[1] as u32,
+                depth_or_array_layers: 1,
+            },
+        );
+    }
+}
+
+/// A cache of glyphs.
+///
+/// Text is required to come from a cache. Creation is easy and only requires
+/// a vector of the fonts to be used in sections.
+///
+/// ``` ignore
+/// let font = fs::load_font("my_font.ttf").await?;
+/// let mut cache = GlyphCache::new(vec![font]);
+/// cache.brush.queue(
+///     Section::default()
+///         .add_text(
+///             Text::new("Here is some text.\n")
+///                 .with_scale(64.0)
+///                 .with_color(Color::rgb(0x00, 0x00, 0x00)),
+///         )
+///         .add_text(
+///             Text::new("Here is text in a new color\n")
+///                 .with_scale(64.0)
+///                 .with_color(Color::rgb(255, 255, 0)),
+///         )
+///         .add_text(
+///             Text::new("(and variable size)\n")
+///                 .with_scale(32.0)
+///                 .with_color(Color::rgb(255, 0, 255))
+///         )
+///         .add_text(
+///             Text::new("...and variable transparency\n...and word wrap")
+///                 .with_scale(64.0)
+///                 .with_color(Color::rgba(0x33, 0x33, 0x33, 127)),
+///         )
+/// );
+/// ```
+///
+/// Once you have a `GlyphCache` that has text [`queue`](GlyphBrush::queue)d you
+/// can use [`TextData`] to create a builder, which can be used to position and
+/// scale the text entity and add other components.
+pub struct GlyphCache {
+    pub(crate) cache: Option<Cache>,
+    pub brush: GlyphBrush<Vec<Vertex>>,
+}
+
+impl Deref for GlyphCache {
+    type Target = GlyphBrush<Vec<Vertex>>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.brush
+    }
+}
+
+impl DerefMut for GlyphCache {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.brush
+    }
+}
+
+impl GlyphCache {}
+
+#[inline]
+fn to_vertex(
+    glyph_brush::GlyphVertex {
+        mut tex_coords,
+        pixel_coords,
+        bounds,
+        extra,
+    }: glyph_brush::GlyphVertex,
+) -> Vec<Vertex> {
+    let gl_bounds = bounds;
+
+    let mut gl_rect = Rect {
+        min: ab_glyph::point(pixel_coords.min.x as f32, pixel_coords.min.y as f32),
+        max: ab_glyph::point(pixel_coords.max.x as f32, pixel_coords.max.y as f32),
+    };
+
+    // handle overlapping bounds, modify uv_rect to preserve texture aspect
+    if gl_rect.max.x > gl_bounds.max.x {
+        let old_width = gl_rect.width();
+        gl_rect.max.x = gl_bounds.max.x;
+        tex_coords.max.x = tex_coords.min.x + tex_coords.width() * gl_rect.width() / old_width;
+    }
+    if gl_rect.min.x < gl_bounds.min.x {
+        let old_width = gl_rect.width();
+        gl_rect.min.x = gl_bounds.min.x;
+        tex_coords.min.x = tex_coords.max.x - tex_coords.width() * gl_rect.width() / old_width;
+    }
+    if gl_rect.max.y > gl_bounds.max.y {
+        let old_height = gl_rect.height();
+        gl_rect.max.y = gl_bounds.max.y;
+        tex_coords.max.y = tex_coords.min.y + tex_coords.height() * gl_rect.height() / old_height;
+    }
+    if gl_rect.min.y < gl_bounds.min.y {
+        let old_height = gl_rect.height();
+        gl_rect.min.y = gl_bounds.min.y;
+        tex_coords.min.y = tex_coords.max.y - tex_coords.height() * gl_rect.height() / old_height;
+    }
+    let tl = Vertex::default()
+        .with_position([gl_rect.min.x, gl_rect.min.y, 0.0])
+        .with_uv0([tex_coords.min.x, tex_coords.min.y])
+        .with_color(extra.color);
+    let tr = Vertex::default()
+        .with_position([gl_rect.max.x, gl_rect.min.y, 0.0])
+        .with_uv0([tex_coords.max.x, tex_coords.min.y])
+        .with_color(extra.color);
+    let br = Vertex::default()
+        .with_position([gl_rect.max.x, gl_rect.max.y, 0.0])
+        .with_uv0([tex_coords.max.x, tex_coords.max.y])
+        .with_color(extra.color);
+    let bl = Vertex::default()
+        .with_position([gl_rect.min.x, gl_rect.max.y, 0.0])
+        .with_uv0([tex_coords.min.x, tex_coords.max.y])
+        .with_color(extra.color);
+
+    // Draw as two tris
+    let data = vec![tl, br, tr, tl, bl, br];
+    data
+}
+
+impl GlyphCache {
+    pub fn new(fonts: Vec<FontArc>) -> Self {
+        let brush = GlyphBrushBuilder::using_fonts(fonts).build();
+        GlyphCache { cache: None, brush }
+    }
+
+    pub fn bounds<'a, S>(&mut self, section: S) -> Option<ab_glyph::Rect>
+    where
+        S: Into<Cow<'a, Section<'a, Extra>>>,
+    {
+        self.brush.glyph_bounds(section)
+    }
+    /// Process any brushes, updating textures, etc.
+    ///
+    /// Returns a new mesh if the mesh needs to be updated.
+    /// Returns a new texture if the texture needs to be updated.
+    ///
+    /// The texture and mesh are meant to be used to build or update an object
+    /// to display.
+    pub fn get_updated(
+        &mut self,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+    ) -> (Option<Vec<Vertex>>, Option<Texture>) {
+        let mut may_mesh: Option<Vec<Vertex>> = None;
+        let mut may_texture: Option<Texture> = None;
+        let mut cache = self.cache.take().unwrap_or_else(|| {
+            let (width, height) = self.brush.texture_dimensions();
+            let cache = Cache::new(device, width, height);
+            may_texture = Some(cache.texture.clone());
+            cache
+        });
+
+        let mut brush_action;
+        loop {
+            brush_action = self.brush.process_queued(
+                |rect, tex_data| {
+                    let offset = [rect.min[0] as u16, rect.min[1] as u16];
+                    let size = [rect.width() as u16, rect.height() as u16];
+                    cache.update(queue, offset, size, tex_data)
+                },
+                to_vertex,
+            );
+
+            match brush_action {
+                Ok(_) => break,
+                Err(BrushError::TextureTooSmall { suggested, .. }) => {
+                    let max_image_dimension = 2048;
+
+                    let (new_width, new_height) = if (suggested.0 > max_image_dimension
+                        || suggested.1 > max_image_dimension)
+                        && (self.brush.texture_dimensions().0 < max_image_dimension
+                            || self.brush.texture_dimensions().1 < max_image_dimension)
+                    {
+                        (max_image_dimension, max_image_dimension)
+                    } else {
+                        suggested
+                    };
+
+                    log::warn!(
+                        "Increasing glyph texture size {old:?} -> {new:?}. Consider building with \
+                         `.initial_cache_size({new:?})` to avoid resizing",
+                        old = self.brush.texture_dimensions(),
+                        new = (new_width, new_height),
+                    );
+
+                    cache = Cache::new(device, new_width, new_height);
+                    self.brush.resize_texture(new_width, new_height);
+                    may_texture = Some(cache.texture.clone());
+                }
+            }
+        }
+        self.cache = Some(cache);
+
+        match brush_action.unwrap() {
+            BrushAction::Draw(all_vertices) => {
+                if !all_vertices.is_empty() {
+                    may_mesh = Some(
+                        all_vertices
+                            .into_iter()
+                            .flat_map(|vs| vs.into_iter())
+                            .collect(),
+                    );
+                }
+            }
+            BrushAction::ReDraw => {}
+        }
+
+        (may_mesh, may_texture)
+    }
+}
diff --git a/crates/renderling-shader/src/gltf.rs b/crates/renderling-shader/src/gltf.rs
index c7d042ea..7e5eb344 100644
--- a/crates/renderling-shader/src/gltf.rs
+++ b/crates/renderling-shader/src/gltf.rs
@@ -1,8 +1,13 @@
 //! Gltf types that are used in shaders.
 use crabslab::{Array, Id, Slab, SlabItem};
-use glam::{Vec2, Vec3, Vec4};
-
-use crate::{pbr::PbrMaterial, texture::GpuTexture};
+use glam::{Mat4, Vec2, Vec3, Vec4};
+
+use crate::{
+    pbr::Material,
+    stage::{Camera, Transform, Vertex},
+    texture::GpuTexture,
+    IsMatrix,
+};
 #[repr(transparent)]
 #[cfg_attr(not(target_arch = "spirv"), derive(Debug))]
 #[derive(Default, Clone, Copy, SlabItem)]
@@ -602,7 +607,7 @@ impl GltfAccessor {
 #[derive(Default, Clone, Copy, SlabItem)]
 pub struct GltfPrimitive {
     pub vertex_count: u32,
-    pub material: Id<PbrMaterial>,
+    pub material: Id<Material>,
     pub indices: Id<GltfAccessor>,
     pub positions: Id<GltfAccessor>,
     pub normals: Id<GltfAccessor>,
@@ -1051,8 +1056,8 @@ pub struct GltfDocument {
     pub buffers: Array<GltfBuffer>,
     pub cameras: Array<GltfCamera>,
     // TODO: Think about making a `GltfMaterial`
-    pub materials: Array<PbrMaterial>,
-    pub default_material: Id<PbrMaterial>,
+    pub materials: Array<Material>,
+    pub default_material: Id<Material>,
     pub meshes: Array<GltfMesh>,
     pub nodes: Array<GltfNode>,
     pub scenes: Array<GltfScene>,
@@ -1061,3 +1066,78 @@ pub struct GltfDocument {
     pub textures: Array<GpuTexture>,
     pub views: Array<GltfBufferView>,
 }
+
+/// A rendering "command" that draws a single mesh from a top-level node.
+#[cfg_attr(not(target_arch = "spirv"), derive(Debug))]
+#[repr(C)]
+#[derive(Default, Clone, Copy, PartialEq, SlabItem)]
+pub struct RenderUnit {
+    // Which node are we rendering, and what is the path through its
+    // ancestors to get to it.
+    pub node_path: Array<Id<GltfNode>>,
+    // Index of the mesh within the child node that we're rendering.
+    pub mesh_index: u32,
+    // Index of the primitive within the mesh that we're rendering.
+    pub primitive_index: u32,
+    // Points to a `Camera` in the stage's slab.
+    pub camera: Id<Camera>,
+    // Points to a top-level `Transform` in the stage's slab.
+    //
+    // This is used to transform your GLTF models.
+    pub transform: Id<Transform>,
+    // Number of vertices to draw for this unit.
+    //
+    // This is a cache for convenience on CPU.
+    pub vertex_count: u32,
+}
+
+impl crate::stage::IsRendering for RenderUnit {
+    fn vertex_count(&self) -> u32 {
+        self.vertex_count
+    }
+
+    fn wrap(id: Id<Self>) -> crate::stage::Rendering {
+        crate::stage::Rendering::Gltf(id)
+    }
+}
+
+impl RenderUnit {
+    pub fn get_vertex_details(
+        &self,
+        vertex_index: u32,
+        slab: &[u32],
+    ) -> (Vertex, Transform, Id<Material>) {
+        let t = slab.read(self.transform);
+        crate::println!("t: {t:#?}");
+        let mut model =
+            glam::Mat4::from_scale_rotation_translation(t.scale, t.rotation, t.translation);
+        crate::println!("model: {model:#?}");
+        let mut node = GltfNode::default();
+        for id_id in self.node_path.iter() {
+            let node_id = slab.read(id_id);
+            crate::println!("  node_id: {node_id:?}");
+            node = slab.read(node_id);
+            crate::println!("  node.scale: {:?}", node.scale);
+            crate::println!("  node.rotation: {:?}", node.rotation);
+            crate::println!("  node.translation: {:?}", node.translation);
+            let node_transform =
+                Mat4::from_scale_rotation_translation(node.scale, node.rotation, node.translation);
+            model = model * node_transform;
+        }
+
+        crate::println!("model(after): {model:#?}");
+        // TODO: check nodes for skinning
+        let mesh = slab.read(node.mesh);
+        let primitive_id = mesh.primitives.at(self.primitive_index as usize);
+        let primitive = slab.read(primitive_id);
+        let material = primitive.material;
+        let vertex = primitive.get_vertex(vertex_index as usize, slab);
+        let (s, r, t) = model.to_scale_rotation_translation_or_id();
+        let transform = Transform {
+            translation: t,
+            rotation: r,
+            scale: s,
+        };
+        (vertex, transform, material)
+    }
+}
diff --git a/crates/renderling-shader/src/lib.rs b/crates/renderling-shader/src/lib.rs
index 77677fb3..5f54901a 100644
--- a/crates/renderling-shader/src/lib.rs
+++ b/crates/renderling-shader/src/lib.rs
@@ -19,6 +19,7 @@ pub mod debug;
 pub mod gltf;
 pub mod math;
 pub mod pbr;
+pub mod sdf;
 pub mod skybox;
 pub mod stage;
 pub mod texture;
diff --git a/crates/renderling-shader/src/pbr.rs b/crates/renderling-shader/src/pbr.rs
index cc7b4b91..d65822de 100644
--- a/crates/renderling-shader/src/pbr.rs
+++ b/crates/renderling-shader/src/pbr.rs
@@ -11,21 +11,18 @@ use glam::{Vec2, Vec3, Vec4, Vec4Swizzles};
 use spirv_std::num_traits::Float;
 
 use crate::{
-    math,
-    stage::{light::LightStyle, GpuLight, LightType, LightingModel},
-    texture::GpuTexture,
-    IsSampler, IsVector, Sample2d, SampleCube,
+    math, stage::light::LightStyle, texture::GpuTexture, IsSampler, IsVector, Sample2d, SampleCube,
 };
 
 /// Represents a material on the GPU.
 ///
-/// `PbrMaterial` is capable of representing many material types.
+/// `Material` is capable of representing many material types.
 /// Use the appropriate builder for your material type from
 /// [`SceneBuilder`](crate::SceneBuilder).
 #[repr(C)]
 #[cfg_attr(not(target_arch = "spirv"), derive(Debug))]
 #[derive(Clone, Copy, PartialEq, SlabItem)]
-pub struct PbrMaterial {
+pub struct Material {
     // x, y, z is emissive factor, default [0.0, 0.0, 0.0]
     // w is emissive strength multiplier (gltf's KHR_materials_emissive_strength extension),
     // default 1.0
@@ -47,11 +44,11 @@ pub struct PbrMaterial {
     pub ao_tex_coord: u32,
     pub emissive_tex_coord: u32,
 
-    pub lighting_model: LightingModel,
+    pub has_lighting: bool,
     pub ao_strength: f32,
 }
 
-impl Default for PbrMaterial {
+impl Default for Material {
     fn default() -> Self {
         Self {
             emissive_factor: Vec3::ZERO.extend(1.0),
@@ -67,7 +64,7 @@ impl Default for PbrMaterial {
             metallic_roughness_tex_coord: 0,
             normal_tex_coord: 0,
             ao_tex_coord: 0,
-            lighting_model: LightingModel::PBR_LIGHTING,
+            has_lighting: true,
             ao_strength: 0.0,
             emissive_texture: Id::NONE,
             emissive_tex_coord: 0,
@@ -228,116 +225,6 @@ pub fn sample_brdf<T: Sample2d<Sampler = S>, S: IsSampler>(
         .xy()
 }
 
-#[allow(clippy::too_many_arguments)]
-pub fn shade_fragment(
-    // camera's position in world space
-    camera_pos: Vec3,
-    // normal of the fragment
-    in_norm: Vec3,
-    // position of the fragment in world space
-    in_pos: Vec3,
-    // base color of the fragment
-    albedo: Vec3,
-    metallic: f32,
-    roughness: f32,
-    ao: f32,
-    emissive: Vec3,
-    irradiance: Vec3,
-    prefiltered: Vec3,
-    brdf: Vec2,
-
-    lights: &[GpuLight],
-) -> Vec4 {
-    let n = in_norm.alt_norm_or_zero();
-    let v = (camera_pos - in_pos).alt_norm_or_zero();
-
-    // reflectance
-    let mut lo = Vec3::ZERO;
-    #[allow(clippy::needless_range_loop)]
-    for i in 0..lights.len() {
-        // calculate per-light radiance
-        let light = lights[i];
-
-        // determine the light ray and the radiance
-        match light.light_type {
-            LightType::END_OF_LIGHTS => {
-                break;
-            }
-            LightType::POINT_LIGHT => {
-                let frag_to_light = light.position.xyz() - in_pos;
-                let distance = frag_to_light.length();
-                if distance == 0.0 {
-                    continue;
-                }
-                let l = frag_to_light.alt_norm_or_zero();
-                let attenuation = light.intensity * 1.0 / (distance * distance);
-                lo += outgoing_radiance(
-                    light.color,
-                    albedo,
-                    attenuation,
-                    v,
-                    l,
-                    n,
-                    metallic,
-                    roughness,
-                );
-            }
-
-            LightType::SPOT_LIGHT => {
-                let frag_to_light = light.position.xyz() - in_pos;
-                let distance = frag_to_light.length();
-                if distance == 0.0 {
-                    continue;
-                }
-                let l = frag_to_light.alt_norm_or_zero();
-                let theta: f32 = l.dot(light.direction.xyz().alt_norm_or_zero());
-                let epsilon: f32 = light.inner_cutoff - light.outer_cutoff;
-                let attenuation: f32 =
-                    light.intensity * ((theta - light.outer_cutoff) / epsilon).clamp(0.0, 1.0);
-                lo += outgoing_radiance(
-                    light.color,
-                    albedo,
-                    attenuation,
-                    v,
-                    l,
-                    n,
-                    metallic,
-                    roughness,
-                );
-            }
-
-            LightType::DIRECTIONAL_LIGHT => {
-                let l = -light.direction.xyz().alt_norm_or_zero();
-                let attenuation = light.intensity;
-                lo += outgoing_radiance(
-                    light.color,
-                    albedo,
-                    attenuation,
-                    v,
-                    l,
-                    n,
-                    metallic,
-                    roughness,
-                );
-            }
-            _ => {}
-        }
-    }
-
-    // calculate reflectance at normal incidence; if dia-electric (like plastic) use
-    // F0 of 0.04 and if it's a metal, use the albedo color as F0 (metallic
-    // workflow)
-    let f0: Vec3 = Vec3::splat(0.04).lerp(albedo, metallic);
-    let cos_theta = n.dot(v).max(0.0);
-    let fresnel = fresnel_schlick_roughness(cos_theta, f0, roughness);
-    let ks = fresnel;
-    let kd = (1.0 - ks) * (1.0 - metallic);
-    let diffuse = irradiance * albedo;
-    let specular = prefiltered * (fresnel * brdf.x + brdf.y);
-    let color = (kd * diffuse + specular) * ao + lo + emissive;
-    color.extend(1.0)
-}
-
 #[allow(clippy::too_many_arguments)]
 pub fn stage_shade_fragment(
     // camera's position in world space
diff --git a/crates/renderling-shader/src/rectangle.rs b/crates/renderling-shader/src/rectangle.rs
new file mode 100644
index 00000000..e69de29b
diff --git a/crates/renderling-shader/src/sdf.rs b/crates/renderling-shader/src/sdf.rs
new file mode 100644
index 00000000..7c0178fc
--- /dev/null
+++ b/crates/renderling-shader/src/sdf.rs
@@ -0,0 +1 @@
+//! SDF shaders
diff --git a/crates/renderling-shader/src/stage.rs b/crates/renderling-shader/src/stage.rs
index 105afdaf..6367465f 100644
--- a/crates/renderling-shader/src/stage.rs
+++ b/crates/renderling-shader/src/stage.rs
@@ -16,12 +16,10 @@ use spirv_std::{
 use spirv_std::num_traits::*;
 
 use crate::{
-    bits::{bits, extract, insert},
     debug::*,
-    gltf::{GltfMesh, GltfNode},
-    pbr::{self, PbrMaterial},
+    pbr::{self, Material},
     texture::GpuTexture,
-    IsMatrix, IsSampler, IsVector, Sample2d, SampleCube,
+    IsSampler, IsVector, Sample2d, SampleCube,
 };
 
 pub mod light;
@@ -92,49 +90,49 @@ impl Vertex {
         self
     }
 
-    /// Return the matrix needed to bring vertices into the coordinate space of
-    /// the joint node.
-    pub fn get_joint_matrix(
-        &self,
-        i: usize,
-        joint_ids: &[Id<GpuEntity>; 32],
-        entities: &[GpuEntity],
-    ) -> Mat4 {
-        if i >= self.joints.len() {
-            return Mat4::IDENTITY;
-        }
-        let joint_index = self.joints[i];
-        let joint_id = if joint_index as usize >= joint_ids.len() {
-            Id::NONE
-        } else {
-            joint_ids[joint_index as usize]
-        };
-        if joint_id.is_none() {
-            return Mat4::IDENTITY;
-        }
-        let entity_index = joint_id.index();
-        if entity_index >= entities.len() {
-            return Mat4::IDENTITY;
-        }
-        let joint_entity = &entities[entity_index];
-        let (t, r, s) = joint_entity.get_world_transform(entities);
-        let trs = Mat4::from_scale_rotation_translation(s, r, t);
-        trs * joint_entity.inverse_bind_matrix
-    }
-
-    /// Return the result of adding all joint matrices multiplied by their
-    /// weights for the given vertex.
-    // See the [khronos gltf viewer reference](https://github.com/KhronosGroup/glTF-Sample-Viewer/blob/47a191931461a6f2e14de48d6da0f0eb6ec2d147/source/Renderer/shaders/animation.glsl#L47)
-    pub fn get_skin_matrix(&self, joint_ids: &[Id<GpuEntity>; 32], entities: &[GpuEntity]) -> Mat4 {
-        let mut mat = Mat4::ZERO;
-        for i in 0..self.joints.len() {
-            mat += self.weights[i] * self.get_joint_matrix(i, joint_ids, entities);
-        }
-        if mat == Mat4::ZERO {
-            return Mat4::IDENTITY;
-        }
-        mat
-    }
+    ///// Return the matrix needed to bring vertices into the coordinate space of
+    ///// the joint node.
+    //pub fn get_joint_matrix(
+    //    &self,
+    //    i: usize,
+    //    joint_ids: &[Id<GpuEntity>; 32],
+    //    entities: &[GpuEntity],
+    //) -> Mat4 {
+    //    if i >= self.joints.len() {
+    //        return Mat4::IDENTITY;
+    //    }
+    //    let joint_index = self.joints[i];
+    //    let joint_id = if joint_index as usize >= joint_ids.len() {
+    //        Id::NONE
+    //    } else {
+    //        joint_ids[joint_index as usize]
+    //    };
+    //    if joint_id.is_none() {
+    //        return Mat4::IDENTITY;
+    //    }
+    //    let entity_index = joint_id.index();
+    //    if entity_index >= entities.len() {
+    //        return Mat4::IDENTITY;
+    //    }
+    //    let joint_entity = &entities[entity_index];
+    //    let (t, r, s) = joint_entity.get_world_transform(entities);
+    //    let trs = Mat4::from_scale_rotation_translation(s, r, t);
+    //    trs * joint_entity.inverse_bind_matrix
+    //}
+
+    ///// Return the result of adding all joint matrices multiplied by their
+    ///// weights for the given vertex.
+    //// See the [khronos gltf viewer reference](https://github.com/KhronosGroup/glTF-Sample-Viewer/blob/47a191931461a6f2e14de48d6da0f0eb6ec2d147/source/Renderer/shaders/animation.glsl#L47)
+    //pub fn get_skin_matrix(&self, joint_ids: &[Id<GpuEntity>; 32], entities:
+    // &[GpuEntity]) -> Mat4 {    let mut mat = Mat4::ZERO;
+    //    for i in 0..self.joints.len() {
+    //        mat += self.weights[i] * self.get_joint_matrix(i, joint_ids,
+    // entities);    }
+    //    if mat == Mat4::ZERO {
+    //        return Mat4::IDENTITY;
+    //    }
+    //    mat
+    //}
 
     pub fn generate_normal(a: Vec3, b: Vec3, c: Vec3) -> Vec3 {
         let ab = a - b;
@@ -169,319 +167,6 @@ impl Vertex {
     }
 }
 
-#[repr(transparent)]
-#[cfg_attr(not(target_arch = "spirv"), derive(Debug))]
-#[derive(Copy, Clone, Default, PartialEq, Eq, SlabItem)]
-pub struct LightType(u32);
-
-#[cfg(not(target_arch = "spirv"))]
-impl core::fmt::Display for LightType {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        let s = match *self {
-            Self::END_OF_LIGHTS => "end of lights",
-            Self::POINT_LIGHT => "point light",
-            Self::SPOT_LIGHT => "spot light",
-            Self::DIRECTIONAL_LIGHT => "directional light",
-            _ => "unsupported light",
-        };
-        f.write_str(s)
-    }
-}
-
-impl LightType {
-    pub const END_OF_LIGHTS: Self = Self(0);
-    pub const POINT_LIGHT: Self = Self(1);
-    pub const SPOT_LIGHT: Self = Self(2);
-    pub const DIRECTIONAL_LIGHT: Self = Self(3);
-}
-
-/// A light capable of representing a directional, point or spotlight.
-#[repr(C)]
-#[cfg_attr(not(target_arch = "spirv"), derive(Debug))]
-#[derive(Copy, Clone, Default, SlabItem)]
-pub struct GpuLight {
-    pub position: Vec4,
-    pub direction: Vec4,
-    pub attenuation: Vec4,
-    pub color: Vec4,
-    pub inner_cutoff: f32,
-    pub outer_cutoff: f32,
-    pub intensity: f32,
-    pub light_type: LightType,
-}
-
-/// Determines the lighting to use in an ubershader.
-#[repr(transparent)]
-#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Debug, SlabItem)]
-pub struct LightingModel(u32);
-
-impl LightingModel {
-    pub const NO_LIGHTING: Self = LightingModel(0);
-    pub const PBR_LIGHTING: Self = LightingModel(1);
-}
-
-/// Provides information about an entity.
-///
-/// ### Provides what attributes are provided by a morph target.
-///
-/// In `renderling` morph targets' geometry are meshlets - they are assumed to
-/// come directly after the base mesh in the `GpuVertex` buffer, that way they
-/// can be indexed from the base mesh using only the `GpuEntity` struct (through
-/// `MorphTargetsInfo::num_targets`). See [`GpuEntity::get_vertex`] for more
-/// info.
-///
-/// ### Provides info about if the entity is a skin.
-#[repr(transparent)]
-#[cfg_attr(not(target_arch = "spirv"), derive(Debug))]
-#[derive(Clone, Copy, Default, PartialEq, SlabItem)]
-pub struct GpuEntityInfo(pub u32);
-
-impl GpuEntityInfo {
-    const BITS_NUM_TARGETS: (u32, u32) = bits(0..=7);
-    const BITS_HAS_POSITIONS: (u32, u32) = bits(8..=8);
-    const BITS_HAS_NORMALS: (u32, u32) = bits(9..=9);
-    const BITS_HAS_TANGENTS: (u32, u32) = bits(10..=10);
-    const BITS_IS_SKIN: (u32, u32) = bits(11..=11);
-
-    pub fn num_morph_targets(&self) -> u32 {
-        extract(self.0, Self::BITS_NUM_TARGETS)
-    }
-
-    #[cfg(not(target_arch = "spirv"))]
-    pub fn set_num_morph_targets(&mut self, num_targets: u8) {
-        insert(&mut self.0, Self::BITS_NUM_TARGETS, num_targets as u32)
-    }
-
-    pub fn morph_targets_have_positions(&self) -> bool {
-        extract(self.0, Self::BITS_HAS_POSITIONS) == 1
-    }
-
-    pub fn set_morph_targets_have_positions(&mut self, has: bool) {
-        insert(
-            &mut self.0,
-            Self::BITS_HAS_POSITIONS,
-            if has { 1 } else { 0 },
-        )
-    }
-
-    pub fn morph_targets_have_normals(&self) -> bool {
-        extract(self.0, Self::BITS_HAS_NORMALS) == 1
-    }
-
-    pub fn set_morph_targets_have_normals(&mut self, has: bool) {
-        insert(&mut self.0, Self::BITS_HAS_NORMALS, if has { 1 } else { 0 })
-    }
-
-    pub fn morph_targets_have_tangents(&self) -> bool {
-        extract(self.0, Self::BITS_HAS_TANGENTS) == 1
-    }
-
-    pub fn set_morph_targets_have_tangents(&mut self, has: bool) {
-        insert(
-            &mut self.0,
-            Self::BITS_HAS_TANGENTS,
-            if has { 1 } else { 0 },
-        )
-    }
-
-    pub fn is_skin(&self) -> bool {
-        extract(self.0, Self::BITS_IS_SKIN) == 1
-    }
-
-    pub fn set_is_skin(&mut self, is_skin: bool) {
-        insert(&mut self.0, Self::BITS_IS_SKIN, if is_skin { 1 } else { 0 })
-    }
-}
-
-/// A bundle of GPU components.
-#[cfg_attr(not(target_arch = "spirv"), derive(Debug))]
-#[repr(C)]
-#[derive(Clone, Copy, PartialEq, SlabItem)]
-pub struct GpuEntity {
-    // The id of this entity. `Id::NONE` means this entity is not in use.
-    pub id: Id<GpuEntity>,
-    // Info about the entity.
-    pub info: GpuEntityInfo,
-    // The index of the first vertex in this entity's mesh.
-    pub mesh_first_vertex: u32,
-    // The number of vertices in this entity's mesh.
-    pub mesh_vertex_count: u32,
-    // Nothing to see here
-    pub padding: u32,
-    // The index/id of this entity's material in the material buffer.
-    pub material: Id<pbr::PbrMaterial>,
-    // The id of this entity's parent, if it exists. `Id::NONE` means "no parent".
-    pub parent: Id<GpuEntity>,
-    // Whether this entity is visible. `0` is "not visible", any other value is "visible".
-    pub visible: u32,
-    // The local translation of this entity
-    pub position: Vec4,
-    // The local scale of this entity
-    pub scale: Vec4,
-    // The local rotation of this entity
-    pub rotation: Quat,
-    // A joint inverse-bind-matrix
-    // TODO: restructure the buffers so we don't need this
-    pub inverse_bind_matrix: Mat4,
-    pub skin_joint_ids: [Id<GpuEntity>; 32],
-    // Morph target weights for this entity, if it has morph targets
-    pub morph_targets_weights: [f32; 8],
-}
-
-impl Default for GpuEntity {
-    fn default() -> Self {
-        Self {
-            id: Id::NONE,
-            mesh_first_vertex: 0,
-            mesh_vertex_count: 0,
-            info: GpuEntityInfo::default(),
-            morph_targets_weights: [0.0; 8],
-            padding: 0,
-            material: Id::NONE,
-            position: Vec4::ZERO,
-            scale: Vec4::ONE,
-            rotation: Quat::IDENTITY,
-            visible: 1,
-            parent: Id::NONE,
-            skin_joint_ids: [Id::NONE; 32],
-            inverse_bind_matrix: Mat4::IDENTITY,
-        }
-    }
-}
-
-impl From<&GpuEntity> for Id<GpuEntity> {
-    fn from(value: &GpuEntity) -> Self {
-        value.id
-    }
-}
-
-impl From<GpuEntity> for Id<GpuEntity> {
-    fn from(value: GpuEntity) -> Self {
-        value.id
-    }
-}
-
-impl GpuEntity {
-    pub fn is_alive(&self) -> bool {
-        !self.id.is_none()
-    }
-
-    /// Return the position, rotation and scale that describe this entity's
-    /// transform in world space.
-    pub fn get_world_transform(&self, entities: &[GpuEntity]) -> (Vec3, Quat, Vec3) {
-        let mut mat = Mat4::IDENTITY;
-        let mut id = self.id;
-        loop {
-            let entity = entities[id.index()];
-            mat = Mat4::from_scale_rotation_translation(
-                entity.scale.xyz(),
-                entity.rotation,
-                entity.position.xyz(),
-            ) * mat;
-            id = entity.parent;
-            if id.index() >= entities.len() {
-                break;
-            }
-        }
-        let (s, r, t) = mat.to_scale_rotation_translation_or_id();
-        (t, r, s)
-    }
-
-    #[cfg(not(target_arch = "spirv"))]
-    pub fn set_morph_target_weights(&mut self, weights: impl IntoIterator<Item = f32>) {
-        for (i, weight) in weights
-            .into_iter()
-            .take(self.morph_targets_weights.len())
-            .enumerate()
-        {
-            self.morph_targets_weights[i] = weight;
-        }
-    }
-
-    /// Return the `GpuVertex` at the given index.
-    ///
-    /// This takes into consideration any morph targets the base mesh may
-    /// reference as well as any joints.
-    pub fn get_vertex(&self, vertex_index: u32, vertices: &[Vertex]) -> Vertex {
-        let index = vertex_index as usize;
-        let mut vertex = vertices[index];
-
-        // Apply target morphing
-        let targets = self.info.num_morph_targets() as usize;
-        let vertex_count = self.mesh_vertex_count as usize;
-        for i in 1..=targets {
-            let target_weight = self.morph_targets_weights[i - 1];
-            let target_index = index + (i * vertex_count);
-            let target = vertices[target_index];
-            vertex.position += (target_weight * target.position.xyz()).extend(0.0);
-            vertex.normal += (target_weight * target.normal.xyz()).extend(0.0);
-            vertex.tangent += (target_weight * target.tangent.xyz()).extend(0.0);
-        }
-
-        vertex
-    }
-
-    #[cfg(not(target_arch = "spirv"))]
-    /// Return all the vertices of this entity.
-    ///
-    /// This takes into consideration any morph targets the base mesh may
-    /// reference as well as any joints.
-    pub fn get_vertices(&self, vertices: &[Vertex]) -> Vec<Vertex> {
-        let mut mesh_vertices = vec![];
-        for vertex_index in self.mesh_first_vertex..self.mesh_first_vertex + self.mesh_vertex_count
-        {
-            mesh_vertices.push(self.get_vertex(vertex_index, vertices));
-        }
-        mesh_vertices
-    }
-}
-
-/// Boolean toggles that cause the renderer to turn on/off certain features.
-#[repr(transparent)]
-#[cfg_attr(not(target_arch = "spirv"), derive(Debug))]
-#[derive(Default, Clone, Copy, PartialEq, SlabItem)]
-pub struct GpuToggles(pub u32);
-
-impl GpuToggles {
-    const BITS_HAS_SKYBOX: (u32, u32) = bits(0..=0);
-    const BITS_USE_LIGHTING: (u32, u32) = bits(1..=1);
-
-    pub fn get_has_skybox(&self) -> bool {
-        extract(self.0, Self::BITS_HAS_SKYBOX) == 1
-    }
-
-    pub fn set_has_skybox(&mut self, has: bool) {
-        insert(&mut self.0, Self::BITS_HAS_SKYBOX, if has { 1 } else { 0 })
-    }
-
-    pub fn get_use_lighting(&self) -> bool {
-        extract(self.0, Self::BITS_USE_LIGHTING) == 1
-    }
-
-    /// Setting this to `false` causes all models to be rendered "unlit", as
-    /// if each used a material with `lighting_model = LightModel::NO_LIGHTING`.
-    pub fn set_use_lighting(&mut self, use_lighting: bool) {
-        insert(
-            &mut self.0,
-            Self::BITS_USE_LIGHTING,
-            if use_lighting { 1 } else { 0 },
-        )
-    }
-}
-
-/// Unforms/constants for a scene's worth of rendering.
-#[cfg_attr(not(target_arch = "spirv"), derive(Debug))]
-#[repr(C)]
-#[derive(Default, Clone, Copy, PartialEq, SlabItem)]
-pub struct GpuConstants {
-    pub camera_projection: Mat4,
-    pub camera_view: Mat4,
-    pub camera_pos: Vec4,
-    pub atlas_size: UVec2,
-    pub debug_mode: DebugMode,
-    pub toggles: GpuToggles,
-}
-
 #[repr(C)]
 #[derive(Default, Debug, Clone, Copy, PartialEq, SlabItem)]
 pub struct DrawIndirect {
@@ -491,32 +176,6 @@ pub struct DrawIndirect {
     pub base_instance: u32,
 }
 
-fn texture_color<T, S>(
-    texture_id: Id<GpuTexture>,
-    uv: Vec2,
-    atlas: &T,
-    sampler: &S,
-    atlas_size: UVec2,
-    textures: &[GpuTexture],
-) -> Vec4
-where
-    T: Sample2d<Sampler = S>,
-    S: IsSampler,
-{
-    let texture = if texture_id.is_none() {
-        GpuTexture::default()
-    } else {
-        textures[texture_id.index()]
-    };
-
-    let uv = texture.uv(uv, atlas_size);
-    let mut color: Vec4 = atlas.sample_by_lod(*sampler, uv, 0.0);
-    if texture_id.is_none() {
-        color = Vec4::splat(1.0);
-    }
-    color
-}
-
 fn stage_texture_color<T: Sample2d<Sampler = S>, S: IsSampler>(
     texture_id: Id<GpuTexture>,
     uv: Vec2,
@@ -534,390 +193,6 @@ fn stage_texture_color<T: Sample2d<Sampler = S>, S: IsSampler>(
     color
 }
 
-#[allow(clippy::too_many_arguments)]
-#[spirv(vertex)]
-/// Scene vertex shader.
-pub fn main_vertex_scene(
-    // which entity are we drawing
-    #[spirv(instance_index)] instance_index: u32,
-    // which vertex are we drawing
-    #[spirv(vertex_index)] vertex_index: u32,
-
-    #[spirv(uniform, descriptor_set = 0, binding = 0)] constants: &GpuConstants,
-    #[spirv(storage_buffer, descriptor_set = 0, binding = 1)] vertices: &[Vertex],
-    #[spirv(storage_buffer, descriptor_set = 0, binding = 2)] entities: &[GpuEntity],
-
-    #[spirv(flat)] out_material: &mut u32,
-    out_color: &mut Vec4,
-    out_uv0: &mut Vec2,
-    out_uv1: &mut Vec2,
-    out_norm: &mut Vec3,
-    out_tangent: &mut Vec3,
-    out_bitangent: &mut Vec3,
-    // position of the vertex/fragment in world space
-    out_pos: &mut Vec3,
-
-    #[spirv(position)] gl_pos: &mut Vec4,
-) {
-    let entity = entities[instance_index as usize];
-    let vertex = entity.get_vertex(vertex_index, vertices);
-
-    let (position, rotation, scale) = if entity.info.is_skin() {
-        let skin_mat = vertex.get_skin_matrix(&entity.skin_joint_ids, entities);
-        let (s, r, t) = skin_mat.to_scale_rotation_translation_or_id();
-        (t, r, s)
-    } else {
-        entity.get_world_transform(entities)
-    };
-    let model_matrix = Mat4::from_scale_rotation_translation(scale, rotation, position);
-    *out_material = entity.material.into();
-    *out_color = vertex.color;
-    *out_uv0 = vertex.uv.xy();
-    *out_uv1 = vertex.uv.zw();
-
-    let scale2 = scale * scale;
-    let normal = vertex.normal.xyz().alt_norm_or_zero();
-    let tangent = vertex.tangent.xyz().alt_norm_or_zero();
-    let normal_w = (model_matrix * (normal / scale2).extend(0.0))
-        .xyz()
-        .alt_norm_or_zero();
-    let tangent_w = (model_matrix * tangent.extend(0.0))
-        .xyz()
-        .alt_norm_or_zero();
-    let bitangent_w = normal_w.cross(tangent_w) * if vertex.tangent.w >= 0.0 { 1.0 } else { -1.0 };
-    *out_tangent = tangent_w;
-    *out_bitangent = bitangent_w;
-    *out_norm = normal_w;
-
-    let view_pos = model_matrix * vertex.position.xyz().extend(1.0);
-    *out_pos = view_pos.xyz();
-    *gl_pos = constants.camera_projection * constants.camera_view * view_pos;
-}
-
-#[allow(clippy::too_many_arguments)]
-#[spirv(fragment)]
-/// Scene fragment shader.
-pub fn main_fragment_scene(
-    #[spirv(descriptor_set = 1, binding = 0)] atlas: &Image2d,
-    #[spirv(descriptor_set = 1, binding = 1)] atlas_sampler: &Sampler,
-
-    #[spirv(descriptor_set = 0, binding = 5)] irradiance: &Cubemap,
-    #[spirv(descriptor_set = 0, binding = 6)] irradiance_sampler: &Sampler,
-    #[spirv(descriptor_set = 0, binding = 7)] prefiltered: &Cubemap,
-    #[spirv(descriptor_set = 0, binding = 8)] prefiltered_sampler: &Sampler,
-    #[spirv(descriptor_set = 0, binding = 9)] brdf: &Image2d,
-    #[spirv(descriptor_set = 0, binding = 10)] brdf_sampler: &Sampler,
-
-    #[spirv(uniform, descriptor_set = 0, binding = 0)] constants: &GpuConstants,
-    #[spirv(storage_buffer, descriptor_set = 0, binding = 3)] lights: &[GpuLight],
-    #[spirv(storage_buffer, descriptor_set = 0, binding = 4)] materials: &[pbr::PbrMaterial],
-    #[spirv(storage_buffer, descriptor_set = 1, binding = 2)] textures: &[GpuTexture],
-
-    #[spirv(flat)] in_material: u32,
-    in_color: Vec4,
-    in_uv0: Vec2,
-    in_uv1: Vec2,
-    in_norm: Vec3,
-    in_tangent: Vec3,
-    in_bitangent: Vec3,
-    in_pos: Vec3,
-
-    output: &mut Vec4,
-    brigtness: &mut Vec4,
-) {
-    main_fragment_impl(
-        atlas,
-        atlas_sampler,
-        irradiance,
-        irradiance_sampler,
-        prefiltered,
-        prefiltered_sampler,
-        brdf,
-        brdf_sampler,
-        constants,
-        lights,
-        materials,
-        textures,
-        in_material,
-        in_color,
-        in_uv0,
-        in_uv1,
-        in_norm,
-        in_tangent,
-        in_bitangent,
-        in_pos,
-        output,
-        brigtness,
-    );
-}
-
-/// Scene fragment shader, callable from the CPU or GPU.
-pub fn main_fragment_impl<T, C, S>(
-    atlas: &T,
-    atlas_sampler: &S,
-
-    irradiance: &C,
-    irradiance_sampler: &S,
-    prefiltered: &C,
-    prefiltered_sampler: &S,
-    brdf: &T,
-    brdf_sampler: &S,
-
-    constants: &GpuConstants,
-    lights: &[GpuLight],
-    materials: &[pbr::PbrMaterial],
-    textures: &[GpuTexture],
-
-    in_material: u32,
-    in_color: Vec4,
-    in_uv0: Vec2,
-    in_uv1: Vec2,
-    in_norm: Vec3,
-    in_tangent: Vec3,
-    in_bitangent: Vec3,
-    in_pos: Vec3,
-
-    output: &mut Vec4,
-    brigtness: &mut Vec4,
-) where
-    T: Sample2d<Sampler = S>,
-    C: SampleCube<Sampler = S>,
-    S: IsSampler,
-{
-    let material = if in_material == ID_NONE || !constants.toggles.get_use_lighting() {
-        // without an explicit material (or if the entire render has no lighting)
-        // the entity will not participate in any lighting calculations
-        pbr::PbrMaterial {
-            lighting_model: LightingModel::NO_LIGHTING,
-            ..Default::default()
-        }
-    } else {
-        materials[in_material as usize]
-    };
-
-    let albedo_tex_uv = if material.albedo_tex_coord == 0 {
-        in_uv0
-    } else {
-        in_uv1
-    };
-    let albedo_tex_color = texture_color(
-        material.albedo_texture,
-        albedo_tex_uv,
-        atlas,
-        atlas_sampler,
-        constants.atlas_size,
-        textures,
-    );
-
-    let metallic_roughness_uv = if material.metallic_roughness_tex_coord == 0 {
-        in_uv0
-    } else {
-        in_uv1
-    };
-    let metallic_roughness_tex_color = texture_color(
-        material.metallic_roughness_texture,
-        metallic_roughness_uv,
-        atlas,
-        atlas_sampler,
-        constants.atlas_size,
-        textures,
-    );
-
-    let normal_tex_uv = if material.normal_tex_coord == 0 {
-        in_uv0
-    } else {
-        in_uv1
-    };
-    let normal_tex_color = texture_color(
-        material.normal_texture,
-        normal_tex_uv,
-        atlas,
-        atlas_sampler,
-        constants.atlas_size,
-        textures,
-    );
-
-    let ao_tex_uv = if material.ao_tex_coord == 0 {
-        in_uv0
-    } else {
-        in_uv1
-    };
-    let ao_tex_color = texture_color(
-        material.ao_texture,
-        ao_tex_uv,
-        atlas,
-        atlas_sampler,
-        constants.atlas_size,
-        textures,
-    );
-
-    let emissive_tex_uv = if material.emissive_tex_coord == 0 {
-        in_uv0
-    } else {
-        in_uv1
-    };
-    let emissive_tex_color = texture_color(
-        material.emissive_texture,
-        emissive_tex_uv,
-        atlas,
-        atlas_sampler,
-        constants.atlas_size,
-        textures,
-    );
-
-    let (norm, uv_norm) = if material.normal_texture.is_none() {
-        // there is no normal map, use the normal normal ;)
-        (in_norm, Vec3::ZERO)
-    } else {
-        // convert the normal from color coords to tangent space -1,1
-        let sampled_norm = (normal_tex_color.xyz() * 2.0 - Vec3::splat(1.0)).alt_norm_or_zero();
-        let tbn = mat3(
-            in_tangent.alt_norm_or_zero(),
-            in_bitangent.alt_norm_or_zero(),
-            in_norm.alt_norm_or_zero(),
-        );
-        // convert the normal from tangent space to world space
-        let norm = (tbn * sampled_norm).alt_norm_or_zero();
-        (norm, sampled_norm)
-    };
-
-    let n = norm;
-    let albedo = albedo_tex_color * material.albedo_factor * in_color;
-    let roughness = metallic_roughness_tex_color.y * material.roughness_factor;
-    let metallic = metallic_roughness_tex_color.z * material.metallic_factor;
-    let ao = 1.0 + material.ao_strength * (ao_tex_color.x - 1.0);
-    let emissive =
-        emissive_tex_color.xyz() * material.emissive_factor.xyz() * material.emissive_factor.w;
-    let irradiance = pbr::sample_irradiance(irradiance, irradiance_sampler, n);
-    let specular = pbr::sample_specular_reflection(
-        prefiltered,
-        prefiltered_sampler,
-        constants.camera_pos.xyz(),
-        in_pos,
-        n,
-        roughness,
-    );
-    let brdf = pbr::sample_brdf(
-        brdf,
-        brdf_sampler,
-        constants.camera_pos.xyz(),
-        in_pos,
-        n,
-        roughness,
-    );
-
-    fn colorize(u: Vec3) -> Vec4 {
-        ((u.alt_norm_or_zero() + Vec3::splat(1.0)) / 2.0).extend(1.0)
-    }
-
-    match constants.debug_mode.into() {
-        DebugChannel::None => {}
-        DebugChannel::UvCoords0 => {
-            *output = colorize(Vec3::new(in_uv0.x, in_uv0.y, 0.0));
-            return;
-        }
-        DebugChannel::UvCoords1 => {
-            *output = colorize(Vec3::new(in_uv1.x, in_uv1.y, 0.0));
-            return;
-        }
-        DebugChannel::Normals => {
-            *output = colorize(norm);
-            return;
-        }
-        DebugChannel::VertexColor => {
-            *output = in_color;
-            return;
-        }
-        DebugChannel::VertexNormals => {
-            *output = colorize(in_norm);
-            return;
-        }
-        DebugChannel::UvNormals => {
-            *output = colorize(uv_norm);
-            return;
-        }
-        DebugChannel::Tangents => {
-            *output = colorize(in_tangent);
-            return;
-        }
-        DebugChannel::Bitangents => {
-            *output = colorize(in_bitangent);
-            return;
-        }
-        DebugChannel::DiffuseIrradiance => {
-            *output = irradiance.extend(1.0);
-            return;
-        }
-        DebugChannel::SpecularReflection => {
-            *output = specular.extend(1.0);
-            return;
-        }
-        DebugChannel::Brdf => {
-            *output = brdf.extend(1.0).extend(1.0);
-            return;
-        }
-        DebugChannel::Roughness => {
-            *output = Vec3::splat(roughness).extend(1.0);
-            return;
-        }
-        DebugChannel::Metallic => {
-            *output = Vec3::splat(metallic).extend(1.0);
-            return;
-        }
-        DebugChannel::Albedo => {
-            *output = albedo;
-            return;
-        }
-        DebugChannel::Occlusion => {
-            *output = Vec3::splat(ao).extend(1.0);
-            return;
-        }
-        DebugChannel::Emissive => {
-            *output = emissive.extend(1.0);
-            return;
-        }
-        DebugChannel::UvEmissive => {
-            *output = emissive_tex_color.xyz().extend(1.0);
-            return;
-        }
-        DebugChannel::EmissiveFactor => {
-            *output = material.emissive_factor.xyz().extend(1.0);
-            return;
-        }
-        DebugChannel::EmissiveStrength => {
-            *output = Vec3::splat(material.emissive_factor.w).extend(1.0);
-            return;
-        }
-    }
-
-    *output = match material.lighting_model {
-        LightingModel::PBR_LIGHTING => pbr::shade_fragment(
-            constants.camera_pos.xyz(),
-            n,
-            in_pos,
-            albedo.xyz(),
-            metallic,
-            roughness,
-            ao,
-            emissive,
-            irradiance,
-            specular,
-            brdf,
-            lights,
-        ),
-        _unlit => in_color * albedo_tex_color * material.albedo_factor,
-    };
-
-    // write the brightest colors for the bloom effect
-    let brightness_value = output.xyz().dot(Vec3::new(0.2126, 0.7152, 0.0722));
-    *brigtness = if brightness_value > 1.0 {
-        output.xyz()
-    } else {
-        Vec3::ZERO
-    }
-    .extend(1.0);
-}
-
 /// A camera used for transforming the stage during rendering.
 ///
 /// Use `Camera::new(projection, view)` to create a new camera.
@@ -995,18 +270,6 @@ impl Default for StageLegend {
     }
 }
 
-#[cfg_attr(not(target_arch = "spirv"), derive(Debug))]
-#[repr(C)]
-#[derive(Default, Clone, Copy, PartialEq, SlabItem)]
-pub struct GltfVertexData {
-    // A path of node ids that leads to the node that contains the mesh.
-    pub parent_node_path: Array<Id<GltfNode>>,
-    // Points to a `GltfMesh` in the stage's slab.
-    pub mesh: Id<GltfMesh>,
-    // The index of the primitive within the mesh that this unit draws.
-    pub primitive_index: u32,
-}
-
 #[cfg_attr(not(target_arch = "spirv"), derive(Debug))]
 #[repr(C)]
 #[derive(Clone, Copy, PartialEq, SlabItem)]
@@ -1026,71 +289,70 @@ impl Default for Transform {
     }
 }
 
-/// A rendering "command" that draws a single mesh from a top-level node.
-#[cfg_attr(not(target_arch = "spirv"), derive(Debug))]
-#[repr(C)]
-#[derive(Default, Clone, Copy, PartialEq, SlabItem)]
-pub struct RenderUnit {
-    // Which node are we rendering, and what is the path through its
-    // ancestors to get to it.
-    pub node_path: Array<Id<GltfNode>>,
-    // Index of the mesh within the child node that we're rendering.
-    pub mesh_index: u32,
-    // Index of the primitive within the mesh that we're rendering.
-    pub primitive_index: u32,
-    // Points to a `Camera` in the stage's slab.
-    pub camera: Id<Camera>,
-    // Points to a top-level `Transform` in the stage's slab.
-    //
-    // This is used to transform your GLTF models.
-    pub transform: Id<Transform>,
-    // Number of vertices to draw for this unit.
-    //
-    // This is a cache for convenience on CPU.
-    pub vertex_count: u32,
+/// Pointer to a renderable unit.
+#[derive(Default, SlabItem)]
+pub enum Rendering {
+    #[default]
+    None,
+    /// Render the scene using the gltf vertex and fragment shaders.
+    Gltf(Id<crate::gltf::RenderUnit>),
 }
 
-impl RenderUnit {
-    pub fn get_vertex_details(
-        &self,
-        vertex_index: u32,
-        slab: &[u32],
-    ) -> (Vertex, Transform, Id<PbrMaterial>) {
-        let t = slab.read(self.transform);
-        crate::println!("t: {t:#?}");
-        let mut model = Mat4::from_scale_rotation_translation(t.scale, t.rotation, t.translation);
-        crate::println!("model: {model:#?}");
-        let mut node = GltfNode::default();
-        for id_id in self.node_path.iter() {
-            let node_id = slab.read(id_id);
-            crate::println!("  node_id: {node_id:?}");
-            node = slab.read(node_id);
-            crate::println!("  node.scale: {:?}", node.scale);
-            crate::println!("  node.rotation: {:?}", node.rotation);
-            crate::println!("  node.translation: {:?}", node.translation);
-            let node_transform =
-                Mat4::from_scale_rotation_translation(node.scale, node.rotation, node.translation);
-            model = model * node_transform;
-        }
+pub trait IsRendering: Default + SlabItem + Sized {
+    /// Returns the number of vertices in the rendering.
+    fn vertex_count(&self) -> u32;
 
-        crate::println!("model(after): {model:#?}");
-        // TODO: check nodes for skinning
-        let mesh = slab.read(node.mesh);
-        let primitive_id = mesh.primitives.at(self.primitive_index as usize);
-        let primitive = slab.read(primitive_id);
-        let material = primitive.material;
-        let vertex = primitive.get_vertex(vertex_index as usize, slab);
-        let (s, r, t) = model.to_scale_rotation_translation_or_id();
-        let transform = Transform {
-            translation: t,
-            rotation: r,
-            scale: s,
-        };
-        (vertex, transform, material)
+    /// Wraps an `Id` in a `Rendering`.
+    fn wrap(id: Id<Self>) -> Rendering;
+}
+
+/// Uber vertex shader.
+///
+/// This reads the "instance" by index and proxies to a specific vertex shader.
+#[spirv(vertex)]
+pub fn vertex(
+    // Points at a
+    #[spirv(instance_index)] instance_index: u32,
+    // Which vertex within the render unit are we rendering
+    #[spirv(vertex_index)] vertex_index: u32,
+    #[spirv(storage_buffer, descriptor_set = 0, binding = 0)] slab: &[u32],
+    #[spirv(flat)] out_camera: &mut u32,
+    #[spirv(flat)] out_material: &mut u32,
+    out_color: &mut Vec4,
+    out_uv0: &mut Vec2,
+    out_uv1: &mut Vec2,
+    out_norm: &mut Vec3,
+    out_tangent: &mut Vec3,
+    out_bitangent: &mut Vec3,
+    // position of the vertex/fragment in world space
+    out_pos: &mut Vec3,
+    #[spirv(position)] clip_pos: &mut Vec4,
+) {
+    let rendering = slab.read(Id::<Rendering>::new(instance_index));
+    match rendering {
+        Rendering::None => {}
+        Rendering::Gltf(unit_id) => {
+            gltf_vertex(
+                unit_id.inner(),
+                vertex_index,
+                slab,
+                out_camera,
+                out_material,
+                out_color,
+                out_uv0,
+                out_uv1,
+                out_norm,
+                out_tangent,
+                out_bitangent,
+                out_pos,
+                clip_pos,
+            );
+        }
     }
 }
 
 #[spirv(vertex)]
+// TODO: rename `gltf_vertex` to `gltf::vertex`
 pub fn gltf_vertex(
     // Which render unit are we rendering
     #[spirv(instance_index)] instance_index: u32,
@@ -1109,7 +371,7 @@ pub fn gltf_vertex(
     out_pos: &mut Vec3,
     #[spirv(position)] clip_pos: &mut Vec4,
 ) {
-    let unit_id: Id<RenderUnit> = Id::from(instance_index);
+    let unit_id: Id<crate::gltf::RenderUnit> = Id::from(instance_index);
     let unit = slab.read(unit_id);
     let (vertex, tfrm, material) = unit.get_vertex_details(vertex_index, slab);
     let model_matrix =
@@ -1145,19 +407,19 @@ pub fn get_stage_legend(slab: &[u32]) -> StageLegend {
     slab.read(Id::new(0))
 }
 
-/// Returns the `PbrMaterial` from the stage's slab.
-pub fn get_material(material_index: u32, has_lighting: bool, slab: &[u32]) -> pbr::PbrMaterial {
+/// Returns the `Material` from the stage's slab.
+pub fn get_material(material_index: u32, has_lighting: bool, slab: &[u32]) -> pbr::Material {
     if material_index == ID_NONE {
         // without an explicit material (or if the entire render has no lighting)
         // the entity will not participate in any lighting calculations
-        pbr::PbrMaterial {
-            lighting_model: LightingModel::NO_LIGHTING,
+        pbr::Material {
+            has_lighting: false,
             ..Default::default()
         }
     } else {
-        let mut material = slab.read(Id::<PbrMaterial>::new(material_index));
+        let mut material = slab.read(Id::<Material>::new(material_index));
         if !has_lighting {
-            material.lighting_model = LightingModel::NO_LIGHTING;
+            material.has_lighting = false;
         }
         material
     }
@@ -1166,6 +428,7 @@ pub fn get_material(material_index: u32, has_lighting: bool, slab: &[u32]) -> pb
 #[allow(clippy::too_many_arguments)]
 #[spirv(fragment)]
 /// Scene fragment shader.
+// TODO: rename from `gltf_fragment` to `fragment`.
 pub fn gltf_fragment(
     #[spirv(descriptor_set = 1, binding = 0)] atlas: &Image2d,
     #[spirv(descriptor_set = 1, binding = 1)] atlas_sampler: &Sampler,
@@ -1457,8 +720,8 @@ pub fn gltf_fragment_impl<T, C, S>(
         }
     }
 
-    *output = match material.lighting_model {
-        LightingModel::PBR_LIGHTING => pbr::stage_shade_fragment(
+    *output = if material.has_lighting {
+        pbr::stage_shade_fragment(
             camera.position,
             n,
             in_pos,
@@ -1472,8 +735,9 @@ pub fn gltf_fragment_impl<T, C, S>(
             brdf,
             light_array,
             slab,
-        ),
-        _unlit => in_color * albedo_tex_color * material.albedo_factor,
+        )
+    } else {
+        in_color * albedo_tex_color * material.albedo_factor
     };
 
     // write the brightest colors for the bloom effect
@@ -1486,46 +750,47 @@ pub fn gltf_fragment_impl<T, C, S>(
     .extend(1.0);
 }
 
-#[spirv(compute(threads(32)))]
-/// Compute the draw calls for this frame.
-///
-/// This should be called with `groupcount = (entities.len() / threads) + 1`.
-pub fn compute_cull_entities(
-    #[spirv(storage_buffer, descriptor_set = 0, binding = 2)] entities: &[GpuEntity],
-    #[spirv(storage_buffer, descriptor_set = 1, binding = 0)] draws: &mut [DrawIndirect],
-    #[spirv(global_invocation_id)] global_id: UVec3,
-) {
-    let i = global_id.x as usize;
-
-    if i > entities.len() {
-        return;
-    }
-
-    // when the vertex count and/or instance count is 0, it effectively filters
-    // the draw call
-    let mut call = DrawIndirect {
-        vertex_count: 0,
-        instance_count: 0,
-        base_vertex: 0,
-        base_instance: i as u32,
-    };
-    let entity = &entities[i];
-    let is_visible = entity.visible != 0;
-    if entity.is_alive() && is_visible {
-        //// once naga supports atomics we can use this to compact the array
-        // let index = unsafe {
-        //    spirv_std::arch::atomic_i_increment::<
-        //        u32,
-        //        { spirv_std::memory::Scope::Device as u32 },
-        //        { spirv_std::memory::Semantics::NONE.bits() as u32 },
-        //    >(count)
-        //};
-        call.instance_count = 1;
-        call.base_vertex = entity.mesh_first_vertex;
-        call.vertex_count = entity.mesh_vertex_count;
-    }
-    draws[i] = call;
-}
+//#[spirv(compute(threads(32)))]
+///// Compute the draw calls for this frame.
+/////
+///// This should be called with `groupcount = (entities.len() / threads) + 1`.
+//pub fn compute_cull_entities(
+//    #[spirv(storage_buffer, descriptor_set = 0, binding = 2)] entities:
+// &[GpuEntity],    #[spirv(storage_buffer, descriptor_set = 1, binding = 0)]
+// draws: &mut [DrawIndirect],    #[spirv(global_invocation_id)] global_id:
+// UVec3,
+//) {
+//    let i = global_id.x as usize;
+//
+//    if i > entities.len() {
+//        return;
+//    }
+//
+//    // when the vertex count and/or instance count is 0, it effectively
+// filters    // the draw call
+//    let mut call = DrawIndirect {
+//        vertex_count: 0,
+//        instance_count: 0,
+//        base_vertex: 0,
+//        base_instance: i as u32,
+//    };
+//    let entity = &entities[i];
+//    let is_visible = entity.visible != 0;
+//    if entity.is_alive() && is_visible {
+//        //// once naga supports atomics we can use this to compact the array
+//        // let index = unsafe {
+//        //    spirv_std::arch::atomic_i_increment::<
+//        //        u32,
+//        //        { spirv_std::memory::Scope::Device as u32 },
+//        //        { spirv_std::memory::Semantics::NONE.bits() as u32 },
+//        //    >(count)
+//        //};
+//        call.instance_count = 1;
+//        call.base_vertex = entity.mesh_first_vertex;
+//        call.vertex_count = entity.mesh_vertex_count;
+//    }
+//    draws[i] = call;
+//}
 
 #[spirv(compute(threads(32)))]
 /// A shader to ensure that we can extract i8 and i16 values from a storage
diff --git a/crates/renderling-shader/src/tutorial.rs b/crates/renderling-shader/src/tutorial.rs
index f13fcf4e..59176282 100644
--- a/crates/renderling-shader/src/tutorial.rs
+++ b/crates/renderling-shader/src/tutorial.rs
@@ -3,7 +3,7 @@ use crabslab::{Array, Id, Slab, SlabItem};
 use glam::{Mat4, Vec4, Vec4Swizzles};
 use spirv_std::spirv;
 
-use crate::stage::{RenderUnit, Vertex};
+use crate::{gltf::RenderUnit, stage::Vertex};
 
 /// Simple fragment shader that writes the input color to the output color.
 #[spirv(fragment)]
diff --git a/crates/renderling/Cargo.toml b/crates/renderling/Cargo.toml
index ee30b17d..eb273abd 100644
--- a/crates/renderling/Cargo.toml
+++ b/crates/renderling/Cargo.toml
@@ -12,12 +12,10 @@ readme = "../../README.md"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [features]
-default = ["gltf", "text", "raw-window-handle", "winit"]
-text = ["ab_glyph", "glyph_brush"]
+default = ["gltf", "raw-window-handle", "winit"]
 wasm = ["wgpu/fragile-send-sync-non-atomic-wasm"]
 
 [dependencies]
-ab_glyph = { version = "0.2", optional = true }
 any_vec = "0.13"
 async-channel = {workspace=true}
 bytemuck = { workspace = true }
@@ -26,7 +24,6 @@ crunch = "0.5"
 futures-lite = {workspace=true}
 glam = { workspace = true, default-features = false, features = ["bytemuck", "libm"] }
 gltf = { workspace = true, optional = true }
-glyph_brush = { version = "0.7", optional = true }
 half = "2.3"
 image = { workspace = true, features = ["hdr"] }
 log = { workspace = true }
diff --git a/crates/renderling/src/atlas.rs b/crates/renderling/src/atlas.rs
index fc3fb2f1..be8b29ba 100644
--- a/crates/renderling/src/atlas.rs
+++ b/crates/renderling/src/atlas.rs
@@ -523,8 +523,8 @@ mod test {
     use crate::{
         shader::{
             gltf::*,
-            pbr::PbrMaterial,
-            stage::{Camera, LightingModel, RenderUnit, Transform, Vertex},
+            pbr::Material,
+            stage::{Camera, Transform, Vertex},
             texture::{GpuTexture, TextureAddressMode, TextureModes},
         },
         Renderling,
@@ -574,9 +574,9 @@ mod test {
             .modes
             .set_wrap_t(TextureAddressMode::CLAMP_TO_EDGE);
         let texels_tex_id = stage.append(&texels_tex);
-        let material_id = stage.append(&PbrMaterial {
+        let material_id = stage.append(&Material {
             albedo_texture: texels_tex_id,
-            lighting_model: LightingModel::NO_LIGHTING,
+            has_lighting: false,
             ..Default::default()
         });
         let mesh = stage
@@ -667,21 +667,21 @@ mod test {
             .set_wrap_t(TextureAddressMode::MIRRORED_REPEAT);
 
         let albedo_texture = stage.append(&clamp_tex);
-        let clamp_material_id = stage.append(&PbrMaterial {
+        let clamp_material_id = stage.append(&Material {
             albedo_texture,
-            lighting_model: LightingModel::NO_LIGHTING,
+            has_lighting: false,
             ..Default::default()
         });
         let albedo_texture = stage.append(&repeat_tex);
-        let repeat_material_id = stage.append(&PbrMaterial {
+        let repeat_material_id = stage.append(&Material {
             albedo_texture,
-            lighting_model: LightingModel::NO_LIGHTING,
+            has_lighting: false,
             ..Default::default()
         });
         let albedo_texture = stage.append(&mirror_tex);
-        let mirror_material_id = stage.append(&PbrMaterial {
+        let mirror_material_id = stage.append(&Material {
             albedo_texture,
-            lighting_model: LightingModel::NO_LIGHTING,
+            has_lighting: false,
             ..Default::default()
         });
 
@@ -831,23 +831,23 @@ mod test {
             .set_wrap_t(TextureAddressMode::MIRRORED_REPEAT);
 
         let albedo_texture = stage.append(&clamp_tex);
-        let clamp_material_id = stage.append(&PbrMaterial {
+        let clamp_material_id = stage.append(&Material {
             albedo_texture,
-            lighting_model: LightingModel::NO_LIGHTING,
+            has_lighting: false,
             ..Default::default()
         });
 
         let albedo_texture = stage.append(&repeat_tex);
-        let repeat_material_id = stage.append(&PbrMaterial {
+        let repeat_material_id = stage.append(&Material {
             albedo_texture,
-            lighting_model: LightingModel::NO_LIGHTING,
+            has_lighting: false,
             ..Default::default()
         });
 
         let albedo_texture = stage.append(&mirror_tex);
-        let mirror_material_id = stage.append(&PbrMaterial {
+        let mirror_material_id = stage.append(&Material {
             albedo_texture,
-            lighting_model: LightingModel::NO_LIGHTING,
+            has_lighting: false,
             ..Default::default()
         });
 
diff --git a/crates/renderling/src/lib.rs b/crates/renderling/src/lib.rs
index 4282cabd..aa829ed1 100644
--- a/crates/renderling/src/lib.rs
+++ b/crates/renderling/src/lib.rs
@@ -99,8 +99,6 @@ pub mod shader {
     pub use renderling_shader::*;
 }
 
-pub use renderling_shader::stage::{GpuEntityInfo, LightingModel};
-
 /// A CPU-side texture sampler.
 ///
 /// Provided primarily for testing purposes.
@@ -164,8 +162,9 @@ mod test {
     use pretty_assertions::assert_eq;
     use renderling_shader::{
         gltf as gl,
-        pbr::PbrMaterial,
-        stage::{light::*, Camera, RenderUnit, Transform, Vertex},
+        gltf::RenderUnit,
+        pbr::Material,
+        stage::{light::*, Camera, Transform, Vertex},
     };
 
     #[test]
@@ -398,7 +397,7 @@ mod test {
             scale: Vec3::new(6.0, 6.0, 6.0),
             rotation: Quat::from_axis_angle(Vec3::Y, std::f32::consts::FRAC_PI_4),
         });
-        let cube_two = stage.draw_unit(&render_unit);
+        let (_, cube_two_rendering) = stage.draw_unit(&render_unit);
 
         // we should see two colored cubes
         let img = r.render_image().unwrap();
@@ -406,14 +405,14 @@ mod test {
         let img_before = img;
 
         // update cube two making it invisible
-        stage.hide_unit(cube_two);
+        stage.hide_unit(cube_two_rendering);
 
         // we should see only one colored cube
         let img = r.render_image().unwrap();
         img_diff::assert_img_eq("cmy_cube/visible_after.png", img);
 
         // update cube two making in visible again
-        stage.show_unit(cube_two);
+        stage.show_unit(cube_two_rendering);
 
         // we should see two colored cubes again
         let img = r.render_image().unwrap();
@@ -465,7 +464,7 @@ mod test {
             ..Default::default()
         });
 
-        let cube = stage.draw_unit(&RenderUnit {
+        let (cube, _) = stage.draw_unit(&RenderUnit {
             camera,
             vertex_count: cube_vertex_count as u32,
             node_path,
@@ -551,9 +550,9 @@ mod test {
         let sandstone_tex = textures[0];
         let dirt_tex = textures[1];
         let sandstone_tex_id = stage.append(&sandstone_tex);
-        let material_id = stage.append(&PbrMaterial {
+        let material_id = stage.append(&Material {
             albedo_texture: sandstone_tex_id,
-            lighting_model: LightingModel::NO_LIGHTING,
+            has_lighting: false,
             ..Default::default()
         });
         let vertices = gpu_uv_unit_cube();
@@ -613,9 +612,9 @@ mod test {
         let img = AtlasImage::from_path("../../img/cheetah.jpg").unwrap();
         let textures = stage.set_images([img]).unwrap();
         let textures = stage.append_array(&textures);
-        let cheetah_material = stage.append(&PbrMaterial {
+        let cheetah_material = stage.append(&Material {
             albedo_texture: textures.at(0),
-            lighting_model: LightingModel::NO_LIGHTING,
+            has_lighting: false,
             ..Default::default()
         });
 
@@ -741,7 +740,7 @@ mod test {
         let lights = stage.append_array(&[dir_red.into(), dir_green.into(), dir_blue.into()]);
         stage.set_lights(lights);
 
-        let material = stage.append(&PbrMaterial::default());
+        let material = stage.append(&Material::default());
         let verts = renderling_shader::math::unit_cube()
             .into_iter()
             .map(|(p, n)| Vertex {
@@ -815,19 +814,19 @@ mod test {
         let (projection, view) = camera::default_ortho2d(100.0, 100.0);
         let camera = stage.append(&Camera::new(projection, view));
         let size = 1.0;
-        let cyan_material = stage.append(&PbrMaterial {
+        let cyan_material = stage.append(&Material {
             albedo_factor: Vec4::new(0.0, 1.0, 1.0, 1.0),
-            lighting_model: LightingModel::NO_LIGHTING,
+            has_lighting: false,
             ..Default::default()
         });
-        let yellow_material = stage.append(&PbrMaterial {
+        let yellow_material = stage.append(&Material {
             albedo_factor: Vec4::new(1.0, 1.0, 0.0, 1.0),
-            lighting_model: LightingModel::NO_LIGHTING,
+            has_lighting: false,
             ..Default::default()
         });
-        let red_material = stage.append(&PbrMaterial {
+        let red_material = stage.append(&Material {
             albedo_factor: Vec4::new(1.0, 0.0, 0.0, 1.0),
-            lighting_model: LightingModel::NO_LIGHTING,
+            has_lighting: false,
             ..Default::default()
         });
 
@@ -1007,7 +1006,7 @@ mod test {
                 let metallic = j as f32 / (k - 1) as f32;
                 let y = (diameter + spacing) * j as f32;
                 let mut prim = sphere_primitive;
-                prim.material = stage.append(&PbrMaterial {
+                prim.material = stage.append(&Material {
                     albedo_factor: Vec4::new(1.0, 1.0, 1.0, 1.0),
                     metallic_factor: metallic,
                     roughness_factor: roughness,
@@ -1041,10 +1040,4 @@ mod test {
         let img = r.render_linear_image().unwrap();
         img_diff::assert_img_eq("pbr/metallic_roughness_spheres.png", img);
     }
-
-    #[test]
-    fn is_skin_sanity() {
-        let info = GpuEntityInfo(2048);
-        assert!(info.is_skin());
-    }
 }
diff --git a/crates/renderling/src/linkage/convolution-vertex_prefilter_environment_cubemap.spv b/crates/renderling/src/linkage/convolution-vertex_prefilter_environment_cubemap.spv
index 2c24629b..0e9bbbac 100644
Binary files a/crates/renderling/src/linkage/convolution-vertex_prefilter_environment_cubemap.spv and b/crates/renderling/src/linkage/convolution-vertex_prefilter_environment_cubemap.spv differ
diff --git a/crates/renderling/src/linkage/skybox-vertex.spv b/crates/renderling/src/linkage/skybox-vertex.spv
index 1283523f..0b708fac 100644
Binary files a/crates/renderling/src/linkage/skybox-vertex.spv and b/crates/renderling/src/linkage/skybox-vertex.spv differ
diff --git a/crates/renderling/src/linkage/skybox-vertex_cubemap.spv b/crates/renderling/src/linkage/skybox-vertex_cubemap.spv
index f7054025..79a162ee 100644
Binary files a/crates/renderling/src/linkage/skybox-vertex_cubemap.spv and b/crates/renderling/src/linkage/skybox-vertex_cubemap.spv differ
diff --git a/crates/renderling/src/linkage/stage-gltf_fragment.spv b/crates/renderling/src/linkage/stage-gltf_fragment.spv
index 84ab130f..c9d332ae 100644
Binary files a/crates/renderling/src/linkage/stage-gltf_fragment.spv and b/crates/renderling/src/linkage/stage-gltf_fragment.spv differ
diff --git a/crates/renderling/src/linkage/stage-gltf_vertex.spv b/crates/renderling/src/linkage/stage-gltf_vertex.spv
index 3ddefd49..c2ce04ed 100644
Binary files a/crates/renderling/src/linkage/stage-gltf_vertex.spv and b/crates/renderling/src/linkage/stage-gltf_vertex.spv differ
diff --git a/crates/renderling/src/linkage/stage-test_i8_i16_extraction.spv b/crates/renderling/src/linkage/stage-test_i8_i16_extraction.spv
index 1fad7572..8392d935 100644
Binary files a/crates/renderling/src/linkage/stage-test_i8_i16_extraction.spv and b/crates/renderling/src/linkage/stage-test_i8_i16_extraction.spv differ
diff --git a/crates/renderling/src/linkage/stage-vertex.spv b/crates/renderling/src/linkage/stage-vertex.spv
new file mode 100644
index 00000000..b1a4bf30
Binary files /dev/null and b/crates/renderling/src/linkage/stage-vertex.spv differ
diff --git a/crates/renderling/src/linkage/tonemapping-fragment.spv b/crates/renderling/src/linkage/tonemapping-fragment.spv
index 4a8c61aa..67ff10c1 100644
Binary files a/crates/renderling/src/linkage/tonemapping-fragment.spv and b/crates/renderling/src/linkage/tonemapping-fragment.spv differ
diff --git a/crates/renderling/src/linkage/tutorial-slabbed_render_unit.spv b/crates/renderling/src/linkage/tutorial-slabbed_render_unit.spv
index 8ce4c700..f6b60859 100644
Binary files a/crates/renderling/src/linkage/tutorial-slabbed_render_unit.spv and b/crates/renderling/src/linkage/tutorial-slabbed_render_unit.spv differ
diff --git a/crates/renderling/src/linkage/tutorial-slabbed_vertices.spv b/crates/renderling/src/linkage/tutorial-slabbed_vertices.spv
index 9001018d..dc95f6c8 100644
Binary files a/crates/renderling/src/linkage/tutorial-slabbed_vertices.spv and b/crates/renderling/src/linkage/tutorial-slabbed_vertices.spv differ
diff --git a/crates/renderling/src/linkage/tutorial-slabbed_vertices_no_instance.spv b/crates/renderling/src/linkage/tutorial-slabbed_vertices_no_instance.spv
index f6ab41b9..c99de937 100644
Binary files a/crates/renderling/src/linkage/tutorial-slabbed_vertices_no_instance.spv and b/crates/renderling/src/linkage/tutorial-slabbed_vertices_no_instance.spv differ
diff --git a/crates/renderling/src/linkage/ui-fragment.spv b/crates/renderling/src/linkage/ui-fragment.spv
index 1d1880bd..31143ade 100644
Binary files a/crates/renderling/src/linkage/ui-fragment.spv and b/crates/renderling/src/linkage/ui-fragment.spv differ
diff --git a/crates/renderling/src/linkage/ui-vertex.spv b/crates/renderling/src/linkage/ui-vertex.spv
index e6374f92..d3240eb3 100644
Binary files a/crates/renderling/src/linkage/ui-vertex.spv and b/crates/renderling/src/linkage/ui-vertex.spv differ
diff --git a/crates/renderling/src/scene.rs b/crates/renderling/src/scene.rs
index 9f8f1e8a..e69de29b 100644
--- a/crates/renderling/src/scene.rs
+++ b/crates/renderling/src/scene.rs
@@ -1,1118 +0,0 @@
-//! Build GPU scenes from the CPU.
-use std::sync::Arc;
-
-use glam::{Mat4, Vec3};
-use moongraph::{Move, View, ViewMut};
-use renderling_shader::debug::DebugChannel;
-use snafu::prelude::*;
-
-pub use renderling_shader::{
-    pbr::PbrMaterial,
-    stage::{DrawIndirect, GpuConstants, GpuEntity, GpuLight, GpuToggles, Vertex},
-    texture::*,
-};
-
-use crate::{
-    bloom::BloomResult, frame::FrameTextureView, hdr::HdrSurface, Atlas, BufferArray, DepthTexture,
-    Device, HasWgpuBuffer, Id, Queue, Skybox, SkyboxRenderPipeline, Uniform,
-};
-
-mod entity;
-pub use entity::*;
-
-mod img;
-pub use img::*;
-
-mod light;
-pub use light::*;
-
-#[cfg(feature = "gltf")]
-mod gltf_support;
-#[cfg(feature = "gltf")]
-pub use gltf_support::*;
-
-#[derive(Debug, Snafu)]
-pub enum SceneError {
-    #[snafu(display("{source}"))]
-    Buffer { source: crate::BufferError },
-
-    #[snafu(display("Invalid indirect draw count"))]
-    InvalidIndirectCount,
-
-    #[snafu(display("{source}"))]
-    Atlas { source: crate::AtlasError },
-
-    #[snafu(display("Missing texture {id}"))]
-    MissingTexture { id: u32 },
-
-    #[snafu(display("Missing image {index}"))]
-    MissingImage { index: usize },
-
-    #[snafu(display("All atlases are used."))]
-    ExhaustedAtlases,
-
-    #[snafu(display("Images cannot be packed. The texture atlas has already been packed."))]
-    AlreadyPackedAtlas,
-
-    #[snafu(display(
-        "The scene builder has {name}s, but a text scene only contains one {name} which is \
-         automatically included."
-    ))]
-    TextSceneSingleton { name: &'static str },
-
-    #[snafu(display("Missing the glyph.cache"))]
-    MissingCache,
-
-    #[snafu(display("Missing entity {id:?}"))]
-    MissingEntity { id: Id<GpuEntity> },
-}
-
-pub(crate) fn scene_render_usage() -> wgpu::BufferUsages {
-    wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::COPY_SRC
-}
-
-pub(crate) fn scene_indirect_usage() -> wgpu::BufferUsages {
-    wgpu::BufferUsages::STORAGE
-        | wgpu::BufferUsages::COPY_DST
-        | wgpu::BufferUsages::COPY_SRC
-        | wgpu::BufferUsages::INDIRECT
-}
-
-/// Helps build textures, storing texture parameters before images are packed
-/// into the atlas.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct TextureParams {
-    // The index of the image this texture references.
-    pub image_index: usize,
-    // The wrapping in S.
-    pub mode_s: TextureAddressMode,
-    // The wrapping in T.
-    pub mode_t: TextureAddressMode,
-}
-
-impl Default for TextureParams {
-    fn default() -> Self {
-        Self {
-            image_index: Default::default(),
-            mode_s: Default::default(),
-            mode_t: Default::default(),
-        }
-    }
-}
-
-/// Sets up the scene using different build phases.
-#[derive(Debug)]
-pub struct SceneBuilder {
-    pub device: Arc<wgpu::Device>,
-    pub queue: Arc<wgpu::Queue>,
-    pub debug_channel: DebugChannel,
-    pub projection: Mat4,
-    pub view: Mat4,
-    pub images: Vec<SceneImage>,
-    pub skybox_image: Option<SceneImage>,
-    pub skybox: Option<Skybox>,
-    pub textures: Vec<TextureParams>,
-    pub materials: Vec<PbrMaterial>,
-    pub vertices: Vec<Vertex>,
-    pub entities: Vec<GpuEntity>,
-    pub lights: Vec<GpuLight>,
-    pub use_lighting: bool,
-}
-
-impl SceneBuilder {
-    pub fn new(device: Arc<wgpu::Device>, queue: Arc<wgpu::Queue>) -> Self {
-        Self {
-            device,
-            queue,
-            debug_channel: DebugChannel::None.into(),
-            projection: Mat4::IDENTITY,
-            view: Mat4::IDENTITY,
-            images: vec![],
-            skybox_image: None,
-            skybox: None,
-            vertices: vec![],
-            textures: vec![],
-            materials: vec![],
-            entities: vec![],
-            lights: vec![],
-            use_lighting: true,
-        }
-    }
-
-    /// Set whether or not to use **ANY** lighting.
-    /// If set to false, this will overide model and material settings.
-    pub fn set_use_lighting(&mut self, use_lighting: bool) {
-        self.use_lighting = use_lighting;
-    }
-
-    /// Set whether or not to use **ANY** lighting.
-    /// If set to false, this will overide model and material settings.
-    pub fn with_lighting(mut self, use_lighting: bool) -> Self {
-        self.set_use_lighting(use_lighting);
-        self
-    }
-
-    /// Add a material.
-    pub fn add_material(&mut self, material: PbrMaterial) -> Id<PbrMaterial> {
-        let id = self.materials.len();
-        self.materials.push(material);
-        Id::new(id as u32)
-    }
-
-    /// Add an image and return a texture id for it.
-    pub fn add_image_texture_mode(
-        &mut self,
-        img: impl Into<SceneImage>,
-        mode_s: TextureAddressMode,
-        mode_t: TextureAddressMode,
-    ) -> Id<GpuTexture> {
-        let image_index = self.images.len();
-        self.images.push(img.into());
-        self.add_texture(TextureParams {
-            image_index,
-            mode_s,
-            mode_t,
-        })
-    }
-
-    /// Add an image and return a texture id for it.
-    ///
-    /// The texture sampling mode defaults to "repeat".
-    pub fn add_image_texture(&mut self, img: impl Into<SceneImage>) -> Id<GpuTexture> {
-        self.add_image_texture_mode(
-            img,
-            TextureAddressMode::CLAMP_TO_EDGE,
-            TextureAddressMode::CLAMP_TO_EDGE,
-        )
-    }
-
-    /// Add an image, without adding an explicit texture.
-    ///
-    /// Returns the index of the image.
-    pub fn add_image(&mut self, img: impl Into<SceneImage>) -> usize {
-        let index = self.images.len();
-        self.images.push(img.into());
-        index
-    }
-
-    /// Add a texture referencing an image.
-    pub fn add_texture(&mut self, params: TextureParams) -> Id<GpuTexture> {
-        let texture_id = self.textures.len();
-        self.textures.push(params);
-        Id::new(texture_id as u32)
-    }
-
-    /// Add a skybox image from bytes.
-    ///
-    /// Currently only one skybox image is supported, so this function returns
-    /// nothing.
-    ///
-    /// ## Panics
-    /// This function panics if there is an error decoding the HDR image data.
-    pub fn add_skybox_image_from_bytes(&mut self, hdr_data: &[u8]) {
-        self.skybox_image = Some(SceneImage::from_hdr_bytes(hdr_data).unwrap());
-    }
-
-    /// Add a skybox image from bytes.
-    ///
-    /// Currently only one skybox image is supported, so this function returns
-    /// nothing.
-    pub fn with_skybox_image_from_bytes(mut self, hdr_data: &[u8]) -> Self {
-        self.add_skybox_image_from_bytes(hdr_data);
-        self
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    /// Add a skybox image from path.
-    ///
-    /// Not available on WASM.
-    ///
-    /// Currently only one skybox image is supported, so this function returns
-    /// nothing.
-    ///
-    /// ## Panics
-    /// This function panics if there is an error decoding the HDR image data.
-    pub fn add_skybox_image_from_path(&mut self, hdr_path: impl AsRef<std::path::Path>) {
-        self.skybox_image = Some(SceneImage::from_hdr_path(hdr_path).unwrap());
-    }
-
-    /// Add a pre-made [`Skybox`].
-    ///
-    /// This overrides any path or image given to use for the skybox.
-    pub fn add_skybox(&mut self, skybox: Skybox) {
-        self.skybox = Some(skybox);
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    /// Add a skybox image from path.
-    ///
-    /// Not available on WASM.
-    ///
-    /// Currently only one skybox image is supported, so this function returns
-    /// nothing.
-    pub fn with_skybox_image_from_path(mut self, hdr_path: impl AsRef<std::path::Path>) -> Self {
-        self.add_skybox_image_from_path(hdr_path);
-        self
-    }
-
-    /// Add a pre-made [`Skybox`].
-    ///
-    /// This overrides any path or image given to use for the skybox.
-    pub fn with_skybox(mut self, skybox: Skybox) -> Self {
-        self.add_skybox(skybox);
-        self
-    }
-
-    pub fn with_camera(mut self, projection: Mat4, view: Mat4) -> Self {
-        self.set_camera(projection, view);
-        self
-    }
-
-    pub fn set_camera(&mut self, projection: Mat4, view: Mat4) {
-        self.projection = projection;
-        self.view = view;
-    }
-
-    pub fn set_debug_channel(&mut self, channel: DebugChannel) {
-        self.debug_channel = channel.into();
-    }
-
-    pub fn with_debug_channel(mut self, channel: DebugChannel) -> Self {
-        self.set_debug_channel(channel);
-        self
-    }
-
-    pub fn new_directional_light(&mut self) -> GpuDirectionalLightBuilder<'_> {
-        GpuDirectionalLightBuilder::new(&mut self.lights)
-    }
-
-    pub fn new_spot_light(&mut self) -> GpuSpotLightBuilder<'_> {
-        GpuSpotLightBuilder::new(&mut self.lights)
-    }
-
-    pub fn new_point_light(&mut self) -> GpuPointLightBuilder<'_> {
-        GpuPointLightBuilder::new(&mut self.lights)
-    }
-
-    /// Add a meshlet.
-    ///
-    /// Returns the index of the first vertex of the newly created meshlet and
-    /// the vertex count.
-    pub fn add_meshlet(&mut self, vertices: impl IntoIterator<Item = Vertex>) -> (u32, u32) {
-        let vertices = vertices.into_iter().collect::<Vec<_>>();
-        let start = self.vertices.len();
-        let len = vertices.len();
-        self.vertices.extend(vertices);
-        (start as u32, len as u32)
-    }
-
-    pub fn new_entity(&mut self) -> EntityBuilder<'_> {
-        EntityBuilder {
-            scene: self,
-            entity: GpuEntity::default(),
-        }
-    }
-
-    pub fn get_image_for_texture_id_mut(
-        &mut self,
-        tex_id: &Id<GpuTexture>,
-    ) -> Option<&mut SceneImage> {
-        let texture = self.textures.get(tex_id.index())?;
-        self.images.get_mut(texture.image_index)
-    }
-
-    #[cfg(all(feature = "gltf", not(target_arch = "wasm32")))]
-    /// Load the gltf file at the given path.
-    ///
-    /// The first material in `self` will be used as the default material for
-    /// the gltf or none if not available.
-    pub fn gltf_load(
-        &mut self,
-        path: impl AsRef<std::path::Path>,
-    ) -> Result<gltf_support::GltfLoader, gltf_support::GltfLoaderError> {
-        log::trace!("loading gltf file '{}'", path.as_ref().display());
-        let (document, buffers, images) =
-            gltf::import(path).map_err(|source| gltf_support::GltfLoaderError::Gltf {
-                source,
-                cwd: std::env::current_dir()
-                    .map(|p| format!("{}", p.display()))
-                    .unwrap_or("?".to_string()),
-            })?;
-        gltf_support::GltfLoader::load(self, document, buffers, images)
-    }
-
-    #[cfg(feature = "gltf")]
-    /// Load the gltf file of the given bytes.
-    ///
-    /// The first material in `self` will be used as the default material for
-    /// the gltf or none if not available.
-    pub fn gltf_load_bytes(
-        &mut self,
-        bytes: Vec<u8>,
-    ) -> Result<gltf_support::GltfLoader, gltf_support::GltfLoaderError> {
-        let (document, buffers, images) =
-            gltf::import_slice(&bytes).map_err(|source| gltf_support::GltfLoaderError::Gltf {
-                source,
-                cwd: "{bytes}".to_string(),
-            })?;
-        gltf_support::GltfLoader::load(self, document, buffers, images)
-    }
-
-    pub fn build(self) -> Result<Scene, SceneError> {
-        Scene::new(self)
-    }
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-pub type MutableBufferArray<T> = BufferArray<T>;
-#[cfg(target_arch = "wasm32")]
-pub type MutableBufferArray<T> = BufferArray<T, crate::CpuAndGpuBuffer>;
-
-pub struct Scene {
-    pub vertices: BufferArray<Vertex>,
-    pub entities: MutableBufferArray<GpuEntity>,
-    pub lights: BufferArray<GpuLight>,
-    pub materials: BufferArray<PbrMaterial>,
-    pub textures: BufferArray<GpuTexture>,
-    pub indirect_draws: MutableBufferArray<DrawIndirect>,
-    pub constants: Uniform<GpuConstants>,
-    pub skybox: Skybox,
-    pub environment_bindgroup: wgpu::BindGroup,
-    pub atlas: Atlas,
-    skybox_update: Option<Option<SceneImage>>,
-    cull_bindgroup: wgpu::BindGroup,
-    render_buffers_bindgroup: wgpu::BindGroup,
-    render_atlas_bindgroup: wgpu::BindGroup,
-}
-
-impl Scene {
-    /// Creates a new scene with the given atlas.
-    pub fn new(mut scene_builder: SceneBuilder) -> Result<Self, SceneError> {
-        let atlas = Atlas::pack(
-            &scene_builder.device,
-            &scene_builder.queue,
-            std::mem::take(&mut scene_builder.images),
-        )
-        .context(AtlasSnafu)?;
-        log::trace!("atlas created");
-        Self::new_with_atlas(scene_builder, atlas)
-    }
-
-    /// Creates a new scene on the GPU.
-    pub fn new_with_atlas(scene_builder: SceneBuilder, atlas: Atlas) -> Result<Self, SceneError> {
-        let SceneBuilder {
-            device,
-            queue,
-            debug_channel,
-            projection,
-            view,
-            images,
-            skybox_image,
-            skybox,
-            textures,
-            materials,
-            vertices,
-            entities,
-            lights,
-            use_lighting,
-        } = scene_builder;
-        snafu::ensure!(images.is_empty(), AlreadyPackedAtlasSnafu);
-        let debug_mode = debug_channel.into();
-        let frames = textures.into_iter();
-        let mut textures = vec![];
-        for TextureParams {
-            image_index,
-            mode_s,
-            mode_t,
-        } in frames
-        {
-            let (offset_px, size_px) = atlas
-                .get_frame(image_index)
-                .context(MissingImageSnafu { index: image_index })?;
-            textures.push(GpuTexture {
-                offset_px,
-                size_px,
-                modes: {
-                    let mut modes = TextureModes::default();
-                    modes.set_wrap_s(mode_s);
-                    modes.set_wrap_t(mode_t);
-                    modes
-                },
-                ..Default::default()
-            });
-        }
-        let textures = BufferArray::new(&device, &textures, textures.len(), scene_render_usage());
-        let vertices = BufferArray::new(&device, &vertices, vertices.len(), scene_render_usage());
-        let draws = entities
-            .iter()
-            .map(|_| DrawIndirect::default())
-            .collect::<Vec<_>>();
-        let indirect_draws: MutableBufferArray<_> =
-            BufferArray::new(&device, &draws, draws.len(), scene_indirect_usage());
-        let entities: MutableBufferArray<_> =
-            BufferArray::new(&device, &entities, entities.len(), scene_render_usage());
-        let lights = BufferArray::new(&device, &lights, lights.len(), scene_render_usage());
-        let materials =
-            BufferArray::new(&device, &materials, materials.len(), scene_render_usage());
-        let constants = Uniform::new(
-            &device,
-            GpuConstants {
-                camera_projection: projection,
-                camera_pos: view.inverse().transform_point3(Vec3::ZERO).extend(0.0),
-                camera_view: view,
-                atlas_size: atlas.size,
-                debug_mode,
-                toggles: {
-                    let mut toggles = GpuToggles::default();
-                    toggles.set_has_skybox(skybox_image.is_some() || skybox.is_some());
-                    toggles.set_use_lighting(use_lighting);
-                    toggles
-                },
-            },
-            wgpu::BufferUsages::UNIFORM
-                | wgpu::BufferUsages::COPY_DST
-                | wgpu::BufferUsages::COPY_SRC,
-            wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
-        );
-        let skybox = if let Some(skybox) = skybox {
-            log::trace!("scene has skybox");
-            skybox
-        } else if let Some(skybox_img) = skybox_image {
-            log::trace!("scene will build a skybox");
-            Skybox::new(&device, &queue, skybox_img, Id::NONE)
-        } else {
-            log::trace!("skybox is empty");
-            Skybox::empty(&device, &queue)
-        };
-        let environment_bindgroup = crate::skybox::create_skybox_bindgroup(
-            &device,
-            &constants,
-            &skybox.environment_cubemap,
-        );
-
-        let cull_bindgroup = device.create_bind_group(&wgpu::BindGroupDescriptor {
-            label: Some("Scene::new cull_bindgroup"),
-            layout: &scene_draw_indirect_bindgroup_layout(&device),
-            entries: &[wgpu::BindGroupEntry {
-                binding: 0,
-                resource: indirect_draws.buffer.get_wgpu_buffer().as_entire_binding(),
-            }],
-        });
-
-        let render_buffers_bindgroup = create_scene_buffers_bindgroup(
-            &device,
-            &constants,
-            &vertices,
-            &entities.buffer.get_wgpu_buffer(),
-            &lights,
-            &materials,
-            &skybox,
-        );
-
-        let render_atlas_bindgroup = device.create_bind_group(&wgpu::BindGroupDescriptor {
-            label: Some("Scene::new render_atlas_bindgroup"),
-            layout: &scene_atlas_bindgroup_layout(&device),
-            entries: &[
-                wgpu::BindGroupEntry {
-                    binding: 0,
-                    resource: wgpu::BindingResource::TextureView(&atlas.texture.view),
-                },
-                wgpu::BindGroupEntry {
-                    binding: 1,
-                    resource: wgpu::BindingResource::Sampler(&atlas.texture.sampler),
-                },
-                wgpu::BindGroupEntry {
-                    binding: 2,
-                    resource: textures.get_buffer().as_entire_binding(),
-                },
-            ],
-        });
-
-        let mut scene = Self {
-            render_buffers_bindgroup,
-            render_atlas_bindgroup,
-            vertices,
-            textures,
-            materials,
-            entities,
-            constants,
-            indirect_draws,
-            cull_bindgroup,
-            atlas,
-            lights,
-            skybox,
-            skybox_update: None,
-            environment_bindgroup,
-        };
-        scene.update(&device, &queue);
-        Ok(scene)
-    }
-
-    /// Update the scene.
-    ///
-    /// This uploads changed data to the GPU and submits the queue.
-    pub fn update(&mut self, device: &wgpu::Device, queue: &wgpu::Queue) {
-        let Self {
-            constants,
-            render_buffers_bindgroup,
-            render_atlas_bindgroup: _,
-            indirect_draws: _,
-            cull_bindgroup: _,
-            atlas: _,
-            skybox,
-            skybox_update,
-            environment_bindgroup,
-            vertices,
-            entities,
-            materials,
-            textures,
-            lights,
-        } = self;
-        vertices.update(queue);
-        entities.update(queue);
-        materials.update(queue);
-        textures.update(queue);
-        lights.update(queue);
-        constants.update(queue);
-        match skybox_update.take() {
-            None => {
-                // no update, do nothing
-            }
-            Some(None) => {
-                // skybox should be "removed"
-                constants.toggles.set_has_skybox(false);
-            }
-            Some(Some(img)) => {
-                // skybox should change image
-                log::trace!("skybox changed");
-                constants.toggles.set_has_skybox(true);
-                *skybox = Skybox::new(device, queue, img, Id::NONE);
-                *environment_bindgroup = crate::skybox::create_skybox_bindgroup(
-                    device,
-                    constants,
-                    &skybox.environment_cubemap,
-                );
-                // we also have to create a new render buffers bindgroup because irradiance is
-                // part of that
-                *render_buffers_bindgroup = create_scene_buffers_bindgroup(
-                    device,
-                    constants,
-                    vertices,
-                    entities.buffer.get_wgpu_buffer(),
-                    lights,
-                    materials,
-                    &self.skybox,
-                );
-            }
-        }
-        queue.submit(std::iter::empty());
-    }
-
-    /// Set the camera.
-    ///
-    /// The data is not uploaded to the cpu until [`Scene::update`] has been
-    /// called.
-    pub fn set_camera(&mut self, proj: Mat4, view: Mat4) {
-        if self.constants.camera_projection != proj || self.constants.camera_view != view {
-            self.constants.camera_projection = proj;
-            self.constants.camera_view = view;
-            self.constants.camera_pos = view.inverse().transform_point3(Vec3::ZERO).extend(0.0);
-        }
-    }
-
-    /// Set the camera projection.
-    ///
-    /// The data is not uploaded to the cpu until [`Scene::update`] has been
-    /// called.
-    pub fn set_camera_projection(&mut self, proj: Mat4) {
-        let view = self.constants.camera_view;
-        self.set_camera(proj, view);
-    }
-
-    /// Set the camera view.
-    ///
-    /// The data is not uploaded to the cpu until [`Scene::update`] has been
-    /// called.
-    pub fn set_camera_view(&mut self, view: Mat4) {
-        let proj = self.constants.camera_projection;
-        self.set_camera(proj, view);
-    }
-
-    /// Update/set an entity.
-    pub fn update_entity(&mut self, entity: GpuEntity) -> Result<(), SceneError> {
-        let (i, n) = self
-            .entities
-            .overwrite(entity.id.index(), std::iter::once(entity))
-            .context(BufferSnafu)?;
-        debug_assert_eq!((entity.id.index(), 1), (i, n));
-        Ok(())
-    }
-
-    pub fn get_debug_channel(&self) -> DebugChannel {
-        self.constants.debug_mode.into()
-    }
-
-    pub fn set_debug_channel(&mut self, channel: DebugChannel) {
-        let current: DebugChannel = self.constants.debug_mode.into();
-        if current != channel {
-            log::debug!("setting debug mode from '{current:?}' to '{channel:?}'");
-            self.constants.debug_mode = channel.into();
-        }
-    }
-
-    /// Queues an update to the skybox.
-    ///
-    /// This will not update any GPU resources until [`Scene::update`] is
-    /// called.
-    pub fn set_skybox_img(&mut self, may_img: Option<SceneImage>) {
-        self.skybox_update = Some(may_img);
-    }
-}
-
-pub fn create_scene_buffers_bindgroup(
-    device: &wgpu::Device,
-    constants: &Uniform<GpuConstants>,
-    vertices: &BufferArray<Vertex>,
-    entities: &wgpu::Buffer,
-    lights: &BufferArray<GpuLight>,
-    materials: &BufferArray<PbrMaterial>,
-    skybox: &Skybox,
-) -> wgpu::BindGroup {
-    device.create_bind_group(&wgpu::BindGroupDescriptor {
-        label: Some("Scene::new render_buffers_bindgroup"),
-        layout: &scene_buffers_bindgroup_layout(&device),
-        entries: &[
-            wgpu::BindGroupEntry {
-                binding: 0,
-                resource: constants.buffer().as_entire_binding(),
-            },
-            wgpu::BindGroupEntry {
-                binding: 1,
-                resource: vertices.get_buffer().as_entire_binding(),
-            },
-            wgpu::BindGroupEntry {
-                binding: 2,
-                resource: entities.as_entire_binding(),
-            },
-            wgpu::BindGroupEntry {
-                binding: 3,
-                resource: lights.get_buffer().as_entire_binding(),
-            },
-            wgpu::BindGroupEntry {
-                binding: 4,
-                resource: materials.get_buffer().as_entire_binding(),
-            },
-            wgpu::BindGroupEntry {
-                binding: 5,
-                resource: wgpu::BindingResource::TextureView(&skybox.irradiance_cubemap.view),
-            },
-            wgpu::BindGroupEntry {
-                binding: 6,
-                resource: wgpu::BindingResource::Sampler(&skybox.irradiance_cubemap.sampler),
-            },
-            wgpu::BindGroupEntry {
-                binding: 7,
-                resource: wgpu::BindingResource::TextureView(
-                    &skybox.prefiltered_environment_cubemap.view,
-                ),
-            },
-            wgpu::BindGroupEntry {
-                binding: 8,
-                resource: wgpu::BindingResource::Sampler(
-                    &skybox.prefiltered_environment_cubemap.sampler,
-                ),
-            },
-            wgpu::BindGroupEntry {
-                binding: 9,
-                resource: wgpu::BindingResource::TextureView(&skybox.brdf_lut.view),
-            },
-            wgpu::BindGroupEntry {
-                binding: 10,
-                resource: wgpu::BindingResource::Sampler(&skybox.brdf_lut.sampler),
-            },
-        ],
-    })
-}
-
-pub fn scene_buffers_bindgroup_layout(device: &wgpu::Device) -> wgpu::BindGroupLayout {
-    let visibility =
-        wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT | wgpu::ShaderStages::COMPUTE;
-    let cfg = wgpu::BindGroupLayoutEntry {
-        binding: 0,
-        visibility,
-        ty: wgpu::BindingType::Buffer {
-            ty: wgpu::BufferBindingType::Uniform,
-            has_dynamic_offset: false,
-            min_binding_size: None,
-        },
-        count: None,
-    };
-    let mut entries = vec![cfg];
-    let buffers = (1..5)
-        .map(|binding| wgpu::BindGroupLayoutEntry {
-            binding,
-            visibility,
-            ty: wgpu::BindingType::Buffer {
-                ty: wgpu::BufferBindingType::Storage { read_only: true },
-                has_dynamic_offset: false,
-                min_binding_size: None,
-            },
-            count: None,
-        })
-        .collect::<Vec<_>>();
-    entries.extend(buffers);
-    entries.extend([
-        wgpu::BindGroupLayoutEntry {
-            binding: 5,
-            visibility: wgpu::ShaderStages::FRAGMENT,
-            ty: wgpu::BindingType::Texture {
-                sample_type: wgpu::TextureSampleType::Float { filterable: true },
-                view_dimension: wgpu::TextureViewDimension::Cube,
-                multisampled: false,
-            },
-            count: None,
-        },
-        wgpu::BindGroupLayoutEntry {
-            binding: 6,
-            visibility: wgpu::ShaderStages::FRAGMENT,
-            ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
-            count: None,
-        },
-        wgpu::BindGroupLayoutEntry {
-            binding: 7,
-            visibility: wgpu::ShaderStages::FRAGMENT,
-            ty: wgpu::BindingType::Texture {
-                sample_type: wgpu::TextureSampleType::Float { filterable: true },
-                view_dimension: wgpu::TextureViewDimension::Cube,
-                multisampled: false,
-            },
-            count: None,
-        },
-        wgpu::BindGroupLayoutEntry {
-            binding: 8,
-            visibility: wgpu::ShaderStages::FRAGMENT,
-            ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
-            count: None,
-        },
-        wgpu::BindGroupLayoutEntry {
-            binding: 9,
-            visibility: wgpu::ShaderStages::FRAGMENT,
-            ty: wgpu::BindingType::Texture {
-                sample_type: wgpu::TextureSampleType::Float { filterable: true },
-                view_dimension: wgpu::TextureViewDimension::D2,
-                multisampled: false,
-            },
-            count: None,
-        },
-        wgpu::BindGroupLayoutEntry {
-            binding: 10,
-            visibility: wgpu::ShaderStages::FRAGMENT,
-            ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
-            count: None,
-        },
-    ]);
-    device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-        label: Some("scene buffers and lighting"),
-        entries: &entries,
-    })
-}
-
-pub fn scene_atlas_bindgroup_layout(device: &wgpu::Device) -> wgpu::BindGroupLayout {
-    device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-        label: Some("scene atlas"),
-        entries: &[
-            wgpu::BindGroupLayoutEntry {
-                binding: 0,
-                visibility: wgpu::ShaderStages::FRAGMENT,
-                ty: wgpu::BindingType::Texture {
-                    sample_type: wgpu::TextureSampleType::Float { filterable: true },
-                    view_dimension: wgpu::TextureViewDimension::D2,
-                    multisampled: false,
-                },
-                count: None,
-            },
-            wgpu::BindGroupLayoutEntry {
-                binding: 1,
-                visibility: wgpu::ShaderStages::FRAGMENT,
-                ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
-                count: None,
-            },
-            wgpu::BindGroupLayoutEntry {
-                binding: 2,
-                visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
-                ty: wgpu::BindingType::Buffer {
-                    ty: wgpu::BufferBindingType::Storage { read_only: true },
-                    has_dynamic_offset: false,
-                    min_binding_size: None,
-                },
-                count: None,
-            },
-        ],
-    })
-}
-
-pub fn scene_draw_indirect_bindgroup_layout(device: &wgpu::Device) -> wgpu::BindGroupLayout {
-    device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-        label: Some("scene compute cull indirect"),
-        entries: &[wgpu::BindGroupLayoutEntry {
-            binding: 0,
-            visibility: wgpu::ShaderStages::COMPUTE,
-            ty: wgpu::BindingType::Buffer {
-                ty: wgpu::BufferBindingType::Storage { read_only: false },
-                has_dynamic_offset: false,
-                min_binding_size: None,
-            },
-            count: None,
-        }],
-    })
-}
-
-pub fn create_scene_render_pipeline(
-    device: &wgpu::Device,
-    format: wgpu::TextureFormat,
-) -> wgpu::RenderPipeline {
-    log::trace!("creating scene render pipeline with format '{format:?}'");
-    let label = Some("scene render pipeline");
-    let vertex_shader =
-        device.create_shader_module(wgpu::include_spirv!("linkage/stage-main_vertex_scene.spv"));
-    let fragment_shader = device.create_shader_module(wgpu::include_spirv!(
-        "linkage/stage-main_fragment_scene.spv"
-    ));
-    let scene_buffers_layout = scene_buffers_bindgroup_layout(device);
-    let scene_atlas_layout = scene_atlas_bindgroup_layout(device);
-    let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-        label,
-        bind_group_layouts: &[&scene_buffers_layout, &scene_atlas_layout],
-        push_constant_ranges: &[],
-    });
-    let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-        label,
-        layout: Some(&layout),
-        vertex: wgpu::VertexState {
-            module: &vertex_shader,
-            entry_point: "stage::main_vertex_scene",
-            buffers: &[],
-        },
-        primitive: wgpu::PrimitiveState {
-            topology: wgpu::PrimitiveTopology::TriangleList,
-            strip_index_format: None,
-            front_face: wgpu::FrontFace::Ccw,
-            cull_mode: None,
-            unclipped_depth: false,
-            polygon_mode: wgpu::PolygonMode::Fill,
-            conservative: false,
-        },
-        depth_stencil: Some(wgpu::DepthStencilState {
-            format: wgpu::TextureFormat::Depth32Float,
-            depth_write_enabled: true,
-            depth_compare: wgpu::CompareFunction::Less,
-            stencil: wgpu::StencilState::default(),
-            bias: wgpu::DepthBiasState::default(),
-        }),
-        multisample: wgpu::MultisampleState {
-            mask: !0,
-            alpha_to_coverage_enabled: false,
-            count: 1,
-        },
-        fragment: Some(wgpu::FragmentState {
-            module: &fragment_shader,
-            entry_point: "stage::main_fragment_scene",
-            targets: &[
-                Some(wgpu::ColorTargetState {
-                    format,
-                    blend: Some(wgpu::BlendState::ALPHA_BLENDING),
-                    write_mask: wgpu::ColorWrites::ALL,
-                }),
-                Some(wgpu::ColorTargetState {
-                    format,
-                    blend: Some(wgpu::BlendState::ALPHA_BLENDING),
-                    write_mask: wgpu::ColorWrites::ALL,
-                }),
-            ],
-        }),
-        multiview: None,
-    });
-    pipeline
-}
-
-pub fn create_scene_compute_cull_pipeline(device: &wgpu::Device) -> wgpu::ComputePipeline {
-    let label = Some("scene compute cull pipeline");
-    let shader_crate = device.create_shader_module(wgpu::include_spirv!(
-        "linkage/stage-compute_cull_entities.spv"
-    ));
-    let scene_buffers_layout = scene_buffers_bindgroup_layout(device);
-    let indirect_buffers_layout = scene_draw_indirect_bindgroup_layout(device);
-    let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-        label,
-        bind_group_layouts: &[&scene_buffers_layout, &indirect_buffers_layout],
-        push_constant_ranges: &[],
-    });
-    let pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
-        label,
-        layout: Some(&layout),
-        module: &shader_crate,
-        entry_point: "stage::compute_cull_entities",
-    });
-    pipeline
-}
-
-pub struct SceneRenderPipeline(pub wgpu::RenderPipeline);
-
-pub struct SceneComputeCullPipeline(pub wgpu::ComputePipeline);
-
-pub fn scene_update(
-    (device, queue, mut scene): (View<Device>, View<Queue>, ViewMut<Scene>),
-) -> Result<(), SceneError> {
-    scene.update(&device, &queue);
-    Ok(())
-}
-
-pub fn scene_cull_gpu(
-    (device, queue, scene, pipeline): (
-        View<Device>,
-        View<Queue>,
-        View<Scene>,
-        View<SceneComputeCullPipeline>,
-    ),
-) -> Result<(), SceneError> {
-    let label = Some("scene cull");
-    let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label });
-    let mut compute_pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor { label });
-    compute_pass.set_pipeline(&pipeline.0);
-    compute_pass.set_bind_group(0, &scene.render_buffers_bindgroup, &[]);
-    compute_pass.set_bind_group(1, &scene.cull_bindgroup, &[]);
-    let num_entities = scene.entities.capacity();
-    let groups = num_entities / 32 + 1;
-    compute_pass.dispatch_workgroups(groups as u32, 1, 1);
-    drop(compute_pass);
-    queue.submit(std::iter::once(encoder.finish()));
-    Ok(())
-}
-
-#[cfg(target_arch = "wasm32")]
-pub fn scene_cull_cpu(mut scene: ViewMut<Scene>) -> Result<(), SceneError> {
-    use std::ops::DerefMut;
-    let Scene {
-        entities,
-        indirect_draws,
-        ..
-    } = scene.deref_mut();
-    entities
-        .buffer
-        .cpu_buffer
-        .with_slice(|entities: &[GpuEntity]| -> Result<(), BufferError> {
-            indirect_draws
-                .buffer
-                .cpu_buffer
-                .with_mut_slice::<DrawIndirect, _>(|draws: &mut [DrawIndirect]| {
-                    for id in entities.iter().map(|e| e.id) {
-                        let global_id = glam::UVec3::new(id.into(), 0, 0);
-                        renderling_shader::stage::compute_cull_entities(entities, draws, global_id);
-                    }
-                })
-        })
-        .context(BufferSnafu)?
-        .context(BufferSnafu)?;
-
-    Ok(())
-}
-
-pub fn skybox_render(
-    (device, queue, scene, pipeline, hdr_frame, depth): (
-        View<Device>,
-        View<Queue>,
-        View<Scene>,
-        View<SkyboxRenderPipeline>,
-        View<HdrSurface>,
-        View<DepthTexture>,
-    ),
-) -> Result<(), SceneError> {
-    if !scene.constants.toggles.get_has_skybox() {
-        return Ok(());
-    }
-    let label = Some("skybox render");
-    let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label });
-    let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-        label,
-        color_attachments: &[Some(wgpu::RenderPassColorAttachment {
-            view: &hdr_frame.hdr_texture.view,
-            resolve_target: None,
-            ops: wgpu::Operations {
-                load: wgpu::LoadOp::Load,
-                store: wgpu::StoreOp::Store,
-            },
-        })],
-        depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
-            view: &depth.view,
-            depth_ops: Some(wgpu::Operations {
-                load: wgpu::LoadOp::Load,
-                store: wgpu::StoreOp::Store,
-            }),
-            stencil_ops: None,
-        }),
-    });
-    render_pass.set_pipeline(&pipeline.0);
-    render_pass.set_bind_group(0, &scene.environment_bindgroup, &[]);
-    render_pass.draw(0..36, 0..1);
-    drop(render_pass);
-
-    queue.submit(std::iter::once(encoder.finish()));
-    Ok(())
-}
-
-pub fn scene_render(
-    (device, queue, scene, pipeline, hdr_frame, depth): (
-        View<Device>,
-        View<Queue>,
-        View<Scene>,
-        View<SceneRenderPipeline>,
-        View<HdrSurface>,
-        View<DepthTexture>,
-    ),
-) -> Result<(), SceneError> {
-    let label = Some("scene hdr render");
-    let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label });
-    let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-        label,
-        color_attachments: &hdr_frame.color_attachments(),
-        depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
-            view: &depth.view,
-            depth_ops: Some(wgpu::Operations {
-                load: wgpu::LoadOp::Load,
-                store: wgpu::StoreOp::Store,
-            }),
-            stencil_ops: None,
-        }),
-    });
-    render_pass.set_pipeline(&pipeline.0);
-    render_pass.set_bind_group(0, &scene.render_buffers_bindgroup, &[]);
-    render_pass.set_bind_group(1, &scene.render_atlas_bindgroup, &[]);
-    // We should use multi_draw_indirect_count after (actually) culling
-    #[cfg(not(target_arch = "wasm32"))]
-    render_pass.multi_draw_indirect(
-        scene.indirect_draws.get_buffer(),
-        0,
-        scene.entities.len() as u32,
-    );
-    #[cfg(target_arch = "wasm32")]
-    {
-        let indirect_buffer = scene
-            .indirect_draws
-            .buffer
-            .cpu_buffer
-            .read::<DrawIndirect>(0, scene.indirect_draws.len())
-            .context(BufferSnafu)?;
-        for indirect in indirect_buffer.into_iter() {
-            if indirect.instance_count == 0 || indirect.vertex_count == 0 {
-                continue;
-            }
-            let id = indirect.base_instance;
-            render_pass.draw(0..indirect.vertex_count, id..id + 1);
-        }
-    }
-
-    drop(render_pass);
-
-    queue.submit(std::iter::once(encoder.finish()));
-    Ok(())
-}
diff --git a/crates/renderling/src/stage.rs b/crates/renderling/src/stage.rs
index fcf547d4..51c52f57 100644
--- a/crates/renderling/src/stage.rs
+++ b/crates/renderling/src/stage.rs
@@ -11,7 +11,7 @@ use crabslab::{Array, CpuSlab, GrowableSlab, Id, Slab, SlabItem, WgpuBuffer};
 use moongraph::{View, ViewMut};
 use renderling_shader::{
     debug::DebugMode,
-    stage::{light::Light, Camera, RenderUnit, StageLegend},
+    stage::{light::Light, Camera, IsRendering, Rendering, StageLegend},
     texture::GpuTexture,
 };
 use snafu::Snafu;
@@ -348,7 +348,7 @@ impl Stage {
             log::trace!("creating stage render pipeline");
             let label = Some("stage render pipeline");
             let vertex_shader =
-                device.create_shader_module(wgpu::include_spirv!("linkage/stage-gltf_vertex.spv"));
+                device.create_shader_module(wgpu::include_spirv!("linkage/stage-vertex.spv"));
             let fragment_shader = device
                 .create_shader_module(wgpu::include_spirv!("linkage/stage-gltf_fragment.spv"));
             let stage_slab_buffers_layout = Stage::buffers_bindgroup_layout(device);
@@ -363,7 +363,7 @@ impl Stage {
                 layout: Some(&layout),
                 vertex: wgpu::VertexState {
                     module: &vertex_shader,
-                    entry_point: "stage::gltf_vertex",
+                    entry_point: "stage::vertex",
                     buffers: &[],
                 },
                 primitive: wgpu::PrimitiveState {
@@ -530,12 +530,16 @@ impl Stage {
         }
     }
 
-    /// Draw the [`RenderUnit`] each frame, and immediately return its `Id`.
-    pub fn draw_unit(&mut self, unit: &RenderUnit) -> Id<RenderUnit> {
-        let id = self.append(unit);
+    /// Draw a rendering each frame.
+    ///
+    /// Returns the id of the stored `T` and the id of the [`Rendering`].
+    pub fn draw_unit<T: IsRendering>(&mut self, unit: &T) -> (Id<T>, Id<Rendering>) {
+        let unit_id = self.append(unit);
+        let rendering = T::wrap(unit_id);
+        let id = self.append(&rendering);
         let draw = DrawUnit {
             id,
-            vertex_count: unit.vertex_count,
+            vertex_count: unit.vertex_count(),
             visible: true,
         };
         // UNWRAP: if we can't acquire the lock we want to panic.
@@ -545,11 +549,11 @@ impl Stage {
                 units.push(draw);
             }
         }
-        id
+        (unit_id, id)
     }
 
     /// Erase the [`RenderUnit`] with the given `Id` from the stage.
-    pub fn erase_unit(&self, id: Id<RenderUnit>) {
+    pub fn erase_unit(&self, id: Id<Rendering>) {
         let mut draws = self.draws.write().unwrap();
         match draws.deref_mut() {
             StageDrawStrategy::Direct(units) => {
@@ -568,7 +572,7 @@ impl Stage {
     }
 
     /// Show the [`RenderUnit`] with the given `Id` for rendering.
-    pub fn show_unit(&self, id: Id<RenderUnit>) {
+    pub fn show_unit(&self, id: Id<Rendering>) {
         let mut draws = self.draws.write().unwrap();
         match draws.deref_mut() {
             StageDrawStrategy::Direct(units) => {
@@ -582,7 +586,7 @@ impl Stage {
     }
 
     /// Hide the [`RenderUnit`] with the given `Id` from rendering.
-    pub fn hide_unit(&self, id: Id<RenderUnit>) {
+    pub fn hide_unit(&self, id: Id<Rendering>) {
         let mut draws = self.draws.write().unwrap();
         match draws.deref_mut() {
             StageDrawStrategy::Direct(units) => {
@@ -680,7 +684,7 @@ impl Stage {
 /// A unit of work to be drawn.
 #[derive(Clone, Copy, Debug, Default)]
 pub struct DrawUnit {
-    pub id: Id<RenderUnit>,
+    pub id: Id<Rendering>,
     pub vertex_count: u32,
     pub visible: bool,
 }
diff --git a/crates/renderling/src/stage/gltf_support.rs b/crates/renderling/src/stage/gltf_support.rs
index ca940bc7..5809114b 100644
--- a/crates/renderling/src/stage/gltf_support.rs
+++ b/crates/renderling/src/stage/gltf_support.rs
@@ -3,8 +3,8 @@ use super::*;
 use crate::{
     shader::{
         gltf::*,
-        pbr::PbrMaterial,
-        stage::{Camera, LightingModel},
+        pbr::Material,
+        stage::Camera,
         texture::{GpuTexture, TextureAddressMode, TextureModes},
     },
     AtlasImage,
@@ -258,14 +258,14 @@ impl Stage {
         }
 
         log::trace!("Creating materials");
-        let mut default_material = Id::<PbrMaterial>::NONE;
-        let materials = self.allocate_array::<PbrMaterial>(document.materials().len());
+        let mut default_material = Id::<Material>::NONE;
+        let materials = self.allocate_array::<Material>(document.materials().len());
         for material in document.materials() {
             let material_id = if let Some(index) = material.index() {
                 materials.at(index)
             } else {
                 // Allocate some extra space for this default material
-                default_material = self.allocate::<PbrMaterial>();
+                default_material = self.allocate::<Material>();
                 default_material
             };
             let name = material.name().map(String::from);
@@ -298,7 +298,7 @@ impl Stage {
                         (Id::NONE, 0)
                     };
 
-                PbrMaterial {
+                Material {
                     albedo_texture,
                     albedo_tex_coord,
                     albedo_factor: pbr.base_color_factor().into(),
@@ -386,7 +386,7 @@ impl Stage {
                 let emissive_factor = Vec3::from(material.emissive_factor())
                     .extend(material.emissive_strength().unwrap_or(1.0));
 
-                PbrMaterial {
+                Material {
                     albedo_factor,
                     metallic_factor,
                     roughness_factor,
@@ -402,7 +402,7 @@ impl Stage {
                     emissive_factor,
                     emissive_texture,
                     emissive_tex_coord,
-                    lighting_model: LightingModel::PBR_LIGHTING,
+                    has_lighting: true,
                     ..Default::default()
                 }
             };
@@ -1011,7 +1011,7 @@ impl Stage {
         camera_id: Id<Camera>,
         node: gltf::Node<'a>,
         parents: Vec<Id<GltfNode>>,
-    ) -> Vec<Id<RenderUnit>> {
+    ) -> Vec<(Id<RenderUnit>, Id<Rendering>)> {
         if let Some(_light) = node.light() {
             // TODO: Support transforming lights based on node transforms
             ////let light = gpu_doc.lights.at(light.index());
@@ -1082,7 +1082,7 @@ impl Stage {
         gpu_doc: &GltfDocument,
         camera_id: Id<Camera>,
         node: gltf::Node<'_>,
-    ) -> Vec<Id<RenderUnit>> {
+    ) -> Vec<(Id<RenderUnit>, Id<Rendering>)> {
         self.draw_gltf_node_with(gpu_doc, camera_id, node, vec![])
     }
 
@@ -1093,7 +1093,7 @@ impl Stage {
         gpu_doc: &GltfDocument,
         camera_id: Id<Camera>,
         scene: gltf::Scene<'_>,
-    ) -> Vec<Id<RenderUnit>> {
+    ) -> Vec<(Id<RenderUnit>, Id<Rendering>)> {
         scene
             .nodes()
             .flat_map(|node| self.draw_gltf_node(gpu_doc, camera_id, node))
@@ -1109,11 +1109,17 @@ impl Stage {
         &mut self,
         vertices: impl IntoIterator<Item = Vertex>,
         indices: impl IntoIterator<Item = u32>,
-        material: Id<PbrMaterial>,
+        material: Id<Material>,
     ) -> GltfPrimitive {
         let vertices: Vec<Vertex> = vertices.into_iter().collect();
         let indices: Vec<u32> = indices.into_iter().collect();
-        let vertex_count = vertices.len().max(indices.len()) as u32;
+        let indices_len: usize = indices.len();
+        let vertices_len: usize = vertices.len();
+        let vertex_count = if vertices_len > indices_len {
+            vertices_len
+        } else {
+            indices_len
+        } as u32;
         let indices = if indices.is_empty() {
             Id::NONE
         } else {
@@ -1283,7 +1289,7 @@ impl<'a> GltfMeshBuilder<'a> {
         &mut self,
         vertices: impl IntoIterator<Item = Vertex>,
         indices: impl IntoIterator<Item = u32>,
-        material_id: Id<PbrMaterial>,
+        material_id: Id<Material>,
     ) {
         let primitive = self.stage.new_primitive(vertices, indices, material_id);
         self.primitives.push(primitive);
@@ -1293,7 +1299,7 @@ impl<'a> GltfMeshBuilder<'a> {
         mut self,
         vertices: impl IntoIterator<Item = Vertex>,
         indices: impl IntoIterator<Item = u32>,
-        material_id: Id<PbrMaterial>,
+        material_id: Id<Material>,
     ) -> Self {
         self.add_primitive(vertices, indices, material_id);
         self
@@ -1314,14 +1320,13 @@ mod test {
     use crate::{
         shader::{
             gltf::*,
-            pbr::PbrMaterial,
-            stage::{Camera, LightingModel, RenderUnit, Transform, Vertex},
+            pbr::Material,
+            stage::{Camera, Transform, Vertex},
         },
         Renderling, Stage,
     };
     use crabslab::{Array, GrowableSlab, Id, Slab};
     use glam::{Vec2, Vec3, Vec4, Vec4Swizzles};
-    use renderling_shader::stage::{GpuConstants, GpuEntity};
 
     #[test]
     fn get_vertex_count_primitive_sanity() {
@@ -1525,9 +1530,9 @@ mod test {
         assert!(!gpu_doc.textures.is_empty());
         let albedo_texture_id = gpu_doc.textures.at(0);
         assert!(albedo_texture_id.is_some());
-        let material_id = stage.append(&PbrMaterial {
+        let material_id = stage.append(&Material {
             albedo_texture: albedo_texture_id,
-            lighting_model: LightingModel::NO_LIGHTING,
+            has_lighting: false,
             ..Default::default()
         });
         println!("material_id: {:#?}", material_id);
@@ -1720,7 +1725,7 @@ mod test {
         let (projection, view) = crate::camera::default_ortho2d(100.0, 100.0);
         let camera = stage.append(&Camera::new(projection, view));
         let node_path = stage.append_array(&[nodes.at(0)]);
-        let unit_id = stage.draw_unit(&RenderUnit {
+        let (_, rendering_id) = stage.draw_unit(&RenderUnit {
             camera,
             node_path,
             mesh_index: 0,
@@ -1730,7 +1735,7 @@ mod test {
         });
 
         let data = stage.read_slab().unwrap();
-        let invocation = VertexInvocation::invoke(unit_id.inner(), 0, &data);
+        let invocation = VertexInvocation::invoke(rendering_id.inner(), 0, &data);
         println!("invoctaion: {invocation:#?}");
 
         let img = r.render_linear_image().unwrap();
@@ -1788,38 +1793,5 @@ mod test {
             v.ndc_pos = v.clip_pos.xyz() / v.clip_pos.w;
             v
         }
-
-        #[allow(dead_code)]
-        pub fn invoke_legacy(
-            instance_index: u32,
-            vertex_index: u32,
-            constants: &GpuConstants,
-            vertices: &[Vertex],
-            entities: &[GpuEntity],
-        ) -> Self {
-            let mut v = Self {
-                instance_index,
-                vertex_index,
-                ..Default::default()
-            };
-            renderling_shader::stage::main_vertex_scene(
-                v.instance_index,
-                v.vertex_index,
-                &constants,
-                &vertices,
-                &entities,
-                &mut v.out_material,
-                &mut v.out_color,
-                &mut v.out_uv0,
-                &mut v.out_uv1,
-                &mut v.out_norm,
-                &mut v.out_tangent,
-                &mut v.out_bitangent,
-                &mut v.out_pos,
-                &mut v.clip_pos,
-            );
-            v.ndc_pos = v.clip_pos.xyz() / v.clip_pos.w;
-            v
-        }
     }
 }