HyperFlow H3 Flash: Video-mit-Ton-Modell auf 14 Milliarden Parameter geschrumpft

Das Start-up Video Rebirth hat das Video-und-Ton-Modell MiniMax-H3 von rund 31 auf knapp 14 Milliarden Parameter verkleinert. Es braucht nur noch 4 bis 8 Rechenschritte und läuft als GGUF auf Gaming-Grafikkarten mit 24 GB, laut einem Nutzertest sogar mit 16 GB. Der Haken für Leser in Deutschland: Die Lizenz deckt die Nutzung in der EU ohne Erlaubnis von MiniMax nicht ab.

Modell-Releases Selbst ausprobieren 7. Nov. 2026 6 Min. Lesezeit Quelle: Show HN (neue Projekte)

Das Wichtigste in Kürze

HyperFlow H3 Flash ist eine komprimierte Fassung von MiniMax-H3 mit 13,7 bzw. 13,9 Milliarden Parametern statt rund 31 Milliarden.
Das Modell erzeugt 5,2 bis 15 Sekunden Video mit 24 Bildern pro Sekunde (Standard 1344×768) und passendem Stereo-Ton in 32 kHz.
Standard sind 6 Rechenschritte ohne Classifier-Free Guidance; ein 5,2-Sekunden-Clip dauert laut Hersteller 92 Sekunden auf einer RTX 5090 und 8,7 Sekunden auf 4× B200.
Die kleinste empfohlene Quantisierung Q4_K_M ist 9,1 GB groß und läuft auf PCs mit 24- oder 32-GB-Grafikkarte und nur 16 GB Arbeitsspeicher.
Ein unabhängiger Test auf einer RTX 5060 Ti 16 GB zeigt: kaum schneller als die bisherige INT8-Fassung, aber deutlich mehr freier Grafikspeicher.
Die Lizenz (MiniMax H3 Community License) deckt die Nutzung in EU, Großbritannien, Südkorea und den USA ohne Genehmigung von MiniMax nicht ab.

Worum es geht

Das Unternehmen Video Rebirth hat mit HyperFlow H3 Flash eine stark verkleinerte und beschleunigte Version des Video-Modells MiniMax-H3 veröffentlicht. Wie das Original erzeugt es Video und dazu passenden Stereo-Ton in einem Durchgang – aus einem Textprompt, aus einem Start- oder Start-und-End-Bild oder aus bis zu zwölf Referenzen (Bilder, Videos, Audioclips). Die Gewichte liegen frei auf Hugging Face unter VideoRebirthAI/hyperflow-h3-flash, dazu gibt es ein Python-Paket, eigene ComfyUI-Nodes und Anleitungen für Unsloth Studio und stable-diffusion.cpp. Vorgestellt wurde das Projekt als „Show HN“ auf Hacker News.

Die Kernaussage: Aus dem rund 31 Milliarden Parameter großen Transformer von MiniMax-H3 wurden 13,7 Milliarden (Variante fl2va) bzw. 13,9 Milliarden (ref2va) – weniger als die Hälfte. Statt vieler Rechenschritte reichen 4, 6 (Standard) oder 8.

Was das Modell erzeugt

Länge: 5,2 bis 15 Sekunden Video bei 24 Bildern pro Sekunde
Auflösung: standardmäßig 1344×768, die Kantenlängen müssen Vielfache von 32 sein; auch 1920×1088 wurde getestet
Ton: Stereo mit 32 kHz, synchron zum Bild erzeugt
Aufgaben: Text zu Video+Audio (t2va), Keyframe(s) zu Video+Audio (fl2va), Referenzen zu Video+Audio (ref2va, maximal 9 Bilder, 3 Videos, 3 Audioclips, insgesamt 12)

Bei Referenzen schreibt man Platzhalter wie <Picture 1> in den Prompt, etwa „ läuft durch die Szene aus “. In den GGUF-Versionen funktionieren als Referenzen nur Bilder; Videos und Audio als Referenz gehen nur mit dem Python-Paket.

Wie die Verkleinerung funktioniert

Video Rebirth hat den MiniMax-H3-Transformer auf drei Arten umgebaut:

Pruning und Low-Rank-Faktorisierung: Einzelne Blöcke des Netzes wurden entfernt (bei fl2va 3 von 50, bei ref2va 1 von 50), und über 100 Rechenschichten wurden in kleinere Matrizen zerlegt – so, als würde man eine große Tabelle durch das Produkt zweier schmaler Tabellen annähern.
Rotierte INT8-Quantisierung („convrot“): 180 Schichten rechnen mit 8-Bit-Ganzzahlen statt mit größeren Fließkommazahlen. Vorher werden die Werte mit einer sogenannten Hadamard-Rotation „verwirbelt“, damit einzelne Ausreißer beim groben Speichern nicht so viel Schaden anrichten.
Zwei-Zeit-Konditionierung (t, r): Diffusionsmodelle entfernen schrittweise Rauschen aus einem Startbild. Hier bekommt jedes Token nicht nur den aktuellen Rauschwert t, sondern auch den Zielwert r des Schritts mitgeteilt. Dadurch kann das Modell in wenigen großen Sprüngen statt vielen kleinen arbeiten – und das ohne Classifier-Free Guidance (CFG), ein Verfahren, das sonst pro Schritt zwei Durchläufe nötig macht.

