switch to Docker with compiled sd.cpp

Dockerfile

@@ -0,0 +1,24 @@
+FROM python:3.11-slim
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    git cmake build-essential libopenblas-dev && \
+    rm -rf /var/lib/apt/lists/*
+
+# Build stable-diffusion.cpp from source (latest, with Anima support)
+RUN git clone --depth 1 https://github.com/leejet/stable-diffusion.cpp /tmp/sdcpp && \
+    cd /tmp/sdcpp && mkdir build && cd build && \
+    cmake .. -DCMAKE_BUILD_TYPE=Release \
+             -DSD_BUILD_SHARED_LIBS=OFF \
+             -DGGML_OPENBLAS=ON && \
+    cmake --build . --config Release -j2 && \
+    cp bin/sd-cli /usr/local/bin/sd-cli && \
+    rm -rf /tmp/sdcpp
+
+RUN pip install --no-cache-dir gradio Pillow huggingface-hub
+
+WORKDIR /app
+COPY app.py .
+COPY README.md .
+
+EXPOSE 7860
+CMD ["python", "app.py"]

README.md

@@ -1,18 +1,24 @@
 ---
-title: Anima 2B Image Generation (CPU)
-emoji: "\U0001F3A8"
-colorFrom: blue
-colorTo: purple
-sdk: gradio
-sdk_version: 6.9.0
-app_file: app.py
+title: Anima 2B CPU
+emoji: 🎨
+colorFrom: purple
+colorTo: pink
+sdk: docker
 pinned: false
-license: mit
-python_version: "3.11"
-startup_duration_timeout: 1h
-preload_from_hub:
-  - JusteLeo/Anima2-GGUF anima-preview2_q4_K_M.gguf
-  - circlestone-labs/Anima split_files/text_encoders/qwen_3_06b_base.safetensors
-  - circlestone-labs/Anima split_files/vae/qwen_image_vae.safetensors
-  - Einhorn/Anima-Preview2-Turbo-LoRA anima_preview2_turbo_8step.safetensors
+license: other
+short_description: Anime image generation with Anima 2B on CPU
+tags:
+  - text-to-image
+  - anime
+  - gguf
+  - cpu
 ---
+
+# Anima 2B Image Generation (CPU)
+
+Generate anime images with Anima 2B (Q4_K_M GGUF) + Turbo LoRA on free CPU hardware.
+
+- Engine: stable-diffusion.cpp (compiled from source with Anima support)
+- Model: Anima 2B Q4_K_M (1.2 GB)
+- Turbo LoRA: 8-step distillation (cfg 1.0)
+- Hardware: CPU Basic

app.py

@@ -1,157 +1,139 @@
-import os
-import shutil
-import time
-import gradio as gr
-from huggingface_hub import hf_hub_download
-from stable_diffusion_cpp import StableDiffusion
+"""Anima 2B Image Generation (CPU) via sd-cli binary"""
 
-# Download / locate model files
-print("Downloading model files...")
-t0 = time.time()
+import os, time, subprocess, tempfile, shutil
+from pathlib import Path
+from PIL import Image
+from huggingface_hub import hf_hub_download
+import gradio as gr
 
-diffusion_path = hf_hub_download(
-    repo_id="JusteLeo/Anima2-GGUF",
-    filename="anima-preview2_q4_K_M.gguf",
-)
-llm_path = hf_hub_download(
-    repo_id="circlestone-labs/Anima",
-    filename="split_files/text_encoders/qwen_3_06b_base.safetensors",
-)
-vae_path = hf_hub_download(
-    repo_id="circlestone-labs/Anima",
-    filename="split_files/vae/qwen_image_vae.safetensors",
-)
-
-# Download Turbo LoRA (8-step distillation)
-lora_src = hf_hub_download(
-    repo_id="Einhorn/Anima-Preview2-Turbo-LoRA",
-    filename="anima_preview2_turbo_8step.safetensors",
-)
-# Copy LoRA to a flat directory for sd.cpp lora_model_dir
+# ---------------------------------------------------------------------------
+# Download models
+# ---------------------------------------------------------------------------
+MODELS_DIR = "/tmp/anima_models"
 LORA_DIR = "/tmp/loras"
+os.makedirs(MODELS_DIR, exist_ok=True)
 os.makedirs(LORA_DIR, exist_ok=True)
-lora_dest = os.path.join(LORA_DIR, "anima_turbo_8step.safetensors")
-if not os.path.exists(lora_dest):
-    shutil.copy2(lora_src, lora_dest)
-    print(f"LoRA copied to {lora_dest}")
 
-print(f"Model files ready in {time.time() - t0:.1f}s")
+def ensure_model(repo_id, filename, subdir=""):
+    path = os.path.join(MODELS_DIR, filename)
+    if os.path.exists(path):
+        return path
+    print(f"[init] Downloading {repo_id}/{subdir}/{filename}...")
+    src = hf_hub_download(
+        repo_id=repo_id,
+        filename=f"{subdir}/{filename}" if subdir else filename,
+    )
+    shutil.copy2(src, path)
+    return path
 
-# Load model
-print("Loading Anima 2B model with Turbo LoRA...")
+print("[init] Ensuring model files...")
 t0 = time.time()
-sd = StableDiffusion(
-    diffusion_model_path=diffusion_path,
-    llm_path=llm_path,
-    vae_path=vae_path,
-    lora_model_dir=LORA_DIR,
-    diffusion_flash_attn=True,
-    n_threads=2,
-    verbose=True,
-)
-print(f"Model loaded in {time.time() - t0:.1f}s")
-
-RESOLUTIONS = [
-    "1024x1024",
-    "768x768",
-    "512x512",
-    "1024x768",
-    "768x1024",
-    "1280x768",
-    "768x1280",
-]
-
-
-def generate(
-    prompt: str,
-    resolution: str,
-    steps: int,
-    cfg_scale: float,
-    seed: int,
-) -> tuple:
-    """Generate an image from a text prompt using Anima 2B with Turbo LoRA."""
-    if not prompt or not prompt.strip():
-        raise gr.Error("Please enter a prompt.")
+diffusion_path = ensure_model("JusteLeo/Anima2-GGUF", "anima-preview2_q4_K_M.gguf")
+llm_path = ensure_model("circlestone-labs/Anima", "qwen_3_06b_base.safetensors", "split_files/text_encoders")
+vae_path = ensure_model("circlestone-labs/Anima", "qwen_image_vae.safetensors", "split_files/vae")
 
-    w, h = (int(x) for x in resolution.split("x"))
+# Turbo LoRA (8-step)
+lora_src = hf_hub_download("Einhorn/Anima-Preview2-Turbo-LoRA", "anima_preview2_turbo_8step.safetensors")
+lora_path = os.path.join(LORA_DIR, "anima_turbo_8step.safetensors")
+if not os.path.exists(lora_path):
+    shutil.copy2(lora_src, lora_path)
 
-    # Prepend LoRA trigger to prompt
-    full_prompt = f"<lora:anima_turbo_8step:1.0> {prompt}"
+print(f"[init] Models ready in {time.time()-t0:.1f}s")
 
-    t0 = time.time()
-    images = sd.generate_image(
-        prompt=full_prompt,
-        width=w,
-        height=h,
-        sample_steps=steps,
-        cfg_scale=cfg_scale,
-        seed=seed,
-        vae_tiling=True,
-    )
-    elapsed = time.time() - t0
+# ---------------------------------------------------------------------------
+# Inference via sd-cli binary
+# ---------------------------------------------------------------------------
+RESOLUTIONS = ["512x512", "768x768", "1024x1024", "1024x768", "768x1024"]
 
-    if not images or images[0] is None:
-        raise gr.Error("Generation failed. Try a different prompt or settings.")
-
-    return images[0], f"Generated {resolution} in {elapsed:.1f}s ({steps} steps, cfg {cfg_scale})"
+def generate(prompt, resolution, steps, cfg_scale, seed):
+    if not prompt or not prompt.strip():
+        raise gr.Error("Please enter a prompt.")
 
+    w, h = (int(x) for x in resolution.split("x"))
+    seed = int(seed) if int(seed) >= 0 else -1
+
+    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as f:
+        output_path = f.name
+
+    # Build sd-cli command (same as official docs)
+    cmd = [
+        "sd-cli",
+        "--diffusion-model", diffusion_path,
+        "--llm", llm_path,
+        "--vae", vae_path,
+        "--lora-model-dir", LORA_DIR,
+        "-p", f"<lora:anima_turbo_8step:1.0> {prompt}",
+        "-W", str(w),
+        "-H", str(h),
+        "--steps", str(int(steps)),
+        "--cfg-scale", str(float(cfg_scale)),
+        "--sampling-method", "euler",
+        "-o", output_path,
+        "--diffusion-fa",
+        "--vae-tiling",
+        "-v",
+    ]
+    if seed >= 0:
+        cmd += ["-s", str(seed)]
+
+    print(f"[gen] {w}x{h} steps={steps} cfg={cfg_scale} seed={seed}")
+    t0 = time.time()
 
-with gr.Blocks(title="Anima 2B Image Generation (CPU)") as demo:
-    gr.Markdown("# Anima 2B Image Generation (CPU)")
+    try:
+        result = subprocess.run(
+            cmd, capture_output=True, text=True, timeout=1800,
+        )
+        elapsed = time.time() - t0
+
+        if result.returncode != 0:
+            err = result.stderr[-500:] if result.stderr else "Unknown error"
+            raise gr.Error(f"sd-cli failed (code {result.returncode}): {err}")
+
+        if not os.path.exists(output_path) or os.path.getsize(output_path) == 0:
+            raise gr.Error("No output image generated")
+
+        img = Image.open(output_path)
+        status = f"Generated in {elapsed:.1f}s ({w}x{h}, {steps} steps, cfg {cfg_scale})"
+        print(f"[gen] {status}")
+        return img, status
+
+    except subprocess.TimeoutExpired:
+        raise gr.Error("Generation timed out (30 min limit)")
+    except gr.Error:
+        raise
+    except Exception as e:
+        raise gr.Error(f"Error: {e}")
+
+# ---------------------------------------------------------------------------
+# Gradio UI
+# ---------------------------------------------------------------------------
+with gr.Blocks(title="Anima 2B (CPU)") as demo:
     gr.Markdown(
-        "Generate images using [Anima 2B](https://huggingface.co/circlestone-labs/Anima) "
-        "via stable-diffusion.cpp on free CPU hardware. "
-        "Q4_K_M GGUF (~1.2 GB) with "
-        "[Turbo LoRA](https://huggingface.co/Einhorn/Anima-Preview2-Turbo-LoRA) "
-        "for 8-step generation."
+        "# Anima 2B Image Generation (CPU)\n"
+        "Generate anime images using [Anima 2B](https://huggingface.co/circlestone-labs/Anima) "
+        "with [Turbo LoRA](https://huggingface.co/Einhorn/Anima-Preview2-Turbo-LoRA) (8 steps). "
+        "Powered by [sd.cpp](https://github.com/leejet/stable-diffusion.cpp)."
     )
-
     with gr.Row():
         with gr.Column():
-            prompt_box = gr.Textbox(
-                label="Prompt",
-                placeholder="anime girl with silver hair, fantasy armor",
-                lines=3,
-            )
-            resolution_dd = gr.Dropdown(
-                label="Resolution",
-                choices=RESOLUTIONS,
-                value="1024x1024",
-            )
+            prompt_input = gr.Textbox(label="Prompt", lines=3,
+                placeholder="anime girl with silver hair, fantasy armor, dramatic lighting")
+            res_input = gr.Dropdown(choices=RESOLUTIONS, value="512x512", label="Resolution")
             with gr.Row():
-                steps_slider = gr.Slider(
-                    label="Steps",
-                    minimum=1,
-                    maximum=50,
-                    step=1,
-                    value=8,
-                )
-                cfg_slider = gr.Slider(
-                    label="CFG Scale",
-                    minimum=1.0,
-                    maximum=10.0,
-                    step=0.5,
-                    value=1.0,
-                )
-            seed_number = gr.Number(
-                label="Seed (-1 = random)",
-                value=-1,
-                precision=0,
-            )
-            run_btn = gr.Button("Generate", variant="primary")
-
-            gr.Markdown(
-                "**Turbo LoRA active:** Defaults are Steps=8, CFG=1.0. "
-                "For non-turbo (no LoRA), use Steps=30, CFG=4.0."
-            )
+                steps_input = gr.Slider(minimum=4, maximum=30, value=8, step=1, label="Steps")
+                cfg_input = gr.Slider(minimum=1.0, maximum=10.0, value=1.0, step=0.5, label="CFG Scale")
+                seed_input = gr.Number(value=-1, label="Seed", precision=0)
+            gen_btn = gr.Button("Generate", variant="primary", size="lg")
         with gr.Column():
-            output_image = gr.Image(label="Result", type="pil")
-            timing_label = gr.Textbox(label="Timing", interactive=False)
+            output_img = gr.Image(type="pil", label="Output")
+            status_box = gr.Textbox(label="Status", interactive=False)
 
-    inputs = [prompt_box, resolution_dd, steps_slider, cfg_slider, seed_number]
-    outputs = [output_image, timing_label]
+    gen_btn.click(fn=generate,
+        inputs=[prompt_input, res_input, steps_input, cfg_input, seed_input],
+        outputs=[output_img, status_box])
 
-    run_btn.click(fn=generate, inputs=inputs, outputs=outputs, api_name="generate")
-    prompt_box.submit(fn=generate, inputs=inputs, outputs=outputs, api_name=False)
+    gr.Markdown("---\nAnima 2B Q4_K_M GGUF + Turbo LoRA (8 steps) | "
+                "[Model](https://huggingface.co/circlestone-labs/Anima) | "
+                "[sd.cpp](https://github.com/leejet/stable-diffusion.cpp)")
 
-demo.launch(show_error=True, ssr_mode=False, theme="NoCrypt/miku")
+demo.launch(server_name="0.0.0.0", port=7860, show_error=True, theme="NoCrypt/miku")

packages.txt

@@ -1,3 +0,0 @@
-build-essential
-cmake
-libopenblas-dev

requirements.txt

@@ -1,4 +0,0 @@
-git+https://github.com/william-murray1204/stable-diffusion-cpp-python.git
-gradio
-Pillow
-huggingface-hub