Z-Image CMF demo (cortiq 0.7.5)

README.md

@@ -1,13 +1,27 @@
 ---
-title: Z Image Cmf
-emoji: 🏆
-colorFrom: red
-colorTo: yellow
+title: Z-Image CMF
+emoji: 🎨
+colorFrom: indigo
+colorTo: pink
 sdk: gradio
 sdk_version: 6.28.0
-python_version: '3.13'
+python_version: "3.12"
 app_file: app.py
 pinned: false
+license: apache-2.0
+short_description: Z-Image and Z-Image-Turbo run by cortiq, a Rust engine
+models:
+  - infosave/Z-Image-Turbo-cmf
+  - infosave/Z-Image-cmf
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Z-Image · CMF
+
+Text-to-image with Tongyi-MAI's Z-Image and Z-Image-Turbo, packaged as single `.cmf` files
+([infosave/Z-Image-Turbo-cmf](https://huggingface.co/infosave/Z-Image-Turbo-cmf),
+[infosave/Z-Image-cmf](https://huggingface.co/infosave/Z-Image-cmf)) and run by
+[cortiq](https://github.com/infosave2007/cmf), a Rust engine with no Python ML stack. The Space
+downloads the cortiq 0.7.5 Linux binary and the chosen model on first use, then calls
+`cortiq imagine` for each request. On the free CPU hardware a 256² Turbo image takes minutes and
+jobs run one at a time; the app shows a live ETA, a gallery of 1024² samples, and the commands
+to run the same files on your own GPU or Mac.

app.py

@@ -0,0 +1,607 @@
+"""Z-Image CMF demo: text-to-image with the cortiq engine (Rust, no Python ML stack).
+
+The same file runs on a Hugging Face Space and locally. Paths are set by env:
+
+  CORTIQ_BIN         an existing cortiq binary (default: download the Linux x86-64 release)
+  ZIMAGE_TURBO_CMF   an existing z-image-turbo.cmf (default: download from the Hub on first use)
+  ZIMAGE_BASE_CMF    an existing z-image.cmf       (default: download from the Hub on first use)
+  CACHE_DIR          where downloads go (default: /data if writable, else ./cache)
+  CORTIQ_DEVICE      auto | cpu | gpu  (auto: GPU only when nvidia-smi or macOS is present)
+  MAX_JOB_MINUTES    refuse jobs whose estimate exceeds this on the CPU (default 45)
+"""
+
+import glob
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tarfile
+import threading
+import time
+import urllib.request
+import uuid
+
+import gradio as gr
+from huggingface_hub import hf_hub_download
+from PIL import Image
+
+CORTIQ_VERSION = "0.7.5"
+CORTIQ_URL = os.environ.get(
+    "CORTIQ_URL",
+    f"https://github.com/infosave2007/cmf/releases/download/v{CORTIQ_VERSION}/"
+    "cortiq-x86_64-unknown-linux-gnu.tar.gz",
+)
+GITHUB = "https://github.com/infosave2007/cmf"
+
+
+def _pick_cache():
+    if os.environ.get("CACHE_DIR"):
+        return os.environ["CACHE_DIR"]
+    if os.path.isdir("/data") and os.access("/data", os.W_OK):
+        return "/data/zimage-cache"
+    return os.path.join(os.path.dirname(os.path.abspath(__file__)), "cache")
+
+
+CACHE = _pick_cache()
+os.makedirs(CACHE, exist_ok=True)
+OUT_DIR = os.path.join(CACHE, "out")
+os.makedirs(OUT_DIR, exist_ok=True)
+
+MODELS = {
+    "Z-Image-Turbo (8 steps, no CFG)": {
+        "key": "turbo",
+        "repo": "infosave/Z-Image-Turbo-cmf",
+        "file": "z-image-turbo.cmf",
+        "env": "ZIMAGE_TURBO_CMF",
+        "steps": 8,
+        "cfg": 0.0,
+        "size_gb": 10.46,
+    },
+    "Z-Image base (28 steps, CFG 4)": {
+        "key": "base",
+        "repo": "infosave/Z-Image-cmf",
+        "file": "z-image.cmf",
+        "env": "ZIMAGE_BASE_CMF",
+        "steps": 28,
+        "cfg": 4.0,
+        "size_gb": 10.46,
+    },
+}
+MODEL_NAMES = list(MODELS)
+
+SAMPLE_PROMPTS = [
+    "A cat on a windowsill at sunset, photorealistic",
+    "A fisherman's hands tying a rope",
+    'A "CORTIQ" neon sign on a brick wall',
+    "An aerial view of a river in autumn",
+]
+
+
+# ── hardware ─────────────────────────────────────────────────────────────────
+
+def effective_cpus():
+    """vCPUs this container may use: the cgroup quota, not the host's core count."""
+    n = os.cpu_count() or 1
+    try:
+        n = len(os.sched_getaffinity(0))
+    except AttributeError:
+        pass
+    try:  # cgroup v2
+        quota, period = open("/sys/fs/cgroup/cpu.max").read().split()[:2]
+        if quota != "max":
+            n = min(n, max(1, round(int(quota) / int(period))))
+    except (OSError, ValueError):
+        try:  # cgroup v1
+            q = int(open("/sys/fs/cgroup/cpu/cpu.cfs_quota_us").read())
+            p = int(open("/sys/fs/cgroup/cpu/cpu.cfs_period_us").read())
+            if q > 0:
+                n = min(n, max(1, round(q / p)))
+        except (OSError, ValueError):
+            pass
+    return n
+
+
+def ram_gb():
+    try:
+        for f in ("/sys/fs/cgroup/memory.max", "/sys/fs/cgroup/memory/memory.limit_in_bytes"):
+            if os.path.exists(f):
+                v = open(f).read().strip()
+                if v != "max" and int(v) < 1 << 50:
+                    return int(v) / 1e9
+        return os.sysconf("SC_PAGE_SIZE") * os.sysconf("SC_PHYS_PAGES") / 1e9
+    except (OSError, ValueError, AttributeError):
+        return 0.0
+
+
+NCPU = effective_cpus()
+RAM_GB = ram_gb()
+
+
+def detect_device():
+    want = os.environ.get("CORTIQ_DEVICE", "auto").lower()
+    if want == "cpu":
+        return "cpu"
+    if want == "gpu":
+        return "metal" if sys.platform == "darwin" else "vulkan"
+    if sys.platform == "darwin":
+        return "metal"
+    if shutil.which("nvidia-smi"):
+        try:
+            r = subprocess.run(["nvidia-smi", "-L"], capture_output=True, text=True, timeout=10)
+            if r.returncode == 0 and "GPU" in r.stdout:
+                return "vulkan"
+        except Exception:
+            pass
+    return "cpu"
+
+
+DEVICE = detect_device()
+DEVICE_LABEL = {
+    "cpu": f"CPU only, {NCPU} vCPU{'s' if NCPU != 1 else ''}",
+    "metal": "Apple silicon GPU (Metal)",
+    "vulkan": "NVIDIA GPU (Vulkan)",
+}[DEVICE]
+
+# ── cost model for the ETA ───────────────────────────────────────────────────
+# One DiT forward is ~2 * 6.15e9 FLOP per token row (image patches + caption)
+# plus attention; 256² ≈ 3.4 TFLOP, 512² ≈ 13.6 TFLOP. CFG doubles it.
+
+DIT_PARAMS = 6.15e9
+CAPTION_ROWS = 64
+
+
+def step_tflop(w, h, cfg):
+    rows = (w // 16) * (h // 16) + CAPTION_ROWS
+    f = 2 * DIT_PARAMS * rows + 4 * rows * rows * 3840 * 34
+    return f * (2 if cfg > 0 else 1) / 1e12
+
+
+def vae_tflop(w, h):
+    return 2.5 * (w * h) / (1024 * 1024)
+
+
+# Default effective throughputs (TFLOP/s) and fixed overhead (s): measured on
+# the M4 and the RTX 3090; the CPU figure is a guess the first run corrects.
+DEFAULT_SPEED = {
+    "cpu": {"dit": 0.045 * NCPU, "vae": 0.03 * NCPU, "overhead": 20 + 120 / max(NCPU, 1)},
+    "metal": {"dit": 3.7, "vae": 2.5, "overhead": 6.0},
+    "vulkan": {"dit": 50.0, "vae": 20.0, "overhead": 3.0},
+}
+SPEED_FILE = os.path.join(CACHE, f"speed-{DEVICE}-{NCPU}.json")
+
+
+def load_speed():
+    s = dict(DEFAULT_SPEED[DEVICE])
+    s["measured"] = False
+    try:
+        s.update(json.load(open(SPEED_FILE)))
+    except (OSError, ValueError):
+        pass
+    return s
+
+
+SPEED = load_speed()
+
+
+def save_speed(dit_tflops, overhead):
+    SPEED["dit"] = dit_tflops if not SPEED.get("measured") else 0.5 * SPEED["dit"] + 0.5 * dit_tflops
+    SPEED["overhead"] = overhead if not SPEED.get("measured") else 0.5 * SPEED["overhead"] + 0.5 * overhead
+    SPEED["measured"] = True
+    try:
+        json.dump(SPEED, open(SPEED_FILE, "w"))
+    except OSError:
+        pass
+
+
+def estimate_seconds(w, h, steps, cfg):
+    return (
+        SPEED["overhead"]
+        + steps * step_tflop(w, h, cfg) / SPEED["dit"]
+        + vae_tflop(w, h) / SPEED["vae"]
+    )
+
+
+def fmt_dur(s):
+    s = max(0, int(round(s)))
+    if s < 90:
+        return f"{s} s"
+    if s < 3600:
+        return f"{s // 60} min {s % 60:02d} s"
+    return f"{s // 3600} h {(s % 3600) // 60:02d} min"
+
+
+MAX_JOB_S = float(os.environ.get("MAX_JOB_MINUTES", "45")) * 60 if DEVICE == "cpu" else float("inf")
+
+# ── downloads ────────────────────────────────────────────────────────────────
+
+_bin_lock = threading.Lock()
+_dl_lock = threading.Lock()
+_downloads = {}  # model key -> {"thread", "error", "path"}
+
+
+def cortiq_bin():
+    env = os.environ.get("CORTIQ_BIN")
+    if env:
+        return env
+    path = os.path.join(CACHE, "bin", "cortiq")
+    with _bin_lock:
+        if not os.path.exists(path):
+            os.makedirs(os.path.dirname(path), exist_ok=True)
+            tgz = path + ".tar.gz"
+            urllib.request.urlretrieve(CORTIQ_URL, tgz)
+            with tarfile.open(tgz) as t:
+                member = next(m for m in t.getmembers() if os.path.basename(m.name) == "cortiq")
+                member.name = "cortiq"
+                t.extract(member, os.path.dirname(path))
+            os.remove(tgz)
+            os.chmod(path, 0o755)
+    return path
+
+
+def model_local(name):
+    m = MODELS[name]
+    env = os.environ.get(m["env"])
+    if env and os.path.exists(env):
+        return env
+    p = os.path.join(CACHE, "models", m["key"], m["file"])
+    return p if os.path.exists(p) else None
+
+
+def _download(name):
+    m = MODELS[name]
+    d = _downloads[name]
+    try:
+        d["path"] = hf_hub_download(
+            m["repo"], m["file"], local_dir=os.path.join(CACHE, "models", m["key"])
+        )
+    except Exception as e:  # surfaced to the user by the generator
+        d["error"] = f"{type(e).__name__}: {e}"
+
+
+def start_download(name):
+    with _dl_lock:
+        d = _downloads.get(name)
+        if d and (d["thread"].is_alive() or d.get("path")):
+            return d
+        d = {"thread": None, "error": None, "path": None, "t0": time.time()}
+        _downloads[name] = d
+        d["thread"] = threading.Thread(target=_download, args=(name,), daemon=True)
+        d["thread"].start()
+        return d
+
+
+def download_bytes(name):
+    root = os.path.join(CACHE, "models", MODELS[name]["key"])
+    return sum(
+        os.path.getsize(f)
+        for f in glob.glob(os.path.join(root, "**", "*.incomplete"), recursive=True)
+        + glob.glob(os.path.join(root, ".cache", "**", "*.incomplete"), recursive=True)
+        if os.path.exists(f)
+    )
+
+
+# ── samples for the gallery ──────────────────────────────────────────────────
+
+def load_samples():
+    items = []
+    for label, repo in (("Z-Image-Turbo", "infosave/Z-Image-Turbo-cmf"), ("Z-Image", "infosave/Z-Image-cmf")):
+        for i, prompt in enumerate(SAMPLE_PROMPTS, 1):
+            cap = f"{label}: {prompt} (1024², seed 7)"
+            try:
+                p = hf_hub_download(repo, f"samples/{i}.png", local_dir=os.path.join(CACHE, "samples", label))
+                items.append((p, cap))
+            except Exception:
+                items.append((f"https://huggingface.co/{repo}/resolve/main/samples/{i}.png", cap))
+    return items
+
+
+# ── generation ─────────────────────────────────────────��─────────────────────
+
+ANSI = re.compile(r"\x1b\[[0-9;]*[A-Za-z]")
+RE_STEP = re.compile(r"^zimage: image (\d+) step (\d+)/(\d+) ([\d.]+)s")
+RE_TE = re.compile(r"^zimage: text-encode ([\d.]+)s")
+RE_STAGES = re.compile(r"^zimage stages: (.*)")
+
+
+def _reader(stream, sink):
+    buf = b""
+    while True:
+        ch = stream.read1(4096) if hasattr(stream, "read1") else stream.read(4096)
+        if not ch:
+            break
+        buf += ch
+        parts = re.split(rb"[\r\n]", buf)
+        buf = parts.pop()
+        for p in parts:
+            line = ANSI.sub("", p.decode("utf-8", "replace")).strip()
+            if line:
+                sink.append(line)
+    if buf.strip():
+        sink.append(ANSI.sub("", buf.decode("utf-8", "replace")).strip())
+
+
+def _status(title, lines):
+    return f"**{title}**\n\n" + "\n".join(f"- {l}" for l in lines)
+
+
+def on_model_change(name):
+    m = MODELS[name]
+    base = m["key"] == "base"
+    return (
+        gr.update(value=m["steps"]),
+        gr.update(value=m["cfg"], visible=base),
+        gr.update(visible=base),
+    )
+
+
+def estimate_text(name, size, steps, cfg):
+    m = MODELS[name]
+    w = h = int(size)
+    cfg = float(cfg) if m["key"] == "base" else 0.0
+    est = estimate_seconds(w, h, int(steps), cfg)
+    src = "measured on this machine" if SPEED.get("measured") else "first-run guess, refined after one image"
+    dl = ""
+    if not model_local(name):
+        dl = f" + a one-time {m['size_gb']:.1f} GB model download"
+    warn = ""
+    if est > MAX_JOB_S:
+        warn = f" — over this Space's {fmt_dur(MAX_JOB_S)} limit: use Turbo, 256², or fewer steps"
+    return f"Estimated time on {DEVICE_LABEL}: **~{fmt_dur(est)}**{dl} ({src}){warn}"
+
+
+def generate(prompt, negative, name, size, steps, seed, cfg, progress=gr.Progress()):
+    prompt = (prompt or "").strip()
+    if not prompt:
+        raise gr.Error("Enter a prompt.")
+    m = MODELS[name]
+    w = h = int(size)
+    steps = int(steps)
+    seed = int(seed)
+    base = m["key"] == "base"
+    cfg = float(cfg) if base else 0.0
+    est = estimate_seconds(w, h, steps, cfg)
+    if est > MAX_JOB_S:
+        raise gr.Error(
+            f"This job is estimated at {fmt_dur(est)} on {DEVICE_LABEL}, over the "
+            f"{fmt_dur(MAX_JOB_S)} limit. Use Z-Image-Turbo, 256², or fewer steps."
+        )
+
+    t_start = time.time()
+    yield None, _status("Preparing", ["fetching the cortiq engine"])
+    try:
+        exe = cortiq_bin()
+    except Exception as e:
+        raise gr.Error(f"Could not fetch the cortiq binary: {e}")
+
+    path = model_local(name)
+    if not path:
+        d = start_download(name)
+        total = m["size_gb"] * 1e9
+        while d["thread"].is_alive():
+            got = download_bytes(name)
+            el = time.time() - d["t0"]
+            rate = got / el if el > 5 and got else 0
+            eta = f", ~{fmt_dur((total - got) / rate)} left" if rate > 0 else ""
+            progress(min(got / total, 0.99), desc="downloading model")
+            yield None, _status(
+                f"Downloading {m['file']} (one time, {m['size_gb']:.1f} GB)",
+                [f"{got / 1e9:.2f} GB so far{eta}", "the image starts right after"],
+            )
+            time.sleep(2)
+        if d.get("error"):
+            raise gr.Error(f"Model download failed: {d['error']}")
+        path = model_local(name) or d["path"]
+
+    out = os.path.join(OUT_DIR, f"{uuid.uuid4().hex}.png")
+    cmd = [exe, "imagine", path, "--prompt", prompt, "--width", str(w), "--height", str(h),
+           "--steps", str(steps), "--seed", str(seed), "--out", out]
+    if base:
+        cmd += ["--cfg", f"{cfg:g}"]
+        if cfg > 0:
+            cmd += ["--negative-prompt", (negative or "").strip()]
+    env = dict(os.environ, CMF_ZIMAGE_PROF="1", XDG_RUNTIME_DIR=os.environ.get("XDG_RUNTIME_DIR", "/tmp"))
+    if DEVICE == "cpu":
+        env["CMF_GPU"] = "0"
+
+    lines = []
+    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env)
+    reader = threading.Thread(target=_reader, args=(proc.stdout, lines), daemon=True)
+    reader.start()
+    t0 = time.time()
+    hard_limit = max(MAX_JOB_S * 1.5, 600) if MAX_JOB_S != float("inf") else None
+    try:
+        while proc.poll() is None:
+            el = time.time() - t0
+            if hard_limit and el > hard_limit:
+                proc.kill()
+                raise gr.Error(f"Stopped after {fmt_dur(el)}: over this Space's time limit.")
+            steps_done, step_times, te = 0, [], None
+            for l in lines:
+                s = RE_STEP.match(l)
+                if s:
+                    steps_done = int(s.group(2))
+                    step_times.append(float(s.group(4)))
+                t = RE_TE.match(l)
+                if t:
+                    te = float(t.group(1))
+            per_step = step_tflop(w, h, cfg) / SPEED["dit"]
+            if step_times:
+                per_step = sorted(step_times)[len(step_times) // 2]
+            vae_s = vae_tflop(w, h) / SPEED["vae"]
+            if steps_done == 0:
+                phase = "loading the model and encoding the prompt" if te is None else "preparing the transformer"
+                remaining = max(SPEED["overhead"] - el, 5) + steps * per_step + vae_s
+            elif steps_done < steps:
+                phase = f"denoising: step {steps_done}/{steps} ({per_step:.1f} s/step)"
+                remaining = (steps - steps_done) * per_step + vae_s
+            else:
+                phase = "decoding the image (VAE)"
+                remaining = vae_s
+            progress((steps_done + 0.5 * (te is not None)) / (steps + 1), desc=phase)
+            info = [phase, f"elapsed {fmt_dur(el)}, about {fmt_dur(remaining)} left",
+                    f"{w}×{h}, {steps} steps" + (f", CFG {cfg:g}" if cfg > 0 else "") + f", seed {seed}, {DEVICE_LABEL}"]
+            yield None, _status("Generating", info)
+            time.sleep(1.0)
+    finally:
+        if proc.poll() is None:
+            proc.kill()
+            proc.wait()
+    reader.join(timeout=5)
+    total = time.time() - t_start
+
+    if proc.returncode != 0 or not os.path.exists(out):
+        tail = "\n".join(lines[-12:])
+        raise gr.Error(f"cortiq exited with code {proc.returncode}:\n{tail}")
+
+    # refine the ETA model from what this machine actually did
+    step_times = [float(s.group(4)) for s in (RE_STEP.match(l) for l in lines) if s]
+    stages = next((s.group(1) for s in (RE_STAGES.match(l) for l in lines) if s), "")
+    if step_times:
+        med = sorted(step_times)[len(step_times) // 2]
+        run_s = time.time() - t0
+        overhead = max(run_s - sum(step_times) - vae_tflop(w, h) / SPEED["vae"], 1.0)
+        save_speed(step_tflop(w, h, cfg) / med, overhead)
+
+    img = Image.open(out)
+    img.load()
+    os.remove(out)
+    summary = [f"{w}×{h}, {steps} steps" + (f", CFG {cfg:g}" if cfg > 0 else "") + f", seed {seed}",
+               f"total {fmt_dur(total)} on {DEVICE_LABEL}"]
+    if stages:
+        summary.append("engine stages: " + stages)
+    yield img, _status("Done", summary)
+
+
+# ── UI ───────────────────────────────────────────────────────────────────────
+
+RUN_LOCALLY = f"""
+The same files run on your own machine with `cortiq` {CORTIQ_VERSION}, a single binary with no Python:
+NVIDIA GPUs through Vulkan (tensor cores), Apple silicon through Metal, and a CPU fallback everywhere.
+
+**1. Get cortiq** — prebuilt binaries on the [releases page]({GITHUB}/releases), or build it:
+
+```bash
+# Linux x86-64
+curl -L {CORTIQ_URL} | tar xz
+# or, with Rust installed (macOS, Linux, Windows)
+cargo install cortiq-cli
+```
+
+**2. Download a model** (10.5 GB each):
+
+```bash
+hf download infosave/Z-Image-Turbo-cmf z-image-turbo.cmf --local-dir .
+hf download infosave/Z-Image-cmf z-image.cmf --local-dir .
+```
+
+**3. Generate:**
+
+```bash
+./cortiq imagine z-image-turbo.cmf --prompt "A cat sitting on a windowsill at sunset, photorealistic"
+./cortiq imagine z-image.cmf --prompt "..." --negative-prompt "blurry, low quality" --steps 28 --cfg 4
+```
+
+No flags are needed: each file stores its recipe (Turbo: 1024², 8 steps, no CFG; base: 1024², 28 steps, CFG 4).
+Useful options: `--width`/`--height` (multiples of 16), `--steps`, `--seed`, `--num-images N`, `--out file.png`.
+`CMF_ZIMAGE_PROF=1` prints stage times; `CMF_GPU=0` forces the CPU. On a headless Linux box set `XDG_RUNTIME_DIR=/tmp`.
+
+**Measured speed** (cortiq 0.7.5, one image per process, no flags):
+
+| hardware | model | 512×512 | 1024×1024 |
+|---|---|---:|---:|
+| RTX 3090 (Vulkan) | Turbo, 8 steps | 4.6 s | 11.4 s |
+| RTX 3090 (Vulkan) | base, 28 steps + CFG | 16.2 s | 60 s |
+| Mac mini M4 24 GB (Metal) | Turbo, 8 steps | 30 s | 160 s |
+| Mac mini M4 24 GB (Metal) | base, 28 steps + CFG | 3.9 min | 21 min |
+
+About 8 GB of memory on the Mac; 14–15 GB of VRAM peak on the 3090 (16 GB cards fit).
+On a CPU the transformer costs about 3.4 TFLOP per step at 256² and 13.6 at 512², so expect minutes per image.
+
+Models: [Z-Image-Turbo-cmf](https://huggingface.co/infosave/Z-Image-Turbo-cmf) ·
+[Z-Image-cmf](https://huggingface.co/infosave/Z-Image-cmf) · engine: [{GITHUB}]({GITHUB})
+"""
+
+CSS = """
+#title h1 {margin-bottom: 0}
+.gradio-container {max-width: 1180px !important; margin: 0 auto}
+"""
+
+
+def build():
+    samples = load_samples()
+    default_model = MODEL_NAMES[0]
+    default_size = "256" if DEVICE == "cpu" else "512"
+    header = (
+        "# Z-Image · CMF\n"
+        "Text-to-image with Tongyi-MAI's Z-Image and Z-Image-Turbo (6B DiT + Qwen3-4B text encoder), "
+        f"run by [cortiq]({GITHUB}), a Rust engine with no Python ML stack. "
+        "Models: [Z-Image-Turbo-cmf](https://huggingface.co/infosave/Z-Image-Turbo-cmf) · "
+        "[Z-Image-cmf](https://huggingface.co/infosave/Z-Image-cmf).\n\n"
+        f"This Space runs on **{DEVICE_LABEL}**"
+        + (f", {RAM_GB:.0f} GB RAM" if RAM_GB else "")
+        + ". "
+        + (
+            "The CPU is slow for a 6B image model: a 256² Turbo image takes minutes, and jobs run one at a time "
+            "in a queue. The Gallery tab shows what the models do at 1024² on a GPU."
+            if DEVICE == "cpu"
+            else "Jobs run one at a time in a queue."
+        )
+    )
+    with gr.Blocks(title="Z-Image CMF") as demo:
+        gr.Markdown(header, elem_id="title")
+        with gr.Tabs():
+            with gr.Tab("Generate"):
+                with gr.Row():
+                    with gr.Column(scale=5):
+                        prompt = gr.Textbox(label="Prompt", lines=3, value=SAMPLE_PROMPTS[0])
+                        negative = gr.Textbox(label="Negative prompt (base model only)",
+                                              value="blurry, low quality", visible=False)
+                        model = gr.Dropdown(MODEL_NAMES, value=default_model, label="Model")
+                        size = gr.Radio(["256", "384", "512"], value=default_size,
+                                        label="Size (square, pixels)")
+                        with gr.Row():
+                            steps = gr.Slider(1, 50, value=8, step=1, label="Steps")
+                            seed = gr.Number(value=7, precision=0, label="Seed")
+                        cfg = gr.Slider(0, 10, value=4.0, step=0.5, label="CFG (base model)", visible=False)
+                        eta = gr.Markdown(estimate_text(default_model, default_size, 8, 0))
+                        base_note = gr.Markdown(
+                            "The base model runs 28 steps with CFG (two transformer passes per step): "
+                            "about 7× the Turbo cost, which is very slow on a CPU. Lower the steps for a draft.",
+                            visible=False,
+                        )
+                        btn = gr.Button("Generate", variant="primary")
+                    with gr.Column(scale=6):
+                        image = gr.Image(label="Result", type="pil", format="png", height=560)
+                        status = gr.Markdown("Ready. " + (
+                            "The first run also downloads the model (10.5 GB)." if not model_local(default_model) else ""))
+                gr.Examples([[p] for p in SAMPLE_PROMPTS], inputs=[prompt], label="Sample prompts")
+
+                model.change(on_model_change, [model], [steps, cfg, negative]).then(
+                    lambda n: gr.update(visible=MODELS[n]["key"] == "base"), [model], [base_note])
+                for c in (model, size, steps, cfg):
+                    c.change(estimate_text, [model, size, steps, cfg], [eta], queue=False)
+                btn.click(generate, [prompt, negative, model, size, steps, seed, cfg], [image, status],
+                          concurrency_limit=1)
+            with gr.Tab("Gallery"):
+                gr.Markdown("1024×1024, seed 7, each file's default recipe (Turbo: 8 steps; base: 28 steps, CFG 4), "
+                            "generated by cortiq on a GPU.")
+                gr.Gallery(samples, columns=4, height="auto", object_fit="contain", label="Samples",
+                           show_label=False)
+            with gr.Tab("Run it locally"):
+                gr.Markdown(RUN_LOCALLY)
+    return demo
+
+
+demo = build()
+demo.queue(default_concurrency_limit=1, max_size=16)
+
+if __name__ == "__main__":
+    demo.launch(
+        server_name=os.environ.get("GRADIO_SERVER_NAME", "0.0.0.0"),
+        server_port=int(os.environ.get("PORT", os.environ.get("GRADIO_SERVER_PORT", "7860"))),
+        allowed_paths=[CACHE],
+        css=CSS,
+        theme=gr.themes.Soft(),
+    )

packages.txt

@@ -0,0 +1,5 @@
+libvulkan1
+libglvnd0
+libegl1
+libgl1
+libglx0

requirements.txt

@@ -0,0 +1,3 @@
+gradio==6.28.0
+huggingface_hub>=1.0
+pillow