Omni2Web: Benchmarking Audiovisual Website Development

Paper · Code · Project & leaderboard · Source webpages: WebVR

Omni2Web evaluates whether a model can turn an audiovisual webpage-editing request into the right final website. A user points at page elements with the cursor while speaking requests such as “change this,” “move this one here,” or “swap these two.” Resolving those requests requires connecting speech, cursor movements, visible page context, and the history of earlier edits—including changes the user later undoes.

The benchmark contains 918 Chinese and English instances across 129 source webpages, with 13,907 editing steps and 28,732 rubric items. Each instance includes a screen recording with its original audio, a manually written transcript, a reference to the source HTML, and structured evaluation annotations. Three complementary tracks separate direct website editing, instruction recovery, and the downstream utility of recovered instructions.

The cursor trajectory connects spoken requests to webpage targets. Track A produces a complete edited HTML page; Tracks B and C diagnose intent recovery and its utility for a fixed coding executor.

Benchmark at a glance

Content	Scale
Instances / split	918 instances in the test split
Source webpages	129
Editing steps	13,907; 10–20 per instance
Rubric items	28,732
Operation types	12
Languages	465 Chinese and 453 English instances
Difficulty labels	207 easy, 230 medium, and 481 hard instances
Videos	918 MP4 recordings with audio; 34.05 hours; 14.53 GB
Recording duration	Median: 128.04 seconds; range: 58.69–299.52 seconds
JSONL annotations	918 records; 17.11 MB
Total release	Approximately 14.55 GB

Sizes use decimal GB/MB. This release provides a single evaluation split; it does not include a separate training or validation split. Machine-readable statistics and the per-video inventory are available in manifest.json.

Editing operations

Operation	Description
rewrite_text	Rewrite text in the indicated element.
change_color	Change the color of the indicated target or property.
change_font	Change typography, such as font size or styling.
change_layout	Change how elements are arranged.
change_theme	Change the visual theme of the indicated target.
batch_style	Apply styling to multiple indicated elements.
region_edit	Edit a selected region of the page.
replace_image	Replace an image with the requested content.
move	Move an element to the indicated position.
swap	Exchange the positions of two elements.
hide_or_delete	Hide or remove the indicated content.
revert	Restore the state affected by an earlier edit.

An instance may contain several operation types. Revisions must be interpreted in the context of the editing sequence, so the final page reflects the user's final intent.

Evaluation tracks

Track	Model input	Required output	Main metrics
A — Direct Editing	Audiovisual recording and source HTML	A complete edited HTML page	Edit Fidelity Score (EFS)
B — Instruction Recovery	Audiovisual recording	Explicit, self-contained target/action instructions for each step	Instruction Recovery Score (IRS)
C — Instruction Utility	Recovered instructions and source HTML, passed to a fixed deepseek-v4-pro executor	Executor-generated HTML	EFS and Normalized Instruction Utility (NIU)

The released prediction example supports three input routes: omni uses the original video with audio; vl-video uses a silent video plus the manual transcript; vl-frames uses timestamped frames plus the transcript, with 1 FPS as the default. Report the input route when comparing models. The transcripts retain the spoken language, while the task prompt templates are in English.

Track A: Edit Fidelity Score

EFS evaluates the requested final webpage through four components:

Component	Weight	What it checks
Target grounding	0.10	Whether the intended webpage elements or regions were identified.
Edit fulfillment	0.50	Whether the requested edits were implemented.
No-damage	0.20	Whether unrelated page content and structure were preserved.
Revision	0.20	Whether undo and restoration requests were fulfilled.

With component scores on a 0–1 scale:

EFS = 0.10 × target_grounding + 0.50 × edit_fulfillment
    + 0.20 × no_damage + 0.20 × revision

The evaluator scores the final state, rather than requiring an intermediate execution trace. Requirements canceled by later whole-step reversions are recorded in rubric.excluded_steps and omitted from final-state scoring; the restoration request itself remains subject to evaluation. If a component has no applicable items, the scorer renormalizes the available component weights.

Track B: Instruction Recovery Score

A Gemini judge matches reference steps and predicted steps one to one by semantic meaning, then checks target identification and editing action separately:

F1_target = 2 × TP_target / (n_reference + n_predicted)
F1_action = 2 × TP_action / (n_reference + n_predicted)
IRS = 0.5 × F1_target + 0.5 × F1_action

