VisCoder2: Building Multi-Language Visualization Coding Agents
Authors: Yuansheng Ni
Songcheng Cai
Xiangchao Chen
Jiarong Liang
Zhiheng Lyu
Jiaqi Deng
Kai Zou
Ping Nie
Fei Yuan
Xiang Yue
Wenhu Chen
Venue: ICLR 2026 Poster (2026)
Keywords: Code Models
Visualization
Fine-tuning
Primary area: generative models

Abstract: Large language models (LLMs) have recently enabled coding agents capable of generating, executing, and revising visualization code. However, existing models often fail in practical workflows due to limited language coverage, unreliable execution, and lack of iterative correction mechanisms. Progress has been constrained by narrow datasets and benchmarks that emphasize single-round generation and single-language tasks. To address these challenges, we introduce three complementary resources for advancing visualization coding agents. **VisCode-Multi-679K** is a large-scale, supervised dataset containing 679K validated and executable visualization samples with multi-turn correction dialogues across 12 programming languages. **VisPlotBench** is a benchmark for systematic evaluation, featuring executable tasks, rendered outputs, and protocols for both initial generation and multi-round self-debug. Finally, we present **VisCoder2**, a family of multi-language visualization models trained on VisCode-Multi-679K. Experiments show that VisCoder2 significantly outperforms strong open-source baselines and approaches the performance of proprietary models like GPT-4.1, with further gains from iterative self-debug, reaching **82.4%** overall execution pass rate at the 32B scale, particularly in symbolic or compiler-dependent languages.

VISCODER2: BUILDING MULTI-LANGUAGE VISUALIZATION CODING AGENTS
Yuansheng "i Songcheng Cai'; Xiangehao Chen'; Jiarong Liang', Zhiheng Lyu', Jiaqi Deng'. Ping S Kai Zou", Fei Yuan', Xiang Yue?, Wenhu Chen 1
University of Waterloo, CCarnegie Mellon University, 'Korea Advanced Institute of Science & Technology, 'Netmind.ai, 'Independent Researcher
https://tige--ai-iae to/.ccooo..
VisCode-Mulli-679K
VisPlotBench
VisCoder2
Python (196, 22%
Visualization Coding Agent
(65, 7%)
Self-Debug
Vega-Lite (129, 15%)
LaTeX (112, 13%)
Bars, Lines, Areas, 3D, Scatter and Relation, Distribution, Matrix and Heatmaps, Diagramming. Maps, Music, Hierarchies, Radial and Pular, Networks and Flows,...
LilyPond (55, 65)
Asymptote (92, 10%)
Execution
Rendering
Mermaid (131, 15%)
HTML (108, 12%)
Code Execution,
Runtime Feed Self-Correctio
Rendering in
Figure Overview of VisCoder2. We present three components: 1) VisCode-Mutti-679K:
dataset of 679K executable visualization samples and multi-turn correction dialogues, spanning 12 programming languages; 2) VisPlotBench: spanning 8 languages with natural language instructions, executable code, and rendered outputs; VisCoder:: family of visualization coding agents that iteratively execute, render, and self-debug. approaching the performance of proprictary models.
ABSTRACT
Large language models (LLMs) have recently enabled coding agents capable of generating, executing, and revising visualization code. However, existing mod- els often fail practical workflows due to limited language coverage, unreliable execution, and lack of iterative correction mechanisms. Progress has been con- strained by narrow datasets and benchmarks that emphasize single-round gener- ation and single-language tasks. To address these challenges, we introduce three complementary resources for advancing visualization coding agents. VisCode- Multi-679K is large-scale, supervised dataset comprising 679K validated ex- ecutable visualization samples and multi-turn correction dialogues, covering 12 programming languages. VisPlotBench is benchmark for systematic evalua- tion, featuring executable tasks, rendered outputs, and protocols for both initial generation and multi-round self-debug. Finally, present VisCoder2, family of multi-language visualization models trained on VisCode-Multi-67999
Exper- iments show that VisCoder2 significantly outperforms strong open-source base- lines and approaches the performance of proprietary models like 1PT-4.1, with further gains from iterative self-debug, reaching 82.4% overall execution pass rate at the 32B scale, particularly in symbolic or compiler-dependen languages.
INTRODUCTION
Recent advances in large language models (LLMMs) have enabled coding agents Jimenez al.
(023):
Yang et al. (2024b) that can generate visualization code, execute it, and even revise their outputs in response to feedback (Robeyns et al. 2025 Li al.] 2025b). These agents increasingly
Core Contributors; Project Lead;" Corresponding: (yuansheng.ni, wenhuchen] Sartinhhhn@uwwwtrrrroo @uwaterloo.ca

---

