first commit

.gitignore

@@ -0,0 +1,4 @@
+__pycache__/
+*.pyc
+.DS_Store
+.env

README.md

@@ -1,15 +1,142 @@
 ---
-title: Cydermotion
-emoji: 📉
-colorFrom: gray
-colorTo: green
+title: My Motion Video AI
+emoji: 🎬
+colorFrom: purple
+colorTo: blue
 sdk: gradio
-sdk_version: 6.24.0
-python_version: '3.12'
 app_file: app.py
 pinned: false
-license: apache-2.0
-short_description: 'Personal AI video generator (text & image to video) '
+models:
+  - Lightricks/LTX-Video-0.9.5
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🎬 My Motion Video AI
+
+Your own AI video generator — **runs 100% in the cloud** on Hugging Face GPUs.
+Your old laptop only needs a browser. No local install, no local GPU, no cost
+to deploy.
+
+- **Model:** [LTX-Video 0.9.5 (2B)](https://huggingface.co/Lightricks/LTX-Video-0.9.5) (open source, by Lightricks)
+- **Stack:** Gradio web UI + Diffusers
+- **Hosting:** Hugging Face Space with **ZeroGPU** (free GPU in the cloud)
+- **Features:** Text-to-Video and Image-to-Video (animate a logo or title card)
+
+---
+
+## How to deploy it (free, ~20 minutes)
+
+1. **Create a Hugging Face account** → https://huggingface.co/join
+   (verify your email so you're in "good standing" and can host ZeroGPU Spaces)
+
+2. **Create a new Space:**
+   - Go to https://huggingface.co/new-space
+   - Name it e.g. `my-motion-video-ai`
+   - License: any (Apache 2.0 is fine)
+   - SDK: **Gradio**
+   - Click **Create Space**, then in **Settings → Hardware** select
+     **ZeroGPU** ⚠️ (free GPU). The README also requests it via
+     `hardware: {accelerator: zero-gpu}` when you push these files.
+
+   > Note: ZeroGPU hosting needs an account in good standing — verified email
+   > and account older than 30 days. If you just created the account, it may
+   > take a few weeks before you can host a ZeroGPU Space; until then you can
+   > still use *other* public ZeroGPU Spaces, or ask me to point you at ready-made ones.
+
+3. **Upload these files.** Either:
+   - Use the **Files** tab → "Add file" → upload `app.py`, `requirements.txt`,
+     `README.md` (replace the auto-generated README), or
+   - Push from your laptop with git:
+     ```bash
+     git init
+     git add .
+     git commit -m "initial"
+     git remote add origin https://huggingface.co/spaces/<your-username>/<space-name>
+     git push --force
+     ```
+
+4. **Wait for the build** (the model is downloaded automatically at build time
+   thanks to the `models:` key in this README). Then open the app — it's live
+   at `https://huggingface.co/spaces/<your-username>/<space-name>`.
+
+That's it. The app is **your** AI, hosted on their GPU, reachable from any
+browser, on any device, forever (as long as the Space stays public/free).
+
+---
+
+## ⚠️ The real limits (read this — it saves disappointment)
+
+| Account | Free GPU per day | Note |
+|---|---|---|
+| No account | 2 minutes | Low queue priority |
+| Free account | **5 minutes** | Resets 24h after first use each day |
+| PRO ($9/mo) | 40 minutes + credits | Highest queue priority |
+
+(Data from the official [ZeroGPU docs](https://huggingface.co/docs/hub/en/spaces-zerogpu),
+Aug 2026. Free accounts can host up to 2 ZeroGPU Spaces.)
+
+- One short clip (~5s, 30 steps) consumes roughly **1–2 minutes** of that quota,
+  so a free account realistically gets **~3–5 videos per day**.
+- Queue priority is based on remaining quota — use your quota early in the day.
+- There is **no unlimited free tier anywhere** for video generation. GPUs are
+  expensive; that's physics, not a scam.
+
+---
+
+## How to use it well
+
+### Prompting tips (motion graphics)
+- Describe the scene **and** the motion: *"glossy chrome sphere rotating slowly,
+  volumetric lighting, dark studio"*.
+- Keep clips short (~5s, 121 frames) — LTX-Video shines at short, single-shot clips.
+- More inference steps (40–50) = better quality but slower and more quota.
+- Reuse a **seed** to reproduce a video and iterate on it.
+
+### Kinetic typography / logos (the pro move)
+Text rendering in video models is unreliable. Instead:
+1. Generate the title/logo as an **image** (free tools: Stable Diffusion in a
+   free Space, or Google AI Studio for images).
+2. Switch the app to **Image to Video**, upload it, and prompt for motion:
+   *"logo rotating in 3D, smooth, reflective floor, cinematic lighting"*.
+
+### Sample prompts
+- **3D-style:** `Cinematic 3D render, glossy chrome sphere rotating on a dark studio background, volumetric lighting, smooth slow motion, octane render, 8k`
+- **Abstract loop:** `Seamless abstract loop, flowing liquid metal, iridescent gradient colors, dark background, smooth hypnotic motion`
+- **Kinetic typography:** `Kinetic typography, the word MOTION exploding into view letter by letter, bold neon glowing letters, dark background, energetic dynamic camera`
+
+---
+
+## Phase 2: training it on YOUR style (optional, later)
+
+"Training your own" realistically means **fine-tuning / LoRA** on top of an
+existing open model. For LTX-Video, the official trainer is
+[`ltx-video` (ltx-trainer)](https://github.com/Lightricks/ltx-video).
+
+- **What you need:** ~10–50 of your own motion-graphics clips, a few hours of
+  rented GPU, and some patience.
+- **Cheapest real path:** rent a GPU for a few hours (~$0.5–2/hr at providers
+  like RunPod/Vast.ai; Google Colab free is too slow/limited for this).
+- **Cost honesty:** fine-tuning a video model from *scratch* costs tens of
+  thousands of dollars — nobody does that. Fine-tuning on top of LTX-Video or
+  Wan 2.2 is the legitimate, achievable version.
+- **Do Phase 1 first.** The base model already handles 3D-style shots, abstract
+  loops, and kinetic typography — you may never need Phase 2.
+
+---
+
+## FAQ
+
+**My laptop is old / low spec. Does that matter?**
+No. The app runs on Hugging Face's GPU. Your laptop just opens a web page.
+
+**Is this really free?**
+Deploying and running the Space is free. Generation is limited by the 5
+min/day free GPU quota above.
+
+**I want "unlimited".**
+Then you'll pay eventually — the cheapest legit path is HF PRO ($9/mo, 40 min
+GPU/day + credits) or renting a GPU for batch jobs. Anyone promising unlimited
+free video AI is either lying or harvesting your data.
+
+**Can others use my app?**
+Yes — if the Space is public, anyone with the link can use it (consuming your
+daily quota). Make it private if it's just for you.

app.py

@@ -0,0 +1,256 @@
+"""My Motion Video AI — LTX-Video (text-to-video + image-to-video) on ZeroGPU.
+
+Deploy as a Hugging Face Space with the ZeroGPU hardware option selected.
+Everything runs in the cloud: your laptop only needs a browser.
+"""
+
+import os
+import random
+import tempfile
+
+import gradio as gr
+import spaces
+
+# The 2B LTX-Video checkpoint (0.9.5): much lighter than the 13B main repo
+# (~15GB bf16 vs ~38GB), so it fits the 48GB ZeroGPU slice comfortably.
+# Un-gated, official diffusers structure, supports text-to-video + image-to-video.
+MODEL_ID = "Lightricks/LTX-Video-0.9.5"
+
+DEFAULT_NEGATIVE = (
+    "worst quality, inconsistent motion, blurry, jittery, distorted, "
+    "low resolution, watermark, flicker"
+)
+
+RESOLUTIONS = {
+    "Landscape 768x512": (768, 512),
+    "Portrait 512x768": (512, 768),
+    "Square 768x768": (768, 768),
+    "Square 512x512": (512, 512),
+}
+
+FPS = 24
+
+# Pipelines are loaded lazily on the first generation (the model files are
+# prefetched at build time via the `models:` key in README.md, so this only
+# loads them into GPU memory once). Keeps the Space from OOM-ing at startup.
+_text_pipe = None
+_image_pipe = None
+
+
+def _load_pipes():
+    """Load the text-to-video and image-to-video pipelines once, then reuse."""
+    global _text_pipe, _image_pipe
+
+    import torch
+    from diffusers import LTXImageToVideoPipeline, LTXPipeline
+
+    if _text_pipe is None:
+        _text_pipe = LTXPipeline.from_pretrained(MODEL_ID, torch_dtype=torch.bfloat16)
+        _text_pipe.to("cuda")
+        _text_pipe.vae.enable_slicing()
+        _text_pipe.vae.enable_tiling()
+
+    if _image_pipe is None:
+        _image_pipe = LTXImageToVideoPipeline.from_pretrained(
+            MODEL_ID, torch_dtype=torch.bfloat16
+        )
+        _image_pipe.to("cuda")
+        _image_pipe.vae.enable_slicing()
+        _image_pipe.vae.enable_tiling()
+
+    return _text_pipe, _image_pipe
+
+
+def _get_duration(
+    prompt, negative_prompt, mode, input_image, num_frames, resolution, seed, num_steps, guidance
+):
+    """Return the GPU runtime budget for this call (seconds).
+
+    ZeroGPU charges quota based on this reservation, so keep it tight.
+    The first call also loads the model into GPU memory, so give it more room.
+    """
+    if _text_pipe is None:
+        return 240  # first call: model load + generation
+    return max(45, int(num_steps * 1.5) + 15)
+
+
+@spaces.GPU(duration=_get_duration)
+def generate_video(
+    prompt,
+    negative_prompt,
+    mode,
+    input_image,
+    num_frames,
+    resolution,
+    seed,
+    num_steps,
+    guidance,
+):
+    """Generate a video from a text prompt (or an image + prompt)."""
+    import torch
+    from diffusers.utils import export_to_video
+
+    if not prompt or not prompt.strip():
+        raise gr.Error("Please write a prompt first.")
+
+    negative_prompt = (negative_prompt or "").strip() or DEFAULT_NEGATIVE
+    width, height = RESOLUTIONS[resolution]
+
+    seed = int(seed)  # gr.Number returns a float
+    if seed < 0:
+        seed = random.randint(0, 2**31 - 1)
+    generator = torch.Generator(device="cuda").manual_seed(seed)
+
+    text_pipe, image_pipe = _load_pipes()
+
+    # Timestep-aware VAE settings recommended for LTX-Video 0.9.1+.
+    decode_kwargs = {"decode_timestep": 0.05, "decode_noise_scale": 0.025}
+
+    if mode == "Image to Video":
+        if input_image is None:
+            raise gr.Error("Upload an image to use Image-to-Video mode.")
+        result = image_pipe(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            image=input_image,
+            num_frames=num_frames,
+            height=height,
+            width=width,
+            num_inference_steps=num_steps,
+            guidance_scale=guidance,
+            image_cond_noise_scale=0.025,
+            generator=generator,
+            **decode_kwargs,
+        )
+    else:
+        result = text_pipe(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            num_frames=num_frames,
+            height=height,
+            width=width,
+            num_inference_steps=num_steps,
+            guidance_scale=guidance,
+            generator=generator,
+            **decode_kwargs,
+        )
+
+    frames = result.frames[0]
+    out_path = os.path.join(
+        tempfile.gettempdir(), f"ltx_{seed}_{random.randint(0, 99999)}.mp4"
+    )
+    export_to_video(frames, out_path, fps=FPS)
+    return out_path
+
+
+PROMPT_EXAMPLES = [
+    "Cinematic 3D render, glossy chrome sphere rotating on a dark studio background, volumetric lighting, smooth slow motion, octane render, 8k",
+    "Seamless abstract loop, flowing liquid metal, iridescent gradient colors, dark background, smooth hypnotic motion",
+    "Kinetic typography, the word MOTION exploding into view letter by letter, bold neon glowing letters, dark background, energetic dynamic camera",
+]
+
+with gr.Blocks(title="My Motion Video AI", theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        """# 🎬 My Motion Video AI
+
+Your own video generation AI, running 100% in the cloud on Hugging Face GPUs
+(open-source **LTX-Video**). Your laptop never does the work.
+
+> **Free tier limit:** ~5 minutes of GPU per day (resets 24h after first use).
+> One short clip ≈ 1–2 minutes of that. Choose your prompts wisely!
+"""
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            mode = gr.Radio(
+                ["Text to Video", "Image to Video"],
+                value="Text to Video",
+                label="Mode",
+                info="Image to Video animates an uploaded image — great for kinetic typography and logos.",
+            )
+            prompt = gr.Textbox(
+                lines=3,
+                label="Prompt",
+                placeholder="Describe the motion graphics you want...",
+                info="Describe the scene AND the motion. Short clips work best.",
+            )
+            negative_prompt = gr.Textbox(
+                lines=2,
+                label="Negative prompt (optional)",
+                placeholder=DEFAULT_NEGATIVE,
+            )
+            input_image = gr.Image(
+                type="pil",
+                label="Starting image (Image to Video only)",
+                visible=False,
+            )
+
+            with gr.Accordion("Settings", open=False):
+                num_frames = gr.Slider(
+                    minimum=49,
+                    maximum=241,
+                    value=121,
+                    step=8,
+                    label="Frames (121 ≈ 5 seconds)",
+                )
+                resolution = gr.Dropdown(
+                    list(RESOLUTIONS.keys()),
+                    value="Landscape 768x512",
+                    label="Resolution",
+                )
+                num_steps = gr.Slider(
+                    minimum=10,
+                    maximum=50,
+                    value=30,
+                    step=1,
+                    label="Inference steps (more = slower but higher quality)",
+                )
+                guidance = gr.Slider(
+                    minimum=1.0,
+                    maximum=6.0,
+                    value=3.0,
+                    step=0.5,
+                    label="Guidance scale (how strictly it follows the prompt)",
+                )
+                seed = gr.Number(
+                    value=-1,
+                    label="Seed (-1 = random, reuse a seed to reproduce a video)",
+                )
+
+            generate_btn = gr.Button("🎬 Generate video", variant="primary")
+
+        with gr.Column(scale=1):
+            output_video = gr.Video(
+                label="Your video", format="mp4", autoplay=False
+            )
+            gr.Examples(
+                examples=PROMPT_EXAMPLES,
+                inputs=prompt,
+                label="Try one of these",
+            )
+
+    def toggle_image_visibility(selected_mode):
+        return gr.update(visible=(selected_mode == "Image to Video"))
+
+    mode.change(toggle_image_visibility, inputs=mode, outputs=input_image)
+
+    generate_btn.click(
+        generate_video,
+        inputs=[
+            prompt,
+            negative_prompt,
+            mode,
+            input_image,
+            num_frames,
+            resolution,
+            seed,
+            num_steps,
+            guidance,
+        ],
+        outputs=output_video,
+    )
+
+
+if __name__ == "__main__":
+    demo.queue().launch()

requirements.txt

@@ -0,0 +1,11 @@
+gradio>=5.0
+diffusers>=0.33.0
+transformers>=4.46.0
+accelerate>=0.34.0
+torch>=2.8.0
+safetensors>=0.4.5
+imageio>=2.35.0
+imageio-ffmpeg>=0.5.0
+pillow>=10.0.0
+spaces>=0.28.0
+huggingface_hub>=0.26.0