Extra predicted steps contribute to n_predicted. The judge compares the intended target and resulting change, rather than exact wording. Predictions should resolve references such as “this” into explicit page elements and express each action so that it can be followed without viewing the recording.

Track C: Normalized Instruction Utility

The fixed executor generates HTML from both recovered instructions and oracle reference instructions under identical settings. NIU is the ratio of dataset-level mean EFS values over the same paired, successfully scored samples:

NIU = mean(EFS_recovered) / mean(EFS_oracle)

NIU is a ratio of means, rather than a mean of per-instance ratios. The project leaderboard displays EFS and IRS on a 0–100 scale and NIU as 100 × NIU; the scoring code stores the underlying 0–1 scores and the NIU ratio.

All reported means are instance macro averages. Missing or unparsable contestant outputs receive zero. Judge-side failures are reported separately and excluded from scoring; Track C also reports executor failures and paired-sample coverage.

Release contents

Omni2Web/
├── README.md                 # Dataset card
├── benchmark.jsonl           # Complete annotations, one record per instance
├── data/test.parquet         # Hugging Face Datasets index
├── videos/001.mp4 ... 918.mp4 # Original recordings with audio
├── source_pages.json         # 129 source HTML paths and pinned WebVR revision
├── manifest.json             # Dataset statistics and video inventory
├── assets/                   # Overview and dataset anatomy figures
├── CHECKSUMS.sha256           # SHA-256 checksums for release files
├── LICENSE                   # CC BY-NC 4.0 for original contributions
└── NOTICE.md                 # Attribution and upstream-content notices

Source HTML files are obtained separately from WebVR. This repository includes their paths and a pinned upstream revision, so they can be resolved reproducibly through the original distribution. See Get the source webpages.

Annotation schema

benchmark.jsonl contains one JSON object per instance. Sample IDs are strings from "001" through "918"; preserve their leading zeros when writing predictions.

Field	Type	Description
sample_id	string	Three-digit instance identifier.
video	string	Recording path relative to the dataset directory, such as videos/001.mp4.
transcript	string	Manually written speech transcript, with requests separated by newlines.
source_page.dataset	string	Upstream dataset ID, BroAlanTaps/WebVR.
source_page.html_path	string	Source HTML path relative to the WebVR directory.
metadata.language	string	Spoken language: en or zh.
metadata.difficulty	string	Released difficulty label: easy, medium, or hard.
metadata.difficulty_hit_rate	number	Released hit-rate value accompanying the difficulty annotation.
metadata.step_count	integer	Number of editing steps in the instance.
metadata.operation_types	array of strings	Operation types appearing in the instance.
metadata.video_duration_sec	number	Recording duration in seconds.
rubric.items	array of objects	Evaluation items, including category, question, weight, and expected visible evidence.
rubric.revision_links	array of objects	Links from each revision step to the earlier steps it reverts.
rubric.excluded_steps	array of objects	Canceled requirements, their rubric item IDs, and the steps that revert them.

Rubric item categories are target_grounding (13,907 items), edit_fulfillment (11,738), revision (2,169), and no_damage (918). Expected evidence describes the original target, the requested resulting change, forbidden changes, and any distractor context. The rubrics and revision annotations are reference information for evaluation and oracle execution; keep them out of contestant inputs for Tracks A and B.

For example, instance 001 has the following revision annotations:

{
  "revision_links": [
    {"revision_step": 5, "reverted_steps": [4]},
    {"revision_step": 12, "reverted_steps": [11]},
    {"revision_step": 19, "reverted_steps": [18]}
  ],
  "excluded_steps": [
    {"step": 4, "item_ids": ["r7", "r8"], "reverted_by_steps": [5]},
    {"step": 11, "item_ids": ["r21", "r22"], "reverted_by_steps": [12]},
    {"step": 18, "item_ids": ["r35", "r36"], "reverted_by_steps": [19]}
  ]
}

Download and use

Inspect annotations and download one recording

Install the Hub client:

pip install -U huggingface_hub

The following example downloads the annotations and the first recording, without downloading all 14.55 GB:

import json
from pathlib import Path
from huggingface_hub import hf_hub_download

repo_id = "minghaofdu/Omni2Web"
annotation_path = hf_hub_download(
    repo_id=repo_id,
    repo_type="dataset",
    filename="benchmark.jsonl",
    local_dir="Omni2Web",
)
with Path(annotation_path).open(encoding="utf-8") as f:
    sample = json.loads(next(f))

