Analysis August 29, 2026 tool 11 min read

SANA-Video 2.0's four-step preview is a real speed win under a genuinely permissive license, but that license covers only NVIDIA's transformer, and NVIDIA's own mirrors of the two files you need to run it strip away the terms those files normally arrive with.

SANA-Video 2.0 NVIDIA Efficient Large Model LTX-2.3 Gemma 2 NVlabs Sana video-gen open-weights licensing-provenance local-creative-ai creative-workflows

SANA-Video 2.0 Renders 720p in Four Steps. The Apache 2.0 Badge Covers Less Than It Looks Like.

NVIDIA's distilled video model publishes its sampling schedule to ten decimal places and ships an install command that clones a repository which does not exist. Both facts tell you something useful.

The model card for SANA-Video 2.0's four-step preview lists the exact noise levels it samples at: 0.9998332262, 0.9471688271, 0.8568977118, 0.6663702130. Ten decimal places, in a table, with the API timestep and the model embedding timestep beside each one. I have read a lot of video model cards this year and almost none of them tell you that.

Four paragraphs later, the same card tells you to run git clone https://github.com/Efficient-Large-Model/Sana.git. That organization has exactly one public repository on GitHub and it is not this one. The clone 404s. The branch you want, feat/sana-video2-4step-preview, lives on NVlabs/Sana instead, where the pull request to merge it has been open since August 27 with zero reviews and zero comments on it.

That combination is the honest summary of this release: unusually precise about the things that are hard to get right, careless about the things that are easy. It is worth your afternoon anyway, and the reason is not the speed.

Four steps instead of fifty, and what that actually buys

The release landed on Hugging Face at 08:11 UTC on August 27, 2026, from NVIDIA's Efficient-Large-Model group. It produces about five seconds of video: 736 by 1280, 81 frames at 16 frames per second, from a text prompt, in four passes through the network. The 50-step base model it was distilled from went up seven days earlier, on August 20.

Distillation is the trick, and the plain version is this. You have a teacher network that walks from noise to a finished frame in fifty careful steps. You train a student to land on the same place in four jumps. The student is not a smaller model. This one is 4,466,980,960 parameters of full transformer, 32 layers at hidden size 2,560, and the card is explicit that the checkpoint is a full model export and "not a LoRA adapter." Teacher and student checkpoints are the same size on disk to within 25 kilobytes. Same model, roughly a twelfth of the sampling work.

The architecture is worth a sentence because it explains the memory profile. The card puts three quarters of the attention at gated linear attention, which scales with sequence length instead of its square, and the remaining quarter at dense softmax anchors placed periodically through the stack to catch what linear attention loses. Attention residuals aggregate every eight layers, which the config confirms with softmax_ratio: 0.25 and attn_res_block_size: 8. That mix is why the transformer is 4.47B rather than something you need a rented card for.

Here is the part the launch coverage skipped. The four steps are not a setting. This is not a sampler where you type 4 and could have typed 20 for a better result. The model predicts a velocity at each of those four fixed noise levels, computes a clean estimate, then re-noises that estimate to the next level with a fresh draw from the same seeded generator. Those four numbers are the operating points. Ask it to sample at 0.75 and you are asking a question the card never claims it was taught to answer.

If that sounds abstract, the neighboring project makes it concrete. The FastH3 v0.2 card, released August 23, corrected its own earlier instructions on exactly this point: passing num_inference_steps=4 makes the scheduler build its own four-point grid rather than using the four trained jump points, and the same off-operating-point mismatch affected that run's in-training validation renders, so the team told readers to judge the model on fresh samples instead. Same failure mode, same family of models, one lab over. SANA-Video sidesteps it by hard-coding --sampling_algo=fastvideo_dmd_4step and publishing the ladder, which is exactly why those ten decimal places are on the card.

One more detail. The last stage sits at sigma 0.666, not at zero, so the finished frame is a clean-estimate prediction made from a latent that is still substantially noisy. That is normal for this family of distillation. The card lists fine motion and texture among the first things to degrade but never connects the two, so read the link as my reading rather than theirs.

The license question, which is the actual story

The model is Apache 2.0. The base model is Apache 2.0. Both carry a LICENSE file. If you stop reading the metadata there, you conclude that you can render client work with this tonight and owe nobody anything, which is what I assumed on the first pass.