Wichtig: Den großen Textencoder (ein auf Qwen3-VL-32B basierender Teil von MiniMax-H3) behält das System bei; er wird nur geschickt beschnitten und verlagert.

Zahlen: Geschwindigkeit und Speicher

Alle Herstellerangaben gelten für 1344×768 und 6 Schritte, inklusive Textverarbeitung und Dekodierung von Bild und Ton.

Grafikkarte	GGUF Q4_K_M (≥ 64 GB RAM)	GGUF, 16 GB RAM	INT8 (≥ 69 GiB RAM)
RTX 5090 (32 GB)	99 s / 575 s	130 s / 615 s	92 s / 551 s
RTX 4090 (24 GB)	157 s / 830 s	153 s / 812 s	130 s / 750 s
RTX 3090 (24 GB)	315 s / 1835 s	325 s / 1866 s	266 s / 1684 s

Erster Wert: 5,2-Sekunden-Clip, zweiter Wert: 15-Sekunden-Clip.

Im Rechenzentrum geht es deutlich schneller: 36 Sekunden auf einer H200, 12,6 Sekunden auf vier H200 und 8,7 Sekunden auf vier B200 für einen 5,2-Sekunden-Clip. Mit Nvidias Beschleunigungs-Engine SOL-H3 soll das Modell auf vier Blackwell-GPUs laut Video Rebirth sogar in Echtzeit laufen. Die INT8-Fassung ist laut Hersteller 10 bis 20 Prozent schneller als GGUF, braucht aber mehr als doppelt so viel Arbeitsspeicher.

Referenzen machen die Erzeugung teuer: Ein Referenzbild mit 2048 Pixeln an der kurzen Kante fügt rund 14.300 Tokens hinzu, der Clip selbst hat 37.710 (5,2 s) bzw. 109.062 Tokens (15 s). Weil der Rechenaufwand der Aufmerksamkeit mit dem Quadrat der Tokenzahl wächst, dauert ref2va mit zwei Bildern beim INT8-Transformer 2,6- bis 2,9-mal so lange wie reines Text-zu-Video.

Was ein unabhängiger Test zeigt

Ein Nutzer auf note.com hat das Modell auf einer RTX 5060 Ti mit 16 GB getestet – eine Konfiguration, die Video Rebirth selbst noch nicht gemessen hat. Verglichen hat er mit der bisherigen beschnittenen INT8-Fassung von H3 bei 832×480, 124 Bildern und gleichem Seed:

Konfiguration	Schritte	Zeit	Freier VRAM (Spitze)
Bisheriges H3 (INT8)	8	ca. 130,5 s	0,49–0,54 GB
HyperFlow Flash (Q4_K_M)	6	130,6–132,5 s	3,07–3,33 GB
HyperFlow Flash	4	95,4 s	3,07 GB

Sein Fazit: Schneller wurde es bei 6 Schritten nicht, weil jeder einzelne Schritt länger dauert. Bei 4 Schritten war es 27 Prozent schneller, aber die Bewegung nahm messbar ab – mehr nahezu stehende Bilder. Der klare Gewinn liege beim Speicher: Statt etwa 0,5 GB blieben gut 3 GB Grafikspeicher frei, was auf seiner Karte Abstürze verhindert. Die Kantenschärfe fiel bei Flash minimal besser aus.

Was du zum Ausprobieren brauchst

Grafikkarte: Nvidia, Ampere-Generation (RTX 30) oder neuer. Offiziell gemessen sind 24 und 32 GB VRAM; die Spitzenbelegung liegt dort bei 22–28 GiB. Laut dem note.com-Test läuft es auch auf 16 GB, dann eher mit kleinerer Auflösung.
Arbeitsspeicher: Für die GGUF-Variante in ComfyUI genügen 16 GB RAM, wenn man mit --fast-disk startet und die Modelle auf einer NVMe-SSD liegen. Die INT8-Python-Variante braucht auf Consumer-Karten mindestens 69 GiB (fp8-Textencoder) oder 91 GiB RAM.
Speicherplatz: Das Transformer-GGUF ist 7,2 bis 15,2 GB groß, dazu kommt ein 15,7 GB großer Textencoder plus VAEs. Die Python-Variante lädt beim ersten Start rund 90 GB (68 GB mit fp8).
Mac, CPU, Colab: Nicht vorgesehen – das Python-Paket verlangt CUDA, und die gemessenen Pfade sind alle Nvidia-basiert.

Einordnung

