Pith. sign in

REVIEW 3 major objections 7 minor 9 cited by

MRWeb: An Exploration of Generating Multi-Page Resource-Aware Web Code from UI Designs

T0 review · 3 major / 7 minor · reviewed 2026-08-11 · deepseek-v4-flash

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

Pith's one-line read This paper argues that a machine-readable resource list is what lets multimodal models turn UI screenshots into multi-page, navigable websites—raising functional resource matching from near zero to 66–80%.

desk verdict Useful benchmark and IQA data, but the headline RER boost is an artifact of giving the model the answer; the navigation claim is not supported by the metric. read the letter →

arxiv 2412.15310 v1 pith:35RL3BUW submitted 2024-12-19 cs.SE cs.AIcs.IR

Yuxuan Wan , Yi Dong , Jingyu Xiao , Yintong Huo , Wenxuan Wang , Michael R. Lyu This is my paper · ORCID
classification cs.SEcs.AIcs.IR
keywords multi-pagewebsitegenerationUIdesigntocoderesourcelistmultimodallargelanguagemodelswebsimilaritymetricsdesign-to-codebenchmarknavigationfunctionalityimagequalityassessment
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

Existing design-to-code tools assume a webpage is a single, self-contained file: they generate static replicas with placeholder images and empty links. This paper introduces a harder task, MRWeb, in which a model must turn a UI screenshot into multi-page code with internal and external navigation, real images, and backend routing. The central proposal is a "resource list"—a structured dictionary of each page's links, images, and routes with their bounding boxes—fed to the model alongside the screenshot. The paper reports that with this list, the fraction of resources correctly reproduced jumps from near zero under self-contained prompting to 66–80% across three leading multimodal models, while visual similarity also improves. It also reports a human study showing that among six image-similarity metrics, the pixel-level MAE and NEMD track human judgment best (SROCC 0.542 and 0.508), suggesting that simple pixel comparisons are the right evaluation for web UI code.

What carries the argument

The load-bearing mechanism is the resource list: a dictionary-like data structure in which each actionable element of a webpage is recorded with its position (bounding box), its type (link, image, or backend route), and its target URL or source. It is the input channel through which the model learns the exact URLs it must emit, which is why the self-contained baseline—which receives only a screenshot—has no way to reproduce any real resource. The paper's MRWeb dataset of 300 synthetic and 200 real-world websites, and its human-rated set of 600 UI-similarity pairs, are the supporting instruments that give the resource-list mechanism empirical force.

What would settle it

Take a model that scores 66–80% RER, then click through every internal link in its generated multi-page site. If the proportion of links that lead to a real, rendered page with the expected content is far below 66–80%—or near zero—the paper's claim that resource lists "boost navigation functionality" would be falsified.

Watch

Extended reading notes

Core claim

On its own terms, the paper's central claim is that the missing ingredient in design-to-code is a machine-readable map of the page's resources. Providing the model with a resource list—entries of the form {position: bounding box, type: image/link, url}—makes it possible to reproduce the exact image sources and link targets that make a site functional. Empirically, this lifts the Resource Existence Ratio from 0.006–0.008 under self-contained prompting to 0.640–0.832 depending on model and prompting strategy, and improves MAE, NEMD, and CLIP visual scores across all three tested models. The paper further discovers that when choosing an automated similarity metric for web UIs, pixel-level MAE and NEMD correlate most strongly with human similarity ratings, and that semantic and structural metrics such as SSIM, CLIP, and LPIPS only align with humans in highly similar pairs. The authors treat these results as evidence that resource-aware prompting, not just larger models, is the lever that unlocks functional multi-page generation.

Load-bearing premise

The claim rests on defining a resource as "matched" when the generated element points to the same URL or image source as the reference, regardless of whether the link resolves or the target page exists; under that definition the near-zero baseline is almost forced, because the self-contained model is never told the ground-truth URLs.

Editorial extensions

