Code2Video and Magnific Move render motion as editable code

Three tools that shipped in the last week of October all take the same bet: a motion graphic is design plus timing, and both can be written down as code instead of sampled out of a model. SenseTime's SenseNova 6.8 Code2Video writes the program. fal's Motion to Code turns a prompt, a still or a reference clip into one. Magnific Move puts an agent and a version history in front of the same idea.

For a creator, the three are not variations on one product. They sit at different points in the job, and the figure that separates them is not quality. It is how much control you keep over the individual frame.

What code-rendered motion is

A code render is a small program that draws a video. The program states where every element sits, how long each move takes and what color each shape is, then a renderer runs that program frame by frame and writes an MP4. Nothing is guessed.

SenseTime's project page makes the case in plain terms. Under a heading called "Why a code model", the GitHub README describes the weak spot of generative video models: their output is one black-box sampling pass, so a change to one detail forces the whole clip to be resampled, and on-screen text, formulas, charts and data values "must be exactly right, yet are easily garbled." The advantage it claims for code is blunt. Text is typeset verbatim, formulas and data come from the source, every coordinate and duration is an explicit number, and each frame is a pure function of time, so the same code always renders the same film.

Magnific's launch post for Move says the same thing from the other direction, in a claim about its own product: because a motion in Move is code and not pixels, "text stays sharp, colors stay exact, and your 20th version looks as clean as the first." When a chart, a price or a caption has to be legible, that difference is the whole argument.

Code2Video writes the film itself

SenseNova 6.8 Code2Video is a 27B model fine-tuned from Qwen3.8-27B, released on Hugging Face with weights, config and tokenizer under the Apache 2.0 license, and mirrored on GitHub. It builds and renders videos by generating executable code and it supports a 512K context.

The intended harness is Claude Code. SenseTime says the model sustains runs of more than 10 hours and more than 2,000 turns, and it publishes the settings for them. The workflow has three stages: a strong general model expands a short request into a production brief using a template the team ships; then Code2Video runs in Claude Code with a code-video skill that carries eight craft guides and the rendering tools, producing out/final.mp4, a SPEC.md and a VERIFY.md; then a creator writes notes and the model edits the same project for a new version. The repo also ships full generation logs as trajectories, including 357 figures.

What it will not do is read as a camera. The project states the scope plainly: motion graphics, explainers, stylized 2D and 3D scenes, procedural audio, and it "does not generate photorealistic footage." It also says it publishes qualitative examples only, and that the team has "not yet built a systematic benchmark for code-driven video."

fal rebuilds a clip as editable code

fal's Motion to Code is a hosted API with two endpoints, both carrying a commercial-use label. The GSAP endpoint writes a motion design animation as one self-contained HTML page, with inline SVG animated by a single GSAP 3 timeline, rendered in a headless browser and checked against a reference clip, with the timing of every move measured on both clips and matched. The GLSL endpoint writes one Shadertoy-style fragment shader in GLSL ES 3.00, single pass and no textures, that loops without a seam.

Both take a prompt of up to 4,000 characters, plus either an image or a reference video of 1 to 15 seconds, which sets the duration and the aspect ratio. A video and an image together are refused. The loop runs from 1 to 15 seconds, default 6, and a refine_rounds control lets the model compare its render with the reference once and fix the code. The output is the code, a playable HTML page, an MP4 preview and a contact sheet with the reference and the render side by side.

There are no weights to download. It is the platform's product, and you rent it by the second.

Magnific Move directs the code for you

Magnific Move, announced on October 28, 2026 in a post by Martin LeBlanc, is an agent-based motion graphics editor. You describe the piece, pick a format, a length and a Brand Kit, and an agent builds a first version with text, shapes, images, transitions, music and voiceover. Then you direct it in plain language, or pause the video, click the spot and leave a comment.

Every edit becomes a new version that you can branch or compare, and nothing is overwritten. Magnific says an edit takes a minute or two. When you need another shape, Move recomposes every shot for 9:16, 1:1 and 4:5 rather than cropping, and it exports MP4 at 1080p or 4K up to 180 seconds.

The post credits the machinery underneath: HyperFrames, "the open-source framework from HeyGen," which lets an agent write a motion graphic as plain HTML, preview it, check it frame by frame and render it to MP4. HeyGen's own page calls it "the video editor built for agents," installs with npx skills add heygen-com/hyperframes, and the repository describes it as a framework for turning HTML, CSS, media and seekable animations into deterministic MP4 videos, meaning the same input gives the same frames every time. It is Apache 2.0 and needs Node.js 22 or newer plus FFmpeg.

What each route costs

fal is the one with a number attached to a second of animation. On its model pages, the rate is $0.30 per second when MiniMax H3 Max animates your prompt or image into the reference clip first, or $0.20 per second from your own video, with a 5-second minimum and a 15-second maximum. The page works the math out: a 6-second loop from a prompt costs $1.80, and a 10-second clip rebuilt from your video costs $2.00.

Code2Video costs nothing for the weights. What it charges in is hardware and agent time. A production run, in SenseTime's words, "takes hours and a long context," and the results depend on how the harness is configured.

Magnific does not publish a per-second figure for Move on its launch post. The tool is live under Motion graphics on Magnific, which is sold as a subscription. Its cost is best read as an add-on to a plan you already pay for.

What each one is bad at

Code2Video cannot make footage that looks like a camera. That is the stated scope, not a quality judgment, and it also means you cannot ask it for a photorealistic crowd. It publishes no benchmark, so its polish is a claim you check yourself, and its long runs take hours.

fal gives you 15 seconds and stops. The loop is capped at 15 seconds, the reference clip is capped at the same, and both endpoints refuse a video and an image together. You get the code, but you are on fal's servers and you pay per second.

Magnific Move is hosted and opaque about the machine underneath. You do not get the HTML to edit by hand, and the post publishes no price per second and no cap on how many versions you can keep. Its own example, blocking out a 3D shot in Move and then finishing it in Seedance 2.5, suggests the code render is a blocking stage, not the finished look.

The shared limit is the same one the whole approach carries. A code render is only as good as the program, and a program is bad at the thing diffusion models are good at: texture, skin, foliage and the unpredictable.

How to choose

Pick by what has to be exact. If the job is a chart, a price, a product name, a lower third or a title that must be legible at every frame, reach for code, because that is the failure the makers themselves name. If you want to talk to the edit and keep every version, Move is the front end. If you want the code itself, in your own project, fal hands it over and charges by the second. If you want to run the model on your own hardware and keep the whole production local, Code2Video is the open weights.

If you want footage that looks real, none of the three is built for it. SenseTime says so outright, and Magnific's own example finishes its 3D shot in another model.

The open question is the benchmark SenseTime says does not exist yet. A separate leaderboard for code-driven video, reported second-hand as ranking model-written code against a human-made reference and hosted on Kaggle, could not be opened for this piece on October 30, 2026, so no figures from it appear here. Until a benchmark is publicly readable, a creator comparing these three is comparing documentation and demos, not measured output. That gap is where the next round of launches will land.

Move is live under Motion graphics inside a Magnific account, Code2Video's weights download free from Hugging Face and run behind Claude Code, and both fal endpoints are callable through fal's API from a prompt. All three are reachable in a browser today, and the one practical step none of them will pick for you is which of the two fal endpoints to call first.