HyperFlow H3 Flash zeigt, wie viel sich aus einem großen Video-Modell herausholen lässt: halbe Größe, wenige Schritte, Ton inklusive, und das auf einer normalen Gaming-Karte. Für alle, die bereits mit MiniMax-H3 in ComfyUI arbeiten, ist vor allem der geringere Speicherbedarf interessant. Die Geschwindigkeitsgewinne sind auf Consumer-Hardware allerdings überschaubar; anderthalb bis fünf Minuten für einen 5-Sekunden-Clip sind kein Echtzeit-Erlebnis, und der unabhängige Test relativiert den Tempo-Vorteil weiter. Weniger Schritte kosten offenbar Bewegung.

Für Leser in Deutschland gibt es einen gewichtigen Haken: Die Gewichte stehen unter der MiniMax H3 Community License. Laut Video Rebirth deckt diese die Nutzung in der Europäischen Union, Großbritannien, Südkorea und den USA ohne Genehmigung von MiniMax nicht ab. Wer das Modell hier einsetzt, bewegt sich also ohne ausdrückliche Erlaubnis außerhalb der Lizenz – das gilt besonders für kommerzielle Nutzung. Der Code selbst ist dagegen Apache-2.0 (ComfyUI-Nodes GPL-3.0). Zu Bildqualität im Vergleich zum vollen MiniMax-H3 liefert der Hersteller keine systematischen Messungen; das bleibt offen.

Begriffe einfach erklärt

Diffusionsmodell: Ein KI-Modell, das Bilder oder Videos erzeugt, indem es aus reinem Rauschen Schritt für Schritt ein klares Ergebnis herausrechnet.
Pruning: Das gezielte Entfernen von Teilen eines neuronalen Netzes, die wenig beitragen – ähnlich wie man überflüssige Äste von einem Baum schneidet.
INT8-Quantisierung: Die Zahlen des Modells werden als 8-Bit-Ganzzahlen statt als genauere Fließkommazahlen gespeichert und berechnet. Das spart Speicher und Rechenzeit bei geringem Qualitätsverlust.
GGUF: Ein Dateiformat für komprimierte KI-Modelle, das in Programmen wie ComfyUI oder stable-diffusion.cpp genutzt wird. Kürzel wie Q4_K_M geben an, wie stark komprimiert wurde.
Classifier-Free Guidance (CFG): Ein Verfahren, das das Ergebnis enger an den Prompt bindet, dafür aber pro Rechenschritt zwei Durchläufe braucht. HyperFlow kommt ohne aus.
Offloading: Teile des Modells werden im normalen Arbeitsspeicher geparkt und nur bei Bedarf auf die Grafikkarte geladen, damit auch Karten mit wenig Speicher das Modell nutzen können.
ComfyUI: Eine beliebte, kostenlose Oberfläche, in der man KI-Bild- und Video-Modelle über verbundene Bausteine (Nodes) steuert.

Quellen

Show HN (neue Projekte) github.com
note.com note.com

#video-generierung#minimax#quantisierung#comfyui#open-weights#audio

Originalquelle lesen

Selbst ausprobieren: HyperFlow H3 Flash

Schritt für Schritt erklärt, auch ohne Vorkenntnisse – auf deinem Rechner oder kostenlos im Browser.

Was kann ich damit machen?

HyperFlow H3 Flash erzeugt kurze Videoclips von 5,2 bis 15 Sekunden mit passendem Stereo-Ton – Geräusche, Atmosphäre und Musik entstehen gleich mit. Du kannst einen Text eingeben, ein Startbild (oder Start- und Endbild) vorgeben oder mehrere Referenzbilder kombinieren, etwa eine Person und einen Ort. Gegenüber dem vollen MiniMax-H3 ist es weniger als halb so groß und braucht nur 4 bis 8 Rechenschritte, was es überhaupt erst auf Gaming-Grafikkarten bringt. Auf einer RTX 4090 dauert ein 5-Sekunden-Clip laut Hersteller rund zweieinhalb Minuten, auf einer RTX 3090 gut fünf Minuten. Ein unabhängiger Test auf einer 16-GB-Karte zeigt, dass es gegenüber der bisherigen H3-INT8-Fassung kaum schneller ist, aber viel mehr Grafikspeicher frei lässt. Mit 4 Schritten wird es schneller, allerdings werden Bewegungen ruhiger und Bilder wirken öfter fast stehend. Echtzeit gibt es nur auf teuren Rechenzentrums-GPUs.

Für wen lohnt es sich?

Lohnt sich für Leute mit einer Nvidia-Karte ab 24 GB VRAM (mit Abstrichen 16 GB), die bereits ComfyUI nutzen und Video mit Ton lokal erzeugen wollen. Wer in der EU kommerziell arbeitet, sollte wegen der Lizenz die Finger davon lassen oder MiniMax um Erlaubnis bitten; ohne Nvidia-GPU oder auf dem Mac ist es nicht sinnvoll.

Ideen: Was du damit anstellen kannst

Social-Media-Clip mit Sound

Beschreibe eine kurze Szene samt Geräuschkulisse und lass einen 5-Sekunden-Clip im Hochformat oder 16:9 erzeugen. Das Ergebnis ist ein fertiges MP4 mit Ton, das du direkt als Reel oder Story nutzen kannst.

