Slop TVNewsLatest
Explainers

Apple's FastFrames runs 480p video at 36 ms a frame

The two open models distill Alibaba's Wan2.1 down to two diffusion steps, but Apple's speed needs a B200-class GPU and the video comes out silent.

Illustration: Apple's FastFrames runs 480p video at 36 ms a frame
Illustration: SLOP TV News. Logos are trademarks of their owners.

Key takeaways

  • Apple released FastFrames-S (1.3B) and FastFrames-L (14B) on November 17, 2026, as autoregressive two-step video diffusion models that output 832x480 video.
  • Apple's paper reports FastFrames-S at 36 milliseconds per frame, or 28 responses per second, on one B200 GPU, and FastFrames-L at 45 milliseconds per frame on an eight-GPU node.
  • FastFrames generates no audio and caps output at 480p, and Apple names higher resolution, action conditioning and lighter hardware as future work.
  • The weights carry Apple's apple-amlr license, the code carries the Apple Sample Code License, and the LingBot-World v2 parts follow the non-commercial CC BY-NC-SA 4.0.

Apple's FastFrames is a family of video models built for response time rather than resolution. Its target is a new steering input answered in under 50 milliseconds, the point where interaction research says a person stops noticing the lag. Apple ML Research released FastFrames on November 17, 2026, with weights on Hugging Face and code on GitHub, plus a paper written with Cornell University. Two independent write-ups, CPU3D and OrcaRouter, date the Hugging Face upload to November 16; Apple's own repository and the arXiv listing both carry November 17.

Every AI video tool creators reach for today answers in seconds. FastFrames answers in milliseconds, and that changes what the tool is for.

What Apple's FastFrames actually is

FastFrames is two open models: FastFrames-S at 1.3 billion parameters and FastFrames-L at 14 billion. Both are autoregressive video diffusion models that generate one frame at a time and feed the frame they just made back in as the input for the next one. That loop is what makes them steerable. A new instruction can arrive between frames instead of waiting for a whole clip to finish.

Neither model is trained from scratch. FastFrames-S starts from a two-step Causal Forcing++ checkpoint built on Alibaba's Wan 2.1 1.3B backbone. FastFrames-L is distilled from Wan-AI's Wan2.1-T2V-14B. The paper, FastFrames: Video Generation at Interactive Latency, is by Gene Chou, Guandao Yang, Fujun Luan, Lars Mescheder, Wei Dong, Stephan R. Richter and Vladlen Koltun. Chou completed the work during an internship at Apple, and the affiliations are Apple and Cornell University.

Output is 832x480 video, 81 frames at 16 fps, which is about five seconds. The task is text to video.

Why two steps, and why the denoiser is not the bottleneck

A diffusion model normally builds a frame by denoising it over many passes. Two-step means two denoiser passes per frame, which is already a distilled, fast setup. Apple's finding is that once you are down to two steps, the denoiser is no longer where the time goes.

The paper profiles Causal Forcing++, the fastest few-step autoregressive model at the time of writing, on a single B200. One frame at 480p costs 271.8 milliseconds, and only 30% of that wall time is diffusion sampling. The rest sits in the parts treated as plumbing: the VAE decoder, which turns the model's latents into pixels, takes 147 milliseconds per generated latent, and the KV cache refresh runs a whole extra transformer pass just to rewrite memory. Apple's phrase for the VAE cost is blunt: a single decoding step takes as long as 3.5 denoiser passes.

The paper also argues that frames per second has been the wrong yardstick. A model that generates 30 frames in one batch over one second scores 30 fps, but the user still waited a full second to see anything. Apple measures end-to-end per-frame latency and its reciprocal, responses per second, counting one autoregressive generation unit as one response no matter how many frames it holds. The 50 ms interactive target equals 20 responses per second.

How Apple got a frame down to 36 ms

Apple removed the two expensive accessories instead of shrinking the denoiser further.

The VAE decoder is replaced by a ConvNeXt-based pixel head that works only at the transformer's low token resolution, followed by one linear layer that unpatchifies the tokens into RGB. It has 63.87 million parameters against the Wan VAE's 73.3 million, yet it renders a frame in about 1 millisecond against 147, a 147x cut at matching quality. The KV cache refresh is replaced by a small repair network that takes the noisy keys and values from the last denoising pass and predicts corrections, in roughly 2 milliseconds for the 1.3B model and 6 for the 14B, which the paper puts at about 20x and 12x faster than the baseline pass. Systems work on top of that, including cached RoPE tables, fused projections and a segmented attention scheme, brought the transformer evaluation itself from 41.6 milliseconds to 16.4 on one B200.

The result: FastFrames-S at 36 milliseconds per frame, or 28 responses per second, on a single B200, matching Causal Forcing++'s VBench quality at 7.6 times the speed. The model card's own component table for FastFrames-S, at 480p with a full KV cache, reads 16.1 ms for the first denoiser pass, 16.2 for the second, 2.2 for KV refinement and 0.9 for the pixel decoder, for a 35.4 ms total that Apple rounds to 36 in the paper.

The 36 ms number comes with an asterisk

