acceptodds
Withdrawn from ICLR 2027

CodingImage: Programmable Image Editing via Vector Graphics Code

Withdrawn from ICLR 2027, so left out of the paper lists and the map.

Abstract

Fine-grained image editing calls for intuitive, element-level control. Scalable Vector Graphics (SVG) code offers a shared editing interface: large language models (LLMs) can rewrite it from natural-language instructions, while humans can directly refine its paths. However, conventional image-to-SVG methods face two challenges: their outputs may lack the semantic alignment and hierarchy needed for intuitive editing and manipulation, and pursuing high reconstruction fidelity can make vectorization prohibitively time-consuming. We introduce CodingImage to address both challenges. It efficiently parses images into hierarchical vector graphics (VGs) that are semantically aligned and structurally coherent. For photorealistic synthesis, we further propose Vector-Guided Noise Prediction, which conditions the diffusion model on these VGs and guides generated images to follow their structure and semantics. This enables precise control over geometry, color, and object semantics. Experiments demonstrate CodingImage's effectiveness in image editing, object-level manipulation, and fine-grained content creation.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
Controllable Image Generation, Image Editing, Vector Graphics

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_hcyMOpenReview ↗
Rating
2
Confidence
3
Informativeness
1
Presentation
3
Soundness
1
Read review
Paper summary

The paper suggests a new image editing pipeline which leverage SVG representation to edit images using LLMs/agents or humans with easy interface. SVG representation enables a layerwise, easy to control domain for editability and, as such, is suitable for the task. The paper describes a complete pipeline of transforming images to SVG and back to images, enabling a regeneration loop for editing.

Critical strengths
  • The paper is mostly well-written, polished, and easy to follow.
  • The qualitative results are impressive, and the suggested interface looks practical.
  • The idea of controlling editing through SVG representation is straightforward and makes sense.
Critical weaknesses
  • Limited novelty - while the proposed pipeline looks effective, most of its components are already published, and chaining them together has limitted novelty. Specifically, the flexibility enabled by SVG is already well known and is used to justify methods that convert images to SVG (like LIVSS). While the NPV module appears novel, it's not well justified and is not compared to other inversion-free methods (like flow-edit) or other conditioning methods (like IC-LORA).

  • Limited comparisons - The paper does prove its claim on the superiority of SVG representation as a medium for editing compared to edges or depth conditioning. But the paper presents several tasks and does not compare to other methods tackling them. While SVG does capture more information than depth, the authors should compare to other methods of achieving the same end goals. For example, for the task of agentic image editing, the authors should compare to other instruction-based/agentic works (like Agent Banana [1], Qwen-Image-edit [2], OmniGen [3], etc) on this task. Or, for the task of image-to-SVG, the authors only compare to LIVSS, where there are numerous works focused on semantically layered representation (LIVE [4], O&R [5], LIVSS [6], LayerPeeler [7], etc).

  • Hierarchical and semantic-aligned initialization - The difference between the suggested method and LIVSS is not clear.

[1] Ye, Ruijie, et al. "Agent banana: High-fidelity image editing with agentic thinking and tooling." arXiv preprint arXiv:2602.09084 (2026).

[2] Wu, Chenfei, et al. "Qwen-image technical report." arXiv preprint arXiv:2508.02324 (2025).

[3] Wu, Chenyuan, et al. "Omnigen2: Towards instruction-aligned multimodal generation." Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition. 2026.

[4] Ma, Xu, et al. "Towards layer-wise image vectorization." 2022 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). IEEE, 2022.

[5] Hirschorn, Or, Amir Jevnisek, and Shai Avidan. "Optimize & reduce: A top-down approach for image vectorization." Proceedings of the AAAI Conference on Artificial Intelligence. Vol. 38. No. 3. 2024.

[6] Wang, Zhenyu, et al. "Layered image vectorization via semantic simplification." 2025 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). IEEE, 2025.

[7] Wu, Ronghuan, Wanchao Su, and Jing Liao. "Layerpeeler: Autoregressive peeling for layer-wise image vectorization." Proceedings of the SIGGRAPH Asia 2025 Conference Papers. 2025.

Questions for authors

Please see weaknesses.

Reviewer_HK2COpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes CodingImage, a framework that makes image editing programmable through SVG code. An image is first parsed into hierarchical SVG. An LLM/agent then rewrites the SVG from a natural-language instruction, a human refines it by dragging Bézier control points, and the edited SVG is rendered back into a photorealistic image. CodingImage is composed of two core components, an Image-to-SVG parsing module and an SVG-to-Image generation module, which run in a closed loop. The Image-to-SVG module follows LIVSS: diffusion priors produce progressively simplified images, and SAM segments them into hierarchical masks. Each mask is then converted into a few cubic Bézier segments and optimized with Bézier Splatting under fixed opacity, with a mask-alignment loss and a reconstruction loss. The SVG-to-Image module is built on FLUX.1-dev and trained in two stages. The first stage adds LoRA to the transformer and concatenates rendered-SVG tokens with noisy latent tokens, following OminiControl. The key component in their method is the second stage, Noise Prediction from Vectors (NPV), which attaches LoRA and prediction heads to the FLUX VAE encoder to estimate the mean and variance of the initial noise from the rendered SVG. The training set contains around 5M LAION-400M images converted into SVG by their own module. On 5K source–target pairs from AnyEdit, the SVG condition achieves the best reconstruction and editing results compared with Canny, depth, stroke, and segmentation-mask conditions, and NPV brings further gains. Their vectorizer is also reported to be 7× faster than LIVSS on DIV2K with slightly higher PSNR. Qualitative comparisons are shown against GPT-4o, Qwen-Image, Flux-Kontext, and ICEdit.