Foto zum Leben erwecken

Lade ein eigenes Foto als Startbild in den Workflow hyperflow_i2v und beschreibe, was passieren soll. Heraus kommt ein kurzer Clip, der genau mit deinem Bild beginnt und passende Geräusche hat.

Übergang zwischen zwei Bildern

Mit hyperflow_flf2v gibst du Start- und Endbild vor, etwa ein Zimmer vorher und nachher. Das Modell erfindet die Bewegung dazwischen – praktisch für Vorher-nachher-Videos oder Storyboards.

Figur in neue Umgebung setzen

Kombiniere im Workflow hyperflow_ref2v ein Bild einer Figur mit einem Bild eines Ortes und verweise im Prompt mit <Picture 1> und <Picture 2> darauf. So entsteht eine Szene, in der deine Figur durch diesen Ort läuft.

Storyboard für Film- oder Spielprojekte

Erzeuge mehrere kurze Szenen aus einem Drehbuch, um Kamerawinkel, Stimmung und Ton auszuprobieren, bevor gedreht oder animiert wird. Schnell genug, um Varianten zu vergleichen, auch wenn die Clips nicht final sind.

Größe13,9 Mrd. Parameter

Download32 GB (bei 100 MBit/s ca. 43 Min.)

Lizenzeigene Lizenz (siehe Model Card)

ArtVideogenerator

Hugging FaceVideoRebirthAI/hyperflow-h3-flash

Was dein Rechner braucht

Grafikkarte (NVIDIA) mind. 24 GB VRAMDas sind Herstellerangaben: Die GGUF-Variante Q4_K_M (9,1 GB) wurde auf Grafikkarten mit 24 und 32 GB gemessen. Auf 24-GB-Karten lag der höchste Verbrauch bei etwa 23 GiB. Karten mit 16 GB hat der Hersteller noch nicht getestet. Mehr Grafikspeicher erlaubt größere Varianten wie Q6_K oder Q8_0, die näher an der vollen Qualität liegen.

Mac (Apple Silicon M1–M5) ab 36 GB gemeinsamer SpeicherGrafik und Prozessor teilen sich den Speicher – etwa 70 % davon kann das Modell nutzen

Speicherplatz ca. 34 GB freiModell-Download plus Programme

Für Heim-PCs mit 64 GB RAM oder weniger empfiehlt der Hersteller die GGUF-Dateien in ComfyUI. Q4_K_M (9,1 GB) ist der empfohlene Standard für 24-GB-Karten; Q8_0 (14,9 GB) ist am nächsten an voller Präzision, wenn genug VRAM und RAM vorhanden sind; Q3_K_M (7,2 GB) ist die kleinste Variante, etwa für 16-GB-Karten. Für Text-zu-Video und Keyframe-Videos nimmt man den Ordner fl2va_gguf, für Referenzbilder ref2va_gguf. Die INT8-Python-Variante lohnt sich nur auf Rechenzentrums-GPUs oder auf RTX-Karten ab 24 GB mit mindestens 69 GiB Arbeitsspeicher.

Nvidia-GPU ab Ampere-Generation (RTX 30xx) nötig; offiziell gemessen auf RTX 3090, 4090 und 5090.
Spitzen-VRAM in ComfyUI mit Q4_K_M: etwa 22–23 GiB auf 24-GB-Karten, 27–28 GiB auf der RTX 5090. 16-GB-Karten sind offiziell nicht gemessen, ein Nutzertest mit RTX 5060 Ti bei 832×480 lief aber.
GGUF läuft schon mit 16 GB Arbeitsspeicher, wenn ComfyUI mit --fast-disk gestartet wird und die Modelle auf einer NVMe-SSD liegen.
Zusätzlich zum Transformer wird ein 15,7 GB großer Textencoder (qwen3vl_32b_minimax_h3_nvfp4_awq) benötigt – plane insgesamt rund 30 GB Speicherplatz ein.
Längere Clips (15 s) dauern etwa fünf- bis sechsmal so lange wie 5,2-Sekunden-Clips und brauchen mehr Speicher.
Referenzbilder erhöhen Rechenzeit und Speicherbedarf deutlich, weil jedes Bild tausende zusätzliche Tokens erzeugt.

Wie finde ich heraus, was mein Rechner hat?

Windows: Strg + Umschalt + Esc drücken → Task-Manager → Reiter Leistung → links GPU anklicken. Unten steht Dedizierter GPU-Speicher (das ist dein VRAM). Den Arbeitsspeicher findest du unter Arbeitsspeicher.
Mac: Apfel-Menü oben links → Über diesen Mac. Dort stehen Chip (z. B. M2) und Speicher (z. B. 16 GB). Bei Apple-Chips teilen sich Grafik und Prozessor diesen Speicher.
Linux: Im Terminal nvidia-smi eingeben (zeigt Grafikkarte und Speicher) und free -h für den Arbeitsspeicher.