print(sample["sample_id"], sample["metadata"])
print(sample["transcript"])
print(sample["source_page"])

video_path = hf_hub_download(
    repo_id=repo_id,
    repo_type="dataset",
    filename=sample["video"],
    local_dir="Omni2Web",
)
print("Local recording:", video_path)

Load the Hugging Face Datasets index

pip install -U datasets

from datasets import Video, load_dataset

dataset = load_dataset("minghaofdu/Omni2Web", split="test")
dataset = dataset.cast_column("video", Video(decode=False))
sample = dataset[0]
print(len(dataset))  # 918
print(sample["sample_id"])
print(sample["video"]["path"])

The Parquet index carries the same annotations, with each video field represented as a Hugging Face Video feature pointing to the recording's Hub URL. decode=False exposes the path without decoding video frames. Use the original MP4 when the model needs synchronized audio and visual input.

Download the full release

hf download minghaofdu/Omni2Web \
  --repo-type dataset --local-dir Omni2Web

To download only annotations and metadata:

hf download minghaofdu/Omni2Web \
  README.md benchmark.jsonl data/test.parquet source_pages.json \
  manifest.json CHECKSUMS.sha256 LICENSE NOTICE.md \
  --repo-type dataset --local-dir Omni2Web

For reproducible runs, pin a dataset commit with --revision COMMIT_SHA or the Python client's revision argument. After downloading the full release, check its integrity from the Omni2Web directory with sha256sum -c CHECKSUMS.sha256 on Linux, or shasum -a 256 -c CHECKSUMS.sha256 on macOS. The full checksum check expects every listed file to be present.

Get the source webpages

The required HTML paths are listed in source_pages.json. This example obtains just those 129 files from the pinned WebVR revision:

import json
from pathlib import Path
from huggingface_hub import hf_hub_download

mapping_path = hf_hub_download(
    repo_id="minghaofdu/Omni2Web",
    repo_type="dataset",
    filename="source_pages.json",
    local_dir="Omni2Web",
)
mapping = json.loads(Path(mapping_path).read_text(encoding="utf-8"))
for html_path in mapping["html_paths"]:
    hf_hub_download(
        repo_id=mapping["dataset"],
        repo_type="dataset",
        revision=mapping["revision"],
        filename=html_path,
        local_dir="WebVR",
    )

The pinned revision is 7917c3a2b44a0838eb0acffb80a38ec6030b49b6. For instance 001, the source resolves to WebVR/test/279/279_1.html. Pass the WebVR directory as --webvr-root when running the scoring code. Upstream pages may reference externally hosted images or other third-party assets; their availability and terms remain governed by the original sources.

Run the official evaluation

The official evaluation code repository is Hanminghao/Omni2Web-evaluation. Follow the GitHub repository's README for the latest installation instructions and complete evaluator documentation. The scoring code provides the three evaluation tracks, a prediction example, prompt templates, example prediction files, and synthetic tests.

Python 3.10 or later is recommended. Clone the repository and install the evaluator:

git clone https://github.com/Hanminghao/Omni2Web-evaluation.git
cd Omni2Web-evaluation
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
cp .env.example .env

Download the Omni2Web dataset and resolve its source HTML using the instructions above before running predictions or scoring.

Configure GEMINI_API_KEY in .env for scoring. Track C also requires DEEPSEEK_API_KEY. The released scorer uses the Google Gemini API, and the fixed executor uses the DeepSeek API. The VL prediction routes additionally require ffmpeg.

Prediction formats

For Track A, write one JSONL record per sample containing the complete edited HTML in response. HTML may be wrapped in a single html code fence. The scorer also accepts JSON predictions or a directory of HTML files; for the latter, preserve the sample IDs in filenames such as 001.html.

For Track B, the response string contains a JSON array with one object per editing step:

{"sample_id":"001","response":"[{\"step\":1,\"target\":\"the title and body inside the 'VOCAL ENSEMBLE' card\",\"instruction\":\"Arrange the title and body side by side in two columns.\"}]"}

This is a single-step format illustration from instance 001, rather than a complete prediction for its 20-step sequence. Keep the target and action text in the spoken language, and retain all requested steps, including revisions.

predict_example.py demonstrates how to generate Track A or B outputs. For example, from the evaluator directory:

python predict_example.py \
  --benchmark /path/to/Omni2Web/benchmark.jsonl \
  --webvr-root /path/to/WebVR \
  --track a --input-mode omni \
  --output track_a_predictions.jsonl

