Style Customization of Text-to-Vector Generation with Image Diffusion Priors

Jing Liao; Nanxuan Zhao; Peiying Zhang

REVIEW 3 major objections 6 minor 4 references

Style Customization of Text-to-Vector Generation with Image Diffusion Priors

T0 review · 3 major / 6 minor · reviewed 2026-08-15 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read Text-to-vector generation can learn a custom SVG style from a few example files and apply it to arbitrary text prompts in a single feed-forward pass.

desk verdict A plausible and useful two-stage recipe for style-customized text-to-vector generation, with a self-referential Path FID and an untested frozen path VAE as the two things to fix before trusting the numbers. read the letter →

arxiv 2505.10558 v1 pith:M7D5G43K submitted 2025-05-15 cs.GR cs.CV

Peiying Zhang , Nanxuan Zhao , Jing Liao This is my paper · ORCID

classification cs.GRcs.CV

keywords ScalableVectorGraphicsSVGgenerationtext-to-vectorstylecustomizationdiffusionmodelpath-levelrepresentationimagepriorsfeed-forward

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper claims that a text-to-vector (T2V) model can learn a custom visual style from just a few example SVG files, and that after learning it can generate new SVGs in that style from any text prompt in a single forward pass. The proposed pipeline separates the problem into two stages: first train a diffusion model that generates well-structured SVGs using a path-level latent representation; then transfer style knowledge from a customized text-to-image diffusion model into the vector model through rendered-image supervision. The key payoff is that designers could obtain a whole set of consistently styled icons or illustrations from text prompts, without per-image optimization and without the overfitting that occurs when a small style dataset is used to fine-tune a vector model directly. The paper supports the claim with quantitative comparisons and a user study across 200 trained styles.

What carries the argument

The load-bearing mechanism is the path-level SVG latent representation combined with style distillation through a differentiable rasterizer. Each SVG is encoded as a sequence of path embeddings $s_0=(P_1,\dots,P_m)$, $m\le 32$, where each path embedding $P_i=(z_i,C_i,Tr_i)$ consists of a latent code from a pretrained path-level SVG autoencoder, a uniform color, and a transformation; a transformer-based diffusion backbone with cross-attention to CLIP text embeddings generates this sequence under the DDPM objective. In the second stage, a text-to-image diffusion model fine-tuned on style examples (via LoRA) is paired with a structure-control module that uses the Canny edge map of the rendered SVG, producing a customized image that matches the generated SVG's structure. The reparameterization trick predicts the denoised SVG tensor $\hat{\mathbf{s}}^g_0$, which is rendered to an image $\hat{\mathbf{I}}^g_0$; the image loss $\mathcal{L}_{\text{img}}=\omega_t\|\hat{\mathbf{I}}^g_0-\mathbf{I}^c_0\|^2$ together with the diffusion loss transfers the style into the vector model.

What would settle it

Take colored, gradient-filled, or multi-layer SVG style exemplars, pass them through the path-level encoder and decoder used by the pipeline, and measure how much of the style survives reconstruction; if decoded SVGs lose color, decoration, or layer structure enough that the style becomes unrecognizable, the pretrained latent space is the bottleneck and the feed-forward customization claim fails for those styles.

Watch

Extended reading notes

Core claim

The central discovery is that content and style can be disentangled in text-to-vector generation by training in two separate stages. In the first stage, a path-level T2V diffusion model is trained on black-and-white vector icons so it learns the structural regularities of clean SVG designs. In the second stage, the style of a few exemplar SVGs is captured by fine-tuning a text-to-image diffusion model, and this customized image model is used to generate many diverse styled images that become augmented training data for the vector model. The vector model is updated by an image-level loss between its rendered SVG predictions and these customized images, so the style flows from the image diffusion prior into the vector generator. After training, appending a learned style token to a text prompt produces an SVG in that style in a feed-forward manner. If correct, this makes the pipeline the first feed-forward T2V method with style customization.

Load-bearing premise

The pretrained path-level SVG compression network, trained on simple black-and-white icons, must be able to encode and decode the colored, decorative, or structurally complex paths that appear after style customization; if it cannot, the style distillation has no way to produce valid vector output.

Editorial extensions

If this is right

