MLFont: Machine Learning-Driven Font Subsetting and Range-Compact Unicode-Range Slicing for Low-Latency Web Typography

Quan Wang; Yiran Mao

cs.LGOct 18, 2026

MLFont: Machine Learning-Driven Font Subsetting and Range-Compact Unicode-Range Slicing for Low-Latency Web Typography

Authors: Quan Wang, Yiran Mao

Abstract

CSS3 @font-face rules with unicode-range descriptors partition web fonts into downloadable slices. While Latin fonts need ~20 KB in WOFF2, Pan-European (LGC) and East Asian (CJK) fonts contain 2,297-30,759 codepoints (158 KB-5.9 MB in WOFF2), where heuristic partitioning causes unused-glyph downloads, high HTTP RTT, CSS bloat, or missing-glyph fallbacks. We present MLFont, a machine learning and optimization framework that learns font slicing strategies from corpora via three stages: (1) a Zipfian High-Frequency Tier (most) isolating top-frequency codepoints; (2) a Latent Co-Occurrence Topic Tier using Online Variational Bayes LDA (Online LDA) or a Deep Neural Network Topic Model (DNNTM) with Shannon Entropy Difference Loss and Sinkhorn-Knopp normalization; and (3) a Memetic Range-Compact Genetic Algorithm (GA) with Potts-Viterbi dynamic programming and island bridging that minimizes topic discrepancy and CSS fragmentation. Across five Google Noto fonts (LGC, KR, JP, TC, SC), MLFont cuts 3G per-glyph latency by 56.7%-75.3% over single-file delivery and 46.1%-66.3% over equal-bin baselines on CJK with 100% coverage, reduces CSS intervals by 17.9%-41.7%, and achieves 1.56x-6.09x cold-cache speedups (65.4%-84.9% CJK and 44.7% LGC bandwidth savings) across 20 websites in simulator and Headless Chrome benchmarks (45/45 exact slice-set parity). Code: https://github.com/wq2012/mlfont Models: https://huggingface.co/collections/wq2012/mlfont

Figures & tables

Figure 1: (a) Empirical Zipfian decay of codepoint document frequencies across five Google Noto fonts on Wikipedia corpora, motivating Tier-1 high-frequency isolation ( most_1..M ). (b) Pareto trade-off between mean per-glyph download latency ( GIN-3g , session length

L=10

) and total CSS unicode-range intervals on Noto Sans SC (

30{,}759

codepoints).

Figure 2: Convergence of the Memetic Range-Compact Genetic Algorithm ( RangeCompactGeneticLearner ) across all five Google Noto fonts over

T=1200

generations: (a) relative population range fragmentation cost

C_{\text{range}}(t)/C_{\text{range}}(0)

, (b) best per-codepoint topic consistency cost

C_{\text{topic}}(t)/V_{\text{rem}}

, and (c) power-law slice-capacity curriculum

\text{max\_diff}(t)

