[read-fonts] a new Font API by dfrg · Pull Request #1852 · googlefonts/fontations

dfrg · 2026-05-01T15:14:25Z

Where we open the door to a more ergonomic API that supports sanitization, caching, sourcing data from platform native font handles and nicer interop for skrifa/harfrust.

Rationale at googlefonts/oxidize#77

Where we open the door to a more ergonomic API that supports sanitization, caching, sourcing data from platform native font handles and nicer interop for skrifa/harfrust.

dfrg · 2026-05-01T15:36:28Z

+    fn try_load<T>(
+        &self,
+        sanitize_fn: impl Fn(&'a [u8]) -> Result<T, ReadError>,
+        load_fn: impl Fn(&'a [u8]) -> Result<T, ReadError>,
+    ) -> Result<T, ReadError> {
+        match self.flag.load(Ordering::Acquire) {
+            Self::UNCHECKED => {
+                if let Ok(table) = sanitize_fn(self.data) {
+                    self.flag.store(Self::VALID, Ordering::Release);
+                    Ok(table)
+                } else {
+                    self.flag.store(Self::INVALID, Ordering::Release);
+                    Err(ReadError::ValidationError)
+                }
+            }
+            Self::VALID => load_fn(self.data),
+            // Assume any other bit pattern is invalid
+            _ => Err(ReadError::ValidationError),
+        }
+    }
+}


This is the hook for tracking sanitize state.

dfrg · 2026-05-01T15:38:28Z

+    fn load_table_with_tag<'a, T: FontRead<'a>>(
+        &'a self,
+        state: Option<TableState<'a>>,
+        tag: Tag,
+    ) -> Result<T, ReadError> {
+        let state = state.ok_or(ReadError::TableIsMissing(tag))?;
+        state.try_load(
+            |data| FontRead::read(data.into()),
+            |data| FontRead::read(data.into()),
+        )
+    }


And this is where try_load is called. Since this isn't built on the sanitize branch, we currently just pass FontRead::read for both the sanitize and load fns.

behdad · 2026-05-02T17:13:49Z

+    ///
+    /// The field contains the number of available fonts. This is always 1 for
+    /// .ttf and .otf files and usually greater than 1 for .ttc and .otc files.
+    OpenType(u32),


Nit. AAT uses the same SFNT container but is not technically OpenType.

This was originally Sfnt (here and in other places) but that seemed too obtuse. Any suggestions for a better name?

edit: I should say that I think sfnt is the most accurate name for this but felt that others might find it too obtuse so changed it preemptively.

Nothing other than Sfnt comes to mind. But maybe TrueType as the ancestor of all works better? Donno. Fine with OpenType.

behdad · 2026-05-02T17:15:26Z

+    }
+
+    fn sbix(&self) -> Result<tables::sbix::Sbix<'a>, ReadError> {
+        // should we make the user pass this in?


I don't think it's needed.

I believe this comment was copied from the first impl of TableProvider but I agree. We should probably remove the is_long parameter from loca() as well since I don’t think anyone uses it.

nicoburns · 2026-05-07T12:18:01Z

