Port Marigold V2 to CPU-only

Runs the 20B Qwen-Image-Edit-2509 base from a memory-mapped GGUF instead of
bitsandbytes NF4, which is CUDA-only. diffusers copies each GGUF tensor out of
its memory map, which peaked near twice the file size and was OOM-killed; the
mapping is kept instead, so the weights are file-backed and evictable.

Everything computes fp32, since bf16 kernels can deadlock on a CPU-only build.
The four 1.85 GB LoRA checkpoints stream in one at a time rather than all four
resident. Runs are serialized on a lock, because Gradio's concurrency limit is
per handler and DualVisionApp registers three.

Measured on the free tier: 3.5 to 5 min per modality at 512 px in 14.7 GB.

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,4 @@
+.venv/
+.gradio/
+__pycache__/
+local/

LICENSE.txt

@@ -0,0 +1,177 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

README.md

@@ -1,13 +1,117 @@
 ---
-title: Q Cpu Test Hold
-emoji: 👁
-colorFrom: indigo
-colorTo: yellow
+title: Marigold V2 CPU
+emoji: 🌼
+colorFrom: green
+colorTo: indigo
 sdk: gradio
-sdk_version: 6.27.0
-python_version: '3.13'
+sdk_version: 5.29.0
+python_version: "3.10"
 app_file: app.py
 pinned: false
