diff --git a/Cargo.lock b/Cargo.lock
index 0b73952c1..9a6208e27 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1303,9 +1303,11 @@ dependencies = [
  "smallvec",
  "tempfile",
  "tracing",
+ "unicode-segmentation",
  "vello",
  "wgpu",
  "winit",
+ "xi-unicode",
 ]
 
 [[package]]
@@ -3130,6 +3132,12 @@ version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a0ccd7b4a5345edfcd0c3535718a4e9ff7798ffc536bb5b5a0e26ff84732911"
 
+[[package]]
+name = "xi-unicode"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a67300977d3dc3f8034dae89778f502b6ba20b269527b3223ba59c0cf393bb8a"
+
 [[package]]
 name = "xilem"
 version = "0.1.0"
diff --git a/crates/masonry/Cargo.toml b/crates/masonry/Cargo.toml
index fd1defca4..b4057fd01 100644
--- a/crates/masonry/Cargo.toml
+++ b/crates/masonry/Cargo.toml
@@ -30,6 +30,9 @@ pollster = "0.3.0"
 parley.workspace = true
 wgpu = { version = "0.19.3" }
 winit.workspace = true
+unicode-segmentation = "1.11.0"
+# TODO: Is this still the most up-to-date crate for this?
+xi-unicode = "0.3.0"
 
 [dev-dependencies]
 float-cmp = { version = "0.8.0", features = ["std"], default-features = false }
diff --git a/crates/masonry/examples/calc.rs b/crates/masonry/examples/calc.rs
index 5013d36a6..13bbd852e 100644
--- a/crates/masonry/examples/calc.rs
+++ b/crates/masonry/examples/calc.rs
@@ -222,9 +222,9 @@ impl AppDriver for CalcState {
         ctx.get_root::<Flex>()
             .child_mut(1)
             .unwrap()
-            .downcast::<Label>()
+            .downcast::<Label<String>>()
             .unwrap()
-            .set_text(self.value.clone());
+            .set_text((&*self.value).into());
     }
 }
 
diff --git a/crates/masonry/examples/custom_widget.rs b/crates/masonry/examples/custom_widget.rs
index 64ef03e01..1be86148c 100644
--- a/crates/masonry/examples/custom_widget.rs
+++ b/crates/masonry/examples/custom_widget.rs
@@ -105,14 +105,16 @@ impl Widget for CustomWidget {
             FontFamily::Generic(parley::style::GenericFamily::Serif),
         )));
         text_layout_builder.push_default(&StyleProperty::FontSize(24.0));
-        text_layout_builder.push_default(&StyleProperty::Brush(Brush::Solid(fill_color)));
+        text_layout_builder.push_default(&StyleProperty::Brush(Brush::Solid(fill_color).into()));
 
         let mut text_layout = text_layout_builder.build();
         text_layout.break_all_lines(None, Alignment::Start);
 
+        let mut scratch_scene = Scene::new();
         // We can pass a transform matrix to rotate the text we render
         masonry::text_helpers::render_text(
             scene,
+            &mut scratch_scene,
             Affine::rotate(std::f64::consts::FRAC_PI_4).then_translate((80.0, 40.0).into()),
             &text_layout,
         );
diff --git a/crates/masonry/src/event_loop_runner.rs b/crates/masonry/src/event_loop_runner.rs
index c1976be6f..8f4f0ced6 100644
--- a/crates/masonry/src/event_loop_runner.rs
+++ b/crates/masonry/src/event_loop_runner.rs
@@ -76,9 +76,27 @@ impl ApplicationHandler for MainState<'_> {
                     .handle_window_event(WindowEvent::Resize(size));
             }
             WinitWindowEvent::ModifiersChanged(modifiers) => {
+                self.pointer_state.mods = modifiers;
                 self.render_root
                     .handle_text_event(TextEvent::ModifierChange(modifiers.state()));
             }
