diff --git a/Cargo.toml b/Cargo.toml
index 62ad1cd93a1d6..d50561f1dd289 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -866,6 +866,17 @@ description = "Renders text to multiple windows with different scale factors usi
 category = "2D Rendering"
 wasm = true
 
+[[example]]
+name = "text_input_2d"
+path = "examples/2d/text_input_2d.rs"
+doc-scrape-examples = true
+
+[package.metadata.example.text_input_2d]
+name = "Text Input 2D"
+description = "Text input in 2D"
+category = "2D Rendering"
+wasm = true
+
 [[example]]
 name = "texture_atlas"
 path = "examples/2d/texture_atlas.rs"
diff --git a/crates/bevy_sprite/src/lib.rs b/crates/bevy_sprite/src/lib.rs
index 81874f37af24f..cf68b9a1077a1 100644
--- a/crates/bevy_sprite/src/lib.rs
+++ b/crates/bevy_sprite/src/lib.rs
@@ -87,7 +87,8 @@ impl Plugin for SpritePlugin {
                 bevy_text::detect_text_needs_rerender::<Text2d>,
                 update_text2d_layout
                     .after(bevy_camera::CameraUpdateSystems)
-                    .after(bevy_text::remove_dropped_font_atlas_sets),
+                    .after(bevy_text::remove_dropped_font_atlas_sets)
+                    .ambiguous_with(bevy_text::update_placeholder_layouts),
                 calculate_bounds_text2d.in_set(VisibilitySystems::CalculateBounds),
             )
                 .chain()
diff --git a/crates/bevy_sprite/src/sprite.rs b/crates/bevy_sprite/src/sprite.rs
index 065effa8d494b..7f3dac07f2a2d 100644
--- a/crates/bevy_sprite/src/sprite.rs
+++ b/crates/bevy_sprite/src/sprite.rs
@@ -1,10 +1,13 @@
 use bevy_asset::{Assets, Handle};
-use bevy_camera::visibility::{self, Visibility, VisibilityClass};
+use bevy_camera::{
+    primitives::Aabb,
+    visibility::{self, Visibility, VisibilityClass},
+};
 use bevy_color::Color;
 use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::{component::Component, reflect::ReflectComponent};
 use bevy_image::{Image, TextureAtlas, TextureAtlasLayout};
-use bevy_math::{Rect, UVec2, Vec2};
+use bevy_math::{Rect, UVec2, Vec2, Vec3};
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_transform::components::Transform;
 
