Initial turbo Space: ZeroGPU-compatible LTX-2.3 with FP8 quantization and two-phase GPU leasing

README.md

@@ -1,13 +1,70 @@
 ---
-title: LTX 2.3 Turbo
-emoji: 🚀
-colorFrom: red
-colorTo: gray
+title: LTX-2.3 Turbo
+emoji: ⚡
+colorFrom: purple
+colorTo: blue
 sdk: gradio
-sdk_version: 6.8.0
+sdk_version: 5.23.0
 python_version: '3.12'
 app_file: app.py
 pinned: false
+license: other
+license_name: ltx-2-community-license-agreement
+license_link: https://github.com/Lightricks/LTX-2/blob/main/LICENSE
+short_description: LTX-2.3 video+audio generation on free ZeroGPU
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# LTX-2.3 Turbo (ZeroGPU)
+
+Generate synchronized **video + audio** from text or images using
+[Lightricks/LTX-2.3](https://huggingface.co/Lightricks/LTX-2.3) — a 22B
+parameter DiT-based audio-video foundation model — running on **free ZeroGPU**
+hardware.
+
+## How it works
+
+This Space uses a **two-phase GPU leasing** strategy to run the massive 22B
+model on ZeroGPU's limited hardware:
+
+1. **Phase 1 — Text Encoding**: A short GPU lease loads the Gemma-3 12B text
+   encoder, encodes the prompt into context tensors, then frees the encoder.
+2. **Phase 2 — Video Generation**: A longer GPU lease loads the FP8-quantized
+   transformer (~22GB vs ~44GB in bf16), runs two-stage distilled denoising
+   (8 steps low-res + 4 steps high-res with 2x spatial upscaling), then
+   decodes video and audio.
+
+### Key optimizations for ZeroGPU
+
+- **FP8 quantization**: Transformer weights are cast to `float8_e4m3fn`,
+  halving VRAM usage with minimal quality impact.
+- **Two-phase GPU leasing**: Text encoding and video generation use separate
+  `@spaces.GPU()` calls, so the text encoder and transformer never coexist
+  in VRAM simultaneously.
+- **Distilled pipeline**: Only 8+4 denoising steps (vs 30+ for the full model),
+  dramatically reducing inference time.
+
+## Parameters
+
+| Parameter | Range | Default | Notes |
+|-----------|-------|---------|-------|
+| Mode | Text to Video / Image to Video | Text to Video | |
+| Prompt | Free text | — | Describe scene, motion, and audio |
+| Resolution | 768x512, 512x512, 512x768 | 768x512 | Upscaled 2x by spatial upscaler |
+| Duration | 1–5 seconds | 2s | Shorter = more reliable on ZeroGPU |
+| Enhance prompt | On/Off | On | Uses Gemma to enhance the prompt |
+| Seed | 0–2^31 | Random | For reproducibility |
+
+## Limitations
+
+- **ZeroGPU time limits**: Longer videos may exceed the GPU lease duration.
+  Keep duration at 3 seconds or less for best reliability.
+- **VRAM constraints**: Even with FP8 quantization, very high resolutions
+  are not possible. The preset resolutions are tuned for ZeroGPU.
+- **No audio conditioning**: This simplified interface doesn't support
+  custom audio input (the full model does).
+
+## Credits
+
+- Model: [Lightricks/LTX-2.3](https://huggingface.co/Lightricks/LTX-2.3)
+- Codebase: [Lightricks/LTX-2](https://github.com/Lightricks/LTX-2)
+- ZeroGPU architecture inspired by [alexnasa/ltx-2-TURBO](https://huggingface.co/spaces/alexnasa/ltx-2-TURBO)

app.py

@@ -0,0 +1,612 @@
+"""
+LTX-2.3 Turbo — ZeroGPU Edition
+Generates synchronized audio-video content using Lightricks/LTX-2.3 on
+free ZeroGPU hardware via Hugging Face Spaces.
+
+Architecture (ZeroGPU-compatible, two-phase GPU leasing):
+  1. Model files are downloaded at module startup (CPU, no GPU lease).
+  2. ModelLedger is constructed once, with gemma_root for text encoding.
+  3. Phase 1 (@spaces.GPU): encode_prompt — loads Gemma text encoder,
+     encodes prompt, frees encoder. Returns pre-encoded context tensors.
+  4. Phase 2 (@spaces.GPU): generate_video — loads transformer, video
+     encoder, spatial upsampler. Runs two-stage distilled denoising with
+     pre-encoded contexts. Decodes video+audio. Returns output file.
+  5. FP8 quantization is used for the transformer to fit ~22GB (from ~44GB
+     in bf16), enabling inference on A100-40GB ZeroGPU allocations.
+
+Based on the official LTX-2 codebase: https://github.com/Lightricks/LTX-2
+Inspired by alexnasa/ltx-2-TURBO's ZeroGPU architecture.
+"""
+
+import gc
+import logging
+import os
+import random
+import tempfile
+import time
+import traceback
+from pathlib import Path
+
+import gradio as gr
+import numpy as np
+import spaces
+import torch
+from huggingface_hub import hf_hub_download, snapshot_download
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+MAX_SEED = np.iinfo(np.int32).max
+LTX_REPO = "Lightricks/LTX-2.3"
+GEMMA_REPO = "google/gemma-3-12b-it-qat-q4_0-unquantized"
+CKPT_DISTILLED = "ltx-2.3-22b-distilled.safetensors"
+CKPT_UPSCALER = "ltx-2.3-spatial-upscaler-x2-1.0.safetensors"
+
+# Distilled pipeline sigma schedules (from official LTX-2 constants)
+DISTILLED_SIGMA_VALUES = [
+    1.0,
+    0.99375,
+    0.9875,
+    0.98125,
+    0.975,
+    0.909375,
+    0.725,
+    0.421875,
+    0.0,
+]
+STAGE_2_DISTILLED_SIGMA_VALUES = [0.909375, 0.725, 0.421875, 0.0]
+
+# Resolution presets: (label, width, height)
+RESOLUTION_PRESETS = {
+    "16:9 (768x512)": (768, 512),
+    "1:1 (512x512)": (512, 512),
+    "9:16 (512x768)": (512, 768),
+}
+
+# ---------------------------------------------------------------------------
+# 1) Download model files at module startup (CPU, no GPU lease)
+# ---------------------------------------------------------------------------
+logger.info("Downloading LTX model files...")
+DISTILLED_PATH = hf_hub_download(repo_id=LTX_REPO, filename=CKPT_DISTILLED)
+logger.info(f"  Distilled checkpoint: {DISTILLED_PATH}")
+UPSCALER_PATH = hf_hub_download(repo_id=LTX_REPO, filename=CKPT_UPSCALER)
+logger.info(f"  Upscaler: {UPSCALER_PATH}")
+
+logger.info("Downloading Gemma text encoder...")
+HF_TOKEN = os.environ.get("HF_TOKEN")
+GEMMA_ROOT = snapshot_download(repo_id=GEMMA_REPO, token=HF_TOKEN)
+logger.info(f"  Gemma root: {GEMMA_ROOT}")
+logger.info("All model files ready on disk.")
+
+# ---------------------------------------------------------------------------
+# 2) Build ModelLedger (CPU — no model weights loaded to GPU yet)
+# ---------------------------------------------------------------------------
+logger.info("Constructing ModelLedger...")
+from ltx_core.components.diffusion_steps import EulerDiffusionStep
+from ltx_core.components.noisers import GaussianNoiser
+from ltx_core.components.protocols import DiffusionStepProtocol
+from ltx_core.model.audio_vae import decode_audio as vae_decode_audio
+from ltx_core.model.upsampler import upsample_video
+from ltx_core.model.video_vae import TilingConfig, get_video_chunks_number
+from ltx_core.model.video_vae import decode_video as vae_decode_video
+from ltx_core.quantization import QuantizationPolicy
+from ltx_core.types import LatentState, VideoPixelShape
+from ltx_pipelines.utils import ModelLedger, euler_denoising_loop
+from ltx_pipelines.utils.args import ImageConditioningInput
+from ltx_pipelines.utils.helpers import (
+    assert_resolution,
+    cleanup_memory,
+    combined_image_conditionings,
+    denoise_audio_video,
+    encode_prompts,
+    simple_denoising_func,
+)
+from ltx_pipelines.utils.media_io import encode_video
+from ltx_pipelines.utils.types import PipelineComponents
+
+# Use FP8 quantization to reduce transformer VRAM from ~44GB to ~22GB
+fp8_quantization = QuantizationPolicy.fp8_cast()
+
+model_ledger = ModelLedger(
+    dtype=torch.bfloat16,
+    device=torch.device("cuda"),
+    checkpoint_path=DISTILLED_PATH,
+    spatial_upsampler_path=UPSCALER_PATH,
+    gemma_root_path=GEMMA_ROOT,
+    loras=(),
+    quantization=fp8_quantization,
+)
+
+pipeline_components = PipelineComponents(
+    dtype=torch.bfloat16,
+    device=torch.device("cuda"),
+)
+
+logger.info("ModelLedger constructed (no GPU memory used yet).")
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+def align64(v: int) -> int:
+    """Round to nearest multiple of 64 (min 64) for two-stage pipeline."""
+    return max(64, int(round(int(v) / 64)) * 64)
+
+
+def calc_frames(duration: float, fps: float) -> int:
+    """Compute num_frames satisfying: frames = 8k + 1, frames >= 9."""
+    raw = int(duration * fps) + 1
+    raw = max(raw, 9)
+    k = (raw - 1 + 7) // 8
+    return k * 8 + 1
+
+
+def gpu_memory_info() -> str:
+    """Return a brief GPU memory summary."""
+    if not torch.cuda.is_available():
+        return "No GPU"
+    alloc = torch.cuda.memory_allocated() / 1024**3
+    total = torch.cuda.get_device_properties(0).total_mem / 1024**3
+    return f"{alloc:.1f} / {total:.1f} GB"
+
+
+def get_gpu_duration(duration_seconds: float, has_image: bool) -> int:
+    """Estimate GPU lease duration in seconds based on video parameters."""
+    # Base time: ~60s for short videos, scales up with duration
+    base = 90
+    per_second = 30  # ~30s GPU time per second of video
+    extra = 30 if has_image else 0
+    return min(int(base + duration_seconds * per_second + extra), 300)
+
+
+# ---------------------------------------------------------------------------
+# Phase 1: Text Encoding (separate GPU lease)
+# ---------------------------------------------------------------------------
+@spaces.GPU(duration=120)
+@torch.inference_mode()
+def encode_prompt_gpu(prompt: str, enhance_prompt: bool, image_path: str | None = None):
+    """
+    Load Gemma text encoder, encode prompt, free encoder.
+    Returns (video_context, audio_context) tensors.
+    """
+    logger.info(f"[Phase 1] Encoding prompt on GPU: {gpu_memory_info()}")
+    logger.info(f"  prompt='{prompt[:80]}...', enhance={enhance_prompt}")
+
+    (ctx,) = encode_prompts(
+        [prompt],
+        model_ledger,
+        enhance_first_prompt=enhance_prompt,
+        enhance_prompt_image=image_path,
+    )
+    video_context = ctx.video_encoding
+    audio_context = ctx.audio_encoding
+
+    logger.info(
+        f"[Phase 1] Encoding complete. "
+        f"video_context: {video_context.shape}, audio_context: {audio_context.shape}, "
+        f"GPU: {gpu_memory_info()}"
+    )
+    return video_context, audio_context
+
+
+# ---------------------------------------------------------------------------
+# Phase 2: Video Generation (separate GPU lease, dynamic duration)
+# ---------------------------------------------------------------------------
+@spaces.GPU(duration=240)
+@torch.inference_mode()
+def generate_video_gpu(
+    video_context: torch.Tensor,
+    audio_context: torch.Tensor,
+    seed: int,
+    height: int,
+    width: int,
+    num_frames: int,
+    frame_rate: float,
+    images: list,
+    output_path: str,
+):
+    """
+    Run two-stage distilled denoising with pre-encoded contexts.
+    Replicates DistilledPipeline.__call__ but uses pre-encoded video_context
+    and audio_context instead of calling encode_prompts internally.
+    """
+    logger.info(f"[Phase 2] Starting generation on GPU: {gpu_memory_info()}")
+
+    device = torch.device("cuda")
+    dtype = torch.bfloat16
+    generator = torch.Generator(device=device).manual_seed(seed)
+    noiser = GaussianNoiser(generator=generator)
+    stepper = EulerDiffusionStep()
+
+    # ------ Stage 1: Low-res generation (half resolution) ------
+    logger.info("[Phase 2] Stage 1: Low-res generation...")
+    video_encoder = model_ledger.video_encoder()
+    transformer = model_ledger.transformer()
+    stage_1_sigmas = torch.Tensor(DISTILLED_SIGMA_VALUES).to(device)
+
+    def denoising_loop(
+        sigmas: torch.Tensor,
+        video_state: LatentState,
+        audio_state: LatentState,
+        stepper_arg: DiffusionStepProtocol,
+    ) -> tuple[LatentState, LatentState]:
+        return euler_denoising_loop(
+            sigmas=sigmas,
+            video_state=video_state,
+            audio_state=audio_state,
+            stepper=stepper_arg,
+            denoise_fn=simple_denoising_func(
+                video_context=video_context,
+                audio_context=audio_context,
+                transformer=transformer,
+            ),
+        )
+
+    stage_1_output_shape = VideoPixelShape(
+        batch=1,
+        frames=num_frames,
+        width=width // 2,
+        height=height // 2,
+        fps=frame_rate,
+    )
+
+    # Convert image paths back to ImageConditioningInput objects
+    image_conditionings = []
+    for img_data in images:
+        img_input = ImageConditioningInput(
+            path=img_data["path"],
+            frame_idx=img_data["frame_idx"],
+            strength=img_data["strength"],
+        )
+        image_conditionings.append(img_input)
+
+    stage_1_conditionings = combined_image_conditionings(
+        images=image_conditionings,
+        height=stage_1_output_shape.height,
+        width=stage_1_output_shape.width,
+        video_encoder=video_encoder,
+        dtype=dtype,
+        device=device,
+    )
+
+    video_state, audio_state = denoise_audio_video(
+        output_shape=stage_1_output_shape,
+        conditionings=stage_1_conditionings,
+        noiser=noiser,
+        sigmas=stage_1_sigmas,
+        stepper=stepper,
+        denoising_loop_fn=denoising_loop,
+        components=pipeline_components,
+        dtype=dtype,
+        device=device,
+    )
+
+    logger.info(f"[Phase 2] Stage 1 complete. GPU: {gpu_memory_info()}")
+
+    # ------ Stage 2: Upsample + refine at full resolution ------
+    logger.info("[Phase 2] Stage 2: Upsampling + refinement...")
+    upscaled_video_latent = upsample_video(
+        latent=video_state.latent[:1],
+        video_encoder=video_encoder,
+        upsampler=model_ledger.spatial_upsampler(),
+    )
+
+    torch.cuda.synchronize()
+    cleanup_memory()
+
+    stage_2_sigmas = torch.Tensor(STAGE_2_DISTILLED_SIGMA_VALUES).to(device)
+    stage_2_output_shape = VideoPixelShape(
+        batch=1, frames=num_frames, width=width, height=height, fps=frame_rate
+    )
+    stage_2_conditionings = combined_image_conditionings(
+        images=image_conditionings,
+        height=stage_2_output_shape.height,
+        width=stage_2_output_shape.width,
+        video_encoder=video_encoder,
+        dtype=dtype,
+        device=device,
+    )
+
+    video_state, audio_state = denoise_audio_video(
+        output_shape=stage_2_output_shape,
+        conditionings=stage_2_conditionings,
+        noiser=noiser,
+        sigmas=stage_2_sigmas,
+        stepper=stepper,
+        denoising_loop_fn=denoising_loop,
+        components=pipeline_components,
+        dtype=dtype,
+        device=device,
+        noise_scale=stage_2_sigmas[0],
+        initial_video_latent=upscaled_video_latent,
+        initial_audio_latent=audio_state.latent,
+    )
+
+    logger.info(f"[Phase 2] Stage 2 complete. GPU: {gpu_memory_info()}")
+
+    # ------ Decode video + audio ------
+    logger.info("[Phase 2] Decoding video and audio...")
+    torch.cuda.synchronize()
+    del transformer
+    del video_encoder
+    cleanup_memory()
+
+    tiling_config = TilingConfig.default()
+    decoded_video = vae_decode_video(
+        video_state.latent, model_ledger.video_decoder(), tiling_config, generator
+    )
+    decoded_audio = vae_decode_audio(
+        audio_state.latent, model_ledger.audio_decoder(), model_ledger.vocoder()
+    )
+
+    video_chunks_number = get_video_chunks_number(num_frames, tiling_config)
+    encode_video(
+        video=decoded_video,
+        fps=int(frame_rate),
+        audio=decoded_audio,
+        output_path=output_path,
+        video_chunks_number=video_chunks_number,
+    )
+
+    logger.info(f"[Phase 2] Video saved to {output_path}. GPU: {gpu_memory_info()}")
+    return output_path
+
+
+# ---------------------------------------------------------------------------
+# Main generate function (orchestrates Phase 1 + Phase 2)
+# ---------------------------------------------------------------------------
+def generate(
+    mode: str,
+    input_image,
+    prompt: str,
+    duration: float,
+    enhance_prompt: bool,
+    seed: int,
+    randomize_seed: bool,
+    resolution: str,
+    progress=gr.Progress(track_tqdm=True),
+):
+    if mode == "Image to Video" and input_image is None:
+        raise gr.Error("Please upload an image for Image to Video mode.")
+    if not prompt or not prompt.strip():
+        raise gr.Error("Please enter a prompt.")
+
+    # --- Resolve params ---
+    current_seed = random.randint(0, MAX_SEED) if randomize_seed else int(seed)
+    width, height = RESOLUTION_PRESETS.get(resolution, (768, 512))
+    num_frames = calc_frames(duration, 24.0)
+    fps = 24.0
+
+    output_dir = Path(tempfile.mkdtemp())
+    stamp = int(time.time())
+    output_path = str(output_dir / f"ltx23_turbo_{current_seed}_{stamp}.mp4")
+
+    # --- Handle input image ---
+    images_data = []
+    image_path_for_enhance = None
+    if mode == "Image to Video" and input_image is not None:
+        temp_image_path = str(output_dir / f"input_{stamp}.jpg")
+        if hasattr(input_image, "save"):
+            input_image.save(temp_image_path)
+        else:
+            from PIL import Image as PILImage
+
+            PILImage.open(input_image).save(temp_image_path)
+        images_data = [{"path": temp_image_path, "frame_idx": 0, "strength": 1.0}]
+        image_path_for_enhance = temp_image_path
+
+    logger.info(
+        f"Request: seed={current_seed}, {width}x{height}, "
+        f"frames={num_frames}, fps={fps}, enhance={enhance_prompt}, "
+        f"mode={mode}, duration={duration}s"
+    )
+
+    t0 = time.time()
+    try:
+        # Phase 1: Encode prompt (separate GPU lease)
+        video_context, audio_context = encode_prompt_gpu(
+            prompt=prompt,
+            enhance_prompt=enhance_prompt,
+            image_path=image_path_for_enhance,
+        )
+
+        # Phase 2: Generate video (separate GPU lease)
+        generate_video_gpu(
+            video_context=video_context,
+            audio_context=audio_context,
+            seed=current_seed,
+            height=height,
+            width=width,
+            num_frames=num_frames,
+            frame_rate=fps,
+            images=images_data,
+            output_path=output_path,
+        )
+
+        elapsed = time.time() - t0
+        logger.info(f"Total generation time: {elapsed:.1f}s")
+
+    except torch.cuda.OutOfMemoryError:
+        elapsed = time.time() - t0
+        logger.error(f"OOM after {elapsed:.1f}s")
+        raise gr.Error("Out of GPU memory. Try a shorter duration or lower resolution.")
+    except Exception as e:
+        elapsed = time.time() - t0
+        tb = traceback.format_exc()
+        logger.error(f"Generation failed after {elapsed:.1f}s:\n{tb}")
+        raise gr.Error(f"Generation failed: {type(e).__name__}: {e}")
+
+    info_text = (
+        f"Seed: {current_seed}\n"
+        f"Resolution: {width}x{height} (upscaled from {width // 2}x{height // 2})\n"
+        f"Frames: {num_frames} @ {int(fps)} fps\n"
+        f"Duration: {duration}s\n"
+        f"Pipeline: Distilled 2-stage (8+4 steps, FP8 quantized)\n"
+        f"Total time: {elapsed:.1f}s\n"
+        f"Hardware: ZeroGPU"
+    )
+
+    return output_path, info_text, current_seed
+
+
+# ---------------------------------------------------------------------------
+# UI toggle
+# ---------------------------------------------------------------------------
+def toggle_image(mode: str):
+    return gr.update(visible=(mode == "Image to Video"))
+
+
+# ---------------------------------------------------------------------------
+# Gradio UI
+# ---------------------------------------------------------------------------
+CSS = """
+.gradio-container { max-width: 1200px !important; }
+.header { text-align: center; margin-bottom: 1rem; }
+.generate-btn { min-height: 50px; }
+"""
+
+with gr.Blocks(css=CSS, title="LTX-2.3 Turbo", theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        """
+        # LTX-2.3 Turbo (ZeroGPU)
+        Generate synchronized **video + audio** from text or images using
+        [Lightricks/LTX-2.3](https://huggingface.co/Lightricks/LTX-2.3) —
+        a 22B parameter DiT-based audio-video foundation model.
+
+        Running on **free ZeroGPU** with FP8 quantization.
+        Distilled pipeline (8+4 denoising steps, two-stage with 2x spatial upscaling).
+        """,
+        elem_classes="header",
+    )
+
+    with gr.Row():
+        # --- Left: Controls ---
+        with gr.Column(scale=1):
+            mode = gr.Radio(
+                ["Text to Video", "Image to Video"],
+                value="Text to Video",
+                label="Mode",
+            )
+            input_image = gr.Image(
+                type="pil",
+                label="Input Image",
+                visible=False,
+            )
+            prompt = gr.Textbox(
+                label="Prompt",
+                lines=3,
+                placeholder="Describe the scene, motion, and audio...",
+                value=(
+                    "A golden retriever puppy plays in fresh snow, "
+                    "tossing it up with its paws, soft winter sunlight, "
+                    "gentle wind sounds and playful barking"
+                ),
+            )
+
+            with gr.Row():
+                resolution = gr.Dropdown(
+                    choices=list(RESOLUTION_PRESETS.keys()),
+                    value="16:9 (768x512)",
+                    label="Resolution",
+                )
+                duration = gr.Slider(1, 5, value=2, step=0.5, label="Duration (sec)")
+
+            with gr.Row():
+                enhance_prompt = gr.Checkbox(value=True, label="Enhance prompt")
+                randomize_seed = gr.Checkbox(value=True, label="Random seed")
+
+            seed = gr.Slider(0, MAX_SEED, value=42, step=1, label="Seed")
+
+            generate_btn = gr.Button(
+                "Generate Video",
+                variant="primary",
+                size="lg",
+                elem_classes="generate-btn",
+            )
+
+        # --- Right: Output ---
+        with gr.Column(scale=1):
+            output_video = gr.Video(label="Generated Video", autoplay=True)
+            run_info = gr.Textbox(label="Generation Info", lines=7, interactive=False)
+
+    # --- Events ---
+    mode.change(fn=toggle_image, inputs=mode, outputs=[input_image])
+
+    _inputs = [
+        mode,
+        input_image,
+        prompt,
+        duration,
+        enhance_prompt,
+        seed,
+        randomize_seed,
+        resolution,
+    ]
+    _outputs = [output_video, run_info, seed]
+
+    generate_btn.click(fn=generate, inputs=_inputs, outputs=_outputs)
+
+    # --- Examples ---
+    gr.Examples(
+        examples=[
+            [
+                "Text to Video",
+                None,
+                "Aerial drone shot of a coastal city at sunset, golden light "
+                "reflecting off glass buildings, gentle ocean waves, seagulls "
+                "calling, cinematic ambient soundtrack",
+                3.0,
+                True,
+                42,
+                True,
+                "16:9 (768x512)",
+            ],
+            [
+                "Text to Video",
+                None,
+                "Close-up of a barista pouring latte art in slow motion, "
+                "steam rising from the cup, coffee shop ambience with soft jazz",
+                2.0,
+                True,
+                123,
+                True,
+                "1:1 (512x512)",
+            ],
+            [
+                "Text to Video",
+                None,
+                "A cat sits on a windowsill watching rain fall outside, "
+                "soft indoor lighting, raindrops on glass, gentle rain sounds",
+                3.0,
+                True,
+                7,
+                True,
+                "16:9 (768x512)",
+            ],
+        ],
+        fn=generate,
+        inputs=_inputs,
+        outputs=_outputs,
+        cache_examples=False,
+        label="Example Prompts",
+    )
+
+    gr.Markdown(
+        """
+        ---
+        **Notes:**
+        - ZeroGPU provides limited GPU time per request. Shorter durations are more reliable.
+        - Max duration is capped at 5 seconds to stay within GPU time limits.
+        - FP8 quantization reduces VRAM usage by ~50% with minimal quality impact.
+        - The 2x spatial upscaler doubles the initial generation resolution.
+
+        Built with [Lightricks/LTX-2.3](https://huggingface.co/Lightricks/LTX-2.3)
+        | [GitHub](https://github.com/Lightricks/LTX-2)
+        """
+    )
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,18 @@
+gradio>=5.0
+spaces
+huggingface_hub[hf_xet]
+torch>=2.7
+torchaudio
+transformers>=4.52,<5.0
+safetensors
+accelerate
+einops
+numpy
+pillow
+scipy>=1.14
+scikit-image>=0.25.2
+av
+tqdm
+triton
+ltx-core @ git+https://github.com/Lightricks/LTX-2.git#subdirectory=packages/ltx-core
+ltx-pipelines @ git+https://github.com/Lightricks/LTX-2.git#subdirectory=packages/ltx-pipelines