Week 1: The Rig

Setting up the rig for the semester — a VRAM budget or a credit budget, where model weights and their licences come from, and the graph or the request log as the artefact that survives the render.

22 February 2027

Every shot this semester comes out of a rig, and a rig is one of exactly two things: a graphics card with a VRAM ceiling, or an account with a credit balance. Neither is the legitimate one — a booked slot on the school’s shared card and a metered API key are both rigs, and this course treats them as interchangeable inputs to the same discipline. What doesn’t change between them is what has to be tracked: where the weights or the model came from, what licence governs the output, and a record detailed enough that today’s result can be found again next week.

The rig, item by item. Both kinds of rig carry all five.
BudgetA VRAM ceiling on a local rig, a credit balance on an API rig. One of those two numbers is yours, and it is known before a shot is planned, not after.
WeightsOne base release plus a long tail of community finetunes, from a public repository. An API model publishes the same information as terms of service instead of as a file.
LicenceNot interchangeable between files: some permit commercial use outright, some are research-only, and some carry a responsible-use clause restricting the output itself.
The recordThe workflow graph on a local rig, the request log on an API rig. Either one lets someone rerun the decision that produced a frame; the frame does not.
Render timeWall-clock time per take on a local rig, queue time plus a metered cost on an API rig. It is a number you measure on the rig you actually have, not one you can carry over from someone else’s — and before counting the takes thrown away.

The two shapes of a budget

A local rig is bounded by VRAM, not by price or processor speed — VRAM sets the largest model, the highest resolution, and the longest clip a single pass can produce. Running out of it doesn’t mean slower; past a point, it means the model does not run at all. An API rig is bounded by a credit balance instead: no ceiling on model size, but every call has a metered cost, and a workflow that loops without a limit burns through a semester’s budget in an afternoon. Know which number is yours before planning a shot around a model you’ve only read about.

Where the weights, or the model, come from

Local model weights come from public repositories — one base release, then a long tail of community finetunes built on top of it — and every file carries a licence that is not interchangeable with any other: some permit commercial use outright, some are research-only or non-commercial, and a few carry a responsible-use clause restricting specific output regardless of what was paid for access. An API model publishes the same information differently, as terms of service rather than a licence file, but the obligation to read it before building a shot around it is identical.

The artefact is the record, not the frame

On a local rig, the thing worth keeping is the workflow graph: a node-based description of the operations that produced a frame, saved so the same recipe runs again with a new seed for a comparable result. On an API rig there’s no graph to save, but there is a request log — the exact parameters sent and the response received — and it does the same job. Either way, today’s frame is not the point. What’s worth keeping is whatever lets someone else rerun the decision that produced it.

Render time is not shooting time

Wan2.2’s README states that TI2V-5B, the smallest model in that release, “can generate a 5-second 720P video in under 9 minutes on a single consumer-grade GPU” — the same model the README puts at a floor of 24GB of VRAM. Read that as a floor rather than a promise: it is the model’s own best case, at its smallest size, for one take that worked.

A heavier model, a longer clip, or a card that only just clears the VRAM line all move that number, which is why the only render time worth planning a shot around is the one you have timed on your own rig. On an API rig the equivalent number is the provider’s published per-call price for the model you are calling, plus queue time: look it up for the account you open this week and write it down, the same way you would time a local render. A shot that survives Dailies is rarely attempt one, on either kind of rig.

Source: Wan2.2 README — https://github.com/Wan-Video/Wan2.2

Before class

Pick one rig and commit to it: install a local workflow engine and download one base model plus one small community finetune, or open an account with a generative video API and note its per-call cost. Either way, arrive with two comparable checkpoints or settings to test against each other.

This week’s exercise

Generate one five-second clip on default settings, then generate it again after changing exactly one parameter. Keep both graph files or both request logs, and log both render times and, if relevant, both costs. Bring both clips, their graphs or logs, and your timing notes to Wednesday’s Dailies.

Reading

Teaching team