Announcing Fonts 3.0.0

Fonts 3 brings .NET 8+, SVG and COLR v1 color fonts, variable fonts, Unicode 17 data, shaping updates, FreeType v40-compatible hinting, and new layout APIs.

ReleasesFontsImageSharp.Drawing

Fonts 3.0.0 is out.

Fonts 3.0.0 includes a .NET 8+ baseline, SVG and COLR v1 color fonts, variable-font support, Unicode 17 data, shaping and layout updates, FreeType v40-compatible TrueType hinting, new measurement and text interaction APIs, and fixes across font loading, shaping, line breaking, bounds, and rendering.

Fonts is a standalone text engine for loading fonts, shaping text, measuring layout, inspecting metrics, and driving custom renderers. It is also part of the Six Labors suite, the only graphics stack in any ecosystem designed top to bottom, by one team, in pure .NET.

The release targets applications that need text layout rather than simple glyph drawing: editors, dashboards, report generators, creative tools, export pipelines, game UI, diagramming systems, and graphics workflows.

V3 is also the first Fonts release to enforce a build-time license key for direct package dependencies. More on that below.

What's new since V2 #

  • A .NET 8+ baseline for the library
  • Public support for SVG color fonts and COLR v1 paint-graph glyphs
  • Variable-font support across fvar, gvar, hvar, vvar, cvar, MVAR, feature variations, and CFF2
  • Unicode 17 data, East Asian Width support, emoji properties, and public Unicode property APIs on CodePoint
  • Grapheme cluster APIs with terminal-cell width calculation and emoji-aware metadata
  • Hebrew and Thai/Lao shapers, plus Indic shaping fixes for dotted-circle insertion and reordering
  • FreeType v40-compatible TrueType hinting
  • Measurement and interaction APIs including TextMetrics, TextBlock, line layout enumeration, hit testing, caret movement, selection bounds, soft hyphenation, ellipsis, and inline placeholders
  • Layout behavior changes for justification, vertical layout, fallback font metrics, and line breaking
  • Performance and allocation work across shaping, glyph lookup, SVG glyph caching, variation instance handling, and color glyph rendering

Color Fonts #

Fonts 3 adds public support for SVG color fonts and COLR v1 paint-graph glyphs.

SVG color fonts and COLR v1 sit alongside COLR v0 support. The renderer can now receive gradients, transforms, clipping, layered paints, and SVG-backed glyph content through the public glyph-rendering pipeline.

using SixLabors.Fonts;

FontCollection collection = new();
FontFamily family = collection.Add("fonts/NotoColorEmoji-Regular.ttf");
Font font = family.CreateFont(32);

TextOptions options = new(font)
{
    ColorFontSupport = ColorFontSupport.ColrV1 | ColorFontSupport.ColrV0 | ColorFontSupport.Svg
};

COLR v1 color font rendering

Fonts 3 renders painted glyphs through the same layout engine used for monochrome glyphs, including COLR v1 paint graphs and SVG-backed color glyphs.

Color fonts are not only for emoji. They also appear in brand, UI, icon, and display-font workflows where monochrome outlines cannot represent the source font.

Fonts resolves these color technologies into a painted-glyph flow through IGlyphRenderer. Consumers can handle layered text, solid paints, linear, radial, and sweep gradients, clip quads, and fill rules without building a separate renderer path for each color-font table.

V3 also separates glyph transforms from paint transforms when flattening COLR v1 paint graphs. That matters for glyphs where the geometry and the paint node transform independently. SVG color glyph parsing now uses document-span caching and default inherited paint handling, reducing repeated parsing work and producing more consistent fallback fills.

Variable fonts arrive in V3 #

Fonts 3 implements variable fonts across the main TrueType and OpenType variation tables.

Fonts 3 implements variable fonts end to end: fvar, gvar, hvar, vvar, cvar, MVAR, feature variations, normalized variation coordinates, and CFF2-based variation data. Design-space coordinates affect outlines, metrics, positioning, control values, and layout behavior across the stack, and V3 handles all of it.

using SixLabors.Fonts;

FontCollection collection = new();
FontFamily family = collection.Add("fonts/RobotoFlex.ttf");

Font font = family.CreateFont(
    16,
    new FontVariation(KnownVariationAxes.Weight, 700),
    new FontVariation(KnownVariationAxes.Width, 85),
    new FontVariation(KnownVariationAxes.OpticalSize, 16));
Adobe Variable Font Prototype at weight 200

Weight 200

Adobe Variable Font Prototype at weight 900

Weight 900

Fonts 3 applies variation data so one font file can expose multiple positions in its design space.

The public API makes all of that accessible. KnownVariationAxes gives developers a straightforward way to target common registered axes, FontVariation follows CSS-style variation semantics, and FontMetrics.TryGetVariationAxes(...) makes it easy to inspect what a font actually exposes.

Variation data affects outlines, metrics, positioning, and hinting. Fonts applies those values during shaping and layout instead of treating a variable font as a static outline source.

Shaping, Unicode, and Layout #

Fonts 3 updates shaping, Unicode data, and line layout.

The shaping engine covers GSUB and GPOS, bidirectional layout, mirrored-form handling, and fallback-aware layout. V3 adds Hebrew and Thai/Lao shapers, Indic fixes for dotted-circle insertion and reordering, and layout refinements backed by browser-comparison tests.

That shows up in the API in practical ways too. TextDirection.Auto, FallbackFontFamilies, TextRuns, known OpenType feature tags, and the line-breaking and layout machinery underneath them all depend on the same shaping core. Fonts handles mixed LTR and RTL content, emoji, fallback-heavy UI strings, scripts that need shaping, and wrapped text that follows Unicode line-breaking data.

