> 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/vergleiche/video-gen-comparison.md).

# Vergleich von Video-Generierung

Vergleichen Sie die führenden Open-Source-Modelle zur Videogenerierung für den Einsatz auf Clore.ai GPU-Servern.

{% hint style="info" %}
**KI-Videogenerierung** ist 2024–2025 explodiert. Dieser Leitfaden vergleicht die besten Open-Source-Modelle — Hunyuan Video, Wan2.1, CogVideoX, Mochi 1 und LTX-Video — und behandelt Qualität, Geschwindigkeit, VRAM-Anforderungen und Anwendungsfälle.
{% endhint %}

***

## Schnelle Entscheidungsübersicht

|                        | Hunyuan Video | Wan2.1     | CogVideoX  | Mochi 1    | LTX-Video   |
| ---------------------- | ------------- | ---------- | ---------- | ---------- | ----------- |
| **Entwickler**         | Tencent       | Alibaba    | Zhipu AI   | Genmo      | LightRicks  |
| **Qualität**           | ⭐⭐⭐⭐⭐         | ⭐⭐⭐⭐⭐      | ⭐⭐⭐⭐       | ⭐⭐⭐⭐       | ⭐⭐⭐         |
| **Geschwindigkeit**    | Langsam       | Mittel     | Mittel     | Mittel     | **Schnell** |
| **Min. VRAM**          | 24GB          | 16GB       | 16GB       | 24GB       | **8GB**     |
| **Maximale Auflösung** | 1280×720      | 1280×720   | 1440×960   | 848×480    | 1216×704    |
| **Maximale Länge**     | 5s            | 5s         | 6s         | 5,4s       | 2min        |
| **Lizenz**             | CLA           | Apache 2.0 | Apache 2.0 | Apache 2.0 | Apache 2.0  |
| **GitHub-Sterne**      | 10K+          | 7K+        | 6K+        | 4K+        | 5K+         |

***

## Übersicht

### Hunyuan Video

Tencents Hunyuan Video gilt Anfang 2025 allgemein als das beste Open-Source-Modell zur Videogenerierung. Es verwendet eine transformerbasierte Architektur mit außergewöhnlicher Bewegungsqualität.

**Wesentliche Spezifikationen**: 13B Parameter, 5s bei 720p, erfordert 24GB+ VRAM

### Wan2.1

Alibabas Wan (Wenying) 2.1 ist ein starker Konkurrent zu Hunyuan und bietet ähnliche Qualität bei geringeren Mindest-VRAM-Anforderungen. Verfügbar in Varianten mit 1,3B und 14B Parametern.

**Wesentliche Spezifikationen**: 1,3B (lite) oder 14B, 5s bei 720p, 16GB+ VRAM für 1,3B

### CogVideoX

Zhipu AIs CogVideoX konzentriert sich auf präzise Textübereinstimmung und kohärente Langform-Videos. Es ist besonders stark für kinoreife Inhalte und erzählerische Generierung.

**Wesentliche Spezifikationen**: 5B/10B Parameter, 6s bei 1440×960, 16GB+ VRAM

### Mochi 1

Genmos Mochi 1 ist für sanfte, flüssige Bewegungen und realistische Physik bekannt. Es verwendet eine neuartige AsymmDiT-Architektur. Vollständig Open-Source verfügbar (Gewichte + Trainingscode).

**Wesentliche Spezifikationen**: 10B Parameter, 5,4s bei 848×480, 24GB VRAM

### LTX-Video

LightRicks LTX-Video priorisiert vor allem Inferenzgeschwindigkeit. Es kann in Echtzeit oder nahezu Echtzeit auf modernen GPUs Videos generieren — ideal für interaktive Anwendungen.

**Wesentliche Spezifikationen**: 2B Parameter, bis zu 2 Minuten Video, 8GB VRAM

***

## Qualitätsvergleich

### EvalCrafter Benchmark (2025)

