Pith. sign in

REVIEW 5 major objections 5 minor 2 cited by

EfficientUICoder: A Bidirectional Token Compression Framework for Efficient MLLM-Based UI Code Generation

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

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

Pith's one-line read EfficientUICoder claims UI-to-code generation can drop roughly 60% of visual tokens and cut compute and latency by nearly half without hurting webpage fidelity.

desk verdict Real efficiency gains, but the 'without compromising quality' claim is not supported by the reported tables. read the letter →

arxiv 2509.12159 v2 pith:AWUNLKQK submitted 2025-09-15 cs.SE cs.AI

Jingyu Xiao , Zhongyi Zhang , Yuxuan Wan , Yintong Huo , Yang Liu , Michael R. Lyu This is my paper · ORCID
classification cs.SEcs.AI
keywords UI-to-codegenerationmultimodallargelanguagemodeltokencompressionvisualpruningrepetitionsuppressionHTML/CSSefficientinferencelayout-awareselection
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

EfficientUICoder tries to establish that the dominant cost of turning a webpage screenshot into HTML/CSS—very long image-token and code-token sequences—is largely redundant, and that this redundancy can be removed from both ends of a multimodal model. On the input side, it detects UI elements and builds a minimum-spanning-tree layout representation so only tokens that belong to meaningful elements and their spatial relations survive; on the output side, it tracks repeated HTML/CSS/text structures during decoding and applies an exponential penalty to suppress them. On two UI-to-code benchmarks with open 7B and 34B multimodal models, the reported effect is a 55–60% input-token compression, a 41% drop in generated tokens, and roughly 45–49% reductions in FLOPs, prefill time, and inference time, with rendered quality at or above the uncompressed baseline. If correct, this makes screenshot-to-code generation substantially cheaper, faster, and less prone to looping failures.

What carries the argument

The load-bearing objects are (1) a UI element tree: detected bounding boxes become graph nodes, edge weights are shortest spatial distances between boxes, and a minimum spanning tree yields the least-token representation that preserves element and layout relationships; (2) attention scores from the vision encoder's class token, used to rank token importance for refinement; (3) structure-frequency counters fed by CSS/HTML parsers that apply an exponential logit penalty to the next s tokens when repetitions are detected. The element tree performs coarse semantic selection, attention performs fine-grained pruning, and the penalty suppresses repetition loops at decode time.

What would settle it

Construct a set of UI screenshots where a small but essential element (a form field, icon, or link) is missed by element detection or receives near-zero attention. Run EfficientUICoder and the uncompressed model on them; if the compressed outputs systematically omit that element while the uncompressed outputs include it, the central quality-preservation claim fails. A second check: perturb detected bounding boxes slightly and measure block-match on the full benchmark—if quality collapses, the method's safety margin is critically thin.

Watch

Extended reading notes

Core claim

The central discovery is that UI images and MLLM-generated HTML/CSS both contain removable redundancy, attackable on opposite sides of the model. Encoding-side element detection builds a UI element graph weighted by spatial distance, then a minimum spanning tree selects tokens that cover UI elements and layout; attention scores then trim low-value tokens inside selected regions and recover high-attention background tokens. Decoding-side HTML/CSS parsers count repeated selector-property pairs, tag/content quadruples, and repeated text, and apply an exponential logit penalty. The reported effect is 55–60% input compression, roughly 41% fewer output tokens, and about 45–49% lower FLOPs, prefill

Load-bearing premise

The load-bearing premise is that the element detector's boxes and the vision encoder's attention scores jointly capture every UI detail, and that the grid-searched parameter settings transfer to the full test sets; if either fails, compressed inputs can omit critical elements and the 'without compromising quality' claim breaks.

Editorial extensions

If this is right

  • UI2Code workloads on large multimodal models could run at roughly half the compute and latency while producing webpages of comparable or better quality.
  • Suppressing repetitive HTML/CSS/text does more than save tokens: it prevents models from getting trapped in generation loops that produce invalid or oversized webpages.
  • Attention-based visual token pruning alone is insufficient for UI tasks; combining element/layout structure with attention refinement preserves critical UI elements that pure attention methods miss.
  • Input-side visual compression and output-side code suppression address independent redundancies, so combining them yields efficiency gains larger than either approach alone.