+            WinitWindowEvent::KeyboardInput {
+                device_id: _,
+                event,
+                is_synthetic: _,
+            } => {
+                self.render_root.handle_text_event(TextEvent::KeyboardKey(
+                    event,
+                    self.pointer_state.mods.state(),
+                ));
+            }
+            WinitWindowEvent::Ime(ime) => {
+                self.render_root.handle_text_event(TextEvent::Ime(ime));
+            }
+            WinitWindowEvent::Focused(new_focus) => {
+                self.render_root
+                    .handle_text_event(TextEvent::FocusChange(new_focus));
+            }
             WinitWindowEvent::CursorMoved { position, .. } => {
                 self.pointer_state.physical_position = position;
                 self.pointer_state.position = position.to_logical(self.window.scale_factor());
diff --git a/crates/masonry/src/lib.rs b/crates/masonry/src/lib.rs
index 05f5b124c..622299af1 100644
--- a/crates/masonry/src/lib.rs
+++ b/crates/masonry/src/lib.rs
@@ -104,6 +104,7 @@ pub mod paint_scene_helpers;
 pub mod promise;
 pub mod render_root;
 pub mod testing;
+// mod text;
 pub mod text_helpers;
 pub mod theme;
 pub mod widget;
@@ -113,6 +114,7 @@ pub mod app_driver;
 pub mod debug_logger;
 pub mod debug_values;
 pub mod event_loop_runner;
+pub mod text2;
 
 pub use action::Action;
 pub use box_constraints::BoxConstraints;
diff --git a/crates/masonry/src/render_root.rs b/crates/masonry/src/render_root.rs
index 03bf7ec39..12b265547 100644
--- a/crates/masonry/src/render_root.rs
+++ b/crates/masonry/src/render_root.rs
@@ -464,8 +464,8 @@ impl RenderRoot {
         // Only send RouteFocusChanged in case there's actual change
         if old != new {
             let event = LifeCycle::Internal(InternalLifeCycle::RouteFocusChanged { old, new });
-            self.root_lifecycle(event);
             self.state.focused_widget = new;
+            self.root_lifecycle(event);
 
             // TODO - Handle IME
             // Send TextFieldFocused(focused_widget) signal
diff --git a/crates/masonry/src/text/README.md b/crates/masonry/src/text/README.md
new file mode 100644
index 000000000..eeb22ff8b
--- /dev/null
+++ b/crates/masonry/src/text/README.md
@@ -0,0 +1,6 @@
+# Old Text code
+
+This folder contains code which was previously used for handling text in Masonry and Druid.
+This is provided for reference.
+
+The expectation is that this will be adapted into the versions in `text2`, then this will be deleted and `text2` will be renamed to text.
diff --git a/crates/masonry/src/text/attribute.rs b/crates/masonry/src/text/attribute.rs
new file mode 100644
index 000000000..28df2fe95
--- /dev/null
+++ b/crates/masonry/src/text/attribute.rs
@@ -0,0 +1,389 @@
+// Copyright 2018 the Xilem Authors and the Druid Authors
+// SPDX-License-Identifier: Apache-2.0
+
+//! Text attributes and spans.
+
+use std::ops::Range;
+
+use parley::{
+    fontique::{Style, Weight},
+    style::{FontFamily, StyleProperty},
+};
+use vello::peniko::{Brush, Color};
+
+use super::font_descriptor::FontDescriptor;
+
+// TODO - Should also hold an associated Command, maybe.
+/// A clickable range of text
+#[derive(Debug, Clone)]
+pub struct Link {
+    /// The range of text for the link.
+    pub range: Range<usize>,
+}
+
+/// A collection of spans of attributes of various kinds.
+#[derive(Debug, Clone, Default)]
+pub struct AttributeSpans {
+    family: SpanSet<FontFamily<'static>>,
+    size: SpanSet<f32>,
+    weight: SpanSet<Weight>,
+    fg_color: SpanSet<Color>,
+    style: SpanSet<Style>,
+    underline: SpanSet<bool>,
+    font_descriptor: SpanSet<FontDescriptor>,
+}
+
+/// A set of spans for a given attribute.
+///
+/// Invariant: the spans are sorted and non-overlapping.
+#[derive(Debug, Clone)]
+struct SpanSet<T> {
+    spans: Vec<Span<T>>,
+}
+
+/// An attribute and a range.
+///
+/// This is used to represent text attributes of various kinds,
+/// with the range representing a region of some text buffer.
+#[derive(Debug, Clone, PartialEq)]
+struct Span<T> {
+    range: Range<usize>,
+    attr: T,
+}
+
+/// Attributes that can be applied to text.
+///
+/// Where possible, attributes are [`KeyOrValue`] types; this means you
+/// can use items defined in the [`theme`] *or* concrete types, where appropriate.
+///
+/// The easiest way to construct these attributes is via the various constructor
+/// methods, such as [`Attribute::size`] or [`Attribute::text_color`].
+///
+/// # Examples
+///
+/// ```no_run
+/// use masonry::text::Attribute;
+/// use masonry::{theme, Color};
+///
+/// let font = Attribute::font_descriptor(theme::UI_FONT);
+/// let font_size = Attribute::size(32.0);
+/// let explicit_color = Attribute::text_color(Color::BLACK);
+/// let theme_color = Attribute::text_color(theme::SELECTION_TEXT_COLOR);
+/// ```
+///
+/// [`KeyOrValue`]: ../enum.KeyOrValue.html
+/// [`theme`]: ../theme
+/// [`Attribute::size`]: #method.size
+/// [`Attribute::text_color`]: #method.text_color
+#[derive(Debug, Clone)]
+pub enum Attribute {
+    /// The font family.
+    FontFamily(FontFamily<'static>),
+    /// The font size, in points.
+    FontSize(f32),
+    /// The [`FontWeight`](struct.FontWeight.html).
+    Weight(Weight),
+    /// The foreground color of the text.
+    TextColor(Color),
+    /// The [`FontStyle`]; either regular or italic.
+    ///
+    /// [`FontStyle`]: enum.FontStyle.html
+    Style(Style),
+    /// Underline.
+    Underline(bool),
+    /// A [`FontDescriptor`](struct.FontDescriptor.html).
+    Descriptor(FontDescriptor),
+}
+
+impl Link {
+    /// Create a new `Link`.
+    pub fn new(range: Range<usize>) -> Self {
+        Self { range }
+    }
+
+    /// Get this `Link`'s range.
+    pub fn range(&self) -> Range<usize> {
+        self.range.clone()
+    }
+}
+
+impl AttributeSpans {
+    /// Create a new, empty `AttributeSpans`.
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Add a new [`Attribute`] over the provided [`Range`].
+    pub fn add(&mut self, range: Range<usize>, attr: Attribute) {
+        match attr {
+            Attribute::FontFamily(attr) => self.family.add(Span::new(range, attr)),
+            Attribute::FontSize(attr) => self.size.add(Span::new(range, attr)),
+            Attribute::Weight(attr) => self.weight.add(Span::new(range, attr)),
+            Attribute::TextColor(attr) => self.fg_color.add(Span::new(range, attr)),
+            Attribute::Style(attr) => self.style.add(Span::new(range, attr)),
+            Attribute::Underline(attr) => self.underline.add(Span::new(range, attr)),
+            Attribute::Descriptor(attr) => self.font_descriptor.add(Span::new(range, attr)),
+        }
+    }
+
+    pub(crate) fn to_piet_attrs(&self) -> Vec<(Range<usize>, StyleProperty<'static, Brush>)> {
+        let mut items = Vec::new();
+        for Span { range, attr } in self.font_descriptor.iter() {
+            items.push((
+                range.clone(),
+                StyleProperty::FontStack(parley::style::FontStack::Single(attr.family.clone())),
+            ));
+            items.push((range.clone(), StyleProperty::FontSize(attr.size)));
+            items.push((range.clone(), StyleProperty::FontWeight(attr.weight)));
+            items.push((range.clone(), StyleProperty::FontStyle(attr.style)));
+        }
+
+        items.extend(self.family.iter().map(|s| {
+            (
+                s.range.clone(),
+                StyleProperty::FontStack(parley::style::FontStack::Single(s.attr.clone())),
+            )
+        }));
+        items.extend(
+            self.size
+                .iter()
+                .map(|s| (s.range.clone(), StyleProperty::FontSize(s.attr))),
+        );
+        items.extend(
+            self.weight
+                .iter()
+                .map(|s| (s.range.clone(), StyleProperty::FontWeight(s.attr))),
+        );
+        items.extend(
+            self.fg_color
+                .iter()
+                .map(|s| (s.range.clone(), StyleProperty::Brush(Brush::Solid(s.attr)))),
+        );
+        items.extend(
+            self.style
+                .iter()
+                .map(|s| (s.range.clone(), StyleProperty::FontStyle(s.attr))),
+        );
+        items.extend(
+            self.underline
+                .iter()
+                .map(|s| (s.range.clone(), StyleProperty::Underline(s.attr))),
+        );
+
+        // sort by ascending start order; this is a stable sort
+        // so items that come from FontDescriptor will stay at the front
+        items.sort_by(|a, b| a.0.start.cmp(&b.0.start));
+        items
+    }
+}
+
+impl<T: Clone> SpanSet<T> {
+    fn iter(&self) -> impl Iterator<Item = &Span<T>> {
+        self.spans.iter()
+    }
+
+    /// Add a `Span` to this `SpanSet`.
+    ///
+    /// Spans can be added in any order. existing spans will be updated
+    /// as required.
+    fn add(&mut self, span: Span<T>) {
+        let span_start = span.range.start;
+        let span_end = span.range.end;
+        let insert_idx = self
+            .spans
+            .iter()
+            .position(|x| x.range.start >= span.range.start)
+            .unwrap_or_else(|| self.spans.len());
+
+        // if we are inserting into the middle of an existing span we need
+        // to add the trailing portion back afterwards.
+        let mut prev_remainder = None;
+
+        if insert_idx > 0 {
+            // truncate the preceding item, if necessary
+            let before = self.spans.get_mut(insert_idx - 1).unwrap();
+            if before.range.end > span_end {
+                let mut remainder = before.clone();
+                remainder.range.start = span_end;
+                prev_remainder = Some(remainder);
+            }
+            before.range.end = before.range.end.min(span_start);
+        }
+
+        self.spans.insert(insert_idx, span);
+        if let Some(remainder) = prev_remainder.take() {
+            self.spans.insert(insert_idx + 1, remainder);
+        }
+
+        // clip any existing spans as needed
+        for after in self.spans.iter_mut().skip(insert_idx + 1) {
+            after.range.start = after.range.start.max(span_end);
+            after.range.end = after.range.end.max(span_end);
+        }
+
+        // remove any spans that have been overwritten
+        self.spans.retain(|span| !span.is_empty());
+    }
+
+    /// Edit the spans, inserting empty space into the changed region if needed.
+    ///
+    /// This is used to keep the spans up to date as edits occur in the buffer.
+    ///
+    /// `changed` is the range of the string that has been replaced; this can
+    /// be an empty range (eg, 10..10) for the insertion case.
+    ///
+    /// `new_len` is the length of the inserted text.
+    //TODO: we could be smarter here about just extending the existing spans
+    //as requred for insertions in the interior of a span.
+    //TODO: this isn't currently used; it should be used if we use spans with
+    //some editable type.
+    // the branches are much more readable without sharing code
+    #[allow(dead_code, clippy::branches_sharing_code)]
+    fn edit(&mut self, changed: Range<usize>, new_len: usize) {
+        let old_len = changed.len();
+        let mut to_insert = None;
+
+        for (idx, Span { range, attr }) in self.spans.iter_mut().enumerate() {
+            if range.end <= changed.start {
+                continue;
+            } else if range.start < changed.start {
+                // we start before but end inside; truncate end
+                if range.end <= changed.end {
+                    range.end = changed.start;
+                // we start before and end after; this is a special case,
+                // we'll need to add a new span
+                } else {
+                    let new_start = changed.start + new_len;
+                    let new_end = range.end - old_len + new_len;
+                    let new_span = Span::new(new_start..new_end, attr.clone());
+                    to_insert = Some((idx + 1, new_span));
+                    range.end = changed.start;
+                }
+            // start inside
+            } else if range.start < changed.end {
+                range.start = changed.start + new_len;
+                // end inside; collapse
+                if range.end <= changed.end {
+                    range.end = changed.start + new_len;
+                // end outside: adjust by length delta
+                } else {
+                    range.end -= old_len;
+                    range.end += new_len;
+                }
+            // whole range is after:
+            } else {
+                range.start -= old_len;
+                range.start += new_len;
+                range.end -= old_len;
+                range.end += new_len;
+            }
+        }
+        if let Some((idx, span)) = to_insert.take() {
+            self.spans.insert(idx, span);
+        }
+
+        self.spans.retain(|span| !span.is_empty());
+    }
+}
+
+impl<T> Span<T> {
+    fn new(range: Range<usize>, attr: T) -> Self {
+        Span { range, attr }
+    }
+
+    fn is_empty(&self) -> bool {
+        self.range.end <= self.range.start
+    }
+}
+
+impl Attribute {
+    /// Create a new font size attribute.
+    pub fn size(size: impl Into<f32>) -> Self {
+        Attribute::FontSize(size.into())
+    }
+
+    /// Create a new forground color attribute.
+    pub fn text_color(color: impl Into<Color>) -> Self {
+        Attribute::TextColor(color.into())
+    }
+
+    /// Create a new font family attribute.
+    pub fn font_family(family: FontFamily) -> Self {
+        Attribute::FontFamily(family)
+    }
+
+    /// Create a new `FontWeight` attribute.
+    pub fn weight(weight: Weight) -> Self {
+        Attribute::Weight(weight)
+    }
+
+    /// Create a new `FontStyle` attribute.
+    pub fn style(style: Style) -> Self {
+        Attribute::Style(style)
+    }
+
+    /// Create a new underline attribute.
+    pub fn underline(underline: bool) -> Self {
+        Attribute::Underline(underline)
+    }
+
+    /// Create a new `FontDescriptor` attribute.
+    pub fn font_descriptor(font: impl Into<FontDescriptor>) -> Self {
+        Attribute::Descriptor(font.into())
+    }
+}
+
+impl<T> Default for SpanSet<T> {
+    fn default() -> Self {
+        SpanSet { spans: Vec::new() }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn smoke_test_spans() {
+        let mut spans = SpanSet::<u32>::default();
+        spans.add(Span::new(2..10, 1));
+        spans.add(Span::new(3..6, 2));
+        assert_eq!(
+            &spans.spans,
+            &vec![Span::new(2..3, 1), Span::new(3..6, 2), Span::new(6..10, 1)]
+        );
+
+        spans.add(Span::new(0..12, 3));
+        assert_eq!(&spans.spans, &vec![Span::new(0..12, 3)]);
+        spans.add(Span::new(5..20, 4));
+        assert_eq!(&spans.spans, &vec![Span::new(0..5, 3), Span::new(5..20, 4)]);
+    }
+
+    #[test]
+    fn edit_spans() {
+        let mut spans = SpanSet::<u32>::default();
+        spans.add(Span::new(0..2, 1));
+        spans.add(Span::new(8..12, 2));
+        spans.add(Span::new(13..16, 3));
+        spans.add(Span::new(20..22, 4));
+
+        let mut deletion = spans.clone();
+        deletion.edit(6..14, 0);
+        assert_eq!(
+            &deletion.spans,
+            &vec![Span::new(0..2, 1), Span::new(6..8, 3), Span::new(12..14, 4)]
+        );
+
+        spans.edit(10..10, 2);
+        assert_eq!(
+            &spans.spans,
+            &vec![
+                Span::new(0..2, 1),
+                Span::new(8..10, 2),
+                Span::new(12..14, 2),
+                Span::new(15..18, 3),
+                Span::new(22..24, 4),
+            ]
+        );
+    }
+}
diff --git a/crates/masonry/src/text/backspace.rs b/crates/masonry/src/text/backspace.rs
new file mode 100644
index 000000000..17b89a9f7
--- /dev/null
+++ b/crates/masonry/src/text/backspace.rs
@@ -0,0 +1,197 @@
+// Copyright 2018 the Xilem Authors and the Druid Authors
+// SPDX-License-Identifier: Apache-2.0
+
+//! Calc start of a backspace delete interval
+
+use xi_unicode::*;
+
+use crate::text::editable_text::EditableTextCursor;
+
+use super::{editable_text::EditableText, shell_text::Selection};
+
+#[allow(clippy::cognitive_complexity)]
+fn backspace_offset(text: &impl EditableText, start: usize) -> usize {
+    #[derive(PartialEq)]
+    enum State {
+        Start,
+        Lf,
+        BeforeKeycap,
+        BeforeVsAndKeycap,
+        BeforeEmojiModifier,
+        BeforeVsAndEmojiModifier,
+        BeforeVs,
+        BeforeEmoji,
+        BeforeZwj,
+        BeforeVsAndZwj,
+        OddNumberedRis,
+        EvenNumberedRis,
+        InTagSequence,
+        Finished,
+    }
+    let mut state = State::Start;
+
+    let mut delete_code_point_count = 0;
+    let mut last_seen_vs_code_point_count = 0;
+    let mut cursor = text
+        .cursor(start)
+        .expect("Backspace must begin at a valid codepoint boundary.");
+
+    while state != State::Finished && cursor.pos() > 0 {
+        let code_point = cursor.prev_codepoint().unwrap_or('0');
+
+        match state {
+            State::Start => {
+                delete_code_point_count = 1;
+                if code_point == '\n' {
+                    state = State::Lf;
+                } else if is_variation_selector(code_point) {
+                    state = State::BeforeVs;
+                } else if code_point.is_regional_indicator_symbol() {
+                    state = State::OddNumberedRis;
+                } else if code_point.is_emoji_modifier() {
+                    state = State::BeforeEmojiModifier;
+                } else if code_point.is_emoji_combining_enclosing_keycap() {
+                    state = State::BeforeKeycap;
+                } else if code_point.is_emoji() {
+                    state = State::BeforeEmoji;
+                } else if code_point.is_emoji_cancel_tag() {
+                    state = State::InTagSequence;
+                } else {
+                    state = State::Finished;
+                }
+            }
+            State::Lf => {
+                if code_point == '\r' {
+                    delete_code_point_count += 1;
+                }
+                state = State::Finished;
+            }
+            State::OddNumberedRis => {
+                if code_point.is_regional_indicator_symbol() {
+                    delete_code_point_count += 1;
+                    state = State::EvenNumberedRis
+                } else {
+                    state = State::Finished
+                }
+            }
+            State::EvenNumberedRis => {
+                if code_point.is_regional_indicator_symbol() {
+                    delete_code_point_count -= 1;
+                    state = State::OddNumberedRis;
+                } else {
+                    state = State::Finished;
+                }
+            }
+            State::BeforeKeycap => {
+                if is_variation_selector(code_point) {
+                    last_seen_vs_code_point_count = 1;
+                    state = State::BeforeVsAndKeycap;
+                } else {
+                    if is_keycap_base(code_point) {
+                        delete_code_point_count += 1;
+                    }
+                    state = State::Finished;
+                }
+            }
+            State::BeforeVsAndKeycap => {
+                if is_keycap_base(code_point) {
+                    delete_code_point_count += last_seen_vs_code_point_count + 1;
+                }
+                state = State::Finished;
+            }
+            State::BeforeEmojiModifier => {
+                if is_variation_selector(code_point) {
+                    last_seen_vs_code_point_count = 1;
+                    state = State::BeforeVsAndEmojiModifier;
+                } else {
+                    if code_point.is_emoji_modifier_base() {
+                        delete_code_point_count += 1;
+                    }
+                    state = State::Finished;
+                }
+            }
+            State::BeforeVsAndEmojiModifier => {
+                if code_point.is_emoji_modifier_base() {
+                    delete_code_point_count += last_seen_vs_code_point_count + 1;
+                }
+                state = State::Finished;
+            }
+            State::BeforeVs => {
+                if code_point.is_emoji() {
+                    delete_code_point_count += 1;
+                    state = State::BeforeEmoji;
+                } else {
+                    if !is_variation_selector(code_point) {
+                        //TODO: UCharacter.getCombiningClass(codePoint) == 0
+                        delete_code_point_count += 1;
+                    }
+                    state = State::Finished;
+                }
+            }
+            State::BeforeEmoji => {
+                if code_point.is_zwj() {
+                    state = State::BeforeZwj;
+                } else {
+                    state = State::Finished;
+                }
+            }
+            State::BeforeZwj => {
+                if code_point.is_emoji() {
+                    delete_code_point_count += 2;
+                    state = if code_point.is_emoji_modifier() {
+                        State::BeforeEmojiModifier
+                    } else {
+                        State::BeforeEmoji
+                    };
+                } else if is_variation_selector(code_point) {
+                    last_seen_vs_code_point_count = 1;
+                    state = State::BeforeVsAndZwj;
+                } else {
+                    state = State::Finished;
+                }
+            }
+            State::BeforeVsAndZwj => {
+                if code_point.is_emoji() {
+                    delete_code_point_count += last_seen_vs_code_point_count + 2;
+                    last_seen_vs_code_point_count = 0;
+                    state = State::BeforeEmoji;
+                } else {
+                    state = State::Finished;
+                }
+            }
+            State::InTagSequence => {
+                if code_point.is_tag_spec_char() {
+                    delete_code_point_count += 1;
+                } else if code_point.is_emoji() {
+                    delete_code_point_count += 1;
+                    state = State::Finished;
+                } else {
+                    delete_code_point_count = 1;
+                    state = State::Finished;
+                }
+            }
+            State::Finished => {
+                break;
+            }
+        }
+    }
+
+    cursor.set(start);
+    for _ in 0..delete_code_point_count {
+        let _ = cursor.prev_codepoint();
+    }
+    cursor.pos()
+}
+
+/// Calculate resulting offset for a backwards delete.
+///
+/// This involves complicated logic to handle various special cases that
+/// are unique to backspace.
+#[allow(clippy::trivially_copy_pass_by_ref)]
+pub fn offset_for_delete_backwards(region: &Selection, text: &impl EditableText) -> usize {
+    if !region.is_caret() {
+        region.min()
+    } else {
+        backspace_offset(text, region.active)
+    }
+}
diff --git a/crates/masonry/src/text/editable_text.rs b/crates/masonry/src/text/editable_text.rs
new file mode 100644
index 000000000..e0a6c5e1f
--- /dev/null
+++ b/crates/masonry/src/text/editable_text.rs
@@ -0,0 +1,521 @@
+// Copyright 2018 the Xilem Authors and the Druid Authors
+// SPDX-License-Identifier: Apache-2.0
+
+//! Traits for text editing and a basic String implementation.
+
+use std::borrow::Cow;
+use std::ops::{Deref, Range};
+use std::sync::Arc;
+
+use unicode_segmentation::{GraphemeCursor, UnicodeSegmentation};
+
+/// An EditableText trait.
+pub trait EditableText: Sized {
+    // TODO: would be nice to have something like
+    // type Cursor: EditableTextCursor<Self>;
+
+    /// Create a cursor with a reference to the text and a offset position.
+    ///
+    /// Returns None if the position isn't a codepoint boundary.
+    fn cursor(&self, position: usize) -> Option<StringCursor>;
+
+    /// Replace range with new text.
+    /// Can panic if supplied an invalid range.
+    // TODO: make this generic over Self
+    fn edit(&mut self, range: Range<usize>, new: impl Into<String>);
+
+    /// Get slice of text at range.
+    fn slice(&self, range: Range<usize>) -> Option<Cow<str>>;
+
+    /// Get length of text (in bytes).
+    fn len(&self) -> usize;
+
+    /// Get the previous word offset from the given offset, if it exists.
+    fn prev_word_offset(&self, offset: usize) -> Option<usize>;
+
+    /// Get the next word offset from the given offset, if it exists.
+    fn next_word_offset(&self, offset: usize) -> Option<usize>;
+
+    /// Get the next grapheme offset from the given offset, if it exists.
+    fn prev_grapheme_offset(&self, offset: usize) -> Option<usize>;
+
+    /// Get the next grapheme offset from the given offset, if it exists.
+    fn next_grapheme_offset(&self, offset: usize) -> Option<usize>;
+
+    /// Get the previous codepoint offset from the given offset, if it exists.
+    fn prev_codepoint_offset(&self, offset: usize) -> Option<usize>;
+
+    /// Get the next codepoint offset from the given offset, if it exists.
+    fn next_codepoint_offset(&self, offset: usize) -> Option<usize>;
+
+    /// Get the preceding line break offset from the given offset
+    fn preceding_line_break(&self, offset: usize) -> usize;
+
+    /// Get the next line break offset from the given offset
+    fn next_line_break(&self, offset: usize) -> usize;
+
+    /// Returns `true` if this text has 0 length.
+    fn is_empty(&self) -> bool;
+
+    /// Construct an instance of this type from a `&str`.
+    fn from_str(s: &str) -> Self;
+}
+
+impl EditableText for String {
+    fn cursor<'a>(&self, position: usize) -> Option<StringCursor> {
+        let new_cursor = StringCursor {
+            text: self,
+            position,
+        };
+
+        if new_cursor.is_boundary() {
+            Some(new_cursor)
+        } else {
+            None
+        }
+    }
+
+    fn edit(&mut self, range: Range<usize>, new: impl Into<String>) {
+        self.replace_range(range, &new.into());
+    }
+
+    fn slice(&self, range: Range<usize>) -> Option<Cow<str>> {
+        self.get(range).map(Cow::from)
+    }
+
+    fn len(&self) -> usize {
+        self.len()
+    }
+
+    fn prev_grapheme_offset(&self, from: usize) -> Option<usize> {
+        let mut c = GraphemeCursor::new(from, self.len(), true);
+        c.prev_boundary(self, 0).unwrap()
+    }
+
+    fn next_grapheme_offset(&self, from: usize) -> Option<usize> {
+        let mut c = GraphemeCursor::new(from, self.len(), true);
+        c.next_boundary(self, 0).unwrap()
+    }
+
+    fn prev_codepoint_offset(&self, from: usize) -> Option<usize> {
+        let mut c = self.cursor(from).unwrap();
+        c.prev()
+    }
+
+    fn next_codepoint_offset(&self, from: usize) -> Option<usize> {
+        let mut c = self.cursor(from).unwrap();
+        if c.next().is_some() {
+            Some(c.pos())
+        } else {
+            None
+        }
+    }
+
+    fn prev_word_offset(&self, from: usize) -> Option<usize> {
+        let mut offset = from;
+        let mut passed_alphanumeric = false;
+        for prev_grapheme in self.get(0..from)?.graphemes(true).rev() {
+            let is_alphanumeric = prev_grapheme.chars().next()?.is_alphanumeric();
+            if is_alphanumeric {
+                passed_alphanumeric = true;
+            } else if passed_alphanumeric {
+                return Some(offset);
+            }
+            offset -= prev_grapheme.len();
+        }
+        None
+    }
+
+    fn next_word_offset(&self, from: usize) -> Option<usize> {
+        let mut offset = from;
+        let mut passed_alphanumeric = false;
+        for next_grapheme in self.get(from..)?.graphemes(true) {
+            let is_alphanumeric = next_grapheme.chars().next()?.is_alphanumeric();
+            if is_alphanumeric {
+                passed_alphanumeric = true;
+            } else if passed_alphanumeric {
+                return Some(offset);
+            }
+            offset += next_grapheme.len();
+        }
+        Some(self.len())
+    }
+
+    fn is_empty(&self) -> bool {
+        self.is_empty()
+    }
+
+    fn from_str(s: &str) -> Self {
+        s.to_string()
+    }
+
+    fn preceding_line_break(&self, from: usize) -> usize {
+        let mut offset = from;
+
+        for byte in self.get(0..from).unwrap_or("").bytes().rev() {
+            if byte == 0x0a {
+                return offset;
+            }
+            offset -= 1;
+        }
+
+        0
+    }
+
+    fn next_line_break(&self, from: usize) -> usize {
+        let mut offset = from;
+
+        for char in self.get(from..).unwrap_or("").bytes() {
+            if char == 0x0a {
+                return offset;
+            }
+            offset += 1;
+        }
+
+        self.len()
+    }
+}
+
+impl EditableText for Arc<String> {
+    fn cursor(&self, position: usize) -> Option<StringCursor> {
+        <String as EditableText>::cursor(self, position)
+    }
+    fn edit(&mut self, range: Range<usize>, new: impl Into<String>) {
+        let new = new.into();
+        if !range.is_empty() || !new.is_empty() {
+            Arc::make_mut(self).edit(range, new)
+        }
+    }
+    fn slice(&self, range: Range<usize>) -> Option<Cow<str>> {
+        Some(Cow::Borrowed(&self[range]))
+    }
+    fn len(&self) -> usize {
+        self.deref().len()
+    }
+    fn prev_word_offset(&self, offset: usize) -> Option<usize> {
+        self.deref().prev_word_offset(offset)
+    }
+    fn next_word_offset(&self, offset: usize) -> Option<usize> {
+        self.deref().next_word_offset(offset)
+    }
+    fn prev_grapheme_offset(&self, offset: usize) -> Option<usize> {
+        self.deref().prev_grapheme_offset(offset)
+    }
+    fn next_grapheme_offset(&self, offset: usize) -> Option<usize> {
+        self.deref().next_grapheme_offset(offset)
+    }
+    fn prev_codepoint_offset(&self, offset: usize) -> Option<usize> {
+        self.deref().prev_codepoint_offset(offset)
+    }
+    fn next_codepoint_offset(&self, offset: usize) -> Option<usize> {
+        self.deref().next_codepoint_offset(offset)
+    }
+    fn preceding_line_break(&self, offset: usize) -> usize {
+        self.deref().preceding_line_break(offset)
+    }
+    fn next_line_break(&self, offset: usize) -> usize {
+        self.deref().next_line_break(offset)
+    }
+    fn is_empty(&self) -> bool {
+        self.deref().is_empty()
+    }
+    fn from_str(s: &str) -> Self {
+        Arc::new(s.to_owned())
+    }
+}
+
+/// A cursor with convenience functions for moving through EditableText.
+pub trait EditableTextCursor {
+    /// Set cursor position.
+    fn set(&mut self, position: usize);
+
+    /// Get cursor position.
+    fn pos(&self) -> usize;
+
+    /// Check if cursor position is at a codepoint boundary.
+    fn is_boundary(&self) -> bool;
+
+    /// Move cursor to previous codepoint boundary, if it exists.
+    /// Returns previous codepoint as usize offset.
+    fn prev(&mut self) -> Option<usize>;
+
+    /// Move cursor to next codepoint boundary, if it exists.
+    /// Returns current codepoint as usize offset.
+    fn next(&mut self) -> Option<usize>;
+
+    /// Get the next codepoint after the cursor position, without advancing
+    /// the cursor.
+    fn peek_next_codepoint(&self) -> Option<char>;
+
+    /// Return codepoint preceding cursor offset and move cursor backward.
+    fn prev_codepoint(&mut self) -> Option<char>;
+
+    /// Return codepoint at cursor offset and move cursor forward.
+    fn next_codepoint(&mut self) -> Option<char>;
+
+    /// Return current offset if it's a boundary, else next.
+    fn at_or_next(&mut self) -> Option<usize>;
+
+    /// Return current offset if it's a boundary, else previous.
+    fn at_or_prev(&mut self) -> Option<usize>;
+}
+
+/// A cursor type that implements EditableTextCursor for String
+#[derive(Debug)]
+pub struct StringCursor<'a> {
+    text: &'a str,
+    position: usize,
+}
+
+impl<'a> EditableTextCursor<&'a String> for StringCursor<'a> {
+    fn set(&mut self, position: usize) {
+        self.position = position;
+    }
+
+    fn pos(&self) -> usize {
+        self.position
+    }
+
+    fn is_boundary(&self) -> bool {
+        self.text.is_char_boundary(self.position)
+    }
+
+    fn prev(&mut self) -> Option<usize> {
+        let current_pos = self.pos();
+
+        if current_pos == 0 {
+            None
+        } else {
+            let mut len = 1;
+            while !self.text.is_char_boundary(current_pos - len) {
+                len += 1;
+            }
+            self.set(self.pos() - len);
+            Some(self.pos())
+        }
+    }
+
+    fn next(&mut self) -> Option<usize> {
+        let current_pos = self.pos();
+
+        if current_pos == self.text.len() {
+            None
+        } else {
+            let b = self.text.as_bytes()[current_pos];
+            self.set(current_pos + len_utf8_from_first_byte(b));
+            Some(current_pos)
+        }
+    }
+
+    fn peek_next_codepoint(&self) -> Option<char> {
+        self.text[self.pos()..].chars().next()
+    }
+
+    fn prev_codepoint(&mut self) -> Option<char> {
+        if let Some(prev) = self.prev() {
+            self.text[prev..].chars().next()
+        } else {
+            None
+        }
+    }
+
+    fn next_codepoint(&mut self) -> Option<char> {
+        let current_index = self.pos();
+        if self.next().is_some() {
+            self.text[current_index..].chars().next()
+        } else {
+            None
+        }
+    }
+
+    fn at_or_next(&mut self) -> Option<usize> {
+        if self.is_boundary() {
+            Some(self.pos())
+        } else {
+            self.next()
+        }
+    }
+
+    fn at_or_prev(&mut self) -> Option<usize> {
+        if self.is_boundary() {
+            Some(self.pos())
+        } else {
+            self.prev()
+        }
+    }
+}
+
+pub fn len_utf8_from_first_byte(b: u8) -> usize {
+    match b {
+        b if b < 0x80 => 1,
+        b if b < 0xe0 => 2,
+        b if b < 0xf0 => 3,
+        _ => 4,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn replace() {
+        let mut a = String::from("hello world");
+        a.edit(1..9, "era");
+        assert_eq!("herald", a);
+    }
+
+    #[test]
+    fn prev_codepoint_offset() {
+        let a = String::from("a\u{00A1}\u{4E00}\u{1F4A9}");
+        assert_eq!(Some(6), a.prev_codepoint_offset(10));
+        assert_eq!(Some(3), a.prev_codepoint_offset(6));
+        assert_eq!(Some(1), a.prev_codepoint_offset(3));
+        assert_eq!(Some(0), a.prev_codepoint_offset(1));
+        assert_eq!(None, a.prev_codepoint_offset(0));
+        let b = a.slice(1..10).unwrap().to_string();
+        assert_eq!(Some(5), b.prev_codepoint_offset(9));
+        assert_eq!(Some(2), b.prev_codepoint_offset(5));
+        assert_eq!(Some(0), b.prev_codepoint_offset(2));
+        assert_eq!(None, b.prev_codepoint_offset(0));
+    }
+
+    #[test]
+    fn next_codepoint_offset() {
+        let a = String::from("a\u{00A1}\u{4E00}\u{1F4A9}");
+        assert_eq!(Some(10), a.next_codepoint_offset(6));
+        assert_eq!(Some(6), a.next_codepoint_offset(3));
+        assert_eq!(Some(3), a.next_codepoint_offset(1));
+        assert_eq!(Some(1), a.next_codepoint_offset(0));
+        assert_eq!(None, a.next_codepoint_offset(10));
+        let b = a.slice(1..10).unwrap().to_string();
+        assert_eq!(Some(9), b.next_codepoint_offset(5));
+        assert_eq!(Some(5), b.next_codepoint_offset(2));
+        assert_eq!(Some(2), b.next_codepoint_offset(0));
+        assert_eq!(None, b.next_codepoint_offset(9));
+    }
+
+    #[test]
+    fn prev_next() {
+        let input = String::from("abc");
+        let mut cursor = input.cursor(0).unwrap();
+        assert_eq!(cursor.next(), Some(0));
+        assert_eq!(cursor.next(), Some(1));
+        assert_eq!(cursor.prev(), Some(1));
+        assert_eq!(cursor.next(), Some(1));
+        assert_eq!(cursor.next(), Some(2));
+    }
+
+    #[test]
+    fn peek_next_codepoint() {
+        let inp = String::from("$¢€£💶");
+        let mut cursor = inp.cursor(0).unwrap();
+        assert_eq!(cursor.peek_next_codepoint(), Some('$'));
+        assert_eq!(cursor.peek_next_codepoint(), Some('$'));
+        assert_eq!(cursor.next_codepoint(), Some('$'));
+        assert_eq!(cursor.peek_next_codepoint(), Some('¢'));
+        assert_eq!(cursor.prev_codepoint(), Some('$'));
+        assert_eq!(cursor.peek_next_codepoint(), Some('$'));
+        assert_eq!(cursor.next_codepoint(), Some('$'));
+        assert_eq!(cursor.next_codepoint(), Some('¢'));
+        assert_eq!(cursor.peek_next_codepoint(), Some('€'));
+        assert_eq!(cursor.next_codepoint(), Some('€'));
+        assert_eq!(cursor.peek_next_codepoint(), Some('£'));
+        assert_eq!(cursor.next_codepoint(), Some('£'));
+        assert_eq!(cursor.peek_next_codepoint(), Some('💶'));
+        assert_eq!(cursor.next_codepoint(), Some('💶'));
+        assert_eq!(cursor.peek_next_codepoint(), None);
+        assert_eq!(cursor.next_codepoint(), None);
+        assert_eq!(cursor.peek_next_codepoint(), None);
+    }
+
+    #[test]
+    fn prev_grapheme_offset() {
+        // A with ring, hangul, regional indicator "US"
+        let a = String::from("A\u{030a}\u{110b}\u{1161}\u{1f1fa}\u{1f1f8}");
+        assert_eq!(Some(9), a.prev_grapheme_offset(17));
+        assert_eq!(Some(3), a.prev_grapheme_offset(9));
+        assert_eq!(Some(0), a.prev_grapheme_offset(3));
+        assert_eq!(None, a.prev_grapheme_offset(0));
+    }
+
+    #[test]
+    fn next_grapheme_offset() {
+        // A with ring, hangul, regional indicator "US"
+        let a = String::from("A\u{030a}\u{110b}\u{1161}\u{1f1fa}\u{1f1f8}");
+        assert_eq!(Some(3), a.next_grapheme_offset(0));
+        assert_eq!(Some(9), a.next_grapheme_offset(3));
+        assert_eq!(Some(17), a.next_grapheme_offset(9));
+        assert_eq!(None, a.next_grapheme_offset(17));
+    }
+
+    #[test]
+    fn prev_word_offset() {
+        let a = String::from("Technically a word: ৬藏A\u{030a}\u{110b}\u{1161}");
+        assert_eq!(Some(20), a.prev_word_offset(35));
+        assert_eq!(Some(20), a.prev_word_offset(27));
+        assert_eq!(Some(20), a.prev_word_offset(23));
+        assert_eq!(Some(14), a.prev_word_offset(20));
+        assert_eq!(Some(14), a.prev_word_offset(19));
+        assert_eq!(Some(12), a.prev_word_offset(13));
+        assert_eq!(None, a.prev_word_offset(12));
+        assert_eq!(None, a.prev_word_offset(11));
+        assert_eq!(None, a.prev_word_offset(0));
+    }
+
+    #[test]
+    fn next_word_offset() {
+        let a = String::from("Technically a word: ৬藏A\u{030a}\u{110b}\u{1161}");
+        assert_eq!(Some(11), a.next_word_offset(0));
+        assert_eq!(Some(11), a.next_word_offset(7));
+        assert_eq!(Some(13), a.next_word_offset(11));
+        assert_eq!(Some(18), a.next_word_offset(14));
+        assert_eq!(Some(35), a.next_word_offset(18));
+        assert_eq!(Some(35), a.next_word_offset(19));
+        assert_eq!(Some(35), a.next_word_offset(20));
+        assert_eq!(Some(35), a.next_word_offset(26));
+        assert_eq!(Some(35), a.next_word_offset(35));
+    }
+
+    #[test]
+    fn preceding_line_break() {
+        let a = String::from("Technically\na word:\n ৬藏A\u{030a}\n\u{110b}\u{1161}");
+        assert_eq!(0, a.preceding_line_break(0));
+        assert_eq!(0, a.preceding_line_break(11));
+        assert_eq!(12, a.preceding_line_break(12));
+        assert_eq!(12, a.preceding_line_break(13));
+        assert_eq!(20, a.preceding_line_break(21));
+        assert_eq!(31, a.preceding_line_break(31));
+        assert_eq!(31, a.preceding_line_break(34));
+
+        let b = String::from("Technically a word: ৬藏A\u{030a}\u{110b}\u{1161}");
+        assert_eq!(0, b.preceding_line_break(0));
+        assert_eq!(0, b.preceding_line_break(11));
+        assert_eq!(0, b.preceding_line_break(13));
+        assert_eq!(0, b.preceding_line_break(21));
+    }
+
+    #[test]
+    fn next_line_break() {
+        let a = String::from("Technically\na word:\n ৬藏A\u{030a}\n\u{110b}\u{1161}");
+        assert_eq!(11, a.next_line_break(0));
+        assert_eq!(11, a.next_line_break(11));
+        assert_eq!(19, a.next_line_break(13));
+        assert_eq!(30, a.next_line_break(21));
+        assert_eq!(a.len(), a.next_line_break(31));
+
+        let b = String::from("Technically a word: ৬藏A\u{030a}\u{110b}\u{1161}");
+        assert_eq!(b.len(), b.next_line_break(0));
+        assert_eq!(b.len(), b.next_line_break(11));
+        assert_eq!(b.len(), b.next_line_break(13));
+        assert_eq!(b.len(), b.next_line_break(19));
+    }
+
+    #[test]
+    fn arcstring_empty_edit() {
+        let a = Arc::new("hello".to_owned());
+        let mut b = a.clone();
+        b.edit(5..5, "");
+        assert!(Arc::ptr_eq(&a, &b));
+    }
+}
diff --git a/crates/masonry/src/text/font_descriptor.rs b/crates/masonry/src/text/font_descriptor.rs
new file mode 100644
index 000000000..1eb428d3f
--- /dev/null
+++ b/crates/masonry/src/text/font_descriptor.rs
@@ -0,0 +1,72 @@
+// Copyright 2018 the Xilem Authors and the Druid Authors
+// SPDX-License-Identifier: Apache-2.0
+
+//! Font attributes
+
+use parley::{
+    fontique::{Style, Weight},
+    style::FontFamily,
+};
+
+/// A collection of attributes that describe a font.
+///
+/// This is provided as a convenience; library consumers may wish to have
+/// a single type that represents a specific font face at a specific size.
+#[derive(Debug, Clone, PartialEq)]
+pub struct FontDescriptor {
+    /// The font's [`FontFamily`](struct.FontFamily.html).
+    pub family: FontFamily<'static>,
+    /// The font's size.
+    pub size: f32,
+    /// The font's [`FontWeight`](struct.FontWeight.html).
+    pub weight: Weight,
+    /// The font's [`FontStyle`](struct.FontStyle.html).
+    pub style: Style,
+}
+
+impl FontDescriptor {
+    /// Create a new descriptor with the provided [`FontFamily`].
+    ///
+    /// [`FontFamily`]: struct.FontFamily.html
+    pub const fn new(family: FontFamily<'static>) -> Self {
+        FontDescriptor {
+            family,
+            size: 12.,
+            weight: Weight::NORMAL,
+            style: Style::Normal,
+        }
+    }
+
+    /// Buider-style method to set the descriptor's font size.
+    pub const fn with_size(mut self, size: f32) -> Self {
+        self.size = size;
+        self
+    }
+
+    /// Buider-style method to set the descriptor's [`FontWeight`].
+    ///
+    /// [`FontWeight`]: struct.FontWeight.html
+    pub const fn with_weight(mut self, weight: Weight) -> Self {
+        self.weight = weight;
+        self
+    }
+
+    /// Buider-style method to set the descriptor's [`FontStyle`].
+    ///
+    /// [`FontStyle`]: enum.FontStyle.html
+    pub const fn with_style(mut self, style: Style) -> Self {
+        self.style = style;
+        self
+    }
+}
+
+impl Default for FontDescriptor {
+    fn default() -> Self {
+        FontDescriptor {
+            family: FontFamily::Generic(parley::style::GenericFamily::SystemUi),
+            weight: Default::default(),
+            style: Default::default(),
+            size: 12.,
+        }
+    }
+}
diff --git a/crates/masonry/src/text/input_component.rs b/crates/masonry/src/text/input_component.rs
new file mode 100644
index 000000000..e60b0d518
--- /dev/null
+++ b/crates/masonry/src/text/input_component.rs
@@ -0,0 +1,750 @@
+// Copyright 2018 the Xilem Authors and the Druid Authors
+// SPDX-License-Identifier: Apache-2.0
+
+//! A widget component that integrates with the platform text system.
+
+use std::cell::{Cell, Ref, RefCell, RefMut};
+use std::ops::Range;
+use std::sync::{Arc, Weak};
+
+use kurbo::{Line, Point, Vec2};
+use parley::layout::Alignment;
+use winit::event::Modifiers;
+
+use super::backspace::offset_for_delete_backwards;
+use super::editable_text::EditableText;
+use super::layout::TextLayout;
+use super::shell_text::{Action, Direction, Movement, Selection};
+use super::storage::TextStorage;
+
+use crate::text;
+
+/// A widget that accepts text input.
+///
+/// This is intended to be used as a component of other widgets.
+///
+/// Text input is more complicated than you think, probably. For a good
+/// overview, see [`druid_shell::text`].
+///
+/// This type manages an inner [`EditSession`] that is shared with the platform.
+/// Unlike other aspects of Masonry, the platform interacts with this session, not
+/// through discrete events.
+///
+/// This is managed through a simple 'locking' mechanism; the platform asks for
+/// a lock on a particular text session that it wishes to interact with, calls
+/// methods on the locked session, and then later releases the lock.
+///
+/// Importantly, *other events may be received while the lock is held*.
+///
+/// It is the responsibility of the user of this widget to ensure that the
+/// session is not locked before it is accessed. This can be done by checking
+/// [`TextComponent::can_read`] and [`TextComponent::can_write`];
+/// after checking these methods the inner session can be accessed via
+/// [`TextComponent::borrow`] and [`TextComponent::borrow_mut`].
+///
+/// Sementically, this functions like a `RefCell`; attempting to borrow while
+/// a lock is held will result in a panic.
+#[derive(Debug, Clone)]
+pub struct TextComponent<T> {
+    edit_session: Arc<RefCell<EditSession<T>>>,
+    lock: Arc<Cell<ImeLock>>,
+    // HACK: because of the way focus works (it is managed higher up, in
+    // whatever widget is controlling this) we can't rely on `is_focused` in
+    // the PaintCtx.
+    /// A manual flag set by the parent to control drawing behaviour.
+    ///
+    /// The parent should update this when handling [`StatusChange::FocusChanged`].
+    pub has_focus: bool,
+}
+
+// crate::declare_widget!(
+//     TextComponentMut,
+//     TextComponent<T: (TextStorage + EditableText)>
+// );
+
+/// Editable text state.
+///
+/// This is the inner state of a [`TextComponent`]. It should only be accessed
+/// through its containing [`TextComponent`], or by the platform through an
+/// [`ImeHandlerRef`] created by [`TextComponent::input_handler`].
+#[derive(Debug, Clone)]
+pub struct EditSession<T> {
+    /// The inner [`TextLayout`] object.
+    ///
+    /// This is exposed so that users can do things like set text properties;
+    /// you should avoid doing things like rebuilding this layout manually, or
+    /// setting the text directly.
+    pub layout: TextLayout<T>,
+    /// If the platform modifies the text, this contains the new text;
+    /// we update the app `Data` with this text on the next update pass.
+    external_text_change: Option<T>,
+    external_selection_change: Option<Selection>,
+    external_scroll_to: Option<bool>,
+    // external_action: Option<Action>,
+    /// A flag set in `update` if the text has changed from a non-IME source.
+    // pending_ime_invalidation: Option<ImeInvalidation>,
+    /// If `true`, the component will send the [`TextComponent::RETURN`]
+    /// notification when the user enters a newline.
+    pub send_notification_on_return: bool,
+    /// If `true`, the component will send the [`TextComponent::CANCEL`]
+    /// notification when the user cancels editing.
+    pub send_notification_on_cancel: bool,
+    selection: Selection,
+    accepts_newlines: bool,
+    accepts_tabs: bool,
+    alignment: Alignment,
+    /// The y-position of the text when it does not fill our width.
+    alignment_offset: f64,
+    /// The portion of the text that is currently marked by the IME.
+    composition_range: Option<Range<usize>>,
+    drag_granularity: DragGranularity,
+    /// The origin of the textbox, relative to the origin of the window.
+    pub origin: Point,
+}
+
+/// An object that can be used to acquire an `ImeHandler`.
+///
+/// This does not own the session; when the widget that owns the session
+/// is dropped, this will become invalid.
+#[derive(Debug, Clone)]
+struct EditSessionRef<T> {
+    inner: Weak<RefCell<EditSession<T>>>,
+    lock: Arc<Cell<ImeLock>>,
+}
+
+/// A locked handle to an [`EditSession`].
+///
+/// This type implements [`InputHandler`]; it is the type that we pass to the
+/// platform.
+struct EditSessionHandle<T> {
+    text: T,
+    inner: Arc<RefCell<EditSession<T>>>,
+}
+
+/// When a drag follows a double- or triple-click, the behaviour of
+/// drag changes to only select whole words or whole paragraphs.
+#[derive(Debug, Clone, Copy, PartialEq)]
+enum DragGranularity {
+    Grapheme,
+    /// Start and end are the start/end bounds of the initial selection.
+    Word {
+        start: usize,
+        end: usize,
+    },
+    /// Start and end are the start/end bounds of the initial selection.
+    Paragraph {
+        start: usize,
+        end: usize,
+    },
+}
+
+/// An informal lock.
+#[derive(Debug, Clone, Copy, PartialEq)]
+enum ImeLock {
+    None,
+    ReadWrite,
+    Read,
+}
+
+impl<T> TextComponent<T> {
+    /// Returns `true` if the inner [`EditSession`] can be read.
+    pub fn can_read(&self) -> bool {
+        self.lock.get() != ImeLock::ReadWrite
+    }
+
+    /// Returns `true` if the inner [`EditSession`] can be mutated.
+    pub fn can_write(&self) -> bool {
+        self.lock.get() == ImeLock::None
+    }
+
+    /// Returns `true` if the IME is actively composing (or the text is locked.)
+    ///
+    /// When text is composing, you should avoid doing things like modifying the
+    /// selection or copy/pasting text.
+    pub fn is_composing(&self) -> bool {
+        self.can_read() && self.borrow().composition_range.is_some()
+    }
+
+    /// Attempt to mutably borrow the inner [`EditSession`].
+    ///
+    /// # Panics
+    ///
+    /// This method panics if there is an outstanding lock on the session.
+    pub fn borrow_mut(&self) -> RefMut<'_, EditSession<T>> {
+        assert!(self.can_write());
+        self.edit_session.borrow_mut()
+    }
+
+    /// Attempt to borrow the inner [`EditSession`].
+    ///
+    /// # Panics
+    ///
+    /// This method panics if there is an outstanding write lock on the session.
+    pub fn borrow(&self) -> Ref<'_, EditSession<T>> {
+        assert!(self.can_read());
+        self.edit_session.borrow()
+    }
+}
+
+impl<T: TextStorage + EditableText> TextComponentMut<'_, T> {
+    pub fn set_text(&mut self, new_text: impl Into<T>) {
+        let new_text = new_text.into();
+        // TODO - use '==' instead
+        let needs_rebuild = self
+            .widget
+            .borrow()
+            .layout
+            .text()
+            .map(|old| !old.maybe_eq(&new_text))
+            .unwrap_or(true);
+        if needs_rebuild {
+            self.widget.borrow_mut().layout.set_text(new_text.clone());
+            self.ctx.request_layout();
+        }
+    }
+
+    pub fn set_focused(&mut self, focused: bool) {
+        self.widget.has_focus = focused;
+        self.ctx.request_paint();
+    }
+}
+
+// impl<T: TextStorage + EditableText> Widget for TextComponent<T> {
+//     fn on_event(&mut self, ctx: &mut EventCtx, event: &Event) {
+//         match event {
+//             Event::MouseDown(mouse) if self.can_write() && !ctx.is_disabled() => {
+//                 ctx.set_active(true);
+//                 self.borrow_mut()
+//                     .do_mouse_down(mouse.pos, mouse.mods, mouse.count);
+//                 self.borrow_mut()
+//                     .update_pending_invalidation(ImeInvalidation::SelectionChanged);
+//                 ctx.request_layout();
+//                 ctx.request_paint();
+//             }
+//             Event::MouseMove(mouse) if self.can_write() => {
+//                 if !ctx.is_disabled() {
+//                     ctx.set_cursor(&Cursor::IBeam);
+//                     if ctx.is_active() {
+//                         let pre_sel = self.borrow().selection();
+//                         self.borrow_mut().do_drag(mouse.pos);
+//                         if self.borrow().selection() != pre_sel {
+//                             self.borrow_mut()
+//                                 .update_pending_invalidation(ImeInvalidation::SelectionChanged);
+//                             ctx.request_layout();
+//                             ctx.request_paint();
+//                         }
+//                     }
+//                 } else {
+//                     ctx.set_disabled(false);
+//                     ctx.clear_cursor();
+//                 }
+//             }
+//             Event::MouseUp(_) if ctx.is_active() => {
+//                 ctx.set_active(false);
+//                 ctx.request_paint();
+//             }
+//             Event::ImeStateChange => {
+//                 assert!(
+//                     self.can_write(),
+//                     "lock release should be cause of ImeStateChange event"
+//                 );
+
+//                 let scroll_to = self.borrow_mut().take_scroll_to();
+//                 if let Some(scroll_to) = scroll_to {
+//                     ctx.submit_notification(TextComponent::SCROLL_TO.with(scroll_to));
+//                 }
+
+//                 let text = self.borrow_mut().take_external_text_change();
+//                 if let Some(text) = text {
+//                     self.borrow_mut().layout.set_text(text.clone());
+//                     let new_text = self
+//                         .borrow()
+//                         .layout
+//                         .text()
+//                         .map(|txt| txt.as_str())
+//                         .unwrap_or("")
+//                         .to_string();
+//                     ctx.submit_notification(TextComponent::TEXT_CHANGED.with(new_text));
+//                 }
+
+//                 let action = self.borrow_mut().take_external_action();
+//                 if let Some(action) = action {
+//                     match action {
+//                         Action::Cancel => ctx.submit_notification(TextComponent::CANCEL),
+//                         Action::InsertNewLine { .. } => {
+//                             let text = self
+//                                 .borrow()
+//                                 .layout
+//                                 .text()
+//                                 .map(|txt| txt.as_str())
+//                                 .unwrap_or("")
+//                                 .to_string();
+//                             ctx.submit_notification(TextComponent::RETURN.with(text));
+//                         }
+//                         Action::InsertTab { .. } => ctx.submit_notification(TextComponent::TAB),
+//                         Action::InsertBacktab => {
+//                             ctx.submit_notification(TextComponent::BACKTAB)
+//                         }
+//                         _ => tracing::warn!("unexepcted external action '{:?}'", action),
+//                     };
+//                 }
+
+//                 let selection = self.borrow_mut().take_external_selection_change();
+//                 if let Some(selection) = selection {
+//                     self.borrow_mut().selection = selection;
+//                     ctx.request_paint();
+//                 }
+//                 ctx.request_layout();
+//             }
+//             _ => (),
+//         }
+//     }
+
+//     fn on_status_change(&mut self, _ctx: &mut LifeCycleCtx, _event: &StatusChange) {}
+
+//     fn lifecycle(&mut self, ctx: &mut LifeCycleCtx, event: &LifeCycle) {
+//         match event {
+//             LifeCycle::WidgetAdded => {
+//                 assert!(
+//                     self.can_write(),
+//                     "ime should never be locked at WidgetAdded"
+//                 );
+//                 self.borrow_mut().layout.rebuild_if_needed(ctx.text());
+//             }
+//             LifeCycle::DisabledChanged(disabled) => {
+//                 if self.can_write() {
+//                     let color = if *disabled {
+//                         theme::DISABLED_TEXT_COLOR
+//                     } else {
+//                         theme::TEXT_COLOR
+//                     };
+//                     self.borrow_mut().layout.set_text_color(color);
+//                 }
+//                 ctx.request_layout();
+//             }
+//             //FIXME: this should happen in the parent too?
+//             LifeCycle::Internal(crate::InternalLifeCycle::ParentWindowOrigin) => {
+//                 if self.can_write() {
+//                     let prev_origin = self.borrow().origin;
+//                     let new_origin = ctx.window_origin();
+//                     if prev_origin != new_origin {
+//                         self.borrow_mut().origin = ctx.window_origin();
+//                         ctx.invalidate_text_input(ImeInvalidation::LayoutChanged);
+//                     }
+//                 }
+//             }
+//             _ => (),
+//         }
+//     }
+
+//     fn layout(&mut self, ctx: &mut LayoutCtx, bc: &BoxConstraints) -> Size {
+//         if !self.can_write() {
+//             tracing::warn!("Text layout called with IME lock held.");
+//             return Size::ZERO;
+//         }
+
+//         self.borrow_mut().layout.set_wrap_width(bc.max().width);
+//         self.borrow_mut().layout.rebuild_if_needed(ctx.text());
+//         let metrics = self.borrow().layout.layout_metrics();
+//         let width = if bc.max().width.is_infinite() || bc.max().width < f64::MAX {
+//             metrics.trailing_whitespace_width
+//         } else {
+//             metrics.size.width
+//         };
+//         let size = bc.constrain((width, metrics.size.height));
+//         let extra_width = if self.borrow().accepts_newlines {
+//             0.0
+//         } else {
+//             (size.width - width).max(0.0)
+//         };
+//         self.borrow_mut().update_alignment_offset(extra_width);
+//         let baseline_off = metrics.size.height - metrics.first_baseline;
+//         ctx.set_baseline_offset(baseline_off);
+//         size
+//     }
+
+//     fn paint(&mut self, ctx: &mut PaintCtx) {
+//         if !self.can_read() {
+//             tracing::warn!("Text paint called with IME lock held.");
+//         }
+
+//         let selection_color = if self.has_focus {
+//             theme::SELECTED_TEXT_BACKGROUND_COLOR
+//         } else {
+//             theme::SELECTED_TEXT_INACTIVE_BACKGROUND_COLOR
+//         };
+
+//         let cursor_color = theme::CURSOR_COLOR;
+//         let text_offset = Vec2::new(self.borrow().alignment_offset, 0.0);
+
+//         let selection = self.borrow().selection();
+//         let composition = self.borrow().composition_range();
+//         let sel_rects = self.borrow().layout.rects_for_range(selection.range());
+//         if let Some(composition) = composition {
+//             // I believe selection should always be contained in composition range while composing?
+//             assert!(composition.start <= selection.anchor && composition.end >= selection.active);
+//             let comp_rects = self.borrow().layout.rects_for_range(composition);
+//             for region in comp_rects {
+//                 let y = region.max_y().floor();
+//                 let line = Line::new((region.min_x(), y), (region.max_x(), y)) + text_offset;
+//                 ctx.stroke(line, &cursor_color, 1.0);
+//             }
+//             for region in sel_rects {
+//                 let y = region.max_y().floor();
+//                 let line = Line::new((region.min_x(), y), (region.max_x(), y)) + text_offset;
+//                 ctx.stroke(line, &cursor_color, 2.0);
+//             }
+//         } else {
+//             for region in sel_rects {
+//                 let rounded = (region + text_offset).to_rounded_rect(1.0);
+//                 ctx.fill(rounded, &selection_color);
+//             }
+//         }
+//         self.borrow().layout.draw(ctx, text_offset.to_point());
+//     }
+
+//     fn children(&self) -> SmallVec<[WidgetRef<'_, dyn Widget>; 16]> {
+//         SmallVec::new()
+//     }
+
+//     fn make_trace_span(&self) -> Span {
+//         trace_span!("TextComponent")
+//     }
+// }
+
+impl<T> EditSession<T> {
+    /// The current [`Selection`].
+    pub fn selection(&self) -> Selection {
+        self.selection
+    }
+
+    /// Manually set the selection.
+    ///
+    /// If the new selection is different from the current selection, this
+    /// will return an ime event that the controlling widget should use to
+    /// invalidte the platform's IME state, by passing it to
+    /// [`EventCtx::invalidate_text_input`].
+    #[must_use]
+    pub fn set_selection(&mut self, selection: Selection) /* -> Option<ImeInvalidation> */
+    {
+        if selection != self.selection {
+            self.selection = selection;
+            // self.update_pending_invalidation(ImeInvalidation::SelectionChanged);
+            // Some(ImeInvalidation::SelectionChanged)
+        }
+    }
+
+    /// The range of text currently being modified by an IME.
+    pub fn composition_range(&self) -> Option<Range<usize>> {
+        self.composition_range.clone()
+    }
+
+    /// Sets whether or not this session will allow the insertion of newlines.
+    pub fn set_accepts_newlines(&mut self, accepts_newlines: bool) {
+        self.accepts_newlines = accepts_newlines;
+    }
+
+    /// Set the text alignment.
+    ///
+    /// This is only meaningful for single-line text that does not fill
+    /// the minimum layout size.
+    pub fn set_text_alignment(&mut self, alignment: Alignment) {
+        self.alignment = alignment;
+    }
+
+    /// The text alignment.
+    pub fn text_alignment(&self) -> Alignment {
+        self.alignment
+    }
+
+    // /// Returns any invalidation action that should be passed to the platform.
+    // ///
+    // /// The user of this component *must* check this after calling `update`.
+    // pub fn pending_ime_invalidation(&mut self) -> Option<ImeInvalidation> {
+    //     self.pending_ime_invalidation.take()
+    // }
+
+    fn take_external_text_change(&mut self) -> Option<T> {
+        self.external_text_change.take()
+    }
+
+    fn take_external_selection_change(&mut self) -> Option<Selection> {
+        self.external_selection_change.take()
+    }
+
+    fn take_scroll_to(&mut self) -> Option<bool> {
+        self.external_scroll_to.take()
+    }
+
+    // fn take_external_action(&mut self) -> Option<Action> {
+    //     self.external_action.take()
+    // }
+
+    // // we don't want to replace a more aggressive invalidation with a less aggressive one.
+    // fn update_pending_invalidation(&mut self, new_invalidation: ImeInvalidation) {
+    //     self.pending_ime_invalidation = match self.pending_ime_invalidation.take() {
+    //         None => Some(new_invalidation),
+    //         Some(prev) => match (prev, new_invalidation) {
+    //             (ImeInvalidation::SelectionChanged, ImeInvalidation::SelectionChanged) => {
+    //                 ImeInvalidation::SelectionChanged
+    //             }
+    //             (ImeInvalidation::LayoutChanged, ImeInvalidation::LayoutChanged) => {
+    //                 ImeInvalidation::LayoutChanged
+    //             }
+    //             _ => ImeInvalidation::Reset,
+    //         }
+    //         .into(),
+    //     }
+    // }
+
+    fn update_alignment_offset(&mut self, extra_width: f64) {
+        self.alignment_offset = match self.alignment {
+            Alignment::Start | Alignment::Justified => 0.0,
+            Alignment::End => extra_width,
+            Alignment::Center => extra_width / 2.0,
+        };
+    }
+}
+
+impl<T: TextStorage + EditableText> EditSession<T> {
+    /// Insert text *not* from the IME, replacing the current selection.
+    ///
+    /// The caller is responsible for notifying the platform of the change in
+    /// text state, by calling [`EventCtx::invalidate_text_input`].
+    #[must_use]
+    pub fn insert_text(&mut self, data: &mut T, new_text: &str) {
+        let new_cursor_pos = self.selection.min() + new_text.len();
+        data.edit(self.selection.range(), new_text);
+        self.selection = Selection::caret(new_cursor_pos);
+        self.scroll_to_selection_end(true);
+    }
+
+    /// Sets the clipboard to the contents of the current selection.
+    ///
+    /// Returns `true` if the clipboard was set, and `false` if not (indicating)
+    /// that the selection was empty.)
+    pub fn set_clipboard(&self) -> bool {
+        // if let Some(text) = self
+        //     .layout
+        //     .text()
+        //     .and_then(|txt| txt.slice(self.selection.range()))
+        // {
+        //     if !text.is_empty() {
+        //         druid_shell::Application::global()
+        //             .clipboard()
+        //             .put_string(text);
+        //         return true;
+        //     }
+        // }
+        false
+    }
+
+    fn scroll_to_selection_end(&mut self, after_edit: bool) {
+        self.external_scroll_to = Some(after_edit);
+    }
+
+    fn do_action(&mut self, buffer: &mut T, action: Action) {
+        match action {
+            Action::Move(movement) => {
+                let sel = text::movement::movement(movement, self.selection, &self.layout, false);
+                self.external_selection_change = Some(sel);
+                self.scroll_to_selection_end(false);
+            }
+            Action::MoveSelecting(movement) => {
+                let sel = text::movement::movement(movement, self.selection, &self.layout, true);
+                self.external_selection_change = Some(sel);
+                self.scroll_to_selection_end(false);
+            }
+            Action::SelectAll => {
+                let len = buffer.len();
+                self.external_selection_change = Some(Selection::new(0, len));
+            }
+            Action::SelectWord => {
+                if self.selection.is_caret() {
+                    let range =
+                        text::movement::word_range_for_pos(buffer.as_str(), self.selection.active);
+                    self.external_selection_change = Some(Selection::new(range.start, range.end));
+                }
+
+                // it is unclear what the behaviour should be if the selection
+                // is not a caret (and may span multiple words)
+            }
+            // This requires us to have access to the layout, which might be stale?
+            Action::SelectLine => (),
+            // this assumes our internal selection is consistent with the buffer?
+            Action::SelectParagraph => {
+                if !self.selection.is_caret() || buffer.len() < self.selection.active {
+                    return;
+                }
+                let prev = buffer.preceding_line_break(self.selection.active);
+                let next = buffer.next_line_break(self.selection.active);
+                self.external_selection_change = Some(Selection::new(prev, next));
+            }
+            Action::Delete(movement) if self.selection.is_caret() => {
+                if movement == Movement::Grapheme(Direction::Upstream) {
+                    self.backspace(buffer);
+                } else {
+                    let to_delete =
+                        text::movement::movement(movement, self.selection, &self.layout, true);
+                    self.selection = to_delete;
+                    self.ime_insert_text(buffer, "")
+                }
+            }
+            Action::Delete(_) => self.ime_insert_text(buffer, ""),
+            Action::DecomposingBackspace => {
+                tracing::warn!("Decomposing Backspace is not implemented");
+                self.backspace(buffer);
+            }
+            //Action::UppercaseSelection
+            //| Action::LowercaseSelection
+            //| Action::TitlecaseSelection => {
+            //tracing::warn!("IME transformations are not implemented");
+            //}
+            Action::InsertNewLine {
+                newline_type,
+                ignore_hotkey,
+            } => {
+                if self.send_notification_on_return && !ignore_hotkey {
+                    self.external_action = Some(action);
+                } else if self.accepts_newlines {
+                    self.ime_insert_text(buffer, &newline_type.to_string());
+                }
+            }
+            Action::InsertTab { ignore_hotkey } => {
+                if ignore_hotkey || self.accepts_tabs {
+                    self.ime_insert_text(buffer, "\t");
+                } else if !ignore_hotkey {
+                    self.external_action = Some(action);
+                }
+            }
+            Action::InsertBacktab => {
+                if !self.accepts_tabs {
+                    self.external_action = Some(action);
+                }
+            }
+            Action::InsertSingleQuoteIgnoringSmartQuotes => self.ime_insert_text(buffer, "'"),
+            Action::InsertDoubleQuoteIgnoringSmartQuotes => self.ime_insert_text(buffer, "\""),
+            Action::Cancel if self.send_notification_on_cancel => {
+                self.external_action = Some(action)
+            }
+            other => tracing::warn!("unhandled IME action {:?}", other),
+        }
+    }
+
+    /// Replace the current selection with `text`, and advance the cursor.
+    ///
+    /// This should only be called from the IME.
+    fn ime_insert_text(&mut self, buffer: &mut T, text: &str) {
+        let new_cursor_pos = self.selection.min() + text.len();
+        buffer.edit(self.selection.range(), text);
+        self.external_selection_change = Some(Selection::caret(new_cursor_pos));
+        self.scroll_to_selection_end(true);
+    }
+
+    fn backspace(&mut self, buffer: &mut T) {
+        let to_del = if self.selection.is_caret() {
+            let del_start = offset_for_delete_backwards(&self.selection, buffer);
+            del_start..self.selection.anchor
+        } else {
+            self.selection.range()
+        };
+        self.external_selection_change = Some(Selection::caret(to_del.start));
+        buffer.edit(to_del, "");
+        self.scroll_to_selection_end(true);
+    }
+
+    fn do_mouse_down(&mut self, point: Point, mods: Modifiers, count: u8) {
+        let point = point - Vec2::new(self.alignment_offset, 0.0);
+        let pos = self.layout.text_position_for_point(point);
+        if mods.shift() {
+            self.selection.active = pos;
+        } else {
+            let Range { start, end } = self.sel_region_for_pos(pos, count);
+            self.selection = Selection::new(start, end);
+            self.drag_granularity = match count {
+                2 => DragGranularity::Word { start, end },
+                3 => DragGranularity::Paragraph { start, end },
+                _ => DragGranularity::Grapheme,
+            };
+        }
+    }
+
+    fn do_drag(&mut self, point: Point) {
+        let point = point - Vec2::new(self.alignment_offset, 0.0);
+        //FIXME: this should behave differently if we were double or triple clicked
+        let pos = self.layout.text_position_for_point(point);
+        let text = match self.layout.text() {
+            Some(text) => text,
+            None => return,
+        };
+
+        let (start, end) = match self.drag_granularity {
+            DragGranularity::Grapheme => (self.selection.anchor, pos),
+            DragGranularity::Word { start, end } => {
+                let word_range = self.word_for_pos(pos);
+                if pos <= start {
+                    (end, word_range.start)
+                } else {
+                    (start, word_range.end)
+                }
+            }
+            DragGranularity::Paragraph { start, end } => {
+                let par_start = text.preceding_line_break(pos);
+                let par_end = text.next_line_break(pos);
+
+                if pos <= start {
+                    (end, par_start)
+                } else {
+                    (start, par_end)
+                }
+            }
+        };
+        self.selection = Selection::new(start, end);
+        self.scroll_to_selection_end(false);
+    }
+
+    /// Returns a line suitable for drawing a standard cursor.
+    pub fn cursor_line_for_text_position(&self, pos: usize) -> Line {
+        let line = self.layout.cursor_line_for_text_position(pos);
+        line + Vec2::new(self.alignment_offset, 0.0)
+    }
+
+    fn sel_region_for_pos(&mut self, pos: usize, click_count: u8) -> Range<usize> {
+        match click_count {
+            1 => pos..pos,
+            2 => self.word_for_pos(pos),
+            _ => {
+                let text = match self.layout.text() {
+                    Some(text) => text,
+                    None => return pos..pos,
+                };
+                let line_min = text.preceding_line_break(pos);
+                let line_max = text.next_line_break(pos);
+                line_min..line_max
+            }
+        }
+    }
+
+    fn word_for_pos(&self, pos: usize) -> Range<usize> {
+        let layout = match self.layout.layout() {
+            Some(layout) => layout,
+            None => return pos..pos,
+        };
+
+        let line_n = layout.hit_test_text_position(pos).line;
+        let lm = layout.line_metric(line_n).unwrap();
+        let text = layout.line_text(line_n).unwrap();
+        let rel_pos = pos - lm.start_offset;
+        let mut range = text::movement::word_range_for_pos(text, rel_pos);
+        range.start += lm.start_offset;
+        range.end += lm.start_offset;
+        range
+    }
+}
+
+impl<T: TextStorage> EditSessionHandle<T> {
+    fn new(inner: Arc<RefCell<EditSession<T>>>) -> Self {
+        let text = inner.borrow().layout.text().cloned().unwrap();
+        EditSessionHandle { text, inner }
+    }
+}
diff --git a/crates/masonry/src/text/layout.rs b/crates/masonry/src/text/layout.rs
new file mode 100644
index 000000000..f9a554d99
--- /dev/null
+++ b/crates/masonry/src/text/layout.rs
@@ -0,0 +1,417 @@
+// Copyright 2018 the Xilem Authors and the Druid Authors
+// SPDX-License-Identifier: Apache-2.0
+
+//! A type for laying out, drawing, and interacting with text.
+
+use std::rc::Rc;
+
+use kurbo::{Line, Point, Rect, Size};
+use parley::layout::{Alignment, Cursor};
+use parley::style::{FontFamily, GenericFamily};
+use parley::{Layout, LayoutContext};
+use vello::peniko::{Brush, Color};
+
+use crate::PaintCtx;
+
+use super::attribute::Link;
+use super::font_descriptor::FontDescriptor;
+use super::storage::TextStorage;
+
+/// A component for displaying text on screen.
+///
+/// This is a type intended to be used by other widgets that display text.
+/// It allows for the text itself as well as font and other styling information
+/// to be set and modified. It wraps an inner layout object, and handles
+/// invalidating and rebuilding it as required.
+///
+/// This object is not valid until the [`rebuild_if_needed`] method has been
+/// called. You should generally do this in your widget's [`layout`] method.
+/// Additionally, you should call [`needs_rebuild_after_update`]
+/// as part of your widget's [`update`] method; if this returns `true`, you will need
+/// to call [`rebuild_if_needed`] again, generally by scheduling another [`layout`]
+/// pass.
+///
+/// [`layout`]: trait.Widget.html#tymethod.layout
+/// [`update`]: trait.Widget.html#tymethod.update
+/// [`needs_rebuild_after_update`]: #method.needs_rebuild_after_update
+/// [`rebuild_if_needed`]: #method.rebuild_if_needed
+#[derive(Clone)]
+pub struct TextLayout<T> {
+    // TODO - remove Option
+    text: Option<T>,
+    font: FontDescriptor,
+    // when set, this will be used to override the size in he font descriptor.
+    // This provides an easy way to change only the font size, while still
+    // using a `FontDescriptor` in the `Env`.
+    text_size_override: Option<f32>,
+    text_color: Color,
+    layout: Option<Layout<Brush>>,
+    wrap_width: f64,
+    alignment: Alignment,
+    links: Rc<[(Rect, usize)]>,
+}
+
+/// Metrics describing the layout text.
+#[derive(Debug, Clone, Copy, Default)]
+pub struct LayoutMetrics {
+    /// The nominal size of the layout.
+    pub size: Size,
+    /// The distance from the nominal top of the layout to the first baseline.
+    pub first_baseline: f32,
+    /// The width of the layout, inclusive of trailing whitespace.
+    pub trailing_whitespace_width: f32,
+    //TODO: add inking_rect
+}
+
+impl<T> TextLayout<T> {
+    /// Create a new `TextLayout` object.
+    ///
+    /// You must set the text ([`set_text`]) before using this object.
+    ///
+    /// [`set_text`]: #method.set_text
+    pub fn new() -> Self {
+        TextLayout {
+            text: None,
+            font: FontDescriptor::new(FontFamily::Generic(GenericFamily::SystemUi)),
+            text_color: crate::theme::TEXT_COLOR,
+            text_size_override: None,
+            layout: None,
+            wrap_width: f64::INFINITY,
+            alignment: Default::default(),
+            links: Rc::new([]),
+        }
+    }
+
+    /// Set the default text color for this layout.
+    pub fn set_text_color(&mut self, color: Color) {
+        if color != self.text_color {
+            self.text_color = color;
+            self.layout = None;
+        }
+    }
+
+    /// Set the default font.
+    ///
+    /// The argument is a [`FontDescriptor`].
+    ///
+    /// [`FontDescriptor`]: struct.FontDescriptor.html
+    pub fn set_font(&mut self, font: FontDescriptor) {
+        if font != self.font {
+            self.font = font;
+            self.layout = None;
+            self.text_size_override = None;
+        }
+    }
+
+    /// Set the font size.
+    ///
+    /// This overrides the size in the [`FontDescriptor`] provided to [`set_font`].
+    ///
+    /// [`set_font`]: #method.set_font.html
+    /// [`FontDescriptor`]: struct.FontDescriptor.html
+    pub fn set_text_size(&mut self, size: f32) {
+        if Some(&size) != self.text_size_override.as_ref() {
+            self.text_size_override = Some(size);
+            self.layout = None;
+        }
+    }
+
+    /// Set the width at which to wrap words.
+    ///
+    /// You may pass `f64::INFINITY` to disable word wrapping
+    /// (the default behaviour).
+    pub fn set_wrap_width(&mut self, width: f64) {
+        let width = width.max(0.0);
+        // 1e-4 is an arbitrary small-enough value that we don't care to rewrap
+        if (width - self.wrap_width).abs() > 1e-4 {
+            self.wrap_width = width;
+            self.layout = None;
+        }
+    }
+
+    /// Set the [`TextAlignment`] for this layout.
+    ///
+    /// [`TextAlignment`]: enum.TextAlignment.html
+    pub fn set_text_alignment(&mut self, alignment: Alignment) {
+        if self.alignment != alignment {
+            self.alignment = alignment;
+            self.layout = None;
+        }
+    }
+
+    // /// Returns `true` if this layout's text appears to be right-to-left.
+    // ///
+    // /// See [`piet::util::first_strong_rtl`] for more information.
+    // ///
+    // /// [`piet::util::first_strong_rtl`]: crate::piet::util::first_strong_rtl
+    // pub fn text_is_rtl(&self) -> bool {
+    //     self.text_is_rtl
+    // }
+}
+
+impl<T: TextStorage> TextLayout<T> {
+    /// Create a new `TextLayout` with the provided text.
+    ///
+    /// This is useful when the text is not tied to application data.
+    pub fn from_text(text: impl Into<T>) -> Self {
+        let mut this = TextLayout::new();
+        this.set_text(text.into());
+        this
+    }
+
+    /// Returns `true` if this layout needs to be rebuilt.
+    ///
+    /// This happens (for instance) after style attributes are modified.
+    ///
+    /// This does not account for things like the text changing, handling that
+    /// is the responsibility of the user.
+    pub fn needs_rebuild(&self) -> bool {
+        self.layout.is_none()
+    }
+
+    /// Set the text to display.
+    pub fn set_text(&mut self, text: T) {
+        if self.text.is_none() || !self.text.as_ref().unwrap().maybe_eq(&text) {
+            self.text = Some(text);
+            self.layout = None;
+        }
+    }
+
+    /// Returns the [`TextStorage`] backing this layout, if it exists.
+    pub fn text(&self) -> Option<&T> {
+        self.text.as_ref()
+    }
+
+    /// Returns the length of the [`TextStorage`] backing this layout, if it exists.
+    pub fn text_len(&self) -> usize {
+        if let Some(text) = &self.text {
+            text.as_str().len()
+        } else {
+            0
+        }
+    }
+
+    /// Returns the inner Piet [`TextLayout`] type.
+    ///
+    /// [`TextLayout`]: ./piet/trait.TextLayout.html
+    pub fn layout(&self) -> Option<&Layout<Brush>> {
+        self.layout.as_ref()
+    }
+
+    /// The size of the laid-out text.
+    ///
+    /// This is not meaningful until [`rebuild_if_needed`] has been called.
+    ///
+    /// [`rebuild_if_needed`]: #method.rebuild_if_needed
+    pub fn size(&self) -> Size {
+        self.layout
+            .as_ref()
+            .map(|layout| Size::new(layout.width().into(), layout.height().into()))
+            .unwrap_or_default()
+    }
+
+    /// Return the text's [`LayoutMetrics`].
+    ///
+    /// This is not meaningful until [`rebuild_if_needed`] has been called.
+    ///
+    /// [`rebuild_if_needed`]: #method.rebuild_if_needed
+    /// [`LayoutMetrics`]: struct.LayoutMetrics.html
+    pub fn layout_metrics(&self) -> LayoutMetrics {
+        debug_assert!(
+            self.layout.is_some(),
+            "TextLayout::layout_metrics called without rebuilding layout object. Text was '{}'",
+            self.text().as_ref().map(|s| s.as_str()).unwrap_or_default()
+        );
+
+        if let Some(layout) = self.layout.as_ref() {
+            let first_baseline = layout.get(0).unwrap().metrics().baseline;
+            let size = Size::new(layout.width().into(), layout.height().into());
+            LayoutMetrics {
+                size,
+                first_baseline,
+                trailing_whitespace_width: layout.width(),
+            }
+        } else {
+            LayoutMetrics::default()
+        }
+    }
+
+    /// For a given `Point` (relative to this object's origin), returns index
+    /// into the underlying text of the nearest grapheme boundary.
+    pub fn text_position_for_point(&self, point: Point) -> usize {
+        self.layout
+            .as_ref()
+            .map(|layout| Cursor::from_point(layout, point.x as f32, point.y as f32).insert_point)
+            .unwrap_or_default()
+    }
+
+    /// Given the utf-8 position of a character boundary in the underlying text,
+    /// return the `Point` (relative to this object's origin) representing the
+    /// boundary of the containing grapheme.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `text_pos` is not a character boundary.
+    pub fn point_for_text_position(&self, text_pos: usize) -> Point {
+        self.layout
+            .as_ref()
+            .map(|layout| {
+                let from_position = Cursor::from_position(layout, text_pos, /* TODO */ false);
+
+                Point::new(
+                    from_position.advance as f64,
+                    (from_position.baseline + from_position.offset) as f64,
+                )
+            })
+            .unwrap_or_default()
+    }
+
+    // /// Given a utf-8 range in the underlying text, return a `Vec` of `Rect`s
+    // /// representing the nominal bounding boxes of the text in that range.
+    // ///
+    // /// # Panics
+    // ///
+    // /// Panics if the range start or end is not a character boundary.
+    // pub fn rects_for_range(&self, range: Range<usize>) -> Vec<Rect> {
+    //     self.layout
+    //         .as_ref()
+    //         .map(|layout| layout.rects_for_range(range))
+    //         .unwrap_or_default()
+    // }
+
+    /// Given the utf-8 position of a character boundary in the underlying text,
+    /// return a `Line` suitable for drawing a vertical cursor at that boundary.
+    pub fn cursor_line_for_text_position(&self, text_pos: usize) -> Line {
+        self.layout
+            .as_ref()
+            .map(|layout| {
+                let from_position = Cursor::from_position(layout, text_pos, /* TODO */ false);
+
+                let line_metrics = from_position.path.line(layout).unwrap().metrics();
+
+                let p1 = (from_position.advance as f64, line_metrics.baseline as f64);
+                let p2 = (
+                    from_position.advance as f64,
+                    (line_metrics.baseline + line_metrics.size()) as f64,
+                );
+                Line::new(p1, p2)
+            })
+            .unwrap_or_else(|| Line::new(Point::ZERO, Point::ZERO))
+    }
+
+    /// Returns the [`Link`] at the provided point (relative to the layout's origin) if one exists.
+    ///
+    /// This can be used both for hit-testing (deciding whether to change the mouse cursor,
+    /// or performing some other action when hovering) as well as for retrieving a [`Link`]
+    /// on click.
+    ///
+    /// [`Link`]: super::attribute::Link
+    pub fn link_for_pos(&self, pos: Point) -> Option<&Link> {
+        let (_, i) = self
+            .links
+            .iter()
+            .rfind(|(hit_box, _)| hit_box.contains(pos))?;
+
+        let text = self.text()?;
+        text.links().get(*i)
+    }
+
+    /// Rebuild the inner layout as needed.
+    ///
+    /// This `TextLayout` object manages a lower-level layout object that may
+    /// need to be rebuilt in response to changes to the text or attributes
+    /// like the font.
+    ///
+    /// This method should be called whenever any of these things may have changed.
+    /// A simple way to ensure this is correct is to always call this method
+    /// as part of your widget's [`layout`] method.
+    ///
+    /// [`layout`]: trait.Widget.html#method.layout
+    pub fn rebuild_if_needed(&mut self, factory: &mut LayoutContext<Brush>) {
+        if let Some(text) = &self.text {
+            if self.layout.is_none() {
+                let font = self.font.clone();
+                let color = self.text_color;
+                let size_override = self.text_size_override;
+
+                let descriptor = if let Some(size) = size_override {
+                    font.with_size(size)
+                } else {
+                    font
+                };
+
+                let builder = factory.ranged_builder(fcx, text, 1.0);
+                builder
+                    .push_default(StyleProperty)
+                    .new_text_layout(text.clone())
+                    .max_width(self.wrap_width)
+                    .alignment(self.alignment)
+                    .font(descriptor.family.clone(), descriptor.size)
+                    .default_attribute(descriptor.weight)
+                    .default_attribute(descriptor.style);
+                // .default_attribute(TextAttribute::TextColor(color));
+                let layout = text.add_attributes(builder).build().unwrap();
+
+                self.links = text
+                    .links()
+                    .iter()
+                    .enumerate()
+                    .flat_map(|(i, link)| {
+                        layout
+                            .rects_for_range(link.range())
+                            .into_iter()
+                            .map(move |rect| (rect, i))
+                    })
+                    .collect();
+
+                self.layout = Some(layout);
+            }
+        }
+    }
+
+    ///  Draw the layout at the provided `Point`.
+    ///
+    ///  The origin of the layout is the top-left corner.
+    ///
+    ///  You must call [`rebuild_if_needed`] at some point before you first
+    ///  call this method.
+    ///
+    ///  [`rebuild_if_needed`]: #method.rebuild_if_needed
+    pub fn draw(&self, ctx: &mut PaintCtx, point: impl Into<Point>) {
+        debug_assert!(
+            self.layout.is_some(),
+            "TextLayout::draw called without rebuilding layout object. Text was '{}'",
+            self.text
+                .as_ref()
+                .map(|t| t.as_str())
+                .unwrap_or("layout is missing text")
+        );
+        if let Some(layout) = self.layout.as_ref() {
+            ctx.draw_text(layout, point);
+        }
+    }
+}
+
+impl<T> std::fmt::Debug for TextLayout<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.debug_struct("TextLayout")
+            .field("font", &self.font)
+            .field("text_size_override", &self.text_size_override)
+            .field("text_color", &self.text_color)
+            .field(
+                "layout",
+                if self.layout.is_some() {
+                    &"Some"
+                } else {
+                    &"None"
+                },
+            )
+            .finish()
+    }
+}
+
+impl<T: TextStorage> Default for TextLayout<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
diff --git a/crates/masonry/src/text/mod.rs b/crates/masonry/src/text/mod.rs
new file mode 100644
index 000000000..7ca2cc16c
--- /dev/null
+++ b/crates/masonry/src/text/mod.rs
@@ -0,0 +1,20 @@
+// Copyright 2018 the Xilem Authors and the Druid Authors
+// SPDX-License-Identifier: Apache-2.0
+
+//! Editing and displaying text.
+
+// TODO
+#![allow(clippy::all)]
+
+mod attribute;
+mod backspace;
+mod editable_text;
+mod font_descriptor;
+
+mod input_component;
+mod layout;
+mod movement;
+mod rich_text;
+mod shell_text;
+mod storage;
+mod util;
diff --git a/crates/masonry/src/text/movement.rs b/crates/masonry/src/text/movement.rs
new file mode 100644
index 000000000..63c3eeda5
--- /dev/null
+++ b/crates/masonry/src/text/movement.rs
@@ -0,0 +1,193 @@
+// Copyright 2018 the Xilem Authors and the Druid Authors
+// SPDX-License-Identifier: Apache-2.0
+
+//! Text editing movements.
+
+use std::ops::Range;
+
+use unicode_segmentation::UnicodeSegmentation;
+
+use crate::kurbo::Point;
+
+use super::{
+    editable_text::EditableText,
+    layout::TextLayout,
+    shell_text::{Movement, Selection, VerticalMovement, WritingDirection},
+    storage::TextStorage,
+};
+
+/// Compute the result of a [`Movement`] on a [`Selection`].
+///
+/// returns a new selection representing the state after the movement.
+///
+/// If `modify` is true, only the 'active' edge (the `end`) of the selection
+/// should be changed; this is the case when the user moves with the shift
+/// key pressed.
+pub fn movement<T: EditableText + TextStorage>(
+    m: Movement,
+    s: Selection,
+    layout: &TextLayout<T>,
+    modify: bool,
+) -> Selection {
+    let (text, layout) = match (layout.text(), layout.layout()) {
+        (Some(text), Some(layout)) => (text, layout),
+        _ => {
+            debug_assert!(false, "movement() called before layout rebuild");
+            return s;
+        }
+    };
+    // TODO
+    let writing_direction = WritingDirection::LeftToRight;
+
+    let (offset, h_pos) = match m {
+        Movement::Grapheme(d) if d.is_upstream_for_direction(writing_direction) => {
+            if s.is_caret() || modify {
+                text.prev_grapheme_offset(s.active)
+                    .map(|off| (off, None))
+                    .unwrap_or((0, s.h_pos))
+            } else {
+                (s.min(), None)
+            }
+        }
+        Movement::Grapheme(_) => {
+            if s.is_caret() || modify {
+                text.next_grapheme_offset(s.active)
+                    .map(|off| (off, None))
+                    .unwrap_or((s.active, s.h_pos))
+            } else {
+                (s.max(), None)
+            }
+        }
+        Movement::Vertical(VerticalMovement::LineUp) => {
+            let cur_pos = layout.hit_test_text_position(s.active);
+            let h_pos = s.h_pos.unwrap_or(cur_pos.point.x);
+            if cur_pos.line == 0 {
+                (0, Some(h_pos))
+            } else {
+                let lm = layout.line_metric(cur_pos.line).unwrap();
+                let point_above = Point::new(h_pos, cur_pos.point.y - lm.height);
+                let up_pos = layout.hit_test_point(point_above);
+                if up_pos.is_inside {
+                    (up_pos.idx, Some(h_pos))
+                } else {
+                    // because we can't specify affinity, moving up when h_pos
+                    // is wider than both the current line and the previous line
+                    // can result in a cursor position at the visual start of the
+                    // current line; so we handle this as a special-case.
+                    let lm_prev = layout.line_metric(cur_pos.line.saturating_sub(1)).unwrap();
+                    let up_pos = lm_prev.end_offset - lm_prev.trailing_whitespace;
+                    (up_pos, Some(h_pos))
+                }
+            }
+        }
+        Movement::Vertical(VerticalMovement::LineDown) => {
+            let cur_pos = layout.hit_test_text_position(s.active);
+            let h_pos = s.h_pos.unwrap_or(cur_pos.point.x);
+            if cur_pos.line == layout.line_count() - 1 {
+                (text.len(), Some(h_pos))
+            } else {
+                let lm = layout.line_metric(cur_pos.line).unwrap();
+                // may not work correctly for point sizes below 1.0
+                let y_below = lm.y_offset + lm.height + 1.0;
+                let point_below = Point::new(h_pos, y_below);
+                let up_pos = layout.hit_test_point(point_below);
+                (up_pos.idx, Some(point_below.x))
+            }
+        }
+        Movement::Vertical(VerticalMovement::DocumentStart) => (0, None),
+        Movement::Vertical(VerticalMovement::DocumentEnd) => (text.len(), None),
+
+        Movement::ParagraphStart => (text.preceding_line_break(s.active), None),
+        Movement::ParagraphEnd => (text.next_line_break(s.active), None),
+
+        Movement::Line(d) => {
+            let hit = layout.hit_test_text_position(s.active);
+            let lm = layout.line_metric(hit.line).unwrap();
+            let offset = if d.is_upstream_for_direction(writing_direction) {
+                lm.start_offset
+            } else {
+                lm.end_offset - lm.trailing_whitespace
+            };
+            (offset, None)
+        }
+        Movement::Word(d) if d.is_upstream_for_direction(writing_direction) => {
+            let offset = if s.is_caret() || modify {
+                text.prev_word_offset(s.active).unwrap_or(0)
+            } else {
+                s.min()
+            };
+            (offset, None)
+        }
+        Movement::Word(_) => {
+            let offset = if s.is_caret() || modify {
+                text.next_word_offset(s.active).unwrap_or(s.active)
+            } else {
+                s.max()
+            };
+            (offset, None)
+        }
+
+        // These two are not handled; they require knowledge of the size
+        // of the viewport.
+        Movement::Vertical(VerticalMovement::PageDown)
+        | Movement::Vertical(VerticalMovement::PageUp) => (s.active, s.h_pos),
+        other => {
+            tracing::warn!("unhandled movement {:?}", other);
+            (s.anchor, s.h_pos)
+        }
+    };
+
+    let start = if modify { s.anchor } else { offset };
+    Selection::new(start, offset).with_h_pos(h_pos)
+}
+
+/// Given a position in some text, return the containing word boundaries.
+///
+/// The returned range may not necessary be a 'word'; for instance it could be
+/// the sequence of whitespace between two words.
+///
+/// If the position is on a word boundary, that will be considered the start
+/// of the range.
+///
+/// This uses Unicode word boundaries, as defined in [UAX#29].
+///
+/// [UAX#29]: http://www.unicode.org/reports/tr29/
+pub(crate) fn word_range_for_pos(text: &str, pos: usize) -> Range<usize> {
+    text.split_word_bound_indices()
+        .map(|(ix, word)| ix..(ix + word.len()))
+        .find(|range| range.contains(&pos))
+        .unwrap_or(pos..pos)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn word_range_simple() {
+        assert_eq!(word_range_for_pos("hello world", 3), 0..5);
+        assert_eq!(word_range_for_pos("hello world", 8), 6..11);
+    }
+
+    #[test]
+    fn word_range_whitespace() {
+        assert_eq!(word_range_for_pos("hello world", 5), 5..6);
+    }
+
+    #[test]
+    fn word_range_rtl() {
+        let rtl = "مرحبا بالعالم";
+        assert_eq!(word_range_for_pos(rtl, 5), 0..10);
+        assert_eq!(word_range_for_pos(rtl, 16), 11..25);
+        assert_eq!(word_range_for_pos(rtl, 10), 10..11);
+    }
+
+    #[test]
+    fn word_range_mixed() {
+        let mixed = "hello مرحبا بالعالم world";
+        assert_eq!(word_range_for_pos(mixed, 3), 0..5);
+        assert_eq!(word_range_for_pos(mixed, 8), 6..16);
+        assert_eq!(word_range_for_pos(mixed, 19), 17..31);
+        assert_eq!(word_range_for_pos(mixed, 36), 32..37);
+    }
+}
diff --git a/crates/masonry/src/text/rich_text.rs b/crates/masonry/src/text/rich_text.rs
new file mode 100644
index 000000000..44d66370d
--- /dev/null
+++ b/crates/masonry/src/text/rich_text.rs
@@ -0,0 +1,233 @@
+// Copyright 2018 the Xilem Authors and the Druid Authors
+// SPDX-License-Identifier: Apache-2.0
+
+//! Rich text with style spans.
+
+use std::ops::{Range, RangeBounds};
+use std::sync::Arc;
+
+use parley::context::RangedBuilder;
+use parley::fontique::{Style, Weight};
+use parley::style::FontFamily;
+use vello::peniko::{Brush, Color};
+
+use super::attribute::{Attribute, AttributeSpans, Link};
+use super::font_descriptor::FontDescriptor;
+use super::storage::TextStorage;
+use super::util;
+use crate::ArcStr;
+
+/// Text with optional style spans.
+#[derive(Clone, Debug)]
+pub struct RichText {
+    buffer: ArcStr,
+    attrs: Arc<AttributeSpans>,
+    links: Arc<[Link]>,
+}
+
+impl RichText {
+    /// Create a new `RichText` object with the provided text.
+    pub fn new(buffer: ArcStr) -> Self {
+        RichText::new_with_attributes(buffer, Default::default())
+    }
+
+    /// Create a new `RichText`, providing explicit attributes.
+    pub fn new_with_attributes(buffer: ArcStr, attributes: AttributeSpans) -> Self {
+        RichText {
+            buffer,
+            attrs: Arc::new(attributes),
+            links: Arc::new([]),
+        }
+    }
+
+    /// Builder-style method for adding an [`Attribute`] to a range of text.
+    ///
+    /// [`Attribute`]: enum.Attribute.html
+    pub fn with_attribute(mut self, range: impl RangeBounds<usize>, attr: Attribute) -> Self {
+        self.add_attribute(range, attr);
+        self
+    }
+
+    /// The length of the buffer, in utf8 code units.
+    pub fn len(&self) -> usize {
+        self.buffer.len()
+    }
+
+    /// Returns `true` if the underlying buffer is empty.
+    pub fn is_empty(&self) -> bool {
+        self.buffer.is_empty()
+    }
+
+    /// Add an [`Attribute`] to the provided range of text.
+    ///
+    /// [`Attribute`]: enum.Attribute.html
+    pub fn add_attribute(&mut self, range: impl RangeBounds<usize>, attr: Attribute) {
+        let range = util::resolve_range(range, self.buffer.len());
+        Arc::make_mut(&mut self.attrs).add(range, attr);
+    }
+}
+
+impl TextStorage for RichText {
+    fn as_str(&self) -> &str {
+        &self.buffer
+    }
+    fn add_attributes(
+        &self,
+        mut builder: RangedBuilder<'_, Brush, &str>,
+    ) -> RangedBuilder<'_, Brush, &str> {
+        for (range, attr) in self.attrs.to_piet_attrs() {
+            builder.push(&attr, range);
+        }
+        builder
+    }
+
+    fn links(&self) -> &[Link] {
+        &self.links
+    }
+
+    fn maybe_eq(&self, other: &Self) -> bool {
+        Arc::ptr_eq(&self.buffer, &other.buffer)
+            && Arc::ptr_eq(&self.attrs, &other.attrs)
+            && Arc::ptr_eq(&self.links, &other.links)
+    }
+}
+
+/// A builder for creating [`RichText`] objects.
+///
+/// This builder allows you to construct a [`RichText`] object by building up a sequence
+/// of styled sub-strings; first you [`push`](RichTextBuilder::push) a `&str` onto the string,
+/// and then you can optionally add styles to that text via the returned [`AttributesAdder`]
+/// object.
+///
+/// # Example
+/// ```
+/// # use masonry::text::{Attribute, RichTextBuilder};
+/// # use masonry::Color;
+/// # use masonry::piet::FontWeight;
+/// let mut builder = RichTextBuilder::new();
+/// builder.push("Hello ");
+/// builder.push("World!").weight(FontWeight::BOLD);
+///
+/// // Can also use write!
+/// write!(builder, "Here is your number: {}", 1).underline(true).text_color(Color::RED);
+///
+/// let rich_text = builder.build();
+/// ```
+///
+/// [`RichText`]: RichText
+#[derive(Default)]
+pub struct RichTextBuilder {
+    buffer: String,
+    attrs: AttributeSpans,
+    links: Vec<Link>,
+}
+
+impl RichTextBuilder {
+    /// Create a new `RichTextBuilder`.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Append a `&str` to the end of the text.
+    ///
+    /// This method returns a [`AttributesAdder`] that can be used to style the newly
+    /// added string slice.
+    pub fn push(&mut self, string: &str) -> AttributesAdder {
+        let range = self.buffer.len()..(self.buffer.len() + string.len());
+        self.buffer.push_str(string);
+        self.add_attributes_for_range(range)
+    }
+
+    /// Glue for usage of the write! macro.
+    ///
+    /// This method should generally not be invoked manually, but rather through the write! macro itself.
+    #[doc(hidden)]
+    pub fn write_fmt(&mut self, fmt: std::fmt::Arguments<'_>) -> AttributesAdder {
+        use std::fmt::Write;
+        let start = self.buffer.len();
+        self.buffer
+            .write_fmt(fmt)
+            .expect("a formatting trait implementation returned an error");
+        self.add_attributes_for_range(start..self.buffer.len())
+    }
+
+    /// Get an [`AttributesAdder`] for the given range.
+    ///
+    /// This can be used to modify styles for a given range after it has been added.
+    pub fn add_attributes_for_range(&mut self, range: impl RangeBounds<usize>) -> AttributesAdder {
+        let range = util::resolve_range(range, self.buffer.len());
+        AttributesAdder {
+            rich_text_builder: self,
+            range,
+        }
+    }
+
+    /// Build the `RichText`.
+    pub fn build(self) -> RichText {
+        RichText {
+            buffer: self.buffer.into(),
+            attrs: self.attrs.into(),
+            links: self.links.into(),
+        }
+    }
+}
+
+/// Adds Attributes to the text.
+///
+/// See also: [`RichTextBuilder`](RichTextBuilder)
+pub struct AttributesAdder<'a> {
+    rich_text_builder: &'a mut RichTextBuilder,
+    range: Range<usize>,
+}
+
+impl AttributesAdder<'_> {
+    /// Add the given attribute.
+    pub fn add_attr(&mut self, attr: Attribute) -> &mut Self {
+        self.rich_text_builder.attrs.add(self.range.clone(), attr);
+        self
+    }
+
+    /// Add a font size attribute.
+    pub fn size(&mut self, size: impl Into<f32>) -> &mut Self {
+        self.add_attr(Attribute::size(size));
+        self
+    }
+
+    /// Add a forground color attribute.
+    pub fn text_color(&mut self, color: impl Into<Color>) -> &mut Self {
+        self.add_attr(Attribute::text_color(color));
+        self
+    }
+
+    /// Add a font family attribute.
+    pub fn font_family(&mut self, family: FontFamily<'static>) -> &mut Self {
+        self.add_attr(Attribute::font_family(family));
+        self
+    }
+
+    /// Add a `FontWeight` attribute.
+    pub fn weight(&mut self, weight: Weight) -> &mut Self {
+        self.add_attr(Attribute::weight(weight));
+        self
+    }
+
+    /// Add a `FontStyle` attribute.
+    pub fn style(&mut self, style: Style) -> &mut Self {
+        self.add_attr(Attribute::style(style));
+        self
+    }
+
+    /// Add a underline attribute.
+    pub fn underline(&mut self, underline: bool) -> &mut Self {
+        self.add_attr(Attribute::underline(underline));
+        self
+    }
+
+    /// Add a `FontDescriptor` attribute.
+    pub fn font_descriptor(&mut self, font: impl Into<FontDescriptor>) -> &mut Self {
+        self.add_attr(Attribute::font_descriptor(font));
+        self
+    }
+
+    //pub fn link(&mut self, command: impl Into<Command>) -> &mut Self;
+}
diff --git a/crates/masonry/src/text/shell_text.rs b/crates/masonry/src/text/shell_text.rs
new file mode 100644
index 000000000..f60327736
--- /dev/null
+++ b/crates/masonry/src/text/shell_text.rs
@@ -0,0 +1,527 @@
+// Copyright 2018 the Xilem Authors and the Druid Authors and the Glazier Authors
+// SPDX-License-Identifier: Apache-2.0
+
+//! Types and functions for cross-platform text input.
+//!
+//! Text input is a notoriously difficult problem.  Unlike many other aspects of
+//! user interfaces, text input can not be correctly modeled using discrete
+//! events passed from the platform to the application. For example, many mobile
+//! phones implement autocorrect: when the user presses the spacebar, the
+//! platform peeks at the word directly behind the caret, and potentially
+//! replaces it if it's misspelled. This means the platform needs to know the
+//! contents of a text field. On other devices, the platform may need to draw an
+//! emoji window under the caret, or look up the on-screen locations of letters
+//! for crossing out with a stylus, both of which require fetching on-screen
+//! coordinates from the application.
+//!
+//! This is all to say: text editing is a bidirectional conversation between the
+//! application and the platform. The application, when the platform asks for
+//! it, serves up text field coordinates and content.  The platform looks at
+//! this information and combines it with input from keyboards (physical or
+//! onscreen), voice, styluses, the user's language settings, and then sends
+//! edit commands to the application.
+//!
+//! Many platforms have an additional complication: this input fusion often
+//! happens in a different process from your application. If we don't
+//! specifically account for this fact, we might get race conditions!  In the
+//! autocorrect example, if I sloppily type "meoow" and press space, the
+//! platform might issue edits to "delete backwards one word and insert meow".
+//! However, if I concurrently click somewhere else in the document to move the
+//! caret, this will replace some *other* word with "meow", and leave the
+//! "meoow" disappointingly present. To mitigate this problem, we use locks,
+//! represented by the `InputHandler` trait.
+//!
+//! ## Lifecycle of a Text Input
+//!
+//! 1. The user clicks a link or switches tabs, and the window content now
+//!    contains a new text field.  The application registers this new field by
+//!    calling `WindowHandle::add_text_field`, and gets a `TextFieldToken` that
+//!    represents this new field.
+//! 2. The user clicks on that text field, focusing it. The application lets the
+//!    platform know by calling `WindowHandle::set_focused_text_field` with that
+//!    field's `TextFieldToken`.
+//! 3. The user presses a key on the keyboard. The platform first calls
+//!    `WinHandler::key_down`. If this method returns `true`, the application
+//!    has indicated the keypress was captured, and we skip the remaining steps.
+//! 4. If `key_down` returned `false`, `druid-shell` forwards the key event to the
+//!    platform's text input system
+//! 5. The platform, in response to either this key event or some other user
+//!    action, determines it's time for some text input. It calls
+//!    `WinHandler::text_input` to acquire a lock on the text field's state.
+//!    The application returns an `InputHandler` object corresponding to the
+//!    requested text field. To prevent race conditions, your application may
+//!    not make any changes
+//!    to the text field's state until the platform drops the `InputHandler`.
+//! 6. The platform calls various `InputHandler` methods to inspect and edit the
+//!    text field's state. Later, usually within a few milliseconds, the
+//!    platform drops the `InputHandler`, allowing the application to once again
+//!    make changes to the text field's state. These commands might be "insert
+//!    `q`" for a smartphone user tapping on their virtual keyboard, or
+//!    "move the caret one word left" for a user pressing the left arrow key
+//!    while holding control.
+//! 7. Eventually, after many keypresses cause steps 3–6 to repeat, the user
+//!    unfocuses the text field. The application indicates this to the platform
+//!    by calling `set_focused_text_field`.  Note that even though focus has
+//!    shifted away from our text field, the platform may still send edits to it
+//!    by calling `WinHandler::text_input`.
+//! 8. At some point, the user clicks a link or switches a tab, and the text
+//!    field is no longer present in the window.  The application calls
+//!    `WindowHandle::remove_text_field`, and the platform may no longer call
+//!    `WinHandler::text_input` to make changes to it.
+//!
+//! The application also has a series of steps it follows if it wants to make
+//! its own changes to the text field's state:
+//!
+//! 1. The application determines it would like to make a change to the text
+//!    field; perhaps the user has scrolled and and the text field has changed
+//!    its visible location on screen, or perhaps the user has clicked to move
+//!    the caret to a new location.
+//! 2. The application first checks to see if there's an outstanding
+//!    `InputHandler` lock for this text field; if so, it waits until the last
+//!    `InputHandler` is dropped before continuing.
+//! 3. The application then makes the change to the text input. If the change
+//!    would affect state visible from an `InputHandler`, the application must
+//!    notify the platform via `WinHandler::update_text_field`.
+//!
+//! ## Supported Platforms
+//!
+//! Currently, `druid-shell` text input is fully implemented on macOS. Our goal
+//! is to have full support for all `druid-shell` targets, but for now,
+//! `InputHandler` calls are simulated from keypresses on other platforms, which
+//! doesn't allow for IME input, dead keys, etc.
+
+use std::ops::Range;
+
+/// An event representing an application-initiated change in [`InputHandler`]
+/// state.
+///
+/// When we change state that may have previously been retrieved from an
+/// [`InputHandler`], we notify the platform so that it can invalidate any
+/// data if necessary.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum Event {
+    /// Indicates the value returned by `InputHandler::selection` may have changed.
+    SelectionChanged,
+
+    /// Indicates the values returned by one or more of these methods may have changed:
+    /// - `InputHandler::hit_test_point`
+    /// - `InputHandler::line_range`
+    /// - `InputHandler::bounding_box`
+    /// - `InputHandler::slice_bounding_box`
+    LayoutChanged,
+
+    /// Indicates any value returned from any `InputHandler` method may have changed.
+    Reset,
+}
+
+/// A range of selected text, or a caret.
+///
+/// A caret is the blinking vertical bar where text is to be inserted. We
+/// represent it as a selection with zero length, where `anchor == active`.
+/// Indices are always expressed in UTF-8 bytes, and must be between 0 and the
+/// document length, inclusive.
+///
+/// As an example, if the input caret is at the start of the document `hello
+/// world`, we would expect both `anchor` and `active` to be `0`. If the user
+/// holds shift and presses the right arrow key five times, we would expect the
+/// word `hello` to be selected, the `anchor` to still be `0`, and the `active`
+/// to now be `5`.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+#[non_exhaustive]
+pub struct Selection {
+    /// The 'anchor' end of the selection.
+    ///
+    /// This is the end of the selection that stays unchanged while holding
+    /// shift and pressing the arrow keys.
+    pub anchor: usize,
+    /// The 'active' end of the selection.
+    ///
+    /// This is the end of the selection that moves while holding shift and
+    /// pressing the arrow keys.
+    pub active: usize,
+    /// The saved horizontal position, during vertical movement.
+    ///
+    /// This should not be set by the IME; it will be tracked and handled by
+    /// the text field.
+    pub h_pos: Option<f64>,
+}
+
+#[allow(clippy::len_without_is_empty)]
+impl Selection {
+    /// Create a new `Selection` with the provided `anchor` and `active` positions.
+    ///
+    /// Both positions refer to UTF-8 byte indices in some text.
+    ///
+    /// If your selection is a caret, you can use [`Selection::caret`] instead.
+    pub fn new(anchor: usize, active: usize) -> Selection {
+        Selection {
+            anchor,
+            active,
+            h_pos: None,
+        }
+    }
+
+    /// Create a new caret (zero-length selection) at the provided UTF-8 byte index.
+    ///
+    /// `index` must be a grapheme cluster boundary.
+    pub fn caret(index: usize) -> Selection {
+        Selection {
+            anchor: index,
+            active: index,
+            h_pos: None,
+        }
+    }
+
+    /// Construct a new selection from this selection, with the provided h_pos.
+    ///
+    /// # Note
+    ///
+    /// `h_pos` is used to track the *pixel* location of the cursor when moving
+    /// vertically; lines may have available cursor positions at different
+    /// positions, and arrowing down and then back up should always result
+    /// in a cursor at the original starting location; doing this correctly
+    /// requires tracking this state.
+    ///
+    /// You *probably* don't need to use this, unless you are implementing a new
+    /// text field, or otherwise implementing vertical cursor motion, in which
+    /// case you will want to set this during vertical motion if it is not
+    /// already set.
+    pub fn with_h_pos(mut self, h_pos: Option<f64>) -> Self {
+        self.h_pos = h_pos;
+        self
+    }
+
+    /// Create a new selection that is guaranteed to be valid for the provided
+    /// text.
+    #[must_use = "constrained constructs a new Selection"]
+    pub fn constrained(mut self, s: &str) -> Self {
+        let s_len = s.len();
+        self.anchor = self.anchor.min(s_len);
+        self.active = self.active.min(s_len);
+        while !s.is_char_boundary(self.anchor) {
+            self.anchor += 1;
+        }
+        while !s.is_char_boundary(self.active) {
+            self.active += 1;
+        }
+        self
+    }
+
+    /// Return the position of the upstream end of the selection.
+    ///
+    /// This is end with the lesser byte index.
+    ///
+    /// Because of bidirectional text, this is not necessarily "left".
+    pub fn min(&self) -> usize {
+        usize::min(self.anchor, self.active)
+    }
+
+    /// Return the position of the downstream end of the selection.
+    ///
+    /// This is the end with the greater byte index.
+    ///
+    /// Because of bidirectional text, this is not necessarily "right".
+    pub fn max(&self) -> usize {
+        usize::max(self.anchor, self.active)
+    }
+
+    /// The sequential range of the document represented by this selection.
+    ///
+    /// This is the range that would be replaced if text were inserted at this
+    /// selection.
+    pub fn range(&self) -> Range<usize> {
+        self.min()..self.max()
+    }
+
+    /// The length, in bytes of the selected region.
+    ///
+    /// If the selection is a caret, this is `0`.
+    pub fn len(&self) -> usize {
+        if self.anchor > self.active {
+            self.anchor - self.active
+        } else {
+            self.active - self.anchor
+        }
+    }
+
+    /// Returns `true` if the selection's length is `0`.
+    pub fn is_caret(&self) -> bool {
+        self.len() == 0
+    }
+}
+
+/// Indicates a movement that transforms a particular text position in a
+/// document.
+///
+/// These movements transform only single indices — not selections.
+///
+/// You'll note that a lot of these operations are idempotent, but you can get
+/// around this by first sending a `Grapheme` movement.  If for instance, you
+/// want a `ParagraphStart` that is not idempotent, you can first send
+/// `Movement::Grapheme(Direction::Upstream)`, and then follow it with
+/// `ParagraphStart`.
+#[non_exhaustive]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum Movement {
+    /// A movement that stops when it reaches an extended grapheme cluster boundary.
+    ///
+    /// This movement is achieved on most systems by pressing the left and right
+    /// arrow keys.  For more information on grapheme clusters, see
+    /// [Unicode Text Segmentation](https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries).
+    Grapheme(Direction),
+    /// A movement that stops when it reaches a word boundary.
+    ///
+    /// This movement is achieved on most systems by pressing the left and right
+    /// arrow keys while holding control. For more information on words, see
+    /// [Unicode Text Segmentation](https://unicode.org/reports/tr29/#Word_Boundaries).
+    Word(Direction),
+    /// A movement that stops when it reaches a soft line break.
+    ///
+    /// This movement is achieved on macOS by pressing the left and right arrow
+    /// keys while holding command.  `Line` should be idempotent: if the
+    /// position is already at the end of a soft-wrapped line, this movement
+    /// should never push it onto another soft-wrapped line.
+    ///
+    /// In order to implement this properly, your text positions should remember
+    /// their affinity.
+    Line(Direction),
+    /// An upstream movement that stops when it reaches a hard line break.
+    ///
+    /// `ParagraphStart` should be idempotent: if the position is already at the
+    /// start of a hard-wrapped line, this movement should never push it onto
+    /// the previous line.
+    ParagraphStart,
+    /// A downstream movement that stops when it reaches a hard line break.
+    ///
+    /// `ParagraphEnd` should be idempotent: if the position is already at the
+    /// end of a hard-wrapped line, this movement should never push it onto the
+    /// next line.
+    ParagraphEnd,
+    /// A vertical movement, see `VerticalMovement` for more details.
+    Vertical(VerticalMovement),
+}
+
+/// Indicates a horizontal direction in the text.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum Direction {
+    /// The direction visually to the left.
+    ///
+    /// This may be byte-wise forwards or backwards in the document, depending
+    /// on the text direction around the position being moved.
+    Left,
+    /// The direction visually to the right.
+    ///
+    /// This may be byte-wise forwards or backwards in the document, depending
+    /// on the text direction around the position being moved.
+    Right,
+    /// Byte-wise backwards in the document.
+    ///
+    /// In a left-to-right context, this value is the same as `Left`.
+    Upstream,
+    /// Byte-wise forwards in the document.
+    ///
+    /// In a left-to-right context, this value is the same as `Right`.
+    Downstream,
+}
+
+impl Direction {
+    /// Returns `true` if this direction is byte-wise backwards for
+    /// the provided [`WritingDirection`].
+    ///
+    /// The provided direction *must not be* `WritingDirection::Natural`.
+    pub fn is_upstream_for_direction(self, direction: WritingDirection) -> bool {
+        assert!(
+            !matches!(direction, WritingDirection::Natural),
+            "writing direction must be resolved"
+        );
+        match self {
+            Direction::Upstream => true,
+            Direction::Downstream => false,
+            Direction::Left => matches!(direction, WritingDirection::LeftToRight),
+            Direction::Right => matches!(direction, WritingDirection::RightToLeft),
+        }
+    }
+}
+
+/// Distinguishes between two visually distinct locations with the same byte
+/// index.
+///
+/// Sometimes, a byte location in a document has two visual locations. For
+/// example, the end of a soft-wrapped line and the start of the subsequent line
+/// have different visual locations (and we want to be able to place an input
+/// caret in either place!) but the same byte-wise location. This also shows up
+/// in bidirectional text contexts. Affinity allows us to disambiguate between
+/// these two visual locations.
+pub enum Affinity {
+    Upstream,
+    Downstream,
+}
+
+/// Indicates a horizontal direction for writing text.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum WritingDirection {
+    LeftToRight,
+    RightToLeft,
+    /// Indicates writing direction should be automatically detected based on
+    /// the text contents.
+    Natural,
+}
+
+/// Indicates a vertical movement in a text document.
+#[non_exhaustive]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum VerticalMovement {
+    LineUp,
+    LineDown,
+    PageUp,
+    PageDown,
+    DocumentStart,
+    DocumentEnd,
+}
+
+/// A special text editing command sent from the platform to the application.
+#[non_exhaustive]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum Action {
+    /// Moves the selection.
+    ///
+    /// Before moving, if the active and the anchor of the selection are not at
+    /// the same position (it's a non-caret selection), then:
+    ///
+    /// 1. First set both active and anchor to the same position: the
+    ///    selection's upstream index if `Movement` is an upstream movement, or
+    ///    the downstream index if `Movement` is a downstream movement.
+    ///
+    /// 2. If `Movement` is `Grapheme`, then stop. Otherwise, apply the
+    ///    `Movement` as per the usual rules.
+    Move(Movement),
+
+    /// Moves just the selection's active edge.
+    ///
+    /// Equivalent to holding shift while performing movements or clicks on most
+    /// operating systems.
+    MoveSelecting(Movement),
+
+    /// Select the entire document.
+    SelectAll,
+
+    /// Expands the selection to the entire soft-wrapped line.
+    ///
+    /// If multiple lines are already selected, expands the selection to
+    /// encompass all soft-wrapped lines that intersected with the prior
+    /// selection.  If the selection is a caret is on a soft line break, uses
+    /// the affinity of the caret to determine which of the two lines to select.
+    /// `SelectLine` should be idempotent: it should never expand onto adjacent
+    /// lines.
+    SelectLine,
+
+    /// Expands the selection to the entire hard-wrapped line.
+    ///
+    /// If multiple lines are already selected, expands the selection to
+    /// encompass all hard-wrapped lines that intersected with the prior
+    /// selection.  `SelectParagraph` should be idempotent: it should never
+    /// expand onto adjacent lines.
+    SelectParagraph,
+
+    /// Expands the selection to the entire word.
+    ///
+    /// If multiple words are already selected, expands the selection to
+    /// encompass all words that intersected with the prior selection.  If the
+    /// selection is a caret is on a word boundary, selects the word downstream
+    /// of the caret.  `SelectWord` should be idempotent: it should never expand
+    /// onto adjacent words.
+    ///
+    /// For more information on what these so-called "words" are, see
+    /// [Unicode Text Segmentation](https://unicode.org/reports/tr29/#Word_Boundaries).
+    SelectWord,
+
+    /// Deletes some text.
+    ///
+    /// If some text is already selected, `Movement` is ignored, and the
+    /// selection is deleted.  If the selection's anchor is the same as the
+    /// active, then first apply `MoveSelecting(Movement)` and then delete the
+    /// resulting selection.
+    Delete(Movement),
+
+    /// Delete backwards, potentially breaking graphemes.
+    ///
+    /// A special kind of backspace that, instead of deleting the entire
+    /// grapheme upstream of the caret, may in some cases and character sets
+    /// delete a subset of that grapheme's code points.
+    DecomposingBackspace,
+
+    /// Maps the characters in the selection to uppercase.
+    ///
+    /// For more information on case mapping, see the
+    /// [Unicode Case Mapping FAQ](https://unicode.org/faq/casemap_charprop.html#7)
+    UppercaseSelection,
+
+    /// Maps the characters in the selection to lowercase.
+    ///
+    /// For more information on case mapping, see the
+    /// [Unicode Case Mapping FAQ](https://unicode.org/faq/casemap_charprop.html#7)
+    LowercaseSelection,
+
+    /// Maps the characters in the selection to titlecase.
+    ///
+    /// When calculating whether a character is at the beginning of a word, you
+    /// may have to peek outside the selection to other characters in the document.
+    ///
+    /// For more information on case mapping, see the
+    /// [Unicode Case Mapping FAQ](https://unicode.org/faq/casemap_charprop.html#7)
+    TitlecaseSelection,
+
+    /// Inserts a newline character into the document.
+    InsertNewLine {
+        /// If `true`, then always insert a newline, even if normally you
+        /// would run a keyboard shortcut attached to the return key, like
+        /// sending a message or activating autocomplete.
+        ///
+        /// On macOS, this is triggered by pressing option-return.
+        ignore_hotkey: bool,
+        /// Either `U+000A`, `U+2029`, or `U+2028`. For instance, on macOS, control-enter inserts `U+2028`.
+        //FIXME: what about windows?
+        newline_type: char,
+    },
+
+    /// Inserts a tab character into the document.
+    InsertTab {
+        /// If `true`, then always insert a tab, even if normally you would run
+        /// a keyboard shortcut attached to the return key, like indenting a
+        /// line or activating autocomplete.
+        ///
+        /// On macOS, this is triggered by pressing option-tab.
+        ignore_hotkey: bool,
+    },
+
+    /// Indicates the reverse of inserting tab; corresponds to shift-tab on most
+    /// operating systems.
+    InsertBacktab,
+
+    InsertSingleQuoteIgnoringSmartQuotes,
+    InsertDoubleQuoteIgnoringSmartQuotes,
+
+    /// Scrolls the text field without modifying the selection.
+    Scroll(VerticalMovement),
+
+    /// Centers the selection vertically in the text field.
+    ///
+    /// The average of the anchor's y and the active's y should be exactly
+    /// halfway down the field.  If the selection is taller than the text
+    /// field's visible height, then instead scrolls the minimum distance such
+    /// that the text field is completely vertically filled by the selection.
+    ScrollToSelection,
+
+    /// Sets the writing direction of the selected text or caret.
+    SetSelectionWritingDirection(WritingDirection),
+
+    /// Sets the writing direction of all paragraphs that partially or fully
+    /// intersect with the selection or caret.
+    SetParagraphWritingDirection(WritingDirection),
+
+    /// Cancels the current window or operation.
+    ///
+    /// Triggered on most operating systems with escape.
+    Cancel,
+}
diff --git a/crates/masonry/src/text/storage.rs b/crates/masonry/src/text/storage.rs
new file mode 100644
index 000000000..9bb3039e8
--- /dev/null
+++ b/crates/masonry/src/text/storage.rs
@@ -0,0 +1,74 @@
+// Copyright 2018 the Xilem Authors and the Druid Authors
+// SPDX-License-Identifier: Apache-2.0
+
+//! Storing text.
+
+use std::{ops::Deref, sync::Arc};
+
+use parley::context::RangedBuilder;
+use vello::peniko::Brush;
+
+use super::attribute::Link;
+
+/// A type that represents text that can be displayed.
+pub trait TextStorage: Clone {
+    fn as_str(&self) -> &str;
+    /// If this TextStorage object manages style spans, it should implement
+    /// this method and update the provided builder with its spans, as required.
+    #[allow(unused_variables)]
+    fn add_attributes(&self, builder: RangedBuilder<Brush, &str>) -> RangedBuilder<Brush, &str> {
+        builder
+    }
+
+    /// Any additional [`Link`] attributes on this text.
+    ///
+    /// If this `TextStorage` object manages link attributes, it should implement this
+    /// method and return any attached [`Link`]s.
+    ///
+    /// Unlike other attributes, links are managed in Masonry, not in [`piet`]; as such they
+    /// require a separate API.
+    ///
+    /// [`Link`]: super::attribute::Link
+    /// [`piet`]: https://docs.rs/piet
+    fn links(&self) -> &[Link] {
+        &[]
+    }
+
+    /// Determines quickly whether two text objects have the same content.
+    ///
+    /// To allow for faster checks, this method is allowed to return false negatives.
+    fn maybe_eq(&self, other: &Self) -> bool;
+}
+
+/// A reference counted string slice.
+///
+/// This is a data-friendly way to represent strings in Masonry. Unlike `String`
+/// it cannot be mutated, but unlike `String` it can be cheaply cloned.
+pub type ArcStr = Arc<str>;
+
+impl TextStorage for ArcStr {
+    fn as_str(&self) -> &str {
+        self.deref()
+    }
+    fn maybe_eq(&self, other: &Self) -> bool {
+        self == other
+    }
+}
+
+impl TextStorage for String {
+    fn as_str(&self) -> &str {
+        self.deref()
+    }
+    fn maybe_eq(&self, other: &Self) -> bool {
+        self == other
+    }
+}
+
+impl TextStorage for Arc<String> {
+    fn as_str(&self) -> &str {
+        self.deref()
+    }
+    fn maybe_eq(&self, other: &Self) -> bool {
+        self == other
+    }
+}
diff --git a/crates/masonry/src/text/util.rs b/crates/masonry/src/text/util.rs
new file mode 100644
index 000000000..f12784acb
--- /dev/null
+++ b/crates/masonry/src/text/util.rs
@@ -0,0 +1,21 @@
+// Copyright 2018 the Xilem Authors and the Druid Authors
+// SPDX-License-Identifier: Apache-2.0
+
+use std::ops::{Bound, Range, RangeBounds};
+
+/// Resolves a `RangeBounds` into a range in the range 0..len.
+pub fn resolve_range(range: impl RangeBounds<usize>, len: usize) -> Range<usize> {
+    let start = match range.start_bound() {
+        Bound::Unbounded => 0,
+        Bound::Included(n) => *n,
+        Bound::Excluded(n) => *n + 1,
+    };
+
+    let end = match range.end_bound() {
+        Bound::Unbounded => len,
+        Bound::Included(n) => *n + 1,
+        Bound::Excluded(n) => *n,
+    };
+
+    start.min(len)..end.min(len)
+}
diff --git a/crates/masonry/src/text2/edit.rs b/crates/masonry/src/text2/edit.rs
new file mode 100644
index 000000000..8a356e8e4
--- /dev/null
+++ b/crates/masonry/src/text2/edit.rs
@@ -0,0 +1,193 @@
+// Copyright 2018 the Xilem Authors and the Druid Authors
+// SPDX-License-Identifier: Apache-2.0
+
+use std::ops::{Deref, DerefMut, Range};
+
+use kurbo::Point;
+use parley::FontContext;
+use vello::Scene;
+use winit::{
+    event::MouseButton,
+    keyboard::{Key, NamedKey},
+};
+
+use crate::{event::PointerState, Handled, TextEvent};
+
+use super::{
+    selection::{Affinity, Selection},
+    Selectable, TextWithSelection,
+};
+
+/// Text which can be edited
+pub trait EditableText: Selectable {
+    /// Replace range with new text.
+    /// Can panic if supplied an invalid range.
+    // TODO: make this generic over Self
+    fn edit(&mut self, range: Range<usize>, new: impl Into<String>);
+    /// Create a value of this struct
+    fn from_str(s: &str) -> Self;
+}
+
+impl EditableText for String {
+    fn edit(&mut self, range: Range<usize>, new: impl Into<String>) {
+        self.replace_range(range, &new.into());
+    }
+    fn from_str(s: &str) -> Self {
+        s.to_string()
+    }
+}
+
+// TODO: What advantage does this actually have?
+// impl EditableText for Arc<String> {
+//     fn edit(&mut self, range: Range<usize>, new: impl Into<String>) {
+//         let new = new.into();
+//         if !range.is_empty() || !new.is_empty() {
+//             Arc::make_mut(self).edit(range, new)
+//         }
+//     }
+//     fn from_str(s: &str) -> Self {
+//         Arc::new(s.to_owned())
+//     }
+// }
+
+/// A region of text which can support editing operations
+pub struct TextEditor<T: EditableText> {
+    selection: TextWithSelection<T>,
+    /// The range of the preedit region in the text
+    /// This is currently unused
+    _preedit_range: Option<Range<usize>>,
+}
+
+impl<T: EditableText> TextEditor<T> {
+    pub fn new(text: T, text_size: f32) -> Self {
+        Self {
+            selection: TextWithSelection::new(text, text_size),
+            _preedit_range: None,
+        }
+    }
+
+    pub fn rebuild(&mut self, fcx: &mut FontContext) {
+        // TODO: Add the pre-edit range as an underlined region in the text attributes
+        self.selection.rebuild(fcx);
+    }
+
+    pub fn draw(&mut self, scene: &mut Scene, point: impl Into<Point>) {
+        self.selection.draw(scene, point);
+    }
+
+    pub fn pointer_down(
+        &mut self,
+        origin: Point,
+        state: &PointerState,
+        button: MouseButton,
+    ) -> bool {
+        // TODO: If we have a selection and we're hovering over it,
+        // implement (optional?) click and drag
+        self.selection.pointer_down(origin, state, button)
+    }
+
+    pub fn text_event(&mut self, event: &TextEvent) -> Handled {
+        let inner_handled = self.selection.text_event(event);
+        if inner_handled.is_handled() {
+            return inner_handled;
+        }
+        match event {
+            TextEvent::KeyboardKey(event, mods) if event.state.is_pressed() => {
+                // We don't input actual text when these keys are pressed
+                if !(mods.control_key() || mods.alt_key() || mods.super_key()) {
+                    match &event.logical_key {
+                        Key::Named(NamedKey::Backspace) => {
+                            eprintln!("Got backspace, not yet handled");
+                            Handled::No
+                        }
+                        Key::Named(NamedKey::Space) => {
+                            if let Some(selection) = self.selection.selection {
+                                // TODO: We know this is not the fullest model of copy-paste, and that we should work with the inner text
+                                // e.g. to put HTML code if supported by the rich text kind
+                                let c = ' ';
+                                self.text_mut().edit(selection.range(), c);
+                                self.selection.selection = Some(Selection::caret(
+                                    selection.min() + c.len_utf8(),
+                                    // We have just added this character, so we are "affined" with it
+                                    Affinity::Downstream,
+                                ));
+                                Handled::Yes
+                            } else {
+                                debug_panic!("Got text input event whilst not focused");
+                                Handled::No
+                            }
+                        }
+                        Key::Named(_) => Handled::No,
+                        Key::Character(c) => {
+                            if let Some(selection) = self.selection.selection {
+                                // TODO: We know this is not the fullest model of copy-paste, and that we should work with the inner text
+                                // e.g. to put HTML code if supported by the rich text kind
+                                self.text_mut().edit(selection.range(), &**c);
+                                self.selection.selection = Some(Selection::caret(
+                                    selection.min() + c.len(),
+                                    // We have just added this character, so we are "affined" with it
+                                    Affinity::Downstream,
+                                ));
+                                Handled::Yes
+                            } else {
+                                debug_panic!("Got text input event whilst not focused");
+                                Handled::No
+                            }
+                        }
+                        Key::Unidentified(_) => Handled::No,
+                        Key::Dead(d) => {
+                            eprintln!("Got dead key {d:?}. Will handle");
+                            Handled::No
+                        }
+                    }
+                } else {
+                    Handled::No
+                }
+            }
+            TextEvent::KeyboardKey(_, _) => Handled::No,
+            TextEvent::Ime(_) => {
+                eprintln!(
+                    "Got IME event in Textbox. We are planning on supporting this, but do not yet"
+                );
+                Handled::No
+            }
+            TextEvent::ModifierChange(_) => Handled::No,
+            TextEvent::FocusChange(_) => Handled::No,
+        }
+    }
+}
+
+impl<T: EditableText> Deref for TextEditor<T> {
+    type Target = TextWithSelection<T>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.selection
+    }
+}
+
+// TODO: Being able to call `Self::Target::rebuild` (and `draw`) isn't great.
+impl<T: EditableText> DerefMut for TextEditor<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.selection
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::EditableText;
+
+    // #[test]
+    // fn arcstring_empty_edit() {
+    //     let a = Arc::new("hello".to_owned());
+    //     let mut b = a.clone();
+    //     b.edit(5..5, "");
+    //     assert!(Arc::ptr_eq(&a, &b));
+    // }
+
+    #[test]
+    fn replace() {
+        let mut a = String::from("hello world");
+        a.edit(1..9, "era");
+        assert_eq!("herald", a);
+    }
+}
diff --git a/crates/masonry/src/text2/layout.rs b/crates/masonry/src/text2/layout.rs
new file mode 100644
index 000000000..6d8d8138c
--- /dev/null
+++ b/crates/masonry/src/text2/layout.rs
@@ -0,0 +1,512 @@
+// Copyright 2018 the Xilem Authors and the Druid Authors
+// SPDX-License-Identifier: Apache-2.0
+
+//! A type for laying out, drawing, and interacting with text.
+
+use std::rc::Rc;
+
+use kurbo::{Affine, Line, Point, Rect, Size};
+use parley::context::RangedBuilder;
+use parley::fontique::{Style, Weight};
+use parley::layout::{Alignment, Cursor};
+use parley::style::{Brush as BrushTrait, FontFamily, FontStack, GenericFamily, StyleProperty};
+use parley::{FontContext, Layout, LayoutContext};
+use vello::peniko::{self, Color, Gradient};
+use vello::Scene;
+
+use super::{Link, TextStorage};
+
+/// A component for displaying text on screen.
+///
+/// This is a type intended to be used by other widgets that display text.
+/// It allows for the text itself as well as font and other styling information
+/// to be set and modified. It wraps an inner layout object, and handles
+/// invalidating and rebuilding it as required.
+///
+/// This object is not valid until the [`rebuild_if_needed`] method has been
+/// called. You should generally do this in your widget's [`layout`] method.
+/// Additionally, you should call [`needs_rebuild_after_update`]
+/// as part of your widget's [`update`] method; if this returns `true`, you will need
+/// to call [`rebuild_if_needed`] again, generally by scheduling another [`layout`]
+/// pass.
+///
+/// [`layout`]: trait.Widget.html#tymethod.layout
+/// [`update`]: trait.Widget.html#tymethod.update
+/// [`needs_rebuild_after_update`]: #method.needs_rebuild_after_update
+/// [`rebuild_if_needed`]: #method.rebuild_if_needed
+///
+/// TODO: Update docs to mentionParley
+#[derive(Clone)]
+pub struct TextLayout<T> {
+    text: T,
+    // TODO: Find a way to let this use borrowed data
+    scale: f32,
+
+    brush: TextBrush,
+    font: FontStack<'static>,
+    text_size: f32,
+    weight: Weight,
+    style: Style,
+
+    alignment: Alignment,
+    max_advance: Option<f32>,
+
+    links: Rc<[(Rect, usize)]>,
+
+    needs_layout: bool,
+    needs_line_breaks: bool,
+    layout: Layout<TextBrush>,
+    layout_context: LayoutContext<TextBrush>,
+    scratch_scene: Scene,
+}
+
+/// A custom brush for `Parley`, enabling using Parley to pass-through
+/// which glyphs are selected/highlighted
+#[derive(Clone, Debug, PartialEq)]
+pub enum TextBrush {
+    Normal(peniko::Brush),
+    Highlight {
+        text: peniko::Brush,
+        fill: peniko::Brush,
+    },
+}
+
+impl BrushTrait for TextBrush {}
+
+impl From<peniko::Brush> for TextBrush {
+    fn from(value: peniko::Brush) -> Self {
+        Self::Normal(value)
+    }
+}
+
+impl From<Gradient> for TextBrush {
+    fn from(value: Gradient) -> Self {
+        Self::Normal(value.into())
+    }
+}
+
+impl From<Color> for TextBrush {
+    fn from(value: Color) -> Self {
+        Self::Normal(value.into())
+    }
+}
+
+// Parley requires their Brush implementations to implement Default
+impl Default for TextBrush {
+    fn default() -> Self {
+        Self::Normal(Default::default())
+    }
+}
+
+/// Metrics describing the layout text.
+#[derive(Debug, Clone, Copy, Default)]
+pub struct LayoutMetrics {
+    /// The nominal size of the layout.
+    pub size: Size,
+    /// The distance from the nominal top of the layout to the first baseline.
+    pub first_baseline: f32,
+    /// The width of the layout, inclusive of trailing whitespace.
+    pub trailing_whitespace_width: f32,
+    //TODO: add inking_rect
+}
+
+impl<T> TextLayout<T> {
+    /// Create a new `TextLayout` object.
+    pub fn new(text: T, text_size: f32) -> Self {
+        TextLayout {
+            text,
+            scale: 1.0,
+
+            brush: crate::theme::TEXT_COLOR.into(),
+            font: FontStack::Single(FontFamily::Generic(GenericFamily::SansSerif)),
+            text_size,
+            weight: Weight::NORMAL,
+            style: Style::Normal,
+
+            max_advance: None,
+            alignment: Default::default(),
+
+            links: Rc::new([]),
+
+            needs_layout: true,
+            needs_line_breaks: true,
+            layout: Layout::new(),
+            layout_context: LayoutContext::new(),
+            scratch_scene: Scene::new(),
+        }
+    }
+
+    /// Mark that the inner layout needs to be updated.
+    ///
+    /// This should be used if your `T` has interior mutability
+    pub fn invalidate(&mut self) {
+        self.needs_layout = true;
+        self.needs_line_breaks = true;
+    }
+
+    /// Set the scaling factor
+    pub fn set_scale(&mut self, scale: f32) {
+        if scale != self.scale {
+            self.scale = scale;
+            self.invalidate();
+        }
+    }
+
+    /// Set the default brush used for the layout.
+    ///
+    /// This is the non-layout impacting styling (primarily colour)
+    /// used when displaying the text
+    #[doc(alias = "set_color")]
+    pub fn set_brush(&mut self, brush: impl Into<TextBrush>) {
+        let brush = brush.into();
+        if brush != self.brush {
+            self.brush = brush;
+            self.invalidate();
+        }
+    }
+
+    /// Set the default font stack.
+    pub fn set_font(&mut self, font: FontStack<'static>) {
+        if font != self.font {
+            self.font = font;
+            self.invalidate();
+        }
+    }
+
+    /// Set the font size.
+    pub fn set_text_size(&mut self, size: f32) {
+        if size != self.text_size {
+            self.text_size = size;
+            self.invalidate();
+        }
+    }
+
+    /// Set the font weight.
+    pub fn set_weight(&mut self, weight: Weight) {
+        if weight != self.weight {
+            self.weight = weight;
+            self.invalidate();
+        }
+    }
+
+    /// Set the font style.
+    pub fn set_style(&mut self, style: Style) {
+        if style != self.style {
+            self.style = style;
+            self.invalidate();
+        }
+    }
+
+    /// Set the [`Alignment`] for this layout.
+    pub fn set_text_alignment(&mut self, alignment: Alignment) {
+        if self.alignment != alignment {
+            self.alignment = alignment;
+            self.invalidate();
+        }
+    }
+
+    /// Set the width at which to wrap words.
+    ///
+    /// You may pass `None` to disable word wrapping
+    /// (the default behaviour).
+    pub fn set_max_advance(&mut self, max_advance: Option<f32>) {
+        let max_advance = max_advance.map(|it| it.max(0.0));
+        if self.max_advance.is_some() != max_advance.is_some()
+            || self
+                .max_advance
+                .zip(max_advance)
+                // 1e-4 is an arbitrary small-enough value that we don't care to rewrap
+                .map(|(old, new)| (old - new).abs() >= 1e-4)
+                .unwrap_or(false)
+        {
+            self.max_advance = max_advance;
+            self.needs_line_breaks = true;
+        }
+    }
+
+    /// Returns `true` if this layout needs to be rebuilt.
+    ///
+    /// This happens (for instance) after style attributes are modified.
+    ///
+    /// This does not account for things like the text changing, handling that
+    /// is the responsibility of the user.
+    pub fn needs_rebuild(&self) -> bool {
+        self.needs_layout || self.needs_line_breaks
+    }
+
+    // TODO: What are the valid use cases for this, where we shouldn't use a run-specific check instead?
+    // /// Returns `true` if this layout's text appears to be right-to-left.
+    // ///
+    // /// See [`piet::util::first_strong_rtl`] for more information.
+    // ///
+    // /// [`piet::util::first_strong_rtl`]: crate::piet::util::first_strong_rtl
+    // pub fn text_is_rtl(&self) -> bool {
+    //     self.text_is_rtl
+    // }
+}
+
+impl<T: TextStorage> TextLayout<T> {
+    #[track_caller]
+    fn assert_rebuilt(&self, method: &str) {
+        if self.needs_layout || self.needs_line_breaks {
+            debug_panic!(
+                "TextLayout::{method} called without rebuilding layout object. Text was '{}'",
+                self.text.as_str().chars().take(250).collect::<String>()
+            );
+        }
+    }
+
+    /// Set the text to display.
+    pub fn set_text(&mut self, text: T) {
+        if !self.text.maybe_eq(&text) {
+            self.text = text;
+            self.invalidate();
+        }
+    }
+
+    /// Returns the [`TextStorage`] backing this layout, if it exists.
+    pub fn text(&self) -> &T {
+        &self.text
+    }
+
+    /// Returns the [`TextStorage`] backing this layout, if it exists.
+    ///
+    /// Invalidates the layout and so should only be used when definitely applying an edit
+    pub fn text_mut(&mut self) -> &mut T {
+        self.invalidate();
+        &mut self.text
+    }
+
+    /// Returns the inner Parley [`Layout`] value.
+    pub fn layout(&self) -> &Layout<TextBrush> {
+        self.assert_rebuilt("layout");
+        &self.layout
+    }
+
+    /// The size of the laid-out text, excluding any trailing whitespace.
+    ///
+    /// This is not meaningful until [`Self::rebuild`] has been called.
+    pub fn size(&self) -> Size {
+        self.assert_rebuilt("size");
+        Size::new(self.layout.width().into(), self.layout.height().into())
+    }
+
+    /// The size of the laid-out text, including any trailing whitespace.
+    ///
+    /// This is not meaningful until [`Self::rebuild`] has been called.
+    pub fn full_size(&self) -> Size {
+        self.assert_rebuilt("full_size");
+        Size::new(self.layout.full_width().into(), self.layout.height().into())
+    }
+
+    /// Return the text's [`LayoutMetrics`].
+    ///
+    /// This is not meaningful until [`Self::rebuild`] has been called.
+    pub fn layout_metrics(&self) -> LayoutMetrics {
+        self.assert_rebuilt("layout_metrics");
+
+        let first_baseline = self.layout.get(0).unwrap().metrics().baseline;
+        let size = Size::new(self.layout.width().into(), self.layout.height().into());
+        LayoutMetrics {
+            size,
+            first_baseline,
+            trailing_whitespace_width: self.layout.full_width(),
+        }
+    }
+
+    /// For a given `Point` (relative to this object's origin), returns index
+    /// into the underlying text of the nearest grapheme boundary.
+    ///
+    /// This is not meaningful until [`Self::rebuild`] has been called.
+    pub fn cursor_for_point(&self, point: Point) -> Cursor {
+        self.assert_rebuilt("text_position_for_point");
+
+        // TODO: This is a mostly good first pass, but doesn't handle cursor positions in
+        // grapheme clusters within a parley cluster.
+        // We can also try
+        Cursor::from_point(&self.layout, point.x as f32, point.y as f32)
+    }
+
+    /// Given the utf-8 position of a character boundary in the underlying text,
+    /// return the `Point` (relative to this object's origin) representing the
+    /// boundary of the containing grapheme.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `text_pos` is not a character boundary.
+    ///
+    /// This is not meaningful until [`Self::rebuild`] has been called.
+    pub fn cursor_for_text_position(&self, text_pos: usize) -> Cursor {
+        self.assert_rebuilt("cursor_for_text_position");
+
+        // TODO: As a reminder, `is_leading` is not very useful to us; we don't know this ahead of time
+        // We're going to need to do quite a bit of remedial work on these
+        // e.g. to handle a inside a ligature made of multiple (unicode) grapheme clusters
+        // https://raphlinus.github.io/text/2020/10/26/text-layout.html#shaping-cluster
+        // But we're choosing to defer this work
+        // This also needs to handle affinity.
+        Cursor::from_position(&self.layout, text_pos, true)
+    }
+
+    /// Given the utf-8 position of a character boundary in the underlying text,
+    /// return the `Point` (relative to this object's origin) representing the
+    /// boundary of the containing grapheme.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `text_pos` is not a character boundary.
+    ///
+    /// This is not meaningful until [`Self::rebuild`] has been called.
+    pub fn point_for_text_position(&self, text_pos: usize) -> Point {
+        let cursor = self.cursor_for_text_position(text_pos);
+        Point::new(
+            cursor.advance as f64,
+            (cursor.baseline + cursor.offset) as f64,
+        )
+    }
+
+    // TODO: needed for text selection
+    // /// Given a utf-8 range in the underlying text, return a `Vec` of `Rect`s
+    // /// representing the nominal bounding boxes of the text in that range.
+    // ///
+    // /// # Panics
+    // ///
+    // /// Panics if the range start or end is not a character boundary.
+    // pub fn rects_for_range(&self, range: Range<usize>) -> Vec<Rect> {
+    //     self.layout.rects_for_range(range)
+    // }
+
+    /// Given the utf-8 position of a character boundary in the underlying text,
+    /// return a `Line` suitable for drawing a vertical cursor at that boundary.
+    ///
+    /// This is not meaningful until [`Self::rebuild`] has been called.
+    // TODO: This is too simplistic. See https://raphlinus.github.io/text/2020/10/26/text-layout.html#shaping-cluster
+    // for example. This would break in a `fi` ligature
+    pub fn cursor_line_for_text_position(&self, text_pos: usize) -> Line {
+        let from_position = self.cursor_for_text_position(text_pos);
+
+        let line = from_position.path.line(&self.layout).unwrap();
+        let line_metrics = line.metrics();
+
+        let baseline = line_metrics.baseline + line_metrics.descent;
+        let p1 = (from_position.offset as f64, baseline as f64);
+        let p2 = (
+            from_position.offset as f64,
+            (baseline - line_metrics.size()) as f64,
+        );
+        Line::new(p1, p2)
+    }
+
+    /// Returns the [`Link`] at the provided point (relative to the layout's origin) if one exists.
+    ///
+    /// This can be used both for hit-testing (deciding whether to change the mouse cursor,
+    /// or performing some other action when hovering) as well as for retrieving a [`Link`]
+    /// on click.
+    ///
+    /// [`Link`]: super::attribute::Link
+    pub fn link_for_pos(&self, pos: Point) -> Option<&Link> {
+        let (_, i) = self
+            .links
+            .iter()
+            .rfind(|(hit_box, _)| hit_box.contains(pos))?;
+
+        self.text.links().get(*i)
+    }
+
+    /// Rebuild the inner layout as needed.
+    ///
+    /// This `TextLayout` object manages a lower-level layout object that may
+    /// need to be rebuilt in response to changes to the text or attributes
+    /// like the font.
+    ///
+    /// This method should be called whenever any of these things may have changed.
+    /// A simple way to ensure this is correct is to always call this method
+    /// as part of your widget's [`layout`][crate::Widget::layout] method.
+    pub fn rebuild(&mut self, fcx: &mut FontContext) {
+        self.rebuild_with_attributes(fcx, |builder| builder);
+    }
+
+    /// Rebuild the inner layout as needed, adding attributes to the underlying layout.
+    ///
+    /// See [`Self::rebuild`] for more information
+    pub fn rebuild_with_attributes(
+        &mut self,
+        fcx: &mut FontContext,
+        attributes: impl for<'b> FnOnce(
+            RangedBuilder<'b, TextBrush, &'b str>,
+        ) -> RangedBuilder<'b, TextBrush, &'b str>,
+    ) {
+        if self.needs_layout {
+            self.needs_layout = false;
+
+            let mut builder =
+                self.layout_context
+                    .ranged_builder(fcx, self.text.as_str(), self.scale);
+            builder.push_default(&StyleProperty::Brush(self.brush.clone()));
+            builder.push_default(&StyleProperty::FontSize(self.text_size));
+            builder.push_default(&StyleProperty::FontStack(self.font));
+            builder.push_default(&StyleProperty::FontWeight(self.weight));
+            builder.push_default(&StyleProperty::FontStyle(self.style));
+            // For more advanced features (e.g. variable font axes), these can be set in add_attributes
+
+            let builder = self.text.add_attributes(builder);
+            let mut builder = attributes(builder);
+            builder.build_into(&mut self.layout);
+
+            self.needs_line_breaks = true;
+        }
+        if self.needs_line_breaks {
+            self.needs_line_breaks = false;
+            self.layout
+                .break_all_lines(self.max_advance, self.alignment);
+
+            // TODO:
+            // self.links = text
+            //     .links()
+            // ...
+        }
+    }
+
+    /// Draw the layout at the provided `Point`.
+    ///
+    /// The origin of the layout is the top-left corner.
+    ///
+    /// You must call [`Self::rebuild`] at some point before you first
+    /// call this method.
+    pub fn draw(&mut self, scene: &mut Scene, point: impl Into<Point>) {
+        self.assert_rebuilt("draw");
+        // TODO: This translation doesn't seem great
+        let p: Point = point.into();
+        crate::text_helpers::render_text(
+            scene,
+            &mut self.scratch_scene,
+            Affine::translate((p.x, p.y)),
+            &self.layout,
+        );
+    }
+}
+
+impl<T: TextStorage> std::fmt::Debug for TextLayout<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.debug_struct("TextLayout")
+            .field("text", &self.text.as_str().len())
+            .field("scale", &self.scale)
+            .field("brush", &self.brush)
+            .field("font", &self.font)
+            .field("text_size", &self.text_size)
+            .field("weight", &self.weight)
+            .field("style", &self.style)
+            .field("alignment", &self.alignment)
+            .field("wrap_width", &self.max_advance)
+            .field("outdated?", &self.needs_rebuild())
+            .field("width", &self.layout.width())
+            .field("height", &self.layout.height())
+            .finish()
+    }
+}
+
+impl<T: TextStorage + Default> Default for TextLayout<T> {
+    fn default() -> Self {
+        Self::new(Default::default(), crate::theme::TEXT_SIZE_NORMAL as f32)
+    }
+}
diff --git a/crates/masonry/src/text2/mod.rs b/crates/masonry/src/text2/mod.rs
new file mode 100644
index 000000000..e0ff00e70
--- /dev/null
+++ b/crates/masonry/src/text2/mod.rs
@@ -0,0 +1,27 @@
+// Copyright 2018 the Xilem Authors and the Druid Authors
+// SPDX-License-Identifier: Apache-2.0
+
+//! Support for text display and rendering
+//!
+//! There are three kinds of text commonly needed:
+//!  1) Entirely display text (e.g. a button)
+//!  2) Selectable text (e.g. a paragraph of content)
+//!  3) Editable text (e.g. a search bar)
+//!
+//! All of these have the same set of global styling options, and can contain rich text
+
+mod store;
+pub use store::{Link, TextStorage};
+
+mod layout;
+pub use layout::{LayoutMetrics, TextBrush, TextLayout};
+
+mod selection;
+pub use selection::{
+    len_utf8_from_first_byte, EditableTextCursor, Selectable, StringCursor, TextWithSelection,
+};
+
+// mod movement;
+
+mod edit;
+pub use edit::{EditableText, TextEditor};
diff --git a/crates/masonry/src/text2/movement.rs b/crates/masonry/src/text2/movement.rs
new file mode 100644
index 000000000..753e997c8
--- /dev/null
+++ b/crates/masonry/src/text2/movement.rs
@@ -0,0 +1,357 @@
+// Copyright 2018 the Xilem Authors and the Druid Authors
+// SPDX-License-Identifier: Apache-2.0
+
+//! Text editing movements.
+
+use std::ops::Range;
+
+use unicode_segmentation::UnicodeSegmentation;
+
+use crate::kurbo::Point;
+
+use super::{layout::TextLayout, Selectable, TextStorage};
+
+/// Compute the result of a [`Movement`] on a [`Selection`].
+///
+/// returns a new selection representing the state after the movement.
+///
+/// If `modify` is true, only the 'active' edge (the `end`) of the selection
+/// should be changed; this is the case when the user moves with the shift
+/// key pressed.
+pub fn movement<T: Selectable + TextStorage>(
+    m: Movement,
+    s: Selection,
+    layout: &TextLayout<T>,
+    modify: bool,
+) -> Selection {
+    if layout.needs_rebuild() {
+        debug_panic!("movement() called before layout rebuild");
+        return s;
+    }
+    let text = layout.text();
+    let parley_layout = layout.layout();
+
+    let writing_direction = || {
+        if layout
+            .cursor_for_text_position(s.active, s.active_affinity)
+            .is_rtl
+        {
+            WritingDirection::RightToLeft
+        } else {
+            WritingDirection::LeftToRight
+        }
+    };
+
+    let (offset, h_pos) = match m {
+        Movement::Grapheme(d) => {
+            let direction = writing_direction();
+            if d.is_upstream_for_direction(direction) {
+                if s.is_caret() || modify {
+                    text.prev_grapheme_offset(s.active)
+                        .map(|off| (off, None))
+                        .unwrap_or((0, s.h_pos))
+                } else {
+                    (s.min(), None)
+                }
+            } else {
+                if s.is_caret() || modify {
+                    text.next_grapheme_offset(s.active)
+                        .map(|off| (off, None))
+                        .unwrap_or((s.active, s.h_pos))
+                } else {
+                    (s.max(), None)
+                }
+            }
+        }
+        Movement::Vertical(VerticalMovement::LineUp) => {
+            let cur_pos = layout.cursor_for_text_position(s.active, s.active_affinity);
+            let h_pos = s.h_pos.unwrap_or(cur_pos.advance);
+            if cur_pos.path.line_index == 0 {
+                (0, Some(h_pos))
+            } else {
+                let lm = cur_pos.path.line(&parley_layout).unwrap();
+                let point_above = Point::new(h_pos, cur_pos.point.y - lm.height);
+                let up_pos = layout.hit_test_point(point_above);
+                if up_pos.is_inside {
+                    (up_pos.idx, Some(h_pos))
+                } else {
+                    // because we can't specify affinity, moving up when h_pos
+                    // is wider than both the current line and the previous line
+                    // can result in a cursor position at the visual start of the
+                    // current line; so we handle this as a special-case.
+                    let lm_prev = layout.line_metric(cur_pos.line.saturating_sub(1)).unwrap();
+                    let up_pos = lm_prev.end_offset - lm_prev.trailing_whitespace;
+                    (up_pos, Some(h_pos))
+                }
+            }
+        }
+        Movement::Vertical(VerticalMovement::LineDown) => {
+            let cur_pos = layout.hit_test_text_position(s.active);
+            let h_pos = s.h_pos.unwrap_or(cur_pos.point.x);
+            if cur_pos.line == layout.line_count() - 1 {
+                (text.len(), Some(h_pos))
+            } else {
+                let lm = layout.line_metric(cur_pos.line).unwrap();
+                // may not work correctly for point sizes below 1.0
+                let y_below = lm.y_offset + lm.height + 1.0;
+                let point_below = Point::new(h_pos, y_below);
+                let up_pos = layout.hit_test_point(point_below);
+                (up_pos.idx, Some(point_below.x))
+            }
+        }
+        Movement::Vertical(VerticalMovement::DocumentStart) => (0, None),
+        Movement::Vertical(VerticalMovement::DocumentEnd) => (text.len(), None),
+
+        Movement::ParagraphStart => (text.preceding_line_break(s.active), None),
+        Movement::ParagraphEnd => (text.next_line_break(s.active), None),
+
+        Movement::Line(d) => {
+            let hit = layout.hit_test_text_position(s.active);
+            let lm = layout.line_metric(hit.line).unwrap();
+            let offset = if d.is_upstream_for_direction(writing_direction) {
+                lm.start_offset
+            } else {
+                lm.end_offset - lm.trailing_whitespace
+            };
+            (offset, None)
+        }
+        Movement::Word(d) => {
+            if d.is_upstream_for_direction(writing_direction()) {
+                let offset = if s.is_caret() || modify {
+                    text.prev_word_offset(s.active).unwrap_or(0)
+                } else {
+                    s.min()
+                };
+                (offset, None)
+            } else {
+                let offset = if s.is_caret() || modify {
+                    text.next_word_offset(s.active).unwrap_or(s.active)
+                } else {
+                    s.max()
+                };
+                (offset, None)
+            }
+        }
+
+        // These two are not handled; they require knowledge of the size
+        // of the viewport.
+        Movement::Vertical(VerticalMovement::PageDown)
+        | Movement::Vertical(VerticalMovement::PageUp) => (s.active, s.h_pos),
+        other => {
+            tracing::warn!("unhandled movement {:?}", other);
+            (s.anchor, s.h_pos)
+        }
+    };
+
+    let start = if modify { s.anchor } else { offset };
+    Selection::new(start, offset).with_h_pos(h_pos)
+}
+
+/// Indicates a movement that transforms a particular text position in a
+/// document.
+///
+/// These movements transform only single indices — not selections.
+///
+/// You'll note that a lot of these operations are idempotent, but you can get
+/// around this by first sending a `Grapheme` movement.  If for instance, you
+/// want a `ParagraphStart` that is not idempotent, you can first send
+/// `Movement::Grapheme(Direction::Upstream)`, and then follow it with
+/// `ParagraphStart`.
+#[non_exhaustive]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum Movement {
+    /// A movement that stops when it reaches an extended grapheme cluster boundary.
+    ///
+    /// This movement is achieved on most systems by pressing the left and right
+    /// arrow keys.  For more information on grapheme clusters, see
+    /// [Unicode Text Segmentation](https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries).
+    Grapheme(Direction),
+    /// A movement that stops when it reaches a word boundary.
+    ///
+    /// This movement is achieved on most systems by pressing the left and right
+    /// arrow keys while holding control. For more information on words, see
+    /// [Unicode Text Segmentation](https://unicode.org/reports/tr29/#Word_Boundaries).
+    Word(Direction),
+    /// A movement that stops when it reaches a soft line break.
+    ///
+    /// This movement is achieved on macOS by pressing the left and right arrow
+    /// keys while holding command.  `Line` should be idempotent: if the
+    /// position is already at the end of a soft-wrapped line, this movement
+    /// should never push it onto another soft-wrapped line.
+    ///
+    /// In order to implement this properly, your text positions should remember
+    /// their affinity.
+    Line(Direction),
+    /// An upstream movement that stops when it reaches a hard line break.
+    ///
+    /// `ParagraphStart` should be idempotent: if the position is already at the
+    /// start of a hard-wrapped line, this movement should never push it onto
+    /// the previous line.
+    ParagraphStart,
+    /// A downstream movement that stops when it reaches a hard line break.
+    ///
+    /// `ParagraphEnd` should be idempotent: if the position is already at the
+    /// end of a hard-wrapped line, this movement should never push it onto the
+    /// next line.
+    ParagraphEnd,
+    /// A vertical movement, see `VerticalMovement` for more details.
+    Vertical(VerticalMovement),
+}
+
+/// Indicates a horizontal direction in the text.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum Direction {
+    /// The direction visually to the left.
+    ///
+    /// This may be byte-wise forwards or backwards in the document, depending
+    /// on the text direction around the position being moved.
+    Left,
+    /// The direction visually to the right.
+    ///
+    /// This may be byte-wise forwards or backwards in the document, depending
+    /// on the text direction around the position being moved.
+    Right,
+    /// Byte-wise backwards in the document.
+    ///
+    /// In a left-to-right context, this value is the same as `Left`.
+    Upstream,
+    /// Byte-wise forwards in the document.
+    ///
+    /// In a left-to-right context, this value is the same as `Right`.
+    Downstream,
+}
+
+impl Direction {
+    /// Returns `true` if this direction is byte-wise backwards for
+    /// the provided [`WritingDirection`].
+    ///
+    /// The provided direction *must not be* `WritingDirection::Natural`.
+    pub fn is_upstream_for_direction(self, direction: WritingDirection) -> bool {
+        // assert!(
+        //     !matches!(direction, WritingDirection::Natural),
+        //     "writing direction must be resolved"
+        // );
+        match self {
+            Direction::Upstream => true,
+            Direction::Downstream => false,
+            Direction::Left => matches!(direction, WritingDirection::LeftToRight),
+            Direction::Right => matches!(direction, WritingDirection::RightToLeft),
+        }
+    }
+}
+
+/// Distinguishes between two visually distinct locations with the same byte
+/// index.
+///
+/// Sometimes, a byte location in a document has two visual locations. For
+/// example, the end of a soft-wrapped line and the start of the subsequent line
+/// have different visual locations (and we want to be able to place an input
+/// caret in either place!) but the same byte-wise location. This also shows up
+/// in bidirectional text contexts. Affinity allows us to disambiguate between
+/// these two visual locations.
+///
+/// Note that in scenarios where soft line breaks interact with bidi text, this gets
+/// more complicated.
+#[derive(Copy, Clone, Debug, Hash, PartialEq)]
+pub enum Affinity {
+    /// The position which has an apparent position "earlier" in the text.
+    /// For soft line breaks, this is the position at the end of the first line.
+    ///
+    /// For positions in-between bidi contexts, this is the position which is
+    /// related to the "outgoing" text section. E.g. for the string "abcDEF" (rendered `abcFED`),
+    /// with the cursor at "abc|DEF" with upstream affinity, the cursor would be rendered at the
+    /// position `abc|DEF`
+    Upstream,
+    /// The position which has a higher apparent position in the text.
+    /// For soft line breaks, this is the position at the beginning of the second line.
+    ///
+    /// For positions in-between bidi contexts, this is the position which is
+    /// related to the "incoming" text section. E.g. for the string "abcDEF" (rendered `abcFED`),
+    /// with the cursor at "abc|DEF" with downstream affinity, the cursor would be rendered at the
+    /// position `abcDEF|`
+    Downstream,
+}
+
+impl Affinity {
+    /// Convert into the `parley` form of "leading"
+    pub fn is_leading(&self) -> bool {
+        match self {
+            Affinity::Upstream => false,
+            Affinity::Downstream => true,
+        }
+    }
+}
+
+/// Indicates a horizontal direction for writing text.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum WritingDirection {
+    LeftToRight,
+    RightToLeft,
+    // /// Indicates writing direction should be automatically detected based on
+    // /// the text contents.
+    // See also `is_upstream_for_direction` if adding back in
+    // Natural,
+}
+
+/// Indicates a vertical movement in a text document.
+#[non_exhaustive]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum VerticalMovement {
+    LineUp,
+    LineDown,
+    PageUp,
+    PageDown,
+    DocumentStart,
+    DocumentEnd,
+}
+
+/// Given a position in some text, return the containing word boundaries.
+///
+/// The returned range may not necessary be a 'word'; for instance it could be
+/// the sequence of whitespace between two words.
+///
+/// If the position is on a word boundary, that will be considered the start
+/// of the range.
+///
+/// This uses Unicode word boundaries, as defined in [UAX#29].
+///
+/// [UAX#29]: http://www.unicode.org/reports/tr29/
+pub(crate) fn word_range_for_pos(text: &str, pos: usize) -> Range<usize> {
+    text.split_word_bound_indices()
+        .map(|(ix, word)| ix..(ix + word.len()))
+        .find(|range| range.contains(&pos))
+        .unwrap_or(pos..pos)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn word_range_simple() {
+        assert_eq!(word_range_for_pos("hello world", 3), 0..5);
+        assert_eq!(word_range_for_pos("hello world", 8), 6..11);
+    }
+
+    #[test]
+    fn word_range_whitespace() {
+        assert_eq!(word_range_for_pos("hello world", 5), 5..6);
+    }
+
+    #[test]
+    fn word_range_rtl() {
+        let rtl = "مرحبا بالعالم";
+        assert_eq!(word_range_for_pos(rtl, 5), 0..10);
+        assert_eq!(word_range_for_pos(rtl, 16), 11..25);
+        assert_eq!(word_range_for_pos(rtl, 10), 10..11);
+    }
+
+    #[test]
+    fn word_range_mixed() {
+        let mixed = "hello مرحبا بالعالم world";
+        assert_eq!(word_range_for_pos(mixed, 3), 0..5);
+        assert_eq!(word_range_for_pos(mixed, 8), 6..16);
+        assert_eq!(word_range_for_pos(mixed, 19), 17..31);
+        assert_eq!(word_range_for_pos(mixed, 36), 32..37);
+    }
+}
diff --git a/crates/masonry/src/text2/selection.rs b/crates/masonry/src/text2/selection.rs
new file mode 100644
index 000000000..b5c922da9
--- /dev/null
+++ b/crates/masonry/src/text2/selection.rs
@@ -0,0 +1,853 @@
+// Copyright 2018 the Xilem Authors and the Druid Authors and the Glazier Authors
+// SPDX-License-Identifier: Apache-2.0
+
+//! Traits for text editing and a basic String implementation.
+
+use std::borrow::Cow;
+use std::ops::{Deref, DerefMut, Range};
+
+use kurbo::{Affine, Line, Point, Stroke};
+use parley::FontContext;
+use unicode_segmentation::{GraphemeCursor, UnicodeSegmentation};
+use vello::peniko::{Brush, Color};
+use vello::Scene;
+use winit::event::MouseButton;
+use winit::keyboard::NamedKey;
+use winit::platform::modifier_supplement::KeyEventExtModifierSupplement;
+
+use crate::event::PointerState;
+use crate::{Handled, TextEvent};
+
+use super::{TextBrush, TextLayout, TextStorage};
+
+pub struct TextWithSelection<T: Selectable> {
+    pub layout: TextLayout<T>,
+    /// The current selection within this widget
+    // TODO: Allow multiple selections (i.e. by holding down control)
+    pub selection: Option<Selection>,
+    highlight_brush: TextBrush,
+    needs_selection_update: bool,
+    selecting_with_mouse: bool,
+    // TODO: Cache cursor line, selection boxes
+    cursor_line: Option<Line>,
+}
+
+impl<T: Selectable> TextWithSelection<T> {
+    pub fn new(text: T, text_size: f32) -> Self {
+        Self {
+            layout: TextLayout::new(text, text_size),
+            selection: None,
+            needs_selection_update: false,
+            selecting_with_mouse: false,
+            cursor_line: None,
+            highlight_brush: TextBrush::Highlight {
+                text: Color::WHITE.into(),
+                fill: Color::LIGHT_BLUE.into(),
+            },
+        }
+    }
+
+    pub fn set_text(&mut self, text: T) {
+        self.selection = None;
+        self.needs_selection_update = true;
+        self.layout.set_text(text);
+    }
+
+    pub fn needs_rebuild(&self) -> bool {
+        self.layout.needs_rebuild() || self.needs_selection_update
+    }
+
+    pub fn pointer_down(
+        &mut self,
+        origin: Point,
+        state: &PointerState,
+        button: MouseButton,
+    ) -> bool {
+        // TODO: work out which button is the primary button?
+        if button == MouseButton::Left {
+            self.selecting_with_mouse = true;
+            self.needs_selection_update = true;
+            // TODO: Much of this juggling seems unnecessary
+            let position = Point::new(state.position.x, state.position.y) - origin;
+            let position = self
+                .layout
+                .cursor_for_point(Point::new(position.x, position.y));
+            tracing::warn!("Got cursor point without getting affinity");
+            if state.mods.state().shift_key() {
+                if let Some(selection) = self.selection.as_mut() {
+                    selection.active = position.insert_point;
+                    selection.active_affinity = Affinity::Downstream;
+                    return true;
+                }
+            }
+            self.selection = Some(Selection::caret(
+                position.insert_point,
+                Affinity::Downstream,
+            ));
+
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn pointer_up(&mut self, _origin: Point, _state: &PointerState, button: MouseButton) {
+        if button == MouseButton::Left {
+            self.selecting_with_mouse = false;
+        }
+    }
+
+    pub fn pointer_move(&mut self, origin: Point, state: &PointerState) -> bool {
+        if self.selecting_with_mouse {
+            self.needs_selection_update = true;
+            let position = Point::new(state.position.x, state.position.y) - origin;
+            let position = self
+                .layout
+                .cursor_for_point(Point::new(position.x, position.y));
+            tracing::warn!("Got cursor point without getting affinity");
+            if let Some(selection) = self.selection.as_mut() {
+                selection.active = position.insert_point;
+                selection.active_affinity = Affinity::Downstream;
+            } else {
+                debug_panic!("No selection set whilst still dragging");
+            }
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn text_event(&mut self, event: &TextEvent) -> Handled {
+        match event {
+            TextEvent::KeyboardKey(key, mods) if key.state.is_pressed() => {
+                match key.key_without_modifiers() {
+                    winit::keyboard::Key::Named(NamedKey::ArrowLeft) if mods.shift_key() => {
+                        // TODO: Expand selection
+                        Handled::Yes
+                    }
+                    winit::keyboard::Key::Named(_) => Handled::No,
+                    winit::keyboard::Key::Character(chr) => match &*chr {
+                        "a" if mods.control_key() || /* macOS, yes this is a hack */ mods.super_key() =>
+                        {
+                            self.selection =
+                                Some(Selection::new(0, self.text().len(), Affinity::Downstream));
+                            self.needs_selection_update = true;
+                            Handled::Yes
+                        }
+                        "c" if mods.control_key() || mods.super_key() => {
+                            match &self.selection {
+                                Some(selection) => {
+                                    // TODO: We know this is not the fullest model of copy-paste, and that we should work with the inner text
+                                    // e.g. to put HTML code if supported by the rich text kind
+                                    if let Some(text) =
+                                        self.text().slice(selection.min()..selection.max())
+                                    {
+                                        println!(r#"Copying "{text}""#);
+                                    } else {
+                                        debug_panic!("Had invalid selection");
+                                    }
+                                }
+                                None => debug_panic!("Got text input event whilst not focused"),
+                            }
+                            Handled::Yes
+                        }
+                        _ => Handled::No,
+                    },
+                    winit::keyboard::Key::Unidentified(_) => todo!(),
+                    winit::keyboard::Key::Dead(_) => todo!(),
+                }
+            }
+            TextEvent::KeyboardKey(_, _) => Handled::No,
+            TextEvent::Ime(_) => Handled::No,
+            TextEvent::ModifierChange(_) => {
+                // TODO: What does it mean to "handle" this change?
+                Handled::No
+            }
+            TextEvent::FocusChange(_) => {
+                // TODO: What does it mean to "handle" this change
+                // TODO: Set our highlighting colour to a lighter blue if window unfocused
+                Handled::No
+            }
+        }
+    }
+
+    /// Call when another widget becomes focused
+    pub fn focus_lost(&mut self) {
+        self.selection = None;
+        self.selecting_with_mouse = false;
+        self.needs_selection_update = true;
+    }
+
+    // Intentionally aliases the method on
+    pub fn rebuild(&mut self, fcx: &mut FontContext) {
+        // In theory, we could be clever here and only rebuild the layout if the
+        // selected range was previously or currently non-zero size (i.e. there is a selected range)
+        if self.needs_selection_update || self.layout.needs_rebuild() {
+            self.layout.invalidate();
+            self.layout.rebuild_with_attributes(fcx, |mut builder| {
+                if let Some(selection) = self.selection {
+                    let range = selection.min()..selection.max();
+                    if !range.is_empty() {
+                        builder.push(
+                            &parley::style::StyleProperty::Brush(self.highlight_brush.clone()),
+                            range,
+                        );
+                    }
+                }
+                builder
+            });
+            self.needs_selection_update = false;
+        }
+    }
+
+    pub fn draw(&mut self, scene: &mut Scene, point: impl Into<Point>) {
+        // TODO: Calculate the location for this in layout lazily?
+        if let Some(selection) = self.selection {
+            self.cursor_line = Some(self.layout.cursor_line_for_text_position(selection.active));
+        } else {
+            self.cursor_line = None;
+        }
+        let point: Point = point.into();
+        if let Some(line) = self.cursor_line {
+            scene.stroke(
+                &Stroke::new(2.),
+                Affine::translate((point.x, point.y)),
+                &Brush::Solid(Color::WHITE),
+                None,
+                &line,
+            );
+        }
+        self.layout.draw(scene, point);
+    }
+}
+
+impl<T: Selectable> Deref for TextWithSelection<T> {
+    type Target = TextLayout<T>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.layout
+    }
+}
+
+// TODO: Being able to call `Self::Target::rebuild` (and `draw`) isn't great.
+impl<T: Selectable> DerefMut for TextWithSelection<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.layout
+    }
+}
+
+/// A range of selected text, or a caret.
+///
+/// A caret is the blinking vertical bar where text is to be inserted. We
+/// represent it as a selection with zero length, where `anchor == active`.
+/// Indices are always expressed in UTF-8 bytes, and must be between 0 and the
+/// document length, inclusive.
+///
+/// As an example, if the input caret is at the start of the document `hello
+/// world`, we would expect both `anchor` and `active` to be `0`. If the user
+/// holds shift and presses the right arrow key five times, we would expect the
+/// word `hello` to be selected, the `anchor` to still be `0`, and the `active`
+/// to now be `5`.
+#[derive(Clone, Copy, Debug, PartialEq)]
+#[non_exhaustive]
+pub struct Selection {
+    /// The 'anchor' end of the selection.
+    ///
+    /// This is the end of the selection that stays unchanged while holding
+    /// shift and pressing the arrow keys.
+    // TODO: Is usize the right type for these? Is it plausible to be dealing with a
+    // more than 4gb file on a 32 bit machine?
+    pub anchor: usize,
+    /// The 'active' end of the selection.
+    ///
+    /// This is the end of the selection that moves while holding shift and
+    /// pressing the arrow keys.
+    pub active: usize,
+    /// The affinity of the `active` side of the cursor
+    ///
+    /// The affinity of `anchor` is entirely based on the affinity of active:
+    /// 1) If `active` is Upstream
+    pub active_affinity: Affinity,
+    /// The saved horizontal position, during vertical movement.
+    ///
+    /// This should not be set by the IME; it will be tracked and handled by
+    /// the text field.
+    pub h_pos: Option<f32>,
+}
+
+#[allow(clippy::len_without_is_empty)]
+impl Selection {
+    /// Create a new `Selection` with the provided `anchor` and `active` positions.
+    ///
+    /// Both positions refer to UTF-8 byte indices in some text.
+    ///
+    /// If your selection is a caret, you can use [`Selection::caret`] instead.
+    pub fn new(anchor: usize, active: usize, active_affinity: Affinity) -> Selection {
+        Selection {
+            anchor,
+            active,
+            h_pos: None,
+            active_affinity,
+        }
+    }
+
+    /// Create a new caret (zero-length selection) at the provided UTF-8 byte index.
+    ///
+    /// `index` must be a grapheme cluster boundary.
+    pub fn caret(index: usize, affinity: Affinity) -> Selection {
+        Selection {
+            anchor: index,
+            active: index,
+            h_pos: None,
+            active_affinity: affinity,
+        }
+    }
+
+    /// Construct a new selection from this selection, with the provided h_pos.
+    ///
+    /// # Note
+    ///
+    /// `h_pos` is used to track the *pixel* location of the cursor when moving
+    /// vertically; lines may have available cursor positions at different
+    /// positions, and arrowing down and then back up should always result
+    /// in a cursor at the original starting location; doing this correctly
+    /// requires tracking this state.
+    ///
+    /// You *probably* don't need to use this, unless you are implementing a new
+    /// text field, or otherwise implementing vertical cursor motion, in which
+    /// case you will want to set this during vertical motion if it is not
+    /// already set.
+    pub fn with_h_pos(mut self, h_pos: Option<f32>) -> Self {
+        self.h_pos = h_pos;
+        self
+    }
+
+    /// Create a new selection that is guaranteed to be valid for the provided
+    /// text.
+    #[must_use = "constrained constructs a new Selection"]
+    pub fn constrained(mut self, s: &str) -> Self {
+        let s_len = s.len();
+        self.anchor = self.anchor.min(s_len);
+        self.active = self.active.min(s_len);
+        while !s.is_char_boundary(self.anchor) {
+            self.anchor += 1;
+        }
+        while !s.is_char_boundary(self.active) {
+            self.active += 1;
+        }
+        self
+    }
+
+    /// Return the position of the upstream end of the selection.
+    ///
+    /// This is end with the lesser byte index.
+    ///
+    /// Because of bidirectional text, this is not necessarily "left".
+    pub fn min(&self) -> usize {
+        usize::min(self.anchor, self.active)
+    }
+
+    /// Return the position of the downstream end of the selection.
+    ///
+    /// This is the end with the greater byte index.
+    ///
+    /// Because of bidirectional text, this is not necessarily "right".
+    pub fn max(&self) -> usize {
+        usize::max(self.anchor, self.active)
+    }
+
+    /// The sequential range of the document represented by this selection.
+    ///
+    /// This is the range that would be replaced if text were inserted at this
+    /// selection.
+    pub fn range(&self) -> Range<usize> {
+        self.min()..self.max()
+    }
+
+    /// The length, in bytes of the selected region.
+    ///
+    /// If the selection is a caret, this is `0`.
+    pub fn len(&self) -> usize {
+        if self.anchor > self.active {
+            self.anchor - self.active
+        } else {
+            self.active - self.anchor
+        }
+    }
+
+    /// Returns `true` if the selection's length is `0`.
+    pub fn is_caret(&self) -> bool {
+        self.len() == 0
+    }
+}
+
+/// Distinguishes between two visually distinct locations with the same byte
+/// index.
+///
+/// Sometimes, a byte location in a document has two visual locations. For
+/// example, the end of a soft-wrapped line and the start of the subsequent line
+/// have different visual locations (and we want to be able to place an input
+/// caret in either place!) but the same byte-wise location. This also shows up
+/// in bidirectional text contexts. Affinity allows us to disambiguate between
+/// these two visual locations.
+///
+/// Note that in scenarios where soft line breaks interact with bidi text, this gets
+/// more complicated.
+///
+/// This also has an impact on rich text editing.
+/// For example, if the cursor is in a region like `a|1`, where `a` is bold and `1` is not.
+/// When editing, if we came from the start of the string, we should assume that the next
+/// character will be bold, from the right italic.
+#[derive(Copy, Clone, Debug, Hash, PartialEq)]
+pub enum Affinity {
+    /// The position which has an apparent position "earlier" in the text.
+    /// For soft line breaks, this is the position at the end of the first line.
+    ///
+    /// For positions in-between bidi contexts, this is the position which is
+    /// related to the "outgoing" text section. E.g. for the string "abcDEF" (rendered `abcFED`),
+    /// with the cursor at "abc|DEF" with upstream affinity, the cursor would be rendered at the
+    /// position `abc|DEF`
+    Upstream,
+    /// The position which has a higher apparent position in the text.
+    /// For soft line breaks, this is the position at the beginning of the second line.
+    ///
+    /// For positions in-between bidi contexts, this is the position which is
+    /// related to the "incoming" text section. E.g. for the string "abcDEF" (rendered `abcFED`),
+    /// with the cursor at "abc|DEF" with downstream affinity, the cursor would be rendered at the
+    /// position `abcDEF|`
+    Downstream,
+}
+
+/// Text which can have internal selections
+pub trait Selectable: Sized + TextStorage {
+    type Cursor<'a>: EditableTextCursor
+    where
+        Self: 'a;
+
+    /// Create a cursor with a reference to the text and a offset position.
+    ///
+    /// Returns None if the position isn't a codepoint boundary.
+    fn cursor(&self, position: usize) -> Option<Self::Cursor<'_>>;
+    /// Get slice of text at range.
+    fn slice(&self, range: Range<usize>) -> Option<Cow<str>>;
+
+    /// Get length of text (in bytes).
+    fn len(&self) -> usize;
+
+    /// Get the previous word offset from the given offset, if it exists.
+    fn prev_word_offset(&self, offset: usize) -> Option<usize>;
+
+    /// Get the next word offset from the given offset, if it exists.
+    fn next_word_offset(&self, offset: usize) -> Option<usize>;
+
+    /// Get the next grapheme offset from the given offset, if it exists.
+    fn prev_grapheme_offset(&self, offset: usize) -> Option<usize>;
+
+    /// Get the next grapheme offset from the given offset, if it exists.
+    fn next_grapheme_offset(&self, offset: usize) -> Option<usize>;
+
+    /// Get the previous codepoint offset from the given offset, if it exists.
+    fn prev_codepoint_offset(&self, offset: usize) -> Option<usize>;
+
+    /// Get the next codepoint offset from the given offset, if it exists.
+    fn next_codepoint_offset(&self, offset: usize) -> Option<usize>;
+
+    /// Get the preceding line break offset from the given offset
+    fn preceding_line_break(&self, offset: usize) -> usize;
+
+    /// Get the next line break offset from the given offset
+    fn next_line_break(&self, offset: usize) -> usize;
+
+    /// Returns `true` if this text has 0 length.
+    fn is_empty(&self) -> bool;
+}
+
+/// A cursor with convenience functions for moving through EditableText.
+pub trait EditableTextCursor {
+    /// Set cursor position.
+    fn set(&mut self, position: usize);
+
+    /// Get cursor position.
+    fn pos(&self) -> usize;
+
+    /// Check if cursor position is at a codepoint boundary.
+    fn is_boundary(&self) -> bool;
+
+    /// Move cursor to previous codepoint boundary, if it exists.
+    /// Returns previous codepoint as usize offset.
+    fn prev(&mut self) -> Option<usize>;
+
+    /// Move cursor to next codepoint boundary, if it exists.
+    /// Returns current codepoint as usize offset.
+    fn next(&mut self) -> Option<usize>;
+
+    /// Get the next codepoint after the cursor position, without advancing
+    /// the cursor.
+    fn peek_next_codepoint(&self) -> Option<char>;
+
+    /// Return codepoint preceding cursor offset and move cursor backward.
+    fn prev_codepoint(&mut self) -> Option<char>;
+
+    /// Return codepoint at cursor offset and move cursor forward.
+    fn next_codepoint(&mut self) -> Option<char>;
+
+    /// Return current offset if it's a boundary, else next.
+    fn at_or_next(&mut self) -> Option<usize>;
+
+    /// Return current offset if it's a boundary, else previous.
+    fn at_or_prev(&mut self) -> Option<usize>;
+}
+
+impl<Str: Deref<Target = str> + TextStorage> Selectable for Str {
+    type Cursor<'a> = StringCursor<'a> where Self: 'a;
+
+    fn cursor<'a>(&self, position: usize) -> Option<StringCursor> {
+        let new_cursor = StringCursor {
+            text: self,
+            position,
+        };
+
+        if new_cursor.is_boundary() {
+            Some(new_cursor)
+        } else {
+            None
+        }
+    }
+
+    fn slice(&self, range: Range<usize>) -> Option<Cow<str>> {
+        self.get(range).map(Cow::from)
+    }
+
+    fn len(&self) -> usize {
+        self.deref().len()
+    }
+
+    fn prev_grapheme_offset(&self, from: usize) -> Option<usize> {
+        let mut c = GraphemeCursor::new(from, self.len(), true);
+        c.prev_boundary(self, 0).unwrap()
+    }
+
+    fn next_grapheme_offset(&self, from: usize) -> Option<usize> {
+        let mut c = GraphemeCursor::new(from, self.len(), true);
+        c.next_boundary(self, 0).unwrap()
+    }
+
+    fn prev_codepoint_offset(&self, from: usize) -> Option<usize> {
+        let mut c = self.cursor(from).unwrap();
+        c.prev()
+    }
+
+    fn next_codepoint_offset(&self, from: usize) -> Option<usize> {
+        let mut c = self.cursor(from).unwrap();
+        if c.next().is_some() {
+            Some(c.pos())
+        } else {
+            None
+        }
+    }
+
+    fn prev_word_offset(&self, from: usize) -> Option<usize> {
+        let mut offset = from;
+        let mut passed_alphanumeric = false;
+        for prev_grapheme in self.get(0..from)?.graphemes(true).rev() {
+            let is_alphanumeric = prev_grapheme.chars().next()?.is_alphanumeric();
+            if is_alphanumeric {
+                passed_alphanumeric = true;
+            } else if passed_alphanumeric {
+                return Some(offset);
+            }
+            offset -= prev_grapheme.len();
+        }
+        None
+    }
+
+    fn next_word_offset(&self, from: usize) -> Option<usize> {
+        let mut offset = from;
+        let mut passed_alphanumeric = false;
+        for next_grapheme in self.get(from..)?.graphemes(true) {
+            let is_alphanumeric = next_grapheme.chars().next()?.is_alphanumeric();
+            if is_alphanumeric {
+                passed_alphanumeric = true;
+            } else if passed_alphanumeric {
+                return Some(offset);
+            }
+            offset += next_grapheme.len();
+        }
+        Some(self.len())
+    }
+
+    fn is_empty(&self) -> bool {
+        self.deref().is_empty()
+    }
+
+    fn preceding_line_break(&self, from: usize) -> usize {
+        let mut offset = from;
+
+        for byte in self.get(0..from).unwrap_or("").bytes().rev() {
+            if byte == 0x0a {
+                return offset;
+            }
+            offset -= 1;
+        }
+
+        0
+    }
+
+    fn next_line_break(&self, from: usize) -> usize {
+        let mut offset = from;
+
+        for char in self.get(from..).unwrap_or("").bytes() {
+            if char == 0x0a {
+                return offset;
+            }
+            offset += 1;
+        }
+
+        self.len()
+    }
+}
+
+/// A cursor type that implements EditableTextCursor for string types
+#[derive(Debug)]
+pub struct StringCursor<'a> {
+    text: &'a str,
+    position: usize,
+}
+
+impl<'a> EditableTextCursor for StringCursor<'a> {
+    fn set(&mut self, position: usize) {
+        self.position = position;
+    }
+
+    fn pos(&self) -> usize {
+        self.position
+    }
+
+    fn is_boundary(&self) -> bool {
+        self.text.is_char_boundary(self.position)
+    }
+
+    fn prev(&mut self) -> Option<usize> {
+        let current_pos = self.pos();
+
+        if current_pos == 0 {
+            None
+        } else {
+            let mut len = 1;
+            while !self.text.is_char_boundary(current_pos - len) {
+                len += 1;
+            }
+            self.set(self.pos() - len);
+            Some(self.pos())
+        }
+    }
+
+    fn next(&mut self) -> Option<usize> {
+        let current_pos = self.pos();
+
+        if current_pos == self.text.len() {
+            None
+        } else {
+            let b = self.text.as_bytes()[current_pos];
+            self.set(current_pos + len_utf8_from_first_byte(b));
+            Some(current_pos)
+        }
+    }
+
+    fn peek_next_codepoint(&self) -> Option<char> {
+        self.text[self.pos()..].chars().next()
+    }
+
+    fn prev_codepoint(&mut self) -> Option<char> {
+        if let Some(prev) = self.prev() {
+            self.text[prev..].chars().next()
+        } else {
+            None
+        }
+    }
+
+    fn next_codepoint(&mut self) -> Option<char> {
+        let current_index = self.pos();
+        if self.next().is_some() {
+            self.text[current_index..].chars().next()
+        } else {
+            None
+        }
+    }
+
+    fn at_or_next(&mut self) -> Option<usize> {
+        if self.is_boundary() {
+            Some(self.pos())
+        } else {
+            self.next()
+        }
+    }
+
+    fn at_or_prev(&mut self) -> Option<usize> {
+        if self.is_boundary() {
+            Some(self.pos())
+        } else {
+            self.prev()
+        }
+    }
+}
+
+pub fn len_utf8_from_first_byte(b: u8) -> usize {
+    match b {
+        b if b < 0x80 => 1,
+        b if b < 0xe0 => 2,
+        b if b < 0xf0 => 3,
+        _ => 4,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn prev_codepoint_offset() {
+        let a = String::from("a\u{00A1}\u{4E00}\u{1F4A9}");
+        assert_eq!(Some(6), a.prev_codepoint_offset(10));
+        assert_eq!(Some(3), a.prev_codepoint_offset(6));
+        assert_eq!(Some(1), a.prev_codepoint_offset(3));
+        assert_eq!(Some(0), a.prev_codepoint_offset(1));
+        assert_eq!(None, a.prev_codepoint_offset(0));
+        let b = a.slice(1..10).unwrap().to_string();
+        assert_eq!(Some(5), b.prev_codepoint_offset(9));
+        assert_eq!(Some(2), b.prev_codepoint_offset(5));
+        assert_eq!(Some(0), b.prev_codepoint_offset(2));
+        assert_eq!(None, b.prev_codepoint_offset(0));
+    }
+
+    #[test]
+    fn next_codepoint_offset() {
+        let a = String::from("a\u{00A1}\u{4E00}\u{1F4A9}");
+        assert_eq!(Some(10), a.next_codepoint_offset(6));
+        assert_eq!(Some(6), a.next_codepoint_offset(3));
+        assert_eq!(Some(3), a.next_codepoint_offset(1));
+        assert_eq!(Some(1), a.next_codepoint_offset(0));
+        assert_eq!(None, a.next_codepoint_offset(10));
+        let b = a.slice(1..10).unwrap().to_string();
+        assert_eq!(Some(9), b.next_codepoint_offset(5));
+        assert_eq!(Some(5), b.next_codepoint_offset(2));
+        assert_eq!(Some(2), b.next_codepoint_offset(0));
+        assert_eq!(None, b.next_codepoint_offset(9));
+    }
+
+    #[test]
+    fn prev_next() {
+        let input = String::from("abc");
+        let mut cursor = input.cursor(0).unwrap();
+        assert_eq!(cursor.next(), Some(0));
+        assert_eq!(cursor.next(), Some(1));
+        assert_eq!(cursor.prev(), Some(1));
+        assert_eq!(cursor.next(), Some(1));
+        assert_eq!(cursor.next(), Some(2));
+    }
+
+    #[test]
+    fn peek_next_codepoint() {
+        let inp = String::from("$¢€£💶");
+        let mut cursor = inp.cursor(0).unwrap();
+        assert_eq!(cursor.peek_next_codepoint(), Some('$'));
+        assert_eq!(cursor.peek_next_codepoint(), Some('$'));
+        assert_eq!(cursor.next_codepoint(), Some('$'));
+        assert_eq!(cursor.peek_next_codepoint(), Some('¢'));
+        assert_eq!(cursor.prev_codepoint(), Some('$'));
+        assert_eq!(cursor.peek_next_codepoint(), Some('$'));
+        assert_eq!(cursor.next_codepoint(), Some('$'));
+        assert_eq!(cursor.next_codepoint(), Some('¢'));
+        assert_eq!(cursor.peek_next_codepoint(), Some('€'));
+        assert_eq!(cursor.next_codepoint(), Some('€'));
+        assert_eq!(cursor.peek_next_codepoint(), Some('£'));
+        assert_eq!(cursor.next_codepoint(), Some('£'));
+        assert_eq!(cursor.peek_next_codepoint(), Some('💶'));
+        assert_eq!(cursor.next_codepoint(), Some('💶'));
+        assert_eq!(cursor.peek_next_codepoint(), None);
+        assert_eq!(cursor.next_codepoint(), None);
+        assert_eq!(cursor.peek_next_codepoint(), None);
+    }
+
+    #[test]
+    fn prev_grapheme_offset() {
+        // A with ring, hangul, regional indicator "US"
+        let a = String::from("A\u{030a}\u{110b}\u{1161}\u{1f1fa}\u{1f1f8}");
+        assert_eq!(Some(9), a.prev_grapheme_offset(17));
+        assert_eq!(Some(3), a.prev_grapheme_offset(9));
+        assert_eq!(Some(0), a.prev_grapheme_offset(3));
+        assert_eq!(None, a.prev_grapheme_offset(0));
+    }
+
+    #[test]
+    fn next_grapheme_offset() {
+        // A with ring, hangul, regional indicator "US"
+        let a = String::from("A\u{030a}\u{110b}\u{1161}\u{1f1fa}\u{1f1f8}");
+        assert_eq!(Some(3), a.next_grapheme_offset(0));
+        assert_eq!(Some(9), a.next_grapheme_offset(3));
+        assert_eq!(Some(17), a.next_grapheme_offset(9));
+        assert_eq!(None, a.next_grapheme_offset(17));
+    }
+
+    #[test]
+    fn prev_word_offset() {
+        let a = String::from("Technically a word: ৬藏A\u{030a}\u{110b}\u{1161}");
+        assert_eq!(Some(20), a.prev_word_offset(35));
+        assert_eq!(Some(20), a.prev_word_offset(27));
+        assert_eq!(Some(20), a.prev_word_offset(23));
+        assert_eq!(Some(14), a.prev_word_offset(20));
+        assert_eq!(Some(14), a.prev_word_offset(19));
+        assert_eq!(Some(12), a.prev_word_offset(13));
+        assert_eq!(None, a.prev_word_offset(12));
+        assert_eq!(None, a.prev_word_offset(11));
+        assert_eq!(None, a.prev_word_offset(0));
+    }
+
+    #[test]
+    fn next_word_offset() {
+        let a = String::from("Technically a word: ৬藏A\u{030a}\u{110b}\u{1161}");
+        assert_eq!(Some(11), a.next_word_offset(0));
+        assert_eq!(Some(11), a.next_word_offset(7));
+        assert_eq!(Some(13), a.next_word_offset(11));
+        assert_eq!(Some(18), a.next_word_offset(14));
+        assert_eq!(Some(35), a.next_word_offset(18));
+        assert_eq!(Some(35), a.next_word_offset(19));
+        assert_eq!(Some(35), a.next_word_offset(20));
+        assert_eq!(Some(35), a.next_word_offset(26));
+        assert_eq!(Some(35), a.next_word_offset(35));
+    }
+
+    #[test]
+    fn preceding_line_break() {
+        let a = String::from("Technically\na word:\n ৬藏A\u{030a}\n\u{110b}\u{1161}");
+        assert_eq!(0, a.preceding_line_break(0));
+        assert_eq!(0, a.preceding_line_break(11));
+        assert_eq!(12, a.preceding_line_break(12));
+        assert_eq!(12, a.preceding_line_break(13));
+        assert_eq!(20, a.preceding_line_break(21));
+        assert_eq!(31, a.preceding_line_break(31));
+        assert_eq!(31, a.preceding_line_break(34));
+
+        let b = String::from("Technically a word: ৬藏A\u{030a}\u{110b}\u{1161}");
+        assert_eq!(0, b.preceding_line_break(0));
+        assert_eq!(0, b.preceding_line_break(11));
+        assert_eq!(0, b.preceding_line_break(13));
+        assert_eq!(0, b.preceding_line_break(21));
+    }
+
+    #[test]
+    fn next_line_break() {
+        let a = String::from("Technically\na word:\n ৬藏A\u{030a}\n\u{110b}\u{1161}");
+        assert_eq!(11, a.next_line_break(0));
+        assert_eq!(11, a.next_line_break(11));
+        assert_eq!(19, a.next_line_break(13));
+        assert_eq!(30, a.next_line_break(21));
+        assert_eq!(a.len(), a.next_line_break(31));
+
+        let b = String::from("Technically a word: ৬藏A\u{030a}\u{110b}\u{1161}");
+        assert_eq!(b.len(), b.next_line_break(0));
+        assert_eq!(b.len(), b.next_line_break(11));
+        assert_eq!(b.len(), b.next_line_break(13));
+        assert_eq!(b.len(), b.next_line_break(19));
+    }
+}
diff --git a/crates/masonry/src/text2/store.rs b/crates/masonry/src/text2/store.rs
new file mode 100644
index 000000000..fa9a16dda
--- /dev/null
+++ b/crates/masonry/src/text2/store.rs
@@ -0,0 +1,88 @@
+// Copyright 2018 the Xilem Authors and the Druid Authors
+// SPDX-License-Identifier: Apache-2.0
+
+//! Storing text.
+
+use std::{ops::Deref, sync::Arc};
+
+use parley::context::RangedBuilder;
+
+use crate::ArcStr;
+
+use super::layout::TextBrush;
+
+#[derive(Copy, Clone)]
+// TODO: Implement links
+pub struct Link;
+
+/// Text which can be displayed.
+pub trait TextStorage: 'static {
+    fn as_str(&self) -> &str;
+    /// If this TextStorage object manages style spans, it should implement
+    /// this method and update the provided builder with its spans, as required.
+    ///
+    /// This takes `&self`, as we needed to call `Self::as_str` to get the value stored in
+    /// the `RangedBuilder`
+    #[allow(unused_variables)]
+    fn add_attributes<'b>(
+        &self,
+        builder: RangedBuilder<'b, TextBrush, &'b str>,
+    ) -> RangedBuilder<'b, TextBrush, &'b str> {
+        builder
+    }
+
+    /// Any additional [`Link`] attributes on this text.
+    ///
+    /// If this `TextStorage` object manages link attributes, it should implement this
+    /// method and return any attached [`Link`]s.
+    ///
+    /// Unlike other attributes, links are managed in Masonry, not in [`piet`]; as such they
+    /// require a separate API.
+    ///
+    /// [`Link`]: super::attribute::Link
+    /// [`piet`]: https://docs.rs/piet
+    fn links(&self) -> &[Link] {
+        &[]
+    }
+
+    /// Determines quickly whether two text objects have the same content.
+    ///
+    /// To allow for faster checks, this method is allowed to return false negatives.
+    fn maybe_eq(&self, other: &Self) -> bool;
+}
+
+impl TextStorage for &'static str {
+    fn as_str(&self) -> &str {
+        self
+    }
+    fn maybe_eq(&self, other: &Self) -> bool {
+        self == other
+    }
+}
+
+impl TextStorage for ArcStr {
+    fn as_str(&self) -> &str {
+        self.deref()
+    }
+    fn maybe_eq(&self, other: &Self) -> bool {
+        self == other
+    }
+}
+
+impl TextStorage for String {
+    fn as_str(&self) -> &str {
+        self.deref()
+    }
+    fn maybe_eq(&self, other: &Self) -> bool {
+        self == other
+    }
+}
+
+impl TextStorage for Arc<String> {
+    fn as_str(&self) -> &str {
+        self.deref()
+    }
+    fn maybe_eq(&self, other: &Self) -> bool {
+        self == other
+    }
+}
diff --git a/crates/masonry/src/text_helpers.rs b/crates/masonry/src/text_helpers.rs
index 71a41d25d..47cdddf18 100644
--- a/crates/masonry/src/text_helpers.rs
+++ b/crates/masonry/src/text_helpers.rs
@@ -3,14 +3,11 @@
 
 //! Helper functions for working with text in Masonry.
 
