> 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/wan22-vbvr.md).

# Wan 2.2 VBVR (Bewegungssteuerung)

**Wan 2.2 VBVR** (Video-Based Video Reference) ist Alibabas Erweiterung vom April 2026 für das Wan-2.2-Basis-Modell für Bild-zu-Video. Sie fügt eine leistungsstarke neue Fähigkeit hinzu: Sie geben einen **Referenz-Videoausschnitt** an, um Bewegungsmuster in Ihrem generierten Video zu steuern, nicht nur ein Startbild. Das Ergebnis ist eine konsistente, steuerbare Animation — dieselbe Figur, dasselbe Produkt oder dieselbe Szene folgt dem Bewegungsweg aus Ihrem Referenzmaterial.

Dieser Leitfaden behandelt die Bereitstellung von Wan 2.2 VBVR über ComfyUI auf einer GPU-Miete bei Clore.ai.

***

## Was ist VBVR (Video-Based Video Reference)?

Traditionelle Bild-zu-Video-Modelle nehmen ein statisches Bild und erzeugen Bewegung von Grund auf. Die Bewegung wird durch Ihren Text-Prompt gesteuert, kann aber unvorhersehbar sein — insbesondere bei bestimmten Gesten, Kamerabewegungen oder Figurenaktionen.

**VBVR ändert die Ausgangslage:** Sie liefern:

1. Ein **Startbild** — Ihr Motiv (Figur, Produkt, Szene)
2. Ein **Referenz-Bewegungsvideo** — ein kurzer Clip, der die gewünschte Bewegung demonstriert
3. Ein **Text-Prompt** — beschreibt Inhalt und Stil

Das Modell extrahiert das Bewegungsmuster aus dem Referenzvideo und überträgt es auf Ihr Startbild, wodurch ein neues Video entsteht, in dem Ihr Motiv diese Bewegung natürlich ausführt.

### Beispielanwendungen

| Eingabebild               | Bewegung des Referenzvideos        | Ausgabe                               |
| ------------------------- | ---------------------------------- | ------------------------------------- |
| Produktfoto               | Hand hebt ähnlichen Gegenstand auf | Animation zum Aufheben eines Produkts |
| Figurenillustration       | Gangszyklus eines Schauspielers    | Figur läuft                           |
| Modemodell                | Laufsteg-Aufnahmen                 | Kleidung in Bewegung                  |
| Außenseite eines Gebäudes | Kameraschwenk aus Drohnenaufnahmen | Kinematische B-Roll-Enthüllung        |

***

## Modellübersicht

* **Vollständiger Name:** Wan 2.2 I2V-A14B mit VBVR (Video-Based Video Reference)
* **Veröffentlicht:** April 2026 von Alibaba / Wan-AI-Team
* **Aufgebaut auf:** Wan 2.2 I2V-A14B (Bild-zu-Video, 14B Parameter, bis zu 480p Auflösung)
* **HuggingFace:** `Wan-AI/Wan2.2-I2V-A14B`
* **VBVR-Workflow:** über ComfyUI-Manager-Community-Nodes verteilt
* **Lizenz:** Apache 2.0

### Varianten

| Variante | Benötigter VRAM | Qualität | Geschwindigkeit |
| -------- | --------------- | -------- | --------------- |
| **FP8**  | 16–24 GB        | Hoch     | Schnell         |
| **BF16** | 24–40 GB        | Höchste  | Mittel          |

Die **FP8-Variante** läuft auf einer RTX 3090 (24 GB) und kann mit verringerter Batch-Größe auch in 16-GB-Karten passen. Die **BF16-Variante** liefert die beste Qualität und läuft problemlos auf einer RTX 4090 (24 GB) oder A6000 (48 GB).

***

## Hardware-Anforderungen