Reading between the lines

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

  • Beyond the paper's tests, the element-tree selection strategy may transfer to other structured visual generation tasks—slides, posters, or form designs from images—where layout hierarchy matters more than pixel-level detail.
  • A testable extension would apply the repetition-suppression idea to general code generation outside UI, where boilerplate inflates token budgets; the parser-based counters would need a language-specific grammar.
  • The reported gains depend on open models that expose visual-encoder and decoding hook points; closed API models may not permit the same input-token surgery, so deployment benefits in proprietary settings remain an open question.
  • One implicit consequence: on long, dense webpages the benefits may be larger than the reported averages, since both attention scatter and repetition loops worsen with sequence length.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

5 major / 5 minor

Summary. The paper proposes EfficientUICoder, a token-compression framework for MLLM-based UI-to-code generation. It combines three modules: Element and Layout-aware Token Compression (ELTC), which detects UI elements, builds a UI element graph, and applies a minimum spanning tree; Region-aware Token Refinement (RTR), which uses CLIP attention scores to refine the selected token set; and Adaptive Duplicate Token Suppression (ADTS), which tracks HTML/CSS/text repetition frequencies and applies an exponential penalty during decoding. The authors report experiments on Design2Code and WebCode2M using Llava-v1.6-7b/34b, claiming 55%–60% image-token compression, large reductions in FLOPs, prefill time, and inference time, and maintained or improved output quality. The manuscript also includes ablation, parameter, and human evaluation studies.

Significance. If the claims are substantiated, the paper addresses a real practical bottleneck in UI2Code: the high computational cost of long image-token sequences and repetitive output tokens. The direction is novel relative to prior visual-token compression methods (FastV, Pdrop, VisionZip), which ignore UI structure and do not address output redundancy. The paper is extensive: it includes two datasets, two model scales, automatic and human evaluation, an ablation study, parameter analyses, and a public code repository. The main contribution, however, rests on the assertion that large token compression can be achieved 'without compromising webpage quality'. That assertion is not consistently supported by the paper's own tables, and several key mechanism details are underspecified. The significance is therefore conditional on substantial revision.

major comments (5)
  1. [§6.1, Table 2] The central claim of 'without compromising webpage quality' is contradicted by the paper's own results. For Llava-v1.6-34b/WebCode2M, EfficientUICoder is numerically lower than Vanilla on every automatic quality metric: Block 0.4382 vs 0.4688, Text 0.7533 vs 0.8207, Position 0.5907 vs 0.6441, Color 0.5313 vs 0.5546, CLIP 0.7270 vs 0.7554, BLEU 0.2634 vs 0.2689. Additional drops appear in Block match for the other three configurations and in BLEU for Design2Code-34b. No confidence intervals, error bars, or significance tests are reported anywhere. The statement in §6.1 that human evaluation 'corroborate[s] our automatic metrics' does not resolve this discrepancy, because the human study compares methods against Vanilla and may not align with the automatic metrics for this configuration. The efficiency gains in Table 3 can still hold with a quality drop; the 'free lunch' claim, however, ca
  2. [§4.1–4.2] The mapping from the UI element tree / MST to the actual visual-token mask is never specified. Section 4.1 defines a graph and an MST over element bounding boxes, but it does not state which image patches are retained: all patches inside bounding boxes? Patches whose centers fall inside a box? How are tokens between or on the boundaries of boxes handled? How are overlapping boxes (after the merge step) reconciled with the token grid? The MST's edges are used only to define a tree, but there is no algorithmic rule connecting tree nodes/edges to token indices. Consequently, the ELTC module—the first and most novel stage—is not fully derivable or reproducible from the text. Section 4.2 describes refining the 'selected' and 'unselected' sets, but again relies on the unspecified output of ELTC. Please provide a precise, step-by-step algorithm for token selection, including any threshold or pa
  3. [§5.3.2 and §6.1] The compression-ratio definition is inconsistent with the reported numbers and with the abstract's '55%-60% compression' claim. Equation for R in §5.3.2 defines R = C_compressed / C_original. Under that definition, a value of 60.36% (Design2Code) or 55.86% (WebCode2M) means the method retains 60.36% and 55.86% of the original tokens, i.e., removes 39.64% and 44.14%, not 'compressing 55%-60% of tokens' as stated in §6.1 and the abstract. If the intended meaning is that 55%–60% of tokens are removed, then the formula and the reported percentages must be corrected. This is a headline-number inconsistency and must be fixed before the paper can be assessed fairly.
  4. [§6.4 and §5.2] The hyperparameters (s=3, λ=1/2, r=5–10%) are tuned on 100 webpages from Design2Code and 50 from WebCode2M, and the final performance tables (§6.1) report results on the full datasets. The paper does not state that the tuning samples are excluded from the final test sets, nor does it describe any held-out split or cross-validation for Design2Code/WebCode2M. Because parameter selection directly maximizes the same evaluation metrics on subsets of the same datasets, the reported numbers may be optimistically biased. Please clarify whether the tuning samples overlap with the final test sets and, if so, provide a separate held-out evaluation or internal cross-validation.
  5. [§4.3.2, Eq. (9)] The ADTS penalty procedure is underspecified. Equation (9) states that 'when duplicates occur, we will impose the following penalties on the subsequent s tokens’ logits' and writes z_i = z_i * λ^c for all i in {1,...,s}. In an autoregressive decoder, only the current step's logits can be modified; future tokens have not yet been generated. Does the method (a) at each step, penalize the logits of any token that has appeared in a tracked repeated structure, with intensity λ^c, for the next s decoding steps, or (b) re-score already generated tokens? The description in Algorithm 1 and the paragraph are too vague to reimplement. Please specify exactly which logits are modified at each decoding step, which tokens are eligible for penalty (e.g., all occurrences of the repeated string? only tokens that continue the repeated pattern?), and how c is maintained per structure.