One trained model can serve many styles: each style is bound to a unique token, and at inference that token is simply appended to the text prompt.
Generation is feed-forward after training, taking about 25 seconds per SVG on an A6000, compared with tens of minutes for optimization-based baselines.
A new style can be added with only a few exemplars, either by full-model fine-tuning or by learning LoRA adapters that avoid introducing a new style token.
The two-stage design prevents the content collapse seen when a vector model is fine-tuned directly on a small style set, as shown by the text-alignment results in the ablation.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

The practical ceiling of the approach is set by the pretrained path-level autoencoder: because it was trained on black-and-white icons, styles that rely on gradients, strokes, or complex decorative geometry may not be representable, so extending to richer styles would likely require retraining the autoencoder on colored or decorative SVG data.
The method inherits the semantic limits of its training data and of the text-to-image teacher: prompts outside the FIGR-8 vocabulary, such as 'cello', produce inaccurate objects, so collecting a larger, better-annotated SVG dataset is the most direct route to broader prompt coverage.
A testable extension is to evaluate style fidelity on exemplars whose style lives in stroke texture or non-geometric detail; the current image-level loss and black-and-white autoencoder would likely capture silhouette and palette but lose such texture.
The same distillation scheme could be applied to other vector formats or to per-subject, not just per-style, customization, since the rendered-image bridge does not depend on SVG-specific code generation.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Quick take: this is the first feed-forward text-to-vector model I've seen that handles style customization, and the two-stage trick — train a path-level T2V diffusion model on plain icons, then distill style from a DreamBooth-LoRA-tuned SD model through image loss with ControlNet keeping the structure — is a sensible way to get there. The qualitative results are genuinely impressive: the styled icons look coherent and structurally regular, and the user study, while small, backs the main claim. The authors also state limitations honestly.

Where it gets shaky is the vector-level evaluation. Path FID compares generated latents to ground-truth latents in the same path-VAE space that the model itself uses (from their T2V-NPR paper). That cannot certify vector quality; it partly measures how well the model stays in its own prior. The table has no error bars or significance tests, so the margin over GPT-4o and T2V-NPR is hard to trust. A cheap fix would be reconstruction and human-editing metrics, plus reporting variance.

The stress-test worry about the frozen path VAE is real but slightly overstated. Color is carried outside the VAE latent (C_i is separate), so the claim that colored/decorative styles cannot be represented is too strong. The geometry of ornate shapes is still a legitimate risk, and there is no experiment measuring VAE reconstruction on stylized SVG shapes. Since the whole second stage leans on that decoder, I'd want one reconstruction plot before believing the pipeline generalizes to arbitrary styles. Relatedly, Stage 2 uses the model's own generations as training seeds; the diffusion loss may keep it on-manifold, but this is another reason external evaluation matters.

Citation pattern is fine, though the paper leans on T2V-NPR for the VAE and representation — that is a dependency, not a flaw. Missing SVGFusion as a baseline is a minor gap. No code or data release, which weakens reproducibility.

Overall: I think the core claim probably holds — feed-forward style customization for SVGs is a real capability and this is a practical route to it. The evaluation is the weak link, not the method. I would send this to referees, but ask them to nail down the Path FID issue and demand a reconstruction check for the VAE. If the authors add that, it's a solid paper.

Referee Report

3 major / 6 minor

Summary. The paper proposes a two-stage pipeline for text-to-vector (T2V) generation with customizable styles. In Stage 1, a path-level diffusion transformer is trained on the black-and-white FIGR-8-SVG dataset. Each SVG is represented as a sequence of path-latent vectors obtained from a pre-trained path VAE from the authors' prior T2V-NPR work, together with per-path color and transform parameters. In Stage 2, the T2V model is customized by distilling from fine-tuned text-to-image diffusion models: for each style, a DreamBooth-LoRA and a ControlNet-equipped Stable Diffusion model generate customized images conditioned on Canny edges of the current model's renderings, and the T2V model is fine-tuned with an image-space MSE loss plus the original diffusion loss. The authors report quantitative comparisons on Path FID, style alignment, aesthetic score, and text alignment, a user study, and qualitative results, and claim this is the first feed-forward T2V model that supports style customization from a few exemplar SVGs.

