Two tabs (Image, one-button Video), sharper 1152x768 clips, better narration planner

README.md

@@ -12,11 +12,15 @@ short_description: FLUX image, LTX video, MusicGen music, Kokoro+Qwen narration
 
 # Graphics Studio
 
-1. **FLUX.1-schnell** (black-forest-labs) turns a prompt into a 1152×768 still in 4 steps.
-2. **LTX-Video** (Lightricks) animates that still, or any uploaded image, into a 2 to 8 second clip at 768×512, 10 fps.
-3. **MusicGen medium** (facebook) writes a soundtrack for the clip from a text description.
-4. **Qwen2.5 1.5B** plans the narration (what to say and when), and **Kokoro** speaks it over the music.
+**Image tab:** FLUX.1-schnell (black-forest-labs) turns a prompt into a 1152×768 still in 4 steps.
 
-FLUX.1-schnell and LTX-Video are openly licensed; MusicGen medium is CC-BY-NC 4.0 (non-commercial).
+**Video tab:** one button makes a whole clip from a scene and a motion description.
+
+1. **FLUX.1-schnell** draws the scene (or you supply a start image).
+2. **LTX-Video 0.9.8 13B distilled** (Lightricks) animates it: 2 to 8 seconds, 1152×768, 10 fps.
+3. **MusicGen medium** (facebook) adds a soundtrack if you describe one.
+4. **Qwen2.5 1.5B** plans the narration (what to say and when) and **Kokoro** speaks it, if narration is ticked.
+
+FLUX.1-schnell, LTX-Video, Qwen and Kokoro are openly licensed; MusicGen medium is CC-BY-NC 4.0 (non-commercial).
 
 Runs on ZeroGPU: set the Space hardware to **ZeroGPU** in Settings.

app.py

@@ -1,51 +1,40 @@
-"""Image to video on ZeroGPU.
+"""Graphics Studio on ZeroGPU.
 
