💻 computer science

NIV: Neural Axis Variations for Variable Font Generation

The paper introduces NIV (Neural Axis Variations), a neural network method that automatically converts static fonts into fully functional variable fonts by predicting per-point glyph displacements using a novel Property Embedding mechanism, enabling consistent multi-axis variations across diverse character sets and styles without manual intervention.

Original authors: Nadav Benedek, Ariel Shamir, Ohad Fried

Published 2026-06-05

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Nadav Benedek, Ariel Shamir, Ohad Fried

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a digital library of books, but every single book is printed in only one specific style: a standard "Regular" font. If you want a "Bold" version for a headline or an "Italic" version for emphasis, a human designer has to manually redraw every single letter for every single style. It's like hiring an artist to hand-paint a new cover for every book in the library just to change the font weight. This is slow, expensive, and why most fonts on your computer are "static"—they only exist in one form.

NIV (Neural Axis Variations) is a new AI tool that acts like a magical "morphing machine" for fonts. It takes a single, static font and automatically turns it into a Variable Font.

Here is how it works, using simple analogies:

1. The "Shape-Shifting" Blueprint

Think of a letter (like the letter "a") not as a fixed drawing, but as a wireframe sculpture made of thousands of tiny, invisible dots (points).

Static Font: The dots are glued in place. The "a" is always the same.
Variable Font: The dots are on springs. You can pull them to make the letter thicker (Weight), stretch it wider (Width), or tilt it (Slant).

The problem is that for a human to make a Variable Font, they have to manually tell the computer exactly how to move every single dot for every single letter when you turn the "Bold" knob.

2. The "Neural Artist"

NIV is an AI that learns the rules of how letters should change shape.

Training: The researchers fed NIV over one million examples of existing Variable Fonts (mostly from Google Fonts). It studied how the dots move when a letter goes from light to bold, or narrow to wide.
The "Property Embedding": This is the paper's secret sauce. Imagine you are giving instructions to a chef. Instead of just saying "add salt," you say "add salt, pepper, and heat, but adjust the amounts based on how spicy you want it." NIV uses a special mechanism called Property Embedding to understand how different "knobs" (axes) interact. It knows that making a letter wider might require a slightly different adjustment than making it bolder, and it can handle turning both knobs at the same time without the letter looking weird.

3. The Magic Trick: One Font, Infinite Styles

Once NIV is trained, you can give it any static font (even one it has never seen before), and it will instantly generate a new, fully functional Variable Font file.

Unseen Characters: If you give it a font that only has the letter "A," NIV can guess how to morph the letter "Z" or even complex Chinese characters, because it learned the geometry of shapes, not just the specific letters.
Handwriting: In a cool experiment, the team took a single person's handwriting, turned it into a static font, and NIV successfully turned it into a Variable Font. It could make that specific handwriting "bolder" or "slanted" even though the AI had never seen that person's handwriting style before.

4. Why Rule-Based Math Failed

Before NIV, people tried to use simple math rules to change fonts.

The Naive Approach: Imagine trying to make a letter wider by just stretching a rubber band horizontally. The problem? The vertical lines of the letter also get thicker, making it look like a fat, distorted mess.
The NIV Approach: NIV is smarter. It knows to stretch the spaces between the lines while keeping the lines themselves thin. It preserves the "soul" of the letter while changing its shape.

The Result

The paper claims that NIV can take a boring, single-style font and turn it into a professional-grade Variable Font file (a .ttf file) that works in your web browser or design software immediately. You can slide a bar to change the weight from light to bold, and the text morphs smoothly without losing quality.

In short: NIV is a neural network that learned the "dance" of how letters move. Now, it can teach any static font to dance, turning a single, rigid design into a flexible, living system that can change shape on the fly.

Technical Summary: NIV (Neural Axis Variations) for Variable Font Generation

Problem Statement

Variable fonts represent a significant advancement in typography, allowing continuous variation of glyph geometry along semantic design axes (e.g., weight, width, slant, optical size) within a single file. However, converting a static font into a functional variable font is traditionally a labor-intensive process requiring expert typographic design. It involves manually defining multiple master glyph outlines and specifying the gvar (glyph variation) data that dictates how every control point in a glyph moves as a function of axis values. Consequently, many existing fonts remain static. While prior neural methods have focused on generating static raster images or individual vector outlines, no existing method has successfully automated the generation of a fully functional, standard-compliant OpenType variable font file from a single static input.

Methodology

The authors introduce NIV (Neural Axis Variations), a two-stage method that automatically converts a static font into a variable font by learning to predict per-point displacements conditioned on design axis values.

1. Data and Input Representation