@@ -260,6 +263,16 @@ impl Anchor {
     pub fn as_vec(&self) -> Vec2 {
         self.0
     }
+
+    /// Determine the bounds at the anchor
+    pub fn calculate_bounds(&self, size: Vec2) -> Aabb {
+        let x1 = (Anchor::TOP_LEFT.0.x - self.as_vec().x) * size.x;
+        let x2 = (Anchor::TOP_LEFT.0.x - self.as_vec().x + 1.) * size.x;
+        let y1 = (Anchor::TOP_LEFT.0.y - self.as_vec().y - 1.) * size.y;
+        let y2 = (Anchor::TOP_LEFT.0.y - self.as_vec().y) * size.y;
+
+        Aabb::from_min_max(Vec3::new(x1, y1, 0.), Vec3::new(x2, y2, 0.))
+    }
 }
 
 impl Default for Anchor {
diff --git a/crates/bevy_text/Cargo.toml b/crates/bevy_text/Cargo.toml
index 1d46bf56511d5..cecbbf46fc2fa 100644
--- a/crates/bevy_text/Cargo.toml
+++ b/crates/bevy_text/Cargo.toml
@@ -22,6 +22,7 @@ bevy_image = { path = "../bevy_image", version = "0.17.0-dev" }
 bevy_log = { path = "../bevy_log", version = "0.17.0-dev" }
 bevy_math = { path = "../bevy_math", version = "0.17.0-dev" }
 bevy_reflect = { path = "../bevy_reflect", version = "0.17.0-dev" }
+bevy_time = { path = "../bevy_time", version = "0.17.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.17.0-dev" }
 bevy_platform = { path = "../bevy_platform", version = "0.17.0-dev", default-features = false, features = [
   "std",
diff --git a/crates/bevy_text/src/input/buffer.rs b/crates/bevy_text/src/input/buffer.rs
new file mode 100644
index 0000000000000..08803591849bf
--- /dev/null
+++ b/crates/bevy_text/src/input/buffer.rs
@@ -0,0 +1,306 @@
+use bevy_asset::{AssetEvent, Assets, Handle};
+use bevy_derive::Deref;
+use bevy_ecs::{
+    change_detection::DetectChanges,
+    component::Component,
+    event::EventReader,
+    lifecycle::HookContext,
+    system::{Query, Res, ResMut},
+    world::{DeferredWorld, Ref},
+};
+use bevy_time::Time;
+use cosmic_text::{Buffer, BufferLine, Edit, Editor, Metrics};
+
+use crate::{
+    load_font_to_fontdb, CosmicFontSystem, CursorBlink, Font, FontSmoothing, Justify, LineBreak,
+    LineHeight, TextCursorBlinkInterval, TextEdit, TextEdits, TextError, TextInputTarget,
+    TextLayoutInfo, TextPipeline,
+};
+
+/// Common text input properties set by the user.
+/// On changes, the text input systems will automatically update the buffer, layout and fonts as required.
+#[derive(Component, Debug, PartialEq)]
+pub struct TextInputAttributes {
+    /// The text input's font, which also applies to any [`crate::Placeholder`] text or password mask.
+    /// A text input's glyphs must all be from the same font.
+    pub font: Handle<Font>,
+    /// The size of the font.
+    /// A text input's glyphs must all be the same size.
+    pub font_size: f32,
+    /// The height of each line.
+    /// A text input's lines must all be the same height.
+    pub line_height: LineHeight,
+    /// Determines how lines will be broken
+    pub line_break: LineBreak,
+    /// The horizontal alignment for all the text in the text input buffer.
+    pub justify: Justify,
+    /// Controls text antialiasing
+    pub font_smoothing: FontSmoothing,
+    /// Maximum number of glyphs the text input buffer can contain.
+    /// Any edits that extend the length above `max_chars` are ignored.
+    /// If set on a buffer longer than `max_chars` the buffer will be truncated.
+    pub max_chars: Option<usize>,
+    /// The maximum number of lines the buffer will display without scrolling.
+    /// * Clamped between zero and target height divided by line height.
+    /// * If None or equal or less than 0, will fill the target space.
+    /// * Only restricts the maximum number of visible lines, places no constraint on the text buffer's length.
+    /// * Supports fractional values, `visible_lines: Some(2.5)` will display two and a half lines of text.
+    pub visible_lines: Option<f32>,
+}
+
+/// Default font size
+pub const DEFAULT_FONT_SIZE: f32 = 20.;
+/// Default line height factor (relative to font size)
+///
+/// `1.2` corresponds to `normal` in `<https://developer.mozilla.org/en-US/docs/Web/CSS/line-height>`
+pub const DEFAULT_LINE_HEIGHT_FACTOR: f32 = 1.2;
+/// Default line height
+pub const DEFAULT_LINE_HEIGHT: f32 = DEFAULT_FONT_SIZE * DEFAULT_LINE_HEIGHT_FACTOR;
+/// Default space advance
+pub const DEFAULT_SPACE_ADVANCE: f32 = 20.;
+
+impl Default for TextInputAttributes {
+    fn default() -> Self {
+        Self {
+            font: Default::default(),
+            font_size: DEFAULT_FONT_SIZE,
+            line_height: LineHeight::RelativeToFont(DEFAULT_LINE_HEIGHT_FACTOR),
+            font_smoothing: Default::default(),
+            justify: Default::default(),
+            line_break: Default::default(),
+            max_chars: None,
+            visible_lines: None,
+        }
+    }
+}
+
+/// Contains the current text in the text input buffer.
+/// Automatically synchronized with the buffer by [`crate::apply_text_edits`] after any edits are applied.
+/// On insertion, replaces the current text in the text buffer.
+#[derive(Component, PartialEq, Debug, Default, Deref)]
+#[component(
+    on_insert = on_insert_text_input_value,
+)]
+pub struct TextInputValue(pub String);
+
+impl TextInputValue {
+    /// New text, when inserted replaces the current text in the text buffer
+    pub fn new(value: impl Into<String>) -> Self {
+        Self(value.into())
+    }
+
+    /// Get the current text
+    pub fn get(&self) -> &str {
+        &self.0
+    }
+}
+
+/// Set the text input with the text from the `TextInputValue` when inserted.
+fn on_insert_text_input_value(mut world: DeferredWorld, context: HookContext) {
+    if let Some(value) = world.get::<TextInputValue>(context.entity) {
+        let value = value.0.clone();
+        if let Some(mut actions) = world.entity_mut(context.entity).get_mut::<TextEdits>() {
+            actions.queue(TextEdit::SetText(value));
+        }
+    }
+}
+
+/// Get the text from a cosmic text buffer
+pub fn get_cosmic_text_buffer_contents(buffer: &Buffer) -> String {
+    buffer
+        .lines
+        .iter()
+        .map(BufferLine::text)
+        .fold(String::new(), |mut out, line| {
+            if !out.is_empty() {
+                out.push('\n');
+            }
+            out.push_str(line);
+            out
+        })
+}
+
+/// The text input buffer.
+/// Primary component that contains the text layout.
+///
+/// The `needs_redraw` method can be used to check if the buffer's contents have changed and need redrawing.
+/// Component change detection is not reliable as the editor buffer needs to be borrowed mutably during updates.
+#[derive(Component, Debug)]
+#[require(TextInputAttributes, TextInputTarget, TextEdits, TextLayoutInfo)]
+pub struct TextInputBuffer {
+    /// The cosmic text editor buffer.
+    pub editor: Editor<'static>,
+    /// Space advance width for the current font, used to determine the width of the cursor when it is at the end of a line
+    /// or when the buffer is empty.
+    pub space_advance: f32,
+}
+
+impl Default for TextInputBuffer {
+    fn default() -> Self {
+        Self {
+            editor: Editor::new(Buffer::new_empty(Metrics::new(
+                DEFAULT_FONT_SIZE,
+                DEFAULT_LINE_HEIGHT,
+            ))),
+            space_advance: DEFAULT_SPACE_ADVANCE,
+        }
+    }
+}
+
+impl TextInputBuffer {
+    /// Use the cosmic text buffer mutably
+    pub fn with_buffer_mut<F, T>(&mut self, f: F) -> T
+    where
+        F: FnOnce(&mut Buffer) -> T,
+    {
+        self.editor.with_buffer_mut(f)
+    }
+
+    /// Use the cosmic text buffer
+    pub fn with_buffer<F, T>(&self, f: F) -> T
+    where
+        F: FnOnce(&Buffer) -> T,
+    {
+        self.editor.with_buffer(f)
+    }
+
+    /// True if the buffer is empty
+    pub fn is_empty(&self) -> bool {
+        self.with_buffer(|buffer| {
+            buffer.lines.is_empty()
+                || (buffer.lines.len() == 1 && buffer.lines[0].text().is_empty())
+        })
+    }
+
+    /// Get the text contained in the text buffer
+    pub fn get_text(&self) -> String {
+        self.editor.with_buffer(get_cosmic_text_buffer_contents)
+    }
+
+    /// Returns true if the buffer's contents have changed and need to be redrawn.
+    pub fn needs_redraw(&self) -> bool {
+        self.editor.redraw()
+    }
+}
+
+/// Updates the text input buffer in response to changes
+/// that require regeneration of the the buffer's
+/// metrics and attributes.
+pub fn update_text_input_buffers(
+    mut text_input_query: Query<(
+        &mut TextInputBuffer,
+        Ref<TextInputTarget>,
+        &TextEdits,
+        Ref<TextInputAttributes>,
+        Option<&mut CursorBlink>,
+    )>,
+    time: Res<Time>,
+    cursor_blink_interval: Res<TextCursorBlinkInterval>,
+    mut font_system: ResMut<CosmicFontSystem>,
+    mut text_pipeline: ResMut<TextPipeline>,
+    fonts: Res<Assets<Font>>,
+    mut font_events: EventReader<AssetEvent<Font>>,
+) {
+    let font_system = &mut font_system.0;
+    let font_id_map = &mut text_pipeline.map_handle_to_font_id;
+    for (mut input_buffer, target, edits, attributes, maybe_cursor_blink) in
+        text_input_query.iter_mut()
+    {
+        let TextInputBuffer {
+            editor,
+            space_advance,
+        } = input_buffer.as_mut();
+
+        if let Some(mut cursor_blink) = maybe_cursor_blink {
+            cursor_blink.cursor_blink_timer = if edits.queue.is_empty() {
+                (cursor_blink.cursor_blink_timer + time.delta_secs())
+                    .rem_euclid(cursor_blink_interval.0.as_secs_f32() * 2.)
+            } else {
+                0.
+            };
+        }
+
+        let _ = editor.with_buffer_mut(|buffer| {
+            if target.is_changed()
+                || attributes.is_changed()
+                || font_events.read().any(|event| match event {
+                    AssetEvent::Added { id } | AssetEvent::Modified { id } => {
+                        *id == attributes.font.id()
+                    }
+                    _ => false,
+                })
+            {
+                let line_height = attributes.line_height.eval(attributes.font_size);
+                let metrics =
+                    Metrics::new(attributes.font_size, line_height).scale(target.scale_factor);
+                buffer.set_metrics(font_system, metrics);
+
+                buffer.set_wrap(font_system, attributes.line_break.into());
+
+                if !fonts.contains(attributes.font.id()) {
+                    return Err(TextError::NoSuchFont);
+                }
+
+                let face_info =
+                    load_font_to_fontdb(attributes.font.clone(), font_system, font_id_map, &fonts);
+
+                let attrs = cosmic_text::Attrs::new()
+                    .metadata(0)
+                    .family(cosmic_text::Family::Name(&face_info.family_name))
+                    .stretch(face_info.stretch)
+                    .style(face_info.style)
+                    .weight(face_info.weight);
+
+                let mut text = buffer.lines.iter().map(BufferLine::text).fold(
+                    String::new(),
+                    |mut out, line| {
+                        if !out.is_empty() {
+                            out.push('\n');
+                        }
+                        out.push_str(line);
+                        out
+                    },
+                );
+
+                if let Some(max_chars) = attributes.max_chars {
+                    text.truncate(max_chars);
+                }
+
+                buffer.set_text(font_system, &text, &attrs, cosmic_text::Shaping::Advanced);
+                let align = Some(attributes.justify.into());
+                for buffer_line in buffer.lines.iter_mut() {
+                    buffer_line.set_align(align);
+                }
+
+                *space_advance = font_id_map
+                    .get(&attributes.font.id())
+                    .and_then(|(id, ..)| font_system.get_font(*id))
+                    .and_then(|font| {
+                        let face = font.rustybuzz();
+                        face.glyph_index(' ')
+                            .and_then(|gid| face.glyph_hor_advance(gid))
+                            .map(|advance| advance as f32 / face.units_per_em() as f32)
+                    })
+                    .unwrap_or(0.0)
+                    * buffer.metrics().font_size;
+
+                let height =
+                    if let Some(lines) = attributes.visible_lines.filter(|lines| 0. < *lines) {
+                        (metrics.line_height * lines).max(target.size.y)
+                    } else {
+                        target.size.y
+                    };
+
+                buffer.set_size(
+                    font_system,
+                    Some(target.size.x - *space_advance),
+                    Some(height),
+                );
+
+                buffer.set_redraw(true);
+            }
+
+            Ok(())
+        });
+    }
+}
diff --git a/crates/bevy_text/src/input/clipboard.rs b/crates/bevy_text/src/input/clipboard.rs
new file mode 100644
index 0000000000000..4fbba685ab9cb
--- /dev/null
+++ b/crates/bevy_text/src/input/clipboard.rs
@@ -0,0 +1,8 @@
+use bevy_ecs::resource::Resource;
+
+/// Basic clipboard implementation that only works within the bevy app.
+///
+/// This is written to in the [`crate::apply_text_edits`] system when
+/// [`crate::TextEdit::Copy`], [`crate::TextEdit::Cut`] or [`crate::TextEdit::Paste`] edits are applied.
+#[derive(Resource, Default)]
+pub struct Clipboard(pub String);
diff --git a/crates/bevy_text/src/input/cursor_blink.rs b/crates/bevy_text/src/input/cursor_blink.rs
new file mode 100644
index 0000000000000..e77f15ae06fa3
--- /dev/null
+++ b/crates/bevy_text/src/input/cursor_blink.rs
@@ -0,0 +1,26 @@
+use core::time::Duration;
+
+use bevy_derive::{Deref, DerefMut};
+use bevy_ecs::{component::Component, prelude::ReflectComponent, resource::Resource};
+use bevy_reflect::{prelude::ReflectDefault, Reflect};
+
+/// The time taken for the cursor to blink
+#[derive(Resource)]
+pub struct TextCursorBlinkInterval(pub Duration);
+
+impl Default for TextCursorBlinkInterval {
+    fn default() -> Self {
+        Self(Duration::from_secs_f32(0.5))
+    }
+}
+
+/// Optional component to control cursor blink behavior
+#[derive(Default, Component, Clone, Debug, Reflect, Deref, DerefMut)]
+#[reflect(Component, Default, Debug)]
+pub struct CursorBlink {
+    /// Controls cursor blinking.
+    /// If the value is greater than the `blink_interval` in `TextCursorStyle` then the cursor
+    /// is not displayed.
+    /// The timer is reset when a `TextEdit` is applied.
+    pub cursor_blink_timer: f32,
+}
diff --git a/crates/bevy_text/src/input/filtering.rs b/crates/bevy_text/src/input/filtering.rs
new file mode 100644
index 0000000000000..d4d05e04b2b04
--- /dev/null
+++ b/crates/bevy_text/src/input/filtering.rs
@@ -0,0 +1,61 @@
+use bevy_ecs::component::Component;
+
+/// If a text input entity has a `TextInputFilter` component, after each [`crate::TextEdit`] is applied, the [`crate::TextInputBuffer`]’s text is checked
+/// against the filter, and if it fails, the `TextEdit` is immediately rolled back, and a [`crate::TextInputEvent::InvalidEdit`] event is emitted.
+#[derive(Component)]
+pub enum TextInputFilter {
+    /// Positive integer input
+    /// accepts only digits
+    PositiveInteger,
+    /// Integer input
+    /// accepts only digits and a leading sign
+    Integer,
+    /// Decimal input
+    /// accepts only digits, a decimal point and a leading sign
+    Decimal,
+    /// Hexadecimal input
+    /// accepts only `0-9`, `a-f` and `A-F`
+    Hex,
+    /// Alphanumeric input
+    /// accepts only `0-9`, `a-z` and `A-Z`
+    Alphanumeric,
+    /// Custom filter
+    Custom(Box<dyn Fn(&str) -> bool + Send + Sync>),
+}
+
+impl TextInputFilter {
+    /// Returns `true` if the given `text` passes the filter
+    pub fn is_match(&self, text: &str) -> bool {
+        // Always passes if the input is empty unless using a custom filter
+        if text.is_empty() && !matches!(self, Self::Custom(_)) {
+            return true;
+        }
+
+        match self {
+            TextInputFilter::PositiveInteger => text.chars().all(|c| c.is_ascii_digit()),
+            TextInputFilter::Integer => text
+                .strip_prefix('-')
+                .unwrap_or(text)
+                .chars()
+                .all(|c| c.is_ascii_digit()),
+            TextInputFilter::Decimal => text
+                .strip_prefix('-')
+                .unwrap_or(text)
+                .chars()
+                .try_fold(true, |is_int, c| match c {
+                    '.' if is_int => Ok(false),
+                    c if c.is_ascii_digit() => Ok(is_int),
+                    _ => Err(()),
+                })
+                .is_ok(),
+            TextInputFilter::Hex => text.chars().all(|c| c.is_ascii_hexdigit()),
+            TextInputFilter::Alphanumeric => text.chars().all(|c| c.is_ascii_alphanumeric()),
+            TextInputFilter::Custom(is_match) => is_match(text),
+        }
+    }
+
+    /// Create a custom filter
+    pub fn custom(filter_fn: impl Fn(&str) -> bool + Send + Sync + 'static) -> Self {
+        Self::Custom(Box::new(filter_fn))
+    }
+}
diff --git a/crates/bevy_text/src/input/layout.rs b/crates/bevy_text/src/input/layout.rs
new file mode 100644
index 0000000000000..71dd08c9a8922
--- /dev/null
+++ b/crates/bevy_text/src/input/layout.rs
@@ -0,0 +1,275 @@
+use bevy_asset::Assets;
+use bevy_ecs::{
+    change_detection::{DetectChanges, DetectChangesMut},
+    system::{Query, ResMut},
+};
+use bevy_image::{Image, TextureAtlasLayout};
+use bevy_math::{IVec2, Rect, UVec2, Vec2};
+use cosmic_text::{Buffer, Edit};
+
+use crate::{
+    buffer_dimensions, CosmicFontSystem, FontAtlasSets, FontSmoothing, PasswordMask,
+    PositionedGlyph, TextError, TextInputAttributes, TextInputBuffer, TextLayoutInfo,
+};
+
+/// Based on `LayoutRunIter` from cosmic-text but fixes a bug where the
+/// bottom line should be visible but gets cropped when scrolling upwards.
+#[derive(Debug)]
+pub struct ScrollingLayoutRunIter<'b> {
+    /// Cosmic text buffer
+    buffer: &'b Buffer,
+    /// Index of the current `BufferLine` (The paragraphs of text before line-breaking)
+    paragraph_index: usize,
+    /// Index of the current `LayoutLine`, a horizontal line of glyphs from the current `BufferLine` (The individual lines of a paragraph after line-breaking)
+    broken_line_index: usize,
+    /// Total height of the lines iterated so far
+    total_height: f32,
+    /// The y-coordinate of the top of the current `LayoutLine`.
+    line_top: f32,
+}
+
+impl<'b> ScrollingLayoutRunIter<'b> {
+    /// Returns a new iterator that iterates the visible lines of the `buffer`.
+    pub fn new(buffer: &'b Buffer) -> Self {
+        Self {
+            buffer,
+            paragraph_index: buffer.scroll().line,
+            broken_line_index: 0,
+            total_height: 0.0,
+            line_top: 0.0,
+        }
+    }
+}
+
+impl<'b> Iterator for ScrollingLayoutRunIter<'b> {
+    type Item = cosmic_text::LayoutRun<'b>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        // Iterate paragraphs
+        while let Some(line) = self.buffer.lines.get(self.paragraph_index) {
+            let shape = line.shape_opt()?;
+            let layout = line.layout_opt()?;
+
+            // Iterate the paragraph's lines after line-breaking
+            while let Some(layout_line) = layout.get(self.broken_line_index) {
+                self.broken_line_index += 1;
+
+                let line_height = layout_line
+                    .line_height_opt
+                    .unwrap_or(self.buffer.metrics().line_height);
+                self.total_height += line_height;
+
+                let line_top = self.line_top - self.buffer.scroll().vertical;
+                let glyph_height = layout_line.max_ascent + layout_line.max_descent;
+                let centering_offset = (line_height - glyph_height) / 2.0;
+                let line_bottom = line_top + centering_offset + layout_line.max_ascent;
+                if let Some(height) = self.buffer.size().1
+                    && height + line_height < line_bottom
+                {
+                    // The line is below the target bound's bottom edge.
+                    // No more lines are visible, return `None` to end the iteration.
+                    return None;
+                }
+                self.line_top += line_height;
+                if line_bottom < 0.0 {
+                    // The bottom of the line is above the target's bounds top edge and not visible. Skip it.
+                    continue;
+                }
+
+                return Some(cosmic_text::LayoutRun {
+                    line_i: self.paragraph_index,
+                    text: line.text(),
+                    rtl: shape.rtl,
+                    glyphs: &layout_line.glyphs,
+                    line_y: line_bottom,
+                    line_top,
+                    line_height,
+                    line_w: layout_line.w,
+                });
+            }
+            self.paragraph_index += 1;
+            self.broken_line_index = 0;
+        }
+
+        None
+    }
+}
+
+/// Updates the `TextLayoutInfo` for each text input for rendering.
+pub fn update_text_input_layouts(
+    mut textures: ResMut<Assets<Image>>,
+    mut texture_atlases: ResMut<Assets<TextureAtlasLayout>>,
+    mut text_query: Query<(
+        &mut TextLayoutInfo,
+        &mut TextInputBuffer,
+        &TextInputAttributes,
+        Option<&mut PasswordMask>,
+    )>,
+    mut font_system: ResMut<CosmicFontSystem>,
+    mut swash_cache: ResMut<crate::pipeline::SwashCache>,
+    mut font_atlas_sets: ResMut<FontAtlasSets>,
+) {
+    let font_system = &mut font_system.0;
+    for (mut layout_info, mut buffer, attributes, mut maybe_password_mask) in text_query.iter_mut()
+    {
+        // Force a redraw when a password is revealed or hidden
+        let force_redraw = maybe_password_mask
+            .as_mut()
+            .map(|mask| mask.is_changed() && mask.show_password)
+            .unwrap_or(false);
+
+        let space_advance = buffer.space_advance;
+        let editor = if let Some(password_mask) = maybe_password_mask
+            .as_mut()
+            .filter(|mask| !mask.show_password)
+        {
+            // The underlying buffer is hidden, so set redraw to false to avoid unnecessary reupdates.
+            buffer.editor.set_redraw(false);
+            &mut password_mask.bypass_change_detection().editor
+        } else {
+            &mut buffer.editor
+        };
+        editor.shape_as_needed(font_system, false);
+
+        if editor.redraw() || force_redraw {
+            layout_info.glyphs.clear();
+            layout_info.section_rects.clear();
+            layout_info.selection_rects.clear();
+            layout_info.cursor_index = None;
+            layout_info.cursor = None;
+
+            let selection = editor.selection_bounds();
+            let cursor_position = editor.cursor_position();
+            let cursor = editor.cursor();
+
+            let result = editor.with_buffer_mut(|buffer| {
+                let box_size = buffer_dimensions(buffer);
+                let line_height = buffer.metrics().line_height;
+                if let Some((x, y)) = cursor_position {
+                    let size = Vec2::new(space_advance, line_height);
+                    layout_info.cursor = Some((
+                        IVec2::new(x, y).as_vec2() + 0.5 * size,
+                        size,
+                        cursor.affinity.after(),
+                    ));
+                }
+                let result = ScrollingLayoutRunIter::new(buffer).try_for_each(|run| {
+                    if let Some(selection) = selection
+                        && let Some((x0, w)) = run.highlight(selection.0, selection.1)
+                    {
+                        let y0 = run.line_top;
+                        let y1 = y0 + run.line_height;
+                        let x1 = x0 + w;
+                        let r = Rect::new(x0, y0, x1, y1);
+                        layout_info.selection_rects.push(r);
+                    }
+
+                    run.glyphs
+                        .iter()
+                        .map(move |layout_glyph| (layout_glyph, run.line_y, run.line_i))
+                        .try_for_each(|(layout_glyph, line_y, line_i)| {
+                            let mut temp_glyph;
+                            let span_index = layout_glyph.metadata;
+                            let font_id = attributes.font.id();
+                            let font_smoothing = attributes.font_smoothing;
+
+                            let layout_glyph = if font_smoothing == FontSmoothing::None {
+                                // If font smoothing is disabled, round the glyph positions and sizes,
+                                // effectively discarding all subpixel layout.
+                                temp_glyph = layout_glyph.clone();
+                                temp_glyph.x = temp_glyph.x.round();
+                                temp_glyph.y = temp_glyph.y.round();
+                                temp_glyph.w = temp_glyph.w.round();
+                                temp_glyph.x_offset = temp_glyph.x_offset.round();
+                                temp_glyph.y_offset = temp_glyph.y_offset.round();
+                                temp_glyph.line_height_opt =
+                                    temp_glyph.line_height_opt.map(f32::round);
+
+                                &temp_glyph
+                            } else {
+                                layout_glyph
+                            };
+
+                            let font_atlas_set = font_atlas_sets.sets.entry(font_id).or_default();
+
+                            let physical_glyph = layout_glyph.physical((0., 0.), 1.);
+
+                            let atlas_info = font_atlas_set
+                                .get_glyph_atlas_info(physical_glyph.cache_key, font_smoothing)
+                                .map(Ok)
+                                .unwrap_or_else(|| {
+                                    font_atlas_set.add_glyph_to_atlas(
+                                        &mut texture_atlases,
+                                        &mut textures,
+                                        font_system,
+                                        &mut swash_cache.0,
+                                        layout_glyph,
+                                        font_smoothing,
+                                    )
+                                })?;
+
+                            let texture_atlas =
+                                texture_atlases.get(atlas_info.texture_atlas).unwrap();
+                            let location = atlas_info.location;
+                            let glyph_rect = texture_atlas.textures[location.glyph_index];
+                            let left = location.offset.x as f32;
+                            let top = location.offset.y as f32;
+                            let glyph_size = UVec2::new(glyph_rect.width(), glyph_rect.height());
+
+                            // offset by half the size because the origin is center
+                            let x = glyph_size.x as f32 / 2.0 + left + physical_glyph.x as f32;
+                            let y = line_y.round() + physical_glyph.y as f32 - top
+                                + glyph_size.y as f32 / 2.0;
+
+                            let position = Vec2::new(x, y);
+
+                            let pos_glyph = PositionedGlyph {
+                                position,
+                                size: glyph_size.as_vec2(),
+                                atlas_info,
+                                span_index,
+                                byte_index: layout_glyph.start,
+                                byte_length: layout_glyph.end - layout_glyph.start,
+                                line_index: line_i,
+                            };
+                            layout_info.glyphs.push(pos_glyph);
+                            if cursor.line == line_i && cursor.index == layout_glyph.start {
+                                layout_info.cursor_index = Some(layout_info.glyphs.len() - 1);
+                                if let Some((ref mut position, ref mut size, ..)) =
+                                    layout_info.cursor
+                                {
+                                    size.x = layout_glyph.w;
+                                    if let Some(cursor_position) = cursor_position {
+                                        *position =
+                                            IVec2::from(cursor_position).as_vec2() + 0.5 * *size;
+                                    }
+                                }
+                            }
+
+                            Ok(())
+                        })
+                });
+
+                // Check result.
+                result?;
+                layout_info.size = box_size;
+                Ok(())
+            });
+
+            match result {
+                Err(TextError::NoSuchFont) => {
+                    // There was an error processing the text layout, try again next frame
+                }
+                Err(e @ (TextError::FailedToAddGlyph(_) | TextError::FailedToGetGlyphImage(_))) => {
+                    panic!("Fatal error when processing text: {e}.");
+                }
+                Ok(()) => {
+                    layout_info.scroll =
+                        editor.with_buffer(|buffer| Vec2::new(buffer.scroll().horizontal, 0.));
+
+                    editor.set_redraw(false);
+                }
+            }
+        }
+    }
+}
diff --git a/crates/bevy_text/src/input/masking.rs b/crates/bevy_text/src/input/masking.rs
new file mode 100644
index 0000000000000..6fba05975139e
--- /dev/null
+++ b/crates/bevy_text/src/input/masking.rs
@@ -0,0 +1,72 @@
+use bevy_ecs::{
+    change_detection::{DetectChanges, DetectChangesMut},
+    component::Component,
+    system::{Query, ResMut},
+};
+pub use cosmic_text::Motion;
+use cosmic_text::{Action, Buffer, Edit, Editor, Metrics, Selection};
+
+use crate::{CosmicFontSystem, TextInputBuffer, DEFAULT_FONT_SIZE, DEFAULT_LINE_HEIGHT};
+
+/// Add this component to hide the text input buffer contents
+/// by replacing the characters with `mask_char`.
+///
+/// It is strongly recommended to only use a [`PasswordMask` with fixed-width fonts.
+/// With variable width fonts mouse picking and horizontal scrolling
+/// may not work correctly.
+///
+/// This is updated in [`update_password_masks`].
+#[derive(Component)]
+pub struct PasswordMask {
+    /// If true the password will not be hidden
+    pub show_password: bool,
+    /// Char that will replace the masked input characters, by default `*`
+    pub mask_char: char,
+    /// Buffer mirroring the actual text input buffer but only containing `mask_char`s
+    pub editor: Editor<'static>,
+}
+
+impl Default for PasswordMask {
+    fn default() -> Self {
+        Self {
+            show_password: false,
+            mask_char: '*',
+            editor: Editor::new(Buffer::new_empty(Metrics::new(
+                DEFAULT_FONT_SIZE,
+                DEFAULT_LINE_HEIGHT,
+            ))),
+        }
+    }
+}
+
+/// Update each [`PasswordMask`] to mirror its underlying [`TextInputBuffer`].
+///
+/// The recommended practice is to use fixed-width fonts for password inputs.
+/// With variable sized fonts the glyph geometry of the password mask editor buffer may not match the
+/// underlying editor buffer, possibly resulting in incorrect scrolling and mouse interactions.
+pub fn update_password_masks(
+    mut text_input_query: Query<(&mut TextInputBuffer, &mut PasswordMask)>,
+    mut cosmic_font_system: ResMut<CosmicFontSystem>,
+) {
+    let font_system = &mut cosmic_font_system.0;
+    for (mut buffer, mut mask) in text_input_query.iter_mut() {
+        if buffer.editor.redraw() || mask.is_changed() {
+            buffer.editor.shape_as_needed(font_system, false);
+            let mask_text: String = buffer.get_text().chars().map(|_| mask.mask_char).collect();
+            let mask_editor = &mut mask.bypass_change_detection().editor;
+            *mask_editor = buffer.editor.clone();
+            let mut editor = mask_editor.borrow_with(font_system);
+            let selection = editor.selection();
+            let cursor = editor.cursor();
+            editor.action(Action::Motion(Motion::BufferStart));
+            let start = editor.cursor();
+            editor.set_selection(Selection::Normal(start));
+            editor.action(Action::Motion(Motion::BufferEnd));
+            editor.action(Action::Delete);
+            editor.insert_string(&mask_text, None);
+            editor.set_selection(selection);
+            editor.set_cursor(cursor);
+            editor.set_redraw(true);
+        }
+    }
+}
diff --git a/crates/bevy_text/src/input/mod.rs b/crates/bevy_text/src/input/mod.rs
new file mode 100644
index 0000000000000..f321e76e51ede
--- /dev/null
+++ b/crates/bevy_text/src/input/mod.rs
@@ -0,0 +1,70 @@
+//! This module provides text editing functionality, by wrapping the functionality of the
+//! [`cosmic_text`] crate.
+//!
+//! The primary entry point into the text editing functionality is the [`TextInputBuffer`] component,
+//! which includes a [`cosmic_text::Editor`], and adds the associated "required components" needed
+//! to construct functioning text input fields.
+//!
+//! ## How this works
+//!
+//! Text editing functionality is included as part of [`TextPlugin`](crate::TextPlugin),
+//! and the systems which perform the work are grouped under the [`TextInputSystems`] system set.
+//!  
+//! The [`TextInputBuffer`] comes with the following required components that act as machinery to convert user inputs into text:
+//!
+//! * [`TextInputValue`] - Contains the current text in the text input buffer.
+//!    * Automatically synchronized with the buffer by [`apply_text_edits`] after any edits are applied.
+//! * [`TextEdits`] - Text input commands queue, used to queue up text edit and navigation actions.\
+//!    * Contains a queue of [`TextEdit`] actions that are applied to the buffer.
+//!    * These are applied by the [`apply_text_edits` system.
+//! * [`TextInputTarget`] - Details of the render target the text input will be rendered to, such as size and scale factor.
+//!
+//!
+//! Layouting is done in:
+//!
+//! * [`update_text_input_layouts`] - Updates the `TextLayoutInfo` for each text input for rendering.
+//! * [`update_placeholder_layouts`] - Updates the `TextLayoutInfo` for each [`Placeholder`] for rendering.
+//!
+//! ## Configuring text input
+//!
+//! Several components are used to configure the text input, and belong on the [`TextInputBuffer`] entity:
+//!
+//! * [`TextInputAttributes`] - Common text input properties set by the user, such as font, font size, line height, justification, maximum characters etc.
+//! * [`TextInputFilter`] - Optional component that can be added to restrict the text input to certain formats, such as integers, decimals, hexadecimal etc.
+//! * [`PasswordMask`] - Optional component that can be added to hide the text input buffer contents by replacing the characters with a mask character.
+//! * [`Placeholder`] - Optional component that can be added to display placeholder text when the input buffer is empty.
+//! * [`CursorBlink`] - Optional component that controls cursor blinking.
+//!
+//! ## Copy-paste and clipboard support
+//!
+//! The clipboard support provided by this module is very basic, and only works within the `bevy` app,
+//! storing a simple [`String`].
+//!
+//! It can be accessed via the [`Clipboard`] resource.
+
+use bevy_ecs::schedule::SystemSet;
+pub use cosmic_text::Motion;
+
+/// Systems handling text input update and layout
+#[derive(Debug, Hash, PartialEq, Eq, Clone, SystemSet)]
+pub struct TextInputSystems;
+
+mod buffer;
+mod clipboard;
+mod cursor_blink;
+mod filtering;
+mod layout;
+mod masking;
+mod placeholder;
+mod target;
+mod text_edit;
+
+pub use buffer::*;
+pub use clipboard::*;
+pub use cursor_blink::*;
+pub use filtering::*;
+pub use layout::*;
+pub use masking::*;
+pub use placeholder::*;
+pub use target::*;
+pub use text_edit::*;
diff --git a/crates/bevy_text/src/input/placeholder.rs b/crates/bevy_text/src/input/placeholder.rs
new file mode 100644
index 0000000000000..1a12965b0d51b
--- /dev/null
+++ b/crates/bevy_text/src/input/placeholder.rs
@@ -0,0 +1,239 @@
+use bevy_asset::{AssetEvent, Assets};
+use bevy_derive::{Deref, DerefMut};
+use bevy_ecs::{
+    change_detection::DetectChanges,
+    component::Component,
+    event::EventReader,
+    prelude::ReflectComponent,
+    system::{Query, Res, ResMut},
+    world::Ref,
+};
+use bevy_image::{Image, TextureAtlasLayout};
+use bevy_math::{UVec2, Vec2};
+use bevy_reflect::{prelude::ReflectDefault, Reflect};
+use cosmic_text::{Buffer, Metrics};
+
+use crate::{
+    buffer_dimensions, load_font_to_fontdb, CosmicFontSystem, Font, FontAtlasSets, FontSmoothing,
+    PositionedGlyph, TextBounds, TextError, TextInputAttributes, TextInputTarget, TextLayoutInfo,
+    TextPipeline, DEFAULT_FONT_SIZE, DEFAULT_LINE_HEIGHT,
+};
+
+/// Placeholder text displayed when the input is empty.
+///
+/// Text inputs that contain only whitespace (i.e spaces or tabs) are not empty.
+///
+/// This is an optional component, intended to work with [`TextInputTarget`].
+/// The font and other properties are controlled with [`TextInputAttributes`].
+#[derive(Default, Component, Clone, Debug, Reflect, Deref, DerefMut)]
+#[reflect(Component, Default, Debug)]
+#[require(PlaceholderLayout)]
+pub struct Placeholder(pub String);
+
+impl Placeholder {
+    /// A new [`Placeholder`] text.
+    pub fn new(prompt: impl Into<String>) -> Self {
+        Self(prompt.into())
+    }
+}
+
+/// Layout for the [`Placeholder`] text.
+///
+/// This is laid out in [`update_placeholder_layouts`].
+#[derive(Component)]
+pub struct PlaceholderLayout {
+    /// A [`Placeholder`] text's cosmic-text buffer (not an Editor as it isn't editable).
+    buffer: Buffer,
+    /// A [`Placeholder`] text's glyph layout. Displayed when the text input is empty.
+    /// Doesn't reuse the editor's [`TextLayoutInfo`] as otherwise the placeholder would need a relayout
+    /// everytime it was displayed.
+    layout: TextLayoutInfo,
+}
+
+impl PlaceholderLayout {
+    /// Returns the renderable glyph layout for the associated [`Placeholder`] text
+    pub fn layout(&self) -> &TextLayoutInfo {
+        &self.layout
+    }
+}
+
+impl Default for PlaceholderLayout {
+    fn default() -> Self {
+        Self {
+            buffer: Buffer::new_empty(Metrics::new(DEFAULT_FONT_SIZE, DEFAULT_LINE_HEIGHT)),
+            layout: Default::default(),
+        }
+    }
+}
+
+/// Generates a new [`PlaceholderLayout`] when a [`Placeholder`]'s text or its target's geometry has changed.
+pub fn update_placeholder_layouts(
+    mut textures: ResMut<Assets<Image>>,
+    fonts: Res<Assets<Font>>,
+    mut font_system: ResMut<CosmicFontSystem>,
+    mut texture_atlases: ResMut<Assets<TextureAtlasLayout>>,
+    mut text_pipeline: ResMut<TextPipeline>,
+    mut swash_cache: ResMut<crate::pipeline::SwashCache>,
+    mut font_atlas_sets: ResMut<FontAtlasSets>,
+    mut text_query: Query<(
+        Ref<Placeholder>,
+        Ref<TextInputAttributes>,
+        Ref<TextInputTarget>,
+        &mut PlaceholderLayout,
+    )>,
+    mut font_events: EventReader<AssetEvent<Font>>,
+) {
+    for (placeholder, attributes, target, mut prompt_layout) in text_query.iter_mut() {
+        if !(placeholder.is_changed()
+            || attributes.is_changed()
+            || target.is_changed()
+            || font_events.read().any(|event| match event {
+                AssetEvent::Added { id } | AssetEvent::Modified { id } => {
+                    *id == attributes.font.id()
+                }
+                _ => false,
+            }))
+        {
+            continue;
+        }
+        let PlaceholderLayout { buffer, layout } = prompt_layout.as_mut();
+
+        layout.clear();
+
+        if placeholder.0.is_empty() || target.is_empty() {
+            continue;
+        }
+
+        if !fonts.contains(attributes.font.id()) {
+            continue;
+        }
+
+        let line_height = attributes.line_height.eval(attributes.font_size);
+
+        let metrics = Metrics::new(attributes.font_size, line_height).scale(target.scale_factor);
+
+        if metrics.font_size <= 0. || metrics.line_height <= 0. {
+            continue;
+        }
+
+        let bounds: TextBounds = target.size.into();
+        let face_info = load_font_to_fontdb(
+            attributes.font.clone(),
+            font_system.as_mut(),
+            &mut text_pipeline.map_handle_to_font_id,
+            &fonts,
+        );
+
+        buffer.set_size(font_system.as_mut(), bounds.width, bounds.height);
+
+        buffer.set_wrap(&mut font_system, attributes.line_break.into());
+
+        let attrs = cosmic_text::Attrs::new()
+            .metadata(0)
+            .family(cosmic_text::Family::Name(&face_info.family_name))
+            .stretch(face_info.stretch)
+            .style(face_info.style)
+            .weight(face_info.weight)
+            .metrics(metrics);
+
+        buffer.set_text(
+            &mut font_system,
+            &placeholder.0,
+            &attrs,
+            cosmic_text::Shaping::Advanced,
+        );
+
+        let align = Some(attributes.justify.into());
+        for buffer_line in buffer.lines.iter_mut() {
+            buffer_line.set_align(align);
+        }
+
+        buffer.shape_until_scroll(&mut font_system, false);
+
+        let box_size = buffer_dimensions(buffer);
+        let result = buffer.layout_runs().try_for_each(|run| {
+            run.glyphs
+                .iter()
+                .map(move |layout_glyph| (layout_glyph, run.line_y, run.line_i))
+                .try_for_each(|(layout_glyph, line_y, line_i)| {
+                    let mut temp_glyph;
+                    let span_index = layout_glyph.metadata;
+                    let font_id = attributes.font.id();
+                    let font_smoothing = attributes.font_smoothing;
+
+                    let layout_glyph = if font_smoothing == FontSmoothing::None {
+                        // If font smoothing is disabled, round the glyph positions and sizes,
+                        // effectively discarding all subpixel layout.
+                        temp_glyph = layout_glyph.clone();
+                        temp_glyph.x = temp_glyph.x.round();
+                        temp_glyph.y = temp_glyph.y.round();
+                        temp_glyph.w = temp_glyph.w.round();
+                        temp_glyph.x_offset = temp_glyph.x_offset.round();
+                        temp_glyph.y_offset = temp_glyph.y_offset.round();
+                        temp_glyph.line_height_opt = temp_glyph.line_height_opt.map(f32::round);
+
+                        &temp_glyph
+                    } else {
+                        layout_glyph
+                    };
+
+                    let font_atlas_set = font_atlas_sets.sets.entry(font_id).or_default();
+
+                    let physical_glyph = layout_glyph.physical((0., 0.), 1.);
+
+                    let atlas_info = font_atlas_set
+                        .get_glyph_atlas_info(physical_glyph.cache_key, font_smoothing)
+                        .map(Ok)
+                        .unwrap_or_else(|| {
+                            font_atlas_set.add_glyph_to_atlas(
+                                &mut texture_atlases,
+                                &mut textures,
+                                &mut font_system,
+                                &mut swash_cache.0,
+                                layout_glyph,
+                                font_smoothing,
+                            )
+                        })?;
+
+                    let texture_atlas = texture_atlases.get(atlas_info.texture_atlas).unwrap();
+                    let location = atlas_info.location;
+                    let glyph_rect = texture_atlas.textures[location.glyph_index];
+                    let left = location.offset.x as f32;
+                    let top = location.offset.y as f32;
+                    let glyph_size = UVec2::new(glyph_rect.width(), glyph_rect.height());
+
+                    // offset by half the size because the origin is center
+                    let x = glyph_size.x as f32 / 2.0 + left + physical_glyph.x as f32;
+                    let y =
+                        line_y.round() + physical_glyph.y as f32 - top + glyph_size.y as f32 / 2.0;
+
+                    let position = Vec2::new(x, y);
+
+                    let pos_glyph = PositionedGlyph {
+                        position,
+                        size: glyph_size.as_vec2(),
+                        atlas_info,
+                        span_index,
+                        byte_index: layout_glyph.start,
+                        byte_length: layout_glyph.end - layout_glyph.start,
+                        line_index: line_i,
+                    };
+                    layout.glyphs.push(pos_glyph);
+                    Ok(())
+                })
+        });
+
+        prompt_layout.layout.size = target.scale_factor.recip() * box_size;
+
+        match result {
+            Err(TextError::NoSuchFont) => {
+                // There was an error processing the text layout, try again next frame
+                prompt_layout.layout.clear();
+            }
+            Err(e @ (TextError::FailedToAddGlyph(_) | TextError::FailedToGetGlyphImage(_))) => {
+                panic!("Fatal error when processing text: {e}.");
+            }
+            Ok(()) => {}
+        }
+    }
+}
diff --git a/crates/bevy_text/src/input/target.rs b/crates/bevy_text/src/input/target.rs
new file mode 100644
index 0000000000000..6e4d11c1f296f
--- /dev/null
+++ b/crates/bevy_text/src/input/target.rs
@@ -0,0 +1,18 @@
+use bevy_ecs::component::Component;
+use bevy_math::Vec2;
+
+/// Details of the target the text input will be rendered to
+#[derive(Component, PartialEq, Debug, Default)]
+pub struct TextInputTarget {
+    /// Size of the target in physical pixels
+    pub size: Vec2,
+    /// Scale factor of the target
+    pub scale_factor: f32,
+}
+
+impl TextInputTarget {
+    /// Returns true if the target has zero or negative size.
+    pub fn is_empty(&self) -> bool {
+        (self.scale_factor * self.size).cmple(Vec2::ZERO).all()
+    }
+}
diff --git a/crates/bevy_text/src/input/text_edit.rs b/crates/bevy_text/src/input/text_edit.rs
new file mode 100644
index 0000000000000..d0b20ba4efc64
--- /dev/null
+++ b/crates/bevy_text/src/input/text_edit.rs
@@ -0,0 +1,356 @@
+use alloc::collections::VecDeque;
+use bevy_ecs::{
+    component::Component,
+    entity::Entity,
+    event::EntityEvent,
+    hierarchy::ChildOf,
+    system::{Commands, Query, ResMut},
+};
+use bevy_math::IVec2;
+pub use cosmic_text::Motion;
+use cosmic_text::{Action, BorrowedWithFontSystem, Edit, Editor, Selection};
+
+use crate::{
+    get_cosmic_text_buffer_contents, Clipboard, CosmicFontSystem, TextInputAttributes,
+    TextInputBuffer, TextInputFilter, TextInputValue,
+};
+
+/// Text input commands queue
+#[derive(Component, Default)]
+pub struct TextEdits {
+    /// Commands to be applied before the text input is updated
+    pub queue: VecDeque<TextEdit>,
+}
+
+impl TextEdits {
+    /// queue an action
+    pub fn queue(&mut self, command: TextEdit) {
+        self.queue.push_back(command);
+    }
+}
+
+/// Deferred text input edit and navigation actions.
+///
+/// These are generated by user inputs,
+/// stored in the [`TextEdits`] component,
+/// and applied by the [`apply_text_edits`] system.
+///
+/// The user is currently completely responsible for generating these edits
+/// by handling input events and mapping them to edits.
+#[derive(Debug, Clone)]
+pub enum TextEdit {
+    /// Copy the selected text into the clipboard. Does nothing if no text is selected.
+    Copy,
+    /// Copy the selected text into the clipboard, then delete the selected text. Does nothing if no text is selected.
+    Cut,
+    /// Insert the contents of the clipboard at the current cursor position, or replaces the current selection.
+    /// Does nothing if the clipboard is empty.
+    Paste,
+    /// Move the cursor with some motion.
+    Motion {
+        /// The motion to perform.
+        motion: Motion,
+        /// Select the text from the initial cursor position to the end of the motion.
+        with_select: bool,
+    },
+    /// Insert a character at the cursor. If there is a selection, replaces the selection with the character instead.
+    Insert(char),
+    /// Set the character at the cursor, overwriting the previous character. Inserts if cursor is at the end of a line.
+    /// If there is a selection, replaces the selection with the character instead.
+    Overwrite(char),
+    /// Insert a string at the cursor. If there is a selection, replaces the selection with the string instead.
+    InsertString(String),
+    /// Start a new line. Ignored for single line text inputs.
+    NewLine,
+    /// Delete the character behind the cursor.
+    /// If there is a selection, deletes the selection instead.
+    Backspace,
+    /// Delete the character at the cursor.
+    /// If there is a selection, deletes the selection instead.
+    Delete,
+    /// Indent at the cursor.
+    Indent,
+    /// Unindent at the cursor.
+    Unindent,
+    /// Moves the cursor to the character at the given position.
+    Click(IVec2),
+    /// Selects the word at the given position.
+    DoubleClick(IVec2),
+    /// Selects the line at the given position.
+    TripleClick(IVec2),
+    /// Select the text up to the given position
+    Drag(IVec2),
+    /// Scroll vertically by the given number of lines.
+    /// Negative values scroll upwards towards the start of the text, positive downwards to the end of the text.
+    Scroll {
+        /// Number of lines to scroll.
+        /// Negative values scroll upwards towards the start of the text, positive downwards to the end of the text.
+        lines: i32,
+    },
+    /// Select the entire contents of the text input buffer.
+    SelectAll,
+    /// Select the line at the cursor.
+    SelectLine,
+    /// Clear any selection.
+    Escape,
+    /// Clear the text input buffer.
+    Clear,
+    /// Set the contents of the text input buffer. The existing contents are discarded.
+    SetText(String),
+}
+
+impl TextEdit {
+    /// An action that moves the cursor.
+    ///
+    /// If `with_select` is true, it selects as it moves.
+    pub fn motion(motion: Motion, with_select: bool) -> Self {
+        Self::Motion {
+            motion,
+            with_select,
+        }
+    }
+}
+
+/// apply a motion action to the editor buffer
+pub fn apply_motion<'a>(
+    editor: &mut BorrowedWithFontSystem<Editor<'a>>,
+    shift_pressed: bool,
+    motion: Motion,
+) {
+    if shift_pressed {
+        if editor.selection() == Selection::None {
+            let cursor = editor.cursor();
+            editor.set_selection(Selection::Normal(cursor));
+        }
+    } else {
+        editor.action(Action::Escape);
+    }
+    editor.action(Action::Motion(motion));
+}
+
+/// Returns true if the cursor is at the end of a line
+pub fn is_cursor_at_end_of_line(editor: &mut Editor<'_>) -> bool {
+    let cursor = editor.cursor();
+    editor.with_buffer(|buffer| {
+        buffer
+            .lines
+            .get(cursor.line)
+            .map(|line| cursor.index == line.text().len())
+            .unwrap_or(false)
+    })
+}
+
+/// Applies the [`TextEdit`]s queued for each [`TextInputBuffer`] and emits [`TextInputEvent`]s in response.
+///
+/// After all edits are applied, if a text input entity has a [`TextInputValue`] component and its buffer was changed,
+/// then the [`TextInputValue`]'s text is updated with the new contents of the [`TextInputBuffer`].
+pub fn apply_text_edits(
+    mut commands: Commands,
+    mut font_system: ResMut<CosmicFontSystem>,
+    mut text_input_query: Query<(
+        Entity,
+        &mut TextInputBuffer,
+        &mut TextEdits,
+        &TextInputAttributes,
+        Option<&TextInputFilter>,
+        Option<&mut TextInputValue>,
+    )>,
+    mut clipboard: ResMut<Clipboard>,
+) {
+    for (entity, mut buffer, mut text_input_actions, attribs, maybe_filter, maybe_value) in
+        text_input_query.iter_mut()
+    {
+        for edit in text_input_actions.queue.drain(..) {
+            if let Err(error) = apply_text_edit(
+                buffer.editor.borrow_with(&mut font_system),
+                maybe_filter,
+                attribs.max_chars,
+                &mut clipboard,
+                &edit,
+            ) {
+                commands.trigger_targets(TextInputEvent::InvalidEdit(error, edit), entity);
+            }
+        }
+
+        if let Some(mut value) = maybe_value {
+            let contents = buffer.get_text();
+            if value.0 != contents {
+                value.0 = contents;
+                commands.trigger_targets(TextInputEvent::TextChanged, entity);
+            }
+        }
+    }
+}
+
+/// Error emitted by [`apply_text_edit`] when it fails to apply a [`TextEdit`].
+#[derive(Debug, Clone)]
+pub enum InvalidTextEditError {
+    /// Applying the edit would cause the text to fail its [`TextInputFilter`].
+    Filtered,
+    /// Applying the edit would cause the text to be longer than its maximum character limit.
+    Overflowed,
+}
+
+/// Apply a text input action to a text input
+pub fn apply_text_edit(
+    mut editor: BorrowedWithFontSystem<'_, Editor<'static>>,
+    maybe_filter: Option<&TextInputFilter>,
+    max_chars: Option<usize>,
+    clipboard_contents: &mut ResMut<Clipboard>,
+    edit: &TextEdit,
+) -> Result<(), InvalidTextEditError> {
+    editor.start_change();
+
+    match edit {
+        TextEdit::Copy => {
+            if let Some(text) = editor.copy_selection() {
+                clipboard_contents.0 = text;
+            }
+        }
+        TextEdit::Cut => {
+            if let Some(text) = editor.copy_selection() {
+                clipboard_contents.0 = text;
+                editor.delete_selection();
+            }
+        }
+        TextEdit::Paste => {
+            editor.insert_string(&clipboard_contents.0, None);
+        }
+        &TextEdit::Motion {
+            motion,
+            with_select,
+        } => {
+            apply_motion(&mut editor, with_select, motion);
+        }
+        TextEdit::Insert(ch) => {
+            editor.action(Action::Insert(*ch));
+        }
+        TextEdit::InsertString(text) => {
+            editor.insert_string(text, None);
+        }
+        &TextEdit::Overwrite(ch) => match editor.selection() {
+            Selection::None => {
+                if is_cursor_at_end_of_line(&mut editor) {
+                    editor.action(Action::Insert(ch));
+                } else {
+                    editor.action(Action::Delete);
+                    editor.action(Action::Insert(ch));
+                }
+            }
+            _ => editor.action(Action::Insert(ch)),
+        },
+        TextEdit::NewLine => {
+            editor.action(Action::Enter);
+        }
+        TextEdit::Backspace => {
+            if !editor.delete_selection() {
+                editor.action(Action::Backspace);
+            }
+        }
+        TextEdit::Delete => {
+            if !editor.delete_selection() {
+                editor.action(Action::Delete);
+            }
+        }
+        TextEdit::Indent => {
+            editor.action(Action::Indent);
+        }
+        TextEdit::Unindent => {
+            editor.action(Action::Unindent);
+        }
+        TextEdit::Click(point) => {
+            editor.action(Action::Click {
+                x: point.x,
+                y: point.y,
+            });
+        }
+        TextEdit::DoubleClick(point) => {
+            editor.action(Action::DoubleClick {
+                x: point.x,
+                y: point.y,
+            });
+        }
+        TextEdit::TripleClick(point) => {
+            editor.action(Action::TripleClick {
+                x: point.x,
+                y: point.y,
+            });
+        }
+        TextEdit::Drag(point) => {
+            editor.action(Action::Drag {
+                x: point.x,
+                y: point.y,
+            });
+        }
+        &TextEdit::Scroll { lines } => {
+            editor.action(Action::Scroll { lines });
+        }
+        TextEdit::SelectAll => {
+            editor.action(Action::Motion(Motion::BufferStart));
+            let cursor = editor.cursor();
+            editor.set_selection(Selection::Normal(cursor));
+            editor.action(Action::Motion(Motion::BufferEnd));
+        }
+        TextEdit::SelectLine => {
+            editor.action(Action::Motion(Motion::Home));
+            let cursor = editor.cursor();
+            editor.set_selection(Selection::Normal(cursor));
+            editor.action(Action::Motion(Motion::End));
+        }
+        TextEdit::Escape => {
+            editor.set_selection(Selection::None);
+        }
+        TextEdit::Clear => {
+            editor.action(Action::Motion(Motion::BufferStart));
+            let cursor = editor.cursor();
+            editor.set_selection(Selection::Normal(cursor));
+            editor.action(Action::Motion(Motion::BufferEnd));
+            editor.action(Action::Delete);
+        }
+        TextEdit::SetText(text) => {
+            editor.action(Action::Motion(Motion::Home));
+            let cursor = editor.cursor();
+            editor.set_selection(Selection::Normal(cursor));
+            editor.action(Action::Motion(Motion::End));
+            editor.insert_string(text, None);
+        }
+    }
+
+    let Some(mut change) = editor.finish_change() else {
+        return Ok(());
+    };
+
+    if change.items.is_empty() {
+        return Ok(());
+    }
+
+    if maybe_filter.is_some() || max_chars.is_some() {
+        let text = editor.with_buffer(get_cosmic_text_buffer_contents);
+        if maybe_filter.is_some_and(|filter| !filter.is_match(&text)) {
+            change.reverse();
+            editor.apply_change(&change);
+            return Err(InvalidTextEditError::Filtered);
+        }
+        if max_chars.is_some_and(|max_chars| max_chars < text.chars().count()) {
+            change.reverse();
+            editor.apply_change(&change);
+            return Err(InvalidTextEditError::Overflowed);
+        }
+    }
+
+    // Set redraw manually, sometimes the editor doesn't set it automatically.
+    editor.set_redraw(true);
+
+    Ok(())
+}
+
+/// Automatically propagated events that can be dispatched by a text input entity.
+#[derive(EntityEvent, Clone, Debug, Component)]
+#[entity_event(traversal = &'static ChildOf, auto_propagate)]
+pub enum TextInputEvent {
+    /// The text input received an invalid [`TextEdit`] that failed to be applied
+    InvalidEdit(InvalidTextEditError, TextEdit),
+    /// The contents of the text input changed due to a [`TextEdit`].
+    /// Only dispatched if a text input entity has a [`TextInputValue`] component.
+    TextChanged,
+}
diff --git a/crates/bevy_text/src/lib.rs b/crates/bevy_text/src/lib.rs
index 1e341880e5336..486ec617ef6d1 100644
--- a/crates/bevy_text/src/lib.rs
+++ b/crates/bevy_text/src/lib.rs
@@ -1,4 +1,4 @@
-//! This crate provides the tools for positioning and rendering text in Bevy.
+//! This crate provides the tools for positioning, rendering and editing text in Bevy.
 //!
 //! # `Font`
 //!
