How to Run Apple's FastFrames-L Video Model Locally (It Won't Run on a Mac)
DEV Community

How to Run Apple's FastFrames-L Video Model Locally (It Won't Run on a Mac)

Apple just put FastFrames-L, a 14B open text-to-video model, on Hugging Face, and the first thing every Mac owner I know asked was "will it run on my M-series laptop?" Short answer: no.

The official code needs Linux, an NVIDIA GPU and CUDA 12.8, Apple publishes no VRAM figure, and the headline 45 ms number comes from a node of eight B200s. The longer answer is still worth your time.

FastFrames-L is a real piece of engineering, and it ships under a license that keeps it out of anything you'd sell. I haven't run it myself. The hardware notes, commands and Wan2.1 comparison below all come from the model card, the paper, the GitHub repo and the license file.

What Apple FastFrames-L actually is

FastFrames comes from Apple's ML research group (Gene Chou, Guandao Yang, Fujun Luan, Lars Mescheder, Wei Dong, Stephan Richter, Vladlen Koltun). The paper went up on arXiv on 17 November 2026 as FastFrames: Video Generation at Interactive Latency.

There are two models:

  • FastFrames-S, 1.3B parameters
  • FastFrames-L, 14B on the model card and 14.3B in the paper's Table 1

Neither was trained from scratch. FastFrames-L is Wan2.1-T2V-14B distilled into a two-step causal (autoregressive) generator following the Causal Forcing++ recipe. Apple then trained two extra pieces on top: a lightweight pixel decoder and a KV refinement network.

That last part is the idea worth stealing. The authors profiled existing real-time video pipelines and found that VAE decoding and KV cache updates, the parts everyone treats as fixed overhead, take more than half of end-to-end latency. So they replaced them.

On FastFrames-S, the repo's profiling table shows where each millisecond goes on one GPU:

Component Latency
DiT eval, t=1000 16.1 ms
DiT eval, t=833 16.2 ms
KV refinement 2.2 ms
Pixel decoder 0.9 ms
Total 35.4 ms (paper: 36 ms)

The pixel decoder takes 0.9 ms. In the baseline pipeline the paper profiles, the VAE decoder alone took 147 ms. Apple's project page puts the whole thing at 271.8 ms per autoregressive step before their changes and 35.8 ms after.

Output specs are modest: 832×480, 81 frames at 16 fps, so about five seconds per clip. The paper is upfront that going to 720p "increases latency significantly": 127 ms per step for FastFrames-S on one B200, well past the 50 ms target.

45 ms per frame, on eight B200s

The pitch is "interactive latency (<50 ms)". Here's what that costs:

  • FastFrames-S: 36 ms per step on 1× B200, 14 ms on 8× B200
  • FastFrames-L: 158 ms on 1× B200, 45 ms on 8× B200

The paper's appendix profiles H100s too and says they're roughly 25-50% slower depending on configuration. Getting FastFrames-L under 50 ms takes context parallelism across eight GPUs, with CUDA graphs and NVLink symmetric-memory gathers. That's datacenter plumbing, and you can't approximate it on a desktop.

Every latency number in the main paper is a B200 number. The paper also calls on-device interactive video "an exciting possibility", which is an odd line to read in an Apple paper whose code won't start on a Mac.

Can you run FastFrames-L locally?

On a Mac: no. The installation doc lists Linux x86-64 with an NVIDIA GPU and a CUDA 12.8-compatible driver, and uv sync pins PyTorch 2.9.1 / CUDA 12.8. There's no MPS or MLX support, and no diffusers pipeline or ComfyUI node for FastFrames (diffusers only shows up as a pinned dependency of the lingbot and baselines extras). Someone could port it to MLX eventually, but today you'd be starting from zero.

On a single NVIDIA card: maybe, if it's a big one. Apple publishes no inference VRAM figure. My own back-of-envelope: 14.3B parameters in BF16 is about 28.6 GB for the DiT weights alone (the released dit.safetensors is 28.6 GB, so the math holds), before the umT5 text encoder, activations and the KV cache. That puts a 24 GB consumer card out of reach without quantization, and Apple doesn't ship a quantized version. I'd treat an 80 GB H100 as the realistic minimum for trying it unmodified, though that's my estimate and I haven't measured it.

Disk is the other surprise. The FastFrames-L repo is 174 GB, but 143 GB of that is intermediate checkpoints (causal teacher, consistency-distilled, DMD-distilled). For generation you only need the fastframes-l/ folder, and you can skip the Wan base DiT weights:

git clone https://github.com/apple-aiml-research/ml-fastframes
cd ml-fastframes
uv sync
uv run hf download apple/FastFrames-L --include 'fastframes-l/*' --local-dir checkpoints
uv run hf download Wan-AI/Wan2.1-T2V-14B --local-dir checkpoints/Wan2.1-T2V-14B \
  --exclude 'diffusion_pytorch_model*'
uv run python scripts/generate.py --model ff-l --checkpoint-dir checkpoints \
  --prompt "A corgi surfing a wave at sunset" --seed 0 --output outputs/corgi.mp4

If you have a multi-GPU box and want to check the latency claim yourself:

uv run python evaluation/latency/benchmark.py ff-l --gpus 8

flash-attn isn't required; the wrappers use cuDNN SDPA. That saves you the usual hour of compiling wheels.

The license: research only, no commercial use

The weights are tagged apple-amlr, the Apple Machine Learning Research Model License Agreement. It grants use "exclusively for Research Purposes" and explicitly excludes "any commercial exploitation, product development or use in any commercial product or service." Fine-tunes count as derivatives and inherit the same restriction. The code is under the Apple Sample Code License, and the LingBot demo pieces are CC BY-NC-SA 4.0.

This is the part that bugs me. FastFrames-L is distilled from Wan2.1-14B, which is Apache 2.0. Apple took a permissively licensed base, added a decoder and a KV trick, and shipped the result under terms that rule out a product, an internal tool at a company, or a paid side project. You can learn plenty from the paper, but you can't build on the weights.

FastFrames-L vs Wan2.1, Wan2.2 and HunyuanVideo on VBench

Table 1 of the paper puts everything on one B200 unless noted. I've pulled the rows most people will compare against; the full table also has MiniMax-H3, LTX2.5, MAGI1.1, Helios, LongLive2.0 and CausVid. These are Apple's measurements on Apple's harness, so treat them that way.

Model Params (B) Latency (ms) VBench Total Quality Semantic
Wan2.1 1.3 30,444 83.80 84.56 80.73
Wan2.2 14.3 117,734 84.65 85.41 81.60
HunyuanVideo1.5 8.3 1,555,508 83.18 84.14 79.35
Krea-Realtime 14.3 1,675 84.42 85.08 81.81
Self-Forcing 1.3 717 84.10 84.84 81.13
Causal Forcing++ 1.3 272 84.11 85.09 80.20
FastFrames-S 1.3 36 84.23 85.30 79.92
FastFrames-L 14.3 158 84.44 85.48 80.29
FastFrames-L (8 GPU) 14.3 45 84.44 85.48 80.29

The quality gap is tiny. FastFrames-L's VBench Total of 84.44 sits below Wan2.2 (84.65) and level with Krea-Realtime (84.42). Its Semantic score, 80.29, trails Wan2.2, Wan2.1 1.3B and Krea-Realtime. It does have the best Quality score in the table, at 85.48. Apple claims it matches the slow models while being much faster, and on VBench that holds up. Calling it "better than Wan" goes further than the numbers do.

The latency column is also comparing different things. The bidirectional models (Wan, HunyuanVideo) have to produce the whole clip before you see anything. The autoregressive ones stream frame by frame. HunyuanVideo1.5's 1,555,508 ms is about 26 minutes on a B200. That's a fair measure of interactivity, but it doesn't tell you how long a finished five-second clip takes to render, and that's the number most people care about.

What to run instead, depending on your hardware

On a Mac, skip FastFrames for now. Wan2.1 T2V-1.3B is in diffusers and ComfyUI, Apache 2.0, and the Wan README says it needs 8.19 GB of VRAM and takes about 4 minutes for a 5-second 480p clip on an RTX 4090.

On a rented H100 or B200, for research, try FastFrames-S first. It runs on one GPU, hits 36 ms on a B200, and needs far less download than the L model.

For anything commercial, don't touch the FastFrames weights. Build on Wan2.1 directly and read the paper for the pixel decoder and KV refinement ideas, since those are what make it fast.

If you're writing a paper on real-time video, this is a strong baseline, and Apple released the intermediate training checkpoints too, which almost nobody does.

The engineering is good, and the release is generous for researchers. Everyone else gets a five-second corgi video they're not allowed to ship.

So: would you use an Apple open video model in a real project, or does the research-only license kill it for you? And if you've got FastFrames-L running on a single 80 GB card, post your peak memory in the comments. I'd like to know how far off my estimate is.

Sources

  • apple/FastFrames-L model card and LICENSE
  • FastFrames: Video Generation at Interactive Latency (arXiv:2611.23226)
  • ml-fastframes on GitHub and its installation guide
  • FastFrames project page
  • Wan2.1 README
Read on DEV Community ↗ ← Back to News

Comments

No comments yet. Start the discussion.