What it takes to run one on your own card

The arithmetic before the download

Three things have to fit in VRAM at once, and people usually count only the first.

1. Weights. Parameters times bytes per parameter. A 14-billion-parameter model at bf16 is 2 bytes each: about 28GB. At fp8 it is roughly 14GB. At a 4-bit GGUF quantisation, around 8GB.
2. Activations. The latent block plus every intermediate tensor the attention layers hold during a forward pass. This scales with resolution and duration, and at video sizes it is not small: often several gigabytes.
3. The VAE decode. Expanding the latent back to pixels allocates the full-size frames. Decoding a 1080p clip in one go can spike higher than the whole generation.

So “the model is 14GB” and “14GB of VRAM is enough” are different claims, and the second one is usually false.

The four things that make it fit

• Quantisation. fp8 roughly halves the weights against bf16, with a small quality cost. 4-bit GGUF halves again, with a larger one: motion tends to soften and fine detail degrades before anything looks obviously broken. Quantise the transformer; leave the text encoder and VAE alone if you can afford to.
• Offloading. Keep most weights in system RAM and stream the needed blocks to the GPU. ComfyUI’s block-swap and the --lowvram family of flags do this. It works and it is slow, because you are moving gigabytes across PCIe every step.
• Tiled VAE decode. Decode the output in overlapping tiles instead of all at once. Removes the decode spike almost entirely, at the cost of faint seams if the tiles are too small.
• Smaller outputs. 480p instead of 720p cuts activation memory by more than half. Generate drafts small. This is the cheapest lever and the one people reach for last.

What runs on what

Rough shape as of 2026, and it moves:

• 24GB (e.g. a 3090 or 4090). Comfortable. A 14B model at fp8, 720p, five seconds, in roughly one to three minutes.
• 16GB. Workable with fp8 and tiled decode. Expect a few minutes per clip.
• 12GB. Quantised models at 480p, with offloading. Several minutes per clip. Usable for learning and draft passes, painful for production.
• 8GB. 4-bit quantisations, low resolution, heavy offload. Minutes per clip, frequent out-of-memory failures. Possible, not pleasant.
• Apple Silicon. Unified memory helps with fit; MPS support in video pipelines is behind CUDA and considerably slower. A 32GB or 64GB Mac will run things a 12GB PC cannot, and will take longer doing it.
• Integrated graphics, or a phone. No. Not slowly: not at all. This is not pessimism, it is the memory arithmetic.

The free GPU paths that actually work

If you do not own a card, three routes are real:

1. Hugging Face Spaces. Browser demos of most open video models, no install, no account needed for many. You queue behind everyone else and you cannot change much. On a phone this is the entire workflow, and it works.
2. Google Colab free tier. A T4 with around 15GB, session limits, and disconnections. Enough for quantised models at low resolution. ComfyUI runs in Colab through community notebooks.
3. Kaggle notebooks. A weekly GPU quota, typically around 30 hours, on T4s. More generous session length than free Colab and less prone to mid-render disconnection, which matters when a render takes four minutes.

The honest cost of all three is queue time and the risk of losing a session at eighty per cent. Use them to learn and to make your own work. Do not promise a client a deadline that depends on somebody else’s free queue.

Why you would bother at all

Running locally is slower and more fiddly than a hosted endpoint. The reasons people do it anyway are specific:

• No per-second meter. Experimentation becomes free, which changes how much you experiment.
• Real determinism. Same graph, same seed, same output, which hosted APIs will not promise.
• No unexpected refusal. Content filters on hosted services occasionally decline legitimate work with no explanation and no appeal.
• You can train. A character LoRA needs the weights. That is covered later in the course, and it is the strongest identity tool available.
• The model does not change under you. A checkpoint on your disk is the same checkpoint next year.

The setup, in one paragraph

ComfyUI is the practical front end: a node graph, an enormous community library, and workflows shared as JSON files you can drop in. Install it, download a model in the format your VRAM allows, load a known-good workflow from the model’s own page rather than building one from scratch, and change one node at a time. Everybody’s first week is spent on dependency versions and out-of-memory errors; that is normal and it ends.

More on the general mechanics in running-models-yourself.

Today: look up your GPU’s VRAM, then check the model card for the quantisation that fits in it with three or four gigabytes to spare for activations. If nothing fits, open a Hugging Face Space instead and lose nothing.