Pith. sign in

REVIEW 5 major objections 7 minor 4 cited by

SVRepair: Structured Visual Reasoning for Automated Program Repair

T0 review · 5 major / 7 minor · reviewed 2026-08-04 · deepseek-v4-flash

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

Pith's one-line read SVRepair claims that translating bug screenshots into structured semantic scene graphs, then iteratively cropping to bug-centered regions, lets a coding agent fix visual bugs at higher rates than unimodal or raw-image methods.

desk verdict A novel structured-visual-reasoning idea for APR, undermined by inconsistent headline numbers—the SOTA claim needs a denominator fix before it can be taken seriously. read the letter →

arxiv 2602.06090 v2 pith:I54V3OKP submitted 2026-02-05 cs.SE cs.AIcs.CV

Jincheng Wang , Liwei Luo , Xiaoxuan Tang , Jingxuan Xu , Sheng Zhou , Dajun Chen , Wei Jiang , Yong Li This is my paper
classification cs.SEcs.AIcs.CV
keywords automatedprogramrepairmultimodalLLMsemanticscenegraphvisualartifactsegmentationfaultlocalizationSWE-BenchMMermaidvision-languagemodel
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

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

The reading

The paper tries to establish that structured visual reasoning improves automated program repair. Its central move is to fine-tune a vision-language model to turn screenshots and control-flow graphs into a textual 'semantic scene graph' that lists GUI elements and their hierarchical relations, then feed that graph to a coding agent that localizes and patches the fault. A second mechanism recursively segments the original image, focusing each repair round on the region most likely to contain the bug. On SWE-Bench M the full system reports a Pass@1 of 36.47%, and on the two supplementary code-from-vision benchmarks it reaches 38.02% and 95.12%.

What carries the argument

Semantic Scene Graph (SSG): a directed graph whose nodes are visual elements (HTML nodes, CFG basic blocks) and whose edges carry relation types (composition hierarchy, control flow, data flow), serialized into Mermaid syntax for the coding LLM. The SVR model is a fine-tuned Qwen3-VL-8B trained on WebSight HTML/DOM pairs and staticfg control-flow graphs. The third component is the iterative visual-artifact segmenter, a larger VLM that predicts a bounding box for the buggy region and crops the image for the next round.

What would settle it

Measure whether SVRepair's Pass@1 on SWE-Bench M drops to the unimodal baseline when the SVR module is replaced by a generic image captioner (or by SVR fine-tuned on a small held-out set of real SWE-Bench M images). A drop to baseline would show the scene graph, not the agent's search, is doing the work; no drop would undermine the paper's causal story.

Watch

Extended reading notes

Core claim

The authors contend that the bottleneck in multimodal program repair is not visual perception but representation: raw screenshots fed to a multimodal LLM cause context loss and noise, so the LLM cannot ground the image in code. SVRepair's contribution is to replace the raw image with a normalized intermediate structure — a Semantic Scene Graph serialized as Mermaid text — and to iterate on it: a segmenter crops the image to the suspected bug region, the SVR model re-graphs that crop, and the coding agent retries localization and patching. The reported gains over prior visual-repair systems and over the authors' own unimodal baseline are attributed to this representation and to the iterative

Load-bearing premise

The SVR model is trained only on clean, synthetic HTML/DOM pairs and control-flow graphs extracted with staticfg, yet it is deployed on noisy, real-world SWE-Bench M screenshots with no in-domain fine-tuning; the entire pipeline's benefit on that benchmark depends on this transfer producing code-relevant scene graphs.

Editorial extensions

If this is right

  • Visual bug reports can be repaired automatically without losing the diagnostic signal present in screenshots.
  • An 8B-parameter vision-language model fine-tuned on structured pairs can match or beat much larger general VLMs on diagram-to-structure parsing.
  • Iterative cropping of the visual artifact is what unlocks gains on noisy real-world repo issues; it does not help on noise-free code-generation benchmarks.
  • The same pipeline transfers, with no change, to code generation from flowcharts and competition problems (MMCode, CodeVision).

