Use ComfyUI native Redcraft T2I

app.py

@@ -1,455 +1,261 @@
-import glob
+import json
 import os
 import random
 import subprocess
 import sys
-import spaces
-import torch
-import gradio as gr
-from huggingface_hub import hf_hub_download, login
+import threading
+import time
+import uuid
+from pathlib import Path
 
-if os.environ.get("HF_TOKEN"):
-    login(token=os.environ["HF_TOKEN"])
+import gradio as gr
+import requests
+import spaces
+from huggingface_hub import hf_hub_download
+from PIL import Image
 
-from diffusers import Krea2Pipeline
 
-DTYPE = torch.bfloat16
 MODEL_REPO = "Daankular/redcraft-krea2-fp8"
 MODEL_FILE = "redcraftKREA2RedMix_krea2Edition.safetensors"
-AOTI_REPO = "multimodalart/krea2-aoti-kernels"
-AOTI_FILE = "Krea2TransformerBlock-lora-r64/package.pt2"
+COMFY_REPO = "https://github.com/comfyanonymous/ComfyUI.git"
+COMFY_DIR = Path(os.environ.get("COMFYUI_DIR", "/tmp/ComfyUI"))
+COMFY_HOST = "127.0.0.1"
+COMFY_PORT = int(os.environ.get("COMFYUI_PORT", "8188"))
+COMFY_URL = f"http://{COMFY_HOST}:{COMFY_PORT}"
 MAX_SEED = 2**31 - 1
 
-checkpoint_path = hf_hub_download(
-    repo_id=MODEL_REPO,
-    filename=MODEL_FILE,
-    token=os.environ.get("HF_TOKEN"),
-)
-pipe_redcraft = Krea2Pipeline.from_single_file(checkpoint_path, torch_dtype=DTYPE)
-pipe_redcraft.to("cuda")
-
-
-
-def _load_aoti():
-    # The compiled Krea2TransformerBlock kernels are public and separate from
-    # the checkpoint weights. If they cannot be loaded, the Space falls back to
-    # eager mode.
-    from spaces.zero.torch.aoti import LazyAOTIModel
-
-    pt2 = hf_hub_download(
-        repo_id=AOTI_REPO,
-        filename=AOTI_FILE,
-        repo_type="dataset",
-    )
-    aoti_model = LazyAOTIModel(pt2)
-    for block in pipe_redcraft.transformer.modules():
-        if block.__class__.__name__ == "Krea2TransformerBlock":
-            spaces.aoti_patch(block, aoti_model)
-
-
-try:
-    _load_aoti()
-    print("AoTI blocks loaded.")
-except Exception as e:
-    print(f"AoTI load skipped ({e}); running eager.")
-
-PIPES = {"Redcraft": pipe_redcraft}
-DEFAULTS = {
-    "Redcraft": {"steps": 8, "guidance": 0.0},
-}
-
-# Resolution presets. The model renders up to 2K, but the compiled transformer
-# block can exceed this Space's GPU memory above 1024, so 1024 is the default
-# and larger sizes are opt-in (see the OOM guard in generate).
-RESOLUTIONS = {
-    "Square · 1024": (1024, 1024),
-    "Portrait · 1024": (832, 1216),
-    "Landscape · 1024": (1216, 832),
-    "Square · 2K": (2048, 2048),
-}
-
-PROMPT_TIPS = """\
-Krea 2 is tuned for natural language. Describe the image the way you would describe it to a person.
-
-- Write in full sentences or rich phrases. Longer, more specific prompts give the best results, but short prompts work too.
-- Name the things that matter: subject, setting, lighting, color, framing, medium, and mood.
-- To render text in the image, wrap the words in quotes, for example: a storefront window with a neon sign that reads "open late".
-- The model can render up to 2K, but very high resolutions may run out of GPU memory on this Space. 1024 is the reliable default.
-
-This Space uses the Redcraft checkpoint from [Daankular/redcraft-krea2-fp8](https://huggingface.co/Daankular/redcraft-krea2-fp8).
-"""
+_comfy_lock = threading.Lock()
+_comfy_process = None
+
+
+def _run(cmd, cwd=None):
+    print("[setup]", " ".join(map(str, cmd)), flush=True)
+    subprocess.check_call(cmd, cwd=str(cwd) if cwd else None)
+
+
+def _wait_for_comfy(timeout=180):
+    deadline = time.time() + timeout
+    last_error = None
+    while time.time() < deadline:
+        try:
+            response = requests.get(f"{COMFY_URL}/system_stats", timeout=2)
+            if response.ok:
+                return
+        except Exception as exc:
+            last_error = exc
+        time.sleep(1)
+    raise RuntimeError(f"ComfyUI did not start in time: {last_error}")
+
+
+def _ensure_comfyui():
+    global _comfy_process
+
+    with _comfy_lock:
+        if _comfy_process is not None and _comfy_process.poll() is None:
+            return
+        try:
+            response = requests.get(f"{COMFY_URL}/system_stats", timeout=2)
+            if response.ok:
+                return
+        except Exception:
+            pass
+
+        if not COMFY_DIR.exists():
+            _run(["git", "clone", "--depth", "1", COMFY_REPO, str(COMFY_DIR)])
+
+        marker = COMFY_DIR / ".requirements-installed"
+        if not marker.exists():
+            _run([sys.executable, "-m", "pip", "install", "-r", "requirements.txt"], cwd=COMFY_DIR)
+            marker.write_text("ok", encoding="utf-8")
+
+        checkpoint_dir = COMFY_DIR / "models" / "checkpoints"
+        checkpoint_dir.mkdir(parents=True, exist_ok=True)
+        hf_hub_download(
+            repo_id=MODEL_REPO,
+            filename=MODEL_FILE,
+            local_dir=str(checkpoint_dir),
+            token=os.environ.get("HF_TOKEN"),
+        )
 
