FFGaussType: Feed-Forward Conversion of Glyph and SVG Geometry into Compact Gaussian Assets

Haoan Feng, Tianfu Wang, Peimeng Guan, Dae Yeol Lee, Guan-ming SuarXiv 2026 · arXiv

TL;DR

FFGaussType is a novel feed-forward model that converts 2D glyphs and SVG outlines into high-fidelity 3D Gaussian Splatting assets in just 9.1 milliseconds. By mapping surface geometry to a compact, codec-friendly 2D feature plane, it enables the scalable creation and efficient delivery of relightable 3D text and icons for immersive environments.

What Problem Does This Paper Address?

In the world of immersive 3D content, adding text and icons isn't as simple as slapping a 2D overlay on the screen. To feel "real," these elements need to exist within the 3D space, respecting occlusion, perspective, and scene lighting.

While 3D Gaussian Splatting (3DGS) has revolutionized real-time 3D rendering, it typically relies on an iterative optimization process. If you want to add a new word to a scene, you might have to wait through thousands of optimization steps for each character. This "per-asset fitting" is a major bottleneck for applications like dynamic subtitles, AR annotations, or user-generated content.

The authors of FFGaussType set out to replace this slow optimization with a single, lightning-fast "forward pass" that preserves the sharp edges and precise geometry of fonts and vector graphics.

Methods

The core of FFGaussType is a "geometry-to-Gaussian" converter that decouples the shape of an object from its visual appearance.

  1. Input: The system starts with a 2D outline (like a letter 'A') and its 3D extrusion. It samples a set of "anchors" (points) on this known surface.
  2. Encoder: A point transformer encoder maps these 3D anchors onto a single 2D feature plane ($64 \times 64$ pixels).
  3. The "Z" Trick: Because extruded shapes have a front and a back that project to the same 2D coordinates, the model uses the raw depth ($z$) of the anchors to help the decoder distinguish between the two "caps" of the glyph.
  4. Shared Decoder: A small MLP (Multi-Layer Perceptron) queries the feature plane at each anchor point to predict Gaussian parameters: spatial offsets, scales, opacity, and—crucially—surface normals.
  5. Relightable Rendering: Unlike standard 3DGS which predicts color directly, FFGaussType predicts geometry. This allows the assets to be shaded using standard Physically Based Rendering (PBR) techniques at runtime, meaning you can change a letter from "shiny gold" to "matte plastic" without re-running the model.
The FFGaussType architecture maps anchors to a feature plane to predict neural Gaussians.

Datasets

To train this converter, the authors curated a massive new paired dataset:

  • 27,221 assets: Comprising glyphs from 256 font families and various SVG icon collections.
  • Rich Supervision: Each asset includes sampled anchors and calibrated multi-view renderings of both surface normals and silhouettes.
  • Generalization Testing: They held out specific font families entirely during training to evaluate how well the model handles typefaces it has never seen before.

Key Insights and Ideas

  • Normals over Color: By supervising on surface normals rather than pre-rendered colors, the model learns pure geometry. This makes the resulting assets "reusable" across different lighting environments.
  • The Feature Plane as a Codec: By squeezing the 3D information into a 2D plane, the authors made 3D assets compatible with standard image and video compression. You can literally use HEVC (H.265) to store and transmit 3D text.
  • Amortized Optimization: The model essentially "learns" how to optimize. A single 9ms pass achieves results that previously required thousands of iterations of per-asset fitting.
Qualitative comparison showing FFGaussType's ability to capture sharp edges compared to baselines.

Key Results

  • Speed: Conversion takes only 9.1 ms per asset on an NVIDIA RTX A6000, roughly 100x faster than some previous feed-forward methods.
  • Fidelity: On unseen font families, it achieves a 1.62° normal error and a 0.985 silhouette IoU. This outperforms other feed-forward converters like TexGaussian and LGM.
  • Efficiency: The representation is incredibly compact. Using HEVC compression, a high-quality 3D asset can be stored in just ~24 KB.
  • Refinement: If 9ms isn't enough, a quick 10-second "refinement" step can further reduce error, outperforming even the most intensive per-asset optimization baselines.
FFGaussType assets integrated into a complex 3D scene with consistent shading and occlusion.

Limitations and Future Work

  • Extrusion Only: The current model is specialized for geometry derived from 2D outlines (extrusions). It cannot yet handle arbitrary 3D meshes.
  • Homogeneous Materials: While the assets are relightable, the current implementation assumes a single material per asset (e.g., the whole letter is gold). Adding spatially varying textures (like a marble pattern) is left for future work.
  • Simplified Shading: The current shading model does not account for complex effects like self-shadowing or inter-reflections between different 3D assets.

Summary updated

Abstract

Immersive 3D content allows text and graphical elements, such as subtitles, annotations, and icons, to be placed inside a scene rather than displayed as flat overlays. Placed this way, they respect occlusion and perspective and take on user-assigned materials and lighting while preserving their original shapes. In Gaussian scenes, however, each new glyph or icon requires its own iterative optimization, which limits scalable content creation. We present FFGaussType, which converts extruded glyph and SVG outlines into Gaussian assets in a single forward pass. A point encoder maps anchors sampled on the known surface to a single feature plane, from which a decoder shared by all assets predicts neural Gaussians carrying surface normals. This separates geometric conversion from material and lighting choices, and the feature plane supports image and video coding for compact delivery. We construct a paired dataset of 27,221 glyph and SVG icon assets with anchors and calibrated normal and silhouette renderings, holding out font families for evaluation. Conversion from prepared anchors takes 9.1 ms per asset, at a fraction of the compute and memory of prior baselines. On unseen font families and test icons, FFGaussType achieves $1.62^\circ$ normal error and $0.985$ silhouette IoU, the best among the compared feed-forward converters, matching the fidelity that per-asset fitting needs thousands of steps to reach. The code and dataset will be released after publication.
BibTeX
@misc{feng2026ffgausstype,
  author = {Haoan Feng and Tianfu Wang and Peimeng Guan and Dae Yeol Lee and Guan-ming Su},
  title = {{FFGaussType: Feed-Forward Conversion of Glyph and SVG Geometry into Compact Gaussian Assets}},
  year = {2026},
  eprint = {2611.26431},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.26431},
}
Figure