Reading between the lines

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

  • The SSG format is agnostic to artifact type; sequence diagrams, UML class diagrams, or architecture diagrams could be supported by fine-tuning SVR on those pairs, making the framework a general visual-to-code bridge.
  • Because the segmentation step relies on an external large VLM, the marginal cost of SVRepair scales with the number of failed patch attempts; a cheaper, learned segmenter could be a natural follow-up.
  • A direct test of the transfer assumption would be to fine-tune SVR on a handful of real SWE-Bench M screenshots and measure whether Pass@1 changes; the paper's current numbers leave the domain gap unmeasured.
  • The unimodal-to-vision gap on CodeVision (51.83% to 95.12%) suggests that the biggest wins are in tasks where the image is essentially a specification; in noisy settings the graph's filtering role, not just its structure, may be what matters.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

5 major / 7 minor

Summary. The paper proposes SVRepair, a multimodal automated program repair framework. It fine-tunes Qwen3-VL-8B on WebSight HTML/DOM pairs and staticfg control-flow graphs to produce a textual Mermaid-based Semantic Scene Graph (SSG) from bug-related images. A coding agent (GPT-o3) uses the SSG plus the repository to localize bugs and generate patches, with an iterative visual-artifact segmentation loop (Qwen3-VL-235B) that crops to bug-centered regions when patch validation fails. Experiments are reported on SWE-Bench M (186/517 resolved, 36.47% Pass@1 over submitted runs / 35.98% over all instances), MMCode (38.02%), and CodeVision (95.12%/95.73% in abstract), with ablations V1-V4 and a Mermaid rendering fidelity study (Table 4). The central claim is state-of-the-art performance on multimodal APR through structured visual representation.

Significance. If the reported numbers hold, the paper makes a useful contribution: it provides evidence that a compact fine-tuned VLM can convert screenshots into a code-relevant intermediate graph that improves fault localization and patch generation, and it quantifies the benefit of iterative visual cropping. The method is largely reproducible in design (open model, public code link, detailed prompts in appendices), and the SVR training setup is simple and transparent. The strength of the paper is the idea of normalizing visual artifacts into a structured textual graph rather than feeding raw images to the coding agent. However, the load-bearing evidence is currently undermined by arithmetic inconsistencies in the headline SWE-Bench M result and ambiguous evaluation-subset definitions, so the significance assessment is conditional.

major comments (5)
  1. [Abstract / §4.2–4.3, Table 1] The headline Pass@1 numbers are arithmetically inconsistent. The abstract reports 186/517 SWE-Bench M instances (35.98% over all instances; 36.47% over submitted runs), which implies 186/510 ≈ 36.47% submitted runs. But §4.2 states that SWE-Bench M consists of 617 task instances. If the benchmark has 617 instances, then 186/617 = 30.15%, which is below GUIRepair (35.98%) and OpenHands-Versa (34.43%) in Table 1, invalidating the claimed SOTA. If the evaluation was restricted to a 517-instance subset, the paper must state this explicitly, justify the subset, and show that all baselines in Table 1 were evaluated on the same subset. Without a consistent denominator and a shared evaluation set, the central claim is not verifiable.
  2. [Abstract vs. §4.3, Table 2] The CodeVision result is reported as 95.73% in the abstract and as 95.12% in Table 2 and §4.3. Similarly, OmniGIRL appears only in the abstract (4/19, 21.05%) and is never mentioned again in the experimental sections, including the benchmark description, Table 1, or the effectiveness section. These discrepancies must be reconciled. The stated CodeVision value affects the 'outperforming all baselines' claim, and the OmniGIRL result is part of the abstract's evidence but no method or evaluation details are provided for it.
  3. [§3.1 / §4.1] The training description is internally inconsistent and incomplete. The paper says SVR is fine-tuned on WebSight (HTML/DOM) and 37 GitHub repositories' staticfg control-flow graphs, but no dataset sizes, class balance, or preprocessing details are given. More importantly, §4.1 states 'The training is performed on 8 NVIDIA H20 96GB GPUs, and the process includes three epochs' and then two sentences later says 'The model is trained for 2 epochs.' This is a concrete contradiction that matters for reproducibility. The transfer claim — that a model trained only on clean HTML/DOM and CFG images produces useful SSGs for noisy, in-the-wild screenshots in SWE-Bench M — is central to the method, but no in-domain or noisy-image evaluation is provided beyond the 1,300 CFG parse benchmark in §4.4. The paper should report the actual epoch count and provide evidence on real bug-report screenshots (e.g.
  4. [§4.4, Table 3] The ablation table is missing numbers: row (3) has '35.0138.02' for SWE-Bench M (presumably '35.01' and '38.02' concatenated), and row (4) has only SWE-Bench M. The narrative explains that feedback was not applied to MMCode/CodeVision, but the table does not show the V4 rows for those benchmarks, making it impossible to verify the claim that V4 equalled V3 on those benchmarks. Also, V2 (+Vision) on SWE-Bench M is only 33.08% vs V1's 32.88%, which is a small gain; this is fine but the text's phrase 'nuanced' is vague. Please report complete numbers.
  5. [§4.2 / Table 1] The baseline numbers appear to be taken from other papers, but the evaluation conditions are not fully specified: are all baselines run on the same Docker environment, same test harness, same subset (if any), same number of attempts, and same compute budget? The only methodological comparison given is that GUIRepair uses multi-sampling up to 40 candidates, while SVRepair uses greedy decoding. However, Table 1 reports a single Pass@1 number per method without clarifying whether Pass@1 is the best-of-N or first-attempt rate for baselines. Since the central claim is SOTA, the comparison must be apples-to-apples or at least clearly qualified.