Anleitung

Dieses Modell läuft mit einem eigenen Programm seiner Entwickler (NVlabs/Sana auf GitHub). Die Befehle unten stammen aus der Model Card und der Anleitung der Entwickler.

Windows 10 / 11

Windows 10 / 11: unterstützt. Die Python-Variante des Herstellers unterstützt Windows ausdrücklich. Für normale PCs mit wenig Arbeitsspeicher empfiehlt er aber den Weg über ComfyUI mit GGUF, und den beschreiben wir hier. Du brauchst eine NVIDIA-Karte mit 24 GB. Achtung: Laut Lizenz ist die Nutzung in der EU ohne Erlaubnis von MiniMax nicht gestattet.

Voraussetzungen prüfen. Du brauchst eine NVIDIA-Grafikkarte ab RTX 30xx mit mindestens 24 GB Grafikspeicher (VRAM), einen aktuellen NVIDIA-Treiber, 16 GB Arbeitsspeicher und rund 40 GB freien Platz. Außerdem müssen Python ab Version 3.10 und Git für Windows installiert sein. Öffne die PowerShell und prüfe alles mit den Befehlen unten.
```
nvidia-smi
python --version
git --version
```
ComfyUI installieren. ComfyUI ist das Programm, in dem das Modell läuft. Installiere es nach der offiziellen ComfyUI-Anleitung für Windows, am besten mit einer eigenen Python-Umgebung (venv), also einem abgetrennten Ordner nur für dieses Programm. Starte es einmal zum Test. Am Ende hast du einen Ordner namens ComfyUI.
Erweiterungen holen. Damit ComfyUI das Modell versteht, brauchst du zwei Erweiterungen (Custom Nodes). ComfyUI-GGUF liest die komprimierten Modelldateien, ComfyUI-HyperFlow-Flash bringt die passenden Vorlagen mit.
```
cd ComfyUI\custom_nodes
git clone https://github.com/city96/ComfyUI-GGUF
git clone https://github.com/Video-Rebirth/ComfyUI-HyperFlow-Flash
```
Zusatzpakete installieren. Aktiviere zuerst die Python-Umgebung von ComfyUI. Danach installierst du die Pakete der GGUF-Erweiterung und das Download-Werkzeug von Hugging Face. Meldet die PowerShell, dass keine Skripte ausgeführt werden dürfen, gib vorher Set-ExecutionPolicy -Scope CurrentUser RemoteSigned ein.
```
..\.venv\Scripts\Activate.ps1
pip install -r ComfyUI-GGUF\requirements.txt
pip install -U huggingface_hub
cd ..
```
Modell herunterladen. Jetzt lädst du die empfohlene Variante Q4_K_M (etwa 9 GB) in den Ordner models\diffusion_models. Falls eine Anmeldung nötig ist, melde dich vorher mit hf auth login an und akzeptiere die Lizenz auf der Modellseite.
```
hf download VideoRebirthAI/hyperflow-h3-flash fl2va_gguf/minimax_h3_fl2va_hyperflow_flash_14b-Q4_K_M.gguf --local-dir models\diffusion_models
```

Textencoder und VAEs herunterladen. Der Textencoder übersetzt deinen Text in Zahlen (15,7 GB). Die VAEs machen am Ende daraus Bild und Ton. Die Dateien landen automatisch in models\text_encoders und models\vae.

hf download Comfy-Org/MiniMax-H3 text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors --local-dir models
hf download Comfy-Org/MiniMax-H3 vae/minimax_h3_video_vae_fp16.safetensors vae/minimax_h3_audio_vae_fp32.safetensors --local-dir models

ComfyUI starten. Starte ComfyUI mit der Option --fast-disk. Sie spart Arbeitsspeicher und wird für PCs mit 16 oder 32 GB empfohlen. Öffne dann im Browser die angezeigte Adresse, meistens http://127.0.0.1:8188.
```
python main.py --fast-disk
```
Vorlage öffnen und erstes Video erzeugen. Wähle Workflow > Browse Templates > ComfyUI-HyperFlow-Flash > hyperflow_t2v. Prüfe, dass die heruntergeladenen Dateien ausgewählt sind. Gib als Prompt ein: A chef slides a steaming bowl of ramen across a wooden counter; rain taps on the window. Klicke dann auf Run. Das dauert je nach Karte etwa 2 bis 5 Minuten.
Ergebnis ansehen. Das Video mit Ton erscheint in ComfyUI und liegt im Ordner ComfyUI\output. Reicht der Speicher nicht, nimm die kleinere Variante Q3_K_M.
Ergebnis. Im Ordner ComfyUI/output liegt ein etwa 5 Sekunden langes Video mit Ton: Ein Koch schiebt eine dampfende Schüssel Ramen über eine Holztheke.

macOS