If this is right

  • Design-to-code systems that adopt a resource list can generate pages with genuine image sources and link targets instead of placeholders, which is the difference between a static mockup and a usable site.
  • For evaluating generated web UIs, the paper's human study makes a case for using pixel-level MAE and NEMD as primary metrics, rather than the semantic or structural scores that prior work favored.
  • The reported degradation with input image size and resource-list length implies a concrete scaling target: models and prompts must handle large, dense pages before MRWeb generation works on complex real-world websites.
  • Self-refine prompting consistently outperformed direct and chain-of-thought prompting, while CoT actually hurt performance, giving a practical prompt-design rule for this task.
  • If reproduced, the 66–80% RER numbers suggest that resource lists are a cheap, data-free way to make multimodal models produce navigable multi-page code from UI designs.

Reading between the lines

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

  • Beyond the paper: the RER metric defines "exists" as pointing to the same URL/source, so the 66–80% numbers mostly measure whether the model transcribes the supplied list into code; whether the resulting multi-page site actually navigates end-to-end is a separate question the paper does not test.
  • Beyond the paper: because MAE and NEMD excel in low-to-medium similarity while semantic metrics excel in high similarity, a hybrid metric—pixel error plus a learned semantic score—could match human judgment more uniformly than any single metric in the study.
  • Beyond the paper: the resource-list trick likely generalizes beyond HTML, e.g., to mobile UI code generation or accessible document generation, wherever the failure mode is that models invent rather than reproduce resource references.
  • Beyond the paper: a testable extension would be an end-to-end crawl of generated sites, counting what fraction of internal links lead to real rendered pages; the paper's tool case study suggests this could be high on simple sites, but the benchmark's 66–80% figure does not by itself establish it.
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

3 major / 7 minor

Summary. The paper introduces MRWeb, a task and benchmark for generating multi-page, resource-aware web code from UI screenshots and an accompanying 'resource list' that specifies the positions, types, and URLs of links and images. The authors collect 300 synthetic and 200 real-world websites, propose a suite of visual and functional metrics, and evaluate Gemini, GPT-4o, and Claude-3.5 under self-contained, zero-shot, CoT, and self-refine prompting. They also run a human study to identify which image-similarity metric best matches human judgments, concluding that MAE and NEMD correlate best (SROCC 0.542 and 0.508). The headline finding is that providing the resource list raises the Resource Existence Ratio from near zero to 66-80%, interpreted as a boost in navigation functionality.

Significance. If the headline claim were rigorously supported, the work would be a meaningful step beyond single-page design-to-code. The dataset, the resource-list formalism, and the IQA comparison are concrete contributions, and the release of the tool, dataset, and evaluation framework supports reproducibility. The experimental setup is transparent, with temperature 0 and seed 42 and exact prompts in the appendix. However, the functional metric and the task setup undermine the central navigation claim, so the significance currently rests on the benchmarking and IQA contributions rather than on the claimed functional advance.

major comments (3)
  1. [Section 5.3.1 and Table 4] The Resource Existence Ratio (RER) is defined as the proportion of reference resources matched to generated resources by exact URL/source equality. Because the self-contained (SC) baseline is given no resource list, it cannot know ground-truth URLs, so its near-zero RER is forced by the input design. The 66-80% scores under zero-shot, CoT, and self-refine largely measure whether the model copies the provided URLs from the resource list into the generated code, which is a transcription check rather than a navigation check. Moreover, RER does not verify that a matched link resolves, that an internal link leads to a generated page with the expected content, or that backend routing works. The abstract and Section 6.2 claim that resource lists 'boost navigation functionality from 0% to 66%-80%', but the reported numbers do not establish end-to-end navigability.
  2. [Section 3 and Section 5.2] The task formulation Cg = M(I0, R0) and the prompt designs in Appendix C change two variables at once when comparing SC (no resource list) with ZS/CoT/SR (resource list provided): the presence of R0 and the prompt content. The reported improvements in RER and visual metrics cannot be attributed solely to the resource list because the prompting strategies also differ in instruction and supplementary text. A controlled comparison, for example providing a resource list with incorrect or scrambled URLs, or placing the same URL information in a non-structured textual format, is needed to isolate the effect of the resource list itself.
  3. [Section 6.4 and Table 6] The case study reports a 100% success rate for the MRWeb tool on a three-page personal website, but the criteria for success are not defined. It is unclear whether 'success' means that the generated code contains the correct URL strings, that the links are actually clickable and resolve, that the internal pages are generated and consistent, or that the backend route was tested with an actual request. Without an explicit evaluation protocol, this anecdote does not substantiate end-to-end navigation functionality.