minor comments (5)
  1. [§4.1.2] Typos: 'elememt' and 'construted' appear in the same paragraph. Please proofread.
  2. [Figures 8–10] Figure captions contain 'datatset' (Figures 8 and 9) and a mismatched caption: Figure 10 is titled 'Inference time under different λ and r' but the axes show decay factor λ and suppression step s, not r.
  3. [§7] The Threat to Validity section refers to 'human evaluation (Section 2)', but human evaluation is described in Section 6.1, not Section 2. The reference should be corrected.
  4. [§6.1, Human Evaluation] The human evaluation reports only win/tie/lose percentages. It does not report the number of comparisons per annotator, pairwise inter-annotator agreement (e.g., Fleiss' kappa), or confidence intervals. These are standard for preference studies and would strengthen the claim that human results 'corroborate' the automatic metrics.
  5. [§5.3.1] The metric group is titled 'High-level Similarity', but BLEU is a code-text n-gram overlap measure, not a visual similarity. Consider renaming the group to 'Overall Similarity' or splitting the metrics.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: EfficientUICoder's claims are empirical system results, not derived by construction from their inputs.

full rationale

The paper contains no derivation chain that reduces by construction to its own inputs. The three components are concrete mechanisms: ELTC builds a UI element tree via UIED detection and a minimum spanning tree; RTR uses CLIP CLS-token attention scores to drop/add tokens; ADTS tracks HTML/CSS/text frequencies and applies an exponential logit penalty. None of these steps defines a target metric in terms of the method's own outputs, and none fits a parameter that is then reported as a prediction. The compression ratio, token reductions, FLOPs savings, and latency numbers are measured outcomes on external benchmarks (Design2Code, WebCode2M) using external metrics (CLIP, BLEU, and the Si et al. element-matching metrics), not quantities forced by the method's construction. Hyperparameters (s=3, lambda=1/2, r=5-10%) are tuned on sampled subsets and then applied to full test sets; this is standard model selection and could be a generalization risk, but it is not circularity. Self-citations (MRWeb, Interaction2Code, DesignBench, DCGen) appear only in related work and are not load-bearing evidence for the paper's central efficiency or quality claims. No uniqueness theorem from the authors' prior work is invoked to forbid alternatives, and no external method is re-imported as an unexamined ansatz via self-citation. The apparent quality drop for Llava-v1.6-34b on WebCode2M in Table 2 is a possible empirical contradiction of the 'without compromising quality' claim, but that is a correctness or significance-testing concern, not a circular derivation. Accordingly, no circular step is identified.

Assumptions & free parameters 3 free parameters · 5 assumptions · 0 invented entities

The framework introduces no new physical or semantic entities. All free parameters are decoding/refinement hyperparameters, several tuned on the same datasets used for final evaluation. The key domain assumptions are about the reliability of UIED detection and CLIP attention as proxies for UI semantics.

free parameters (3)
  • Suppression step s = 3
    Grid-searched over {1,3,5,10} on 100 Design2Code and 50 WebCode2M samples (Section 6.4.1). Used in the final evaluation on the full datasets.
  • Decay factor lambda = 1/2
    Grid-searched over {7/8, 3/4, 1/2, 1/3} on the same samples (Section 6.4.1).
  • Refinement ratio r = 10% (Design2Code), 5% (WebCode2M)
    Tuned per dataset on a subset of the test data (Section 6.4.2). Determines how many low-attention tokens are dropped from selected regions and how many high-attention tokens are added from unselected regions.
assumptions (5)
  • domain assumption UIED element detection accurately identifies all UI element bounding boxes on arbitrary webpage screenshots.
    Invoked in Section 4.1.2; if the detector misses elements or produces inaccurate boxes, the compressed token set may omit critical UI content.
  • domain assumption CLS-token attention scores from the frozen CLIP visual encoder reliably indicate which visual tokens are semantically important for UI code generation.
    Used in Section 4.2, Eq. 6, for the RTR refinement. The paper only provides a visual motivation (Fig. 3), not a quantitative justification.
  • standard math The FLOPs formula in Eq. (1) accurately models LLM inference cost for the efficiency comparison.
    Standard approximation of transformer complexity used in Section 2.2; reasonable for comparing sequence-length reductions.
  • domain assumption Incremental parsing of generated HTML/CSS during decoding can robustly identify intended structure repetitions.
    The ADTS parsers (Algorithms 2 and 3) assume token-by-token parsing of well-formed markup; if the model generates malformed code, the tracking may behave unpredictably.
  • domain assumption CLIP score, BLEU, and the block/text/position/color element-matching metrics adequately capture 'webpage quality'.
    The authors rely on these metrics plus a small human evaluation (Section 6.1); if the metrics miss semantic errors, the quality-preservation claim is weaker.

how reviews work

0 comments
Cite this review

Pith. "Pith review of EfficientUICoder: A Bidirectional Token Compression Framework for Efficient MLLM-Based UI Code Generation." pith.science (2026). https://pith.science/paper/AWUNLKQK

@misc{pith2026250912159,
  author       = {Pith},
  title        = {Pith review of: EfficientUICoder: A Bidirectional Token Compression Framework for Efficient MLLM-Based UI Code Generation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/AWUNLKQK}},
  note         = {Machine review of arXiv:2509.12159}
}
read the original abstract