+use kurbo::Rect;
 use parley::Layout;
-use vello::{
-    kurbo::Affine,
-    peniko::{Brush, Fill},
-    Scene,
-};
+use vello::{kurbo::Affine, peniko::Fill, Scene};
 
-use crate::WidgetId;
+use crate::{text2::TextBrush, WidgetId};
 
 /// A reference counted string slice.
 ///
@@ -51,8 +48,15 @@ pub enum ImeChangeSignal {
 }
 
 /// A function that renders laid out glyphs to a [Scene].
-pub fn render_text(scene: &mut Scene, transform: Affine, layout: &Layout<Brush>) {
+pub fn render_text(
+    scene: &mut Scene,
+    scratch_scene: &mut Scene,
+    transform: Affine,
+    layout: &Layout<TextBrush>,
+) {
+    scratch_scene.reset();
     for line in layout.lines() {
+        let metrics = &line.metrics();
         for glyph_run in line.glyph_runs() {
             let mut x = glyph_run.offset();
             let y = glyph_run.baseline();
@@ -69,9 +73,31 @@ pub fn render_text(scene: &mut Scene, transform: Affine, layout: &Layout<Brush>)
                 .iter()
                 .map(|coord| vello::skrifa::instance::NormalizedCoord::from_bits(*coord))
                 .collect::<Vec<_>>();
-            scene
+            let text_brush = match &style.brush {
+                TextBrush::Normal(text_brush) => text_brush,
+                TextBrush::Highlight { text, fill } => {
+                    scene.fill(
+                        Fill::EvenOdd,
+                        transform,
+                        fill,
+                        None,
+                        &Rect::from_origin_size(
+                            (
+                                glyph_run.offset() as f64,
+                                // The y coordinate is on the baseline. We want to draw from the top of the line
+                                // (Note that we are in a y-down coordinate system)
+                                (y - metrics.ascent - metrics.leading) as f64,
+                            ),
+                            (glyph_run.advance() as f64, metrics.size() as f64),
+                        ),
+                    );
+
+                    text
+                }
+            };
+            scratch_scene
                 .draw_glyphs(font)
-                .brush(&style.brush)
+                .brush(text_brush)
                 .transform(transform)
                 .glyph_transform(glyph_xform)
                 .font_size(font_size)
@@ -90,5 +116,6 @@ pub fn render_text(scene: &mut Scene, transform: Affine, layout: &Layout<Brush>)
                     }),
                 );
         }
