The Production Pipeline

A single second of a feature animation is 24 frames, and one shot might be a hundred of them. Yet no single artist made that shot. It was carried, like a baton, through a relay of departments — story, layout, modelling, rigging, animation, effects, lighting, rendering, compositing, editorial — each adding its layer and handing the result downstream. A modern film touches thousands of people and hundreds of thousands of files. The remarkable thing is not that it looks good; it is that it ever finishes.

This page is about the industrial reality of making animation: the pipeline that orders the work, the versioning and interchange that keep it consistent, and the review cycles that catch mistakes. The core lesson runs against a beginner's instinct — the hardest problems in a big production are not the algorithms you have been studying, they are organisational: dependencies, versions and communication between people. Structure is as much a part of the craft as the maths.

It builds directly on the conceptual animation pipeline overview; here we zoom out to the whole studio.

The film / VFX pipeline: a relay of departments

Think of a shot as an object that gains detail as it flows through the studio. Each department depends on the previous one — you cannot light a character before it is animated, and you cannot animate it before it is rigged. That strict ordering is the spine of the whole operation.

Story & previs — storyboards and rough 3-D "previsualisation" fix what happens and roughly how the camera sees it.
Layout — places the real cameras, sets the staging, and blocks where characters and props sit in the scene.
Modelling — builds the geometry: characters, props, environments.
Rigging — gives models a control skeleton and deformation so they can be posed.
Animation — performs the shot, keyframing the rig over time.
CFX / simulation — cloth, hair, muscle and FX (fire, water, dust) driven by physics on top of the animation.
Lighting — places lights and defines materials for the shot's mood.
Rendering — computes the final images, one frame at a time, on the farm.
Compositing — combines the rendered layers (passes) into the finished frame.
Editorial — cuts approved shots into the sequence and the film.

Each arrow in that chain is a handoff: a package of data with an agreed shape, delivered to the next department. The pipeline is, at heart, the set of rules for those handoffs.

Department by department — what it makes, what it uses

Everything you study in this course is used somewhere in that relay. The table maps each department to what it produces and which parts of the course power it.

Department	Produces	Draws on (course topics)
Layout	Camera placement, shot staging, blocking	Cameras, projection, scene composition
Modelling	Meshes, surfaces, UVs	Curves & surfaces, geometry
Rigging	Skeletons, skinning, controls	Kinematics, rigging, skinning weights
Animation	Keyframed / mocap performance	Principles, timing & spacing, mocap
CFX / simulation	Cloth, hair, fluids, particle FX caches	Physics, rigid bodies, particles, fluids
Lighting	Lights, materials, look	Shading, radiometry, global illumination
Rendering	Rendered frames & passes	Ray tracing, sampling, the render farm
Compositing	Final assembled frames	Image compositing, colour, layers

Worked example: tracing one shot's dependency chain

Follow a single shot of a caped hero walking through wind. A lighting artist is assigned to it, but cannot render a single final frame yet. Why? Trace the chain of blockers:

Rigging must deliver an approved cape-and-body rig.
Animation can only start once the rig is stable; the walk is keyframed and sent to dailies for approval.
CFX runs the cloth simulation on top of the approved animation, then bakes the result to a geometry cache (an Alembic file) so it need not be re-simulated every time.
Lighting loads the animated character plus the cached cloth, lights the scene, and only then can rendering produce final frames.

So the lighting artist is genuinely blocked: idle until animation is signed off and the cloth cache exists. Now the twist. Deep into lighting, a supervisor spots that the rig's shoulder deforms badly, and rigging ships a fix. That single upstream change ripples all the way down: the character must be re-skinned, the walk re-animated (or at least re-checked and re-approved), the cloth re-simulated and re-cached, and only then re-lit and re-rendered. One late edit at the top of the chain has invalidated the work of four departments below it. This is why the pipeline is ordered, and why every artefact is versioned.

The connective tissue: assets, versions, review, interchange

Between the departments sits the machinery that makes the relay survivable at scale.