{% hint style="info" %}
Qualität ist subjektiv. Diese Bewertungen spiegeln den Community-Konsens aus VBench- und EvalCrafter-Benchmarks wider.
{% endhint %}

| Modell        | VBench-Score | Bewegungsqualität | Textausrichtung | Ästhetik      |
| ------------- | ------------ | ----------------- | --------------- | ------------- |
| Hunyuan Video | **83.2**     | **Ausgezeichnet** | Ausgezeichnet   | Ausgezeichnet |
| Wan2.1 (14B)  | **82.8**     | Ausgezeichnet     | Ausgezeichnet   | Ausgezeichnet |
| CogVideoX-5B  | 79.6         | Gut               | **Sehr gut**    | Gut           |
| Mochi 1       | 77.4         | Sehr gut          | Gut             | Gut           |
| LTX-Video     | 71.2         | Gut               | Gut             | Akzeptabel    |

### Qualitative Stärken

| Modell        | Besonders geeignet für                     | Schwächen                        |
| ------------- | ------------------------------------------ | -------------------------------- |
| Hunyuan Video | Gesamtqualität, Kinematographie            | Sehr langsam, VRAM-hungrig       |
| Wan2.1        | Ausgewogenheit von Qualität/Effizienz, I2V | Gelegentlich übersättigt         |
| CogVideoX     | Langform-Erzählung, Textgenauigkeit        | Weniger dynamische Bewegung      |
| Mochi 1       | Flüssige Bewegung, Physik                  | Niedrigere Auflösungsgrenze      |
| LTX-Video     | Geschwindigkeit, lange Videos              | Qualitätslücke gegenüber anderen |

***

## Geschwindigkeitsbenchmarks

### Generierungszeit (A100 80GB, Single GPU)

| Modell        | 480p 5s    | 720p 5s     | 1080p 5s |
| ------------- | ---------- | ----------- | -------- |
| Hunyuan Video | 45 Min     | \~3 Stunden | ❌ OOM    |
| Wan2.1 (14B)  | 15 Min     | 45 Min      | ❌ OOM    |
| Wan2.1 (1.3B) | 3 Min      | 8 Min       | ❌ OOM    |
| CogVideoX-5B  | 10 Min     | 25 Min      | ❌ OOM    |
| Mochi 1       | 8 Min      | ❌ OOM       | ❌ OOM    |
| LTX-Video     | **45 Sek** | **3 Min**   | 8 Min    |

{% hint style="warning" %}
**Zeiten sind ungefähr** und variieren je nach Sampler-Schritten (20–50), Guidance-Scale und Hardware. Verwenden Sie für Vorschauen weniger Schritte.
{% endhint %}

### Mit Optimierung (TeaCache / FORA / Step Distillation)

Optimierte Inferenz kann die Generierungszeit deutlich reduzieren:

| Modell        | Mit Cache       | Beschleunigung |
| ------------- | --------------- | -------------- |
| Hunyuan Video | \~15 Min (720p) | 4×             |
| Wan2.1        | \~12 Min (720p) | \~4×           |
| CogVideoX     | \~8 Min (720p)  | \~3×           |
| LTX-Video     | \~45s (720p)    | 4×             |

***

## VRAM-Anforderungen

### Mindest-VRAM nach Modell und Auflösung

| Modell        | 480p    | 720p  | 1080p |
| ------------- | ------- | ----- | ----- |
| Hunyuan Video | 24GB    | 40GB+ | ❌     |
| Wan2.1 (14B)  | 24GB    | 40GB+ | ❌     |
| Wan2.1 (1.3B) | **8GB** | 16GB  | 24GB  |
| CogVideoX-5B  | 16GB    | 24GB  | ❌     |
| CogVideoX-2B  | **8GB** | 16GB  | ❌     |
| Mochi 1       | 24GB    | ❌     | ❌     |
| LTX-Video     | **8GB** | 12GB  | 24GB  |

### Speicheroptimierungstechniken

#### Quantisierung