applied to data analysis and reporting workflows, where producing plots and diagrams is a central task (Galimzyanov et al. 2024).
While existing models can attempt these steps. they often fail in practice: generating code that crashes, produces incorrect visuals, or lacks flexibility across programming languages and li- braries (Goswami et al. 2025). Building more reliable visualization coding agents requires resources that go beyond single-round generation, supporting multi-language coverage, runtime validation, and iterative correction through execution feedback (Yang et al.) (023). However, current datasets and benchmarks lack these capabilities, limiting progress toward agents that can effectively assist in real-world visualization workflows (Ni et al. (025).
Visualization presents uniquely valuable setting for advancing these agents. Unlike general-purpose code generation (Li al., 2022), visualization tasks produce clear and interpretable outputs: the execution process and rendered figure provide an immediate signal of whether the code executed successfully and whether the output aligns with the intended result (Ni et al.) 2025). Moreover, visualization requires cross-domain reasoning. combining knowledge of data handling, plotting syntax, and design conventions (Satyanarayan et al. (2016). Crucially, real-world workflows are inherently iterative - analysts rarely produce perfect visualizations on the first attempt, instead refining their code based on runtime behavior and visual inspection (Goswami et al. (2025). This natural feedback loop makes visualization tasks especially well-suited for developing agents that can generate and self-correct code (Chen et al. 2023).
Despite this potential, existing resources for visualization code generation remain narrow in scope. Most datasets focus on single languages, such as Python or Vega-Lite (Galimzyanov et al. [024 Luo al. 202T), and include many snippets that cannot be executed reliably (Ni et al. (025)). They lack validated, executable samples, and they do not provide the multi-turn interactions needed to train models for iterative debugging (Ni et al., 2025). Existing benchmarks also have significant gaps: they emphasize single-round generation and do not support systematic evaluation across languages or multi-round repair scenarios (Yang et al. 2023). As a result, current models are tested in settings that fail to capture the complexity of real-world visualization development (Goswami et al. 2025
To address these limitations, we introduce two complementary resources. First, we present VisCode-Multi-679K, a large-scale supervised instruction-tuniin dataset comprising 679K executable visualization and code-correction samples cover twelve programming languages. VisCode-Mult-669k combines validated visualization code extracted from diverse open-source
repositories (Lozhkov et al. 2024, Yang et al., 2025a [Rodiiguzz et al., 2025) and multi-turn di- alogues that teach models to revise faulty code based exccution feedback (Zheng et al.) 2024). Second, we propose VisPlotBench, a benchmark for evaluating visualization coding agents across eight languages. VisPlotBench provides carefully curated, executable tasks with natural language instructions and rendered outputs, along with a standardized evaluation protocol for both initial gen- eration and multi-round self-debug (Galimzyanov al. 2024).
Finally, we train VisCoder2, a family of multi-language visualization models built on VisCode-Multi-679K VisCoder2 substantially outperforms size-matched open-source base- lines (Hui et al., 2024; Guo et al. 2024a; Ni et al., (2025) and closes much of the performance gap with proprictary models such as GPT-4.1 (Fachada al. 2025). Experiments show that itera- tive self-debug yields further improvements, reaching 82.4% at the 32B scale, par with GPT-4.1 and surpassing GPT-4. I-mini particularly benefiting symbolic or compiler-dependen languages like LilyPond, LaTeX, and Asymptote. Together, VisCode-Multi-679K VisPlotBench, and VisCoder2 establish a foundation for building and evaluating visualization coding agents that can operate reliably across diverse programming languages and real-world visualization tasks.
2 RELATED WORK
LLMs for Visualization Code Generation Large language models have shown promising re- sults in generating visualization code from natural language descriptions (Yang et al. 2024c Chen et al. 2024; Galimzyanov et al. 2024). Most existing approaches focus on single languages, par- ticularly Python with matplotlib or plotly (Wu et al.] 2024 Yang et al. 2024a), while some explore specification based methods using Vega-Lite (Xie et al. 2024) and HTML (Li et al.] 2025a). How- ever, these systems face significant limitations: they typically support only one or two programming
2

---

languages, lack systematic execution validation, and often generate code that fails to run reliably (Ni et al. 2025 Sun et al. )025). Multi- langull code generation efforts in broader domains (Lozhkov ee al. 2024; Muennighoft
al. 2023) provide extensive language coverage but lack the special- ized knowledge required for visualization tasks, particularly for domain-specific languages like La- TeX for mathematical plots LilyPond for musical notation. Our
dataset addresses these limitations by providing validated, executable visualization samples across twelve programming languages, enabling robust multi-language visualization code generation with system- atic quality control and execution verification.
Self-Debug and Coding Agents Recent advances in coding agents have emphasized iterative de- velopment capabilities, where models can generate, execute, and refine code through multiple rounds of feedback (Jimenez al. 2023 Yang et al.
2024b). Self-debug approaches leverage execution
traces, error messages, and runtime outcomes to guide automatic code correction (Chen et al.) 2023
Madaan et al. 2023 Zheng et al. 2024 Zeng et al. 2025). Agent-based systems further extend these capabilities by incorporating planning, tool use, and collaborative debugging workflows (Gr-
ishina et al. 2025 Li et al. 2024; Zhang et al. 2025). While these methods show promise in general programming tasks, their application to visualization remains underexplored. Existing vi- sualization systems like LIDA (Dibia, (023) incorporate some feedback mechanisms, but lack the systematic multi-turn correction capabilities needed for reliable cross-language deployment. Our work uniquely combines multi-language visualization generation with systematic self-debug, en- abling VisCoder2 iteratively refine code across diverse programming environments, particularly excelling in symbolic languages where execution validation is essential.
Visualization Benchmark Existing visualization benchmarks focus predominantly on Python
Galimzzynnov et al. 2024 Chen et al. 22024] Yang et al.) 2224c Rahman et al. (025) or declara-
tive specifications like Vega-Lite and H HTML (Luo et al. |021|22025| et al. 2025ap, limiting their applicability across diverse programming environments used in real-world data analysis. While gen- eral code datasets like the-stack-v2 (Lozhkov et al. 2024) provide broad language coverage, they lack visualization-speciff content and execution validation. Most visualization benchmarks evalu- ate only single-turn generation, failing to capture the iterative debugging workflows that characterize practical visualization development (Ni et al. 2025| (Sco et al. (025). Without multi-languaag sup- port and multi-round evaluation, existing benchmarks cannot assess whether models can handle the diverse toolchains and iterative workflows essential for real-world visualization tasks. VisCode- Multi-679K addresses these limitations by providing the first large-scale dataset with execution- validated visualization code across twelve programming languages, while VisPlotBench enables systematic evaluation of both initial generation and multi-turn self-debug capabilities across visual- ization tasks multiple programming languages.
3 VISCODE-MULTI-679E AN INSTRUCTION TUNING DATASET FOR VISUALIZATION ACROSS TWELVE PROGRAMMING LANGUAGES
1 Data Filtering
2 Runtime Validation
3
Instruction Gen.
Multi-Lang Code Data
Multi-Lang Vis Code Block
Multi-Lang Vis Code Image
Libs filler
Python, LateX
nbeanvert Gen. images
Split 5 parts cessc Coustruct instruction
code block LilyPodd, SVG, HTML.
aallow error validation
extraction
Fabs
Merge Code-Foedlazk
Vis Code Block
Runnable Vis Code & Image
VisCode-Multi-69K
We collect code blocks across twelve programming languages from open-source repositories, including large-scale code corpora, syn- thetic visualization datasets, and Nomain-specinn diagram collections. We validate executability and render outputs through basedd runtime checks, yielding instructions paired with images. We integrate multi-turn dialogues from
Figure 2: Data construction pipeline for
to provide iterative correction supervision.
We present VisCode-Mulli-679K, a supervised instruction tuning dataset for visualization code gen- eration and feevback-driven correction across twelve programming languages. The dataset supports
3

---

robust multi-language code generation and enables iterative refinement through multi-tur supervi- sion, aligning with the needs interactive visualization workflows.
DisCode-Multi--i (lllk unifies two complementary sources of supervision. The first is a large collec- tion exccutable visualization code extracted from open source repositories across twelve program- ming languages, spanning diverse chart types, libraries, and real-world usage patterns. Each sample is validated for runtime execution and paired with its rendered output, ensuring reliable supervision for multi-language code generation. The second source is 66K multi-turn dialogues from the Code Feedback dataset (Zheng et al. 2024), which provide training signals for revising faulty code based on execution feedback. Although these dialogues are not exclusively coualization-oriented they are essential for modeling realistic self-correction behaviors in iterative workflows.
Figure summarizes the construction pipeline of SSCCode-Muli-67999 forming the raw material for a four-stage process: library-based filtering, code block extraction, runtime validation, and in- struction generation. The following subsections detail each stage.
3.1 CODE EXTRACTION FROM PUBLIC REPOSITORIES
We construct VisCode-Multe Mul6 by drawing on three complementary open source corpora: the- stack-v2 Lozhkov et al. 2024). svg rig-diagram?" (Rodriguez et al. 2025), and CoSyn-400k Yang al., 2025b Deitke et al., (024). These sources are complementary: the-stack-v2 provides large- scale, diverse code across many languages, capturing realistic visualization embedded in general programs; svg-diagrams contributes domain-specific SVG samples focused on diagram rendering; and CoSyn-40OK offers synthetic but cleanly structured visualization code spanning multiple lan- guages. Together, they cover both natural and synthetic usage across a wide range of languages and visualization styles. From each corpus, we extract code that invokes widely used visualization li- braries to capture real- world plotting practices. These sources provide the raw material for a pipeline with four stages: ubrary-based filtering for each language, code block extraction, runtime validation, and instruction generation.
Filtering and Code Block Extraction. For the-stack-v2 (oozhkov al., 2024), which contains approximately 900B tokens of code, we restrict our selection to two filtered subsets: stack-ed (A- lal et al., 2025) and sotuuck-----rrin---m---efff
stack-edu was curated from the-stack-v2 using classifier- based filtering strategy that retains only high-quality educational programming content. the-stack-v2-rett -raai--smoll-iidd
deauplldulle subset further filtered with heuristics and span- ning 17 programming languages. We first apply library-based filters on these subsets to identify ap- proximately 5.3M visualization code candidates Python, JavaScrips C++, TypeScr ipt, HIML, and R. Because most examples are embedded in broader program contexts rather than self- contained plotting examples, we use GPT-4. 1-mini (OpenAI) 2025) to extract standalone plotting blocks for each language. When the original code does not include data, inject mock inputs so that each block can execute in isolation. This structural cleaning preserves realistic visualization usage while remaining compatible with our runtime pipeline. After filtering and reconstruction, obtain roughly 900K candidate blocks.
For svg-diagrams, which contains 182K domain-specific SVG samples focused on diagrams from star-vector (Rodriguez et al. (002),, we apply regular-expression filtering to remove noisy data that lack width, height, or other essential components. This step retains about 79K candidate blocks.
For CoSyn-40OK, we select 408K visualization snippets across eight languages, including Python, HTML, LaTeX, SVG, Asymptote, Mermaid, Li 1yPondd, and vides synthetic but cleanly structured code spanning a wide range of styles, with well-rendered out- puts and consistent structure. Unlike the -22 Python and HTML code store logic and data separately, which requires reconstruction for runtime execution. For languages requiring reconstruc- tion, we rebuild runnable scripts by inserting lightweight annotations such as column headers and
CoSyn-400K pro-
hicollasse/sarrvccooyyyyyaaaaaa
hf. hww.lattsss//ugggggggeeee///llas
4

---

data to emulate realistic data loading. When necessary, we append missing plotting function calls to ensure that each language can execute within a Jupyter notebook environment.
Runtime Validation. To ensure executability, we run each candidate block in isolated Jupyter en- vironments. C++, JavaScript, and R are executed in dedicated kernels, while all other languages share the Python kernel. Each block is run with nbconvert using force strict filtering. We apply a fixed timeout and terminate runs that hang or enter infinite loops via a simulated keyboard interrupt. Only samples that execute successfully and generate valid image files that are non-monochrome and larger than 10KB are retained. This step produces 245K vali- dated plotting scripts from the-stack-v2, 43K from -ig-diagsmss, and 322K from CoSyn-400K, each paired with its rendered output. The detailed distribution is shown in Table 5
se to en-
Instruction Generation. To enable models to learn from both structural code features and ren- dered visual outputs. we generate natural language instructions for each validated example using GPT-4.1 (OpenAl 2023). This process ensures that supervision captures not only code syntax but also the semanties of the corresponding visualization.
To capture both data semantics and visual design, each instruction is structured into five components: (1) a brief setup description specifying the programming language and visualization libraries used; (2) a description of either the underlying data (for data-driven code) or the visible elements of the figure (for non-data-driven code); (3) a data block that either contains a copied data-generation line or two-row preview, left empty for non-data-driven cases; (4) high-level output description that conveys the intended visualization conceptually; and (5) a style description capturing colors, grid layout, and other visual properties. These components are assembled into fixed template:
[Output Description]
[Setup]
(Data/Visual Description]
"The data is shown below:" or None
[Data] or None
IStyle Description]
This format enforces consistent prompt structure across sources and languages, ensuring that mod- els receive a unified description of the visualization target, its data, and its stylistic attributes.
3.2 MULTI-TURN INSTRUCTION
DIALOGUES WITH EXECUTION FEEDBACK
VisCode-Multi-67KK further includes over 66K multi-turn dialogues from the Code-Feedbacl dataset (Zheng et al. [022]. These dialogues cover programming tasks in Python, HTMI, JavaScript.R, and other languages, with user instructions, model-generated code, and follow- up turns carrying execution feedback or revision prompts.
Although not tailored to visualization, they provide essential supervision for teaching models to revise faulty code based runtime signals and to reason over iterative interactions. We incorporate these dialogues into the instruction tuming corpus alongside single-turn samples from stack-edu, the-stack-22. svg-diagrams, and CoSyn-400K. This integration allows models practice both initial code generation and multi-turn refinement strategies.
VISPLOTBENCH: MULTI-LANGUAGE BENCHMARK FOR VISUALIZATION CODING AGENTS
VisPlotBench is a benchmark for evaluating visualization coding agents across eight languages. Unlike prior efforts that focus on single language specification style, VisPlotBench spans im- perative libraries, declarative grammars, markup-based formats, and symbolic notations, providing standardized protocol for assessing both initial code generation and multi-round self-debug.
5

---

Python
Vega-Lite
LilyPond
Mermaid
Generate a three- dimensional surface plot, the plot visualizes the relationship between three variables, X, and Z,
Task: Create an area chart to visualize the sum of counts over time, categorized by different series. The x-axis represents time in
Task: Generate a musical score for piano that presents analysis of J.S. Bach's piece "Wenn wir höchsten Noten sein"
Task: Generate Gantt chart visualize project timeline, illustrating tacks across different sections such "A section, "Critical
Style: The visual features
Style: The area segments are
Style: The staves
Style: The
visual consists
smooth, colorful
stacked on
spaced apart,
of horizontal
surface with gradient transitioning...
each other, each
with the right above the left hand. Notes
aligned with labeled
filled with palette
sections the left, each
Visual Cate.:
Visual Cate. Areas;
Visual Music;
Visual Cate, Diagramming: Subtype
Subtype: Surface
Subtype: ; Stacked- Area
Sublype Sheet Music
SVG
LaTeX
Asymptote
HTML
Generate a box plot display the distribution of data across live different categories. Each category is represented by separate...
Task: Generate schematic diagram of an electronic circuit that includes various components such as resistors, capacitors,
Task: Generate a 3D surface plot
Task: Generate polar area represent market share percentages of different smartphone includes...
representing: mathematical function defined by the cosine
sine the coordinates. surface is
chart Style: The chart is centered light gray background
Style: The visual consists of five colored boxes
Style: The
Style: Create colorful,
components are labeled with
grid like 3D
aligned horizontally, each with distinct color
respective
visualization
rainbow gradient applied to the
symbols and names, and
with title above it
Visual Cate. Distribution;
Diagramming: Subtype: Electrical Circuit
Cate.:
Visual :ate
Visual Radial Polar;
Subtype: Box-Plot
Subtype: Surface
Subtype : Radial Area
Figure 3: Overview of VisPlotBench. The benehmark covers eight visualization languages and con- tains 888 diverse visualization tasks, each combining a natural language instruction and rendered visual. Tasks are annotated with Visual category and a Subtype, spanning 13 categories in total.
4.1 OVERVIEW
Existing visualization benchmarks are narrow in scope: most cover a single language, few chart families, and iterative debugging. VisPiotBench fills these gaps with 888 tasks across eight languages and 13 Visual categories Figure 4). The taxonomy spans common families such as Bars, Lines, and Scatter, while adding rarely represented ones like Hierarchies, Music, and Networks & Flows. Each task combines a natural language instruction, executable code, and a rendered output, enabling execution-grounded evaluation. With its execute-render-score protocol and multi-round self-debug loop, VisPlotBench provides the first systematic benchmark for assessing visualization coding agents across languages and task types.
Table 1: Comparison with existing benchmarks. VisPlotBench provides executable, multi-language tasks with natural language instructions, rendered outputs, and standardized protocol for both initial code generation and multi-round self-debugging.
Benchmark
Coverage
Self-debug
Visual Category
Num
VisEval Chen 2024
Python
4
2,524
MatPlotBench Yang et al.
2024c
Python
11
100
nvBench (Luo el al. 2021
Vega-Lite
X
4
25,750
avBench 2,0 (Luo al. 2025
Vega-Lite
X
5
7,878
Text2Vis (Rahman al.
2025
Python
10
1,985
PandasPlolBench (Galimzyanov et al.
2024
Python
10
175
Pandasplo Ennacccc [Ni ct al.
2025
Python
10
175
VisPlotBench (ours)
languages
13
888
Table positions VisPlotBench among representative benchmarks across four dimensions: language coverage, visual categories, self-debug support, and dataset size. Earlier resources remain nar- row foc-focusing on Python or Vega-Lite, with limited chart types and no iterative debugging. VisCoder introduced self-debugging for PandasPlotBennds while VisPlotBench generalizes this to eight languages, expands coverage to 13 categories, including Hierarchies, Music, and Networks & Flows, and standardizes evaluation for systematic cross-language assessment.

---

4.2 DATA COLLECTION AND CURATION
We assemble 888 executable tasks from publicly available examples, library documentation, and high-quality code snippets across eight programming languages. The tasks span 13 Visual cate- gories and 116 Subtypes, covering common families such as Bars, Lines, and Seatter, as well as underrepresented ones including Hierarchies, Music, and Networks & Flows.
Each candidate script is executed in an isolated runtime with language-specific kernels or headless renderers. Tasks are retained only if execution succeeds and valid image is produced. We discard visually trivial outputs (e.g., near- wear-monochrome images) and remove duplicates by hashing rendered outputs and normalizing code. This process yields pool of verified code- image pairs compatible with our evaluation pipeline.
Annotators then review verified pairs, removing low-quality items such as unreadable or degenerate plots. Each remaining task is annotated with Visual category and Subtype from the shared taxon- omy shown in Table 7 with library-specific idioms added when appropriate. double-past review with conffict resolution ensures consistency across languages.
4.3 TASK CONSTRUCTION
Each VisPlotBench task extends the verified code-image pair with a structured natural language instruction. To ensure consistency across languages, we adopt five-part schema: Setup Plot Instruct + Data Instruct + Task Description + Style Description. This schema provides a unified template that reflects both the semantic intent and the stylistic requirements of each visualization.
Setup, Plot Instruct, and Data Instruct are authored separately for each language so that tasks cap- ture real usage, including syntax constraints, runtime notes, and data access conventions. Task Description and Style Description are generated with GPT-4.1 conditioned on the verified code and its rendered visual. The Task Description specifies the semantic intent and structural elements re- quired for correctness, while the Style Description summarizes perceptual attributes such as layout, annotations, label formatting, and color usage. Detailed authoring templates and generation prompts provided in Appendix
and
The final instruction is the concatenation of the five components, producing a unified input format across languages. This design enables coding agents condition natural language instructions paired with minimal data previews and generate executable code that satisfies both the semantic and stylistic requirements of the task.
4.4 EVALUATION PROTOCOT.
VisPlotBench adopts a standardized execute-render-scon pipeline. Each submission is executed an isolated runtime with language-specific kernels or headless renderers, subject to strict timeouts and log capture. The process outputs three artifacts: rendered image, execution log and metadata record, supporting reccution-groundee and judgment-based evaluation.
Evaluation metrics extend those of PandasPlotBench and VisCoder. Execution Pass Rate checks whether the code runs without error and produces valid visualization. Task Score measures in- struction compliance using LLM judge guided by semantic and structural rubrics, and Visual Score assesses perceptual similarity between generated and reference outputs. Both follow the GPT- based judging protocol of PandasPlodBench.
To assess iterative refinement, VisPlotBench includes a multi-round self-debug protocol. Unresolved tasks are revisited for up to three rounds, where the model receives the instruction, its prior code, and an excerpt of the execution log before producing a revision. The final score reflects the best attempt, mirroring real- world correction loops and enabling systematic evaluation of both baseline generation and feedback-drive recovery.
5
MAIN RESULTS
We evaluate both proprictary and open-source models on VisPlotBench to compare execution reli- ability across parameter scales, programming languages, and evaluation modes. Proprietary refer-
7

---

ences include GPT-4.1 O 2025 and its lighter variant 3PT--41-mini OOpenAl 2025 ) while open-source baselines include DeepSeek-Coor Coder (uuo et al. 2024b), CrepSeek-Codeer V2 (Zhu et al, 2024). Qwen2.5-Coder (Hui al., 2024), and VisCoder (Ni al. 2025). Our VisCoder2 models are trained on VisCode-Multi-67)
using Qwen2.5-Coder backhones at 3B, 7B, 14B, and 32B scales, full training and evaluation setup provided in Appendix A controlled ablation of training data sources is presented in Appendix
Table 2: Overall execution pass rate (%) selected models on the VisPlotBench benchmark. The best-performing model in each scale is shown in bold, and the second best is underlined.
Exec Pass
Python (196)
Vega-Lite (129)
LilyPond
Mermaid (131)
SVG
LaTeX
Asymptote (92)
HTML
Model
Overall
(55)
(65)
(112)
(108)
GPT-4.1 GPT-441 Debug
63.4
64.3
84.5
43.6
68.7
95.4
31.3
21.7
89.8
96.1
97.2
GPT 1.immi,1mmiii
58.9
64.8
84.5
16.4
51.9
95.4
29.5
23.9
86.1
GPT-4.1-mini Self Debug
56.4
100.0
3B Scale
DeepSeck-Codr-11 -.3-Ins.
32.3
29.1
53.5
30.9
63.4
7.7
13.0
36.1
Qwen2.5-Coder-311 Boder--B-Inn
45.8
34.2
68.2
3.6
74.1
75.4
17.9
18.5
62.0
VisCoder-3B
56.1
45.4
83.7
21.8
75.6
76.9
23.2
30.4
79.6
VisCoder2-3B
67.7
56.1
83.0
50.9
76.3
87.7
36.6
62.0
93.5
VisCoder2-3B Debug
84.5
76.3
87.7
94.4
7B Scale
DeepSck-Coddr-6725
46.4
39.3
79.8
7.3
91.6
96.9
18.8
0.0
22.2
Qwen2.5-Coddr-77-lmss
41.3
76.0
5.5
77.9
92.3
25.9
13.0
64.8
VisCrder:7R
57.2
58.2
71.3
23.6
77.1
93.9
25.9
17.4
75.9
VisCoder2.7B
70.9
64.8
83.0
69.1
78.6
96.9
39.3
64.1
82.4
VisCoder2-7B Self Debug
76.4
77.0
84.5
72.7
84.7
96.9
42.9
70.7
84.3
14B Scale
DeepSeck-Codes -2-er--V--Lite-nnss
55.3
47.5
75.2
49.1
69.5
93.9
29.5
20.7
64.8
Qwen2.5 Coder-14BBBn
98.5
ViCCoder2144B VisCoder2-14B Dehug
72.1
65.3
93.0
54.6
81.7
89.2
42.0
56.5
90.7
94.4
32B Scale
DeepSeek Coder Ins.
$4.3
58.2
90.7
30.9
87.0
92.3
24.1
21.7
12.0
Qwen2.5-Codee-322 Codeer-3BB-nng
57.5
50.5
83.0
30,9
71.0
93.9
29.5
17.4
78.7
ViCoode22332B VRsCoder2-32B- Self Debug
73.1
65.3
94.6
56.4
87.0
81.5
42.9
58.7
91.7
82.4
81.6
96.1
69.1
90.1
86.2
61.6
71.7
93.5
5.1 OVERALL COMPARISON
summarizes execution pass rates for all models across eight visualization languages and overall averages. The following analysis examines differences between proprietary and open-source models, variation across languages, and the relative advantages of VisCoder2 under both default and self-debug evaluation modes.
Table
Proprietary Models Remain Stronger. GPT-4. I achieves 63.4% overall, the highest among refer- ence models, and GPT-4.1 1.4.-mmmnii follows closely. Both perform strongly standardized declarative or markup languages such as Vega-Lite SVG, and HTML, all above 84%. In contrast, instruction- tuned open-source models remain far behind. At the 7B scale, Qwen2.5-Codes reaches only 51. 11.2% overall, with fewer than 30% on LaTeX X and just 5.5% on LilyPonre Previous VisCoder variants improve Python performance but fail to generalize across languages. These results underline the substantial gap between proprietary and open-source models.
Cross-Language Variation. Performance differs sharply across visualization languages. Vega -iite and HTML are close to saturation for most models, while Python shows steady gains with scale. By contrast, symbolic and compiler-dependee
languages remain the most difficult. Even GPT-4.1 achieves less than 45% LilyPond and under 25% As ysypptor ote, and open-source baselines fall much lower. This uneven landscape highlights that progress on symbolic grammars is the key bottleneck for reliable multi-language visualization.
8

---

VisCoder2 Advantage. Across all scales, VisCoder2 consistently outperforms size-matched open-source basclines. At 32B, it improves overall execution pass rate by approximately 15 points compared with Qwen2.5-Coder and reaches parity with GPT-4.1. The only consistent shortfall is on SVG, where VisCoder2 trails the strongest baseline by over 10 points. Overall, VisCoder2 is the first open-source model to match proprietary reliability executable visualization tasks.
Effect of Self-Debug. Iterative correction consistently improves execution reliability across model families and scales. Proprietary models benefit strongly, and VisCoder2 follows the same trend: larger scales, overall execution rises by nearly ten points when self-debugging is enabled. The effect is especially pronounced for symbolic and cempiler-dependent languages such as Lil LilyP yndd, LaTeX, and Asympt where fragile syntax or compilation errors dominate. Self-dcbugging enables the model to repair these shallow but frequent failures, allowing models to resolve previously intractable failures into valid outputs. This demonstrates that feedback driven refinement is not just marginal improvement but critical mechanism for tackling the hardest visualization languages.
5.2 TASK AND VISUAL SCORE ANALYSIS
We analyze Task Score and Visual Score on three representative languages that highlight differ- ent behaviors, as shown Table 3/ LaTeX illustrates execution-semantic mismatch, LilyPond shows the largest gains symbolic grammars, and SVG exposes model-library sensitivity where semantic and perceptual signals diverge. Results for all languages and scales are provided in Ap- pendix G
Table 3: Performance of selected languages on the VisPlotbench benchmark. For each model, we report (1) execution pass rate (Exee Pass), (2) mean visual and task scores (Mean), and (3) the proportion of samples scoring at least 75 (Good). The best-performing model each scale shown in bold, and the second best underlined.
LaTeX (112)
LilyPond (55)
SVG (65)
Model
Exec
Mean
(5
Exec
Mean
G2
Exec
Mean
Goodf (7))
vis
Pass
task
GPT-411
31.3
18
26
13%:
25%
43.6
14
38
5%
36%
95.4
45
92
14%.
94%%
GPT-4.1 Self Debug
66.1
38
25%
51%
63.6
54
5%
53%
96.9
14%
95%
1-T-4.1-mini
29.5
21
18%
25%
16.4
12
0%
11%
95.4
86
11%
86%
GPT-4.1-mii Self Dehug
58.9
35
23%
49%
56.4
42
0%
35%
96.9
42
88
11%
88%
Tr"
75
66%"
5.5
"0"
"0%
4%
92.5
25
0%
40%
VisCoder2-7B
39.3
15
23
6%
1.5%
69.1
16
52
2%
45%
96.9
34
73
3%
62%
VisCoder2-7B- Debug
6%
72.7
55
96.9
Qwen2 3-2-add--38---nnniee
29.5
14
25
9%
21%
30.9
5
22
2%%
T8%6
93.9
34
88
3%
75%
VisCoder2-32B
42.9
20
11%
34%
56.4
39
2%
27%
81.5
33
11%
63%
VisCoder2-32B + Self Debug
61.6
28
14%
42%
69.1
16
48
2%
35%
86.2
34
71
11%
66%.
LaTeX: Execution-Semantte Mismatch. Models often capture the intended structure of figure but fail to compile reliably. For example, GPT-4.1 improves from 31.3% to 66. 1..1% 1% execution pass rate with Self-Debug, while task scores remain around 50 even when execution fails. VisCoder2 raises execution and task scores compared with baselines, but compilation errors remain frequent. This pattern indicates that semantic alignment does not always translate into successful rendering.
LilyPond: Symbolic Grammar Gains. VisCoder2 delivers the clearest advantage on symbolic languages. At 7B, Qwen2.5-Coder executes only 5.5% of tasks, while VisCoder2 reaches 69. % and further improves with Self-Debug. The proportion of examples with task scores above 75 also increases by more than tenfold. These results show that targeted coverage of symbolic grammars in Gooodde-Muli-67999 translates directly into reliable generation and semantic adherence.
SVG: Sensitivity to Rendering Libraries. Execution success is high across most models, yet vi- sual scores lag behind task scores. For instance, GPT-4.1 with Belf-Debug achieves 95.4% execution and task score near 90, but the average visual score is below 50. VisCoder2 performs competitively but trails Qwen2.5 on execution at larger scales (81.5% versus 93.9% at 32B). These discrepancies suggest that evaluation on SVG is strongly influenced by library-speciffe rendering details rather than semantic understanding alone.

---

5.3 ERROR ANALYSIS
To better understand failure modes across languages, we analyze execution errors before and after self-debug. Many language-speccffcc exceptions, such PunctionSignatureErroo in Asymptote or MaroupError in Li LilyPond, were merged into four broader categories for clarity: Structural Errors (syntax or parsing), Type&Interface Errors (invalid calls or arguments), Semantic Data Errors (mismatched variables or values), and Runtime / Environment Errors (renderer or package issues). Representative results for VisCoder2-32B are shown in Table 4 with full breakdowns in in/pppendix
Table 4: Representative enror transitions for VisCoder2-32B across eight visualization languages. Each cell shows error counts from initial failure to the final self-debug round (X + Y). A dash indicates the error type does not occur for that language.
Error Category
Python
Vega-Lite
LilyPond
Mermaid
SVG
LaTeX
Asymptote
HTML
Structural Errors
1 1-+1
2
14 10
12
8->7
10 +
9-3
Type & Interface
13 3
2
5-2
Semantic / Data
-
28 +
23
15 -
Runtime Env.
2
27
6
8
3 3
Effective recovery on structural and interface errors. Self-debug reduces shallow errors such as missing tokens or invalid arguments across multiple languages. For example, Python interface errors fall from 13 to 3 (Figure 6), and structural errors in LilyPond decrease from 14 10 (Figure 12). Mermai di and As ymsptt ot show the same trend, with syntax and function signature errors shrinking after correction (Figure 15). These cases benefit from explicit diagnostic traces, making them relatively easy to fix through ieerttvve feedback.
Persistent failures in semantic and runtime errors. Errors involving semantics or execution environments remain difficult to resolve. In LaTeX, undefined variables decrease only slightly (28 to 23), and As Asymptote ote variable mismatches improve only marginally (15 to 11) (Figure 24). Renderer failures such Vega-Lite te rendering errors (2 2) and HTML request failures (3 to 2) often persist across all rounds (Figure 28). These errors require deeper reasoning over symbolic grammars and runtime contexts, which current self-debug protocols cannot fully capture. Symbolic languages and renderer-sensitive environments therefore remain the dominant bottlenecks, pointing the need for grammar-awar training objectives and more robust runtime integration.
CONCLUSION
Reliable visualization coding goes beyond single-pass generation: it requires competence across diverse languages and the ability to refine outputs iteratively in response to execution feedback. Existing datasets and benchmarks lack these capabilities, limiting progress toward practical agents for real-world workflows.
We addressed these gaps through three contributions. First, introduced MisCode-Multi-679K large-scale instruction tuning dataset that unifies executable visualization code across twelve lan- guages with multi-turn feedback dialogues. Second, we built VisPlotBench, benchmark covering cight visualization languages under standardized execute-render-sowe protocol, with tasks span- ning 13 categories and 1 116 subtypes. Third, we trained the VisCoder2 model family on these re- sources, showing that it consistently outperforms open-source baselines and approaches proprietary models in execution reliability.
Our experiments highlight two insights. Broad multi-language coverage is essential: symbolic and compiler-dependert languages such as I. Tax, Li lylyd and Asymptote remain challenging, yet progress on them is decisive for true generalization. Iterative refinement further proves indis- pensable: self-debug delivers large gains across models, especially on languages where structural and semantic errors common.
VisPlotBench, and VisCoder2 establish the first systematic framework for building and evaluating visualization coding agents. We believe these resources accelerate the development of agents that are not only multi-language but also capable of realistic correction loops, pushing toward reliable coding assistants for data analysis, reporting, and beyond.
Taken together,
10

---

ETHICS STATEMENT
This work complies with the ICLR Code of Ethics. this study, no human subjects or animal experimentation were involved. All datasets used were accessed and used under their licenses/terms of use, in line with applicable usage guidelines and with no infringement of privacy. We took steps minimize unfair bias or discriminatory effects throughout the research process. No personally identifiable information was processed, and no experiments were conducted that could raise privacy or security risks. We remain committed transparency and research integrity across the entire project lifecycle.
REPRODUCIBILITY STATEMENT
We have made every effort to ensure that the results presented in this paper are reproducible. We re- lease all prompts used construct the training datasets Appendix E. the full processing pipeline applied to raw sources, and the prompts and instructions used in building the VisPlotBench bench- mark in Appendix E.2 | E.3 setup in Appendix A
We also provide detailed description of the experimental
In addition. all datasets used (stack-edu, tle-stackt-2-traiinsmo-- svg-diagrams, and Code-Feedback) in constructing VisCode-Multi-69h9 are publicly available, as described in insubsection 3.1 We will open-source our complete training and evaluation codebase, along with all trained model weights after publication. This release will include comprehensive documentation and usage examples to support future research and enable direct comparison with our results.
We believe these measures will enable other researchers to reproduce our findings, trace our dataset construction pipeline, and extend our work in future studies.

---

REFERENCES
Loubna Ben Allal, Anton Lozhkov, Elie Bakouch, Gabriel Martín Blázquez, Guilherme Penedo, Lewis Tunstall, Andrés Marafioti, Hynek Kydlfček, Agustín Piqueres Lajarin, Vaibhav Srivastav, Joshua Lochner, Caleb Fahlgren, Xuan-Son Nguyen, Clémentine Fourrier, Ben Burtenshaw, Hugo Larcher, Haojun Zhao, Cyril Zakka, Mathieu Morlon, Colin Raffel, Leandro von Werra, and Thomas Wolf. Smollm2: When smol goes big data-centric training of small language model, 2025. URL httttt::///aaatte http:///wwwwww.../aaaaossss www.ooog//a... 2502. 02737
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 on code. arXiv preprint wrXiv:2107.03377 2021.
Nan Chen, Yuge Zhang, Jiahang Xu, Kan Ren, and Yuqing Yang. Viseval: A benchmark for data visualization in the era of large language models. IEEE Transactions on Visualization and Com- puter Graphics, 2024.
Xinyun Chen, Maxwell Lin, Nathanael Schärli, and Denny Zhou. Teaching large language models to self-debug. arXiv preprint arXiv:2304.051/28, 2023.
Matt Deitke, Christopher Clark, Sangho Lee, Rohun Tripathi, Yue Yang, Jae Sung Park, Moham- madreza Salehi, Niklas Muennighoff, Kyle Lo, Luca Soldaíni, et al. Molmo and pixmo: Open weights and open data for state-of-the-art multimodal models. ArXiv preprint, abs/2409. 2024. URL
Victor Dibia. Lida: tool for automatic generation of grammar-agnostic visualizations and info- graphics using large language models. ArXiv preprint, abs/2303.02921 2023. URL https:
//arxiv.ogg/abli aa/aab////33../////// 02927
Nuno Fachada, Daniel Fernandes, Carlos M. Fernandes, Bruno D. Ferreira-Saraiva. and João P. Matos-Carvalho. Gpt-4.1 sets the standard in automated experiment design using novel python libraries. arXiv preprint arXiv:2508.0003 000333 2025.
Timur Galimzyanov, Sergey Titov, Yaroslav Golubev, and Egor Bogomolov. Drawing pandas: A benchmark for Ilms in generating plotting code. ArXiv preprint, abs/2412.02764, 2024. URL
httts://aaxiv. httpr//abb/2212...22 2476.02764
Kanika Goswami, Puneet Mathur, Ryan Rossi, and Franck Dernoncourt. Plotgen: Multi-agent 11m- based scientific data visualization via multimodal feedback. arXiv preprint arXiv:2502.00988, 2025.
Anastasiia Grishina, Vadim Liventsev, Aki Härmä, and Leon Moonen. Fully autonomous program- ming using iterative multi-agent debugging with large language models. ACM Transactions Evolutionary Learning, 5(1):1-37, 2025.
Daya Guo, Qihao Zhu, Dejian Yang, Zhenda Xie, Kai Dong, Wentao Zhang, Guanting Chen, Xiao Bi. Yu Wu, YK Li, et al. Deepseck-coder, When the large language model meets programming- the rise of code intelligence. ArXiv preprint, Abs/2401.14196. 2024a. URL httpt:://araattt org/ atg/abs// 2401. 14196
Daya Guo, Qihao Zhu, Dejian Yang. Zhenda Xie, Kai Dong, Wentao Zhang, Guanting Chen, Xiao Bi, Yu Wu, YK Li, et al. Deepseek-coder: When the large language model meets programming- the rise of code intelligence. arXiv preprint 2rXiv:2401. 14196, 2024b.
Binyuan Hui, Jian Yang, Zeyu Cui, Jiaxi Yang, Dayiheng Liu, Lei Zhang, Tianyu Liu, Jiajun Zhang, Bowen Yu, Kai Dang, et al. Qwen2. 5-coder technical report. ArXiv preprint, abs/2409. 12186, 2024. URL htttttt://aaiiiiiie http://rwwivv..rg///////////////
12186
Carlos E Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kexin Pei, Ofir Press, and Karthik Narasimhan. Swe-bench: Can language models resolve real-world github issues? arXiv preprint arXiv:2310.06770, 2023.
12

---

Bozheng Li, Miao Yang. Zhenhan Chen, Jiawang Cao, Mushui Liu, Yi Lu, Yongliang Wu, Bin Zhang, Yangguang Ji, Licheng Tang, et al. Opusanimation: Code-based dynamic chart generation. arXiv preprint ar arXiv:2510.0334/1 2025a.
Hao Li, Haoxiang Zhang, and Ahmed Hassan. The rise of ai teammates in software engineering (se) 3.0: How autonomous coding agents are reshaping software engineering. arXiv preprini arXiv:2507. 15003, 2025b.
Jierui Li, Hung Le, Yingbo Zhou, Caiming Xiong, Silvio Savarese, and Doyen Sahoo. Code- tree: Agent-guided tree search for code generation with large language models. ArXiv preprint,
abs/2411.04322 2024. URL BtLphtss:///xxae http://wwxix..raaaaaa/aa/aa/a/aa bbrgg/abs/2a 2411. 04329
Yujia Li, David Choi, Junyoung Chung, Nate Kushman, Julian Schrittwieser, Rémi Leblond, Tom Eccles, James Keeling, Felix Gimeno, Agustin Dal Lago, et al. Competition- code generation with alphacode. Science, 378(6624):1092-119999 2022.
Anton Lozhkov, Raymond Li, Loubna Ben Allal, Federico Cassano, Joel Lamy-Poiries Nouamane Tazi, Ao Tang, Dmytro Pykhtar, Jiawei Liu, Yuxiang Wei, et al. Starcoder 2 and the stack v2: The next generation. arXiv preprint arXiv:2402. 19173, 2024.
Tianqi Luo, Chuhan Huang, Leixian Shen, Boyan Li, Shuyu Shen, Wei Zeng, Nan Tang, and Yuyu Luo. nvbench 2.0: A benchmark for natural language visualization under ambiguity. arXiv preprint arXiv:2503. 12880, 2025.
Yuyu Luo, Jiawei Tang, and Guoliang Li. nvbench: A large-scale synthesized dataset for cross- domain natural language to visualization task. arXiv preprint arXiv:2112.12928 2021.
Aman Madaan, Niket Tandon, Prakhar Gupta, Skyler Hallinan, Luyu Gao, Sarah Wiegreffe, Uri Alon, Nouha Dziri, Shrimai Prabhumoye, Yiming Yang, et Self-refine: Iterative refinement with self-feedback. Advances in Neural Information Processing Systems, 36:46534 46544434446594, 2023.
Niklas Muennighoff, Qian Liu, Armel Zebaze, Qinkai Zheng, Binyuan Hui, Terry Yue Zhuo, Swayam Singh, Xiangru Tang, Leandro von Werra, and Shayne Longpre. Octopack: Instruc- tion tuning code large language models. arXiv preprint arXiv:2308.07124 2023.
Yuansheng Ni, Ping Nie, Kai Zou, Xiang Yue, and Wenhu Chen. Viscoder: Fine-tuning lims for executable python visualization code generation. arXiv preprint arXiv:2506.033300 2025.
OpenAl. Introducing gpt-4.1 in the api. https://oeeni..com//nnewvvggg// 2025. URL https:
7/openai, com http//iiexxxxppp 4-rtt-4117 4-17
Mizanur Rahman, Md Tahmid Rahman Laskar, Shafiq Joty, and Enamul Hoque. Text2vis: A chal- lenging and diverse benchmark for generating multimodal visualizations from text. arXiv preprint arXiv:2507.19965 2025.
Maxime Robeyns, Martin Szummer, and Laurence Aitchison. A self-improving coding agent. arXiv preprint arXiv:2504. 15228, 2025.
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. arXiv preprint arXiv:2312./15556 2025.
Arvind Satyanarayan, Dominik Moritz, Kanit Wongsuphasawat, and Jeffrey Heer. Vega-lite: A grammar of interactive graphics. IEEE transactions visualization and computer graphics, 23 (1):341-350, 2016.
Wonduk Seo, Seungyong Lee, Daye Kang, Zonghao Yuan, and Seunghyun Lee. Vispath: Automated visualization code synthesis via multi-path reasoning and feedback-driven optimization. ArXiv preprint, abs/2502. 11140, 2025, URL
http://wwwi.rrr///////22./2/ org/ abs http://aa/225221221 2114
Qiushi Sun, Jingyang Gong, Yang Liu, Qiaosheng Chen, Lei Li, Kai Chen, Qipeng Guo. Ben Kao, and Fei Yuan. Januscoder: Towards a foundational visual- prourammroaammtticc interface for code intel- ligence. arXiv preprint arXiv:2510.238 2025.
13

---

Chengyue Wu, Yixiao Ge, Qiushan Guo, Jiahao Wang, Zhixuan Liang, Zeyu Lu, Ying Shan, and Ping Luo. Plot2code: A comprehensive benchmark for evaluating multi-modal large language models in code generation from scientific plots. ArXiv preprint, abs/2405.07990, 2024. URL
httpss / /ttps///rxvv.. wttp .07990
Liwenhan Xie, Chengbo Zheng, Haijun Xia, Huamin Qu, and Chen Zhu-Tian. Waitgpt: Monitor- ing and steering conversational I1m agent in data analysis with on-the-fly fly code visualization. In Proceedings of the 37th Annual ACM Symposium on User Interface Software and Technology, pp-
1-14, 2024.
Cheng Yang, Chufan Shi, Yaxin Liu, Bo Shui, Junjie Wang, Mohan Jing, Linran Xu, Xinyu Zhu, Siheng Li, Yuxiang Zhang, et al. Chartmimic: Evaluating Imm's cross-modie reasoning capability via chart-to-code generation. arXiv preprint arXiv:2406.09%9 09961, 2024a.
John Yang. Akshara Prabhakar, Karthik Narasimhan, and Shunyu Yao. Intercode: Standardizing
and benchmarking interactive coding with execution feedback. Advances in Neural Information Processing Systems, 01122382-223555 2023.
John Yang, Carlos E Jimenez, Alexander Wettig, Kilian Lieret, Shunyu Yao, Karthik Narasimhan, and Ofir Press. Swe-agent: Agent-computer interfaces enable automated software engineering. Advances in Neural Information Processing Systems, 37:50528-50652 2024b.
Yue Yang, Ajay Patel, Matt Deitke, Tanmay Gupta, Luca Weihs, Andrew Head, Mark Yatskar, Chris Callison- Callison-Burch, Ranjay Krishna, Aniruddha Kembhavi, and Christopher Clark. Scaling text- rich image understanding via code-guided synthetic multimodal data generation. arXiv preprint arXiv:2502. 14846, 2025a.
Yue Yang, Ajay Patel, Matt Deitke, Tanmay Gupta, Luca Weihs, Andrew Head, Mark Yatskar, Chris Callison-Buus Burch, Ranjay Krishna, Aniruddha Kembhavi, et al. Scaling text-rich image under- standing via code-guided synthetic multimodal data generation. ArXiv preprint, 1ess2502..14466 2025b. URL /estps:///rxivee
abs///bbs/2222 4446
Zhiyu Yang. Zihan Zhou, Shuo Wang, Xin Cong, Xu Han, Yukun Yan, Zhenghao Liu, Zhixing Tan, Pengyuan Liu, Dong Yu, al. Matplotagent: Method and evaluation for llm-based agentic scientific data visualization. ArXiv preprint, abs/2402. 11555, 2024c. httpp::/:
org/abs/ 2402. 11453
Huaye Zeng, Dongfu Jiang, Haozhe Wang, Ping Nie, Xiaotong Chen, and Wenhu Chen. Acecoder: Acing coder rl via automated test-case synthesis. ArXiv preprint, abs/2502.01718, 2025. URL
attps://arxivv org/ abs/ 25022002277
Kai Zhang, Xiangchao Chen, Bo Liu, Tianci Xue, Zeyi Liao, Zhihan Liu, Xiyao Wang, Yuting Ning, Zhaorun Chen, Xiaohan Fu, et al. Agent learning via early experience. arXiv preprint arXiv:2510.08558, 2025.
Yuze Zhao, Jintao Huang, Jinghan Hu, Xingjun Wang, Yunlin Mao, Daoze Zhang, Zeyinzi Jiang, Zhikai Wu, Baole Ai, Ang Wang, Wenmeng Zhou, and Yingda Chen. Swiftra scalable lightweight infrastructure for fine-tuning, 2024. https: / /aaxiv.vvv.......//aaaaaaaaaavv. org/ wtwp/as/////oooooooo///////.aaea 2408 05517
Tianyu Zheng, Ge Zhang, Tianhao Shen, Xueling Liu, Bill Yuchen Lin, Jie Fu, Wenhu Chen, and Xiang Yue. Opencodeinteerreter:: Integrating code generation with execution and refinement. ArXiv preprint, abs/2402.146553 2024. httll/ttss/:aax......a
Qihao Zhu, Daya Guo, Zhihong Shao, Dejian Yang. Peiyi Wang, Runxin Xu, Y Wu, Yukun Li, Huazuo Gao, Shirong Ma, al. Deepseek-coder--V:: Breaking the barrier of closed-source models in code intelligence. arXiv preprint arXiv:2406. /931, 2024.
14

---

Table of Contents in Appendix
Experiment Setup
17
Training Data Distribution
17
Ablation Study
18
Limitations
18
Prompt Used and Instruct Design
19
E.1 Prompt Used in VisCode-Multi-699K
19
Prompt Used in VisPlotBench
22
Instruct Design in VisPlotBench Evaluation
23
laxonomy of Visual Categories and Subtypes
27
Breakdown Main Results
29
Python, Vega-Lite & Lilypond
29
G.2
Mermaid, SVG & LaTeX
30
G.3
Asymptote & HTML
Breakdown Self-Debug Results
32
H.1
Python & Vega-Lite
32
H.2
LilyPond & Mermaid
33
SVG & LaTeX
34
Asymptote & HIML
35
Breakdown Error Type Results
36
Python
36
I.2
Vega-Lite
36
1.3
Lilypond
36
Mermaid
37
1.5
SVG
37
166
LaTeX
37
L.7
Asymptote
38
8
HTML
38
J
Additional Experimental Results Discussions
39
J.1
Evaluation Settings
Additional Evaluation Results
39
J.3
Deep Analysis of Self- Behavior and Task/Visual Score
40
15

---

J.4
Quantitative Analysis of
43
Case Study
46
K.1
Python: Successful Generation
46
K.2
Python: Self-Debug Recovery
47
K.3
Python: Self- Failed
48
K.4
Vega-Lite: Successtul Generation
49
K.5
Vega-Lite: Self-Debug Recovery
50
K.6
Vega-Lite: Self-Debug Failed
K.7
Lilypond: Successful Generation
52
K.8
Lilypond: Self-Debug Recovery
53
K.9 Lilypond: Self-Debug Failed
54
Mermaid: Successful Generation
55
K. 11 Mermaid: Self-Debug Recovery
56
K. 12 Mermaid: Self-Debug Failed
57
K. 13 SVG: Successful Generation
58
K. 14 SVG: Self-Debug Recovery
59
K.15 SVG: Self-Debug Failed
60
16 LaTeX: Successful Generation
61
K.17 LaTeX: Self-Debug Recovery
62
K.18 LaTeX: Self-Debug Failed
63
K. 1.19
Asymptote: Successful Generation
64
K.20
Asymptote: Self-Debug Recovery
65
K.21
Asymptote: Self-Debug Failed
66
K 22
HTML: Successful Generation
67
K.23
HTML: Self-Debug Recovery
68
K.
24 HTML: Self-Debug Failed
69
LLM Usage
70
16

---

A EXPERIMENT SETUP
(Hui et al. 2024) at four parameter scales: 3B, 7B, 14B, and 32B. This setup allows assess the generalizability of VisCode-Multi-699K across capacities. All models are trained for epochs with a learning rate of 5 x 10 a warm-up ratio 0.05, and a cosine scheduler. We perform full-parameter tuning in bfloat 6 precision on 8XH100 GPUs with total batch size of 64, using the SWIFT infrastructure (Zhao et al., (024))
Training Setup. We fine-tune
Evaluation Setup. All evaluations are conducted on VisPlotBench using the standardized proto- col in Section 4.4 We report three metries: Execution Pass Rate, Task Score, and Visual Score, capturing executability, semantic alignment, and perceptual similarity. Models are also tested under the self-debug protocol with up three rounds of correction based on execution feedback, assessing both baseline generation and recovery through iterative refinement.
B TRAINING DATA DISTRIBUTION
Table 5: Distribution visualization code samples across languages and sources. The final column reports per-language totals, and the final row reports per-source totals. [Back to Appendix Contents]
Language
CoSyn-400K
the-stack-v2
svg-diagrams
Total
Python
66,052
120,902
186,954
HTML
75,315
59,915
135,230
LaTeX
124,039
124,039
SVG
2,693
43,928
46,621
JavaSeript
28,807
28,807
Asymptote
22,539
22,539
C++
16,776
16,776
13,437
13,437
Mermaid
13.381
13,381
LilyPond
12,093
12,093
Vega-Lite
6,790
6,790
TypeScript
6,315
6,315
Total
322,902
246,152
43,928
612,982
17

---

C ABLATION STUDY
To disentangle the contribution each data source, we conduct a controlled ablation study using the base model. Separate models are fine-tuned on individual subsets of The Stwssttcck-ee -V, CoSyn, StarVector, and Code Fedde-Feedbcck under the same instruction- tuning setup as the full configuration. We report execution pass rates on VisPlotBench in both default and self-debug modes, with comparisons to the untuned Qwen2.5-Coder-77 baseline and the full
Qwen2.5-Coder-1
model (Table 6).
Table 6: Execution pass rates of (wen2.5-Coder-7B models trained on individual subsets of VisCode-Mulli-6990 Each model is evaluated under both default (X) and self-debug (V) modes.
Model
Self-Debug Overall
Python
Vega-Lite
Lilyoond
Mermaid
SVG
LaTeX
Asymptote
HIML
Qwen2.5 Dwee2255Codee:7.. Coder-BB-Ins
51.2
41.3
76.0
13.0
64,8
59.0
61.7
77.5
79.4
92.3
30.4
20.7
76.9
49.0
81.4
69.5
84.66
0.9
194
64.8
The Ttc-Stuck-V222166
56.5
58.2
83.7
10.9
73.3
84.6
31.3
18.5
65.7
CoSyn.323K
59.
25.5
83.7
65.5
57.3
100.0
36.6
36.5
91.7
62.2
31.1
84.5
69.1
61.1
100.0
38.1
62.0
91.7
40.1
43.4
72.1
5.5
67.9
16.9
10.7
13.0
47.3
Vortorttr44KK
44.5
53.6
73.6
7.3
70.2
13.4
19.6
50.0
55.2
17.4
Code-Foclbuck-6K
63.1
62.2
80.6
21.8
81.7
92.3
38.4
23.9
83.3
Full 67C
76.4
70.9
64,8
83.0
69.1
78.6
84.7
96.9
39.3
64.1
70.7
82.4
84.3
Natural Synthetic. Training The-Stack-V2 alone yields limited improvements and even degrades symbolic languages such as LaTeX, reflecting the sparsity of clean visualization signals in general-purpose code. By contrast, CoSyn delivers large gains on symbolic and grammar-sensitive languages, with execution rates on LilyPond and Asymptote rising by over 60 points compared the baseline. This contrast shows that large-scale synthetic data provides valuable structural coverage that complements natural code.
Domain vs. Multi-turn. The StarVector subset contributes primarily to SVG but too small to improve overall performance. In contrast, Code-Feedback does not drastically shift baseline pass rates but produces consistent gains under self-debug, lifting overall execution from 55.2% to 63.1%. This demonstrates that multi-turn dialogue data provides critical supervision for recovery through iterative correction, rather than improving one-shot generation.
Full Dataset Synergy. Combining all subsets yields the strongest model. With VisCode-Mun 679K, the overall pass rate reaches 70.9% in default mode and 76.4% with self-debug, substantially surpassing both the untuned baseline and any single-source variant. These results confirm that dataset's 's diverse
natural, synthetic, domain-specifie, and iterative data-in essential for building robust multi- language visualization coding agents.
D LIMITATIONS
VisCode-Mulii-o 679K and VisPlotBench take a step toward more reliable multi multi-language visualiza- tion coding agents, but several limitations remain. First, the training corpus imbalanced across lan- guages: high-resource ecosystems such as Python and Vega-Lite t are well represented, whereas symbolic and domain-specifie languages have far fewer samples, which may bias models toward dominant languages. Second, VisPlotBench currently covers eight visualization languages; extend- ing it to additional frameworks and languages would provide broader coverage and enable more comprehensive evaluation.
18

---

E PROMPT USED AND INSTRUCT DESIGN
In this section, we present the prompts used during the construction of VisCode-Multi-699K and VisPlotBench.
E.1 PROMPT USED IN VISCODE-MULTI-6799
Code Extraction Prompt
Model: GPT-4.1-mini
# LANGUAGK= [Python, JavaScript, TypeScri pt, C++, R, HTMI]]
# HULLET ={
Python: Write a single -py file. No external files or internet access. Use helper libraries only truly required for the chart.
JavaScript: Write single is file. Add necessary imports for any required libraries. TypeScript: Write single file. Use ES6 module syntax (import/export). The code should not require module bundler.
C++: Write a single cpp file with main (). Program must exit automatically. Do not load external assets. If linking is needed, add one build command as comment.
Write single R file. Use library (Library). Create mock data if needed. No external files, HTML: Write single HTML file. Include <script> tag and the needed DOM element for the chart. code runs in browser.
}
are (LANGUAGE) visualization code extraction agent.
Given LANGUAGE) code snippet and the used library, your task is to extract a minimal yet runnable snippet that reflects how the library is actually used for visual output.
[LANGUAGE]
Guidelines: Keep only the logic needed for the visual output; remove unrelated code. If the library is not used for rendering/drawing//loee prwtwin//pootting in Code, return "null".
If inputss/asssss are missing, create semantically relevant mock data that makes the output meaning- ful.
Preserve the main intent, API pattern, key parameters, and style* from the original code; simplify when it improves clarity, and avoid adding new wrappers or layers that are not essential.
Make the visual output clear and professional: use appropriate visual cues (titles/ahelk/legends when applicable); keep layout readable.
Ensure the snippet runs standalone in minimal environment and terminates automatically (no user input required).
If the library is unused or information is insufficient, return "null".
Used Library: fused_libs}
Code: {code}
19

---

Instruct Generation Prompt: the-stack-v2& svg-diagrams
Model: GPT-4.1
# LANGUACE= [Python, JavaScript, TypeScript, C++, R, HTML, SVC]
You are given a {LANGUAGE] code snippet that renders an image. A rendered image of the resulting output is provided at the end. Your task is to infer and clearly descrihe the purpose, structure, and style of this image.
Break your response into following five parts:
1. Setup (state the language and rendering context, including any tools or libs implied).
2. Visa/l Description
If the code is data-driven; summarize the inputs the code relies on and any shaping operations.
If the code is data-driven, summarize the visible content the image.
3. Data Generation (the geterreettttonnn lines copied verbatim, or "None" if not applicable).
4. Output Description (omit language constructs; start with "Generate..." " or "Create..", and describe
the final image conceptually).
5. Style Description (describe appearance and layout without naming language constructs).
Each part must start on a new line, numbered through 5. Use plain text only; no markdown.
Code:
{code}
Image:
Instruct Generation Prompt: CoSyn-400K
Model: GPT-4.1
# FOR DATA-DRIVEN LANGJAGES
# LANGUAGE= [Python, Vega-Li te, HTML, Lilydnnd, Mermaid
You are given (LANGUAGE) code snippet that produces rendered visual. A rendered image of the resulting output is provided at the end. Your task is to infer and clearly describe the purpose and structure of this visual.
Break your response into the following four parts: 1. Setup (state the {LANGUAGE} and its rendering context, including any tools or specification frameworks implied).
2. Data/Content Description (summarize the input fields, entities, content the code relies on, including any shaping or transformation operations).
3. Output Description (omit library, directive, or element names; start with "Generate..." or "Create...", and describe the visual conceptually).
4. Style Description (describe appearance and layout without naming language constructs).
Each part must start on new line, numbered through 4.
Use plain text only; no markdown.
Code: (code)
Image:
20

---

Instruct Generation Prompt: CoSyn-400K
Model: GPT-4.1
# FOR NONE DATA-DRIVEN LANGUAGES
# LANGUACE= [Asymptote, SVG]
You are given a { [LANGUAGE] code snippet that renders an image. A rendered image of the resulting output is provided at the end. Your task is to infer and clearly describe the purpose and structure of this image.
Break your response into the following four parts:
1. Setup (state the {LANGUAGE) and its rendering context).
2. Visual Elements (summarize the visible components of the image).
3. Output Description (omit language constructs; with "Generate..." or "Create...", and describe
the image conceptually).
4. Style Description (describe appearance and layout without naming language constructs).
Each part must start line, numbered through 4.
plain text only; no markdown.
Code: (code)
Image:
21

---

E.2
PROMPT USED IN VISPLOTBENCH
Task & Style Description Generation Prompt:
Model: GPT-4.1
# LANCUAGE= [Python, Vega-Lite, HTML, LilyPond, Mermaid, Asympt HTML, SVG]
You are given [LANGJAGE] code that produces rendered visual. A rendered image of the resulting output is provided at the end. Your task is to infer and clearly describe the purpose and structure of this visual.
Task Description (omit libraries and specific function names at this part, start with "Generate.." or "Create..")). 2. Style Description (describe appearance and layout without using specification keywords).
Break your response into the following two parts: 1.
Each part start new line, numbered through 2. Use plain text only; no markdown.
CODE: code IMAGE:
Vis & Task Judge Prompt
# Vuall Judge
You are excellent judge at evaluating visualization plots between model generated plot and the ground truth.
You will be giving scores on how well it matches the ground truth plot.
The generated plot will be given you the first figure.
Another plot will be given you the second figure, which is the desired outcome of the query,
meaning is ground truth for you to reference.
Please compare the two figures head to head and rate them.
Suppose the second figure has score of 100, rate the first figure on a scale from 0 to 100.
Scoring should be carried in the following aspect:
Plot correctness: compare closely between the generated plot and the ground truth, the more resemblance the generated plot has compared to the ground truth, the higher the score. The score should be proportionate to the resemblance between the two plots.
Ignore color matching. If the plots present the same information but are made in different colors, consider them matching. Capture the resemblance of the main idea of the plot.
Only rate first figure, second figure is only for reference.
After scoring from the above aspect, please give final score. Do not write anything else. The final score is preceded by the [FINAL SCOREJ token. For example [FINAL SCOREJ: 40
# Task Judge
You are excellent judge evaluating visualization plot according to the given task.
You will be giving scores how well plot image matches the task.
The generated plot will be given you as an image.
Please score how well plot matches the task. Score it on scale from to 100.
Scoring should be carried out in the following aspect:
Task adherence: how the plot corresponds to the task given below (begins from [PLOT TASK] token).
After scoring from the above aspect, please give final score. not write anything else. The final score is preceded by the [FINAL. SCORE] token.
For example [FINAL SCORE]: 40
22

---

E.3 INSTRUCT DESIGN VISPLOTBENCH EVALUATION
Python Instruct
# SYSTEM PROMPT:
are helpful programming assistant proficient Python. All answers must enclosed a block ""yython SOME CODE" containing one complete Python code. Example minimal spec: "'python
print hellc world')
# SETUP INSTRUCT:
Use Python programming language. Import essential libraries. The essential libraries needed are pandas for managing dataframes and [USED LIBJ with its subsidiary libraries for plotting. Ensure importing numpy as and scipy they are used in program. DO NOT use or import other visualization libraries.
# PLOT INSTRUCT:
Write a code to build a plot of dataframe according to following instructions. Write a code that returns plot, not just function declaration. Do not write explanations, just code enclosed in codeblock. Important reasoning write in comments the code. Make sure that all used libraries and functions imported.
# DATA INSTRUCT:
Load df dataframe by single line df pd.read csv(" sx(("dta.css")) DO NOT alter df dataframe columns add columns. This df dataframe should remain intact. The metadata of the dataframe is following:
Vega-Lite Instruct
# SYSTEM PROMPT:
a helpful programming assistant proficient Vega-Lite. All answers must enclosed a block "'vegalite SOME CODE"" containing one complete Vega-Lite specification. Example minimal spec: vegalite
$schema"; "https:/ /ttees://vveegee /vega.ega..o .gi thub. o h//achea//eaa--llee///5 "data": ("values") [[ [["hello". "world")]]
"mark": "text",
"encoding": (ttext: "fieldd" "hello", "type": "nominal"]
# SETUP INSTRUCT:
Setup. Use the Vega-Lite v6 JSON schema and produce exactly one valid Vega-Lite specification as a single top-level ISON object that MUST include the $schema property. Do not output raw Vega specifications, imperative ende, language-specific wrappers, references other plotingg libraries; use only Vega-Litee encodings, transforms, and configuration required by the plot.
# PLOT INSTRUCT:
Write code to build plot of the dataset according to the following instructions. Return one complete Vega-Lite JSON specification enclosed in single code block, and do not include explanations comments. Use only the constructs permitted by setup, ensure that all referenced field names exactly match the dataset metadata, and do not rename or drop columns; only use non-destructive Vega-Lite transforms if required.
# DATA INSTRUCT:
Data description. Load dataset by setting "data": "url": "data.csv". Do not create synthetic data load inline data values. The metadata of the dataset is following:
23

---

Mermaid Instruct
# SYSTEM PROMPT:
You helpful programming assistant proficient in Mermaid diagrams. All answers must be enclosed a block "'mermaid SOME CODE"" containing one complete Mermaid specification. Example min- imal spec: ""mermaid
graph TD
A ][Start] -Arightarrow B(Condition)
B - -Vrightarrow Yesl CDo something]
B - -righhtarow |No| [Stoo]
# SETUP INSTRUCT:
Setup. Use Mermaid syntax only and produce exactly one valid Mermaid diagram definition. Do not output explanations, comments outside the code block, code in other languages formats. Do not split diagram into multiple blocks. Ensure the code can rendered directly by mermaid-cli (mmdc).
# PLOT INSTRUCT:
include explanations or natural language outside code block. Ensure that diagram is self-contained, syntactically correct Mermaid code, and does not rely on external data or libraries. Use node and edge labels exactly as provided in the instructions.
Write diagram according to the following instructions.
# DATA INSTRUCT:
Data description. The diagram is constructed only from the provided instructions. Do not load external files or datasets.
LilyPond Instruct
# SYSTEM PROMPT:
You are helpful programming assistant proficient LilyPond. Always use the version statement version "2.22.1" All answers must be enclosed in block "'ilypoon SOME CODE" containing one complete LilyPond score. Example minimal spec: "'ilyppond
iversion "2.22.1" \score
\new Staft I c' e' FF \layout (
}
SETUP INSTRUCT:
Setup. Use LilyPond syntax only and produce exactly one valid LilyPond music notation definition. Do not output explanations, comments outside the code block, or code in other languages or formats. Do not split the notation into multiple blocks. Ensure the code can be rendered directly by LilyPond.
# PLOT INSTRUCT:
Write a music notation according to following instructions. Do not include explanations or natural language outside the code block. Ensure that the notation is self-contained, syntactically correct LilyPond code, and does not rely external data or libraries. Use note names and other musical symbols exactly provided in the instructions.
# DATA INSTRUCT:
Data description. The music notation is constructed only from the provided instructions. Do not load external files or datasets.
24

---

SVG Instruct
# SYSTEM PROMPT:
You helpful programming assistant proficient in SVG. All be enclosed in black "ssg SOME CODE"" containing one complete SVG specification. Example minimal spee: "'svg
<svg width="100" height="100" xmins="http:///x http:/wwwwwg////////0 <eircle cx="50" cy="50" r="40" stroke="black"
stroke-width="2 fill="red" />
</svg>
# SETUP INSTRUCT:
Setup. Use SVG syntax only and produce exactly one valid SVG definition. Do not output expla- nations, comments outside the code block, code in other languages formats. Do not split the diagram into multiple blocks. Ensure the code rendered directly by SVG viewers.
# PLOT INSTRUCT:
Write an SVG according to the following instructions. Do not include explanations or natural language outside the code block. Ensure that the SVG is self-contained, syntactically correct SVG code, and does not rely on external data libraries. Use shapes and attributes exactly provided the instructions.
# DATA INSTRUCT: Data description. The SVG constructed only from the provided instructions, Do load external files or datasets.
Asymptote Instruct
# SYSTEM PROMPT:
You helpful programming assistant proficient in Asymptote. All answers must be enclosed in block ""asymptote SOME CODE" containing one complete Asymptote specification. Example mini- mal spec: "asymptole
import graph;
size (100); draw (0, (1, 11);
SETUP INSTRUCT:
Sctup. Use Asymptote syntax only and produce exactly one valid Asymptote definition. Do not output explanations, comments outside the code block, or code in other languages or formats. Do not split the diagram into multiple blocks. Ensure the code can be rendered directly by Asymptote.
# PLOT INSTRUCT:
Write an Asymptote according to the following instructions. Do not include explanations or natural language outside the code block. Ensure that the Asymptote is self-contained syntactically correct Asymptote code, and does not rely external data or libraries. Use shapes and attributes exactly provided the instructions.
# DATA INSTRUCT:
Data description. Please use the provided data definition code to construct the plot. Do not modify this code create data by yourself. Use the variables defined in this code directly when building the plot. data definition code is as follows:
25

---

LaTeX Instruct
# SYSTEM PROMPT:
You helpful programming assistant proficient in LaTeX. All answers must be enclosed in block "'latex SOME CODE"" containing one complete LaTeX document, Example minimal spec: "'latex
idocumentclass stands lone)
\begin (documen))))
Hello
\ond ( document)
# SETUP INSTRUCT:
Setup. Use LaTeX syntax only and produce exactly one valid LaTeX document as single code hlock. Do not oulput explanations, comments outside the code block, code in other languages or formats. rendered directly by LaTeX compilers.
Ensure the document
# PLOT INSTRUCT:
Write a LaTeX code to build plot of the dataset according to the following instructions. Re- tur exactly complete LaTeX document enclosed in single code block. Include all required packages. Do not include explanations comments. Do not create synthetic data modify the dataset.
# DATA INSTRUCT:
Data description. Load the dataset by adding Apefplosstablereallaeex .evtteeee..c..v... datattbbe. Do not create synthetic data modify the dataset. The metadata of the dataset following:
HTML Instruct
# SYSTEM PROMPT:
You are helpful programming assistant proficient in HTML. All answers must be enclosed in a block "html SOME CODE containing one complete HTML document Example minimal spec: "'hmml
!DOCTTPP html>
<html>
Sbody>tiello</body.
</html>
# SETUP INSTRUCT:
Setup. Use HTML syntax only and produce exactly valid HTML document single code block. Do not output explanations, comments outside the code block, or code other languages or formats. Ensure the document can be rendered directly by web browsers.
# #LOT INSTRUCT:
Write an HTML code exactly one complete HTMI. document enclosed in single code block. Include required libraries and scripts. Do not include explanations or comments. Do not create synthetic data or modify the datasct.
a plot dataset according to the following instructions. Return
# DATA INSTRUCT:
Data description. Load the dataset by defining: const data [htmllcsv]: [html.csv] is placeholder for the parsed CSV rows. Assume that the placcholder will be replaced at runtime by the CSV content converted into JavaScript array of objects (i.c., list of dicts), where each object represents with column names keys and cell values values. Write the code as if "data" is already such valid JavaScript array of objects. not create synthetic data or modify the dataset. The metadata of the dataset is following:
26

---

F TAXONOMY OF VISUAL CATEGORIES AND SUBTYPES
Bars
106
Lines
136
Arcas
45
Seatter Relation
Distribution
Matrix & Heatmaps
49
3D
43
Diagramming
208
Hierarchies
Maps
Music
Networks Flows
12
Radial & Polar
56
Figure 4: Distribution of fin-grainee visualization types VisPlotBench. Tasks are organized into 13 Visual categories and 116 Subtypes, ensuring broad coverage of both common and underexplored visualization families.
Back to Appendix Contents]
27

---

Table 7: Taxonomy of Visual Categories and Subtypes
Back to Appendix Contents]
Visual Category
Subtype
Count
Visual Category
Subtype
Count
verticul-bar
31
area stacked-area
horizontal -arr
23
grouped-bur
15
normalized
normalized-stacke -sscaccee--brr
8
difference-urea
Areas
stacked-bor bcd-bar
7
missing-data-
data-matrix
diverging-bun bur
5
ternary-area streamgraph ridgeline
dot-plot
lollipop
3
Bars
sorted-bar bar
2
waterfall
1
bubble
25
polar-bur bur
scatter
24
bullet
color-scatter
funnel
regression-ci
combo-chart
ternary-line
missing-be bar
Scatter & Relation
quadrant-chart
marimekko
ellipse-scatter
polar polar-line-seade line-ieeee line-scatter
single-line
45
splom
multi-line
39
commevted-scatter
function-lins -ine
26
dumbbell chart
dlep-line
10
Lines
gapped-ling line
6
bux-plot
17
band-line
histogram
stope-chart
3
density-contours
candlestick
3
violin
kde-ld
surface
21
Distribution
hexbin-2d
multi-line -lne
3
qq-plot
rug-plot
point-cloud
3
ridgeline
solid
3
prediction-interval
3D
single-line
2
spectrum
rector-iieldmmal
2
ad-density-conloon
heatmap
connected-scatte
calendar-heatman
isosurface
Matrix & Heatmaps
muising-corr-heattne
slices
adjacency-matte
correltioo-heatmap
sequence-diagram
37
flowchart
25
freemap
10
geometric--ngee
20
sunburst
electrical-cirui--die diagram
16
circle-pucking
Hierarchies
state-machine
16
missing-dende -endroognm
table
15
tidy-tree indented-tree
uml-class-diarram
12
gantt
11
timeline
11
choropleth
simple-figur
10
vector-field-ne
Maps
Diagramming
concept-illustrtio
10
dot-map
icon
pnportional-symbol-nne
block-diagram
3
physics-diagram
2
sankey
venn word-cloud
2
chord
2
dopendency-gree graph are are-diagram dlg--layeeed force-directed
Networks & Flows
mind-map
2
color-paletle
anontannotations
Chemical graph sankey
pie rudar
17
10
Music
sheet-music
55
polar-line-scatter
Radial & Polar
donut
radial-bur
radial-urea
wind-rose
28