Significance. If the central claim holds, the work is a useful step: it combines the structural regularity of feed-forward vector diffusion with the customization power of text-to-image diffusion models, and the idea of distilling style through rendered image pairs is sensible. The paper provides extensive qualitative comparisons, a user study, and ablation studies, which are strengths. The two-stage design is clear and the claim of feed-forward customized generation is concrete and falsifiable. However, the evaluation as reported does not yet establish the claim to the standard required by a major venue, because the main vector-level metric is computed in the latent space of the same path VAE that the model itself uses, and because the frozen decoder's ability to represent stylized, colored, and decorated paths is asserted rather than demonstrated.

major comments (3)

[Section 6, Table 1] The Path FID metric is computed by encoding generated SVGs and ground-truth FIGR-8-SVG paths with the path VAE from T2V-NPR, which is exactly the latent representation used by the proposed T2V model. This makes the metric partially self-referential: a model that produces latents close to the training distribution will score well even if its decoded SVGs are visually poor, while optimization-based baselines that are not trained in this latent space are systematically disadvantaged. In addition, Table 1 (and Table 2) report no error bars, confidence intervals, or multiple-seed results, so it is unclear whether the differences among Potrace, GPT-4o, T2V-NPR, and Ours are statistically meaningful. I recommend reporting an image-space FID on rendered SVGs, an independent vector-quality metric, and variance estimates over test prompts and generation seeds.
[Sections 4.1 and 5.2] The whole pipeline rests on a pre-trained path VAE/decoder from T2V-NPR that was trained on black-and-white FIGR-8-SVG icons, but the style-customization objective in Eq. (3) trains the diffusion model to produce latents whose renderings match colored, decorated customized images. The paper provides no reconstruction evaluation showing that this VAE can encode and decode stylized paths, including colored fills, ornaments, and complex silhouettes. If the decoder's latent space cannot represent such structures, the image loss is unsatisfiable and the feed-forward outputs will be stylistically wrong regardless of how well the diffusion model fits the image distribution; the authors' own failure case in Figure 8(b) is consistent with this risk. Please add a quantitative encode-decode reconstruction study on the style exemplars and on held-out stylized SVGs, reporting geometric and color fidelity, and discuss how training on self-generated s0^g avoids drifting off the VAE manifold.
[Section 6, Table 1] The Style Alignment metric, measured as CLIP image cosine similarity to the style reference, is not a reliable indicator of customization quality in this comparison: the vector-fine-tuned VecFusion baseline scores highest (0.726) precisely because it overfits and reproduces the exemplars, while the qualitative results show that it fails to adapt to the text prompts. Reporting style alignment without its trade-off against text alignment is misleading; at minimum the authors should present per-method paired results or a combined metric that penalizes overfitting, and should report the same variance information requested for the other metrics.

minor comments (6)

[Section 2.3 heading] The heading reads 'Cusomization of T2I Generation' and should be corrected to 'Customization of T2I Generation'.
[Table 1] The directional arrows attached to the metric names are not explained; please state in the caption which direction is better for each metric.
[Equation (3)] Equation (3) writes an L2 norm without squaring while the text calls the loss an MSE; please make the notation consistent by writing the squared L2 norm or clarifying the intended loss.
[Section 5.2] The text says the diffusion loss is defined on the predicted denoised tensor \hat{s}^g_0, but Eq. (1) defines the diffusion loss on the original SVG tensor s0; please clarify the exact training target for the Stage 2 diffusion loss and whether gradients flow through the reparameterization in Eq. (2).
[Section 6.2 and Figure 6] The user study reports preferences from 30 participants on 20 prompts but gives no statistical significance test; please add a significance test or bootstrap confidence intervals for the preference percentages.
[Section 7] The conclusion's admitted limitations, especially the 'inadequate style capture' for complex references in Figure 8(b), should be reflected in the abstract's unqualified claim of 'high-quality and diverse' custom-style generation; please qualify the claim or provide evidence on the failure rate.

Circularity Check

1 steps flagged · score 4.0 of 10

Path FID evaluation is self-referential: it scores generated paths in the same path-VAE latent space the model was trained to produce, so the vector-level metric cannot independently validate decoded SVG quality.

