SenseNova 6.8 Code2Video: Offenes 27B-Modell schreibt Code, der Videos erzeugt

SenseNova hat ein offenes Modell mit 27 Milliarden Parametern veröffentlicht, das Videos nicht direkt generiert, sondern als ausführbaren Code schreibt, rendert und nach Anweisungen überarbeitet. Das eignet sich vor allem für Motion Design und Erklärvideos; fotorealistisches Material kann es nicht.

Modell-Releases Selbst ausprobieren 27. Okt. 2026 4 Min. Lesezeit Quelle: r/LocalLLaMA
Symbolbild, KI-generiert

Worum es geht

Das Projekt OpenSenseNova hat SenseNova 6.8 Code2Video veröffentlicht, ein offenes Sprachmodell mit 27 Milliarden Parametern (Parameter – grob gesagt die Stellschrauben, die das Modell beim Training gelernt hat). Es ist auf Qwen3.8-27B aufgebaut und feinabgestimmt. Es erzeugt Videos nicht wie klassische Videomodelle Pixel für Pixel, sondern schreibt ausführbaren Code, der die Bilder berechnet. Gewichte, ein begleitender Skill (eine Sammlung von Arbeitsanleitungen und Werkzeugen für den KI-Agenten), Prompt-Vorlagen und komplette Produktionsverläufe sind auf GitHub und Hugging Face verfügbar. Der Ansatz ähnelt Animations-Workflows, die Nutzer mit großen proprietären Modellen aufbauen: Das Modell schreibt Code, Werkzeuge rendern ihn zu Video, weitere Anweisungen überarbeiten das Ergebnis.

Warum Code statt Videomodell

Die Entwickler nennen drei Schwächen generativer Videomodelle, die den ganzen Clip in einem einzigen Sampling-Vorgang erzeugen:

  • Keine Bodenhaftung: Das Modell lernt, wie die Welt aussieht, nicht wie sie funktioniert. Bewegungen wirken plausibel, können aber physikalisch falsch sein.
  • Schwer zu bearbeiten: Größe, Timing und Bahn bleiben implizit. Eine Änderung bedeutet neu prompten und neu samplen, wobei sich der Rest des Clips mitverändert.
  • Ungenaue Inhalte: Text, Formeln, Diagramme und Zahlen müssen exakt stimmen, werden aber leicht verfälscht.

Code soll das lösen: Jedes Element ist ein benanntes Objekt, Text wird wörtlich gesetzt, Koordinaten, Dauern und Kamerapfade sind explizite Zahlen. Jedes Bild ist eine reine Funktion der Zeit t, derselbe Code rendert also immer denselben Film. Bewegung, Kollisionen und Licht werden berechnet statt geraten. Außerdem sei das Rendern auf normaler Hardware deutlich billiger als das Sampling eines Videomodells. Der Code kann zudem Bild-, Video-, 3D- und Schnittmodelle aufrufen. Als Ausblick nennen die Autoren Code-Renderings als schnelle Vorschau für Videomodelle sowie exakt beschriftete Daten (Tiefe, Kameraposen, Multi-View) für Weltmodelle.

Überarbeiten statt neu würfeln

Besonders betont wird das iterative Arbeiten. Nach dem ersten Schnitt nimmt das Modell Anmerkungen (neuer Look, zusätzliche Elemente, anderes Tempo) entgegen, ändert den Code im selben Projekt und rendert neu. Als Beispiel nennt das Repo eine Retro-Flughafen-Anzeigetafel: Die erste Fassung zeigt eine dunkle Tafel im Scheinwerferlicht, Runde 2 gestaltet sie als helle Pastell-Hotellobby um, Runde 3 ergänzt ein Flugzeug und Reisende mit Gepäck. Text, Timing und Flip-Mechanik, die nicht geändert werden sollten, bleiben laut Hersteller identisch. Laut Reddit-Beitrag kann das Modell auch den visuellen Stil eines Referenzvideos als editierbaren Code nachbauen.

Modell, Skill und Betrieb

Das Modell unterstützt 512K Kontext (rund eine halbe Million Token), geht laut Hersteller gut mit Kontextverdichtung um und hält Sitzungen mit über tausend Turns durch. Der Download erfolgt per huggingface-cli. Die Beispiele zum Bereitstellen nutzen LightLLM, vLLM oder SGLang jeweils mit --tp 4, also Tensor-Parallelismus über vier GPUs, und einer maximalen Länge von 524288 Token.