---

G BREAKDOWN MAIN RESULTS
In this section, we provide a breakdown model performance VisPlotBench. For each visualiza- tion language,e report (1) execution pass rate (Exec Pass). (2) mean visual and task scores (Mean), and (3) the proportion of samples scoring at least 75 (Good).
G.1 PYTHON, VEGA-LITE & LILYPOND
Table 8: Performance of selected languages on the VisPlotbench benchmark. For each model, we report (1) execution pass rate (Exec Pass). (2) mean visual and task scores (Mean), and (3) the proportion of samples scoring at least 75 (Good). The best- pest-performing model in each scale is shown in bold, and the second best is underlined. Back to Appendix Contents]
Python (196)
Vega-Lite (129)
LilyPond (SS)
Model
Exec Pass
Meun
(25d(2
Exee Pass
Mean
Good(275)
Exec
Mean
(2
vis
task
task
vis
task
vis
task
Pass
vis
task
vis
task
GPT-4.1
61
61%
66%
43.6
38
36%
GPT-4.1+ Self Debug
84.2
66
76
64%
76%
96.1
64
74
60%
72%
63.6
17
54
5%
53%
G-Ti,1-mini
64.8
53
61
47%
59%
84.3
63
45%
60%
16.4
12
0%
11%
1-mini Self Debug
67%
68%
42
35%
3B Scale
DeepSeck-Coder-.. L.B-et--.B-isstrucc
34.2
23
28
17%
2499
68.2
25
34
1.3
2.2%
3.6
2
019
0%
VisCoder-3B 3B
45.4
32
39
26%
35%
83.7
37
20'
26%
21.8
7
0%%
2%
VisCoder2-3B
56.1
39
45
38%
40%
31
1.5%
VisCoder2.3B Self Debug
63.3
42
49
35%
40%
84.5
50
34%
41 %
32.7
32
2%6
1.5%
7B Scale
DeepSeck-Codeee Coto-ooo----..-ttsttts
39.3
19%
23%
79.8
37
47
24%%
37%
7.3
3
4%
Owen2.5-Coder: Coder Instractt
41.3
29
37
24%
32%
76.0
40
50
29%
40%
5.5
3
096
4%
VisCader-7B
58.2
33%
42%
71.3
49
311
43%
23.6
11
2%
4%
VisCoder2-7B
64.8
37%
49%
83.0
49
58
43%
51
69.1
16
52
2%
4.59
VisCoder2-7BB Self Debug
77.0
50
61
41%
54%
84.5
49
59
43%
52%
72.7
17
55
248
45%
148 Scale
DeepSeck-Codeee Codee--V--Lii---nsseee
47.5
32
40
28%
36%
75.2
36
43.
27%
33%
49.1
28
0%%
13%
Sove2.5-Coder--ie 4BB-Instuct
50.0
35
43
28%
39%
83.0
61
42%
539)
25.5
12
2%
4%%
VisCoder2-14B
47
52%
4779
58866
54.6
44
40%
VisCoder2-14B Self Debug
78.1
55
64
46%
58%
94.6
56
64
47%
60%
63.6
12
.47
019
40%
32B Scale
DxspSeck-Codce-31B---
58.2
40
34%
41%
90.7
61
40%
51%
30.9
11
4%
Sreen2.--Cnder3266 Instrictt
50.5
36
43
30%
41%
83.0
48
57
39%
49%
30.9
22
256
18%
VicCoseer-32B
65.3
49
42%
54%
94.6
5.96
65%
56.4
39
296
27%
VisCoder2-32B Self Debug
81.6
58
46%
62%
96.1
72
54%
67%
69.1
48
35%
29

---

G.2 MERMAID, SVG & LATEX
Table 9: Performance of selected languages the VisPlotbench benchmark. For each model, we
report (1) execution pass rate (Exec Pass), (2) mean visual and task scores (Mean), and (3)
proportion of samples scoring at least 75 (Good). The best best-performing model in each scale is shown in bold, and the second best is underlined.
Back to Appendix Contents]
Mermaid (131)
SVG (65)
LaTeX (112)
Model
Exec
Meun
2
Exec
Mean
Exec
Meun
2
GPT-4.1
68.7
41
22%
50%
95.4
92
14%
94%
31.3
18
26
13%
25%
GPT-4.1 + Self Debug
93.9
56
32%
73%
96.9
93
14%
95%
66.1
38
56
25%
51%
GPT-4.1-miii
33
18%
GPI-1.1-mint Self Debug
94.7
58
79
26%
74%
96.9
42
88
11%
88%
58.9
35
50
23%
49%
Scale
DeepSeek- Coder: 1.30 Instruct
63.4
19
25%
8%%
7.7
0%
0%
4.5
25g
Qwen2 Qwen2.5-Coder-Bee 3-Coooer-----tnntcet
74.1
30
38
956
21.%
75.4
18
39
2%
28%
17.9
9
3%
55%
VisCader-3B
VisCoder2-3B VisCoder2-3B- Self Debug
76.3
43
23%
50%
87.7
25
59
3%
48%
36.6
21
34
12%
76.3
43
23%
50%
87.7
59
3%
48%
38.4
14
23
3%
13%
7B Scale
DeepSeck- Coder-6. 7B Instruct
91.6
-00
50
11%
28%
96.9
19
46
0%
22%
18.8
6
11
3%
8%
Qwen2.5-Codere
39
6%
VisCoder-7B
77.1
41
17%
43%
93.9
53
2%
32%
25.9
15
66%
12%
VisCoder2-7B Self Debug
78.6
43
39
20%
53%
96.9
34
73
3%
62%
39.3
15
23
666
1.5%
42.9
~v. 14H Scale
DeepSeek- Codes--Ceer-- Careek--Cdee..---iitete. V2-..te-fnnsrr
69.5
34
12%
34%
55
34%
29.5
16
4%
10%
Qwen2.5-Coder-148
74.8
39
15%
48%
95.5
80
596
77%
30.4
6%
VisCoder2-144
81.7
53
324
6.6
89.2
34
72
65%
42.0
22
33
1256
27%
VieCoder2-14B- Self Debug
86.3
58
33%
659
45.5
24
35
122
28%
~v 32B Scale
CoosSeckCCode-3322 -nn-strtt
87.0
44
15%
40%
92.3
23
58
0%
43%
24.1
14
4%
11%
Qwen2.5-Coder.
29.5
9%
VisCoder2-32B
87.0
51
31%
62%
81.5
33
68
11%
63%
42.9
20
35
11%
34%
VisCoder2-32B- Self Debug
90.1
54
34%
63%
86.2
71
11%
66%
61.6
28
45
14%
42%
30

---

G.3 ASYMPTOTE & HTML
Table 10: Performance of selected languages on the VisPlotbench benchmark. For each model, we report (1) execution pass rate (Exec Pass), (2) mean visual and task scores (Mean), and (3) the proportion of samples scoring at least 75 (Good). The best-performing model each scale shown in bold, and the second best is underlined. [Back to Appendix Contents]
Asymptote (92)
HTML. (108)
Model
Exec Pass
Mean
Good (275)
Exec Pass
Mean
Good(>75))
task
task
task
task
GPT-4.1 GPT-4.1 Self Debug
21.7
20
20%
89.8
48
21%
50%
46.7
22
41
9%
39%
97.2
51
68
22%
52%
GPT-4.1-mini
23.9
13
22
7%
21%
86.1
36
53
11%
34%
GPT-4.I-mini + Self Dehug
48.9
21
40
9%
36%
100
42
62
12%
42%
3B Scale
DeepSeck-Coders 1.3--LLsttuccc
13.0
0
0%
0%
36.1
2
3
1%
0%
- Innnstrcttt
18.5
8
11
4%
9%
62.0
16
19
6%%
7%
VisCoder-3B
30.4
12
3%
8%
79.6
21
29
9%
17%
VisCoder2-3B
62.0
23
36
7%
26%
93.5
34
8%
23%
VisCoder2-3B- Self Debug
63.0
37
27%
8%
23%
7B Scale
DeepSeek-Coud Codeer- Coweer-677-Innsttee
7B-Instruct
0
0
0%
0%
22.2
5
8
1%
3%
Breen2.5-Coder-71 BB-Instrutt
13.0
10
9%
20
6%
13%
VisCoder-7B
17.4
11
9%
75.9
20
5%
16%
VisCoder2-7B
64.1
27
43
11%
33%
82.4
30
46
7%
19%
VisCoder2-7B Self Debug
70.7
29
47
11%
35%
84.3
31
47
7%
21%
14B
Scale
DeepScek-Coder Ve--e------Lii-nitieee
20.7
10
9%
64.8
21
32
4%
18%
Owen2.5-Coder 1-----odee------Ineeeee 14B-nttruett
25.0
17
9%
16%
83.3
34
50
9%
31%
VisCoder2-14B
56.5
27
45
15%
41%
90.7
41
58
12%
36%
VisCoder2-14B Self Debug
66.3
31
50
16%
45%
94.4
42
60
13%
37%
32B Scule
BoyySeck-Codrr33BB-Bo
21.7
8
14
2%
9%
12.0
4
6
0%
0%
17.4
9
13
5%
12%
78.7
33
49
11%
32%
VisCoder2-32B
58.7
27
46
10%
39%
91.7
43
61
18%
48%
VisCoder2-32B Self Debug
71.7
31
53
10%
41%
93.5
44
62
18%
49%
31