+license: apache-2.0
+fullWidth: true
+short_description: Depth, normals, albedo on free CPU, ~4 min per output
+startup_duration_timeout: 1h
+models:
+  - Qwen/Qwen-Image-Edit-2509
+  - QuantStack/Qwen-Image-Edit-2509-GGUF
+  - huawei-bayerlab/marigold-v2-0
+preload_from_hub:
+  - QuantStack/Qwen-Image-Edit-2509-GGUF Qwen-Image-Edit-2509-Q3_K_M.gguf
+  - Qwen/Qwen-Image-Edit-2509 transformer/config.json,vae/config.json,vae/diffusion_pytorch_model.safetensors
+  - huawei-bayerlab/marigold-v2-0 depth/Log-stage2/trainables.safetensors,depth/Log-layered/trainables.safetensors,normals/trainables.safetensors,albedo/trainables.safetensors
+  - huawei-bayerlab/marigold-v2-0 qwen_text_embeddings/qwen_edit_2509_qwen_depth_realimg512_prompt_embeds.pt,qwen_text_embeddings/qwen_edit_2509_qwen_depth_realimg512_prompt_mask.pt,qwen_text_embeddings/qwen_edit_2509_qwen_normals_dummy512_prompt_embeds.pt,qwen_text_embeddings/qwen_edit_2509_qwen_normals_dummy512_prompt_mask.pt,qwen_text_embeddings/qwen_edit_2509_qwen_albedo_rgb_dummy512_prompt_embeds.pt,qwen_text_embeddings/qwen_edit_2509_qwen_albedo_rgb_dummy512_prompt_mask.pt
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Marigold V2, CPU only
+
+A CPU port of [toshas/Marigold-V2](https://huggingface.co/spaces/toshas/Marigold-V2).
+Same weights, same single flow step, no GPU anywhere.
+
+Live demo: https://luminia-marigold-v2-cpu.hf.space/
+
+## What had to change
+
+The upstream Space runs a 20B `Qwen-Image-Edit-2509` transformer through bitsandbytes NF4 on
+an A100. Three things in that path are GPU only.
+
+**NF4 does not exist on CPU.** bitsandbytes needs CUDA, so the weights come from a GGUF build
+instead, loaded through `diffusers`' `GGUFQuantizationConfig` and dequantized per layer at
+fp32. `GGUFLinear` subclasses `nn.Linear`, so peft still wraps it and the four Marigold LoRAs
+attach exactly as before.
+
+There is a second trap underneath it. `diffusers` reads each GGUF tensor as
+`torch.from_numpy(tensor.data.copy())`, and `GGUFReader` hands it a memory map, so that
+`.copy()` turns a mapped file into anonymous RAM and the load peaks near twice the file size.
+Q2_K, the smallest build there is, peaked at 13.5 GB and was OOM-killed. `enable_gguf_mmap()`
+drops the copy, the pages stay file-backed on the 50 GB disk, and the identical run then held
+5.18 GB anonymous with 7.33 GB mapped. Base weights are read-only at inference, so sharing the
+mapping is safe. Set `MARIGOLD_GGUF_MMAP=0` to go back to upstream behaviour.
+
+Because anonymous memory no longer tracks the quant, the quant only decides how much page
+cache it wants on top of a fixed ~5.2 GB:
+
+The tier reports `MEMORY=16.0G`, not the 18 GB the docs quote, so the margin is about 1 GB
+rather than 3. Anon is roughly 4.9 GB once the dead VAE decoder backup is gone:
+
+| quant | on disk | + ~4.9 GB anon | verdict |
+|---|---|---|---|
+| bf16 (upstream) | 40.9 GB | n/a | needs a GPU |
+| Q4_K_M | 13.1 GB | 18.0 GB | over 16 GB, so it re-reads from disk every pass |
+| **Q3_K_M (default)** | **9.8 GB** | **14.7 GB** | fits 16 GB with about 1 GB spare |
+| Q2_K | 7.2 GB | 12.1 GB | the floor, measured working |
+
+**bf16 deadlocks on a CPU-only torch build.** The first forward hangs with no crash and no log
+line (pytorch#75458, pytorch#111456). Everything runs fp32 here. The one exception is the
+timestep, still divided in bf16 so the rounding matches training, then widened before it
+reaches a kernel.
+
+**Four checkpoints will not fit at once.** Upstream holds all four 1.85 GB `trainables.safetensors`
+resident, which is 7.4 GB on top of the transformer. Here they are read per request and dropped,
+so only one is in memory at a time.
+
+## Cost
+
+Measured on the Space itself, free tier, two shared cores, at 512 px (~196k pixels). Three runs,
+each the first after a restart:
+
+| run | Depth | See-through Depth | pair |
+|---|---|---|---|
+| 1 | 204.8 s | 218.4 s | 7.2 min |
+| 2 | 244.8 s | 253.5 s | 8.4 min |
+| 3 | 306.0 s | 270.0 s | 9.6 min |
+
+So **3.5 to 5 minutes per modality, 7 to 10 minutes for the default pair**. The spread is the
+cores being shared, not the input: runs 2 and 3 processed the same photo at the same size. Treat
+any single number here as a sample, not a spec.
+
+Cost is dominated by dequantizing 20B weights once per pass rather than by pixel count, so raising
+the long side is cheaper than it looks. A cold page cache costs more than the resolution does: the
+same forward took 749.8 s cold against 99.2 s warm on a 4-core box.
+
+Every run prints its real per-modality timing to the container log, so read `logs/run` for the
+number on your own input.
+
+One job runs at a time (`default_concurrency_limit=1`), because on two shared cores a second
+concurrent request makes both slower.
+
+## Run it locally
+
+Faster than the Space on any machine with more than two cores, and your images never leave it.
+
+```bash
+git clone https://huggingface.co/spaces/Luminia/Marigold-V2-CPU
+cd Marigold-V2-CPU
+pip install -r requirements.txt
+python app.py
+```
+
+Set `MARIGOLD_GGUF_FILE=Qwen-Image-Edit-2509-Q8_0.gguf` for the best quality if you have the RAM
+for it, or point `MARIGOLD_MAX_LONG_SIDE` higher than 512.
+
+## Credit
+
+Model and original demo by the Marigold V2 authors: [paper](https://arxiv.org/abs/2609.08084),
+[code](https://github.com/huawei-bayerlab/marigold-v2),
+[weights](https://huggingface.co/huawei-bayerlab/marigold-v2-0). GGUF conversion by
+[QuantStack](https://huggingface.co/QuantStack/Qwen-Image-Edit-2509-GGUF). Apache 2.0, as upstream.

app.py

@@ -0,0 +1,311 @@
+import base64
+import os
+import time
+from pathlib import Path
+
+import gradio as gr
+from gradio_dualvision import DualVisionApp
+from huggingface_hub import login
+from PIL import Image
+
+from marigoldv2_inference import (
+    BASE_MODEL_URI,
+    CHECKPOINTS,
+    GGUF_FILE,
+    MODEL_URI,
+    PROCESSING_MAX_LONG_SIDE,
+    MarigoldV2,
+)
+
+DEFAULT_RIGHT_MODALITY = "See-through Depth"
+DEFAULT_MODALITIES = ["Depth", "See-through Depth"]
+
+uri_base = os.environ.get("QWEN_IMAGE_EDIT_URI", BASE_MODEL_URI)
+uri_model = os.environ.get("MARIGOLD_V2_URI", MODEL_URI)
+
+if "HF_TOKEN_LOGIN" in os.environ:
+    login(token=os.environ["HF_TOKEN_LOGIN"])
+
+model = MarigoldV2(uri_base, uri_model)
+QUANT = GGUF_FILE.replace("Qwen-Image-Edit-2509-", "").replace(".gguf", "")
+# Backend and throughput on one line, the guide's `## Name | CPU (int8) | ~1.5s per 1s audio`.
+# The minutes are measured on the Space's two cores and stay prose on purpose: scaling them by
+# thread count would be a confident lie, since 4 cores at a quarter the pixels still took 134.6 s.
+BACKEND = f"CPU ({QUANT}, {model.threads} threads) | 3.5 to 5 min per modality on 2 cores"
+
+
+SHIELDS_DIR = Path(__file__).parent / "assets" / "shields"
+LINKS = [
+    ("website", "Website", "https://hf.co/spaces/huawei-bayerlab/marigold-v2-web"),
+    (
+        "paper",
+        "Paper",
+        "https://arxiv.org/abs/2609.08084",
+    ),
+    ("code", "Code", "https://github.com/huawei-bayerlab/marigold-v2"),
+    ("weights", "Weights", f"https://hf.co/huawei-bayerlab/marigold-v2-0"),
+    ("follow", "Follow", "https://twitter.com/antonobukhov1"),
+]
+# Badges are the committed SVGs, shared with the README, model card, and website. Inlined
+# as data URIs so the HTML header needs no static file route.
+BADGES = {
+    name: "data:image/svg+xml;base64,"
+    + base64.b64encode((SHIELDS_DIR / f"{name}.svg").read_bytes()).decode()
+    for name, _, _ in LINKS
+}
+HEADER_CSS = """
+    .mv2-header { max-width: 70vw; margin: 0 auto; display: grid; grid-template-columns: minmax(0, 6fr) minmax(0, 7fr); gap: 28px; align-items: center; color: var(--body-text-color); }
+    .mv2-identity { display: flex; flex-direction: column; gap: 6px; border-right: 1px solid var(--border-color-primary); padding-right: 28px; }
+    .mv2-titles { display: flex; flex-wrap: wrap; align-items: baseline; gap: 4px 14px; }
+    .mv2-title { font-family: 'Instrument Serif', Georgia, serif; font-weight: 400; font-size: 36px; line-height: 40px; color: var(--body-text-color); }
+    .mv2-subtitle { font-size: 12px; line-height: 16px; letter-spacing: 0.16em; text-transform: uppercase; color: var(--body-text-color-subdued); }
+    .mv2-links { display: flex; flex-wrap: wrap; align-items: center; gap: 6px 8px; margin-top: 8px; }
+    .mv2-link-group { display: inline-flex; gap: inherit; white-space: nowrap; }
+    .mv2-links a { display: inline-flex; line-height: 0; }
+    .mv2-links img { height: 22px; width: auto; transition: transform 0.15s ease; }
+    .mv2-links a:hover img { transform: translateY(-1px); }
+    .mv2-intro { margin: 0; font-size: 14px; line-height: 20px; }
+    .mv2-cost { font-weight: 600; }
+    @media (max-width: 900px) {
+        .mv2-header { max-width: none; grid-template-columns: minmax(0, 1fr); gap: 10px; }
+        .mv2-identity { display: grid; grid-template-columns: max-content minmax(0, 1fr); column-gap: 16px; row-gap: 4px; align-items: center; border-right: 0; border-bottom: 1px solid var(--border-color-primary); padding: 0 0 10px 0; }
+        .mv2-titles { display: contents; }
+        .mv2-title { grid-column: 1; grid-row: 1; font-size: 30px; line-height: 34px; }
+        .mv2-links { grid-column: 2; grid-row: 1; justify-content: flex-end; gap: 6px 8px; margin: 0; }
+        .mv2-subtitle { grid-column: 1 / -1; grid-row: 2; }
+        .mv2-intro { font-size: 13px; line-height: 18px; }
+    }
+    @media (max-width: 529px) {
+        .mv2-identity { grid-template-columns: minmax(0, 1fr) max-content; }
+        .mv2-subtitle { grid-column: 1; font-size: 10px; letter-spacing: 0.12em; }
+        .mv2-links { grid-row: 1 / span 2; align-self: center; flex-direction: column; align-items: flex-end; gap: 6px; }
+        .mv2-link-group { gap: 6px; }
+        .mv2-links img { height: 20px; }
+    }
+    @media (max-width: 370px) {
+        .mv2-title { font-size: 26px; line-height: 30px; }
+    }
+    /* Each modality group centered inside its half of the selector row, with a
+       hairline on the midline separating the left pane's choices from the right's. */
+    #selector_right > .wrap,
+    div:has(> #selector_right) > fieldset:first-child > .wrap { justify-content: center; }
+    div:has(> #selector_right) { position: relative; }
+    div:has(> #selector_right)::before {
+        content: "";
+        position: absolute;
+        top: 3px;
+        bottom: 3px;
+        left: 50%;
+        width: 1px;
+        background: var(--border-color-primary);
+    }
+    /* Footer links wrap as whole items; outside .contain, so plain rules only. */
+    footer.svelte-1byz9vf { flex-wrap: wrap; justify-content: center; gap: 2px 24px; }
+    footer.svelte-1byz9vf a { white-space: nowrap; }
+    footer.svelte-1byz9vf .divider { display: none; }
+    /* Examples block as wide as the drop zone, tiles in a full rectangle (column counts that divide 12). */
+    .block:has(> .gallery.svelte-p5q82i) { max-width: 70vw; margin-left: auto; margin-right: auto; }
+    .gallery.svelte-p5q82i.svelte-p5q82i.svelte-p5q82i { display: grid; grid-template-columns: repeat(6, minmax(0, 1fr)); gap: var(--spacing-lg); }
+    .gallery-item .gallery.svelte-a9zvka { width: 100%; min-width: 0; max-width: none; height: auto; min-height: 0; aspect-ratio: 1; }
+    .gallery.svelte-p5q82i .gallery-item img { width: 100%; min-width: 0; max-width: none; height: 100%; min-height: 0; object-fit: cover; }
+    @media (max-width: 900px) {
+        .block:has(> .gallery.svelte-p5q82i) { max-width: none; }
+        .sliderrow .slider { max-width: none; width: 100%; }
+        .slider .wrap.half-wrap { width: 100%; }
+    }
+    @media (max-width: 829px) { .gallery.svelte-p5q82i.svelte-p5q82i.svelte-p5q82i { grid-template-columns: repeat(4, minmax(0, 1fr)); } }
+    @media (max-width: 529px) { .gallery.svelte-p5q82i.svelte-p5q82i.svelte-p5q82i { grid-template-columns: repeat(3, minmax(0, 1fr)); } }
+    /* Keyboard focus stays visible wherever the theme above removes an outline. */
+    :where(button, input, textarea, select, [role="button"], [tabindex]):focus-visible {
+        outline: 2px solid var(--color-accent) !important;
+        outline-offset: 2px;
+    }
+    @media (prefers-reduced-motion: reduce) {
+        *, *::before, *::after { animation-duration: 0.01ms !important; transition-duration: 0.01ms !important; }
+    }
+"""
+HEADER_HEAD = '<link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Instrument+Serif&display=swap">'
+
+
+class MarigoldV2App(DualVisionApp):
+    def make_header(self):
+        links = "".join(
+            '<span class="mv2-link-group">'
+            + "".join(
+                f'<a href="{href}" target="_blank" rel="noopener noreferrer">'
+                f'<img src="{BADGES[name]}" alt="{label}"></a>'
+                for name, label, href in group
+            )
+            + "</span>"
+            for group in (LINKS[:3], LINKS[3:])
+        )
+        gr.HTML(
+            f"""
+            <div class="mv2-header">
+                <div class="mv2-identity">
+                    <div class="mv2-titles">
+                        <div class="mv2-title">Marigold V2</div>
+                        <div class="mv2-subtitle">{BACKEND}</div>
+                    </div>
+                    <div class="mv2-links remove-elements">{links}</div>
+                </div>
+                <p class="mv2-intro">
+                    A CPU port of the authors' <i>Marigold V2</i> demo, no GPU anywhere. Each modality is one
+                    pass through a 20B transformer, so
+                    <span class="mv2-cost">the default Depth plus See-through Depth pair takes 7 to 10 minutes</span>
+                    at 512 px on two shared cores. Set the modalities in Settings first, because the run starts
+                    the moment you drop a photo. One job runs at a time, so you may wait behind another visitor.
+                    Examples ignore Settings and take the same 7 minutes on their first click, then they are cached.
+                </p>
+            </div>
+            """,
+            padding=False,
+        )
+
+    def make_advanced_settings(self):
+        """Open the settings panel and put the cost in its header.
+
+        DualVisionApp starts the first run on upload, with no Start button, so a dropped photo
+        commits seven minutes immediately. Upstream hides these controls and the Apply button
+        behind `gr.Accordion(..., open=False)`, which means the labels carrying the cost are
+        never read before that happens. This mirrors upstream's bookkeeping, so re-check it if
+        the pinned gradio_dualvision commit ever moves.
+        """
+        with gr.Accordion(
+            f"Settings: {len(DEFAULT_MODALITIES)} modalities at {PROCESSING_MAX_LONG_SIDE} px, 7 to 10 min",
+            open=True,
+            visible=self.advanced_settings_visible,
+        ):
+            user_components = self.build_user_components()
+            with gr.Row():
+                btn_clear, btn_submit = self.make_buttons()
+        self.input_keys = list(user_components.keys())
+        self.input_cls = list(v.__class__ for v in user_components.values())
+        self.input_kwargs = [
+            {k: v for k, v in c.constructor_args.items() if k != "value"}
+            for c in user_components.values()
+        ]
+        return user_components, btn_clear, btn_submit
+
+    def build_user_components(self):
+        return {
+            "modalities": gr.CheckboxGroup(
+                choices=list(CHECKPOINTS),
+                value=DEFAULT_MODALITIES,
+                label="Modalities to compute (each is one full 20B pass, 3.5 to 5 min at 512 px)",
+                info="Depth and See-through Depth share one colour scale when both are on.",
+            ),
+            "max_long_side": gr.Slider(
+                minimum=256,
+                maximum=1024,
+                step=128,
+                value=PROCESSING_MAX_LONG_SIDE,
+                label=f"Max long side ({PROCESSING_MAX_LONG_SIDE} px default, 3.5 to 5 min per modality)",
+                info=(
+                    "Only downscales, so raising it past your photo's long side does nothing. "
+                    "Time goes on dequantizing the 20B weights rather than on pixels, so raising "
+                    "this costs much less than the pixel count suggests, and lowering it saves little."
+                ),
+            ),
+        }
+
+    def process_components(
+        self, image_in, modality_selector_left, modality_selector_right, **kwargs
+    ):
+        if modality_selector_right is None:
+            modality_selector_right = DEFAULT_RIGHT_MODALITY
+        return super().process_components(
+            image_in, modality_selector_left, modality_selector_right, **kwargs
+        )
+
+    def process(self, image_in: Image.Image, **kwargs):
+        modalities = kwargs.get("modalities")
+        # An explicitly emptied box is a mistake worth naming. The examples path passes no
+        # kwargs at all, so None still has to fall through to the defaults.
+        if modalities is not None and not modalities:
+            raise gr.Error(
+                "Pick at least one modality in Settings. Depth alone is the cheapest at "
+                "3.5 to 5 min.",
+                duration=None,
+            )
+        modalities = modalities or DEFAULT_MODALITIES
+        max_long_side = int(kwargs.get("max_long_side") or PROCESSING_MAX_LONG_SIDE)
+
+        progress = gr.Progress()
+        began = time.perf_counter()
+        # One forward per modality, 60 transformer blocks inside each, so hooking the blocks
+        # moves the bar every ~3.5 s with a real ETA instead of twice in seven minutes.
+        # These hooks mutate the shared model, and default_concurrency_limit=1 does NOT prevent
+        # a second run entering (it is per handler, and there are three). MarigoldV2 holds its
+        # own lock, so only the run that owns it is inside model(). The hooks still must come
+        # off in finally or they leak onto the next run.
+        blocks = model.transformer.transformer_blocks
+        total = len(modalities) * len(blocks)
+        state = {"done": 0, "name": modalities[0]}
+
+        def tick(*_):
+            state["done"] += 1
+            elapsed = time.perf_counter() - began
+            fraction = state["done"] / total
+            left = elapsed / fraction - elapsed
+            progress(
+                fraction,
+                desc=f"{state['name']} [+{elapsed / 60:.1f} min, about {left / 60:.0f} min left]",
+            )
+
+        handles = [block.register_forward_hook(tick) for block in blocks]
+        try:
+            outputs = model(
+                image_in,
+                modalities=modalities,
+                max_long_side=max_long_side,
+                progress_cb=lambda fraction, message: state.update(name=message),
+            )
+        except gr.Error:
+            raise
+        except Exception as exc:
+            raise gr.Error(
+                f"Run failed at {max_long_side} px with {len(modalities)} modalities: {exc}. "
+                f"Try Max long side 512 and one modality.",
+                duration=None,
+            ) from exc
+        finally:
+            for handle in handles:
+                handle.remove()
+        progress(1.0, desc=f"done in {(time.perf_counter() - began) / 60:.1f} min")
+        # One entry per build_user_components key, or DualVisionApp rejects the result AFTER
+        # the whole run has completed. The values come back as the restored control state.
+        return outputs, {"modalities": modalities, "max_long_side": max_long_side}
+
+
+with MarigoldV2App(
+    title="Marigold V2 CPU",
+    key_original_image="Input",
+    examples_path="example_images",
+    examples_per_page=12,
+    # NOT False. DualVisionApp hardcodes cache_examples=True and forwards this to cache_mode,
+    # so False is not "off", it is an invalid mode that falls back to caching every example
+    # eagerly at startup. At CPU speed that never finishes. "lazy" computes an example on its
+    # first click and caches it from then on.
+    examples_cache="lazy",
+    left_selector_visible=True,
+    advanced_settings_visible=True,
+    squeeze_canvas=True,
+    # Default 75vh puts the examples and settings below the fold, worse with the panel open.
+    squeeze_viewport_height_pct=58,
+    spaces_zero_gpu_enabled=False,
+    css=HEADER_CSS,
+    head=HEADER_HEAD,
+) as demo:
+    # Cores are the bottleneck on the 2-vCPU tier, so a second concurrent job makes both slower.
+    demo.queue(
+        api_open=False,
+        # Per concurrency group, and gradio derives the group from str(id(fn)), so this does
+        # not by itself stop three handlers running at once. MarigoldV2's lock is what does.
+        default_concurrency_limit=1,
+        # Unbounded, visitor six waits 40 minutes staring at a queue position. Refuse instead.
+        max_size=4,
+    ).launch(
+        show_error=True,
+        ssr_mode=False,
+    )