Merge remote-tracking branch 'origin/master' into feat/multi-window-support

# Conflicts:
#	Cargo.toml
#	core/src/window/icon.rs
#	core/src/window/id.rs
#	core/src/window/position.rs
#	core/src/window/settings.rs
#	examples/integration/src/main.rs
#	examples/integration_opengl/src/main.rs
#	glutin/src/application.rs
#	native/src/subscription.rs
#	native/src/window.rs
#	runtime/src/window/action.rs
#	src/lib.rs
#	src/window.rs
#	winit/Cargo.toml
#	winit/src/application.rs
#	winit/src/icon.rs
#	winit/src/settings.rs
#	winit/src/window.rs

19 files changed, 2339 insertions, 0 deletions

diff --git a/runtime/src/clipboard.rs b/runtime/src/clipboard.rs
new file mode 100644
index 00000000..bc450912
--- /dev/null
+++ b/runtime/src/clipboard.rs
@@ -0,0 +1,53 @@
+//! Access the clipboard.
+use crate::command::{self, Command};
+use crate::futures::MaybeSend;
+
+use std::fmt;
+
+/// A clipboard action to be performed by some [`Command`].
+///
+/// [`Command`]: crate::Command
+pub enum Action<T> {
+    /// Read the clipboard and produce `T` with the result.
+    Read(Box<dyn Fn(Option<String>) -> T>),
+
+    /// Write the given contents to the clipboard.
+    Write(String),
+}
+
+impl<T> Action<T> {
+    /// Maps the output of a clipboard [`Action`] using the provided closure.
+    pub fn map<A>(
+        self,
+        f: impl Fn(T) -> A + 'static + MaybeSend + Sync,
+    ) -> Action<A>
+    where
+        T: 'static,
+    {
+        match self {
+            Self::Read(o) => Action::Read(Box::new(move |s| f(o(s)))),
+            Self::Write(content) => Action::Write(content),
+        }
+    }
+}
+
+impl<T> fmt::Debug for Action<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Read(_) => write!(f, "Action::Read"),
+            Self::Write(_) => write!(f, "Action::Write"),
+        }
+    }
+}
+
+/// Read the current contents of the clipboard.
+pub fn read<Message>(
+    f: impl Fn(Option<String>) -> Message + 'static,
+) -> Command<Message> {
+    Command::single(command::Action::Clipboard(Action::Read(Box::new(f))))
+}
+
+/// Write the given contents to the clipboard.
+pub fn write<Message>(contents: String) -> Command<Message> {
+    Command::single(command::Action::Clipboard(Action::Write(contents)))
+}
diff --git a/runtime/src/command.rs b/runtime/src/command.rs
new file mode 100644
index 00000000..cd4c51ff
--- /dev/null
+++ b/runtime/src/command.rs
@@ -0,0 +1,108 @@
+//! Run asynchronous actions.
+mod action;
+
+pub use action::Action;
+
+use crate::core::widget;
+use crate::futures::MaybeSend;
+
+use std::fmt;
+use std::future::Future;
+
+/// A set of asynchronous actions to be performed by some runtime.
+#[must_use = "`Command` must be returned to runtime to take effect"]
+pub struct Command<T>(Internal<Action<T>>);
+
+#[derive(Debug)]
+enum Internal<T> {
+    None,
+    Single(T),
+    Batch(Vec<T>),
+}
+
+impl<T> Command<T> {
+    /// Creates an empty [`Command`].
+    ///
+    /// In other words, a [`Command`] that does nothing.
+    pub const fn none() -> Self {
+        Self(Internal::None)
+    }
+
+    /// Creates a [`Command`] that performs a single [`Action`].
+    pub const fn single(action: Action<T>) -> Self {
+        Self(Internal::Single(action))
+    }
+
+    /// Creates a [`Command`] that performs a [`widget::Operation`].
+    pub fn widget(operation: impl widget::Operation<T> + 'static) -> Self {
+        Self::single(Action::Widget(Box::new(operation)))
+    }
+
+    /// Creates a [`Command`] that performs the action of the given future.
+    pub fn perform<A>(
+        future: impl Future<Output = T> + 'static + MaybeSend,
+        f: impl FnOnce(T) -> A + 'static + MaybeSend,
+    ) -> Command<A> {
+        use iced_futures::futures::FutureExt;
+
+        Command::single(Action::Future(Box::pin(future.map(f))))
+    }
+
+    /// Creates a [`Command`] that performs the actions of all the given
+    /// commands.
+    ///
+    /// Once this command is run, all the commands will be executed at once.
+    pub fn batch(commands: impl IntoIterator<Item = Command<T>>) -> Self {
+        let mut batch = Vec::new();
+
+        for Command(command) in commands {
+            match command {
+                Internal::None => {}
+                Internal::Single(command) => batch.push(command),
+                Internal::Batch(commands) => batch.extend(commands),
+            }
+        }
+
+        Self(Internal::Batch(batch))
+    }
+
+    /// Applies a transformation to the result of a [`Command`].
+    pub fn map<A>(
+        self,
+        f: impl Fn(T) -> A + 'static + MaybeSend + Sync + Clone,
+    ) -> Command<A>
+    where
+        T: 'static,
+        A: 'static,
+    {
+        match self.0 {
+            Internal::None => Command::none(),
+            Internal::Single(action) => Command::single(action.map(f)),
+            Internal::Batch(batch) => Command(Internal::Batch(
+                batch
+                    .into_iter()
+                    .map(|action| action.map(f.clone()))
+                    .collect(),
+            )),
+        }
+    }
+
+    /// Returns all of the actions of the [`Command`].
+    pub fn actions(self) -> Vec<Action<T>> {
+        let Command(command) = self;
+
+        match command {
+            Internal::None => Vec::new(),
+            Internal::Single(action) => vec![action],
+            Internal::Batch(batch) => batch,
+        }
+    }
+}
+
+impl<T> fmt::Debug for Command<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Command(command) = self;
+
+        command.fmt(f)
+    }
+}
diff --git a/runtime/src/command/action.rs b/runtime/src/command/action.rs
new file mode 100644
index 00000000..b2594379
--- /dev/null
+++ b/runtime/src/command/action.rs
@@ -0,0 +1,88 @@
+use crate::clipboard;
+use crate::core::widget;
+use crate::font;
+use crate::system;
+use crate::window;
+
+use iced_futures::MaybeSend;
+
+use std::borrow::Cow;
+use std::fmt;
+
+/// An action that a [`Command`] can perform.
+///
+/// [`Command`]: crate::Command
+pub enum Action<T> {
+    /// Run a [`Future`] to completion.
+    ///
+    /// [`Future`]: iced_futures::BoxFuture
+    Future(iced_futures::BoxFuture<T>),
+
+    /// Run a clipboard action.
+    Clipboard(clipboard::Action<T>),
+
+    /// Run a window action.
+    Window(window::Id, window::Action<T>),
+
+    /// Run a system action.
+    System(system::Action<T>),
+
+    /// Run a widget action.
+    Widget(Box<dyn widget::Operation<T>>),
+
+    /// Load a font from its bytes.
+    LoadFont {
+        /// The bytes of the font to load.
+        bytes: Cow<'static, [u8]>,
+
+        /// The message to produce when the font has been loaded.
+        tagger: Box<dyn Fn(Result<(), font::Error>) -> T>,
+    },
+}
+
+impl<T> Action<T> {
+    /// Applies a transformation to the result of a [`Command`].
+    ///
+    /// [`Command`]: crate::Command
+    pub fn map<A>(
+        self,
+        f: impl Fn(T) -> A + 'static + MaybeSend + Sync,
+    ) -> Action<A>
+    where
+        A: 'static,
+        T: 'static,
+    {
+        use iced_futures::futures::FutureExt;
+
+        match self {
+            Self::Future(future) => Action::Future(Box::pin(future.map(f))),
+            Self::Clipboard(action) => Action::Clipboard(action.map(f)),
+            Self::Window(id, window) => Action::Window(id, window.map(f)),
+            Self::System(system) => Action::System(system.map(f)),
+            Self::Widget(operation) => {
+                Action::Widget(Box::new(widget::operation::map(operation, f)))
+            }
+            Self::LoadFont { bytes, tagger } => Action::LoadFont {
+                bytes,
+                tagger: Box::new(move |result| f(tagger(result))),
+            },
+        }
+    }
+}
+
+impl<T> fmt::Debug for Action<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Future(_) => write!(f, "Action::Future"),
+            Self::Clipboard(action) => {
+                write!(f, "Action::Clipboard({action:?})")
+            }
+            Self::Window(id, action) => {
+                write!(f, "Action::Window({id:?}, {action:?})")
+            }
+            Self::System(action) => write!(f, "Action::System({action:?})"),
+            Self::Widget(_action) => write!(f, "Action::Widget"),
+            Self::LoadFont { .. } => write!(f, "Action::LoadFont"),
+        }
+    }
+}
diff --git a/runtime/src/debug/basic.rs b/runtime/src/debug/basic.rs
new file mode 100644
index 00000000..32f725a1
--- /dev/null
+++ b/runtime/src/debug/basic.rs
@@ -0,0 +1,226 @@
+#![allow(missing_docs)]
+use crate::core::time;
+
+use std::collections::VecDeque;
+
+/// A bunch of time measurements for debugging purposes.
+#[derive(Debug)]
+pub struct Debug {
+    is_enabled: bool,
+
+    startup_start: time::Instant,
+    startup_duration: time::Duration,
+
+    update_start: time::Instant,
+    update_durations: TimeBuffer,
+
+    view_start: time::Instant,
+    view_durations: TimeBuffer,
+
+    layout_start: time::Instant,
+    layout_durations: TimeBuffer,
+
+    event_start: time::Instant,
+    event_durations: TimeBuffer,
+
+    draw_start: time::Instant,
+    draw_durations: TimeBuffer,
+
+    render_start: time::Instant,
+    render_durations: TimeBuffer,
+
+    message_count: usize,
+    last_messages: VecDeque<String>,
+}
+
+impl Debug {
+    /// Creates a new [`struct@Debug`].
+    pub fn new() -> Self {
+        let now = time::Instant::now();
+
+        Self {
+            is_enabled: false,
+            startup_start: now,
+            startup_duration: time::Duration::from_secs(0),
+
+            update_start: now,
+            update_durations: TimeBuffer::new(200),
+
+            view_start: now,
+            view_durations: TimeBuffer::new(200),
+
+            layout_start: now,
+            layout_durations: TimeBuffer::new(200),
+
+            event_start: now,
+            event_durations: TimeBuffer::new(200),
+
+            draw_start: now,
+            draw_durations: TimeBuffer::new(200),
+
+            render_start: now,
+            render_durations: TimeBuffer::new(50),
+
+            message_count: 0,
+            last_messages: VecDeque::new(),
+        }
+    }
+
+    pub fn toggle(&mut self) {
+        self.is_enabled = !self.is_enabled;
+    }
+
+    pub fn startup_started(&mut self) {
+        self.startup_start = time::Instant::now();
+    }
+
+    pub fn startup_finished(&mut self) {
+        self.startup_duration = time::Instant::now() - self.startup_start;
+    }
+
+    pub fn update_started(&mut self) {
+        self.update_start = time::Instant::now();
+    }
+
+    pub fn update_finished(&mut self) {
+        self.update_durations
+            .push(time::Instant::now() - self.update_start);
+    }
+
+    pub fn view_started(&mut self) {
+        self.view_start = time::Instant::now();
+    }
+
+    pub fn view_finished(&mut self) {
+        self.view_durations
+            .push(time::Instant::now() - self.view_start);
+    }
+
+    pub fn layout_started(&mut self) {
+        self.layout_start = time::Instant::now();
+    }
+
+    pub fn layout_finished(&mut self) {
+        self.layout_durations
+            .push(time::Instant::now() - self.layout_start);
+    }
+
+    pub fn event_processing_started(&mut self) {
+        self.event_start = time::Instant::now();
+    }
+
+    pub fn event_processing_finished(&mut self) {
+        self.event_durations
+            .push(time::Instant::now() - self.event_start);
+    }
+
+    pub fn draw_started(&mut self) {
+        self.draw_start = time::Instant::now();
+    }
+
+    pub fn draw_finished(&mut self) {
+        self.draw_durations
+            .push(time::Instant::now() - self.draw_start);
+    }
+
+    pub fn render_started(&mut self) {
+        self.render_start = time::Instant::now();
+    }
+
+    pub fn render_finished(&mut self) {
+        self.render_durations
+            .push(time::Instant::now() - self.render_start);
+    }
+
+    pub fn log_message<Message: std::fmt::Debug>(&mut self, message: &Message) {
+        self.last_messages.push_back(format!("{message:?}"));
+
+        if self.last_messages.len() > 10 {
+            let _ = self.last_messages.pop_front();
+        }
+
+        self.message_count += 1;
+    }
+
+    pub fn overlay(&self) -> Vec<String> {
+        if !self.is_enabled {
+            return Vec::new();
+        }
+
+        let mut lines = Vec::new();
+
+        fn key_value<T: std::fmt::Debug>(key: &str, value: T) -> String {
+            format!("{key} {value:?}")
+        }
+
+        lines.push(format!(
+            "{} {} - {}",
+            env!("CARGO_PKG_NAME"),
+            env!("CARGO_PKG_VERSION"),
+            env!("CARGO_PKG_REPOSITORY"),
+        ));
+        lines.push(key_value("Startup:", self.startup_duration));
+        lines.push(key_value("Update:", self.update_durations.average()));
+        lines.push(key_value("View:", self.view_durations.average()));
+        lines.push(key_value("Layout:", self.layout_durations.average()));
+        lines.push(key_value(
+            "Event processing:",
+            self.event_durations.average(),
+        ));
+        lines.push(key_value(
+            "Primitive generation:",
+            self.draw_durations.average(),
+        ));
+        lines.push(key_value("Render:", self.render_durations.average()));
+        lines.push(key_value("Message count:", self.message_count));
+        lines.push(String::from("Last messages:"));
+        lines.extend(self.last_messages.iter().map(|msg| {
+            if msg.len() <= 100 {
+                format!("    {msg}")
+            } else {
+                format!("    {msg:.100}...")
+            }
+        }));
+
+        lines
+    }
+}
+
+impl Default for Debug {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[derive(Debug)]
+struct TimeBuffer {
+    head: usize,
+    size: usize,
+    contents: Vec<time::Duration>,
+}
+
+impl TimeBuffer {
+    fn new(capacity: usize) -> TimeBuffer {
+        TimeBuffer {
+            head: 0,
+            size: 0,
+            contents: vec![time::Duration::from_secs(0); capacity],
+        }
+    }
+
+    fn push(&mut self, duration: time::Duration) {
+        self.head = (self.head + 1) % self.contents.len();
+        self.contents[self.head] = duration;
+        self.size = (self.size + 1).min(self.contents.len());
+    }
+
+    fn average(&self) -> time::Duration {
+        let sum: time::Duration = if self.size == self.contents.len() {
+            self.contents[..].iter().sum()
+        } else {
+            self.contents[..self.size].iter().sum()
+        };
+
+        sum / self.size.max(1) as u32
+    }
+}
diff --git a/runtime/src/debug/null.rs b/runtime/src/debug/null.rs
new file mode 100644
index 00000000..2db0eebb
--- /dev/null
+++ b/runtime/src/debug/null.rs
@@ -0,0 +1,47 @@
+#![allow(missing_docs)]
+#[derive(Debug, Default)]
+pub struct Debug;
+
+impl Debug {
+    pub fn new() -> Self {
+        Self
+    }
+
+    pub fn startup_started(&mut self) {}
+
+    pub fn startup_finished(&mut self) {}
+
+    pub fn update_started(&mut self) {}
+
+    pub fn update_finished(&mut self) {}
+
+    pub fn view_started(&mut self) {}
+
+    pub fn view_finished(&mut self) {}
+
+    pub fn layout_started(&mut self) {}
+
+    pub fn layout_finished(&mut self) {}
+
+    pub fn event_processing_started(&mut self) {}
+
+    pub fn event_processing_finished(&mut self) {}
+
+    pub fn draw_started(&mut self) {}
+
+    pub fn draw_finished(&mut self) {}
+
+    pub fn render_started(&mut self) {}
+
+    pub fn render_finished(&mut self) {}
+
+    pub fn log_message<Message: std::fmt::Debug>(
+        &mut self,
+        _message: &Message,
+    ) {
+    }
+
+    pub fn overlay(&self) -> Vec<String> {
+        Vec::new()
+    }
+}
diff --git a/runtime/src/font.rs b/runtime/src/font.rs
new file mode 100644
index 00000000..15359694
--- /dev/null
+++ b/runtime/src/font.rs
@@ -0,0 +1,19 @@
+//! Load and use fonts.
+pub use iced_core::font::*;
+
+use crate::command::{self, Command};
+use std::borrow::Cow;
+
+/// An error while loading a font.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Error {}
+
+/// Load a font from its bytes.
+pub fn load(
+    bytes: impl Into<Cow<'static, [u8]>>,
+) -> Command<Result<(), Error>> {
+    Command::single(command::Action::LoadFont {
+        bytes: bytes.into(),
+        tagger: Box::new(std::convert::identity),
+    })
+}
diff --git a/runtime/src/keyboard.rs b/runtime/src/keyboard.rs
new file mode 100644
index 00000000..012538e3
--- /dev/null
+++ b/runtime/src/keyboard.rs
@@ -0,0 +1,2 @@
+//! Track keyboard events.
+pub use iced_core::keyboard::*;
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
new file mode 100644
index 00000000..4bbf9687
--- /dev/null
+++ b/runtime/src/lib.rs
@@ -0,0 +1,72 @@
+//! A renderer-agnostic native GUI runtime.
+//!
+//! ![The native path of the Iced ecosystem](https://github.com/iced-rs/iced/raw/improvement/update-ecosystem-and-roadmap/docs/graphs/native.png)
+//!
+//! `iced_native` takes [`iced_core`] and builds a native runtime on top of it,
+//! featuring:
+//!
+//! - A custom layout engine, greatly inspired by [`druid`]
+//! - Event handling for all the built-in widgets
+//! - A renderer-agnostic API
+//!
+//! To achieve this, it introduces a couple of reusable interfaces:
+//!
+//! - A [`Widget`] trait, which is used to implement new widgets: from layout
+//!   requirements to event and drawing logic.
+//! - A bunch of `Renderer` traits, meant to keep the crate renderer-agnostic.
+//!
+//! # Usage
+//! The strategy to use this crate depends on your particular use case. If you
+//! want to:
+//! - Implement a custom shell or integrate it in your own system, check out the
+//! [`UserInterface`] type.
+//! - Build a new renderer, see the [renderer] module.
+//! - Build a custom widget, start at the [`Widget`] trait.
+//!
+//! [`iced_core`]: https://github.com/iced-rs/iced/tree/0.9/core
+//! [`iced_winit`]: https://github.com/iced-rs/iced/tree/0.9/winit
+//! [`druid`]: https://github.com/xi-editor/druid
+//! [`raw-window-handle`]: https://github.com/rust-windowing/raw-window-handle
+//! [renderer]: crate::renderer
+#![doc(
+    html_logo_url = "https://raw.githubusercontent.com/iced-rs/iced/9ab6923e943f784985e9ef9ca28b10278297225d/docs/logo.svg"
+)]
+#![deny(
+    missing_debug_implementations,
+    missing_docs,
+    unused_results,
+    clippy::extra_unused_lifetimes,
+    clippy::from_over_into,
+    clippy::needless_borrow,
+    clippy::new_without_default,
+    clippy::useless_conversion
+)]
+#![forbid(unsafe_code, rust_2018_idioms)]
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+pub mod clipboard;
+pub mod command;
+pub mod font;
+pub mod keyboard;
+pub mod overlay;
+pub mod program;
+pub mod system;
+pub mod user_interface;
+pub mod window;
+
+// We disable debug capabilities on release builds unless the `debug` feature
+// is explicitly enabled.
+#[cfg(feature = "debug")]
+#[path = "debug/basic.rs"]
+mod debug;
+#[cfg(not(feature = "debug"))]
+#[path = "debug/null.rs"]
+mod debug;
+
+pub use iced_core as core;
+pub use iced_futures as futures;
+
+pub use command::Command;
+pub use debug::Debug;
+pub use font::Font;
+pub use program::Program;
+pub use user_interface::UserInterface;
diff --git a/runtime/src/overlay.rs b/runtime/src/overlay.rs
new file mode 100644
index 00000000..03390980
--- /dev/null
+++ b/runtime/src/overlay.rs
@@ -0,0 +1,4 @@
+//! Overlays for user interfaces.
+mod nested;
+
+pub use nested::Nested;
diff --git a/runtime/src/overlay/nested.rs b/runtime/src/overlay/nested.rs
new file mode 100644
index 00000000..b729f769
--- /dev/null
+++ b/runtime/src/overlay/nested.rs
@@ -0,0 +1,353 @@
+use crate::core::event;
+use crate::core::layout;
+use crate::core::mouse;
+use crate::core::overlay;
+use crate::core::renderer;
+use crate::core::widget;
+use crate::core::{Clipboard, Event, Layout, Point, Rectangle, Shell, Size};
+
+/// An [`Overlay`] container that displays nested overlays
+#[allow(missing_debug_implementations)]
+pub struct Nested<'a, Message, Renderer> {
+    overlay: overlay::Element<'a, Message, Renderer>,
+}
+
+impl<'a, Message, Renderer> Nested<'a, Message, Renderer>
+where
+    Renderer: renderer::Renderer,
+{
+    /// Creates a nested overlay from the provided [`overlay::Element`]
+    pub fn new(element: overlay::Element<'a, Message, Renderer>) -> Self {
+        Self { overlay: element }
+    }
+
+    /// Returns the position of the [`Nested`] overlay.
+    pub fn position(&self) -> Point {
+        self.overlay.position()
+    }
+
+    /// Returns the layout [`Node`] of the [`Nested`] overlay.
+    pub fn layout(
+        &mut self,
+        renderer: &Renderer,
+        bounds: Size,
+        position: Point,
+    ) -> layout::Node {
+        fn recurse<Message, Renderer>(
+            element: &mut overlay::Element<'_, Message, Renderer>,
+            renderer: &Renderer,
+            bounds: Size,
+            position: Point,
+        ) -> layout::Node
+        where
+            Renderer: renderer::Renderer,
+        {
+            let translation = position - Point::ORIGIN;
+
+            let node = element.layout(renderer, bounds, translation);
+
+            if let Some(mut nested) =
+                element.overlay(Layout::new(&node), renderer)
+            {
+                layout::Node::with_children(
+                    node.size(),
+                    vec![
+                        node,
+                        recurse(&mut nested, renderer, bounds, position),
+                    ],
+                )
+            } else {
+                layout::Node::with_children(node.size(), vec![node])
+            }
+        }
+
+        recurse(&mut self.overlay, renderer, bounds, position)
+    }
+
+    /// Draws the [`Nested`] overlay using the associated `Renderer`.
+    pub fn draw(
+        &mut self,
+        renderer: &mut Renderer,
+        theme: &<Renderer as renderer::Renderer>::Theme,
+        style: &renderer::Style,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+    ) {
+        fn recurse<Message, Renderer>(
+            element: &mut overlay::Element<'_, Message, Renderer>,
+            layout: Layout<'_>,
+            renderer: &mut Renderer,
+            theme: &<Renderer as renderer::Renderer>::Theme,
+            style: &renderer::Style,
+            cursor: mouse::Cursor,
+        ) where
+            Renderer: renderer::Renderer,
+        {
+            let mut layouts = layout.children();
+
+            if let Some(layout) = layouts.next() {
+                let nested_layout = layouts.next();
+
+                let is_over = cursor
+                    .position()
+                    .zip(nested_layout)
+                    .and_then(|(cursor_position, nested_layout)| {
+                        element.overlay(layout, renderer).map(|nested| {
+                            nested.is_over(
+                                nested_layout.children().next().unwrap(),
+                                renderer,
+                                cursor_position,
+                            )
+                        })
+                    })
+                    .unwrap_or_default();
+
+                renderer.with_layer(layout.bounds(), |renderer| {
+                    element.draw(
+                        renderer,
+                        theme,
+                        style,
+                        layout,
+                        if is_over {
+                            mouse::Cursor::Unavailable
+                        } else {
+                            cursor
+                        },
+                    );
+                });
+
+                if let Some((mut nested, nested_layout)) =
+                    element.overlay(layout, renderer).zip(nested_layout)
+                {
+                    recurse(
+                        &mut nested,
+                        nested_layout,
+                        renderer,
+                        theme,
+                        style,
+                        cursor,
+                    );
+                }
+            }
+        }
+
+        recurse(&mut self.overlay, layout, renderer, theme, style, cursor);
+    }
+
+    /// Applies a [`widget::Operation`] to the [`Nested`] overlay.
+    pub fn operate(
+        &mut self,
+        layout: Layout<'_>,
+        renderer: &Renderer,
+        operation: &mut dyn widget::Operation<Message>,
+    ) {
+        fn recurse<Message, Renderer>(
+            element: &mut overlay::Element<'_, Message, Renderer>,
+            layout: Layout<'_>,
+            renderer: &Renderer,
+            operation: &mut dyn widget::Operation<Message>,
+        ) where
+            Renderer: renderer::Renderer,
+        {
+            let mut layouts = layout.children();
+
+            if let Some(layout) = layouts.next() {
+                element.operate(layout, renderer, operation);
+
+                if let Some((mut nested, nested_layout)) =
+                    element.overlay(layout, renderer).zip(layouts.next())
+                {
+                    recurse(&mut nested, nested_layout, renderer, operation);
+                }
+            }
+        }
+
+        recurse(&mut self.overlay, layout, renderer, operation)
+    }
+
+    /// Processes a runtime [`Event`].
+    pub fn on_event(
+        &mut self,
+        event: Event,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        renderer: &Renderer,
+        clipboard: &mut dyn Clipboard,
+        shell: &mut Shell<'_, Message>,
+    ) -> event::Status {
+        fn recurse<Message, Renderer>(
+            element: &mut overlay::Element<'_, Message, Renderer>,
+            layout: Layout<'_>,
+            event: Event,
+            cursor: mouse::Cursor,
+            renderer: &Renderer,
+            clipboard: &mut dyn Clipboard,
+            shell: &mut Shell<'_, Message>,
+        ) -> (event::Status, bool)
+        where
+            Renderer: renderer::Renderer,
+        {
+            let mut layouts = layout.children();
+
+            if let Some(layout) = layouts.next() {
+                let (nested_status, nested_is_over) =
+                    if let Some((mut nested, nested_layout)) =
+                        element.overlay(layout, renderer).zip(layouts.next())
+                    {
+                        recurse(
+                            &mut nested,
+                            nested_layout,
+                            event.clone(),
+                            cursor,
+                            renderer,
+                            clipboard,
+                            shell,
+                        )
+                    } else {
+                        (event::Status::Ignored, false)
+                    };
+
+                if matches!(nested_status, event::Status::Ignored) {
+                    let is_over = nested_is_over
+                        || cursor
+                            .position()
+                            .map(|cursor_position| {
+                                element.is_over(
+                                    layout,
+                                    renderer,
+                                    cursor_position,
+                                )
+                            })
+                            .unwrap_or_default();
+
+                    (
+                        element.on_event(
+                            event,
+                            layout,
+                            if nested_is_over {
+                                mouse::Cursor::Unavailable
+                            } else {
+                                cursor
+                            },
+                            renderer,
+                            clipboard,
+                            shell,
+                        ),
+                        is_over,
+                    )
+                } else {
+                    (nested_status, nested_is_over)
+                }
+            } else {
+                (event::Status::Ignored, false)
+            }
+        }
+
+        let (status, _) = recurse(
+            &mut self.overlay,
+            layout,
+            event,
+            cursor,
+            renderer,
+            clipboard,
+            shell,
+        );
+
+        status
+    }
+
+    /// Returns the current [`mouse::Interaction`] of the [`Nested`] overlay.
+    pub fn mouse_interaction(
+        &mut self,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        viewport: &Rectangle,
+        renderer: &Renderer,
+    ) -> mouse::Interaction {
+        fn recurse<Message, Renderer>(
+            element: &mut overlay::Element<'_, Message, Renderer>,
+            layout: Layout<'_>,
+            cursor: mouse::Cursor,
+            viewport: &Rectangle,
+            renderer: &Renderer,
+        ) -> Option<mouse::Interaction>
+        where
+            Renderer: renderer::Renderer,
+        {
+            let mut layouts = layout.children();
+
+            let layout = layouts.next()?;
+            let cursor_position = cursor.position()?;
+
+            if !element.is_over(layout, renderer, cursor_position) {
+                return None;
+            }
+
+            Some(
+                element
+                    .overlay(layout, renderer)
+                    .zip(layouts.next())
+                    .and_then(|(mut overlay, layout)| {
+                        recurse(
+                            &mut overlay,
+                            layout,
+                            cursor,
+                            viewport,
+                            renderer,
+                        )
+                    })
+                    .unwrap_or_else(|| {
+                        element.mouse_interaction(
+                            layout, cursor, viewport, renderer,
+                        )
+                    }),
+            )
+        }
+
+        recurse(&mut self.overlay, layout, cursor, viewport, renderer)
+            .unwrap_or_default()
+    }
+
+    /// Returns true if the cursor is over the [`Nested`] overlay.
+    pub fn is_over(
+        &mut self,
+        layout: Layout<'_>,
+        renderer: &Renderer,
+        cursor_position: Point,
+    ) -> bool {
+        fn recurse<Message, Renderer>(
+            element: &mut overlay::Element<'_, Message, Renderer>,
+            layout: Layout<'_>,
+            renderer: &Renderer,
+            cursor_position: Point,
+        ) -> bool
+        where
+            Renderer: renderer::Renderer,
+        {
+            let mut layouts = layout.children();
+
+            if let Some(layout) = layouts.next() {
+                if element.is_over(layout, renderer, cursor_position) {
+                    return true;
+                }
+
+                if let Some((mut nested, nested_layout)) =
+                    element.overlay(layout, renderer).zip(layouts.next())
+                {
+                    recurse(
+                        &mut nested,
+                        nested_layout,
+                        renderer,
+                        cursor_position,
+                    )
+                } else {
+                    false
+                }
+            } else {
+                false
+            }
+        }
+
+        recurse(&mut self.overlay, layout, renderer, cursor_position)
+    }
+}
diff --git a/runtime/src/program.rs b/runtime/src/program.rs
new file mode 100644
index 00000000..44585cc5
--- /dev/null
+++ b/runtime/src/program.rs
@@ -0,0 +1,33 @@
+//! Build interactive programs using The Elm Architecture.
+use crate::Command;
+
+use iced_core::text;
+use iced_core::{Element, Renderer};
+
+mod state;
+
+pub use state::State;
+
+/// The core of a user interface application following The Elm Architecture.
+pub trait Program: Sized {
+    /// The graphics backend to use to draw the [`Program`].
+    type Renderer: Renderer + text::Renderer;
+
+    /// The type of __messages__ your [`Program`] will produce.
+    type Message: std::fmt::Debug + Send;
+
+    /// Handles a __message__ and updates the state of the [`Program`].
+    ///
+    /// This is where you define your __update logic__. All the __messages__,
+    /// produced by either user interactions or commands, will be handled by
+    /// this method.
+    ///
+    /// Any [`Command`] returned will be executed immediately in the
+    /// background by shells.
+    fn update(&mut self, message: Self::Message) -> Command<Self::Message>;
+
+    /// Returns the widgets to display in the [`Program`].
+    ///
+    /// These widgets can produce __messages__ based on user interaction.
+    fn view(&self) -> Element<'_, Self::Message, Self::Renderer>;
+}
diff --git a/runtime/src/program/state.rs b/runtime/src/program/state.rs
new file mode 100644
index 00000000..35df6078
--- /dev/null
+++ b/runtime/src/program/state.rs
@@ -0,0 +1,232 @@
+use crate::core::event::{self, Event};
+use crate::core::mouse;
+use crate::core::renderer;
+use crate::core::widget::operation::{self, Operation};
+use crate::core::{Clipboard, Size};
+use crate::user_interface::{self, UserInterface};
+use crate::{Command, Debug, Program};
+
+/// The execution state of a [`Program`]. It leverages caching, event
+/// processing, and rendering primitive storage.
+#[allow(missing_debug_implementations)]
+pub struct State<P>
+where
+    P: Program + 'static,
+{
+    program: P,
+    cache: Option<user_interface::Cache>,
+    queued_events: Vec<Event>,
+    queued_messages: Vec<P::Message>,
+    mouse_interaction: mouse::Interaction,
+}
+
+impl<P> State<P>
+where
+    P: Program + 'static,
+{
+    /// Creates a new [`State`] with the provided [`Program`], initializing its
+    /// primitive with the given logical bounds and renderer.
+    pub fn new(
+        mut program: P,
+        bounds: Size,
+        renderer: &mut P::Renderer,
+        debug: &mut Debug,
+    ) -> Self {
+        let user_interface = build_user_interface(
+            &mut program,
+            user_interface::Cache::default(),
+            renderer,
+            bounds,
+            debug,
+        );
+
+        let cache = Some(user_interface.into_cache());
+
+        State {
+            program,
+            cache,
+            queued_events: Vec::new(),
+            queued_messages: Vec::new(),
+            mouse_interaction: mouse::Interaction::Idle,
+        }
+    }
+
+    /// Returns a reference to the [`Program`] of the [`State`].
+    pub fn program(&self) -> &P {
+        &self.program
+    }
+
+    /// Queues an event in the [`State`] for processing during an [`update`].
+    ///
+    /// [`update`]: Self::update
+    pub fn queue_event(&mut self, event: Event) {
+        self.queued_events.push(event);
+    }
+
+    /// Queues a message in the [`State`] for processing during an [`update`].
+    ///
+    /// [`update`]: Self::update
+    pub fn queue_message(&mut self, message: P::Message) {
+        self.queued_messages.push(message);
+    }
+
+    /// Returns whether the event queue of the [`State`] is empty or not.
+    pub fn is_queue_empty(&self) -> bool {
+        self.queued_events.is_empty() && self.queued_messages.is_empty()
+    }
+
+    /// Returns the current [`mouse::Interaction`] of the [`State`].
+    pub fn mouse_interaction(&self) -> mouse::Interaction {
+        self.mouse_interaction
+    }
+
+    /// Processes all the queued events and messages, rebuilding and redrawing
+    /// the widgets of the linked [`Program`] if necessary.
+    ///
+    /// Returns a list containing the instances of [`Event`] that were not
+    /// captured by any widget, and the [`Command`] obtained from [`Program`]
+    /// after updating it, only if an update was necessary.
+    pub fn update(
+        &mut self,
+        bounds: Size,
+        cursor: mouse::Cursor,
+        renderer: &mut P::Renderer,
+        theme: &<P::Renderer as iced_core::Renderer>::Theme,
+        style: &renderer::Style,
+        clipboard: &mut dyn Clipboard,
+        debug: &mut Debug,
+    ) -> (Vec<Event>, Option<Command<P::Message>>) {
+        let mut user_interface = build_user_interface(
+            &mut self.program,
+            self.cache.take().unwrap(),
+            renderer,
+            bounds,
+            debug,
+        );
+
+        debug.event_processing_started();
+        let mut messages = Vec::new();
+
+        let (_, event_statuses) = user_interface.update(
+            &self.queued_events,
+            cursor,
+            renderer,
+            clipboard,
+            &mut messages,
+        );
+
+        let uncaptured_events = self
+            .queued_events
+            .iter()
+            .zip(event_statuses)
+            .filter_map(|(event, status)| {
+                matches!(status, event::Status::Ignored).then_some(event)
+            })
+            .cloned()
+            .collect();
+
+        self.queued_events.clear();
+        messages.append(&mut self.queued_messages);
+        debug.event_processing_finished();
+
+        let command = if messages.is_empty() {
+            debug.draw_started();
+            self.mouse_interaction =
+                user_interface.draw(renderer, theme, style, cursor);
+            debug.draw_finished();
+
+            self.cache = Some(user_interface.into_cache());
+
+            None
+        } else {
+            // When there are messages, we are forced to rebuild twice
+            // for now :^)
+            let temp_cache = user_interface.into_cache();
+
+            let commands =
+                Command::batch(messages.into_iter().map(|message| {
+                    debug.log_message(&message);
+
+                    debug.update_started();
+                    let command = self.program.update(message);
+                    debug.update_finished();
+
+                    command
+                }));
+
+            let mut user_interface = build_user_interface(
+                &mut self.program,
+                temp_cache,
+                renderer,
+                bounds,
+                debug,
+            );
+
+            debug.draw_started();
+            self.mouse_interaction =
+                user_interface.draw(renderer, theme, style, cursor);
+            debug.draw_finished();
+
+            self.cache = Some(user_interface.into_cache());
+
+            Some(commands)
+        };
+
+        (uncaptured_events, command)
+    }
+
+    /// Applies [`widget::Operation`]s to the [`State`]
+    pub fn operate(
+        &mut self,
+        renderer: &mut P::Renderer,
+        operations: impl Iterator<Item = Box<dyn Operation<P::Message>>>,
+        bounds: Size,
+        debug: &mut Debug,
+    ) {
+        let mut user_interface = build_user_interface(
+            &mut self.program,
+            self.cache.take().unwrap(),
+            renderer,
+            bounds,
+            debug,
+        );
+
+        for operation in operations {
+            let mut current_operation = Some(operation);
+
+            while let Some(mut operation) = current_operation.take() {
+                user_interface.operate(renderer, operation.as_mut());
+
+                match operation.finish() {
+                    operation::Outcome::None => {}
+                    operation::Outcome::Some(message) => {
+                        self.queued_messages.push(message)
+                    }
+                    operation::Outcome::Chain(next) => {
+                        current_operation = Some(next);
+                    }
+                };
+            }
+        }
+
+        self.cache = Some(user_interface.into_cache());
+    }
+}
+
+fn build_user_interface<'a, P: Program>(
+    program: &'a mut P,
+    cache: user_interface::Cache,
+    renderer: &mut P::Renderer,
+    size: Size,
+    debug: &mut Debug,
+) -> UserInterface<'a, P::Message, P::Renderer> {
+    debug.view_started();
+    let view = program.view();
+    debug.view_finished();
+
+    debug.layout_started();
+    let user_interface = UserInterface::build(view, size, cache, renderer);
+    debug.layout_finished();
+
+    user_interface
+}
diff --git a/runtime/src/system.rs b/runtime/src/system.rs
new file mode 100644
index 00000000..61c8ff29
--- /dev/null
+++ b/runtime/src/system.rs
@@ -0,0 +1,6 @@
+//! Access the native system.
+mod action;
+mod information;
+
+pub use action::Action;
+pub use information::Information;
diff --git a/runtime/src/system/action.rs b/runtime/src/system/action.rs
new file mode 100644
index 00000000..dea9536f
--- /dev/null
+++ b/runtime/src/system/action.rs
@@ -0,0 +1,39 @@
+use crate::system;
+
+use iced_futures::MaybeSend;
+use std::fmt;
+
+/// An operation to be performed on the system.
+pub enum Action<T> {
+    /// Query system information and produce `T` with the result.
+    QueryInformation(Box<dyn Closure<T>>),
+}
+
+pub trait Closure<T>: Fn(system::Information) -> T + MaybeSend {}
+
+impl<T, O> Closure<O> for T where T: Fn(system::Information) -> O + MaybeSend {}
+
+impl<T> Action<T> {
+    /// Maps the output of a system [`Action`] using the provided closure.
+    pub fn map<A>(
+        self,
+        f: impl Fn(T) -> A + 'static + MaybeSend + Sync,
+    ) -> Action<A>
+    where
+        T: 'static,
+    {
+        match self {
+            Self::QueryInformation(o) => {
+                Action::QueryInformation(Box::new(move |s| f(o(s))))
+            }
+        }
+    }
+}
+
+impl<T> fmt::Debug for Action<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::QueryInformation(_) => write!(f, "Action::QueryInformation"),
+        }
+    }
+}
diff --git a/runtime/src/system/information.rs b/runtime/src/system/information.rs
new file mode 100644
index 00000000..93e7a5a4
--- /dev/null
+++ b/runtime/src/system/information.rs
@@ -0,0 +1,29 @@
+/// Contains informations about the system (e.g. system name, processor, memory, graphics adapter).
+#[derive(Clone, Debug)]
+pub struct Information {
+    /// The operating system name
+    pub system_name: Option<String>,
+    /// Operating system kernel version
+    pub system_kernel: Option<String>,
+    /// Long operating system version
+    ///
+    /// Examples:
+    /// - MacOS 10.15 Catalina
+    /// - Windows 10 Pro
+    /// - Ubuntu 20.04 LTS (Focal Fossa)
+    pub system_version: Option<String>,
+    /// Short operating system version number
+    pub system_short_version: Option<String>,
+    /// Detailed processor model information
+    pub cpu_brand: String,
+    /// The number of physical cores on the processor
+    pub cpu_cores: Option<usize>,
+    /// Total RAM size, KB
+    pub memory_total: u64,
+    /// Memory used by this process, KB
+    pub memory_used: Option<u64>,
+    /// Underlying graphics backend for rendering
+    pub graphics_backend: String,
+    /// Model information for the active graphics adapter
+    pub graphics_adapter: String,
+}
diff --git a/runtime/src/user_interface.rs b/runtime/src/user_interface.rs
new file mode 100644
index 00000000..619423fd
--- /dev/null
+++ b/runtime/src/user_interface.rs
@@ -0,0 +1,626 @@
+//! Implement your own event loop to drive a user interface.
+use crate::core::event::{self, Event};
+use crate::core::layout;
+use crate::core::mouse;
+use crate::core::renderer;
+use crate::core::widget;
+use crate::core::window;
+use crate::core::{Clipboard, Element, Layout, Point, Rectangle, Shell, Size};
+use crate::overlay;
+
+/// A set of interactive graphical elements with a specific [`Layout`].
+///
+/// It can be updated and drawn.
+///
+/// Iced tries to avoid dictating how to write your event loop. You are in
+/// charge of using this type in your system in any way you want.
+///
+/// # Example
+/// The [`integration`] example uses a [`UserInterface`] to integrate Iced in an
+/// existing graphical application.
+///
+/// [`integration`]: https://github.com/iced-rs/iced/tree/0.9/examples/integration
+#[allow(missing_debug_implementations)]
+pub struct UserInterface<'a, Message, Renderer> {
+    root: Element<'a, Message, Renderer>,
+    base: layout::Node,
+    state: widget::Tree,
+    overlay: Option<layout::Node>,
+    bounds: Size,
+}
+
+impl<'a, Message, Renderer> UserInterface<'a, Message, Renderer>
+where
+    Renderer: crate::core::Renderer,
+{
+    /// Builds a user interface for an [`Element`].
+    ///
+    /// It is able to avoid expensive computations when using a [`Cache`]
+    /// obtained from a previous instance of a [`UserInterface`].
+    ///
+    /// # Example
+    /// Imagine we want to build a [`UserInterface`] for
+    /// [the counter example that we previously wrote](index.html#usage). Here
+    /// is naive way to set up our application loop:
+    ///
+    /// ```no_run
+    /// # mod iced_wgpu {
+    /// #     pub use iced_runtime::core::renderer::Null as Renderer;
+    /// # }
+    /// #
+    /// # pub struct Counter;
+    /// #
+    /// # impl Counter {
+    /// #     pub fn new() -> Self { Counter }
+    /// #     pub fn view(&self) -> iced_core::Element<(), Renderer> { unimplemented!() }
+    /// #     pub fn update(&mut self, _: ()) {}
+    /// # }
+    /// use iced_runtime::core::Size;
+    /// use iced_runtime::user_interface::{self, UserInterface};
+    /// use iced_wgpu::Renderer;
+    ///
+    /// // Initialization
+    /// let mut counter = Counter::new();
+    /// let mut cache = user_interface::Cache::new();
+    /// let mut renderer = Renderer::new();
+    /// let mut window_size = Size::new(1024.0, 768.0);
+    ///
+    /// // Application loop
+    /// loop {
+    ///     // Process system events here...
+    ///
+    ///     // Build the user interface
+    ///     let user_interface = UserInterface::build(
+    ///         counter.view(),
+    ///         window_size,
+    ///         cache,
+    ///         &mut renderer,
+    ///     );
+    ///
+    ///     // Update and draw the user interface here...
+    ///     // ...
+    ///
+    ///     // Obtain the cache for the next iteration
+    ///     cache = user_interface.into_cache();
+    /// }
+    /// ```
+    pub fn build<E: Into<Element<'a, Message, Renderer>>>(
+        root: E,
+        bounds: Size,
+        cache: Cache,
+        renderer: &mut Renderer,
+    ) -> Self {
+        let root = root.into();
+
+        let Cache { mut state } = cache;
+        state.diff(root.as_widget());
+
+        let base =
+            renderer.layout(&root, &layout::Limits::new(Size::ZERO, bounds));
+
+        UserInterface {
+            root,
+            base,
+            state,
+            overlay: None,
+            bounds,
+        }
+    }
+
+    /// Updates the [`UserInterface`] by processing each provided [`Event`].
+    ///
+    /// It returns __messages__ that may have been produced as a result of user
+    /// interactions. You should feed these to your __update logic__.
+    ///
+    /// # Example
+    /// Let's allow our [counter](index.html#usage) to change state by
+    /// completing [the previous example](#example):
+    ///
+    /// ```no_run
+    /// # mod iced_wgpu {
+    /// #     pub use iced_runtime::core::renderer::Null as Renderer;
+    /// # }
+    /// #
+    /// # pub struct Counter;
+    /// #
+    /// # impl Counter {
+    /// #     pub fn new() -> Self { Counter }
+    /// #     pub fn view(&self) -> iced_core::Element<(), Renderer> { unimplemented!() }
+    /// #     pub fn update(&mut self, _: ()) {}
+    /// # }
+    /// use iced_runtime::core::clipboard;
+    /// use iced_runtime::core::mouse;
+    /// use iced_runtime::core::Size;
+    /// use iced_runtime::user_interface::{self, UserInterface};
+    /// use iced_wgpu::Renderer;
+    ///
+    /// let mut counter = Counter::new();
+    /// let mut cache = user_interface::Cache::new();
+    /// let mut renderer = Renderer::new();
+    /// let mut window_size = Size::new(1024.0, 768.0);
+    /// let mut cursor = mouse::Cursor::default();
+    /// let mut clipboard = clipboard::Null;
+    ///
+    /// // Initialize our event storage
+    /// let mut events = Vec::new();
+    /// let mut messages = Vec::new();
+    ///
+    /// loop {
+    ///     // Obtain system events...
+    ///
+    ///     let mut user_interface = UserInterface::build(
+    ///         counter.view(),
+    ///         window_size,
+    ///         cache,
+    ///         &mut renderer,
+    ///     );
+    ///
+    ///     // Update the user interface
+    ///     let (state, event_statuses) = user_interface.update(
+    ///         &events,
+    ///         cursor,
+    ///         &mut renderer,
+    ///         &mut clipboard,
+    ///         &mut messages
+    ///     );
+    ///
+    ///     cache = user_interface.into_cache();
+    ///
+    ///     // Process the produced messages
+    ///     for message in messages.drain(..) {
+    ///         counter.update(message);
+    ///     }
+    /// }
+    /// ```
+    pub fn update(
+        &mut self,
+        events: &[Event],
+        cursor: mouse::Cursor,
+        renderer: &mut Renderer,
+        clipboard: &mut dyn Clipboard,
+        messages: &mut Vec<Message>,
+    ) -> (State, Vec<event::Status>) {
+        use std::mem::ManuallyDrop;
+
+        let mut outdated = false;
+        let mut redraw_request = None;
+
+        let mut manual_overlay = ManuallyDrop::new(
+            self.root
+                .as_widget_mut()
+                .overlay(&mut self.state, Layout::new(&self.base), renderer)
+                .map(overlay::Nested::new),
+        );
+
+        let (base_cursor, overlay_statuses) = if manual_overlay.is_some() {
+            let bounds = self.bounds;
+
+            let mut overlay = manual_overlay.as_mut().unwrap();
+            let mut layout = overlay.layout(renderer, bounds, Point::ORIGIN);
+            let mut event_statuses = Vec::new();
+
+            for event in events.iter().cloned() {
+                let mut shell = Shell::new(messages);
+
+                let event_status = overlay.on_event(
+                    event,
+                    Layout::new(&layout),
+                    cursor,
+                    renderer,
+                    clipboard,
+                    &mut shell,
+                );
+
+                event_statuses.push(event_status);
+
+                match (redraw_request, shell.redraw_request()) {
+                    (None, Some(at)) => {
+                        redraw_request = Some(at);
+                    }
+                    (Some(current), Some(new)) if new < current => {
+                        redraw_request = Some(new);
+                    }
+                    _ => {}
+                }
+
+                if shell.is_layout_invalid() {
+                    let _ = ManuallyDrop::into_inner(manual_overlay);
+
+                    self.base = renderer.layout(
+                        &self.root,
+                        &layout::Limits::new(Size::ZERO, self.bounds),
+                    );
+
+                    manual_overlay = ManuallyDrop::new(
+                        self.root
+                            .as_widget_mut()
+                            .overlay(
+                                &mut self.state,
+                                Layout::new(&self.base),
+                                renderer,
+                            )
+                            .map(overlay::Nested::new),
+                    );
+
+                    if manual_overlay.is_none() {
+                        break;
+                    }
+
+                    overlay = manual_overlay.as_mut().unwrap();
+
+                    shell.revalidate_layout(|| {
+                        layout =
+                            overlay.layout(renderer, bounds, Point::ORIGIN);
+                    });
+                }
+
+                if shell.are_widgets_invalid() {
+                    outdated = true;
+                }
+            }
+
+            let base_cursor = if manual_overlay
+                .as_mut()
+                .and_then(|overlay| {
+                    cursor.position().map(|cursor_position| {
+                        overlay.is_over(
+                            Layout::new(&layout),
+                            renderer,
+                            cursor_position,
+                        )
+                    })
+                })
+                .unwrap_or_default()
+            {
+                mouse::Cursor::Unavailable
+            } else {
+                cursor
+            };
+
+            self.overlay = Some(layout);
+
+            (base_cursor, event_statuses)
+        } else {
+            (cursor, vec![event::Status::Ignored; events.len()])
+        };
+
+        let _ = ManuallyDrop::into_inner(manual_overlay);
+
+        let event_statuses = events
+            .iter()
+            .cloned()
+            .zip(overlay_statuses.into_iter())
+            .map(|(event, overlay_status)| {
+                if matches!(overlay_status, event::Status::Captured) {
+                    return overlay_status;
+                }
+
+                let mut shell = Shell::new(messages);
+
+                let event_status = self.root.as_widget_mut().on_event(
+                    &mut self.state,
+                    event,
+                    Layout::new(&self.base),
+                    base_cursor,
+                    renderer,
+                    clipboard,
+                    &mut shell,
+                );
+
+                if matches!(event_status, event::Status::Captured) {
+                    self.overlay = None;
+                }
+
+                match (redraw_request, shell.redraw_request()) {
+                    (None, Some(at)) => {
+                        redraw_request = Some(at);
+                    }
+                    (Some(current), Some(new)) if new < current => {
+                        redraw_request = Some(new);
+                    }
+                    _ => {}
+                }
+
+                shell.revalidate_layout(|| {
+                    self.base = renderer.layout(
+                        &self.root,
+                        &layout::Limits::new(Size::ZERO, self.bounds),
+                    );
+
+                    self.overlay = None;
+                });
+
+                if shell.are_widgets_invalid() {
+                    outdated = true;
+                }
+
+                event_status.merge(overlay_status)
+            })
+            .collect();
+
+        (
+            if outdated {
+                State::Outdated
+            } else {
+                State::Updated { redraw_request }
+            },
+            event_statuses,
+        )
+    }
+
+    /// Draws the [`UserInterface`] with the provided [`Renderer`].
+    ///
+    /// It returns the current [`mouse::Interaction`]. You should update the
+    /// icon of the mouse cursor accordingly in your system.
+    ///
+    /// [`Renderer`]: crate::Renderer
+    ///
+    /// # Example
+    /// We can finally draw our [counter](index.html#usage) by
+    /// [completing the last example](#example-1):
+    ///
+    /// ```no_run
+    /// # mod iced_wgpu {
+    /// #     pub use iced_runtime::core::renderer::Null as Renderer;
+    /// #     pub type Theme = ();
+    /// # }
+    /// #
+    /// # pub struct Counter;
+    /// #
+    /// # impl Counter {
+    /// #     pub fn new() -> Self { Counter }
+    /// #     pub fn view(&self) -> Element<(), Renderer> { unimplemented!() }
+    /// #     pub fn update(&mut self, _: ()) {}
+    /// # }
+    /// use iced_runtime::core::clipboard;
+    /// use iced_runtime::core::mouse;
+    /// use iced_runtime::core::renderer;
+    /// use iced_runtime::core::{Element, Size};
+    /// use iced_runtime::user_interface::{self, UserInterface};
+    /// use iced_wgpu::{Renderer, Theme};
+    ///
+    /// let mut counter = Counter::new();
+    /// let mut cache = user_interface::Cache::new();
+    /// let mut renderer = Renderer::new();
+    /// let mut window_size = Size::new(1024.0, 768.0);
+    /// let mut cursor = mouse::Cursor::default();
+    /// let mut clipboard = clipboard::Null;
+    /// let mut events = Vec::new();
+    /// let mut messages = Vec::new();
+    /// let mut theme = Theme::default();
+    ///
+    /// loop {
+    ///     // Obtain system events...
+    ///
+    ///     let mut user_interface = UserInterface::build(
+    ///         counter.view(),
+    ///         window_size,
+    ///         cache,
+    ///         &mut renderer,
+    ///     );
+    ///
+    ///     // Update the user interface
+    ///     let event_statuses = user_interface.update(
+    ///         &events,
+    ///         cursor,
+    ///         &mut renderer,
+    ///         &mut clipboard,
+    ///         &mut messages
+    ///     );
+    ///
+    ///     // Draw the user interface
+    ///     let mouse_interaction = user_interface.draw(&mut renderer, &theme, &renderer::Style::default(), cursor);
+    ///
+    ///     cache = user_interface.into_cache();
+    ///
+    ///     for message in messages.drain(..) {
+    ///         counter.update(message);
+    ///     }
+    ///
+    ///     // Update mouse cursor icon...
+    ///     // Flush rendering operations...
+    /// }
+    /// ```
+    pub fn draw(
+        &mut self,
+        renderer: &mut Renderer,
+        theme: &Renderer::Theme,
+        style: &renderer::Style,
+        cursor: mouse::Cursor,
+    ) -> mouse::Interaction {
+        // TODO: Move to shell level (?)
+        renderer.clear();
+
+        let viewport = Rectangle::with_size(self.bounds);
+
+        let base_cursor = if let Some(mut overlay) = self
+            .root
+            .as_widget_mut()
+            .overlay(&mut self.state, Layout::new(&self.base), renderer)
+            .map(overlay::Nested::new)
+        {
+            let overlay_layout = self.overlay.take().unwrap_or_else(|| {
+                overlay.layout(renderer, self.bounds, Point::ORIGIN)
+            });
+
+            let cursor = if cursor
+                .position()
+                .map(|cursor_position| {
+                    overlay.is_over(
+                        Layout::new(&overlay_layout),
+                        renderer,
+                        cursor_position,
+                    )
+                })
+                .unwrap_or_default()
+            {
+                mouse::Cursor::Unavailable
+            } else {
+                cursor
+            };
+
+            self.overlay = Some(overlay_layout);
+
+            cursor
+        } else {
+            cursor
+        };
+
+        self.root.as_widget().draw(
+            &self.state,
+            renderer,
+            theme,
+            style,
+            Layout::new(&self.base),
+            base_cursor,
+            &viewport,
+        );
+
+        let base_interaction = self.root.as_widget().mouse_interaction(
+            &self.state,
+            Layout::new(&self.base),
+            base_cursor,
+            &viewport,
+            renderer,
+        );
+
+        let Self {
+            overlay,
+            root,
+            base,
+            ..
+        } = self;
+
+        // TODO: Currently, we need to call Widget::overlay twice to
+        // implement the painter's algorithm properly.
+        //
+        // Once we have a proper persistent widget tree, we should be able to
+        // avoid this additional call.
+        overlay
+            .as_ref()
+            .and_then(|layout| {
+                root.as_widget_mut()
+                    .overlay(&mut self.state, Layout::new(base), renderer)
+                    .map(overlay::Nested::new)
+                    .map(|mut overlay| {
+                        let overlay_interaction = overlay.mouse_interaction(
+                            Layout::new(layout),
+                            cursor,
+                            &viewport,
+                            renderer,
+                        );
+
+                        let overlay_bounds = layout.bounds();
+
+                        renderer.with_layer(overlay_bounds, |renderer| {
+                            overlay.draw(
+                                renderer,
+                                theme,
+                                style,
+                                Layout::new(layout),
+                                cursor,
+                            );
+                        });
+
+                        if cursor
+                            .position()
+                            .map(|cursor_position| {
+                                overlay.is_over(
+                                    Layout::new(layout),
+                                    renderer,
+                                    cursor_position,
+                                )
+                            })
+                            .unwrap_or_default()
+                        {
+                            overlay_interaction
+                        } else {
+                            base_interaction
+                        }
+                    })
+            })
+            .unwrap_or(base_interaction)
+    }
+
+    /// Applies a [`widget::Operation`] to the [`UserInterface`].
+    pub fn operate(
+        &mut self,
+        renderer: &Renderer,
+        operation: &mut dyn widget::Operation<Message>,
+    ) {
+        self.root.as_widget().operate(
+            &mut self.state,
+            Layout::new(&self.base),
+            renderer,
+            operation,
+        );
+
+        if let Some(mut overlay) = self
+            .root
+            .as_widget_mut()
+            .overlay(&mut self.state, Layout::new(&self.base), renderer)
+            .map(overlay::Nested::new)
+        {
+            if self.overlay.is_none() {
+                self.overlay =
+                    Some(overlay.layout(renderer, self.bounds, Point::ORIGIN));
+            }
+
+            overlay.operate(
+                Layout::new(self.overlay.as_ref().unwrap()),
+                renderer,
+                operation,
+            );
+        }
+    }
+
+    /// Relayouts and returns a new  [`UserInterface`] using the provided
+    /// bounds.
+    pub fn relayout(self, bounds: Size, renderer: &mut Renderer) -> Self {
+        Self::build(self.root, bounds, Cache { state: self.state }, renderer)
+    }
+
+    /// Extract the [`Cache`] of the [`UserInterface`], consuming it in the
+    /// process.
+    pub fn into_cache(self) -> Cache {
+        Cache { state: self.state }
+    }
+}
+
+/// Reusable data of a specific [`UserInterface`].
+#[derive(Debug)]
+pub struct Cache {
+    state: widget::Tree,
+}
+
+impl Cache {
+    /// Creates an empty [`Cache`].
+    ///
+    /// You should use this to initialize a [`Cache`] before building your first
+    /// [`UserInterface`].
+    pub fn new() -> Cache {
+        Cache {
+            state: widget::Tree::empty(),
+        }
+    }
+}
+
+impl Default for Cache {
+    fn default() -> Cache {
+        Cache::new()
+    }
+}
+
+/// The resulting state after updating a [`UserInterface`].
+#[derive(Debug, Clone, Copy)]
+pub enum State {
+    /// The [`UserInterface`] is outdated and needs to be rebuilt.
+    Outdated,
+
+    /// The [`UserInterface`] is up-to-date and can be reused without
+    /// rebuilding.
+    Updated {
+        /// The [`Instant`] when a redraw should be performed.
+        redraw_request: Option<window::RedrawRequest>,
+    },
+}
diff --git a/runtime/src/window.rs b/runtime/src/window.rs
new file mode 100644
index 00000000..5219fbfd
--- /dev/null
+++ b/runtime/src/window.rs
@@ -0,0 +1,135 @@
+//! Build window-based GUI applications.
+mod action;
+
+pub mod screenshot;
+
+pub use action::Action;
+pub use screenshot::Screenshot;
+
+use crate::command::{self, Command};
+use crate::core::time::Instant;
+use crate::core::window::{Event, Icon, Level, Mode, UserAttention};
+use crate::core::Size;
+use crate::futures::subscription::{self, Subscription};
+
+/// Subscribes to the frames of the window of the running application.
+///
+/// The resulting [`Subscription`] will produce items at a rate equal to the
+/// refresh rate of the window. Note that this rate may be variable, as it is
+/// normally managed by the graphics driver and/or the OS.
+///
+/// In any case, this [`Subscription`] is useful to smoothly draw application-driven
+/// animations without missing any frames.
+pub fn frames() -> Subscription<Instant> {
+    subscription::raw_events(|event, _status| match event {
+        iced_core::Event::Window(Event::RedrawRequested(at)) => Some(at),
+        _ => None,
+    })
+}
+
+/// Closes the current window and exits the application.
+pub fn close<Message>() -> Command<Message> {
+    Command::single(command::Action::Window(Action::Close))
+}
+
+/// Begins dragging the window while the left mouse button is held.
+pub fn drag<Message>() -> Command<Message> {
+    Command::single(command::Action::Window(Action::Drag))
+}
+
+/// Resizes the window to the given logical dimensions.
+pub fn resize<Message>(new_size: Size<u32>) -> Command<Message> {
+    Command::single(command::Action::Window(Action::Resize(new_size)))
+}
+
+/// Fetches the current window size in logical dimensions.
+pub fn fetch_size<Message>(
+    f: impl FnOnce(Size<u32>) -> Message + 'static,
+) -> Command<Message> {
+    Command::single(command::Action::Window(Action::FetchSize(Box::new(f))))
+}
+
+/// Maximizes the window.
+pub fn maximize<Message>(maximized: bool) -> Command<Message> {
+    Command::single(command::Action::Window(Action::Maximize(maximized)))
+}
+
+/// Minimes the window.
+pub fn minimize<Message>(minimized: bool) -> Command<Message> {
+    Command::single(command::Action::Window(Action::Minimize(minimized)))
+}
+
+/// Moves a window to the given logical coordinates.
+pub fn move_to<Message>(x: i32, y: i32) -> Command<Message> {
+    Command::single(command::Action::Window(Action::Move { x, y }))
+}
+
+/// Changes the [`Mode`] of the window.
+pub fn change_mode<Message>(mode: Mode) -> Command<Message> {
+    Command::single(command::Action::Window(Action::ChangeMode(mode)))
+}
+
+/// Fetches the current [`Mode`] of the window.
+pub fn fetch_mode<Message>(
+    f: impl FnOnce(Mode) -> Message + 'static,
+) -> Command<Message> {
+    Command::single(command::Action::Window(Action::FetchMode(Box::new(f))))
+}
+
+/// Toggles the window to maximized or back.
+pub fn toggle_maximize<Message>() -> Command<Message> {
+    Command::single(command::Action::Window(Action::ToggleMaximize))
+}
+
+/// Toggles the window decorations.
+pub fn toggle_decorations<Message>() -> Command<Message> {
+    Command::single(command::Action::Window(Action::ToggleDecorations))
+}
+
+/// Request user attention to the window, this has no effect if the application
+/// is already focused. How requesting for user attention manifests is platform dependent,
+/// see [`UserAttention`] for details.
+///
+/// Providing `None` will unset the request for user attention. Unsetting the request for
+/// user attention might not be done automatically by the WM when the window receives input.
+pub fn request_user_attention<Message>(
+    user_attention: Option<UserAttention>,
+) -> Command<Message> {
+    Command::single(command::Action::Window(Action::RequestUserAttention(
+        user_attention,
+    )))
+}
+
+/// Brings the window to the front and sets input focus. Has no effect if the window is
+/// already in focus, minimized, or not visible.
+///
+/// This [`Command`] steals input focus from other applications. Do not use this method unless
+/// you are certain that's what the user wants. Focus stealing can cause an extremely disruptive
+/// user experience.
+pub fn gain_focus<Message>() -> Command<Message> {
+    Command::single(command::Action::Window(Action::GainFocus))
+}
+
+/// Changes the window [`Level`].
+pub fn change_level<Message>(level: Level) -> Command<Message> {
+    Command::single(command::Action::Window(Action::ChangeLevel(level)))
+}
+
+/// Fetches an identifier unique to the window.
+pub fn fetch_id<Message>(
+    f: impl FnOnce(u64) -> Message + 'static,
+) -> Command<Message> {
+    Command::single(command::Action::Window(Action::FetchId(Box::new(f))))
+}
+
+/// Changes the [`Icon`] of the window.
+pub fn change_icon<Message>(icon: Icon) -> Command<Message> {
+    Command::single(command::Action::Window(Action::ChangeIcon(icon)))
+}
+
+/// Captures a [`Screenshot`] from the window.
+pub fn screenshot<Message>(
+    f: impl FnOnce(Screenshot) -> Message + Send + 'static,
+) -> Command<Message> {
+    Command::single(command::Action::Window(Action::Screenshot(Box::new(f))))
+}
diff --git a/runtime/src/window/action.rs b/runtime/src/window/action.rs
new file mode 100644
index 00000000..cebec4ae
--- /dev/null
+++ b/runtime/src/window/action.rs
@@ -0,0 +1,175 @@
+use crate::core::window::{Icon, Level, Mode, UserAttention, Settings};
+use crate::core::Size;
+use crate::futures::MaybeSend;
+use crate::window::Screenshot;
+
+use std::fmt;
+
+/// An operation to be performed on some window.
+pub enum Action<T> {
+    /// Close the current window and exits the application.
+    Close,
+    /// Move the window with the left mouse button until the button is
+    /// released.
+    ///
+    /// There’s no guarantee that this will work unless the left mouse
+    /// button was pressed immediately before this function is called.
+    Drag,
+    /// Spawns a new window with the provided [`window::Settings`].
+    Spawn {
+        /// The settings of the [`Window`].
+        settings: Settings,
+    },
+    /// Resize the window.
+    Resize(Size<u32>),
+    /// Fetch the current size of the window.
+    FetchSize(Box<dyn FnOnce(Size<u32>) -> T + 'static>),
+    /// Set the window to maximized or back
+    Maximize(bool),
+    /// Set the window to minimized or back
+    Minimize(bool),
+    /// Move the window.
+    ///
+    /// Unsupported on Wayland.
+    Move {
+        /// The new logical x location of the window
+        x: i32,
+        /// The new logical y location of the window
+        y: i32,
+    },
+    /// Change the [`Mode`] of the window.
+    ChangeMode(Mode),
+    /// Fetch the current [`Mode`] of the window.
+    FetchMode(Box<dyn FnOnce(Mode) -> T + 'static>),
+    /// Toggle the window to maximized or back
+    ToggleMaximize,
+    /// Toggle whether window has decorations.
+    ///
+    /// ## Platform-specific
+    /// - **X11:** Not implemented.
+    /// - **Web:** Unsupported.
+    ToggleDecorations,
+    /// Request user attention to the window, this has no effect if the application
+    /// is already focused. How requesting for user attention manifests is platform dependent,
+    /// see [`UserAttention`] for details.
+    ///
+    /// Providing `None` will unset the request for user attention. Unsetting the request for
+    /// user attention might not be done automatically by the WM when the window receives input.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **iOS / Android / Web:** Unsupported.
+    /// - **macOS:** `None` has no effect.
+    /// - **X11:** Requests for user attention must be manually cleared.
+    /// - **Wayland:** Requires `xdg_activation_v1` protocol, `None` has no effect.
+    RequestUserAttention(Option<UserAttention>),
+    /// Bring the window to the front and sets input focus. Has no effect if the window is
+    /// already in focus, minimized, or not visible.
+    ///
+    /// This method steals input focus from other applications. Do not use this method unless
+    /// you are certain that's what the user wants. Focus stealing can cause an extremely disruptive
+    /// user experience.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Web / Wayland:** Unsupported.
+    GainFocus,
+    /// Change the window [`Level`].
+    ChangeLevel(Level),
+    /// Fetch an identifier unique to the window.
+    FetchId(Box<dyn FnOnce(u64) -> T + 'static>),
+    /// Change the window [`Icon`].
+    ///
+    /// On Windows and X11, this is typically the small icon in the top-left
+    /// corner of the titlebar.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Web / Wayland / macOS:** Unsupported.
+    ///
+    /// - **Windows:** Sets `ICON_SMALL`. The base size for a window icon is 16x16, but it's
+    ///   recommended to account for screen scaling and pick a multiple of that, i.e. 32x32.
+    ///
+    /// - **X11:** Has no universal guidelines for icon sizes, so you're at the whims of the WM. That
+    ///   said, it's usually in the same ballpark as on Windows.
+    ChangeIcon(Icon),
+    /// Screenshot the viewport of the window.
+    Screenshot(Box<dyn FnOnce(Screenshot) -> T + 'static>),
+}
+
+impl<T> Action<T> {
+    /// Maps the output of a window [`Action`] using the provided closure.
+    pub fn map<A>(
+        self,
+        f: impl Fn(T) -> A + 'static + MaybeSend + Sync,
+    ) -> Action<A>
+    where
+        T: 'static,
+    {
+        match self {
+            Self::Close => Action::Close,
+            Self::Drag => Action::Drag,
+            Self::Spawn { settings } => Action::Spawn { settings },
+            Self::Resize(size) => Action::Resize(size),
+            Self::FetchSize(o) => Action::FetchSize(Box::new(move |s| f(o(s)))),
+            Self::Maximize(maximized) => Action::Maximize(maximized),
+            Self::Minimize(minimized) => Action::Minimize(minimized),
+            Self::Move { x, y } => Action::Move { x, y },
+            Self::ChangeMode(mode) => Action::ChangeMode(mode),
+            Self::FetchMode(o) => Action::FetchMode(Box::new(move |s| f(o(s)))),
+            Self::ToggleMaximize => Action::ToggleMaximize,
+            Self::ToggleDecorations => Action::ToggleDecorations,
+            Self::RequestUserAttention(attention_type) => {
+                Action::RequestUserAttention(attention_type)
+            }
+            Self::GainFocus => Action::GainFocus,
+            Self::ChangeLevel(level) => Action::ChangeLevel(level),
+            Self::FetchId(o) => Action::FetchId(Box::new(move |s| f(o(s)))),
+            Self::ChangeIcon(icon) => Action::ChangeIcon(icon),
+            Self::Screenshot(tag) => {
+                Action::Screenshot(Box::new(move |screenshot| {
+                    f(tag(screenshot))
+                }))
+            }
+        }
+    }
+}
+
+impl<T> fmt::Debug for Action<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Close => write!(f, "Action::Close"),
+            Self::Drag => write!(f, "Action::Drag"),
+            Self::Spawn { settings } => {
+                write!(f, "Action::Spawn {{ settings: {:?} }}", settings)
+            }
+            Self::Resize(size) => write!(f, "Action::Resize({size:?})"),
+            Self::FetchSize(_) => write!(f, "Action::FetchSize"),
+            Self::Maximize(maximized) => {
+                write!(f, "Action::Maximize({maximized})")
+            }
+            Self::Minimize(minimized) => {
+                write!(f, "Action::Minimize({minimized}")
+            }
+            Self::Move { x, y } => {
+                write!(f, "Action::Move {{ x: {x}, y: {y} }}")
+            }
+            Self::ChangeMode(mode) => write!(f, "Action::SetMode({mode:?})"),
+            Self::FetchMode(_) => write!(f, "Action::FetchMode"),
+            Self::ToggleMaximize => write!(f, "Action::ToggleMaximize"),
+            Self::ToggleDecorations => write!(f, "Action::ToggleDecorations"),
+            Self::RequestUserAttention(_) => {
+                write!(f, "Action::RequestUserAttention")
+            }
+            Self::GainFocus => write!(f, "Action::GainFocus"),
+            Self::ChangeLevel(level) => {
+                write!(f, "Action::ChangeLevel({level:?})")
+            }
+            Self::FetchId(_) => write!(f, "Action::FetchId"),
+            Self::ChangeIcon(_icon) => {
+                write!(f, "Action::ChangeIcon(icon)")
+            }
+            Self::Screenshot(_) => write!(f, "Action::Screenshot"),
+        }
+    }
+}
diff --git a/runtime/src/window/screenshot.rs b/runtime/src/window/screenshot.rs
new file mode 100644
index 00000000..c84286b6
--- /dev/null
+++ b/runtime/src/window/screenshot.rs
@@ -0,0 +1,92 @@
+//! Take screenshots of a window.
+use crate::core::{Rectangle, Size};
+
+use std::fmt::{Debug, Formatter};
+use std::sync::Arc;
+
+/// Data of a screenshot, captured with `window::screenshot()`.
+///
+/// The `bytes` of this screenshot will always be ordered as `RGBA` in the sRGB color space.
+#[derive(Clone)]
+pub struct Screenshot {
+    /// The bytes of the [`Screenshot`].
+    pub bytes: Arc<Vec<u8>>,
+    /// The size of the [`Screenshot`].
+    pub size: Size<u32>,
+}
+
+impl Debug for Screenshot {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "Screenshot: {{ \n bytes: {}\n size: {:?} }}",
+            self.bytes.len(),
+            self.size
+        )
+    }
+}
+
+impl Screenshot {
+    /// Creates a new [`Screenshot`].
+    pub fn new(bytes: Vec<u8>, size: Size<u32>) -> Self {
+        Self {
+            bytes: Arc::new(bytes),
+            size,
+        }
+    }
+
+    /// Crops a [`Screenshot`] to the provided `region`. This will always be relative to the
+    /// top-left corner of the [`Screenshot`].
+    pub fn crop(&self, region: Rectangle<u32>) -> Result<Self, CropError> {
+        if region.width == 0 || region.height == 0 {
+            return Err(CropError::Zero);
+        }
+
+        if region.x + region.width > self.size.width
+            || region.y + region.height > self.size.height
+        {
+            return Err(CropError::OutOfBounds);
+        }
+
+        // Image is always RGBA8 = 4 bytes per pixel
+        const PIXEL_SIZE: usize = 4;
+
+        let bytes_per_row = self.size.width as usize * PIXEL_SIZE;
+        let row_range = region.y as usize..(region.y + region.height) as usize;
+        let column_range = region.x as usize * PIXEL_SIZE
+            ..(region.x + region.width) as usize * PIXEL_SIZE;
+
+        let chopped = self.bytes.chunks(bytes_per_row).enumerate().fold(
+            vec![],
+            |mut acc, (row, bytes)| {
+                if row_range.contains(&row) {
+                    acc.extend(&bytes[column_range.clone()]);
+                }
+
+                acc
+            },
+        );
+
+        Ok(Self {
+            bytes: Arc::new(chopped),
+            size: Size::new(region.width, region.height),
+        })
+    }
+}
+
+impl AsRef<[u8]> for Screenshot {
+    fn as_ref(&self) -> &[u8] {
+        &self.bytes
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+/// Errors that can occur when cropping a [`Screenshot`].
+pub enum CropError {
+    #[error("The cropped region is out of bounds.")]
+    /// The cropped region's size is out of bounds.
+    OutOfBounds,
+    #[error("The cropped region is not visible.")]
+    /// The cropped region's size is zero.
+    Zero,
+}