macOS: nicht offiziell getestet. Der Hersteller nennt nur NVIDIA-Grafikkarten. Macs werden nirgends erwähnt, und die schnelle Python-Variante setzt CUDA voraus, das es auf dem Mac nicht gibt. Ob der ComfyUI-Weg auf Apple Silicon funktioniert, ist offen. Rechne mit sehr langen Laufzeiten und mindestens 32 GB gemeinsamem Speicher. Realistischer ist ein Windows- oder Linux-PC mit NVIDIA-Karte oder eine gemietete Cloud-GPU. Laut Lizenz ist die Nutzung in der EU ohne Erlaubnis nicht gestattet.

Voraussetzungen prüfen. Du brauchst einen Mac mit Apple-Chip (M1 oder neuer), möglichst viel Arbeitsspeicher und rund 40 GB freien Platz. Installiere die Xcode-Kommandozeilenwerkzeuge (sie bringen Git mit) und Python ab Version 3.10. Prüfe alles im Terminal.
```
xcode-select --install
python3 --version
git --version
```
ComfyUI installieren. ComfyUI ist das Programm, in dem das Modell läuft. Installiere es nach der offiziellen ComfyUI-Anleitung für macOS, am besten mit einer eigenen Python-Umgebung (venv). Am Ende hast du einen Ordner namens ComfyUI.

Erweiterungen holen. Damit ComfyUI das Modell versteht, holst du die beiden Erweiterungen in den Ordner custom_nodes.

cd ComfyUI/custom_nodes
git clone https://github.com/city96/ComfyUI-GGUF
git clone https://github.com/Video-Rebirth/ComfyUI-HyperFlow-Flash

Zusatzpakete installieren. Aktiviere die Python-Umgebung von ComfyUI. Danach installierst du die Pakete der GGUF-Erweiterung und das Download-Werkzeug von Hugging Face.
```
source ../.venv/bin/activate
pip install -r ComfyUI-GGUF/requirements.txt
pip install -U huggingface_hub
cd ..
```

Modell und Hilfsdateien herunterladen. Lade das Modell (Q4_K_M, etwa 9 GB), den Textencoder (15,7 GB) und die beiden VAEs. Die Dateien landen automatisch in den richtigen Unterordnern von models. Hinweis: Der Textencoder im Format nvfp4 ist für NVIDIA-Karten gedacht und läuft auf dem Mac womöglich gar nicht.

hf download VideoRebirthAI/hyperflow-h3-flash fl2va_gguf/minimax_h3_fl2va_hyperflow_flash_14b-Q4_K_M.gguf --local-dir models/diffusion_models
hf download Comfy-Org/MiniMax-H3 text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors --local-dir models
hf download Comfy-Org/MiniMax-H3 vae/minimax_h3_video_vae_fp16.safetensors vae/minimax_h3_audio_vae_fp32.safetensors --local-dir models

ComfyUI starten. Starte ComfyUI mit der speichersparenden Option --fast-disk. Öffne dann im Browser http://127.0.0.1:8188.
```
python3 main.py --fast-disk
```
Erstes Video versuchen. Wähle Workflow > Browse Templates > ComfyUI-HyperFlow-Flash > hyperflow_t2v. Gib als Prompt ein: A chef slides a steaming bowl of ramen across a wooden counter; rain taps on the window. Klicke auf Run. Klappt es, liegt das Video im Ordner ComfyUI/output. Erscheinen Fehlermeldungen, wird dein Mac wahrscheinlich nicht unterstützt.
Ergebnis. Im Ordner ComfyUI/output liegt ein etwa 5 Sekunden langes Video mit Ton: Ein Koch schiebt eine dampfende Schüssel Ramen über eine Holztheke.

Linux

Linux: unterstützt. Läuft über ComfyUI (eine Bedienoberfläche für Bild- und Video-KI) mit GGUF-Dateien. Der Hersteller hat das auf RTX 3090, 4090 und 5090 gemessen, auch auf PCs mit nur 16 GB Arbeitsspeicher. Wichtig: Laut Lizenz ist die Nutzung in der EU, im Vereinigten Königreich, in Südkorea und in den USA ohne Erlaubnis von MiniMax nicht gestattet. Prüfe das, bevor du loslegst.

