- Rating
- 2
- Confidence
- 2
- Informativeness
- 2
- Presentation
- 3
- Soundness
- 2
Read review
Paper summary
LITEGLYPH is a compact autoregressive framework for few-shot Chinese vector font generation that directly produces complete, editable SVG glyphs. The method factorizes character structure and font style through a visual structure prefix and dense style tokens.
The model is trained on a newly constructed large-scale Chinese raster-vector corpus containing approximately 16M pairs across 2.6k fonts and 6,763 characters. Experiments on validation, unseen-font seen-character (UFSC), and unseen-font unseen-character (UFUC) splits show competitive rasterized glyph quality compared with evaluated baselines. Ablations examine dense versus global style conditioning, the number of reference glyphs, and the scale-dependent effect of Raster-to-SVG initialization.
Critical strengths
- LITEGLYPH separates character structure and font style by using a visual prefix for structure and dense style tokens derived from reference glyphs for style conditioning. The dense style tokens provide query-dependent modulation throughout the decoder. This design allows the model to directly generate complete SVG glyphs without an additional raster-to-vector conversion stage.
- The paper constructs a substantially larger Chinese raster-vector corpus and evaluates on validation, UFSC, and UFUC splits. Retraining raster baselines on the same dataset makes the main comparisons reasonably controlled, and LITEGLYPH achieves strong results, particularly in FID. The analysis of Raster-to-SVG initialization and other ablation results also make the work useful.
Critical weaknesses
- The paper motivates LITEGLYPH by stating that existing work has not established a unified framework that jointly handles complete SVG generation and factorized structure/style conditioning. However, prior work has already explored closely related problem formulations. However, as noted in the related work, prior studies have already explored closely related problem formulations. Aoki & Aizawa (2022) [1] generate Chinese SVG glyphs from content and style references, DeepVecFont-v2[2] addresses few-shot Chinese vector-font generation by conditioning on target-character information and reference glyphs with Transformer-based vector generation, and VecGlypher[3] formulates direct vector-glyph generation within a unified language-model framework. Therefore, the novelty appears to lie more specifically in LITEGLYPH's conditioning architecture; otherwise, the overall methodological contribution appears relatively incremental.
- While Table2 provides comparisons against raster baselines, it does not directly compare against some of the most relevant recent vector-generation approaches. The held-out fonts in Table1 is reported seen by LITEGLYPH during Raster-to-SVG initialization, which makes me difficult to disentangle the benefit. I am also unclear about why DeepVecFont-v2 and the other vector baselines are restricted to the reduced method-compatible subset. It would be helpful to report how the increased glyph complexity in the full benchmark affects these methods, for example through the distribution of command or sequence lengths and the fraction of glyphs that exceed each method's supported range. If the limitation arises from representation or sequence-length constraints, I would also like to know whether these constraints could be adjusted to enable a broader and more directly comparable evaluation.
- Figure 6 compares Raster-to-SVG initialization against training from scratch. However, the initialized model has already undergone a separate Raster-to-SVG pretraining stage before this matched downstream training. In particular, the strong results with only 250 downstream fonts may be interpreted in the context that the initialized model has already been exposed to 2,376 fonts during Raster-to-SVG pretraining. Reporting the total training data exposure and computational cost would provide a clearer picture of the practical efficiency of this approach.
[1] SVG vector font generation for Chinese Characters with Transformer [2] DeepVecFont-v2: Exploiting Transformers to Synthesize Vector Fonts with Higher Quality [3] VecGlypher: Unified Vector Glyph Generation with Language Models
Questions for authors
- Could the authors clarify the primary technical novelty of LITEGLYPH relative to prior vector-font generation methods? Is the main novelty specifically the causal structure prefix and query-adaptive dense style conditioning?
- Could the authors report the command/sequence-length distribution and coverage of these methods on the full benchmark, and clarify whether their constraints could be adjusted to enable a broader common evaluation?
- For the Raster-to-SVG initialization study, could the authors report the total training data exposure and computational cost including the pretraining stage? A controlled comparison that isolates the effect of the additional pretraining data would also help distinguish the contribution of Raster-to-SVG initialization from that of additional data and compute.
Addressing these concerns, particularly by clarifying the novelty positioning and providing more controlled evidence for the vector-method comparisons and initialization study, would positively affect my overall assessment of the paper.
4 comments
W2 and Q2. Why use a smaller benchmark for the vector baselines?
Table 1 uses a common subset for downstream training and evaluation so that all methods are compared on the same complete glyphs. Many complex Chinese outlines exceed the 70-command limit in our original DeepVecFont and DeepVecFont-v2 configurations. DualVector represents each glyph with a fixed set of curve primitives. Citing these methods’ difficulty generating complex glyphs reliably, VecFontLLM trained the same three baselines on 495 simple Chinese characters and tested them on those characters in held-out fonts. VecFontLLM, Secs. 4.1.1 and 4.2
| Target length under the DeepVecFont encoding (10,000 per split) | UFSC | UFUC |
|---|---|---|
| Drawing commands (excluding EOS), median / 95th percentile | 87 / 186 | 88 / 188 |
| Target coverage by length, limit of 70 → 140 commands | 35.43% → 83.60% | 34.44% → 82.94% |
We raised the limit to 140 commands and retrained DeepVecFont-v2. This expanded the UFSC comparison with LiteGlyph from 62 to 333 targets with four matched references per target. The original 300-character comparison vocabulary covers no UFUC targets.
W2 (continued). Did initialization use the Table 1 test fonts?
Yes, the original Table 1 setting had font-level data leakage. We held out all 65 test fonts during downstream training, but all 65 were in the original Raster-to-SVG pretraining set. The separate 250-font subset used in Figure 6 also contained six of those fonts.
For a fair comparison, we retrained both the Raster-to-SVG initializer and the downstream Dense model on the vector baselines’ training split. Both stages used the same 71,796 glyphs from 260 training fonts and excluded all 65 test fonts. We verified that all 17,772 targets and their eight references matched the original evaluation. The retrained LiteGlyph model scored better than the published model on all five metrics below.
| Table 1 comparison | FID ↓ | LPIPS ↓ | L1 ↓ | RMSE ↓ | SSIM ↑ |
|---|---|---|---|---|---|
| DeepVecFont-v2 | 72.876 | 0.295 | 0.204 | 0.418 | 0.640 |
| LiteGlyph, original (test fonts held out downstream only) | 3.686 | 0.173 | 0.117 | 0.278 | 0.606 |
| LiteGlyph, fonts held out at both stages | 3.303 | 0.166 | 0.110 | 0.269 | 0.611 |
LiteGlyph retains its FID and LPIPS advantage over the vector baselines when the test fonts are held out of both stages. Pretraining corpus size and training budget also changed between the two LiteGlyph runs, so this comparison does not isolate the effect of removing the overlap.
W3 and Q3. How much data and compute did initialization add?
The Raster-to-SVG initializer used a pool of 13,476,734 glyphs from 2,376 fonts. Each training slot below is one example in a global batch of 32. The totals count repeated exposure across stages. The GPU-hours column covers downstream training only. Historical wall time for pretraining is unavailable.
| Downstream run | Initialization updates | Downstream updates | Total updates | Total training slots | Downstream H800 GPU-hours | Downstream training loss near epoch end ↓ |
|---|---|---|---|---|---|---|
| 250 fonts, scratch | 0 | 44,478 | 44,478 | 1,423,296 | 57.73 | 0.971 |
| 250 fonts, Raster-to-SVG initialization | 421,147 | 44,478 | 465,625 | 14,900,000 | 55.33 | 0.767 |
| 2,376 fonts, Raster-to-SVG initialization | 421,147 | 421,147 | 842,294 | 26,953,408 | ≈520 | 0.7215 |
Downstream GPU-hours for 2,376 fonts are estimated by linearly scaling historical job durations for the same Dense24 model on 250, 500, and 1,000 fonts by the number of training updates. These runs also used eight H800 GPUs, a global batch size of 32, and FP16. The estimate excludes Raster-to-SVG pretraining and does not adjust for differences in validation frequency or glyph-length distribution between the subset and full-data runs.
The 250-font losses are the endpoints shown in Fig. 9. For 2,376 fonts, we report the last training-log value, averaged over the 20 updates ending at update 421,140.
At 250 fonts, the initialized model reached lower training loss after the same number of downstream updates (Fig. 9) and lower FID on both UFSC and UFUC (Table 8). This suggests that learning to construct outlines from SVG commands and coordinates before adaptation helps optimize font generation when downstream examples cover a limited range of contours. The initialized model used additional pretraining data and updates. Isolating the effect of the Raster-to-SVG objective would require matching total data exposure and updates across both stages. The separate 260-font experiment above addresses prior exposure to the Table 1 test fonts.
Thank you for the response. I have read it carefully and will maintain my current score.
We appreciate the reviewer’s suggestions on the experimental setup, which prompted us to strengthen the controls for a fairer comparison.
W1 and Q1. What is the technical novelty?
Yes. Our main technical contribution is a conditioning interface that combines a causal structure prefix with query-adaptive dense style conditioning at every decoder layer. Aoki and Aizawa already generated Chinese SVG glyphs from separate content and style references, pooling style into a single vector for AdaIN. In LiteGlyph, a standard-font rendering specifies the target character through the prefix. Raster images of eight other characters in the target font supply a separate memory of local style features. At each layer, the current SVG position queries that memory to predict the next command or coordinate. Aoki and Aizawa, Sec. 3.2
With this interface, a single 350M-parameter Transformer decoder directly generates complete, editable SVG outlines for complex Chinese characters. Figure 14(b) presents multiple examples of complex Chinese characters generated under the UFUC setting, where both the typefaces and characters are unseen during training. The full Dense model has 680.0M parameters, of which 375.6M are trainable (Table 4).
Raster-to-SVG initialization provides a transferable vector prior for few-shot font generation. We first train the same autoregressive generator to reconstruct a glyph's complete SVG from its raster image, learning drawing commands, contour organization and coordinate geometry. We then transfer the visual projection and SVG decoder to the few-shot font task and jointly train them with the style-conditioning branch. In our experiments with few downstream fonts, initialization yields lower training loss and better generation quality under the same downstream training budget (Sec. 3.4, Figs. 6 and 9).
We also contribute a large-scale paired Chinese raster–vector corpus. It contains approximately 16 million raster–SVG glyph pairs spanning over 2,600 typefaces and 6,763 GB2312 characters. Our construction pipeline combines deduplication, structural-consistency filtering, outline canonicalization, automated checks and manual audits to align standard-font structure references with target glyphs while retaining broad stylistic diversity. The corpus pairs complete SVG outlines with raster images, supporting end-to-end vector generation of complex Chinese characters and evaluation of generalization to unseen typefaces and characters through explicit font and character splits (Sec. 3.1 and Appendix A).
We are comparing a visual prefix with layer-wise cross-attention over the same Heiti image features, using the same style branch and training episodes.
Table 2 compares our style conditioning with the pooled Global variant.
To quantify performance on long outlines, we took every target whose ground-truth path contained more than 140 drawing commands (M, L, C) in the separately frozen rebuttal sets of 10,000 targets per split. We used the paper Dense checkpoint with eight references and rollback enabled. Mean LPIPS at 512 pixels includes every selected target, scoring invalid or blank outputs as white images.