The example processes one instance by default. Add --limit 0 to generate predictions for all 918 instances, or --dry-run to inspect the assembled prompt without calling the model. For Track B, use --track b; select --input-mode vl-video or vl-frames for the corresponding visual-plus-transcript route. The templates in prediction_prompts.py can be reused with another model provider.

Score predictions

Run these commands from the evaluation code directory, using prediction files for the full benchmark. Replace /path/to/Omni2Web and /path/to/WebVR with your local dataset directories:

# Track A: direct edited HTML
python run_eval.py \
  --benchmark /path/to/Omni2Web/benchmark.jsonl --webvr-root /path/to/WebVR \
  --predictions track_a_predictions.jsonl \
  --model-name my-model --output-dir track_a_results

# Track B: recovered instructions
python run_eval_rewrite.py \
  --benchmark /path/to/Omni2Web/benchmark.jsonl --webvr-root /path/to/WebVR \
  --predictions track_b_predictions.jsonl \
  --model-name my-model --output-dir track_b_results

# Track C: recovered instructions and oracle instructions with the fixed executor
python run_eval_e2e.py \
  --benchmark /path/to/Omni2Web/benchmark.jsonl --webvr-root /path/to/WebVR \
  --rewrite-predictions track_b_predictions.jsonl \
  --model-name my-model --output-dir track_c_results

Add --resume to reuse successful results after interruption. Each track writes aggregate metrics and coverage in summary.json, per-sample results in results.json, and input hashes and scoring settings in run_manifest.json. Track A/C also retain intermediate judge outputs for inspection. The benchmark and predictions bundled inside the code's examples/ directory are synthetic scoring fixtures; use the dataset root's benchmark.jsonl for actual benchmark evaluation.

Results on the project leaderboard

The project leaderboard covers 23 open- and closed-source models: 17 reported in the paper and 6 additional models. The following values summarize the published leaderboard as of November 2, 2026:

Result	Model / setting	Score on the displayed 0–100 scale
Best Track A EFS	Gemini 3.8 Flash	56.95
Best Track B IRS	Qwen3.8-Omni-Flash-Realtime	57.01
Best Track C EFS	Qwen3.8-Omni-Flash-Realtime + fixed executor	60.24
Corresponding Track C NIU	Same recovered-instruction setting	67.16
Oracle-instruction EFS	Reference instructions + deepseek-v4-pro	89.69

These results highlight complementary challenges: identifying the right target does not guarantee a successful edit; temporal alignment between speech and visual context matters; and recovered instructions can benefit from a separate coding executor. For example, the project reports that Qwen3.5-Omni-Plus increases from 29.56 EFS in direct editing to 51.08 EFS when its recovered instructions are passed to the fixed executor. Consult the live leaderboard for updates and report evaluator configuration and sample coverage alongside reproduced scores.

License and attribution

The Omni2Web creators' original dataset contributions are released under CC BY-NC 4.0. See LICENSE and NOTICE.md. Attribute the project and its creators, indicate changes, and retain the relevant notices when redistributing covered materials. Refer to the GitHub code repository for the evaluation code's license.

Source webpages are obtained from WebVR under their upstream terms. The WebVR dataset card declares MIT, while its code repository uses Apache-2.0; those sources and any third-party assets retain their own applicable licenses. Omni2Web's license does not relicense upstream or third-party material.

Disclaimer

All webpage content, interface elements, and related webpage materials depicted in the Omni2Web dataset are fictional, AI-generated materials produced using Qwen models based on publicly available open-source datasets. These materials are intended solely for benchmark evaluation and academic research and do not represent the authors' views. They should not be interpreted as descriptions of, or allusions to, any real organization, technology, law or regulation, event, or individual. Downstream users are responsible for complying with the licensing terms of upstream datasets and model service agreements, as well as applicable laws and regulations.

Citation

If you use the dataset or evaluation code, please cite Omni2Web:

@article{han2026omni2web,
  title={Omni2Web: Benchmarking Audiovisual Website Development},
  author={Han, Minghao and Xing, Zhenghao and Cheng, Xize and Wang, Yuxuan and Lin, Junming and Wang, Ling and Yan, Yinsong and Chu, Yunfei and Yang, Qize and Xu, Jin},
  journal={arXiv preprint arXiv:2609.23417},
  year={2026}
}