Voraussetzungen prüfen. Du brauchst eine NVIDIA-Grafikkarte ab RTX 30xx mit mindestens 24 GB Grafikspeicher (VRAM), dazu einen aktuellen NVIDIA-Treiber, 16 GB Arbeitsspeicher und rund 40 GB freien Platz auf der Festplatte. Außerdem müssen Python ab Version 3.10 und Git installiert sein. Mit den Befehlen unten prüfst du alles: nvidia-smi zeigt deine Grafikkarte an, die anderen beiden zeigen die Versionsnummern.
```
nvidia-smi
python3 --version
git --version
```
ComfyUI installieren. ComfyUI ist das Programm, in dem das Modell läuft. Installiere es nach der offiziellen ComfyUI-Anleitung, am besten in einer eigenen Python-Umgebung (venv), also einem abgetrennten Ordner nur für dieses Programm. Starte es einmal zum Test. Am Ende hast du einen Ordner namens ComfyUI.
Erweiterungen holen. Damit ComfyUI das Modell versteht, brauchst du zwei Erweiterungen, sogenannte Custom Nodes. ComfyUI-GGUF liest die komprimierten Modelldateien, ComfyUI-HyperFlow-Flash bringt die passenden Vorlagen mit. Beide kommen in den Ordner custom_nodes.
```
cd ComfyUI/custom_nodes
git clone https://github.com/city96/ComfyUI-GGUF
git clone https://github.com/Video-Rebirth/ComfyUI-HyperFlow-Flash
```
Zusatzpakete installieren. Aktiviere zuerst die Python-Umgebung von ComfyUI. Danach installierst du die Pakete, die die GGUF-Erweiterung braucht, und das Download-Werkzeug von Hugging Face. Liegt auch im Ordner ComfyUI-HyperFlow-Flash eine Datei requirements.txt, installierst du sie genauso.
```
source ../.venv/bin/activate
pip install -r ComfyUI-GGUF/requirements.txt
pip install -U huggingface_hub
cd ..
```
Modell herunterladen. Jetzt lädst du die empfohlene Variante Q4_K_M (etwa 9 GB). Sie kommt in den Ordner models/diffusion_models. Falls Hugging Face eine Anmeldung verlangt, melde dich vorher mit hf auth login an und akzeptiere auf der Modellseite die Lizenz.
```
hf download VideoRebirthAI/hyperflow-h3-flash fl2va_gguf/minimax_h3_fl2va_hyperflow_flash_14b-Q4_K_M.gguf --local-dir models/diffusion_models
```
Textencoder und VAEs herunterladen. Das Modell braucht noch Hilfsdateien. Der Textencoder übersetzt deinen Text in Zahlen (15,7 GB). Die VAEs wandeln das Ergebnis am Ende in Bild und Ton um. Die Befehle legen alles automatisch in die richtigen Unterordner text_encoders und vae.
```
hf download Comfy-Org/MiniMax-H3 text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors --local-dir models
hf download Comfy-Org/MiniMax-H3 vae/minimax_h3_video_vae_fp16.safetensors vae/minimax_h3_audio_vae_fp32.safetensors --local-dir models
```
ComfyUI starten. Starte ComfyUI aus dem Ordner ComfyUI. Die Option --fast-disk spart Arbeitsspeicher und wird für PCs mit 16 oder 32 GB empfohlen. Öffne danach im Browser die Adresse, die im Terminal angezeigt wird, meistens http://127.0.0.1:8188.
```
python main.py --fast-disk
```
Vorlage öffnen und erstes Video erzeugen. Klicke auf Workflow > Browse Templates > ComfyUI-HyperFlow-Flash und wähle hyperflow_t2v (Text zu Video). Prüfe, dass in den Ladefeldern die heruntergeladenen Dateien ausgewählt sind. Gib als Prompt das Beispiel aus der Anleitung ein: A chef slides a steaming bowl of ramen across a wooden counter; rain taps on the window. Klicke dann auf Run. Auf einer RTX 4090 dauert das etwa 2,5 Minuten, auf einer RTX 3090 rund 5 Minuten.
Ergebnis ansehen. Das fertige Video mit Ton erscheint in ComfyUI und liegt zusätzlich im Ordner ComfyUI/output. Bricht der Lauf wegen zu wenig Speicher ab, nimm die kleinere Variante Q3_K_M.
Ergebnis. Im Ordner ComfyUI/output liegt ein etwa 5 Sekunden langes Video mit Ton: Ein Koch schiebt eine dampfende Schüssel Ramen über eine Holztheke.

So geht es nach dem ersten Ergebnis weiter

Ändere im Workflow den Text (Prompt) und beschreibe deine eigene Szene. Das Modell erzeugt Bild und passenden Stereo-Ton gleichzeitig.
Mit den Vorlagen hyperflow_i2v und hyperflow_flf2v machst du aus einem Startbild (oder aus Start- und Endbild) ein Video. Dafür reicht dieselbe fl2va-Datei.
Für hyperflow_ref2v (bis zu 12 Referenzbilder, zum Beispiel eine Person und ein Ort) brauchst du zusätzlich die Datei aus dem Ordner ref2va_gguf, zum Beispiel minimax_h3_ref2va_hyperflow_flash_14b-Q4_K_M.gguf.
Längere Videos bis 15 Sekunden sind möglich, dauern aber deutlich länger: Auf einer RTX 4090 sind es rund 14 Minuten statt etwa 2,5 Minuten.

Das kannst du ausprobieren

Ein Koch schiebt eine dampfende Schüssel Ramen über eine Holztheke, draußen prasselt Regen gegen das Fenster.

Eine Katze springt auf einen Küchentisch und stößt eine Tasse um, die klirrend auf dem Boden zerbricht.

Wellen brechen bei Sonnenuntergang an einer felsigen Küste, Möwen kreischen, Wind rauscht im Mikrofon.

Ein Straßenmusiker spielt Akkordeon auf einem belebten Marktplatz, Passanten bleiben stehen und klatschen.