---

H BREAKDOWN SELF-DEBUG RESULTS
In this section, we provide breakdown of model performance under the self-debug setting. For each language, we report execution pass rates across up to three rounds of automatic correction, grouped by model series.
H.1 PYTHON & VEGA-LITE
Table 11: Execution pass rates (%) Python and Vega-Lite under the normal and self-debug settings. Models that fail initially are allowed up to three rounds of automatic correction. Left columns show Python results, right columns show Vega-Lite results.
Back to Appendix Contents]
Python Self Debug
Vega-Lite Self Debug
Model
Normal
Normal
Round
Round 2
Round
Round 1
Round
Round
GPT-4.1 GPT-4.1-mmni
64.3
75.0
81.6
84,2
84.5
95.3
96.1
96.1
64.8
73.5
79.1
80.6
84.5
95.3
96.9
96.9
3B Scale
DeepSeck-Coder- -.B-Instett
29.1
35.7
35.7
35.7
53.5
53.5
(ren2.5-Coder33B-innte
34.2
39.8
41.8
42.9
68.2
68.2
69.0
69.0
VisCoder:3IB
45.4
51.0
52.6
52.6
83.7
83.7
83.7
83.7
VisCoder2-3B
56.1
61.7
62.8
63.3
83.0
84.5
84.5
84.5
Scale
DeepSeck-Coder-6 B-Isstcctt
39.3
53.1
79.8
81.4
81.4
Qwen2.5-Coder-7B VisCoder-7B
41.3
53.6
60.2
61.7
76.0
77.5
77.5
77.5
58.2
66.8
68.9
71.9
71.3
76.0
77.5
77.5
VisCoder2-7B
64.8
72.5
76.0
77.0
83.0
84,5
84.5
84.5
14B Scale
DeepSeek Coder--V--Lall Lite- Instruct
47.5
54.6
55.6
58.7
75.2
78.3
79.8
79.8
50.0
65.3
72.5
76.0
83.0
86.8
86.8
86.8
VisCoder2-14B
65.3
76.5
78.1
78.1
93.0
93.8
94.6
94.6
32B Scale
SeegSeck-Coder-33---nssse Owen225-Coodr-32B-Ineete
58.2
67.9
71.4
73.0
90.7
92.3
92.3
92.3
50.5
70.9
78.1
79.1
83.0
87.6
89.9
89.9
VisCoder2-32B
65.3
81.6
94.6
96.1
96.1
32

---

H.2 LILYPOND & MERMAID
Table 12: Execution pass rates (%) LilyPond and Mermaid under the normal and self-debug settings. Models that fail initially allowed up three rounds of automatic correction. Left columns show LilyPond results, right columns show Mermaid results.
Back Appendix Contents]
Lily Self Debug
Mermuid Self Debug
Model
Normal
Normal
Round
Round
Round
Round
Round
Round
GPT-4.1 GPT-4.I-mini
43.6
54.5
63.6
63.6
68.7
84.7
93.0
93.9
16.4
30.9
47.3
56.4
51.9
81.7
90.1
94.7
3B Scale
DeepSeek-Cooe Coder-1 Ins-tuctt
30.9
32.7
32.7
32.7
63.4
76.3
77.9
78.6
Breen..5-Code--BB-mmae
5.5
74.1
76.3
VisCoder-3B
21.8
21.8
21.8
21.8
75.6
76.3
76.3
76.3
VisCoder2-3B
50.9
52.7
$2.7
52.7
76.3
76.3
76.3
76.3
7B Scale
DecpSeck-Coder-6 7B-Instruct Breen25--Cuder-7BB---ee
7.3
9.1
10.9
10.9
91.6
93.9
94.7
94.7
5.5
77.9
79.4
VisCoder-7B
23.6
27.3
30.9
30,9
77.1
80.9
80.9
80.9
VisCoder2-7B
69.1
72.7
72.7
72.7
78.6
84.0
84.7
84.7
148 Scale
DeepSeck- Colbeek---ode-VVVe V2-Lite Lite-nnstrut
49.1
52.7
$2.7
52.7
69.5
69.5
69.5
71.0
Swen2.5-Codes. Lo InB-tnttt
50.0
72.5
76.0
83.0
86.8
86.8
VisCoder2-14B
$4.6
63.6
63.6
63.6
81.7
86.3
86.3
86.3
32B Scale
DeepSack-Coder-333 Coder-33B Instrutt
30.9
40.0
41.8
41.8
87.0
87.0
87.8
88.6
Qwen2.5 Qwee22.5Cooder3336 -2re--CCrrr-SS-nnnstn
30.9
40.0
43.6
43.6
71.0
74.8
75.6
76.3
VisCoder2-32BB
56.4
61.8
69.1
69.1
87.0
89.3
90.1
90.1
33

