> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/video-generierung/framepack.md).

# FramePack Video-Generierung

FramePack ist ein Durchbruch in der KI-Videoerzeugung: es kann Videos von bis zu 2 Minuten Länge erstellen mit **nur 6GB VRAM**. Basierend auf der HunyuanVideo-Architektur besteht FramePacks Hauptinnovation darin, Frames effizient zu packen, sodass der GPU-Speicher unabhängig von der Videolänge konstant bleibt. Das macht KI-Videoerzeugung auf günstigen GPUs zugänglich, die zuvor zu begrenzt waren.

## Hauptmerkmale

* **Mindestens 6GB VRAM**: Funktioniert auf RTX 3060, RTX 3070, sogar GTX 1060!
* **Bis zu 2-minütige Videos**: Konstanter VRAM-Verbrauch unabhängig von der Videolänge
* **Bild-zu-Video**: Animieren Sie jedes Bild mit einer Textaufforderung
* **Web UI enthalten**: Gradio-basierte Oberfläche für einfache Nutzung
* **Auf HunyuanVideo aufgebaut**: Nutzt Tengxuns Video-Diffusionsarchitektur
* **Open Source**: GitHub mit aktiver Entwicklung

## Anforderungen

| Komponente | Minimum      | Empfohlen     |
| ---------- | ------------ | ------------- |
| GPU        | GTX 1060 6GB | RTX 4090 24GB |
| VRAM       | 6GB          | 12GB+         |
| RAM        | 16GB         | 32GB          |
| Festplatte | 30GB         | 50GB          |
| CUDA       | 11.8+        | 12.0+         |
| Python     | 3.10+        | 3.11          |

**Empfohlene Clore.ai-GPU**: RTX 3080 10GB (\~0,2–0,5 $/Tag) — großartige Qualität zu geringen Kosten!

### Geschwindigkeitsreferenz

| GPU           | Zeit pro Frame | 60-Frame-Video (\~2s bei 30fps) |
| ------------- | -------------- | ------------------------------- |
| RTX 3060 12GB | \~30 Sek.      | \~30 Min.                       |
| RTX 3080 10GB | \~18 Sek.      | \~18 Min.                       |
| RTX 4080 16GB | \~12 Sek.      | \~12 Min.                       |
| RTX 4090 24GB | \~8 Sek.       | \~8 Min.                        |
| RTX 5090 32GB | \~5 Sek.       | \~5 Min                         |

## Installation

```bash
# Repository klonen
git clone https://github.com/lllyasviel/FramePack.git
cd FramePack

# Erstelle conda-Umgebung (empfohlen)
conda create -n framepack python=3.11 -y
conda activate framepack

# Abhängigkeiten installieren
pip install -r requirements.txt

# PyTorch mit CUDA installieren
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
```

### Docker-Einrichtung

```bash
docker run --gpus all -p 7860:7860 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  -v ./outputs:/app/outputs \
  ghcr.io/lllyasviel/framepack:latest
```

## Schnellstart — Web UI

Der einfachste Weg, FramePack zu nutzen:

```bash
cd FramePack
python app.py --port 7860

# Für niedrigen VRAM (6GB):
python app.py --port 7860 --low-vram

# Zugriff unter http://localhost:7860
```

**Web UI Ablauf:**

1. Laden Sie ein Quellbild hoch (der erste Frame)
2. Geben Sie eine Textaufforderung ein, die die Bewegung beschreibt ("Kamera zoomt langsam hinein", "Person geht nach vorne")
3. Stellen Sie die Videolänge ein (Anzahl der Frames)
4. Auf Generieren klicken
5. Laden Sie das MP4 herunter

## Verwendung

FramePack ist eine **Gradio-Webanwendung**, keine Python-Bibliothek. Die primäre Schnittstelle ist die Web-UI.

### Web UI Ablauf

1. Öffnen `http://localhost:7860` nach dem Start
2. Laden Sie ein Quellbild hoch (wird der erste Frame sein)
3. Geben Sie eine Textaufforderung ein, die die gewünschte Bewegung beschreibt
4. Legen Sie die Anzahl der Frames fest (mehr = längeres Video)
5. Klicken **Generieren** → warten → MP4 herunterladen

### API-Zugriff über Gradio Client

Sie können FramePack programmatisch über die Gradio-API aufrufen:

```python
from gradio_client import Client

# Verbindung zur laufenden FramePack-Instanz
client = Client("http://localhost:7860")

# Video aus Bild + Prompt erzeugen
result = client.predict(
    "input_photo.jpg",                              # Quellbild
    "die Person lächelt und dreht ihren Kopf langsam", # Prompt
    60,                                              # Anzahl Frames
    7.5,                                             # Guidance-Scale
    30,                                              # Inferenzschritte
    42,                                              # Seed
    api_name="/generate"
)
print(f"Video gespeichert unter: {result}")
```

### Batch-Verarbeitung mit Gradio Client

```python
from gradio_client import Client
import glob

client = Client("http://localhost:7860")

prompts = [
    ("photo1.jpg", "sanfter Kamerazoom mit weicher Beleuchtung"),
    ("photo2.jpg", "Wind weht durch die Haare, Wolken bewegen sich"),
    ("photo3.jpg", "langsames Herauszoom, das die komplette Szene zeigt"),
]

for img_path, prompt in prompts:
    result = client.predict(img_path, prompt, 60, 7.5, 30, -1, api_name="/generate")
    print(f"Fertig: {img_path} → {result}")
```

## Auflösungsleitfaden

| VRAM | Maximale Auflösung | Qualität               |
| ---- | ------------------ | ---------------------- |
| 6GB  | 512×512            | Gut für soziale Medien |
| 8GB  | 640×640            | Besserer Detailgrad    |
| 10GB | 512×768            | Porträt/Landschaft     |
| 12GB | 768×768            | Hohe Qualität          |
| 24GB | 1024×768           | Beste Qualität         |

## Tipps für Clore.ai-Nutzer

* **Budgetfreundlich**: Dies ist eines der wenigen Video-KI-Modelle, das auf günstigen GPUs funktioniert (0,15–0,3 $/Tag für RTX 3060!)
* **Verwenden Sie `--low-vram` Flag**: Wesentlich für 6–8GB GPUs — aktiviert automatisch CPU-Offloading
* **512×512 ist in Ordnung**: Für soziale Medien (TikTok, Reels) sind 512px völlig akzeptabel
* **Länger ≠ mehr VRAM**: Im Gegensatz zu anderen Videomodellen hält FramePack den VRAM konstant — erzeugen Sie längere Videos frei
* **Modelle vorab herunterladen**: Beim ersten Lauf werden \~15GB heruntergeladen. Führen Sie es einmal aus, dann sind die Modelle in Ihrer Clore-Sitzung zwischengespeichert
* **Kombinieren mit Upscaling**: Erzeugen Sie in 512×512 und verwenden Sie dann Real-ESRGAN, um auf 2K/4K hochzuskalieren

## Prompt-Tipps

Gute Prompts beschreiben **Bewegung**, nicht nur das Aussehen:

```
✅ "die Kamera schwenkt langsam nach rechts und zeigt eine Berglandschaft"
✅ "die Person blinzelt und lächelt sanft, der Wind bewegt ihr Haar"
✅ "langsam herauszoomen und das ganze Gebäude zeigen"

❌ "ein schöner Sonnenuntergang" (keine Bewegung beschrieben)
❌ "hohe Qualität, 4K, detailliert" (Stilwörter helfen nicht viel)
```

## Fehlerbehebung

| Problem                     | Lösung                                                                                                   |
| --------------------------- | -------------------------------------------------------------------------------------------------------- |
| CUDA out of memory          | Verwenden Sie `--low-vram` Flagge, Auflösung auf 512×512 reduzieren                                      |
| Sehr langsame Generierung   | Normal für 6GB-GPUs (\~30s/Frame). Verwenden Sie RTX 4090 für 4x Geschwindigkeit                         |
| Schwarze/beschädigte Frames | Aktualisieren Sie PyTorch: `pip install torch --upgrade`                                                 |
| Modell-Download hängt       | Überprüfen Sie den Festplattenspeicher (benötigt 30GB frei). Versuchen Sie `HF_HUB_ENABLE_HF_TRANSFER=1` |
| Web UI startet nicht        | Überprüfen Sie, ob Port 7860 frei ist: `lsof -i :7860`                                                   |

## Weiterführende Lektüre

* [GitHub-Repository](https://github.com/lllyasviel/FramePack)
* [HunyuanVideo (Basismodell)](https://github.com/Tencent/HunyuanVideo)
* [Clore.ai GPU-Vergleich](/guides/guides_v2-de/erste-schritte/gpu-comparison.md) — finden Sie die günstigste GPU für Ihre Bedürfnisse


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/video-generierung/framepack.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