minor comments (7)
  1. [Abstract / §1 / §4.3] The abstract says '36.47% accuracy on SWE-Bench M', '95.12% on CodeVision', and '186/517', while the body says '95.12%' and '36.47%'. Please ensure all numbers are consistent across abstract, introduction, and results.
  2. [§3.1] The term 'directed cyclic graph' is odd for a DOM tree or control-flow graph. A CFG may have cycles, but a DOM tree is acyclic. Please clarify whether the SSG is a general directed graph.
  3. [§4.4 / Table 4] The Mermaid parsing benchmark is described as '1,300 code-control flow graph pairs' and later 'code-control flow graph pairs from high-starred GitHub repositories'. It is unclear whether these are held-out from the SVR training set. Please specify the split to avoid optimism bias.
  4. [§4.5, Figure 3] The case study legend is difficult to read: 'SVRepairw/o feedback loop' and 'SVRepair' are concatenated. Please clean up the figure captions and labels.
  5. [§6] The limitation section says 'threshold of three rounds is generally sufficient' in §3.3 and 'e.g., k=2' in §6. Please reconcile the default iteration threshold.
  6. [Related Work / References] Some references are duplicated or incomplete (e.g., Laurençon et al. appears twice; the Refact URL is split across lines). Please check formatting.
  7. [§4.1] The implementation details are too terse: no learning rate schedule, warmup, batch size, LoRA rank if any, or image resolution. For a paper that introduces a fine-tuned model, these details are needed for reproducibility.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: SVRepair's SVR model is trained on external corpora (WebSight HTML/DOM and staticfg CFGs) and the downstream repair/segmentation loop uses test feedback and a separate Qwen3-VL grounding model, so no prediction reduces to a fitted input, definitional identity, or self-citation chain.

full rationale

The paper's derivation chain is empirical rather than definitional. SVR is trained on (image, SSG) pairs constructed from WebSight HTML/DOM and control-flow graphs from high-rating GitHub repositories (Section 3.1), none of which are SWE-Bench M, MMCode, or CodeVision target patches. The coding agent then consumes the SSG with the repository and validates patches against test suites; the iterative visual-artifact segmentation uses a pre-trained Qwen3-VL model prompted with the bug report, localized code snippets, and previous patch feedback (Section 3.3), not the gold patch. The central claim is supported by ablations (V1 unimodal, V2 vision, V3 SVR, V4 segmentation) that show incremental effects, so the contribution is not assumed by construction. There is no load-bearing self-citation: baselines such as GUIRepair, OpenHands, and Agentless are external works, and no uniqueness theorem or ansatz is imported from the authors' prior papers. The Mermaid parsing diagnostic (Table 4) is evaluated on 1,300 CFG pairs built from high-starred GitHub repositories that overlap in distribution with the training data, but it is presented as a model-capability check rather than as the APR prediction, and the APR results themselves are not derived from this diagnostic. The discrepancies in the SWE-Bench M denominator (517 vs 617 in Section 4.2) and CodeVision numbers (abstract 95.73 vs body 95.12) are serious reporting/consistency concerns that affect verifiability of the SOTA claim, but they are not circularity: they do not make any reported Pass@1 equal to a fitted parameter or to the evaluation input by construction. Therefore, no circular step is demonstrated.

Assumptions & free parameters 2 free parameters · 5 assumptions · 1 invented entities