+        scene.append(scratch_scene, None);
     }
 }
diff --git a/crates/masonry/src/widget/button.rs b/crates/masonry/src/widget/button.rs
index ae0273c38..6903d0357 100644
--- a/crates/masonry/src/widget/button.rs
+++ b/crates/masonry/src/widget/button.rs
@@ -9,9 +9,10 @@ use vello::Scene;
 
 use crate::action::Action;
 use crate::paint_scene_helpers::{fill_lin_gradient, stroke, UnitPoint};
+use crate::text2::TextStorage;
 use crate::widget::{Label, WidgetMut, WidgetPod, WidgetRef};
 use crate::{
-    theme, ArcStr, BoxConstraints, EventCtx, Insets, LayoutCtx, LifeCycle, LifeCycleCtx, PaintCtx,
+    theme, BoxConstraints, EventCtx, Insets, LayoutCtx, LifeCycle, LifeCycleCtx, PaintCtx,
     PointerEvent, Size, StatusChange, TextEvent, Widget,
 };
 
@@ -23,11 +24,11 @@ const LABEL_INSETS: Insets = Insets::uniform_xy(8., 2.);
 /// A button with a text label.
 ///
 /// Emits [`Action::ButtonPressed`] when pressed.
-pub struct Button {
-    label: WidgetPod<Label>,
+pub struct Button<T: TextStorage> {
+    label: WidgetPod<Label<T>>,
 }
 
-impl Button {
+impl<T: TextStorage> Button<T> {
     /// Create a new button with a text label.
     ///
     /// # Examples
@@ -37,7 +38,7 @@ impl Button {
     ///
     /// let button = Button::new("Increment");
     /// ```
-    pub fn new(text: impl Into<ArcStr>) -> Button {
+    pub fn new(text: T) -> Button<T> {
         Button::from_label(Label::new(text))
     }
 
@@ -49,28 +50,28 @@ impl Button {
     /// use masonry::Color;
     /// use masonry::widget::{Button, Label};
     ///
-    /// let label = Label::new("Increment").with_text_color(Color::rgb(0.5, 0.5, 0.5));
+    /// let label = Label::new("Increment").with_text_brush(Color::rgb(0.5, 0.5, 0.5));
     /// let button = Button::from_label(label);
     /// ```
-    pub fn from_label(label: Label) -> Button {
+    pub fn from_label(label: Label<T>) -> Button<T> {
         Button {
             label: WidgetPod::new(label),
         }
     }
 }
 
-impl WidgetMut<'_, Button> {
+impl<T: TextStorage> WidgetMut<'_, Button<T>> {
     /// Set the text.
-    pub fn set_text(&mut self, new_text: impl Into<ArcStr>) {
-        self.label_mut().set_text(new_text.into());
+    pub fn set_text(&mut self, new_text: T) {
+        self.label_mut().set_text(new_text);
     }
 
-    pub fn label_mut(&mut self) -> WidgetMut<'_, Label> {
+    pub fn label_mut(&mut self) -> WidgetMut<'_, Label<T>> {
         self.ctx.get_mut(&mut self.widget.label)
     }
 }
 
-impl Widget for Button {
+impl<T: TextStorage> Widget for Button<T> {
     fn on_pointer_event(&mut self, ctx: &mut EventCtx, event: &PointerEvent) {
         match event {
             PointerEvent::PointerDown(_, _) => {
@@ -181,7 +182,7 @@ impl Widget for Button {
     }
 
     fn get_debug_text(&self) -> Option<String> {
-        Some(self.label.as_ref().text().to_string())
+        Some(self.label.as_ref().text().as_str().to_string())
     }
 }
 
@@ -216,11 +217,10 @@ mod tests {
     #[test]
     fn edit_button() {
         let image_1 = {
-            let button = Button::from_label(
-                Label::new("The quick brown fox jumps over the lazy dog")
-                    .with_text_color(PRIMARY_LIGHT)
-                    .with_text_size(20.0),
-            );
+            let label = Label::new("The quick brown fox jumps over the lazy dog")
+                .with_text_brush(PRIMARY_LIGHT)
+                .with_text_size(20.0);
+            let button = Button::from_label(label);
 
             let mut harness = TestHarness::create_with_size(button, Size::new(50.0, 50.0));
 
@@ -233,12 +233,14 @@ mod tests {
             let mut harness = TestHarness::create_with_size(button, Size::new(50.0, 50.0));
 
             harness.edit_root_widget(|mut button| {
-                let mut button = button.downcast::<Button>().unwrap();
+                let mut button = button.downcast::<Button<&'static str>>().unwrap();
                 button.set_text("The quick brown fox jumps over the lazy dog");
 
                 let mut label = button.label_mut();
-                label.set_text_color(PRIMARY_LIGHT);
-                label.set_text_size(20.0);
+                label.set_text_properties(|props| {
+                    props.set_brush(PRIMARY_LIGHT);
+                    props.set_text_size(20.0);
+                });
             });
 
             harness.render()
diff --git a/crates/masonry/src/widget/checkbox.rs b/crates/masonry/src/widget/checkbox.rs
index c1c376dc8..b55c1fd11 100644
--- a/crates/masonry/src/widget/checkbox.rs
+++ b/crates/masonry/src/widget/checkbox.rs
@@ -11,6 +11,7 @@ use vello::Scene;
 use crate::action::Action;
 use crate::kurbo::{BezPath, Cap, Join, Size};
 use crate::paint_scene_helpers::{fill_lin_gradient, stroke, UnitPoint};
+use crate::text2::TextStorage;
 use crate::widget::{Label, WidgetMut, WidgetRef};
 use crate::{
     theme, ArcStr, BoxConstraints, EventCtx, LayoutCtx, LifeCycle, LifeCycleCtx, PaintCtx,
@@ -18,14 +19,14 @@ use crate::{
 };
 
 /// A checkbox that can be toggled.
-pub struct Checkbox {
+pub struct Checkbox<T: TextStorage = ArcStr> {
     checked: bool,
-    label: WidgetPod<Label>,
+    label: WidgetPod<Label<T>>,
 }
 
-impl Checkbox {
+impl<T: TextStorage> Checkbox<T> {
     /// Create a new `Checkbox` with a text label.
-    pub fn new(checked: bool, text: impl Into<ArcStr>) -> Checkbox {
+    pub fn new(checked: bool, text: T) -> Checkbox<T> {
         Checkbox {
             checked,
             label: WidgetPod::new(Label::new(text)),
@@ -33,7 +34,7 @@ impl Checkbox {
     }
 
     /// Create a new `Checkbox` with the given label.
-    pub fn from_label(checked: bool, label: Label) -> Checkbox {
+    pub fn from_label(checked: bool, label: Label<T>) -> Checkbox<T> {
         Checkbox {
             checked,
             label: WidgetPod::new(label),
@@ -41,23 +42,23 @@ impl Checkbox {
     }
 }
 
-impl WidgetMut<'_, Checkbox> {
+impl<T: TextStorage> WidgetMut<'_, Checkbox<T>> {
     pub fn set_checked(&mut self, checked: bool) {
         self.widget.checked = checked;
         self.ctx.request_paint();
     }
 
     /// Set the text.
-    pub fn set_text(&mut self, new_text: impl Into<ArcStr>) {
-        self.label_mut().set_text(new_text.into());
+    pub fn set_text(&mut self, new_text: T) {
+        self.label_mut().set_text(new_text);
     }
 
-    pub fn label_mut(&mut self) -> WidgetMut<'_, Label> {
+    pub fn label_mut(&mut self) -> WidgetMut<'_, Label<T>> {
         self.ctx.get_mut(&mut self.widget.label)
     }
 }
 
-impl Widget for Checkbox {
+impl<T: TextStorage> Widget for Checkbox<T> {
     fn on_pointer_event(&mut self, ctx: &mut EventCtx, event: &PointerEvent) {
         match event {
             PointerEvent::PointerDown(_, _) => {
@@ -177,7 +178,7 @@ impl Widget for Checkbox {
         Some(format!(
             "[{}] {}",
             if self.checked { "X" } else { " " },
-            self.label.as_ref().text()
+            self.label.as_ref().text().as_str()
         ))
     }
 }
@@ -225,7 +226,7 @@ mod tests {
             let checkbox = Checkbox::from_label(
                 true,
                 Label::new("The quick brown fox jumps over the lazy dog")
-                    .with_text_color(PRIMARY_LIGHT)
+                    .with_text_brush(PRIMARY_LIGHT)
                     .with_text_size(20.0),
             );
 
@@ -240,12 +241,12 @@ mod tests {
             let mut harness = TestHarness::create_with_size(checkbox, Size::new(50.0, 50.0));
 
             harness.edit_root_widget(|mut checkbox| {
-                let mut checkbox = checkbox.downcast::<Checkbox>().unwrap();
+                let mut checkbox = checkbox.downcast::<Checkbox<&'static str>>().unwrap();
                 checkbox.set_checked(true);
                 checkbox.set_text("The quick brown fox jumps over the lazy dog");
 
                 let mut label = checkbox.label_mut();
-                label.set_text_color(PRIMARY_LIGHT);
+                label.set_text_brush(PRIMARY_LIGHT);
                 label.set_text_size(20.0);
             });
 
diff --git a/crates/masonry/src/widget/flex.rs b/crates/masonry/src/widget/flex.rs
index 1f14f62b9..1d2ddc3c2 100644
--- a/crates/masonry/src/widget/flex.rs
+++ b/crates/masonry/src/widget/flex.rs
@@ -492,7 +492,11 @@ impl Widget for Flex {
         }
     }
 
-    fn on_text_event(&mut self, _ctx: &mut EventCtx, _event: &TextEvent) {}
+    fn on_text_event(&mut self, ctx: &mut EventCtx, event: &TextEvent) {
+        for child in self.children.iter_mut().filter_map(|x| x.widget_mut()) {
+            child.on_text_event(ctx, event);
+        }
+    }
 
     fn on_status_change(&mut self, _ctx: &mut LifeCycleCtx, _event: &StatusChange) {}
 
@@ -1370,7 +1374,12 @@ mod tests {
 
             let mut child = flex.child_mut(1).unwrap();
             assert_eq!(
-                child.downcast::<Label>().unwrap().widget.text().to_string(),
+                child
+                    .downcast::<Label<&'static str>>()
+                    .unwrap()
+                    .widget
+                    .text()
+                    .to_string(),
                 "world"
             );
             std::mem::drop(child);
diff --git a/crates/masonry/src/widget/label.rs b/crates/masonry/src/widget/label.rs
index 15b679f91..01945c670 100644
--- a/crates/masonry/src/widget/label.rs
+++ b/crates/masonry/src/widget/label.rs
@@ -1,37 +1,29 @@
 // Copyright 2019 the Xilem Authors and the Druid Authors
 // SPDX-License-Identifier: Apache-2.0
 
-//! A label widget.
-
-use kurbo::Affine;
-use parley::layout::Alignment;
-use parley::style::{FontFamily, FontStack, GenericFamily, StyleProperty};
-use parley::{FontContext, Layout};
+use kurbo::{Affine, Point, Size};
+use parley::{
+    layout::Alignment,
+    style::{FontFamily, FontStack},
+};
 use smallvec::SmallVec;
-use tracing::{trace, trace_span, Span};
-use vello::peniko::{BlendMode, Brush};
-use vello::Scene;
+use tracing::trace;
+use vello::{
+    peniko::{BlendMode, Color},
+    Scene,
+};
 
-use crate::widget::{WidgetMut, WidgetRef};
 use crate::{
-    ArcStr, BoxConstraints, Color, EventCtx, LayoutCtx, LifeCycle, LifeCycleCtx, PaintCtx,
-    PointerEvent, Size, StatusChange, TextEvent, Widget,
+    text2::{TextBrush, TextLayout, TextStorage},
+    widget::WidgetRef,
+    ArcStr, BoxConstraints, EventCtx, LayoutCtx, LifeCycle, LifeCycleCtx, PaintCtx, PointerEvent,
+    StatusChange, TextEvent, Widget,
 };
 
-// added padding between the edges of the widget and the text.
-const LABEL_X_PADDING: f64 = 2.0;
+use super::WidgetMut;
 
-/// A widget displaying non-editable text.
-pub struct Label {
-    current_text: ArcStr,
-    text_layout: Option<Layout<Brush>>,
-    text_size: f32,
-    font_family: FontFamily<'static>,
-    line_break_mode: LineBreaking,
-    disabled: bool,
-    text_color: Color,
-    alignment: Alignment,
-}
+// added padding between the edges of the widget and the text.
+pub(super) const LABEL_X_PADDING: f64 = 2.0;
 
 /// Options for handling lines that are too wide for the label.
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ -44,169 +36,163 @@ pub enum LineBreaking {
     Overflow,
 }
 
-// --- METHODS ---
+/// A widget displaying non-editable text.
+pub struct Label<T: TextStorage> {
+    text_layout: TextLayout<T>,
+    line_break_mode: LineBreaking,
+    show_disabled: bool,
+    brush: TextBrush,
+    // disabled: bool,
+}
 
-impl Label {
+impl<T: TextStorage> Label<T> {
     /// Create a new label.
-    pub fn new(text: impl Into<ArcStr>) -> Self {
-        let current_text = text.into();
+    pub fn new(text: T) -> Self {
         Self {
-            current_text,
-            text_layout: None,
-            text_color: crate::theme::TEXT_COLOR,
-            text_size: crate::theme::TEXT_SIZE_NORMAL as f32,
-            font_family: FontFamily::Generic(GenericFamily::SystemUi),
+            text_layout: TextLayout::new(text, crate::theme::TEXT_SIZE_NORMAL as f32),
             line_break_mode: LineBreaking::Overflow,
-            disabled: false,
-            alignment: Alignment::Start,
+            show_disabled: true,
+            brush: crate::theme::TEXT_COLOR.into(),
         }
     }
 
-    /// Create a label with empty text.
-    pub fn empty() -> Self {
-        Self::new("")
+    pub fn text(&self) -> &T {
+        self.text_layout.text()
     }
 
-    // TODO - Rename methods
-    /// Builder-style method for setting the text string.
-    pub fn with_text(mut self, new_text: impl Into<ArcStr>) -> Self {
-        self.current_text = new_text.into();
-        // TODO - Rethink how layout caching works during the builder phase
-        self.text_layout = None;
+    #[doc(alias = "with_text_color")]
+    pub fn with_text_brush(mut self, color: Color) -> Self {
+        self.text_layout.set_brush(color);
         self
     }
 
-    /// Builder-style method for setting the text color.
-    pub fn with_text_color(mut self, color: impl Into<Color>) -> Self {
-        self.text_color = color.into();
+    pub fn with_text_size(mut self, size: f32) -> Self {
+        self.text_layout.set_text_size(size);
         self
     }
 
-    /// Builder-style method for setting the text size.
-    pub fn with_text_size(mut self, size: impl Into<f32>) -> Self {
-        self.text_size = size.into();
+    pub fn with_text_alignment(mut self, alignment: Alignment) -> Self {
+        self.text_layout.set_text_alignment(alignment);
         self
     }
 
-    /// Builder-style method for setting the font.
-    pub fn with_font_family(mut self, font_family: impl Into<FontFamily<'static>>) -> Self {
-        self.font_family = font_family.into();
+    pub fn with_font(mut self, font: FontStack<'static>) -> Self {
+        self.text_layout.set_font(font);
         self
     }
-
-    /// Builder-style method to set the [`LineBreaking`] behaviour.
-    pub fn with_line_break_mode(mut self, mode: LineBreaking) -> Self {
-        self.line_break_mode = mode;
-        self
+    pub fn with_font_family(self, font: FontFamily<'static>) -> Self {
+        self.with_font(FontStack::Single(font))
     }
 
-    /// Builder-style method to set the [`Alignment`].
-    pub fn with_text_alignment(mut self, alignment: Alignment) -> Self {
-        self.alignment = alignment;
+    pub fn with_line_break_mode(mut self, line_break_mode: LineBreaking) -> Self {
+        self.line_break_mode = line_break_mode;
         self
     }
+}
 
-    /// Builder-style method to disable this label.
-    pub fn with_disabled(mut self, disabled: bool) -> Self {
-        self.disabled = disabled;
-        self
+impl Label<ArcStr> {
+    /// Create a label with empty text.
+    pub fn empty() -> Self {
+        Self::new("".into())
     }
+}
 
-    /// Return the current value of the label's text.
-    pub fn text(&self) -> ArcStr {
-        self.current_text.clone()
+impl<T: TextStorage> WidgetMut<'_, Label<T>> {
+    pub fn text(&self) -> &T {
+        self.widget.text_layout.text()
     }
 
-    #[cfg(FALSE)]
-    /// Return the offset of the first baseline relative to the bottom of the widget.
-    pub fn baseline_offset(&self) -> f64 {
-        let text_metrics = self.text_layout.layout_metrics();
-        text_metrics.size.height - text_metrics.first_baseline
+    pub fn set_text_properties<R>(&mut self, f: impl FnOnce(&mut TextLayout<T>) -> R) -> R {
+        let ret = f(&mut self.widget.text_layout);
+        if self.widget.text_layout.needs_rebuild() {
+            self.ctx.request_layout();
+        }
+        ret
     }
 
-    fn get_layout_mut(&mut self, font_cx: &mut FontContext) -> &mut Layout<Brush> {
-        let color = if self.disabled {
-            crate::theme::DISABLED_TEXT_COLOR
-        } else {
-            self.text_color
-        };
-        let mut lcx = parley::LayoutContext::new();
-        let mut layout_builder = lcx.ranged_builder(font_cx, &self.current_text, 1.0);
-
-        layout_builder.push_default(&StyleProperty::FontStack(FontStack::Single(
-            self.font_family,
-        )));
-        layout_builder.push_default(&StyleProperty::FontSize(self.text_size));
-        layout_builder.push_default(&StyleProperty::Brush(Brush::Solid(color)));
-
-        // TODO - Refactor. This code is mostly copy-pasted from Xilem's text widget
-        // Not super elegant.
-        self.text_layout = Some(layout_builder.build());
-        self.text_layout.as_mut().unwrap()
+    pub fn set_text(&mut self, new_text: T) {
+        self.set_text_properties(|layout| layout.set_text(new_text));
     }
-}
 
-impl WidgetMut<'_, Label> {
-    /// Set the text.
-    pub fn set_text(&mut self, new_text: impl Into<ArcStr>) {
-        self.widget.current_text = new_text.into();
-        self.widget.text_layout = None;
-        self.ctx.request_layout();
+    #[doc(alias = "set_text_color")]
+    pub fn set_text_brush(&mut self, brush: impl Into<TextBrush>) {
+        let brush = brush.into();
+        self.widget.brush = brush;
+        if !self.ctx.is_disabled() {
+            let brush = self.widget.brush.clone();
+            self.set_text_properties(|layout| layout.set_brush(brush));
+        }
     }
-
-    /// Set the text color.
-    pub fn set_text_color(&mut self, color: impl Into<Color>) {
-        self.widget.text_color = color.into();
-        self.ctx.request_layout();
+    pub fn set_text_size(&mut self, size: f32) {
+        self.set_text_properties(|layout| layout.set_text_size(size));
     }
-
-    /// Set the text size.
-    pub fn set_text_size(&mut self, size: impl Into<f32>) {
-        self.widget.text_size = size.into();
-        self.ctx.request_layout();
+    pub fn set_alignment(&mut self, alignment: Alignment) {
+        self.set_text_properties(|layout| layout.set_text_alignment(alignment));
     }
-
-    /// Set the font.
-    pub fn set_font_family(&mut self, font_family: impl Into<FontFamily<'static>>) {
-        self.widget.font_family = font_family.into();
-        self.ctx.request_layout();
+    pub fn set_font(&mut self, font_stack: FontStack<'static>) {
+        self.set_text_properties(|layout| layout.set_font(font_stack));
     }
-
-    /// Set the [`LineBreaking`] behaviour.
-    pub fn set_line_break_mode(&mut self, mode: LineBreaking) {
-        self.widget.line_break_mode = mode;
-        self.ctx.request_layout();
-    }
-
-    /// Set the [`Alignment`] for this layout.
-    pub fn set_text_alignment(&mut self, alignment: Alignment) {
-        self.widget.alignment = alignment;
-        self.ctx.request_layout();
+    pub fn set_font_family(&mut self, family: FontFamily<'static>) {
+        self.set_font(FontStack::Single(family));
     }
-
-    /// Set disabled
-    pub fn set_disabled(&mut self, disabled: bool) {
-        self.widget.disabled = disabled;
-        // TODO: only request_paint necessary?
-        self.ctx.request_layout();
+    pub fn set_line_break_mode(&mut self, line_break_mode: LineBreaking) {
+        self.widget.line_break_mode = line_break_mode;
+        self.ctx.request_paint();
     }
 }
 
-// --- TRAIT IMPLS ---
-
-impl Widget for Label {
-    fn on_pointer_event(&mut self, _ctx: &mut EventCtx, _event: &PointerEvent) {}
+impl<T: TextStorage> Widget for Label<T> {
+    fn on_pointer_event(&mut self, _ctx: &mut EventCtx, event: &PointerEvent) {
+        match event {
+            PointerEvent::PointerMove(_point) => {
+                // TODO: Set cursor if over link
+            }
+            PointerEvent::PointerDown(_button, _state) => {
+                // TODO: Start tracking currently pressed link
+                // (i.e. don't press)
+            }
+            PointerEvent::PointerUp(_button, _state) => {
+                // TODO: Follow link (if not now dragging ?)
+            }
+            _ => {}
+        }
+    }
 
-    fn on_text_event(&mut self, _ctx: &mut EventCtx, _event: &TextEvent) {}
+    fn on_text_event(&mut self, _ctx: &mut EventCtx, _event: &TextEvent) {
+        // If focused on a link and enter pressed, follow it?
+        // TODO: This sure looks like each link needs its own widget, although I guess the challenge there is
+        // that the bounding boxes can go e.g. across line boundaries?
+    }
 
-    fn on_status_change(&mut self, _ctx: &mut LifeCycleCtx, _event: &StatusChange) {}
+    #[allow(missing_docs)]
+    fn on_status_change(&mut self, _ctx: &mut LifeCycleCtx, event: &StatusChange) {
+        match event {
+            StatusChange::FocusChanged(_) => {
+                // TODO: Focus on first link
+            }
+            _ => {}
+        }
+    }
 
     fn lifecycle(&mut self, ctx: &mut LifeCycleCtx, event: &LifeCycle) {
         match event {
-            LifeCycle::DisabledChanged(_) => {
-                // TODO - only request paint
+            LifeCycle::DisabledChanged(disabled) => {
+                if self.show_disabled {
+                    if *disabled {
+                        self.text_layout
+                            .set_brush(crate::theme::DISABLED_TEXT_COLOR);
+                    } else {
+                        self.text_layout.set_brush(self.brush.clone());
+                    }
+                }
+                // TODO: Parley seems to require a relayout when colours change
                 ctx.request_layout();
             }
+            LifeCycle::BuildFocusChain => {
+                if !self.text_layout.text().links().is_empty() {
+                    tracing::warn!("Links present in text, but not yet integrated");
+                }
+            }
             _ => {}
         }
     }
@@ -222,18 +208,17 @@ impl Widget for Label {
         } else {
             None
         };
-
-        // TODO - Handle baseline
-
-        // Lay text out
-        let alignment = self.alignment;
-        let layout = self.get_layout_mut(ctx.font_ctx());
-        layout.break_all_lines(max_advance, alignment);
-        let size = Size {
-            width: layout.width() as f64 + 2. * LABEL_X_PADDING,
-            height: layout.height() as f64,
+        self.text_layout.set_max_advance(max_advance);
+        if self.text_layout.needs_rebuild() {
+            self.text_layout.rebuild(ctx.font_ctx());
+        }
+        // We ignore trailing whitespace for a label
+        let text_size = self.text_layout.size();
+        let label_size = Size {
+            height: text_size.height,
+            width: text_size.width + 2. * LABEL_X_PADDING,
         };
-        let size = bc.constrain(size);
+        let size = bc.constrain(label_size);
         trace!(
             "Computed layout: max={:?}. w={}, h={}",
             max_advance,
@@ -244,21 +229,18 @@ impl Widget for Label {
     }
 
     fn paint(&mut self, ctx: &mut PaintCtx, scene: &mut Scene) {
-        if let Some(text_layout) = &self.text_layout {
-            if self.line_break_mode == LineBreaking::Clip {
-                let clip_rect = ctx.size().to_rect();
-                scene.push_layer(BlendMode::default(), 1., Affine::IDENTITY, &clip_rect);
-            }
-
-            crate::text_helpers::render_text(
-                scene,
-                Affine::translate((LABEL_X_PADDING, 0.)),
-                text_layout,
-            );
+        if self.text_layout.needs_rebuild() {
+            debug_panic!("Called Label paint before layout");
+        }
+        if self.line_break_mode == LineBreaking::Clip {
+            let clip_rect = ctx.size().to_rect();
+            scene.push_layer(BlendMode::default(), 1., Affine::IDENTITY, &clip_rect);
+        }
+        self.text_layout
+            .draw(scene, Point::new(LABEL_X_PADDING, 0.0));
 
-            if self.line_break_mode == LineBreaking::Clip {
-                scene.pop_layer();
-            }
+        if self.line_break_mode == LineBreaking::Clip {
+            scene.pop_layer();
         }
     }
 
@@ -266,19 +248,15 @@ impl Widget for Label {
         SmallVec::new()
     }
 
-    fn make_trace_span(&self) -> Span {
-        trace_span!("Label")
-    }
-
     fn get_debug_text(&self) -> Option<String> {
-        Some(self.current_text.to_string())
+        Some(self.text_layout.text().as_str().to_string())
     }
 }
 
-// TODO - reenable tests
 #[cfg(test)]
 mod tests {
     use insta::assert_debug_snapshot;
+    use parley::style::GenericFamily;
 
     use super::*;
     use crate::assert_render_snapshot;
@@ -299,7 +277,7 @@ mod tests {
     #[test]
     fn styled_label() {
         let label = Label::new("The quick brown fox jumps over the lazy dog")
-            .with_text_color(PRIMARY_LIGHT)
+            .with_text_brush(PRIMARY_LIGHT)
             .with_font_family(FontFamily::Generic(GenericFamily::Monospace))
             .with_text_size(20.0)
             .with_line_break_mode(LineBreaking::WordWrap)
@@ -348,7 +326,7 @@ mod tests {
     fn edit_label() {
         let image_1 = {
             let label = Label::new("The quick brown fox jumps over the lazy dog")
-                .with_text_color(PRIMARY_LIGHT)
+                .with_text_brush(PRIMARY_LIGHT)
                 .with_font_family(FontFamily::Generic(GenericFamily::Monospace))
                 .with_text_size(20.0)
                 .with_line_break_mode(LineBreaking::WordWrap)
@@ -361,19 +339,19 @@ mod tests {
 
         let image_2 = {
             let label = Label::new("Hello world")
-                .with_text_color(PRIMARY_DARK)
+                .with_text_brush(PRIMARY_DARK)
                 .with_text_size(40.0);
 
             let mut harness = TestHarness::create_with_size(label, Size::new(50.0, 50.0));
 
             harness.edit_root_widget(|mut label| {
-                let mut label = label.downcast::<Label>().unwrap();
+                let mut label = label.downcast::<Label<&'static str>>().unwrap();
                 label.set_text("The quick brown fox jumps over the lazy dog");
-                label.set_text_color(PRIMARY_LIGHT);
+                label.set_text_brush(PRIMARY_LIGHT);
                 label.set_font_family(FontFamily::Generic(GenericFamily::Monospace));
                 label.set_text_size(20.0);
                 label.set_line_break_mode(LineBreaking::WordWrap);
-                label.set_text_alignment(Alignment::Middle);
+                label.set_alignment(Alignment::Middle);
             });
 
             harness.render()
diff --git a/crates/masonry/src/widget/mod.rs b/crates/masonry/src/widget/mod.rs
index 100f4c477..e667ecc99 100644
--- a/crates/masonry/src/widget/mod.rs
+++ b/crates/masonry/src/widget/mod.rs
@@ -20,10 +20,12 @@ mod flex;
 mod image;
 mod label;
 mod portal;
+mod prose;
 mod scroll_bar;
 mod sized_box;
 mod spinner;
 mod split;
+mod textbox;
 
 pub use self::image::Image;
 pub use align::Align;
@@ -32,10 +34,12 @@ pub use checkbox::Checkbox;
 pub use flex::{Axis, CrossAxisAlignment, Flex, FlexParams, MainAxisAlignment};
 pub use label::{Label, LineBreaking};
 pub use portal::Portal;
+pub use prose::Prose;
 pub use scroll_bar::ScrollBar;
 pub use sized_box::SizedBox;
 pub use spinner::Spinner;
 pub use split::Split;
+pub use textbox::Textbox;
 pub use widget_mut::WidgetMut;
 pub use widget_pod::WidgetPod;
 pub use widget_ref::WidgetRef;
diff --git a/crates/masonry/src/widget/portal.rs b/crates/masonry/src/widget/portal.rs
index 6a9ad7d0a..bb534198c 100644
--- a/crates/masonry/src/widget/portal.rs
+++ b/crates/masonry/src/widget/portal.rs
@@ -397,7 +397,7 @@ mod tests {
     use crate::testing::{widget_ids, TestHarness};
     use crate::widget::{Button, Flex, SizedBox};
 
-    fn button(text: &str) -> impl Widget {
+    fn button(text: &'static str) -> impl Widget {
         SizedBox::new(Button::new(text)).width(70.0).height(40.0)
     }
 
diff --git a/crates/masonry/src/widget/prose.rs b/crates/masonry/src/widget/prose.rs
new file mode 100644
index 000000000..00e032254
--- /dev/null
+++ b/crates/masonry/src/widget/prose.rs
@@ -0,0 +1,271 @@
+// Copyright 2018 the Xilem Authors and the Druid Authors
+// SPDX-License-Identifier: Apache-2.0
+
+use kurbo::{Affine, Point, Size};
+use parley::{
+    layout::Alignment,
+    style::{FontFamily, FontStack},
+};
+use smallvec::SmallVec;
+use tracing::trace;
+use vello::{peniko::BlendMode, Scene};
+
+use crate::{
+    text2::{Selectable, TextBrush, TextWithSelection},
+    widget::label::LABEL_X_PADDING,
+    BoxConstraints, EventCtx, LayoutCtx, LifeCycle, LifeCycleCtx, PaintCtx, PointerEvent,
+    StatusChange, TextEvent, Widget,
+};
+
+use super::{LineBreaking, WidgetMut, WidgetRef};
+
+/// The prose widget is a widget which displays text which can be
+/// selected with keyboard and mouse, and which can be copied from,
+/// but cannot be modified by the user.
+///
+/// This should be preferred over [`Label`](super::Label) for most
+/// immutable text, other than that within
+pub struct Prose<T: Selectable> {
+    text_layout: TextWithSelection<T>,
+    line_break_mode: LineBreaking,
+    show_disabled: bool,
+    brush: TextBrush,
+}
+
+impl<T: Selectable> Prose<T> {
+    pub fn new(text: T) -> Self {
+        Prose {
+            text_layout: TextWithSelection::new(text, crate::theme::TEXT_SIZE_NORMAL as f32),
+            line_break_mode: LineBreaking::WordWrap,
+            show_disabled: true,
+            brush: crate::theme::TEXT_COLOR.into(),
+        }
+    }
+
+    // TODO: Can we reduce code duplication with `Label` widget somehow?
+    pub fn text(&self) -> &T {
+        self.text_layout.text()
+    }
+
+    #[doc(alias = "with_text_color")]
+    pub fn with_text_brush(mut self, brush: impl Into<TextBrush>) -> Self {
+        self.brush = brush.into();
+        self.text_layout.set_brush(self.brush.clone());
+        self
+    }
+
+    pub fn with_text_size(mut self, size: f32) -> Self {
+        self.text_layout.set_text_size(size);
+        self
+    }
+
+    pub fn with_text_alignment(mut self, alignment: Alignment) -> Self {
+        self.text_layout.set_text_alignment(alignment);
+        self
+    }
+
+    pub fn with_font(mut self, font: FontStack<'static>) -> Self {
+        self.text_layout.set_font(font);
+        self
+    }
+    pub fn with_font_family(self, font: FontFamily<'static>) -> Self {
+        self.with_font(FontStack::Single(font))
+    }
+
+    pub fn with_line_break_mode(mut self, line_break_mode: LineBreaking) -> Self {
+        self.line_break_mode = line_break_mode;
+        self
+    }
+}
+
+impl<T: Selectable> WidgetMut<'_, Prose<T>> {
+    pub fn text(&self) -> &T {
+        self.widget.text_layout.text()
+    }
+
+    pub fn set_text_properties<R>(&mut self, f: impl FnOnce(&mut TextWithSelection<T>) -> R) -> R {
+        let ret = f(&mut self.widget.text_layout);
+        if self.widget.text_layout.needs_rebuild() {
+            self.ctx.request_layout();
+        }
+        ret
+    }
+
+    pub fn set_text(&mut self, new_text: T) {
+        self.set_text_properties(|layout| layout.set_text(new_text));
+    }
+
+    #[doc(alias = "set_text_color")]
+    pub fn set_text_brush(&mut self, brush: impl Into<TextBrush>) {
+        let brush = brush.into();
+        self.widget.brush = brush;
+        if !self.ctx.is_disabled() {
+            let brush = self.widget.brush.clone();
+            self.set_text_properties(|layout| layout.set_brush(brush));
+        }
+    }
+    pub fn set_text_size(&mut self, size: f32) {
+        self.set_text_properties(|layout| layout.set_text_size(size));
+    }
+    pub fn set_alignment(&mut self, alignment: Alignment) {
+        self.set_text_properties(|layout| layout.set_text_alignment(alignment));
+    }
+    pub fn set_font(&mut self, font_stack: FontStack<'static>) {
+        self.set_text_properties(|layout| layout.set_font(font_stack));
+    }
+    pub fn set_font_family(&mut self, family: FontFamily<'static>) {
+        self.set_font(FontStack::Single(family));
+    }
+    pub fn set_line_break_mode(&mut self, line_break_mode: LineBreaking) {
+        self.widget.line_break_mode = line_break_mode;
+        self.ctx.request_paint();
+    }
+}
+
+impl<T: Selectable> Widget for Prose<T> {
+    fn on_pointer_event(&mut self, ctx: &mut EventCtx, event: &PointerEvent) {
+        let window_origin = ctx.widget_state.window_origin();
+        let inner_origin = Point::new(window_origin.x + LABEL_X_PADDING, window_origin.y);
+        match event {
+            PointerEvent::PointerDown(button, state) => {
+                if !ctx.is_disabled() {
+                    // TODO: Start tracking currently pressed link?
+                    let made_change = self.text_layout.pointer_down(inner_origin, state, *button);
+                    if made_change {
+                        ctx.request_layout();
+                        ctx.request_paint();
+                        ctx.request_focus();
+                        ctx.set_active(true);
+                    }
+                }
+            }
+            PointerEvent::PointerMove(state) => {
+                if !ctx.is_disabled() {
+                    // TODO: Set cursor if over link
+                    ctx.set_cursor(&winit::window::CursorIcon::Text);
+                    if ctx.is_active() && self.text_layout.pointer_move(inner_origin, state) {
+                        // We might have changed text colours, so we need to re-request a layout
+                        ctx.request_layout();
+                        ctx.request_paint();
+                    }
+                }
+            }
+            PointerEvent::PointerUp(button, state) => {
+                // TODO: Follow link (if not now dragging ?)
+                if !ctx.is_disabled() && ctx.is_active() {
+                    self.text_layout.pointer_up(inner_origin, state, *button);
+                }
+                ctx.set_active(false);
+            }
+            PointerEvent::PointerLeave(_state) => {
+                ctx.set_active(false);
+            }
+            _ => {}
+        }
+    }
+
+    fn on_text_event(&mut self, ctx: &mut EventCtx, event: &TextEvent) {
+        // If focused on a link and enter pressed, follow it?
+        let result = self.text_layout.text_event(event);
+        if result.is_handled() {
+            ctx.set_handled();
+            // TODO: only some handlers need this repaint
+            ctx.request_layout();
+            ctx.request_paint();
+        }
+    }
+
+    #[allow(missing_docs)]
+    fn on_status_change(&mut self, ctx: &mut LifeCycleCtx, event: &StatusChange) {
+        match event {
+            StatusChange::FocusChanged(false) => {
+                self.text_layout.focus_lost();
+                ctx.request_layout();
+                // TODO: Stop focusing on any links
+            }
+            StatusChange::FocusChanged(true) => {
+                // TODO: Focus on first link
+            }
+            _ => {}
+        }
+    }
+
+    fn lifecycle(&mut self, ctx: &mut LifeCycleCtx, event: &LifeCycle) {
+        match event {
+            LifeCycle::DisabledChanged(disabled) => {
+                if self.show_disabled {
+                    if *disabled {
+                        self.text_layout
+                            .set_brush(crate::theme::DISABLED_TEXT_COLOR);
+                    } else {
+                        self.text_layout.set_brush(self.brush.clone());
+                    }
+                }
+                // TODO: Parley seems to require a relayout when colours change
+                ctx.request_layout();
+            }
+            LifeCycle::BuildFocusChain => {
+                if !self.text_layout.text().links().is_empty() {
+                    tracing::warn!("Links present in text, but not yet integrated");
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn layout(&mut self, ctx: &mut LayoutCtx, bc: &BoxConstraints) -> Size {
+        // Compute max_advance from box constraints
+        let max_advance = if self.line_break_mode != LineBreaking::WordWrap {
+            None
+        } else if bc.max().width.is_finite() {
+            // TODO: Does Prose have different needs here?
+            Some(bc.max().width as f32 - 2. * LABEL_X_PADDING as f32)
+        } else if bc.min().width.is_sign_negative() {
+            Some(0.0)
+        } else {
+            None
+        };
+        self.text_layout.set_max_advance(max_advance);
+        if self.text_layout.needs_rebuild() {
+            self.text_layout.rebuild(ctx.font_ctx());
+        }
+        // We ignore trailing whitespace for a label
+        let text_size = self.text_layout.size();
+        let label_size = Size {
+            height: text_size.height,
+            width: text_size.width + 2. * LABEL_X_PADDING,
+        };
+        let size = bc.constrain(label_size);
+        trace!(
+            "Computed layout: max={:?}. w={}, h={}",
+            max_advance,
+            size.width,
+            size.height,
+        );
+        size
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, scene: &mut Scene) {
+        if self.text_layout.needs_rebuild() {
+            debug_panic!("Called Label paint before layout");
+        }
+        if self.line_break_mode == LineBreaking::Clip {
+            let clip_rect = ctx.size().to_rect();
+            scene.push_layer(BlendMode::default(), 1., Affine::IDENTITY, &clip_rect);
+        }
+        self.text_layout
+            .draw(scene, Point::new(LABEL_X_PADDING, 0.0));
+
+        if self.line_break_mode == LineBreaking::Clip {
+            scene.pop_layer();
+        }
+    }
+
+    fn children(&self) -> SmallVec<[WidgetRef<'_, dyn Widget>; 16]> {
+        SmallVec::new()
+    }
+
+    fn get_debug_text(&self) -> Option<String> {
+        Some(self.text_layout.text().as_str().chars().take(100).collect())
+    }
+}
diff --git a/crates/masonry/src/widget/textbox.rs b/crates/masonry/src/widget/textbox.rs
new file mode 100644
index 000000000..c587663a1
--- /dev/null
+++ b/crates/masonry/src/widget/textbox.rs
@@ -0,0 +1,284 @@
+// Copyright 2018 the Xilem Authors and the Druid Authors
+// SPDX-License-Identifier: Apache-2.0
+
+use kurbo::{Affine, Point, Size, Stroke};
+use parley::{
+    layout::Alignment,
+    style::{FontFamily, FontStack},
+};
+use smallvec::SmallVec;
+use tracing::trace;
+use vello::{
+    peniko::{BlendMode, Color},
+    Scene,
+};
+
+use crate::{
+    text2::{EditableText, TextBrush, TextEditor, TextWithSelection},
+    BoxConstraints, EventCtx, LayoutCtx, LifeCycle, LifeCycleCtx, PaintCtx, PointerEvent,
+    StatusChange, TextEvent, Widget,
+};
+
+use super::{LineBreaking, WidgetMut, WidgetRef};
+
+const TEXTBOX_PADDING: f64 = 4.0;
+
+/// The textbox widget is a widget which shows text which can be edited by the user
+///
+/// For immutable text [`Prose`](super::Prose) should be preferred
+pub struct Textbox<T: EditableText> {
+    editor: TextEditor<T>,
+    line_break_mode: LineBreaking,
+    show_disabled: bool,
+    brush: TextBrush,
+}
+
+impl<T: EditableText> Textbox<T> {
+    pub fn new(text: T) -> Self {
+        Textbox {
+            editor: TextEditor::new(text, crate::theme::TEXT_SIZE_NORMAL as f32),
+            line_break_mode: LineBreaking::WordWrap,
+            show_disabled: true,
+            brush: crate::theme::TEXT_COLOR.into(),
+        }
+    }
+
+    // TODO: Can we reduce code duplication with `Label` widget somehow?
+    pub fn text(&self) -> &T {
+        self.editor.text()
+    }
+
+    #[doc(alias = "with_text_color")]
+    pub fn with_text_brush(mut self, brush: impl Into<TextBrush>) -> Self {
+        self.brush = brush.into();
+        self.editor.set_brush(self.brush.clone());
+        self
+    }
+
+    pub fn with_text_size(mut self, size: f32) -> Self {
+        self.editor.set_text_size(size);
+        self
+    }
+
+    pub fn with_text_alignment(mut self, alignment: Alignment) -> Self {
+        self.editor.set_text_alignment(alignment);
+        self
+    }
+
+    pub fn with_font(mut self, font: FontStack<'static>) -> Self {
+        self.editor.set_font(font);
+        self
+    }
+    pub fn with_font_family(self, font: FontFamily<'static>) -> Self {
+        self.with_font(FontStack::Single(font))
+    }
+
+    pub fn with_line_break_mode(mut self, line_break_mode: LineBreaking) -> Self {
+        self.line_break_mode = line_break_mode;
+        self
+    }
+}
+
+impl<T: EditableText> WidgetMut<'_, Textbox<T>> {
+    pub fn text(&self) -> &T {
+        self.widget.editor.text()
+    }
+
+    pub fn set_text_properties<R>(&mut self, f: impl FnOnce(&mut TextWithSelection<T>) -> R) -> R {
+        let ret = f(&mut self.widget.editor);
+        if self.widget.editor.needs_rebuild() {
+            self.ctx.request_layout();
+        }
+        ret
+    }
+
+    pub fn set_text(&mut self, new_text: T) {
+        self.set_text_properties(|layout| layout.set_text(new_text));
+    }
+
+    #[doc(alias = "set_text_color")]
+    pub fn set_text_brush(&mut self, brush: impl Into<TextBrush>) {
+        let brush = brush.into();
+        self.widget.brush = brush;
+        if !self.ctx.is_disabled() {
+            let brush = self.widget.brush.clone();
+            self.set_text_properties(|layout| layout.set_brush(brush));
+        }
+    }
+    pub fn set_text_size(&mut self, size: f32) {
+        self.set_text_properties(|layout| layout.set_text_size(size));
+    }
+    pub fn set_alignment(&mut self, alignment: Alignment) {
+        self.set_text_properties(|layout| layout.set_text_alignment(alignment));
+    }
+    pub fn set_font(&mut self, font_stack: FontStack<'static>) {
+        self.set_text_properties(|layout| layout.set_font(font_stack));
+    }
+    pub fn set_font_family(&mut self, family: FontFamily<'static>) {
+        self.set_font(FontStack::Single(family));
+    }
+    pub fn set_line_break_mode(&mut self, line_break_mode: LineBreaking) {
+        self.widget.line_break_mode = line_break_mode;
+        self.ctx.request_paint();
+    }
+}
+
+impl<T: EditableText> Widget for Textbox<T> {
+    fn on_pointer_event(&mut self, ctx: &mut EventCtx, event: &PointerEvent) {
+        let window_origin = ctx.widget_state.window_origin();
+        let inner_origin = Point::new(
+            window_origin.x + TEXTBOX_PADDING,
+            window_origin.y + TEXTBOX_PADDING,
+        );
+        match event {
+            PointerEvent::PointerDown(button, state) => {
+                if !ctx.is_disabled() {
+                    // TODO: Start tracking currently pressed link?
+                    let made_change = self.editor.pointer_down(inner_origin, state, *button);
+                    if made_change {
+                        ctx.request_layout();
+                        ctx.request_paint();
+                        ctx.request_focus();
+                        ctx.set_active(true);
+                    }
+                }
+            }
+            PointerEvent::PointerMove(state) => {
+                if !ctx.is_disabled() {
+                    // TODO: Set cursor if over link
+                    ctx.set_cursor(&winit::window::CursorIcon::Text);
+                    if ctx.is_active() && self.editor.pointer_move(inner_origin, state) {
+                        // We might have changed text colours, so we need to re-request a layout
+                        ctx.request_layout();
+                        ctx.request_paint();
+                    }
+                }
+            }
+            PointerEvent::PointerUp(button, state) => {
+                // TODO: Follow link (if not now dragging ?)
+                if !ctx.is_disabled() && ctx.is_active() {
+                    self.editor.pointer_up(inner_origin, state, *button);
+                }
+                ctx.set_active(false);
+            }
+            PointerEvent::PointerLeave(_state) => {
+                ctx.set_active(false);
+            }
+            _ => {}
+        }
+    }
+
+    fn on_text_event(&mut self, ctx: &mut EventCtx, event: &TextEvent) {
+        let result = self.editor.text_event(event);
+        // If focused on a link and enter pressed, follow it?
+        if result.is_handled() {
+            ctx.set_handled();
+            // TODO: only some handlers need this repaint
+            ctx.request_layout();
+            ctx.request_paint();
+        }
+    }
+
+    #[allow(missing_docs)]
+    fn on_status_change(&mut self, ctx: &mut LifeCycleCtx, event: &StatusChange) {
+        match event {
+            StatusChange::FocusChanged(false) => {
+                self.editor.focus_lost();
+                ctx.request_layout();
+                // TODO: Stop focusing on any links
+            }
+            StatusChange::FocusChanged(true) => {
+                // TODO: Focus on first link
+            }
+            _ => {}
+        }
+    }
+
+    fn lifecycle(&mut self, ctx: &mut LifeCycleCtx, event: &LifeCycle) {
+        match event {
+            LifeCycle::DisabledChanged(disabled) => {
+                if self.show_disabled {
+                    if *disabled {
+                        self.editor.set_brush(crate::theme::DISABLED_TEXT_COLOR);
+                    } else {
+                        self.editor.set_brush(self.brush.clone());
+                    }
+                }
+                // TODO: Parley seems to require a relayout when colours change
+                ctx.request_layout();
+            }
+            LifeCycle::BuildFocusChain => {
+                if !self.editor.text().links().is_empty() {
+                    tracing::warn!("Links present in text, but not yet integrated");
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn layout(&mut self, ctx: &mut LayoutCtx, bc: &BoxConstraints) -> Size {
+        // Compute max_advance from box constraints
+        let max_advance = if self.line_break_mode != LineBreaking::WordWrap {
+            None
+        } else if bc.max().width.is_finite() {
+            // TODO: Does Prose have different needs here?
+            Some(bc.max().width as f32 - 2. * TEXTBOX_PADDING as f32)
+        } else if bc.min().width.is_sign_negative() {
+            Some(0.0)
+        } else {
+            None
+        };
+        self.editor.set_max_advance(max_advance);
+        if self.editor.needs_rebuild() {
+            self.editor.rebuild(ctx.font_ctx());
+        }
+        // We ignore trailing whitespace for a label
+        let text_size = self.editor.size();
+        let label_size = Size {
+            height: text_size.height + 2. * TEXTBOX_PADDING,
+            // TODO: Better heuristic here?
+            width: bc.max().width - 20.,
+        };
+        let size = bc.constrain(label_size);
+        trace!(
+            "Computed layout: max={:?}. w={}, h={}",
+            max_advance,
+            size.width,
+            size.height,
+        );
+        size
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, scene: &mut Scene) {
+        if self.editor.needs_rebuild() {
+            debug_panic!("Called Label paint before layout");
+        }
+        if self.line_break_mode == LineBreaking::Clip {
+            let clip_rect = ctx.size().to_rect();
+            scene.push_layer(BlendMode::default(), 1., Affine::IDENTITY, &clip_rect);
+        }
+
+        self.editor
+            .draw(scene, Point::new(TEXTBOX_PADDING, TEXTBOX_PADDING));
+
+        let outline_rect = ctx.size().to_rect().inset(1.0);
+        scene.stroke(
+            &Stroke::new(1.0),
+            Affine::IDENTITY,
+            Color::WHITE,
+            None,
+            &outline_rect,
+        );
+        if self.line_break_mode == LineBreaking::Clip {
+            scene.pop_layer();
+        }
+    }
+
+    fn children(&self) -> SmallVec<[WidgetRef<'_, dyn Widget>; 16]> {
+        SmallVec::new()
+    }
+
+    fn get_debug_text(&self) -> Option<String> {
+        Some(self.editor.text().as_str().chars().take(100).collect())
+    }
+}
diff --git a/crates/masonry/src/widget/widget_ref.rs b/crates/masonry/src/widget/widget_ref.rs
index 504435dfd..8d6f03efd 100644
--- a/crates/masonry/src/widget/widget_ref.rs
+++ b/crates/masonry/src/widget/widget_ref.rs
@@ -216,9 +216,9 @@ mod tests {
         let label = WidgetPod::new(Label::new("Hello"));
         let dyn_widget: WidgetRef<dyn Widget> = label.as_dyn();
 
-        let label = dyn_widget.downcast::<Label>();
+        let label = dyn_widget.downcast::<Label<&'static str>>();
         assert_matches!(label, Some(_));
-        let label = dyn_widget.downcast::<Button>();
+        let label = dyn_widget.downcast::<Button<&'static str>>();
         assert_matches!(label, None);
     }
 
@@ -229,7 +229,17 @@ mod tests {
 
         let harness = TestHarness::create(label);
 
-        assert_matches!(harness.get_widget(label_id).downcast::<Label>(), Some(_));
-        assert_matches!(harness.get_widget(label_id).downcast::<Button>(), None);
+        assert_matches!(
+            harness
+                .get_widget(label_id)
+                .downcast::<Label<&'static str>>(),
+            Some(_)
+        );
+        assert_matches!(
+            harness
+                .get_widget(label_id)
+                .downcast::<Button<&'static str>>(),
+            None
+        );
     }
 }
diff --git a/crates/xilem_masonry/examples/mason.rs b/crates/xilem_masonry/examples/mason.rs
index 9988f9624..052130cf5 100644
--- a/crates/xilem_masonry/examples/mason.rs
+++ b/crates/xilem_masonry/examples/mason.rs
@@ -4,9 +4,13 @@
 // On Windows platform, don't show a console when opening the app.
 #![windows_subsystem = "windows"]
 
-use xilem_masonry::view::{button, checkbox, flex, label};
+use xilem_masonry::view::{button, checkbox, flex, label, prose, textbox};
 use xilem_masonry::{Axis, BoxedMasonryView, Color, MasonryView, TextAlignment, Xilem};
 
+const LOREM: &str = r"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Morbi cursus mi sed euismod euismod. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Nullam placerat efficitur tellus at semper. Morbi ac risus magna. Donec ut cursus ex. Etiam quis posuere tellus. Mauris posuere dui et turpis mollis, vitae luctus tellus consectetur. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Curabitur eu facilisis nisl.
+
+Phasellus in viverra dolor, vitae facilisis est. Maecenas malesuada massa vel ultricies feugiat. Vivamus venenatis et nibh nec pharetra. Phasellus vestibulum elit enim, nec scelerisque orci faucibus id. Vivamus consequat purus sit amet orci egestas, non iaculis massa porttitor. Vestibulum ut eros leo. In fermentum convallis magna in finibus. Donec justo leo, maximus ac laoreet id, volutpat ut elit. Mauris sed leo non neque laoreet faucibus. Aliquam orci arcu, faucibus in molestie eget, ornare non dui. Donec volutpat nulla in fringilla elementum. Aliquam vitae ante egestas ligula tempus vestibulum sit amet sed ante. ";
+
 fn app_logic(data: &mut AppData) -> impl MasonryView<AppData> {
     // here's some logic, deriving state for the view from our state
     let count = data.count;
@@ -35,6 +39,8 @@ fn app_logic(data: &mut AppData) -> impl MasonryView<AppData> {
             label("Disabled label").disabled(),
         ))
         .direction(Axis::Horizontal),
+        textbox(),
+        prose(LOREM).alignment(TextAlignment::Middle),
         button(button_label, |data: &mut AppData| data.count += 1),
         checkbox("Check me", data.active, |data: &mut AppData, checked| {
             data.active = checked;
diff --git a/crates/xilem_masonry/src/sequence.rs b/crates/xilem_masonry/src/sequence.rs
index 8dc2d368b..bd6107b69 100644
--- a/crates/xilem_masonry/src/sequence.rs
+++ b/crates/xilem_masonry/src/sequence.rs
@@ -115,7 +115,6 @@ pub struct OptionSeqState<InnerState> {
     generation: u64,
 }
 
-// TODO(DJMcNab): Add the generation to the id path
 impl<State, Action, Marker, VT: ViewSequence<State, Action, Marker>>
     ViewSequence<State, Action, (WasASequence, Marker)> for Option<VT>
 {
diff --git a/crates/xilem_masonry/src/view/button.rs b/crates/xilem_masonry/src/view/button.rs
index 0003ab27d..6638054e6 100644
--- a/crates/xilem_masonry/src/view/button.rs
+++ b/crates/xilem_masonry/src/view/button.rs
@@ -24,7 +24,7 @@ impl<F, State, Action> MasonryView<State, Action> for Button<F>
 where
     F: Fn(&mut State) -> Action + Send + 'static,
 {
-    type Element = masonry::widget::Button;
+    type Element = masonry::widget::Button<ArcStr>;
     type ViewState = ();
 
     fn build(&self, cx: &mut ViewCx) -> (WidgetPod<Self::Element>, Self::ViewState) {
diff --git a/crates/xilem_masonry/src/view/label.rs b/crates/xilem_masonry/src/view/label.rs
index 08abca96c..07e58fd1e 100644
--- a/crates/xilem_masonry/src/view/label.rs
+++ b/crates/xilem_masonry/src/view/label.rs
@@ -40,19 +40,16 @@ impl Label {
 }
 
 impl<State, Action> MasonryView<State, Action> for Label {
-    type Element = masonry::widget::Label;
+    type Element = masonry::widget::Label<ArcStr>;
     type ViewState = ();
 
     fn build(&self, _cx: &mut ViewCx) -> (WidgetPod<Self::Element>, Self::ViewState) {
-        (
-            WidgetPod::new(
-                masonry::widget::Label::new(self.label.clone())
-                    .with_text_color(self.text_color)
-                    .with_text_alignment(self.alignment)
-                    .with_disabled(self.disabled),
-            ),
-            (),
-        )
+        let widget_pod = WidgetPod::new(
+            masonry::widget::Label::new(self.label.clone())
+                .with_text_brush(self.text_color)
+                .with_text_alignment(self.alignment),
+        );
+        (widget_pod, ())
     }
 
     fn rebuild(
@@ -68,16 +65,16 @@ impl<State, Action> MasonryView<State, Action> for Label {
             element.set_text(self.label.clone());
             changeflags.changed |= ChangeFlags::CHANGED.changed;
         }
-        if prev.disabled != self.disabled {
-            element.set_disabled(self.disabled);
-            changeflags.changed |= ChangeFlags::CHANGED.changed;
-        }
+        // if prev.disabled != self.disabled {
+        //     element.set_disabled(self.disabled);
+        //     changeflags.changed |= ChangeFlags::CHANGED.changed;
+        // }
         if prev.text_color != self.text_color {
-            element.set_text_color(self.text_color);
+            element.set_text_brush(self.text_color);
             changeflags.changed |= ChangeFlags::CHANGED.changed;
         }
         if prev.alignment != self.alignment {
-            element.set_text_alignment(self.alignment);
+            element.set_alignment(self.alignment);
             changeflags.changed |= ChangeFlags::CHANGED.changed;
         }
         changeflags
diff --git a/crates/xilem_masonry/src/view/mod.rs b/crates/xilem_masonry/src/view/mod.rs
index 0c95f8920..68d2378f5 100644
--- a/crates/xilem_masonry/src/view/mod.rs
+++ b/crates/xilem_masonry/src/view/mod.rs
@@ -12,3 +12,9 @@ pub use flex::*;
 
 mod label;
 pub use label::*;
+
+mod prose;
+pub use prose::*;
+
+mod textbox;
+pub use textbox::*;
diff --git a/crates/xilem_masonry/src/view/prose.rs b/crates/xilem_masonry/src/view/prose.rs
new file mode 100644
index 000000000..5da290714
--- /dev/null
+++ b/crates/xilem_masonry/src/view/prose.rs
@@ -0,0 +1,94 @@
+// Copyright 2024 the Xilem Authors
+// SPDX-License-Identifier: Apache-2.0
+
+use masonry::{text2::TextBrush, widget::WidgetMut, ArcStr, WidgetPod};
+
+use crate::{ChangeFlags, Color, MasonryView, MessageResult, TextAlignment, ViewCx, ViewId};
+
+pub fn prose(label: impl Into<ArcStr>) -> Prose {
+    Prose {
+        label: label.into(),
+        text_brush: Color::WHITE.into(),
+        alignment: TextAlignment::default(),
+        disabled: false,
+    }
+}
+
+pub struct Prose {
+    label: ArcStr,
+    text_brush: TextBrush,
+    alignment: TextAlignment,
+    disabled: bool,
+    // TODO: add more attributes of `masonry::widget::Label`
+}
+
+impl Prose {
+    #[doc(alias = "color")]
+    pub fn brush(mut self, color: impl Into<TextBrush>) -> Self {
+        self.text_brush = color.into();
+        self
+    }
+
+    pub fn alignment(mut self, alignment: TextAlignment) -> Self {
+        self.alignment = alignment;
+        self
+    }
+
+    pub fn disabled(mut self) -> Self {
+        self.disabled = true;
+        self
+    }
+}
+
+impl<State, Action> MasonryView<State, Action> for Prose {
+    type Element = masonry::widget::Prose<ArcStr>;
+    type ViewState = ();
+
+    fn build(&self, _cx: &mut ViewCx) -> (WidgetPod<Self::Element>, Self::ViewState) {
+        let widget_pod = WidgetPod::new(
+            masonry::widget::Prose::new(self.label.clone())
+                .with_text_brush(self.text_brush.clone())
+                .with_text_alignment(self.alignment),
+        );
+        (widget_pod, ())
+    }
+
+    fn rebuild(
+        &self,
+        _view_state: &mut Self::ViewState,
+        _cx: &mut ViewCx,
+        prev: &Self,
+        mut element: WidgetMut<Self::Element>,
+    ) -> crate::ChangeFlags {
+        let mut changeflags = ChangeFlags::UNCHANGED;
+
+        if prev.label != self.label {
+            element.set_text(self.label.clone());
+            changeflags.changed |= ChangeFlags::CHANGED.changed;
+        }
+        // if prev.disabled != self.disabled {
+        //     element.set_disabled(self.disabled);
+        //     changeflags.changed |= ChangeFlags::CHANGED.changed;
+        // }
+        if prev.text_brush != self.text_brush {
+            element.set_text_brush(self.text_brush.clone());
+            changeflags.changed |= ChangeFlags::CHANGED.changed;
+        }
+        if prev.alignment != self.alignment {
+            element.set_alignment(self.alignment);
+            changeflags.changed |= ChangeFlags::CHANGED.changed;
+        }
+        changeflags
+    }
+
+    fn message(
+        &self,
+        _view_state: &mut Self::ViewState,
+        _id_path: &[ViewId],
+        message: Box<dyn std::any::Any>,
+        _app_state: &mut State,
+    ) -> crate::MessageResult<Action> {
+        tracing::error!("Message arrived in Label::message, but Label doesn't consume any messages, this is a bug");
+        MessageResult::Stale(message)
+    }
+}
diff --git a/crates/xilem_masonry/src/view/textbox.rs b/crates/xilem_masonry/src/view/textbox.rs
new file mode 100644
index 000000000..cec92804a
--- /dev/null
+++ b/crates/xilem_masonry/src/view/textbox.rs
@@ -0,0 +1,89 @@
+// Copyright 2024 the Xilem Authors
+// SPDX-License-Identifier: Apache-2.0
+
+use masonry::{text2::TextBrush, widget::WidgetMut, WidgetPod};
+
+use crate::{ChangeFlags, Color, MasonryView, MessageResult, TextAlignment, ViewCx, ViewId};
+
+pub fn textbox() -> Textbox {
+    // TODO: Allow setting a placeholder
+    Textbox {
+        text_brush: Color::WHITE.into(),
+        alignment: TextAlignment::default(),
+        disabled: false,
+    }
+}
+
+pub struct Textbox {
+    text_brush: TextBrush,
+    alignment: TextAlignment,
+    disabled: bool,
+    // TODO: add more attributes of `masonry::widget::Label`
+}
+
+impl Textbox {
+    #[doc(alias = "color")]
+    pub fn brush(mut self, color: impl Into<TextBrush>) -> Self {
+        self.text_brush = color.into();
+        self
+    }
+
+    pub fn alignment(mut self, alignment: TextAlignment) -> Self {
+        self.alignment = alignment;
+        self
+    }
+
+    pub fn disabled(mut self) -> Self {
+        self.disabled = true;
+        self
+    }
+}
+
+impl<State, Action> MasonryView<State, Action> for Textbox {
+    type Element = masonry::widget::Textbox<String>;
+    type ViewState = ();
+
+    fn build(&self, _cx: &mut ViewCx) -> (WidgetPod<Self::Element>, Self::ViewState) {
+        let widget_pod = WidgetPod::new(
+            masonry::widget::Textbox::new(String::new())
+                .with_text_brush(self.text_brush.clone())
+                .with_text_alignment(self.alignment),
+        );
+        (widget_pod, ())
+    }
+
+    fn rebuild(
+        &self,
+        _view_state: &mut Self::ViewState,
+        _cx: &mut ViewCx,
+        prev: &Self,
+        mut element: WidgetMut<Self::Element>,
+    ) -> crate::ChangeFlags {
+        let mut changeflags = ChangeFlags::UNCHANGED;
+
+        // if prev.disabled != self.disabled {
+        //     element.set_disabled(self.disabled);
+        //     changeflags.changed |= ChangeFlags::CHANGED.changed;
+        // }
+        if prev.text_brush != self.text_brush {
+            element.set_text_brush(self.text_brush.clone());
+            changeflags.changed |= ChangeFlags::CHANGED.changed;
+        }
+        if prev.alignment != self.alignment {
+            element.set_alignment(self.alignment);
+            changeflags.changed |= ChangeFlags::CHANGED.changed;
+        }
+        changeflags
+    }
+
+    fn message(
+        &self,
+        _view_state: &mut Self::ViewState,
+        _id_path: &[ViewId],
+        message: Box<dyn std::any::Any>,
+        _app_state: &mut State,
+    ) -> crate::MessageResult<Action> {
+        tracing::error!("Message arrived in Label::message, but Label doesn't consume any messages, this is a bug");
+        MessageResult::Stale(message)
+    }
+}