minor comments (7)
  1. [Section 3, Appendix C, Appendix I] The terms 'resource list' and 'action list' are used interchangeably; unify the terminology throughout the paper.
  2. [Section 3] The string 'bonding_box' in the resource list example is a typo for 'bounding_box'.
  3. [Section 6.2] The model name 'Genimi-Pro' is a typo; it should be 'Gemini-Pro'.
  4. [Appendix E] The sentence 'SROCC ... where a indicates perfect positive or negative correlation' is missing the value '1' after 'a'; it should read 'where a value of 1 indicates'.
  5. [Tables 3 and 4] The visual and functional metric tables report point estimates with no error bars or significance tests; given the small gaps between some models and methods, the reader cannot assess whether the differences are meaningful.
  6. [Figure 3 and Appendix H] The binning of image sizes and action-list lengths into five bins is not described, including the number of samples per bin, which makes the complexity-trend analysis difficult to interpret.
  7. [Introduction and References] The citation key '(web, 2024)' in the Introduction does not match any reference entry; the corresponding TechJury entry should be cited with an author or consistent key.

Circularity Check

1 steps flagged · score 6.0 of 10

The headline RER boost reduces to transcription of the provided resource list: the metric matches generated elements to the exact URLs that were supplied as input, and the self-contained baseline is forced to near zero because those URLs are withheld.

  1. self definitional [Sec. 3 (Task Definition), Sec. 5.3.1 (Resource Existence Ratio), Sec. 6.2 (Effectiveness of the Resource List)]
    "Task Definition Let the ground-truth webpage’s HTML+CSS code be C0, screenshot be I0, and resource list be R0, the MRWeb generation task uses an MLLM M to produce HTML+CSS code Cg = M (I0, R0). ... RER = # Matched Resources in G / # Total Resources in R. Matching is determined based on relevant attributes of resources, such as whether navigational elements direct to the same link or whether images share the same source. Resource lists enable MLLMs to generate webpages with valid resources, significantly boosting RER from 0% to 66%-80%."

    R0 is an input to generation (Cg = M (I0, R0)), and RER is defined by matching the generated resources to R0's exact links and image sources. The self-contained baseline is run without R0, so it cannot know the ground-truth URLs; a near-zero RER is forced by the experimental design, not by a failure of navigation. The 66-80% scores under ZS/CoT/SR therefore measure whether the model copied the supplied URLs into the generated code, i.e., transcription of the input list. RER never checks whether a link resolves, leads to a generated page, or triggers backend routing, so the claim that resource lists 'boost navigation functionality from 0% to 66%-80%' reduces by construction to providing the answer and then scoring a metric defined over that answer.

full rationale

The central functional claim in the abstract and Sec. 6.2 is not self-contained: RER is computed against the same resource list R0 that is fed to the model in the zero-shot, chain-of-thought, and self-refine settings, while the self-contained baseline does not receive R0 at all. This makes the 0-to-66-80% jump a measure of list-to-code transcription rather than of navigability. The paper does not check whether matched links resolve, whether internal links lead to generated pages, or whether backend routing works, so the word 'navigation functionality' overstates what RER establishes. This is a partial circularity: the visual-similarity comparisons in Sec. 6.1, including the human IQA study and the ranking of MAE/NEMD against human judgments, are independent and self-contained, and the fine-grained layout metrics are computed against rendered screenshots and human-labeled properties. There is no load-bearing self-citation or imported uniqueness theorem; the IQA study is an external human-evaluation benchmark. The score is 6 because the headline functional claim reduces by construction, while the remaining contributions retain independent content.

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

