diff --git a/radicle-cli/examples/rad-patch.md b/radicle-cli/examples/rad-patch.md
index 406a8d8d..9fad65b6 100644
--- a/radicle-cli/examples/rad-patch.md
+++ b/radicle-cli/examples/rad-patch.md
@@ -99,10 +99,10 @@ And let's leave a quick comment for our team:
 
 ```
 $ rad patch comment 73b73f376e93e09e0419664766ac9e433bf7d389 --message 'I cannot wait to get back to the 90s!'
-╭───────────────────────────────────────────────╮
-│ z6MknSL…StBU8Vi (you) [   ...    ] 5c418a5    │
-│ I cannot wait to get back to the 90s!         │
-╰───────────────────────────────────────────────╯
+╭────────────────────────────────────────────╮
+│ z6MknSL…StBU8Vi (you) [   ...    ] 5c418a5 │
+│ I cannot wait to get back to the 90s!      │
+╰────────────────────────────────────────────╯
 $ rad patch comment 73b73f376e93e09e0419664766ac9e433bf7d389 --message 'My favorite decade!' --reply-to 5c418a5 -q
 729cdf63ce4793ab3cabffbe0dce24db16e45549
 ```
diff --git a/radicle-term/src/ansi.rs b/radicle-term/src/ansi.rs
index 1fb22463..1b6f594e 100644
--- a/radicle-term/src/ansi.rs
+++ b/radicle-term/src/ansi.rs
@@ -12,5 +12,6 @@ mod windows;
 
 pub use color::Color;
 pub use paint::paint;
+pub use paint::Filled;
 pub use paint::Paint;
 pub use style::Style;
diff --git a/radicle-term/src/ansi/paint.rs b/radicle-term/src/ansi/paint.rs
index bbe14a54..e69d17a0 100644
--- a/radicle-term/src/ansi/paint.rs
+++ b/radicle-term/src/ansi/paint.rs
@@ -3,6 +3,7 @@ use std::sync;
 use std::sync::atomic::AtomicBool;
 use std::{fmt, io};
 
+use once_cell::sync::Lazy;
 use unicode_width::UnicodeWidthStr;
 
 use super::color::Color;
@@ -282,6 +283,12 @@ impl Paint<()> {
             || anstyle_query::clicolor_force()
     }
 
+    /// Check 24-bit RGB color support.
+    pub fn truecolor() -> bool {
+        static TRUECOLOR: Lazy<bool> = Lazy::new(anstyle_query::term_supports_color);
+        *TRUECOLOR
+    }
+
     /// Enable paint styling.
     pub fn enable() {
         ENABLED.store(true, sync::atomic::Ordering::SeqCst);
@@ -299,6 +306,19 @@ impl Paint<()> {
     }
 }
 
