Serve rotating WebP turntables + GT generator

Point the gallery and proxy routes at rotating.webp (submissions and
GT), publish the full per-fixture renders folder, and add a reusable
one-time GT turntable generator that renders from the cached GT mesh.

Co-authored-by: Cursor <cursoragent@cursor.com>

app.py

@@ -528,18 +528,12 @@ def serve_report(submission_id: str) -> Response:
     return Response(content=content, media_type="text/html; charset=utf-8")
 
 
-# Single canonical view served as the gallery thumbnail. Matches the
-# view uploaded by the eval job (eval_job.py GALLERY_THUMB_VIEW) and the
-# GT render the gallery pairs it with, so columns stay comparable.
-GALLERY_THUMB_VIEW = "iso"
-
-
 def _fetch_render(submission_id: str, fixture: str) -> bytes | None:
-    """Pull a submission's gallery thumbnail (``renders/<id>/<fixture>.png``).
+    """Pull a submission's gallery WebP (``renders/<id>/<fixture>/rotating.webp``).
 
     Deliberately **not** memoized: renders land over time (a submission
     completes, or an existing row is backfilled) after the Space process
-    booted, so negative-caching a boot-time miss would keep a thumbnail
+    booted, so negative-caching a boot-time miss would keep a turntable
     dashed until the next restart. ``hf_hub_download`` does its own disk
     caching per revision, so a re-fetch of an unchanged file stays cheap.
     Returns ``None`` on any failure (the gallery draws the dashed cell).
@@ -547,7 +541,7 @@ def _fetch_render(submission_id: str, fixture: str) -> bytes | None:
     try:
         local_path = hf_hub_download(
             repo_id=HF_SUBMISSIONS_REPO,
-            filename=f"renders/{submission_id}/{fixture}.png",
+            filename=f"renders/{submission_id}/{fixture}/rotating.webp",
             repo_type="dataset",
         )
         return Path(local_path).read_bytes()
@@ -560,13 +554,12 @@ def _fetch_render(submission_id: str, fixture: str) -> bytes | None:
 
 
 def _fetch_gt_render(fixture: str) -> bytes | None:
-    """Pull a fixture's ground-truth thumbnail from the private GT dataset.
+    """Pull a fixture's ground-truth GIF from the private GT dataset.
 