-# Drawn from the official Krea 2 prompt guide. These demonstrate the
-# detailed, natural-language style the model rewards.
-EXAMPLE_PROMPTS = [
-    ["immense rocket launch exhaust as seen from extremely close up"],
-    [
-        "3D rendered matte black designer toy figure, stylized round anthropomorphic shape, "
-        "backward black baseball cap, oversized gold-rimmed aviator sunglasses, white traditional "
-        "line-art tattoos of tiger and bird on torso, black studded belt with gold buckle, smooth "
-        "vinyl texture, studio lighting, solid vibrant blue background, high contrast minimal composition"
-    ],
-    [
-        "A tiny, russet-brown harvest mouse clings to a slender diagonal branch amid vibrant green "
-        "lobed leaves and small round buds. The mouse has soft textured fur, glossy black eyes, a pink "
-        "nose, fine whiskers, and delicate pink paws firmly gripping the wood. In this macro photograph, "
-        "an extremely shallow depth of field sharply focuses on the animal's face. The deep green "
-        "background dissolves into a smooth, creamy bokeh, illuminated by soft, diffused natural lighting "
-        "that highlights the intricate details of the fur and foliage."
-    ],
-    [
-        "high-fashion editorial portrait of a young East Asian woman, short choppy platinum blonde bob "
-        "with heavy bangs, looking over her bare shoulder to the right, lips playfully pursed, wearing a "
-        "structured black top with an architectural protruding bust detail and thin straps, delicate gold "
-        "hoop earrings, arm bent with hand resting on hip, warm skin tones, solid striking crimson red "
-        "background, soft directional studio lighting, cinematic color palette, medium close-up shot"
-    ],
-    [
-        "A minimalist flat-color illustration of a person wading through expansive shallow ocean waves "
-        "beneath a pale peach sky. The dark-skinned figure, wearing an orange swim cap, light blue top, and "
-        "bright green shorts, steps carefully through knee-deep water. The ocean is rendered in muted mint "
-        "green with delicate, thin black linework detailing the continuous ripples and gentle whitecaps. "
-        "Soft pinkish-peach reflections echo the sky on the water's surface. The high-angle wide perspective "
-        "emphasizes the vast negative space of the water, utilizing a clean ligne claire drawing aesthetic "
-        "with a subtle paper texture."
-    ],
-    [
-        "A surreal retro-futuristic space scene features liquid chrome forming an abstract face merging "
-        "with a glowing planetary horizon. The foreground is dominated by swirling, highly reflective "
-        "metallic fluid that distorts into a stylized, melting facial profile with deep shadows and bright "
-        "silver highlights. This undulating chrome form rests against the curved, atmospheric edge of a "
-        "massive planet bathed in a soft electric blue and purple glow. Set against a deep black starfield, "
-        "the artwork employs a vintage 1980s airbrush aesthetic with smooth gradients, ethereal lighting, "
-        "and high-contrast metallic rendering."
-    ],
-    [
-        "Stylized digital painting of a menacing jester figure rendered with bold, expressive brushstrokes "
-        "and a vibrant, almost psychedelic color palette against a pitch-black background. Dynamic low-angle "
-        "perspective forces a dramatic, imposing composition as the character leans forward, one leg raised "
-        "high. The jester wears a classic multi-pointed hat with bells, a ruffled collar, and striped tights "
-        "in alternating shades of purple, blue, and chartreuse. The figure's face is a smooth, faceless, pale "
-        "mauve mask with a single glowing white point of light at the center, and it grips a massive ornate "
-        "sword with a glowing ethereal white blade. Theatrical lighting, dark fantasy concept-art aesthetic."
-    ],
-    [
-        "A close-up portrait of a young East Asian woman with straight black hair, loose strands sweeping "
-        "across her fair skin, and an intense gaze. She wears a light grey collared shirt with a black tie. "
-        "A vibrant bouquet of pink and orange lilies with lush green leaves sits in the blurred right "
-        "foreground. The background is a solid, striking crimson red. Soft, directional studio lighting "
-        "highlights her facial features, creating a high-contrast composition with a shallow depth of field."
-    ],
-]
-
-# Official sample renders for the prompts above, in the same order. Drop the
-# matching PNGs into assets/samples/ and the gallery shows them; clicking a
-# thumbnail loads its prompt. Filenames follow the Krea 2 prompt guide. If the
-# files are absent, the UI falls back to the text example prompts below.
-SAMPLE_DIR = os.path.join(os.path.dirname(__file__), "assets", "samples")
-SAMPLE_FILES = ["takeoff.png", "3d.png", "mouse.png", "red.png", "beach.png", "future.png", "jester.png", "flowers.png"]
-SAMPLE_LABELS = [
-    "Rocket exhaust",
-    "Designer toy",
-    "Harvest mouse",
-    "Editorial portrait",
-    "Ligne claire beach",
-    "Liquid chrome",
-    "Jester",
-    "Crimson portrait",
-]
-
-_gallery = [
-    (os.path.join(SAMPLE_DIR, fname), label, prompt[0])
-    for fname, label, prompt in zip(SAMPLE_FILES, SAMPLE_LABELS, EXAMPLE_PROMPTS)
-    if os.path.exists(os.path.join(SAMPLE_DIR, fname))
-]
-GALLERY_ITEMS = [(path, label) for path, label, _ in _gallery]
-GALLERY_PROMPTS = [prompt for _, _, prompt in _gallery]
-
-PLACEHOLDER = (
-    "Describe your image in natural language. e.g. a russet harvest mouse clinging to a "
-    'branch, macro photograph, shallow depth of field, creamy green bokeh, soft natural light. '
-    'Wrap words in "quotes" to render them as text.'
-)
-
-
-def _duration(prompt, negative_prompt, model, steps, guidance, width, height, seed, randomize, progress=None):
-    # Scale the GPU reservation by step count and pixel area so larger renders
-    # are not killed before they finish.
+        cmd = [
+            sys.executable,
+            "main.py",
+            "--listen",
+            COMFY_HOST,
+            "--port",
+            str(COMFY_PORT),
+            "--disable-auto-launch",
+        ]
+        _comfy_process = subprocess.Popen(cmd, cwd=str(COMFY_DIR))
+        _wait_for_comfy()
+
+
+def _build_workflow(prompt, negative_prompt, width, height, steps, cfg, seed, sampler, scheduler):
+    workflow = {
+        "1": {
+            "class_type": "CheckpointLoaderSimple",
+            "inputs": {"ckpt_name": MODEL_FILE},
+        },
+        "2": {
+            "class_type": "CLIPTextEncode",
+            "inputs": {"text": prompt, "clip": ["1", 1]},
+        },
+        "4": {
+            "class_type": "EmptyLatentImage",
+            "inputs": {"width": int(width), "height": int(height), "batch_size": 1},
+        },
+        "5": {
+            "class_type": "KSampler",
+            "inputs": {
+                "seed": int(seed),
+                "steps": int(steps),
+                "cfg": float(cfg),
+                "sampler_name": sampler,
+                "scheduler": scheduler,
+                "denoise": 1.0,
+                "model": ["1", 0],
+                "positive": ["2", 0],
+                "negative": ["3", 0],
+                "latent_image": ["4", 0],
+            },
+        },
+        "6": {
+            "class_type": "VAEDecode",
+            "inputs": {"samples": ["5", 0], "vae": ["1", 2]},
+        },
+        "7": {
+            "class_type": "SaveImage",
+            "inputs": {"filename_prefix": "redcraft", "images": ["6", 0]},
+        },
+    }
+
+    if negative_prompt and negative_prompt.strip():
+        workflow["3"] = {
+            "class_type": "CLIPTextEncode",
+            "inputs": {"text": negative_prompt, "clip": ["1", 1]},
+        }
+    else:
+        workflow["3"] = {
+            "class_type": "ConditioningZeroOut",
+            "inputs": {"conditioning": ["2", 0]},
+        }
+    return workflow
+
+
+def _queue_prompt(workflow):
+    payload = {"prompt": workflow, "client_id": str(uuid.uuid4())}
+    response = requests.post(f"{COMFY_URL}/prompt", json=payload, timeout=30)
+    if not response.ok:
+        raise RuntimeError(f"ComfyUI prompt error {response.status_code}: {response.text[:1000]}")
+    return response.json()["prompt_id"]
+
+
+def _wait_for_history(prompt_id, timeout=900):
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        response = requests.get(f"{COMFY_URL}/history/{prompt_id}", timeout=30)
+        response.raise_for_status()
+        history = response.json()
+        if prompt_id in history:
+            item = history[prompt_id]
+            status = item.get("status", {})
+            if status.get("completed"):
+                return item
+            messages = status.get("messages") or []
+            for message in messages:
+                if isinstance(message, list) and message and message[0] == "execution_error":
+                    raise RuntimeError(json.dumps(message[1], indent=2)[:2000])
+        time.sleep(1)
+    raise RuntimeError("Timed out waiting for ComfyUI generation.")
+
+
+def _load_output_image(history_item):
+    outputs = history_item.get("outputs", {})
+    for output in outputs.values():
+        for image in output.get("images", []):
+            params = {
+                "filename": image["filename"],
+                "subfolder": image.get("subfolder", ""),
+                "type": image.get("type", "output"),
+            }
+            response = requests.get(f"{COMFY_URL}/view", params=params, timeout=120)
+            response.raise_for_status()
+            temp_path = Path("/tmp") / f"{uuid.uuid4().hex}.png"
+            temp_path.write_bytes(response.content)
+            return Image.open(temp_path).convert("RGB")
+    raise RuntimeError("ComfyUI completed without returning an image.")
+
+
+def _duration(prompt, negative_prompt, width, height, steps, cfg, seed, randomize_seed, sampler, scheduler):
     megapixels = max(1.0, (int(width) * int(height)) / (1024 * 1024))
