diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index 015d21db..55462660 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -21,6 +21,8 @@ jobs:
         uses: Swatinem/rust-cache@v2
       - name: Run tests
         run: cargo test --workspace --verbose
+      - name: Run mt tests
+        run: cargo test --workspace --verbose --features multithread
 
   lint:
     runs-on: ubuntu-latest
diff --git a/CHANGES.md b/CHANGES.md
index 1a823f74..a4c84ede 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -4,6 +4,7 @@
     * `attributes.value_as::<T>` is now available on `Attributes`
     * Performance improvements
     * New template function: `len`
+    * `List<T>` now has `clear` and `retain`
 * 0.2.11
     * FEATURE: ranges 
     * `padding` function
diff --git a/Cargo.toml b/Cargo.toml
index f20ef105..2a42fa1e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -14,26 +14,19 @@ publish = true
 rust-version = "1.88"
 
 [dependencies]
-anathema-backend = { workspace = true }
-anathema-default-widgets = { workspace = true }
+anathema-core = { workspace = true }
 anathema-geometry = { workspace = true }
-anathema-runtime = { workspace = true }
 anathema-state = { workspace = true }
 anathema-state-derive = { workspace = true }
 anathema-store = { workspace = true }
-anathema-templates = { workspace = true }
-anathema-value-resolver = { workspace = true }
+anathema-strings = { workspace = true }
 anathema-widgets = { workspace = true }
 
-[dev-dependencies]
-# anathema-debug = { path = "anathema-debug" }
-anathema-testutils = { path = "anathema-testutils" }
-
 [features]
 default = []
-profile = ["anathema-runtime/profile", "anathema-widgets/profile", "anathema-backend/profile", "anathema-value-resolver/profile"]
+profile = []
+multithread = ["anathema-core/multithread", "anathema-state/multithread"]
 serde = ["anathema-state/serde", "anathema-store/serde"]
-# filelog = ["anathema-debug/filelog", "anathema-widgets/filelog", "anathema-runtime/filelog"]
 
 [lints]
 workspace = true
@@ -48,29 +41,23 @@ crossterm = "0.28.1"
 unicode-width = "0.1.11"
 flume = "0.11.0"
 notify = "6.1.1"
-anathema-default-widgets = { path = "./anathema-default-widgets", version = "0.2.12-beta" }
-anathema-backend = { path = "./anathema-backend", version = "0.2.12-beta" }
-anathema-runtime = { path = "./anathema-runtime", version = "0.2.12-beta" }
+anathema-core = { path = "./anathema-core", version = "0.2.12-beta" }
+anathema-geometry = { path = "./anathema-geometry", version = "0.2.12-beta" }
 anathema-state = { path = "./anathema-state", version = "0.2.12-beta" }
 anathema-state-derive = { path = "./anathema-state-derive", version = "0.2.12-beta" }
 anathema-store = { path = "./anathema-store", version = "0.2.12-beta" }
-anathema-templates = { path = "./anathema-templates", version = "0.2.12-beta" }
+anathema-strings = { path = "./anathema-strings", version = "0.2.12-beta" }
 anathema-widgets = { path = "./anathema-widgets", version = "0.2.12-beta" }
-anathema-geometry = { path = "./anathema-geometry", version = "0.2.12-beta" }
-anathema-value-resolver = { path = "./anathema-value-resolver", version = "0.2.12-beta" }
 
 [workspace]
 members = [
-    "anathema-backend", 
-    "anathema-runtime", 
-    "anathema-default-widgets", 
+    "anathema-core", 
     "anathema-geometry", 
     "anathema-state",
     "anathema-state-derive",
     "anathema-store",
-    "anathema-templates", 
+    "anathema-strings", 
     "anathema-widgets", 
-    "anathema-value-resolver",
 ]
 
 [workspace.lints.rust]
diff --git a/anathema-backend/Cargo.toml b/anathema-backend/Cargo.toml
deleted file mode 100644
index 7721c76a..00000000
--- a/anathema-backend/Cargo.toml
+++ /dev/null
@@ -1,28 +0,0 @@
-[package]
-name = "anathema-backend"
-license = "MIT"
-description = "Various backends for Anathema"
-version.workspace = true
-edition.workspace = true
-documentation = "https://togglebyte.github.io/anathema-guide/"
-homepage = "https://github.com/togglebyte/anathema"
-repository = "https://github.com/togglebyte/anathema"
-
-[dependencies]
-anathema-geometry = { workspace = true }
-anathema-state = { workspace = true }
-anathema-store = { workspace = true }
-anathema-templates = { workspace = true }
-anathema-value-resolver = { workspace = true }
-anathema-widgets = { workspace = true }
-crossterm = { workspace = true }
-unicode-width = { workspace = true }
-bitflags = { workspace = true }
-puffin = { version = "0.19.1", optional = true }
-
-[features]
-default = []
-profile = ["puffin"]
-
-[lints]
-workspace = true
diff --git a/anathema-backend/src/lib.rs b/anathema-backend/src/lib.rs
deleted file mode 100644
index 6fe3cd0b..00000000
--- a/anathema-backend/src/lib.rs
+++ /dev/null
@@ -1,210 +0,0 @@
-use std::ops::ControlFlow;
-use std::time::Duration;
-
-use anathema_geometry::{Pos, Size};
-use anathema_value_resolver::{AttributeStorage, Scope};
-use anathema_widgets::components::events::Event;
-use anathema_widgets::error::Result;
-use anathema_widgets::layout::{Constraints, LayoutCtx, LayoutFilter, PositionFilter, Viewport};
-use anathema_widgets::paint::PaintFilter;
-use anathema_widgets::{
-    DirtyWidgets, GlyphMap, Layout, LayoutForEach, PaintChildren, PositionChildren, WidgetTreeView,
-};
-
-pub mod testing;
-pub mod tui;
-
-pub trait Backend {
-    fn size(&self) -> Size;
-
-    fn next_event(&mut self, timeout: Duration) -> Option<Event>;
-
-    fn resize(&mut self, new_size: Size, glyph_map: &mut GlyphMap);
-
-    /// Paint the widgets
-    fn paint<'bp>(
-        &mut self,
-        glyph_map: &mut GlyphMap,
-        widgets: PaintChildren<'_, 'bp>,
-        attribute_storage: &AttributeStorage<'bp>,
-    );
-
-    /// Called by the runtime at the end of the frame.
-    fn render(&mut self, glyph_map: &mut GlyphMap);
-
-    /// Clear is called immediately after `render` is called.
-    fn clear(&mut self);
-
-    /// Finalizes the backend. This is called when the runtime starts.
-    fn finalize(&mut self) {}
-}
-
-// TODO: rename this.
-// This does layout, position and paint and should have
-// a less silly name
-pub struct WidgetCycle<'rt, 'bp, T> {
-    backend: &'rt mut T,
-    tree: WidgetTreeView<'rt, 'bp>,
-    constraints: Constraints,
-}
-
-impl<'rt, 'bp, T: Backend> WidgetCycle<'rt, 'bp, T> {
-    pub fn new(backend: &'rt mut T, tree: WidgetTreeView<'rt, 'bp>, constraints: Constraints) -> Self {
-        Self {
-            backend,
-            tree,
-            constraints,
-        }
-    }
-
-    fn fixed(&mut self, ctx: &mut LayoutCtx<'_, 'bp>) -> Result<()> {
-        // -----------------------------------------------------------------------------
-        //   - Position -
-        // -----------------------------------------------------------------------------
-        self.position(ctx.attribute_storage, *ctx.viewport, PositionFilter::fixed());
-
-        // -----------------------------------------------------------------------------
-        //   - Paint -
-        // -----------------------------------------------------------------------------
-        self.paint(ctx, PaintFilter::fixed());
-
-        Ok(())
-    }
-
-    fn floating(&mut self, ctx: &mut LayoutCtx<'_, 'bp>) -> Result<()> {
-        // -----------------------------------------------------------------------------
-        //   - Position -
-        // -----------------------------------------------------------------------------
-        self.position(ctx.attribute_storage, *ctx.viewport, PositionFilter::floating());
-
-        // -----------------------------------------------------------------------------
-        //   - Paint -
-        // -----------------------------------------------------------------------------
-        self.paint(ctx, PaintFilter::floating());
-
-        Ok(())
-    }
-
-    pub fn run(
-        &mut self,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-        force_layout: bool,
-        dirty_widgets: &mut DirtyWidgets,
-    ) -> Result<()> {
-        // -----------------------------------------------------------------------------
-        //   - Layout -
-        // -----------------------------------------------------------------------------
-        self.layout(ctx, LayoutFilter, dirty_widgets, force_layout)?;
-
-        // -----------------------------------------------------------------------------
-        //   - Position and paint -
-        // -----------------------------------------------------------------------------
-        self.fixed(ctx)?;
-        self.floating(ctx)?;
-        Ok(())
-    }
-
-    fn layout(
-        &mut self,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-        filter: LayoutFilter,
-        dirty_widgets: &mut DirtyWidgets,
-        force_layout: bool,
-    ) -> Result<()> {
-        #[cfg(feature = "profile")]
-        puffin::profile_function!();
-
-        let mut tree = self.tree.view();
-
-        if force_layout {
-            // Perform a layout across the entire tree
-            let scope = Scope::root();
-            let mut for_each = LayoutForEach::new(tree, &scope, filter);
-            let constraints = self.constraints;
-            _ = for_each.each(ctx, |ctx, widget, children| {
-                _ = widget.layout(children, constraints, ctx)?;
-                Ok(ControlFlow::Break(()))
-            })?;
-            return Ok(());
-        }
-
-        // If a widget has changed, mark the parent as dirty
-
-        // Layout only changed widgets.
-        // These are the parents of changed widgets.
-        //
-        // Investigate the possibility of attaching an offset as existing widgets don't need
-        // to reflow unless the constraint has changed.
-        //
-        // This means `additional_widgets` needs to store (key, offset) where offset can be None
-        //
-        // If this is going to work we need to consider `expand` and `spacer`
-        //
-        // Since widgets can be made by anyone and they are always guaranteed to give
-        // access to all their children this might not be a possibility.
-        //
-        // parent
-        //     widget 0
-        //     widget 1
-        //     widget 2 |  <- if this changes, only reflow this, three and four
-        //     widget 3 |-- reflow
-        //     widget 4 |
-
-        // TODO: make `additional_widgets` a scratch buffer part of `DirtyWidgets`.
-        //       Also ensure that it tracks last id as well
-        //       ... and removes it when done!
-        let mut additional_widgets = vec![];
-
-        loop {
-            for widget_id in dirty_widgets.drain() {
-                if !tree.contains(widget_id) {
-                    continue;
-                }
-                tree.with_value_mut(widget_id, |_, widget, children| {
-                    let scope = Scope::root();
-                    let mut children = LayoutForEach::new(children, &scope, filter);
-                    children.parent_element = Some(widget_id);
-                    let parent_id = widget.parent_widget;
-                    let anathema_widgets::WidgetKind::Element(widget) = &mut widget.kind else { return };
-
-                    let constraints = widget.constraints();
-                    if let Ok(Layout::Changed(_)) = widget.layout(children, constraints, ctx) {
-                        // write into scratch buffer
-                        if let Some(id) = parent_id {
-                            additional_widgets.push(id);
-                        }
-                    }
-                });
-            }
-
-            // merge the scratch if it's not empty
-
-            if additional_widgets.is_empty() {
-                break;
-            }
-
-            dirty_widgets.inner.append(&mut additional_widgets);
-        }
-
-        Ok(())
-    }
-
-    fn position(&mut self, attributes: &AttributeStorage<'bp>, viewport: Viewport, filter: PositionFilter) {
-        #[cfg(feature = "profile")]
-        puffin::profile_function!();
-
-        let mut for_each = PositionChildren::new(self.tree.view(), attributes, filter);
-        _ = for_each.each(|widget, children| {
-            widget.position(children, Pos::ZERO, attributes, viewport);
-            ControlFlow::Break(())
-        });
-    }
-
-    fn paint(&mut self, ctx: &mut LayoutCtx<'_, 'bp>, filter: PaintFilter) {
-        #[cfg(feature = "profile")]
-        puffin::profile_function!();
-
-        let for_each = PaintChildren::new(self.tree.view(), ctx.attribute_storage, filter);
-        self.backend.paint(ctx.glyph_map, for_each, ctx.attribute_storage);
-    }
-}
diff --git a/anathema-backend/src/testing/events.rs b/anathema-backend/src/testing/events.rs
deleted file mode 100644
index 44971ad2..00000000
--- a/anathema-backend/src/testing/events.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-use std::collections::VecDeque;
-
-use anathema_geometry::Size;
-use anathema_widgets::components::events::{Event, KeyEvent};
-
-pub struct EventsMut<'a> {
-    event_queue: &'a mut VecDeque<Option<Event>>,
-}
-
-impl EventsMut<'_> {
-    pub fn next(self) -> Self {
-        self.event_queue.push_back(None);
-        self
-    }
-
-    pub fn next_frames(self, count: usize) -> Self {
-        for _ in 0..count {
-            self.event_queue.push_back(None);
-        }
-        self
-    }
-
-    pub fn resize(self, new_size: impl Into<Size>) -> Self {
-        let size = new_size.into();
-        self.event_queue.push_back(Some(Event::Resize(size)));
-        self
-    }
-
-    pub fn stop(self) -> Self {
-        self.event_queue.push_back(Some(Event::Stop));
-        self
-    }
-
-    pub fn press(self, event: KeyEvent) -> Self {
-        self.event_queue.push_back(Some(Event::Key(event)));
-        self
-    }
-}
-
-#[derive(Debug)]
-pub struct Events {
-    event_queue: VecDeque<Option<Event>>,
-}
-
-impl Events {
-    pub(super) fn new() -> Self {
-        Self {
-            event_queue: VecDeque::new(),
-        }
-    }
-
-    pub(super) fn mut_ref(&mut self) -> EventsMut<'_> {
-        EventsMut {
-            event_queue: &mut self.event_queue,
-        }
-    }
-
-    pub(super) fn pop(&mut self) -> Option<Event> {
-        self.event_queue.pop_front().flatten()
-    }
-}
diff --git a/anathema-backend/src/testing/mod.rs b/anathema-backend/src/testing/mod.rs
deleted file mode 100644
index d4f566ae..00000000
--- a/anathema-backend/src/testing/mod.rs
+++ /dev/null
@@ -1,98 +0,0 @@
-use std::time::Duration;
-
-use anathema_geometry::Size;
-use anathema_value_resolver::AttributeStorage;
-use anathema_widgets::components::events::Event;
-use anathema_widgets::paint::{Glyph, paint};
-use anathema_widgets::{GlyphMap, PaintChildren};
-use surface::TestSurface;
-
-use crate::Backend;
-
-mod events;
-mod surface;
-
-#[derive(Debug)]
-/// This is used for testing
-pub struct GlyphRef<'a> {
-    inner: Option<&'a Glyph>,
-}
-
-impl<'a> GlyphRef<'a> {
-    pub fn is_char(&self, rhs: char) -> bool {
-        let Some(glyph) = self.inner else { return false };
-        match glyph {
-            Glyph::Single(lhs, _) => *lhs == rhs,
-            Glyph::Cluster(_glyph_index, _) => todo!(),
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct TestBackend {
-    surface: TestSurface,
-    events: events::Events,
-}
-
-impl TestBackend {
-    pub fn new(size: impl Into<Size>) -> Self {
-        let size = size.into();
-        Self {
-            surface: TestSurface::new(size),
-            events: events::Events::new(),
-        }
-    }
-
-    pub fn at(&self, x: usize, y: usize) -> GlyphRef<'_> {
-        GlyphRef {
-            inner: self.surface.get(x, y),
-        }
-    }
-
-    pub fn line(&self, index: usize) -> String {
-        let glyphs = self.surface.line(index);
-        glyphs
-            .iter()
-            .filter_map(|g| match g {
-                Glyph::Single(c, _) => Some(c),
-                Glyph::Cluster(_, _) => None,
-            })
-            .collect::<String>()
-            .trim()
-            .to_string()
-    }
-
-    pub fn events(&mut self) -> events::EventsMut<'_> {
-        self.events.mut_ref()
-    }
-}
-
-impl Backend for TestBackend {
-    fn size(&self) -> Size {
-        self.surface.size
-    }
-
-    fn next_event(&mut self, _timeout: Duration) -> Option<Event> {
-        self.events.pop()
-    }
-
-    fn resize(&mut self, new_size: Size, glyph_map: &mut GlyphMap) {
-        self.surface.resize(new_size, glyph_map);
-    }
-
-    fn paint<'bp>(
-        &mut self,
-        glyph_map: &mut GlyphMap,
-        widgets: PaintChildren<'_, 'bp>,
-        attribute_storage: &AttributeStorage<'bp>,
-    ) {
-        self.surface.clear();
-        paint(&mut self.surface, glyph_map, widgets, attribute_storage);
-    }
-
-    fn render(&mut self, _glyph_map: &mut GlyphMap) {
-        // this does nothing here as everything written to the test buffer
-    }
-
-    fn clear(&mut self) {}
-}
diff --git a/anathema-backend/src/testing/surface.rs b/anathema-backend/src/testing/surface.rs
deleted file mode 100644
index 045f95e8..00000000
--- a/anathema-backend/src/testing/surface.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-use anathema_geometry::{Pos, Size};
-use anathema_value_resolver::Attributes;
-use anathema_widgets::paint::Glyph;
-use anathema_widgets::{GlyphMap, Style, WidgetRenderer};
-
-#[derive(Debug)]
-pub struct TestSurface {
-    pub(super) size: Size,
-    lines: Vec<Glyph>,
-    prev_lines: Vec<Glyph>,
-}
-
-impl TestSurface {
-    pub fn new(size: Size) -> Self {
-        let len = size.width * size.height;
-        let lines = vec![Glyph::space(); len as usize];
-        Self {
-            size,
-            lines,
-            prev_lines: vec![],
-        }
-    }
-
-    pub(crate) fn resize(&mut self, new_size: Size, _glyph_map: &mut GlyphMap) {
-        self.size = new_size;
-        // TODO: this should pop and truncate the lines to fit the new size
-    }
-
-    // Get from previous lines as the clear function has most likely
-    // been called by the time this is relevant
-    pub(crate) fn get(&self, x: usize, y: usize) -> Option<&Glyph> {
-        let index = y * self.size.width as usize + x;
-        self.prev_lines.get(index)
-    }
-
-    // Look at the old lines as the surface has been cleared
-    // by the time we can inspect the lines
-    pub(crate) fn line(&self, index: usize) -> &[Glyph] {
-        let from = index * self.size.width as usize;
-        let to = from + self.size.width as usize;
-        &self.prev_lines[from..to]
-    }
-
-    pub(crate) fn clear(&mut self) {
-        let len = self.size.width * self.size.height;
-        let mut lines = vec![Glyph::space(); len as usize];
-        std::mem::swap(&mut lines, &mut self.lines);
-        std::mem::swap(&mut lines, &mut self.prev_lines);
-    }
-}
-
-impl WidgetRenderer for TestSurface {
-    fn draw_glyph(&mut self, mut glyph: Glyph, local_pos: Pos) {
-        let index = self.size.width as i32 * local_pos.y + local_pos.x;
-        let index = index as usize;
-        std::mem::swap(&mut glyph, &mut self.lines[index]);
-    }
-
-    fn set_attributes(&mut self, attribs: &Attributes<'_>, local_pos: Pos) {
-        let style = Style::from_cell_attribs(attribs);
-        self.set_style(style, local_pos)
-    }
-
-    fn set_style(&mut self, _style: Style, _local_pos: Pos) {}
-
-    fn size(&self) -> Size {
-        self.size
-    }
-}
diff --git a/anathema-backend/src/tui/buffer.rs b/anathema-backend/src/tui/buffer.rs
deleted file mode 100644
index 3d4773ff..00000000
--- a/anathema-backend/src/tui/buffer.rs
+++ /dev/null
@@ -1,453 +0,0 @@
-#![deny(missing_docs)]
-use std::io::{Result, Write};
-use std::ops::Index;
-
-use anathema_geometry::Size;
-use anathema_widgets::Style;
-use anathema_widgets::paint::{Glyph, GlyphMap};
-use crossterm::style::Print;
-use crossterm::{QueueableCommand, cursor};
-
-use super::LocalPos;
-use super::style::write_style;
-
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub struct Cell {
-    pub(crate) style: Style,
-    pub(crate) state: CellState,
-}
-
-impl Cell {
-    pub(crate) fn empty() -> Self {
-        // It's important to reset the colours as there
-        // might be residual colors from previous draw.
-        Self {
-            style: Style::reset(),
-            state: CellState::Empty,
-        }
-    }
-
-    pub(crate) fn reset() -> Self {
-        Self {
-            style: Style::reset(),
-            state: CellState::Occupied(Glyph::space()),
-        }
-    }
-
-    fn continuation(style: Style) -> Self {
-        Self {
-            style,
-            state: CellState::Continuation,
-        }
-    }
-
-    pub(crate) fn new(glyph: Glyph, style: Style) -> Self {
-        Self {
-            style,
-            state: CellState::Occupied(glyph),
-        }
-    }
-}
-
-/// Represent the state of a cell inside a [`Buffer`].
-#[derive(Copy, Clone, PartialEq)]
-pub(crate) enum CellState {
-    /// Empty
-    Empty,
-    /// Occupied by a certain character
-    Occupied(Glyph),
-    /// A continuation means this cell is part of another cell
-    /// representing a value that spans more than two chars, e.g 💖
-    Continuation,
-}
-
-impl std::fmt::Debug for CellState {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            CellState::Empty => write!(f, "<E>"),
-            CellState::Occupied(Glyph::Single(glyph, _width)) => write!(f, "{glyph}"),
-            CellState::Occupied(Glyph::Cluster(index, width)) => write!(f, "<C{index:?},{width}>"),
-            CellState::Continuation => write!(f, "<C>"),
-        }
-    }
-}
-
-/// A buffer contains a list of cells representing characters that can be rendered.
-/// This doesn't necessarily have to be `stdout`, it can be anything that implements
-/// [`std::io::Write`]
-///
-/// The [`crate::Screen`] holds two `Buffer`s, used to only render the difference between frames.
-///
-/// The [`crate::Screen`] writes all the chars and their styles to the buffer, which works like a
-/// grid.
-#[derive(Debug, Clone)]
-pub struct Buffer {
-    size: Size,
-    pub(crate) inner: Box<[Cell]>,
-}
-
-impl Buffer {
-    /// Crate a new `Buffer` with a given size.
-    pub fn new(size: impl Into<Size>) -> Self {
-        let size = size.into();
-        Self {
-            inner: vec![Cell::empty(); (size.width * size.height) as usize].into_boxed_slice(),
-            size,
-        }
-    }
-
-    /// Create a new buffer with reset cells
-    pub(crate) fn reset(size: impl Into<Size>) -> Self {
-        let size = size.into();
-        Self {
-            inner: vec![Cell::reset(); (size.width * size.height) as usize].into_boxed_slice(),
-            size,
-        }
-    }
-
-    /// The size of the `Buffer`
-    pub fn size(&self) -> Size {
-        self.size
-    }
-
-    /// Resize the buffer, truncating what doesn't fit but keeps what does.
-    pub fn resize(&mut self, size: Size) {
-        let mut new_buf = Buffer::new(size);
-        for (y, line) in self.cell_lines().enumerate() {
-            if y >= size.height as usize {
-                break;
-            }
-
-            for (x, cell) in line.iter().enumerate() {
-                if x >= size.width as usize {
-                    break;
-                }
-
-                let pos = LocalPos::new(x as u16, y as u16);
-                new_buf.put(*cell, pos);
-            }
-        }
-
-        self.size = size;
-        self.inner = new_buf.inner;
-    }
-
-    /// Put a character with a style at a given position.
-    pub fn put_glyph(&mut self, glyph: Glyph, pos: LocalPos) {
-        assert!(
-            pos.x < self.size.width && pos.y < self.size.height,
-            "position out of bounds"
-        );
-
-        let style = match self.get(pos) {
-            Some((_, style)) => *style,
-            None => Style::new(),
-        };
-
-        let cell = Cell::new(glyph, style);
-        self.put(cell, pos);
-    }
-
-    /// Update the attributes at a given cell.
-    /// If there is no character at that cell, then write an empty space into it
-    pub fn update_cell(&mut self, style: Style, pos: LocalPos) {
-        if pos.x >= self.size.width || pos.y >= self.size.height {
-            return;
-        }
-
-        let index = pos.to_index(self.size.width);
-        let cell = &mut self.inner[index];
-
-        if let fg @ Some(_) = style.fg {
-            cell.style.fg = fg;
-        }
-
-        if let bg @ Some(_) = style.bg {
-            cell.style.bg = bg;
-        }
-
-        cell.style.attributes |= style.attributes;
-    }
-
-    /// Get a reference to a `char` and [`Style`] at a given position inside the buffer.
-    pub fn get(&self, pos: LocalPos) -> Option<(&Glyph, &Style)> {
-        if pos.x >= self.size.width || pos.y >= self.size.height {
-            return None;
-        }
-
-        let index = pos.to_index(self.size.width);
-        let cell = self.inner.get(index)?;
-        match &cell.state {
-            CellState::Occupied(c) => Some((c, &cell.style)),
-            _ => None,
-        }
-    }
-
-    /// Get a mutable reference to a `char` and [`Style`] at a given position inside the buffer.
-    pub fn get_mut(&mut self, pos: LocalPos) -> Option<(&mut Glyph, &mut Style)> {
-        if pos.x >= self.size.width || pos.y >= self.size.height {
-            return None;
-        }
-
-        let index = pos.to_index(self.size.width);
-        let cell = self.inner.get_mut(index)?;
-        match &mut cell.state {
-            CellState::Occupied(c) => Some((c, &mut cell.style)),
-            _ => None,
-        }
-    }
-
-    pub(super) fn reset_cell(&mut self, pos: LocalPos) {
-        let index = pos.to_index(self.size.width);
-        self.inner[index] = Cell::empty();
-    }
-
-    fn put(&mut self, mut cell: Cell, pos: LocalPos) {
-        let index = pos.to_index(self.size.width);
-
-        if let CellState::Occupied(c) = cell.state {
-            // If this is a unicode char that is wider than one cell,
-            // add a continuation cell if it fits, this way if we overwrite it
-            // we can set the continuation cell to `Empty`.
-            if pos.x < self.size.width && c.width() >= 2 {
-                self.put(Cell::continuation(cell.style), LocalPos::new(pos.x + 1, pos.y));
-            }
-        }
-
-        let current = &mut self.inner[index];
-        cell.style.merge(current.style);
-
-        match (&mut current.state, cell.state) {
-            // Merge the styles
-            (CellState::Occupied(current_char), CellState::Occupied(new_char)) => {
-                *current_char = new_char;
-                current.style.attributes |= cell.style.attributes;
-
-                if let Some(col) = cell.style.fg {
-                    current.style.fg = Some(col);
-                }
-
-                if let Some(col) = cell.style.bg {
-                    current.style.bg = Some(col);
-                }
-            }
-            _ => *current = cell,
-        }
-    }
-
-    pub(super) fn cell_lines(&mut self) -> impl Iterator<Item = &mut [Cell]> {
-        self.inner.chunks_mut(self.size.width as usize)
-    }
-}
-
-impl Index<(usize, usize)> for Buffer {
-    type Output = Cell;
-
-    fn index(&self, pos: (usize, usize)) -> &Self::Output {
-        let pos = LocalPos::from(pos);
-        let index = pos.to_index(self.size.width);
-        &self.inner[index]
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub(crate) enum Change {
-    Remove,
-    Continuation,
-    Insert(Glyph),
-}
-
-impl Change {
-    fn width(self) -> usize {
-        match self {
-            Self::Remove => 1,
-            Self::Continuation => 0,
-            Self::Insert(c) => c.width(),
-        }
-    }
-}
-
-pub(crate) fn diff(
-    old: &mut Buffer,
-    new: &mut Buffer,
-    changes: &mut Vec<(LocalPos, Option<Style>, Change)>,
-) -> Result<()> {
-    let mut previous_style = None;
-
-    for (y, (old_line, new_line)) in old.cell_lines().zip(new.cell_lines()).enumerate() {
-        for (x, (old_cell, new_cell)) in old_line.iter_mut().zip(new_line).enumerate() {
-            if old_cell == new_cell {
-                continue;
-            }
-
-            let change = match new_cell.state {
-                CellState::Empty => Change::Remove,
-                CellState::Continuation => Change::Continuation,
-                CellState::Occupied(c) => Change::Insert(c),
-            };
-
-            let style = match previous_style {
-                Some(previous) => (previous != new_cell.style).then_some(new_cell.style),
-                None => Some(new_cell.style),
-            };
-
-            previous_style = Some(new_cell.style);
-
-            *old_cell = *new_cell;
-
-            changes.push((LocalPos::from((x, y)), style, change));
-        }
-    }
-
-    Ok(())
-}
-
-// -----------------------------------------------------------------------------
-//     - Draw changes -
-// -----------------------------------------------------------------------------
-pub(crate) fn draw_changes(
-    mut w: impl Write,
-    glyph_map: &GlyphMap,
-    changes: &Vec<(LocalPos, Option<Style>, Change)>,
-) -> Result<()> {
-    let mut last_y = None;
-    let mut next_cell_x = None;
-
-    for (screen_pos, style, change) in changes {
-        // Cursor movement
-        let should_move = match (last_y, next_cell_x) {
-            (Some(last_y), Some(next_x)) => screen_pos.y > last_y || next_x != screen_pos.x,
-            _ => true,
-        };
-
-        if should_move {
-            w.queue(cursor::MoveTo(screen_pos.x, screen_pos.y))?;
-        }
-
-        last_y = Some(screen_pos.y);
-        next_cell_x = Some(screen_pos.x + change.width() as u16);
-
-        // Apply style
-        if let Some(style) = style {
-            write_style(style, &mut w)?;
-        }
-
-        // Draw changes
-        match change {
-            Change::Insert(c) => match c {
-                Glyph::Single(c, _) => {
-                    w.queue(Print(c))?;
-                }
-                Glyph::Cluster(index, _) => {
-                    if let Some(glyph) = glyph_map.get(*index) {
-                        w.queue(Print(glyph))?;
-                    }
-                }
-            },
-            Change::Continuation => (), // Don't write on continuation, just advance
-            Change::Remove => {
-                w.queue(Print(' '))?;
-            }
-        };
-    }
-
-    write_style(&Style::reset(), &mut w)?;
-    w.queue(cursor::MoveTo(0, 0))?;
-    Ok(())
-}
-
-#[cfg(test)]
-mod test {
-    use anathema_state::Color;
-
-    use super::*;
-    use crate::tui;
-
-    #[test]
-    fn changes() {
-        // Changes between the old buffer and the new buffer should be two inserts and one removal.
-        // The isnerts are for C and N, and since V is no longer present
-        // in the new buffer, it should be removed
-
-        let mut changes = vec![];
-
-        let mut old_buffer = Buffer::new((5u16, 3));
-        old_buffer.inner[0] = Cell::new(Glyph::from_char('O', 1), Style::reset());
-        old_buffer.inner[1] = Cell::new(Glyph::from_char('V', 1), Style::reset());
-
-        let mut new_buffer = Buffer::new((5u16, 3));
-        new_buffer.inner[0] = Cell::new(Glyph::from_char('C', 1), Style::reset());
-        new_buffer.inner[2] = Cell::new(Glyph::from_char('N', 1), Style::reset());
-
-        diff(&mut old_buffer, &mut new_buffer, &mut changes).unwrap();
-
-        let (_, _, change_1) = changes[0]; // Insert 'C'
-        let (_, _, change_2) = changes[1]; // Remove 'V'
-        let (_, _, change_3) = changes[2]; // Insert 'N'
-
-        assert_eq!(Change::Insert(Glyph::from_char('C', 1)), change_1);
-        assert_eq!(Change::Remove, change_2);
-        assert_eq!(Change::Insert(Glyph::from_char('N', 1)), change_3);
-    }
-
-    #[test]
-    fn resize() {
-        let mut buffer = Buffer::new((2u16, 2));
-        buffer.inner[0] = Cell::new(Glyph::from_char('1', 1), Style::reset());
-        buffer.inner[1] = Cell::new(Glyph::from_char('2', 1), Style::reset());
-        buffer.inner[2] = Cell::new(Glyph::from_char('3', 1), Style::reset());
-        buffer.inner[3] = Cell::new(Glyph::from_char('4', 1), Style::reset());
-
-        buffer.resize(Size::new(1, 2));
-        assert_eq!(buffer.inner[0], Cell::new(Glyph::from_char('1', 1), Style::reset()));
-        assert_eq!(buffer.inner[1], Cell::new(Glyph::from_char('3', 1), Style::reset()));
-    }
-
-    #[test]
-    fn update_cell_checks_range() {
-        let mut under_test = Buffer::new((1, 2));
-
-        let valid_pos = LocalPos::new(0, 1);
-        under_test.put_glyph(Glyph::from_char('1', 1), valid_pos);
-        under_test.put_glyph(Glyph::from_char('2', 1), valid_pos);
-
-        let new_style = Style {
-            fg: Some(Color::Red),
-            bg: None,
-            attributes: tui::Attributes::empty(),
-        };
-        under_test.update_cell(new_style, LocalPos::new(1, 0));
-
-        assert_eq!(under_test.get(valid_pos).unwrap().1.clone(), Style::reset());
-    }
-
-    #[test]
-    #[should_panic(expected = "position out of bounds")]
-    fn put_glyph_checks_range() {
-        let mut under_test = Buffer::new((1, 2));
-
-        under_test.put_glyph(Glyph::from_char('x', 1), LocalPos::new(0, 0));
-        under_test.put_glyph(Glyph::from_char('x', 1), LocalPos::new(0, 1));
-        under_test.put_glyph(Glyph::from_char('o', 1), LocalPos::new(1, 0));
-    }
-
-    #[test]
-    fn get_checks_range() {
-        let mut under_test = Buffer::new((1, 2));
-
-        under_test.put_glyph(Glyph::from_char('1', 1), LocalPos::new(0, 0));
-        under_test.put_glyph(Glyph::from_char('2', 1), LocalPos::new(0, 1));
-
-        assert_eq!(under_test.get(LocalPos::new(1, 0)), None);
-    }
-
-    #[test]
-    fn get_mut_checks_range() {
-        let mut under_test = Buffer::new((1, 2));
-
-        under_test.put_glyph(Glyph::from_char('1', 1), LocalPos::new(0, 0));
-        under_test.put_glyph(Glyph::from_char('2', 1), LocalPos::new(0, 1));
-
-        assert_eq!(under_test.get_mut(LocalPos::new(1, 0)), None);
-    }
-}
diff --git a/anathema-backend/src/tui/events.rs b/anathema-backend/src/tui/events.rs
deleted file mode 100644
index b3afaa64..00000000
--- a/anathema-backend/src/tui/events.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-use std::time::Duration;
-
-use anathema_widgets::components::events::{Event, KeyCode, KeyEvent, KeyState, MouseButton, MouseEvent, MouseState};
-use crossterm::event::{Event as CTEvent, KeyEventKind, read};
-pub use crossterm::event::{
-    KeyCode as CTKeyCode, KeyEvent as CTKeyEvent, KeyEventState, KeyModifiers, MouseButton as CTMouseButton,
-    MouseEvent as CTMouseEvent, MouseEventKind,
-};
-
-/// Event listener
-pub struct Events;
-
-impl Events {
-    /// Poll events given a duration.
-    /// If no event is available within the duration
-    /// the function will return `None`.
-    pub fn poll(&self, timeout: Duration) -> Option<Event> {
-        match crossterm::event::poll(timeout).ok()? {
-            true => {
-                let event = read().ok()?;
-
-                let event = match event {
-                    CTEvent::Paste(_) => Event::Noop,
-                    CTEvent::FocusGained => Event::Focus,
-                    CTEvent::FocusLost => Event::Blur,
-                    CTEvent::Key(key_ev) => Event::Key(key_code_to_key_code(key_ev)),
-                    CTEvent::Mouse(mouse_ev) => Event::Mouse(mouse_to_mouse(mouse_ev)),
-                    CTEvent::Resize(width, height) => Event::Resize((width, height).into()),
-                };
-
-                Some(event)
-            }
-            false => None,
-        }
-    }
-}
-
-fn key_code_to_key_code(from: CTKeyEvent) -> KeyEvent {
-    KeyEvent {
-        ctrl: from.modifiers.contains(KeyModifiers::CONTROL),
-        code: match from.code {
-            CTKeyCode::Backspace => KeyCode::Backspace,
-            CTKeyCode::Enter => KeyCode::Enter,
-            CTKeyCode::Left => KeyCode::Left,
-            CTKeyCode::Right => KeyCode::Right,
-            CTKeyCode::Up => KeyCode::Up,
-            CTKeyCode::Down => KeyCode::Down,
-            CTKeyCode::Home => KeyCode::Home,
-            CTKeyCode::End => KeyCode::End,
-            CTKeyCode::PageUp => KeyCode::PageUp,
-            CTKeyCode::PageDown => KeyCode::PageDown,
-            CTKeyCode::Tab => KeyCode::Tab,
-            CTKeyCode::BackTab => KeyCode::BackTab,
-            CTKeyCode::Delete => KeyCode::Delete,
-            CTKeyCode::Insert => KeyCode::Insert,
-            CTKeyCode::F(key) => KeyCode::F(key),
-            CTKeyCode::Char(c) => KeyCode::Char(c),
-            CTKeyCode::Null => KeyCode::Null,
-            CTKeyCode::Esc => KeyCode::Esc,
-            CTKeyCode::CapsLock => KeyCode::CapsLock,
-            CTKeyCode::ScrollLock => KeyCode::ScrollLock,
-            CTKeyCode::NumLock => KeyCode::NumLock,
-            CTKeyCode::PrintScreen => KeyCode::PrintScreen,
-            CTKeyCode::Pause => KeyCode::Pause,
-            CTKeyCode::Menu => KeyCode::Menu,
-            CTKeyCode::KeypadBegin => KeyCode::KeypadBegin,
-            CTKeyCode::Media(_) => KeyCode::Null,
-            CTKeyCode::Modifier(_) => KeyCode::Null,
-        },
-        state: match from.kind {
-            KeyEventKind::Press => KeyState::Press,
-            KeyEventKind::Repeat => KeyState::Repeat,
-            KeyEventKind::Release => KeyState::Release,
-        },
-    }
-}
-
-fn mouse_to_mouse(from: CTMouseEvent) -> MouseEvent {
-    MouseEvent {
-        x: from.column,
-        y: from.row,
-        state: match from.kind {
-            MouseEventKind::Down(button) => MouseState::Down(button_to_button(button)),
-            MouseEventKind::Up(button) => MouseState::Up(button_to_button(button)),
-            MouseEventKind::Drag(button) => MouseState::Drag(button_to_button(button)),
-            MouseEventKind::Moved => MouseState::Move,
-            MouseEventKind::ScrollDown => MouseState::ScrollDown,
-            MouseEventKind::ScrollUp => MouseState::ScrollUp,
-            MouseEventKind::ScrollLeft => MouseState::ScrollLeft,
-            MouseEventKind::ScrollRight => MouseState::ScrollRight,
-        },
-    }
-}
-
-fn button_to_button(button: CTMouseButton) -> MouseButton {
-    match button {
-        CTMouseButton::Left => MouseButton::Left,
-        CTMouseButton::Middle => MouseButton::Middle,
-        CTMouseButton::Right => MouseButton::Right,
-    }
-}
diff --git a/anathema-backend/src/tui/mod.rs b/anathema-backend/src/tui/mod.rs
deleted file mode 100644
index f0e10ab8..00000000
--- a/anathema-backend/src/tui/mod.rs
+++ /dev/null
@@ -1,268 +0,0 @@
-//! The tui module contains the essential types for drawing in the terminal.
-//!
-//! It uses two buffers and only draws the diffs from top left to bottom right, making it less
-//! likely to flicker when moving the cursor etc.
-#![deny(missing_docs)]
-use std::io::{Stdout, Write};
-use std::ops::Add;
-use std::time::Duration;
-
-use anathema_geometry::{LocalPos, Pos, Size};
-use anathema_value_resolver::AttributeStorage;
-use anathema_widgets::components::events::Event;
-pub use anathema_widgets::{Attributes, Style};
-use anathema_widgets::{GlyphMap, PaintChildren, WidgetRenderer};
-use crossterm::cursor::{RestorePosition, SavePosition};
-use crossterm::execute;
-use crossterm::terminal::{BeginSynchronizedUpdate, Clear, ClearType, EndSynchronizedUpdate, size};
-pub use screen::Screen;
-
-pub use self::buffer::Buffer;
-use self::events::Events;
-use crate::Backend;
-
-mod buffer;
-/// Events
-pub mod events;
-mod screen;
-mod style;
-
-/// Backend builder for a tui backend.
-pub struct TuiBackendBuilder {
-    output: Stdout,
-    hide_cursor: bool,
-    enable_raw_mode: bool,
-    enable_alt_screen: bool,
-    enable_mouse: bool,
-}
-
-impl TuiBackendBuilder {
-    /// Enable an alternative screen.
-    /// When using this with stdout it means the output will not persist
-    /// once the program exits.
-    pub fn enable_alt_screen(mut self) -> Self {
-        self.enable_alt_screen = true;
-        self
-    }
-
-    /// Enable mouse support.
-    pub fn enable_mouse(mut self) -> Self {
-        self.enable_mouse = true;
-        self
-    }
-
-    /// When raw mode is enabled, every key press is sent to the terminal.
-    /// If raw mode is not enabled, the return key has to be pressed to
-    /// send characters to the terminal.
-    pub fn enable_raw_mode(mut self) -> Self {
-        self.enable_raw_mode = true;
-        self
-    }
-
-    /// Hide the text cursor.
-    pub fn hide_cursor(mut self) -> Self {
-        self.hide_cursor = true;
-        self
-    }
-
-    /// Clear the screen using ansi escape codes.
-    pub fn clear(mut self) -> Self {
-        let _ = execute!(&mut self.output, Clear(ClearType::All));
-        self
-    }
-
-    /// Consume self and create the tui backend.
-    pub fn finish(self) -> Result<TuiBackend, std::io::Error> {
-        let size = size()?;
-        let screen = Screen::new(size);
-
-        let backend = TuiBackend {
-            screen,
-            output: self.output,
-            events: Events,
-
-            hide_cursor: self.hide_cursor,
-            enable_raw_mode: self.enable_raw_mode,
-            enable_alt_screen: self.enable_alt_screen,
-            enable_mouse: self.enable_mouse,
-        };
-
-        Ok(backend)
-    }
-}
-
-/// Terminal backend
-pub struct TuiBackend {
-    screen: Screen,
-    output: Stdout,
-    events: Events,
-
-    // Settings
-    hide_cursor: bool,
-    enable_raw_mode: bool,
-    enable_alt_screen: bool,
-    enable_mouse: bool,
-}
-
-impl TuiBackend {
-    /// Create a new instance of the tui backend.
-    pub fn builder() -> TuiBackendBuilder {
-        TuiBackendBuilder {
-            output: std::io::stdout(),
-            hide_cursor: false,
-            enable_raw_mode: false,
-            enable_alt_screen: false,
-            enable_mouse: false,
-        }
-    }
-
-    /// Convenience function this is the same as calling
-    /// ```no_run
-    /// # use anathema_backend::tui::TuiBackend;
-    /// # use anathema_backend::Backend;
-    /// let mut backend = TuiBackend::builder()
-    ///     .enable_alt_screen()
-    ///     .enable_raw_mode()
-    ///     .hide_cursor()
-    ///     .finish()
-    ///     .unwrap();
-    /// backend.finalize();
-    /// ```
-    pub fn full_screen() -> Self {
-        let mut inst = Self::builder()
-            .enable_alt_screen()
-            .enable_raw_mode()
-            .hide_cursor()
-            .finish()
-            .unwrap();
-        inst.finalize();
-        inst
-    }
-
-    /// Disable raw mode.
-    pub fn disable_raw_mode(self) -> Self {
-        let _ = Screen::disable_raw_mode();
-        self
-    }
-}
-
-impl Backend for TuiBackend {
-    fn size(&self) -> Size {
-        self.screen.size()
-    }
-
-    fn next_event(&mut self, timeout: Duration) -> Option<Event> {
-        self.events.poll(timeout)
-    }
-
-    fn resize(&mut self, new_size: Size, _: &mut GlyphMap) {
-        self.screen.resize(new_size);
-    }
-
-    fn paint<'bp>(
-        &mut self,
-        glyph_map: &mut GlyphMap,
-        widgets: PaintChildren<'_, 'bp>,
-        attribute_storage: &AttributeStorage<'bp>,
-    ) {
-        anathema_widgets::paint::paint(&mut self.screen, glyph_map, widgets, attribute_storage);
-    }
-
-    fn render(&mut self, glyph_map: &mut GlyphMap) {
-        let _ = execute!(&mut self.output, BeginSynchronizedUpdate);
-        let _ = self.screen.render(&mut self.output, glyph_map);
-        let _ = execute!(&mut self.output, EndSynchronizedUpdate);
-    }
-
-    fn clear(&mut self) {
-        self.screen.erase();
-    }
-
-    fn finalize(&mut self) {
-        if self.enable_alt_screen {
-            let _ = execute!(&mut self.output, SavePosition);
-            let _ = Screen::enter_alt_screen(&mut self.output);
-        }
-
-        if self.hide_cursor {
-            // This is to fix an issue with Windows cmd.exe
-            let _ = Screen::show_cursor(&mut self.output);
-            let _ = Screen::hide_cursor(&mut self.output);
-        }
-
-        if self.enable_raw_mode {
-            let _ = Screen::enable_raw_mode();
-        }
-
-        if self.enable_mouse {
-            let _ = Screen::enable_mouse(&mut self.output);
-        }
-
-        let _ = self.output.flush();
-    }
-}
-
-impl Drop for TuiBackend {
-    fn drop(&mut self) {
-        if self.enable_alt_screen {
-            let _ = execute!(&mut self.output, RestorePosition);
-        }
-        let _ = self.screen.restore(&mut self.output, self.enable_alt_screen);
-    }
-}
-
-/// Represents a position on the screen, meaning this should never
-/// be a value outside of the screen size.
-///
-/// It will be ignored if the value is used in a drawing operation and it's outside the current
-/// screen size.
-///
-/// `Screen::ZERO` is the top left of a buffer.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct ScreenPos {
-    /// The x coordinate on screen
-    pub x: u16,
-    /// The y coordinate on screen
-    pub y: u16,
-}
-
-impl ScreenPos {
-    /// A zero screen size
-    pub const ZERO: Self = Self::new(0, 0);
-
-    /// Create a new instance of a `ScreenPos`
-    pub const fn new(x: u16, y: u16) -> Self {
-        Self { x, y }
-    }
-}
-
-impl Add<ScreenPos> for LocalPos {
-    type Output = Self;
-
-    fn add(self, rhs: ScreenPos) -> Self::Output {
-        LocalPos {
-            x: self.x + rhs.x,
-            y: self.y + rhs.y,
-        }
-    }
-}
-
-impl TryFrom<LocalPos> for ScreenPos {
-    type Error = <u16 as TryFrom<usize>>::Error;
-
-    fn try_from(value: LocalPos) -> std::result::Result<ScreenPos, Self::Error> {
-        let x = value.x;
-        let y = value.y;
-        Ok(ScreenPos::new(x, y))
-    }
-}
-
-impl TryFrom<Pos> for ScreenPos {
-    type Error = <i32 as TryFrom<usize>>::Error;
-
-    fn try_from(value: Pos) -> std::result::Result<ScreenPos, Self::Error> {
-        let x: u16 = value.x.try_into()?;
-        let y: u16 = value.y.try_into()?;
-        Ok(ScreenPos::new(x, y))
-    }
-}
diff --git a/anathema-backend/src/tui/screen.rs b/anathema-backend/src/tui/screen.rs
deleted file mode 100644
index daa5d72a..00000000
--- a/anathema-backend/src/tui/screen.rs
+++ /dev/null
@@ -1,258 +0,0 @@
-use std::io::{Result, Write};
-
-use anathema_geometry::{Pos, Size};
-use anathema_value_resolver::Attributes;
-use anathema_widgets::paint::Glyph;
-use anathema_widgets::{GlyphMap, Style, WidgetRenderer};
-use crossterm::event::EnableMouseCapture;
-use crossterm::terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode};
-use crossterm::{ExecutableCommand, QueueableCommand, cursor};
-
-use super::LocalPos;
-use super::buffer::{Buffer, Change, diff, draw_changes};
-
-/// The `Screen` is used to draw to some `std::io::Write`able output (generally `stdout`);
-pub struct Screen {
-    // This is pub(crate) for testing purposes
-    pub(crate) new_buffer: Buffer,
-    old_buffer: Buffer,
-    changes: Vec<(LocalPos, Option<Style>, Change)>,
-}
-
-impl Screen {
-    /// Hide the cursor
-    pub(super) fn hide_cursor(mut output: impl Write) -> Result<()> {
-        output.queue(cursor::Hide)?;
-        Ok(())
-    }
-
-    /// Show the cursor
-    pub(super) fn show_cursor(mut output: impl Write) -> Result<()> {
-        output.queue(cursor::Show)?;
-        Ok(())
-    }
-
-    /// Enable mouse support
-    pub(super) fn enable_mouse(mut output: impl Write) -> Result<()> {
-        output.queue(EnableMouseCapture)?;
-        Ok(())
-    }
-
-    /// Create a new instance of a screen.
-    /// The `output` should be a mutable reference to whatever this screen renders to.
-    /// The `output` is used initially to move the cursor and hide it.
-    pub fn new(size: impl Into<Size>) -> Self {
-        let size: Size = size.into();
-
-        Self {
-            old_buffer: Buffer::new(size),
-            new_buffer: Buffer::new(size),
-            changes: vec![],
-        }
-    }
-
-    /// Resize the buffer.
-    /// This will empty the underlying buffers so everything will have
-    /// to be redrawn.
-    pub(super) fn resize(&mut self, new_size: Size) {
-        self.old_buffer = Buffer::new(new_size);
-        self.new_buffer = Buffer::reset(new_size);
-    }
-
-    /// Erase the entire buffer by writing empty cells
-    pub(crate) fn erase(&mut self) {
-        self.erase_region(LocalPos::ZERO, self.size());
-    }
-
-    /// Erase a specific region.
-    /// Will reset the styles for all the cells as well.
-    pub(crate) fn erase_region(&mut self, pos: LocalPos, size: Size) {
-        let to_x = (size.width + pos.x).min(self.size().width);
-        let to_y = (size.height + pos.y).min(self.size().height);
-
-        for x in pos.x.min(to_x)..to_x {
-            for y in pos.y.min(to_y)..to_y {
-                self.new_buffer.reset_cell(LocalPos::new(x, y));
-            }
-        }
-    }
-
-    /// Put a char at the given screen position, with a given style.
-    /// If the screen position is outside the [`Buffer`]s size then this is
-    /// out of bounds and will panic.
-    pub(crate) fn paint_glyph(&mut self, glyph: Glyph, pos: LocalPos) {
-        self.new_buffer.put_glyph(glyph, pos);
-    }
-
-    pub(crate) fn update_cell(&mut self, style: Style, pos: LocalPos) {
-        self.new_buffer.update_cell(style, pos);
-    }
-
-    /// Draw the changes to the screen
-    pub(crate) fn render(&mut self, mut output: impl Write, glyph_map: &GlyphMap) -> Result<()> {
-        diff(&mut self.old_buffer, &mut self.new_buffer, &mut self.changes)?;
-
-        if self.changes.is_empty() {
-            return Ok(());
-        }
-
-        draw_changes(&mut output, glyph_map, &self.changes)?;
-
-        self.changes.clear();
-
-        output.flush()?;
-
-        Ok(())
-    }
-
-    /// Enter an alternative screen.
-    /// When using this with stdout it means the output will not persist once the program exits.
-    pub fn enter_alt_screen(mut output: impl Write) -> Result<()> {
-        output.execute(EnterAlternateScreen)?;
-        Ok(())
-    }
-
-    /// Enable raw mode: input will not be forwarded to the screen.
-    pub fn enable_raw_mode() -> Result<()> {
-        enable_raw_mode()?;
-        Ok(())
-    }
-
-    /// Disable raw mode: input will be forwarded to the screen.
-    pub fn disable_raw_mode() -> Result<()> {
-        disable_raw_mode()?;
-        Ok(())
-    }
-
-    /// Restore the terminal by setting the cursor to show, disable raw mode, disable mouse capture
-    /// and leave any alternative screens
-    pub fn restore(&mut self, mut output: impl Write, leave_alt_screen: bool) -> Result<()> {
-        disable_raw_mode()?;
-        if leave_alt_screen {
-            output.execute(LeaveAlternateScreen)?;
-        }
-        #[cfg(not(target_os = "windows"))]
-        output.execute(crossterm::event::DisableMouseCapture)?;
-        output.execute(cursor::Show)?;
-        Ok(())
-    }
-}
-
-impl WidgetRenderer for Screen {
-    fn draw_glyph(&mut self, c: Glyph, pos: Pos) {
-        let Ok(screen_pos) = pos.try_into() else { return };
-        self.paint_glyph(c, screen_pos);
-    }
-
-    fn set_attributes(&mut self, attribs: &Attributes<'_>, pos: Pos) {
-        let style = Style::from_cell_attribs(attribs);
-        self.set_style(style, pos)
-    }
-
-    fn set_style(&mut self, style: Style, local_pos: Pos) {
-        let Ok(screen_pos) = local_pos.try_into() else { return };
-        self.update_cell(style, screen_pos);
-    }
-
-    fn size(&self) -> Size {
-        self.new_buffer.size()
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::tui::buffer::{Cell, CellState};
-
-    fn state_at(buffer: &Buffer, x: usize, y: usize) -> CellState {
-        let cell = buffer[(x, y)];
-        cell.state
-    }
-
-    fn char_at(buffer: &Buffer, x: usize, y: usize) -> char {
-        match state_at(buffer, x, y) {
-            CellState::Occupied(Glyph::Single(c, _)) => c,
-            _ => panic!(),
-        }
-    }
-
-    #[test]
-    fn render() {
-        // Render a character
-        let mut render_output = vec![];
-        let glyph_map = GlyphMap::empty();
-        let mut screen = Screen::new(Size::new(1, 1));
-        screen.paint_glyph(Glyph::from_char('x', 1), LocalPos::ZERO);
-        screen.render(&mut render_output, &glyph_map).unwrap();
-
-        let expected = Cell::new(Glyph::from_char('x', 1), Style::reset());
-        let actual = screen.new_buffer.inner[0];
-        assert_eq!(expected, actual);
-    }
-
-    #[test]
-    fn erase_region() {
-        let mut render_output = vec![];
-        let glyph_map = GlyphMap::empty();
-        let mut screen = Screen::new(Size::new(2, 2));
-        screen.render(&mut render_output, &glyph_map).unwrap();
-
-        // Erase the bottom right corner of the 2x2 region
-        screen.erase_region(LocalPos::new(1, 1), Size::new(2, 2));
-
-        let top_left = screen.new_buffer.inner[0];
-        assert_eq!(Cell::empty(), top_left);
-        let bottom_right = screen.new_buffer.inner[3];
-        assert_eq!(Cell::empty(), bottom_right);
-    }
-
-    #[test]
-    #[should_panic(expected = "position out of bounds")]
-    fn put_outside_of_screen() {
-        // Put a character outside of the screen should panic
-        let glyph_map = GlyphMap::empty();
-        let mut screen = Screen::new(Size::new(1, 1));
-        screen.paint_glyph(Glyph::from_char('x', 1), LocalPos::new(3, 0));
-        screen.render(&mut vec![], &glyph_map).unwrap();
-    }
-
-    #[test]
-    fn erasing_unicode_with_continuation_cell() {
-        // Paint a bunny in the next cell
-
-        let glyph_map = GlyphMap::empty();
-        let mut screen = Screen::new(Size::new(4, 1));
-        let bunny = '🐇';
-        // Where B = Bunny, c = continuation, 1 = some character
-        //
-        // Buffer
-        // B c 1 0
-        //
-        // Next buffer
-        // - B c 1
-
-        // First frame: Bc10
-        screen.paint_glyph(Glyph::from_char('1', 1), LocalPos::new(2, 0));
-        screen.paint_glyph(Glyph::from_char('0', 1), LocalPos::new(3, 0));
-        screen.paint_glyph(Glyph::from_char(bunny, 2), LocalPos::new(0, 0));
-
-        screen.render(&mut vec![], &glyph_map).unwrap();
-
-        assert_eq!(char_at(&screen.new_buffer, 0, 0), bunny);
-        assert_eq!(state_at(&screen.new_buffer, 1, 0), CellState::Continuation);
-        assert_eq!(char_at(&screen.new_buffer, 2, 0), '1');
-        assert_eq!(char_at(&screen.new_buffer, 3, 0), '0');
-
-        // // Second frame: -Bc1
-        screen.erase();
-
-        screen.paint_glyph(Glyph::from_char('1', 1), LocalPos::new(3, 0));
-        screen.paint_glyph(Glyph::from_char(bunny, 2), LocalPos::new(1, 0));
-        screen.render(&mut vec![], &glyph_map).unwrap();
-
-        assert_eq!(state_at(&screen.new_buffer, 0, 0), CellState::Empty);
-        assert_eq!(char_at(&screen.new_buffer, 1, 0), bunny);
-        assert_eq!(state_at(&screen.new_buffer, 2, 0), CellState::Continuation);
-        assert_eq!(char_at(&screen.new_buffer, 3, 0), '1');
-    }
-}
diff --git a/anathema-backend/src/tui/style.rs b/anathema-backend/src/tui/style.rs
deleted file mode 100644
index 6621b93d..00000000
--- a/anathema-backend/src/tui/style.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-use std::io::{Result, Write};
-
-use anathema_state::Color;
-use anathema_widgets::{Attributes, Style};
-use crossterm::QueueableCommand;
-pub use crossterm::style::{Attribute as CrossAttrib, Color as CTColor};
-use crossterm::style::{SetAttribute, SetBackgroundColor, SetForegroundColor};
-
-struct ColorWrapper(Color);
-
-impl From<ColorWrapper> for CTColor {
-    fn from(color: ColorWrapper) -> CTColor {
-        match color.0 {
-            Color::Reset => Self::Reset,
-            Color::Black => Self::Black,
-            Color::Red => Self::DarkRed,
-            Color::Green => Self::DarkGreen,
-            Color::Yellow => Self::DarkYellow,
-            Color::Blue => Self::DarkBlue,
-            Color::Magenta => Self::DarkMagenta,
-            Color::Cyan => Self::DarkCyan,
-            Color::Grey => Self::Grey,
-            Color::DarkGrey => Self::DarkGrey,
-            Color::LightRed => Self::Red,
-            Color::LightGreen => Self::Green,
-            Color::LightYellow => Self::Yellow,
-            Color::LightBlue => Self::Blue,
-            Color::LightMagenta => Self::Magenta,
-            Color::LightCyan => Self::Cyan,
-            Color::White => Self::White,
-            Color::Rgb(r, g, b) => Self::Rgb { r, g, b },
-            Color::AnsiVal(v) => Self::AnsiValue(v),
-        }
-    }
-}
-
-pub(crate) fn write_style(style: &Style, w: &mut impl Write) -> Result<()> {
-    if let Some(fg) = style.fg {
-        w.queue(SetForegroundColor(ColorWrapper(fg).into()))?;
-    }
-
-    if let Some(bg) = style.bg {
-        w.queue(SetBackgroundColor(ColorWrapper(bg).into()))?;
-    }
-
-    // Dim and bold are a special case, as they are both
-    // reset through `NormalIntensity` (22).
-    // This means the reset has to happen before setting
-    // bold or dim
-    if !style.attributes.contains(Attributes::BOLD | Attributes::DIM) {
-        w.queue(SetAttribute(CrossAttrib::NormalIntensity))?;
-    }
-
-    if style.attributes.contains(Attributes::NORMAL) {
-        w.queue(SetAttribute(CrossAttrib::NormalIntensity))?;
-    } else if style.attributes.contains(Attributes::BOLD) {
-        w.queue(SetAttribute(CrossAttrib::Bold))?;
-    }
-
-    if style.attributes.contains(Attributes::DIM) {
-        w.queue(SetAttribute(CrossAttrib::Dim))?;
-    }
-
-    macro_rules! check {
-        ($inc:expr, $exc:expr) => {
-            style.attributes.contains($inc) && !style.attributes.contains($exc)
-        };
-    }
-
-    // Italic
-    if check!(Attributes::ITALIC, Attributes::NOT_ITALIC) {
-        w.queue(SetAttribute(CrossAttrib::Italic))?;
-    } else {
-        w.queue(SetAttribute(CrossAttrib::NoItalic))?;
-    }
-
-    // Underlined
-    if check!(Attributes::UNDERLINED, Attributes::NOT_UNDERLINED) {
-        w.queue(SetAttribute(CrossAttrib::Underlined))?;
-    } else {
-        w.queue(SetAttribute(CrossAttrib::NoUnderline))?;
-    }
-
-    if check!(Attributes::OVERLINED, Attributes::NOT_OVERLINED) {
-        w.queue(SetAttribute(CrossAttrib::OverLined))?;
-    } else {
-        w.queue(SetAttribute(CrossAttrib::NotOverLined))?;
-    }
-
-    if check!(Attributes::CROSSED_OUT, Attributes::NOT_CROSSED_OUT) {
-        w.queue(SetAttribute(CrossAttrib::CrossedOut))?;
-    } else {
-        w.queue(SetAttribute(CrossAttrib::NotCrossedOut))?;
-    }
-
-    if check!(Attributes::REVERSED, Attributes::NOT_REVERSED) {
-        w.queue(SetAttribute(CrossAttrib::Reverse))?;
-    } else {
-        w.queue(SetAttribute(CrossAttrib::NoReverse))?;
-    }
-
-    Ok(())
-}
diff --git a/anathema-backend/src/tuiscroll/mod.rs b/anathema-backend/src/tuiscroll/mod.rs
deleted file mode 100644
index dd381e95..00000000
--- a/anathema-backend/src/tuiscroll/mod.rs
+++ /dev/null
@@ -1,88 +0,0 @@
-use std::time::Duration;
-
-use anathema_geometry::{Pos, Size};
-use anathema_value_resolver::{AttributeStorage, Attributes};
-use anathema_widgets::components::events::Event;
-use anathema_widgets::paint::Glyph;
-use anathema_widgets::{GlyphMap, WidgetRenderer};
-use crossterm::cursor::position;
-use crossterm::terminal::size;
-
-use crate::Backend;
-
-struct Surface {
-    width: usize,
-    position: Pos,
-    draw: Vec<Pos>,
-}
-
-impl Surface {
-    pub fn new() -> Self {
-        let position = position().map(|(x, y)| Pos::new(x as i32, y as i32)).unwrap();
-        let (width, _) = size().unwrap();
-        let width = width as usize;
-        Self {
-            position,
-            width,
-            draw: vec![],
-        }
-    }
-
-    fn drain(&mut self) {
-        self.draw.sort_by(|a, b| a.partial_cmp(&b).unwrap());
-    }
-}
-
-impl WidgetRenderer for Surface {
-    fn draw_glyph(&mut self, glyph: Glyph, local_pos: Pos) {
-        todo!()
-    }
-
-    fn set_attributes(&mut self, attribs: &Attributes<'_>, local_pos: Pos) {
-        todo!()
-    }
-
-    fn set_style(&mut self, style: anathema_widgets::Style, local_pos: Pos) {
-        todo!()
-    }
-
-    fn size(&self) -> Size {
-        panic!()
-        // Size {
-        //     width: self.width,
-        //     height: usize::MAX,
-        // }
-    }
-}
-
-pub struct TuiScroll {
-    surface: Surface,
-}
-
-impl Backend for TuiScroll {
-    fn size(&self) -> Size {
-        let s = size().expect("without the size there is no life");
-        s.into()
-    }
-
-    fn next_event(&mut self, timeout: Duration) -> Option<Event> {
-        None
-    }
-
-    fn resize(&mut self, _: Size, _: &mut GlyphMap) {}
-
-    fn paint<'bp>(
-        &mut self,
-        glyph_map: &mut GlyphMap,
-        widgets: anathema_widgets::PaintChildren<'_, 'bp>,
-        attribute_storage: &AttributeStorage<'bp>,
-    ) {
-        anathema_widgets::paint::paint(&mut self.surface, glyph_map, widgets, attribute_storage);
-    }
-
-    fn render(&mut self, glyph_map: &mut GlyphMap) {
-        todo!()
-    }
-
-    fn clear(&mut self) {}
-}
diff --git a/anathema-core/Cargo.toml b/anathema-core/Cargo.toml
new file mode 100644
index 00000000..c7510cc9
--- /dev/null
+++ b/anathema-core/Cargo.toml
@@ -0,0 +1,18 @@
+[package]
+name = "anathema-core"
+edition.workspace = true
+version.workspace = true
+
+[dependencies]
+anathema-store = { path = "../anathema-store", version = "0.2.12-beta" }
+anathema-geometry = { path = "../anathema-geometry", version = "0.2.12-beta" }
+anathema-state = { path = "../anathema-state", version = "0.2.12-beta" }
+nohash-hasher = "0.2.0"
+
+[lints]
+workspace = true
+
+[features]
+default = []
+multithread = []
+
diff --git a/anathema-core/src/attributes.rs b/anathema-core/src/attributes.rs
new file mode 100644
index 00000000..24b01208
--- /dev/null
+++ b/anathema-core/src/attributes.rs
@@ -0,0 +1,321 @@
+//! Element attributes
+use std::borrow::Borrow;
+use std::ops::Deref;
+
+use anathema_store::remotecell::RemoteCell;
+use anathema_store::slab::SecondaryMap;
+use anathema_store::smallmap::{SmallIndex, SmallMap};
+
+use crate::runtime::elements::ElementId;
+use crate::runtime::eval::values::TemplateValue;
+
+// All attributes for all elements
+#[derive(Debug)]
+pub(crate) struct AttributeRegistry<'bp> {
+    attributes: SecondaryMap<ElementId, Attributes<'bp>>,
+}
+
+impl<'bp> AttributeRegistry<'bp> {
+    pub(crate) fn empty() -> Self {
+        Self {
+            attributes: SecondaryMap::empty(),
+        }
+    }
+
+    pub(crate) fn insert(&mut self, id: ElementId, attributes: Attributes<'bp>) {
+        self.attributes.insert(id, attributes);
+    }
+
+    pub(crate) fn get(&self, id: ElementId) -> Option<&Attributes<'bp>> {
+        self.attributes.get(id)
+    }
+}
+
+// The access key for attributes.
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub(crate) enum ValueKey<'bp> {
+    Value,
+    Attribute(&'bp str),
+}
+
+impl ValueKey<'_> {
+    fn as_str(&self) -> &str {
+        match self {
+            ValueKey::Value => "[value]",
+            ValueKey::Attribute(name) => name,
+        }
+    }
+}
+
+impl Borrow<str> for ValueKey<'_> {
+    fn borrow(&self) -> &str {
+        self.as_str()
+    }
+}
+
+/// Element attributes
+///
+/// ```text
+/// text [foreground: "red", bold: true] "hello world"
+/// ```
+///
+/// Attributes can be set / replaced or read, but never mutated because of the `RemoteCell`.
+#[derive(Debug)]
+pub struct Attributes<'bp> {
+    inner: SmallMap<ValueKey<'bp>, RemoteCell<TemplateValue<'bp>>>,
+}
+
+impl<'bp> Attributes<'bp> {
+    /// Create a new instance of en empty set of attributes
+    pub fn empty() -> Self {
+        Self {
+            inner: SmallMap::empty(),
+        }
+    }
+
+    /// Set an attribute value.
+    /// ```
+    /// # use anathema_core::attributes::Attributes;
+    /// # use anathema_core::runtime::TemplateValue;
+    ///
+    /// let mut attributes = Attributes::empty();
+    /// attributes.set("name", "Nonsense");
+    /// attributes.get_as::<&str>("name").unwrap();
+    /// ```
+    pub fn set(&mut self, key: &'bp str, value: impl Into<TemplateValue<'bp>>) {
+        let value = value.into();
+        let (cell, _) = RemoteCell::new(value);
+        self.inner.set(ValueKey::Attribute(key), cell);
+    }
+
+    /// Set an attribute value.
+    /// ```
+    /// # use anathema_core::attributes::Attributes ;
+    /// # use anathema_core::runtime::TemplateValue;
+    ///
+    /// let mut attributes = Attributes::empty();
+    /// attributes.set_value("Nonsense");
+    /// attributes.value_as::<&str>().unwrap();
+    /// ```
+    pub fn set_value(&mut self, value: impl Into<TemplateValue<'bp>>) {
+        let key = ValueKey::Value;
+        let value = value.into();
+        let (cell, _) = RemoteCell::new(value);
+        self.inner.set(key, cell);
+    }
+
+    // Set remote cells directly.
+    // Use this when there is an update handle at the other end
+    pub(crate) fn set_attribute(&mut self, key: ValueKey<'bp>, value: RemoteCell<TemplateValue<'bp>>) {
+        self.inner.set(key, value);
+    }
+
+    /// Remove a value from attributes
+    pub fn remove(&mut self, key: &str) -> Option<RemoteCell<TemplateValue<'bp>>> {
+        self.inner.remove(key)
+    }
+
+    pub(crate) fn get(&self, key: &str) -> Option<&TemplateValue<'bp>> {
+        let val = self.inner.get(key)?;
+        Some(&*val)
+    }
+
+    /// Get a value as a given type.
+    /// If the value doesn't exist or can not be cast to the
+    /// expected type `None` is returned.
+    /// ```
+    /// # use anathema_core::attributes::Attributes;
+    ///
+    /// let mut attributes = Attributes::empty();
+    /// attributes.set("num", 123);
+    ///
+    /// assert_eq!(attributes.get_as::<u32>("num").unwrap(), 123);
+    /// assert_eq!(attributes.get_as::<i16>("num").unwrap(), 123);
+    /// ```
+    pub fn get_as<'a, T>(&'a self, key: &str) -> Option<T>
+    where
+        T: TryFrom<&'a TemplateValue<'bp>>,
+    {
+        self.inner.get(key).and_then(|val| val.deref().try_into().ok())
+    }
+
+    /// Get a value as a specific type
+    pub fn value_as<'a, T>(&'a self) -> Option<T>
+    where
+        T: TryFrom<&'a TemplateValue<'bp>>,
+        T: ?Sized,
+    {
+        self.inner
+            .get(&ValueKey::Value)
+            .and_then(|val| val.deref().try_into().ok())
+    }
+
+    /// Get the `Value` out of attributes.
+    /// This is always the first item
+    pub fn value(&self) -> Option<&RemoteCell<TemplateValue<'bp>>> {
+        self.inner.get(&ValueKey::Value)
+    }
+
+    /// Iterate over values of a given type
+    /// ```
+    /// # use anathema_core::attributes::Attributes;
+    /// # use anathema_core::runtime::TemplateValue;
+    ///
+    /// let mut attributes = Attributes::empty();
+    /// let values = TemplateValue::List(
+    ///     [
+    ///         TemplateValue::Int(1),
+    ///         TemplateValue::Bool(true),
+    ///         TemplateValue::Int(2),
+    ///     ]
+    ///     .into(),
+    /// );
+    /// attributes.set("mixed_list", values);
+    ///
+    /// let iter = attributes.iter_as::<u32>("mixed_list");
+    /// assert_eq!(vec![1u32, 2], iter.collect::<Vec<_>>());
+    /// ```
+    pub fn iter_as<'a, T>(&'a self, key: &str) -> impl Iterator<Item = T>
+    where
+        T: TryFrom<&'a TemplateValue<'bp>>,
+    {
+        self.inner
+            .get(key)
+            .and_then(|val| match &**val {
+                TemplateValue::List(list) => {
+                    let list = list.iter().filter_map(|v| T::try_from(v).ok());
+                    Some(list)
+                }
+                _ => None,
+            })
+            .into_iter()
+            .flatten()
+    }
+
+    /// Iterator of keys and values.
+    /// NOTE: This will skip the value
+    pub fn iter(&self) -> impl Iterator<Item = (&str, &TemplateValue<'bp>)> {
+        self.inner.iter().filter_map(|(key, val)| match key {
+            ValueKey::Value => None,
+            &ValueKey::Attribute(key) => Some((key, &**val)),
+        })
+    }
+
+    /// Iterator of keys
+    pub fn iter_keys(&self) -> impl Iterator<Item = &str> {
+        self.inner.iter().filter_map(|(key, _)| match key {
+            ValueKey::Value => None,
+            &ValueKey::Attribute(key) => Some(key),
+        })
+    }
+
+    /// Iterator of values
+    pub fn iter_values(&self) -> impl Iterator<Item = &TemplateValue<'bp>> {
+        self.inner.iter().filter_map(|(key, value)| match key {
+            ValueKey::Value => None,
+            &ValueKey::Attribute(_) => Some(&**value),
+        })
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    fn attributes() -> Attributes<'static> {
+        let mut attributes = Attributes::empty();
+        attributes.set("int", 1);
+        attributes.set("strings", vec!["one", "two"]);
+        attributes.set("numbers", vec![1, 2, 3]);
+        attributes.set(
+            "mixed",
+            TemplateValue::List(vec![true.into(), 1.into(), "string".into()].into()),
+        );
+        attributes
+    }
+
+    #[test]
+    fn replace_attribute() {
+        let mut attributes = attributes();
+        assert_eq!(attributes.get_as::<u32>("int").unwrap(), 1);
+        attributes.set("int", 2);
+        assert_eq!(attributes.get_as::<u32>("int").unwrap(), 2);
+    }
+
+    #[test]
+    fn set_value() {
+        let mut attributes = attributes();
+        attributes.set("other", 2);
+        assert_eq!(attributes.get_as::<u32>("other").unwrap(), 2);
+    }
+
+    #[test]
+    fn remove() {
+        let mut attributes = attributes();
+        attributes.remove("int");
+        assert!(attributes.get("int").is_none());
+    }
+
+    #[test]
+    fn get_attribute() {
+        let attributes = attributes();
+        assert_eq!(attributes.get("int"), Some(&TemplateValue::Int(1)));
+    }
+
+    #[test]
+    fn get_attribute_as() {
+        let attributes = attributes();
+        assert_eq!(attributes.get_as::<u8>("int").unwrap(), 1);
+        assert!(attributes.get_as::<bool>("int").is_none());
+    }
+
+    #[test]
+    fn get_value_as() {
+        let mut attributes = attributes();
+        attributes.set_value("hello world");
+        assert_eq!(attributes.value_as::<&str>().unwrap(), "hello world");
+
+        attributes.set_value("hello world".to_string());
+        assert_eq!(attributes.value_as::<&str>().unwrap(), "hello world");
+    }
+
+    #[test]
+    fn iterate_as() {
+        let attributes = attributes();
+        let numbers = attributes.iter_as::<u32>("numbers").collect::<Vec<_>>();
+        assert_eq!(numbers, vec![1, 2, 3]);
+
+        let strings = attributes.iter_as::<&str>("strings").collect::<Vec<_>>();
+        assert_eq!(strings, vec!["one", "two"]);
+    }
+
+    #[test]
+    fn iter() {
+        let attributes = attributes();
+        let mut iter = attributes.iter();
+        assert_eq!(("int", &TemplateValue::Int(1)), iter.next().unwrap());
+    }
+
+    #[test]
+    fn iter_keys() {
+        let attributes = attributes();
+        let mut iter = attributes.iter_keys();
+        assert_eq!("int", iter.next().unwrap());
+        assert_eq!("strings", iter.next().unwrap());
+        assert_eq!("numbers", iter.next().unwrap());
+    }
+
+    #[test]
+    fn mixed_type_iteration() {
+        let attributes = attributes();
+        let mixed = attributes.get("mixed").unwrap();
+
+        if let TemplateValue::List(list) = mixed {
+            assert_eq!(list[0].as_bool().unwrap(), true);
+            assert_eq!(list[1].as_int().unwrap(), 1);
+            assert_eq!(list[2].as_str().unwrap(), "string");
+        } else {
+            panic!("Expected List");
+        }
+    }
+}
diff --git a/anathema-core/src/frontend/mod.rs b/anathema-core/src/frontend/mod.rs
new file mode 100644
index 00000000..b941b39b
--- /dev/null
+++ b/anathema-core/src/frontend/mod.rs
@@ -0,0 +1 @@
+//! front ends...
diff --git a/anathema-core/src/layout.rs b/anathema-core/src/layout.rs
new file mode 100644
index 00000000..f94eb0c3
--- /dev/null
+++ b/anathema-core/src/layout.rs
@@ -0,0 +1,37 @@
+//! Storing the calculated layout of each element.
+//!
+//! The calculating the layout it self is done elsewhere.
+use anathema_geometry::{Pos, Region, Size};
+use anathema_store::slab::SecondaryMap;
+
+use crate::runtime::elements::ElementId;
+
+/// Store the layout for each element.
+#[derive(Debug)]
+pub struct Layout {
+    regions: SecondaryMap<ElementId, Region>,
+}
+
+impl Layout {
+    pub(crate) fn empty() -> Self {
+        Self {
+            regions: SecondaryMap::empty(),
+        }
+    }
+
+    pub(crate) fn set_size(&mut self, id: ElementId, size: Size) {
+        self.regions[id].resize(size);
+    }
+
+    pub(crate) fn set_pos(&mut self, id: ElementId, pos: Pos) {
+        self.regions[id].set_pos(pos);
+    }
+
+    pub(crate) fn insert(&mut self, id: ElementId) {
+        self.regions.insert(id, Region::ZERO);
+    }
+
+    pub(crate) fn iter(&self) -> impl Iterator<Item = &Region> {
+        self.regions.iter()
+    }
+}
diff --git a/anathema-core/src/lib.rs b/anathema-core/src/lib.rs
new file mode 100644
index 00000000..4c22b96c
--- /dev/null
+++ b/anathema-core/src/lib.rs
@@ -0,0 +1,44 @@
+//! TODO: write docs
+#![deny(missing_docs)]
+#[allow(unused_extern_crates)]
+extern crate self as anathema;
+
+pub mod attributes;
+pub mod frontend;
+pub mod layout;
+pub mod runtime;
+pub mod templates;
+
+/// State aliases and imports.
+// This is because all the value types in core should use the value index.
+pub mod state {
+    use std::cell::RefCell;
+
+    use anathema_state::Change;
+    pub use anathema_state::{List, Map, State};
+    use anathema_store::stack::Stack;
+
+    use crate::runtime::ValueIndex;
+
+    pub(crate) type Changes = Stack<(ValueIndex, Change)>;
+
+    // TODO: This has to be behind the cfg not(multithread)
+    thread_local! {
+        static CHANGES: RefCell<Changes> = RefCell::new(Default::default());
+    }
+
+    /// Value alias
+    pub type Value<T> = anathema_state::Value<ValueIndex, T>;
+    /// Map alias
+    pub type Map<T> = anathema_state::Map<ValueIndex, T>;
+    /// List alias
+    pub type List<T> = anathema_state::List<ValueIndex, T>;
+
+    /// AnonValue alias
+    pub type AnonValue = anathema_state::AnonValue<ValueIndex>;
+}
+
+// Decide what to do here
+// pub mod ui;
+
+pub(crate) mod testing;
diff --git a/anathema-core/src/runtime/changes.rs b/anathema-core/src/runtime/changes.rs
new file mode 100644
index 00000000..09ad6a90
--- /dev/null
+++ b/anathema-core/src/runtime/changes.rs
@@ -0,0 +1,20 @@
+use anathema_state::{Change, SubKey};
+
+use crate::runtime::elements::ElementId;
+use crate::runtime::eval::scope::ScopeId;
+use crate::templates::ExpressionId;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct ValueIndex(ExpressionId, Option<ScopeId>);
+
+impl ValueIndex {
+    pub(crate) fn consume(self) -> (ExpressionId, Option<ScopeId>) {
+        (self.0, self.1)
+    }
+}
+
+impl SubKey for ValueIndex {
+    fn changed_many(change: Change, keys: impl Iterator<Item = Self>) {
+        todo!()
+    }
+}
diff --git a/anathema-core/src/runtime/components/component.rs b/anathema-core/src/runtime/components/component.rs
new file mode 100644
index 00000000..49660900
--- /dev/null
+++ b/anathema-core/src/runtime/components/component.rs
@@ -0,0 +1,31 @@
+/// User defined components
+///
+/// ```
+/// use anathema_core::runtime::Component;
+/// use anathema_state::Value;
+///
+/// struct MyComponent;
+///
+/// impl Component for MyComponent {
+///     type State = Value<String>;
+///     type Message = u32;
+/// }
+/// ```
+pub trait Component: 'static {
+    /// The state associated with the component
+    type State;
+    /// The type of message that can be sent to the component
+    type Message;
+}
+
+pub(crate) trait AnyComponent: 'static {
+}
+
+impl std::fmt::Debug for dyn AnyComponent {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "<component>")
+    }
+}
+
+impl<T: Component> AnyComponent for T {
+}
diff --git a/anathema-core/src/runtime/components/mod.rs b/anathema-core/src/runtime/components/mod.rs
new file mode 100644
index 00000000..49c32d22
--- /dev/null
+++ b/anathema-core/src/runtime/components/mod.rs
@@ -0,0 +1,106 @@
+//! Runtime user defined component registry
+use anathema_state::State;
+use anathema_store::key;
+use anathema_store::slab::{GenSlab, SecondaryMap};
+
+pub use self::component::Component;
+use crate::runtime::components::component::AnyComponent;
+use crate::runtime::ValueIndex;
+use crate::state::Value;
+use crate::templates::ComponentBlueprintId;
+
+key!(ComponentId, Debug, Copy, Clone);
+
+pub(crate) type FnComp = Box<dyn Fn() -> Box<dyn AnyComponent>>;
+pub(crate) type FnState = Box<dyn Fn() -> Box<dyn State<ValueIndex>>>;
+
+mod component;
+
+struct Entry {
+    component: Box<dyn AnyComponent>,
+    state: Value<Box<dyn State<ValueIndex>>>,
+    kind: ComponentKind,
+}
+
+enum ComponentKind {
+    Component,
+    PrototypeInstance,
+}
+
+enum Lookup {
+    Prototype(FnComp, FnState),
+    Component(ComponentId),
+}
+
+/// Runtime component storage
+pub(crate) struct Components {
+    instances: GenSlab<ComponentId, Entry>,
+    blueprints: SecondaryMap<ComponentBlueprintId, Lookup>,
+}
+
+impl Components {
+    pub fn empty() -> Self {
+        Self {
+            instances: GenSlab::empty(),
+            blueprints: SecondaryMap::empty(),
+        }
+    }
+
+    pub(crate) fn insert_component(
+        &mut self,
+        blueprint_id: ComponentBlueprintId,
+        component: impl AnyComponent,
+        state: impl State<ValueIndex>,
+    ) -> ComponentId {
+        let entry = Entry {
+            component: Box::new(component),
+            state: Value::new(Box::new(state)),
+            kind: ComponentKind::Component,
+        };
+        let component_id = self.instances.insert(entry);
+        self.blueprints.insert(blueprint_id, Lookup::Component(component_id));
+        component_id
+    }
+
+    pub(crate) fn insert_prototype(&mut self, blueprint_id: ComponentBlueprintId, component: FnComp, state: FnState) {
+        self.blueprints
+            .insert(blueprint_id, Lookup::Prototype(component, state));
+    }
+
+    pub(crate) fn by_blueprint_id(&mut self, id: ComponentBlueprintId) -> ComponentId {
+        match self.blueprints.get(id) {
+            Some(Lookup::Component(id)) => *id,
+            Some(Lookup::Prototype(comp, state)) => {
+                let entry = Entry {
+                    component: comp(),
+                    state: Value::new(state()),
+                    kind: ComponentKind::PrototypeInstance,
+                };
+                self.instances.insert(entry)
+            }
+            None => todo!(),
+        }
+    }
+
+    pub(crate) fn get_state(&self, component_id: ComponentId) -> Option<&Value<Box<dyn State<ValueIndex>>>> {
+        let inst = self.instances.get(component_id)?;
+        Some(&inst.state)
+    }
+
+    pub(crate) fn get_state_mut(&mut self, component_id: ComponentId) -> Option<&mut Value<Box<dyn State<ValueIndex>>>> {
+        let inst = self.instances.get_mut(component_id)?;
+        Some(&mut inst.state)
+    }
+}
+
+impl Default for Components {
+    fn default() -> Self {
+        Self::empty()
+    }
+}
+
+impl std::fmt::Debug for Components {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "<components>")
+    }
+}
diff --git a/anathema-core/src/runtime/elements/debug.rs b/anathema-core/src/runtime/elements/debug.rs
new file mode 100644
index 00000000..fcf01fd9
--- /dev/null
+++ b/anathema-core/src/runtime/elements/debug.rs
@@ -0,0 +1,44 @@
+use std::fmt::{Debug, Formatter};
+
+use super::Elements;
+use crate::runtime::elements::{Element, ElementId, Node};
+
+impl Debug for Elements<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "")?;
+        self.fmt_node(f, self.root, 0)
+    }
+}
+
+impl Elements<'_> {
+    fn fmt_node(&self, f: &mut Formatter<'_>, id: ElementId, depth: usize) -> std::fmt::Result {
+        let node = match self.elements.get(id) {
+            None => return Ok(()),
+            Some(node) => node,
+        };
+
+        write!(f, "{:?} | ", anathema_store::slab::Key::from(id))?;
+        for _ in 0..depth {
+            write!(f, "    ")?;
+        }
+
+        writeln!(f, "{:?}", node.element)?;
+
+        for id in &node.children {
+            self.fmt_node(f, *id, depth + 1)?;
+        }
+
+        Ok(())
+    }
+}
+
+impl Debug for Element<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Element::For { binding, collection } => write!(f, "<for {binding}>"),
+            Element::Iteration { loop_counter } => write!(f, "<iter {loop_counter}>"),
+            Element::Widget(widget) => write!(f, "{:?}", widget.borrow()),
+            Element::Component(component_id) => write!(f, "<component {component_id:?}>"),
+        }
+    }
+}
diff --git a/anathema-core/src/runtime/elements/iter.rs b/anathema-core/src/runtime/elements/iter.rs
new file mode 100644
index 00000000..6b86998c
--- /dev/null
+++ b/anathema-core/src/runtime/elements/iter.rs
@@ -0,0 +1,31 @@
+use std::cell::RefMut;
+
+use anathema_geometry::Size;
+
+use crate::layout::Layout;
+use crate::runtime::elements::{Element, ElementId, Elements};
+use crate::runtime::widgets::Widget;
+
+pub struct ElementChildren<'a, 'bp> {
+    children: &'a [ElementId],
+    elements: &'a Elements<'bp>,
+    index: usize,
+}
+
+impl<'a, 'bp> Iterator for ElementChildren<'a, 'bp> {
+    type Item = &'a Element<'bp>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.index == self.children.len() {
+            return None;
+        }
+
+        let id = self.children[self.index];
+        self.index += 1;
+
+        let node = &self.elements[id];
+
+        Some(&node.element)
+    }
+}
+
diff --git a/anathema-core/src/runtime/elements/mod.rs b/anathema-core/src/runtime/elements/mod.rs
new file mode 100644
index 00000000..27de6d95
--- /dev/null
+++ b/anathema-core/src/runtime/elements/mod.rs
@@ -0,0 +1,95 @@
+use std::cell::{Ref, RefCell, RefMut};
+use std::ops::Index;
+
+use anathema_store::key;
+use anathema_store::slab::{GenSlab, Key, SecondaryMap};
+
+use crate::runtime::components::ComponentId;
+use crate::runtime::eval::values::Collection;
+use crate::runtime::widgets::{Node as WidgetNode, Widget, Widgets};
+use crate::templates::{Blueprint, ExpressionId};
+
+pub mod iter;
+mod debug;
+
+key!(ElementId, Debug, PartialEq, Copy, Clone, Eq);
+
+impl std::hash::Hash for ElementId {
+    fn hash<H: std::hash::Hasher>(&self, hasher: &mut H) {
+        hasher.write_u32(self.0.into())
+    }
+}
+
+impl nohash_hasher::IsEnabled for ElementId {}
+
+#[derive(Debug)]
+pub struct Node<'bp> {
+    pub(super) parent: Option<ElementId>,
+    pub(super) children: Vec<ElementId>,
+    pub(super) element: Element<'bp>,
+}
+
+pub enum Element<'bp> {
+    For {
+        binding: &'bp str,
+        collection: Collection<'bp>,
+    },
+    Iteration {
+        loop_counter: u32,
+    },
+    Widget(RefCell<Box<dyn Widget>>),
+    Component(ComponentId),
+}
+
+pub struct Elements<'bp> {
+    root: ElementId,
+    pub(crate) elements: GenSlab<ElementId, Node<'bp>>,
+    removed_widgets: Vec<ElementId>,
+}
+
+impl<'bp> Elements<'bp> {
+    pub fn empty() -> Self {
+        let elements = GenSlab::empty();
+        Self {
+            root: elements.next_id(),
+            elements,
+            removed_widgets: vec![],
+        }
+    }
+
+    pub fn insert(&mut self, element: Element<'bp>, parent: Option<ElementId>) -> ElementId {
+        let node = Node {
+            parent,
+            element,
+            children: vec![],
+        };
+
+        let id = self.elements.insert(node);
+
+        if let Some(parent) = parent {
+            self.elements[parent].children.push(id);
+        }
+
+        id
+    }
+
+    pub fn remove(&mut self, id: ElementId) {
+        let Some(node) = self.elements.remove(id) else { return };
+
+        if let Some(parent) = node.parent {
+            self.elements[parent].children.retain(|node| parent.ne(node));
+        }
+
+        if let Element::Widget(_) = node.element {
+            self.removed_widgets.push(id);
+        }
+    }
+}
+
+impl<'bp> Index<ElementId> for Elements<'bp> {
+    type Output = Node<'bp>;
+
+    fn index(&self, index: ElementId) -> &Self::Output {
+        &self.elements[index]
+    }
+}
diff --git a/anathema-core/src/runtime/error.rs b/anathema-core/src/runtime/error.rs
new file mode 100644
index 00000000..f969d58d
--- /dev/null
+++ b/anathema-core/src/runtime/error.rs
@@ -0,0 +1,13 @@
+pub type Result<T> = std::result::Result<T, Error>;
+
+#[derive(Debug)]
+pub enum Error {
+}
+
+impl std::fmt::Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        panic!()
+    }
+}
+
+impl std::error::Error for Error {}
diff --git a/anathema-core/src/runtime/eval/assoc.rs b/anathema-core/src/runtime/eval/assoc.rs
new file mode 100644
index 00000000..71cdda53
--- /dev/null
+++ b/anathema-core/src/runtime/eval/assoc.rs
@@ -0,0 +1,101 @@
+// Associate expressions with elements
+use std::hash::{BuildHasherDefault, Hash};
+
+use nohash_hasher::{IsEnabled, NoHashHasher};
+
+use crate::runtime::elements::ElementId;
+use crate::runtime::eval::values::TemplateValue;
+use crate::templates::ExpressionId;
+
+type HashMap<K, V> = std::collections::HashMap<K, V, BuildHasherDefault<NoHashHasher<K>>>;
+type HashSet<K> = std::collections::HashSet<K, BuildHasherDefault<NoHashHasher<K>>>;
+
+#[derive(Debug)]
+enum Entry<T> {
+    Empty,
+    One(T),
+    Many(HashSet<T>),
+}
+
+impl<T> Entry<T>
+where
+    T: PartialEq + Copy + Eq,
+    T: Hash + IsEnabled,
+{
+    fn add(&mut self, value: T) {
+        match self {
+            Self::Empty => *self = Self::One(value),
+            Self::One(existing) => *self = Self::Many(HashSet::from_iter([*existing, value])),
+            Self::Many(items) => _ = items.insert(value),
+        }
+    }
+
+    fn remove(&mut self, value: T) {
+        match self {
+            Self::One(existing) if *existing == value => *self = Self::Empty,
+            Self::Many(values) => _ = values.remove(&value),
+            _ => return,
+        }
+    }
+
+    fn extend_other(&self, source: &mut Vec<T>)
+    where
+        T: Copy,
+    {
+        match self {
+            Entry::Empty => return,
+            Entry::One(val) => source.push(*val),
+            Entry::Many(items) => source.extend(items),
+        }
+    }
+
+    fn for_each(&self, mut f: impl FnMut(T)) {
+        match self {
+            Self::Empty => (),
+            Self::One(val) => f(*val),
+            Self::Many(values) => values.iter().copied().for_each(f),
+        }
+    }
+}
+
+// Associate expressions with elements
+#[derive(Debug)]
+pub(super) struct Associations {
+    expressions: HashMap<ExpressionId, Entry<ElementId>>,
+    elements: HashMap<ElementId, Entry<ExpressionId>>,
+}
+
+impl Associations {
+    pub fn new() -> Self {
+        Self {
+            expressions: HashMap::default(),
+            elements: HashMap::default(),
+        }
+    }
+
+    fn add_expression(&mut self, expression: ExpressionId) {
+        self.expressions.insert(expression, Entry::Empty);
+    }
+
+    pub(super) fn associate(&mut self, expr: ExpressionId, el: ElementId) -> Option<()> {
+        let expression = self.expressions.get_mut(&expr)?;
+        expression.add(el);
+
+        let element = self.elements.get_mut(&el)?;
+        element.add(expr);
+
+        Some(())
+    }
+
+    fn disassociate(&mut self, el: ElementId) -> Option<()> {
+        let expressions = self.elements.remove(&el)?;
+
+        expressions.for_each(|expr: ExpressionId| {
+            if let Some(expressions) = self.expressions.get_mut(&expr) {
+                expressions.remove(el);
+            }
+        });
+
+        Some(())
+    }
+}
diff --git a/anathema-core/src/runtime/eval/expression.rs b/anathema-core/src/runtime/eval/expression.rs
new file mode 100644
index 00000000..8ae9c479
--- /dev/null
+++ b/anathema-core/src/runtime/eval/expression.rs
@@ -0,0 +1,1133 @@
+use std::collections::HashMap;
+
+use anathema_state::{Color, Hex, Type};
+use anathema_store::key;
+use anathema_store::remotecell::{RemoteCell, RemoteHandle};
+use anathema_store::slab::{GenSlab, Key, SecondaryMap};
+
+use crate::runtime::elements::ElementId;
+use crate::runtime::eval::assoc::Associations;
+use crate::runtime::eval::scope::{Entry, ScopeId, ScopeKey};
+use crate::runtime::eval::values::{Collection, TemplateValue};
+use crate::runtime::eval::EvalCtx;
+use crate::runtime::functions::Function;
+use crate::runtime::ValueIndex;
+use crate::state::AnonValue;
+use crate::templates::expressions::{Equality, LogicalOp, Op};
+use crate::templates::{Expression, ExpressionId, Primitive};
+
+#[derive(Debug)]
+struct ExprEntry<'bp> {
+    exprs: Vec<(Option<ScopeId>, RuntimeExpression<'bp>)>,
+    handle: RemoteHandle<TemplateValue<'bp>>,
+}
+
+impl<'bp> ExprEntry<'bp> {
+    fn new(scope: Option<ScopeId>, expr: RuntimeExpression<'bp>, handle: RemoteHandle<TemplateValue<'bp>>) -> Self {
+        Self {
+            exprs: vec![(scope, expr)],
+            handle,
+        }
+    }
+
+    fn value(&self) -> RemoteCell<TemplateValue<'bp>> {
+        self.handle.value()
+    }
+
+    fn get_scoped(
+        &self,
+        scope_id: Option<ScopeId>,
+    ) -> Option<(&RemoteHandle<TemplateValue<'bp>>, &RuntimeExpression<'bp>)> {
+        let expr = self.exprs.iter().find(|e| e.0 == scope_id).map(|e| &e.1)?;
+        Some((&self.handle, expr))
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq)]
+struct RTKey {
+    expression: ExpressionId,
+    scope: Option<ElementId>,
+}
+
+#[derive(Debug)]
+pub(crate) struct RuntimeExpressions<'bp> {
+    // The element id here is howe we can scope different values with the same expression id,
+    // for instance in a for-loop:
+    // ```
+    // for x in [1, 2, 3]
+    //     text x // <- here x has the same expression id for every iteration
+    //            //    even though the value should be different. So by scoping
+    //            //    the value with the `Iteration`s ElementId it becomes unique
+    //            //    per itration.
+    // ```
+    inner: SecondaryMap<ExpressionId, ExprEntry<'bp>>,
+    associations: Associations,
+}
+
+impl<'bp> RuntimeExpressions<'bp> {
+    pub fn empty() -> Self {
+        Self {
+            inner: SecondaryMap::empty(),
+            associations: Associations::new(),
+        }
+    }
+
+    fn get_entry(&self, index: ValueIndex) -> Option<(&RemoteHandle<TemplateValue<'bp>>, &RuntimeExpression<'bp>)> {
+        let (expression_id, scope_id) = index.consume();
+        let entry = self.inner.get(expression_id)?;
+        entry.get_scoped(scope_id)
+    }
+
+    fn get_value(&self, id: ExpressionId, scope: Option<ScopeId>) -> Option<RemoteCell<TemplateValue<'bp>>> {
+        self.inner.get(id).map(|e| e.handle.value())
+    }
+
+    fn insert(
+        &mut self,
+        id: ExpressionId,
+        // Made from the parent elements `ElementId`.
+        // There is no guarantee that this element is an actual scope,
+        // but it's used to find the nearest scope.
+        scope: Option<ScopeId>,
+        expr: RuntimeExpression<'bp>,
+        value: TemplateValue<'bp>,
+    ) -> RemoteCell<TemplateValue<'bp>> {
+        let (value, handle) = RemoteCell::new(value);
+        let entry = ExprEntry::new(scope, expr, handle);
+        self.inner.insert(id, entry);
+        value
+    }
+
+    // The element will be placed in `dirty_widgets` when the value expression
+    // is re-evaluated
+    fn associate(&mut self, id: ExpressionId, element: ElementId) {
+        self.associations.associate(id, element);
+    }
+}
+
+#[derive(Debug, Clone)]
+enum Kind<T> {
+    Static(T),
+    Dyn(AnonValue, ValueIndex),
+}
+
+impl<T> Drop for Kind<T> {
+    fn drop(&mut self) {
+        if let Self::Dyn(val, key) = self {
+            val.unsubscribe(*key);
+        }
+    }
+}
+
+// It's only runtime expressions that subscribe to changes.
+#[derive(Debug)]
+pub(crate) enum RuntimeExpression<'bp> {
+    Bool(Kind<bool>),
+    Char(Kind<char>),
+    Int(Kind<i64>),
+    Float(Kind<f64>),
+    Hex(Kind<Hex>),
+    Color(AnonValue, ValueIndex),
+    Str(Kind<&'bp str>),
+    DynMap(AnonValue, ValueIndex),
+    DynList(AnonValue, ValueIndex),
+    Composite(AnonValue, ValueIndex),
+    List(Box<[Self]>),
+    Map(HashMap<&'bp str, Self>),
+    Index(Box<Self>, Box<Self>),
+    Range {
+        start: Box<Self>,
+        end: Box<Self>,
+        inclusive: bool,
+    },
+    Attributes(ElementId),
+
+    Not(Box<Self>),
+    Negative(Box<Self>),
+
+    Equality(Box<Self>, Box<Self>, Equality),
+    LogicalOp(Box<Self>, Box<Self>, LogicalOp),
+
+    Op(Box<Self>, Box<Self>, Op),
+    Either(Box<Self>, Box<Self>),
+
+    Call {
+        fun_ptr: &'bp Function,
+        args: Box<[RuntimeExpression<'bp>]>,
+    },
+
+    Null,
+}
+
+impl RuntimeExpression<'_> {
+    fn as_usize(&self) -> Option<usize> {
+        match self {
+            RuntimeExpression::Int(Kind::Static(int)) => Some(*int as usize),
+            RuntimeExpression::Int(Kind::Dyn(int, _)) => int.as_state().as_int().map(|i| i as usize),
+            _ => None,
+        }
+    }
+
+    fn with_str<F, T>(&self, f: F) -> Option<T>
+    where
+        F: Fn(&str) -> T,
+    {
+        match self {
+            &RuntimeExpression::Str(Kind::Static(s)) => Some(f(s)),
+            RuntimeExpression::Str(Kind::Dyn(s, _)) => s.as_state().as_str().map(f),
+            _ => None,
+        }
+    }
+
+    fn from_anon(value: AnonValue, key: impl Into<ValueIndex>) -> Self {
+        let key = key.into();
+        match value.type_info() {
+            Type::Int => Self::Int(Kind::Dyn(value, key)),
+            Type::Float => Self::Float(Kind::Dyn(value, key)),
+            Type::Char => Self::Char(Kind::Dyn(value, key)),
+            Type::String => Self::Str(Kind::Dyn(value, key)),
+            Type::Bool => Self::Bool(Kind::Dyn(value, key)),
+            Type::Hex => Self::Hex(Kind::Dyn(value, key)),
+            Type::Color => Self::Color(value, key),
+            Type::Map => Self::DynMap(value, key),
+            Type::List => Self::DynList(value, key),
+            Type::Composite => Self::Composite(value, key),
+            Type::Unit => Self::Null,
+            Type::Maybe => todo!(),
+        }
+    }
+}
+
+impl<'bp> From<Primitive> for RuntimeExpression<'bp> {
+    fn from(value: Primitive) -> Self {
+        match value {
+            Primitive::Bool(val) => RuntimeExpression::Bool(Kind::Static(val)),
+            Primitive::Char(val) => RuntimeExpression::Char(Kind::Static(val)),
+            Primitive::Int(val) => RuntimeExpression::Int(Kind::Static(val)),
+            Primitive::Float(val) => RuntimeExpression::Float(Kind::Static(val)),
+            Primitive::Hex(val) => RuntimeExpression::Hex(Kind::Static(val)),
+        }
+    }
+}
+
+pub fn re_evalute_expr<'bp>(idx: ValueIndex, ctx: &EvalCtx<'_, 'bp>) {
+    let Some((handle, expr)) = ctx.runtime_expressions.get_entry(idx) else { return };
+    let (id, _) = idx.consume();
+    let value = eval_runtime_expr(expr, id, ctx);
+    handle.set(value);
+}
+
+pub fn eval_collection<'bp>(
+    id: ExpressionId,
+    element: ElementId,
+    scope: Option<ScopeId>,
+    ctx: &mut EvalCtx<'_, 'bp>,
+) -> Collection<'bp> {
+    let inner = eval_by_id(id, element, scope, ctx);
+    Collection::new(inner)
+}
+
+pub fn eval_by_id<'bp>(
+    id: ExpressionId,
+    element: ElementId,
+    // the parent is needed for scope lookup
+    // as the `element` might not be added to the tree yet at this point.
+    scope: Option<ScopeId>,
+    ctx: &mut EvalCtx<'_, 'bp>,
+) -> RemoteCell<TemplateValue<'bp>> {
+    // If the expression already exist: associate the element with the expression
+    // and return a remote cell to the already existing value.
+    //
+    // This is to ensure that there is only one value per expression
+    if let Some(value) = ctx.runtime_expressions.get_value(id, scope) {
+        ctx.runtime_expressions.associate(id, element);
+        return value;
+    }
+
+    let expr = ctx.expressions.get(id);
+    let expr = eval_expr(expr, id, scope, ctx);
+    let value = eval_runtime_expr(&expr, id, ctx);
+    ctx.runtime_expressions.associate(id, element);
+    ctx.runtime_expressions.insert(id, scope, expr, value)
+}
+
+fn eval_expr<'bp>(
+    expr: &'bp Expression,
+    expr_id: ExpressionId,
+    // The parent element, converted to a `ScopeId`
+    scope: Option<ScopeId>,
+    ctx: &mut EvalCtx<'_, 'bp>,
+) -> RuntimeExpression<'bp> {
+    match expr {
+        &Expression::Primitive(primitive) => primitive.into(),
+        &Expression::Variable(var_id) => ctx
+            .variables
+            .load(var_id)
+            .map(|expr_id| {
+                let expr = ctx.expressions.get(expr_id);
+                eval_expr(expr, expr_id, scope, ctx)
+            })
+            .unwrap_or(RuntimeExpression::Null),
+        Expression::Str(s) => RuntimeExpression::Str(Kind::Static(s)),
+        Expression::List(expressions) | Expression::TextSegments(expressions) => {
+            let list = expressions.iter().map(|e| eval_expr(e, expr_id, scope, ctx)).collect();
+            RuntimeExpression::List(list)
+        }
+        Expression::Map(map) => RuntimeExpression::Map(
+            map.iter()
+                .map(|(k, e)| (k.as_str(), eval_expr(e, expr_id, scope, ctx)))
+                .collect(),
+        ),
+        Expression::Not(expression) => RuntimeExpression::Not(Box::new(eval_expr(expression, expr_id, scope, ctx))),
+        Expression::Negative(expression) => {
+            RuntimeExpression::Negative(Box::new(eval_expr(expression, expr_id, scope, ctx)))
+        }
+        Expression::Equality(lhs, rhs, eq) => RuntimeExpression::Equality(
+            eval_expr(lhs, expr_id, scope, ctx).into(),
+            eval_expr(rhs, expr_id, scope, ctx).into(),
+            *eq,
+        ),
+        Expression::LogicalOp(lhs, rhs, op) => RuntimeExpression::LogicalOp(
+            eval_expr(lhs, expr_id, scope, ctx).into(),
+            eval_expr(rhs, expr_id, scope, ctx).into(),
+            *op,
+        ),
+        Expression::Ident(ident) => lookup(ident, expr_id, scope, ctx),
+        Expression::Index(src, index) => RuntimeExpression::Index(
+            eval_expr(src, expr_id, scope, ctx).into(),
+            eval_expr(index, expr_id, scope, ctx).into(),
+        ),
+        Expression::Op(lhs, rhs, op) => RuntimeExpression::Op(
+            eval_expr(lhs, expr_id, scope, ctx).into(),
+            eval_expr(rhs, expr_id, scope, ctx).into(),
+            *op,
+        ),
+        Expression::Either(first, second) => RuntimeExpression::Either(
+            eval_expr(first, expr_id, scope, ctx).into(),
+            eval_expr(second, expr_id, scope, ctx).into(),
+        ),
+        Expression::Range { start, end, inclusive } => RuntimeExpression::Range {
+            start: eval_expr(start, expr_id, scope, ctx).into(),
+            end: eval_expr(end, expr_id, scope, ctx).into(),
+            inclusive: *inclusive,
+        },
+        Expression::Call { fun, args } => {
+            match &**fun {
+                // function(args)
+                Expression::Ident(fun) => match ctx.lookup_function(fun) {
+                    Some(fun_ptr) => {
+                        let args = args
+                            .iter()
+                            .map(|arg| eval_expr(arg, expr_id, scope, ctx))
+                            .collect::<Box<_>>();
+                        RuntimeExpression::Call { fun_ptr, args }
+                    }
+                    None => RuntimeExpression::Null,
+                },
+                // some.value.function(args)
+                Expression::Index(lhs, rhs) => {
+                    let first_arg = eval_expr(lhs, expr_id, scope, ctx);
+                    let Expression::Str(fun) = &**rhs else { return RuntimeExpression::Null };
+                    match ctx.lookup_function(fun) {
+                        Some(fun_ptr) => {
+                            let args = std::iter::once(first_arg)
+                                .chain(args.iter().map(|arg| eval_expr(arg, expr_id, scope, ctx)))
+                                .collect::<Box<_>>();
+                            RuntimeExpression::Call { fun_ptr, args }
+                        }
+                        None => RuntimeExpression::Null,
+                    }
+                }
+                _ => RuntimeExpression::Null,
+            }
+        }
+    }
+}
+
+// Lookup an ident for an Expression
+fn lookup<'bp>(
+    ident: &str,
+    expr_id: ExpressionId,
+    scope: Option<ScopeId>,
+    ctx: &mut EvalCtx<'_, 'bp>,
+) -> RuntimeExpression<'bp> {
+    let key = match ident {
+        "state" => ScopeKey::State,
+        "attributes" => ScopeKey::Attributes,
+        key => ScopeKey::Key(key),
+    };
+
+    let Some(scope) = scope else { return RuntimeExpression::Null };
+
+    match ctx.scope.lookup(key, scope, ctx.elements) {
+        Some(Entry::State(component_id)) => {
+            let Some(state) = ctx.components.get_state(component_id) else { return RuntimeExpression::Null };
+            let value = state.reference();
+            // RuntimeExpression::from_anon(value, expr_id,
+            // (value, expr_id).into()
+            panic!()
+        }
+        Some(Entry::Attributes(component)) => RuntimeExpression::Attributes(component),
+        Some(Entry::Value { value, .. }) => panic!("values needs to be scoped"),
+        None => {
+            let Some(id) = ctx.variables.global_lookup(ident) else { return RuntimeExpression::Null };
+            let expr = ctx.expressions.get(id);
+            eval_expr(expr, expr_id, Some(scope), ctx)
+        }
+    }
+}
+
+#[derive(Debug)]
+enum LazyExpression<'a, 'bp> {
+    Expression(&'a RuntimeExpression<'bp>),
+    Value(TemplateValue<'bp>),
+}
+
+impl<'bp> From<TemplateValue<'bp>> for LazyExpression<'_, 'bp> {
+    fn from(value: TemplateValue<'bp>) -> Self {
+        Self::Value(value)
+    }
+}
+
+macro_rules! or_null {
+    ($opt:expr) => {
+        match $opt {
+            Some(val) => val,
+            None => return TemplateValue::Null.into(),
+        }
+    };
+}
+
+fn lazy_eval<'a, 'bp>(
+    expr: &'a RuntimeExpression<'bp>,
+    expression_id: ExpressionId,
+    ctx: &EvalCtx<'_, 'bp>,
+) -> LazyExpression<'a, 'bp> {
+    match expr {
+        // -----------------------------------------------------------------------------
+        //   - Primitives -
+        // -----------------------------------------------------------------------------
+        &RuntimeExpression::Bool(Kind::Static(val)) => TemplateValue::Bool(val).into(),
+        RuntimeExpression::Bool(Kind::Dyn(value, _)) => {
+            let state = value.as_state();
+            match state.as_bool() {
+                Some(val) => TemplateValue::Bool(val).into(),
+                None => TemplateValue::Null.into(),
+            }
+        }
+        &RuntimeExpression::Char(Kind::Static(val)) => TemplateValue::Char(val).into(),
+        RuntimeExpression::Char(Kind::Dyn(value, _)) => {
+            let state = value.as_state();
+            match state.as_char() {
+                Some(val) => TemplateValue::Char(val).into(),
+                None => TemplateValue::Null.into(),
+            }
+        }
+        &RuntimeExpression::Int(Kind::Static(value)) => TemplateValue::Int(value).into(),
+        RuntimeExpression::Int(Kind::Dyn(value, _)) => {
+            let state = value.as_state();
+            match state.as_int() {
+                Some(value) => TemplateValue::Int(value).into(),
+                None => TemplateValue::Null.into(),
+            }
+        }
+        &RuntimeExpression::Float(Kind::Static(value)) => TemplateValue::Float(value).into(),
+        RuntimeExpression::Float(Kind::Dyn(value, _)) => {
+            let state = value.as_state();
+            match state.as_float() {
+                Some(value) => TemplateValue::Float(value).into(),
+                None => TemplateValue::Null.into(),
+            }
+        }
+        &RuntimeExpression::Hex(Kind::Static(value)) => TemplateValue::Hex(value).into(),
+        RuntimeExpression::Hex(Kind::Dyn(value, _)) => {
+            let state = value.as_state();
+            match state.as_hex() {
+                Some(value) => TemplateValue::Hex(value).into(),
+                None => TemplateValue::Null.into(),
+            }
+        }
+        &RuntimeExpression::Str(Kind::Static(s)) => TemplateValue::Str((s).into()).into(),
+        RuntimeExpression::Str(Kind::Dyn(value, _)) => {
+            let state = value.as_state();
+            match state.as_str() {
+                Some(s) => TemplateValue::Str(s.to_string().into()).into(),
+                None => TemplateValue::Null.into(),
+            }
+        }
+        RuntimeExpression::Color(value, _) => {
+            let state = value.as_state();
+            match state.as_color() {
+                Some(c) => TemplateValue::Color(c).into(),
+                None => TemplateValue::Null.into(),
+            }
+        }
+
+        &RuntimeExpression::Range {
+            ref start,
+            ref end,
+            inclusive,
+        } => {
+            let start = match eval_runtime_expr(start, expression_id, ctx) {
+                TemplateValue::Int(num) => num,
+                _ => return TemplateValue::Null.into(),
+            };
+            let end = match eval_runtime_expr(end, expression_id, ctx) {
+                TemplateValue::Int(num) => num,
+                _ => return TemplateValue::Null.into(),
+            };
+            TemplateValue::Range { start, end, inclusive }.into()
+        }
+
+        // -----------------------------------------------------------------------------
+        //   - Maps, lists and range -
+        // -----------------------------------------------------------------------------
+        RuntimeExpression::DynMap(_, _)
+        | RuntimeExpression::DynList(_, _)
+        | RuntimeExpression::Composite(_, _)
+        | RuntimeExpression::List(_)
+        | RuntimeExpression::Map(_) => LazyExpression::Expression(expr),
+        RuntimeExpression::Attributes(key) => todo!(),
+
+        // -----------------------------------------------------------------------------
+        //   - Index -
+        // -----------------------------------------------------------------------------
+        RuntimeExpression::Index(src, index) => eval_index(src, index, expression_id, ctx),
+
+        // -----------------------------------------------------------------------------
+        //   - Ops -
+        // -----------------------------------------------------------------------------
+        RuntimeExpression::Not(expr) => {
+            let value = eval_runtime_expr(expr, expression_id, ctx);
+            TemplateValue::Bool(!value.truthiness()).into()
+        }
+        RuntimeExpression::Negative(num) => match eval_runtime_expr(num, expression_id, ctx) {
+            TemplateValue::Int(num) => TemplateValue::Int(-num),
+            _ => TemplateValue::Null,
+        }
+        .into(),
+        RuntimeExpression::Equality(lhs, rhs, equality) => {
+            let lhs = eval_runtime_expr(lhs, expression_id, ctx);
+            if lhs == TemplateValue::Null {
+                return TemplateValue::Null.into();
+            }
+
+            let rhs = eval_runtime_expr(rhs, expression_id, ctx);
+            if rhs == TemplateValue::Null {
+                return TemplateValue::Null.into();
+            }
+
+            let boolean = match equality {
+                Equality::Eq => lhs == rhs,
+                Equality::NotEq => lhs != rhs,
+                Equality::Gt => or_null!(lhs.as_int()) > or_null!(rhs.as_int()),
+                Equality::Gte => or_null!(lhs.as_int()) >= or_null!(rhs.as_int()),
+                Equality::Lt => or_null!(lhs.as_int()) < or_null!(rhs.as_int()),
+                Equality::Lte => or_null!(lhs.as_int()) <= or_null!(rhs.as_int()),
+            };
+
+            TemplateValue::Bool(boolean).into()
+        }
+        RuntimeExpression::LogicalOp(lhs, rhs, op) => {
+            let lhs = or_null!(eval_runtime_expr(lhs, expression_id, ctx).as_bool());
+            let rhs = or_null!(eval_runtime_expr(rhs, expression_id, ctx).as_bool());
+
+            let result = match op {
+                LogicalOp::And => lhs && rhs,
+                LogicalOp::Or => lhs || rhs,
+            };
+
+            TemplateValue::Bool(result).into()
+        }
+        &RuntimeExpression::Op(ref lhs, ref rhs, op) => {
+            let lhs = eval_runtime_expr(lhs, expression_id, ctx);
+            let rhs = eval_runtime_expr(rhs, expression_id, ctx);
+
+            match (lhs, rhs) {
+                (TemplateValue::Int(lhs), TemplateValue::Int(rhs)) => int_op(lhs, rhs, op).into(),
+                (TemplateValue::Int(lhs), TemplateValue::Float(rhs)) => float_op(lhs as f64, rhs, op).into(),
+                (TemplateValue::Float(lhs), TemplateValue::Int(rhs)) => float_op(lhs, rhs as f64, op).into(),
+                (TemplateValue::Float(lhs), TemplateValue::Float(rhs)) => float_op(lhs, rhs, op).into(),
+                _ => return TemplateValue::Null.into(),
+            }
+        }
+        RuntimeExpression::Either(first, second) => {
+            let first = eval_runtime_expr(first, expression_id, ctx);
+            if first.truthiness() {
+                return first.into();
+            }
+            eval_runtime_expr(second, expression_id, ctx).into()
+        }
+
+        // -----------------------------------------------------------------------------
+        //   - Functions -
+        // -----------------------------------------------------------------------------
+        RuntimeExpression::Call { fun_ptr, args } => todo!(),
+
+        // -----------------------------------------------------------------------------
+        //   - Null -
+        // -----------------------------------------------------------------------------
+        RuntimeExpression::Null => TemplateValue::Null.into(),
+    }
+}
+
+fn int_op(lhs: i64, rhs: i64, op: Op) -> TemplateValue<'static> {
+    let result = match op {
+        Op::Add => lhs + rhs,
+        Op::Sub => lhs - rhs,
+        Op::Div => lhs / rhs,
+        Op::Mul => lhs * rhs,
+        Op::Mod => lhs % rhs,
+    };
+
+    TemplateValue::Int(result)
+}
+
+fn float_op(lhs: f64, rhs: f64, op: Op) -> TemplateValue<'static> {
+    let result = match op {
+        Op::Add => lhs + rhs,
+        Op::Sub => lhs - rhs,
+        Op::Div => lhs / rhs,
+        Op::Mul => lhs * rhs,
+        Op::Mod => lhs % rhs,
+    };
+
+    TemplateValue::Float(result)
+}
+
+// This is the final value and should be resolved to a template value.
+// That means no indices should be resolved at this step, but rather
+// by the lazy_eval.
+fn eval_runtime_expr<'bp>(
+    expr: &RuntimeExpression<'bp>,
+    expression_id: ExpressionId,
+    ctx: &EvalCtx<'_, 'bp>,
+) -> TemplateValue<'bp> {
+    let expr = match lazy_eval(expr, expression_id, ctx) {
+        LazyExpression::Expression(expr) => expr,
+        LazyExpression::Value(template_value) => return template_value,
+    };
+
+    match expr {
+        // -----------------------------------------------------------------------------
+        //   - Primitives -
+        //
+        //   Primitives are resolved as part of lazy_eval as they are
+        //   always TemplateValues
+        // -----------------------------------------------------------------------------
+        RuntimeExpression::Bool(_)
+        | RuntimeExpression::Char(_)
+        | RuntimeExpression::Int(_)
+        | RuntimeExpression::Float(_)
+        | RuntimeExpression::Hex(_)
+        | RuntimeExpression::Color(_, _)
+        | RuntimeExpression::Range { .. }
+        | RuntimeExpression::Str(_) => unreachable!("this was evaluated in lazy eval"),
+
+        // -----------------------------------------------------------------------------
+        //   - Maps, lists and range -
+        // -----------------------------------------------------------------------------
+        RuntimeExpression::DynMap(_, _) | RuntimeExpression::DynList(_, _) | RuntimeExpression::Composite(_, _) => {
+            unreachable!("this is handled by lazy_eval")
+        }
+
+        RuntimeExpression::List(items) => {
+            TemplateValue::List(items.iter().map(|i| eval_runtime_expr(i, expression_id, ctx)).collect())
+        }
+        RuntimeExpression::Map(hash_map) => todo!(),
+        RuntimeExpression::Attributes(key) => todo!(),
+
+        // -----------------------------------------------------------------------------
+        //   - Index -
+        // -----------------------------------------------------------------------------
+        RuntimeExpression::Index(_, _) => unreachable!("this should be resolved by lazy eval only"),
+
+        // -----------------------------------------------------------------------------
+        //   - Ops -
+        // -----------------------------------------------------------------------------
+        RuntimeExpression::Not(expr) => {
+            panic!();
+        }
+        RuntimeExpression::Negative(runtime_expression) => todo!(),
+        RuntimeExpression::Equality(runtime_expression, runtime_expression1, equality) => todo!(),
+        RuntimeExpression::LogicalOp(runtime_expression, runtime_expression1, logical_op) => todo!(),
+        RuntimeExpression::Op(runtime_expression, runtime_expression1, op) => todo!(),
+        RuntimeExpression::Either(runtime_expression, runtime_expression1) => todo!(),
+
+        // -----------------------------------------------------------------------------
+        //   - Functions -
+        // -----------------------------------------------------------------------------
+        RuntimeExpression::Call { fun_ptr, args } => {
+            // NOTE: Should this perhaps be done in the lazy eval instead?
+            let args = args
+                .iter()
+                .map(|expr| eval_runtime_expr(expr, expression_id, ctx))
+                .collect::<Box<_>>();
+            fun_ptr.invoke(&args)
+        }
+
+        // -----------------------------------------------------------------------------
+        //   - Null -
+        // -----------------------------------------------------------------------------
+        RuntimeExpression::Null => TemplateValue::Null,
+    }
+}
+
+fn eval_index<'a, 'bp>(
+    container: &'a RuntimeExpression<'bp>,
+    index: &'a RuntimeExpression<'bp>,
+    expression_id: ExpressionId,
+    ctx: &EvalCtx<'_, 'bp>,
+) -> LazyExpression<'a, 'bp> {
+    match container {
+        RuntimeExpression::DynMap(map, _) | RuntimeExpression::Composite(map, _) => {
+            let state = map.as_state();
+            let map = or_null!(state.as_any_map());
+            let value = or_null!(index.with_str(|key| map.lookup(key)).flatten());
+            panic!()
+            // value.subscribe(expression_id);
+            // anon_to_template_value(value).into()
+        }
+        RuntimeExpression::DynList(list, _) => {
+            let state = list.as_state();
+            let list = or_null!(state.as_any_list());
+            let index = or_null!(index.as_usize());
+            let value = or_null!(list.lookup(index));
+            panic!()
+            // value.subscribe(expression_id);
+            // anon_to_template_value(value).into()
+        }
+        RuntimeExpression::Attributes(el) => {
+            let attributes = or_null!(ctx.get_attributes(*el));
+            let value = or_null!(index.with_str(|key| attributes.get(key)).flatten());
+            value.clone().into()
+        }
+        RuntimeExpression::List(list) => {
+            let index = or_null!(index.as_usize());
+            let expr = or_null!(list.get(index));
+            lazy_eval(expr, expression_id, ctx)
+        }
+        RuntimeExpression::Map(map) => {
+            let expr = or_null!(index.with_str(|key| map.get(key)).flatten());
+            lazy_eval(expr, expression_id, ctx)
+        }
+        RuntimeExpression::Index(inner_container, inner_index) => {
+            let container = eval_index(inner_container, inner_index, expression_id, ctx);
+            match container {
+                LazyExpression::Expression(container) => eval_index(container, index, expression_id, ctx),
+                LazyExpression::Value(TemplateValue::DynMap(map)) => {
+                    let value = index.with_str(|key| map.as_state().as_any_map().expect("type checked").lookup(key));
+                    let value = or_null!(value.flatten());
+                    panic!();
+                    // value.subscribe(expression_id);
+                    anon_to_template_value(value).into()
+                }
+                LazyExpression::Value(TemplateValue::DynList(list)) => {
+                    let index = or_null!(index.as_usize());
+                    let value = list.as_state().as_any_list().expect("type checked").lookup(index);
+                    let value = or_null!(value);
+                    // value.subscribe(expression_id);
+                    panic!();
+                    anon_to_template_value(value).into()
+                }
+                LazyExpression::Value(_) => TemplateValue::Null.into(),
+            }
+        }
+        RuntimeExpression::Range { start, end, inclusive } => todo!(),
+        RuntimeExpression::Either(first, second) => match eval_index(first, index, expression_id, ctx) {
+            LazyExpression::Expression(runtime_expression) => todo!(),
+            LazyExpression::Value(TemplateValue::Null) => eval_index(second, index, expression_id, ctx),
+            LazyExpression::Value(value) => value.into(),
+        },
+        RuntimeExpression::Null => TemplateValue::Null.into(),
+        _ => unreachable!("should this return null instead?"),
+    }
+}
+
+fn anon_to_template_value<'a>(value: AnonValue) -> TemplateValue<'a> {
+    match value.type_info() {
+        Type::Int => TemplateValue::Int(value.as_state().as_int().expect("type checked")),
+        Type::Float => TemplateValue::Float(value.as_state().as_float().expect("type checked")),
+        Type::Char => TemplateValue::Char(value.as_state().as_char().expect("type checked")),
+        Type::Bool => TemplateValue::Bool(value.as_state().as_bool().expect("type checked")),
+        Type::Hex => TemplateValue::Hex(value.as_state().as_hex().expect("type checked")),
+        Type::Color => TemplateValue::Color(value.as_state().as_color().expect("type checked")),
+        Type::String => TemplateValue::Str(value.as_state().as_str().expect("type checked").to_string().into()),
+        Type::Map => TemplateValue::DynMap(value),
+        Type::List => TemplateValue::DynList(value),
+        Type::Composite => TemplateValue::Composite(value),
+        Type::Unit => TemplateValue::Null,
+        Type::Maybe => {
+            let val = or_null!(value.as_state().as_maybe()).get();
+            anon_to_template_value(or_null!(val))
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use anathema::State;
+
+    use super::*;
+    use crate::attributes::Attributes;
+    use crate::runtime::eval::values;
+    use crate::state::{List, Map, Value};
+    use crate::templates::expressions;
+    use crate::testing::{ExpressionEvaluator, RunBuilder, TestWidget};
+
+    #[derive(Debug, State)]
+    pub struct TestState {
+        list: Value<List<u32>>,
+        list_o_lists: Value<List<List<u32>>>,
+        map: Value<Map<u32>>,
+        map_o_maps: Value<Map<Map<u32>>>,
+        index: Value<usize>,
+    }
+
+    struct TestComp;
+
+    impl crate::runtime::components::Component for TestComp {
+        type Message = ();
+        type State = TestState;
+    }
+
+    fn assert_expr<'a>(expr: impl Into<Expression>, expected: impl Into<TemplateValue<'a>>) {
+        let expected = expected.into();
+        with_val(expr, |value| assert_eq!(value, &expected));
+    }
+
+    fn with_val<F>(expr: impl Into<Expression>, f: F)
+    where
+        F: Fn(&TemplateValue<'_>),
+    {
+        let expr = expr.into();
+        expr_test(|mut test, state| {
+            test.eval(
+                expr,
+                state,
+                |attr| {
+                    attr.set("number", 1);
+                },
+                |val| f(val),
+            );
+        });
+    }
+
+    fn expr_test<F>(f: F)
+    where
+        F: FnOnce(ExpressionEvaluator, TestState),
+    {
+        // -----------------------------------------------------------------------------
+        //   - State -
+        // -----------------------------------------------------------------------------
+        let mut state = TestState {
+            list: List::from_iter(1..5).into(),
+            map: Map::empty().into(),
+            map_o_maps: Map::empty().into(),
+            list_o_lists: List::from_iter((0..5).map(|i| List::from_iter(i..i + 3))).into(),
+            index: 2.into(),
+        };
+
+        state.map.to_mut().insert("a", 1);
+        state.map.to_mut().insert("b", 2);
+
+        let mut a = Map::empty();
+        a.insert("val", 1);
+        state.map_o_maps.to_mut().insert("a", a);
+
+        let mut attributes = Attributes::empty();
+        attributes.set("number", 123);
+
+        f(ExpressionEvaluator::new(), state)
+    }
+
+    #[test]
+    fn state_index_lookup() {
+        use expressions::{ident, index, strlit};
+        assert_expr(index(ident("state"), strlit("index")), values::num(2));
+    }
+
+    #[test]
+    fn global_index_lookup() {
+        use expressions::{ident, index, num, strlit};
+
+        let expr = index(
+            index(
+                //
+                ident("map"),
+                strlit("b"),
+            ),
+            //
+            strlit("c"),
+        );
+
+        expr_test(|mut test, state| {
+            let mut b = HashMap::from([("c".to_string(), num(123))]);
+            let map = Expression::from(HashMap::from([("b".to_string(), b)]));
+
+            test.register_global("map", map);
+            test.eval(*expr, state, |_| {}, |val| assert_eq!(*val, values::num(123)));
+        });
+    }
+
+    #[test]
+    fn static_int() {
+        let expected = values::num(123);
+        assert_expr(expressions::num(123), expected);
+    }
+
+    #[test]
+    fn static_float() {
+        let expected = values::float(1.23);
+        assert_expr(expressions::float(1.23), expected);
+    }
+
+    #[test]
+    fn static_bool() {
+        let expected = values::boolean(true);
+        assert_expr(expressions::boolean(true), expected);
+    }
+
+    #[test]
+    fn static_char() {
+        let expected = values::chr('a');
+        assert_expr(expressions::chr('a'), expected);
+    }
+
+    #[test]
+    fn static_hex() {
+        let expected = values::hex(Hex::from((1, 2, 3)));
+        assert_expr(expressions::hex(Hex::from((1, 2, 3))), expected);
+    }
+
+    #[test]
+    fn static_str() {
+        let expected = values::strlit("hello");
+        assert_expr(expressions::strlit("hello"), expected);
+    }
+
+    #[test]
+    fn negative_int() {
+        let expected = values::num(-1);
+        assert_expr(expressions::negative(expressions::num(1)), expected);
+    }
+
+    #[test]
+    fn equals() {
+        use expressions::num;
+        let expected = values::boolean(true);
+        assert_expr(expressions::eq(num(1), num(1)), expected);
+        let expected = values::boolean(false);
+        assert_expr(expressions::eq(num(2), num(1)), expected);
+    }
+
+    #[test]
+    fn not_equals() {
+        use expressions::num;
+        let expected = values::boolean(true);
+        assert_expr(expressions::neq(num(2), num(1)), expected);
+    }
+
+    #[test]
+    fn gt() {
+        use expressions::num;
+        let expected = values::boolean(true);
+        assert_expr(expressions::gt(num(2), num(1)), expected);
+        let expected = values::boolean(false);
+        assert_expr(expressions::gt(num(2), num(2)), expected);
+    }
+
+    #[test]
+    fn gte() {
+        use expressions::num;
+        let expected = values::boolean(true);
+        assert_expr(expressions::gte(num(2), num(1)), expected);
+        let expected = values::boolean(true);
+        assert_expr(expressions::gte(num(2), num(2)), expected);
+    }
+
+    #[test]
+    fn lt() {
+        use expressions::num;
+        let expected = values::boolean(false);
+        assert_expr(expressions::lt(num(2), num(1)), expected);
+        let expected = values::boolean(false);
+        assert_expr(expressions::lt(num(2), num(2)), expected);
+    }
+
+    #[test]
+    fn lte() {
+        use expressions::num;
+        let expected = values::boolean(false);
+        assert_expr(expressions::lte(num(2), num(1)), expected);
+        let expected = values::boolean(true);
+        assert_expr(expressions::lte(num(2), num(2)), expected);
+    }
+
+    #[test]
+    fn and() {
+        use expressions::boolean;
+        let expected = values::boolean(true);
+        assert_expr(expressions::and(boolean(true), boolean(true)), expected);
+        let expected = values::boolean(false);
+        assert_expr(expressions::and(boolean(true), boolean(false)), expected);
+    }
+
+    #[test]
+    fn or() {
+        use expressions::boolean;
+        let expected = values::boolean(true);
+        assert_expr(expressions::or(boolean(true), boolean(true)), expected);
+        let expected = values::boolean(true);
+        assert_expr(expressions::or(boolean(true), boolean(false)), expected);
+    }
+
+    #[test]
+    fn add() {
+        use expressions::num;
+        let expected = values::num(3);
+        assert_expr(expressions::add(num(1), num(2)), expected);
+    }
+
+    #[test]
+    fn sub() {
+        use expressions::num;
+        let expected = values::num(3);
+        assert_expr(expressions::sub(num(5), num(2)), expected);
+    }
+
+    #[test]
+    fn mul() {
+        use expressions::num;
+        let expected = values::num(10);
+        assert_expr(expressions::mul(num(5), num(2)), expected);
+    }
+
+    #[test]
+    fn div() {
+        use expressions::num;
+        let expected = values::num(10);
+        assert_expr(expressions::div(num(100), num(10)), expected);
+    }
+
+    #[test]
+    fn modulo() {
+        use expressions::num;
+        let expected = values::num(2);
+        assert_expr(expressions::modulo(num(8), num(6)), expected);
+    }
+
+    #[test]
+    fn either() {
+        use expressions::{num, strlit};
+        use values::num as val;
+        assert_expr(expressions::either(num(0), num(2)), val(2));
+        assert_expr(expressions::either(strlit(""), num(2)), val(2));
+    }
+
+    #[test]
+    fn complex_either() {
+        use expressions::{either, ident, index, list, num, strlit};
+        use values::num as val;
+        let expr = index(
+            either(
+                // index
+                index(ident("state"), strlit("missing")),
+                // num
+                list([1, 2]),
+            ),
+            num(0),
+        );
+        assert_expr(expr, val(1));
+    }
+
+    #[test]
+    fn range_exclusive() {
+        use expressions::num;
+        let expected = values::range(0, 5, false);
+        assert_expr(expressions::range(num(0), num(5), false), expected);
+    }
+
+    #[test]
+    fn range_inclusive() {
+        use expressions::num;
+        let expected = values::range(0, 5, true);
+        assert_expr(expressions::range(num(0), num(5), true), expected);
+    }
+
+    #[test]
+    fn not_true() {
+        use expressions::boolean;
+        let expected = values::boolean(false);
+        assert_expr(expressions::not(boolean(true)), expected);
+    }
+
+    #[test]
+    fn static_list() {
+        let expected = values::list([1, 2, 3]);
+        assert_expr(expressions::list([1, 2, 3]), expected);
+    }
+
+    #[test]
+    fn dyn_list() {
+        use expressions::{ident, index, strlit};
+
+        with_val(index(ident("state"), strlit("list")), |value| {
+            assert!(matches!(value, TemplateValue::DynList(_)));
+        });
+    }
+
+    #[test]
+    fn dyn_map() {
+        use expressions::{ident, index, strlit};
+
+        with_val(index(ident("state"), strlit("map")), |value| {
+            assert!(matches!(value, TemplateValue::DynMap(_)));
+        });
+    }
+
+    #[test]
+    fn dyn_nested_map() {
+        use expressions::{ident, index, strlit};
+
+        let expr = index(
+            index(
+                index(
+                    //
+                    ident("state"),
+                    strlit("map_o_maps"),
+                ),
+                strlit("a"),
+            ),
+            strlit("val"),
+        );
+
+        assert_expr(expr, values::num(1));
+    }
+
+    #[test]
+    fn dyn_nested_list() {
+        use expressions::{ident, index, num, strlit};
+
+        let expr = index(
+            index(
+                index(
+                    //
+                    ident("state"),
+                    strlit("list_o_lists"),
+                ),
+                num(1),
+            ),
+            num(2),
+        );
+
+        assert_expr(expr, values::num(3));
+    }
+
+    #[test]
+    fn attributes() {
+        use expressions::{ident, index, num, strlit};
+        let expr = index(ident("attributes"), strlit("number"));
+        assert_expr(expr, values::num(1));
+    }
+}
diff --git a/anathema-core/src/runtime/eval/mod.rs b/anathema-core/src/runtime/eval/mod.rs
new file mode 100644
index 00000000..57c7f8e0
--- /dev/null
+++ b/anathema-core/src/runtime/eval/mod.rs
@@ -0,0 +1,317 @@
+use std::cell::RefCell;
+
+use anathema_store::remotecell::RemoteHandle;
+
+use self::scope::Scope;
+use super::error::Result;
+use crate::attributes::{AttributeRegistry, Attributes, ValueKey};
+use crate::runtime::components::Components;
+use crate::runtime::elements::{Element, ElementId, Elements};
+use crate::runtime::eval::expression::{eval_by_id, eval_collection, RuntimeExpression, RuntimeExpressions};
+use crate::runtime::eval::values::TemplateValue;
+use crate::runtime::functions::{Function, FunctionTable};
+use crate::runtime::widgets::RegisteredWidgets;
+use crate::templates::expressions::{self, Expressions};
+use crate::templates::{Blueprint, Component, ExpressionId, For, Single, Variables};
+
+mod assoc;
+pub(crate) mod expression;
+pub(crate) mod scope;
+pub(crate) mod values;
+
+#[derive(Debug)]
+pub struct EvalCtx<'a, 'bp> {
+    pub(crate) elements: &'a mut Elements<'bp>,
+    pub(crate) attributes: &'a mut AttributeRegistry<'bp>,
+    pub(crate) components: &'a mut Components,
+    pub(crate) variables: &'a Variables,
+    pub(crate) expressions: &'bp Expressions,
+    pub(crate) runtime_expressions: &'a mut RuntimeExpressions<'bp>,
+    pub(crate) functions: &'bp FunctionTable,
+    pub(crate) scope: &'a mut Scope<'bp>,
+    pub(crate) dirty_elements: &'a mut Vec<ElementId>,
+}
+
+impl<'frame, 'bp> EvalCtx<'frame, 'bp> {
+    pub(crate) fn new(
+        elements: &'frame mut Elements<'bp>,
+        attributes: &'frame mut AttributeRegistry<'bp>,
+        components: &'frame mut Components,
+        variables: &'frame Variables,
+        expressions: &'bp Expressions,
+        functions: &'bp FunctionTable,
+        scope: &'frame mut Scope<'bp>,
+        runtime_expressions: &'frame mut RuntimeExpressions<'bp>,
+        dirty_elements: &'frame mut Vec<ElementId>,
+    ) -> Self {
+        Self {
+            elements,
+            attributes,
+            components,
+            variables,
+            expressions,
+            functions,
+            scope,
+            runtime_expressions,
+            dirty_elements,
+        }
+    }
+
+    // fn with_expression<F>(&mut self, id: ExpressionId, mut f: F)
+    // where
+    //     F: FnMut(&mut Self, &RuntimeExpression<'bp>, &mut RemoteHandle<TemplateValue<'bp>>),
+    // {
+    //     let Some((expr, mut handle)) = self.runtime_expressions.remove(id) else { return };
+    //     f(self, &expr, &mut handle);
+    //     self.runtime_expressions.return_entry(id, expr, handle);
+    // }
+
+    fn insert_element(&mut self, element: Element<'bp>, parent: Option<ElementId>) -> ElementId {
+        self.elements.insert(element, parent)
+    }
+
+    fn insert_attributes(&mut self, id: ElementId, attributes: Attributes<'bp>) {
+        self.attributes.insert(id, attributes);
+    }
+
+    fn lookup_function(&self, fun: &str) -> Option<&'bp Function> {
+        self.functions.lookup(fun)
+    }
+
+    fn get_attributes(&self, element: ElementId) -> Option<&Attributes<'bp>> {
+        self.attributes.get(element)
+    }
+
+    fn reserve_element_id(&mut self) -> ElementId {
+        self.elements.elements.next_id()
+    }
+}
+
+trait Evaluator {
+    type Input<'bp>;
+
+    fn eval<'a, 'bp>(
+        &mut self,
+        input: Self::Input<'bp>,
+        ctx: &mut EvalCtx<'a, 'bp>,
+        factory: &RegisteredWidgets,
+        parent: Option<ElementId>,
+    ) -> Result<()>;
+}
+
+pub fn eval<'a, 'bp>(
+    blueprint: &'bp Blueprint,
+    ctx: &mut EvalCtx<'a, 'bp>,
+    factory: &RegisteredWidgets,
+    parent: Option<ElementId>,
+) -> Result<()> {
+    match blueprint {
+        Blueprint::Single(stmt) => SingleEval.eval(stmt, ctx, factory, parent),
+        Blueprint::For(stmt) => ForEval.eval(stmt, ctx, factory, parent),
+        Blueprint::With(with) => todo!(),
+        Blueprint::ControlFlow(control_flow) => todo!(),
+        Blueprint::Component(stmt) => ComponentEval.eval(stmt, ctx, factory, parent),
+        Blueprint::Slot(blueprints) => todo!(),
+    }
+}
+
+struct SingleEval;
+
+impl Evaluator for SingleEval {
+    type Input<'bp> = &'bp Single;
+
+    fn eval<'a, 'bp>(
+        &mut self,
+        input: Self::Input<'bp>,
+        ctx: &mut EvalCtx<'a, 'bp>,
+        factory: &RegisteredWidgets,
+        parent: Option<ElementId>,
+    ) -> Result<()> {
+        let element_id = ctx.reserve_element_id();
+
+        let mut attributes = Attributes::empty();
+
+        for (key, expr) in input.attributes.iter() {
+            let value = eval_by_id(*expr, element_id, parent.map(Into::into), ctx);
+            attributes.set_attribute(ValueKey::Attribute(key), value);
+        }
+
+        if let Some(expr) = &input.value {
+            let val = eval_by_id(*expr, element_id, parent.map(Into::into), ctx);
+            attributes.set_attribute(ValueKey::Value, val);
+        }
+
+        let el = match factory.make(&input.ident, &attributes) {
+            Ok(el) => Element::Widget(RefCell::new(el)),
+            Err(e) => panic!(), //return Err(ctx.error(e)),
+        };
+
+        let parent = ctx.insert_element(el, parent);
+        assert_eq!(parent, element_id);
+
+        ctx.insert_attributes(parent, attributes);
+
+        for child in &input.children {
+            eval(child, ctx, factory, Some(parent));
+        }
+
+        Ok(())
+    }
+}
+
+struct ForEval;
+
+impl Evaluator for ForEval {
+    type Input<'bp> = &'bp For;
+
+    fn eval<'a, 'bp>(
+        &mut self,
+        input: Self::Input<'bp>,
+        ctx: &mut EvalCtx<'a, 'bp>,
+        factory: &RegisteredWidgets,
+        parent: Option<ElementId>,
+    ) -> Result<()> {
+        let element_id = ctx.reserve_element_id();
+
+        let collection = eval_collection(input.data, element_id, parent.map(Into::into), ctx);
+
+        let el = Element::For {
+            binding: &input.binding,
+            collection: collection.clone(),
+        };
+
+        let parent = ctx.insert_element(el, parent);
+        assert_eq!(parent, element_id);
+
+        for (loop_counter, val) in collection.iter().enumerate() {
+            let loop_counter = loop_counter as u32;
+            let iteration = Element::Iteration { loop_counter };
+            let parent = ctx.insert_element(iteration, Some(parent));
+            ctx.scope.scope_iteration(val, loop_counter);
+
+            for child in &input.body {
+                eval(child, ctx, factory, Some(parent));
+            }
+        }
+
+        Ok(())
+    }
+}
+
+struct ComponentEval;
+
+impl Evaluator for ComponentEval {
+    type Input<'bp> = &'bp Component;
+
+    fn eval<'a, 'bp>(
+        &mut self,
+        input: Self::Input<'bp>,
+        ctx: &mut EvalCtx<'a, 'bp>,
+        factory: &RegisteredWidgets,
+        parent: Option<ElementId>,
+    ) -> Result<()> {
+        let element_id = ctx.reserve_element_id();
+        let comp_id = ctx.components.by_blueprint_id(input.id);
+
+        let mut attributes = Attributes::empty();
+
+        for (key, expr) in input.attributes.iter() {
+            let rte = eval_by_id(*expr, element_id, parent.map(Into::into), ctx);
+        }
+
+        let el = Element::Component(comp_id);
+
+        let parent = ctx.insert_element(el, parent);
+        assert_eq!(parent, element_id);
+
+        ctx.insert_attributes(parent, attributes);
+
+        ctx.scope.push_component(element_id, comp_id);
+
+        for child in &input.body {
+            eval(child, ctx, factory, Some(parent));
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use anathema::State;
+    use crate::state::Value;
+
+    use super::*;
+    use crate::attributes::AttributeRegistry;
+    use crate::layout::Layout;
+    use crate::testing::{RunBuilder, TestWidget};
+
+    #[derive(Debug, State)]
+    struct TestState {
+        value: Value<u8>,
+    }
+
+    struct Comp;
+
+    impl crate::runtime::components::Component for Comp {
+        type Message = ();
+        type State = ();
+    }
+
+    #[test]
+    fn eval_single() {
+        let component_tpl = "
+            node state.value
+            node state.value
+            node state.value
+            node state.value
+            node state.value
+            node state.value
+        ";
+
+        let state = TestState { value: 123.into() };
+
+        let mut test = RunBuilder::from_src("@comp");
+        let comp_id = test.add_component("comp", component_tpl, Comp, state);
+
+        let mut inst = test.finish();
+        inst.eval(|ctx| {
+            // * Get hold of the state
+            {
+                let state = ctx.components.get_state_mut(comp_id).unwrap();
+                let state = &mut *state.to_mut();
+                let state = state.as_mut() as &mut dyn std::any::Any;
+                let test_state = state.downcast_mut::<TestState>().unwrap();
+                test_state.value.set(321);
+            }
+
+            // * Drain changes
+            let mut changes = anathema::Changes::empty();
+            anathema::drain_changes(&mut changes);
+
+            eprintln!("{changes:?}");
+
+            while let Some((expr_id, _)) = changes.pop() {
+                expression::re_evalute_expr(expr_id.into(), ctx);
+            }
+
+            // * Change the value
+            // * Look at dirty widgets
+            // * Update the values using the remote handle
+
+            // panic!("{:#?}", ctx.attributes)
+        });
+    }
+
+    #[test]
+    fn forloop() {
+        let tpl = "
+            for x in [1, 2, 3]
+                node x
+        ";
+
+        let mut test = RunBuilder::from_src(tpl);
+        let mut inst = test.finish();
+        inst.eval(|ctx| panic!("{:#?}", ctx.elements));
+    }
+}
diff --git a/anathema-core/src/runtime/eval/scope.rs b/anathema-core/src/runtime/eval/scope.rs
new file mode 100644
index 00000000..a0d454f6
--- /dev/null
+++ b/anathema-core/src/runtime/eval/scope.rs
@@ -0,0 +1,128 @@
+use anathema_state::StateId;
+use anathema_store::key;
+use anathema_store::slab::{Index, Key, SecondaryMap};
+
+use crate::runtime::components::ComponentId;
+use crate::runtime::elements::{ElementId, Elements};
+use crate::runtime::TemplateValue;
+
+// The value key for a scope entry
+#[derive(Debug, Copy, Clone)]
+pub(super) enum ScopeKey<'a> {
+    Attributes,
+    State,
+    Key(&'a str),
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub(crate) struct ScopeId(ElementId);
+
+impl From<ElementId> for ScopeId {
+    fn from(value: ElementId) -> Self {
+        ScopeId(value)
+    }
+}
+
+impl From<ScopeId> for Index {
+    fn from(value: ScopeId) -> Self {
+        value.0.into()
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+pub(crate) enum Entry<'bp> {
+    State(ComponentId),
+
+    Attributes(ElementId),
+    Value { key: &'bp str, value: () },
+}
+
+impl PartialEq<Entry<'_>> for ScopeKey<'_> {
+    fn eq(&self, other: &Entry<'_>) -> bool {
+        match (self, other) {
+            (ScopeKey::Attributes, Entry::Attributes(_)) => true,
+            (ScopeKey::Attributes, _) => false,
+
+            (ScopeKey::State, Entry::State(_)) => true,
+            (ScopeKey::State, _) => false,
+
+            (ScopeKey::Key(lhs), Entry::Value { key: rhs, .. }) => lhs == rhs,
+            (_, _) => false,
+        }
+    }
+}
+
+#[derive(Debug)]
+struct ScopeNode<'bp> {
+    entries: Vec<Entry<'bp>>,
+    boundary: bool,
+}
+
+impl<'bp> ScopeNode<'bp> {
+    fn get(&self, key: ScopeKey<'_>) -> Option<&Entry<'bp>> {
+        self.entries.iter().find(|entry| key.eq(entry))
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct Scope<'bp> {
+    scopes: SecondaryMap<ScopeId, ScopeNode<'bp>>,
+}
+
+impl<'bp> Scope<'bp> {
+    pub fn empty() -> Self {
+        Self {
+            scopes: SecondaryMap::empty(),
+        }
+    }
+
+    /// Find the closest scoped id from a given element id
+    pub fn nearest_scope_id(&self, id: ElementId, elements: &Elements<'_>) -> Option<ScopeId> {
+        let mut id = ScopeId(id);
+        loop {
+            match self.scopes.get(id) {
+                Some(node) => break Some(id),
+                None => id = ScopeId(elements[id.0].parent?),
+            }
+        }
+    }
+
+    pub fn lookup(&self, key: ScopeKey<'_>, mut id: ScopeId, elements: &Elements<'bp>) -> Option<Entry<'bp>> {
+        // Try to get until we reach a scope boundary
+
+        loop {
+            match self.scopes.get(id) {
+                Some(node) => {
+                    // If the scope node contains the key then fetch the value
+                    match node.get(key).copied() {
+                        val @ Some(_) => break val,
+                        None if node.boundary => break None,
+                        None => id = ScopeId(elements[id.0].parent?),
+                    }
+                }
+                None => id = ScopeId(elements[id.0].parent?),
+            }
+        }
+    }
+
+    pub(crate) fn push_component(&mut self, component_element: ElementId, component: ComponentId) {
+        let scope_id = ScopeId(component_element);
+
+        match self.scopes.get_mut(scope_id) {
+            Some(node) => node
+                .entries
+                .extend_from_slice(&[Entry::State(component), Entry::Attributes(component_element)]),
+            None => self.scopes.insert(
+                scope_id,
+                ScopeNode {
+                    entries: vec![Entry::State(component), Entry::Attributes(component_element)],
+                    boundary: true,
+                },
+            ),
+        }
+    }
+
+    pub(crate) fn scope_iteration(&self, value: TemplateValue<'bp>, loop_coutner: u32) {
+        todo!()
+    }
+}
diff --git a/anathema-core/src/runtime/eval/values.rs b/anathema-core/src/runtime/eval/values.rs
new file mode 100644
index 00000000..0979870f
--- /dev/null
+++ b/anathema-core/src/runtime/eval/values.rs
@@ -0,0 +1,387 @@
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::ops::Range;
+
+use anathema_state::{Color, Hex};
+use anathema_store::remotecell::RemoteCell;
+
+use crate::state::AnonValue;
+
+/// A collection used by a for-loop
+#[derive(Debug, Clone)]
+pub struct Collection<'bp> {
+    inner: RemoteCell<TemplateValue<'bp>>,
+}
+
+impl<'bp> Collection<'bp> {
+    pub fn new(inner: RemoteCell<TemplateValue<'bp>>) -> Self {
+        Self { inner }
+    }
+
+    pub(crate) fn iter<'a>(&'a self) -> CollectionIter<'a, 'bp> {
+        CollectionIter {
+            inner: &*self.inner,
+            index: 0,
+        }
+    }
+}
+
+pub(crate) struct CollectionIter<'a, 'bp> {
+    inner: &'a TemplateValue<'bp>,
+    index: u32,
+}
+
+impl<'a, 'bp> Iterator for CollectionIter<'a, 'bp> {
+    type Item = TemplateValue<'bp>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let index = self.index;
+
+        let value = match self.inner {
+            TemplateValue::DynList(list) => todo!(),
+            TemplateValue::List(list) => list.get(index as usize).cloned()?,
+            TemplateValue::Range { start, end, inclusive } => todo!(),
+            _ => return None,
+        };
+
+        self.index += 1;
+
+        Some(value)
+    }
+}
+
+/// This value can never be part of an evaluation chain, only the return value.
+/// It should only ever be the final type that is held by a `Value`, at
+/// the end of an evaluation
+#[derive(Debug, PartialEq, Clone)]
+pub enum TemplateValue<'bp> {
+    /// Int
+    Int(i64),
+    /// Float
+    Float(f64),
+    /// Bool
+    Bool(bool),
+    /// Char
+    Char(char),
+    /// Hex
+    Hex(Hex),
+    /// Color
+    Color(Color),
+    /// Either a borrowed string from the template or an owned string
+    /// from state
+    Str(Cow<'bp, str>),
+    /// Null...
+    Null,
+
+    // NOTE
+    // The map is the final value, and is never used as part
+    // of an index, for that reason the map doesn't hold any values.
+    // TODO: is this true? what about variables binding to maps? e.g: let a = {a: 1}, let b = a.a
+    /// A map of values
+    Map(HashMap<&'bp str, TemplateValue<'bp>>),
+    // Map,
+    // NOTE
+    // The attributes is the final value, and is never used as part
+    // of an index, for that reason the attributes doesn't hold any values.
+    /// Attributes
+    Attributes,
+    /// A collection of values
+    List(Box<[TemplateValue<'bp>]>),
+    /// A collection of values from state
+    DynList(AnonValue),
+    /// A map of values from state
+    DynMap(AnonValue),
+    /// A state
+    Composite(AnonValue),
+    /// A range
+    Range {
+        /// Start of the range
+        start: i64,
+        /// End of the range
+        end: i64,
+        /// Is the range inclusive or exclusive
+        inclusive: bool,
+    },
+}
+
+impl TemplateValue<'_> {
+    pub(crate) fn truthiness(&self) -> bool {
+        match self {
+            Self::Int(0) | Self::Float(0.0) | Self::Bool(false) => false,
+            Self::Str(cow) if cow.is_empty() => false,
+            Self::Null => false,
+            Self::List(list) if list.is_empty() => false,
+            Self::DynList(list) => {
+                let state = list.as_state();
+                let Some(state) = state.as_any_list() else { return false };
+                !state.is_empty()
+            }
+            Self::DynMap(map) => {
+                let state = map.as_state();
+                let Some(state) = state.as_any_map() else { return false };
+                !state.is_empty()
+            }
+            _ => true,
+        }
+    }
+
+    pub(crate) fn as_bool(&self) -> Option<bool> {
+        match self {
+            Self::Bool(b) => Some(*b),
+            _ => None,
+        }
+    }
+
+    pub(crate) fn as_int(&self) -> Option<i64> {
+        match self {
+            Self::Int(i) => Some(*i),
+            _ => None,
+        }
+    }
+
+    pub(crate) fn as_float(&self) -> Option<f64> {
+        match self {
+            Self::Float(f) => Some(*f),
+            _ => None,
+        }
+    }
+
+    pub(crate) fn as_char(&self) -> Option<char> {
+        match self {
+            Self::Char(c) => Some(*c),
+            _ => None,
+        }
+    }
+
+    pub(crate) fn as_hex(&self) -> Option<Hex> {
+        match self {
+            Self::Hex(h) => Some(*h),
+            _ => None,
+        }
+    }
+
+    pub(crate) fn as_color(&self) -> Option<Color> {
+        match self {
+            Self::Color(c) => Some(*c),
+            _ => None,
+        }
+    }
+
+    pub(crate) fn as_str(&self) -> Option<&str> {
+        match self {
+            Self::Str(s) => Some(s.as_ref()),
+            _ => None,
+        }
+    }
+
+    pub(crate) fn as_range(&self) -> Option<Range<i64>> {
+        match self {
+            Self::Range {
+                start,
+                end,
+                inclusive: false,
+            } => Some(*start..*end),
+            Self::Range {
+                start,
+                end,
+                inclusive: true,
+            } => Some(*start..*end + 1),
+            _ => None,
+        }
+    }
+}
+
+// -----------------------------------------------------------------------------
+//   - From -
+// -----------------------------------------------------------------------------
+macro_rules! impl_from {
+    ($t:ty, $variant:ident) => {
+        impl From<$t> for TemplateValue<'static> {
+            fn from(val: $t) -> Self {
+                Self::$variant(val)
+            }
+        }
+    };
+}
+
+impl_from!(bool, Bool);
+impl_from!(char, Char);
+impl_from!(Hex, Hex);
+impl_from!(Color, Color);
+
+macro_rules! from_int {
+    ($int:ty) => {
+        impl From<$int> for TemplateValue<'_> {
+            fn from(value: $int) -> Self {
+                TemplateValue::Int(value as i64)
+            }
+        }
+    };
+}
+
+from_int!(i64);
+from_int!(i32);
+from_int!(i16);
+from_int!(i8);
+from_int!(u64);
+from_int!(u32);
+from_int!(u16);
+from_int!(u8);
+
+impl From<f64> for TemplateValue<'_> {
+    fn from(value: f64) -> Self {
+        TemplateValue::Float(value)
+    }
+}
+
+impl From<f32> for TemplateValue<'_> {
+    fn from(value: f32) -> Self {
+        TemplateValue::Float(value as f64)
+    }
+}
+
+impl From<Range<i64>> for TemplateValue<'static> {
+    fn from(value: Range<i64>) -> Self {
+        Self::Range {
+            start: value.start,
+            end: value.end,
+            inclusive: false,
+        }
+    }
+}
+
+impl<'bp, T> From<Vec<T>> for TemplateValue<'bp>
+where
+    T: Into<TemplateValue<'bp>>,
+{
+    fn from(value: Vec<T>) -> Self {
+        let list = value.into_iter().map(T::into).collect();
+        TemplateValue::List(list)
+    }
+}
+
+impl<'a> From<&'a str> for TemplateValue<'a> {
+    fn from(value: &'a str) -> Self {
+        TemplateValue::Str(Cow::Borrowed(value))
+    }
+}
+
+impl From<String> for TemplateValue<'_> {
+    fn from(value: String) -> Self {
+        TemplateValue::Str(value.into())
+    }
+}
+
+// -----------------------------------------------------------------------------
+//   - Primitives -
+// -----------------------------------------------------------------------------
+pub fn num(value: i64) -> TemplateValue<'static> {
+    TemplateValue::Int(value)
+}
+
+pub fn float(value: f64) -> TemplateValue<'static> {
+    TemplateValue::Float(value)
+}
+
+pub fn chr(value: char) -> TemplateValue<'static> {
+    TemplateValue::Char(value)
+}
+
+pub fn hex(value: Hex) -> TemplateValue<'static> {
+    TemplateValue::Hex(value)
+}
+
+pub fn color(value: Color) -> TemplateValue<'static> {
+    TemplateValue::Color(value)
+}
+
+pub fn boolean(value: bool) -> TemplateValue<'static> {
+    TemplateValue::Bool(value)
+}
+
+pub fn strlit<'a>(value: &'a str) -> TemplateValue<'a> {
+    TemplateValue::Str(value.into())
+}
+
+// -----------------------------------------------------------------------------
+//   - List, map and range -
+// -----------------------------------------------------------------------------
+pub fn range(start: i64, end: i64, inclusive: bool) -> TemplateValue<'static> {
+    TemplateValue::Range { start, end, inclusive }
+}
+
+pub fn list<'a, T: Into<TemplateValue<'a>>>(list: impl IntoIterator<Item = T>) -> TemplateValue<'a> {
+    let list = list.into_iter().map(Into::into).collect();
+    TemplateValue::List(list)
+}
+
+pub fn map<'a, T: Into<TemplateValue<'a>>>(map: HashMap<&'static str, T>) -> TemplateValue<'a> {
+    let mut hm = HashMap::with_capacity(map.len());
+    for (k, v) in map.into_iter() {
+        hm.insert(k, v.into());
+    }
+    TemplateValue::Map(hm)
+}
+
+// -----------------------------------------------------------------------------
+//   - Try From -
+// -----------------------------------------------------------------------------
+macro_rules! try_from_valuekind {
+    ($t:ty, $kind:ident) => {
+        impl TryFrom<&TemplateValue<'_>> for $t {
+            type Error = ();
+
+            fn try_from(value: &TemplateValue<'_>) -> Result<Self, Self::Error> {
+                match value {
+                    TemplateValue::$kind(val) => Ok(*val),
+                    _ => Err(()),
+                }
+            }
+        }
+    };
+}
+
+macro_rules! try_from_valuekind_int {
+    ($t:ty, $kind:ident) => {
+        impl TryFrom<&TemplateValue<'_>> for $t {
+            type Error = ();
+
+            fn try_from(value: &TemplateValue<'_>) -> Result<Self, Self::Error> {
+                match value {
+                    TemplateValue::$kind(val) => Ok(*val as $t),
+                    _ => Err(()),
+                }
+            }
+        }
+    };
+}
+
+try_from_valuekind!(i64, Int);
+try_from_valuekind!(f64, Float);
+try_from_valuekind!(bool, Bool);
+try_from_valuekind!(char, Char);
+try_from_valuekind!(Hex, Hex);
+try_from_valuekind!(Color, Color);
+
+try_from_valuekind_int!(usize, Int);
+try_from_valuekind_int!(isize, Int);
+try_from_valuekind_int!(i32, Int);
+try_from_valuekind_int!(f32, Float);
+try_from_valuekind_int!(i16, Int);
+try_from_valuekind_int!(i8, Int);
+try_from_valuekind_int!(u32, Int);
+try_from_valuekind_int!(u64, Int);
+try_from_valuekind_int!(u16, Int);
+try_from_valuekind_int!(u8, Int);
+
+impl<'a, 'bp> TryFrom<&'a TemplateValue<'bp>> for &'a str {
+    type Error = ();
+
+    fn try_from(value: &'a TemplateValue<'bp>) -> Result<Self, Self::Error> {
+        match value {
+            TemplateValue::Str(Cow::Borrowed(val)) => Ok(val),
+            TemplateValue::Str(Cow::Owned(val)) => Ok(val.as_str()),
+            _ => Err(()),
+        }
+    }
+}
diff --git a/anathema-core/src/runtime/functions.rs b/anathema-core/src/runtime/functions.rs
new file mode 100644
index 00000000..5cacb034
--- /dev/null
+++ b/anathema-core/src/runtime/functions.rs
@@ -0,0 +1,81 @@
+use std::collections::HashMap;
+use std::fmt::{Debug, Display};
+
+use crate::runtime::eval::values::TemplateValue;
+
+#[derive(Debug)]
+pub enum Error {
+    FunctionAlreadyRegistered(String),
+}
+
+impl Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Error::FunctionAlreadyRegistered(name) => write!(f, "function `{name}` is already registered"),
+        }
+    }
+}
+
+impl std::error::Error for Error {}
+
+pub struct Function {
+    inner: Box<dyn for<'bp> Fn(&[TemplateValue<'bp>]) -> TemplateValue<'bp>>,
+}
+
+impl Function {
+    pub(crate) fn invoke<'bp>(&self, args: &[TemplateValue<'bp>]) -> TemplateValue<'bp> {
+        (self.inner)(args)
+    }
+}
+
+impl Debug for Function {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "<fun>")
+    }
+}
+
+impl<T> From<T> for Function
+where
+    T: 'static,
+    T: for<'bp> Fn(&[TemplateValue<'bp>]) -> TemplateValue<'bp>,
+{
+    fn from(value: T) -> Self {
+        Self { inner: Box::new(value) }
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct FunctionTable {
+    inner: HashMap<String, Function>,
+}
+
+impl FunctionTable {
+    pub fn new() -> Self {
+        let mut inner = HashMap::new();
+        // inner.insert("to_upper".into(), Function::from(string::to_upper));
+        // inner.insert("to_lower".into(), Function::from(string::to_lower));
+        // inner.insert("truncate".into(), Function::from(string::truncate));
+        // inner.insert("to_str".into(), Function::from(string::to_str));
+        // inner.insert("pad".into(), Function::from(string::pad));
+        // inner.insert("width".into(), Function::from(string::width));
+        // inner.insert("to_int".into(), Function::from(number::to_int));
+        // inner.insert("to_float".into(), Function::from(number::to_float));
+        // inner.insert("round".into(), Function::from(number::round));
+        // inner.insert("contains".into(), Function::from(list::contains));
+        // inner.insert("len".into(), Function::from(list::len));
+        Self { inner }
+    }
+
+    pub fn insert(&mut self, ident: impl Into<String>, f: impl Into<Function>) -> Result<(), Error> {
+        let key = ident.into();
+        if self.inner.contains_key(&key) {
+            return Err(Error::FunctionAlreadyRegistered(key));
+        }
+        self.inner.insert(key, f.into());
+        Ok(())
+    }
+
+    pub fn lookup(&self, ident: &str) -> Option<&Function> {
+        self.inner.get(ident)
+    }
+}
diff --git a/anathema-core/src/runtime/mod.rs b/anathema-core/src/runtime/mod.rs
new file mode 100644
index 00000000..fafee401
--- /dev/null
+++ b/anathema-core/src/runtime/mod.rs
@@ -0,0 +1,16 @@
+//! TODO: write docs
+use anathema_state::SubKey;
+pub use components::Component;
+pub use widgets::iter::Children;
+pub use widgets::{RegisteredWidgets, Widget};
+
+pub(crate) use self::changes::ValueIndex;
+pub use crate::runtime::eval::values::TemplateValue;
+
+mod changes;
+pub mod components;
+pub(crate) mod elements;
+mod error;
+pub(crate) mod eval;
+pub(crate) mod functions;
+pub(crate) mod widgets;
diff --git a/anathema-core/src/runtime/widgets/iter.rs b/anathema-core/src/runtime/widgets/iter.rs
new file mode 100644
index 00000000..54bdc22b
--- /dev/null
+++ b/anathema-core/src/runtime/widgets/iter.rs
@@ -0,0 +1,56 @@
+use std::cell::RefMut;
+
+use anathema_geometry::Size;
+
+use crate::layout::Layout;
+use crate::runtime::elements::{Element, ElementId, Elements};
+use crate::runtime::widgets::Widget;
+
+/// Children of a given widget.
+pub struct Children<'a, 'bp> {
+    children: &'a [ElementId],
+    elements: &'a Elements<'bp>,
+    index: usize,
+}
+
+impl<'a, 'bp> Iterator for Children<'a, 'bp> {
+    type Item = WidgetRef<'a, 'bp>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.index == self.children.len() {
+            return None;
+        }
+
+        let id = self.children[self.index];
+        self.index += 1;
+
+        let node = &self.elements[id];
+        let Element::Widget(widget) = &node.element else { unreachable!() };
+
+        let children = Children {
+            children: &node.children,
+            elements: self.elements,
+            index: 0,
+        };
+
+        let widget_ref = WidgetRef {
+            id,
+            widget: widget.borrow_mut(),
+            children,
+        };
+
+        Some(widget_ref)
+    }
+}
+
+pub struct WidgetRef<'a, 'bp> {
+    id: ElementId,
+    widget: RefMut<'a, Box<dyn Widget>>,
+    children: Children<'a, 'bp>,
+}
+
+impl<'a, 'bp> WidgetRef<'a, 'bp> {
+    pub fn layout(mut self, layout: &mut Layout) -> Size {
+        self.widget.layout(self.children, layout)
+    }
+}
diff --git a/anathema-core/src/runtime/widgets/mod.rs b/anathema-core/src/runtime/widgets/mod.rs
new file mode 100644
index 00000000..8ebffb6c
--- /dev/null
+++ b/anathema-core/src/runtime/widgets/mod.rs
@@ -0,0 +1,94 @@
+use std::collections::HashMap;
+
+use anathema_geometry::{Pos, Size};
+use anathema_store::slab::{GenSlab, Key, SecondaryMap};
+
+use crate::attributes::Attributes;
+use crate::layout::Layout;
+use crate::runtime::widgets::iter::Children;
+use crate::runtime::elements::ElementId;
+
+type WidgetFactory = Box<dyn Fn(&Attributes<'_>) -> Box<dyn Widget>>;
+
+pub mod iter;
+
+/// All registered widget types
+#[derive(Default)]
+pub struct RegisteredWidgets {
+    registry: HashMap<Box<str>, WidgetFactory>,
+}
+
+impl std::fmt::Debug for RegisteredWidgets {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_set().entries(self.registry.keys()).finish()
+    }
+}
+
+impl RegisteredWidgets {
+    /// Create an empty set of registered widgets.
+    pub fn empty() -> Self {
+        Self {
+            registry: HashMap::new(),
+        }
+    }
+
+    /// Register a widget type as longas it implements default
+    pub fn register_default<T: Widget + Default>(&mut self, ident: impl Into<Box<str>>) {
+        self.registry
+            .insert(ident.into(), Box::new(|_attr| Box::<T>::default()));
+    }
+
+    /// Create a widget from attributes
+    pub fn make(&self, ident: &str, attributes: &Attributes<'_>) -> Result<Box<dyn Widget>, ()> {
+        let Some(factory) = self.registry.get(ident) else { return Err(()) };
+        let element = factory(attributes);
+        Ok(element)
+    }
+}
+
+/// A widget
+pub trait Widget: 'static {
+    /// Layout the widget
+    fn layout(&mut self, children: Children<'_, '_>, layout: &mut Layout) -> Size;
+
+    /// Position the widget
+    fn position(&mut self) -> Pos;
+
+    /// Paint the widget
+    fn paint(&mut self);
+
+    /// A function that described a widget in a debug context.
+    fn describe(&self) -> &str {
+        "<dyn Element>"
+    }
+}
+
+impl std::fmt::Debug for dyn Widget {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.describe())
+    }
+}
+
+pub struct Node {
+    children: Vec<ElementId>,
+}
+
+impl Node {
+    pub fn new(children: Vec<ElementId>) -> Self {
+        Self { children }
+    }
+}
+
+/// The widget tree, constructed from the element tree
+pub struct Widgets {
+    pub widgets: SecondaryMap<ElementId, Node>,
+}
+
+impl Widgets {
+    pub(crate) fn empty() -> Self {
+        Self {
+            widgets: SecondaryMap::empty(),
+        }
+    }
+
+}
diff --git a/anathema-core/src/templates/blueprints.rs b/anathema-core/src/templates/blueprints.rs
new file mode 100644
index 00000000..b5b81c00
--- /dev/null
+++ b/anathema-core/src/templates/blueprints.rs
@@ -0,0 +1,147 @@
+use anathema_store::smallmap::SmallMap;
+use anathema_store::storage::strings::StringId;
+
+use super::ComponentBlueprintId;
+use super::components::AssocEventMapping;
+use super::expressions::ExpressionId;
+
+/// A singular named node in the blueprint tree (e.g., "text", "container")
+#[derive(Debug, Clone, PartialEq)]
+pub struct Single {
+    pub ident: String,
+    /// Associated children
+    pub children: Vec<Blueprint>,
+    /// Key-value pairs of widget attributes mapped to their expressions
+    pub attributes: SmallMap<String, ExpressionId>,
+    /// Expression representing the widget's value content
+    pub value: Option<ExpressionId>,
+}
+
+/// Iterating over a collection with a binding:
+/// ```text
+/// for item in items
+///     text item
+/// ```
+#[derive(Debug, Clone, PartialEq)]
+pub struct For {
+    /// The loop variable name binding
+    pub binding: String,
+    /// Expression representing the collection
+    pub data: ExpressionId,
+    /// The body of the for-loop
+    pub body: Vec<Blueprint>,
+}
+
+/// Scoping a value with a given name:
+/// ```text
+/// with 123 as number
+///     text number
+/// ```
+#[derive(Debug, Clone, PartialEq)]
+pub struct With {
+    /// The variable name binding for the scoped value
+    pub binding: String,
+    /// Data to be scoped
+    pub data: ExpressionId,
+    /// The body of the with-scope
+    pub body: Vec<Blueprint>,
+}
+
+/// Conditional control flow structure for if/else statements:
+/// ```text
+/// if condition
+///     text "true branch"
+/// else
+///     text "false branch"
+/// ```
+#[derive(Clone, Debug, PartialEq)]
+pub struct ControlFlow {
+    /// A vector of else branches, where the first element represents the initial `if` condition
+    /// and subsequent elements represent `else if` or final `else` branches
+    pub elses: Vec<Else>,
+}
+
+/// A single branch in a conditional control flow structure.
+/// Represents an `if`, `else if`, or `else` branch.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Else {
+    /// Optional condition expression; `None` represents a final `else` branch
+    pub cond: Option<ExpressionId>,
+    /// The body of this branch
+    pub body: Vec<Blueprint>,
+}
+
+/// Components have attributes, body content, and event handlers
+#[derive(Debug, Clone, PartialEq)]
+pub struct Component {
+    /// The name of the component as a string
+    pub name: String,
+    /// The interned string identifier for the component name
+    pub name_id: StringId,
+    /// Unique identifier for this component blueprint
+    pub id: ComponentBlueprintId,
+    /// The body of the component
+    pub body: Vec<Blueprint>,
+    /// Component attributes
+    pub attributes: SmallMap<String, ExpressionId>,
+    /// Associated event handler mappings for this component
+    pub assoc_functions: Vec<AssocEventMapping>,
+    /// The parent component in the blueprint
+    pub parent: Option<ComponentBlueprintId>,
+}
+
+/// A blueprint represents what widget should be built from the information
+#[derive(Clone, Debug, PartialEq)]
+pub enum Blueprint {
+    /// A singular widget
+    Single(Single),
+    /// A for-loop
+    For(For),
+    /// A `with` statement
+    With(With),
+    /// If / else
+    ControlFlow(ControlFlow),
+    /// A component
+    Component(Component),
+    /// A slot for a component
+    Slot(Vec<Self>),
+}
+
+macro_rules! single {
+    ($ident:expr) => {
+        $crate::templates::blueprints::Blueprint::Single(Single {
+            ident: $ident.into(),
+            children: vec![],
+            attributes: SmallMap::empty(),
+            value: None,
+        })
+    };
+    (value @ $ident:expr, $value:expr) => {
+        $crate::templates::blueprints::Blueprint::Single(Single {
+            ident: $ident.into(),
+            children: vec![],
+            attributes: SmallMap::empty(),
+            value: Some($value.into()),
+        })
+    };
+    (children @ $ident:expr, $children:expr) => {
+        $crate::templates::blueprints::Blueprint::Single(Single {
+            ident: $ident.into(),
+            children: $children,
+            attributes: SmallMap::empty(),
+            value: None,
+        })
+    };
+}
+
+macro_rules! forloop {
+    ($binding:expr, $data:expr, $body:expr) => {
+        $crate::templates::blueprints::Blueprint::For(For {
+            binding: $binding.into(),
+            data: $data,
+            body: $body,
+        })
+    };
+}
+
+pub(crate) use {forloop, single};
diff --git a/anathema-templates/src/components.rs b/anathema-core/src/templates/components.rs
similarity index 76%
rename from anathema-templates/src/components.rs
rename to anathema-core/src/templates/components.rs
index 0323c44b..f533c1ea 100644
--- a/anathema-templates/src/components.rs
+++ b/anathema-core/src/templates/components.rs
@@ -1,3 +1,4 @@
+use std::cell::RefCell;
 use std::fs::read_to_string;
 use std::ops::Deref;
 use std::path::PathBuf;
@@ -7,74 +8,26 @@ use anathema_store::smallmap::SmallMap;
 use anathema_store::stack::Stack;
 use anathema_store::storage::Storage;
 
-use crate::Lexer;
-use crate::blueprints::Blueprint;
-use crate::error::{Error, ErrorKind, Result};
-use crate::statements::eval::Scope;
-use crate::statements::parser::Parser;
-use crate::statements::{Context, Statements};
-use crate::strings::{StringId, Strings};
-use crate::token::Tokens;
-use crate::variables::Variables;
-
-pub trait ToSourceKind {
-    fn to_path(self) -> SourceKind;
-
-    fn to_template(self) -> SourceKind;
-
-    fn to_source_kind(self) -> SourceKind
-    where
-        Self: Sized,
-    {
-        self.to_path()
-    }
-}
-
-impl ToSourceKind for String {
-    fn to_path(self) -> SourceKind {
-        SourceKind::Path(self.into())
-    }
-
-    fn to_template(self) -> SourceKind {
-        SourceKind::Str(self)
-    }
-}
-
-impl ToSourceKind for &str {
-    fn to_path(self) -> SourceKind {
-        SourceKind::Path(self.into())
-    }
-
-    fn to_template(self) -> SourceKind {
-        SourceKind::Str(self.into())
-    }
-}
-
-impl ToSourceKind for PathBuf {
-    fn to_path(self) -> SourceKind {
-        SourceKind::Path(self)
-    }
-
-    fn to_template(self) -> SourceKind {
-        panic!("PathBuf can not be a template, only a path to one")
-    }
-}
-
+use super::Lexer;
+use super::blueprints::Blueprint;
+use super::error::{Error, ErrorKind, Result};
+use super::expressions::Expressions;
+use super::statements::eval::Scope;
+use super::statements::parser::Parser;
+use super::statements::{Context, Statements};
+use super::strings::{StringId, Strings};
+use super::token::Tokens;
+use super::variables::Variables;
+
+/// Template source.
+/// For hot reloading this has to be a `Path`.
 pub enum SourceKind {
+    /// A path to a file
     Path(PathBuf),
+    /// The template as a string
     Str(String),
 }
 
-impl ToSourceKind for SourceKind {
-    fn to_path(self) -> SourceKind {
-        self
-    }
-
-    fn to_template(self) -> SourceKind {
-        self
-    }
-}
-
 impl From<PathBuf> for SourceKind {
     fn from(value: PathBuf) -> Self {
         Self::Path(value)
@@ -93,7 +46,8 @@ impl From<&str> for SourceKind {
     }
 }
 
-pub enum TemplateSource {
+/// The template source used by the template compiler.
+pub(crate) enum TemplateSource {
     File { path: PathBuf, template: String },
     InMemory(String),
     Static(&'static str),
@@ -136,15 +90,31 @@ impl From<String> for TemplateSource {
     }
 }
 
+/// An associated event mapping maps the internal name to the external name.
+///
+/// The following example maps the "press" event to "submit".
+/// ```text
+/// @button (press -> submit)
+/// ```
+///
+/// When the button publishes the "press" event it can be found as "submit".
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub struct AssocEventMapping {
+    /// The name of the event used by the issuing component
     pub internal: StringId,
+    /// The public event name used by components to catch the event.
     pub external: StringId,
 }
 
+/// This is used by both the templates and the runtime to identify components.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub struct ComponentBlueprintId(u32);
 
+impl ComponentBlueprintId {
+    /// This should never be used for anything other than testing.
+    pub const ZERO: Self = Self(0);
+}
+
 impl SlabIndex for ComponentBlueprintId {
     const MAX: usize = u32::MAX as usize;
 
@@ -186,14 +156,14 @@ impl From<usize> for ComponentBlueprintId {
 }
 
 pub(crate) struct ComponentTemplates {
-    dependencies: Stack<ComponentBlueprintId>,
+    dependencies: RefCell<Stack<ComponentBlueprintId>>,
     components: Storage<ComponentBlueprintId, StringId, TemplateSource>,
 }
 
 impl ComponentTemplates {
     pub(crate) fn new() -> Self {
         Self {
-            dependencies: Stack::empty(),
+            dependencies: RefCell::new(Stack::empty()),
             components: Storage::empty(),
         }
     }
@@ -218,38 +188,37 @@ impl ComponentTemplates {
     }
 
     pub(crate) fn load(
-        &mut self,
+        &self,
         component_id: ComponentBlueprintId,
         variables: &mut Variables,
         slots: SmallMap<StringId, Vec<Blueprint>>,
         strings: &mut Strings,
+        expressions: &mut Expressions,
     ) -> Result<Vec<Blueprint>> {
-        let ticket = self.components.checkout(component_id);
-        let (_, component_src) = &*ticket;
+        let component_src = &self.components[component_id].1;
 
-        if self.dependencies.contains(&component_id) {
+        if self.dependencies.borrow().contains(&component_id) {
             let path = component_src.path();
-            self.components.restore(ticket);
             return Err(Error::new(path, ErrorKind::CircularDependency));
         }
 
-        self.dependencies.push(component_id);
+        self.dependencies.borrow_mut().push(component_id);
 
         // NOTE
         // The ticket has to be restored to the component store,
         // this is why the error is returned rather than using `?` on `self.compile`.
-        let ret = self.compile(component_src, variables, slots, strings, component_id);
-        self.components.restore(ticket);
-        self.dependencies.pop();
+        let ret = self.compile(component_src, variables, slots, strings, expressions, component_id);
+        self.dependencies.borrow_mut().pop();
         ret
     }
 
     fn compile(
-        &mut self,
+        &self,
         template: &TemplateSource,
         variables: &mut Variables,
         slots: SmallMap<StringId, Vec<Blueprint>>,
         strings: &mut Strings,
+        expressions: &mut Expressions,
         parent: ComponentBlueprintId,
     ) -> Result<Vec<Blueprint>> {
         let tokens = Lexer::new(template, strings).collect::<Result<Vec<_>>>()?;
@@ -258,7 +227,7 @@ impl ComponentTemplates {
 
         let statements = parser.collect::<Result<Statements>>()?;
 
-        let mut context = Context::new(template, variables, self, strings, slots, Some(parent));
+        let mut context = Context::new(template, variables, self, strings, expressions, slots, Some(parent));
 
         Scope::new(statements).eval(&mut context)
     }
diff --git a/anathema-templates/src/document.rs b/anathema-core/src/templates/document.rs
similarity index 67%
rename from anathema-templates/src/document.rs
rename to anathema-core/src/templates/document.rs
index d5ff8698..0798d055 100644
--- a/anathema-templates/src/document.rs
+++ b/anathema-core/src/templates/document.rs
@@ -3,41 +3,48 @@ use std::path::PathBuf;
 
 use anathema_store::smallmap::SmallMap;
 
-use crate::blueprints::Blueprint;
-use crate::components::{ComponentTemplates, SourceKind, TemplateSource};
-use crate::error::{Error, ErrorKind, Result};
-use crate::statements::eval::Scope;
-use crate::statements::parser::Parser;
-use crate::statements::{Context, Statements};
-use crate::strings::Strings;
-use crate::token::Tokens;
-use crate::{ComponentBlueprintId, Lexer, Variables};
+use super::blueprints::Blueprint;
+use super::components::{ComponentTemplates, SourceKind, TemplateSource};
+use super::error::{Error, ErrorKind, Result};
+use super::expressions::Expressions;
+use super::statements::eval::Scope;
+use super::statements::parser::Parser;
+use super::statements::{Context, Statements};
+use super::strings::Strings;
+use super::token::Tokens;
+use super::{ComponentBlueprintId, Lexer, Variables};
 
 /// A document containing templates and components
 /// ```
-/// # use anathema_templates::Document;
+/// # use anathema_core::templates::Document;
 /// let mut doc = Document::new("text 'I am a widget'");
 /// ```
 pub struct Document {
     template: TemplateSource,
-    pub strings: Strings,
+    pub(crate) strings: Strings,
+    pub(crate) expressions: Expressions,
     components: ComponentTemplates,
-    pub hot_reload: bool,
 }
 
 impl Document {
+    /// Create a new instance of a document.
     pub fn new(template: impl Into<TemplateSource>) -> Self {
         let template = template.into();
         Self {
             template,
             strings: Strings::new(),
+            expressions: Expressions::empty(),
             components: ComponentTemplates::new(),
-            hot_reload: true,
         }
     }
 
     #[allow(private_bounds)]
-    pub fn add_component(&mut self, name: impl Into<String>, src: SourceKind) -> Result<ComponentBlueprintId> {
+    pub(crate) fn add_component(
+        &mut self,
+        name: impl Into<String>,
+        src: impl Into<SourceKind>,
+    ) -> Result<ComponentBlueprintId> {
+        let src = src.into();
         let name = name.into();
         let name = self.strings.push(name);
 
@@ -56,7 +63,11 @@ impl Document {
         Ok(id)
     }
 
+    /// Compile the document to a [`Blueprint`].
     pub fn compile(&mut self, globals: &mut Variables) -> Result<Blueprint> {
+        globals.reset_globals();
+        self.expressions.clear();
+
         let tokens = Lexer::new(&self.template, &mut self.strings).collect::<Result<Vec<_>>>()?;
         let tokens = Tokens::new(tokens, self.template.len());
         let parser = Parser::new(tokens, &mut self.strings, &self.template, &mut self.components);
@@ -67,6 +78,7 @@ impl Document {
             template: &self.template,
             variables: globals,
             strings: &mut self.strings,
+            expressions: &mut self.expressions,
             components: &mut self.components,
             slots: SmallMap::empty(),
             current_component_parent: None,
@@ -79,14 +91,17 @@ impl Document {
         }
     }
 
+    /// Get an iterator of all the file paths for all the templates
     pub fn template_paths(&self) -> impl Iterator<Item = &PathBuf> {
         self.components.file_paths()
     }
 
+    /// Reload all the templates (that have a file path associated with them)
     pub fn reload_templates(&mut self) -> Result<()> {
         self.components.reload()
     }
 
+    /// Get the file path for a component if it has one
     pub fn get_component_source(&self, component_id: ComponentBlueprintId) -> Option<PathBuf> {
         self.components.path(component_id)
     }
diff --git a/anathema-templates/src/error/mod.rs b/anathema-core/src/templates/error/mod.rs
similarity index 100%
rename from anathema-templates/src/error/mod.rs
rename to anathema-core/src/templates/error/mod.rs
diff --git a/anathema-templates/src/error/parse.rs b/anathema-core/src/templates/error/parse.rs
similarity index 97%
rename from anathema-templates/src/error/parse.rs
rename to anathema-core/src/templates/error/parse.rs
index 27292578..acf4a7cd 100644
--- a/anathema-templates/src/error/parse.rs
+++ b/anathema-core/src/templates/error/parse.rs
@@ -4,8 +4,8 @@ use std::ops::Range;
 use std::path::PathBuf;
 
 use super::Error;
-use crate::components::TemplateSource;
-use crate::token::Operator;
+use crate::templates::components::TemplateSource;
+use crate::templates::token::Operator;
 
 // Line number and column starts at one, not zero,
 // because actual humans might read this
diff --git a/anathema-templates/src/expressions/eval.rs b/anathema-core/src/templates/expressions/eval.rs
similarity index 93%
rename from anathema-templates/src/expressions/eval.rs
rename to anathema-core/src/templates/expressions/eval.rs
index 88a63601..cdce5e25 100644
--- a/anathema-templates/src/expressions/eval.rs
+++ b/anathema-core/src/templates/expressions/eval.rs
@@ -2,10 +2,10 @@ use std::collections::HashMap;
 
 use super::parser::Expr;
 use super::{Expression, LogicalOp, Op};
-use crate::error::{ParseErrorKind, Result};
-use crate::expressions::Equality;
-use crate::strings::Strings;
-use crate::token::Operator;
+use crate::templates::error::{ParseErrorKind, Result};
+use crate::templates::expressions::Equality;
+use crate::templates::strings::Strings;
+use crate::templates::token::Operator;
 
 pub(super) fn eval(expr: Expr, strings: &Strings) -> Result<Expression, ParseErrorKind> {
     let output = match expr {
@@ -37,9 +37,13 @@ pub(super) fn eval(expr: Expr, strings: &Strings) -> Result<Expression, ParseErr
                 let rhs = strings.get_unchecked(string_id);
                 Expression::Index(lhs, Expression::Str(rhs).into())
             }
-            Operator::DotDot => {
-                let (lhs, rhs) = (eval(*lhs, strings)?.into(), eval(*rhs, strings)?.into());
-                Expression::Range(lhs, rhs)
+            op @ (Operator::DotDot | Operator::DotDotDot) => {
+                let (start, end) = (eval(*lhs, strings)?.into(), eval(*rhs, strings)?.into());
+                Expression::Range {
+                    start,
+                    end,
+                    inclusive: op == Operator::DotDotDot,
+                }
             }
             Operator::Mul | Operator::Plus | Operator::Minus | Operator::Div | Operator::Mod => {
                 let (lhs, rhs) = (eval(*lhs, strings)?.into(), eval(*rhs, strings)?.into());
@@ -137,10 +141,10 @@ pub(super) fn eval(expr: Expr, strings: &Strings) -> Result<Expression, ParseErr
 mod test {
 
     use super::*;
-    use crate::expressions::parser::parse_expr;
-    use crate::lexer::Lexer;
-    use crate::strings::Strings;
-    use crate::token::Tokens;
+    use crate::templates::expressions::parser::parse_expr;
+    use crate::templates::lexer::Lexer;
+    use crate::templates::strings::Strings;
+    use crate::templates::token::Tokens;
 
     fn eval_src(input: &'static str) -> Expression {
         let input = input.into();
diff --git a/anathema-templates/src/expressions/mod.rs b/anathema-core/src/templates/expressions/mod.rs
similarity index 66%
rename from anathema-templates/src/expressions/mod.rs
rename to anathema-core/src/templates/expressions/mod.rs
index 83de162e..7e440e4d 100644
--- a/anathema-templates/src/expressions/mod.rs
+++ b/anathema-core/src/templates/expressions/mod.rs
@@ -1,88 +1,190 @@
 use std::collections::HashMap;
 use std::fmt::Display;
 
-use anathema_state::Hex;
+use anathema_state::{Color, Hex};
+use anathema_store::key;
+use anathema_store::slab::Index;
 
-use crate::primitives::Primitive;
-use crate::variables::VarId;
+use super::primitives::Primitive;
+use super::variables::{ScopeId, VarId};
 
 pub(crate) mod eval;
 pub(crate) mod parser;
 
+/// A key for an [`Expression`]
+key!(ExpressionId, Debug, Clone, Copy, PartialEq, Eq);
+
+impl std::hash::Hash for ExpressionId {
+    fn hash<H: std::hash::Hasher>(&self, hasher: &mut H) {
+        hasher.write_u32(self.0.into())
+    }
+}
+
+impl nohash_hasher::IsEnabled for ExpressionId {}
+
+/// A collection of expressions paired with their scope boundaries.
+#[derive(Debug)]
+pub struct Expressions {
+    // Each expression is stored with its associated scope boundary
+    inner: Vec<(Expression, ScopeId)>,
+}
+
+impl Expressions {
+    /// Create an empty set of expressions
+    pub fn empty() -> Self {
+        Self { inner: vec![] }
+    }
+
+    /// Get a reference to an expression
+    ///
+    /// # Panics
+    ///
+    /// Panics if the expression id is greater than the length of expressions.
+    /// This should never happen as the ids are assigned to blueprints using them.
+    ///
+    /// Only time this could happen is if the expression id is created outside of the tempalte
+    /// generation.
+    pub fn get(&self, id: ExpressionId) -> &Expression {
+        &self.inner[id.0.index()].0
+    }
+
+    /// Insert an expression in the root scope
+    pub fn insert_at_root(&mut self, expression: impl Into<Expression>) -> ExpressionId {
+        self.insert(expression.into(), ScopeId::root().clone())
+    }
+
+    /// Insert an expression and return the id to the newly inserted expression
+    pub fn insert(&mut self, expression: Expression, boundary: ScopeId) -> ExpressionId {
+        let id = ExpressionId(self.inner.len().into());
+        match self
+            .inner
+            .iter()
+            .position(|(e, scope)| expression.eq(e) && boundary.eq(scope))
+        {
+            Some(id) => ExpressionId(id.into()),
+            None => {
+                self.inner.push((expression, boundary));
+                id
+            }
+        }
+    }
+
+    pub(crate) fn clear(&mut self) {
+        self.inner.clear()
+    }
+
+    #[cfg(test)]
+    pub(crate) fn iter(&self) -> std::slice::Iter<'_, (Expression, ScopeId)> {
+        self.inner.iter()
+    }
+}
+
+impl std::ops::Index<ExpressionId> for Expressions {
+    type Output = Expression;
+
+    fn index(&self, index: ExpressionId) -> &Self::Output {
+        &self.inner[index.0.index()].0
+    }
+}
+
+/// Binary arithmetic operators for expressions
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub enum Op {
+    /// Add
     Add,
+    /// Sub
     Sub,
+    /// Div
     Div,
+    /// Mul
     Mul,
+    /// Mod
     Mod,
 }
 
+/// Equality check
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub enum Equality {
+    /// Eq
     Eq,
+    /// NotEq
     NotEq,
+    /// Gt
     Gt,
+    /// Gte
     Gte,
+    /// Lt
     Lt,
+    /// Lte
     Lte,
 }
 
+/// Logical operators
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub enum LogicalOp {
+    /// And
     And,
+    /// Or
     Or,
 }
 
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub enum BoolOp {
-    Eq,
-    NotEq,
-    And,
-    Or,
-    Gt,
-    Gte,
-    Lt,
-    Lte,
-}
-
+/// An expression is a value for a blueprint
 #[derive(Debug, Clone, PartialEq)]
 pub enum Expression {
-    // Value types
+    /// Primitives (int, bool, char, etc.)
     Primitive(Primitive),
+    /// String
     Str(String),
+    /// List
     List(Vec<Self>),
+    /// Map
     Map(HashMap<String, Self>),
 
-    // Lookup a variable in the var table
+    /// Variable
     Variable(VarId),
 
-    // This is specifically for the "value" of a node.
+    /// This is specifically for the "value" of a node.
     TextSegments(Vec<Self>),
 
-    // Unary
+    /// Unary expression
     Not(Box<Self>),
+
+    /// Negative numbers
     Negative(Box<Self>),
 
-    // Conditionals
+    /// Conditionals
     Equality(Box<Self>, Box<Self>, Equality),
+    /// Logical operations
     LogicalOp(Box<Self>, Box<Self>, LogicalOp),
 
-    // Lookup
+    /// Lookup
     Ident(String),
+    /// Index (a.b / a["b"])
     Index(Box<Self>, Box<Self>),
 
-    // Operations
+    /// Maths operations
     Op(Box<Self>, Box<Self>, Op),
 
-    // Either
+    /// Either
     Either(Box<Self>, Box<Self>),
 
-    // Range
-    Range(Box<Self>, Box<Self>),
-
-    // Function call
-    Call { fun: Box<Self>, args: Vec<Self> },
+    /// Range
+    Range {
+        /// Start value of the range
+        start: Box<Self>,
+        /// End value of the range
+        end: Box<Self>,
+        /// If the range exclusive (..) or inclusive (...)
+        inclusive: bool,
+    },
+
+    /// Function call
+    Call {
+        /// Function
+        fun: Box<Self>,
+        /// Arguments
+        args: Vec<Self>,
+    },
 }
 
 impl From<Box<Expression>> for Expression {
@@ -151,7 +253,16 @@ impl Display for Expression {
                 write!(f, "{lhs} {op} {rhs}")
             }
             Self::Either(lhs, rhs) => write!(f, "{lhs} ? {rhs}"),
-            Self::Range(lhs, rhs) => write!(f, "{lhs} .. {rhs}"),
+            Self::Range {
+                start,
+                end,
+                inclusive: false,
+            } => write!(f, "{start} .. {end}"),
+            Self::Range {
+                start,
+                end,
+                inclusive: true,
+            } => write!(f, "{start} ... {end}"),
             Self::List(list) => {
                 write!(
                     f,
@@ -223,8 +334,8 @@ pub fn either(lhs: Box<Expression>, rhs: Box<Expression>) -> Box<Expression> {
     Expression::Either(lhs, rhs).into()
 }
 
-pub fn range(lhs: Box<Expression>, rhs: Box<Expression>) -> Box<Expression> {
-    Expression::Range(lhs, rhs).into()
+pub fn range(start: Box<Expression>, end: Box<Expression>, inclusive: bool) -> Box<Expression> {
+    Expression::Range { start, end, inclusive }.into()
 }
 
 // -----------------------------------------------------------------------------
@@ -266,6 +377,10 @@ pub fn less_than_equal(lhs: Box<Expression>, rhs: Box<Expression>) -> Box<Expres
     Expression::Equality(lhs, rhs, Equality::Lte).into()
 }
 
+pub fn negative(num: Box<Expression>) -> Box<Expression> {
+    Expression::Negative(num).into()
+}
+
 // -----------------------------------------------------------------------------
 //   - Values -
 // -----------------------------------------------------------------------------
@@ -331,6 +446,26 @@ pub fn eq(lhs: Box<Expression>, rhs: Box<Expression>) -> Box<Expression> {
     Expression::Equality(lhs, rhs, Equality::Eq).into()
 }
 
+pub fn neq(lhs: Box<Expression>, rhs: Box<Expression>) -> Box<Expression> {
+    Expression::Equality(lhs, rhs, Equality::NotEq).into()
+}
+
+pub fn gt(lhs: Box<Expression>, rhs: Box<Expression>) -> Box<Expression> {
+    Expression::Equality(lhs, rhs, Equality::Gt).into()
+}
+
+pub fn gte(lhs: Box<Expression>, rhs: Box<Expression>) -> Box<Expression> {
+    Expression::Equality(lhs, rhs, Equality::Gte).into()
+}
+
+pub fn lt(lhs: Box<Expression>, rhs: Box<Expression>) -> Box<Expression> {
+    Expression::Equality(lhs, rhs, Equality::Lt).into()
+}
+
+pub fn lte(lhs: Box<Expression>, rhs: Box<Expression>) -> Box<Expression> {
+    Expression::Equality(lhs, rhs, Equality::Lte).into()
+}
+
 pub fn and(lhs: Box<Expression>, rhs: Box<Expression>) -> Box<Expression> {
     Expression::LogicalOp(lhs, rhs, LogicalOp::And).into()
 }
diff --git a/anathema-templates/src/expressions/parser.rs b/anathema-core/src/templates/expressions/parser.rs
similarity index 94%
rename from anathema-templates/src/expressions/parser.rs
rename to anathema-core/src/templates/expressions/parser.rs
index 238cab5d..eef6df6b 100644
--- a/anathema-templates/src/expressions/parser.rs
+++ b/anathema-core/src/templates/expressions/parser.rs
@@ -2,10 +2,10 @@ use std::fmt::Display;
 
 use super::Expression;
 use super::eval::eval;
-use crate::error::{ParseErrorKind, Result};
-use crate::primitives::Primitive;
-use crate::strings::{StringId, Strings};
-use crate::token::{Kind, Operator, Tokens, Value};
+use crate::templates::error::{ParseErrorKind, Result};
+use crate::templates::primitives::Primitive;
+use crate::templates::strings::{StringId, Strings};
+use crate::templates::token::{Kind, Operator, Tokens, Value};
 
 pub(crate) mod prec {
     pub const INITIAL: u8 = 0;
@@ -31,7 +31,7 @@ fn get_precedence(op: Operator) -> u8 {
         }
         Operator::EqualEqual | Operator::NotEqual => prec::EQUALITY,
         Operator::Or | Operator::And | Operator::Either => prec::CONDITIONAL,
-        Operator::DotDot => prec::RANGE,
+        Operator::DotDot | Operator::DotDotDot => prec::RANGE,
 
         _ => prec::INITIAL,
     }
@@ -266,9 +266,9 @@ fn parse_map(tokens: &mut Tokens) -> Result<Expr, ParseErrorKind> {
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::error::Result;
-    use crate::lexer::Lexer;
-    use crate::strings::Strings;
+    use crate::templates::error::Result;
+    use crate::templates::lexer::Lexer;
+    use crate::templates::strings::Strings;
 
     fn parse_src(input: &'static str) -> Expr {
         let input = input.into();
@@ -388,12 +388,19 @@ mod test {
     }
 
     #[test]
-    fn range() {
+    fn range_exclusive() {
         let input = "a..b";
         let actual = parse(input);
         assert_eq!(actual, "(.. <sid 1> <sid 2>)");
     }
 
+    #[test]
+    fn range_inclusive() {
+        let input = "a...b";
+        let actual = parse(input);
+        assert_eq!(actual, "(... <sid 1> <sid 2>)");
+    }
+
     #[test]
     fn range_2() {
         let input = "1 + 0..1 + 5";
diff --git a/anathema-templates/src/lexer.rs b/anathema-core/src/templates/lexer.rs
similarity index 94%
rename from anathema-templates/src/lexer.rs
rename to anathema-core/src/templates/lexer.rs
index 2544fbf5..8a2251a6 100644
--- a/anathema-templates/src/lexer.rs
+++ b/anathema-core/src/templates/lexer.rs
@@ -1,10 +1,10 @@
 use std::iter::Peekable;
 use std::str::CharIndices;
 
-use crate::components::TemplateSource;
-use crate::error::{ParseError, ParseErrorKind, Result};
-use crate::strings::Strings;
-use crate::token::{Kind, Operator, Token, Value};
+use super::components::TemplateSource;
+use super::error::{ParseError, ParseErrorKind, Result};
+use super::strings::Strings;
+use super::token::{Kind, Operator, Token, Value};
 
 // TODO:
 // const EOF: char = '\0';
@@ -47,6 +47,7 @@ impl<'src, 'consts> Iterator for Lexer<'src, 'consts> {
     }
 }
 
+/// Lex AML source to tokens
 pub struct Lexer<'src, 'strings> {
     pub(super) src: &'src TemplateSource,
     pub(crate) strings: &'strings mut Strings,
@@ -90,7 +91,14 @@ impl<'src, 'strings> Lexer<'src, 'strings> {
             }
             ('.', Some('.')) => {
                 let _ = self.chars.next();
-                Ok(Kind::Op(Operator::DotDot).to_token(index))
+                let op = match self.chars.peek() {
+                    Some(&(_, '.')) => {
+                        self.chars.next();
+                        Operator::DotDotDot
+                    }
+                    _ => Operator::DotDot,
+                };
+                Ok(Kind::Op(op).to_token(index))
             }
             ('|', Some('|')) => {
                 let _ = self.chars.next();
@@ -351,7 +359,7 @@ mod test {
     use anathema_store::storage::strings::StringId;
 
     use super::*;
-    use crate::error::ParseErrorKind;
+    use crate::templates::error::{ErrorKind, ParseErrorKind};
 
     fn token_kind(input: &'static str) -> Kind {
         let mut strings = Strings::new();
@@ -373,14 +381,14 @@ mod test {
         let mut lexer = Lexer::new(&input, &mut strings);
         let err = lexer.next().unwrap().unwrap_err();
         match err.kind {
-            crate::error::ErrorKind::ParseError(err) => err.kind,
-            crate::error::ErrorKind::CircularDependency
-            | crate::error::ErrorKind::InvalidStatement(_)
-            | crate::error::ErrorKind::MissingComponent(_)
-            | crate::error::ErrorKind::EmptyTemplate
-            | crate::error::ErrorKind::EmptyBody
-            | crate::error::ErrorKind::GlobalAlreadyAssigned(_)
-            | crate::error::ErrorKind::Io(_) => panic!("invalid error"),
+            ErrorKind::ParseError(err) => err.kind,
+            ErrorKind::CircularDependency
+            | ErrorKind::InvalidStatement(_)
+            | ErrorKind::MissingComponent(_)
+            | ErrorKind::EmptyTemplate
+            | ErrorKind::EmptyBody
+            | ErrorKind::GlobalAlreadyAssigned(_)
+            | ErrorKind::Io(_) => panic!("invalid error"),
         }
     }
 
@@ -580,4 +588,10 @@ mod test {
         let decl = token_kind("..");
         assert_eq!(decl, Kind::Op(Operator::DotDot));
     }
+
+    #[test]
+    fn triple_dot() {
+        let decl = token_kind("...");
+        assert_eq!(decl, Kind::Op(Operator::DotDotDot));
+    }
 }
diff --git a/anathema-core/src/templates/mod.rs b/anathema-core/src/templates/mod.rs
new file mode 100644
index 00000000..2fa3eecc
--- /dev/null
+++ b/anathema-core/src/templates/mod.rs
@@ -0,0 +1,22 @@
+//! Compiling template source to blueprints and expressions.
+pub use blueprints::Blueprint;
+pub(crate) use blueprints::{Component, ControlFlow, For, Single, With};
+
+pub use self::components::{ComponentBlueprintId, SourceKind};
+pub use self::document::Document;
+pub use self::expressions::{Expression, ExpressionId, Expressions};
+pub use self::lexer::Lexer;
+pub use self::primitives::Primitive;
+pub use self::variables::Variables;
+
+mod blueprints;
+mod components;
+mod document;
+mod error;
+pub(crate) mod expressions;
+mod lexer;
+mod primitives;
+mod statements;
+mod strings;
+mod token;
+mod variables;
diff --git a/anathema-templates/src/primitives.rs b/anathema-core/src/templates/primitives.rs
similarity index 95%
rename from anathema-templates/src/primitives.rs
rename to anathema-core/src/templates/primitives.rs
index f5d75663..588bc060 100644
--- a/anathema-templates/src/primitives.rs
+++ b/anathema-core/src/templates/primitives.rs
@@ -6,10 +6,15 @@ use anathema_state::Hex;
 /// These values are all static and resolved at eval time.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum Primitive {
+    /// Bool
     Bool(bool),
+    /// Char
     Char(char),
+    /// Int
     Int(i64),
+    /// Float
     Float(f64),
+    /// Hex
     Hex(Hex),
 }
 
diff --git a/anathema-templates/src/statements/const_eval.rs b/anathema-core/src/templates/statements/const_eval.rs
similarity index 85%
rename from anathema-templates/src/statements/const_eval.rs
rename to anathema-core/src/templates/statements/const_eval.rs
index b45b768c..24b54295 100644
--- a/anathema-templates/src/statements/const_eval.rs
+++ b/anathema-core/src/templates/statements/const_eval.rs
@@ -1,8 +1,8 @@
 use std::collections::HashMap;
 
 use super::Context;
-use crate::expressions::{Expression, Op};
-use crate::primitives::Primitive;
+use crate::templates::expressions::{Expression, Op};
+use crate::templates::primitives::Primitive;
 
 // Evaluate the expression using `vars` as a backing store.
 // e.g `a.b.c` would first find `a` in `vars` and resolve the remaining path
@@ -35,7 +35,7 @@ fn eval_path(expr: Expression, ctx: &Context<'_>) -> Option<Expression> {
 }
 
 // Returning `None` here means we evaluated a const expression but the expression didn't exist,
-// e.g indexing outside of a list of primitives.
+// e.g indexing outside of a list of primitives or refering to state value / attributes.
 pub(crate) fn const_eval(expr: impl Into<Expression>, ctx: &Context<'_>) -> Option<Expression> {
     use {Expression as E, Primitive as P};
 
@@ -54,11 +54,15 @@ pub(crate) fn const_eval(expr: impl Into<Expression>, ctx: &Context<'_>) -> Opti
             Some(expr) => E::Either(expr.into(), ce!(second)),
             None => return None,
         },
-        E::Not(expr) => E::Not(ce!(*expr)),
-        E::Negative(expr) => E::Negative(ce!(*expr)),
-        E::Equality(lhs, rhs, eq) => E::Equality(ce!(*lhs), ce!(*rhs), eq),
-        E::LogicalOp(lhs, rhs, op) => E::LogicalOp(ce!(*lhs), ce!(*rhs), op),
-        E::Range(from, to) => E::Range(ce!(*from), ce!(*to)),
+        E::Not(expr) => E::Not(ce!(expr)),
+        E::Negative(expr) => E::Negative(ce!(expr)),
+        E::Equality(lhs, rhs, eq) => E::Equality(ce!(lhs), ce!(rhs), eq),
+        E::LogicalOp(lhs, rhs, op) => E::LogicalOp(ce!(lhs), ce!(rhs), op),
+        E::Range { start, end, inclusive } => E::Range {
+            start: ce!(start),
+            end: ce!(end),
+            inclusive,
+        },
 
         E::Ident(_) | E::Index(..) => eval_path(expr, ctx)?,
         E::Variable(_) => unreachable!("const eval is not recursive so this can never happen"),
@@ -76,7 +80,7 @@ pub(crate) fn const_eval(expr: impl Into<Expression>, ctx: &Context<'_>) -> Opti
             let hm = HashMap::from_iter(map.into_iter().flat_map(|(k, v)| Some((k, ce!(v)))));
             E::Map(hm)
         }
-        E::Op(lhs, rhs, op) => match (ce!(*lhs), ce!(*rhs)) {
+        E::Op(lhs, rhs, op) => match (ce!(lhs), ce!(rhs)) {
             (E::Primitive(P::Int(lhs)), E::Primitive(P::Int(rhs))) => {
                 let val = match op {
                     Op::Add => lhs + rhs,
@@ -101,8 +105,8 @@ pub(crate) fn const_eval(expr: impl Into<Expression>, ctx: &Context<'_>) -> Opti
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::expressions::{add, div, either, ident, index, list, mul, num, range, strlit, sub};
-    use crate::statements::with_context;
+    use crate::templates::expressions::{add, div, either, ident, index, list, mul, num, range, strlit, sub};
+    use crate::templates::statements::with_context;
 
     #[test]
     fn addition() {
@@ -182,10 +186,10 @@ mod test {
     #[test]
     fn const_range() {
         with_context(|ctx| {
-            let expr = range(num(1), num(2));
+            let expr = range(num(1), num(2), true);
 
             let output = const_eval(expr, &ctx).unwrap();
-            assert_eq!(output, *range(num(1), num(2)));
+            assert_eq!(output, *range(num(1), num(2), true));
         });
     }
 }
diff --git a/anathema-templates/src/statements/eval.rs b/anathema-core/src/templates/statements/eval.rs
similarity index 85%
rename from anathema-templates/src/statements/eval.rs
rename to anathema-core/src/templates/statements/eval.rs
index c4852626..3345d503 100644
--- a/anathema-templates/src/statements/eval.rs
+++ b/anathema-core/src/templates/statements/eval.rs
@@ -1,12 +1,12 @@
 use anathema_store::smallmap::SmallMap;
 use anathema_store::storage::strings::StringId;
 
-use super::const_eval::const_eval;
-use super::{Context, Statement, Statements};
-use crate::blueprints::{Blueprint, Component, ControlFlow, Else, For, Single, With};
-use crate::error::{ErrorKind, Result};
-use crate::expressions::{Equality, Expression};
-use crate::{ComponentBlueprintId, Primitive};
+use crate::templates::blueprints::{Blueprint, Component, ControlFlow, Else, For, Single, With};
+use crate::templates::error::{ErrorKind, Result};
+use crate::templates::expressions::{Equality, Expression, ExpressionId};
+use crate::templates::statements::const_eval::const_eval;
+use crate::templates::statements::{Context, Statement, Statements};
+use crate::templates::{ComponentBlueprintId, Primitive};
 
 pub(crate) struct Scope {
     statements: Statements,
@@ -52,7 +52,9 @@ impl Scope {
                     is_global,
                 } => {
                     let Some(value) = const_eval(value, ctx) else { continue };
+                    let expr_id = ctx.insert_expression(value);
                     let binding = ctx.strings.get_unchecked(binding);
+                    // TODO: have a list of keywords here that we fail on
                     if binding == "state" {
                         return Err(
                             ErrorKind::InvalidStatement(format!("{binding} is a reserved identifier"))
@@ -60,8 +62,8 @@ impl Scope {
                         );
                     }
                     match is_global {
-                        false => _ = ctx.variables.define_local(binding, value),
-                        true => match ctx.variables.define_global(binding, value) {
+                        false => _ = ctx.variables.define_local(binding, expr_id),
+                        true => match ctx.variables.define_global(binding, expr_id) {
                             Ok(()) => (),
                             Err(kind) => return Err(kind.to_error(ctx.template.path())),
                         },
@@ -91,7 +93,11 @@ impl Scope {
     fn eval_node(&mut self, ident: StringId, ctx: &mut Context<'_>) -> Result<Blueprint> {
         let ident = ctx.strings.get_unchecked(ident);
         let attributes = self.eval_attributes(ctx)?;
-        let value = self.statements.take_value().and_then(|v| const_eval(v, ctx));
+        let value = self
+            .statements
+            .take_value()
+            .and_then(|v| const_eval(v, ctx))
+            .map(|expr| ctx.insert_expression(expr));
 
         ctx.variables.push();
         let children = self.consume_scope(ctx)?;
@@ -109,21 +115,33 @@ impl Scope {
 
     fn eval_for(&mut self, binding: StringId, data: Expression, ctx: &mut Context<'_>) -> Result<Option<Blueprint>> {
         let Some(data) = const_eval(data, ctx) else { return Ok(None) };
+        let expr_id = ctx.insert_expression(data);
+
         let binding = ctx.strings.get_unchecked(binding);
         // add binding to globals so nothing can resolve past the binding outside of the loop
-        ctx.variables.declare_local(binding.clone());
+        ctx.variables.declare_local(binding.clone(), ctx.expressions);
         let body = self.consume_scope(ctx)?;
-        let node = Blueprint::For(For { binding, data, body });
+        let node = Blueprint::For(For {
+            binding,
+            data: expr_id,
+            body,
+        });
         Ok(Some(node))
     }
 
     fn eval_with(&mut self, binding: StringId, data: Expression, ctx: &mut Context<'_>) -> Result<Option<Blueprint>> {
         let Some(data) = const_eval(data, ctx) else { return Ok(None) };
+        let expr_id = ctx.insert_expression(data);
+
         let binding = ctx.strings.get_unchecked(binding);
         // add binding to globals so nothing can resolve past the binding outside of the loop
-        ctx.variables.declare_local(binding.clone());
+        ctx.variables.declare_local(binding.clone(), ctx.expressions);
         let body = self.consume_scope(ctx)?;
-        let node = Blueprint::With(With { binding, data, body });
+        let node = Blueprint::With(With {
+            binding,
+            data: expr_id,
+            body,
+        });
         Ok(Some(node))
     }
 
@@ -132,13 +150,14 @@ impl Scope {
         scope.eval(ctx)
     }
 
-    fn eval_attributes(&mut self, ctx: &mut Context<'_>) -> Result<SmallMap<String, Expression>> {
+    fn eval_attributes(&mut self, ctx: &mut Context<'_>) -> Result<SmallMap<String, ExpressionId>> {
         let mut hm = SmallMap::empty();
 
         for (key, value) in self.statements.take_attributes() {
             let Some(value) = const_eval(value, ctx) else { continue };
+            let expr_id = ctx.insert_expression(value);
             let key = ctx.strings.get_unchecked(key);
-            hm.set(key, value);
+            hm.set(key, expr_id);
         }
 
         Ok(hm)
@@ -147,16 +166,22 @@ impl Scope {
     fn eval_if(&mut self, cond: Expression, ctx: &mut Context<'_>) -> Result<Blueprint> {
         // Const eval fail = static false
         let cond = const_eval(cond, ctx).unwrap_or(Expression::Primitive(Primitive::Bool(false)));
+        let expr_id = ctx.insert_expression(cond);
         let body = self.consume_scope(ctx)?;
         if body.is_empty() {
             return Err(ErrorKind::EmptyBody.to_error(ctx.template.path()));
         }
 
-        let mut elses = vec![Else { cond: Some(cond), body }];
+        let mut elses = vec![Else {
+            cond: Some(expr_id),
+            body,
+        }];
 
         while let Some(cond) = self.statements.next_else() {
             let body = self.consume_scope(ctx)?;
-            let cond = cond.and_then(|v| const_eval(v, ctx));
+            let cond = cond
+                .and_then(|v| const_eval(v, ctx))
+                .map(|expr| ctx.insert_expression(expr));
 
             if body.is_empty() {
                 return Err(ErrorKind::EmptyBody.to_error(ctx.template.path()));
@@ -179,6 +204,7 @@ impl Scope {
                 Some(ref switch) => Expression::Equality(switch.clone().into(), case.into(), Equality::Eq),
                 None => Expression::Primitive(Primitive::Bool(false)),
             };
+            let expr_id = ctx.insert_expression(cond);
 
             let body = match body.is_next_scope() {
                 true => body.take_scope(),
@@ -186,7 +212,10 @@ impl Scope {
             };
             let body = Scope::new(body).eval(ctx)?;
 
-            elses.push(Else { cond: Some(cond), body });
+            elses.push(Else {
+                cond: Some(expr_id),
+                body,
+            });
         }
 
         if body.next_default() {
@@ -260,14 +289,16 @@ impl Scope {
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::document::Document;
-    use crate::{ToSourceKind, Variables, single};
+    use crate::templates::blueprints::single;
+    use crate::templates::document::Document;
+    use crate::templates::Variables;
+
 
     #[test]
     fn eval_node() {
         let mut doc = Document::new("node");
-        let bp = doc.compile(&mut Variables::new()).unwrap();
-        assert_eq!(bp, single!("node"));
+        let blueprint = doc.compile(&mut Variables::new()).unwrap();
+        assert_eq!(blueprint, single!("node"));
     }
 
     #[test]
@@ -386,7 +417,7 @@ mod test {
         let comp_src = "node a + 2";
 
         let mut doc = Document::new(src);
-        doc.add_component("comp", comp_src.to_template()).unwrap();
+        doc.add_component("comp", comp_src).unwrap();
         let blueprint = doc.compile(&mut Variables::new()).unwrap();
         assert!(matches!(blueprint, Blueprint::Component(Component { .. })));
     }
@@ -411,7 +442,7 @@ mod test {
         ";
 
         let mut doc = Document::new(src);
-        doc.add_component("comp", comp_src.to_template()).unwrap();
+        doc.add_component("comp", comp_src).unwrap();
         let blueprint = doc.compile(&mut Variables::new()).unwrap();
         assert!(matches!(blueprint, Blueprint::Component(Component { .. })));
     }
@@ -425,7 +456,7 @@ mod test {
         ";
 
         let mut doc = Document::new(src);
-        doc.add_component("comp", "node a".to_template()).unwrap();
+        doc.add_component("comp", "node a").unwrap();
         let _ = doc.compile(&mut Variables::new()).unwrap();
     }
 
@@ -436,7 +467,7 @@ mod test {
         ";
 
         let mut doc = Document::new(src);
-        doc.add_component("comp", "node a".to_template()).unwrap();
+        doc.add_component("comp", "node a").unwrap();
         let _ = doc.compile(&mut Variables::new()).unwrap();
     }
 
@@ -448,7 +479,7 @@ mod test {
         ";
 
         let mut doc = Document::new(src);
-        doc.add_component("comp", "node a".to_template()).unwrap();
+        doc.add_component("comp", "node a").unwrap();
         let blueprint = doc.compile(&mut Variables::new()).unwrap();
         assert!(matches!(blueprint, Blueprint::With(With { .. })));
     }
diff --git a/anathema-templates/src/statements/mod.rs b/anathema-core/src/templates/statements/mod.rs
similarity index 77%
rename from anathema-templates/src/statements/mod.rs
rename to anathema-core/src/templates/statements/mod.rs
index 76bca877..93306996 100644
--- a/anathema-templates/src/statements/mod.rs
+++ b/anathema-core/src/templates/statements/mod.rs
@@ -1,12 +1,12 @@
 use anathema_store::smallmap::SmallMap;
 
-use crate::ComponentBlueprintId;
-use crate::blueprints::Blueprint;
-use crate::components::{AssocEventMapping, ComponentTemplates, TemplateSource};
-use crate::error::Result;
-use crate::expressions::Expression;
-use crate::strings::{StringId, Strings};
-use crate::variables::{VarId, Variables};
+use super::ComponentBlueprintId;
+use super::blueprints::Blueprint;
+use super::components::{AssocEventMapping, ComponentTemplates, TemplateSource};
+use super::error::Result;
+use super::expressions::{Expression, ExpressionId, Expressions};
+use super::strings::{StringId, Strings};
+use super::variables::{VarId, Variables};
 
 mod const_eval;
 pub(crate) mod eval;
@@ -15,8 +15,9 @@ pub(super) mod parser;
 pub(crate) struct Context<'vars> {
     pub(crate) template: &'vars TemplateSource,
     pub(crate) variables: &'vars mut Variables,
-    pub(crate) components: &'vars mut ComponentTemplates,
+    pub(crate) components: &'vars ComponentTemplates,
     pub(crate) strings: &'vars mut Strings,
+    pub(crate) expressions: &'vars mut Expressions,
     pub(crate) slots: SmallMap<StringId, Vec<Blueprint>>,
     pub(crate) current_component_parent: Option<ComponentBlueprintId>,
 }
@@ -25,8 +26,9 @@ impl<'vars> Context<'vars> {
     pub fn new(
         template: &'vars TemplateSource,
         variables: &'vars mut Variables,
-        components: &'vars mut ComponentTemplates,
+        components: &'vars ComponentTemplates,
         strings: &'vars mut Strings,
+        expressions: &'vars mut Expressions,
         slots: SmallMap<StringId, Vec<Blueprint>>,
         current_component_parent: Option<ComponentBlueprintId>,
     ) -> Self {
@@ -35,10 +37,15 @@ impl<'vars> Context<'vars> {
             variables,
             components,
             strings,
+            expressions,
             slots,
             current_component_parent,
         }
     }
+
+    fn insert_expression(&mut self, expression: Expression) -> ExpressionId {
+        self.expressions.insert(expression, self.variables.boundary())
+    }
 }
 
 impl Context<'_> {
@@ -55,7 +62,8 @@ impl Context<'_> {
         component_id: ComponentBlueprintId,
         slots: SmallMap<StringId, Vec<Blueprint>>,
     ) -> Result<Vec<Blueprint>> {
-        self.components.load(component_id, self.variables, slots, self.strings)
+        self.components
+            .load(component_id, self.variables, slots, self.strings, self.expressions)
     }
 }
 
@@ -94,32 +102,36 @@ pub(crate) enum Statement {
 }
 
 #[derive(Debug, PartialEq)]
-pub(crate) struct Statements(Vec<Statement>);
+pub(crate) struct Statements {
+    inner: Vec<Statement>,
+}
 
 impl From<Vec<Statement>> for Statements {
-    fn from(value: Vec<Statement>) -> Self {
-        Self(value)
+    fn from(statements: Vec<Statement>) -> Self {
+        Self { inner: statements }
     }
 }
 
 impl FromIterator<Statement> for Statements {
     fn from_iter<T: IntoIterator<Item = Statement>>(iter: T) -> Self {
-        Self(iter.into_iter().collect())
+        Self {
+            inner: iter.into_iter().collect(),
+        }
     }
 }
 
 impl Statements {
     fn next(&mut self) -> Option<Statement> {
         match self.is_empty() {
-            false => Some(self.0.remove(0)),
+            false => Some(self.inner.remove(0)),
             true => None,
         }
     }
 
     fn take_value(&mut self) -> Option<Expression> {
-        match matches!(&self.0.first(), Some(Statement::LoadValue(_))) {
-            true => match self.0.remove(0) {
-                Statement::LoadValue(expr) => Some(expr),
+        match matches!(&self.inner.first(), Some(Statement::LoadValue(_))) {
+            true => match self.inner.remove(0) {
+                Statement::LoadValue(expr_id) => Some(expr_id),
                 _ => unreachable!(),
             },
             false => None,
@@ -128,8 +140,8 @@ impl Statements {
 
     fn take_attributes(&mut self) -> Vec<(StringId, Expression)> {
         let mut v = vec![];
-        while matches!(&self.0.first(), Some(Statement::LoadAttribute { .. })) {
-            match self.0.remove(0) {
+        while matches!(&self.inner.first(), Some(Statement::LoadAttribute { .. })) {
+            match self.inner.remove(0) {
                 Statement::LoadAttribute { key, value } => v.push((key, value)),
                 _ => unreachable!(),
             }
@@ -139,8 +151,8 @@ impl Statements {
 
     fn take_assoc_functions(&mut self) -> Vec<AssocEventMapping> {
         let mut v = vec![];
-        while matches!(&self.0.first(), Some(Statement::AssociatedFunction { .. })) {
-            match self.0.remove(0) {
+        while matches!(&self.inner.first(), Some(Statement::AssociatedFunction { .. })) {
+            match self.inner.remove(0) {
                 Statement::AssociatedFunction(map) => v.push(map),
                 _ => unreachable!(),
             }
@@ -153,19 +165,19 @@ impl Statements {
             return vec![].into();
         }
 
-        if self.0[0] != Statement::ScopeStart {
+        if self.inner[0] != Statement::ScopeStart {
             return vec![].into();
         }
 
         let mut level = 0;
 
-        for i in 0..self.0.len() {
-            match &self.0[i] {
+        for i in 0..self.inner.len() {
+            match &self.inner[i] {
                 Statement::ScopeStart => level += 1,
                 Statement::ScopeEnd if level - 1 == 0 => {
-                    let mut scope = self.0.split_off(i);
+                    let mut scope = self.inner.split_off(i);
                     scope.remove(0); // remove the scope start
-                    std::mem::swap(&mut scope, &mut self.0);
+                    std::mem::swap(&mut scope, &mut self.inner);
                     scope.remove(0); // remove the scope end
                     return scope.into();
                 }
@@ -184,20 +196,20 @@ impl Statements {
 
         let mut statements = vec![];
 
-        while !self.0.is_empty() {
-            match self.0[0] {
+        while !self.inner.is_empty() {
+            match self.inner[0] {
                 Statement::Case(_) | Statement::Default | Statement::Eof => break,
                 _ => {}
             }
-            statements.push(self.0.remove(0));
+            statements.push(self.inner.remove(0));
         }
 
         statements.into()
     }
 
     fn next_else(&mut self) -> Option<Option<Expression>> {
-        match matches!(self.0.first(), Some(Statement::Else(_))) {
-            true => match self.0.remove(0) {
+        match matches!(self.inner.first(), Some(Statement::Else(_))) {
+            true => match self.inner.remove(0) {
                 Statement::Else(cond) => Some(cond),
                 _ => unreachable!(),
             },
@@ -206,8 +218,8 @@ impl Statements {
     }
 
     fn next_case(&mut self) -> Option<Expression> {
-        match matches!(self.0.first(), Some(Statement::Case(_))) {
-            true => match self.0.remove(0) {
+        match matches!(self.inner.first(), Some(Statement::Case(_))) {
+            true => match self.inner.remove(0) {
                 Statement::Case(cond) => Some(cond),
                 _ => unreachable!(),
             },
@@ -216,9 +228,9 @@ impl Statements {
     }
 
     fn next_default(&mut self) -> bool {
-        match matches!(self.0.first(), Some(Statement::Default)) {
+        match matches!(self.inner.first(), Some(Statement::Default)) {
             true => {
-                _ = self.0.remove(0);
+                _ = self.inner.remove(0);
                 true
             }
             false => false,
@@ -226,8 +238,8 @@ impl Statements {
     }
 
     fn next_slot(&mut self) -> Option<StringId> {
-        match matches!(self.0.first(), Some(Statement::ComponentSlot(_))) {
-            true => match self.0.remove(0) {
+        match matches!(self.inner.first(), Some(Statement::ComponentSlot(_))) {
+            true => match self.inner.remove(0) {
                 Statement::ComponentSlot(slot_id) => Some(slot_id),
                 _ => unreachable!(),
             },
@@ -236,15 +248,15 @@ impl Statements {
     }
 
     fn is_next_slot(&mut self) -> bool {
-        matches!(self.0.first(), Some(Statement::ComponentSlot(_)))
+        matches!(self.inner.first(), Some(Statement::ComponentSlot(_)))
     }
 
     fn is_next_scope(&mut self) -> bool {
-        matches!(self.0.first(), Some(Statement::ScopeStart))
+        matches!(self.inner.first(), Some(Statement::ScopeStart))
     }
 
     fn is_empty(&self) -> bool {
-        self.0.is_empty()
+        self.inner.is_empty()
     }
 }
 
@@ -256,6 +268,7 @@ where
 {
     let mut globals = Variables::new();
     let mut strings = Strings::new();
+    let mut expressions = Expressions::empty();
     let mut components = ComponentTemplates::new();
     let template_source = TemplateSource::Static("");
 
@@ -263,6 +276,7 @@ where
         template: &template_source,
         variables: &mut globals,
         strings: &mut strings,
+        expressions: &mut expressions,
         components: &mut components,
         slots: SmallMap::empty(),
         current_component_parent: None,
diff --git a/anathema-templates/src/statements/parser.rs b/anathema-core/src/templates/statements/parser.rs
similarity index 96%
rename from anathema-templates/src/statements/parser.rs
rename to anathema-core/src/templates/statements/parser.rs
index 9255abee..3d7bb6b2 100644
--- a/anathema-templates/src/statements/parser.rs
+++ b/anathema-core/src/templates/statements/parser.rs
@@ -1,10 +1,10 @@
-use super::Statement;
-use crate::components::{AssocEventMapping, ComponentTemplates, TemplateSource};
-use crate::error::{Error, ParseError, ParseErrorKind, Result, src_line_no};
-use crate::expressions::Expression;
-use crate::expressions::parser::parse_expr;
-use crate::strings::{StringId, Strings};
-use crate::token::{Kind, Operator, Tokens, Value};
+use crate::templates::components::{AssocEventMapping, ComponentTemplates, TemplateSource};
+use crate::templates::error::{src_line_no, Error, ParseError, ParseErrorKind, Result};
+use crate::templates::expressions::parser::parse_expr;
+use crate::templates::expressions::Expression;
+use crate::templates::statements::Statement;
+use crate::templates::strings::{StringId, Strings};
+use crate::templates::token::{Kind, Operator, Tokens, Value};
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 enum State {
@@ -32,7 +32,7 @@ enum State {
 // -----------------------------------------------------------------------------
 pub(crate) struct Parser<'src, 'strings, 'components> {
     tokens: Tokens,
-    components: &'components mut ComponentTemplates,
+    components: &'components ComponentTemplates,
     strings: &'strings mut Strings,
     src: &'src TemplateSource,
     state: State,
@@ -42,12 +42,12 @@ pub(crate) struct Parser<'src, 'strings, 'components> {
     done: bool,
 }
 
-impl<'src, 'strings, 'view> Parser<'src, 'strings, 'view> {
+impl<'src, 'strings, 'components> Parser<'src, 'strings, 'components> {
     pub(crate) fn new(
         mut tokens: Tokens,
         strings: &'strings mut Strings,
         src: &'src TemplateSource,
-        components: &'view mut ComponentTemplates,
+        components: &'components ComponentTemplates,
     ) -> Self {
         tokens.consume_newlines();
         let base_indent = match tokens.peek() {
@@ -639,10 +639,10 @@ impl Iterator for Parser<'_, '_, '_> {
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::error::ErrorKind;
-    use crate::expressions::{boolean, ident, map, num, range, strlit, text_segments};
-    use crate::lexer::Lexer;
-    use crate::statements::test::{
+    use crate::templates::error::ErrorKind;
+    use crate::templates::expressions::{boolean, ident, map, num, range, strlit, text_segments};
+    use crate::templates::lexer::Lexer;
+    use crate::templates::statements::test::{
         associated_fun, case, component, else_stmt, eof, for_loop, global, if_else, if_stmt, load_attrib, load_value,
         local, node, scope_end, scope_start, slot, switch, with,
     };
@@ -651,7 +651,7 @@ mod test {
         let mut strings = Strings::new();
         let x_id = strings.push("x");
         let mut components = ComponentTemplates::new();
-        components.insert(x_id, crate::components::TemplateSource::InMemory(String::new()));
+        components.insert(x_id, TemplateSource::InMemory(String::new()));
         let lexer = Lexer::new(&src, &mut strings);
         let tokens = Tokens::new(lexer.collect::<Result<Vec<_>>>().unwrap(), src.len());
         let parser = Parser::new(tokens, &mut strings, &src, &mut components);
@@ -978,10 +978,17 @@ mod test {
     }
 
     #[test]
-    fn parse_range() {
+    fn parse_exclusive_range() {
         let src = "for i in x..y";
         let mut statements = parse_ok(src);
-        assert_eq!(statements.remove(0), for_loop(2, range(ident("x"), ident("y"))));
+        assert_eq!(statements.remove(0), for_loop(2, range(ident("x"), ident("y"), false)));
+    }
+
+    #[test]
+    fn parse_inclusive_range() {
+        let src = "for i in x...y";
+        let mut statements = parse_ok(src);
+        assert_eq!(statements.remove(0), for_loop(2, range(ident("x"), ident("y"), true)));
     }
 
     #[test]
diff --git a/anathema-templates/src/strings.rs b/anathema-core/src/templates/strings.rs
similarity index 100%
rename from anathema-templates/src/strings.rs
rename to anathema-core/src/templates/strings.rs
diff --git a/anathema-templates/src/token.rs b/anathema-core/src/templates/token.rs
similarity index 98%
rename from anathema-templates/src/token.rs
rename to anathema-core/src/templates/token.rs
index 8fff2790..2213b687 100644
--- a/anathema-templates/src/token.rs
+++ b/anathema-core/src/templates/token.rs
@@ -2,7 +2,7 @@ use std::fmt::{self, Display, Formatter};
 
 use anathema_store::storage::strings::StringId;
 
-use crate::primitives::Primitive;
+use super::primitives::Primitive;
 
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub enum Operator {
@@ -33,6 +33,7 @@ pub enum Operator {
     Or,
     Dot,
     DotDot,
+    DotDotDot,
     Comma,
     Colon,
     Semicolon,
@@ -68,6 +69,7 @@ impl Display for Operator {
             Self::Or => write!(f, "||"),
             Self::Dot => write!(f, "."),
             Self::DotDot => write!(f, ".."),
+            Self::DotDotDot => write!(f, "..."),
             Self::Comma => write!(f, ","),
             Self::Colon => write!(f, ":"),
             Self::Semicolon => write!(f, ";"),
diff --git a/anathema-templates/src/variables.rs b/anathema-core/src/templates/variables.rs
similarity index 70%
rename from anathema-templates/src/variables.rs
rename to anathema-core/src/templates/variables.rs
index 1ec7afe8..b957d766 100644
--- a/anathema-templates/src/variables.rs
+++ b/anathema-core/src/templates/variables.rs
@@ -3,11 +3,19 @@ use std::sync::OnceLock;
 
 use anathema_store::slab::{Slab, SlabIndex};
 
-use crate::error::ErrorKind;
-use crate::expressions::Expression;
+use super::error::ErrorKind;
+use super::expressions::{Expression, ExpressionId, Expressions};
+
+#[derive(Debug, Copy, Clone)]
+enum Global {
+    // The global value was set from the runtime
+    Runtime(ExpressionId),
+    // The global value originates from a template
+    Template(ExpressionId),
+}
 
 #[derive(Debug, Default, Clone)]
-pub struct Globals(HashMap<String, Expression>);
+pub struct Globals(HashMap<String, Global>);
 
 impl Globals {
     pub fn empty() -> Self {
@@ -18,16 +26,32 @@ impl Globals {
         self.0.contains_key(ident)
     }
 
-    pub fn get(&self, ident: &str) -> Option<&Expression> {
-        self.0.get(ident)
+    pub fn get(&self, ident: &str) -> Option<ExpressionId> {
+        match self.0.get(ident).copied()? {
+            Global::Runtime(expression) | Global::Template(expression) => Some(expression),
+        }
     }
 
-    pub fn set(&mut self, ident: String, value: Expression) {
+    fn set(&mut self, ident: String, value: Global) {
         if self.0.contains_key(&ident) {
             return;
         }
         _ = self.0.insert(ident, value);
     }
+
+    fn clear_template_globals(&mut self) {
+        let mut clear = vec![];
+        for (key, glob) in &self.0 {
+            match glob {
+                Global::Runtime(_) => continue,
+                Global::Template(_) => clear.push(key.to_owned()),
+            }
+        }
+
+        for key in clear {
+            _ = self.0.remove(&key);
+        }
+    }
 }
 
 #[derive(Debug, Copy, Clone, PartialEq)]
@@ -52,15 +76,15 @@ impl SlabIndex for VarId {
 pub enum Variable {
     /// A variable is defined but the value will be available at runtime, e.g `for-loops` and
     /// `with`
-    Definition(Expression),
+    Definition(ExpressionId),
     /// A value is declared, either as a local value or a global value
-    Declaration(Expression),
+    Declaration(ExpressionId),
 }
 
 impl Variable {
-    fn as_expression(&self) -> &Expression {
+    fn as_expression(&self) -> ExpressionId {
         match self {
-            Variable::Definition(expr) | Variable::Declaration(expr) => expr,
+            Variable::Definition(expr) | Variable::Declaration(expr) => *expr,
         }
     }
 }
@@ -72,7 +96,7 @@ impl Variable {
 pub struct ScopeId(Box<[u16]>);
 
 impl ScopeId {
-    fn root() -> &'static Self {
+    pub(crate) fn root() -> &'static Self {
         static ROOT: OnceLock<ScopeId> = OnceLock::new();
         ROOT.get_or_init(|| ScopeId(Box::new([])))
     }
@@ -196,10 +220,10 @@ impl Declarations {
         Self(HashMap::new())
     }
 
-    fn add(&mut self, ident: impl Into<String>, id: impl Into<ScopeId>, value_id: impl Into<VarId>) {
+    fn add(&mut self, ident: impl Into<String>, scope_id: impl Into<ScopeId>, value_id: impl Into<VarId>) {
         let value_id = value_id.into();
         let ids = self.0.entry(ident.into()).or_default();
-        ids.push((id.into(), value_id));
+        ids.push((scope_id.into(), value_id));
     }
 
     // Get the scope id that is closest to the argument
@@ -215,8 +239,7 @@ impl Declarations {
     }
 }
 
-/// Variable access, declaration and assignment
-/// during the compilation step.
+/// Map variables to expressions.
 #[derive(Debug)]
 pub struct Variables {
     globals: Globals,
@@ -234,6 +257,7 @@ impl Default for Variables {
 }
 
 impl Variables {
+    /// Create a new instance of variable storage.
     pub fn new() -> Self {
         let root = RootScope::default();
         Self {
@@ -252,34 +276,67 @@ impl Variables {
         var_id
     }
 
-    pub fn define_global(&mut self, ident: impl Into<String>, value: impl Into<Expression>) -> Result<(), ErrorKind> {
+    fn set_global(&mut self, ident: impl Into<String>, global: Global) -> Result<(), ErrorKind> {
         let ident = ident.into();
         if self.globals.contains(&ident) {
             return Err(ErrorKind::GlobalAlreadyAssigned(ident));
         }
 
-        self.globals.set(ident, value.into());
+        self.globals.set(ident, global);
         Ok(())
     }
 
-    pub fn define_local(&mut self, ident: impl Into<String>, value: impl Into<Expression>) -> VarId {
-        let value = value.into();
+    /// Reset the globals defined in the template.
+    /// This keeps any globals registered through Rust
+    pub fn reset_globals(&mut self) {
+        self.globals.clear_template_globals();
+    }
+
+    /// Register a global value.
+    ///
+    /// A global value can be anything that implements `Into<Expression>`,
+    /// which is most primitives.
+    ///
+    /// ```
+    /// # use anathema_core::templates::{Variables, Expressions};
+    /// # let mut expressions = Expressions::empty();
+    /// let mut variables = Variables::new();
+    /// variables.register_global("number", 123, &mut expressions);
+    /// ```
+    pub fn register_global(
+        &mut self,
+        ident: impl Into<String>,
+        value: impl Into<Expression>,
+        expressions: &mut Expressions,
+    ) -> Result<(), ErrorKind> {
+        let id = expressions.insert(value.into(), ScopeId::root().clone());
+        let global = Global::Runtime(id);
+        self.set_global(ident, global)
+    }
+
+    pub(super) fn define_global(&mut self, ident: impl Into<String>, expression: ExpressionId) -> Result<(), ErrorKind> {
+        let global = Global::Template(expression);
+        self.set_global(ident, global)
+    }
+
+    pub(super) fn define_local(&mut self, ident: impl Into<String>, value: ExpressionId) -> VarId {
         let scope_id = self.current.clone();
         let var_id = self.store.insert(Variable::Declaration(value));
         self.declare_at(ident, var_id, scope_id)
     }
 
-    pub fn declare_local(&mut self, ident: impl Into<String>) -> VarId {
+    pub(super) fn declare_local(&mut self, ident: impl Into<String>, expressions: &mut Expressions) -> VarId {
+        let scope_id = self.current.clone();
         let ident = ident.into();
-        let value = Variable::Definition(Expression::Ident(ident.clone()));
+        let id = expressions.insert(Expression::Ident(ident.clone()), scope_id.clone());
+        let value = Variable::Definition(id);
         let var_id = self.store.insert(value);
-        let scope_id = self.current.clone();
         self.declare_at(ident, var_id, scope_id)
     }
 
     /// Fetch a value starting from the current path.
     pub fn fetch(&self, ident: &str) -> Option<VarId> {
-        self.declarations.get(ident, &self.current, self.boundary())
+        self.declarations.get(ident, &self.current, self.boundary_ref())
     }
 
     /// Create a new scope and set that scope as a boundary.
@@ -313,24 +370,28 @@ impl Variables {
     }
 
     /// Load a variable from the store
-    pub fn load(&self, var: VarId) -> Option<&Expression> {
+    pub fn load(&self, var: VarId) -> Option<ExpressionId> {
         self.store.get(var).map(Variable::as_expression)
     }
 
     // Fetch and load a value from its ident
     #[cfg(test)]
-    fn fetch_load(&self, ident: &str) -> Option<&Expression> {
-        let id = self.declarations.get(ident, &self.current, self.boundary())?;
+    fn fetch_load(&self, ident: &str) -> Option<ExpressionId> {
+        let id = self.declarations.get(ident, &self.current, self.boundary_ref())?;
         self.load(id)
     }
 
-    pub fn global_lookup(&self, ident: &str) -> Option<&Expression> {
+    pub(crate) fn global_lookup(&self, ident: &str) -> Option<ExpressionId> {
         self.globals.get(ident)
     }
 
-    fn boundary(&self) -> &ScopeId {
+    fn boundary_ref(&self) -> &ScopeId {
         self.boundary.last().unwrap_or(ScopeId::root())
     }
+
+    pub(crate) fn boundary(&self) -> ScopeId {
+        self.boundary.last().unwrap_or(ScopeId::root()).clone()
+    }
 }
 
 impl From<Variables> for HashMap<String, Variable> {
@@ -352,7 +413,6 @@ impl From<Variables> for HashMap<String, Variable> {
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::expressions::num;
 
     impl From<usize> for VarId {
         fn from(value: usize) -> Self {
@@ -392,36 +452,40 @@ mod test {
     #[test]
     fn variable_declaration() {
         let mut vars = Variables::new();
-        let expected = Expression::from(123i64);
+        let mut expressions = Expressions::empty();
 
-        vars.define_local("var", expected.clone());
+        let expected = expressions.insert_at_root(Expression::from(123i64));
+        vars.define_local("var", expected);
         let id = vars.fetch("var").unwrap();
         let value = vars.load(id).unwrap();
 
-        assert_eq!(&expected, value);
+        assert_eq!(expected, value);
     }
 
     #[test]
     fn shadow_value() {
-        let ident = "var";
         let mut vars = Variables::new();
-        let value_a = Expression::from("1");
-        let value_b = Expression::from("2");
+        let mut expressions = Expressions::empty();
+        let ident = "var";
+        let value_a = expressions.insert_at_root(Expression::from("1"));
+        let value_b = expressions.insert_at_root(Expression::from("2"));
 
-        let first_value_ref = vars.define_local(ident, value_a.clone());
-        let second_value_ref = vars.define_local(ident, value_b.clone());
-        assert_eq!(&value_a, vars.load(first_value_ref).unwrap());
-        assert_eq!(&value_b, vars.load(second_value_ref).unwrap());
+        let first_value_ref = vars.define_local(ident, value_a);
+        let second_value_ref = vars.define_local(ident, value_b);
+        assert_eq!(value_a, vars.load(first_value_ref).unwrap());
+        assert_eq!(value_b, vars.load(second_value_ref).unwrap());
     }
 
     #[test]
     fn scoping_variables_inaccessible_sibling() {
         // Declare a variable in a sibling and fail to access that value
         let mut vars = Variables::new();
+        let mut expressions = Expressions::empty();
+        let inaccessible = expressions.insert_at_root("inaccessible");
         let ident = "var";
 
         vars.push();
-        vars.define_local(ident, "inaccessible");
+        vars.define_local(ident, inaccessible);
         assert!(vars.fetch(ident).is_some());
         vars.pop();
 
@@ -472,25 +536,29 @@ mod test {
     #[test]
     fn get_inside_boundary() {
         let mut vars = Variables::new();
+        let mut expressions = Expressions::empty();
+        let one = expressions.insert_at_root(1);
+        let two = expressions.insert_at_root(2);
+        let three = expressions.insert_at_root(3);
 
         // Define a variable in the root scope
-        _ = vars.define_local("var", 1);
+        _ = vars.define_local("var", one);
 
         // Create a new unique scope and boundary.
         // * `var` should be inaccessible from within the new scope boundary
         // * `outer_var` should be inaccessible to the root scope
         vars.push_scope_boundary();
         assert!(vars.fetch("var").is_none());
-        _ = vars.define_local("var", 2);
-        _ = vars.define_local("other_var", 3);
-        assert_eq!(vars.fetch_load("var").unwrap(), &*num(2));
+        _ = vars.define_local("var", two);
+        _ = vars.define_local("other_var", three);
+        assert_eq!(vars.fetch_load("var").unwrap(), two);
         vars.push();
-        assert_eq!(vars.fetch_load("other_var").unwrap(), &*num(3));
+        assert_eq!(vars.fetch_load("other_var").unwrap(), three);
         vars.pop();
 
         // Return to root scope
         vars.pop_scope_boundary();
-        assert_eq!(vars.fetch_load("var").unwrap(), &*num(1));
+        assert_eq!(vars.fetch_load("var").unwrap(), one);
         assert!(vars.fetch("other_var").is_none());
     }
 }
diff --git a/anathema-core/src/testing.rs b/anathema-core/src/testing.rs
new file mode 100644
index 00000000..88a993b8
--- /dev/null
+++ b/anathema-core/src/testing.rs
@@ -0,0 +1,339 @@
+use std::cell::RefCell;
+
+use anathema_geometry::{Pos, Size};
+use anathema_state::{State, StateId};
+
+use crate::attributes::{AttributeRegistry, Attributes};
+use crate::layout::Layout;
+use crate::runtime::components::{Component, ComponentId, Components, FnComp, FnState};
+use crate::runtime::elements::{Element, ElementId, Elements};
+use crate::runtime::eval::expression::{eval_by_id, RuntimeExpressions};
+use crate::runtime::eval::scope::Scope;
+use crate::runtime::eval::values::TemplateValue;
+use crate::runtime::eval::{eval, EvalCtx};
+use crate::runtime::functions::FunctionTable;
+use crate::runtime::widgets::iter::Children;
+use crate::runtime::widgets::{RegisteredWidgets, Widget};
+use crate::runtime::ValueIndex;
+use crate::templates::expressions::Expressions;
+use crate::templates::{
+    Blueprint, ComponentBlueprintId, Document, Expression, ExpressionId, SourceKind, Variables,
+};
+
+fn test_widgets() -> RegisteredWidgets {
+    let mut factory = RegisteredWidgets::empty();
+    factory.register_default::<TestWidget>("node");
+    factory
+}
+
+#[derive(Debug)]
+pub struct NoDoc {
+    expressions: Expressions,
+}
+
+impl Default for NoDoc {
+    fn default() -> Self {
+        Self {
+            expressions: Expressions::empty(),
+        }
+    }
+}
+
+// -----------------------------------------------------------------------------
+//   - Generic test runner -
+// -----------------------------------------------------------------------------
+#[derive(Debug, Default)]
+pub struct RunBuilder<T> {
+    inner: T,
+    components: Components,
+    functions: FunctionTable,
+    variables: Variables,
+    widget_registry: RegisteredWidgets,
+    dirty_elements: Vec<ElementId>,
+}
+
+impl RunBuilder<NoDoc> {
+    pub fn new() -> Self {
+        let mut inst = Self::default();
+        inst.widget_registry = test_widgets();
+        inst
+    }
+
+    pub fn insert_expression(&mut self, expression: impl Into<Expression>) -> ExpressionId {
+        self.inner.expressions.insert_at_root(expression)
+    }
+
+    pub fn register_global(&mut self, ident: &str, expression: impl Into<Expression>) {
+        self.variables
+            .register_global(ident, expression, &mut self.inner.expressions)
+            .unwrap()
+    }
+
+    // pub fn add_component(&mut self, comp: impl Component, state: impl State) -> ComponentId {
+    //     panic!()
+    //     // self.components.insert_component(comp, state)
+    // }
+
+    pub(crate) fn finish(&mut self) -> Instance<'_, '_> {
+        Instance::new(
+            &mut self.components,
+            &self.variables,
+            &self.inner.expressions,
+            &self.functions,
+            None,
+            &self.widget_registry,
+            &mut self.dirty_elements,
+        )
+    }
+}
+
+impl RunBuilder<(Document, Option<Blueprint>)> {
+    pub fn from_src(src: &str) -> Self {
+        let template = src.to_string();
+        let variables = Variables::new();
+        let doc = Document::new(template);
+
+        Self {
+            inner: (doc, None),
+            components: Default::default(),
+            functions: Default::default(),
+            variables,
+            widget_registry: test_widgets(),
+            dirty_elements: vec![],
+        }
+    }
+
+    pub fn add_component(
+        &mut self,
+        name: &str,
+        template: impl Into<SourceKind>,
+        comp: impl Component,
+        state: impl State<ValueIndex>,
+    ) -> ComponentId {
+        let component_bp_id = self.inner.0.add_component(name, template.into()).unwrap();
+        let comp_id = self.components.insert_component(component_bp_id, comp, state);
+        comp_id
+    }
+
+    pub fn add_prototype(&mut self, name: &str, template: impl Into<SourceKind>, component: FnComp, state: FnState) {
+        let component_bp_id = self.inner.0.add_component(name, template.into()).unwrap();
+        let comp_id = self.components.insert_prototype(component_bp_id, component, state);
+    }
+
+    pub(crate) fn finish(&mut self) -> Instance<'_, '_> {
+        let bp = self.inner.0.compile(&mut self.variables).unwrap();
+        self.inner.1 = Some(bp);
+
+        Instance::new(
+            &mut self.components,
+            &self.variables,
+            &self.inner.0.expressions,
+            &self.functions,
+            self.inner.1.as_ref(),
+            &self.widget_registry,
+            &mut self.dirty_elements,
+        )
+    }
+}
+
+impl<T> RunBuilder<T> {}
+
+pub struct Instance<'frame, 'bp> {
+    pub scope: Scope<'bp>,
+    attributes: AttributeRegistry<'bp>,
+    elements: Elements<'bp>,
+    components: &'frame mut Components,
+    variables: &'frame Variables,
+    expressions: &'bp Expressions,
+    functions: &'bp FunctionTable,
+    blueprint: Option<&'bp Blueprint>,
+    widget_registry: &'bp RegisteredWidgets,
+    runtime_expressions: RuntimeExpressions<'bp>,
+    dirty_elements: &'frame mut Vec<ElementId>,
+}
+
+impl<'frame, 'bp> Instance<'frame, 'bp> {
+    fn new(
+        components: &'frame mut Components,
+        variables: &'frame Variables,
+        expressions: &'bp Expressions,
+        functions: &'bp FunctionTable,
+        blueprint: Option<&'bp Blueprint>,
+        widget_registry: &'bp RegisteredWidgets,
+        dirty_elements: &'frame mut Vec<ElementId>,
+    ) -> Self {
+        Self {
+            scope: Scope::empty(),
+            attributes: AttributeRegistry::empty(),
+            elements: Elements::empty(),
+            runtime_expressions: RuntimeExpressions::empty(),
+            components,
+            variables,
+            expressions,
+            functions,
+            blueprint,
+            widget_registry,
+            dirty_elements,
+        }
+    }
+
+    pub fn run<F>(&mut self, f: F)
+    where
+        F: Fn(&mut EvalCtx<'_, '_>),
+    {
+        let mut eval_ctx = EvalCtx::new(
+            &mut self.elements,
+            &mut self.attributes,
+            &mut self.components,
+            &self.variables,
+            &self.expressions,
+            &self.functions,
+            &mut self.scope,
+            &mut self.runtime_expressions,
+            &mut self.dirty_elements,
+        );
+
+        f(&mut eval_ctx);
+    }
+
+    pub fn add_widget(&mut self, widget: impl Widget, parent: Option<ElementId>) -> ElementId {
+        let el = Element::Widget(RefCell::new(Box::new(widget)));
+        let id = self.elements.insert(el, parent);
+        self.attributes.insert(id, Attributes::empty());
+        id
+    }
+
+    pub(crate) fn eval<F>(&mut self, f: F)
+    where
+        F: Fn(&mut EvalCtx<'_, '_>),
+    {
+        let mut eval_ctx = EvalCtx::new(
+            &mut self.elements,
+            &mut self.attributes,
+            &mut self.components,
+            &self.variables,
+            &self.expressions,
+            &self.functions,
+            &mut self.scope,
+            &mut self.runtime_expressions,
+            &mut self.dirty_elements,
+        );
+
+        eval(self.blueprint.unwrap(), &mut eval_ctx, self.widget_registry, None).unwrap();
+        f(&mut eval_ctx);
+    }
+}
+
+// -----------------------------------------------------------------------------
+//   - Expression evaluator -
+// -----------------------------------------------------------------------------
+
+struct ExpressionEvaluatorComponent<S>(std::marker::PhantomData<S>);
+impl<S: State<ValueIndex>> Component for ExpressionEvaluatorComponent<S> {
+    type Message = ();
+    type State = S;
+}
+
+pub struct ExpressionEvaluator {
+    variables: Variables,
+    expressions: Expressions,
+    components: Components,
+    functions: FunctionTable,
+}
+
+impl ExpressionEvaluator {
+    pub fn new() -> Self {
+        Self {
+            variables: Variables::new(),
+            expressions: Expressions::empty(),
+            components: Components::empty(),
+            functions: FunctionTable::new(),
+        }
+    }
+
+    pub fn register_global(&mut self, ident: &str, value: impl Into<Expression>) {
+        self.variables.register_global(ident, value, &mut self.expressions);
+    }
+
+    pub fn eval<S: State<ValueIndex>, F, FA>(&mut self, expr: Expression, state: S, with_attribs: FA, f: F)
+    where
+        F: Fn(&TemplateValue<'_>),
+        FA: Fn(&mut Attributes<'_>),
+    {
+        let mut elements = Elements::empty();
+
+        let component = ExpressionEvaluatorComponent::<S>(Default::default());
+        let component = self
+            .components
+            .insert_component(ComponentBlueprintId::ZERO, component, state);
+        let parent = elements.insert(Element::Component(component), None);
+        let element = elements.insert(Element::Widget(test_widget("")), Some(parent));
+
+        let mut scope = Scope::empty();
+        scope.push_component(parent, component);
+        let expr_id = self.expressions.insert_at_root(expr);
+        let mut runtime_expressions = RuntimeExpressions::empty();
+
+        let mut attribute_reg = AttributeRegistry::empty();
+        let mut attributes = Attributes::empty();
+        with_attribs(&mut attributes);
+        attribute_reg.insert(parent, attributes);
+
+        let mut dirty_elements = vec![];
+
+        let mut ctx = EvalCtx::new(
+            &mut elements,
+            &mut attribute_reg,
+            &mut self.components,
+            &self.variables,
+            &self.expressions,
+            &self.functions,
+            &mut scope,
+            &mut runtime_expressions,
+            &mut dirty_elements,
+        );
+
+        let value = eval_by_id(expr_id, element, Some(parent.into()), &mut ctx);
+        f(&value);
+    }
+}
+
+// -----------------------------------------------------------------------------
+//   - Test widget -
+// -----------------------------------------------------------------------------
+
+fn test_widget(s: impl Into<String>) -> RefCell<Box<dyn Widget>> {
+    RefCell::new(Box::new(TestWidget(s.into())))
+}
+
+#[derive(Debug, Default)]
+pub struct TestWidget(pub String);
+
+impl Widget for TestWidget {
+    fn layout(&mut self, children: Children<'_, '_>, layout: &mut Layout) -> Size {
+        let mut size = Size::new(self.0.len() as u16, 1);
+
+        for mut child in children {
+            let child_size = child.layout(layout);
+            size.width = size.width.max(child_size.width);
+            size.height += child_size.height;
+        }
+
+        size
+    }
+
+    fn position(&mut self) -> Pos {
+        todo!()
+    }
+
+    fn paint(&mut self) {
+        todo!()
+    }
+
+    fn describe(&self) -> &str {
+        if self.0.is_empty() {
+            return "<test>";
+        }
+        &self.0
+    }
+}
diff --git a/anathema-core/src/ui/constraints.rs b/anathema-core/src/ui/constraints.rs
new file mode 100644
index 00000000..64472dbc
--- /dev/null
+++ b/anathema-core/src/ui/constraints.rs
@@ -0,0 +1,2 @@
+pub struct Constraints {
+}
diff --git a/anathema-core/src/ui/document.rs b/anathema-core/src/ui/document.rs
new file mode 100644
index 00000000..c4acc78a
--- /dev/null
+++ b/anathema-core/src/ui/document.rs
@@ -0,0 +1,68 @@
+use std::cell::RefCell;
+
+use crate::attributes::AttributeRegistry;
+use crate::runtime::elements::{Element, ElementId, Elements};
+use crate::layout::Layout;
+
+#[derive(Debug)]
+pub struct Document<'a, 'bp> {
+    elements: &'a mut Elements<'bp>,
+    layout: &'a mut Layout,
+    attributes: &'a mut AttributeRegistry<'bp>,
+}
+
+impl<'a, 'bp> Document<'a, 'bp> {
+    pub fn insert(&mut self, insert: (), parent: Option<ElementId>) -> ElementId {
+        panic!()
+        // let node_id = self.elements.apply_insert(insert, parent, self.layout, self.attributes);
+        // let node = self.elements.node(node_id);
+        // node.layout(self.layout);
+
+        // if let Some(parent) = parent {
+        //     self.elements[parent].children.push(node_id);
+        // }
+
+        // node_id
+    }
+
+    pub(crate) fn new(elements: &'a mut Elements<'bp>, layout: &'a mut Layout, attributes: &'a mut AttributeRegistry<'bp>) -> Self {
+        Self {
+            elements,
+            layout,
+            attributes,
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    // use super::*;
+    // use crate::testing::test_el;
+
+    // fn with_doc<F>(f: F)
+    // where
+    //     F: Fn(Document<'_>),
+    // {
+    //     let mut nodes = Elements::empty();
+    //     let mut layout = Layout::empty();
+    //     let mut attributes = AllAttributes::empty();
+
+    //     let doc = Document {
+    //         elements: &mut nodes,
+    //         layout: &mut layout,
+    //         attributes: &mut attributes,
+    //     };
+
+    //     f(doc);
+    // }
+
+    // #[test]
+    // fn insert_node() {
+    //     with_doc(|mut doc| {
+    //         let node = test_el("dad").add_child(test_el("baby"));
+    //         let parent = doc.insert(node, None);
+    //         doc.insert(test_el("other baby"), Some(parent));
+    //         panic!("{doc:#?}");
+    //     });
+    // }
+}
diff --git a/anathema-core/src/ui/layout.rs b/anathema-core/src/ui/layout.rs
new file mode 100644
index 00000000..e69de29b
diff --git a/anathema-core/src/ui/mod.rs b/anathema-core/src/ui/mod.rs
new file mode 100644
index 00000000..d4644037
--- /dev/null
+++ b/anathema-core/src/ui/mod.rs
@@ -0,0 +1,6 @@
+pub use document::Document;
+
+mod constraints;
+mod document;
+mod layout;
+mod query;
diff --git a/anathema-core/src/ui/query.rs b/anathema-core/src/ui/query.rs
new file mode 100644
index 00000000..dde489f8
--- /dev/null
+++ b/anathema-core/src/ui/query.rs
@@ -0,0 +1,13 @@
+pub trait Queryable {
+    fn by_tag(self) -> impl Queryable;
+}
+
+pub struct QueryBuilder<T> {
+    inner: T
+}
+
+impl<T> Queryable for QueryBuilder<T> {
+    fn by_tag(self) -> impl Queryable {
+        self
+    }
+}
diff --git a/anathema-debug/Cargo.toml b/anathema-debug/Cargo.toml
deleted file mode 100644
index 253f7f70..00000000
--- a/anathema-debug/Cargo.toml
+++ /dev/null
@@ -1,18 +0,0 @@
-[package]
-name = "anathema-debug"
-license = "MIT"
-description = "Debug utils for Anathema"
-version.workspace = true
-edition.workspace = true
-documentation = "https://togglebyte.github.io/anathema-guide/"
-homepage = "https://github.com/togglebyte/anathema"
-repository = "https://github.com/togglebyte/anathema"
-
-[dependencies]
-
-[features]
-default = []
-filelog = []
-
-[lints]
-workspace = true
diff --git a/anathema-debug/src/lib.rs b/anathema-debug/src/lib.rs
deleted file mode 100644
index cb0ead57..00000000
--- a/anathema-debug/src/lib.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-use std::fmt::{Result, Write};
-
-pub trait DebugWriter {
-    fn write(&mut self, output: &mut impl Write) -> Result;
-}
-
-pub struct Debug<O>(pub O);
-
-impl<O: Write> Debug<O> {
-    pub fn new(output: O) -> Self {
-        Self(output)
-    }
-
-    pub fn heading(mut self) -> Self {
-        let _ = writeln!(&mut self.0, "=== Debug ===");
-        self
-    }
-
-    pub fn debug(mut self, title: &str, mut item: impl DebugWriter) -> Self {
-        let _ = writeln!(&mut self.0, "--- {title} ---");
-        let _ = item.write(&mut self.0);
-        self
-    }
-
-    pub fn footer(mut self) -> Self {
-        let _ = writeln!(&mut self.0, "--- EO Debug ---");
-        self
-    }
-
-    pub fn sep(mut self) -> Self {
-        let _ = writeln!(&mut self.0, "----------------");
-        self
-    }
-
-    pub fn finish(self) -> O {
-        self.0
-    }
-}
-
-#[cfg(feature = "filelog")]
-pub mod macros {
-    #[macro_export]
-    macro_rules! debug_to_file {
-        ($($arg:tt)*) => {
-            use ::std::io::Write as _;
-            let mut file = std::fs::OpenOptions::new().create(true).append(true).open("/tmp/log.lol").unwrap();
-            let payload = format!($($arg)*);
-            file.write_all(payload.as_bytes()).unwrap();
-            file.write(b"\n").unwrap();
-            file.flush();
-        }
-    }
-
-    #[macro_export]
-    macro_rules! debug_tree {
-        ($tree:expr) => {
-            let mut d = anathema_widgets::tree::debug::DebugTree::new();
-            $tree.apply_visitor(&mut d);
-            $crate::debug_to_file!("{}", d.output);
-        };
-    }
-}
-
-#[cfg(not(feature = "filelog"))]
-pub mod macros {
-    #[macro_export]
-    macro_rules! debug_to_file {
-        ($($arg:tt)*) => {};
-    }
-
-    #[macro_export]
-    macro_rules! debug_tree {
-        ($tree:expr) => {};
-    }
-}
diff --git a/anathema-default-widgets/Cargo.toml b/anathema-default-widgets/Cargo.toml
deleted file mode 100644
index 21e59d7f..00000000
--- a/anathema-default-widgets/Cargo.toml
+++ /dev/null
@@ -1,23 +0,0 @@
-[package]
-name = "anathema-default-widgets"
-license = "MIT"
-description = "Default widget implementations for Anathema"
-version.workspace = true
-edition.workspace = true
-documentation = "https://togglebyte.github.io/anathema-guide/"
-homepage = "https://github.com/togglebyte/anathema"
-repository = "https://github.com/togglebyte/anathema"
-
-[dependencies]
-anathema-backend = { workspace = true }
-anathema-geometry = { workspace = true }
-anathema-state = { workspace = true }
-anathema-store = { workspace = true }
-anathema-templates = { workspace = true }
-anathema-value-resolver = { workspace = true }
-anathema-widgets = { workspace = true }
-bitflags = { workspace = true }
-unicode-width = { workspace = true }
-
-[lints]
-workspace = true
diff --git a/anathema-default-widgets/src/alignment.rs b/anathema-default-widgets/src/alignment.rs
deleted file mode 100644
index 53cfbf8e..00000000
--- a/anathema-default-widgets/src/alignment.rs
+++ /dev/null
@@ -1,229 +0,0 @@
-use std::ops::ControlFlow;
-
-use anathema_geometry::{Pos, Size};
-use anathema_value_resolver::AttributeStorage;
-use anathema_widgets::error::Result;
-use anathema_widgets::layout::{Constraints, LayoutCtx, PositionCtx};
-use anathema_widgets::{LayoutForEach, PositionChildren, Widget, WidgetId};
-
-use crate::layout::alignment::{ALIGNMENT, Alignment};
-
-#[derive(Default)]
-pub struct Align;
-
-impl Widget for Align {
-    fn layout<'bp>(
-        &mut self,
-        mut children: LayoutForEach<'_, 'bp>,
-        constraints: Constraints,
-        _: WidgetId,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-    ) -> Result<Size> {
-        _ = children.each(ctx, |ctx, widget, children| {
-            _ = widget.layout(children, constraints, ctx);
-            Ok(ControlFlow::Break(()))
-        })?;
-
-        Ok(constraints.max_size())
-    }
-
-    fn position<'bp>(
-        &mut self,
-        mut children: PositionChildren<'_, 'bp>,
-        id: WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        ctx: PositionCtx,
-    ) {
-        let attributes = attribute_storage.get(id);
-        let alignment = attributes.get_as::<Alignment>(ALIGNMENT).unwrap_or_default();
-
-        _ = children.each(|child, children| {
-            let width = ctx.inner_size.width as i32;
-            let height = ctx.inner_size.height as i32;
-            let child_width = child.size().width as i32;
-            let child_height = child.size().height as i32;
-
-            let child_offset = match alignment {
-                Alignment::TopLeft => Pos::ZERO,
-                Alignment::Top => Pos::new(width / 2 - child_width / 2, 0),
-                Alignment::TopRight => Pos::new(width - child_width, 0),
-                Alignment::Right => Pos::new(width - child_width, height / 2 - child_height / 2),
-                Alignment::BottomRight => Pos::new(width - child_width, height - child_height),
-                Alignment::Bottom => Pos::new(width / 2 - child_width / 2, height - child_height),
-                Alignment::BottomLeft => Pos::new(0, height - child_height),
-                Alignment::Left => Pos::new(0, height / 2 - child_height / 2),
-                Alignment::Centre => Pos::new(width / 2 - child_width / 2, height / 2 - child_height / 2),
-            };
-
-            child.position(children, ctx.pos + child_offset, attribute_storage, ctx.viewport);
-            ControlFlow::Break(())
-        });
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use crate::testing::TestRunner;
-
-    #[test]
-    fn top_left() {
-        let tpl = "
-            align [alignment: 'top_left']
-                text 'x'
-        ";
-
-        let expected = "
-            ╔═══╗
-            ║x  ║
-            ║   ║
-            ║   ║
-            ╚═══╝
-        ";
-
-        TestRunner::new(tpl, (3, 3)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn top() {
-        let tpl = "
-            align [alignment: 'top']
-                text 'x'
-        ";
-
-        let expected = "
-            ╔═══╗
-            ║ x ║
-            ║   ║
-            ║   ║
-            ╚═══╝
-        ";
-
-        TestRunner::new(tpl, (3, 3)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn top_right() {
-        let tpl = "
-            align [alignment: 'top_right']
-                text 'x'
-        ";
-
-        let expected = "
-            ╔═══╗
-            ║  x║
-            ║   ║
-            ║   ║
-            ╚═══╝
-        ";
-
-        TestRunner::new(tpl, (3, 3)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn right() {
-        let tpl = "
-            align [alignment: 'right']
-                text 'x'
-        ";
-
-        let expected = "
-            ╔═══╗
-            ║   ║
-            ║  x║
-            ║   ║
-            ╚═══╝
-        ";
-
-        TestRunner::new(tpl, (3, 3)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn bottom_right() {
-        let tpl = "
-            align [alignment: 'bottom_right']
-                text 'x'
-        ";
-
-        let expected = "
-            ╔═══╗
-            ║   ║
-            ║   ║
-            ║  x║
-            ╚═══╝
-        ";
-
-        TestRunner::new(tpl, (3, 3)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn bottom() {
-        let tpl = "
-            align [alignment: 'bottom']
-                text 'x'
-        ";
-
-        let expected = "
-            ╔═══╗
-            ║   ║
-            ║   ║
-            ║ x ║
-            ╚═══╝
-        ";
-
-        TestRunner::new(tpl, (3, 3)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn bottom_left() {
-        let tpl = "
-            align [alignment: 'bottom_left']
-                text 'x'
-        ";
-
-        let expected = "
-            ╔═══╗
-            ║   ║
-            ║   ║
-            ║x  ║
-            ╚═══╝
-        ";
-
-        TestRunner::new(tpl, (3, 3)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn left() {
-        let tpl = "
-            align [alignment: 'left']
-                text 'x'
-        ";
-
-        let expected = "
-            ╔═══╗
-            ║   ║
-            ║x  ║
-            ║   ║
-            ╚═══╝
-        ";
-
-        TestRunner::new(tpl, (3, 3)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn centre() {
-        let tpl = "
-            align [alignment: 'centre']
-                text 'x'
-        ";
-
-        let expected = "
-            ╔═══╗
-            ║   ║
-            ║ x ║
-            ║   ║
-            ╚═══╝
-        ";
-
-        TestRunner::new(tpl, (3, 3)).instance().render_assert(expected);
-    }
-}
diff --git a/anathema-default-widgets/src/border.rs b/anathema-default-widgets/src/border.rs
deleted file mode 100644
index cdf43a77..00000000
--- a/anathema-default-widgets/src/border.rs
+++ /dev/null
@@ -1,781 +0,0 @@
-use std::ops::ControlFlow;
-use std::str::FromStr;
-
-use anathema_geometry::{LocalPos, Pos, Region, Size};
-use anathema_value_resolver::{AttributeStorage, Attributes, ValueKind};
-use anathema_widgets::error::Result;
-use anathema_widgets::layout::{Constraints, LayoutCtx, PositionCtx};
-use anathema_widgets::paint::{Glyph, Glyphs, PaintCtx, SizePos};
-use anathema_widgets::{AnyWidget, LayoutForEach, PaintChildren, PositionChildren, Widget, WidgetId};
-
-use crate::layout::Axis;
-use crate::layout::border::BorderLayout;
-use crate::{HEIGHT, MAX_HEIGHT, MAX_WIDTH, MIN_HEIGHT, MIN_WIDTH, WIDTH};
-
-pub const BORDER_STYLE: &str = "border_style";
-
-// -----------------------------------------------------------------------------
-//     - Indices -
-//     Index into `DEFAULT_SLIM_EDGES` or `DEFAULT_THICK_EDGES`
-// -----------------------------------------------------------------------------
-pub const BORDER_EDGE_TOP_LEFT: usize = 0;
-pub const BORDER_EDGE_TOP: usize = 1;
-pub const BORDER_EDGE_TOP_RIGHT: usize = 2;
-pub const BORDER_EDGE_RIGHT: usize = 3;
-pub const BORDER_EDGE_BOTTOM_RIGHT: usize = 4;
-pub const BORDER_EDGE_BOTTOM: usize = 5;
-pub const BORDER_EDGE_BOTTOM_LEFT: usize = 6;
-pub const BORDER_EDGE_LEFT: usize = 7;
-
-// -----------------------------------------------------------------------------
-//     - Sides -
-// -----------------------------------------------------------------------------
-bitflags::bitflags! {
-    /// Border sides
-    /// ```ignore
-    /// let sides = Sides::TOP | Sides::LEFT;
-    /// ```
-    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-    pub struct Sides: u8 {
-        /// Empty
-        const EMPTY = 0x0;
-        /// Top border
-        const TOP = 0b0001;
-        /// Right border
-        const RIGHT = 0b0010;
-        /// Bottom border
-        const BOTTOM = 0b0100;
-        /// Left border
-        const LEFT = 0b1000;
-        /// All sides
-        const ALL = Self::TOP.bits() | Self::RIGHT.bits() | Self::BOTTOM.bits() | Self::LEFT.bits();
-    }
-}
-
-impl Default for Sides {
-    fn default() -> Self {
-        Self::ALL
-    }
-}
-
-impl TryFrom<&ValueKind<'_>> for Sides {
-    type Error = ();
-
-    fn try_from(value: &ValueKind<'_>) -> Result<Self, Self::Error> {
-        let mut sides = Sides::EMPTY;
-        match value {
-            ValueKind::Str(cow) => Sides::from_str(cow),
-            ValueKind::List(list) => {
-                for x in list {
-                    sides |= Sides::try_from(x)?;
-                }
-                Ok(sides)
-            }
-            ValueKind::DynList(value) => {
-                let Some(state) = value.as_state() else { return Err(()) };
-                let Some(list) = state.as_any_list() else { return Err(()) };
-                for i in 0..list.len() {
-                    if sides == Sides::ALL {
-                        break;
-                    }
-                    let value = list.lookup(i).ok_or(())?;
-                    let value = value.as_state().ok_or(())?;
-                    let s = value.as_str().ok_or(())?;
-                    sides |= Sides::from_str(s)?;
-                }
-                Ok(sides)
-            }
-            _ => Err(()),
-        }
-    }
-}
-
-impl FromStr for Sides {
-    type Err = ();
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let sides = match s {
-            "all" => Sides::ALL,
-            "top" => Sides::TOP,
-            "left" => Sides::LEFT,
-            "right" => Sides::RIGHT,
-            "bottom" => Sides::BOTTOM,
-            _ => Sides::EMPTY,
-        };
-        Ok(sides)
-    }
-}
-
-// -----------------------------------------------------------------------------
-//   - Border types -
-// -----------------------------------------------------------------------------
-pub const DEFAULT_SLIM_EDGES: [Glyph; 8] = [
-    Glyph::from_char('┌', 1),
-    Glyph::from_char('─', 1),
-    Glyph::from_char('┐', 1),
-    Glyph::from_char('│', 1),
-    Glyph::from_char('┘', 1),
-    Glyph::from_char('─', 1),
-    Glyph::from_char('└', 1),
-    Glyph::from_char('│', 1),
-];
-
-pub const DEFAULT_THICK_EDGES: [Glyph; 8] = [
-    Glyph::from_char('╔', 1),
-    Glyph::from_char('═', 1),
-    Glyph::from_char('╗', 1),
-    Glyph::from_char('║', 1),
-    Glyph::from_char('╝', 1),
-    Glyph::from_char('═', 1),
-    Glyph::from_char('╚', 1),
-    Glyph::from_char('║', 1),
-];
-
-pub const DEFAULT_ROUNDED_EDGES: [Glyph; 8] = [
-    Glyph::from_char('╭', 1),
-    Glyph::from_char('─', 1),
-    Glyph::from_char('╮', 1),
-    Glyph::from_char('│', 1),
-    Glyph::from_char('╯', 1),
-    Glyph::from_char('─', 1),
-    Glyph::from_char('╰', 1),
-    Glyph::from_char('│', 1),
-];
-
-/// The style of the border.
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
-pub enum BorderStyle {
-    /// ```text
-    /// ┌─────┐
-    /// │hello│
-    /// └─────┘
-    /// ```
-    #[default]
-    Thin,
-    /// ```text
-    /// ╔═════╗
-    /// ║hello║
-    /// ╚═════╝
-    /// ```
-    Thick,
-    /// ```text
-    /// 0111112
-    /// 7hello3
-    /// 6555554
-    /// ```
-    Rounded,
-    Custom([Glyph; 8]),
-}
-
-impl BorderStyle {
-    pub fn edges(&self) -> [Glyph; 8] {
-        match self {
-            BorderStyle::Thin => DEFAULT_SLIM_EDGES,
-            BorderStyle::Thick => DEFAULT_THICK_EDGES,
-            BorderStyle::Rounded => DEFAULT_ROUNDED_EDGES,
-            BorderStyle::Custom(edges) => *edges,
-        }
-    }
-}
-
-struct Brush {
-    glyph: Glyph,
-    width: u8,
-}
-
-impl Brush {
-    pub fn new(glyph: Glyph, width: u8) -> Self {
-        Self { width, glyph }
-    }
-}
-
-struct BorderPainter {
-    top: Line,
-    bottom: Line,
-    left: Line,
-    right: Line,
-}
-
-struct Line {
-    start_cap: Option<Brush>,
-    middle: Option<Brush>,
-    end_cap: Option<Brush>,
-    start: LocalPos,
-    end: u16,
-    axis: Axis,
-}
-
-impl Line {
-    fn will_draw(&self) -> bool {
-        self.start_cap.is_some() || self.end_cap.is_some() || self.middle.is_some()
-    }
-
-    fn draw<F>(&self, f: &mut F)
-    where
-        F: FnMut(LocalPos, Glyph),
-    {
-        let mut pos = self.start;
-        let mut end = self.end;
-
-        if let Some(brush) = &self.start_cap {
-            f(pos, brush.glyph);
-            match self.axis {
-                Axis::Horizontal => pos.x += brush.width as u16,
-                Axis::Vertical => pos.y += 1,
-            }
-        }
-
-        if let Some(brush) = &self.end_cap {
-            let pos = match self.axis {
-                Axis::Horizontal => {
-                    end -= brush.width as u16;
-                    LocalPos::new(end, pos.y)
-                }
-                Axis::Vertical => {
-                    end -= 1;
-                    LocalPos::new(pos.x, end)
-                }
-            };
-            f(pos, brush.glyph);
-        }
-
-        if let Some(brush) = &self.middle {
-            loop {
-                match self.axis {
-                    Axis::Horizontal => {
-                        if pos.x + brush.width as u16 > end {
-                            break;
-                        }
-                        f(pos, brush.glyph);
-                        pos.x += brush.width as u16;
-                    }
-                    Axis::Vertical => {
-                        if pos.y + 1 > end {
-                            break;
-                        }
-                        f(pos, brush.glyph);
-                        pos.y += 1;
-                    }
-                }
-            }
-        }
-    }
-}
-
-impl BorderPainter {
-    fn new(glyphs: &[Glyph; 8], border_size: BorderSize, size: Size) -> Self {
-        let mut height = size.height;
-
-        let top = Line {
-            start_cap: (border_size.top_left > 0).then(|| Brush::new(glyphs[0], border_size.top_left)),
-            middle: (border_size.top > 0).then(|| Brush::new(glyphs[1], border_size.top)),
-            end_cap: (border_size.top_right > 0).then(|| Brush::new(glyphs[2], border_size.top_right)),
-            start: LocalPos::ZERO,
-            axis: Axis::Horizontal,
-            end: size.width,
-        };
-
-        let bottom = Line {
-            start_cap: (border_size.bottom_left > 0).then(|| Brush::new(glyphs[6], border_size.bottom_left)),
-            middle: (border_size.bottom > 0).then(|| Brush::new(glyphs[5], border_size.bottom)),
-            end_cap: (border_size.bottom_right > 0).then(|| Brush::new(glyphs[4], border_size.bottom_right)),
-            start: LocalPos::new(0, height - 1),
-            axis: Axis::Horizontal,
-            end: size.width,
-        };
-
-        if bottom.will_draw() {
-            height -= 1;
-        }
-
-        let mut offset = 0;
-        if top.will_draw() {
-            offset += 1;
-        }
-
-        let left = Line {
-            start_cap: None,
-            middle: (border_size.left > 0).then(|| Brush::new(glyphs[7], border_size.left)),
-            end_cap: None,
-            start: LocalPos::new(0, offset),
-            axis: Axis::Vertical,
-            end: height,
-        };
-
-        let right = Line {
-            start_cap: None,
-            middle: (border_size.right > 0).then(|| Brush::new(glyphs[3], border_size.right)),
-            end_cap: None,
-            start: LocalPos::new(size.width - border_size.right as u16, offset),
-            axis: Axis::Vertical,
-            end: height,
-        };
-
-        Self {
-            top,
-            bottom,
-            left,
-            right,
-        }
-    }
-
-    fn paint<F>(&mut self, mut f: F)
-    where
-        F: FnMut(LocalPos, Glyph),
-    {
-        self.top.draw(&mut f);
-        self.bottom.draw(&mut f);
-        self.left.draw(&mut f);
-        self.right.draw(&mut f);
-    }
-}
-
-/// Width of every character that makes up the border
-#[derive(Debug, Default, Copy, Clone)]
-pub(crate) struct BorderSize {
-    pub top_left: u8,
-    pub top: u8,
-    pub top_right: u8,
-    pub right: u8,
-    pub bottom_right: u8,
-    pub bottom: u8,
-    pub bottom_left: u8,
-    pub left: u8,
-}
-
-impl BorderSize {
-    pub(crate) fn as_size(&self) -> Size {
-        let left_width = self.left.max(self.top_left).max(self.bottom_left) as u16;
-        let right_width = self.right.max(self.top_right).max(self.bottom_right) as u16;
-
-        Size::new(left_width + right_width, (self.top + self.bottom) as u16)
-    }
-}
-
-/// Draw a border around an element.
-///
-/// The border will size it self around the child if it has one.
-///
-/// If a width and / or a height is provided then the border will produce tight constraints
-/// for the child.
-///
-/// If a border has no size (width and height) and no child then nothing will be rendered.
-///
-/// To render a border with no child provide a width and a height.
-#[derive(Debug)]
-pub struct Border {
-    /// The border style decides the characters
-    /// to be used for each side of the border.
-    border_style: BorderStyle,
-    /// Which sides of the border should be rendered.
-    sides: Sides,
-    /// All the characters for the border, starting from the top left moving clockwise.
-    /// This means the top-left corner is `edges[0]`, the top if `edges[1]` and the top right is
-    /// `edges[2]` etc.
-    edges: [Glyph; 8],
-}
-
-impl Border {
-    // The additional size of the border
-    // to subtract from the constraint.
-    fn border_size(&self, sides: Sides) -> BorderSize {
-        // Get the size of the border (thickness).
-        // This is NOT including the child.
-
-        let mut border_size = BorderSize::default();
-
-        if sides.contains(Sides::LEFT | Sides::TOP) {
-            border_size.top_left = self.edges[BORDER_EDGE_TOP_LEFT].width() as u8;
-        }
-
-        if sides.contains(Sides::LEFT | Sides::BOTTOM) {
-            border_size.bottom_left = self.edges[BORDER_EDGE_BOTTOM_LEFT].width() as u8;
-        }
-
-        if sides.contains(Sides::RIGHT | Sides::BOTTOM) {
-            border_size.bottom_right = self.edges[BORDER_EDGE_BOTTOM_RIGHT].width() as u8;
-        }
-
-        if sides.contains(Sides::RIGHT | Sides::TOP) {
-            border_size.top_right = self.edges[BORDER_EDGE_TOP_RIGHT].width() as u8;
-        }
-
-        if sides.contains(Sides::LEFT) {
-            border_size.left = self.edges[BORDER_EDGE_LEFT].width() as u8;
-        }
-
-        if sides.contains(Sides::RIGHT) {
-            border_size.right = self.edges[BORDER_EDGE_RIGHT].width() as u8;
-        }
-
-        if sides.contains(Sides::TOP) {
-            border_size.top = self.edges[BORDER_EDGE_TOP].width() as u8;
-        }
-
-        if sides.contains(Sides::BOTTOM) {
-            border_size.bottom = self.edges[BORDER_EDGE_BOTTOM].width() as u8;
-        }
-
-        border_size
-    }
-}
-
-impl Widget for Border {
-    fn layout<'bp>(
-        &mut self,
-        children: LayoutForEach<'_, 'bp>,
-        constraints: Constraints,
-        id: WidgetId,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-    ) -> Result<Size> {
-        let attributes = ctx.attribute_storage.get_mut(id);
-
-        self.sides = attributes.get_as::<Sides>("sides").unwrap_or_default();
-
-        self.border_style = match attributes.get(BORDER_STYLE) {
-            None => BorderStyle::Thin,
-            Some(val) => {
-                let s = val.as_str();
-                let mut edges = DEFAULT_SLIM_EDGES;
-                let mut index = 0;
-
-                match s {
-                    Some("thin") | None => BorderStyle::default(),
-                    Some("thick") => BorderStyle::Thick,
-                    Some("rounded") => BorderStyle::Rounded,
-                    Some(s) => {
-                        let mut glyphs = Glyphs::new(s);
-                        while let Some(g) = glyphs.next(ctx.glyph_map) {
-                            edges[index] = g;
-                            index += 1;
-                            if index >= DEFAULT_SLIM_EDGES.len() {
-                                break;
-                            };
-                        }
-                        BorderStyle::Custom(edges)
-                    }
-                }
-            }
-        };
-        self.edges = self.border_style.edges();
-
-        let mut layout = BorderLayout {
-            min_width: attributes.get_as::<u16>(MIN_WIDTH),
-            min_height: attributes.get_as::<u16>(MIN_HEIGHT),
-            max_width: attributes.get_as::<u16>(MAX_WIDTH),
-            max_height: attributes.get_as::<u16>(MAX_HEIGHT),
-            height: attributes.get_as::<u16>(HEIGHT),
-            width: attributes.get_as::<u16>(WIDTH),
-            border_size: self.border_size(self.sides),
-        };
-
-        layout.layout(children, constraints, ctx)
-    }
-
-    fn position<'bp>(
-        &mut self,
-        mut children: PositionChildren<'_, 'bp>,
-        _: WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        mut ctx: PositionCtx,
-    ) {
-        _ = children.each(|child, children| {
-            if self.sides.contains(Sides::TOP) {
-                ctx.pos.y += 1;
-            }
-
-            if self.sides.contains(Sides::LEFT) {
-                ctx.pos.x += self.edges[BORDER_EDGE_LEFT].width() as i32;
-            }
-
-            child.position(children, ctx.pos, attribute_storage, ctx.viewport);
-            ControlFlow::Break(())
-        });
-    }
-
-    fn paint<'bp>(
-        &mut self,
-        mut children: PaintChildren<'_, 'bp>,
-        _id: WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        mut ctx: PaintCtx<'_, SizePos>,
-    ) {
-        let border_size = self.border_size(self.sides);
-
-        _ = children.each(|child, children| {
-            let ctx = ctx.to_unsized();
-            child.paint(children, ctx, attribute_storage);
-            ControlFlow::Break(())
-        });
-
-        // Draw the border
-        // Only draw corners if there are connecting sides:
-        // e.g Sides::Left | Sides::Top
-        //
-        // Don't draw corners if there are no connecting sides:
-        // e.g Sides::Top | Sides::Bottom
-
-        if ctx.local_size.width == 0 || ctx.local_size.height == 0 {
-            return;
-        }
-
-        let mut painter = BorderPainter::new(&self.edges, border_size, ctx.local_size);
-        let paint = |pos, glyph| {
-            ctx.place_glyph(glyph, pos);
-        };
-
-        painter.paint(paint);
-    }
-
-    fn inner_bounds(&self, mut pos: Pos, mut size: Size) -> Region {
-        let bs = self.border_size(self.sides);
-        pos.x += bs.top_left.max(bs.bottom_left).max(bs.left) as i32;
-        pos.y += bs.top as i32;
-        size.width = size
-            .width
-            .saturating_sub(bs.top_right.max(bs.bottom_right).max(bs.right) as u16);
-        size.height = size.height.saturating_sub(bs.bottom as u16);
-        Region::from((pos, size))
-    }
-}
-
-pub(crate) fn make(attributes: &Attributes<'_>) -> Box<dyn AnyWidget> {
-    let sides = attributes.get_as::<Sides>("sides").unwrap_or_default();
-
-    let text = Border {
-        sides,
-        edges: DEFAULT_SLIM_EDGES,
-        border_style: BorderStyle::Thin,
-    };
-
-    Box::new(text)
-}
-//}
-
-#[cfg(test)]
-mod test {
-    use crate::testing::TestRunner;
-
-    #[test]
-    fn thin_border() {
-        let tpl = "border [width: 6, height: 4]";
-
-        let expected = "
-            ╔════════╗
-            ║┌────┐  ║
-            ║│    │  ║
-            ║│    │  ║
-            ║└────┘  ║
-            ║        ║
-            ║        ║
-            ╚════════╝
-        ";
-
-        TestRunner::new(tpl, (8, 6)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn thick_border() {
-        let tpl = "border [width: 6, height: 4, border_style: 'thick']";
-
-        let expected = "
-            ╔════════╗
-            ║╔════╗  ║
-            ║║    ║  ║
-            ║║    ║  ║
-            ║╚════╝  ║
-            ║        ║
-            ║        ║
-            ╚════════╝
-        ";
-
-        TestRunner::new(tpl, (8, 6)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn custom_border() {
-        let tpl = "border [width: 6, height: 4, border_style: '╔─╗│╝─╚│']";
-
-        let expected = "
-            ╔════════╗
-            ║╔────╗  ║
-            ║│    │  ║
-            ║│    │  ║
-            ║╚────╝  ║
-            ║        ║
-            ║        ║
-            ╚════════╝
-        ";
-
-        TestRunner::new(tpl, (8, 6)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn border_top() {
-        let tpl = "border [sides: 'top', width: 6, height: 4, border_style: '╔─╗│╝─╚│']";
-
-        let expected = "
-            ╔════════╗
-            ║──────  ║
-            ║        ║
-            ║        ║
-            ║        ║
-            ║        ║
-            ║        ║
-            ╚════════╝
-        ";
-
-        TestRunner::new(tpl, (8, 6)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn border_top_bottom() {
-        let tpl = "border [sides: 'bottom', width: 6, height: 4, border_style: '╔─╗│╝─╚│']";
-
-        let expected = "
-            ╔════════╗
-            ║        ║
-            ║        ║
-            ║        ║
-            ║──────  ║
-            ║        ║
-            ║        ║
-            ╚════════╝
-        ";
-
-        TestRunner::new(tpl, (8, 6)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn border_left() {
-        let tpl = "border [sides: 'left', width: 6, height: 4, border_style: '╔─╗│╝─╚│']";
-
-        let expected = "
-            ╔════════╗
-            ║│       ║
-            ║│       ║
-            ║│       ║
-            ║│       ║
-            ║        ║
-            ║        ║
-            ╚════════╝
-        ";
-
-        TestRunner::new(tpl, (8, 6)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn border_right() {
-        let tpl = "border [sides: 'right', width: 6, height: 4, border_style: '╔─╗│╝─╚│']";
-
-        let expected = "
-            ╔════════╗
-            ║     │  ║
-            ║     │  ║
-            ║     │  ║
-            ║     │  ║
-            ║        ║
-            ║        ║
-            ╚════════╝
-        ";
-
-        TestRunner::new(tpl, (8, 6)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn border_top_left() {
-        let tpl = "border [sides: ['top', 'left'], width: 6, height: 4, border_style: '╔─╗│╝─╚│']";
-
-        let expected = "
-            ╔════════╗
-            ║╔─────  ║
-            ║│       ║
-            ║│       ║
-            ║│       ║
-            ║        ║
-            ║        ║
-            ╚════════╝
-        ";
-
-        TestRunner::new(tpl, (8, 6)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn border_bottom_right() {
-        let tpl = "border [sides: ['bottom', 'right'], width: 6, height: 4]";
-
-        let expected = "
-            ╔════════╗
-            ║     │  ║
-            ║     │  ║
-            ║     │  ║
-            ║─────┘  ║
-            ║        ║
-            ║        ║
-            ╚════════╝
-        ";
-
-        TestRunner::new(tpl, (8, 6)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn unsized_empty_border() {
-        let tpl = "
-            border [sides: '']
-                text 'hi'
-        ";
-
-        let expected = "
-            ╔════════╗
-            ║hi      ║
-            ║        ║
-            ║        ║
-            ║        ║
-            ╚════════╝
-        ";
-
-        TestRunner::new(tpl, (8, 4)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn sized_by_child() {
-        let tpl = "
-            border 
-                text 'hello world'
-            ";
-
-        let expected = "
-            ╔════════╗
-            ║┌──────┐║
-            ║│hello │║
-            ║│world │║
-            ║└──────┘║
-            ║        ║
-            ║        ║
-            ╚════════╝
-        ";
-
-        TestRunner::new(tpl, (8, 6)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn fixed_size() {
-        let tpl = "
-            border [width: 3 + 2, height: 2 + 2]
-                text 'hello world'
-            ";
-
-        let expected = "
-            ╔════════╗
-            ║┌───┐   ║
-            ║│hel│   ║
-            ║│lo │   ║
-            ║└───┘   ║
-            ║        ║
-            ║        ║
-            ╚════════╝
-        ";
-
-        TestRunner::new(tpl, (8, 6)).instance().render_assert(expected);
-    }
-}
diff --git a/anathema-default-widgets/src/canvas.rs b/anathema-default-widgets/src/canvas.rs
deleted file mode 100644
index fb5ac677..00000000
--- a/anathema-default-widgets/src/canvas.rs
+++ /dev/null
@@ -1,348 +0,0 @@
-use anathema_geometry::{LocalPos, Pos, Size};
-use anathema_value_resolver::AttributeStorage;
-use anathema_widgets::error::Result;
-use anathema_widgets::layout::{Constraints, LayoutCtx, PositionCtx};
-use anathema_widgets::paint::{Glyph, PaintCtx, SizePos};
-use anathema_widgets::{LayoutForEach, PaintChildren, PositionChildren, Style, Widget, WidgetId};
-use unicode_width::UnicodeWidthChar;
-
-use crate::{HEIGHT, WIDTH};
-
-#[derive(Debug, Default, Clone, Copy)]
-enum Cell {
-    #[default]
-    Empty,
-    Occupied(char, Style),
-}
-
-#[derive(Debug, Default)]
-pub struct CanvasBuffer {
-    positions: Box<[Cell]>,
-    size: Size,
-}
-
-impl CanvasBuffer {
-    pub fn new(size: Size) -> Self {
-        Self {
-            positions: vec![Cell::Empty; size.area()].into_boxed_slice(),
-            size,
-        }
-    }
-
-    fn put(&mut self, c: char, style: Style, pos: impl Into<LocalPos>) {
-        let pos = pos.into();
-
-        if pos.x >= self.size.width || pos.y >= self.size.height {
-            return;
-        }
-        let index = pos.to_index(self.size.width);
-
-        let mut cell = Cell::Occupied(c, style);
-        std::mem::swap(&mut self.positions[index], &mut cell);
-    }
-
-    fn get(&self, pos: impl Into<LocalPos>) -> Option<&Cell> {
-        let pos = pos.into();
-        if pos.x >= self.size.width || pos.y >= self.size.height {
-            return None;
-        }
-
-        let index = pos.to_index(self.size.width);
-        match self.positions.get(index)? {
-            cell @ Cell::Occupied(..) => Some(cell),
-            Cell::Empty => None,
-        }
-    }
-
-    fn get_mut(&mut self, pos: impl Into<LocalPos>) -> Option<&mut Cell> {
-        let pos = pos.into();
-        if pos.x >= self.size.width || pos.y >= self.size.height {
-            return None;
-        }
-
-        let index = pos.to_index(self.size.width);
-        match self.positions.get_mut(index)? {
-            cell @ Cell::Occupied(..) => Some(cell),
-            Cell::Empty => None,
-        }
-    }
-
-    fn remove(&mut self, pos: impl Into<LocalPos>) {
-        let pos = pos.into();
-        if pos.x >= self.size.width || pos.y >= self.size.height {
-            return;
-        }
-
-        let index = pos.to_index(self.size.width);
-        if index < self.positions.len() {
-            let mut cell = Cell::Empty;
-            std::mem::swap(&mut self.positions[index], &mut cell);
-        }
-    }
-
-    fn copy_from(other: &mut CanvasBuffer, size: Size) -> Self {
-        let mut new_buffer = CanvasBuffer::new(size);
-
-        for (pos, c, attrs) in other.drain() {
-            if pos.x >= size.width || pos.y >= size.height {
-                continue;
-            }
-            new_buffer.put(c, attrs, pos);
-        }
-
-        new_buffer
-    }
-
-    fn drain(&mut self) -> impl Iterator<Item = (LocalPos, char, Style)> + '_ {
-        self.positions.iter_mut().enumerate().filter_map(|(index, cell)| {
-            let mut old = Cell::Empty;
-            std::mem::swap(&mut old, cell);
-            //
-            match old {
-                Cell::Empty => None,
-                Cell::Occupied(c, attribs) => {
-                    let y = index as u16 / self.size.width;
-                    let x = index as u16 % self.size.width;
-                    let pos = LocalPos::new(x, y);
-                    Some((pos, c, attribs))
-                }
-            }
-        })
-    }
-
-    fn iter(&self) -> impl Iterator<Item = (LocalPos, char, &Style)> + '_ {
-        self.positions.iter().enumerate().filter_map(|(index, cell)| {
-            let x = index as u16 % self.size.width;
-            let y = index as u16 / self.size.width;
-            let pos = LocalPos::new(x, y);
-            //
-            match cell {
-                Cell::Empty => None,
-                Cell::Occupied(c, attribs) => Some((pos, *c, attribs)),
-            }
-        })
-    }
-
-    pub fn clear(&mut self) {
-        *self = Self::new(self.size);
-    }
-}
-
-#[derive(Debug)]
-pub struct Canvas {
-    buffer: CanvasBuffer,
-    pos: Pos,
-    is_dirty: bool,
-}
-
-impl Canvas {
-    pub fn restore_buffer(&mut self, buffer: &mut CanvasBuffer) {
-        self.buffer = std::mem::take(buffer);
-    }
-
-    pub fn take_buffer(&mut self) -> CanvasBuffer {
-        std::mem::take(&mut self.buffer)
-    }
-
-    pub fn translate(&self, pos: Pos) -> LocalPos {
-        let offset = pos - self.pos;
-        LocalPos::new(offset.x as u16, offset.y as u16)
-    }
-
-    pub fn put(&mut self, c: char, style: Style, pos: impl Into<LocalPos>) {
-        self.is_dirty = true;
-        self.buffer.put(c, style, pos);
-    }
-
-    pub fn get(&mut self, pos: impl Into<LocalPos>) -> Option<(char, Style)> {
-        match self.buffer.get(pos).copied()? {
-            Cell::Occupied(c, style) => Some((c, style)),
-            Cell::Empty => None,
-        }
-    }
-
-    pub fn get_mut(&mut self, pos: impl Into<LocalPos>) -> Option<(&mut char, &mut Style)> {
-        match self.buffer.get_mut(pos)? {
-            Cell::Occupied(c, style) => {
-                self.is_dirty = true;
-                Some((c, style))
-            }
-            Cell::Empty => None,
-        }
-    }
-
-    pub fn erase(&mut self, pos: impl Into<LocalPos>) {
-        self.is_dirty = true;
-        self.buffer.remove(pos)
-    }
-
-    pub fn clear(&mut self) {
-        self.buffer.clear();
-    }
-}
-
-impl Default for Canvas {
-    fn default() -> Self {
-        Self {
-            buffer: CanvasBuffer::new((32, 32).into()),
-            pos: Pos::ZERO,
-            is_dirty: true,
-        }
-    }
-}
-
-impl Widget for Canvas {
-    fn layout<'bp>(
-        &mut self,
-        _: LayoutForEach<'_, 'bp>,
-        mut constraints: Constraints,
-        id: WidgetId,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-    ) -> Result<Size> {
-        let attribs = ctx.attribute_storage.get(id);
-
-        if let Some(width) = attribs.get_as::<u16>(WIDTH) {
-            constraints.set_max_width(width);
-        }
-
-        if let Some(height) = attribs.get_as::<u16>(HEIGHT) {
-            constraints.set_max_height(height);
-        }
-
-        let size = constraints.max_size();
-
-        if self.buffer.size != size {
-            self.buffer = CanvasBuffer::copy_from(&mut self.buffer, size);
-        }
-
-        Ok(size)
-    }
-
-    fn position<'bp>(
-        &mut self,
-        _: PositionChildren<'_, 'bp>,
-        _id: WidgetId,
-        _attribute_storage: &AttributeStorage<'bp>,
-        ctx: PositionCtx,
-    ) {
-        self.pos = ctx.pos;
-    }
-
-    fn paint<'bp>(
-        &mut self,
-        _children: PaintChildren<'_, 'bp>,
-        _id: WidgetId,
-        _attribute_storage: &AttributeStorage<'bp>,
-        mut ctx: PaintCtx<'_, SizePos>,
-    ) {
-        for (pos, c, style) in self.buffer.iter() {
-            ctx.set_style(*style, pos);
-            let glyph = Glyph::from_char(c, c.width().unwrap_or(0) as u8);
-            ctx.place_glyph(glyph, pos);
-        }
-    }
-
-    fn needs_reflow(&mut self) -> bool {
-        let needs_reflow = self.is_dirty;
-        self.is_dirty = false;
-        needs_reflow
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::testing::TestRunner;
-
-    #[test]
-    fn resize_canvas() {
-        let expected = "
-            ╔══╗
-            ║  ║
-            ║  ║
-            ╚══╝
-        ";
-        TestRunner::new("canvas", (2, 2)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn get_set_glyph() {
-        let mut canvas = Canvas::default();
-        canvas.put('a', Style::reset(), (0, 0));
-        let (c, _) = canvas.get((0, 0)).unwrap();
-        assert_eq!(c, 'a');
-    }
-
-    #[test]
-    fn remove_glyph() {
-        let mut canvas = Canvas::default();
-        canvas.put('a', Style::reset(), (0, 0));
-        assert!(canvas.get((0, 0)).is_some());
-        canvas.erase((0, 0));
-        assert!(canvas.get((0, 0)).is_none());
-    }
-
-    #[test]
-    fn put_buffer_out_of_range() {
-        let mut under_test = Canvas {
-            buffer: CanvasBuffer::new(Size::new(1, 2)),
-            ..Default::default()
-        };
-
-        under_test.put('x', Style::reset(), LocalPos::new(0, 0));
-        under_test.put('x', Style::reset(), LocalPos::new(0, 1));
-        under_test.put('o', Style::reset(), LocalPos::new(1, 0));
-
-        for cell in under_test.buffer.positions {
-            match cell {
-                Cell::Empty => panic!("Should not be empty"),
-                Cell::Occupied(c, _) => assert_eq!(c, 'x'),
-            }
-        }
-    }
-
-    #[test]
-    fn get_buffer_out_of_range() {
-        let mut under_test = Canvas {
-            buffer: CanvasBuffer::new(Size::new(1, 2)),
-            ..Default::default()
-        };
-
-        under_test.put('x', Style::reset(), LocalPos::new(0, 0));
-        under_test.put('x', Style::reset(), LocalPos::new(0, 1));
-
-        assert!(under_test.get(LocalPos::new(1, 0)).is_none());
-    }
-
-    #[test]
-    fn get_mut_buffer_out_of_range() {
-        let mut under_test = Canvas {
-            buffer: CanvasBuffer::new(Size::new(1, 2)),
-            ..Default::default()
-        };
-
-        under_test.put('x', Style::reset(), LocalPos::new(0, 0));
-        under_test.put('x', Style::reset(), LocalPos::new(0, 1));
-
-        assert!(under_test.get_mut(LocalPos::new(1, 0)).is_none());
-    }
-
-    #[test]
-    fn remove_buffer_out_of_range() {
-        let mut under_test = Canvas {
-            buffer: CanvasBuffer::new(Size::new(1, 2)),
-            ..Default::default()
-        };
-
-        under_test.put('x', Style::reset(), LocalPos::new(0, 0));
-        under_test.put('x', Style::reset(), LocalPos::new(0, 1));
-        under_test.erase(LocalPos::new(1, 0));
-
-        for cell in under_test.buffer.positions {
-            match cell {
-                Cell::Empty => panic!("Should not be empty"),
-                Cell::Occupied(c, _) => assert_eq!(c, 'x'),
-            }
-        }
-    }
-}
diff --git a/anathema-default-widgets/src/container.rs b/anathema-default-widgets/src/container.rs
deleted file mode 100644
index fff44960..00000000
--- a/anathema-default-widgets/src/container.rs
+++ /dev/null
@@ -1,95 +0,0 @@
-use std::ops::ControlFlow;
-
-use anathema_geometry::Size;
-use anathema_value_resolver::AttributeStorage;
-use anathema_widgets::error::Result;
-use anathema_widgets::layout::{Constraints, LayoutCtx, PositionCtx};
-use anathema_widgets::{LayoutForEach, PositionChildren, Widget, WidgetId};
-
-use crate::{HEIGHT, MAX_HEIGHT, MAX_WIDTH, MIN_HEIGHT, MIN_WIDTH, WIDTH};
-
-#[derive(Debug, Default)]
-pub struct Container;
-
-impl Widget for Container {
-    fn layout<'bp>(
-        &mut self,
-        mut children: LayoutForEach<'_, 'bp>,
-        mut constraints: Constraints,
-        id: WidgetId,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-    ) -> Result<Size> {
-        let mut size = Size::ZERO;
-
-        let attribs = ctx.attribute_storage.get(id);
-
-        if let Some(width) = attribs.get_as::<u16>(WIDTH) {
-            constraints.make_width_tight(width);
-        }
-
-        if let Some(height) = attribs.get_as::<u16>(HEIGHT) {
-            constraints.make_height_tight(height);
-        }
-
-        if let Some(width) = attribs.get_as::<u16>(MIN_WIDTH) {
-            constraints.min_width = width;
-        }
-
-        if let Some(height) = attribs.get_as::<u16>(MIN_HEIGHT) {
-            constraints.min_height = height;
-        }
-
-        if let Some(width) = attribs.get_as::<u16>(MAX_WIDTH) {
-            constraints.set_max_width(width);
-        }
-
-        if let Some(height) = attribs.get_as::<u16>(MAX_HEIGHT) {
-            constraints.set_max_height(height);
-        }
-
-        _ = children.each(ctx, |ctx, child, children| {
-            size = child.layout(children, constraints, ctx)?.into();
-            Ok(ControlFlow::Break(()))
-        })?;
-
-        size.width = size.width.max(constraints.min_width);
-        size.height = size.height.max(constraints.min_height);
-
-        Ok(size)
-    }
-
-    fn position<'bp>(
-        &mut self,
-        mut children: PositionChildren<'_, 'bp>,
-        _id: WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        ctx: PositionCtx,
-    ) {
-        _ = children.each(|child, children| {
-            child.position(children, ctx.pos, attribute_storage, ctx.viewport);
-            ControlFlow::Break(())
-        });
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use crate::testing::TestRunner;
-
-    #[test]
-    fn container() {
-        let tpl = "
-            container
-                text 'a'
-        ";
-
-        let expected = "
-            ╔══════╗
-            ║a     ║
-            ║      ║
-            ╚══════╝
-        ";
-
-        TestRunner::new(tpl, (6, 2)).instance().render_assert(expected);
-    }
-}
diff --git a/anathema-default-widgets/src/expand.rs b/anathema-default-widgets/src/expand.rs
deleted file mode 100644
index d1f2a3d8..00000000
--- a/anathema-default-widgets/src/expand.rs
+++ /dev/null
@@ -1,117 +0,0 @@
-use std::ops::ControlFlow;
-
-use anathema_geometry::Size;
-use anathema_value_resolver::AttributeStorage;
-use anathema_widgets::error::Result;
-use anathema_widgets::layout::{Constraints, LayoutCtx, PositionCtx};
-use anathema_widgets::paint::{PaintCtx, SizePos};
-use anathema_widgets::{LayoutForEach, PaintChildren, PositionChildren, Widget, WidgetId};
-
-use crate::layout::{Axis, single_layout};
-
-#[derive(Debug, Default)]
-pub struct Expand;
-
-impl Widget for Expand {
-    fn layout<'bp>(
-        &mut self,
-        children: LayoutForEach<'_, 'bp>,
-        constraints: Constraints,
-        id: WidgetId,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-    ) -> Result<Size> {
-        let mut size = single_layout(children, constraints, ctx)?;
-
-        let attributes = ctx.attribute_storage.get(id);
-        match attributes.get_as::<Axis>("axis") {
-            Some(Axis::Horizontal) => size.width = constraints.max_width(),
-            Some(Axis::Vertical) => size.height = constraints.max_height(),
-            None => {
-                size.width = constraints.max_width();
-                size.height = constraints.max_height();
-            }
-        }
-
-        Ok(size)
-    }
-
-    fn position<'bp>(
-        &mut self,
-        mut children: PositionChildren<'_, 'bp>,
-        _attributes: WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        ctx: PositionCtx,
-    ) {
-        _ = children.each(|node, children| {
-            node.position(children, ctx.pos, attribute_storage, ctx.viewport);
-            ControlFlow::Break(())
-        });
-    }
-
-    fn paint<'bp>(
-        &mut self,
-        mut children: PaintChildren<'_, 'bp>,
-        _: WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        mut ctx: PaintCtx<'_, SizePos>,
-    ) {
-        _ = children.each(|child, children| {
-            let ctx = ctx.to_unsized();
-            child.paint(children, ctx, attribute_storage);
-            ControlFlow::Break(())
-        });
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use crate::testing::TestRunner;
-
-    #[test]
-    fn hstack_expand_nospace() {
-        let tpl = "
-        border
-            container [width:12]
-                hstack
-                    expand
-                    text 'this is text'
-        ";
-
-        let expected = "
-            ╔══════════════╗
-            ║┌────────────┐║
-            ║│this is text│║
-            ║│            │║
-            ║└────────────┘║
-            ╚══════════════╝
-        ";
-
-        let mut runner = TestRunner::new(tpl, (14, 4));
-        let mut runner = runner.instance();
-        runner.render_assert(expected);
-    }
-
-    #[test]
-    fn vstack_expand_nospace() {
-        let tpl = "
-        border
-            container [height:1]
-                vstack
-                    expand
-                    text 'this is text'
-        ";
-
-        let expected = "
-            ╔═════════════════╗
-            ║┌───────────────┐║
-            ║│this is text   │║
-            ║└───────────────┘║
-            ║                 ║
-            ╚═════════════════╝
-        ";
-
-        let mut runner = TestRunner::new(tpl, (17, 4));
-        let mut runner = runner.instance();
-        runner.render_assert(expected);
-    }
-}
diff --git a/anathema-default-widgets/src/layout/alignment.rs b/anathema-default-widgets/src/layout/alignment.rs
deleted file mode 100644
index 70c7ad6b..00000000
--- a/anathema-default-widgets/src/layout/alignment.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-use anathema_value_resolver::ValueKind;
-
-pub const ALIGNMENT: &str = "alignment";
-
-/// Word wrapping strategy
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Default)]
-pub enum Alignment {
-    #[default]
-    TopLeft,
-    Top,
-    TopRight,
-    Right,
-    BottomRight,
-    Bottom,
-    BottomLeft,
-    Left,
-    Centre,
-}
-
-impl TryFrom<&ValueKind<'_>> for Alignment {
-    type Error = ();
-
-    fn try_from(value: &ValueKind<'_>) -> Result<Self, Self::Error> {
-        match value {
-            ValueKind::Str(wrap) => match wrap.as_ref() {
-                "top_left" => Ok(Alignment::TopLeft),
-                "top" => Ok(Alignment::Top),
-                "top_right" => Ok(Alignment::TopRight),
-                "right" => Ok(Alignment::Right),
-                "left" => Ok(Alignment::Left),
-                "bottom_left" => Ok(Alignment::BottomLeft),
-                "bottom" => Ok(Alignment::Bottom),
-                "bottom_right" => Ok(Alignment::BottomRight),
-                "centre" | "center" => Ok(Alignment::Centre),
-                _ => Err(()),
-            },
-            _ => Err(()),
-        }
-    }
-}
diff --git a/anathema-default-widgets/src/layout/border.rs b/anathema-default-widgets/src/layout/border.rs
deleted file mode 100644
index ea1f2a7e..00000000
--- a/anathema-default-widgets/src/layout/border.rs
+++ /dev/null
@@ -1,88 +0,0 @@
-use std::ops::ControlFlow;
-
-use anathema_geometry::Size;
-use anathema_widgets::LayoutForEach;
-use anathema_widgets::error::Result;
-use anathema_widgets::layout::{Constraints, LayoutCtx};
-
-use crate::border::BorderSize;
-
-pub struct BorderLayout {
-    pub min_width: Option<u16>,
-    pub min_height: Option<u16>,
-    pub max_width: Option<u16>,
-    pub max_height: Option<u16>,
-    pub width: Option<u16>,
-    pub height: Option<u16>,
-    pub border_size: BorderSize,
-}
-
-impl BorderLayout {
-    pub(crate) fn layout<'bp>(
-        &mut self,
-        mut children: LayoutForEach<'_, 'bp>,
-        mut constraints: Constraints,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-    ) -> Result<Size> {
-        let mut size = Size::ZERO;
-
-        if let Some(min_width) = self.min_width {
-            constraints.min_width = constraints.min_width.max(min_width);
-        }
-
-        if let Some(min_height) = self.min_height {
-            constraints.min_height = constraints.min_height.max(min_height);
-        }
-
-        if let Some(width) = self.max_width {
-            constraints.set_max_width(width);
-        }
-
-        if let Some(height) = self.max_height {
-            constraints.set_max_height(height);
-        }
-
-        // If there is a width / height then make the constraints tight
-        // around the size. This will modify the size to fit within the
-        // constraints first.
-        if let Some(width) = self.width {
-            constraints.set_max_width(width);
-            size.width = width;
-        }
-
-        if let Some(height) = self.height {
-            constraints.set_max_height(height);
-            size.height = height;
-        }
-
-        let border_size = self.border_size;
-
-        let mut child_constraints = constraints;
-
-        _ = children.each(ctx, |ctx, child, children| {
-            // Shrink the constraint for the child to fit inside the border
-
-            // border [min-width: 10]
-            //     border [min-width: 18]
-            //         ...
-
-            // border [max-width: 8]
-            //     border [min-width: 10]
-            //         ...
-
-            child_constraints.sub_max_width((border_size.left + border_size.right) as u16);
-            child_constraints.sub_max_height((border_size.top + border_size.bottom) as u16);
-            let mut child_size = Size::from(child.layout(children, child_constraints, ctx)?);
-            child_size += border_size.as_size();
-            size.width = child_size.width.max(size.width);
-            size.height = child_size.height.max(size.height);
-
-            Ok(ControlFlow::Break(()))
-        })?;
-
-        size.width = constraints.min_width.max(size.width).min(constraints.max_width());
-        size.height = constraints.min_height.max(size.height).min(constraints.max_height());
-
-        Ok(size)
-    }
-}
diff --git a/anathema-default-widgets/src/layout/expand.rs b/anathema-default-widgets/src/layout/expand.rs
deleted file mode 100644
index 9edbb96c..00000000
--- a/anathema-default-widgets/src/layout/expand.rs
+++ /dev/null
@@ -1,117 +0,0 @@
-use std::ops::ControlFlow;
-
-use anathema_geometry::Size;
-use anathema_widgets::LayoutForEach;
-use anathema_widgets::error::Result;
-use anathema_widgets::layout::{Constraints, LayoutCtx};
-
-use super::Axis;
-
-const DEFAULT_FACTOR: u16 = 1;
-
-/// Distributes the total size over a list of weights
-///
-/// It uses the [Huntington-Hill method](https://en.wikipedia.org/wiki/Huntington%E2%80%93Hill_method)
-///
-/// Panics when called with more weights than the total number of available size.
-/// Allocates a minimum of one to each weight.
-fn distribute_size(weights: &[u16], mut total: u16) -> Vec<u16> {
-    let mut indexed = weights
-        .iter()
-        .copied()
-        .enumerate()
-        .map(|(i, w)| (i, w, 0u16))
-        .collect::<Vec<_>>();
-
-    fn pop(n: &mut u16) -> bool {
-        if let Some(nn) = n.checked_sub(1) {
-            *n = nn;
-            true
-        } else {
-            false
-        }
-    }
-
-    while pop(&mut total) {
-        indexed.sort_by_cached_key(|&(_, w, r)| (((w as f64) / ((r * (r + 1)) as f64).sqrt()) * -10000.) as isize);
-        indexed[0].2 += 1;
-    }
-
-    indexed.sort_by_key(|&(i, ..)| i);
-    indexed.into_iter().map(|(_, _, r)| r).collect()
-}
-
-pub fn layout_all_expansions<'bp>(
-    nodes: &mut LayoutForEach<'_, 'bp>,
-    constraints: Constraints,
-    axis: Axis,
-    ctx: &mut LayoutCtx<'_, 'bp>,
-) -> Result<Size> {
-    let mut factors = vec![];
-
-    _ = nodes.each(ctx, |ctx, node, _children| {
-        if node.ident == "expand" {
-            let attributes = ctx.attribute_storage.get(node.id());
-            let factor = attributes.get_as::<u16>("factor").unwrap_or(DEFAULT_FACTOR);
-            factors.push(factor);
-        }
-
-        Ok(ControlFlow::Continue(()))
-    })?;
-
-    let mut size = Size::ZERO;
-
-    if factors.is_empty() {
-        return Ok(size);
-    }
-
-    // Distribute the available space
-    let sizes = match axis {
-        Axis::Horizontal => distribute_size(&factors, constraints.max_width()),
-        Axis::Vertical => distribute_size(&factors, constraints.max_height()),
-    };
-
-    let mut index = 0;
-    _ = nodes.each(ctx, |ctx, node, children| {
-        if node.ident != "expand" {
-            return Ok(ControlFlow::Continue(()));
-        }
-
-        let sub_size = sizes[index];
-        index += 1;
-
-        let constraints = match axis {
-            Axis::Horizontal => {
-                let mut constraints = Constraints::new(sub_size, constraints.max_height());
-
-                // Ensure that the rounding doesn't push the constraint outside of the max width
-                constraints.min_width = constraints.min_width.min(constraints.max_width());
-                constraints
-            }
-            Axis::Vertical => {
-                let mut constraints = Constraints::new(constraints.max_width(), sub_size);
-
-                // Ensure that the rounding doesn't push the constraint outside of the max height
-                constraints.min_height = constraints.min_height.min(constraints.max_height());
-                constraints
-            }
-        };
-
-        let widget_size = Size::from(node.layout(children, constraints, ctx)?);
-
-        match axis {
-            Axis::Horizontal => {
-                size.width += widget_size.width;
-                size.height = size.height.max(widget_size.height);
-            }
-            Axis::Vertical => {
-                size.width = size.width.max(widget_size.width);
-                size.height += widget_size.height;
-            }
-        }
-
-        Ok(ControlFlow::Continue(()))
-    })?;
-
-    Ok(size)
-}
diff --git a/anathema-default-widgets/src/layout/many.rs b/anathema-default-widgets/src/layout/many.rs
deleted file mode 100644
index bc2c217c..00000000
--- a/anathema-default-widgets/src/layout/many.rs
+++ /dev/null
@@ -1,155 +0,0 @@
-use std::ops::ControlFlow;
-
-use anathema_geometry::Size;
-use anathema_widgets::LayoutForEach;
-use anathema_widgets::error::Result;
-use anathema_widgets::layout::{Constraints, LayoutCtx};
-
-use super::{Axis, Direction, expand, spacers};
-
-pub(crate) struct SizeMod {
-    inner: Size,
-    max_size: Size,
-    axis: Axis,
-}
-
-impl SizeMod {
-    const ZERO: Self = Self::new(Size::ZERO, Axis::Vertical);
-
-    const fn new(max_size: Size, axis: Axis) -> Self {
-        Self {
-            inner: Size::ZERO,
-            max_size,
-            axis,
-        }
-    }
-
-    fn apply(&mut self, size: Size) {
-        match self.axis {
-            Axis::Vertical => {
-                self.inner.width = self.inner.width.max(size.width);
-                self.inner.height = (self.inner.height + size.height).min(self.max_size.height);
-            }
-            Axis::Horizontal => {
-                self.inner.height = self.inner.height.max(size.height);
-                self.inner.width = (self.inner.width + size.width).min(self.max_size.width);
-            }
-        }
-    }
-
-    fn no_space_left(&self) -> bool {
-        match self.axis {
-            Axis::Horizontal => self.inner.width >= self.max_size.width,
-            Axis::Vertical => self.inner.height >= self.max_size.height,
-        }
-    }
-
-    fn to_constraints(&self) -> Constraints {
-        match self.axis {
-            Axis::Horizontal => Constraints::new(self.max_size.width - self.inner.width, self.max_size.height),
-            Axis::Vertical => Constraints::new(self.max_size.width, self.max_size.height - self.inner.height),
-        }
-    }
-
-    pub fn inner_size(&self) -> Size {
-        self.inner
-    }
-}
-
-pub struct Many {
-    pub direction: Direction,
-    pub axis: Axis,
-    unconstrained: bool,
-    pub(crate) used_size: SizeMod,
-}
-
-impl Many {
-    pub fn new(direction: Direction, axis: Axis, unconstrained: bool) -> Self {
-        Self {
-            direction,
-            axis,
-            unconstrained,
-            used_size: SizeMod::ZERO,
-        }
-    }
-}
-
-impl Many {
-    pub(crate) fn layout<'bp>(
-        &mut self,
-        mut children: LayoutForEach<'_, 'bp>,
-        constraints: Constraints,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-    ) -> Result<Size> {
-        let max_constraints = constraints;
-
-        self.used_size.axis = self.axis;
-        self.used_size.max_size = Size::new(max_constraints.max_width(), max_constraints.max_height());
-
-        let mut size = Size::ZERO;
-
-        _ = children.each(ctx, |ctx, node, children| {
-            if ["spacer", "expand"].contains(&node.ident) {
-                return Ok(ControlFlow::Continue(()));
-            }
-
-            let widget_constraints = {
-                let mut constraints = self.used_size.to_constraints();
-                if self.unconstrained {
-                    match self.axis {
-                        Axis::Vertical => constraints.unbound_height(),
-                        Axis::Horizontal => constraints.unbound_width(),
-                    }
-                }
-                constraints
-            };
-
-            let widget_size = node.layout(children, widget_constraints, ctx)?.into();
-
-            self.used_size.apply(widget_size);
-
-            match self.used_size.no_space_left() {
-                true => Ok(ControlFlow::Break(())),
-                false => Ok(ControlFlow::Continue(())),
-            }
-        })?;
-
-        let constraints = self.used_size.to_constraints();
-        let expanded_size = expand::layout_all_expansions(&mut children, constraints, self.axis, ctx)?;
-        self.used_size.apply(expanded_size);
-
-        let constraints = self.used_size.to_constraints();
-        let spacer_size = spacers::layout_all_spacers(&mut children, constraints, self.axis, ctx)?;
-        self.used_size.apply(spacer_size);
-
-        size.width = self.used_size.inner.width.max(max_constraints.min_width);
-        size.height = (self.used_size.inner.height).max(max_constraints.min_height);
-
-        match self.axis {
-            Axis::Vertical => {
-                size.width = self.used_size.inner.width.max(max_constraints.min_width);
-                size.height = (self.used_size.inner.height).max(max_constraints.min_height);
-            }
-            Axis::Horizontal => {
-                size.height = size.height.max(self.used_size.inner.height);
-                size.height = size
-                    .height
-                    .max(self.used_size.inner.height)
-                    .max(max_constraints.min_height);
-                size.width = size
-                    .width
-                    .max(self.used_size.inner.width)
-                    .max(max_constraints.min_width);
-            }
-        }
-
-        if let Direction::Backward = self.direction {
-            match self.axis {
-                Axis::Horizontal => size.width = max_constraints.max_width(),
-                Axis::Vertical => size.height = max_constraints.max_height(),
-            }
-        }
-
-        Ok(size)
-    }
-}
diff --git a/anathema-default-widgets/src/layout/mod.rs b/anathema-default-widgets/src/layout/mod.rs
deleted file mode 100644
index 1dfcec70..00000000
--- a/anathema-default-widgets/src/layout/mod.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-use std::ops::ControlFlow;
-
-use anathema_geometry::Size;
-use anathema_value_resolver::ValueKind;
-use anathema_widgets::LayoutForEach;
-use anathema_widgets::error::Result;
-use anathema_widgets::layout::{Constraints, LayoutCtx};
-
-pub static DIRECTION: &str = "direction";
-pub static AXIS: &str = "axis";
-
-pub(crate) mod alignment;
-pub(crate) mod border;
-pub(crate) mod expand;
-pub(crate) mod many;
-mod spacers;
-
-pub(crate) fn single_layout<'bp>(
-    mut children: LayoutForEach<'_, 'bp>,
-    constraints: Constraints,
-    ctx: &mut LayoutCtx<'_, 'bp>,
-) -> Result<Size> {
-    let mut size = Size::ZERO;
-
-    _ = children.each(ctx, |ctx, node, children| {
-        size = node.layout(children, constraints, ctx)?.into();
-        Ok(ControlFlow::Break(()))
-    })?;
-
-    Ok(size)
-}
-
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub enum Axis {
-    Horizontal,
-    Vertical,
-}
-
-impl TryFrom<&ValueKind<'_>> for Axis {
-    type Error = ();
-
-    fn try_from(value: &ValueKind<'_>) -> Result<Self, Self::Error> {
-        let s = value.as_str().ok_or(())?;
-        match s {
-            "horz" | "horizontal" => Ok(Self::Horizontal),
-            "vert" | "vertical" => Ok(Self::Vertical),
-            _ => Err(()),
-        }
-    }
-}
-
-#[derive(Debug, Copy, Clone, Default, PartialEq)]
-pub enum Direction {
-    #[default]
-    Forward,
-    Backward,
-}
-
-impl TryFrom<&ValueKind<'_>> for Direction {
-    type Error = ();
-
-    fn try_from(value: &ValueKind<'_>) -> Result<Self, Self::Error> {
-        let s = value.as_str().ok_or(())?;
-        match s {
-            "fwd" | "forward" | "forwards" => Ok(Self::Forward),
-            "back" | "backward" | "backwards" => Ok(Self::Backward),
-            _ => Err(()),
-        }
-    }
-}
diff --git a/anathema-default-widgets/src/layout/spacers.rs b/anathema-default-widgets/src/layout/spacers.rs
deleted file mode 100644
index 319a18c2..00000000
--- a/anathema-default-widgets/src/layout/spacers.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-use std::ops::ControlFlow;
-
-use anathema_geometry::Size;
-use anathema_widgets::LayoutForEach;
-use anathema_widgets::error::Result;
-use anathema_widgets::layout::{Constraints, LayoutCtx};
-
-use super::Axis;
-
-/// Layout spacers.
-/// This is different to [`SpacerLayout`] which
-/// does the layout of the child of a single [`Spacer`],
-/// whereas this does the layout of multiple [`Spacer`]s
-/// inside already evaluated children.
-pub fn layout_all_spacers<'bp>(
-    nodes: &mut LayoutForEach<'_, 'bp>,
-    constraints: Constraints,
-    axis: Axis,
-    ctx: &mut LayoutCtx<'_, 'bp>,
-) -> Result<Size> {
-    let mut final_size = Size::ZERO;
-    let mut count = 0;
-
-    _ = nodes.each(ctx, |_, node, _| {
-        if node.ident == "spacer" {
-            count += 1;
-        }
-        Ok(ControlFlow::Continue(()))
-    })?;
-
-    if count == 0 {
-        return Ok(final_size);
-    }
-
-    let max = match axis {
-        Axis::Horizontal => constraints.max_width(),
-        Axis::Vertical => constraints.max_height(),
-    };
-
-    let mut overflow = max % count;
-
-    _ = nodes.each(ctx, |ctx, node, children| {
-        if node.ident != "spacer" {
-            return Ok(ControlFlow::Continue(()));
-        }
-
-        // This is a bit gross
-        let overflow = if overflow > 0 {
-            overflow -= 1;
-            1
-        } else {
-            0
-        };
-
-        let constraints = match axis {
-            Axis::Horizontal => constraints.div_assign_max_width(count, overflow),
-            Axis::Vertical => constraints.div_assign_max_height(count, overflow),
-        };
-
-        let size = Size::from(node.layout(children, constraints, ctx)?);
-
-        match axis {
-            Axis::Horizontal => {
-                final_size.width += size.width;
-                final_size.height = final_size.height.max(size.height);
-            }
-            Axis::Vertical => {
-                final_size.height += size.height;
-                final_size.width = final_size.width.max(size.width);
-            }
-        }
-
-        Ok(ControlFlow::Continue(()))
-    })?;
-
-    Ok(final_size)
-}
diff --git a/anathema-default-widgets/src/lib.rs b/anathema-default-widgets/src/lib.rs
deleted file mode 100644
index 9a5b0305..00000000
--- a/anathema-default-widgets/src/lib.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-#[allow(unused_extern_crates)]
-extern crate anathema_state as anathema;
-use anathema_widgets::Factory;
-
-mod alignment;
-mod border;
-mod canvas;
-mod container;
-mod expand;
-mod layout;
-mod overflow;
-mod padding;
-mod position;
-mod spacer;
-mod stacks;
-mod text;
-
-#[cfg(test)]
-mod testing;
-
-pub(crate) const WIDTH: &str = "width";
-pub(crate) const HEIGHT: &str = "height";
-pub(crate) const MIN_WIDTH: &str = "min_width";
-pub(crate) const MIN_HEIGHT: &str = "min_height";
-pub(crate) const MAX_WIDTH: &str = "max_width";
-pub(crate) const MAX_HEIGHT: &str = "max_height";
-pub(crate) const TOP: &str = "top";
-pub(crate) const RIGHT: &str = "right";
-pub(crate) const BOTTOM: &str = "bottom";
-pub(crate) const LEFT: &str = "left";
-
-pub use alignment::Align;
-pub use border::Border;
-pub use canvas::{Canvas, CanvasBuffer};
-pub use expand::Expand;
-pub use overflow::Overflow;
-pub use padding::Padding;
-pub use position::Position;
-pub use stacks::{Column, HStack, Row, VStack};
-pub use text::Text;
-
-pub fn register_default_widgets(factory: &mut Factory) {
-    factory.register_default::<alignment::Align>("align");
-    factory.register_default::<expand::Expand>("expand");
-    factory.register_default::<canvas::Canvas>("canvas");
-    factory.register_default::<container::Container>("container");
-    factory.register_default::<padding::Padding>("padding");
-    factory.register_default::<position::Position>("position");
-    factory.register_default::<stacks::Column>("column");
-    factory.register_default::<spacer::Spacer>("spacer");
-    factory.register_default::<stacks::HStack>("hstack");
-    factory.register_default::<stacks::Row>("row");
-    factory.register_default::<stacks::VStack>("vstack");
-    factory.register_default::<stacks::ZStack>("zstack");
-    factory.register_default::<text::Span>("span");
-    factory.register_default::<text::Text>("text");
-    factory.register_default::<overflow::Overflow>("overflow");
-    factory.register_widget("border", border::make);
-}
diff --git a/anathema-default-widgets/src/overflow.rs b/anathema-default-widgets/src/overflow.rs
deleted file mode 100644
index 1a869c49..00000000
--- a/anathema-default-widgets/src/overflow.rs
+++ /dev/null
@@ -1,303 +0,0 @@
-use std::ops::ControlFlow;
-
-use anathema_geometry::{Pos, Size};
-use anathema_value_resolver::AttributeStorage;
-use anathema_widgets::error::Result;
-use anathema_widgets::layout::{Constraints, LayoutCtx, PositionCtx};
-use anathema_widgets::paint::{PaintCtx, SizePos};
-use anathema_widgets::{LayoutForEach, PaintChildren, PositionChildren, Widget, WidgetId};
-
-use crate::layout::many::Many;
-use crate::layout::{AXIS, Axis, DIRECTION, Direction};
-use crate::{HEIGHT, WIDTH};
-
-const UNCONSTRAINED: &str = "unconstrained";
-const CLAMP: &str = "clamp";
-
-#[derive(Debug, Default)]
-pub struct Overflow {
-    offset: Pos,
-    // The size of the children since the last layout call
-    inner_size: Size,
-
-    direction: Direction,
-    is_dirty: bool,
-}
-
-impl Overflow {
-    pub fn scroll(&mut self, direction: Direction, amount: Pos) {
-        self.is_dirty = true;
-
-        match (self.direction, direction) {
-            (Direction::Forward, Direction::Forward) => self.offset += amount,
-            (Direction::Forward, Direction::Backward) => self.offset -= amount,
-            (Direction::Backward, Direction::Backward) => self.offset += amount,
-            (Direction::Backward, Direction::Forward) => self.offset -= amount,
-        }
-    }
-
-    pub fn scroll_up(&mut self) {
-        self.scroll(Direction::Backward, Pos { x: 0, y: 1 });
-    }
-
-    pub fn scroll_up_by(&mut self, amount: i32) {
-        self.scroll(Direction::Backward, Pos { x: 0, y: amount });
-    }
-
-    pub fn scroll_down(&mut self) {
-        self.scroll(Direction::Forward, Pos { x: 0, y: 1 });
-    }
-
-    pub fn scroll_down_by(&mut self, amount: i32) {
-        self.scroll(Direction::Forward, Pos { x: 0, y: amount });
-    }
-
-    pub fn scroll_right(&mut self) {
-        self.scroll(Direction::Forward, Pos { x: 1, y: 0 });
-    }
-
-    pub fn scroll_right_by(&mut self, amount: i32) {
-        self.scroll(Direction::Forward, Pos { x: amount, y: 0 });
-    }
-
-    pub fn scroll_left(&mut self) {
-        self.scroll(Direction::Backward, Pos { x: 1, y: 0 });
-    }
-
-    pub fn scroll_left_by(&mut self, amount: i32) {
-        self.scroll(Direction::Backward, Pos { x: amount, y: 0 });
-    }
-
-    pub fn scroll_to(&mut self, pos: Pos) {
-        self.offset = pos;
-    }
-
-    pub fn offset(&self) -> Pos {
-        self.offset
-    }
-
-    fn clamp(&mut self, children: Size, parent: Size) {
-        if self.offset.x < 0 {
-            self.offset.x = 0;
-        }
-
-        if self.offset.y < 0 {
-            self.offset.y = 0;
-        }
-
-        if children.height <= parent.height {
-            self.offset.y = 0;
-        } else {
-            let max_y = children.height as i32 - parent.height as i32;
-            if self.offset.y > max_y {
-                self.offset.y = max_y;
-            }
-        }
-
-        if children.width <= parent.width {
-            self.offset.x = 0;
-        } else {
-            let max_x = children.width as i32 - parent.width as i32;
-            if self.offset.x > max_x {
-                self.offset.x = max_x
-            }
-        }
-    }
-}
-
-impl Widget for Overflow {
-    fn layout<'bp>(
-        &mut self,
-        children: LayoutForEach<'_, 'bp>,
-        mut constraints: Constraints,
-        id: WidgetId,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-    ) -> Result<Size> {
-        let attributes = ctx.attribute_storage.get(id);
-        let axis = attributes.get_as(AXIS).unwrap_or(Axis::Vertical);
-
-        let output_size: Size = (constraints.max_width(), constraints.max_height()).into();
-
-        match axis {
-            Axis::Horizontal => constraints.unbound_width(),
-            Axis::Vertical => constraints.unbound_height(),
-        }
-
-        if attributes.get_as::<bool>(UNCONSTRAINED).unwrap_or_default() {
-            constraints.unbound_width();
-            constraints.unbound_height();
-        }
-
-        if let Some(width) = attributes.get_as::<u16>(WIDTH) {
-            constraints.make_width_tight(width);
-        }
-
-        if let Some(height) = attributes.get_as::<u16>(HEIGHT) {
-            constraints.make_height_tight(height);
-        }
-
-        self.direction = attributes.get_as(DIRECTION).unwrap_or_default();
-
-        // Make `unconstrained` an enum instead of a `bool`
-        let unconstrained = true;
-        let mut many = Many::new(self.direction, axis, unconstrained);
-
-        // NOTE: we use the inner size here from many.layout
-        _ = many.layout(children, constraints, ctx)?;
-
-        self.inner_size = many.used_size.inner_size();
-
-        Ok(output_size)
-    }
-
-    fn position<'bp>(
-        &mut self,
-        mut children: PositionChildren<'_, 'bp>,
-        id: WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        ctx: PositionCtx,
-    ) {
-        let attributes = attribute_storage.get(id);
-        let direction = attributes.get_as(DIRECTION).unwrap_or_default();
-        let axis = attributes.get_as(AXIS).unwrap_or(Axis::Vertical);
-        let mut pos = ctx.pos;
-
-        // If the value is clamped, update the offset
-        match attributes.get_as::<bool>(CLAMP).unwrap_or(true) {
-            false => (),
-            true => self.clamp(self.inner_size, ctx.inner_size),
-        }
-
-        if let Direction::Backward = direction {
-            match axis {
-                Axis::Horizontal => pos.x += ctx.inner_size.width as i32,
-                Axis::Vertical => pos.y += ctx.inner_size.height as i32,
-            }
-        }
-
-        let mut pos = match direction {
-            Direction::Forward => pos - self.offset,
-            Direction::Backward => pos + self.offset,
-        };
-
-        let mut count = 0;
-        _ = children.each(|node, children| {
-            match direction {
-                Direction::Forward => {
-                    node.position(children, pos, attribute_storage, ctx.viewport);
-                    match axis {
-                        Axis::Horizontal => pos.x += node.size().width as i32,
-                        Axis::Vertical => pos.y += node.size().height as i32,
-                    }
-                }
-                Direction::Backward => {
-                    match axis {
-                        Axis::Horizontal => pos.x -= node.size().width as i32,
-                        Axis::Vertical => pos.y -= node.size().height as i32,
-                    }
-                    node.position(children, pos, attribute_storage, ctx.viewport);
-                }
-            }
-
-            count += 1;
-            ControlFlow::Continue(())
-        });
-    }
-
-    fn paint<'bp>(
-        &mut self,
-        mut children: PaintChildren<'_, 'bp>,
-        _: WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        mut ctx: PaintCtx<'_, SizePos>,
-    ) {
-        let region = ctx.create_region();
-
-        _ = children.each(|widget, children| {
-            ctx.set_clip_region(region);
-            let ctx = ctx.to_unsized();
-            widget.paint(children, ctx, attribute_storage);
-            ControlFlow::Continue(())
-        });
-    }
-
-    fn needs_reflow(&mut self) -> bool {
-        let needs_reflow = self.is_dirty;
-        self.is_dirty = false;
-        needs_reflow
-    }
-}
-
-#[cfg(test)]
-mod test {
-
-    use crate::Overflow;
-    use crate::testing::TestRunner;
-
-    #[test]
-    fn overflow() {
-        let tpl = "
-    overflow
-        for i in [0, 1, 2]
-            border
-                text i
-";
-
-        let expected_first = "
-    ╔═══╗
-    ║┌─┐║
-    ║│0│║
-    ║└─┘║
-    ║┌─┐║
-    ║│1│║
-    ║└─┘║
-    ╚═══╝
-";
-
-        let expected_second = "
-    ╔═══╗
-    ║│0│║
-    ║└─┘║
-    ║┌─┐║
-    ║│1│║
-    ║└─┘║
-    ║┌─┐║
-    ╚═══╝
-";
-
-        TestRunner::new(tpl, (3, 6))
-            .instance()
-            .render_assert(expected_first)
-            .with_widget(|mut query| {
-                query.by_tag("overflow").first(|el, _| {
-                    let overflow = el.to::<Overflow>();
-                    overflow.scroll_down();
-                });
-            })
-            .render_assert(expected_second);
-    }
-
-    #[test]
-    fn clamp_prevents_scrolling() {
-        let tpl = "
-    overflow
-        text '0'";
-
-        let expected_first = "
-    ╔═══╗
-    ║0  ║
-    ║   ║
-    ╚═══╝
-";
-
-        TestRunner::new(tpl, (3, 2))
-            .instance()
-            .with_widget(|mut query| {
-                query.by_tag("overflow").first(|el, _| {
-                    let overflow = el.to::<Overflow>();
-                    overflow.scroll_down();
-                });
-            })
-            .render_assert(expected_first);
-    }
-}
diff --git a/anathema-default-widgets/src/padding.rs b/anathema-default-widgets/src/padding.rs
deleted file mode 100644
index 80f1d8cb..00000000
--- a/anathema-default-widgets/src/padding.rs
+++ /dev/null
@@ -1,293 +0,0 @@
-use std::ops::ControlFlow;
-
-use anathema_geometry::{Pos, Region, Size};
-use anathema_value_resolver::AttributeStorage;
-use anathema_widgets::error::Result;
-use anathema_widgets::layout::{Constraints, LayoutCtx, PositionCtx};
-use anathema_widgets::paint::{PaintCtx, SizePos};
-use anathema_widgets::{LayoutForEach, PaintChildren, PositionChildren, Widget, WidgetId};
-
-use crate::{BOTTOM, LEFT, RIGHT, TOP};
-
-const PADDING: &str = "padding";
-
-#[derive(Default)]
-struct PaddingValues {
-    top: u16,
-    right: u16,
-    bottom: u16,
-    left: u16,
-}
-
-impl PaddingValues {
-    fn size(&self) -> Size {
-        Size::new(self.left + self.right, self.top + self.bottom)
-    }
-}
-
-#[derive(Default)]
-pub struct Padding(PaddingValues);
-
-impl Widget for Padding {
-    fn layout<'bp>(
-        &mut self,
-        mut children: LayoutForEach<'_, 'bp>,
-        constraints: Constraints,
-        id: WidgetId,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-    ) -> Result<Size> {
-        let attributes = ctx.attribute_storage.get(id);
-        let mut size = Size::ZERO;
-        let padding = attributes.get_as::<u16>(PADDING).unwrap_or(0);
-
-        self.0.top = attributes
-            .get_as::<usize>(TOP)
-            .and_then(|v| v.try_into().ok())
-            .unwrap_or(padding);
-        self.0.right = attributes
-            .get_as::<usize>(RIGHT)
-            .and_then(|v| v.try_into().ok())
-            .unwrap_or(padding);
-        self.0.bottom = attributes
-            .get_as::<usize>(BOTTOM)
-            .and_then(|v| v.try_into().ok())
-            .unwrap_or(padding);
-        self.0.left = attributes
-            .get_as::<usize>(LEFT)
-            .and_then(|v| v.try_into().ok())
-            .unwrap_or(padding);
-
-        let padding_size = self.0.size();
-
-        _ = children.each(ctx, |ctx, child, children| {
-            let mut child_constraints = constraints;
-            child_constraints.sub_max_width(padding_size.width);
-            child_constraints.sub_max_height(padding_size.height);
-            let mut child_size = Size::from(child.layout(children, child_constraints, ctx)?);
-            child_size += padding_size;
-            size.width = child_size.width.max(size.width);
-            size.height = child_size.height.max(size.height);
-
-            Ok(ControlFlow::Break(()))
-        })?;
-
-        size.width = constraints.min_width.max(size.width).min(constraints.max_width());
-        size.height = constraints.min_height.max(size.height).min(constraints.max_height());
-
-        Ok(size)
-    }
-
-    fn position<'bp>(
-        &mut self,
-        mut children: PositionChildren<'_, 'bp>,
-        _: WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        mut ctx: PositionCtx,
-    ) {
-        _ = children.each(|child, children| {
-            ctx.pos.y += self.0.top as i32;
-            ctx.pos.x += self.0.left as i32;
-
-            child.position(children, ctx.pos, attribute_storage, ctx.viewport);
-            ControlFlow::Break(())
-        });
-    }
-
-    fn paint<'bp>(
-        &mut self,
-        mut children: PaintChildren<'_, 'bp>,
-        _id: WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        mut ctx: PaintCtx<'_, SizePos>,
-    ) {
-        _ = children.each(|child, children| {
-            let mut ctx = ctx.to_unsized();
-            if let Some(clip) = ctx.clip.as_mut() {
-                clip.from.x += self.0.left as i32;
-                clip.from.y += self.0.top as i32;
-                clip.to.x -= self.0.right as i32;
-                clip.to.y -= self.0.bottom as i32;
-            }
-            child.paint(children, ctx, attribute_storage);
-            ControlFlow::Break(())
-        });
-    }
-
-    fn inner_bounds(&self, mut pos: Pos, mut size: Size) -> Region {
-        pos.x += self.0.left as i32;
-        pos.y += self.0.top as i32;
-        size.width = size.width.saturating_sub(self.0.right);
-        size.height = size.height.saturating_sub(self.0.bottom);
-        Region::from((pos, size))
-    }
-}
-
-#[cfg(test)]
-mod test {
-
-    use crate::testing::TestRunner;
-
-    #[test]
-    fn padding_all() {
-        let tpl = "
-            padding [padding: 1]
-                text 'a'
-        ";
-
-        let expected = "
-            ╔═══╗
-            ║   ║
-            ║ a ║
-            ║   ║
-            ╚═══╝
-        ";
-
-        TestRunner::new(tpl, (3, 3)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn padding_top_inclusive() {
-        let tpl = "
-            padding [padding: 1, top: 2]
-                text 'a'
-        ";
-
-        let expected = "
-            ╔════╗
-            ║    ║
-            ║    ║
-            ║ a  ║
-            ║    ║
-            ╚════╝
-        ";
-
-        TestRunner::new(tpl, (4, 4)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn padding_top() {
-        let tpl = "
-            padding [top: 2]
-                text 'a'
-        ";
-
-        let expected = "
-            ╔════╗
-            ║    ║
-            ║    ║
-            ║a   ║
-            ╚════╝
-        ";
-
-        TestRunner::new(tpl, (4, 3)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn padding_right_inclusive() {
-        let tpl = "
-            padding [padding: 1, right: 2]
-                text 'a'
-        ";
-
-        let expected = "
-            ╔════╗
-            ║    ║
-            ║ a  ║
-            ║    ║
-            ╚════╝
-        ";
-
-        TestRunner::new(tpl, (4, 3)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn padding_right() {
-        let tpl = "
-            padding [right: 2]
-                text 'a'
-        ";
-
-        let expected = "
-            ╔════╗
-            ║a   ║
-            ║    ║
-            ║    ║
-            ╚════╝
-        ";
-
-        TestRunner::new(tpl, (4, 3)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn padding_bottom_inclusive() {
-        let tpl = "
-            padding [padding: 1, bottom: 2]
-                text 'a'
-        ";
-
-        let expected = "
-            ╔════╗
-            ║    ║
-            ║ a  ║
-            ║    ║
-            ║    ║
-            ╚════╝
-        ";
-
-        TestRunner::new(tpl, (4, 4)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn padding_bottom() {
-        let tpl = "
-            padding [bottom: 2]
-                text 'a'
-        ";
-
-        let expected = "
-            ╔════╗
-            ║a   ║
-            ║    ║
-            ║    ║
-            ╚════╝
-        ";
-
-        TestRunner::new(tpl, (4, 3)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn padding_left_inclusive() {
-        let tpl = "
-            padding [padding: 1, left: 2]
-                text 'a'
-        ";
-
-        let expected = "
-            ╔════╗
-            ║    ║
-            ║  a ║
-            ║    ║
-            ╚════╝
-        ";
-
-        TestRunner::new(tpl, (4, 3)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn padding_left() {
-        let tpl = "
-            padding [left: 2]
-                text 'a'
-        ";
-
-        let expected = "
-            ╔════╗
-            ║  a ║
-            ║    ║
-            ║    ║
-            ╚════╝
-        ";
-
-        TestRunner::new(tpl, (4, 3)).instance().render_assert(expected);
-    }
-}
diff --git a/anathema-default-widgets/src/position.rs b/anathema-default-widgets/src/position.rs
deleted file mode 100644
index 4f039a3e..00000000
--- a/anathema-default-widgets/src/position.rs
+++ /dev/null
@@ -1,282 +0,0 @@
-use std::ops::ControlFlow;
-
-use anathema_geometry::{Pos, Size};
-use anathema_value_resolver::{AttributeStorage, ValueKind};
-use anathema_widgets::error::Result;
-use anathema_widgets::layout::{Constraints, LayoutCtx, PositionCtx};
-use anathema_widgets::paint::{PaintCtx, SizePos};
-use anathema_widgets::{LayoutForEach, PaintChildren, PositionChildren, Widget, WidgetId};
-
-use crate::{BOTTOM, LEFT, RIGHT, TOP};
-
-const RELATIVE: &str = "relative";
-const ABSOLUTE: &str = "absolute";
-const PLACEMENT: &str = "placement";
-
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub enum HorzEdge {
-    Left(i32),
-    Right(i32),
-}
-
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub enum VertEdge {
-    Top(i32),
-    Bottom(i32),
-}
-
-#[derive(Debug, Default, Copy, Clone, PartialEq)]
-pub enum Placement {
-    /// Widget is positioned relative to its parent
-    #[default]
-    Relative,
-    /// Absolute position of a widget
-    Absolute,
-}
-
-impl TryFrom<&ValueKind<'_>> for Placement {
-    type Error = ();
-
-    fn try_from(value: &ValueKind<'_>) -> Result<Self, Self::Error> {
-        match value {
-            ValueKind::Str(wrap) => match wrap.as_ref() {
-                RELATIVE => Ok(Placement::Relative),
-                ABSOLUTE => Ok(Placement::Absolute),
-                _ => Err(()),
-            },
-            _ => Err(()),
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Position {
-    horz_edge: HorzEdge,
-    vert_edge: VertEdge,
-    placement: Placement,
-}
-
-impl Default for Position {
-    fn default() -> Self {
-        Self {
-            horz_edge: HorzEdge::Left(0),
-            vert_edge: VertEdge::Top(0),
-            placement: Placement::Relative,
-        }
-    }
-}
-
-impl Widget for Position {
-    fn floats(&self) -> bool {
-        true
-    }
-
-    fn layout<'bp>(
-        &mut self,
-        mut children: LayoutForEach<'_, 'bp>,
-        constraints: Constraints,
-        id: WidgetId,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-    ) -> Result<Size> {
-        let attribs = ctx.attribute_storage.get(id);
-        self.placement = attribs.get_as::<Placement>(PLACEMENT).unwrap_or_default();
-
-        self.horz_edge = match attribs.get_as::<i32>(LEFT) {
-            Some(left) => HorzEdge::Left(left),
-            None => match attribs.get_as::<i32>(RIGHT) {
-                Some(right) => HorzEdge::Right(right),
-                None => HorzEdge::Left(0),
-            },
-        };
-
-        self.vert_edge = match attribs.get_as::<i32>(TOP) {
-            Some(top) => VertEdge::Top(top),
-            None => match attribs.get_as::<i32>(BOTTOM) {
-                Some(bottom) => VertEdge::Bottom(bottom),
-                None => VertEdge::Top(0),
-            },
-        };
-
-        let size = constraints.max_size();
-
-        _ = children.each(ctx, |ctx, child, children| {
-            // size is determined by the constraint
-            _ = child.layout(children, ctx.viewport.constraints(), ctx)?;
-            Ok(ControlFlow::Break(()))
-        })?;
-
-        Ok(size)
-    }
-
-    fn position<'bp>(
-        &mut self,
-        mut children: PositionChildren<'_, 'bp>,
-        _: WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        mut ctx: PositionCtx,
-    ) {
-        if let Placement::Absolute = self.placement {
-            ctx.pos = Pos::ZERO;
-        }
-
-        _ = children.each(|child, children| {
-            match self.horz_edge {
-                HorzEdge::Left(left) => ctx.pos.x += left,
-                HorzEdge::Right(right) => {
-                    let offset = ctx.pos.x + ctx.inner_size.width as i32 - child.size().width as i32 - right;
-                    ctx.pos.x = offset;
-                }
-            }
-
-            match self.vert_edge {
-                VertEdge::Top(top) => ctx.pos.y += top,
-                VertEdge::Bottom(bottom) => {
-                    let offset = ctx.pos.y + ctx.inner_size.height as i32 - child.size().height as i32 - bottom;
-                    ctx.pos.y = offset;
-                }
-            }
-
-            child.position(children, ctx.pos, attribute_storage, ctx.viewport);
-            ControlFlow::Break(())
-        });
-    }
-
-    fn paint<'bp>(
-        &mut self,
-        mut children: PaintChildren<'_, 'bp>,
-        _id: WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        mut ctx: PaintCtx<'_, SizePos>,
-    ) {
-        _ = children.each(|child, children| {
-            let mut ctx = ctx.to_unsized();
-            ctx.clip = None;
-            child.paint(children, ctx, attribute_storage);
-            ControlFlow::Continue(())
-        });
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use crate::testing::TestRunner;
-
-    #[test]
-    fn position_top_left() {
-        let tpl = "
-            position [top: 0, left: 0]
-                text 'hi'
-            ";
-
-        let expected = "
-            ╔════╗
-            ║hi  ║
-            ║    ║
-            ╚════╝
-        ";
-
-        TestRunner::new(tpl, (4, 2)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn position_top() {
-        let tpl = "
-            position [top: 1]
-                text 'hi'
-            ";
-
-        let expected = "
-            ╔════╗
-            ║    ║
-            ║hi  ║
-            ╚════╝
-        ";
-
-        TestRunner::new(tpl, (4, 2)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn position_top_right() {
-        let tpl = "
-            position [top: 1, right: 0]
-                text 'hi'
-            ";
-
-        let expected = "
-            ╔════╗
-            ║    ║
-            ║  hi║
-            ╚════╝
-        ";
-
-        TestRunner::new(tpl, (4, 2)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn position_right() {
-        let tpl = "
-            position [right: 0]
-                text 'hi'
-            ";
-
-        let expected = "
-            ╔════╗
-            ║  hi║
-            ║    ║
-            ╚════╝
-        ";
-
-        TestRunner::new(tpl, (4, 2)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn position_bottom_right() {
-        let tpl = "
-            position [placement: 'relative', bottom: 0, right: 0]
-                text 'hi'
-            ";
-
-        let expected = "
-            ╔════╗
-            ║    ║
-            ║  hi║
-            ╚════╝
-        ";
-
-        TestRunner::new(tpl, (4, 2)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn position_bottom() {
-        let tpl = "
-            position [bottom: 0]
-                text 'hi'
-            ";
-
-        let expected = "
-            ╔════╗
-            ║    ║
-            ║hi  ║
-            ╚════╝
-        ";
-
-        TestRunner::new(tpl, (4, 2)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn position_bottom_left() {
-        let tpl = "
-            position [bottom: 0, left: 1]
-                text 'hi'
-            ";
-
-        let expected = "
-            ╔════╗
-            ║    ║
-            ║ hi ║
-            ╚════╝
-        ";
-
-        TestRunner::new(tpl, (4, 2)).instance().render_assert(expected);
-    }
-}
diff --git a/anathema-default-widgets/src/spacer.rs b/anathema-default-widgets/src/spacer.rs
deleted file mode 100644
index 580a7458..00000000
--- a/anathema-default-widgets/src/spacer.rs
+++ /dev/null
@@ -1,88 +0,0 @@
-use anathema_geometry::Size;
-use anathema_value_resolver::AttributeStorage;
-use anathema_widgets::error::Result;
-use anathema_widgets::layout::{Constraints, LayoutCtx, PositionCtx};
-use anathema_widgets::paint::{PaintCtx, SizePos};
-use anathema_widgets::{LayoutForEach, PaintChildren, PositionChildren, Widget, WidgetId};
-
-#[derive(Debug, Default)]
-pub struct Spacer;
-
-impl Widget for Spacer {
-    fn layout<'bp>(
-        &mut self,
-        _: LayoutForEach<'_, 'bp>,
-        constraints: Constraints,
-        _: WidgetId,
-        _: &mut LayoutCtx<'_, 'bp>,
-    ) -> Result<Size> {
-        Ok(Size::new(constraints.min_width, constraints.min_height))
-    }
-
-    fn paint<'bp>(
-        &mut self,
-        _: PaintChildren<'_, 'bp>,
-        _: WidgetId,
-        _: &AttributeStorage<'bp>,
-        _: PaintCtx<'_, SizePos>,
-    ) {
-        // The spacer widget has no children
-    }
-
-    fn position<'bp>(&mut self, _: PositionChildren<'_, 'bp>, _: WidgetId, _: &AttributeStorage<'bp>, _: PositionCtx) {
-        // The spacer widget has no children
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use crate::testing::TestRunner;
-
-    #[test]
-    fn hstack_spacer_nospace() {
-        let tpl = "
-        border
-            container [width:12]
-                hstack
-                    spacer
-                    text 'this is text'
-        ";
-
-        let expected = "
-            ╔══════════════╗
-            ║┌────────────┐║
-            ║│this is text│║
-            ║└────────────┘║
-            ║              ║
-            ╚══════════════╝
-        ";
-
-        let mut runner = TestRunner::new(tpl, (14, 4));
-        let mut runner = runner.instance();
-        runner.render_assert(expected);
-    }
-
-    #[test]
-    fn vstack_spacer_nospace() {
-        let tpl = "
-        border
-            container [height:1]
-                vstack
-                    spacer
-                    text 'this is text'
-        ";
-
-        let expected = "
-            ╔═════════════════╗
-            ║┌────────────┐   ║
-            ║│this is text│   ║
-            ║└────────────┘   ║
-            ║                 ║
-            ╚═════════════════╝
-        ";
-
-        let mut runner = TestRunner::new(tpl, (17, 4));
-        let mut runner = runner.instance();
-        runner.render_assert(expected);
-    }
-}
diff --git a/anathema-default-widgets/src/stacks/column.rs b/anathema-default-widgets/src/stacks/column.rs
deleted file mode 100644
index 1b3347fc..00000000
--- a/anathema-default-widgets/src/stacks/column.rs
+++ /dev/null
@@ -1,82 +0,0 @@
-use std::ops::ControlFlow;
-
-use anathema_geometry::Size;
-use anathema_value_resolver::AttributeStorage;
-use anathema_widgets::error::Result;
-use anathema_widgets::layout::{Constraints, LayoutCtx, PositionCtx};
-use anathema_widgets::{LayoutChildren, PositionChildren, Widget, WidgetId};
-
-use crate::layout::Axis;
-use crate::stacks::Stack;
-
-pub struct Column(Stack);
-
-impl Default for Column {
-    fn default() -> Self {
-        Self(Stack(Axis::Vertical))
-    }
-}
-
-impl Widget for Column {
-    fn layout<'bp>(
-        &mut self,
-        children: LayoutChildren<'_, 'bp>,
-        constraints: Constraints,
-        id: WidgetId,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-    ) -> Result<Size> {
-        self.0.layout(children, constraints, id, ctx)
-    }
-
-    fn position<'bp>(
-        &mut self,
-        mut children: PositionChildren<'_, 'bp>,
-        _: WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        mut ctx: PositionCtx,
-    ) {
-        let x_offset = (ctx.inner_size.width / 2) as i32;
-
-        _ = children.each(|child, children| {
-            let size = child.size();
-            let child_width = size.width as i32;
-            let x = x_offset - child_width / 2;
-
-            let mut pos = ctx.pos;
-            pos.x += x;
-
-            child.position(children, pos, attribute_storage, ctx.viewport);
-            ctx.pos.y += size.height as i32;
-            ControlFlow::Continue(())
-        });
-    }
-}
-
-#[cfg(test)]
-mod test {
-
-    use crate::testing::TestRunner;
-
-    #[test]
-    fn basic_column() {
-        let tpl = "
-            column
-                text 'a'
-                border
-                    text 'b'
-                text 'c'
-        ";
-
-        let expected = "
-            ╔═══╗
-            ║ a ║
-            ║┌─┐║
-            ║│b│║
-            ║└─┘║
-            ║ c ║
-            ╚═══╝
-        ";
-
-        TestRunner::new(tpl, (3, 5)).instance().render_assert(expected);
-    }
-}
diff --git a/anathema-default-widgets/src/stacks/hstack.rs b/anathema-default-widgets/src/stacks/hstack.rs
deleted file mode 100644
index 33cfd8bf..00000000
--- a/anathema-default-widgets/src/stacks/hstack.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-use anathema_geometry::Size;
-use anathema_value_resolver::AttributeStorage;
-use anathema_widgets::error::Result;
-use anathema_widgets::layout::{Constraints, LayoutCtx, PositionCtx};
-use anathema_widgets::{LayoutForEach, PositionChildren, Widget, WidgetId};
-
-use super::Stack;
-use crate::layout::Axis;
-
-pub struct HStack(Stack);
-
-impl Default for HStack {
-    fn default() -> Self {
-        HStack(Stack(Axis::Horizontal))
-    }
-}
-
-impl Widget for HStack {
-    fn layout<'bp>(
-        &mut self,
-        children: LayoutForEach<'_, 'bp>,
-        constraints: Constraints,
-        id: WidgetId,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-    ) -> Result<Size> {
-        self.0.layout(children, constraints, id, ctx)
-    }
-
-    fn position<'bp>(
-        &mut self,
-        children: PositionChildren<'_, 'bp>,
-        attributes: WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        ctx: PositionCtx,
-    ) {
-        self.0.position(children, attributes, attribute_storage, ctx)
-    }
-}
diff --git a/anathema-default-widgets/src/stacks/mod.rs b/anathema-default-widgets/src/stacks/mod.rs
deleted file mode 100644
index 92e1a897..00000000
--- a/anathema-default-widgets/src/stacks/mod.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-use std::ops::ControlFlow;
-
-use anathema_geometry::Size;
-use anathema_value_resolver::AttributeStorage;
-use anathema_widgets::error::Result;
-use anathema_widgets::layout::{Constraints, LayoutCtx, PositionCtx};
-use anathema_widgets::{LayoutForEach, PositionChildren, WidgetId};
-
-pub use self::column::Column;
-pub use self::hstack::HStack;
-pub use self::row::Row;
-pub use self::vstack::VStack;
-pub use self::zstack::ZStack;
-use crate::layout::many::Many;
-use crate::layout::{Axis, DIRECTION, Direction};
-use crate::{HEIGHT, MIN_HEIGHT, MIN_WIDTH, WIDTH};
-
-mod column;
-mod hstack;
-mod row;
-mod vstack;
-mod zstack;
-
-pub struct Stack(Axis);
-
-impl Stack {
-    fn layout<'bp>(
-        &mut self,
-        children: LayoutForEach<'_, 'bp>,
-        mut constraints: Constraints,
-        id: WidgetId,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-    ) -> Result<Size> {
-        let attributes = ctx.attribute_storage.get_mut(id);
-
-        if let Some(width) = attributes.get_as::<u16>(MIN_WIDTH) {
-            constraints.min_width = width;
-        }
-
-        if let Some(height) = attributes.get_as::<u16>(MIN_HEIGHT) {
-            constraints.min_height = height;
-        }
-
-        if let Some(width) = attributes.get_as::<u16>(WIDTH) {
-            constraints.make_width_tight(width);
-        }
-
-        if let Some(height) = attributes.get_as::<u16>(HEIGHT) {
-            constraints.make_height_tight(height);
-        }
-
-        let dir = attributes.get_as(DIRECTION).unwrap_or_default();
-
-        // Make `unconstrained` an enum instead of a `bool`
-        let unconstrained = false;
-        let mut many = Many::new(dir, self.0, unconstrained);
-        many.layout(children, constraints, ctx)
-    }
-
-    fn position<'bp>(
-        &mut self,
-        mut children: PositionChildren<'_, 'bp>,
-        id: WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        ctx: PositionCtx,
-    ) {
-        let attributes = attribute_storage.get(id);
-        let direction = attributes.get_as(DIRECTION).unwrap_or_default();
-        let mut pos = ctx.pos;
-
-        if let Direction::Backward = direction {
-            match self.0 {
-                Axis::Horizontal => pos.x += ctx.inner_size.width as i32,
-                Axis::Vertical => pos.y += ctx.inner_size.height as i32,
-            }
-        }
-
-        _ = children.each(|node, children| {
-            match direction {
-                Direction::Forward => {
-                    node.position(children, pos, attribute_storage, ctx.viewport);
-
-                    match self.0 {
-                        Axis::Horizontal => pos.x += node.size().width as i32,
-                        Axis::Vertical => pos.y += node.size().height as i32,
-                    }
-                }
-                Direction::Backward => {
-                    match self.0 {
-                        Axis::Horizontal => pos.x += node.size().width as i32,
-                        Axis::Vertical => pos.y -= node.size().height as i32,
-                    }
-
-                    node.position(children, pos, attribute_storage, ctx.viewport);
-                }
-            }
-
-            ControlFlow::Continue(())
-        });
-    }
-}
diff --git a/anathema-default-widgets/src/stacks/row.rs b/anathema-default-widgets/src/stacks/row.rs
deleted file mode 100644
index d3ad6bc4..00000000
--- a/anathema-default-widgets/src/stacks/row.rs
+++ /dev/null
@@ -1,78 +0,0 @@
-use std::ops::ControlFlow;
-
-use anathema_geometry::Size;
-use anathema_value_resolver::AttributeStorage;
-use anathema_widgets::error::Result;
-use anathema_widgets::layout::{Constraints, LayoutCtx, PositionCtx};
-use anathema_widgets::{LayoutChildren, PositionChildren, Widget, WidgetId};
-
-use crate::layout::Axis;
-use crate::stacks::Stack;
-
-pub struct Row(Stack);
-
-impl Default for Row {
-    fn default() -> Self {
-        Self(Stack(Axis::Horizontal))
-    }
-}
-
-impl Widget for Row {
-    fn layout<'bp>(
-        &mut self,
-        children: LayoutChildren<'_, 'bp>,
-        constraints: Constraints,
-        id: WidgetId,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-    ) -> Result<Size> {
-        self.0.layout(children, constraints, id, ctx)
-    }
-
-    fn position<'bp>(
-        &mut self,
-        mut children: PositionChildren<'_, 'bp>,
-        _: WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        mut ctx: PositionCtx,
-    ) {
-        let y_offset = (ctx.inner_size.height / 2) as i32;
-
-        _ = children.each(|child, children| {
-            let size = child.size();
-            let child_height = size.height as i32;
-            let y = y_offset - child_height / 2;
-
-            let mut pos = ctx.pos;
-            pos.y += y;
-            child.position(children, pos, attribute_storage, ctx.viewport);
-            ctx.pos.x += size.width as i32;
-            ControlFlow::Continue(())
-        });
-    }
-}
-
-#[cfg(test)]
-mod test {
-
-    use crate::testing::TestRunner;
-
-    #[test]
-    fn basic_row() {
-        let tpl = "
-            row
-                text 'a'
-                border
-                    text 'b'
-        ";
-
-        let expected = "
-            ╔════╗
-            ║ ┌─┐║
-            ║a│b│║
-            ║ └─┘║
-            ╚════╝
-        ";
-
-        TestRunner::new(tpl, (4, 3)).instance().render_assert(expected);
-    }
-}
diff --git a/anathema-default-widgets/src/stacks/vstack.rs b/anathema-default-widgets/src/stacks/vstack.rs
deleted file mode 100644
index 8a143767..00000000
--- a/anathema-default-widgets/src/stacks/vstack.rs
+++ /dev/null
@@ -1,184 +0,0 @@
-use std::ops::ControlFlow;
-
-use anathema_geometry::Size;
-use anathema_value_resolver::AttributeStorage;
-use anathema_widgets::error::Result;
-use anathema_widgets::layout::{Constraints, LayoutCtx, PositionCtx};
-use anathema_widgets::paint::{PaintCtx, SizePos};
-use anathema_widgets::{LayoutForEach, PaintChildren, PositionChildren, Widget, WidgetId};
-
-use super::Stack;
-use crate::layout::Axis;
-
-pub struct VStack(Stack);
-
-impl Default for VStack {
-    fn default() -> Self {
-        VStack(Stack(Axis::Vertical))
-    }
-}
-
-impl Widget for VStack {
-    fn layout<'bp>(
-        &mut self,
-        children: LayoutForEach<'_, 'bp>,
-        constraints: Constraints,
-        id: WidgetId,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-    ) -> Result<Size> {
-        self.0.layout(children, constraints, id, ctx)
-    }
-
-    fn position<'bp>(
-        &mut self,
-        children: PositionChildren<'_, 'bp>,
-        attributes: WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        ctx: PositionCtx,
-    ) {
-        self.0.position(children, attributes, attribute_storage, ctx)
-    }
-
-    fn paint<'bp>(
-        &mut self,
-        mut children: PaintChildren<'_, 'bp>,
-        _id: WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        mut ctx: PaintCtx<'_, SizePos>,
-    ) {
-        _ = children.each(|child, children| {
-            let ctx = ctx.to_unsized();
-            child.paint(children, ctx, attribute_storage);
-            ControlFlow::Continue(())
-        });
-    }
-}
-
-#[cfg(test)]
-mod test {
-
-    use crate::testing::TestRunner;
-
-    #[test]
-    fn vstack() {
-        let tpl = "
-            vstack
-                border
-                    text state.value
-                for i in [2]
-                    border
-                        text i
-        ";
-
-        let expected_first = "
-            ╔═══╗
-            ║┌─┐║
-            ║│0│║
-            ║└─┘║
-            ║┌─┐║
-            ║│2│║
-            ║└─┘║
-            ╚═══╝
-        ";
-
-        let expected_second = "
-            ╔═══╗
-            ║┌─┐║
-            ║│7│║
-            ║└─┘║
-            ║┌─┐║
-            ║│2│║
-            ║└─┘║
-            ╚═══╝
-        ";
-
-        TestRunner::new(tpl, (3, 6))
-            .instance()
-            .render_assert(expected_first)
-            .with_state(|state| *state.value.to_mut() = 7)
-            .render_assert(expected_second);
-    }
-
-    #[test]
-    fn fixed_height() {
-        let tpl = "
-            vstack [height: 2]
-                for i in [0, 1]
-                    border
-                        text i
-        ";
-
-        let expected = "
-            ╔══╗
-            ║┌┐║
-            ║└┘║
-            ╚══╝
-        ";
-
-        TestRunner::new(tpl, (2, 2)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn fixed_width() {
-        let tpl = "
-            vstack [width: 7, height: 3]
-                border
-                    expand
-                        text 'a'
-        ";
-
-        let expected = "
-            ╔═══════╗
-            ║┌─────┐║
-            ║│a    │║
-            ║└─────┘║
-            ╚═══════╝
-        ";
-
-        TestRunner::new(tpl, (7, 3)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn bottom_up_vstack() {
-        let tpl = "
-            vstack [direction: 'back']
-                text 'b'
-                border
-                    text 'a'
-        ";
-
-        let expected = "
-            ╔══════╗
-            ║      ║
-            ║┌─┐   ║
-            ║│a│   ║
-            ║└─┘   ║
-            ║b     ║
-            ╚══════╝
-        ";
-
-        TestRunner::new(tpl, (6, 5)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn vstack_overflow() {
-        let tpl = "
-            vstack
-                text 'a'
-                text 'b'
-                text 'c'
-                text 'd'
-        ";
-
-        let expected = "
-            ╔══════╗
-            ║a     ║
-            ║b     ║
-            ╚══════╝
-        ";
-
-        let mut runner = TestRunner::new(tpl, (6, 2));
-        let mut runner = runner.instance();
-        runner.render_assert(expected);
-    }
-}
diff --git a/anathema-default-widgets/src/stacks/zstack.rs b/anathema-default-widgets/src/stacks/zstack.rs
deleted file mode 100644
index 00044cd9..00000000
--- a/anathema-default-widgets/src/stacks/zstack.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-use std::ops::ControlFlow;
-
-use anathema_geometry::Size;
-use anathema_value_resolver::AttributeStorage;
-use anathema_widgets::error::Result;
-use anathema_widgets::layout::{Constraints, LayoutCtx, PositionCtx};
-use anathema_widgets::{LayoutForEach, PositionChildren, Widget, WidgetId};
-
-#[derive(Default)]
-pub struct ZStack;
-
-impl Widget for ZStack {
-    fn layout<'bp>(
-        &mut self,
-        mut children: LayoutForEach<'_, 'bp>,
-        constraints: Constraints,
-        _: WidgetId,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-    ) -> Result<Size> {
-        let mut size = Size::ZERO;
-        _ = children.each(ctx, |ctx, child, children| {
-            let child_size = Size::from(child.layout(children, constraints, ctx)?);
-            size.width = size.width.max(child_size.width);
-            size.height = size.height.max(child_size.height);
-            Ok(ControlFlow::Continue(()))
-        })?;
-        Ok(size)
-    }
-
-    fn position<'bp>(
-        &mut self,
-        mut children: PositionChildren<'_, 'bp>,
-        _: WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        ctx: PositionCtx,
-    ) {
-        _ = children.each(|child, children| {
-            child.position(children, ctx.pos, attribute_storage, ctx.viewport);
-            ControlFlow::Continue(())
-        });
-    }
-}
-
-#[cfg(test)]
-mod test {
-
-    use crate::testing::TestRunner;
-
-    #[test]
-    fn zstack() {
-        let tpl = "
-            zstack
-                text '333'
-                text '22'
-                text '1'
-        ";
-
-        let expected = "
-            ╔═══╗
-            ║123║
-            ╚═══╝
-        ";
-
-        TestRunner::new(tpl, (3, 1)).instance().render_assert(expected);
-    }
-}
diff --git a/anathema-default-widgets/src/testing.rs b/anathema-default-widgets/src/testing.rs
deleted file mode 100644
index b0591013..00000000
--- a/anathema-default-widgets/src/testing.rs
+++ /dev/null
@@ -1,380 +0,0 @@
-use anathema::{Changes, drain_changes};
-use anathema_backend::{Backend, WidgetCycle};
-use anathema_geometry::{Pos, Size};
-use anathema_state::{State, StateId, States, Value};
-use anathema_templates::blueprints::Blueprint;
-use anathema_templates::{Document, ToSourceKind, Variables};
-use anathema_value_resolver::{AttributeStorage, Attributes, FunctionTable, Scope};
-use anathema_widgets::components::ComponentRegistry;
-use anathema_widgets::components::events::Event;
-use anathema_widgets::layout::{Constraints, LayoutCtx, Viewport};
-use anathema_widgets::paint::{Glyph, paint};
-use anathema_widgets::query::{Children, Elements};
-use anathema_widgets::{
-    Components, DirtyWidgets, Factory, FloatingWidgets, GlyphMap, Style, WidgetRenderer, WidgetTree, eval_blueprint,
-    update_widget,
-};
-
-use crate::register_default_widgets;
-
-pub struct TestBackend {
-    pub surface: TestSurface,
-    pub output: String,
-}
-
-impl TestBackend {
-    pub fn new(size: impl Into<Size>) -> Self {
-        let size = size.into();
-        Self {
-            surface: TestSurface::new(size),
-            output: String::new(),
-        }
-    }
-}
-
-impl Backend for TestBackend {
-    fn size(&self) -> Size {
-        self.surface.size
-    }
-
-    fn next_event(&mut self, _timeout: std::time::Duration) -> Option<Event> {
-        None
-    }
-
-    fn paint<'bp>(
-        &mut self,
-        glyph_map: &mut GlyphMap,
-        widgets: anathema_widgets::PaintChildren<'_, 'bp>,
-        attribute_storage: &AttributeStorage<'bp>,
-    ) {
-        paint(&mut self.surface, glyph_map, widgets, attribute_storage);
-    }
-
-    fn render(&mut self, _glyph_map: &mut GlyphMap) {
-        self.output = format!("{}", self.surface);
-    }
-
-    fn clear(&mut self) {
-        self.surface.clear();
-    }
-
-    fn finalize(&mut self) {}
-
-    fn resize(&mut self, _new_size: Size, _glyph_map: &mut GlyphMap) {
-        todo!()
-    }
-}
-
-pub struct TestSurface {
-    size: Size,
-    buffer: Vec<char>,
-}
-
-impl TestSurface {
-    pub fn new(size: impl Into<Size>) -> Self {
-        let size = size.into();
-        let buffer_size = size.width * size.height;
-        Self {
-            buffer: vec![' '; buffer_size as usize],
-            size,
-        }
-    }
-
-    fn clear(&mut self) {
-        self.buffer.fill_with(|| ' ');
-    }
-}
-
-impl WidgetRenderer for TestSurface {
-    fn draw_glyph(&mut self, c: Glyph, local_pos: Pos) {
-        let y_offset = local_pos.y as usize * self.size.width as usize;
-        let x_offset = local_pos.x as usize;
-        let index = y_offset + x_offset;
-
-        match c {
-            Glyph::Single(c, _width) => self.buffer[index] = c,
-            Glyph::Cluster(_glyph_index, _) => todo!(),
-        }
-    }
-
-    fn size(&self) -> Size {
-        self.size
-    }
-
-    fn set_attributes(&mut self, attribs: &Attributes<'_>, local_pos: Pos) {
-        let style = Style::from_cell_attribs(attribs);
-        self.set_style(style, local_pos);
-    }
-
-    // This does nothing for the test backend,
-    // which is only used to test layouts
-    fn set_style(&mut self, _: Style, _: Pos) {}
-}
-
-impl std::fmt::Display for TestSurface {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        for y in 0..self.size.height {
-            for x in 0..self.size.width {
-                let idx = y * self.size.width + x;
-                write!(f, "{}", self.buffer[idx as usize])?;
-            }
-            writeln!(f)?;
-        }
-
-        Ok(())
-    }
-}
-
-pub struct TestRunner {
-    states: States,
-    component_registry: ComponentRegistry,
-    factory: Factory,
-    backend: TestBackend,
-    blueprint: Blueprint,
-    variables: Variables,
-    components: Components,
-    function_table: FunctionTable,
-}
-
-impl TestRunner {
-    pub fn new(src: &str, size: impl Into<Size>) -> Self {
-        let mut factory = Factory::new();
-        register_default_widgets(&mut factory);
-
-        let mut component_registry = ComponentRegistry::new();
-        let states = States::new();
-
-        // Add two to both dimensions to compensate
-        // for the border size that we inject here.
-        let mut size = size.into();
-        size.width += 2;
-        size.height += 2;
-
-        let root = "
-        border [border_style: 'thick']
-            expand
-                @main
-        ";
-        let mut doc = Document::new(root);
-        let main = doc.add_component("main", src.to_template()).unwrap();
-        component_registry.add_component(main, (), TestState::new());
-
-        let mut variables = Default::default();
-        let blueprint = doc.compile(&mut variables).unwrap();
-
-        Self {
-            factory,
-            backend: TestBackend::new(size),
-            states,
-            component_registry,
-            blueprint,
-            variables,
-            components: Components::new(),
-            function_table: FunctionTable::new(),
-        }
-    }
-
-    pub fn instance(&mut self) -> TestInstance<'_> {
-        TestInstance::new(
-            &self.blueprint,
-            &mut self.states,
-            &mut self.backend,
-            &self.variables,
-            &self.factory,
-            &mut self.component_registry,
-            &mut self.components,
-            &self.function_table,
-        )
-    }
-}
-
-pub struct TestInstance<'bp> {
-    tree: WidgetTree<'bp>,
-    attribute_storage: AttributeStorage<'bp>,
-    floating_widgets: FloatingWidgets,
-    states: &'bp mut States,
-    variables: &'bp Variables,
-    backend: &'bp mut TestBackend,
-    viewport: Viewport,
-    factory: &'bp Factory,
-    component_registry: &'bp mut ComponentRegistry,
-    components: &'bp mut Components,
-    changes: Changes,
-    glyph_map: GlyphMap,
-    function_table: &'bp FunctionTable,
-}
-
-impl<'bp> TestInstance<'bp> {
-    fn new(
-        blueprint: &'bp Blueprint,
-        states: &'bp mut States,
-        backend: &'bp mut TestBackend,
-        variables: &'bp Variables,
-        factory: &'bp Factory,
-        component_registry: &'bp mut ComponentRegistry,
-        components: &'bp mut Components,
-        function_table: &'bp FunctionTable,
-    ) -> Self {
-        let mut tree = WidgetTree::empty();
-        let mut attribute_storage = AttributeStorage::empty();
-        let mut floating_widgets = FloatingWidgets::empty();
-        let mut viewport = Viewport::new(backend.size());
-        let mut glyph_map = GlyphMap::empty();
-
-        let scope = Scope::root();
-        let mut ctx = LayoutCtx::new(
-            variables,
-            factory,
-            states,
-            &mut attribute_storage,
-            components,
-            component_registry,
-            &mut floating_widgets,
-            &mut glyph_map,
-            &mut viewport,
-            function_table,
-        );
-
-        let mut ctx = ctx.eval_ctx(None, None);
-        let mut view = tree.view();
-
-        eval_blueprint(blueprint, &mut ctx, &scope, &[], &mut view).unwrap();
-
-        Self {
-            tree,
-            attribute_storage,
-            floating_widgets,
-            states,
-            variables,
-            backend,
-            viewport,
-            factory,
-            component_registry,
-            components,
-            changes: Changes::empty(),
-            glyph_map,
-            function_table,
-        }
-    }
-
-    pub fn with_state<F>(&mut self, mut f: F) -> &mut Self
-    where
-        F: FnMut(&mut TestState),
-    {
-        let state = self.states.get_mut(StateId::ZERO).unwrap();
-        let mut state = state.to_mut_cast::<TestState>();
-        f(&mut state);
-        drop(state);
-
-        drain_changes(&mut self.changes);
-
-        if self.changes.is_empty() {
-            return self;
-        }
-
-        let mut tree = self.tree.view();
-
-        let mut ctx = LayoutCtx::new(
-            self.variables,
-            self.factory,
-            self.states,
-            &mut self.attribute_storage,
-            self.components,
-            self.component_registry,
-            &mut self.floating_widgets,
-            &mut self.glyph_map,
-            &mut self.viewport,
-            self.function_table,
-        );
-
-        self.changes.iter().for_each(|(sub, change)| {
-            sub.iter().for_each(|value_id| {
-                let widget_id = value_id.key();
-
-                // TODO: review if this is still needed: - TB 2025-08-27
-                // if let Some(widget) = tree.get_mut(widget_id) {
-                //     if let WidgetKind::Element(element) = &mut widget.kind {
-                //         element.invalidate_cache();
-                //     }
-                // }
-
-                // check that the node hasn't already been removed
-                if !tree.contains(widget_id) {
-                    return;
-                }
-
-                _ = tree
-                    .with_value_mut(value_id.key(), |_path, widget, tree| {
-                        update_widget(widget, value_id, change, tree, &mut ctx, &mut DirtyWidgets::empty())
-                    })
-                    .unwrap();
-            })
-        });
-
-        self
-    }
-
-    pub fn render_assert(&mut self, expected: &str) -> &mut Self {
-        let expected = expected.trim().lines().map(str::trim).collect::<Vec<_>>().join("\n");
-
-        let (width, height) = self.backend.size().into();
-        let constraints = Constraints::new(width as u16, height as u16);
-
-        let mut ctx = LayoutCtx::new(
-            self.variables,
-            self.factory,
-            self.states,
-            &mut self.attribute_storage,
-            self.components,
-            self.component_registry,
-            &mut self.floating_widgets,
-            &mut self.glyph_map,
-            &mut self.viewport,
-            self.function_table,
-        );
-
-        let mut cycle = WidgetCycle::new(self.backend, self.tree.view(), constraints);
-        _ = cycle.run(&mut ctx, true, &mut DirtyWidgets::empty());
-
-        self.backend.render(&mut self.glyph_map);
-
-        let actual = std::mem::take(&mut self.backend.output);
-        let actual = actual.trim().lines().map(str::trim).collect::<Vec<_>>().join("\n");
-
-        assert_eq!(expected, actual, "\nExpected:\n{expected}\nGot:\n{actual}");
-        self
-    }
-
-    pub(crate) fn with_widget<F>(&mut self, mut f: F) -> &mut Self
-    where
-        F: FnMut(Elements<'_, '_, '_>),
-    {
-        // path [0, 0, 0] points to:
-        // border [0]
-        //     expand [0, 0]
-        //          @main [0, 0, 0] <- this one
-        // let path = &[0, 0, 0];
-
-        let tree = self.tree.view();
-        let mut dirty_widgets = DirtyWidgets::empty();
-        let mut children = Children::new(tree, &mut self.attribute_storage, &mut dirty_widgets);
-        let elements = children.elements();
-        f(elements);
-        self
-    }
-}
-
-#[derive(State)]
-pub struct TestState {
-    pub value: Value<usize>,
-    pub offset: Value<i32>,
-}
-
-impl TestState {
-    pub fn new() -> Self {
-        Self {
-            value: 0.into(),
-            offset: 0.into(),
-        }
-    }
-}
diff --git a/anathema-default-widgets/src/text.rs b/anathema-default-widgets/src/text.rs
deleted file mode 100644
index 5d88a9cb..00000000
--- a/anathema-default-widgets/src/text.rs
+++ /dev/null
@@ -1,317 +0,0 @@
-use std::ops::ControlFlow;
-
-use anathema_geometry::{LocalPos, Size};
-use anathema_value_resolver::{AttributeStorage, ValueKind};
-use anathema_widgets::error::Result;
-use anathema_widgets::layout::text::{ProcessResult, Segment, Strings};
-use anathema_widgets::layout::{Constraints, LayoutCtx, PositionCtx};
-use anathema_widgets::paint::{Glyphs, PaintCtx, SizePos};
-use anathema_widgets::{LayoutForEach, PaintChildren, PositionChildren, Widget, WidgetId};
-
-use crate::{LEFT, RIGHT};
-
-pub(crate) const WRAP: &str = "wrap";
-pub(crate) const TEXT_ALIGN: &str = "text_align";
-
-/// Text alignment aligns the text inside its parent.
-///
-/// Given a border with a width of nine and text alignment set to [`TextAlignment::Right`]:
-/// ```text
-/// ┌───────┐
-/// │I would│
-/// │ like a│
-/// │ lovely│
-/// │ cup of│
-/// │    tea│
-/// │ please│
-/// └───────┘
-/// ```
-///
-/// The text will only align it self within the parent widget.
-#[derive(Debug, PartialEq, Eq, Copy, Clone, Default)]
-pub enum TextAlignment {
-    /// Align the to the left inside the parent
-    #[default]
-    Left,
-    /// Align the text in the centre of the parent
-    Centre,
-    /// Align the to the right inside the parent
-    Right,
-}
-
-impl TryFrom<&ValueKind<'_>> for TextAlignment {
-    type Error = ();
-
-    fn try_from(value: &ValueKind<'_>) -> Result<Self, Self::Error> {
-        let s = value.as_str().ok_or(())?;
-        match s {
-            LEFT => Ok(TextAlignment::Left),
-            RIGHT => Ok(TextAlignment::Right),
-            "centre" | "center" => Ok(TextAlignment::Centre),
-            _ => Err(()),
-        }
-    }
-}
-
-/// Text widget
-/// ```ignore
-/// Attributes:
-/// * background
-/// * foreground
-/// * text-align
-/// * wrap
-/// ```
-///
-/// Note: Spans, unlike other widgets, does not require a widget id
-///
-/// A `Text` widget will be as wide as its text.
-#[derive(Debug, Default)]
-pub struct Text {
-    strings: Strings,
-}
-
-impl Widget for Text {
-    fn layout<'bp>(
-        &mut self,
-        mut children: LayoutForEach<'_, 'bp>,
-        constraints: Constraints,
-        id: WidgetId,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-    ) -> Result<Size> {
-        let attributes = ctx.attributes(id);
-        let wrap = attributes.get_as(WRAP).unwrap_or_default();
-        let size = constraints.max_size();
-        self.strings = Strings::new(size, wrap);
-        self.strings.set_style(id);
-
-        // Layout text
-        if let Some(text) = attributes.value() {
-            text.strings(|s| match self.strings.add_str(s) {
-                ProcessResult::Break => false,
-                ProcessResult::Continue => true,
-            });
-        }
-
-        // Layout text of all the sub-nodes
-        _ = children.each(ctx, |ctx, child, _| {
-            let Some(_span) = child.try_to_ref::<Span>() else {
-                return Ok(ControlFlow::Continue(()));
-            };
-
-            self.strings.set_style(child.id());
-            let attributes = ctx.attributes(child.id());
-            if let Some(text) = attributes.value() {
-                text.strings(|s| match self.strings.add_str(s) {
-                    ProcessResult::Break => false,
-                    ProcessResult::Continue => true,
-                });
-                Ok(ControlFlow::Continue(()))
-            } else {
-                Ok(ControlFlow::Break(()))
-            }
-        })?;
-
-        Ok(self.strings.finish())
-    }
-
-    fn paint<'bp>(
-        &mut self,
-        _: PaintChildren<'_, 'bp>,
-        id: WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        mut ctx: PaintCtx<'_, SizePos>,
-    ) {
-        let lines = self.strings.lines();
-        let alignment = attribute_storage.get(id).get_as(TEXT_ALIGN).unwrap_or_default();
-
-        let mut pos = LocalPos::ZERO;
-        let mut style = attribute_storage.get(id);
-
-        for line in lines {
-            let x = match alignment {
-                TextAlignment::Left => 0,
-                TextAlignment::Centre => ctx.local_size.width / 2 - line.width / 2,
-                TextAlignment::Right => ctx.local_size.width - line.width,
-            };
-
-            pos.x = x;
-
-            for entry in line.entries {
-                match entry {
-                    Segment::Str(s) => {
-                        let glyphs = Glyphs::new(s);
-                        if let Some(new_pos) = ctx.place_glyphs(glyphs, pos) {
-                            // TODO:
-                            // In the future there should probably be a way to
-                            // provide both style and glyph at the same time.
-                            for x in pos.x..new_pos.x {
-                                ctx.set_attributes(style, (x, pos.y).into());
-                            }
-                            pos = new_pos;
-                        }
-                    }
-                    Segment::SetStyle(attribute_id) => style = attribute_storage.get(attribute_id),
-                }
-            }
-            pos.y += 1;
-            pos.x = 0;
-        }
-    }
-
-    fn position<'bp>(&mut self, _: PositionChildren<'_, 'bp>, _: WidgetId, _: &AttributeStorage<'bp>, _: PositionCtx) {
-        // NOTE
-        // No positioning is done in here, it's all done when painting
-    }
-}
-
-#[derive(Default, Copy, Clone)]
-pub struct Span;
-
-impl Widget for Span {
-    fn layout<'bp>(
-        &mut self,
-        _: LayoutForEach<'_, 'bp>,
-        _: Constraints,
-        _: WidgetId,
-        _: &mut LayoutCtx<'_, 'bp>,
-    ) -> Result<Size> {
-        // Everything is handled by the parent text
-        Ok(Size::ZERO)
-    }
-
-    fn position<'bp>(&mut self, _: PositionChildren<'_, 'bp>, _: WidgetId, _: &AttributeStorage<'bp>, _: PositionCtx) {
-        // Everything is handled by the parent text
-        // panic!("this should never be called");
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use crate::testing::TestRunner;
-
-    #[test]
-    fn word_wrap_excessive_space() {
-        let src = "text 'hello      how are     you'";
-        let expected = "
-           ╔════════════════╗
-           ║hello      how  ║
-           ║are     you     ║
-           ║                ║
-           ║                ║
-           ║                ║
-           ║                ║
-           ╚════════════════╝";
-
-        TestRunner::new(src, (16, 6)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn word_wrap() {
-        let src = "text 'hello how are you'";
-        let expected = r#"
-           ╔════════════════╗
-           ║hello how are   ║
-           ║you             ║
-           ║                ║
-           ╚════════════════╝
-           "#;
-
-        TestRunner::new(src, (16, 3)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn break_word_wrap() {
-        let src = "text [wrap: 'break'] 'hello howareyoudoing'";
-        let expected = r#"
-           ╔════════════════╗
-           ║hello howareyoud║
-           ║oing            ║
-           ║                ║
-           ╚════════════════╝
-           "#;
-
-        TestRunner::new(src, (16, 3)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn char_wrap_layout_multiple_spans() {
-        let src = r#"
-            text 'one'
-                span 'two'
-                span ' averylongword'
-                span ' bunny'
-        "#;
-
-        let expected = r#"
-           ╔═══════════════════╗
-           ║onetwo             ║
-           ║averylongword bunny║
-           ║                   ║
-           ╚═══════════════════╝
-       "#;
-
-        TestRunner::new(src, (19, 3)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn multi_line_with_span() {
-        let src = r#"
-            border [width: 5 + 2]
-                text 'one'
-                    span 'two'
-        "#;
-
-        let expected = r#"
-            ╔═════════╗
-            ║┌─────┐  ║
-            ║│onetw│  ║
-            ║│o    │  ║
-            ║└─────┘  ║
-            ╚═════════╝
-       "#;
-
-        TestRunner::new(src, (9, 4)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn right_alignment() {
-        let src = "text [text_align: 'right'] 'a one xxxxxxxxxxxxxxxxxx'";
-        let expected = r#"
-               ╔══════════════════╗
-               ║            a one ║
-               ║xxxxxxxxxxxxxxxxxx║
-               ║                  ║
-               ╚══════════════════╝
-           "#;
-
-        TestRunner::new(src, (18, 3)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn centre_alignment() {
-        let src = "text [text_align: 'centre'] 'a one xxxxxxxxxxxxxxxxxx'";
-        let expected = r#"
-               ╔══════════════════╗
-               ║      a one       ║
-               ║xxxxxxxxxxxxxxxxxx║
-               ║                  ║
-               ╚══════════════════╝
-           "#;
-
-        TestRunner::new(src, (18, 3)).instance().render_assert(expected);
-    }
-
-    #[test]
-    fn line_break() {
-        let src = "text 'What have you'";
-        let expected = r#"
-               ╔═════════╗
-               ║What have║
-               ║you      ║
-               ║         ║
-               ╚═════════╝
-           "#;
-
-        TestRunner::new(src, (9, 3)).instance().render_assert(expected);
-    }
-}
diff --git a/anathema-default-widgets/tags b/anathema-default-widgets/tags
deleted file mode 100644
index 841f95d2..00000000
--- a/anathema-default-widgets/tags
+++ /dev/null
@@ -1,471 +0,0 @@
-!_TAG_EXTRA_DESCRIPTION	anonymous	/Include tags for non-named objects like lambda/
-!_TAG_EXTRA_DESCRIPTION	fileScope	/Include tags of file scope/
-!_TAG_EXTRA_DESCRIPTION	pseudo	/Include pseudo tags/
-!_TAG_EXTRA_DESCRIPTION	subparser	/Include tags generated by subparsers/
-!_TAG_FIELD_DESCRIPTION	epoch	/the last modified time of the input file (only for F\/file kind tag)/
-!_TAG_FIELD_DESCRIPTION	file	/File-restricted scoping/
-!_TAG_FIELD_DESCRIPTION	input	/input file/
-!_TAG_FIELD_DESCRIPTION	name	/tag name/
-!_TAG_FIELD_DESCRIPTION	pattern	/pattern/
-!_TAG_FIELD_DESCRIPTION	typeref	/Type and name of a variable or typedef/
-!_TAG_FILE_FORMAT	2	/extended format; --format=1 will not append ;" to lines/
-!_TAG_FILE_SORTED	1	/0=unsorted, 1=sorted, 2=foldcase/
-!_TAG_KIND_DESCRIPTION!Rust	C,constant	/A constant/
-!_TAG_KIND_DESCRIPTION!Rust	M,macro	/Macro Definition/
-!_TAG_KIND_DESCRIPTION!Rust	P,method	/A method/
-!_TAG_KIND_DESCRIPTION!Rust	c,implementation	/implementation/
-!_TAG_KIND_DESCRIPTION!Rust	e,enumerator	/An enum variant/
-!_TAG_KIND_DESCRIPTION!Rust	f,function	/Function/
-!_TAG_KIND_DESCRIPTION!Rust	g,enum	/Enum/
-!_TAG_KIND_DESCRIPTION!Rust	i,interface	/trait interface/
-!_TAG_KIND_DESCRIPTION!Rust	m,field	/A struct field/
-!_TAG_KIND_DESCRIPTION!Rust	n,module	/module/
-!_TAG_KIND_DESCRIPTION!Rust	s,struct	/structural type/
-!_TAG_KIND_DESCRIPTION!Rust	t,typedef	/Type Alias/
-!_TAG_KIND_DESCRIPTION!Rust	v,variable	/Global variable/
-!_TAG_OUTPUT_EXCMD	mixed	/number, pattern, mixed, or combineV2/
-!_TAG_OUTPUT_FILESEP	slash	/slash or backslash/
-!_TAG_OUTPUT_MODE	u-ctags	/u-ctags or e-ctags/
-!_TAG_OUTPUT_VERSION	0.0	/current.age/
-!_TAG_PARSER_VERSION!Rust	0.0	/current.age/
-!_TAG_PATTERN_LENGTH_LIMIT	96	/0 for no limit/
-!_TAG_PROC_CWD	/home/togglebit/projects/rust/anathema/anathema-default-widgets/	//
-!_TAG_PROGRAM_AUTHOR	Universal Ctags Team	//
-!_TAG_PROGRAM_NAME	Universal Ctags	/Derived from Exuberant Ctags/
-!_TAG_PROGRAM_URL	https://ctags.io/	/official site/
-!_TAG_PROGRAM_VERSION	6.1.0	/v6.1.0/
-ABSOLUTE	src/position.rs	/^const ABSOLUTE: &str = "absolute";$/;"	C
-ALIGNMENT	src/layout/alignment.rs	/^pub const ALIGNMENT: &str = "alignment";$/;"	C
-AXIS	src/layout/mod.rs	/^pub static AXIS: &str = "axis";$/;"	v
-Absolute	src/position.rs	/^    Absolute,$/;"	e	enum:Placement
-Align	src/alignment.rs	/^impl Widget for Align {$/;"	c
-Align	src/alignment.rs	/^pub struct Align;$/;"	s
-Alignment	src/layout/alignment.rs	/^impl TryFrom<CommonVal<'_>> for Alignment {$/;"	c
-Alignment	src/layout/alignment.rs	/^pub enum Alignment {$/;"	g
-Axis	src/layout/mod.rs	/^impl TryFrom<CommonVal<'_>> for Axis {$/;"	c
-Axis	src/layout/mod.rs	/^pub enum Axis {$/;"	g
-BORDER_EDGE_BOTTOM	src/border.rs	/^pub const BORDER_EDGE_BOTTOM: usize = 5;$/;"	C
-BORDER_EDGE_BOTTOM_LEFT	src/border.rs	/^pub const BORDER_EDGE_BOTTOM_LEFT: usize = 6;$/;"	C
-BORDER_EDGE_BOTTOM_RIGHT	src/border.rs	/^pub const BORDER_EDGE_BOTTOM_RIGHT: usize = 4;$/;"	C
-BORDER_EDGE_LEFT	src/border.rs	/^pub const BORDER_EDGE_LEFT: usize = 7;$/;"	C
-BORDER_EDGE_RIGHT	src/border.rs	/^pub const BORDER_EDGE_RIGHT: usize = 3;$/;"	C
-BORDER_EDGE_TOP	src/border.rs	/^pub const BORDER_EDGE_TOP: usize = 1;$/;"	C
-BORDER_EDGE_TOP_LEFT	src/border.rs	/^pub const BORDER_EDGE_TOP_LEFT: usize = 0;$/;"	C
-BORDER_EDGE_TOP_RIGHT	src/border.rs	/^pub const BORDER_EDGE_TOP_RIGHT: usize = 2;$/;"	C
-BORDER_STYLE	src/border.rs	/^pub const BORDER_STYLE: &str = "border_style";$/;"	C
-BOTTOM	src/lib.rs	/^pub(crate) const BOTTOM: &str = "bottom";$/;"	C
-Backward	src/layout/mod.rs	/^    Backward,$/;"	e	enum:Direction
-Border	src/border.rs	/^impl Border {$/;"	c
-Border	src/border.rs	/^impl Widget for Border {$/;"	c
-Border	src/border.rs	/^pub struct Border {$/;"	s
-BorderLayout	src/layout/border.rs	/^impl BorderLayout {$/;"	c
-BorderLayout	src/layout/border.rs	/^pub struct BorderLayout {$/;"	s
-BorderPainter	src/border.rs	/^impl BorderPainter {$/;"	c
-BorderPainter	src/border.rs	/^struct BorderPainter {$/;"	s
-BorderSize	src/border.rs	/^impl BorderSize {$/;"	c
-BorderSize	src/border.rs	/^pub(crate) struct BorderSize {$/;"	s
-BorderStyle	src/border.rs	/^impl BorderStyle {$/;"	c
-BorderStyle	src/border.rs	/^impl Display for BorderStyle {$/;"	c
-BorderStyle	src/border.rs	/^impl TryFrom<&EvalValue<'_>> for BorderStyle {$/;"	c
-BorderStyle	src/border.rs	/^pub enum BorderStyle {$/;"	g
-Bottom	src/layout/alignment.rs	/^    Bottom,$/;"	e	enum:Alignment
-Bottom	src/position.rs	/^    Bottom(u32),$/;"	e	enum:VertEdge
-BottomLeft	src/layout/alignment.rs	/^    BottomLeft,$/;"	e	enum:Alignment
-BottomRight	src/layout/alignment.rs	/^    BottomRight,$/;"	e	enum:Alignment
-Brush	src/border.rs	/^impl Brush {$/;"	c
-Brush	src/border.rs	/^struct Brush {$/;"	s
-Buffer	src/canvas.rs	/^impl Buffer {$/;"	c
-Buffer	src/canvas.rs	/^struct Buffer {$/;"	s
-CLAMP	src/overflow.rs	/^const CLAMP: &str = "clamp";$/;"	C
-Canvas	src/canvas.rs	/^impl Canvas {$/;"	c
-Canvas	src/canvas.rs	/^impl Default for Canvas {$/;"	c
-Canvas	src/canvas.rs	/^impl Widget for Canvas {$/;"	c
-Canvas	src/canvas.rs	/^pub struct Canvas {$/;"	s
-Cell	src/canvas.rs	/^enum Cell {$/;"	g
-Centre	src/layout/alignment.rs	/^    Centre,$/;"	e	enum:Alignment
-Centre	src/text.rs	/^    Centre,$/;"	e	enum:TextAlignment
-Column	src/stacks/column.rs	/^impl Default for Column {$/;"	c
-Column	src/stacks/column.rs	/^impl Widget for Column {$/;"	c
-Column	src/stacks/column.rs	/^pub struct Column(Stack);$/;"	s
-Container	src/container.rs	/^impl Widget for Container {$/;"	c
-Container	src/container.rs	/^pub struct Container;$/;"	s
-Custom	src/border.rs	/^    Custom(String),$/;"	e	enum:BorderStyle
-DEFAULT_FACTOR	src/layout/expand.rs	/^const DEFAULT_FACTOR: usize = 1;$/;"	C
-DEFAULT_SLIM_EDGES	src/border.rs	/^pub const DEFAULT_SLIM_EDGES: [char; 8] = ['┌', '─', '┐', '│', '┘', '─', '└', '│/;"	C
-DEFAULT_THICK_EDGES	src/border.rs	/^pub const DEFAULT_THICK_EDGES: [char; 8] = ['╔', '═', '╗', '║', '╝', '═', '╚', '║/;"	C
-DIRECTION	src/layout/mod.rs	/^pub static DIRECTION: &str = "direction";$/;"	v
-Direction	src/layout/mod.rs	/^impl TryFrom<CommonVal<'_>> for Direction {$/;"	c
-Direction	src/layout/mod.rs	/^pub enum Direction {$/;"	g
-Empty	src/canvas.rs	/^    Empty,$/;"	e	enum:Cell
-Error	src/border.rs	/^    type Error = ();$/;"	t	implementation:Sides
-Error	src/border.rs	/^    type Error = Infallible;$/;"	t	implementation:BorderStyle
-Error	src/layout/alignment.rs	/^    type Error = ();$/;"	t	implementation:Alignment
-Error	src/layout/mod.rs	/^    type Error = ();$/;"	t	implementation:Axis
-Error	src/layout/mod.rs	/^    type Error = ();$/;"	t	implementation:Direction
-Error	src/position.rs	/^    type Error = ();$/;"	t	implementation:Placement
-Error	src/text.rs	/^    type Error = ();$/;"	t	implementation:TextAlignment
-Expand	src/expand.rs	/^impl Widget for Expand {$/;"	c
-Expand	src/expand.rs	/^pub struct Expand;$/;"	s
-Forward	src/layout/mod.rs	/^    Forward,$/;"	e	enum:Direction
-HEIGHT	src/lib.rs	/^pub(crate) const HEIGHT: &str = "height";$/;"	C
-HStack	src/stacks/hstack.rs	/^impl Default for HStack {$/;"	c
-HStack	src/stacks/hstack.rs	/^impl Widget for HStack {$/;"	c
-HStack	src/stacks/hstack.rs	/^pub struct HStack(Stack);$/;"	s
-Horizontal	src/layout/mod.rs	/^    Horizontal,$/;"	e	enum:Axis
-HorzEdge	src/position.rs	/^pub enum HorzEdge {$/;"	g
-LEFT	src/lib.rs	/^pub(crate) const LEFT: &str = "left";$/;"	C
-Left	src/layout/alignment.rs	/^    Left,$/;"	e	enum:Alignment
-Left	src/position.rs	/^    Left(u32),$/;"	e	enum:HorzEdge
-Left	src/text.rs	/^    Left,$/;"	e	enum:TextAlignment
-Line	src/border.rs	/^impl Line {$/;"	c
-Line	src/border.rs	/^struct Line {$/;"	s
-MAX_HEIGHT	src/lib.rs	/^pub(crate) const MAX_HEIGHT: &str = "max_height";$/;"	C
-MAX_WIDTH	src/lib.rs	/^pub(crate) const MAX_WIDTH: &str = "max_width";$/;"	C
-MIN_HEIGHT	src/lib.rs	/^pub(crate) const MIN_HEIGHT: &str = "min_height";$/;"	C
-MIN_WIDTH	src/lib.rs	/^pub(crate) const MIN_WIDTH: &str = "min_width";$/;"	C
-Many	src/layout/many.rs	/^impl Many {$/;"	c
-Many	src/layout/many.rs	/^pub struct Many {$/;"	s
-Occupied	src/canvas.rs	/^    Occupied(char, Style),$/;"	e	enum:Cell
-Overflow	src/overflow.rs	/^impl Overflow {$/;"	c
-Overflow	src/overflow.rs	/^impl Widget for Overflow {$/;"	c
-Overflow	src/overflow.rs	/^pub struct Overflow {$/;"	s
-PADDING	src/padding.rs	/^const PADDING: &str = "padding";$/;"	C
-PLACEMENT	src/position.rs	/^const PLACEMENT: &str = "placement";$/;"	C
-Padding	src/padding.rs	/^impl Widget for Padding {$/;"	c
-Padding	src/padding.rs	/^pub struct Padding(PaddingValues);$/;"	s
-PaddingValues	src/padding.rs	/^impl PaddingValues {$/;"	c
-PaddingValues	src/padding.rs	/^struct PaddingValues {$/;"	s
-Placement	src/position.rs	/^impl TryFrom<CommonVal<'_>> for Placement {$/;"	c
-Placement	src/position.rs	/^pub enum Placement {$/;"	g
-Position	src/position.rs	/^impl Default for Position {$/;"	c
-Position	src/position.rs	/^impl Widget for Position {$/;"	c
-Position	src/position.rs	/^pub struct Position {$/;"	s
-RELATIVE	src/position.rs	/^const RELATIVE: &str = "relative";$/;"	C
-RIGHT	src/lib.rs	/^pub(crate) const RIGHT: &str = "right";$/;"	C
-Relative	src/position.rs	/^    Relative,$/;"	e	enum:Placement
-Right	src/layout/alignment.rs	/^    Right,$/;"	e	enum:Alignment
-Right	src/position.rs	/^    Right(u32),$/;"	e	enum:HorzEdge
-Right	src/text.rs	/^    Right,$/;"	e	enum:TextAlignment
-Row	src/stacks/row.rs	/^impl Default for Row {$/;"	c
-Row	src/stacks/row.rs	/^impl Widget for Row {$/;"	c
-Row	src/stacks/row.rs	/^pub struct Row(Stack);$/;"	s
-Sides	src/border.rs	/^impl Default for Sides {$/;"	c
-Sides	src/border.rs	/^impl From<&str> for Sides {$/;"	c
-Sides	src/border.rs	/^impl TryFrom<&EvalValue<'_>> for Sides {$/;"	c
-SizeMod	src/layout/many.rs	/^impl SizeMod {$/;"	c
-SizeMod	src/layout/many.rs	/^pub(crate) struct SizeMod {$/;"	s
-Spacer	src/spacer.rs	/^impl Widget for Spacer {$/;"	c
-Spacer	src/spacer.rs	/^pub struct Spacer;$/;"	s
-Span	src/text.rs	/^impl Widget for Span {$/;"	c
-Span	src/text.rs	/^pub struct Span;$/;"	s
-Stack	src/stacks/mod.rs	/^impl Stack {$/;"	c
-Stack	src/stacks/mod.rs	/^pub struct Stack(Axis);$/;"	s
-TEXT_ALIGN	src/text.rs	/^pub(crate) const TEXT_ALIGN: &str = "text_align";$/;"	C
-TOP	src/lib.rs	/^pub(crate) const TOP: &str = "top";$/;"	C
-TestInstance	src/testing.rs	/^impl TestInstance<'_> {$/;"	c
-TestInstance	src/testing.rs	/^pub struct TestInstance<'bp> {$/;"	s
-TestRunner	src/testing.rs	/^impl TestRunner {$/;"	c
-TestRunner	src/testing.rs	/^pub struct TestRunner {$/;"	s
-TestState	src/testing.rs	/^impl TestState {$/;"	c
-TestState	src/testing.rs	/^pub struct TestState {$/;"	s
-Text	src/text.rs	/^impl Widget for Text {$/;"	c
-Text	src/text.rs	/^pub struct Text {$/;"	s
-TextAlignment	src/text.rs	/^impl TryFrom<CommonVal<'_>> for TextAlignment {$/;"	c
-TextAlignment	src/text.rs	/^pub enum TextAlignment {$/;"	g
-Thick	src/border.rs	/^    Thick,$/;"	e	enum:BorderStyle
-Thin	src/border.rs	/^    Thin,$/;"	e	enum:BorderStyle
-Top	src/layout/alignment.rs	/^    Top,$/;"	e	enum:Alignment
-Top	src/position.rs	/^    Top(u32),$/;"	e	enum:VertEdge
-TopLeft	src/layout/alignment.rs	/^    TopLeft,$/;"	e	enum:Alignment
-TopRight	src/layout/alignment.rs	/^    TopRight,$/;"	e	enum:Alignment
-UNCONSTRAINED	src/overflow.rs	/^const UNCONSTRAINED: &str = "unconstrained";$/;"	C
-VStack	src/stacks/vstack.rs	/^impl Default for VStack {$/;"	c
-VStack	src/stacks/vstack.rs	/^impl Widget for VStack {$/;"	c
-VStack	src/stacks/vstack.rs	/^pub struct VStack(Stack);$/;"	s
-VertEdge	src/position.rs	/^pub enum VertEdge {$/;"	g
-Vertical	src/layout/mod.rs	/^    Vertical,$/;"	e	enum:Axis
-WIDTH	src/lib.rs	/^pub(crate) const WIDTH: &str = "width";$/;"	C
-WRAP	src/text.rs	/^pub(crate) const WRAP: &str = "wrap";$/;"	C
-ZERO	src/layout/many.rs	/^    const ZERO: Self = Self::new(Size::ZERO, Axis::Vertical);$/;"	C	implementation:SizeMod
-ZStack	src/stacks/zstack.rs	/^impl Widget for ZStack {$/;"	c
-ZStack	src/stacks/zstack.rs	/^pub struct ZStack;$/;"	s
-alignment	src/layout/mod.rs	/^pub(crate) mod alignment;$/;"	n
-alignment	src/lib.rs	/^mod alignment;$/;"	n
-apply	src/layout/many.rs	/^    fn apply(&mut self, size: Size) {$/;"	P	implementation:SizeMod
-as_size	src/border.rs	/^    pub(crate) fn as_size(&self) -> Size {$/;"	P	implementation:BorderSize
-attribute_storage	src/testing.rs	/^    attribute_storage: AttributeStorage<'bp>,$/;"	m	struct:TestInstance
-axis	src/border.rs	/^    axis: Axis,$/;"	m	struct:Line
-axis	src/layout/many.rs	/^    axis: Axis,$/;"	m	struct:SizeMod
-axis	src/layout/many.rs	/^    pub axis: Axis,$/;"	m	struct:Many
-backend	src/testing.rs	/^    backend: &'bp mut TestBackend,$/;"	m	struct:TestInstance
-backend	src/testing.rs	/^    backend: TestBackend,$/;"	m	struct:TestRunner
-basic_column	src/stacks/column.rs	/^    fn basic_column() {$/;"	f	module:test
-basic_row	src/stacks/row.rs	/^    fn basic_row() {$/;"	f	module:test
-blueprint	src/testing.rs	/^    blueprint: Blueprint,$/;"	m	struct:TestRunner
-border	src/layout/mod.rs	/^pub(crate) mod border;$/;"	n
-border	src/lib.rs	/^mod border;$/;"	n
-border_bottom_right	src/border.rs	/^    fn border_bottom_right() {$/;"	f	module:test
-border_left	src/border.rs	/^    fn border_left() {$/;"	f	module:test
-border_right	src/border.rs	/^    fn border_right() {$/;"	f	module:test
-border_size	src/border.rs	/^    fn border_size(&self, sides: Sides) -> BorderSize {$/;"	P	implementation:Border
-border_size	src/layout/border.rs	/^    pub border_size: BorderSize,$/;"	m	struct:BorderLayout
-border_style	src/border.rs	/^    pub border_style: BorderStyle,$/;"	m	struct:Border
-border_top	src/border.rs	/^    fn border_top() {$/;"	f	module:test
-border_top_bottom	src/border.rs	/^    fn border_top_bottom() {$/;"	f	module:test
-border_top_left	src/border.rs	/^    fn border_top_left() {$/;"	f	module:test
-bottom	src/alignment.rs	/^    fn bottom() {$/;"	f	module:test
-bottom	src/border.rs	/^    bottom: Line,$/;"	m	struct:BorderPainter
-bottom	src/border.rs	/^    pub bottom: u8,$/;"	m	struct:BorderSize
-bottom	src/padding.rs	/^    bottom: u16,$/;"	m	struct:PaddingValues
-bottom_left	src/alignment.rs	/^    fn bottom_left() {$/;"	f	module:test
-bottom_left	src/border.rs	/^    pub bottom_left: u8,$/;"	m	struct:BorderSize
-bottom_right	src/alignment.rs	/^    fn bottom_right() {$/;"	f	module:test
-bottom_right	src/border.rs	/^    pub bottom_right: u8,$/;"	m	struct:BorderSize
-bottom_up_vstack	src/stacks/vstack.rs	/^    fn bottom_up_vstack() {$/;"	f	module:test
-break_word_wrap	src/text.rs	/^    fn break_word_wrap() {$/;"	f	module:test
-buffer	src/canvas.rs	/^    buffer: Buffer,$/;"	m	struct:Canvas
-canvas	src/lib.rs	/^mod canvas;$/;"	n
-centre	src/alignment.rs	/^    fn centre() {$/;"	f	module:test
-centre_alignment	src/text.rs	/^    fn centre_alignment() {$/;"	f	module:test
-char_wrap_layout_multiple_spans	src/text.rs	/^    fn char_wrap_layout_multiple_spans() {$/;"	f	module:test
-clamp	src/overflow.rs	/^    fn clamp(&mut self, children: Size, parent: Size) {$/;"	P	implementation:Overflow
-clamp_prevents_scrolling	src/overflow.rs	/^    fn clamp_prevents_scrolling() {$/;"	f	module:test
-column	src/stacks/mod.rs	/^mod column;$/;"	n
-component_registry	src/testing.rs	/^    component_registry: ComponentRegistry,$/;"	m	struct:TestRunner
-container	src/container.rs	/^    fn container() {$/;"	f	module:test
-container	src/lib.rs	/^mod container;$/;"	n
-copy_from	src/canvas.rs	/^    fn copy_from(other: &mut Buffer, size: Size) -> Self {$/;"	P	implementation:Buffer
-custom_border	src/border.rs	/^    fn custom_border() {$/;"	f	module:test
-default	src/border.rs	/^    fn default() -> Self {$/;"	P	implementation:Sides
-default	src/canvas.rs	/^    fn default() -> Self {$/;"	P	implementation:Canvas
-default	src/position.rs	/^    fn default() -> Self {$/;"	P	implementation:Position
-default	src/stacks/column.rs	/^    fn default() -> Self {$/;"	P	implementation:Column
-default	src/stacks/hstack.rs	/^    fn default() -> Self {$/;"	P	implementation:HStack
-default	src/stacks/row.rs	/^    fn default() -> Self {$/;"	P	implementation:Row
-default	src/stacks/vstack.rs	/^    fn default() -> Self {$/;"	P	implementation:VStack
-direction	src/layout/many.rs	/^    pub direction: Direction,$/;"	m	struct:Many
-direction	src/overflow.rs	/^    direction: Direction,$/;"	m	struct:Overflow
-distribute_size	src/layout/expand.rs	/^fn distribute_size(weights: &[usize], mut total: usize) -> Vec<usize> {$/;"	f
-drain	src/canvas.rs	/^    fn drain(&mut self) -> impl Iterator<Item = (LocalPos, char, Style)> + '_ {$/;"	P	implementation:Buffer
-draw	src/border.rs	/^    fn draw<F>(&self, f: &mut F)$/;"	P	implementation:Line
-edges	src/border.rs	/^    pub edges: [char; 8],$/;"	m	struct:Border
-edges	src/border.rs	/^    pub fn edges(&self) -> [char; 8] {$/;"	P	implementation:BorderStyle
-end	src/border.rs	/^    end: u16,$/;"	m	struct:Line
-end_cap	src/border.rs	/^    end_cap: Option<Brush>,$/;"	m	struct:Line
-erase	src/canvas.rs	/^    pub fn erase(&mut self, pos: impl Into<LocalPos>) {$/;"	P	implementation:Canvas
-expand	src/expand.rs	/^    fn expand() {}$/;"	f	module:test
-expand	src/layout/mod.rs	/^pub(crate) mod expand;$/;"	n
-expand	src/lib.rs	/^mod expand;$/;"	n
-factory	src/testing.rs	/^    factory: Factory,$/;"	m	struct:TestRunner
-fixed_height	src/stacks/vstack.rs	/^    fn fixed_height() {$/;"	f	module:test
-fixed_size	src/border.rs	/^    fn fixed_size() {$/;"	f	module:test
-fixed_width	src/stacks/vstack.rs	/^    fn fixed_width() {$/;"	f	module:test
-floating_widgets	src/testing.rs	/^    floating_widgets: FloatingWidgets,$/;"	m	struct:TestInstance
-floats	src/position.rs	/^    fn floats(&self) -> bool {$/;"	P	implementation:Position
-fmt	src/border.rs	/^    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {$/;"	P	implementation:BorderStyle
-fn	src/layout/many.rs	/^    const fn new(max_size: Size, axis: Axis) -> Self {$/;"	C	implementation:SizeMod
-from	src/border.rs	/^    fn from(value: &str) -> Self {$/;"	P	implementation:Sides
-get	src/canvas.rs	/^    fn get(&self, pos: impl Into<LocalPos>) -> Option<&Cell> {$/;"	P	implementation:Buffer
-get	src/canvas.rs	/^    pub fn get(&mut self, pos: impl Into<LocalPos>) -> Option<(char, Style)> {$/;"	P	implementation:Canvas
-get_mut	src/canvas.rs	/^    fn get_mut(&mut self, pos: impl Into<LocalPos>) -> Option<&mut Cell> {$/;"	P	implementation:Buffer
-get_mut	src/canvas.rs	/^    pub fn get_mut(&mut self, pos: impl Into<LocalPos>) -> Option<(&mut char, &mut Style)> {$/;"	P	implementation:Canvas
-get_set_glyph	src/canvas.rs	/^    fn get_set_glyph() {$/;"	f	module:test
-globals	src/testing.rs	/^    globals: Globals,$/;"	m	struct:TestRunner
-glyph	src/border.rs	/^    glyph: char,$/;"	m	struct:Brush
-height	src/layout/border.rs	/^    pub height: Option<usize>,$/;"	m	struct:BorderLayout
-horz_edge	src/position.rs	/^    horz_edge: HorzEdge,$/;"	m	struct:Position
-hstack	src/stacks/mod.rs	/^mod hstack;$/;"	n
-inner	src/layout/many.rs	/^    inner: Size,$/;"	m	struct:SizeMod
-inner_bounds	src/border.rs	/^    fn inner_bounds(&self, mut pos: Pos, mut size: Size) -> Rect {$/;"	P	implementation:Border
-inner_bounds	src/padding.rs	/^    fn inner_bounds(&self, mut pos: Pos, mut size: Size) -> Rect {$/;"	P	implementation:Padding
-inner_size	src/layout/many.rs	/^    pub fn inner_size(&self) -> Size {$/;"	P	implementation:SizeMod
-inner_size	src/overflow.rs	/^    inner_size: Size,$/;"	m	struct:Overflow
-instance	src/testing.rs	/^    pub fn instance(&mut self) -> TestInstance<'_> {$/;"	P	implementation:TestRunner
-iter	src/canvas.rs	/^    fn iter(&self) -> impl Iterator<Item = (LocalPos, char, &Style)> + '_ {$/;"	P	implementation:Buffer
-layout	src/alignment.rs	/^    fn layout<'bp>($/;"	P	implementation:Align
-layout	src/border.rs	/^    fn layout<'bp>($/;"	P	implementation:Border
-layout	src/canvas.rs	/^    fn layout<'bp>($/;"	P	implementation:Canvas
-layout	src/container.rs	/^    fn layout<'bp>($/;"	P	implementation:Container
-layout	src/expand.rs	/^    fn layout<'bp>($/;"	P	implementation:Expand
-layout	src/layout/border.rs	/^    pub(crate) fn layout<'bp>($/;"	P	implementation:BorderLayout
-layout	src/layout/many.rs	/^    pub(crate) fn layout<'bp>($/;"	P	implementation:Many
-layout	src/lib.rs	/^mod layout;$/;"	n
-layout	src/overflow.rs	/^    fn layout<'bp>($/;"	P	implementation:Overflow
-layout	src/padding.rs	/^    fn layout<'bp>($/;"	P	implementation:Padding
-layout	src/position.rs	/^    fn layout<'bp>($/;"	P	implementation:Position
-layout	src/spacer.rs	/^    fn layout<'bp>($/;"	P	implementation:Spacer
-layout	src/stacks/column.rs	/^    fn layout<'bp>($/;"	P	implementation:Column
-layout	src/stacks/hstack.rs	/^    fn layout<'bp>($/;"	P	implementation:HStack
-layout	src/stacks/mod.rs	/^    fn layout<'bp>($/;"	P	implementation:Stack
-layout	src/stacks/row.rs	/^    fn layout<'bp>($/;"	P	implementation:Row
-layout	src/stacks/vstack.rs	/^    fn layout<'bp>($/;"	P	implementation:VStack
-layout	src/stacks/zstack.rs	/^    fn layout<'bp>($/;"	P	implementation:ZStack
-layout	src/text.rs	/^    fn layout<'bp>($/;"	P	implementation:Span
-layout	src/text.rs	/^    fn layout<'bp>($/;"	P	implementation:Text
-layout_all_expansions	src/layout/expand.rs	/^pub fn layout_all_expansions<'bp>($/;"	f
-layout_all_spacers	src/layout/spacers.rs	/^pub fn layout_all_spacers<'bp>($/;"	f
-left	src/alignment.rs	/^    fn left() {$/;"	f	module:test
-left	src/border.rs	/^    left: Line,$/;"	m	struct:BorderPainter
-left	src/border.rs	/^    pub left: u8,$/;"	m	struct:BorderSize
-left	src/padding.rs	/^    left: u16,$/;"	m	struct:PaddingValues
-line_break	src/text.rs	/^    fn line_break() {$/;"	f	module:test
-make	src/border.rs	/^pub(crate) fn make(attributes: &Attributes<'_>) -> Box<dyn AnyWidget> {$/;"	f
-many	src/layout/mod.rs	/^pub(crate) mod many;$/;"	n
-max_height	src/layout/border.rs	/^    pub max_height: Option<usize>,$/;"	m	struct:BorderLayout
-max_size	src/layout/many.rs	/^    max_size: Size,$/;"	m	struct:SizeMod
-max_width	src/layout/border.rs	/^    pub max_width: Option<usize>,$/;"	m	struct:BorderLayout
-middle	src/border.rs	/^    middle: Option<Brush>,$/;"	m	struct:Line
-min_height	src/layout/border.rs	/^    pub min_height: Option<usize>,$/;"	m	struct:BorderLayout
-min_width	src/layout/border.rs	/^    pub min_width: Option<usize>,$/;"	m	struct:BorderLayout
-multi_line_with_span	src/text.rs	/^    fn multi_line_with_span() {$/;"	f	module:test
-new	src/border.rs	/^    fn new(glyphs: &[char; 8], border_size: BorderSize, size: Size) -> Self {$/;"	P	implementation:BorderPainter
-new	src/border.rs	/^    pub fn new(glyph: char, width: u8) -> Self {$/;"	P	implementation:Brush
-new	src/canvas.rs	/^    pub fn new(size: Size) -> Self {$/;"	P	implementation:Buffer
-new	src/layout/many.rs	/^    const fn new(max_size: Size, axis: Axis) -> Self {$/;"	P	implementation:SizeMod
-new	src/layout/many.rs	/^    pub fn new(direction: Direction, axis: Axis, unconstrained: bool) -> Self {$/;"	P	implementation:Many
-new	src/testing.rs	/^    pub fn new() -> Self {$/;"	P	implementation:TestState
-new	src/testing.rs	/^    pub fn new(src: &str, size: impl Into<Size>) -> Self {$/;"	P	implementation:TestRunner
-no_space_left	src/layout/many.rs	/^    fn no_space_left(&self) -> bool {$/;"	P	implementation:SizeMod
-offset	src/overflow.rs	/^    offset: Pos,$/;"	m	struct:Overflow
-offset	src/overflow.rs	/^    pub fn offset(&self) -> Pos {$/;"	P	implementation:Overflow
-offset	src/testing.rs	/^    pub offset: Value<i32>,$/;"	m	struct:TestState
-overflow	src/lib.rs	/^mod overflow;$/;"	n
-overflow	src/overflow.rs	/^    fn overflow() {$/;"	f	module:test
-padding	src/lib.rs	/^mod padding;$/;"	n
-padding_all	src/padding.rs	/^    fn padding_all() {$/;"	f	module:test
-padding_bottom	src/padding.rs	/^    fn padding_bottom() {$/;"	f	module:test
-padding_bottom_inclusive	src/padding.rs	/^    fn padding_bottom_inclusive() {$/;"	f	module:test
-padding_left	src/padding.rs	/^    fn padding_left() {$/;"	f	module:test
-padding_left_inclusive	src/padding.rs	/^    fn padding_left_inclusive() {$/;"	f	module:test
-padding_right	src/padding.rs	/^    fn padding_right() {$/;"	f	module:test
-padding_right_inclusive	src/padding.rs	/^    fn padding_right_inclusive() {$/;"	f	module:test
-padding_top	src/padding.rs	/^    fn padding_top() {$/;"	f	module:test
-padding_top_inclusive	src/padding.rs	/^    fn padding_top_inclusive() {$/;"	f	module:test
-paint	src/border.rs	/^    fn paint<'bp>($/;"	P	implementation:Border
-paint	src/border.rs	/^    fn paint<F>(&mut self, f: &mut F)$/;"	P	implementation:BorderPainter
-paint	src/canvas.rs	/^    fn paint<'bp>($/;"	P	implementation:Canvas
-paint	src/expand.rs	/^    fn paint<'bp>($/;"	P	implementation:Expand
-paint	src/overflow.rs	/^    fn paint<'bp>($/;"	P	implementation:Overflow
-paint	src/padding.rs	/^    fn paint<'bp>($/;"	P	implementation:Padding
-paint	src/position.rs	/^    fn paint<'bp>($/;"	P	implementation:Position
-paint	src/spacer.rs	/^    fn paint<'bp>($/;"	P	implementation:Spacer
-paint	src/text.rs	/^    fn paint<'bp>($/;"	P	implementation:Text
-placement	src/position.rs	/^    placement: Placement,$/;"	m	struct:Position
-pop	src/layout/expand.rs	/^    fn pop(n: &mut usize) -> bool {$/;"	f	function:distribute_size
-pos	src/canvas.rs	/^    pos: Pos,$/;"	m	struct:Canvas
-position	src/alignment.rs	/^    fn position<'bp>($/;"	P	implementation:Align
-position	src/border.rs	/^    fn position<'bp>($/;"	P	implementation:Border
-position	src/canvas.rs	/^    fn position<'bp>($/;"	P	implementation:Canvas
-position	src/container.rs	/^    fn position<'bp>($/;"	P	implementation:Container
-position	src/expand.rs	/^    fn position<'bp>($/;"	P	implementation:Expand
-position	src/lib.rs	/^mod position;$/;"	n
-position	src/overflow.rs	/^    fn position<'bp>($/;"	P	implementation:Overflow
-position	src/padding.rs	/^    fn position<'bp>($/;"	P	implementation:Padding
-position	src/position.rs	/^    fn position<'bp>($/;"	P	implementation:Position
-position	src/spacer.rs	/^    fn position<'bp>($/;"	P	implementation:Spacer
-position	src/stacks/column.rs	/^    fn position<'bp>($/;"	P	implementation:Column
-position	src/stacks/hstack.rs	/^    fn position<'bp>($/;"	P	implementation:HStack
-position	src/stacks/mod.rs	/^    fn position<'bp>($/;"	P	implementation:Stack
-position	src/stacks/row.rs	/^    fn position<'bp>($/;"	P	implementation:Row
-position	src/stacks/vstack.rs	/^    fn position<'bp>($/;"	P	implementation:VStack
-position	src/stacks/zstack.rs	/^    fn position<'bp>($/;"	P	implementation:ZStack
-position	src/text.rs	/^    fn position<'bp>($/;"	P	implementation:Span
-position	src/text.rs	/^    fn position<'bp>($/;"	P	implementation:Text
-position_bottom	src/position.rs	/^    fn position_bottom() {$/;"	f	module:test
-position_bottom_left	src/position.rs	/^    fn position_bottom_left() {$/;"	f	module:test
-position_bottom_right	src/position.rs	/^    fn position_bottom_right() {$/;"	f	module:test
-position_right	src/position.rs	/^    fn position_right() {$/;"	f	module:test
-position_top	src/position.rs	/^    fn position_top() {$/;"	f	module:test
-position_top_left	src/position.rs	/^    fn position_top_left() {$/;"	f	module:test
-position_top_right	src/position.rs	/^    fn position_top_right() {$/;"	f	module:test
-positions	src/canvas.rs	/^    positions: Box<[Cell]>,$/;"	m	struct:Buffer
-put	src/canvas.rs	/^    fn put(&mut self, c: char, style: Style, pos: impl Into<LocalPos>) {$/;"	P	implementation:Buffer
-put	src/canvas.rs	/^    pub fn put(&mut self, c: char, style: Style, pos: impl Into<LocalPos>) {$/;"	P	implementation:Canvas
-register_default_widgets	src/lib.rs	/^pub fn register_default_widgets(factory: &mut Factory) {$/;"	f
-remove	src/canvas.rs	/^    fn remove(&mut self, pos: impl Into<LocalPos>) {$/;"	P	implementation:Buffer
-remove_glyph	src/canvas.rs	/^    fn remove_glyph() {$/;"	f	module:test
-render_assert	src/testing.rs	/^    pub fn render_assert(&mut self, expected: &str) -> &mut Self {$/;"	P	implementation:TestInstance
-resize_canvas	src/canvas.rs	/^    fn resize_canvas() {$/;"	f	module:test
-right	src/alignment.rs	/^    fn right() {$/;"	f	module:test
-right	src/border.rs	/^    pub right: u8,$/;"	m	struct:BorderSize
-right	src/border.rs	/^    right: Line,$/;"	m	struct:BorderPainter
-right	src/padding.rs	/^    right: u16,$/;"	m	struct:PaddingValues
-right_alignment	src/text.rs	/^    fn right_alignment() {$/;"	f	module:test
-row	src/stacks/mod.rs	/^mod row;$/;"	n
-scroll	src/overflow.rs	/^    pub fn scroll(&mut self, direction: Direction, amount: Pos) {$/;"	P	implementation:Overflow
-scroll_down	src/overflow.rs	/^    pub fn scroll_down(&mut self) {$/;"	P	implementation:Overflow
-scroll_down_by	src/overflow.rs	/^    pub fn scroll_down_by(&mut self, amount: i32) {$/;"	P	implementation:Overflow
-scroll_left	src/overflow.rs	/^    pub fn scroll_left(&mut self) {$/;"	P	implementation:Overflow
-scroll_left_by	src/overflow.rs	/^    pub fn scroll_left_by(&mut self, amount: i32) {$/;"	P	implementation:Overflow
-scroll_right	src/overflow.rs	/^    pub fn scroll_right(&mut self) {$/;"	P	implementation:Overflow
-scroll_right_by	src/overflow.rs	/^    pub fn scroll_right_by(&mut self, amount: i32) {$/;"	P	implementation:Overflow
-scroll_to	src/overflow.rs	/^    pub fn scroll_to(&mut self, pos: Pos) {$/;"	P	implementation:Overflow
-scroll_up	src/overflow.rs	/^    pub fn scroll_up(&mut self) {$/;"	P	implementation:Overflow
-scroll_up_by	src/overflow.rs	/^    pub fn scroll_up_by(&mut self, amount: i32) {$/;"	P	implementation:Overflow
-sides	src/border.rs	/^    pub sides: Sides,$/;"	m	struct:Border
-single_layout	src/layout/mod.rs	/^pub(crate) fn single_layout<'bp>($/;"	f
-size	src/canvas.rs	/^    size: Size,$/;"	m	struct:Buffer
-size	src/padding.rs	/^    fn size(&self) -> Size {$/;"	P	implementation:PaddingValues
-sized_by_child	src/border.rs	/^    fn sized_by_child() {$/;"	f	module:test
-spacer	src/lib.rs	/^mod spacer;$/;"	n
-spacers	src/layout/mod.rs	/^mod spacers;$/;"	n
-stacks	src/lib.rs	/^mod stacks;$/;"	n
-start	src/border.rs	/^    start: LocalPos,$/;"	m	struct:Line
-start_cap	src/border.rs	/^    start_cap: Option<Brush>,$/;"	m	struct:Line
-states	src/testing.rs	/^    states: &'bp mut States,$/;"	m	struct:TestInstance
-states	src/testing.rs	/^    states: States,$/;"	m	struct:TestRunner
-test	src/alignment.rs	/^mod test {$/;"	n
-test	src/border.rs	/^mod test {$/;"	n
-test	src/canvas.rs	/^mod test {$/;"	n
-test	src/container.rs	/^mod test {$/;"	n
-test	src/expand.rs	/^mod test {$/;"	n
-test	src/overflow.rs	/^mod test {$/;"	n
-test	src/padding.rs	/^mod test {$/;"	n
-test	src/position.rs	/^mod test {$/;"	n
-test	src/stacks/column.rs	/^mod test {$/;"	n
-test	src/stacks/row.rs	/^mod test {$/;"	n
-test	src/stacks/vstack.rs	/^mod test {$/;"	n
-test	src/stacks/zstack.rs	/^mod test {$/;"	n
-test	src/text.rs	/^mod test {$/;"	n
-testing	src/lib.rs	/^mod testing;$/;"	n
-text	src/lib.rs	/^mod text;$/;"	n
-text	src/testing.rs	/^    text: StringStorage,$/;"	m	struct:TestInstance
-text_key	src/text.rs	/^    text_key: LayoutKey,$/;"	m	struct:Text
-thick_border	src/border.rs	/^    fn thick_border() {$/;"	f	module:test
-thin_border	src/border.rs	/^    fn thin_border() {$/;"	f	module:test
-to_constraints	src/layout/many.rs	/^    fn to_constraints(&self) -> Constraints {$/;"	P	implementation:SizeMod
-top	src/alignment.rs	/^    fn top() {$/;"	f	module:test
-top	src/border.rs	/^    pub top: u8,$/;"	m	struct:BorderSize
-top	src/border.rs	/^    top: Line,$/;"	m	struct:BorderPainter
-top	src/padding.rs	/^    top: u16,$/;"	m	struct:PaddingValues
-top_left	src/alignment.rs	/^    fn top_left() {$/;"	f	module:test
-top_left	src/border.rs	/^    pub top_left: u8,$/;"	m	struct:BorderSize
-top_right	src/alignment.rs	/^    fn top_right() {$/;"	f	module:test
-top_right	src/border.rs	/^    pub top_right: u8,$/;"	m	struct:BorderSize
-translate	src/canvas.rs	/^    pub fn translate(&self, pos: Pos) -> LocalPos {$/;"	P	implementation:Canvas
-tree	src/testing.rs	/^    tree: WidgetTree<'bp>,$/;"	m	struct:TestInstance
-try_from	src/border.rs	/^    fn try_from(value: &EvalValue<'_>) -> Result<Self, Self::Error> {$/;"	P	implementation:BorderStyle
-try_from	src/border.rs	/^    fn try_from(value: &EvalValue<'_>) -> Result<Self, Self::Error> {$/;"	P	implementation:Sides
-try_from	src/layout/alignment.rs	/^    fn try_from(value: CommonVal<'_>) -> Result<Self, Self::Error> {$/;"	P	implementation:Alignment
-try_from	src/layout/mod.rs	/^    fn try_from(value: CommonVal<'_>) -> Result<Self, Self::Error> {$/;"	P	implementation:Axis
-try_from	src/layout/mod.rs	/^    fn try_from(value: CommonVal<'_>) -> Result<Self, Self::Error> {$/;"	P	implementation:Direction
-try_from	src/position.rs	/^    fn try_from(value: CommonVal<'_>) -> Result<Self, Self::Error> {$/;"	P	implementation:Placement
-try_from	src/text.rs	/^    fn try_from(value: CommonVal<'_>) -> Result<Self, Self::Error> {$/;"	P	implementation:TextAlignment
-unconstrained	src/layout/many.rs	/^    unconstrained: bool,$/;"	m	struct:Many
-unsized_empty_border	src/border.rs	/^    fn unsized_empty_border() {$/;"	f	module:test
-used_size	src/layout/many.rs	/^    pub(crate) used_size: SizeMod,$/;"	m	struct:Many
-value	src/testing.rs	/^    pub value: Value<usize>,$/;"	m	struct:TestState
-vert_edge	src/position.rs	/^    vert_edge: VertEdge,$/;"	m	struct:Position
-viewport	src/testing.rs	/^    viewport: Viewport,$/;"	m	struct:TestInstance
-vstack	src/stacks/mod.rs	/^mod vstack;$/;"	n
-vstack	src/stacks/vstack.rs	/^    fn vstack() {$/;"	f	module:test
-vstack_overflow	src/stacks/vstack.rs	/^    fn vstack_overflow() {$/;"	f	module:test
-width	src/border.rs	/^    width: u8,$/;"	m	struct:Brush
-width	src/layout/border.rs	/^    pub width: Option<usize>,$/;"	m	struct:BorderLayout
-will_draw	src/border.rs	/^    fn will_draw(&self) -> bool {$/;"	P	implementation:Line
-with_state	src/testing.rs	/^    pub fn with_state<F>(&mut self, mut f: F) -> &mut Self$/;"	P	implementation:TestInstance
-with_widget	src/testing.rs	/^    pub(crate) fn with_widget<F>(&mut self, mut f: F) -> &mut Self$/;"	P	implementation:TestInstance
-word_wrap	src/text.rs	/^    fn word_wrap() {$/;"	f	module:test
-word_wrap_excessive_space	src/text.rs	/^    fn word_wrap_excessive_space() {$/;"	f	module:test
-zstack	src/stacks/mod.rs	/^mod zstack;$/;"	n
-zstack	src/stacks/zstack.rs	/^    fn zstack() {$/;"	f	module:test
diff --git a/anathema-geometry/src/region.rs b/anathema-geometry/src/region.rs
index cbc6d691..8a6e5b5f 100644
--- a/anathema-geometry/src/region.rs
+++ b/anathema-geometry/src/region.rs
@@ -1,6 +1,6 @@
 use crate::{Pos, Size};
 
-/// A region in global space
+/// A normalized region in global space
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct Region {
     /// The starting position of the region
@@ -15,6 +15,7 @@ impl Region {
 
     /// Create a new instance of a region.
     pub const fn new(from: Pos, to: Pos) -> Self {
+        assert!(from.x <= to.x && from.y <= to.y, "region is non-normalized");
         Self { from, to }
     }
 
@@ -31,6 +32,32 @@ impl Region {
         true
     }
 
+    /// Get the size of the region
+    pub const fn size(&self) -> Size {
+        Size::new(
+            (self.to.x - self.from.x) as u16,
+            (self.to.y - self.from.y) as u16,
+        )
+    }
+
+    /// Get the position of the region.
+    /// This is equal to the top left corner of the region
+    pub const fn pos(&self) -> Pos {
+        self.from
+    }
+
+    /// Move the region to a new position
+    pub fn set_pos(&mut self, pos: Pos) {
+        self.from += pos;
+        self.to += pos;
+    }
+
+    /// Resize the region
+    pub fn resize(&mut self, size: Size) {
+        self.to.x = self.from.x + size.width as i32;
+        self.to.y = self.from.y + size.height as i32;
+    }
+
     /// Create a new region by intersecting two regions
     pub fn intersect_with(self, other: &Region) -> Self {
         // There is no intersection, making this a zero sized region
diff --git a/anathema-runtime/Cargo.toml b/anathema-runtime/Cargo.toml
deleted file mode 100644
index 3281f7e9..00000000
--- a/anathema-runtime/Cargo.toml
+++ /dev/null
@@ -1,31 +0,0 @@
-[package]
-name = "anathema-runtime"
-license = "MIT"
-description = "Anathema runtime"
-version.workspace = true
-edition.workspace = true
-documentation = "https://togglebyte.github.io/anathema-guide/"
-homepage = "https://github.com/togglebyte/anathema"
-repository = "https://github.com/togglebyte/anathema"
-
-[dependencies]
-anathema-geometry = { workspace = true }
-anathema-default-widgets = { workspace = true }
-anathema-backend = { workspace = true }
-anathema-state = { workspace = true }
-anathema-store = { workspace = true }
-anathema-templates = { workspace = true }
-anathema-widgets = { workspace = true }
-anathema-value-resolver = { workspace = true }
-flume = { workspace = true }
-notify = { workspace = true }
-puffin = { version = "0.19.1", features = ["web"], optional = true }
-puffin_http = { version = "0.16.1", optional = true }
-
-[features]
-default = []
-profile = ["puffin", "puffin_http"]
-filelog = []
-
-[lints]
-workspace = true
diff --git a/anathema-runtime/src/builder.rs b/anathema-runtime/src/builder.rs
deleted file mode 100644
index 46b7755a..00000000
--- a/anathema-runtime/src/builder.rs
+++ /dev/null
@@ -1,264 +0,0 @@
-use std::sync::atomic::Ordering;
-
-use anathema_backend::Backend;
-use anathema_default_widgets::register_default_widgets;
-use anathema_geometry::Size;
-use anathema_templates::{Document, Expression, ToSourceKind, Variables};
-use anathema_value_resolver::{Function, FunctionTable};
-use anathema_widgets::components::deferred::DeferredComponents;
-use anathema_widgets::components::events::Event;
-use anathema_widgets::components::{Component, ComponentId, ComponentRegistry, Emitter, ViewMessage};
-use anathema_widgets::tabindex::TabIndex;
-use anathema_widgets::{Factory, Widget};
-use notify::{Event as NotifyEvent, RecommendedWatcher, RecursiveMode, Watcher, recommended_watcher};
-
-use crate::REBUILD;
-pub use crate::error::{Error, Result};
-use crate::events::GlobalEventHandler;
-use crate::runtime::{Runtime, show_error};
-
-pub struct Builder<G> {
-    factory: Factory,
-    document: Document,
-    component_registry: ComponentRegistry,
-    emitter: Emitter,
-    message_receiver: flume::Receiver<ViewMessage>,
-    fps: u32,
-    size: Size,
-    global_event_handler: G,
-    hot_reload: bool,
-    function_table: FunctionTable,
-    variables: Variables,
-}
-
-impl<G: GlobalEventHandler> Builder<G> {
-    /// Create a new runtime builder with a receiver.
-    /// Use this if the `Emitter` was created outside of the runtime.
-    pub(super) fn with_receiver(
-        message_receiver: flume::Receiver<ViewMessage>,
-        emitter: Emitter,
-        document: Document,
-        size: Size,
-        global_event_handler: G,
-    ) -> Self {
-        let mut factory = Factory::new();
-        register_default_widgets(&mut factory);
-
-        Self {
-            factory,
-            document,
-            component_registry: ComponentRegistry::new(),
-            emitter,
-            message_receiver,
-            fps: 30,
-            size,
-            global_event_handler,
-            hot_reload: true,
-            function_table: FunctionTable::new(),
-            variables: Variables::new(),
-        }
-    }
-
-    /// Create a new runtime builder
-    pub(super) fn new(document: Document, size: Size, global_event_handler: G) -> Self {
-        let (tx, rx) = flume::unbounded();
-        let emitter = Emitter::from(tx);
-        Self::with_receiver(rx, emitter.clone(), document, size, global_event_handler)
-    }
-
-    /// Enable/Disable hot reloading
-    pub fn hot_reload(&mut self, value: bool) {
-        self.hot_reload = value;
-    }
-
-    /// Register a new widget
-    pub fn register_widget<T: Widget + Default + 'static>(&mut self, ident: &'static str) {
-        self.factory.register_default::<T>(ident);
-    }
-
-    /// Set the expected frame rate
-    pub fn fps(&mut self, fps: u32) {
-        self.fps = fps;
-    }
-
-    /// Returns an [Emitter] to send messages to components
-    pub fn emitter(&self) -> Emitter {
-        self.emitter.clone()
-    }
-
-    /// Registers a component as a template-only component.
-    ///
-    /// This component has no state or reacts to any events
-    pub fn template(&mut self, ident: impl Into<String>, template: impl ToSourceKind) -> Result<()> {
-        self.prototype(ident, template, || (), || ())
-    }
-
-    /// Registers a [Component] with the runtime.
-    /// This returns a unique [ComponentId] that is used to send messages to the component.
-    ///
-    /// A component can only be used once in a template.
-    /// If you want multiple instances, register the component as a prototype instead,
-    /// see [RuntimeBuilder::prototype].
-    pub fn component<C: Component>(
-        &mut self,
-        ident: impl Into<String>,
-        template: impl ToSourceKind,
-        component: C,
-        state: C::State,
-    ) -> Result<ComponentId<C::Message>> {
-        let id = self.document.add_component(ident, template.to_source_kind())?;
-        self.component_registry.add_component(id, component, state);
-        Ok(id.into())
-    }
-
-    /// Registers a [Component] with the runtime as long as the component and the associated state
-    /// implements the `Default` trait.
-    /// This returns a unique [ComponentId] that is used to send messages to the component.
-    pub fn default<C>(
-        &mut self,
-        ident: impl Into<String>,
-        template: impl ToSourceKind,
-    ) -> Result<ComponentId<C::Message>>
-    where
-        C: Component + Default,
-        C::State: Default,
-    {
-        let component = C::default();
-        let state = C::State::default();
-        let id = self.document.add_component(ident, template.to_source_kind())?;
-        self.component_registry.add_component(id, component, state);
-        Ok(id.into())
-    }
-
-    /// Registers a [Component] as a prototype with the [Runtime],
-    /// which allows for multiple instances of the component to exist the templates.
-    pub fn prototype<FC, FS, C>(
-        &mut self,
-        ident: impl Into<String>,
-        template: impl ToSourceKind,
-        proto: FC,
-        state: FS,
-    ) -> Result<()>
-    where
-        FC: 'static + Fn() -> C,
-        FS: 'static + FnMut() -> C::State,
-        C: Component + 'static,
-    {
-        let id = self.document.add_component(ident, template.to_source_kind())?;
-        self.component_registry.add_prototype(id, proto, state);
-        Ok(())
-    }
-
-    /// Assign a new event handler (make sure not to forget to add some mechanism to stop the
-    /// runtime)
-    pub fn with_global_event_handler<Eh>(self, global_event_handler: Eh) -> Builder<Eh>
-    where
-        Eh: Fn(Event, &mut TabIndex<'_, '_>, &mut DeferredComponents) -> Option<Event>,
-    {
-        Builder {
-            factory: self.factory,
-            document: self.document,
-            component_registry: self.component_registry,
-            emitter: self.emitter,
-            message_receiver: self.message_receiver,
-            fps: self.fps,
-            size: self.size,
-            global_event_handler,
-            hot_reload: self.hot_reload,
-            function_table: self.function_table,
-            variables: Variables::new(),
-        }
-    }
-
-    pub fn register_global(&mut self, key: impl Into<String>, value: impl Into<Expression>) -> Result<()> {
-        self.variables.define_global(key, value).map_err(|e| e.to_error(None))?;
-        Ok(())
-    }
-
-    pub fn finish<F, B>(mut self, backend: &mut B, mut f: F) -> Result<()>
-    where
-        F: FnMut(&mut Runtime<G>, &mut B) -> Result<()>,
-        B: Backend,
-    {
-        #[cfg(feature = "profile")]
-        let _puffin_server = {
-            let server_addr = format!("127.0.0.1:{}", puffin_http::DEFAULT_PORT);
-            let server = puffin_http::Server::new(&server_addr).unwrap();
-            puffin::set_scopes_on(true);
-            server
-        };
-
-        let blueprint = loop {
-            match self.document.compile(&mut self.variables) {
-                Ok(val) => break val,
-                // This can only show template errors.
-                // Widget errors doesn't become available until after the first tick.
-                Err(error) => match show_error(error.into(), backend, &self.document) {
-                    Ok(()) => return Err(Error::Stop),
-                    Err(Error::Reload) if self.hot_reload => {
-                        _ = self.document.reload_templates();
-                    }
-                    err => err?,
-                },
-            }
-        };
-
-        let watcher = self.set_watcher(self.hot_reload)?;
-
-        let mut inst = Runtime::new(
-            blueprint,
-            self.variables,
-            self.component_registry,
-            self.document,
-            self.factory,
-            self.message_receiver,
-            self.emitter,
-            watcher,
-            self.size,
-            self.fps,
-            self.global_event_handler,
-            self.function_table,
-            self.hot_reload,
-        );
-
-        f(&mut inst, backend)
-    }
-
-    fn set_watcher(&mut self, hot_reload: bool) -> Result<Option<RecommendedWatcher>> {
-        if !hot_reload {
-            return Ok(None);
-        }
-
-        let paths = self
-            .document
-            .template_paths()
-            .filter_map(|p| p.canonicalize().ok())
-            .collect::<Vec<_>>();
-
-        let mut watcher = recommended_watcher(move |event: std::result::Result<NotifyEvent, _>| match event {
-            Ok(event) => match event.kind {
-                notify::EventKind::Create(_) | notify::EventKind::Remove(_) | notify::EventKind::Modify(_) => {
-                    if paths.iter().any(|p| event.paths.contains(p)) {
-                        REBUILD.store(true, Ordering::Relaxed);
-                    }
-                }
-                notify::EventKind::Any | notify::EventKind::Access(_) | notify::EventKind::Other => (),
-            },
-            Err(_err) => (),
-        })?;
-
-        for path in self.document.template_paths() {
-            let path = path.canonicalize().unwrap();
-
-            if let Some(parent) = path.parent() {
-                watcher.watch(parent, RecursiveMode::NonRecursive)?;
-            }
-        }
-
-        Ok(Some(watcher))
-    }
-
-    pub fn register_function(&mut self, ident: impl Into<String>, f: impl Into<Function>) -> Result<()> {
-        Ok(self.function_table.insert(ident, f)?)
-    }
-}
diff --git a/anathema-runtime/src/error.rs b/anathema-runtime/src/error.rs
deleted file mode 100644
index ee01abc7..00000000
--- a/anathema-runtime/src/error.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-use std::error::Error as StdError;
-use std::fmt::{self, Display};
-
-use anathema_templates::error::Error as TemplateError;
-
-pub type Result<T> = std::result::Result<T, Error>;
-
-#[derive(Debug)]
-pub enum Error {
-    Template(TemplateError),
-    Widget(anathema_widgets::error::Error),
-    Notify(notify::Error),
-    Stop,
-    Reload,
-    InvalidComponentName,
-    Resolver(anathema_value_resolver::Error),
-}
-
-impl Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Template(template) => write!(f, "{template}"),
-            Self::Stop => write!(f, "stopping"),
-            Self::Reload => write!(f, "reloading"),
-            Self::Notify(err) => write!(f, "{err}"),
-            Self::Widget(err) => write!(f, "{err}"),
-            Self::Resolver(err) => write!(f, "{err}"),
-            Self::InvalidComponentName => write!(f, "no such component"),
-        }
-    }
-}
-
-impl StdError for Error {}
-
-impl From<TemplateError> for Error {
-    fn from(err: TemplateError) -> Self {
-        Self::Template(err)
-    }
-}
-
-impl From<notify::Error> for Error {
-    fn from(err: notify::Error) -> Self {
-        Self::Notify(err)
-    }
-}
-
-impl From<anathema_widgets::error::Error> for Error {
-    fn from(value: anathema_widgets::error::Error) -> Self {
-        Self::Widget(value)
-    }
-}
-
-impl From<anathema_value_resolver::Error> for Error {
-    fn from(value: anathema_value_resolver::Error) -> Self {
-        Self::Resolver(value)
-    }
-}
diff --git a/anathema-runtime/src/events.rs b/anathema-runtime/src/events.rs
deleted file mode 100644
index b38416c3..00000000
--- a/anathema-runtime/src/events.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-use anathema_widgets::components::deferred::DeferredComponents;
-use anathema_widgets::components::events::{Event, KeyCode, KeyEvent};
-use anathema_widgets::tabindex::TabIndex;
-
-pub trait GlobalEventHandler {
-    fn handle(
-        &self,
-        event: Event,
-        tabindex: &mut TabIndex<'_, '_>,
-        components: &mut DeferredComponents,
-    ) -> Option<Event>;
-}
-
-impl GlobalEventHandler for () {
-    fn handle(&self, event: Event, tabindex: &mut TabIndex<'_, '_>, _: &mut DeferredComponents) -> Option<Event> {
-        if let Event::Key(KeyEvent {
-            code: KeyCode::Tab,
-            ctrl: false,
-            ..
-        }) = event
-        {
-            tabindex.next();
-            return None;
-        }
-
-        if let Event::Key(KeyEvent {
-            code: KeyCode::BackTab, ..
-        }) = event
-        {
-            tabindex.prev();
-            return None;
-        }
-
-        if event.is_ctrl_c() {
-            return Some(Event::Stop);
-        }
-        Some(event)
-    }
-}
-
-impl<T> GlobalEventHandler for T
-where
-    T: Fn(Event, &mut TabIndex<'_, '_>, &mut DeferredComponents) -> Option<Event>,
-{
-    fn handle(
-        &self,
-        event: Event,
-        tabindex: &mut TabIndex<'_, '_>,
-        components: &mut DeferredComponents,
-    ) -> Option<Event> {
-        self(event, tabindex, components)
-    }
-}
diff --git a/anathema-runtime/src/lib.rs b/anathema-runtime/src/lib.rs
deleted file mode 100644
index b6e424a4..00000000
--- a/anathema-runtime/src/lib.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-// -----------------------------------------------------------------------------
-//   - Runtime -
-//   1. Creating the initial widget tree
-//   2. Runtime loop >----------------------------------------+
-//    ^  2.1. Wait for messages                               |
-//    |  2.2. Wait for events                                 v
-//    |  2.4. Was there events / messages / data changes? (no) (yes)
-//    |                                                    |    |
-//    +----------------------------------------------------+    |
-//    |       +-------------------------------------------------+
-//    |       |
-//    |       V
-//    |       1. Layout
-//    |       2. Position
-//    |       3. Draw
-//    +-----< 4. Run again
-//
-// -----------------------------------------------------------------------------
-
-use std::sync::atomic::AtomicBool;
-
-pub use crate::builder::Builder;
-pub use crate::error::{Error, Result};
-pub use crate::runtime::{Frame, Runtime};
-
-static REBUILD: AtomicBool = AtomicBool::new(false);
-
-mod error;
-
-pub mod builder;
-mod events;
-pub mod runtime;
diff --git a/anathema-runtime/src/renderonly.rs b/anathema-runtime/src/renderonly.rs
deleted file mode 100644
index fdb3effc..00000000
--- a/anathema-runtime/src/renderonly.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-use anathema_backend::{Backend, WidgetCycle};
-use anathema_state::{Changes, States};
-use anathema_store::tree::root_node;
-use anathema_templates::blueprints::Blueprint;
-use anathema_templates::{Document, Globals};
-use anathema_widgets::components::ComponentRegistry;
-use anathema_widgets::layout::{Constraints, Viewport};
-use anathema_widgets::{
-    eval_blueprint, ChangeList, Components, DirtyWidgets, Factory, FloatingWidgets, GlyphMap, WidgetTree,
-};
-
-pub use crate::error::Result;
-
-pub struct OneShot<T> {
-    pub(super) factory: Factory,
-    pub(super) blueprint: Blueprint,
-    pub(super) globals: Globals,
-    pub(super) document: Document,
-    pub(super) glyph_map: GlyphMap,
-    pub(super) backend: T,
-    pub(super) viewport: Viewport,
-    pub(super) constraints: Constraints,
-    pub(super) components: Components,
-    pub(super) dirty_widgets: DirtyWidgets,
-    pub(super) changes: Changes,
-    pub(super) component_registry: ComponentRegistry,
-    pub(super) floating_widgets: FloatingWidgets,
-    pub(super) changelist: ChangeList,
-}
-
-impl<T> OneShot<T>
-where
-    T: Backend,
-{
-    pub fn run(mut self) -> Result<()> {
-        panic!()
-        // let (blueprint, globals) = self.document.compile()?;
-        // let mut tree = WidgetTree::empty();
-        // let mut attribute_storage = AttributeStorage::empty();
-        // let mut scope = Scope::new();
-        // let mut states = States::new();
-
-        // let mut ctx = EvalContext::new(
-        //     &globals,
-        //     &self.factory,
-        //     &mut scope,
-        //     &mut states,
-        //     &mut self.component_registry,
-        //     &mut attribute_storage,
-        //     &mut self.floating_widgets,
-        //     &mut self.changelist,
-        //     &mut self.components,
-        //     &mut self.dirty_widgets,
-        //     &self.viewport,
-        //     &mut self.glyph_map,
-        //     true,
-        // );
-
-        // let mut view = tree.view_mut();
-        // let res = eval_blueprint(&blueprint, &mut ctx, root_node(), &mut view);
-
-        // let mut cycle = WidgetCycle::new(&mut self.backend, &mut tree, self.constraints);
-        // cycle.run(&mut ctx);
-
-        // self.backend.render(&mut self.glyph_map);
-        // self.backend.clear();
-
-        // Ok(())
-    }
-}
diff --git a/anathema-runtime/src/runtime/error.rs b/anathema-runtime/src/runtime/error.rs
deleted file mode 100644
index 939badaa..00000000
--- a/anathema-runtime/src/runtime/error.rs
+++ /dev/null
@@ -1,99 +0,0 @@
-use std::sync::atomic::{AtomicBool, Ordering};
-
-use anathema_backend::Backend;
-use anathema_templates::Document;
-use notify::{Event, RecommendedWatcher, RecursiveMode, Watcher, recommended_watcher};
-
-use super::Runtime;
-use crate::error::{Error, Result};
-
-static STOP_ERROR_RT: AtomicBool = AtomicBool::new(false);
-
-// TODO:
-// this should be cleaned up.
-// The file watcher is almost identitcal to the one in the runtime.
-pub(crate) fn show_error<B: Backend>(error: Error, backend: &mut B, document: &Document) -> Result<()> {
-    if STOP_ERROR_RT.load(Ordering::Relaxed) {
-        panic!("recursive error displays.");
-    }
-
-    let template_path = match &error {
-        Error::Template(error) => format!(": {}", error.path()),
-        Error::Widget(error) => match error.path.as_ref() {
-            Some(path) => format!(": {}", path.display()),
-            None => String::new(),
-        },
-        _ => String::new(),
-    };
-
-    let tpl = format!(
-        "
-align [alignment: 'centre']
-    border [background: 'red', foreground: 'black']
-        vstack
-            text [bold: true] 'Template error{template_path}'
-            text '{error}'
-    "
-    );
-
-    let doc = Document::new(tpl);
-
-    // File watchers here
-    let _watcher = set_watcher(document);
-
-    let mut builder = Runtime::builder(doc, backend);
-    builder.hot_reload(false);
-    let res = builder.finish(backend, |runtime, backend| {
-        runtime.with_frame(backend, |backend, mut frame| {
-            loop {
-                if STOP_ERROR_RT.load(Ordering::Relaxed) {
-                    break Err(Error::Reload);
-                }
-
-                frame.tick(backend)?;
-                frame.present(backend);
-                frame.cleanup();
-            }?;
-            backend.clear();
-            Err(Error::Stop)
-        })
-    });
-
-    // Reset
-    STOP_ERROR_RT.store(false, Ordering::Relaxed);
-
-    res
-}
-
-fn set_watcher(document: &Document) -> Result<RecommendedWatcher> {
-    let _paths = document
-        .template_paths()
-        .filter_map(|p| p.canonicalize().ok())
-        .collect::<Vec<_>>();
-
-    let mut watcher = recommended_watcher(move |event: std::result::Result<Event, _>| match event {
-        Ok(event) => match event.kind {
-            notify::EventKind::Create(_) | notify::EventKind::Remove(_) | notify::EventKind::Modify(_) => {
-                // NOTE: we'll let any changes to any files stop the error runtime,
-                // and let the main runtime attempt to restart again.
-                //
-                // This might change in the future but it works for now
-
-                // if paths.iter().any(|p| event.paths.contains(p)) {
-                STOP_ERROR_RT.store(true, Ordering::Relaxed);
-                // }
-            }
-            notify::EventKind::Any | notify::EventKind::Access(_) | notify::EventKind::Other => (),
-        },
-        Err(_err) => (),
-    })?;
-
-    for path in document.template_paths() {
-        let Some(path) = path.parent() else { continue };
-        let Ok(path) = path.canonicalize() else { continue };
-
-        watcher.watch(&path, RecursiveMode::NonRecursive)?;
-    }
-
-    Ok(watcher)
-}
diff --git a/anathema-runtime/src/runtime/mod.rs b/anathema-runtime/src/runtime/mod.rs
deleted file mode 100644
index 224ca467..00000000
--- a/anathema-runtime/src/runtime/mod.rs
+++ /dev/null
@@ -1,784 +0,0 @@
-use std::collections::VecDeque;
-use std::sync::atomic::Ordering;
-use std::time::{Duration, Instant};
-
-use anathema_backend::{Backend, WidgetCycle};
-use anathema_geometry::Size;
-use anathema_state::{Changes, StateId, States, clear_all_changes, clear_all_subs, drain_changes};
-use anathema_store::tree::root_node;
-use anathema_templates::blueprints::Blueprint;
-use anathema_templates::{Document, Expression, Variables};
-use anathema_value_resolver::{AttributeStorage, FunctionTable, Scope};
-use anathema_widgets::components::deferred::{CommandKind, DeferredComponents};
-use anathema_widgets::components::events::{Event, EventType};
-use anathema_widgets::components::{
-    AnyComponentContext, AssociatedEvents, ComponentKind, ComponentRegistry, Emitter, MessageReceiver, Recipient,
-    ViewMessage,
-};
-use anathema_widgets::layout::{LayoutCtx, Viewport};
-use anathema_widgets::query::Children;
-use anathema_widgets::tabindex::{Index, TabIndex};
-use anathema_widgets::{
-    Component, Components, DirtyWidgets, Factory, FloatingWidgets, GlyphMap, WidgetContainer, WidgetId, WidgetKind,
-    WidgetTree, eval_blueprint, update_widget,
-};
-use flume::Receiver;
-use notify::RecommendedWatcher;
-
-pub(crate) use self::error::show_error;
-use crate::builder::Builder;
-pub use crate::error::Result;
-use crate::events::GlobalEventHandler;
-use crate::{Error, REBUILD};
-
-mod error;
-mod testing;
-
-/// Anathema runtime
-pub struct Runtime<G> {
-    pub(super) blueprint: Blueprint,
-    pub(super) variables: Variables,
-    pub(super) factory: Factory,
-    pub(super) states: States,
-    pub(super) component_registry: ComponentRegistry,
-    pub(super) components: Components,
-    pub(super) document: Document,
-    pub(super) floating_widgets: FloatingWidgets,
-    pub(super) assoc_events: AssociatedEvents,
-    pub(super) glyph_map: GlyphMap,
-    pub(super) changes: Changes,
-    pub(super) viewport: Viewport,
-    pub(super) emitter: Emitter,
-    pub(super) sleep_micros: u64,
-    pub(super) message_receiver: flume::Receiver<ViewMessage>,
-    pub(super) dt: Instant,
-    pub(super) _watcher: Option<RecommendedWatcher>,
-    pub(super) deferred_components: DeferredComponents,
-    pub(super) global_event_handler: G,
-    pub(super) function_table: FunctionTable,
-    pub(super) hot_reload: bool,
-}
-
-impl Runtime<()> {
-    /// Create a runtime builder
-    pub fn builder<B: Backend>(doc: Document, backend: &B) -> Builder<()> {
-        Builder::new(doc, backend.size(), ())
-    }
-
-    pub fn register_global(&mut self, key: impl Into<String>, value: impl Into<Expression>) -> Result<()> {
-        self.variables.define_global(key, value).map_err(|e| e.to_error(None))?;
-        Ok(())
-    }
-
-    /// Create a runtime builder using an existing emitter
-    pub fn with_receiver<B: Backend>(
-        message_receiver: MessageReceiver,
-        emitter: Emitter,
-        doc: Document,
-        backend: &B,
-    ) -> Builder<()> {
-        Builder::with_receiver(message_receiver, emitter, doc, backend.size(), ())
-    }
-}
-
-impl<G: GlobalEventHandler> Runtime<G> {
-    pub(crate) fn new(
-        blueprint: Blueprint,
-        variables: Variables,
-        component_registry: ComponentRegistry,
-        document: Document,
-        factory: Factory,
-        message_receiver: Receiver<ViewMessage>,
-        emitter: Emitter,
-        watcher: Option<RecommendedWatcher>,
-        size: Size,
-        fps: u32,
-        global_event_handler: G,
-        function_table: FunctionTable,
-        hot_reload: bool,
-    ) -> Self {
-        let sleep_micros: u64 = ((1.0 / fps as f64) * 1000.0 * 1000.0) as u64;
-
-        Self {
-            component_registry,
-            components: Components::new(),
-            document,
-            factory,
-            states: States::new(),
-            floating_widgets: FloatingWidgets::empty(),
-            assoc_events: AssociatedEvents::new(),
-            glyph_map: GlyphMap::empty(),
-            blueprint,
-            variables,
-            changes: Changes::empty(),
-            viewport: Viewport::new(size),
-            message_receiver,
-            emitter,
-            dt: Instant::now(),
-            _watcher: watcher,
-            deferred_components: DeferredComponents::new(),
-            sleep_micros,
-            global_event_handler,
-            function_table,
-            hot_reload,
-        }
-    }
-
-    // TODO
-    // Rename Frame as it does not represent an individual frame
-    // but rather something that can continuously draw.
-    pub fn with_frame<B, F>(&mut self, backend: &mut B, mut f: F) -> Result<()>
-    where
-        B: Backend,
-        F: FnMut(&mut B, Frame<'_, '_, G>) -> Result<()>,
-    {
-        let mut tree = WidgetTree::empty();
-        let mut attribute_storage = AttributeStorage::empty();
-        let mut frame = self.next_frame(&mut tree, &mut attribute_storage)?;
-        frame.init_tree()?;
-        f(backend, frame)
-    }
-
-    pub fn run<B: Backend>(&mut self, backend: &mut B) -> Result<()> {
-        let sleep_micros = self.sleep_micros;
-
-        loop {
-            let res = self.with_frame(backend, |backend, mut frame| {
-                // Perform the initial tick so tab index has a tree to work with.
-                // This means we can not react to any events in this tick as the tree does not
-                // yet have any widgets or components.
-                _ = frame.tick(backend);
-                TabIndex::new(&mut frame.tabindex, frame.tree.view()).next();
-
-                if let Some(current) = frame.tabindex.as_ref() {
-                    frame.with_component(current.widget_id, current.state_id, |comp, children, ctx| {
-                        comp.dyn_component.any_focus(children, ctx)
-                    });
-                }
-
-                loop {
-                    if REBUILD.swap(false, Ordering::Relaxed) {
-                        frame.force_unmount_return();
-                        backend.clear();
-                        break Err(Error::Reload);
-                    }
-
-                    match frame.tick(backend) {
-                        Ok(_duration) => (),
-                        Err(err) => match err {
-                            err @ (Error::Template(_) | Error::Widget(_)) => {
-                                match show_error(err, backend, frame.document) {
-                                    Err(Error::Stop) => return Err(Error::Stop),
-                                    // NOTE: we continue here as this should
-                                    // cause the REBUILD to trigger
-                                    Err(Error::Reload) => continue,
-                                    _ => unreachable!("show_error only return stop or rebuild"),
-                                }
-                            }
-                            err => return Err(err),
-                        },
-                    }
-
-                    if frame.layout_ctx.stop_runtime {
-                        return Err(Error::Stop);
-                    }
-
-                    if frame.needs_paint {
-                        frame.present(backend);
-                        frame.needs_paint = false;
-                    }
-
-                    frame.cleanup();
-                    std::thread::sleep(Duration::from_micros(sleep_micros));
-                }
-            });
-
-            match res {
-                Ok(()) => panic!(),
-                Err(e) => match e {
-                    Error::Template(_) | Error::Widget(_) => {
-                        unreachable!("these error variants are handled inside the tick loop")
-                    }
-                    Error::Stop => return Err(Error::Stop),
-
-                    Error::Reload => loop {
-                        // Reload can fail if the template fails to parse.
-                        match self.reload() {
-                            Ok(()) => break,
-                            Err(e) => {
-                                if let Err(Error::Stop) = show_error(e, backend, &self.document) {
-                                    return Err(Error::Stop);
-                                }
-                            }
-                        }
-                    },
-                    e => return Err(e),
-                },
-            }
-
-            if !self.hot_reload {
-                break;
-            }
-        }
-        Ok(())
-    }
-
-    pub fn next_frame<'frame, 'bp>(
-        &'bp mut self,
-        tree: &'frame mut WidgetTree<'bp>,
-        attribute_storage: &'frame mut AttributeStorage<'bp>,
-    ) -> Result<Frame<'frame, 'bp, G>> {
-        let layout_ctx = LayoutCtx::new(
-            &self.variables,
-            &self.factory,
-            &mut self.states,
-            attribute_storage,
-            &mut self.components,
-            &mut self.component_registry,
-            &mut self.floating_widgets,
-            &mut self.glyph_map,
-            &mut self.viewport,
-            &self.function_table,
-        );
-
-        let inst = Frame {
-            document: &self.document,
-            blueprint: &self.blueprint,
-            tree,
-            layout_ctx,
-            changes: &mut self.changes,
-            sleep_micros: self.sleep_micros,
-
-            assoc_events: &mut self.assoc_events,
-            deferred_components: &mut self.deferred_components,
-
-            emitter: &self.emitter,
-            message_receiver: &self.message_receiver,
-
-            dt: &mut self.dt,
-            force_layout: true,
-            needs_paint: true,
-            post_cycle_events: VecDeque::new(),
-
-            global_event_handler: &self.global_event_handler,
-            tabindex: None,
-            dirty_widgets: DirtyWidgets::empty(),
-        };
-
-        Ok(inst)
-    }
-
-    pub(super) fn reload(&mut self) -> Result<()> {
-        clear_all_changes();
-        clear_all_subs();
-
-        self.components = Components::new();
-        self.floating_widgets = FloatingWidgets::empty();
-
-        // Reload templates
-        self.document.reload_templates()?;
-
-        let blueprint = self.document.compile(&mut self.variables)?;
-        self.blueprint = blueprint;
-
-        Ok(())
-    }
-}
-
-pub struct Frame<'rt, 'bp, G> {
-    document: &'bp Document,
-    blueprint: &'bp Blueprint,
-    pub tree: &'rt mut WidgetTree<'bp>,
-    deferred_components: &'rt mut DeferredComponents,
-    layout_ctx: LayoutCtx<'rt, 'bp>,
-    changes: &'rt mut Changes,
-    assoc_events: &'rt mut AssociatedEvents,
-    sleep_micros: u64,
-    emitter: &'rt Emitter,
-    message_receiver: &'rt flume::Receiver<ViewMessage>,
-    dt: &'rt mut Instant,
-    force_layout: bool,
-    needs_paint: bool,
-    post_cycle_events: VecDeque<Event>,
-    dirty_widgets: DirtyWidgets,
-
-    global_event_handler: &'rt G,
-    pub tabindex: Option<Index>,
-}
-
-impl<'rt, 'bp, G: GlobalEventHandler> Frame<'rt, 'bp, G> {
-    /// Unmount all components and return them to storage
-    pub fn force_unmount_return(mut self) {
-        // call unmount on all components
-        for i in 0..self.layout_ctx.components.len() {
-            let Some((widget_id, state_id)) = self.layout_ctx.components.get_ticking(i) else { continue };
-            let event = Event::Unmount;
-            self.send_event_to_component(event, widget_id, state_id);
-        }
-
-        self.return_state_and_component();
-    }
-
-    pub fn handle_global_event(&mut self, event: Event) -> Option<Event> {
-        let mut tabindex = TabIndex::new(&mut self.tabindex, self.tree.view());
-
-        let event = self
-            .global_event_handler
-            .handle(event, &mut tabindex, self.deferred_components);
-
-        if tabindex.changed {
-            let prev = tabindex.consume();
-            if let Some(prev) = prev {
-                self.with_component(prev.widget_id, prev.state_id, |comp, children, ctx| {
-                    comp.dyn_component.any_blur(children, ctx)
-                });
-            }
-
-            if let Some(current) = self.tabindex.as_ref() {
-                self.with_component(current.widget_id, current.state_id, |comp, children, ctx| {
-                    comp.dyn_component.any_focus(children, ctx)
-                });
-            }
-        }
-
-        event
-    }
-
-    pub fn event(&mut self, event: Event) {
-        #[cfg(feature = "profile")]
-        puffin::profile_function!();
-
-        let Some(event) = self.handle_global_event(event) else { return };
-        if let Event::Stop = event {
-            self.layout_ctx.stop_runtime = true;
-            return;
-        }
-
-        match event {
-            Event::Noop => (),
-            Event::Stop => todo!(),
-
-            // Component specific event
-            Event::Blur | Event::Focus | Event::Key(_) => {
-                let Some(Index {
-                    widget_id, state_id, ..
-                }) = self.tabindex
-                else {
-                    return;
-                };
-                self.send_event_to_component(event, widget_id, state_id);
-            }
-            Event::Mouse(_) | Event::Resize(_) => {
-                for i in 0..self.layout_ctx.components.len() {
-                    let Some((widget_id, state_id)) = self.layout_ctx.components.get(i) else { continue };
-                    self.send_event_to_component(event, widget_id, state_id);
-                }
-            }
-            Event::Tick(_) | Event::Mount | Event::Unmount => panic!("this event should never be sent to the runtime"),
-        }
-    }
-
-    // Should be called only once to initialise the node tree.
-    pub fn init_tree(&mut self) -> Result<()> {
-        let mut ctx = self.layout_ctx.eval_ctx(None, None);
-        eval_blueprint(
-            self.blueprint,
-            &mut ctx,
-            &Scope::root(),
-            root_node(),
-            &mut self.tree.view(),
-        )?;
-
-        Ok(())
-    }
-
-    pub fn tick<B: Backend>(&mut self, backend: &mut B) -> Result<Duration> {
-        #[cfg(feature = "profile")]
-        puffin::GlobalProfiler::lock().new_frame();
-
-        let now = Instant::now();
-        let elapsed = self.handle_messages(now);
-        self.poll_events(elapsed, now, backend);
-        self.drain_deferred_commands();
-        self.drain_assoc_events();
-        self.tick_components(self.dt.elapsed());
-
-        // TODO:
-        // this secondary call is here to deal with changes causing changes
-        // which happens when values are removed or inserted and indices needs updating
-        self.apply_changes()?;
-        self.apply_changes()?;
-
-        self.cycle(backend)?;
-
-        self.init_new_components();
-        self.post_cycle_events();
-
-        *self.dt = Instant::now();
-
-        match self.layout_ctx.stop_runtime {
-            false => Ok(now.elapsed()),
-            true => Err(Error::Stop),
-        }
-    }
-
-    pub fn present<B: Backend>(&mut self, backend: &mut B) {
-        #[cfg(feature = "profile")]
-        puffin::profile_function!();
-
-        backend.render(self.layout_ctx.glyph_map);
-        backend.clear();
-    }
-
-    pub fn cleanup(&mut self) {
-        #[cfg(feature = "profile")]
-        puffin::profile_function!();
-        for key in self.tree.drain_removed() {
-            self.layout_ctx.attribute_storage.try_remove(key);
-            self.layout_ctx.floating_widgets.try_remove(key);
-            self.layout_ctx.components.try_remove(key);
-            if let Some(Index { widget_id, .. }) = self.tabindex {
-                if widget_id == key {
-                    self.tabindex.take();
-                }
-            }
-        }
-    }
-
-    fn handle_messages(&mut self, fps_now: Instant) -> Duration {
-        #[cfg(feature = "profile")]
-        puffin::profile_function!();
-
-        while let Ok(msg) = self.message_receiver.try_recv() {
-            let (widget_id, state_id) = match msg.recipient() {
-                Recipient::ComponentId(id) => {
-                    let val = self
-                        .layout_ctx
-                        .components
-                        .get_by_component_id(id)
-                        .map(|e| (e.widget_id, e.state_id));
-                    let Some(id_and_state) = val else { continue };
-                    id_and_state
-                }
-                Recipient::WidgetId(id) => {
-                    let state_id = self.layout_ctx.components.get_by_widget_id(id).map(|(_, state)| state);
-                    let Some(state_id) = state_id else { continue };
-                    (id, state_id)
-                }
-            };
-
-            self.with_component(widget_id, state_id, |comp, elements, ctx| {
-                comp.dyn_component.any_message(elements, ctx, msg.payload())
-            });
-
-            // Make sure event handling isn't holding up the rest of the event loop.
-            if fps_now.elapsed().as_micros() as u64 >= self.sleep_micros / 2 {
-                break;
-            }
-        }
-
-        fps_now.elapsed()
-    }
-
-    fn poll_events<B: Backend>(&mut self, remaining: Duration, fps_now: Instant, backend: &mut B) {
-        while let Some(event) = backend.next_event(remaining) {
-            if let Event::Resize(size) = event {
-                self.layout_ctx.viewport.resize(size);
-                self.force_layout = true;
-                backend.resize(size, self.layout_ctx.glyph_map);
-            }
-
-            if let Event::Stop = event {
-                self.layout_ctx.stop_runtime = true;
-                break;
-            }
-
-            match event.into() {
-                EventType::PreCycle => {
-                    // This is a pre-cycle event, we should notify immediately.
-                    self.event(event);
-                }
-                EventType::PostCycle => {
-                    // This is a post-cycle event, we should notify after the cycle is done.
-                    self.post_cycle_events.push_back(event);
-                }
-            }
-
-            // Make sure event handling isn't holding up the rest of the event loop.
-            if fps_now.elapsed().as_micros() as u64 > self.sleep_micros {
-                break;
-            }
-        }
-    }
-
-    fn drain_deferred_commands(&mut self) {
-        #[cfg(feature = "profile")]
-        puffin::profile_function!();
-
-        // TODO: let's keep some memory around to drain this into instead of allocating
-        // a new vector every time.
-        // E.g `self.deferred_components.drain_into(&mut self.deferred_buffer)`
-        // Nb: Add drain_into to DeferredComponents
-        let commands = self.deferred_components.drain().collect::<Vec<_>>();
-        for mut cmd in commands {
-            for index in 0..self.layout_ctx.components.len() {
-                let Some((widget_id, state_id)) = self.layout_ctx.components.get(index) else { continue };
-                let Some(comp) = self.tree.get_ref(widget_id) else { continue };
-                let WidgetContainer {
-                    kind: WidgetKind::Component(comp),
-                    ..
-                } = comp
-                else {
-                    continue;
-                };
-                let attributes = self.layout_ctx.attribute_storage.get(widget_id);
-                if !cmd.filter_component(comp, attributes) {
-                    continue;
-                }
-
-                // -----------------------------------------------------------------------------
-                //   - Set focus -
-                //   TODO: here is another candidate for refactoring to make it
-                //   less cludgy and verbose.
-                // -----------------------------------------------------------------------------
-                // Blur the current component if the message is a `Focus` message
-                if let CommandKind::Focus = cmd.kind {
-                    // If this component current has focus ignore this command
-                    if let Some(index) = self.tabindex.as_ref() {
-                        if index.widget_id == widget_id {
-                            continue;
-                        }
-                    }
-
-                    // here we can find the component that should receive focus
-                    let new_index = self
-                        .with_component(widget_id, state_id, |comp, children, ctx| {
-                            if comp.dyn_component.any_accept_focus() {
-                                let index = Index {
-                                    path: children.parent_path().into(),
-                                    index: comp.tabindex,
-                                    widget_id,
-                                    state_id,
-                                };
-
-                                comp.dyn_component.any_focus(children, ctx);
-
-                                Some(index)
-                            } else {
-                                None
-                            }
-                        })
-                        .flatten();
-
-                    if let Some(index) = new_index {
-                        // If there is currently a component with focus that component
-                        // should only lose focus if the selected component accepts focus.
-                        if let Some(old) = self.tabindex.replace(index) {
-                            self.with_component(old.widget_id, old.state_id, |comp, children, ctx| {
-                                comp.dyn_component.any_blur(children, ctx)
-                            });
-                        }
-                    }
-                }
-
-                // -----------------------------------------------------------------------------
-                //   - Send message -
-                // -----------------------------------------------------------------------------
-                if let CommandKind::SendMessage(msg) = cmd.kind {
-                    self.with_component(widget_id, state_id, |comp, children, ctx| {
-                        comp.dyn_component.any_message(children, ctx, msg);
-                    });
-                    break;
-                }
-            }
-        }
-    }
-
-    fn drain_assoc_events(&mut self) {
-        #[cfg(feature = "profile")]
-        puffin::profile_function!();
-
-        while let Some(assoc_event) = self.assoc_events.next() {
-            let mut parent = assoc_event.parent;
-            let external_ident = self.document.strings.get_ref_unchecked(assoc_event.external());
-            let internal_ident = self.document.strings.get_ref_unchecked(assoc_event.internal());
-            let sender = self.document.strings.get_ref_unchecked(assoc_event.sender);
-            let sender_id = assoc_event.sender_id;
-            let mut event = assoc_event.to_event(internal_ident, external_ident, sender, sender_id);
-
-            loop {
-                let Some((widget_id, state_id)) = self.layout_ctx.components.get_by_widget_id(parent.into()) else {
-                    return;
-                };
-
-                let stop_propagation = self
-                    .with_component(widget_id, state_id, |comp, children, ctx| {
-                        let next_parent = ctx.parent();
-                        comp.dyn_component.any_component_event(children, ctx, &mut event);
-
-                        parent = match next_parent {
-                            Some(p) => p,
-                            None => return true,
-                        };
-
-                        event.should_stop_propagation()
-                    })
-                    .unwrap_or(true);
-
-                if stop_propagation {
-                    break;
-                }
-            }
-        }
-    }
-
-    fn cycle<B: Backend>(&mut self, backend: &mut B) -> Result<()> {
-        #[cfg(feature = "profile")]
-        puffin::profile_function!();
-
-        if !self.force_layout && self.dirty_widgets.is_empty() {
-            return Ok(());
-        }
-
-        let mut cycle = WidgetCycle::new(backend, self.tree.view(), self.layout_ctx.viewport.constraints());
-        cycle.run(&mut self.layout_ctx, self.force_layout, &mut self.dirty_widgets)?;
-
-        self.force_layout = false;
-        self.needs_paint = true;
-
-        Ok(())
-    }
-
-    fn apply_changes(&mut self) -> Result<()> {
-        #[cfg(feature = "profile")]
-        puffin::profile_function!();
-
-        drain_changes(self.changes);
-
-        if self.changes.is_empty() {
-            return Ok(());
-        }
-
-        // self.needs_layout = true;
-        let mut tree = self.tree.view();
-
-        self.changes.iter().try_for_each(|(sub, change)| {
-            sub.iter().try_for_each(|value_id| {
-                let widget_id = value_id.key();
-
-                // check that the node hasn't already been removed
-                if !tree.contains(widget_id) {
-                    return Result::Ok(());
-                }
-
-                tree.with_value_mut(widget_id, |_path, widget, tree| {
-                    update_widget(
-                        widget,
-                        value_id,
-                        change,
-                        tree,
-                        &mut self.layout_ctx,
-                        &mut self.dirty_widgets,
-                    )
-                })
-                .unwrap_or(Ok(()))?;
-
-                Result::Ok(())
-            })?;
-
-            Result::Ok(())
-        })?;
-
-        self.changes.clear();
-
-        Ok(())
-    }
-
-    fn send_event_to_component(&mut self, event: Event, widget_id: WidgetId, state_id: StateId) {
-        self.with_component(widget_id, state_id, |comp, elements, ctx| {
-            comp.dyn_component.any_event(elements, ctx, event);
-        });
-    }
-
-    fn with_component<F, U>(&mut self, widget_id: WidgetId, state_id: StateId, f: F) -> Option<U>
-    where
-        F: FnOnce(&mut Component<'_>, Children<'_, '_>, AnyComponentContext<'_, '_>) -> U,
-    {
-        let mut tree = self.tree.view();
-
-        tree.with_value_mut(widget_id, |_path, container, children| {
-            let WidgetKind::Component(component) = &mut container.kind else {
-                panic!("this is always a component")
-            };
-
-            let Some(state) = self.layout_ctx.states.get_mut(state_id) else {
-                panic!("a component always has a state")
-            };
-
-            self.layout_ctx
-                .attribute_storage
-                .with_mut(widget_id, |attributes, storage| {
-                    let elements = Children::new(children, storage, &mut self.dirty_widgets);
-
-                    let ctx = AnyComponentContext::new(
-                        component.parent.map(Into::into),
-                        component.name_id,
-                        widget_id,
-                        state_id,
-                        component.assoc_functions,
-                        self.assoc_events,
-                        self.deferred_components,
-                        attributes,
-                        Some(state),
-                        self.emitter,
-                        self.layout_ctx.viewport,
-                        &mut self.layout_ctx.stop_runtime,
-                        &self.document.strings,
-                    );
-
-                    f(component, elements, ctx)
-                })
-        })?
-    }
-
-    fn tick_components(&mut self, dt: Duration) {
-        #[cfg(feature = "profile")]
-        puffin::profile_function!();
-
-        for i in 0..self.layout_ctx.components.len() {
-            let Some((widget_id, state_id)) = self.layout_ctx.components.get_ticking(i) else { continue };
-            let event = Event::Tick(dt);
-            self.send_event_to_component(event, widget_id, state_id);
-        }
-    }
-
-    fn init_new_components(&mut self) {
-        while let Some((widget_id, state_id)) = self.layout_ctx.new_components.pop() {
-            self.with_component(widget_id, state_id, |comp, elements, ctx| {
-                comp.dyn_component.any_event(elements, ctx, Event::Mount);
-            });
-        }
-    }
-
-    // Return the state for each component back into the component registry
-    fn return_state_and_component(self) {
-        // Return all states
-        let mut tree = WidgetTree::empty();
-        std::mem::swap(&mut tree, self.tree);
-
-        for (_, widget) in tree.values().into_iter() {
-            let WidgetKind::Component(comp) = widget.kind else { continue };
-            let ComponentKind::Instance = comp.kind else { continue };
-            let state = self.layout_ctx.states.remove(comp.state_id).take();
-            self.layout_ctx
-                .component_registry
-                .return_component(comp.component_id, comp.dyn_component, state);
-        }
-    }
-
-    fn post_cycle_events(&mut self) {
-        while let Some(event) = self.post_cycle_events.pop_front() {
-            self.event(event);
-        }
-    }
-}
diff --git a/anathema-runtime/src/runtime/testing.rs b/anathema-runtime/src/runtime/testing.rs
deleted file mode 100644
index 4d6637f1..00000000
--- a/anathema-runtime/src/runtime/testing.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-use std::time::{Duration, Instant};
-
-use anathema_backend::Backend;
-use anathema_state::{Watched, Watcher, drain_watchers};
-use anathema_store::stack::Stack;
-
-use crate::Frame;
-use crate::error::Result;
-use crate::events::GlobalEventHandler;
-
-// -----------------------------------------------------------------------------
-//   - Used with test driver -
-//   These functions should not be used outside of testing
-// -----------------------------------------------------------------------------
-impl<'bp, G> Frame<'_, 'bp, G>
-where
-    G: GlobalEventHandler,
-{
-    // TODO: Do we need this for anything? - TB 2025-08-27
-    // pub fn elements(&mut self) -> Children<'_, 'bp> {
-    //     Children::new(
-    //         self.tree.view(),
-    //         self.layout_ctx.attribute_storage,
-    //         &mut self.needs_layout,
-    //     )
-    // }
-
-    // TODO: this can't really be called a frame if we can tick it multiple
-    // times. Maybe RuntimeMut or something less mental
-    pub fn wait_for_monitor<B: Backend>(
-        &mut self,
-        backend: &mut B,
-        watcher: Watcher,
-        timeout: Duration,
-    ) -> Result<Watched> {
-        let now = Instant::now();
-
-        let mut watchers = Stack::empty();
-        drain_watchers(&mut watchers);
-
-        if watchers.contains(&watcher) {
-            return Ok(Watched::Triggered);
-        }
-
-        loop {
-            let dur = self.tick(backend)?;
-            self.present(backend);
-            self.cleanup();
-
-            drain_watchers(&mut watchers);
-
-            if watchers.contains(&watcher) {
-                return Ok(Watched::Triggered);
-            }
-
-            if timeout.saturating_sub(now.elapsed()).is_zero() {
-                break Ok(Watched::Timeout);
-            }
-
-            let sleep = self.sleep_micros - dur.as_micros() as u64;
-            std::thread::sleep(Duration::from_micros(sleep));
-        }
-    }
-}
diff --git a/anathema-state-derive/src/structs.rs b/anathema-state-derive/src/structs.rs
index 1b505ae7..ca7d1ad8 100644
--- a/anathema-state-derive/src/structs.rs
+++ b/anathema-state-derive/src/structs.rs
@@ -39,7 +39,7 @@ pub fn generate(input: &DeriveInput, data: &DataStruct) -> proc_macro::TokenStre
 
 fn generate_unit(name: &Ident) -> proc_macro::TokenStream {
     quote::quote! {
-        impl ::anathema::state::State for #name {
+        impl ::anathema::state::State<::anathema::core::ValueIndex> for #name {
             fn type_info(&self) -> ::anathema::state::Type {
                 ::anathema::state::Type::Unit
             }
@@ -66,7 +66,7 @@ fn generate_list(name: &Ident, len: usize) -> proc_macro::TokenStream {
                 ::anathema::state::Type::List
             }
 
-            fn as_any_list(&self) -> Option<&dyn ::anathema::state::AnyList> {
+            fn as_any_list(&self) -> Option<&dyn ::anathema::state::AnyList<::anathema::core::ValueIndex>> {
                 Some(self)
             }
         }
@@ -76,7 +76,7 @@ fn generate_list(name: &Ident, len: usize) -> proc_macro::TokenStream {
         }
 
         impl ::anathema::state::AnyList for #name {
-            fn lookup(&self, index: usize) -> Option<::anathema::state::PendingValue> {
+            fn lookup(&self, index: usize) -> Option<::anathema::state::AnonValue<::anathema::core::ValueIndex>> {
                 match index {
                     #( #iter, )*
                     _ => None
@@ -118,7 +118,7 @@ fn generate_composite(name: &Ident, fields: Vec<data::Field>) -> proc_macro::Tok
                 ::anathema::state::Type::Composite
             }
 
-            fn as_any_map(&self) -> Option<&dyn ::anathema::state::AnyMap> {
+            fn as_any_map(&self) -> Option<&dyn ::anathema::state::AnyMap<::anathema::core::ValueIndex>> {
                 Some(self)
             }
         }
@@ -128,7 +128,7 @@ fn generate_composite(name: &Ident, fields: Vec<data::Field>) -> proc_macro::Tok
         }
 
         impl ::anathema::state::AnyMap for #name {
-            fn lookup(&self, key: &str) -> Option<::anathema::state::PendingValue> {
+            fn lookup(&self, key: &str) -> Option<::anathema::state::AnonValue<::anathema::core::ValueIndex>> {
                 match key {
                     #(
                         #field_names => {
diff --git a/anathema-state/Cargo.toml b/anathema-state/Cargo.toml
index e1d12a04..06e89245 100644
--- a/anathema-state/Cargo.toml
+++ b/anathema-state/Cargo.toml
@@ -11,10 +11,12 @@ repository = "https://github.com/togglebyte/anathema"
 [dependencies]
 anathema-state-derive = { workspace = true }
 anathema-store = { workspace = true }
+parking_lot = "0.12.5"
 serde = { version = "1.0", optional = true, features = ["derive"] }
 
 [features]
 default = []
+multithread = []
 serde = ["dep:serde"]
 
 [lints]
diff --git a/anathema-state/src/lib.rs b/anathema-state/src/lib.rs
index 6a1dd47b..30bfd4af 100644
--- a/anathema-state/src/lib.rs
+++ b/anathema-state/src/lib.rs
@@ -5,18 +5,12 @@ use anathema_store::slab::Key;
 
 pub use crate::colors::{Color, FromColor};
 pub use crate::numbers::Number;
-pub use crate::states::{AnyList, AnyMap, State, StateId, States, TypeId};
-pub use crate::store::subscriber::SubTo;
-pub use crate::store::watchers::Watcher;
-pub use crate::store::{
-    Change, Changes, Subscriber, Watched, clear_all_changes, clear_all_subs, drain_changes, drain_watchers,
-};
-pub use crate::value::{List, Map, Maybe, Nullable, PendingValue, SharedState, Type, Value, ValueRef};
+pub use crate::states::{AnyList, AnyMap, State, StateId, TypeId};
+pub use crate::value::{AnonValue, Change, List, Map, Maybe, SubKey, Type, Value, ValueRef};
 
 mod colors;
 mod numbers;
 mod states;
-mod store;
 mod value;
 
 // -----------------------------------------------------------------------------
@@ -27,24 +21,6 @@ extern crate self as anathema;
 #[allow(unused_imports)]
 pub use crate as state;
 
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub enum Path<'e> {
-    Key(&'e str),
-    Index(usize),
-}
-
-impl From<usize> for Path<'_> {
-    fn from(value: usize) -> Self {
-        Self::Index(value)
-    }
-}
-
-impl<'a> From<&'a str> for Path<'a> {
-    fn from(value: &'a str) -> Self {
-        Self::Key(value)
-    }
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Hex {
diff --git a/anathema-state/src/numbers.rs b/anathema-state/src/numbers.rs
index 96415cda..1032d77b 100644
--- a/anathema-state/src/numbers.rs
+++ b/anathema-state/src/numbers.rs
@@ -7,7 +7,8 @@
 //! number has to be treated as a float
 use std::ops::{Add, Div, Mul, Neg, Rem, Sub};
 
-use crate::{State, Type};
+use crate::value::{SubKey, Type};
+use crate::State;
 
 #[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
 pub enum Number {
@@ -83,7 +84,7 @@ impl Number {
     }
 }
 
-impl State for Number {
+impl<K: SubKey> State<K> for Number {
     fn type_info(&self) -> Type {
         match self {
             Number::Usize(_)
diff --git a/anathema-state/src/states.rs b/anathema-state/src/states.rs
index 8f60087f..5226b1e9 100644
--- a/anathema-state/src/states.rs
+++ b/anathema-state/src/states.rs
@@ -3,7 +3,8 @@ use std::fmt::Debug;
 
 use anathema_store::slab::{Slab, SlabIndex};
 
-use crate::{Color, Hex, PendingValue, Type, Value};
+use crate::value::{AnonValue, SubKey, Type};
+use crate::{Color, Hex, Value};
 
 pub trait TypeId {
     const TYPE: Type = Type::Composite;
@@ -25,11 +26,11 @@ impl TypeId for Hex {
     const TYPE: Type = Type::Hex;
 }
 
-impl<T> TypeId for crate::Map<T> {
+impl<K, V> TypeId for crate::Map<K, V> {
     const TYPE: Type = Type::Map;
 }
 
-impl<T> TypeId for crate::List<T> {
+impl<K, V> TypeId for crate::List<K, V> {
     const TYPE: Type = Type::List;
 }
 
@@ -63,7 +64,7 @@ impl SlabIndex for StateId {
     }
 }
 
-pub trait State: Any + 'static {
+pub trait State<K: SubKey>: Any + 'static {
     fn type_info(&self) -> Type;
 
     fn as_int(&self) -> Option<i64> {
@@ -94,26 +95,26 @@ pub trait State: Any + 'static {
         None
     }
 
-    fn as_any_map(&self) -> Option<&dyn AnyMap> {
+    fn as_any_map(&self) -> Option<&dyn AnyMap<K>> {
         None
     }
 
-    fn as_any_list(&self) -> Option<&dyn AnyList> {
+    fn as_any_list(&self) -> Option<&dyn AnyList<K>> {
         None
     }
 
-    fn as_maybe(&self) -> Option<&dyn AnyMaybe> {
+    fn as_maybe(&self) -> Option<&dyn AnyMaybe<K>> {
         None
     }
 }
 
-impl Debug for dyn State {
+impl<K: SubKey> Debug for dyn State<K> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "<State ({:?})>", self.type_info())
     }
 }
 
-impl State for Box<dyn State> {
+impl<K: SubKey> State<K> for Box<dyn State<K>> {
     fn type_info(&self) -> Type {
         self.as_ref().type_info()
     }
@@ -146,27 +147,27 @@ impl State for Box<dyn State> {
         self.as_ref().as_bool()
     }
 
-    fn as_any_map(&self) -> Option<&dyn AnyMap> {
+    fn as_any_map(&self) -> Option<&dyn AnyMap<K>> {
         self.as_ref().as_any_map()
     }
 
-    fn as_any_list(&self) -> Option<&dyn AnyList> {
+    fn as_any_list(&self) -> Option<&dyn AnyList<K>> {
         self.as_ref().as_any_list()
     }
 
-    fn as_maybe(&self) -> Option<&dyn AnyMaybe> {
+    fn as_maybe(&self) -> Option<&dyn AnyMaybe<K>> {
         self.as_ref().as_maybe()
     }
 }
 
-pub trait AnyMap: 'static {
-    fn lookup(&self, key: &str) -> Option<PendingValue>;
+pub trait AnyMap<K: SubKey>: 'static {
+    fn lookup(&self, key: &str) -> Option<AnonValue<K>>;
 
     fn is_empty(&self) -> bool;
 }
 
-pub trait AnyList: 'static {
-    fn lookup(&self, index: usize) -> Option<PendingValue>;
+pub trait AnyList<K: SubKey>: 'static {
+    fn lookup(&self, index: usize) -> Option<AnonValue<K>>;
 
     fn len(&self) -> usize;
 
@@ -175,15 +176,15 @@ pub trait AnyList: 'static {
     }
 }
 
-impl dyn AnyList {
-    pub fn iter(&self) -> impl Iterator<Item = PendingValue> {
+impl<K: SubKey> dyn AnyList<K> {
+    pub fn iter(&self) -> impl Iterator<Item = AnonValue<K>> {
         let len = self.len();
         (0..len).filter_map(|i| self.lookup(i))
     }
 }
 
-pub trait AnyMaybe {
-    fn get(&self) -> Option<PendingValue>;
+pub trait AnyMaybe<K: SubKey> {
+    fn get(&self) -> Option<AnonValue<K>>;
 }
 
 macro_rules! impl_num_state {
@@ -192,7 +193,7 @@ macro_rules! impl_num_state {
             const TYPE: Type = Type::Int;
         }
 
-        impl State for $t {
+        impl<K: SubKey> State<K> for $t {
             fn type_info(&self) -> Type {
                 Type::Int
             }
@@ -210,7 +211,7 @@ macro_rules! impl_float_state {
             const TYPE: Type = Type::Float;
         }
 
-        impl State for $t {
+        impl<K: SubKey> State<K> for $t {
             fn type_info(&self) -> Type {
                 Type::Float
             }
@@ -222,7 +223,7 @@ macro_rules! impl_float_state {
     };
 }
 
-impl State for bool {
+impl<K: SubKey> State<K> for bool {
     fn type_info(&self) -> Type {
         Type::Bool
     }
@@ -232,7 +233,7 @@ impl State for bool {
     }
 }
 
-impl State for String {
+impl<K: SubKey> State<K> for String {
     fn type_info(&self) -> Type {
         Type::String
     }
@@ -242,7 +243,7 @@ impl State for String {
     }
 }
 
-impl State for &'static str {
+impl<K: SubKey> State<K> for &'static str {
     fn type_info(&self) -> Type {
         Type::String
     }
@@ -252,7 +253,7 @@ impl State for &'static str {
     }
 }
 
-impl State for char {
+impl<K: SubKey> State<K> for char {
     fn type_info(&self) -> Type {
         Type::Char
     }
@@ -262,7 +263,7 @@ impl State for char {
     }
 }
 
-impl State for Hex {
+impl<K: SubKey> State<K> for Hex {
     fn type_info(&self) -> Type {
         Type::Hex
     }
@@ -272,7 +273,7 @@ impl State for Hex {
     }
 }
 
-impl State for Color {
+impl<K: SubKey> State<K> for Color {
     fn type_info(&self) -> Type {
         Type::Color
     }
@@ -282,7 +283,7 @@ impl State for Color {
     }
 }
 
-impl State for () {
+impl<K: SubKey> State<K> for () {
     fn type_info(&self) -> Type {
         Type::Unit
     }
@@ -300,46 +301,3 @@ impl_num_state!(usize);
 impl_num_state!(isize);
 impl_float_state!(f32);
 impl_float_state!(f64);
-
-#[derive(Debug)]
-pub struct States {
-    inner: Slab<StateId, Value<Box<dyn State>>>,
-}
-
-impl States {
-    pub fn new() -> Self {
-        Self { inner: Slab::empty() }
-    }
-
-    pub fn insert(&mut self, state: Box<dyn State>) -> StateId {
-        let state = Value::from_box(state);
-        self.inner.insert(state)
-    }
-
-    pub fn get(&self, state_id: impl Into<StateId>) -> Option<&Value<Box<dyn State>>> {
-        self.inner.get(state_id.into())
-    }
-
-    pub fn get_mut(&mut self, state_id: impl Into<StateId>) -> Option<&mut Value<Box<dyn State>>> {
-        self.inner.get_mut(state_id.into())
-    }
-
-    pub fn with_mut<F, U>(&mut self, index: impl Into<StateId>, f: F) -> U
-    where
-        F: FnOnce(&mut dyn State, &mut Self) -> U,
-    {
-        let mut ticket = self.inner.checkout(index.into());
-        let ret = f(&mut *ticket.to_mut(), self);
-        self.inner.restore(ticket);
-        ret
-    }
-
-    /// Remove and return a given state.
-    ///
-    /// # Panics
-    ///
-    /// Will panic if the state does not exist.
-    pub fn remove(&mut self, state_id: StateId) -> Value<Box<dyn State>> {
-        self.inner.remove(state_id)
-    }
-}
diff --git a/anathema-state/src/store/change.rs b/anathema-state/src/store/change.rs
deleted file mode 100644
index 114204a4..00000000
--- a/anathema-state/src/store/change.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-use anathema_store::stack::Stack;
-
-use super::subscriber::Subscribers;
-use super::{CHANGES, SUBSCRIBERS, ValueKey};
-
-pub type Changes = Stack<(Subscribers, Change)>;
-
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub enum Change {
-    /// A value was inserted into a list
-    Inserted(u32),
-    /// A value was removed from a list
-    Removed(u32),
-    /// A value has changed
-    Changed,
-    /// Value was removed (e.g removed from a map)
-    Dropped,
-}
-
-/// Drain the current changes into a local value.
-pub fn drain_changes(local_changes: &mut Changes) {
-    CHANGES.with_borrow_mut(|changes| changes.drain_into(local_changes));
-}
-
-/// Clear all changes
-pub fn clear_all_changes() {
-    CHANGES.with_borrow_mut(|changes| changes.clear());
-}
-
-pub(crate) fn changed(key: ValueKey, change: Change) {
-    // Notify subscribers
-    let subscribers = SUBSCRIBERS.with_borrow(|subs| subs.get(key.sub()));
-    if subscribers.is_empty() {
-        return;
-    }
-
-    CHANGES.with_borrow_mut(|changes| {
-        changes.push((subscribers, change));
-    });
-}
diff --git a/anathema-state/src/store/mod.rs b/anathema-state/src/store/mod.rs
deleted file mode 100644
index fd7ee010..00000000
--- a/anathema-state/src/store/mod.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-use std::cell::RefCell;
-
-use anathema_store::stack::Stack;
-use anathema_store::store::{Owned, OwnedKey, Shared};
-use values::OwnedValue;
-pub use watchers::Watched;
-use watchers::{Watcher, Watchers};
-
-pub(crate) use self::change::changed;
-pub use self::change::{Change, Changes, clear_all_changes, drain_changes};
-pub use self::subscriber::Subscriber;
-use self::subscriber::{SubKey, SubscriberMap};
-use crate::Type;
-
-mod change;
-pub(crate) mod subscriber;
-pub(crate) mod values;
-pub(crate) mod watchers;
-
-thread_local! {
-    static OWNED: Owned<OwnedValue> = const { Owned::empty() };
-    static SHARED: Shared<OwnedValue> = const { Shared::empty() };
-    static SUBSCRIBERS: RefCell<SubscriberMap> = const { RefCell::new(SubscriberMap::empty()) };
-    static CHANGES: RefCell<Changes> = const { RefCell::new(Stack::empty()) };
-    static WATCHERS: RefCell<Watchers> = const { RefCell::new(Watchers::new()) };
-    static WATCH_QUEUE: RefCell<Stack<Watcher>> = const { RefCell::new(Stack::empty()) };
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
-/// A value key is a composite from an owned key and a sub key.
-pub struct ValueKey(OwnedKey, SubKey);
-
-impl ValueKey {
-    pub fn owned(&self) -> OwnedKey {
-        self.0
-    }
-
-    pub(crate) fn sub(&self) -> SubKey {
-        self.1
-    }
-
-    pub fn type_info(&self) -> Type {
-        let type_info = self.0.aux();
-        match type_info {
-            1 => Type::Int,
-            2 => Type::Float,
-            3 => Type::Char,
-            4 => Type::String,
-            5 => Type::Bool,
-            6 => Type::Hex,
-            7 => Type::Map,
-            8 => Type::List,
-            9 => Type::Composite,
-            10 => Type::Unit,
-            11 => Type::Color,
-            12 => Type::Maybe,
-            _ => unreachable!("corrupt type information"),
-        }
-    }
-}
-
-/// Drain values from WATCH_QUEUE into the local stack.
-pub fn drain_watchers(local: &mut Stack<Watcher>) {
-    WATCH_QUEUE.with_borrow_mut(|watchers| watchers.drain_copy_into(local));
-}
-
-/// Remove all subscribers from values.
-///
-/// This keeps the values intact and leaves them with
-/// empty subscribers.
-pub fn clear_all_subs() {
-    SUBSCRIBERS.with_borrow_mut(|subs| subs.clear_subscribers());
-}
-
-// -----------------------------------------------------------------------------
-//   - Test functions -
-// -----------------------------------------------------------------------------
-
-#[cfg(test)]
-pub(crate) mod testing {
-    use crate::{Change, Subscriber};
-
-    pub fn drain_changes() -> Vec<(Vec<Subscriber>, Change)> {
-        let mut ret = vec![];
-
-        super::CHANGES.with_borrow_mut(|changes| {
-            changes.drain().for_each(|(subscribers, change)| {
-                ret.push((subscribers.iter().collect(), change));
-            });
-            changes.clear();
-        });
-
-        ret
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use anathema_store::slab::SlabIndex;
-    use test::values::new_value;
-
-    use super::*;
-
-    #[test]
-    fn store_value() {
-        let key = new_value(Box::new(0usize), Type::Int);
-        let mut zero = OwnedKey::ZERO;
-        zero.set_aux(Type::Int as u16);
-
-        assert_eq!(key.owned(), zero);
-        assert_eq!(key.sub(), SubKey::from_usize(0));
-    }
-}
diff --git a/anathema-state/src/store/subscriber.rs b/anathema-state/src/store/subscriber.rs
deleted file mode 100644
index c5191381..00000000
--- a/anathema-state/src/store/subscriber.rs
+++ /dev/null
@@ -1,427 +0,0 @@
-use anathema_store::slab::{Slab, SlabIndex};
-use anathema_store::smallmap::SmallIndex;
-
-use super::SUBSCRIBERS;
-use crate::Key;
-
-#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
-#[repr(transparent)]
-pub struct KeyIndex(u8);
-
-impl KeyIndex {
-    const MAX: Self = Self(3);
-    const TWO: Self = Self(2);
-    const ZERO: Self = Self(0);
-}
-
-impl KeyIndex {
-    fn add(&mut self) {
-        debug_assert!(self.0 <= Self::MAX.0);
-        self.0 += 1;
-    }
-
-    fn sub(&mut self) {
-        self.0 -= 1;
-    }
-
-    const fn max() -> usize {
-        Self::MAX.0 as usize
-    }
-}
-
-// The key associated with the value that is being subscribed to.
-#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
-pub struct SubKey(u32);
-
-impl SlabIndex for SubKey {
-    const MAX: usize = u32::MAX as usize;
-
-    fn as_usize(&self) -> usize {
-        self.0 as usize
-    }
-
-    fn from_usize(index: usize) -> Self
-    where
-        Self: Sized,
-    {
-        Self(index as u32)
-    }
-}
-
-/// A composite key made up of a key and an index
-/// into small map.
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub struct Subscriber(Key, SmallIndex);
-
-impl Subscriber {
-    pub const MAX: Self = Self(Key::MAX, SmallIndex::MAX);
-    pub const ONE: Self = Self(Key::ONE, SmallIndex::ONE);
-    pub const ZERO: Self = Self(Key::ZERO, SmallIndex::ZERO);
-
-    pub fn index(&self) -> SmallIndex {
-        self.1
-    }
-
-    pub fn key(&self) -> Key {
-        self.0
-    }
-}
-
-impl From<(Key, SmallIndex)> for Subscriber {
-    fn from((key, index): (Key, SmallIndex)) -> Self {
-        Self(key, index)
-    }
-}
-
-impl From<Subscriber> for Key {
-    fn from(Subscriber(value, _): Subscriber) -> Self {
-        value
-    }
-}
-
-/// Contains zero, one or more subscribers associated with a value.
-#[derive(Debug, Clone, PartialEq)]
-pub enum Subscribers {
-    Empty,
-    One(Subscriber),
-    Arr([Subscriber; KeyIndex::max()], KeyIndex),
-    Heap(Vec<Subscriber>),
-}
-
-impl Subscribers {
-    /// Apply `F` to each subscriber
-    pub fn with<F>(&self, f: F)
-    where
-        F: FnMut(Subscriber),
-    {
-        self.iter().for_each(f);
-    }
-
-    pub(super) fn is_empty(&self) -> bool {
-        matches!(self, Self::Empty)
-    }
-
-    // Insert a new subscriber.
-    // If there are already `KeyIndex::max()` subscribers associated
-    // with this value then this will cause heap allocations.
-    fn insert(&mut self, sub: Subscriber) {
-        match self {
-            Self::Empty => *self = Self::One(sub),
-            Self::One(key) if *key != sub => *self = Self::Arr([*key, sub, Subscriber::MAX], KeyIndex::TWO),
-            Self::One(key) => *self = Self::Arr([*key, sub, Subscriber::MAX], KeyIndex::TWO),
-            Self::Arr(arr_keys, index) if *index == KeyIndex::MAX => {
-                let mut keys = Vec::with_capacity(KeyIndex::max() + 1);
-                keys.extend_from_slice(arr_keys);
-                keys.push(sub);
-                *self = Self::Heap(keys);
-            }
-            Self::Arr(keys, index) => {
-                keys[index.0 as usize] = sub;
-                index.add();
-            }
-            Self::Heap(keys) => keys.push(sub),
-        }
-    }
-
-    // Remove a subscriber.
-    // If the `Subscriber` is already using heap allocations,
-    // then it will keep doing so until it reaches zero entries,
-    // at which point it will become `Self::Empty`.
-    fn remove(&mut self, sub: Subscriber) {
-        match self {
-            Self::Empty => (),
-            Self::One(key) if sub == *key => *self = Self::Empty,
-            Self::One(_key) => (),
-            Self::Arr(arr_keys, index) => {
-                let Some(pos) = arr_keys.iter().position(|k| *k == sub) else {
-                    return;
-                };
-                arr_keys.copy_within(pos + 1.., pos);
-                index.sub();
-                if *index == KeyIndex::ZERO {
-                    *self = Self::Empty;
-                }
-            }
-            Self::Heap(keys) => {
-                keys.iter().position(|k| *k == sub).map(|pos| keys.remove(pos));
-
-                if keys.is_empty() {
-                    *self = Self::Empty;
-                }
-            }
-        }
-    }
-
-    /// Produce an iterator over the keys
-    pub fn iter(&self) -> impl Iterator<Item = Subscriber> + '_ {
-        let mut one = None;
-        let mut arr = None;
-        let mut heap = None;
-
-        match self {
-            Subscribers::Empty => {}
-            Subscribers::One(sub) => one = Some(std::iter::once(*sub)),
-            Subscribers::Arr(subs, index) => arr = Some(subs[..index.0 as usize].iter().copied()),
-            Subscribers::Heap(subs) => heap = Some(subs.iter().copied()),
-        };
-
-        std::iter::from_fn(move || match self {
-            Subscribers::Empty => None,
-            Subscribers::One(_) => one.as_mut()?.next(),
-            Subscribers::Arr(..) => arr.as_mut()?.next(),
-            Subscribers::Heap(_) => heap.as_mut()?.next(),
-        })
-    }
-
-    fn clear(&mut self) {
-        *self = Subscribers::Empty;
-    }
-
-    #[cfg(test)]
-    fn len(&self) -> usize {
-        match self {
-            Subscribers::Empty => 0,
-            Subscribers::One(_) => 1,
-            Subscribers::Arr(_, index) => index.0 as usize,
-            Subscribers::Heap(vec) => vec.len(),
-        }
-    }
-}
-
-pub(super) struct SubscriberMap {
-    pub(crate) inner: Slab<SubKey, Subscribers>,
-}
-
-impl SubscriberMap {
-    pub(super) const fn empty() -> Self {
-        Self { inner: Slab::empty() }
-    }
-
-    pub(super) fn get(&self, key: SubKey) -> Subscribers {
-        self.inner.get(key).cloned().unwrap_or(Subscribers::Empty)
-    }
-
-    pub(super) fn push_empty(&mut self) -> SubKey {
-        self.inner.insert(Subscribers::Empty)
-    }
-
-    pub(super) fn remove(&mut self, key: SubKey) -> Subscribers {
-        self.inner.remove(key)
-    }
-
-    pub(super) fn subscribe(&mut self, key: SubKey, subscriber: Subscriber) {
-        if let Some(subs) = self.inner.get_mut(key) {
-            subs.insert(subscriber);
-        }
-    }
-
-    pub(super) fn unsubscribe(&mut self, key: SubKey, subscriber: Subscriber) {
-        if let Some(subs) = self.inner.get_mut(key) {
-            subs.remove(subscriber);
-        }
-    }
-
-    // Remove every subscriber but keep the entry as it is owned by a value.
-    pub(super) fn clear_subscribers(&mut self) {
-        for (_, subs) in self.inner.iter_mut() {
-            subs.clear();
-        }
-    }
-
-    #[cfg(test)]
-    fn count(&self) -> usize {
-        self.inner.iter_values().map(|s| s.len()).sum()
-    }
-}
-
-// Subscribe to a key
-pub(crate) fn subscribe(sub_key: SubKey, subscriber: Subscriber) {
-    SUBSCRIBERS.with_borrow_mut(|subs| subs.subscribe(sub_key, subscriber));
-}
-
-// Unsubscribe from a key
-pub(crate) fn unsubscribe(sub_key: SubKey, subscriber: Subscriber) {
-    SUBSCRIBERS.with_borrow_mut(|subs| subs.unsubscribe(sub_key, subscriber));
-}
-
-// -----------------------------------------------------------------------------
-//   - Track what values something is subscribed to -
-// -----------------------------------------------------------------------------
-
-/// Store sub keys.
-/// This is used by any type that needs to track any or all the
-/// values that it subscribes to.
-#[derive(Debug, Default)]
-pub enum SubTo {
-    #[default]
-    Zero,
-    One(SubKey),
-    Two(SubKey, SubKey),
-    Three(SubKey, SubKey, SubKey),
-    Four(SubKey, SubKey, SubKey, SubKey),
-    Many(Vec<SubKey>),
-}
-
-impl SubTo {
-    pub fn empty() -> Self {
-        Self::Zero
-    }
-
-    pub fn push(&mut self, key: SubKey) {
-        let this = std::mem::take(self);
-        *self = match this {
-            Self::Zero => Self::One(key),
-            Self::One(key1) => Self::Two(key1, key),
-            Self::Two(key1, key2) => Self::Three(key1, key2, key),
-            Self::Three(key1, key2, key3) => Self::Four(key1, key2, key3, key),
-            Self::Four(key1, key2, key3, key4) => Self::Many(vec![key1, key2, key3, key4]),
-            Self::Many(mut keys) => {
-                keys.push(key);
-                Self::Many(keys)
-            }
-        }
-    }
-
-    // TODO: another gross function impl
-    // - TB 2025-09-11
-    pub fn merge(&mut self, other: Self) {
-        match other {
-            SubTo::Zero => (),
-            SubTo::One(key) => self.push(key),
-            SubTo::Two(key1, key2) => {
-                self.push(key1);
-                self.push(key2);
-            }
-            SubTo::Three(key1, key2, key3) => {
-                self.push(key1);
-                self.push(key2);
-                self.push(key3);
-            }
-            SubTo::Four(key1, key2, key3, key4) => {
-                self.push(key1);
-                self.push(key2);
-                self.push(key3);
-                self.push(key4);
-            }
-            SubTo::Many(items) => items.into_iter().for_each(|key| self.push(key)),
-        }
-    }
-
-    pub fn unsubscribe(&mut self, sub: Subscriber) {
-        match std::mem::take(self) {
-            SubTo::Zero => (),
-            SubTo::One(key) => unsubscribe(key, sub),
-            SubTo::Two(key1, key2) => {
-                unsubscribe(key1, sub);
-                unsubscribe(key2, sub);
-            }
-            SubTo::Three(key1, key2, key3) => {
-                unsubscribe(key1, sub);
-                unsubscribe(key2, sub);
-                unsubscribe(key3, sub);
-            }
-            SubTo::Four(key1, key2, key3, key4) => {
-                unsubscribe(key1, sub);
-                unsubscribe(key2, sub);
-                unsubscribe(key3, sub);
-                unsubscribe(key4, sub);
-            }
-            SubTo::Many(vec) => vec.into_iter().for_each(|key| unsubscribe(key, sub)),
-        }
-    }
-
-    // TODO: clean this up, it's gross
-    pub fn remove(&mut self, sub_key: SubKey) {
-        match self {
-            SubTo::Zero => (),
-            SubTo::One(key) if *key == sub_key => *self = SubTo::Zero,
-            SubTo::Two(key1, key2) if *key1 == sub_key => *self = SubTo::One(*key2),
-            SubTo::Two(key1, key2) if *key2 == sub_key => *self = SubTo::One(*key1),
-            SubTo::Three(key1, key2, key3) => {
-                if sub_key == *key1 {
-                    *self = SubTo::Two(*key2, *key3);
-                    return;
-                }
-
-                if sub_key == *key2 {
-                    *self = SubTo::Two(*key1, *key3);
-                    return;
-                }
-
-                if sub_key == *key3 {
-                    *self = SubTo::Two(*key1, *key2);
-                }
-            }
-            SubTo::Four(key1, key2, key3, key4) => {
-                if sub_key == *key1 {
-                    *self = SubTo::Three(*key2, *key3, *key4);
-                    return;
-                }
-
-                if sub_key == *key2 {
-                    *self = SubTo::Three(*key1, *key3, *key4);
-                    return;
-                }
-
-                if sub_key == *key3 {
-                    *self = SubTo::Three(*key1, *key2, *key4);
-                    return;
-                }
-
-                if sub_key == *key4 {
-                    *self = SubTo::Three(*key1, *key2, *key3);
-                }
-            }
-            SubTo::Many(vec) => vec.retain(|key| *key != sub_key),
-            _ => {}
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::{Change, Value};
-
-    fn count_subs() -> usize {
-        SUBSCRIBERS.with_borrow(|subs| subs.count())
-    }
-
-    fn drain_changes() -> Vec<(Subscribers, Change)> {
-        crate::store::CHANGES.with_borrow_mut(|changes| changes.drain().collect())
-    }
-
-    #[test]
-    fn transition_from_empty_to_heap_and_back_to_empty() {
-        let mut subs = SubscriberMap::empty();
-        let key = subs.push_empty();
-
-        let keys = [Subscriber::ZERO, Subscriber::MAX];
-
-        for s in &keys {
-            subs.subscribe(key, *s);
-        }
-
-        for s in &keys {
-            subs.unsubscribe(key, *s);
-        }
-    }
-
-    #[test]
-    fn drop_value() {
-        assert_eq!(count_subs(), 0);
-
-        let subscriber = Subscriber::ZERO;
-        let value = Value::new(123);
-        let _value_ref = value.value_ref(subscriber);
-        assert_eq!(count_subs(), 1);
-
-        drop(value);
-
-        assert_eq!(count_subs(), 0);
-
-        let (sub, change) = drain_changes().remove(0);
-        assert_eq!(change, Change::Dropped);
-        assert_eq!(sub, Subscribers::One(subscriber));
-    }
-}
diff --git a/anathema-state/src/store/values.rs b/anathema-state/src/store/values.rs
deleted file mode 100644
index 8e5c9540..00000000
--- a/anathema-state/src/store/values.rs
+++ /dev/null
@@ -1,132 +0,0 @@
-use anathema_store::slab::RcElement;
-use anathema_store::store::{Monitor, OwnedKey, SharedKey};
-
-use super::watchers::queue_monitor;
-use super::{OWNED, SHARED, SUBSCRIBERS, ValueKey};
-use crate::Type;
-use crate::states::State;
-
-pub(crate) struct OwnedValue {
-    pub(crate) val: Box<dyn State>,
-    pub(crate) monitor: Monitor,
-}
-
-impl OwnedValue {
-    pub fn new(val: Box<dyn State>) -> Self {
-        Self {
-            val,
-            monitor: Monitor::initial(),
-        }
-    }
-}
-
-// Write a new value into the `OWNED` store and associate
-// a subscriber key with the value.
-pub(crate) fn new_value(value: Box<dyn State>, value_type: Type) -> ValueKey {
-    let value = OwnedValue::new(value);
-    let mut owned_key = OWNED.with(|owned| owned.push(value));
-    owned_key.set_aux(value_type as u16);
-    let sub_key = SUBSCRIBERS.with_borrow_mut(|subscribers| subscribers.push_empty());
-    ValueKey(owned_key, sub_key)
-}
-
-pub(crate) fn with_owned<F, T>(key: OwnedKey, f: F) -> T
-where
-    F: Fn(&mut OwnedValue) -> T,
-{
-    let mut val = get_unique(key);
-    let ret = f(&mut val);
-    return_owned(key, val);
-    ret
-}
-
-// Get access to the owned value. This allows mutating the value.
-//
-// This checks out the value, making impossible to call `get_unique` again
-// until the value has been returned (using `return_owned`).
-pub(crate) fn get_unique(key: OwnedKey) -> OwnedValue {
-    OWNED.with(|owned| owned.unique(key))
-}
-
-// Try to make an owned value into a shared value, if it isn't already.
-// To get access to another shared instance of the value, call this function again.
-pub(crate) fn try_make_shared(owned_key: OwnedKey) -> Option<(SharedKey, RcElement<OwnedValue>)> {
-    fn lookup_shared(key: SharedKey) -> RcElement<OwnedValue> {
-        SHARED.with(|shared| shared.get(key))
-    }
-
-    OWNED.with(|owned| {
-        match owned.get_shared_key(owned_key) {
-            Some(key) => Some((key, lookup_shared(key))),
-            None => {
-                // Transfer value from OWNED to SHARED
-                let value = owned.try_unique(owned_key)?;
-                SHARED.with(|shared| {
-                    let key = shared.insert(owned_key, value);
-                    owned.try_set_as_shared(owned_key, key).then(|| {
-                        let value = lookup_shared(key);
-                        Some((key, value))
-                    })?
-                })
-            }
-        }
-    })
-}
-
-// Make an owned value into a shared value, if it isn't already.
-// Mutation is not possible while the value is shared.
-//
-// To get access to another shared instance of the value, call this function again.
-//
-// This function assumes the value exists and should be limited to `Value<T>`.
-// If there is a chance the value is no longer present use `try_make_shared` instead.
-pub(crate) fn make_shared(owned_key: OwnedKey) -> Option<(SharedKey, RcElement<OwnedValue>)> {
-    fn lookup_shared(key: SharedKey) -> RcElement<OwnedValue> {
-        SHARED.with(|shared| shared.get(key))
-    }
-
-    OWNED.with(|owned| {
-        match owned.get_shared_key(owned_key) {
-            Some(key) => Some((key, lookup_shared(key))),
-            None => {
-                // Transfer value from OWNED to SHARED
-                let value = owned.unique(owned_key);
-                SHARED.with(|shared| {
-                    let key = shared.insert(owned_key, value);
-                    if owned.try_set_as_shared(owned_key, key) {
-                        let value = lookup_shared(key);
-                        Some((key, value))
-                    } else {
-                        None
-                    }
-                })
-            }
-        }
-    })
-}
-
-// Return an owned value back into `OWNED`.
-pub(crate) fn return_owned(key: OwnedKey, value: OwnedValue) {
-    OWNED.with(|owned| owned.return_unique_borrow(key, value));
-}
-
-// Return a shared value.
-// If the value reference count reaches zero then the value is removed
-// and returned as an owned value.
-pub(crate) fn return_shared(key: SharedKey) {
-    if let Some(value) = SHARED.with(|shared| shared.try_evict(key)) {
-        return_owned(key.into(), value);
-    }
-}
-
-// Remove a value and it's associated subscribers
-pub(crate) fn drop_value(key: ValueKey) -> OwnedValue {
-    let mut value = OWNED.with(|owned| owned.remove(key.0));
-    let _ = SUBSCRIBERS.with_borrow_mut(|subscribers| subscribers.remove(key.1));
-
-    if value.monitor.is_set() {
-        queue_monitor(&mut value.monitor);
-    }
-
-    value
-}
diff --git a/anathema-state/src/store/watchers.rs b/anathema-state/src/store/watchers.rs
deleted file mode 100644
index 9efd1865..00000000
--- a/anathema-state/src/store/watchers.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-use anathema_store::slab::Slab;
-use anathema_store::store::{Monitor, OwnedKey};
-
-use super::{WATCH_QUEUE, WATCHERS};
-use crate::store::values::with_owned;
-
-#[derive(Debug)]
-pub enum Watched {
-    Timeout,
-    Triggered,
-}
-
-/// There can be at most `u16::MAX` watchers at any given time, even though there can be up to
-/// `u32::MAX` values.
-///
-/// Watchers should only be used to monitor values for testing.
-/// For reactive values use the subscribers instead.
-///
-/// Once a value changes the watcher is removed, and the value has to be re-watched again.
-pub struct Watchers {
-    inner: Slab<Monitor, Watcher>,
-}
-
-impl Watchers {
-    pub const fn new() -> Self {
-        Self { inner: Slab::empty() }
-    }
-
-    pub(crate) fn insert(&mut self, watcher: Watcher) -> Monitor {
-        self.inner.insert(watcher)
-    }
-
-    pub(crate) fn remove(&mut self, key: Monitor) -> Watcher {
-        self.inner.remove(key)
-    }
-}
-
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub struct Watcher(usize);
-
-impl Watcher {
-    pub fn new(val: usize) -> Self {
-        Self(val)
-    }
-}
-
-pub(crate) fn monitor(key: OwnedKey, watcher: Watcher) {
-    let monitor = WATCHERS.with_borrow_mut(|watchers| watchers.insert(watcher));
-    with_owned(key, |val| val.monitor = monitor);
-}
-
-pub(crate) fn queue_monitor(monitor: &mut Monitor) {
-    let watcher = WATCHERS.with_borrow_mut(|watchers| watchers.remove(*monitor));
-    *monitor = Monitor::initial();
-    WATCH_QUEUE.with_borrow_mut(|queue| queue.push(watcher));
-}
diff --git a/anathema-state/src/value/arcval.rs b/anathema-state/src/value/arcval.rs
new file mode 100644
index 00000000..86877193
--- /dev/null
+++ b/anathema-state/src/value/arcval.rs
@@ -0,0 +1,135 @@
+//! Multi threaded reactive values
+//!
+//! These values could cause deadlocks so do mind when using them.
+use std::ops::{Deref, DerefMut};
+use std::sync::{Arc, LazyLock};
+
+use anathema_store::slab::Key;
+use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard};
+
+use crate::State;
+
+type ArcRw<T> = Arc<RwLock<T>>;
+
+static CHANGES: LazyLock<Arc<RwLock<Changes>>> = LazyLock::new(Default::default);
+static SUBS: LazyLock<Subs> = LazyLock::new(Default::default);
+
+/// Drain the current changes into a local value.
+pub fn drain_changes(local_changes: &mut Changes) {
+    let mut changes = CHANGES.write();
+    changes.drain_into(local_changes);
+}
+
+/// Clear all changes
+pub fn clear_all_changes() {
+    CHANGES.write().clear();
+}
+
+fn changes() -> ArcRw<Changes> {
+    CHANGES.clone()
+}
+
+fn subs() -> Subs {
+    SUBS.clone()
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Subs(ArcRw<Vec<Key>>);
+
+impl Subs {
+    fn subscribe(&self, key: Key) {
+        self.0.write().push(key);
+    }
+
+    fn unsubscribe(&self, key: Key) {
+        self.0.write().retain(|id| !key.eq(id));
+    }
+}
+
+/// A value that reacts to change.
+///
+/// ```
+/// # use anathema_state::*;
+/// let mut value = Value::<usize>::new(1);
+/// *value.to_mut() += 1;
+/// ```
+pub struct Value<T> {
+    inner: ArcRw<T>,
+    subs: Subs,
+}
+
+impl<T> Value<T>
+where
+    T: State,
+{
+    pub fn new(inner: T) -> Self {
+        Self { inner, subs: panic!() }
+    }
+
+    pub fn anon(&self) -> AnonValue {
+        AnonValue {
+            inner: self.inner.clone(),
+            subs: self.subs.clone(),
+        }
+    }
+
+    pub fn to_ref(&self) -> ValueRef<'_, T> {
+        ValueRef { val: self.inner.read() }
+    }
+
+    pub fn to_mut(&mut self) -> ValueMut<'_, T> {
+        ValueMut {
+            val: self.inner.write(),
+        }
+    }
+}
+
+/// A value reference of a `Value<T>`.
+#[derive(Debug)]
+pub struct ValueRef<'a, T> {
+    val: RwLockReadGuard<'a, T>,
+}
+
+impl<T> Deref for ValueRef<'_, T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &*self.val
+    }
+}
+
+pub struct ValueMut<'a, T> {
+    val: RwLockWriteGuard<'a, T>,
+}
+
+impl<T> Deref for ValueMut<'_, T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &*self.val
+    }
+}
+
+impl<T> DerefMut for ValueMut<'_, T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        panic!();
+        // self.changes.inner.push(Change::Changed);
+        &mut *self.val
+    }
+}
+
+/// Anonymous value
+pub struct AnonValue {
+    inner: ArcRw<dyn State>,
+    subs: Subs,
+}
+
+impl AnonValue {
+    pub(crate) fn subscribe(&self, key: Key) {
+        self.subs.subscribe(key);
+    }
+
+    pub(crate) fn unsub(&self, key: Key) {
+        self.subs.unsubscribe(key);
+    }
+}
diff --git a/anathema-state/src/value/changes.rs b/anathema-state/src/value/changes.rs
new file mode 100644
index 00000000..e87e9b57
--- /dev/null
+++ b/anathema-state/src/value/changes.rs
@@ -0,0 +1,14 @@
+use anathema_store::slab::Key;
+use anathema_store::stack::Stack;
+
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub enum Change {
+    /// A value was inserted into a list
+    Inserted(u32),
+    /// A value was removed from a list
+    Removed(u32),
+    /// A value has changed
+    Changed,
+    /// Value was removed (e.g removed from a map)
+    Dropped,
+}
diff --git a/anathema-state/src/value/list.rs b/anathema-state/src/value/list.rs
index 8e91549e..581a4531 100644
--- a/anathema-state/src/value/list.rs
+++ b/anathema-state/src/value/list.rs
@@ -4,35 +4,36 @@
 use std::collections::VecDeque;
 use std::ops::DerefMut;
 
-use super::{Shared, Type, Unique, Value};
+use super::{AnonValue, Value};
 use crate::states::{AnyList, State};
-use crate::store::changed;
-use crate::store::values::{get_unique, try_make_shared};
-use crate::{Change, PendingValue};
+use crate::value::changes::Change;
+use crate::value::rcval::Subs;
+use crate::value::{SubKey, Type, ValueMut};
+use crate::ValueRef;
 
 #[derive(Debug)]
-pub struct List<T> {
-    inner: VecDeque<Value<T>>,
+pub struct List<K, V> {
+    inner: VecDeque<Value<K, V>>,
 }
 
-impl<T: State> List<T> {
+impl<K: SubKey, V: State<K>> List<K, V> {
     pub const fn empty() -> Self {
         Self { inner: VecDeque::new() }
     }
 
-    pub fn get(&self, index: usize) -> Option<&Value<T>> {
+    pub fn get(&self, index: usize) -> Option<&Value<K, V>> {
         self.inner.get(index)
     }
 
-    pub fn get_mut(&mut self, index: usize) -> Option<&mut Value<T>> {
+    pub fn get_mut(&mut self, index: usize) -> Option<&mut Value<K, V>> {
         self.inner.get_mut(index)
     }
 
-    pub fn iter(&self) -> impl Iterator<Item = &Value<T>> {
+    pub fn iter(&self) -> impl Iterator<Item = &Value<K, V>> {
         self.inner.iter()
     }
 
-    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut Value<T>> {
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut Value<K, V>> {
         self.inner.iter_mut()
     }
 
@@ -45,7 +46,7 @@ impl<T: State> List<T> {
     }
 }
 
-impl<T: State> Default for List<T> {
+impl<K: SubKey, V: State<K>> Default for List<K, V> {
     fn default() -> Self {
         Self { inner: VecDeque::new() }
     }
@@ -57,75 +58,102 @@ impl<T: State> Default for List<T> {
 /// let mut list: Value<List<u32>> = List::empty().into();
 /// list.push(123);
 /// ```
-impl<T: State> Value<List<T>> {
+impl<K: SubKey, V: State<K>> Value<K, List<K, V>> {
+    // This does not trigger a change but still gives mutable access
+    // to the underlying list.
     fn with_mut<F, U>(&mut self, f: F) -> U
     where
-        F: FnOnce(&mut List<T>) -> U,
+        F: FnOnce(&mut Subs<K>, &mut List<K, V>) -> U,
     {
-        let mut inner = get_unique(self.key.owned());
+        let (subs, mut inner) = self.untracked_mut();
 
-        let list: &mut dyn State = inner.val.deref_mut();
+        let list: &mut dyn State<K> = inner.deref_mut();
         let list: &mut dyn std::any::Any = list;
-        let list: &mut List<T> = list.downcast_mut().expect("the type should never change");
+        let list: &mut List<K, V> = list.downcast_mut().expect("the type should never change");
 
-        let ret_val = f(list);
-
-        crate::store::values::return_owned(self.key.owned(), inner);
+        let ret_val = f(subs, list);
 
         ret_val
     }
 
+    /// Create an empty list
     pub fn empty() -> Self {
         let list = List { inner: VecDeque::new() };
         Value::new(list)
     }
 
-    pub fn get<'a>(&'a self, index: usize) -> Option<Shared<'a, T>> {
-        let list = &*self.to_ref();
-        let value = list.get(index)?;
-        let key = value.key;
+    /// Clear the list
+    pub fn clear(&mut self) {
+        self.set(List::empty());
+    }
 
-        let (key, value) = try_make_shared(key.owned())?;
-        let shared = Shared::new(key, value);
-        Some(shared)
+    /// Retain all values that matches the predicate
+    pub fn retain<F>(&mut self, mut f: F)
+    where
+        F: FnMut(&Value<K, V>) -> bool,
+    {
+        let mut index = 0;
+        self.with_mut(|subs, list| {
+            list.inner.retain(|value| {
+                let retain = f(value);
+                if !retain {
+                    subs.changed(Change::Removed(index));
+                }
+                index += 1;
+                retain
+            });
+        });
     }
 
-    pub fn get_mut<'a>(&'a mut self, index: usize) -> Option<Unique<'a, T>> {
-        let list = &*self.to_ref();
-        let value = list.get(index)?;
+    /// Return all values matching the predicate.
+    ///
+    /// Note that unlike `Vec::extract_if`, this will allocate a vector for the result
+    pub fn extract_if<F>(&mut self, mut f: F) -> Vec<Value<K, V>>
+    where
+        F: FnMut(&Value<K, V>) -> bool,
+    {
+        self.with_mut(|subs, List { inner: list, .. }| {
+            let mut extraction = vec![];
 
-        let key = value.key;
-        let value = Unique {
-            value: Some(get_unique(key.owned())),
-            key,
-            _p: std::marker::PhantomData,
-        };
-        Some(value)
+            let mut del = 0;
+
+            for i in 0..list.len() {
+                let index = i - del;
+                if f(&list[index]) {
+                    let value = list.remove(index).expect("value is present");
+                    extraction.push(value);
+                    subs.changed(Change::Removed(index as u32));
+                    del += 1;
+                }
+            }
+
+            extraction
+        })
     }
 
     /// Push a value to the list
-    pub fn push(&mut self, value: T) {
+    pub fn push(&mut self, value: V) {
         self.push_back(value)
     }
 
     /// Push a value to the back of the list
-    pub fn push_back(&mut self, value: T) {
+    pub fn push_back(&mut self, value: V) {
         let value = Value::new(value);
 
-        let index = self.with_mut(|list| {
+        let index = self.with_mut(|_, list| {
             let index = list.len();
             list.inner.push_back(value);
             index as u32
         });
 
-        changed(self.key, Change::Inserted(index));
+        self.changed(Change::Inserted(index));
     }
 
     /// Push a value to the front of the list
-    pub fn push_front(&mut self, value: impl Into<Value<T>>) {
+    pub fn push_front(&mut self, value: impl Into<Value<K, V>>) {
         let value = value.into();
-        self.with_mut(|list| list.inner.push_front(value));
-        changed(self.key, Change::Inserted(0));
+        self.with_mut(|_, list| list.inner.push_front(value));
+        self.changed(Change::Inserted(0));
     }
 
     /// Insert a value at a given index.
@@ -133,41 +161,41 @@ impl<T: State> Value<List<T>> {
     /// # Panics
     ///
     /// Will panic if the index is out of bounds
-    pub fn insert(&mut self, index: usize, value: impl Into<Value<T>>) {
+    pub fn insert(&mut self, index: usize, value: impl Into<Value<K, V>>) {
         let value = value.into();
-        self.with_mut(|list| list.inner.insert(index, value));
-        changed(self.key, Change::Inserted(index as u32));
+        self.with_mut(|_, list| list.inner.insert(index, value));
+        self.changed(Change::Inserted(index as u32));
     }
 
     /// Remove a value from the list.
     /// If the value isn't in the list `None` is returned.
-    pub fn remove(&mut self, index: usize) -> Option<Value<T>> {
-        let value = self.with_mut(|list| list.inner.remove(index));
-        changed(self.key, Change::Removed(index as u32));
+    pub fn remove(&mut self, index: usize) -> Option<Value<K, V>> {
+        let value = self.with_mut(|_, list| list.inner.remove(index));
+        self.changed(Change::Removed(index as u32));
         value
     }
 
     /// Pop a value from the front of the list
-    pub fn pop_front(&mut self) -> Option<Value<T>> {
-        let value = self.with_mut(|list| list.inner.pop_front());
+    pub fn pop_front(&mut self) -> Option<Value<K, V>> {
+        let value = self.with_mut(|_, list| list.inner.pop_front());
         if value.is_some() {
-            changed(self.key, Change::Removed(0));
+            self.changed(Change::Removed(0));
         }
         value
     }
 
     /// Pop a value from the back of the list
-    pub fn pop_back(&mut self) -> Option<Value<T>> {
-        let value = self.with_mut(|list| list.inner.pop_back());
+    pub fn pop_back(&mut self) -> Option<Value<K, V>> {
+        let value = self.with_mut(|_, list| list.inner.pop_back());
         if value.is_some() {
             let index = self.len();
-            changed(self.key, Change::Removed(index as u32));
+            self.changed(Change::Removed(index as u32));
         }
         value
     }
 
     /// Alias for `pop_back`
-    pub fn pop(&mut self) -> Option<Value<T>> {
+    pub fn pop(&mut self) -> Option<Value<K, V>> {
         self.pop_back()
     }
 
@@ -175,38 +203,41 @@ impl<T: State> Value<List<T>> {
     /// Each element will be marked as changed.
     pub fn for_each<F>(&mut self, mut f: F)
     where
-        F: FnMut(&mut T),
+        F: FnMut(&mut V),
     {
-        self.with_mut(|list| {
+        self.with_mut(|_, list| {
             list.inner.iter_mut().for_each(|val| {
                 f(&mut *val.to_mut());
             })
         });
     }
 
-    pub fn len(&self) -> usize {
-        self.to_ref().len()
-    }
-
+    /// Merge the list with another list.
     pub fn merge(&mut self, other: &mut Self) {
         while let Some(value) = other.pop_front() {
-            let index = self.with_mut(|list| {
+            let index = self.with_mut(|_, list| {
                 let index = list.len();
                 list.inner.push_back(value);
                 index as u32
             });
 
-            changed(self.key, Change::Inserted(index));
+            self.changed(Change::Inserted(index));
         }
     }
 
+    /// Return the length of the list
+    pub fn len(&self) -> usize {
+        self.to_ref().len()
+    }
+
+    /// Returns true if the list is empty
     pub fn is_empty(&self) -> bool {
         self.to_ref().is_empty()
     }
 }
 
-impl<T: State> AnyList for List<T> {
-    fn lookup(&self, index: usize) -> Option<PendingValue> {
+impl<K: SubKey, V: State<K>> AnyList<K> for List<K, V> {
+    fn lookup(&self, index: usize) -> Option<AnonValue<K>> {
         self.get(index).map(|val| val.reference())
     }
 
@@ -215,33 +246,35 @@ impl<T: State> AnyList for List<T> {
     }
 }
 
-impl<T: State> State for List<T> {
+impl<K: SubKey, V: State<K>> State<K> for List<K, V> {
     fn type_info(&self) -> Type {
         Type::List
     }
 
-    fn as_any_list(&self) -> Option<&dyn AnyList> {
+    fn as_any_list(&self) -> Option<&dyn AnyList<K>> {
         Some(self)
     }
 }
 
-impl<T> FromIterator<T> for Value<List<T>>
+impl<K, V> FromIterator<V> for Value<K, List<K, V>>
 where
-    T: State,
-    Value<T>: From<T>,
+    K: SubKey,
+    V: State<K>,
+    Value<K, V>: From<V>,
 {
-    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
+    fn from_iter<I: IntoIterator<Item = V>>(iter: I) -> Self {
         let inner = iter.into_iter().map(Into::into).collect::<VecDeque<_>>();
         let list = List { inner };
         Value::new(list)
     }
 }
 
-impl<T> FromIterator<T> for List<T>
+impl<K, V> FromIterator<V> for List<K, V>
 where
-    T: State,
+    K: SubKey,
+    V: State<K>,
 {
-    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
+    fn from_iter<I: IntoIterator<Item = V>>(iter: I) -> Self {
         let inner = iter.into_iter().map(Into::into).collect::<VecDeque<_>>();
         List { inner }
     }
@@ -250,9 +283,16 @@ where
 #[cfg(test)]
 mod test {
 
+    use anathema_store::slab::Key;
+
     use super::*;
-    use crate::Subscriber;
-    use crate::store::testing::drain_changes;
+    use crate::value::changes::Changes;
+
+    fn changes() -> Vec<(Key, Change)> {
+        let mut changes = Changes::empty();
+        crate::value::drain_changes(&mut changes);
+        changes.into()
+    }
 
     #[test]
     fn insert() {
@@ -272,10 +312,10 @@ mod test {
     #[test]
     fn notify_insert() {
         let mut list = Value::new(List::<u32>::empty());
-        list.reference().subscribe(Subscriber::ZERO);
+        list.reference().subscribe(Key::ZERO);
         list.push_back(1);
 
-        let (_, change) = drain_changes().remove(0);
+        let (_, change) = changes().remove(0);
         assert!(matches!(change, Change::Inserted(_)));
     }
 
@@ -283,10 +323,10 @@ mod test {
     fn notify_remove() {
         let mut list = Value::new(List::<u32>::empty());
         list.push_back(1);
-        list.reference().subscribe(Subscriber::ZERO);
+        list.reference().subscribe(Key::ZERO);
         list.remove(0);
 
-        let change = drain_changes().remove(0);
+        let change = changes().remove(0);
         assert!(matches!(change, (_, Change::Removed(_))));
     }
 
@@ -295,36 +335,80 @@ mod test {
         let mut list = Value::new(List::<u32>::empty());
         list.push_back(1);
         list.push_back(2);
-        list.reference().subscribe(Subscriber::ZERO);
+        list.reference().subscribe(Key::ZERO);
         let front = list.pop_front();
 
-        let change = drain_changes().remove(0);
+        let change = changes().remove(0);
         assert!(matches!(change, (_, Change::Removed(0))));
         assert_eq!(*front.unwrap().to_ref(), 1);
     }
 
+    #[test]
+    fn notify_clear() {
+        let mut list = Value::new(List::<u32>::empty());
+        list.reference().subscribe(Key::ZERO);
+        list.clear();
+
+        let change = changes().remove(0);
+        assert!(matches!(change, (_, Change::Changed)));
+    }
+
+    #[test]
+    fn notify_retain() {
+        let mut list = Value::new(List::<u32>::empty());
+        list.push_back(1);
+        list.push_back(2);
+        list.push_back(3);
+
+        list.reference().subscribe(Key::ZERO);
+
+        list.retain(|val| *val.to_ref() == 1);
+
+        let mut changes = changes();
+        assert!(matches!(changes.remove(0), (_, Change::Removed(1))));
+        assert!(matches!(changes.remove(0), (_, Change::Removed(2))));
+    }
+
+    #[test]
+    fn notify_extract_if() {
+        let mut list = Value::new(List::<u32>::empty());
+        list.push_back(1);
+        list.push_back(2);
+        list.push_back(3);
+        list.push_back(4);
+
+        list.reference().subscribe(Key::ZERO);
+
+        let result = list.extract_if(|val| *val.to_ref() % 2 == 0);
+
+        let mut changes = changes();
+        assert!(matches!(changes.remove(0), (_, Change::Removed(1))));
+        assert!(matches!(changes.remove(0), (_, Change::Removed(2))));
+
+        assert_eq!(*result[0].to_ref(), 2);
+        assert_eq!(*result[1].to_ref(), 4);
+    }
+
     #[test]
     fn notify_pop_back() {
         let mut list = Value::new(List::<u32>::empty());
         list.push_back(0);
         list.push_back(1);
-        list.reference().subscribe(Subscriber::ZERO);
+        list.reference().subscribe(Key::ZERO);
         list.pop_back();
 
-        let change = drain_changes().remove(0);
+        let change = changes().remove(0);
         assert!(matches!(change, (_, Change::Removed(1))));
     }
 
     #[test]
     fn pop_empty_list() {
         let mut list = Value::new(List::<u32>::empty());
-        list.reference().subscribe(Subscriber::ZERO);
+        list.reference().subscribe(Key::ZERO);
         list.pop_back();
-        let changes = drain_changes();
-        assert!(changes.is_empty());
+        assert!(changes().is_empty());
 
         list.pop_front();
-        let changes = drain_changes();
-        assert!(changes.is_empty());
+        assert!(changes().is_empty());
     }
 }
diff --git a/anathema-state/src/value/map.rs b/anathema-state/src/value/map.rs
index 35f58a04..d139c96e 100644
--- a/anathema-state/src/value/map.rs
+++ b/anathema-state/src/value/map.rs
@@ -1,39 +1,39 @@
 use std::collections::HashMap;
 
-use super::{Shared, Type, Unique, Value};
+use super::{AnonValue, Value};
 use crate::states::AnyMap;
-use crate::store::values::{get_unique, try_make_shared};
-use crate::{PendingValue, State};
+use crate::value::{SubKey, Type, ValueMut};
+use crate::{State, ValueRef};
 
 #[derive(Debug)]
-pub struct Map<T> {
-    inner: HashMap<String, Value<T>>,
+pub struct Map<K, V> {
+    inner: HashMap<String, Value<K, V>>,
 }
 
-impl<T: State> Map<T> {
+impl<K: SubKey, V: State<K>> Map<K, V> {
     pub fn empty() -> Self {
         Self { inner: HashMap::new() }
     }
 
-    pub fn get(&self, key: &str) -> Option<&Value<T>> {
+    pub fn get(&self, key: &str) -> Option<&Value<K, V>> {
         self.inner.get(key)
     }
 
-    pub fn get_mut(&mut self, key: &str) -> Option<&mut Value<T>> {
+    pub fn get_mut(&mut self, key: &str) -> Option<&mut Value<K, V>> {
         self.inner.get_mut(key)
     }
 
     /// Insert a value into the `Map`.
     /// The value will be wrapped in a `Value<T>` so it's not advisable to insert pre-wrapped
     /// value.
-    pub fn insert(&mut self, map_key: impl Into<String>, value: T) {
+    pub fn insert(&mut self, map_key: impl Into<String>, value: V) {
         let value = value.into();
         let map_key = map_key.into();
         self.inner.insert(map_key, value);
     }
 
     /// Remove a value from the map.
-    pub fn remove(&mut self, map_key: &str) -> Option<Value<T>> {
+    pub fn remove(&mut self, map_key: &str) -> Option<Value<K, V>> {
         self.inner.remove(map_key)
     }
 
@@ -43,7 +43,7 @@ impl<T: State> Map<T> {
     }
 }
 
-impl<T: State> Default for Map<T> {
+impl<K: SubKey, V: State<K>> Default for Map<K, V> {
     fn default() -> Self {
         Self { inner: HashMap::new() }
     }
@@ -55,38 +55,15 @@ impl<T: State> Default for Map<T> {
 /// let mut map = Map::empty();
 /// map.insert("key", 123);
 /// ```
-impl<T: State> Value<Map<T>> {
+impl<K: SubKey, V: State<K>> Value<K, Map<K, V>> {
     pub fn empty() -> Self {
         let map = Map { inner: HashMap::new() };
         Value::new(map)
     }
-
-    pub fn get(&self, key: impl AsRef<str>) -> Option<Shared<'_, T>> {
-        let map = &*self.to_ref();
-        let value = map.get(key.as_ref())?;
-        let key = value.key;
-
-        let (key, value) = try_make_shared(key.owned())?;
-        let shared = Shared::new(key, value);
-        Some(shared)
-    }
-
-    pub fn get_mut<'a>(&'a mut self, key: impl AsRef<str>) -> Option<Unique<'a, T>> {
-        let map = &*self.to_ref();
-        let value = map.get(key.as_ref())?;
-
-        let key = value.key;
-        let value = Unique {
-            value: Some(get_unique(key.owned())),
-            key,
-            _p: std::marker::PhantomData,
-        };
-        Some(value)
-    }
 }
 
-impl<T: State> AnyMap for Map<T> {
-    fn lookup(&self, key: &str) -> Option<PendingValue> {
+impl<K: SubKey, V: State<K>> AnyMap<K> for Map<K, V> {
+    fn lookup(&self, key: &str) -> Option<AnonValue<K>> {
         self.get(key).map(|val| val.reference())
     }
 
@@ -95,12 +72,12 @@ impl<T: State> AnyMap for Map<T> {
     }
 }
 
-impl<T: State> State for Map<T> {
+impl<K: SubKey, V: State<K>> State<K> for Map<K, V> {
     fn type_info(&self) -> Type {
         Type::Map
     }
 
-    fn as_any_map(&self) -> Option<&dyn AnyMap> {
+    fn as_any_map(&self) -> Option<&dyn AnyMap<K>> {
         Some(self)
     }
 }
diff --git a/anathema-state/src/value/maybe.rs b/anathema-state/src/value/maybe.rs
index 79de998e..98729314 100644
--- a/anathema-state/src/value/maybe.rs
+++ b/anathema-state/src/value/maybe.rs
@@ -1,46 +1,45 @@
-use super::{PendingValue, Value};
+use super::{AnonValue, Value};
 use crate::states::AnyMaybe;
+use crate::value::SubKey;
 use crate::{State, TypeId};
 
-pub type Nullable<T> = Maybe<T>;
-
 #[derive(Debug)]
-pub struct Maybe<T>(Option<Value<T>>);
+pub struct Maybe<K, V>(Option<Value<K, V>>);
 
-impl<T> Default for Maybe<T> {
+impl<K, V> Default for Maybe<K, V> {
     fn default() -> Self {
         Self(None)
     }
 }
 
-impl<T: State> Maybe<T> {
+impl<K: SubKey, V: State<K>> Maybe<K, V> {
     /// Create a Maybe with no value
     pub fn none() -> Self {
         Self(None)
     }
 
     /// Create a Maybe with a value
-    pub fn some(value: T) -> Self {
+    pub fn some(value: V) -> Self {
         Self(Some(Value::new(value)))
     }
 
     /// Take the underlying value
-    pub fn take(&mut self) -> Option<Value<T>> {
+    pub fn take(&mut self) -> Option<Value<K, V>> {
         self.0.take()
     }
 
     /// Get option of a reference to the underlying value
-    pub fn get_ref(&self) -> Option<&Value<T>> {
+    pub fn get_ref(&self) -> Option<&Value<K, V>> {
         self.0.as_ref()
     }
 
     /// Get option of a mutable reference to the underlying value
-    pub fn get_mut(&mut self) -> Option<&mut Value<T>> {
+    pub fn get_mut(&mut self) -> Option<&mut Value<K, V>> {
         self.0.as_mut()
     }
 
     /// Set / update the value
-    pub fn set(&mut self, value: T) {
+    pub fn set(&mut self, value: V) {
         match &mut self.0 {
             None => self.0 = Some(Value::new(value)),
             Some(existing) => existing.set(value),
@@ -50,7 +49,7 @@ impl<T: State> Maybe<T> {
     /// Update the current value.
     /// If the input value is `None` the underlying value will be removed.
     /// If the input value is `Some(T)` the underlying value will be replaced.
-    pub fn update(&mut self, value: Option<T>) {
+    pub fn update(&mut self, value: Option<V>) {
         match (self.get_mut(), value) {
             (None, None) => (),
             (None, Some(value)) => *self = Maybe::some(value),
@@ -61,7 +60,7 @@ impl<T: State> Maybe<T> {
 
     pub fn map_mut<F, U>(&mut self, mut f: F) -> Option<U>
     where
-        F: FnMut(&mut T) -> U,
+        F: FnMut(&mut V) -> U,
     {
         let value = self.0.as_mut()?;
         Some(f(&mut *value.to_mut()))
@@ -69,7 +68,7 @@ impl<T: State> Maybe<T> {
 
     pub fn map_ref<F, U>(&self, f: F) -> Option<U>
     where
-        F: Fn(&T) -> U,
+        F: Fn(&V) -> U,
     {
         let value = self.0.as_ref()?;
         Some(f(&*value.to_ref()))
@@ -77,7 +76,7 @@ impl<T: State> Maybe<T> {
 
     pub fn and_then_ref<F, U>(&self, f: F) -> Option<U>
     where
-        F: Fn(&T) -> Option<U>,
+        F: Fn(&V) -> Option<U>,
     {
         let value = self.0.as_ref()?;
         f(&*value.to_ref())
@@ -85,42 +84,42 @@ impl<T: State> Maybe<T> {
 
     pub fn and_then<F, U>(&mut self, mut f: F) -> Option<U>
     where
-        F: FnMut(&mut T) -> Option<U>,
+        F: FnMut(&mut V) -> Option<U>,
     {
         let value = self.0.as_mut()?;
         f(&mut *value.to_mut())
     }
 }
 
-impl<T> TypeId for Maybe<T> {
+impl<K, V> TypeId for Maybe<K, V> {
     const TYPE: super::Type = super::Type::Maybe;
 }
 
-impl<T: State + TypeId> State for Maybe<T> {
+impl<K: SubKey, V: State<K> + TypeId> State<K> for Maybe<K, V> {
     fn type_info(&self) -> super::Type {
         Self::TYPE
     }
 
-    fn as_maybe(&self) -> Option<&dyn AnyMaybe> {
+    fn as_maybe(&self) -> Option<&dyn AnyMaybe<K>> {
         Some(self)
     }
 }
 
-impl<T: State> AnyMaybe for Maybe<T> {
-    fn get(&self) -> Option<PendingValue> {
+impl<K: SubKey, V: State<K>> AnyMaybe<K> for Maybe<K, V> {
+    fn get(&self) -> Option<AnonValue<K>> {
         let value = self.get_ref()?;
         Some(value.reference())
     }
 }
 
-impl<T: State + TypeId> From<Option<T>> for Value<Maybe<T>> {
-    fn from(value: Option<T>) -> Self {
+impl<K: SubKey, V: State<K> + TypeId> From<Option<V>> for Value<K, Maybe<K, V>> {
+    fn from(value: Option<V>) -> Self {
         Maybe::from(value).into()
     }
 }
 
-impl<T: State + TypeId> From<Option<T>> for Maybe<T> {
-    fn from(value: Option<T>) -> Self {
+impl<K: SubKey, V: State<K> + TypeId> From<Option<V>> for Maybe<K, V> {
+    fn from(value: Option<V>) -> Self {
         match value {
             Some(val) => Maybe::some(val),
             None => Maybe::none(),
@@ -128,10 +127,10 @@ impl<T: State + TypeId> From<Option<T>> for Maybe<T> {
     }
 }
 
-impl<T: State + TypeId> Value<Maybe<T>> {
+impl<K: SubKey, V: State<K> + TypeId> Value<K, Maybe<K, V>> {
     pub fn map<F, U>(&mut self, f: F) -> Option<U>
     where
-        F: FnMut(&mut T) -> U,
+        F: FnMut(&mut V) -> U,
     {
         let mut value = self.to_mut();
         value.map_mut(f)
@@ -140,19 +139,30 @@ impl<T: State + TypeId> Value<Maybe<T>> {
 
 #[cfg(test)]
 mod test {
-    use super::*;
-
-    #[test]
-    fn nullable_int() {
-        let value = Maybe::some(1);
-        let inner = value.get().unwrap();
-        assert_eq!(1, inner.as_state().unwrap().as_int().unwrap());
-    }
-
-    #[test]
-    fn nested_nullables() {
-        let value = Maybe::some(Maybe::some(1));
-        let one = value.and_then_ref(|inner_map| inner_map.map_ref(|m| *m)).unwrap();
-        assert_eq!(one, 1);
-    }
+    // use super::*;
+    // use crate::store::testing::drain_changes;
+    // use crate::{Change, Subscriber};
+
+    // #[test]
+    // fn nullable_int() {
+    //     let value = Maybe::some(1);
+    //     let inner = value.get().unwrap();
+    //     assert_eq!(1, inner.as_state().unwrap().as_int().unwrap());
+    // }
+
+    // #[test]
+    // fn nested_nullables() {
+    //     let value = Maybe::some(Maybe::some(1));
+    //     let one = value.and_then_ref(|inner_map| inner_map.map_ref(|m| *m)).unwrap();
+    //     assert_eq!(one, 1);
+    // }
+
+    // #[test]
+    // fn changing_value() {
+    //     let mut value = Value::new(Maybe::<u32>::none());
+    //     value.reference().subscribe(Subscriber::ZERO);
+    //     value.to_mut().update(Some(1));
+    //     let mut changes = drain_changes();
+    //     assert!(matches!(changes.remove(0), (_, Change::Changed)));
+    // }
 }
diff --git a/anathema-state/src/value/mod.rs b/anathema-state/src/value/mod.rs
index c89edc5c..7db69acb 100644
--- a/anathema-state/src/value/mod.rs
+++ b/anathema-state/src/value/mod.rs
@@ -1,545 +1,46 @@
-#![debugger_visualizer(gdb_script_file = "pretty-values.py")]
-
 use std::any::Any;
 use std::fmt::Debug;
 use std::marker::PhantomData;
 use std::ops::{Deref, DerefMut};
 
 use anathema_store::slab::RcElement;
-use anathema_store::store::{OwnedKey, SharedKey};
+#[cfg(feature = "multithread")]
+pub use arcval::{drain_changes, AnonValue, Value, ValueMut, ValueRef};
+#[cfg(not(feature = "multithread"))]
+pub use rcval::{AnonValue, Value, ValueMut, ValueRef};
 
 pub use self::list::List;
 pub use self::map::Map;
-pub use self::maybe::{Maybe, Nullable};
+pub use self::maybe::Maybe;
 use crate::states::State;
-use crate::store::subscriber::{SubKey, subscribe, unsubscribe};
-use crate::store::values::{
-    OwnedValue, drop_value, get_unique, make_shared, new_value, return_owned, return_shared, try_make_shared,
-};
-use crate::store::watchers::{Watcher, monitor, queue_monitor};
-use crate::store::{ValueKey, changed};
-use crate::{Change, Subscriber};
+pub use crate::value::changes::Change;
+
+#[cfg(feature = "multithread")]
+mod arcval;
+#[cfg(not(feature = "multithread"))]
+mod rcval;
 
+mod changes;
 mod list;
 mod map;
 mod maybe;
 
-/// A value that reacts to change.
-///
-/// The value is stored in a global store and accessed via the `Value`.
-/// ```
-/// # use anathema_state::*;
-/// let mut value = Value::<usize>::new(1);
-/// *value.to_mut() += 1;
-/// ```
-#[derive(Debug)]
-pub struct Value<T> {
-    key: ValueKey,
-    // Ensure that `Value` is not Send or Sync.
-    // Given that values live in TLS, sending a value across thread boundaries
-    // would result in loading an incorrect value
-    _p: PhantomData<*const T>,
+pub trait SubKey: PartialEq + Eq + Copy + 'static {
+    fn changed_many(change: Change, keys: impl Iterator<Item = Self>);
 }
 
-impl<T: Default + State> Default for Value<T> {
+impl<K: SubKey, V: Default + State<K>> Default for Value<K, V> {
     fn default() -> Self {
-        Self::new(T::default())
+        Self::new(V::default())
     }
 }
 
-impl<T: State> From<T> for Value<T> {
-    fn from(value: T) -> Self {
+impl<K: SubKey, V: State<K>> From<V> for Value<K, V> {
+    fn from(value: V) -> Self {
         Value::new(value)
     }
 }
 
-impl Value<Box<dyn State>> {
-    // This is a mildly sketchy function and you should probably not use it
-    #[doc(hidden)]
-    pub fn to_mut_cast<U: State>(&mut self) -> Unique<'_, U> {
-        let value = get_unique(self.key.owned());
-        Unique {
-            value: Some(value),
-            key: self.key,
-            _p: PhantomData,
-        }
-    }
-}
-
-impl<T: State> Value<T> {
-    /// Create a new instance of a `Value`.
-    pub fn new(value: T) -> Self {
-        let type_id = value.type_info();
-        let key = new_value(Box::new(value), type_id);
-        Self { key, _p: PhantomData }
-    }
-
-    pub(crate) fn from_box(value: Box<dyn State>) -> Self {
-        let type_id = value.type_info();
-        let key = new_value(value, type_id);
-        Self { key, _p: PhantomData }
-    }
-
-    /// A `Unique` reference to the value.
-    /// There can only be one of these at any given point for a given `Value`.
-    ///
-    /// Attempting to take a reference to the value using a `ValueRef` will
-    /// result in a runtime error.
-    pub fn to_mut(&mut self) -> Unique<'_, T> {
-        let value = get_unique(self.key.owned());
-        Unique {
-            value: Some(value),
-            key: self.key,
-            _p: PhantomData,
-        }
-    }
-
-    /// A `Shared` reference to the value.
-    /// There can be several shared references to a given value as long as there
-    /// is no unique access to the value.
-    #[must_use]
-    pub fn to_ref(&self) -> Shared<'_, T> {
-        let (key, value) = make_shared(self.key.owned()).expect("the value exists as it's coming directly from `Self`");
-
-        Shared {
-            state: SharedState::new(key, value),
-            _p: PhantomData,
-        }
-    }
-
-    /// Produce a detached `ValueRef`.
-    /// Since this is not subject to the same lifetime as the `Value` it originates from it is
-    /// possible to try to access the underlying value while a `Unique` reference exists.
-    /// This will result in a runtime error.
-    #[must_use]
-    pub fn value_ref(&self, subscriber: Subscriber) -> ValueRef {
-        subscribe(self.key.sub(), subscriber);
-        ValueRef {
-            value_key: self.key,
-            subscriber,
-        }
-    }
-
-    /// A Pending value that can later become a value reference when
-    /// combined with a subscriber.
-    pub fn reference(&self) -> PendingValue {
-        PendingValue(self.key)
-    }
-
-    pub fn shared_state(&self) -> Option<SharedState<'_>> {
-        let (key, value) = try_make_shared(self.key.owned())?;
-        let shared = SharedState::new(key, value);
-        Some(shared)
-    }
-
-    /// Get a copy of the value key.
-    /// Useful for debugging.
-    pub fn key(&self) -> ValueKey {
-        self.key
-    }
-
-    /// Convenience function for reassigning a value.
-    pub fn set(&mut self, new_value: T) {
-        *self.to_mut() = new_value;
-    }
-
-    /// Take the value out of the value storage.
-    /// This will prevent the value from being dropped
-    /// and subsequently no `Change::Dropped` will be issued as a result of this.
-    /// However a `Change::Remove(_)` will be issued if the value was removed from a list.
-    pub fn take(self) -> Box<dyn State> {
-        let value = drop_value(self.key).val;
-        // Prevent the drop function from being called
-        // as that would try to free the value from storage again
-        _ = std::mem::ManuallyDrop::new(self);
-        value
-    }
-}
-
-/// Copy the inner value from the owned value.
-impl<T: State + Copy> Value<T> {
-    pub fn copy_value(&self) -> T {
-        *self.to_ref()
-    }
-}
-
-impl<T> Drop for Value<T> {
-    fn drop(&mut self) {
-        changed(self.key, Change::Dropped);
-        let _ = drop_value(self.key);
-    }
-}
-
-/// Unique access to the underlying value.
-/// This is the primary means to mutate the value.
-pub struct Unique<'a, T: 'static> {
-    value: Option<OwnedValue>,
-    key: ValueKey,
-    _p: PhantomData<&'a mut T>,
-}
-
-#[cfg(test)]
-impl<'a, T> Unique<'a, T> {
-    pub(crate) fn is_monitored(&self) -> bool {
-        self.value.as_ref().unwrap().monitor.is_set()
-    }
-}
-
-impl<'a, T> Deref for Unique<'a, T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        let value: &dyn Any = &*self.value.as_ref().expect("value is only ever set to None on drop").val;
-        value.downcast_ref().expect("the type should never change")
-    }
-}
-
-impl<'a, T> DerefMut for Unique<'a, T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        let value = self.value.as_mut().expect("value is only ever set to None on drop");
-
-        if value.monitor.is_set() {
-            queue_monitor(&mut value.monitor);
-        }
-
-        changed(self.key, Change::Changed);
-
-        let value: &mut dyn State = value.val.deref_mut();
-        let value: &mut dyn Any = value;
-        value.downcast_mut().expect("the type should never change")
-    }
-}
-
-impl<'a, T: 'static> Drop for Unique<'a, T> {
-    fn drop(&mut self) {
-        let value = self
-            .value
-            .take()
-            .expect("`Unique` always has a value as it's checked out");
-
-        // NOTE: this is the only place where self.value = None
-        return_owned(self.key.owned(), value);
-    }
-}
-
-// -----------------------------------------------------------------------------
-//   - Shared -
-// -----------------------------------------------------------------------------
-#[derive(Default)]
-enum ElementState {
-    Alive(RcElement<OwnedValue>),
-    #[default]
-    Dropped,
-}
-
-impl ElementState {
-    #[allow(clippy::borrowed_box)]
-    fn as_state(&self) -> &Box<dyn State> {
-        match self {
-            Self::Dropped => unreachable!(),
-            Self::Alive(value) => &value.val,
-        }
-    }
-
-    fn as_ref<T: 'static>(&self) -> &T {
-        match self {
-            Self::Dropped => unreachable!(),
-            Self::Alive(_) => self.try_as_ref().expect("invalid type"),
-        }
-    }
-
-    fn try_as_ref<T: 'static>(&self) -> Option<&T> {
-        match self {
-            Self::Dropped => unreachable!(),
-            Self::Alive(value) => {
-                let value: &dyn Any = &*value.val;
-                value.downcast_ref()
-            }
-        }
-    }
-
-    fn drop_value(&mut self) {
-        let _ = std::mem::take(self);
-    }
-}
-
-pub struct Shared<'a, T: 'static> {
-    state: SharedState<'a>,
-    _p: PhantomData<T>,
-}
-
-impl<'a, T> Shared<'a, T> {
-    fn new(key: SharedKey, value: RcElement<OwnedValue>) -> Self {
-        Self {
-            state: SharedState::new(key, value),
-            _p: PhantomData,
-        }
-    }
-
-    pub fn try_as_ref(&self) -> Option<&T> {
-        self.state.inner.try_as_ref()
-    }
-}
-
-impl<'a, T> Deref for Shared<'a, T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        self.state.inner.as_ref()
-    }
-}
-
-impl<'a, T> AsRef<T> for Shared<'a, T> {
-    fn as_ref(&self) -> &T {
-        self.deref()
-    }
-}
-
-impl<'a, T: Debug> Debug for Shared<'a, T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let value: &dyn Any = self.state.inner.as_state();
-
-        let state = value
-            .downcast_ref::<T>()
-            // It's fine to expect here since the type information
-            // is retained from the source that produces the `Shared` instance.
-            .expect("type information is retained");
-        f.debug_struct("Shared").field("state", &state).finish()
-    }
-}
-
-/// Shared state
-pub struct SharedState<'a> {
-    inner: ElementState,
-    key: SharedKey,
-    _p: PhantomData<&'a ()>,
-}
-
-impl<'a> SharedState<'a> {
-    fn new(key: SharedKey, state: RcElement<OwnedValue>) -> Self {
-        Self {
-            key,
-            inner: ElementState::Alive(state),
-            _p: PhantomData,
-        }
-    }
-}
-
-impl<'a> PartialEq for SharedState<'a> {
-    fn eq(&self, other: &Self) -> bool {
-        self.key == other.key
-    }
-}
-
-impl<'a> Deref for SharedState<'a> {
-    type Target = Box<dyn State>;
-
-    fn deref(&self) -> &Self::Target {
-        self.inner.as_state()
-    }
-}
-
-impl<'a> Drop for SharedState<'a> {
-    fn drop(&mut self) {
-        self.inner.drop_value();
-        return_shared(self.key);
-    }
-}
-
-/// This is a detached value without an associated value type.
-///
-/// This type serves two purposed:
-/// 1. Observe changes to the value.
-/// 2. Act as a "maybe" value (the value might be dropped between uses).
-///
-/// This can never be mutable, just like a shared reference in Rust can not
-/// be mutable.
-///
-/// `SharedValue` exists as a maybe-value, as the owner of the value can drop
-/// the value regardless of how many shared values there are.
-/// This is why `load<T>()` returns an option.
-/// ```
-/// # use anathema_state::*;
-/// # let key_1 = Subscriber::ZERO;
-/// # let key_2 = Subscriber::MAX;
-/// let value = Value::new(123u32);
-/// let v1 = value.value_ref(key_1);
-/// let v2 = value.value_ref(key_2);
-///
-/// assert_eq!(*v1.value::<u32>().unwrap(), 123);
-/// ```
-#[derive(Debug, PartialEq)]
-pub struct ValueRef {
-    value_key: ValueKey,
-    subscriber: Subscriber,
-}
-
-impl ValueRef {
-    /// Load the value. This will return `None` if the owner has dropped the value
-    pub fn value<T: 'static>(&self) -> Option<Shared<'_, T>> {
-        let (key, value) = try_make_shared(self.value_key.owned())?;
-        let shared = Shared::new(key, value);
-        Some(shared)
-    }
-
-    /// Try to get access to the underlying value as a `dyn AnyState`.
-    /// This will return `None` if the `Value<T>` behind this `ValueRef` has
-    /// been dropped.
-    pub fn as_state(&self) -> Option<SharedState<'_>> {
-        let (key, value) = try_make_shared(self.value_key.owned())?;
-        let shared = SharedState::new(key, value);
-        Some(shared)
-    }
-
-    /// Read the type information for the given value
-    pub fn type_info(&self) -> Type {
-        self.value_key.type_info()
-    }
-
-    pub fn to_pending(&self) -> PendingValue {
-        PendingValue(self.value_key)
-    }
-
-    // /// Get a copy of the owned key.
-    // /// Used for debugging.
-    // pub fn owned_key(&self) -> OwnedKey {
-    //     self.value_key.owned()
-    // }
-
-    pub fn copy_with_sub(&self, subscriber: Subscriber) -> ValueRef {
-        subscribe(self.value_key.sub(), subscriber);
-        ValueRef {
-            value_key: self.value_key,
-            subscriber,
-        }
-    }
-}
-
-impl Drop for ValueRef {
-    fn drop(&mut self) {
-        unsubscribe(self.value_key.sub(), self.subscriber);
-    }
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
-pub struct PendingValue(ValueKey);
-
-impl PendingValue {
-    pub fn subscribe(self, subscriber: Subscriber) {
-        subscribe(self.0.sub(), subscriber);
-    }
-
-    pub fn unsubscribe(self, subscriber: Subscriber) {
-        unsubscribe(self.0.sub(), subscriber);
-    }
-
-    /// Load the value. This will return `None` if the owner has dropped the value
-    pub fn value<T: 'static>(&self) -> Option<Shared<'_, T>> {
-        let (key, value) = try_make_shared(self.0.owned())?;
-        let shared = Shared::new(key, value);
-        Some(shared)
-    }
-
-    /// Try to get access to the underlying value as a `dyn AnyState`.
-    /// This will return `None` if the `Value<T>` behind this `ValueRef` has
-    /// been dropped.
-    pub fn as_state<'a>(&'a self) -> Option<SharedState<'a>> {
-        let (key, value) = try_make_shared(self.0.owned())?;
-        let shared = SharedState::new(key, value);
-        Some(shared)
-    }
-
-    /// Read the type information for the given value
-    pub fn type_info(&self) -> Type {
-        self.0.type_info()
-    }
-
-    pub fn owned_key(&self) -> OwnedKey {
-        self.0.owned()
-    }
-
-    pub fn monitor(&self, watcher: Watcher) {
-        monitor(self.0.owned(), watcher);
-    }
-
-    pub fn sub_key(&self) -> SubKey {
-        self.0.sub()
-    }
-
-    pub fn key(&self) -> ValueKey {
-        self.0
-    }
-
-    pub fn pending_eq(&self, rhs: PendingValue) -> bool {
-        let lhs = self;
-        // -----------------------------------------------------------------------------
-        //   - Composite -
-        //   If two keys are the same it's the same value.
-        //   This is mostly for composite values
-        // -----------------------------------------------------------------------------
-        if lhs.key() == rhs.key() {
-            return true;
-        }
-
-        let lhs_type = lhs.type_info();
-        let rhs_type = rhs.type_info();
-
-        // -----------------------------------------------------------------------------
-        //   - Maybe -
-        // -----------------------------------------------------------------------------
-        if let Type::Maybe = lhs_type {
-            let Some(lhs) = lhs.as_state() else { return false };
-            let lhs = lhs.as_maybe().expect("type checked");
-            if let Some(lhs) = lhs.get() {
-                return lhs.pending_eq(rhs);
-            }
-        }
-
-        if let Type::Maybe = rhs_type {
-            let Some(rhs) = rhs.as_state() else { return false };
-            let rhs = rhs.as_maybe().expect("type checked");
-
-            if let Some(rhs) = rhs.get() {
-                return lhs.pending_eq(rhs);
-            }
-        }
-
-        let Some(lhs) = lhs.as_state() else { return false };
-        let Some(rhs) = rhs.as_state() else { return false };
-
-        match (lhs_type, rhs_type) {
-            (Type::Int, Type::Int) => lhs.as_int() == rhs.as_int(),
-            (Type::Float, Type::Float) => lhs.as_float() == rhs.as_float(),
-            (Type::Char, Type::Char) => lhs.as_char() == rhs.as_char(),
-            (Type::String, Type::String) => lhs.as_str() == rhs.as_str(),
-            (Type::Bool, Type::Bool) => lhs.as_bool() == rhs.as_bool(),
-            (Type::Hex, Type::Hex) => lhs.as_hex() == rhs.as_hex(),
-            (Type::Map, Type::Map) => false,
-            (Type::Unit, Type::Unit) => true,
-            (Type::List, Type::List) => {
-                let lhs = lhs.as_any_list().expect("type checked");
-                let rhs = rhs.as_any_list().expect("type checked");
-
-                if lhs.len() != rhs.len() {
-                    return false;
-                }
-
-                for (lhs, rhs) in lhs.iter().zip(rhs.iter()) {
-                    if !lhs.pending_eq(rhs) {
-                        return false;
-                    }
-                }
-
-                true
-            }
-            (Type::Color, Type::Color) => lhs.as_color() == rhs.as_color(),
-            (Type::Maybe, Type::Maybe) => true, // both are None
-
-            _ => false,
-        }
-    }
-}
-
 #[derive(Debug, Copy, Clone)]
 #[repr(u16)]
 pub enum Type {
@@ -559,10 +60,10 @@ pub enum Type {
 
 #[cfg(test)]
 mod test {
+    use anathema_store::slab::Key;
     use anathema_store::stack::Stack;
 
     use super::*;
-    use crate::drain_watchers;
 
     #[test]
     fn new_value() {
@@ -595,12 +96,12 @@ mod test {
     }
 
     #[test]
-    #[should_panic(expected = "value is currently shared: Key <0:0>")]
+    #[should_panic(expected = "RefCell already borrowed")]
     fn mutable_shared_panic() {
         // This should panic because of mutable access
         // is held while also having a value reference.
         let mut value = Value::new(String::new());
-        let s1 = value.value_ref(Subscriber::ZERO);
+        let s1 = value.reference();
         let _r1 = s1.value::<String>();
         let _m1 = value.to_mut();
     }
@@ -611,71 +112,11 @@ mod test {
         let r1 = value.reference();
         let r2 = value.reference();
 
-        let s1 = r1.as_state().unwrap();
-        let s2 = r2.as_state().unwrap();
+        let s1 = r1.as_state();
+        let s2 = r2.as_state();
 
         let val = s1.as_int().unwrap() + s2.as_int().unwrap();
 
         assert_eq!(val, 2);
     }
-
-    #[test]
-    fn monitor_change() {
-        let mut value = Value::new(1);
-        assert!(!value.to_mut().is_monitored());
-
-        value.reference().monitor(Watcher::new(0));
-        assert!(value.to_mut().is_monitored());
-
-        // Modify value
-        *value.to_mut() = 2;
-
-        let mut stack = Stack::empty();
-        drain_watchers(&mut stack);
-        assert_eq!(stack.pop().unwrap(), Watcher::new(0));
-    }
-
-    #[test]
-    fn monitor_drop() {
-        let value = Value::new(1);
-        value.reference().monitor(Watcher::new(0));
-        drop(value);
-
-        let mut stack = Stack::empty();
-        drain_watchers(&mut stack);
-        assert_eq!(stack.pop().unwrap(), Watcher::new(0));
-    }
-
-    #[test]
-    fn monitor_only_once() {
-        let mut stack = Stack::empty();
-
-        let mut value = Value::new(1);
-        value.reference().monitor(Watcher::new(0));
-        *value.to_mut() = 2;
-
-        // First monitor
-        drain_watchers(&mut stack);
-        assert_eq!(stack.pop().unwrap(), Watcher::new(0));
-
-        // Second change but there was no re-attached monitor
-        drop(value);
-
-        // ... so the stack is now empty
-        drain_watchers(&mut stack);
-        assert!(stack.pop().is_none());
-    }
-
-    #[test]
-    fn monitor_pending() {
-        let mut stack = Stack::empty();
-
-        let value = Value::new(1);
-        let pending = value.reference();
-        pending.monitor(Watcher::new(0));
-        drop(value);
-
-        drain_watchers(&mut stack);
-        assert_eq!(stack.pop().unwrap(), Watcher::new(0));
-    }
 }
diff --git a/anathema-state/src/value/pretty-values.py b/anathema-state/src/value/pretty-values.py
deleted file mode 100644
index d580e2d6..00000000
--- a/anathema-state/src/value/pretty-values.py
+++ /dev/null
@@ -1,55 +0,0 @@
-import gdb
-
-class PendingValuePrinter:
-    "Print a PendingValue"
-
-    types = [
-        'corrupt type information',
-        'Int',
-        'Float',
-        'Char',
-        'String',
-        'Bool',
-        'Hex',
-        'Map',
-        'List',
-        'Composite',
-        'Unit',
-        'Color',
-        'Maybe',
-    ]
-
-    def __init__(self, val):
-        owned = val['__0']['__0']['__0']
-        self.sub = val['__0']['__1']['__0']
-
-        self.index = owned & 0xFFFFFFFF
-        self.gen = (owned >> 32) & 0x00FF
-        aux = owned >> 48
-        self.tpe = self.types[aux] 
-
-        if not self.tpe:
-            self.tpe = self.types[0]
-
-    def to_string(self):
-        return "<PendingValue ({}) idx: {} | g: {} | sub: {}>".format(
-            self.tpe,
-            self.index, 
-            self.gen, 
-            self.sub
-        )
-
-
-def lookup(val):
-    lookup_tag = val.type.tag
-
-    if lookup_tag is None:
-        return None
-
-    if "anathema_state::value::PendingValue" == lookup_tag:
-        return PendingValuePrinter(val)
-
-    return None
-
-
-gdb.current_objfile().pretty_printers.append(lookup)
diff --git a/anathema-state/src/value/rcval.rs b/anathema-state/src/value/rcval.rs
new file mode 100644
index 00000000..41bd3d5f
--- /dev/null
+++ b/anathema-state/src/value/rcval.rs
@@ -0,0 +1,248 @@
+//! Single threaded values
+use std::cell::{Ref, RefCell, RefMut};
+use std::ops::{Deref, DerefMut};
+use std::rc::{Rc, Weak};
+
+use anathema_store::slab::Key;
+
+use crate::value::changes::Change;
+use crate::value::{SubKey, Type};
+use crate::State;
+
+type RcRefCell<T> = Rc<RefCell<T>>;
+
+// thread_local! {
+//     static CHANGES: RefCell<Changes> = RefCell::new(Default::default());
+// }
+
+// /// Drain the current changes into a local value.
+// pub fn drain_changes(local_changes: &mut Changes) {
+//     CHANGES.with_borrow_mut(|changes| changes.drain_into(local_changes));
+// }
+
+// /// Clear all changes
+// pub fn clear_all_changes() {
+//     CHANGES.with_borrow_mut(|changes| changes.clear());
+// }
+
+// pub(crate) fn changed(key: (Key, Key), change: Change) {
+//     CHANGES.with_borrow_mut(|changes| changes.push((key, change)));
+// }
+
+/// Keys that are subscribing to changes of a given value
+#[derive(Debug, Default, PartialEq)]
+pub struct Subs<K>(RcRefCell<Vec<K>>);
+
+impl<K: Clone> Clone for Subs<K> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
+impl<K: SubKey> Subs<K> {
+    pub(crate) fn changed(&mut self, change: Change) {
+        K::changed_many(change, self.0.borrow_mut().iter().copied());
+    }
+
+    fn empty() -> Subs<K> {
+        Self(Default::default())
+    }
+
+    fn subscribe(&self, key: K) {
+        self.0.borrow_mut().push(key);
+    }
+
+    fn unsubscribe(&self, key: K) {
+        self.0.borrow_mut().retain(|id| !key.eq(id));
+    }
+
+    fn with_keys<F>(&self, f: F)
+    where
+        F: Fn(K),
+    {
+        self.0.borrow().iter().copied().for_each(f)
+    }
+}
+
+/// A value that reacts to change.
+///
+/// ```
+/// # use anathema_state::*;
+/// let mut value = Value::<usize>::new(1);
+/// *value.to_mut() += 1;
+/// ```
+#[derive(Debug)]
+pub struct Value<K, V> {
+    inner: RcRefCell<V>,
+    pub(crate) subs: Subs<K>,
+}
+
+impl<K, V> Value<K, V>
+where
+    V: State<K>,
+    K: SubKey,
+{
+    /// Create a new instance of a value
+    pub fn new(inner: V) -> Self {
+        Self {
+            inner: Rc::new(RefCell::new(inner)),
+            subs: Subs::empty(),
+        }
+    }
+
+    /// Get an anonymous value
+    pub fn reference(&self) -> AnonValue<K> {
+        let weak = Rc::downgrade(&self.inner);
+        AnonValue {
+            inner: self.inner.clone(), //weak,
+            subs: self.subs.clone(),
+        }
+    }
+
+    /// Replace the underlying value
+    pub fn set(&mut self, new_value: V) {
+        _ = self.inner.replace(new_value);
+        self.subs.changed(Change::Changed);
+    }
+
+    /// Mutable access to the underlying value.
+    pub fn to_mut(&mut self) -> ValueMut<'_, K, V> {
+        ValueMut {
+            val: self.inner.borrow_mut(),
+            subs: self.subs.clone(),
+        }
+    }
+
+    /// Immutable access to the underlying value.
+    pub fn to_ref(&self) -> ValueRef<'_, V> {
+        ValueRef {
+            val: self.inner.borrow(),
+        }
+    }
+
+    pub(crate) fn untracked_mut(&mut self) -> (&mut Subs<K>, UntrackedMut<'_, V>) {
+        (&mut self.subs, UntrackedMut(self.inner.borrow_mut()))
+    }
+
+    pub(crate) fn changed(&mut self, change: Change) {
+        self.subs.changed(change);
+    }
+}
+
+/// A value reference of a `Value<T>`.
+#[derive(Debug)]
+pub struct ValueRef<'a, T> {
+    val: Ref<'a, T>,
+}
+
+impl<T> Deref for ValueRef<'_, T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &*self.val
+    }
+}
+
+// -----------------------------------------------------------------------------
+//   - Value mut -
+// -----------------------------------------------------------------------------
+/// A mutable reference to a value that registers changes whenever the value is dereferenced
+pub struct ValueMut<'a, K, V> {
+    val: RefMut<'a, V>,
+    subs: Subs<K>,
+}
+
+impl<'a, K: SubKey, V> ValueMut<'a, K, V> {
+    pub fn sub(&mut self, sub: K) {
+        self.subs.subscribe(sub);
+    }
+}
+
+impl<K, V> Deref for ValueMut<'_, K, V> {
+    type Target = V;
+
+    fn deref(&self) -> &Self::Target {
+        &*self.val
+    }
+}
+
+impl<K: SubKey, V> DerefMut for ValueMut<'_, K, V> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.subs.changed(Change::Changed);
+        &mut *self.val
+    }
+}
+
+// -----------------------------------------------------------------------------
+//   - Untracked mut -
+// -----------------------------------------------------------------------------
+pub(crate) struct UntrackedMut<'a, V>(RefMut<'a, V>);
+
+impl<V> Deref for UntrackedMut<'_, V> {
+    type Target = V;
+
+    fn deref(&self) -> &Self::Target {
+        &*self.0
+    }
+}
+
+impl<T> DerefMut for UntrackedMut<'_, T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut *self.0
+    }
+}
+
+/// This is an anonymous value without an associated value type.
+///
+/// This type serves two purposed:
+/// 1. Observe changes to the value.
+/// 2. Act as a "maybe" value (the value might be dropped between uses).
+///
+/// This can never be mutable, just like a shared reference in Rust can not
+/// be mutable.
+///
+/// `SharedValue` exists as a maybe-value, as the owner of the value can drop
+/// the value regardless of how many shared values there are.
+/// This is why `load<T>()` returns an option.
+/// ```
+/// # use anathema_state::*;
+/// let value = Value::new(123u32);
+/// let v1 = value.anon();
+/// let v2 = value.anon();
+///
+/// assert_eq!(*v1.value::<u32>().unwrap(), 123);
+/// ```
+#[derive(Debug, Clone)]
+pub struct AnonValue<K: SubKey> {
+    inner: Rc<RefCell<dyn State<K>>>,
+    subs: Subs<K>,
+}
+
+impl<K: SubKey> PartialEq for AnonValue<K> {
+    fn eq(&self, other: &Self) -> bool {
+        Rc::ptr_eq(&self.inner, &other.inner) && self.subs == other.subs
+    }
+}
+
+impl<K: SubKey> AnonValue<K> {
+    pub fn subscribe(&self, key: impl Into<K>) {
+        self.subs.subscribe(key.into());
+    }
+
+    pub fn unsubscribe(&self, key: impl Into<K>) {
+        self.subs.unsubscribe(key.into());
+    }
+
+    pub fn as_state(&self) -> Ref<'_, dyn State<K>> {
+        self.inner.borrow()
+    }
+
+    pub fn value<T: 'static>(&self) -> Option<Ref<'_, T>> {
+        let val = self.inner.borrow() as Ref<'_, dyn std::any::Any>;
+        Ref::filter_map(val, |x| x.downcast_ref::<T>()).ok()
+    }
+
+    pub fn type_info(&self) -> Type {
+        self.as_state().type_info()
+    }
+}
diff --git a/anathema-store/src/lib.rs b/anathema-store/src/lib.rs
index 4ea37bd2..20ea45b4 100644
--- a/anathema-store/src/lib.rs
+++ b/anathema-store/src/lib.rs
@@ -1,9 +1,9 @@
 pub mod buffer;
 pub mod indexmap;
 pub mod regionlist;
+pub mod remotecell;
 pub mod slab;
 pub mod smallmap;
 pub mod stack;
 pub mod storage;
-pub mod store;
 pub mod tree;
diff --git a/anathema-store/src/remotecell.rs b/anathema-store/src/remotecell.rs
new file mode 100644
index 00000000..cb662122
--- /dev/null
+++ b/anathema-store/src/remotecell.rs
@@ -0,0 +1,97 @@
+use std::cell::UnsafeCell;
+use std::ops::{Deref, DerefMut};
+use std::rc::Rc;
+
+/// A remote cell allows the value to be updated from another location.
+/// It's important that a `RemoteCell` is never available while its corresponding `RemoteHandle`
+/// is, as that could lead to UB.
+///
+/// NOTE: This is designed to be used with Anathema attributes (and the value types in there), and nothing else.
+///
+/// # SAFETY:
+///
+/// This is not even remotely safe.
+/// The remote cell can **not ever** be used at the same time as the remote handle.
+///
+/// NOTE: Since the remote cell is clonable it's not safe to ever implement any kind of 
+/// mutable access for the remote cell.
+pub struct RemoteCell<T> {
+    value: Rc<UnsafeCell<T>>,
+}
+
+impl<T> Clone for RemoteCell<T> {
+    fn clone(&self) -> Self {
+        Self { value: self.value.clone() }
+    }
+}
+
+impl<T> RemoteCell<T> {
+    /// Create a new instance of a remote cell and its corresponding handle
+    pub fn new(value: T) -> (Self, RemoteHandle<T>) {
+        let value = Rc::new(UnsafeCell::new(value));
+        let handle = RemoteHandle::new(value.clone());
+        let inst = Self { value };
+        (inst, handle)
+    }
+}
+
+impl<T> Deref for RemoteCell<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.value.get() }
+    }
+}
+
+impl<T: std::fmt::Debug> std::fmt::Debug for RemoteCell<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "-> ")?;
+        self.deref().fmt(f);
+        write!(f, " ({:p})", Rc::as_ptr(&self.value))
+    }
+}
+
+/// A remote handle to update the underlying value.
+///
+/// This can never be used at the same time as the corresponding remote cell.
+pub struct RemoteHandle<T> {
+    value: Rc<UnsafeCell<T>>,
+}
+
+impl<T> std::fmt::Debug for RemoteHandle<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "<remote handle>")
+    }
+}
+
+impl<T> RemoteHandle<T> {
+    fn new(value: Rc<UnsafeCell<T>>) -> Self {
+        Self { value }
+    }
+
+    /// Update the value of the remote cell.
+    pub fn set(&self, new_value: T) {
+        _ = std::mem::replace(unsafe { &mut *self.value.get() }, new_value);
+    }
+
+    pub fn value(&self) -> RemoteCell<T> {
+        RemoteCell {
+            value: self.value.clone(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn update_cell() {
+        let (cell, handle) = RemoteCell::new("hello".to_string());
+
+        assert_eq!(&*cell, "hello");
+
+        handle.set("updated".to_string());
+        assert_eq!(&*cell, "updated");
+    }
+}
diff --git a/anathema-store/src/slab/basic.rs b/anathema-store/src/slab/basic.rs
index 4c59b954..a31f7610 100644
--- a/anathema-store/src/slab/basic.rs
+++ b/anathema-store/src/slab/basic.rs
@@ -1,4 +1,4 @@
-use super::Ticket;
+use std::ops::{Index, IndexMut};
 
 /// Implement this for anything that can be an index of a slab
 pub trait SlabIndex: Copy + PartialEq {
@@ -58,11 +58,11 @@ impl_slabindex!(u32);
 // -----------------------------------------------------------------------------
 //   - Entry -
 // -----------------------------------------------------------------------------
+
 #[derive(Debug, PartialEq, Clone)]
 enum Entry<I, T> {
     Vacant(Option<I>),
     Occupied(T),
-    CheckedOut(I),
 }
 
 impl<I, T> Entry<I, T> {
@@ -81,10 +81,10 @@ impl<I, T> Entry<I, T> {
     // An entry should never be vacant where this call is involved.
     //
     // This means this method should never be used outside of update calls.
-    fn as_occupied_mut(&mut self) -> &mut T {
+    pub fn as_occupied_mut(&mut self) -> &mut T {
         match self {
             Entry::Occupied(value) => value,
-            Entry::Vacant(_) | Entry::CheckedOut(_) => unreachable!("invalid state"),
+            Entry::Vacant(_) => unreachable!("invalid state"),
         }
     }
 }
@@ -93,12 +93,21 @@ impl<I, T> Entry<I, T> {
 //   - Slab -
 // -----------------------------------------------------------------------------
 /// A basic slab
-#[derive(Debug, Default, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Slab<I, T> {
     next_id: Option<I>,
     inner: Vec<Entry<I, T>>,
 }
 
+impl<I, T> Default for Slab<I, T> {
+    fn default() -> Self {
+        Self {
+            next_id: None,
+            inner: vec![],
+        }
+    }
+}
+
 impl<I, T> Slab<I, T>
 where
     I: SlabIndex,
@@ -169,7 +178,6 @@ where
                 .expect("there should be entries up to self.len()");
 
             match entry {
-                Entry::CheckedOut(_) => panic!("value is checked out"),
                 Entry::Vacant(None) => *entry = Entry::Occupied(value),
                 Entry::Occupied(val) => *val = value,
                 &mut Entry::Vacant(Some(next_free)) => {
@@ -193,7 +201,6 @@ where
                                     Some(Entry::Occupied(_)) => {
                                         unreachable!("entry is occupied, so this should never be the next value")
                                     }
-                                    Some(Entry::CheckedOut(_)) => unreachable!("entry checked out"),
                                     None => unreachable!("the index can only point to a vacant value"),
                                 }
                             }
@@ -234,7 +241,7 @@ where
 
         match entry {
             Entry::Occupied(val) => val,
-            Entry::Vacant(_) | Entry::CheckedOut(_) => panic!("removal of vacant entry"),
+            Entry::Vacant(_) => panic!("removal of vacant entry"),
         }
     }
 
@@ -255,7 +262,6 @@ where
                 Some(val)
             }
             Entry::Vacant(_) => None,
-            Entry::CheckedOut(_) => panic!("value is in use"),
         }
     }
 
@@ -283,7 +289,6 @@ where
                 Some(val)
             }
             Entry::Vacant(_) => None,
-            Entry::CheckedOut(_) => panic!("value is in use"),
         }
     }
 
@@ -296,7 +301,7 @@ where
                 std::mem::swap(value, &mut new_value);
                 Some(new_value)
             }
-            Entry::Vacant(_) | Entry::CheckedOut(_) => None,
+            Entry::Vacant(_) => None,
         }
     }
 
@@ -327,41 +332,6 @@ where
         }
     }
 
-    /// Check out a value from the slab.
-    /// The value has to be manually returned using `Self::restore`.
-    ///
-    /// It's up to the developer to remember to do this
-    ///
-    /// # Panics
-    ///
-    /// This will panic if a value does not at exist at the given key
-    pub fn checkout(&mut self, key: I) -> Ticket<I, T> {
-        let mut entry = Entry::CheckedOut(key);
-        std::mem::swap(&mut entry, &mut self.inner[key.as_usize()]);
-
-        match entry {
-            Entry::Occupied(value) => Ticket { value, key },
-            Entry::CheckedOut(_) => panic!("value already checked out"),
-            _ => panic!("no entry matching the key"),
-        }
-    }
-
-    /// Restore a value that is currently checked out.
-    ///
-    /// # Panics
-    ///
-    /// This will panic if a value does not at exist at the given key,
-    /// or if the value is not currently checked out
-    pub fn restore(&mut self, Ticket { value, key }: Ticket<I, T>) {
-        let mut entry = Entry::Occupied(value);
-        std::mem::swap(&mut entry, &mut self.inner[key.as_usize()]);
-
-        match entry {
-            Entry::CheckedOut(_) => (),
-            _ => panic!("failed to return checked out value"),
-        }
-    }
-
     /// # Panics
     ///
     /// Will panic if the value does not exist
@@ -381,7 +351,6 @@ where
         self.inner.iter().filter_map(|e| match e {
             Entry::Occupied(val) => Some(val),
             Entry::Vacant(_) => None,
-            Entry::CheckedOut(_) => None,
         })
     }
 
@@ -393,7 +362,7 @@ where
     pub fn iter_values_mut(&mut self) -> impl Iterator<Item = &mut T> + '_ {
         self.inner.iter_mut().filter_map(|e| match e {
             Entry::Occupied(val) => Some(val),
-            Entry::Vacant(_) | Entry::CheckedOut(_) => None,
+            Entry::Vacant(_) => None,
         })
     }
 
@@ -401,7 +370,7 @@ where
     pub fn iter(&self) -> impl Iterator<Item = (I, &T)> + '_ {
         self.inner.iter().enumerate().filter_map(|(i, e)| match e {
             Entry::Occupied(val) => Some((I::from_usize(i), val)),
-            Entry::Vacant(_) | Entry::CheckedOut(_) => None,
+            Entry::Vacant(_) => None,
         })
     }
 
@@ -412,7 +381,7 @@ where
         self.next_id = None;
         self.inner.drain(..).filter_map(|e| match e {
             Entry::Occupied(val) => Some(val),
-            Entry::Vacant(_) | Entry::CheckedOut(_) => None,
+            Entry::Vacant(_) => None,
         })
     }
 
@@ -420,7 +389,7 @@ where
     pub fn iter_mut(&mut self) -> impl Iterator<Item = (I, &mut T)> + '_ {
         self.inner.iter_mut().enumerate().filter_map(|(i, e)| match e {
             Entry::Occupied(val) => Some((I::from_usize(i), val)),
-            Entry::Vacant(_) | Entry::CheckedOut(_) => None,
+            Entry::Vacant(_) => None,
         })
     }
 
@@ -431,6 +400,29 @@ where
     }
 }
 
+impl<T: SlabIndex, U> Index<T> for Slab<T, U> {
+    type Output = U;
+
+    fn index(&self, index: T) -> &Self::Output {
+        let entry = &self.inner[index.as_usize()];
+        match entry {
+            Entry::Occupied(value) => value,
+            Entry::Vacant(_) => panic!("vacant slot"),
+        }
+    }
+}
+
+impl<T: SlabIndex, U> IndexMut<T> for Slab<T, U> {
+    fn index_mut(&mut self, index: T) -> &mut Self::Output {
+        let entry = &mut self.inner[index.as_usize()];
+        match entry {
+            Entry::Occupied(value) => value,
+            Entry::Vacant(_) => panic!("vacant slot"),
+        }
+    }
+}
+
+#[cfg(test)]
 impl<I, T> Slab<I, T>
 where
     I: Copy,
@@ -454,7 +446,6 @@ where
                     }
                 }
                 Entry::Occupied(value) => writeln!(&mut s, "{idx}: {value:?}"),
-                Entry::CheckedOut(_) => writeln!(&mut s, "entry is checked out"),
             };
         }
 
diff --git a/anathema-store/src/slab/generational.rs b/anathema-store/src/slab/generational.rs
index fb7f33a6..a1e1192c 100644
--- a/anathema-store/src/slab/generational.rs
+++ b/anathema-store/src/slab/generational.rs
@@ -1,8 +1,44 @@
 use std::fmt::{self, Debug, Display};
+use std::marker::PhantomData;
 use std::ops::Deref;
 
 use super::{Index, Ticket};
 
+/// Create a newtype that wraps a `Key`.
+/// This implements the following traits:
+/// * From<Key>
+#[macro_export]
+macro_rules! key {
+    ($name:ident, $($derive:ident),*) => {
+        /// A newtype for a [`Key`](anathema_store::slab::Key)
+        #[derive(
+            $(
+                $derive,
+            )*
+        )]
+        pub struct $name(anathema_store::slab::Key);
+        impl anathema_store::slab::SlabKey for $name { }
+
+        impl From<anathema_store::slab::Key> for $name {
+            fn from(key: anathema_store::slab::Key) -> Self {
+                Self(key)
+            }
+        }
+
+        impl From<$name> for anathema_store::slab::Key {
+            fn from(key: $name) -> Self {
+                key.0
+            }
+        }
+
+        impl From<$name> for anathema_store::slab::Index {
+            fn from(key: $name) -> Self {
+                key.0.into()
+            }
+        }
+    }
+}
+
 /// A generation associated with a key.
 /// The generation is used to ensure that the same key can be reused without retaining
 /// a reference to old data.
@@ -45,16 +81,13 @@ impl Display for Gen {
 /// Bits 48..64 is the 16-bit aux storage in the key.
 ///
 /// This is used to attach additional data to the key.
-#[derive(Hash, Copy, Clone, PartialEq, PartialOrd)]
+#[derive(Hash, Copy, Clone, PartialEq, PartialOrd, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub struct Key(u64);
+pub struct Key(u32);
 
 impl Key {
-    const AUX_BITS: usize = 16;
-    const AUX_OFFSET: usize = Self::INDEX_BITS + Self::GEN_BITS;
-    const GEN_BITS: usize = 16;
-    const INDEX_BITS: usize = 32;
-    const INDEX_OFFSET: usize = Self::AUX_BITS + Self::GEN_BITS;
+    const GEN_BITS: usize = 10;
+    const INDEX_BITS: usize = 22;
     /// Max, with the generation set to zero
     pub const MAX: Self = Self::new(u32::MAX, 0);
     /// One (generation is set to zero)
@@ -64,22 +97,11 @@ impl Key {
 
     /// Create a new instance of a key
     pub const fn new(index: u32, generation: u16) -> Self {
-        let index = (index as u64) << Self::INDEX_OFFSET >> Self::INDEX_OFFSET;
-        let generation = (generation as u64) << Self::INDEX_BITS;
+        let index = index << Self::GEN_BITS >> Self::GEN_BITS;
+        let generation = (generation as u32) << Self::INDEX_BITS;
         Self(index | generation)
     }
 
-    /// Set the upper auxiliary value
-    pub fn set_aux(&mut self, aux: u16) {
-        let aux = (aux as u64) << (Self::INDEX_BITS + Self::GEN_BITS);
-        self.0 = self.0 << Self::GEN_BITS >> Self::GEN_BITS | aux;
-    }
-
-    /// Get the auxiliary value
-    pub fn aux(&self) -> u16 {
-        (self.0 >> Self::AUX_OFFSET) as u16
-    }
-
     pub(super) fn bump(mut self) -> Self {
         let generation = self.generation().wrapping_add(1);
         self.set_gen(generation);
@@ -87,18 +109,13 @@ impl Key {
     }
 
     pub(super) fn set_gen(&mut self, new_gen: u16) {
-        let generation = (new_gen as u64) << Self::INDEX_BITS;
-        self.0 = (self.0 << Self::INDEX_OFFSET >> Self::INDEX_OFFSET) | generation;
+        let generation = (new_gen as u32) << Self::INDEX_BITS;
+        self.0 = self.index() as u32 | generation
     }
 
     /// The index
     pub const fn index(&self) -> usize {
-        (self.0 << Self::INDEX_OFFSET >> Self::INDEX_OFFSET) as usize
-    }
-
-    /// This gets the index of the key, this is used for debugging only
-    pub const fn debug_index(&self) -> usize {
-        self.index()
+        (self.0 << Self::GEN_BITS >> Self::GEN_BITS) as usize
     }
 
     /// Get the key generation
@@ -109,7 +126,7 @@ impl Key {
 
 impl Debug for Key {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "Key <{}:{}>", self.index(), self.generation().0)
+        write!(f, "<{}:{}>", self.index(), self.generation().0)
     }
 }
 
@@ -125,12 +142,35 @@ impl From<(usize, Gen)> for Key {
     }
 }
 
+impl From<u32> for Key {
+    fn from(value: u32) -> Self {
+        Self(value)
+    }
+}
+
+impl From<usize> for Key {
+    fn from(value: usize) -> Self {
+        Self(value as u32)
+    }
+}
+
 impl From<Key> for Index {
     fn from(value: Key) -> Self {
         value.index().into()
     }
 }
 
+impl From<Key> for u32 {
+    fn from(value: Key) -> Self {
+        value.0
+    }
+}
+
+/// Implement this trait for any type acting like a key
+pub trait SlabKey: Into<Key> + From<Key> {}
+
+impl SlabKey for Key {}
+
 // -----------------------------------------------------------------------------
 //   - Entry -
 // -----------------------------------------------------------------------------
@@ -175,27 +215,22 @@ impl<T: Debug> Debug for Entry<T> {
 /// If another value is inserted at the same index it will have a new generation.
 /// This prevents stale indices pointing to incorrect values.
 #[derive(Debug)]
-pub struct GenSlab<T> {
+pub struct GenSlab<K, T> {
     next_id: Option<Key>,
     inner: Vec<Entry<T>>,
+    _key: PhantomData<K>,
 }
 
-impl<T> GenSlab<T> {
+impl<K, T> GenSlab<K, T>
+where
+    K: SlabKey,
+{
     /// Create an empty slab
     pub const fn empty() -> Self {
         Self {
             next_id: None,
             inner: vec![],
-        }
-    }
-}
-
-impl<T> GenSlab<T> {
-    /// Create an empty slab
-    pub const fn empty_aux() -> Self {
-        Self {
-            next_id: None,
-            inner: vec![],
+            _key: PhantomData,
         }
     }
 
@@ -205,18 +240,20 @@ impl<T> GenSlab<T> {
         Self {
             next_id: None,
             inner: Vec::with_capacity(cap),
+            _key: PhantomData,
         }
     }
 
     /// Try to replace an existing value if it exists, with a new one.
     /// This will bump the generation.
-    pub fn try_replace(&mut self, key: Key, mut new_value: T) -> Option<(Key, T)> {
+    pub fn try_replace(&mut self, key: K, mut new_value: T) -> Option<(K, T)> {
+        let key = key.into();
         match &mut self.inner.get_mut(key.index())? {
             Entry::Occupied(val, generation) if key.generation() == *generation => {
                 key.bump();
                 *generation = key.generation();
                 std::mem::swap(&mut new_value, val);
-                Some((key, new_value))
+                Some((key.into(), new_value))
             }
             _ => None,
         }
@@ -228,13 +265,14 @@ impl<T> GenSlab<T> {
     /// # Panics
     ///
     /// Panics if the entry does not exist
-    pub fn replace(&mut self, key: Key, mut new_value: T) -> (Key, T) {
+    pub fn replace(&mut self, key: K, mut new_value: T) -> (K, T) {
+        let key = key.into();
         match &mut self.inner[key.index()] {
             Entry::Occupied(val, generation) if key.generation() == *generation => {
                 key.bump();
                 *generation = key.generation();
                 std::mem::swap(&mut new_value, val);
-                (key, new_value)
+                (key.into(), new_value)
             }
             Entry::Occupied(..) => panic!("entry refers to a different value"),
             Entry::CheckedOut(_) => panic!("entry is checked out"),
@@ -243,7 +281,7 @@ impl<T> GenSlab<T> {
     }
 
     /// Closure over a mutable reference to T
-    pub fn with_mut<F, U>(&mut self, key: Key, f: F) -> U
+    pub fn with_mut<F, U>(&mut self, key: K, f: F) -> U
     where
         F: FnOnce(&mut T, &mut Self) -> U,
     {
@@ -253,8 +291,9 @@ impl<T> GenSlab<T> {
         ret
     }
 
-    pub(crate) fn checkout(&mut self, key: Key) -> Ticket<Key, T> {
-        let mut entry = Entry::CheckedOut(key);
+    pub(crate) fn checkout(&mut self, key: K) -> Ticket<Key, T> {
+        let key = key.into();
+        let mut entry = Entry::CheckedOut(key.into());
         std::mem::swap(&mut entry, &mut self.inner[key.index()]);
 
         match entry {
@@ -285,10 +324,10 @@ impl<T> GenSlab<T> {
     /// There is no guarantee that this value will be the same
     /// value produced when doing an insert if another insert has happened
     /// since this value was returned.
-    pub fn next_id(&self) -> Key {
+    pub fn next_id(&self) -> K {
         match self.next_id {
-            Some(id) => id,
-            None => Key::new(self.inner.len() as u32, 0),
+            Some(id) => id.into(),
+            None => Key::new(self.inner.len() as u32, 0).into(),
         }
     }
 
@@ -298,7 +337,7 @@ impl<T> GenSlab<T> {
     // Write the vacant entry's `next_id` into self.next_id, and
     // finally replace the vacant entry with the occupied value
     /// Insert a value into the slab
-    pub fn insert(&mut self, value: T) -> Key {
+    pub fn insert(&mut self, value: T) -> K {
         match self.next_id.take() {
             Some(key) => {
                 let entry = &mut self.inner[key.index()];
@@ -310,19 +349,20 @@ impl<T> GenSlab<T> {
                 self.next_id = new_next_id.take();
                 entry.swap(value, key.generation());
 
-                key
+                key.into()
             }
             None => {
                 let index = Key::new(self.inner.len() as u32, 0);
                 self.inner.push(Entry::occupied(value, index.generation()));
-                index
+                index.into()
             }
         }
     }
 
     /// Remove a value from the slab, as long as the index and generation matches
     #[must_use]
-    pub fn remove(&mut self, mut key: Key) -> Option<T> {
+    pub fn remove(&mut self, key: K) -> Option<T> {
+        let mut key = key.into();
         let mut entry = Entry::Vacant(self.next_id.take());
         // Increment the generation
         std::mem::swap(&mut self.inner[key.index()], &mut entry);
@@ -339,7 +379,8 @@ impl<T> GenSlab<T> {
     }
 
     /// Try to remove a value from the slab, where the index and generation matches
-    pub fn try_remove(&mut self, key: Key) -> Option<T> {
+    pub fn try_remove(&mut self, key: K) -> Option<T> {
+        let key = key.into();
         if self.inner.len() <= key.index() {
             return None;
         }
@@ -359,7 +400,8 @@ impl<T> GenSlab<T> {
     }
 
     /// Get a reference to a value in the slab
-    pub fn get(&self, key: Key) -> Option<&T> {
+    pub fn get(&self, key: K) -> Option<&T> {
+        let key = key.into();
         match self.inner.get(key.index())? {
             Entry::Occupied(val, generation) if key.generation() == *generation => Some(val),
             _ => None,
@@ -367,20 +409,14 @@ impl<T> GenSlab<T> {
     }
 
     /// Get a mutable reference to a value in the slab
-    pub fn get_mut(&mut self, key: Key) -> Option<&mut T> {
+    pub fn get_mut(&mut self, key: K) -> Option<&mut T> {
+        let key = key.into();
         match self.inner.get_mut(key.index())? {
             Entry::Occupied(val, generation) if key.generation() == *generation => Some(val),
             _ => None,
         }
     }
 
-    /// Remove this function
-    //TODO: remove this
-    #[deprecated]
-    pub fn count_all_entries(&self) -> usize {
-        self.inner.len()
-    }
-
     /// Be aware that this will only ever be as performant as
     /// the underlying vector if all entries are occupied.
     ///
@@ -415,17 +451,18 @@ impl<T> GenSlab<T> {
     }
 
     /// Iterate over the keys and elements
-    pub fn iter_keys(&self) -> impl Iterator<Item = (Key, &T)> + '_ {
+    pub fn iter_keys(&self) -> impl Iterator<Item = (K, &T)> + '_ {
         self.inner.iter().enumerate().filter_map(|(i, e)| match e {
-            Entry::Occupied(val, generation) => Some(((i, *generation).into(), val)),
+            Entry::Occupied(val, generation) => Some((Key::from((i, *generation)).into(), val)),
             Entry::Vacant(_) | Entry::CheckedOut(_) => None,
         })
     }
 }
 
-impl<T> GenSlab<T>
+impl<K, T> GenSlab<K, T>
 where
     T: std::fmt::Debug,
+    K: SlabKey,
 {
     #[doc(hidden)]
     pub fn dump_state(&self) -> String {
@@ -460,13 +497,42 @@ where
     }
 }
 
+// -----------------------------------------------------------------------------
+//   - Index -
+// -----------------------------------------------------------------------------
+impl<K, T> std::ops::Index<K> for GenSlab<K, T>
+where
+    K: SlabKey,
+{
+    type Output = T;
+
+    fn index(&self, index: K) -> &Self::Output {
+        match self.get(index) {
+            Some(val) => val,
+            None => panic!("invalid index or generation"),
+        }
+    }
+}
+
+impl<K, T> std::ops::IndexMut<K> for GenSlab<K, T>
+where
+    K: SlabKey,
+{
+    fn index_mut(&mut self, index: K) -> &mut Self::Output {
+        match self.get_mut(index) {
+            Some(val) => val,
+            None => panic!("invalid index or generation"),
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
 
     #[test]
     fn push() {
-        let mut slab = GenSlab::empty();
+        let mut slab = GenSlab::<Key, _>::empty();
         let index = slab.insert(123);
         let val = slab.remove(index).unwrap();
         assert_eq!(val, 123);
@@ -474,7 +540,7 @@ mod test {
 
     #[test]
     fn remove() {
-        let mut slab = GenSlab::empty();
+        let mut slab = GenSlab::<Key, _>::empty();
         let key_1 = slab.insert(1u32);
         let _ = slab.remove(key_1);
         let key_2 = slab.insert(2);
@@ -484,7 +550,7 @@ mod test {
 
     #[test]
     fn replace() {
-        let mut slab = GenSlab::empty();
+        let mut slab = GenSlab::<Key, _>::empty();
         let key_1 = slab.insert("hello world");
         let (key_1, _) = slab.replace(key_1, "updated");
         let s = slab.remove(key_1).unwrap();
@@ -493,7 +559,7 @@ mod test {
 
     #[test]
     fn get_and_get_mut() {
-        let mut slab = GenSlab::empty();
+        let mut slab = GenSlab::<Key, _>::empty();
         let key = slab.insert(1);
 
         let value = slab.get_mut(key).unwrap();
@@ -505,7 +571,7 @@ mod test {
 
     #[test]
     fn ticket() {
-        let mut slab = GenSlab::empty();
+        let mut slab = GenSlab::<Key, _>::empty();
         let key_1 = slab.insert(1);
         let key_2 = slab.insert(2);
 
@@ -527,7 +593,7 @@ mod test {
     #[test]
     #[should_panic(expected = "value already checked out")]
     fn double_checkout() {
-        let mut slab = GenSlab::empty();
+        let mut slab = GenSlab::<Key, _>::empty();
         let key_1 = slab.insert(1);
         let _t1 = slab.checkout(key_1);
         let _t2 = slab.checkout(key_1);
@@ -552,15 +618,4 @@ mod test {
         assert_eq!(key.index(), index as usize);
         assert_eq!(key.generation(), Gen(generation));
     }
-
-    #[test]
-    fn write_aux_store() {
-        let index = 123;
-        let generation = 456u16;
-        let mut key = Key::new(index, generation);
-        key.set_aux(42);
-        assert_eq!(key.index(), index as usize);
-        assert_eq!(key.generation(), Gen(generation));
-        assert_eq!(key.aux(), 42);
-    }
 }
diff --git a/anathema-store/src/slab/mod.rs b/anathema-store/src/slab/mod.rs
index 9b364ef0..a3c46437 100644
--- a/anathema-store/src/slab/mod.rs
+++ b/anathema-store/src/slab/mod.rs
@@ -11,7 +11,7 @@
 use std::ops::{Deref, DerefMut};
 
 pub use self::basic::{Slab, SlabIndex};
-pub use self::generational::{Gen, GenSlab, Key};
+pub use self::generational::{Gen, GenSlab, Key, SlabKey};
 pub use self::secondary_map::SecondaryMap;
 pub use self::shared::SharedSlab;
 pub use self::shared::arc::{ArcElement, ArcSlab};
diff --git a/anathema-store/src/slab/secondary_map.rs b/anathema-store/src/slab/secondary_map.rs
index aecc8d0a..268f20db 100644
--- a/anathema-store/src/slab/secondary_map.rs
+++ b/anathema-store/src/slab/secondary_map.rs
@@ -7,9 +7,9 @@ use super::{Index, Slab};
 ///
 ///
 /// ```
-/// use anathema_store::slab::{GenSlab, SecondaryMap};
+/// use anathema_store::slab::{GenSlab, Key, SecondaryMap};
 ///
-/// let mut names = GenSlab::empty();
+/// let mut names = GenSlab::<Key, _>::empty();
 /// let lilly = names.insert("Lilly");
 ///
 /// let mut favourite_foods = SecondaryMap::empty();
@@ -72,6 +72,32 @@ where
     }
 }
 
+impl<K, V> std::ops::Index<K> for SecondaryMap<K, V>
+where
+    K: Into<Index> + Copy,
+{
+    type Output = V;
+
+    fn index(&self, index: K) -> &Self::Output {
+        match self.get(index) {
+            Some(val) => val,
+            None => panic!("invalid key: {:?}", index.into()),
+        }
+    }
+}
+
+impl<K, V> std::ops::IndexMut<K> for SecondaryMap<K, V>
+where
+    K: Into<Index> + Copy,
+{
+    fn index_mut(&mut self, index: K) -> &mut Self::Output {
+        match self.get_mut(index) {
+            Some(val) => val,
+            None => panic!("invalid key: {:?}", index.into()),
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
diff --git a/anathema-store/src/smallmap.rs b/anathema-store/src/smallmap.rs
index f76e47de..bd34ee46 100644
--- a/anathema-store/src/smallmap.rs
+++ b/anathema-store/src/smallmap.rs
@@ -34,23 +34,6 @@ impl SlabIndex for SmallIndex {
     }
 }
 
-// impl From<u8> for SmallIndex {
-//     fn from(value: u8) -> Self {
-//         Self(value)
-//     }
-// }
-// impl From<usize> for SmallIndex {
-//     fn from(value: usize) -> Self {
-//         Self(value as u8)
-//     }
-// }
-
-// impl From<SmallIndex> for usize {
-//     fn from(value: SmallIndex) -> Self {
-//         value.0 as usize
-//     }
-// }
-
 /// A small map used to store a small amount of values.
 ///
 /// The `SmallMap` can store up to 256 values.
diff --git a/anathema-store/src/stack.rs b/anathema-store/src/stack.rs
index 1f22c4ed..3c0ea849 100644
--- a/anathema-store/src/stack.rs
+++ b/anathema-store/src/stack.rs
@@ -30,7 +30,7 @@ impl<T> Entry<T> {
 
 /// Allocate memory but never free it until the entire `Stack` is dropped.
 /// Items popped from the stack are marked as `Empty` so the memory is reused.
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct Stack<T> {
     inner: Vec<Entry<T>>,
     len: usize,
@@ -208,6 +208,18 @@ impl<T> FromIterator<T> for Stack<T> {
     }
 }
 
+impl<T> Default for Stack<T> {
+    fn default() -> Self {
+        Self::empty()
+    }
+}
+
+impl<T> From<Stack<T>> for Vec<T> {
+    fn from(value: Stack<T>) -> Self {
+        value.inner.into_iter().filter_map(Entry::into_value).collect()
+    }
+}
+
 /// A draining iterator over the stack.
 /// Any values that wasn't consumed will be dropped
 /// along with the iterator.
diff --git a/anathema-store/src/storage/mod.rs b/anathema-store/src/storage/mod.rs
index b3285315..a561c7b5 100644
--- a/anathema-store/src/storage/mod.rs
+++ b/anathema-store/src/storage/mod.rs
@@ -1,4 +1,6 @@
-use crate::slab::{Slab, SlabIndex, Ticket};
+use std::ops::Index;
+
+use crate::slab::{Slab, SlabIndex};
 
 pub mod strings;
 
@@ -52,14 +54,6 @@ where
         }
     }
 
-    pub fn checkout(&mut self, index: I) -> Ticket<I, (K, V)> {
-        self.0.checkout(index)
-    }
-
-    pub fn restore(&mut self, ticket: Ticket<I, (K, V)>) {
-        self.0.restore(ticket)
-    }
-
     /// Get a reference by index
     pub fn get(&self, index: I) -> Option<&(K, V)> {
         self.0.get(index)
@@ -98,3 +92,11 @@ where
         self.0.iter_values_mut()
     }
 }
+
+impl<I: SlabIndex, U, T> Index<I> for Storage<I, U, T> {
+    type Output = (U, T);
+
+    fn index(&self, index: I) -> &Self::Output {
+        &self.0[index]
+    }
+}
diff --git a/anathema-store/src/store/mod.rs b/anathema-store/src/store/mod.rs
deleted file mode 100644
index c573d488..00000000
--- a/anathema-store/src/store/mod.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-pub use self::owned::{Monitor, Owned, OwnedEntry, OwnedKey};
-pub use self::shared::{Shared, SharedKey};
-
-mod owned;
-mod shared;
diff --git a/anathema-store/src/store/owned.rs b/anathema-store/src/store/owned.rs
deleted file mode 100644
index 190335ec..00000000
--- a/anathema-store/src/store/owned.rs
+++ /dev/null
@@ -1,231 +0,0 @@
-use std::cell::RefCell;
-
-use super::shared::SharedKey;
-use crate::slab::SlabIndex;
-
-// -----------------------------------------------------------------------------
-//   - Key -
-// -----------------------------------------------------------------------------
-pub type OwnedKey = crate::slab::Key;
-
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub struct Monitor(u16);
-
-impl Monitor {
-    pub const INITIAL: u16 = u16::MAX;
-
-    pub const fn initial() -> Self {
-        Self(Self::INITIAL)
-    }
-
-    pub fn is_set(self) -> bool {
-        self != Self::initial()
-    }
-}
-
-impl SlabIndex for Monitor {
-    const MAX: usize = u16::MAX as usize - 1;
-
-    fn as_usize(&self) -> usize {
-        self.0 as usize
-    }
-
-    fn from_usize(index: usize) -> Self
-    where
-        Self: Sized,
-    {
-        Self(index as u16)
-    }
-}
-
-// -----------------------------------------------------------------------------
-//   - Storage entity -
-// -----------------------------------------------------------------------------
-/// Represents a value in the storage.
-/// The value can be "checked out" either shared or unique.
-#[derive(Debug, Clone)]
-pub enum OwnedEntry<T> {
-    /// An entry in the store
-    Occupied(T),
-    /// The value is currently borrowed (unique / writable)
-    Unique,
-    /// The value is currently borrowed (shared)
-    Shared(SharedKey),
-}
-
-impl<T> OwnedEntry<T> {
-    fn is_occupied(&self) -> bool {
-        matches!(self, Self::Occupied(_))
-    }
-}
-
-// -----------------------------------------------------------------------------
-//   - Storage -
-// -----------------------------------------------------------------------------
-pub struct Owned<T> {
-    inner: RefCell<crate::slab::GenSlab<OwnedEntry<T>>>,
-}
-
-impl<T> Owned<T> {
-    pub const fn empty() -> Self {
-        Self {
-            inner: RefCell::new(crate::slab::GenSlab::empty_aux()),
-        }
-    }
-
-    pub fn get_shared_key(&self, key: OwnedKey) -> Option<SharedKey> {
-        match self.inner.borrow().get(key)? {
-            OwnedEntry::Shared(key) => Some(*key),
-            _ => None,
-        }
-    }
-
-    pub fn push(&self, value: T) -> OwnedKey {
-        self.inner.borrow_mut().insert(OwnedEntry::Occupied(value))
-    }
-
-    pub fn try_set_as_shared(&self, owned_key: OwnedKey, shared_key: SharedKey) -> bool {
-        let entry = self
-            .inner
-            .borrow_mut()
-            .try_replace(owned_key, OwnedEntry::Shared(shared_key));
-
-        matches!(entry, Some((_, OwnedEntry::Unique)))
-    }
-
-    /// Call closure on a value.
-    /// This assumes the value exists and is currently
-    /// not shared.
-    ///
-    /// # Panics
-    ///
-    /// This will panic if the value does not exist or is
-    /// currently shared.
-    pub fn with<F, U>(&self, key: OwnedKey, f: F) -> Option<U>
-    where
-        F: FnOnce(&T) -> U,
-    {
-        let inner = self.inner.borrow();
-        inner.get(key).map(|val| match val {
-            OwnedEntry::Occupied(val) => f(val),
-            OwnedEntry::Unique => panic!("value is already checked out"),
-            OwnedEntry::Shared(_) => panic!("value is currently shared"),
-        })
-    }
-
-    /// Get unique access to the value at a given key.
-    ///
-    /// # Panics
-    ///
-    /// Will panic if the value is currently shared, or was removed
-    pub fn unique(&self, key: OwnedKey) -> T {
-        match self.try_unique(key) {
-            Some(value) => value,
-            None => panic!("value unavailable"),
-        }
-    }
-
-    /// Try to get unique access to a value.
-    /// The value may or may not exist.
-    ///
-    /// # Panics
-    ///
-    /// If the value exists but is in an invalid state
-    /// this function will panic.
-    pub fn try_unique(&self, key: OwnedKey) -> Option<T> {
-        let mut inner = self.inner.borrow_mut();
-        let (_, output) = inner.try_replace(key, OwnedEntry::Unique)?;
-        match output {
-            OwnedEntry::Occupied(value) => Some(value),
-            OwnedEntry::Unique => panic!("value is already checked out"),
-            OwnedEntry::Shared(_) => panic!("value is currently shared: {key:?}"),
-        }
-    }
-
-    /// Remove the value from the storage.
-    ///
-    /// # Panics
-    ///
-    /// This will panic if the value does not exist.
-    pub fn remove(&self, key: OwnedKey) -> T {
-        match self.inner.borrow_mut().remove(key) {
-            Some(OwnedEntry::Occupied(value)) => value,
-            Some(OwnedEntry::Unique) => panic!("invalid state (U)"),
-            Some(OwnedEntry::Shared(_)) => panic!("invalid state (S)"),
-            None => panic!("invalid state: the value does not exist"),
-        }
-    }
-
-    // Return a value to the storage.
-    // The value can be either a
-    // * Unique borrow
-    // * The end of a shared borrow
-    pub fn return_unique_borrow(&self, key: OwnedKey, value: T) {
-        let (_, val) = self.inner.borrow_mut().replace(key, OwnedEntry::Occupied(value));
-        match val {
-            OwnedEntry::Unique => (),
-            OwnedEntry::Shared(_) => (),
-            _ => panic!("invalid state"),
-        }
-    }
-
-    /// This function should only be used for tests
-    #[doc(hidden)]
-    pub fn count_occupied(&self) -> usize {
-        self.inner.borrow().iter().filter(|e| e.is_occupied()).count()
-    }
-
-    pub fn for_each<F>(&self, mut f: F)
-    where
-        F: FnMut(OwnedKey, &OwnedEntry<T>),
-    {
-        self.inner.borrow().iter_keys().for_each(|(k, v)| f(k, v));
-    }
-}
-
-impl<T: std::fmt::Debug> Owned<T> {
-    pub fn dump_state(&self) -> String {
-        self.inner.borrow().dump_state()
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn push() {
-        let owned = Owned::empty();
-        let key = owned.push(Box::new(123u32));
-        let unique = owned.unique(key);
-        let value: u32 = *unique;
-        assert_eq!(value, 123);
-    }
-
-    #[test]
-    #[should_panic(expected = "value is already checked out")]
-    fn unique_borrow() {
-        let owned = Owned::empty();
-        let key = owned.push(Box::new(123u32));
-        let _ = owned.unique(key);
-        let _ = owned.unique(key);
-    }
-
-    #[test]
-    fn return_unique_borrow() {
-        let owned = Owned::empty();
-        let key = owned.push(Box::new(123u32));
-        let value = owned.unique(key);
-        owned.return_unique_borrow(key, value);
-        let _value = owned.unique(key);
-    }
-
-    #[test]
-    #[should_panic(expected = "value unavailable")]
-    fn remove() {
-        let owned = Owned::empty();
-        let key = owned.push(Box::new(123u32));
-        let _ = owned.remove(key);
-        let _value = owned.unique(key);
-    }
-}
diff --git a/anathema-store/src/store/shared.rs b/anathema-store/src/store/shared.rs
deleted file mode 100644
index bb82f784..00000000
--- a/anathema-store/src/store/shared.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-use std::cell::RefCell;
-
-use super::OwnedKey;
-use crate::slab::{RcElement, RcSlab, SharedSlab};
-
-// -----------------------------------------------------------------------------
-//   - Shared key -
-// -----------------------------------------------------------------------------
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub struct SharedKey(pub u32, pub OwnedKey);
-
-impl From<SharedKey> for usize {
-    fn from(key: SharedKey) -> usize {
-        key.0 as usize
-    }
-}
-
-impl From<SharedKey> for OwnedKey {
-    fn from(key: SharedKey) -> OwnedKey {
-        key.1
-    }
-}
-
-// -----------------------------------------------------------------------------
-//   - Shared storage -
-// -----------------------------------------------------------------------------
-pub struct Shared<T> {
-    inner: RefCell<RcSlab<usize, T>>,
-}
-
-impl<T> Shared<T> {
-    pub const fn empty() -> Self {
-        Self {
-            inner: RefCell::new(RcSlab::empty()),
-        }
-    }
-
-    // Get a shared value under the assumption that the value exists.
-    // This should only be called if the Rc::strong count is greater than one
-    pub fn get(&self, key: SharedKey) -> RcElement<T> {
-        self.inner
-            .borrow_mut()
-            .get(key.into())
-            .expect("the value exists because the shared key exists")
-    }
-
-    pub fn insert(&self, owned_key: OwnedKey, value: T) -> SharedKey {
-        let key = self.inner.borrow_mut().insert(value);
-        SharedKey(key as u32, owned_key)
-    }
-
-    pub fn try_evict(&self, key: SharedKey) -> Option<T> {
-        self.inner.borrow_mut().try_remove(key.into())
-    }
-
-    pub fn for_each<F>(&self, mut f: F)
-    where
-        F: FnMut(usize, &T),
-    {
-        self.inner.borrow().iter().for_each(|(k, v)| f(k, v));
-    }
-}
-
-impl<T: std::fmt::Debug> Shared<T> {
-    pub fn dump_state(&self) -> String {
-        self.inner.borrow().dump_state()
-    }
-}
diff --git a/anathema-store/src/tree/mod.rs b/anathema-store/src/tree/mod.rs
index 227312be..6ff163f3 100644
--- a/anathema-store/src/tree/mod.rs
+++ b/anathema-store/src/tree/mod.rs
@@ -10,7 +10,7 @@ mod nodepath;
 mod transactions;
 mod view;
 
-pub type TreeValues<T> = GenSlab<(Box<[u16]>, T)>;
+pub type TreeValues<T> = GenSlab<ValueId, (Box<[u16]>, T)>;
 
 #[derive(Debug)]
 pub struct RemovedValues {
@@ -141,7 +141,7 @@ impl Nodes {
     }
 
     // Clear nodes and remove associated values
-    fn clear<T, F>(&mut self, values: &mut GenSlab<(Box<[u16]>, T)>, removed_values: &mut RemovedValues, f: &mut F)
+    fn clear<T, F>(&mut self, values: &mut GenSlab<ValueId, (Box<[u16]>, T)>, removed_values: &mut RemovedValues, f: &mut F)
     where
         F: FnMut(T),
     {
diff --git a/anathema-templates/Cargo.toml b/anathema-templates/Cargo.toml
deleted file mode 100644
index 07efb1ef..00000000
--- a/anathema-templates/Cargo.toml
+++ /dev/null
@@ -1,19 +0,0 @@
-[package]
-name = "anathema-templates"
-license = "MIT"
-description = "Anathema template parser (aml)"
-version.workspace = true
-edition.workspace = true
-documentation = "https://togglebyte.github.io/anathema-guide/"
-homepage = "https://github.com/togglebyte/anathema"
-repository = "https://github.com/togglebyte/anathema"
-
-[dependencies]
-anathema-state = { workspace = true }
-anathema-store = { workspace = true }
-
-[dev-dependencies]
-anathema-debug = { path = "../anathema-debug" }
-
-[lints]
-workspace = true
diff --git a/anathema-templates/src/blueprints.rs b/anathema-templates/src/blueprints.rs
deleted file mode 100644
index 6652f18b..00000000
--- a/anathema-templates/src/blueprints.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-use anathema_store::smallmap::SmallMap;
-use anathema_store::storage::strings::StringId;
-
-use crate::components::AssocEventMapping;
-use crate::{ComponentBlueprintId, Expression};
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct Single {
-    pub ident: String,
-    pub children: Vec<Blueprint>,
-    pub attributes: SmallMap<String, Expression>,
-    pub value: Option<Expression>,
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct For {
-    pub binding: String,
-    pub data: Expression,
-    pub body: Vec<Blueprint>,
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct With {
-    pub binding: String,
-    pub data: Expression,
-    pub body: Vec<Blueprint>,
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub struct ControlFlow {
-    // pub if_node: If,
-    pub elses: Vec<Else>,
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct Else {
-    pub cond: Option<Expression>,
-    pub body: Vec<Blueprint>,
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct Component {
-    pub name: String,
-    pub name_id: StringId,
-    pub id: ComponentBlueprintId,
-    pub body: Vec<Blueprint>,
-    pub attributes: SmallMap<String, Expression>,
-    pub assoc_functions: Vec<AssocEventMapping>,
-    /// The parent component in the blueprint
-    pub parent: Option<ComponentBlueprintId>,
-}
-
-/// A blueprint represents what widget should be built from the information
-#[derive(Clone, Debug, PartialEq)]
-pub enum Blueprint {
-    Single(Single),
-    For(For),
-    With(With),
-    ControlFlow(ControlFlow),
-    Component(Component),
-    Slot(Vec<Self>),
-}
-
-#[macro_export]
-macro_rules! single {
-    ($ident:expr) => {
-        $crate::blueprints::Blueprint::Single(Single {
-            ident: $ident.into(),
-            children: vec![],
-            attributes: SmallMap::empty(),
-            value: None,
-        })
-    };
-    (value @ $ident:expr, $value:expr) => {
-        $crate::blueprints::Blueprint::Single(Single {
-            ident: $ident.into(),
-            children: vec![],
-            attributes: SmallMap::empty(),
-            value: Some($value.into()),
-        })
-    };
-    (children @ $ident:expr, $children:expr) => {
-        $crate::blueprints::Blueprint::Single(Single {
-            ident: $ident.into(),
-            children: $children,
-            attributes: SmallMap::empty(),
-            value: None,
-        })
-    };
-}
-
-#[macro_export]
-macro_rules! forloop {
-    ($binding:expr, $data:expr, $body:expr) => {
-        $crate::blueprints::Blueprint::For(For {
-            binding: $binding.into(),
-            data: $data,
-            body: $body,
-        })
-    };
-}
diff --git a/anathema-templates/src/lib.rs b/anathema-templates/src/lib.rs
deleted file mode 100644
index bd39a03f..00000000
--- a/anathema-templates/src/lib.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-pub use crate::components::{AssocEventMapping, ComponentBlueprintId, SourceKind, TemplateSource, ToSourceKind};
-pub use crate::document::Document;
-pub use crate::expressions::Expression;
-pub use crate::lexer::Lexer;
-pub use crate::primitives::Primitive;
-pub use crate::variables::Variables;
-
-pub mod blueprints;
-pub(crate) mod components;
-mod document;
-pub mod error;
-pub mod expressions;
-mod lexer;
-mod primitives;
-mod statements;
-pub mod strings;
-mod token;
-mod variables;
diff --git a/anathema-testutils/Cargo.toml b/anathema-testutils/Cargo.toml
deleted file mode 100644
index e4ee4795..00000000
--- a/anathema-testutils/Cargo.toml
+++ /dev/null
@@ -1,15 +0,0 @@
-[package]
-name = "anathema-testutils"
-license = "MIT"
-description = "Test utilities for Anathema"
-version.workspace = true
-edition.workspace = true
-documentation = "https://togglebyte.github.io/anathema-guide/"
-homepage = "https://github.com/togglebyte/anathema"
-repository = "https://github.com/togglebyte/anathema"
-
-[dependencies]
-anathema = { path = "../", version = "0.2.12-beta" }
-
-[lints]
-workspace = true
diff --git a/anathema-testutils/src/lib.rs b/anathema-testutils/src/lib.rs
deleted file mode 100644
index b9f9eccd..00000000
--- a/anathema-testutils/src/lib.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-use std::marker::PhantomData;
-
-use anathema::component::*;
-
-#[derive(Debug, State, Default)]
-pub struct BasicState {
-    pub boolean: Value<bool>,
-    pub number: Value<u32>,
-    pub string: Value<String>,
-}
-
-pub struct BasicComp<F, T = BasicState>(F, PhantomData<T>);
-
-impl<F, T> BasicComp<F, T> {
-    pub fn new(f: F) -> Self {
-        Self(f, PhantomData)
-    }
-}
-
-impl<F, T> Component for BasicComp<F, T>
-where
-    F: FnMut(KeyEvent, &mut T, Children<'_, '_>, Context<'_, '_, T>) + 'static,
-    T: State,
-{
-    type Message = ();
-    type State = T;
-
-    fn on_key(
-        &mut self,
-        key: KeyEvent,
-        state: &mut Self::State,
-        children: Children<'_, '_>,
-        context: Context<'_, '_, Self::State>,
-    ) {
-        self.0(key, state, children, context);
-    }
-}
-
-pub fn character(c: char) -> KeyEvent {
-    KeyEvent {
-        code: KeyCode::Char(c),
-        ctrl: false,
-        state: KeyState::Press,
-    }
-}
-
-pub fn tab() -> KeyEvent {
-    KeyEvent {
-        code: KeyCode::Tab,
-        ctrl: false,
-        state: KeyState::Press,
-    }
-}
diff --git a/anathema-value-resolver/Cargo.toml b/anathema-value-resolver/Cargo.toml
deleted file mode 100644
index 5fa45266..00000000
--- a/anathema-value-resolver/Cargo.toml
+++ /dev/null
@@ -1,24 +0,0 @@
-[package]
-name = "anathema-value-resolver"
-license = "MIT"
-description = "Anathema value resolver"
-version.workspace = true
-edition.workspace = true
-documentation = "https://togglebyte.github.io/anathema-guide/"
-homepage = "https://github.com/togglebyte/anathema"
-repository = "https://github.com/togglebyte/anathema"
-
-[dependencies]
-anathema-state = { workspace = true }
-anathema-templates = { workspace = true }
-anathema-store = { workspace = true }
-unicode-width = { workspace = true }
-puffin = { version = "0.19.1", features = ["web"], optional = true }
-puffin_http = { version = "0.16.1", optional = true }
-
-[features]
-default = []
-profile = ["puffin", "puffin_http"]
-
-[lints]
-workspace = true
diff --git a/anathema-value-resolver/src/attributes.rs b/anathema-value-resolver/src/attributes.rs
deleted file mode 100644
index 8441a520..00000000
--- a/anathema-value-resolver/src/attributes.rs
+++ /dev/null
@@ -1,355 +0,0 @@
-use std::borrow::Borrow;
-
-use anathema_store::slab::{Gen, SecondaryMap};
-use anathema_store::smallmap::SmallIndex;
-
-use crate::ValueKind;
-use crate::expression::ValueExpr;
-use crate::value::{Value, Values};
-
-type WidgetId = anathema_store::slab::Key;
-
-#[derive(Debug, Copy, Clone, PartialEq, Default)]
-pub enum ValueKey<'bp> {
-    #[default]
-    Value,
-    Attribute(&'bp str),
-}
-
-impl ValueKey<'_> {
-    pub fn as_str(&self) -> &str {
-        match self {
-            ValueKey::Value => "[value]",
-            ValueKey::Attribute(name) => name,
-        }
-    }
-}
-
-impl Borrow<str> for ValueKey<'_> {
-    fn borrow(&self) -> &str {
-        self.as_str()
-    }
-}
-
-// -----------------------------------------------------------------------------
-//   - Attribute storage -
-// -----------------------------------------------------------------------------
-#[derive(Debug)]
-pub struct AttributeStorage<'bp>(SecondaryMap<WidgetId, (Gen, Attributes<'bp>)>);
-
-impl<'bp> AttributeStorage<'bp> {
-    pub fn empty() -> Self {
-        Self(SecondaryMap::empty())
-    }
-
-    /// Get a reference to attributes by widget id
-    pub fn get(&self, id: WidgetId) -> &Attributes<'bp> {
-        self.0.get(id).map(|(_, a)| a).expect("every element has attributes")
-    }
-
-    /// Get a reference to attributes by widget id
-    pub fn try_get(&self, id: WidgetId) -> Option<&Attributes<'bp>> {
-        self.0.get(id).map(|(_, a)| a)
-    }
-
-    /// Get a mutable reference to attributes by widget id
-    pub fn get_mut(&mut self, id: WidgetId) -> &mut Attributes<'bp> {
-        self.0
-            .get_mut(id)
-            .map(|(_, a)| a)
-            .expect("every element has attributes")
-    }
-
-    pub fn with_mut<F, O>(&mut self, widget_id: WidgetId, f: F) -> Option<O>
-    where
-        F: FnOnce(&mut Attributes<'bp>, &mut Self) -> O,
-    {
-        let mut value = self.try_remove(widget_id)?;
-        let output = f(&mut value, self);
-        self.insert(widget_id, value);
-        Some(output)
-    }
-
-    /// Insert attributes for a given widget.
-    ///
-    /// This will overwrite any existing attributes at that location
-    pub fn insert(&mut self, widget_id: WidgetId, attribs: Attributes<'bp>) {
-        self.0.insert(widget_id, (widget_id.generation(), attribs))
-    }
-
-    /// Try to remove attributes for a specific widget
-    pub fn try_remove(&mut self, id: WidgetId) -> Option<Attributes<'bp>> {
-        self.0
-            .remove_if(id, |(current_gen, _)| *current_gen == id.generation())
-            .map(|(_, value)| value)
-    }
-}
-
-// -----------------------------------------------------------------------------
-//   - Attributes -
-// -----------------------------------------------------------------------------
-
-#[derive(Debug)]
-pub struct Attributes<'bp> {
-    pub(crate) attribs: Values<'bp>,
-    pub value: Option<SmallIndex>,
-}
-
-// TODO
-// Only get, set and remove should be part of the interface
-// that is exposed to the end user.
-//
-// The rest is for widget creation and should be moved to its own type.
-
-impl<'bp> Attributes<'bp> {
-    /// Create an empty set of attributes
-    pub fn empty() -> Self {
-        Self {
-            attribs: Values::empty(),
-            value: None,
-        }
-    }
-
-    /// Set an attribute value.
-    /// ```
-    /// # use anathema_value_resolver::{Attributes, ValueKind};
-    ///
-    /// let mut attributes = Attributes::empty();
-    /// attributes.set("name", "Nonsense");
-    /// attributes.get_as::<&str>("name").unwrap();
-    /// ```
-    pub fn set(&mut self, key: &'bp str, value: impl Into<ValueKind<'bp>>) {
-        let key = ValueKey::Attribute(key);
-        let value = Value::static_val(value);
-        self.attribs.set(key, value);
-    }
-
-    /// Set an attribute value.
-    /// ```
-    /// # use anathema_value_resolver::{Attributes, ValueKind};
-    ///
-    /// let mut attributes = Attributes::empty();
-    /// attributes.set_value("Nonsense");
-    /// attributes.value_as::<&str>().unwrap();
-    /// ```
-    pub fn set_value(&mut self, value: impl Into<ValueKind<'bp>>) {
-        let value = Value::static_val(value);
-
-        match self.value {
-            Some(index) => match self.attribs.get_mut_with_index(index) {
-                Some(current) => *current = value,
-                None => {
-                    let index = self.attribs.insert_with(ValueKey::Value, |_| value);
-                    self.value = Some(index);
-                }
-            },
-            None => {
-                let index = self.attribs.insert_with(ValueKey::Value, |_| value);
-                self.value = Some(index);
-            }
-        }
-    }
-
-    // This is only used for inserting values during widget creation where values originate from
-    // expressions.
-    #[doc(hidden)]
-    pub fn insert_with<F>(&mut self, key: ValueKey<'bp>, f: F) -> SmallIndex
-    where
-        F: FnMut(SmallIndex) -> Value<'bp>,
-    {
-        self.attribs.insert_with(key, f)
-    }
-
-    /// Remove a value from attributes
-    pub fn remove(&mut self, key: &'bp str) -> Option<Value<'bp>> {
-        let key = ValueKey::Attribute(key);
-        self.attribs.remove(&key)
-    }
-
-    /// Get the `Value` out of attributes.
-    /// This is always the first item
-    pub fn value(&self) -> Option<&ValueKind<'bp>> {
-        let idx = self.value?;
-        self.attribs.get_with_index(idx).map(|val| &val.kind)
-    }
-
-    /// Get a value as a specific type
-    pub fn value_as<'a, T>(&'a self) -> Option<T>
-    where
-        T: TryFrom<&'a ValueKind<'bp>>,
-    {
-        let idx = self.value?;
-        self.attribs
-            .get_with_index(idx)
-            .and_then(|val| (&val.kind).try_into().ok())
-    }
-
-    pub fn get(&self, key: &str) -> Option<&ValueKind<'bp>> {
-        self.attribs.get(key).map(|val| &val.kind)
-    }
-
-    /// Get a value as a given type.
-    /// If the value doesn't exist or can not be cast to the
-    /// expected type `None` is returned.
-    /// ```
-    /// # use anathema_value_resolver::{Attributes, ValueKind};
-    ///
-    /// let mut attributes = Attributes::empty();
-    /// attributes.set("num", 123);
-    ///
-    /// assert_eq!(attributes.get_as::<u32>("num").unwrap(), 123);
-    /// assert_eq!(attributes.get_as::<i16>("num").unwrap(), 123);
-    /// ```
-    pub fn get_as<'a, T>(&'a self, key: &str) -> Option<T>
-    where
-        T: TryFrom<&'a ValueKind<'bp>>,
-    {
-        self.attribs.get(key).and_then(|val| (&val.kind).try_into().ok())
-    }
-
-    /// Iterate over values of a given type
-    /// ```
-    /// # use anathema_value_resolver::{Attributes, ValueKind};
-    ///
-    /// let mut attributes = Attributes::empty();
-    /// let values =
-    ///     ValueKind::List([ValueKind::Int(1), ValueKind::Bool(true), ValueKind::Int(2)].into());
-    /// attributes.set("mixed_list", values);
-    ///
-    /// let iter = attributes.iter_as::<u32>("mixed_list");
-    /// assert_eq!(vec![1u32, 2], iter.collect::<Vec<_>>());
-    /// ```
-    pub fn iter_as<'a, T>(&'a self, key: &str) -> impl Iterator<Item = T>
-    where
-        T: TryFrom<&'a ValueKind<'bp>>,
-    {
-        self.attribs
-            .get(key)
-            .and_then(|val| match &val.kind {
-                ValueKind::List(value_kinds) => {
-                    let list = value_kinds.iter().filter_map(|v| T::try_from(v).ok());
-                    Some(list)
-                }
-
-                _ => None,
-            })
-            .into_iter()
-            .flatten()
-    }
-
-    #[doc(hidden)]
-    /// This should only be used internally by the widgets
-    /// when updating a value.
-    pub fn get_mut_with_index(&mut self, index: SmallIndex) -> Option<&mut Value<'bp>> {
-        self.attribs.get_mut_with_index(index)
-    }
-
-    /// Iterate over attributes.
-    /// This will skip the value
-    pub fn iter(&self) -> impl Iterator<Item = (&ValueKey<'_>, &ValueKind<'bp>)> {
-        self.attribs.iter().filter_map(|(key, val)| match key {
-            ValueKey::Value => None,
-            ValueKey::Attribute(_) => Some((key, &val.kind)),
-        })
-    }
-
-    pub(super) fn get_value_expr(&self, key: &str) -> Option<ValueExpr<'bp>> {
-        let value = self.attribs.get(key)?;
-        Some(value.expr.clone())
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use anathema_state::{Color, Hex};
-
-    use super::*;
-
-    fn attribs() -> Attributes<'static> {
-        let mut attributes = Attributes::empty();
-
-        let values = ValueKind::List([ValueKind::Int(1), ValueKind::Bool(true), ValueKind::Int(2)].into());
-        attributes.set("mixed_list", values);
-        attributes.set("num", 123);
-        attributes.set("static_str", "static");
-        attributes.set("string", String::from("string"));
-        attributes.set("hex", Hex::from((1, 2, 3)));
-        attributes.set("red", Color::Red);
-        attributes.set("float", 1.23);
-        attributes.set("bool", true);
-        attributes.set("char", 'a');
-        attributes.set_value(123u8);
-
-        attributes
-    }
-
-    #[test]
-    fn iter_as_type() {
-        let attributes = attribs();
-
-        let values = attributes.iter_as::<u8>("mixed_list").collect::<Vec<_>>();
-        assert_eq!(vec![1, 2], values);
-
-        let values = attributes.iter_as::<bool>("mixed_list").collect::<Vec<_>>();
-        assert_eq!(vec![true], values);
-    }
-
-    #[test]
-    fn get_as_int() {
-        assert_eq!(123, attribs().get_as::<u8>("num").unwrap());
-        assert_eq!(123, attribs().get_as::<i8>("num").unwrap());
-        assert_eq!(123, attribs().get_as::<u16>("num").unwrap());
-        assert_eq!(123, attribs().get_as::<i16>("num").unwrap());
-        assert_eq!(123, attribs().get_as::<u32>("num").unwrap());
-        assert_eq!(123, attribs().get_as::<i32>("num").unwrap());
-        assert_eq!(123, attribs().get_as::<u64>("num").unwrap());
-        assert_eq!(123, attribs().get_as::<i64>("num").unwrap());
-        assert_eq!(123, attribs().get_as::<usize>("num").unwrap());
-        assert_eq!(123, attribs().get_as::<isize>("num").unwrap());
-    }
-
-    #[test]
-    fn get_as_strings() {
-        let attributes = attribs();
-        assert_eq!("static", attributes.get_as::<&str>("static_str").unwrap());
-        assert_eq!("string", attributes.get_as::<&str>("string").unwrap());
-    }
-
-    #[test]
-    fn get_as_hex() {
-        let attributes = attribs();
-        assert_eq!(Hex::from((1, 2, 3)), attributes.get_as::<Hex>("hex").unwrap());
-    }
-
-    #[test]
-    fn get_as_color() {
-        let attributes = attribs();
-        assert_eq!(Color::Red, attributes.get_as::<Color>("red").unwrap());
-    }
-
-    #[test]
-    fn get_as_float() {
-        let attributes = attribs();
-        assert_eq!(1.23, attributes.get_as::<f32>("float").unwrap());
-        assert_eq!(1.23, attributes.get_as::<f64>("float").unwrap());
-    }
-
-    #[test]
-    fn get_as_bool() {
-        let attributes = attribs();
-        assert!(attributes.get_as::<bool>("bool").unwrap());
-    }
-
-    #[test]
-    fn get_as_char() {
-        let attributes = attribs();
-        assert_eq!('a', attributes.get_as::<char>("char").unwrap());
-    }
-
-    #[test]
-    fn get_value_as() {
-        let attributes = attribs();
-        let value = attributes.value_as::<u8>().unwrap();
-        assert_eq!(value, 123);
-    }
-}
diff --git a/anathema-value-resolver/src/context.rs b/anathema-value-resolver/src/context.rs
deleted file mode 100644
index 93457770..00000000
--- a/anathema-value-resolver/src/context.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-use anathema_state::States;
-use anathema_templates::Variables;
-
-use crate::AttributeStorage;
-use crate::functions::{Function, FunctionTable};
-use crate::scope::Scope;
-
-pub struct ResolverCtx<'frame, 'bp> {
-    pub(crate) scope: &'frame Scope<'frame, 'bp>,
-    pub(crate) variables: &'bp Variables,
-    pub(crate) states: &'frame States,
-    pub(crate) attribute_storage: &'frame AttributeStorage<'bp>,
-    pub(crate) function_table: &'bp FunctionTable,
-}
-
-impl<'frame, 'bp> ResolverCtx<'frame, 'bp> {
-    pub fn new(
-        variables: &'bp Variables,
-        scope: &'frame Scope<'frame, 'bp>,
-        states: &'frame States,
-        attribute_storage: &'frame AttributeStorage<'bp>,
-        function_table: &'bp FunctionTable,
-    ) -> Self {
-        Self {
-            scope,
-            variables,
-            states,
-            attribute_storage,
-            function_table,
-        }
-    }
-
-    pub(crate) fn lookup_function(&self, ident: &str) -> Option<&'bp Function> {
-        self.function_table.lookup(ident)
-    }
-}
diff --git a/anathema-value-resolver/src/expression.rs b/anathema-value-resolver/src/expression.rs
deleted file mode 100644
index 49c78a15..00000000
--- a/anathema-value-resolver/src/expression.rs
+++ /dev/null
@@ -1,614 +0,0 @@
-use std::borrow::Cow;
-use std::collections::HashMap;
-
-use anathema_state::{Color, Hex, PendingValue, SubTo, Subscriber, Type};
-use anathema_store::slab::Key;
-use anathema_templates::Primitive;
-use anathema_templates::expressions::{Equality, LogicalOp, Op};
-
-use crate::AttributeStorage;
-use crate::functions::Function;
-use crate::value::ValueKind;
-
-macro_rules! or_null {
-    ($val:expr) => {
-        match $val {
-            Some(val) => val,
-            None => return ValueExpr::Null,
-        }
-    };
-}
-
-#[derive(Debug, Default, Copy, Clone)]
-pub(crate) enum ResolvedState {
-    Resolved,
-    PartiallyResolved,
-    #[default]
-    Unresolved,
-}
-
-pub struct ValueResolutionContext<'a, 'bp> {
-    pub(crate) sub: Subscriber,
-    attribute_storage: &'a AttributeStorage<'bp>,
-    pub(crate) resolved_state: ResolvedState,
-    pub(crate) sub_keys: SubTo,
-}
-
-impl<'a, 'bp> ValueResolutionContext<'a, 'bp> {
-    pub fn new(attribute_storage: &'a AttributeStorage<'bp>, sub: Subscriber, resolved_state: ResolvedState) -> Self {
-        Self {
-            attribute_storage,
-            sub,
-            resolved_state,
-            sub_keys: SubTo::empty(),
-        }
-    }
-
-    pub(crate) fn force_sub(&mut self, pending: &PendingValue) {
-        pending.subscribe(self.sub);
-        self.sub_keys.push(pending.sub_key());
-    }
-
-    fn maybe_subscribe(&mut self, pending: &PendingValue) {
-        match self.resolved_state {
-            ResolvedState::Resolved => (),
-            ResolvedState::PartiallyResolved => (),
-            ResolvedState::Unresolved => {
-                pending.subscribe(self.sub);
-                self.sub_keys.push(pending.sub_key());
-            }
-        }
-    }
-
-    fn resolved(&mut self, pending: &PendingValue) {
-        match self.resolved_state {
-            ResolvedState::Resolved => (),
-            ResolvedState::PartiallyResolved | ResolvedState::Unresolved => pending.subscribe(self.sub),
-        }
-
-        self.resolved_state = ResolvedState::Resolved;
-    }
-
-    fn partially_resolved(&mut self, pending: &PendingValue) {
-        self.resolved_state = ResolvedState::PartiallyResolved;
-        self.sub_keys.push(pending.sub_key());
-        pending.subscribe(self.sub);
-    }
-
-    fn is_partially_resolved(&self) -> bool {
-        match self.resolved_state {
-            ResolvedState::PartiallyResolved => true,
-            ResolvedState::Resolved | ResolvedState::Unresolved => false,
-        }
-    }
-
-    pub(crate) fn done(&mut self) {
-        if let ResolvedState::Unresolved = self.resolved_state {
-            self.resolved_state = ResolvedState::Resolved;
-        }
-    }
-}
-
-#[derive(Debug, Copy, Clone)]
-pub enum Kind<T> {
-    Static(T),
-    Dyn(PendingValue),
-}
-
-#[derive(Debug, Clone)]
-pub enum ValueExpr<'bp> {
-    Bool(Kind<bool>),
-    Char(Kind<char>),
-    Int(Kind<i64>),
-    Float(Kind<f64>),
-    Hex(Kind<Hex>),
-    Color(Kind<Color>),
-    Str(Kind<&'bp str>),
-    DynMap(PendingValue),
-    DynList(PendingValue),
-    Composite(PendingValue),
-    List(Box<[Self]>),
-    Map(HashMap<&'bp str, Self>),
-    Index(Box<Self>, Box<Self>),
-    Range(Box<Self>, Box<Self>),
-    Attributes(Key),
-
-    Not(Box<Self>),
-    Negative(Box<Self>),
-
-    Equality(Box<Self>, Box<Self>, Equality),
-    LogicalOp(Box<Self>, Box<Self>, LogicalOp),
-
-    Op(Box<Self>, Box<Self>, Op),
-    Either(Box<Self>, Box<Self>),
-
-    Call {
-        fun_ptr: &'bp Function,
-        args: Box<[ValueExpr<'bp>]>,
-    },
-
-    Null,
-}
-
-impl<'bp> From<Primitive> for ValueExpr<'bp> {
-    fn from(value: Primitive) -> Self {
-        match value {
-            Primitive::Bool(b) => Self::Bool(Kind::Static(b)),
-            Primitive::Char(c) => Self::Char(Kind::Static(c)),
-            Primitive::Int(i) => Self::Int(Kind::Static(i)),
-            Primitive::Float(f) => Self::Float(Kind::Static(f)),
-            Primitive::Hex(hex) => Self::Hex(Kind::Static(hex)),
-        }
-    }
-}
-
-impl<'bp> From<PendingValue> for ValueExpr<'bp> {
-    fn from(value: PendingValue) -> Self {
-        match value.type_info() {
-            Type::Int => Self::Int(Kind::Dyn(value)),
-            Type::Float => Self::Float(Kind::Dyn(value)),
-            Type::Char => Self::Char(Kind::Dyn(value)),
-            Type::String => Self::Str(Kind::Dyn(value)),
-            Type::Bool => Self::Bool(Kind::Dyn(value)),
-            Type::Hex => Self::Hex(Kind::Dyn(value)),
-            Type::Color => Self::Color(Kind::Dyn(value)),
-            Type::Map => Self::DynMap(value),
-            Type::List => Self::DynList(value),
-            Type::Composite => Self::Composite(value),
-            Type::Unit => Self::Null,
-            Type::Maybe => todo!(
-                "we probably need to add ValueExpr::Maybe(PendingValue) for this, this would be the only place where that variant would make sense"
-            ),
-        }
-    }
-}
-
-// Resolve an expression to a value kind, this is the final value in the chain
-pub(crate) fn resolve_value<'a, 'bp>(
-    value_expr: &ValueExpr<'bp>,
-    ctx: &mut ValueResolutionContext<'a, 'bp>,
-) -> ValueKind<'bp> {
-    match value_expr {
-        // -----------------------------------------------------------------------------
-        //   - Primitives -
-        // -----------------------------------------------------------------------------
-        ValueExpr::Bool(Kind::Static(b)) => ValueKind::Bool(*b),
-        ValueExpr::Bool(Kind::Dyn(pending)) => {
-            ctx.maybe_subscribe(pending);
-            let Some(state) = pending.as_state() else { return ValueKind::Null };
-            match state.as_bool() {
-                Some(b) => ValueKind::Bool(b),
-                None => ValueKind::Null,
-            }
-        }
-        ValueExpr::Char(Kind::Static(c)) => ValueKind::Char(*c),
-        ValueExpr::Char(Kind::Dyn(pending)) => {
-            ctx.maybe_subscribe(pending);
-            let Some(state) = pending.as_state() else { return ValueKind::Null };
-            match state.as_char() {
-                Some(c) => ValueKind::Char(c),
-                None => ValueKind::Null,
-            }
-        }
-        ValueExpr::Int(Kind::Static(i)) => ValueKind::Int(*i),
-        ValueExpr::Int(Kind::Dyn(pending)) => {
-            ctx.maybe_subscribe(pending);
-            let Some(state) = pending.as_state() else { return ValueKind::Null };
-            match state.as_int() {
-                Some(i) => ValueKind::Int(i),
-                None => ValueKind::Null,
-            }
-        }
-        ValueExpr::Float(Kind::Static(f)) => ValueKind::Float(*f),
-        ValueExpr::Float(Kind::Dyn(pending)) => {
-            ctx.maybe_subscribe(pending);
-            let Some(state) = pending.as_state() else { return ValueKind::Null };
-            match state.as_float() {
-                Some(f) => ValueKind::Float(f),
-                None => ValueKind::Null,
-            }
-        }
-        ValueExpr::Hex(Kind::Static(h)) => ValueKind::Hex(*h),
-        ValueExpr::Hex(Kind::Dyn(pending)) => {
-            ctx.maybe_subscribe(pending);
-            let Some(state) = pending.as_state() else { return ValueKind::Null };
-            match state.as_hex() {
-                Some(h) => ValueKind::Hex(h),
-                None => ValueKind::Null,
-            }
-        }
-        ValueExpr::Color(Kind::Static(h)) => ValueKind::Color(*h),
-        ValueExpr::Color(Kind::Dyn(pending)) => {
-            ctx.maybe_subscribe(pending);
-            let Some(state) = pending.as_state() else { return ValueKind::Null };
-            match state.as_color() {
-                Some(h) => ValueKind::Color(h),
-                None => ValueKind::Null,
-            }
-        }
-        ValueExpr::Str(Kind::Static(s)) => ValueKind::Str(Cow::Borrowed(s)),
-        ValueExpr::Str(Kind::Dyn(pending)) => {
-            ctx.maybe_subscribe(pending);
-            let Some(state) = pending.as_state() else { return ValueKind::Null };
-            match state.as_str() {
-                Some(s) => ValueKind::Str(Cow::Owned(s.to_owned())),
-                None => ValueKind::Null,
-            }
-        }
-
-        // -----------------------------------------------------------------------------
-        //   - Operations and conditionals -
-        // -----------------------------------------------------------------------------
-        ValueExpr::Not(value_expr) => {
-            let value = resolve_value(value_expr, ctx);
-            ValueKind::Bool(!value.truthiness())
-        }
-        ValueExpr::Negative(value_expr) => match resolve_value(value_expr, ctx) {
-            ValueKind::Int(n) => ValueKind::Int(-n),
-            ValueKind::Float(n) => ValueKind::Float(-n),
-            _ => ValueKind::Null,
-        },
-        ValueExpr::Equality(lhs, rhs, equality) => {
-            let lhs = resolve_value(lhs, ctx);
-            let rhs = resolve_value(rhs, ctx);
-            let b = match equality {
-                Equality::Eq => lhs.value_eq(&rhs),
-                Equality::NotEq => !lhs.value_eq(&rhs),
-                Equality::Gt => lhs > rhs,
-                Equality::Gte => lhs >= rhs,
-                Equality::Lt => lhs < rhs,
-                Equality::Lte => lhs <= rhs,
-            };
-            ValueKind::Bool(b)
-        }
-        ValueExpr::LogicalOp(lhs, rhs, logical_op) => {
-            let ValueKind::Bool(lhs) = resolve_value(lhs, ctx) else { return ValueKind::Null };
-            let ValueKind::Bool(rhs) = resolve_value(rhs, ctx) else { return ValueKind::Null };
-            let b = match logical_op {
-                LogicalOp::And => lhs && rhs,
-                LogicalOp::Or => lhs || rhs,
-            };
-            ValueKind::Bool(b)
-        }
-        ValueExpr::Op(lhs, rhs, op) => match (resolve_value(lhs, ctx), resolve_value(rhs, ctx)) {
-            (ValueKind::Int(lhs), ValueKind::Int(rhs)) => ValueKind::Int(int_op(lhs, rhs, *op)),
-            (ValueKind::Int(lhs), ValueKind::Float(rhs)) => ValueKind::Float(float_op(lhs as f64, rhs, *op)),
-            (ValueKind::Float(lhs), ValueKind::Int(rhs)) => ValueKind::Float(float_op(lhs, rhs as f64, *op)),
-            (ValueKind::Float(lhs), ValueKind::Float(rhs)) => ValueKind::Float(float_op(lhs, rhs, *op)),
-            _ => ValueKind::Null,
-        },
-        ValueExpr::Either(first, second) => {
-            let value = resolve_value(first, ctx);
-            if value.truthiness() {
-                return value;
-            }
-            resolve_value(second, ctx)
-        }
-        ValueExpr::Range(from, to) => {
-            let from = match resolve_int(from, ctx) {
-                Some(i) => i,
-                None => return ValueKind::Null,
-            };
-
-            let to = match resolve_int(to, ctx) {
-                Some(i) => i,
-                None => return ValueKind::Null,
-            };
-            ValueKind::Range(from, to)
-        }
-
-        // -----------------------------------------------------------------------------
-        //   - Maps, lists and maybe -
-        // -----------------------------------------------------------------------------
-        ValueExpr::Map(_) => ValueKind::Map,
-        ValueExpr::DynMap(map) => ValueKind::DynMap(*map),
-        ValueExpr::Attributes(_) => ValueKind::Attributes,
-        ValueExpr::DynList(value) => {
-            ctx.maybe_subscribe(value);
-            ValueKind::DynList(*value)
-        }
-        ValueExpr::List(l) => {
-            let values = l.iter().map(|v| resolve_value(v, ctx)).collect();
-            ValueKind::List(values)
-        }
-        ValueExpr::Index(src, index) => {
-            let expr = resolve_index(src, index, ctx);
-            resolve_value(&expr, ctx)
-        }
-        ValueExpr::Composite(comp) => ValueKind::Composite(*comp),
-
-        // -----------------------------------------------------------------------------
-        //   - Call -
-        // -----------------------------------------------------------------------------
-        ValueExpr::Call { fun_ptr, args } => {
-            let args = args.iter().map(|arg| resolve_value(arg, ctx)).collect::<Box<_>>();
-            fun_ptr.invoke(&args)
-        }
-
-        // -----------------------------------------------------------------------------
-        //   - Null -
-        // -----------------------------------------------------------------------------
-        ValueExpr::Null => ValueKind::Null,
-    }
-}
-
-fn resolve_pending<'bp>(val: PendingValue, ctx: &mut ValueResolutionContext<'_, 'bp>) -> ValueExpr<'static> {
-    match val.type_info() {
-        Type::Int => ValueExpr::Int(Kind::Dyn(val)),
-        Type::Float => ValueExpr::Float(Kind::Dyn(val)),
-        Type::Char => ValueExpr::Char(Kind::Dyn(val)),
-        Type::String => ValueExpr::Str(Kind::Dyn(val)),
-        Type::Bool => ValueExpr::Bool(Kind::Dyn(val)),
-        Type::Hex => ValueExpr::Hex(Kind::Dyn(val)),
-        Type::Color => ValueExpr::Color(Kind::Dyn(val)),
-        Type::Map | Type::Composite => ValueExpr::DynMap(val),
-        Type::List => ValueExpr::DynList(val),
-        Type::Unit => ValueExpr::Null,
-        Type::Maybe => {
-            let state = or_null!(val.as_state());
-            let maybe = or_null!(state.as_maybe());
-            // If there is no value, subscribe to the `Maybe`
-            let inner = match maybe.get() {
-                Some(inner) => inner,
-                None => {
-                    ctx.maybe_subscribe(&val);
-                    return ValueExpr::Null;
-                }
-            };
-            resolve_pending(inner, ctx)
-        }
-    }
-}
-
-fn resolve_index<'bp>(
-    src: &ValueExpr<'bp>,
-    index: &ValueExpr<'bp>,
-    ctx: &mut ValueResolutionContext<'_, 'bp>,
-) -> ValueExpr<'bp> {
-    match src {
-        ValueExpr::DynMap(value) | ValueExpr::Composite(value) => {
-            let state = or_null!(value.as_state());
-            let map = match state.as_any_map() {
-                Some(map) => map,
-                None => return ValueExpr::Null,
-            };
-
-            let key = or_null!(resolve_str(index, ctx));
-            let val = map.lookup(&key);
-
-            let val = match val {
-                Some(key) => {
-                    if ctx.is_partially_resolved() {
-                        value.unsubscribe(ctx.sub);
-                    }
-                    key
-                }
-                None => {
-                    ctx.partially_resolved(value);
-                    return ValueExpr::Null;
-                }
-            };
-
-            ctx.resolved(&val);
-            resolve_pending(val, ctx)
-        }
-        ValueExpr::DynList(value) => {
-            let state = or_null!(value.as_state());
-            let list = match state.as_any_list() {
-                Some(list) => list,
-                None => return ValueExpr::Null,
-            };
-
-            let index = or_null!(resolve_int(index, ctx));
-            let val = list.lookup(index);
-
-            // If the values doesn't exist subscribe to the underlying map / state
-            // to get notified when the value does exist.
-            //
-            // If the value does exist unsubscribe from the underlying map / state
-            let val = match val {
-                Some(val) => {
-                    if ctx.is_partially_resolved() {
-                        value.unsubscribe(ctx.sub);
-                    }
-                    val
-                }
-                None => {
-                    ctx.partially_resolved(value);
-                    return ValueExpr::Null;
-                }
-            };
-            resolve_pending(val, ctx)
-        }
-        ValueExpr::Attributes(widget_id) => {
-            let key = or_null!(resolve_str(index, ctx));
-            let attributes = ctx.attribute_storage.get(*widget_id);
-            or_null!(attributes.get_value_expr(&key))
-        }
-        ValueExpr::List(list) => {
-            let index = or_null!(resolve_int(index, ctx));
-            match list.get(index).cloned() {
-                Some(val) => val,
-                None => ValueExpr::Null,
-            }
-        }
-        ValueExpr::Map(hash_map) => {
-            let key = or_null!(resolve_str(index, ctx));
-            or_null!(hash_map.get(&*key).cloned())
-        }
-        ValueExpr::Index(inner_src, inner_index) => {
-            let src = resolve_index(inner_src, inner_index, ctx);
-            resolve_index(&src, index, ctx)
-        }
-        ValueExpr::Either(first, second) => {
-            let src = match resolve_expr(first, ctx) {
-                None | Some(ValueExpr::Null) => match resolve_expr(second, ctx) {
-                    None | Some(ValueExpr::Null) => return ValueExpr::Null,
-                    Some(e) => e,
-                },
-                Some(e) => e,
-            };
-            resolve_index(&src, index, ctx)
-        }
-        ValueExpr::Null => ValueExpr::Null,
-        // TODO: see unreachable message
-        val => unreachable!(
-            "resolving index: this should return null eventually: {val:?} (you probably did something like x.y on a string)"
-        ),
-    }
-}
-
-fn resolve_expr<'bp>(expr: &ValueExpr<'bp>, ctx: &mut ValueResolutionContext<'_, 'bp>) -> Option<ValueExpr<'bp>> {
-    match expr {
-        ValueExpr::Either(first, second) => match resolve_expr(first, ctx) {
-            None | Some(ValueExpr::Null) => resolve_expr(second, ctx),
-            expr => expr,
-        },
-        ValueExpr::Index(src, index) => Some(resolve_index(src, index, ctx)),
-        _ => None,
-    }
-}
-
-fn resolve_str<'bp>(index: &ValueExpr<'bp>, ctx: &mut ValueResolutionContext<'_, 'bp>) -> Option<Cow<'bp, str>> {
-    match resolve_value(index, ctx) {
-        ValueKind::Str(s) => Some(s),
-        _ => None,
-    }
-}
-
-fn resolve_int<'bp>(index: &ValueExpr<'bp>, ctx: &mut ValueResolutionContext<'_, 'bp>) -> Option<usize> {
-    let value = resolve_value(index, ctx);
-    match value {
-        ValueKind::Int(index) => Some(index as usize),
-        ValueKind::Bool(false) => Some(0),
-        ValueKind::Bool(true) => Some(1),
-        ValueKind::Float(index) => Some(index as usize),
-        ValueKind::Char(_)
-        | ValueKind::Hex(_)
-        | ValueKind::Color(_)
-        | ValueKind::Str(_)
-        | ValueKind::Composite(_)
-        | ValueKind::Null
-        | ValueKind::Map
-        | ValueKind::DynMap(_)
-        | ValueKind::Attributes
-        | ValueKind::List(_)
-        | ValueKind::Range(..)
-        | ValueKind::DynList(_) => None,
-    }
-}
-
-fn int_op(lhs: i64, rhs: i64, op: Op) -> i64 {
-    match op {
-        Op::Add => lhs + rhs,
-        Op::Sub => lhs - rhs,
-        Op::Div => lhs / rhs,
-        Op::Mul => lhs * rhs,
-        Op::Mod => lhs % rhs,
-    }
-}
-
-fn float_op(lhs: f64, rhs: f64, op: Op) -> f64 {
-    match op {
-        Op::Add => lhs + rhs,
-        Op::Sub => lhs - rhs,
-        Op::Div => lhs / rhs,
-        Op::Mul => lhs * rhs,
-        Op::Mod => lhs % rhs,
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use anathema_state::{Changes, Map, Maybe, States, drain_changes};
-    use anathema_templates::expressions::{ident, index, num, strlit};
-
-    use crate::testing::setup;
-
-    #[test]
-    fn subscribe_if_not_exist() {
-        // In this case the list is empty but it exists
-
-        let mut changes = Changes::empty();
-        drain_changes(&mut changes);
-        assert!(changes.is_empty());
-
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            let expr = index(index(ident("state"), strlit("list")), num(0));
-
-            let mut value = test.eval(&expr);
-
-            assert_eq!(value.as_int(), None);
-
-            test.with_state(|state| state.list.push("a"));
-
-            drain_changes(&mut changes);
-            for (subs, _) in changes.drain() {
-                for sub in subs.iter() {
-                    if sub == value.sub {
-                        value.reload(&test.attributes);
-                    }
-                }
-            }
-
-            assert_eq!(value.as_str().unwrap(), "a");
-        });
-    }
-
-    #[test]
-    fn list_preceding_value_removed() {
-        let mut changes = Changes::empty();
-        let mut states = States::new();
-
-        setup(&mut states, Default::default(), |test| {
-            // state.list[1]
-            let expr = index(index(ident("state"), strlit("list")), num(1));
-
-            test.with_state(|state| {
-                state.list.push("a");
-                state.list.push("b");
-                state.list.push("c");
-            });
-
-            let mut value = test.eval(&expr);
-
-            assert_eq!(value.as_str().unwrap(), "b");
-
-            test.with_state(|state| state.list.remove(0));
-
-            drain_changes(&mut changes);
-            assert!(!changes.is_empty());
-
-            for (subs, _) in changes.drain() {
-                if subs.iter().any(|sub| sub == value.sub) {
-                    value.reload(&test.attributes);
-                }
-            }
-            assert_eq!(value.as_str().unwrap(), "c");
-        });
-    }
-
-    #[test]
-    fn optional_map_from_empty_to_value() {
-        let mut changes = Changes::empty();
-
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            // let expr = index(index(ident("state"), strlit("opt_map")), strlit("key"));
-            let expr = index(ident("state"), strlit("opt_map"));
-
-            let value = test.eval(&expr);
-            assert!(value.as_str().is_none());
-
-            test.with_state(|state| {
-                let mut map = Map::empty();
-                map.insert("key", 123);
-                state.opt_map.set(Maybe::some(map));
-            });
-
-            drain_changes(&mut changes);
-            assert!(!changes.is_empty());
-        });
-    }
-}
diff --git a/anathema-value-resolver/src/functions/list.rs b/anathema-value-resolver/src/functions/list.rs
deleted file mode 100644
index f74cd89d..00000000
--- a/anathema-value-resolver/src/functions/list.rs
+++ /dev/null
@@ -1,143 +0,0 @@
-use crate::ValueKind;
-
-pub(super) fn contains<'bp>(args: &[ValueKind<'bp>]) -> ValueKind<'bp> {
-    if args.len() != 2 {
-        return ValueKind::Null;
-    }
-
-    let haystack = &args[0];
-    let needle = &args[1];
-
-    match haystack {
-        ValueKind::Str(string) => match needle {
-            ValueKind::Str(other) => ValueKind::Bool(string.as_ref().contains(other.as_ref())),
-            _ => ValueKind::Bool(false),
-        },
-        ValueKind::List(elements) => elements
-            .iter()
-            .find_map(|el| needle.eq(el).then_some(ValueKind::Bool(true)))
-            .unwrap_or(ValueKind::Bool(false)),
-        ValueKind::DynList(haystack) => {
-            let Some(haystack) = haystack.as_state() else { return ValueKind::Bool(false) };
-            let Some(haystack) = haystack.as_any_list() else { return ValueKind::Bool(false) };
-            for val in haystack.iter() {
-                if needle.compare_pending(val) {
-                    return ValueKind::Bool(true);
-                }
-            }
-            ValueKind::Bool(false)
-        }
-        _ => ValueKind::Null,
-    }
-}
-
-pub(super) fn len<'bp>(args: &[ValueKind<'bp>]) -> ValueKind<'bp> {
-    if args.len() != 1 {
-        return ValueKind::Null;
-    }
-
-    let len = match &args[0] {
-        ValueKind::Str(string) => string.len(),
-        ValueKind::List(list) => list.len(),
-        ValueKind::Range(from, to) => to - from,
-        ValueKind::DynList(pending) => match pending.as_state() {
-            None => return ValueKind::Null,
-            Some(state) => match state.as_any_list() {
-                None => return ValueKind::Null,
-                Some(list) => list.len(),
-            },
-        },
-        _ => return ValueKind::Null,
-    };
-
-    ValueKind::Int(len as i64)
-}
-
-#[cfg(test)]
-mod test {
-    use anathema_state::{List, Value};
-
-    use super::*;
-    use crate::functions::test::{list, value};
-
-    #[test]
-    fn list_contains_int() {
-        let haystack = list([1, 2]);
-        let needle = value(2);
-        let args = [haystack, needle];
-        assert!(matches!(contains(&args), ValueKind::Bool(true)));
-    }
-
-    #[test]
-    fn list_contains_list() {
-        let haystack = list([list([1, 2]), list([4, 8])]);
-        let needle = list([4, 8]);
-        let args = [haystack, needle];
-        assert!(matches!(contains(&args), ValueKind::Bool(true)));
-    }
-
-    #[test]
-    fn dyn_list_contains() {
-        let list = Value::new(List::from_iter(0..10));
-        let haystack = ValueKind::DynList(list.reference());
-        let needle = value(0);
-        let args = [haystack, needle];
-        contains(&args);
-        assert!(matches!(contains(&args), ValueKind::Bool(true)));
-    }
-
-    #[test]
-    fn static_string_contains() {
-        let haystack = value("like looking for a needle in a");
-        let needle = value("needle");
-        let args = [haystack, needle];
-        assert!(matches!(contains(&args), ValueKind::Bool(true)));
-    }
-
-    #[test]
-    fn dyn_list_of_lists_contains() {
-        let haystack = List::from_iter(vec![List::from_iter(0..10), List::from_iter(100..110)]);
-        let haystack = Value::new(haystack);
-        let haystack = ValueKind::DynList(haystack.reference());
-        let needle = List::from_iter(100..110);
-        let needle = Value::new(needle);
-        let needle = ValueKind::DynList(needle.reference());
-        let args = [haystack, needle];
-        let result = contains(&args);
-        assert!(matches!(result, ValueKind::Bool(true)));
-    }
-
-    #[test]
-    fn list_len() {
-        let list = value(vec![1, 2, 3]);
-        let args = [list];
-        let result = len(&args);
-        assert!(matches!(result, ValueKind::Int(3)));
-    }
-
-    #[test]
-    fn dyn_list_len() {
-        let list = List::from_iter([1, 2, 3]);
-        let list = Value::new(list);
-        let list = ValueKind::DynList(list.reference());
-        let args = [list];
-        let result = len(&args);
-        assert!(matches!(result, ValueKind::Int(3)));
-    }
-
-    #[test]
-    fn string_len() {
-        let value = value("hello");
-        let args = [value];
-        let result = len(&args);
-        assert!(matches!(result, ValueKind::Int(5)));
-    }
-
-    #[test]
-    fn int_len() {
-        let value = value(123);
-        let args = [value];
-        let result = len(&args);
-        assert!(matches!(result, ValueKind::Null));
-    }
-}
diff --git a/anathema-value-resolver/src/functions/mod.rs b/anathema-value-resolver/src/functions/mod.rs
deleted file mode 100644
index 34c0bbbc..00000000
--- a/anathema-value-resolver/src/functions/mod.rs
+++ /dev/null
@@ -1,106 +0,0 @@
-use std::collections::HashMap;
-use std::fmt::{Debug, Display};
-
-use crate::ValueKind;
-
-mod list;
-mod number;
-mod string;
-
-#[derive(Debug)]
-pub enum Error {
-    FunctionAlreadyRegistered(String),
-}
-
-impl Display for Error {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Error::FunctionAlreadyRegistered(name) => write!(f, "function `{name}` is already registered"),
-        }
-    }
-}
-
-impl std::error::Error for Error {}
-
-pub struct Function {
-    inner: Box<dyn for<'bp> Fn(&[ValueKind<'bp>]) -> ValueKind<'bp>>,
-}
-
-impl Function {
-    pub(crate) fn invoke<'bp>(&self, args: &[ValueKind<'bp>]) -> ValueKind<'bp> {
-        (self.inner)(args)
-    }
-}
-
-impl Debug for Function {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "<fun>")
-    }
-}
-
-impl<T> From<T> for Function
-where
-    T: 'static,
-    T: for<'bp> Fn(&[ValueKind<'bp>]) -> ValueKind<'bp>,
-{
-    fn from(value: T) -> Self {
-        Self { inner: Box::new(value) }
-    }
-}
-
-pub struct FunctionTable {
-    inner: HashMap<String, Function>,
-}
-
-impl FunctionTable {
-    pub fn new() -> Self {
-        let mut inner = HashMap::new();
-        inner.insert("to_upper".into(), Function::from(string::to_upper));
-        inner.insert("to_lower".into(), Function::from(string::to_lower));
-        inner.insert("truncate".into(), Function::from(string::truncate));
-        inner.insert("to_str".into(), Function::from(string::to_str));
-        inner.insert("pad".into(), Function::from(string::pad));
-        inner.insert("width".into(), Function::from(string::width));
-        inner.insert("to_int".into(), Function::from(number::to_int));
-        inner.insert("to_float".into(), Function::from(number::to_float));
-        inner.insert("round".into(), Function::from(number::round));
-        inner.insert("contains".into(), Function::from(list::contains));
-        inner.insert("len".into(), Function::from(list::len));
-        Self { inner }
-    }
-
-    pub fn insert(&mut self, ident: impl Into<String>, f: impl Into<Function>) -> Result<(), Error> {
-        let key = ident.into();
-        if self.inner.contains_key(&key) {
-            return Err(Error::FunctionAlreadyRegistered(key));
-        }
-        self.inner.insert(key, f.into());
-        Ok(())
-    }
-
-    pub fn lookup(&self, ident: &str) -> Option<&Function> {
-        self.inner.get(ident)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use crate::ValueKind;
-
-    pub(crate) fn list<T, U>(items: T) -> ValueKind<'static>
-    where
-        U: Into<ValueKind<'static>>,
-        T: IntoIterator<Item = U>,
-    {
-        let inner = items.into_iter().map(Into::into).collect::<Box<[ValueKind<'_>]>>();
-
-        ValueKind::List(inner)
-    }
-
-    pub(crate) fn value<T>(val: T) -> ValueKind<'static>
-    where
-        T: Into<ValueKind<'static>>,
-    {
-        val.into()
-    }
-}
diff --git a/anathema-value-resolver/src/functions/number.rs b/anathema-value-resolver/src/functions/number.rs
deleted file mode 100644
index 8b30d88d..00000000
--- a/anathema-value-resolver/src/functions/number.rs
+++ /dev/null
@@ -1,127 +0,0 @@
-use crate::ValueKind;
-
-pub(super) fn to_int<'bp>(args: &[ValueKind<'bp>]) -> ValueKind<'bp> {
-    if args.len() != 1 {
-        return ValueKind::Null;
-    }
-
-    match &args[0] {
-        ValueKind::Int(i) => ValueKind::Int(*i),
-        ValueKind::Float(f) => ValueKind::Int(*f as i64),
-        ValueKind::Bool(b) if !b => ValueKind::Int(0),
-        ValueKind::Bool(_) => ValueKind::Int(1),
-        ValueKind::Char(c) => match c.to_digit(10) {
-            Some(i) => ValueKind::Int(i as i64),
-            None => ValueKind::Null,
-        },
-        ValueKind::Hex(hex) => ValueKind::Int(hex.as_u32() as i64),
-        ValueKind::Str(s) => match s.parse() {
-            Ok(i) => ValueKind::Int(i),
-            Err(_) => ValueKind::Null,
-        },
-        ValueKind::Color(_)
-        | ValueKind::Null
-        | ValueKind::Map
-        | ValueKind::Attributes
-        | ValueKind::List(_)
-        | ValueKind::DynList(_)
-        | ValueKind::DynMap(_)
-        | ValueKind::Range(..)
-        | ValueKind::Composite(_) => ValueKind::Null,
-    }
-}
-
-pub(super) fn to_float<'bp>(args: &[ValueKind<'bp>]) -> ValueKind<'bp> {
-    if args.len() != 1 {
-        return ValueKind::Null;
-    }
-
-    match &args[0] {
-        ValueKind::Int(i) => ValueKind::Float(*i as f64),
-        ValueKind::Float(f) => ValueKind::Float(*f),
-        ValueKind::Bool(b) if !b => ValueKind::Float(0.0),
-        ValueKind::Bool(_) => ValueKind::Float(1.0),
-        ValueKind::Char(c) => match c.to_digit(10) {
-            Some(i) => ValueKind::Float(i as f64),
-            None => ValueKind::Null,
-        },
-        ValueKind::Hex(hex) => ValueKind::Float(hex.as_u32() as f64),
-        ValueKind::Str(s) => match s.parse() {
-            Ok(i) => ValueKind::Float(i),
-            Err(_) => ValueKind::Null,
-        },
-        _ => ValueKind::Null,
-    }
-}
-
-pub(super) fn round<'bp>(args: &[ValueKind<'bp>]) -> ValueKind<'bp> {
-    if args.is_empty() || args.len() > 2 {
-        return ValueKind::Null;
-    }
-
-    let precision = match to_int(&args[1..]) {
-        ValueKind::Int(i) => i as usize,
-        _ => 0,
-    };
-
-    match &args[0] {
-        ValueKind::Float(f) => ValueKind::Str(format!("{f:.precision$}").into()),
-        _ => ValueKind::Null,
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::functions::test::value;
-
-    #[test]
-    fn str_to_int() {
-        let arg = value("123");
-        let output = to_int(&[arg]);
-        assert_eq!(ValueKind::Int(123), output);
-
-        let arg = value("not a number");
-        let output = to_int(&[arg]);
-        assert_eq!(ValueKind::Null, output);
-    }
-
-    #[test]
-    fn char_to_int() {
-        let arg = value('4');
-        let output = to_int(&[arg]);
-        assert_eq!(ValueKind::Int(4), output);
-
-        let arg = value('G');
-        let output = to_int(&[arg]);
-        assert_eq!(ValueKind::Null, output);
-    }
-
-    #[test]
-    fn float_to_int() {
-        let arg = value(1.1234);
-        let output = to_int(&[arg]);
-        assert_eq!(ValueKind::Int(1), output);
-    }
-
-    #[test]
-    fn rounding_default_zero() {
-        let args = [value(1.1234)];
-        let output = round(&args);
-        assert_eq!(value("1"), output);
-    }
-
-    #[test]
-    fn rounding_with_arg() {
-        let args = [value(1.1234), value(2)];
-        let output = round(&args);
-        assert_eq!(value("1.12"), output);
-    }
-
-    #[test]
-    fn invalid_rounding() {
-        let args = [value("1.1234"), value(2)];
-        let output = round(&args);
-        assert_eq!(ValueKind::Null, output);
-    }
-}
diff --git a/anathema-value-resolver/src/functions/string.rs b/anathema-value-resolver/src/functions/string.rs
deleted file mode 100644
index 908b2e44..00000000
--- a/anathema-value-resolver/src/functions/string.rs
+++ /dev/null
@@ -1,218 +0,0 @@
-use unicode_width::{UnicodeWidthChar, UnicodeWidthStr};
-
-use crate::ValueKind;
-
-pub(super) fn to_upper<'bp>(args: &[ValueKind<'bp>]) -> ValueKind<'bp> {
-    if args.len() != 1 {
-        return ValueKind::Null;
-    }
-
-    let mut buffer = String::new();
-    args[0].strings(|s| {
-        buffer.push_str(&s.to_uppercase());
-        true
-    });
-
-    ValueKind::Str(buffer.into())
-}
-
-pub(super) fn to_lower<'bp>(args: &[ValueKind<'bp>]) -> ValueKind<'bp> {
-    if args.len() != 1 {
-        return ValueKind::Null;
-    }
-
-    let mut buffer = String::new();
-    args[0].strings(|s| {
-        buffer.push_str(&s.to_lowercase());
-        true
-    });
-
-    ValueKind::Str(buffer.into())
-}
-
-pub(super) fn to_str<'bp>(args: &[ValueKind<'bp>]) -> ValueKind<'bp> {
-    if args.len() != 1 {
-        return ValueKind::Null;
-    }
-    let mut buffer = String::new();
-    args[0].strings(|s| {
-        buffer.push_str(s);
-        true
-    });
-    ValueKind::Str(buffer.into())
-}
-
-pub(super) fn truncate<'bp>(args: &[ValueKind<'bp>]) -> ValueKind<'bp> {
-    if args.len() != 2 {
-        return ValueKind::Null;
-    }
-
-    let Some(mut remainder) = args[1].as_int() else { return ValueKind::Null };
-
-    let mut buffer = String::new();
-    args[0].strings(|s| {
-        let width = s.width() as i64;
-
-        if width < remainder {
-            remainder = remainder.saturating_sub(width);
-            buffer.push_str(s);
-        } else {
-            let mut chars = s.chars();
-            while remainder > 0 {
-                let Some(c) = chars.next() else { break };
-                let width = c.width().unwrap_or(0) as i64;
-                if width > remainder {
-                    break;
-                };
-                buffer.push(c);
-                remainder = remainder.saturating_sub(width);
-            }
-        }
-        true
-    });
-    ValueKind::Str(buffer.into())
-}
-
-pub(super) fn pad<'bp>(args: &[ValueKind<'bp>]) -> ValueKind<'bp> {
-    if args.len() != 2 {
-        return ValueKind::Null;
-    }
-
-    let Some(width) = args[1].as_int() else { return ValueKind::Null };
-    if width < 0 {
-        return ValueKind::Null;
-    }
-    let width = width as usize;
-
-    let mut buffer = String::new();
-    args[0].strings(|s| {
-        buffer.push_str(s);
-        true
-    });
-
-    while width > buffer.width() {
-        buffer.push(' ');
-    }
-
-    ValueKind::Str(buffer.into())
-}
-
-pub(super) fn width<'bp>(args: &[ValueKind<'bp>]) -> ValueKind<'bp> {
-    if args.len() != 1 {
-        return ValueKind::Null;
-    }
-
-    let mut width = 0;
-
-    args[0].strings(|s| {
-        width += s.width();
-        true
-    });
-
-    ValueKind::Int(width as i64)
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::functions::test::{list, value};
-
-    fn to_string(value: ValueKind<'_>) -> String {
-        let ValueKind::Str(s) = to_str(&[value]) else { panic!() };
-        s.to_string()
-    }
-
-    #[test]
-    fn string_to_upper() {
-        let val = value("hello");
-        let val = to_upper(&[val]);
-        let val = to_string(val);
-        assert_eq!(val, "HELLO");
-    }
-
-    #[test]
-    fn string_to_lower() {
-        let val = value("HELLO");
-        let val = to_lower(&[val]);
-        let val = to_string(val);
-        assert_eq!(val, "hello");
-    }
-
-    #[test]
-    fn int_to_string() {
-        let val = value(123);
-        let val = to_str(&[val]);
-        assert_eq!(val, value("123"));
-    }
-
-    #[test]
-    fn bool_to_string() {
-        let val = value(true);
-        let val = to_str(&[val]);
-        assert_eq!(val, value("true"));
-    }
-
-    #[test]
-    fn list_to_string() {
-        let val = list([1, 2, 3]);
-        let val = to_str(&[val]);
-        assert_eq!(val, value("123"));
-    }
-
-    #[test]
-    fn truncate_long_string() {
-        let val = value("this is a longer string");
-        let val = truncate(&[val, value(4)]);
-        assert_eq!(val, value("this"));
-    }
-
-    #[test]
-    fn truncate_short_string() {
-        let val = value("hi");
-        let val = truncate(&[val, value(4)]);
-        assert_eq!(val, value("hi"));
-    }
-
-    #[test]
-    fn truncate_wide_cells() {
-        let val = value("🐇🐇");
-        let val = truncate(&[val, value(3)]);
-        assert_eq!(val, value("🐇"));
-    }
-
-    #[test]
-    fn pad_string() {
-        let val = value("hi");
-        let val = pad(&[val, value(3)]);
-        assert_eq!(val, value("hi "));
-
-        let val = value("bye");
-        let val = pad(&[val, value(3)]);
-        assert_eq!(val, value("bye"));
-
-        let val = value("hello");
-        let val = pad(&[val, value(3)]);
-        assert_eq!(val, value("hello"));
-    }
-
-    #[test]
-    fn pad_non_string() {
-        let val = value(1);
-        let val = pad(&[val, value(3)]);
-        assert_eq!(val, value("1  "));
-    }
-
-    #[test]
-    fn width_of_string() {
-        let val = value("one");
-        let val = width(&[val]);
-        assert_eq!(val, value(3));
-    }
-
-    #[test]
-    fn width_of_int() {
-        let val = value(1);
-        let val = width(&[val]);
-        assert_eq!(val, value(1));
-    }
-}
diff --git a/anathema-value-resolver/src/immediate.rs b/anathema-value-resolver/src/immediate.rs
deleted file mode 100644
index fb25d450..00000000
--- a/anathema-value-resolver/src/immediate.rs
+++ /dev/null
@@ -1,109 +0,0 @@
-use anathema_templates::Expression;
-
-use crate::context::ResolverCtx;
-use crate::expression::{Kind, ValueExpr};
-
-pub struct Resolver<'a, 'frame, 'bp> {
-    ctx: &'a ResolverCtx<'frame, 'bp>,
-}
-
-impl<'a, 'frame, 'bp> Resolver<'a, 'frame, 'bp> {
-    pub fn new(ctx: &'a ResolverCtx<'frame, 'bp>) -> Self {
-        Self { ctx }
-    }
-
-    fn lookup(&self, ident: &str) -> ValueExpr<'bp> {
-        match ident {
-            "state" => {
-                let Some(state_id) = self.ctx.scope.get_state() else { return ValueExpr::Null };
-                let Some(state) = self.ctx.states.get(state_id) else { return ValueExpr::Null };
-                let value = state.reference();
-                value.into()
-            }
-            "attributes" => {
-                // TODO: unwrap? Why is this okay?
-                let component = self.ctx.scope.get_attributes().unwrap();
-                ValueExpr::Attributes(component)
-            }
-            ident => match self.ctx.scope.lookup(ident) {
-                Some(value) => value,
-                None => {
-                    let Some(expr) = self.ctx.variables.global_lookup(ident) else { return ValueExpr::Null };
-                    self.resolve(expr)
-                }
-            },
-        }
-    }
-
-    pub(crate) fn resolve(&self, expr: &'bp Expression) -> ValueExpr<'bp> {
-        match expr {
-            Expression::Primitive(primitive) => ValueExpr::from(*primitive),
-            Expression::Variable(var) => match self.ctx.variables.load(*var) {
-                Some(expr) => self.resolve(expr),
-                None => ValueExpr::Null,
-            },
-            Expression::Str(s) => ValueExpr::Str(Kind::Static(s)),
-            Expression::List(vec) => ValueExpr::List(vec.iter().map(|e| self.resolve(e)).collect()),
-            Expression::Map(map) => ValueExpr::Map(map.iter().map(|(k, e)| (k.as_str(), self.resolve(e))).collect()),
-            Expression::TextSegments(vec) => ValueExpr::List(vec.iter().map(|e| self.resolve(e)).collect()),
-            Expression::Not(expr) => ValueExpr::Not(self.resolve(expr).into()),
-            Expression::Negative(expr) => ValueExpr::Negative(self.resolve(expr).into()),
-            Expression::Equality(lhs, rhs, equality) => {
-                let lhs = self.resolve(lhs);
-                let rhs = self.resolve(rhs);
-                ValueExpr::Equality(lhs.into(), rhs.into(), *equality)
-            }
-            Expression::LogicalOp(lhs, rhs, op) => {
-                let lhs = self.resolve(lhs).into();
-                let rhs = self.resolve(rhs).into();
-                ValueExpr::LogicalOp(lhs, rhs, *op)
-            }
-            Expression::Op(lhs, rhs, op) => {
-                let lhs = self.resolve(lhs).into();
-                let rhs = self.resolve(rhs).into();
-                ValueExpr::Op(lhs, rhs, *op)
-            }
-            Expression::Either(first, second) => {
-                ValueExpr::Either(self.resolve(first).into(), self.resolve(second).into())
-            }
-            Expression::Ident(ident) => self.lookup(ident),
-            Expression::Index(source, index) => {
-                let source = self.resolve(source);
-                let index = self.resolve(index);
-                ValueExpr::Index(source.into(), index.into())
-            }
-            Expression::Range(from, to) => {
-                let from = self.resolve(from);
-                let to = self.resolve(to);
-                ValueExpr::Range(from.into(), to.into())
-            }
-            Expression::Call { fun, args } => {
-                match &**fun {
-                    // function(args)
-                    Expression::Ident(fun) => match self.ctx.lookup_function(fun) {
-                        Some(fun_ptr) => {
-                            let args = args.iter().map(|arg| self.resolve(arg)).collect::<Box<_>>();
-                            ValueExpr::Call { fun_ptr, args }
-                        }
-                        None => ValueExpr::Null,
-                    },
-                    // some.value.function(args)
-                    Expression::Index(lhs, rhs) => {
-                        let first_arg = self.resolve(lhs);
-                        let Expression::Str(fun) = &**rhs else { return ValueExpr::Null };
-                        match self.ctx.lookup_function(fun) {
-                            Some(fun_ptr) => {
-                                let args = std::iter::once(first_arg)
-                                    .chain(args.iter().map(|arg| self.resolve(arg)))
-                                    .collect::<Box<_>>();
-                                ValueExpr::Call { fun_ptr, args }
-                            }
-                            None => ValueExpr::Null,
-                        }
-                    }
-                    _ => ValueExpr::Null,
-                }
-            }
-        }
-    }
-}
diff --git a/anathema-value-resolver/src/lib.rs b/anathema-value-resolver/src/lib.rs
deleted file mode 100644
index acdee1a2..00000000
--- a/anathema-value-resolver/src/lib.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-pub use crate::attributes::{AttributeStorage, Attributes, ValueKey};
-pub use crate::context::ResolverCtx;
-pub use crate::functions::{Error, Function, FunctionTable};
-pub use crate::scope::Scope;
-pub use crate::value::{Collection, Value, ValueKind, resolve, resolve_collection};
-
-mod attributes;
-mod context;
-mod expression;
-mod functions;
-mod immediate;
-mod scope;
-mod value;
-
-#[cfg(test)]
-pub(crate) mod testing;
diff --git a/anathema-value-resolver/src/scope.rs b/anathema-value-resolver/src/scope.rs
deleted file mode 100644
index 1f4db87c..00000000
--- a/anathema-value-resolver/src/scope.rs
+++ /dev/null
@@ -1,158 +0,0 @@
-use anathema_state::{PendingValue, StateId};
-use anathema_store::slab::Key;
-
-use crate::expression::{Kind, ValueExpr};
-use crate::{Collection, Value, ValueKind};
-
-#[derive(Debug)]
-pub(crate) enum Entry<'parent, 'bp> {
-    Component { state: StateId, component_attributes: Key },
-    Collection(&'parent Collection<'bp>),
-    Index(&'bp str, usize, PendingValue),
-    WithValue(&'bp str, &'parent Value<'bp>),
-    Empty,
-}
-
-#[derive(Debug)]
-pub struct Scope<'parent, 'bp> {
-    outer: Option<&'parent Scope<'parent, 'bp>>,
-    parent: Option<&'parent Scope<'parent, 'bp>>,
-    value: Entry<'parent, 'bp>,
-}
-
-impl<'parent, 'bp> Scope<'parent, 'bp> {
-    fn new(value: Entry<'parent, 'bp>) -> Self {
-        Self {
-            parent: None,
-            outer: None,
-            value,
-        }
-    }
-
-    pub fn with_component(state: StateId, attributes: Key, outer: Option<&'parent Scope<'parent, 'bp>>) -> Self {
-        Self {
-            outer,
-            parent: None,
-            value: Entry::Component {
-                state,
-                component_attributes: attributes,
-            },
-        }
-    }
-
-    pub fn with_collection(collection: &'parent Collection<'bp>, parent: &'parent Scope<'parent, 'bp>) -> Self {
-        let value = Entry::Collection(collection);
-        Self {
-            outer: None,
-            parent: Some(parent),
-            value,
-        }
-    }
-
-    pub fn with_index(
-        binding: &'bp str,
-        index: usize,
-        parent: &'parent Scope<'parent, 'bp>,
-        loop_index: PendingValue,
-    ) -> Self {
-        let value = Entry::Index(binding, index, loop_index);
-        Self {
-            value,
-            parent: Some(parent),
-            outer: None,
-        }
-    }
-
-    pub fn with_value(binding: &'bp str, value: &'parent Value<'bp>, parent: &'parent Scope<'parent, 'bp>) -> Self {
-        let value = Entry::WithValue(binding, value);
-        Self {
-            outer: None,
-            parent: Some(parent),
-            value,
-        }
-    }
-
-    pub fn root() -> Self {
-        Self::empty()
-    }
-
-    pub fn empty() -> Self {
-        Self::new(Entry::Empty)
-    }
-
-    pub(crate) fn get_state(&self) -> Option<StateId> {
-        match &self.value {
-            Entry::Component { state, .. } => Some(*state),
-            _ => self.parent?.get_state(),
-        }
-    }
-
-    pub(crate) fn get_attributes(&self) -> Option<Key> {
-        match &self.value {
-            Entry::Component {
-                component_attributes, ..
-            } => Some(*component_attributes),
-            _ => self.parent?.get_attributes(),
-        }
-    }
-
-    pub(crate) fn lookup(&self, key: &str) -> Option<ValueExpr<'bp>> {
-        match self.value {
-            Entry::WithValue(ident, val) if ident == key => Some(val.expr.clone()),
-            Entry::Index(_, _, loop_index) if key == "loop" => Some(ValueExpr::Int(Kind::Dyn(loop_index))),
-            Entry::Index(binding, index, _) if key == binding => {
-                match self.parent.expect("the parent can only be a collection").value {
-                    Entry::Collection(collection) => match &collection.0.kind {
-                        ValueKind::List(_) => {
-                            let value_expr = ValueExpr::Index(
-                                collection.0.expr.clone().into(),
-                                ValueExpr::Int(Kind::Static(index as i64)).into(),
-                            );
-                            Some(value_expr)
-                        }
-                        ValueKind::DynList(value) => {
-                            let state = value.as_state()?;
-                            let list = state.as_any_list()?;
-                            let value = list.lookup(index)?;
-                            Some(value.into())
-                        }
-                        &ValueKind::Range(from, to) => (from..to)
-                            .skip(index)
-                            .map(|num| ValueExpr::Int(Kind::Static(num as i64)))
-                            .next(),
-                        _ => unreachable!("none of the other values can be a collection"),
-                    },
-                    _ => unreachable!("the parent scope is always a collection"),
-                }
-            }
-            _ => self.parent?.lookup(key),
-        }
-    }
-
-    /// Get the outer scope
-    ///
-    /// # Panics
-    ///
-    /// This will panic if the outer scope has been set incorrectly
-    /// or there is no parent scope.
-    pub fn outer(&self) -> &'parent Scope<'parent, 'bp> {
-        match self.outer {
-            Some(scope) => scope,
-            None => match self.parent {
-                Some(parent) => parent.outer(),
-                None => panic!("no outer scope, no parent"),
-            },
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-
-    #[test]
-    fn scope_one() {
-        // let mut scope = Scope::new();
-        // panic!();
-        // scope.scope("key",
-    }
-}
diff --git a/anathema-value-resolver/src/testing.rs b/anathema-value-resolver/src/testing.rs
deleted file mode 100644
index 56f75926..00000000
--- a/anathema-value-resolver/src/testing.rs
+++ /dev/null
@@ -1,121 +0,0 @@
-use anathema_state::{AnyMap, List, Map, Maybe, State, StateId, States, Subscriber, Value};
-use anathema_store::slab::Key;
-use anathema_templates::{Expression, Variables};
-
-use super::*;
-use crate::context::ResolverCtx;
-use crate::scope::Scope;
-
-#[derive(Debug)]
-pub(crate) struct TestState {
-    pub(crate) string: Value<&'static str>,
-    pub(crate) num: Value<i32>,
-    pub(crate) num_2: Value<i32>,
-    pub(crate) float: Value<f64>,
-    pub(crate) list: Value<List<&'static str>>,
-    pub(crate) map: Value<Map<i32>>,
-    pub(crate) opt_map: Value<Maybe<Map<i32>>>,
-}
-
-impl TestState {
-    pub fn new() -> Self {
-        Self {
-            string: "".into(),
-            num: 0.into(),
-            num_2: 0.into(),
-            float: 0.0.into(),
-            list: List::empty().into(),
-            map: Map::empty().into(),
-            opt_map: Value::new(Maybe::none()),
-        }
-    }
-}
-
-impl State for TestState {
-    fn type_info(&self) -> anathema_state::Type {
-        anathema_state::Type::Composite
-    }
-
-    fn as_any_map(&self) -> Option<&dyn AnyMap> {
-        Some(self)
-    }
-}
-
-impl AnyMap for TestState {
-    fn lookup(&self, key: &str) -> Option<anathema_state::PendingValue> {
-        match key {
-            "list" => self.list.reference().into(),
-            "num" => self.num.reference().into(),
-            "num_2" => self.num_2.reference().into(),
-            "float" => self.float.reference().into(),
-            "string" => self.string.reference().into(),
-            "map" => self.map.reference().into(),
-            "opt_map" => self.opt_map.reference().into(),
-            _ => None,
-        }
-    }
-
-    fn is_empty(&self) -> bool {
-        false
-    }
-}
-
-pub(crate) struct TestCase<'a, 'bp> {
-    variables: &'static Variables,
-    states: &'a mut States,
-    pub attributes: AttributeStorage<'bp>,
-    function_table: &'static FunctionTable,
-}
-
-impl<'a, 'bp> TestCase<'a, 'bp> {
-    pub fn new(states: &'a mut States, variables: Variables) -> Self {
-        let mut attributes = AttributeStorage::empty();
-        attributes.insert(Key::ZERO, Attributes::empty());
-
-        Self {
-            variables: Box::leak(variables.into()),
-            states,
-            attributes,
-            function_table: Box::leak(FunctionTable::new().into()),
-        }
-    }
-
-    pub(crate) fn eval(&self, expr: &'bp Expression) -> crate::value::Value<'bp> {
-        let state_id = StateId::ZERO;
-        let scope = Scope::with_component(state_id, Key::ZERO, None);
-        let ctx = ResolverCtx::new(
-            self.variables,
-            &scope,
-            self.states,
-            &self.attributes,
-            self.function_table,
-        );
-        resolve(expr, &ctx, Subscriber::ZERO)
-    }
-
-    pub fn set_attribute(&mut self, key: &'bp str, expr: &'bp Expression) {
-        let scope = Scope::with_component(StateId::ZERO, Key::ZERO, None);
-        self.attributes.with_mut(Key::ZERO, |attributes, storage| {
-            let ctx = ResolverCtx::new(self.variables, &scope, self.states, storage, self.function_table);
-            attributes.insert_with(ValueKey::Attribute(key), |_index| resolve(expr, &ctx, Subscriber::ZERO));
-        });
-    }
-
-    pub(crate) fn with_state<F, U>(&mut self, f: F) -> U
-    where
-        F: FnOnce(&mut TestState) -> U,
-    {
-        let state = self.states.get_mut(StateId::ZERO).unwrap();
-        let mut state = state.to_mut_cast::<TestState>();
-        f(&mut state)
-    }
-}
-
-pub(crate) fn setup<'bp, F>(states: &mut States, variables: Variables, mut f: F)
-where
-    F: FnMut(&mut TestCase<'_, 'bp>),
-{
-    states.insert(Box::new(TestState::new()));
-    let mut test = TestCase::new(states, variables);
-    f(&mut test)
-}
diff --git a/anathema-value-resolver/src/value.rs b/anathema-value-resolver/src/value.rs
deleted file mode 100644
index abe26af3..00000000
--- a/anathema-value-resolver/src/value.rs
+++ /dev/null
@@ -1,1087 +0,0 @@
-use std::borrow::Cow;
-use std::ops::{Deref, DerefMut};
-
-use anathema_state::{Color, Hex, PendingValue, SubTo, Subscriber, Type};
-use anathema_store::smallmap::SmallMap;
-use anathema_templates::Expression;
-
-use crate::attributes::ValueKey;
-use crate::expression::{ResolvedState, ValueExpr, ValueResolutionContext, resolve_value};
-use crate::immediate::Resolver;
-use crate::{AttributeStorage, ResolverCtx};
-
-pub type Values<'bp> = SmallMap<ValueKey<'bp>, Value<'bp>>;
-
-pub fn resolve<'bp>(expr: &'bp Expression, ctx: &ResolverCtx<'_, 'bp>, sub: impl Into<Subscriber>) -> Value<'bp> {
-    let resolver = Resolver::new(ctx);
-    let value_expr = resolver.resolve(expr);
-    Value::resolve(value_expr, sub.into(), ctx.attribute_storage)
-}
-
-pub fn resolve_collection<'bp>(
-    expr: &'bp Expression,
-    ctx: &ResolverCtx<'_, 'bp>,
-    sub: impl Into<Subscriber>,
-) -> Collection<'bp> {
-    let value = resolve(expr, ctx, sub);
-    Collection(value)
-}
-
-#[derive(Debug)]
-pub struct Collection<'bp>(pub(crate) Value<'bp>);
-
-impl<'bp> Collection<'bp> {
-    pub fn reload(&mut self, attributes: &AttributeStorage<'bp>) {
-        self.0.reload(attributes)
-    }
-
-    pub fn len(&self) -> usize {
-        match &self.0.kind {
-            ValueKind::List(vec) => vec.len(),
-            ValueKind::DynList(value) => {
-                let Some(state) = value.as_state() else { return 0 };
-                let Some(list) = state.as_any_list() else { return 0 };
-                list.len()
-            }
-            ValueKind::Range(from, to) => *to - *from,
-            ValueKind::Int(_)
-            | ValueKind::Float(_)
-            | ValueKind::Bool(_)
-            | ValueKind::Char(_)
-            | ValueKind::Hex(_)
-            | ValueKind::Color(_)
-            | ValueKind::Str(_)
-            | ValueKind::DynMap(_)
-            | ValueKind::Map
-            | ValueKind::Composite(_)
-            | ValueKind::Attributes
-            | ValueKind::Null => 0,
-        }
-    }
-}
-
-/// This is the final value for a node attribute / value.
-/// This should be evaluated fully for the `ValueKind`
-#[derive(Debug)]
-pub struct Value<'bp> {
-    pub(crate) expr: ValueExpr<'bp>,
-    pub(crate) sub: Subscriber,
-    pub(crate) kind: ValueKind<'bp>,
-    pub(crate) resolved: ResolvedState,
-    sub_keys: SubTo,
-}
-
-impl<'bp> Value<'bp> {
-    pub(crate) fn static_val(value: impl Into<ValueKind<'bp>>) -> Self {
-        Self {
-            expr: ValueExpr::Null,
-            kind: value.into(),
-            sub: anathema_state::Subscriber::MAX,
-            resolved: ResolvedState::Resolved,
-            sub_keys: SubTo::empty(),
-        }
-    }
-
-    pub fn resolve(expr: ValueExpr<'bp>, sub: Subscriber, attribute_storage: &AttributeStorage<'bp>) -> Self {
-        let mut ctx = ValueResolutionContext::new(attribute_storage, sub, ResolvedState::Unresolved);
-        let kind = resolve_value(&expr, &mut ctx);
-
-        // NOTE
-        // This is a special edge case where the map or state is used
-        // as a final value `Option<ValueKind>`.
-        //
-        // This would only hold value in an if-statement:
-        // ```
-        // if state.opt_map
-        //     text "show this if there is a map"
-        // ```
-        match kind {
-            ValueKind::DynMap(pending) | ValueKind::Composite(pending) => {
-                ctx.force_sub(&pending);
-            }
-            _ => {}
-        }
-
-        ctx.done();
-        Self {
-            expr,
-            sub,
-            kind,
-            resolved: ctx.resolved_state,
-            sub_keys: ctx.sub_keys,
-        }
-    }
-
-    /// ```text
-    /// None         = false
-    /// 0            = false
-    /// Some("")     = false
-    /// Some(0)      = false
-    /// []           = false
-    /// {}           = false
-    /// Some(bool)   = bool
-    /// _            = true
-    /// ```
-    pub fn truthiness(&self) -> bool {
-        self.kind.truthiness()
-    }
-
-    #[doc(hidden)]
-    pub fn kind(&self) -> &ValueKind<'_> {
-        &self.kind
-    }
-
-    pub fn reload(&mut self, attribute_storage: &AttributeStorage<'bp>) {
-        #[cfg(feature = "profile")]
-        puffin::profile_function!();
-
-        let mut ctx = ValueResolutionContext::new(attribute_storage, self.sub, self.resolved);
-        let kind = resolve_value(&self.expr, &mut ctx);
-        ctx.done();
-        self.sub_keys.merge(ctx.sub_keys);
-        self.kind = kind;
-        self.resolved = ctx.resolved_state;
-    }
-
-    pub fn try_as<T>(&self) -> Option<T>
-    where
-        T: for<'a> TryFrom<&'a ValueKind<'a>>,
-    {
-        (&self.kind).try_into().ok()
-    }
-
-    pub fn strings<F>(&self, mut f: F)
-    where
-        F: FnMut(&str) -> bool,
-    {
-        self.kind.strings(&mut f);
-    }
-}
-
-impl Drop for Value<'_> {
-    fn drop(&mut self) {
-        self.sub_keys.unsubscribe(self.sub);
-    }
-}
-
-impl<'a> Deref for Value<'a> {
-    type Target = ValueKind<'a>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.kind
-    }
-}
-
-impl<'a> DerefMut for Value<'a> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.kind
-    }
-}
-
-/// This value can never be part of an evaluation chain, only the return value.
-/// It should only ever be the final type that is held by a `Value`, at
-/// the end of an evaluation
-#[derive(Debug, PartialEq, PartialOrd, Clone)]
-pub enum ValueKind<'bp> {
-    Int(i64),
-    Float(f64),
-    Bool(bool),
-    Char(char),
-    Hex(Hex),
-    Color(Color),
-    Str(Cow<'bp, str>),
-    Null,
-
-    // NOTE
-    // The map is the final value, and is never used as part
-    // of an index, for that reason the map doesn't hold any values.
-    Map,
-    // NOTE
-    // The attributes is the final value, and is never used as part
-    // of an index, for that reason the attributes doesn't hold any values.
-    Attributes,
-    List(Box<[ValueKind<'bp>]>),
-    DynList(PendingValue),
-    DynMap(PendingValue),
-    Composite(PendingValue),
-    Range(usize, usize),
-}
-
-impl ValueKind<'_> {
-    pub fn to_int(&self) -> Option<i64> {
-        match self.as_int() {
-            Some(val) => Some(val),
-            None => Some(self.as_float()? as i64),
-        }
-    }
-
-    pub fn as_int(&self) -> Option<i64> {
-        let ValueKind::Int(i) = self else { return None };
-        Some(*i)
-    }
-
-    pub fn as_float(&self) -> Option<f64> {
-        let ValueKind::Float(i) = self else { return None };
-        Some(*i)
-    }
-
-    pub fn as_bool(&self) -> Option<bool> {
-        let ValueKind::Bool(b) = self else { return None };
-        Some(*b)
-    }
-
-    pub fn as_char(&self) -> Option<char> {
-        let ValueKind::Char(i) = self else { return None };
-        Some(*i)
-    }
-
-    pub fn as_hex(&self) -> Option<Hex> {
-        let ValueKind::Hex(i) = self else { return None };
-        Some(*i)
-    }
-
-    pub fn as_color(&self) -> Option<Color> {
-        let ValueKind::Color(i) = self else { return None };
-        Some(*i)
-    }
-
-    pub fn as_str(&self) -> Option<&str> {
-        let ValueKind::Str(i) = &self else { return None };
-        Some(i)
-    }
-
-    pub fn as_list(&self) -> Option<&[Self]> {
-        let ValueKind::List(list) = &self else { return None };
-        Some(list)
-    }
-
-    pub fn is_null(&self) -> bool {
-        matches!(self, ValueKind::Null)
-    }
-
-    pub fn strings<F>(&self, mut f: F)
-    where
-        F: FnMut(&str) -> bool,
-    {
-        self.internal_strings(&mut f);
-    }
-
-    fn internal_strings<F>(&self, f: &mut F) -> bool
-    where
-        F: FnMut(&str) -> bool,
-    {
-        match self {
-            ValueKind::Int(n) => f(&n.to_string()),
-            ValueKind::Float(n) => f(&n.to_string()),
-            ValueKind::Bool(b) => f(&b.to_string()),
-            ValueKind::Char(c) => f(&c.to_string()),
-            ValueKind::Hex(x) => f(&x.to_string()),
-            ValueKind::Color(col) => f(&col.to_string()),
-            ValueKind::Str(cow) => f(cow.as_ref()),
-            ValueKind::List(vec) => vec.iter().take_while(|val| val.internal_strings(f)).count() == vec.len(),
-            ValueKind::DynList(value) => dyn_string(*value, f),
-            ValueKind::Range(from, to) => f(&format!("{from}..{to}")),
-            ValueKind::DynMap(_) => f("<dyn map>"),
-            ValueKind::Map => f("<map>"),
-            ValueKind::Composite(_) => f("<composite>"),
-            ValueKind::Attributes => f("<attributes>"),
-            ValueKind::Null => true,
-        }
-    }
-
-    pub(crate) fn truthiness(&self) -> bool {
-        match self {
-            ValueKind::Int(0) | ValueKind::Float(0.0) | ValueKind::Bool(false) => false,
-            ValueKind::Str(cow) if cow.is_empty() => false,
-            ValueKind::Null => false,
-            ValueKind::List(list) if list.is_empty() => false,
-            ValueKind::DynList(list) => {
-                let Some(state) = list.as_state() else { return false };
-                let Some(state) = state.as_any_list() else { return false };
-                !state.is_empty()
-            }
-            ValueKind::DynMap(map) => {
-                let Some(state) = map.as_state() else { return false };
-                let Some(state) = state.as_any_map() else { return false };
-                !state.is_empty()
-            }
-            _ => true,
-        }
-    }
-
-    pub(crate) fn value_eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (ValueKind::Int(lhs), ValueKind::Int(rhs)) => lhs == rhs,
-            (ValueKind::Float(lhs), ValueKind::Float(rhs)) => lhs == rhs,
-            (ValueKind::Bool(lhs), ValueKind::Bool(rhs)) => lhs == rhs,
-            (ValueKind::Char(lhs), ValueKind::Char(rhs)) => lhs == rhs,
-            (ValueKind::Hex(lhs), ValueKind::Hex(rhs)) => lhs == rhs,
-            (ValueKind::Color(lhs), ValueKind::Color(rhs)) => lhs == rhs,
-            (ValueKind::Str(lhs), ValueKind::Str(rhs)) => lhs == rhs,
-            (ValueKind::Null, ValueKind::Null) => true,
-            (ValueKind::Attributes, ValueKind::Attributes) => true,
-            (ValueKind::List(lhs), ValueKind::List(rhs)) => lhs == rhs,
-            (ValueKind::DynList(lhs), ValueKind::DynList(rhs)) => lhs.pending_eq(*rhs),
-            (ValueKind::DynList(lhs), ValueKind::List(rhs)) => dyn_static_eq(*lhs, rhs),
-            (ValueKind::List(lhs), ValueKind::DynList(rhs)) => dyn_static_eq(*rhs, lhs),
-            (ValueKind::DynMap(lhs), ValueKind::DynMap(rhs)) => lhs.pending_eq(*rhs),
-            (ValueKind::Composite(lhs), ValueKind::Composite(rhs)) => lhs.pending_eq(*rhs),
-            _ => false,
-        }
-    }
-
-    pub(crate) fn compare_pending(&self, pending: PendingValue) -> bool {
-        let type_info = pending.type_info();
-        let Some(rhs) = pending.as_state() else { return false };
-
-        match type_info {
-            Type::Int => compare_owned(self.as_int(), rhs.as_int()),
-            Type::Float => compare_owned(self.as_float(), rhs.as_float()),
-            Type::Char => compare_owned(self.as_char(), rhs.as_char()),
-            Type::Bool => compare_owned(self.as_bool(), rhs.as_bool()),
-            Type::Hex => compare_owned(self.as_hex(), rhs.as_hex()),
-            Type::Color => compare_owned(self.as_color(), rhs.as_color()),
-            Type::String => compare_owned(self.as_str(), rhs.as_str()),
-            Type::Map => false,
-            Type::List => match self {
-                ValueKind::List(rhs) => dyn_static_eq(pending, rhs),
-                ValueKind::DynList(rhs) => rhs.pending_eq(pending),
-                _ => false,
-            },
-            Type::Composite => match self {
-                ValueKind::Composite(pending_value) => pending.pending_eq(*pending_value),
-                _ => false,
-            },
-            Type::Unit => self.is_null(),
-            Type::Maybe => unreachable!("ValueKind can never be a Maybe as it's the final value"),
-        }
-    }
-}
-
-fn compare_owned<T: PartialEq>(lhs: Option<T>, rhs: Option<T>) -> bool {
-    lhs.is_some() && lhs == rhs
-}
-
-fn dyn_static_eq(pending: PendingValue, val_kind: &[ValueKind<'_>]) -> bool {
-    let Some(state) = pending.as_state() else { return false };
-    let Some(lhs) = state.as_any_list() else { return false };
-
-    if lhs.len() != val_kind.len() {
-        return false;
-    }
-
-    for (lhs, rhs) in lhs.iter().zip(val_kind) {
-        if !rhs.compare_pending(lhs) {
-            return false;
-        }
-    }
-
-    true
-}
-
-fn dyn_string<F>(value: PendingValue, f: &mut F) -> bool
-where
-    F: FnMut(&str) -> bool,
-{
-    let Some(state) = value.as_state() else { return true };
-    let Some(list) = state.as_any_list() else { return true };
-    for i in 0..list.len() {
-        let value = list.lookup(i).expect("the value exists");
-        let Some(state) = value.as_state() else { continue };
-        let should_continue = match value.type_info() {
-            Type::Int => f(&state.as_int().expect("type info dictates this").to_string()),
-            Type::Float => f(&state.as_float().expect("type info dictates this").to_string()),
-            Type::Char => f(&state.as_char().expect("type info dictates this").to_string()),
-            Type::String => f(state.as_str().expect("type info dictates this")),
-            Type::Bool => f(&state.as_bool().expect("type info dictates this").to_string()),
-            Type::Hex => f(&state.as_hex().expect("type info dictates this").to_string()),
-            Type::Map => f("<map>"),
-            Type::List => dyn_string(value, f),
-            Type::Composite => f(&state.as_hex().expect("type info dictates this").to_string()),
-            Type::Unit => f(""),
-            Type::Color => f(&state.as_color().expect("type info dictates this").to_string()),
-            Type::Maybe => panic!(),
-        };
-
-        if !should_continue {
-            return false;
-        }
-    }
-    true
-}
-
-// -----------------------------------------------------------------------------
-//   - From impls -
-// -----------------------------------------------------------------------------
-macro_rules! from_int {
-    ($int:ty) => {
-        impl From<$int> for ValueKind<'_> {
-            fn from(value: $int) -> Self {
-                ValueKind::Int(value as i64)
-            }
-        }
-    };
-}
-
-from_int!(i64);
-from_int!(i32);
-from_int!(i16);
-from_int!(i8);
-from_int!(u64);
-from_int!(u32);
-from_int!(u16);
-from_int!(u8);
-
-impl From<f64> for ValueKind<'_> {
-    fn from(value: f64) -> Self {
-        ValueKind::Float(value)
-    }
-}
-
-impl From<f32> for ValueKind<'_> {
-    fn from(value: f32) -> Self {
-        ValueKind::Float(value as f64)
-    }
-}
-
-impl From<bool> for ValueKind<'_> {
-    fn from(value: bool) -> Self {
-        ValueKind::Bool(value)
-    }
-}
-
-impl From<char> for ValueKind<'_> {
-    fn from(value: char) -> Self {
-        ValueKind::Char(value)
-    }
-}
-
-impl From<Hex> for ValueKind<'_> {
-    fn from(value: Hex) -> Self {
-        ValueKind::Hex(value)
-    }
-}
-
-impl From<Color> for ValueKind<'_> {
-    fn from(value: Color) -> Self {
-        ValueKind::Color(value)
-    }
-}
-
-impl<'bp, T> From<Vec<T>> for ValueKind<'bp>
-where
-    T: Into<ValueKind<'bp>>,
-{
-    fn from(value: Vec<T>) -> Self {
-        let list = value.into_iter().map(T::into).collect();
-        ValueKind::List(list)
-    }
-}
-
-impl<'a> From<&'a str> for ValueKind<'a> {
-    fn from(value: &'a str) -> Self {
-        ValueKind::Str(Cow::Borrowed(value))
-    }
-}
-
-impl From<String> for ValueKind<'_> {
-    fn from(value: String) -> Self {
-        ValueKind::Str(value.into())
-    }
-}
-
-// -----------------------------------------------------------------------------
-//   - Try From -
-// -----------------------------------------------------------------------------
-macro_rules! try_from_valuekind {
-    ($t:ty, $kind:ident) => {
-        impl TryFrom<&ValueKind<'_>> for $t {
-            type Error = ();
-
-            fn try_from(value: &ValueKind<'_>) -> Result<Self, Self::Error> {
-                match value {
-                    ValueKind::$kind(val) => Ok(*val),
-                    _ => Err(()),
-                }
-            }
-        }
-    };
-}
-
-macro_rules! try_from_valuekind_int {
-    ($t:ty, $kind:ident) => {
-        impl TryFrom<&ValueKind<'_>> for $t {
-            type Error = ();
-
-            fn try_from(value: &ValueKind<'_>) -> Result<Self, Self::Error> {
-                match value {
-                    ValueKind::$kind(val) => Ok(*val as $t),
-                    _ => Err(()),
-                }
-            }
-        }
-    };
-}
-
-try_from_valuekind!(i64, Int);
-try_from_valuekind!(f64, Float);
-try_from_valuekind!(bool, Bool);
-try_from_valuekind!(Hex, Hex);
-try_from_valuekind!(Color, Color);
-
-try_from_valuekind_int!(usize, Int);
-try_from_valuekind_int!(isize, Int);
-try_from_valuekind_int!(i32, Int);
-try_from_valuekind_int!(f32, Float);
-try_from_valuekind_int!(i16, Int);
-try_from_valuekind_int!(i8, Int);
-try_from_valuekind_int!(u32, Int);
-try_from_valuekind_int!(u64, Int);
-try_from_valuekind_int!(u16, Int);
-try_from_valuekind_int!(u8, Int);
-
-impl<'bp> TryFrom<&ValueKind<'bp>> for char {
-    type Error = ();
-
-    fn try_from(value: &ValueKind<'bp>) -> Result<Self, Self::Error> {
-        match value {
-            ValueKind::Char(c) => Ok(*c),
-            ValueKind::Str(s) => s.chars().next().ok_or(()),
-            _ => Err(()),
-        }
-    }
-}
-
-impl<'a, 'bp> TryFrom<&'a ValueKind<'bp>> for &'a str {
-    type Error = ();
-
-    fn try_from(value: &'a ValueKind<'bp>) -> Result<Self, Self::Error> {
-        match value {
-            ValueKind::Str(Cow::Borrowed(val)) => Ok(val),
-            ValueKind::Str(Cow::Owned(val)) => Ok(val.as_str()),
-            _ => Err(()),
-        }
-    }
-}
-
-#[cfg(test)]
-pub(crate) mod test {
-    use anathema_state::{Hex, Map, Maybe, States};
-    use anathema_templates::Variables;
-    use anathema_templates::expressions::{
-        add, and, boolean, chr, div, either, eq, float, greater_than, greater_than_equal, hex, ident, index, less_than,
-        less_than_equal, list, map, modulo, mul, neg, not, num, or, strlit, sub, text_segments,
-    };
-
-    use crate::ValueKind;
-    use crate::testing::setup;
-
-    #[test]
-    fn attribute_lookup() {
-        let expr = index(ident("attributes"), strlit("a"));
-        let int = num(123);
-
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            test.set_attribute("a", &int);
-            let value = test.eval(&expr);
-            assert_eq!(123, value.as_int().unwrap());
-        });
-    }
-
-    #[test]
-    fn expr_list_dyn_index() {
-        let expr = index(list([1, 2, 3]), add(ident("index"), num(1)));
-
-        let mut states = States::new();
-        let mut globals = Variables::new();
-        globals.define_global("index", 0).unwrap();
-
-        setup(&mut states, globals, |test| {
-            let value = test.eval(&expr);
-            assert_eq!(2, value.as_int().unwrap());
-        });
-    }
-
-    #[test]
-    fn expr_list() {
-        let expr = index(list([1, 2, 3]), num(0));
-
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            let value = test.eval(&expr);
-            assert_eq!(1, value.as_int().unwrap());
-        });
-    }
-
-    #[test]
-    fn either_index() {
-        // state[0] ? attributes[0]
-        let expr = either(
-            index(index(ident("state"), strlit("list")), num(0)),
-            index(index(ident("attributes"), strlit("list")), num(0)),
-        );
-
-        let list = list([strlit("from attribute")]);
-
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            // Set list for attributes
-            test.set_attribute("list", &list);
-
-            // Evaluate the value.
-            // The state is not yet set so it will fall back to attributes
-            let mut value = test.eval(&expr);
-            assert_eq!("from attribute", value.as_str().unwrap());
-
-            // Set the state value
-            test.with_state(|state| state.list.push("from state"));
-
-            // The value now comes from the state
-            value.reload(&test.attributes);
-            assert_eq!("from state", value.as_str().unwrap());
-        });
-    }
-
-    #[test]
-    fn either_then_index() {
-        // (state ? attributes)[0]
-
-        let list = list([num(123)]);
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            let expr = index(
-                either(
-                    index(ident("attributes"), strlit("list")),
-                    index(ident("state"), strlit("list")),
-                ),
-                num(0),
-            );
-
-            test.with_state(|state| state.list.push("a string"));
-            let value = test.eval(&expr);
-            assert_eq!("a string", value.as_str().unwrap());
-
-            test.set_attribute("list", &list);
-            let value = test.eval(&expr);
-            assert_eq!(123, value.as_int().unwrap());
-        });
-    }
-
-    #[test]
-    fn either_or() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            test.with_state(|state| state.num.set(1));
-            test.with_state(|state| state.num_2.set(2));
-
-            // There is no c, so use b
-            let expr = either(
-                index(ident("state"), strlit("num_3")),
-                index(ident("state"), strlit("num_2")),
-            );
-            let value = test.eval(&expr);
-            assert_eq!(2, value.as_int().unwrap());
-
-            // There is a, so don't use b
-            let expr = either(
-                index(ident("state"), strlit("num")),
-                index(ident("state"), strlit("num_2")),
-            );
-            let value = test.eval(&expr);
-            assert_eq!(1, value.as_int().unwrap());
-        });
-    }
-
-    #[test]
-    fn mods() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            test.with_state(|state| state.num.set(5));
-            let lookup = index(ident("state"), strlit("num"));
-            let expr = modulo(lookup, num(3));
-            let value = test.eval(&expr);
-            assert_eq!(2, value.as_int().unwrap());
-        });
-    }
-
-    #[test]
-    fn division() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            test.with_state(|state| state.num.set(6));
-            let lookup = index(ident("state"), strlit("num"));
-            let expr = div(lookup, num(2));
-            let value = test.eval(&expr);
-            assert_eq!(3, value.as_int().unwrap());
-        });
-    }
-
-    #[test]
-    fn multiplication() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            test.with_state(|state| state.num.set(2));
-            let lookup = index(ident("state"), strlit("num"));
-            let expr = mul(lookup, num(2));
-            let value = test.eval(&expr);
-            assert_eq!(4, value.as_int().unwrap());
-        });
-    }
-
-    #[test]
-    fn subtraction() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            test.with_state(|state| state.num.set(1));
-            let lookup = index(ident("state"), strlit("num"));
-            let expr = sub(lookup, num(2));
-            let value = test.eval(&expr);
-            assert_eq!(-1, value.as_int().unwrap());
-        });
-    }
-
-    #[test]
-    fn addition() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            test.with_state(|state| state.num.set(1));
-            let lookup = index(ident("state"), strlit("num"));
-            let expr = add(lookup, num(2));
-            let value = test.eval(&expr);
-            assert_eq!(3, value.as_int().unwrap());
-        });
-    }
-
-    #[test]
-    fn test_or() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            let is_true = or(boolean(false), boolean(true));
-            let is_true = test.eval(&is_true);
-            assert!(is_true.as_bool().unwrap());
-        });
-    }
-
-    #[test]
-    fn test_and() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            let is_true = and(boolean(true), boolean(true));
-            let is_true = test.eval(&is_true);
-            assert!(is_true.as_bool().unwrap());
-        });
-    }
-
-    #[test]
-    fn lte() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            let is_true = less_than_equal(num(1), num(2));
-            let is_also_true = less_than_equal(num(1), num(1));
-            let is_true = test.eval(&is_true);
-            let is_also_true = test.eval(&is_also_true);
-            assert!(is_true.as_bool().unwrap());
-            assert!(is_also_true.as_bool().unwrap());
-        });
-    }
-
-    #[test]
-    fn lt() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            let is_true = less_than(num(1), num(2));
-            let is_false = less_than(num(1), num(1));
-            let is_true = test.eval(&is_true);
-            let is_false = test.eval(&is_false);
-            assert!(is_true.as_bool().unwrap());
-            assert!(!is_false.as_bool().unwrap());
-        });
-    }
-
-    #[test]
-    fn gte() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            let is_true = greater_than_equal(num(2), num(1));
-            let is_also_true = greater_than_equal(num(2), num(2));
-            let is_true = test.eval(&is_true);
-            let is_also_true = test.eval(&is_also_true);
-            assert!(is_true.as_bool().unwrap());
-            assert!(is_also_true.as_bool().unwrap());
-        });
-    }
-
-    #[test]
-    fn gt() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            let is_true = greater_than(num(2), num(1));
-            let is_false = greater_than(num(2), num(2));
-            let is_true = test.eval(&is_true);
-            let is_false = test.eval(&is_false);
-            assert!(is_true.as_bool().unwrap());
-            assert!(!is_false.as_bool().unwrap());
-        });
-    }
-
-    #[test]
-    fn equality() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            let is_true = eq(num(1), num(1));
-            let is_true = test.eval(&is_true);
-            let is_false = &not(eq(num(1), num(1)));
-            let is_false = test.eval(is_false);
-            assert!(is_true.as_bool().unwrap());
-            assert!(!is_false.as_bool().unwrap());
-        });
-    }
-
-    #[test]
-    fn neg_float() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            let expr = neg(float(123.1));
-            let value = test.eval(&expr);
-            assert_eq!(-123.1, value.as_float().unwrap());
-        });
-    }
-
-    #[test]
-    fn neg_num() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            let expr = neg(num(123));
-            let value = test.eval(&expr);
-            assert_eq!(-123, value.as_int().unwrap());
-        });
-    }
-
-    #[test]
-    fn not_true() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            let expr = not(boolean(false));
-            let value = test.eval(&expr);
-            assert!(value.as_bool().unwrap());
-        });
-    }
-
-    #[test]
-    fn map_resolve() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            let expr = map([("a", 123), ("b", 456)]);
-            let value = test.eval(&expr);
-            assert_eq!(ValueKind::Map, value.kind);
-        });
-    }
-
-    #[test]
-    fn optional_map_resolve() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            // At first there is no map...
-            let expr = index(ident("state"), strlit("opt_map"));
-            let mut value = test.eval(&expr);
-            assert!(matches!(value.kind, ValueKind::Null));
-
-            // ... then we insert a map
-            test.with_state(|state| {
-                let map = Map::empty();
-                state.opt_map.set(Maybe::some(map));
-            });
-
-            value.reload(&test.attributes);
-            assert!(matches!(value.kind, ValueKind::DynMap(_)));
-        });
-    }
-
-    #[test]
-    fn str_resolve() {
-        // state[empty|full]
-        let mut states = States::new();
-        let mut globals = Variables::new();
-        globals.define_global("full", "string").unwrap();
-        setup(&mut states, globals, |test| {
-            let expr = index(ident("state"), either(ident("empty"), ident("full")));
-            test.with_state(|state| state.string.set("a string"));
-            let value = test.eval(&expr);
-            assert_eq!("a string", value.as_str().unwrap());
-        });
-    }
-
-    #[test]
-    fn state_string() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            test.with_state(|state| state.string.set("a string"));
-            let expr = index(ident("state"), strlit("string"));
-            let value = test.eval(&expr);
-            assert_eq!("a string", value.as_str().unwrap());
-        });
-    }
-
-    #[test]
-    fn state_float() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            let expr = index(ident("state"), strlit("float"));
-            test.with_state(|state| state.float.set(1.2));
-            let value = test.eval(&expr);
-            assert_eq!(1.2, value.as_float().unwrap());
-        });
-    }
-
-    #[test]
-    fn test_either_with_state() {
-        let mut states = States::new();
-        let expr = either(index(ident("state"), strlit("num")), num(2));
-
-        setup(&mut states, Variables::new(), |test| {
-            test.with_state(|state| state.num.set(0));
-            let value = test.eval(&expr);
-            assert_eq!(2, value.as_int().unwrap());
-        });
-
-        setup(&mut states, Variables::new(), |test| {
-            test.with_state(|state| state.num.set(1));
-            let value = test.eval(&expr);
-            assert_eq!(1, value.as_int().unwrap());
-        });
-    }
-
-    #[test]
-    fn test_either() {
-        let mut states = States::new();
-        let mut globals = Variables::new();
-        globals.define_global("missing", 111).unwrap();
-        setup(&mut states, globals, |test| {
-            let expr = either(ident("missings"), num(2));
-            let value = test.eval(&expr);
-            assert_eq!(2, value.as_int().unwrap());
-        });
-    }
-
-    #[test]
-    fn test_hex() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            let expr = hex((1, 2, 3));
-            let value = test.eval(&expr);
-            assert_eq!(Hex::from((1, 2, 3)), value.as_hex().unwrap());
-        });
-    }
-
-    #[test]
-    fn test_char() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            let expr = chr('x');
-            let value = test.eval(&expr);
-            assert_eq!('x', value.as_char().unwrap());
-        });
-    }
-
-    #[test]
-    fn test_float() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            let expr = float(123.123);
-            let value = test.eval(&expr);
-            assert_eq!(123.123, value.as_float().unwrap());
-        });
-    }
-
-    #[test]
-    fn test_int() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            let expr = num(123);
-            let value = test.eval(&expr);
-            assert_eq!(123, value.as_int().unwrap());
-        });
-    }
-
-    #[test]
-    fn test_bool() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            let expr = boolean(true);
-            let value = test.eval(&expr);
-            assert!(value.as_bool().unwrap());
-        });
-    }
-
-    #[test]
-    fn test_dyn_list() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            test.with_state(|state| {
-                state.list.push("abc");
-                state.list.push("def");
-            });
-            let expr = index(index(ident("state"), strlit("list")), num(1));
-            let value = test.eval(&expr);
-            assert_eq!("def", value.as_str().unwrap());
-        });
-    }
-
-    #[test]
-    fn test_expression_map_state_key() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            let expr = index(map([("value", 123)]), index(ident("state"), strlit("string")));
-            test.with_state(|state| state.string.set("value"));
-            let value = test.eval(&expr);
-            assert_eq!(123, value.as_int().unwrap());
-        });
-    }
-
-    #[test]
-    fn test_expression_map() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            let expr = index(map([("value", 123)]), strlit("value"));
-            let value = test.eval(&expr);
-            assert_eq!(123, value.as_int().unwrap());
-        });
-    }
-
-    #[test]
-    fn test_state_lookup() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            let expr = index(ident("state"), strlit("num"));
-            let value = test.eval(&expr);
-            assert_eq!(0, value.as_int().unwrap());
-        });
-    }
-
-    #[test]
-    fn test_nested_map() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            let expr = index(index(ident("state"), strlit("map")), strlit("value"));
-            test.with_state(|state| state.map.to_mut().insert("value", 123));
-            let value = test.eval(&expr);
-            assert_eq!(123, value.as_int().unwrap());
-        });
-    }
-
-    #[test]
-    fn stringify() {
-        let mut states = States::new();
-        setup(&mut states, Default::default(), |test| {
-            let expr = text_segments([strlit("hello"), strlit(" "), strlit("world")]);
-            let value = test.eval(&expr);
-            let mut actual = String::new();
-            value.strings(|st| {
-                actual.push_str(st);
-                true
-            });
-            assert_eq!("hello world", &actual);
-        });
-    }
-}
diff --git a/anathema-widgets/Cargo.toml b/anathema-widgets/Cargo.toml
index 64c1bf7b..a6eff9af 100644
--- a/anathema-widgets/Cargo.toml
+++ b/anathema-widgets/Cargo.toml
@@ -1,30 +1,11 @@
 [package]
 name = "anathema-widgets"
-license = "MIT"
-description = "Anathema widget base"
-version.workspace = true
 edition.workspace = true
-documentation = "https://togglebyte.github.io/anathema-guide/"
-homepage = "https://github.com/togglebyte/anathema"
-repository = "https://github.com/togglebyte/anathema"
+version.workspace = true
 
 [dependencies]
-anathema-geometry = { workspace = true }
-anathema-state = { workspace = true }
-anathema-store = { workspace = true }
-# anathema-strings = { workspace = true }
-anathema-templates = { workspace = true }
-anathema-value-resolver = { workspace = true }
-flume = { workspace = true }
-bitflags = { workspace = true }
-unicode-width = { workspace = true }
-unicode-segmentation = "1.11.0"
-puffin = { version = "0.19.1", features = ["web"], optional = true }
-
-[features]
-default = []
-profile = ["puffin"]
-filelog = []
+anathema-core = { path = "../anathema-core", version = "0.2.12-beta" }
+anathema-geometry = { path = "../anathema-geometry", version = "0.2.12-beta" }
 
 [lints]
 workspace = true
diff --git a/anathema-widgets/src/border.rs b/anathema-widgets/src/border.rs
new file mode 100644
index 00000000..c5af78bd
--- /dev/null
+++ b/anathema-widgets/src/border.rs
@@ -0,0 +1,29 @@
+use anathema_core::layout::Layout;
+use anathema_core::runtime::{Children, Widget};
+use anathema_geometry::{Pos, Size};
+
+#[derive(Debug, Default)]
+pub struct Border;
+
+impl Widget for Border {
+    fn layout(&mut self, mut children: Children<'_, '_>, layout: &mut Layout) -> Size {
+        let mut size = children.next().map(|child| child.layout(layout)).unwrap_or(Size::ZERO);
+        size
+    }
+
+    fn position(&mut self) -> Pos {
+        todo!()
+    }
+
+    fn paint(&mut self) {
+        todo!()
+    }
+
+    fn describe(&self) -> &str {
+        "border"
+    }
+}
+
+pub fn border() -> Box<dyn Widget> {
+    Box::new(Border)
+}
diff --git a/anathema-widgets/src/components/deferred.rs b/anathema-widgets/src/components/deferred.rs
deleted file mode 100644
index 33dfbc04..00000000
--- a/anathema-widgets/src/components/deferred.rs
+++ /dev/null
@@ -1,155 +0,0 @@
-use std::any::Any;
-use std::borrow::Cow;
-
-use anathema_value_resolver::{Attributes, ValueKind};
-
-use crate::nodes::component::Component;
-
-pub struct DeferredComponents {
-    queue: Vec<Command>,
-}
-
-impl DeferredComponents {
-    pub fn new() -> Self {
-        Self { queue: vec![] }
-    }
-
-    pub fn drain(&mut self) -> impl Iterator<Item = Command> + '_ {
-        self.queue.drain(..).rev()
-    }
-
-    pub fn by_name(&mut self, name: impl Into<Cow<'static, str>>) -> QueryBuilder<'_> {
-        QueryBuilder::new(&mut self.queue, Filter::Name(name.into()))
-    }
-
-    pub fn by_attribute(
-        &mut self,
-        key: impl Into<Cow<'static, str>>,
-        value: impl Into<ValueKind<'static>>,
-    ) -> QueryBuilder<'_> {
-        QueryBuilder::new(
-            &mut self.queue,
-            Filter::Attribute {
-                key: key.into(),
-                value: value.into(),
-            },
-        )
-    }
-
-    pub fn nth(&mut self, count: usize) -> QueryBuilder<'_> {
-        QueryBuilder::new(&mut self.queue, Filter::Nth(count))
-    }
-}
-
-pub struct QueryBuilder<'a> {
-    queue: &'a mut Vec<Command>,
-    filter: Filter,
-}
-
-impl<'a> QueryBuilder<'a> {
-    fn new(queue: &'a mut Vec<Command>, filter: Filter) -> Self {
-        Self { queue, filter }
-    }
-
-    pub fn by_name(self, name: impl Into<Cow<'static, str>>) -> Self {
-        Self {
-            queue: self.queue,
-            filter: self.filter.chain(Filter::Name(name.into())),
-        }
-    }
-
-    pub fn by_attribute(self, key: impl Into<Cow<'static, str>>, value: impl Into<ValueKind<'static>>) -> Self {
-        Self {
-            queue: self.queue,
-            filter: self.filter.chain(Filter::Attribute {
-                key: key.into(),
-                value: value.into(),
-            }),
-        }
-    }
-
-    pub fn nth(self, count: usize) -> Self {
-        Self {
-            queue: self.queue,
-            filter: self.filter.chain(Filter::Nth(count)),
-        }
-    }
-
-    pub fn send(self, message: impl Any + Send + Sync) {
-        let command = Command {
-            kind: CommandKind::SendMessage(Box::new(message)),
-            filter: self.filter,
-        };
-        self.queue.push(command);
-    }
-
-    pub fn focus(self) {
-        let command = Command {
-            kind: CommandKind::Focus,
-            filter: self.filter,
-        };
-        self.queue.push(command);
-    }
-}
-
-enum Filter {
-    Name(Cow<'static, str>),
-    Attribute {
-        key: Cow<'static, str>,
-        value: ValueKind<'static>,
-    },
-    Nth(usize),
-    Chain(Box<Self>, Box<Self>),
-}
-
-impl Filter {
-    fn chain(self, other: Self) -> Self {
-        Self::Chain(Box::new(self), Box::new(other))
-    }
-
-    // The filter only works with primitives, this excludes maps, lists and composite
-    // values
-    fn filter(&mut self, component: &Component<'_>, attributes: &Attributes<'_>) -> bool {
-        match self {
-            Filter::Name(cow) => component.name == cow,
-            Filter::Attribute { key, value: rhs } => match attributes.get(key) {
-                Some(lhs) => match (lhs, rhs) {
-                    (ValueKind::Int(lhs), ValueKind::Int(rhs)) => lhs == rhs,
-                    (ValueKind::Float(lhs), ValueKind::Float(rhs)) => lhs == rhs,
-                    (ValueKind::Bool(lhs), ValueKind::Bool(rhs)) => lhs == rhs,
-                    (ValueKind::Char(lhs), ValueKind::Char(rhs)) => lhs == rhs,
-                    (ValueKind::Hex(lhs), ValueKind::Hex(rhs)) => lhs == rhs,
-                    (ValueKind::Str(lhs), ValueKind::Str(rhs)) => lhs == rhs,
-                    (ValueKind::Null, ValueKind::Null) => true,
-                    _ => false,
-                },
-                None => false,
-            },
-            Filter::Nth(0) => true,
-            Filter::Nth(nth) => {
-                *nth -= 1;
-                false
-            }
-            Filter::Chain(first, second) => match first.filter(component, attributes) {
-                true => second.filter(component, attributes),
-                false => false,
-            },
-        }
-    }
-}
-
-pub struct Command {
-    filter: Filter,
-    pub kind: CommandKind,
-}
-
-impl Command {
-    pub fn filter_component(&mut self, component: &Component<'_>, attributes: &Attributes<'_>) -> bool {
-        self.filter.filter(component, attributes)
-    }
-}
-
-pub enum CommandKind {
-    SendMessage(Box<dyn Any + Send + Sync>),
-    Focus,
-}
diff --git a/anathema-widgets/src/components/events/key.rs b/anathema-widgets/src/components/events/key.rs
deleted file mode 100644
index 82b98475..00000000
--- a/anathema-widgets/src/components/events/key.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub enum KeyState {
-    Press,
-    Repeat,
-    Release,
-}
-
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub struct KeyEvent {
-    pub code: KeyCode,
-    pub ctrl: bool,
-    pub state: KeyState,
-}
-
-impl KeyEvent {
-    pub fn get_char(&self) -> Option<char> {
-        match self.code {
-            KeyCode::Char(c) => Some(c),
-            _ => None,
-        }
-    }
-
-    pub fn is_ctrl_c(&self) -> bool {
-        match self.code {
-            KeyCode::Char('c') => self.ctrl,
-            _ => false,
-        }
-    }
-}
-
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub enum KeyCode {
-    Char(char),
-    Tab,
-    BackTab,
-    CtrlC,
-    Backspace,
-    Enter,
-    Left,
-    Right,
-    Up,
-    Down,
-    Home,
-    End,
-    PageUp,
-    PageDown,
-    Delete,
-    Insert,
-    F(u8),
-    Null,
-    Esc,
-    CapsLock,
-    ScrollLock,
-    NumLock,
-    PrintScreen,
-    Pause,
-    Menu,
-    KeypadBegin,
-}
diff --git a/anathema-widgets/src/components/events/mod.rs b/anathema-widgets/src/components/events/mod.rs
deleted file mode 100644
index 1b5e6975..00000000
--- a/anathema-widgets/src/components/events/mod.rs
+++ /dev/null
@@ -1,72 +0,0 @@
-use std::time::Duration;
-
-use anathema_geometry::Size;
-
-pub use self::key::{KeyCode, KeyEvent, KeyState};
-pub use self::mouse::{MouseButton, MouseEvent, MouseState};
-
-mod key;
-mod mouse;
-
-#[derive(Debug, Copy, Clone)]
-pub enum EventType {
-    PreCycle,
-    PostCycle,
-}
-
-impl From<Event> for EventType {
-    fn from(event: Event) -> Self {
-        match event {
-            Event::Resize(_) => EventType::PostCycle,
-            _ => EventType::PreCycle,
-        }
-    }
-}
-
-/// An event
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub enum Event {
-    /// No op
-    Noop,
-    /// Mount, called first time a component is added to the tree
-    Mount,
-    /// Unmount, called when the component is returned to component storage
-    Unmount,
-    /// Stop the runtime
-    Stop,
-    /// Terminal lost focus (not widely supported)
-    Blur,
-    /// Terminal gained focus (not widely supported)
-    Focus,
-    /// Key event
-    Key(KeyEvent),
-    /// Mouse event
-    Mouse(MouseEvent),
-    /// Window was resized
-    Resize(Size),
-    /// Tick
-    Tick(Duration),
-}
-
-impl Event {
-    pub fn is_mouse_event(&self) -> bool {
-        matches!(self, Self::Mouse(_))
-    }
-
-    pub fn get_char(&self) -> Option<char> {
-        match self {
-            Self::Key(event) => event.get_char(),
-            _ => None,
-        }
-    }
-
-    pub fn is_ctrl_c(&self) -> bool {
-        match self {
-            Self::Key(event) => match event.code {
-                KeyCode::Char('c') => event.ctrl,
-                _ => false,
-            },
-            _ => false,
-        }
-    }
-}
diff --git a/anathema-widgets/src/components/events/mouse.rs b/anathema-widgets/src/components/events/mouse.rs
deleted file mode 100644
index fd27fa4c..00000000
--- a/anathema-widgets/src/components/events/mouse.rs
+++ /dev/null
@@ -1,88 +0,0 @@
-use anathema_geometry::Pos;
-
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub struct MouseEvent {
-    pub x: u16,
-    pub y: u16,
-    pub state: MouseState,
-}
-
-impl MouseEvent {
-    /// Translate the x and y position into a `Position`
-    pub fn pos(&self) -> Pos {
-        (self.x, self.y).into()
-    }
-
-    /// Returns true if the left mouse button is pressed
-    pub fn left_down(&self) -> bool {
-        matches!(self.state, MouseState::Down(MouseButton::Left))
-    }
-
-    /// Returns true if the right mouse button is pressed
-    pub fn right_down(&self) -> bool {
-        matches!(self.state, MouseState::Down(MouseButton::Right))
-    }
-
-    /// Returns true if the middle mouse button is pressed
-    pub fn middle_down(&self) -> bool {
-        matches!(self.state, MouseState::Down(MouseButton::Middle))
-    }
-
-    /// Returns true if the left mouse button is down
-    pub fn is_left_down(&self) -> bool {
-        matches!(
-            self.state,
-            MouseState::Down(MouseButton::Left) | MouseState::Drag(MouseButton::Left)
-        )
-    }
-
-    /// Returns true if the right mouse button is down
-    pub fn is_right_down(&self) -> bool {
-        matches!(
-            self.state,
-            MouseState::Down(MouseButton::Right) | MouseState::Drag(MouseButton::Right)
-        )
-    }
-
-    /// Returns true if the middle mouse button is down
-    pub fn is_middle_down(&self) -> bool {
-        matches!(
-            self.state,
-            MouseState::Down(MouseButton::Middle) | MouseState::Drag(MouseButton::Middle)
-        )
-    }
-
-    /// Returns true if the left mouse button is released
-    pub fn left_up(&self) -> bool {
-        matches!(self.state, MouseState::Up(MouseButton::Left))
-    }
-
-    /// Returns true if the right mouse button is released
-    pub fn right_up(&self) -> bool {
-        matches!(self.state, MouseState::Up(MouseButton::Right))
-    }
-
-    /// Returns true if the middle mouse button is released
-    pub fn middle_up(&self) -> bool {
-        matches!(self.state, MouseState::Up(MouseButton::Middle))
-    }
-}
-
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub enum MouseState {
-    Down(MouseButton),
-    Up(MouseButton),
-    Drag(MouseButton),
-    Move,
-    ScrollUp,
-    ScrollDown,
-    ScrollLeft,
-    ScrollRight,
-}
-
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub enum MouseButton {
-    Left,
-    Middle,
-    Right,
-}
diff --git a/anathema-widgets/src/components/mod.rs b/anathema-widgets/src/components/mod.rs
deleted file mode 100644
index b7a52902..00000000
--- a/anathema-widgets/src/components/mod.rs
+++ /dev/null
@@ -1,702 +0,0 @@
-use std::any::Any;
-use std::marker::PhantomData;
-use std::ops::{Deref, DerefMut};
-use std::time::Duration;
-
-use anathema_state::{State, StateId, Value as StateValue};
-use anathema_store::slab::Slab;
-use anathema_templates::strings::{StringId, Strings};
-use anathema_templates::{AssocEventMapping, ComponentBlueprintId};
-use anathema_value_resolver::{Attributes, ValueKind};
-use deferred::DeferredComponents;
-use flume::SendError;
-
-use self::events::{Event, KeyEvent, MouseEvent};
-use crate::WidgetId;
-use crate::layout::Viewport;
-use crate::query::Children;
-use crate::widget::Parent;
-
-pub mod deferred;
-pub mod events;
-
-pub type ComponentFn = dyn Fn() -> Box<dyn AnyComponent>;
-pub type StateFn = dyn FnMut() -> Box<dyn State>;
-
-enum ComponentType {
-    Component(Option<Box<dyn AnyComponent>>, Option<Box<dyn State>>),
-    Prototype(Box<ComponentFn>, Box<StateFn>),
-}
-
-/// Store component factories.
-/// This is how components are created.
-pub struct ComponentRegistry(Slab<ComponentBlueprintId, ComponentType>);
-
-impl ComponentRegistry {
-    pub fn new() -> Self {
-        Self(Slab::empty())
-    }
-
-    /// Both `add_component` and `add_prototype` are using `Slab::insert_at`.
-    ///
-    /// This is fine as the component ids are generated at the same time.
-    pub fn add_component<S: State>(&mut self, id: ComponentBlueprintId, component: impl Component + 'static, state: S) {
-        let comp_type = ComponentType::Component(Some(Box::new(component)), Some(Box::new(state)));
-        self.0.insert_at(id, comp_type);
-    }
-
-    pub fn add_prototype<FC, FS, C, S>(&mut self, id: ComponentBlueprintId, proto: FC, mut state: FS)
-    where
-        FC: 'static + Fn() -> C,
-        FS: 'static + FnMut() -> S,
-        C: Component + 'static,
-        S: State + 'static,
-    {
-        let comp_type =
-            ComponentType::Prototype(Box::new(move || Box::new(proto())), Box::new(move || Box::new(state())));
-
-        self.0.insert_at(id, comp_type);
-    }
-
-    // # Panics
-    //
-    // Panics if the component isn't registered.
-    // This shouldn't happen as the statement eval should catch this.
-    pub(super) fn get(
-        &mut self,
-        id: ComponentBlueprintId,
-    ) -> Option<(ComponentKind, Box<dyn AnyComponent>, Box<dyn State>)> {
-        match self.0.get_mut(id) {
-            Some(component) => match component {
-                ComponentType::Component(comp, state) => Some((ComponentKind::Instance, comp.take()?, state.take()?)),
-                ComponentType::Prototype(proto, state) => Some((ComponentKind::Prototype, proto(), state())),
-            },
-            None => panic!(),
-        }
-    }
-
-    /// Return a component back to the registry.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the component entry doesn't exist or if the entry is for a prototype.
-    pub fn return_component(
-        &mut self,
-        id: ComponentBlueprintId,
-        current_component: Box<dyn AnyComponent>,
-        current_state: Box<dyn State>,
-    ) {
-        match self.0.get_mut(id) {
-            Some(component) => match component {
-                ComponentType::Component(comp, state) => {
-                    *comp = Some(current_component);
-                    *state = Some(current_state);
-                }
-                ComponentType::Prototype(..) => {
-                    // Can't return a prototype
-                }
-            },
-            None => panic!(),
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ComponentId<T>(pub(crate) ComponentBlueprintId, pub(crate) PhantomData<T>);
-
-impl<T> From<ComponentBlueprintId> for ComponentId<T> {
-    fn from(value: ComponentBlueprintId) -> Self {
-        Self(value, PhantomData)
-    }
-}
-
-impl<T> Clone for ComponentId<T> {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-
-impl<T> Copy for ComponentId<T> {}
-
-pub struct ViewMessage {
-    pub(super) payload: Box<dyn Any + Send + Sync>,
-    pub(super) recipient: Recipient,
-}
-
-impl ViewMessage {
-    pub fn recipient(&self) -> Recipient {
-        self.recipient
-    }
-
-    pub fn payload(self) -> Box<dyn Any + Send + Sync> {
-        self.payload
-    }
-}
-
-#[derive(Debug, Copy, Clone)]
-pub enum Recipient {
-    ComponentId(ComponentBlueprintId),
-    WidgetId(WidgetId),
-}
-
-#[derive(Debug, Clone)]
-pub struct Emitter(pub(crate) flume::Sender<ViewMessage>);
-
-impl From<flume::Sender<ViewMessage>> for Emitter {
-    fn from(value: flume::Sender<ViewMessage>) -> Self {
-        Self(value)
-    }
-}
-
-pub type MessageReceiver = flume::Receiver<ViewMessage>;
-
-impl Emitter {
-    pub fn new() -> (Self, MessageReceiver) {
-        let (tx, rx) = flume::unbounded();
-        (Self(tx), rx)
-    }
-
-    /// Emit a message to a component via a `ComponentId<T>`
-    pub fn emit<T: 'static + Send + Sync>(
-        &self,
-        component_id: ComponentId<T>,
-        value: T,
-    ) -> Result<(), SendError<ViewMessage>> {
-        let msg = ViewMessage {
-            payload: Box::new(value),
-            recipient: Recipient::ComponentId(component_id.0),
-        };
-        self.0.send(msg)
-    }
-
-    /// Emit a message to a component via a `ComponentId<T>` asynchronously
-    pub async fn emit_async<T: 'static + Send + Sync>(
-        &self,
-        component_id: ComponentId<T>,
-        value: T,
-    ) -> Result<(), SendError<ViewMessage>> {
-        let msg = ViewMessage {
-            payload: Box::new(value),
-            recipient: Recipient::ComponentId(component_id.0),
-        };
-        self.0.send_async(msg).await
-    }
-
-    /// Try to emit a message to a component via its `WidgetId`.
-    /// Unlike the `emit` function there is no type associated with the widget id,
-    /// and the message will fail to deliver silently if the wrong type is used.
-    pub fn try_emit<T: 'static + Send + Sync>(
-        &self,
-        widget_id: WidgetId,
-        value: T,
-    ) -> Result<(), SendError<ViewMessage>> {
-        let msg = ViewMessage {
-            payload: Box::new(value),
-            recipient: Recipient::WidgetId(widget_id),
-        };
-        self.0.send(msg)
-    }
-
-    /// Async counterpart of `try_emit`.
-    pub async fn try_emit_async<T: 'static + Send + Sync>(
-        &self,
-        widget_id: WidgetId,
-        value: T,
-    ) -> Result<(), SendError<ViewMessage>> {
-        let msg = ViewMessage {
-            payload: Box::new(value),
-            recipient: Recipient::WidgetId(widget_id),
-        };
-        self.0.send_async(msg).await
-    }
-}
-
-pub struct Context<'frame, 'bp, T> {
-    inner: AnyComponentContext<'frame, 'bp>,
-    _p: PhantomData<T>,
-}
-
-impl<'frame, 'bp, T: 'static> Context<'frame, 'bp, T> {
-    pub fn new(inner: AnyComponentContext<'frame, 'bp>) -> Self {
-        Self { inner, _p: PhantomData }
-    }
-
-    /// Publish an event
-    ///
-    /// # Panics
-    ///
-    /// This will panic if the shared value is exclusively borrowed
-    /// at the time of the invocation.
-    pub fn publish<D: 'static>(&mut self, ident: &str, data: D) {
-        // If there is no parent there is no one to emit the event to.
-        let Some(parent) = self.parent else { return };
-
-        let Some(ident_id) = self.inner.strings.lookup(ident) else { return };
-
-        let ids = self.assoc_functions.iter().find(|assoc| assoc.internal == ident_id);
-
-        let Some(assoc_event_map) = ids else { return };
-
-        self.inner.assoc_events.push(
-            self.state_id,
-            parent,
-            *assoc_event_map,
-            self.ident_id,
-            self.widget_id,
-            data,
-        );
-    }
-
-    /// Get a value from the component attributes
-    pub fn attribute(&self, key: &str) -> Option<&ValueKind<'_>> {
-        self.attributes.get(key)
-    }
-
-    /// Send a message to a given component
-    pub fn emit<M: 'static + Send + Sync>(&self, recipient: ComponentId<M>, value: M) {
-        self.emitter
-            .emit(recipient, value)
-            .expect("this will not fail unless the runtime is dropped")
-    }
-}
-
-impl<'frame, 'bp, T> Deref for Context<'frame, 'bp, T> {
-    type Target = AnyComponentContext<'frame, 'bp>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-
-impl<'frame, 'bp, T> DerefMut for Context<'frame, 'bp, T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.inner
-    }
-}
-
-pub struct AnyComponentContext<'frame, 'bp> {
-    parent: Option<Parent>,
-    ident_id: StringId,
-    pub widget_id: WidgetId,
-    state_id: StateId,
-    assoc_functions: &'frame [AssocEventMapping],
-    assoc_events: &'frame mut AssociatedEvents,
-    pub attributes: &'frame mut Attributes<'bp>,
-    state: Option<&'frame mut StateValue<Box<dyn State>>>,
-    pub emitter: &'frame Emitter,
-    pub viewport: &'frame Viewport,
-    pub strings: &'frame Strings,
-    pub components: &'frame mut DeferredComponents,
-    stop_runtime: &'frame mut bool,
-}
-
-impl<'frame, 'bp> AnyComponentContext<'frame, 'bp> {
-    pub fn new(
-        parent: Option<Parent>,
-        ident_id: StringId,
-        sender_id: WidgetId,
-        state_id: StateId,
-        assoc_functions: &'frame [AssocEventMapping],
-        assoc_events: &'frame mut AssociatedEvents,
-        components: &'frame mut DeferredComponents,
-        attributes: &'frame mut Attributes<'bp>,
-        state: Option<&'frame mut StateValue<Box<dyn State>>>,
-        emitter: &'frame Emitter,
-        viewport: &'frame Viewport,
-        stop_runtime: &'frame mut bool,
-        strings: &'frame Strings,
-    ) -> Self {
-        Self {
-            parent,
-            ident_id,
-            widget_id: sender_id,
-            state_id,
-            assoc_functions,
-            assoc_events,
-            attributes,
-            components,
-            state,
-            emitter,
-            viewport,
-            strings,
-            stop_runtime,
-        }
-    }
-
-    pub fn parent(&self) -> Option<Parent> {
-        self.parent
-    }
-
-    pub fn stop_runtime(&mut self) {
-        *self.stop_runtime = true;
-    }
-}
-
-pub struct AssociatedEvent {
-    pub state: StateId,
-    pub parent: Parent,
-    pub sender: StringId,
-    pub sender_id: WidgetId,
-    event_map: AssocEventMapping,
-    data: Box<dyn Any>,
-}
-
-impl AssociatedEvent {
-    pub fn to_event<'a>(
-        &'a self,
-        internal: &'a str,
-        external: &'a str,
-        sender: &'a str,
-        sender_id: WidgetId,
-    ) -> UserEvent<'a> {
-        UserEvent {
-            external_ident: external,
-            internal_ident: internal,
-            data: &*self.data,
-            sender,
-            sender_id,
-            stop_propagation: false,
-        }
-    }
-
-    pub fn external(&self) -> StringId {
-        self.event_map.external
-    }
-
-    pub fn internal(&self) -> StringId {
-        self.event_map.internal
-    }
-}
-
-#[derive(Debug, Copy, Clone)]
-pub struct UserEvent<'a> {
-    pub sender: &'a str,
-    pub sender_id: WidgetId,
-    pub external_ident: &'a str,
-    pub internal_ident: &'a str,
-    data: &'a dyn Any,
-    stop_propagation: bool,
-}
-
-impl<'a> UserEvent<'a> {
-    pub fn stop_propagation(&mut self) {
-        self.stop_propagation = true;
-    }
-
-    pub fn name(&self) -> &str {
-        self.external_ident
-    }
-
-    /// Cast the event payload to a specific type
-    ///
-    /// # Panics
-    ///
-    /// This will panic if the type is incorrect
-    pub fn data<T: 'static>(&self) -> &'a T {
-        match self.data.downcast_ref() {
-            Some(data) => data,
-            None => panic!("invalid type when casting event data"),
-        }
-    }
-
-    /// Try to cast the event payload to a specific type
-    pub fn data_checked<T: 'static>(&self) -> Option<&'a T> {
-        self.data.downcast_ref()
-    }
-
-    pub fn should_stop_propagation(&self) -> bool {
-        self.stop_propagation
-    }
-}
-
-// The reason the component can not have access
-// to the children during this event is because the parent is borrowing from the
-// child's state while this is happening.
-pub struct AssociatedEvents {
-    inner: Vec<AssociatedEvent>,
-}
-
-impl AssociatedEvents {
-    pub fn new() -> Self {
-        Self { inner: vec![] }
-    }
-
-    fn push<T: 'static>(
-        &mut self,
-        state: StateId,
-        parent: Parent,
-        assoc_event_map: AssocEventMapping,
-        sender: StringId,
-        sender_id: WidgetId,
-        data: T,
-    ) {
-        self.inner.push(AssociatedEvent {
-            state,
-            parent,
-            sender,
-            sender_id,
-            event_map: assoc_event_map,
-            data: Box::new(data),
-        })
-    }
-
-    pub fn next(&mut self) -> Option<AssociatedEvent> {
-        self.inner.pop()
-    }
-}
-
-pub trait Component: 'static {
-    type State: State;
-    type Message;
-
-    const TICKS: bool = true;
-
-    #[allow(unused_variables, unused_mut)]
-    fn on_key(
-        &mut self,
-        key: KeyEvent,
-        state: &mut Self::State,
-        mut children: Children<'_, '_>,
-        mut context: Context<'_, '_, Self::State>,
-    ) {
-    }
-
-    #[allow(unused_variables, unused_mut)]
-    fn on_mount(
-        &mut self,
-        state: &mut Self::State,
-        mut children: Children<'_, '_>,
-        mut context: Context<'_, '_, Self::State>,
-    ) {
-    }
-
-    #[allow(unused_variables, unused_mut)]
-    fn on_unmount(
-        &mut self,
-        state: &mut Self::State,
-        mut children: Children<'_, '_>,
-        mut context: Context<'_, '_, Self::State>,
-    ) {
-    }
-
-    #[allow(unused_variables, unused_mut)]
-    fn on_blur(
-        &mut self,
-        state: &mut Self::State,
-        mut children: Children<'_, '_>,
-        mut context: Context<'_, '_, Self::State>,
-    ) {
-    }
-
-    #[allow(unused_variables, unused_mut)]
-    fn on_focus(
-        &mut self,
-        state: &mut Self::State,
-        mut children: Children<'_, '_>,
-        mut context: Context<'_, '_, Self::State>,
-    ) {
-    }
-
-    #[allow(unused_variables, unused_mut)]
-    fn on_mouse(
-        &mut self,
-        mouse: MouseEvent,
-        state: &mut Self::State,
-        mut children: Children<'_, '_>,
-        mut context: Context<'_, '_, Self::State>,
-    ) {
-    }
-
-    #[allow(unused_variables, unused_mut)]
-    fn on_tick(
-        &mut self,
-        state: &mut Self::State,
-        mut children: Children<'_, '_>,
-        context: Context<'_, '_, Self::State>,
-        dt: Duration,
-    ) {
-    }
-
-    #[allow(unused_variables, unused_mut)]
-    fn on_message(
-        &mut self,
-        message: Self::Message,
-        state: &mut Self::State,
-        mut children: Children<'_, '_>,
-        mut context: Context<'_, '_, Self::State>,
-    ) {
-    }
-
-    #[allow(unused_variables, unused_mut)]
-    fn on_resize(
-        &mut self,
-        state: &mut Self::State,
-        mut children: Children<'_, '_>,
-        mut context: Context<'_, '_, Self::State>,
-    ) {
-    }
-
-    #[allow(unused_variables, unused_mut)]
-    fn on_event(
-        &mut self,
-        event: &mut UserEvent<'_>,
-        state: &mut Self::State,
-        mut children: Children<'_, '_>,
-        mut context: Context<'_, '_, Self::State>,
-    ) {
-    }
-
-    fn accept_focus(&self) -> bool {
-        true
-    }
-}
-
-impl Component for () {
-    type Message = ();
-    type State = ();
-
-    const TICKS: bool = false;
-
-    fn accept_focus(&self) -> bool {
-        false
-    }
-}
-
-#[derive(Debug)]
-pub enum ComponentKind {
-    Instance,
-    Prototype,
-}
-
-pub trait AnyComponent {
-    fn any_event(&mut self, children: Children<'_, '_>, ctx: AnyComponentContext<'_, '_>, ev: Event) -> Event;
-
-    fn any_message(&mut self, children: Children<'_, '_>, ctx: AnyComponentContext<'_, '_>, message: Box<dyn Any>);
-
-    fn any_tick(&mut self, children: Children<'_, '_>, ctx: AnyComponentContext<'_, '_>, dt: Duration);
-
-    fn any_focus(&mut self, children: Children<'_, '_>, ctx: AnyComponentContext<'_, '_>);
-
-    fn any_blur(&mut self, children: Children<'_, '_>, ctx: AnyComponentContext<'_, '_>);
-
-    fn any_resize(&mut self, children: Children<'_, '_>, ctx: AnyComponentContext<'_, '_>);
-
-    fn any_component_event(
-        &mut self,
-        children: Children<'_, '_>,
-        ctx: AnyComponentContext<'_, '_>,
-        value: &mut UserEvent<'_>,
-    );
-
-    fn any_accept_focus(&self) -> bool;
-
-    fn any_ticks(&self) -> bool;
-}
-
-impl<T> AnyComponent for T
-where
-    T: Component,
-    T: 'static,
-{
-    fn any_event(&mut self, children: Children<'_, '_>, mut ctx: AnyComponentContext<'_, '_>, event: Event) -> Event {
-        let mut state = ctx
-            .state
-            .take()
-            .map(|s| s.to_mut_cast::<T::State>())
-            .expect("components always have a state");
-        let context = Context::<T::State>::new(ctx);
-        match event {
-            Event::Blur | Event::Focus => (), // Application focus, not component focus.
-            Event::Key(ev) => self.on_key(ev, &mut *state, children, context),
-            Event::Mouse(ev) => self.on_mouse(ev, &mut *state, children, context),
-            Event::Tick(dt) => self.on_tick(&mut *state, children, context, dt),
-            Event::Resize(_) => self.on_resize(&mut *state, children, context),
-            Event::Mount => self.on_mount(&mut *state, children, context),
-            Event::Unmount => self.on_unmount(&mut *state, children, context),
-            Event::Noop | Event::Stop => (),
-        }
-        event
-    }
-
-    fn any_accept_focus(&self) -> bool {
-        self.accept_focus()
-    }
-
-    fn any_ticks(&self) -> bool {
-        T::TICKS
-    }
-
-    fn any_message(&mut self, children: Children<'_, '_>, mut ctx: AnyComponentContext<'_, '_>, message: Box<dyn Any>) {
-        let mut state = ctx
-            .state
-            .take()
-            .map(|s| s.to_mut_cast::<T::State>())
-            .expect("components always have a state");
-        let Ok(message) = message.downcast::<T::Message>() else { return };
-        let context = Context::<T::State>::new(ctx);
-        self.on_message(*message, &mut *state, children, context);
-    }
-
-    fn any_focus(&mut self, children: Children<'_, '_>, mut ctx: AnyComponentContext<'_, '_>) {
-        let mut state = ctx
-            .state
-            .take()
-            .map(|s| s.to_mut_cast::<T::State>())
-            .expect("components always have a state");
-        let context = Context::<T::State>::new(ctx);
-        self.on_focus(&mut *state, children, context);
-    }
-
-    fn any_blur(&mut self, children: Children<'_, '_>, mut ctx: AnyComponentContext<'_, '_>) {
-        let mut state = ctx
-            .state
-            .take()
-            .map(|s| s.to_mut_cast::<T::State>())
-            .expect("components always have a state");
-        let context = Context::<T::State>::new(ctx);
-        self.on_blur(&mut *state, children, context);
-    }
-
-    fn any_tick(&mut self, children: Children<'_, '_>, mut ctx: AnyComponentContext<'_, '_>, dt: Duration) {
-        let mut state = ctx
-            .state
-            .take()
-            .map(|s| s.to_mut_cast::<T::State>())
-            .expect("components always have a state");
-        let context = Context::<T::State>::new(ctx);
-        self.on_tick(&mut *state, children, context, dt);
-    }
-
-    fn any_resize(&mut self, children: Children<'_, '_>, mut ctx: AnyComponentContext<'_, '_>) {
-        let mut state = ctx
-            .state
-            .take()
-            .map(|s| s.to_mut_cast::<T::State>())
-            .expect("components always have a state");
-        let context = Context::<T::State>::new(ctx);
-        self.on_resize(&mut *state, children, context);
-    }
-
-    fn any_component_event(
-        &mut self,
-        children: Children<'_, '_>,
-        mut ctx: AnyComponentContext<'_, '_>,
-        event: &mut UserEvent<'_>,
-    ) {
-        let mut state = ctx
-            .state
-            .take()
-            .map(|s| s.to_mut_cast::<T::State>())
-            .expect("components always have a state");
-
-        let context = Context::<T::State>::new(ctx);
-
-        self.on_event(event, &mut *state, children, context);
-    }
-}
-
-impl std::fmt::Debug for dyn AnyComponent {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "<dyn AnyComponent>")
-    }
-}
diff --git a/anathema-widgets/src/container.rs b/anathema-widgets/src/container.rs
deleted file mode 100644
index a101cf52..00000000
--- a/anathema-widgets/src/container.rs
+++ /dev/null
@@ -1,168 +0,0 @@
-use anathema_geometry::{LocalPos, Pos, Region, Size};
-use anathema_value_resolver::AttributeStorage;
-
-use crate::error::Result;
-use crate::layout::{Constraints, LayoutCtx, PositionCtx, PositionFilter, Viewport};
-use crate::nodes::element::Layout;
-use crate::paint::{Glyphs, PaintCtx, Unsized};
-use crate::widget::{AnyWidget, ForEach};
-use crate::{LayoutForEach, PaintChildren, Style, WidgetId};
-
-#[derive(Debug, PartialEq)]
-pub struct Cache {
-    pub(super) size: Size,
-    pub(super) pos: Option<Pos>,
-    constraints: Constraints,
-    pub(super) child_count: usize,
-    valid: bool,
-}
-
-impl Cache {
-    pub(crate) const ZERO: Self = Self {
-        size: Size::ZERO,
-        pos: None,
-        // Constraints are `None` for the root node
-        constraints: Constraints::ZERO,
-        child_count: 0,
-        valid: false,
-    };
-
-    const fn new(size: Size, constraints: Constraints) -> Self {
-        Self {
-            size,
-            pos: None,
-            constraints,
-            child_count: 0,
-            valid: true,
-        }
-    }
-
-    // Get the size if the constraints are matching, but only
-    // if the size is not max, as that would be an invalid cache
-    pub(super) fn size(&self) -> Option<Size> {
-        self.valid.then_some(self.size)
-    }
-
-    fn changed(&mut self, mut cache: Cache) -> bool {
-        let changed = self.size != cache.size;
-        cache.child_count = self.child_count;
-        *self = cache;
-        changed
-    }
-
-    pub fn constraints(&self) -> Constraints {
-        self.constraints
-    }
-}
-
-/// Wraps a widget and retain some geometry for the widget
-#[derive(Debug)]
-pub(crate) struct Container {
-    pub inner: Box<dyn AnyWidget>,
-    pub id: WidgetId,
-    pub inner_bounds: Region,
-    pub(super) cache: Cache,
-}
-
-impl Container {
-    pub(crate) fn layout<'bp>(
-        &mut self,
-        children: LayoutForEach<'_, 'bp>,
-        constraints: Constraints,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-    ) -> Result<Layout> {
-        let size = self.inner.any_layout(children, constraints, self.id, ctx)?;
-        let cache = Cache::new(size, constraints);
-
-        let changed = self.cache.changed(cache);
-
-        // Floating widgets always report a zero size
-        // as they should not affect their parents
-        if self.inner.any_floats() {
-            return Ok(Layout::Unchanged(Size::ZERO));
-        }
-
-        // If the layout is changed but the widget is floating it will
-        // have no impact on the parent widget
-        let layout = match changed {
-            true => match self.inner.any_floats() {
-                false => Layout::Changed(self.cache.size),
-                true => Layout::Floating(self.cache.size),
-            },
-            false => Layout::Unchanged(self.cache.size),
-        };
-
-        Ok(layout)
-    }
-
-    pub(crate) fn position<'bp>(
-        &mut self,
-        children: ForEach<'_, 'bp, PositionFilter>,
-        pos: Pos,
-        attribute_storage: &AttributeStorage<'bp>,
-        viewport: Viewport,
-    ) {
-        if self.cache.size().is_none() {
-            return;
-        }
-
-        let pos = *self.cache.pos.get_or_insert(pos);
-
-        let ctx = PositionCtx {
-            inner_size: self.cache.size,
-            pos,
-            viewport,
-        };
-        self.inner.any_position(children, self.id, attribute_storage, ctx);
-        self.inner_bounds = self.inner.any_inner_bounds(pos, self.cache.size);
-    }
-
-    pub(crate) fn paint<'bp>(
-        &mut self,
-        children: PaintChildren<'_, 'bp>,
-        ctx: PaintCtx<'_, Unsized>,
-        attribute_storage: &AttributeStorage<'bp>,
-    ) {
-        if self.cache.size().is_none() {
-            return;
-        }
-
-        let mut ctx = ctx.into_sized(self.cache.size, self.cache.pos.expect("only paint laid-out widgets"));
-        let region = ctx.create_region();
-        ctx.set_clip_region(region);
-
-        let attributes = attribute_storage.get(self.id);
-
-        if !self.inner.any_floats() {
-            let style = Style::from_cell_attribs(attributes);
-            // Apply all attributes to the widget
-            // as long as it's **not** a floating widget.
-            for y in 0..self.cache.size.height {
-                for x in 0..self.cache.size.width {
-                    let pos = LocalPos::new(x, y);
-                    ctx.set_style(style, pos);
-                }
-            }
-
-            if let Some(fill) = attributes.get("fill") {
-                for y in 0..ctx.local_size.height {
-                    let mut used_width = 0;
-                    while used_width < ctx.local_size.width {
-                        let pos = LocalPos::new(used_width, y);
-
-                        fill.strings(|s| {
-                            let glyphs = Glyphs::new(s);
-                            let Some(p) = ctx.place_glyphs(glyphs, pos) else {
-                                return false;
-                            };
-                            used_width = p.x;
-                            true
-                        });
-                    }
-                }
-            }
-        }
-
-        self.inner.any_paint(children, self.id, attribute_storage, ctx)
-    }
-}
diff --git a/anathema-widgets/src/error.rs b/anathema-widgets/src/error.rs
deleted file mode 100644
index 6bb76b48..00000000
--- a/anathema-widgets/src/error.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-use std::fmt::Display;
-use std::path::PathBuf;
-
-pub type Result<T, E = Error> = std::result::Result<T, E>;
-
-#[derive(Debug)]
-pub struct Error {
-    pub kind: ErrorKind,
-    pub path: Option<PathBuf>,
-}
-
-impl Error {
-    pub(crate) fn transaction_failed() -> Self {
-        Self {
-            kind: ErrorKind::TreeTransactionFailed,
-            path: None,
-        }
-    }
-}
-
-impl Display for Error {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        self.kind.fmt(f)
-    }
-}
-
-#[derive(Debug)]
-pub enum ErrorKind {
-    InvalidElement(String),
-    TreeTransactionFailed,
-    ComponentConsumed(String),
-}
-
-impl Display for ErrorKind {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            ErrorKind::InvalidElement(el) => write!(f, "element `{el}` does not exist"),
-            ErrorKind::TreeTransactionFailed => write!(
-                f,
-                "failed to insert into the widget tree (most likely the parent was removed)"
-            ),
-            ErrorKind::ComponentConsumed(name) => write!(f, "`@{name}` has already been used"),
-        }
-    }
-}
-
-impl std::error::Error for Error {}
diff --git a/anathema-widgets/src/layout/constraints.rs b/anathema-widgets/src/layout/constraints.rs
deleted file mode 100644
index 224400ff..00000000
--- a/anathema-widgets/src/layout/constraints.rs
+++ /dev/null
@@ -1,218 +0,0 @@
-use anathema_geometry::Region;
-
-use crate::layout::Size;
-
-/// `Constraints` are used to ensure that a widget doesn't size it self outside of a set of given bounds.
-/// A constraint can be tight, meaning then minimum and maximum width / height are the same.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct Constraints {
-    /// Minimum width.
-    pub min_width: u16,
-    /// Minimum height.
-    pub min_height: u16,
-    /// Max width.
-    max_width: u16,
-    /// Max height.
-    max_height: u16,
-}
-
-impl Constraints {
-    pub const MAX: Self = Self {
-        min_width: u16::MAX,
-        min_height: u16::MAX,
-        max_width: u16::MAX,
-        max_height: u16::MAX,
-    };
-    pub const ZERO: Self = Self {
-        min_width: 0,
-        min_height: 0,
-        max_width: 0,
-        max_height: 0,
-    };
-
-    pub fn max_height(&self) -> u16 {
-        self.max_height
-    }
-
-    pub fn max_width(&self) -> u16 {
-        self.max_width
-    }
-
-    /// Subtract `width` from the max width, as long
-    /// as the width isn't unbounded.
-    pub fn sub_max_width(&mut self, width: u16) {
-        if self.max_width < u16::MAX {
-            self.max_width = self.max_width.saturating_sub(width);
-            self.min_width = self.min_width.min(self.max_width);
-        }
-    }
-
-    /// Subtract `height` from the max height, as long
-    /// as the height isn't unbounded.
-    pub fn sub_max_height(&mut self, height: u16) {
-        if self.max_height < u16::MAX {
-            self.max_height = self.max_height.saturating_sub(height);
-            self.min_height = self.min_height.min(self.max_height);
-        }
-    }
-
-    /// Create a set of constraints with a given max width / height.
-    /// If `None` is passed for either `max_width` and / or `max_height` then this is qualified as
-    /// "unbounded" constraints.
-    ///
-    /// The `min_width` and `min_height` are zero by default.
-    ///
-    /// If the `min_width` and the `max_width` are the same the constraints are considered "tight".
-    pub fn new(max_width: impl Into<Option<u16>>, max_height: impl Into<Option<u16>>) -> Self {
-        let max_width = max_width.into().unwrap_or(u16::MAX);
-        let max_height = max_height.into().unwrap_or(u16::MAX);
-        Self {
-            min_width: 0,
-            min_height: 0,
-            max_width,
-            max_height,
-        }
-    }
-
-    /// Create unbounded constraints.
-    pub fn unbounded() -> Self {
-        Self {
-            min_width: 0,
-            min_height: 0,
-            max_width: u16::MAX,
-            max_height: u16::MAX,
-        }
-    }
-
-    /// Create unbounded height
-    pub fn unbound_height(&mut self) {
-        self.max_height = u16::MAX;
-    }
-
-    /// Create unbounded width
-    pub fn unbound_width(&mut self) {
-        self.max_width = u16::MAX;
-    }
-
-    /// Returns true if the width and height is unbounded.
-    pub fn is_unbounded(&self) -> bool {
-        self.is_width_unbounded() && self.is_height_unbounded()
-    }
-
-    /// Returns true if the width is unbounded.
-    pub fn is_width_unbounded(&self) -> bool {
-        self.max_width == u16::MAX
-    }
-
-    /// Returns true if the height is unbounded.
-    pub fn is_height_unbounded(&self) -> bool {
-        self.max_height == u16::MAX
-    }
-
-    /// Returns true if the `min_width` and `max_width` are the same.
-    pub fn is_width_tight(&self) -> bool {
-        self.max_width == self.min_width
-    }
-
-    /// Returns true if the `min_height` and `max_height` are the same.
-    pub fn is_height_tight(&self) -> bool {
-        self.max_height == self.min_height
-    }
-
-    /// Make the width constraint tight.
-    /// ```
-    /// # use anathema_widgets::layout::Constraints;
-    /// let mut constraints = Constraints::new(10, 10);
-    /// constraints.make_width_tight(constraints.max_width());
-    /// # assert_eq!(constraints.min_width, constraints.max_width());
-    /// ```
-    pub fn make_width_tight(&mut self, width: u16) {
-        self.max_width = self.max_width.min(width);
-        self.min_width = self.max_width;
-    }
-
-    /// Make the height constraint tight.
-    /// ```
-    /// # use anathema_widgets::layout::Constraints;
-    /// let mut constraints = Constraints::new(10, 10);
-    /// constraints.make_height_tight(constraints.max_height());
-    /// # assert_eq!(constraints.min_height, constraints.max_height());
-    /// ```
-    pub fn make_height_tight(&mut self, height: u16) {
-        self.max_height = self.max_height.min(height);
-        self.min_height = self.max_height;
-    }
-
-    pub fn expand_horz(&mut self, mut size: Size) -> Size {
-        size.width = self.max_width;
-        size
-    }
-
-    pub fn expand_vert(&mut self, mut size: Size) -> Size {
-        size.height = self.max_height;
-        size
-    }
-
-    pub fn expand_all(&mut self, mut size: Size) -> Size {
-        size = self.expand_horz(size);
-        self.expand_vert(size)
-    }
-
-    /// This function does not verify anything, but simply
-    /// sets the max width.
-    /// There is no check to see if the max width is smaller than the min width here.
-    pub fn set_max_width(&mut self, width: u16) {
-        self.max_width = width;
-    }
-
-    /// This function does not verify anything, but simply
-    /// sets the max height.
-    /// There is no check to see if the max height is smaller than the min height here.
-    pub fn set_max_height(&mut self, height: u16) {
-        self.max_height = height;
-    }
-
-    pub fn div_assign_max_width(mut self, count: u16, overflow: u16) -> Self {
-        let width = self.max_width / count + overflow;
-        self.make_width_tight(width);
-        self
-    }
-
-    pub fn div_assign_max_height(mut self, count: u16, overflow: u16) -> Self {
-        let height = self.max_height / count + overflow;
-        self.make_height_tight(height);
-        self
-    }
-
-    /// If either the max width or max height are
-    /// zero then nothing can be laid out within
-    /// the given constraint.
-    pub fn has_zero_dimension(&self) -> bool {
-        self.max_width == 0 || self.max_height == 0
-    }
-
-    /// Get a size from the max width / height
-    pub fn max_size(&self) -> Size {
-        (self.max_width, self.max_height).into()
-    }
-}
-
-impl From<Size> for Constraints {
-    fn from(value: Size) -> Self {
-        Self::new(value.width, value.height)
-    }
-}
-
-impl From<Region> for Constraints {
-    fn from(value: Region) -> Self {
-        let width = value.to.x - value.from.x;
-        let height = value.to.y - value.from.y;
-        Self::new(width as u16, height as u16)
-    }
-}
-
-impl Default for Constraints {
-    fn default() -> Self {
-        Self::ZERO
-    }
-}
diff --git a/anathema-widgets/src/layout/display.rs b/anathema-widgets/src/layout/display.rs
deleted file mode 100644
index f7b56be5..00000000
--- a/anathema-widgets/src/layout/display.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-use anathema_value_resolver::ValueKind;
-
-pub const DISPLAY: &str = "display";
-
-#[derive(Debug, Copy, Clone, Default, PartialEq)]
-pub enum Display {
-    #[default]
-    Show,
-    Hide,
-    Exclude,
-}
-
-impl TryFrom<&ValueKind<'_>> for Display {
-    type Error = ();
-
-    fn try_from(value: &ValueKind<'_>) -> Result<Self, Self::Error> {
-        let Some(s) = value.as_str() else { return Err(()) };
-        let disp = match s {
-            "show" => Self::Show,
-            "hide" => Self::Hide,
-            "exclude" => Self::Exclude,
-            _ => return Err(()),
-        };
-        Ok(disp)
-    }
-}
-
-impl From<Display> for ValueKind<'_> {
-    fn from(value: Display) -> Self {
-        let value = match value {
-            Display::Show => "show",
-            Display::Hide => "hide",
-            Display::Exclude => "exclude",
-        };
-        ValueKind::Str(value.into())
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use anathema_value_resolver::Attributes;
-
-    use super::*;
-
-    #[test]
-    fn to_and_from_attributes() {
-        let mut attribs = Attributes::empty();
-        attribs.set("disp", Display::Show);
-        assert_eq!(Display::Show, attribs.get_as::<Display>("disp").unwrap());
-
-        attribs.set("disp", Display::Hide);
-        assert_eq!(Display::Hide, attribs.get_as::<Display>("disp").unwrap());
-
-        attribs.set("disp", Display::Exclude);
-        assert_eq!(Display::Exclude, attribs.get_as::<Display>("disp").unwrap());
-    }
-}
diff --git a/anathema-widgets/src/layout/mod.rs b/anathema-widgets/src/layout/mod.rs
deleted file mode 100644
index 70115479..00000000
--- a/anathema-widgets/src/layout/mod.rs
+++ /dev/null
@@ -1,294 +0,0 @@
-use anathema_geometry::{Pos, Region, Size};
-use anathema_state::{State, StateId, States};
-use anathema_store::tree::TreeView;
-use anathema_templates::{ComponentBlueprintId, Variables};
-use anathema_value_resolver::{AttributeStorage, Attributes, FunctionTable};
-use display::DISPLAY;
-
-pub use self::constraints::Constraints;
-pub use self::display::Display;
-use crate::components::{AnyComponent, ComponentKind, ComponentRegistry};
-use crate::error::{Error, ErrorKind};
-use crate::nodes::element::Element;
-use crate::tree::{FilterOutput, WidgetPositionFilter};
-use crate::{Components, Factory, FloatingWidgets, GlyphMap, WidgetContainer, WidgetId, WidgetKind};
-
-mod constraints;
-pub mod display;
-pub mod text;
-
-pub struct LayoutCtx<'frame, 'bp> {
-    pub states: &'frame mut States,
-    pub(super) globals: &'bp Variables,
-    factory: &'frame Factory,
-    pub attribute_storage: &'frame mut AttributeStorage<'bp>,
-    pub components: &'frame mut Components,
-    pub glyph_map: &'frame mut GlyphMap,
-    pub viewport: &'frame mut Viewport,
-
-    // Need these for the eval context
-    pub floating_widgets: &'frame mut FloatingWidgets,
-    pub component_registry: &'frame mut ComponentRegistry,
-    pub new_components: Vec<(WidgetId, StateId)>,
-    pub stop_runtime: bool,
-    pub(super) function_table: &'bp FunctionTable,
-}
-
-impl<'frame, 'bp> LayoutCtx<'frame, 'bp> {
-    pub fn new(
-        globals: &'bp Variables,
-        factory: &'frame Factory,
-        states: &'frame mut States,
-        attribute_storage: &'frame mut AttributeStorage<'bp>,
-        components: &'frame mut Components,
-        component_registry: &'frame mut ComponentRegistry,
-        floating_widgets: &'frame mut FloatingWidgets,
-        glyph_map: &'frame mut GlyphMap,
-        viewport: &'frame mut Viewport,
-        function_table: &'bp FunctionTable,
-    ) -> Self {
-        Self {
-            states,
-            attribute_storage,
-            components,
-            component_registry,
-            globals,
-            factory,
-            floating_widgets,
-            glyph_map,
-            viewport,
-            new_components: vec![],
-            stop_runtime: false,
-            function_table,
-        }
-    }
-
-    pub fn attributes(&self, node_id: WidgetId) -> &Attributes<'bp> {
-        self.attribute_storage.get(node_id)
-    }
-
-    pub fn eval_ctx(
-        &mut self,
-        parent_component: Option<WidgetId>,
-        parent_element: Option<WidgetId>,
-    ) -> EvalCtx<'_, 'bp> {
-        EvalCtx {
-            floating_widgets: self.floating_widgets,
-            attribute_storage: self.attribute_storage,
-            states: self.states,
-            component_registry: self.component_registry,
-            components: self.components,
-            globals: self.globals,
-            factory: self.factory,
-            parent_component,
-            parent_widget: parent_element,
-            new_components: &mut self.new_components,
-            function_table: self.function_table,
-        }
-    }
-
-    pub(crate) fn truncate_children(&mut self, tree: &mut TreeView<'_, WidgetContainer<'bp>>) {
-        tree.truncate_children(&mut |widget| {
-            self.return_component(widget);
-        });
-    }
-
-    pub(crate) fn relative_remove(&mut self, path: &[u16], mut tree: TreeView<'_, WidgetContainer<'bp>>) {
-        tree.relative_remove(path, &mut |widget| {
-            self.return_component(widget);
-        });
-    }
-
-    fn return_component(&mut self, widget: WidgetContainer<'_>) {
-        let WidgetKind::Component(comp) = widget.kind else { return };
-        self.components.try_remove(comp.widget_id);
-        let id = comp.component_id;
-        let state = self.states.remove(comp.state_id).take();
-        self.component_registry.return_component(id, comp.dyn_component, state);
-    }
-}
-
-pub struct EvalCtx<'frame, 'bp> {
-    pub(super) new_components: &'frame mut Vec<(WidgetId, StateId)>,
-    pub(super) floating_widgets: &'frame mut FloatingWidgets,
-    pub(super) attribute_storage: &'frame mut AttributeStorage<'bp>,
-    pub(super) states: &'frame mut States,
-    component_registry: &'frame mut ComponentRegistry,
-    pub(super) components: &'frame mut Components,
-    pub(super) globals: &'bp Variables,
-    pub(super) factory: &'frame Factory,
-    pub(super) function_table: &'bp FunctionTable,
-    pub(super) parent_component: Option<WidgetId>,
-    pub(super) parent_widget: Option<WidgetId>,
-}
-
-impl<'frame, 'bp> EvalCtx<'frame, 'bp> {
-    pub(super) fn get_component(
-        &mut self,
-        component_id: ComponentBlueprintId,
-    ) -> Option<(ComponentKind, Box<dyn AnyComponent>, Box<dyn State>)> {
-        self.component_registry.get(component_id)
-    }
-
-    pub(crate) fn error(&self, kind: ErrorKind) -> Error {
-        Error { kind, path: None }
-    }
-}
-
-#[derive(Debug, Copy, Clone)]
-/// A viewport represents the available space in the root
-pub struct Viewport {
-    size: Size,
-}
-
-impl Viewport {
-    pub fn new(size: impl Into<Size>) -> Self {
-        let size = size.into();
-        Self { size }
-    }
-
-    pub fn size(&self) -> Size {
-        self.size
-    }
-
-    pub fn constraints(&self) -> Constraints {
-        Constraints::new(self.size.width, self.size.height)
-    }
-
-    pub fn resize(&mut self, size: Size) {
-        self.size = size;
-    }
-}
-
-#[derive(Debug, Copy, Clone)]
-pub struct LayoutFilter;
-
-impl<'bp> crate::widget::Filter<'bp> for LayoutFilter {
-    type Output = WidgetContainer<'bp>;
-
-    fn filter<'a>(
-        &mut self,
-        widget: &'a mut WidgetContainer<'bp>,
-        attribute_storage: &AttributeStorage<'_>,
-    ) -> FilterOutput<&'a mut Self::Output, Self> {
-        match &mut widget.kind {
-            WidgetKind::Element(element) => {
-                let attributes = attribute_storage.get(element.id());
-                match attributes.get_as::<Display>(DISPLAY).unwrap_or_default() {
-                    Display::Show | Display::Hide => FilterOutput::Include(widget, *self),
-                    Display::Exclude => FilterOutput::Exclude,
-                }
-            }
-            _ => FilterOutput::Continue,
-        }
-    }
-}
-
-#[derive(Debug, Copy, Clone)]
-pub struct PositionCtx {
-    pub inner_size: Size,
-    pub pos: Pos,
-    pub viewport: Viewport,
-}
-
-impl PositionCtx {
-    pub fn region(&self) -> Region {
-        Region::from((self.pos, self.inner_size))
-    }
-}
-
-#[derive(Debug, Copy, Clone)]
-pub struct PositionFilter(WidgetPositionFilter);
-
-impl PositionFilter {
-    pub fn fixed() -> Self {
-        Self(WidgetPositionFilter::Fixed)
-    }
-
-    pub fn floating() -> Self {
-        Self(WidgetPositionFilter::Floating)
-    }
-
-    pub fn all() -> Self {
-        Self(WidgetPositionFilter::All)
-    }
-
-    pub fn none() -> Self {
-        Self(WidgetPositionFilter::None)
-    }
-}
-
-impl<'bp> crate::widget::Filter<'bp> for PositionFilter {
-    type Output = Element<'bp>;
-
-    fn filter<'a>(
-        &mut self,
-        widget: &'a mut WidgetContainer<'bp>,
-        attribute_storage: &AttributeStorage<'_>,
-    ) -> FilterOutput<&'a mut Self::Output, Self> {
-        match &mut widget.kind {
-            WidgetKind::Element(element) => {
-                let attributes = attribute_storage.get(element.id());
-                match attributes.get_as::<Display>(DISPLAY).unwrap_or_default() {
-                    Display::Show => match self.0 {
-                        WidgetPositionFilter::Floating => match element.is_floating() {
-                            true => FilterOutput::Include(element, Self::all()),
-                            false => FilterOutput::Continue,
-                        },
-                        WidgetPositionFilter::Fixed => match element.is_floating() {
-                            false => FilterOutput::Include(element, *self),
-                            true => FilterOutput::Include(element, Self::none()),
-                        },
-                        WidgetPositionFilter::All => FilterOutput::Include(element, *self),
-                        WidgetPositionFilter::None => FilterOutput::Exclude,
-                    },
-                    Display::Hide | Display::Exclude => FilterOutput::Exclude,
-                }
-            }
-            _ => FilterOutput::Continue,
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::ops::ControlFlow;
-
-    use super::*;
-    use crate::widget::ForEach;
-
-    #[test]
-    fn filter_floating_positioning() {
-        let tpl = "
-        many
-            many
-                many
-                // --------------------
-                float                //
-                    text             // <- only these
-                        text         // <------------
-                            float    //
-                                text //
-                // --------------------
-                many
-            many
-                many
-                    many
-        ";
-
-        let mut expected = vec!["float", "text", "text", "float", "text"];
-        crate::testing::with_template(tpl, move |tree, attributes| {
-            let filter = PositionFilter::floating();
-            let children = ForEach::new(tree, attributes, filter);
-            recur(children, &mut expected);
-        });
-
-        fn recur(mut f: ForEach<'_, '_, PositionFilter>, expected: &mut Vec<&'static str>) {
-            _ = f.each(|el, nodes| {
-                assert_eq!(expected.remove(0), el.ident);
-                recur(nodes, expected);
-                ControlFlow::Continue(())
-            });
-        }
-    }
-}
diff --git a/anathema-widgets/src/layout/text.rs b/anathema-widgets/src/layout/text.rs
deleted file mode 100644
index a0b81ce7..00000000
--- a/anathema-widgets/src/layout/text.rs
+++ /dev/null
@@ -1,536 +0,0 @@
-use std::ops::{AddAssign, Deref};
-
-use anathema_geometry::Size;
-use anathema_store::tree::ValueId;
-use anathema_value_resolver::ValueKind;
-use unicode_width::{UnicodeWidthChar, UnicodeWidthStr};
-
-use crate::WidgetId;
-
-/// Word wrapping strategy
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Default)]
-pub enum Wrap {
-    /// Normal word wrapping. This will break text on hyphen and whitespace.
-    /// Trailing whitespace is consumed if it would cause a line break.
-    #[default]
-    Normal,
-    /// Insert a newline in the middle of any text
-    WordBreak,
-}
-
-impl Wrap {
-    /// Returns true if word wrapping is enabled (self == Self::Normal)
-    pub fn is_word_wrap(&self) -> bool {
-        matches!(self, Self::Normal)
-    }
-}
-
-impl TryFrom<&ValueKind<'_>> for Wrap {
-    type Error = ();
-
-    fn try_from(value: &ValueKind<'_>) -> Result<Self, Self::Error> {
-        let s = value.as_str().ok_or(())?;
-        match s {
-            "normal" => Ok(Wrap::Normal),
-            "break" => Ok(Wrap::WordBreak),
-            _ => Err(()),
-        }
-    }
-}
-
-impl From<Wrap> for ValueKind<'_> {
-    fn from(value: Wrap) -> Self {
-        let value = match value {
-            Wrap::Normal => "normal",
-            Wrap::WordBreak => "break",
-        };
-
-        ValueKind::Str(value.into())
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct LineWidth(u16);
-
-impl LineWidth {
-    pub(crate) const ZERO: Self = Self(0);
-
-    // update the current value and return the old value
-    pub(crate) fn swap(&mut self, mut new_value: u16) -> u16 {
-        std::mem::swap(&mut self.0, &mut new_value);
-        new_value
-    }
-}
-
-impl Default for LineWidth {
-    fn default() -> Self {
-        LineWidth::ZERO
-    }
-}
-
-impl Deref for LineWidth {
-    type Target = u16;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl AddAssign<u16> for LineWidth {
-    fn add_assign(&mut self, rhs: u16) {
-        self.0 += rhs;
-    }
-}
-
-/// The process result dictates whether it's possible to
-/// fit more text or not.
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub enum ProcessResult {
-    /// Continue means it's possible to process more text
-    Continue,
-    /// Break means that there is no more room for text and
-    /// further processing should be avoided
-    Break,
-}
-
-#[derive(Debug, Copy, Clone)]
-pub(crate) enum Entry {
-    Newline,
-    LineWidth(u16),
-    Style(ValueId),
-}
-
-/// Represents a line containing the width and the segments
-#[derive(Debug)]
-pub struct Line<I> {
-    pub width: u16,
-    pub entries: I,
-}
-
-/// A line segment.
-#[derive(Debug)]
-pub enum Segment<'a> {
-    /// Set the style
-    SetStyle(ValueId),
-    /// String slice
-    Str(&'a str),
-}
-
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub(crate) enum LineEntry {
-    Width(u16),
-    Str(u32, u32),
-    SetStyle(ValueId),
-    Newline,
-}
-
-/// Perform text layout
-/// ```
-/// # use anathema_widgets::layout::text::*;
-/// # use anathema_geometry::Size;
-///
-/// let mut text = Strings::new(Size::new(10, 10), Wrap::Normal);
-/// text.add_str("he");
-/// text.add_str("ll");
-/// text.add_str("o world");
-/// let size = text.finish();
-///
-/// let lines = text.lines();
-/// ```
-#[derive(Debug)]
-pub struct Strings {
-    layout: Vec<(u32, Entry)>,
-    lines: Vec<LineEntry>,
-    chomper: Chomper,
-    frozen: bool,
-    bytes: Vec<u8>,
-    max: Size,
-    size: Size,
-    wrap: Wrap,
-    // Byte index where the current line starts
-    line: usize,
-    current_width: LineWidth,
-}
-
-impl Strings {
-    pub fn new(max: Size, wrap: Wrap) -> Self {
-        Self {
-            layout: vec![],
-            lines: vec![],
-            chomper: Chomper::Continuous(0),
-            frozen: false,
-            bytes: vec![],
-            max,
-            wrap,
-            size: Size::new(0, 1),
-            line: 0,
-            current_width: LineWidth::ZERO,
-        }
-    }
-
-    /// Layout another string slice.
-    pub fn add_str(&mut self, s: &str) -> ProcessResult {
-        if self.max.height == 0 || self.max.width == 0 {
-            return ProcessResult::Break;
-        }
-
-        if self.frozen {
-            return ProcessResult::Break;
-        }
-
-        for word in s.split_inclusive(char::is_whitespace) {
-            self.bytes.extend(word.bytes());
-            for c in word.chars() {
-                if let res @ ProcessResult::Break = self.chomp(c) {
-                    self.bytes.truncate(self.chomper.index());
-                    self.freeze();
-                    return res;
-                }
-            }
-        }
-
-        ProcessResult::Continue
-    }
-
-    /// Access the laid out strings.
-    /// See [`Strings`] for example.
-    pub fn lines(&self) -> impl Iterator<Item = Line<impl Iterator<Item = Segment<'_>>>> {
-        let lines = self.lines.split(|e| *e == LineEntry::Newline);
-
-        lines.map(|entries| {
-            let LineEntry::Width(width) = entries[0] else { unreachable!() };
-
-            Line {
-                width,
-                entries: entries[1..].iter().map(|e| match e {
-                    LineEntry::Str(from, to) => Segment::Str(
-                        std::str::from_utf8(&self.bytes[*from as usize..*to as usize])
-                            .expect("only strings written to the byte store"),
-                    ),
-                    LineEntry::SetStyle(style) => Segment::SetStyle(*style),
-                    LineEntry::Width(_) | LineEntry::Newline => unreachable!("consumed already"),
-                }),
-            }
-        })
-    }
-
-    pub fn set_style(&mut self, style: WidgetId) {
-        let index = self.bytes.len();
-        self.layout.push((index as u32, Entry::Style(style)));
-    }
-
-    /// Finalize the layout, converting entries to lines
-    pub fn finish(&mut self) -> Size {
-        self.frozen = true;
-        self.layout.sort_by(|a, b| a.0.cmp(&b.0));
-
-        let last_line = self.line(self.bytes.len());
-        let last_line_width = last_line.width();
-        self.layout
-            .push((self.bytes.len() as u32, Entry::LineWidth(last_line_width as u16)));
-
-        // Write the entries as lines
-        let mut from = 0;
-        for line in self.layout.split(|e| matches!(e.1, Entry::Newline)) {
-            // Find the line width (always the last entry)
-            let width = match line.last() {
-                Some((_, Entry::LineWidth(w))) => *w,
-                _ => unreachable!("the last entry is always the line width"),
-            };
-
-            self.lines.push(LineEntry::Width(width));
-
-            for (i, entry) in line {
-                // Don't bother adding a string entry for an empty string
-                if from != *i {
-                    self.lines.push(LineEntry::Str(from, *i));
-                }
-
-                from = *i;
-
-                match entry {
-                    Entry::Style(style) => self.lines.push(LineEntry::SetStyle(*style)),
-                    Entry::LineWidth(_) => {}
-                    Entry::Newline => unreachable!("consumed by the split"),
-                }
-            }
-            self.lines.push(LineEntry::Newline);
-        }
-
-        self.lines.pop();
-
-        self.update_width();
-        if self.size.width == 0 {
-            self.size = Size::ZERO;
-        }
-        self.size
-    }
-
-    fn freeze(&mut self) {
-        self.frozen = true;
-    }
-
-    fn newline(&mut self) {
-        self.size.height += 1;
-        self.update_width();
-        self.line = match self.chomper {
-            Chomper::Continuous(idx) => {
-                self.layout.push((idx, Entry::LineWidth(self.current_width.swap(0))));
-                self.layout.push((idx, Entry::Newline));
-                idx as usize
-            }
-            Chomper::WordBoundary {
-                word_boundary,
-                current_index,
-            } => {
-                let diff =
-                    (self.line(current_index as usize).width() - self.line(word_boundary as usize).width()) as u16;
-                let width = *self.current_width - diff;
-                self.layout.push((word_boundary, Entry::LineWidth(width)));
-                self.layout.push((word_boundary, Entry::Newline));
-                let _ = self.current_width.swap(diff);
-                self.chomper = Chomper::Continuous(current_index);
-                word_boundary as usize
-            }
-        };
-    }
-
-    fn line(&self, index: usize) -> &str {
-        self.str(self.line, index)
-    }
-
-    fn str(&self, offset: usize, index: usize) -> &str {
-        std::str::from_utf8(&self.bytes[offset..index]).expect("only valid strings here")
-    }
-
-    fn update_width(&mut self) {
-        self.size.width = self.size.width.max(*self.current_width);
-    }
-
-    fn chomp(&mut self, c: char) -> ProcessResult {
-        let width = c.width().unwrap_or(0) as u16;
-
-        // NOTE
-        // Special case: the character is too wide to ever fit so it's removed,
-        // e.g a character width of two with a max width of one.
-        if width > self.max.width {
-            for _ in 0..c.len_utf8() {
-                self.bytes.pop();
-            }
-            return ProcessResult::Continue;
-        }
-
-        // NOTE
-        // If newline characters are handled then pop the bytes and insert a newline
-        if c == '\n' {
-            self.bytes.pop();
-
-            if self.size.height >= self.max.height {
-                return ProcessResult::Break;
-            }
-
-            self.chomper.force_word_boundary();
-            self.newline();
-            return ProcessResult::Continue;
-        }
-
-        // NOTE
-        // If the trailing whitespace should be removed, do so here
-        while width + *self.current_width > self.max.width {
-            if c.is_whitespace() {
-                // 1. Make this the next word boundary
-                // 2. Insert a newline here
-                // 3. Remove the bytes representing this whitespace
-
-                for _ in 0..c.len_utf8() {
-                    self.bytes.pop();
-                }
-
-                self.chomper.force_word_boundary();
-                self.newline();
-
-                return ProcessResult::Continue;
-            }
-
-            if self.size.height >= self.max.height {
-                return ProcessResult::Break;
-            }
-
-            self.newline();
-        }
-
-        self.chomper.chomp(c, self.wrap);
-        self.current_width += width;
-
-        ProcessResult::Continue
-    }
-}
-
-impl Default for Strings {
-    fn default() -> Self {
-        Self::new(Size::ZERO, Wrap::default())
-    }
-}
-
-#[derive(Debug)]
-pub(crate) enum Chomper {
-    Continuous(u32),
-    WordBoundary { word_boundary: u32, current_index: u32 },
-}
-
-impl Chomper {
-    pub(crate) fn index(&self) -> usize {
-        match self {
-            Chomper::Continuous(current_index) | Chomper::WordBoundary { current_index, .. } => *current_index as usize,
-        }
-    }
-
-    pub(crate) fn force_word_boundary(&mut self) {
-        if let Chomper::WordBoundary {
-            word_boundary,
-            current_index,
-        } = self
-        {
-            *word_boundary = *current_index;
-        }
-    }
-
-    pub(crate) fn chomp(&mut self, c: char, wrap: Wrap) {
-        let c_len = c.len_utf8() as u32;
-
-        if c.is_whitespace() && wrap.is_word_wrap() {
-            match self {
-                Chomper::Continuous(idx) | Chomper::WordBoundary { current_index: idx, .. } => {
-                    let new_index = *idx + c_len;
-                    *self = Self::WordBoundary {
-                        word_boundary: new_index,
-                        current_index: new_index,
-                    };
-                    return;
-                }
-            }
-        }
-
-        match self {
-            Self::Continuous(idx) => *idx += c_len,
-            Self::WordBoundary { current_index, .. } => *current_index += c_len,
-        }
-    }
-}
-
-impl Default for Chomper {
-    fn default() -> Self {
-        Chomper::Continuous(0)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    fn test_layout(max: Size, input: &[&str], expected: &str, wrap: Wrap) {
-        let mut strings = Strings::new(max, wrap);
-
-        for i in input {
-            if let ProcessResult::Break = strings.add_str(i) {
-                break;
-            }
-        }
-
-        let _size = strings.finish();
-
-        let lines = strings.lines();
-
-        let mut output = String::new();
-        for line in lines {
-            for e in line.entries {
-                match e {
-                    Segment::SetStyle(_) => todo!(),
-                    Segment::Str(s) => output.push_str(s),
-                }
-            }
-            output.push('\n');
-        }
-        output.pop();
-
-        assert_eq!(&output, expected);
-    }
-
-    #[test]
-    fn word_wrapping_layout() {
-        let inputs: &[(&[&str], &str)] = &[
-            (&["a\nb\nc"], "a\nb\nc"),
-            (&[" 12", "345 12", "345 "], " \n12345\n12345\n"),
-            (&[" 12", "345　12", "345 "], " \n12345\n12345\n"),
-            (&[" 🐇🐇🐇", "🐇🐇 12", "345 "], " \n🐇🐇\n🐇🐇\n🐇 \n12345\n"),
-            (&["1", "23", "45 12", "345 "], "12345\n12345\n"),
-            (&["12345 abcde "], "12345\nabcde\n"),
-            (&["onereallylongword"], "onere\nallyl\nongwo\nrd"),
-            (&["ahello do the"], "ahell\no do \nthe"),
-            (&["hello do the"], "hello\ndo \nthe"),
-        ];
-
-        for (input, expected) in inputs {
-            test_layout(Size::new(5, 10), input, expected, Wrap::Normal);
-        }
-    }
-
-    #[test]
-    fn outliers() {
-        let inputs: &[(&[&str], &str)] = &[
-            (&["🐇"], ""),
-            (&["\n"], "\n"),
-            (&["\n\n\n"], "\n\n\n"),
-            (&["abc"], "a\nb\nc"),
-        ];
-
-        for (input, expected) in inputs {
-            test_layout(Size::new(1, 10), input, expected, Wrap::Normal);
-        }
-    }
-
-    #[test]
-    fn layout_size() {
-        let inputs: &[(&[&str], &str)] = &[(&["123456789"], "123\n456")];
-
-        for (input, expected) in inputs {
-            test_layout(Size::new(3, 2), input, expected, Wrap::Normal);
-        }
-    }
-
-    #[test]
-    fn word_breaking_layout() {
-        let inputs: &[(&[&str], &str)] = &[(&["123 4567"], "123 4\n567")];
-
-        for (input, expected) in inputs {
-            test_layout(Size::new(5, 3), input, expected, Wrap::WordBreak);
-        }
-    }
-
-    #[test]
-    fn freeze_layout() {
-        let mut strings = Strings::new(Size::new(100, 10), Wrap::Normal);
-
-        assert_eq!(strings.add_str("abc"), ProcessResult::Continue);
-        strings.freeze();
-        assert_eq!(strings.add_str("abc"), ProcessResult::Break);
-    }
-
-    #[test]
-    fn limited_space() {
-        test_layout(Size::new(58, 0), &["meh"], "", Wrap::Normal);
-    }
-
-    #[test]
-    fn wrap_from_attribute() {
-        let mut attributes = anathema_value_resolver::Attributes::empty();
-
-        attributes.set("break", Wrap::WordBreak);
-        let word_break = attributes.get_as::<Wrap>("break").unwrap();
-        assert_eq!(word_break, Wrap::WordBreak);
-
-        attributes.set("normal", Wrap::Normal);
-        let word_break = attributes.get_as::<Wrap>("normal").unwrap();
-        assert_eq!(word_break, Wrap::Normal);
-    }
-}
diff --git a/anathema-widgets/src/lib.rs b/anathema-widgets/src/lib.rs
index 1aa280e7..8d7ccb7d 100644
--- a/anathema-widgets/src/lib.rs
+++ b/anathema-widgets/src/lib.rs
@@ -1,27 +1,8 @@
-use anathema_state::Subscriber;
+use anathema_core::runtime::RegisteredWidgets;
+pub use border::{border, Border};
 
-pub use crate::nodes::component::Component;
-pub use crate::nodes::element::Layout;
-pub use crate::nodes::{Element, WidgetContainer, WidgetGenerator, WidgetKind, eval_blueprint, update_widget};
-pub use crate::paint::{GlyphMap, WidgetRenderer};
-pub use crate::widget::{
-    AnyWidget, Attributes, ComponentParents, Components, DirtyWidgets, Factory, FloatingWidgets, ForEach,
-    LayoutChildren, LayoutForEach, PaintChildren, PositionChildren, Style, Widget, WidgetId, WidgetTree,
-    WidgetTreeView,
-};
+mod border;
 
-pub type ChangeList = anathema_store::regionlist::RegionList<32, WidgetId, Subscriber>;
-
-pub mod components;
-mod container;
-pub mod error;
-pub mod layout;
-mod nodes;
-pub mod paint;
-pub mod query;
-pub mod tabindex;
-pub mod tree;
-mod widget;
-
-#[cfg(test)]
-mod testing;
+pub fn register_default_widgets(factory: &mut RegisteredWidgets) {
+    factory.register_default::<Border>("border");
+}
diff --git a/anathema-widgets/src/nodes/component.rs b/anathema-widgets/src/nodes/component.rs
deleted file mode 100644
index 5fdc0433..00000000
--- a/anathema-widgets/src/nodes/component.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-use anathema_state::StateId;
-use anathema_store::storage::strings::StringId;
-use anathema_templates::blueprints::Blueprint;
-use anathema_templates::{AssocEventMapping, ComponentBlueprintId};
-
-use crate::WidgetId;
-use crate::components::{AnyComponent, ComponentKind};
-
-#[derive(Debug)]
-pub struct Component<'bp> {
-    pub name: &'bp str,
-    pub name_id: StringId,
-    pub body: &'bp [Blueprint],
-    pub dyn_component: Box<dyn AnyComponent>,
-    pub state_id: StateId,
-    /// Used to identify the component in the component registry.
-    /// This id will not be unique for prototypes
-    pub component_id: ComponentBlueprintId,
-    pub widget_id: WidgetId,
-    pub parent: Option<WidgetId>,
-    pub kind: ComponentKind,
-    pub assoc_functions: &'bp [AssocEventMapping],
-    pub tabindex: u16,
-}
-
-impl<'bp> Component<'bp> {
-    pub fn new(
-        name: &'bp str,
-        name_id: StringId,
-        body: &'bp [Blueprint],
-        dyn_component: Box<dyn AnyComponent>,
-        state_id: StateId,
-        component_id: ComponentBlueprintId,
-        widget_id: WidgetId,
-        kind: ComponentKind,
-        assoc_functions: &'bp [AssocEventMapping],
-        parent: Option<WidgetId>,
-    ) -> Self {
-        Self {
-            name,
-            name_id,
-            body,
-            dyn_component,
-            state_id,
-            component_id,
-            widget_id,
-            kind,
-            assoc_functions,
-            parent,
-            tabindex: 0,
-        }
-    }
-
-    pub(crate) fn state_id(&self) -> StateId {
-        self.state_id
-    }
-}
diff --git a/anathema-widgets/src/nodes/controlflow.rs b/anathema-widgets/src/nodes/controlflow.rs
deleted file mode 100644
index 5408fa4f..00000000
--- a/anathema-widgets/src/nodes/controlflow.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-use anathema_state::Change;
-use anathema_templates::blueprints::Blueprint;
-use anathema_value_resolver::Value;
-
-use crate::layout::LayoutCtx;
-use crate::widget::WidgetTreeView;
-use crate::{DirtyWidgets, WidgetId};
-
-#[derive(Debug)]
-pub struct ControlFlow<'bp> {
-    pub elses: Vec<Else<'bp>>,
-}
-
-impl<'bp> ControlFlow<'bp> {
-    pub(crate) fn update(
-        &mut self,
-        change: &Change,
-        branch_id: u16,
-        mut tree: WidgetTreeView<'_, 'bp>,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-        parent_widget: Option<WidgetId>,
-        dirty_widgets: &mut DirtyWidgets,
-    ) {
-        match change {
-            Change::Changed | Change::Dropped => {
-                let Some(el) = self.elses.get_mut(branch_id as usize) else { return };
-                let Some(cond) = el.cond.as_mut() else { return };
-                let current = cond.truthiness();
-                cond.reload(ctx.attribute_storage);
-                if cond.truthiness() != current {
-                    ctx.truncate_children(&mut tree);
-
-                    if let Some(widget) = parent_widget {
-                        dirty_widgets.push(widget);
-                    }
-                }
-            }
-            // TODO:
-            // this could probably happen given something like this
-            // ```
-            // if state.list
-            //     text "list is not empty"
-            // ```
-            Change::Inserted(_) | Change::Removed(_) => todo!(),
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Else<'bp> {
-    pub cond: Option<Value<'bp>>,
-    pub body: &'bp [Blueprint],
-    pub show: bool,
-}
-
-impl Else<'_> {
-    pub(crate) fn is_true(&self) -> bool {
-        match self.cond.as_ref() {
-            Some(cond) => cond.truthiness(),
-            None => true,
-        }
-    }
-}
diff --git a/anathema-widgets/src/nodes/element.rs b/anathema-widgets/src/nodes/element.rs
deleted file mode 100644
index acf70223..00000000
--- a/anathema-widgets/src/nodes/element.rs
+++ /dev/null
@@ -1,147 +0,0 @@
-use anathema_geometry::{Pos, Region, Size};
-use anathema_value_resolver::AttributeStorage;
-
-use crate::container::Container;
-use crate::error::Result;
-use crate::layout::{Constraints, LayoutCtx, PositionFilter, Viewport};
-use crate::paint::{PaintCtx, PaintFilter, Unsized};
-use crate::widget::ForEach;
-use crate::{LayoutForEach, WidgetId};
-
-pub enum Layout {
-    Changed(Size),
-    Unchanged(Size),
-    Floating(Size),
-}
-
-impl From<Layout> for Size {
-    fn from(value: Layout) -> Self {
-        match value {
-            Layout::Changed(size) | Layout::Unchanged(size) | Layout::Floating(size) => size,
-        }
-    }
-}
-
-// TODO
-// Merge the `Element` and the `Container` into one type
-#[derive(Debug)]
-pub struct Element<'bp> {
-    pub ident: &'bp str,
-    pub(crate) container: Container,
-}
-
-impl<'bp> Element<'bp> {
-    pub fn id(&self) -> WidgetId {
-        self.container.id
-    }
-
-    pub(crate) fn new(ident: &'bp str, container: Container) -> Self {
-        Self { ident, container }
-    }
-
-    pub fn layout(
-        &mut self,
-        children: LayoutForEach<'_, 'bp>,
-        constraints: Constraints,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-    ) -> Result<Layout> {
-        #[cfg(feature = "profile")]
-        puffin::profile_function!();
-        self.container.layout(children, constraints, ctx)
-    }
-
-    // pub fn invalidate_cache(&mut self) {
-    //     self.container.cache.invalidate();
-    // }
-
-    /// Position the element
-    pub fn position(
-        &mut self,
-        children: ForEach<'_, 'bp, PositionFilter>,
-        pos: Pos,
-        attribute_storage: &AttributeStorage<'bp>,
-        viewport: Viewport,
-    ) {
-        self.container.position(children, pos, attribute_storage, viewport)
-    }
-
-    /// Draw an element to the surface
-    pub fn paint(
-        &mut self,
-        children: ForEach<'_, 'bp, PaintFilter>,
-        ctx: PaintCtx<'_, Unsized>,
-        attribute_storage: &AttributeStorage<'bp>,
-    ) {
-        self.container.paint(children, ctx, attribute_storage);
-    }
-
-    /// Return the cached size if the constraints are matching
-    /// the cached constraints.
-    pub fn cached_size(&self) -> Option<Size> {
-        self.container.cache.size()
-    }
-
-    pub fn size(&self) -> Size {
-        self.container.cache.size
-    }
-
-    /// Inner bounds in global space
-    pub fn inner_bounds(&self) -> Region {
-        self.container.inner_bounds
-    }
-
-    /// Bounds in global space
-    pub fn bounds(&self) -> Region {
-        let pos = self.pos();
-        let size = self.size();
-        Region::from((pos, size))
-    }
-
-    /// Get a mutable reference to the underlying widget of the given type
-    ///
-    /// # Panics
-    ///
-    /// Panics if the element is of a different type
-    pub fn to<T: 'static>(&mut self) -> &mut T {
-        self.try_to().expect("wrong element type")
-    }
-
-    /// Get a mutable reference to the underlying widget of the given type
-    pub fn try_to<T: 'static>(&mut self) -> Option<&mut T> {
-        self.container.inner.to_any_mut().downcast_mut::<T>()
-    }
-
-    /// Get a reference to the underlying widget of the given type
-    ///
-    /// # Panics
-    ///
-    /// Panics if the element is of a different type
-    pub fn to_ref<T: 'static>(&self) -> &T {
-        self.try_to_ref().expect("wrong element type")
-    }
-
-    /// Get a reference to the underlying widget of the given type
-    pub fn try_to_ref<T: 'static>(&self) -> Option<&T> {
-        self.container.inner.to_any_ref().downcast_ref::<T>()
-    }
-
-    /// Get the position of the container.
-    pub fn pos(&self) -> Pos {
-        self.container.cache.pos.unwrap_or(Pos::ZERO)
-    }
-
-    /// Get the position of the container.
-    #[deprecated(note = "use `pos` instead")]
-    pub fn get_pos(&self) -> Pos {
-        self.container.cache.pos.unwrap_or(Pos::ZERO)
-    }
-
-    /// Returns true if the widget is a floating widget
-    pub(crate) fn is_floating(&self) -> bool {
-        self.container.inner.any_floats()
-    }
-
-    pub fn constraints(&self) -> Constraints {
-        self.container.cache.constraints()
-    }
-}
diff --git a/anathema-widgets/src/nodes/eval.rs b/anathema-widgets/src/nodes/eval.rs
deleted file mode 100644
index 5a150e47..00000000
--- a/anathema-widgets/src/nodes/eval.rs
+++ /dev/null
@@ -1,332 +0,0 @@
-use anathema_geometry::Region;
-use anathema_state::Subscriber;
-use anathema_store::slab::SlabIndex;
-use anathema_store::smallmap::SmallIndex;
-use anathema_templates::blueprints::{Blueprint, Component, ControlFlow, For, Single, With};
-use anathema_value_resolver::{Attributes, ResolverCtx, Scope, ValueKey, resolve, resolve_collection};
-
-use super::element::Element;
-use super::{WidgetContainer, component, controlflow};
-use crate::WidgetKind;
-use crate::container::{Cache, Container};
-use crate::error::{ErrorKind, Result};
-use crate::layout::EvalCtx;
-use crate::widget::WidgetTreeView;
-
-/// Evaluate a node kind
-pub(super) trait Evaluator {
-    type Input<'bp>;
-
-    fn eval<'bp>(
-        &mut self,
-        input: Self::Input<'bp>,
-        context: &mut EvalCtx<'_, 'bp>,
-        scope: &Scope<'_, 'bp>,
-        parent: &[u16],
-        tree: &mut WidgetTreeView<'_, 'bp>,
-    ) -> Result<()>;
-}
-
-pub(super) struct SingleEval;
-
-impl Evaluator for SingleEval {
-    type Input<'bp> = &'bp Single;
-
-    fn eval<'bp>(
-        &mut self,
-        single: Self::Input<'bp>,
-        ctx: &mut EvalCtx<'_, 'bp>,
-        scope: &Scope<'_, 'bp>,
-        parent: &[u16],
-        tree: &mut WidgetTreeView<'_, 'bp>,
-    ) -> Result<()> {
-        let transaction = tree.insert(parent);
-        let widget_id = transaction.node_id();
-
-        // -----------------------------------------------------------------------------
-        //   - New api -
-        // -----------------------------------------------------------------------------
-        let mut attributes = Attributes::empty();
-
-        if let Some(expr) = single.value.as_ref() {
-            let ctx = ResolverCtx::new(
-                ctx.globals,
-                scope,
-                ctx.states,
-                ctx.attribute_storage,
-                ctx.function_table,
-            );
-
-            let value = attributes.insert_with(ValueKey::Value, |value_index| {
-                resolve(expr, &ctx, (widget_id, value_index))
-            });
-            attributes.value = Some(value);
-        }
-
-        for (key, expr) in single.attributes.iter() {
-            attributes.insert_with(ValueKey::Attribute(key), |value_index| {
-                let ctx = ResolverCtx::new(
-                    ctx.globals,
-                    scope,
-                    ctx.states,
-                    ctx.attribute_storage,
-                    ctx.function_table,
-                );
-                resolve(expr, &ctx, (widget_id, value_index))
-            });
-        }
-
-        let widget = match ctx.factory.make(&single.ident, &attributes) {
-            Ok(widget) => widget,
-            Err(e) => return Err(ctx.error(e)),
-        };
-
-        // Is the widget a floating widget?
-        if widget.any_floats() {
-            ctx.floating_widgets.insert(widget_id);
-        }
-
-        ctx.attribute_storage.insert(widget_id, attributes);
-
-        // Container
-        let container = Container {
-            inner: widget,
-            id: widget_id,
-            inner_bounds: Region::ZERO,
-            cache: Cache::ZERO,
-        };
-
-        // Widget
-        let widget = WidgetKind::Element(Element::new(&single.ident, container));
-        let widget = WidgetContainer::new(widget, &single.children, ctx.parent_widget);
-
-        transaction
-            .commit_child(widget)
-            .ok_or_else(|| ctx.error(ErrorKind::TreeTransactionFailed))?;
-
-        Ok(())
-    }
-}
-
-pub(super) struct ForLoopEval;
-
-impl Evaluator for ForLoopEval {
-    type Input<'bp> = &'bp For;
-
-    fn eval<'bp>(
-        &mut self,
-        for_loop: Self::Input<'bp>,
-        ctx: &mut EvalCtx<'_, 'bp>,
-        scope: &Scope<'_, 'bp>,
-        parent: &[u16],
-        tree: &mut WidgetTreeView<'_, 'bp>,
-    ) -> Result<()> {
-        let transaction = tree.insert(parent);
-        let value_id = Subscriber::from((transaction.node_id(), SmallIndex::ZERO));
-
-        let resolver_ctx = ResolverCtx::new(
-            ctx.globals,
-            scope,
-            ctx.states,
-            ctx.attribute_storage,
-            ctx.function_table,
-        );
-        let collection = resolve_collection(&for_loop.data, &resolver_ctx, value_id);
-
-        let for_loop = super::loops::For {
-            binding: &for_loop.binding,
-            body: &for_loop.body,
-            collection,
-        };
-
-        let body = for_loop.body;
-        let widget = WidgetKind::For(for_loop);
-        let widget = WidgetContainer::new(widget, body, ctx.parent_widget);
-        transaction
-            .commit_child(widget)
-            .ok_or_else(|| ctx.error(ErrorKind::TreeTransactionFailed))?;
-        Ok(())
-    }
-}
-
-pub(super) struct WithEval;
-
-impl Evaluator for WithEval {
-    type Input<'bp> = &'bp With;
-
-    fn eval<'bp>(
-        &mut self,
-        with: Self::Input<'bp>,
-        ctx: &mut EvalCtx<'_, 'bp>,
-        scope: &Scope<'_, 'bp>,
-        parent: &[u16],
-        tree: &mut WidgetTreeView<'_, 'bp>,
-    ) -> Result<()> {
-        let transaction = tree.insert(parent);
-        let value_id = Subscriber::from((transaction.node_id(), SmallIndex::ZERO));
-
-        let resolver_ctx = ResolverCtx::new(
-            ctx.globals,
-            scope,
-            ctx.states,
-            ctx.attribute_storage,
-            ctx.function_table,
-        );
-        let data = resolve(&with.data, &resolver_ctx, value_id);
-
-        let with = super::with::With {
-            binding: &with.binding,
-            body: &with.body,
-            data,
-        };
-
-        let body = with.body;
-        let widget = WidgetKind::With(with);
-        let widget = WidgetContainer::new(widget, body, ctx.parent_widget);
-        transaction
-            .commit_child(widget)
-            .ok_or_else(|| ctx.error(ErrorKind::TreeTransactionFailed))?;
-        Ok(())
-    }
-}
-
-pub(super) struct ControlFlowEval;
-
-impl Evaluator for ControlFlowEval {
-    type Input<'bp> = &'bp ControlFlow;
-
-    fn eval<'bp>(
-        &mut self,
-        control_flow: Self::Input<'bp>,
-        ctx: &mut EvalCtx<'_, 'bp>,
-        scope: &Scope<'_, 'bp>,
-        parent: &[u16],
-        tree: &mut WidgetTreeView<'_, 'bp>,
-    ) -> Result<()> {
-        let transaction = tree.insert(parent);
-        let widget_id = transaction.node_id();
-
-        let widget = WidgetKind::ControlFlow(controlflow::ControlFlow {
-            elses: control_flow
-                .elses
-                .iter()
-                .enumerate()
-                .map(|(i, e)| {
-                    let ctx = ResolverCtx::new(
-                        ctx.globals,
-                        scope,
-                        ctx.states,
-                        ctx.attribute_storage,
-                        ctx.function_table,
-                    );
-
-                    controlflow::Else {
-                        cond: e
-                            .cond
-                            .as_ref()
-                            .map(|cond| resolve(cond, &ctx, (widget_id, SmallIndex::from_usize(i)))),
-                        body: &e.body,
-                        show: false,
-                    }
-                })
-                .collect(),
-        });
-        let widget = WidgetContainer::new(widget, &[], ctx.parent_widget);
-        transaction
-            .commit_child(widget)
-            .ok_or_else(|| ctx.error(ErrorKind::TreeTransactionFailed))?;
-        Ok(())
-    }
-}
-
-pub(super) struct ComponentEval;
-
-impl Evaluator for ComponentEval {
-    type Input<'bp> = &'bp Component;
-
-    fn eval<'bp>(
-        &mut self,
-        input: Self::Input<'bp>,
-        ctx: &mut EvalCtx<'_, 'bp>,
-        scope: &Scope<'_, 'bp>,
-        parent: &[u16],
-        tree: &mut WidgetTreeView<'_, 'bp>,
-    ) -> Result<()> {
-        let transaction = tree.insert(parent);
-        let widget_id = transaction.node_id();
-
-        let mut attributes = Attributes::empty();
-
-        for (key, expr) in input.attributes.iter() {
-            attributes.insert_with(ValueKey::Attribute(key), |value_index| {
-                let ctx = ResolverCtx::new(
-                    ctx.globals,
-                    scope,
-                    ctx.states,
-                    ctx.attribute_storage,
-                    ctx.function_table,
-                );
-                resolve(expr, &ctx, (widget_id, value_index))
-            });
-        }
-
-        let component_id = usize::from(input.id).into();
-        ctx.attribute_storage.insert(widget_id, attributes);
-
-        // let (kind, component, state) = ctx.get_component(component_id);
-        let comp = ctx.get_component(component_id);
-        let (kind, component, state) = match comp {
-            Some(comp) => comp,
-            None => return Err(ctx.error(ErrorKind::ComponentConsumed(input.name.clone()))),
-        };
-
-        let state_id = ctx.states.insert(state);
-        let accept_ticks = component.any_ticks();
-
-        let comp_widget = component::Component::new(
-            &input.name,
-            input.name_id,
-            &input.body,
-            component,
-            state_id,
-            component_id,
-            widget_id,
-            kind,
-            &input.assoc_functions,
-            ctx.parent_component,
-        );
-
-        let widget = WidgetKind::Component(comp_widget);
-        let widget = WidgetContainer::new(widget, &input.body, ctx.parent_widget);
-        let widget_id = transaction
-            .commit_child(widget)
-            .ok_or_else(|| ctx.error(ErrorKind::TreeTransactionFailed))?;
-        ctx.new_components.push((widget_id, state_id));
-
-        ctx.components.push(component_id, widget_id, state_id, accept_ticks);
-
-        Ok(())
-    }
-}
-
-pub(super) struct SlotEval;
-
-impl Evaluator for SlotEval {
-    type Input<'bp> = &'bp [Blueprint];
-
-    fn eval<'bp>(
-        &mut self,
-        input: Self::Input<'bp>,
-        ctx: &mut EvalCtx<'_, 'bp>,
-        _: &Scope<'_, 'bp>,
-        parent: &[u16],
-        tree: &mut WidgetTreeView<'_, 'bp>,
-    ) -> Result<()> {
-        let transaction = tree.insert(parent);
-        let widget = WidgetContainer::new(WidgetKind::Slot, input, ctx.parent_widget);
-        transaction
-            .commit_child(widget)
-            .ok_or_else(|| ctx.error(ErrorKind::TreeTransactionFailed))?;
-        Ok(())
-    }
-}
diff --git a/anathema-widgets/src/nodes/loops.rs b/anathema-widgets/src/nodes/loops.rs
deleted file mode 100644
index 6e608cc7..00000000
--- a/anathema-widgets/src/nodes/loops.rs
+++ /dev/null
@@ -1,106 +0,0 @@
-use anathema_state::Change;
-use anathema_templates::blueprints::Blueprint;
-use anathema_value_resolver::Collection;
-
-use super::{WidgetContainer, WidgetKind};
-use crate::error::{Error, Result};
-use crate::layout::LayoutCtx;
-use crate::widget::WidgetTreeView;
-use crate::{DirtyWidgets, WidgetId};
-
-#[derive(Debug)]
-pub struct For<'bp> {
-    pub(crate) binding: &'bp str,
-    pub(crate) collection: Collection<'bp>,
-    pub(crate) body: &'bp [Blueprint],
-}
-
-impl<'bp> For<'bp> {
-    pub fn binding(&self) -> &'bp str {
-        self.binding
-    }
-
-    pub(super) fn update(
-        &mut self,
-        change: &Change,
-        mut tree: WidgetTreeView<'_, 'bp>,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-        parent_widget: Option<WidgetId>,
-        dirty_widgets: &mut DirtyWidgets,
-    ) -> Result<()> {
-        match change {
-            Change::Inserted(index) => {
-                // 1. Declare insert path
-                // 2. Create new iteration
-                // 3. Insert new iteration
-                // 4. Update index of all subsequent iterations
-
-                // ctx.scope.push();
-                // ctx.scope.scope_pending(self.binding, *value);
-
-                let path = [*index as u16];
-                let transaction = tree.insert(&path);
-                let widget = WidgetKind::Iteration(Iteration {
-                    loop_index: anathema_state::Value::new(*index as i64),
-                    binding: self.binding,
-                });
-                let widget = WidgetContainer::new(widget, self.body, parent_widget);
-                let _ = transaction.commit_at(widget).ok_or_else(Error::transaction_failed)?;
-
-                for child in &tree.layout[*index as usize + 1..] {
-                    let iter_widget = tree.values.get_mut(child.value());
-                    let Some((
-                        _,
-                        WidgetContainer {
-                            kind: WidgetKind::Iteration(iter),
-                            ..
-                        },
-                    )) = iter_widget
-                    else {
-                        unreachable!("this can only ever be an iteration")
-                    };
-                    *iter.loop_index.to_mut() += 1;
-                }
-            }
-            Change::Removed(index) => {
-                if let Some(widget) = parent_widget {
-                    dirty_widgets.push(widget);
-                }
-
-                for child in &tree.layout[*index as usize + 1..] {
-                    let iter_widget = tree.values.get_mut(child.value());
-                    let Some((
-                        _,
-                        WidgetContainer {
-                            kind: WidgetKind::Iteration(iter),
-                            ..
-                        },
-                    )) = iter_widget
-                    else {
-                        unreachable!("this can only ever be an iteration")
-                    };
-                    *iter.loop_index.to_mut() -= 1;
-                }
-
-                ctx.relative_remove(&[*index as u16], tree);
-            }
-            Change::Dropped | Change::Changed => {
-                // If the collection has changed to a different collection
-                // then truncate the tree
-                self.collection.reload(ctx.attribute_storage);
-                ctx.truncate_children(&mut tree);
-                if let Some(widget) = parent_widget {
-                    dirty_widgets.push(widget);
-                }
-            }
-        }
-
-        Ok(())
-    }
-}
-
-#[derive(Debug)]
-pub struct Iteration<'bp> {
-    pub loop_index: anathema_state::Value<i64>,
-    pub binding: &'bp str,
-}
diff --git a/anathema-widgets/src/nodes/mod.rs b/anathema-widgets/src/nodes/mod.rs
deleted file mode 100644
index bdb16fec..00000000
--- a/anathema-widgets/src/nodes/mod.rs
+++ /dev/null
@@ -1,78 +0,0 @@
-use anathema_templates::blueprints::Blueprint;
-use anathema_value_resolver::Scope;
-use eval::SlotEval;
-
-pub use self::element::Element;
-use self::eval::{ComponentEval, ControlFlowEval, Evaluator, ForLoopEval, SingleEval};
-pub use self::update::update_widget;
-use crate::WidgetId;
-use crate::error::Result;
-use crate::layout::EvalCtx;
-use crate::nodes::eval::WithEval;
-use crate::widget::WidgetTreeView;
-
-pub(crate) mod component;
-pub(crate) mod controlflow;
-pub(crate) mod element;
-pub(crate) mod eval;
-pub(crate) mod loops;
-mod update;
-pub(crate) mod with;
-
-// -----------------------------------------------------------------------------
-//   - Generators -
-// -----------------------------------------------------------------------------
-pub enum WidgetGenerator<'bp> {
-    Children(&'bp [Blueprint]),
-    Single,
-    Slot(&'bp [Blueprint]),
-    Loop(&'bp [Blueprint]),
-    ControlFlow,
-    Noop,
-}
-
-#[derive(Debug)]
-pub enum WidgetKind<'bp> {
-    Element(Element<'bp>),
-    For(loops::For<'bp>),
-    With(with::With<'bp>),
-    Iteration(loops::Iteration<'bp>),
-    ControlFlow(controlflow::ControlFlow<'bp>),
-    ControlFlowContainer(u16),
-    Component(component::Component<'bp>),
-    Slot,
-}
-
-#[derive(Debug)]
-pub struct WidgetContainer<'bp> {
-    pub kind: WidgetKind<'bp>,
-    pub(crate) children: &'bp [Blueprint],
-    pub parent_widget: Option<WidgetId>,
-}
-
-impl<'bp> WidgetContainer<'bp> {
-    pub fn new(kind: WidgetKind<'bp>, blueprints: &'bp [Blueprint], parent_widget: Option<WidgetId>) -> Self {
-        Self {
-            kind,
-            children: blueprints,
-            parent_widget,
-        }
-    }
-}
-
-pub fn eval_blueprint<'bp>(
-    blueprint: &'bp Blueprint,
-    ctx: &mut EvalCtx<'_, 'bp>,
-    scope: &Scope<'_, 'bp>,
-    parent: &[u16],
-    tree: &mut WidgetTreeView<'_, 'bp>,
-) -> Result<()> {
-    match blueprint {
-        Blueprint::Single(single) => SingleEval.eval(single, ctx, scope, parent, tree),
-        Blueprint::For(for_loop) => ForLoopEval.eval(for_loop, ctx, scope, parent, tree),
-        Blueprint::With(with) => WithEval.eval(with, ctx, scope, parent, tree),
-        Blueprint::ControlFlow(flow) => ControlFlowEval.eval(flow, ctx, scope, parent, tree),
-        Blueprint::Component(component) => ComponentEval.eval(component, ctx, scope, parent, tree),
-        Blueprint::Slot(blueprints) => SlotEval.eval(blueprints, ctx, scope, parent, tree),
-    }
-}
diff --git a/anathema-widgets/src/nodes/stringify.rs b/anathema-widgets/src/nodes/stringify.rs
deleted file mode 100644
index c6a16791..00000000
--- a/anathema-widgets/src/nodes/stringify.rs
+++ /dev/null
@@ -1,104 +0,0 @@
-use std::fmt::Write;
-use std::ops::ControlFlow;
-
-use anathema_store::tree::visitor::NodeVisitor;
-use anathema_store::tree::ValueId;
-use anathema_value_resolver::AttributeStorage;
-
-use super::element::Element;
-use super::WidgetContainer;
-use crate::WidgetKind;
-
-/// Stringify the tree.
-/// Used for debugging
-pub struct Stringify<'a, 'bp> {
-    level: usize,
-    indent: String,
-    output: String,
-    attribute_storage: &'a AttributeStorage<'bp>,
-}
-
-impl<'a, 'bp> Stringify<'a, 'bp> {
-    pub fn new(attribute_storage: &'a AttributeStorage<'bp>) -> Self {
-        Self {
-            level: 0,
-            indent: String::new(),
-            output: String::new(),
-            attribute_storage,
-        }
-    }
-
-    pub fn finish(self) -> String {
-        self.output
-    }
-}
-
-impl<'a, 'bp> NodeVisitor<WidgetContainer<'_>> for Stringify<'a, 'bp> {
-    fn visit(&mut self, value: &mut WidgetContainer<'_>, _path: &[u16], _: ValueId) -> ControlFlow<bool> {
-        let _ = write!(&mut self.output, "{}", self.indent);
-        match &value.kind {
-            WidgetKind::Element(Element { ident, container, .. }) => {
-                let _ = write!(&mut self.output, "{ident}");
-
-                let attribs = self.attribute_storage.get(container.id);
-                let attrib_count = attribs.iter().count();
-                if attrib_count > 0 {
-                    // Print attributes
-                    let _ = write!(&mut self.output, "[");
-                    for (i, (key, val)) in attribs.iter().enumerate() {
-                        // Write a comma before the values if this is not the first entry
-                        if i > 0 {
-                            let _ = write!(&mut self.output, ", ");
-                        }
-                        let _ = write!(&mut self.output, "{}: {:?}", key.as_str(), val);
-                    }
-                    let _ = write!(&mut self.output, "]");
-                }
-
-                if let Some(val) = attribs.value() {
-                    let _ = write!(&mut self.output, " {:?}", val);
-                }
-            }
-            WidgetKind::For(_) => drop(write!(&mut self.output, "<for>")),
-            WidgetKind::Iteration(iteration) => {
-                let _ = write!(
-                    &mut self.output,
-                    "<iter binding = {}, index = {}>",
-                    iteration.binding,
-                    iteration.loop_index.copy_value()
-                );
-            }
-            WidgetKind::ControlFlow(_) => {
-                let _ = write!(&mut self.output, "<control flow>");
-            }
-            WidgetKind::ControlFlowContainer(id) => {
-                let _ = write!(&mut self.output, "<control flow container {id}>");
-            }
-            // WidgetKind::If(if_widget) => {
-            //     let _ = write!(&mut self.output, "<if cond = {}>", if_widget.cond.load_bool());
-            // }
-            // WidgetKind::Else(if_widget) => match &if_widget.cond {
-            //     Some(cond) => {
-            //         let _ = write!(&mut self.output, "<else cond = {}>", cond.load_bool());
-            //     }
-            //     None => drop(write!(&mut self.output, "<else>")),
-            // },
-            WidgetKind::Component(_) => drop(write!(&mut self.output, "<component>")),
-            WidgetKind::Slot => todo!(),
-        }
-
-        let _ = writeln!(&mut self.output);
-
-        ControlFlow::Continue(())
-    }
-
-    fn push(&mut self) {
-        self.level += 1;
-        self.indent = " ".repeat(self.level * 4);
-    }
-
-    fn pop(&mut self) {
-        self.level -= 1;
-        self.indent = " ".repeat(self.level * 4);
-    }
-}
diff --git a/anathema-widgets/src/nodes/update.rs b/anathema-widgets/src/nodes/update.rs
deleted file mode 100644
index 714723b1..00000000
--- a/anathema-widgets/src/nodes/update.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-use anathema_state::{Change, Subscriber};
-
-use super::WidgetContainer;
-use crate::error::Result;
-use crate::layout::LayoutCtx;
-use crate::widget::WidgetTreeView;
-use crate::{DirtyWidgets, WidgetKind};
-
-pub fn update_widget<'bp>(
-    widget: &mut WidgetContainer<'bp>,
-    value_id: Subscriber,
-    change: &Change,
-    tree: WidgetTreeView<'_, 'bp>,
-    ctx: &mut LayoutCtx<'_, 'bp>,
-    dirty_widgets: &mut DirtyWidgets,
-) -> Result<()> {
-    match &mut widget.kind {
-        WidgetKind::Element(element) => {
-            ctx.attribute_storage.with_mut(element.id(), |attributes, storage| {
-                let Some(value) = attributes.get_mut_with_index(value_id.index()) else { return };
-                value.reload(storage);
-                dirty_widgets.push(element.id());
-            });
-
-            if let Change::Dropped = change {
-                // TODO: Is there anything that needs to be done here given that the value will
-            }
-        }
-        WidgetKind::For(for_loop) => for_loop.update(change, tree, ctx, widget.parent_widget, dirty_widgets)?,
-        WidgetKind::With(with) => with.update(change, tree, ctx.attribute_storage)?,
-        WidgetKind::Iteration(_) => todo!(),
-        WidgetKind::ControlFlow(controlflow) => controlflow.update(
-            change,
-            value_id.index().into(),
-            tree,
-            ctx,
-            widget.parent_widget,
-            dirty_widgets,
-        ),
-        WidgetKind::ControlFlowContainer(_) => unreachable!("control flow containers have no values"),
-        WidgetKind::Component(_) => (),
-        WidgetKind::Slot => todo!(),
-    }
-
-    Ok(())
-}
diff --git a/anathema-widgets/src/nodes/with.rs b/anathema-widgets/src/nodes/with.rs
deleted file mode 100644
index ee25df7b..00000000
--- a/anathema-widgets/src/nodes/with.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-use anathema_state::Change;
-use anathema_templates::blueprints::Blueprint;
-use anathema_value_resolver::{AttributeStorage, Value};
-
-use crate::error::Result;
-use crate::widget::WidgetTreeView;
-
-#[derive(Debug)]
-pub struct With<'bp> {
-    pub(crate) binding: &'bp str,
-    pub(crate) data: Value<'bp>,
-    pub(crate) body: &'bp [Blueprint],
-}
-
-impl<'bp> With<'bp> {
-    pub fn binding(&self) -> &'bp str {
-        self.binding
-    }
-
-    pub(super) fn update(
-        &mut self,
-        change: &Change,
-        _: WidgetTreeView<'_, 'bp>,
-        attribute_storage: &mut AttributeStorage<'bp>,
-    ) -> Result<()> {
-        match change {
-            Change::Dropped | Change::Changed => {
-                self.data.reload(attribute_storage);
-            }
-            _ => {}
-        }
-
-        Ok(())
-    }
-}
diff --git a/anathema-widgets/src/paint.rs b/anathema-widgets/src/paint.rs
deleted file mode 100644
index d86494a9..00000000
--- a/anathema-widgets/src/paint.rs
+++ /dev/null
@@ -1,382 +0,0 @@
-use std::ops::{ControlFlow, Deref};
-
-use anathema_geometry::{LocalPos, Pos, Region, Size};
-use anathema_store::indexmap::IndexMap;
-use anathema_store::slab::SlabIndex;
-use anathema_value_resolver::{AttributeStorage, Attributes};
-use unicode_segmentation::{Graphemes, UnicodeSegmentation};
-use unicode_width::{UnicodeWidthChar, UnicodeWidthStr};
-
-use crate::layout::Display;
-use crate::layout::display::DISPLAY;
-use crate::nodes::element::Element;
-use crate::tree::{FilterOutput, WidgetPositionFilter};
-use crate::widget::Style;
-use crate::{PaintChildren, WidgetContainer, WidgetKind};
-
-pub type GlyphMap = IndexMap<GlyphIndex, String>;
-
-pub struct Glyphs<'a> {
-    inner: Graphemes<'a>,
-}
-
-impl<'a> Glyphs<'a> {
-    pub fn new(src: &'a str) -> Self {
-        let inner = src.graphemes(true);
-        Self { inner }
-    }
-
-    pub fn next(&mut self, map: &mut GlyphMap) -> Option<Glyph> {
-        let g = self.inner.next()?;
-        let mut chars = g.chars();
-        let c = chars.next()?;
-
-        match chars.next() {
-            None => Glyph::Single(c, c.width().unwrap_or(0) as u8),
-            Some(_) => {
-                let width = g.width();
-                let glyph = map.insert(g.into());
-                Glyph::Cluster(glyph, width as u8)
-            }
-        }
-        .into()
-    }
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub enum Glyph {
-    // Character and the number of cells it occypies
-    Single(char, u8),
-    // Glyph index and the number of cells it occypies
-    Cluster(GlyphIndex, u8),
-}
-
-impl Glyph {
-    pub fn space() -> Self {
-        Self::Single(' ', 1)
-    }
-
-    pub fn is_newline(&self) -> bool {
-        matches!(self, Self::Single('\n', _))
-    }
-
-    pub fn width(&self) -> usize {
-        match self {
-            Glyph::Single(_, width) | Glyph::Cluster(_, width) => *width as usize,
-        }
-    }
-
-    pub const fn from_char(c: char, width: u8) -> Self {
-        Self::Single(c, width)
-    }
-}
-
-pub trait WidgetRenderer {
-    fn draw_glyph(&mut self, glyph: Glyph, local_pos: Pos);
-
-    fn draw(&mut self) {
-        todo!(
-            "this function is only here to remind us that we should have a raw draw function for Kitty image protocol and such"
-        );
-    }
-
-    fn set_attributes(&mut self, attribs: &Attributes<'_>, local_pos: Pos);
-
-    fn set_style(&mut self, style: Style, local_pos: Pos);
-
-    fn size(&self) -> Size;
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Hash, Eq)]
-pub struct GlyphIndex(u32);
-
-impl SlabIndex for GlyphIndex {
-    const MAX: usize = u32::MAX as usize;
-
-    fn as_usize(&self) -> usize {
-        self.0 as usize
-    }
-
-    fn from_usize(index: usize) -> Self
-    where
-        Self: Sized,
-    {
-        Self(index as u32)
-    }
-}
-
-#[derive(Debug, Copy, Clone)]
-pub struct PaintFilter(WidgetPositionFilter);
-
-impl PaintFilter {
-    pub fn fixed() -> Self {
-        Self(WidgetPositionFilter::Fixed)
-    }
-
-    pub fn floating() -> Self {
-        Self(WidgetPositionFilter::Floating)
-    }
-}
-
-impl<'bp> crate::widget::Filter<'bp> for PaintFilter {
-    type Output = Element<'bp>;
-
-    fn filter<'a>(
-        &mut self,
-        widget: &'a mut WidgetContainer<'bp>,
-        attribute_storage: &AttributeStorage<'_>,
-    ) -> FilterOutput<&'a mut Self::Output, Self> {
-        match &mut widget.kind {
-            WidgetKind::Element(element) => {
-                let attributes = attribute_storage.get(element.id());
-                match attributes.get_as::<Display>(DISPLAY).unwrap_or_default() {
-                    Display::Show => match self.0 {
-                        WidgetPositionFilter::Floating => match element.is_floating() {
-                            true => FilterOutput::Include(element, PaintFilter::fixed()),
-                            false => FilterOutput::Continue,
-                        },
-                        WidgetPositionFilter::Fixed => match element.is_floating() {
-                            false => FilterOutput::Include(element, *self),
-                            true => FilterOutput::Exclude,
-                        },
-                        WidgetPositionFilter::All => FilterOutput::Include(element, *self),
-                        WidgetPositionFilter::None => FilterOutput::Exclude,
-                    },
-                    Display::Hide | Display::Exclude => FilterOutput::Exclude,
-                }
-            }
-            _ => FilterOutput::Continue,
-        }
-    }
-}
-
-pub fn paint<'bp>(
-    surface: &mut impl WidgetRenderer,
-    glyph_index: &mut GlyphMap,
-    mut widgets: PaintChildren<'_, 'bp>,
-    attribute_storage: &AttributeStorage<'bp>,
-) {
-    _ = widgets.each(|widget, children| {
-        let ctx = PaintCtx::new(surface, None, glyph_index);
-        widget.paint(children, ctx, attribute_storage);
-        ControlFlow::Continue(())
-    });
-}
-
-#[derive(Debug, Copy, Clone)]
-pub struct Unsized;
-
-pub struct SizePos {
-    pub local_size: Size,
-    pub global_pos: Pos,
-}
-
-impl SizePos {
-    pub fn new(local_size: Size, global_pos: Pos) -> Self {
-        Self { local_size, global_pos }
-    }
-}
-
-// -----------------------------------------------------------------------------
-//     - Paint context -
-// -----------------------------------------------------------------------------
-// * Context should draw in local coordinates and translate to the screen
-// * A child always starts at 0, 0 in local space
-/// Paint context used by the widgets to paint.
-/// It works in local coordinates, translated to screen position.
-pub struct PaintCtx<'surface, Size> {
-    surface: &'surface mut dyn WidgetRenderer,
-    pub clip: Option<Region>,
-    pub(crate) state: Size,
-    glyph_map: &'surface mut GlyphMap,
-}
-
-impl<'surface> Deref for PaintCtx<'surface, SizePos> {
-    type Target = SizePos;
-
-    fn deref(&self) -> &Self::Target {
-        &self.state
-    }
-}
-
-impl<'surface> PaintCtx<'surface, Unsized> {
-    pub fn new(
-        surface: &'surface mut dyn WidgetRenderer,
-        clip: Option<Region>,
-        glyph_map: &'surface mut GlyphMap,
-    ) -> Self {
-        Self {
-            surface,
-            clip,
-            state: Unsized,
-            glyph_map,
-        }
-    }
-
-    /// Create a sized context at a given position
-    pub fn into_sized(self, size: Size, global_pos: Pos) -> PaintCtx<'surface, SizePos> {
-        PaintCtx {
-            surface: self.surface,
-            glyph_map: self.glyph_map,
-            clip: self.clip,
-            state: SizePos::new(size, global_pos),
-        }
-    }
-}
-
-impl<'screen> PaintCtx<'screen, SizePos> {
-    pub fn to_unsized(&mut self) -> PaintCtx<'_, Unsized> {
-        PaintCtx::new(self.surface, self.clip, self.glyph_map)
-    }
-
-    pub fn update(&mut self, new_size: Size, new_pos: Pos) {
-        self.state.local_size = new_size;
-        self.state.global_pos = new_pos;
-    }
-
-    /// This will create an intersection with any previous regions
-    pub fn set_clip_region(&mut self, region: Region) {
-        let current = self.clip.get_or_insert(region);
-        *current = current.intersect_with(&region);
-    }
-
-    pub fn create_region(&self) -> Region {
-        let mut region = Region::new(
-            self.global_pos,
-            Pos::new(
-                self.global_pos.x + self.local_size.width as i32,
-                self.global_pos.y + self.local_size.height as i32,
-            ),
-        );
-
-        if let Some(existing) = self.clip {
-            region.constrain(&existing);
-        }
-
-        region
-    }
-
-    fn clip(&self, local_pos: LocalPos, clip: &Region) -> bool {
-        let pos = self.global_pos + local_pos;
-        clip.contains(pos)
-    }
-
-    fn pos_inside_local_region(&self, pos: LocalPos, width: u16) -> bool {
-        pos.x + width <= self.local_size.width && pos.y < self.local_size.height
-    }
-
-    // Translate local coordinates to screen coordinates.
-    // Will return `None` if the coordinates are outside the screen bounds
-    pub fn translate_to_global(&self, local: LocalPos) -> Option<Pos> {
-        let screen_x = local.x as i32 + self.global_pos.x;
-        let screen_y = local.y as i32 + self.global_pos.y;
-
-        let (width, height) = self.surface.size().into();
-        if screen_x < 0 || screen_y < 0 || screen_x >= width || screen_y >= height {
-            return None;
-        }
-
-        Some(Pos {
-            x: screen_x,
-            y: screen_y,
-        })
-    }
-
-    fn newline(&mut self, pos: LocalPos) -> Option<LocalPos> {
-        let y = pos.y + 1; // next line
-        if y >= self.local_size.height { None } else { Some(LocalPos { x: 0, y }) }
-    }
-
-    pub fn to_glyphs<'a>(&mut self, s: &'a str) -> Glyphs<'a> {
-        Glyphs::new(s)
-    }
-
-    pub fn place_glyphs(&mut self, mut glyphs: Glyphs<'_>, mut pos: LocalPos) -> Option<LocalPos> {
-        while let Some(glyph) = glyphs.next(self.glyph_map) {
-            pos = self.place_glyph(glyph, pos)?;
-        }
-        Some(pos)
-    }
-
-    pub fn set_style(&mut self, style: Style, pos: LocalPos) {
-        // Ensure that the position is inside provided clipping region
-        if let Some(clip) = self.clip.as_ref() {
-            if !self.clip(pos, clip) {
-                return;
-            }
-        }
-
-        let screen_pos = match self.translate_to_global(pos) {
-            Some(pos) => pos,
-            None => return,
-        };
-
-        self.surface.set_style(style, screen_pos);
-    }
-
-    pub fn set_attributes(&mut self, attrs: &Attributes<'_>, pos: LocalPos) {
-        // Ensure that the position is inside provided clipping region
-        if let Some(clip) = self.clip.as_ref() {
-            if !self.clip(pos, clip) {
-                return;
-            }
-        }
-
-        let screen_pos = match self.translate_to_global(pos) {
-            Some(pos) => pos,
-            None => return,
-        };
-
-        self.surface.set_attributes(attrs, screen_pos);
-    }
-
-    // Place a char on the screen buffer, return the next cursor position in local space.
-    //
-    // The `input_pos` is the position, in local space, where the character
-    // should be placed. This will (possibly) be offset if there is clipping available.
-    //
-    // The `output_pos` is the same as the `input_pos` unless clipping has been applied.
-    pub fn place_glyph(&mut self, glyph: Glyph, input_pos: LocalPos) -> Option<LocalPos> {
-        let width = glyph.width() as u16;
-        let next = LocalPos {
-            x: input_pos.x + width,
-            y: input_pos.y,
-        };
-
-        // Ensure that the position is inside provided clipping region
-        if let Some(clip) = self.clip.as_ref() {
-            if !self.clip(input_pos, clip) {
-                return Some(next);
-            }
-        }
-
-        // 1. Newline (yes / no)
-        if glyph.is_newline() {
-            return self.newline(input_pos);
-        }
-
-        // 2. Check if the char can be placed
-        if !self.pos_inside_local_region(input_pos, width) {
-            return None;
-        }
-
-        // 3. Find position on the screen
-        let screen_pos = match self.translate_to_global(input_pos) {
-            Some(pos) => pos,
-            None => return Some(next),
-        };
-
-        // 4. Place the char
-        self.surface.draw_glyph(glyph, screen_pos);
-
-        // 4. Advance the cursor (which might trigger another newline)
-        if input_pos.x >= self.local_size.width {
-            self.newline(input_pos)
-        } else {
-            Some(LocalPos {
-                x: input_pos.x + width,
-                y: input_pos.y,
-            })
-        }
-    }
-}
diff --git a/anathema-widgets/src/query/components.rs b/anathema-widgets/src/query/components.rs
deleted file mode 100644
index 6fc5d94d..00000000
--- a/anathema-widgets/src/query/components.rs
+++ /dev/null
@@ -1,156 +0,0 @@
-use std::ops::ControlFlow;
-
-use anathema_value_resolver::{AttributeStorage, Attributes};
-
-use super::{Chain, Filter, Nodes, Query, QueryValue};
-use crate::nodes::component::Component;
-use crate::{WidgetId, WidgetKind};
-
-pub struct Components<'children, 'tree, 'bp> {
-    pub(super) elements: &'children mut Nodes<'tree, 'bp>,
-}
-
-impl<'children, 'tree, 'bp> Components<'children, 'tree, 'bp> {
-    pub fn by_name<'a>(&mut self, name: &'a str) -> ComponentQuery<'_, 'tree, 'bp, Kind<'a>> {
-        self.make_query(Kind::ByName(name))
-    }
-
-    pub fn by_id<F, U>(&mut self, id: WidgetId, mut f: F) -> Option<U>
-    where
-        F: FnMut(&mut Component<'_>, &mut Attributes<'_>) -> U,
-    {
-        let widget = self.elements.children.get_mut(id)?;
-        let WidgetKind::Component(component) = &mut widget.kind else { return None };
-        let attributes = self.elements.attributes.get_mut(id);
-        Some(f(component, attributes))
-    }
-
-    pub fn by_attribute<'a>(
-        &mut self,
-        key: &'a str,
-        value: impl Into<QueryValue<'a>>,
-    ) -> ComponentQuery<'_, 'tree, 'bp, Kind<'a>> {
-        self.make_query(Kind::ByAttribute(key, value.into()))
-    }
-
-    fn make_query<'a>(&mut self, kind: Kind<'a>) -> ComponentQuery<'_, 'tree, 'bp, Kind<'a>> {
-        ComponentQuery {
-            query: Query {
-                filter: kind,
-                elements: self.elements,
-            },
-        }
-    }
-}
-
-pub struct ComponentQuery<'el, 'tree, 'bp, T>
-where
-    T: Filter<'bp, Kind = Component<'bp>> + Copy,
-{
-    query: Query<'el, 'tree, 'bp, T, Component<'bp>>,
-}
-
-impl<'el, 'tree, 'bp, T> ComponentQuery<'el, 'tree, 'bp, T>
-where
-    T: Filter<'bp, Kind = Component<'bp>> + Copy,
-{
-    pub fn by_name(self, name: &str) -> ComponentQuery<'el, 'tree, 'bp, Chain<T, Kind<'_>>> {
-        ComponentQuery {
-            query: Query {
-                filter: Chain::new(self.query.filter, Kind::ByName(name)),
-                elements: self.query.elements,
-            },
-        }
-    }
-
-    pub fn by_attribute<'a>(
-        self,
-        key: &'a str,
-        value: impl Into<QueryValue<'a>>,
-    ) -> ComponentQuery<'el, 'tree, 'bp, Chain<T, Kind<'a>>> {
-        ComponentQuery {
-            query: Query {
-                filter: Chain::new(self.query.filter, Kind::ByAttribute(key, value.into())),
-                elements: self.query.elements,
-            },
-        }
-    }
-
-    pub fn first<F, U>(self, mut f: F) -> Option<U>
-    where
-        F: FnMut(WidgetId, &mut Component<'_>, &mut Attributes<'_>) -> U,
-    {
-        match self.query(&mut f, false) {
-            ControlFlow::Continue(_) => None,
-            ControlFlow::Break(val) => Some(val),
-        }
-    }
-
-    pub fn each<F>(self, mut f: F)
-    where
-        F: FnMut(WidgetId, &mut Component<'_>, &mut Attributes<'_>),
-    {
-        _ = self.query(&mut f, true);
-    }
-
-    fn query<F, U>(self, f: &mut F, continuous: bool) -> ControlFlow<U>
-    where
-        F: FnMut(WidgetId, &mut Component<'_>, &mut Attributes<'_>) -> U,
-    {
-        let ret_val = self.query.elements.children.for_each(|_path, container, children| {
-            if let WidgetKind::Component(ref mut component) = container.kind {
-                if self.query.filter.filter(component, self.query.elements.attributes) {
-                    let attributes = self.query.elements.attributes.get_mut(component.widget_id);
-                    let ret_val = f(component.widget_id, component, attributes);
-
-                    if !continuous {
-                        return ControlFlow::Break(ret_val);
-                    }
-                }
-            }
-
-            let mut elements = Nodes::new(
-                children,
-                self.query.elements.attributes,
-                self.query.elements.dirty_widgets,
-            );
-
-            let query = ComponentQuery {
-                query: Query {
-                    elements: &mut elements,
-                    filter: self.query.filter,
-                },
-            };
-
-            query.query(f, continuous)
-        });
-
-        match ret_val {
-            Some(val) => ControlFlow::Break(val),
-            None => ControlFlow::Continue(()),
-        }
-    }
-}
-
-// -----------------------------------------------------------------------------
-//   - Query kind -
-// -----------------------------------------------------------------------------
-#[derive(Debug, Copy, Clone)]
-pub enum Kind<'a> {
-    ByName(&'a str),
-    ByAttribute(&'a str, QueryValue<'a>),
-}
-
-impl<'bp> Filter<'bp> for Kind<'_> {
-    type Kind = Component<'bp>;
-
-    fn filter(&self, el: &Self::Kind, attributes: &mut AttributeStorage<'bp>) -> bool {
-        match self {
-            Kind::ByName(name) => el.name == *name,
-            Kind::ByAttribute(key, value) => {
-                let attribs = attributes.get(el.widget_id);
-                attribs.get(key).map(|attribute| value.eq(attribute)).unwrap_or(false)
-            }
-        }
-    }
-}
diff --git a/anathema-widgets/src/query/deferred.rs b/anathema-widgets/src/query/deferred.rs
deleted file mode 100644
index f76ea405..00000000
--- a/anathema-widgets/src/query/deferred.rs
+++ /dev/null
@@ -1,190 +0,0 @@
-use std::ops::ControlFlow;
-
-use anathema_geometry::{Pos, Region};
-pub use anathema_store::tree::visitor::apply_visitor;
-use anathema_store::tree::visitor::NodeVisitor;
-use anathema_store::tree::{Node, TreeValues};
-use anathema_value_resolver::{AttributeStorage, Attributes};
-
-use super::{Chain, Filter, Nodes, Query, QueryValue};
-use crate::nodes::component::Component;
-use crate::nodes::element::Element;
-use crate::{DirtyWidgets, WidgetContainer, WidgetId, WidgetKind, WidgetTreeView};
-
-pub struct DeferredComponents {
-    pub(super) elements: &'children mut Nodes<'tree, 'bp>,
-}
-
-impl<'children, 'tree, 'bp> DeferredComponents<'children, 'tree, 'bp> {
-    pub fn by_name<'a>(&mut self, name: &'a str) -> ComponentQuery<'_, 'tree, 'bp, Kind<'a>> {
-        self.make_query(Kind::ByName(name))
-    }
-
-    pub fn by_attribute<'a>(
-        &mut self,
-        key: &'a str,
-        value: impl Into<QueryValue<'a>>,
-    ) -> ComponentQuery<'_, 'tree, 'bp, Kind<'a>> {
-        self.make_query(Kind::ByAttribute(key, value.into()))
-    }
-
-    fn make_query<'a>(&mut self, kind: Kind<'a>) -> ComponentQuery<'_, 'tree, 'bp, Kind<'a>> {
-        ComponentQuery {
-            query: Query {
-                filter: kind,
-                elements: &mut self.elements,
-            },
-        }
-    }
-}
-
-pub struct ComponentQuery<'el, 'tree, 'bp, T>
-where
-    T: Filter<'bp, Kind = Component<'bp>> + Copy,
-{
-    query: Query<'el, 'tree, 'bp, T, Component<'bp>>,
-}
-
-impl<'el, 'tree, 'bp, T> ComponentQuery<'el, 'tree, 'bp, T>
-where
-    T: Filter<'bp, Kind = Component<'bp>> + Copy,
-{
-    pub fn by_name(self, name: &str) -> ComponentQuery<'el, 'tree, 'bp, Chain<T, Kind<'_>>> {
-        ComponentQuery {
-            query: Query {
-                filter: Chain::new(self.query.filter, Kind::ByName(name)),
-                elements: self.query.elements,
-            },
-        }
-    }
-
-    pub fn by_attribute<'a>(
-        self,
-        key: &'a str,
-        value: impl Into<QueryValue<'a>>,
-    ) -> ComponentQuery<'el, 'tree, 'bp, Chain<T, Kind<'a>>> {
-        ComponentQuery {
-            query: Query {
-                filter: Chain::new(self.query.filter, Kind::ByAttribute(key, value.into())),
-                elements: self.query.elements,
-            },
-        }
-    }
-
-    pub fn first<F, U>(self, mut f: F) -> Option<U>
-    where
-        F: FnMut(WidgetId, &mut Component<'_>, &mut Attributes<'_>) -> U,
-    {
-        match self.query(&mut f, false) {
-            ControlFlow::Continue(_) => None,
-            ControlFlow::Break(val) => Some(val),
-        }
-    }
-
-    pub fn each<F>(self, mut f: F)
-    where
-        F: FnMut(WidgetId, &mut Component<'_>, &mut Attributes<'_>),
-    {
-        self.query(&mut f, true);
-    }
-
-    fn queryold<U>(
-        self,
-        f: &mut impl FnMut(WidgetId, &mut Component<'_>, &mut Attributes<'_>) -> U,
-        continuous: bool,
-    ) -> Option<U> {
-        let len = self.query.elements.children.layout.len();
-        for i in 0..self.query.elements.children.layout.len() {
-            let node = &self.query.elements.children.layout[i];
-            let Some((_path, container)) = self.query.elements.children.values.get_mut(node.value()) else {
-                continue;
-            };
-
-            let WidgetKind::Component(ref mut component) = container.kind else { continue };
-
-            if !self.query.filter.filter(component, self.query.elements.attributes) {
-                continue;
-            }
-
-            let attributes = self.query.elements.attributes.get_mut(component.widget_id);
-            let retval = f(component.widget_id, component, attributes);
-
-            if !continuous {
-                return Some(retval);
-            }
-
-            let mut query = ComponentQuery {
-                query: Query {
-                    elements: self.query.elements,
-                    filter: self.query.filter,
-                },
-            };
-
-            query.query(f, continuous);
-        }
-
-        None
-    }
-
-    fn query<F, U>(self, mut f: &mut F, continuous: bool) -> ControlFlow<U>
-    where
-        F: FnMut(WidgetId, &mut Component<'_>, &mut Attributes<'_>) -> U,
-    {
-        let ret_val = self.query.elements.children.for_each(|_path, container, children| {
-            if let WidgetKind::Component(ref mut component) = container.kind {
-                if self.query.filter.filter(component, self.query.elements.attributes) {
-                    let attributes = self.query.elements.attributes.get_mut(component.widget_id);
-                    let ret_val = f(component.widget_id, component, attributes);
-
-                    if !continuous {
-                        return ControlFlow::Break(ret_val);
-                    }
-                }
-            }
-
-            let mut elements = Nodes::new(
-                children,
-                self.query.elements.attributes,
-                self.query.elements.dirty_widgets,
-            );
-
-            let mut query = ComponentQuery {
-                query: Query {
-                    elements: &mut elements,
-                    filter: self.query.filter,
-                },
-            };
-
-            query.query(f, continuous)
-        });
-
-        match ret_val {
-            Some(val) => ControlFlow::Break(val),
-            None => ControlFlow::Continue(()),
-        }
-    }
-}
-
-// -----------------------------------------------------------------------------
-//   - Query kind -
-// -----------------------------------------------------------------------------
-#[derive(Debug, Copy, Clone)]
-pub enum Kind<'a> {
-    ByName(&'a str),
-    ByAttribute(&'a str, QueryValue<'a>),
-}
-
-impl<'bp> Filter<'bp> for Kind<'_> {
-    type Kind = Component<'bp>;
-
-    fn filter(&self, el: &Self::Kind, attributes: &mut AttributeStorage<'bp>) -> bool {
-        match self {
-            Kind::ByName(name) => el.name == *name,
-            Kind::ByAttribute(key, value) => {
-                let attribs = attributes.get(el.widget_id);
-                attribs.get(key).map(|attribute| value.eq(attribute)).unwrap_or(false)
-            }
-        }
-    }
-}
-
diff --git a/anathema-widgets/src/query/elements.rs b/anathema-widgets/src/query/elements.rs
deleted file mode 100644
index 17d59b32..00000000
--- a/anathema-widgets/src/query/elements.rs
+++ /dev/null
@@ -1,188 +0,0 @@
-use std::ops::ControlFlow;
-
-use anathema_geometry::{Pos, Region};
-use anathema_value_resolver::{AttributeStorage, Attributes};
-
-use super::{Chain, Filter, Nodes, Query, QueryValue};
-use crate::nodes::element::Element;
-use crate::{WidgetId, WidgetKind};
-
-pub struct Elements<'children, 'tree, 'bp> {
-    pub(super) elements: &'children mut Nodes<'tree, 'bp>,
-}
-
-impl<'children, 'tree, 'bp> Elements<'children, 'tree, 'bp> {
-    pub fn by_tag<'a>(&mut self, tag: &'a str) -> ElementQuery<'_, 'tree, 'bp, Kind<'a>> {
-        self.make_query(Kind::ByTag(tag))
-    }
-
-    pub fn at_position<'a>(&mut self, pos: impl Into<Pos>) -> ElementQuery<'_, 'tree, 'bp, Kind<'a>> {
-        self.make_query(Kind::AtPosition(pos.into()))
-    }
-
-    pub fn first<F, U>(&mut self, f: F) -> Option<U>
-    where
-        F: FnMut(&mut Element<'_>, &mut Attributes<'_>) -> U,
-    {
-        self.make_query(Kind::All).first(f)
-    }
-
-    pub fn each<F>(&mut self, f: F)
-    where
-        F: FnMut(&mut Element<'_>, &mut Attributes<'_>),
-    {
-        self.make_query(Kind::All).each(f)
-    }
-
-    pub fn by_attribute<'a>(
-        &mut self,
-        key: &'a str,
-        value: impl Into<QueryValue<'a>>,
-    ) -> ElementQuery<'_, 'tree, 'bp, Kind<'a>> {
-        self.make_query(Kind::ByAttribute(key, value.into()))
-    }
-
-    pub fn by_id<'a>(&mut self, id: WidgetId) -> ElementQuery<'_, 'tree, 'bp, Kind<'a>> {
-        self.make_query(Kind::ById(id))
-    }
-
-    fn make_query<'a>(&mut self, kind: Kind<'a>) -> ElementQuery<'_, 'tree, 'bp, Kind<'a>> {
-        ElementQuery {
-            query: Query {
-                filter: kind,
-                elements: self.elements,
-            },
-        }
-    }
-}
-
-pub struct ElementQuery<'el, 'tree, 'bp, T>
-where
-    T: Filter<'bp, Kind = Element<'bp>> + Copy,
-{
-    query: Query<'el, 'tree, 'bp, T, Element<'bp>>,
-}
-
-impl<'el, 'tree, 'bp, T> ElementQuery<'el, 'tree, 'bp, T>
-where
-    T: Filter<'bp, Kind = Element<'bp>> + Copy,
-{
-    pub fn by_tag(self, name: &str) -> ElementQuery<'el, 'tree, 'bp, Chain<T, Kind<'_>>> {
-        ElementQuery {
-            query: Query {
-                filter: Chain::new(self.query.filter, Kind::ByTag(name)),
-                elements: self.query.elements,
-            },
-        }
-    }
-
-    pub fn at_position(self, pos: impl Into<Pos>) -> ElementQuery<'el, 'tree, 'bp, Chain<T, Kind<'static>>> {
-        ElementQuery {
-            query: Query {
-                filter: Chain::new(self.query.filter, Kind::AtPosition(pos.into())),
-                elements: self.query.elements,
-            },
-        }
-    }
-
-    pub fn by_attribute<'a>(
-        self,
-        key: &'a str,
-        value: impl Into<QueryValue<'a>>,
-    ) -> ElementQuery<'el, 'tree, 'bp, Chain<T, Kind<'a>>> {
-        ElementQuery {
-            query: Query {
-                filter: Chain::new(self.query.filter, Kind::ByAttribute(key, value.into())),
-                elements: self.query.elements,
-            },
-        }
-    }
-
-    pub fn first<F, U>(self, mut f: F) -> Option<U>
-    where
-        F: FnMut(&mut Element<'_>, &mut Attributes<'_>) -> U,
-    {
-        match self.query(&mut f, false) {
-            ControlFlow::Continue(_) => None,
-            ControlFlow::Break(val) => Some(val),
-        }
-    }
-
-    pub fn each<F>(self, mut f: F)
-    where
-        F: FnMut(&mut Element<'_>, &mut Attributes<'_>),
-    {
-        _ = self.query(&mut f, true);
-    }
-
-    fn query<F, U>(self, f: &mut F, continuous: bool) -> ControlFlow<U>
-    where
-        F: FnMut(&mut Element<'_>, &mut Attributes<'_>) -> U,
-    {
-        let ret_val = self.query.elements.children.for_each(|_path, container, children| {
-            if let WidgetKind::Element(ref mut element) = container.kind {
-                if self.query.filter.filter(element, self.query.elements.attributes) {
-                    let attributes = self.query.elements.attributes.get_mut(element.id());
-                    let ret_val = f(element, attributes);
-                    self.query.elements.dirty_widgets.push(element.id());
-
-                    if !continuous {
-                        return ControlFlow::Break(ret_val);
-                    }
-                }
-            }
-
-            let mut elements = Nodes::new(
-                children,
-                self.query.elements.attributes,
-                self.query.elements.dirty_widgets,
-            );
-
-            let query = ElementQuery {
-                query: Query {
-                    elements: &mut elements,
-                    filter: self.query.filter,
-                },
-            };
-
-            query.query(f, continuous)
-        });
-
-        match ret_val {
-            Some(val) => ControlFlow::Break(val),
-            None => ControlFlow::Continue(()),
-        }
-    }
-}
-
-// -----------------------------------------------------------------------------
-//   - Query kind -
-// -----------------------------------------------------------------------------
-#[derive(Debug, Copy, Clone)]
-pub enum Kind<'a> {
-    All,
-    ByTag(&'a str),
-    ByAttribute(&'a str, QueryValue<'a>),
-    AtPosition(Pos),
-    ById(WidgetId),
-}
-
-impl<'bp, 'a> Filter<'bp> for Kind<'a> {
-    type Kind = Element<'bp>;
-
-    fn filter(&self, el: &Element<'bp>, attributes: &mut AttributeStorage<'_>) -> bool {
-        match self {
-            Kind::All => true,
-            Kind::ByTag(tag) => el.ident == *tag,
-            Kind::ByAttribute(key, value) => {
-                let attribs = attributes.get(el.container.id);
-                attribs.get(key).map(|attribute| value.eq(attribute)).unwrap_or(false)
-            }
-            Kind::AtPosition(pos) => {
-                let region = Region::from((el.pos(), el.size()));
-                region.contains(*pos)
-            }
-            Kind::ById(id) => el.id() == *id,
-        }
-    }
-}
diff --git a/anathema-widgets/src/query/mod.rs b/anathema-widgets/src/query/mod.rs
deleted file mode 100644
index 35c957b9..00000000
--- a/anathema-widgets/src/query/mod.rs
+++ /dev/null
@@ -1,249 +0,0 @@
-use anathema_state::{Color, Hex};
-use anathema_value_resolver::{AttributeStorage, ValueKind};
-
-pub use self::components::Components;
-pub use self::elements::Elements;
-use crate::{DirtyWidgets, WidgetTreeView};
-
-mod components;
-mod elements;
-
-pub struct Children<'tree, 'bp>(Nodes<'tree, 'bp>);
-
-impl<'tree, 'bp> Children<'tree, 'bp> {
-    pub fn new(
-        children: WidgetTreeView<'tree, 'bp>,
-        attribute_storage: &'tree mut AttributeStorage<'bp>,
-        dirty_widgets: &'tree mut DirtyWidgets,
-    ) -> Self {
-        Self(Nodes::new(children, attribute_storage, dirty_widgets))
-    }
-
-    pub fn elements(&mut self) -> Elements<'_, 'tree, 'bp> {
-        Elements { elements: &mut self.0 }
-    }
-
-    pub fn components(&mut self) -> Components<'_, 'tree, 'bp> {
-        Components { elements: &mut self.0 }
-    }
-
-    pub fn parent_path(&self) -> &[u16] {
-        self.0.children.offset
-    }
-}
-
-#[derive(Debug, Copy, Clone)]
-pub enum QueryValue<'a> {
-    Str(&'a str),
-    Int(i64),
-    Float(f64),
-    Bool(bool),
-    Char(char),
-    Hex(Hex),
-    Color(Color),
-}
-
-impl<'a> From<&'a str> for QueryValue<'a> {
-    fn from(value: &'a str) -> Self {
-        Self::Str(value)
-    }
-}
-
-impl<'a> From<bool> for QueryValue<'a> {
-    fn from(value: bool) -> Self {
-        Self::Bool(value)
-    }
-}
-
-macro_rules! impl_from_int {
-    ($t:ty) => {
-        impl<'a> From<$t> for QueryValue<'a> {
-            fn from(value: $t) -> Self {
-                Self::Int(value as i64)
-            }
-        }
-    };
-}
-
-impl_from_int!(u8);
-impl_from_int!(u16);
-impl_from_int!(u32);
-impl_from_int!(u64);
-impl_from_int!(usize);
-impl_from_int!(i8);
-impl_from_int!(i16);
-impl_from_int!(i32);
-impl_from_int!(i64);
-impl_from_int!(isize);
-
-impl PartialEq<ValueKind<'_>> for QueryValue<'_> {
-    fn eq(&self, other: &ValueKind<'_>) -> bool {
-        match self {
-            QueryValue::Str(lhs) => match other {
-                ValueKind::Str(rhs) => lhs == rhs,
-                _ => false,
-            },
-            QueryValue::Bool(lhs) => match other {
-                ValueKind::Bool(rhs) => lhs == rhs,
-                _ => false,
-            },
-            &QueryValue::Int(lhs) => match other {
-                &ValueKind::Int(rhs) => lhs == rhs,
-                _ => false,
-            },
-            &QueryValue::Float(lhs) => match other {
-                &ValueKind::Float(rhs) => lhs == rhs,
-                _ => false,
-            },
-            &QueryValue::Char(lhs) => match other {
-                &ValueKind::Char(rhs) => lhs == rhs,
-                _ => false,
-            },
-            &QueryValue::Hex(lhs) => match other {
-                &ValueKind::Hex(rhs) => lhs == rhs,
-                _ => false,
-            },
-            &QueryValue::Color(lhs) => match other {
-                &ValueKind::Color(rhs) => lhs == rhs,
-                _ => false,
-            },
-        }
-    }
-}
-
-// -----------------------------------------------------------------------------
-//   - Elements -
-// -----------------------------------------------------------------------------
-pub struct Nodes<'tree, 'bp> {
-    children: WidgetTreeView<'tree, 'bp>,
-    attributes: &'tree mut AttributeStorage<'bp>,
-    dirty_widgets: &'tree mut DirtyWidgets,
-}
-
-impl<'tree, 'bp> Nodes<'tree, 'bp> {
-    pub fn new(
-        children: WidgetTreeView<'tree, 'bp>,
-        attribute_storage: &'tree mut AttributeStorage<'bp>,
-        dirty_widgets: &'tree mut DirtyWidgets,
-    ) -> Self {
-        Self {
-            children,
-            attributes: attribute_storage,
-            dirty_widgets,
-        }
-    }
-}
-
-// -----------------------------------------------------------------------------
-//   - Query -
-// -----------------------------------------------------------------------------
-pub struct Query<'el, 'tree, 'bp, F, T>
-where
-    F: Filter<'bp, Kind = T>,
-{
-    filter: F,
-    elements: &'el mut Nodes<'tree, 'bp>,
-}
-
-impl<'el, 'tree, 'bp, F, T> Filter<'bp> for Query<'el, 'tree, 'bp, F, T>
-where
-    F: Filter<'bp, Kind = T>,
-{
-    type Kind = T;
-
-    fn filter(&self, arg: &Self::Kind, attributes: &mut AttributeStorage<'bp>) -> bool {
-        self.filter.filter(arg, attributes)
-    }
-}
-
-// -----------------------------------------------------------------------------
-//   - Filter -
-// -----------------------------------------------------------------------------
-pub trait Filter<'bp> {
-    type Kind;
-
-    fn filter(&self, arg: &Self::Kind, attributes: &mut AttributeStorage<'bp>) -> bool;
-}
-
-// -----------------------------------------------------------------------------
-//   - Chain -
-// -----------------------------------------------------------------------------
-#[derive(Debug, Copy, Clone)]
-pub struct Chain<A, B> {
-    a: A,
-    b: B,
-}
-
-impl<A, B> Chain<A, B> {
-    pub fn new(a: A, b: B) -> Self {
-        Self { a, b }
-    }
-}
-
-impl<'bp, A, B> Filter<'bp> for Chain<A, B>
-where
-    A: Filter<'bp>,
-    B: Filter<'bp, Kind = A::Kind>,
-{
-    type Kind = A::Kind;
-
-    fn filter(&self, arg: &Self::Kind, attributes: &mut AttributeStorage<'bp>) -> bool {
-        self.a.filter(arg, attributes) && self.b.filter(arg, attributes)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn filter_by_tag() {
-        let tpl = "
-        many
-            many
-                text '1'
-            text '2'
-            many
-                many
-                    text '3'
-        ";
-
-        crate::testing::with_template(tpl, |tree, attributes| {
-            let mut dirty = DirtyWidgets::empty();
-            let mut children = Children::new(tree, attributes, &mut dirty);
-            let mut cntr = 0;
-            children.elements().by_tag("text").each(|el, _| {
-                assert_eq!(el.ident, "text");
-                cntr += 1;
-            });
-
-            assert_eq!(cntr, 3);
-        });
-    }
-
-    #[test]
-    fn filter_by_tag_and_attribute() {
-        let tpl = "
-        many
-            many
-                text [a: 1] '1'
-            text '2'
-            many
-                many
-                    text [a: 1] '3'
-        ";
-
-        crate::testing::with_template(tpl, |tree, attributes| {
-            let mut dirty = DirtyWidgets::empty();
-            let mut children = Children::new(tree, attributes, &mut dirty);
-            let mut cntr = 0;
-
-            children.elements().by_tag("text").by_attribute("a", 1).each(|el, _| {
-                assert_eq!(el.ident, "text");
-                cntr += 1;
-            });
-
-            assert_eq!(cntr, 2);
-        });
-    }
-}
diff --git a/anathema-widgets/src/tabindex.rs b/anathema-widgets/src/tabindex.rs
deleted file mode 100644
index 3b6b670d..00000000
--- a/anathema-widgets/src/tabindex.rs
+++ /dev/null
@@ -1,209 +0,0 @@
-use std::cmp::Ordering;
-use std::fmt::Debug;
-
-use anathema_state::StateId;
-
-use crate::{WidgetId, WidgetKind, WidgetTreeView};
-
-// TODO
-// Test this with
-// * One component
-// * Many components
-// * No components that accepts focus
-
-#[derive(Clone)]
-pub struct Index {
-    pub path: Box<[u16]>,
-    pub index: u16,
-    pub widget_id: WidgetId,
-    pub state_id: StateId,
-}
-
-impl Index {
-    fn to_ref(&self) -> IndexRef<'_> {
-        IndexRef {
-            path: &self.path,
-            index: self.index,
-        }
-    }
-}
-
-impl Debug for Index {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{} | {:?}", self.index, self.path)
-    }
-}
-
-#[derive(Debug, Copy, Clone, PartialEq)]
-struct IndexRef<'a> {
-    path: &'a [u16],
-    index: u16,
-}
-
-impl IndexRef<'_> {
-    fn to_owned(self, widget_id: WidgetId, state_id: StateId) -> Index {
-        Index {
-            index: self.index,
-            path: self.path.into(),
-            widget_id,
-            state_id,
-        }
-    }
-}
-
-impl PartialOrd for IndexRef<'_> {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        let ord = match self.index.cmp(&other.index) {
-            ord @ (Ordering::Less | Ordering::Greater) => ord,
-            Ordering::Equal => self.path.cmp(other.path),
-        };
-        Some(ord)
-    }
-}
-
-#[derive(Debug)]
-pub enum Direction {
-    Forward,
-    Backward,
-}
-
-pub struct TabIndex<'a, 'bp> {
-    pub previous: Option<Index>,
-    pub current: &'a mut Option<Index>,
-    tree: WidgetTreeView<'a, 'bp>,
-    pub changed: bool,
-}
-
-impl<'a, 'bp> TabIndex<'a, 'bp> {
-    pub fn new(current: &'a mut Option<Index>, tree: WidgetTreeView<'a, 'bp>) -> Self {
-        Self {
-            current,
-            previous: None,
-            tree,
-            changed: false,
-        }
-    }
-
-    pub fn consume(mut self) -> Option<Index> {
-        self.previous.take()
-    }
-
-    pub fn next(&mut self) {
-        self.find_component_accepting_focus(Direction::Forward);
-    }
-
-    pub fn prev(&mut self) {
-        self.find_component_accepting_focus(Direction::Backward);
-    }
-
-    fn find_component_accepting_focus(&mut self, dir: Direction) {
-        let values = self.tree.values.iter();
-
-        let mut next_index = NextIndex {
-            origin: self.current.as_ref().map(|i| i.to_ref()),
-            next: None,
-        };
-
-        let mut smallest_index = None;
-        let mut largest_index = None;
-
-        for (path, container) in values {
-            match &container.kind {
-                crate::WidgetKind::Component(component) if component.dyn_component.any_accept_focus() => {
-                    let index = IndexRef {
-                        path,
-                        index: component.tabindex,
-                    };
-
-                    // Keep track of the smallest index
-                    match &mut smallest_index {
-                        Some(smallest) if *smallest > index => *smallest = index,
-                        None => smallest_index = Some(index),
-                        Some(_) => {}
-                    }
-
-                    // Keep track of the largest index
-                    match &mut largest_index {
-                        Some(largest) if *largest < index => *largest = index,
-                        None => largest_index = Some(index),
-                        Some(_) => {}
-                    }
-
-                    // Skip the current index
-                    if let Some(origin) = &mut next_index.origin {
-                        match dir {
-                            Direction::Forward if *origin >= index => continue,
-                            Direction::Backward if *origin <= index => continue,
-                            _ => {}
-                        }
-                    }
-
-                    match &mut next_index.next {
-                        Some(next) => match dir {
-                            Direction::Forward if *next > index => *next = index,
-                            Direction::Backward if *next < index => *next = index,
-                            _ => {}
-                        },
-                        None => next_index.next = Some(index),
-                    }
-                }
-                _ => {}
-            }
-        }
-
-        // Handle wrapping around.
-        // I.e if the direction is forward and the current tab index is the same
-        // as the max index, then set the next index to be the smallest index
-        if let Some(origin) = next_index.origin.take() {
-            let largest_index = largest_index.expect("if there is a next, there is a largest");
-            let smallest_index = smallest_index.expect("if there is a largest, there is a smallest");
-            match dir {
-                Direction::Forward if origin == largest_index => {
-                    next_index.next.replace(smallest_index);
-                }
-                Direction::Backward if origin == smallest_index => {
-                    next_index.next.replace(largest_index);
-                }
-                _ => {}
-            }
-        }
-
-        let Some(next) = next_index.next.take() else { return };
-
-        let Some((widget_id, value)) = self.tree.get_node_and_value(next.path) else { return };
-        let WidgetKind::Component(comp) = &value.kind else { return };
-        let next = IndexRef::to_owned(next, widget_id, comp.state_id);
-
-        self.previous = self.current.replace(next);
-        self.changed = true;
-    }
-}
-
-#[derive(Debug)]
-struct NextIndex<'a> {
-    // The current index, before trying to find the next one
-    origin: Option<IndexRef<'a>>,
-    next: Option<IndexRef<'a>>,
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn comparison() {
-        let a = IndexRef { path: &[0], index: 1 };
-
-        let b = IndexRef {
-            path: &[0, 0],
-            index: 1,
-        };
-
-        match a.partial_cmp(&b) {
-            Some(Ordering::Less) => (),
-            Some(Ordering::Greater) => unreachable!(),
-            Some(Ordering::Equal) => unreachable!(),
-            None => panic!(),
-        }
-    }
-}
diff --git a/anathema-widgets/src/testing.rs b/anathema-widgets/src/testing.rs
deleted file mode 100644
index c2b492a7..00000000
--- a/anathema-widgets/src/testing.rs
+++ /dev/null
@@ -1,183 +0,0 @@
-use std::fmt::Write;
-use std::ops::ControlFlow;
-
-use anathema_geometry::Size;
-use anathema_state::States;
-use anathema_store::tree::root_node;
-use anathema_templates::Document;
-use anathema_value_resolver::{AttributeStorage, FunctionTable, Scope};
-
-use crate::components::ComponentRegistry;
-use crate::layout::{LayoutCtx, Viewport};
-use crate::{
-    Components, Factory, FloatingWidgets, GlyphMap, LayoutForEach, Widget, WidgetTree, WidgetTreeView, eval_blueprint,
-};
-
-pub fn with_template<F>(tpl: &'static str, mut f: F)
-where
-    F: for<'bp> FnMut(WidgetTreeView<'_, 'bp>, &mut AttributeStorage<'bp>),
-{
-    let mut tree = WidgetTree::empty();
-    let mut doc = Document::new(tpl);
-    let mut variables = Default::default();
-    let blueprint = doc.compile(&mut variables).unwrap();
-    let variables = Box::leak(Box::new(variables));
-    let blueprint = Box::leak(Box::new(blueprint));
-    let function_table = Box::leak(Box::new(FunctionTable::new()));
-
-    let mut factory = Factory::new();
-    factory.register_default::<Many>("many");
-    factory.register_default::<Float>("float");
-    factory.register_default::<Text>("text");
-
-    let mut states = States::new();
-    let mut attribute_storage = AttributeStorage::empty();
-
-    let mut components = Components::new();
-    let mut component_registry = ComponentRegistry::new();
-
-    let mut viewport = Viewport::new((80, 25));
-
-    let mut floating = FloatingWidgets::empty();
-    let mut glyph_map = GlyphMap::empty();
-
-    let mut layout_ctx = LayoutCtx::new(
-        variables,
-        &factory,
-        &mut states,
-        &mut attribute_storage,
-        &mut components,
-        &mut component_registry,
-        &mut floating,
-        &mut glyph_map,
-        &mut viewport,
-        function_table,
-    );
-
-    let mut ctx = layout_ctx.eval_ctx(None, None);
-    let scope = Scope::root();
-
-    eval_blueprint(blueprint, &mut ctx, &scope, root_node(), &mut tree.view()).unwrap();
-
-    let filter = crate::layout::LayoutFilter;
-    let mut for_each = LayoutForEach::new(tree.view(), &scope, filter);
-    _ = for_each
-        .each(&mut layout_ctx, |ctx, widget, children| {
-            _ = widget.layout(children, ctx.viewport.constraints(), ctx)?;
-            Ok(ControlFlow::Break(()))
-        })
-        .unwrap();
-
-    f(tree.view(), layout_ctx.attribute_storage);
-}
-
-// -----------------------------------------------------------------------------
-//   - Test widgets -
-// -----------------------------------------------------------------------------
-
-#[derive(Debug, Default)]
-pub(crate) struct Many;
-
-impl Widget for Many {
-    fn layout<'bp>(
-        &mut self,
-        mut children: crate::LayoutForEach<'_, 'bp>,
-        constraints: crate::layout::Constraints,
-        _: crate::WidgetId,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-    ) -> crate::error::Result<anathema_geometry::Size> {
-        let mut size = Size::ZERO;
-        _ = children.each(ctx, |ctx, child, children| {
-            let child_size: Size = child.layout(children, constraints, ctx)?.into();
-            size.width = size.width.max(child_size.width);
-            size.height += child_size.height;
-            Ok(ControlFlow::Continue(()))
-        });
-
-        Ok(size)
-    }
-
-    fn position<'bp>(
-        &mut self,
-        mut children: crate::ForEach<'_, 'bp, crate::layout::PositionFilter>,
-        _: crate::WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        ctx: crate::layout::PositionCtx,
-    ) {
-        _ = children.each(|child, children| {
-            child.position(children, ctx.pos, attribute_storage, ctx.viewport);
-            ControlFlow::Continue(())
-        });
-    }
-}
-
-#[derive(Debug, Default)]
-pub(crate) struct Text(String);
-
-impl Widget for Text {
-    fn layout<'bp>(
-        &mut self,
-        _: crate::LayoutForEach<'_, 'bp>,
-        _: crate::layout::Constraints,
-        id: crate::WidgetId,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-    ) -> crate::error::Result<anathema_geometry::Size> {
-        let attributes = ctx.attributes(id);
-        let Some(value) = attributes.value() else { return Ok(Size::ZERO) };
-
-        let mut buffer = String::new();
-        value.strings(|s| write!(&mut buffer, "{s}").is_ok());
-        self.0 = buffer;
-
-        Ok(Size::new(self.0.chars().count() as u16, 1))
-    }
-
-    fn position<'bp>(
-        &mut self,
-        _: crate::ForEach<'_, 'bp, crate::layout::PositionFilter>,
-        _: crate::WidgetId,
-        _: &AttributeStorage<'bp>,
-        _: crate::layout::PositionCtx,
-    ) {
-    }
-}
-
-#[derive(Debug, Default)]
-pub(crate) struct Float;
-
-impl Widget for Float {
-    fn layout<'bp>(
-        &mut self,
-        mut children: crate::LayoutForEach<'_, 'bp>,
-        constraints: crate::layout::Constraints,
-        _: crate::WidgetId,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-    ) -> crate::error::Result<anathema_geometry::Size> {
-        let mut size = Size::ZERO;
-        _ = children.each(ctx, |ctx, child, children| {
-            let child_size: Size = child.layout(children, constraints, ctx)?.into();
-            size.width = size.width.max(child_size.width);
-            size.height += child_size.height;
-            Ok(ControlFlow::Continue(()))
-        });
-
-        Ok(size)
-    }
-
-    fn position<'bp>(
-        &mut self,
-        mut children: crate::ForEach<'_, 'bp, crate::layout::PositionFilter>,
-        _: crate::WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        ctx: crate::layout::PositionCtx,
-    ) {
-        _ = children.each(|child, children| {
-            child.position(children, ctx.pos, attribute_storage, ctx.viewport);
-            ControlFlow::Continue(())
-        });
-    }
-
-    fn floats(&self) -> bool {
-        true
-    }
-}
diff --git a/anathema-widgets/src/tree/debug.rs b/anathema-widgets/src/tree/debug.rs
deleted file mode 100644
index 56d4c5cf..00000000
--- a/anathema-widgets/src/tree/debug.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-use std::fmt::{Result, Write};
-
-use anathema_store::tree::{Node, TreeValues};
-
-use crate::{WidgetContainer, WidgetId, WidgetKind, WidgetTreeView};
-
-pub fn debug_tree(tree: &WidgetTreeView<'_, '_>) -> String {
-    let mut output = String::new();
-
-    let (nodes, values) = tree.nodes_and_values();
-
-    walk_tree(0, nodes, values, &mut output).unwrap();
-    output
-}
-
-fn walk_tree(level: usize, nodes: &[Node], values: &TreeValues<WidgetContainer<'_>>, output: &mut String) -> Result {
-    for node in nodes {
-        let Some((_, widget)) = values.get(node.value()) else { continue };
-        write_value(widget, level + 1, node.value(), output)?;
-        walk_tree(level + 1, node.children(), values, output)?;
-    }
-
-    Ok(())
-}
-
-fn write_value(widget: &WidgetContainer<'_>, level: usize, widget_id: WidgetId, output: &mut String) -> Result {
-    write!(output, "{}:{}", widget_id.index(), widget_id.generation())?;
-    let indent = " ".repeat(level * 4);
-    write!(output, "{indent}{}:{} ", widget_id.index(), widget_id.generation())?;
-
-    match &widget.kind {
-        WidgetKind::Element(element) => writeln!(output, "{}", element.ident),
-        WidgetKind::For(_) => writeln!(output, "<for>"),
-        WidgetKind::With(_) => writeln!(output, "<with>"),
-        WidgetKind::Iteration(_) => writeln!(output, "<iter>"),
-        WidgetKind::ControlFlow(_) => writeln!(output, "<control flow>"),
-        WidgetKind::ControlFlowContainer(_) => writeln!(output, "<control flow container>"),
-        WidgetKind::Component(_) => writeln!(output, "<component>"),
-        WidgetKind::Slot => writeln!(output, "<slot>"),
-    }
-}
diff --git a/anathema-widgets/src/tree/mod.rs b/anathema-widgets/src/tree/mod.rs
deleted file mode 100644
index f0625d51..00000000
--- a/anathema-widgets/src/tree/mod.rs
+++ /dev/null
@@ -1,495 +0,0 @@
-// -----------------------------------------------------------------------------
-//   - Here be dragons -
-//   This code needs cleaning up.
-//
-//   At some point this should be better documented and broken
-//   into smaller pieces.
-//
-//   TODO: clean this blessed mess
-// -----------------------------------------------------------------------------
-use std::ops::ControlFlow;
-
-use anathema_state::Value as StateValue;
-use anathema_templates::blueprints::Blueprint;
-use anathema_value_resolver::{AttributeStorage, Scope};
-
-use crate::error::Result;
-use crate::layout::{LayoutCtx, LayoutFilter};
-use crate::nodes::controlflow::Else;
-use crate::nodes::loops::Iteration;
-use crate::nodes::{controlflow, eval_blueprint};
-use crate::widget::WidgetTreeView;
-use crate::{Element, WidgetContainer, WidgetId, WidgetKind};
-
-pub mod debug;
-
-// TODO:
-// Add the option to "skip" values with an offset for `inner_each` (this is for overflow widgets)
-// Note that this might not be possible, depending on how widget generation goes
-
-/// Determine what kind of widgets that should be laid out:
-/// Fixed or floating.
-#[derive(Debug, Copy, Clone)]
-pub enum WidgetPositionFilter {
-    Floating,
-    Fixed,
-    All,
-    None,
-}
-
-#[derive(Debug, Copy, Clone)]
-pub enum Generator<'widget, 'bp> {
-    Single {
-        ident: &'bp str,
-        body: &'bp [Blueprint],
-    },
-    Loop {
-        len: usize,
-        binding: &'bp str,
-        body: &'bp [Blueprint],
-    },
-    Iteration {
-        binding: &'bp str,
-        body: &'bp [Blueprint],
-    },
-    With {
-        binding: &'bp str,
-        body: &'bp [Blueprint],
-    },
-    ControlFlow(&'widget controlflow::ControlFlow<'bp>),
-    ControlFlowContainer(&'bp [Blueprint]),
-    Slot(&'bp [Blueprint]),
-}
-
-impl<'widget, 'bp> Generator<'widget, 'bp> {
-    fn from_loop(body: &'bp [Blueprint], binding: &'bp str, len: usize) -> Self {
-        Self::Loop { binding, body, len }
-    }
-
-    fn from_with(body: &'bp [Blueprint], binding: &'bp str) -> Self {
-        Self::With { binding, body }
-    }
-}
-
-impl<'widget, 'bp> From<&'widget WidgetContainer<'bp>> for Generator<'widget, 'bp> {
-    fn from(widget: &'widget WidgetContainer<'bp>) -> Self {
-        match &widget.kind {
-            WidgetKind::Element(_) => panic!("use Self::Single directly"),
-            WidgetKind::For(_) => panic!("use Self::Loop directly"),
-            WidgetKind::With(_) => panic!("use Self::With directly"),
-            WidgetKind::ControlFlowContainer(_) => Self::ControlFlowContainer(widget.children),
-            WidgetKind::Component(comp) => Self::Single {
-                ident: comp.name,
-                body: widget.children,
-            },
-            WidgetKind::Iteration(iter) => Self::Iteration {
-                binding: iter.binding,
-                body: widget.children,
-            },
-            WidgetKind::ControlFlow(controlflow) => Self::ControlFlow(controlflow),
-            WidgetKind::Slot => Self::Slot(widget.children),
-        }
-    }
-}
-
-// -----------------------------------------------------------------------------
-//   - Layout -
-// -----------------------------------------------------------------------------
-#[derive(Debug)]
-pub struct LayoutForEach<'a, 'bp> {
-    tree: WidgetTreeView<'a, 'bp>,
-    scope: &'a Scope<'a, 'bp>,
-    generator: Option<Generator<'a, 'bp>>,
-    parent_component: Option<WidgetId>,
-    pub parent_element: Option<WidgetId>,
-    filter: LayoutFilter,
-}
-
-impl<'a, 'bp> LayoutForEach<'a, 'bp> {
-    pub fn new(tree: WidgetTreeView<'a, 'bp>, scope: &'a Scope<'a, 'bp>, filter: LayoutFilter) -> Self {
-        Self {
-            tree,
-            scope,
-            generator: None,
-            parent_component: None,
-            parent_element: None,
-            filter,
-        }
-    }
-
-    fn with_generator(
-        tree: WidgetTreeView<'a, 'bp>,
-        scope: &'a Scope<'a, 'bp>,
-        generator: Generator<'a, 'bp>,
-        filter: LayoutFilter,
-        parent_component: Option<WidgetId>,
-        parent_element: Option<WidgetId>,
-    ) -> Self {
-        Self {
-            tree,
-            scope,
-            generator: Some(generator),
-            filter,
-            parent_component,
-            parent_element,
-        }
-    }
-
-    pub fn each<F>(&mut self, ctx: &mut LayoutCtx<'_, 'bp>, mut f: F) -> Result<ControlFlow<()>>
-    where
-        F: FnMut(&mut LayoutCtx<'_, 'bp>, &mut Element<'bp>, LayoutForEach<'_, 'bp>) -> Result<ControlFlow<()>>,
-    {
-        self.inner_each(ctx, &mut f)
-    }
-
-    fn inner_each<F>(&mut self, ctx: &mut LayoutCtx<'_, 'bp>, f: &mut F) -> Result<ControlFlow<()>>
-    where
-        F: FnMut(&mut LayoutCtx<'_, 'bp>, &mut Element<'bp>, LayoutForEach<'_, 'bp>) -> Result<ControlFlow<()>>,
-    {
-        for index in 0..self.tree.layout_len() {
-            match self.process(index, ctx, f)? {
-                ControlFlow::Continue(_) => continue,
-                ControlFlow::Break(_) => return Ok(ControlFlow::Break(())),
-            }
-        }
-
-        // If there is no parent then there can be no children generated
-        let Some(parent) = self.generator else { return Ok(ControlFlow::Continue(())) };
-
-        // NOTE: Generate will never happen unless the preceding iteration returns `Continue(())`.
-        //       Therefore there is no need to worry about excessive creation of `Iter`s for loops.
-        loop {
-            let index = self.tree.layout_len();
-            if !generate(
-                parent,
-                &mut self.tree,
-                ctx,
-                self.scope,
-                self.parent_component,
-                self.parent_element,
-            )? {
-                break;
-            }
-            match self.process(index, ctx, f)? {
-                ControlFlow::Continue(_) => continue,
-                ControlFlow::Break(_) => return Ok(ControlFlow::Break(())),
-            }
-        }
-
-        Ok(ControlFlow::Continue(()))
-    }
-
-    // TODO: this function is gross and large
-    fn process<F>(&mut self, index: usize, ctx: &mut LayoutCtx<'_, 'bp>, f: &mut F) -> Result<ControlFlow<()>>
-    where
-        F: FnMut(&mut LayoutCtx<'_, 'bp>, &mut Element<'bp>, LayoutForEach<'_, 'bp>) -> Result<ControlFlow<()>>,
-    {
-        let node = self
-            .tree
-            .layout
-            .get(index)
-            .expect("widgets are always generated before processed");
-
-        let widget_id = node.value();
-
-        self.tree
-            .with_value_mut(widget_id, |_, widget, children| {
-                let output = self.filter.filter(widget, ctx.attribute_storage);
-                if let FilterOutput::Exclude = output {
-                    return Ok(ControlFlow::Continue(()));
-                }
-
-                match &mut widget.kind {
-                    WidgetKind::Element(el) => {
-                        let children = LayoutForEach::with_generator(
-                            children,
-                            self.scope,
-                            Generator::Single {
-                                ident: el.ident,
-                                body: widget.children,
-                            },
-                            self.filter,
-                            self.parent_component,
-                            Some(el.id()),
-                        );
-                        f(ctx, el, children)
-                    }
-                    WidgetKind::ControlFlow(_) => {
-                        let generator = Generator::from(&*widget);
-                        let mut children = LayoutForEach::with_generator(
-                            children,
-                            self.scope,
-                            generator,
-                            self.filter,
-                            self.parent_component,
-                            self.parent_element,
-                        );
-                        children.inner_each(ctx, f)
-                    }
-                    WidgetKind::For(for_loop) => {
-                        let len = for_loop.collection.len();
-                        if len == 0 {
-                            return Ok(ControlFlow::Break(()));
-                        }
-
-                        let scope = Scope::with_collection(&for_loop.collection, self.scope);
-                        let mut children = LayoutForEach::with_generator(
-                            children,
-                            &scope,
-                            Generator::from_loop(widget.children, for_loop.binding, len),
-                            self.filter,
-                            self.parent_component,
-                            self.parent_element,
-                        );
-
-                        children.inner_each(ctx, f)
-                    }
-                    WidgetKind::Iteration(iteration) => {
-                        let loop_index = *iteration.loop_index.to_ref() as usize;
-                        let scope = Scope::with_index(
-                            iteration.binding,
-                            loop_index,
-                            self.scope,
-                            iteration.loop_index.reference(),
-                        );
-                        let mut children = LayoutForEach::with_generator(
-                            children,
-                            &scope,
-                            Generator::from(&*widget),
-                            self.filter,
-                            self.parent_component,
-                            self.parent_element,
-                        );
-                        children.inner_each(ctx, f)
-                    }
-                    WidgetKind::With(with) => {
-                        let scope = Scope::with_value(with.binding, &with.data, self.scope);
-                        let mut children = LayoutForEach::with_generator(
-                            children,
-                            &scope,
-                            Generator::from_with(widget.children, with.binding),
-                            self.filter,
-                            self.parent_component,
-                            self.parent_element,
-                        );
-
-                        children.inner_each(ctx, f)
-                    }
-                    WidgetKind::Component(component) => {
-                        let parent_component = component.widget_id;
-                        let state_id = component.state_id();
-                        let scope = Scope::with_component(state_id, component.widget_id, Some(self.scope));
-                        let mut children = LayoutForEach::with_generator(
-                            children,
-                            &scope,
-                            Generator::from(&*widget),
-                            self.filter,
-                            Some(parent_component),
-                            self.parent_element,
-                        );
-                        children.inner_each(ctx, f)
-                    }
-                    WidgetKind::ControlFlowContainer(_) => {
-                        let mut children = LayoutForEach::with_generator(
-                            children,
-                            self.scope,
-                            Generator::from(&*widget),
-                            self.filter,
-                            self.parent_component,
-                            self.parent_element,
-                        );
-                        children.inner_each(ctx, f)
-                    }
-                    WidgetKind::Slot => {
-                        let mut children = LayoutForEach::with_generator(
-                            children,
-                            self.scope.outer(),
-                            Generator::from(&*widget),
-                            self.filter,
-                            self.parent_component,
-                            self.parent_element,
-                        );
-                        children.inner_each(ctx, f)
-                    }
-                }
-            })
-            .unwrap_or(Ok(ControlFlow::Continue(())))
-    }
-}
-
-// Generate the next available widget into the tree
-// TODO: break this down into more manageable code.
-//       this is a hot mess
-fn generate<'bp>(
-    parent: Generator<'_, 'bp>,
-    tree: &mut WidgetTreeView<'_, 'bp>,
-    ctx: &mut LayoutCtx<'_, 'bp>,
-    scope: &Scope<'_, 'bp>,
-    parent_component: Option<WidgetId>,
-    parent_widget: Option<WidgetId>,
-) -> Result<bool> {
-    match parent {
-        Generator::Single { body: blueprints, .. }
-        | Generator::Iteration { body: blueprints, .. }
-        | Generator::With { body: blueprints, .. }
-        | Generator::Slot(blueprints)
-        | Generator::ControlFlowContainer(blueprints) => {
-            if blueprints.is_empty() {
-                return Ok(false);
-            }
-
-            let index = tree.layout_len();
-            if index >= blueprints.len() {
-                return Ok(false);
-            }
-
-            let mut ctx = ctx.eval_ctx(parent_component, parent_widget);
-            eval_blueprint(&blueprints[index], &mut ctx, scope, tree.offset, tree)?;
-            Ok(true)
-        }
-        Generator::Loop { len, .. } if len == tree.layout_len() => Ok(false),
-        Generator::Loop { binding, body, .. } => {
-            let loop_index = tree.layout_len();
-
-            let transaction = tree.insert(tree.offset);
-            let widget = WidgetKind::Iteration(Iteration {
-                loop_index: StateValue::new(loop_index as i64),
-                binding,
-            });
-            let widget = WidgetContainer::new(widget, body, parent_widget);
-            // NOTE: for this to fail one of the values along the path would have to
-            // have been removed
-            transaction.commit_child(widget).unwrap();
-            Ok(true)
-        }
-        Generator::ControlFlow(controlflow) => {
-            let child_count = tree.layout_len();
-            assert_eq!(child_count.saturating_sub(1), 0, "too many branches have been created");
-
-            let should_create = {
-                if child_count == 0 {
-                    true
-                } else {
-                    let node_id = tree.layout[0].value();
-                    let (_, widget) = tree
-                        .values
-                        .get(node_id)
-                        .expect("because the node exists, the value exist");
-
-                    let is_true = match &widget.kind {
-                        WidgetKind::ControlFlowContainer(id) => controlflow.elses[*id as usize].is_true(),
-                        _ => unreachable!("the child of `ControlFlow` can only be `Else`"),
-                    };
-
-                    // The condition no longer holds so the branch has to be trimmed
-                    if is_true {
-                        return Ok(false);
-                    }
-
-                    is_true
-                }
-            };
-
-            if !should_create {
-                return Ok(false);
-            }
-
-            let cond = |(id, node): (usize, &Else<'bp>)| {
-                // If there is a condition but it's not a bool, then it's false
-                // If there is no condition then it's true (a conditionless else)
-                // Everything else is down to the value
-                let cond = match node.cond.as_ref() {
-                    Some(val) => val.truthiness(),
-                    None => true,
-                };
-                match cond {
-                    true => Some((id, node.body)),
-                    false => None,
-                }
-            };
-
-            let (id, body) = match controlflow.elses.iter().enumerate().filter_map(cond).next() {
-                Some(val) => val,
-                None => return Ok(false),
-            };
-
-            let kind = WidgetKind::ControlFlowContainer(id as u16);
-            let widget = WidgetContainer::new(kind, body, parent_widget);
-            let transaction = tree.insert(tree.offset);
-            transaction.commit_child(widget);
-
-            Ok(true)
-        }
-    }
-}
-
-#[derive(Debug)]
-pub enum FilterOutput<T, F> {
-    Include(T, F),
-    Exclude,
-    Continue,
-}
-
-pub trait Filter<'bp>: std::fmt::Debug + Copy {
-    type Output: std::fmt::Debug;
-
-    fn filter<'a>(
-        &mut self,
-        widget: &'a mut WidgetContainer<'bp>,
-        attribute_storage: &AttributeStorage<'_>,
-    ) -> FilterOutput<&'a mut Self::Output, Self>;
-}
-
-// -----------------------------------------------------------------------------
-//   - Position / Paint -
-// -----------------------------------------------------------------------------
-#[derive(Debug)]
-pub struct ForEach<'a, 'bp, Fltr> {
-    tree: WidgetTreeView<'a, 'bp>,
-    attribute_storage: &'a AttributeStorage<'bp>,
-    pub filter: Fltr,
-}
-
-impl<'a, 'bp, Fltr: Filter<'bp>> ForEach<'a, 'bp, Fltr> {
-    pub fn new(tree: WidgetTreeView<'a, 'bp>, attribute_storage: &'a AttributeStorage<'bp>, filter: Fltr) -> Self {
-        Self {
-            tree,
-            attribute_storage,
-            filter,
-        }
-    }
-
-    pub fn each<F>(&mut self, mut f: F) -> ControlFlow<()>
-    where
-        F: FnMut(&mut Fltr::Output, ForEach<'_, 'bp, Fltr>) -> ControlFlow<()>,
-    {
-        self.inner_each(&mut f)
-    }
-
-    fn inner_each<F>(&mut self, f: &mut F) -> ControlFlow<()>
-    where
-        F: FnMut(&mut Fltr::Output, ForEach<'_, 'bp, Fltr>) -> ControlFlow<()>,
-    {
-        for index in 0..self.tree.layout_len() {
-            _ = self.process(index, f);
-        }
-
-        ControlFlow::Continue(())
-    }
-
-    fn process<F>(&mut self, index: usize, f: &mut F) -> ControlFlow<()>
-    where
-        F: FnMut(&mut Fltr::Output, ForEach<'_, 'bp, Fltr>) -> ControlFlow<()>,
-    {
-        let Some(node) = self.tree.layout.get(index) else { panic!() };
-        self.tree
-            .with_value_mut(node.value(), |_, widget, children| {
-                match self.filter.filter(widget, self.attribute_storage) {
-                    FilterOutput::Include(el, filter) => f(el, ForEach::new(children, self.attribute_storage, filter)),
-                    FilterOutput::Exclude => ControlFlow::Break(()),
-                    FilterOutput::Continue => ForEach::new(children, self.attribute_storage, self.filter).inner_each(f),
-                }
-            })
-            .unwrap() // TODO: unwrap...
-    }
-}
diff --git a/anathema-widgets/src/widget/attributes.rs b/anathema-widgets/src/widget/attributes.rs
deleted file mode 100644
index 2fc08b6e..00000000
--- a/anathema-widgets/src/widget/attributes.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-use std::ops::Deref;
-
-use anathema_state::{CommonVal, PendingValue};
-use anathema_store::slab::{Gen, SecondaryMap};
-use anathema_store::smallmap::{SmallIndex, SmallMap};
-use anathema_value_resolver::Value;
-
-use crate::paint::CellAttributes;
-use crate::widget::ValueKey;
-use crate::WidgetId;
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn read_attribute() {
-        let mut attributes = Attributes::empty(WidgetId::ZERO);
-        let s = String::from("hello");
-        attributes.set("str", s.as_ref());
-        attributes.set("num", 123u32);
-
-        assert_eq!("hello", attributes.get_ref::<&str>("str").unwrap());
-        assert_eq!(123, attributes.get::<u32>("num").unwrap());
-    }
-
-    #[test]
-    fn write_attribute() {
-        let mut attributes = Attributes::empty(WidgetId::ZERO);
-        attributes.set("num", 123u32);
-        attributes.set("num", 1u32);
-        assert_eq!(1, attributes.get::<u32>("num").unwrap());
-    }
-
-    #[test]
-    fn remove_attribute() {
-        let mut attributes = Attributes::empty(WidgetId::ZERO);
-        attributes.set("num", 123u32);
-        attributes.remove("num");
-        assert!(attributes.get::<u32>("num").is_none());
-    }
-
-    #[test]
-    fn contains_attribute() {
-        let mut attributes = Attributes::empty(WidgetId::ZERO);
-        attributes.set("num", 123u32);
-        assert!(attributes.contains("num"));
-    }
-}
diff --git a/anathema-widgets/src/widget/factory.rs b/anathema-widgets/src/widget/factory.rs
deleted file mode 100644
index be65c4d0..00000000
--- a/anathema-widgets/src/widget/factory.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-use std::collections::HashMap;
-
-use anathema_value_resolver::Attributes;
-
-use super::{AnyWidget, Widget};
-use crate::error::{ErrorKind, Result};
-
-pub struct Factory(HashMap<Box<str>, Box<dyn Fn(&Attributes<'_>) -> Box<dyn AnyWidget>>>);
-
-impl Factory {
-    pub fn new() -> Self {
-        Self(HashMap::new())
-    }
-
-    pub(crate) fn make(&self, ident: &str, attribs: &Attributes<'_>) -> Result<Box<dyn AnyWidget>, ErrorKind> {
-        let f = self.0.get(ident).ok_or(ErrorKind::InvalidElement(ident.to_string()))?;
-        Ok((f)(attribs))
-    }
-
-    pub fn register_widget(&mut self, ident: &str, factory: impl Fn(&Attributes<'_>) -> Box<dyn AnyWidget> + 'static) {
-        self.0.insert(ident.into(), Box::new(factory));
-    }
-
-    pub fn register_default<W: 'static + Widget + Default>(&mut self, ident: &str) {
-        self.0.insert(ident.into(), Box::new(|_| Box::<W>::default()));
-    }
-}
diff --git a/anathema-widgets/src/widget/mod.rs b/anathema-widgets/src/widget/mod.rs
deleted file mode 100644
index 27c0cc24..00000000
--- a/anathema-widgets/src/widget/mod.rs
+++ /dev/null
@@ -1,356 +0,0 @@
-use std::any::Any;
-use std::fmt::{self, Debug};
-use std::ops::ControlFlow;
-
-use anathema_geometry::{Pos, Region, Size};
-use anathema_state::StateId;
-use anathema_store::slab::SecondaryMap;
-use anathema_store::tree::{Tree, TreeView};
-use anathema_templates::ComponentBlueprintId;
-use anathema_value_resolver::AttributeStorage;
-
-pub use self::factory::Factory;
-pub use self::style::{Attributes, Style};
-use crate::WidgetContainer;
-use crate::error::Result;
-use crate::layout::{Constraints, LayoutCtx, PositionCtx, PositionFilter};
-use crate::paint::{PaintCtx, PaintFilter, SizePos};
-pub use crate::tree::{Filter, ForEach, LayoutForEach};
-
-mod factory;
-mod style;
-
-pub type WidgetTreeView<'a, 'bp> = TreeView<'a, WidgetContainer<'bp>>;
-pub type WidgetTree<'a> = Tree<WidgetContainer<'a>>;
-pub type LayoutChildren<'a, 'bp> = LayoutForEach<'a, 'bp>;
-pub type PositionChildren<'a, 'bp> = ForEach<'a, 'bp, PositionFilter>;
-pub type PaintChildren<'a, 'bp> = ForEach<'a, 'bp, PaintFilter>;
-pub type WidgetId = anathema_store::slab::Key;
-
-#[derive(Debug)]
-pub struct CompEntry {
-    /// The state owned by this component
-    pub state_id: StateId,
-    /// The components id in the widget tree
-    pub widget_id: WidgetId,
-
-    /// Does the component accept tick events
-    pub accept_ticks: bool,
-
-    component_id: ComponentBlueprintId,
-}
-
-// -----------------------------------------------------------------------------
-//   - Components -
-// -----------------------------------------------------------------------------
-
-/// Store a list of components currently in the tree
-pub struct Components {
-    inner: Vec<CompEntry>,
-}
-
-impl Components {
-    pub fn new() -> Self {
-        Self { inner: vec![] }
-    }
-
-    pub fn push(
-        &mut self,
-        component_id: ComponentBlueprintId,
-        widget_id: WidgetId,
-        state_id: StateId,
-        accept_ticks: bool,
-    ) {
-        let entry = CompEntry {
-            component_id,
-            widget_id,
-            state_id,
-            accept_ticks,
-        };
-
-        self.inner.push(entry)
-    }
-
-    pub fn try_remove(&mut self, widget_id: WidgetId) {
-        self.inner.retain(|entry| entry.widget_id != widget_id);
-    }
-
-    /// Get the component by its index
-    pub fn get(&mut self, index: usize) -> Option<(WidgetId, StateId)> {
-        self.inner.get(index).map(|e| (e.widget_id, e.state_id))
-    }
-
-    /// This is used to send messages to components.
-    /// The `ComponentBlueprintId` is only available to components that were added
-    /// as a singular component, not prototypes
-    pub fn get_by_component_id(&mut self, id: ComponentBlueprintId) -> Option<&CompEntry> {
-        self.inner.iter().find(|e| e.component_id == id)
-    }
-
-    /// Get the component by its widget id
-    pub fn get_by_widget_id(&mut self, id: WidgetId) -> Option<(WidgetId, StateId)> {
-        self.inner
-            .iter()
-            .find(|entry| entry.widget_id == id)
-            .map(|e| (e.widget_id, e.state_id))
-    }
-
-    /// Get widget id and state id for a component that accepts tick events
-    pub fn get_ticking(&self, index: usize) -> Option<(WidgetId, StateId)> {
-        self.inner
-            .get(index)
-            .and_then(|e| e.accept_ticks.then_some((e.widget_id, e.state_id)))
-    }
-
-    pub fn iter(&self) -> impl Iterator<Item = &CompEntry> {
-        self.inner.iter()
-    }
-
-    pub fn len(&self) -> usize {
-        self.inner.len()
-    }
-}
-
-#[derive(Debug)]
-pub struct FloatingWidgets(SecondaryMap<WidgetId, WidgetId>);
-
-impl FloatingWidgets {
-    pub fn empty() -> Self {
-        Self(SecondaryMap::empty())
-    }
-
-    pub fn try_remove(&mut self, key: WidgetId) {
-        self.0.try_remove(key);
-    }
-
-    pub(crate) fn insert(&mut self, widget_id: WidgetId) {
-        self.0.insert(widget_id, widget_id);
-    }
-
-    pub fn iter(&self) -> impl Iterator<Item = &WidgetId> {
-        self.0.iter()
-    }
-}
-
-/// Parent in a component relationship
-#[derive(Debug, Copy, Clone)]
-pub struct Parent(pub WidgetId);
-
-impl From<Parent> for WidgetId {
-    fn from(value: Parent) -> Self {
-        value.0
-    }
-}
-
-impl From<WidgetId> for Parent {
-    fn from(value: WidgetId) -> Self {
-        Self(value)
-    }
-}
-
-/// Component relationships, tracking the parent component of each component
-pub struct ComponentParents(SecondaryMap<ComponentBlueprintId, Parent>);
-
-impl ComponentParents {
-    pub fn empty() -> Self {
-        Self(SecondaryMap::empty())
-    }
-
-    pub fn try_remove(&mut self, key: ComponentBlueprintId) {
-        self.0.try_remove(key);
-    }
-
-    pub fn get_parent(&self, child: ComponentBlueprintId) -> Option<Parent> {
-        self.0.get(child).copied()
-    }
-}
-
-// -----------------------------------------------------------------------------
-//   - Any widget -
-// -----------------------------------------------------------------------------
-
-/// Any widget should never be implemented directly
-/// as it's implemented for any type that implements `Widget`
-pub trait AnyWidget {
-    fn to_any_ref(&self) -> &dyn Any;
-    fn to_any_mut(&mut self) -> &mut dyn Any;
-
-    fn any_layout<'bp>(
-        &mut self,
-        children: LayoutForEach<'_, 'bp>,
-        constraints: Constraints,
-        id: WidgetId,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-    ) -> Result<Size>;
-
-    fn any_position<'bp>(
-        &mut self,
-        children: ForEach<'_, 'bp, PositionFilter>,
-        id: WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        ctx: PositionCtx,
-    );
-
-    fn any_paint<'bp>(
-        &mut self,
-        children: ForEach<'_, 'bp, PaintFilter>,
-        id: WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        ctx: PaintCtx<'_, SizePos>,
-    );
-
-    fn any_floats(&self) -> bool;
-
-    fn any_inner_bounds(&self, pos: Pos, size: Size) -> Region;
-
-    fn any_needs_reflow(&mut self) -> bool;
-}
-
-impl<T: 'static + Widget> AnyWidget for T {
-    fn to_any_ref(&self) -> &dyn Any {
-        self
-    }
-
-    fn to_any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    fn any_layout<'bp>(
-        &mut self,
-        children: LayoutForEach<'_, 'bp>,
-        constraints: Constraints,
-        id: WidgetId,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-    ) -> Result<Size> {
-        self.layout(children, constraints, id, ctx)
-    }
-
-    fn any_position<'bp>(
-        &mut self,
-        children: ForEach<'_, 'bp, PositionFilter>,
-        id: WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        ctx: PositionCtx,
-    ) {
-        self.position(children, id, attribute_storage, ctx)
-    }
-
-    fn any_paint<'bp>(
-        &mut self,
-        children: ForEach<'_, 'bp, PaintFilter>,
-        id: WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        ctx: PaintCtx<'_, SizePos>,
-    ) {
-        self.paint(children, id, attribute_storage, ctx)
-    }
-
-    fn any_inner_bounds(&self, pos: Pos, size: Size) -> Region {
-        self.inner_bounds(pos, size)
-    }
-
-    fn any_floats(&self) -> bool {
-        self.floats()
-    }
-
-    fn any_needs_reflow(&mut self) -> bool {
-        self.needs_reflow()
-    }
-}
-
-impl Debug for dyn AnyWidget {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "<dyn AnyWidget>")
-    }
-}
-
-pub trait Widget {
-    fn layout<'bp>(
-        &mut self,
-        children: LayoutForEach<'_, 'bp>,
-        constraints: Constraints,
-        id: WidgetId,
-        ctx: &mut LayoutCtx<'_, 'bp>,
-    ) -> Result<Size>;
-
-    fn paint<'bp>(
-        &mut self,
-        mut children: ForEach<'_, 'bp, PaintFilter>,
-        _id: WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        mut ctx: PaintCtx<'_, SizePos>,
-    ) {
-        _ = children.each(|child, children| {
-            let ctx = ctx.to_unsized();
-            child.paint(children, ctx, attribute_storage);
-            ControlFlow::Continue(())
-        });
-    }
-
-    fn position<'bp>(
-        &mut self,
-        children: ForEach<'_, 'bp, PositionFilter>,
-        id: WidgetId,
-        attribute_storage: &AttributeStorage<'bp>,
-        ctx: PositionCtx,
-    );
-
-    fn floats(&self) -> bool {
-        false
-    }
-
-    fn inner_bounds(&self, pos: Pos, size: Size) -> Region {
-        Region::from((pos, size))
-    }
-
-    fn needs_reflow(&mut self) -> bool {
-        false
-    }
-}
-
-impl Debug for dyn Widget {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "<dyn Widget>")
-    }
-}
-
-// -----------------------------------------------------------------------------
-//   - Dirty widgets collection -
-// -----------------------------------------------------------------------------
-pub struct DirtyWidgets {
-    pub inner: Vec<WidgetId>,
-    last_id: Option<WidgetId>,
-}
-
-impl DirtyWidgets {
-    pub fn empty() -> Self {
-        Self {
-            inner: vec![],
-            last_id: None,
-        }
-    }
-
-    pub fn push(&mut self, widget_id: WidgetId) {
-        if let Some(last) = self.last_id
-            && last == widget_id
-        {
-            return;
-        }
-
-        self.last_id.replace(widget_id);
-        self.inner.push(widget_id);
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.inner.is_empty()
-    }
-
-    pub fn clear(&mut self) {
-        self.inner.clear();
-    }
-
-    pub fn drain(&mut self) -> impl Iterator<Item = WidgetId> {
-        _ = self.last_id.take();
-        self.inner.drain(..)
-    }
-}
diff --git a/anathema-widgets/src/widget/style.rs b/anathema-widgets/src/widget/style.rs
deleted file mode 100644
index 83bbd3cf..00000000
--- a/anathema-widgets/src/widget/style.rs
+++ /dev/null
@@ -1,276 +0,0 @@
-use std::str::FromStr;
-
-use anathema_state::{Color, Hex};
-use anathema_value_resolver::ValueKind;
-
-/// The style for a cell in a [`crate::Buffer`]
-/// A style is applied to ever single cell in a [`crate::Buffer`].
-///
-/// Styles do not cascade (and don't behave like CSS).
-/// So giving a style to a parent widget does not automatically apply it to the child.
-///
-/// The following template would draw a red border with white text inside:
-///
-/// ```text
-/// border [foreground: red]:
-///     text: "hi"
-/// ```
-///
-/// In the following example, if the condition is ever true, and then false the text `is_false`
-/// will be rendered with a red foreground.
-///
-/// The way to reset the foreground is to apply `Color::Reset` to the text.
-///
-/// ```text
-/// if [cond: {{ is_true }}]:
-///     text [foreground: red]: "is true"
-/// else:
-///     text: "is false"
-/// ```
-#[derive(Debug, PartialEq, Eq, Copy, Clone)]
-pub struct Style {
-    /// Foreground colour.
-    pub fg: Option<Color>,
-    /// Background colour.
-    pub bg: Option<Color>,
-    /// Attributes.
-    pub attributes: Attributes,
-}
-
-impl Style {
-    /// Create a new instance of a `Style`:
-    pub const fn new() -> Self {
-        Self {
-            fg: None,
-            bg: None,
-            attributes: Attributes::empty(),
-        }
-    }
-
-    /// Create an instance of `Style` from `CellAttributes`.
-    pub fn from_cell_attribs(attributes: &anathema_value_resolver::Attributes<'_>) -> Self {
-        let mut style = Self::new();
-
-        if let Some(color) = attributes.get("foreground") {
-            let color = match color {
-                ValueKind::Hex(Hex { r, g, b }) => Color::from((*r, *g, *b)),
-                ValueKind::Str(cow) => Color::from_str(cow.as_ref()).unwrap_or(Color::Reset),
-                ValueKind::Int(ansi) => Color::AnsiVal(*ansi as u8),
-                ValueKind::Color(c) => *c,
-                _ => Color::Reset,
-            };
-
-            style.fg = Some(color)
-        }
-
-        if let Some(color) = attributes.get("background") {
-            let color = match color {
-                ValueKind::Color(color) => *color,
-                ValueKind::Hex(Hex { r, g, b }) => Color::from((*r, *g, *b)),
-                ValueKind::Str(cow) => Color::from_str(cow.as_ref()).unwrap_or(Color::Reset),
-                ValueKind::Int(ansi) => Color::AnsiVal(*ansi as u8),
-                _ => Color::Reset,
-            };
-
-            style.bg = Some(color)
-        }
-
-        if let Some(true) = attributes.get_as::<bool>("bold") {
-            style.attributes |= Attributes::BOLD;
-        } else if let Some(false) = attributes.get_as::<bool>("bold") {
-            style.attributes |= Attributes::NORMAL;
-        }
-
-        if let Some(true) = attributes.get_as::<bool>("dim") {
-            style.attributes |= Attributes::DIM;
-        } else if let Some(false) = attributes.get_as::<bool>("dim") {
-            style.attributes |= Attributes::NOT_DIM;
-        }
-
-        if let Some(true) = attributes.get_as::<bool>("italic") {
-            style.attributes |= Attributes::ITALIC;
-        } else if let Some(false) = attributes.get_as::<bool>("italic") {
-            style.attributes |= Attributes::NOT_ITALIC;
-        }
-
-        if let Some(true) = attributes.get_as::<bool>("underline") {
-            style.attributes |= Attributes::UNDERLINED;
-        } else if let Some(false) = attributes.get_as::<bool>("underline") {
-            style.attributes |= Attributes::NOT_UNDERLINED;
-        }
-
-        if let Some(true) = attributes.get_as::<bool>("crossed_out") {
-            style.attributes |= Attributes::CROSSED_OUT;
-        } else if let Some(false) = attributes.get_as::<bool>("crossed_out") {
-            style.attributes |= Attributes::NOT_CROSSED_OUT;
-        }
-
-        if let Some(true) = attributes.get_as::<bool>("overline") {
-            style.attributes |= Attributes::OVERLINED;
-        } else if let Some(false) = attributes.get_as::<bool>("overline") {
-            style.attributes |= Attributes::NOT_OVERLINED;
-        }
-
-        if let Some(true) = attributes.get_as::<bool>("inverse") {
-            style.attributes |= Attributes::REVERSED;
-        } else if let Some(false) = attributes.get_as::<bool>("inverse") {
-            style.attributes |= Attributes::NOT_REVERSED;
-        }
-
-        style
-    }
-
-    /// Set the foreground colour
-    pub fn set_fg(&mut self, fg: Color) {
-        self.fg = Some(fg);
-    }
-
-    /// Set the background colour
-    pub fn set_bg(&mut self, bg: Color) {
-        self.bg = Some(bg);
-    }
-
-    /// Set the style to bold
-    pub fn set_bold(&mut self, bold: bool) {
-        if bold {
-            self.attributes |= Attributes::BOLD;
-        } else {
-            self.attributes &= !Attributes::BOLD;
-        }
-    }
-
-    /// Set the style to italic
-    pub fn set_italic(&mut self, italic: bool) {
-        if italic {
-            self.attributes |= Attributes::ITALIC;
-        } else {
-            self.attributes &= !Attributes::ITALIC;
-        }
-    }
-
-    /// Make the cell dim
-    pub fn set_dim(&mut self, dim: bool) {
-        if dim {
-            self.attributes |= Attributes::DIM;
-        } else {
-            self.attributes &= !Attributes::DIM;
-        }
-    }
-
-    /// Make the cell underlined as long as it's supported
-    pub fn set_underlined(&mut self, underlined: bool) {
-        if underlined {
-            self.attributes |= Attributes::UNDERLINED;
-        } else {
-            self.attributes &= !Attributes::UNDERLINED;
-        }
-    }
-
-    /// Make the cell overlined as long as it's supported
-    pub fn set_overlined(&mut self, overlined: bool) {
-        if overlined {
-            self.attributes |= Attributes::OVERLINED;
-        } else {
-            self.attributes &= !Attributes::OVERLINED;
-        }
-    }
-
-    /// Make the cell crossed out as long as it's supported
-    pub fn set_crossed_out(&mut self, crossed_out: bool) {
-        if crossed_out {
-            self.attributes |= Attributes::CROSSED_OUT;
-        } else {
-            self.attributes &= !Attributes::CROSSED_OUT;
-        }
-    }
-
-    /// Invert the foreground and background
-    pub fn set_reversed(&mut self, inverse: bool) {
-        if inverse {
-            self.attributes |= Attributes::REVERSED;
-        } else {
-            self.attributes &= !Attributes::REVERSED;
-        }
-    }
-
-    /// Reset the style
-    pub fn reset() -> Self {
-        let mut style = Self::new();
-        style.fg = Some(Color::Reset);
-        style.bg = Some(Color::Reset);
-        style
-    }
-
-    /// Merge two styles:
-    /// if `self` has no foreground the foreground from the other style is copied to self.
-    /// if `self` has no background the background from the other style is copied to self.
-    pub fn merge(&mut self, other: Style) {
-        if let (None, Some(fg)) = (self.fg, other.fg) {
-            self.fg = Some(fg);
-        }
-
-        if let (None, Some(bg)) = (self.bg, other.bg) {
-            self.bg = Some(bg);
-        }
-
-        self.attributes |= other.attributes;
-    }
-}
-
-bitflags::bitflags! {
-    /// Style attributes
-    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-    pub struct Attributes: u16 {
-        // Turn style on
-        /// Make the characters bold
-        const BOLD =            0b0000_0000_0000_0001;
-        /// Make the characters dim
-        const DIM =             0b0000_0000_0000_0010;
-        /// Make the characters italic
-        const ITALIC =          0b0000_0000_0000_0100;
-        /// Make the characters underlined
-        const UNDERLINED =      0b0000_0000_0000_1000;
-        /// Make the characters crossed out
-        const CROSSED_OUT =     0b0000_0000_0001_0000;
-        /// Make the characters overlined
-        const OVERLINED =       0b0000_0000_0010_0000;
-        /// Make the characters inverse
-        const REVERSED =        0b0000_0000_0100_0000;
-
-        // Turn style off
-        /// Make the characters not bold
-        const NORMAL =          0b0000_0000_1000_0000;
-        /// Make the characters not dim
-        const NOT_DIM =         0b0000_0001_0000_0000;
-        /// Make the characters not italic
-        const NOT_ITALIC =      0b0000_0010_0000_0000;
-        /// Make the characters not underlined
-        const NOT_UNDERLINED =  0b0000_0100_0000_0000;
-        /// Make the characters not crossed out
-        const NOT_CROSSED_OUT = 0b0000_1000_0000_0000;
-        /// Make the characters not overlined
-        const NOT_OVERLINED =   0b0001_0000_0000_0000;
-        /// Make the characters not inverse
-        const NOT_REVERSED =    0b0010_0000_0000_0000;
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn merging_styles() {
-        let mut right = Style::new();
-        right.set_fg(Color::Green);
-        right.set_bg(Color::Blue);
-
-        let mut left = Style::new();
-        left.set_fg(Color::Red);
-
-        left.merge(right);
-
-        assert_eq!(left.fg.unwrap(), Color::Red);
-        assert_eq!(left.bg.unwrap(), Color::Blue);
-    }
-}
diff --git a/examples/animate.rs b/examples/animate.rs
deleted file mode 100644
index 7bef5a11..00000000
--- a/examples/animate.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-use std::f64::consts::PI;
-use std::time::Duration;
-
-use anathema::component::*;
-use anathema::prelude::*;
-
-#[derive(State)]
-struct Num {
-    x: Value<i32>,
-    speed: Value<f64>,
-}
-
-struct C {
-    val: f64,
-}
-
-fn ease_in_out(val: f64) -> f64 {
-    let x = PI * val;
-    let x = x.cos() - 1.0;
-    -(x / 2.0)
-}
-
-impl Component for C {
-    type Message = ();
-    type State = Num;
-
-    fn on_tick(
-        &mut self,
-        state: &mut Self::State,
-        _: Children<'_, '_>,
-        context: Context<'_, '_, Self::State>,
-        dt: Duration,
-    ) {
-        let x = dt.as_millis() as f64;
-
-        self.val += x / 1000.0 * *state.speed.to_ref();
-        let x = ease_in_out(self.val) * (context.viewport.size().width - 8) as f64;
-        state.x.set(x as i32);
-    }
-
-    fn on_key(&mut self, key: KeyEvent, state: &mut Self::State, _: Children<'_, '_>, _: Context<'_, '_, Self::State>) {
-        if matches!(key.state, KeyState::Press) {
-            match key.code {
-                KeyCode::Char('k') => *state.speed.to_mut() += 0.1,
-                KeyCode::Char('j') => *state.speed.to_mut() -= 0.1,
-                _ => {}
-            }
-        }
-    }
-}
-
-fn main() {
-    let doc = Document::new("@main");
-
-    let mut backend = TuiBackend::builder()
-        .enable_alt_screen()
-        .enable_raw_mode()
-        .hide_cursor()
-        .finish()
-        .unwrap();
-    backend.finalize();
-
-    let mut builder = Runtime::builder(doc, &backend);
-    builder
-        .component(
-            "main",
-            "examples/templates/animate/animate.aml",
-            C { val: 0.0 },
-            Num {
-                x: 0.into(),
-                speed: 0.1.into(),
-            },
-        )
-        .unwrap();
-
-    builder
-        .finish(&mut backend, |runtime, backend| runtime.run(backend))
-        .unwrap();
-}
diff --git a/examples/basic.rs b/examples/basic.rs
deleted file mode 100644
index 858de0f8..00000000
--- a/examples/basic.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-use std::fs::read_to_string;
-
-use anathema::backend::Backend;
-use anathema::backend::tui::TuiBackend;
-use anathema::runtime::Runtime;
-use anathema::templates::{Document, ToSourceKind};
-
-fn main() {
-    let template = read_to_string("examples/templates/basic/basic.aml").unwrap();
-
-    let doc = Document::new("@index");
-
-    let mut backend = TuiBackend::builder()
-        .enable_alt_screen()
-        .enable_raw_mode()
-        .hide_cursor()
-        .finish()
-        .unwrap();
-    backend.finalize();
-
-    let mut builder = Runtime::builder(doc, &backend);
-    builder.template("index", template.to_template()).unwrap();
-    builder
-        .finish(&mut backend, |runtime, backend| runtime.run(backend))
-        .unwrap();
-}
diff --git a/examples/buttons.rs b/examples/buttons.rs
deleted file mode 100644
index e78df0b3..00000000
--- a/examples/buttons.rs
+++ /dev/null
@@ -1,128 +0,0 @@
-use anathema::component::*;
-use anathema::prelude::*;
-
-struct App;
-
-#[derive(State)]
-struct AppState {
-    number: Value<i32>,
-}
-
-impl Component for App {
-    type Message = ();
-    type State = AppState;
-
-    const TICKS: bool = false;
-
-    fn on_event(
-        &mut self,
-        event: &mut UserEvent<'_>,
-        state: &mut Self::State,
-        _: Children<'_, '_>,
-        _: Context<'_, '_, Self::State>,
-    ) {
-        if event.name() == "increment" {
-            *state.number.to_mut() += 1;
-        } else if event.name() == "decrement" {
-            *state.number.to_mut() -= 1;
-        }
-    }
-
-    fn accept_focus(&self) -> bool {
-        false
-    }
-}
-
-struct Button;
-
-#[derive(State)]
-struct ButtonState {
-    active: Value<u8>,
-}
-
-impl Component for Button {
-    type Message = ();
-    type State = ButtonState;
-
-    const TICKS: bool = false;
-
-    fn on_blur(&mut self, state: &mut Self::State, _: Children<'_, '_>, _: Context<'_, '_, Self::State>) {
-        state.active.set(0);
-    }
-
-    fn on_focus(&mut self, state: &mut Self::State, _: Children<'_, '_>, _: Context<'_, '_, Self::State>) {
-        state.active.set(1);
-    }
-
-    fn on_mouse(
-        &mut self,
-        mouse: MouseEvent,
-        _: &mut Self::State,
-        mut children: Children<'_, '_>,
-        mut context: Context<'_, '_, Self::State>,
-    ) {
-        let pos = mouse.pos();
-        children.elements().at_position(pos).first(|_, _| {
-            if mouse.left_down() {
-                context.publish("click", ());
-
-                let id = context.attributes.get_as::<i64>("id").unwrap();
-                context.components.by_attribute("id", id).focus();
-            }
-        });
-    }
-
-    fn on_key(
-        &mut self,
-        key: KeyEvent,
-        _: &mut Self::State,
-        _: Children<'_, '_>,
-        mut context: Context<'_, '_, Self::State>,
-    ) {
-        if !matches!(key.state, KeyState::Press) {
-            return;
-        }
-
-        if let KeyCode::Enter = key.code {
-            context.publish("click", ());
-        }
-    }
-}
-
-fn main() {
-    let doc = Document::new("@main");
-
-    let mut backend = TuiBackend::builder()
-        .enable_alt_screen()
-        .enable_raw_mode()
-        .clear()
-        .hide_cursor()
-        .enable_mouse()
-        .finish()
-        .unwrap();
-    backend.finalize();
-
-    let mut builder = Runtime::builder(doc, &backend);
-
-    builder
-        .component(
-            "main",
-            "examples/templates/buttons/buttons.aml",
-            App,
-            AppState { number: 0.into() },
-        )
-        .unwrap();
-
-    builder
-        .prototype(
-            "button",
-            "examples/templates/buttons/button.aml",
-            || Button,
-            || ButtonState { active: 0.into() },
-        )
-        .unwrap();
-
-    builder
-        .finish(&mut backend, |runtime, backend| runtime.run(backend))
-        .unwrap();
-}
diff --git a/examples/message-passing.rs b/examples/message-passing.rs
deleted file mode 100644
index c0ce429a..00000000
--- a/examples/message-passing.rs
+++ /dev/null
@@ -1,90 +0,0 @@
-use anathema::backend::Backend;
-use anathema::backend::tui::TuiBackend;
-use anathema::component::{Children, Component, Context, MouseEvent};
-use anathema::runtime::Runtime;
-use anathema::state::{List, State, Value};
-use anathema::templates::Document;
-
-pub struct Index;
-
-impl Component for Index {
-    type Message = ();
-    type State = ();
-
-    fn on_mouse(
-        &mut self,
-        mouse: MouseEvent,
-        _: &mut Self::State,
-        mut children: Children<'_, '_>,
-        mut context: Context<'_, '_, Self::State>,
-    ) {
-        if mouse.left_down() {
-            children
-                .elements()
-                .at_position(mouse.pos())
-                .by_attribute("id", "button")
-                .first(|_, attr| {
-                    let Some(value) = attr.get_as::<&str>("id").map(|s| s.to_string()) else { return };
-                    context.components.by_name("messages").send(value);
-                });
-        }
-    }
-}
-
-#[derive(Default, State)]
-pub struct MessagesState {
-    messages: Value<List<String>>,
-    message_count: Value<usize>,
-}
-
-#[derive(Default)]
-pub struct Messages;
-
-impl Component for Messages {
-    type Message = String;
-    type State = MessagesState;
-
-    fn on_message(
-        &mut self,
-        message: Self::Message,
-        state: &mut Self::State,
-        _: Children<'_, '_>,
-        _: Context<'_, '_, Self::State>,
-    ) {
-        if state.messages.len() > 20 {
-            state.messages.pop_front();
-        }
-        let message_count = state.message_count.copy_value() + 1;
-        state.message_count.set(message_count);
-        state.messages.push_back(format!("{message_count} {message}"));
-    }
-}
-
-fn main() {
-    let doc = Document::new("@index");
-    let mut backend = TuiBackend::builder()
-        .enable_raw_mode()
-        .enable_mouse()
-        .hide_cursor()
-        .clear()
-        .finish()
-        .unwrap();
-    backend.finalize();
-
-    let mut builder = Runtime::builder(doc, &backend);
-
-    builder
-        .default::<Messages>("messages", "examples/templates/message-passing/messages.aml")
-        .expect("failed to register messages component");
-
-    builder
-        .component(
-            "index",
-            "examples/templates/message-passing/message_passing.aml",
-            Index,
-            (),
-        )
-        .expect("failed to register index component");
-
-    _ = builder.finish(&mut backend, |runtime, backend| runtime.run(backend));
-}
diff --git a/examples/templates/animate/animate.aml b/examples/templates/animate/animate.aml
deleted file mode 100644
index dc323787..00000000
--- a/examples/templates/animate/animate.aml
+++ /dev/null
@@ -1,11 +0,0 @@
-zstack
-    position [left: state.x, placement: "absolute"]
-        border [background: "blue", foreground: "black", width: 8]
-            text "hello"
-
-    align [alignment: "centre"]
-        border
-            vstack
-                text "speed: " state.speed
-                text "press k to increase"
-                text "press j to decrease"
diff --git a/examples/templates/basic/basic.aml b/examples/templates/basic/basic.aml
deleted file mode 100644
index d60a22be..00000000
--- a/examples/templates/basic/basic.aml
+++ /dev/null
@@ -1,7 +0,0 @@
-align [alignment: "centre"]
-    border
-        vstack
-            text [foreground: "red", italic: true] "You"
-            text [foreground: "green"] "are"
-            text [foreground: "yellow", bold: true] "great!"
-
diff --git a/examples/templates/buttons/button.aml b/examples/templates/buttons/button.aml
deleted file mode 100644
index b5e6052b..00000000
--- a/examples/templates/buttons/button.aml
+++ /dev/null
@@ -1,21 +0,0 @@
-let THEME = [
-    // Inactive
-    {
-        "background": "black",
-        "foreground": "reset",
-    },
-
-    // Active
-    {
-        "background": "grey",
-        "foreground": "black",
-    }
-]
-
-
-border
-    row
-        text [
-            background: THEME[state.active].background,
-            foreground: THEME[state.active].foreground
-        ] attributes.caption
diff --git a/examples/templates/buttons/buttons.aml b/examples/templates/buttons/buttons.aml
deleted file mode 100644
index f82673ea..00000000
--- a/examples/templates/buttons/buttons.aml
+++ /dev/null
@@ -1,7 +0,0 @@
-align [alignment: "centre"]
-    border
-        column
-            text "Simple counter app"
-            @button (click->increment) [caption: "Increment", id: 1]
-            text state.number
-            @button (click->decrement) [caption: "Decrement", id: 2]
diff --git a/examples/templates/message-passing/message_passing.aml b/examples/templates/message-passing/message_passing.aml
deleted file mode 100644
index 5c3063f2..00000000
--- a/examples/templates/message-passing/message_passing.aml
+++ /dev/null
@@ -1,14 +0,0 @@
-vstack [background: #282727]
-    expand [factor: 7]
-        border
-            vstack
-                expand
-                @messages
-
-    expand [factor: 3]
-        border [background: #393836]
-            vstack
-                align [alignment: "center"]
-                    border [background: #658594, id: "button"]
-                        padding [top: 2, bottom: 2, left: 5, right: 5]
-                            text "Send a message"
diff --git a/examples/templates/message-passing/messages.aml b/examples/templates/message-passing/messages.aml
deleted file mode 100644
index 88a033da..00000000
--- a/examples/templates/message-passing/messages.aml
+++ /dev/null
@@ -1,5 +0,0 @@
-for value in state.messages
-    text value
-
-padding [top: 1]
-    text "Received messages: " state.message_count
diff --git a/src/lib.rs b/src/lib.rs
index a4ed1d5b..7771adc5 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2,31 +2,17 @@
 //!
 //! See the guide to get stared: https://togglebyte.github.io/anathema-guide/
 pub use {
-    anathema_backend as backend,                 // backend
-    anathema_default_widgets as default_widgets, // default widgets
-    anathema_geometry as geometry,               // geometry
-    anathema_runtime as runtime,                 // runtime
-    anathema_state as state,                     // state
-    anathema_state_derive as derive,             // derive
-    anathema_store as store,                     // store
-    anathema_templates as templates,             // templates
-    anathema_value_resolver as resolver,         // resolver
-    anathema_widgets as widgets,                 // wigets
+    anathema_core as core,           // core
+    anathema_geometry as geometry,   // geometry
+    anathema_state as state,         // state
+    anathema_state_derive as derive, // derive
+    anathema_store as store,         // store
 };
 
 pub mod prelude {
-    pub use crate::backend::Backend;
-    pub use crate::backend::tui::TuiBackend;
-    pub use crate::runtime::Runtime;
-    pub use crate::templates::{ComponentBlueprintId, Document, SourceKind, ToSourceKind};
-    pub use crate::widgets::components::MessageReceiver;
+    pub use crate::core::templates::{ComponentBlueprintId, Document, SourceKind};
 }
 
 pub mod component {
-    pub use crate::state::{Color, List, Map, Maybe, Nullable, State, Value};
-    pub use crate::widgets::components::events::{
-        Event, KeyCode, KeyEvent, KeyState, MouseButton, MouseEvent, MouseState,
-    };
-    pub use crate::widgets::components::{Component, ComponentId, Context, Emitter, UserEvent};
-    pub use crate::widgets::query::Children;
+    pub use crate::state::{Color, List, Map, Maybe, State, Value};
 }
diff --git a/tests/custom_function.rs b/tests/custom_function.rs
deleted file mode 100644
index 61babe12..00000000
--- a/tests/custom_function.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-use anathema::component::*;
-use anathema::prelude::*;
-use anathema_backend::testing::TestBackend;
-use anathema_runtime::Error;
-use anathema_testutils::{BasicComp, BasicState, character};
-use anathema_value_resolver::ValueKind;
-
-fn keypress(_: KeyEvent, _: &mut BasicState, _: Children<'_, '_>, _: Context<'_, '_, BasicState>) {}
-
-#[test]
-fn run_custom_function() {
-    let tpl = "text state.string.custom()";
-    let doc = Document::new("@index");
-
-    let mut backend = TestBackend::new((10, 3));
-
-    backend.events().next().press(character(' ')).next().stop();
-
-    let mut builder = Runtime::builder(doc, &backend);
-    builder
-        .component(
-            "index",
-            tpl.to_template(),
-            BasicComp::<_, BasicState>::new(keypress),
-            BasicState::default(),
-        )
-        .unwrap();
-
-    builder.register_function("custom", custom).unwrap();
-
-    let res = builder.finish(&mut backend, |runtime, backend| runtime.run(backend));
-
-    assert!(backend.at(0, 0).is_char('x'));
-
-    match res {
-        Ok(_) | Err(Error::Stop) => (),
-        Err(err) => panic!("{err}"),
-    }
-}
-
-fn custom<'bp>(args: &[ValueKind<'bp>]) -> ValueKind<'bp> {
-    if args.len() != 1 {
-        return ValueKind::Null;
-    }
-
-    let mut buffer = String::new();
-    buffer.push('x');
-
-    ValueKind::Str(buffer.into())
-}
diff --git a/tests/if-bug-component-reuse.rs b/tests/if-bug-component-reuse.rs
deleted file mode 100644
index 09263c44..00000000
--- a/tests/if-bug-component-reuse.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-use anathema::component::*;
-use anathema::prelude::*;
-use anathema_backend::testing::TestBackend;
-use anathema_runtime::Error;
-use anathema_testutils::{BasicComp, BasicState, character};
-
-// Bug triggered when a component is used in two separate branches:
-//
-// ```
-// if x
-//     @comp [val: 1]
-// else
-//     @comp [val: 2]
-// ```
-
-static TEMPLATE: &str = "
-container
-    if state.number == 0
-        @comp [val: true]
-    else
-        @comp [val: false]
-";
-
-fn keypress(_: KeyEvent, state: &mut BasicState, _: Children<'_, '_>, _: Context<'_, '_, BasicState>) {
-    *state.number.to_mut() += 1;
-}
-
-#[test]
-fn component_reuse_bug() {
-    let doc = Document::new("@index");
-
-    let mut backend = TestBackend::new((10, 3));
-    backend.events().next().press(character('x')).next().stop();
-
-    let mut builder = Runtime::builder(doc, &backend);
-    builder
-        .component(
-            "index",
-            TEMPLATE.to_template(),
-            BasicComp::<_>::new(keypress),
-            BasicState::default(),
-        )
-        .unwrap();
-    builder
-        .component("comp", "text attributes.val".to_template(), (), ())
-        .unwrap();
-
-    let res = builder.finish(&mut backend, |runtime, backend| runtime.run(backend));
-
-    assert_eq!(backend.line(0), "false");
-
-    match res {
-        Ok(_) | Err(Error::Stop) => (),
-        Err(err) => panic!("{err}"),
-    }
-}
diff --git a/tests/if.rs b/tests/if.rs
deleted file mode 100644
index ae69645b..00000000
--- a/tests/if.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-use anathema::component::*;
-use anathema::prelude::*;
-use anathema_backend::testing::TestBackend;
-use anathema_runtime::Error;
-use anathema_testutils::character;
-
-#[derive(Debug, State)]
-struct S {
-    value: Value<bool>,
-}
-
-impl Default for S {
-    fn default() -> Self {
-        Self { value: true.into() }
-    }
-}
-
-#[derive(Debug, Default)]
-struct C;
-
-impl Component for C {
-    type Message = ();
-    type State = S;
-
-    fn on_key(
-        &mut self,
-        _: KeyEvent,
-        _: &mut Self::State,
-        _: Children<'_, '_>,
-        mut context: Context<'_, '_, Self::State>,
-    ) {
-        context.components.by_name("comp").send(());
-    }
-
-    fn on_message(
-        &mut self,
-        _: Self::Message,
-        state: &mut Self::State,
-        _: Children<'_, '_>,
-        _: Context<'_, '_, Self::State>,
-    ) {
-        state.value.set(false);
-    }
-}
-
-#[test]
-fn eval_if() {
-    let tpl = "
-    if state.value
-        @inner
-    else
-        text 'bork'
-    ";
-
-    let mut backend = TestBackend::new((10, 3));
-
-    backend
-        .events()
-        .next()
-        .press(character('x'))
-        .next_frames(10)
-        .press(character('x'))
-        .stop();
-
-    let doc = Document::new("@comp");
-
-    let mut builder = Runtime::builder(doc, &backend);
-    builder.default::<C>("comp", tpl.to_template()).unwrap();
-    builder.default::<C>("inner", "text '1'".to_template()).unwrap();
-
-    let res = builder.finish(&mut backend, |runtime, backend| runtime.run(backend));
-
-    match res {
-        Ok(_) | Err(Error::Stop) => (),
-        Err(err) => panic!("{err}"),
-    }
-}
diff --git a/tests/mount_unmount.rs b/tests/mount_unmount.rs
deleted file mode 100644
index ccd8e425..00000000
--- a/tests/mount_unmount.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-use anathema::component::*;
-use anathema::prelude::*;
-use anathema_backend::testing::TestBackend;
-use anathema_runtime::Error;
-
-struct Comp;
-
-impl Component for Comp {
-    type Message = ();
-    type State = bool;
-
-    fn on_mount(&mut self, state: &mut Self::State, _: Children<'_, '_>, _: Context<'_, '_, Self::State>) {
-        *state = true;
-    }
-
-    fn on_unmount(&mut self, state: &mut Self::State, _: Children<'_, '_>, _: Context<'_, '_, Self::State>) {
-        if *state {
-            panic!("test passed");
-        }
-    }
-}
-
-#[test]
-#[should_panic(expected = "test passed")]
-fn state_change() {
-    let tpl = "text state";
-    let doc = Document::new("@index");
-
-    let mut backend = TestBackend::new((10, 3));
-
-    backend.events().next().stop();
-
-    let mut builder = Runtime::builder(doc, &backend);
-    builder.component("index", tpl.to_template(), Comp, true).unwrap();
-
-    let res = builder.finish(&mut backend, |runtime, backend| {
-        runtime.with_frame(backend, |backend, mut frame| {
-            frame.tick(backend)?;
-            frame.force_unmount_return();
-            Err(Error::Stop)
-        })
-    });
-
-    assert_eq!(backend.line(0), "true");
-
-    match res {
-        Ok(_) | Err(Error::Stop) => (),
-        Err(err) => panic!("{err}"),
-    }
-}
diff --git a/tests/nested_collections.rs b/tests/nested_collections.rs
deleted file mode 100644
index c8880967..00000000
--- a/tests/nested_collections.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-use anathema::component::*;
-use anathema::prelude::*;
-use anathema_backend::testing::TestBackend;
-use anathema_runtime::Error;
-use anathema_testutils::{BasicComp, character};
-
-#[derive(Debug, State)]
-struct Inner {
-    list: Value<List<u32>>,
-}
-
-impl Default for Inner {
-    fn default() -> Self {
-        Self {
-            list: List::from_iter([1]).into(),
-        }
-    }
-}
-
-#[derive(Debug, State, Default)]
-struct Outer {
-    inner: Value<Inner>,
-}
-
-type Comp<F> = BasicComp<F, Outer>;
-
-fn keypress(_: KeyEvent, state: &mut Outer, _: Children<'_, '_>, _: Context<'_, '_, Outer>) {
-    state.inner.set(Inner {
-        list: List::from_iter([2]).into(),
-    });
-}
-
-#[test]
-fn nested_collections() {
-    let tpl = "
-    container
-        for i in state.inner.list
-            text i
-    ";
-    let doc = Document::new("@index");
-
-    let mut backend = TestBackend::new((10, 3));
-
-    backend.events().next().press(character(' ')).next().stop();
-
-    let mut builder = Runtime::builder(doc, &backend);
-    builder
-        .component("index", tpl.to_template(), Comp::<_>::new(keypress), Outer::default())
-        .unwrap();
-
-    let res = builder.finish(&mut backend, |runtime, backend| runtime.run(backend));
-
-    assert!(backend.at(0, 0).is_char('2'));
-
-    match res {
-        Ok(_) | Err(Error::Stop) => (),
-        Err(err) => panic!("{err}"),
-    }
-}
diff --git a/tests/quit_from_context.rs b/tests/quit_from_context.rs
deleted file mode 100644
index 4b5c02a1..00000000
--- a/tests/quit_from_context.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-use anathema::component::*;
-use anathema::prelude::*;
-use anathema_backend::testing::TestBackend;
-use anathema_runtime::Error;
-use anathema_testutils::{BasicComp, BasicState, character};
-
-fn keypress(_: KeyEvent, _: &mut BasicState, _: Children<'_, '_>, mut ctx: Context<'_, '_, BasicState>) {
-    ctx.stop_runtime();
-}
-
-#[test]
-fn quit_from_context() {
-    let tpl = "text state.number";
-    let doc = Document::new("@index");
-
-    let mut backend = TestBackend::new((10, 3));
-
-    backend.events().next().press(character(' ')).next();
-
-    let mut builder = Runtime::builder(doc, &backend);
-    builder
-        .component(
-            "index",
-            tpl.to_template(),
-            BasicComp::<_, BasicState>::new(keypress),
-            BasicState::default(),
-        )
-        .unwrap();
-
-    let res = builder.finish(&mut backend, |runtime, backend| runtime.run(backend));
-
-    match res {
-        Ok(_) | Err(Error::Stop) => (),
-        Err(err) => panic!("{err}"),
-    }
-}
diff --git a/tests/resize_event.rs b/tests/resize_event.rs
deleted file mode 100644
index 51a90cd1..00000000
--- a/tests/resize_event.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-use anathema::component::*;
-use anathema::prelude::*;
-use anathema_backend::testing::TestBackend;
-use anathema_runtime::Error;
-
-#[derive(Debug, State, Default)]
-struct S {
-    width: Value<u16>,
-    height: Value<u16>,
-}
-
-#[derive(Debug, Default)]
-struct C;
-
-impl Component for C {
-    type Message = ();
-    type State = S;
-
-    #[allow(unused_variables, unused_mut)]
-    fn on_resize(
-        &mut self,
-        state: &mut Self::State,
-        mut children: Children<'_, '_>,
-        mut context: Context<'_, '_, Self::State>,
-    ) {
-        let size = children.elements().first(|el, _| el.size()).unwrap();
-        state.width.set(size.width);
-        state.height.set(size.height);
-    }
-}
-
-#[test]
-fn resize_event() {
-    let mut backend = TestBackend::new((10, 3));
-    let tpl = "
-    expand
-        text state.width * state.height
-    ";
-
-    backend.events().next().resize((2, 2)).next().stop();
-
-    let doc = Document::new("@comp");
-
-    let mut builder = Runtime::builder(doc, &backend);
-    builder.default::<C>("comp", tpl.to_template()).unwrap();
-
-    let res = builder.finish(&mut backend, |runtime, backend| runtime.run(backend));
-
-    // Resize event should be triggered after cycle so that the new size is available
-    assert_eq!(backend.line(0), "4");
-
-    match res {
-        Ok(_) | Err(Error::Stop) => (),
-        Err(err) => panic!("{err}"),
-    }
-}
diff --git a/tests/statechange.rs b/tests/statechange.rs
deleted file mode 100644
index 0993e09a..00000000
--- a/tests/statechange.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-use anathema::component::*;
-use anathema::prelude::*;
-use anathema_backend::testing::TestBackend;
-use anathema_testutils::{BasicComp, BasicState, character};
-
-fn keypress(_: KeyEvent, state: &mut BasicState, _: Children<'_, '_>, _: Context<'_, '_, BasicState>) {
-    state.number.set(9);
-}
-
-#[test]
-fn state_change() {
-    let tpl = "text state.number";
-    let doc = Document::new("@index");
-
-    let mut backend = TestBackend::new((10, 3));
-
-    backend.events().next().press(character(' ')).next().stop();
-
-    let mut builder = Runtime::builder(doc, &backend);
-    builder
-        .component(
-            "index",
-            tpl.to_template(),
-            BasicComp::<_, BasicState>::new(keypress),
-            BasicState::default(),
-        )
-        .unwrap();
-
-    _ = builder.finish(&mut backend, |runtime, backend| runtime.run(backend));
-
-    assert!(backend.at(0, 0).is_char('9'));
-}
diff --git a/tests/tabindex.rs b/tests/tabindex.rs
deleted file mode 100644
index 459be598..00000000
--- a/tests/tabindex.rs
+++ /dev/null
@@ -1,212 +0,0 @@
-use anathema::component::*;
-use anathema::prelude::*;
-use anathema::runtime::Builder;
-use anathema_backend::testing::TestBackend;
-use anathema_runtime::Error;
-use anathema_testutils::{BasicComp, BasicState, character, tab};
-use anathema_widgets::WidgetId;
-use anathema_widgets::tabindex::Index;
-
-fn keypress(_: KeyEvent, state: &mut BasicState, _: Children<'_, '_>, _: Context<'_, '_, BasicState>) {
-    state.number.set(9);
-}
-
-fn comp_index(widget_id: u32, index: Option<Index>) {
-    let index = index.unwrap();
-    assert_eq!(WidgetId::new(widget_id, 0), index.widget_id);
-}
-
-fn builder(template: &'static str, backend: &mut impl Backend) -> Builder<()> {
-    let doc = Document::new(template);
-
-    let mut builder = Runtime::builder(doc, backend);
-    builder
-        .prototype(
-            "comp",
-            String::new().to_template(),
-            || BasicComp::<_, BasicState>::new(keypress),
-            BasicState::default,
-        )
-        .unwrap();
-
-    builder
-}
-
-#[test]
-fn tabindex_change() {
-    let tpl = "
-    vstack
-        @comp [id: 1]
-        @comp [id: 2]
-        @comp [id: 3]
-    ";
-
-    let mut backend = TestBackend::new((10, 3));
-
-    backend
-        .events()
-        .next()
-        .press(tab())
-        .next()
-        .press(tab())
-        .next()
-        .press(tab())
-        .next()
-        .press(tab())
-        .next()
-        .stop();
-
-    let builder = builder(tpl, &mut backend);
-    let res = builder.finish(&mut backend, |runtime, backend| {
-        runtime.with_frame(backend, |backend, mut frame| {
-            // Initial tick to build the tree
-            frame.tick(backend)?;
-
-            assert!(frame.tabindex.is_none());
-            frame.tick(backend)?;
-            comp_index(1, frame.tabindex.clone());
-
-            frame.tick(backend)?;
-            comp_index(2, frame.tabindex.clone());
-
-            frame.tick(backend)?;
-            comp_index(3, frame.tabindex.clone());
-
-            frame.tick(backend)?;
-            comp_index(1, frame.tabindex.clone());
-
-            Err(Error::Stop)
-        })
-    });
-
-    match res {
-        Ok(_) | Err(Error::Stop) => (),
-        Err(err) => panic!("{err}"),
-    }
-}
-
-#[test]
-fn tabindex_single_component() {
-    let tpl = "
-    vstack
-        @comp [id: 1]
-    ";
-
-    let mut backend = TestBackend::new((10, 3));
-
-    backend.events().next().press(tab()).next().press(tab()).next().stop();
-
-    let builder = builder(tpl, &mut backend);
-    let res = builder.finish(&mut backend, |runtime, backend| {
-        runtime.with_frame(backend, |backend, mut frame| {
-            // Initial tick to build the tree
-            frame.tick(backend)?;
-
-            assert!(frame.tabindex.is_none());
-            frame.tick(backend)?;
-            comp_index(1, frame.tabindex.clone());
-
-            frame.tick(backend)?;
-            comp_index(1, frame.tabindex.clone());
-
-            Err(Error::Stop)
-        })
-    });
-
-    match res {
-        Ok(_) | Err(Error::Stop) => (),
-        Err(err) => panic!("{err}"),
-    }
-}
-
-#[test]
-fn tabindex_no_component() {
-    let tpl = "
-    vstack
-    ";
-
-    let mut backend = TestBackend::new((10, 3));
-
-    backend.events().press(tab()).next().press(tab()).next().stop();
-
-    let builder = builder(tpl, &mut backend);
-
-    let res = builder.finish(&mut backend, |runtime, backend| {
-        runtime.with_frame(backend, |backend, mut frame| {
-            // Initial tick to build the tree
-            assert!(frame.tabindex.is_none());
-            frame.tick(backend)?;
-            assert!(frame.tabindex.is_none());
-            frame.tick(backend)?;
-            assert!(frame.tabindex.is_none());
-            Err(Error::Stop)
-        })
-    });
-
-    match res {
-        Ok(_) | Err(Error::Stop) => (),
-        Err(err) => panic!("{err}"),
-    }
-}
-
-struct CompA;
-impl Component for CompA {
-    type Message = ();
-    type State = bool;
-
-    fn on_key(
-        &mut self,
-        _: KeyEvent,
-        _: &mut Self::State,
-        _: Children<'_, '_>,
-        mut context: Context<'_, '_, Self::State>,
-    ) {
-        context.components.by_name("comp_b").focus();
-    }
-
-    fn on_blur(&mut self, state: &mut Self::State, _: Children<'_, '_>, _: Context<'_, '_, Self::State>) {
-        *state = false;
-    }
-}
-
-struct CompB;
-impl Component for CompB {
-    type Message = ();
-    type State = bool;
-
-    fn on_focus(&mut self, state: &mut Self::State, _: Children<'_, '_>, _: Context<'_, '_, Self::State>) {
-        *state = true;
-    }
-}
-
-#[test]
-fn tabindex_change_via_deferred_command() {
-    let tpl = "
-    vstack
-        @comp_a
-        @comp_b
-    ";
-
-    let comp_tpl = "text state";
-
-    let mut backend = TestBackend::new((5, 2));
-
-    backend.events().next().press(character('x')).next().stop();
-
-    let mut builder = builder(tpl, &mut backend);
-    builder
-        .component("comp_a", comp_tpl.to_template(), CompA, true)
-        .unwrap();
-    builder
-        .component("comp_b", comp_tpl.to_template(), CompB, false)
-        .unwrap();
-    let res = builder.finish(&mut backend, |runtime, backend| runtime.run(backend));
-
-    assert_eq!("false", backend.line(0));
-    assert_eq!("true", backend.line(1));
-
-    match res {
-        Ok(_) | Err(Error::Stop) => (),
-        Err(err) => panic!("{err}"),
-    }
-}
diff --git a/tests/with.rs b/tests/with.rs
deleted file mode 100644
index f753989a..00000000
--- a/tests/with.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-use anathema::prelude::*;
-use anathema_backend::testing::TestBackend;
-use anathema_runtime::Error;
-
-static TEMPLATE: &str = "
-with x as 1 + 2 * 3
-    text x
-";
-
-#[test]
-fn eval_with() {
-    let doc = Document::new(TEMPLATE);
-
-    let mut backend = TestBackend::new((10, 3));
-    backend.events().next().next().stop();
-
-    let builder = Runtime::builder(doc, &backend);
-
-    let res = builder.finish(&mut backend, |runtime, backend| runtime.run(backend));
-
-    assert_eq!(backend.line(0), "7");
-
-    match res {
-        Ok(_) | Err(Error::Stop) => (),
-        Err(err) => panic!("{err}"),
-    }
-}