-    Path inside the GT repo is ``<fixture>/renders/<view>.png`` (see
-    ``cadgenbench.common.paths.data_gt_dir``). GT renders are a property
-    of the data revision, not of any submission, so they're served
-    straight from the GT repo rather than duplicated per submission.
-    Not memoized for the same reason as :func:`_fetch_render` (GT
+    Path inside the GT repo is ``<fixture>/renders/rotating.webp``. GT
+    renders are a property of the data revision, not of any submission,
+    so they're served straight from the GT repo rather than duplicated
+    per submission. Not memoized for the same reason as :func:`_fetch_render` (GT
     renders can be added/updated on a data revision bump);
     ``hf_hub_download`` handles the per-revision disk cache. Needs the
     Space ``HF_TOKEN``'s read scope on the private repo.
@@ -574,7 +567,7 @@ def _fetch_gt_render(fixture: str) -> bytes | None:
     try:
         local_path = hf_hub_download(
             repo_id=HF_DATA_GT_REPO,
-            filename=f"{fixture}/renders/{GALLERY_THUMB_VIEW}.png",
+            filename=f"{fixture}/renders/rotating.webp",
             repo_type="dataset",
         )
         return Path(local_path).read_bytes()
@@ -589,13 +582,13 @@ def _fetch_gt_render(fixture: str) -> bytes | None:
 # Long-lived immutable caching: a (submission, fixture) render never
 # changes (fixed camera + lighting; re-renders would be a new artifact),
 # so the browser/CDN can keep it forever. This is what makes fixture
-# swaps and repeat visits free: only the ~33 on-screen thumbnails are
+# swaps and repeat visits free: only the ~33 on-screen turntables are
 # fetched on first paint, and everything after that is a cache hit.
 RENDER_CACHE_CONTROL = "public, max-age=31536000, immutable"
 
 
 def _render_proxy_url(submission_id: str, fixture: str) -> str | None:
-    """Resolver returning the cached proxy URL for a submission render.
+    """Resolver returning the cached proxy URL for a submission GIF.
 
     Returns the route string **without** fetching the bytes (that's the
     whole point: the browser lazy-fetches on demand, so only the visible
@@ -608,40 +601,40 @@ def _render_proxy_url(submission_id: str, fixture: str) -> str | None:
     Requires the Space to be **public**: while private, HF's edge 404s
     in-browser fetches to these custom routes.
     """
-    return f"/render/{submission_id}/{fixture}.png"
+    return f"/render/{submission_id}/{fixture}.webp"
 
 
 def _gt_proxy_url(fixture: str) -> str | None:
-    """Resolver returning the cached proxy URL for a fixture's GT render."""
-    return f"/gt-render/{fixture}.png"
+    """Resolver returning the cached proxy URL for a fixture's GT WebP."""
+    return f"/gt-render/{fixture}.webp"
 
 
 def serve_render(submission_id: str, fixture: str) -> Response:
-    """Stream a submission's per-fixture render PNG with long-lived caching.
+    """Stream a submission's per-fixture render WebP with long-lived caching.
 
-    The gallery references ``/render/<id>/<fixture>.png`` and the browser
+    The gallery references ``/render/<id>/<fixture>.webp`` and the browser
     fetches it lazily. Re-streams the dataset bytes (the Space holds the
     read token) with an immutable ``Cache-Control`` so the CDN/browser
     cache it hard.
     """
-    png = _fetch_render(submission_id, fixture)
-    if png is None:
+    webp = _fetch_render(submission_id, fixture)
+    if webp is None:
         return Response(status_code=404)
     return Response(
-        content=png,
-        media_type="image/png",
+        content=webp,
+        media_type="image/webp",
         headers={"Cache-Control": RENDER_CACHE_CONTROL},
     )
 
 
 def serve_gt_render(fixture: str) -> Response:
-    """Stream a fixture's ground-truth render PNG with long-lived caching."""
-    png = _fetch_gt_render(fixture)
-    if png is None:
+    """Stream a fixture's ground-truth render WebP with long-lived caching."""
+    webp = _fetch_gt_render(fixture)
+    if webp is None:
         return Response(status_code=404)
     return Response(
-        content=png,
-        media_type="image/png",
+        content=webp,
+        media_type="image/webp",
         headers={"Cache-Control": RENDER_CACHE_CONTROL},
     )
 
@@ -649,7 +642,7 @@ def serve_gt_render(fixture: str) -> Response:
 def _gallery_iframe_html() -> str:
     """Build the gallery as a self-contained ``srcdoc`` iframe.
 
-    Reads the live rows and renders the page (thumbnails referenced as
+    Reads the live rows and renders the page (turntables referenced as
     cached ``/render`` / ``/gt-render`` proxy URLs, lazy-loaded by the
     browser), then inlines the whole document into an iframe ``srcdoc``
     so it gets its own style context (no Gradio CSS collision). A Hub
@@ -678,7 +671,7 @@ with gr.Blocks(title="CADGenBench Leaderboard", theme=gr.themes.Soft()) as block
 
     with gr.Tab("Gallery"):
         # Visual-first leaderboard. The bespoke surface (sticky GT row,
-        # fixture picker, thumbnail grid, compare modal) is a
+        # fixture picker, turntable grid, compare modal) is a
         # self-contained HTML doc inlined into an iframe `srcdoc` so it
         # keeps its own style context. Thumbnails are lazy-loaded from
         # the cached `/render` / `/gt-render` proxy routes (requires the
@@ -1000,16 +993,16 @@ app.add_api_route(
     serve_report,
     methods=["GET"],
 )
-# Cached render proxies the gallery's lazy-loaded thumbnails point at.
+# Cached render proxies the gallery's lazy-loaded turntables point at.
 # Registered before the Gradio mount so they're not shadowed by the
 # catch-all sub-app.
 app.add_api_route(
-    "/render/{submission_id}/{fixture}.png",
+    "/render/{submission_id}/{fixture}.webp",
     serve_render,
     methods=["GET"],
 )
 app.add_api_route(
-    "/gt-render/{fixture}.png",
+    "/gt-render/{fixture}.webp",
     serve_gt_render,
     methods=["GET"],
 )

gallery.py

@@ -17,7 +17,7 @@
 Builds a self-contained HTML document (its own CSS + JS) from the live
 submission rows. The Space serves it at ``/gallery`` and embeds it in
 the Gradio "Gallery" tab via an iframe, so the bespoke visual surface
-(sticky ground-truth row, fixture picker, thumbnail grid, report
+(sticky ground-truth row, fixture picker, turntable grid, report
 modal) lives in plain HTML/JS isolated from Gradio's styles rather
 than being forced into Gradio components.
 
@@ -28,18 +28,18 @@ which the page's JS renders. Render lookups are isolated behind the
 pointed at the cached render-proxy URLs the caller injects via the two
 resolvers:
 
-- ``renderFor(sub, fixtureId)``  -> ``/render/<id>/<fixture>.png`` (or
+- ``renderFor(sub, fixtureId)``  -> ``/render/<id>/<fixture>.webp`` (or
   ``null`` when the per-fixture status is invalid/missing, which draws
   the dashed "invalid generation" cell).
-- ``gtRenderFor(fixtureId)``     -> ``/gt-render/<fixture>.png``.
+- ``gtRenderFor(fixtureId)``     -> ``/gt-render/<fixture>.webp``.
 
-Thumbnails are lazy-loaded by the browser, so only the ~33 on-screen
+GIFs are lazy-loaded by the browser, so only the ~33 on-screen
 tiles are fetched and CDN/browser caching makes fixture-swaps and
 repeat visits essentially free. This requires the Space to be
 **public** (HF's edge 404s in-browser fetches to our custom routes
 while private).
 
-Thumbnail clicks open a GT-vs-output compare modal that points at the
+Turntable clicks open a GT-vs-output compare modal that points at the
 existing per-submission detail/report view.
 """
 from __future__ import annotations
@@ -163,7 +163,7 @@ def render_gallery_page(rows: list[dict], render_resolver, gt_resolver) -> str:
 
     ``render_resolver`` / ``gt_resolver`` supply the cached render-proxy
     URLs (see :func:`build_gallery_payload`); the browser lazy-loads only
-    the on-screen thumbnails.
+    the on-screen turntables.
 
     The document is self-contained and uses **system font stacks only**
     (no external font CDN fetch) so it never errors inside a sandboxed
@@ -335,7 +335,7 @@ body {
 }
 .thumb:hover { transform: translateY(-2px); box-shadow: 0 6px 18px rgba(20,22,28,.14); border-color: var(--accent); }
 /* Display width is CSS-constrained so the browser downscales the existing
-   full-res render: no resize step, no new assets. */
+   render artifact: no resize step, no new assets. */
 .thumb img { width: 100%; height: 100%; display: block; object-fit: contain; }
 .thumb .open-hint {
   position: absolute; inset: 0; display: flex; align-items: center; justify-content: center;

submit.py

@@ -133,11 +133,6 @@ RESULTS_FILENAME = "results.jsonl"
 SUBMISSIONS_DIR = "submissions"
 REPORTS_DIR = "reports"
 RENDERS_DIR = "renders"
-# Single canonical view staged per fixture for the leaderboard gallery
-# thumbnail (matches eval_job.py's GALLERY_THUMB_VIEW). The merged-shard
-# path stages these from the merged run dir, exactly as the single-job
-# eval_job does from its in-job run dir.
-GALLERY_THUMB_VIEW = "iso"
 DATA_REV_SHORT_LEN = 12
 FAILURE_REASON_MAX_CHARS = 200
 SHA256_BLOCK_SIZE = 64 * 1024
@@ -1456,7 +1451,7 @@ def _merge_shards_and_publish(
     (the proven merge primitive, importable from the Space's own
     ``cadgenbench`` install -- no private-repo dependency), a
     ``report.json`` bundle, an HTML report via the same ``report
-    single`` renderer the job uses, and one ``iso`` gallery thumbnail
+    single`` renderer the job uses, and the full gallery render folder
     per fixture. Uploads ``reports/<id>.{html,json}`` + the gallery
     renders, and returns the merged ``run_summary`` for the row flip.
 
@@ -1574,19 +1569,19 @@ def _publish_reports_and_gallery(
     report_json: dict[str, Any],
     run_dir: Path,
 ) -> None:
-    """Publish report HTML/JSON + every gallery thumbnail in one commit.
+    """Publish report HTML/JSON + every per-fixture gallery render in one commit.
 
     The merged artifacts land at the exact paths the leaderboard + the
     row-flip expect: ``reports/<id>.{html,json}`` plus one
-    ``renders/<id>/<fixture>.png`` per fixture that produced an ``iso``
-    thumbnail. All of it goes in a single ``create_commit`` rather than
+    ``renders/<id>/<fixture>/<filename>`` entry for every PNG/GIF in each
+    fixture's render folder. All of it goes in a single ``create_commit`` rather than
     one ``upload_file`` per file: a fan-out can stage ~80+ thumbnails,
     and a commit-per-file both serialises the publish (slow) and hammers
     the dataset's commit endpoint (the 429 "concurrency queue" failures
     that stranded earlier runs). One commit is atomic, fast, and
     rate-limit friendly.
 
-    A fixture with no ``iso.png`` (missing output / render that never
+    A fixture with no render folder (missing output / render that never
     ran) is skipped, matching the single-job behaviour; the gallery
     draws the dashed "invalid" cell from the row, so an absent thumbnail
     is not an error.
@@ -1605,14 +1600,19 @@ def _publish_reports_and_gallery(
     ]
     render_count = 0
     for fixture_dir in sorted(d for d in run_dir.iterdir() if d.is_dir()):
-        iso_png = fixture_dir / "renders" / f"{GALLERY_THUMB_VIEW}.png"
-        if iso_png.is_file():
+        renders_dir = fixture_dir / "renders"
+        if not renders_dir.is_dir():
+            continue
+        for render_path in sorted(renders_dir.iterdir()):
+            if render_path.suffix.lower() not in {".png", ".webp"}:
+                continue
             operations.append(
                 CommitOperationAdd(
                     path_in_repo=(
-                        f"{RENDERS_DIR}/{submission_id}/{fixture_dir.name}.png"
+                        f"{RENDERS_DIR}/{submission_id}/"
+                        f"{fixture_dir.name}/{render_path.name}"
                     ),
-                    path_or_fileobj=str(iso_png),
+                    path_or_fileobj=str(render_path),
                 )
             )
             render_count += 1

tests/test_proxy.py

@@ -42,6 +42,28 @@ def test_serve_report_returns_404_when_file_missing(monkeypatch):
     assert "Report not found" in resp.body.decode("utf-8")
 
 
+def test_serve_render_returns_webp_when_file_exists(monkeypatch):
+    """Submission render proxy serves WebP bytes with image/webp media type."""
+    monkeypatch.setattr(app, "_fetch_render", lambda sid, fixture: b"RIFFwebp")
+
+    resp = app.serve_render("sub-test", "101")
+
+    assert resp.status_code == 200
+    assert resp.media_type == "image/webp"
+    assert resp.body == b"RIFFwebp"
+
+
+def test_serve_gt_render_returns_webp_when_file_exists(monkeypatch):
+    """GT render proxy serves generated GT WebP bytes."""
+    monkeypatch.setattr(app, "_fetch_gt_render", lambda fixture: b"RIFFwebp")
+
+    resp = app.serve_gt_render("101")
+
+    assert resp.status_code == 200
+    assert resp.media_type == "image/webp"
+    assert resp.body == b"RIFFwebp"
+
+
 def test_fetch_report_html_returns_none_on_hub_failure(monkeypatch):
     """A Hub-side exception is caught and surfaced as None.
 
@@ -57,6 +79,38 @@ def test_fetch_report_html_returns_none_on_hub_failure(monkeypatch):
     assert app._fetch_report_html("sub-failure-probe-unique-1") is None
 
 
+def test_fetch_render_uses_nested_rotating_webp_path(monkeypatch, tmp_path):
+    """Submission renders are fetched from the nested WebP artifact path."""
+    webp = tmp_path / "rotating.webp"
+    webp.write_bytes(b"RIFFwebp")
+    captured: dict = {}
+
+    def fake_download(**kwargs):
+        captured.update(kwargs)
+        return str(webp)
+
+    monkeypatch.setattr(app, "hf_hub_download", fake_download)
+
+    assert app._fetch_render("sub-test", "101") == b"RIFFwebp"
+    assert captured["filename"] == "renders/sub-test/101/rotating.webp"
+
+
+def test_fetch_gt_render_uses_gt_rotating_webp_path(monkeypatch, tmp_path):
+    """GT WebPs are fetched from the GT dataset's per-fixture render folder."""
+    webp = tmp_path / "rotating.webp"
+    webp.write_bytes(b"RIFFwebp")
+    captured: dict = {}
+
+    def fake_download(**kwargs):
+        captured.update(kwargs)
+        return str(webp)
+
+    monkeypatch.setattr(app, "hf_hub_download", fake_download)
+
+    assert app._fetch_gt_render("101") == b"RIFFwebp"
+    assert captured["filename"] == "101/renders/rotating.webp"
+
+
 def test_proxy_route_is_registered():
     """The mounted FastAPI app exposes ``/reports/{submission_id}.html`` as GET.
 
@@ -66,6 +120,8 @@ def test_proxy_route_is_registered():
     """
     routes = [getattr(r, "path", None) for r in app.app.routes]
     assert "/reports/{submission_id}.html" in routes
+    assert "/render/{submission_id}/{fixture}.webp" in routes
+    assert "/gt-render/{fixture}.webp" in routes
 
 
 # --- Boot resilience: no silent fallback, but no crash either -------

tools/generate_gt_turntables.py

@@ -0,0 +1,215 @@
+#!/usr/bin/env python3
+"""Generate the permanent ground-truth turntable WebPs (one-time work).
+
+Each GT fixture in ``cadgenbench-data-gt`` ships a trusted mesh sidecar
+(``ground_truth.mesh.npz``) next to its ``ground_truth.step``. This tool loads
+that **cached mesh** via :class:`cadgenbench.common.artifacts.StepArtifacts`
+(so it never re-tessellates) and renders the same rotating WebP the eval
+pipeline produces for submissions, then commits each to
+``<fixture>/renders/rotating.webp`` in the GT dataset.
+
+GT renders are a property of the data revision, not of any submission, so this
+runs once (and again only when the GT geometry changes). The shared renderer
+(:func:`cadgenbench.common.viewer.render_mesh_turntable_webp`) guarantees GT and
+candidate turntables look identical (same material, lighting, framing, speed).
+
+Run locally (against a checkout)::
+
+    python tools/generate_gt_turntables.py --gt-root ../cadgenbench-data-gt --upload
+
+Or on an HF Job (GPU, no checkout — downloads STEP + sidecar from the Hub).
+After the eval-gpu image is rebuilt with the updated ``cadgenbench`` package,
+dispatch this file's contents on that image, e.g. with the Python API::
+
+    from huggingface_hub import run_job
+    run_job(
+        image="hf.co/spaces/HuggingAI4Engineering/cadgenbench-eval-gpu",
+        command=["python", "-c", Path("generate_gt_turntables.py").read_text()
+                 + "\nimport sys; sys.exit(main())"],
+        flavor="a10g-large",
+        namespace="michaelr27",
+        secrets={"HF_TOKEN": "<write-token>"},
+        timeout="30m",
+    )
+
+(The job needs a **write**-scoped token for the private GT dataset.)
+"""
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+import tempfile
+from pathlib import Path
+
+from huggingface_hub import CommitOperationAdd, HfApi, hf_hub_download
+
+# Allow running straight from the repo without installing the leaderboard pkg;
+# cadgenbench itself must be importable (installed in the env / eval-gpu image).
+_REPO_ROOT = Path(__file__).resolve().parents[2]
+_SRC = _REPO_ROOT / "cadgenbench" / "src"
+if _SRC.is_dir():
+    sys.path.insert(0, str(_SRC))
+
+from cadgenbench.common.artifacts import StepArtifacts  # noqa: E402
+from cadgenbench.common.viewer import render_mesh_turntable_webp  # noqa: E402
+
+GT_STEP_NAME = "ground_truth.step"
+GT_SIDECAR_NAME = "ground_truth.mesh.npz"
+RENDER_PATH_IN_FIXTURE = "renders/rotating.webp"
+# One commit per this many files: ~80 GT fixtures fit in a single commit, but
+# chunking keeps an individual commit small and rate-limit friendly.
+COMMIT_CHUNK = 60
+
+
+def _default_repo_id() -> str:
+    return os.getenv(
+        "HF_DATA_GT_REPO",
+        f"{os.getenv('HF_ORG', 'HuggingAI4Engineering')}/cadgenbench-data-gt",
+    )
+
+
+def _fixture_ids(api: HfApi, repo_id: str, gt_root: Path | None) -> list[str]:
+    """Fixture ids that have a ``ground_truth.step`` (local checkout or Hub)."""
+    if gt_root is not None:
+        ids = [
+            p.name for p in gt_root.iterdir()
+            if p.is_dir() and (p / GT_STEP_NAME).is_file()
+        ]
+    else:
+        files = api.list_repo_files(repo_id, repo_type="dataset")
+        ids = [
+            f.split("/", 1)[0] for f in files if f.endswith("/" + GT_STEP_NAME)
+        ]
+    return sorted(set(ids), key=lambda s: (len(s), s))
+
+
+def _materialize_fixture(
+    api: HfApi,
+    repo_id: str,
+    fixture: str,
+    gt_root: Path | None,
+    cache_dir: Path,
+    token: str | None,
+) -> Path:
+    """Return a local dir holding this fixture's STEP + trusted mesh sidecar.
+
+    The sidecar must sit next to the STEP so ``StepArtifacts`` takes the
+    trusted-mesh path (no tessellation, no validation).
+    """
+    if gt_root is not None:
+        return gt_root / fixture
+    dest = cache_dir / fixture
+    dest.mkdir(parents=True, exist_ok=True)
+    for name in (GT_STEP_NAME, GT_SIDECAR_NAME):
+        local = hf_hub_download(
+            repo_id=repo_id,
+            filename=f"{fixture}/{name}",
+            repo_type="dataset",
+            token=token,
+        )
+        target = dest / name
+        if not target.exists():
+            target.write_bytes(Path(local).read_bytes())
+    return dest
+
+
+def _render_fixture_webp(fixture_dir: Path) -> bytes:
+    """Render the turntable WebP from the fixture's cached GT mesh."""
+    art = StepArtifacts(fixture_dir / GT_STEP_NAME, is_ground_truth=True)
+    mesh = art.mesh()  # trusted sidecar -> no tessellation
+    return render_mesh_turntable_webp(mesh)
+
+
+def _commit_in_chunks(
+    api: HfApi, repo_id: str, ops: list[CommitOperationAdd],
+) -> None:
+    for i in range(0, len(ops), COMMIT_CHUNK):
+        chunk = ops[i:i + COMMIT_CHUNK]
+        api.create_commit(
+            repo_id=repo_id,
+            repo_type="dataset",
+            operations=chunk,
+            commit_message=(
+                f"add GT turntable webp(s) [{i + 1}-{i + len(chunk)}]"
+            ),
+        )
+        print(f"  committed {len(chunk)} file(s)", flush=True)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--gt-root", type=Path, default=None,
+        help="Local cadgenbench-data-gt checkout. Omit to download from the Hub.",
+    )
+    parser.add_argument("--repo-id", default=_default_repo_id())
+    parser.add_argument(
+        "--fixtures",
+        help="Comma-separated fixture ids. Omit for every GT fixture.",
+    )
+    parser.add_argument("--limit", type=int, default=None)
+    parser.add_argument(
+        "--out-dir", type=Path, default=None,
+        help="Also write each webp here (e.g. for local inspection).",
+    )
+    parser.add_argument(
+        "--no-upload", action="store_true",
+        help="Render only; do not commit to the GT dataset.",
+    )
+    args = parser.parse_args()
+
+    token = os.environ.get("HF_TOKEN")
+    api = HfApi(token=token)
+    gt_root = args.gt_root.resolve() if args.gt_root else None
+    if gt_root is not None and not gt_root.is_dir():
+        parser.error(f"--gt-root does not exist: {gt_root}")
+
+    fixtures = _fixture_ids(api, args.repo_id, gt_root)
+    if args.fixtures:
+        wanted = {f.strip() for f in args.fixtures.split(",") if f.strip()}
+        fixtures = [f for f in fixtures if f in wanted]
+    if args.limit is not None:
+        fixtures = fixtures[: args.limit]
+    if not fixtures:
+        parser.error("No GT fixtures matched.")
+
+    if not args.no_upload and not token:
+        parser.error("HF_TOKEN required to upload (or pass --no-upload).")
+
+    print(
+        f"Rendering {len(fixtures)} GT turntable(s) -> {args.repo_id}"
+        + ("" if args.no_upload else " (will upload)"),
+        flush=True,
+    )
+    ops: list[CommitOperationAdd] = []
+    with tempfile.TemporaryDirectory(prefix="gt-turntable-") as tmp:
+        cache_dir = Path(tmp)
+        for i, fixture in enumerate(fixtures, start=1):
+            print(f"[{i}/{len(fixtures)}] {fixture}", flush=True)
+            fixture_dir = _materialize_fixture(
+                api, args.repo_id, fixture, gt_root, cache_dir, token,
+            )
+            webp = _render_fixture_webp(fixture_dir)
+            if args.out_dir is not None:
+                local_out = args.out_dir / fixture / "rotating.webp"
+                local_out.parent.mkdir(parents=True, exist_ok=True)
+                local_out.write_bytes(webp)
+            ops.append(
+                CommitOperationAdd(
+                    path_in_repo=f"{fixture}/{RENDER_PATH_IN_FIXTURE}",
+                    path_or_fileobj=webp,
+                )
+            )
+
+        if args.no_upload:
+            print(f"Rendered {len(ops)} webp(s); upload skipped.", flush=True)
+            return 0
+        print(f"Uploading {len(ops)} webp(s) to {args.repo_id}…", flush=True)
+        _commit_in_chunks(api, args.repo_id, ops)
+    print("Done.", flush=True)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())