Then you read the config. Running this model requires two components that NVIDIA did not train and does not license to you: google/gemma-2-2b-it as the text encoder, and the LTX 2.3 VAE from Lightricks.

The Lightricks terms are the wall. The LTX-2 Community License Agreement grants a royalty-free license for any purpose, subject to a twenty-item restricted-use attachment, and then carves out this:

"Entities with annual revenues of at least $10,000,000 (the 'Commercial Entities') are required to obtain a paid commercial use license"

That threshold aggregates. The license defines an entity to include "all subsidiaries, affiliates, and companies under common Control." Breach is priced in advance: back fees plus liquidated damages "equal to double the amount that would otherwise have been paid." There is no component-level carve-out anywhere in the file, so the VAE inherits the threshold along with the twenty restrictions. If you are a freelancer or a small studio, none of this touches you. If you sit inside an agency clearing eight figures, an Apache 2.0 badge on the transformer does not get your delivery cleared.

Google's terms are friction rather than a wall. google/gemma-2-2b-it is gated on Hugging Face, though Google's own gate text says requests are processed immediately, so this is a click and not a queue. The Gemma Terms of Use permit commercial use with no revenue threshold, and Section 3.3 states that "Google claims no rights in Outputs you generate using Gemma." Section 3.2 incorporates a Prohibited Use Policy by reference and restricts how you may use the model, though Section 1.1(e) is careful to say that outputs are not deemed model derivatives.

Now the part I did not expect. NVIDIA hosts its own copies of both dependencies, and neither copy carries the terms.

Efficient-Large-Model/gemma-2-2b-it is not gated. Efficient-Large-Model/LTX-2.3-Diffusers, created May 1, 2026, has no LICENSE file and no license tag at all: its entire tag list is diffusers, safetensors, diffusers:LTX2Pipeline, region:us. It is not a VAE mirror either. It is a full LTX-2 pipeline of nearly 19 billion parameters, transformer shards and text encoder and vocoder included, of which SANA loads only the vae/ folder. NVIDIA's own demo Space loads all three models, the SANA checkpoint and both dependencies, from the Efficient-Large-Model organization.

So if you follow NVIDIA's path rather than the upstream one, you never see Google's gate and you never see Lightricks' license text. The $10M ceiling still applies to you, because a redistributed copy does not rewrite the terms of the thing it copied. You just have no way of finding out from the page you downloaded it from.

I am not accusing anyone of anything. NVIDIA built the piece it owns and released it about as permissively as anyone could ask, and whether it has a separate arrangement with Lightricks is not visible from outside. What I am saying is that the badge on a model page has stopped describing the thing you actually execute, and following the vendor's own quickstart is now the least likely way to find that out.

Put this into practice

Start in the browser. It costs nothing and takes two minutes. NVIDIA runs a free Space at huggingface.co/spaces/Efficient-Large-Model/sana-video2-5b-720p-demo. Write a prompt with one subject, one clear action, and a stated camera position. Generate. You will know inside five seconds of playback whether this model's failure modes collide with your work.

Prompt in the shape the card's own verified example uses. Their published sample names the setting, the subject, the specific actions, the surrounding objects, and then the shot: "The camera captures the rooster from a close-up angle." Models distilled this hard reward prompts that pin down one thing happening rather than prompts that describe a mood.

If the browser test lands, install locally. Use the corrected clone, not the one on the card:

git clone https://github.com/NVlabs/Sana.git
cd Sana
git checkout feat/sana-video2-4step-preview
bash environment_setup.sh sana
conda activate sana

Then place the Diffusers-format LTX 2.3 VAE at output/pretrained_models/LTX-2.3-Diffusers/, or point vae.vae_pretrained in the config somewhere else. Budget for the size: the transformer checkpoint is 17.9GB on its own, the Gemma encoder is another 5GB, and the LTX pipeline folder is large enough that you want to pull only the vae/ subfolder rather than cloning the repository. If you later want first-frame conditioning, the 50-step base model is a separate 17.9GB checkpoint.

Reproduce their published sample before you change anything. The card gives the exact command with --seed=4, and it ships the resulting MP4 in the repo. Run it, then compare your output against theirs. If they match you have a known-good baseline, and every later problem is yours rather than the install's. This is the step people skip and then spend an evening debugging a working system.