Critical strengths

The paper uses semantically structured SVG code as a shared editing interface between LLMs and humans, and closes the loop from image to SVG and back to image. Shape, position, and region-level edits, such as turning a round bubble into a heart or fixing a wrong number of fingers, are exactly where instruction-based editors often fail, so making these edits explicit in code is a reasonable direction. Also, NPV is a lightweight plug-in with only about 135K parameters. It consistently improves not only the SVG condition but also the Canny and Stroke conditions, which suggests it might be useful beyond this paper.

Critical weaknesses

The central claim is that an LLM can edit images by rewriting SVG code, yet this is never evaluated quantitatively. The editing results in Table 1 involve no LLM or human edit at all. The edited condition is built as mask × target_SVG + (1 − mask) × source_SVG, where target_SVG is extracted from the ground-truth edited image. The metric therefore mainly measures how well the model reconstructs a target from a condition partly derived from that target. It is also confounded by color information: Canny and depth carry no color and fall behind by about 5–6 dB PSNR, while Stroke, which does carry color, is only 0.29 dB below SVG w/o NPV in reconstruction (17.13 vs. 17.42). The comparison in Fig. 5 seems unfair as well. CodingImage uses GPT-5.6 Luna for the initial edit and then a human manually adjusts the angle and size, while all baselines are fully automatic. Only three examples are shown, and the ~14s runtime excludes LLM and human time. Moreover, the paper never explains how SVG paths get semantic names such as “ear-left” in Fig. 1, even though SAM masks are class-agnostic and the whole LLM interface depends on these names. Finally, the image is fully regenerated from a flat-color SVG, and reconstruction reaches only 17.77 dB PSNR and 0.49 SSIM, so unedited regions are likely not preserved. This is the very background-consistency problem the introduction uses to motivate the method, but it is never measured.

The contribution specific to SVG is not separated from simpler alternatives. The generator only sees a rasterized SVG, so the hierarchy, path semantics, and Bézier parameters play no role in generation. The SVG-to-Image module is therefore essentially OminiControl conditioned on a flat-colored region map. A direct baseline, such as the same model trained on SAM masks filled with mean region colors, is missing, and the paper does not say how its Segmentation Mask baseline is encoded. The gains from NPV are small and come without variance over seeds. NPV is also not compared with simpler ways to inject structure into the initial noise, such as SDEdit-style noising of the rendered-SVG latent or RF-inversion (Rout et al., 2024), both of which the paper cites. The covariance loss in Eq. 11 seems ill-posed as written: if µ̃ is a vector, R is rank-one and Σ_{i≠j} R_ij² = 1 − Σ_i µ̃_i⁴ / ‖µ̃‖⁴, which is minimized by a one-hot µ̃ rather than by decorrelating channels. For the vectorizer, Table 2 reports only PSNR (+0.39 dB) and time at 30 steps. It gives no measure of compactness or semantic alignment, the very properties the paper claims make its SVGs editable. Without these comparisons, it is hard to tell how much each component adds beyond LIVSS, Bézier Splatting, and OminiControl.

Questions for authors
  1. How are semantic names assigned to SVG paths? Is there a VLM or open-vocabulary labeling step? Were the names in Fig. 1 and Fig. 3 added manually?

  2. Please evaluate the LLM editing claim directly. On a held-out set of instructions, what fraction of LLM-generated SVG patches are valid, target the correct path, and leave other paths unchanged? What is the editing quality with LLM edits only, without human refinement? When refinement is used, how much human time does it take? Please also compare with the instruction-based baselines quantitatively on the same instructions.

  3. Does the 2.656 s in Table 2 include the diffusion simplification and SAM stages, or only the 30 optimization steps? Is 30 steps the default setting of LIVSS? Please also report the number of paths and control points per image for both methods.

Reviewer_TazzOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

CodingImage uses hierarchical SVGs as editable controls for photorealistic image generation. It combines semantic vectorization, human–LLM SVG editing, and a FLUX-based generator with vector-conditioned initial noise prediction.

Critical strengths
  1. SVG provides a useful shared interface for code-based editing and direct geometric refinement, enabling explicit control over image content.

  2. The experiments support improvements from SVG conditioning and noise prediction, alongside faster vectorization under matched optimization settings.

Critical weaknesses
  1. Semantic hierarchy needs stronger validation. Parent–child assignment and semantic path naming are insufficiently specified (Sec. 3.2). Reconstruction quality and runtime (Table 2) do not establish object/part correctness or reliable editing of individual elements.

  2. End-to-end editing reliability remains unclear. Quantitative editing uses target-derived conditions (Sec. 4.3), while showcased instruction-based edits involve human refinement. Aggregate image metrics provide limited evidence of identity, texture, and unedited-region preservation on difficult inputs or across repeated edits. The acknowledged limitations are not accompanied by systematic failure rates.

Questions for authors
  1. How are semantic path names and parent–child relationships assigned, and how accurate are they on a small annotated subset?

  2. Could you report editing success, changes in unedited regions, and manual correction effort on a small, diverse set, including repeated edits? Please separate automatic and human-refined results.

  3. Beyond the cited DuetSVG and vectorization methods, please discuss StarVector, OmniSVG, and InternSVG, clarifying the distinction between SVG generation and SVG-mediated photorealistic editing.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Discussion (0)

Sign in to comment.