+/// An object filled with a background color.
+#[derive(Debug, Clone)]
+pub struct Filled<T> {
+    pub item: T,
+    pub color: Color,
+}
+
+impl<T: fmt::Display> fmt::Display for Filled<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", Paint::wrapping(&self.item).bg(self.color))
+    }
+}
+
 /// Shorthand for [`Paint::new`].
 pub fn paint<T>(item: T) -> Paint<T> {
     Paint::new(item)
diff --git a/radicle-term/src/ansi/style.rs b/radicle-term/src/ansi/style.rs
index e17bb14c..5d4d1ee5 100644
--- a/radicle-term/src/ansi/style.rs
+++ b/radicle-term/src/ansi/style.rs
@@ -135,6 +135,19 @@ impl Style {
         self
     }
 
+    /// Merge styles with other. This is an additive process, so colors will only
+    /// be changed if they aren't set on the receiver object.
+    pub fn merge(mut self, other: Style) -> Style {
+        if self.foreground == Color::Unset {
+            self.foreground = other.foreground;
+        }
+        if self.background == Color::Unset {
+            self.background = other.background;
+        }
+        self.properties.set(other.properties);
+        self
+    }
+
     /// Sets `self` to be wrapping.
     ///
     /// A wrapping `Style` converts all color resets written out by the internal
diff --git a/radicle-term/src/cell.rs b/radicle-term/src/cell.rs
index fb8e8c18..a7d82ff4 100644
--- a/radicle-term/src/cell.rs
+++ b/radicle-term/src/cell.rs
@@ -1,12 +1,12 @@
-use std::fmt::Display;
+use std::fmt;
 
-use super::{Element, Line, Paint};
+use super::{Color, Filled, Line, Paint};
 
 use unicode_segmentation::UnicodeSegmentation as _;
 use unicode_width::UnicodeWidthStr;
 
 /// Text that can be displayed on the terminal, measured, truncated and padded.
-pub trait Cell: Display {
+pub trait Cell: fmt::Display {
     /// Type after truncation.
     type Truncated: Cell;
     /// Type after padding.
@@ -14,6 +14,10 @@ pub trait Cell: Display {
 
     /// Cell display width in number of terminal columns.
     fn width(&self) -> usize;
+    /// Background color of cell.
+    fn background(&self) -> Color {
+        Color::Unset
+    }
     /// Truncate cell if longer than given width. Shows the delimiter if truncated.
     #[must_use]
     fn truncate(&self, width: usize, delim: &str) -> Self::Truncated;
@@ -30,6 +34,10 @@ impl Cell for Paint<String> {
         Cell::width(self.content())
     }
 
+    fn background(&self) -> Color {
+        self.style.background
+    }
+
     fn truncate(&self, width: usize, delim: &str) -> Self {
         Self {
             item: self.item.truncate(width, delim),
@@ -50,7 +58,7 @@ impl Cell for Line {
     type Padded = Line;
 
     fn width(&self) -> usize {
-        <Self as Element>::size(self).cols
+        Line::width(self)
     }
 
     fn pad(&self, width: usize) -> Self::Padded {
@@ -74,6 +82,10 @@ impl Cell for Paint<&str> {
         Cell::width(self.item)
     }
 
+    fn background(&self) -> Color {
+        self.style.background
+    }
+
     fn truncate(&self, width: usize, delim: &str) -> Paint<String> {
         Paint {
             item: self.item.truncate(width, delim),
@@ -171,3 +183,24 @@ impl<T: Cell + ?Sized> Cell for &T {
         T::pad(self, width)
     }
 }
+
+impl<T: Cell + fmt::Display> Cell for Filled<T> {
+    type Truncated = T::Truncated;
+    type Padded = T::Padded;
+
+    fn width(&self) -> usize {
+        T::width(&self.item)
+    }
+
+    fn background(&self) -> Color {
+        self.color
+    }
+
+    fn truncate(&self, width: usize, delim: &str) -> Self::Truncated {
+        T::truncate(&self.item, width, delim)
+    }
+
+    fn pad(&self, width: usize) -> Self::Padded {
+        T::pad(&self.item, width)
+    }
+}
diff --git a/radicle-term/src/colors.rs b/radicle-term/src/colors.rs
index 71f6f102..ffdd7853 100644
--- a/radicle-term/src/colors.rs
+++ b/radicle-term/src/colors.rs
@@ -1,7 +1,81 @@
 use crate::ansi::Color;
 
 /// The faintest color; useful for borders and such.
-pub const FAINT: Color = Color::Fixed(236);
+pub const FAINT: Color = fixed::FAINT;
 
-/// Negative color, useful for errors.
-pub const NEGATIVE: Color = Color::Red;
+// RGB (24-bit) colors supported by modern terminals.
+pub mod rgb {
+    use super::*;
+
+    pub const NEGATIVE: Color = Color::RGB(60, 10, 20);
+    pub const POSITIVE: Color = Color::RGB(10, 60, 20);
+    pub const NEGATIVE_DARK: Color = Color::RGB(30, 10, 20);
+    pub const POSITIVE_DARK: Color = Color::RGB(10, 30, 20);
+    pub const NEGATIVE_LIGHT: Color = Color::RGB(170, 80, 120);
+    pub const POSITIVE_LIGHT: Color = Color::RGB(80, 170, 120);
+    pub const DIM: Color = Color::RGB(100, 100, 100);
+    pub const FAINT: Color = Color::RGB(20, 20, 20);
+
+    // Default syntax theme.
+    pub const PURPLE: Color = Color::RGB(0xd2, 0xa8, 0xff);
+    pub const RED: Color = Color::RGB(0xff, 0x7b, 0x72);
+    pub const GREEN: Color = Color::RGB(0x7e, 0xd7, 0x87);
+    pub const TEAL: Color = Color::RGB(0xa5, 0xd6, 0xff);
+    pub const ORANGE: Color = Color::RGB(0xff, 0xa6, 0x57);
+    pub const BLUE: Color = Color::RGB(0x79, 0xc0, 0xff);
+    pub const GREY: Color = Color::RGB(0x8b, 0x94, 0x9e);
+    pub const GREY_LIGHT: Color = Color::RGB(0xc9, 0xd1, 0xd9);
+
+    /// Get a color using the color name.
+    pub fn theme(name: &'static str) -> Option<Color> {
+        match name {
+            "negative" => Some(NEGATIVE),
+            "negative.dark" => Some(NEGATIVE_DARK),
+            "negative.light" => Some(NEGATIVE_LIGHT),
+            "positive" => Some(POSITIVE),
+            "positive.dark" => Some(POSITIVE_DARK),
+            "positive.light" => Some(POSITIVE_LIGHT),
+            "dim" => Some(DIM),
+            "faint" => Some(FAINT),
+            "purple" => Some(PURPLE),
+            "red" => Some(RED),
+            "green" => Some(GREEN),
+            "teal" => Some(TEAL),
+            "orange" => Some(ORANGE),
+            "blue" => Some(BLUE),
+            "grey" => Some(GREY),
+            "grey.light" => Some(GREY_LIGHT),
+
+            _ => None,
+        }
+    }
+}
+
+/// "Fixed" ANSI colors, supported by most terminals.
+pub mod fixed {
+    use super::*;
+
+    /// The faintest color; useful for borders and such.
+    pub const FAINT: Color = Color::Fixed(236);
+    /// Slightly brighter than faint.
+    pub const DIM: Color = Color::Fixed(239);
+
+    /// Get a color using the color name.
+    pub fn theme(name: &'static str) -> Option<Color> {
+        match name {
+            "negative" => Some(Color::Red),
+            "negative.dark" => None,
+            "positive" => Some(Color::Green),
+            "positive.dark" => None,
+            "dim" => None,
+            "faint" => None,
+            "blue" => Some(Color::Blue),
+            "green" => Some(Color::Green),
+            "red" => Some(Color::Red),
+            "teal" => Some(Color::Cyan),
+            "purple" => Some(Color::Magenta),
+
+            _ => None,
+        }
+    }
+}
diff --git a/radicle-term/src/element.rs b/radicle-term/src/element.rs
index 75f27aa8..38a0beac 100644
--- a/radicle-term/src/element.rs
+++ b/radicle-term/src/element.rs
@@ -1,41 +1,114 @@
 use std::fmt;
+use std::io::IsTerminal;
 use std::ops::Deref;
-use std::vec;
+use std::{io, vec};
 
 use crate::cell::Cell;
-use crate::Label;
+use crate::{viewport, Color, Filled, Label, Style};
+
+/// Rendering constraint.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct Constraint {
+    /// Minimum space the element can take.
+    pub min: Size,
+    /// Maximum space the element can take.
+    pub max: Size,
+}
+
+impl Default for Constraint {
+    fn default() -> Self {
+        Self::UNBOUNDED
+    }
+}
+
+impl Constraint {
+    /// Can satisfy any size of object.
+    pub const UNBOUNDED: Self = Self {
+        min: Size::MIN,
+        max: Size::MAX,
+    };
+
+    /// Create a new constraint.
+    pub fn new(min: Size, max: Size) -> Self {
+        assert!(min.cols <= max.cols && min.rows <= max.rows);
+
+        Self { min, max }
+    }
+
+    /// A constraint with only a maximum size.
+    pub fn max(max: Size) -> Self {
+        Self {
+            min: Size::MIN,
+            max,
+        }
+    }
+
+    /// A constraint that can only be satisfied by a single size.
+    pub fn tight(size: Size) -> Self {
+        Self {
+            min: size,
+            max: size,
+        }
+    }
+
+    /// Return a new constraint that forces objects to the maximum size.
+    pub fn maximize(self) -> Self {
+        Self {
+            min: self.max,
+            max: self.max,
+        }
+    }
+
+    /// Create a constraint from the terminal environment.
+    ///
+    /// If standard out isn't a terminal, returns an unbounded constraint.
+    pub fn from_env() -> Self {
+        if io::stdout().is_terminal() {
+            Self::max(viewport().unwrap_or(Size::MAX))
+        } else {
+            Self::UNBOUNDED
+        }
+    }
+}
 
 /// A text element that has a size and can be rendered to the terminal.
 pub trait Element: fmt::Debug {
     /// Get the size of the element, in rows and columns.
-    fn size(&self) -> Size;
+    fn size(&self, parent: Constraint) -> Size;
 
     #[must_use]
     /// Render the element as lines of text that can be printed.
-    fn render(&self) -> Vec<Line>;
+    fn render(&self, parent: Constraint) -> Vec<Line>;
 
     /// Get the number of columns occupied by this element.
-    fn columns(&self) -> usize {
-        self.size().cols
+    fn columns(&self, parent: Constraint) -> usize {
+        self.size(parent).cols
     }
 
     /// Get the number of rows occupied by this element.
-    fn rows(&self) -> usize {
-        self.size().rows
+    fn rows(&self, parent: Constraint) -> usize {
+        self.size(parent).rows
     }
 
     /// Print this element to stdout.
     fn print(&self) {
-        for line in self.render() {
-            println!("{line}");
+        for line in self.render(Constraint::from_env()) {
+            println!("{}", line.to_string().trim_end());
+        }
+    }
+
+    /// Write to a writer.
+    fn write(&self, constraints: Constraint) {
+        for line in self.render(constraints) {
+            println!("{}", line.to_string().trim_end());
         }
     }
 
     #[must_use]
     /// Return a string representation of this element.
-    fn display(&self) -> String {
+    fn display(&self, constraints: Constraint) -> String {
         let mut out = String::new();
-        for line in self.render() {
+        for line in self.render(constraints) {
             out.extend(line.into_iter().map(|l| l.to_string()));
             out.push('\n');
         }
@@ -44,12 +117,12 @@ pub trait Element: fmt::Debug {
 }
 
 impl<'a> Element for Box<dyn Element + 'a> {
-    fn size(&self) -> Size {
-        self.deref().size()
+    fn size(&self, parent: Constraint) -> Size {
+        self.deref().size(parent)
     }
 
-    fn render(&self) -> Vec<Line> {
-        self.deref().render()
+    fn render(&self, parent: Constraint) -> Vec<Line> {
+        self.deref().render(parent)
     }
 
     fn print(&self) {
@@ -58,12 +131,12 @@ impl<'a> Element for Box<dyn Element + 'a> {
 }
 
 impl<T: Element> Element for &T {
-    fn size(&self) -> Size {
-        (*self).size()
+    fn size(&self, parent: Constraint) -> Size {
+        (*self).size(parent)
     }
 
-    fn render(&self) -> Vec<Line> {
-        (*self).render()
+    fn render(&self, parent: Constraint) -> Vec<Line> {
+        (*self).render(parent)
     }
 
     fn print(&self) {
@@ -71,13 +144,6 @@ impl<T: Element> Element for &T {
     }
 }
 
-/// Used to specify maximum width or height.
-#[derive(Debug, Default, PartialEq, Eq, Clone, Copy)]
-pub struct Max {
-    pub width: Option<usize>,
-    pub height: Option<usize>,
-}
-
 /// A line of text that has styling and can be displayed.
 #[derive(Clone, Default, Debug)]
 pub struct Line {
@@ -97,6 +163,21 @@ impl Line {
         Self { items: vec![] }
     }
 
+    /// Return a styled line by styling all its labels.
+    pub fn style(self, style: Style) -> Line {
+        Self {
+            items: self
+                .items
+                .into_iter()
+                .map(|l| {
+                    let style = l.paint().style().merge(style);
+                    l.style(style)
+                })
+                .collect(),
+        }
+    }
+
+    /// Return a line with a single space between the given labels.
     pub fn spaced(items: impl IntoIterator<Item = Label>) -> Self {
         let mut line = Self::default();
         for item in items.into_iter() {
@@ -126,18 +207,23 @@ impl Line {
 
     /// Pad this line to occupy the given width.
     pub fn pad(&mut self, width: usize) {
-        let w = self.columns();
+        let w = self.width();
 
         if width > w {
             let pad = width - w;
-            self.items.push(Label::new(" ".repeat(pad).as_str()));
+            let bg = if let Some(last) = self.items.last() {
+                last.background()
+            } else {
+                Color::Unset
+            };
+            self.items.push(Label::new(" ".repeat(pad).as_str()).bg(bg));
         }
     }
 
     /// Truncate this line to the given width.
     pub fn truncate(&mut self, width: usize, delim: &str) {
-        while self.columns() > width {
-            let total = self.columns();
+        while self.width() > width {
+            let total = self.width();
 
             if total - self.items.last().map_or(0, Cell::width) > width {
                 self.items.pop();
@@ -147,22 +233,34 @@ impl Line {
         }
     }
 
+    /// Get the actual column width of this line.
+    pub fn width(&self) -> usize {
+        self.items.iter().map(Cell::width).sum()
+    }
+
+    /// Create a line that contains a single space.
     pub fn space(mut self) -> Self {
         self.items.push(Label::space());
         self
     }
 
+    /// Box this line as an [`Element`].
     pub fn boxed(self) -> Box<dyn Element> {
         Box::new(self)
     }
+
+    /// Return a filled line.
+    pub fn filled(self, color: Color) -> Filled<Self> {
+        Filled { item: self, color }
+    }
 }
 
 impl IntoIterator for Line {
     type Item = Label;
-    type IntoIter = vec::IntoIter<Label>;
+    type IntoIter = Box<dyn Iterator<Item = Label>>;
 
     fn into_iter(self) -> Self::IntoIter {
-        self.items.into_iter()
+        Box::new(self.items.into_iter())
     }
 }
 
@@ -172,12 +270,18 @@ impl<T: Into<Label>> From<T> for Line {
     }
 }
 
+impl From<Vec<Label>> for Line {
+    fn from(items: Vec<Label>) -> Self {
+        Self { items }
+    }
+}
+
 impl Element for Line {
-    fn size(&self) -> Size {
+    fn size(&self, _parent: Constraint) -> Size {
         Size::new(self.items.iter().map(Cell::width).sum(), 1)
     }
 
-    fn render(&self) -> Vec<Line> {
+    fn render(&self, _parent: Constraint) -> Vec<Line> {
         vec![self.clone()]
     }
 }
@@ -201,20 +305,28 @@ pub struct Size {
 }
 
 impl Size {
+    /// Minimum size.
+    pub const MIN: Self = Self {
+        cols: usize::MIN,
+        rows: usize::MIN,
+    };
+    /// Maximum size.
+    pub const MAX: Self = Self {
+        cols: usize::MAX,
+        rows: usize::MAX,
+    };
+
     /// Create a new [`Size`].
     pub fn new(cols: usize, rows: usize) -> Self {
         Self { cols, rows }
     }
 
-    /// Limit size.
-    pub fn limit(mut self, lim: Max) -> Self {
-        if let Some(w) = lim.width {
-            self.cols = self.cols.min(w);
+    /// Constrain size.
+    pub fn constrain(self, c: Constraint) -> Self {
+        Self {
+            cols: self.cols.clamp(c.min.cols, c.max.cols),
+            rows: self.rows.clamp(c.min.rows, c.max.rows),
         }
-        if let Some(h) = lim.height {
-            self.rows = self.rows.min(h);
-        }
-        self
     }
 }
 
diff --git a/radicle-term/src/hstack.rs b/radicle-term/src/hstack.rs
index 4051438b..7af1a38e 100644
--- a/radicle-term/src/hstack.rs
+++ b/radicle-term/src/hstack.rs
@@ -1,11 +1,9 @@
-use crate::{Element, Line, Size};
+use crate::{Constraint, Element, Line, Size};
 
 /// Horizontal stack of [`Element`] objects that implements [`Element`].
 #[derive(Default, Debug)]
 pub struct HStack<'a> {
     elems: Vec<Box<dyn Element + 'a>>,
-    width: usize,
-    height: usize,
 }
 
 impl<'a> HStack<'a> {
@@ -16,18 +14,19 @@ impl<'a> HStack<'a> {
     }
 
     pub fn push(&mut self, child: impl Element + 'a) {
-        self.width += child.columns() + 1;
-        self.height = self.height.max(child.rows());
         self.elems.push(Box::new(child));
     }
 }
 
 impl<'a> Element for HStack<'a> {
-    fn size(&self) -> Size {
-        Size::new(self.width, self.height)
+    fn size(&self, parent: Constraint) -> Size {
+        let width = self.elems.iter().map(|c| c.columns(parent)).sum();
+        let height = self.elems.iter().map(|c| c.rows(parent)).max().unwrap_or(0);
+
+        Size::new(width, height)
     }
 
-    fn render(&self) -> Vec<Line> {
+    fn render(&self, parent: Constraint) -> Vec<Line> {
         fn rearrange(input: Vec<Vec<Line>>) -> Vec<Line> {
             let max_len = input.iter().map(|v| v.len()).max().unwrap_or(0);
 
@@ -37,11 +36,11 @@ impl<'a> Element for HStack<'a> {
                         input
                             .iter()
                             .filter_map(move |v| v.get(i))
-                            .flat_map(|l| l.clone().into_iter()),
+                            .flat_map(|l| l.clone()),
                     )
                 })
                 .collect()
         }
-        rearrange(self.elems.iter().map(|e| e.render()).collect())
+        rearrange(self.elems.iter().map(|e| e.render(parent)).collect())
     }
 }
diff --git a/radicle-term/src/io.rs b/radicle-term/src/io.rs
index 13612009..3a20dfcb 100644
--- a/radicle-term/src/io.rs
+++ b/radicle-term/src/io.rs
@@ -10,7 +10,7 @@ use zeroize::Zeroizing;
 
 use crate::command;
 use crate::format;
-use crate::{style, Paint};
+use crate::{style, Paint, Size};
 
 pub use inquire;
 pub use inquire::Select;
@@ -92,6 +92,12 @@ pub fn columns() -> Option<usize> {
     termion::terminal_size().map(|(cols, _)| cols as usize).ok()
 }
 
+pub fn viewport() -> Option<Size> {
+    termion::terminal_size()
+        .map(|(cols, rows)| Size::new(cols as usize, rows as usize))
+        .ok()
+}
+
 pub fn headline(headline: impl fmt::Display) {
     println!();
     println!("{}", style(headline).bold());
diff --git a/radicle-term/src/label.rs b/radicle-term/src/label.rs
index e0ffae50..c9090e86 100644
--- a/radicle-term/src/label.rs
+++ b/radicle-term/src/label.rs
@@ -1,6 +1,6 @@
 use std::fmt;
 
-use crate::{cell::Cell, Element, Line, Paint, Size};
+use crate::{cell::Cell, Color, Constraint, Element, Filled, Line, Paint, Size, Style};
 
 /// A styled string that does not contain any `'\n'` and implements [`Element`] and [`Cell`].
 #[derive(Clone, Default, Debug)]
@@ -31,14 +31,44 @@ impl Label {
     pub fn boxed(self) -> Box<dyn Element> {
         Box::new(self)
     }
+
+    /// Color the label's foreground.
+    pub fn fg(self, color: Color) -> Self {
+        Self(self.0.fg(color))
+    }
+
+    /// Color the label's background.
+    pub fn bg(self, color: Color) -> Self {
+        Self(self.0.bg(color))
+    }
+
+    /// Style a label.
+    pub fn style(self, style: Style) -> Self {
+        Self(self.0.with_style(style))
+    }
+
+    /// Get inner paint object.
+    pub fn paint(&self) -> &Paint<String> {
+        &self.0
+    }
+
+    /// Return a filled cell from this label.
+    pub fn filled(self, color: Color) -> Filled<Self> {
+        Filled { item: self, color }
+    }
+
+    /// Wrap into a line.
+    pub fn to_line(self) -> Line {
+        Line::from(self)
+    }
 }
 
 impl Element for Label {
-    fn size(&self) -> Size {
+    fn size(&self, _parent: Constraint) -> Size {
         Size::new(self.0.width(), 1)
     }
 
-    fn render(&self) -> Vec<Line> {
+    fn render(&self, _parent: Constraint) -> Vec<Line> {
         vec![Line::new(self.clone())]
     }
 }
@@ -53,6 +83,10 @@ impl Cell for Label {
     type Padded = Self;
     type Truncated = Self;
 
+    fn background(&self) -> Color {
+        self.paint().style.background
+    }
+
     fn pad(&self, width: usize) -> Self::Padded {
         Self(self.0.pad(width))
     }
@@ -89,7 +123,7 @@ impl From<&str> for Label {
 
 /// Create a new label from a [`Paint`] object.
 pub fn label(s: impl Into<Paint<String>>) -> Label {
-    Label(s.into())
+    Label::from(s.into())
 }
 
 /// Cleanup the input string for display as a label.
diff --git a/radicle-term/src/lib.rs b/radicle-term/src/lib.rs
index 97b6e5bc..e6135f3b 100644
--- a/radicle-term/src/lib.rs
+++ b/radicle-term/src/lib.rs
@@ -14,9 +14,9 @@ pub mod textarea;
 pub mod vstack;
 
 pub use ansi::Color;
-pub use ansi::{paint, Paint, Style};
+pub use ansi::{paint, Filled, Paint, Style};
 pub use editor::Editor;
-pub use element::{Element, Line, Max, Size};
+pub use element::{Constraint, Element, Line, Size};
 pub use hstack::HStack;
 pub use inquire::ui::Styled;
 pub use io::*;
diff --git a/radicle-term/src/table.rs b/radicle-term/src/table.rs
index 7656fa4d..6671ee85 100644
--- a/radicle-term/src/table.rs
+++ b/radicle-term/src/table.rs
@@ -18,9 +18,9 @@
 //! ```
 use std::fmt;
 
-use crate as term;
 use crate::cell::Cell;
-use crate::{Color, Line, Max, Paint, Size};
+use crate::{self as term, Style};
+use crate::{Color, Constraint, Line, Paint, Size};
 
 pub use crate::Element;
 
@@ -28,8 +28,6 @@ pub use crate::Element;
 pub struct TableOptions {
     /// Whether the table should be allowed to overflow.
     pub overflow: bool,
-    /// The maximum width and height.
-    pub max: Max,
     /// Horizontal spacing between table cells.
     pub spacing: usize,
     /// Table border.
@@ -40,7 +38,6 @@ impl Default for TableOptions {
     fn default() -> Self {
         Self {
             overflow: false,
-            max: Max::default(),
             spacing: 1,
             border: None,
         }
@@ -84,16 +81,14 @@ impl<const W: usize, T: Cell + fmt::Debug> Element for Table<W, T>
 where
     T::Padded: Into<Line>,
 {
-    fn size(&self) -> Size {
-        Table::size(self)
+    fn size(&self, parent: Constraint) -> Size {
+        Table::size(self, parent)
     }
 
-    fn render(&self) -> Vec<Line> {
+    fn render(&self, parent: Constraint) -> Vec<Line> {
         let mut lines = Vec::new();
-        let limits = self.limits();
-        let width = limits.width;
         let border = self.opts.border;
-        let inner = self.inner().limit(limits);
+        let inner = self.inner(parent);
         let cols = inner.cols;
 
         if let Some(color) = border {
@@ -115,20 +110,19 @@ where
                     }
                     for (i, cell) in cells.iter().enumerate() {
                         let pad = if i == cells.len() - 1 {
-                            if border.is_some() {
-                                self.widths[i]
-                            } else {
-                                0
-                            }
+                            0
                         } else {
                             self.widths[i] + self.opts.spacing
                         };
-                        line = line.extend(cell.pad(pad).into());
+                        line = line.extend(
+                            cell.pad(pad)
+                                .into()
+                                .style(Style::default().bg(cell.background())),
+                        );
                     }
+                    Line::pad(&mut line, cols);
+                    Line::truncate(&mut line, cols, "…");
 
-                    if let Some(width) = width {
-                        line = line.truncate(width, "…");
-                    }
                     if let Some(color) = border {
                         line.push(Paint::new(" │").fg(color));
                     }
@@ -169,28 +163,14 @@ impl<const W: usize, T: Cell> Table<W, T> {
         }
     }
 
-    pub fn size(&self) -> Size {
-        self.outer()
+    pub fn size(&self, parent: Constraint) -> Size {
+        self.outer(parent)
     }
 
     pub fn divider(&mut self) {
         self.rows.push(Row::Divider);
     }
 
-    pub fn limits(&self) -> Max {
-        let width = self.opts.max.width.or_else(term::columns).map(|w| {
-            if self.opts.border.is_some() {
-                w - 2
-            } else {
-                w
-            }
-        });
-        Max {
-            width,
-            height: None,
-        }
-    }
-
     pub fn push(&mut self, row: [T; W]) {
         for (i, cell) in row.iter().enumerate() {
             self.widths[i] = self.widths[i].max(cell.width());
@@ -198,27 +178,27 @@ impl<const W: usize, T: Cell> Table<W, T> {
         self.rows.push(Row::Data(row));
     }
 
-    fn inner(&self) -> Size {
-        let mut cols = self.widths.iter().sum::<usize>() + (W - 1) * self.opts.spacing;
-        let rows = self.rows.len();
-        let limits = self.limits();
+    fn inner(&self, c: Constraint) -> Size {
+        let mut outer = self.outer(c);
 
-        // Account for inner spacing.
         if self.opts.border.is_some() {
-            cols += 2;
+            outer.cols -= 2;
+            outer.rows -= 2;
         }
-        Size::new(cols, rows).limit(limits)
+        outer
     }
 
-    fn outer(&self) -> Size {
-        let mut inner = self.inner();
+    fn outer(&self, c: Constraint) -> Size {
+        let mut cols = self.widths.iter().sum::<usize>() + (W - 1) * self.opts.spacing;
+        let mut rows = self.rows.len();
+        let padding = 2;
 
         // Account for outer borders.
         if self.opts.border.is_some() {
-            inner.cols += 2;
-            inner.rows += 2;
+            cols += 2 + padding;
+            rows += 2;
         }
-        inner
+        Size::new(cols, rows).constrain(c)
     }
 }
 
@@ -251,10 +231,10 @@ mod test {
 
         #[rustfmt::skip]
         assert_eq!(
-            t.display(),
+            t.display(Constraint::UNBOUNDED),
             [
                 "pineapple rosemary\n",
-                "apples    pears\n"
+                "apples    pears   \n"
             ].join("")
         );
     }
@@ -273,16 +253,16 @@ mod test {
         t.push(["Switzerland", "7M", "CH"]);
         t.push(["Germany", "80M", "DE"]);
 
-        let inner = t.inner();
+        let inner = t.inner(Constraint::UNBOUNDED);
         assert_eq!(inner.cols, 33);
         assert_eq!(inner.rows, 5);
 
-        let outer = t.outer();
+        let outer = t.outer(Constraint::UNBOUNDED);
         assert_eq!(outer.cols, 35);
         assert_eq!(outer.rows, 7);
 
         assert_eq!(
-            t.display(),
+            t.display(Constraint::UNBOUNDED),
             r#"
 ╭─────────────────────────────────╮
 │ Country       Population   Code │
@@ -301,10 +281,6 @@ mod test {
         let mut t = Table::new(TableOptions {
             border: Some(Color::Unset),
             spacing: 3,
-            max: Max {
-                width: Some(19),
-                height: None,
-            },
             ..TableOptions::default()
         });
 
@@ -314,16 +290,20 @@ mod test {
         t.push(["CH", "Switzerland"]);
         t.push(["DE", "Germany"]);
 
-        let inner = t.inner();
-        assert_eq!(inner.cols, 17);
-        assert_eq!(inner.rows, 5);
-
-        let outer = t.outer();
+        let constrain = Constraint::max(Size {
+            cols: 19,
+            rows: usize::MAX,
+        });
+        let outer = t.outer(constrain);
         assert_eq!(outer.cols, 19);
         assert_eq!(outer.rows, 7);
 
+        let inner = t.inner(constrain);
+        assert_eq!(inner.cols, 17);
+        assert_eq!(inner.rows, 5);
+
         assert_eq!(
-            t.display(),
+            t.display(constrain),
             r#"
 ╭─────────────────╮
 │ Code   Name     │
@@ -338,24 +318,69 @@ mod test {
     }
 
     #[test]
-    fn test_table_truncate() {
+    fn test_table_border_maximized() {
         let mut t = Table::new(TableOptions {
-            max: Max {
-                width: Some(16),
-                height: None,
-            },
+            border: Some(Color::Unset),
+            spacing: 3,
             ..TableOptions::default()
         });
 
+        t.push(["Code", "Name"]);
+        t.divider();
+        t.push(["FR", "France"]);
+        t.push(["CH", "Switzerland"]);
+        t.push(["DE", "Germany"]);
+
+        let constrain = Constraint::new(
+            Size { cols: 26, rows: 0 },
+            Size {
+                cols: 26,
+                rows: usize::MAX,
+            },
+        );
+        let outer = t.outer(constrain);
+        assert_eq!(outer.cols, 26);
+        assert_eq!(outer.rows, 7);
+
+        let inner = t.inner(constrain);
+        assert_eq!(inner.cols, 24);
+        assert_eq!(inner.rows, 5);
+
+        assert_eq!(
+            t.display(constrain),
+            r#"
+╭────────────────────────╮
+│ Code   Name            │
+├────────────────────────┤
+│ FR     France          │
+│ CH     Switzerland     │
+│ DE     Germany         │
+╰────────────────────────╯
+"#
+            .trim_start()
+        );
+    }
+
+    #[test]
+    fn test_table_truncate() {
+        let mut t = Table::default();
+        let constrain = Constraint::new(
+            Size::MIN,
+            Size {
+                cols: 16,
+                rows: usize::MAX,
+            },
+        );
+
         t.push(["pineapple", "rosemary"]);
         t.push(["apples", "pears"]);
 
         #[rustfmt::skip]
         assert_eq!(
-            t.display(),
+            t.display(constrain),
             [
                 "pineapple rosem…\n",
-                "apples    pears\n"
+                "apples    pears \n"
             ].join("")
         );
     }
@@ -369,9 +394,9 @@ mod test {
 
         #[rustfmt::skip]
         assert_eq!(
-            t.display(),
+            t.display(Constraint::UNBOUNDED),
             [
-                "🍍pineapple __rosemary __sage\n",
+                "🍍pineapple __rosemary __sage   \n",
                 "__pears     🍎apples   🍌bananas\n"
             ].join("")
         );
@@ -380,19 +405,18 @@ mod test {
     #[test]
     fn test_table_unicode_truncate() {
         let mut t = Table::new(TableOptions {
-            max: Max {
-                width: Some(16),
-                height: None,
-            },
             ..TableOptions::default()
         });
-
+        let constrain = Constraint::max(Size {
+            cols: 16,
+            rows: usize::MAX,
+        });
         t.push(["🍍pineapple", "__rosemary"]);
         t.push(["__pears", "🍎apples"]);
 
         #[rustfmt::skip]
         assert_eq!(
-            t.display(),
+            t.display(constrain),
             [
                 "🍍pineapple __r…\n",
                 "__pears     🍎a…\n"
diff --git a/radicle-term/src/textarea.rs b/radicle-term/src/textarea.rs
index 055711a3..a1b5e9f7 100644
--- a/radicle-term/src/textarea.rs
+++ b/radicle-term/src/textarea.rs
@@ -1,4 +1,4 @@
-use crate::{cell::Cell, Element, Line, Paint, Size};
+use crate::{cell::Cell, Constraint, Element, Line, Paint, Size};
 
 /// Default text wrap width.
 pub const DEFAULT_WRAP: usize = 80;
@@ -65,14 +65,14 @@ impl TextArea {
 }
 
 impl Element for TextArea {
-    fn size(&self) -> Size {
+    fn size(&self, _parent: Constraint) -> Size {
         let cols = self.lines().map(|l| l.width()).max().unwrap_or(0);
         let rows = self.lines().count();
 
         Size::new(cols, rows)
     }
 
-    fn render(&self) -> Vec<Line> {
+    fn render(&self, _parent: Constraint) -> Vec<Line> {
         self.lines()
             .map(|l| Line::new(Paint::new(l).with_style(self.body.style)))
             .collect()
diff --git a/radicle-term/src/vstack.rs b/radicle-term/src/vstack.rs
index 26d6772e..6fb25b9b 100644
--- a/radicle-term/src/vstack.rs
+++ b/radicle-term/src/vstack.rs
@@ -1,10 +1,20 @@
 use crate::colors;
-use crate::{Color, Element, Label, Line, Paint, Size};
+use crate::{Color, Constraint, Element, Label, Line, Paint, Size};
 
 /// Options for [`VStack`].
-#[derive(Default, Debug)]
+#[derive(Debug)]
 pub struct VStackOptions {
     border: Option<Color>,
+    padding: usize,
+}
+
+impl Default for VStackOptions {
+    fn default() -> Self {
+        Self {
+            border: None,
+            padding: 1,
+        }
+    }
 }
 
 /// A vertical stack row.
@@ -14,13 +24,21 @@ enum Row<'a> {
     #[default]
     Dividier,
 }
+
+impl<'a> Row<'a> {
+    fn width(&self, c: Constraint) -> usize {
+        match self {
+            Self::Element(e) => e.columns(c),
+            Self::Dividier => c.min.cols,
+        }
+    }
+}
+
 /// Vertical stack of [`Element`] objects that implements [`Element`].
 #[derive(Default, Debug)]
 pub struct VStack<'a> {
     rows: Vec<Row<'a>>,
     opts: VStackOptions,
-    width: usize,
-    height: usize,
 }
 
 impl<'a> VStack<'a> {
@@ -38,7 +56,6 @@ impl<'a> VStack<'a> {
     /// Add a horizontal divider.
     pub fn divider(mut self) -> Self {
         self.rows.push(Row::Dividier);
-        self.height += 1;
         self
     }
 
@@ -61,31 +78,67 @@ impl<'a> VStack<'a> {
         self
     }
 
+    /// Set horizontal padding.
+    pub fn padding(mut self, cols: usize) -> Self {
+        self.opts.padding = cols;
+        self
+    }
+
     /// Add an element to the stack.
     pub fn push(&mut self, child: impl Element + 'a) {
-        self.width = self.width.max(child.columns());
-        self.height += child.rows();
         self.rows.push(Row::Element(Box::new(child)));
     }
+
+    /// Box this element.
+    pub fn boxed(self) -> Box<dyn Element + 'a> {
+        Box::new(self)
+    }
+
+    /// Inner size.
+    fn inner(&self, c: Constraint) -> Size {
+        let mut outer = self.outer(c);
+
+        if self.opts.border.is_some() {
+            outer.cols -= 2;
+            outer.rows -= 2;
+        }
+        outer
+    }
+
+    /// Outer size (includes borders).
+    fn outer(&self, c: Constraint) -> Size {
+        let padding = self.opts.padding * 2;
+        let mut cols = self.rows.iter().map(|r| r.width(c)).max().unwrap_or(0) + padding;
+        let mut rows = self.rows.len();
+
+        // Account for outer borders.
+        if self.opts.border.is_some() {
+            cols += 2;
+            rows += 2;
+        }
+        Size::new(cols, rows).constrain(c)
+    }
 }
 
 impl<'a> Element for VStack<'a> {
-    fn size(&self) -> Size {
-        if self.opts.border.is_some() {
-            Size::new(self.width + 4, self.height + 2)
-        } else {
-            Size::new(self.width, self.height)
-        }
+    fn size(&self, parent: Constraint) -> Size {
+        self.outer(parent)
     }
 
-    fn render(&self) -> Vec<Line> {
+    fn render(&self, parent: Constraint) -> Vec<Line> {
         let mut lines = Vec::new();
+        let padding = self.opts.padding;
+        let inner = self.inner(parent);
+        let child = Constraint::tight(Size {
+            cols: inner.cols - padding * 2,
+            rows: usize::MAX,
+        });
 
         if let Some(color) = self.opts.border {
             lines.push(
                 Line::default()
                     .item(Paint::new("╭").fg(color))
-                    .item(Paint::new("─".repeat(self.width + 2)).fg(color))
+                    .item(Paint::new("─".repeat(inner.cols)).fg(color))
                     .item(Paint::new("╮").fg(color)),
             );
         }
@@ -93,14 +146,17 @@ impl<'a> Element for VStack<'a> {
         for row in &self.rows {
             match row {
                 Row::Element(elem) => {
-                    for mut line in elem.render() {
+                    for mut line in elem.render(child) {
+                        line.pad(child.max.cols);
+
                         if let Some(color) = self.opts.border {
-                            line.pad(self.width);
                             lines.push(
                                 Line::default()
-                                    .item(Paint::new("│ ").fg(color))
+                                    .item(Paint::new(format!("│{}", " ".repeat(padding))).fg(color))
                                     .extend(line)
-                                    .item(Paint::new(" │").fg(color)),
+                                    .item(
+                                        Paint::new(format!("{}│", " ".repeat(padding))).fg(color),
+                                    ),
                             );
                         } else {
                             lines.push(line);
@@ -112,7 +168,7 @@ impl<'a> Element for VStack<'a> {
                         lines.push(
                             Line::default()
                                 .item(Paint::new("├").fg(color))
-                                .item(Paint::new("─".repeat(self.width + 2)).fg(color))
+                                .item(Paint::new("─".repeat(inner.cols)).fg(color))
                                 .item(Paint::new("┤").fg(color)),
                         );
                     } else {
@@ -126,11 +182,11 @@ impl<'a> Element for VStack<'a> {
             lines.push(
                 Line::default()
                     .item(Paint::new("╰").fg(color))
-                    .item(Paint::new("─".repeat(self.width + 2)).fg(color))
+                    .item(Paint::new("─".repeat(inner.cols)).fg(color))
                     .item(Paint::new("╯").fg(color)),
             );
         }
-        lines.into_iter().flat_map(|h| h.render()).collect()
+        lines.into_iter().flat_map(|h| h.render(child)).collect()
     }
 }
 
@@ -138,3 +194,72 @@ impl<'a> Element for VStack<'a> {
 pub fn bordered<'a>(child: impl Element + 'a) -> VStack<'a> {
     VStack::default().border(Some(colors::FAINT)).child(child)
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use pretty_assertions::assert_eq;
+
+    #[test]
+    fn test_vstack() {
+        let mut v = VStack::default().border(Some(Color::Unset)).padding(1);
+
+        v.push(Line::new("banana"));
+        v.push(Line::new("apple"));
+        v.push(Line::new("abricot"));
+
+        let constraint = Constraint::default();
+        let outer = v.outer(constraint);
+        assert_eq!(outer.cols, 11);
+        assert_eq!(outer.rows, 5);
+
+        let inner = v.inner(constraint);
+        assert_eq!(inner.cols, 9);
+        assert_eq!(inner.rows, 3);
+
+        assert_eq!(
+            v.display(constraint),
+            r#"
+╭─────────╮
+│ banana  │
+│ apple   │
+│ abricot │
+╰─────────╯
+"#
+            .trim_start()
+        );
+    }
+
+    #[test]
+    fn test_vstack_maximize() {
+        let mut v = VStack::default().border(Some(Color::Unset)).padding(1);
+
+        v.push(Line::new("banana"));
+        v.push(Line::new("apple"));
+        v.push(Line::new("abricot"));
+
+        let constraint = Constraint {
+            min: Size::new(14, 0),
+            max: Size::new(14, usize::MAX),
+        };
+        let outer = v.outer(constraint);
+        assert_eq!(outer.cols, 14);
+        assert_eq!(outer.rows, 5);
+
+        let inner = v.inner(constraint);
+        assert_eq!(inner.cols, 12);
+        assert_eq!(inner.rows, 3);
+
+        assert_eq!(
+            v.display(constraint),
+            r#"
+╭────────────╮
+│ banana     │
+│ apple      │
+│ abricot    │
+╰────────────╯
+"#
+            .trim_start()
+        );
+    }
+}