self definitional [Section 6, 'Evaluation Metrics' (vector-level paragraph); cf. Section 4.1 and Eq. 1]
"For vector-level evaluation, we use a path VAE [Zhang et al. 2024] trained on the FIGR-8-SVG dataset to encode SVG paths into latent vectors. We calculate the FID between these latents and the ground truth paths from FIGR-8-SVG, to evaluate how well the paths align with well-designed vector graphics."

The vector-level metric is computed inside the same pre-trained path VAE latent space that defines the model's output representation. Section 4.1 states 'we leverage a pre-trained SVG VAE to encode the d control points of each path into a latent vector z_i', and the denoising objective (Eq. 1) trains the model directly on such latent tensors s0. Therefore 'these latents' in the Path FID are the model's native output space, which the diffusion model is explicitly trained to match to FIGR-8-SVG latents. A low Path FID can be achieved by matching the latent distribution even if the frozen decoder produces invalid, broken, or stylistically wrong paths for out-of-distribution colored/decorative styles.

full rationale

The paper's central claim is an empirical result—feed-forward style-customized SVG generation—rather than a theorem derived from stated assumptions. The two-stage pipeline uses a path VAE from the authors' prior T2V-NPR work as a component; this is a self-citation and it is load-bearing for the method, but it is not a circular derivation because the VAE is published prior work and is not invoked to prove the paper's own output. The Stage-2 training is a teacher-student distillation: customized T2I images provide style targets, and the student is trained with an image-level loss (Eq. 3); the targets are not simply the student's own outputs, so the style-customization claim does not reduce to its inputs. The one genuine circularity is in the vector-level evaluation: Path FID is computed in the same latent space that the path VAE defines and in which the T2V diffusion model is trained (Section 4.1 and Eq. 1). Thus the metric cannot independently verify that decoded paths are structurally valid for the new colored/decorative styles; it is partly re-measuring the training distribution. The visual aesthetic score, CLIP style/text alignment, and user study are independent and support the central empirical claim, which keeps the overall circularity partial rather than total. There is also an unaddressed correctness risk—no reconstruction experiment checks whether the frozen black-and-white-trained VAE can decode stylized colored paths—but that is a weakness, not itself a circularity.

Assumptions & free parameters 7 free parameters · 5 assumptions · 0 invented entities

The central claim rests on two pillars: a pretrained path VAE that is not re-trained for style, and the assumption that image-space distillation from a customized T2I model transfers style while preserving structure. The free parameters are standard hyperparameters, but several (guidance scale, loss weighting) are tuned empirically and could affect the reported results. No new natural-world entities are introduced; the style token is a learned embedding, not an invented physical entity.

free parameters (7)

classifier_free_guidance_scale = 3
Inference-time guidance scale (Section 6), chosen empirically for better results.
latent_dim_dP = 28
Dimension of path-level latent embeddings in the SVG representation (Section 4.3); follows the pretrained T2V-NPR VAE.
max_paths_m = 32
Fixed sequence length used for padding path tensors; SVGs with more than 32 paths are filtered out (Section 4.3).
image_loss_weight_wt = (1 - alpha_bar_t)
Time-dependent weighting for the image loss, set empirically following Crowson et al. 2024 (Section 5.2).
stage2_learning_rate = 4e-6
Learning rate for style fine-tuning (Section 5.2).
stage2_iterations = 80K
Number of training iterations in the style distillation stage (Section 5.2).
num_style_sets = 200
The model is trained simultaneously on 200 distinct style reference sets (Section 5.2).

assumptions (5)