The Unicode data has been updated to Unicode 17. CodePoint now exposes public property APIs for script class, Arabic joining data, Indic shaping categories, Indic conjunct break class, East Asian Width, and emoji properties. Grapheme enumeration now returns GraphemeCluster values with UTF-16 offsets, code point counts, flags, and terminal-cell width information.

Terminal-width APIs let callers compute display-cell width for East Asian wide/fullwidth clusters, emoji presentation, emoji ZWJ clusters, ambiguous-width characters, and controls using an explicit TerminalWidthOptions policy.

Layout fixes include line-break state cleanup after colon-separated text, paragraph-final lines no longer being justified, vertical layout fixes, fallback glyph substitution using the resolved fallback font metrics, ligature caret fixes, and safeguards around invalid coverage tables and missing CFF tables.

FreeType v40-compatible hinting #

V3 adds FreeType v40-compatible TrueType hinting.

The implementation executes TrueType instructions and applies control value table data before glyph positioning. That affects small-size UI text, dashboards, editors, terminals, and other dense text surfaces where hinted outlines change pixel placement.

using SixLabors.Fonts;

Font font = SystemFonts.CreateFont("Segoe UI", 11);
TextOptions options = new(font)
{
    Dpi = 96,
    HintingMode = HintingMode.Standard
};

The hinting path includes:

  • full TrueType instruction execution
  • fpgm, prep, and cvt support
  • variable-font cvar adjustments before hinting runs
  • hinted contour-point handling for positioning scenarios that depend on it
  • behavior aligned with FreeType's v40 subpixel interpreter

The goal is stable glyph fit and baseline behavior at UI sizes.

Measurement and custom rendering #

Fonts 3 expands measurement, prepared layout, and renderer-facing APIs.

The measurement APIs separate layout boxes from rendered ink. MeasureAdvance(...) gives you the logical layout rectangle. MeasureBounds(...) gives you tight glyph ink bounds. MeasureRenderableBounds(...) gives you the union of both. That distinction affects overshoot, color glyphs, decorations, and wrapped layout.

When a single layout pass needs to feed several questions at once, TextMeasurer.Measure(...) returns a TextMetrics value that exposes advance, ink bounds, renderable bounds, line metrics, grapheme metrics, and word metrics from one shaping pass, alongside built-in hit testing, caret positioning, and selection geometry for editor-style interactions.

Measurement runs through the same shaping and layout engine that rendering uses, so text fitting, label placement, editor chrome, diagram annotations, and UI layout can use the same glyph positions that rendering will consume.

V3 also adds wrapped-text inspection through CountLines(...) and GetLineMetrics(...), with LineMetrics exposing ascender, baseline, descender, line height, start, and extent for each laid-out line.

For text that is measured, wrapped, or rendered repeatedly at different widths, TextBlock shapes the string once and lets callers vary the wrapping length per call. GetLineLayouts(...) returns stacked block coordinates, while EnumerateLineLayouts() returns line-local coordinates when each line lands in a different column, frame, or shape.

For custom renderers, IGlyphRenderer now receives paint-aware inputs for layered color glyphs, normalized bounds, and layout data that includes the resolved Font used for each glyph. That helps SVG export, PDF generation, game or UI engines, diagnostics tooling, and any surface where Fonts performs shaping while the application owns drawing.

Performance and correctness #

V3 includes performance and correctness work throughout the shaping and layout engine:

  • faster glyph shaping and lookup paths
  • reduced allocations in color glyph processing and related render paths
  • variation instance caching that shares base font lookups across design-space instances
  • measurement and bounds handling that fixes origin and drift issues
  • correctness fixes across vertical layout, decoration placement, ligature carets, and clipping
  • compatibility logic and targeted fixes for awkward or broken fonts

These changes reduce repeated layout work, avoid allocations in glyph streaming and color glyph paths, and fix cases where malformed or unusual fonts previously produced incorrect layout or exceptions.

Breaking and operational changes #

Fonts 3 includes upgrade considerations.

The baseline change is that Fonts now targets .NET 8+.

There are API cleanups and behavior changes across shaping, measurement, color glyphs, decorations, layout defaults, and variation support. If you maintain custom renderers, layout-sensitive tests, or wrappers over the lower-level APIs, review the V3 release notes before upgrading.

Fonts 3 is also the first release of the library to enforce a build-time license key for direct package dependencies.

The licensing behavior is:

  • the license terms themselves are not changing
  • the new part is build-time enforcement through a sixlabors.lic file
  • this applies to direct dependencies, not transitive consumers
  • if you already qualify under the existing terms, your entitlement does not change

If you are using Fonts as a qualifying direct dependency in closed-source software, make sure your licensing setup is in place before upgrading. If you qualify for community licensing, you can apply via licensing.sixlabors.com.

Closing #

Fonts 3 moves the library to .NET 8+, adds SVG and COLR v1 color glyph rendering, implements variable-font tables, updates Unicode data to version 17, adds grapheme and terminal-width APIs, expands measurement and interaction APIs, implements FreeType v40-compatible TrueType hinting, and fixes shaping, layout, bounds, and font-loading edge cases.

Thank you, as always, to everyone who has used the library, reported issues, contributed fixes, and tested previews.

We are excited to see what you build with it.

Fonts 3.0.0 is licensed under the Six Labors Split License. This means that it is free to use in both non-commercial and certain commercial applications. However, if you are using it in a commercial application and your organization has annual gross revenue exceeding 1M USD per year, you must purchase a commercial license. Please see the Pricing page for more information.