Als empfohlene Umgebung („Harness“) dient Claude Code. Ein kompletter Film ist eine langfristige Aufgabe: schreiben, rendern, Frames prüfen, überarbeiten. Das Modell soll Läufe von mehr als 10 Stunden und mehr als 2.000 Turns durchhalten. Empfohlene Einstellungen:

Einstellung Wert
Kontextfenster 512K (CLAUDE_CODE_MAX_CONTEXT_TOKENS=524288)
Auto-Verdichtung bei 80 %
Max. Ausgabe 64K
Turns pro Lauf 2.000+
Zeit pro Lauf 10 h+

Der Skill code-video macht die Produktion zu einem prüfbaren Ablauf: Spezifikation schreiben, jedes Bild als Funktion der Zeit rendern, Kontaktbögen als Bilder prüfen, die gelieferte Datei verifizieren. Er enthält acht Handwerksleitfäden (Erklärvideos, stilisierte Looks, Simulationen, Charaktere, 3D-Szenen, Motion Graphics, Ton und Sprecher, Musiksynchronisation). Benötigt werden Claude Code, Node.js 18+, Python 3, ffmpeg und passende Schriftarten; Playwright mit Chromium wird für das Rendern installiert. Optional wird ein kurzer Wunsch mit einer Vorlage zu einem ausführlichen Produktionsbriefing aufgeblasen, am besten durch ein starkes Modell wie Claude.

Was du zum Ausprobieren brauchst

Die Beispielbefehle gehen von vier GPUs aus (--tp 4) – für 27B-Parameter in voller Präzision plus langem Kontext ist das ein Serverszenario. Quantisierte INT4/INT8-Gewichte sind erst geplant. Ein 27B-Modell würde in 4-Bit grob 16–18 GB Speicher brauchen, aber lange Kontexte kosten zusätzlich viel Speicher; das ist nicht von der Quelle belegt. Rechne mit mehreren Dutzend GB Festplatte, installiertem ffmpeg, Node.js und Chromium. Für die gesamte Pipeline brauchst du zusätzlich Claude Code als Agentenumgebung und Geduld: Ein Produktionslauf dauert Stunden.

Einordnung

Der Ansatz ist interessant, weil Änderungen präzise und reproduzierbar werden und Texte sowie Zahlen exakt bleiben. Das passt zu Erklärvideos, Datenvisualisierungen und Motion Design. Fotorealistische Aufnahmen kann das Modell ausdrücklich nicht erzeugen. Kritisch: Die Autoren legen nur qualitative Beispiele vor, einen Benchmark gibt es nicht. Sie räumen ein, dass das Modell bei visueller Politur und Zuverlässigkeit über lange Läufe klar hinter den stärksten proprietären Modellen liegt, und dass ein Produktionslauf Stunden dauert. Offen bleibt, ob es gegenüber allgemeinen Coding-Modellen weniger Reparaturversuche, bessere Bewegung oder zuverlässigere Änderungen bringt – diese Frage stellt auch der Reddit-Beitrag. Die Veröffentlichung von Gewichten, Skill und Trajektorien ist dennoch eine brauchbare Grundlage für Forschung und eigene Experimente.

Quellen

#video#code-generierung#open-weights#qwen#agenten
Originalquelle lesen

Selbst ausprobieren: SenseNova 6.8 Code2Video

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

Was kann ich damit machen?

Das Modell schreibt Code, der kurze Videos erzeugt – etwa Motion Graphics, Erklärvideos, Simulationen oder stilisierte 2D/3D-Szenen – und überarbeitet sie nach Hinweisen im selben Projekt. Es arbeitet als Agent mit Claude Code, rendert selbst und prüft die Frames.

Für wen lohnt es sich?

Für Entwickler und Tüftler mit Serverhardware oder Mehr-GPU-Setup, die programmatische Videos bauen wollen. Wer fotorealistische Clips oder schnelle Ergebnisse sucht, ist hier falsch.

Größe27,4 Mrd. Parameter
Download55 GB (bei 100 MBit/s ca. 73 Min.)
Lizenzapache-2.0
ArtBild + Text (versteht Bilder)

Was dein Rechner braucht