The central empirical claims rest on two main assumptions: that Selenium-extracted resource lists are complete ground truth for page functionality, and that exact URL matching is a valid functional-similarity measure. The latter assumption is introduced ad hoc to the paper and inflates the functional-gain claim. The motivating study (top-300 Tranco) is a domain assumption about real-world needs. No free parameters are fitted; the resource-matching rule is a hand-chosen definition rather than a number fitted to data.

assumptions (5)
  • domain assumption The three assumptions about real websites (multi-page, with external links and real images) are over-simplified in prior work; the motivating Tranco study (top 300 sites) is representative of real-world web development needs.
    Section 1 and Appendix A: 90.3% multi-page result motivates the task definition.
  • domain assumption Resource lists extracted via Selenium (positions, types, URLs) constitute ground truth for the resources a webpage needs, including visibility and functionality filtering.
    Section 4.3: automatic extraction assumes the list is complete and correct; the generated code's RER is judged against it.
  • ad hoc to paper Exact URL/source matching between reference and generated resource lists is a valid measure of functional similarity (RER).
    Section 5.3.1: RER definition. This assumption makes the no-resource-list baseline near zero by construction.
  • domain assumption Randomly assigned C4 links in synthetic data are treated as valid external links, even though they are not semantically related to page content.
    Section 4.1 link insertion: external links are chosen randomly, so generated sites are not realistic navigation graphs.
  • domain assumption Human ratings from 14 college students over 600 pairs provide a reliable gold standard for image-similarity metric evaluation.
    Section 6.1: IQA with 14 annotators; inter-rater SROCC 0.640 is moderate, and the conclusion about best metric is drawn from this sample.
invented entities (1)
  • Resource list (action list) independent evidence
    purpose: A structured representation (dictionary-like) storing positions, types, and URLs of links, images, and backend routes, provided to the MLLM alongside the screenshot to enable functional code generation.
    The paper releases the dataset and code implementing the resource list (GitHub), providing an external artifact. It is a representation, not a physical entity, with no independent falsifiable prediction beyond the benchmark.

how reviews work

0 comments
Cite this review

Pith. "Pith review of MRWeb: An Exploration of Generating Multi-Page Resource-Aware Web Code from UI Designs." pith.science (2026). https://pith.science/paper/35RL3BUW

@misc{pith2026241215310,
  author       = {Pith},
  title        = {Pith review of: MRWeb: An Exploration of Generating Multi-Page Resource-Aware Web Code from UI Designs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/35RL3BUW}},
  note         = {Machine review of arXiv:2412.15310}
}
read the original abstract

Multi-page websites dominate modern web development. However, existing design-to-code methods rely on simplified assumptions, limiting to single-page, self-contained webpages without external resource connection. To address this gap, we introduce the Multi-Page Resource-Aware Webpage (MRWeb) generation task, which transforms UI designs into multi-page, functional web UIs with internal/external navigation, image loading, and backend routing. We propose a novel resource list data structure to track resources, links, and design components. Our study applies existing methods to the MRWeb problem using a newly curated dataset of 500 websites (300 synthetic, 200 real-world). Specifically, we identify the best metric to evaluate the similarity of the web UI, assess the impact of the resource list on MRWeb generation, analyze MLLM limitations, and evaluate the effectiveness of the MRWeb tool in real-world workflows. The results show that resource lists boost navigation functionality from 0% to 66%-80% while facilitating visual similarity. Our proposed metrics and evaluation framework provide new insights into MLLM performance on MRWeb tasks. We release the MRWeb tool, dataset, and evaluation framework to promote further research.

Figures

Figures reproduced from arXiv: 2412.15310 by the authors.