+#[derive(Clone)]
+pub enum FontBlob {
+    /// A borrowed static reference to a slice of bytes.
+    Static(&'static [u8]),


What is the motivation for the static variant here? Const construction of FontBlobs? Cheaper cloning of static FontBlobs?

(because &'static [u8] wrapped in Arc is a valid Arc<dyn AsRef<[u8]> + Send + Sync>, and this enum is introducing a branch in accessing the font data)

I guess perhaps accessing the font data pointer isn't a on a hot path as this design as you end up with cached pointers into specific parts of the data? But it occurs to me that it ought to be possible with some unsafe code to remove the branch required when accessing the data here (branch would still be required for Clone and Drop).

Might be that you have to require Deref or even StableDeref rather AsRef for that to be sound though.

The motivation was mostly unsafe FFIs where we can potentially avoid an unnecessary allocation and (as you pointed out) indirection. This is probably premature optimization and we can likely omit it when we stabilize the API.

We might indeed start using unsafe at some point to cache preparsed tables (or groups of tables!) internally. Another option is to make FontTables a wrapper type with a lifetime that resolves all the indirections on construction so we can avoid them during bulk table lookup although the compiler possibly does this for us.

and make `Font::tables()` infallible by using empty `FontTables` type with `TableSource::None` for non-SFNT fonts

- and some additional tests - fix typos

- move FontSource to its own module - add FontKindRepr and change FontKind to take references; this will support future support for pure CFF - feature gate whole API

to satisfy clippy

dfrg · 2026-06-16T15:56:37Z

This is now ready for review.

As discussed elsewhere, this is now gated on a new experimental_font_api feature. The code is basically a minimal subset of functionality required to get HarfRust working on macOS.

The new API basically looks like this:

// Create a font, shareable among multiple instances
let font = Font::new(font_data, 1).unwrap();

// Want to access some font tables?
let tables = font.tables();
let glyf = tables.glyf().unwrap();

// We have an SFNT at index 1
assert!(matches!(font.kind(), FontKind::Sfnt(_, 1)));

// Create an instance at 16px, wght=450, wdth=75
let instance = FontInstance::builder(&font).size(Some(16.0)).variations([("wght", 450.0), ("wdth", 75.0)]).build();
// Check some basic properties
assert_eq!(instance.size(), Some(16.0));
assert!(!instance.normalized_coords().is_empty());

// Shaping with HarfRust
let glyph_buffer = harfrust::shape(&instance, unicode_buffer, options);

// Perhaps in the future...
instance.glyphs().outline(gid).unwrap().draw(pen);
instance.glyphs().color(gid).unwrap().paint(painter);

We want the font types to remain immutable and thread safe but also want to lazily compute some data. See liberal use of onces and atomics with more to come. See FeatureVarsStorage for fun atomic stuff to avoid loading GSUB/GPOS unless necessary.

Pure CFF is still TODO. We need some "accelerators" to make this work nicely.

cmyr

leaving some comments for potential future discussion, but i'm happy to see this merged and we can iterate on it as needed.

cmyr · 2026-05-01T19:50:34Z

+///
+/// Calling this directly will make your `Font` **UNUSABLE** with
+/// HarfRust.


probably demands more explanation?

cmyr · 2026-05-01T20:12:08Z

+        &self.0.kind
+    }
+
+    /// If this is a table based (i.e. OpenType) font, then returns an object


what do we do otherwise?

[read-fonts] a new Font API

bc57ea0

Where we open the door to a more ergonomic API that supports sanitization, caching, sourcing data from platform native font handles and nicer interop for skrifa/harfrust.

dfrg marked this pull request as draft May 1, 2026 15:17

dfrg mentioned this pull request May 1, 2026

A new (read-fonts) Font API googlefonts/oxidize#77

Open

dfrg added 2 commits May 1, 2026 11:28

lints

870ac4b

more lints

42f448a

dfrg commented May 1, 2026

View reviewed changes

behdad reviewed May 2, 2026

View reviewed changes

dfrg added 2 commits May 3, 2026 19:50

return inner Any for shaping data

2a859f8

add shaping data interop test

5fe0b05

nicoburns reviewed May 7, 2026

View reviewed changes

dfrg mentioned this pull request May 26, 2026

Add support for font funcs harfbuzz/harfrust#365

Merged

dfrg added 7 commits June 14, 2026 13:58

Merge branch 'main' into new-font-api

e585838

add table lookup benchmarks

7372fcc

remove unused fmtx table

058fac1

and make `Font::tables()` infallible by using empty `FontTables` type with `TableSource::None` for non-SFNT fonts

add FontInstance

4294f58

add named_instance_with_overrides

c938743

- and some additional tests - fix typos

minor cleanup

5166c0f

- move FontSource to its own module - add FontKindRepr and change FontKind to take references; this will support future support for pure CFF - feature gate whole API

clippy

c7748ee

dfrg mentioned this pull request Jun 16, 2026

Adopt new read-fonts API harfbuzz/harfrust#389

Merged

feature gate once module as well

4d6a910

to satisfy clippy

dfrg marked this pull request as ready for review June 16, 2026 15:44

export FontTableFunction

a5fe958

cmyr approved these changes Jun 19, 2026

View reviewed changes

cmyr merged commit c4d87b2 into main Jun 19, 2026
18 checks passed

cmyr deleted the new-font-api branch June 19, 2026 15:50

mkorje mentioned this pull request Sep 24, 2026

Migrate from rustybuzz and ttf-parser to harfrust and read-fonts typst/typst#8172

Draft

Conversation

dfrg commented May 1, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

dfrg May 2, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

dfrg commented Jun 16, 2026

Uh oh!

cmyr left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Reviewers

Uh oh!

Assignees

Labels

Projects

Milestone

Development

Uh oh!

4 participants

dfrg commented May 1, 2026 •

edited

Loading

dfrg May 2, 2026 •

edited

Loading