
FastFrames-L is a 14B autoregressive video diffusion model from Apple and Cornell that generates 480p video at interactive latency. It runs at 45 ms per frame, or 22 responses per second, on an 8x B200 GPU node. It is a two-step causal model distilled from Wan2.1-14B, with a ConvNeXt-based pixel decoder and a KV refinement network replacing VAE decoding and KV cache updates. Code and weights are released on GitHub and Hugging Face under a license listed as Other.
A workable 14B-parameter dense video generator from Apple and Cornell. Treat the modality benchmarks above as the leading indicator of fit — composite scoring across modalities is still maturing. Newly released, so production-readiness is still being shaken out.
Generated from this model’s benchmarks and ranking signals. Editor reviews refine it over time.
Access model weights, configuration files, and documentation.
No benchmark data available for this model yet.
Benchmark data sourced from: Hugging Face, Arena.ai, Artificial Analysis.
The top devices for this model at 4-bit, ranked by fit and speed.
| Device | Grade | VRAM |
|---|---|---|
| ACEMAGIC M1A Pro (i9-13900HK + ARC A770)ACEMAGIC | SS | 9.1 GB |
| Acer Veriton GN100 AI MiniAcer | SS | 9.1 GB |
| AI TOP ATOM ATAGB10-9003Gigabyte | SS | 9.1 GB |
| AMD Instinct MI300XAMD | SS | 9.1 GB |
| AMD Instinct MI325XAMD | SS | 9.1 GB |
Cheapest current cloud rentals with at least 9 GB VRAM, refreshed hourly.
Advertising disclosure: we earn commissions when you shop through the links below.
| Option | Cost / GPU-hour |
|---|---|
NVIDIA GeForce RTX 5060 TiVast.ai · Spot · 16 GB VRAM | $0.06 |
NVIDIA Tesla V100 16GBVast.ai · Spot · 16 GB VRAM | $0.08 |
NVIDIA RTX A4000Vast.ai · Spot · 16 GB VRAM | $0.08 |
NVIDIA RTX A4000Vast.ai · On-Demand · 16 GB VRAM | $0.09 |
NVIDIA GeForce RTX 4070Vast.ai · Spot · 12 GB VRAM | $0.09 |
Per-GPU rate across RunPod, the Vast.ai marketplace, DigitalOcean, and Vultr.
Spot tier is interruptible. Plan for restarts when comparing against on-demand prices.
FastFrames-L (14B) is an open-weights autoregressive video diffusion model developed jointly by Apple and Cornell University. Engineered specifically to eliminate the latency bottlenecks that traditionally prevent real-time video generation, the model delivers 480p output at an interactive latency of 45 ms per frame (22 responses per second) on an 8x NVIDIA B200 GPU node. It operates as a two-step causal diffusion model distilled directly from the Wan2.1-T2V-14B foundation model, targeting engineers who require responsive, interactive visual synthesis rather than slow, offline batch generation.
Standard video diffusion architectures rely on multi-step denoising loops that take seconds or minutes to generate brief video sequences. FastFrames-L repositions the 14-billion-parameter scale for low-latency interactive workflows. By identifying and replacing hidden latency bottlenecks in traditional pipelines, specifically Variational Autoencoder (VAE) decoding and quadratic key-value (KV) cache updates, the model achieves interactive frame generation without sacrificing the visual depth, spatial coherence, or lighting realism expected from a large foundation model.
Apple and Cornell released the model weights and source code under a custom research license (listed as apple-amlr on Hugging Face). For practitioners building interactive environments, robotics simulators, and real-time visual interfaces, evaluating a local AI model 14B parameters 2026 release like FastFrames-L offers an operational blueprint for deploying high-fidelity video generation directly on dedicated local hardware.
FastFrames-L uses a dense 14-billion-parameter Diffusion Transformer (DiT) architecture adapted for causal, autoregressive frame generation. Instead of sampling an entire video volume across dozens of diffusion steps simultaneously, FastFrames-L generates video causally, conditioning each new frame on previous visual tokens and ongoing user input.
During their profiling of modern video generation pipelines, the researchers identified that non-DiT operations account for more than 50% of end-to-end inference latency. Specifically, high-resolution VAE decoding and constant KV cache updates across long temporal windows introduce severe overhead. FastFrames-L systematically replaces these components:
FastFrames-L focuses on low-latency text-to-video (T2V) and interactive control streams. It natively generates video at 832x480 resolution at 16 frames per second, handling continuous sequences of 81 frames or indefinite interactive loops.
Deploying the model locally requires a solid understanding of its computational footprint. Because this is a dense 14B diffusion model distilled to run at ultra-low latency, memory bandwidth and multi-GPU interconnect speeds dictate real-world performance.
uv.FastFrames-L (14B) performance varies sharply depending on whether your hardware configuration matches the high-bandwidth multi-GPU topology intended by the authors:
The best GPU for FastFrames-L (14B) in a production or research lab is an enterprise cluster with high-speed interconnects (NVLink), such as 8x H100 or B200 systems, where cross-GPU tensor parallel synchronization completes in single-digit milliseconds.
If you are determining how to run 14B model on consumer GPU setups, you must split the model across multiple cards. The best quantization for FastFrames-L (14B) is FP8 (W8A8 or W8A16). Diffusion models are historically brittle under aggressive 4-bit integer quantization (such as INT4 or Q4_K_M), which often leads to severe temporal artifacts, color banding, and frame collapse in DiT blocks. FP8 maintains numerical stability across the two diffusion steps while cutting the parameter footprint from ~28 GB down to ~14 GB, allowing a 2x RTX 4090 workstation to run FastFrames-L (14B) locally without running out of memory.
The model is not distributed as an Ollama LLM because it is a video diffusion pipeline requiring custom CUDA kernels for the ConvNeXt pixel decoder and causal attention layers. To set up the environment:
1# Clone the repository and sync dependencies2git clone https://github.com/apple-aiml-research/ml-fastframes.git3cd ml-fastframes4uv sync56# Run the 8-GPU latency benchmark7uv run python evaluation/latency/benchmark.py ff-l --gpus 889# Generate a text-to-video clip10uv run python scripts/generate.py \11 --model ff-l \12 --checkpoint-dir checkpoints \13 --prompt "Cinematic shot of an astronaut walking on a foreign planet, dynamic lighting" \14 --output outputs/astronaut.mp4
Understanding the trade-offs of FastFrames-L requires comparing it to both its foundation base and its smaller architectural sibling.

Explore the Provider
Aggregate stats, leaderboard, release timeline, and benchmark coverage across every Apple and Cornell model we track.

Check which of your devices can run this model and how fast.

Compare hosted per-token prices before you commit to local hardware.

Break-even math for self-hosting, renting a GPU, or paying per token.
Live status for the hosted APIs you might use instead of running this locally.