---

H.3 SVG & LATEX
Table 13: Exccution pass rates (%) in SVG and LaTeX under the normal and self-debug settings. Models that fail initially are allowed up three rounds of automatic correction. Left columns show SVG results, right columns show LaTeX results.
Back Appendix Contents]
Self Debug
LaTeX Self Debug
Model
Normal
Normal
Round
Round
Round
Round
Round
Round
GPT-4.1 GPT-4.1-mini
95.4
96.9
96.9
96.9
31.3
53.6
59.8
66.1
95.4
96.9
96.9
96.9
29.5
50.9
53.4
58.9
~v 3B Scale
DeepSeek-Code Coder-1 Insttuctt
7.7
95.4
95.4
95.4
4.5
5.4
5.4
5.4
Breen2.5-Cuder-BB-mmee
75.4
75.4
17.9
VisCoder-3B
76.9
76.9
76.9
76.9
23.2
25.9
25.9
25.9
VisCoder2-3B
87.7
87.7
87.7
87.7
36.6
38.4
38.4
38.4
7B Scale
DeepSeck-Coder-6 7B-Instruct
96.9
98.5
98.5
98.5
18.8
19.6
22.3
22.3
92.3
92.3
92.3
25.9
VisCoder-7B
93.9
93.9
93.9
93.9
25.9
38.4
42.0
43.8
VisCoder2-7B
96.9
96.9
96.9
96.9
39.3
42.9
42,9
42.9
148 Scale
DeepSeck- Conbeek--ooe--VVee V2- Liternnstrut
93.9
93.9
93.9
93.9
29.5
33.9
35.7
35.7
Swen2.5-Coder- InB-Instt
98.5
98.5
98.5
30.4
37.5
38.4
38.4
VisCoder2-14BB
89.2
90.8
90.8
90.8
42.0
43.8
45.5
45.5
32B Scale
DeepSack-Coder-333 Coder-33B Instrutt
92.3
92.3
92.3
92.3
24.1
28.6
31.3
31.3
93.9
93.9
93.9
93.9
29.5
42.9
50.0
51.8
VisCoder2-32B
81.5
84.6
86.2
86.2
42.9
55.4
59.8
61.6
34

---

H.4 ASYMPTOTE & HTML
Table 14: Exccution pass rates (%) in Asymptote and HTML under the normal and self-debug settings. Models that fail initially allowed up three rounds of automatic correction. Left columns show Asymptote results, right columns show HTML results.
Back Appendix Contents]
Asymplote Self Debug
HTML Self Debug
Model
Normal
Normal
Round
Round
Round
Round
Round
Round
GPT-4.1 GPT-4.I-mini
21.7
35.9
43.5
46.7
89.8
96.3
97.2
97.2
23.9
37.0
42.4
48.9
86.1
99.1
99.1
100
~v 3B Scale
DeepSeek-Cooe Coder-1 InS-tuctt
13.0
17.4
17.4
36.1
36.1
36.1
36.1
Breen..5-Code--BB--mae
18.5
70.4
VisCoder-3B
30.4
31.5
32.6
32.6
79.6
83.3
83.3
83.3
VisCoder2-3B
62.0
63.0
63.0
63.0
93.5
94.4
94.4
94.4
7B Scale
DeepSeck-Coder-6 7B-Instruct Been225--Cude-7BB--mae
0.0
1.1
2.2
2.2
22.2
25.0
25.0
25.0
20.7
76.9
VisCoder-7B
17.4
26.1
26.1
26.1
75.9
81.5
82.4
82.4
VisCoder2-7B
64.1
68.5
70.7
70.7
82.4
84.3
84,3
84.3
148 Scale
DeepSeck- Colbeek--Coee-VVee V2-Lite Liternnstrut 20.7
23.9
26.1
26.1
64.8
76.9
79.6
79.6
Swen2.5-Codes. Cod-er-------nsruc InB-Inttt
25.0
32.6
40.2
83.3
89.8
VisCoder2-14B
56.5
64.1
66.3
66.3
90.7
94.4
94.4
94.4
32B Scale
DeepSack-Coder-333 Coder-33B Instrrtt
21.7
26.1
28.3
29.4
12.0
14.8
14.8
14.8
17.4
25.0
31,5
33.7
78.7
88.9
89.8
89.8
VisCoder2-32BB
58.7
68.5
71.7
71.7
91.7
92.6
93.5
93.5
35

---

I BREAKDOWN ERROR TYPE RESULTS
In this section, we provide breakdown error type results execution errors for GPT-4.1 and VisCoder2-32B. For each language, we report error type across up three rounds of automatic correction.
I.1 PYTHON
Table 15: Distribution of execution errors for GPT-4.1 and VisCoder2-32B Python, Each column shows error counts at different self-dehugging rounds after initial failure. Back to Appendix Contents)
GPT-4.1
VisCoder2-32B
Error Type
Normal
Round
Round 2
Round 3
Normal
Round
Round
Round
AutributeError
17
12
9
8
15
12
12
FileNotFoundErroo
1
ImportError
2
Schema Ear
I
KeyFrror
3
2
KeyboardInterrupt
6
9
9
9
CellSizeError
I
DataError
2
NameFrror
2
RuntimeErroo
2
0
O
SyntaxError
1
1
1
TypeError
14
7
ValucError
20
10
Total Errors
70
36
31
68
47
39
1.2 VEGA-LITE
Table 16: Distribution of execution enrors for GPT-4.1 and VisCoder2-32B in Vega-Lite. Each column shows error counts at different self-debugging rounds after initial failure. [Back to Appendix Contents]
GPT-4.1
VisCoder2-32B
Error Type
Normal Round
Round
Round 3
Normal
Round Round
Round
ISONDecodeError
0
0
KcyboardInteruut
0
ParseError
2
TypeFrror
2
RenderingError
1
0
Total Errors
20
4
1.3 LILYPOND
Table 17: Distribution of execution errors for GPT-4.1 and VisCoder2-32BB Lilypond. Each column shows eтror counts at different self-debugging rounds after initial failure. Back Appendix Contents]
GPT-4.1 Round
VisCoder2-32BB
Error Type
Normal
Round
Round
Normal
Round 1
Round 2
Round
FileNodFoundFrror
MarkupError
2
2
4
SyntaxError
25
17
12
14
12
10
TypeFrrrr
2
Total Errors
31
25
20
20
24
21
17
17
36

---

1.4 MERMAID
Table 18: Distribution of execution errors for GPT-4.1 and VisCoder2-32B Mermaid. Each column shows error counts at different self-debugging rounds after initial failure. Back to Appendix Contents]
GPT-4.1
VisCoder2-321
Error Type
Normal
Round
Round 2
Round
Normal
Round 1 Round
Round
StructureEErur
2
2
0
0
SyntaxEirrur
32
16
7
7
12
10
TypeError
2
UnknownDiagrammnnn
0
1
#AMeExccption
I
0
0
LogicError
1
Diagraml Dmairaml.imidEroor JimitErrr
Keyboarddmterrupt
Total Errors
20
14
1.5 SVG
Table 19: Distribution of execution enrors for GPT-4.1 and VisCoder2-32B in SVG. Each column shows error counts at different self-debugging rounds after initial failure. Back to Appendix Contents]
GPT-4.1
VisCoder2-3211
Error Type
Normal
Round
Round 2
Round 3
Normal
Round 1
Round 2
Round
SyntaxFrror UnclosedError
4
2
2
1
8
7
7
Total Errors
12
9
1.6 LATEX
Table Distribution of execution errors for GPT-4.1 and VisCoder2-32B in LaTeX. Each column shows error counts at different self-debugging rounds after initial failure. [Bak to Appendix Contents]
GPT-4.1
VisCoder2-32B
Error Type
Normal
Round
Round 2
Round 3
Normal
Round
Round
Round
KeyboardInterrupt
16
16
16
15
5
2
PackageError
2
2
1
1
RuntimeError
17
9
7
7
27
12
6
StructureError
3
2
2
3
SyntaxError
5
4
4
4
10
UndefinedError
15
15
23
Total Errors
64
50
45
43
77
52
45
38
37

---

1.7 ASYMPTOTE
Table 21: Distribution of execution errors for GPT-4.1 and VisCoder2-32B in Asymptote. Each column shows error counts at different self-debugging rounds after initial failure. Back to Appendix Contents]
GPT-4.1 Round
VisCoder2-32B
Error Type
Normal
Round
Round
Normal
Round
Round
Round
AmbiguousFunctionCas
Ambiguous UsageeFroo
CastError
Signtten
28
20
18
16
4
16
15
13
13
2
Furor
7
SyrtaxError
VariableError
16
KeyboardInterrupt
2
Total Errors
72
59
52
49
38
29
26
26
1.8 HTML
Table 22: Distribution of execution emrors for GPT-4.1 and VisCoder2-328 in HTML. Each column shows error counts at different self-debugging rounds after initial failure. [Back to Appendix Contents]
GPT-4.1
VisCoder2-32B
Error Type
Normal
Round
Round
Round 3
Normal
Round
Round 2
Round
ConsoleError
1
2
2
PageError
9
2
2
2
RequestFailed
1
3
Total Errors
11
4
3
7
38

---

J ADDITIONAL EXPERIMENTAL RESULTS & DISCUSSIONS
In this section, we present additional experimental results and discussions including evaluation set- tings, additional evaluation results and deep analysis of self-debug behavior & Task/Visual Score.
J.1 EVALUATION SETTINGS
Self-Debug Evaluation Protocol In VisPlotBench, we adopt the same self-debug evaluation mode used VisCoder to simulate a realistic developer-style debugging workflow. In this setting, if the model's initial code generation fails to execute or does not produce a valid plot, the model is given up to K rounds to iteratively refine its output based on feedback from the previous attempt. In each round, only the tasks that remain unsolved from the previous iteration model receives a multi-turn conversational prompt consisting of (i) the original natural-language instruction, (ii) the previously generated code that failed, and (iii) the feedback derived from the execution error. Based on this dialogue history, the model produces a revised version of the code. the revised code executes successfully and generates valid plot, the task is marked as solved and excluded from further rounds; otherwise, the latest failed output is recorded and carried forward to the next iteration.
reconsidered. The
Algorithm Self-Debus Evaluation Protocol
1: Let Fy be failed tasks from initial evaluation
2: for = 1 to K do
3: for each task
F;-1 not yet fixed do
4: Fix ar via feedback-driven prompting
5: Evaluate the result of the revised code
6: if successful then
7:
Mark x as fixed & record output 8: else
9: Record x 's latest failed output
10: end if
11: end for
12:
end for
13:
Evaluate all tasks with final recorded outputs
In all experiments, we set the maximum number of rounds K 3. After all rounds are completed, each task is evaluated using its latest recorded output (either the successfully corrected code from an earlier round or the final failed attempt) using the same evaluation pipeline as in the initial pass. This iterative mechanism mirrors the common "generate-execute-ee execute-repali workflow and provides a standardized way to evaluate how models recover from different error types across languages.
Task and Visual Score Metries In VisPlotBench, in PandasPlotBench (Galimzyanov et al. 2024). and the judge prompts are provided in Appendix The core idea is use GPT model to compare the ground-truth image and the model- rendered image within the context of the task description. For the Task Score, the judge compares the generated plot against the task instruction; for the Visual Score, the judge compares the generated plot against the ground-truth reference image.
follow the scoring procedure introduced
E.2
J.2 ADDITIONAL EVALUATION RESULTS
Results on PandasplotBeech We additionally evaluate Qwen2.5-Coder, VisCoder, VisCoder2, and proprictary models (GPT-4.1 / GPT-4.1--mmm PandasPlotBenchh, which covers Python-based visualization libraries including Matplotiil Seaborn, and Plotly. Tabll 23 Execu- tion Pass Rate, Task Score, Visual Score, and the proportion of samples achieving score>75.
Across all three libraries, VisCoder2 consistently outperforms the base Qwen2.5-Coder models on execution success well as both semantic (task) and perceptual (visual) metrics. The gains further increase under self-debug, where VisCoder2- 14B achieves performance close to GPT-4.1. These results support the generalization capability of VisCoder2 on unseen visualization benchmarks.
39

---

Table 23: Results of VisCoder2 and Baselines on the PandasPlotBench. For each model, report (1) execution pass rate (Exec Pass), (2) mean visual and task scores (Mean), and (3) the proportion of samples scoring at least 75 (Good).
Back to Appendix Contents]
Mutplotiib
Seaborn
Plotly
Model
Exec Puss
Mean
(2)d(275)
Exee
Mean
Go)d(275)
Exec
Mean
Good(
vis
task
vis
task
Pass
vis
tusk
vis
task
Pass
tack
task
GPT-4.1
94.3
75
88
69%
91%
93.7
72
86
68%
86%
76.6
61
67
581
66%
GPT-4.1 Self Dehug
100
77
90
70%
94%
98.9
74
89
70%
90%
97.7
74
85
69%
85%
G.T--.1-mini
87%
70.9
GPT-4.1-mint 1-mini Self Debug
98.9
76
89
73%
91%
100
74
87
67%
90%
97.1
72.
84
659
86%
3B Scale
Qwen2.5-Cade Cod.ee.-C-----BBBe In-Irtt
71.4
56
72
50%
69
58.3
44
36%
51%
27.4
19
17%
18%
VisCoder-3B
81.7
60
69
53%
69
73.7
48
65
38%
61%
60.6
38
45
52%
44%
VisCoder:3B Dehug
60
37%
64.6
VisCoder2-3B
83.4
62
70
55%
69 %
73.7
51
42%
56%
61.1
41
48
35%
45%
VisCoder2-3B Self Debug
86.3
63
71
56%
69
77.7
53
64
43%
58%;
64
43
52
37%
49%
7B Scale
3
63
76
58%
75%
68.6
51
63
40%
62%
48
29
34
24%
31%
VisCoder:7B
87.4
80%
50%
74.3
VisCodar-B-- + Solf Debog
91,4
67
81
62%
83
90.3
62
77
51%
75%
81.7
51
65
44%
63%
VisCoder2-7B
87.4
67
76
61%
78%
83.4
61
72
52%
70%
77.7
48
62
4.1
63%
VisCoder2-7B Debug
62%
80%
74%
87.4
47%
14H Scale
Owede2.-Coderr- Instrrt
67
61%
78%
56
VisCodar-48B 148
86.3
78.9
74,3
VisCoder- 148 Self Debug
93.7
93.1
VisCoder2-14B
76
63%
80%
66
58%
71%
78.3
46%
65%
VisCoder2-14BB Self Debug
94.3
71
83
68%
83%
93.7
67
79
59%
%
78%
94.9
60
71
51%
70%
Results on Human-Eval further evaluate Owen2.5--Cdeer-Inse and the fine-tuned Vis- Coder2 models on HumanEval and HumanEval+ (Chen et al. 2021).
Table 24: Performance on HumanEval and HumanEval+, Pass 1. Back to Appendix Contents]
Model
HumanEval Pass@1 1
HumanEval+ Pass@1
GPT-4.1
91.5
GPT-4.I-mini
92.1
86.6
Qwen2.5-Coder-30 3--nstuu--
84.8
79.9
VisCoder2-3B
81.1
76.2
Qwen2.5-Coder In-tntrttt
91.5
84.8
VisCoder2-7B
89
83.5
92.1
86.6
VisCoder2-14B
92.1
84.8
90.9
85.4
VisCoder2-32B
87.8
81.7
Table 24 shows that VisCoder2 exhibits only modest 2-3 point decrease compared the base Qwen2.5-Coder models on HumanEEva//HumanEYaaa This behavior aligns with the distributional differences between the two task families: VisCoder2 trained heavily on multi-language visual- ization code, whereas HumanEval focuses algorithmic and data-structure problems. Such minor fluctuations are therefore expected and do not indicate systematic capability degradation. Overall, VisCoder2 maintains stable general coding ability while achieving substantial gains on its target task of cross-language executable visualization code generation and multi-round self-debug.
J.3 DEEP ANALYSIS OF SELF-DEBUG BEHAVIOR AND TASK/VISUAL SCORE
Self-Debug Analysis In Appendix H
we report the complete self-debug results of all models across the eight visualization languages. To better understand model behavior during self-debug, we select four representative systems: GPT-4.11 GPT-4.1-mm 1-mini, Sreen2.--ooder-32--inntte and
40

---