domain assumption The pretrained path-level SVG VAE from T2V-NPR (Zhang et al. 2024) provides a latent space that can represent arbitrary SVG paths, including the colored, stylized paths needed after style customization.
Invoked in Sections 4.1 and 5.2: the VAE is pretrained and used to encode/decode paths. The central claim depends on the VAE not bottlenecking new styles, but the VAE was trained on black-and-white FIGR-8-SVG icons, not on colored stylized graphics.
domain assumption FIGR-8-SVG, filtered to 210,000 black-and-white icons, is sufficient for the T2V model to learn general content and structure of SVGs.
Section 4.3 uses only this dataset in Stage 1; the authors themselves note semantic limitations for concepts outside this dataset (Section 7, Figure 8a).
domain assumption DreamBooth-LoRA fine-tuning of SD-v1-5 with a small set of style images yields a T2I model that captures the style, and ControlNet with Canny edges preserves the structural content of the original SVG.
Section 5.1 relies on the customized T2I model producing structurally aligned images that serve as training targets; if ControlNet or the LoRA does not preserve structure or transfer style, the image loss would mislead the T2V model.
standard math The reparameterization in Eq. (2) allows predicting the denoised SVG tensor at every timestep and using an image-space MSE loss as a valid style signal.
Eq. (2) is a standard DDPM/score-based reparameterization (Song et al. 2020); applying it to a vector latent space is a domain adaptation, but the mathematical identity itself is standard.
domain assumption Optimizing the image-space MSE between rendered predicted SVG and customized image transfers the desired style without requiring the T2V model to emulate all details of the raster image.
The whole style distillation in Section 5.2 rests on this design choice; no analysis is given for how the loss balances style and structure.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Style Customization of Text-to-Vector Generation with Image Diffusion Priors." pith.science (2026). https://pith.science/paper/M7D5G43K

@misc{pith2026250510558,
  author       = {Pith},
  title        = {Pith review of: Style Customization of Text-to-Vector Generation with Image Diffusion Priors},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/M7D5G43K}},
  note         = {Machine review of arXiv:2505.10558}
}

read the original abstract

Scalable Vector Graphics (SVGs) are highly favored by designers due to their resolution independence and well-organized layer structure. Although existing text-to-vector (T2V) generation methods can create SVGs from text prompts, they often overlook an important need in practical applications: style customization, which is vital for producing a collection of vector graphics with consistent visual appearance and coherent aesthetics. Extending existing T2V methods for style customization poses certain challenges. Optimization-based T2V models can utilize the priors of text-to-image (T2I) models for customization, but struggle with maintaining structural regularity. On the other hand, feed-forward T2V models can ensure structural regularity, yet they encounter difficulties in disentangling content and style due to limited SVG training data. To address these challenges, we propose a novel two-stage style customization pipeline for SVG generation, making use of the advantages of both feed-forward T2V models and T2I image priors. In the first stage, we train a T2V diffusion model with a path-level representation to ensure the structural regularity of SVGs while preserving diverse expressive capabilities. In the second stage, we customize the T2V diffusion model to different styles by distilling customized T2I models. By integrating these techniques, our pipeline can generate high-quality and diverse SVGs in custom styles based on text prompts in an efficient feed-forward manner. The effectiveness of our method has been validated through extensive experiments. The project page is https://customsvg.github.io.

Figures

Figures reproduced from arXiv: 2505.10558 by the authors.

