> 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/videogenerierung/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-Image-to-Video-Grundmodell. Sie fügt eine leistungsstarke neue Fähigkeit hinzu: Du gibst einen **Referenz-Videoclip** an, um Bewegungsmuster in deinem generierten Video zu steuern, nicht nur ein Startbild. Das Ergebnis ist eine konsistente, steuerbare Animation — dieselbe Figur, dasselbe Produkt oder dieselbe Szene folgt dem Bewegungsverlauf aus deinem Referenzmaterial.

Diese Anleitung 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 neu. Die Bewegung wird durch deinen Text-Prompt gesteuert, kann aber unvorhersehbar sein — besonders bei spezifischen Gesten, Kamerabewegungen oder Aktionen von Figuren.

**VBVR ändert die Ausgangslage:** du lieferst:

1. Ein **Startbild** — dein Motiv (Figur, Produkt, Szene)
2. Ein **Referenzbewegungsvideo** — 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 dein Startbild, wodurch ein neues Video erzeugt wird, in dem dein Motiv diese Bewegung natürlich ausführt.

### Beispielanwendungen

| Eingabebild         | Bewegung des Referenzvideos                   | Ausgabe                              |
| ------------------- | --------------------------------------------- | ------------------------------------ |
| Produktfoto         | Hand, die einen ähnlichen Gegenstand aufnimmt | Animation zum Aufnehmen des Produkts |
| Figurenillustration | Gehzyklus eines Schauspielers                 | Figur geht                           |
| Modell für Mode     | Laufsteg-Gehlauf-Material                     | Kleidung in Bewegung                 |
| Gebäudeaußenansicht | Kameraschwenk aus Drohnenaufnahmen            | Cinematischer B-Roll-Reveal          |

***

## Modellübersicht

* **Vollständiger Name:** Wan 2.2 I2V-A14B mit VBVR (Video-Based Video Reference)
* **Veröffentlicht:** April 2026 von Alibaba / dem Wan-AI-Team
* **Basiert 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 Community-Nodes des ComfyUI Managers verteilt
* **Lizenz:** Apache 2.0

### Varianten

| Variante | Erforderlicher VRAM | Qualität    | Geschwindigkeit |
| -------- | ------------------- | ----------- | --------------- |
| **FP8**  | 16–24 GB            | Hoch        | Schnell         |
| **BF16** | 24–40 GB            | Am höchsten | Mittel          |

Der **FP8-Variante** läuft auf einer RTX 3090 (24 GB) und passt mit reduzierter Batch-Größe sogar auf 16-GB-Karten. Die **BF16-Variante** liefert die beste Qualität und läuft komfortabel auf einer RTX 4090 (24 GB) oder A6000 (48 GB).

***

## Hardware-Anforderungen

