Rendering-Aware Reinforcement Learning for Vector Graphics Generation
Authors: Juan A. Rodriguez
Haotian Zhang
Abhay Puri
Rishav Pramanik
Aarash Feizi
Pascal Wichmann
Arnab Kumar Mondal
Mohammad Reza Samsami
Rabiul Awal
Perouz Taslakian
Spandana Gella
Sai Rajeswar
David Vazquez
Christopher Pal
Marco Pedersoli
Venue: NeurIPS 2025 poster ()
Keywords: SVG
Scalable Vector Graphics
Multimodal
VLM
Reinforcement Learning
Primary area: applications
TL;DR: We refine SVG generation using online reinforcement learning with image reconstruction, semantic, and code-level rewards, boosting accuracy, efficiency, and interpretability.

Abstract: Scalable Vector Graphics (SVG) offer a powerful format for representing visual designs as interpretable code. Recent advances in vision-language models (VLMs) have enabled high-quality SVG generation by framing the problem as a code generation task and leveraging large-scale pretraining. VLMs are particularly suitable for this task as they capture both global semantics and fine-grained visual patterns, while transferring knowledge across vision, natural language, and code domains. However, existing VLM approaches often struggle to produce faithful and efficient SVGs because they never observe the rendered images during training. Although differentiable rendering for autoregressive SVG code generation remains unavailable, rendered outputs can still be compared to original inputs, enabling evaluative feedback suitable for reinforcement learning (RL). We introduce Reinforcement Learning from Rendering Feedback, an RL method that enhances SVG generation in autoregressive VLMs by leveraging feedback from rendered SVG outputs. Given an input image, the model generates SVG roll-outs that are rendered and compared to the original image to compute a reward. This visual fidelity feedback guides the model toward producing more accurate, efficient, and semantically coherent SVGs. \method significantly outperforms supervised fine-tuning, addressing common failure modes and enabling precise, high-quality SVG generation with strong structural understanding and generalization.

Rendering-Aware Reinforcement Learning for Vector Graphics Generation
Juan A. Rodriguez!.2.; Haotian Zhang Abhay Puri', Aarash Feizi-.2.11, Rishav Pramanik', Pascal Wichmann Arnab Mondal Mohammad Reza Samsami
Rabiul Awal Perouz Taslakian', Spandana Gella', Sai Rajeswar
David Vazquez', Christopher Pa11.2,4.10, Marco Pedersoli
NerviceNow Research
Mila ²ÉTS Montréal *Polytechnique Montréal "Independent Scholar
5 Coolmbia University
"Stony Brook University *Apple
Google Research
CCCaaaaa CIFAR AI Chair MMMGiill University
Abstract
Scalable Vector Graphics (SVG) offer powerful format for representing visual designs interpretable code. Recent advances in vision-language models (VLMs) have enabled high-quality SVG generation by framing the problem as code generation task and leveraging large-scale pretraining. VLMs are particularly suitable for this task as they capture both global semantics and fine-grained visual patterns, while transferring knowledge across vision, natural language, and code domains. However, existing VLM approaches often struggle to produce faithful and efficient SVGs because they never observe the rendered images during training. Although differentiable rendering for autoregressive SVG code generation remains unavailable, rendered outputs still be compared original inputs, enabling evaluative feedback suitable for reinforcement learning (RL). We introduce RLRF (Reinforcement Learning from Rendering Feedback), an RL method that enhances SVG generation in autoregressive VLMs by leveraging feedback from rendered SVG outputs. Given input image, the model generates SVG roll-outs that rendered and compared to the original image to compute a reward. This visual fidelity feedback guides the model toward producing more accurate, efficient, and semantically coherent SVGs. RLRF significantly outperforms supervised fine- tuning, addressing common failure modes and enabling precise, high-quality SVG generation with strong structural understanding and generalization.
1 Introduction
Generating structured visual code from perceptual inputs, known as the inverse rendering code gener- ation problem, aims to translate images
into executable code that reproduces the target visual
content [Rodriguez et al., 20255 Baulé et al. 2021]. This task has gained momentum with the rise of vision-language models (VLMs) capable of visual-symbolic reasoning and autoregressive sequence
generation. Among symbolic formats, Scalable Vector Graphics (SVG) [Ferraiolo et al.) 22000] Quint
2003) offer uniquely expressive target: they are compact, editable, and resolution-indeeendenn and
align naturally with the token-based generation processes of language models [Brown et al. [2020]
Recent works successfully frame SVG generation
code synthesis problem [Wu al.]] [023]]0 Cai
et al. 2023 Xing et al.) 2024 Zhang et al. 2023 Nishina and Matsui 2024]. Star [Rodriguez
al. 2025b] proposes model that combines a CLIP vision encoder with a pretrained LLM to
directly predict SVG code from images. Other works [Cai et al. 2023 Yang et al. 2025b Zhang
af. 2023) have explored editing, reasoning, and style control using similar architectures. These
models are typically trained using supervised learning on tokenized SVG sequences, achieving strong
"Equal contribution
39th Conference on Neural Information Processing Systems (NcurIPS 2025).

---