```python
# CogVideoX mit 8-Bit-Quantisierung (halbiert VRAM)
from diffusers import CogVideoXPipeline
import torch

pipe = CogVideoXPipeline.from_pretrained(
    "THUDM/CogVideoX-5b",
    torch_dtype=torch.float16
)
pipe.enable_model_cpu_offload()  # Reduziert VRAM weiter
pipe.vae.enable_slicing()
pipe.vae.enable_tiling()
```

#### CPU-Auslagerung

```python
# Wan2.1 mit CPU-Auslagerung für geringeren VRAM
from diffusers import WanPipeline

pipe = WanPipeline.from_pretrained(
    "Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()
```

***

## Hunyuan Video: Tiefer Einblick

### Architektur

* **13B DiT** (Diffusion Transformer) Parameter
* Volle Attention über alle räumlichen und temporalen Token
* Trainiert an 1B+ Videoclips

### Bereitstellung auf Clore.ai

```bash
# Klonen und installieren
git clone https://github.com/Tencent/HunyuanVideo
cd HunyuanVideo
pip install -r requirements.txt

# Gewichte herunterladen (~87GB)
huggingface-cli download tencent/HunyuanVideo --local-dir ./weights

# Generieren
python sample_video.py \
  --video-size 720 1280 \
  --video-length 129 \
  --infer-steps 50 \
  --prompt "Ein majestätischer Adler, der über schneebedeckte Berge gleitet" \
  --flow-shift 7.0 \
  --embedded-cfg-scale 6.0 \
  --save-path ./outputs
```

### Via ComfyUI

```bash
# HunyuanVideo-Knoten für ComfyUI installieren
cd ComfyUI/custom_nodes
git clone https://github.com/kijai/ComfyUI-HunyuanVideoWrapper
pip install -r ComfyUI-HunyuanVideoWrapper/requirements.txt
```

**Am besten für**: Höchste Qualität bei kinoreifer Videogenerierung, keine VRAM-Einschränkungen

***

## Wan2.1: Tiefer Einblick

### Architektur

* **Zwei Varianten**: Wan2.1-T2V-1.3B und Wan2.1-T2V-14B
* **Image-to-Video** (I2V) Modell ebenfalls verfügbar
* Starke mehrsprachige (Chinesisch + Englisch) Prompt-Unterstützung

### Bereitstellung auf Clore.ai

```python
from diffusers import WanPipeline
from diffusers.utils import export_to_video
import torch

# 1.3B-Modell — passt in 8–16GB VRAM
pipe = WanPipeline.from_pretrained(
    "Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
    torch_dtype=torch.bfloat16,
)
pipe.to("cuda")

output = pipe(
    prompt="Ein ruhiger japanischer Garten mit fallenden Kirschblüten",
    negative_prompt="niedrige Qualität, unscharf",
    height=480,
    width=832,
    num_frames=81,
    num_inference_steps=50,
    guidance_scale=5.0,
).frames[0]

export_to_video(output, "wan_video.mp4", fps=16)
```

### Image-to-Video mit Wan2.1

```python
from diffusers import WanImageToVideoPipeline
from PIL import Image

pipe = WanImageToVideoPipeline.from_pretrained(
    "Wan-AI/Wan2.1-I2V-14B-480P-Diffusers",
    torch_dtype=torch.bfloat16,
)
pipe.enable_model_cpu_offload()

image = Image.open("input.jpg")
output = pipe(
    image=image,
    prompt="Die Person geht selbstbewusst nach vorne",
    num_frames=81,
).frames[0]
```

**Am besten für**: Ausgewogenheit von Qualität und Effizienz, I2V, mehrsprachig

***

## CogVideoX: Tiefer Einblick

### Architektur

* **Experten-Transformer** mit 3D-Vollattention
* **5B und 10B** Parameter-Varianten
* CogView3 Bildencoder für visuelle Qualität

### Bereitstellung auf Clore.ai

