diff --git a/crates/tek_core/examples/demo.rs b/crates/tek_core/examples/demo.rs
index d0711e9c..7123e6c3 100644
--- a/crates/tek_core/examples/demo.rs
+++ b/crates/tek_core/examples/demo.rs
@@ -123,3 +123,22 @@ impl Handle<Tui> for Demo<Tui> {
         Ok(Some(true))
     }
 }
+
+//lisp!(CONTENT Demo (LET
+  //(BORDER-STYLE (STYLE (FG (RGB 0 0 0))))
+  //(BG-COLOR-0   (RGB 0 128 128))
+  //(BG-COLOR-1   (RGB 128 96 0))
+  //(BG-COLOR-2   (RGB 128 64 0))
+  //(BG-COLOR-3   (RGB 96 64 0))
+  //(CENTER (LAYERS
+    //(BACKGROUND BG-COLOR-0)
+      //(OUTSET-XY 1 1 (SPLIT-DOWN
+        //(LAYERS (BACKGROUND BG-COLOR-1)
+                //(BORDER SQUARE BORDER-STYLE)
+                //(OUTSET-XY 2 1 "..."))
+        //(LAYERS (BACKGROUND BG-COLOR-2)
+                //(BORDER LOZENGE BORDER-STYLE)
+                //(OUTSET-XY 4 2 "---"))
+        //(LAYERS (BACKGROUND BG-COLOR-3)
+                //(BORDER SQUARE-BOLD BORDER-STYLE)
+                //(OUTSET-XY 2 1 "~~~"))))))))
diff --git a/crates/tek_core/src/audio.rs b/crates/tek_core/src/audio.rs
index 50a94923..6cb9934f 100644
--- a/crates/tek_core/src/audio.rs
+++ b/crates/tek_core/src/audio.rs
@@ -307,7 +307,7 @@ impl<E: Engine> std::fmt::Debug for JackDevice<E> {
 
 impl<E: Engine> Widget for JackDevice<E> {
     type Engine = E;
-    fn layout (&self, to: E::Area) -> Perhaps<E::Area> {
+    fn layout (&self, to: E::Size) -> Perhaps<E::Size> {
         self.state.read().unwrap().layout(to)
     }
     fn render (&self, to: &mut E) -> Perhaps<E::Area> {
diff --git a/crates/tek_core/src/engine.rs b/crates/tek_core/src/engine.rs
index c668acfd..3fa5e7ca 100644
--- a/crates/tek_core/src/engine.rs
+++ b/crates/tek_core/src/engine.rs
@@ -34,8 +34,8 @@ pub trait Engine: Send + Sync + Sized {
 
 pub trait Widget: Send + Sync {
     type Engine: Engine;
-    fn layout (&self, to: <<Self as Widget>::Engine as Engine>::Area) ->
-        Perhaps<<<Self as Widget>::Engine as Engine>::Area>
+    fn layout (&self, to: <<Self as Widget>::Engine as Engine>::Size) ->
+        Perhaps<<<Self as Widget>::Engine as Engine>::Size>
     {
         Ok(Some(to))
     }
@@ -44,7 +44,7 @@ pub trait Widget: Send + Sync {
 }
 impl<'a, E: Engine> Widget for Box<dyn Widget<Engine = E> + 'a> {
     type Engine = E;
-    fn layout (&self, to: E::Area) -> Perhaps<E::Area> {
+    fn layout (&self, to: E::Size) -> Perhaps<E::Size> {
         (**self).layout(to)
     }
     fn render (&self, to: &mut E) -> Perhaps<E::Area> {
@@ -53,7 +53,7 @@ impl<'a, E: Engine> Widget for Box<dyn Widget<Engine = E> + 'a> {
 }
 impl<E: Engine> Widget for &dyn Widget<Engine = E> {
     type Engine = E;
-    fn layout (&self, to: E::Area)  -> Perhaps<E::Area> {
+    fn layout (&self, to: E::Size)  -> Perhaps<E::Size> {
         (*self).layout(to)
     }
     fn render (&self, to: &mut E) -> Perhaps<E::Area> {
@@ -62,7 +62,7 @@ impl<E: Engine> Widget for &dyn Widget<Engine = E> {
 }
 impl<E: Engine> Widget for &mut dyn Widget<Engine = E> {
     type Engine = E;
-    fn layout (&self, to: E::Area) -> Perhaps<E::Area> {
+    fn layout (&self, to: E::Size) -> Perhaps<E::Size> {
         (**self).layout(to)
     }
     fn render (&self, to: &mut E) -> Perhaps<E::Area> {
@@ -71,7 +71,7 @@ impl<E: Engine> Widget for &mut dyn Widget<Engine = E> {
 }
 impl<E: Engine, W: Widget<Engine = E>> Widget for Arc<W> {
     type Engine = E;
-    fn layout (&self, to: E::Area) -> Perhaps<E::Area> {
+    fn layout (&self, to: E::Size) -> Perhaps<E::Size> {
         self.as_ref().layout(to)
     }
     fn render (&self, to: &mut E) -> Perhaps<E::Area> {
@@ -80,7 +80,7 @@ impl<E: Engine, W: Widget<Engine = E>> Widget for Arc<W> {
 }
 impl<E: Engine, W: Widget<Engine = E>> Widget for Mutex<W> {
     type Engine = E;
-    fn layout (&self, to: E::Area) -> Perhaps<E::Area> {
+    fn layout (&self, to: E::Size) -> Perhaps<E::Size> {
         self.lock().unwrap().layout(to)
     }
     fn render (&self, to: &mut E) -> Perhaps<E::Area> {
@@ -89,7 +89,7 @@ impl<E: Engine, W: Widget<Engine = E>> Widget for Mutex<W> {
 }
 impl<E: Engine, W: Widget<Engine = E>> Widget for RwLock<W> {
     type Engine = E;
-    fn layout (&self, to: E::Area) -> Perhaps<E::Area> {
+    fn layout (&self, to: E::Size) -> Perhaps<E::Size> {
         self.read().unwrap().layout(to)
     }
     fn render (&self, to: &mut E) -> Perhaps<E::Area> {
@@ -98,7 +98,7 @@ impl<E: Engine, W: Widget<Engine = E>> Widget for RwLock<W> {
 }
 impl<E: Engine, W: Widget<Engine = E>> Widget for Option<W> {
     type Engine = E;
-    fn layout (&self, to: E::Area) -> Perhaps<E::Area> {
+    fn layout (&self, to: E::Size) -> Perhaps<E::Size> {
         Ok(self.as_ref().map(|widget|widget.layout(to)).transpose()?.flatten())
     }
     fn render (&self, to: &mut E) -> Perhaps<E::Area> {
@@ -117,12 +117,12 @@ pub trait Content: Send + Sync {
 //}
 impl<E: Engine, W: Content<Engine = E>> Widget for W {
     type Engine = E;
-    fn layout (&self, to: E::Area) -> Perhaps<E::Area> {
+    fn layout (&self, to: E::Size) -> Perhaps<E::Size> {
         self.content().layout(to)
     }
     fn render (&self, to: &mut E) -> Perhaps<E::Area> {
-        match self.layout(to.area())? {
-            Some(area) => to.render_in(area, &self.content()),
+        match self.layout(to.area().wh().into())? {
+            Some(wh) => to.render_in(to.area().clip(wh).into(), &self.content()),
             None => Ok(None)
         }
     }
@@ -394,45 +394,74 @@ impl<T> Align<T> {
     }
 }
 
-impl<E: Engine, T: Widget<Engine = E>> Widget for Align<T> {
-    type Engine = E;
-    fn layout (&self, outer_area: E::Area) -> Perhaps<E::Area> {
-        Ok(match self {
-            Self::Center(_) => self.inner().layout(outer_area)?.map(|inner_area|{
-                let [_, _, w, h] = inner_area.xywh();
-                let offset_x = (outer_area.w() / 2.into()) - (w / 2.into());
-                let offset_y = (outer_area.h() / 2.into()) - (h / 2.into());
-                let result = [outer_area.x() + offset_x, outer_area.y() + offset_y, w, h];
-                result.into()
-            }),
-            Self::X(_) => self.inner().layout(outer_area)?.map(|inner_area|{
-                let [_, y, w, h] = inner_area.xywh();
-                let offset_x = (outer_area.w() - w) / 2.into();
-                let result = [outer_area.x() + offset_x, y, w, h];
-                result.into()
-            }),
-            Self::Y(_) => self.inner().layout(outer_area)?.map(|inner_area|{
-                let [x, _, w, h] = inner_area.xywh();
-                let offset_y = (outer_area.h() / 2.into()) - (h / 2.into());
-                let result = [x, outer_area.y() + offset_y, w, h];
-                result.into()
-            }),
-            Self::NW(_) => { todo!() },
-            Self::N(_)  => { todo!() },
-            Self::NE(_) => { todo!() },
-            Self::W(_)  => { todo!() },
-            Self::E(_)  => { todo!() },
-            Self::SW(_) => { todo!() },
-            Self::S(_)  => { todo!() },
-            Self::SE(_) => { todo!() },
+fn align<T, N: Number, R: Area<N> + From<[N;4]>> (align: &Align<T>, outer: R, inner: R) -> Option<R> {
+    if outer.w() < inner.w() || outer.h() < inner.h() {
+        None
+    } else {
+        let [ox, oy, ow, oh] = outer.xywh();
+        let [ix, iy, iw, ih] = inner.xywh();
+        Some(match align {
+            Align::Center(_) => [ox + (ow - iw) / 2.into(), oy + (oh - ih) / 2.into(), iw, ih,].into(),
+            Align::X(_)  => [ox + (ow - iw) / 2.into(), iy, iw, ih,].into(),
+            Align::Y(_)  => [ix, oy + (oh - ih) / 2.into(), iw, ih,].into(),
+            Align::NW(_) => [ox, oy, iw, ih,].into(),
+            Align::N(_)  => [ox + (ow - iw) / 2.into(), oy, iw, ih,].into(),
+            Align::NE(_) => [ox + ow - iw, oy, iw, ih,].into(),
+            Align::W(_)  => [ox, oy + (oh - ih) / 2.into(), iw, ih,].into(),
+            Align::E(_)  => [ox + ow - iw, oy + (oh - ih) / 2.into(), iw, ih,].into(),
+            Align::SW(_) => [ox, oy + oh - ih, iw, ih,].into(),
+            Align::S(_)  => [ox + (ow - iw) / 2.into(), oy + oh - ih, iw, ih,].into(),
+            Align::SE(_) => [ox + ow - iw, oy + oh - ih, iw, ih,].into(),
         })
     }
+}
+
+impl<E: Engine, T: Widget<Engine = E>> Widget for Align<T> {
+    type Engine = E;
+    fn layout (&self, outer_area: E::Size) -> Perhaps<E::Size> {
+        self.inner().layout(outer_area)
+        //Ok(match self {
+            //Self::Center(_) => self.inner().layout(outer_area)?.map(|inner_area|{
+                //let [_, _, w, h] = inner_area.xywh();
+                //let offset_x = (outer_area.w() / 2.into()) - (w / 2.into());
+                //let offset_y = (outer_area.h() / 2.into()) - (h / 2.into());
+                //let result = [outer_area.x() + offset_x, outer_area.y() + offset_y, w, h];
+                //result.into()
+            //}),
+            //Self::X(_) => self.inner().layout(outer_area)?.map(|inner_area|{
+                //let [_, y, w, h] = inner_area.xywh();
+                //let offset_x = (outer_area.w() - w) / 2.into();
+                //let result = [outer_area.x() + offset_x, y, w, h];
+                //result.into(
+            //}),
+            //Self::Y(_) => self.inner().layout(outer_area)?.map(|inner_area|{
+                //let [x, _, w, h] = inner_area.xywh();
+                //let offset_y = (outer_area.h() / 2.into()) - (h / 2.into());
+                //let result = [x, outer_area.y() + offset_y, w, h];
+                //result.into()
+            //}),
+            //Self::NW(_) => { todo!() },
+            //Self::N(_)  => { todo!() },
+            //Self::NE(_) => { todo!() },
+            //Self::W(_)  => { todo!() },
+            //Self::E(_)  => { todo!() },
+            //Self::SW(_) => { todo!() },
+            //Self::S(_)  => { todo!() },
+            //Self::SE(_) => { todo!() },
+        //})
+    }
     fn render (&self, to: &mut E) -> Perhaps<E::Area> {
-        if let Some(area) = self.layout(to.area())? {
-            to.render_in(area, self.inner())
+        let outer_area = to.area();
+        Ok(if let Some(inner_size) = self.layout(outer_area.wh().into())? {
+            let inner_area = outer_area.clip(inner_size);
+            if let Some(aligned) = align(&self, outer_area.into(), inner_area.into()) {
+                to.render_in(aligned, self.inner())?
+            } else {
+                None
+            }
         } else {
-            Ok(None)
-        }
+            None
+        })
     }
 }
 
@@ -468,16 +497,18 @@ impl<N: Number, T> Min<N, T> {
 }
 impl<E: Engine, T: Widget<Engine = E>> Widget for Min<E::Unit, T> {
     type Engine = E;
-    fn layout (&self, to: E::Area) -> Perhaps<E::Area> {
+    fn layout (&self, to: E::Size) -> Perhaps<E::Size> {
         Ok(self.inner().layout(to)?.map(|to|match *self {
-            Self::X(w, _)     => [to.x(), to.y(), to.w().max(w), to.h()],
-            Self::Y(h, _)     => [to.x(), to.y(), to.w(), to.h().max(h)],
-            Self::XY(w, h, _) => [to.x(), to.y(), to.w().max(w), to.h().max(h)],
+            Self::X(w, _)     => [to.w().max(w), to.h()],
+            Self::Y(h, _)     => [to.w(), to.h().max(h)],
+            Self::XY(w, h, _) => [to.w().max(w), to.h().max(h)],
         }.into()))
     }
     // TODO: 🡘  🡙 ←🡙→
     fn render (&self, to: &mut E) -> Perhaps<E::Area> {
-        Ok(self.layout(to.area())?.map(|a|to.render_in(a, self.inner())).transpose()?.flatten())
+        Ok(self.layout(to.area().wh().into())?
+            .map(|size|to.render_in(to.area().clip(size).into(), self.inner()))
+            .transpose()?.flatten())
     }
 }
 
@@ -499,15 +530,17 @@ impl<N: Number, T> Max<N, T> {
 
 impl<E: Engine, T: Widget<Engine = E>> Widget for Max<E:: Unit, T> {
     type Engine = E;
-    fn layout (&self, to: E::Area) -> Perhaps<E::Area> {
+    fn layout (&self, to: E::Size) -> Perhaps<E::Size> {
         Ok(self.inner().layout(to)?.map(|to|match *self {
-            Self::X(w, _)     => [to.x(), to.y(), to.w().min(w), to.h()],
-            Self::Y(h, _)     => [to.x(), to.y(), to.w(), to.h().min(h)],
-            Self::XY(w, h, _) => [to.x(), to.y(), to.w().min(w), to.h().min(h)],
+            Self::X(w, _)     => [to.w().min(w), to.h()],
+            Self::Y(h, _)     => [to.w(), to.h().min(h)],
+            Self::XY(w, h, _) => [to.w().min(w), to.h().min(h)],
         }.into()))
     }
     fn render (&self, to: &mut E) -> Perhaps<E::Area> {
-        Ok(self.layout(to.area())?.map(|a|to.render_in(a, self.inner())).transpose()?.flatten())
+        Ok(self.layout(to.area().wh().into())?
+            .map(|size|to.render_in(to.area().clip(size).into(), self.inner()))
+            .transpose()?.flatten())
     }
 }
 
@@ -529,15 +562,17 @@ impl<N: Number, T> Grow<N, T> {
 
 impl<E: Engine, T: Widget<Engine = E>> Widget for Grow<E::Unit, T> {
     type Engine = E;
-    fn layout (&self, to: E::Area) -> Perhaps<E::Area> {
+    fn layout (&self, to: E::Size) -> Perhaps<E::Size> {
         Ok(self.inner().layout(to)?.map(|to|match *self {
-            Self::X(w, _)     => [to.x(), to.y(), to.w() + w, to.h()],
-            Self::Y(h, _)     => [to.x(), to.y(), to.w(), to.h() + h],
-            Self::XY(w, h, _) => [to.x(), to.y(), to.w() + w, to.h() + h],
+            Self::X(w, _)     => [to.w() + w, to.h()],
+            Self::Y(h, _)     => [to.w(), to.h() + h],
+            Self::XY(w, h, _) => [to.w() + w, to.h() + h],
         }.into()))
     }
     fn render (&self, to: &mut E) -> Perhaps<E::Area> {
-        Ok(self.layout(to.area())?.map(|a|to.render_in(a, self.inner())).transpose()?.flatten())
+        Ok(self.layout(to.area().wh().into())?
+            .map(|size|to.render_in(to.area().clip(size).into(), self.inner()))
+            .transpose()?.flatten())
     }
 }
 
@@ -559,15 +594,17 @@ impl<N: Number, T: Widget> Shrink<N, T> {
 
 impl<E: Engine, T: Widget<Engine = E>> Widget for Shrink<E::Unit, T> {
     type Engine = E;
-    fn layout (&self, to: E::Area) -> Perhaps<E::Area> {
+    fn layout (&self, to: E::Size) -> Perhaps<E::Size> {
         Ok(self.inner().layout(to)?.map(|to|match *self {
-            Self::X(w, _)     => [to.x(), to.y(), to.w() - w, to.h()],
-            Self::Y(h, _)     => [to.x(), to.y(), to.w(), to.h() - h],
-            Self::XY(w, h, _) => [to.x(), to.y(), to.w() - w, to.h() - h]
+            Self::X(w, _)     => [to.w() - w, to.h()],
+            Self::Y(h, _)     => [to.w(), to.h() - h],
+            Self::XY(w, h, _) => [to.w() - w, to.h() - h]
         }.into()))
     }
     fn render (&self, to: &mut E) -> Perhaps<E::Area> {
-        Ok(self.layout(to.area())?.map(|a|to.render_in(a, self.inner())).transpose()?.flatten())
+        Ok(self.layout(to.area().wh().into())?
+            .map(|size|to.render_in(to.area().clip(size).into(), self.inner()))
+            .transpose()?.flatten())
     }
 }
 
@@ -605,7 +642,7 @@ impl<N: Number, T: Widget> Outset<N, T> {
 
 impl<E: Engine, T: Widget<Engine = E>> Widget for Inset<E::Unit, T> {
     type Engine = E;
-    fn layout (&self, to: E::Area) -> Perhaps<E::Area> {
+    fn layout (&self, to: E::Size) -> Perhaps<E::Size> {
         match *self {
             Self::X(x, ref inner)     => Shrink::X(x + x, inner as &dyn Widget<Engine = E>),
             Self::Y(y, ref inner)     => Shrink::Y(y + y, inner as &dyn Widget<Engine = E>),
@@ -623,7 +660,7 @@ impl<E: Engine, T: Widget<Engine = E>> Widget for Inset<E::Unit, T> {
 
 impl<E: Engine, T: Widget<Engine = E>> Widget for Outset<E::Unit, T> {
     type Engine = E;
-    fn layout (&self, to: E::Area) -> Perhaps<E::Area> {
+    fn layout (&self, to: E::Size) -> Perhaps<E::Size> {
         match *self {
             Self::X(x, ref inner)     => Grow::X(x + x, inner as &dyn Widget<Engine = E>),
             Self::Y(y, ref inner)     => Grow::Y(y + y, inner as &dyn Widget<Engine = E>),
@@ -663,15 +700,17 @@ impl<N: Number, T: Widget> Plus<N, T> {
 
 impl<E: Engine, T: Widget<Engine = E>> Widget for Plus<E::Unit, T> {
     type Engine = E;
-    fn layout (&self, to: E::Area) -> Perhaps<E::Area> {
-        Ok(self.inner().layout(to)?.map(|to|match *self {
-            Self::X(x, _)     => [to.x() + x, to.y(), to.w(), to.h()],
-            Self::Y(y, _)     => [to.x(), to.y() + y, to.w(), to.h()],
-            Self::XY(x, y, _) => [to.x() + x, to.y() + y, to.w(), to.h()]
-        }.into()))
+    fn layout (&self, to: E::Size) -> Perhaps<E::Size> {
+        self.inner().layout(to)
     }
     fn render (&self, to: &mut E) -> Perhaps<E::Area> {
-        Ok(self.layout(to.area())?.map(|a|to.render_in(a, self.inner())).transpose()?.flatten())
+        let area = to.area();
+        Ok(self.layout(area.wh().into())?
+            .map(|size|to.render_in(match *self {
+                Self::X(x, _)     => [area.x() + x, area.y(),     size.w(), size.h()],
+                Self::Y(y, _)     => [area.x(),     area.y() + y, size.w(), size.h()],
+                Self::XY(x, y, _) => [area.x() + x, area.y() + y, size.w(), size.h()],
+            }.into(), self.inner())).transpose()?.flatten())
     }
 }
 
@@ -699,15 +738,17 @@ impl<N: Number, T: Widget> Minus<N, T> {
 
 impl<E: Engine, T: Widget<Engine = E>> Widget for Minus<E::Unit, T> {
     type Engine = E;
-    fn layout (&self, to: E::Area) -> Perhaps<E::Area> {
-        Ok(self.inner().layout(to)?.map(|to|match *self {
-            Self::X(x, _)     => [to.x().minus(x), to.y(), to.w(), to.h()],
-            Self::Y(y, _)     => [to.x(), to.y().minus(y), to.w(), to.h()],
-            Self::XY(x, y, _) => [to.x().minus(x), to.y().minus(y), to.w(), to.h()]
-        }.into()))
+    fn layout (&self, to: E::Size) -> Perhaps<E::Size> {
+        self.inner().layout(to)
     }
     fn render (&self, to: &mut E) -> Perhaps<E::Area> {
-        Ok(self.layout(to.area())?.map(|a|to.render_in(a, self.inner())).transpose()?.flatten())
+        let area = to.area();
+        Ok(self.layout(area.wh().into())?
+            .map(|size|to.render_in(match *self {
+                Self::X(x, _)     => [area.x().minus(x), area.y(),          size.w(), size.h()],
+                Self::Y(y, _)     => [area.x(),     area.y().minus(y),      size.w(), size.h()],
+                Self::XY(x, y, _) => [area.x().minus(x), area.y().minus(y), size.w(), size.h()],
+            }.into(), self.inner())).transpose()?.flatten())
     }
 }
 
diff --git a/crates/tek_core/src/space.rs b/crates/tek_core/src/space.rs
index bb1b8dbc..93a957e4 100644
--- a/crates/tek_core/src/space.rs
+++ b/crates/tek_core/src/space.rs
@@ -1,10 +1,20 @@
 use crate::*;
 
+// TODO: return impl Point and impl Size instead of [N;x]
+// to disambiguate between usage of 2-"tuple"s
+
 pub trait Size<N: Number> {
     fn x (&self) -> N;
     fn y (&self) -> N;
-    fn w (&self) -> N { self.x() }
-    fn h (&self) -> N { self.y() }
+    #[inline] fn w (&self) -> N { self.x() }
+    #[inline] fn h (&self) -> N { self.y() }
+    #[inline] fn expect_min (&self, w: N, h: N) -> Usually<&Self> {
+        if self.w() < w || self.h() < h {
+            Err(format!("min {w}x{h}").into())
+        } else {
+            Ok(self)
+        }
+    }
 }
 
 impl<N: Number> Size<N> for (N, N) {
@@ -24,39 +34,39 @@ pub trait Area<N: Number>: Copy {
     fn h (&self) -> N;
     fn x2 (&self) -> N { self.x() + self.w() }
     fn y2 (&self) -> N { self.y() + self.h() }
-    fn wh (&self) -> [N;2] {
+    #[inline] fn wh (&self) -> [N;2] {
         [self.w(), self.h()]
     }
-    fn xywh (&self) -> [N;4] {
+    #[inline] fn xywh (&self) -> [N;4] {
         [self.x(), self.y(), self.w(), self.h()]
     }
-    fn lrtb (&self) -> [N;4] {
+    #[inline] fn lrtb (&self) -> [N;4] {
         [self.x(), self.x2(), self.y(), self.y2()]
     }
-    fn expect_min (&self, w: N, h: N) -> Usually<&Self> {
+    #[inline] fn expect_min (&self, w: N, h: N) -> Usually<&Self> {
         if self.w() < w || self.h() < h {
             Err(format!("min {w}x{h}").into())
         } else {
             Ok(self)
         }
     }
-    fn clip (&self, wh: impl Size<N>) -> [N;4] {
+    #[inline] fn clip (&self, wh: impl Size<N>) -> [N;4] {
         [self.x(), self.y(), wh.w(), wh.h()]
     }
 }
 
 impl<N: Number> Area<N> for (N, N, N, N) {
-    fn x (&self) -> N { self.0 }
-    fn y (&self) -> N { self.1 }
-    fn w (&self) -> N { self.2 }
-    fn h (&self) -> N { self.3 }
+    #[inline] fn x (&self) -> N { self.0 }
+    #[inline] fn y (&self) -> N { self.1 }
+    #[inline] fn w (&self) -> N { self.2 }
+    #[inline] fn h (&self) -> N { self.3 }
 }
 
 impl<N: Number> Area<N> for [N;4] {
-    fn x (&self) -> N { self[0] }
-    fn y (&self) -> N { self[1] }
-    fn w (&self) -> N { self[2] }
-    fn h (&self) -> N { self[3] }
+    #[inline] fn x (&self) -> N { self[0] }
+    #[inline] fn y (&self) -> N { self[1] }
+    #[inline] fn w (&self) -> N { self[2] }
+    #[inline] fn h (&self) -> N { self[3] }
 }
 
 macro_rules! impl_axis_common { ($A:ident $T:ty) => {
diff --git a/crates/tek_core/src/test.rs b/crates/tek_core/src/test.rs
index 86f239d6..928a34e2 100644
--- a/crates/tek_core/src/test.rs
+++ b/crates/tek_core/src/test.rs
@@ -24,7 +24,7 @@ struct TestArea(u16, u16);
 
 impl Widget for TestArea {
     type Engine = TestEngine;
-    fn layout (&self, to: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, to: [u16;2]) -> Perhaps<[u16;2]> {
         Ok(Some([to[0], to[1], self.0, self.1]))
     }
     fn render (&self, to: &mut Self::Engine) -> Perhaps<[u16;4]> {
diff --git a/crates/tek_core/src/tui.rs b/crates/tek_core/src/tui.rs
index d442c8e8..353c2f5d 100644
--- a/crates/tek_core/src/tui.rs
+++ b/crates/tek_core/src/tui.rs
@@ -246,15 +246,15 @@ pub fn buffer_update (buf: &mut Buffer, area: [u16;4], callback: &impl Fn(&mut C
 
 impl Widget for &str {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
-        let [x, y, ..] = area;
+    fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
         // TODO: line breaks
-        Ok(Some([x, y, self.len() as u16, 1]))
+        Ok(Some([self.len() as u16, 1]))
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
-        let area = self.layout(to.area())?.unwrap();
-        to.blit(&self, area.x(), area.y(), None)?;
-        Ok(Some(area))
+        let [x, y, ..] = to.area();
+        let [w, h] = self.layout(to.area().wh())?.unwrap();
+        to.blit(&self, x, y, None)?;
+        Ok(Some([x, y, w, h]))
     }
 }
 
@@ -262,12 +262,12 @@ pub struct Styled<T: Widget<Engine = Tui>>(pub Option<Style>, pub T);
 
 impl Widget for Styled<&str> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
-        Ok(Some([area.x(), area.y(), self.1.len() as u16, 1]))
+    fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
+        Ok(Some([self.1.len() as u16, 1]))
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
-        let area = self.layout(to.area())?.unwrap();
-        Ok(Some([area.x(), area.y(), self.1.len() as u16, 1]))
+        let _ = self.layout(to.area().wh())?.unwrap();
+        Ok(Some([to.area.x(), to.area.y(), self.1.len() as u16, 1]))
     }
 }
 
@@ -275,8 +275,8 @@ pub struct Background(pub Color);
 
 impl Widget for Background {
     type Engine = Tui;
-    fn layout (&self, [x,y,_,_]: [u16;4]) -> Perhaps<[u16;4]> {
-        Ok(Some([x,y,0,0]))
+    fn layout (&self, _: [u16;2]) -> Perhaps<[u16;2]> {
+        Ok(Some([0,0]))
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
         to.fill_bg(to.area(), self.0);
@@ -286,19 +286,17 @@ impl Widget for Background {
 
 impl<T: Widget<Engine = Tui>> Widget for Fixed<u16, T> {
     type Engine = Tui;
-    fn layout (&self, to: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, to: [u16;2]) -> Perhaps<[u16;2]> {
         Ok(match self {
-            Self::X(w, _) => (to.w() < *w).then(||[to.x() + *w, to.y(), to.w() - *w, to.h()]),
-            Self::Y(h, _) => (to.h() < *h).then(||[to.x(), to.y() + *h, to.w(), to.h() - *h]),
-            Self::XY(w, h, _) => (to.w() < *w || to.h() < *h).then(||[
-                to.x() + *w, to.y() + *h, to.w() - *w, to.h() - *h
-            ])
+            Self::X(w, _) => (to.w() < *w).then(||[to.w() - *w, to.h()]),
+            Self::Y(h, _) => (to.h() < *h).then(||[to.w(), to.h() - *h]),
+            Self::XY(w, h, _) => (to.w() < *w && to.h() < *h).then(||[to.w() - *w, to.h() - *h])
         }.map(|offset_area|self.inner().layout(offset_area.into())).transpose()?.flatten())
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
         // 🡘  🡙 ←🡙→
-        if let Some(area) = self.layout(to.area())? {
-            to.render_in(area, self.inner())
+        if let Some(size) = self.layout(to.area().wh())? {
+            to.render_in(to.area().clip(size), self.inner())
         } else {
             Ok(None)
         }
@@ -310,7 +308,7 @@ where
     F: Send + Sync + Fn(&mut dyn FnMut(&dyn Widget<Engine = Tui>)->Usually<()>)->Usually<()>
 {
     type Engine = Tui;
-    fn layout (&self, to: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, to: [u16;2]) -> Perhaps<[u16;2]> {
         let mut w = 0;
         let mut h = 0;
         match self.1 {
@@ -320,7 +318,7 @@ where
                         return Ok(())
                     }
                     let area = Plus::Y(h, component as &dyn Widget<Engine = Tui>).layout(to)?;
-                    if let Some([_, _, width, height]) = area {
+                    if let Some([width, height]) = area {
                         h += height;
                         w = w.max(width)
                     }
@@ -333,7 +331,7 @@ where
                         return Ok(())
                     }
                     let area = Plus::X(w, component as &dyn Widget<Engine = Tui>).layout(to)?;
-                    if let Some([_, _, width, height]) = area {
+                    if let Some([width, height]) = area {
                         w += width;
                         h = h.max(height)
                     }
@@ -342,7 +340,7 @@ where
             },
             _ => todo!()
         };
-        Ok(Some([to.x(), to.y(), w, h]))
+        Ok(Some([w, h]))
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
         let area = to.area();
@@ -386,8 +384,7 @@ where
     F: Send + Sync + Fn(&mut dyn FnMut(&dyn Widget<Engine = Tui>)->Usually<()>)->Usually<()>
 {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
-        let [x, y, ..] = area;
+    fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
         let mut w = 0;
         let mut h = 0;
         (self.0)(&mut |layer| {
@@ -397,11 +394,14 @@ where
             }
             Ok(())
         })?;
-        Ok(Some([x, y, w, h]))
+        Ok(Some([w, h]))
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
-        self.layout(to.area())?
-            .map(|area|(self.0)(&mut |layer|to.render_in(area, &layer).map(|_|())).map(|_|area))
+        self.layout(to.area().wh())?
+            .map(|size|(self.0)(&mut |layer|{
+                to.render_in(to.area().clip(size), &layer).map(|_|())
+            })
+                .map(|_|to.area()))
             .transpose()
     }
 }
@@ -410,7 +410,7 @@ pub struct Border<S: BorderStyle>(pub S);
 
 impl<S: BorderStyle> Widget for Border<S> {
     type Engine = Tui;
-    fn layout (&self, to: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, to: [u16;2]) -> Perhaps<[u16;2]> {
         Outset::XY(1, 1, "").layout(to)
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
@@ -558,7 +558,7 @@ macro_rules! border {
         }
         impl Widget for $T {
             type Engine = Tui;
-            fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
+            fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
                 Ok(Some(area))
             }
             fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
diff --git a/crates/tek_mixer/src/plugin_view.rs b/crates/tek_mixer/src/plugin_view.rs
index 18529cf8..b9e359c3 100644
--- a/crates/tek_mixer/src/plugin_view.rs
+++ b/crates/tek_mixer/src/plugin_view.rs
@@ -2,7 +2,7 @@ use crate::*;
 
 impl Widget for Plugin<Tui> {
     type Engine = Tui;
-    fn layout (&self, to: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, to: [u16;2]) -> Perhaps<[u16;2]> {
         Ok(Some(to))
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
diff --git a/crates/tek_mixer/src/sample_add.rs b/crates/tek_mixer/src/sample_add.rs
index f21e7f95..b09a2b02 100644
--- a/crates/tek_mixer/src/sample_add.rs
+++ b/crates/tek_mixer/src/sample_add.rs
@@ -31,7 +31,7 @@ impl Exit for AddSampleModal {
 
 impl Widget for AddSampleModal {
     type Engine = Tui;
-    fn layout (&self, to: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, to: [u16;2]) -> Perhaps<[u16;2]> {
         todo!()
         //Align::Center(()).layout(to)
     }
diff --git a/crates/tek_mixer/src/sampler_view.rs b/crates/tek_mixer/src/sampler_view.rs
index 058119a2..f824e2c5 100644
--- a/crates/tek_mixer/src/sampler_view.rs
+++ b/crates/tek_mixer/src/sampler_view.rs
@@ -2,7 +2,7 @@ use crate::*;
 
 impl Widget for Sampler {
     type Engine = Tui;
-    fn layout (&self, to: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, to: [u16;2]) -> Perhaps<[u16;2]> {
         todo!()
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
diff --git a/crates/tek_mixer/src/track_view.rs b/crates/tek_mixer/src/track_view.rs
index efb7838f..50d5e7bc 100644
--- a/crates/tek_mixer/src/track_view.rs
+++ b/crates/tek_mixer/src/track_view.rs
@@ -33,7 +33,7 @@ pub struct TrackView<'a, E: Engine> {
 }
 impl<'a> Widget for TrackView<'a, Tui> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
         todo!()
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
diff --git a/crates/tek_sequencer/src/arranger.rs b/crates/tek_sequencer/src/arranger.rs
index a934ffa7..a34f8e54 100644
--- a/crates/tek_sequencer/src/arranger.rs
+++ b/crates/tek_sequencer/src/arranger.rs
@@ -603,7 +603,7 @@ struct TrackNameColumn<'a>(&'a [Sequencer<Tui>], ArrangerFocus);
 
 impl<'a> Widget for TrackNameColumn<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
         todo!()
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
@@ -635,7 +635,7 @@ struct TrackMonitorColumn<'a>(&'a [Sequencer<Tui>]);
 
 impl<'a> Widget for TrackMonitorColumn<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
         todo!()
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
@@ -668,7 +668,7 @@ struct TrackRecordColumn<'a>(&'a [Sequencer<Tui>]);
 
 impl<'a> Widget for TrackRecordColumn<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
         todo!()
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
@@ -701,7 +701,7 @@ struct TrackOverdubColumn<'a>(&'a [Sequencer<Tui>]);
 
 impl<'a> Widget for TrackOverdubColumn<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
         todo!()
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
@@ -737,7 +737,7 @@ struct TrackEraseColumn<'a>(&'a [Sequencer<Tui>]);
 
 impl<'a> Widget for TrackEraseColumn<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
         todo!()
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
@@ -768,7 +768,7 @@ struct TrackGainColumn<'a>(&'a [Sequencer<Tui>]);
 
 impl<'a> Widget for TrackGainColumn<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
         todo!()
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
@@ -799,7 +799,7 @@ struct TrackScenesColumn<'a>(&'a [Sequencer<Tui>], &'a [Scene], ArrangerFocus);
 
 impl<'a> Widget for TrackScenesColumn<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
         todo!()
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
@@ -867,7 +867,7 @@ impl<E: Engine> ArrangerRenameModal<E> {
 
 impl Widget for ArrangerRenameModal<Tui> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
         todo!()
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
diff --git a/crates/tek_sequencer/src/sequencer.rs b/crates/tek_sequencer/src/sequencer.rs
index 3966cf91..0be4bd45 100644
--- a/crates/tek_sequencer/src/sequencer.rs
+++ b/crates/tek_sequencer/src/sequencer.rs
@@ -200,7 +200,7 @@ impl<E: Engine> Sequencer<E> {
 
 impl Widget for Sequencer<Tui> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
         todo!()
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
@@ -448,7 +448,7 @@ struct SequenceName<'a>(&'a Sequencer<Tui>);
 
 impl<'a> Widget for SequenceName<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
         todo!()
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
@@ -465,7 +465,7 @@ struct SequenceRange;
 
 impl Widget for SequenceRange {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
         todo!()
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
@@ -484,7 +484,7 @@ struct SequenceLoopRange;
 
 impl Widget for SequenceLoopRange {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
         todo!()
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
@@ -504,7 +504,7 @@ struct SequenceNoteRange;
 
 impl Widget for SequenceNoteRange {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
         todo!()
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
@@ -526,7 +526,7 @@ struct SequenceKeys<'a>(&'a Sequencer<Tui>);
 
 impl<'a> Widget for SequenceKeys<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
         todo!()
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
@@ -549,7 +549,7 @@ struct SequenceNotes<'a>(&'a Sequencer<Tui>);
 
 impl<'a> Widget for SequenceNotes<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
         todo!()
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
@@ -582,7 +582,7 @@ struct SequenceCursor<'a>(&'a Sequencer<Tui>);
 
 impl<'a> Widget for SequenceCursor<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
         todo!()
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
@@ -602,7 +602,7 @@ struct SequenceZoom<'a>(&'a Sequencer<Tui>);
 
 impl<'a> Widget for SequenceZoom<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
         todo!()
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
@@ -618,7 +618,7 @@ struct SequenceTimer<'a>(&'a Sequencer<Tui>, Arc<RwLock<Phrase>>);
 
 impl<'a> Widget for SequenceTimer<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
         todo!()
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
diff --git a/crates/tek_sequencer/src/transport.rs b/crates/tek_sequencer/src/transport.rs
index 139d176b..6bbebaad 100644
--- a/crates/tek_sequencer/src/transport.rs
+++ b/crates/tek_sequencer/src/transport.rs
@@ -317,9 +317,9 @@ impl Handle<Tui> for TransportBPM<Tui> {
 }
 impl Widget for TransportBPM<Tui> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
         area.expect_min(10, 1)?;
-        Ok(Some([area.x(), area.y(), 10, 1]))
+        Ok(Some([10, 1]))
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
         let area = to.area();
@@ -371,9 +371,9 @@ impl Handle<Tui> for TransportQuantize<Tui> {
 }
 impl Widget for TransportQuantize<Tui> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
         area.expect_min(10, 1)?;
-        Ok(Some([area.x(), area.y(), 10, 1]))
+        Ok(Some([10, 1]))
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
         let [x, y, ..] = to.area();
@@ -424,9 +424,9 @@ impl Handle<Tui> for TransportSync<Tui> {
 }
 impl Widget for TransportSync<Tui> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
+    fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
         area.expect_min(10, 1)?;
-        Ok(Some([area.x(), area.y(), 10, 1]))
+        Ok(Some([10, 1]))
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
         let [x, y, ..] = to.area();
@@ -470,9 +470,9 @@ impl Handle<Tui> for TransportClock<Tui> {
 }
 impl Widget for TransportClock<Tui> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
-        area.expect_min(10, 1)?;
-        Ok(Some([area.x(), area.y(), 20, 1]))
+    fn layout (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
+        area.expect_min(20, 1)?;
+        Ok(Some([20, 1]))
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
         let [x, y, width, _] = to.area();