Keep the pinned flags where they are: --cfg_scale=1.0, --step=4, --sampling_algo=fastvideo_dmd_4step, --generator_sigma_profile=sana_shift6_dpm, along with --num_frames=81, --fps=16, and --custom_height_width='[736,1280]'. The card pins CFG to 1 without saying why. In this family of distillations that normally means guidance is folded into the student during training, which would make turning it up counterproductive rather than sharpening. Change the prompt, the seed, and the output path. Leave the sampler alone. One curiosity if you like reading configs: the card also pins --flow_shift=1.0 and then states that flow shift is not applied by this sampler, so that flag does nothing at all.

One thing it will not do: feed it a starting image. This preview is text-to-video only. Image-to-video needs the 50-step base release, which puts both the download and the render time back up.

Where it breaks

The card is candid, which I want to credit before piling on. It lists motion, anatomy, text rendering, object permanence, and physical interactions as inconsistent, and it names crowded or fast-moving scenes as the trigger. It says prompt following degrades on long or compositionally complex instructions. It labels itself a research preview with less release validation than the 50-step model. Believe all of that. Two people in a fight is a bad prompt. One person walking is a good one.

The gap I keep coming back to is the evaluation. The card states that the checkpoint was evaluated on the full VBench text-to-video suite, 4,730 prompts across all sixteen dimensions, using the exact sampling contract described above. It then publishes not a single score, and the API returns a null model index. Running the benchmark and withholding the numbers is a strange choice, and I read a missing number the way I read any missing number: as the result of a comparison somebody chose not to lead with. Maybe the four-step scores sit close to the teacher's and a paper is pending. Maybe they do not. Either way you are being asked to judge this on your own footage, which is the right thing to do regardless, but the card gestures at rigor it does not show you.

The maturity signals are early. The enabling pull request is open, unreviewed, and eleven files wide. The checkpoint is global step 1,000 of a DMD run. Downloads sat at 2,129 against 377 for the base model when I checked, and those are rolling thirty-day figures rather than lifetime totals, so read them as current interest rather than installed base. The parent repository has 8,883 stars, so the project is not obscure. This particular artifact is two days old.

And there is no ComfyUI node pack for SANA-Video 2.0. SANA's image models have had community nodes for a long time, so support for the family exists; support for this video release does not. Everything here is command line, conda, and a config file. If your practice lives in a node graph, this one does not reach you yet.

What I would actually watch

The interesting question is not whether four-step video is good enough. It will be, on some axis, within a couple of months, and the honest cards coming out of this group and the FastVideo lab are going to make that transition much less painful than it could have been.

The question is what "open weights" means when the runnable unit is three licenses in a trench coat, and when the vendor's own mirrors file two of them off without saying so. SANA-Video 2.0 is Apache 2.0 and cannot be run without a Google model and a Lightricks VAE that stops being free at $10M in aggregated revenue. Nothing about that is hidden, exactly. It is just distributed across four repositories, two of which do not mention it.

So before your next commercial render off any open video model, open the config, list every checkpoint it loads, and look each one up at its original home rather than the mirror you pulled it from. It takes ten minutes. I did it here expecting to confirm a clean Apache pipeline and found a revenue ceiling, an ungated mirror, and a redistribution with no license file on it.

If you run the seed-4 reproduction and your output diverges from the shipped MP4, I want to hear about it. That would be a more interesting bug than anything in the limitations list.

Medium metadata

Primary sources

Model card: https://huggingface.co/Efficient-Large-Model/SANA-Video_2.0_5B_720p_4step
Free demo Space: https://huggingface.co/spaces/Efficient-Large-Model/sana-video2-5b-720p-demo
Base 50-step model: https://huggingface.co/Efficient-Large-Model/SANA-Video_2.0_5B_720p
Enabling pull request: https://github.com/NVlabs/Sana/pull/471
LTX-2 Community License Agreement: https://huggingface.co/Lightricks/LTX-2.3/raw/main/LICENSE
NVIDIA's LTX mirror: https://huggingface.co/Efficient-Large-Model/LTX-2.3-Diffusers
Gemma Terms of Use: https://ai.google.dev/gemma/terms
FastH3 v0.2 card: https://huggingface.co/FastVideo/FastVideo-Minimax-FastH3-Preview-v0.2

Model specifications, dates, licenses, and file sizes verified against cache-busted Hugging Face API and raw model card responses on August 29, 2026. GitHub figures (star count, pull request state, changed file count) were confirmed against live GitHub data on the same date at a moment when the unauthenticated REST API was rate limited, and the pull request state in particular can change after publication.