SenseNova 6.8 Code2Video: Open 27B model writes code that renders video
SenseNova has released an open 27-billion-parameter model that doesn't generate video directly. Instead, it writes executable code, renders it and revises it based on your feedback. It suits motion design and explainer videos best. It can't do photorealistic footage.
What this is about
The OpenSenseNova project has released SenseNova 6.8 Code2Video, an open language model with 27 billion parameters (parameters are, roughly speaking, the dials the model adjusted during training). It is built on Qwen3.8-27B and fine-tuned from it. Unlike classic video models, it doesn't generate video pixel by pixel. It writes executable code that computes the frames. Weights, an accompanying skill (a bundle of instructions and tools for an AI agent), prompt templates and complete production trajectories are available on GitHub and Hugging Face. The approach resembles the animation workflows users build with large proprietary models: the model writes code, tools render it into video, and follow-up instructions revise the result.
Why code instead of a video model
The developers point to three weaknesses of generative video models that create the whole clip in a single sampling pass:
- No grounding: The model learns what the world looks like, not how it works. Motion looks plausible but can be physically wrong.
- Hard to edit: Size, timing and trajectory stay implicit. A change means re-prompting and re-sampling, and the rest of the clip changes with it.
- Inaccurate content: Text, formulas, diagrams and numbers have to be exact, but they are easily garbled.
Code is meant to fix this. Every element is a named object, text is set verbatim, and coordinates, durations and camera paths are explicit numbers. Every frame is a pure function of time t, so the same code always renders the same film. Motion, collisions and lighting are computed rather than guessed. The authors also say rendering on ordinary hardware is far cheaper than sampling from a video model. The code can also call image, video, 3D and editing models. Looking ahead, the authors suggest code renderings as quick previews for video models, and precisely labeled data (depth, camera poses, multi-view) for world models.
Revise instead of rolling the dice again
The developers stress iterative work in particular. After the first cut, the model takes notes (a new look, extra elements, a different pace), changes the code in the same project and re-renders. As an example, the repo shows a retro airport departure board. The first version is a dark board under a spotlight. Round 2 restyles it as a bright pastel hotel lobby. Round 3 adds an airplane and travelers with luggage. According to the developers, the text, timing and flip mechanics that weren't meant to change stay identical. According to the Reddit post, the model can also rebuild the visual style of a reference video as editable code.
Model, skill and setup
The model supports a 512K context window (roughly half a million tokens). The developers say it handles context compaction well and holds up through sessions of more than a thousand turns. You download it with huggingface-cli. The deployment examples use LightLLM, vLLM or SGLang, each with --tp 4, meaning tensor parallelism across four GPUs, and a maximum length of 524288 tokens.
The recommended environment (the "harness") is Claude Code. A complete film is a long-horizon task: write, render, check frames, revise. The model is meant to sustain runs of more than 10 hours and more than 2,000 turns. Recommended settings:
| Setting | Value |
|---|---|
| Context window | 512K (CLAUDE_CODE_MAX_CONTEXT_TOKENS=524288) |
| Auto-compaction | at 80% |
| Max output | 64K |
| Turns per run | 2,000+ |
| Time per run | 10 h+ |
The code-video skill turns production into a verifiable workflow: write a spec, render every frame as a function of time, check contact sheets as images, and verify the delivered file. It includes eight craft guides (explainer videos, stylized looks, simulations, characters, 3D scenes, motion graphics, audio and narration, music sync). You need Claude Code, Node.js 18+, Python 3, ffmpeg and suitable fonts. Playwright with Chromium is installed for rendering. Optionally, a template expands a short request into a detailed production brief, ideally with a strong model such as Claude.
What you need to try it
The example commands assume four GPUs (--tp 4). For 27B parameters at full precision plus a long context, that is a server scenario. Quantized INT4/INT8 weights are only planned. A 27B model in 4-bit would need roughly 16–18 GB of memory, but long contexts add a lot on top. The source doesn't confirm this figure. Expect several dozen GB of disk space, plus ffmpeg, Node.js and Chromium. For the full pipeline you also need Claude Code as the agent environment, and patience: a production run takes hours.
Our take
The approach is interesting because edits become precise and reproducible, and text and numbers stay exact. That fits explainer videos, data visualizations and motion design. The model explicitly can't produce photorealistic footage. On the critical side, the authors only offer qualitative examples, and there is no benchmark. They admit the model clearly trails the strongest proprietary models in visual polish and reliability over long runs, and that a production run takes hours. It also remains open whether it needs fewer repair attempts, produces better motion or makes edits more reliably than general-purpose coding models. The Reddit post raises the same question. Still, releasing the weights, skill and trajectories gives researchers and tinkerers a solid base for their own experiments.
Sources
- r/LocalLLaMA github.com
Try it yourself: SenseNova 6.8 Code2Video
Explained step by step, no prior knowledge needed – on your own computer or free in your browser.
What can I do with it?
SenseNova 6.8 Code2Video isn't a classic video model. It doesn't paint pixels. It writes program code, and tools then turn that code into a film. Every frame is a function of time `t`, so the same code always produces the same film. That suits explainer videos, data visualizations, motion design, simulations and stylized 2D or 3D scenes. Text and numbers are set verbatim and stay exact. That's an advantage over video models, which tend to garble lettering. It is especially strong at revising: you give notes, the model changes the code in the same project and re-renders. According to the developers, text, timing and mechanics are preserved. Limits: it explicitly can't produce photorealistic footage. A run takes hours. According to the authors, it clearly trails the strongest proprietary models in visual polish and reliability over long runs. There is no benchmark, only qualitative examples.
Who is it worth it for?
It's worth a look for tinkerers, developers and researchers with a multi-GPU server or access to a hosted endpoint. It's also fun if you want to build explainer videos, data graphics or motion design as reproducible code. It's not for you if you want photorealistic clips, need quick results or only have a regular PC. Setup is involved and runs through an agent environment.
Ideas: What you can do with it
You describe a topic, such as the Fourier transform or the Pythagorean theorem. The model builds an animated explanation with exact formulas and labels. Then you adjust pacing or colors with a note.
You supply numbers and a key message. The model produces animated charts for a presentation. Because numbers are set verbatim, they stay correct.
You describe the style and title, such as kinetic typography. The model builds a short motion design intro. With the skill's guides for audio and music sync, it can even match the beat.
You give a product name, tagline and colors. The model turns them into a stylized promo clip. In further rounds you change the look or elements without losing the text.
You describe an experiment such as collisions or pendulums. Motion and lighting are computed rather than guessed. This yields clear animations for teaching or as a hobby.
According to the Reddit post, the model can rebuild the look of a reference video as editable code. That gives you a template you can adjust step by step.
What your computer needs
Only one variant is released: 27B parameters at full precision with a 512K context. The official examples use four GPUs (`--tp 4`). According to the Reddit post, quantized INT4/INT8 weights are only planned. A community quantization is conceivable but not confirmed. As a rough rule of thumb (not backed by the source), a 27B model in 4-bit would need about 16–18 GB of memory, plus a lot more for long context. If you don't have four GPUs, you're better off waiting for quantized weights or renting a server. LightLLM, vLLM and SGLang are available as serving software.
- The official launch commands for LightLLM, vLLM and SGLang use four GPUs (tensor parallelism, meaning the model is split across several graphics cards).
- The maximum length of 524288 tokens costs a lot of extra memory for the context cache (KV cache). The source gives no figures.
- Besides the GPU hardware, you need Node.js 18+, Python 3, ffmpeg, suitable fonts, and Playwright with Chromium for rendering.
- Plan for several dozen GB of disk space.
- A production run can take over 10 hours and over 2,000 turns. Your machine has to keep running that long.
- Quantized INT4/INT8 weights don't exist yet. The source doesn't cover Apple Silicon or CPU-only operation.
How do I find out what my computer has?
- Windows: Press Ctrl + Shift + Esc → Task Manager → Performance tab → click GPU on the left. At the bottom you'll see Dedicated GPU memory (that's your VRAM). You'll find system memory under Memory.
- Mac: Apple menu at the top left → About This Mac. You'll see your chip (e.g. M2) and memory (e.g. 16 GB). On Apple chips, graphics and processor share this memory.
- Linux: Type
nvidia-smiin the terminal (shows your graphics card and its memory) andfree -hfor system memory.
Guide
This model runs with its developers' own program (OpenSenseNova/SenseNova-6.8-Code2Video on GitHub). The commands below come from the Model Card and the developers' instructions.
Windows 10 / 11
Windows 10 / 11: not officially tested. The source only covers Linux Docker with NVIDIA cards. On Windows it presumably only works through WSL2 (Linux inside Windows) with several NVIDIA cards, but this is untested. Without suitable hardware, your only option is a rented Linux server with GPUs.
- Check the prerequisites. You need Windows with WSL2 (Ubuntu), Docker Desktop with WSL2 integration, a current NVIDIA driver and 4 NVIDIA graphics cards with at least about 67 GB of VRAM (video memory) combined. You also need roughly 60 GB of free space, Git, Python 3, Node.js 18+, ffmpeg, Claude Code and fonts for the language of your video. Enter all the following commands in the Ubuntu window (WSL2).
- Download the model weights. Create a Python environment and download the model (about 55 GB). Depending on your connection, this takes a long time.
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 - Start the model server. The server makes the model available to Claude Code. Replace the path with your download folder (in WSL2, use the full path if needed, such as /home/YOURNAME/SenseNova-6.8-Code2Video). Keep this window open.
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 - Copy the skill into the task folder. The "skill" is the model's working playbook. Open a new Ubuntu window. Set TASK to the full path of a new folder.
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/" - Install dependencies. This downloads the Python packages and the browser used to render frames.
python3 -m pip install -r "$TASK/.claude/skills/code-video/requirements.txt" cd "$TASK" && npm install playwright && npx playwright install chromium - Create the settings file and the brief. Save this file as private-settings.json. For the model name, enter the name your server uses (with vLLM, usually /model). Set the access key with ANTHROPIC_AUTH_TOKEN. Then write your video request (e.g. "retro airport split-flap board"), have a strong chat model expand it using the template prompts/enhance_prompt.md from the GitHub repo, and save the result as dense_prompt.md in the task folder.
{ "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" } - Generate the video. Start production. It often runs for many hours and executes commands without asking, so use an isolated environment.
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.' - Result. After production, the task folder contains the folder out with the finished video file final.mp4, plus SPEC.md and VERIFY.md.
macOS
macOS: not supported. The developers' guide requires Docker with NVIDIA graphics cards (--gpus all) and 4 cards. That isn't available on a Mac. Use a rented Linux server with 4 NVIDIA cards instead. Your Mac can then serve only as a remote control.
Linux
Linux: supported. Officially supported is a Docker server (vLLM, SGLang or LightLLM) with 4 NVIDIA cards (tensor parallel 4). The source doesn't say which cards the developers tested.
- Check the prerequisites. You need 4 NVIDIA graphics cards with at least about 67 GB of VRAM (video memory) combined, the NVIDIA driver and Docker with the NVIDIA Container Toolkit (so Docker is allowed to use the cards). You also need roughly 60 GB of free space, Git, Python 3, Node.js 18+, ffmpeg, Claude Code and fonts for the language of your video.
- Download the model weights. Create a Python environment and download the model (about 55 GB). Depending on your connection, this takes a long time.
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 - Start the model server. The server makes the model available to Claude Code. Replace /path/to/... with the full path to your download folder. Keep this terminal open.
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 - Copy the skill into the task folder. The "skill" is the model's working playbook. Open a new terminal. Set TASK to the full path of a new folder.
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/" - Install dependencies. This downloads the Python packages and the browser used to render frames.
python3 -m pip install -r "$TASK/.claude/skills/code-video/requirements.txt" cd "$TASK" && npm install playwright && npx playwright install chromium - Create the settings file and the brief. Save this file as private-settings.json. For the model name, enter the name your server uses (with vLLM, usually /model). Set the access key with ANTHROPIC_AUTH_TOKEN. Then write your video request (e.g. "retro airport split-flap board"), have a strong chat model expand it using the template prompts/enhance_prompt.md from the GitHub repo, and save the result as dense_prompt.md in the task folder.
{ "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" } - Generate the video. Start production. It often runs for many hours and executes commands without asking, so use an isolated environment.
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.' - Result. After production, the task folder contains the folder out with the finished video file final.mp4, plus SPEC.md and VERIFY.md.
Try it
Create a 30-second explainer video that shows the Fourier transform with animated waves.Build a retro airport departure board with flip digits showing departures to Berlin, Vienna and Zurich.Visualize as an animated bar chart how the numbers from my table develop over ten years. Label every axis and every value exactly.Simulate a ball rolling down a ramp and hitting dominoes. Show the formula for its velocity as on-screen text.Now make the video in bright pastel colors and add an airplane with travelers at second 10, without changing the text or timing.Tips for better results
- Don't write just one sentence. The "Enhance prompt" template turns a short request into a detailed brief (`dense_prompt.md`). The authors use a strong model such as Claude for this.
- Use the recommended settings: auto-compaction at 80% (`CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=80`), max output 64K, at least 2,000 turns and a 10-hour time limit.
- Revise in rounds. Start `claude -p --continue` in the same folder and give clear notes. Say explicitly what should stay the same, such as text and timing.
- Look at the files `SPEC.md` and `VERIFY.md`. They show what the model planned and checked.
- Browse the example trajectories (`trajectories/all.openai.jsonl`). They show how the model works and repairs errors.
If something goes wrong
Claude Code assumes unknown models have a 200K context. Set the context window explicitly with `CLAUDE_CODE_MAX_CONTEXT_TOKENS=524288`.
For long contexts with vLLM and SGLang, you need the environment variables `VLLM_ALLOW_LONG_MAX_MODEL_LEN=1` and `SGLANG_ALLOW_OVERWRITE_LONGER_CONTEXT_LEN=1`, respectively.
Copy the skill unchanged to `.claude/skills/code-video`. Your own requests belong in the prompt, not in the skill.
Install Playwright, Chromium and ffmpeg before the first run. Otherwise setup slows you down in the middle of production.
The run executes shell commands without asking. Start it in an isolated environment, such as a container.
Avoid slow shell initialization, because every Bash call starts a new shell.
The trajectories in the example data are anonymized and can't be replayed directly.
“out of memory,” a crash, or your computer freezes
The model is too big for your VRAM (video memory). Pick a smaller variant from the table above and close other programs, especially games and browsers with lots of tabs.
It runs, but extremely slowly
Your CPU is probably doing the work instead of your graphics card. In Ollama, the PROCESSOR column of ollama ps shows how much runs on the GPU. If it says "100% CPU", update your graphics driver or pick a smaller variant that fits entirely into VRAM (video memory).
“ollama” or “python” is not found
Close the terminal window and open it again so it recognizes the newly installed program. For Python on Windows: reinstall it and check Add python.exe to PATH.
Windows: "Running scripts is disabled on this system"
Run the script with exactly the command above: powershell -ExecutionPolicy Bypass -File try_windows.ps1. This allows execution for this one time only.
Error message when loading the model (version, "trust_remote_code", unknown architecture)
Brand-new models often need the latest software version. With Ollama: update Ollama. With Python: pip install -U transformers in the activated environment. The Model Card usually lists the exact version.
Tokenstrom generates the scripts and notebook automatically. Please take a quick look before running them – they're plain, readable text. Mind the model's license: apache-2.0.
Ask the AI assistant
Questions about this article, installation or background? Our assistant knows this page and runs on our own machine, not in someone else's cloud.
The Assistant is an AI (Gemma 4) and can make mistakes – please check important details against the source. Questions are used only to generate an answer and are deleted after one hour. Please don't enter any personal data.
Comments
What do you think? Already tried it? Write it here, no sign-up needed.
Comments are public. Links aren't allowed, and we delete abusive posts. You can delete your own comment at any time in this browser. Learn more in the Privacy Policy.