**Figure 1.** Examples of vector graphics generated from text prompts in custom styles using our method, showcasing structural [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗

**Figure 2.** Our two-stage style customization pipeline for SVGs. (a) In Stage 1, we train a path-level T2V diffusion model on [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗

**Figure 3.** (a) SVG examples from the dataset. (b) SVG samples [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗

Figures from the paper (8 more)

**Figure 4.** Figure 4: Qualitative comparison with optimization-based [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]

**Figure 5.** Figure 5: Qualitative comparison to feed-forward T2V meth [PITH_FULL_IMAGE:figures/full_fig_p006_5.png]

**Figure 6.** Figure 6: User Study. We show the human preferences in %. [PITH_FULL_IMAGE:figures/full_fig_p007_6.png]

**Figure 7.** Figure 7: Qualitative results on ablation study. Exemplar [PITH_FULL_IMAGE:figures/full_fig_p007_7.png]

**Figure 8.** Figure 8: Failure cases. The exemplar SVG is from ©iconfont. contains only simple class labels, limiting the model’s semantic understanding of SVG content. For example, as shown in [PITH_FULL_IMAGE:figures/full_fig_p008_8.png]

**Figure 9.** Figure 9: More qualitative comparison with optimization-based T2V methods. Exemplar SVGs: the [PITH_FULL_IMAGE:figures/full_fig_p010_9.png]

**Figure 10.** Figure 10: More qualitative comparison to feed-forward T2V methods. Exemplar SVGs: the [PITH_FULL_IMAGE:figures/full_fig_p010_10.png]

**Figure 11.** Figure 11: More results of our style customization of T2V generation. Exemplar SVGs: the [PITH_FULL_IMAGE:figures/full_fig_p011_11.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

4 extracted references · 4 linked inside Pith

[4]

camera” “shiba inu

High-resolution image synthesis with latent diffusion models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition . 10684– 10695. Nataniel Ruiz, Yuanzhen Li, Varun Jampani, Yael Pritch, Michael Rubinstein, and Kfir Aberman. 2022. Dreambooth: Fine tuning text-to-image diffusion models for subject-driven generation. arXiv pr...

arXiv 2022
[2021]

In International conference on machine learning

Learning transferable visual models from natural language supervision. In International conference on machine learning . PMLR, 8748–8763. Juan A Rodriguez, Shubham Agarwal, Issam H Laradji, Pau Rodriguez, David Vazquez, Christopher Pal, and Marco Pedersoli. 2023. StarVector: Generating Scalable Vector Graphics Code from Images. arXiv preprint arXiv:2312.1...

arXiv 2023
[2022]

arXiv preprint arXiv:2212.04488 (2022)

Multi-Concept Customization of Text-to-Image Diffusion. arXiv preprint arXiv:2212.04488 (2022). Tzu-Mao Li, Michal Lukáč, Michaël Gharbi, and Jonathan Ragan-Kelley. 2020. Differ- entiable vector graphics rasterization for editing and learning. ACM Transactions on Graphics (TOG) 39, 6 (2020), 1–15. Eric Luhman and Troy Luhman. 2021. Knowledge distillation ...

arXiv 2022
[2023]

arXiv preprint arXiv:2303.01818 (2023)

Word-as-image for semantic typography. arXiv preprint arXiv:2303.01818 (2023). Ajay Jain, Amber Xie, and Pieter Abbeel. 2022. VectorFusion: Text-to-SVG by Abstract- ing Pixel-Based Diffusion Models. arXiv preprint arXiv:2211.11319 (2022). Johannes Kopf and Dani Lischinski. 2011. Depixelizing pixel art. In ACM SIGGRAPH 2011 papers. 1–8. Nupur Kumari, Bingl...

arXiv 2023

Pith tools

Reviewed August 15, 2026 · model on record in the stance chip above.

[1] [4]

camera” “shiba inu

High-resolution image synthesis with latent diffusion models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition . 10684– 10695. Nataniel Ruiz, Yuanzhen Li, Varun Jampani, Yael Pritch, Michael Rubinstein, and Kfir Aberman. 2022. Dreambooth: Fine tuning text-to-image diffusion models for subject-driven generation. arXiv pr...

arXiv 2022

[2] [2021]

In International conference on machine learning

Learning transferable visual models from natural language supervision. In International conference on machine learning . PMLR, 8748–8763. Juan A Rodriguez, Shubham Agarwal, Issam H Laradji, Pau Rodriguez, David Vazquez, Christopher Pal, and Marco Pedersoli. 2023. StarVector: Generating Scalable Vector Graphics Code from Images. arXiv preprint arXiv:2312.1...

arXiv 2023

[3] [2022]

arXiv preprint arXiv:2212.04488 (2022)

Multi-Concept Customization of Text-to-Image Diffusion. arXiv preprint arXiv:2212.04488 (2022). Tzu-Mao Li, Michal Lukáč, Michaël Gharbi, and Jonathan Ragan-Kelley. 2020. Differ- entiable vector graphics rasterization for editing and learning. ACM Transactions on Graphics (TOG) 39, 6 (2020), 1–15. Eric Luhman and Troy Luhman. 2021. Knowledge distillation ...

arXiv 2022

[4] [2023]

arXiv preprint arXiv:2303.01818 (2023)

Word-as-image for semantic typography. arXiv preprint arXiv:2303.01818 (2023). Ajay Jain, Amber Xie, and Pieter Abbeel. 2022. VectorFusion: Text-to-SVG by Abstract- ing Pixel-Based Diffusion Models. arXiv preprint arXiv:2211.11319 (2022). Johannes Kopf and Dani Lischinski. 2011. Depixelizing pixel art. In ACM SIGGRAPH 2011 papers. 1–8. Nupur Kumari, Bingl...

arXiv 2023