Grafikkarte (NVIDIA) mind. 67 GB VRAMBerechnet, nicht gemessen: Die zwölf bf16-Gewichtsdateien sind zusammen 54,7 GB, mal 1,2 plus 1 GB ergibt rund 67 GB. Der Hersteller startet mit 4 Karten (tensor parallel 4); mehr Speicher bringt Luft für den sehr langen Kontext von 512K.
Mac (Apple Silicon M1–M5) nicht unterstütztDie Anleitung des Herstellers setzt Docker mit NVIDIA-Grafikkarten (--gpus all) und 4 Karten voraus. Das gibt es auf dem Mac nicht. Nutze stattdessen einen gemieteten Linux-Server mit 4 NVIDIA-Karten; dein Mac kann dann nur als Fernbedienung dienen.
Speicherplatz ca. 57 GB freiModell-Download plus Programme

Veröffentlicht ist eine 27B-Variante mit 512K Kontext; die Beispielbefehle nutzen 4 GPUs. INT4- und INT8-Gewichte sind laut Reddit-Beitrag für später geplant, bis dahin ist eine Community-Quantisierung denkbar, aber nicht bestätigt.

  • Die offiziellen Startbefehle nutzen --tp 4, also vier GPUs.
  • Für 512K Kontext (524288 Token) wird viel zusätzlicher Speicher für den KV-Cache gebraucht.
  • Zusätzlich nötig: Node.js 18+, Python 3, ffmpeg/ffprobe, Chromium über Playwright und Schriftarten für die Videosprache.
  • Ein Produktionslauf kann über 10 Stunden dauern.
  • Quantisierte INT4/INT8-Gewichte sind noch nicht veröffentlicht.
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 (OpenSenseNova/SenseNova-6.8-Code2Video auf GitHub). Die Befehle unten stammen aus der Model Card und der Anleitung der Entwickler.

Windows 10 / 11

Windows 10 / 11: nicht offiziell getestet. Die Quelle nennt nur Linux-Docker mit NVIDIA-Karten. Unter Windows geht es vermutlich nur über WSL2 (Linux im Windows) mit mehreren NVIDIA-Karten, getestet ist das nicht. Ohne passende Hardware bleibt nur ein gemieteter Linux-Server mit GPUs.

  1. Voraussetzungen prüfen. Du brauchst Windows mit WSL2 (Ubuntu), Docker Desktop mit WSL2-Anbindung, einen aktuellen NVIDIA-Treiber und 4 NVIDIA-Grafikkarten mit zusammen mindestens etwa 67 GB Grafikspeicher. Dazu rund 60 GB freien Platz, Git, Python 3, Node.js 18+, ffmpeg, Claude Code und Schriftarten für die Sprache des Videos. Alle folgenden Befehle gibst du im Ubuntu-Fenster (WSL2) ein.
  2. Modellgewichte herunterladen. Lege eine Python-Umgebung an und lade das Modell (ca. 55 GB). Das dauert je nach Leitung lange.
    python3 -m venv .venv
    source .venv/bin/activate
    pip install -U huggingface_hub
    hf download sensenova/SenseNova-6.8-Code2Video --local-dir ~/SenseNova-6.8-Code2Video
  3. Modell-Server starten. Der Server macht das Modell für Claude Code erreichbar. Ersetze den Pfad durch deinen Download-Ordner (in WSL2 ggf. den vollen Pfad wie /home/DEINNAME/SenseNova-6.8-Code2Video). Das Fenster bleibt offen.
    docker run --rm --gpus all --ipc=host -p 8000:8000 \
      -e VLLM_ALLOW_LONG_MAX_MODEL_LEN=1 \
      -v /path/to/SenseNova-6.8-Code2Video:/model \
      vllm/vllm-openai:latest \
        --model /model \
        --tensor-parallel-size 4 \
        --max-model-len 524288 \
        --reasoning-parser qwen3 \
        --enable-auto-tool-choice \
        --tool-call-parser qwen3_coder \
        --host 0.0.0.0 --port 8000
  4. Skill ins Aufgabenordner kopieren. Der „Skill“ ist das Arbeitsprogramm des Modells. Öffne ein neues Ubuntu-Fenster. Setze TASK auf den vollen Pfad eines neuen Ordners.
    TASK=/absolute/path/to/a-new-video-task
    git clone https://github.com/OpenSenseNova/SenseNova-6.8-Code2Video.git
    mkdir -p "$TASK/.claude/skills"
    cp -r SenseNova-6.8-Code2Video/skills/code-video "$TASK/.claude/skills/"
  5. Abhängigkeiten installieren. Das lädt die Python-Pakete und den Browser, mit dem Bilder gerendert werden.
    python3 -m pip install -r "$TASK/.claude/skills/code-video/requirements.txt"
    cd "$TASK" && npm install playwright && npx playwright install chromium
  6. Einstellungsdatei und Wunschtext anlegen. Speichere diese Datei als private-settings.json. Als Modellname trägst du den Namen ein, den dein Server führt (bei vLLM meist /model). Den Zugangsschlüssel setzt du mit ANTHROPIC_AUTH_TOKEN. Dann schreibst du deinen Videowunsch (z. B. „retro airport split-flap board“), lässt ihn mit der Vorlage prompts/enhance_prompt.md aus dem GitHub-Repo von einem starken Chat-Modell ausbauen und speicherst das Ergebnis als dense_prompt.md im Aufgabenordner.
    {
      "env": {
        "ANTHROPIC_BASE_URL": "http://localhost:8000",
        "ANTHROPIC_MODEL": "/model",
        "CLAUDE_CODE_MAX_CONTEXT_TOKENS": "524288",
        "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE": "80",
        "CLAUDE_CODE_MAX_OUTPUT_TOKENS": "64000"
      },
      "model": "/model"
    }
  7. Video erzeugen lassen. Starte die Produktion. Sie läuft oft viele Stunden und führt Befehle ohne Nachfrage aus, nutze also eine abgeschottete Umgebung.
    cd "$TASK"
    claude -p --settings /absolute/path/to/private-settings.json --model /model \
      --max-turns 2000 --permission-mode acceptEdits --allowedTools "Bash,Read,Write,Edit,Glob,Grep,Skill" \
      'Use the project code-video skill. Read .claude/skills/code-video/SKILL.md and dense_prompt.md, then the relevant craft guides. Produce the complete video and deliver out/final.mp4, SPEC.md and VERIFY.md.'
  8. Ergebnis. Im Aufgabenordner liegt nach der Produktion der Ordner out mit der fertigen Videodatei final.mp4, dazu SPEC.md und VERIFY.md.