```python
from diffusers import CogVideoXPipeline
from diffusers.utils import export_to_video
import torch

pipe = CogVideoXPipeline.from_pretrained(
    "THUDM/CogVideoX-5b",
    torch_dtype=torch.bfloat16
)
pipe.to("cuda")
pipe.vae.enable_slicing()
pipe.vae.enable_tiling()

video = pipe(
    prompt="Eine Zeitrafferaufnahme einer Stadt bei Nacht mit Lichtspuren von Autos",
    num_videos_per_prompt=1,
    num_inference_steps=50,
    num_frames=49,
    guidance_scale=6,
    generator=torch.Generator(device="cuda").manual_seed(42),
).frames[0]

export_to_video(video, "cogvideo.mp4", fps=8)
```

**Am besten für**: Präzise Text-zu-Video, erzählerische Inhalte, Langform-Generierung

***

## Mochi 1: Tiefer Einblick

### Architektur

* **AsymmDiT** — asymmetrischer Diffusions-Transformer
* Fokus auf zeitliche Konsistenz und flüssige Bewegung
* Vollständig Open-Source einschließlich Trainingscode

### Bereitstellung auf Clore.ai

```bash
pip install mochi-preview

python -c "
from mochi_preview.pipelines import DecoderModelFactory, DitModelFactory, MochiSingleGPUPipeline, T5ModelFactory
import tempfile
from pathlib import Path

pipeline = MochiSingleGPUPipeline(
    text_encoder_factory=T5ModelFactory(),
    dit_factory=DitModelFactory(model_path='./weights/mochi-dit.safetensors'),
    decoder_factory=DecoderModelFactory(model_path='./weights/mochi-vae.safetensors'),
    cpu_offload=True,
    decode_type='tiled_full',
)

video = pipeline(
    height=480, width=848,
    num_frames=163,
    num_inference_steps=64,
    sigma_schedule_type='linear_quadratic',
    cfg_schedule_type='linear',
    conditioning_args={'prompt': 'Ein Delfin, der bei Sonnenuntergang durch Meereswellen springt'},
)
"
```

**Am besten für**: Flüssige Bewegung, realistische Physik, Forschungsanwendungen

***

## LTX-Video: Tiefer Einblick

### Architektur

* **2B Parameter** DiT — kleiner, schneller
* Native **Unterstützung für lange Videos** (bis zu 2 Minuten)
* Entwickelt für Echtzeit- oder nahezu Echtzeit-Generierung

### Bereitstellung auf Clore.ai

```python
from diffusers import LTXPipeline
from diffusers.utils import export_to_video
import torch

pipe = LTXPipeline.from_pretrained(
    "Lightricks/LTX-Video",
    torch_dtype=torch.bfloat16
)
pipe.to("cuda")

video = pipe(
    prompt="Ein Schmetterling, der auf einer Blume in einem Sommergarten landet",
    negative_prompt="schlechteste Qualität, inkonsistente Bewegung, unscharf",
    width=704,
    height=480,
    num_frames=161,
    decode_timestep=0.03,
    decode_noise_scale=0.025,
    num_inference_steps=50,
).frames[0]

export_to_video(video, "ltx_video.mp4", fps=24)
```

**Am besten für**: Schnelle Generierung, interaktive Anwendungen, lange Videos, begrenzter VRAM (8GB)

***

## Funktionsvergleich

### Fähigkeitenübersicht

| Funktion            | Hunyuan   | Wan2.1 | CogVideoX | Mochi | LTX |
| ------------------- | --------- | ------ | --------- | ----- | --- |
| Text-zu-Video       | ✅         | ✅      | ✅         | ✅     | ✅   |
| Image-to-Video      | ✅         | ✅      | ✅         | ❌     | ✅   |
| Video-zu-Video      | ❌         | ❌      | ✅         | ❌     | ✅   |
| ControlNet          | Teilweise | ❌      | ✅         | ❌     | ❌   |
| LoRA-Unterstützung  | ✅         | ✅      | ✅         | ❌     | ✅   |
| ComfyUI-Knoten      | ✅         | ✅      | ✅         | ✅     | ✅   |
| Langes Video (>10s) | ❌         | ❌      | Teilweise | ❌     | ✅   |
| Chinesische Prompts | ✅         | ✅      | ✅         | ❌     | ❌   |

