Merge pull request #1830 from iced-rs/advanced-text

Advanced text

42 files changed, 596 insertions, 2934 deletions

diff --git a/graphics/src/backend.rs b/graphics/src/backend.rs
index 256b7ab5..ae89da06 100644
--- a/graphics/src/backend.rs
+++ b/graphics/src/backend.rs
@@ -1,8 +1,10 @@
 //! Write a graphics backend.
-use iced_native::image;
-use iced_native::svg;
-use iced_native::text;
-use iced_native::{Font, Point, Size};
+use iced_core::image;
+use iced_core::svg;
+use iced_core::text;
+use iced_core::{Font, Point, Size};
+
+use std::borrow::Cow;
 
 /// The graphics backend of a [`Renderer`].
 ///
@@ -31,6 +33,9 @@ pub trait Text {
     /// [`ICON_FONT`]: Self::ICON_FONT
     const ARROW_DOWN_ICON: char;
 
+    /// Returns the default [`Font`].
+    fn default_font(&self) -> Font;
+
     /// Returns the default size of text.
     fn default_size(&self) -> f32;
 
@@ -41,8 +46,10 @@ pub trait Text {
         &self,
         contents: &str,
         size: f32,
+        line_height: text::LineHeight,
         font: Font,
         bounds: Size,
+        shaping: text::Shaping,
     ) -> (f32, f32);
 
     /// Tests whether the provided point is within the boundaries of [`Text`]
@@ -56,11 +63,16 @@ pub trait Text {
         &self,
         contents: &str,
         size: f32,
+        line_height: text::LineHeight,
         font: Font,
         bounds: Size,
+        shaping: text::Shaping,
         point: Point,
         nearest_only: bool,
     ) -> Option<text::Hit>;
+
+    /// Loads a [`Font`] from its bytes.
+    fn load_font(&mut self, font: Cow<'static, [u8]>);
 }
 
 /// A graphics backend that supports image rendering.
diff --git a/graphics/src/window/compositor.rs b/graphics/src/compositor.rs
index db4ba45d..d55e801a 100644
--- a/graphics/src/window/compositor.rs
+++ b/graphics/src/compositor.rs
@@ -1,6 +1,8 @@
 //! A compositor is responsible for initializing a renderer and managing window
 //! surfaces.
-use crate::{Color, Error, Viewport};
+use crate::{Error, Viewport};
+
+use iced_core::Color;
 
 use raw_window_handle::{HasRawDisplayHandle, HasRawWindowHandle};
 use thiserror::Error;
@@ -11,7 +13,7 @@ pub trait Compositor: Sized {
     type Settings: Default;
 
     /// The iced renderer of the backend.
-    type Renderer: iced_native::Renderer;
+    type Renderer: iced_core::Renderer;
 
     /// The surface of the backend.
     type Surface;
@@ -28,6 +30,8 @@ pub trait Compositor: Sized {
     fn create_surface<W: HasRawWindowHandle + HasRawDisplayHandle>(
         &mut self,
         window: &W,
+        width: u32,
+        height: u32,
     ) -> Self::Surface;
 
     /// Configures a new [`Surface`] with the given dimensions.
diff --git a/graphics/src/damage.rs b/graphics/src/damage.rs
new file mode 100644
index 00000000..c6b0f759
--- /dev/null
+++ b/graphics/src/damage.rs
@@ -0,0 +1,147 @@
+//! Track and compute the damage of graphical primitives.
+use crate::core::{Rectangle, Size};
+use crate::Primitive;
+
+use std::sync::Arc;
+
+/// Computes the damage regions between the two given primitives.
+pub fn regions(a: &Primitive, b: &Primitive) -> Vec<Rectangle> {
+    match (a, b) {
+        (
+            Primitive::Group {
+                primitives: primitives_a,
+            },
+            Primitive::Group {
+                primitives: primitives_b,
+            },
+        ) => return list(primitives_a, primitives_b),
+        (
+            Primitive::Clip {
+                bounds: bounds_a,
+                content: content_a,
+                ..
+            },
+            Primitive::Clip {
+                bounds: bounds_b,
+                content: content_b,
+                ..
+            },
+        ) => {
+            if bounds_a == bounds_b {
+                return regions(content_a, content_b)
+                    .into_iter()
+                    .filter_map(|r| r.intersection(&bounds_a.expand(1.0)))
+                    .collect();
+            } else {
+                return vec![bounds_a.expand(1.0), bounds_b.expand(1.0)];
+            }
+        }
+        (
+            Primitive::Translate {
+                translation: translation_a,
+                content: content_a,
+            },
+            Primitive::Translate {
+                translation: translation_b,
+                content: content_b,
+            },
+        ) => {
+            if translation_a == translation_b {
+                return regions(content_a, content_b)
+                    .into_iter()
+                    .map(|r| r + *translation_a)
+                    .collect();
+            }
+        }
+        (
+            Primitive::Cache { content: content_a },
+            Primitive::Cache { content: content_b },
+        ) => {
+            if Arc::ptr_eq(content_a, content_b) {
+                return vec![];
+            }
+        }
+        _ if a == b => return vec![],
+        _ => {}
+    }
+
+    let bounds_a = a.bounds();
+    let bounds_b = b.bounds();
+
+    if bounds_a == bounds_b {
+        vec![bounds_a]
+    } else {
+        vec![bounds_a, bounds_b]
+    }
+}
+
+/// Computes the damage regions between the two given lists of primitives.
+pub fn list(previous: &[Primitive], current: &[Primitive]) -> Vec<Rectangle> {
+    let damage = previous
+        .iter()
+        .zip(current)
+        .flat_map(|(a, b)| regions(a, b));
+
+    if previous.len() == current.len() {
+        damage.collect()
+    } else {
+        let (smaller, bigger) = if previous.len() < current.len() {
+            (previous, current)
+        } else {
+            (current, previous)
+        };
+
+        // Extend damage by the added/removed primitives
+        damage
+            .chain(bigger[smaller.len()..].iter().map(Primitive::bounds))
+            .collect()
+    }
+}
+
+/// Groups the given damage regions that are close together inside the given
+/// bounds.
+pub fn group(
+    mut damage: Vec<Rectangle>,
+    scale_factor: f32,
+    bounds: Size<u32>,
+) -> Vec<Rectangle> {
+    use std::cmp::Ordering;
+
+    const AREA_THRESHOLD: f32 = 20_000.0;
+
+    let bounds = Rectangle {
+        x: 0.0,
+        y: 0.0,
+        width: bounds.width as f32,
+        height: bounds.height as f32,
+    };
+
+    damage.sort_by(|a, b| {
+        a.x.partial_cmp(&b.x)
+            .unwrap_or(Ordering::Equal)
+            .then_with(|| a.y.partial_cmp(&b.y).unwrap_or(Ordering::Equal))
+    });
+
+    let mut output = Vec::new();
+    let mut scaled = damage
+        .into_iter()
+        .filter_map(|region| (region * scale_factor).intersection(&bounds))
+        .filter(|region| region.width >= 1.0 && region.height >= 1.0);
+
+    if let Some(mut current) = scaled.next() {
+        for region in scaled {
+            let union = current.union(&region);
+
+            if union.area() - current.area() - region.area() <= AREA_THRESHOLD {
+                current = union;
+            } else {
+                output.push(current);
+                current = region;
+            }
+        }
+
+        output.push(current);
+    }
+
+    output
+}
diff --git a/graphics/src/font.rs b/graphics/src/font.rs
deleted file mode 100644
index d55d0faf..00000000
--- a/graphics/src/font.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-//! Find system fonts or use the built-in ones.
-#[cfg(feature = "font-source")]
-mod source;
-
-#[cfg(feature = "font-source")]
-#[cfg_attr(docsrs, doc(cfg(feature = "font-source")))]
-pub use source::Source;
-
-#[cfg(feature = "font-source")]
-#[cfg_attr(docsrs, doc(cfg(feature = "font-source")))]
-pub use font_kit::{
-    error::SelectionError as LoadError, family_name::FamilyName as Family,
-};
-
-/// A built-in fallback font, for convenience.
-#[cfg(feature = "font-fallback")]
-#[cfg_attr(docsrs, doc(cfg(feature = "font-fallback")))]
-pub const FALLBACK: &[u8] = include_bytes!("../fonts/Lato-Regular.ttf");
-
-/// A built-in icon font, for convenience.
-#[cfg(feature = "font-icons")]
-#[cfg_attr(docsrs, doc(cfg(feature = "font-icons")))]
-pub const ICONS: iced_native::Font = iced_native::Font::External {
-    name: "iced_wgpu icons",
-    bytes: include_bytes!("../fonts/Icons.ttf"),
-};
-
-/// The `char` representing a ✔ icon in the built-in [`ICONS`] font.
-#[cfg(feature = "font-icons")]
-#[cfg_attr(docsrs, doc(cfg(feature = "font-icons")))]
-pub const CHECKMARK_ICON: char = '\u{F00C}';
-
-/// The `char` representing a ▼ icon in the built-in [`ICONS`] font.
-#[cfg(feature = "font-icons")]
-pub const ARROW_DOWN_ICON: char = '\u{E800}';
diff --git a/graphics/src/font/source.rs b/graphics/src/font/source.rs
deleted file mode 100644
index c0b50e1d..00000000
--- a/graphics/src/font/source.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-use crate::font::{Family, LoadError};
-
-/// A font source that can find and load system fonts.
-#[allow(missing_debug_implementations)]
-pub struct Source {
-    raw: font_kit::source::SystemSource,
-}
-
-impl Source {
-    /// Creates a new [`Source`].
-    pub fn new() -> Self {
-        Source {
-            raw: font_kit::source::SystemSource::new(),
-        }
-    }
-
-    /// Finds and loads a font matching the set of provided family priorities.
-    pub fn load(&self, families: &[Family]) -> Result<Vec<u8>, LoadError> {
-        let font = self.raw.select_best_match(
-            families,
-            &font_kit::properties::Properties::default(),
-        )?;
-
-        match font {
-            font_kit::handle::Handle::Path { path, .. } => {
-                use std::io::Read;
-
-                let mut buf = Vec::new();
-                let mut reader = std::fs::File::open(path).expect("Read font");
-                let _ = reader.read_to_end(&mut buf);
-
-                Ok(buf)
-            }
-            font_kit::handle::Handle::Memory { bytes, .. } => {
-                Ok(bytes.as_ref().clone())
-            }
-        }
-    }
-}
-
-impl Default for Source {
-    fn default() -> Self {
-        Self::new()
-    }
-}
diff --git a/graphics/src/geometry.rs b/graphics/src/geometry.rs
new file mode 100644
index 00000000..88997288
--- /dev/null
+++ b/graphics/src/geometry.rs
@@ -0,0 +1,33 @@
+//! Build and draw geometry.
+pub mod fill;
+pub mod path;
+pub mod stroke;
+
+mod style;
+mod text;
+
+pub use fill::Fill;
+pub use path::Path;
+pub use stroke::{LineCap, LineDash, LineJoin, Stroke};
+pub use style::Style;
+pub use text::Text;
+
+pub use crate::core::gradient::{self, Gradient};
+
+use crate::Primitive;
+
+/// A bunch of shapes that can be drawn.
+#[derive(Debug, Clone)]
+pub struct Geometry(pub Primitive);
+
+impl From<Geometry> for Primitive {
+    fn from(geometry: Geometry) -> Self {
+        geometry.0
+    }
+}
+
+/// A renderer capable of drawing some [`Geometry`].
+pub trait Renderer: crate::core::Renderer {
+    /// Draws the given layers of [`Geometry`].
+    fn draw(&mut self, layers: Vec<Geometry>);
+}
diff --git a/graphics/src/widget/canvas/fill.rs b/graphics/src/geometry/fill.rs
index e954ebb5..2e8c1669 100644
--- a/graphics/src/widget/canvas/fill.rs
+++ b/graphics/src/geometry/fill.rs
@@ -1,7 +1,7 @@
 //! Fill [crate::widget::canvas::Geometry] with a certain style.
-use crate::{Color, Gradient};
+use iced_core::{Color, Gradient};
 
-pub use crate::widget::canvas::Style;
+pub use crate::geometry::Style;
 
 /// The style used to fill geometry.
 #[derive(Debug, Clone)]
@@ -19,14 +19,14 @@ pub struct Fill {
     /// By default, it is set to `NonZero`.
     ///
     /// [1]: https://www.w3.org/TR/SVG/painting.html#FillRuleProperty
-    pub rule: FillRule,
+    pub rule: Rule,
 }
 
 impl Default for Fill {
     fn default() -> Self {
         Self {
             style: Style::Solid(Color::BLACK),
-            rule: FillRule::NonZero,
+            rule: Rule::NonZero,
         }
     }
 }
@@ -57,16 +57,7 @@ impl From<Gradient> for Fill {
 /// [1]: https://www.w3.org/TR/SVG/painting.html#FillRuleProperty
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[allow(missing_docs)]
-pub enum FillRule {
+pub enum Rule {
     NonZero,
     EvenOdd,
 }
-
-impl From<FillRule> for lyon::tessellation::FillRule {
-    fn from(rule: FillRule) -> lyon::tessellation::FillRule {
-        match rule {
-            FillRule::NonZero => lyon::tessellation::FillRule::NonZero,
-            FillRule::EvenOdd => lyon::tessellation::FillRule::EvenOdd,
-        }
-    }
-}
diff --git a/graphics/src/widget/canvas/path.rs b/graphics/src/geometry/path.rs
index aeb2589e..3d8fc6fa 100644
--- a/graphics/src/widget/canvas/path.rs
+++ b/graphics/src/geometry/path.rs
@@ -7,18 +7,16 @@ mod builder;
 pub use arc::Arc;
 pub use builder::Builder;
 
-use crate::widget::canvas::LineDash;
+pub use lyon_path;
 
-use iced_native::{Point, Size};
-use lyon::algorithms::walk::{walk_along_path, RepeatedPattern, WalkerEvent};
-use lyon::path::iterator::PathIterator;
+use iced_core::{Point, Size};
 
 /// An immutable set of points that may or may not be connected.
 ///
 /// A single [`Path`] can represent different kinds of 2D shapes!
 #[derive(Debug, Clone)]
 pub struct Path {
-    raw: lyon::path::Path,
+    raw: lyon_path::Path,
 }
 
 impl Path {
@@ -55,55 +53,17 @@ impl Path {
         Self::new(|p| p.circle(center, radius))
     }
 
+    /// Returns the internal [`lyon_path::Path`].
     #[inline]
-    pub(crate) fn raw(&self) -> &lyon::path::Path {
+    pub fn raw(&self) -> &lyon_path::Path {
         &self.raw
     }
 
+    /// Returns the current [`Path`] with the given transform applied to it.
     #[inline]
-    pub(crate) fn transformed(
-        &self,
-        transform: &lyon::math::Transform,
-    ) -> Path {
+    pub fn transform(&self, transform: &lyon_path::math::Transform) -> Path {
         Path {
             raw: self.raw.clone().transformed(transform),
         }
     }
 }
-
-pub(super) fn dashed(path: &Path, line_dash: LineDash<'_>) -> Path {
-    Path::new(|builder| {
-        let segments_odd = (line_dash.segments.len() % 2 == 1)
-            .then(|| [line_dash.segments, line_dash.segments].concat());
-
-        let mut draw_line = false;
-
-        walk_along_path(
-            path.raw().iter().flattened(0.01),
-            0.0,
-            lyon::tessellation::StrokeOptions::DEFAULT_TOLERANCE,
-            &mut RepeatedPattern {
-                callback: |event: WalkerEvent<'_>| {
-                    let point = Point {
-                        x: event.position.x,
-                        y: event.position.y,
-                    };
-
-                    if draw_line {
-                        builder.line_to(point);
-                    } else {
-                        builder.move_to(point);
-                    }
-
-                    draw_line = !draw_line;
-
-                    true
-                },
-                index: line_dash.offset,
-                intervals: segments_odd
-                    .as_deref()
-                    .unwrap_or(line_dash.segments),
-            },
-        );
-    })
-}
diff --git a/graphics/src/widget/canvas/path/arc.rs b/graphics/src/geometry/path/arc.rs
index b8e72daf..2cdebb66 100644
--- a/graphics/src/widget/canvas/path/arc.rs
+++ b/graphics/src/geometry/path/arc.rs
@@ -1,5 +1,5 @@
 //! Build and draw curves.
-use iced_native::{Point, Vector};
+use iced_core::{Point, Vector};
 
 /// A segment of a differentiable curve.
 #[derive(Debug, Clone, Copy)]
diff --git a/graphics/src/widget/canvas/path/builder.rs b/graphics/src/geometry/path/builder.rs
index 5121aa68..794dd3bc 100644
--- a/graphics/src/widget/canvas/path/builder.rs
+++ b/graphics/src/geometry/path/builder.rs
@@ -1,35 +1,38 @@
-use crate::widget::canvas::path::{arc, Arc, Path};
+use crate::geometry::path::{arc, Arc, Path};
 
-use iced_native::{Point, Size};
-use lyon::path::builder::SvgPathBuilder;
+use iced_core::{Point, Size};
+
+use lyon_path::builder::{self, SvgPathBuilder};
+use lyon_path::geom;
+use lyon_path::math;
 
 /// A [`Path`] builder.
 ///
 /// Once a [`Path`] is built, it can no longer be mutated.
 #[allow(missing_debug_implementations)]
 pub struct Builder {
-    raw: lyon::path::builder::WithSvg<lyon::path::path::BuilderImpl>,
+    raw: builder::WithSvg<lyon_path::path::BuilderImpl>,
 }
 
 impl Builder {
     /// Creates a new [`Builder`].
     pub fn new() -> Builder {
         Builder {
-            raw: lyon::path::Path::builder().with_svg(),
+            raw: lyon_path::Path::builder().with_svg(),
         }
     }
 
     /// Moves the starting point of a new sub-path to the given `Point`.
     #[inline]
     pub fn move_to(&mut self, point: Point) {
-        let _ = self.raw.move_to(lyon::math::Point::new(point.x, point.y));
+        let _ = self.raw.move_to(math::Point::new(point.x, point.y));
     }
 
     /// Connects the last point in the [`Path`] to the given `Point` with a
     /// straight line.
     #[inline]
     pub fn line_to(&mut self, point: Point) {
-        let _ = self.raw.line_to(lyon::math::Point::new(point.x, point.y));
+        let _ = self.raw.line_to(math::Point::new(point.x, point.y));
     }
 
     /// Adds an [`Arc`] to the [`Path`] from `start_angle` to `end_angle` in
@@ -53,8 +56,6 @@ impl Builder {
     /// See [the HTML5 specification of `arcTo`](https://html.spec.whatwg.org/multipage/canvas.html#building-paths:dom-context-2d-arcto)
     /// for more details and examples.
     pub fn arc_to(&mut self, a: Point, b: Point, radius: f32) {
-        use lyon::{math, path};
-
         let start = self.raw.current_position();
         let mid = math::Point::new(a.x, a.y);
         let end = math::Point::new(b.x, b.y);
@@ -92,7 +93,7 @@ impl Builder {
         self.raw.arc_to(
             math::Vector::new(radius, radius),
             math::Angle::radians(0.0),
-            path::ArcFlags {
+            lyon_path::ArcFlags {
                 large_arc: false,
                 sweep,
             },
@@ -102,8 +103,6 @@ impl Builder {
 
     /// Adds an ellipse to the [`Path`] using a clockwise direction.
     pub fn ellipse(&mut self, arc: arc::Elliptical) {
-        use lyon::{geom, math};
-
         let arc = geom::Arc {
             center: math::Point::new(arc.center.x, arc.center.y),
             radii: math::Vector::new(arc.radii.x, arc.radii.y),
@@ -128,8 +127,6 @@ impl Builder {
         control_b: Point,
         to: Point,
     ) {
-        use lyon::math;
-
         let _ = self.raw.cubic_bezier_to(
             math::Point::new(control_a.x, control_a.y),
             math::Point::new(control_b.x, control_b.y),
@@ -141,8 +138,6 @@ impl Builder {
     /// and its end point.
     #[inline]
     pub fn quadratic_curve_to(&mut self, control: Point, to: Point) {
-        use lyon::math;
-
         let _ = self.raw.quadratic_bezier_to(
             math::Point::new(control.x, control.y),
             math::Point::new(to.x, to.y),
diff --git a/graphics/src/widget/canvas/stroke.rs b/graphics/src/geometry/stroke.rs
index 49f5701c..69a76e1c 100644
--- a/graphics/src/widget/canvas/stroke.rs
+++ b/graphics/src/geometry/stroke.rs
@@ -1,7 +1,7 @@
 //! Create lines from a [crate::widget::canvas::Path] and assigns them various attributes/styles.
-pub use crate::widget::canvas::Style;
+pub use crate::geometry::Style;
 
-use iced_native::Color;
+use iced_core::Color;
 
 /// The style of a stroke.
 #[derive(Debug, Clone)]
@@ -72,16 +72,6 @@ pub enum LineCap {
     Round,
 }
 
-impl From<LineCap> for lyon::tessellation::LineCap {
-    fn from(line_cap: LineCap) -> lyon::tessellation::LineCap {
-        match line_cap {
-            LineCap::Butt => lyon::tessellation::LineCap::Butt,
-            LineCap::Square => lyon::tessellation::LineCap::Square,
-            LineCap::Round => lyon::tessellation::LineCap::Round,
-        }
-    }
-}
-
 /// The shape used at the corners of paths or basic shapes when they are
 /// stroked.
 #[derive(Debug, Clone, Copy, Default)]
@@ -95,16 +85,6 @@ pub enum LineJoin {
     Bevel,
 }
 
-impl From<LineJoin> for lyon::tessellation::LineJoin {
-    fn from(line_join: LineJoin) -> lyon::tessellation::LineJoin {
-        match line_join {
-            LineJoin::Miter => lyon::tessellation::LineJoin::Miter,
-            LineJoin::Round => lyon::tessellation::LineJoin::Round,
-            LineJoin::Bevel => lyon::tessellation::LineJoin::Bevel,
-        }
-    }
-}
-
 /// The dash pattern used when stroking the line.
 #[derive(Debug, Clone, Copy, Default)]
 pub struct LineDash<'a> {
diff --git a/graphics/src/widget/canvas/style.rs b/graphics/src/geometry/style.rs
index 6794f2e7..be9ee376 100644
--- a/graphics/src/widget/canvas/style.rs
+++ b/graphics/src/geometry/style.rs
@@ -1,4 +1,4 @@
-use crate::{Color, Gradient};
+use iced_core::{Color, Gradient};
 
 /// The coloring style of some drawing.
 #[derive(Debug, Clone, PartialEq)]
diff --git a/graphics/src/widget/canvas/text.rs b/graphics/src/geometry/text.rs
index 056f8204..c584f3cd 100644
--- a/graphics/src/widget/canvas/text.rs
+++ b/graphics/src/geometry/text.rs
@@ -1,5 +1,6 @@
-use crate::alignment;
-use crate::{Color, Font, Point};
+use crate::core::alignment;
+use crate::core::text::{LineHeight, Shaping};
+use crate::core::{Color, Font, Point};
 
 /// A bunch of text that can be drawn to a canvas
 #[derive(Debug, Clone)]
@@ -19,12 +20,16 @@ pub struct Text {
     pub color: Color,
     /// The size of the text
     pub size: f32,
+    /// The line height of the text.
+    pub line_height: LineHeight,
     /// The font of the text
     pub font: Font,
     /// The horizontal alignment of the text
     pub horizontal_alignment: alignment::Horizontal,
     /// The vertical alignment of the text
     pub vertical_alignment: alignment::Vertical,
+    /// The shaping strategy of the text.
+    pub shaping: Shaping,
 }
 
 impl Default for Text {
@@ -34,9 +39,11 @@ impl Default for Text {
             position: Point::ORIGIN,
             color: Color::BLACK,
             size: 16.0,
-            font: Font::Default,
+            line_height: LineHeight::Relative(1.2),
+            font: Font::default(),
             horizontal_alignment: alignment::Horizontal::Left,
             vertical_alignment: alignment::Vertical::Top,
+            shaping: Shaping::Basic,
         }
     }
 }
diff --git a/graphics/src/gradient.rs b/graphics/src/gradient.rs
deleted file mode 100644
index 61e919d6..00000000
--- a/graphics/src/gradient.rs
+++ /dev/null
@@ -1,117 +0,0 @@
-//! For creating a Gradient.
-pub mod linear;
-
-pub use linear::Linear;
-
-use crate::{Color, Point, Size};
-
-#[derive(Debug, Clone, PartialEq)]
-/// A fill which transitions colors progressively along a direction, either linearly, radially (TBD),
-/// or conically (TBD).
-pub enum Gradient {
-    /// A linear gradient interpolates colors along a direction from its `start` to its `end`
-    /// point.
-    Linear(Linear),
-}
-
-impl Gradient {
-    /// Creates a new linear [`linear::Builder`].
-    pub fn linear(position: impl Into<Position>) -> linear::Builder {
-        linear::Builder::new(position.into())
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq)]
-/// A point along the gradient vector where the specified [`color`] is unmixed.
-///
-/// [`color`]: Self::color
-pub struct ColorStop {
-    /// Offset along the gradient vector.
-    pub offset: f32,
-
-    /// The color of the gradient at the specified [`offset`].
-    ///
-    /// [`offset`]: Self::offset
-    pub color: Color,
-}
-
-#[derive(Debug)]
-/// The position of the gradient within its bounds.
-pub enum Position {
-    /// The gradient will be positioned with respect to two points.
-    Absolute {
-        /// The starting point of the gradient.
-        start: Point,
-        /// The ending point of the gradient.
-        end: Point,
-    },
-    /// The gradient will be positioned relative to the provided bounds.
-    Relative {
-        /// The top left position of the bounds.
-        top_left: Point,
-        /// The width & height of the bounds.
-        size: Size,
-        /// The start [Location] of the gradient.
-        start: Location,
-        /// The end [Location] of the gradient.
-        end: Location,
-    },
-}
-
-impl From<(Point, Point)> for Position {
-    fn from((start, end): (Point, Point)) -> Self {
-        Self::Absolute { start, end }
-    }
-}
-
-#[derive(Debug, Clone, Copy)]
-/// The location of a relatively-positioned gradient.
-pub enum Location {
-    /// Top left.
-    TopLeft,
-    /// Top.
-    Top,
-    /// Top right.
-    TopRight,
-    /// Right.
-    Right,
-    /// Bottom right.
-    BottomRight,
-    /// Bottom.
-    Bottom,
-    /// Bottom left.
-    BottomLeft,
-    /// Left.
-    Left,
-}
-
-impl Location {
-    fn to_absolute(self, top_left: Point, size: Size) -> Point {
-        match self {
-            Location::TopLeft => top_left,
-            Location::Top => {
-                Point::new(top_left.x + size.width / 2.0, top_left.y)
-            }
-            Location::TopRight => {
-                Point::new(top_left.x + size.width, top_left.y)
-            }
-            Location::Right => Point::new(
-                top_left.x + size.width,
-                top_left.y + size.height / 2.0,
-            ),
-            Location::BottomRight => {
-                Point::new(top_left.x + size.width, top_left.y + size.height)
-            }
-            Location::Bottom => Point::new(
-                top_left.x + size.width / 2.0,
-                top_left.y + size.height,
-            ),
-            Location::BottomLeft => {
-                Point::new(top_left.x, top_left.y + size.height)
-            }
-            Location::Left => {
-                Point::new(top_left.x, top_left.y + size.height / 2.0)
-            }
-        }
-    }
-}
diff --git a/graphics/src/gradient/linear.rs b/graphics/src/gradient/linear.rs
deleted file mode 100644
index c886db47..00000000
--- a/graphics/src/gradient/linear.rs
+++ /dev/null
@@ -1,112 +0,0 @@
-//! Linear gradient builder & definition.
-use crate::gradient::{ColorStop, Gradient, Position};
-use crate::{Color, Point};
-
-/// A linear gradient that can be used in the style of [`Fill`] or [`Stroke`].
-///
-/// [`Fill`]: crate::widget::canvas::Fill
-/// [`Stroke`]: crate::widget::canvas::Stroke
-#[derive(Debug, Clone, PartialEq)]
-pub struct Linear {
-    /// The point where the linear gradient begins.
-    pub start: Point,
-    /// The point where the linear gradient ends.
-    pub end: Point,
-    /// [`ColorStop`]s along the linear gradient path.
-    pub color_stops: Vec<ColorStop>,
-}
-
-/// A [`Linear`] builder.
-#[derive(Debug)]
-pub struct Builder {
-    start: Point,
-    end: Point,
-    stops: Vec<ColorStop>,
-    error: Option<BuilderError>,
-}
-
-impl Builder {
-    /// Creates a new [`Builder`].
-    pub fn new(position: Position) -> Self {
-        let (start, end) = match position {
-            Position::Absolute { start, end } => (start, end),
-            Position::Relative {
-                top_left,
-                size,
-                start,
-                end,
-            } => (
-                start.to_absolute(top_left, size),
-                end.to_absolute(top_left, size),
-            ),
-        };
-
-        Self {
-            start,
-            end,
-            stops: vec![],
-            error: None,
-        }
-    }
-
-    /// Adds a new stop, defined by an offset and a color, to the gradient.
-    ///
-    /// `offset` must be between `0.0` and `1.0` or the gradient cannot be built.
-    ///
-    /// Note: when using the [`glow`] backend, any color stop added after the 16th
-    /// will not be displayed.
-    ///
-    /// On the [`wgpu`] backend this limitation does not exist (technical limit is 524,288 stops).
-    ///
-    /// [`glow`]: https://docs.rs/iced_glow
-    /// [`wgpu`]: https://docs.rs/iced_wgpu
-    pub fn add_stop(mut self, offset: f32, color: Color) -> Self {
-        if offset.is_finite() && (0.0..=1.0).contains(&offset) {
-            match self.stops.binary_search_by(|stop| {
-                stop.offset.partial_cmp(&offset).unwrap()
-            }) {
-                Ok(_) => {
-                    self.error = Some(BuilderError::DuplicateOffset(offset))
-                }
-                Err(index) => {
-                    self.stops.insert(index, ColorStop { offset, color });
-                }
-            }
-        } else {
-            self.error = Some(BuilderError::InvalidOffset(offset))
-        };
-
-        self
-    }
-
-    /// Builds the linear [`Gradient`] of this [`Builder`].
-    ///
-    /// Returns `BuilderError` if gradient in invalid.
-    pub fn build(self) -> Result<Gradient, BuilderError> {
-        if self.stops.is_empty() {
-            Err(BuilderError::MissingColorStop)
-        } else if let Some(error) = self.error {
-            Err(error)
-        } else {
-            Ok(Gradient::Linear(Linear {
-                start: self.start,
-                end: self.end,
-                color_stops: self.stops,
-            }))
-        }
-    }
-}
-
-/// An error that happened when building a [`Linear`] gradient.
-#[derive(Debug, thiserror::Error)]
-pub enum BuilderError {
-    #[error("Gradients must contain at least one color stop.")]
-    /// Gradients must contain at least one color stop.
-    MissingColorStop,
-    #[error("Offset {0} must be a unique, finite number.")]
-    /// Offsets in a gradient must all be unique & finite.
-    DuplicateOffset(f32),
-    #[error("Offset {0} must be between 0.0..=1.0.")]
-    /// Offsets in a gradient must be between 0.0..=1.0.
-    InvalidOffset(f32),
-}
diff --git a/graphics/src/image.rs b/graphics/src/image.rs
index 04f4ff9d..6b43f4a8 100644
--- a/graphics/src/image.rs
+++ b/graphics/src/image.rs
@@ -1,10 +1,95 @@
-//! Render images.
-#[cfg(feature = "image_rs")]
-pub mod raster;
+//! Load and operate on images.
+use crate::core::image::{Data, Handle};
 
-#[cfg(feature = "svg")]
-pub mod vector;
+use bitflags::bitflags;
 
-pub mod storage;
+pub use ::image as image_rs;
 
-pub use storage::Storage;
+/// Tries to load an image by its [`Handle`].
+pub fn load(handle: &Handle) -> image_rs::ImageResult<image_rs::DynamicImage> {
+    match handle.data() {
+        Data::Path(path) => {
+            let image = ::image::open(path)?;
+
+            let operation = std::fs::File::open(path)
+                .ok()
+                .map(std::io::BufReader::new)
+                .and_then(|mut reader| Operation::from_exif(&mut reader).ok())
+                .unwrap_or_else(Operation::empty);
+
+            Ok(operation.perform(image))
+        }
+        Data::Bytes(bytes) => {
+            let image = ::image::load_from_memory(bytes)?;
+            let operation =
+                Operation::from_exif(&mut std::io::Cursor::new(bytes))
+                    .ok()
+                    .unwrap_or_else(Operation::empty);
+
+            Ok(operation.perform(image))
+        }
+        Data::Rgba {
+            width,
+            height,
+            pixels,
+        } => {
+            if let Some(image) = image_rs::ImageBuffer::from_vec(
+                *width,
+                *height,
+                pixels.to_vec(),
+            ) {
+                Ok(image_rs::DynamicImage::ImageRgba8(image))
+            } else {
+                Err(image_rs::error::ImageError::Limits(
+                    image_rs::error::LimitError::from_kind(
+                        image_rs::error::LimitErrorKind::DimensionError,
+                    ),
+                ))
+            }
+        }
+    }
+}
+
+bitflags! {
+    struct Operation: u8 {
+        const FLIP_HORIZONTALLY = 0b001;
+        const ROTATE_180 = 0b010;
+        const FLIP_DIAGONALLY = 0b100;
+    }
+}
+
+impl Operation {
+    // Meaning of the returned value is described e.g. at:
+    // https://magnushoff.com/articles/jpeg-orientation/
+    fn from_exif<R>(reader: &mut R) -> Result<Self, exif::Error>
+    where
+        R: std::io::BufRead + std::io::Seek,
+    {
+        let exif = exif::Reader::new().read_from_container(reader)?;
+
+        Ok(exif
+            .get_field(exif::Tag::Orientation, exif::In::PRIMARY)
+            .and_then(|field| field.value.get_uint(0))
+            .and_then(|value| u8::try_from(value).ok())
+            .and_then(|value| Self::from_bits(value.saturating_sub(1)))
+            .unwrap_or_else(Self::empty))
+    }
+
+    fn perform(self, mut image: image::DynamicImage) -> image::DynamicImage {
+        use image::imageops;
+
+        if self.contains(Self::FLIP_DIAGONALLY) {
+            imageops::flip_vertical_in_place(&mut image)
+        }
+
+        if self.contains(Self::ROTATE_180) {
+            imageops::rotate180_in_place(&mut image);
+        }
+
+        if self.contains(Self::FLIP_HORIZONTALLY) {
+            imageops::flip_horizontal_in_place(&mut image);
+        }
+
+        image
+    }
+}
diff --git a/graphics/src/image/raster.rs b/graphics/src/image/raster.rs
deleted file mode 100644
index da46c30f..00000000
--- a/graphics/src/image/raster.rs
+++ /dev/null
@@ -1,242 +0,0 @@
-//! Raster image loading and caching.
-use crate::image::Storage;
-use crate::Size;
-
-use iced_native::image;
-
-use bitflags::bitflags;
-use std::collections::{HashMap, HashSet};
-
-/// Entry in cache corresponding to an image handle
-#[derive(Debug)]
-pub enum Memory<T: Storage> {
-    /// Image data on host
-    Host(::image_rs::ImageBuffer<::image_rs::Rgba<u8>, Vec<u8>>),
-    /// Storage entry
-    Device(T::Entry),
-    /// Image not found
-    NotFound,
-    /// Invalid image data
-    Invalid,
-}
-
-impl<T: Storage> Memory<T> {
-    /// Width and height of image
-    pub fn dimensions(&self) -> Size<u32> {
-        use crate::image::storage::Entry;
-
-        match self {
-            Memory::Host(image) => {
-                let (width, height) = image.dimensions();
-
-                Size::new(width, height)
-            }
-            Memory::Device(entry) => entry.size(),
-            Memory::NotFound => Size::new(1, 1),
-            Memory::Invalid => Size::new(1, 1),
-        }
-    }
-}
-
-/// Caches image raster data
-#[derive(Debug)]
-pub struct Cache<T: Storage> {
-    map: HashMap<u64, Memory<T>>,
-    hits: HashSet<u64>,
-}
-
-impl<T: Storage> Cache<T> {
-    /// Load image
-    pub fn load(&mut self, handle: &image::Handle) -> &mut Memory<T> {
-        if self.contains(handle) {
-            return self.get(handle).unwrap();
-        }
-
-        let memory = match handle.data() {
-            image::Data::Path(path) => {
-                if let Ok(image) = image_rs::open(path) {
-                    let operation = std::fs::File::open(path)
-                        .ok()
-                        .map(std::io::BufReader::new)
-                        .and_then(|mut reader| {
-                            Operation::from_exif(&mut reader).ok()
-                        })
-                        .unwrap_or_else(Operation::empty);
-
-                    Memory::Host(operation.perform(image.to_rgba8()))
-                } else {
-                    Memory::NotFound
-                }
-            }
-            image::Data::Bytes(bytes) => {
-                if let Ok(image) = image_rs::load_from_memory(bytes) {
-                    let operation =
-                        Operation::from_exif(&mut std::io::Cursor::new(bytes))
-                            .ok()
-                            .unwrap_or_else(Operation::empty);
-
-                    Memory::Host(operation.perform(image.to_rgba8()))
-                } else {
-                    Memory::Invalid
-                }
-            }
-            image::Data::Rgba {
-                width,
-                height,
-                pixels,
-            } => {
-                if let Some(image) = image_rs::ImageBuffer::from_vec(
-                    *width,
-                    *height,
-                    pixels.to_vec(),
-                ) {
-                    Memory::Host(image)
-                } else {
-                    Memory::Invalid
-                }
-            }
-        };
-
-        self.insert(handle, memory);
-        self.get(handle).unwrap()
-    }
-
-    /// Load image and upload raster data
-    pub fn upload(
-        &mut self,
-        handle: &image::Handle,
-        state: &mut T::State<'_>,
-        storage: &mut T,
-    ) -> Option<&T::Entry> {
-        let memory = self.load(handle);
-
-        if let Memory::Host(image) = memory {
-            let (width, height) = image.dimensions();
-
-            let entry = storage.upload(width, height, image, state)?;
-
-            *memory = Memory::Device(entry);
-        }
-
-        if let Memory::Device(allocation) = memory {
-            Some(allocation)
-        } else {
-            None
-        }
-    }
-
-    /// Trim cache misses from cache
-    pub fn trim(&mut self, storage: &mut T, state: &mut T::State<'_>) {
-        let hits = &self.hits;
-
-        self.map.retain(|k, memory| {
-            let retain = hits.contains(k);
-
-            if !retain {
-                if let Memory::Device(entry) = memory {
-                    storage.remove(entry, state);
-                }
-            }
-
-            retain
-        });
-
-        self.hits.clear();
-    }
-
-    fn get(&mut self, handle: &image::Handle) -> Option<&mut Memory<T>> {
-        let _ = self.hits.insert(handle.id());
-
-        self.map.get_mut(&handle.id())
-    }
-
-    fn insert(&mut self, handle: &image::Handle, memory: Memory<T>) {
-        let _ = self.map.insert(handle.id(), memory);
-    }
-
-    fn contains(&self, handle: &image::Handle) -> bool {
-        self.map.contains_key(&handle.id())
-    }
-}
-
-impl<T: Storage> Default for Cache<T> {
-    fn default() -> Self {
-        Self {
-            map: HashMap::new(),
-            hits: HashSet::new(),
-        }
-    }
-}
-
-bitflags! {
-    struct Operation: u8 {
-        const FLIP_HORIZONTALLY = 0b001;
-        const ROTATE_180 = 0b010;
-        const FLIP_DIAGONALLY = 0b100;
-    }
-}
-
-impl Operation {
-    // Meaning of the returned value is described e.g. at:
-    // https://magnushoff.com/articles/jpeg-orientation/
-    fn from_exif<R>(reader: &mut R) -> Result<Self, exif::Error>
-    where
-        R: std::io::BufRead + std::io::Seek,
-    {
-        let exif = exif::Reader::new().read_from_container(reader)?;
-
-        Ok(exif
-            .get_field(exif::Tag::Orientation, exif::In::PRIMARY)
-            .and_then(|field| field.value.get_uint(0))
-            .and_then(|value| u8::try_from(value).ok())
-            .and_then(|value| Self::from_bits(value.saturating_sub(1)))
-            .unwrap_or_else(Self::empty))
-    }
-
-    fn perform<P>(
-        self,
-        image: image_rs::ImageBuffer<P, Vec<P::Subpixel>>,
-    ) -> image_rs::ImageBuffer<P, Vec<P::Subpixel>>
-    where
-        P: image_rs::Pixel + 'static,
-    {
-        use image_rs::imageops;
-
-        let mut image = if self.contains(Self::FLIP_DIAGONALLY) {
-            flip_diagonally(image)
-        } else {
-            image
-        };
-
-        if self.contains(Self::ROTATE_180) {
-            imageops::rotate180_in_place(&mut image);
-        }
-
-        if self.contains(Self::FLIP_HORIZONTALLY) {
-            imageops::flip_horizontal_in_place(&mut image);
-        }
-
-        image
-    }
-}
-
-fn flip_diagonally<I>(
-    image: I,
-) -> image_rs::ImageBuffer<I::Pixel, Vec<<I::Pixel as image_rs::Pixel>::Subpixel>>
-where
-    I: image_rs::GenericImage,
-    I::Pixel: 'static,
-{
-    let (width, height) = image.dimensions();
-    let mut out = image_rs::ImageBuffer::new(height, width);
-
-    for x in 0..width {
-        for y in 0..height {
-            let p = image.get_pixel(x, y);
-
-            out.put_pixel(y, x, p);
-        }
-    }
-
-    out
-}
diff --git a/graphics/src/image/storage.rs b/graphics/src/image/storage.rs
index 1b5b5c35..4caa6141 100644
--- a/graphics/src/image/storage.rs
+++ b/graphics/src/image/storage.rs
@@ -1,5 +1,5 @@
 //! Store images.
-use crate::Size;
+use iced_core::Size;
 
 use std::fmt::Debug;
 
diff --git a/graphics/src/image/vector.rs b/graphics/src/image/vector.rs
deleted file mode 100644
index c950ccd6..00000000
--- a/graphics/src/image/vector.rs
+++ /dev/null
@@ -1,191 +0,0 @@
-//! Vector image loading and caching
-use crate::image::Storage;
-use crate::Color;
-
-use iced_native::svg;
-use iced_native::Size;
-
-use resvg::tiny_skia;
-use resvg::usvg;
-use std::collections::{HashMap, HashSet};
-use std::fs;
-
-/// Entry in cache corresponding to an svg handle
-pub enum Svg {
-    /// Parsed svg
-    Loaded(usvg::Tree),
-    /// Svg not found or failed to parse
-    NotFound,
-}
-
-impl Svg {
-    /// Viewport width and height
-    pub fn viewport_dimensions(&self) -> Size<u32> {
-        match self {
-            Svg::Loaded(tree) => {
-                let size = tree.size;
-
-                Size::new(size.width() as u32, size.height() as u32)
-            }
-            Svg::NotFound => Size::new(1, 1),
-        }
-    }
-}
-
-/// Caches svg vector and raster data
-#[derive(Debug)]
-pub struct Cache<T: Storage> {
-    svgs: HashMap<u64, Svg>,
-    rasterized: HashMap<(u64, u32, u32, ColorFilter), T::Entry>,
-    svg_hits: HashSet<u64>,
-    rasterized_hits: HashSet<(u64, u32, u32, ColorFilter)>,
-}
-
-type ColorFilter = Option<[u8; 4]>;
-
-impl<T: Storage> Cache<T> {
-    /// Load svg
-    pub fn load(&mut self, handle: &svg::Handle) -> &Svg {
-        if self.svgs.contains_key(&handle.id()) {
-            return self.svgs.get(&handle.id()).unwrap();
-        }
-
-        let svg = match handle.data() {
-            svg::Data::Path(path) => {
-                let tree = fs::read_to_string(path).ok().and_then(|contents| {
-                    usvg::Tree::from_str(&contents, &usvg::Options::default())
-                        .ok()
-                });
-
-                tree.map(Svg::Loaded).unwrap_or(Svg::NotFound)
-            }
-            svg::Data::Bytes(bytes) => {
-                match usvg::Tree::from_data(bytes, &usvg::Options::default()) {
-                    Ok(tree) => Svg::Loaded(tree),
-                    Err(_) => Svg::NotFound,
-                }
-            }
-        };
-
-        let _ = self.svgs.insert(handle.id(), svg);
-        self.svgs.get(&handle.id()).unwrap()
-    }
-
-    /// Load svg and upload raster data
-    pub fn upload(
-        &mut self,
-        handle: &svg::Handle,
-        color: Option<Color>,
-        [width, height]: [f32; 2],
-        scale: f32,
-        state: &mut T::State<'_>,
-        storage: &mut T,
-    ) -> Option<&T::Entry> {
-        let id = handle.id();
-
-        let (width, height) = (
-            (scale * width).ceil() as u32,
-            (scale * height).ceil() as u32,
-        );
-
-        let color = color.map(Color::into_rgba8);
-        let key = (id, width, height, color);
-
-        // TODO: Optimize!
-        // We currently rerasterize the SVG when its size changes. This is slow
-        // as heck. A GPU rasterizer like `pathfinder` may perform better.
-        // It would be cool to be able to smooth resize the `svg` example.
-        if self.rasterized.contains_key(&key) {
-            let _ = self.svg_hits.insert(id);
-            let _ = self.rasterized_hits.insert(key);
-
-            return self.rasterized.get(&key);
-        }
-
-        match self.load(handle) {
-            Svg::Loaded(tree) => {
-                if width == 0 || height == 0 {
-                    return None;
-                }
-
-                // TODO: Optimize!
-                // We currently rerasterize the SVG when its size changes. This is slow
-                // as heck. A GPU rasterizer like `pathfinder` may perform better.
-                // It would be cool to be able to smooth resize the `svg` example.
-                let mut img = tiny_skia::Pixmap::new(width, height)?;
-
-                resvg::render(
-                    tree,
-                    if width > height {
-                        usvg::FitTo::Width(width)
-                    } else {
-                        usvg::FitTo::Height(height)
-                    },
-                    tiny_skia::Transform::default(),
-                    img.as_mut(),
-                )?;
-
-                let mut rgba = img.take();
-
-                if let Some(color) = color {
-                    rgba.chunks_exact_mut(4).for_each(|rgba| {
-                        if rgba[3] > 0 {
-                            rgba[0] = color[0];
-                            rgba[1] = color[1];
-                            rgba[2] = color[2];
-                        }
-                    });
-                }
-
-                let allocation = storage.upload(width, height, &rgba, state)?;
-                log::debug!("allocating {} {}x{}", id, width, height);
-
-                let _ = self.svg_hits.insert(id);
-                let _ = self.rasterized_hits.insert(key);
-                let _ = self.rasterized.insert(key, allocation);
-
-                self.rasterized.get(&key)
-            }
-            Svg::NotFound => None,
-        }
-    }
-
-    /// Load svg and upload raster data
-    pub fn trim(&mut self, storage: &mut T, state: &mut T::State<'_>) {
-        let svg_hits = &self.svg_hits;
-        let rasterized_hits = &self.rasterized_hits;
-
-        self.svgs.retain(|k, _| svg_hits.contains(k));
-        self.rasterized.retain(|k, entry| {
-            let retain = rasterized_hits.contains(k);
-
-            if !retain {
-                storage.remove(entry, state);
-            }
-
-            retain
-        });
-        self.svg_hits.clear();
-        self.rasterized_hits.clear();
-    }
-}
-
-impl<T: Storage> Default for Cache<T> {
-    fn default() -> Self {
-        Self {
-            svgs: HashMap::new(),
-            rasterized: HashMap::new(),
-            svg_hits: HashSet::new(),
-            rasterized_hits: HashSet::new(),
-        }
-    }
-}
-
-impl std::fmt::Debug for Svg {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Svg::Loaded(_) => write!(f, "Svg::Loaded"),
-            Svg::NotFound => write!(f, "Svg::NotFound"),
-        }
-    }
-}
diff --git a/graphics/src/layer.rs b/graphics/src/layer.rs
deleted file mode 100644
index 1d453caa..00000000
--- a/graphics/src/layer.rs
+++ /dev/null
@@ -1,269 +0,0 @@
-//! Organize rendering primitives into a flattened list of layers.
-mod image;
-mod quad;
-mod text;
-
-pub mod mesh;
-
-pub use image::Image;
-pub use mesh::Mesh;
-pub use quad::Quad;
-pub use text::Text;
-
-use crate::alignment;
-use crate::{
-    Background, Font, Point, Primitive, Rectangle, Size, Vector, Viewport,
-};
-
-/// A group of primitives that should be clipped together.
-#[derive(Debug)]
-pub struct Layer<'a> {
-    /// The clipping bounds of the [`Layer`].
-    pub bounds: Rectangle,
-
-    /// The quads of the [`Layer`].
-    pub quads: Vec<Quad>,
-
-    /// The triangle meshes of the [`Layer`].
-    pub meshes: Vec<Mesh<'a>>,
-
-    /// The text of the [`Layer`].
-    pub text: Vec<Text<'a>>,
-
-    /// The images of the [`Layer`].
-    pub images: Vec<Image>,
-}
-
-impl<'a> Layer<'a> {
-    /// Creates a new [`Layer`] with the given clipping bounds.
-    pub fn new(bounds: Rectangle) -> Self {
-        Self {
-            bounds,
-            quads: Vec::new(),
-            meshes: Vec::new(),
-            text: Vec::new(),
-            images: Vec::new(),
-        }
-    }
-
-    /// Creates a new [`Layer`] for the provided overlay text.
-    ///
-    /// This can be useful for displaying debug information.
-    pub fn overlay(lines: &'a [impl AsRef<str>], viewport: &Viewport) -> Self {
-        let mut overlay =
-            Layer::new(Rectangle::with_size(viewport.logical_size()));
-
-        for (i, line) in lines.iter().enumerate() {
-            let text = Text {
-                content: line.as_ref(),
-                bounds: Rectangle::new(
-                    Point::new(11.0, 11.0 + 25.0 * i as f32),
-                    Size::INFINITY,
-                ),
-                color: [0.9, 0.9, 0.9, 1.0],
-                size: 20.0,
-                font: Font::Default,
-                horizontal_alignment: alignment::Horizontal::Left,
-                vertical_alignment: alignment::Vertical::Top,
-            };
-
-            overlay.text.push(text);
-
-            overlay.text.push(Text {
-                bounds: text.bounds + Vector::new(-1.0, -1.0),
-                color: [0.0, 0.0, 0.0, 1.0],
-                ..text
-            });
-        }
-
-        overlay
-    }
-
-    /// Distributes the given [`Primitive`] and generates a list of layers based
-    /// on its contents.
-    pub fn generate(
-        primitives: &'a [Primitive],
-        viewport: &Viewport,
-    ) -> Vec<Self> {
-        let first_layer =
-            Layer::new(Rectangle::with_size(viewport.logical_size()));
-
-        let mut layers = vec![first_layer];
-
-        for primitive in primitives {
-            Self::process_primitive(
-                &mut layers,
-                Vector::new(0.0, 0.0),
-                primitive,
-                0,
-            );
-        }
-
-        layers
-    }
-
-    fn process_primitive(
-        layers: &mut Vec<Self>,
-        translation: Vector,
-        primitive: &'a Primitive,
-        current_layer: usize,
-    ) {
-        match primitive {
-            Primitive::None => {}
-            Primitive::Group { primitives } => {
-                // TODO: Inspect a bit and regroup (?)
-                for primitive in primitives {
-                    Self::process_primitive(
-                        layers,
-                        translation,
-                        primitive,
-                        current_layer,
-                    )
-                }
-            }
-            Primitive::Text {
-                content,
-                bounds,
-                size,
-                color,
-                font,
-                horizontal_alignment,
-                vertical_alignment,
-            } => {
-                let layer = &mut layers[current_layer];
-
-                layer.text.push(Text {
-                    content,
-                    bounds: *bounds + translation,
-                    size: *size,
-                    color: color.into_linear(),
-                    font: *font,
-                    horizontal_alignment: *horizontal_alignment,
-                    vertical_alignment: *vertical_alignment,
-                });
-            }
-            Primitive::Quad {
-                bounds,
-                background,
-                border_radius,
-                border_width,
-                border_color,
-            } => {
-                let layer = &mut layers[current_layer];
-
-                // TODO: Move some of these computations to the GPU (?)
-                layer.quads.push(Quad {
-                    position: [
-                        bounds.x + translation.x,
-                        bounds.y + translation.y,
-                    ],
-                    size: [bounds.width, bounds.height],
-                    color: match background {
-                        Background::Color(color) => color.into_linear(),
-                    },
-                    border_radius: *border_radius,
-                    border_width: *border_width,
-                    border_color: border_color.into_linear(),
-                });
-            }
-            Primitive::SolidMesh { buffers, size } => {
-                let layer = &mut layers[current_layer];
-
-                let bounds = Rectangle::new(
-                    Point::new(translation.x, translation.y),
-                    *size,
-                );
-
-                // Only draw visible content
-                if let Some(clip_bounds) = layer.bounds.intersection(&bounds) {
-                    layer.meshes.push(Mesh::Solid {
-                        origin: Point::new(translation.x, translation.y),
-                        buffers,
-                        clip_bounds,
-                    });
-                }
-            }
-            Primitive::GradientMesh {
-                buffers,
-                size,
-                gradient,
-            } => {
-                let layer = &mut layers[current_layer];
-
-                let bounds = Rectangle::new(
-                    Point::new(translation.x, translation.y),
-                    *size,
-                );
-
-                // Only draw visible content
-                if let Some(clip_bounds) = layer.bounds.intersection(&bounds) {
-                    layer.meshes.push(Mesh::Gradient {
-                        origin: Point::new(translation.x, translation.y),
-                        buffers,
-                        clip_bounds,
-                        gradient,
-                    });
-                }
-            }
-            Primitive::Clip { bounds, content } => {
-                let layer = &mut layers[current_layer];
-                let translated_bounds = *bounds + translation;
-
-                // Only draw visible content
-                if let Some(clip_bounds) =
-                    layer.bounds.intersection(&translated_bounds)
-                {
-                    let clip_layer = Layer::new(clip_bounds);
-                    layers.push(clip_layer);
-
-                    Self::process_primitive(
-                        layers,
-                        translation,
-                        content,
-                        layers.len() - 1,
-                    );
-                }
-            }
-            Primitive::Translate {
-                translation: new_translation,
-                content,
-            } => {
-                Self::process_primitive(
-                    layers,
-                    translation + *new_translation,
-                    content,
-                    current_layer,
-                );
-            }
-            Primitive::Cached { cache } => {
-                Self::process_primitive(
-                    layers,
-                    translation,
-                    cache,
-                    current_layer,
-                );
-            }
-            Primitive::Image { handle, bounds } => {
-                let layer = &mut layers[current_layer];
-
-                layer.images.push(Image::Raster {
-                    handle: handle.clone(),
-                    bounds: *bounds + translation,
-                });
-            }
-            Primitive::Svg {
-                handle,
-                color,
-                bounds,
-            } => {
-                let layer = &mut layers[current_layer];
-
-                layer.images.push(Image::Vector {
-                    handle: handle.clone(),
-                    color: *color,
-                    bounds: *bounds + translation,
-                });
-            }
-        }
-    }
-}
diff --git a/graphics/src/layer/image.rs b/graphics/src/layer/image.rs
deleted file mode 100644
index 3eff2397..00000000
--- a/graphics/src/layer/image.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-use crate::{Color, Rectangle};
-
-use iced_native::{image, svg};
-
-/// A raster or vector image.
-#[derive(Debug, Clone)]
-pub enum Image {
-    /// A raster image.
-    Raster {
-        /// The handle of a raster image.
-        handle: image::Handle,
-
-        /// The bounds of the image.
-        bounds: Rectangle,
-    },
-    /// A vector image.
-    Vector {
-        /// The handle of a vector image.
-        handle: svg::Handle,
-
-        /// The [`Color`] filter
-        color: Option<Color>,
-
-        /// The bounds of the image.
-        bounds: Rectangle,
-    },
-}
diff --git a/graphics/src/layer/mesh.rs b/graphics/src/layer/mesh.rs
deleted file mode 100644
index 7661c5c9..00000000
--- a/graphics/src/layer/mesh.rs
+++ /dev/null
@@ -1,93 +0,0 @@
-//! A collection of triangle primitives.
-use crate::triangle;
-use crate::{Gradient, Point, Rectangle};
-
-/// A mesh of triangles.
-#[derive(Debug, Clone, Copy)]
-pub enum Mesh<'a> {
-    /// A mesh of triangles with a solid color.
-    Solid {
-        /// The origin of the vertices of the [`Mesh`].
-        origin: Point,
-
-        /// The vertex and index buffers of the [`Mesh`].
-        buffers: &'a triangle::Mesh2D<triangle::ColoredVertex2D>,
-
-        /// The clipping bounds of the [`Mesh`].
-        clip_bounds: Rectangle<f32>,
-    },
-    /// A mesh of triangles with a gradient color.
-    Gradient {
-        /// The origin of the vertices of the [`Mesh`].
-        origin: Point,
-
-        /// The vertex and index buffers of the [`Mesh`].
-        buffers: &'a triangle::Mesh2D<triangle::Vertex2D>,
-
-        /// The clipping bounds of the [`Mesh`].
-        clip_bounds: Rectangle<f32>,
-
-        /// The gradient to apply to the [`Mesh`].
-        gradient: &'a Gradient,
-    },
-}
-
-impl Mesh<'_> {
-    /// Returns the origin of the [`Mesh`].
-    pub fn origin(&self) -> Point {
-        match self {
-            Self::Solid { origin, .. } | Self::Gradient { origin, .. } => {
-                *origin
-            }
-        }
-    }
-
-    /// Returns the indices of the [`Mesh`].
-    pub fn indices(&self) -> &[u32] {
-        match self {
-            Self::Solid { buffers, .. } => &buffers.indices,
-            Self::Gradient { buffers, .. } => &buffers.indices,
-        }
-    }
-
-    /// Returns the clip bounds of the [`Mesh`].
-    pub fn clip_bounds(&self) -> Rectangle<f32> {
-        match self {
-            Self::Solid { clip_bounds, .. }
-            | Self::Gradient { clip_bounds, .. } => *clip_bounds,
-        }
-    }
-}
-
-/// The result of counting the attributes of a set of meshes.
-#[derive(Debug, Clone, Copy, Default)]
-pub struct AttributeCount {
-    /// The total amount of solid vertices.
-    pub solid_vertices: usize,
-
-    /// The total amount of gradient vertices.
-    pub gradient_vertices: usize,
-
-    /// The total amount of indices.
-    pub indices: usize,
-}
-
-/// Returns the number of total vertices & total indices of all [`Mesh`]es.
-pub fn attribute_count_of<'a>(meshes: &'a [Mesh<'a>]) -> AttributeCount {
-    meshes
-        .iter()
-        .fold(AttributeCount::default(), |mut count, mesh| {
-            match mesh {
-                Mesh::Solid { buffers, .. } => {
-                    count.solid_vertices += buffers.vertices.len();
-                    count.indices += buffers.indices.len();
-                }
-                Mesh::Gradient { buffers, .. } => {
-                    count.gradient_vertices += buffers.vertices.len();
-                    count.indices += buffers.indices.len();
-                }
-            }
-
-            count
-        })
-}
diff --git a/graphics/src/layer/quad.rs b/graphics/src/layer/quad.rs
deleted file mode 100644
index 0d8bde9d..00000000
--- a/graphics/src/layer/quad.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-/// A colored rectangle with a border.
-///
-/// This type can be directly uploaded to GPU memory.
-#[derive(Debug, Clone, Copy)]
-#[repr(C)]
-pub struct Quad {
-    /// The position of the [`Quad`].
-    pub position: [f32; 2],
-
-    /// The size of the [`Quad`].
-    pub size: [f32; 2],
-
-    /// The color of the [`Quad`], in __linear RGB__.
-    pub color: [f32; 4],
-
-    /// The border color of the [`Quad`], in __linear RGB__.
-    pub border_color: [f32; 4],
-
-    /// The border radius of the [`Quad`].
-    pub border_radius: [f32; 4],
-
-    /// The border width of the [`Quad`].
-    pub border_width: f32,
-}
-
-#[allow(unsafe_code)]
-unsafe impl bytemuck::Zeroable for Quad {}
-
-#[allow(unsafe_code)]
-unsafe impl bytemuck::Pod for Quad {}
diff --git a/graphics/src/layer/text.rs b/graphics/src/layer/text.rs
deleted file mode 100644
index 74f7a676..00000000
--- a/graphics/src/layer/text.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-use crate::{alignment, Font, Rectangle};
-
-/// A paragraph of text.
-#[derive(Debug, Clone, Copy)]
-pub struct Text<'a> {
-    /// The content of the [`Text`].
-    pub content: &'a str,
-
-    /// The layout bounds of the [`Text`].
-    pub bounds: Rectangle,
-
-    /// The color of the [`Text`], in __linear RGB_.
-    pub color: [f32; 4],
-
-    /// The size of the [`Text`].
-    pub size: f32,
-
-    /// The font of the [`Text`].
-    pub font: Font,
-
-    /// The horizontal alignment of the [`Text`].
-    pub horizontal_alignment: alignment::Horizontal,
-
-    /// The vertical alignment of the [`Text`].
-    pub vertical_alignment: alignment::Vertical,
-}
diff --git a/graphics/src/lib.rs b/graphics/src/lib.rs
index d39dd90c..91f50282 100644
--- a/graphics/src/lib.rs
+++ b/graphics/src/lib.rs
@@ -23,33 +23,31 @@
 #![cfg_attr(docsrs, feature(doc_cfg))]
 mod antialiasing;
 mod error;
-mod primitive;
 mod transformation;
 mod viewport;
 
 pub mod backend;
-pub mod font;
-pub mod gradient;
-pub mod image;
-pub mod layer;
-pub mod overlay;
+pub mod compositor;
+pub mod damage;
+pub mod primitive;
 pub mod renderer;
-pub mod triangle;
-pub mod widget;
-pub mod window;
+
+#[cfg(feature = "geometry")]
+pub mod geometry;
+
+#[cfg(feature = "image")]
+pub mod image;
 
 pub use antialiasing::Antialiasing;
 pub use backend::Backend;
+pub use compositor::Compositor;
 pub use error::Error;
-pub use gradient::Gradient;
-pub use layer::Layer;
 pub use primitive::Primitive;
 pub use renderer::Renderer;
 pub use transformation::Transformation;
 pub use viewport::Viewport;
-pub use window::compositor;
 
-pub use iced_native::alignment;
-pub use iced_native::{
-    Alignment, Background, Color, Font, Point, Rectangle, Size, Vector,
-};
+#[cfg(feature = "geometry")]
+pub use geometry::Geometry;
+
+pub use iced_core as core;
diff --git a/graphics/src/overlay.rs b/graphics/src/overlay.rs
deleted file mode 100644
index bc0ed744..00000000
--- a/graphics/src/overlay.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-//! Display interactive elements on top of other widgets.
-pub mod menu;
diff --git a/graphics/src/overlay/menu.rs b/graphics/src/overlay/menu.rs
deleted file mode 100644
index 8b489e5e..00000000
--- a/graphics/src/overlay/menu.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-//! Build and show dropdown menus.
-
-pub use iced_style::menu::{Appearance, StyleSheet};
diff --git a/graphics/src/primitive.rs b/graphics/src/primitive.rs
index cef422a2..d4446c87 100644
--- a/graphics/src/primitive.rs
+++ b/graphics/src/primitive.rs
@@ -1,24 +1,17 @@
-use iced_native::image;
-use iced_native::svg;
-use iced_native::{Background, Color, Font, Rectangle, Size, Vector};
-
-use crate::alignment;
-use crate::gradient::Gradient;
-use crate::triangle;
+//! Draw using different graphical primitives.
+use crate::core::alignment;
+use crate::core::image;
+use crate::core::svg;
+use crate::core::text;
+use crate::core::{Background, Color, Font, Gradient, Rectangle, Size, Vector};
 
+use bytemuck::{Pod, Zeroable};
 use std::sync::Arc;
 
 /// A rendering primitive.
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, PartialEq)]
+#[non_exhaustive]
 pub enum Primitive {
-    /// An empty primitive
-    #[default]
-    None,
-    /// A group of primitives
-    Group {
-        /// The primitives of the group
-        primitives: Vec<Primitive>,
-    },
     /// A text primitive
     Text {
         /// The contents of the text
@@ -27,14 +20,18 @@ pub enum Primitive {
         bounds: Rectangle,
         /// The color of the text
         color: Color,
-        /// The size of the text
+        /// The size of the text in logical pixels
         size: f32,
+        /// The line height of the text
+        line_height: text::LineHeight,
         /// The font of the text
         font: Font,
         /// The horizontal alignment of the text
         horizontal_alignment: alignment::Horizontal,
         /// The vertical alignment of the text
         vertical_alignment: alignment::Vertical,
+        /// The shaping strategy of the text.
+        shaping: text::Shaping,
     },
     /// A quad primitive
     Quad {
@@ -67,27 +64,12 @@ pub enum Primitive {
         /// The bounds of the viewport
         bounds: Rectangle,
     },
-    /// A clip primitive
-    Clip {
-        /// The bounds of the clip
-        bounds: Rectangle,
-        /// The content of the clip
-        content: Box<Primitive>,
-    },
-    /// A primitive that applies a translation
-    Translate {
-        /// The translation vector
-        translation: Vector,
-
-        /// The primitive to translate
-        content: Box<Primitive>,
-    },
     /// A low-level primitive to render a mesh of triangles with a solid color.
     ///
     /// It can be used to render many kinds of geometry freely.
     SolidMesh {
         /// The vertices and indices of the mesh.
-        buffers: triangle::Mesh2D<triangle::ColoredVertex2D>,
+        buffers: Mesh2D<ColoredVertex2D>,
 
         /// The size of the drawable region of the mesh.
         ///
@@ -99,7 +81,7 @@ pub enum Primitive {
     /// It can be used to render many kinds of geometry freely.
     GradientMesh {
         /// The vertices and indices of the mesh.
-        buffers: triangle::Mesh2D<triangle::Vertex2D>,
+        buffers: Mesh2D<Vertex2D>,
 
         /// The size of the drawable region of the mesh.
         ///
@@ -109,12 +91,178 @@ pub enum Primitive {
         /// The [`Gradient`] to apply to the mesh.
         gradient: Gradient,
     },
+    /// A [`tiny_skia`] path filled with some paint.
+    #[cfg(feature = "tiny-skia")]
+    Fill {
+        /// The path to fill.
+        path: tiny_skia::Path,
+        /// The paint to use.
+        paint: tiny_skia::Paint<'static>,
+        /// The fill rule to follow.
+        rule: tiny_skia::FillRule,
+        /// The transform to apply to the path.
+        transform: tiny_skia::Transform,
+    },
+    /// A [`tiny_skia`] path stroked with some paint.
+    #[cfg(feature = "tiny-skia")]
+    Stroke {
+        /// The path to stroke.
+        path: tiny_skia::Path,
+        /// The paint to use.
+        paint: tiny_skia::Paint<'static>,
+        /// The stroke settings.
+        stroke: tiny_skia::Stroke,
+        /// The transform to apply to the path.
+        transform: tiny_skia::Transform,
+    },
+    /// A group of primitives
+    Group {
+        /// The primitives of the group
+        primitives: Vec<Primitive>,
+    },
+    /// A clip primitive
+    Clip {
+        /// The bounds of the clip
+        bounds: Rectangle,
+        /// The content of the clip
+        content: Box<Primitive>,
+    },
+    /// A primitive that applies a translation
+    Translate {
+        /// The translation vector
+        translation: Vector,
+
+        /// The primitive to translate
+        content: Box<Primitive>,
+    },
     /// A cached primitive.
     ///
     /// This can be useful if you are implementing a widget where primitive
     /// generation is expensive.
-    Cached {
+    Cache {
         /// The cached primitive
-        cache: Arc<Primitive>,
+        content: Arc<Primitive>,
     },
 }
+
+impl Primitive {
+    /// Creates a [`Primitive::Group`].
+    pub fn group(primitives: Vec<Self>) -> Self {
+        Self::Group { primitives }
+    }
+
+    /// Creates a [`Primitive::Clip`].
+    pub fn clip(self, bounds: Rectangle) -> Self {
+        Self::Clip {
+            bounds,
+            content: Box::new(self),
+        }
+    }
+
+    /// Creates a [`Primitive::Translate`].
+    pub fn translate(self, translation: Vector) -> Self {
+        Self::Translate {
+            translation,
+            content: Box::new(self),
+        }
+    }
+
+    /// Returns the bounds of the [`Primitive`].
+    pub fn bounds(&self) -> Rectangle {
+        match self {
+            Self::Text {
+                bounds,
+                horizontal_alignment,
+                vertical_alignment,
+                ..
+            } => {
+                let mut bounds = *bounds;
+
+                bounds.x = match horizontal_alignment {
+                    alignment::Horizontal::Left => bounds.x,
+                    alignment::Horizontal::Center => {
+                        bounds.x - bounds.width / 2.0
+                    }
+                    alignment::Horizontal::Right => bounds.x - bounds.width,
+                };
+
+                bounds.y = match vertical_alignment {
+                    alignment::Vertical::Top => bounds.y,
+                    alignment::Vertical::Center => {
+                        bounds.y - bounds.height / 2.0
+                    }
+                    alignment::Vertical::Bottom => bounds.y - bounds.height,
+                };
+
+                bounds.expand(1.5)
+            }
+            Self::Quad { bounds, .. }
+            | Self::Image { bounds, .. }
+            | Self::Svg { bounds, .. } => bounds.expand(1.0),
+            Self::Clip { bounds, .. } => bounds.expand(1.0),
+            Self::SolidMesh { size, .. } | Self::GradientMesh { size, .. } => {
+                Rectangle::with_size(*size)
+            }
+            #[cfg(feature = "tiny-skia")]
+            Self::Fill { path, .. } | Self::Stroke { path, .. } => {
+                let bounds = path.bounds();
+
+                Rectangle {
+                    x: bounds.x(),
+                    y: bounds.y(),
+                    width: bounds.width(),
+                    height: bounds.height(),
+                }
+                .expand(1.0)
+            }
+            Self::Group { primitives } => primitives
+                .iter()
+                .map(Self::bounds)
+                .fold(Rectangle::with_size(Size::ZERO), |a, b| {
+                    Rectangle::union(&a, &b)
+                }),
+            Self::Translate {
+                translation,
+                content,
+            } => content.bounds() + *translation,
+            Self::Cache { content } => content.bounds(),
+        }
+    }
+}
+
+/// A set of [`Vertex2D`] and indices representing a list of triangles.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Mesh2D<T> {
+    /// The vertices of the mesh
+    pub vertices: Vec<T>,
+
+    /// The list of vertex indices that defines the triangles of the mesh.
+    ///
+    /// Therefore, this list should always have a length that is a multiple of 3.
+    pub indices: Vec<u32>,
+}
+
+/// A two-dimensional vertex.
+#[derive(Copy, Clone, Debug, PartialEq, Zeroable, Pod)]
+#[repr(C)]
+pub struct Vertex2D {
+    /// The vertex position in 2D space.
+    pub position: [f32; 2],
+}
+
+/// A two-dimensional vertex with a color.
+#[derive(Copy, Clone, Debug, PartialEq, Zeroable, Pod)]
+#[repr(C)]
+pub struct ColoredVertex2D {
+    /// The vertex position in 2D space.
+    pub position: [f32; 2],
+
+    /// The color of the vertex in __linear__ RGBA.
+    pub color: [f32; 4],
+}
+
+impl From<()> for Primitive {
+    fn from(_: ()) -> Self {
+        Self::Group { primitives: vec![] }
+    }
+}
diff --git a/graphics/src/renderer.rs b/graphics/src/renderer.rs
index 34b6eb1d..de905503 100644
--- a/graphics/src/renderer.rs
+++ b/graphics/src/renderer.rs
@@ -1,15 +1,17 @@
 //! Create a renderer from a [`Backend`].
 use crate::backend::{self, Backend};
-use crate::{Primitive, Vector};
-use iced_native::image;
-use iced_native::layout;
-use iced_native::renderer;
-use iced_native::svg;
-use iced_native::text::{self, Text};
-use iced_native::{Background, Color, Element, Font, Point, Rectangle, Size};
-
-pub use iced_native::renderer::Style;
-
+use crate::Primitive;
+
+use iced_core::image;
+use iced_core::layout;
+use iced_core::renderer;
+use iced_core::svg;
+use iced_core::text::{self, Text};
+use iced_core::{
+    Background, Color, Element, Font, Point, Rectangle, Size, Vector,
+};
+
+use std::borrow::Cow;
 use std::marker::PhantomData;
 
 /// A backend-agnostic renderer that supports all the built-in widgets.
@@ -30,7 +32,7 @@ impl<B: Backend, T> Renderer<B, T> {
         }
     }
 
-    /// Returns the [`Backend`] of the [`Renderer`].
+    /// Returns a reference to the [`Backend`] of the [`Renderer`].
     pub fn backend(&self) -> &B {
         &self.backend
     }
@@ -42,12 +44,15 @@ impl<B: Backend, T> Renderer<B, T> {
 
     /// Runs the given closure with the [`Backend`] and the recorded primitives
     /// of the [`Renderer`].
-    pub fn with_primitives(&mut self, f: impl FnOnce(&mut B, &[Primitive])) {
-        f(&mut self.backend, &self.primitives);
+    pub fn with_primitives<O>(
+        &mut self,
+        f: impl FnOnce(&mut B, &[Primitive]) -> O,
+    ) -> O {
+        f(&mut self.backend, &self.primitives)
     }
 }
 
-impl<B, T> iced_native::Renderer for Renderer<B, T>
+impl<B, T> iced_core::Renderer for Renderer<B, T>
 where
     B: Backend,
 {
@@ -66,19 +71,13 @@ where
     }
 
     fn with_layer(&mut self, bounds: Rectangle, f: impl FnOnce(&mut Self)) {
-        let current_primitives = std::mem::take(&mut self.primitives);
+        let current = std::mem::take(&mut self.primitives);
 
         f(self);
 
-        let layer_primitives =
-            std::mem::replace(&mut self.primitives, current_primitives);
+        let layer = std::mem::replace(&mut self.primitives, current);
 
-        self.primitives.push(Primitive::Clip {
-            bounds,
-            content: Box::new(Primitive::Group {
-                primitives: layer_primitives,
-            }),
-        });
+        self.primitives.push(Primitive::group(layer).clip(bounds));
     }
 
     fn with_translation(
@@ -86,19 +85,14 @@ where
         translation: Vector,
         f: impl FnOnce(&mut Self),
     ) {
-        let current_primitives = std::mem::take(&mut self.primitives);
+        let current = std::mem::take(&mut self.primitives);
 
         f(self);
 
-        let layer_primitives =
-            std::mem::replace(&mut self.primitives, current_primitives);
+        let layer = std::mem::replace(&mut self.primitives, current);
 
-        self.primitives.push(Primitive::Translate {
-            translation,
-            content: Box::new(Primitive::Group {
-                primitives: layer_primitives,
-            }),
-        });
+        self.primitives
+            .push(Primitive::group(layer).translate(translation));
     }
 
     fn fill_quad(
@@ -130,6 +124,10 @@ where
     const CHECKMARK_ICON: char = B::CHECKMARK_ICON;
     const ARROW_DOWN_ICON: char = B::ARROW_DOWN_ICON;
 
+    fn default_font(&self) -> Self::Font {
+        self.backend().default_font()
+    }
+
     fn default_size(&self) -> f32 {
         self.backend().default_size()
     }
@@ -138,40 +136,59 @@ where
         &self,
         content: &str,
         size: f32,
+        line_height: text::LineHeight,
         font: Font,
         bounds: Size,
+        shaping: text::Shaping,
     ) -> (f32, f32) {
-        self.backend().measure(content, size, font, bounds)
+        self.backend().measure(
+            content,
+            size,
+            line_height,
+            font,
+            bounds,
+            shaping,
+        )
     }
 
     fn hit_test(
         &self,
         content: &str,
         size: f32,
+        line_height: text::LineHeight,
         font: Font,
         bounds: Size,
+        shaping: text::Shaping,
         point: Point,
         nearest_only: bool,
     ) -> Option<text::Hit> {
         self.backend().hit_test(
             content,
             size,
+            line_height,
             font,
             bounds,
+            shaping,
             point,
             nearest_only,
         )
     }
 
+    fn load_font(&mut self, bytes: Cow<'static, [u8]>) {
+        self.backend.load_font(bytes);
+    }
+
     fn fill_text(&mut self, text: Text<'_, Self::Font>) {
         self.primitives.push(Primitive::Text {
             content: text.content.to_string(),
             bounds: text.bounds,
             size: text.size,
+            line_height: text.line_height,
             color: text.color,
             font: text.font,
             horizontal_alignment: text.horizontal_alignment,
             vertical_alignment: text.vertical_alignment,
+            shaping: text.shaping,
         });
     }
 }
@@ -187,7 +204,7 @@ where
     }
 
     fn draw(&mut self, handle: image::Handle, bounds: Rectangle) {
-        self.draw_primitive(Primitive::Image { handle, bounds })
+        self.primitives.push(Primitive::Image { handle, bounds })
     }
 }
 
@@ -205,10 +222,21 @@ where
         color: Option<Color>,
         bounds: Rectangle,
     ) {
-        self.draw_primitive(Primitive::Svg {
+        self.primitives.push(Primitive::Svg {
             handle,
             color,
             bounds,
         })
     }
 }
+
+#[cfg(feature = "geometry")]
+impl<B, T> crate::geometry::Renderer for Renderer<B, T>
+where
+    B: Backend,
+{
+    fn draw(&mut self, layers: Vec<crate::Geometry>) {
+        self.primitives
+            .extend(layers.into_iter().map(crate::Geometry::into));
+    }
+}
diff --git a/graphics/src/triangle.rs b/graphics/src/triangle.rs
index f52b2339..09b61767 100644
--- a/graphics/src/triangle.rs
+++ b/graphics/src/triangle.rs
@@ -1,33 +1 @@
 //! Draw geometry using meshes of triangles.
-use bytemuck::{Pod, Zeroable};
-
-/// A set of [`Vertex2D`] and indices representing a list of triangles.
-#[derive(Clone, Debug)]
-pub struct Mesh2D<T> {
-    /// The vertices of the mesh
-    pub vertices: Vec<T>,
-
-    /// The list of vertex indices that defines the triangles of the mesh.
-    ///
-    /// Therefore, this list should always have a length that is a multiple of 3.
-    pub indices: Vec<u32>,
-}
-
-/// A two-dimensional vertex.
-#[derive(Copy, Clone, Debug, Zeroable, Pod)]
-#[repr(C)]
-pub struct Vertex2D {
-    /// The vertex position in 2D space.
-    pub position: [f32; 2],
-}
-
-/// A two-dimensional vertex with a color.
-#[derive(Copy, Clone, Debug, Zeroable, Pod)]
-#[repr(C)]
-pub struct ColoredVertex2D {
-    /// The vertex position in 2D space.
-    pub position: [f32; 2],
-
-    /// The color of the vertex in __linear__ RGBA.
-    pub color: [f32; 4],
-}
diff --git a/graphics/src/viewport.rs b/graphics/src/viewport.rs
index 2c0b541a..5792555d 100644
--- a/graphics/src/viewport.rs
+++ b/graphics/src/viewport.rs
@@ -1,4 +1,6 @@
-use crate::{Size, Transformation};
+use crate::Transformation;
+
+use iced_core::Size;
 
 /// A viewing region for displaying computer graphics.
 #[derive(Debug, Clone)]
diff --git a/graphics/src/widget.rs b/graphics/src/widget.rs
deleted file mode 100644
index e7fab97c..00000000
--- a/graphics/src/widget.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//! Use the graphical widgets supported out-of-the-box.
-#[cfg(feature = "canvas")]
-#[cfg_attr(docsrs, doc(cfg(feature = "canvas")))]
-pub mod canvas;
-
-#[cfg(feature = "canvas")]
-#[doc(no_inline)]
-pub use canvas::Canvas;
-
-#[cfg(feature = "qr_code")]
-#[cfg_attr(docsrs, doc(cfg(feature = "qr_code")))]
-pub mod qr_code;
-
-#[cfg(feature = "qr_code")]
-#[doc(no_inline)]
-pub use qr_code::QRCode;
diff --git a/graphics/src/widget/canvas.rs b/graphics/src/widget/canvas.rs
deleted file mode 100644
index a8d050f5..00000000
--- a/graphics/src/widget/canvas.rs
+++ /dev/null
@@ -1,268 +0,0 @@
-//! Draw 2D graphics for your users.
-//!
-//! A [`Canvas`] widget can be used to draw different kinds of 2D shapes in a
-//! [`Frame`]. It can be used for animation, data visualization, game graphics,
-//! and more!
-pub mod event;
-pub mod fill;
-pub mod path;
-pub mod stroke;
-
-mod cache;
-mod cursor;
-mod frame;
-mod geometry;
-mod program;
-mod style;
-mod text;
-
-pub use crate::gradient::{self, Gradient};
-pub use cache::Cache;
-pub use cursor::Cursor;
-pub use event::Event;
-pub use fill::{Fill, FillRule};
-pub use frame::Frame;
-pub use geometry::Geometry;
-pub use path::Path;
-pub use program::Program;
-pub use stroke::{LineCap, LineDash, LineJoin, Stroke};
-pub use style::Style;
-pub use text::Text;
-
-use crate::{Backend, Primitive, Renderer};
-
-use iced_native::layout::{self, Layout};
-use iced_native::mouse;
-use iced_native::renderer;
-use iced_native::widget::tree::{self, Tree};
-use iced_native::{
-    Clipboard, Element, Length, Point, Rectangle, Shell, Size, Vector, Widget,
-};
-
-use std::marker::PhantomData;
-
-/// A widget capable of drawing 2D graphics.
-///
-/// ## Drawing a simple circle
-/// If you want to get a quick overview, here's how we can draw a simple circle:
-///
-/// ```no_run
-/// # mod iced {
-/// #     pub mod widget {
-/// #         pub use iced_graphics::widget::canvas;
-/// #     }
-/// #     pub use iced_native::{Color, Rectangle, Theme};
-/// # }
-/// use iced::widget::canvas::{self, Canvas, Cursor, Fill, Frame, Geometry, Path, Program};
-/// use iced::{Color, Rectangle, Theme};
-///
-/// // First, we define the data we need for drawing
-/// #[derive(Debug)]
-/// struct Circle {
-///     radius: f32,
-/// }
-///
-/// // Then, we implement the `Program` trait
-/// impl Program<()> for Circle {
-///     type State = ();
-///
-///     fn draw(&self, _state: &(), _theme: &Theme, bounds: Rectangle, _cursor: Cursor) -> Vec<Geometry>{
-///         // We prepare a new `Frame`
-///         let mut frame = Frame::new(bounds.size());
-///
-///         // We create a `Path` representing a simple circle
-///         let circle = Path::circle(frame.center(), self.radius);
-///
-///         // And fill it with some color
-///         frame.fill(&circle, Color::BLACK);
-///
-///         // Finally, we produce the geometry
-///         vec![frame.into_geometry()]
-///     }
-/// }
-///
-/// // Finally, we simply use our `Circle` to create the `Canvas`!
-/// let canvas = Canvas::new(Circle { radius: 50.0 });
-/// ```
-#[derive(Debug)]
-pub struct Canvas<Message, Theme, P>
-where
-    P: Program<Message, Theme>,
-{
-    width: Length,
-    height: Length,
-    program: P,
-    message_: PhantomData<Message>,
-    theme_: PhantomData<Theme>,
-}
-
-impl<Message, Theme, P> Canvas<Message, Theme, P>
-where
-    P: Program<Message, Theme>,
-{
-    const DEFAULT_SIZE: f32 = 100.0;
-
-    /// Creates a new [`Canvas`].
-    pub fn new(program: P) -> Self {
-        Canvas {
-            width: Length::Fixed(Self::DEFAULT_SIZE),
-            height: Length::Fixed(Self::DEFAULT_SIZE),
-            program,
-            message_: PhantomData,
-            theme_: PhantomData,
-        }
-    }
-
-    /// Sets the width of the [`Canvas`].
-    pub fn width(mut self, width: impl Into<Length>) -> Self {
-        self.width = width.into();
-        self
-    }
-
-    /// Sets the height of the [`Canvas`].
-    pub fn height(mut self, height: impl Into<Length>) -> Self {
-        self.height = height.into();
-        self
-    }
-}
-
-impl<Message, P, B, T> Widget<Message, Renderer<B, T>> for Canvas<Message, T, P>
-where
-    P: Program<Message, T>,
-    B: Backend,
-{
-    fn tag(&self) -> tree::Tag {
-        struct Tag<T>(T);
-        tree::Tag::of::<Tag<P::State>>()
-    }
-
-    fn state(&self) -> tree::State {
-        tree::State::new(P::State::default())
-    }
-
-    fn width(&self) -> Length {
-        self.width
-    }
-
-    fn height(&self) -> Length {
-        self.height
-    }
-
-    fn layout(
-        &self,
-        _renderer: &Renderer<B, T>,
-        limits: &layout::Limits,
-    ) -> layout::Node {
-        let limits = limits.width(self.width).height(self.height);
-        let size = limits.resolve(Size::ZERO);
-
-        layout::Node::new(size)
-    }
-
-    fn on_event(
-        &mut self,
-        tree: &mut Tree,
-        event: iced_native::Event,
-        layout: Layout<'_>,
-        cursor_position: Point,
-        _renderer: &Renderer<B, T>,
-        _clipboard: &mut dyn Clipboard,
-        shell: &mut Shell<'_, Message>,
-    ) -> event::Status {
-        let bounds = layout.bounds();
-
-        let canvas_event = match event {
-            iced_native::Event::Mouse(mouse_event) => {
-                Some(Event::Mouse(mouse_event))
-            }
-            iced_native::Event::Touch(touch_event) => {
-                Some(Event::Touch(touch_event))
-            }
-            iced_native::Event::Keyboard(keyboard_event) => {
-                Some(Event::Keyboard(keyboard_event))
-            }
-            _ => None,
-        };
-
-        let cursor = Cursor::from_window_position(cursor_position);
-
-        if let Some(canvas_event) = canvas_event {
-            let state = tree.state.downcast_mut::<P::State>();
-
-            let (event_status, message) =
-                self.program.update(state, canvas_event, bounds, cursor);
-
-            if let Some(message) = message {
-                shell.publish(message);
-            }
-
-            return event_status;
-        }
-
-        event::Status::Ignored
-    }
-
-    fn mouse_interaction(
-        &self,
-        tree: &Tree,
-        layout: Layout<'_>,
-        cursor_position: Point,
-        _viewport: &Rectangle,
-        _renderer: &Renderer<B, T>,
-    ) -> mouse::Interaction {
-        let bounds = layout.bounds();
-        let cursor = Cursor::from_window_position(cursor_position);
-        let state = tree.state.downcast_ref::<P::State>();
-
-        self.program.mouse_interaction(state, bounds, cursor)
-    }
-
-    fn draw(
-        &self,
-        tree: &Tree,
-        renderer: &mut Renderer<B, T>,
-        theme: &T,
-        _style: &renderer::Style,
-        layout: Layout<'_>,
-        cursor_position: Point,
-        _viewport: &Rectangle,
-    ) {
-        use iced_native::Renderer as _;
-
-        let bounds = layout.bounds();
-
-        if bounds.width < 1.0 || bounds.height < 1.0 {
-            return;
-        }
-
-        let translation = Vector::new(bounds.x, bounds.y);
-        let cursor = Cursor::from_window_position(cursor_position);
-        let state = tree.state.downcast_ref::<P::State>();
-
-        renderer.with_translation(translation, |renderer| {
-            renderer.draw_primitive(Primitive::Group {
-                primitives: self
-                    .program
-                    .draw(state, theme, bounds, cursor)
-                    .into_iter()
-                    .map(Geometry::into_primitive)
-                    .collect(),
-            });
-        });
-    }
-}
-
-impl<'a, Message, P, B, T> From<Canvas<Message, T, P>>
-    for Element<'a, Message, Renderer<B, T>>
-where
-    Message: 'a,
-    P: Program<Message, T> + 'a,
-    B: Backend,
-    T: 'a,
-{
-    fn from(
-        canvas: Canvas<Message, T, P>,
-    ) -> Element<'a, Message, Renderer<B, T>> {
-        Element::new(canvas)
-    }
-}
diff --git a/graphics/src/widget/canvas/cache.rs b/graphics/src/widget/canvas/cache.rs
deleted file mode 100644
index 678b0f92..00000000
--- a/graphics/src/widget/canvas/cache.rs
+++ /dev/null
@@ -1,97 +0,0 @@
-use crate::widget::canvas::{Frame, Geometry};
-use crate::Primitive;
-
-use iced_native::Size;
-use std::{cell::RefCell, sync::Arc};
-
-#[derive(Default)]
-enum State {
-    #[default]
-    Empty,
-    Filled {
-        bounds: Size,
-        primitive: Arc<Primitive>,
-    },
-}
-
-/// A simple cache that stores generated [`Geometry`] to avoid recomputation.
-///
-/// A [`Cache`] will not redraw its geometry unless the dimensions of its layer
-/// change or it is explicitly cleared.
-#[derive(Debug, Default)]
-pub struct Cache {
-    state: RefCell<State>,
-}
-
-impl Cache {
-    /// Creates a new empty [`Cache`].
-    pub fn new() -> Self {
-        Cache {
-            state: Default::default(),
-        }
-    }
-
-    /// Clears the [`Cache`], forcing a redraw the next time it is used.
-    pub fn clear(&self) {
-        *self.state.borrow_mut() = State::Empty;
-    }
-
-    /// Draws [`Geometry`] using the provided closure and stores it in the
-    /// [`Cache`].
-    ///
-    /// The closure will only be called when
-    /// - the bounds have changed since the previous draw call.
-    /// - the [`Cache`] is empty or has been explicitly cleared.
-    ///
-    /// Otherwise, the previously stored [`Geometry`] will be returned. The
-    /// [`Cache`] is not cleared in this case. In other words, it will keep
-    /// returning the stored [`Geometry`] if needed.
-    pub fn draw(
-        &self,
-        bounds: Size,
-        draw_fn: impl FnOnce(&mut Frame),
-    ) -> Geometry {
-        use std::ops::Deref;
-
-        if let State::Filled {
-            bounds: cached_bounds,
-            primitive,
-        } = self.state.borrow().deref()
-        {
-            if *cached_bounds == bounds {
-                return Geometry::from_primitive(Primitive::Cached {
-                    cache: primitive.clone(),
-                });
-            }
-        }
-
-        let mut frame = Frame::new(bounds);
-        draw_fn(&mut frame);
-
-        let primitive = {
-            let geometry = frame.into_geometry();
-
-            Arc::new(geometry.into_primitive())
-        };
-
-        *self.state.borrow_mut() = State::Filled {
-            bounds,
-            primitive: primitive.clone(),
-        };
-
-        Geometry::from_primitive(Primitive::Cached { cache: primitive })
-    }
-}
-
-impl std::fmt::Debug for State {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            State::Empty => write!(f, "Empty"),
-            State::Filled { primitive, bounds } => f
-                .debug_struct("Filled")
-                .field("primitive", primitive)
-                .field("bounds", bounds)
-                .finish(),
-        }
-    }
-}
diff --git a/graphics/src/widget/canvas/cursor.rs b/graphics/src/widget/canvas/cursor.rs
deleted file mode 100644
index 9588d129..00000000
--- a/graphics/src/widget/canvas/cursor.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-use iced_native::{Point, Rectangle};
-
-/// The mouse cursor state.
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum Cursor {
-    /// The cursor has a defined position.
-    Available(Point),
-
-    /// The cursor is currently unavailable (i.e. out of bounds or busy).
-    Unavailable,
-}
-
-impl Cursor {
-    // TODO: Remove this once this type is used in `iced_native` to encode
-    // proper cursor availability
-    pub(crate) fn from_window_position(position: Point) -> Self {
-        if position.x < 0.0 || position.y < 0.0 {
-            Cursor::Unavailable
-        } else {
-            Cursor::Available(position)
-        }
-    }
-
-    /// Returns the absolute position of the [`Cursor`], if available.
-    pub fn position(&self) -> Option<Point> {
-        match self {
-            Cursor::Available(position) => Some(*position),
-            Cursor::Unavailable => None,
-        }
-    }
-
-    /// Returns the relative position of the [`Cursor`] inside the given bounds,
-    /// if available.
-    ///
-    /// If the [`Cursor`] is not over the provided bounds, this method will
-    /// return `None`.
-    pub fn position_in(&self, bounds: &Rectangle) -> Option<Point> {
-        if self.is_over(bounds) {
-            self.position_from(bounds.position())
-        } else {
-            None
-        }
-    }
-
-    /// Returns the relative position of the [`Cursor`] from the given origin,
-    /// if available.
-    pub fn position_from(&self, origin: Point) -> Option<Point> {
-        match self {
-            Cursor::Available(position) => {
-                Some(Point::new(position.x - origin.x, position.y - origin.y))
-            }
-            Cursor::Unavailable => None,
-        }
-    }
-
-    /// Returns whether the [`Cursor`] is currently over the provided bounds
-    /// or not.
-    pub fn is_over(&self, bounds: &Rectangle) -> bool {
-        match self {
-            Cursor::Available(position) => bounds.contains(*position),
-            Cursor::Unavailable => false,
-        }
-    }
-}
diff --git a/graphics/src/widget/canvas/event.rs b/graphics/src/widget/canvas/event.rs
deleted file mode 100644
index 7c733a4d..00000000
--- a/graphics/src/widget/canvas/event.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//! Handle events of a canvas.
-use iced_native::keyboard;
-use iced_native::mouse;
-use iced_native::touch;
-
-pub use iced_native::event::Status;
-
-/// A [`Canvas`] event.
-///
-/// [`Canvas`]: crate::widget::Canvas
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum Event {
-    /// A mouse event.
-    Mouse(mouse::Event),
-
-    /// A touch event.
-    Touch(touch::Event),
-
-    /// A keyboard event.
-    Keyboard(keyboard::Event),
-}
diff --git a/graphics/src/widget/canvas/frame.rs b/graphics/src/widget/canvas/frame.rs
deleted file mode 100644
index d68548ae..00000000
--- a/graphics/src/widget/canvas/frame.rs
+++ /dev/null
@@ -1,530 +0,0 @@
-use crate::gradient::Gradient;
-use crate::triangle;
-use crate::widget::canvas::{path, Fill, Geometry, Path, Stroke, Style, Text};
-use crate::Primitive;
-
-use iced_native::{Point, Rectangle, Size, Vector};
-
-use lyon::geom::euclid;
-use lyon::tessellation;
-use std::borrow::Cow;
-
-/// The frame of a [`Canvas`].
-///
-/// [`Canvas`]: crate::widget::Canvas
-#[allow(missing_debug_implementations)]
-pub struct Frame {
-    size: Size,
-    buffers: BufferStack,
-    primitives: Vec<Primitive>,
-    transforms: Transforms,
-    fill_tessellator: tessellation::FillTessellator,
-    stroke_tessellator: tessellation::StrokeTessellator,
-}
-
-enum Buffer {
-    Solid(tessellation::VertexBuffers<triangle::ColoredVertex2D, u32>),
-    Gradient(
-        tessellation::VertexBuffers<triangle::Vertex2D, u32>,
-        Gradient,
-    ),
-}
-
-struct BufferStack {
-    stack: Vec<Buffer>,
-}
-
-impl BufferStack {
-    fn new() -> Self {
-        Self { stack: Vec::new() }
-    }
-
-    fn get_mut(&mut self, style: &Style) -> &mut Buffer {
-        match style {
-            Style::Solid(_) => match self.stack.last() {
-                Some(Buffer::Solid(_)) => {}
-                _ => {
-                    self.stack.push(Buffer::Solid(
-                        tessellation::VertexBuffers::new(),
-                    ));
-                }
-            },
-            Style::Gradient(gradient) => match self.stack.last() {
-                Some(Buffer::Gradient(_, last)) if gradient == last => {}
-                _ => {
-                    self.stack.push(Buffer::Gradient(
-                        tessellation::VertexBuffers::new(),
-                        gradient.clone(),
-                    ));
-                }
-            },
-        }
-
-        self.stack.last_mut().unwrap()
-    }
-
-    fn get_fill<'a>(
-        &'a mut self,
-        style: &Style,
-    ) -> Box<dyn tessellation::FillGeometryBuilder + 'a> {
-        match (style, self.get_mut(style)) {
-            (Style::Solid(color), Buffer::Solid(buffer)) => {
-                Box::new(tessellation::BuffersBuilder::new(
-                    buffer,
-                    TriangleVertex2DBuilder(color.into_linear()),
-                ))
-            }
-            (Style::Gradient(_), Buffer::Gradient(buffer, _)) => Box::new(
-                tessellation::BuffersBuilder::new(buffer, Vertex2DBuilder),
-            ),
-            _ => unreachable!(),
-        }
-    }
-
-    fn get_stroke<'a>(
-        &'a mut self,
-        style: &Style,
-    ) -> Box<dyn tessellation::StrokeGeometryBuilder + 'a> {
-        match (style, self.get_mut(style)) {
-            (Style::Solid(color), Buffer::Solid(buffer)) => {
-                Box::new(tessellation::BuffersBuilder::new(
-                    buffer,
-                    TriangleVertex2DBuilder(color.into_linear()),
-                ))
-            }
-            (Style::Gradient(_), Buffer::Gradient(buffer, _)) => Box::new(
-                tessellation::BuffersBuilder::new(buffer, Vertex2DBuilder),
-            ),
-            _ => unreachable!(),
-        }
-    }
-}
-
-#[derive(Debug)]
-struct Transforms {
-    previous: Vec<Transform>,
-    current: Transform,
-}
-
-#[derive(Debug, Clone, Copy)]
-struct Transform {
-    raw: lyon::math::Transform,
-    is_identity: bool,
-}
-
-impl Transform {
-    /// Transforms the given [Point] by the transformation matrix.
-    fn transform_point(&self, point: &mut Point) {
-        let transformed = self
-            .raw
-            .transform_point(euclid::Point2D::new(point.x, point.y));
-        point.x = transformed.x;
-        point.y = transformed.y;
-    }
-
-    fn transform_style(&self, style: Style) -> Style {
-        match style {
-            Style::Solid(color) => Style::Solid(color),
-            Style::Gradient(gradient) => {
-                Style::Gradient(self.transform_gradient(gradient))
-            }
-        }
-    }
-
-    fn transform_gradient(&self, mut gradient: Gradient) -> Gradient {
-        let (start, end) = match &mut gradient {
-            Gradient::Linear(linear) => (&mut linear.start, &mut linear.end),
-        };
-        self.transform_point(start);
-        self.transform_point(end);
-        gradient
-    }
-}
-
-impl Frame {
-    /// Creates a new empty [`Frame`] with the given dimensions.
-    ///
-    /// The default coordinate system of a [`Frame`] has its origin at the
-    /// top-left corner of its bounds.
-    pub fn new(size: Size) -> Frame {
-        Frame {
-            size,
-            buffers: BufferStack::new(),
-            primitives: Vec::new(),
-            transforms: Transforms {
-                previous: Vec::new(),
-                current: Transform {
-                    raw: lyon::math::Transform::identity(),
-                    is_identity: true,
-                },
-            },
-            fill_tessellator: tessellation::FillTessellator::new(),
-            stroke_tessellator: tessellation::StrokeTessellator::new(),
-        }
-    }
-
-    /// Returns the width of the [`Frame`].
-    #[inline]
-    pub fn width(&self) -> f32 {
-        self.size.width
-    }
-
-    /// Returns the height of the [`Frame`].
-    #[inline]
-    pub fn height(&self) -> f32 {
-        self.size.height
-    }
-
-    /// Returns the dimensions of the [`Frame`].
-    #[inline]
-    pub fn size(&self) -> Size {
-        self.size
-    }
-
-    /// Returns the coordinate of the center of the [`Frame`].
-    #[inline]
-    pub fn center(&self) -> Point {
-        Point::new(self.size.width / 2.0, self.size.height / 2.0)
-    }
-
-    /// Draws the given [`Path`] on the [`Frame`] by filling it with the
-    /// provided style.
-    pub fn fill(&mut self, path: &Path, fill: impl Into<Fill>) {
-        let Fill { style, rule } = fill.into();
-
-        let mut buffer = self
-            .buffers
-            .get_fill(&self.transforms.current.transform_style(style));
-
-        let options =
-            tessellation::FillOptions::default().with_fill_rule(rule.into());
-
-        if self.transforms.current.is_identity {
-            self.fill_tessellator.tessellate_path(
-                path.raw(),
-                &options,
-                buffer.as_mut(),
-            )
-        } else {
-            let path = path.transformed(&self.transforms.current.raw);
-
-            self.fill_tessellator.tessellate_path(
-                path.raw(),
-                &options,
-                buffer.as_mut(),
-            )
-        }
-        .expect("Tessellate path.");
-    }
-
-    /// Draws an axis-aligned rectangle given its top-left corner coordinate and
-    /// its `Size` on the [`Frame`] by filling it with the provided style.
-    pub fn fill_rectangle(
-        &mut self,
-        top_left: Point,
-        size: Size,
-        fill: impl Into<Fill>,
-    ) {
-        let Fill { style, rule } = fill.into();
-
-        let mut buffer = self
-            .buffers
-            .get_fill(&self.transforms.current.transform_style(style));
-
-        let top_left =
-            self.transforms.current.raw.transform_point(
-                lyon::math::Point::new(top_left.x, top_left.y),
-            );
-
-        let size =
-            self.transforms.current.raw.transform_vector(
-                lyon::math::Vector::new(size.width, size.height),
-            );
-
-        let options =
-            tessellation::FillOptions::default().with_fill_rule(rule.into());
-
-        self.fill_tessellator
-            .tessellate_rectangle(
-                &lyon::math::Box2D::new(top_left, top_left + size),
-                &options,
-                buffer.as_mut(),
-            )
-            .expect("Fill rectangle");
-    }
-
-    /// Draws the stroke of the given [`Path`] on the [`Frame`] with the
-    /// provided style.
-    pub fn stroke<'a>(&mut self, path: &Path, stroke: impl Into<Stroke<'a>>) {
-        let stroke = stroke.into();
-
-        let mut buffer = self
-            .buffers
-            .get_stroke(&self.transforms.current.transform_style(stroke.style));
-
-        let mut options = tessellation::StrokeOptions::default();
-        options.line_width = stroke.width;
-        options.start_cap = stroke.line_cap.into();
-        options.end_cap = stroke.line_cap.into();
-        options.line_join = stroke.line_join.into();
-
-        let path = if stroke.line_dash.segments.is_empty() {
-            Cow::Borrowed(path)
-        } else {
-            Cow::Owned(path::dashed(path, stroke.line_dash))
-        };
-
-        if self.transforms.current.is_identity {
-            self.stroke_tessellator.tessellate_path(
-                path.raw(),
-                &options,
-                buffer.as_mut(),
-            )
-        } else {
-            let path = path.transformed(&self.transforms.current.raw);
-
-            self.stroke_tessellator.tessellate_path(
-                path.raw(),
-                &options,
-                buffer.as_mut(),
-            )
-        }
-        .expect("Stroke path");
-    }
-
-    /// Draws the characters of the given [`Text`] on the [`Frame`], filling
-    /// them with the given color.
-    ///
-    /// __Warning:__ Text currently does not work well with rotations and scale
-    /// transforms! The position will be correctly transformed, but the
-    /// resulting glyphs will not be rotated or scaled properly.
-    ///
-    /// Additionally, all text will be rendered on top of all the layers of
-    /// a [`Canvas`]. Therefore, it is currently only meant to be used for
-    /// overlays, which is the most common use case.
-    ///
-    /// Support for vectorial text is planned, and should address all these
-    /// limitations.
-    ///
-    /// [`Canvas`]: crate::widget::Canvas
-    pub fn fill_text(&mut self, text: impl Into<Text>) {
-        let text = text.into();
-
-        let position = if self.transforms.current.is_identity {
-            text.position
-        } else {
-            let transformed = self.transforms.current.raw.transform_point(
-                lyon::math::Point::new(text.position.x, text.position.y),
-            );
-
-            Point::new(transformed.x, transformed.y)
-        };
-
-        // TODO: Use vectorial text instead of primitive
-        self.primitives.push(Primitive::Text {
-            content: text.content,
-            bounds: Rectangle {
-                x: position.x,
-                y: position.y,
-                width: f32::INFINITY,
-                height: f32::INFINITY,
-            },
-            color: text.color,
-            size: text.size,
-            font: text.font,
-            horizontal_alignment: text.horizontal_alignment,
-            vertical_alignment: text.vertical_alignment,
-        });
-    }
-
-    /// Stores the current transform of the [`Frame`] and executes the given
-    /// drawing operations, restoring the transform afterwards.
-    ///
-    /// This method is useful to compose transforms and perform drawing
-    /// operations in different coordinate systems.
-    #[inline]
-    pub fn with_save(&mut self, f: impl FnOnce(&mut Frame)) {
-        self.transforms.previous.push(self.transforms.current);
-
-        f(self);
-
-        self.transforms.current = self.transforms.previous.pop().unwrap();
-    }
-
-    /// Executes the given drawing operations within a [`Rectangle`] region,
-    /// clipping any geometry that overflows its bounds. Any transformations
-    /// performed are local to the provided closure.
-    ///
-    /// This method is useful to perform drawing operations that need to be
-    /// clipped.
-    #[inline]
-    pub fn with_clip(&mut self, region: Rectangle, f: impl FnOnce(&mut Frame)) {
-        let mut frame = Frame::new(region.size());
-
-        f(&mut frame);
-
-        let primitives = frame.into_primitives();
-
-        let (text, meshes) = primitives
-            .into_iter()
-            .partition(|primitive| matches!(primitive, Primitive::Text { .. }));
-
-        let translation = Vector::new(region.x, region.y);
-
-        self.primitives.push(Primitive::Group {
-            primitives: vec![
-                Primitive::Translate {
-                    translation,
-                    content: Box::new(Primitive::Group { primitives: meshes }),
-                },
-                Primitive::Translate {
-                    translation,
-                    content: Box::new(Primitive::Clip {
-                        bounds: Rectangle::with_size(region.size()),
-                        content: Box::new(Primitive::Group {
-                            primitives: text,
-                        }),
-                    }),
-                },
-            ],
-        });
-    }
-
-    /// Applies a translation to the current transform of the [`Frame`].
-    #[inline]
-    pub fn translate(&mut self, translation: Vector) {
-        self.transforms.current.raw = self
-            .transforms
-            .current
-            .raw
-            .pre_translate(lyon::math::Vector::new(
-                translation.x,
-                translation.y,
-            ));
-        self.transforms.current.is_identity = false;
-    }
-
-    /// Applies a rotation in radians to the current transform of the [`Frame`].
-    #[inline]
-    pub fn rotate(&mut self, angle: f32) {
-        self.transforms.current.raw = self
-            .transforms
-            .current
-            .raw
-            .pre_rotate(lyon::math::Angle::radians(angle));
-        self.transforms.current.is_identity = false;
-    }
-
-    /// Applies a scaling to the current transform of the [`Frame`].
-    #[inline]
-    pub fn scale(&mut self, scale: f32) {
-        self.transforms.current.raw =
-            self.transforms.current.raw.pre_scale(scale, scale);
-        self.transforms.current.is_identity = false;
-    }
-
-    /// Produces the [`Geometry`] representing everything drawn on the [`Frame`].
-    pub fn into_geometry(self) -> Geometry {
-        Geometry::from_primitive(Primitive::Group {
-            primitives: self.into_primitives(),
-        })
-    }
-
-    fn into_primitives(mut self) -> Vec<Primitive> {
-        for buffer in self.buffers.stack {
-            match buffer {
-                Buffer::Solid(buffer) => {
-                    if !buffer.indices.is_empty() {
-                        self.primitives.push(Primitive::SolidMesh {
-                            buffers: triangle::Mesh2D {
-                                vertices: buffer.vertices,
-                                indices: buffer.indices,
-                            },
-                            size: self.size,
-                        })
-                    }
-                }
-                Buffer::Gradient(buffer, gradient) => {
-                    if !buffer.indices.is_empty() {
-                        self.primitives.push(Primitive::GradientMesh {
-                            buffers: triangle::Mesh2D {
-                                vertices: buffer.vertices,
-                                indices: buffer.indices,
-                            },
-                            size: self.size,
-                            gradient,
-                        })
-                    }
-                }
-            }
-        }
-
-        self.primitives
-    }
-}
-
-struct Vertex2DBuilder;
-
-impl tessellation::FillVertexConstructor<triangle::Vertex2D>
-    for Vertex2DBuilder
-{
-    fn new_vertex(
-        &mut self,
-        vertex: tessellation::FillVertex<'_>,
-    ) -> triangle::Vertex2D {
-        let position = vertex.position();
-
-        triangle::Vertex2D {
-            position: [position.x, position.y],
-        }
-    }
-}
-
-impl tessellation::StrokeVertexConstructor<triangle::Vertex2D>
-    for Vertex2DBuilder
-{
-    fn new_vertex(
-        &mut self,
-        vertex: tessellation::StrokeVertex<'_, '_>,
-    ) -> triangle::Vertex2D {
-        let position = vertex.position();
-
-        triangle::Vertex2D {
-            position: [position.x, position.y],
-        }
-    }
-}
-
-struct TriangleVertex2DBuilder([f32; 4]);
-
-impl tessellation::FillVertexConstructor<triangle::ColoredVertex2D>
-    for TriangleVertex2DBuilder
-{
-    fn new_vertex(
-        &mut self,
-        vertex: tessellation::FillVertex<'_>,
-    ) -> triangle::ColoredVertex2D {
-        let position = vertex.position();
-
-        triangle::ColoredVertex2D {
-            position: [position.x, position.y],
-            color: self.0,
-        }
-    }
-}
-
-impl tessellation::StrokeVertexConstructor<triangle::ColoredVertex2D>
-    for TriangleVertex2DBuilder
-{
-    fn new_vertex(
-        &mut self,
-        vertex: tessellation::StrokeVertex<'_, '_>,
-    ) -> triangle::ColoredVertex2D {
-        let position = vertex.position();
-
-        triangle::ColoredVertex2D {
-            position: [position.x, position.y],
-            color: self.0,
-        }
-    }
-}
diff --git a/graphics/src/widget/canvas/geometry.rs b/graphics/src/widget/canvas/geometry.rs
deleted file mode 100644
index e8ac621d..00000000
--- a/graphics/src/widget/canvas/geometry.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-use crate::Primitive;
-
-/// A bunch of shapes that can be drawn.
-///
-/// [`Geometry`] can be easily generated with a [`Frame`] or stored in a
-/// [`Cache`].
-///
-/// [`Frame`]: crate::widget::canvas::Frame
-/// [`Cache`]: crate::widget::canvas::Cache
-#[derive(Debug, Clone)]
-pub struct Geometry(Primitive);
-
-impl Geometry {
-    pub(crate) fn from_primitive(primitive: Primitive) -> Self {
-        Self(primitive)
-    }
-
-    /// Turns the [`Geometry`] into a [`Primitive`].
-    ///
-    /// This can be useful if you are building a custom widget.
-    pub fn into_primitive(self) -> Primitive {
-        self.0
-    }
-}
diff --git a/graphics/src/widget/canvas/program.rs b/graphics/src/widget/canvas/program.rs
deleted file mode 100644
index 656dbfa6..00000000
--- a/graphics/src/widget/canvas/program.rs
+++ /dev/null
@@ -1,102 +0,0 @@
-use crate::widget::canvas::event::{self, Event};
-use crate::widget::canvas::mouse;
-use crate::widget::canvas::{Cursor, Geometry};
-use crate::Rectangle;
-
-/// The state and logic of a [`Canvas`].
-///
-/// A [`Program`] can mutate internal state and produce messages for an
-/// application.
-///
-/// [`Canvas`]: crate::widget::Canvas
-pub trait Program<Message, Theme = iced_native::Theme> {
-    /// The internal state mutated by the [`Program`].
-    type State: Default + 'static;
-
-    /// Updates the [`State`](Self::State) of the [`Program`].
-    ///
-    /// When a [`Program`] is used in a [`Canvas`], the runtime will call this
-    /// method for each [`Event`].
-    ///
-    /// This method can optionally return a `Message` to notify an application
-    /// of any meaningful interactions.
-    ///
-    /// By default, this method does and returns nothing.
-    ///
-    /// [`Canvas`]: crate::widget::Canvas
-    fn update(
-        &self,
-        _state: &mut Self::State,
-        _event: Event,
-        _bounds: Rectangle,
-        _cursor: Cursor,
-    ) -> (event::Status, Option<Message>) {
-        (event::Status::Ignored, None)
-    }
-
-    /// Draws the state of the [`Program`], producing a bunch of [`Geometry`].
-    ///
-    /// [`Geometry`] can be easily generated with a [`Frame`] or stored in a
-    /// [`Cache`].
-    ///
-    /// [`Frame`]: crate::widget::canvas::Frame
-    /// [`Cache`]: crate::widget::canvas::Cache
-    fn draw(
-        &self,
-        state: &Self::State,
-        theme: &Theme,
-        bounds: Rectangle,
-        cursor: Cursor,
-    ) -> Vec<Geometry>;
-
-    /// Returns the current mouse interaction of the [`Program`].
-    ///
-    /// The interaction returned will be in effect even if the cursor position
-    /// is out of bounds of the program's [`Canvas`].
-    ///
-    /// [`Canvas`]: crate::widget::Canvas
-    fn mouse_interaction(
-        &self,
-        _state: &Self::State,
-        _bounds: Rectangle,
-        _cursor: Cursor,
-    ) -> mouse::Interaction {
-        mouse::Interaction::default()
-    }
-}
-
-impl<Message, Theme, T> Program<Message, Theme> for &T
-where
-    T: Program<Message, Theme>,
-{
-    type State = T::State;
-
-    fn update(
-        &self,
-        state: &mut Self::State,
-        event: Event,
-        bounds: Rectangle,
-        cursor: Cursor,
-    ) -> (event::Status, Option<Message>) {
-        T::update(self, state, event, bounds, cursor)
-    }
-
-    fn draw(
-        &self,
-        state: &Self::State,
-        theme: &Theme,
-        bounds: Rectangle,
-        cursor: Cursor,
-    ) -> Vec<Geometry> {
-        T::draw(self, state, theme, bounds, cursor)
-    }
-
-    fn mouse_interaction(
-        &self,
-        state: &Self::State,
-        bounds: Rectangle,
-        cursor: Cursor,
-    ) -> mouse::Interaction {
-        T::mouse_interaction(self, state, bounds, cursor)
-    }
-}
diff --git a/graphics/src/widget/qr_code.rs b/graphics/src/widget/qr_code.rs
deleted file mode 100644
index 12ce5b1f..00000000
--- a/graphics/src/widget/qr_code.rs
+++ /dev/null
@@ -1,301 +0,0 @@
-//! Encode and display information in a QR code.
-use crate::renderer::{self, Renderer};
-use crate::widget::canvas;
-use crate::Backend;
-
-use iced_native::layout;
-use iced_native::widget::Tree;
-use iced_native::{
-    Color, Element, Layout, Length, Point, Rectangle, Size, Vector, Widget,
-};
-use thiserror::Error;
-
-const DEFAULT_CELL_SIZE: u16 = 4;
-const QUIET_ZONE: usize = 2;
-
-/// A type of matrix barcode consisting of squares arranged in a grid which
-/// can be read by an imaging device, such as a camera.
-#[derive(Debug)]
-pub struct QRCode<'a> {
-    state: &'a State,
-    dark: Color,
-    light: Color,
-    cell_size: u16,
-}
-
-impl<'a> QRCode<'a> {
-    /// Creates a new [`QRCode`] with the provided [`State`].
-    pub fn new(state: &'a State) -> Self {
-        Self {
-            cell_size: DEFAULT_CELL_SIZE,
-            dark: Color::BLACK,
-            light: Color::WHITE,
-            state,
-        }
-    }
-
-    /// Sets both the dark and light [`Color`]s of the [`QRCode`].
-    pub fn color(mut self, dark: Color, light: Color) -> Self {
-        self.dark = dark;
-        self.light = light;
-        self
-    }
-
-    /// Sets the size of the squares of the grid cell of the [`QRCode`].
-    pub fn cell_size(mut self, cell_size: u16) -> Self {
-        self.cell_size = cell_size;
-        self
-    }
-}
-
-impl<'a, Message, B, T> Widget<Message, Renderer<B, T>> for QRCode<'a>
-where
-    B: Backend,
-{
-    fn width(&self) -> Length {
-        Length::Shrink
-    }
-
-    fn height(&self) -> Length {
-        Length::Shrink
-    }
-
-    fn layout(
-        &self,
-        _renderer: &Renderer<B, T>,
-        _limits: &layout::Limits,
-    ) -> layout::Node {
-        let side_length = (self.state.width + 2 * QUIET_ZONE) as f32
-            * f32::from(self.cell_size);
-
-        layout::Node::new(Size::new(side_length, side_length))
-    }
-
-    fn draw(
-        &self,
-        _state: &Tree,
-        renderer: &mut Renderer<B, T>,
-        _theme: &T,
-        _style: &renderer::Style,
-        layout: Layout<'_>,
-        _cursor_position: Point,
-        _viewport: &Rectangle,
-    ) {
-        use iced_native::Renderer as _;
-
-        let bounds = layout.bounds();
-        let side_length = self.state.width + 2 * QUIET_ZONE;
-
-        // Reuse cache if possible
-        let geometry = self.state.cache.draw(bounds.size(), |frame| {
-            // Scale units to cell size
-            frame.scale(f32::from(self.cell_size));
-
-            // Draw background
-            frame.fill_rectangle(
-                Point::ORIGIN,
-                Size::new(side_length as f32, side_length as f32),
-                self.light,
-            );
-
-            // Avoid drawing on the quiet zone
-            frame.translate(Vector::new(QUIET_ZONE as f32, QUIET_ZONE as f32));
-
-            // Draw contents
-            self.state
-                .contents
-                .iter()
-                .enumerate()
-                .filter(|(_, value)| **value == qrcode::Color::Dark)
-                .for_each(|(index, _)| {
-                    let row = index / self.state.width;
-                    let column = index % self.state.width;
-
-                    frame.fill_rectangle(
-                        Point::new(column as f32, row as f32),
-                        Size::UNIT,
-                        self.dark,
-                    );
-                });
-        });
-
-        let translation = Vector::new(bounds.x, bounds.y);
-
-        renderer.with_translation(translation, |renderer| {
-            renderer.draw_primitive(geometry.into_primitive());
-        });
-    }
-}
-
-impl<'a, Message, B, T> From<QRCode<'a>>
-    for Element<'a, Message, Renderer<B, T>>
-where
-    B: Backend,
-{
-    fn from(qr_code: QRCode<'a>) -> Self {
-        Self::new(qr_code)
-    }
-}
-
-/// The state of a [`QRCode`].
-///
-/// It stores the data that will be displayed.
-#[derive(Debug)]
-pub struct State {
-    contents: Vec<qrcode::Color>,
-    width: usize,
-    cache: canvas::Cache,
-}
-
-impl State {
-    /// Creates a new [`State`] with the provided data.
-    ///
-    /// This method uses an [`ErrorCorrection::Medium`] and chooses the smallest
-    /// size to display the data.
-    pub fn new(data: impl AsRef<[u8]>) -> Result<Self, Error> {
-        let encoded = qrcode::QrCode::new(data)?;
-
-        Ok(Self::build(encoded))
-    }
-
-    /// Creates a new [`State`] with the provided [`ErrorCorrection`].
-    pub fn with_error_correction(
-        data: impl AsRef<[u8]>,
-        error_correction: ErrorCorrection,
-    ) -> Result<Self, Error> {
-        let encoded = qrcode::QrCode::with_error_correction_level(
-            data,
-            error_correction.into(),
-        )?;
-
-        Ok(Self::build(encoded))
-    }
-
-    /// Creates a new [`State`] with the provided [`Version`] and
-    /// [`ErrorCorrection`].
-    pub fn with_version(
-        data: impl AsRef<[u8]>,
-        version: Version,
-        error_correction: ErrorCorrection,
-    ) -> Result<Self, Error> {
-        let encoded = qrcode::QrCode::with_version(
-            data,
-            version.into(),
-            error_correction.into(),
-        )?;
-
-        Ok(Self::build(encoded))
-    }
-
-    fn build(encoded: qrcode::QrCode) -> Self {
-        let width = encoded.width();
-        let contents = encoded.into_colors();
-
-        Self {
-            contents,
-            width,
-            cache: canvas::Cache::new(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-/// The size of a [`QRCode`].
-///
-/// The higher the version the larger the grid of cells, and therefore the more
-/// information the [`QRCode`] can carry.
-pub enum Version {
-    /// A normal QR code version. It should be between 1 and 40.
-    Normal(u8),
-
-    /// A micro QR code version. It should be between 1 and 4.
-    Micro(u8),
-}
-
-impl From<Version> for qrcode::Version {
-    fn from(version: Version) -> Self {
-        match version {
-            Version::Normal(v) => qrcode::Version::Normal(i16::from(v)),
-            Version::Micro(v) => qrcode::Version::Micro(i16::from(v)),
-        }
-    }
-}
-
-/// The error correction level.
-///
-/// It controls the amount of data that can be damaged while still being able
-/// to recover the original information.
-///
-/// A higher error correction level allows for more corrupted data.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum ErrorCorrection {
-    /// Low error correction. 7% of the data can be restored.
-    Low,
-    /// Medium error correction. 15% of the data can be restored.
-    Medium,
-    /// Quartile error correction. 25% of the data can be restored.
-    Quartile,
-    /// High error correction. 30% of the data can be restored.
-    High,
-}
-
-impl From<ErrorCorrection> for qrcode::EcLevel {
-    fn from(ec_level: ErrorCorrection) -> Self {
-        match ec_level {
-            ErrorCorrection::Low => qrcode::EcLevel::L,
-            ErrorCorrection::Medium => qrcode::EcLevel::M,
-            ErrorCorrection::Quartile => qrcode::EcLevel::Q,
-            ErrorCorrection::High => qrcode::EcLevel::H,
-        }
-    }
-}
-
-/// An error that occurred when building a [`State`] for a [`QRCode`].
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Error)]
-pub enum Error {
-    /// The data is too long to encode in a QR code for the chosen [`Version`].
-    #[error(
-        "The data is too long to encode in a QR code for the chosen version"
-    )]
-    DataTooLong,
-
-    /// The chosen [`Version`] and [`ErrorCorrection`] combination is invalid.
-    #[error(
-        "The chosen version and error correction level combination is invalid."
-    )]
-    InvalidVersion,
-
-    /// One or more characters in the provided data are not supported by the
-    /// chosen [`Version`].
-    #[error(
-        "One or more characters in the provided data are not supported by the \
-        chosen version"
-    )]
-    UnsupportedCharacterSet,
-
-    /// The chosen ECI designator is invalid. A valid designator should be
-    /// between 0 and 999999.
-    #[error(
-        "The chosen ECI designator is invalid. A valid designator should be \
-        between 0 and 999999."
-    )]
-    InvalidEciDesignator,
-
-    /// A character that does not belong to the character set was found.
-    #[error("A character that does not belong to the character set was found")]
-    InvalidCharacter,
-}
-
-impl From<qrcode::types::QrError> for Error {
-    fn from(error: qrcode::types::QrError) -> Self {
-        use qrcode::types::QrError;
-
-        match error {
-            QrError::DataTooLong => Error::DataTooLong,
-            QrError::InvalidVersion => Error::InvalidVersion,
-            QrError::UnsupportedCharacterSet => Error::UnsupportedCharacterSet,
-            QrError::InvalidEciDesignator => Error::InvalidEciDesignator,
-            QrError::InvalidCharacter => Error::InvalidCharacter,
-        }
-    }
-}
diff --git a/graphics/src/window.rs b/graphics/src/window.rs
deleted file mode 100644
index a38b81f3..00000000
--- a/graphics/src/window.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//! Draw graphics to window surfaces.
-pub mod compositor;
-
-#[cfg(feature = "opengl")]
-pub mod gl_compositor;
-
-pub use compositor::Compositor;
-
-#[cfg(feature = "opengl")]
-pub use gl_compositor::GLCompositor;
diff --git a/graphics/src/window/gl_compositor.rs b/graphics/src/window/gl_compositor.rs
deleted file mode 100644
index a45a7ca1..00000000
--- a/graphics/src/window/gl_compositor.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-//! A compositor is responsible for initializing a renderer and managing window
-//! surfaces.
-use crate::compositor::Information;
-use crate::{Color, Error, Size, Viewport};
-
-use core::ffi::c_void;
-
-/// A basic OpenGL compositor.
-///
-/// A compositor is responsible for initializing a renderer and managing window
-/// surfaces.
-///
-/// For now, this compositor only deals with a single global surface
-/// for drawing. However, the trait will most likely change in the near future
-/// to handle multiple surfaces at once.
-///
-/// If you implement an OpenGL renderer, you can implement this trait to ease
-/// integration with existing windowing shells, like `iced_glutin`.
-pub trait GLCompositor: Sized {
-    /// The renderer of the [`GLCompositor`].
-    ///
-    /// This should point to your renderer type, which could be a type alias
-    /// of the [`Renderer`] provided in this crate with with a specific
-    /// [`Backend`].
-    ///
-    /// [`Renderer`]: crate::Renderer
-    /// [`Backend`]: crate::Backend
-    type Renderer: iced_native::Renderer;
-
-    /// The settings of the [`GLCompositor`].
-    ///
-    /// It's up to you to decide the configuration supported by your renderer!
-    type Settings: Default;
-
-    /// Creates a new [`GLCompositor`] and [`Renderer`] with the given
-    /// [`Settings`] and an OpenGL address loader function.
-    ///
-    /// # Safety
-    /// The `loader_function` should resolve to valid OpenGL bindings.
-    ///
-    /// [`Renderer`]: crate::Renderer
-    /// [`Backend`]: crate::Backend
-    /// [`Settings`]: Self::Settings
-    #[allow(unsafe_code)]
-    unsafe fn new(
-        settings: Self::Settings,
-        loader_function: impl FnMut(&str) -> *const c_void,
-    ) -> Result<(Self, Self::Renderer), Error>;
-
-    /// Returns the amount of samples that should be used when configuring
-    /// an OpenGL context for this [`GLCompositor`].
-    fn sample_count(settings: &Self::Settings) -> u32;
-
-    /// Resizes the viewport of the [`GLCompositor`].
-    fn resize_viewport(&mut self, physical_size: Size<u32>);
-
-    /// Returns [`Information`] used by this [`GLCompositor`].
-    fn fetch_information(&self) -> Information;
-
-    /// Presents the primitives of the [`Renderer`] to the next frame of the
-    /// [`GLCompositor`].
-    ///
-    /// [`Renderer`]: crate::Renderer
-    fn present<T: AsRef<str>>(
-        &mut self,
-        renderer: &mut Self::Renderer,
-        viewport: &Viewport,
-        background_color: Color,
-        overlay: &[T],
-    );
-}