Update README.md

README.md

@@ -5,50 +5,145 @@ colorFrom: blue
 colorTo: purple
 sdk: gradio
 app_file: app.py
+pinned: false
 hardware: zerogpu
 python_version: "3.10.13"
-short_description: "Realtime T2V demo via diffusers ModularPipeline"
 ---
 
-# Krea Realtime Video 14B
+# Krea Realtime Video
 
-This Space implements **real local inference** for [krea/krea-realtime-video](https://huggingface.co/krea/krea-realtime-video) using the official 🧨 Diffusers `ModularPipeline` path from the model card.
+A Hugging Face Space for generating short videos with [`krea/krea-realtime-video`](https://huggingface.co/krea/krea-realtime-video), using Diffusers `ModularPipeline` and ZeroGPU.
 
-## What it does
+This demo runs local text-to-video inference inside the Space and includes optional LoRA support for the Origami style.
 
-- **Text-to-video**: enter a prompt, choose how many blocks (≈ frames) to generate, and hit **Generate Video**.
-- The model is a 14B autoregressive video diffusion model distilled from Wan 2.1 T2V 14B.
+## Features
 
-## How to try it
+- Text-to-video generation with Krea Realtime Video 14B
+- Diffusers `ModularPipeline` integration
+- ZeroGPU-compatible runtime
+- Manual style loading before generation
+- Optional Origami LoRA support
+- Automatic `[origami]` trigger insertion when the Origami style is active
+- Adjustable video length and quality controls
+- Progress feedback during generation
 
-1. Open the **Generate Video** tab.
-2. Type a prompt (e.g. *"a cat sitting on a boat"*).
-3. Adjust **Number of Blocks** (1–9) and **Inference Steps per Block** (1–20).
-   - Lower values = faster and cheaper first test.
-4. Click **Generate Video**.
+## How to use
 
-**Example inputs**
-- `a cat sitting on a boat` (3 blocks, 4 steps, seed 42)
-- `a futuristic city at sunset` (3 blocks, 4 steps, seed 123)
-- `a panda playing guitar in a forest` (2 blocks, 4 steps, seed 7)
+1. Enter a prompt describing the video you want to generate.
+2. Optionally select a style.
+3. If you select **Origami**, click **Load style** before generating.
+4. Adjust:
+   - **Length**: number of video blocks
+   - **Quality**: inference steps per block
+   - **Seed**: reproducibility seed
+5. Click **Generate video**.
 
-## Limitations & known risks
+The generated video will appear on the right side of the interface.
 
-- **VRAM**: the 14B transformer (~28 GB in bf16) plus the UMT5-XXL text encoder (~12–14 GB) and VAE push the full pipeline well above 48 GB. Standard HF Space GPU tiers are **unlikely to fit** the model without aggressive quantization or >96 GB of VRAM.
-- **Hardware recommendation**: this demo should be run on a Space with a very large GPU (e.g. `xlarge` ZeroGPU tier or a dedicated high-memory GPU).
-- If the pipeline fails to load, the `/health` endpoint and the UI surface the **concrete load error** (OOM, CUDA init, missing import, etc.).
-- The model card’s recommended optimizations (`torch.compile`, SageAttention, FP8 quantization with `torchao`) are **not enabled** here because:
-  - `torch.compile` is [not supported on ZeroGPU](https://huggingface.co/blog/zerogpu-aoti).
-  - `flash-attn` / `kernels` / `torchao` are native-build dependencies that frequently fail in HF Space build environments.
-- We therefore rely on the **SDPA fallback** and vanilla bf16/fp16 precision.
+## Styles
 
-## Architecture
+### Base model
 
-- `app.py` loads `ModularPipeline.from_pretrained(..., trust_remote_code=True)` at module level so ZeroGPU can pack resident tensors.
-- Generation is guarded by `@spaces.GPU` and uses iterative `PipelineState` blocks exactly as the model card demonstrates.
-- Health (`api_name="health"`) is instant and never touches weights.
+Uses the original Krea Realtime Video model without any additional LoRA.
 
-## Dependencies
+### Origami
 
-- `diffusers` (main branch from GitHub)
-- `torch`, `transformers`, `accelerate`, `safetensors`, `spaces`, `gradio`, `tqdm`
+Uses the Origami LoRA adapter:
+
+[`shauray/Origami_WanLora`](https://huggingface.co/shauray/Origami_WanLora)
+
+When this style is active, the app automatically prefixes the prompt with:
+
+```text
+[origami]
+```
+
+For example, this prompt:
+
+```text
+a cat sitting on a boat
+```
+
+is internally sent as:
+
+```text
+[origami] a cat sitting on a boat
+```
+
+## Recommended settings
+
+For a balanced result:
+
+```text
+Length: 9
+Quality: 6
+Seed: any fixed integer
+```
+
+Lower values generate faster. Higher values may improve temporal consistency and visual quality, but can take longer.
+
+## Example prompts
+
+```text
+Astronaut in a jungle, cold color palette, muted colors, detailed, cinematic, 8k
+```
+
+```text
+A tiny wooden boat drifting through a misty lake at sunrise, a curious cat sitting at the front, soft cinematic lighting, calm water reflections
+```
+
+```text
+A futuristic city at sunset, flying vehicles between glass towers, neon reflections, cinematic camera movement, atmospheric haze
+```
+
+```text
+A car racing down a snowy mountain road, dramatic chase shot, powder snow flying behind the wheels, cold blue lighting, high speed motion
+```
+
+```text
+A surreal underwater library, glowing jellyfish floating between bookshelves, slow cinematic dolly shot, dreamlike atmosphere
+```
+
+Origami examples:
+
+```text
+a cat sitting on a boat
+```
+
+```text
+a dragon flying over a mountain village at sunrise, paper-folded geometry, delicate handmade texture, soft shadows
+```
+
+```text
+a small fox walking through a paper forest, handcrafted origami style, warm lantern light, cinematic close-up
+```
+
+## Implementation notes
+
+This Space uses a ZeroGPU compatibility path.
+
+The original optimized inference path for Krea Realtime Video relies on features such as `torch.compile` and optimized attention kernels. In this Space, `torch.compile` is intentionally disabled to keep the runtime compatible with ZeroGPU.
+
+The model is loaded when the Space starts. LoRA styles are loaded manually through the UI before generation, so the generation step can focus on inference.
+
+## Limitations
+
+- The demo is intended for short video generation.
+- Very long generations may be slower or less stable.
+- The Origami style must be loaded once before it can be used.
+- LoRA strength control is not exposed in the UI because the current adapter API used by this runtime does not reliably support per-adapter weights.
+- ZeroGPU compatibility may be slower than a fully optimized dedicated GPU deployment.
+
+## Model
+
+Base model:
+
+[`krea/krea-realtime-video`](https://huggingface.co/krea/krea-realtime-video)
+
+Optional LoRA:
+
+[`shauray/Origami_WanLora`](https://huggingface.co/shauray/Origami_WanLora)
+
+## Acknowledgements
+
+This Space is built on top of the Hugging Face ecosystem, including Diffusers, Gradio, PEFT, and the Hugging Face Hub.