- Rating
- 1
- Confidence
- 4
- Informativeness
- 2
- Presentation
- 1
- Soundness
- 1
Read review
Paper summary
This paper proposes IR4RL, a reinforcement learning method for image-to-code generation. Instead of relying only on a single reward computed from the final rendered program, the method exploits the fact that many intermediate code prefixes can be closed into executable programs and rendered. After each completed drawing command, the prefix is rendered and scored against the target image, and the change in visual score between consecutive renders serves as a render-progress reward. These segment-level rewards are propagated backward to preceding tokens with exponential decay and combined with the standard group-relative outcome advantage in GRPO. The method is evaluated on Image-to-SVG, using OmniSVG-4B on MMSVGBench, and on Image-to-TikZ, using DeTikZify-v2 on DaTikZ-v3. It improves over SFT, RAFT, and outcome-only RL baselines, achieves state-of-the-art results among open-source models, and produces substantially shorter programs.
Critical strengths
- The paper introduces an appealing process-level reward for image-to-code generation by exploiting renderable code prefixes, without requiring human annotations or a separately trained reward model. Using changes in visual similarity between consecutive renders provides localized feedback on whether newly generated segments improve or degrade the reconstruction.
- Compared with Render-in-the-Loop [1], the method leaves the inference procedure unchanged, requiring no step-wise rendering or visual feedback at inference time.
[1] Liang G, Wang Z, Hu J, et al. Render-in-the-loop: Vector graphics generation via visual self-feedback[C]//European Conference on Computer Vision. Cham: Springer Nature Switzerland, 2026: 229-245.
Critical weaknesses
-
The paper motivates image-to-code generation through structured editing, yet its reward measures only visual similarity and does not explicitly encourage editable SVG structure. A single complex path and a collection of independently editable semantic elements can produce identical renders while offering substantially different editing experiences. Per-command scoring does not directly address this distinction. The evaluation reports visual quality and token length but does not examine path structure, semantic decomposition, or practical editing operations, leaving unclear whether the gains come at the expense of editability. Moreover, the path-based representation appears to exclude primitives such as
<rect>,<circle>, and<text>, which expose properties that are often easier to manipulate than equivalent generic paths. Without evaluating these structural limitations, the paper provides insufficient support for the editability benefit motivating the task. Shorter code is not necessarily easier to edit. -
The authors render after every completed SVG path command, but these boundaries do not necessarily correspond to meaningful visual changes. For example, a move command typically adds no visible content, while the effects of some geometric operations become apparent only after subsequent commands are completed. Repeatedly rendering and scoring such prefixes may therefore increase computational overhead while providing limited useful supervision. However, the paper does not quantify how rendering frequency affects training time. Moreover, the rendering-frequency ablation reports only test reward, without showing how this choice affects the individual reconstruction metrics reported in Table 1. Further analysis is needed to establish whether per-command rendering offers sufficient benefits to justify its computational cost.
-
The presentation lacks clarity, making it difficult to understand how the method actually works. The method hinges on the granularity of intermediate rendering and on how prefixes are closed, yet the main text describes both only vaguely. It merely states that a boundary is placed after every completed "drawing command". In SVG, however, "drawing command" may refer either to a graphical element such as
<path>or to an individual command within a path, so readers can easily interpret the method as rendering at the element level. Only Appendix A.2 and Fig. A.2 make clear that boundaries are in fact placed after every move, line, curve, arc, or close command within a single path. Moreover, unfinished paths are closed back to their starting point and filled with a default black color. In addition, OmniSVG's tokenizer does not generate the outer<svg>and<path>tags, so the closure operator must supply them. These details directly determine what the intermediate renders look like and what the reward actually measures, yet they too are described only in the appendix.
Questions for authors
- Since the reward does not constrain how SVG elements are organized, could the authors report structural statistics of the generated SVGs, such as the number of paths per image and commands per path, compared with the SFT and outcome-only baselines? Does the reduction in token length come from more compact geometry, or from merging separate visual parts into fewer, more complex paths that are harder to edit?
- How does training time vary across the rendering frequencies in the ablation, and what fraction of it is spent on rendering and scoring intermediate prefixes? Could the authors also report the full evaluation metrics on the test set for this ablation, rather than test reward alone?
- For the Image-to-SVG setting, could the authors clarify in the method section what a "drawing command" refers to, i.e., whether boundaries are placed after each SVG element such as
<path>, or after each command within a path (e.g., M, L, C)?