Add ZeroGPU-ready Gradio app for HF Space

Adapt copie_de_poc.py into app.py: remove Colab pip-install/share/debug,
add spaces lib with @spaces.GPU decorator, load models on cuda at startup,
queue() the demo. Add requirements.txt.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

app.py

@@ -0,0 +1,830 @@
+# -*- coding: utf-8 -*-
+"""GameGen - POC mini-jeux génératifs visuels (HuggingFace Space / ZeroGPU)
+
+Qwen3-4B génère la spec JSON, SDXL génère les assets, un canvas exécute le mini-jeu.
+Adapté du POC Colab pour tourner sur HuggingFace Spaces avec ZeroGPU.
+"""
+
+import spaces  # doit être importé avant torch sur ZeroGPU
+
+import torch, json, re, base64, io, html
+from PIL import Image
+from pydantic import BaseModel, Field
+from typing import Literal, List, Dict
+
+
+class VisualMiniGameSpec(BaseModel):
+    template: Literal["grab_target", "avoid_falling", "timing_hit"]
+    instruction: str = Field(min_length=5, max_length=80)
+    theme: str = Field(min_length=3, max_length=80)
+    duration_seconds: int = Field(ge=3, le=8)
+    difficulty: int = Field(ge=1, le=5)
+
+    visual_style: str = Field(min_length=10, max_length=200)
+    background_prompt: str = Field(min_length=10, max_length=300)
+    target_prompt: str = Field(min_length=10, max_length=300)
+    decoy_prompts: List[str] = Field(min_length=2, max_length=2)
+
+    success_text: str = Field(min_length=2, max_length=80)
+    failure_text: str = Field(min_length=2, max_length=80)
+
+
+# ---------------------------------------------------------------------------
+# Chargement des modèles (au démarrage du Space)
+# ---------------------------------------------------------------------------
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+
+LLM_ID = "Qwen/Qwen3-4B-Instruct-2507"
+
+bnb_config = BitsAndBytesConfig(
+    load_in_4bit=True,
+    bnb_4bit_compute_dtype=torch.float16,
+    bnb_4bit_quant_type="nf4",
+    bnb_4bit_use_double_quant=True,
+)
+
+tokenizer = AutoTokenizer.from_pretrained(LLM_ID, trust_remote_code=True)
+
+llm = AutoModelForCausalLM.from_pretrained(
+    LLM_ID,
+    quantization_config=bnb_config,
+    device_map="cuda",
+    trust_remote_code=True,
+)
+
+from diffusers import StableDiffusionXLPipeline
+
+IMAGE_MODEL_ID = "stabilityai/stable-diffusion-xl-base-1.0"
+
+pipe = StableDiffusionXLPipeline.from_pretrained(
+    IMAGE_MODEL_ID,
+    torch_dtype=torch.float16,
+    use_safetensors=True,
+    variant="fp16",
+)
+pipe.to("cuda")
+pipe.enable_attention_slicing()
+
+
+# ---------------------------------------------------------------------------
+# Génération de la spec (LLM)
+# ---------------------------------------------------------------------------
+SYSTEM_PROMPT = """
+Tu es un game designer pour micro-jeux très courts type WarioWare-like.
+
+Tu dois répondre uniquement en JSON valide.
+Aucun markdown. Aucun commentaire. Aucun texte hors JSON.
+
+Tu génères un mini-jeu visuel, pas un quiz.
+Les objets doivent être rendus comme des vrais assets visuels générables par un modèle image.
+
+Templates autorisés:
+- grab_target: cliquer/toucher rapidement l'objet cible qui bouge
+- avoid_falling: éviter des objets qui tombent
+- timing_hit: cliquer/toucher au bon moment quand l'objet passe dans une zone
+
+Contraintes:
+- duration_seconds entre 3 et 8
+- difficulty entre 1 et 5
+- instruction courte, impérative, arcade
+- prompts visuels en anglais
+- style cohérent entre background, target et decoys
+- target_prompt doit décrire un objet visuel concret
+- decoy_prompts doivent décrire de vrais objets visuels, pas du texte
+- pas de violence réaliste
+- pas de texte dans les images
+"""
+
+EXAMPLE_JSON = {
+    "template": "grab_target",
+    "instruction": "Attrape la banane !",
+    "theme": "marché fruité arcade",
+    "duration_seconds": 5,
+    "difficulty": 2,
+    "visual_style": "colorful arcade sticker art, bold black outlines, clean silhouettes, playful exaggerated shapes",
+    "background_prompt": "colorful arcade fruit market background, dynamic playful composition, bold shapes, vibrant colors, no text",
+    "target_prompt": "single ripe banana, sticker art, bold black outline, centered, clean silhouette, vibrant yellow, no text",
+    "decoy_prompts": [
+        "single yellow boomerang, sticker art, bold black outline, centered, clean silhouette, no text",
+        "single crescent moon, sticker art, bold black outline, centered, clean silhouette, no text",
+    ],
+    "success_text": "Bien joué !",
+    "failure_text": "Raté !",
+}
+
+
+def extract_json(text: str):
+    match = re.search(r"\{.*\}", text, re.DOTALL)
+    if not match:
+        raise ValueError("Aucun JSON trouvé")
+    return json.loads(match.group(0))
+
+
+def generate_spec(user_prompt: str) -> VisualMiniGameSpec:
+    messages = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {
+            "role": "user",
+            "content": f"""
+Inspiration utilisateur: {user_prompt}
+
+Génère un JSON exactement dans ce style:
+{json.dumps(EXAMPLE_JSON, ensure_ascii=False, indent=2)}
+""",
+        },
+    ]
+
+    try:
+        prompt = tokenizer.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True,
+            enable_thinking=False,
+        )
+    except TypeError:
+        prompt = tokenizer.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True,
+        )
+
+    inputs = tokenizer(prompt, return_tensors="pt").to(llm.device)
+
+    with torch.no_grad():
+        output = llm.generate(
+            **inputs,
+            max_new_tokens=420,
+            do_sample=True,
+            temperature=0.75,
+            top_p=0.9,
+            repetition_penalty=1.05,
+        )
+
+    decoded = tokenizer.decode(
+        output[0][inputs["input_ids"].shape[-1]:],
+        skip_special_tokens=True,
+    )
+
+    data = extract_json(decoded)
+    return VisualMiniGameSpec(**data)
+
+
+def fallback_spec():
+    return VisualMiniGameSpec(**EXAMPLE_JSON)
+
+
+def safe_generate_spec(prompt):
+    try:
+        return generate_spec(prompt)
+    except Exception as e:
+        print("Fallback spec:", e)
+        return fallback_spec()
+
+
+# ---------------------------------------------------------------------------
+# Génération des assets (SDXL)
+# ---------------------------------------------------------------------------
+ASSET_CACHE = {}
+
+NEGATIVE_PROMPT = """
+text, words, letters, watermark, logo, blurry, low quality,
+photorealistic, realistic photo, messy background, cropped object,
+multiple objects, extra limbs, duplicate, unreadable
+"""
+
+
+def pil_to_b64(img: Image.Image) -> str:
+    buffer = io.BytesIO()
+    img.save(buffer, format="PNG")
+    return base64.b64encode(buffer.getvalue()).decode("utf-8")
+
+
+def generate_image(prompt, width=512, height=512, steps=18):
+    key = (prompt, width, height, steps)
+
+    if key in ASSET_CACHE:
+        return ASSET_CACHE[key]
+
+    with torch.no_grad():
+        image = pipe(
+            prompt=prompt,
+            negative_prompt=NEGATIVE_PROMPT,
+            width=width,
+            height=height,
+            num_inference_steps=steps,
+            guidance_scale=7.0,
+        ).images[0]
+
+    ASSET_CACHE[key] = image
+    return image
+
+
+def generate_assets(spec: VisualMiniGameSpec):
+    style = spec.visual_style
+
+    background = generate_image(
+        f"{spec.background_prompt}, {style}, no text, game background",
+        width=768,
+        height=512,
+        steps=18,
+    )
+
+    target = generate_image(
+        f"{spec.target_prompt}, {style}, isolated object, white background, no text",
+        width=512,
+        height=512,
+        steps=18,
+    )
+
+    decoy_1 = generate_image(
+        f"{spec.decoy_prompts[0]}, {style}, isolated object, white background, no text",
+        width=512,
+        height=512,
+        steps=18,
+    )
+
+    decoy_2 = generate_image(
+        f"{spec.decoy_prompts[1]}, {style}, isolated object, white background, no text",
+        width=512,
+        height=512,
+        steps=18,
+    )
+
+    return {
+        "background": pil_to_b64(background),
+        "target": pil_to_b64(target),
+        "decoy_1": pil_to_b64(decoy_1),
+        "decoy_2": pil_to_b64(decoy_2),
+    }
+
+
+# ---------------------------------------------------------------------------
+# Rendu du mini-jeu (canvas dans une iframe)
+# ---------------------------------------------------------------------------
+def render_canvas_game(spec: VisualMiniGameSpec, assets: Dict[str, str]):
+    spec_json = json.dumps(spec.model_dump(), ensure_ascii=False)
+    assets_json = json.dumps(assets)
+
+    iframe_html = f"""
+<!doctype html>
+<html>
+<head>
+<meta charset="utf-8" />
+<style>
+  html, body {{
+    margin: 0;
+    padding: 0;
+    width: 100%;
+    height: 100%;
+    overflow: hidden;
+    background: #111;
+    font-family: system-ui, sans-serif;
+  }}
+
+  #wrap {{
+    position: relative;
+    width: 100%;
+    height: 100vh;
+    background: #111;
+  }}
+
+  canvas {{
+    display: block;
+    width: 100%;
+    height: 100%;
+    background: #000;
+  }}
+
+  #hud {{
+    position: absolute;
+    left: 16px;
+    right: 16px;
+    top: 14px;
+    display: flex;
+    justify-content: space-between;
+    align-items: flex-start;
+    pointer-events: none;
+    color: white;
+    text-shadow: 0 3px 0 #000;
+  }}
+
+  #instruction {{
+    font-size: 32px;
+    font-weight: 1000;
+    line-height: 1;
+    max-width: 72%;
+  }}
+
+  #timer {{
+    font-size: 42px;
+    font-weight: 1000;
+    background: #ff2d55;
+    border: 4px solid white;
+    color: white;
+    padding: 4px 16px;
+    border-radius: 16px;
+    box-shadow: 0 5px 0 #000;
+  }}
+
+  #center {{
+    position: absolute;
+    left: 50%;
+    top: 50%;
+    transform: translate(-50%, -50%);
+  }}
+
+  #start {{
+    font-size: 30px;
+    font-weight: 1000;
+    padding: 20px 42px;
+    border: 5px solid white;
+    border-radius: 22px;
+    background: #ffe600;
+    color: #111;
+    cursor: pointer;
+    box-shadow: 0 8px 0 #000;
+  }}
+
+  #result {{
+    position: absolute;
+    left: 0;
+    right: 0;
+    bottom: 26px;
+    text-align: center;
+    color: white;
+    font-size: 42px;
+    font-weight: 1000;
+    text-shadow: 0 4px 0 #000;
+    pointer-events: none;
+  }}
+</style>
+</head>
+
+<body>
+<div id="wrap">
+  <canvas id="game" width="768" height="512"></canvas>
+
+  <div id="hud">
+    <div id="instruction"></div>
+    <div id="timer"></div>
+  </div>
+
+  <div id="center">
+    <button id="start">START</button>
+  </div>
+
+  <div id="result"></div>
+</div>
+
+<script>
+const spec = {spec_json};
+const assets = {assets_json};
+
+const canvas = document.getElementById("game");
+const ctx = canvas.getContext("2d");
+const instruction = document.getElementById("instruction");
+const timer = document.getElementById("timer");
+const startBtn = document.getElementById("start");
+const result = document.getElementById("result");
+
+instruction.textContent = spec.instruction;
+timer.textContent = spec.duration_seconds;
+
+const W = canvas.width;
+const H = canvas.height;
+
+let images = {{}};
+let running = false;
+let startTime = 0;
+let raf = null;
+let particles = [];
+let gameState = null;
+
+function loadImage(src) {{
+  return new Promise(resolve => {{
+    const img = new Image();
+    img.onload = () => resolve(img);
+    img.src = "data:image/png;base64," + src;
+  }});
+}}
+
+async function loadAssets() {{
+  images.background = await loadImage(assets.background);
+  images.target = await loadImage(assets.target);
+  images.decoy1 = await loadImage(assets.decoy_1);
+  images.decoy2 = await loadImage(assets.decoy_2);
+}}
+
+function rand(min, max) {{
+  return min + Math.random() * (max - min);
+}}
+
+function clamp(v, min, max) {{
+  return Math.max(min, Math.min(max, v));
+}}
+
+function drawCover(img, x, y, w, h) {{
+  const s = Math.max(w / img.width, h / img.height);
+  const nw = img.width * s;
+  const nh = img.height * s;
+  ctx.drawImage(img, x + (w - nw) / 2, y + (h - nh) / 2, nw, nh);
+}}
+
+function drawSprite(img, x, y, size, angle=0, pulse=1) {{
+  ctx.save();
+  ctx.translate(x, y);
+  ctx.rotate(angle);
+  ctx.scale(pulse, pulse);
+
+  ctx.shadowColor = "rgba(0,0,0,0.45)";
+  ctx.shadowBlur = 16;
+  ctx.shadowOffsetY = 8;
+
+  ctx.fillStyle = "white";
+  ctx.beginPath();
+  ctx.roundRect(-size/2, -size/2, size, size, 24);
+  ctx.fill();
+
+  ctx.drawImage(img, -size/2 + 8, -size/2 + 8, size - 16, size - 16);
+  ctx.restore();
+}}
+
+function addBurst(x, y, color="#ffe600") {{
+  for (let i = 0; i < 26; i++) {{
+    particles.push({{
+      x, y,
+      vx: rand(-7, 7),
+      vy: rand(-7, 7),
+      life: rand(18, 34),
+      color
+    }});
+  }}
+}}
+
+function drawParticles() {{
+  particles = particles.filter(p => p.life > 0);
+  for (const p of particles) {{
+    p.x += p.vx;
+    p.y += p.vy;
+    p.vy += 0.25;
+    p.life -= 1;
+
+    ctx.globalAlpha = clamp(p.life / 30, 0, 1);
+    ctx.fillStyle = p.color;
+    ctx.beginPath();
+    ctx.arc(p.x, p.y, 5, 0, Math.PI * 2);
+    ctx.fill();
+    ctx.globalAlpha = 1;
+  }}
+}}
+
+function endGame(success) {{
+  if (!running) return;
+  running = false;
+  cancelAnimationFrame(raf);
+
+  result.textContent = success ? spec.success_text : spec.failure_text;
+  result.style.color = success ? "#35ff6b" : "#ff3b30";
+
+  addBurst(W/2, H/2, success ? "#35ff6b" : "#ff3b30");
+
+  for (let i = 0; i < 20; i++) {{
+    drawFrame(performance.now());
+  }}
+
+  startBtn.textContent = "REJOUER";
+  startBtn.style.display = "block";
+}}
+
+function timeRemaining(now) {{
+  const elapsed = (now - startTime) / 1000;
+  return Math.max(0, spec.duration_seconds - elapsed);
+}}
+
+function resetBase() {{
+  result.textContent = "";
+  particles = [];
+  timer.textContent = spec.duration_seconds;
+}}
+
+function initGrabTarget() {{
+  const speed = 2.6 + spec.difficulty * 0.8;
+
+  gameState = {{
+    target: {{
+      x: rand(130, W - 130),
+      y: rand(150, H - 110),
+      vx: rand(-speed, speed),
+      vy: rand(-speed, speed),
+      size: 120
+    }},
+    decoys: [
+      {{
+        x: rand(100, W - 100),
+        y: rand(150, H - 100),
+        vx: rand(-speed, speed),
+        vy: rand(-speed, speed),
+        size: 105,
+        img: images.decoy1
+      }},
+      {{
+        x: rand(100, W - 100),
+        y: rand(150, H - 100),
+        vx: rand(-speed, speed),
+        vy: rand(-speed, speed),
+        size: 105,
+        img: images.decoy2
+      }}
+    ]
+  }};
+}}
+
+function updateMovingObject(o) {{
+  o.x += o.vx;
+  o.y += o.vy;
+
+  if (o.x < o.size/2 || o.x > W - o.size/2) o.vx *= -1;
+  if (o.y < 115 || o.y > H - o.size/2) o.vy *= -1;
+
+  o.x = clamp(o.x, o.size/2, W - o.size/2);
+  o.y = clamp(o.y, 115, H - o.size/2);
+}}
+
+function initAvoidFalling() {{
+  const count = 4 + spec.difficulty * 2;
+  const hazards = [];
+
+  for (let i = 0; i < count; i++) {{
+    hazards.push({{
+      x: rand(60, W - 60),
+      y: rand(-H, -40),
+      size: rand(70, 105),
+      speed: rand(2.4, 4.5) + spec.difficulty * 0.6,
+      img: Math.random() > 0.5 ? images.target : images.decoy1
+    }});
+  }}
+
+  gameState = {{
+    player: {{ x: W/2, y: H - 65, size: 92 }},
+    hazards
+  }};
+}}
+
+function initTimingHit() {{
+  const speed = 4 + spec.difficulty * 1.1;
+
+  gameState = {{
+    obj: {{
+      x: -80,
+      y: H / 2 + 40,
+      size: 115,
+      speed
+    }},
+    zoneX: W / 2,
+    zoneW: 120,
+    resolved: false
+  }};
+}}
+
+function startGame() {{
+  resetBase();
+  startBtn.style.display = "none";
+  running = true;
+  startTime = performance.now();
+
+  if (spec.template === "grab_target") initGrabTarget();
+  if (spec.template === "avoid_falling") initAvoidFalling();
+  if (spec.template === "timing_hit") initTimingHit();
+
+  raf = requestAnimationFrame(drawFrame);
+}}
+
+function drawBackground() {{
+  drawCover(images.background, 0, 0, W, H);
+
+  ctx.fillStyle = "rgba(0,0,0,0.22)";
+  ctx.fillRect(0, 0, W, H);
+
+  ctx.strokeStyle = "rgba(255,255,255,0.35)";
+  ctx.lineWidth = 8;
+  ctx.strokeRect(8, 8, W - 16, H - 16);
+}}
+
+function drawFrame(now) {{
+  drawBackground();
+
+  const left = timeRemaining(now);
+  timer.textContent = Math.ceil(left);
+
+  if (running && left <= 0) {{
+    if (spec.template === "avoid_falling") endGame(true);
+    else endGame(false);
+    return;
+  }}
+
+  const t = now / 1000;
+
+  if (running && spec.template === "grab_target") {{
+    const target = gameState.target;
+    updateMovingObject(target);
+
+    for (const d of gameState.decoys) {{
+      updateMovingObject(d);
+      drawSprite(d.img, d.x, d.y, d.size, Math.sin(t * 4) * 0.12, 1);
+    }}
+
+    drawSprite(
+      images.target,
+      target.x,
+      target.y,
+      target.size,
+      Math.sin(t * 5) * 0.16,
+      1 + Math.sin(t * 8) * 0.04
+    );
+  }}
+
+  if (running && spec.template === "avoid_falling") {{
+    const p = gameState.player;
+
+    drawSprite(images.target, p.x, p.y, p.size, 0, 1);
+
+    for (const h of gameState.hazards) {{
+      h.y += h.speed;
+
+      if (h.y > H + 80) {{
+        h.y = rand(-220, -60);
+        h.x = rand(60, W - 60);
+      }}
+
+      drawSprite(h.img, h.x, h.y, h.size, Math.sin(t * 6 + h.x) * 0.2, 1);
+
+      const dx = h.x - p.x;
+      const dy = h.y - p.y;
+      const dist = Math.sqrt(dx*dx + dy*dy);
+
+      if (dist < (h.size + p.size) * 0.38) {{
+        endGame(false);
+        return;
+      }}
+    }}
+  }}
+
+  if (running && spec.template === "timing_hit") {{
+    const obj = gameState.obj;
+    const zoneX = gameState.zoneX;
+    const zoneW = gameState.zoneW;
+
+    obj.x += obj.speed;
+
+    ctx.fillStyle = "rgba(53,255,107,0.35)";
+    ctx.fillRect(zoneX - zoneW/2, 105, zoneW, H - 125);
+
+    ctx.strokeStyle = "#35ff6b";
+    ctx.lineWidth = 6;
+    ctx.strokeRect(zoneX - zoneW/2, 105, zoneW, H - 125);
+
+    drawSprite(images.target, obj.x, obj.y, obj.size, Math.sin(t*7)*0.15, 1);
+
+    if (obj.x > W + 100) {{
+      endGame(false);
+      return;
+    }}
+  }}
+
+  drawParticles();
+
+  if (running) {{
+    raf = requestAnimationFrame(drawFrame);
+  }}
+}}
+
+function canvasPoint(event) {{
+  const rect = canvas.getBoundingClientRect();
+  return {{
+    x: (event.clientX - rect.left) * (W / rect.width),
+    y: (event.clientY - rect.top) * (H / rect.height)
+  }};
+}}
+
+canvas.addEventListener("mousemove", e => {{
+  if (!running || spec.template !== "avoid_falling") return;
+  const p = canvasPoint(e);
+  gameState.player.x = clamp(p.x, 55, W - 55);
+}});
+
+canvas.addEventListener("click", e => {{
+  if (!running) return;
+  const p = canvasPoint(e);
+
+  if (spec.template === "grab_target") {{
+    const target = gameState.target;
+    const dx = p.x - target.x;
+    const dy = p.y - target.y;
+    const dist = Math.sqrt(dx*dx + dy*dy);
+
+    if (dist < target.size * 0.48) {{
+      addBurst(target.x, target.y, "#35ff6b");
+      endGame(true);
+      return;
+    }}
+
+    for (const d of gameState.decoys) {{
+      const ddx = p.x - d.x;
+      const ddy = p.y - d.y;
+      const ddist = Math.sqrt(ddx*ddx + ddy*ddy);
+      if (ddist < d.size * 0.48) {{
+        addBurst(d.x, d.y, "#ff3b30");
+        endGame(false);
+        return;
+      }}
+    }}
+  }}
+
+  if (spec.template === "timing_hit") {{
+    const obj = gameState.obj;
+    const zoneX = gameState.zoneX;
+    const zoneW = gameState.zoneW;
+    const success = obj.x > zoneX - zoneW/2 && obj.x < zoneX + zoneW/2;
+    addBurst(obj.x, obj.y, success ? "#35ff6b" : "#ff3b30");
+    endGame(success);
+  }}
+}});
+
+window.addEventListener("keydown", e => {{
+  if (!running) return;
+
+  if (spec.template === "timing_hit" && (e.code === "Space" || e.code === "Enter")) {{
+    const obj = gameState.obj;
+    const zoneX = gameState.zoneX;
+    const zoneW = gameState.zoneW;
+    const success = obj.x > zoneX - zoneW/2 && obj.x < zoneX + zoneW/2;
+    endGame(success);
+  }}
+
+  if (spec.template === "avoid_falling") {{
+    const p = gameState.player;
+    if (e.key === "ArrowLeft" || e.key === "q" || e.key === "a") p.x = clamp(p.x - 42, 55, W - 55);
+    if (e.key === "ArrowRight" || e.key === "d") p.x = clamp(p.x + 42, 55, W - 55);
+  }}
+}});
+
+startBtn.onclick = startGame;
+
+loadAssets().then(() => {{
+  drawBackground();
+  timer.textContent = spec.duration_seconds;
+}});
+</script>
+</body>
+</html>
+"""
+
+    srcdoc = html.escape(iframe_html, quote=True)
+
+    return f"""
+<iframe
+  srcdoc="{srcdoc}"
+  style="width:100%; height:620px; border:0; border-radius:18px; overflow:hidden;"
+></iframe>
+"""
+
+
+# ---------------------------------------------------------------------------
+# Pipeline complet (décoré ZeroGPU : GPU attaché le temps de l'appel)
+# ---------------------------------------------------------------------------
+@spaces.GPU(duration=120)
+def make_visual_game(prompt):
+    spec = safe_generate_spec(prompt)
+    assets = generate_assets(spec)
+    html_game = render_canvas_game(spec, assets)
+    return spec.model_dump(), html_game
+
+
+# ---------------------------------------------------------------------------
+# Interface Gradio
+# ---------------------------------------------------------------------------
+import gradio as gr
+
+with gr.Blocks() as demo:
+    gr.Markdown("# POC mini-jeux génératifs visuels")
+    gr.Markdown(
+        "Qwen3-4B génère la spec. SDXL génère les assets. Canvas exécute le mini-jeu."
+    )
+
+    prompt = gr.Textbox(
+        label="Inspiration",
+        value="mini-jeu absurde avec une vraie banane arcade, rapide et visuel",
+    )
+
+    btn = gr.Button("Générer un mini-jeu visuel")
+    json_out = gr.JSON(label="Spec générée")
+    game_out = gr.HTML(label="Mini-jeu jouable")
+
+    btn.click(
+        make_visual_game,
+        inputs=prompt,
+        outputs=[json_out, game_out],
+    )
+
+if __name__ == "__main__":
+    demo.queue().launch()

requirements.txt

@@ -0,0 +1,9 @@
+spaces
+torch
+transformers>=4.51.0
+accelerate>=0.30.0
+bitsandbytes>=0.43.0
+diffusers>=0.27.0
+safetensors
+pydantic>=2.0
+pillow