-    return int(int(steps) * 2 * megapixels + 25)
+    return int(900 + int(steps) * 8 * megapixels)
 
 
-@spaces.GPU(duration=_duration, size="xlarge")
+@spaces.GPU(duration=_duration)
 def generate(
     prompt,
     negative_prompt="",
-    model="Redcraft",
-    steps=8,
-    guidance=0,
     width=1024,
     height=1024,
-    seed=42,
-    randomize=False,
-    progress=gr.Progress(track_tqdm=True),
+    steps=10,
+    cfg=1.0,
+    seed=0,
+    randomize_seed=True,
+    sampler="er_sde",
+    scheduler="simple",
 ):
     if not prompt or not prompt.strip():
-        raise gr.Error("Enter a prompt to generate an image.")
-    if randomize:
+        raise gr.Error("Enter a prompt.")
+    if randomize_seed:
         seed = random.randint(0, MAX_SEED)
-    seed = int(seed)
-    generator = torch.Generator("cuda").manual_seed(seed)
-    pipe = PIPES[model]
+
     try:
-        image = pipe(
-            prompt=prompt,
-            negative_prompt=(negative_prompt or None) if guidance > 0 else None,
-            height=int(height),
-            width=int(width),
-            num_inference_steps=int(steps),
-            guidance_scale=float(guidance),
-            generator=generator,
-        ).images[0]
-    except RuntimeError as exc:
-        # At high resolution the compiled transformer block can exhaust GPU
-        # memory, which surfaces as a CUDA allocation / AOTI runtime error.
-        # Recover the worker and tell the user how to fix it.
-        torch.cuda.empty_cache()
-        raise gr.Error(
-            f"Generation failed at {int(width)}x{int(height)}. This is usually the GPU running "
-            "out of memory at high resolution. Try 1024x1024 or a smaller size."
-        ) from exc
-    return image, seed
-
-
-def on_model_change(model):
-    d = DEFAULTS[model]
-    return (
-        gr.update(value=d["steps"]),
-        gr.update(value=d["guidance"]),
-        gr.update(interactive=d["guidance"] > 0),
-    )
-
-
-def on_resolution_change(label):
-    w, h = RESOLUTIONS[label]
-    return gr.update(value=w), gr.update(value=h)
-
-
-# Krea brand identity: neutral grayscale foundation with a single blue action
-# accent (krea.ai/press). Dark surfaces, mono utility type, accent reserved for
-# the primary action and focus states.
-KREA_ACCENT = "#2b5cff"
-
-theme = gr.themes.Base(
-    primary_hue=gr.themes.colors.blue,
-    neutral_hue=gr.themes.colors.neutral,
-    font=[gr.themes.GoogleFont("Inter"), "ui-sans-serif", "system-ui", "sans-serif"],
-    font_mono=[gr.themes.GoogleFont("JetBrains Mono"), "ui-monospace", "monospace"],
-).set(
-    body_background_fill="#000000",
-    body_background_fill_dark="#000000",
-    body_text_color="#f5f5f5",
-    background_fill_primary="#0d0d0d",
-    background_fill_secondary="#0d0d0d",
-    block_background_fill="#0d0d0d",
-    block_border_color="#262626",
-    block_border_width="1px",
-    block_label_background_fill="#0d0d0d",
-    block_label_text_color="#737373",
-    block_title_text_color="#d4d4d5",
-    border_color_primary="#262626",
-    input_background_fill="#000000",
-    input_border_color="#262626",
-    input_border_color_focus=KREA_ACCENT,
-    button_primary_background_fill=KREA_ACCENT,
-    button_primary_background_fill_hover="#1f4fff",
-    button_primary_text_color="#ffffff",
-    button_primary_border_color=KREA_ACCENT,
-    button_secondary_background_fill="#171717",
-    button_secondary_background_fill_hover="#262626",
-    button_secondary_text_color="#f5f5f5",
-    button_secondary_border_color="#262626",
-    slider_color=KREA_ACCENT,
-)
+        _ensure_comfyui()
+        workflow = _build_workflow(prompt, negative_prompt, width, height, steps, cfg, seed, sampler, scheduler)
+        prompt_id = _queue_prompt(workflow)
+        history_item = _wait_for_history(prompt_id)
+        return _load_output_image(history_item), seed
+    except Exception as exc:
+        raise gr.Error(str(exc)) from exc
+
 
 CSS = """
-.gradio-container { background: #000 !important; }
-#page { max-width: 1120px; margin: 0 auto; padding: 4px 8px 32px; }
-
-#krea-header {
-  padding: 32px 6px 22px;
-  border-bottom: 1px solid #1a1a1a;
-  margin-bottom: 22px;
-}
-#krea-header .eyebrow {
-  font-family: 'JetBrains Mono', ui-monospace, monospace;
-  font-size: 11px;
-  letter-spacing: 0.24em;
-  text-transform: uppercase;
-  color: #737373;
-}
-#krea-header h1 {
-  font-size: 42px;
-  font-weight: 600;
-  letter-spacing: -0.025em;
-  line-height: 1.05;
-  margin: 10px 0 6px;
-  color: #fff;
-}
-#krea-header .subtitle {
-  font-size: 15px;
-  line-height: 1.5;
-  color: #a3a3a3;
-  margin: 0;
-  max-width: 60ch;
-}
-#krea-header .meta {
-  margin-top: 18px;
-  display: flex;
-  justify-content: space-between;
-  align-items: center;
-  flex-wrap: wrap;
-  gap: 12px;
-}
-#krea-header .badges { display: flex; gap: 8px; }
-#krea-header .badge {
-  font-family: 'JetBrains Mono', ui-monospace, monospace;
-  font-size: 10px;
-  letter-spacing: 0.12em;
-  text-transform: uppercase;
-  color: #d4d4d5;
-  border: 1px solid #262626;
-  border-radius: 999px;
-  padding: 4px 10px;
-}
-#krea-header .links { display: flex; gap: 16px; }
-#krea-header .links a {
-  font-family: 'JetBrains Mono', ui-monospace, monospace;
-  font-size: 11px;
-  letter-spacing: 0.08em;
-  text-transform: uppercase;
-  color: #737373;
-  text-decoration: none;
-  transition: color 0.15s ease;
-}
-#krea-header .links a:hover { color: #f5f5f5; }
-
-#generate-btn { font-weight: 600; letter-spacing: 0.01em; }
-
-#result-image { min-height: 420px; border-radius: 10px; overflow: hidden; }
-
-/* Inline code chips legible on the dark theme (e.g. the expansion.txt mention in tips). */
-.gradio-container code,
-.gradio-container .prose code {
-  background: #171717 !important;
-  color: #d4d4d5 !important;
-  border: 1px solid #262626 !important;
-  border-radius: 5px !important;
-  padding: 2px 7px !important;
-  font-family: 'JetBrains Mono', ui-monospace, monospace !important;
-  font-size: 0.85em !important;
-}
-
-footer { display: none !important; }
-.gradio-container .prose a { color: """ + KREA_ACCENT + """; }
+.gradio-container { max-width: 1120px !important; margin: 0 auto !important; }
+#result-image { min-height: 520px; }
 """
 