macOS

macOS: nicht unterstützt. Die Anleitung des Herstellers setzt Docker mit NVIDIA-Grafikkarten (--gpus all) und 4 Karten voraus. Das gibt es auf dem Mac nicht. Nutze stattdessen einen gemieteten Linux-Server mit 4 NVIDIA-Karten; dein Mac kann dann nur als Fernbedienung dienen.

Linux

Linux: unterstützt. Offiziell vorgesehen sind Docker-Server (vLLM, SGLang oder LightLLM) mit 4 NVIDIA-Karten (tensor parallel 4). Welche Karten der Hersteller getestet hat, steht nicht in der Quelle.

  1. Voraussetzungen prüfen. Du brauchst 4 NVIDIA-Grafikkarten mit zusammen mindestens etwa 67 GB Grafikspeicher, den NVIDIA-Treiber und Docker mit NVIDIA Container Toolkit (damit Docker die Karten nutzen darf). Dazu rund 60 GB freien Platz, Git, Python 3, Node.js 18+, ffmpeg, Claude Code und Schriftarten für die Sprache des Videos.
  2. Modellgewichte herunterladen. Lege eine Python-Umgebung an und lade das Modell (ca. 55 GB). Das dauert je nach Leitung lange.
    python3 -m venv .venv
    source .venv/bin/activate
    pip install -U huggingface_hub
    hf download sensenova/SenseNova-6.8-Code2Video --local-dir ~/SenseNova-6.8-Code2Video
  3. Modell-Server starten. Der Server macht das Modell für Claude Code erreichbar. Ersetze /path/to/... durch den vollen Pfad deines Download-Ordners. Das Terminal bleibt offen.
    docker run --rm --gpus all --ipc=host -p 8000:8000 \
      -e VLLM_ALLOW_LONG_MAX_MODEL_LEN=1 \
      -v /path/to/SenseNova-6.8-Code2Video:/model \
      vllm/vllm-openai:latest \
        --model /model \
        --tensor-parallel-size 4 \
        --max-model-len 524288 \
        --reasoning-parser qwen3 \
        --enable-auto-tool-choice \
        --tool-call-parser qwen3_coder \
        --host 0.0.0.0 --port 8000
  4. Skill ins Aufgabenordner kopieren. Der „Skill“ ist das Arbeitsprogramm des Modells. Öffne ein neues Terminal. Setze TASK auf den vollen Pfad eines neuen Ordners.
    TASK=/absolute/path/to/a-new-video-task
    git clone https://github.com/OpenSenseNova/SenseNova-6.8-Code2Video.git
    mkdir -p "$TASK/.claude/skills"
    cp -r SenseNova-6.8-Code2Video/skills/code-video "$TASK/.claude/skills/"
  5. Abhängigkeiten installieren. Das lädt die Python-Pakete und den Browser, mit dem Bilder gerendert werden.
    python3 -m pip install -r "$TASK/.claude/skills/code-video/requirements.txt"
    cd "$TASK" && npm install playwright && npx playwright install chromium
  6. Einstellungsdatei und Wunschtext anlegen. Speichere diese Datei als private-settings.json. Als Modellname trägst du den Namen ein, den dein Server führt (bei vLLM meist /model). Den Zugangsschlüssel setzt du mit ANTHROPIC_AUTH_TOKEN. Dann schreibst du deinen Videowunsch (z. B. „retro airport split-flap board“), lässt ihn mit der Vorlage prompts/enhance_prompt.md aus dem GitHub-Repo von einem starken Chat-Modell ausbauen und speicherst das Ergebnis als dense_prompt.md im Aufgabenordner.
    {
      "env": {
        "ANTHROPIC_BASE_URL": "http://localhost:8000",
        "ANTHROPIC_MODEL": "/model",
        "CLAUDE_CODE_MAX_CONTEXT_TOKENS": "524288",
        "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE": "80",
        "CLAUDE_CODE_MAX_OUTPUT_TOKENS": "64000"
      },
      "model": "/model"
    }
  7. Video erzeugen lassen. Starte die Produktion. Sie läuft oft viele Stunden und führt Befehle ohne Nachfrage aus, nutze also eine abgeschottete Umgebung.
    cd "$TASK"
    claude -p --settings /absolute/path/to/private-settings.json --model /model \
      --max-turns 2000 --permission-mode acceptEdits --allowedTools "Bash,Read,Write,Edit,Glob,Grep,Skill" \
      'Use the project code-video skill. Read .claude/skills/code-video/SKILL.md and dense_prompt.md, then the relevant craft guides. Produce the complete video and deliver out/final.mp4, SPEC.md and VERIFY.md.'
  8. Ergebnis. Im Aufgabenordner liegt nach der Produktion der Ordner out mit der fertigen Videodatei final.mp4, dazu SPEC.md und VERIFY.md.