The central claim rests on three families of assumptions: (1) the fine-tuned SVR model transfers from its structured training sources to noisy real-world screenshots; (2) the Mermaid-serialized SSG is a lossless-enough conduit of visual information for repair; and (3) the benchmark reformulations and iteration rules are valid evaluation choices. No target-benchmark fitting is evident, but the domain-transfer and representation-fidelity assumptions are load-bearing and untested in isolation.

free parameters (2)
  • Max segmentation iterations = 3
    Section 3.3 sets a maximum iteration threshold of three rounds based on 'typical complexity' with no sensitivity analysis; the final SWE-Bench M result depends on this hand-chosen stopping rule.
  • SVR training epochs = 2 (one sentence says 3)
    Section 4.1 first says training includes three epochs, then says the model is trained for 2 epochs; the learning rate is fixed at 1e-5 with no sweep. Either way it is a hyperparameter not shown to be robust.
assumptions (5)
  • domain assumption SVR fine-tuned on WebSight HTML/DOM pairs and staticfg control-flow graphs generalizes to real bug-report screenshots in SWE-Bench M.
    Section 3.1 describes training data only from these two structured sources; no in-domain fine-tuning or transfer analysis on SWE-Bench M images is reported.
  • domain assumption A semantic scene graph serialized as Mermaid text preserves the code-relevant content of a visual artifact (element attributes and hierarchy).
    Section 3.1 claims the SSG 'preserves the critical context necessary for comprehensive issue understanding' without a formal information-loss or completeness argument.
  • domain assumption Iteratively cropping to a predicted bounding box removes noise while retaining all bug-relevant pixels.
    Section 3.3 relies on Qwen3-VL-235B bounding-box predictions; if the crop excludes the actual buggy component, the refinement loop cannot recover from the error.
  • ad hoc to paper MMCode and CodeVision can be treated as APR tasks by rewriting requirements as issue descriptions.
    Section 4.2 explicitly reformulates code-generation benchmarks as repair tasks; this is a task-framing choice made for this paper, not a property of the original benchmarks.
  • domain assumption Standard autoregressive fine-tuning on (image, SSG) pairs produces visual grounding of adequate fidelity for downstream code repair.
    Section 3.1 uses a standard next-token-prediction objective; the paper provides no evidence that this objective optimizes for the code-relevance of the extracted graph.
invented entities (1)
  • Semantic Scene Graph (SSG)
    purpose: A Mermaid-serialized textual representation of visual artifacts, capturing GUI elements and their hierarchy/control-flow relations, intended to bridge screenshots and code for APR.
    SSG is a new conceptual representation introduced in this paper; its fidelity is evaluated only through downstream benchmark Pass@1 and Mermaid rendering metrics, with no external validation that it is a faithful or sufficient code-relevant representation of arbitrary bug screenshots.

how reviews work

0 comments
Cite this review

Pith. "Pith review of SVRepair: Structured Visual Reasoning for Automated Program Repair." pith.science (2026). https://pith.science/paper/I54V3OKP

@misc{pith2026260206090,
  author       = {Pith},
  title        = {Pith review of: SVRepair: Structured Visual Reasoning for Automated Program Repair},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/I54V3OKP}},
  note         = {Machine review of arXiv:2602.06090}
}
read the original abstract

Large language models (LLMs) have recently been applied to Automated Program Repair (APR), yet most existing approaches remain unimodal and fail to use diagnostic signals contained in visual artifacts such as screenshots and control-flow graphs. In practice, many bug reports convey critical information visually (e.g., layout breakage or missing widgets), but directly using such dense visual inputs often causes context loss and noise, making it difficult for MLLMs to ground visual observations into precise fault localization and executable patches. To bridge this semantic gap, we propose \textbf{SVRepair}, a multimodal APR framework with Structured Visual Representation (SVR). SVRepair first fine-tunes a vision-language model, SVR, to uniformly transform heterogeneous visual artifacts into a \emph{semantic scene graph} that captures GUI elements and their structural relations (e.g., hierarchy), providing normalized, code-relevant context for downstream repair. Building on the graph, SVRepair drives a coding agent to localize faults and synthesize patches, and further introduces an iterative visual-artifact segmentation strategy that progressively narrows the input to bug-centered regions to suppress irrelevant context and reduce hallucinations. Across primary repository-level APR benchmarks, SVRepair resolves \textbf{186/517} SWE-Bench M instances (\textbf{35.98\%} over all instances; \textbf{36.47\%} over submitted runs) and \textbf{4/19} visual OmniGIRL instances (\textbf{21.05\%}). On supplementary structured multimodal code reasoning benchmarks, SVRepair reaches \textbf{38.02\%} on MMCode and \textbf{95.73\%} on CodeVision. Code is available at https://github.com/codefuse-ai/CodeFuse-SVR.