| GPU         | VRAM  | Variante       | Preis bei Clore.ai |
| ----------- | ----- | -------------- | ------------------ |
| RTX 3090    | 24 GB | FP8 ✅          | \~0,30 $/Tag       |
| RTX 4090    | 24 GB | FP8 ✅ / BF16 ✅ | \~0,50 $/Tag       |
| A6000 48 GB | 48 GB | BF16 ✅         | \~1,20 $/Tag       |
| A100 80 GB  | 80 GB | BF16 ✅         | \~2,50 $/Tag       |

Für die meisten Nutzer ist eine **RTX 4090 für \~0,50 $/Tag** die beste Balance aus Preis und Qualität und läuft mit BF16 in voller 480p-Auflösung.

***

## Schritt-für-Schritt-Einrichtung auf Clore.ai

### Schritt 1: Eine GPU mieten

Besuchen Sie [clore.ai/marketplace](https://clore.ai/marketplace):

* **Budget**: RTX 3090 (\~0,30 $/Tag) — nur FP8
* **Empfohlen**: RTX 4090 (\~0,50 $/Tag) — BF16-Qualität
* **Premium**: A6000 (\~1,20 $/Tag) — Batch-Verarbeitung, hoher Durchsatz

Verwenden Sie ein **ComfyUI-Docker-Image** oder das Basis-CUDA-Image (wir installieren ComfyUI manuell).

### Schritt 2: ComfyUI installieren

```bash
# ComfyUI klonen
git clone https://github.com/comfyanonymous/ComfyUI.git /workspace/ComfyUI
cd /workspace/ComfyUI

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

# ComfyUI Manager installieren (für einfache Node-Installation)
cd custom_nodes
git clone https://github.com/ltdrdata/ComfyUI-Manager.git
cd ..
```

### Schritt 3: VBVR-angepasste Nodes über den ComfyUI Manager installieren

Starten Sie ComfyUI:

```bash
cd /workspace/ComfyUI
python main.py --listen 0.0.0.0 --port 8188
```

Öffnen Sie `http://IHRE_CLORE_IP:8188` in Ihrem Browser. Dann:

1. Klicken Sie auf die **Manager** Schaltfläche (oberes Menü)
2. Suchen Sie nach **"Wan 2.2 VBVR"** oder **"WanVideo"**
3. Installieren Sie das **ComfyUI-WanVideo** Node-Paket
4. Starten Sie ComfyUI nach der Installation neu

Alternativ können Sie die Nodes direkt installieren:

```bash
cd /workspace/ComfyUI/custom_nodes
git clone https://github.com/kijai/ComfyUI-WanVideoWrapper.git
pip install -r ComfyUI-WanVideoWrapper/requirements.txt
```

### Schritt 4: Modell-Checkpoints herunterladen

```bash
mkdir -p /workspace/ComfyUI/models/wan

# Wan-2.2-I2V-Basismodell herunterladen (~28 GB)
huggingface-cli download \
  Wan-AI/Wan2.2-I2V-A14B \
  --local-dir /workspace/ComfyUI/models/wan/Wan2.2-I2V-A14B

# VBVR-spezifische Gewichte des Bewegungscoders herunterladen (~2 GB)
# Hinweis: VBVR-Gewichte werden als Community-Release von ComfyUI-WanVideoWrapper verteilt.
# Prüfen Sie https://github.com/kijai/ComfyUI-WanVideoWrapper für den aktuellen Download-Pfad.
huggingface-cli download \
  kijai/WanVideo-motion-encoder \
  --local-dir /workspace/ComfyUI/models/wan/vbvr-motion-encoder
```

> **Tipp:** Verwenden Sie `huggingface-cli download --include "*.safetensors"` um nicht wesentliche Dateien zu überspringen und Speicherplatz zu sparen.

### Schritt 5: VAE und Textencoder herunterladen

```bash
# CLIP-Textencoder (geteilt mit dem Basis-Wan 2.2)
huggingface-cli download \
  Wan-AI/Wan2.2-I2V-A14B \
  --include "xlabs_clip*" \
  --local-dir /workspace/ComfyUI/models/clip

# T5-XXL-Textencoder
huggingface-cli download \
  Wan-AI/Wan2.2-I2V-A14B \
  --include "t5*" \
  --local-dir /workspace/ComfyUI/models/t5

# VAE
huggingface-cli download \
  Wan-AI/Wan2.2-I2V-A14B \
  --include "Wan2.2_VAE.safetensors" \
  --local-dir /workspace/ComfyUI/models/vae
```

***

## Den VBVR-Workflow in ComfyUI erstellen

### Workflow-Übersicht

Der VBVR-Workflow verbindet diese Node-Gruppen:

```
[Bild laden] ──────────────────────────────────┐
                                               ↓
[Referenzvideo laden] → [VBVR Motion Encoder] → [Wan I2V Sampler] → [VAE Decode] → [Video speichern]
                                               ↑
[CLIP Text Encode] ────────────────────────────┘
```

### Den Workflow laden

1. Laden Sie das vorgefertigte VBVR-Workflow-JSON aus dem Repository ComfyUI-WanVideoWrapper herunter:

   ```
   custom_nodes/ComfyUI-WanVideoWrapper/workflows/wan22_vbvr.json
   ```
2. In ComfyUI: **Load** → auswählen `wan22_vbvr.json`

### Wichtige Nodes konfigurieren

**WanVideoModelLoader**

* `model_path`: verweist auf `Wan2.2-I2V-A14B`
* `precision`: `fp8_e4m3fn` für RTX 3090, `bf16` für RTX 4090+

**VBVRMotionEncoderLoader**

* `encoder_path`: verweist auf `vbvr-motion-encoder`

**WanVideoSampler**

* `steps`: 25–30 (Qualität), 15–20 (Geschwindigkeit)
* `cfg`: 6,0–7,5 (höher = stärker prompttreu)
* `motion_strength`: 0,6–0,9 (wie genau der Referenzbewegung gefolgt werden soll)
* `frames`: 25 (ca. 2 Sekunden bei 12 fps) oder 49 (4 Sekunden)
* `resolution`: 832×480 (standardmäßig 480p)

**LoadVideo (Referenz)**

* Laden Sie Ihren Referenz-Bewegungsclip (MP4, GIF oder Bildsequenz)
* Empfohlen: 2–5 Sekunden, ungefähr dieselbe Dauer wie Ihre Zielausgabe

***

## Ihre erste Generierung ausführen

### Bereiten Sie Ihre Eingaben vor

1. **Startbild**: 832×480 px oder ähnlich. PNG oder JPG. Das ist Ihr Motiv.
2. **Referenz-Bewegungsvideo**: idealerweise 2–5 Sekunden, zeigt die gewünschte Bewegung. Die Auflösung muss nicht übereinstimmen — das Modell extrahiert Bewegungsvektoren, nicht Pixelinhalt.
3. **Text-Prompt**: beschreiben Sie Ihr Motiv und was es tut (z. B. `"eine Produktflasche, die sich sanft auf einer weißen Oberfläche dreht, kinoreife Beleuchtung, 4K, professionelle Fotografie"`)

### Empfohlene Einstellungen für den ersten Lauf

```yaml
steps: 25
cfg: 7,0
motion_strength: 0,75
frames: 25
seed: 42 (fest für Reproduzierbarkeit)
```

### Geschätzte Generierungszeiten

| GPU        | Variante | Frames    | Zeit           |
| ---------- | -------- | --------- | -------------- |
| RTX 3090   | FP8      | 25 Frames | \~3–5 Min.     |
| RTX 4090   | BF16     | 25 Frames | \~2–4 Min.     |
| RTX 4090   | FP8      | 25 Frames | \~1,5–2,5 Min. |
| A100 80 GB | BF16     | 49 Frames | \~3–5 Min.     |

***

## Praktische Workflows

### Charakteranimation

1. **Bild**: Figurenillustration oder Foto
2. **Referenz**: Aufnahmen eines Schauspielers, der die gewünschte Aktion ausführt (gehen, winken, rennen)
3. **Prompt**: `"Cartoonfigur, die durch einen Wald läuft, sanfte Animation, konsistenter Stil"`
4. **motion\_strength**: 0,85 (hohe Übereinstimmung mit der Referenzbewegung)

### Produktdemo

1. **Bild**: saubere Produktaufnahme auf weißem Hintergrund
2. **Referenz**: eine Hand packt aus oder dreht ein ähnliches Produkt
3. **Prompt**: `"hochwertige Produktpräsentation, 360°-Drehung, weiche Studio-Beleuchtung, kommerzielle Qualität"`
4. **motion\_strength**: 0,70 (etwas kreative Freiheit bei Beleuchtung/Umgebung)

### Kinematische B-Roll

1. **Bild**: Landschaftsfoto oder Gebäudeaußenseite
2. **Referenz**: Drohnenaufnahmen oder Kameraschwenk aus einem Stock-Clip
3. **Prompt**: `"aerial cinematische B-Roll, goldene Stunde, sanfte Drohnenbewegung, 4K-Qualität"`
4. **motion\_strength**: 0,65 (das Modell natürliche Bewegung hinzufügen lassen)

***

## Fehlerbehebung

**Speicher voll auf RTX 3090 mit BF16**

* Wechseln Sie in WanVideoModelLoader zur FP8-Quantisierung
* Reduzieren Sie die Frames von 25 auf 17
* Deaktivieren Sie VAE-Kachelung, falls aktiviert

**Bewegung stimmt nicht mit dem Referenzvideo überein**

* Erhöhen Sie `motion_strength` auf 0,85–0,95
* Stellen Sie sicher, dass das Referenzvideo auf die gewünschte Dauer zugeschnitten ist
* Verwenden Sie Referenzvideos mit klarer, eindeutiger Bewegung (Kamerawackeln vermeiden)

**Generiertes Video flackert oder hat Artefakte**

* Erhöhen Sie die Schritte auf 30
* Reduzieren Sie CFG auf 6,0
* Verwenden Sie ein Referenzvideo mit gleichmäßiger Beleuchtung

**Langsamer Download / HuggingFace-Timeout**

* Verwenden Sie `HF_ENDPOINT=https://hf-mirror.com` Umgebungsvariable für schnellere Downloads aus China
* Oder herunterladen via `aria2c` mit mehreren Verbindungen

***

## Was kommt als Nächstes: Wan 2.7

Alibabas **Wan 2.7** ist die nächste Generation der Wan-Video-Modellfamilie und bietet:

* **Generierung von erstem und letztem Frame**: geben Sie sowohl den Anfangs- als auch den Endframe an
* **Video-zu-Video-Bearbeitung**: vorhandenes Video mit Textanweisungen verändern
* **Motivreferenzierung**: konsistentes Erscheinungsbild bestimmter Objekte/Figuren über mehrere Szenen hinweg beibehalten

Wan 2.7 ist derzeit über die API von Together AI verfügbar. **Open-Source-Gewichte werden Mitte Q2 2026 erwartet.** Eine vollständige Anleitung zum Self-Hosting wird diesem Repository hinzugefügt, sobald die Gewichte veröffentlicht sind.

***

## Zusammenfassung

Wan 2.2 VBVR bringt referenzgesteuerte Bewegungssteuerung in die Open-Source-Videogenerierung. Geben Sie ein Startbild und einen Referenz-Bewegungsclip an, und das Modell erzeugt ein konsistentes Video, in dem Ihr Motiv dieser Bewegung natürlich folgt. FP8 läuft auf einer 24-GB RTX 3090 für \~0,30 $/Tag; BF16 auf einer RTX 4090 für \~0,50 $/Tag — beides auf Clore.ai.

**→** [**Mieten Sie eine GPU auf Clore.ai**](https://clore.ai/marketplace) und beginnen Sie noch heute mit der Generierung bewegungsgesteuerter Videos.


---

# 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/wan22-vbvr.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.