The figure is real, and it is narrow. It is one B200 GPU (NVIDIA's data-center part, not a card most creators own), measured at steady state with a full KV cache rather than on a cold first frame, and it is the small model.

FastFrames-L's headline 45 milliseconds needs eight B200s. The paper's own VBench table lists FastFrames-L at 158 milliseconds on a single B200 and FastFrames-S at 14 milliseconds across eight, so eight GPUs buy roughly 3.5x for the large model and about 2.6x for the small one. No consumer-GPU figure appears anywhere in the release. Local Model Watch flagged that the model card's latency table never says what one row measures; the paper defines it, as one autoregressive generation unit at steady state, which the card leaves implicit.

What 480p and no sound mean in practice

FastFrames caps out at 832x480, which is 480p. The paper names scaling to higher resolutions as future work, so the ceiling is the price of the speed rather than a design preference, and Apple does not publish a higher-resolution variant.

The output is silent. The model card lists the task as text to video and describes no audio path, and the paper does not mention sound. The searchable contrast is on Krea's own documentation, which lists Lightricks' LTX-2 as an "audio-video model from Lightricks with native sound generation." A creator who needs dialogue, ambience or sound design gets none of it from FastFrames; the video arrives mute at about five seconds a clip.

What it costs and what you need to run it

Apple publishes no price, because there is nothing to buy. FastFrames is a self-hosted research release: you supply the GPU and the engineer hours. The install wants Linux x86-64, an NVIDIA GPU with a CUDA 12.8 driver, and the uv package manager. CPU3D reports that FastFrames-L's largest weights file is 26.6 GB and the full repository is 161.6 GB, so the download alone is a commitment.

The license field on both model cards is apple-amlr, and the repository puts the code under the Apple Sample Code License while the bundled LingBot-World v2 parts follow CC BY-NC-SA 4.0, a non-commercial license. Commercial work needs a read of both.

How it compares with Krea Realtime

The nearest thing a creator can use today on the same axis is Krea Realtime 14B, which Krea shipped on October 20, 2025. It is also a 14B model distilled from Wan 2.1 14B, though by a different method, Self-Forcing. Krea reports 11 fps text-to-video on a single B200 at four inference steps, with about one second to the first frame, and its weights are Apache 2.0. It is the model Apple measures against.

The two sets of numbers do not line up one to one, and the difference matters. Krea reports frames per second of generated output. FastFrames reports end-to-end latency per generation unit. On Apple's VBench table, run on the same prompts and seeds, Krea Realtime scores 84.42 total at 1,675 milliseconds, while FastFrames-L scores 84.44 at 45 milliseconds across eight B200s and 158 milliseconds on one. Apple's project page states FastFrames-L is over 10x faster than Krea Realtime; the paper's single-GPU comparison of 158 against 1,675 milliseconds is where that multiple comes from. A creator weighing the two should note the license gap as much as the speed gap: Apache 2.0 against apple-amlr plus a non-commercial clause.

Krea's own blog also names the weakness FastFrames is fighting. It says existing open-source realtime models built on "smaller models like Wan 2.1 1.3B" struggle with complex movement and high-frequency detail. FastFrames-S is exactly such a 1.3B model, which is why Apple leans on the 14B results whenever the conversation turns to quality.

What interactive latency could unlock

Apple demonstrates two downstream uses that turn the latency number into something a creator can picture.

LingBot is a camera-conditioned model. Apple's optimizations take LingBot's 1.3B version from 842 milliseconds in its fastest official configuration, which needs two GPUs, to 52 milliseconds across eight, a 16x speedup. RealWonder is a physics-conditioned model, and its 1.3B version drops from 1,141 milliseconds on one GPU to 51 milliseconds on eight, a 22x speedup. On the project page, the original versions visibly lag behind the operator's input while the optimized builds keep pace.

For a creator, that is camera moves that respond as you drag them and physics you can poke, with iteration that feels like a drawing tool rather than a render queue. The paper points at the same machinery for AI game worlds and for predictive models in robotics, which is where the interactive-latency idea is heading next.

The paper's future-work list is the honest spec of what FastFrames cannot do yet: adding action conditioning without adding latency, scaling to higher resolutions, and running on lighter hardware, plus the open problem of long-term consistency and physical plausibility. The release is a research artifact at 480p on data-center GPUs, with no hosted API and no consumer-hardware figure. The 36 milliseconds is a claim about a specific machine, and Apple is clear about which one.

FastFrames-S and FastFrames-L are on Hugging Face under the apple organization at huggingface.co/apple/FastFrames-L, the code is at github.com/apple-aiml-research/ml-fastframes, and the way to check the latency claim on your own hardware is Apple's own benchmark script, evaluation/latency/benchmark.py ff-s.

Sources

  1. huggingface.co - model card, component latency table, base model, license, output spec
  2. huggingface.co - 1.3B variant card, Wan2.1-T2V-1.3B base, same latency table
  3. github.com - code, training recipe, license terms, repo creation date
  4. apple-aiml-research.github.io - project page, Krea-Realtime comparison, demo descriptions
  5. arxiv.org - paper abstract, authors, submission date
  6. arxiv.org - method, VBench table, latency breakdown, interactive application figures
  7. krea.ai - rival's own page: Krea Realtime 14B speed and first-frame time
  8. huggingface.co - rival's own model card: 11 fps, Apache 2.0 license
  9. superpowerdaily.com - independent write-up, FastFrames-L single-GPU figure
  10. aiweekly.co - independent write-up, baseline profiling figures
  11. dailyaibrief.com - independent write-up, release overview
  12. cpu3d.com - weight file and repository sizes, November 16 upload date
  13. localmodelwatch.tsuchitsuchi.com - notes the model card omits the latency unit
  14. orcarouter.ai - independent write-up: Apple's weights published November 16, paper dated the 17th; 63.87M-parameter pixel decoder, 2 to 6 ms KV refinement, 832x480 81 frames 16 fps
  15. krea.ai - Krea's own model list: LTX-2 described as an audio-video model from Lightricks with native sound generation