Das kannst du ausprobieren

Erstelle ein 30-Sekunden-Erklärvideo, das die Fourier-Transformation mit animierten Wellen anschaulich zeigt.
Baue eine Retro-Flughafen-Anzeigetafel mit Klappzahlen, die Abflüge nach Berlin, Wien und Zürich zeigt.
Mach das Video jetzt in hellen Pastellfarben und füge bei Sekunde 10 ein Flugzeug hinzu, ohne den Text zu ändern.

Wenn es hakt

Claude Code hält unbekannte Modelle für 200K-Modelle: Kontextfenster explizit mit CLAUDE_CODE_MAX_CONTEXT_TOKENS=524288 setzen.

Bei vLLM und SGLang sind die Umgebungsvariablen für lange Kontexte (VLLM_ALLOW_LONG_MAX_MODEL_LEN=1 bzw. SGLANG_ALLOW_OVERWRITE_LONGER_CONTEXT_LEN=1) nötig.

Skill nach der Installation in .claude/skills/code-video ablegen und den Agenten ggf. neu starten.

Abhängigkeiten (Playwright, Chromium, ffmpeg) vor dem ersten Lauf installieren, sonst dauert die Einrichtung mitten in der Produktion lange.

Langsame Shell-Initialisierung vermeiden, da jeder Bash-Aufruf eine neue Shell startet.

„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: apache-2.0.

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.

  1. 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.