From 45b920141ce8129c0748e7e5a2b9210c9996364b Mon Sep 17 00:00:00 2001
From: Christopher Serr <christopher.serr@gmail.com>
Date: Sat, 4 Dec 2021 16:54:14 +0100
Subject: [PATCH] Allow Customizing the Text Engine

So far livesplit-core always brought its own text engine. However in
particular the font fallback isn't great. It also always renders the
text as paths instead of leveraging the underlying renderer's built-in
text renderer. So this now allows the renderer to bring its own text
engine implementation. The old path based text engine is now available
as an optional feature that you can still use if the renderer doesn't
provide its own text rendering.
---
 Cargo.toml                                    |  27 +-
 benches/scene_management.rs                   |  42 +-
 src/layout/component.rs                       |  16 +-
 src/rendering/component/detailed_timer.rs     |  36 +-
 src/rendering/component/graph.rs              |   6 +-
 src/rendering/component/key_value.rs          |  20 +-
 src/rendering/component/mod.rs                |  20 +-
 src/rendering/component/splits.rs             |  31 +-
 src/rendering/component/text.rs               |  20 +-
 src/rendering/component/timer.rs              |  22 +-
 src/rendering/component/title.rs              |  21 +-
 src/rendering/entity.rs                       | 103 +++-
 src/rendering/font/cache.rs                   | 120 ++--
 src/rendering/font/glyph_cache.rs             |  71 ---
 src/rendering/font/mod.rs                     | 535 ++++--------------
 src/rendering/mod.rs                          | 292 +++++-----
 .../color_font/colr.rs                        |   0
 .../color_font/cpal.rs                        |   0
 .../color_font/mod.rs                         |  10 +-
 .../color_font/parse_util.rs                  |   0
 src/rendering/path_based_text_engine/mod.rs   | 458 +++++++++++++++
 src/rendering/resource/allocation.rs          | 131 ++++-
 src/rendering/resource/handles.rs             | 118 +++-
 src/rendering/resource/mod.rs                 |   2 +-
 src/rendering/resource/shared_ownership.rs    |   2 +-
 src/rendering/scene.rs                        |  21 +-
 src/rendering/software.rs                     | 235 ++++++--
 src/run/parser/flitter/s_expressions.rs       |   2 +-
 src/settings/image/mod.rs                     |   2 +-
 tests/rendering.rs                            |   2 +-
 30 files changed, 1407 insertions(+), 958 deletions(-)
 delete mode 100644 src/rendering/font/glyph_cache.rs
 rename src/rendering/{font => path_based_text_engine}/color_font/colr.rs (100%)
 rename src/rendering/{font => path_based_text_engine}/color_font/cpal.rs (100%)
 rename src/rendering/{font => path_based_text_engine}/color_font/mod.rs (86%)
 rename src/rendering/{font => path_based_text_engine}/color_font/parse_util.rs (100%)
 create mode 100644 src/rendering/path_based_text_engine/mod.rs

diff --git a/Cargo.toml b/Cargo.toml
index 27f3d056..14f80915 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -22,7 +22,7 @@ include = [
     "/LICENSE-MIT",
     "/README.md",
 ]
-edition = "2018"
+edition = "2021"
 resolver = "2"
 
 [package.metadata.docs.rs]
@@ -63,15 +63,20 @@ serde_json = { version = "1.0.8", optional = true }
 utf-8 = { version = "0.7.4", optional = true }
 
 # Rendering
-ahash = { version = "0.7.0", default-features = false, optional = true }
+# Currently doesn't require any additional dependencies.
+
+# Path-based Text Engine
 rustybuzz = { version = "0.4.0", optional = true }
-ttf-parser = { version = "0.12.0", optional = true }
+ttf-parser = { version = "0.12.3", optional = true }
 
 # Font Loading
 font-kit = { version = "0.10.0", optional = true }
 
 # Software Rendering
-tiny-skia = { version = "0.6.0", default-features = false, features = ["std", "simd"], optional = true }
+tiny-skia = { version = "0.6.0", default-features = false, features = [
+    "std",
+    "simd",
+], optional = true }
 
 # Networking
 splits-io-api = { version = "0.2.0", optional = true }
@@ -127,16 +132,10 @@ more-image-formats = [
     "image/webp",
 ]
 image-shrinking = ["std", "bytemuck", "more-image-formats"]
