HarfBuzz is a ubiquitous open-source text-shaping engine that celebrated its 20th anniversary, powering text rendering across most modern operating systems, browsers, and devices.
Initially designed in C++ with a stable C API, HarfBuzz has evolved beyond basic shaping to include rendering layers (rasterizer, vectorizer, GPU renderer) and font-subsetting libraries to optimize web fonts.
Over the past five years, the project achieved massive performance optimizations driven by Chromium's benchmarks, making it up to three to seven times faster for some fonts.
A major recent development is HarfRust, a high-fidelity safe Rust port of HarfBuzz that reduces performance overhead to just 20% compared to C++ while maintaining compliance with nearly all test suites.
The speaker discusses extending the OpenType format through ISO standardization (e.g., avar2, VARC) to reduce file sizes by up to 90% for complex scripts like Hangul.
An innovative, "long-shot" proposal is presented: embedding WebAssembly (WASM) directly into font files to allow programmable shaping logic, bypassing rigid format limits and enabling advanced features like optical positioning and recursive box modeling.
Performance optimizations in HarfBuzz over five years across different scripts and fonts
[
00:08:50
]
Introduction and Capabilities of HarfBuzz [00:00:17]
HarfBuzz is defined as a C++ platform with a stable C library API and accompanying command-line tools.
The name "HarfBuzz" is a literal Persian translation of "OpenType" (Harf = letter, Buzz = open).
Key components include:
hb-shape: The core text shaper which calculates glyph positions for legible text in any script/font.
Integration layers for GLib, FreeType, Cairo, and platform-specific backends like CoreText and DirectWrite.
hb-subset: Font subsetter and variable font instancer to optimize web font delivery.
hb-draw / hb-paint: APIs to extract outlines for monochrome and color fonts.
New rendering additions (released in 2026/presentation year): hb-raster (grayscale rasterizer), hb-vector (SVG/PDF output), and hb-gpu (using Eric Lengyel's patented Slug algorithm, recently open-sourced).
By the mid-2010s, open-source font compilers, operating systems, and browsers created a bottleneck at the actual font format specification.
Extending the font format became a priority:
avar2: Saves up to 70% in file size for complex Latin variable fonts.
VARC: Compresses Hangul fonts by up to 90% and Chinese/Japanese by up to 70%.
Beyond 64K: Breaks the historic 16-bit limits on the number of glyphs, allowing mega-font families like Google Noto to exist in a single file.
Font format extensions and their corresponding file size savings
[
00:14:40
]
Standardization Challenges:
OpenType is owned by Microsoft; extensions require their support.
Mirroring OpenType in ISO (ISO OpenFontFormat) is an extremely slow process (started in 2022, still unreleased).
Google Chrome is historically reluctant to ship proprietary format extensions until other major engines adopt them. Apple shipped avar2 in late 2022, but Chrome only adopted it in March 2026, representing a "3.5-year standardization tax".
WebAssembly in the Font (The Long Shot) [00:16:30]
Proposal: Securely inject WebAssembly (WASM) directly into the font file to handle shaping logic dynamically.
Advantages:
Breaks the arbitrary code-versus-data boundary (high-level layout uses code, while font remains static data).
Offers a generic solution to highly complex shaping problems (e.g., optical dot positioning in Arabic, recursive box modeling for Egyptian hieroglyphs).
Eliminates the need for constant, hardcoded changes to text shaping engines; engines merely act as WASM container hosts.
Parallels exist in computing, such as the transition from OpenGL's fixed pipelines to programmable shaders.
Progress: Proof of concept developed in HarfBuzz four years ago. A Graphite-shaping WASM engine was successfully embedded within a font inside a 90 KB payload.
Unexpected community experiments:
Embedding a full LLM inference engine inside a font.
Machine learning-based font rendering mimicking a typewriter.
An on-the-fly translator font (typing English, displaying translated German).
Website Demo (harfbuzz-world.cc / harfbuzz.world): A WASM-based portal demonstrating embedding code snippets, glyph cluster outputs (e.g., showing how multiple characters combine to form a single emoji), and subsetting efficiency (saving up to 99% of file size).
GPU Demo: Showcases WebGL and WebGPU rendering using Eric Lengyel's Slug algorithm (patents recently released, allowing integration as hb-gpu). The demo shows infinitely zoomable, rotatable vector shapes and emoji.
WASM-in-Font Demos:
Arabic Nastaliq positioning, showing how WASM resolves character dot overlap through optical collision avoidance with under 100 lines of code.
Egyptian Hieroglyphs rendering via a recursive box layout model.
Arabic Ruq'ah script vertical alignment based on optical centers.
Simon Cousins' "Inception" demo: loads FreeType inside WASM inside a variable font to dynamically alter pixelation parameters (slant, weight, slant, etc.).
Optical kerning using "Bubble Kern" (generating safe boundaries around letters).
Q&A Session:
On the future of WASM: Basic text shaping is largely solved, but complex, highly calligraphic scripts (like Arabic Nastaliq) still struggle under traditional databases. WASM bridges this gap since no single database algorithm can fit all aesthetic requirements.
On Skia/Graphite co-existence: Skia relies on HarfBuzz for shaping, but HarfBuzz's newly integrated rasterizer is designed as a lightweight alternative (without hinting support) for performance-critical engines like games and lightweight mobile applications.
On script performance in browser benchmarks: Browser benchmarks traditionally prioritize Western/Latin/Cyrillic scripts. While including complex scripts like Arabic or Devanagari in standard benchmarks would provide better performance optimization incentives, their omission doesn't break basic support since OpenType features are strictly mandated across major browsers today.