fine-tuned VisCoder2-32B,, and provide deeper analysis that combines ceeguage-speciing charac-
teristics with model behaviors. Table 25
Table 26 and Table 27 present the corresponding results.
Table 25: Execution Pass Rate across Self-Debug Rounds (Python, Vega-Lite, LilyPond). Back to Appendix Contents]
Python RI
Vega-Lite RI
LilyPond
Model
Normal
Normal
R2
Normal
RI
R2
R3
GPT-4.1
64.3
75.0
81.6
84.2
95.4
96.1
96.1
45.5
58.2
61.8
65.5
GPT-4.1-mini
64.8
73.5
79.1
80.6
84.5
95.4
96.9
96.9
22.2
37.0
50.0
57.4
Qwen2.5-Coder -nnsttcttt-
50.5
70.9
78.1
79.1
83.0
87.6
89.9
89.9
30.9
40.0
43.6
43.6
VisCoder2-32B
76.0
94.6
96.1
96.1
96.1
56.4
61.8
69.1
69.1
Table 26: Execution Pass Rate across Self-Debug Rounds (Mermaid, SVG, LaTeX).
Back to Appendix Contents]
Mermaid RI
SVG
LaTTeX
Model
Normal
R2
R3
Normal
R1
R2
R3
Normal
RI
R2
R3
GPT-4,1
68.7
84.7
93.9
93.9
92.3
93.9
95.4
95.4
31.3
53.6
59.8
66.1
GPT-4.
$1.9
81.7
90.1
94.7
89.1
95.3
95.3
96.9
29.5
50.9
55.4
58.9
Qwen2.5:Coder-32 -2sttttettt
71.0
75.6
76.3
93.9
29.5
42.9
50,0
$1.8
VisCoder2-32B
87.0
89.3
90.1
90.1
81.5
84.6
86.2
86.2
42.9
55.4
59.8
61.6
Table 27: Execution Pass Rate across Self-Debug Rounds (Asymptote, HTML)..
[Back to Appendix Contents]
Asymptote
HTMLL
Model
Normal
R2
Normal
R2
R3
GPT-4.1
21.7
35.9
43.5
46.7
89.8
96.3
97.2
97.2
GPT-4.1-mini
23.9
37.0
42.4
48.9
86.1
99.1
99.1
100.0
Swenn.5-Coudrr32BB...
25.0
31.5
33.7
78.7
88.9
89.8
89.8
VisCoder2-32B
58.7
68.5
71.7
71.7
91.7
92.6
93.5
93.5
Effect self-debug: Self-debugging consistently improves execution reliability across all models and most languages. GPT-4. and GPT-4.1-mine already exhibit the strongest cross- language performance at the initial generation stage, and self-debug further repairs the majority of syntax- and interface-related errors, allowing them reach near-saturated execution rates in languages such as Python, Vega-Lite and Me rma d. In contrast, 1reen2.--Cdder-33 Instruct starts from weaker baseline, but still benefits substantially from iterative correction. Our fine-tuned VisCoder2-32B achieves significantly higher initial and final execution success rates than the baseline in seven languages, with especially large gains in symbol-intensive languages such as Li LilyPond, Asymptote, and LaTeX, where self-debug brings it close to or even above the GPT models. Together, these results show that self-debug offers a robust, model-agnostic mechanism for correcting structural and shallow syntactic errors, and is key driver multi-language reliability.
ii) Cross-language trends: In declarative languages like Vega-Lite and HTML, clear struc- tural rules and diagnostics allow most models to reach near-saturated execution within one or two rounds. In execution-driven languages such Python and Mermaid, rich runtime diagnos- tics provide actionable signals that drive steady improvements across rounds. For symbolic or compiler-dependent languages (LilyPong onnd Asymptote, LaTeX), models fix shallow syn- tax early, but deeper semantic issues rarely surface in logs, so improvements taper off after the first round. For SVG, the rendering pipeline sensitive to XML well-formedness but offers little semantic or layout feedback. Larger models generate more complex structures, mak- ing issues like unclosed tags or malformed attributes more common, and these are difficult to repair under weak feedback, limiting improvement.
ii Characteristics of self-debug: Across all models and languages, the first round of self-debur consistently yields the largest improvement, correcting the majority of failures caused by shal-
41

---

low issues such missing syntax, mismatched parameters, or incorrect references. Starting from the second round, the rate of improvement drops sharply, and by the third round perfor- mance typically plateaus. This pattern indicates that the current feedback mechanism effec- tively exposes structural and interface-related errors, but provides limited signals for deeper semantic inconsistencies, complex symbolic dependencies, or issues tied specific rendering or parsing processes. As a result, self-debug follows stable "large first-round gains followed by diminishing returns" trajectory across the entire evaluation.
iv) Failures remain across models: Building upon the error categorization in Section 5.3 we
further examined the final unsuccessful cases of GPT-4.1 and VisCoder2-32B across eight visualization languages and found that the remaining failures fall into three representative pat- terns that are difficult for current self-debug mechanisms to resolve: (1) deep semantic incon- sistencies, such as mismatched variable meanings, incorrect data relationships, or incoherent multi-step step plotting logic, which rarely surface explicitly in execution logs and therefore pre- vent the model from identifying the true source of failure; (2) grammar- or compiler-dependee symbolic errors, including macro expansion, symbol binding, or scope-resolution failures in languages like L, 1 Asymptote, and LaTeX, where parser messages tend to be generic and provide little actionable guidance; and (3) runtime-related behavioral errors, such as in- voking rendering packages that were never loaded, calling APIs unsupported by the target language, or generating plotting logic that may trigger infinite loops or excessive resource consumption. Although these issues manifest as runtime failures, the execution feedback typ- ically contains only coarse, non-localized error signals, making it difficult for the model to refine its output across self-debug rounds. Overall, the lack of explicit localization for seman- tic, symbolic, and runtime behavior-related errors constitutes the primary bottleneck behind the remaining unresolved cases.
Task/Visual Score Analysis In VisPlotBench, the execution pass rate and the Task/Visual Score are equally important evaluation dimensions. In Section 5.2 we analyze three representative lan- guages that highlight different behaviors and discuss the phenomena of execution-semantic mis- match, symbolic grammar gains, and rendering library sensitivity. To provide additional insights into semantic correctness and visual aligmment, extend the analysis using the complete results in Appendix G covering the remaining five languages and examining Task/Visual Score before and after self-dehug as well their relationship with execution pass rates.
i) Supplementary Task/Visual Score analysis for the remaining languages: (1) For Python, observe that from Qwen2.5-Coder to VisCoder2, and further with self-debug enabled, the mean Task/Visual Score, the proportion of high-quality samples, and the execution pass rate improve in a largely synchronized manner. For example, at the 32B scale, VisCoder2-32B increases its Visual Score from 49 to 58 and its Task Score from 56 to 68, with the proportion of samples scoring visual 2 75 rising from 42% to 46% and task 2 75 from 54% to 62%. This shows that execution improvements are primarily driven by joint gains in semantic alignment and visual quality rather than by shallow syntax repairs. (2) Vega- Legga-ite, te, strong mod- els such as GPT-4.1 and VisCoder2 already approach saturated performance after self-debug, yet Task/Visual Score still show mild upward trends; for example, for VisCoder2-32B the Vi- sual Score increases from 60 to 62 and the Task Score from 70 to 72. This suggests that in declarative languages with explicit rules and rich diagnostics, models already produce mostly correct specifications, and self-debug mainly handles long-tail issues. (3) Me rmaid shows notable gains across all metrics. For GPT-4.1: the Visual Score rises from 41 to 56, the Task Score from 57 to 77, and the proportion of high-scoring samples increases correspondingly. VisCoder2 consistently outperforms Qwen2.5--ood task performance improve steadily with self-debug, reflecting that in languages with explicit graph structures and detailed runtime diagnostics. models can use feedback to refine both re- lational semanties and diagram layout. (4) Asymptote remains one of the most challenging languages. Although most models show some improvement in Task/Visual Score, the overall level remains significantly lower than in Python or Vega-Lite. For example, VisCoder2-32B in- creases its Task Score from 46 to 53 after self-debug, while the Visual Score only rises from 27 to 31 with almost no change in high-score proportions, indicating that models can more easily align symbolic task semanties yet struggle to reliably control geometric details and rendering behavior, leaving a substantial gap between semantic correctness and visual consistency. (5) In HTML,, strong models such as GPT-4.1 and VisCoder2 already exhibit high initial Task/Visual
at the same scale, and both visual and
42

---

Score, and self-debug leads only moderate gains. For example, GPT-4.1 increases its Visual Score from 48 to 51 and its Task Score from 64 to 68, while VisCoder2-32B increases its Vi- sual Score from 43 to 44 and its Task Score from 61 to 62. Overall, HTML specifications relatively "mooee--rrendly" in terms of semantic alignment, and remaining discrepancies are more reflective of minor visual deviations introduced by layout strategies and default rendering behaviors rather than true semantic errors.
ii) Effects and limitations of self-debug on Task/Visual Score: Across all eight languages, self- debug generally improves Task/Visual Score alongside execution reliability, with the clearest gains appearing in languages where models can leverage informative diagnostics. Python and Mermaid exemplify this trend: in Python, VisCoder2-32B improves from Task Score of 56 to 68 and from Visual Score of 49 to 58, while GPT-4.1 1 in Mermaid rises from 57 to 77 (task) and 41 to 56 (visual). These cases show that when feedback exposes meaningful se- mantic structural signals, models can refine both correctness and rendered appearance rather than merely repairing syntax. In contrast, LaTeX and Asymptote show limited visual im- provement despite higher execution success (e.g.. VisCoder2-32B increases visual only from 27 to 31), reflecting that symbolic or compiler-dependent failures often surface only as coarse parser messages, offering insufficient guidance for deeper refinement. SVG represents the op- posite extreme: execution and Task Score increase slightly, yet Visual Score remain almost unchanged (GPT-4.1 stays near 45; VisCoder2-32B increases only from 33 to 34), indicat- ing that text-only feedback cannot reveal layout- or rendering-sensstive discrepancies. Taken together, these findings show that Task/Visual Score uncover a distinct layer of quality that execution alone cannot detect, and that the effectiveness of self-debug critically depends how well feedback exposes semantically or visually meaningful error signals.
iii) Cross-language relationship between Exec Pass and Task/Visual Score: Examining all eight languages reveals two broad regimes. In Python, Vega-Lite, Lite, Mermaid. and HTML, execution success, task accuracy, and visual fidelity tend to rise together, indicating that most errors stem from structural or interface issues that, once resolved, directly translate into im- proved semantics and rendering; in these settings, execution pass rate is reasonable proxy for overall quality. LaTeX and SVG, however, demonstrate clear decoupling: models of- ten achieve much higher execution success without corresponding gains in semantic visual alignment. For La Tex, GPT-4.1 reaches a 66.1 % execution pass rate after self-debug, yet Task/Visual Score remain in the mid-fifties and twenty-to-forty ranges due to macro expan- sion and compile-time fragility. For SVG, execution frequently saturates while Visual Score remain around forty to fifty across models, reflecting rendering-libran sensitivity that feed- back cannot capture. Asymptot ot lies between these extremes: all three metrics remain low but tend to improve synchronously, highlighting the intrinsic difficulty of symbolic geomet- ric drawing and that performance on this language is still far from saturated. Together, these cross-lange cross-language patterns show where execution informative of downstream quality and where Task/Visual Score provide essential complementary signals.
J.4 QUANTITATIVE ANALYSIS OF VISCODE-MULTI-677
We provide more detailed descriptions of eπror rates, diversity, redundancy, and semantic alignment for the visualization portion VisCode-Multi-679k
For Error Rates, Table 28 and Table 29 shows the error proportions at each of the three stages in the visualization data pipeline.
Table 28: Error proportions across stages in the visualization data pipeline (Part I).
Back to Appendix Contents]
Stage/Language
Python
Vega-Lite
LilyPond
Mermaid
SVG
LaTeX
Initial Samples
2.657,158
6,864
12.097
13,627
185,313
134,600
Libs Filter ErrorRate
91.90%
0%
0%
0%
57.16%
0%
Code Extract ErrorRate
0.10%
0%
0%
0%
0%
Runtime Validation ErrorRate
13.03%
1.08%
0.03%
1.81%
41.27%
7.85%
Final Valid Samples
186,954
6,790
12,093
13,381
46,621
124,039
43

---

Table 29; Error proportions across stages in the visualization data pipeline (Part II).
Back to Appendix Contents]
Stage/LLnnguage
Asymptote
HTML
JavaScript
TypeScript
C++
R
Initial Samples
25,297
1,400,763
1,325,343
429,035
1,024,674
257, 257,438 438
Libs Filter ErrorRate
0%
87.12%
93.03%
96.75%
92.30%
87.77%
Code Extract ErrorRate
0%
0.40%
21.90%
5.61% %
3.18%
20.75%
Runtime Validation FirorRate
10.90%
24.73%
60.07%
52.08%
78.05%
46.15%
Final Valid Samples
22,539
135,230
28,807
6,315
16,776
13,437
For Diversity, Table 30 reports the visualization-type distribution of VisCode-Muuli-6799 The dataset covers 91 visualization types grouped into 15 categories, highlighting its broad coverage and diversity across multi-language visualization tasks.
Table 30: Distribution of visualization types in ViCCoe-Muuti-6799.
[Back to Appendix Contents]
VisType
Count
Category
VisType
Count
Category
VisType
Count
Category
8,278
Basic
surface-3d
5,862
Surface
network
14,579
Network
bar
73,201
Basic
flow field
382
Surface
parallel coordinates
447
Network
candlestick
427
Basic
surface
5,994
Surface
sankey
1,036
Network
donut
980
Basic
tornary-plot
1,223
Surface
amnotation
139
Diagram
dosplot
Basic
vector-field
6,194
Surface
class-diagram
542
Diagram
grid
13,944
Basic
volume render
1,998
Surface
er diagram
702
Diagram
line
53,992
animation frame
1,744
Temporal
flowchart
4,855
Diagram
pic
19,064
Basic
event
230
Temporal
generic-dingram
12,055
Diagram
polar
3,951
Basic
timeseries
2,599
Temporal
gitgraph
662
Diagram
radar
790
Basic
timeline
3,663
Temporal
other diagram
other-diagran
19,060
Diagram
roctangle
3,896
Basic
calendar
301
Schodule
quadrant-chatt
696
Diagram
rule
1,538
Basic
ganit
2.304
Schedule
requirement diagrrm
600
Diagram
scatter
29.628
Basic
bubble
22,040
Relation
sequence diagram
606
Diagram
spike-line
Basic
jointplot
577
Relation
state-diagram
1.122
Diagram
streamgraph
228
Basic
regression
2,044
Relation
dataflow-diagram
1,295
Diagram
deusity
Distribution
calegtrry-chart
510
Categorical
circle
Geometry
hexhin
1,294
Distribution
funnel
1,314
Categorical
circuit
10,233
Geometry
histogram
Distribution
gange
297
Categorical
geometry
23.727
Geometry
kde
9,855
Distribution
indicator
1,623
Categorical
referenee-shppe
4,579
Geometry
rug
367
Distrbbttonn
waterfall
916
Categorical
choropleth
8,244
Map
941
Distribttonn
wordcloud
281
Calegorical
dot map
5,053
Map
box
11.097
Box
cluster
609
Hienrchy
symbol-map
1,773
Map
errorbar
1.734
dondrogram
630
Hierurcyy
goographic-line-mag
915
Map
interval
660
Box
icicle
647
Hierarchy
geosputial-plot
9,028
Map
violin
1,726
Box
mindmap
923
Hieruchy
document-
10.432
Document
correlationaariix
811
Matrix
sunburst
789
Hierarchy
image
13.140
Document
contourmatrix
2,062
Hieranchty
Ducument
heatmap
11,070
Matrix
treemap
1,780
Hierarcy
pmblem hox
10.924
Document
adjacencymatrix
1,075
Matrix
arediagram
427
Network
table
51.821
Document
splom
409
Matrix
chord
577
Network
text
8.302
Document
textbox
58.688
Document
For Redundancy, the upstream corpora used to construct VisCode-Multi-799K IDs, CoSyn-400K, and SVG-diagrams) were released with deduplication applied. Building on these sources, we further quantify redundancy within VisCode-Mulli-6799) by running additional checks on its visualization- speciiic fields. Concretely, we normalize the instruction text and the code snippet separately, and apply SHA-1 fingerprinting to detect exact duplicates. The resulting redundancy statistics are summarized in Table and Table 32
Table 31: Global redundancy statistics for visualization samples.
[Back to Appendix Contents]
Component
Total Samples
Unique Samples
Redundant Samples
Redundancy Rate
Instruction
612,982 612,982
611,671 594,382
1,311 18,600
0.21%
Code
3.03%
44

---

Table 32: Per-language redundancy for visualization samples.
Back to Appendix Contents]
Language
Samples
Instr. Redundancy (%)
Code Redundancy
Asymptote
22,539
0.00
0.38
C++
16,776
0.00
0.92
HTML
135,230
0.00
0.28
JavaSeript
28,807
0.00
8.33
LaTeX
124,039
0.00
0.00
LilyPond
12,093
0.00
0.00
Mermaid
13,381
0.00
0.93
Python
186,954
0.70
8.24
13,437
0.00
0.15
SVG
46,621
0.00
0.00
TypeScript 6,315
0.00
0.55
Vega-Lite 6,790
0.00
0.00
Overall, instruction redundancy is 0.21 % and code redundancy 3.03%. Redundancy remains low across all visualization languages, indicating that TisCode-Multi-67% contains diverse natural- language instructions and executable visualization code rather than being dominated by duplicated samples.
45

---