@@ -28,6 +28,10 @@
 //!    retrieving glyphs from the cache, or rasterizing to a [`FontAtlas`] if necessary.
 //! 3. [`PositionedGlyph`]s are stored in a [`TextLayoutInfo`],
 //!    which contains all the information that downstream systems need for rendering.
+//!
+//! ## Text editing
+//!
+//! See the input module for more details on text editing support.
 
 extern crate alloc;
 
@@ -38,6 +42,7 @@ mod font_atlas;
 mod font_atlas_set;
 mod font_loader;
 mod glyph;
+mod input;
 mod pipeline;
 mod text;
 mod text_access;
@@ -49,6 +54,7 @@ pub use font_atlas::*;
 pub use font_atlas_set::*;
 pub use font_loader::*;
 pub use glyph::*;
+pub use input::*;
 pub use pipeline::*;
 pub use text::*;
 pub use text_access::*;
@@ -97,10 +103,30 @@ impl Plugin for TextPlugin {
             .init_resource::<TextIterScratch>()
             .add_systems(
                 PostUpdate,
-                remove_dropped_font_atlas_sets.before(AssetEventSystems),
+                remove_dropped_font_atlas_sets
+                    .before(AssetEventSystems)
+                    .ambiguous_with(update_placeholder_layouts)
+                    .ambiguous_with(update_text_input_layouts),
             )
             .add_systems(Last, trim_cosmic_cache);
 
+        app.init_resource::<Clipboard>()
+            .init_resource::<TextCursorBlinkInterval>()
+            .add_systems(
+                PostUpdate,
+                (
+                    update_text_input_buffers,
+                    apply_text_edits,
+                    update_password_masks,
+                    update_text_input_layouts,
+                    update_placeholder_layouts,
+                )
+                    .chain()
+                    .in_set(TextInputSystems)
+                    .before(AssetEventSystems)
+                    .ambiguous_with(Text2dUpdateSystems),
+            );
+
         #[cfg(feature = "default_font")]
         {
             use bevy_asset::{AssetId, Assets};
diff --git a/crates/bevy_text/src/pipeline.rs b/crates/bevy_text/src/pipeline.rs
index ccf6245fad6b6..fb51179ebb222 100644
--- a/crates/bevy_text/src/pipeline.rs
+++ b/crates/bevy_text/src/pipeline.rs
@@ -1,6 +1,6 @@
 use alloc::sync::Arc;
 
-use bevy_asset::{AssetId, Assets};
+use bevy_asset::{AssetId, Assets, Handle};
 use bevy_color::Color;
 use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::{
@@ -136,7 +136,7 @@ impl TextPipeline {
 
             // Load Bevy fonts into cosmic-text's font system.
             let face_info = load_font_to_fontdb(
-                text_font,
+                text_font.font.clone(),
                 font_system,
                 &mut self.map_handle_to_font_id,
                 fonts,
@@ -454,10 +454,31 @@ pub struct TextLayoutInfo {
     /// Scaled and positioned glyphs in screenspace
     pub glyphs: Vec<PositionedGlyph>,
     /// Rects bounding the text block's text sections.
-    /// A text section spanning more than one line will have multiple bounding rects.
+    /// A text section spanning more than one line will have multiple bounding rects
     pub section_rects: Vec<(Entity, Rect)>,
+    /// Rects bounding the selected text
+    pub selection_rects: Vec<Rect>,
     /// The glyphs resulting size
     pub size: Vec2,
+    /// Cursor position and size
+    pub cursor: Option<(Vec2, Vec2, bool)>,
+    /// Index of glyph under the cursor
+    pub cursor_index: Option<usize>,
+    /// Offset for scrolled text
+    pub scroll: Vec2,
+}
+
+impl TextLayoutInfo {
+    /// Clear the text layout    
+    pub fn clear(&mut self) {
+        self.glyphs.clear();
+        self.section_rects.clear();
+        self.selection_rects.clear();
+        self.size = Vec2::ZERO;
+        self.cursor = None;
+        self.cursor_index = None;
+        self.scroll = Vec2::ZERO;
+    }
 }
 
 /// Size information for a corresponding [`ComputedTextBlock`] component.
@@ -492,12 +513,11 @@ impl TextMeasureInfo {
 
 /// Add the font to the cosmic text's `FontSystem`'s in-memory font database
 pub fn load_font_to_fontdb(
-    text_font: &TextFont,
+    font_handle: Handle<Font>,
     font_system: &mut cosmic_text::FontSystem,
     map_handle_to_font_id: &mut HashMap<AssetId<Font>, (cosmic_text::fontdb::ID, Arc<str>)>,
     fonts: &Assets<Font>,
 ) -> FontFaceInfo {
-    let font_handle = text_font.font.clone();
     let (face_id, family_name) = map_handle_to_font_id
         .entry(font_handle.id())
         .or_insert_with(|| {
@@ -551,7 +571,7 @@ fn get_attrs<'a>(
 }
 
 /// Calculate the size of the text area for the given buffer.
-fn buffer_dimensions(buffer: &Buffer) -> Vec2 {
+pub(crate) fn buffer_dimensions(buffer: &Buffer) -> Vec2 {
     let (width, height) = buffer
         .layout_runs()
         .map(|run| (run.line_w, run.line_height))
diff --git a/crates/bevy_text/src/text.rs b/crates/bevy_text/src/text.rs
index 88c766c6d822f..4f5f1e6851cc2 100644
--- a/crates/bevy_text/src/text.rs
+++ b/crates/bevy_text/src/text.rs
@@ -5,7 +5,7 @@ use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::{prelude::*, reflect::ReflectComponent};
 use bevy_reflect::prelude::*;
 use bevy_utils::{default, once};
-use cosmic_text::{Buffer, Metrics};
+use cosmic_text::{Buffer, Metrics, Wrap};
 use serde::{Deserialize, Serialize};
 use smallvec::SmallVec;
 use tracing::warn;
@@ -434,6 +434,17 @@ pub enum LineBreak {
     NoWrap,
 }
 
+impl From<LineBreak> for Wrap {
+    fn from(value: LineBreak) -> Self {
+        match value {
+            LineBreak::WordBoundary => Wrap::Word,
+            LineBreak::AnyCharacter => Wrap::Glyph,
+            LineBreak::WordOrCharacter => Wrap::WordOrGlyph,
+            LineBreak::NoWrap => Wrap::None,
+        }
+    }
+}
+
 /// Determines which antialiasing method to use when rendering text. By default, text is
 /// rendered with grayscale antialiasing, but this can be changed to achieve a pixelated look.
 ///
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index eb62969c6eeb6..d95509ff254aa 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -180,6 +180,9 @@ impl Plugin for UiPlugin {
 
         let ui_layout_system_config = ui_layout_system
             .in_set(UiSystems::Layout)
+            .ambiguous_with(bevy_text::update_password_masks)
+            .ambiguous_with(bevy_text::update_placeholder_layouts)
+            .ambiguous_with(bevy_text::update_text_input_layouts)
             .before(TransformSystems::Propagate);
 
         let ui_layout_system_config = ui_layout_system_config
@@ -235,6 +238,9 @@ fn build_text_interop(app: &mut App) {
             )
                 .chain()
                 .in_set(UiSystems::Content)
+                .ambiguous_with(bevy_text::update_password_masks)
+                .ambiguous_with(bevy_text::update_placeholder_layouts)
+                .ambiguous_with(bevy_text::update_text_input_layouts)
                 // Text and Text2d are independent.
                 .ambiguous_with(bevy_text::detect_text_needs_rerender::<bevy_sprite::Text2d>)
                 // Potential conflict: `Assets<Image>`
@@ -251,7 +257,10 @@ fn build_text_interop(app: &mut App) {
                 // Text2d and bevy_ui text are entirely on separate entities
                 .ambiguous_with(bevy_text::detect_text_needs_rerender::<bevy_sprite::Text2d>)
                 .ambiguous_with(bevy_sprite::update_text2d_layout)
-                .ambiguous_with(bevy_sprite::calculate_bounds_text2d),
+                .ambiguous_with(bevy_sprite::calculate_bounds_text2d)
+                .ambiguous_with(bevy_text::update_password_masks)
+                .ambiguous_with(bevy_text::update_placeholder_layouts)
+                .ambiguous_with(bevy_text::update_text_input_layouts),
         ),
     );
 
diff --git a/examples/2d/text_input_2d.rs b/examples/2d/text_input_2d.rs
new file mode 100644
index 0000000000000..b72ba7dea4672
--- /dev/null
+++ b/examples/2d/text_input_2d.rs
@@ -0,0 +1,464 @@
+//! basic bevy 2d text input
+use std::any::TypeId;
+
+use bevy::{
+    camera::{primitives::Aabb, visibility::VisibilityClass},
+    color::palettes::{
+        css::NAVY,
+        tailwind::{BLUE_900, GRAY_300, GRAY_400, SKY_300},
+    },
+    input::keyboard::{Key, KeyboardInput},
+    prelude::*,
+    render::{sync_world::TemporaryRenderEntity, Extract, RenderApp},
+    sprite::Anchor,
+    sprite_render::{
+        ExtractedSlice, ExtractedSlices, ExtractedSprite, ExtractedSpriteKind, ExtractedSprites,
+    },
+    text::{
+        CursorBlink, LineBreak, Motion, Placeholder, PlaceholderLayout, PositionedGlyph,
+        TextBounds, TextCursorBlinkInterval, TextEdit, TextEdits, TextInputBuffer,
+        TextInputSystems, TextInputTarget, TextLayoutInfo,
+    },
+    window::PrimaryWindow,
+};
+
+#[derive(Component)]
+struct TextInputSize(Vec2);
+
+#[derive(Component, Default)]
+struct Overwrite(bool);
+
+fn main() {
+    let mut app = App::new();
+
+    app.add_plugins(DefaultPlugins)
+        .add_systems(Startup, setup)
+        .add_systems(
+            PostUpdate,
+            (update_inputs, update_targets).before(TextInputSystems),
+        )
+        .add_event::<TextSubmission>()
+        .add_systems(Update, handle_submissions);
+    app.sub_app_mut(RenderApp)
+        .add_systems(ExtractSchedule, extract_text_input);
+
+    app.run();
+}
+
+fn setup(mut commands: Commands) {
+    commands.spawn(Camera2d);
+
+    commands.spawn((
+        Text2d::new("submit with SHIFT + ENTER"),
+        Anchor::TOP_CENTER,
+        TextBounds {
+            width: Some(500.),
+            height: None,
+        },
+        TextLayout {
+            linebreak: LineBreak::AnyCharacter,
+            justify: Justify::Left,
+        },
+        Transform::from_translation(Vec3::new(0., -25., 0.)),
+    ));
+
+    commands.spawn((
+        TextInputBuffer {
+            ..Default::default()
+        },
+        CursorBlink {
+            cursor_blink_timer: 0.,
+        },
+        Overwrite::default(),
+        TextInputSize(Vec2::new(500., 250.)),
+        Transform::from_translation(Vec3::new(0., 150., 0.)), // This is in UI coordinates
+        Placeholder::new("type here.."),
+        Visibility::default(),
+        VisibilityClass([TypeId::of::<Sprite>()].into()), // Text input is rendered as sprites
+        Anchor::CENTER,
+    ));
+}
+
+// Here we set the text rendering target's size to match based on the window's scale factor
+fn update_targets(
+    mut commands: Commands,
+    windows: Query<&Window, With<PrimaryWindow>>,
+    mut query: Query<(
+        Entity,
+        &TextInputSize,
+        &mut TextInputTarget,
+        &Anchor,
+        Option<&mut Aabb>,
+    )>,
+) {
+    let scale_factor = windows
+        .single()
+        .map(|window| window.resolution.scale_factor())
+        .unwrap_or(1.0);
+    for (entity, size, mut target, anchor, aabb) in query.iter_mut() {
+        if target.set_if_neq(TextInputTarget {
+            size: size.0 * scale_factor,
+            scale_factor,
+        }) {
+            let new_aabb = anchor.calculate_bounds(size.0);
+
+            if let Some(mut aabb) = aabb {
+                *aabb = new_aabb;
+            } else {
+                commands.entity(entity).try_insert(new_aabb);
+            }
+        }
+    }
+}
+
+#[derive(BufferedEvent, Clone, Debug, Component)]
+struct TextSubmission;
+
+// This example demonstrates how to convert keyboard input to text edits that get resolved
+fn update_inputs(
+    mut keyboard_events: EventReader<KeyboardInput>,
+    mut query: Query<(&mut TextEdits, &mut Overwrite)>,
+    keyboard_state: Res<ButtonInput<Key>>,
+    mut submit_events: EventWriter<TextSubmission>,
+) {
+    for key_input in keyboard_events.read() {
+        if !key_input.state.is_pressed() {
+            return;
+        }
+
+        let pressed_key = &key_input.logical_key;
+        let is_shift_pressed = keyboard_state.pressed(Key::Shift);
+        #[cfg(not(target_os = "macos"))]
+        let is_command_pressed = keyboard_state.pressed(Key::Control);
+        #[cfg(target_os = "macos")]
+        let is_command_pressed = keyboard_state.pressed(Key::Super);
+
+        for (mut actions, mut overwrite) in query.iter_mut() {
+            if is_command_pressed {
+                match &pressed_key {
+                    Key::Character(str) => {
+                        if let Some(char) = str.chars().next() {
+                            // convert to lowercase so that the commands work with capslock on
+                            match (char.to_ascii_lowercase(), is_shift_pressed) {
+                                ('c', false) => {
+                                    // copy
+                                    actions.queue(TextEdit::Copy);
+                                }
+                                ('x', false) => {
+                                    // cut
+                                    actions.queue(TextEdit::Cut);
+                                }
+                                ('v', false) => {
+                                    // paste
+                                    actions.queue(TextEdit::Paste);
+                                }
+                                ('a', false) => {
+                                    // select all
+                                    actions.queue(TextEdit::SelectAll);
+                                }
+                                _ => {
+                                    // not recognized, ignore
+                                }
+                            }
+                        }
+                    }
+                    Key::ArrowLeft => {
+                        actions.queue(TextEdit::Motion {
+                            motion: Motion::PreviousWord,
+                            with_select: is_shift_pressed,
+                        });
+                    }
+                    Key::ArrowRight => {
+                        actions.queue(TextEdit::Motion {
+                            motion: Motion::NextWord,
+                            with_select: is_shift_pressed,
+                        });
+                    }
+                    Key::ArrowUp => {
+                        actions.queue(TextEdit::Scroll { lines: -1 });
+                    }
+                    Key::ArrowDown => {
+                        actions.queue(TextEdit::Scroll { lines: 1 });
+                    }
+                    Key::Home => {
+                        actions.queue(TextEdit::motion(Motion::BufferStart, is_shift_pressed));
+                    }
+                    Key::End => {
+                        actions.queue(TextEdit::motion(Motion::BufferEnd, is_shift_pressed));
+                    }
+                    _ => {
+                        // not recognized, ignore
+                    }
+                }
+            } else {
+                match &pressed_key {
+                    Key::Character(_) | Key::Space => {
+                        let str = if let Key::Character(str) = &pressed_key {
+                            str.chars()
+                        } else {
+                            " ".chars()
+                        };
+                        for char in str {
+                            actions.queue(if overwrite.0 {
+                                TextEdit::Overwrite(char)
+                            } else {
+                                TextEdit::Insert(char)
+                            });
+                        }
+                    }
+                    Key::Enter => {
+                        if is_shift_pressed {
+                            submit_events.write(TextSubmission);
+                        } else {
+                            actions.queue(TextEdit::NewLine);
+                        }
+                    }
+                    Key::Backspace => {
+                        actions.queue(TextEdit::Backspace);
+                    }
+                    Key::Delete => {
+                        if is_shift_pressed {
+                            actions.queue(TextEdit::Cut);
+                        } else {
+                            actions.queue(TextEdit::Delete);
+                        }
+                    }
+                    Key::PageUp => {
+                        actions.queue(TextEdit::motion(Motion::PageUp, is_shift_pressed));
+                    }
+                    Key::PageDown => {
+                        actions.queue(TextEdit::motion(Motion::PageDown, is_shift_pressed));
+                    }
+                    Key::ArrowLeft => {
+                        actions.queue(TextEdit::motion(Motion::Left, is_shift_pressed));
+                    }
+                    Key::ArrowRight => {
+                        actions.queue(TextEdit::motion(Motion::Right, is_shift_pressed));
+                    }
+                    Key::ArrowUp => {
+                        actions.queue(TextEdit::motion(Motion::Up, is_shift_pressed));
+                    }
+                    Key::ArrowDown => {
+                        actions.queue(TextEdit::motion(Motion::Down, is_shift_pressed));
+                    }
+                    Key::Home => {
+                        actions.queue(TextEdit::motion(Motion::Home, is_shift_pressed));
+                    }
+                    Key::End => {
+                        actions.queue(TextEdit::motion(Motion::End, is_shift_pressed));
+                    }
+                    Key::Escape => {
+                        actions.queue(TextEdit::Escape);
+                    }
+                    Key::Tab => {
+                        actions.queue(if is_shift_pressed {
+                            TextEdit::Unindent
+                        } else {
+                            TextEdit::Indent
+                        });
+                    }
+                    Key::Insert => {
+                        overwrite.0 = !overwrite.0;
+                    }
+                    _ => {}
+                }
+            }
+        }
+    }
+}
+
+fn handle_submissions(
+    mut submit_events: EventReader<TextSubmission>,
+    text_query: Single<&mut Text2d>,
+    buffer_query: Single<&TextInputBuffer>,
+) {
+    let mut text = text_query.into_inner();
+    let buffer = *buffer_query;
+
+    for _ in submit_events.read() {
+        text.0 = buffer.get_text().clone();
+    }
+}
+
+/// Each text fragment is extracted as a sprite for rendering
+fn extract_text_input(
+    mut commands: Commands,
+    mut extracted_sprites: ResMut<ExtractedSprites>,
+    mut extracted_slices: ResMut<ExtractedSlices>,
+    texture_atlases: Extract<Res<Assets<TextureAtlasLayout>>>,
+    cursor_blink_interval: Extract<Res<TextCursorBlinkInterval>>,
+    text_input_query: Extract<
+        Query<(
+            Entity,
+            &TextInputBuffer,
+            &TextLayoutInfo,
+            Option<&PlaceholderLayout>,
+            Option<&CursorBlink>,
+            &TextInputTarget,
+            &Overwrite,
+            &ViewVisibility,
+            &Anchor,
+            &GlobalTransform,
+        )>,
+    >,
+) {
+    let mut start = extracted_slices.slices.len();
+    let mut end = start + 1;
+
+    for (
+        main_entity,
+        buffer,
+        text_layout,
+        maybe_placeholder_layout,
+        maybe_cursor_blink,
+        target,
+        overwrite,
+        view_visibility,
+        anchor,
+        global_transform,
+    ) in text_input_query.iter()
+    {
+        if !view_visibility.get() {
+            continue;
+        }
+
+        let top_left = (Anchor::TOP_LEFT.as_vec() - anchor.as_vec()) * target.size;
+
+        let (layout, color): (_, Color) = if let Some(placeholder_layout) =
+            maybe_placeholder_layout.filter(|_| buffer.is_empty())
+        {
+            (placeholder_layout.layout(), SKY_300.into())
+        } else {
+            (text_layout, GRAY_300.into())
+        };
+
+        let transform = *global_transform
+            * GlobalTransform::from_scale(Vec2::splat(target.scale_factor.recip()).extend(1.))
+            * GlobalTransform::from_translation(top_left.extend(0.));
+
+        extracted_sprites.sprites.push(ExtractedSprite {
+            main_entity,
+            render_entity: commands.spawn(TemporaryRenderEntity).id(),
+            transform,
+            color: NAVY.into(),
+            image_handle_id: AssetId::default(),
+            flip_x: false,
+            flip_y: false,
+            kind: ExtractedSpriteKind::Single {
+                anchor: Anchor::TOP_LEFT.as_vec(),
+                rect: None,
+                scaling_mode: None,
+                custom_size: Some(target.size),
+            },
+        });
+
+        let blink = maybe_cursor_blink
+            .is_none_or(|t| cursor_blink_interval.0.as_secs_f32() < t.cursor_blink_timer);
+
+        let transform = transform
+            * GlobalTransform::from_translation(
+                Vec2::new(-layout.scroll.x, layout.scroll.y).extend(0.),
+            );
+
+        for (i, rect) in layout.selection_rects.iter().enumerate() {
+            let size = if (1..layout.selection_rects.len()).contains(&i) {
+                rect.size() + Vec2::Y
+            } else {
+                rect.size()
+            } + 2. * Vec2::X;
+
+            extracted_sprites.sprites.push(ExtractedSprite {
+                main_entity,
+                render_entity: commands.spawn(TemporaryRenderEntity).id(),
+                transform: transform
+                    * GlobalTransform::from_translation(Vec3::new(rect.min.x, -rect.min.y, 0.)),
+                color: BLUE_900.into(),
+                image_handle_id: AssetId::default(),
+                flip_x: false,
+                flip_y: false,
+                kind: ExtractedSpriteKind::Single {
+                    anchor: Anchor::TOP_LEFT.as_vec(),
+                    rect: None,
+                    scaling_mode: None,
+                    custom_size: Some(size),
+                },
+            });
+        }
+
+        for (
+            i,
+            PositionedGlyph {
+                position,
+                atlas_info,
+                ..
+            },
+        ) in layout.glyphs.iter().enumerate()
+        {
+            let rect = texture_atlases
+                .get(atlas_info.texture_atlas)
+                .unwrap()
+                .textures[atlas_info.location.glyph_index]
+                .as_rect();
+            extracted_slices.slices.push(ExtractedSlice {
+                offset: Vec2::new(position.x, -position.y),
+                rect,
+                size: rect.size(),
+            });
+
+            if layout.glyphs.get(i + 1).is_none_or(|info| {
+                info.atlas_info.texture != atlas_info.texture
+                    || layout.cursor_index.is_some_and(|j| j == i + 1)
+            }) {
+                extracted_sprites.sprites.push(ExtractedSprite {
+                    main_entity,
+                    render_entity: commands.spawn(TemporaryRenderEntity).id(),
+                    transform,
+                    color: color.into(),
+                    image_handle_id: atlas_info.texture,
+                    flip_x: false,
+                    flip_y: false,
+                    kind: ExtractedSpriteKind::Slices {
+                        indices: start..end,
+                    },
+                });
+                start = end;
+            }
+            end += 1;
+        }
+
+        if blink {
+            continue;
+        }
+
+        let Some((position, layout_cursor_size, _affinity)) = layout.cursor else {
+            continue;
+        };
+
+        let (w, _cursor_z_offset) = if overwrite.0 {
+            (layout_cursor_size.x, -0.001)
+        } else {
+            (0.2 * buffer.space_advance, 0.)
+        };
+
+        let cursor_size = Vec2::new(w, layout_cursor_size.y).ceil();
+        let cursor_x = position.x - 0.5 * (layout_cursor_size.x - cursor_size.x);
+        let cursor_y = -position.y;
+
+        extracted_sprites.sprites.push(ExtractedSprite {
+            main_entity,
+            render_entity: commands.spawn(TemporaryRenderEntity).id(),
+            transform: transform
+                * GlobalTransform::from_translation(Vec3::new(cursor_x, cursor_y, 0.)),
+            color: GRAY_400.into(),
+            image_handle_id: AssetId::default(),
+            flip_x: false,
+            flip_y: false,
+            kind: ExtractedSpriteKind::Single {
+                anchor: Vec2::ZERO,
+                rect: None,
+                scaling_mode: None,
+                custom_size: Some(cursor_size),
+            },
+        });
+    }
+}
diff --git a/examples/README.md b/examples/README.md
index 3d2870e4971ed..25c44ab3d6eec 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -129,6 +129,7 @@ Example | Description
 [Sprite Slice](../examples/2d/sprite_slice.rs) | Showcases slicing sprites into sections that can be scaled independently via the 9-patch technique
 [Sprite Tile](../examples/2d/sprite_tile.rs) | Renders a sprite tiled in a grid
 [Text 2D](../examples/2d/text2d.rs) | Generates text in 2D
+[Text Input 2D](../examples/2d/text_input_2d.rs) | Text input in 2D
 [Texture Atlas](../examples/2d/texture_atlas.rs) | Generates a texture atlas (sprite sheet) from individual sprites
 [Tilemap Chunk](../examples/2d/tilemap_chunk.rs) | Renders a tilemap chunk
 [Transparency in 2D](../examples/2d/transparency_2d.rs) | Demonstrates transparency in 2d
diff --git a/release-content/migration-guides/load_font_to_fontdb_parameter_change.md b/release-content/migration-guides/load_font_to_fontdb_parameter_change.md
new file mode 100644
index 0000000000000..c2dfdc58b5a49
--- /dev/null
+++ b/release-content/migration-guides/load_font_to_fontdb_parameter_change.md
@@ -0,0 +1,6 @@
+---
+title: `load_font_to_fontdb` parameter change
+pull_requests: [20763]
+---
+
+`load_font_to_fontdb`'s `text_font: &TextFont` parameter has been renamed to `font_handle` and its type has been changed to `Handle<Font>`.
diff --git a/release-content/release-notes/bevy_text_input_module.md b/release-content/release-notes/bevy_text_input_module.md
new file mode 100644
index 0000000000000..a160ab0a91d70
--- /dev/null
+++ b/release-content/release-notes/bevy_text_input_module.md
@@ -0,0 +1,34 @@
+---
+title: `bevy_text::input` module
+authors: ["@Ickshonpe", "@Zeophlite"]
+pull_requests: [20366, 20763]
+---
+
+A long-standing feature request from our users is support for text input. Whether the user is creating a new character, logging in with a username and password, or creating a new save file, it's vitally important for them to be able to enter a string of text. Unfortunately, writing a robust and feature-rich text input widget is not easy, especially one that supports all of the expected capabilities (such as range selection, and scrolling). This effort is made much easier now that Bevy has incorporated the `cosmic_text` crate for text handling: much of the underlying logic is handled by them.
+
+Features:
+
+* Placeholder text for empty inputs.
+* Password mode.
+* Filters applied at edit.
+* Autopropagated events emitted on submission, invalid edits and text changes.
+* Input method agnostic, users queue `TextEdit`s to make changes to the text input's buffer.
+* Max character limit.
+* Responsive height sizing.
+* Vertical and horizontal scrolling
+* Text selection.
+* Cut, copy and paste.
+* Numeric input mode.
+* Multi-line text input with an optional single line mode.
+* Support for the common navigation actions like arrow key navigation, home, end, page down, page up, next word, end of paragraph, etc.
+* Backspace.
+* Overwrite mode.
+* Click to place cursor.
+* Drag to select.
+* Double click to select a word.
+* Triple click to select a line.
+* Indent and unindent.
+* A `TextInputValue` component that contains a copy of the buffer's text and is automatically synchronized on edits. On insertion the `TextInputValue`s contents replace the current text in the `TextInputBuffer`.
+* Support for bidirectional text, including RTL scripts such as Arabic and Hebrew.
+
+Check out the `text_input_2d` example to see a usage example.
diff --git a/release-content/release-notes/scene-type-crates.md b/release-content/release-notes/scene-type-crates.md
index 9a3abd33120d8..cea212e03da91 100644
--- a/release-content/release-notes/scene-type-crates.md
+++ b/release-content/release-notes/scene-type-crates.md
@@ -1,6 +1,6 @@
 ---
 title: Define scenes without depending on bevy_render
-authors: ["@atlv24", "@Ickshonpe", "@zeophlite"]
+authors: ["@atlv24", "@Ickshonpe", "@Zeophlite"]
 pull_requests: [20485, 20330, 18703, 20587, 20502, 19997, 19991, 20000, 19949, 19943, 19953, 20498, 20496, 20493, 20492, 20491, 20488, 20487, 20486, 20483, 20480, 20479, 20478, 20477, 20473, 20472, 20471, 20470, 20392, 20390, 20388, 20345, 20344, 20051, 19985, 19973, 19965, 19963, 19962, 19960, 19959, 19958, 19957, 19956, 19955, 19954, 16620, 16619, 15700, 15666, 15650]
 ---