Multimodal Large Language Models have demonstrated exceptional performance in UI2Code tasks, significantly enhancing website development efficiency. However, these tasks incur substantially higher computational overhead than traditional code generation due to the large number of input image tokens and extensive output code tokens required. Our comprehensive study identifies significant redundancies in both image and code tokens that exacerbate computational complexity and hinder focus on key UI elements, resulting in excessively lengthy and often invalid HTML files. We propose EfficientUICoder, a compression framework for efficient UI code generation with three key components. First, Element and Layout-aware Token Compression preserves essential UI information by detecting element regions and constructing UI element trees. Second, Region-aware Token Refinement leverages attention scores to discard low-attention tokens from selected regions while integrating high-attention tokens from unselected regions. Third, Adaptive Duplicate Token Suppression dynamically reduces repetitive generation by tracking HTML/CSS structure frequencies and applying exponential penalties. Extensive experiments show EfficientUICoder achieves a 55%-60% compression ratio without compromising webpage quality and delivers superior efficiency improvements: reducing computational cost by 44.9%, generated tokens by 41.4%, prefill time by 46.6%, and inference time by 48.8% on 34B-level MLLMs. Code is available at https://github.com/WebPAI/EfficientUICoder.

Figures

Figures reproduced from arXiv: 2509.12159 by the authors.

