- Rating
- 4(+1)
- Confidence
- 4
- Informativeness
- 3(+1)
- Presentation
- 3
- Soundness
- 3
Read review
Paper summary
This work presents w1, a VLM for screenshot-to-HTML transformation. The core idea is to ensure that the output code in the training data is visually grounded by removing invisible elements and unused styles, etc.
The resulting dataset, WebGround-3M, is shown to be more effective and easier to train compared to baselines such as WebSight-v2 and WebCode2M.
The authors also curate 200k preference pairs for DPO, which intentionally target syntactic repetition and semantic perturbation.
The complete pipeline, SFT + DPO, allows Qwen3.5-9B to outperform strong models such as zero-shot GPT-5 and Gemini-3.5-flash.
Critical strengths
- The idea of ensuring the code is visually grounded for converting webpage screenshots into HTML code is clean and elegant.
- The derived dataset WebGround-3M shows a clear advantage compared to the WebCode2M baseline at different data scales (100k to 3M). The advantage also holds across four other backbone families.
- The experiments are reasonably comprehensive: six benchmarks, three model sizes, five backbone families, and an ablation on the preference-pair construction. The synthetic DPO negatives are also a cheap and practical way to handle repetition, which seems to be the dominant failure mode.
Critical weaknesses
- It seems that there is no plan for releasing the datasets and models. The reproducibility statement only says that the backbones, benchmarks, and source corpus (WebCode2M) are public. Since the main contribution of this paper is the data, not releasing WebGround-3M, the cleaning pipeline, the 200k preference pairs, or the w1 checkpoints significantly limits the value to the community.
- The claim that cleaning "preserves the rendering results" is only supported by CLIP similarity (98.81% after Step 1), which is a coarse measure. Appendix A also acknowledges that removing frames, canvas, and overlays can change visible content. It would be more convincing to report finer-grained metrics (e.g., the Design2Code block/text/position scores) between the original and cleaned renders, and the fraction of pages where visible content is lost.
- The cleaned code is visually grounded, but it may be less useful as real-world code: semantic tags (header, nav, main) are normalized to div, hover styles are removed, and selectors are rewritten to compact class names. These do not change the screenshot, but they matter for accessibility, interactivity, and maintainability, which is part of why people want screenshot-to-HTML in the first place. The paper should at least discuss this trade-off.
Questions for authors
- In Table 2, it seems that the MCD baseline is very competitive while using much fewer pages and tokens (200k pages x 582 tokens, roughly 80x fewer target tokens than WebGround-3M). In fact, at a matched scale of 200k pairs, MCD (5.72 GPT / 84.5 D2C) is better than w1-SFT (5.05 / 80.0, Table 7) with the same Qwen3-VL-4B backbone. Can the authors elaborate more on the pros and cons of using AI-generated HTML code? Would it be a better approach (or more computationally efficient) to use both MCD and WebGround-3M, e.g., by mixing the two or training on MCD first and then on WebGround-3M?
- Is the DPO gain specific to WebGround-3M? Would the same synthetic preference pairs also improve models fine-tuned on WebCode2M or MCD?
2 comments
Thanks the authors for the response.
Most of my concerns are resolved. Looking forward to the public release of the relevant resource.
I want to highlight that this paper present a simple, clean, and effective idea of improving screensho-to-html generation, with convincing empirical evidence.
I will increase my score to 4.
We thank the reviewer for the encouraging assessment and the constructive suggestions. All changes are highlighted in blue in the revised manuscript.
W1. No release plan.
We apologize for the omission. The Reproducibility Statement (p. 11) now commits to releasing WebGround-3M, the 200k preference pairs with their corruption scripts, the w1 checkpoints, and the evaluation scripts.
W2. Rendering preservation is supported only by CLIP.
We agree that CLIP is too coarse. App. E.1 (Table 11, p. 26) now reports the Design2Code sub-scores between the original rendering and the rendering after Step 1. The metric is costly to compute, so we use 10,000 uniformly sampled pages:
Pages losing visible content. We do not yet have a reliable per-page count and prefer not to report one we cannot stand behind. The cases are those in App. A (frames, canvas, overlays); their aggregate effect is bounded by the scores above. We also (i) no longer claim rendering equivalence: the abstract and Sec. 1 now say "largely / closely preserving", and the Limitation paragraph (Sec. 3, p. 6) states that visible content can be deleted on some pages; (ii) note in Sec. 2.2 that the input screenshot is re-rendered from the cleaned code, so every training pair stays consistent.
W3. Cleaned code may be less useful as real-world code.
This is a fair point: tag normalization, removal of
:hoverrules, and class renaming affect how directly the code can be used. We explain the design in a new paragraph of Sec. 3 ("What does screenshot-to-code supervise?", p. 6). A static screenshot specifies appearance only. It does not carry the requirements for accessibility, interactivity, or maintainability, so these cannot be well supervised from a screenshot alone. Interactivity is a separate sub-task that needs other inputs, such as several state captures or a text specification. Semantic tags are partly inferable from layout; the new ablation (Table 12) shows that tag normalization is the least important component of Step 1 (-0.09 GPT when removed), so they could be retained at a small cost. Bringing these properties into the task requires suitably designed inputs and benchmarks, since current benchmarks evaluate visual similarity only; we list this as future work.Q1. Pros and cons of AI-generated HTML; mixing with MCD.
The reviewer's reading of Tables 2 and 7 is correct, and Sec. 3 ("Real-world webpages versus synthetic webpages", p. 6) now explains such.
Pros. Synthetic pages are grounded by construction and short, hence token-efficient: at a matched 200k pairs, MCD reaches 5.72 GPT against 5.05 for WebGround-3M.
Cons. (i) Their quality comes from the teacher: training on them transfers the capability of a frontier model and is bounded by its cost and capability. Our pipeline needs no teacher, only public crawled pages and deterministic rules, so the solution is open and reproducible. (ii) The pages are much simpler than real ones (21.5 vs. 132.3 DOM elements); on CC-Hard, 200k WebGround-3M pairs already beat MCD (5.84 vs. 5.45 GPT). (iii) Crawled pages are practically unlimited, and performance keeps improving up to 3M pairs (Fig. 4), where WebGround-3M overtakes MCD (6.19 vs. 5.72).
Mixing or MCD first. We agree this is promising, since the two sources look complementary. We could not complete these experiments within the rebuttal period, so we make no claim and list them as future work in the same paragraph.
Q2. Is the DPO gain specific to WebGround-3M?
No, although it is largest there by a small margin. For models fine-tuned on WebCode2M and MCD, we built 200k preference pairs with the same construction strategy (that training set's targets as preferred samples, corrupted copies as negatives), so that the preferred samples match what each SFT model was trained to produce. See App. E.3 (Table 13, p. 27).
</html>, of 1,460)DPO helps all three, mainly by reducing code repetition. The gain is smallest for MCD, whose SFT model produces short pages and rarely repeats. To the best of our knowledge, we are the first to construct a preference dataset and to apply DPO for this task.
We thank the reviewer again and are happy to answer further questions.