| GPU        | VRAM  | Variante       | Preis auf Clore.ai                        |
| ---------- | ----- | -------------- | ----------------------------------------- |
| RTX 3090   | 24 GB | FP8 ✅          | ca. 0,07–0,21 $/h                         |
| RTX 4090   | 24 GB | FP8 ✅ / BF16 ✅ | ca. 0,14–0,42 $/h                         |
| A6000 48GB | 48 GB | BF16 ✅         | 0,35–0,38 $/Std.                          |
| A100 80GB  | 80 GB | BF16 ✅         | [Bare Metal](https://clore.ai/bare-metal) |

Für die meisten Nutzer ist eine **RTX 4090 für 0,14–0,42 $/Std.** 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 [clore.ai/marketplace](https://clore.ai/marketplace):

* **Budget**: RTX 3090 (0,07–0,21 $/Std.) — nur FP8
* **Empfohlen**: RTX 4090 (0,14–0,42 $/Std.) — BF16-Qualität
* **Premium**: A6000 (0,35–0,38 $/Std.) — Batch-Verarbeitung, hoher Durchsatz

Verwende 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-Custom-Nodes über den ComfyUI Manager installieren

ComfyUI starten:

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

Öffnen `http://DEINE_CLORE_IP:8188` in deinem Browser. Dann:

1. Klicken Sie auf **Manager** Schaltfläche (oberes Menü)
2. Suche nach **„Wan 2.2 VBVR“** oder **„WanVideo“**
3. Installiere das **ComfyUI-WanVideo** Node-Paket
4. Starte ComfyUI nach der Installation neu

Alternativ kannst du 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 Motion-Encoder-Gewichte herunterladen (~2 GB)
# Hinweis: VBVR-Gewichte werden als Community-Veröffentlichung über ComfyUI-WanVideoWrapper bereitgestellt.
# Prüfe 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:** Verwende `huggingface-cli download --include "*.safetensors"` um nicht notwendige Dateien zu überspringen und Speicherplatz zu sparen.

### Schritt 5: VAE und Text-Encoder herunterladen

```bash
# CLIP-Text-Encoder (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-Text-Encoder
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] ────────────────────────────┘
```

### Workflow laden

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

   ```
   custom_nodes/ComfyUI-WanVideoWrapper/workflows/wan22_vbvr.json
   ```
2. In ComfyUI: **Laden** → wähle `wan22_vbvr.json`

### Wichtige Nodes konfigurieren

**WanVideoModelLoader**

* `model_path`: zeige auf `Wan2.2-I2V-A14B`
* `Präzision`: `fp8_e4m3fn` für RTX 3090, `bf16` für RTX 4090+

**VBVRMotionEncoderLoader**

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

**WanVideoSampler**

* `Schritte`: 25–30 (Qualität), 15–20 (Geschwindigkeit)
* `cfg`: 6,0–7,5 (höher = stärkerer Prompt-Treue)
* `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)
* `Auflösung`: 832×480 (standardmäßig 480p)

**LoadVideo (Referenz)**

* Lade deinen Referenzbewegungsclip (MP4, GIF oder Bildsequenz)
* Empfohlen: 2–5 Sekunden, ungefähr dieselbe Dauer wie dein Zielausgang

***

## Deine erste Generierung ausführen

### Bereite deine Eingaben vor

1. **Startbild**: 832×480px oder ungefähr so. PNG oder JPG. Das ist dein Motiv.
2. **Referenzbewegungsvideo**: idealerweise 2–5 Sekunden, zeigt die gewünschte Bewegung. Die Auflösung muss nicht übereinstimmen — das Modell extrahiert Bewegungsvektoren, nicht Pixelinhalt.
3. **Text-Prompt**: beschreibe dein 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
Schritte: 25
cfg: 7,0
motion_strength: 0,75
Frames: 25
Seed: 42 (fest für Reproduzierbarkeit)
```

### Geschätzte Generierungszeit

| 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 80GB | BF16     | 49 Frames | \~3–5 Min.     |

***

## Praktische Workflows

### Charakteranimation

1. **Image**: Figurenillustration oder Foto
2. **Referenz**: Aufnahmen eines Schauspielers, der die gewünschte Aktion ausführt (gehen, winken, laufen)
3. **Prompt**: `„Cartoon-Figur, die durch einen Wald geht, sanfte Animation, konsistenter Stil“`
4. **motion\_strength**: 0,85 (hohe Treue zur Referenzbewegung)

### Produktdemo

1. **Image**: sauberes Produktfoto auf weißem Hintergrund
2. **Referenz**: Hand, die ein ähnliches Produkt auspackt oder dreht
3. **Prompt**: `„Premium-Produkt-Enthüllung, 360°-Drehung, weiches Studiolicht, kommerzielle Qualität“`
4. **motion\_strength**: 0,70 (etwas kreative Freiheit bei Beleuchtung/Umgebung)

### Cinematisches B-Roll-Material

1. **Image**: Landschaftsfoto oder Gebäudeaußenansicht
2. **Referenz**: Drohnenaufnahmen oder Kameraschwenk aus einem Stock-Clip
3. **Prompt**: `„cinematisches Luft-B-Roll, goldene Stunde, sanfte Drohnenbewegung, 4K-Qualität“`
4. **motion\_strength**: 0,65 (dem Modell natürliche Bewegung hinzufügen lassen)

***

## Fehlerbehebung

**Speicher voll auf RTX 3090 mit BF16**

* Wechsle in WanVideoModelLoader auf FP8-Quantisierung
* Reduziere die Frames von 25 auf 17
* Deaktiviere VAE-Tiling, falls aktiviert

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

* Erhöhen Sie `motion_strength` auf 0,85–0,95
* Stelle sicher, dass das Referenzvideo auf die Ziel-Dauer zugeschnitten ist
* Verwende Referenzvideos mit klarer, eindeutiger Bewegung (Kamerawackeln vermeiden)

**Generiertes Video flackert oder hat Artefakte**

* Erhöhe die Schritte auf 30
* Reduziere CFG auf 6,0
* Verwende ein Referenzvideo mit gleichmäßiger Beleuchtung

**Langsamer Download / HuggingFace-Timeout**

* Verwende `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**: gib sowohl den ersten als auch den letzten Frame an
* **Video-zu-Video-Bearbeitung**: vorhandenes Video mit Textanweisungen verändern
* **Motiv-Referenzierung**: konsistentes Aussehen bestimmter Objekte/Figuren über Szenen hinweg beibehalten

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

***

## Zusammenfassung

Wan 2.2 VBVR bringt referenzgesteuerte Bewegungssteuerung in die Open-Source-Videoerzeugung. Liefere ein Startbild und einen Referenzbewegungsclip, und das Modell erzeugt ein konsistentes Video, in dem dein Motiv dieser Bewegung natürlich folgt. FP8 läuft auf einer 24-GB-RTX-3090 für 0,07–0,21 $/Std.; BF16 auf einer RTX 4090 für 0,14–0,42 $/Std. — beide auf Clore.ai.

**→** [**Miete eine GPU auf Clore.ai**](https://clore.ai/marketplace) und beginne noch heute damit, bewegungsgesteuerte Videos zu erzeugen.


---

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