diff --git a/Cargo.lock b/Cargo.lock
index fe02a86dde8..bc17eaf6bfc 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -21,6 +21,12 @@ version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ee2a4ec343196209d6594e19543ae87a39f96d5534d7174822a3ad825dd6ed7e"
 
+[[package]]
+name = "ahash"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8fd72866655d1904d6b0997d0b07ba561047d070fbe29de039031c641b61217"
+
 [[package]]
 name = "ahash"
 version = "0.4.5"
@@ -519,10 +525,10 @@ checksum = "9ea835d29036a4087793836fa931b08837ad5e957da9e23886b29586fb9b6650"
 name = "egui"
 version = "0.2.0"
 dependencies = [
- "ahash",
+ "ahash 0.4.5",
  "criterion",
+ "fontdue",
  "parking_lot",
- "rusttype",
  "serde",
  "serde_json",
 ]
@@ -574,6 +580,15 @@ version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
+[[package]]
+name = "fontdue"
+version = "0.3.2"
+source = "git+https://github.com/mooman219/fontdue#3e2f51fe70fd7ab21ff70652ff8c2798f6e9fc65"
+dependencies = [
+ "hashbrown",
+ "ttf-parser 0.8.2",
+]
+
 [[package]]
 name = "foreign-types"
 version = "0.3.2"
@@ -716,6 +731,16 @@ version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d36fab90f82edc3c747f9d438e06cf0a491055896f2a279638bb5beed6c40177"
 
+[[package]]
+name = "hashbrown"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e91b62f79061a0bc2e046024cb7ba44b08419ed238ecbd9adbd787434b9e8c25"
+dependencies = [
+ "ahash 0.3.8",
+ "autocfg",
+]
+
 [[package]]
 name = "hermit-abi"
 version = "0.1.17"
@@ -1143,7 +1168,7 @@ version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9f923fb806c46266c02ab4a5b239735c144bdeda724a50ed058e5226f594cde3"
 dependencies = [
- "ttf-parser",
+ "ttf-parser 0.6.2",
 ]
 
 [[package]]
@@ -1525,6 +1550,12 @@ version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3e5d7cd7ab3e47dda6e56542f4bbf3824c15234958c6e1bd6aaa347e93499fdc"
 
+[[package]]
+name = "ttf-parser"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d973cfa0e6124166b50a1105a67c85de40bbc625082f35c0f56f84cb1fb0a827"
+
 [[package]]
 name = "unicode-width"
 version = "0.1.8"