-rendering = [
-    "ahash",
-    "bytemuck/derive",
-    "more-image-formats",
-    "rustybuzz",
-    "std",
-    "ttf-parser",
-]
-font-loading = ["std", "rendering", "font-kit"]
-software-rendering = ["rendering", "tiny-skia"]
+rendering = ["bytemuck/derive", "more-image-formats"]
+path-based-text-engine = ["std", "rendering", "rustybuzz", "ttf-parser"]
+font-loading = ["std", "path-based-text-engine", "font-kit"]
+software-rendering = ["path-based-text-engine", "tiny-skia"]
 wasm-web = [
     "js-sys",
     "livesplit-hotkey/wasm-web",
diff --git a/benches/scene_management.rs b/benches/scene_management.rs
index cc019246..51eb7ad5 100644
--- a/benches/scene_management.rs
+++ b/benches/scene_management.rs
@@ -1,10 +1,13 @@
+use livesplit_core::rendering::SharedOwnership;
+
 cfg_if::cfg_if! {
     if #[cfg(feature = "rendering")] {
         use criterion::{criterion_group, criterion_main, Criterion};
         use livesplit_core::{
             layout::{self, Layout},
-            rendering::{PathBuilder, ResourceAllocator, SceneManager},
+            rendering::{PathBuilder, ResourceAllocator, SceneManager, Label, FontKind},
             run::parser::livesplit,
+            settings::Font,
             Run, Segment, TimeSpan, Timer, TimingMethod,
         };
         use std::{fs::File, io::BufReader};
@@ -14,7 +17,7 @@ cfg_if::cfg_if! {
 
         struct Dummy;
 
-        impl PathBuilder<Dummy> for Dummy {
+        impl PathBuilder for Dummy {
             type Path = ();
 
             fn move_to(&mut self, _: f32, _: f32) {}
@@ -22,18 +25,51 @@ cfg_if::cfg_if! {
             fn quad_to(&mut self, _: f32, _: f32, _: f32, _: f32) {}
             fn curve_to(&mut self, _: f32, _: f32, _: f32, _: f32, _: f32, _: f32) {}
             fn close(&mut self) {}
-            fn finish(self, _: &mut Dummy) -> Self::Path {}
+            fn finish(self) -> Self::Path {}
         }
 
         impl ResourceAllocator for Dummy {
             type PathBuilder = Dummy;
             type Path = ();
             type Image = ();
+            type Font = ();
+            type Label = Dummy;
 
             fn path_builder(&mut self) -> Self::PathBuilder {
                 Dummy
             }
             fn create_image(&mut self, _: u32, _: u32, _: &[u8]) -> Self::Image {}
+            fn create_font(&mut self, _: Option<&Font>, _: FontKind) -> Self::Font {}
+            fn create_label(
+                &mut self,
+                _: &str,
+                _: &mut Self::Font,
+                _: Option<f32>,
+            ) -> Self::Label {
+                Dummy
+            }
+            fn update_label(
+                &mut self,
+                _: &mut Self::Label,
+                _: &str,
+                _: &mut Self::Font,
+                _: Option<f32>,
+            ) {}
+        }
+
+        impl Label for Dummy {
+            fn width(&self, _: f32) -> f32 {
+                0.0
+            }
+            fn width_without_max_width(&self, _: f32) -> f32 {
+                0.0
+            }
+        }
+
+        impl SharedOwnership for Dummy {
+            fn share(&self) -> Self {
+                Dummy
+            }
         }
 
         fn default(c: &mut Criterion) {
diff --git a/src/layout/component.rs b/src/layout/component.rs
index 49c01c35..57f57ac5 100644
--- a/src/layout/component.rs
+++ b/src/layout/component.rs
@@ -1,12 +1,14 @@
 use super::{ComponentSettings, ComponentState, GeneralSettings};
-use crate::component::{
-    blank_space, current_comparison, current_pace, delta, detailed_timer, graph, pb_chance,
-    possible_time_save, previous_segment, segment_time, separator, splits, sum_of_best, text,
-    timer, title, total_playtime,
+use crate::{
+    component::{
+        blank_space, current_comparison, current_pace, delta, detailed_timer, graph, pb_chance,
+        possible_time_save, previous_segment, segment_time, separator, splits, sum_of_best, text,
+        timer, title, total_playtime,
+    },
+    platform::prelude::*,
+    settings::{SettingsDescription, Value},
+    timing::Snapshot,
 };
-use crate::platform::prelude::*;
-use crate::settings::{SettingsDescription, Value};
-use crate::timing::Snapshot;
 use alloc::borrow::Cow;
 
 /// A Component provides information about a run in a way that is easy to
diff --git a/src/rendering/component/detailed_timer.rs b/src/rendering/component/detailed_timer.rs
index c73c789b..518b69bf 100644
--- a/src/rendering/component/detailed_timer.rs
+++ b/src/rendering/component/detailed_timer.rs
@@ -4,7 +4,7 @@ use crate::{
     rendering::{
         component::timer,
         consts::{vertical_padding, BOTH_PADDINGS, PADDING},
-        font::Label,
+        font::CachedLabel,
         icon::Icon,
         resource::ResourceAllocator,
         scene::Layer,
@@ -12,35 +12,35 @@ use crate::{
     },
 };
 
-pub struct Cache<I> {
+pub struct Cache<I, L> {
     icon: Option<Icon<I>>,
-    timer: timer::Cache<I>,
-    segment_timer: timer::Cache<I>,
-    segment_name: Label,
-    comparison1_name: Label,
-    comparison2_name: Label,
-    comparison1_time: Label,
-    comparison2_time: Label,
+    timer: timer::Cache<I, L>,
+    segment_timer: timer::Cache<I, L>,
+    segment_name: CachedLabel<L>,
+    comparison1_name: CachedLabel<L>,
+    comparison2_name: CachedLabel<L>,
+    comparison1_time: CachedLabel<L>,
+    comparison2_time: CachedLabel<L>,
 }
 
-impl<I> Cache<I> {
+impl<I, L> Cache<I, L> {
     pub const fn new() -> Self {
         Self {
             icon: None,
             timer: timer::Cache::new(),
             segment_timer: timer::Cache::new(),
-            segment_name: Label::new(),
-            comparison1_name: Label::new(),
-            comparison2_name: Label::new(),
-            comparison1_time: Label::new(),
-            comparison2_time: Label::new(),
+            segment_name: CachedLabel::new(),
+            comparison1_name: CachedLabel::new(),
+            comparison2_name: CachedLabel::new(),
+            comparison1_time: CachedLabel::new(),
+            comparison2_time: CachedLabel::new(),
         }
     }
 }
 
-pub(in crate::rendering) fn render<B: ResourceAllocator>(
-    cache: &mut Cache<B::Image>,
-    context: &mut RenderContext<'_, B>,
+pub(in crate::rendering) fn render<A: ResourceAllocator>(
+    cache: &mut Cache<A::Image, A::Label>,
+    context: &mut RenderContext<'_, A>,
     [width, height]: [f32; 2],
     component: &State,
     layout_state: &LayoutState,
diff --git a/src/rendering/component/graph.rs b/src/rendering/component/graph.rs
index 4a0f05f6..5fd14273 100644
--- a/src/rendering/component/graph.rs
+++ b/src/rendering/component/graph.rs
@@ -56,7 +56,7 @@ pub(in crate::rendering) fn render(
         builder.line_to(width * p2.x, p2.y);
         builder.line_to(width * p2.x, component.middle);
         builder.close();
-        let partial_fill_path = builder.finish(&mut context.handles);
+        let partial_fill_path = builder.finish();
         context.top_layer_path(partial_fill_path, component.partial_fill_color);
 
         component.points.len() - 1
@@ -71,7 +71,7 @@ pub(in crate::rendering) fn render(
     }
     builder.line_to(width * component.points[len - 1].x, component.middle);
     builder.close();
-    let fill_path = builder.finish(&mut context.handles);
+    let fill_path = builder.finish();
     context.top_layer_path(fill_path, component.complete_fill_color);
 
     for points in component.points.windows(2) {
@@ -85,7 +85,7 @@ pub(in crate::rendering) fn render(
             component.graph_lines_color
         };
 
-        let line_path = builder.finish(&mut context.handles);
+        let line_path = builder.finish();
         context.top_layer_stroke_path(line_path, color, LINE_WIDTH);
     }
 
diff --git a/src/rendering/component/key_value.rs b/src/rendering/component/key_value.rs
index aaf33feb..b12e8734 100644
--- a/src/rendering/component/key_value.rs
+++ b/src/rendering/component/key_value.rs
@@ -1,34 +1,34 @@
-use std::marker::PhantomData;
+use core::marker::PhantomData;
 
 use crate::{
     component::key_value::State,
     layout::{LayoutDirection, LayoutState},
     rendering::{
-        font::{AbbreviatedLabel, Label},
+        font::{AbbreviatedLabel, CachedLabel},
         resource::ResourceAllocator,
         RenderContext,
     },
 };
 
-pub struct Cache<I> {
-    key: AbbreviatedLabel,
-    value: Label,
+pub struct Cache<I, L> {
+    key: AbbreviatedLabel<L>,
+    value: CachedLabel<L>,
     _image: PhantomData<I>,
 }
 
-impl<I> Cache<I> {
+impl<I, L> Cache<I, L> {
     pub const fn new() -> Self {
         Self {
             key: AbbreviatedLabel::new(),
-            value: Label::new(),
+            value: CachedLabel::new(),
             _image: PhantomData,
         }
     }
 }
 
-pub(in crate::rendering) fn render<B: ResourceAllocator>(
-    cache: &mut Cache<B::Image>,
-    context: &mut RenderContext<'_, B>,
+pub(in crate::rendering) fn render<A: ResourceAllocator>(
+    cache: &mut Cache<A::Image, A::Label>,
+    context: &mut RenderContext<'_, A>,
     dim: [f32; 2],
     component: &State,
     layout_state: &LayoutState,
diff --git a/src/rendering/component/mod.rs b/src/rendering/component/mod.rs
index 8fe7034f..a225d0f6 100644
--- a/src/rendering/component/mod.rs
+++ b/src/rendering/component/mod.rs
@@ -16,20 +16,20 @@ pub mod text;
 pub mod timer;
 pub mod title;
 
-pub enum Cache<I> {
+pub enum Cache<I, L> {
     Empty,
-    DetailedTimer(detailed_timer::Cache<I>),
-    KeyValue(key_value::Cache<I>),
-    Splits(splits::Cache<I>),
-    Text(text::Cache<I>),
-    Timer(timer::Cache<I>),
-    Title(title::Cache<I>),
+    DetailedTimer(detailed_timer::Cache<I, L>),
+    KeyValue(key_value::Cache<I, L>),
+    Splits(splits::Cache<I, L>),
+    Text(text::Cache<I, L>),
+    Timer(timer::Cache<I, L>),
+    Title(title::Cache<I, L>),
 }
 
 macro_rules! accessors {
     ($($variant:ident $module:ident),*) => {
         $(
-            fn $module(&mut self) -> &mut $module::Cache<I> {
+            fn $module(&mut self) -> &mut $module::Cache<I, L> {
                 match self {
                     Self::$variant(c) => c,
                     _ => {
@@ -42,7 +42,7 @@ macro_rules! accessors {
     };
 }
 
-impl<I> Cache<I> {
+impl<I, L> Cache<I, L> {
     pub const fn new(component: &ComponentState) -> Self {
         match component {
             ComponentState::DetailedTimer(_) => Self::DetailedTimer(detailed_timer::Cache::new()),
@@ -134,7 +134,7 @@ pub fn height(component: &ComponentState) -> f32 {
 }
 
 pub(super) fn render<A: ResourceAllocator>(
-    cache: &mut Cache<A::Image>,
+    cache: &mut Cache<A::Image, A::Label>,
     context: &mut RenderContext<'_, A>,
     component: &ComponentState,
     state: &LayoutState,
diff --git a/src/rendering/component/splits.rs b/src/rendering/component/splits.rs
index ed50cd8f..5f10d17a 100644
--- a/src/rendering/component/splits.rs
+++ b/src/rendering/component/splits.rs
@@ -6,38 +6,39 @@ use crate::{
             vertical_padding, BOTH_PADDINGS, DEFAULT_COMPONENT_HEIGHT, DEFAULT_TEXT_SIZE, PADDING,
             TEXT_ALIGN_BOTTOM, TEXT_ALIGN_TOP, THIN_SEPARATOR_THICKNESS, TWO_ROW_HEIGHT,
         },
-        font::Label,
+        font::CachedLabel,
         icon::Icon,
         resource::ResourceAllocator,
         scene::Layer,
         solid, RenderContext,
     },
     settings::{Gradient, ListGradient},
+    platform::prelude::*,
 };
 
 pub const COLUMN_WIDTH: f32 = 2.75;
 
-pub struct Cache<I> {
+pub struct Cache<I, L> {
     icons: Vec<Option<Icon<I>>>,
-    splits: Vec<SplitCache>,
-    column_labels: Vec<Label>,
+    splits: Vec<SplitCache<L>>,
+    column_labels: Vec<CachedLabel<L>>,
 }
 
-struct SplitCache {
-    name: Label,
-    columns: Vec<Label>,
+struct SplitCache<L> {
+    name: CachedLabel<L>,
+    columns: Vec<CachedLabel<L>>,
 }
 
-impl SplitCache {
+impl<L> SplitCache<L> {
     const fn new() -> Self {
         Self {
-            name: Label::new(),
+            name: CachedLabel::new(),
             columns: Vec::new(),
         }
     }
 }
 
-impl<I> Cache<I> {
+impl<I, L> Cache<I, L> {
     pub const fn new() -> Self {
         Self {
             icons: Vec::new(),
@@ -47,9 +48,9 @@ impl<I> Cache<I> {
     }
 }
 
-pub(in crate::rendering) fn render<B: ResourceAllocator>(
-    cache: &mut Cache<B::Image>,
-    context: &mut RenderContext<'_, B>,
+pub(in crate::rendering) fn render<A: ResourceAllocator>(
+    cache: &mut Cache<A::Image, A::Label>,
+    context: &mut RenderContext<'_, A>,
     [width, height]: [f32; 2],
     component: &State,
     layout_state: &LayoutState,
@@ -110,7 +111,7 @@ pub(in crate::rendering) fn render<B: ResourceAllocator>(
         if layout_state.direction == LayoutDirection::Vertical {
             cache
                 .column_labels
-                .resize_with(column_labels.len(), Label::new);
+                .resize_with(column_labels.len(), CachedLabel::new);
 
             let mut right_x = width - PADDING;
             for (label, cache) in column_labels.iter().zip(&mut cache.column_labels) {
@@ -175,7 +176,7 @@ pub(in crate::rendering) fn render<B: ResourceAllocator>(
 
             split_cache
                 .columns
-                .resize_with(split.columns.len(), Label::new);
+                .resize_with(split.columns.len(), CachedLabel::new);
 
             for (column, column_cache) in split.columns.iter().zip(&mut split_cache.columns) {
                 if !column.value.is_empty() {
diff --git a/src/rendering/component/text.rs b/src/rendering/component/text.rs
index 103760f1..71ebe0f5 100644
--- a/src/rendering/component/text.rs
+++ b/src/rendering/component/text.rs
@@ -1,35 +1,35 @@
-use std::marker::PhantomData;
+use core::marker::PhantomData;
 
 use crate::{
     component::text::{State, TextState},
     layout::{LayoutDirection, LayoutState},
     rendering::{
         consts::{DEFAULT_TEXT_SIZE, PADDING, TEXT_ALIGN_TOP},
-        font::{AbbreviatedLabel, Label},
+        font::{AbbreviatedLabel, CachedLabel},
         resource::ResourceAllocator,
         solid, RenderContext,
     },
 };
 
-pub struct Cache<I> {
-    label1: AbbreviatedLabel,
-    label2: Label,
+pub struct Cache<I, L> {
+    label1: AbbreviatedLabel<L>,
+    label2: CachedLabel<L>,
     _image: PhantomData<I>,
 }
 
-impl<I> Cache<I> {
+impl<I, L> Cache<I, L> {
     pub const fn new() -> Self {
         Self {
             label1: AbbreviatedLabel::new(),
-            label2: Label::new(),
+            label2: CachedLabel::new(),
             _image: PhantomData,
         }
     }
 }
 
-pub(in crate::rendering) fn render<B: ResourceAllocator>(
-    cache: &mut Cache<B::Image>,
-    context: &mut RenderContext<'_, B>,
+pub(in crate::rendering) fn render<A: ResourceAllocator>(
+    cache: &mut Cache<A::Image, A::Label>,
+    context: &mut RenderContext<'_, A>,
     [width, height]: [f32; 2],
     component: &State,
     layout_state: &LayoutState,
diff --git a/src/rendering/component/timer.rs b/src/rendering/component/timer.rs
index 6a87f54e..77831523 100644
--- a/src/rendering/component/timer.rs
+++ b/src/rendering/component/timer.rs
@@ -1,32 +1,32 @@
-use std::marker::PhantomData;
+use core::marker::PhantomData;
 
 use crate::{
     component::timer::State,
     rendering::{
-        consts::PADDING, font::Label, resource::ResourceAllocator, scene::Layer, FillShader,
+        consts::PADDING, font::CachedLabel, resource::ResourceAllocator, scene::Layer, FillShader,
         RenderContext,
     },
 };
 
-pub struct Cache<I> {
-    time: Label,
-    fraction: Label,
+pub struct Cache<I, L> {
+    time: CachedLabel<L>,
+    fraction: CachedLabel<L>,
     _image: PhantomData<I>,
 }
 
-impl<I> Cache<I> {
+impl<I, L> Cache<I, L> {
     pub const fn new() -> Self {
         Self {
-            time: Label::new(),
-            fraction: Label::new(),
+            time: CachedLabel::new(),
+            fraction: CachedLabel::new(),
             _image: PhantomData,
         }
     }
 }
 
-pub(in crate::rendering) fn render<B: ResourceAllocator>(
-    cache: &mut Cache<B::Image>,
-    context: &mut RenderContext<'_, B>,
+pub(in crate::rendering) fn render<A: ResourceAllocator>(
+    cache: &mut Cache<A::Image, A::Label>,
+    context: &mut RenderContext<'_, A>,
     [width, height]: [f32; 2],
     component: &State,
 ) -> f32 {
diff --git a/src/rendering/component/title.rs b/src/rendering/component/title.rs
index cadd8bf3..e2f326c6 100644
--- a/src/rendering/component/title.rs
+++ b/src/rendering/component/title.rs
@@ -3,41 +3,42 @@ use core::fmt::Write;
 use crate::{
     component::title::State,
     layout::LayoutState,
+    platform::prelude::*,
     rendering::{
         consts::{
             vertical_padding, BOTH_PADDINGS, DEFAULT_TEXT_SIZE, PADDING, TEXT_ALIGN_BOTTOM,
             TEXT_ALIGN_CENTER, TEXT_ALIGN_TOP,
         },
-        font::{AbbreviatedLabel, Label},
+        font::{AbbreviatedLabel, CachedLabel},
         icon::Icon,
         resource::ResourceAllocator,
         solid, Layer, RenderContext,
     },
 };
 
-pub struct Cache<I> {
-    line1: AbbreviatedLabel,
-    line2: AbbreviatedLabel,
+pub struct Cache<I, L> {
+    line1: AbbreviatedLabel<L>,
+    line2: AbbreviatedLabel<L>,
     game_icon: Option<Icon<I>>,
-    attempts: Label,
+    attempts: CachedLabel<L>,
     attempts_buffer: String,
 }
 
-impl<I> Cache<I> {
+impl<I, L> Cache<I, L> {
     pub const fn new() -> Self {
         Self {
             line1: AbbreviatedLabel::new(),
             line2: AbbreviatedLabel::new(),
             game_icon: None,
-            attempts: Label::new(),
+            attempts: CachedLabel::new(),
             attempts_buffer: String::new(),
         }
     }
 }
 
-pub(in crate::rendering) fn render<B: ResourceAllocator>(
-    cache: &mut Cache<B::Image>,
-    context: &mut RenderContext<'_, B>,
+pub(in crate::rendering) fn render<A: ResourceAllocator>(
+    cache: &mut Cache<A::Image, A::Label>,
+    context: &mut RenderContext<'_, A>,
     [width, height]: [f32; 2],
     component: &State,
     layout_state: &LayoutState,
diff --git a/src/rendering/entity.rs b/src/rendering/entity.rs
index ddb55631..ce093e8f 100644
--- a/src/rendering/entity.rs
+++ b/src/rendering/entity.rs
@@ -1,15 +1,72 @@
-use std::{
+use core::{
     hash::{Hash, Hasher},
     mem,
 };
 
-use ahash::AHasher;
+use super::{
+    resource::{Handle, LabelHandle},
+    FillShader, Rgba, Transform,
+};
+
+struct FxHasher(u64);
+
+impl Hasher for FxHasher {
+    #[inline]
+    fn write_u8(&mut self, i: u8) {
+        self.write_u64(i as u64);
+    }
 
-use super::{resource::Handle, FillShader, Rgba, Transform};
+    #[inline]
+    fn write_u16(&mut self, i: u16) {
+        self.write_u64(i as u64);
+    }
+
+    #[inline]
+    fn write_u32(&mut self, i: u32) {
+        self.write_u64(i as u64);
+    }
+
+    #[inline]
+    fn write_u64(&mut self, i: u64) {
+        self.0 = (self.0.rotate_left(5) ^ i).wrapping_mul(0x517cc1b727220a95);
+    }
+
+    #[inline]
+    fn write_u128(&mut self, i: u128) {
+        let [a, b]: [u64; 2] = bytemuck::cast(i);
+        self.write_u64(a);
+        self.write_u64(b);
+    }
+
+    #[inline]
+    fn write_usize(&mut self, i: usize) {
+        self.write(bytemuck::bytes_of(&i))
+    }
+
+    #[inline]
+    fn finish(&self) -> u64 {
+        self.0
+    }
+
+    #[inline]
+    fn write(&mut self, bytes: &[u8]) {
+        let (_, chunks, rem) = bytemuck::pod_align_to::<_, [u8; 8]>(bytes);
+        for chunk in chunks {
+            self.write_u64(bytemuck::cast(*chunk));
+        }
+        let (_, chunks, rem) = bytemuck::pod_align_to::<_, [u8; 4]>(rem);
+        for chunk in chunks {
+            self.write_u32(bytemuck::cast(*chunk));
+        }
+        for byte in rem {
+            self.write_u8(*byte);
+        }
+    }
+}
 
 /// An entity describes an element positioned on a [`Scene's`](super::Scene)
 /// [`Layer`](super::Layer) that is meant to be visualized.
-pub enum Entity<P, I> {
+pub enum Entity<P, I, L> {
     /// A path where the inside is filled with the [`FillShader`]. For
     /// determining what's inside the [non-zero fill
     /// rule](https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/fill-rule#nonzero)
@@ -21,10 +78,15 @@ pub enum Entity<P, I> {
     StrokePath(Handle<P>, f32, Rgba, Transform),
     /// An image.
     Image(Handle<I>, Transform),
+    /// A text label.
+    Label(LabelHandle<L>, FillShader, Transform),
 }
 
-pub fn calculate_hash<P, I>(background: &Option<FillShader>, entities: &[Entity<P, I>]) -> u64 {
-    let mut hasher = AHasher::new_with_keys(1234, 5678);
+pub fn calculate_hash<P, I, L>(
+    background: &Option<FillShader>,
+    entities: &[Entity<P, I, L>],
+) -> u64 {
+    let mut hasher = FxHasher(0x517cc1b727220a95);
     mem::discriminant(background).hash(&mut hasher);
     if let Some(background) = background {
         hash_shader(background, &mut hasher);
@@ -33,12 +95,24 @@ pub fn calculate_hash<P, I>(background: &Option<FillShader>, entities: &[Entity<
     hasher.finish()
 }
 
+#[inline]
 fn hash_float(f: f32, state: &mut impl Hasher) {
     u32::hash(&bytemuck::cast(f), state);
 }
 
-fn hash_floats(f: &[f32], state: &mut impl Hasher) {
-    u32::hash_slice(bytemuck::cast_slice(f), state);
+#[inline]
+fn hash_transform(f: &Transform, state: &mut impl Hasher) {
+    const _: () = assert!(core::mem::size_of::<Transform>() == 16);
+    let [a, b]: [u64; 2] = bytemuck::cast(*f);
+    u64::hash(&a, state);
+    u64::hash(&b, state);
+}
+
+#[inline]
+fn hash_floats(f: &[f32; 4], state: &mut impl Hasher) {
+    let [a, b]: [u64; 2] = bytemuck::cast(*f);
+    u64::hash(&a, state);
+    u64::hash(&b, state);
 }
 
 fn hash_shader(shader: &FillShader, state: &mut impl Hasher) {
@@ -56,24 +130,29 @@ fn hash_shader(shader: &FillShader, state: &mut impl Hasher) {
     }
 }
 
-impl<P, I> Hash for Entity<P, I> {
+impl<P, I, L> Hash for Entity<P, I, L> {
     fn hash<H: Hasher>(&self, state: &mut H) {
         mem::discriminant(self).hash(state);
         match self {
             Entity::FillPath(path, shader, transform) => {
                 path.hash(state);
                 hash_shader(shader, state);
-                hash_floats(&transform.to_array(), state);
+                hash_transform(transform, state);
             }
             Entity::StrokePath(path, stroke_width, color, transform) => {
                 path.hash(state);
                 hash_float(*stroke_width, state);
                 hash_floats(color, state);
-                hash_floats(&transform.to_array(), state);
+                hash_transform(transform, state);
             }
             Entity::Image(image, transform) => {
                 image.hash(state);
-                hash_floats(&transform.to_array(), state);
+                hash_transform(transform, state);
+            }
+            Entity::Label(label, shader, transform) => {
+                label.hash(state);
+                hash_shader(shader, state);
+                hash_transform(transform, state);
             }
         }
     }
diff --git a/src/rendering/font/cache.rs b/src/rendering/font/cache.rs
index e6d4b067..c395f260 100644
--- a/src/rendering/font/cache.rs
+++ b/src/rendering/font/cache.rs
@@ -1,106 +1,60 @@
-use super::{Font, GlyphCache, SharedOwnership, TEXT_FONT, TIMER_FONT};
-use crate::settings::{FontStretch, FontStyle, FontWeight};
-
-pub struct CachedFont<P> {
-    #[cfg(feature = "font-loading")]
-    setting: Option<crate::settings::Font>,
-    pub font: Font<'static>,
-    pub glyph_cache: GlyphCache<P>,
+use super::{
+    super::{FontKind, Handle},
+    ResourceAllocator,
+};
+use crate::{layout::LayoutState, settings::Font};
+
+pub struct CachedFont<F> {
+    setting: Option<Font>,
+    pub font: Handle<F>,
 }
 
-impl<P: SharedOwnership> CachedFont<P> {
-    fn new(font: Font<'static>) -> Self {
+impl<F> CachedFont<F> {
+    const fn new(font: Handle<F>) -> Self {
         Self {
-            #[cfg(feature = "font-loading")]
             setting: None,
             font,
-            glyph_cache: GlyphCache::new(),
         }
     }
 
-    #[cfg(feature = "font-loading")]
     fn maybe_reload(
         &mut self,
-        font_to_use: &Option<crate::settings::Font>,
-        default_font: impl FnOnce() -> Font<'static>,
+        allocator: &mut impl ResourceAllocator<Font = Handle<F>>,
+        font_to_use: &Option<Font>,
+        font_kind: FontKind,
     ) {
         if &self.setting != font_to_use {
-            self.font = font_to_use
-                .as_ref()
-                .and_then(Font::load)
-                .unwrap_or_else(default_font);
-            self.glyph_cache.clear();
+            self.font = allocator.create_font(font_to_use.as_ref(), font_kind);
             self.setting.clone_from(font_to_use);
         }
     }
 }
 
-pub struct FontCache<P> {
-    pub timer: CachedFont<P>,
-    pub times: CachedFont<P>,
-    pub text: CachedFont<P>,
+pub struct FontCache<F> {
+    pub timer: CachedFont<F>,
+    pub times: CachedFont<F>,
+    pub text: CachedFont<F>,
 }
 
-impl<P: SharedOwnership> FontCache<P> {
-    pub fn new() -> Option<Self> {
-        Some(Self {
-            timer: CachedFont::new(Font::from_slice(
-                TIMER_FONT,
-                0,
-                FontStyle::Normal,
-                FontWeight::Bold,
-                FontStretch::Normal,
-            )?),
-            times: CachedFont::new(Font::from_slice(
-                TEXT_FONT,
-                0,
-                FontStyle::Normal,
-                FontWeight::Bold,
-                FontStretch::Normal,
-            )?),
-            text: CachedFont::new(Font::from_slice(
-                TEXT_FONT,
-                0,
-                FontStyle::Normal,
-                FontWeight::Normal,
-                FontStretch::Normal,
-            )?),
-        })
+impl<F> FontCache<F> {
+    pub fn new(allocator: &mut impl ResourceAllocator<Font = Handle<F>>) -> Self {
+        Self {
+            timer: CachedFont::new(allocator.create_font(None, FontKind::Timer)),
+            times: CachedFont::new(allocator.create_font(None, FontKind::Times)),
+            text: CachedFont::new(allocator.create_font(None, FontKind::Text)),
+        }
     }
 
-    #[cfg(feature = "font-loading")]
-    pub fn maybe_reload(&mut self, state: &crate::layout::LayoutState) {
-        self.timer.maybe_reload(&state.timer_font, || {
-            Font::from_slice(
-                TIMER_FONT,
-                0,
-                FontStyle::Normal,
-                FontWeight::Bold,
-                FontStretch::Normal,
-            )
-            .unwrap()
-        });
-
-        self.times.maybe_reload(&state.times_font, || {
-            Font::from_slice(
-                TEXT_FONT,
-                0,
-                FontStyle::Normal,
-                FontWeight::Bold,
-                FontStretch::Normal,
-            )
-            .unwrap()
-        });
-
-        self.text.maybe_reload(&state.text_font, || {
-            Font::from_slice(
-                TEXT_FONT,
-                0,
-                FontStyle::Normal,
-                FontWeight::Normal,
-                FontStretch::Normal,
-            )
-            .unwrap()
-        });
+    pub fn maybe_reload(
+        &mut self,
+        allocator: &mut impl ResourceAllocator<Font = Handle<F>>,
+        state: &LayoutState,
+    ) {
+        self.timer
+            .maybe_reload(allocator, &state.timer_font, FontKind::Timer);
+        self.times
+            .maybe_reload(allocator, &state.times_font, FontKind::Times);
+        self.text
+            .maybe_reload(allocator, &state.text_font, FontKind::Text);
     }
 }
diff --git a/src/rendering/font/glyph_cache.rs b/src/rendering/font/glyph_cache.rs
deleted file mode 100644
index c96a23e2..00000000
--- a/src/rendering/font/glyph_cache.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-use std::marker::PhantomData;
-
-use crate::{
-    rendering::resource::{Handle, Handles, PathBuilder, ResourceAllocator, SharedOwnership},
-    settings::Color,
-};
-
-use super::{color_font::iter_colored_glyphs, Font};
-use hashbrown::HashMap;
-use ttf_parser::OutlineBuilder;
-
-struct GlyphBuilder<B, PB>(PB, PhantomData<fn(&mut B)>);
-
-impl<B, PB: PathBuilder<B>> OutlineBuilder for GlyphBuilder<B, PB> {
-    fn move_to(&mut self, x: f32, y: f32) {
-        self.0.move_to(x, -y);
-    }
-    fn line_to(&mut self, x: f32, y: f32) {
-        self.0.line_to(x, -y);
-    }
-    fn quad_to(&mut self, x1: f32, y1: f32, x: f32, y: f32) {
-        self.0.quad_to(x1, -y1, x, -y);
-    }
-    fn curve_to(&mut self, x1: f32, y1: f32, x2: f32, y2: f32, x: f32, y: f32) {
-        self.0.curve_to(x1, -y1, x2, -y2, x, -y);
-    }
-    fn close(&mut self) {
-        self.0.close();
-    }
-}
-
-pub struct GlyphCache<P> {
-    glyphs: HashMap<u32, Vec<(Option<Color>, Handle<P>)>>,
-}
-
-impl<P> Default for GlyphCache<P> {
-    fn default() -> Self {
-        Self {
-            glyphs: Default::default(),
-        }
-    }
-}
-
-impl<P: SharedOwnership> GlyphCache<P> {
-    pub fn new() -> Self {
-        Default::default()
-    }
-
-    #[cfg(feature = "font-loading")]
-    pub fn clear(&mut self) {
-        self.glyphs.clear();
-    }
-
-    pub fn lookup_or_insert(
-        &mut self,
-        font: &Font<'_>,
-        glyph: u32,
-        handles: &mut Handles<impl ResourceAllocator<Path = P>>,
-    ) -> &[(Option<Color>, Handle<P>)] {
-        self.glyphs.entry(glyph).or_insert_with(|| {
-            let mut glyphs = Vec::new();
-            iter_colored_glyphs(&font.color_tables, 0, glyph as _, |glyph, color| {
-                let mut builder = GlyphBuilder(handles.path_builder(), PhantomData);
-                font.outline_glyph(glyph, &mut builder);
-                let path = builder.0.finish(handles);
-                glyphs.push((color, path));
-            });
-            glyphs
-        })
-    }
-}
diff --git a/src/rendering/font/mod.rs b/src/rendering/font/mod.rs
index 320f784d..a5e729fd 100644
--- a/src/rendering/font/mod.rs
+++ b/src/rendering/font/mod.rs
@@ -1,192 +1,45 @@
 mod cache;
-mod color_font;
-mod glyph_cache;
 
-use self::color_font::ColorTables;
 use super::{
-    entity::Entity,
-    resource::{Handles, ResourceAllocator, SharedOwnership},
-    solid, FillShader, Pos, Transform,
+    resource::{LabelHandle, ResourceAllocator},
+    Handle, Label, Pos, Transform,
 };
-use crate::{
-    clear_vec::ClearVec,
-    settings::{FontStretch, FontStyle, FontWeight},
-};
-use rustybuzz::{Face, Feature, GlyphBuffer, Tag, UnicodeBuffer, Variation};
-use ttf_parser::{GlyphId, OutlineBuilder};
-
-pub use self::{cache::FontCache, glyph_cache::GlyphCache};
+use crate::{clear_vec::ClearVec, platform::prelude::*};
 
-#[cfg(feature = "font-loading")]
-use {
-    font_kit::{
-        family_name::FamilyName,
-        handle::Handle,
-        properties::{Properties, Stretch, Style, Weight},
-        source::SystemSource,
-    },
-    std::{fs, sync::Arc},
-};
+pub use self::cache::FontCache;
 
+/// The default font to use for the text and the times.
 pub const TEXT_FONT: &[u8] = include_bytes!("assets/FiraSans-Regular.ttf");
+/// The default font to use for the timer.
 pub const TIMER_FONT: &[u8] = include_bytes!("assets/Timer.ttf");
 
-pub struct Font<'fd> {
-    face: Face<'fd>,
-    color_tables: Option<ColorTables<'fd>>,
-    scale_factor: f32,
-    tabular_digits: TabularDigits,
-    #[cfg(feature = "font-loading")]
-    /// Safety: This can never be mutated. This also needs to be dropped last.
-    _buf: Option<Box<[u8]>>,
-}
-
-impl<'fd> Font<'fd> {
-    #[cfg(feature = "font-loading")]
-    pub fn load(font: &crate::settings::Font) -> Option<Font<'static>> {
-        let handle = SystemSource::new()
-            .select_best_match(
-                &[FamilyName::Title(font.family.clone())],
-                &Properties {
-                    style: match font.style {
-                        FontStyle::Normal => Style::Normal,
-                        FontStyle::Italic => Style::Italic,
-                    },
-                    weight: Weight(font.weight.value()),
-                    stretch: Stretch(font.stretch.factor()),
-                },
-            )
-            .ok()?;
-
-        let (buf, font_index) = match handle {
-            Handle::Path { path, font_index } => (fs::read(path).ok()?, font_index),
-            Handle::Memory { bytes, font_index } => (
-                Arc::try_unwrap(bytes).unwrap_or_else(|bytes| (*bytes).clone()),
-                font_index,
-            ),
-        };
-        let buf = buf.into_boxed_slice();
-
-        // Safety: We store our own buffer. If we never modify it and drop it
-        // last, this is fine. It also needs to be heap allocated, so it's a
-        // stable pointer. This is guaranteed by the boxed slice.
-        unsafe {
-            let slice: *const [u8] = &*buf;
-            let mut font =
-                Font::from_slice(&*slice, font_index, font.style, font.weight, font.stretch)?;
-            font._buf = Some(buf);
-            Some(font)
-        }
-    }
-
-    pub fn from_slice(
-        data: &'fd [u8],
-        index: u32,
-        style: FontStyle,
-        weight: FontWeight,
-        stretch: FontStretch,
-    ) -> Option<Self> {
-        let mut face = Face::from_slice(data, index)?;
-
-        let italic = style.value_for_italic();
-        let weight = weight.value();
-        let stretch = stretch.percentage();
-
-        face.set_variations(&[
-            Variation {
-                tag: Tag::from_bytes(b"ital"),
-                value: italic,
-            },
-            Variation {
-                tag: Tag::from_bytes(b"wght"),
-                value: weight,
-            },
-            Variation {
-                tag: Tag::from_bytes(b"wdth"),
-                value: stretch,
-            },
-        ]);
-
-        // Calculate the tabular digit width and store the glyph IDs for later.
-        let mut digits = [0; 10];
-        let mut digit_width = 0;
-        for (digit, glyph) in digits.iter_mut().enumerate() {
-            let GlyphId(the_glyph) = face
-                .glyph_index(char::from(digit as u8 + b'0'))
-                .unwrap_or_default();
-
-            *glyph = the_glyph as _;
-
-            let width = face
-                .glyph_hor_advance(GlyphId(the_glyph as _))
-                .unwrap_or_default();
-
-            if width > digit_width {
-                digit_width = width;
-            }
-        }
-
-        Some(Self {
-            scale_factor: 1.0 / face.height() as f32,
-            color_tables: ColorTables::new(&face),
-            face,
-            tabular_digits: TabularDigits {
-                width: digit_width as _,
-                digits,
-            },
-            #[cfg(feature = "font-loading")]
-            _buf: None,
-        })
-    }
-
-    pub fn scale(&self, scale: f32) -> ScaledFont<'_> {
-        ScaledFont {
-            font: self,
-            scale: scale * self.scale_factor,
-        }
-    }
-
-    pub fn outline_glyph(&self, glyph_id: u16, builder: &mut dyn OutlineBuilder) -> bool {
-        self.face
-            .outline_glyph(GlyphId(glyph_id), builder)
-            .is_some()
-    }
-}
-
-#[derive(Copy, Clone)]
-pub struct ScaledFont<'f> {
-    font: &'f Font<'f>,
-    scale: f32,
-}
-
-struct TabularDigits {
-    width: f32,
-    digits: [u16; 10],
-}
-
-pub struct AbbreviatedLabel {
+pub struct AbbreviatedLabel<L> {
     abbreviations: ClearVec<String>,
     max_width: f32,
     chosen: String,
-    label: Label,
+    label: CachedLabel<L>,
 }
 
-impl AbbreviatedLabel {
+impl<L> AbbreviatedLabel<L> {
     pub const fn new() -> Self {
         Self {
             abbreviations: ClearVec::new(),
             max_width: 0.0,
             chosen: String::new(),
-            label: Label::new(),
+            label: CachedLabel::new(),
         }
     }
 
-    pub fn update<'a, 'b>(
-        &'a mut self,
-        abbreviations: impl IntoIterator<Item = &'b str> + Clone,
+    pub fn update<'a, F, R: ResourceAllocator<Label = LabelHandle<L>, Font = Handle<F>>>(
+        &mut self,
+        abbreviations: impl IntoIterator<Item = &'a str> + Clone,
+        allocator: &mut R,
+        font: &mut R::Font,
         max_width: f32,
-        font: ScaledFont<'a>,
-    ) -> Glyphs<'a> {
+    ) -> &mut LabelHandle<L>
+    where
+        L: Label,
+    {
         if self
             .abbreviations
             .iter()
@@ -202,7 +55,10 @@ impl AbbreviatedLabel {
 
             let mut abbreviations = self.abbreviations.iter().map(|s| s.as_str());
             let abbreviation = abbreviations.next().unwrap_or("");
-            let width = self.label.update(abbreviation, font).width();
+            let width = self
+                .label
+                .update(abbreviation, allocator, font, None)
+                .width(1.0);
             let (mut total_longest, mut total_longest_width) = (abbreviation, width);
             let (mut within_longest, mut within_longest_width) = if width <= max_width {
                 (abbreviation, width)
@@ -211,7 +67,10 @@ impl AbbreviatedLabel {
             };
 
             for abbreviation in abbreviations {
-                let width = self.label.update(abbreviation, font).width();
+                let width = self
+                    .label
+                    .update(abbreviation, allocator, font, None)
+                    .width(1.0);
                 if width <= max_width && width > within_longest_width {
                     within_longest_width = width;
                     within_longest = abbreviation;
@@ -232,304 +91,102 @@ impl AbbreviatedLabel {
             self.chosen.push_str(chosen);
         }
 
-        self.label.update(&self.chosen, font)
+        self.label
+            .update(&self.chosen, allocator, font, Some(max_width))
     }
 }
 
-pub struct Label {
+pub struct CachedLabel<L> {
     value: String,
-    glyphs: Option<GlyphBuffer>,
+    max_width: Option<f32>,
+    label: Option<LabelHandle<L>>,
+    font_id: usize,
 }
 
-impl Label {
+impl<L> CachedLabel<L> {
     pub const fn new() -> Self {
         Self {
             value: String::new(),
-            glyphs: None,
+            max_width: None,
+            label: None,
+            font_id: 0,
         }
     }
 
-    pub fn update<'a>(&'a mut self, value: &str, font: ScaledFont<'a>) -> Glyphs<'a> {
-        let is_dirty = if self.value != value {
-            self.value.clear();
-            self.value.push_str(value);
-            true
-        } else {
-            self.glyphs.is_none()
-        };
-
-        let buffer = if is_dirty {
-            let mut buffer = self
-                .glyphs
-                .take()
-                .map_or_else(UnicodeBuffer::new, GlyphBuffer::clear);
-
-            buffer.push_str(value.trim());
-
-            self.glyphs
-                .insert(rustybuzz::shape(&font.font.face, &[], buffer))
-        } else {
-            self.glyphs.as_ref().unwrap()
-        };
-
-        Glyphs { font, buffer }
-    }
-
-    pub fn update_tabular_numbers<'a>(
-        &'a mut self,
+    pub fn update<F, R: ResourceAllocator<Label = LabelHandle<L>, Font = Handle<F>>>(
+        &mut self,
         value: &str,
-        font: ScaledFont<'a>,
-    ) -> Glyphs<'a> {
-        let is_dirty = if self.value != value {
+        allocator: &mut R,
+        font: &mut R::Font,
+        max_width: Option<f32>,
+    ) -> &mut LabelHandle<L>
+    where
+        L: Label,
+    {
+        let is_definitely_dirty = self.value != value || self.font_id != font.id;
+        let is_dirty = if is_definitely_dirty || self.max_width != max_width {
+            let is_dirty = is_definitely_dirty
+                || self
+                    .label
+                    .as_ref()
+                    .zip(max_width)
+                    .zip(self.max_width)
+                    .map_or(true, |((l, max_width), old_max_width)| {
+                        // If both the current and old max width fall outside the
+                        // range where the label would need to use ellipsis, then we
+                        // can consider the label to not be dirty.
+                        let width_without_max_width = l.width_without_max_width(1.0);
+                        old_max_width < width_without_max_width
+                            || max_width < width_without_max_width
+                    });
+
             self.value.clear();
             self.value.push_str(value);
-            true
-        } else {
-            self.glyphs.is_none()
-        };
-
-        let buffer = if is_dirty {
-            let mut buffer = self
-                .glyphs
-                .take()
-                .map_or_else(UnicodeBuffer::new, GlyphBuffer::clear);
-
-            buffer.push_str(value.trim());
-
-            self.glyphs.insert(rustybuzz::shape(
-                &font.font.face,
-                &[
-                    // If the font has support for tabular numbers, we want to
-                    // use it, so we don't have to fix up much. Though we still
-                    // attempt to do so anyway, as we can neither query if tnum
-                    // support is even available, nor can we really trust it all
-                    // too much.
-                    Feature::new(Tag::from_bytes(b"tnum"), 1, ..),
-                    // FIXME: We may or may not want to disable kerning and
-                    // possibly ligatures too. If the font doesn't support tnum,
-                    // then kerning for e.g. `.1` may cause inconsistent
-                    // positioning.
-                    // Feature::new(Tag::from_bytes(b"kern"), 0, ..),
-                ],
-                buffer,
-            ))
-        } else {
-            self.glyphs.as_ref().unwrap()
-        };
-
-        Glyphs { font, buffer }
-    }
-}
-
-#[derive(Copy, Clone)]
-pub struct PositionedGlyph {
-    id: u32,
-    x: f32,
-    y: f32,
-}
-
-pub struct Cursor {
-    pub x: f32,
-    pub y: f32,
-}
-
-impl Cursor {
-    pub const fn new([x, y]: Pos) -> Self {
-        Self { x, y }
-    }
-}
-
-pub struct Glyphs<'fl> {
-    pub font: ScaledFont<'fl>,
-    buffer: &'fl GlyphBuffer,
-}
-
-impl<'fl> Glyphs<'fl> {
-    pub fn left_aligned<'a>(
-        &'a self,
-        cursor: &'a mut Cursor,
-        max_x: f32,
-    ) -> impl Iterator<Item = PositionedGlyph> + 'a {
-        let scale = self.font.scale;
-
-        let mut iter = Iterator::zip(
-            self.buffer.glyph_infos().iter(),
-            self.buffer.glyph_positions().iter(),
-        );
-
-        let ends_at_x = cursor.x + self.width();
-        let ellipsis = if ends_at_x > max_x {
-            let ellipsis = self.font.font.face.glyph_index('…').unwrap_or_default();
-            let ellipsis_width = self
-                .font
-                .font
-                .face
-                .glyph_hor_advance(ellipsis)
-                .unwrap_or_default() as i32;
-
-            let overshoot_width = ((ends_at_x - max_x) / scale) as i32;
-
-            let width_to_cut_off = ellipsis_width + overshoot_width;
-            let mut actually_cut_off = 0;
-
-            iter.by_ref().rev().find(|(_, p)| {
-                actually_cut_off += p.x_advance;
-                actually_cut_off >= width_to_cut_off
-            });
-
-            let x = ends_at_x - actually_cut_off as f32 * scale;
+            self.max_width = max_width;
+            self.font_id = font.id;
 
-            Some(PositionedGlyph {
-                id: ellipsis.0 as _,
-                x,
-                y: cursor.y,
-            })
+            is_dirty
         } else {
-            None
+            self.label.is_none()
         };
 
-        iter.map(move |(i, p)| {
-            let g = PositionedGlyph {
-                id: i.glyph_id,
-                x: cursor.x + p.x_offset as f32 * scale,
-                y: cursor.y + p.y_offset as f32 * scale,
-            };
-            cursor.x += p.x_advance as f32 * scale;
-            cursor.y += p.y_advance as f32 * scale;
-            g
-        })
-        .chain(ellipsis)
-    }
-
-    pub fn right_aligned<'a>(
-        &'a self,
-        cursor: &'a mut Cursor,
-    ) -> impl Iterator<Item = PositionedGlyph> + 'a {
-        let scale = self.font.scale;
+        if is_dirty {
+            let text = self.value.trim();
 
-        Iterator::zip(
-            self.buffer.glyph_infos().iter(),
-            self.buffer.glyph_positions().iter(),
-        )
-        .rev()
-        .map(move |(i, p)| {
-            cursor.x -= p.x_advance as f32 * scale;
-            cursor.y -= p.y_advance as f32 * scale;
-            PositionedGlyph {
-                id: i.glyph_id,
-                x: cursor.x + p.x_offset as f32 * scale,
-                y: cursor.y + p.y_offset as f32 * scale,
+            if let Some(label) = &mut self.label {
+                allocator.update_label(label, text, font, max_width);
+            } else {
+                self.label = Some(allocator.create_label(&self.value, font, max_width));
             }
-        })
-    }
-
-    pub fn centered<'a>(
-        &'a self,
-        cursor: &'a mut Cursor,
-        min_x: f32,
-        max_x: f32,
-    ) -> impl Iterator<Item = PositionedGlyph> + 'a {
-        let (mut adv_x, mut adv_y) = (0, 0);
-
-        for p in self.buffer.glyph_positions() {
-            adv_x += p.x_advance;
-            adv_y += p.y_advance;
-        }
-
-        let width = adv_x as f32 * self.font.scale;
-
-        // Since we want to delegate to left aligned, we calculate the left
-        // coordinates.
-        cursor.x -= width / 2.0;
-        cursor.y -= adv_y as f32 * self.font.scale / 2.0;
-
-        // However, we may overlap on the right. In that case, we want to align
-        // to the right instead.
-        if cursor.x + width >= max_x {
-            // Small epsilon, because we still call the left aligned function.
-            // Due to floating point precision issues this may be considered too
-            // far to the right and may cause the text to have ellipsis.
-            cursor.x -= cursor.x + width - max_x + (5.0 * std::f32::EPSILON);
         }
 
-        // However if we are too far to the left, we align it to the minimum
-        // left position.
-        if cursor.x < min_x {
-            cursor.x = min_x;
-        }
-
-        self.left_aligned(cursor, max_x)
+        self.label.as_mut().unwrap()
     }
+}
 
-    // This is a right aligned layout where all the digits have the same width.
-    pub fn tabular_numbers<'a>(
-        &'a self,
-        cursor: &'a mut Cursor,
-    ) -> impl Iterator<Item = PositionedGlyph> + 'a {
-        // FIXME: There's kerning between e.g. ".1" now, which is maybe not quite
-        // what we want. We may need to either stabilize `:` and `.` now or turn
-        // off kerning for tabular numbers.
-
-        let scale = self.font.scale;
-
-        let digits = &self.font.font.tabular_digits;
-        let digit_width = digits.width * self.font.scale;
-        Iterator::zip(
-            self.buffer.glyph_infos().iter(),
-            self.buffer.glyph_positions().iter(),
-        )
-        .rev()
-        .map(move |(i, p)| {
-            let x = if digits.digits.contains(&(i.glyph_id as _)) {
-                cursor.x -= digit_width;
-                let wider_by = digit_width - (p.x_advance as f32 * scale);
-                cursor.x + p.x_offset as f32 * scale + 0.5 * wider_by
-            } else {
-                cursor.x -= p.x_advance as f32 * scale;
-                cursor.x + p.x_offset as f32 * scale
-            };
-
-            cursor.y -= p.y_advance as f32 * scale;
-            PositionedGlyph {
-                id: i.glyph_id,
-                x,
-                y: cursor.y + p.y_offset as f32 * scale,
-            }
-        })
-    }
+pub fn left_aligned(transform: &Transform, [x, y]: Pos, scale: f32) -> Transform {
+    transform.pre_translate(x, y).pre_scale(scale, scale)
+}
 
-    pub fn width(&self) -> f32 {
-        self.buffer
-            .glyph_positions()
-            .iter()
-            .map(|p| p.x_advance)
-            .sum::<i32>() as f32
-            * self.font.scale
-    }
+pub fn right_aligned(transform: &Transform, [x, y]: Pos, scale: f32, width: f32) -> Transform {
+    transform
+        .pre_translate(x - width, y)
+        .pre_scale(scale, scale)
 }
 
-pub fn render<A: ResourceAllocator>(
-    layout: impl IntoIterator<Item = PositionedGlyph>,
-    shader: FillShader,
-    font: &ScaledFont<'_>,
-    glyph_cache: &mut GlyphCache<A::Path>,
+pub fn centered(
     transform: &Transform,
-    handles: &mut Handles<A>,
-    entities: &mut Vec<Entity<A::Path, A::Image>>,
-) {
-    for glyph in layout {
-        let layers = glyph_cache.lookup_or_insert(font.font, glyph.id, handles);
-
-        let transform = transform
-            .pre_translate(glyph.x, glyph.y)
-            .pre_scale(font.scale, font.scale);
-
-        for (color, layer) in layers {
-            entities.push(Entity::FillPath(
-                layer.share(),
-                color.as_ref().map_or(shader, solid),
-                transform,
-            ));
-        }
-    }
+    [x, y]: Pos,
+    scale: f32,
+    width: f32,
+    min_x: f32,
+    max_x: f32,
+) -> Transform {
+    let mut x = x - 0.5 * width;
+    if x < min_x {
+        x = min_x;
+    } else if x + width > max_x {
+        x = max_x - width;
+    }
+    transform.pre_translate(x, y).pre_scale(scale, scale)
 }
diff --git a/src/rendering/mod.rs b/src/rendering/mod.rs
index b6963c62..f5e336de 100644
--- a/src/rendering/mod.rs
+++ b/src/rendering/mod.rs
@@ -1,12 +1,12 @@
-//! The rendering module provides a [`SceneManager`] that, when provided with a
+//! The rendering module provides a [`SceneManager`], that when provided with a
 //! [`LayoutState`], places [`Entities`](Entity) into a [`Scene`] and updates it
 //! accordingly as the [`LayoutState`] changes. It is up to a specific renderer
 //! to then take the [`Scene`] and render out the [`Entities`](Entity). There is
 //! a [`ResourceAllocator`] trait that defines the types of resources an
 //! [`Entity`] consists of. A specific renderer can then provide an
 //! implementation that provides the resources it can render out. Those
-//! resources are images and paths, i.e. lines, quadratic and cubic bezier
-//! curves. An optional software renderer is available behind the
+//! resources are images, paths, i.e. lines, quadratic and cubic bezier curves,
+//! fonts and labels. An optional software renderer is available behind the
 //! `software-rendering` feature that uses tiny-skia to efficiently render the
 //! paths on the CPU. It is surprisingly fast and can be considered the default
 //! renderer.
@@ -78,6 +78,9 @@ mod icon;
 mod resource;
 mod scene;
 
+#[cfg(feature = "path-based-text-engine")]
+pub mod path_based_text_engine;
+
 #[cfg(feature = "software-rendering")]
 pub mod software;
 
@@ -86,20 +89,25 @@ use self::{
         DEFAULT_TEXT_SIZE, DEFAULT_VERTICAL_WIDTH, PADDING, TEXT_ALIGN_BOTTOM, TEXT_ALIGN_TOP,
         TWO_ROW_HEIGHT,
     },
-    font::{AbbreviatedLabel, FontCache, Label},
+    font::{AbbreviatedLabel, CachedLabel, FontCache},
     icon::Icon,
     resource::Handles,
 };
 use crate::{
     layout::{LayoutDirection, LayoutState},
+    platform::prelude::*,
     settings::{Color, Gradient},
 };
 use alloc::borrow::Cow;
+use bytemuck::{Pod, Zeroable};
 use core::iter;
 
 pub use self::{
     entity::Entity,
-    resource::{Handle, PathBuilder, ResourceAllocator, SharedOwnership},
+    font::{TEXT_FONT, TIMER_FONT},
+    resource::{
+        FontKind, Handle, Label, LabelHandle, PathBuilder, ResourceAllocator, SharedOwnership,
+    },
     scene::{Layer, Scene},
 };
 
@@ -111,7 +119,8 @@ pub type Rgba = [f32; 4];
 
 /// A transformation to apply to the entities in order to place them into the
 /// scene.
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Pod, Zeroable)]
+#[repr(C)]
 pub struct Transform {
     /// Scale the x coordinate by this value.
     pub scale_x: f32,
@@ -147,39 +156,43 @@ enum CachedSize {
 /// [`ResourceAllocator`] trait that defines the types of resources an
 /// [`Entity`] consists of. A specific renderer can then provide an
 /// implementation that provides the resources it can render out. Those
-/// resources are images and paths, i.e. lines, quadratic and cubic bezier
-/// curves.
-pub struct SceneManager<P, I> {
-    scene: Scene<P, I>,
-    fonts: FontCache<P>,
-    components: Vec<component::Cache<I>>,
+/// resources are images, paths, i.e. lines, quadratic and cubic bezier
+/// curves, fonts and labels.
+pub struct SceneManager<P, I, F, L> {
+    scene: Scene<P, I, L>,
+    components: Vec<component::Cache<I, L>>,
     next_id: usize,
     cached_size: Option<CachedSize>,
+    fonts: FontCache<F>,
 }
 
-impl<P: SharedOwnership, I: SharedOwnership> SceneManager<P, I> {
+impl<P: SharedOwnership, I: SharedOwnership, F, L: SharedOwnership> SceneManager<P, I, F, L> {
     /// Creates a new scene manager.
-    pub fn new(mut allocator: impl ResourceAllocator<Path = P, Image = I>) -> Self {
+    pub fn new(
+        mut allocator: impl ResourceAllocator<Path = P, Image = I, Font = F, Label = L>,
+    ) -> Self {
         let mut builder = allocator.path_builder();
         builder.move_to(0.0, 0.0);
         builder.line_to(0.0, 1.0);
         builder.line_to(1.0, 1.0);
         builder.line_to(1.0, 0.0);
         builder.close();
-        let rectangle = Handle::new(0, builder.finish(&mut allocator));
+        let rectangle = Handle::new(0, builder.finish());
+
+        let mut handles = Handles::new(1, allocator);
+        let fonts = FontCache::new(&mut handles);
 
         Self {
-            fonts: FontCache::new().unwrap(),
             components: Vec::new(),
-            // We use 0 for the rectangle.
-            next_id: 1,
+            next_id: handles.into_next_id(),
             scene: Scene::new(rectangle),
             cached_size: None,
+            fonts,
         }
     }
 
     /// Accesses the [`Scene`] in order to render the [`Entities`](Entity).
-    pub fn scene(&self) -> &Scene<P, I> {
+    pub fn scene(&self) -> &Scene<P, I, L> {
         &self.scene
     }
 
@@ -191,15 +204,12 @@ impl<P: SharedOwnership, I: SharedOwnership> SceneManager<P, I> {
     /// change in the layout size is detected, a new more suitable resolution
     /// for subsequent updates is being returned. This is however merely a hint
     /// and can be completely ignored.
-    pub fn update_scene<A: ResourceAllocator<Path = P, Image = I>>(
+    pub fn update_scene<A: ResourceAllocator<Path = P, Image = I, Font = F, Label = L>>(
         &mut self,
         allocator: A,
         resolution: (f32, f32),
         state: &LayoutState,
     ) -> Option<(f32, f32)> {
-        #[cfg(feature = "font-loading")]
-        self.fonts.maybe_reload(state);
-
         self.scene.clear();
 
         self.scene
@@ -225,7 +235,7 @@ impl<P: SharedOwnership, I: SharedOwnership> SceneManager<P, I> {
 
     fn render_vertical(
         &mut self,
-        allocator: impl ResourceAllocator<Path = P, Image = I>,
+        allocator: impl ResourceAllocator<Path = P, Image = I, Font = F, Label = L>,
         resolution: (f32, f32),
         state: &LayoutState,
     ) -> Option<(f32, f32)> {
@@ -264,6 +274,8 @@ impl<P: SharedOwnership, I: SharedOwnership> SceneManager<P, I> {
             fonts: &mut self.fonts,
         };
 
+        context.fonts.maybe_reload(&mut context.handles, state);
+
         // Now we transform the coordinate space to Renderer Coordinate Space by
         // non-uniformly adjusting for the aspect ratio.
         context.scale_non_uniform_x(aspect_ratio.recip());
@@ -294,7 +306,7 @@ impl<P: SharedOwnership, I: SharedOwnership> SceneManager<P, I> {
 
     fn render_horizontal(
         &mut self,
-        allocator: impl ResourceAllocator<Path = P, Image = I>,
+        allocator: impl ResourceAllocator<Path = P, Image = I, Font = F, Label = L>,
         resolution: (f32, f32),
         state: &LayoutState,
     ) -> Option<(f32, f32)> {
@@ -332,6 +344,8 @@ impl<P: SharedOwnership, I: SharedOwnership> SceneManager<P, I> {
             fonts: &mut self.fonts,
         };
 
+        context.fonts.maybe_reload(&mut context.handles, state);
+
         // Now we transform the coordinate space to Renderer Coordinate Space by
         // non-uniformly adjusting for the aspect ratio.
         context.scale_non_uniform_x(aspect_ratio.recip());
@@ -368,8 +382,8 @@ impl<P: SharedOwnership, I: SharedOwnership> SceneManager<P, I> {
 struct RenderContext<'b, A: ResourceAllocator> {
     transform: Transform,
     handles: Handles<A>,
-    scene: &'b mut Scene<A::Path, A::Image>,
-    fonts: &'b mut FontCache<A::Path>,
+    scene: &'b mut Scene<A::Path, A::Image, A::Label>,
+    fonts: &'b mut FontCache<A::Font>,
 }
 
 impl<A: ResourceAllocator> RenderContext<'_, A> {
@@ -500,9 +514,9 @@ impl<A: ResourceAllocator> RenderContext<'_, A> {
         &mut self,
         key: &str,
         abbreviations: &[Cow<'_, str>],
-        key_label: &mut AbbreviatedLabel,
+        key_label: &mut AbbreviatedLabel<A::Label>,
         value: &str,
-        value_label: &mut Label,
+        value_label: &mut CachedLabel<A::Label>,
         updates_frequently: bool,
         [width, height]: [f32; 2],
         key_color: Color,
@@ -536,142 +550,140 @@ impl<A: ResourceAllocator> RenderContext<'_, A> {
     fn render_abbreviated_text_ellipsis<'a>(
         &mut self,
         abbreviations: impl IntoIterator<Item = &'a str> + Clone,
-        label: &mut AbbreviatedLabel,
+        label: &mut AbbreviatedLabel<A::Label>,
         pos @ [x, _]: Pos,
         scale: f32,
         shader: FillShader,
         max_x: f32,
     ) -> f32 {
-        let mut cursor = font::Cursor::new(pos);
-
-        let font = self.fonts.text.font.scale(scale);
-        let max_width = max_x - x;
-        let glyphs = label.update(abbreviations, max_width, font);
-
-        font::render(
-            glyphs.left_aligned(&mut cursor, max_x),
-            shader,
-            &font,
-            &mut self.fonts.text.glyph_cache,
-            &self.transform,
+        let label = label.update(
+            abbreviations,
             &mut self.handles,
-            self.scene.bottom_layer_mut(),
+            &mut self.fonts.text.font,
+            (max_x - x) / scale,
         );
 
-        cursor.x
+        self.scene.bottom_layer_mut().push(Entity::Label(
+            label.share(),
+            shader,
+            font::left_aligned(&self.transform, pos, scale),
+        ));
+
+        x + label.width(scale)
     }
 
     fn render_text_ellipsis(
         &mut self,
         text: &str,
-        label: &mut Label,
-        pos: Pos,
+        label: &mut CachedLabel<A::Label>,
+        pos @ [x, _]: Pos,
         scale: f32,
         shader: FillShader,
         max_x: f32,
     ) -> f32 {
-        let mut cursor = font::Cursor::new(pos);
-
-        let font = self.fonts.text.font.scale(scale);
-        let glyphs = label.update(text, font);
-
-        font::render(
-            glyphs.left_aligned(&mut cursor, max_x),
-            shader,
-            &font,
-            &mut self.fonts.text.glyph_cache,
-            &self.transform,
+        let label = label.update(
+            text,
             &mut self.handles,
-            self.scene.bottom_layer_mut(),
+            &mut self.fonts.text.font,
+            Some((max_x - x) / scale),
         );
 
-        cursor.x
+        self.scene.bottom_layer_mut().push(Entity::Label(
+            label.share(),
+            shader,
+            font::left_aligned(&self.transform, pos, scale),
+        ));
+
+        x + label.width(scale)
     }
 
     fn render_text_centered(
         &mut self,
         text: &str,
-        label: &mut Label,
+        label: &mut CachedLabel<A::Label>,
         min_x: f32,
         max_x: f32,
         pos: Pos,
         scale: f32,
         shader: FillShader,
     ) {
-        let mut cursor = font::Cursor::new(pos);
-
-        let font = self.fonts.text.font.scale(scale);
-        let glyphs = label.update(text, font);
-
-        font::render(
-            glyphs.centered(&mut cursor, min_x, max_x),
-            shader,
-            &font,
-            &mut self.fonts.text.glyph_cache,
-            &self.transform,
+        let label = label.update(
+            text,
             &mut self.handles,
-            self.scene.bottom_layer_mut(),
+            &mut self.fonts.text.font,
+            Some((max_x - min_x) / scale),
         );
+
+        self.scene.bottom_layer_mut().push(Entity::Label(
+            label.share(),
+            shader,
+            font::centered(
+                &self.transform,
+                pos,
+                scale,
+                label.width(scale),
+                min_x,
+                max_x,
+            ),
+        ));
     }
 
     fn render_abbreviated_text_centered<'a>(
         &mut self,
         abbreviations: impl IntoIterator<Item = &'a str> + Clone,
-        label: &mut AbbreviatedLabel,
+        label: &mut AbbreviatedLabel<A::Label>,
         min_x: f32,
         max_x: f32,
         pos: Pos,
         scale: f32,
         shader: FillShader,
     ) {
-        let mut cursor = font::Cursor::new(pos);
-
-        let font = self.fonts.text.font.scale(scale);
-        let max_width = max_x - min_x;
-        let glyphs = label.update(abbreviations, max_width, font);
-
-        font::render(
-            glyphs.centered(&mut cursor, min_x, max_x),
-            shader,
-            &font,
-            &mut self.fonts.text.glyph_cache,
-            &self.transform,
+        let label = label.update(
+            abbreviations,
             &mut self.handles,
-            self.scene.bottom_layer_mut(),
+            &mut self.fonts.text.font,
+            (max_x - min_x) / scale,
         );
+
+        self.scene.bottom_layer_mut().push(Entity::Label(
+            label.share(),
+            shader,
+            font::centered(
+                &self.transform,
+                pos,
+                scale,
+                label.width(scale),
+                min_x,
+                max_x,
+            ),
+        ));
     }
 
     fn render_text_right_align(
         &mut self,
         text: &str,
-        label: &mut Label,
+        label: &mut CachedLabel<A::Label>,
         layer: Layer,
-        pos: Pos,
+        pos @ [x, _]: Pos,
         scale: f32,
         shader: FillShader,
     ) -> f32 {
-        let mut cursor = font::Cursor::new(pos);
-
-        let font = self.fonts.text.font.scale(scale);
-        let glyphs = label.update(text, font);
+        let label = label.update(text, &mut self.handles, &mut self.fonts.text.font, None);
+        let width = label.width(scale);
 
-        font::render(
-            glyphs.right_aligned(&mut cursor),
+        self.scene.layer_mut(layer).push(Entity::Label(
+            label.share(),
             shader,
-            &font,
-            &mut self.fonts.text.glyph_cache,
-            &self.transform,
-            &mut self.handles,
-            self.scene.layer_mut(layer),
-        );
+            font::right_aligned(&self.transform, pos, scale, width),
+        ));
 
-        cursor.x
+        x - width
     }
 
     fn render_abbreviated_text_align<'a>(
         &mut self,
         abbreviations: impl IntoIterator<Item = &'a str> + Clone,
-        label: &mut AbbreviatedLabel,
+        label: &mut AbbreviatedLabel<A::Label>,
         min_x: f32,
         max_x: f32,
         pos: Pos,
@@ -697,67 +709,53 @@ impl<A: ResourceAllocator> RenderContext<'_, A> {
     fn render_numbers(
         &mut self,
         text: &str,
-        label: &mut Label,
+        label: &mut CachedLabel<A::Label>,
         layer: Layer,
-        pos: Pos,
+        pos @ [x, _]: Pos,
         scale: f32,
         shader: FillShader,
     ) -> f32 {
-        let mut cursor = font::Cursor::new(pos);
-
-        let font = self.fonts.times.font.scale(scale);
-        let glyphs = label.update_tabular_numbers(text, font);
+        let label = label.update(text, &mut self.handles, &mut self.fonts.times.font, None);
+        let width = label.width(scale);
 
-        font::render(
-            glyphs.tabular_numbers(&mut cursor),
+        self.scene.layer_mut(layer).push(Entity::Label(
+            label.share(),
             shader,
-            &font,
-            &mut self.fonts.times.glyph_cache,
-            &self.transform,
-            &mut self.handles,
-            self.scene.layer_mut(layer),
-        );
+            font::right_aligned(&self.transform, pos, scale, width),
+        ));
 
-        cursor.x
+        x - width
     }
 
     fn render_timer(
         &mut self,
         text: &str,
-        label: &mut Label,
+        label: &mut CachedLabel<A::Label>,
         layer: Layer,
-        pos: Pos,
+        pos @ [x, _]: Pos,
         scale: f32,
         shader: FillShader,
     ) -> f32 {
-        let mut cursor = font::Cursor::new(pos);
-
-        let font = self.fonts.timer.font.scale(scale);
-        let glyphs = label.update_tabular_numbers(text, font);
+        let label = label.update(text, &mut self.handles, &mut self.fonts.timer.font, None);
+        let width = label.width(scale);
 
-        font::render(
-            glyphs.tabular_numbers(&mut cursor),
+        self.scene.layer_mut(layer).push(Entity::Label(
+            label.share(),
             shader,
-            &font,
-            &mut self.fonts.timer.glyph_cache,
-            &self.transform,
-            &mut self.handles,
-            self.scene.layer_mut(layer),
-        );
+            font::right_aligned(&self.transform, pos, scale, width),
+        ));
 
-        cursor.x
+        x - width
     }
 
-    fn measure_numbers(&mut self, text: &str, label: &mut Label, scale: f32) -> f32 {
-        let mut cursor = font::Cursor::new([0.0; 2]);
-
-        let glyphs = label.update_tabular_numbers(text, self.fonts.times.font.scale(scale));
-
-        // Iterate over all glyphs, to move the cursor forward.
-        glyphs.tabular_numbers(&mut cursor).for_each(drop);
-
-        // Wherever we end up is our width.
-        -cursor.x
+    fn measure_numbers(
+        &mut self,
+        text: &str,
+        label: &mut CachedLabel<A::Label>,
+        scale: f32,
+    ) -> f32 {
+        let label = label.update(text, &mut self.handles, &mut self.fonts.times.font, None);
+        label.width(scale)
     }
 }
 
@@ -788,7 +786,8 @@ impl Transform {
         }
     }
 
-    fn pre_scale(&self, scale_x: f32, scale_y: f32) -> Transform {
+    /// Returns a new transform that first scales the coordinates.
+    pub fn pre_scale(&self, scale_x: f32, scale_y: f32) -> Transform {
         Self {
             scale_x: self.scale_x * scale_x,
             scale_y: self.scale_y * scale_y,
@@ -797,7 +796,8 @@ impl Transform {
         }
     }
 
-    fn pre_translate(&self, x: f32, y: f32) -> Transform {
+    /// Returns a new transform that first translates the coordinates.
+    pub fn pre_translate(&self, x: f32, y: f32) -> Transform {
         Self {
             scale_x: self.scale_x,
             scale_y: self.scale_y,
@@ -806,10 +806,6 @@ impl Transform {
         }
     }
 
-    const fn to_array(&self) -> [f32; 4] {
-        [self.x, self.y, self.scale_x, self.scale_y]
-    }
-
     fn transform_y(&self, y: f32) -> f32 {
         self.y + self.scale_y * y
     }
diff --git a/src/rendering/font/color_font/colr.rs b/src/rendering/path_based_text_engine/color_font/colr.rs
similarity index 100%
rename from src/rendering/font/color_font/colr.rs
rename to src/rendering/path_based_text_engine/color_font/colr.rs
diff --git a/src/rendering/font/color_font/cpal.rs b/src/rendering/path_based_text_engine/color_font/cpal.rs
similarity index 100%
rename from src/rendering/font/color_font/cpal.rs
rename to src/rendering/path_based_text_engine/color_font/cpal.rs
diff --git a/src/rendering/font/color_font/mod.rs b/src/rendering/path_based_text_engine/color_font/mod.rs
similarity index 86%
rename from src/rendering/font/color_font/mod.rs
rename to src/rendering/path_based_text_engine/color_font/mod.rs
index d07f2b26..71bacfad 100644
--- a/src/rendering/font/color_font/mod.rs
+++ b/src/rendering/path_based_text_engine/color_font/mod.rs
@@ -1,4 +1,4 @@
-use ttf_parser::{Face, Tag};
+use ttf_parser::{Face, GlyphId, Tag};
 
 use crate::settings::Color;
 
@@ -41,15 +41,15 @@ impl<'f> ColorTables<'f> {
 pub fn iter_colored_glyphs(
     color_tables: &Option<ColorTables<'_>>,
     palette: usize,
-    glyph: u16,
-    mut f: impl FnMut(u16, Option<Color>),
+    glyph: GlyphId,
+    mut f: impl FnMut(GlyphId, Option<Color>),
 ) {
     if let Some(iter) = color_tables
         .as_ref()
-        .and_then(|c| c.look_up(palette, glyph))
+        .and_then(|c| c.look_up(palette, glyph.0))
     {
         for (glyph, color) in iter {
-            f(glyph, color);
+            f(GlyphId(glyph), color);
         }
     } else {
         f(glyph, None)
diff --git a/src/rendering/font/color_font/parse_util.rs b/src/rendering/path_based_text_engine/color_font/parse_util.rs
similarity index 100%
rename from src/rendering/font/color_font/parse_util.rs
rename to src/rendering/path_based_text_engine/color_font/parse_util.rs
diff --git a/src/rendering/path_based_text_engine/mod.rs b/src/rendering/path_based_text_engine/mod.rs
new file mode 100644
index 00000000..7f584abc
--- /dev/null
+++ b/src/rendering/path_based_text_engine/mod.rs
@@ -0,0 +1,458 @@
+//! An optional path based text engine is provided that allows you to create
+//! fonts and manage text labels that are based on paths. That way the
+//! underlying renderer doesn't by itself need to be able to render text, as all
+//! the text gets turned into paths.
+
+use std::{fs, sync::Arc};
+
+#[cfg(feature = "font-loading")]
+use font_kit::{
+    family_name::FamilyName,
+    handle::Handle,
+    properties::{Properties, Stretch, Style, Weight},
+    source::SystemSource,
+};
+use hashbrown::HashMap;
+use parking_lot::{const_rwlock, RwLock};
+use rustybuzz::{Face, Feature, Tag, UnicodeBuffer, Variation};
+use ttf_parser::{GlyphId, OutlineBuilder};
+
+use super::{
+    font::{TEXT_FONT, TIMER_FONT},
+    FontKind, PathBuilder, Rgba, SharedOwnership,
+};
+use crate::settings::{self, FontStretch, FontStyle, FontWeight};
+
+use self::color_font::{iter_colored_glyphs, ColorTables};
+
+mod color_font;
+
+/// The path based text engine allows you to create fonts and manage text labels
+/// that are based on paths. That way the underlying renderer doesn't by itself
+/// need to be able to render text, as all the text gets turned into paths.
+pub struct TextEngine {
+    #[cfg(feature = "font-loading")]
+    source: SystemSource,
+    buffer: Option<UnicodeBuffer>,
+}
+
+impl Default for TextEngine {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl TextEngine {
+    /// Creates a new path based text engine.
+    pub fn new() -> Self {
+        Self {
+            #[cfg(feature = "font-loading")]
+            source: SystemSource::new(),
+            buffer: None,
+        }
+    }
+
+    /// Creates a new font. You can call this directly from a
+    /// [`ResourceAllocator`](super::ResourceAllocator).
+    pub fn create_font<P>(&mut self, font: Option<&settings::Font>, kind: FontKind) -> Font<P> {
+        #[cfg(feature = "font-loading")]
+        if let Some(font) = font {
+            if let Some(font) = Font::try_load_font(&mut self.source, font, kind) {
+                return font;
+            }
+        }
+        let (font_data, style, weight, stretch) = match kind {
+            FontKind::Timer => (
+                TIMER_FONT,
+                FontStyle::Normal,
+                FontWeight::Bold,
+                FontStretch::Normal,
+            ),
+            FontKind::Times => (
+                TEXT_FONT,
+                FontStyle::Normal,
+                FontWeight::Bold,
+                FontStretch::Normal,
+            ),
+            FontKind::Text => (
+                TEXT_FONT,
+                FontStyle::Normal,
+                FontWeight::Normal,
+                FontStretch::Normal,
+            ),
+        };
+        Font::from_slice(font_data, 0, style, weight, stretch, kind).unwrap()
+    }
+
+    /// Creates a new text label. You can call this directly from a
+    /// [`ResourceAllocator`](super::ResourceAllocator).
+    pub fn create_label<PB: PathBuilder>(
+        &mut self,
+        path_builder: impl FnMut() -> PB,
+        text: &str,
+        font: &mut Font<PB::Path>,
+        max_width: Option<f32>,
+    ) -> Label<PB::Path> {
+        let mut label = Arc::new(const_rwlock(LockedLabel {
+            width: 0.0,
+            width_without_max_width: 0.0,
+            scale: 0.0,
+            glyphs: Vec::new(),
+        }));
+
+        self.update_label(path_builder, &mut label, text, font, max_width);
+
+        label
+    }
+
+    /// Updates a text label. You can call this directly from a
+    /// [`ResourceAllocator`](super::ResourceAllocator).
+    pub fn update_label<PB: PathBuilder>(
+        &mut self,
+        mut path_builder: impl FnMut() -> PB,
+        label: &mut Label<PB::Path>,
+        text: &str,
+        font: &mut Font<PB::Path>,
+        max_width: Option<f32>,
+    ) {
+        let mut label = label.write();
+        let label = &mut *label;
+
+        let mut buffer = self.buffer.take().unwrap_or_else(UnicodeBuffer::new);
+        buffer.push_str(text);
+
+        let features = font
+            .monotonic
+            .as_ref()
+            .map(|m| &m.features[..])
+            .unwrap_or_default();
+
+        let buffer = rustybuzz::shape(&font.face, features, buffer);
+
+        let iter = Iterator::zip(buffer.glyph_infos().iter(), buffer.glyph_positions().iter());
+
+        let (mut x, mut y) = (0.0, 0.0);
+
+        label.glyphs.clear();
+
+        if let Some(monotonic) = &font.monotonic {
+            iter.for_each(|(info, pos)| {
+                let glyph = GlyphId(info.glyph_id as _);
+                let layer_glyphs = font.glyph_cache.entry(glyph).or_insert_with(|| {
+                    let mut glyphs = Vec::new();
+                    iter_colored_glyphs(&font.color_tables, 0, glyph, |glyph, color| {
+                        let mut builder = GlyphBuilder(path_builder());
+                        font.face.outline_glyph(glyph, &mut builder);
+                        let path = builder.0.finish();
+                        glyphs.push((color.map(|c| c.to_array()), path));
+                    });
+                    glyphs
+                });
+                let (x_advance, x_offset) =
+                    if monotonic.digit_glyphs.contains(&(info.glyph_id as u16)) {
+                        (
+                            monotonic.digit_width,
+                            0.5 * (monotonic.digit_width - pos.x_advance as f32)
+                                + pos.x_offset as f32,
+                        )
+                    } else {
+                        (pos.x_advance as f32, pos.x_offset as f32)
+                    };
+                let (glyph_x, glyph_y) = (x + x_offset, y + pos.y_offset as f32);
+                x += x_advance;
+                y += pos.y_advance as f32;
+                label
+                    .glyphs
+                    .extend(layer_glyphs.iter().map(|(color, path)| Glyph {
+                        color: *color,
+                        x: glyph_x,
+                        y: glyph_y,
+                        path: path.share(),
+                    }));
+            });
+        } else {
+            iter.for_each(|(info, pos)| {
+                let glyph = GlyphId(info.glyph_id as _);
+                let layer_glyphs = font.glyph_cache.entry(glyph).or_insert_with(|| {
+                    let mut glyphs = Vec::new();
+                    iter_colored_glyphs(&font.color_tables, 0, glyph, |glyph, color| {
+                        let mut builder = GlyphBuilder(path_builder());
+                        font.face.outline_glyph(glyph, &mut builder);
+                        let path = builder.0.finish();
+                        glyphs.push((color.map(|c| c.to_array()), path));
+                    });
+                    glyphs
+                });
+                let (glyph_x, glyph_y) = (x + pos.x_offset as f32, y + pos.y_offset as f32);
+                x += pos.x_advance as f32;
+                y += pos.y_advance as f32;
+                label
+                    .glyphs
+                    .extend(layer_glyphs.iter().map(|(color, path)| Glyph {
+                        color: *color,
+                        x: glyph_x,
+                        y: glyph_y,
+                        path: path.share(),
+                    }));
+            });
+        };
+
+        label.width_without_max_width = x * font.scale_factor;
+
+        if let Some(max_width) = max_width {
+            let max_width = max_width / font.scale_factor;
+            if x > max_width {
+                let ellipsis = font.face.glyph_index('…').unwrap_or_default();
+                let ellipsis_width =
+                    font.face.glyph_hor_advance(ellipsis).unwrap_or_default() as f32;
+
+                let x_to_look_for = max_width - ellipsis_width;
+
+                let last_index = label
+                    .glyphs
+                    .iter()
+                    .enumerate()
+                    .rev()
+                    .find(|(_, g)| {
+                        x = g.x;
+                        y = g.y;
+                        g.x <= x_to_look_for
+                    })
+                    .map(|(i, _)| i)
+                    .unwrap_or_default();
+                label.glyphs.drain(last_index..);
+                let layer_glyphs = font.glyph_cache.entry(ellipsis).or_insert_with(|| {
+                    let mut glyphs = Vec::new();
+                    iter_colored_glyphs(&font.color_tables, 0, ellipsis, |glyph, color| {
+                        let mut builder = GlyphBuilder(path_builder());
+                        font.face.outline_glyph(glyph, &mut builder);
+                        let path = builder.0.finish();
+                        glyphs.push((color.map(|c| c.to_array()), path));
+                    });
+                    glyphs
+                });
+                label
+                    .glyphs
+                    .extend(layer_glyphs.iter().map(|(color, path)| Glyph {
+                        color: *color,
+                        x,
+                        y,
+                        path: path.share(),
+                    }));
+                x += ellipsis_width;
+            }
+        }
+
+        self.buffer = Some(buffer.clear());
+
+        label.width = x * font.scale_factor;
+        label.scale = font.scale_factor;
+    }
+}
+
+struct MonotonicInfo {
+    digit_glyphs: [u16; 10],
+    digit_width: f32,
+    features: [Feature; 1],
+}
+
+/// The font to use in the [`ResourceAllocator`](super::ResourceAllocator).
+pub struct Font<P> {
+    face: Face<'static>,
+    color_tables: Option<ColorTables<'static>>,
+    scale_factor: f32,
+    monotonic: Option<MonotonicInfo>,
+    glyph_cache: HashMap<GlyphId, Vec<(Option<Rgba>, P)>>,
+    #[cfg(feature = "font-loading")]
+    _buf: Option<Box<[u8]>>,
+}
+
+impl<P> Font<P> {
+    #[cfg(feature = "font-loading")]
+    fn try_load_font(
+        source: &mut SystemSource,
+        font: &settings::Font,
+        kind: FontKind,
+    ) -> Option<Self> {
+        let handle = source
+            .select_best_match(
+                &[FamilyName::Title(font.family.clone())],
+                &Properties {
+                    style: match font.style {
+                        FontStyle::Normal => Style::Normal,
+                        FontStyle::Italic => Style::Italic,
+                    },
+                    weight: Weight(font.weight.value()),
+                    stretch: Stretch(font.stretch.factor()),
+                },
+            )
+            .ok()?;
+
+        let (buf, font_index) = match handle {
+            Handle::Path { path, font_index } => (fs::read(path).ok()?, font_index),
+            Handle::Memory { bytes, font_index } => (
+                Arc::try_unwrap(bytes).unwrap_or_else(|bytes| (*bytes).clone()),
+                font_index,
+            ),
+        };
+        let buf = buf.into_boxed_slice();
+
+        // Safety: We store our own buffer. If we never modify it and drop it
+        // last, this is fine. It also needs to be heap allocated, so it's a
+        // stable pointer. This is guaranteed by the boxed slice.
+        unsafe {
+            let slice: *const [u8] = &*buf;
+            let mut font = Font::from_slice(
+                &*slice,
+                font_index,
+                font.style,
+                font.weight,
+                font.stretch,
+                kind,
+            )?;
+            font._buf = Some(buf);
+            Some(font)
+        }
+    }
+
+    fn from_slice(
+        data: &'static [u8],
+        index: u32,
+        style: FontStyle,
+        weight: FontWeight,
+        stretch: FontStretch,
+        kind: FontKind,
+    ) -> Option<Self> {
+        let mut face = Face::from_slice(data, index)?;
+
+        let italic = style.value_for_italic();
+        let weight = weight.value();
+        let stretch = stretch.percentage();
+
+        face.set_variations(&[
+            Variation {
+                tag: Tag::from_bytes(b"ital"),
+                value: italic,
+            },
+            Variation {
+                tag: Tag::from_bytes(b"wght"),
+                value: weight,
+            },
+            Variation {
+                tag: Tag::from_bytes(b"wdth"),
+                value: stretch,
+            },
+        ]);
+
+        let monotonic = kind.is_monospaced().then(|| {
+            let mut digit_glyphs = [0; 10];
+            let mut digit_width = 0;
+            for (digit, glyph) in digit_glyphs.iter_mut().enumerate() {
+                *glyph = face
+                    .glyph_index(char::from(digit as u8 + b'0'))
+                    .unwrap_or_default()
+                    .0;
+
+                let width = face.glyph_hor_advance(GlyphId(*glyph)).unwrap_or_default();
+                if width > digit_width {
+                    digit_width = width;
+                }
+            }
+            MonotonicInfo {
+                digit_glyphs,
+                digit_width: digit_width as f32,
+                features: [
+                    // If the font has support for tabular numbers, we want to
+                    // use it, so we don't have to fix up much. Though we still
+                    // attempt to do so anyway, as we can neither query if tnum
+                    // support is even available, nor can we really trust it all
+                    // too much.
+                    Feature::new(Tag::from_bytes(b"tnum"), 1, ..),
+                    // FIXME: We may or may not want to disable kerning and
+                    // possibly ligatures too. If the font doesn't support tnum,
+                    // then kerning for e.g. `.1` may cause inconsistent
+                    // positioning.
+                    // Feature::new(Tag::from_bytes(b"kern"), 0, ..),
+                ],
+            }
+        });
+
+        Some(Self {
+            scale_factor: 1.0 / face.height() as f32,
+            color_tables: ColorTables::new(&face),
+            face,
+            #[cfg(feature = "font-loading")]
+            _buf: None,
+            monotonic,
+            glyph_cache: HashMap::new(),
+        })
+    }
+}
+
+struct GlyphBuilder<PB>(PB);
+
+impl<PB: PathBuilder> OutlineBuilder for GlyphBuilder<PB> {
+    fn move_to(&mut self, x: f32, y: f32) {
+        self.0.move_to(x, -y);
+    }
+    fn line_to(&mut self, x: f32, y: f32) {
+        self.0.line_to(x, -y);
+    }
+    fn quad_to(&mut self, x1: f32, y1: f32, x: f32, y: f32) {
+        self.0.quad_to(x1, -y1, x, -y);
+    }
+    fn curve_to(&mut self, x1: f32, y1: f32, x2: f32, y2: f32, x: f32, y: f32) {
+        self.0.curve_to(x1, -y1, x2, -y2, x, -y);
+    }
+    fn close(&mut self) {
+        self.0.close();
+    }
+}
+
+/// The label to use in the [`ResourceAllocator`](super::ResourceAllocator).
+pub type Label<P> = Arc<RwLock<LockedLabel<P>>>;
+
+/// You need to lock the [`Label`] to use it. This is the locked type that
+/// provides all the methods you need to use the label.
+pub struct LockedLabel<P> {
+    width: f32,
+    width_without_max_width: f32,
+    scale: f32,
+    glyphs: Vec<Glyph<P>>,
+}
+
+impl<P> LockedLabel<P> {
+    /// Apply this scale to the transform of the [`Entity`](super::Entity) with
+    /// [`Transform::pre_scale`](super::Transform::pre_scale).
+    pub const fn scale(&self) -> f32 {
+        self.scale
+    }
+
+    /// The glyphs to render.
+    pub fn glyphs(&self) -> &[Glyph<P>] {
+        &self.glyphs
+    }
+}
+
+impl<P> super::Label for Label<P> {
+    fn width(&self, scale: f32) -> f32 {
+        self.read().width * scale
+    }
+
+    fn width_without_max_width(&self, scale: f32) -> f32 {
+        self.read().width_without_max_width * scale
+    }
+}
+
+/// A glyph to render.
+pub struct Glyph<P> {
+    /// A glyph may provide its own color that overrides the fill shader of the
+    /// [`Entity`](super::Entity).
+    pub color: Option<Rgba>,
+    /// The x-coordinate of the glyph.
+    pub x: f32,
+    /// The y-coordinate of the glyph.
+    pub y: f32,
+    /// The path to render.
+    pub path: P,
+}
diff --git a/src/rendering/resource/allocation.rs b/src/rendering/resource/allocation.rs
index 173aa2f7..45d1b16d 100644
--- a/src/rendering/resource/allocation.rs
+++ b/src/rendering/resource/allocation.rs
@@ -1,16 +1,43 @@
+use crate::settings::Font;
+
 use super::SharedOwnership;
 
+/// The kind of text that the font is going to be used for.
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum FontKind {
+    /// The font is going to be used for the timer.
+    Timer,
+    /// The font is going to be used for times.
+    Times,
+    /// The font is going to be used for regular text.
+    Text,
+}
+
+impl FontKind {
+    /// Returns whether this kind of font is intended to be monospaced. This
+    /// usually means the `tabular-nums` variant of the font is supposed to be
+    /// activated. If that variant is not available, then it may be necessary to
+    /// emulate monospaced digits instead.
+    pub fn is_monospaced(self) -> bool {
+        self != FontKind::Text
+    }
+}
+
 /// A resource allocator provides all the paths and images necessary to place
 /// [`Entities`](super::super::Entity) in a [`Scene`](super::super::Scene). This
 /// is usually implemented by a specific renderer where the paths and images are
 /// types that the renderer can directly render out.
 pub trait ResourceAllocator {
     /// The type the renderer uses for building paths.
-    type PathBuilder: PathBuilder<Self, Path = Self::Path>;
+    type PathBuilder: PathBuilder<Path = Self::Path>;
     /// The type the renderer uses for paths.
     type Path: SharedOwnership;
-    /// The type the renderer uses for textures.
+    /// The type the renderer uses for images.
     type Image: SharedOwnership;
+    /// The type the renderer uses for fonts.
+    type Font;
+    /// The type the renderer uses for text labels.
+    type Label: Label;
 
     /// Creates a new [`PathBuilder`] to build a new path.
     fn path_builder(&mut self) -> Self::PathBuilder;
@@ -29,22 +56,73 @@ pub trait ResourceAllocator {
         builder.curve_to(x - c, y + r, x - r, y + c, x - r, y);
         builder.curve_to(x - r, y - c, x - c, y - r, x, y - r);
         builder.close();
-        builder.finish(self)
+        builder.finish()
     }
 
-    /// Instructs the backend to create an image out of the image data provided.
-    /// The image's resolution is provided as well. The data is an array of
-    /// RGBA8 encoded pixels (red, green, blue, alpha with each channel being an
-    /// u8).
+    /// Creates an image out of the image data provided. The image's resolution
+    /// is provided as well. The data is an array of RGBA8 encoded pixels (red,
+    /// green, blue, alpha with each channel being an u8).
     fn create_image(&mut self, width: u32, height: u32, data: &[u8]) -> Self::Image;
+
+    /// Creates a font from the font description provided. It is expected that
+    /// the the font description is used in a font matching algorithm to find
+    /// the most suitable font as described in [CSS Fonts Module Level
+    /// 3](https://drafts.csswg.org/css-fonts-3/#font-matching-algorithm). The
+    /// [`FontKind`] is used to provide additional information about the kind of
+    /// font we are looking for. If the font is [`None`] or the font can't be
+    /// found, then the default font to use is derived from the [`FontKind`].
+    /// Also the timer and times fonts are meant to be monospaced fonts, so
+    /// `tabular-nums` are supposed to be used if available and ideally some
+    /// sort of emulation should happen if that's not the case. The default text
+    /// and times font is provided as [`TEXT_FONT`](super::super::TEXT_FONT) and
+    /// the timer's default font is provided as
+    /// [`TIMER_FONT`](super::super::TIMER_FONT).
+    fn create_font(&mut self, font: Option<&Font>, kind: FontKind) -> Self::Font;
+
+    /// Creates a new text label with the text and font provided. An optional
+    /// maximum width is provided as well. If the width of the text measured at
+    /// a size of 1 (spanning from the descender to the ascender) is greater
+    /// than the maximum width, then it is expected to be truncated with an
+    /// ellipsis such that it fits within the maximum width.
+    fn create_label(
+        &mut self,
+        text: &str,
+        font: &mut Self::Font,
+        max_width: Option<f32>,
+    ) -> Self::Label;
+
+    /// Updates an existing text label with the new text and font provided. An
+    /// optional maximum width is provided as well. If the width of the text
+    /// measured at a size of 1 (spanning from the descender to the ascender) is
+    /// greater than the maximum width, then it is expected to be truncated with
+    /// an ellipsis such that it fits within the maximum width.
+    fn update_label(
+        &mut self,
+        label: &mut Self::Label,
+        text: &str,
+        font: &mut Self::Font,
+        max_width: Option<f32>,
+    );
+}
+
+/// A text label created by a [`ResourceAllocator`].
+pub trait Label: SharedOwnership {
+    /// The width of the current text scaled by the scale factor provided. The
+    /// scale is meant to be the distance from the descender to the ascender.
+    fn width(&self, scale: f32) -> f32;
+
+    /// The width of the current text scaled by the scale factor provided as if
+    /// it wasn't truncated by the maximum width that was provided. The scale is
+    /// meant to be the distance from the descender to the ascender.
+    fn width_without_max_width(&self, scale: f32) -> f32;
 }
 
 /// The [`ResourceAllocator`] provides a path builder that defines how to build
 /// paths that can be used with the renderer.
-pub trait PathBuilder<A: ?Sized> {
+pub trait PathBuilder {
     /// The type of the path to build. This needs to be identical to the type of
     /// the path used by the [`ResourceAllocator`].
-    type Path;
+    type Path: SharedOwnership;
 
     /// Moves the cursor to a specific position and starts a new contour.
     fn move_to(&mut self, x: f32, y: f32);
@@ -69,13 +147,13 @@ pub trait PathBuilder<A: ?Sized> {
     fn close(&mut self);
 
     /// Finishes building the path.
-    fn finish(self, allocator: &mut A) -> Self::Path;
+    fn finish(self) -> Self::Path;
 }
 
 pub struct MutPathBuilder<PB>(PB);
 
-impl<A: ResourceAllocator> PathBuilder<&mut A> for MutPathBuilder<A::PathBuilder> {
-    type Path = A::Path;
+impl<PB: PathBuilder> PathBuilder for MutPathBuilder<PB> {
+    type Path = PB::Path;
 
     fn move_to(&mut self, x: f32, y: f32) {
         self.0.move_to(x, y)
@@ -97,8 +175,8 @@ impl<A: ResourceAllocator> PathBuilder<&mut A> for MutPathBuilder<A::PathBuilder
         self.0.close()
     }
 
-    fn finish(self, allocator: &mut &mut A) -> Self::Path {
-        self.0.finish(*allocator)
+    fn finish(self) -> Self::Path {
+        self.0.finish()
     }
 }
 
@@ -106,6 +184,8 @@ impl<A: ResourceAllocator> ResourceAllocator for &mut A {
     type PathBuilder = MutPathBuilder<A::PathBuilder>;
     type Path = A::Path;
     type Image = A::Image;
+    type Font = A::Font;
+    type Label = A::Label;
 
     fn path_builder(&mut self) -> Self::PathBuilder {
         MutPathBuilder((*self).path_builder())
@@ -114,4 +194,27 @@ impl<A: ResourceAllocator> ResourceAllocator for &mut A {
     fn create_image(&mut self, width: u32, height: u32, data: &[u8]) -> Self::Image {
         (*self).create_image(width, height, data)
     }
+
+    fn create_font(&mut self, font: Option<&Font>, kind: FontKind) -> Self::Font {
+        (*self).create_font(font, kind)
+    }
+
+    fn create_label(
+        &mut self,
+        text: &str,
+        font: &mut Self::Font,
+        max_width: Option<f32>,
+    ) -> Self::Label {
+        (*self).create_label(text, font, max_width)
+    }
+
+    fn update_label(
+        &mut self,
+        label: &mut Self::Label,
+        text: &str,
+        font: &mut Self::Font,
+        max_width: Option<f32>,
+    ) {
+        (*self).update_label(label, text, font, max_width)
+    }
 }
diff --git a/src/rendering/resource/handles.rs b/src/rendering/resource/handles.rs
index 4605261b..284fffe5 100644
--- a/src/rendering/resource/handles.rs
+++ b/src/rendering/resource/handles.rs
@@ -1,9 +1,11 @@
-use std::{
+use core::{
     hash::{Hash, Hasher},
-    ops::Deref,
+    ops::{Deref, DerefMut},
 };
 
-use super::{PathBuilder, ResourceAllocator, SharedOwnership};
+use crate::settings::Font;
+
+use super::{Label, PathBuilder, ResourceAllocator, SharedOwnership};
 
 pub struct Handles<A> {
     next_id: usize,
@@ -17,21 +19,21 @@ impl<A> Handles<A> {
 
     pub fn next<T>(&mut self, element: T) -> Handle<T> {
         let id = self.next_id;
-        self.next_id += 1;
+        self.next_id = self.next_id.wrapping_add(1);
         Handle { id, inner: element }
     }
 
-    /// Get a reference to the handles's next ID.
+    /// Get the handles's next ID.
     #[allow(clippy::missing_const_for_fn)] // FIXME: Drop is unsupported.
     pub fn into_next_id(self) -> usize {
         self.next_id
     }
 }
 
-pub struct HandlePathBuilder<A: ResourceAllocator>(A::PathBuilder);
+pub struct HandlePathBuilder<PB: PathBuilder>(PB, usize);
 
-impl<A: ResourceAllocator> PathBuilder<Handles<A>> for HandlePathBuilder<A> {
-    type Path = Handle<A::Path>;
+impl<PB: PathBuilder> PathBuilder for HandlePathBuilder<PB> {
+    type Path = Handle<PB::Path>;
 
     fn move_to(&mut self, x: f32, y: f32) {
         self.0.move_to(x, y);
@@ -53,19 +55,22 @@ impl<A: ResourceAllocator> PathBuilder<Handles<A>> for HandlePathBuilder<A> {
         self.0.close()
     }
 
-    fn finish(self, handles: &mut Handles<A>) -> Self::Path {
-        let path = self.0.finish(&mut handles.allocator);
-        handles.next(path)
+    fn finish(self) -> Self::Path {
+        Handle::new(self.1, self.0.finish())
     }
 }
 
 impl<A: ResourceAllocator> ResourceAllocator for Handles<A> {
-    type PathBuilder = HandlePathBuilder<A>;
+    type PathBuilder = HandlePathBuilder<A::PathBuilder>;
     type Path = Handle<A::Path>;
     type Image = Handle<A::Image>;
+    type Font = Handle<A::Font>;
+    type Label = LabelHandle<A::Label>;
 
     fn path_builder(&mut self) -> Self::PathBuilder {
-        HandlePathBuilder(self.allocator.path_builder())
+        let id = self.next_id;
+        self.next_id = self.next_id.wrapping_add(1);
+        HandlePathBuilder(self.allocator.path_builder(), id)
     }
 
     fn build_circle(&mut self, x: f32, y: f32, r: f32) -> Self::Path {
@@ -77,11 +82,90 @@ impl<A: ResourceAllocator> ResourceAllocator for Handles<A> {
         let image = self.allocator.create_image(width, height, data);
         self.next(image)
     }
+
+    fn create_font(&mut self, font: Option<&Font>, kind: super::FontKind) -> Self::Font {
+        let font = self.allocator.create_font(font, kind);
+        self.next(font)
+    }
+
+    fn create_label(
+        &mut self,
+        text: &str,
+        font: &mut Self::Font,
+        max_width: Option<f32>,
+    ) -> Self::Label {
+        let label = self.allocator.create_label(text, font, max_width);
+        LabelHandle {
+            update_counter: 0,
+            handle: self.next(label),
+        }
+    }
+
+    fn update_label(
+        &mut self,
+        label: &mut Self::Label,
+        text: &str,
+        font: &mut Self::Font,
+        max_width: Option<f32>,
+    ) {
+        self.allocator
+            .update_label(&mut label.handle, text, font, max_width);
+        label.update_counter += 1;
+    }
+}
+
+/// A special handle meant to be used for text labels that also tracks how often
+/// the label got updated.
+pub struct LabelHandle<L> {
+    update_counter: usize,
+    handle: Handle<L>,
+}
+
+impl<T> Deref for LabelHandle<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.handle
+    }
+}
+
+impl<T> Hash for LabelHandle<T> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.update_counter.hash(state);
+        self.handle.hash(state);
+    }
+}
+
+impl<L: Label> SharedOwnership for LabelHandle<L> {
+    fn share(&self) -> Self {
+        LabelHandle {
+            update_counter: self.update_counter,
+            handle: self.handle.share(),
+        }
+    }
+}
+
+impl<L: Label> Label for LabelHandle<L> {
+    fn width(&self, scale: f32) -> f32 {
+        self.handle.inner.width(scale)
+    }
+
+    fn width_without_max_width(&self, scale: f32) -> f32 {
+        self.handle.inner.width_without_max_width(scale)
+    }
+}
+
+impl<T> Eq for LabelHandle<T> {}
+
+impl<T> PartialEq for LabelHandle<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.update_counter.eq(&other.update_counter) && self.handle.eq(&other.handle)
+    }
 }
 
 /// A handle can be used to uniquely identify the resource it wraps.
 pub struct Handle<T> {
-    id: usize,
+    pub(crate) id: usize,
     inner: T,
 }
 
@@ -112,6 +196,12 @@ impl<T> Deref for Handle<T> {
     }
 }
 
+impl<T> DerefMut for Handle<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+
 impl<T> Hash for Handle<T> {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.id.hash(state)
diff --git a/src/rendering/resource/mod.rs b/src/rendering/resource/mod.rs
index 1e6198f7..39d6f2e7 100644
--- a/src/rendering/resource/mod.rs
+++ b/src/rendering/resource/mod.rs
@@ -3,7 +3,7 @@ mod handles;
 mod shared_ownership;
 
 pub use self::{
-    allocation::{PathBuilder, ResourceAllocator},
+    allocation::{FontKind, Label, PathBuilder, ResourceAllocator},
     handles::*,
     shared_ownership::SharedOwnership,
 };
diff --git a/src/rendering/resource/shared_ownership.rs b/src/rendering/resource/shared_ownership.rs
index 59f23a42..1c9826a3 100644
--- a/src/rendering/resource/shared_ownership.rs
+++ b/src/rendering/resource/shared_ownership.rs
@@ -1,4 +1,4 @@
-use std::{rc::Rc, sync::Arc};
+use alloc::{rc::Rc, sync::Arc};
 
 /// Describes that ownership of a value can be cheaply shared. This is similar
 /// to the [`Clone`] trait, but is expected to only be implemented if sharing is
diff --git a/src/rendering/scene.rs b/src/rendering/scene.rs
index 548f3dfc..f8c5ac29 100644
--- a/src/rendering/scene.rs
+++ b/src/rendering/scene.rs
@@ -3,6 +3,7 @@ use super::{
     resource::{Handle, SharedOwnership},
     FillShader,
 };
+use crate::platform::prelude::*;
 
 /// Describes a layer of a [`Scene`] to place an [`Entity`] on.
 #[derive(Copy, Clone, PartialEq, Eq)]
@@ -34,23 +35,23 @@ impl Layer {
 /// and both the bottom layer didn't change, then no new frame needs to be
 /// rendered. While the top [`Layer`] is inherently transparent, the bottom
 /// [`Layer`] has a background that needs to be considered.
-pub struct Scene<P, I> {
+pub struct Scene<P, I, L> {
     rectangle: Handle<P>,
     background: Option<FillShader>,
     bottom_hash: u64,
     bottom_layer_changed: bool,
-    bottom_layer: Vec<Entity<P, I>>,
-    top_layer: Vec<Entity<P, I>>,
+    bottom_layer: Vec<Entity<P, I, L>>,
+    top_layer: Vec<Entity<P, I, L>>,
 }
 
-impl<P: SharedOwnership, I: SharedOwnership> Scene<P, I> {
+impl<P: SharedOwnership, I: SharedOwnership, L: SharedOwnership> Scene<P, I, L> {
     /// Creates a new scene with the rectangle provided to use for placing
     /// rectangle entities.
     pub fn new(rectangle: Handle<P>) -> Self {
         Self {
             rectangle,
             background: None,
-            bottom_hash: calculate_hash::<P, I>(&None, &[]),
+            bottom_hash: calculate_hash::<P, I, L>(&None, &[]),
             bottom_layer_changed: false,
             bottom_layer: Vec::new(),
             top_layer: Vec::new(),
@@ -75,12 +76,12 @@ impl<P: SharedOwnership, I: SharedOwnership> Scene<P, I> {
     /// Get a reference to the scene's bottom [`Layer`]. This [`Layer`] is
     /// intended to infrequently change, so it doesn't need to be rerendered
     /// every frame.
-    pub fn bottom_layer(&self) -> &[Entity<P, I>] {
+    pub fn bottom_layer(&self) -> &[Entity<P, I, L>] {
         &self.bottom_layer
     }
 
     /// Get a reference to the scene's top [`Layer`].
-    pub fn top_layer(&self) -> &[Entity<P, I>] {
+    pub fn top_layer(&self) -> &[Entity<P, I, L>] {
         &self.top_layer
     }
 
@@ -95,12 +96,12 @@ impl<P: SharedOwnership, I: SharedOwnership> Scene<P, I> {
     }
 
     /// Get a mutable reference to the scene's bottom [`Layer`].
-    pub fn bottom_layer_mut(&mut self) -> &mut Vec<Entity<P, I>> {
+    pub fn bottom_layer_mut(&mut self) -> &mut Vec<Entity<P, I, L>> {
         &mut self.bottom_layer
     }
 
     /// Get a mutable reference to the scene's top [`Layer`].
-    pub fn top_layer_mut(&mut self) -> &mut Vec<Entity<P, I>> {
+    pub fn top_layer_mut(&mut self) -> &mut Vec<Entity<P, I, L>> {
         &mut self.top_layer
     }
 
@@ -121,7 +122,7 @@ impl<P: SharedOwnership, I: SharedOwnership> Scene<P, I> {
     }
 
     /// Accesses the [`Layer`] specified mutably.
-    pub fn layer_mut(&mut self, layer: Layer) -> &mut Vec<Entity<P, I>> {
+    pub fn layer_mut(&mut self, layer: Layer) -> &mut Vec<Entity<P, I, L>> {
         match layer {
             Layer::Bottom => &mut self.bottom_layer,
             Layer::Top => &mut self.top_layer,
diff --git a/src/rendering/software.rs b/src/rendering/software.rs
index 00e44adf..86d96c9b 100644
--- a/src/rendering/software.rs
+++ b/src/rendering/software.rs
@@ -5,10 +5,11 @@ use std::{mem, ops::Deref, rc::Rc};
 
 use super::{
     entity::Entity,
+    path_based_text_engine::{Font, Label, TextEngine},
     resource::{self, ResourceAllocator},
-    FillShader, Scene, SceneManager, SharedOwnership, Transform,
+    FillShader, FontKind, Scene, SceneManager, SharedOwnership, Transform,
 };
-use crate::layout::LayoutState;
+use crate::{layout::LayoutState, settings};
 use image::ImageBuffer;
 use tiny_skia::{
     BlendMode, Color, FillRule, FilterQuality, GradientStop, LinearGradient, Paint, Path,
@@ -21,8 +22,10 @@ struct SkiaBuilder(PathBuilder);
 
 type SkiaPath = Option<UnsafeRc<Path>>;
 type SkiaImage = Option<UnsafeRc<Pixmap>>;
+type SkiaFont = Font<SkiaPath>;
+type SkiaLabel = Label<SkiaPath>;
 
-impl resource::PathBuilder<SkiaAllocator> for SkiaBuilder {
+impl resource::PathBuilder for SkiaBuilder {
     type Path = SkiaPath;
 
     fn move_to(&mut self, x: f32, y: f32) {
@@ -45,7 +48,7 @@ impl resource::PathBuilder<SkiaAllocator> for SkiaBuilder {
         self.0.close()
     }
 
-    fn finish(self, _: &mut SkiaAllocator) -> Self::Path {
+    fn finish(self) -> Self::Path {
         self.0.finish().map(UnsafeRc::new)
     }
 }
@@ -65,15 +68,19 @@ fn convert_transform(transform: &Transform) -> tiny_skia::Transform {
     )
 }
 
-struct SkiaAllocator;
+struct SkiaAllocator {
+    text_engine: TextEngine,
+}
 
 impl ResourceAllocator for SkiaAllocator {
     type PathBuilder = SkiaBuilder;
     type Path = SkiaPath;
     type Image = SkiaImage;
+    type Font = SkiaFont;
+    type Label = SkiaLabel;
 
     fn path_builder(&mut self) -> Self::PathBuilder {
-        SkiaBuilder(PathBuilder::new())
+        path_builder()
     }
 
     fn create_image(&mut self, width: u32, height: u32, data: &[u8]) -> Self::Image {
@@ -87,6 +94,35 @@ impl ResourceAllocator for SkiaAllocator {
         }
         Some(UnsafeRc::new(image))
     }
+
+    fn create_font(&mut self, font: Option<&settings::Font>, kind: FontKind) -> Self::Font {
+        self.text_engine.create_font(font, kind)
+    }
+
+    fn create_label(
+        &mut self,
+        text: &str,
+        font: &mut Self::Font,
+        max_width: Option<f32>,
+    ) -> Self::Label {
+        self.text_engine
+            .create_label(path_builder, text, font, max_width)
+    }
+
+    fn update_label(
+        &mut self,
+        label: &mut Self::Label,
+        text: &str,
+        font: &mut Self::Font,
+        max_width: Option<f32>,
+    ) {
+        self.text_engine
+            .update_label(path_builder, label, text, font, max_width)
+    }
+}
+
+fn path_builder() -> SkiaBuilder {
+    SkiaBuilder(PathBuilder::new())
 }
 
 /// The software renderer allows rendering layouts entirely on the CPU. This is
@@ -95,7 +131,8 @@ impl ResourceAllocator for SkiaAllocator {
 /// does not own the image to render into. This allows the caller to manage
 /// their own image buffer.
 pub struct BorrowedRenderer {
-    scene_manager: SceneManager<SkiaPath, SkiaImage>,
+    allocator: SkiaAllocator,
+    scene_manager: SceneManager<SkiaPath, SkiaImage, SkiaFont, SkiaLabel>,
     background: Pixmap,
     min_y: f32,
     max_y: f32,
@@ -148,8 +185,13 @@ impl Default for BorrowedRenderer {
 impl BorrowedRenderer {
     /// Creates a new software renderer.
     pub fn new() -> Self {
+        let mut allocator = SkiaAllocator {
+            text_engine: TextEngine::new(),
+        };
+        let scene_manager = SceneManager::new(&mut allocator);
         Self {
-            scene_manager: SceneManager::new(SkiaAllocator),
+            allocator,
+            scene_manager,
             background: Pixmap::new(1, 1).unwrap(),
             min_y: f32::INFINITY,
             max_y: f32::NEG_INFINITY,
@@ -184,7 +226,7 @@ impl BorrowedRenderer {
 
         let new_resolution =
             self.scene_manager
-                .update_scene(SkiaAllocator, (width as _, height as _), state);
+                .update_scene(&mut self.allocator, (width as _, height as _), state);
 
         let scene = self.scene_manager.scene();
         let rectangle = scene.rectangle();
@@ -301,52 +343,29 @@ impl Renderer {
 
 fn render_layer(
     canvas: &mut PixmapMut<'_>,
-    layer: &[Entity<SkiaPath, SkiaImage>],
+    layer: &[Entity<SkiaPath, SkiaImage, SkiaLabel>],
     rectangle: &Path,
 ) {
     for entity in layer {
         match entity {
             Entity::FillPath(path, shader, transform) => {
                 if let Some(path) = path.as_deref() {
-                    let shader = match shader {
-                        FillShader::SolidColor(col) => Shader::SolidColor(convert_color(col)),
-                        FillShader::VerticalGradient(top, bottom) => {
+                    let paint = convert_shader(
+                        shader,
+                        path,
+                        |path| {
                             let bounds = path.bounds();
-                            LinearGradient::new(
-                                Point::from_xy(0.0, bounds.top()),
-                                Point::from_xy(0.0, bounds.bottom()),
-                                vec![
-                                    GradientStop::new(0.0, convert_color(top)),
-                                    GradientStop::new(1.0, convert_color(bottom)),
-                                ],
-                                SpreadMode::Pad,
-                                tiny_skia::Transform::identity(),
-                            )
-                            .unwrap()
-                        }
-                        FillShader::HorizontalGradient(left, right) => {
+                            (bounds.top(), bounds.bottom())
+                        },
+                        |path| {
                             let bounds = path.bounds();
-                            LinearGradient::new(
-                                Point::from_xy(bounds.left(), 0.0),
-                                Point::from_xy(bounds.right(), 0.0),
-                                vec![
-                                    GradientStop::new(0.0, convert_color(left)),
-                                    GradientStop::new(1.0, convert_color(right)),
-                                ],
-                                SpreadMode::Pad,
-                                tiny_skia::Transform::identity(),
-                            )
-                            .unwrap()
-                        }
-                    };
+                            (bounds.left(), bounds.right())
+                        },
+                    );
 
                     canvas.fill_path(
                         path,
-                        &Paint {
-                            shader,
-                            anti_alias: true,
-                            ..Default::default()
-                        },
+                        &paint,
                         FillRule::Winding,
                         convert_transform(transform),
                         None,
@@ -395,12 +414,123 @@ fn render_layer(
                     );
                 }
             }
+            Entity::Label(label, shader, transform) => {
+                let label = label.read();
+                let label = &*label;
+
+                let paint = convert_shader(
+                    shader,
+                    label,
+                    |label| {
+                        let (mut top, mut bottom) = (f32::INFINITY, f32::NEG_INFINITY);
+                        for glyph in label.glyphs() {
+                            if let Some(path) = &glyph.path {
+                                let bounds = path.bounds();
+                                top = top.min(bounds.top());
+                                bottom = bottom.max(bounds.bottom());
+                            }
+                        }
+                        if bottom < top {
+                            (0.0, 0.0)
+                        } else {
+                            (top, bottom)
+                        }
+                    },
+                    |label| {
+                        let (mut left, mut right) = (f32::INFINITY, f32::NEG_INFINITY);
+                        for glyph in label.glyphs() {
+                            if let Some(path) = &glyph.path {
+                                let bounds = path.bounds();
+                                left = left.min(bounds.left());
+                                right = right.max(bounds.right());
+                            }
+                        }
+                        if right < left {
+                            (0.0, 0.0)
+                        } else {
+                            (left, right)
+                        }
+                    },
+                );
+
+                let transform = transform.pre_scale(label.scale(), label.scale());
+
+                for glyph in label.glyphs() {
+                    if let Some(path) = &glyph.path {
+                        let transform = transform.pre_translate(glyph.x, glyph.y);
+
+                        let glyph_paint;
+                        let paint = if let Some(color) = &glyph.color {
+                            glyph_paint = Paint {
+                                shader: Shader::SolidColor(convert_color(color)),
+                                ..paint
+                            };
+                            &glyph_paint
+                        } else {
+                            &paint
+                        };
+
+                        canvas.fill_path(
+                            path,
+                            paint,
+                            FillRule::Winding,
+                            convert_transform(&transform),
+                            None,
+                        );
+                    }
+                }
+            }
         }
     }
 }
 
+fn convert_shader<T>(
+    shader: &FillShader,
+    has_bounds: &T,
+    calculate_top_bottom: impl FnOnce(&T) -> (f32, f32),
+    calculate_left_right: impl FnOnce(&T) -> (f32, f32),
+) -> Paint<'static> {
+    let shader = match shader {
+        FillShader::SolidColor(col) => Shader::SolidColor(convert_color(col)),
+        FillShader::VerticalGradient(top, bottom) => {
+            let (bound_top, bound_bottom) = calculate_top_bottom(has_bounds);
+            LinearGradient::new(
+                Point::from_xy(0.0, bound_top),
+                Point::from_xy(0.0, bound_bottom),
+                vec![
+                    GradientStop::new(0.0, convert_color(top)),
+                    GradientStop::new(1.0, convert_color(bottom)),
+                ],
+                SpreadMode::Pad,
+                tiny_skia::Transform::identity(),
+            )
+            .unwrap()
+        }
+        FillShader::HorizontalGradient(left, right) => {
+            let (bound_left, bound_right) = calculate_left_right(has_bounds);
+            LinearGradient::new(
+                Point::from_xy(bound_left, 0.0),
+                Point::from_xy(bound_right, 0.0),
+                vec![
+                    GradientStop::new(0.0, convert_color(left)),
+                    GradientStop::new(1.0, convert_color(right)),
+                ],
+                SpreadMode::Pad,
+                tiny_skia::Transform::identity(),
+            )
+            .unwrap()
+        }
+    };
+
+    Paint {
+        shader,
+        anti_alias: true,
+        ..Default::default()
+    }
+}
+
 fn fill_background(
-    scene: &Scene<SkiaPath, SkiaImage>,
+    scene: &Scene<SkiaPath, SkiaImage, SkiaLabel>,
     background: &mut PixmapMut<'_>,
     width: u32,
     height: u32,
@@ -461,7 +591,7 @@ fn fill_background(
     }
 }
 
-fn calculate_bounds(layer: &[Entity<SkiaPath, SkiaImage>]) -> (f32, f32) {
+fn calculate_bounds(layer: &[Entity<SkiaPath, SkiaImage, SkiaLabel>]) -> (f32, f32) {
     let (mut min_y, mut max_y) = (f32::INFINITY, f32::NEG_INFINITY);
     for entity in layer.iter() {
         match entity {
@@ -495,6 +625,19 @@ fn calculate_bounds(layer: &[Entity<SkiaPath, SkiaImage>]) -> (f32, f32) {
                     }
                 }
             }
+            Entity::Label(label, _, transform) => {
+                for glyph in label.read().glyphs() {
+                    if let Some(path) = &glyph.path {
+                        let transform = transform.pre_translate(glyph.x, glyph.y);
+                        let bounds = path.bounds();
+                        for y in [bounds.top(), bounds.bottom()] {
+                            let transformed_y = transform.transform_y(y);
+                            min_y = min_y.min(transformed_y);
+                            max_y = max_y.max(transformed_y);
+                        }
+                    }
+                }
+            }
         }
     }
     (min_y, max_y)
diff --git a/src/run/parser/flitter/s_expressions.rs b/src/run/parser/flitter/s_expressions.rs
index 40cdd69f..78efaadb 100644
--- a/src/run/parser/flitter/s_expressions.rs
+++ b/src/run/parser/flitter/s_expressions.rs
@@ -1,5 +1,5 @@
 //! Implements a serde deserializer for S-Expressions.
-//! http://people.csail.mit.edu/rivest/Sexp.txt
+//! <http://people.csail.mit.edu/rivest/Sexp.txt>
 
 use core::{fmt::Display, num::ParseIntError};
 use serde::de::{self, DeserializeOwned, DeserializeSeed, MapAccess, SeqAccess, Visitor};
diff --git a/src/settings/image/mod.rs b/src/settings/image/mod.rs
index 869a6d86..25cd63a8 100644
--- a/src/settings/image/mod.rs
+++ b/src/settings/image/mod.rs
@@ -41,7 +41,7 @@ where
 }
 
 impl Deref for ImageData {
-    type Target = Box<[u8]>;
+    type Target = [u8];
     fn deref(&self) -> &Self::Target {
         &self.0
     }
diff --git a/tests/rendering.rs b/tests/rendering.rs
index 79e2bbb6..4b293f29 100644
--- a/tests/rendering.rs
+++ b/tests/rendering.rs
@@ -53,7 +53,7 @@ fn actual_split_file() {
 
     check(
         &layout.state(&timer.snapshot()),
-        "jMTAARBAPDM=",
+        "jMTAARBAPLM=",
         "actual_split_file",
     );
 }