-Step 1: FLUX.1-schnell turns a prompt into a still image (4 steps).
-Step 2: LTX-Video animates that image, or any image you upload, into a short clip.
-Step 3: MusicGen medium writes a soundtrack and attaches it to the clip.
-Step 4: a small planning model (Qwen2.5 1.5B) writes narration and decides when each line starts;
-        Kokoro speaks it, and it is mixed over the music.
+Image tab: FLUX.1-schnell turns a prompt into a still image.
+Video tab: one button makes a whole clip. FLUX draws the scene, LTX-Video (13B) animates it,
+MusicGen medium adds a soundtrack if you describe one, and if narration is ticked a small
+planning model (Qwen2.5 1.5B) writes the lines and their timing and Kokoro speaks them.
 """
 import os
 
 
 def _pick_model_store():
-    """Keep downloaded models on the Space's attached storage, so restarts don't download them again.
-    Uses MODEL_STORE if that variable is set, else the first writable mount it finds."""
-    # Off unless MODEL_STORE is set. Tried /data (the attached bucket) on 2026-10-04: it reads at about
-    # 8 MB/s, so loading 70 GB of models from it takes hours. The local disk downloads at about 1 GB/s.
-    candidates = [os.environ.get("MODEL_STORE")]
-    for path in [c for c in candidates if c]:
-        try:
-            os.makedirs(os.path.join(path, "huggingface"), exist_ok=True)
-            probe = os.path.join(path, "huggingface", ".write_test")
-            open(probe, "w").close()
-            os.remove(probe)
-            return os.path.join(path, "huggingface")
-        except OSError:
-            continue
-    return None
+    """Off unless MODEL_STORE is set. Tried /data (the attached bucket) on 2026-10-04: it reads at
+    about 8 MB/s, so loading 70 GB of models from it takes hours. The local disk downloads at 1 GB/s."""
+    path = os.environ.get("MODEL_STORE")
+    if not path:
+        return None
+    try:
+        os.makedirs(os.path.join(path, "huggingface"), exist_ok=True)
+        return os.path.join(path, "huggingface")
+    except OSError:
+        return None
 
 
 _store = _pick_model_store()
 if _store:
     os.environ["HF_HOME"] = _store          # Must be set before the Hugging Face libraries are imported
-print("MODEL STORE:", _store or "none found, using the default temporary cache",
-      "| mounts seen:", [m for m in ("/data", "/bucket", "/storage", "/mnt") if os.path.isdir(m)], flush=True)
 
-import json
 import random
 import re
 import subprocess
 
 import gradio as gr
-import imageio
 import imageio_ffmpeg
 import numpy as np
 import scipy.io.wavfile
 import spaces
 import torch
-from PIL import Image
 from diffusers import FluxPipeline, LTXConditionPipeline
 from diffusers.pipelines.ltx.pipeline_ltx_condition import LTXVideoCondition
 from diffusers.utils import export_to_video
@@ -54,17 +43,17 @@ from transformers import AutoModelForCausalLM, AutoProcessor, AutoTokenizer, Mus
 
 IMAGE_MODEL = "black-forest-labs/FLUX.1-schnell"
 VIDEO_MODEL = "Lightricks/LTX-Video-0.9.8-13B-distilled"
-MUSIC_MODEL = "facebook/musicgen-medium"      # Non-commercial licence (CC-BY-NC 4.0)
+MUSIC_MODEL = "facebook/musicgen-medium"       # Non-commercial licence (CC-BY-NC 4.0)
 PLANNER_MODEL = "Qwen/Qwen2.5-1.5B-Instruct"   # Writes the narration and its timing
 VOICE = "af_heart"                             # Kokoro voice
 VOICE_RATE = 24000
 WORDS_PER_SECOND = 2.5
 
 IMAGE_WIDTH, IMAGE_HEIGHT = 1152, 768      # 3:2, multiples of 16 for FLUX
-VIDEO_WIDTH, VIDEO_HEIGHT = 768, 512       # 3:2, multiples of 32 for LTX-Video
+VIDEO_WIDTH, VIDEO_HEIGHT = 1152, 768      # Same size as the image, so nothing is shrunk (multiples of 32)
+VIDEO_QUALITY = 9      # 0 to 10. Low values make the saved file blurry
 FPS = 10
 TRIM_FRAMES = 8        # Frames cut from the start of every clip, where the noise is
-FADE_FRAMES = 0        # Loop cross-fade switched off (set to 20 for a 2-second fade)
 MAX_SEED = 2**31 - 1
 
 NEGATIVE_PROMPT = ("worst quality, inconsistent motion, blurry, blurry motion, motion blur, "
@@ -72,15 +61,14 @@ NEGATIVE_PROMPT = ("worst quality, inconsistent motion, blurry, blurry motion, m
 NEGATIVE_SLOW = ", slow motion, slow-motion video"      # Left out when the motion text asks for slow motion
 # The distilled model runs without guidance, so the negative prompt alone has no effect on it.
 # These words are added to every prompt to get the same result from the positive side.
-STYLE_SUFFIX = "Sharp, crisp motion with no blur"
+STYLE_SUFFIX = "Sharp, crisp, highly detailed, in focus, no blur"
 SPEED_SUFFIX = ", moving at natural real-time speed"    # Also left out when slow motion is asked for
 
-
 # Loaded once at start-up. ZeroGPU attaches the GPU only while a @spaces.GPU function runs.
+# Everything together is about 70 GB, more than the default 47 GB ZeroGPU slice, so the GPU steps
+# ask for the whole card (size='xlarge'; it counts double against the quota).
 image_pipe = FluxPipeline.from_pretrained(IMAGE_MODEL, torch_dtype=torch.bfloat16).to("cuda")
-# FLUX (12B) and LTX-Video (13B) together need about 60 GB, more than the default 47 GB ZeroGPU
-# slice, so both steps ask for the whole card (size='xlarge'; it counts double against the quota).
-# Both models use the same T5-XXL text encoder (9.5 GB), so LTX-Video borrows FLUX's copy.
+# FLUX and LTX-Video use the same T5-XXL text encoder (9.5 GB), so LTX-Video borrows FLUX's copy.
 video_pipe = LTXConditionPipeline.from_pretrained(
     VIDEO_MODEL, text_encoder=image_pipe.text_encoder_2, torch_dtype=torch.bfloat16).to("cuda")
 video_pipe.vae.enable_tiling()     # Decode the video in tiles to keep memory low
@@ -95,12 +83,10 @@ def pick_seed(seed, randomize):
     return random.randint(0, MAX_SEED) if randomize else int(seed)
 
 
-@spaces.GPU(duration=10, size='xlarge')
-def make_image(prompt, seed, randomize_seed):
-    if not prompt.strip():
-        raise gr.Error("Describe the image first.")
-    seed = pick_seed(seed, randomize_seed)
-    image = image_pipe(
+# ---------------------------------------------------------------- The four model steps (run on the GPU)
+
+def draw_image(prompt, seed):
+    return image_pipe(
         prompt=prompt,
         width=IMAGE_WIDTH,
         height=IMAGE_HEIGHT,
@@ -109,50 +95,26 @@ def make_image(prompt, seed, randomize_seed):
         max_sequence_length=256,
         generator=torch.Generator("cpu").manual_seed(seed),
     ).images[0]
-    return image, seed
 
 
-def seamless_loop(frames):
-    """Make the clip loop smoothly: its opening frames fade in from its closing frames,
-    and those closing frames are then dropped. The last frame shown flows into the first."""
-    n = min(FADE_FRAMES, len(frames) // 3)
-    if n < 2:
-        return frames
-    body = frames[:len(frames) - n]
-    tail = frames[len(frames) - n:]
-    for i in range(n):
-        body[i] = Image.blend(tail[i], body[i], (i + 1) / (n + 1))
-    return body
-
-
-def video_duration(image, scene_prompt, motion_prompt, seconds, seed, randomize_seed):
-    """Ask ZeroGPU for only as much GPU time as this clip needs."""
-    return int(20 + seconds * 3)
-
-
-@spaces.GPU(duration=video_duration, size='xlarge')
-def make_video(image, scene_prompt, motion_prompt, seconds, seed, randomize_seed):
-    if image is None:
-        raise gr.Error("Make or upload an image first.")
-    seed = pick_seed(seed, randomize_seed)
+def animate(image, scene, motion, seconds, seed):
+    """Returns the path of a silent clip and its length in seconds."""
     # Generate the clip plus the frames that get cut off. LTX-Video wants 8n+1 frames.
-    num_frames = -(-(int(seconds * FPS) + TRIM_FRAMES + FADE_FRAMES - 1) // 8) * 8 + 1
-    # LTX-Video needs the scene AND the motion described, or it tends to hold the picture still
-    motion = motion_prompt.strip() or "gentle cinematic camera motion, natural movement"
-    # The motion comes first so the model gives it the most weight
+    num_frames = -(-(int(seconds * FPS) + TRIM_FRAMES - 1) // 8) * 8 + 1
+    motion = motion.strip() or "gentle cinematic camera motion, natural movement"
     # Only the phrase itself counts: "slow motion", "slow-motion", "slow mo". "Slowly" does not.
     wants_slow = re.search(r"slow[\s-]?mo", motion.lower()) is not None
     style = STYLE_SUFFIX + ("" if wants_slow else SPEED_SUFFIX) + "."
-    negative = NEGATIVE_PROMPT + ("" if wants_slow else NEGATIVE_SLOW)
-    prompt = f"{motion}. {scene_prompt.strip()}. {style}" if scene_prompt.strip() else f"{motion}. {style}"
+    # The motion comes first so the model gives it the most weight
+    prompt = f"{motion}. {scene.strip()}. {style}" if scene.strip() else f"{motion}. {style}"
     start = LTXVideoCondition(image=image.convert("RGB").resize((VIDEO_WIDTH, VIDEO_HEIGHT)), frame_index=0)
     frames = video_pipe(
         conditions=[start],
         prompt=prompt,
+        negative_prompt=NEGATIVE_PROMPT + ("" if wants_slow else NEGATIVE_SLOW),
         image_cond_noise_scale=0.0,
         decode_timestep=0.05,
         decode_noise_scale=0.025,
-        negative_prompt=negative,
         width=VIDEO_WIDTH,
         height=VIDEO_HEIGHT,
         num_frames=num_frames,
@@ -162,40 +124,15 @@ def make_video(image, scene_prompt, motion_prompt, seconds, seed, randomize_seed
         guidance_rescale=0.7,
         generator=torch.Generator("cpu").manual_seed(seed),
     ).frames[0]
-    path = f"/tmp/video_{seed}.mp4"
-    export_to_video(seamless_loop(frames[TRIM_FRAMES:]), path, fps=FPS)
-    return path, seed, path, None, None, ""
-
-
-def clip_seconds(video):
-    try:
-        return float(imageio.get_reader(video).get_meta_data()["duration"])
-    except Exception:
-        return 6.0
-
-
-def mix(video, music_wav, voice_wav):
-    """Put whichever sound tracks exist onto the silent clip. With both, the music plays
-    quietly under the voice. Called after every sound step, so the order never matters."""
-    ffmpeg = [imageio_ffmpeg.get_ffmpeg_exe(), "-y", "-i", video]
-    if music_wav and voice_wav:
-        ffmpeg += ["-i", voice_wav, "-i", music_wav, "-filter_complex",
-                   "[1:a]aresample=44100,volume=1.6[v];[2:a]aresample=44100,volume=0.35[m];"
-                   "[v][m]amix=inputs=2:duration=longest:normalize=0[a]", "-map", "0:v:0", "-map", "[a]"]
-    else:
-        ffmpeg += ["-i", music_wav or voice_wav, "-map", "0:v:0", "-map", "1:a:0"]
-    out_path = f"/tmp/mixed_{random.randint(0, MAX_SEED)}.mp4"
-    subprocess.run(ffmpeg + ["-c:v", "copy", "-c:a", "aac", "-shortest", out_path], check=True, capture_output=True)
-    return out_path
-
-
-def music_duration(video, music_prompt):
-    return int(15 + clip_seconds(video) * 3) if video else 15
+    frames = frames[TRIM_FRAMES:]
+    path = f"/tmp/video_{seed}_{random.randint(0, 99999)}.mp4"
+    export_to_video(frames, path, fps=FPS, quality=VIDEO_QUALITY)
+    return path, len(frames) / FPS
 
 
-@spaces.GPU(duration=music_duration, size='xlarge')
-def compose_music(video, music_prompt):
-    seconds = min(max(clip_seconds(video), 2.0), 28.0)
+def compose_music(music_prompt, seconds):
+    """Returns the path of a WAV file as long as the clip."""
+    seconds = min(max(seconds, 2.0), 28.0)
     inputs = music_processor(text=[music_prompt], padding=True, return_tensors="pt").to("cuda")
     audio = music_model.generate(**inputs, do_sample=True, guidance_scale=3.0,
                                  max_new_tokens=int(seconds * 50) + 8)     # MusicGen makes 50 tokens a second
@@ -209,47 +146,40 @@ def compose_music(video, music_prompt):
     return wav_path
 
 
-def add_music(video, music_prompt, voice_wav):
-    if not video:
-        raise gr.Error("Animate an image first.")
-    if not music_prompt.strip():
-        raise gr.Error("Describe the music first.")
-    music_wav = compose_music(video, music_prompt)
-    return mix(video, music_wav, voice_wav), music_wav
-
-
-@spaces.GPU(duration=20, size='xlarge')
 def plan_narration(scene, motion, seconds):
     """The planning model writes 1 to 3 short lines and picks the second each one starts."""
-    budget = int(seconds * WORDS_PER_SECOND)
-    system = ("You write narration for a short silent video clip. Reply with ONLY a JSON list, no other text. "
-              'Each item is {"start": seconds from the beginning, "text": one short spoken sentence}. '
-              f"The clip is {seconds:.1f} seconds long. Speech takes one second per {WORDS_PER_SECOND} words, "
-              f"so use at most {budget} words in total. Use 1 to 3 items. Lines must not overlap, and the last "
-              "one must finish before the clip ends. Start the first line after a short pause. "
-              "Leave silence where nothing needs saying.")
-    user = f"Scene: {scene or 'unknown'}\nMotion: {motion or 'gentle movement'}\nNarrate the scene with a sense of wonder."
+    budget = max(4, int((seconds - 1) * WORDS_PER_SECOND))
+    system = ("You are the narrator of a short film clip. You are given what the clip shows. Write what the "
+              "narrator SAYS over it: a thought, a feeling or a tiny story about the scene, like a nature "
+              "documentary. Never repeat or list the description itself, and never mention cameras, prompts or "
+              "video. Reply with 1 to 3 lines and nothing else. Each line is: start second | sentence.\n"
+              f"The clip lasts {seconds:.0f} seconds. Use at most {budget} words in total, so every line is short. "
+              "The first line starts at 0.5 or later, and later lines start after the earlier ones have been spoken.\n\n"
+              "Example for a clip of a lighthouse in a storm, 6 seconds:\n"
+              "0.5 | Some lights refuse to go out.\n"
+              "3.5 | Even when the sea says otherwise.")
+    user = f"The clip shows: {scene or 'a quiet scene'}\nWhat moves: {motion or 'gentle movement'}"
     text = planner_tokenizer.apply_chat_template(
         [{"role": "system", "content": system}, {"role": "user", "content": user}],
         tokenize=False, add_generation_prompt=True)
     inputs = planner_tokenizer([text], return_tensors="pt").to("cuda")
-    out = planner_model.generate(**inputs, max_new_tokens=200, do_sample=False)
+    out = planner_model.generate(**inputs, max_new_tokens=120, do_sample=True, temperature=0.8, top_p=0.9)
     return planner_tokenizer.decode(out[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
 
 
-def parse_plan(reply, fallback, seconds):
-    """Turn the planner's reply into [(start, text)], or one safe line if it isn't valid JSON."""
+# ---------------------------------------------------------------- Narration and mixing (CPU only)
+
+def parse_plan(reply, seconds):
+    """Turn the planner's reply into [(start, text)]. If it ignored the format, its own words are
+    still used as one line; the scene description is never read out."""
     plan = []
-    try:
-        for item in json.loads(re.search(r"\[.*\]", reply, re.S).group(0)):
-            line = str(item["text"]).strip()
-            if line:
-                plan.append((max(0.0, float(item["start"])), line))
-    except Exception:
-        plan = []
+    for row in reply.splitlines():
+        match = re.match(r"\s*[-*]?\s*(\d+(?:\.\d+)?)\s*(?:s|sec|seconds)?\s*[|:–-]\s*(.+)", row)
+        if match and match.group(2).strip():
+            plan.append((float(match.group(1)), match.group(2).strip().strip('"')))
     if not plan:
-        words = (fallback or "A quiet moment, captured in motion.").split()[:int(seconds * WORDS_PER_SECOND)]
-        plan = [(0.5, " ".join(words))]
+        words = re.sub(r"[\[\]{}\"|]", " ", reply).split()[:int(seconds * WORDS_PER_SECOND)]
+        plan = [(0.5, " ".join(words) or "A quiet moment, captured in motion.")]
     return sorted(plan)[:3]
 
 
@@ -258,16 +188,11 @@ def speak(text):
     return np.concatenate(chunks) if chunks else np.zeros(0, dtype=np.float32)
 
 
-def add_narration(video, music_wav, scene, motion):
-    if not video:
-        raise gr.Error("Animate an image first.")
-    seconds = clip_seconds(video)
-    reply = plan_narration(scene, motion, seconds)
-    plan = parse_plan(reply, scene, seconds)
-
+def narrate(reply, seconds):
+    """Speak the plan into one WAV as long as the clip. Returns (wav path or None, the plan as text)."""
     track = np.zeros(int(seconds * VOICE_RATE), dtype=np.float32)
     cursor, script = 0.0, []
-    for start, line in plan:
+    for start, line in parse_plan(reply, seconds):
         voice = speak(line)
         start = max(start, cursor)                      # Never talk over the previous line
         begin = int(start * VOICE_RATE)
@@ -279,60 +204,116 @@ def add_narration(video, music_wav, scene, motion):
         cursor = start + len(voice) / VOICE_RATE + 0.3
         script.append(f"{start:4.1f} s  {line}")
     if not script:
-        raise gr.Error("The clip is too short for any narration.")
+        return None, "The clip is too short for narration."
+    path = f"/tmp/voice_{random.randint(0, MAX_SEED)}.wav"
+    scipy.io.wavfile.write(path, VOICE_RATE, (np.clip(track, -1, 1) * 32767).astype(np.int16))
+    return path, "\n".join(script)
+
+
+def mix(video, music_wav, voice_wav):
+    """Put whichever sound tracks exist onto the silent clip. With both, the music plays quietly under the voice."""
+    if not music_wav and not voice_wav:
+        return video
+    ffmpeg = [imageio_ffmpeg.get_ffmpeg_exe(), "-y", "-i", video]
+    if music_wav and voice_wav:
+        ffmpeg += ["-i", voice_wav, "-i", music_wav, "-filter_complex",
+                   "[1:a]aresample=44100,volume=1.6[v];[2:a]aresample=44100,volume=0.35[m];"
+                   "[v][m]amix=inputs=2:duration=longest:normalize=0[a]", "-map", "0:v:0", "-map", "[a]"]
+    else:
+        ffmpeg += ["-i", music_wav or voice_wav, "-map", "0:v:0", "-map", "1:a:0"]
+    out_path = f"/tmp/mixed_{random.randint(0, MAX_SEED)}.mp4"
+    subprocess.run(ffmpeg + ["-c:v", "copy", "-c:a", "aac", "-shortest", out_path], check=True, capture_output=True)
+    return out_path
 
-    voice_path = f"/tmp/voice_{random.randint(0, MAX_SEED)}.wav"
-    scipy.io.wavfile.write(voice_path, VOICE_RATE, (np.clip(track, -1, 1) * 32767).astype(np.int16))
-    return mix(video, music_wav, voice_path), "\n".join(script), voice_path
+
+# ---------------------------------------------------------------- The two buttons
+
+@spaces.GPU(duration=10, size='xlarge')
+def make_image(prompt, seed, randomize_seed):
+    if not prompt.strip():
+        raise gr.Error("Describe the image first.")
+    seed = pick_seed(seed, randomize_seed)
+    return draw_image(prompt, seed), seed
+
+
+def studio_duration(image, scene, motion, music_prompt, want_narration, seconds, seed):
+    """Ask ZeroGPU for only as much GPU time as this clip needs."""
+    total = 20 + seconds * 5                            # Animation
+    if image is None:
+        total += 8                                      # FLUX draws the scene first
+    if music_prompt.strip():
+        total += 8 + seconds * 2.5
+    if want_narration:
+        total += 8
+    return int(total)
+
+
+@spaces.GPU(duration=studio_duration, size='xlarge')
+def run_models(image, scene, motion, music_prompt, want_narration, seconds, seed):
+    """Everything that needs the GPU, in one go, so the models are moved onto it only once."""
+    if image is None:
+        image = draw_image(scene, seed)
+    video, length = animate(image, scene, motion, seconds, seed)
+    music_wav = compose_music(music_prompt, length) if music_prompt.strip() else None
+    reply = plan_narration(scene, motion, length) if want_narration else None
+    return video, length, music_wav, reply
+
+
+def make_video(image, scene, motion, music_prompt, want_narration, seconds, seed, randomize_seed):
+    if image is None and not scene.strip():
+        raise gr.Error("Describe the scene, or add a start image.")
+    seed = pick_seed(seed, randomize_seed)
+    video, length, music_wav, reply = run_models(image, scene, motion, music_prompt, want_narration, seconds, seed)
+    voice_wav, script = narrate(reply, length) if reply is not None else (None, "")
+    return mix(video, music_wav, voice_wav), script, seed
 
 
 with gr.Blocks(title="Graphics Studio") as demo:
-    silent_clip = gr.State(None)        # The clip without sound, as Animate made it
-    music_track = gr.State(None)        # The soundtrack file, once Add music has run
-    voice_track = gr.State(None)        # The narration file, once Add narration has run
-    gr.Markdown("# Graphics Studio\nMake a still with **FLUX.1-schnell**, bring it to life with **LTX-Video**, "
-                "score it with **MusicGen**, then narrate it with **Qwen** and **Kokoro**.")
-
-    with gr.Row():
-        with gr.Column():
-            image_prompt = gr.Textbox(label="1. Describe the image", lines=3,
-                                      placeholder="A breathtaking aurora over a frozen lake at night, ultra detailed")
-            with gr.Row():
-                image_seed = gr.Slider(0, MAX_SEED, value=0, step=1, label="Seed")
-                image_random = gr.Checkbox(value=True, label="Random seed")
-            image_button = gr.Button("Generate image", variant="primary")
-            image_out = gr.Image(label="Image (or upload your own)", type="pil")
-
-        with gr.Column():
-            motion_prompt = gr.Textbox(label="2. Describe the motion", lines=3,
-                                       placeholder="The aurora ripples slowly, stars twinkle, the camera drifts forward")
-            with gr.Row():
+    gr.Markdown("# Graphics Studio\n**FLUX.1-schnell** images, **LTX-Video** animation, **MusicGen** music, "
+                "**Qwen** + **Kokoro** narration.")
+
+    with gr.Tab("Image"):
+        image_prompt = gr.Textbox(label="Describe the image", lines=3,
+                                  placeholder="A breathtaking aurora over a frozen lake at night, ultra detailed")
+        with gr.Row():
+            image_seed = gr.Slider(0, MAX_SEED, value=0, step=1, label="Seed")
+            image_random = gr.Checkbox(value=True, label="Random seed")
+        image_button = gr.Button("Generate image", variant="primary")
+        image_out = gr.Image(label="Image", type="pil")
+        gr.Examples(
+            examples=[
+                ["A breathtaking aurora over a frozen lake at night, snowy mountains, ultra detailed"],
+                ["A lone lighthouse on a cliff during a thunderstorm, giant waves, cinematic lighting"],
+                ["A floating island with waterfalls at sunrise, golden clouds, fantasy landscape"],
+            ],
+            inputs=[image_prompt],
+        )
+
+    with gr.Tab("Video"):
+        with gr.Row():
+            with gr.Column():
+                scene_prompt = gr.Textbox(label="Scene", lines=3,
+                                          placeholder="A lone lighthouse on a cliff during a thunderstorm, giant waves")
+                motion_prompt = gr.Textbox(label="Motion", lines=2,
+                                           placeholder="Waves crash against the rocks, the light beam sweeps to the right")
+                music_prompt = gr.Textbox(label="Music (optional, leave empty for none)", lines=2,
+                                          placeholder="Tense orchestral strings with distant thunder")
+                want_narration = gr.Checkbox(value=False, label="Add narration")
                 seconds = gr.Slider(2, 8, value=5, step=1, label="Length (seconds)")
-            with gr.Row():
-                video_seed = gr.Slider(0, MAX_SEED, value=0, step=1, label="Seed")
-                video_random = gr.Checkbox(value=True, label="Random seed")
-            video_button = gr.Button("Animate", variant="primary")
-            video_out = gr.Video(label="Video", autoplay=False, loop=True)
-            music_prompt = gr.Textbox(label="3. Describe the music", lines=2,
-                                      placeholder="Calm ambient synth pads, slow and dreamy, night sky mood")
-            music_button = gr.Button("Add music (optional)", variant="primary")
-            narration_button = gr.Button("4. Add narration (optional)", variant="primary")
-            narration_script = gr.Textbox(label="Narration plan (start time and line)", lines=3, interactive=False)
-
-    gr.Examples(
-        examples=[
-            ["A breathtaking aurora over a frozen lake at night, snowy mountains, ultra detailed"],
-            ["A lone lighthouse on a cliff during a thunderstorm, giant waves, cinematic lighting"],
-            ["A floating island with waterfalls at sunrise, golden clouds, fantasy landscape"],
-        ],
-        inputs=[image_prompt],
-    )
+                with gr.Accordion("More options", open=False):
+                    start_image = gr.Image(label="Start image (optional; otherwise FLUX draws the scene)", type="pil")
+                    with gr.Row():
+                        video_seed = gr.Slider(0, MAX_SEED, value=0, step=1, label="Seed")
+                        video_random = gr.Checkbox(value=True, label="Random seed")
+                video_button = gr.Button("Make video", variant="primary")
+            with gr.Column():
+                video_out = gr.Video(label="Video", autoplay=False, loop=True)
+                narration_script = gr.Textbox(label="Narration (start time and line)", lines=3, interactive=False)
 
     image_button.click(make_image, [image_prompt, image_seed, image_random], [image_out, image_seed])
-    video_button.click(make_video, [image_out, image_prompt, motion_prompt, seconds, video_seed, video_random],
-                       [video_out, video_seed, silent_clip, music_track, voice_track, narration_script])
-    music_button.click(add_music, [silent_clip, music_prompt, voice_track], [video_out, music_track])
-    narration_button.click(add_narration, [silent_clip, music_track, image_prompt, motion_prompt],
-                           [video_out, narration_script, voice_track])
+    video_button.click(make_video,
+                       [start_image, scene_prompt, motion_prompt, music_prompt, want_narration, seconds,
+                        video_seed, video_random],
+                       [video_out, narration_script, video_seed])
 
 demo.queue().launch()