(

p=3.0

Font Family	Strategy	Slices	Missing (Eval / Font)	CSS Ranges	Mean (ms)	P95 (ms)	Upfront Util	Session Util
Noto Sans LGC	single_slice	1	0 / 0	123	15.22	143.10	2.83%	8.66%
( $2,297$ cps)	equal_bin_20	20	0 / 0	140	9.44	43.41	20.92%	23.17%
	random_slice_20	20	0 / 0	2,180	27.11	256.54	2.91%	8.66%
	language_slice ( .nam )	8	6 / 300	92	10.62	66.28	18.85%	15.08%
	MLFont Online LDA (20 slices)	20	0 / 0	537	7.11	40.95	19.16%	31.26%
	MLFont DNNTM (20 slices)	20	0 / 0	549	6.59	31.88	31.79%	32.56%

Table 1: Main benchmark results on GIN-3g (

\tau_{\text{RTT}}=400

ms,

\beta_{\text{BW}}=50

bytes/ms, session length

L=10

) across all five Google Noto fonts. Missing (Eval / Font) reports uncovered evaluation corpus codepoints and unassigned font cmap codepoints. Best full-coverage (

0/0

missing) metrics per font are bolded.

Figure 3: Cross-font evaluation on GIN-3g (

L=10

pages/session) across all five Google Noto fonts: (a) Mean per-glyph download latency (ms, lower is better) and (b) Session glyph cache utilization (%, higher is better).

Normalization ( $K=20$ )	Ranges	2G (ms)	3G (ms)	Sess Util
row_sum (Row $L_{1}$ )	421	25.15	7.12	31.15%
topic_sum (Col $L_{1}$ )	549	25.17	7.12	31.26%
global_max ( $L_{\infty}$ )	537	25.15	7.11	31.26%
spectral_norm ( $L_{2}$ )	537	25.15	7.11	31.26%
sinkhorn (Bi-stochastic)	542	24.65	6.98	31.77%
DNNTM Loss Objective ( $K=20$ )	Ranges	2G (ms)	3G (ms)	Sess Util

Table 2: Ablation studies on Noto Sans LGC (

K=20

): (Top) Topic affinity matrix normalization. (Middle) DNNTM training loss objectives. (Bottom) Topic slice count

K

(

K_{\text{eff}}

Strategy ( Noto Sans SC )	$L=1$ (ms)	$L=3$ (ms)	$L=10$ (ms)	Sess Util ( $L=10$ )
single_slice	418.33	152.09	63.47	5.55%
equal_bin_102	296.91	116.97	45.26	7.63%
most_1000_500_equal_bin_100	130.06	73.57	29.38	7.82%
MLFont Online LDA ( $102$ )	81.79	36.68	15.93	16.90%
MLFont DNNTM ( $102$ )	78.20	35.89	15.71	16.57%
MLFont Range-Compact GA ( $102$ )	89.11	40.78	17.67	14.64%

Table 3: Effect of browsing session length

L\in\{1,3,10\}

on mean per-glyph latency (ms) and session utilization (

L=10

) on Noto Sans SC ( GIN-3g ).

Appendix figures & tables5 assets

Supplementary material from the paper’s appendix.

Appendix

System Component	Open-Source Implementation ( mlfont )
Data & Corpus Processing	Pure Python 3.10+ with NumPy & SciPy sparse co-occurrence matrices over public Wikimedia/Wikipedia corpora ( wikimedia/wikipedia )
Tier-1 Frequency Isolation	Deterministic Zipfian document-frequency partitioner ( FrequencySolver , most_1..M )
Online LDA Solver	OnlineLdaLearner with two-tier Hungarian contiguous-bin Bayes alignment + Sinkhorn-Knopp bi-stochastic scaling
Neural Topic Model (DNNTM)	PyTorch DnnTmLearner unifying non-negative Shannon Entropy Difference Losses with Nonnegative Sparse Autoencoder reconstruction
Combinatorial Optimizer	Memetic RangeCompactGeneticLearner ( PowerDecay $p=3.0$ + Lagrangian 1D Potts-Viterbi DP + Sparse-Tail Island Bridging)
Physical Font Subsetting	fontTools.subset ( woff2 Brotli compression) + CSS3 @font-face unicode-range stylesheet generator

Appendix

Table 4: Summary of core algorithmic modules and engineering capabilities in the open-source mlfont library.

Hugging Face Repository	Font Binary	Languages / Scripts	Codepoints	Tier-1 ( most )	Topics $K$ ( $K_{\text{eff}}$ )	Total Slices	Physical WOFF2 (CSS)
wq2012/mlfont-notosans-lgc	NotoSans-Regular.ttf	en, de, fr, pl, ru, el	$2,297$	$\emptyset$	$20$ ( $5$ )	$20$	$434.1$ KB ( $7.8$ KB CSS)
wq2012/mlfont-notosanskr	NotoSansKR-Regular.otf	Korean ( ko , Hangul/Hanja)	$22,853$	$(300,300)$	$50$ ( $6$ )	$52$	$5.29$ MB ( $78.0$ KB CSS)
wq2012/mlfont-notosansjp	NotoSansJP-Regular.otf	Japanese ( ja , Kanji/Kana)	$16,663$	$(500,500)$	$60$ ( $12$ )	$62$	$4.67$ MB ( $85.3$ KB CSS)
wq2012/mlfont-notosanstc	NotoSansTC-Regular.otf	Trad. Chinese ( zh-Hant )	$20,637$	$(600,600)$	$80$ ( $20$ )	$82$	$5.94$ MB ( $104.1$ KB CSS)
wq2012/mlfont-notosanssc	NotoSansSC-Regular.otf	Simp. Chinese ( zh-Hans )	$30,759$	$(1000,500)$	$100$ ( $18$ )	$102$	$8.89$ MB ( $83.9$ KB CSS)

Appendix

Table 5: Summary of released pretrained MLFont models and physically sliced WOFF2 Google Noto font bundles on Hugging Face ( https://huggingface.co/collections/wq2012/mlfont ).

Font Family	Strategy	CSS Ranges	2G Mean	2G P95	3G Mean	3G P95	DSL Mean	DSL P95	ADSL2+ Mean
Noto Sans LGC	single_slice	123	60.26	566.45	15.22	143.10	3.00	28.17	0.37
( $2,297$ cps)	equal_bin_20	140	33.37	153.43	9.44	43.41	1.56	7.17	0.65
	random_slice_20	2,180	95.82	906.75	27.11	256.54	4.48	42.35	1.87
	language_slice ( $300$ unass.)	92	40.17	258.54	10.62	66.28	1.95	12.76	0.45
	MLFont Online LDA (20)	537	25.15	144.76	7.11	40.95	1.17	6.76	0.49
	MLFont DNNTM (20)	549	23.29	112.70	6.59	31.88	1.09	5.26	0.45

Appendix

Table 6: Complete cross-network latency benchmark results (Mean and P95 per-glyph latency in ms,

L=10

pages/session) across GIN-2g , GIN-3g , residential-DSL , and residential-ADSL2+ for all five Google Noto fonts.

Font Family	Slices	Avg WOFF2 B/glyph	GIN-3g ( $200$ B)	GIN-3g (Physical WOFF2)	DSL ( $200$ B)	DSL (Physical WOFF2)
Noto Sans LGC	20	$193.5$ B	7.06 / 40.06	6.71 / 39.49	1.17 / 6.64	1.10 / 6.47
Noto Sans KR	52	$242.9$ B	21.06 / 93.00	25.52 / 116.06	3.91 / 17.27	4.80 / 22.05
Noto Sans JP	62	$293.7$ B	11.37 / 59.70	16.29 / 87.35	2.05 / 10.79	3.04 / 16.37
Noto Sans TC	82	$302.0$ B	15.07 / 71.62	20.75 / 99.90	2.71 / 12.79	3.85 / 18.42
Noto Sans SC	102	$303.2$ B	17.67 / 94.33	23.96 / 126.04	3.23 / 17.32	4.49 / 23.67

Appendix

Table 7: Comparison of canonical

200

B/glyph simulation vs. exact physical WOFF2 slice byte sizes

B_{\text{WOFF2}}(S_{k})

for MLFont Range-Compact GA (

L=10

Table 11

VecGlypher: Unified Vector Glyph Generation with Language Models
Feb 25, 2026Xiaoke Huang, Bhavul Gauri, Kam Woh Ng +12Vector Graphics Generation Text-to-SVG Generation
Meta AI · UC, Santa Cruz
Hierarchical Co-Embedding of Font Shapes and Impression Tags
Apr 5, 2026Yugo Kubota, Kaito Shiku, Seiichi UchidaMultimodal Embedding Vision-Language Retrieval
Kyushu University, Fukuoka, Japan
LoGAN: Multilingual Font Localization with Generative Agents
Sep 7, 2026Zhuoning Yuan, Ta-Ying Cheng, Benjamin Klein
Netflix

Feb 25, 2026J/K move · Enter open · S save

VecGlypher: Unified Vector Glyph Generation with Language Models

Xiaoke Huang, Bhavul Gauri, Kam Woh Ng, Tony Ng+11

Meta AI · UC, Santa Cruz

Vector Graphics Generation Text-to-SVG Generation Multimodal Large Language Models

Open paper AskPDF arXiv

Vector glyphs are the atomic units of digital typography, yet most learning-based pipelines still depend on carefully curated exemplar sheets and raster-to-vector postprocessing, which limits accessibility and editability. We introduce VecGlypher, a single multimodal language model that generates high-fidelity vector glyphs directly from text descriptions or image exemplars. Given a style prompt, optional reference glyph images, and a target character, VecGlypher autoregressively emits SVG path tokens, avoiding raster intermediates and producing editable, watertight outlines in one pass. A typography-aware data and training recipe makes this possible: (i) a large-scale continuation stage on 39K noisy Envato fonts to master SVG syntax and long-horizon geometry, followed by (ii) post-training on 2.5K expert-annotated Google Fonts with descriptive tags and exemplars to align language and imagery with geometry; preprocessing normalizes coordinate frames, canonicalizes paths, de-duplicates families, and quantizes coordinates for stable long-sequence decoding. On cross-family OOD evaluation, VecGlypher substantially outperforms both general-purpose LLMs and specialized vector-font baselines for text-only generation, while image-referenced generation reaches a state-of-the-art performance, with marked gains over DeepVecFont-v2 and DualVector. Ablations show that model scale and the two-stage recipe are critical and that absolute-coordinate serialization yields the best geometry. VecGlypher lowers the barrier to font creation by letting users design with words or exemplars, and provides a scalable foundation for future multimodal design tools.

Abstract

Explore similar work

VecGlypher: Unified Vector Glyph Generation with Language Models

Hierarchical Co-Embedding of Font Shapes and Impression Tags

LoGAN: Multilingual Font Localization with Generative Agents