<Picture 1> läuft durch den Straßenmarkt aus <Picture 2>, bleibt an einem Gemüsestand stehen und lacht mit dem Verkäufer.

Tipps für bessere Ergebnisse

Starte mit 6 Schritten (Standard). 4 Schritte sind schneller, liefern laut Nutzertest aber spürbar weniger Bewegung; 8 Schritte sind für die beste Qualität gedacht.
CFG bleibt bei 1 – das Modell ist dafür trainiert, ohne Classifier-Free Guidance zu arbeiten. Höhere Werte bringen hier nichts.
Teste neue Prompts erst mit 5,2-Sekunden-Clips und eventuell kleinerer Auflösung, bevor du 15 Sekunden in voller Auflösung rendern lässt.
Beschreibe Geräusche ausdrücklich im Prompt (Regen, Stimmen, Musik), denn der Ton wird aus derselben Beschreibung erzeugt.
Bei Referenzbildern ist die Einstellung ref_image_size 'match' am schnellsten; 'max' bewahrt mehr Details, kostet aber deutlich mehr Zeit und Speicher.

Wenn es hakt

Lizenz: Die MiniMax H3 Community License deckt die Nutzung in EU, Großbritannien, Südkorea und den USA ohne Genehmigung von MiniMax nicht ab – vor allem bei kommerziellem Einsatz vorher klären.

ComfyUI braucht zwei Custom-Node-Pakete: ComfyUI-GGUF und ComfyUI-HyperFlow-Flash, beide in ComfyUI/custom_nodes/ klonen; sonst fehlen die Workflow-Vorlagen.

Auf PCs mit 16 oder 32 GB RAM unbedingt mit python main.py --fast-disk starten, sonst läuft bei 15-Sekunden-Clips der Arbeitsspeicher voll bzw. es wird 13–21 % langsamer.

Bei ref2v mit großen Referenzbildern (max) und 15 s ComfyUI mit --disable-cuda-malloc starten, sonst erscheint 'CUDA error: invalid argument'.

Die Python-INT8-Variante lädt beim ersten Start rund 90 GB herunter und kompiliert etwa eine Minute lang Kernel; unter Windows wird triton-windows benötigt, Multi-GPU nur unter Linux/WSL2.

Bildmaße müssen Vielfache von 32 sein; die Bildanzahl wird auf 17n+5 aufgerundet (360 wird zu 362).

„out of memory“, Absturz oder der Rechner hängt

Das Modell ist zu groß für deinen Grafikspeicher. Nimm eine kleinere Variante aus der Tabelle oben und schließe andere Programme, vor allem Spiele und Browser mit vielen Tabs.

Es läuft, aber extrem langsam

Wahrscheinlich rechnet der Prozessor statt der Grafikkarte. Bei Ollama zeigt ollama ps in der Spalte PROCESSOR, wie viel auf der GPU läuft. Steht dort „100% CPU“, Grafiktreiber aktualisieren oder eine kleinere Variante nehmen, die komplett in den Grafikspeicher passt.

„ollama“ bzw. „python“ wird nicht gefunden

Das Eingabefenster schließen und neu öffnen, damit es das frisch installierte Programm kennt. Bei Python unter Windows: neu installieren und das Häkchen Add python.exe to PATH setzen.

Windows: „Die Ausführung von Skripts ist auf diesem System deaktiviert“

Das Skript genau mit dem Befehl oben starten: powershell -ExecutionPolicy Bypass -File try_windows.ps1. Das erlaubt die Ausführung nur dieses einen Mal.

Fehlermeldung beim Laden des Modells (Version, „trust_remote_code“, unbekannte Architektur)

Ganz neue Modelle brauchen oft die neueste Programmversion. Bei Ollama: Ollama aktualisieren. Bei Python: pip install -U transformers in der aktivierten Umgebung. Die Model Card nennt meist die genaue Version.

Skripte und Notebook erzeugt Tokenstrom automatisch. Bitte vor dem Ausführen kurz ansehen – sie sind lesbarer Klartext. Lizenz des Modells beachten: eigene Lizenz (siehe Model Card).

Frag den KI-Assistenten

Fragen zu diesem Artikel, zur Installation oder zu Hintergründen? Unser Assistent kennt diese Seite und läuft auf unserem eigenen Rechner, nicht in einer fremden Cloud.

Verbinde …

Der Assistent ist eine KI (Gemma 4) und kann sich irren – wichtige Angaben bitte in der Quelle prüfen. Fragen werden nur zum Beantworten genutzt und nach einer Stunde gelöscht. Bitte keine persönlichen Daten eingeben.

Kommentare

Was meinst du dazu? Schon ausprobiert? Schreib es hier, ohne Anmeldung.

Kommentare werden geladen …

Kommentare sind öffentlich. Links sind nicht erlaubt, beleidigende Beiträge löschen wir. Deinen eigenen Kommentar kannst du in diesem Browser jederzeit wieder löschen. Mehr dazu in der Datenschutzerklärung.