K CASE STUDY
In this section, we present a set of representative examples from VisCoder2-32B to illustrate model behavior across the eight visualization languages.
K.1 PYTHON: SUCCESSFUL GENERATION
VisCoder2-32B: Python
ID:1 :1
TASK: Generate scatter plot to visualize the relationship between sepal width and sepal length for different species of flowers. The data points are colored according to species, with the size each point representing petal length. Additional information about petal width is available when hovering over the points.
STYLE: The plot features grid background with evenly spaced horizontal and vertical lines. Data points are represented as circles varying sizes, each filled with distinct corresponding to species. A legend on the right side identifies the species by color. The axes are labeled with sepal width and sepal length, and the overall layout is clean and organized for easy interpretation.
SEUMOO
sppal wida
Rendered
Ground Truth
Generated Code:
import pandas as pd
import plotly. express as px
import plotly.grap Seclly-grapp_ooe import numpy as nр from scipy import stats import plotly.io io as pio pio.renderers. default "png"
graph_objects objects as go
df www.reeaddsdddaaaaaaaaa
fig sd. sepal width", y= y==sepal length", lenghh,, color= "species,",,"",, size=" "pee=l length", fig.show()
"petalllength", hover data=[ [eptal width"])
Error: null
Figure 5: Example of a successful generation in Python (ID: I). The model generates code that executes successfully and produces a plot consistent with the ground truth. [Back to Appendix Contents]
46

---

K.2 PYTHON: SELF-DEBUG RECOVERY
X
VisCoder2-32B: Python
ID: 69
TASK: Generate scatter plot to visualize the relationship between two variables, labeled as 'x' and yy, from dataset. The plot is designed to display individual data points, allowing for the examination of potential correlations are formatted to represent millions, providing a clear understanding of the scale. STYLE: The visual features title at the top, with axes labeled horizontally and vertically. Data points are depicted blue dots, evenly distributed across the plot area. A dashed grid is present, enhancing readability, and hover tool available for interactive data exploration. The overall layout clean, with focus on clarity and accessibility.
patterns between the measurements. The y-axis values
vs
Menaurements
1300ERUU
$1300000.00
Menoumment (btrooorre (hurhioor))
$400000/06
No Image Rendered
y/th mwlooneee
2000090.00
BM00000.0M
Normal Rendered
Debug Rendered
Ground Truth
Normal Generated Code
Self-Debug Generated Code
irport
import holoviews
from haloviews import opts
scatter hw. hw.Scatter(dF, 'x', 'y').opts(
hv.oxtension( "bokeh")) df pd.read_ -.)
"caaten vs y",
xlabel='x',
ytabel='y millonns)
scatter Iv.Scatten(of, 'x', ''')o title="Scatter Plot of x vs y*, xlabel-'x',
size:5,
colors'blue',
tools=[ (oss=[['oee")]
plobel='y 'y (in nillions)',
show grid-True,
size=5,
gridsty(e=(" (line dash':
tools-[ toolss["haven")] ),
cutorm'blue"
'dashed', color': 'gray". 'line_width 8.5]
show Leo_ggrtdee grtTTrrue,
'line width': : B.5)
grid styles("
'dashed', Liine_coor"" 'gray",
hv. www.savesctter.. opts (yforsutter
='X_1f'') scatter
Scatter.opts (yfoowyooo ".1("")
scatter
ValueError: Unexpected option 'ggrid style' for Scatter type across all extensions.
Figure 6: Example of a failed generation in Python (ID: 69), where the initial code raises ValueError and is resolved in the first round of self-debug, resulting in a corrected plot that matches the intended semanties. [Back to Appendix Contents]
47

---

K.3 PYTHON: SELF-DEBUG FAILED
X
VisCoder2-32B: Python
ID 111
TASK: Generate a visual representation of vector field using data from CSV file. Display points on a coordinate system where each point has an associated vector. The vectors are represented as arrows originating from each point, indicating direction and magnitude. STYLE: The plot features rectangular layout with title the top. The background is white with grid lines. Points are marked with blue dots, and arrows are red with filled triangular head. The axes are labeled with numeric scales and titles.
Folditr
No Image Rendered
Normal Rendered
Debug Rendered
Ground Truth
Normal Generated Code
# InterpoLate the data points
Self-Debug Generated Code
values
grid_ze griddata( -))
p figure(title- "Vector Field # Create ColumnDrtasounce source ColumDetasSurce(.... ...)
# Create a CoLumDDttaSouce
source
Plot the vectors p.quiver('xx ('x',, 'y', 'u', 'v', source-source, Line cotor= "red", Line width=2, ongLe=np.pi/2 p1//2, Length-8.5, Line_ 8 Line dase_ddah"'tee doli""solid""
# Plat the vectors p.segnent (xe- 'x', y0- <1='x'+'U 'u' yl= 1-"y'++'0 sounce=source, Line color="red", Line (in__width22)
Line cap= "oo''round,
round',
Line_dash bash_offset-@
fill cator="re"", fill__llae dlpha=0.6,, size=10, angle ongle_units= urats="rad") # the plot
AttributeError: unexpected attribute 'quiver' to figure.
Figure 7: Example of a failed generation in Python (ID: 115), where the initial code raises AttributeErron and is still failed after three rounds self-debug. [Back to Appendix Contents]
48

---

K.4 VEGA-LITE: SUCCESSFUL GENERATION
VisCoder2-32B: Vega-Lite
ID: 18
TASK: Create population pyramid for the US in the year 2000, displaying the distribution of population by age and gender. The data is filtered to include only the year 2000, and gender categorized into MMae' and 'Female'. The population numbers are adjusted to be negative for females to allow for mirrored bar chart effect.
The visual consists of horizontal bars stacked in mirrored fashion, with age groups sorted descending order from top bottom.
STYLE:
side represents females with purple bars, while the right side represents males with orange bars. The x-axis shows population numbers in millions, formatted with an 'M' suffix. A legend at the top indicates the color coding for gender, and the overall layout is clean with grid lines.
SLU Fimal
-MM
Pagaatakee
population
Rendered
Ground Truth
Generated Code:
"$schema": ".. ...",
"description": "Population Pyramid for the US in the Year 2000" "data": [ "url": "_
"transform": [.. [..,
"width": 480,
"height":
"mark": "bar",
"encoding": (-.
"config": {-
Error: null
Figure 8: Example of successful generation in Vega-Lite (ID: 18). The model generates code that executes successfully and produces a plot consistent with the ground truth. Back Appendix Contents]
49

---

K.5 VEGA-LITE: SELF-DEBUG RECOVERY
X
VisCoder2-32B: Vega-Lite
ID 14
TASK: Create bar chart that displays the production budget movie with the highest US Gross within each major genre. The x-axis represents the production budget in quantitative terms, while the y-axis lists the major genres in nominal terms.
The chart is oriented horizontally with bars extending from the left the right. Each bar corresponds different genre, labeled on the side. The production budget marked along the bottom axis, with gridlines aiding in visual comparison. The bars are uniformly colored blue, providing a clear contrast against the white background.
STYLE:
Image Rendered
Hono
soteme condty
Trlcc
mestaa
Prosuction Badgel res Dhoss
Normal Rendered
Debug Rendered
Ground Truth
Normal Generated Code
Self-Debug Generated Code
"trans Form";
"transform":
"aggregate"; [{ "op": "max*, "field": "US Gross", "as": max__US_Gross }1,
"window": "op": "max", "field": "us Gross", "as":
"groupby": ["Major Genre"]
"nax US Gross" }1, "groupby") Maajor Genre"), "sort"; [[ "field"; "US Grass" "order":
"lookup": "max us "S__Gros",
*fron": {
"descending" "frame": ; [null, 6]
"data": "url": "data.csv"
"fields": [* Gross"], "values"; ["Production Budget"]
"filter"; "datun l'us datun, max "s_o_rsos" "
"as": "Production Budget"
TypeError: Cannot read properties of undefined (reading 'signal').
Figure 9: Example of a failed generation in Vega-Lite (ID: 14), where the initial code raises a TypeError and resolved in the second round of self-debug, resulting corrected plot that matches the intended semantics. Back to Appendix Contents)
50

---

K.6 VEGA-LITE: SELF-DEBUG FAILED
X
VisCoder2-32B: Vega-Lite
ID: :00
TASK: Create grid point plots that represents different animals categorized by country. Each row corresponds to country, and within each row, different animals are represented by distinct shapes. The animals are visually encoded using both shape and color to differentiate between categories such "cattle," "pigs"" and "sheep." The plot does not display axes, focusing solely visual arrangement shapes to convey the data.
STYLE: The visual consists of a series of rows, each labeled with a country name on the left. Within each row, animal shapes arranged horizontally, with each shape filled with specific color corresponding
the animal type. The shapes evenly spaced and sized uniformly, creating clean and organized appearance. The absence of and legends emphasizes the visual comparison of animal types across different countries.
No Image Rendered
No Image Rendered
Normal Rendered
Debug Rendered
Ground Truth
Normal Generated Code
Self- Self-Debug Generated Code
"Sschema":
"$schena":
"https: httss://veggg //we///evaaaeeeee/ee github. cetthub.io/sceee www.so/ea//veeeeeeeeeeeeeeeeeeee /vega-
"https:/ //we://vevgggeeeeeeee lite/v6.
eveegaggthhbl github. io/ schenhh -hega
11te/v6.json
"data": "url"; "data.csv"
"data": { "url": "data.csv"
"}.
"config": {
"config":
"vicH":
"view: {
"stroke": null
"stroke": null
b, "axis":
"xis": f "grid": false
"grid": false
b, "legend":
'legend"; null
TypeError:
Cannot read properties of undefined (reading 'disable") Lp, po-areeeeeeedss
Figure 10: Example of a failed generation in Vega-Lite (ID: 50), where the initial code raises TypeError and is still failed after three rounds self-debug.
Back Appendix Contents)
51

---

K.7 LILYPOND: SUCCESSFUL GENERATION
VisCoder2-32B: LilyPond
ID: :15
Task: Generate musical score with two sequences notes. The first sequence is transposed from C major to D major and uses traditional noteheads. The second sequence uses different set of notehead styles, including shapes like crosses, triangles, and diamonds. Both sequences consist of the notes C, D, E, A, B, and arranged in Style: Create visual layout with staves, each containing series musical notes. The first staff uses standard noteheads, while the second staff employs varied geometric shapes for noteheads. The staves are aligned horizontally, with a treble clef and key signature at the beginning of each. The measures evenly spaced, and the overall appearance is clean and organized, with small footer crediting the engraving software.
each.
Rendered
Ground Truth
Musk engresingee by 2244. www Hypardorg
Generated Code:
Iscore Nnew Staff { litranspose d' lirelative c' def
Noverride NoteHead. #'oooss
Arelltive
oadef agabel
loverride NoteHead. style a'triangle Arelltive c' a
c4 deef F
loverride NoteHead style #' a'dinmond Irelative c4 deef ggabbl
Mayoutt )
Error: null
Figure 11: Example of successful generation in Lilypond (ID: 15). The model generates code that executes successfully and produces a plot consistent with the ground truth. Back to Appendix Contents]
52

---

K.8 LILYPOND: SELF-DEBUR RECOVERY
X
VisCoder2-32B: LilyPond
ID: :
Task: Generate musical score with three staves, each containing a sequence notes. notes are arranged in measures, with a time signature indicating slow tempo. The score includes rehearsal marks and tempo indications at the beginning of each staff.
Style: Create vertically aligned layout with three evenly spaced staves. Each staff begins with treble clef and includes tempo marking labeled "Largo"" with metronome setting- Rehearsal marks are placed prominently. Thee notes are evenly spaced, and the overall appearance clean and organized, with footer crediting the music engraving software.
No Image Rendered
Largo ie
30
Normal Rendered
Debug Rendered
Ground Truth
Self-Debug Generated Code
Normal Generated Code
Vlayout
\context
Mlayuut
\Score
Vooter
\nerove "Bar_ _ur__nuterr__o cuuubber_nngavvee enngavver
Yeankup
fiill-line
Anull
Vheader
Vitalic "Music engraving LilyPond"
FooterMarkup \narkup
Anull
(fill-1ina {
\null
Vitalic "Music engraving by LilyPond"
Inull
SyntaxError: unknown escaped string:
ffooter
Figure 12: Example failed generation in Lilypond (ID: 13), where the initial code raises SyntaxError and is resolved in the first round of self-debug, resulting in corrected plot that matches the intended semantics. Back to Appendix Contents]
53

---

K.9 LILYPOND: SELF- DELFG FAILED
X
VisCoder2-32B: LilyPond
ID: 48
Generate a musical score with repeated sequences notes in varying time signatures. The score is divided into two sections: the first section contains lines with four measures each, and the second section contains lines with six measures each. Each section is labeled accordingly to indicate the number of measures per line.
Style: Create clean organized layout with treble clef at the beginning time signatures change within the repeated sequences, alternating between 5/4, 3/4, and 3/2. The labels '4 measures per line: and '6 measures per line:" are italicized and placed at the beginning each respective section. The notes evenly spaced, and the overall appearance neat, with clear separation between the sections.
staff. The
No Image Rendered
No Image Rendered
Normal Rendered
Debug Rendered
Ground Truth
Generated Code:
Self-Debug Generated Code:
Viscore
|score
Vinew Staff
\new Staff
Miclef treble
Uelef treble
Vmaark \mnrkuu \itallcc "4
Amark \markup { Witalic "4
measures line:
measures per line:"
Vitime 5/4 Wrreeaat volta 2
\iiime 5/4
Wrepeat volta
c'4 d'4 e'4 f'4 g'4
4 d'4 e'4 f'4 g'
Atime 3/4
Atime 3/4
Wrepeat volta 2 { a' c'
Ireeet volta 4 c '
Atiee
time 3/2 Iepeat volta 2''2
Wrepeat volta 2 d' 2 e'
SyntaxError: unmatched y
Figure 13: Example of failed generation in Lilypond (ID: 48), where the initial code raises TypeError and is still failed after three rounds self-debug. [Back Appendix Contents]
54

---

K.10 MERMAID: SUCCESSFUL GENERATION
VisCoder2-32B: Mermaid
ID:10 19
Task: Generate an entity-relationship diagram illustrating the relationships between three entities: PERSON, CAR, and HOUSE. The PERSON entity includes attributes for first name, last name, and age. The CAR entity includes attributes for registration number, make, and model. The diagram shows a one-to-one relationship between PERSON and CAR, indicating that person owns a car. Additionally, there is a one-to-many relationship between PERSON and HOUSE, indicating that person can have multiple houses.
Style: The diagram features rectangular boxes for each entity, with the PERSON entity outlined red, the CAR entity in purple, and the HOUSE entity green. Each box contains rows listing the attributes, with data types specified. Lines connect the entities, with labels indicating the nature of the relationships. The lines have different end markers to represent the type of relationship, and the overall layout is clean and organized with clear visual hierarchy.
PERSON
PERSON
strig
Jamee
Ixstiame
Agp
0.00
CAR
HOUSE
Sting
St/ngg
rnghtratsmmaneeer
HOUSE
string
stFg
reeet
Rendered
Ground Truth
Generated Code:
erDiagram
PERSON --of HOUSE owns -- |
PERSON
PERSON
string first name string last_nams name int age
ČAR
string registration number
string make string model
HOUSE
string address int year built
Error: null
Figure 14:
Example successful generation Mermaid (ID: 19). The model generates code that executes successfully and produces plot consistent with the ground truth. [aak to Appendix Contents]
55

---

K.11 MERMAID: SELF-DEBUC RECOVERY
X
VisCoder2-32B: Mermaid
ID: :88
Task: Generate state diagram illustrating the transitions between three states: "SomeOtherState," "Your state with spaces in it," and "YetAnotherState The diagram begins with an initial state that transitions to both 'SomeOtherState" and "Your state with spaces in it." From "SomeOtherStatee" the flow continues to "YetAnotherState! Similarly, "Your state with spaces in it' also transitions to YYetAnotherState Finally, "YetAnotherState" leads to final state.
Style: Create a visual with rounded rectangles representing states, connected by arrows indicating transitions. The initial and final states depicted as filled circles. "Your state with spaces in it" styled with bold and italic text, while other states have regular text. The layout organized with top-down flow, and states are outlined subtle color.
Your Tour_ wwwp_/ot___________ spacees 21
Some@therddate
Your state spaces
No Image Rendered
YesAratiaertaae
VecAnetherSttte
Normal Rendered
Debug Rendered
Ground Truth
Normal Generated Code
Self Self-Debug Generated Code
stateDiagram:
classDef stateDefault
fil1:4f9f9/f #333, stroke-width width:1px classDef stateText font-weigg : bold, font- style:italic, font sin:-size:14px
[+] --> SomeOtherState
[+]
Your Your_ statsttteeeeee hatr__sttt_ttt______ _ n_it
[ .-> SomeOtherState
YetAnotherstatee YetAnotherState
SomeOtherState -.>
--> Your SomeOtherState --> YetAnotherState with spaces YetAnotherState --> [*]
with spaces in it
Your state with_spac
YetAnotherState
in --> Setan
YetAnotherState ..>
state SomeOtherState
[*]
state "Your state with spaces in it" te"ccttttee state YetAnotherState
SyntaxError: error on line 12: with spaces <<stateText>>
Figure 15: Example failed generation Mermaid (ID: 88), where the initial code raises SyntaxError and is resolved in the second round of self-debug, resulting in corrected plot that matches the intended semantics. Back to Appendix Contents)
56

---

K.12 MERMAID: SELF-DEBUC FAILED
X
VisCoder2-32B: Mermaid
ID: :0:
Task: Generate sequence diagram illustrating interactions between participants named Alice, Bob, Carl, and actor named Donald. The diagram depicts conversation where Alice greets Bob, they exchange pleasantries. Alice then introduces Carl, who subsequently greets Donald. The diagram also shows the destruction of Carl and Bob, with Alice commenting on the number of participants and Bob agreeing.
Style: The visual consists of horizontal arrows connecting labeled rectangular boxes representing participants, with stick figure symbolizing the actor. boxes and arrows are aligned vertically, showing the flow communication. Messages are displayed as text along the arrows, and the destruction of participants is marked by an 'x' on the arrows. The layout is clean, with light color scheme and clear separation between interactions.
No Image Rendered
No Image Rendered
In seiney
CAl
Normal Rendered
Debug Rendered
Ground Truth
Normal Generated Code
Self-Debug
sequenceDiagrar
sequenceOiagran
participant Alice
participant Alice
participant Boh
participant
Alico-3380m 3380:: Hello
are you? Bob->>sAlic:: I good thanks!
Alice->>8ob: Hello Bob, how are you?
Bob-->sAlice: good thanks!
Alice:
way, haw are you?
Boh-xx Alice: By way, are you?
Bob-x Alice: I good thanks!
Bob-x Alice: thanks!
right
long<br/>loo
so longchr/sthatt he needs<bbr/sto split the text overctn/ssovens lines sobicel Checking with John....
AttributeError: 'idda'' object has no attribute 'fileno'
Figure 16: Example of failed generation in Mermaid (ID: 80), where the initial code raises AttributeError and is still failed after three rounds self-debug. Back Appendix Contents]
57

---

K.13
SVG: SUCCESSFUL GENERATION
VisCoder2-32B: SVG
TASK: Generate a five-pointed star shape using a polygon. The star is defined by a series of connected points that form its structure.
STYLE: The star filled with bright green color and outlined with thick purple border. The background is black, making star stand out prominently. overall appearance bold and vibrant, with strong contrast between the star and outline.
Rendered
Ground Truth
Generated Code:
<svg width="20a 220"" height="2e0" = "http:/ <polygon points="180, 198 http///ww.//.... ong. 2080/svg">
fill=" "lime" stroke= purple""
stroke-width="1P0 /> </svg>
Error: null
Figure 17: Example of successful generation in SVG (ID: 52). The model generates code that executes successfully and produces a plot consistent with the ground truth.
[Back Appendix Contents]
58

---

K.14
SVG: SELF-DEBUG RECOVERY
X
VisCoder2-32B: SVG
ID: : 42
TASK: Generate flowchart illustrating the process for producing W3C Recommendation. The flowchart includes stages such Working Draft (WD), Candidate Recommendation (CR), Proposed Recommendation (PR), and W3C Recommendation (REC). It also includes decision points and possible transitions between these stages, such as advancing to the next stage, returning to previous stage, publishing note. Each stage and decision point labeled with descriptive text.
STYLE: Create a visual with elliptical nodes representing different stages, connected by arrows indicating the flow of the process. The nodes are labeled with abbreviations like WD, CR, PR, and REC, and are filled with white. Text annotations provide additional context for each transition, using small font size. Arrows are solid or dashed, with varying colors to indicate different types of transitions. Some elements are partially transparent to indicate optional paths. The layout is horizontal, with nodes aligned in sequence from left to right.
No Image Rendered
Normal Rendered
WD
CR
PR
REC
Debug Rendered
Ground Truth
Generated
Self-Debug Generated
<5vg
arnow. www.:aauu..aaaa... dashed ()
<style type="text/css">
anrow. fuchsia (}
=///style>>
<defs>.. //defs>>>>
aarrw.fuchss wwwhsia.ccaacccco dasheed (
trans/ort-- 'scalo(0.5)">
aavow.navy ()
<ellipse
arrow. naw.aaasaeeddd {
<text x="548" y="628" font
s1ze="12"> </text>
</p>
</syg>
ExpatError: element found: line 362, column 18.
Figure 18: Example failed generation SVG (ID: 42), where the initial code raises ExPatError and is resolved in the first round of self-debug, resulting in corrected plot that matches the intended semantics. [Back to Appendix Contents]
59

---

K.15
SVG: SELF-DEBUS FAILED
X
VisCoder2-32B: SVG
ID: : 12
TASK: Create horizontal bar chart to compare the usage of different media types by gender, The chart displays five categories: Internet, Newspaper, Magazine, and Radio. Each category has two bars representing data for females and males. The x-axis shows numerical values from 0 to 3, indicating the level of usage preference, while the y-axis lists the media types.
white background with light gray area for the graph. The bars colored with semi-transparent red for females and blue for males. Dashed vertical lines serve as grid lines for reference. Labels for the x-axis are centered below the axis, and y-axis labels are rotated vertically. Data values displayed on the bars. A legend on the right identifies the colors for female and male data. The title 'Question centered the top.
STYLE: The chart
No Image Rendered
No Image Rendered
Normal Rendered
Debug Rendered
Ground Truth
Self-Debug Generated Code
Normal Generated Code
<path />
<path /> <path />
<path />
<path />=//g>=ggg
<path />< >><//><g---
<text Lrria-labe==mmedd
<text Lrriallabe==mmedaa Internet; percentage: 2" ro role=" graphiccs -smuccsssmmool !"
Internet; percentage: 2"
role="graphics--yybbll aria-
oria-rrlledescriotion===t text mark" text- anchor="start"
roledescriptiion="eex mark" text-anchor="startt"
late (13.3333331133333333333
transform""translate 333333331,
2.5
ParseError: unclosed token: line 1, column 14401
Figure 19: Example of a failed generation in SVG (ID: 12), where the initial code raises ParseError and still failed after three rounds self-debug.
BBak to Appendix Contents]
60

---

K.16 LATEX: SUCCESSFUL GENERATION
VisCoder2-32B: LaTeX
ID 33
Task: Generate bar chart comparing the population of two groups labeled 'Far' and 'Near' over series of years. The x-axis represents the years, and the y-axis represents the population size. Each year has two bars, one each group, showing their respective population values.
Style: Create vertical bar chart with distinct colors for each group: blue for 'Far' and red for 'Near' The bars slightly separated to enhance clarity. The y-axis label is rotated vertically the left side. Data values displayed above each bar in corresponding colors. A legend positioned below the chart, centered, indicating which color corresponds to each group. The chart has a clean, simple layout with no gridlines.
4.3
1.5
0.2
1970
Rendered
Ground Truth
Generated Code:
\begin (tiipiicuue)
\begin [
width=12cn, height-8cm,
xlabel-Year,
ylabel-Popuiation,
ybar, bar width=15pt, ymajorgrids=ttre,
xtick-data,
xticklabels from ballee=(dtttabllee (ataaabeeeeeaarra (Year),
legend style-(at-( (8.5, (...,,,).115) 0.15),, anchor-north, legend columns--1] nodes near coords, nodes near coords al align=(vertical. every node near coord/ append style= (font=(tinn)),
Error: null
Figure 20: Example of a successful generation in LaTeX (ID: 33). The model generates code that executes successfully and produces a plot consistent with the ground truth. Back to Appendix Contents]
61

---

K.17 LATEX: SELF-DEBUC RECOVERY
X
VisCoder2-32B: LaTeX
37
Task: Generate a scatter plot using data from a CSV file, where the x-axis represents sample indices and the y-axis represents random values. The plot displays individual data points as marks without connecting lines.
Style: The plot features blue circular markers distributed across graph. The axes are labeled with numerical values, and the grid is not visible. The layout is compact, with data points densely packed, especially along several horizontal bands.
No Image Rendered
Swngl
300
390
300
Normal Rendered
Debug Rendered
Ground Truth
Normal Generated Code
Self Self-Debug Generated Code
kusepackage oerer sep=conna]{
beggin tikzpicture) \begin(oxis)
clabel-Sampin Index,
sample_ie index,,andon,
ylabel-Randon Value, only marks, mark=*,
0.0,8.34476
... ...
399.8,0.27358
nark size-1pt, nark options-(blue). gridenajor, grid
Fldatatable
(abcumentecassssaarrdr---- (etarddreedeeeetttaaalloooo [standalone)
(usepackage(psfplots))
style- (daaeeddddedd,.aae gray 138)
(usepackage(pFFoloottttabal
NameError: LaTTeX rendering failed: LaaTeX Error: \usepackage before (documentclass.
Figure 21: Example of a failed generation in LaTeX (ID: 37), where the initial code raises a NameError and is resolved in the second round of self-debug, resulting in a corrected plot that matches the intended semantics. Back to Appendix Contents)
62

---

K.18
LATEX: SELF-DEBUC FAILED
X
VisCoder2-32B: LaTeX
ID:9) :97
Task: Generate schematic diagram an electrical circuit featuring a voltage source labeled V_s, an inductor labeled L_x, a capacitor labeled C_1, and another inductor labeled L_m on the primary side. The circuit includes a transformer with turns ratio N_ 1:N_2, diode, a capacitor labeled C_2, and resistor labeled R the secondary side. The output voltage denoted v_o(t).
Style: Create a clean and organized layout with components aligned horizontally. The circuit elements are connected with straight lines, and labels are placed near each component for clarity. The transformer is depicted with coils and turns ratio label. The diagram uses simple, monochrome style with consistent line thickness and small font size for labels.
N; No
No Image Rendered
No Image Rendered
Normal Rendered
Debug Rendered
Ground Truth
Normal Generated Code
Self-Debug Generated Code
(begin((Creutttkke (rruutthh)(sccaee [scale:8.8]
(0,0)
(0,6)
tofvsource, s$] (9,4)
ta[vsaunce, 1-dV_s$ s$] (8,4)
tolL, 1-$1 x5] (4,4)
toíL, 1-5L x5] (4,4)
to(c, 1-$__18] (4,0) (0,8);
tolc, 1:sc 15] (4,9) (8,9);
Vdraw (4,4) (5,4)
Ydraw (4,4) (6,4)
tolcute Inductor, 1=$L_m$] (6,0) (4,0);
tolcute inductor, 1=8L_n$] (6,0) (4,9))
Vdrow (6,4) (8,4)
ydrow (6,4) (8,4)
Forseens core] (8,8) (6,8);
fortrans core] (8,9) (6,9);
Vdnaw (9,3.5) tofdiode] (21,3.5)
(9,3.5) ta[diode] (11,3.5) toiC, 1:5C_ 25] (11,8.5) -- (9,9.5)
tofC, 1=$C_ (11,8.5) (9,0.5)
tolR, (9,3.5);
tolR, (9,3.5);
Vdraw (12, (12,3.5)
\draw (11,3.5) (12,3.5)
node[right]] ($v_o(t)5);
node[right] ($v_o(t)8);
Inode[abova at (7,4) (3N_1:N_26); (rcuttkkc (end(docu)wnr)
\node[above]] at (7,4) (SN.1:N_23); Jend(cincu(t(k2) (doruuo))))
NamoError: Package circuitikz Error: Unknown circuitikz element 'vsource'.
Figure 22: Example of a failed generation in LaTeX (ID: 97), where the initial code raises a NameError and is still failed after three rounds self-debug.
[Back to Appendix Contents]
63

---

K.19 ASYMPTOTE: SUCCESSFUL GENERATION
VisCoder2-32B: Asymptote
ID 31
Task: Generate line graph with data points marked along the line. The graph plots series of points connected straight lines, with markers at each data point. The x-axis is labeled with "x" and the y-axis with "y", both featuring tick marks for reference.
Style: Create simple and clean visual with a rectangular frame. The data points are marked with circles, some filled and some outlined, depending their position. The axes have evenly spaced tick marks, and the labels are positioned outside the frame. The overall layout balanced and minimalistic, emphasizing clarity and readability.
50
60
40
40
y 30
y
20
20
20
40
60
80
0
20
40
60
80
100
Rendered
Ground Truth
Generated Code:
import graph;
size 200);
pairl] (-( (0), (15, (90,)))))
draw(graph(()) marker (scaee 8mm) "unitcircle, FillDraw))
xaxis ("x" Bottomm LeftTicks); yaxis ("y"""""t""""""""""""" Left, Righttkkg
Error: null
Figure 23: Example of successful generation Asymptote (ID: 31). The model generates code that executes successfully and produces plot consistent with the ground truth. Back to Appendix Contents]
64

---

K.20 ASYMPTOTE: SELF-DEBUG RECOVERY
X
VisCoder2-32B: Asymptote
:53
Task: Generate logarithmic plot of the identity function over the range of x-values from to 20. The x-axis represents mass in solar units, labeled as /MM/MMY "MMooooos'' and the y-axis represents frequency in Hertz, labeled "$) "$)nu_(Nre upp]S [[zz]". The plot displays straight line indicating direct proportionality between two variables on a logarithmic scale.
Style: Create rectangular plot with a horizontal orientation. The x-axis marked with ticks at intervals of 10, 12, 14, 16, and 18, while the y-axis is marked with ticks ranging from 1 to 100. The plot clean, minimalist style with single line and clear labels for both The layout is simple, focusing on relationship between the two variables without additional embellishments.
Noup [Hu]]
No Image Rendered
[b6]
10
M/Ma
20
M//M2
Normal Rendered
Debug Rendered
Ground Truth
Self-Debug Generated Code
Normal Generated Code
import graph;
Import graph;
size(280, (289,150);
s1ze(288,150)
real[]
x-{5,6,7, 9,,,,,,,,,,1,11,,,,,,,, 1,55,6,7,,,991,,1,,,,,,,,,,,,,,, 17,1
real[]
,18 198,19,28); real[] 2<(1222,15577891111112222.2.33
1,1 real[]
15,
y=(_22.44.,7,,60,0011.......
(ran@grap((xxy))
dnaw(eraph(xxy)) Logiscll,,
xaxis( SM/M_
[odots",,otttooopp.c. _oottonTop,Leftrs
xaxis("SH/M "odotttt Bottontop, Leftiikks;;
cks);
yaxis (\en upp} [Hz] Lefftight, Righttiksk,
yaxis Inu_ ('rmupp SS [H22]" LeftRight, RightTicks);
no matching variable 'LogScale'
Figure 24: Example failed generation Asymptote (ID: 53), where the initial code raises NameError and is resolved in the third round of self-debug, resulting in a corrected plot that matches the intended semanties. Back to Appendix Contents)
65

---

K.21 ASYMPTOTE: SELF-DEBUG FAILED
X
VisCoder2-32B: Asymptote
ID :99
Task: Generate visual comparison of interpolation methods over specified range. The plot includes three curves: Lagrange interpolation represented by dashed line, natural spline shown red,
monotone spline depicted in blue. x-axis labeled with values from 1997 to 2002, while the y-axis ranges from 20 to 40. Data points are marked along the curves. Style: Create clean and organized layout featuring large square plot area. The x-axis and y- axis clearly labeled with regular tick marks. The legend is positioned below the plot, providing clear differentiation between the interpolation methods using distinct colors and line styles. Data points are indicated with small gray dots, enhancing the visual clarity of the curves.
No Image Rendered
No Image Rendered
Normal Rendered
Debug Rendered
Ground Truth
Normal Generated Code
a-1997, b-2882;
Self-Debug Generated Code
int n-5;
real(] vyt-aassoqunco(m==))((
real a-1997, b-2082; int n-S; real[] sptrar=:erenccee==))(((
real[] ypt=(31, 36, 26,
(no]:+tdivxpt..ytt))
Fhorner Lifhemer(hh3;
a)/n;
real[]
guide a,-graph(L,,,, 580); (rau(g,,dashed); dot(gt.red);
ypt-(31,33, 22,,36,,,,2,,,1,22
guide gL-graph(nex real(real
real[] ypt2-(31, 22,22,2222222 22, 24); splinn 52-spline ypt2,,,ttt,,pnnne Splinn (natural))))
return yot[o] (x-
xpt[a])* (yp=[]]]
guide b,2- b88); rrau(gs2,rod));
yat(a]) (xpe [1] xxt(e]);
J, a, 598);
draw(gl gl, dashhed))
real[] ypt3=(31, (3,,,6,,,,, 26,2,,,,22,, 22, 24,2 spline iie (xpt, Spline (nonotone)); guide g53=graph($3, b, 588); draw(gs3, bluee)
red(
TypeError: horner h=diffdivwxpt.yypt) no type 'horner'
Figure 25: Example of failed generation Asymptote (ID: 79), where the initial code raises TypeError and is still failed after three rounds self-debug.
Back Appendix Contents)
66

---

K.22 HTML: SUCCESSFUL GENERATION
VisCoder2-32B: HTML
ID:6
Task: Generate pie chart to display the distribution of various science fiction categories. The chart segments represent different categories, such "Dune," "Neuromancer" " "Hyperion," " "Ender's Game," "The Martian," and "Miscellaneous," with each segment sized according its value. The chart includes labels showing the category name and its percentage of the total. STYLE: Create centered layout with light gray background. The pie chart is placed within white, rounded rectangle with subtle shadow, providing clean and modern look. The title, "Science Fiction Categories Distribution," is centered above the chart in bold, dark gray font. The legend positioned to the right of the pie chart, with category names in smaller font size, each colored to match its corresponding pie segment. Labels on the pie chart are bold and positioned outside the segments for clarity.
NEvrrnancer
6.00%
25%
The Martian
10 1000
Dune
Ender's Game 18,00%
Norrmance
foders Maceelheel tu rinn bit
Enders Came
Aperian ot
17%
Neurbmancer
Gorers
18.00%
Rendered
Ground Truth
Generated Code:
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<titlesPlotly Pie Chart</title>
<script src=""></script>
<styles.. /
</head>
<body>
<div >d="chart">
</div> <scripts.. <//crript> </body>
</html>
Error: null
Figure 26: Example of a successful generation in HTML (ID: 6). The model generates code that executes successfully and produces a plot consistent with the ground truth. [Back to Appendix Contents]
67

---

K.23 HTML: SELF-DEBUC RECOVERY
X
VisCoder2-32B: HTML
:
Task: Generate radial bar chart visualize the number of GitHub stars for various AntV projects. Each bar represents a project, with the length corresponding to the star count. The bars are color-coded based on the number of stars, with different colors indicating different ranges of star counts. The chart includes central annotation displaying the total number of stars across all projects.
Style: Create circular chart with a white background and subtle shadow effect. The bars are arranged in radial pattern, with rounded ends and varying colors. The chart is centered on the page, with title above it Inside the chart, there is central text with GitHub icon, the word "AntV," and the total star count blue. The overall layout clean and balanced, with modern aesthetic.
Projects Stare Analyat
No Image Rendered
ArRV
AntV-br/-GtHHub Stara
Normal Rendered
Debug Rendered
Ground Truth
Nornal Generated Code
Self-Debug Generated
<script>
annotations: [
annotations:
(...),
type: 'text' pasition: ('583' '50%'1,
type: 'inage' start: ['58%' '58%'],
content: 'AntV-br/>GitHu
Stars'
style:
con/
con/zos zos wwon/////aaseeenttt////////////e aassenet__prod/666 2ra52-
38e5a22
fantSize: 24,
fill: '#333'
64,
textAlign: 'center', textBase 'middle"
height: 64, offsety: -128
bender))der();; </script>
</script>
</body> </html>
</body> </htnl>
ImportError: HITML Request failed: https:/ https://........svvv (404 Not Found).
Figure 27: Example of failed generation in HTML (ID: 9), where the initial code raises a ImportError and is resolved in the first round of self-debug, resulting in corrected plot that matches the intended semantics. [aak Appendix Contents)
68

---

K.24 HTML: SELF-DEBUC FAILED
X
VisCoder2-32B: HTML
ID :85
Task: Generate a calendar heatmap to visualize daily website traffic analytics for year 2023, Each day is represented by square, with the color intensity indicating the volume of unique visitors. The data includes variations based weekly patterns, monthly multipliers, and special events holidays that affect traffic levels.
Style: Create a centered layout with light background and white container featuring rounded corners and a shadow effect. The title and subtitle are displayed at the top in bold and smaller text, respectively. The calendar heatmap positioned below, with months labeled at the top and days of the week indicated. color gradient bar the bottom illustrates the traffic intensity, with darker colors representing higher traffic. Additional text explains the color coding.
Daily Websito Troffo Analytics
No Image Rendered
No Image Rendered
Normal Rendered
Debug Rendered
Ground Truth
Normal Generated Code
Self-Debug Generated
constetx--doumonnt.p conseets-brrunnt.oeeleeeeeee Byt.eeennntt.......eeeentttti 'calendarHeatmapp >ogttoott 'dd
')3
<titlee>alendar Heatmap 2823 Nebsite Traffics/title:
newchart(ctx,,
type: 'calendan',
data:
elivn. http:///m/chaattjss""" cript>
label;
'ünique Visitors', calendardata,
<scriptsrca"nttps://cee
backgroundCalor: "rgba(54, 162, 235, 0.7)
elivr.net/ met//pm/charttee
borderColon: "rgba(54, 162, 235, 1)',
adapter date- >4sscriitt
borderkidth: 1,
color: {
eliwe.net/ngm//chrrree chart
nax: 1880,
calendang1. wtt......./dee e.e/dist/chartjjs
emoty: "0000"
-chart-
calendar, min js "///"////cppppp
}1
TypeError: HT.M rendering error: "calendar' is registered controller.
Figure 28: Example of failed generation in HTML (ID: 85), where the initial code raises TypeError and is still failed after three rounds self-debug.
[Back to Appendix Contents]
69

---

L LLM USAGE
Large Language Models (LLMs) were used to assist with language editing and polishing of the manuscript. Specifically, we used LLM refine wording, improve readability, and enhance clarity in several sections.
The LLM was involved in research ideation, methodology, data analysis, experimental design. All technical ideas, analyses, and conclusions were developed and validated by the authors; the tool was limited editorial support.
The authors take full responsibility for the content of the manuscript, including any text edited with LLM assistance. We verified suggested edits for accuracy and originality, ensured compliance with ethical guidelines, and noted that LLMs are not listed as authors. We disclose this usage in accordance with ICLR's policies on LLM assistance and attribution.
70


Reviews:
[{"review_id": "axI3jKVnz3", "reviewer": "Reviewer_R3P7", "summary": "This paper introduces VisCoder2, a framework for building multi-language visualization coding agents. Specifically, the work contain three key components: VisCode-Multi-679K, a large-scale dataset of 679K executable visualization code–image pairs with multi-turn correction dialogues across 12 programming languages; VisPlotBench, a benchmark spanning 8 languages and 13 visualization categories, supporting both single-round and multi-round self-debug evaluation; VisCoder2, a family of open-source multi-language models trained on the above dataset.", "questions": "1. The current LLMs like GPT-5 can also support image input. Is it possible to extend the current dataset? e.g., provide the image input and request code output. \n2.  It is better to provide the process of self-debug and better evaluation results.", "limitations": "", "rating": 8, "confidence": 4, "soundness": 3, "presentation": 1, "contribution": 3, "strengths": "1. The author provides a comprehensive dataset construction. They detail a well-structured pipeline including language filtering, runtime validation, and instruction synthesis. Each visualization sample is paired with rendered outputs and multi-turn feedback, ensuring executable, realistic supervision. Compared to the previous method, VisCode-Multi-679K supports 12 languages, which makes its coverage cover most languages.  \n2. The author provides extensive experiments; the proposed VisCoder surpasses open-source baselines by 10–15 points in execution pass rate and achieves parity with GPT-4.1 on several languages. The analysis of self-debug gains and error types (syntax vs. runtime vs. semantic) is particularly insightful.\n3. The paper is well-organized and easy to follow.", "weaknesses": "1. The detail of self-debugging is missed. The paper demonstrates that iterative correction improves performance, but it does not deeply analyze how models leverage feedback logs. It is better to describe how the self-debug works. Moreover, the author shows that there are persistent failures in semantic and runtime errors. It is also better to provide an analysis of why self-debugging does not work on these cases rather than just saying it doesn't work.\n2.  The current evaluation is imbalanced. Execution pass rate dominates the quantitative results, whereas semantic accuracy and visual similarity (Task/Visual Scores) are only partially reported. I understand the space is limited, and the author provides full results in the appendix. However, compared to the execution pass rate, whether the generated results are correct is more important. If possible, it is better to manually check the results and report the correctness for every model. \n3. Both the training corpus (VisCoder) and the evaluation benchmark (VisPlotBench) are constructed by the authors and share the same generation–execution–debug protocol. The paper does not evaluate zero-shot transfer to unseen visualization libraries, natural user prompts, or noisy real-world code, leaving generalization ability uncertain, which limits the usage of the model. It is better to provide natural user test results.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "x5Sb0nSswz", "reviewer": "Reviewer_4iTA", "summary": "The paper introduces VisCoder2, a large-scale dataset and benchmark for multi-domain, multilingual visual code generation. It integrates code, visual plots, and textual prompts across 12 programming languages and multiple application domains (data visualization, UI generation, etc.). The benchmark aims to evaluate both code correctness and visual fidelity in multi-turn coding tasks. The dataset fills an important gap in current research, providing a broader and more diverse benchmark than existing ones like PandasPlotBench. Experiment results demonstrate the effectiveness of the proposed training data.", "questions": "- How were the “visual” and “task” metrics computed? Are they human-judged, automatic, or hybrid?\n\n- What criteria guided the choice of 8 evaluation languages — were they the largest subsets, or randomly sampled?\n\n- How does the model perform on existing benchmarks like PandasPlotBench? Any transfer results?\n\n- Does the multi-turn data actually improve multimodal debugging? Or just the general debugging ability shared by regular code LLMs?", "limitations": "", "rating": 4, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "- Comprehensive dataset coverage: The dataset spans multiple languages and visual domains, filling a real void in existing benchmarks which are typically language- or task-limited.\n\n- Practical relevance: Targets the emerging need for models capable of generating visual outputs (plots, figures, GUIs) from natural-language instructions.\n\n- Readable and well-structured writing: The paper is easy to follow, with clear organization and accessible examples.", "weaknesses": "- Weak multi-turn construction: The “multi-turn” setup seems artificial — simply mixing in existing conversational code data rather than building domain-specific, multimodal dialogues. This undermines the claimed contribution on multi-turn reasoning.\n\n- Incomplete evaluation coverage: Although 12 languages are used for training, only 8 are evaluated. The absence of results for the remaining languages leaves the dataset’s multilingual utility unverified.\n\n- Limited baseline comparison: The model is only evaluated on the proposed benchmark. There’s no comparison against other visual code generation benchmarks (e.g., PandasPlotBench), making it hard to assess generalization.\n\n- Unclear metrics: The paper introduces “visual” and “task” scores but fails to define how visual quality is assessed. For visual generation, perceptual and structural accuracy are as important as code execution success.\n\n- Missing analysis on debug capability: Given the inclusion of multi-turn data, it’s surprising that no explicit debugging evaluation is performed, nor any comparison to instruction-tuned models like Qwen2.5 Coder Instruct. This weakens claims of enhanced reasoning or debugging ability.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "NIk6osCnVF", "reviewer": "Reviewer_ipL2", "summary": "The authors propose VisCoder2, a multi-language visualization coding agent designed to generate, execute, and iteratively correct visualization code. To support this, they introduce VisCode-Multi-679K, a large-scale dataset of executable visualization code and correction dialogues across twelve programming languages, and VisPlotBench, a diverse benchmark for systematic evaluation. Experiments show that VisCoder2 outperforms open-source baselines and matches the reliability of proprietary models like GPT-4.1, especially with self-debugging. These resources advance the development of practical, robust visualization coding agents.", "questions": "Please address my concern in the Quantitative Analysis. Thanks", "limitations": "", "rating": 8, "confidence": 3, "soundness": 2, "presentation": 4, "contribution": 4, "strengths": "* **Focus on an Important Problem:**\n\n  The paper targets automatic visualization code generation and correction, a task that is increasingly important for data analysis and reporting with LLMs but still lacks robust, multi-language solutions.\n\n* **High-Quality, Multi-Language Dataset:**\n\n  VisCode-Multi-679K covers twelve programming languages, including both popular and symbolic ones. The dataset is large-scale, contains only executable code, and includes multi-turn correction dialogues. These features make it valuable for developing and benchmarking robust visualization coding agents.\n\n* **Effective Application of Iterative Correction:**\n\n    The paper proposes an iterative correction approach that, while not highly novel (being similar to established program repair methods), is effective in practice. The results show significant improvements.", "weaknesses": "* **Lack of Quantitative Dataset Analysis:**\n\n  The paper does not provide sufficient quantitative metrics about the dataset (such as error rates, diversity, redundancy, or semantic alignment). Without these, it is difficult to fully evaluate the dataset’s quality and practical value.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "feqg85ZiXv", "reviewer": "Reviewer_wBjo", "summary": "This paper studies the task of generating visualization code from natural language instructions. It introduces VisCode-Multi-679K, a large multi-language dataset containing executable code-image pairs and multi-turn correction dialogues; VisPlotBench, a benchmark for evaluation; and VisCoder2, a fine-tuned model based on Qwen2.5-Coder. Experiments show that VisCoder2 outperforms open-source baselines and approaches the performance of proprietary models like GPT-4.1, with further gains from iterative self-debug.", "questions": "- Line 427: \"Execution success is high across most models\" --> the execution success of which models?\n- Why does Qwen2.5-Coder-32B-Instruct perform worse than the 14B model in Table 2?\n- How are the training and testing data split? How do you guarantee the quality and independence of the training and testing sets?\n- Lines 396–398: What does \"LilyPond shows the largest gains on symbolic grammars\" mean? And what does “SVG exposes model-library sensitivity where semantic and perceptual signals diverge\" mean?\n- Regarding the fine-tuned models: how do they perform on other benchmarks? Does the model lose its capabilities on other types of tasks (e.g., MMMU, HumanEval)?\n- How does performance scale with the number of self-debugging rounds? Do more rounds lead to better performance? Is there a saturation point? More analysis would be helpful.", "limitations": "", "rating": 2, "confidence": 4, "soundness": 2, "presentation": 3, "contribution": 2, "strengths": "- S1: A large multi-language dataset and a benchmark are introduced; both are useful to the community.\n- S2: The overall task setting aligns with real-world needs and is worth studying.\n- S3: The fine-tuned models VisCoder2 show good performance in terms of execution pass rate.", "weaknesses": "- W1: The dataset is curated by combining existing datasets with filtering and cleaning, so the dataset contribution feels limited.\n- W2: The paper evaluates different coding models (mostly scaling within the same model family). Including a wider range of models (e.g., GPT-5 or reasoning-oriented models) would make the comparisons more informative; scaling size alone is not very insightful, as larger models usually perform better.\n- W3: More discussion is needed on the evaluation protocol (Section 3.4). Evaluating visual outputs semantically is inherently challenging, as it requires judging whether the generated image aligns with the textual task. Therefore, the key metrics -- Task Score  and Visual Score -- are important. However, both are judged using an LLM-as-a-judge, whose reliability is neither validated nor justified in this benchmark. Can the LLM accurately evaluate these metrics? If yes, to what extent? A more detailed analysis is needed.\n- W4: The paper’s results rely heavily on the execution pass rate, which is not highly informative. Execution success only indicates that the code runs without errors, but one could “cheat” by outputting syntactically valid yet semantically incorrect code. This makes the analysis less convincing. More discussion and results based on the Task Score and Visual Score would make the evaluation more meaningful.\n- W5: It would be valuable to analyze why other models (e.g., GPT-4.1) fail and to explain how fine-tuning helps reduce specific types of errors. Which errors does fine-tuning effectively mitigate, and which remain challenging? What insights can be drawn for practitioners to improve visualization-coding models?\n- W6: The author claims that they are building \"Coding Agents\". But there is no real autonomous loop, planning, or tool integration -- only self-debugging within a single model. So the use of \"agent\" feels somehow overclaimed.\n- W7: The paper lacks sufficient task statistics for the benchmark dataset (e.g., category distribution, code length distribution, difficulty distribution, etc.). Some statistics are provided, but more detailed and fine-grained statistics would strengthen the paper’s contribution as a benchmark paper.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)