diff --git a/egui/Cargo.toml b/egui/Cargo.toml
index 214eaf484cd..92aa18ce800 100644
--- a/egui/Cargo.toml
+++ b/egui/Cargo.toml
@@ -17,7 +17,7 @@ include = [ "**/*.rs", "Cargo.toml", "fonts/ProggyClean.ttf", "fonts/Comfortaa-R
 [dependencies]
 ahash = { version = "0.4", features = ["std"], default-features = false }
 parking_lot = "0.11"
-rusttype = "0.9"
+fontdue = { version = "0.3", git = "https://github.com/mooman219/fontdue" }
 serde = { version = "1", features = ["derive"], optional = true }
 serde_json = { version = "1", optional = true }
 
diff --git a/egui/src/containers/collapsing_header.rs b/egui/src/containers/collapsing_header.rs
index 978d170686a..91e2b9b2a95 100644
--- a/egui/src/containers/collapsing_header.rs
+++ b/egui/src/containers/collapsing_header.rs
@@ -169,8 +169,9 @@ struct Prepared {
 
 impl CollapsingHeader {
     fn begin(self, ui: &mut Ui) -> Prepared {
-        assert!(
-            ui.layout().dir() == Direction::Vertical,
+        assert_eq!(
+            ui.layout().dir(),
+            Direction::Vertical,
             "Horizontal collapsing is unimplemented"
         );
         let Self {
@@ -186,14 +187,14 @@ impl CollapsingHeader {
 
         let available = ui.available_finite();
         let text_pos = available.min + vec2(ui.style().spacing.indent, 0.0);
-        let galley = label.layout_width(ui, available.right() - text_pos.x);
-        let text_max_x = text_pos.x + galley.size.x;
+        let layout = label.layout_width(ui, available.right() - text_pos.x);
+        let text_max_x = text_pos.x + layout.size.x;
         let desired_width = text_max_x - available.left();
         let desired_width = desired_width.max(available.width());
 
         let mut desired_size = vec2(
             desired_width,
-            galley.size.y + 2.0 * ui.style().spacing.button_padding.y,
+            layout.size.y + 2.0 * ui.style().spacing.button_padding.y,
         );
         desired_size = desired_size.at_least(ui.style().spacing.interact_size);
         let rect = ui.allocate_space(desired_size);
@@ -201,7 +202,7 @@ impl CollapsingHeader {
         let header_response = ui.interact(rect, id, Sense::click());
         let text_pos = pos2(
             text_pos.x,
-            header_response.rect.center().y - galley.size.y / 2.0,
+            header_response.rect.center().y - layout.size.y / 2.0,
         );
 
         let mut state = State::from_memory_with_default_open(ui.ctx(), id, default_open);
@@ -226,9 +227,9 @@ impl CollapsingHeader {
         }
 
         let painter = ui.painter();
-        painter.galley(
+        painter.layout(
             text_pos,
-            galley,
+            layout,
             label.text_style_or_default(ui.style()),
             ui.style().interact(&header_response).text_color(),
         );
diff --git a/egui/src/containers/window.rs b/egui/src/containers/window.rs
index 77ce625807f..0ae6af48ffc 100644
--- a/egui/src/containers/window.rs
+++ b/egui/src/containers/window.rs
@@ -2,9 +2,7 @@
 
 use std::sync::Arc;
 
-use crate::{paint::*, widgets::*, *};
-
-use super::*;
+use crate::{paint::fonts::GlyphLayout, paint::*, widgets::*, *};
 
 /// Builder for a floating window which can be dragged, closed, collapsed, resized and scrolled (off by default).
 ///
@@ -219,7 +217,7 @@ impl<'open> Window<'open> {
         // First interact (move etc) to avoid frame delay:
         let last_frame_outer_rect = area.state().rect();
         let interaction = if possible.movable || possible.resizable {
-            let title_bar_height = title_label.font_height(ctx.fonts(), &ctx.style())
+            let title_bar_height = title_label.font_height(&ctx.fonts().lock(), &ctx.style())
                 + 1.0 * ctx.style().spacing.item_spacing.y; // this could be better
             let margins = 2.0 * frame.margin + vec2(0.0, title_bar_height);
 
@@ -599,7 +597,7 @@ fn paint_frame_interaction(
 
 struct TitleBar {
     title_label: Label,
-    title_galley: font::Galley,
+    title_layout: GlyphLayout,
     title_rect: Rect,
     rect: Rect,
 }
@@ -613,7 +611,7 @@ fn show_title_bar(
     collapsible: bool,
 ) -> TitleBar {
     let (title_bar, response) = ui.horizontal(|ui| {
-        ui.set_min_height(title_label.font_height(ui.fonts(), ui.style()));
+        ui.set_min_height(title_label.font_height(&ui.fonts().lock(), ui.style()));
 
         let item_spacing = ui.style().spacing.item_spacing;
         let button_size = ui.style().spacing.icon_width;
@@ -630,8 +628,8 @@ fn show_title_bar(
             collapsing_header::paint_icon(ui, openness, &collapse_button_response);
         }
 
-        let title_galley = title_label.layout(ui);
-        let title_rect = ui.allocate_space(title_galley.size);
+        let title_layout = title_label.layout(ui);
+        let title_rect = ui.allocate_space(title_layout.size);
 
         if show_close_button {
             // Reserve space for close button which will be added later (once we know our full width):
@@ -649,7 +647,7 @@ fn show_title_bar(
 
         TitleBar {
             title_label,
-            title_galley,
+            title_layout,
             title_rect,
             rect: Rect::invalid(), // Will be filled in later
         }
@@ -685,7 +683,7 @@ impl TitleBar {
 
         // TODO: pick style for title based on move interaction
         self.title_label
-            .paint_galley(ui, self.title_rect.min, self.title_galley);
+            .paint_layout(ui, self.title_rect.min, self.title_layout);
 
         if let Some(content_response) = &content_response {
             // paint separator between title and content:
diff --git a/egui/src/context.rs b/egui/src/context.rs
index 2463fa1c413..64af66563e9 100644
--- a/egui/src/context.rs
+++ b/egui/src/context.rs
@@ -25,7 +25,7 @@ struct Options {
     /// Controls the tessellator.
     paint_options: paint::PaintOptions,
     /// Font sizes etc.
-    font_definitions: FontDefinitions,
+    font_configuration: FontConfiguration,
 }
 
 /// Thi is the first thing you need when working with Egui.
@@ -39,7 +39,7 @@ struct Options {
 pub struct Context {
     options: Mutex<Options>,
     /// None until first call to `begin_frame`.
-    fonts: Option<Arc<Fonts>>,
+    fonts: Option<Arc<Mutex<Fonts>>>,
     memory: Arc<Mutex<Memory>>,
     animation_manager: Arc<Mutex<AnimationManager>>,
 
@@ -110,24 +110,24 @@ impl Context {
 
     /// Not valid until first call to `begin_frame()`
     /// That's because since we don't know the proper `pixels_per_point` until then.
-    pub fn fonts(&self) -> &Fonts {
-        &*self
-            .fonts
+    pub fn fonts(&self) -> Arc<Mutex<Fonts>> {
+        self.fonts
             .as_ref()
             .expect("No fonts available until first call to Context::begin_frame()`")
+            .clone()
     }
 
     /// The Egui texture, containing font characters etc..
     /// Not valid until first call to `begin_frame()`
     /// That's because since we don't know the proper `pixels_per_point` until then.
     pub fn texture(&self) -> Arc<paint::Texture> {
-        self.fonts().texture()
+        self.fonts().lock().texture()
     }
 
     /// Will become active at the start of the next frame.
     /// `pixels_per_point` will be ignored (overwritten at start of each frame with the contents of input)
-    pub fn set_fonts(&self, font_definitions: FontDefinitions) {
-        lock(&self.options, "options").font_definitions = font_definitions;
+    pub fn set_fonts(&self, font_configuration: FontConfiguration) {
+        lock(&self.options, "options").font_configuration = font_configuration;
     }
 
     pub fn style(&self) -> Arc<Style> {
@@ -183,14 +183,16 @@ impl Context {
         self.used_ids.lock().clear();
 
         self.input = std::mem::take(&mut self.input).begin_frame(new_raw_input);
-        let mut font_definitions = lock(&self.options, "options").font_definitions.clone();
-        font_definitions.pixels_per_point = self.input.pixels_per_point();
+        let mut font_configuration = lock(&self.options, "options").font_configuration.clone();
+        font_configuration.pixels_per_point = self.input.pixels_per_point();
         let same_as_current = match &self.fonts {
             None => false,
-            Some(fonts) => *fonts.definitions() == font_definitions,
+            Some(fonts) => *fonts.lock().configuration() == font_configuration,
         };
         if !same_as_current {
-            self.fonts = Some(Arc::new(Fonts::from_definitions(font_definitions)));
+            self.fonts = Some(Arc::new(Mutex::new(Fonts::from_definitions(
+                font_configuration,
+            ))));
         }
     }
 
@@ -523,10 +525,11 @@ impl Context {
         CollapsingHeader::new("Fonts")
             .default_open(false)
             .show(ui, |ui| {
-                let mut font_definitions = self.fonts().definitions().clone();
-                font_definitions.ui(ui);
-                self.fonts().texture().ui(ui);
-                self.set_fonts(font_definitions);
+                let mut font_configuration = self.fonts().lock().configuration().clone();
+                font_configuration.ui(ui);
+                let texture = self.fonts().lock().texture();
+                texture.ui(ui);
+                self.set_fonts(font_configuration);
             });
 
         CollapsingHeader::new("Painting")
diff --git a/egui/src/demos/app.rs b/egui/src/demos/app.rs
index 6bc5c5f389f..9373b6d3822 100644
--- a/egui/src/demos/app.rs
+++ b/egui/src/demos/app.rs
@@ -129,7 +129,7 @@ impl FrameHistory {
                     ui.fonts(),
                     pos2(rect.left(), y),
                     align::LEFT_BOTTOM,
-                    text,
+                    &text,
                     TextStyle::Monospace,
                     color::WHITE,
                 ));
diff --git a/egui/src/introspection.rs b/egui/src/introspection.rs
index e864d19ff42..1895b266a0a 100644
--- a/egui/src/introspection.rs
+++ b/egui/src/introspection.rs
@@ -54,18 +54,18 @@ impl Texture {
     }
 }
 
-impl paint::FontDefinitions {
+impl paint::FontConfiguration {
     pub fn ui(&mut self, ui: &mut Ui) {
-        for (text_style, (_family, size)) in self.fonts.iter_mut() {
+        for (text_style, definition) in self.definitions.iter_mut() {
             // TODO: radio button for family
             ui.add(
-                Slider::f32(size, 4.0..=40.0)
+                Slider::f32(&mut definition.scale_in_points, 4.0..=40.0)
                     .precision(0)
                     .text(format!("{:?}", text_style)),
             );
         }
         if ui.button("Reset fonts").clicked {
-            *self = paint::FontDefinitions::with_pixels_per_point(self.pixels_per_point);
+            *self = paint::FontConfiguration::with_pixels_per_point(self.pixels_per_point);
         }
     }
 }
diff --git a/egui/src/paint/command.rs b/egui/src/paint/command.rs
index 968b7bc3554..dc0fdb986bf 100644
--- a/egui/src/paint/command.rs
+++ b/egui/src/paint/command.rs
@@ -1,8 +1,13 @@
+use std::sync::Arc;
+
+use parking_lot::Mutex;
+
 use {
-    super::{font::Galley, fonts::TextStyle, Fonts, Srgba, Triangles},
+    super::{fonts::TextStyle, Fonts, Srgba, Triangles},
     crate::{
         align::{anchor_rect, Align},
         math::{Pos2, Rect},
+        paint::fonts::GlyphLayout,
     },
 };
 
@@ -38,9 +43,8 @@ pub enum PaintCmd {
     Text {
         /// Top left corner of the first character.
         pos: Pos2,
-        /// The layed out text
-        galley: Galley,
-        text_style: TextStyle, // TODO: Font?
+        layout: GlyphLayout,
+        text_style: TextStyle,
         color: Srgba,
     },
     Triangles(Triangles),
@@ -91,19 +95,18 @@ impl PaintCmd {
     }
 
     pub fn text(
-        fonts: &Fonts,
+        fonts: Arc<Mutex<Fonts>>,
         pos: Pos2,
         anchor: (Align, Align),
-        text: impl Into<String>,
+        text: &str,
         text_style: TextStyle,
         color: Srgba,
     ) -> Self {
-        let font = &fonts[text_style];
-        let galley = font.layout_multiline(text.into(), f32::INFINITY);
-        let rect = anchor_rect(Rect::from_min_size(pos, galley.size), anchor);
+        let layout = fonts.lock().layout_multiline(text_style, text, None);
+        let rect = anchor_rect(Rect::from_min_size(pos, layout.size), anchor);
         Self::Text {
             pos: rect.min,
-            galley,
+            layout,
             text_style,
             color,
         }
diff --git a/egui/src/paint/font.rs b/egui/src/paint/font.rs
deleted file mode 100644
index 8e0f854767d..00000000000
--- a/egui/src/paint/font.rs
+++ /dev/null
@@ -1,531 +0,0 @@
-use std::sync::Arc;
-
-use {
-    ahash::AHashMap,
-    parking_lot::{Mutex, RwLock},
-    rusttype::{point, Scale},
-};
-
-use crate::math::{vec2, Vec2};
-
-use super::texture_atlas::TextureAtlas;
-
-#[derive(Clone, Copy, Debug, Default)]
-pub struct GalleyCursor {
-    /// character count in whole galley
-    pub char_idx: usize,
-    /// line number
-    pub line: usize,
-    /// character count on this line
-    pub column: usize,
-}
-
-/// A collection of text locked into place.
-#[derive(Clone, Debug, Default)]
-pub struct Galley {
-    /// The full text
-    pub text: String,
-
-    /// Lines of text, from top to bottom.
-    /// The number of chars in all lines sum up to text.chars().count()
-    pub lines: Vec<Line>,
-
-    // Optimization: calculate once and reuse.
-    pub size: Vec2,
-}
-
-/// A typeset piece of text on a single line.
-#[derive(Clone, Debug)]
-pub struct Line {
-    /// The start of each character, probably starting at zero.
-    /// The last element is the end of the last character.
-    /// x_offsets.len() == text.chars().count() + 1
-    /// This is never empty.
-    /// Unit: points.
-    pub x_offsets: Vec<f32>,
-
-    /// Top of the line, offset within the Galley.
-    /// Unit: points.
-    pub y_min: f32,
-
-    /// Bottom of the line, offset within the Galley.
-    /// Unit: points.
-    pub y_max: f32,
-
-    /// If true, the last char on this line is '\n'
-    pub ends_with_newline: bool,
-}
-
-impl Galley {
-    pub fn sanity_check(&self) {
-        let mut char_count = 0;
-        for line in &self.lines {
-            line.sanity_check();
-            char_count += line.char_count();
-        }
-        assert_eq!(char_count, self.text.chars().count());
-    }
-
-    /// If given a char index after the first line, the end of the last character is returned instead.
-    /// Returns a Vec2 rather than a Pos2 as this is an offset into the galley. *shrug*
-    pub fn char_start_pos(&self, char_idx: usize) -> Vec2 {
-        let mut char_count = 0;
-        for line in &self.lines {
-            let line_char_count = line.char_count();
-            if char_count <= char_idx && char_idx < char_count + line_char_count {
-                let line_char_offset = char_idx - char_count;
-                return vec2(line.x_offsets[line_char_offset], line.y_min);
-            }
-            char_count += line_char_count;
-        }
-
-        if let Some(last) = self.lines.last() {
-            vec2(last.max_x(), last.y_min)
-        } else {
-            // Empty galley
-            vec2(0.0, 0.0)
-        }
-    }
-
-    /// Character offset at the given position within the galley
-    pub fn char_at(&self, pos: Vec2) -> GalleyCursor {
-        let mut best_y_dist = f32::INFINITY;
-        let mut cursor = GalleyCursor::default();
-
-        let mut char_count = 0;
-        for (line_nr, line) in self.lines.iter().enumerate() {
-            let y_dist = (line.y_min - pos.y).abs().min((line.y_max - pos.y).abs());
-            if y_dist < best_y_dist {
-                best_y_dist = y_dist;
-                let mut column = line.char_at(pos.x);
-                if column == line.char_count() && line.ends_with_newline {
-                    // handle the case where line ends with a \n and we click after it.
-                    // We should return the position BEFORE the \n!
-                    column -= 1;
-                }
-                cursor = GalleyCursor {
-                    char_idx: char_count + column,
-                    line: line_nr,
-                    column,
-                }
-            }
-            char_count += line.char_count();
-        }
-        cursor
-    }
-}
-
-impl Line {
-    pub fn sanity_check(&self) {
-        assert!(!self.x_offsets.is_empty());
-    }
-
-    pub fn char_count(&self) -> usize {
-        assert!(!self.x_offsets.is_empty());
-        self.x_offsets.len() - 1
-    }
-
-    pub fn min_x(&self) -> f32 {
-        *self.x_offsets.first().unwrap()
-    }
-
-    pub fn max_x(&self) -> f32 {
-        *self.x_offsets.last().unwrap()
-    }
-
-    /// Closest char at the desired x coordinate. returns something in the range `[0, char_count()]`
-    pub fn char_at(&self, desired_x: f32) -> usize {
-        for (i, char_x_bounds) in self.x_offsets.windows(2).enumerate() {
-            let char_center_x = 0.5 * (char_x_bounds[0] + char_x_bounds[1]);
-            if desired_x < char_center_x {
-                return i;
-            }
-        }
-        self.char_count()
-    }
-}
-
-// ----------------------------------------------------------------------------
-
-// const REPLACEMENT_CHAR: char = '\u{25A1}'; // □ white square Replaces a missing or unsupported Unicode character.
-// const REPLACEMENT_CHAR: char = '\u{FFFD}'; // � REPLACEMENT CHARACTER
-const REPLACEMENT_CHAR: char = '?';
-
-#[derive(Clone, Copy, Debug)]
-pub struct UvRect {
-    /// X/Y offset for nice rendering (unit: points).
-    pub offset: Vec2,
-    pub size: Vec2,
-
-    /// Top left corner UV in texture.
-    pub min: (u16, u16),
-
-    /// Bottom right corner (exclusive).
-    pub max: (u16, u16),
-}
-
-#[derive(Clone, Copy, Debug)]
-pub struct GlyphInfo {
-    id: rusttype::GlyphId,
-
-    /// Unit: points.
-    pub advance_width: f32,
-
-    /// Texture coordinates. None for space.
-    pub uv_rect: Option<UvRect>,
-}
-
-/// The interface uses points as the unit for everything.
-pub struct Font {
-    font: rusttype::Font<'static>,
-    /// Maximum character height
-    scale_in_pixels: f32,
-    pixels_per_point: f32,
-    replacement_glyph_info: GlyphInfo,
-    glyph_infos: RwLock<AHashMap<char, GlyphInfo>>,
-    atlas: Arc<Mutex<TextureAtlas>>,
-}
-
-impl Font {
-    pub fn new(
-        atlas: Arc<Mutex<TextureAtlas>>,
-        font_data: &'static [u8],
-        scale_in_points: f32,
-        pixels_per_point: f32,
-    ) -> Font {
-        assert!(scale_in_points > 0.0);
-        assert!(pixels_per_point > 0.0);
-
-        let font = rusttype::Font::try_from_bytes(font_data).expect("Error constructing Font");
-        let scale_in_pixels = pixels_per_point * scale_in_points;
-
-        let replacement_glyph_info = allocate_glyph(
-            &mut atlas.lock(),
-            REPLACEMENT_CHAR,
-            &font,
-            scale_in_pixels,
-            pixels_per_point,
-        )
-        .unwrap_or_else(|| {
-            panic!(
-                "Failed to find replacement character {:?}",
-                REPLACEMENT_CHAR
-            )
-        });
-
-        let font = Font {
-            font,
-            scale_in_pixels,
-            pixels_per_point,
-            replacement_glyph_info,
-            glyph_infos: Default::default(),
-            atlas,
-        };
-
-        font.glyph_infos
-            .write()
-            .insert(REPLACEMENT_CHAR, font.replacement_glyph_info);
-
-        // Preload the printable ASCII characters [32, 126] (which excludes control codes):
-        const FIRST_ASCII: usize = 32; // 32 == space
-        const LAST_ASCII: usize = 126;
-        for c in (FIRST_ASCII..=LAST_ASCII).map(|c| c as u8 as char) {
-            font.glyph_info(c);
-        }
-        font.glyph_info('°');
-
-        font
-    }
-
-    pub fn round_to_pixel(&self, point: f32) -> f32 {
-        (point * self.pixels_per_point).round() / self.pixels_per_point
-    }
-
-    /// Height of one line of text. In points
-    /// TODO: rename height ?
-    pub fn line_spacing(&self) -> f32 {
-        self.scale_in_pixels / self.pixels_per_point
-    }
-    pub fn height(&self) -> f32 {
-        self.scale_in_pixels / self.pixels_per_point
-    }
-
-    pub fn uv_rect(&self, c: char) -> Option<UvRect> {
-        self.glyph_infos.read().get(&c).and_then(|gi| gi.uv_rect)
-    }
-
-    fn glyph_info(&self, c: char) -> GlyphInfo {
-        if c == '\n' {
-            // Hack: else we show '\n' as '?' (REPLACEMENT_CHAR)
-            return self.glyph_info(' ');
-        }
-
-        {
-            if let Some(glyph_info) = self.glyph_infos.read().get(&c) {
-                return *glyph_info;
-            }
-        }
-
-        // Add new character:
-        let glyph_info = allocate_glyph(
-            &mut self.atlas.lock(),
-            c,
-            &self.font,
-            self.scale_in_pixels,
-            self.pixels_per_point,
-        );
-        // debug_assert!(glyph_info.is_some(), "Failed to find {:?}", c);
-        let glyph_info = glyph_info.unwrap_or(self.replacement_glyph_info);
-        self.glyph_infos.write().insert(c, glyph_info);
-        glyph_info
-    }
-
-    /// Typeset the given text onto one line.
-    /// Assumes there are no \n in the text.
-    /// Always returns exactly one fragment.
-    pub fn layout_single_line(&self, text: String) -> Galley {
-        let x_offsets = self.layout_single_line_fragment(&text);
-        let line = Line {
-            x_offsets,
-            y_min: 0.0,
-            y_max: self.height(),
-            ends_with_newline: false,
-        };
-        let width = line.max_x();
-        let size = vec2(width, self.height());
-        let galley = Galley {
-            text,
-            lines: vec![line],
-            size,
-        };
-        galley.sanity_check();
-        galley
-    }
-
-    pub fn layout_multiline(&self, text: String, max_width_in_points: f32) -> Galley {
-        let line_spacing = self.line_spacing();
-        let mut cursor_y = 0.0;
-        let mut lines = Vec::new();
-
-        let mut paragraph_start = 0;
-
-        while paragraph_start < text.len() {
-            let next_newline = text[paragraph_start..].find('\n');
-            let paragraph_end = next_newline
-                .map(|newline| paragraph_start + newline + 1)
-                .unwrap_or_else(|| text.len());
-
-            assert!(paragraph_start < paragraph_end);
-            let paragraph_text = &text[paragraph_start..paragraph_end];
-            let mut paragraph_lines =
-                self.layout_paragraph_max_width(paragraph_text, max_width_in_points);
-            assert!(!paragraph_lines.is_empty());
-
-            for line in &mut paragraph_lines {
-                line.y_min += cursor_y;
-                line.y_max += cursor_y;
-            }
-            cursor_y = paragraph_lines.last().unwrap().y_max;
-            cursor_y += line_spacing * 0.4; // extra spacing between paragraphs. less hacky
-
-            lines.append(&mut paragraph_lines);
-
-            paragraph_start = paragraph_end;
-        }
-
-        if text.is_empty() || text.ends_with('\n') {
-            // Add an empty last line for correct visuals etc:
-            lines.push(Line {
-                x_offsets: vec![0.0],
-                y_min: cursor_y,
-                y_max: cursor_y + line_spacing,
-                ends_with_newline: text.ends_with('\n'),
-            });
-        }
-
-        let mut widest_line = 0.0;
-        for line in &lines {
-            widest_line = line.max_x().max(widest_line);
-        }
-        let size = vec2(widest_line, lines.last().unwrap().y_max);
-
-        let galley = Galley { text, lines, size };
-        galley.sanity_check();
-        galley
-    }
-
-    /// Typeset the given text onto one line.
-    /// Assumes there are no \n in the text.
-    /// Return `x_offsets`, one longer than the number of characters in the text.
-    fn layout_single_line_fragment(&self, text: &str) -> Vec<f32> {
-        let scale_in_pixels = Scale::uniform(self.scale_in_pixels);
-
-        let mut x_offsets = Vec::with_capacity(text.chars().count() + 1);
-        x_offsets.push(0.0);
-
-        let mut cursor_x_in_points = 0.0f32;
-        let mut last_glyph_id = None;
-
-        for c in text.chars() {
-            let glyph = self.glyph_info(c);
-
-            if let Some(last_glyph_id) = last_glyph_id {
-                cursor_x_in_points +=
-                    self.font
-                        .pair_kerning(scale_in_pixels, last_glyph_id, glyph.id)
-                        / self.pixels_per_point
-            }
-            cursor_x_in_points += glyph.advance_width;
-            cursor_x_in_points = self.round_to_pixel(cursor_x_in_points);
-            last_glyph_id = Some(glyph.id);
-
-            x_offsets.push(cursor_x_in_points);
-        }
-
-        x_offsets
-    }
-
-    /// A paragraph is text with no line break character in it.
-    /// The text will be linebreaked by the given `max_width_in_points`.
-    pub fn layout_paragraph_max_width(&self, text: &str, max_width_in_points: f32) -> Vec<Line> {
-        let full_x_offsets = self.layout_single_line_fragment(text);
-
-        let mut line_start_x = full_x_offsets[0];
-
-        {
-            #![allow(clippy::float_cmp)]
-            assert_eq!(line_start_x, 0.0);
-        }
-
-        let mut cursor_y = 0.0;
-        let mut line_start_idx = 0;
-
-        // start index of the last space. A candidate for a new line.
-        let mut last_space = None;
-
-        let mut out_lines = vec![];
-
-        for (i, (x, chr)) in full_x_offsets.iter().skip(1).zip(text.chars()).enumerate() {
-            let line_width = x - line_start_x;
-
-            if line_width > max_width_in_points {
-                if let Some(last_space_idx) = last_space {
-                    let include_trailing_space = true;
-                    let line = if include_trailing_space {
-                        Line {
-                            x_offsets: full_x_offsets[line_start_idx..=last_space_idx + 1]
-                                .iter()
-                                .map(|x| x - line_start_x)
-                                .collect(),
-                            y_min: cursor_y,
-                            y_max: cursor_y + self.height(),
-                            ends_with_newline: false, // we'll fix this later
-                        }
-                    } else {
-                        Line {
-                            x_offsets: full_x_offsets[line_start_idx..=last_space_idx]
-                                .iter()
-                                .map(|x| x - line_start_x)
-                                .collect(),
-                            y_min: cursor_y,
-                            y_max: cursor_y + self.height(),
-                            ends_with_newline: false, // we'll fix this later
-                        }
-                    };
-                    line.sanity_check();
-                    out_lines.push(line);
-
-                    line_start_idx = last_space_idx + 1;
-                    line_start_x = full_x_offsets[line_start_idx];
-                    last_space = None;
-                    cursor_y += self.line_spacing();
-                    cursor_y = self.round_to_pixel(cursor_y);
-                }
-            }
-
-            const NON_BREAKING_SPACE: char = '\u{A0}';
-            if chr.is_whitespace() && chr != NON_BREAKING_SPACE {
-                last_space = Some(i);
-            }
-        }
-
-        if line_start_idx + 1 < full_x_offsets.len() {
-            let line = Line {
-                x_offsets: full_x_offsets[line_start_idx..]
-                    .iter()
-                    .map(|x| x - line_start_x)
-                    .collect(),
-                y_min: cursor_y,
-                y_max: cursor_y + self.height(),
-                ends_with_newline: false, // we'll fix this later
-            };
-            line.sanity_check();
-            out_lines.push(line);
-        }
-
-        if text.ends_with('\n') {
-            out_lines.last_mut().unwrap().ends_with_newline = true;
-        }
-
-        out_lines
-    }
-}
-
-fn allocate_glyph(
-    atlas: &mut TextureAtlas,
-    c: char,
-    font: &rusttype::Font<'static>,
-    scale_in_pixels: f32,
-    pixels_per_point: f32,
-) -> Option<GlyphInfo> {
-    let glyph = font.glyph(c);
-    if glyph.id().0 == 0 {
-        return None; // Failed to find a glyph for the character
-    }
-
-    let glyph = glyph.scaled(Scale::uniform(scale_in_pixels));
-    let glyph = glyph.positioned(point(0.0, 0.0));
-
-    let uv_rect = if let Some(bb) = glyph.pixel_bounding_box() {
-        let glyph_width = bb.width() as usize;
-        let glyph_height = bb.height() as usize;
-        assert!(glyph_width >= 1);
-        assert!(glyph_height >= 1);
-
-        let glyph_pos = atlas.allocate((glyph_width, glyph_height));
-
-        let texture = atlas.texture_mut();
-        glyph.draw(|x, y, v| {
-            if v > 0.0 {
-                let px = glyph_pos.0 + x as usize;
-                let py = glyph_pos.1 + y as usize;
-                texture[(px, py)] = (v * 255.0).round() as u8;
-            }
-        });
-
-        let offset_y_in_pixels = scale_in_pixels as f32 + bb.min.y as f32 - 4.0 * pixels_per_point; // TODO: use font.v_metrics
-        Some(UvRect {
-            offset: vec2(
-                bb.min.x as f32 / pixels_per_point,
-                offset_y_in_pixels / pixels_per_point,
-            ),
-            size: vec2(glyph_width as f32, glyph_height as f32) / pixels_per_point,
-            min: (glyph_pos.0 as u16, glyph_pos.1 as u16),
-            max: (
-                (glyph_pos.0 + glyph_width) as u16,
-                (glyph_pos.1 + glyph_height) as u16,
-            ),
-        })
-    } else {
-        // No bounding box. Maybe a space?
-        None
-    };
-
-    let advance_width_in_points = glyph.unpositioned().h_metrics().advance_width / pixels_per_point;
-
-    Some(GlyphInfo {
-        id: glyph.id(),
-        advance_width: advance_width_in_points,
-        uv_rect,
-    })
-}
diff --git a/egui/src/paint/fonts.rs b/egui/src/paint/fonts.rs
index e03109e9f62..58c74f4375e 100644
--- a/egui/src/paint/fonts.rs
+++ b/egui/src/paint/fonts.rs
@@ -4,14 +4,17 @@ use std::{
     sync::Arc,
 };
 
+use ahash::AHashMap;
+use fontdue::{
+    layout::{CoordinateSystem, GlyphPosition, GlyphRasterConfig, LayoutSettings},
+    Font, FontSettings, Metrics,
+};
 use parking_lot::Mutex;
 
-use super::{
-    font::Font,
-    texture_atlas::{Texture, TextureAtlas},
-};
+use crate::math::{vec2, Vec2};
+
+use super::texture_atlas::{Texture, TextureAtlas};
 
-// TODO: rename
 #[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
@@ -29,113 +32,240 @@ pub enum FontFamily {
     VariableWidth,
 }
 
+impl FontFamily {
+    /// Used as index for the font vector. The fonts need to be inserted in this order!
+    pub fn font_index(&self) -> usize {
+        match self {
+            FontFamily::Monospace => 0,
+            FontFamily::VariableWidth => 1,
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct FontDefinition {
+    pub family: FontFamily,
+    pub scale_in_points: f32,
+}
+
+/// Configured the typefaces that are used. This is a configuration and is not supposed to be changed while rendering.
 #[derive(Clone, Debug, PartialEq)]
-pub struct FontDefinitions {
+pub struct FontConfiguration {
     /// The dpi scale factor. Needed to get pixel perfect fonts.
     pub pixels_per_point: f32,
-
-    pub fonts: BTreeMap<TextStyle, (FontFamily, f32)>,
+    pub definitions: BTreeMap<TextStyle, FontDefinition>,
 }
 
-impl Default for FontDefinitions {
+impl Default for FontConfiguration {
     fn default() -> Self {
         Self::with_pixels_per_point(f32::NAN) // must be set later
     }
 }
 
-impl FontDefinitions {
+impl FontConfiguration {
     pub fn with_pixels_per_point(pixels_per_point: f32) -> Self {
-        let mut fonts = BTreeMap::new();
-        fonts.insert(TextStyle::Body, (FontFamily::VariableWidth, 14.0));
-        fonts.insert(TextStyle::Button, (FontFamily::VariableWidth, 16.0));
-        fonts.insert(TextStyle::Heading, (FontFamily::VariableWidth, 24.0));
-        fonts.insert(TextStyle::Monospace, (FontFamily::Monospace, 13.0));
-
+        let mut definitions = BTreeMap::new();
+        definitions.insert(
+            TextStyle::Body,
+            FontDefinition {
+                family: FontFamily::VariableWidth,
+                scale_in_points: 12.0,
+            },
+        );
+        definitions.insert(
+            TextStyle::Button,
+            FontDefinition {
+                family: FontFamily::VariableWidth,
+                scale_in_points: 13.0,
+            },
+        );
+        definitions.insert(
+            TextStyle::Heading,
+            FontDefinition {
+                family: FontFamily::VariableWidth,
+                scale_in_points: 20.0,
+            },
+        );
+        definitions.insert(
+            TextStyle::Monospace,
+            FontDefinition {
+                family: FontFamily::Monospace,
+                scale_in_points: 11.0,
+            },
+        );
         Self {
             pixels_per_point,
-            fonts,
+            definitions,
         }
     }
 }
 
-/// Note: the `default()` fonts are invalid (missing `pixels_per_point`).
-#[derive(Default)]
+#[derive(Clone, Copy, Debug, Default)]
+pub struct UvRect {
+    /// The size of the element in points.
+    pub size: Vec2,
+
+    /// Top left corner UV in texture.
+    pub min: (u16, u16),
+
+    /// Bottom right corner (exclusive).
+    pub max: (u16, u16),
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+pub struct GlyphInfo {
+    /// Glyph metrics.
+    pub metrics: Metrics,
+
+    /// Texture coordinates.
+    pub uv_rect: UvRect,
+}
+
+/// Glyph layout information. Units are in physical pixel and need to be scaled back to points.
+#[derive(Clone, Debug, Default)]
+pub struct GlyphLayout {
+    pub size: Vec2,
+    pub glyph_positions: Vec<GlyphPosition>,
+}
+
+impl GlyphLayout {
+    pub fn with_capacity(capacity: usize) -> Self {
+        Self {
+            size: vec2(0.0, 0.0),
+            glyph_positions: Vec::with_capacity(capacity),
+        }
+    }
+}
+
+/// Font renderer.
 pub struct Fonts {
-    definitions: FontDefinitions,
-    fonts: BTreeMap<TextStyle, Font>,
+    configuration: FontConfiguration,
+    fonts: Vec<Font>,
+    layout_engine: fontdue::layout::Layout,
+    glyph_infos: AHashMap<GlyphRasterConfig, GlyphInfo>,
     atlas: Arc<Mutex<TextureAtlas>>,
     /// Copy of the texture in the texture atlas.
     /// This is so we can return a reference to it (the texture atlas is behind a lock).
     buffered_texture: Mutex<Arc<Texture>>,
+    /// Precalculated heights for the TextStyles.
+    heights: BTreeMap<TextStyle, f32>,
+    /// Precalculated heights for the TextStyles.
+    line_spacings: BTreeMap<TextStyle, f32>,
+}
+
+impl Default for Fonts {
+    fn default() -> Self {
+        Self {
+            configuration: Default::default(),
+            fonts: Default::default(),
+            layout_engine: fontdue::layout::Layout::new(CoordinateSystem::PositiveYDown),
+            glyph_infos: Default::default(),
+            atlas: Default::default(),
+            buffered_texture: Default::default(),
+            heights: Default::default(),
+            line_spacings: Default::default(),
+        }
+    }
 }
 
 impl Fonts {
-    pub fn from_definitions(definitions: FontDefinitions) -> Fonts {
-        let mut fonts = Self::default();
-        fonts.set_definitions(definitions);
+    pub fn from_definitions(configuration: FontConfiguration) -> Fonts {
+        let mut fonts = Fonts::default();
+        fonts.set_configuration(configuration);
         fonts
     }
 
-    pub fn definitions(&self) -> &FontDefinitions {
-        &self.definitions
+    pub fn configuration(&self) -> &FontConfiguration {
+        &self.configuration
     }
 
-    pub fn set_definitions(&mut self, definitions: FontDefinitions) {
-        if self.definitions == definitions {
+    pub fn set_configuration(&mut self, configuration: FontConfiguration) {
+        if self.configuration == configuration {
             return;
         }
 
-        let mut atlas = TextureAtlas::new(512, 16); // TODO: better default?
+        self.atlas = Arc::new(Mutex::new(TextureAtlas::new(512, 512)));
 
-        {
-            // Make the top left pixel fully white:
-            let pos = atlas.allocate((1, 1));
-            assert_eq!(pos, (0, 0));
-            atlas.texture_mut()[pos] = 255;
-        }
+        // Make the top left pixel fully white, since it's used for the UI rendering.
+        let pos = self.atlas.lock().allocate((1, 1));
+        self.atlas.lock().texture_mut()[pos] = 255;
+        debug_assert_eq!(pos, (0, 0));
 
-        let atlas = Arc::new(Mutex::new(atlas));
+        // FontFamily::Monospace (Use 13 for this. NOTHING ELSE).
+        let monospace_typeface_data: &[u8] = include_bytes!("../../fonts/ProggyClean.ttf");
+        // FontFamily::VariableWidth.
+        // FIXME: https://github.com/mooman219/fontdue/issues/38
+        // FIXME: https://github.com/RazrFalcon/ttf-parser/issues/43
+        let variable_typeface_data: &[u8] = include_bytes!("../../fonts/Comfortaa-Regular.ttf");
+        //let variable_typeface_data: &[u8] = include_bytes!("../../fonts/Roboto-Regular.ttf");
 
-        // TODO: figure out a way to make the WASM smaller despite including a font. Zip it?
-        let monospace_typeface_data = include_bytes!("../../fonts/ProggyClean.ttf"); // Use 13 for this. NOTHING ELSE.
+        // Fonts need to be added in the same order as defined in the `FontFamily.font_index()` method.
+        self.fonts.push(
+            Font::from_bytes(monospace_typeface_data, FontSettings::default())
+                .expect("error constructing Font"),
+        );
+        self.fonts.push(
+            Font::from_bytes(variable_typeface_data, FontSettings::default())
+                .expect("error constructing Font"),
+        );
 
-        // let monospace_typeface_data = include_bytes!("../../fonts/Roboto-Regular.ttf");
+        self.configuration = configuration;
 
-        let variable_typeface_data = include_bytes!("../../fonts/Comfortaa-Regular.ttf"); // Funny, hard to read
+        let pixels_per_points = self.configuration.pixels_per_point;
+        for (text_style, definition) in self.configuration.definitions.clone().iter() {
+            let font_index = definition.family.font_index();
+            let scale_in_pixels = definition.scale_in_points * pixels_per_points;
 
-        // let variable_typeface_data = include_bytes!("../../fonts/DejaVuSans.ttf"); // Basic, boring, takes up more space
+            // Preload the printable ASCII characters [33, 126] (which excludes control codes):
+            const FIRST_ASCII: usize = 33; // !
+            const LAST_ASCII: usize = 126; // ~
 
-        self.definitions = definitions.clone();
-        let FontDefinitions {
-            pixels_per_point,
-            fonts,
-        } = definitions;
-        self.fonts = fonts
-            .into_iter()
-            .map(|(text_style, (family, size))| {
-                let typeface_data: &[u8] = match family {
-                    FontFamily::Monospace => monospace_typeface_data,
-                    FontFamily::VariableWidth => variable_typeface_data,
+            for u in FIRST_ASCII..=LAST_ASCII {
+                let c = std::char::from_u32(u as u32)
+                    .unwrap_or_else(|| panic!("can't create char from u32: {}", u));
+                let key = GlyphRasterConfig {
+                    c,
+                    px: scale_in_pixels,
+                    font_index,
                 };
+                self.glyph_info(&key);
+            }
 
-                (
-                    text_style,
-                    Font::new(atlas.clone(), typeface_data, size, pixels_per_point),
-                )
-            })
-            .collect();
-
-        {
-            let mut atlas = atlas.lock();
-            let texture = atlas.texture_mut();
-            // Make sure we seed the texture version with something unique based on the default characters:
-            let mut hasher = ahash::AHasher::default();
-            texture.pixels.hash(&mut hasher);
-            texture.version = hasher.finish();
+            // Precalculate the line spacings and heights (in points)
+            let px = scale_in_pixels;
+            let font = &self.fonts[font_index];
+            let line_spacing = font
+                .horizontal_line_metrics(px)
+                .unwrap_or_else(|| panic!("font doesn't seem to support horizontal text layout"))
+                .new_line_size;
+            self.line_spacings
+                .insert(*text_style, line_spacing / pixels_per_points);
+            self.heights
+                .insert(*text_style, scale_in_pixels / pixels_per_points);
         }
 
-        self.buffered_texture = Default::default(); //atlas.lock().texture().clone();
-        self.atlas = atlas;
+        // Make sure we seed the texture version with something unique based on the default characters:
+        let mut atlas = self.atlas.lock();
+        let texture = atlas.texture_mut();
+        let mut hasher = ahash::AHasher::default();
+        texture.pixels.hash(&mut hasher);
+        texture.version = hasher.finish();
+
+        self.buffered_texture = Default::default();
+    }
+
+    /// Returns the `GlyphInfo` for the given `GlyphRasterConfig` key. Allocates a new Glyph if necessary.
+    pub fn glyph_info(&mut self, grc: &GlyphRasterConfig) -> GlyphInfo {
+        if let Some(glyph_info) = self.glyph_infos.get(grc) {
+            return *glyph_info;
+        }
+
+        let glyph_info = self.allocate_glyph(grc);
+
+        let glyph_info =
+            glyph_info.unwrap_or_else(|| panic!("couldn't render glyph: {:#?}", grc.c));
+        self.glyph_infos.insert(*grc, glyph_info);
+        glyph_info
     }
 
     pub fn texture(&self) -> Arc<Texture> {
@@ -147,12 +277,144 @@ impl Fonts {
 
         buffered_texture.clone()
     }
-}
 
-impl std::ops::Index<TextStyle> for Fonts {
-    type Output = Font;
+    /// Typeset the given text onto one line. Ignores hard wraps. Returns the dimension of the line.
+    pub fn layout_single_line(&mut self, style: TextStyle, text: &str) -> GlyphLayout {
+        let settings = LayoutSettings {
+            wrap_hard_breaks: false,
+            ..Default::default()
+        };
+
+        self.layout(style, text, settings)
+    }
+
+    // FIXME: https://github.com/mooman219/fontdue/issues/39
+    /// Typeset the given text onto multiple lines.
+    pub fn layout_multiline(
+        &mut self,
+        style: TextStyle,
+        text: &str,
+        max_width_in_points: Option<f32>,
+    ) -> GlyphLayout {
+        let settings = LayoutSettings {
+            max_width: max_width_in_points,
+            wrap_hard_breaks: true,
+            ..Default::default()
+        };
+
+        self.layout(style, text, settings)
+    }
+
+    fn layout(
+        &mut self,
+        style: TextStyle,
+        text: &str,
+        mut settings: LayoutSettings,
+    ) -> GlyphLayout {
+        // We calculate the layout in physical pixel and later scale back the metrics back to points.
+        // This is done to get a better looking layout.
+        let mut layout = GlyphLayout::with_capacity(text.len());
+
+        if text.is_empty() {
+            return layout;
+        }
+
+        // Convert points to pixel.
+        settings.max_width = if let Some(width) = settings.max_width {
+            Some(width * self.configuration.pixels_per_point)
+        } else {
+            None
+        };
+
+        let font_index = self.configuration.definitions[&style].family.font_index();
+        let pixels_per_point = self.configuration.pixels_per_point;
+        let height = self.heights[&style];
+        let px_height = self.heights[&style] * pixels_per_point;
+
+        let text_style = fontdue::layout::TextStyle {
+            text,
+            px: px_height,
+            font_index,
+        };
+
+        self.layout_engine.layout_horizontal(
+            &self.fonts,
+            &[&text_style],
+            &settings,
+            &mut layout.glyph_positions,
+        );
+
+        let mut min_y = f32::MAX;
+        let mut max_y = f32::MIN;
+        let mut min_x = f32::MAX;
+        let mut max_x = f32::MIN;
+
+        // Calculate logical points and max dimensions.
+        for pos in layout.glyph_positions.iter_mut() {
+            pos.width = (pos.width as f32 / pixels_per_point) as usize;
+            pos.height = (pos.height as f32 / pixels_per_point) as usize;
+            pos.x /= pixels_per_point;
+            pos.y /= pixels_per_point;
+
+            min_x = min_x.min(pos.x);
+            max_x = max_x.max(pos.x + pos.width as f32);
+            min_y = min_y.min(pos.y);
+            max_y = max_y.max(pos.y + pos.height as f32);
+        }
+
+        // Wait for fontdue do provide better line metrics to align the glyphs
+        // to the line with the current DPI setting.
+
+        // Add 20% height as margin to each side
+        let width = (max_x - min_x) + 0.4 * height;
+
+        // Add 20% height as margin to each side
+        let height = (max_y - min_y) + 0.4 * height;
+
+        layout.size = vec2(width, height);
+        layout
+    }
+
+    fn allocate_glyph(&mut self, grc: &GlyphRasterConfig) -> Option<GlyphInfo> {
+        let font = &self.fonts[grc.font_index];
+        let (metrics, glyph_data) = font.rasterize(grc.c, grc.px);
+
+        if glyph_data.is_empty() {
+            return None;
+        }
+
+        let mut atlas = self.atlas.lock();
+        let glyph_pos = atlas.allocate((metrics.width, metrics.height));
+        let texture = atlas.texture_mut();
+
+        for (i, v) in glyph_data.iter().enumerate() {
+            if *v > 0 {
+                let px = glyph_pos.0 + (i % metrics.width);
+                let py = glyph_pos.1 + (i / metrics.width);
+                texture[(px, py)] = *v;
+            }
+        }
+
+        let uv_rect = UvRect {
+            size: vec2(metrics.width as f32, metrics.height as f32)
+                / self.configuration.pixels_per_point,
+            min: (glyph_pos.0 as u16, glyph_pos.1 as u16),
+            max: (
+                (glyph_pos.0 + metrics.width) as u16,
+                (glyph_pos.1 + metrics.height) as u16,
+            ),
+        };
+
+        Some(GlyphInfo { metrics, uv_rect })
+    }
+
+    /// Returns the font height in points of the given `TextStyle`.
+    pub fn text_style_height(&self, text_style: TextStyle) -> f32 {
+        self.heights[&text_style]
+    }
 
-    fn index(&self, text_style: TextStyle) -> &Font {
-        &self.fonts[&text_style]
+    /// Returns the line spacing in points of the given `TextStyle`.
+    pub fn text_style_line_spacing(&self, text_style: TextStyle) -> f32 {
+        self.line_spacings[&text_style]
     }
 }
diff --git a/egui/src/paint/mod.rs b/egui/src/paint/mod.rs
index 38343531223..de783db3e47 100644
--- a/egui/src/paint/mod.rs
+++ b/egui/src/paint/mod.rs
@@ -4,7 +4,6 @@
 
 pub mod color;
 pub mod command;
-pub mod font;
 pub mod fonts;
 pub mod tessellator;
 mod texture_atlas;
@@ -12,7 +11,7 @@ mod texture_atlas;
 pub use {
     color::{Rgba, Srgba},
     command::{PaintCmd, Stroke},
-    fonts::{FontDefinitions, Fonts, TextStyle},
+    fonts::{FontConfiguration, Fonts, TextStyle},
     tessellator::{PaintJobs, PaintOptions, TextureId, Triangles, Vertex, WHITE_UV},
     texture_atlas::Texture,
 };
diff --git a/egui/src/paint/tessellator.rs b/egui/src/paint/tessellator.rs
index c940d827efa..2a3b6650eaf 100644
--- a/egui/src/paint/tessellator.rs
+++ b/egui/src/paint/tessellator.rs
@@ -5,6 +5,9 @@
 
 #![allow(clippy::identity_op)]
 
+use parking_lot::Mutex;
+use std::sync::Arc;
+
 use {
     super::{
         color::{self, srgba, Rgba, Srgba, TRANSPARENT},
@@ -655,7 +658,7 @@ fn tessellate_paint_command(
     clip_rect: Rect,
     command: PaintCmd,
     options: PaintOptions,
-    fonts: &Fonts,
+    fonts: Arc<Mutex<Fonts>>,
     out: &mut Triangles,
     scratchpad_points: &mut Vec<Pos2>,
     scratchpad_path: &mut Path,
@@ -744,59 +747,55 @@ fn tessellate_paint_command(
         }
         PaintCmd::Text {
             pos,
-            galley,
+            layout,
             text_style,
             color,
         } => {
             if color == TRANSPARENT {
                 return;
             }
-            galley.sanity_check();
-
-            let num_chars = galley.text.chars().count();
-            out.reserve_triangles(num_chars * 2);
-            out.reserve_vertices(num_chars * 4);
-
-            let tex_w = fonts.texture().width as f32;
-            let tex_h = fonts.texture().height as f32;
-
-            let text_offset = vec2(0.0, 1.0); // Eye-balled for buttons. TODO: why is this needed?
-
-            let clip_rect = clip_rect.expand(2.0); // Some fudge to handle letter slightly larger than expected.
-
-            let font = &fonts[text_style];
-            let mut chars = galley.text.chars();
-            for line in &galley.lines {
-                let line_min_y = pos.y + line.y_min + text_offset.x;
-                let line_max_y = line_min_y + font.height();
-                let is_line_visible =
-                    line_max_y >= clip_rect.min.y && line_min_y <= clip_rect.max.y;
-
-                for x_offset in line.x_offsets.iter().take(line.x_offsets.len() - 1) {
-                    let c = chars.next().unwrap();
-
-                    if options.coarse_tessellation_culling && !is_line_visible {
-                        // culling individual lines of text is important, since a single `PaintCmd::Text`
-                        // can span hundreds of lines.
-                        continue;
+            let num_glyphs = layout.glyph_positions.len();
+            out.reserve_triangles(num_glyphs * 2);
+            out.reserve_vertices(num_glyphs * 4);
+
+            let tex_w = fonts.lock().texture().width as f32;
+            let tex_h = fonts.lock().texture().height as f32;
+
+            let line_height = fonts.lock().text_style_line_spacing(text_style);
+
+            let mut was_visible = false;
+            for glyph in &layout.glyph_positions {
+                // Coarse culling the glyphs on the Y-axis.
+                // Could be optimized by only checking every n-th glyph.
+                if options.coarse_tessellation_culling {
+                    let glyph_pos_y = pos.y + glyph.y as f32;
+                    let is_glyph_visible = glyph_pos_y >= clip_rect.min.y - line_height
+                        && glyph_pos_y <= clip_rect.max.y;
+
+                    if !was_visible && is_glyph_visible {
+                        was_visible = true;
                     }
 
-                    if let Some(glyph) = font.uv_rect(c) {
-                        let mut left_top =
-                            pos + glyph.offset + vec2(*x_offset, line.y_min) + text_offset;
-                        left_top.x = font.round_to_pixel(left_top.x); // Pixel-perfection.
-                        left_top.y = font.round_to_pixel(left_top.y); // Pixel-perfection.
-
-                        let pos = Rect::from_min_max(left_top, left_top + glyph.size);
-                        let uv = Rect::from_min_max(
-                            pos2(glyph.min.0 as f32 / tex_w, glyph.min.1 as f32 / tex_h),
-                            pos2(glyph.max.0 as f32 / tex_w, glyph.max.1 as f32 / tex_h),
-                        );
-                        out.add_rect_with_uv(pos, uv, color);
+                    if !is_glyph_visible {
+                        if was_visible {
+                            break;
+                        }
+                        continue;
                     }
                 }
+
+                let glyph_info = fonts.lock().glyph_info(&glyph.key);
+                let uv_rect = glyph_info.uv_rect;
+                let glyph_pos = vec2(glyph.x, glyph.y);
+                let left_top = pos + glyph_pos;
+                let pos = Rect::from_min_max(left_top, left_top + uv_rect.size);
+                let uv = Rect::from_min_max(
+                    pos2(uv_rect.min.0 as f32 / tex_w, uv_rect.min.1 as f32 / tex_h),
+                    pos2(uv_rect.max.0 as f32 / tex_w, uv_rect.max.1 as f32 / tex_h),
+                );
+
+                out.add_rect_with_uv(pos, uv, color);
             }
-            assert_eq!(chars.next(), None);
         }
     }
 }
@@ -815,7 +814,7 @@ fn tessellate_paint_command(
 pub fn tessellate_paint_commands(
     commands: Vec<(Rect, PaintCmd)>,
     options: PaintOptions,
-    fonts: &Fonts,
+    fonts: Arc<Mutex<Fonts>>,
 ) -> Vec<(Rect, Triangles)> {
     let mut scratchpad_points = Vec::new();
     let mut scratchpad_path = Path::default();
@@ -842,7 +841,7 @@ pub fn tessellate_paint_commands(
             clip_rect,
             cmd,
             options,
-            fonts,
+            fonts.clone(),
             out,
             &mut scratchpad_points,
             &mut scratchpad_path,
@@ -860,7 +859,7 @@ pub fn tessellate_paint_commands(
                     stroke: Stroke::new(2.0, srgba(150, 255, 150, 255)),
                 },
                 options,
-                fonts,
+                fonts.clone(),
                 triangles,
                 &mut scratchpad_points,
                 &mut scratchpad_path,
diff --git a/egui/src/painter.rs b/egui/src/painter.rs
index 7154334f1d5..f26d27e5d4f 100644
--- a/egui/src/painter.rs
+++ b/egui/src/painter.rs
@@ -1,11 +1,14 @@
 use std::sync::Arc;
 
+use parking_lot::Mutex;
+
 use crate::{
     align::{anchor_rect, Align, LEFT_TOP},
     color,
     layers::PaintCmdIdx,
     math::{Pos2, Rect, Vec2},
-    paint::{font, Fonts, PaintCmd, Stroke, TextStyle},
+    paint::fonts::GlyphLayout,
+    paint::{Fonts, PaintCmd, Stroke, TextStyle},
     Context, Layer, Srgba,
 };
 
@@ -48,7 +51,7 @@ impl Painter {
     }
 
     /// Available fonts
-    pub(crate) fn fonts(&self) -> &Fonts {
+    pub(crate) fn fonts(&self) -> Arc<Mutex<Fonts>> {
         self.ctx.fonts()
     }
 
@@ -115,25 +118,23 @@ impl Painter {
 
 /// ## Debug painting
 impl Painter {
-    pub fn debug_rect(&mut self, rect: Rect, color: Srgba, text: impl Into<String>) {
+    pub fn debug_rect(&mut self, rect: Rect, color: Srgba, text: &str) {
         self.rect_stroke(rect, 0.0, (1.0, color));
         let text_style = TextStyle::Monospace;
-        self.text(rect.min, LEFT_TOP, text.into(), text_style, color);
+        self.text(rect.min, LEFT_TOP, text, text_style, color);
     }
 
-    pub fn error(&self, pos: Pos2, text: impl Into<String>) {
-        let text = text.into();
+    pub fn error(&self, pos: Pos2, text: &str) {
         let text_style = TextStyle::Monospace;
-        let font = &self.fonts()[text_style];
-        let galley = font.layout_multiline(text, f32::INFINITY);
-        let rect = anchor_rect(Rect::from_min_size(pos, galley.size), LEFT_TOP);
+        let layout = self.fonts().lock().layout_multiline(text_style, text, None);
+        let rect = anchor_rect(Rect::from_min_size(pos, layout.size), LEFT_TOP);
         self.add(PaintCmd::Rect {
             rect: rect.expand(2.0),
             corner_radius: 0.0,
             fill: Srgba::black_alpha(240),
             stroke: Stroke::new(1.0, color::RED),
         });
-        self.galley(rect.min, galley, text_style, color::RED);
+        self.layout(rect.min, layout, text_style, color::RED);
     }
 
     pub fn debug_arrow(&self, origin: Pos2, dir: Vec2, stroke: Stroke) {
@@ -248,22 +249,21 @@ impl Painter {
         &self,
         pos: Pos2,
         anchor: (Align, Align),
-        text: impl Into<String>,
+        text: &str,
         text_style: TextStyle,
         text_color: Srgba,
     ) -> Rect {
-        let font = &self.fonts()[text_style];
-        let galley = font.layout_multiline(text.into(), f32::INFINITY);
-        let rect = anchor_rect(Rect::from_min_size(pos, galley.size), anchor);
-        self.galley(rect.min, galley, text_style, text_color);
+        let layout = self.fonts().lock().layout_multiline(text_style, text, None);
+        let rect = anchor_rect(Rect::from_min_size(pos, layout.size), anchor);
+        self.layout(rect.min, layout, text_style, text_color);
         rect
     }
 
-    /// Paint text that has already been layed out in a `Galley`.
-    pub fn galley(&self, pos: Pos2, galley: font::Galley, text_style: TextStyle, color: Srgba) {
+    /// Paint text that has already been laid out in a `GlyphLayout`.
+    pub fn layout(&self, pos: Pos2, layout: GlyphLayout, text_style: TextStyle, color: Srgba) {
         self.add(PaintCmd::Text {
             pos,
-            galley,
+            layout,
             text_style,
             color,
         });
diff --git a/egui/src/ui.rs b/egui/src/ui.rs
index 7bbb5f67d1d..78fac776171 100644
--- a/egui/src/ui.rs
+++ b/egui/src/ui.rs
@@ -3,6 +3,7 @@
 use std::{hash::Hash, sync::Arc};
 
 use crate::{color::*, containers::*, layout::*, paint::*, widgets::*, *};
+use parking_lot::Mutex;
 
 /// Represents a region of the screen
 /// with a type of layout (horizontal or vertical).
@@ -166,7 +167,7 @@ impl Ui {
 
     /// The `Fonts` of the `Context` associated with the `Ui`.
     /// Equivalent to `.ctx().fonts()`.
-    pub fn fonts(&self) -> &Fonts {
+    pub fn fonts(&self) -> Arc<Mutex<Fonts>> {
         self.ctx().fonts()
     }
 
diff --git a/egui/src/widgets/mod.rs b/egui/src/widgets/mod.rs
index 93a4917222f..438ff9ad108 100644
--- a/egui/src/widgets/mod.rs
+++ b/egui/src/widgets/mod.rs
@@ -6,7 +6,7 @@
 
 #![allow(clippy::new_without_default)]
 
-use crate::{layout::Direction, *};
+use crate::{layout::Direction, paint::fonts::GlyphLayout, paint::*, *};
 
 pub mod color_picker;
 mod drag_value;
@@ -16,8 +16,6 @@ pub(crate) mod text_edit;
 
 pub use {drag_value::DragValue, image::Image, slider::*, text_edit::*};
 
-use paint::*;
-
 // ----------------------------------------------------------------------------
 
 /// Anything implementing Widget can be added to a Ui with `Ui::add`
@@ -74,7 +72,7 @@ impl Label {
         self
     }
 
-    pub fn layout(&self, ui: &Ui) -> font::Galley {
+    pub fn layout(&self, ui: &Ui) -> GlyphLayout {
         let max_width = ui.available().width();
         // Prevent word-wrapping after a single letter, and other silly shit:
         // TODO: general "don't force labels and similar to wrap so early"
@@ -82,19 +80,20 @@ impl Label {
         self.layout_width(ui, max_width)
     }
 
-    pub fn layout_width(&self, ui: &Ui, max_width: f32) -> font::Galley {
+    pub fn layout_width(&self, ui: &Ui, max_width: f32) -> GlyphLayout {
         let text_style = self.text_style_or_default(ui.style());
-        let font = &ui.fonts()[text_style];
         if self.multiline {
-            font.layout_multiline(self.text.clone(), max_width) // TODO: avoid clone
+            ui.fonts()
+                .lock()
+                .layout_multiline(text_style, &self.text, Some(max_width))
         } else {
-            font.layout_single_line(self.text.clone()) // TODO: avoid clone
+            ui.fonts().lock().layout_single_line(text_style, &self.text)
         }
     }
 
     pub fn font_height(&self, fonts: &Fonts, style: &Style) -> f32 {
         let text_style = self.text_style_or_default(style);
-        fonts[text_style].height()
+        fonts.text_style_height(text_style)
     }
 
     // TODO: this should return a LabelLayout which has a paint method.
@@ -105,12 +104,12 @@ impl Label {
     // TODO: a paint method for painting anywhere in a ui.
     // This should be the easiest method of putting text anywhere.
 
-    pub fn paint_galley(&self, ui: &mut Ui, pos: Pos2, galley: font::Galley) {
+    pub fn paint_layout(&self, ui: &mut Ui, pos: Pos2, layout: GlyphLayout) {
         let text_style = self.text_style_or_default(ui.style());
         let text_color = self
             .text_color
             .unwrap_or_else(|| ui.style().visuals.text_color());
-        ui.painter().galley(pos, galley, text_style, text_color);
+        ui.painter().layout(pos, layout, text_style, text_color);
     }
 
     /// Read the text style, or get the default for the current style
@@ -130,9 +129,9 @@ macro_rules! label {
 
 impl Widget for Label {
     fn ui(self, ui: &mut Ui) -> Response {
-        let galley = self.layout(ui);
-        let rect = ui.allocate_space(galley.size);
-        self.paint_galley(ui, rect.min, galley);
+        let layout = self.layout(ui);
+        let rect = ui.allocate_space(layout.size);
+        self.paint_layout(ui, rect.min, layout);
         ui.interact_hover(rect)
     }
 }
@@ -182,13 +181,14 @@ impl Hyperlink {
 impl Widget for Hyperlink {
     fn ui(self, ui: &mut Ui) -> Response {
         let Hyperlink { url, text } = self;
-
         let color = color::LIGHT_BLUE;
         let text_style = ui.style().body_text_style;
         let id = ui.make_child_id(&url);
-        let font = &ui.fonts()[text_style];
-        let galley = font.layout_multiline(text, ui.available().width());
-        let rect = ui.allocate_space(galley.size);
+        let layout =
+            ui.fonts()
+                .lock()
+                .layout_multiline(text_style, &text, Some(ui.available().width()));
+        let rect = ui.allocate_space(layout.size);
         let response = ui.interact(rect, id, Sense::click());
         if response.hovered {
             ui.ctx().output().cursor_icon = CursorIcon::PointingHand;
@@ -197,10 +197,13 @@ impl Widget for Hyperlink {
             ui.ctx().output().open_url = Some(url.clone());
         }
 
+        // FIXME Render the underline (render under all glyphs?)
+        /*
         let visuals = ui.style().interact(&response);
-
+        // Render the underline
         if response.hovered {
-            // Underline:
+
+
             for line in &galley.lines {
                 let pos = response.rect.min;
                 let y = pos.y + line.y_max;
@@ -213,9 +216,10 @@ impl Widget for Hyperlink {
                 );
             }
         }
+        */
 
         ui.painter()
-            .galley(response.rect.min, galley, text_style, color);
+            .layout(response.rect.min, layout, text_style, color);
 
         response.on_hover_text(url)
     }
@@ -294,9 +298,11 @@ impl Widget for Button {
         let button_padding = ui.style().spacing.button_padding;
 
         let id = ui.make_position_id();
-        let font = &ui.fonts()[text_style];
-        let galley = font.layout_multiline(text, ui.available().width());
-        let mut desired_size = galley.size + 2.0 * button_padding;
+        let layout =
+            ui.fonts()
+                .lock()
+                .layout_multiline(text_style, &text, Some(ui.available().width()));
+        let mut desired_size = layout.size + 2.0 * button_padding;
         desired_size = desired_size.at_least(ui.style().spacing.interact_size);
         let rect = ui.allocate_space(desired_size);
 
@@ -305,7 +311,7 @@ impl Widget for Button {
         // let text_cursor = response.rect.center() - 0.5 * galley.size; // centered-centered (looks bad for justified drop-down menus
         let text_cursor = pos2(
             response.rect.left() + button_padding.x,
-            response.rect.center().y - 0.5 * galley.size.y,
+            response.rect.center().y - 0.5 * layout.size.y,
         ); // left-centered
         let fill = fill.unwrap_or(visuals.bg_fill);
         ui.painter().rect(
@@ -318,7 +324,7 @@ impl Widget for Button {
             .or(ui.style().visuals.override_text_color)
             .unwrap_or_else(|| visuals.text_color());
         ui.painter()
-            .galley(text_cursor, galley, text_style, text_color);
+            .layout(text_cursor, layout, text_style, text_color);
         response
     }
 }
@@ -359,15 +365,14 @@ impl<'a> Widget for Checkbox<'a> {
 
         let id = ui.make_position_id();
         let text_style = TextStyle::Button;
-        let font = &ui.fonts()[text_style];
-        let galley = font.layout_single_line(text);
+        let layout = ui.fonts().lock().layout_single_line(text_style, &text);
 
         let spacing = &ui.style().spacing;
         let icon_width = spacing.icon_width;
         let icon_spacing = ui.style().spacing.icon_spacing;
         let button_padding = spacing.button_padding;
         let mut desired_size =
-            button_padding + vec2(icon_width + icon_spacing, 0.0) + galley.size + button_padding;
+            button_padding + vec2(icon_width + icon_spacing, 0.0) + layout.size + button_padding;
         desired_size = desired_size.at_least(spacing.interact_size);
         desired_size.y = desired_size.y.max(icon_width);
         let rect = ui.allocate_space(desired_size);
@@ -380,7 +385,7 @@ impl<'a> Widget for Checkbox<'a> {
         let visuals = ui.style().interact(&response);
         let text_cursor = pos2(
             response.rect.min.x + button_padding.x + icon_width + icon_spacing,
-            response.rect.center().y - 0.5 * galley.size.y,
+            response.rect.center().y - 0.5 * layout.size.y,
         );
         let (small_icon_rect, big_icon_rect) = ui.style().spacing.icon_rectangles(response.rect);
         ui.painter().add(PaintCmd::Rect {
@@ -407,7 +412,7 @@ impl<'a> Widget for Checkbox<'a> {
             .or(ui.style().visuals.override_text_color)
             .unwrap_or_else(|| visuals.text_color());
         ui.painter()
-            .galley(text_cursor, galley, text_style, text_color);
+            .layout(text_cursor, layout, text_style, text_color);
         response
     }
 }
@@ -446,14 +451,16 @@ impl Widget for RadioButton {
         } = self;
         let id = ui.make_position_id();
         let text_style = TextStyle::Button;
-        let font = &ui.fonts()[text_style];
-        let galley = font.layout_multiline(text, ui.available().width());
+        let layout =
+            ui.fonts()
+                .lock()
+                .layout_multiline(text_style, &text, Some(ui.available().width()));
 
         let icon_width = ui.style().spacing.icon_width;
         let icon_spacing = ui.style().spacing.icon_spacing;
         let button_padding = ui.style().spacing.button_padding;
         let mut desired_size =
-            button_padding + vec2(icon_width + icon_spacing, 0.0) + galley.size + button_padding;
+            button_padding + vec2(icon_width + icon_spacing, 0.0) + layout.size + button_padding;
         desired_size = desired_size.at_least(ui.style().spacing.interact_size);
         desired_size.y = desired_size.y.max(icon_width);
         let rect = ui.allocate_space(desired_size);
@@ -462,7 +469,7 @@ impl Widget for RadioButton {
 
         let text_cursor = pos2(
             response.rect.min.x + button_padding.x + icon_width + icon_spacing,
-            response.rect.center().y - 0.5 * galley.size.y,
+            response.rect.center().y - 0.5 * layout.size.y,
         );
 
         let visuals = ui.style().interact(&response);
@@ -492,7 +499,7 @@ impl Widget for RadioButton {
         let text_color = text_color
             .or(ui.style().visuals.override_text_color)
             .unwrap_or_else(|| visuals.text_color());
-        painter.galley(text_cursor, galley, text_style, text_color);
+        painter.layout(text_cursor, layout, text_style, text_color);
         response
     }
 }
diff --git a/egui/src/widgets/slider.rs b/egui/src/widgets/slider.rs
index 6f4238245b8..d407abce135 100644
--- a/egui/src/widgets/slider.rs
+++ b/egui/src/widgets/slider.rs
@@ -354,9 +354,10 @@ impl<'a> Slider<'a> {
 impl<'a> Widget for Slider<'a> {
     fn ui(mut self, ui: &mut Ui) -> Response {
         let text_style = TextStyle::Button;
-        let font = &ui.fonts()[text_style];
-        let height = font
-            .line_spacing()
+        let height = ui
+            .fonts()
+            .lock()
+            .text_style_line_spacing(text_style)
             .at_least(ui.style().spacing.interact_size.y);
 
         if self.text.is_some() {
diff --git a/egui/src/widgets/text_edit.rs b/egui/src/widgets/text_edit.rs
index 512cd6cad41..462f4c8eaa1 100644
--- a/egui/src/widgets/text_edit.rs
+++ b/egui/src/widgets/text_edit.rs
@@ -96,17 +96,19 @@ impl<'t> Widget for TextEdit<'t> {
         let mut state = ui.memory().text_edit.get(&id).cloned().unwrap_or_default();
 
         let text_style = text_style.unwrap_or_else(|| ui.style().body_text_style);
-        let font = &ui.fonts()[text_style];
-        let line_spacing = font.line_spacing();
+
+        let line_spacing = ui.fonts().lock().text_style_line_spacing(text_style);
         let available_width = ui.available().width();
-        let mut galley = if multiline {
-            font.layout_multiline(text.clone(), available_width)
+        let layout = if multiline {
+            ui.fonts()
+                .lock()
+                .layout_multiline(text_style, text, Some(available_width))
         } else {
-            font.layout_single_line(text.clone())
+            ui.fonts().lock().layout_single_line(text_style, text)
         };
         let desired_size = vec2(
-            galley.size.x.max(desired_width.min(available_width)),
-            galley.size.y.max(line_spacing),
+            layout.size.x.max(desired_width.min(available_width)),
+            layout.size.y.max(line_spacing),
         );
         let rect = ui.allocate_space(desired_size);
         let sense = if enabled {
@@ -118,9 +120,11 @@ impl<'t> Widget for TextEdit<'t> {
 
         if response.clicked && enabled {
             ui.memory().request_kb_focus(id);
-            if let Some(mouse_pos) = ui.input().mouse.pos {
-                state.cursor = Some(galley.char_at(mouse_pos - response.rect.min).char_idx);
-            }
+        /* FIXME find the character under the cursor
+        if let Some(mouse_pos) = ui.input().mouse.pos {
+            state.cursor = Some(layout.char_at(mouse_pos - response.rect.min).char_idx);
+        }
+         */
         } else if ui.input().mouse.click || (ui.input().mouse.pressed && !response.hovered) {
             // User clicked somewhere else
             ui.memory().surrender_kb_focus(id);
@@ -172,14 +176,13 @@ impl<'t> Widget for TextEdit<'t> {
             state.cursor = Some(cursor);
 
             // layout again to avoid frame delay:
-            let font = &ui.fonts()[text_style];
-            galley = if multiline {
-                font.layout_multiline(text.clone(), available_width)
+            if multiline {
+                ui.fonts()
+                    .lock()
+                    .layout_multiline(text_style, text, Some(available_width));
             } else {
-                font.layout_single_line(text.clone())
+                ui.fonts().lock().layout_single_line(text_style, text);
             };
-
-            // dbg!(&galley);
         }
 
         let painter = ui.painter();
@@ -196,8 +199,10 @@ impl<'t> Widget for TextEdit<'t> {
             });
         }
 
+        /* FIXME Print the cursor
         if ui.memory().has_kb_focus(id) {
             let cursor_blink_hz = ui.style().visuals.cursor_blink_hz;
+
             let show_cursor = if 0.0 < cursor_blink_hz {
                 ui.ctx().request_repaint(); // TODO: only when cursor blinks on or off
                 (ui.input().time * cursor_blink_hz as f64 * 3.0).floor() as i64 % 3 != 0
@@ -205,6 +210,7 @@ impl<'t> Widget for TextEdit<'t> {
                 true
             };
 
+
             if show_cursor {
                 if let Some(cursor) = state.cursor {
                     let cursor_pos = response.rect.min + galley.char_start_pos(cursor);
@@ -215,11 +221,11 @@ impl<'t> Widget for TextEdit<'t> {
                 }
             }
         }
-
+        */
         let text_color = text_color
             .or(ui.style().visuals.override_text_color)
             .unwrap_or_else(|| visuals.text_color());
-        painter.galley(response.rect.min, galley, text_style, text_color);
+        painter.layout(response.rect.min, layout, text_style, text_color);
         ui.memory().text_edit.insert(id, state);
         response
     }