Autoregressive SVG Generation
Predicted
Rendered
RLRF Training Progress
SVD SFT
Step
Stop 50
Step 200
Step 600
SVG
Image
SVG Pre-Trained VLM
SVG
Image
20b4
SVG
Image
SVG
Image
Text
Image
"Reconstruct this image in SVG"
Rewards
Figure RLRF Overview. We present an RL approach for inverse rendering code generation tasks, focused on SVG generation in VLMs. (Left) Given text or image input, the model generates multiple SVG rollouts, which are rendered and compared to the imput to compute rewards based on reconstruction, semantics, and code efficiency. Non-differentiabl steps (marked with stop signs) are handled through RL. (Right) A challenging ditto--diitribution example with no ground truth SVG. While the base model (SVG-SFT) fails, RLRF enables progressive generalization, producing meaningful SVG that captures key elements like shadows using gradients.
syntactic and visual accuracy on short examples. However, they suffer from consistency issues over long sequences and often fail to generalize more diverse ditoo--distribution inputs. We recognize that they operate with critical limitation: they do not observe or evaluate the rendered visual output of the code during training. Token-leved losses ensure syntactic correctness but fail to incorporate visual feedback from rendered outputs, causing models to hallucinate, loop, or lose grounding when handling complex inputs (see Figure I
This limitation arises from the non con-differentiabiltyy of the SVG rendering process in the context of autoregressive code generation, challenge that differs from settings addressed by differentiable rasterizers such as DiffVG [Li al. 2020]. DiffVG makes raster-space losses trainable by expressing an SVG small set of continuous primitives, and backpropagating the gradients from the rendered image to those primitive parameters. Autoregressive VLMs, in contrast, emit SVGs one discrete token at time, making the generation path non non-diffeen con-dfffrenttabll due to discrete sampling at each decoding step. As gradients cannot flow through discrete sampling steps, differentiable rendering approaches such DifIVG cannot be applied directly, leaving a critical gap in autoregressive SVG generation.
To address this, we propose RLRF (Reinforcement Learning from Rendering Feedback), a method for refining the SVG generation capabilities of pretrained VLMs using feedback from rendered code outputs (images), as depicted in. [igure[] Our key insight is that rendering, though non-differentiable can still provide valuable evaluative feedback: rendered outputs can be directly compared to the ground-truth image using automatic and high-quality reward functions. For each input image, the model samples multiple SVG roll-outs, renders them into images, and compares the results to the original.
We design novel composite reward function integrating complementary reward signals to guide learning: (1) image reconstruction, measured using metrics like I.2 distance, (2) semantic similarity, computed using models such as DreamSim [Fu et al. 2023) or CLIP [Radford et al.) [021]; and (3) code efficiency, based on deviations in SVG token length. This hybrid reward setup encourages the model to improve SVG generation along multiple axes. RLRF delivers substantial gains over supervised fine-tuning, addressing common failure modes and enabling models to acquire a deeper understanding of SVG, producing accurate and well-structured vector graphics across diverse inputs.
Our contributions are as follows:
1. We introduce RLRF, reinforcement learning method for SVG generation that leverages rendering rewards to optimize the model, marking the first use of online RI. algorithm for inverse rendering code generation tasks.

---

2. We introduce a set of rewards for vector graphics rendering that combine pixel-level similarity, semantic alignment, and code efficiency effectively guide models in SVG generation tasks.
3. We demonstrate state-of-the-art improvements in SVG generalization, fidelity, and code compactness across tasks and model sizes, supported by extensive analysis.
2 Related Work
SVG Generation SVG generation methods typically fall into three categories: classical image
processing, latent variable models, and large language model (LLLM)-based methods. Traditional
methods [Vision ( Seeinger, Peter] [0224 Weber, Martin 2024) rasterize images by tracing
contours and clustering regions, effectively extracting shapes but generating verbose, semantically
unstructured code. Latent variable models [Carlier et al. 2020, Wang and Lian 2021 Ma et al.) [022
Li al. 2020 Cao et al. 2023] enable better interpolation and style transfer but are bounded by
simplified SVG subsets. resulting in less readable code. Recent LLM-based approaches [Rodriguzz
al., 2025b] capture the full SVG syntax by treating SVG generation as code generation tasks. Subsequent studies (Zhang et al. 2023 Nishina and Matsui 2025 Yang et al.) (0255) explored structured generation. editing, and reasoning. However, because these models never validate outputs visually, they often generate inefficient or inaccurate SVG code. To address these limitations, we introduce RLRF, a reinforcement learning-basee post-training strategy that incorporates visual feedback into the learning loop, improving visual fidelity, semantic alignment, and code quality.
Vision-Languaae Models (VLMs) In parallel. vision- language models [Li ct al. 2022 Liu et al. 2023 OpenAl 2023] and code- oode-generating LLMs Nijkamm et al. 2022 Li et al.] 2023b] have advanced significantly, enabling tasks that span both modalities - such as inverse rendering where model generates SVG, TikZ. and CAD code from visual inputs (Belouadi al. 2024 Rodriguez et al. 2025a Belouadi et al., 2025 Wang et al.) 2025 However, these models often hallucinate or fail to generalize. Our work addresses this issue by providing visual feedback from the rendered output, which improves both downstream performance and generalization in code-driven visual tasks.
Reinforcement I Learning Post-Training Reinforcement learning (RL.)(Schulman et al. 2017 Zelikman et al. 2024 Rafailov et al., [0233 has recently emerged as powerful framework for post-training, particularly aligning large language models (LLMss) with human or programmatic feedback. GRPO et al. 2024) has shown that online RL can be both efficient and scalable for
LLM aligmment. However, most RL applications in code generation remain focused on execution correctness, largely ignoring visual or structural outcomes. For example. CodeRL [Le et al.] 2022] uses an actor-critic framework to optimize for functional correctness, while RLEF [Gehring et al. 2024] improves code quality by iteratively refining it based on execution signals. In contrast, work introduces a composite reward that incorporates rendering feedback, enabling optimization for visual fidelity, semantic alignment, and code efficiency in SVG generation. A more detailed discussion of related work is provided in Appendix D
3 Method
Autoregressive SVG Code Generation Autoregressive VLMs have recently been applied to generate SVG code from images. StarVector [Rodriguez et al. 2025b trains VLM by encoding images with a CLIP Vision Transformer [Rafford et al. 2021] and projecting features to the language model's dimension. Using next token prediction, it learns generate SVG code that shows strong semantic understanding and effective primitive identification, leveraging primitives like <text>, <circle>, and <polygon>, and enhancing visuals via color gradients. However, the model struggles with complex images requiring longer SVGs, often hallucinating or looping. This likely stems from a lack of direct visual feedback during training, as never sees rendered SVGs, limiting accuracy.
Overcoming the Non-Differentiable Rendering Problem In the autoregressive VLM setting, the model learns to translate pixel images into SVG code. However, at inference time, it can easily drift off-distribution, leading to poor visual outputs. Unlike other code generation tasks, inverse rendering tasks like SVG generation offer a unique advantage: the generated code can be rendered into pixel image and directly compared to the input, enabling precise and inexpensive feedback.
3

---

While differentiable SVG renderers such as DiffVG [L et al. 2020] exist, they rely on latent path representations and are not compatible with our general. token- based approach code generation. Moreover, because SVG generation involves sampling discrete tokens, gradients cannot be directly propagated. To address this, we propose RLRF (Reinforcement Learning from Rendering Feedback). The model generates SVG code, which is rendered and evaluated using composite reward that reflects visual fidelity, semantic alignment, and code efficiency. These rewards are used to optimize the model using reinforcement learning techniques (Schulman et al. 2017 Shao al. 2024], effectively incorporating rendering-baae -based feedback into the training process.
3.1 Two-Stage Training
Our training method first adapts the VLM to the SVG domain through supervised fine-tuning on the Im2SVG task (SVG-SFT), and then further enhances its SVG generation capabilities using reinforcement learming on visual renderings of its own SVG predictions (RLRF).
Stagel: Supervised Fine-Tuning on Images and SVGs (SVG-SFT) Let ah denote the condition- ing input (an image or a text prompt) and let x = ;........;. L..LL the ground-trutt SVG token sequence. We adapt the base VLM by minimising the negative log- likelihood
Σ loggoo(za (agetrre)
LSFT (0) Eu, wD |- log po( xx)]
E Eu. WD
(I)
where 0 are the model parameters. Equation(] corresponds to teacher forcing; it trains the model to complete every prefix in parallel and is therefore highly efficient. After SFT the model can generate plausible SVG code, but it is still unaware of the visual quality of its outputs because feedback is provided on the rendered image. This model shall be denoted as po.. (- Te).
Stage2: Reinforcement Learning from Rendering Feedback (RLRF) The conditional distribu- tion (- x.)) from Equation ① is subsequently reinterpreted as the stochastic policy during the RL stage. Ground-truth SVG tokens are labeled x, during SFT, whereas a sampled SVG sequence during RL is denoted o ~ pa( æe) to differentiate it from ground truth. After the model learns to write SVG code through SFT, we train it to evaluate this code by defining a scalar reward R(x,, o) calculated from the rendered images (details in Section 3.2). objective for given condition input ze:
For this stage, we want to maximize the
JRL (0) = Eo-ro [R(ze, o)] - 3KL. (po Po,a)
where po., is the frozen SFT model and B controls the strength of the KL regularization to prevent catastrophic forgetting. This can be optimized by any policy gradient method with baseline to reduce variance. However, learning a baseline or value network for lengthy, discrete SVG sequences adopt Group Relative Policy Optimization (GRPO) Guo
can be costly and unstable. Therefore, ct al. 2025), which eliminates the external baseline by centering rewards within a batch and maintains proximity between successive policies using PPO's (Schulman et al. 2017) clipped -aapi method.
We draw G roll-outs {01, 02, ... .g.) conditioned on the same input Te using the policy pe... (-|xe). The group-centered advantage and probability ratio for roll-out i is:
1 G
Pa (o: (t) Po (o: Ite)
A = R(Ze, 0z)
R(aes and
Our final GRPO objective to update the current policy po over the conditioning data is given by:
1
(O) Er
Σ min (r:A;, clip(rs, 1 1 e, + e) DKi (l
(4)
T
where e is a hyperparameter to clip the ratio.
3.2 Rewards for Vector Graphics Rendering
We carefully design reward functions that automatically evaluate SVG generation quality across multiple dimensions. key advantage of this setup that we have access to fully automated, high- quality reward signals, eliminating the need to learn using human annotations. We focus our

---

Input Qwen2.5VL.18 RLRF [ours]
SVG-SFT
GPT-4
LIVE
Input
RURF
Owen3-220
Fooel: sroand
cwmphive right
Conshuccon muser
bullding
A man ckmbdnng
Figure 2: Im2SVG Reconstruction. Left: input pixel image. Right: rendered SVG predictions.
Figure 3: Text2SVG Generation. Left: input text. Right: generated SVG renderings.
reward design on two core aspects of SVG generation: the visual fidelity of the rendered output and the efficiency of the SVG code in terms of compression. To capture both, implement suite of complementary reward functions that assess the rasterized image and the underlying SVG code. These include image reconstruction accuracy, semantic alignment, and code efficiency. By combining these rewards with tunable weights, our framework provides rich and targeted feedback that drives the model produce SVGs that both visually faithful and structurally compact. We as our SVG renderer.
utilize CairoSVG Kozea 2023
Image Reconstruction Rewards To measure how accurately the generated SVG reproduces the input image, we define pixel-level reward (L2) that both scale-invarian and robust exposure. Given the input image In and rendered prediction Ipred. we first normalize both to zero mean and unit variance, then compute the L2 distance and convert into clipped reward:
Rang- clip (1 (1-
1 N
norm in
pred 2' -1, 1).
(5)
where 7norm = n)/o, and clip(s, a, b) = min(max a). bounds the reward within [-1, 1]. This normalization ensures the reward emphasizes structural and color discrepancies relevant to vectorization, rather than large uniform regions or exposure artifacts. We also define an edge-aware variant, L2 Canny, where followed by dilation (3 x 3 kernel, iteration) and Gaussian blur (size 13), which enhances structural alignment based on visual fidelity.
apply Canny Edge Detector [Canny 1986) to both 1io and Aprdd
DreamSim [Fu al. 2023 which encodes each image using three ViT-B/16 backbones: CLIP, OpenCLIP (Cherti et al. 2023 and DINOv2 (Oquab et al., 2023). Their feature vectors concatenated, passed through linear projection, and compared using cosine similarity. The DreamSim score is computed as sim = c [0, 2). This provides strong semantic similarity signal for the Im2SVG task. For shape-focused feedback, we apply DreamSim Canny, which uses an edge detector on both prediction and target images before computing DreamSim. A comparison of edge maps emphasizes crisp contours and geometric accuracy while remaining insensitive to variation in color or texture. We convert sim reward using R.am 1 sim [-1, 1], where higher values indicate stronger semantic alignment. For the Tex12VVG task, we use CLIP as reward to compute the cosine similarity between the text prompt and the rendered SVG image in the embedding space. We also utilize VLM as judge to assess generation quality (see details for Tex12VVG rewards in Appendix A.2).
Semantic Similarity Rewards For semantic-level rewards,
Code Efficiency Rewards. To encourage compact SVG generation, define SVG Length Devia- tion as reward that penalizes excessive token length relative to the ground truth SVG. Let Lipedd and Lgt denote the predicted and ground truth SVG token lengths, respectively. The reward is defined as:
(1 max (0, Typred Leg )) Lgg
Rim
5

---

MSE (levt))
Rowward (lwst)
SVG Length (Train)
2750
0100
Trme
00073
2250
2000
1300
0250
Stop
Stap
Stap
Figure 4: Ablation on Sampling Temperature. Keeping the sampling temperature high is critical for promoting roll-out diversity. Test MSE, Reward, and SVG Length measurements consistently improve. We find that increasing the temperature up to 1.2 improves exploration, but values beyond this lead to unstable behavior and diverged outputs.
MSE (Trakt)
Reward [Train)
SVG Length (Triin)
Settings
Rolbura
20
Rolocca
1400
300
300
$top
3top
Step
Figure 5: Ablation on the Number of Roll-outs. Increasing the number of roll-outs consistently improves MSE, reward, and SVG length. We report training curves, which offer clearer visibility by averaging over a large number of roll-outs.
which applies quadratic penalty when the predicted length exceeds half the ground truth. This formulation allows moderate variation while discouraging overly long or redundant SVG sequences. We then apply clipping to constrain the reward within the interval [_1, 1].
Final Reward Aggregation We integrate multiple reward signals by computing weighted sum of individual components. Let R, be the ith reward function and wy its corresponding weight, for i = I,..., K. The final reward is given by Rexal Σ w;R,, This formulation allows fine-tuning the contribution of each component, ensuring balanced and flexible training signal.
4 Experiments
4.1
Experimental Setup
The main paper focuses primarily on the Im2SVG experiments, as this setting offers a well-defined and visually grounded framework for evaluating the SVG performance gains achieved with RLRF We also explore the Tex12VVG setting, presented primarily in Appendix where RLRF demonstrates strong generalization beyond image-conditioned generation. All experiments are conducted using publicly available vision- languag models (VLMs), specifically the Qwen2.5-VL. [Bai et al. 2025 and Qwen3 (Yang et al. 2025a] families (the latter used only for Tex12SVG). We also include the Star Vector- 1B model Rodriguez et al., 2025b), which is trained specifically for the Im2SVG task, and fixed input resolution 224 224. In contrast, Qwen2.5-V VL supports adaptive input resolutions and benefits from broad pretraining, enabling stronger general knowledge. However, Qwen models still exhibit limited performance on SVG-specific tasks without targeted fine-tuning.
Supervised Fine-Tuning on SVGs (SVG-SFT) We fine-tune Qwen2.5-Vi VL. models (3B and 7B) on the Im2SVG task using cleaned subset of 1.7M image-SVG pairs from the SVG-Stack dataset [Ro- driguez et al., 20255), resulting in the SVG-SFT models. Training runs used 4 H100 GPUs (3B model) or 8 8x8 H100 GPUs (7B model) for 4 days over 3 epochs, with learning rate 1e-5, batch

---

size 1024, and context length 32k tokens. Although Qwen2.5-V4 VL supports up to 128k tokens, we limit it to 32k to fit 90% of the data given memory constraints.
Reinforcement Learning from Rendering Feedback (RLRF) on SVGs For the Im2SVG task, further post-train the Qwen2.5-VL models, as well Stattrcto-- (which can be viewed as an SVG-SFT model), using RLRF. We begin by filtering the SVG-Stack dataset to select 20k high-entropy samples that rich in visual detail and SVG complexity (each with over 500 tokens). Details of this data curation process are provided in Appendix B.2 During training, we use the GRPO algorithm with rollout batch size of 32 images per step. For each image, 64 rollouts are generated, resulting in 2,048 rollouts per training step. We train for 500 steps in total, covering 16k unique images, significantly fewer than the 1.7M samples used in SVG-SFT. Training was completed in approximately 3 days using 4 nodes, each with 8xH100 GPUs. For Tex12SVG we use Qwen3-8B, a text-only model, and train it using image caption datasets (Flickr30k and MM-Icons), using only the captions as inputs (no SVG supervision). The model is prompted to <think> before generating SVG code. We train on a single node with 8xA100 GPUs for 4 days, using rollout size of 16 and a batch size of 32 per step, for 1000 steps, corresponding to 16k unique captions. Across all RLRF experiments, we use learning rate of 1c-5 with 70% decay every 100 steps. KL regularization is disabled (KL coefficient 0), with a clipping threshold = 0.4 and sampling temperature set to 1.1.
Exploration of Rendering-Basee Based Rewards and Hyperparameters Starting from Qwen2.55 VL-3B model fine-tuned with SVG-SFT, we apply RLRF We use the smallest model to reduce exploration cost, while ensuring that the findings generalize larger models. We run 800 steps (25.6k images) to study the impact of different rendering- based reward functions, and 150 steps (4.6k images) for hyperparameter ablations involving sampling temperature, KL divergence, and the number of rollouts per input.
4.2 Evaluation
Baselines. We compare our approach against image processing methods (Vtracer (Vision Cortex
2023]. Potrace [Selinger, Peter 2024]. PyAutoTrace [Weber, Martin 2024)). D. deep learning methods
(LIVE [Ma et al., 2022]. J. Diff [Li et al., 2020 D. and LLMs and VLMs including Claude3.7
Sonnet [Anthropic 2024). GPT-4o Hurst et al. 2024]. Gemini Family (Georgiev al., 2024] and
open-source models like Qwen2.5VL [Bai et al. 2025] or Llama4 [Meta] [005]] families. These baselines span a wide range of modeling approaches, scales, and architectures.
Benchmarks. For Im2SVG, we report results on SVG-Stack-Hard, a curated subset of 500 visually complex and diverse SVGs selected from the original SVG-Stack (see Appendix B.2 for more details on datasets). We also evaluate on additional benchmarks including SVG-Emo ji, FFnG-s and SVG- Icons [Rodriguez et al., 2025b). For Tex12SVG evaluation, we use the MM-Icon and MM Illutrtttitio (Yng et al. 2025b], as well as Flickr30k Captions (Young et al. 2014).
Metrics. For Im2SVG, we use MSE and SSIM for pixel-level fidelity, and DINO Score [Oquab] et al. 2023) and LPIPS Zhang et al. 2018) for perceptual similarity. Code Efficiency is the negated mean difference between ground truth and predicted SVG token counts. Positive values indicate more compact outputs. Ideally, the score is near zero, reflecting compression without loss of fidelity, For Tex12SVG, we evaluate with CLIP similarity and LLM--bsed judge (Qwen2.5-VL-72B) for text-image alignment. Additional details on metrics are provided in Appendix B.T
Results
5.1 Main Results
I22VVG Results. Table ! presents the Im2SVG results, Image processing methods like LIVE and VTracer achieve strong reconstruction scores, especially in MSE, by densely fitting paths to the image. However, this leads to artifacts and extremely long SVGs, often exceeding 7k tokens and reaching up to 100k, as reflected in their low code efficiency. Closed-source VLMs perform well overall. While they do not achieve perfect reconstructions, their performance improves with scale and benefits from SVG-rich pertaining. Open-source VLMS lag behind. Smaller Qwen2.5V1. models (3B and 7B) require heavy prompting and struggle to generate SVGs. Larger versions (32B and 72B) can produce SVGs, but still fail at accurate reconstruction.
7

---

Table 1: RLRF Boosts SVG Generation Performance. We compare baselines on the Im2SVG task using the SOG--Sack-Bai test set. Lower MSE/LPIPS and higher DINO/SSIM indicate better performance. Code Efficiency reflects token compactness, with values near zero being ideal. Open VLMs lag behind, while closed models perform well without SVG-specific tuning. Image processing methods achieve strong scores but generate verbose, inefficient code. LIVE scores highest but with high sampling cost. RLRF sets new state-of-the-a with consistent gains across all metries.
Model
MSE
SSIM
DINO
+ LPIPS
Code Eff.
Time(s)
VL (Open-Source)
23.62
55.46
82.38
35.83
+1.3k
58
23.20
55.72
81.68
34.14
+1.4k
62
Llama4-Scour (109B)
20.98
58.58
83.72
33.37
+1.4k
57
Llama4-Maveria (400B)
20.67
59.26
85.61
31.75
+1.3k
61
VLMs (Closed-Souree
Gemini-Flash-
20.38
59.65
84.70
33.27
+1.2k
Gemini-Flash-2.00
19.31
60.21
86.53
32.10
+1.1k
63
Gemini- 1.5-Pro
20.19
60.75
84.17
33.02
+1.2k
Claude 3.7 Sonnet
17.73
69.33
79.80
28.42
+1.4k
62
GPT-4o-1120
16.92
66.91
89.00
27.55
+1.3k
60
Image Processing Methods
Im2VEC
18.10
76.50
69.20
29.10
4.3k
<1
Potrace
8.15
77.28
89.23
19.10
-7.3k
12
DiffVG
6.64
81.23
86.12
20.5
-19.7k
PyAuto Trace
4.71
87.44
95.68
10.71
-99.7k
<1
VTracer
4.25
87.94
95.75
11.66
-1299k
SuperSVG
3.05
83.30
82.70
13.50
-65.6k
<1
LIVE
2.22
88.11
93.45
7.23
-18.3k
1.243
RLRF Results on SVG Base Models
StarVector- B--Base
4.60
87.00
96.00
9.22
-800
64
+RLRF (ours)
3,46
88.00
98.00
7.51
-127
23
A Improvement
-1.14
+1.0
+2.0
-1.71
+763
Qwen2.5VL-33-Innnnee
23.31
62.28
69.26
35.30
+1.5k
24
+SVG-SFT (ours)
9.48
78.40
92.60
17.44
-2.5k
67
+RLRF (ours)
4.79
88.76
95.97
10.97
199
48
A Improvement
-4.69
+10.36
+3.37
-6.47
+2.7k
-19
Bwenn.5-vL-7B--Issree
23.10
61.40
78.00
33.80
+765
37
+SVG-SFT (ours)
8.60
79.40
93.00
16.58
-2.8k
73
+RLRF (ours)
1.03
95.10
98.70
3.08
-334
63
A Improvement
-7.57
+15.70
+5.70
-13.50
+2.5k
-10
RLRF significantly boosts the SVG capabilitics of StarVector- Qwen2.5VL 3B and 7B,
improving both reconstruction accuracy and code efficiency. Qualitative examples in Figure 2 highlight the notable gains achieved with RLRF: it consistently generates coherent and well-aligned SVGs, while other methods often exhibit misalignments due to their lack of rendering awareness.
Tex12SVG Results. Beeueepeeeentt qualitative samples from four models: Qwen3-7B with RLRF, Qwen3-32B, GPT-4o, and Gemini 1.5 Pro. Using only 16k natural captions from Flickr30k and MM-lcons, with no paired SVG supervision, and our text-image alignment rewards, RLRF enables Qwen3-8B to generalize the Text2SVG task, consistently producing SVGs that closely align with user prompts (see Table/4ann Figures 3 p. Qwen3-32B, despite its larger size, lacks the SVG generation capabilities and rendering awareness required for high-quality outputs. often produces results that are misaligned semantically incorrect. GPT-4o and Gemini 1.5 Pro generate more coherent SVGs, but frequently rely on oversimplified representations and struggle with spatial layout and fine-gra ame-grained detail. While Qwen3-8B with RLRF achieves strong performance, it still faces

---

MSE (lest)
Reward (lsst)
SVG Length (Triin)
0.05
holk
0A75
Nambe of of"eeer
0.75
01400
18:0
Calo
1600
0.00
1420
0005
1200
0200
1052
0065
Stap
Stop
Stap
Figure 6: Ablation of the KL Term. Removing the KL term improves reward learning by avoiding early saturation. We attribute this to the conditional distribution p(SVG image) already being well-regularized by the rewards. RLRF benefits from this added flexibility without instability.
Table 2: Ablation the importance of SFT for RLRF, We evaluate the Qwen2.5VI.-7B model under different training configurations to assess the role of supervised fine-tuning on the Im2SVG task (SVG-SFT). The baseline is the instruction-tuned model, which has limited SVG capabilities. Applying SVG-SFT provides a strong performance boost. Running RLRF directly on the instruction- tuned model yields poor results, while the best performance achieved by combining SVG-SFT followed by RLRF.
Method
MSE 4
SSIM 1
DINO f
LPIPS
Code Eff.
Baseline (Instruct)
23.10
61.40
78.00
33.80
-765
Instruct SVG-SFT
8.60
79.40
93.00
16.58
+2,827
Instruct RLRF
14.23
67.23
81.12
26.32
-321
Instruct SVG-SFT + RLRF
4.42
89.09
96.12
10.41
+173
challenges with precise Bezier curves and often relies on basic geometric primitives. These limitations could be addressed through further model scaling and more diverse training data. Additional results and analysis are provided in Appendix
Models trained with RLRF demonstrate strong SVG generalization. We stress-test these models on out-of-distre distribbbtttonn benchmarks, including SVG-Emoji. SVG-Fonts, and SVG-Icons, and show in Table performance improves despite no exposure to these datasets during training. Qualitative examples, such as the "apple" and "strawberry" cases in Figures [ and further illustrate this effect. These samples include visual styles with shadows and layered effects that were never encountered during training and differ significantly from the training distribution. While the SVG-SFT baseline fails to produce coherent outputs under such shifts, RLRF enables the model to develop a deeper understanding of SVG structure, allowing not perfect. The generated SVGs are not only visually faithful to the input but also syntactically clean, editable (Figure 12), and practical for downstream applications. Additional results and discussion provided in Appendix
generate well-aligned and reasonable outputs, even if
5.2 Ablation Studies
using sampling temperature of 1.0 encourages diverse roll-outs, resulting in richer reward signals and more effective learning. Increasing the number of roll-outs per input, from 8 to 64, consistently improves performance. We observe no signs of reward saturation, suggesting that even more roll-outs could further enhance results. Figure 6 shows the effect of removing the KL divergence penalty in the GRPO objective. We find that excluding the KL term improves reward progression, avoids early saturation, and reduces computation, by eliminating the need to query the reference model. Our interpretation is that the conditional SVG distribution p(x, x.) is naturally narrow, thanks to the structured SVG syntax and strong reward signals. The KL term thus provides limited benefit and may unnecessarily constrain exploration. In addition, omitting the KI. penalty improves computational efficiency by eliminating the need to evaluate the reference model during each training step.
SVG Exploration Matters. As shown in Figures
4 and 5

---

Running RLRF directly on instruction-tunel checkpoints fails, shown in Table 2 These models lack the SVG proficiency needed to select appropriate primitives and explore effectively. SVG-SFT is essential to build baseline SVG fluency, while RLRF sharpens these skills for reliable Im2SVG and Tex12SVG generation.
Ablation of Rewards. The choice of reward has a significant impact on learning speed. Figure 13 shows that combining L2 and L2-Canny accelerates convergence compared using either alone. Adding DreamSim further accelerates convergence. While L2-based rewards favor precise recon- struction (lower MSE), they lack semantic coherence, as reflected in lower DINO scores. The best performance is achieved by combining pixel-level and semantic rewards. along with a length penalty for code compactness. More detailed analysis is provided in Appendix(A.4
Conclusion
We have shown that reinforcement learning (RL) can be highly effective for inverse rendering tasks, where models generate code that is rendered into images. By designing tailored rewards, we significantly enhance SVG reconstruction and generation capabilities in vision-language models (VLMs). We introduced RLRF (Reinforcement Learning from Rendering Feedback), a novel approach for fine-tuning autoregressive VLMS on SVG generation using RL. RLRF equips models with stronger understanding the SVG code space, enabling them to produce more efficient, semantically aligned, and visually accurate outputs, We first apply supervised fine-tuning (SFT) to give models a strong foundation in SVG generation. RLRF then drives exploration through rendered rollouts, computes automatic rewards, and optimizes generation accordingly. This results in a fully automated, high-quality training signal powered by a composite reward that balances pixel-level accuracy, semantic alignment, and code efficiency. The results are compelling: models trained with RLRF consistently generate SVGs with deeper structural understanding. improved visual fidelity, and significantly better code efficiency.
on benchmarks and SVG types not seen during training.
Broader Impact While our focus is on SVGs, the core idea behind RLRF generalizes in principle to other inverse rendering code generation tasks. This includes HTMLLCSSS/avaSeripp for web development, LaTeX/TikZ for scientific visualizations, 3D rendering code, and CAD modeling. We believe RLRF offers general framework for improving structured, code-driven visual synthesis.
Acknowledgements We sincerely thank Ghazwa Darwiche, Christian Hudon, Fanny Rancourt, and Marie-Eve Marchand for their invaluable administrative and technical support. This work was supported by the Natural Sciences and Engineering Research Council of Canada and Mitacs. Chris Pal acknowledges the Canada CIFAR AI Chair. This work was partially supported by the MITACS program, which gratefully acknowledge.
References
Saba Ahmadi, Rabiul Awal, Ankur Sikarwar, Amirhossein Kazemnejad, Ge Ya Luo, Juan A Ro- driguez, Sai Rajeswar, Siva Reddy, Christopher Pal, Benno Krojer. et al. The promise of rl for autoregressive image editing. arXiv preprint arXiv:2508.01111 2025.
Jean-Baptiste Alayrac, Jeff Donahue, Pauline Luc, Antoine Miech, lain Barr, Yana Hasson, Karel Lenc, Arthur Mensch, Katherine Millican, Malcolm Reynolds, et al. Flamingo: a visual language model for few-shot learning. Advances in Neural Information Processing Systems, 35:23716 23736, 2022.
Anthropic. The claude 3 model family: Opus, sonnet, haiku. https://www.atthrppic...
index/ claude- -aauude---aae
--maudde---moe----eeeee model -faddel-famllyy 2024. Accessed May 2025.
Rabiul Awal, Mahsa Massoud, Zichao I.i, Aarash Feizi, Suyuchen Wang, Christopher Pal, Aishwarya Agrawal, David Vazquez, Siva Reddy, Juan A Rodriguez, et al. Webmmu: benchmark for multimodal multilingual website understanding and code generation. In ICLR 2025 Third Workshop on Deep Learning for Code, 2025.
Shuai Bai, Keqin Chen, Xuejing Liu, Jialin Wang, Wenbin Ge, Sibo Song, Kai Dang, Peng Wang, Shijie Wang, Jun Tang, Humen Zhong, Yuanzhi Zhu, Mingkun Yang, Zhaohai Li. Jianqiang Wan,
10

---

Pengfei Wang, Wei Ding. Zheren Fu, Yiheng Xu, Jiabo Ye, Xi Zhang, Tianbao Xie, Zesen Cheng, Hang Zhang, Zhibo Yang. Haiyang Xu, and Junyang Lin. Qwen2.5-vl technical report. arXiv preprint arXiv:2502. 13923, 2025.
Daniel Baulé, Christiane Gresse von Wangenheim, Aldo von Wangenheim, Jean CR Hauck, and Edson C Vargas Júnior. Automatic code generation from sketches of mobile applications in end-user development using deep learning. arXiv preprint arXiv:2103.05700 2021.
Patrice Bechard, Chao Wang, Amirhossein Abaskohi, Juan Rodriguez, Christopher Pal, David
Vazquez, Spandana Gella, Sai Rajeswar, and Perouz Taslakian. Starflow: Generating structured workflow outputs from sketch images. arXiv preprint arXiv:2503.2 1889, 2025.
Jonas Belouadi, Anne Lauscher, and Steffen Eger. Automatikz: Text-guided synthesis of scientific vector graphics with tikz. arXiv preprint arXfv:2310.00367, 2023.
Jonas Belouadi, Simone Paolo Ponzetto, and Steffen Eger. Detikzify: Synthesizing graphics programs for scientific figures and sketches with tikz. arXiv preprint arXiv:2405. 2024.
Jonas Belouadi, Eddy Ilg. Margret Keuper, Hideki Tanaka, Masao Utiyama, Raj Dabre, Steffen Eger, and Simone Paolo Ponzetto. Tikzero: Zero-shot text-guided graphics program synthesis. arXiv preprint www::i0033.1500000 2025.
Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. Advances in neural information processing systems, 13:187771 2020.
Mu Cai, Zeyi Huang, Yuheng Li, Haohan Wang, and Yong Jae Lee. Leveraging large language models for scalable vector graphics-driven image understanding. arXiv preprint arXiv:2306.0666 06094, 2023.
John Canny. A computational approach to edge detection. IEEE Transactions on pattern analysis and machine intelligence, (6):679-698, 1986.
Defu Cao, Zhaowen Wang, Jose Echevarria, and Yan Liu. Sygformer: Representation learning for continuous vector graphics using transformers. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 10093-10102, 2023.
Alexandre Carlier, Martin Danelljan, Alexandre Alahi, and Radu Timofte. Deepsvg: A hierarchical generative network for vector graphics animation. Advances in Neural Information Processing Systems, 33:16351-11361 2020.
Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde de Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, et al. Evaluating large language models trained code. arXiv preprint arXiv:2107.03374 2021.
Mehdi Cherti, Romain Beaumont, Ross Wightman, Mitchell Wortsman, Gabriel Ilharco, Cade Gordon, Christoph Schuhmann, Ludwig Schmidt, and Jenia Jitsev. Reproducible scaling laws for contrastive language-imane learning. In Proceedings of the IEEF/CVF conference computer vision and pattern recognition, pages 2818-2829, 2023.
Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition scale. arXiv preprint arXiv:2010.119299 2000.
Shihan Dou, Yan Liu, Haoxiang Jia, Limao Xiong, Enyu Zhou, Wei Shen, Junjie Shan, Caishuang Huang, Xiao Wang, Xiaoran Fan, et al. Stepcoder: Improve code generation with reinforcement learning from compiler feedback. arXiv preprini arXiv:2402.0139) 2024a.
Shihan Dou et al. Stepcoder: Improving code generation with reinforcement learning from compiler feedback. arXiv preprint 200113240..01.99,, 2024b.
Aarash Feizi, Shravan Nayak, Xiangru Jian, Kevin Qinghong Lin, Kaixin Li, Rabiul Awal, Xing Han Lù, Johan Obando-Ceron, Juan A Rodriguez, Nicolas Chapados, et al. Grounding computer use agents on human demonstrations. arXiv preprint arX.v:2511..7333 2025.

---

Jon Ferraiolo, Fujisawa Jun, and Dean Jackson. Scalable vector graphics (SVG) 1.0 specification. iuniverse Bloomington, 2000.
Stephanie Fu, Netanel Tamir, Shobhita Sundaram, Lucy Chai, Richard Zhang, Tali Dekel, and Phillip Isola. Dreamsim: Learning new dimensions of human visual similarity using synthetic data. arXiv preprint arXiv:2306.099:: 09344, 2023.
Jonas Gehring et al. Rlef: Grounding code ilms in execution feedback with reinforcement learning. arXiv preprint arXiv:2410.02089 2024.
Petko Georgiev, Ving Ian Lei, Ryan Burnell, Libin Bai, Anmol Gulati, Garrett Tanzer, Damien Vincent, Zhufeng Pan, Shibo Wang, al. Gemini 1.5: Unlocking multimodal understanding across millions of tokens of context. arXiv preprint arXiv:2403.055300 2024.
Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, et al. Deepseek-rl: Incentivizing reasoning capability in llms via reinforcement learning. arXiv preprint arXiv:2501.12941 2025.
Jonathan Ho, Ajay Jain, and Pieter Abbeel. Denoising diffusion probabilistic models. Advances in neural information processing systems, 33:6840-6851, 2020.
Aaron Hurst, Adam Lerer, Adam Goucher, Adam Perelman, Aditya Ramesh, Aidan Clark, AJ Os- trow, Akila Welihinda, Alan Hayes, Alec Radford, et al. Gpt-4o system card. arXiv preprint arXiv:2410.21276. 2024.
Reza Kakooee and Benjamin Dillenburger. Reimagining space layout design through deep reinforce- ment learning. Journal of Computational Design and Engineering, 2024.
Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114 14, 2013.
Denis Kocetkov, Raymond Li, Loubna Ben Allal, Jia Li, Chenghao Mou, Carlos Muñoz Ferrandis, Yacine Jernite, Margaret Mitchell, Sean Hughes, Thomas Wolf, al. The stack: 3 tb of permissively licensed source code. arXiv preprint arXiv:22 155333, 2022.
Kozea. Cairosvg. https://cairosvg: org/ 2023.
Alex Krizhevsky, Ilya Sutskever, and Geoffrey Hinton. Imagenet classification with deep convolu- tional neural networks. Advances in neural information processing systems, 25, 2012.
Woosuk Kwon, Zhuohan Li, Siyuan Zhuang, Ying Sheng, Lianmin Zheng, Cody Hao Yu, Joseph Gonzalez, Hao Zhang, and lon Stoica. Efficient memory management for large language model serving with pagedattention. In Proceedings of the 29th Symposium Operating Systems Principles, pages 61 1-66, 2023.
Hung Le et al. Coderl: Mastering code generation through pretrained models and deep reinforcement learning. NeurIPS, 2022.
Junnan Li. Dongxu Li, Caiming Xiong, and Steven Hoi. Blip: Bootstrapping laaguage-imagge pre- training for unified vision- languaee understanding and generation. In International Conference on Machine Learning, pages I 12888-12900 PMLR, 2022.
Junnan Li, Dongxu Li, Silvio Savarese, and Steven Hoi. Blip-2: Bootstrapping language-image pre- training with frozen image encoders and large language models. arXiv preprint urXiv:2301.12597 2023a.
Raymond Li, Loubna Ben Allal, Yangtian Zi. Niklas Muennighoff, Denis Kocetkov, Chenghao Mou, Mare Marone, Christopher Akiki, Jia Li, Jenny Chim, et al. Starcoder: may the source be with you! arXiv preprint arXiv:2305.06 06111, 2023b.
Tzu-Mao Li, Michal Lukáč, Michaël Gharbi, and Jonathan Ragan-Kelley, Differentiable vector graphics rasterization for editing and learning. ACM Transactions on Graphics (TOG), 39(6):1-15, 2020.
12

---

Haotian Liu, Chunyuan Li, Qingyang Wu, and Yong Jae Lee. Visual instruction tuning. arXiv preprint FFXY::2304008885 2023.
Jiaheng Liu, Dawei Zhu, Zhiqi Bai, Yancheng He, Huanxuan Liao, Haoran Que, Zekun Wang, Chenchen Zhang, Ge Zhang, Jiebin Zhang. et al. A comprehensive survey on long context language modeling. arXiv preprint TrXiv:2503.17407 2025.
Xu Ma, Yuqian Zhou, Xingqian Xu, Bin Sun, Valerii Filev, Nikita Orlov, Yun Fu, and Humphrey Shi. Towards layer-wise image vectorization. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 16314-16323, 2022.
Ahmed Masry, Juan A Rodriguez, Tianyu Zhang, Suyuchen Wang, Chao Wang, Aarash Feizi, Akshay Kalkunte Suresh, Abhay Puri, Xiangru Jian, Pierre-André Noël, et al. Alignvim: Bridging vision and language latent spaces for multimodal understanding, arXiv preprint arXiv:2502.01341, 2025.
AI Meta. The Ilama 4 herd: The beginning of a new era of natively multimodal ai innovation, april 2025, 2025.
Shravan Nayak, Xiangru Jian, Kevin Qinghong Lin, Juan A Rodriguez, Montek Kalsi, Rabiul Awal, Nicolas Chapados, M Tamer Özsu, Aishwarya Agrawal, David Vazquez, al. Ui-vision: A desktop- centric gui benchmark for visual perception and interaction. arXiv preprint a5Xiv:2503. 15661, 2025.
Erik Nijkamp, Bo Pang, Hiroaki Hayashi, Lifu Tu, Huan Wang, Yingbo Zhou, Silvio Savarese, and Caiming Xiong. Codegen: An open large language model for code with multi-turn program synthesis. arXiv preprint arXiv:2203. 13474, 2022.
Kunato Nishina and Yusuke Matsui. Svgeditbench: A benchmark dataset for quantitative assessment of I1m's 's svg editing capabilities. arXiv preprint arXiv:2404.13710, 2024.
Kunato Nishina and Yusuke Matsui. Sygeditbench v2: A benchmark for instraction-based svg editing. arXiv preprint urXiv:2502. /9453, 2025.
OpenAL. (is--V( System Card, https: //cdn.. httt::::/ch..oppaa..oooo pdf September 2023. Accessed: 2023-11-05.
Card
Maxime Oquab, Timothée Darcet, Théo Moutakanni, Huy Vo, Mare Szafraniec, Vasil Khalidov, Pierre Fernandez, Daniel Haziza, Francisco Massa, Alaaeldin El-Nouby, et al. Dinov2: Learning robust visual features without supervision. arXiv preprint 27X1v:2304.07/93, 2023.
Long Ouyang et al. Training language models to follow instructions with human feedback. In NeurIPS, 2022.
Guilherme Penedo, Hynek Kydlíček, Anton Lozhkov, Margaret Mitchell, Colin A Raffel, Leandro Von Werra, Thomas Wolf, et al. The fineweb datasets: Decanting the web for the finest text data at scale. Advances in Neural Information Processing Systems, 37:308 1-30849, 2024.
Antoine Quint. Scalable vector graphics. IEEE MultiMedia, 10(3):99-102, 2003.
Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, et al. Learning transferable visual models from natural language supervision. In International conference machine learning, pages 9748-8763. PMLR, 2021.
Rafael Rafailov, Archit Sharma, Eric Mitchell, Christopher D Manning, Stefano Ermon, and Chelsea Finn. Direct preference optimization: Your language model is secretly reward model. Advances in Neural Information Processing Systems, 36:53728-5377 2023.
Juan A Rodriguez, David Vazquez, Issam Laradji, Marco Pedersoli, and Pau Rodriguez. Figgen: Text 2023a.
to scientific figure generation. arXiv preprint
Juan A Rodriguez, David Vazquez, Issam Laradji, Marco Pedersoli, and Pau Rodriguez. Ocr-vqgan: Taming text-within generation. Proceedings of the IEFF/VV Winter Conference on Applications of Computer Vision, pages 3689-3698, 2023b.
13

---

Juan A. Rodriguez, Xiangru Jian, Siba Smarak Panigrahi, Tianyu Zhang, Aarash Feizi, Abhay Puri, Akshay Kalkunte Suresh. François Savard, Ahmed Masry, Shravan Nayak, Rabiul Awal, Mahsa Massoud, Amirhossein Abaskohi, Zichao Li, Suyuchen Wang, Pierre-Andre Noel, Mats Leon Richter, Saverio Vadacchino, Shubham Agarwal, Sanket Biswas, Sara Shanian, Ying Zhang, Sathwik Tejaswi Madhusudhan, Joao Monteiro, Krishnamurthy Dj Dvijotham, Torsten Scholak, Nicolas Chapados, Sepidch Kharaghani, Sean Hughes, M. Ōzsu, Siva Reddy, Marco Pedersoli, Yoshua Bengio, Christopher Pal, Issam H. Laradji, Spandana Gella, Perouz Taslakian, David Vazquez, and Sai Rajeswar. Bigdocs: An open dataset for training multimodal models on document and code tasks. In The Thirteenth International Conference on Learning Representations, 2025a. URL httpp::/ htt.://wnnnnt/ooommmmmeeeeiiiaad
net
Juan A. Rodriguez, Abhay Puri, Shubham Agarwal, Issam H. Laradji, Pau Rodriguez, Sai Rajeswar, David Vazquez, Christopher Pal, and Marco Pedersoli. Starvector: Generating scalable vector graphics code from images and text. In Proceedings of the IEEE/CVE Conference on Computer Vision and Puttern Recognition (CVPR), 2025b. https:/tts///arrr http:///xxxvv.oro.. org/ abs/2312 11556
John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06337, 2017.
Selinger, Peter. Potrace.
wtt.//oo/tttaa. http://www..caaaaaaaaaae//pttaaa 2024.
Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang, YK Li, Y Wu, et al. Deepseekmath: Pushing the limits of mathematical reasoning in open language models. arXiv preprint arXiv:2402.03300. 2024.
Guangming Sheng, Chi Zhang, Zilingfeng Ye, Xibin Wu, Wang Zhang, Ru Zhang, Yanghua Peng, Haibin Lin, and Chuan Wu. Hybridflow: A flexible and efficient rlhf framework. arXiv preprint arXiv: 2409. 19256, 2024.
Parshin Shojaee, Aneesh Jain, Sindhu Tipimenii, and Chandan K Reddy. Execution- based code generation using deep reinforcement learning. arXiv preprint arXiv:2301.13811 2023a.
Parshin Shojace et al. Exccution-based code generation using deep reinforcement learning. arXiv preprint arXiv:2301.13816, 2023b.
Davit Soselia et Learning ui-to-code reverse generator using visual critic without rendering. arXiv preprint arXiv:2305. 2023.
Nisan Stiennon et al. Learning to summarize with human feedback. In NeurlPS, 2020.
Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. Advances in neural information processing systems, 30, 2017.
Vision Cortex. VTracer.
2023.
Ruiyu Wang, Yu Yuan, Shizhao Sun, and Jiang Bian. Text-to-cad generation through infusing visual feedback in large language models. arXiv preprint arXiv:2501.19055: 2025.
Yizhi Wang and Zhouhui Lian. Deepvecfont: Synthesizing high-quuity vector fonts via dual- dual-modality learning. ACM Transactions on Graphics (TOG), 415) 2021.
Weber, Martin. Autotrace. https: http:///ggtthbb..oo//tttttttr///
com
2024.
Ronghuan Wu, Wanchao Su, Kede Ma, and Jing Liao. Iconshop: Text-based vector icon synthesis with autoregressive transformers. arXiv preprint 0rXiv:2304.144000 2023.
Ximing Xing, Juncheng Hu, Guotao Liang, Jing Zhang, Dong Xu, and Qian Yu. Empowering Ilms to understand and generate complex vector graphics. arXiv preprint arXiv:2412.1 102, 2024.
An Yang, Anfeng Li, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Gao, Chengen Huang, Chenxu Lv, et al. Qwen3 technical report. arXiv preprint arXiv:2505.09..0 2025a.
14

---

Yiying Yang, Wei Cheng, Sijin Chen, Xianfang Zeng, Jiaxu Zhang, Liao Wang, Gang Yu, Xingjun Ma, and Gang Jiang. Omnisvg: A unified scalable vector graphics generation model. arXiv preprint Mii::2504.062000 2025b.
Peter Young, Alice Lai, Micah Hodosh, and Julia Hockenmaier. From image descriptions visual denotations: New similarity metrics for semantic inference over event descriptions. Transactions of the association for computational linguistics, 2:67-78, 2014.
Eric Zelikman, Georges Harik, Yijia Shao, Varuna Jayasiri, Nick Haber, and Noah D Goodman. Quiet-star: Language models can teach themselves to think before speaking. arXiv preprint arXiv:2403.09663 2024.
Richard Zhang, Phillip Isola, Alexei A Efros, Eli Shechtman, and Oliver Wang. The unreasonable effectiveness of deep features as perceptual metric. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 586-595, 2018.
Tianyu Zhang, Suyuchen Wang, Chao Wang, Juan Rodriguez, Ahmed Masry, Xiangru Jian, Yoshua Bengio, and Perouz Taslakian. Scope: Selective cross-modal orchestration of visual perception experts. arXiv preprint arXiv:2510.12977 2025.
Tong Zhang, Haoyang Liu, Peiyan Zhang, Yuxuan Cheng, and Haohan Wang. Beyond pixels: Exploring human-readate svg generation for simple images with vision language models, 2023.
URL https::/ //axxiv.//xivv///aa org/ ha/aabb//2111 15543
Yaowei Zheng, Richong Zhang, Junhao Zhang, Yanhan Ye, Zheyan Luo, Zhangchi Feng, and Yongqiang Ma. Llamafactory: Unified efficient fine-tuning of 100+ language models. In Pro- ceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 3: System Demonstrationss) Bangkok, Thailand, 2024. Association for Computational Linguistics.
URL http://arxiv org/ abs/2403 13372
Yaowei Zheng, Junting Lu, Shenzhi Wang, Zhangchi Feng, Dongdong Kuang, and Yuwen Xiong. Easyrl: modular toolkit for reinforcement learning with language models. Proceedings of the 41st International Conference Machine Learning (ICML). PMLR, 2025.
Daniel M. Ziegler et al. Fine-tuning language models from human preferences. arXiv preprint 10X.::9999.0893, 2019.
15

---

Appendix
This appendix provides additional details and analyses for the RLRF approach. It is organized as follows:
Appendix presents extended quantitative and qualitative results, including visualizations of SVGs generated from both image and text inputs. These results demonstrate how RLRF outperforms supervised fine-tuning (SVG-SFT) and other strong baselines.
Appendix B details the experimental setup, including datasets, evaluation metrics, and implementation specifics.
Appendix C provides further elaboration on the RLRF approach, covering architectural choices, training objectives, implementation techniques, and limitations.
Appendix D offers comprehensive overview of related work in SVG generation and reinforcement learning for structured code output.
Table of Contents
Additional Experiments and Results
17
A.I
Im2S VG Results
17
A.2
Tex12SVG Results
17
A.3
Generalization across SVG Benchmarks
18
Ablation Study; Impact of Rewards
20
A.5
Cases of Reward Hacking
24
A.6
User Study Editability and Fidelity
25
Experimental Setup
26
B. 1 Metrics
26
B.
2
Datasets
26
RLRF Method
27
Multimodal Architecture
27
2
Reward Details
29
Implementation Strategies for Stable and Robust RLRF Training
30
4
Limitations
30
Extended Related Work
30
D.I SVG Generation)
30
D.2 Vision-Language Models (VLMs)
31
D.3 Reinforcement Learning Tost-Training
32
16

---

Input Image
SVL-2-5LL-7B RLRF (ours)
Owen2 SVL.TB SVG-8FT
Qven2.5VL-775 Instrvet
Gemini 1.5 Pro
Input Image
Owwn2.5VL--7 RLRF (ours)
Qwend. SVL-TB SVG-SFT
2VL-2-5VL-708 Instruct
Gamini 1.5 Pro
R
?
?
#:
Figure 7: Im2SVG Results Visualization. We present qualitative comparisons of our RLRF outputs on test samples from the SVG-Stack-Hard benchmark, alongside generations from Qwen2.5VL-7B (finetuned SVGs via SVG-SFT), Qwen2.5VL-70B (not specifically trained on SVGs but proficient at SVG code generation), and Gemini 1.5 Pro. Our RLRF significantly enhances the performance of Qwen2.5VL-7B, enabling it to produce SVGs that are more geometrically accurate, color-consistent, and visually aligned with the input images.
A Additional Experiments and Results
This section provides additional experiments and results. Specifically, we present visualizations the generated SVGs for both the Im2SVG and Tex12SVG tasks, along with comprehensive quantitative scores. We also evaluate the generalization ability of RLRF by analyzing its performance on out-of- distribution test sets. Finally, we include ablation study assess the impact of different reward configurations.
A.1 Im2SVG Results
We show visualizations of results for Im2SVG in Figure 7 where we compare outputs from our RLRF with those from the SVG-SFT version of the Qwen2.5VLL-7B model, well larger baselines including Qwen2.5VL.-2 Stack-Hard test The SVG-SFT model often exhibits common failure modes such as misaligned shapes, incorrect spatial composition, or missing visual elements. In contrast, our RLRF significantly improves geometric accuracy and semantic alignment. For instance, in several samples requiring intricate spatial layouts or multiple object parts, RLRF consistently generates well-structured and complete SVGs, correcting the errors of the baseline models. Surprisingly. even compared to much larger models like Qwen2.5VL-7708 and Gemini 1.5 Pro, our fine-tuned 7B model produces outputs that are more visually faithful and aligned with the input images. This highlights the impact of our reinforcement learning approach in improving structured image-to-code generation.
and Gemini 1.5 Pro. The examples are drawn from the challenging SVG-
A.2 Text2SVG Results
Table presents quantitative results for the Tex12SVG task across three benchmarks: Flickr30k (proposed here), MM-Icons, and MM-Illutraaions Yang et al. 2025b]. These datasets allow for broad comparison actoss wide range of methods. For RLRF models, Flickr30k and MM- Icons captions are used during training, meaning the prompts are in-distribution. However, the corresponding SVGs are not used, making the generation task itself zero-shot. MM-Illustratios serves as an out-of distribbuttonno evaluation set.
We compare both open-source and closed-source VLMs, none of which were explicitly trained on these benchmarks. For baseline models, we report best available results, including those from MM-Icons and MM-Illsstration as documented in (Yang et al. 2025b). We are actively
working to expand the set of evaluated models and report additional scores. We also introduce new metric, Accurate, which is computed only on results for which ground ground-truth truth comparisons
17

---

valte arossi acruan wweaing
youry riking toeyche cronpe sececte
with
rov, rnd yoiza regreett
vayting aittie arrrpna is conaesl
pellow lgght
proampaie von foor equare
Input
sunderpes wen lage
(oos coest and
Qwend (ours)
Owend-328
GPT-4o
Figure Tex12SVG Results Visualization. We present qualitative comparisons of our RLRF outputs on test samples from the Tex12SVG benchmark, alongside generations from Qwen3-32B, GPT-4o, and Gemini 1.5 Pro. Our method effectively aligns Qwen3-8B to produce high-quality, semantically rich, and visually coherent SVGs.
feasible. The results show that while RLRF does not yet outperform the OmniSVG baseline, it demonstrates strong generalization and SVG generation capabilities. Notably, our method approaches OmniSVG's performance despite not being trained any paired SVGs from the target datasets. Among all models, Claude 3.7 achieves the strongest results, potentially due to specific tuning for SVG tasks. Nonetheless, RLRF showcases promising path toward rendering-awand aware, reward-driven SVG generation.
We show Tex12SVG visualizations in Figure g where we compare our method (Qwen3-8B RLRF) with larger baseline models, including Qwen3-32B, GPT-4o, and Gemini 1.5 Pro. Our approach consistently produces SVGs that are both semantically aligned with the input text and visually coherent. For example, the "girl in a yellow bathing suit" prompt, our model captures the full scene with correct composition and multiple characters, whereas other models either omit key elements or fail to structure the layout meaningfully, Similarly, for more abstract prompts like the "purple clipboard with yellow and orange accents", method generates recognizable object with the correct semantic attributes, while others produce vague or incorrect outputs. Notably, models like GPT-4o and Gemini often misinterpret structural compositional cues, especially in prompts requiring multiple interacting objects. Figure 9 presents two qualitative examples that illustrate the model's 's reasoning process after applying RLRF, as well the alignment between the generated SVGs and the input prompts. While the outputs are not yet fully aesthetic, is remarkable that the model demonstrates such strong generalization despite being trained only with text captions from natural image datasets, Le., without paired SVG supervision. The reward signal is provided solely by VLM (Qwen2.5VL-7B, which evaluates the rendered SVGs, detailed in Appendix C.2 Notably, the model has never seen an image during training (it does not have an image encoder), yer learns to produce visually coherent graphics through this reward signal. These results demonstrate that RLRF enables smaller models to outperform larger baselines in structured visual grounding tasks. We also tested RLRF on Qwen3-3B but found ineffective, as the small size of the model makes lack the SVG proficiency required to benefit from reinforcement learning.
A.3 Generalization across SVG Benchmarks
We tested the generalization capabilities of our trained RLRF models and found that the reinforcement learning stage equips them with strong out-of-distributte robustmess. RLRF models can handle new visual domains and vector styles that were never seen during training. This is shown in Table 3 presenting results on three out-of-distribution datasets (SVG-Emoji, SVG-Fonts, and SVG-Icons) which were entirely excluded from training. Rows marked "RLRF (ours)" correspond to models first instruction-tuun on SVG-Stack (1.7M samples), then refined with RLRF using curated subset
18

---

"ate" 'ate'
Create on of cpeppark oigncape sunset
citycape has
rreet witth- "Io0s" "ALL-"N360R2""
surset Let break doem Syberpune neon kigti, high-tech alemanti, and grmty urbnn
srect sote youa wisehe "seer hes nesphenteser
usuel cool tones Fert the ciyscape needs la bulliigss ylowing sigm, hesn Maybe dayccrapens thatinth nk, Muet.
affaetedd ee setterennreeeoo
Le scperia art xiree
ct' yo cetug ofreeee 223
green May some tnlographic etements feating around etrurauring dii
stop-calor "asadooo" /s
certse cystue" remmia ryetat aallecarreort
bus dings noon segna, dlo sany (ag meybe some loing <itsinns
spacttyrte.a"
</avgr
Ngsiihts
sidts telght "west vientur- resta=lentop// howe tttp:///wwo....///////////oa/ 2rg/2tt//agt
coaisheel hight teat osstnel
sreet aisthe 13t2 "Stp 13l1-999te00
<therka Olkyy, the user wearts siekk and repolasouu koon beeak down the loy a ensenty, Rrst the ort neods bo
callipas com cyntape" ranteat rymta
glowiigg green ahou use gr gradient steais
biedd into a beggnter nor line grenn, Thon add vore figsighss
and
Glav Effect
Faa spacco 255 0,0 33" apecityenn C calligse
I. finwgy manating from with mayys soms tain from
To31 agg.g.. 243, 8, 3,33" opecitye (...)
Maybee
light shae while line transperancy
to suppest eneryy without oen spowwing the muin grwen
to coneey the high-bh dech and myster ous vibe. Keep the
office: stop-celee coo-teleer"cceeeee" "coeodes" stxp sorraty stte
<defsp irddaalraation idd pracienttrii castsmer
Make PVV soalable the delats are dlear any son. <20nnko
clean
atop-calor nefrrew" srop-qaciiyy 1.r7 catno
specity
Vrraiiabraatient </dere> <revp
Figure 9: Text2SVG Generation Examples from RLRF. We show samples generated by the Qwen3- 8B model after applying RLRF training. Each example begins with a reasoning-style planning phase, followed by the generation of SVG code. The two prompis-one describing a cyberpunk scene at sunset and another depicting a mysterious green orb-are rendered into long and complex SVGs that closely match the inputs. Notably, the model achieves this despite its relatively small size (8B), and such quality was not attainable before reinforcement learning. Larger models and more training data are expected further improve results, as current trends show no signs of saturation.
of 16k images (SVG supervision is not used in this stage, only rendered rollouts are rewarded). Across all perceptual fidelity metrics (lower MSE and LPIPS, higher SSIM and DINO), RLRF delivers significant improvements over its own supervised (SVG-SFT) baseline and over all other open-source or commercial VLMs. For example, on SVG-Emojis, the Qwen2.5VL-7B SVG-SFT model improves from 6.39 MSE and 90.99 DINO to 4.93 MSE and 93.50 DINO, while reducing the average SVG length by approximately 1,500 tokens. A similar improvement is observed on SVG-Fonts, where the MSE drops from 7.1 to 4.73, despite no fine-tuning on that domain. These results demonstrate that reward signals derived from rendered images generalize effectively to unseen domains, even without direct supervision on those categories during optimization. In contrast, models like Vector require explicit fine-tuning on each target dataset to achieve comparable performance, as shown by their tpsk-spe tuning on SVG-Fonts and SVG-Icons.
We further observe that RLRF consistently outperforms SVG-SFT across all metrics on both SVG- Emojis and SVG-Fonts. However, on SVG-Icons, RLRF only improves perceptual metrics such as DINO and LPIPS, while MSE and SSIM scores are slightly worse. This discrepancy likely due to the nature of the dataset, which is heavily skewed toward sparse line drawings on white backgrounds. In such cases, small misalignments in thin black strokes can cause large changes in pixel-basee metrics, making MSE and SSIM less reliable indicators of perceptual quality. Notably, traditional image processing methods perform quite well in general, as they are highly optimized for this style of imagery. However, this comes at the cost of producing extremely verbose SVGs with unnecessarily long token sequences, which lack semantic structure and often result less efficient, non-sharp outputs and with artifacts [Rodriguez et al. 2025b).
We show qualitative visualizations in Figures 10 and highlighting the generalization capabilities of RLRF, Despite never being trained on these datasets, models fine-tuned with RLRF produce SVGs that closely match the input in both shape and style, often achieving near-perfect reconstructions. SVG-SFT provides a reasonable baseline and captures basic structure, confirming the importance of the supervised pretraining stage. However, it frequently exhibits notable misalignments. For example, in the "disk" icon, RLRF preserves overlapping circular segments more accurately, whereas SVG-SFT distorts the occlusion geometry. In the "dress" example, RLRF leverages symmetry more effectively, producing more coherent and balanced shape. Other models, including GPT-4o, Claude 3.7, and Gemini 1.5 Pro, perform inconsistently and often fail to reconstruct fine details or preserve shape semantics. This highlights the advantage of reinforcement learning from rendering feedback, which
19

---

Qwen2.5VL-77 RLRF (ours)
Qwen2.5VL.
Claude 3.7
Qwen2.5VL-322B
Input Image
Gemini 1.5 Pro
GPT-4o
NA
Figure 10: Results on the SVG-Emoji test The task is Im2SVG, where the first column shows the pixel-based input image and the remaining columns show generations from different models. This benchmark tests out-of-distribution generalization, as neither RLRF nor SVG-SFT models were trained on this dataset. RLRF shows clear improvements over SVG-SFT, with more coherent and visually accurate outputs. Other strong models like GPT-4o and Claude 3.7 also demonstrate notable generalization
enables RLRF to develop a stronger understanding of structure and style across out-of-distribution examples.
limitation we observe on RLRF the model's tendency to "give up"" on very complex inputs, producing code that diverges and then falls into loops. This likely stems from difficulty approximating intricate visual content. We believe this can be mitigated by scaling up the diversity and complexity of training data, especially images that require longer and more challenging SVG sequences.
Image processing methods still excel at pixel error: Vectorization pipelines like VTracer and LIVE achieve the lowest MSE values on inputs that simple single-color glyphs with white backgrounds, where exact pixel reconstruction is relatively easy. However, these methods score lower on perceptual metrics like DINO, which emphasize sharpness and human- pernevvee fidelity. They also produce SVG code that is orders of magnitude longer and less efficient than any learning-base approach, lacking semantic alignment and practicality for editing or deployment.
RLRF offers the best balance. While image processing methods remain strong on raw pixel metrics, RLRF is the only approach that consistently improves pixel fidelity, structural similarity. semantic alignment, and code compactness. By combining econstruction--bsee and efficiency-based rewards, RLRF learns to generate SVGs that are visually accurate, semantically meaningful, and compact, making it a strong candidate for real-world deployment where models must generalize to new domains and produce editable, efficient code.
A.4 Ablation Study: Impact Rewards
Figure 13
and Table 5 present ablation study the impact of different reward configurations
introduced in Section 3.2 We begin with the Qwen2.5VIL-3B model after completing the SVG-SFT stage. At this point, the model is already capable of generating valid SVGs that resemble the input
20

---

Qwen2.5VL-78 RLRF (ours)
Qwen2.5VL-77 SVG-SFT
Claude 3.7 Sonnet
Qwen2.5VL-328
Input Image
Gemini 1.5 Pro
GPT-4o
Instruct
R
R
R
B
R
M
L
AL
L
L
LILL
L
SIFÉ
K
?
R
F
F
F
Figure 11: Results on the SVG-Fonts test set. The task is Im2SVG, with the first column showing the pixel-based input and subsequent columns displaying SVG generations from different models. This benchmark evaluates out-of-distribute generalization, as the models were not trained on font- like images. RLRF demonstrates strong vectorization capabilities, producing accurate and structurally clean SVGs. In contrast, the SVG-SFT model struggles with alignment and consistency, and all other models perform poorly on this dataset, often failing to capture basic shape.
mestrceess mattaa La aidt) atttrtattt meno 1 www.tttttaaaraaoooooooo.. JAABB wtw. www.mmaaaaaaannn. CETELLLTE
STU, O2 wowger Jenams popenttteene clesstt
selgne" (onmenttt EeC COTT (o
style
secciyd
cleantatt our 79.00 eye1330 20 wi27 Eredinn 10t (8-56C) Ce o-"30.77 ee50..22
gractenniiiee weerigteee seteecaaa" -atto offerring style cop--lorra 1402 offent-1* stple mto-oloooettnn
www.aaaataaaaaaeeoeo.a.oo Sradintt 36/74620
gerss paroe -0 25" yor 20 offaeen'" style"'555 www.eooo---3----- 00000 ww-.88000000010000 7w4812 oftupe' style
aaraerna and 10-g-aa class "118"
affist- styla-"ats 2os.rro0i0222
offaee-"1
clase
S-tuu 2000, 35, de
12.7. MEDR. 12.32
28- 19,1% METORRT
19.32.11.7 7imerr 19.9 3.56e
claaeeass
45,
Figure 12: Im2SVG Vectorization Result: Apple Example This challenging sample highlights the effectiveness of RLRF. The image contains complex shapes, lighting effects, and semantic cues that require multiple SVG primitives: rectangles for the background, paths for the main structure, and gradients for shadows and highlights. Such examples are not present the SVG-Stack dataset, which primarily contains simpler icons and logos. While SFT alone fails to reproduce this image, RLRF enables the model to generalize and successfully generate high-fidelity SVGs for out-of-distribution samples like this.
21

---

Table 3: RLRF Generalization Results. We test our RLRF models are evaluated on out-of- distribution datasets that were not used at any point during training. Despite not being exposed to these datasets, the models perform surprisingly well, demonstrating strong generalization capabilities. This is notable improvement over previous SFT-based approaches, such as the Star Vector- IB and 8B models, which only achieved good results when fine-tuned directly on each target dataset. Image processing methods also perform well in these settings, as they specifically optimized for such domains. In contrast, other VLMs struggle to generalize beyond the SVG distributions seen during their pretraining, resulting in significantly lower performance on these out-of-distribution tasks.
Midel
MISE
SSIM
DINO LPIPS
EIE
LPIPS
ERE.
MMSE
-SIM
Code
V..M
(Ojeen Source)
16.96
$2.01
78.26
46.19
-1850
30.44
40
25.
-1812
17.55
62.14
K2. 18
90.08
-1994
Doon2-5VL-72B-oooo
17.04
58.25
74.38
45.83
-2171
24.76
57.24
$1.20
22.69
-1905
60.97
79.50
26.55
-3975
1 Lamatt-Mmmmcc (400))
16:35
58.02
78.69
43.90
-2106
23.82
67 35
22.11
-1899
16.04
66:15
K5.96
21.61
-1M6
Llanat-Suntt
15.76
44.71
-2158
23:25
-1938
67.76
63:62
25.05
VL.M
(ChuveffSSarree
11mini-Flad-11
15:42
90.47
M0.11
44.57
-1841
73.41
50
74
24.34
-1875
14.79
65.00 10
K3.91
27.86
-1811
Glmini-Fled-20
15.31
60.05
76.31
44.41
-1856
23.31
65.05
83.85
23:11
-1698
69.18
67
24.37
-1661
Geniti- 1.PPPo
15.93
59.41
78.23
46.05
-1942
27.19
62.92
$1.13
24.11
-1770
19.71
63.65
$3.09
26,89
-3815
13:44
39.52
-2122
20.75
09.13
21:22
1905
9.52
14.24
5932
20666
Clande 3.7 Sonnet
11:43
64.55
85.10
35,86
-1828
16.50
73
89.77
1563
-1095
7.83
76.79
99. 10:30
17.57
-3707
Processiny Methads
Porrace
6.70
78,00
89.20
26,70
-9700
0.200
56.30
96.70
01.00
4200
0.40
97.30
97.20
2.30
12200
VTracar
0.90
89.40
98.10
7.40
-15700
0.90
68.80
96.40
2:70
-4500
1.70
91.40
94.00
6.20
-20000
PshatoTruce
1.10
90.20
7.70
94000
0.00
95.40
2.50
.30000
93.70
94.60
5.30
3:00
77.00
S1.40
24.20
-19700
0.70
95.00
K2.10
5.10
-15700
1.50
95.00
95.20
5,00
119080
92.3
KLRF Revalu on SVG Base Modell
Star Vecton
6:30
82,00
92.50
21.70
1800
2.20
96.10
97.
2.20
-2470
95.
97.5 17.50
Stw Vecvee811
5:30
87.90
94.30
19.30
-6700
2.90
94 60
96.35
5.00
-1000
97. 90
96 40
3.50
-7800
Qwen2.5VL. 3B Issioutt
20.25
29.34
68.34
46.32
-258
25.97
65.27
75.35
22.90
-1099
21.43
65.60
77.41
24.55
-0024
+SVG-SFT (ouns
6.74
25.78
-2551
7.42
50.20
50,00
10:32
2060
5.56
5M.17
K5.94
12.88
-4223
.RLRE (suns)
5.45
77.73
91.75
32.82
-661
5:04
87.43
94.03
7.75
-1574
5:13
$2. 49
91 70
11.64
-3887
Qwe.2.5.VV Instruct
18:00
45.75
-0055
26.52
63.92
77.91
23.59
69.41
50.59
1SVG SFT (oons)
6.35
81.85
90.99
24.12
-2511
7.71
58.88
91.12
10.27
2063
6.16
88.34
K5.22
13.37
-422
+RLRE (ownc)
4.91
73.87
91.50
31.06
-163
4.73
91.73
7.36
-1550
7.58
61.64
90104
17.05
-3111
image in simple and moderately complex cases. However, it still lacks rendering awareness, which is necessary for achieving high pixel-level and semantic alignment.
We evaluate several reward configurations, including L2 loss alone, L2 Canny (which focuses on edges), DreamSim alone, DreamSim+Canny and combinations that include the Length penalty. We also test the full composite configuration that integrates L2, DreamSim, Canny, and Length.
All experiments are evaluated on the SVG-Stack-Har test set using four metrics: DINO Score, MSE, LPIPS, and SSIM.
Table 5 summarizes the best checkpoint scores across training steps. We observe that the best overall performance is achieved when using the full combination of rewards. This setup produces high semantic alignment (reflected by DINO Score), while maintaining strong reconstruction fidelity (low MSE and LPIPS, high SSIM).
The progression curves in Figure 1 highlight several trends:
DreamSim-based rewards alone saturate early and yield weaker reconstruction scores, but show stronger perceptual alignment, as indicated by DINO Score. This suggests that DreamSim encourages high-level semantic consistency rather than precise pixel-level accu- racy.
All configurations that include L2 lead to significantly better performance in MSE, LPIPS, and SSIM. L2+Canny slightly improves early convergence, while adding the Length term contributes smoother and more compact SVGs.
The full reward combination consistently outperforms other setups, offering both stable convergence and improved results across all metrics. This configuration balances pixel-level precision and perceptual alignment while also improving training stability.
22

---

Table Text2SVG Performance Across Diverse Datasets. This table shows that RLRF improves Tex12VVG performance over the base model Seven3-BB-Instrue before RL) across multiple datasets. Although the gains are less pronounced than in Im2SVG, this is partly due to the limitations of standard metrics like CLIP and Aesthetic, which are biased toward natural images and misaligned with SVG- like outputs (see Figure 3 for visual examples). Our proposed Accurate metric, which uses I.L.Ms as judges, more clearly captures the improvements. We also report scores from OmniSVG (Yang et al. 2025b], the current sfate-oftthe-art on MM-Icon and MM-Illustration. RLRF models consistently rank second, outperforming all other baselines.
Model
Flickr30k
MM
MM Illustration
CLIP
Accurate
Aesthetic
CLIP 1 Accurate
Aesthetic
CLIP
1 Accurate
Aesthetic
VLMs (Open-Source)
LLMASVG-GPT2XL (3B)
18.58
0.27
0.40
26.82
3.21
3.12
21.70
2.38
2.47
Owen2.5VI.co Instruct
22.10
2.08
2.07
30.26
3,57
3.21
28.54
3.19
2,80
Owen2.5VL. -VL--72B-nnttr
22.27
1.78
30.26
3.48
29.01
3.13
2.85
Llama4-Scone (109B)
21.94
1.92
2.42
30.31
3.56
3.27
29.00
3,30
2.99
Llama4 Maveen-k (400B)
23.26
2.36
31.17
4,01
3.54
30.18
3,76
3.25
VLMs
(Cosed/-ouuce)
Gemini-Flass Flasb-1.5
22.09
1.59
2.16
30.28
3.37
3.23
29.70
3.16
3,05
Gemini-1.5-PP
23.61
2.24
2,30
30.65
3.37
3.41
29.52
3.49
3.14
Demini-Flash-22
1.87
30.00
3.93
29.50
2.92
GPT 11140-11120 1120
25.00
2.43
2.48
31.92
4.10
3.57
31.53
3.92
3.32
Claude- 3.7-omnet
3.37
32.75
Tex12VVG
Vectorfusion SVGDreamer
27.98
26.39
29.23
27.95
Chat28VG
30.29
28.91
lconShop OmniSVG
23 59
21.98
RLRF Models
Qwen3-88B Breenn-8B-Innseee Instmuctt
22.50
2.74
2.53
30.09
3.77
3.35
29.05
3.63
3.15
+RLRF(tiick) (ours)
24.42
3.65
30.20
3.88
3.47
CRLRF(icons: (ours)
22.64
3.12
2.75
30.28
4.13
3.65
29.28
3,95
3,45
Table 5: Ablation Study on Rewards. Higher DINO and SSIM, and lower MSE and LPIPS indicate better reconstructions. This table shows the effect of different reward formulations. Using 1.2 achieves a strong MSE score, and I.2+Canny further improves it. DreamSim and DreamSim-Fdges alone result in poor performance, but their combination with Canny edges yields better outcomes. The best overall performance is achieved when combining all rewards using weighted sum. We clearly observe substantial improvement from the baseline (Qwen2.5VL-3B after SVG-SFT, before RL) to the final model trained with RLRF.
Reward(s)
MSE
t SSIM
DINO
LPIPS
Baseline (no RL)
7.48
78.40
92.6
17.44
L2
4.77
88.25
95.85
10.90
L2 Canny
4.60
88.30
95.60
10.95
L2 L2 Canny
4.50
88.25
95.65
10.95
DreamSim
4.90
87.90
95.90
11.30
DreamSim Canny
4.85
87.90
96.00
11.35
DreamSim Canny 1.2 Canny Length
4.75
88.30
96.00
10.80
All rewards (weighted sum)
4.55
88.45
96.00
10.75
L.2 alone remains competitive for minimizing MSE, as expected for pixel-focused reward, but lacks the broader alignment capabilities offered by perceptual and structural signals.
These findings confirm the effectiveness of combining multiple reward signals (pixel-based, semantic, and code sifccenncybaseede for optimizing SVG generation in RLRF.
23

---

DINO Score (lest)
MSE (Test)
+50
Li
MILE 50
Droaden Daiyy Canyy
La Canty Unarrie Drar Largh
Grobal Sino
Global Step SSIM (Test)
LPIPS (Test)
14.0
120
82.0
672
Stop
Gobal Stop
Figure 13: Ablation on the Impact of Rewards. We show the evolution of test metrics during RLRF training under different reward configurations, Using I.2 alone leads to strong reconstruction performance, particularly in MSE. DreamSim on its own performs poorly, but combinations that include DreamSim alongside other signals tend yield better results. The best overall performance is achieved by combining all reward components, which provides stronger and more stable learning signal. This setup balances pixel-level accuracy (as reflected in MSE, LPIPS, and SSIM) with perceptual alignment (indicated by higher DINO score).
A.5 Cases Reward Hacking
We observe several instances where the model learns to exploit the reward function without actually improving output quality, a behavior known as reward hacking. Below, we highlight one the most notable cases and the corresponding mitigation strategy.
Small ViewBox Hack. The model learns to produce SVGs with extremely small viewboxes, for example: <svg ... viewBox="O 0 1">. This causes the renderer generate extremely low-resolution image, and the input image is similarly resized for comparison. As a result, most information is lost, and the image-based reward becomes artificially high.
This issue arises because we originally used the predicted SVG's viewbox to guide rendering resolution. To fix it, enforce rendering using the reference image size and aspect ratio derived from the input image, ensuring a fair and stable reward computation.
SVG Length Collapse. In some cases, observe that the model progressively generates shorter and shorter SVGs until reaches a collapse point, after which generation diverges entirely and becomes unusable. This behavior is driven by the length deviation reward defined in Equation 6 which continues to incentivize shorter outputs up to half the ground truth length.
The issue arises because lengths below 1 Lgr still receive increasingly higher rewards, peaking at 1 when exactly half the length is reached. However, this unintentionally encourages the model to keep shrinking the SVG below that threshold.
To address this, we explored assigning fixed reward -1 when the predicted length falls below half the ground truth. In practice, we found a more stable solution by reducing the weight of the length reward 0.1 in early training, then gradually increasing it as RLRF progresses. Once the model has undergone sufficient RL training. it is no longer biased toward producing overly short sequences.
Text-in-Image Hack. In the Tex12VVG setup, where the model receives a textual instruction and generates corresponding SVG code, we observed common reward hacking behavior. The model learns to exploit the reward signal by using the <text> SVG primitive to render the exact prompt

---

A8 Particpation Stats
Model Ansigmment Breakdown
19 Loae
267
Rute Ohee
14.1 Aveoge lverul www.a Usar
ivmn ne Fro "MoesA" E' seted inttatte
Octalled Analysis
BLAT
125 153115
BLBF
153 170,00
BLAP
114 (227
(5500)
Summary for R8B5 Owen SP*
Figure 14: Statistics about the human evaluation study and main results, favouring RIRF-trained methods.
string directly onto the image. This artificially boosts similarity scores, especially when using CLIP-based rewards, since the rendered image containing the input text aligns closely with its textual embedding. Figure 9
To mitigate this, we preprocess the SVG before rendering and strip out any <text> elements or related primitives that visually encode the input prompt. We also strengthen reward robustness by incorporating Qwen2.5-728B 2-------Bbssee evaluator as part of the final reward mix, which helps reduce reliance on shallow visual-textual shortcuts.
A.6 User Study on Editability and Fidelity
We ran user study evaluate the editability and fidelity of SVGs produced by four model variants: Star Vector, StarVector + RIRF, Qwen2.5Vi.-7B + SFT, and Qwen2.5VL.-7B + RIRF. We sampled 50 examples from the SVG-Stack-Han Hard dataset, covering wide range of primitives and structural complexity.
For each example, participants were shown the ground truth image together with paired outputs before and after RLRF They were asked to rate the following aspects:
Fidelity: The extent which the generated SVG matches the target image.
Editability: Whether the SVG is clean, structured, and easy modify, for example through appropriate use of primitives and absence of redundant paths or unused style attributes.
We collected total of 267 evaluations from 18 participants, including three professional designers. All model outputs were anonymized, and the interface randomized the presentation order for each task.
In terms of Fidelity, RLRF preferred in 42.7 percent of comparisons, SFT in 12.0 percent, and the remaining 45.3 percent were ties. Regarding Editability, RLRF was preferred in 59.2 percent of comparisons, SFT in 15.0 percent, and 25.8 percent were ties.
These results show that RLRF improves both fidelity and editability compared with SFT. Although SFT already achieves strong fidelity and ties with RLRF on many straightforward examples, RLRF performs better on the more challenging cases without reducing visual quality. Participants consis- tently favored the SVGs produced by RLRF in terms of structure and ease of modification. Designers specifically pointed out that SFT sometimes introduced unused attributes or redundant styles, while RLRF produced more compact and interpretable paths and cleaner overall organization.
25

---

Input Pixel Image
RLVG SVG Rollouts
Figure 15: RLRF Improves SVG Generation. Given an imput image (left), show five SVG generations produced by the model after applying RLRF. By rendering its own predictions and receiving rewards for accuracy and compactness, the model improves over time.
B
Experimental Setup
B.1
Metrics
In addition to the metrics described in Section 4.2 we provide further details specific to the Tex12SVG task. We first employ the CLIP Score, following prior work [Wu et al. 2023 Rodriguez al. 2025b
Yang et al. 2025b]. along with CLIP Aesthetics. These metrics capture general image-text alignment. However, we observed that they do correlate well with the visual characteristics of the SVG
images generated by our models when RLRF is applied to general-purpose purpose instruction-tuner models
such Qwen2.5VL.
To address this, we introduce a dedicated Tex12VVG Accuracy Score ("Accurate"), which uses a vision-language model (specifically, Qwen2.5VLL-70B generation along several axes. The prompt used is shown in Prompt and was carefully designed and tuned using held-out validation ensure that model- scores align with human preferences.
judge. The VLM is prompted to rate the
B.2 Datasets
Curating SVG Stack To train model, we require large-scale data to capture the fundamental structures SVG. For this, we leverage the SVG-Stack dataset [Rodriguez et al.) 20256), which consists of SVG files scraped from GitHub. We rasterize these files to obtain paired image-SVG examples.
The original SVG-Stack contains M samples. We preprocess this data by rounding decimals to two significant figures, removing XML headers, and filtering out samples with excessively long URLs or embedded basc64 images, which could lead the model to memorize irrelevant content. After cleaning, we retain 1.7M high-quality examples, which we use to train the model the SVG-SFT stage, where it learns generate SVGs from images faithfully as possible. The SVGs are rendered using CairoSVG Kozea 2023), and image augmentations follow the protocol introduced by LLaVA Liu
al. 2023
SVG-Stack-Hard Test Set We construct the SVG-Stack- Hard benchmark to address several limitations the original SVG-Stack evaluation set, which contains noisy, overly simple, and short samples. The full test set is also relatively large (3k samples), making evaluation slow, and includes some broken or empty (white) SVGs.
To improve quality and difficulty, we first filter out broken SVGs, white- white-backgrone background SVGs, and samples with low color entropy. We then retain only SVGs with at least 500 tokens to ensure complexity. Next, we cluster the remaining samples using DINO image features and perform stratified sampling to select 600 examples. Finally, we manually verify and curate this set ensure includes visually intricate and moderately challenging samples.
26

---

Implementation Details We use the (LaMA--Fccton codebase [Zheng et al. 2024 to conduct our supervised fine-tuning (SFT) experiments. For reinforcement learning, including our GRPO-based approach, we build on EasyR1 1 [Zheng et al. 2025 and VERL. (Sheng et al. 2024]. We leverage vLJLM [Kwon et al. 2023] for sampling during rollout generation, as enables highly optimized decoding with high throughput and low latency. This is particularly important for SVG generation, which involves long context sequences.
Training Details For GRPO, we use a clipping parameter e 0.4, During RLRF training, we adopt the AdamW optimizer with bf 16 precision. The optimization settings include maximum gradient norm of 1.0, a weight decay of 10-2, and no learning rate warmup (lr__larre __t_aaa____aaaee caammmprriii-i.. 0.0). We enable full parameter sharding via Fully Sharded Data Parallel (FSDP) full model sharding. We keep the vision tower frozen during SVG-SFT and RLRF
Prompt 1: Used for VLM aa a Judge Score (Accurate)
</im_start >>use<< (epuse<</vssiie wiiiion_ssinn ctttoossstttttt | impartial evaluator of SVG/icon renderings.
iisvio_ieedili end|> You are
RUBRIC
Al Alignment Score (0-5) "Does the image depict what the text describes?"
Completely unrelated: no shared objects, themes, or context.
Very weak match: one minor element overlaps, but overall scene/concept different.
Weak match: few elements overlap, yet key objects or main action differ.
3 Partial match: primary abjects/actions align, but notable details context differ.
Strong match: image reflects the description with only small, non-critical discrepancies.
5 Perfect match: image fully and accurately depicts every essential detail of the description.
Aesthetica Score (0-5) "Overall visual quality: clarity of meaning firet-impression appeal."
Unusable: broken or illegible; no clear subject; chaotic or noisy.
Very poor: subject partly recognizable but ugly-obvious errors, off pr-pppoootionn shapes, harsh clashing colors.
Poor: conveys the subject but feels rough; unbalanced layout, dull/flat styling, sparse detail.
3 Fair: subject clear at first glance; proportions mostly correct;
acceptable composition and palette with minor flaws.
Good: rich detail, harmonious colors, balanced negative space; polished with only subtle imperfections.
Excellent: instantly communicates its subject; perfect proportions and composition; refined details, beautiful color Axmony-production TASK
Rate the image **both** scales above. Return **only** this JSON
object-nothing else:
"'json { "aligament_score"" <integer 0-5>, "alignment_reast reason":
"<-100-word justification>" besthetics_score". <integer 0-5>, hesthetics_reason "s=100-word justification"" Description:
iin_end/<<imm__a Dassistant
C RLRF Method
C.1
Multimodal Architecture
To perform SVG generation using the autoregressive approach (see Figure I6), we adopt vision- language model ( (VLM) [Alayrac et al. 2022 Liu et al. 2023) composed of a decoder-only language model [Brown et al. 2020) that generates SVG code tokens one a time, and an image encoder that processes visual inputs. In tasks that do not require an image, the image encoder can be omitted, and the model reduces a text-only L.M.. For Im2SVG, the model receives an image as input and generates SVG code output, treating the code plain text sequence in standard SVG format. In
27

---

Autoregressive SVG Generation
Image
SVG
SVG
Rendered
VLM
Code
Image
Text
Supervised Fine-Tuning (SVG-SFT)
Reinforcement Learning (RLRF)
Foundational SVG Code Learning
Rendering-Driven SVG
Refinement
Predicted
Rendered
SVG
Image
VLM
VLM
SVG
Image
SVG
Image
Pixal Reconstruct on Semantic Similartty
Texts
Images
SVGs
Texts
Images
Code Efficiency
Figure 16: Overview of Autoregressive SVG Generation and RLRF, (Top) Autorregresive SVG generation pipeline. An image or a prompt is given to a VLM to produce SVG code, which is then rendered into image. (Bottom-left) SVG Supervised Fine-Tuning. The VLM is trained with teacher forcing to generate the SVG code from the training data. (Bottom-right) Reinforcement Learning for Vector Graphics. Given the same input (image or text), the model generates several SVG roll-outs, which are then rendered, and a reward is calculated to update the model.
contrast, Tex22SVG is purely textual task, where a strong language model alone may be sufficient to generate valid SVGs from text prompts.
Vision-Language Model Design VLMs combine an image encoder with decoder-only language
model process and generate multimodal content. The image encoder, often Vision Transformer
(ViT) Dosovitskiy et al. 2020] or a convolutional network (Krizhevsky et al. 2012). converts the input image into a sequence of nigh-dimensional vectors called visual tokens. These are not discrete tokens like in language, but continuous embeddings representing image regions.
To make these embeddings compatible with the language model, they are passed through linear projection layers (Liu et al.] [2023]. This allows the language model to attend to the visual context during generation. Since large images produce many visual tokens, some models add modules to reduce their number and retain only the most relevant ones. For example, Q-Former (Li et al. 2023a uses learnable queries to extract smaller of tokens, while Perceiver Resampler [Alayrac et al. 2022] and VLM [Masry et al. 2025 use resampling and sparse attention to compress the visual information efficiently.
Once the visual tokens are projected, they are combined with any textual prompt and fed into a decoder-only language model. This model generates output tokens one at time, using both the image and text context. In our case, the output is SVG code. The model learns to translate visual inputs into structured sequences of SVG instructions that be rendered to reconstruct the original image. This setup allows the model to reason about both the appearance and structure of visual content and generate precise vector representations.
Model Choice: Qwen2.5-VL We perform our experiments using the Qwen2.5-VL [ai et al. 2025) family of models, which are general purross VLMs designed for diverse multimodal tasks. Qwen2.5-VE VL uses eynaaicc-reslluie
vision transformer (ViT) as the image encoder and high- capacity language model decoder based on the Qwen2.5 series. This combination allows it to scale to long contexts, adapt to varied image resolutions, and perform complex vision-language reasoning. The vision tokens extracted by the ViT are prepended the text tokens and jointly processed in the decoder.
28

---

Comparison to Star Compared to StarVector [Rodriguez et al. 2025b], which is specifically designed for SVG generation, Qwen2.5-VI. a more generalist model not specialized for code or vector formats. StarVector employs a CLIP-basee image encoder and code-generation cnteeratioooopmmizeedd decoder (e.g., StarCoder) with an adapter to bridge modalities. It is trained directly on SVG-Stack, large dataset of real-world SVGs, making it more attuned to the syntax, structure, and compositional semantics of SVG code. In contrast, Qwen2.5-VV benefits from broader multimodal training but lacks S SVG-specific pretraining, which we address through supervised fine-tuning and reinforcement learning.
Design Tradeoff's The generalist nature of Qwen2.5-VV VL enables strong transfer learning capabilities and flexibility across tasks but makes it initially less precise at SVG generation. Our method, RLRF, fine-tunes Qwen2.5-VI to align its output with visual fidelity and code compactness through supervised fine-tuning (SVG-SFT) reinforcement learning (RLRF). This specialization helps close the gap with fask-specific models like Star Vector while maintaining broader instruction- following abilities inherent to Qwen2.5-VL.
Context Length Context length plays a crucial role in autoregressive SVG generation. Complex SVGs with fine-grained structure and intricate visual elements often require sequences that span tens or even hundreds of thousands tokens. The Qwen2.5-V1 VL model supports a context length of up to 128k tokens, which allows it to handle long and highly detailed SVG code sequences.
With the growing availability of models that support very long contexts, including recent work pushing towards hundreds of thousands or even millions of tokens (Liu et al. 2025 Meta 2025), we expect context length to become less of limitation the near future. In principle, this trend makes large-scale vector representation increasingly feasible.
In our experiments, we cap the context length at 32k tokens to fit within GPU memory constraints. This is sufficient for all benchmark samples we evaluate, including wide range of complex SVGs. In comparison, the Star Vector model was limited to token context, which restricts its ability to model large or deeply nested SVG structures.
C.2 Reward Details
Tex12VVG Rewards. We incorporate image-text alignment signals to better guide the model toward generating SVGs that are consistent with the input text. However, CLIP-based rewards (including CLIP Score and CLIP Aesthetics) were not effective in this setting. These models provide weak supervision because the generated SVGs fall far outside the distribution of natural images on which CLIP was trained. As shown in Figure 8 the SVG outputs tend to follow an abstract visual style composed of primitives such as rectangles, spirals, and curves, which makes them poorly suited for CLIP-based evaluation.
To address this, propose using VLM judge reward. This approach relies strong vision-language model (VLM) to evaluate the quality of the generated SVGs. Specifically, we prompt Qwen2.5VL-7B, smaller variant selected for its memory efficiency during rollout scoring, assess whether the generated SVG accurately reflects the input prompt. This VLM-based reward aligns more closely with human preferences and provides significantly stronger training signal compared to CLIP. The reward prompts are described in Prompts and 3, and include axes for evaluating semantic accuracy, visual resemblance, and aesthetic quality.
During RLRF rollouts with Qwen3-8B, the model is trained to produce <think traces before answering. We take advantage of this behavior by prompting the model to first plan the SVG content, and then generate the code. The resulting SVGs include inline comments for better structure and readability. Examples of this reasoning process are shown in Figure 9
Prompt 2: Used for VLM as a Judge Reward for TeXt22VG (Easy)
wlim_start >user< hwwlvvvvssiiirrereeeeee /tttaastttttt((tat// /iiiioinnn end >>oes the drawing resemble the description: [Yes/No] <l indennd |>|| iimmstatrttr Dassistant
29

---

Prompt 3: Used VLM as Judge Reward for Text22VG (Hard)
<lim_start >users ( /isieon_ staoontsstttttiioo |><| htae://maeeee///iiiii....ia >>Doooess I>Dess the image match the description clearly, accurately, and aesthetically pleasing: " [Yes/No] < im__idd end /kl/immsaattt Secaart>aae Pasaisttsssstnn
C.3 Implementation Strategies for Stable and Robust RLRF Training
We describe practical strategies that enabled stable and efficient training of our RLRF method.
Dynamic Max Length. After the SVG-SFT stage, models often lack strong SVG code completion skills and struggle with ouf-of-distributiin complex samples. This occasionally leads to failure cases where the model enters indefinite loops, repeating SVG commands until the maximum token limit is reached. These long and unproductive rollouts slow down RL training, each rollout must be fully sampled and passed through multiple models.
To mitigate this, we implement dynamic maximum length schedule. For each batch, estimate the required output length using the ground truth SVGs and set the maximum length to the longest sample plus small threshold t. This strategy significantly reduces rollout overhead early in training, encourages the model to generate shorter and cleaner sequences, and naturally fades in importance as training progresses and generation improves.
During inference, input images are resized using bilinear interpolation such that the shortest side 512 pixels, preserving the original aspect ratio. We sample with temperature and top-p equal to 0.5 and 0.9 respectively, using the best-of-n strategy: we generate five candidates (n 5) and select the one with the lowest mean-squared error (MSE) relative to the target image.
C.4 Limitations
As with prior work, method is constrained by the context length of current models. While this remains a challenge, we note that recent models with extended context windows are beginning to address it. A more specific limitation of our RLRF experiments is the tendency for the model to become increasingly specialized in SVG generation, which may diminish its general instruction- following capabilities. Although straightforward solutions exist, leave their exploration future work.
Another key limitation is the inefficiency of GRPO training, which is bottlenecked by rollout generation. This process introduces significant GPU idle time during the RL stage Mitigating this overhead is important direction for future optimization.
D Extended Related Work
D.1 SVG Generation
SVG generation methods are typically categorized into three main approaches: classical image processing, latent variable models, and large language model (LLM)-based techniques. Traditional methods such as VTracer [Vision Cortex [023), Potrace [Selinger, Peter 2024). and Autotrace (We- ber, Martin 2024 convert raster images into vector graphics by tracing contours and clustering regions. While effective for extracting shapes, these approaches produce long and unstructured SVGs composed of raw path commands. The resulting code is verbose, difficult to edit, and lacks higher-level semantic organization.
Deep learning has also been applied to this domain, particularly through differentiable rendering techniques that overcome the inherent non-differentiabiiiyy of SVG rendering. DifIVG (Li et al. 2020
introduced a differentiable rasterizer, enabling the development of latent variable models Carlierr
al. 2020, Cao al. 2023 Wang and Lian 2021 Ma et al., 2022 that learn deep representations
of SVG commands and the parameters of geometric primitives. These models use architectures based
30

---

on variational autoencoders KKinmma and Welling 2013]. diffusion processes [Ho et al. 2020], or autoregressive decoders [Cao et 2023].
Compared to traditional methods, latent variable models offer more structured control and support tasks like interpolation and style transfer. However, they often rely on simplified subsets of the SVG syntax, producing outputs that are less compact and less interpretable. Additionally, these models are typically trained on narrow, domain-specific datasets, limiting their generalization diverse SVG types, an area where classical image processing methods remain more broadly applicable.
More recent approaches frame SVG generation code generation task using large language models (LLMs). We refer to this as the Autoregressive SVG Generation approach. By tokenizing SVG code and generating it directly, LLM-based models bypass intermediate representations and learn model the full SVG syntax end-to-end.
Starvector [Rodriguez et al., 2025b was among the first to explore this direction, combining code-centric LLM (StarCoder [Li et al. 2023b]) with CLIIP-based image encoder [Radford et al. 2021]. It achieved strong performance on large-scale image-to-Si SVG benchmarks. Follow-up works such as Beyond Pixels (Zhang et al.
2023], J. SVGEditBench [Nishina and Matsui 2024 2025), and related studies (Cai et 2023 explored editing, reasoning, and structured SVG generation. More recently, OmniSVG Yang et al. 2025b extended this line work by leveraging the Qwen2.5- VL
foundation (Bai et al. 2025].
Despite their progress, these models face key limitation: they do not observe or evaluate the visual output of the SVG code they generate. As a result, they often produce SVGs that are syntactically correct but visually inaccurate or inefficient. Moreover, unlike latent models that can rely on differentiable rasterization, autoregressive VLM approaches operate over discrete token spaces, making both rendering and sampling non-differentiable.
Our method, RLRF, addresses this gap by introducing a reinforcement learningbbased post-training strategy that incorporates visual feedback. By closing the loop between code generation and rendered output, we overcome the limitations of purely supervised fine-tuning. This reinforcement learning approach enables optimization of -indifferrnntable rendering quality using automatic reward signals. As a result, models trained with RLRF generalize more effectively across SVG generation tasks compared to standard supervised fine-tuning.
D.2 Vision-Language Models (VLMs)
Early VLMs such as Flamingo Allayrac al. 2022 BLIP-2 [Li al. 2023a LLaVA (Liu et al. 2023], and GPT-4V [OpenAl] 2023] introduced a powerful paradigm by adapting frozen vision encoders and connecting them pretrained unimodal LLMs. This is typically done through learned projection layers that map visual features into token-like embeddings. These models follow an autoregressive generation strategy [Vaswani et al., 2017), enabling them to process both images and text within a unified token stream and perform instruction-followin and multi-turn conversations grounded in visual inputs.
In parallel, the use of LLMs for code generation has grown rapidly recently. Code can be seen as a separate modality, with structure and syntax that differ significantly from natural language. Progress in this area has been driven by the availability of large-scale code corpora [Kocetkov et al. 2022
Penedo et al. 2024 and the development of specialized coding models such Codex [Chen et al.
2021]. CodeGen [Nijkamp et al. 2022). and StarCoder [Li al. 2023b
Recent frontier models like GPT-4o Hurst et al. 2024 Gemini [Georgiev et al. 2024 Claude An thropic 2024), and Qwen2.5-VL [Bii et al.J 2025] have expanded these capabilities further by incorporating larger and more diverse code datasets during pretraining, substantially improving performance on structured code tasks.
This convergence of multimodal models Liu et al. 2023 and their use on structured output gen- eration [Masry et al.] [025] Zhang et al. 2025| Feizi al., [025] Nayak et al.] [025) and code generation [L et al. [223bb] enables a new class of problems: inverse rendering code generation, also known as visual-code generation). In these tasks, the model generates code that compiles or renders into visual content. Examples include SVG, TikZ, HTML,, and CAD, which are used for generating graphies, diagrams, and illustrations. Prior efforts this area include diagram and layout generation [Rodriguez et al. 2023b Belouadi et al. 2023 2024 Rodriguez et al. 2025a
31

---

Belouadi et al. 2025 Nayak et al. 2025 Awal et al. synthesis Wang al., 2025].
2025 Bechard et al. 2025 and text-to-CAM CAD
Although current models can learn valid code distributions and produce visually plausible outputs, they often suffer from hallucinations, limited long-range coherence, and poor generalization. A key limitation is the lack of feedback from the rendered environment. These models are never shown how their outputs look. Our work addresses this gap by enabling models learn from their own rendered predictions, providing a visual feedback signal that improves both precision and generalization in code-driven visual tasks.
D.3 Reinforcement Learning Post-Training
Reinforcement Learning (RL) has become essential for post-training fine-tuning of large language models (LLMss). Reinforcement Learning from Human Feedback (RLHF), using Proximal Policy Optimization (PPO) [Schulman et al. [017]. J. has become the standard for aligning LLM outputs with human preferences, improving tasks like summarization and instruction-following (Ziegler al.)
2019 Stiennon et al. 2020 Ouyang et al., [022]. An alternative approach, Group Relative Policy Optimization (GRPO) [Sho al.] 2024 Guo et 2025]. , stabilizes training by normalizing rewards across batches, removing the need for separate value network and reducing variance, In the visual generation space, GRPO has been successfully used for image editing [Ahmadi et al.) 2025). In code generation, frameworks like CodeRL (Le et al.) 2022 employ an actor-critic approach where the critic predicts functional correctness to guide the actor [Le al. 2002]. PPOCoder (Shojaee et al.) 2023a integrates PPO with execution feedback, using compiler results rewards to fine-tune code generation models [Shojaee et al.) 2023b). StepCoder [Dou al., [024a] introduces curriculum of code completion subtasks, optimizing exploration by masking unexecuted code segments [Dou cet al. 2024b). Additionally, Reinforcement Learning from Execution Feedback (RLEF) enables models to refine code iteratively based on execution outcomes, enhancing performance on complex tasks [Gehring et al. 2024). In multimodal domains, approaches like ViCT use a visual critic to align generated UI code with input screenshots, improving fidelity in Ul-to-code generation (Soselia et al., 2023). RL has also been applied architectural design, where agents learn to generate space layouts by optimizing spatial and functional constraints [Kakooce and Dillenburger 2024). Together, these methods demonstrate the power of RL in enhancing alignment, correctness, and efficiency across generative models.
While existing RL-based post-training methods focus primarily on functional correctness, they overlook visual quality. In contrast, RLRF introduces rendering feedback through composite reward that jointly optimizes visual fidelity, semantic alignment, and code efficiency.
32

---

NeurIPS Paper Checklist
Claims
Question: Do the main claims made in the abstract and introduction accurately reflect the paper's contributions and scope?
Answer: [Yes]
Justification:
Guidelines:
The answer NA means that the abstract and introduction do not include the claims made in the paper.
The abstract and/or introduction should clearly state the claims made, including the contributions made in the paper and important assumptions and limitations. A No or
NA answer to this question will not perceived well by the reviewers.
The claims made should match theoretical and experimental results, and reflect how much the results be expected to generalize other settings.
is fine include aspirational goals as motivation as long is clear that these goals are not attained by the paper.
2. Limitations
Question: Does the paper discuss the limitations of the work performed by the authors?
Answer: [Yes]
Justification:
We discuss the limitations in the supplementary material.
Guidelines:
The answer NA means that the paper has no limitation while the answer No means that the paper has limitations, but those are not discussed in the paper.
The authors are encouraged to create separate "Limitations" section in their paper.
The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (e.g., independence assumptions, noiseless settings, model well-specification. asymptotic approximations only holding locally). The authors should reflect how these assumptions might be violated in practice and what the implications would be.
The authors should reflect on the scope of the claims made, e.g., if the approach was only tested on few datasets or with few runs. In general, empirical results often depend on implicit assumptions, which should be articulated.
The authors should reflect the factors that influence the performance of the approach. For example, facial recognition algorithm may perform poorly when image resolution low images are taken in low lighting. Or speech-to-text system might be used reliably to provide closed captions for online lectures because it fails to handle technical jargon.
The authors should discuss the computational efficiency of the proposed algorithms and how they scale with dataset size.
If applicable, the authors should discuss possible limitations of their approach address problems of privacy and faimess.
While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, a worse outcome might be that reviewers discover limitations that aren't 't acknowledged in the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play an impor- tant role in developing norms that preserve the integrity of the community. Reviewers will be specifically instructed to not penalize honesty concerning limitations.
3. Theory assumptions and proofs
Question: For each theoretical result, does the paper provide the full set of assumptions and complete (and correct) proof?
Answer: [NA]
33

---

Justification: Our work is entirely empirical in nature and does not involve any theoretical assumptions, theorems, or formal proofs.
Guidelines:
The answer NA means that the paper does not include theoretical results.
All the theorems, formulas, and proofs in the paper should be numbered and cross- referenced.
All assumptions should be clearly stated or referenced in the statement of any theorems.
The proof's can either appear in the main paper or the supplemental material, but if they appear in the supplemental material, the authors are encouraged to provide a short proof sketch provide intuition.
Inversely, any informal proof provided in the core of the paper should be complemented by formal proofs provided in appendix or supplemental material.
Theorems and Lemmas that the proof relies upon should properly referenced.
4. Experimental result reproducibility
Does the paper fully disclose all the information needed to reproduce the main ex- perimental results of the paper to the extent that affects the main claims and/or conclusions of the paper (regardless of whether the code and data are provided or not)?
Question:
Answer: [Yes]
Justification:
Guidelines:
The answer NA means that the paper does include experiments. If the paper includes experiments, No answer to this question will not be perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not.
If the contribution is dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable.
Depending on the contribution, reproducibility can be accomplished in various ways. For example, if the contribution is novel architecture, describing the architecture fully might suffice, or if the contribution is a specific model and empirical evaluation, it may be necessary to either make possible for others to replicate the model with the same dataset, or provide access to the model. In general. releasing code and data is often one good way accomplish this, but reproducibility can also be provided via detailed instructions for how to replicate the results, access to a hosted model (e.g.. in the case of large language model), releasing of a model checkpoint, or other means that are appropriate to the research performed.
While NeurIPS does not require releasing code, the conference does require all submis- sions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. For example
(a) If the contribution is primarily a new algorithm, the paper should make it clear how reproduce that algorithm. (b) If the contribution is primarily
model architecture, the paper should describe the architecture clearly and fully.
(c) If the contribution is a new model (e.g., a large language model), then there should either be way to access this model for reproducing the results or way to reproduce the model (e.g., with an open-source dataset instructions for how to construct the dataset).
(d) We recognize that reproducibility may be tricky in some cases, in which case authors are welcome deseribe the particular way they provide for reproducibility, In the case of closed-source models, it may be that access to the model is limited in some way (e.g., registered users), but it should be possible for other researchers to have some path to reproducing or verifying the results.
5. Open access to data and code
Question: Does the paper provide open access to the data and code, with sufficient instruc- tions to faithfully reproduce the main experimental results, as described in supplemental material?
34

---

Answer: [No]
Justification: We are not submitting the data, code, or model weights part of this sub- mission. However, we are actively working towards open sourcing all relevant materials, including the dataset, codebase, and pretrained model weights. We plan to release these resources publicly at the time of the camera-ready version to support full reproducibility of our main experimental results.
Guidelines:
The answer NA means that paper does not include experiments requiring code.
Please see the NeurIPS code and data submission guidelines (https://nips. cc/
Soniides/CoeSSumisssiiee
for more details.
While we encourage the release of code and data, we understand that this might not be possible, so "No" an acceptable answer. Papers cannot be rejected simply for not including code, unless this is central to the contribution (e.g., for new open-source benchmark).
The instructions should contain the exact command and environment needed to run to reproduce the results. See the NeurIPS code and data submission guidelines (https for more details.
//nips http:///ppbbliccuiieeeee/eoeeoee
The authors should provide instructions data access and preparation, including how to access the raw data, preprocessed data, intermediate data, and generated data, etc.
The authors should provide scripts to reproduce all experimental results for the new proposed method and baselines. only subset of experiments are reproducible, they should state which ones are omitted from the script and why.
At submission time, to preserve anonymity, the authors should release anonymized versions (if applicable).
Providing as much information as possible in supplemental material (appended to the paper) recommended, but including URLs to data and code permitted.
6. Experimental setting/details
Question: Does the paper specify all the training and test details (e.g., data splits, hyper- parameters, how they were chosen, type of optimizer, etc.) necessary to understand the results?
Answer: [Yes]
Justification:
Guidelines:
The answer NA means that the paper does include experiments.
The experimental setting should be presented in the core of the paper to a level of detail that is necessary appreciate the results and make sense of them.
The full details can be provided either with the code, appendix, as supplemental material.
7. Experiment statistical significance
Question: Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments?
Answer:
[No]
Justification:
We report single-run results due to prohibitive compute.
Guidelines:
The answer NA means that the paper does not include experiments.
The authors should answer "Yes" if the results are accompanied by error bars, confi- dence intervals, statistical significance tests, least for the experiments that support the main claims of the paper.
The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, or overall with given experimental conditions).
35

---

The method for calculating the error bars should be explained (closed form formula, call to a library function, bootstrap, etc.)
The assumptions made should be given (e.g.. Normally distributed errors).
should be clear whether the error bar is the standard deviation or the standard error of the mean.
It is OK to report 1-sigma error bars, but one should state it. The authors should preferably report a 2-sigma error bar than state that they have 96% CI, if the hypothesis of Normality of errors is not verified.
For asymmetric distributions, the authors should be careful not to show in tables figures symmetric error bars that would yield results that are out range (c.g. negative emror rates).
If error bars reported in tables plots, The authors should explain in the text how they were calculated and reference the corresponding figures or tables the text.
8. Experiments compute resources
For each experiment, does the paper provide sufficient information on the com- puter resources (type of compute workers, memory, time of execution) needed reproduce the experiments?
Question:
Answer: [Yes]
Justification:
Guidelines:
The answer NA means that the paper does not include experiments.
The paper should indicate the type of compute workers CPU or GPU, internal cluster, cloud provider, including relevant memory and storage.
The paper should provide the amount of compute required for each of the individual experimental runs as well as estimate the total compute.
The paper should disclose whether the full research project required more compute than the experiments reported in the paper (e.g., preliminary or failed experiments that didn't 't make it into the paper).
9. Code ethics
Question: Does the research conducted in the paper conform, in every respect, with the NeurIPS Code of Ethics htttpp/s/mouris....pppptt/t/t/ie
Answer: [Yes]
Justification:
Guidelines:
The answer NA means that the authors have reviewed the NeurIPS Code of Ethics.
If the authors answer No, they should explain the special cireumstances that require deviation from the Code of Ethics.
The authors should make sure to preserve anonymity (e.g., if there is special consid- eration due to laws or regulations in their jurisdiction).
10. Broader impacts
Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?
Answer: [Yes]
Justification:
Guidelines:
The answer NA means that there is no societal impact of the work performed.
If the authors answer NA or No, they should explain why their work has no societal impact or why the paper does not address societal impact.
Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations.
36

---

The conference expects that many papers will be foundational research and not tied particular applications, let alone deployments. However, if there is direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that an improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that a generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster.
The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology being used intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology.
If there negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition to attacks, mechanisms for monitoring misuse, mechanisms monitor how system learns from feedback over time, improving the efficiency and accessibility MI..
11. Safeguards
Does the paper describe safeguards that have been put in place for responsible release of data models that have high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)?
Question:
Answer: [NA]
Justification:
Guidelines:
The answer NA means that the paper poses such risks.
Released models that have high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere usage guidelines or restrictions to access the model or implementing safety filters.
Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images.
We recognize that providing effective safeguards is challenging, and many papers do not require this, but we encourage authors to take this into account and make best faith effort.
12. Lieenses for existing assets
Question: Are the creators or original owners of assets (e.g., code, data, models), used in the paper. properly credited and are the license and terms of use explicitly mentioned and properly respected?
Answer: [Yes]
Justification:
Guidelines:
The answer NA means that the paper does existing assets.
The authors should cite the original paper that produced the code package or dataset.
The authors should state which version of the asset is used and, if possible, include URL.
The name of the license (c.g., CC-BY 4.0) should be included for each asset.
For scraped data from a particular source (c.g., website), the copyright and terms of service of that source should be provided.
If assets are released, the license, copyright information, and terms of use in the package should be provided. For popular datasets, paperswi thcode. com com/datasets has curated licenses for some datasets. Their licensing guide can help determine the license of dataset.
For existing datasets that are re-packaged, both the original license and the license of the derived asset (if it has changed) should be provided.
37

---

If this information is not available online, the authors are encouraged to reach out to the asset's creators.
13. New assets
Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets?
Answer: [Yes]
Justification:
Guidelines:
The answer NA means that the paper does not release new assets.
Researchers should communicate the details of the dataset/code/mmoel as part of their submissions via structured templates. This includes details about training, license, limitations, etc.
The paper should discuss whether and how consent obtained from people whose asset is used.
At submission time, remember to anonymize your assets (if applicable). You can either create an anonymized URL or include an anonymized zip file.
14. Crowdsoureing and research with human subjects
Question: For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given to participants and screenshots, if applicable, as well details about compensation (if any)?
Answer: [NA]
Justification:
Guidelines:
The answer NA means that the paper does not involve crowdsoureing nor research with human subjects.
Including this information in the supplemental material is fine, but if the main contribu- tion of the paper involves human subjects, then as much detail as possible should be included the main paper.
According the NeurIPS Code of Ethics, workers involved in data collection, curation, or other labor should be paid at least the minimum wage in the country of the data collector.
15. Institutional review board (IRB) approvals or equivalent for research with human subjects
Question:
Does the paper describe potential risks incurred by study participants, whether such risks were disclosed to the subjects, and whether Institutional Review Board (IRB) approvals (or an equivalent approval/review based on the requirements of your country or institution) were obtained?
Answer: [NA]
Justification:
Guidelines:
The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.
Depending the country in which research is conducted, IRB approval (or equivalent) may be required for any human subjects research. If you obtained IRB approval, you should clearly state this in the paper.
We recognize that the procedures for this may vary significantly between institutions and locations, and expect authors to adhere to the NeurlPS Code of Ethics and the guidelines for their institution.
For initial submissions, do not include any information that would break anonymity (if applicable), such the institution conducting the review.
16. Declaration of LLM usage
38

---

Does the paper describe the usage of LLMs if it is important, original, or non-standard component of the core methods this research? Note that if the LLM used only for writing, editing, or formatting purposes and does not impact the core methodology, scientific rigorousness, or originality of the research, declaration is not required.
Question:
Answer: [NA]
Justification:
Guidelines:
The answer NA means that the core method development in this research does not involve LLMs any important, original, non-standard components.
Please refer to our LLM policy for what should or should not be described.
39


Reviews:
[{"review_id": "856iLHHM7H", "reviewer": "Reviewer_Lhdn", "summary": "This article introduced a reinforcement learning based approach for SVG generation with autoregressive vision-language models. Also, the authors provide a set of rewards for Vector Graphics Rendering in pixel-level, semantic and simplicity to solve the non-differentiable rendering problem.", "questions": "Should these two tasks(Im2SVG and Text2SVG) be done in same model? Is it possible to finetune these two model separately for industrial purposes? For the Im2SVG model, more comparison such as Im2VEC need to be done, not limited in VLM models.", "limitations": "Results on binary images vectorization? Can this method keep topological and back-front logical correct?", "rating": 5, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 4, "clarity": 4, "significance": 3, "originality": 3, "strengths_and_weaknesses": "Strength: Use SVG-SFT and RL to solve the problem. Adequate experiments, especially in the ablation studies are persuasive. \n\nWeakness: I wondering simply use L2 reward is a good idea in Eq.(5). In image generation, L2 Loss function may lead to blur or tropology-misleading results, maybe L1 or other reward functions should also be tried. Also, the canny edge detector based L2 variant should be further discussed.", "was_revised": true, "final_justification": "Experiments in rebuttal partly solved most of my questions. Q4 is partly solved while others(Q1, Q2 and Q3) completely solved. Experiment 1 proved that Canny-L2 does work well. Experiment 3 added other models comparison. I've updated my score in final decision.", "rebuttal": "Thank you for the constructive review and for highlighting the strengths of our approach, such as the clear motivation for combining SVG‑SFT and RL to address non‑differentiable rendering and the thorough ablation studies. Your feedback has greatly improved the quality of our paper.\n\nBelow, we address every point you raised and indicate the concrete additions we have made in the revised manuscript, which will be visible in the camera-ready version.\n\n-------\n\n## **Q1  “Simply using L2 may blur shapes; try other pixel rewards like L1.”**\n\n**We don’t simply use L2**. As shown in the “Final Reward Aggregation” Section 3.2 (line 186), we use a *combination of rewards*. **We realized that the exact weights were not specified clearly in the main paper, and we have now included them**. The best performing combination includes **L2, Canny-L2, and LPIPS, with a small code length deviation term**. As explained in Section 5.2, a *higher L2 weight leads to better vectorization accuracy*, while a *higher LPIPS weight pushes more toward style preservation*. \n\nWe’ve updated the main text for the camera-ready version to make these trade-offs and choices more explicit.\n\n**Experiment**: Following your suggestion, **we also experimented with additional rewards to further analyze their impact**. We conducted a new ablation comparing L1, L2, Canny-L2, and SSIM as pixel-level losses.\n\n**Setup**: We experiment on a 7B Queen 2.5VL model that has completed 5 epochs of SVG-SFT. We train with RLVG with our most optimized RL (GRPO) setup for 240 steps, with 32 samples per step and 32 rollouts (7k train samples in total), using 16 H100 GPUs over 48 hours.\n\n| Method   | Code Eff. | DinoScore | L2     | LPIPS  | SSIM   |\n|----------|-----------|-----------|--------|--------|--------|\n| L2 Canny | -334      | 98.70     | 1.03   | 3.08   | 95.08  |\n| L2       | -159      | 98.82     | 1.10   | 3.17   | 94.76  |\n| SSIM     | -210      | 98.64     | 1.30   | 3.34   | 94.76  |\n| L1       | -254      | 98.69     | 1.57   | 4.06   | 93.62  |\n\n\nWe have added this table and a qualitative figure to compare visually, and both will be available during camera-ready. We note the following findings.\n\n**Main findings:**\n\n- **Finding 1**:  **L2 Canny is the best performant**. As seen in the table above, L2 Canny gives the best performance, though L2 is pretty similar. **L1 gives the world results falling by 0.004 points over the best**. In qualitative terms, we see the *L2 Canny helps get the main shapes and edges well placed, though it fails at very small patterns and details*, *L2 is better here at smaller details*. As we show in the paper, **a combination of rewards is the best approach**. \n\nWe find it interesting to point out that optimizing for SSIM does not make it reach the best SSIM at test, so no reward hacking happens. L2 Canny is the best performance on SSIM as well.\n\n- **Finding 2**: **No blurring**. When using L2 alone, *we do not observe the typical blurring artifacts often seen in raster image generation*. This is likely because SVGs are rendered from discrete and **sharp primitives, and the output space is inherently crisp and well-structured**. However, we do observe that L2 alone can lead to artifacts such as over-closed paths or small geometric misalignments, especially in cases involving thin strokes or disconnected segments. As shown before, L2 Canny provides a better signal for getting sharp shapes and good edges\n\n----------------------\n\n## **Q1.1: The Canny edge detector-based L2 variant should be further discussed.**  \n\nThank you for pointing this out. We now provide a clearer explanation of the **Canny-L2** reward, which was not sufficiently detailed in the original submission.\n\nThis rewards applies a **Canny edge detector** to both the input and predicted images, followed by optional **dilation** and **Gaussian blur**, before computing the L2 loss. We use the `cv2.Canny` implementation from OpenCV, followed by `cv2.dilate` with a configurable kernel and number of iterations.\n\nSpecifically:\n\n- We use `dilate=True` to expand detected edges and improve alignment tolerance.\n- The dilation uses a square kernel of size `dilate_kernel_size=3`, applied for `dilate_iterations=1`.\n- After preprocessing, both edge maps are normalized (zero mean, unit variance), and we compute the clipped L2 loss.\n\nThis formulation encourages the model to match structural boundaries more precisely, especially in settings with thin strokes, closed shapes, or topology-sensitive inputs.\n\n**Results**: As shown in the ablation table above, **Canny-L2 outperforms standard L2 by 0.001 in MSE and 0.01 in SSIM**, confirming its benefit for structural alignment.\n\n----------\n\n## **Q2: Should Im2SVG and Text2SVG live in the same model?**\n\n**Yes, a single model can be trained jointly on both Image2SVG and Text2SVG** tasks by constructing appropriate conversation templates and leveraging datasets that include textual annotations.\n\n**Experiment**: We tested this with the Qwen2.5VL‑3B model using the SVG‑Stack dataset, which contains both image and text prompts. Training was run on 32 × H100 GPUs for 24 hours, a single model can be trained jointly on both Image2SVG and Text2SVG tasks by constructing appropriate conversation templates and leveraging datasets that include textual annotations. The model successfully learned to handle both modalities. \n\nFor comparison: \n- A model trained only on Image2SVG achieves **MSE = 0.04**. \n- A model trained on both tasks jointly reaches **MSE = 0.07**.\n\nWe note that the joint model underperforms slightly in Image2SVG compared to a task-specific one, likely due to increased task complexity and insufficient training time. We are currently running a longer training run that matches the number of image samples used in the standalone Image2SVG training, and we will report those results in the camera-ready version. This could yield a stronger foundation model capable of handling both tasks effectively. That said, we still foresee value in deploying dedicated fine-tuned models for Image2SVG when the goal is high-precision vectorization, as specialization may offer better performance.\n\n---------------------\n\n## **Q3: For the Im2SVG model, more comparisons such as Im2VEC should be included, not limited to VLM models.**\n\nWe did not limit our comparisons to VLM-based models. As detailed in Section 4.2, we already included:\n\n- **Three classic image processing methods**: VTracer, PoTracer, and PyAutoTrace\n\n- **Two parametric deep learning approaches**: DiffVG and LIVE\n\nThese baselines represent the strongest alternatives to autoregressive VLMs across image processing, differentiable rendering, and deep learning methods.\n\n**Regarding Im2VEC**, we had previously tested it and found it to be highly overfitted to small-scale emoji datasets. In practice, we found it **infeasible to retrain effectively** on the large and diverse SVG-Stack dataset due to poor generalization. Nonetheless, **we’ve now included its performance, as well as an additional recent baseline SuperSVG**, which was suggested by Reviewer STcx. \n\nWe summarize the results in the table below:\n\n| Model           | MSE ↓ | SSIM ↑ | LPIPS ↓ | DINO ↓ | Code Eff. |\n|-----------------|-------|--------|---------|--------|----------------|\n| PoTracer        | 8.15  | 77.28  | 89.23   | 19.10  | -7.3k          |\n| DiffVG          | 6.64  | 81.23  | 86.12   | 20.5   | -19.7k         |\n| PyAutoTrace     | 4.71  | 87.44  | 95.68   | 10.71  | -99.7k         |\n| VTracer         | 4.25  | 87.94  | 95.75   | 11.66  | -12.9k         |\n| LIVE            | 2.22  | 88.11  | 93.45   | 7.23   | -18.3k         |\n| **SuperSVG**    | 3.05  | 83.3   | 13.5    | 82.7   | -65.6k         |\n| **StarVector**  | 3.46  | 88.0   | 98.0    | 7.51   | -127           |\n| **Im2VEC**      | **18.1**  | **76.5**   | **29.1**    | **69.2**   | **-4.3k**          |\n| **RLVG (ours)** | **1.03**  | **95.1**   | **3.08**    | **98.7**   | **-334**           |\n\nWe have included the most up-to-date results for RLVG performed in this rebuttal. As seen above, our method outperforms all baselines across all metrics, including those not based on vision-language pretraining. \n\n---------------------\n\n## **Q4: Can the model accurately vectorize binary images and preserve topology and layer order?**\n\nThis is a great question. To evaluate this, **we created a small test set** composed of 50 SVGs by extracting a subset of black-and-white examples from SVG-Stack. We selected SVGs composed of primitives such as circles, polygons, and basic shapes, and binarized them by setting all vector colors to black over a white background.\n\n**Results**: Visually, the resulting rendered images generated by our method remain crisp, and the SVGs generated by our model correctly utilize primitives more effectively than traditional binary-focused methods like Potrace (only using path). We include preliminary results below:\n\n| Model          | MSE ↓ | SSIM ↑ | LPIPS ↓ | DINO ↓ | Code Eff. |\n|----------------|-------|--------|---------|--------|----------------|\n| Potrace        | 8.53   | 77.02   |   19.23  | 90.21   | -7.3k          |\n| VTracer        | 4.32   | 88.01   |  11.51   | 96.21   | -12.9k         |\n| **RLVG (ours)**| **1.11** | **96.22** | **3.32**   | **98.52** | **-334**         |\n\n\nInterestingly, *we find that this task is easier for RLVG* (and for VLM SVG models in general), as it removes many of the challenges related to color, shading, and texture. The model focuses purely on geometric structure, and we observe high-quality outputs that preserve the correct topology and element layering.\n\nWe have included this analysis in our manuscript and will be available in the camera-ready version.\n\nThanks again for your review"}, {"review_id": "28ixUem7PW", "reviewer": "Reviewer_RqsR", "summary": "This paper proposes a reinforcement learning-based Scalable Vector Graphics (SVG) generation model named RLVG. By designing rendering output-aware rewards, based on image reconstruction, semantic similarity, and code efficiency, it fine-tunes pre-trained autoregressive VLMs to generate more precise, high-quality SVGs. Experiments demonstrate that RLVG achieves new state-of-the-art results on multiple benchmarks.", "questions": "1. The term \"inverse rendering code generation problem\" is not commonly used and should be revised or rephrased (e.g., avoid \"known as\"). \"Perceptual inputs\" should also be replaced with a more specific description (e.g., the caption in Figure 1 uses \"text or image input,\" which is clear and concise).\n2. Citation format: The current author-year style differs from the numeric format seen in other papers. Switching to numeric citations would save space in the main text, allowing inclusion of Appendix C.2, which contains crucial methodological details that should not be relegated solely to the supplementary material.  \n3. Issues with Figure 1:  \n(a) The caption states \"compared to the input (image, SVG, or text),\" which may confuse readers who recall this caption mentioning only \"text or image input.\" Clarify the SVG input reference or align the caption with the introduction.  \n(b) While the stop sign is explained in the caption, adding a legend directly in the figure would improve clarity.  \n(c) The caption describes the example as \"out-of-distribution with no associated ground truth SVG,\" conflicting with Lines 180–186, which require ground-truth SVGs for code efficiency calculation. Resolve this inconsistency to avoid reader confusion.", "limitations": "Yes", "rating": 5, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 4, "clarity": 3, "significance": 3, "originality": 4, "strengths_and_weaknesses": "Strength:\n1. The motivation is clear and easy to grasp, and its distinction from existing work is well articulated (Lines 39–46).\n2. The method achieves new state-of-the-art results on task metrics while demonstrating a significant improvement in code efficiency.\nWeakness:\nPlease find details in Questions.\n\nIn my opinion, this is a well-matured paper with clear motivation and solid results. While the key insight seems simple, the paper demonstrates high completeness and sufficient effort throughout. All the experimental results I care about are provided, albeit mostly in the supplementary material due to space constraints. Therefore, I give an **Accept** rating, but I encourage the authors to refine the content further based on the feedback in the Questions.", "was_revised": true, "final_justification": "The idea of this paper is simple and clear, and the experimental results demonstrate its effectiveness. Therefore, I initially gave it a high score. I appreciate the authors‘ rebuttal and will keep my recommendation unchanged.", "rebuttal": "We sincerely thank the reviewer for the thoughtful and positive feedback. We are glad that the motivation and distinction from prior work came through clearly, and we appreciate your recognition of the state-of-the-art results and the overall high completeness of our paper. \n\nWe are especially encouraged by your appreciation of the *simplicity* of our approach. We believe the best ideas are often the simplest ones: easy to understand, straightforward to implement, yet capable of delivering strong and generalizable results. This principle guided our design of RLVG.\n\nThanks for your questions and feedback for improving our manuscript's clarity. We have applied all your concerns as follows:\n\n-----------------\n\n## **Q1. Terminology: “inverse rendering code generation problem” and “perceptual inputs”**\t\n\nThank you for pointing this out. **We agree that the term “inverse rendering code generation problem” is not widely adopted** and could be confusing. We have removed the phrase “known as” and replaced it with a clearer and more intuitive description: **visual code generation**. Additionally, **we have replaced the term “perceptual inputs” with more precise wording** (“images or textual descriptions”).\n\nThe revised opening sentence of the introduction now reads:\n*“Visual Code Generation is the problem of translating images or textual descriptions into executable code that gets compiled and produces a visual output [Rodriguez et al., 2025b; Baulé et al., 2021].”*\n\nFor completeness, the previous version was:\n*“Generating structured visual code from perceptual inputs, known as the inverse rendering code generation problem, aims to translate images or text into executable code that reproduces the target visual content [Rodriguez et al., 2025b; Baulé et al., 2021].”*\n\nWe have also ensured this terminology is used consistently throughout the paper. Please let us know if you have further suggestions.\n\n--------\n\n## **Q2. Citation style: switch to numeric to free space to move Appendix C.2**\n \nThank you for the suggestion. We agree that several important results were previously buried in the supplementary. Following your advice, **we have switched to a numeric citation format to save space** and we have moved key content into the main paper. \n\nSpecifically, the reward details from Appendix C.2, along with select results from Appendices A.1, A.2, and A.3, are now integrated into the main experimental sections.\n\n--------------\n\n## **Q3. Figure 1 inconsistencies**\n\nThank you for pointing out these issues with our main figure. Your feedback has allowed us to improve its clarity.\n**We have applied your changes as follows:**\n\n### **Q3.a) Caption clarity regarding inputs**\n\nYou are right, the SVG is not an input to the model, and the wording was misleading. We intended to convey that the model's outputs are compared to *task targets*: the input image, the input text, or the ground truth SVG (if available). **We have revised the caption to remove the ambiguous reference to \"inputs\"** and clarified what the comparisons are made against.\n\n**The updated caption now reads:**\n\n *“Given a text or image input, the model generates multiple SVG rollouts, which are rendered into images to compute a reward based on the task at hand using the image or text targets, or the ground truth SVG (if available).”*\n\nPreviously, it read:\n\n *“Given a text or image input, the model generates multiple SVG rollouts, which are rendered and compared to the input (image, SVG, or text) to compute rewards based on reconstruction, semantics, and code efficiency.”*\n\nWe believe this change makes the caption more precise and consistent with the description in the introduction.\n\n-------------\n\n### **Q3.b) Missing legend in Figure 1**\n\nWe have **added a small legend in the top-right corner of Figure 1** to clarify the meaning of the stop-sign icon, which denotes non-differentiability in the rendering pipeline. \n\n--------\n\n### **Q3.c) Clarifying ground-truth SVG availability for the example shown**\n\nThank you for catching this ambiguity. **The “apple” example shown in Figure 1 is from the inference (test) phase**, not from the training set. This specific sample is used to visualize how the model's outputs evolve *over the course of RL training*, and no rewards are computed on it.\n\nWe agree that the confusion arises because Figure 1 appears alongside our explanation of the RL training loop, which does involve reward computation using image, text, or SVG targets, depending on the task. However, the visualized sample is only used for monitoring progress on a fixed out-of-distribution Im2SVG test example, for which we only have the raster image, and no ground-truth SVG is required or used.\n\n**We have now clarified this explicitly in the caption**, and it will be visible during camera-ready, to distinguish between the general RL training setup and the illustrative test sample. \n\nThanks again for your review"}, {"review_id": "JEWGPTL1OV", "reviewer": "Reviewer_STcx", "summary": "This work proposes a new method for SVG generation. The core idea is to leverage reinforcement learning (RL) to improve both the visual quality (especially for complex semantics) and the code efficiency of generated SVGs. Additionally, the authors introduce a set of reward functions to guide the SVG generation process. Extensive experiments are conducted to demonstrate the method’s effectiveness, along with some in-depth analysis.", "questions": "Before evaluating code efficiency, is there any preprocessing applied to the SVG codes, such as removing redundant <g> tags or other forms of code cleaning, to ensure compactness? If so, please provide detailed information on the specific preprocessing steps used.", "limitations": "Yes.", "rating": 4, "confidence": 5, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 3, "significance": 2, "originality": 2, "strengths_and_weaknesses": "*Strengths*:\n\n1. The paper is clearly written and provides insightful analysis (primarily in the supplementary materials).\n\n2. The model demonstrates impressive performance on the image-to-SVG task, particularly in terms of generalizability to unseen cases (Fig. 1).\n\n3. The experimental evaluation is extensive, effectively demonstrating the proposed method's advantages.\n\n*Weaknesses*:\n\n1. **Limited Novelty**: The proposed method appears to be an extension of StarVector (Rodriguez, 2025b) through the incorporation of RL. The method consists of two stages: SVG-SFT and RLVG. The first stage involves straightforward fine-tuning of a VLM using SVG data, while the main novelty lies in the design of reward functions for SVG generation. When StarVector is used as the base model, the method essentially becomes a post-training step. Furthermore, the performance improvements of StarVector+RLVG over StarVector across various metrics are relatively moderate.\n\n2. **Lack of Qualitative Results**: The authors claim that incorporating RL improves visual fidelity and code efficiency. Therefore, more qualitative results are expected to support these claims. While quantitative results indicate improvements due to RLVG, it remains unclear how these translate into visual quality enhancements. In Fig. 2 (and Fig. 7 in the supplementary), results using Qwen2.5VL-7B as the base model are compared. It would be beneficial to provide side-by-side qualitative comparisons of StarVector and StarVector+RLVG on the same examples. Additionally, while RLVG seems to significantly improve code efficiency, the meaning of the reported numbers is unclear. For instance, using a ground-truth as reference, what does it look like when code efficiency is +1.3k, -18.3k, -800, or -127? Providing visual and code examples would help clarify these points.\n\n3. **Evaluation of Code Efficiency**: The evaluation of code efficiency could be further improved. In my opinion, code efficiency should reflect the compactness and editability of the SVG code. A user study involving professional designers to assess the editability of the generated SVGs would provide a more comprehensive evaluation from an end-user perspective.\n\n4. **Missing References and Baselines**:\n\n(1) Several relevant image vectorization papers are not cited or compared against, including:\n- [1] SuperSVG: Superpixel-based Scalable Vector Graphics Synthesis, CVPR 2024.\n- [2] Vector Graphics Generation via Mutually Impulsed Dual-domain Diffusion, CVPR 2024.\n- [3] Towards High-fidelity Artistic Image Vectorization via Texture-Encapsulated Shape Parameterization, CVPR 2024.\n\n(2) When reporting performance on the text-to-SVG task, LLM4SVG (Xing, 2024) is missing as a baseline for comparison.", "was_revised": true, "final_justification": "The authors’ response has addressed my concerns well. Accordingly, I would like to raise my rating.", "rebuttal": "Thank you for the time invested in reviewing our paper. We’re glad you found the writing clear, appreciated our insightful analysis, and recognized the strong generalization and performance of our model, as well as the overall quality of the experimental evaluation. \n\nWe have carefully considered all of your comments, and we address each point in detail below.\n\n-----------------\n\n## **Q1. Limited novelty vs. StarVector**\n\nWe respectfully disagree with the characterization of our contribution as limited in novelty. While our method builds on StarVector as a base model, **we introduce a fundamentally new approach: applying reinforcement learning to visual code generation** tasks using autoregressive VLMs, **a new setting** where the generated code is rendered into an image, and the feedback is derived from that visual output.\n\nThis is, to our knowledge, **the first method to successfully apply RL in the SVG VLM space**, addressing a range of challenges that are unique to the setting:\n\n - **Sampling rollouts of SVG code** from a **large vision-language model** and computing **rendering-aware rewards** to **overcome the non-differentiability**.\n - **Designing a reward suite for SVG and visual code generation** that balances pixel‑level fidelity, perceptual alignment, and code efficiency.\n - **Overcoming optimization instabilities** tied to long‑sequence code generation and sparse reward signals.\n\nWe believe **this work opens the door to a new class of rendering-aware fine-tuning techniques for visual code generation**, not just for SVG, but also for visual tasks. RLVG is a *foundational step* in a relatively unexplored but high-impact space.\n\n---------------\n\n## **Q1.1. Improvements of StarVector+RLVG over StarVector across various metrics are relatively moderate.**\n \nWe would like to provide some context. While the improvement margin of StarVector+RLVG over the original StarVector is indeed smaller than what we observe with Qwen2.5VL+RLVG, **this is primarily due to limited optimization and resource investment on the StarVector branch**.\n\nQwen2.5VL offered a more modular architecture and faster iteration cycles. StarVector is based on an earlier architecture that proved more difficult to tune, and as such, **for StarVector, we devoted fewer resources to its RL optimization**. Specifically, the **StarVector+RLVG experiments were conducted with 500 training samples and 8 rollouts per sample** and did not benefit from the full reward suite or extended training time.\n\n### **That said, the observed improvements are still meaningful.**\n\nAcross all metrics, StarVector+RLVG shows consistent gains of +1 to +2 points.** The drop in **code token count (Code Eff.) is dramatic**, highlighting real efficiency gains in the generated SVGs.\n\n**To strengthen this part of the paper, we have launched a new training run of StarVector + RLVG using our most optimized setup.**\n\n----------\n\n## **Q2. Lack of Qualitative Results. Can you provide more qualitative comparisons (e.g., StarVector vs. RLVG)?**\n\nWe agree that the qualitative analysis in the submission (Figures 1, 2, 3, 8, 9) was primarily focused on Qwen2.5VL-based experiments and other baselines.\n\n**To address this, we have created two new figures comparing StarVector and StarVector+RLVG**, highlighting both visual outputs and code-level differences. The main takeaway is that **RLVG significantly improves layer alignment and structure** (as observed in the “strawberry” example of Figure 2), especially in complex SVGs. Additionally, it **reduces failure cases where the base model would previously hallucinate long, invalid SVG sequences or enter repetitive loops**. Unfortunately, we can not share images here, but they will be available in the camera-ready version. \n\nAdditionally, we have added new qualitative figures from other benchmarks and ablations, covering image-to-SVG and text-to-SVG tasks. \n\n---------------\n\n## **Q2.1. Clarify what the code efficiency numbers mean with visual/code examples.**\n\nWe appreciate the opportunity to clarify this further. **The code efficiency metric reports the token length difference between generated SVGs and ground-truth SVGs on the test set.**\n\n**Interpretation**: \n\n- *A value near 0 is ideal*: it indicates that the model produces SVGs similar in size to the reference.**\n- *A value much greater than 0 (e.g., +1.3k) often indicates that the model under-generates*, typically collapsing to overly simplified SVGs with missing details. This behavior is common in base VLMs without SVG-specific tuning, as shown in Table 1.\n- *A value far below 0 (e.g., –18k) means the model over-generates*, often producing excessively long path commands (as seen in image-processing-based methods) or falling into repetitive loops (as observed in some SVG-SFT-trained VLMs).\n\n*Our pipeline, after applying RL, consistently brings this value closer to 0*, by improving both **semantic precision** and **structural regularity** in the generated code.\n\n**We have added a new qualitative figure** that visually compares SVGs before and after RL fine-tuning, highlighting both the visual render and code length. These side-by-side examples illustrate how RL reduces redundancy while preserving fidelity.\n\n--------------------\n## **Q3. Evaluation of code efficiency could be improved. Could you assess compactness and editability via a user study?**\n\nThank you for the suggestion. **We conducted a user study** to assess **editability** and **fidelity** of generated SVGs across four model variants: StarVector, StarVector + RLVG, Qwen2.5VL-7B + SFT, and Qwen2.5VL-7B + RLVG.\n\nWe sampled 50 examples from the SVG-Stack-Hard dataset, ensuring diversity across primitive types and structural complexity. For each sample, **participants were shown the ground-truth image and side-by-side outputs (pre- and post-RLVG), and asked to evaluate:**\n\n- **Fidelity**: How well the SVG matches the image\n\n- **Editability**: Whether the SVG is clean, structured, and easy to manipulate (e.g., use of primitives like <circle> or <text>, absence of redundant paths or styles)\n\nWe collected **267 evaluations** from **18 participants**, including **3 professional designers**. Model outputs were anonymized and randomized in presentation.\n\n### **Results**\n**Fidelity**: RLVG preferred in **42.7%** of cases, SFT in **12%**, tie in **45.3%**\n\n**Editability**: RLVG preferred in **59.2%**, SFT in **15%**, tie in **25.8%**\n\nThe results demonstrate a **clear advantage for RLVG over SFT across both fidelity and editability**. While SFT already performs well in fidelity (tying with RLVG in nearly half the cases), RLVG matches this baseline and is **strongly preferred in the more challenging examples**. In terms of **editability**, participants **overwhelmingly favored RLVG**, citing *cleaner structure*, *better use of primitives*, and *more compact, interpretable code*. Importantly, these gains in efficiency come without any loss in visual quality, confirming that RLVG produces SVGs that are both accurate and significantly easier to edit.\n\n**Designers noted** that SFT often added unused styles or invalid attributes, while RLVG produced cleaner code with shorter, more editable paths\n\n------------------\n\n## **Q4. Missing References and Baselines**\n \nThank you for pointing out these recent works. **We have updated the manuscript to include all four references.**\nWe have run and reported results for SuperSVG [1] on the image-to-SVG task and LLM4SVG [4] on the text-to-SVG task. The results are now included in Tables 1 and 4.\n\n**Image2SVG results** on the svg-stack-hard test set\n\n| Model           | MSE ↓ | SSIM ↑ | LPIPS ↓ | DINO ↓ | Code Eff. |\n|-----------------|-------|--------|---------|--------|----------------|\n| LIVE            | 2.22  | 88.11  | 93.45   | 7.23   | -18.3k         |\n| **SuperSVG**    | 3.05  | 83.3   | 13.5    | 82.7   | -65.6k         |\n| **StarVector**  | 3.46  | 88.0   | 98.0    | 7.51   | -127           |\n| **RLVG (ours)** | **1.03**  | **95.1**   | **3.08**    | **98.7**   | **-334**           |\n\n**SuperSVG** achieves competent visual scores like MSE of 3.05, beating StarVector, but we observe that it **relies exclusively on long path sequences**, fitting curves densely without structure. This results in SVGs with **high visual noise and poor editability**, making them difficult to use in real-world design. **Our latest RLVG model shows the best scores**\n\n**Text2SVG results** on the Flickr30k, MM-Icon, and MM-Illustration benchmarks. For each model, we compute the average across these datasets to obtain aggregate summary scores.\n\n| Model                  | CLIP   | Accurate | Aesthetic |\n|------------------------|--------|----------|-----------|\n| Claude-3.7-sonnet      | 30.96  | 4.10     | 3.44      |\n| GPT-4o-1120            | 29.48  | 3.48     | 3.12      |\n| **LLM4SVG-GPT2XL** (3B)    | 22.37  | 1.95     | 1.99      |\n| **RLRF (OURS)**          | 27.89  | 3.83     | 3.29      |\n\n**LLM4SVG** is able to perform text-to-SVG generation and produces valid SVGs most of the time. However, it often *fails to follow the prompts in our benchmarks*, likely due to distributional shifts from its training data. As a result, it shows limited generalization capabilities.\n\nFor the remaining two baselines,  [2] and [3], we were unable to run them due to the lack of publicly available code. However, we have added a brief discussion in Section 2 (Related Work):\n\n-------------\n\n## **Q.5. Is there any processing applied to the SVGs before evaluating code efficiency?**\n\n**We do not apply any preprocessing aimed at compacting the SVG code**, such as removing redundant tags or cleaning object structures. The only processing step is a minimal repair routine: if an SVG is invalid (i.e., cannot be parsed by the `svgstr2paths(svg_string)` function from `svgpathtools`), we attempt to fix it by closing open paths. No other modifications or clean-up steps are applied.\n\nThanks again for your review."}, {"review_id": "NAI0gBFa61", "reviewer": "Reviewer_CVwa", "summary": "This paper presents an RL-driven method called RLVG, a two-stage approach for high-fidelity SVG code generation using pre-trained vision–language models (VLMs). For rewarding the model, the paper proposes sound loss functions, namely (1) pixel-level reconstruction (L2 and L2+Canny), (2) semantic similarity (DreamSim or CLIP), and (3) code efficiency (token-length penalty). Experiments on the SVG-Stack-Hard benchmark show RLVG markedly improves MSE, SSIM, DINO, LPIPS, and dramatically reduces SVG verbosity.", "questions": "Given the heavy computing reported, what strategies could reduce this cost (e.g., fewer roll-outs, model distillation)?\nThe results of the reconstructions diverge very differently (i.e., Fig 2), did the authors consider a small-scale user study to validate that RL-optimized SVGs align with human judgments of fidelity and editability?\nThe paper argues in future work (broader impact) that RLVG extends to other inverse-rendering tasks (HTML/CSS, TikZ). Do the authors have preliminary results or insights on such domains?\n\nAt the moment, I tend towards acceptance but I might change my mind based on the authors' and other reviewers' replies.", "limitations": "Yes", "rating": 4, "confidence": 2, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 3, "significance": 3, "originality": 3, "strengths_and_weaknesses": "Strengths:\n- The paper shows effort in evaluating their method. In more detail, it includes multiple metrics like pixel (MSE, SSIM), perceptual (DINO, LPIPS), and code-efficiency across multiple baselines and ablations.\n- Extensive supplementary material answering core questions \n- Introduces the first rendering-aware RL framework for autoregressive SVG generation, filling the gap left by non-differentiable rendering.\n\nWeaknesses:\n- RL stage requires thousands of roll-outs (e.g., 16K samples over 5 days on 32 H100s).\n- Briefly mention the reward weight selection would be more appropriate in the main paper (instead of suppl. material), but that's just a style thing.", "was_revised": true, "final_justification": "All raised concerns were addressed accordingly: I am happy to keep my rating as final decision! I hope the additional results, especially the user study, finds its way to the final manuscript!", "rebuttal": "Thank you for taking the time to review our paper. We sincerely appreciate your recognition of RLVG as the first rendering-aware reinforcement learning framework for SVG generation, as well as your positive remarks on the soundness of our reward design and the strength of our experimental evaluation. We're also glad to hear that the supplementary material helped clarify key aspects of the method.\n\nWe have carefully considered all of your comments and suggestions, and we address each point in detail below.\n\n-------------\n\n## **Q1. The RL stage requires heavy compute (e.g., 16K rollouts over 5 days on 32 H100s). Can this cost be reduced?**\n\nWe agree that RL training is computationally demanding, a challenge also noted in prior works [1, 2]. This is primarily due to the memory and system-level requirements:\n\n- Each rollout step must load the **policy model**, **frozen reference model**, and **inference model**, all in parallel, which only fits on large-memory GPUs.\n\n- **During rollout collection, training GPUs remain idle**, and **during training, the inference GPUs sit idle**; this alternating workload limits throughput unless scaled to many GPUs. Using more GPUs increases training speed roughly linearly.\n\nThe directions proposed by the reviewer are promising to reduce the cost:\n\n- **Model distillation**, as explored in DeepSeek-VL, is a compelling strategy: RL can be performed on a large model (which benefits more from feedback and scale), and the improved policy can then be distilled into a smaller, faster model for deployment.\n\n- **Reducing the number of rollouts** is effective, but with tradeoffs, as shown in Figure 6, performance improves steadily with more rollouts.\n\n### **Experiment on cost reduction**: \n\n**We ran a new set of experiments using our latest optimized setup**, performing an ablation across four reward variants as suggested by Reviewer Lhdn. To r*educe computational cost*, we scaled down **from 16k to 1k samples**, reduced rollouts per sample **from 64 to 32**, halved the batch size, and cut GPU usage from **32 to 16 H100s**. Despite these constraints, the model showed *remarkable improvements*, confirming that **RLVG is effective even under limited resources and scales well with increased compute** (more rollouts, longer training).\n\n| Method       | Code Eff. | DinoScore | L2     | LPIPS  | SSIM   |\n|--------------|-----------|-----------|--------|--------|--------|\n| **SFT**      | -2.8k     | 93.00     | 8.60   | 16.58  |  79.40 |\n| **L2 Canny** | -334      | 98.70     | 1.03   | 3.08   | 95.08  |\n| L2           | -159      | 98.82     | 1.10   | 3.17   | 94.76  |\n| SSIM         | -210      | 98.64     | 1.30   | 3.34   | 94.76  |\n| L1           | -254      | 98.69     | 1.57   | 4.06   | 93.62  |\n\n\nA key optimization we plan to explore is introducing slightly *off-policy updates*, where training continues using cached rollouts from earlier policy versions, reducing idle GPU time. Techniques such as PipelineRL [1] support this without major stability loss.\n\nFinally, although expensive, **RLVG is highly data-efficient**. Compared to supervised fine-tuning (SFT) on Qwen2.5VL-7B, which required 2M samples over 14 days on 64 GPUs, our RL setup achieves stronger generalization using only ~16k rollouts over 5 days on 32 GPUs. Furthermore, we show in this rebuttal really good results with 1k rollouts and 16 GPUs.\n\nWe believe that as the community advances RL infrastructure, these costs will continue to decrease, making rendering-aware RL more accessible in future work.\n\n[1]  ServiceNow & Hugging Face Research. (2025, April/May). PipelineRL. Hugging Face\n[2] DeepSeek‑AI, Guo, D., Yang, D., Zhang, H., Song, J., Xu, R., Zhu, Q., … Shao, Z. (2025, January 22). DeepSeek‑R1: Incentivizing reasoning capability in large language models via reinforcement learning. arXiv. \n\n-----------------\n\n## **Q2. Could reward weight selection be included in the main paper rather than the supplementary?**\n\nYes, we agree that this is an important detail that deserves to be in the main paper. We have now included the reward weight configuration directly in **Section 5.1**, with the following sentence (it will appear in the camera-ready version):\n> *“We find that the best-performing configuration uses weights:*  \n> *\\(w_{\\text{L2}} = 1.0\\), \\(w_{\\text{L2-Canny}} = 0.5\\), \\(w_{\\text{DreamSim}} = 0.3\\), \\(w_{\\text{LPIPS}} = 0.3\\), and \\(w_{\\text{Length}} = 0.01\\).”*\n\n\n-----------\n\n## **Q3. Given the divergence in reconstructions (e.g., Fig. 2), did you consider a user study to validate fidelity and editability from a human perspective?**\n\n\nThank you for the suggestion. **We conducted a user study** to assess **editability** and **fidelity** of generated SVGs across four model variants: StarVector, StarVector + RLVG, Qwen2.5VL-7B + SFT, and Qwen2.5VL-7B + RLVG.\n\nWe sampled 50 examples from the SVG-Stack-Hard dataset, ensuring diversity across primitive types and structural complexity. For each sample, **participants were shown the ground-truth image and side-by-side outputs (pre- and post-RLVG), and asked to evaluate:**\n\n- **Fidelity**: How well the SVG matches the image\n\n- **Editability**: Whether the SVG is clean, structured, and easy to manipulate (e.g., use of primitives like <circle> or <text>, absence of redundant paths or styles)\n\nWe collected **267 evaluations** from **18 participants**, including **3 professional designers**. Model outputs were anonymized and randomized in presentation.\n\n### **Results**\n**Fidelity**: RLVG preferred in **42.7%** of cases, SFT in **12%**, tie in **45.3%**\n\n**Editability**: RLVG preferred in **59.2%**, SFT in **15%**, tie in **25.8%**\n\nThe results demonstrate a **clear advantage for RLVG over SFT across both fidelity and editability**. While SFT already performs well in fidelity (tying with RLVG in nearly half the cases), RLVG matches this baseline and is **strongly preferred in the more challenging examples**. In terms of **editability**, participants **overwhelmingly favored RLVG**, citing *cleaner structure*, *better use of primitives*, and *more compact, interpretable code*. Importantly, these gains in efficiency come without any loss in visual quality, confirming that RLVG produces SVGs that are both accurate and significantly easier to edit.\n\n**Designers noted** that SFT often added unused styles or invalid attributes, while RLVG produced cleaner code with shorter, more editable paths\n\n---------------\n\n## **Q4. You mention broader applicability to other code-rendering tasks like HTML/CSS or TikZ. Do you have any preliminary results or insights in those domains?**\n\nYes, **we have conducted early exploratory experiments** applying the **RLVG framework to HTML/CSS generation**. In these experiments, we used the **Qwen2.5VL-32B** model to generate HTML/CSS from web page screenshots, using the **WebMMU** dataset [1]. We treated the HTML/CSS outputs as rollouts, rendered them into webpages, and computed rewards based on the visual similarity between the rendered page and the input screenshot.\n\nWe observed that **L2 and LPIPS-based rewards** are still useful in this setting, while edge-aware metrics like **Canny-L2** are less effective due to the structured and hierarchical nature of web layouts. Vision-language models (VLMs) also show strong potential as judges in this context.\n\nWe hypothesise that **task-specific reward functions** will be crucial in this domain, ones that incorporate layout accuracy, DOM hierarchy, and code-level structure beyond appearance alone.\n\nIn parallel, **we are encouraged to see that RLVG has already inspired follow-up work**. For example, **DeTikzify-v2.5-8B** [2] recently applied similar RL-based techniques to **TikZ code generation**, with strong results.\n\nThese early findings support our belief that RLVG has the potential to significantly advance rendering-aware code generation across a wide range of visual programming domains.\n\n[1] Awal, Rabiul, et al. \"WebMMU: A benchmark for multimodal multilingual website understanding and code generation.\" ICLR 2025 Third Workshop on Deep Learning for Code. 2025.\n\n[2] Belouadi, Jonas, Simone Ponzetto, and Steffen Eger. \"Detikzify: Synthesizing graphics programs for scientific figures and sketches with tikz.\" Advances in Neural Information Processing Systems 37 (2024): 85074-85108.\n\nThanks again for reviewing our paper."}]

Author rebuttal:

Meta-review: The paper received four expert reviews. The authors provided a rebuttal that attempted to address the concerns raised in the reviews. The reviewers read the rebuttal and engaged with the authors.  The reviewers unanimously like the paper and recommended accept. The area chair agreed with the recommendation and decided to accept the paper. Congratulations! Please see the reviews for feedback on the paper to revise the final version of your paper and include any items promised in your rebuttal.
Decision: Accept (poster)