Figure 1
Figure 1. The token ratios of different datasets. Compared to traditional code generation tasks [20, 24, 26, 37], UI2Code presents unique compu￾tational challenges in practice. These tasks consume substantially more tokens due to two primary factors: the extensive number of input image tokens required to represent complex visual designs, and the large volume of generated code tokens needed to describe complete webpage structu… view at source ↗
Figure 2
Figure 2. MLLM-based UI2Code task pipeline. 2.2 MLLMs Background Architecture. As illustrated in [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. Visual encoders’ attention score visualization and distribution on two webpages. [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figures from the paper (9 more)
Figure 4
Figure 4. Figure 4: Duplicate code token examples. (2) Attention distraction: excessive redundant tokens (e.g., background) scatter the model’s attention across uninformative visual regions, diminishing its capacity to focus on semantically crucial interface elements. Observation 1: Redun…
Figure 5
Figure 5. Figure 5: EfficientUICoder framework. relationship defined by the minimum distance between the boundaries of the two bounding boxes: 𝑤𝑖𝑗 = min 𝑝∈𝜕𝐵𝑖 ,𝑞∈𝜕𝐵𝑗 ∥𝑝 − 𝑞∥2, (3) where 𝜕𝐵𝑖 and 𝜕𝐵𝑗 denote the boundaries of bounding boxes 𝐵𝑖 and 𝐵𝑗 , and ∥ · ∥2 represents the Euclidean nor…
Figure 6
Figure 6. Figure 6: Human Evaluation on Design2Code. 0 20 40 60 80 100 Percentage (%) EUC Visionzip Pdrop FastV Random 48% 26% 26% 34% 28% 38% 42% 28% 30% 36% 28% 36% 32% 30% 38% Win Tie Lose (a) Llava-v1.6-7b. 0 20 40 60 80 100 Percentage (%) EUC Visionzip Pdrop FastV Random 50% 36% 14% …
Figure 8
Figure 8. Figure 8: Suppression step 𝑠 and decay factor 𝜆 analysis on Design2Code datatset. 7 8 3 4 1 2 1 3 Decay Factor (λ) 1 3 5 10 Suppression Steps (s) 0.2468 0.2314 0.2304 0.2304 0.2412 0.2390 0.2656 0.2656 0.2463 0.2463 0.2504 0.2504 0.2465 0.2314 0.2435 0.2435 (a) Block Match. 7 8 …
Figure 9
Figure 9. Figure 9: Suppression step 𝑠 and decay factor 𝜆 analysis on WebCode2M datatset. Answer to RQ3: Each component of EfficientUICoder has a positive impact on results. The combination of all components brings the best results, which is much better than using any subset of the three …
Figure 11
Figure 11. Figure 11: Refinement ratio 𝑟 analysis. 0 20 40 60 80 100 Ratio (%) 0.2 0.3 0.4 0.5 0.6 0.7 0.8 Block Text Position Color CLIP Bleu (a) Performance on D2C. 0 20 40 60 80 100 Ratio (%) 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 Block Text Position Color CLIP Bleu (b) Performance on WC2M. 0 …
Figure 12
Figure 12. Figure 12: The performance and efficiency on two datasets when adding unselected token. D2C denotes [PITH_FULL_IMAGE:figures/full_fig_p016_12.png]
Figure 13
Figure 13. Figure 13: Case study of webpages generated by Vanilla, EfficientUICoder and VisionZip. ) UI I (b) ill () ffiiCd [PITH_FULL_IMAGE:figures/full_fig_p017_13.png]
Figure 15
Figure 15. Figure 15: Output redundancy case study. comparable to the Vanilla approach while significantly outperforming VisionZip. Detailed analysis reveals that VisionZip fails to generate essential elements including contact information (name, phone number, email), interactive component…

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 2 Pith papers

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

  1. UI2App: Benchmarking Visual Interaction Inference in Executable Web Application Generation

    cs.SE 2026-07 accept novelty 7.0 of 10

    UI2App introduces a benchmark showing that vision-language models can reconstruct web page visuals but largely fail to infer the underlying interaction logic from screenshots alone.

  2. Does It Render Everywhere? A Study of Cross-Environment Compatibility in MLLM-Generated Webpages

    cs.SE 2026-08 conditional novelty 6.0 of 10

    Sixty-eight percent of AI-generated webpages fail to render correctly in at least one of nine tested browser or device environments, and a new DOM-plus-screenshot detector catches 91% of these failures.

Reference graph

Works this paper leans on

43 extracted references · 6 linked inside Pith · cited by 2 Pith papers

  1. [1]

    How Many Websites Are There in 2025? (13 Latest Statistics).Anthony Cardillo(2025)

    2025. How Many Websites Are There in 2025? (13 Latest Statistics).Anthony Cardillo(2025). https://explodingtopics. com/blog/how-many-websites-on-the-internet Accessed: 2025-07-05

    2025

  2. [2]

    Batuhan Aşıroğlu, Büşta Rümeysa Mete, Eyyüp Yıldız, Yağız Nalçakan, Alper Sezen, Mustafa Dağtekin, and Tolga Ensari. 2019. Automatic HTML code generation from mock-up images using machine learning techniques. In2019 Scientific Meeting on Electrical-Electronics & Biomedical Engineering and Computer Science (EBBT). Ieee, 1–4

    2019

  3. [3]

    Tony Beltramelli. 2018. pix2code: Generating code from a graphical user interface screenshot. InProceedings of the ACM SIGCHI symposium on engineering interactive computing systems. 1–6

    2018

  4. [4]

    C. Chen, T. Su, G. Meng, Z. Xing, and Y. Liu. 2018. From UI design image to GUI skeleton: a neural machine translator to bootstrap mobile GUI implementation. InProceedings of the 40th International Conference on Software Engineering (ICSE). 665–676

    2018

  5. [5]

    Liang Chen, Haozhe Zhao, Tianyu Liu, Shuai Bai, Junyang Lin, Chang Zhou, and Baobao Chang. 2024. An image is worth 1/2 tokens after layer 2: Plug-and-play inference acceleration for large vision-language models. InEuropean Conference on Computer Vision (ECCV). Springer, 19–35

    2024

  6. [6]

    Wen-Yin Chen, Pavol Podstreleny, Wen-Huang Cheng, Yung-Yao Chen, and Kai-Lung Hua. 2022. Code generation from a graphical user interface via attention-based encoder–decoder model.Multimedia Systems28, 1 (2022), 121–130

    2022

  7. [7]

    André Armstrong Janino Cizotto, Rodrigo Clemente Thom de Souza, Viviana Cocco Mariani, and Leandro dos Santos Coelho. 2023. Web pages from mockup design based on convolutional neural network and class activation mapping.Multimedia Tools and Applications82, 25 (2023), 38771–38797

    2023

  8. [8]

    Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. 2020. An image is worth 16x16 words: Transformers for image recognition at scale.arXiv preprint arXiv:2010.11929(2020)

    arXiv 2020

Show all 43 references
  1. [9]

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

    2025

  2. [10]

    Yi Gui, Zhen Li, Zhongyi Zhang, Guohao Wang, Tianpeng Lv, Gaoyang Jiang, Yi Liu, Dongping Chen, Yao Wan, Hongyu Zhang, et al. 2025. LaTCoder: Converting Webpage Design to Code with Layout-as-Thought. InProceedings of the 31st ACM SIGKDD Conference on Knowledge Discovery and Da...

    2025

  3. [11]

    Yi Gui, Yao Wan, Zhen Li, Zhongyi Zhang, Dongping Chen, Hongyu Zhang, Yi Su, Bohua Chen, Xing Zhou, Wenbin Jiang, and Xiangliang Zhang. 2025. UICopilot: Automating UI Synthesis via Hierarchical Code Generation from Webpage Designs. InProceedings of the ACM on Web Conference (W...

    2025

  4. [12]

    Lianghong Guo, Yanlin Wang, Ensheng Shi, Wanjun Zhong, Hongyu Zhang, Jiachi Chen, Ruikai Zhang, Yuchi Ma, and Zibin Zheng. 2024. When to stop? towards efficient code generation in llms with excess token prevention. In Proceedings of the 33rd ACM SIGSOFT International Symposium...

    2024

  5. [13]

    Vanita Jain, Piyush Agrawal, Subham Banga, Rishabh Kapoor, and Shashwat Gulyani. 2019. Sketch2Code: transforma- tion of sketches to UI in real-time using deep neural network.arXiv preprint arXiv:1910.08930(2019)

    2019 arXiv

  6. [14]

    Hugo Laurençon, Léo Tronchon, and Victor Sanh. 2024. Unlocking the conversion of Web Screenshots into HTML Code with the WebSight Dataset. arXiv:2403.09029 [cs.HC]

    2024 arXiv

  7. [15]

    Haiming Li, Qiyang Xia, Yong Wang, et al. 2017. Research and improvement of kruskal algorithm.Journal of Computer and Communications5, 12 (2017), 63

    2017

  8. [16]

    Haotian Liu, Chunyuan Li, Yuheng Li, Bo Li, Yuanhan Zhang, Sheng Shen, and Yong Jae Lee. 2024. LLaVA-NeXT: Improved reasoning, OCR, and world knowledge. https://llava-vl.github.io/blog/2024-01-30-llava-next/

    2024

  9. [17]

    Yuwen Lu, Alan Leung, Amanda Swearngin, Jeffrey Nichols, and Titus Barik. 2025. Misty: Ui prototyping through interactive conceptual blending. InProceedings of the 2025 CHI Conference on Human Factors in Computing Systems (CHI). 1–17

    2025

  10. [18]

    Kevin Moran, Carlos Bernal-Cárdenas, Michael Curcio, Richard Bonett, and Denys Poshyvanyk. 2018. Machine learning-based prototyping of graphical user interfaces for mobile apps.IEEE Transactions on Software Engineering (TSE)46, 2 (2018), 196–221

    2018

  11. [19]

    Tuan Anh Nguyen and Christoph Csallner. 2015. Reverse engineering mobile application user interfaces with remaui (t). In2015 30th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE, 248–259

    2015

  12. [20]

    Dangfeng Pan, Zhensu Sun, Cenyuan Zhang, David Lo, and Xiaoning Du. 2025. The Hidden Cost of Readability: How Code Formatting Silently Consumes Your LLM Budget.2026 IEEE/ACM 44th International Conference on Software , Vol. 1, No. 1, Article . Publication date: September 2026. ...

    2025

  13. [21]

    Wei Pang, Kevin Qinghong Lin, Xiangru Jian, Xi He, and Philip Torr. 2025. Paper2Poster: Towards Multimodal Poster Automation from Scientific Papers.arXiv preprint arXiv:2505.21497(2025)

    2025

  14. [22]

    Kishore Papineni, Salim Roukos, Todd Ward, and Wei-Jing Zhu. 2002. Bleu: a method for automatic evaluation of machine translation. InProceedings of the 40th annual meeting of the Association for Computational Linguistics. 311–318

    2002

  15. [23]

    Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, et al. 2021. Learning transferable visual models from natural language supervision. InInternational conference on machine learnin...

    2021

  16. [24]

    Jieke Shi, Zhou Yang, and David Lo. 2025. Efficient and Green Large Language Models for Software Engineering: Literature Review, Vision, and the Road Ahead.ACM Transactions on Software Engineering and Methodology (TOSEM) 34, 5 (2025), 1–22

    2025

  17. [25]

    Chenglei Si, Yanzhe Zhang, Ryan Li, Zhengyuan Yang, Ruibo Liu, and Diyi Yang. 2025. Design2Code: Benchmarking Multimodal Code Generation for Automated Front-End Engineering. InProceedings of the 2025 Conference of the Nations of the Americas Chapter of the Association for Comp...

    2025

  18. [26]

    Zhensu Sun, Chengran Yang, Xiaoning Du, Zhou Yang, Li Li, and David. Lo. 2025. Token Sugar: Making Source Code Sweeter for LLMs through Token-Efficient Shorthand.2025 40th IEEE/ACM International Conference on Automated Software Engineering (ASE)(2025)

    2025

  19. [27]

    Wenxin Tang, Jingyu Xiao, Wenxuan Jiang, Xi Xiao, Yuhang Wang, Xuxin Tang, Qing Li, Yuehe Ma, Junliang Liu, Shisong Tang, et al. 2025. SlideCoder: Layout-aware RAG-enhanced Hierarchical Slide Generation from Design.arXiv preprint arXiv:2506.07964(2025)

    2025 arXiv

  20. [28]

    Yuxuan Wan, Yi Dong, Jingyu Xiao, Yintong Huo, Wenxuan Wang, and Michael R Lyu. 2024. MRWeb: An Exploration of Generating Multi-Page Resource-Aware Web Code from UI Designs.arXiv preprint arXiv:2412.15310(2024)

    2024 arXiv

  21. [29]

    Yuxuan Wan, Chaozheng Wang, Yi Dong, Wenxuan Wang, Shuqing Li, Yintong Huo, and Michael R Lyu. 2025. Divide- and-Conquer: Generating UI Code from Screenshots.Proceedings of the ACM on Software Engineering (FSE)1, FSE, 1–24

    2025

  22. [30]

    Fan Wu, Cuiyun Gao, Shuqing Li, Xin-Cheng Wen, and Qing Liao. 2025. MLLM-Based UI2Code Automation Guided by UI Layout Information. In2025 International Symposium on Software Testing and Analysis (ISSTA). ACM New York, Trondheim, Norway, 1–23

    2025

  23. [31]

    Jingyu Xiao, Yuxuan Wan, Yintong Huo, Zixin Wang, Xinyi Xu, Wenxuan Wang, Zhiyao Xu, Yuhang Wang, and Michael R Lyu. 2024. Interaction2Code: Benchmarking MLLM-based Interactive Webpage Code Generation from Interactive Prototyping.arXiv preprint arXiv:2411.03292(2024)

    2024

  24. [32]

    Jingyu Xiao, Ming Wang, Man Ho Lam, Yuxuan Wan, Junliang Liu, Yintong Huo, and Michael R Lyu. 2025. Designbench: A comprehensive benchmark for mllm-based front-end code generation.arXiv preprint arXiv:2506.06251(2025)

    2025

  25. [33]

    Mulong Xie, Sidong Feng, Zhenchang Xing, Jieshan Chen, and Chunyang Chen. 2020. UIED: a hybrid tool for GUI element detection. InProceedings of the 28th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering (FSE)...

    2020

  26. [34]

    Long Xing, Qidong Huang, Xiaoyi Dong, Jiajie Lu, Pan Zhang, Yuhang Zang, Yuhang Cao, Conghui He, Jiaqi Wang, Feng Wu, et al. 2024. Pyramiddrop: Accelerating your large vision-language models via pyramid visual redundancy reduction.arXiv preprint arXiv:2410.17247(2024)

    2024 arXiv

  27. [35]

    Y. Xu, L. Bo, X. Sun, B. Li, J. Jiang, and W. Zhou. 2021. image2emmet: Automatic code generation from web user interface image.Journal of Software: Evolution and Process33, 8 (2021), e2369

    2021

  28. [36]

    Mikio Yamamoto and Kenneth W Church. 2001. Using suffix arrays to compute term frequency and document frequency for all substrings in a corpus.Computational Linguistics27, 1 (2001), 1–30

    2001

  29. [37]

    Guang Yang, Yu Zhou, Wei Cheng, Xiangyu Zhang, Xiang Chen, Terry Yue Zhuo, Ke Liu, Xin Zhou, David Lo, and Taolue Chen. 2025. Less is More: DocString Compression in Code Generation.ACM Transactions on Software Engineering and Methodology (TOSEM)(2025)

    2025

  30. [38]

    Senqiao Yang, Yukang Chen, Zhuotao Tian, Chengyao Wang, Jingyao Li, Bei Yu, and Jiaya Jia. 2025. Visionzip: Longer is better but not necessary in vision language models. InProceedings of the Computer Vision and Pattern Recognition Conference (CVPR). 19792–19802

    2025

  31. [39]

    Mingyue Yuan, Jieshan Chen, Zhenchang Xing, Aaron Quigley, Yuyu Luo, Tianqi Luo, Gelareh Mohammadi, Qinghua Lu, and Liming Zhu. 2025. DesignRepair: Dual-Stream Design Guideline-Aware Frontend Repair with Large Language Models . InIEEE/ACM 47th International Conference on Softw...

    2025

  32. [40]

    Xing, Xiaodan Liang, and Zhiqiang Shen

    Sukmin Yun, Haokun Lin, Rusiru Thushara, Mohammad Qazim Bhat, Yongxin Wang, Zutao Jiang, Mingkai Deng, Jinhong Wang, Tianhua Tao, Junbo Li, Haonan Li, Preslav Nakov, Timothy Baldwin, Zhengzhong Liu, Eric P. Xing, Xiaodan Liang, and Zhiqiang Shen. 2024. Web2Code: A Large-scale ...

    2024

  33. [41]

    Sai Zhang, Zhenchang Xing, Ronghui Guo, Fangzhou Xu, Lei Chen, Zhaoyuan Zhang, Xiaowang Zhang, Zhiyong Feng, and Zhiqiang Zhuang. 2025. Empowering agile-based generative software development through human-ai teamwork. ACM Transactions on Software Engineering and Methodology (T...

    2025

  34. [42]

    Yuan Zhang, Chun-Kai Fan, Junpeng Ma, Wenzhao Zheng, Tao Huang, Kuan Cheng, Denis Gudovskiy, Tomoyuki Okuno, Yohei Nakata, Kurt Keutzer, et al. 2025. SparseVLM: Visual Token Sparsification for Efficient Vision-Language Model Inference. InInternational Conference on Machine Lea...

    2025

  35. [43]

    Ting Zhou, Yanjie Zhao, Xinyi Hou, Xiaoyu Sun, Kai Chen, and Haoyu Wang. 2025. Bridging Design and Development with Automated Declarative UI Code Generation.Proceedings of the ACM on Software Engineering (FSE)1, FSE, 1–24. , Vol. 1, No. 1, Article . Publication date: September 2026

    2025

Pith tools

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