Font Family, Static Variants & Variable Fonts❤️

[Nicolas-Red]

Hello! Awesome asset so far. We work in 43 languages and have many fixes in place for TMPro to behave.
We would love to switch to UniText, just digging through and checking all the functionality.

I have a question on something I couldn't find. Right now, when applying Bold Rules, it generates a "fake bold" from the original font. It would be preferable to be able to actually use the real bold font instead when applying bold rules so that the characters look correct.

For example: NotoSansArabic-Regular -> NotoSansArabic-Bold. When applying bold tags to NotoSansArabic-Regular, it should pull from the true characters of NotoSansArabic-Bold.

Thanks!

Here is an example from TMPro. Bolding pulls from the actual Bold font. Character spacing is correct.

Here is an example from UniText. Bolding not pulling from actual Bold font. Character spacing is incorrect.

[LightSideMeowshop]

Heeey! Thank you for your attention❤️ Currently, there is no Font Family support but it is on my radar. My current work is a new revolutionary solution in text rendering. When I implement this logic it should be much easier to implement Font Family feature and more effective than TMP (CPU + RAM performance). I will try to implement it as soon as possible! Wait for updates ❤️

[Nicolas-Red]

Awesome. We'll eagerly await this update. As far as I can tell so far, its literally the only thing missing for us!

[LightSideMeowshop]

I got it! Thanks a ton for your great feedback!

[LightSideMeowshop]

I've finished working on the Font Family implementation, it's already in version 2.0.0, which I plan to release this weekend

Font Family, Static Variants & Variable Fonts — Implementation Summary

What was built

1. Font Family Architecture (UniTextFontStack)

The old flat model (fonts[] + variants[]) has been replaced with a structured FontFamily[] array. Each FontFamily has:

• A primary font (provides strut metrics for the first family, codepoint lookup for all)
• An optional faces[] array — bold, italic, bold-italic, light, variable, etc.
• A pre-computed FontFaceLookup for O(log N) face matching at runtime

FontFaceLookup is built once at initialization and classifies fonts into four buckets:

• uprightWeights[] / uprightFonts[] — sorted static upright faces
• italicWeights[] / italicFonts[] — sorted static italic faces
• variableUpright — variable font for upright (has wght/wdth axes)
• variableItalic — variable font for italic (has ital/slnt axes)

The entire fallback chain (this stack + fallbackStack + its fallbackStack...) is flattened into resolvedFamilies[] with fontIdToFamilyIndex for O(1) family lookup from any font ID.

2. CSS §5.2 Weight Matching (FontFaceLookup.FindFace)

FindFace(targetWeight, italic) implements the CSS Fonts Level 4 §5.2 directional preference algorithm for static face selection.

3. Variable Font Support

• UniTextFont.IsVariable property + VariableAxes metadata (tag, name, min/default/max)
• HarfBuzz and FreeType integration for axis enumeration and coordinate setting
• VariationModifier with tag for direct axis control (wght, wdth, ital, slnt, opsz)
• Three value modes: absolute (700), percentage (150%), delta (+200)
• Per-run variation tracking via VariationRunInfo + variationMap dictionary
• Variation hash for glyph atlas keying — same font can cache glyphs at different axis values

20260311-1639-07.3516028.mp4

4. Three-Tier Face Resolution (TextProcessor.ResolveFontFaces)

A single unified pass over all codepoints with per-cp caching:

Tier 1 — Variable font axes: If the family has a variable font, resolve bold/italic as wght/ital/slnt axis values. Creates a VariationRunInfo, registers the virtual font ID, and clears bold/italic buffers so Tier 3 won't synthesize.

Tier 2 — Static font face: Use CSS §5.2 weight matching via FindFace(). Verifies the face has the glyph before committing. Clears bold buffer always, clears italic buffer only if the selected face is natively italic.

Tier 3 — Synthesis: If neither Tier 1 nor Tier 2 resolved, bold/italic buffers remain non-zero. BoldModifier applies fake bold via SDF dilate + advance correction. ItalicModifier applies vertex shear.

5. Semantic Tags with Fallback

<b> and <i> tags are semantic — they express intent, not mechanism:

• <b> → tries variable wght axis, then static bold face, then falls back to synthesis.
• <i> → tries variable ital/slnt axis, then static italic face, then falls back to vertex shear.

<var> tag is direct axis control — like CSS font-variation-settings. No fallback chain.

6. BoldModifier CSS Weight Scale

Bold is no longer binary. It uses the CSS 100-900 weight scale:

• Default: max(700, baseWeight + 300)
• Explicit: <b=500> for CSS weight 500

7. Editor UX

FontStack editor with family grouping, face management, and drag-and-drop. Font editor shows extracted FaceInfo (weight, italic, family name) and variable font axes.

Key design decisions

1. Variation hashing keys glyph atlas entries by axis values. The same font can render text at weight 400 and weight 700 simultaneously, with different glyph shapes cached independently.

2. Static face selection verifies glyph coverage before committing. If a bold face doesn't have a specific glyph (e.g., rare CJK character), the system falls through to synthesis rather than rendering a .notdef.

3. Bold always clears its buffer after Tier 1/2 resolution (the real font already has the weight). Italic clears only if the resolved face is natively italic — otherwise vertex shear still applies as supplementary synthesis.