Asset management & versioning — every model, rig, texture and cache is a named asset with numbered versions and recorded dependencies. Downstream work pins the exact version it consumed, so a new version never silently corrupts a shot.
Review cycles (dailies) — work is shown daily to supervisors, who give notes; the artist iterates. Approval at a review is the gate that lets a shot move downstream.
Interchange formats — because departments use different tools, data must move in agreed formats (below).
The render farm — a queue manager dispatches thousands of frames to thousands of machines, tracking dependencies and retries.

The interchange formats are worth naming, because you will meet them constantly:

Format	What it carries	Role
USD (Universal Scene Description)	Whole scenes: hierarchy, references, layers	Pixar's open standard for describing, composing and layering scenes across tools — now the industry backbone
Alembic	Baked geometry caches (vertices per frame)	Freezes a sim / animation result so downstream never re-computes it
FBX	Rigs, animation, meshes	Common exchange between DCC tools (esp. rigs + skeletal animation)
glTF	Meshes, materials, animation	Lightweight delivery format, popular for real-time / web / games

USD deserves special note. Its superpower is layering: lighting can add a layer of lights over the animation layer without touching it, and a new version of the animation flows through automatically. That non-destructive composition is precisely what lets many departments work on the same shot at once without stepping on each other.

The render farm

Rendering is embarrassingly parallel: each frame is independent, so it can be computed on a different machine. A studio runs a render farm — thousands of CPU/GPU nodes fed by a queue manager (Deadline, Tractor, and friends) that splits a job into per-frame tasks, dispatches them, honours dependencies (composite only after render), and re-queues failures. If a single frame at 4K takes a few hours, a 150-frame shot rendered serially would take days; spread across the farm it comes back overnight. Farm time is a scarce, scheduled resource — another reason a late upstream change hurts, since it can mean throwing away frames you already paid to render.

The game pipeline: same idea, different constraints

Games share the departmental spine — models, rigs, animation — but bend under one ruthless rule: everything must run at frame rate on the player's machine. There is no overnight farm; the "render" happens 60 times a second, live. That changes the downstream half of the pipeline completely:

Aspect	Film / VFX	Games
Rendering	Offline, hours per frame, on a farm	Real-time, milliseconds per frame, on the player's GPU
Assets	As heavy as needed	Budgeted: poly counts, texture memory, draw calls
Animation	Authored per shot, hand-approved	Clips wired into state machines / blend trees that react to input
Simulation	Baked offline to caches	Approximated live within the frame budget
Target	The final image is the product	The engine that generates images at runtime is the product

So a game animator does not deliver a finished shot; they deliver clips — walk, run, jump, land — that an animation state machine in the engine blends together in response to the player. The craft shifts from "make this one moment perfect" to "make a system that always looks right, whatever the player does, at 60 fps."

Before USD, every studio hand-rolled its own scene format and glued tools together with fragile scripts; moving a scene between two packages was a small act of archaeology. Pixar built Universal Scene Description to compose Toy Story-scale scenes — millions of objects, assembled from thousands of referenced assets, with each department contributing a non-destructive layer on top. Then, in 2016, they open-sourced it. Why give away your crown jewels? Because an interchange format is only valuable if everyone speaks it — a private standard is a dialect, a shared one is a language. Today USD is supported across Maya, Houdini, Unreal, NVIDIA's Omniverse and more, and it is the closest thing the industry has to a universal file for 3-D scenes. Network effects beat secrecy.

The tempting shortcut on a tight deadline is to work out of order or against unversioned assets — "just start lighting off the current animation, we'll sync the rig fix later." It feels faster; it is a trap. A late upstream change — an edited model or a tweaked rig — silently invalidates every downstream artefact: the animation no longer fits the new deformation, the cloth sim was cached against the old shape, the lighting and renders assumed both. Without versioning, nobody even knows which shots consumed the broken version, so the breakage surfaces at random, days later, in dailies.

This is exactly why studios spend so much on asset versioning, USD layering and review gates: pin the version you consumed, layer changes non-destructively, and let nothing move downstream until it is approved. The deepest truth of a big production is that the biggest real-world animation problems are organisational, not algorithmic. A brilliant renderer cannot save a pipeline that has lost track of which version of the hero is the real one.