FastMetal: Run Text-to-Video Locally on Mac with Apple Silicon

Conclusion First: Mac Can Now Run Text-to-Video Locally

Previously, local text-to-video required an RTX 4090/5090 or cloud queues. In August 2026, UCSD's Hao AI Lab released FastMetal (formally FastMetal-QAD), three open-source video generation models (1.3B, 5B, 14B) that run directly on Mac chips via Metal + MLX — no CUDA, no cloud. A 5-second 480p video takes as little as 30 seconds, using only 3.9 GiB memory, even on fanless MacBook Air. This is currently the only consumer-grade Mac solution that truly runs local text-to-video end-to-end.

What FastMetal Is (Three Names, One Project)

FastMetal — product and release name

FastMetal-QAD / FastWan-QAD — model family (QAD = Quantization-Aware Distillation)

FastVideo repo Apple Silicon branch — code source (github.com/hao-ai-lab/FastVideo)

All three models ship as INT8-quantized MLX weights, small downloads, fast loads. Key: everything runs on-device; video never leaves the machine. Code is Apache-2.0, weights free on Hugging Face, no subscriptions or per-generation fees.

Why It Runs on Mac: Technical Principles

FastMetal distills existing Wan video models into Mac-friendly small models:

Model Distillation Mapping

FastMetal-1.3B-QAD : Base model Wan2.1-T2V-1.3B, distillation method 3-step DMD2 + INT8 quantization-aware

FastMetal-5B-QAD : Base model Wan2.2-TI2V-5B, distillation method 3-step DMD2 + INT8 quantization-aware

FastMetal-14B-QAD : Base model Wan2.1-T2V-14B, distillation method 3-step DMD2 + INT8 quantization-aware

Two core techniques:

DMD2 Distillation (Distribution Matching Distillation) : Compresses a diffusion model requiring dozens of denoising steps into a 3-step student model, yielding exponential speedup.

INT8 Quantization-Aware Training (QAD) : Weights stored as 8-bit integers, drastically cutting unified memory usage — the fundamental reason Mac's unified memory architecture can run these models.

Plus MLX runtime optimized for Apple Silicon's Metal graphics stack. Models consume Mac's unified memory (CPU/GPU share same RAM), no dedicated VRAM needed. Full pipeline: text → UMT5 encoder → DiT (DMD2+INT8) denoising → decode (TAEHV / Wan VAE) → RIFE frame interpolation → mp4. Each run produces ~5 seconds (81 frames). The three tiers differ only in resolution, speed, and memory — not in whether they run.

Environment Prerequisites

OS : macOS 14+

Python : must be 3.12.x (3.12.4+ recommended). Hard requirement — 3.11 and 3.13 fail. Do not use system Python 3.13.

Chip : M1 / M2 / M3 / M4 all supported

Disk : Models are larger than expected. 1.3B actual ~13.4 GB (UMT5 text encoder alone ~12.4 GB, DiT quantized weights 1.5 GB, VAE 0.5 GB). Reserve 25 GB+ for 1.3B, 40 GB+ for 14B.

Use uv for environment management (faster, cleaner than conda). Verify with uv --version. Install Python via uv python install 3.12.

Three-Step Installation

Inference scripts live in examples/inference/basic/ — must clone the repo, cannot just install PyPI package .

git clone https://github.com/hao-ai-lab/FastVideo.git
cd FastVideo
uv venv --python 3.12 --seed
source .venv/bin/activate
uv pip install -e ".[mlx]"
brew install ffmpeg

Notes: -e installs from source so example scripts work; [mlx] pulls MLX runtime; ffmpeg packages frames into mp4. Installation provides new hf CLI (old huggingface-cli deprecated and errors).

If git clone stalls at 0% or proxy errors, configure a GitHub-accessible proxy or use a mirror.

Downloading Models

Official repos on Hugging Face:

FastVideo/FastMetal-1.3B-QAD

FastVideo/FastMetal-5B-QAD

FastVideo/FastMetal-14B-QAD

Start with 1.3B only to validate the full pipeline , then add larger models. Download in activated venv:

hf download FastVideo/FastMetal-1.3B-QAD \
--local-dir ./FastMetal-1.3B-QAD

hf download

auto-resumes on interruption; do not add --resume (old CLI flag, errors on new CLI). For slow HF access, use mirror:

HF_ENDPOINT=https://hf-mirror.com hf download \
FastVideo/FastMetal-1.3B-QAD --local-dir ./FastMetal-1.3B-QAD

Generate First Video (1.3B Step-by-Step)

Required pre-step : 1.3B repo root contains only mlx_dit.safetensors / mlx_dit.json, no transformer/ subdirectory, but the script hard-reads model-root/transformer/config.json. Create symlinks or get FileNotFoundError:

mkdir -p ./FastMetal-1.3B-QAD/transformer
ln -sf ../mlx_dit.json ./FastMetal-1.3B-QAD/transformer/config.json
ln -sf ../mlx_dit.safetensors ./FastMetal-1.3B-QAD/transformer/diffusion_pytorch_model.safetensors

Then from project root (containing FastVideo/ and model dir, venv active):

python FastVideo/examples/inference/basic/mlx_wan_prompt_to_video.py \
--model-root ./FastMetal-1.3B-QAD \
--mlx-checkpoint ./FastMetal-1.3B-QAD \
--height 480 --width 832 --num-frames 81 \
--prompt "A fox runs through a misty pine forest, leaves kicking up behind it." \
--output-path ./output_fastmetal.mp4 \
--fast