Figure 1
Figure 1. Comparison between self-contained web￾page and multi-page resource-aware webpage (MR￾Web). MRWeb supports multi-page navigation, real￾image loading and backend routing. to Grow Editorial Team, 2024; Web.com Editorial Team, 2024). To examine this, we conducted a pre￾liminary study by sampling the top 300 most vis￾ited websites ranked by the Tranco list 2 . For each website, we analyzed its structure by recursively vi… view at source ↗
Figure 2
Figure 2. Topic distribution of real-world web data in [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. GPT-4o performance decreases with input image size (million pixels) and resource list length. The performance of MLLMs degrades with increasing input complexity, suggesting further optimization in handling large-scale and com￾plex inputs. To evaluate the robustness of MLLMs in the MRWeb task, we analyzed their visual (MAE) and functional (RER) performances across varying image sizes and resource list lengths. As sho… view at source ↗
Figures from the paper (6 more)
Figure 4
Figure 4. Figure 4: Summary statistics for external/backend links, internal links, and images count. 90.3% 9.7% Page Type Multipage Single Page (a) Proportion of multi-page vs single-page websites. 45.0% 18.9% 36.0% Internal Page count [1, 9] [10, 99] [100, 100+] (b) Number of internal pa…
Figure 8
Figure 8. Figure 8: User interface of the MRWeb tool [PITH_FULL_IMAGE:figures/full_fig_p015_8.png]
Figure 9
Figure 9. Figure 9: Design images of the personal website in [PITH_FULL_IMAGE:figures/full_fig_p015_9.png]
Figure 6
Figure 6. Figure 6: MAE↓ vs. input image size (million pixels). 35 103 172 241 309 Action List Length 0.0 0.2 0.4 0.6 0.8 SC ZS CoT SR (a) Gemini-Pro-1.5. 35 103 172 241 309 Action List Length 0.0 0.2 0.4 0.6 0.8 SC ZS CoT SR (b) GPT-4o. 35 103 172 241 309 Action List Length 0.0 0.2 0.4 0…
Figure 7
Figure 7. Figure 7: Action existence ratio↑ vs. action list length. Self-Contained Websites MRWeb (Ours) [PITH_FULL_IMAGE:figures/full_fig_p016_7.png]
Figure 10
Figure 10. Figure 10: Comparison between self-contained webpages and our multipages resource-aware webpages (MRWebs). [PITH_FULL_IMAGE:figures/full_fig_p016_10.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 9 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. CodeShrink: Adaptive Visual Compression for Efficient Multimodal Code Understanding

    cs.CV 2026-07 conditional novelty 6.0 of 10

    A three-part pipeline (blank-free rendering, instruction-aware visual-token pruning, and per-input compression settings) cuts visual tokens for code-image MLLM inputs by up to 71% without losing accuracy.

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

    cs.SE 2025-09 conditional novelty 6.0 of 10

    EfficientUICoder compresses UI image tokens by 55-60% and suppresses duplicate HTML/CSS/text output, cutting LLM FLOPs by ~45% and inference time by ~49% on Llava-1.6-34b without quality loss on two benchmarks.

  4. When Cars Have Stereotypes: Auditing Demographic Bias in Objects from Text-to-Image Models

    cs.CV 2025-08 unverdicted novelty 6.0 of 10

    A new audit framework, SODA, measures demographic bias in objects generated by text-to-image models and finds strong default-to-majority and stereotype-collapse patterns across five models.

  5. FullFront: Benchmarking MLLMs Across the Full Front-End Engineering Workflow

    cs.CL 2025-05 conditional novelty 6.0 of 10

    FullFront adds a three-task benchmark for webpage design, perception, and code generation, and finds top MLLMs still fail at fine-grained layout and interaction implementation.

  6. P2P: Automated Paper-to-Poster Generation and Fine-Grained Benchmark

    cs.CL 2025-05 conditional novelty 6.0 of 10

    P2P is a multi-agent framework that automatically generates HTML-rendered academic posters from papers, backed by a 30k instruction dataset and a 121-pair evaluation benchmark.

  7. SAM2-UNeXT: An Improved High-Resolution Baseline for Adapting Foundation Models to Downstream Segmentation Tasks

    cs.CV 2025-08 unverdicted novelty 5.0 of 10

    The full text describes LaTCoder, a block-wise chain-of-thought method for webpage design-to-code, reporting improved layout preservation on two benchmarks, while the title and abstract are for a different paper.

  8. LaTCoder: Converting Webpage Design to Code with Layout-as-Thought

    cs.SE 2025-08 conditional novelty 5.0 of 10

    LaTCoder cuts a webpage screenshot into blocks, generates code for each block with chain-of-thought prompting, and assembles the blocks, improving layout fidelity over direct whole-page generation.

  9. SlideCoder: Layout-aware RAG-enhanced Hierarchical Slide Generation from Design

    cs.CV 2025-06 conditional novelty 5.0 of 10

    SlideCoder converts slide design images to editable python-pptx code and reports large gains over prior baselines on a new difficulty-tiered benchmark.

Reference graph

Works this paper leans on

48 extracted references · 29 canonical work pages · cited by 9 Pith papers

  1. [1]

    URL: " 'urlintro :=

    ENTRY address author booktitle chapter edition editor howpublished institution journal key month note number organization pages publisher school series title type volume year eprint doi pubmed url lastchecked label extra.label sort.label short.list INTEGERS output.state before.all mid.sentence after.sentence after.block STRINGS urlintro eprinturl eprintpr...

  2. [2]

    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 word.in bbl.in capitalize " " * FUNCT...

  3. [3]

    https://techjury.net/blog/how-many-websites-are-there/ How many websites are there in 2024? (13 latest statistics)

    2024. https://techjury.net/blog/how-many-websites-are-there/ How many websites are there in 2024? (13 latest statistics) . TechJury. Accessed: 2024-05-30

    work page 2024

  4. [4]

    The White Label Agency. n.d. https://thewhitelabelagency.com/pixel-perfect-web-development-5-essential-steps/ Pixel-perfect web development: 5 essential steps . Accessed: 2024-11-21

    work page 2024

  5. [5]

    Anthropic . 2024 a . https://www.anthropic.com/claude Claude . Accessed: 2024-06-06

    work page 2024

  6. [6]

    Anthropic . 2024 b . https://docs.anthropic.com/en/docs/vision Vision documentation . Accessed: 2024-06-06

    work page 2024

  7. [7]

    Mart \'i n Arjovsky, Soumith Chintala, and L \'e on Bottou. 2017. https://api.semanticscholar.org/CorpusID:13943041 Wasserstein gan . ArXiv, abs/1701.07875

    arXiv 2017

  8. [8]

    u s ta R \

    Batuhan A s ro g lu, B \"u s ta R \"u meysa Mete, Eyy \"u p Y ld z, Ya g z Nal c akan, Alper Sezen, Mustafa Da g tekin, and Tolga Ensari. 2019. Automatic html code generation from mock-up images using machine learning techniques. In 2019 Scientific Meeting on Electrical-Electronics & Biomedical Engineering and Computer Science (EBBT), pages 1--4. Ieee

    work page 2019

Show all 48 references
  1. [9]

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

    2018

  2. [10]

    HTML Burger. n.d. https://htmlburger.com/blog/pixelparallel-free-pixel-perfect-tool/ Pixelparallel: Free pixel-perfect tool . Accessed: 2024-11-21

    2024

  3. [11]

    Hyungjoo Chae, Yeonghyeon Kim, Seungone Kim, Kai Tzu iunn Ong, Beong woo Kwak, Moohyeon Kim, Seonghwan Kim, Taeyoon Kwon, Jiwan Chung, Youngjae Yu, and Jinyoung Yeo. 2024. https://api.semanticscholar.org/CorpusID:268876471 Language models as compilers: Simulating pseudocode ex...

    2024 arXiv

  4. [12]

    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. In Proceedings of the 40th International Conference on Software Engineering, pages 665--676

    2018

  5. [13]

    W.-Y. Chen, P. Podstreleny, W.-H. Cheng, Y.-Y. Chen, and K.-L. Hua. 2022. Code generation from a graphical user interface via attention-based encoder--decoder model. Multimedia Systems, 28(1):121--130

    2022

  6. [14]

    Xinyun Chen, Maxwell Lin, Nathanael Sch \"a rli, and Denny Zhou. 2023. https://api.semanticscholar.org/CorpusID:258059885 Teaching large language models to self-debug . ArXiv, abs/2304.05128

    2023 arXiv

  7. [15]

    A. A. J. Cizotto, R. C. T. de Souza, V. C. Mariani, and L. dos Santos Coelho. 2023. Web pages from mockup design based on convolutional neural network and class activation mapping. Multimedia Tools and Applications, pages 1--27

    2023

  8. [16]

    Google . 2024. https://ai.google.dev/gemini-api Gemini api . Accessed: 2024-06-06

    2024

  9. [17]

    Google AI . 2024. https://ai.google.dev/gemini-api/docs/api-overview Api overview . Accessed: 2024-06-06

    2024

  10. [18]

    Yi Gui, Zhen Li, Yao Wan, Yemin Shi, Hongyu Zhang, Yi Su, Shaoling Dong, Xing Zhou, and Wenbin Jiang. 2024. https://api.semanticscholar.org/CorpusID:269010048 Vision2ui: A real-world dataset with layout for code generation from ui designs . ArXiv, abs/2404.06369

    2024 arXiv

  11. [19]

    Vanita Jain, Piyush Agrawal, Subham Banga, Rishabh Kapoor, and Shashwat Gulyani. 2019. Sketch2code: transformation of sketches to ui in real-time using deep neural network. arXiv preprint arXiv:1910.08930

    2019 arXiv

  12. [20]

    Ankur Joshi, Saket Kale, Satish Chandel, and D Kumar Pal. 2015. Likert scale: Explored and explained. British journal of applied science & technology, 7(4):396--403

    2015

  13. [21]

    Krishna Kiran. 2018. https://medium.com/@krishnakiran1992/pixel-perfect-web-implementation-5598a10bc761 Pixel perfect web implementation . Accessed: 2024-11-21

    2018

  14. [22]

    Hugo Laurençon, Léo Tronchon, and Victor Sanh. 2024. http://arxiv.org/abs/2403.09029 Unlocking the conversion of web screenshots into html code with the websight dataset

    2024 arXiv

  15. [23]

    Bee Lim, Sanghyun Son, Heewon Kim, Seungjun Nah, and Kyoung Mu Lee. 2017. https://api.semanticscholar.org/CorpusID:6540453 Enhanced deep residual networks for single image super-resolution . 2017 IEEE Conference on Computer Vision and Pattern Recognition Workshops (CVPRW), pag...

    2017

  16. [24]

    Ming Ronnier Luo, Guihua Cui, and Bryan Rigg. 2001. https://api.semanticscholar.org/CorpusID:118281853 The development of the cie 2000 colour difference formula

    2001

  17. [25]

    Moran, C

    K. Moran, C. Bernal-Cárdenas, M. Curcio, R. Bonett, and D. Poshyvanyk. 2018. Machine learning-based prototyping of graphical user interfaces for mobile apps. IEEE Transactions on Software Engineering, 46(2):196--221

    2018

  18. [26]

    T. A. Nguyen and C. Csallner. 2015 a . Reverse engineering mobile application user interfaces with remaui (t). In 2015 30th IEEE/ACM International Conference on Automated Software Engineering (ASE), pages 248--259

    2015

  19. [27]

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

    2015

  20. [28]

    OpenAI . 2024 a . https://openai.com/index/hello-gpt-4o/ Hello gpt-4o . Accessed: 2024-06-06

    2024

  21. [29]

    OpenAI . 2024 b . https://platform.openai.com/docs/guides/vision Vision guide . Accessed: 2024-06-06

    2024

  22. [30]

    Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, Gretchen Krueger, and Ilya Sutskever. 2021. https://api.semanticscholar.org/CorpusID:231591445 Learning transferable visual model...

    2021

  23. [31]

    Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J

    Colin Raffel, Noam M. Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J. Liu. 2019. https://api.semanticscholar.org/CorpusID:204838007 Exploring the limits of transfer learning with a unified text-to-text transformer . J. Mach...

    2019

  24. [32]

    Yossi Rubner, Carlo Tomasi, and Leonidas J. Guibas. 2000. https://api.semanticscholar.org/CorpusID:14106275 The earth mover's distance as a metric for image retrieval . International Journal of Computer Vision, 40:99--121

    2000

  25. [33]

    Chenglei Si, Yanzhe Zhang, Zhengyuan Yang, Ruibo Liu, and Diyi Yang. 2024. https://api.semanticscholar.org/CorpusID:268248801 Design2code: How far are we from automating front-end engineering? ArXiv, abs/2403.03163

    2024 arXiv

  26. [34]

    Karen Simonyan and Andrew Zisserman. 2014. https://api.semanticscholar.org/CorpusID:14124313 Very deep convolutional networks for large-scale image recognition . CoRR, abs/1409.1556

    2014 arXiv

  27. [35]

    VQEG. 2000. Final report from the video quality experts group on the validation of objective models of video quality assessment. Online. [Online] Available: http://www.vqeg.org/

    2000

  28. [36]

    Yuxuan Wan, Chaozheng Wang, Yi Dong, Wenxuan Wang, Shuqing Li, Yintong Huo, and Michael R Lyu. 2024. Automatically generating ui code from screenshot: A divide-and-conquer-based approach. arXiv preprint arXiv:2406.16386

    2024 arXiv

  29. [37]

    Xintao Wang, Kelvin C. K. Chan, K. Yu, Chao Dong, and Chen Change Loy. 2019. https://api.semanticscholar.org/CorpusID:146808596 Edvr: Video restoration with enhanced deformable convolutional networks . 2019 IEEE/CVF Conference on Computer Vision and Pattern Recognition Worksho...

    2019

  30. [38]

    Sheikh, and Eero P

    Zhou Wang, Alan Conrad Bovik, Hamid R. Sheikh, and Eero P. Simoncelli. 2004. https://api.semanticscholar.org/CorpusID:207761262 Image quality assessment: from error visibility to structural similarity . IEEE Transactions on Image Processing, 13:600--612

    2004

  31. [39]

    Way to Grow Editorial Team . 2024. https://www.waytogrow.com/blog/understanding-spa-vs-mpa/ Understanding spa vs. mpa: What’s the difference? Accessed: 2024-10-02

    2024

  32. [40]

    Web.com Editorial Team . 2024. https://www.web.com/blog/one-page-vs-multi-page-website/ One-page vs. multi-page website: What’s best for your business? Accessed: 2024-10-02

    2024

  33. [41]

    Xia, Quoc Le, and Denny Zhou

    Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Ed Huai hsin Chi, F. Xia, Quoc Le, and Denny Zhou. 2022. https://api.semanticscholar.org/CorpusID:246411621 Chain of thought prompting elicits reasoning in large language models . ArXiv, abs/2201.11903

    2022 arXiv

  34. [42]

    WellDoneCode. n.d. https://www.welldonecode.com/perfectpixel/ Perfectpixel by welldonecode . Accessed: 2024-11-21

    2024

  35. [43]

    Jingyu Xiao, Yuxuan Wan, Yintong Huo, Zhiyao Xu, and Michael R Lyu. 2024. Interaction2code: How far are we from automatic interactive webpage generation? arXiv preprint arXiv:2411.03292

    2024

  36. [44]

    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 Process, 33(8):e2369

    2021

  37. [45]

    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. https://api.semanticscho...

    2024 arXiv

  38. [46]

    Efros, Eli Shechtman, and Oliver Wang

    Richard Zhang, Phillip Isola, Alexei A. Efros, Eli Shechtman, and Oliver Wang. 2018. https://api.semanticscholar.org/CorpusID:4766599 The unreasonable effectiveness of deep features as a perceptual metric . 2018 IEEE/CVF Conference on Computer Vision and Pattern Recognition, p...

    2018

  39. [47]

    Ting Zhou, Yanjie Zhao, Xinyi Hou, Xiaoyu Sun, Kai Chen, and Haoyu Wang. 2024 a . https://api.semanticscholar.org/CorpusID:272708114 Bridging design and development with automated declarative ui code generation

    2024

  40. [48]

    Ting Zhou, Yanjie Zhao, Xinyi Hou, Xiaoyu Sun, Kai Chen, and Haoyu Wang. 2024 b . Bridging design and development with automated declarative ui code generation. arXiv preprint arXiv:2409.11667

    2024 arXiv

Pith tools

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