Dataset: The model is trained on a newly constructed dataset derived from over one million variation tuples extracted from public Google Fonts. The dataset includes per-glyph outline geometry and fully densified per-point variation deltas, normalized to a unified coordinate system.
Input Encoding: Glyphs are represented as ordered sequences of vector outline points (including on-curve, off-curve, and phantom points). Coordinates are normalized to a $[-1, 1]$ range relative to the font's units-per-em (UPM). Each point is augmented with features indicating whether it is on-curve, its contour position, and phantom status.
Axis Conditioning: The model receives a set of target design axes (e.g., wght, slnt) with normalized scalar values in $[-1, 1]$ . A binary mask indicates which axes are active, allowing the model to handle a variable number of axes per example.

2. Model Architecture

NIV employs a sequence-to-sequence geometric model that maps an ordered sequence of glyph point features to a sequence of displacement vectors $(\Delta x, \Delta y)$ .

Backbone: The core consists of a stack of interaction blocks utilizing multi-head self-attention and feed-forward networks with residual connections. Unlike autoregressive models, this architecture processes the entire point sequence simultaneously, respecting the geometric nature of glyph outlines.
Property Embedding: A novel contribution of this work is the Property Embedding mechanism. It captures interactions between multiple axes by learning positive and negative vectors for each axis. These are weighted by the absolute axis values and summed to create a conditioning vector.
Adaptive Layer Normalization (AdaLN): The resulting conditioning vector modulates the internal representations of the network at every interaction block via AdaLN. This enables fine-grained, geometry-aware control over the deformation process, allowing the model to learn complex, higher-order interactions between axes (e.g., how weight and width changes interact) within a unified framework.
Output: A point-wise regression head maps the latent representations to 2D displacement vectors for each control point.

3. Font Generation Pipeline

In the second stage, the trained model constructs the variable font file:

Tuple Construction: The model predicts outline deltas for specific positions in the design space.
Hierarchical Injection: The system builds the gvar table by progressively injecting tuples. It starts with first-order tuples (single axes) and adds higher-order tuples (pairs, triples) as residual corrections.
Residual Learning: For multi-axis coordinates, the model calculates the displacement already explained by lower-order tuples (using OpenType weighting rules) and subtracts this from the model's prediction before writing the new tuple. This ensures that first-order tuples capture single-axis effects while higher-order tuples encode only the necessary interaction terms.
Output: The process yields a standard .ttf file containing fvar and gvar tables, compatible with existing rendering engines.

Key Results and Evaluation

The paper evaluates NIV across several dimensions, demonstrating robust generalization:

Quantitative Performance: On test sets, NIV achieves a Root Mean Squared Error (RMSE) of approximately 0.053 (in normalized delta units) for unseen code points (Unicode split) and 0.052 for unseen font styles (Font split). This significantly outperforms a null baseline (predicting zero displacement), which yields RMSEs around 0.13–0.14.
Unseen Code Points: The model successfully generalizes deformation patterns to Unicode characters not present in the training data, relying solely on geometric structure.
Unseen Font Styles: The method generates coherent variable fonts for static fonts completely absent from the training set, including complex styles.
High-Complexity Scripts: The model demonstrates robustness on CJK (Chinese, Japanese, Korean) fonts (e.g., Meiryo, PingFang), which involve thousands of glyphs and are traditionally difficult to automate.
Out-of-Distribution Generalization: In a challenging test, NIV generated a variable font from a handwriting sample that bore no structural resemblance to the training data, successfully inferring axis-driven deformations for entirely novel shapes.
Reconstruction Fidelity: When applied to reconstruct variable fonts from the test set (by stripping their variations and re-generating them), NIV produced high-fidelity results with only minor imperfections.
Comparison to Baselines: The paper contrasts NIV with rule-based geometric heuristics (e.g., simple scaling). The authors note that naive geometric approaches often fail to preserve structural integrity (e.g., scaling width inadvertently thickens stems), whereas NIV learns to selectively deform appropriate components.

Significance and Claims

The authors position NIV as the first method to generate a functional variable font file with continuous variations from a single static font.

Automation: The approach significantly reduces the manual engineering effort required to create variable fonts, potentially enabling the conversion of vast libraries of static fonts into variable formats.
Unified Framework: By using Property Embedding and AdaLN, the method captures complex, multi-axis interactions that are difficult to define manually or via simple heuristics.
Practical Utility: The output is a standard-compliant OpenType variable font (.ttf) that can be immediately used in browsers and design software without post-processing.
Broader Implications: Beyond typography, the paper suggests that the proposed framework for learning structured, parametric variation in vector graphics could extend to other geometric domains.

The authors maintain a modest stance regarding limitations, acknowledging that the current method focuses on geometric outline deformation and does not yet predict typographic components like kerning, global spacing, or hinting instructions, which remain areas for future research.