> 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 der Videogenerierung

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

{% hint style="info" %}
**KI-Videogenerierung** Die KI-Videogenerierung hat 2024–2025 explosionsartig zugenommen. 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**          | 24 GB         | 16 GB      | 16 GB      | 24 GB      | **8 GB**    |
| **Maximale Auflösung** | 1280×720      | 1280×720   | 1440×960   | 848×480    | 1216×704    |
| **Maximale Länge**     | 5 s           | 5 s        | 6 s        | 5,4 s      | 2 Min.      |
| **Lizenz**             | CLA           | Apache 2.0 | Apache 2.0 | Apache 2.0 | Apache 2.0  |
| **GitHub-Stars**       | 10K+          | 7K+        | 6K+        | 4K+        | 5K+         |

***

## Überblick

### Hunyuan Video

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

**Wichtige Spezifikationen**: 13B Parameter, 5 s bei 720p, benötigt 24 GB+ 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.

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

### CogVideoX

CogVideoX von Zhipu AI konzentriert sich auf präzises Befolgen von Textanweisungen und kohärente Langform-Videos. Es ist besonders stark für cinematische Inhalte und erzählgetriebene Generierung.

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

### Mochi 1

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

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

### LTX-Video

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

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

***

## Qualitätsvergleich

### EvalCrafter-Benchmark (2025)

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

| Modell        | VBench-Wert | Bewegungsqualität | Texttreue    | Ästhetik     |
| ------------- | ----------- | ----------------- | ------------ | ------------ |
| Hunyuan Video | **83.2**    | **Hervorragend**  | Hervorragend | Hervorragend |
| Wan2.1 (14B)  | **82.8**    | Hervorragend      | Hervorragend | Hervorragend |
| 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        | Am besten bei                           | Schwächen                   |
| ------------- | --------------------------------------- | --------------------------- |
| Hunyuan Video | Gesamtqualität, Kameraführung           | Sehr langsam, VRAM-hungrig  |
| Wan2.1        | Balance aus Qualität und Effizienz, I2V | Gelegentlich übersättigt    |
| CogVideoX     | Langform-Erzählungen, Textgenauigkeit   | Weniger dynamische Bewegung |
| Mochi 1       | Flüssige Bewegung, Physik               | Niedrigere Auflösungsgrenze |
| LTX-Video     | Geschwindigkeit, lange Videos           | Qualitätsabstand zu anderen |

***

## Geschwindigkeits-Benchmarks

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

| Modell        | 480p 5 s    | 720p 5 s    | 1080p 5 s |
| ------------- | ----------- | ----------- | --------- |
| 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ähre Angaben** 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     | \~45 s (720p)    | 4×             |

***

## VRAM-Anforderungen

### Minimaler VRAM nach Modell und Auflösung

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

### Techniken zur Speicheroptimierung

#### Quantisierung

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

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

#### CPU-Offloading

```python
# Wan2.1 mit CPU-Offloading 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: Detaillierter Einblick

### Architektur

* **13B DiT** (Diffusion Transformer)-Parameter
* Volle Aufmerksamkeit über alle räumlichen und zeitlichen Tokens
* Trainiert auf über 1 Mrd. 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 (~87 GB)
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
```

### Über 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**: Cinematische Videogenerierung in höchster Qualität, ohne VRAM-Einschränkungen

***

## Wan2.1: Detaillierter Einblick

### Architektur

* **Zwei Varianten**: Wan2.1-T2V-1.3B und Wan2.1-T2V-14B
* **Bild-zu-Video** (I2V)-Modell ebenfalls verfügbar
* Starke mehrsprachige Prompts (Chinesisch + Englisch)

### Bereitstellung auf Clore.ai

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

# 1,3B-Modell — passt in 8–16 GB 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="geringe 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)
```

### Bild-zu-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 schreitet selbstbewusst vorwärts",
    num_frames=81,
).frames[0]
```

**Am besten für**: Gleichgewicht aus Qualität und Effizienz, I2V, mehrsprachig

***

## CogVideoX: Detaillierter Einblick

### Architektur

* **Experten-Transformer** mit 3D-Vollaufmerksamkeit
* **5B und 10B** Parametervarianten
* 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, narrative Inhalte, Langform-Generierung

***

## Mochi 1: Detaillierter Einblick

### Architektur

* **AsymmDiT** — asymmetrischer Diffusion-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 springt bei Sonnenuntergang durch die Meereswellen'},
)
"
```

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

***

## LTX-Video: Detaillierter Einblick

### Architektur

* **2B-Parameter** DiT — kleiner, schneller
* Nativ **lange Videos** Unterstützung (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 landet auf einer Blume in einem Sommergarten",
    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 (8 GB)

***

## Funktionsvergleich

### Überblick über die Funktionen

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

***

## GPU-Empfehlungen für Clore.ai

### Für jedes Modell

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

### Kostenschätzung pro Video

```
Hunyuan Video (720p, 5 s) auf A100 80 GB ([Bare Metal](https://clore.ai/bare-metal)):
  Zeit: ~45 Min. → Kosten: ~$1,12 pro Video

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

LTX-Video (720p, 5 s) auf RTX 4090 (0,14–0,42 $/Std.):
  Zeit: ~3 Min. → Kosten: ~$0,030 pro Video
```

***

## Wann welches Modell verwenden

### Entscheidungsleitfaden

```
Maximale Qualität (keine Kostenbegrenzung)?
  → Hunyuan Video auf A100

Bestes Verhältnis von Qualität zu Kosten?
  → Wan2.1 14B auf A6000

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

Schnelle Generierung nötig?
  → LTX-Video

Bild-zu-Video nötig?
  → Wan2.1 I2V oder CogVideoX

Lange Videos nötig (>10 s)?
  → LTX-Video

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

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

***

## Nützliche Links

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

***

## Zusammenfassung

| Modell            | Verwenden, wenn                                    |
| ----------------- | -------------------------------------------------- |
| **Hunyuan Video** | Beste Qualität ist am wichtigsten, A100+ verfügbar |
| **Wan2.1**        | Beste Balance aus Qualität und Effizienz           |
| **CogVideoX**     | Präzise 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 der 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/vergleiche/video-gen-comparison.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.