Figures

Figures reproduced from arXiv: 2602.06090 by the authors.

Figure 1
Figure 1. Comparison between traditional Multimodal APR and the proposed SVRepair framework. [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Architecture of SVRepair. The overall workflow comprises three core components: (1) the [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. The case study comparing a traditional method with SVRepair. [PITH_FULL_IMAGE:figures/full_fig_p010_3.png] view at source ↗

Discussion (0). Sign in to comment.

Forward citations

Cited by 4 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score.

  1. LLM Agents Can See Code Repositories

    cs.SE 2026-06 unverdicted novelty 7.0 of 10

    Visual graphs of repository structure added to text inputs for multimodal LLM agents reduce token consumption by up to 26% while maintaining or improving issue-resolution accuracy.

  2. Beyond Textual Repository Exploration: Dual-Modal Structural Reasoning for Agentic Issue Resolution

    cs.SE 2026-07 unverdicted novelty 6.0 of 10

    DUALVIEW is a dual-modal framework using Module Coupling, Function Call, Class Hierarchy, and Program Dependence graphs to enable persistent structural reasoning for agentic issue resolution, reporting gains on SWE-be...

  3. LLM Agents Can See Code Repositories

    cs.SE 2026-06 conditional novelty 6.0 of 10

    Adding visual dependency-graph images to a text-based coding agent cuts token consumption by up to 26% while keeping issue-resolution accuracy roughly unchanged.

  4. GALA: Multimodal Graph Alignment for Bug Localization in Automated Program Repair

    cs.SE 2026-04 unverdicted novelty 6.0 of 10

    GALA uses hierarchical graph alignment between UI screenshots and code structures to achieve state-of-the-art bug localization in multimodal automated program repair on SWE-bench.

Reference graph

Works this paper leans on

46 extracted references · 16 linked inside Pith · cited by 3 Pith papers

  1. [1]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION format.date year duplicate empty "emp...

  2. [2]

    Claudeai, 2025

    Anthropic. Claudeai, 2025. URL https://claude.ai/

    2025

  3. [3]

    Swe-search: Enhancing software agents with monte carlo tree search and iterative refinement

    Antonis Antoniades, Albert \"O rwall, Kexun Zhang, Yuxi Xie, Anirudh Goyal, and William Wang. Swe-search: Enhancing software agents with monte carlo tree search and iterative refinement. arXiv preprint arXiv:2410.20285, 2024

    arXiv 2024

  4. [4]

    Shuai Bai, Keqin Chen, Xuejing Liu, Jialin Wang, Wenbin Ge, Sibo Song, Kai Dang, Peng Wang, Shijie Wang, Jun Tang, et al. Qwen2. 5-vl technical report. arXiv preprint arXiv:2502.13923, 2025

    arXiv 2025

  5. [5]

    pix2code: Generating code from a graphical user interface screenshot

    Tony Beltramelli. pix2code: Generating code from a graphical user interface screenshot. In Proceedings of the ACM SIGCHI symposium on engineering interactive computing systems, pp.\ 1--6, 2018

    2018

  6. [6]

    Evaluating large language models trained on code

    Mark Chen. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374, 2021

    arXiv 2021

  7. [7]

    Automated repair of programs from large language models

    Zhiyu Fan, Xiang Gao, Martin Mirchev, Abhik Roychoudhury, and Shin Hwei Tan. Automated repair of programs from large language models. In 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE), pp.\ 1469--1481. IEEE, 2023

    2023

  8. [8]

    Webcode2m: A real-world dataset for code generation from webpage designs

    Yi Gui, Zhen Li, Yao Wan, Yemin Shi, Hongyu Zhang, Bohua Chen, Yi Su, Dongping Chen, Siyuan Wu, Xing Zhou, et al. Webcode2m: A real-world dataset for code generation from webpage designs. In Proceedings of the ACM on Web Conference 2025, pp.\ 1834--1845, 2025

    2025

Show all 46 references
  1. [9]

    Evolving paradigms in automated program repair: Taxonomy, challenges, and opportunities

    Kai Huang, Zhengzi Xu, Su Yang, Hongyu Sun, Xuejun Li, Zheng Yan, and Yuqing Zhang. Evolving paradigms in automated program repair: Taxonomy, challenges, and opportunities. ACM Computing Surveys, 57 0 (2): 0 1--43, 2024

    2024

  2. [10]

    Seeing is fixing: Cross-modal reasoning with multimodal llms for visual software issue fixing

    Kai Huang, Jian Zhang, Xiaofei Xie, and Chunyang Chen. Seeing is fixing: Cross-modal reasoning with multimodal llms for visual software issue fixing. arXiv preprint arXiv:2506.16136, 2025

    2025 arXiv

  3. [11]

    Gpt-4o system card

    Aaron Hurst, Adam Lerer, Adam P Goucher, Adam Perelman, Aditya Ramesh, Aidan Clark, AJ Ostrow, Akila Welihinda, Alan Hayes, Alec Radford, et al. Gpt-4o system card. arXiv preprint arXiv:2410.21276, 2024

    2024 arXiv

  4. [12]

    Impact of code language models on automated program repair

    Nan Jiang, Kevin Liu, Thibaud Lutellier, and Lin Tan. Impact of code language models on automated program repair. In 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE), pp.\ 1430--1442. IEEE, 2023

    2023

  5. [13]

    Swe-bench: Can language models resolve real-world github issues? arXiv preprint arXiv:2310.06770, 2023

    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

    2023 arXiv

  6. [14]

    Unlocking the conversion of web screenshots into html code with the websight dataset

    Hugo Lauren c on, L \'e o Tronchon, and Victor Sanh. Unlocking the conversion of web screenshots into html code with the websight dataset. arXiv preprint arXiv:2403.09029, 2024

    2024 arXiv

  7. [15]

    Unlocking the conversion of web screenshots into html code with the websight dataset, 2024

    Hugo Laurençon, Léo Tronchon, and Victor Sanh. Unlocking the conversion of web screenshots into html code with the websight dataset, 2024

    2024

  8. [16]

    Mmcode: Benchmarking multimodal large language models for code generation with visually rich programming problems

    Kaixin Li, Yuchen Tian, Qisheng Hu, Ziyang Luo, Zhiyong Huang, and Jing Ma. Mmcode: Benchmarking multimodal large language models for code generation with visually rich programming problems. arXiv preprint arXiv:2404.09486, 2024

    2024 arXiv

  9. [17]

    Full parameter fine-tuning for large language models with limited resources

    Kai Lv, Yuqing Yang, Tengxiao Liu, Qipeng Guo, and Xipeng Qiu. Full parameter fine-tuning for large language models with limited resources. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp.\ 8187--8198, 2024

    2024

  10. [18]

    Alibaba lingmaagent: Improving automated issue resolution via comprehensive repository exploration

    Yingwei Ma, Qingping Yang, Rongyu Cao, Binhua Li, Fei Huang, and Yongbin Li. Alibaba lingmaagent: Improving automated issue resolution via comprehensive repository exploration. In Proceedings of the 33rd ACM International Conference on the Foundations of Software Engineering, ...

    2025

  11. [19]

    Training language models to follow instructions with human feedback

    Long Ouyang, Jeffrey Wu, Xu Jiang, Diogo Almeida, Carroll Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, et al. Training language models to follow instructions with human feedback. Advances in neural information processing systems, 35: 0 2...

    2022

  12. [20]

    Refact - open sourced ai software development agent, 2025

    Refact.ai. Refact - open sourced ai software development agent, 2025. URL https://github.com/smallcloudai/refact

    2025

  13. [21]

    Automated program repair: Emerging trends pose and expose problems for benchmarks

    Joseph Renzullo, Pemma Reiter, Westley Weimer, and Stephanie Forrest. Automated program repair: Emerging trends pose and expose problems for benchmarks. ACM Computing Surveys, 57 0 (8): 0 1--18, 2025

    2025

  14. [22]

    Starvector: Generating scalable vector graphics code from images and text

    Juan A Rodriguez, Abhay Puri, Shubham Agarwal, Issam H Laradji, Pau Rodriguez, Sai Rajeswar, David Vazquez, Christopher Pal, and Marco Pedersoli. Starvector: Generating scalable vector graphics code from images and text. In Proceedings of the Computer Vision and Pattern Recogn...

    2025

  15. [23]

    Code llama: Open foundation models for code

    Baptiste Roziere, Jonas Gehring, Fabian Gloeckle, Sten Sootla, Itai Gat, Xiaoqing Ellen Tan, Yossi Adi, Jingyu Liu, Romain Sauvestre, Tal Remez, et al. Code llama: Open foundation models for code. arXiv preprint arXiv:2308.12950, 2023

    2023 arXiv

  16. [24]

    Specrover: Code intent extraction via llms

    Haifeng Ruan, Yuntong Zhang, and Abhik Roychoudhury. Specrover: Code intent extraction via llms. arXiv preprint arXiv:2408.02232, 2024

    2024 arXiv

  17. [25]

    Design2code: How far are we from automating front-end engineering?, 2024

    Chenglei Si, Yanzhe Zhang, Zhengyuan Yang, Ruibo Liu, and Diyi Yang. Design2code: How far are we from automating front-end engineering?, 2024. URL https://arxiv. org/abs/2403, 3163

    2024

  18. [26]

    Qwen3 technical report, 2025

    Qwen Team. Qwen3 technical report, 2025. URL https://arxiv.org/abs/2505.09388

    2025 arXiv

  19. [27]

    Code-vision: Evaluating multimodal llms logic understanding and code generation capabilities

    Hanbin Wang, Xiaoxuan Zhou, Zhipeng Xu, Keyuan Cheng, Yuxin Zuo, Kai Tian, Jingwei Song, Junting Lu, Wenhui Hu, and Xueyang Liu. Code-vision: Evaluating multimodal llms logic understanding and code generation capabilities. arXiv preprint arXiv:2502.11829, 2025 a

    2025 arXiv

  20. [28]

    Mathcoder-vl: Bridging vision and code for enhanced multimodal mathematical reasoning

    Ke Wang, Junting Pan, Linda Wei, Aojun Zhou, Weikang Shi, Zimu Lu, Han Xiao, Yunqiao Yang, Houxing Ren, Mingjie Zhan, et al. Mathcoder-vl: Bridging vision and code for enhanced multimodal mathematical reasoning. arXiv preprint arXiv:2505.10557, 2025 b

    2025 arXiv

  21. [29]

    Openhands: An open platform for ai software developers as generalist agents

    Xingyao Wang, Boxuan Li, Yufan Song, Frank F Xu, Xiangru Tang, Mingchen Zhuge, Jiayi Pan, Yueqi Song, Bowen Li, Jaskirat Singh, et al. Openhands: An open platform for ai software developers as generalist agents. arXiv preprint arXiv:2407.16741, 2024

    2024 arXiv

  22. [30]

    Plot2code: A comprehensive benchmark for evaluating multi-modal large language models in code generation from scientific plots

    Chengyue Wu, Zhixuan Liang, Yixiao Ge, Qiushan Guo, Zeyu Lu, Jiahao Wang, Ying Shan, and Ping Luo. Plot2code: A comprehensive benchmark for evaluating multi-modal large language models in code generation from scientific plots. In Findings of the Association for Computational L...

    2025

  23. [31]

    How effective are neural networks for fixing security vulnerabilities

    Yi Wu, Nan Jiang, Hung Viet Pham, Thibaud Lutellier, Jordan Davis, Lin Tan, Petr Babkin, and Sameena Shah. How effective are neural networks for fixing security vulnerabilities. In Proceedings of the 32nd ACM SIGSOFT International Symposium on Software Testing and Analysis, pp...

    2023

  24. [32]

    Less training, more repairing please: revisiting automated program repair via zero-shot learning

    Chunqiu Steven Xia and Lingming Zhang. Less training, more repairing please: revisiting automated program repair via zero-shot learning. In Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering, pp.\...

    2022

  25. [33]

    Automated program repair in the era of large pre-trained language models

    Chunqiu Steven Xia, Yuxiang Wei, and Lingming Zhang. Automated program repair in the era of large pre-trained language models. In 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE), pp.\ 1482--1494. IEEE, 2023

    2023

  26. [34]

    Agentless: Demystifying llm-based software engineering agents

    Chunqiu Steven Xia, Yinlin Deng, Soren Dunn, and Lingming Zhang. Agentless: Demystifying llm-based software engineering agents. arXiv preprint arXiv:2407.01489, 2024

    2024 arXiv

  27. [35]

    Demystifying llm-based software engineering agents

    Chunqiu Steven Xia, Yinlin Deng, Soren Dunn, and Lingming Zhang. Demystifying llm-based software engineering agents. Proceedings of the ACM on Software Engineering, 2 0 (FSE): 0 801--824, 2025

    2025

  28. [36]

    Swe-agent: Agent-computer interfaces enable automated software engineering

    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: 0 50528--50652, 2024

    2024

  29. [37]

    Jimenez, Alex L

    John Yang, Carlos E. Jimenez, Alex L. Zhang, Kilian Lieret, Joyce Yang, Xindi Wu, Ori Press, Niklas Muennighoff, Gabriel Synnaeve, Karthik R. Narasimhan, Diyi Yang, Sida I. Wang, and Ofir Press. SWE -bench multimodal: Do ai systems generalize to visual software domains? In The...

    2025

  30. [38]

    Omnisvg: A unified scalable vector graphics generation model

    Yiying Yang, Wei Cheng, Sijin Chen, Xianfang Zeng, Fukun Yin, Jiaxu Zhang, Liao Wang, Gang Yu, Xingjun Ma, and Yu-Gang Jiang. Omnisvg: A unified scalable vector graphics generation model. In The Thirty-ninth Annual Conference on Neural Information Processing Systems, 2025 b

    2025

  31. [39]

    Web2code: A large-scale webpage-to-code dataset and evaluation framework for multimodal llms

    Sukmin Yun, Rusiru Thushara, Mohammad Bhat, Yongxin Wang, Mingkai Deng, Jinhong Wang, Tianhua Tao, Junbo Li, Haonan Li, Preslav Nakov, et al. Web2code: A large-scale webpage-to-code dataset and evaluation framework for multimodal llms. Advances in neural information processing...

    2024

  32. [40]

    Codev: issue resolving with visual data

    Linhao Zhang, Daoguang Zan, Quanshun Yang, Zhirong Huang, Dong Chen, Bo Shen, Tianyu Liu, Yongshun Gong, Huang Pengjie, Xudong Lu, et al. Codev: issue resolving with visual data. In Findings of the Association for Computational Linguistics: ACL 2025, pp.\ 7350--7361, 2025

    2025

  33. [41]

    Autocoderover: Autonomous program improvement

    Yuntong Zhang, Haifeng Ruan, Zhiyu Fan, and Abhik Roychoudhury. Autocoderover: Autonomous program improvement. In Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis, pp.\ 1592--1604, 2024

    2024

  34. [42]

    Enhancing automated program repair with solution design

    Jiuang Zhao, Donghao Yang, Li Zhang, Xiaoli Lian, Zitian Yang, and Fang Liu. Enhancing automated program repair with solution design. In Proceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering, pp.\ 1706--1718, 2024

    2024

  35. [43]

    Chartcoder: Advancing multimodal large language model for chart-to-code generation

    Xuanle Zhao, Xianzhen Luo, Qi Shi, Chi Chen, Shuo Wang, Zhiyuan Liu, and Maosong Sun. Chartcoder: Advancing multimodal large language model for chart-to-code generation. arXiv preprint arXiv:2501.06598, 2025

    2025 arXiv

  36. [44]

    @esa (Ref

    \@ifxundefined[1] #1\@undefined \@firstoftwo \@secondoftwo \@ifnum[1] #1 \@firstoftwo \@secondoftwo \@ifx[1] #1 \@firstoftwo \@secondoftwo [2] @ #1 \@temptokena #2 #1 @ \@temptokena \@ifclassloaded agu2001 natbib The agu2001 class already includes natbib coding, so you should ...

  37. [45]

    \@lbibitem[] @bibitem@first@sw\@secondoftwo \@lbibitem[#1]#2 \@extra@b@citeb \@ifundefined br@#2\@extra@b@citeb \@namedef br@#2 \@nameuse br@#2\@extra@b@citeb \@ifundefined b@#2\@extra@b@citeb @num @parse #2 @tmp #1 NAT@b@open@#2 NAT@b@shut@#2 \@ifnum @merge>\@ne @bibitem@firs...

  38. [46]

    field and its garbling issue. Moreover, the element hierarchy relationship reveals that the field is nested within the

    @open @close @open @close and [1] URL: #1 \@ifundefined chapter * \@mkboth \@ifxundefined @sectionbib * \@mkboth * \@mkboth\@gobbletwo \@ifclassloaded amsart * \@ifclassloaded amsbook * \@ifxundefined @heading @heading NAT@ctr thebibliography [1] @ \@biblabel @NAT@ctr \@bibset...

    2022

Pith tools

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