-with gr.Blocks(title="Krea 2") as demo:
-    with gr.Column(elem_id="page"):
-        gr.HTML(
-            """
-            <header id="krea-header">
-              <div class="eyebrow">KREA · TEXT-TO-IMAGE</div>
-              <h1>Krea 2</h1>
-              <p class="subtitle">Generate images from natural language with the Redcraft Krea 2 checkpoint.</p>
-              <div class="meta">
-                <div class="badges">
-                  <span class="badge">Redcraft</span>
-                  <span class="badge">Public AoTI kernels</span>
-                </div>
-                <div class="links">
-                  <a href="https://www.krea.ai/blog/krea-2-technical-report" target="_blank" rel="noopener">Technical report ↗</a>
-                  <a href="https://github.com/krea-ai/krea-2" target="_blank" rel="noopener">GitHub ↗</a>
-                </div>
-              </div>
-            </header>
-            """
-        )
-
-        with gr.Row(equal_height=False):
-            with gr.Column(scale=5, elem_classes="panel"):
-                prompt = gr.Textbox(
-                    label="Prompt",
-                    lines=4,
-                    placeholder=PLACEHOLDER,
-                    show_label=True,
-                    autofocus=True,
+with gr.Blocks(title="Redcraft Krea2", css=CSS) as demo:
+    gr.Markdown("# Redcraft Krea2")
+    gr.Markdown("Text-to-image generation through ComfyUI-native checkpoint loading.")
+
+    with gr.Row():
+        with gr.Column(scale=5):
+            prompt = gr.Textbox(label="Prompt", lines=5, placeholder="Describe the image to generate.")
+            negative_prompt = gr.Textbox(label="Negative prompt", lines=2, value="")
+            with gr.Row():
+                width = gr.Slider(512, 1536, value=1024, step=64, label="Width")
+                height = gr.Slider(512, 1536, value=1024, step=64, label="Height")
+            with gr.Row():
+                steps = gr.Slider(1, 30, value=10, step=1, label="Steps")
+                cfg = gr.Slider(0.0, 8.0, value=1.0, step=0.1, label="CFG")
+            with gr.Row():
+                seed = gr.Slider(0, MAX_SEED, value=0, step=1, label="Seed")
+                randomize_seed = gr.Checkbox(value=True, label="Randomize seed")
+            with gr.Accordion("Sampler", open=False):
+                sampler = gr.Dropdown(
+                    ["er_sde", "euler", "euler_ancestral", "dpmpp_2m", "dpmpp_sde"],
+                    value="er_sde",
+                    label="Sampler",
                 )
-                model = gr.Radio(["Redcraft"], value="Redcraft", label="Model")
-                run = gr.Button("Generate", variant="primary", elem_id="generate-btn")
-
-                with gr.Accordion("Prompting tips", open=False):
-                    gr.Markdown(PROMPT_TIPS)
+                scheduler = gr.Dropdown(["simple", "normal", "karras", "exponential"], value="simple", label="Scheduler")
+            run = gr.Button("Generate", variant="primary")
+        with gr.Column(scale=6):
+            output = gr.Image(label="Result", format="png", elem_id="result-image")
 
-                resolution = gr.Radio(
-                    list(RESOLUTIONS.keys()),
-                    value="Square · 1024",
-                    label="Resolution",
-                )
-
-                with gr.Accordion("Advanced", open=False):
-                    negative_prompt = gr.Textbox(
-                        label="Negative prompt",
-                        lines=1,
-                        interactive=False,
-                        info="Enabled when guidance is above 0.",
-                    )
-                    steps = gr.Slider(1, 50, value=8, step=1, label="Steps")
-                    guidance = gr.Slider(0.0, 10.0, value=0.0, step=0.1, label="Guidance scale")
-                    with gr.Row():
-                        width = gr.Slider(512, 2048, value=1024, step=16, label="Width")
-                        height = gr.Slider(512, 2048, value=1024, step=16, label="Height")
-                    with gr.Row():
-                        seed = gr.Slider(0, MAX_SEED, value=0, step=1, label="Seed")
-                        randomize = gr.Checkbox(value=True, label="Randomize seed")
-
-            with gr.Column(scale=6, elem_classes="panel"):
-                output = gr.Image(label="Result", format="png", elem_id="result-image")
-
-        if GALLERY_ITEMS:
-            gallery = gr.Gallery(
-                value=GALLERY_ITEMS,
-                label="Example prompts",
-                columns=4,
-                height="auto",
-                object_fit="cover",
-                allow_preview=False,
-                elem_id="examples-gallery",
-            )
-
-            def use_example(evt: gr.SelectData):
-                # Clicking a sample loads its prompt into the box, ready to run.
-                return GALLERY_PROMPTS[evt.index]
-
-            gallery.select(use_example, None, prompt)
-        else:
-            # No bundled sample images present; show the prompts as text.
-            gr.Examples(
-                fn=generate,
-                examples=EXAMPLE_PROMPTS,
-                inputs=[prompt],
-                outputs=[output, seed],
-                cache_examples=True,
-                cache_mode="lazy",
-                label="Example prompts",
-                examples_per_page=4,
-            )
-
-    model.change(on_model_change, model, [steps, guidance, negative_prompt])
-    resolution.change(on_resolution_change, resolution, [width, height])
-
-    inputs = [prompt, negative_prompt, model, steps, guidance, width, height, seed, randomize]
+    inputs = [prompt, negative_prompt, width, height, steps, cfg, seed, randomize_seed, sampler, scheduler]
     run.click(generate, inputs, [output, seed])
     prompt.submit(generate, inputs, [output, seed])
 
-demo.launch(theme=theme, css=CSS)
+
+if __name__ == "__main__":
+    demo.queue().launch()