Parameter breakdown: --model-root / --mlx-checkpoint: both point to downloaded dir. --mlx-checkpoint reuses root MLX quantized weights, skips online cast, loads faster. --height / --width: resolution, 1.3B baseline 480×832. --num-frames: frame count, 81 ≈ 5 seconds. --prompt: English prompt (Chinese requires --enhance-prompt, see advanced). --output-path: output mp4 path. --fast: alternate-frame denoising mode (see advanced), recommended for beginners.

Finished mp4 appears at --output-path.

Choosing Among Three Tiers

Official benchmarks on M4 Max (36 GB) (cold start includes first prompt encoding):

Benchmark Results

1.3B : Resolution 480×832, End-to-End Time ~110s (fast), Peak Memory 3.87 GiB, Use Case: Fastest, runs on MacBook Air

5B : Resolution 704×1280 (720p), End-to-End Time ~151s (Fast ~47s), Peak Memory 9.34 GiB, Use Case: 720p quality, works on 16 GB Mac

14B : Resolution 480×832, End-to-End Time ~602s, Peak Memory 21.68 GiB, Use Case: Quality priority, 36 GB+ machines

Two critical caveats:

Official "peak memory" uses decimal RAM; 24 GB Mac actually has ~22.35 GiB usable, OS consumes several GiB.

14B's 21.7 GiB peak nears 24 GB machine's real limit — officially targeted at 36 GB+. Do not expect smooth 14B on 24 GB.

Real-world varies: 13-inch MacBook Air (M5, 24 GB) fanless runs 1.3–2× slower than M4 Max, normal. Selection guide: 8 GB → 1.3B; 16 GB → 5B sweet spot; 36 GB+ → 14B for quality. Start with 1.3B — most stable, native 480×832, clean output, lowest barrier. 5B/14B trade memory and time, not "better must upgrade."

Advanced Modes

All flags compatible across tiers:

--fast / --fast-factor 2 + --fast-sharpen : alternate-frame generation, RIFE interpolation for missing frames. Official claims ~half denoising time; --fast-sharpen restores edge sharpness. Note: saved denoising time partially eaten by RIFE interpolation, end-to-end not halved, quality slightly softer, but per-step denoising load lighter.

--refine : generate at base resolution, then second denoising pass at higher resolution with same DiT, minimal extra memory, gains detail.

--enhance-prompt : locally expands short prompt into cinematic language, critical for Chinese prompts — Chinese direct input yields poor results, always add this flag.

--decode-backend wan-vae : use full Wan VAE decoder (bf16), better quality but slower.

5B uses separate entry point ( mlx_wan22_generate.py, based on Wan2.2 architecture, different latent structure):

export PYTHONPATH=$PWD/FastVideo  # must expose package path from project root
python FastVideo/examples/inference/basic/mlx_wan22_generate.py \
--mlx-checkpoint ./FastMetal-5B-QAD \
--text-encoder-root ./FastMetal-5B-QAD \
--vae-root ./FastMetal-5B-QAD \
--height 448 --width 832 --num-frames 81 \
--prompt "A red fox trotting through a snowy pine forest, cinematic" \
--output-path ./my_5b.mp4 \
--fast

⚠️ 5B is not the same entry script as 1.3B/14B. Parameters differ: 5B only accepts --mlx-checkpoint / --text-encoder-root / --vae-root, no --model-root (that's for 1.3B/14B script). Applying 1.3B command to 5B yields unrecognized arguments. 14B uses same mlx_wan_prompt_to_video.py as 1.3B, just swap repo name and resolution.

Troubleshooting Checklist

No module named 'examples.inference.basic' → run export PYTHONPATH=$PWD/FastVideo from project root before executing.

FileNotFoundError: .../transformer/config.json → create transformer symlinks per section 7.

huggingface-cli errors → deprecated, use new hf CLI.

hf download rejects --resume → new CLI auto-resumes, drop the flag and rerun.

git clone stuck at 0% → configure proxy or switch mirror.

Chinese prompt quality poor → add --enhance-prompt.

OOM / process killed → drop to 1.3B, or lower resolution (e.g., 5B at 448×832 instead of 704×1280).

Local vs Cloud: When to Use FastMetal

Decision Matrix

Privacy-sensitive, video must stay on-device → Better Choice: FastMetal. Reason: Fully local, zero upload.

No capable Mac (phone/PC/old laptop) → Better Choice: Cloud. Reason: Cloud runs on any device.

Need finished clips with audio, subtitles, transitions → Better Choice: Cloud. Reason: Local outputs raw short video only.

Prefer CLI, want zero cost → Better Choice: FastMetal. Reason: Free open-source, local execution.

Need clips longer than 5 seconds → Better Choice: Cloud. Reason: Local single segment ~5 seconds max.

In short: Have Apple Silicon Mac, care about privacy, don't mind CLI → FastMetal; want ready-to-use finished video, device-constrained → Cloud. They complement, not replace.

Trend Summary

FastMetal signals a clear direction: on-device generation is the future. MLX + INT8 QAD moves data-center-scale models onto consumer laptop unified memory. Wan ecosystem's "distillation-first" path (FastWan → FastMetal) shows video generation's next phase isn't "bigger" but "faster to frame."

Three practical takeaways:

Run 1.3B end-to-end first — pipeline working matters more than chasing 14B quality.

Always add --enhance-prompt for Chinese — it's the quality divider for small models.

Watch Dreamverse (image-to-video) porting to Mac — that's when local video creation truly unlocks imagination.

Mac local text-to-video: this time it actually works.

References: FastVideo official repo (github.com/hao-ai-lab/FastVideo), Hugging Face model collection (FastVideo/fastmetal), Hao AI Lab blog and community benchmarks.