***

## Clore.ai GPU-Empfehlungen

### Für jedes Modell

| Modell        | Minimale GPU    | Empfohlen    | Ideal       |
| ------------- | --------------- | ------------ | ----------- |
| Hunyuan Video | RTX 3090 (24GB) | A6000 (48GB) | A100 (80GB) |
| Wan2.1 14B    | RTX 3090 (24GB) | A6000 (48GB) | A100 (80GB) |
| Wan2.1 1.3B   | RTX 3080 (10GB) | RTX 3090     | RTX 4090    |
| CogVideoX-5B  | RTX 3090 (24GB) | A6000 (48GB) | A100        |
| CogVideoX-2B  | RTX 3080 (10GB) | RTX 3090     | RTX 4090    |
| Mochi 1       | RTX 3090 (24GB) | A6000 (48GB) | A100        |
| LTX-Video     | RTX 3080 (10GB) | RTX 4080     | RTX 4090    |

### Kostenschätzung pro Video

```
Hunyuan Video (720p, 5s) auf A100 80GB (~$1.50/Stunde):
  Zeit: ~45 Min → Kosten: ~ $1,12 pro Video

Wan2.1-1.3B (480p, 5s) auf RTX 3090 (~$0.50/Stunde):
  Zeit: ~3 Min → Kosten: ~ $0,025 pro Video

LTX-Video (720p, 5s) auf RTX 4090 (~$0.60/Stunde):
  Zeit: ~3 Min → Kosten: ~ $0,030 pro Video
```

***

## Wann welches verwenden

### Entscheidungsleitfaden

```
Maximale Qualität (kein Kostenlimit)?
  → Hunyuan Video auf A100

Beste Qualität/Kosten-Balance?
  → Wan2.1 14B auf A6000

Begrenzter VRAM (8–12GB)?
  → LTX-Video oder Wan2.1 1.3B

Brauchen Sie schnelle Generierung?
  → LTX-Video

Brauchen Sie Image-to-Video?
  → Wan2.1 I2V oder CogVideoX

Brauchen Sie lange Videos (>10s)?
  → LTX-Video

Forschung/Feinabstimmung?
  → Mochi 1 (offener Trainingscode) oder CogVideoX

ComfyUI-Workflow?
  → Alle werden unterstützt, Hunyuan/Wan beste Knoten
```

***

## Nützliche Links

* [Hunyuan Video GitHub](https://github.com/Tencent/HunyuanVideo)
* [Wan2.1 auf HuggingFace](https://huggingface.co/Wan-AI)
* [CogVideoX GitHub](https://github.com/THUDM/CogVideo)
* [Mochi 1 GitHub](https://github.com/genmoai/mochi)
* [LTX-Video GitHub](https://github.com/Lightricks/LTX-Video)
* [Video-Generierungs-Rangliste](https://huggingface.co/spaces/ArtificialAnalysis/video-generation-arena-leaderboard)

***

## Zusammenfassung

| Modell            | Verwenden wenn                                           |
| ----------------- | -------------------------------------------------------- |
| **Hunyuan Video** | Die höchste Qualität am wichtigsten ist, A100+ verfügbar |
| **Wan2.1**        | Bestes Gleichgewicht zwischen Qualität und Effizienz     |
| **CogVideoX**     | Präzises Text-zu-Video, lange Erzählungen                |
| **Mochi 1**       | Flüssige Bewegung, Physik, offene Forschung              |
| **LTX-Video**     | Geschwindigkeit, niedriger VRAM, lange Videos            |

Das Open-Source-Ökosystem zur Videogenerierung entwickelt sich schnell. Für die meisten Clore.ai-Bereitstellungen **Wan2.1** (1.3B für Budget, 14B für Qualität) bietet die beste Kombination aus Qualität, Geschwindigkeit und Ressourceneffizienz.


---

# 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/vergleiche/video-gen-comparison.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.