11. Rerunning a Shot in ComfyUI

Summary

Rebuilding shot nine in ComfyUI

The chapter asks whether a shot already made in Runway can be rebuilt in an open tool that reruns on demand and makes controlled variations. Mostly it can. ComfyUI stores every setting of a render in the output file, and a fixed seed usually repeats a render on the same machine with the same software. ComfyUI does not promise identical output, so the accepted file in the shot folder stays the master. The walkthrough is illustrative, on the courier project, and is not a record of finished work. It sets up the unattended batches coming later.

Getting set up

ComfyUI builds a generation as a node graph: boxes that each do one job, joined by wires. Four install routes are covered: Desktop (the stable pick), a Windows-only portable build, a manual Python install, and Comfy Cloud. The Comfy Cloud documentation covers the hosted option. The Wan 2.2 tutorial covers the image-to-video template, which needs two diffusion models (high noise and low noise), the Wan 2.1 VAE and the umt5 text encoder. Each gets its own loader. Check that every loader points at the right file, because a wrong one can run and ignore your start image.

The name plate shot

Shot nine's accepted v002 gives the inputs: the References still and the motion prompt from its sidecar, with the production bible's lighting words kept in. You can change frame length, then run. Set the seed to fixed. The first render passes and is saved as a new source generation with its own sidecar, while the Runway take remains the master.

What the file remembers

ComfyUI embeds the workflow in PNG, WebP, MP4 and WebM outputs. Dragging the file onto the canvas restores the graph. A disable-metadata flag, re-encoding or an upload service can remove it. Model files and input images are recorded by name only. Treat metadata from files other people send as untrusted.

Rerun and variations

A same-seed rerun matches here, but that is likely, not guaranteed, and different hardware or updates can change it. Three single-input variations follow: a new seed, a reworded slower push, and a shorter clip. The new seed loses the warm window light and is rejected. The other two pass. Each has a sidecar naming its parent and the one change. The rejected take is kept and marked.

Where it runs and what it costs

Graphics memory sets the limit at home: about 24 GB suits the 14B model, 16 GB needs a quantized version, and 8 GB points to the 5B hybrid template. Hosted routes are Comfy Cloud, RunPod and the Runway API, whose pricing guide gives per-second credits. The cost figures come from conflicting sources and cover compute only, so compare cost per accepted clip.


Rebuilding the name plate shot as a saved graph

This chapter asks whether a shot you already know can be rebuilt in an open tool, so that it reruns when you ask and makes controlled variations. Mostly, yes. ComfyUI saves every setting of a render inside the file it produces. A fixed seed usually repeats a render on the same machine with the same software. ComfyUI makes no official promise that a fixed seed gives identical output, though, so the accepted file in your shot folder stays the master. That rule from last time still holds.

So far the course has used Runway for generation and Shotcut for editing. This step adds a second way to generate, one you can save, rerun and later run without a person clicking each button. The coming lessons on unattended batches depend on it. Everything below is an illustrative walkthrough on the show's courier project. It describes what you would do. It is not a record of work you have done.

Here's the case. In the show's courier project, the name plate insert, shot nine, has an accepted v002 made in Runway after the note asking for brass. Its shot folder holds the References still that began it and a sidecar with the motion prompt. The question is whether ComfyUI can rebuild that shot from the same inputs, and getting there takes some setup first.

First, get ComfyUI. ComfyUI is a free program that builds a generation as a node graph. A node is one box on a canvas that does one job, such as loading a model, holding your prompt or saving a video. Wires connect the boxes, and the whole picture of boxes and wires is the workflow. There are four ways to get it. ComfyUI Desktop is the stable choice and the one to pick if you are unsure. The portable build runs on Windows only and follows the latest code changes, so it gets new features sooner and breaks more often. A manual install suits people comfortable with Python, and Python 3.13 is recommended. Comfy Cloud is the hosted option. It runs in a browser with the models already installed. It only allows custom nodes that Comfy maintains, and it runs one workflow at a time.

Next, find the template. Open the Template Library inside ComfyUI and search for the Wan 2.2 fourteen-billion image-to-video template. Wan 2.2 is an open video model, and fourteen billion is the size of the version this template uses. The template needs an up-to-date ComfyUI, so update before you load it.

On Desktop the template needs model files you download yourself. On Comfy Cloud they are already there. The files come from the Comfy-Org Wan 2.2 repackaged repository, and each goes into a named folder inside ComfyUI's models folder. Two of them are diffusion models, one called high noise and one called low noise, and both go in the diffusion models folder. The model works in two stages. The high-noise model shapes the rough motion and layout from heavy noise. The low-noise model then refines the detail. Third is the Wan 2.1 VAE, which goes in the vae folder. A VAE translates between finished pixels and the compressed form the model works in. It encodes your start image going in and decodes the frames coming out. Fourth is the umt5 text encoder, which goes in the text encoders folder. It turns your written prompt into numbers the model can follow.

Each of those files gets its own loader node on the canvas. There are two diffusion model loaders, one for high noise and one for low noise, plus a loader for the text encoder, which ComfyUI calls a CLIP loader, and a VAE loader. Click each loader and check which file it actually points to. In places the official documentation names text-to-video fp8 files rather than the image-to-video ones. A loader pointing at the wrong file can still run and give you a clip that ignores your start image, so this check is not optional.

With the loaders checked, go back to shot nine.

The steps run in this order:

  1. Load the template and confirm the four loaders as described above.
  2. In the image node, upload sh09 v002's References still as the start image.
  3. Paste the motion prompt from the sidecar into the positive prompt node. Keep the production bible's lighting words, because shot nine lost its light once before when they were missing. The negative prompt node holds what you don't want, and the template's default is a reasonable start.
  4. If you want a different length, change the frame length in the node called EmptyHunyuanLatentVideo. That node sets up the blank space of frames, at your width and height, that the model fills. More frames means a longer clip and a longer render.
  5. Run the workflow and watch the result play.

The template also contains a sampler node, which does the step-by-step generating and holds the seed, and a node that saves the video. Their exact names and settings can change between template versions, so look at them in the copy you load. Find the seed field and set it to fixed rather than randomize after each run. Otherwise every run gets a new seed and nothing repeats.

In the illustration, the first render shows the brass plate with window glow from screen right, as the bible requires, and the slow push matches the motion prompt. It passes. That clip gets saved into shot nine's folder under the existing naming pattern, with its own sidecar giving ComfyUI as the tool, the template name, all four model file names, the seed, the frame length and the start image file. It counts as a new source generation for the shot. The accepted Runway take stays the master in the cut until you decide otherwise.

Here is the part Runway didn't give you. ComfyUI writes the workflow into the output file. A PNG image carries it in text chunks inside the file. A WebP image carries it in its EXIF data. An MP4 or WebM video carries it in the container's tags. Two fields matter. The field called workflow rebuilds the canvas, every node, wire and setting. The field called prompt holds the same graph in the form ComfyUI's programming interface uses, which matters once scripts start running jobs. To restore a render, drag the output file onto the ComfyUI canvas and the whole graph comes back with your prompt and seed in place.

Know where that stops. If ComfyUI is started with its disable-metadata option, nothing is embedded. Re-encoding the file can strip it, and that includes passing the clip through an editor export or an upload service. So keep the raw output in the shot folder, not only the edited version. The metadata never includes the model files or the input images. It records their names, not the files, which is why the sidecar and the shot folder still hold the start image. And treat metadata in a file someone else sent you as untrusted. A dragged-in graph can point at nodes or settings you didn't choose, so read it before you run it.

Then the rerun test. With the seed still fixed and nothing else changed, run again. In the illustration, the second render matches the first and passes. That is the expected result on the same machine with the same drivers, PyTorch, ComfyUI version and model files, but it is likely, not guaranteed. Move to a different graphics card, or update any of those pieces, and the same seed can give a different clip. That is the reason the accepted file is never overwritten.

Now make variations. Each one changes a single input, so if it fails you know what caused it. Variation one changes only the seed. Variation two changes only the prompt wording, describing a slightly slower push with the bible's lighting words untouched. Variation three changes only the frame length in EmptyHunyuanLatentVideo, making a shorter clip for a tighter cut.

Judge each one against the production bible, not against how pretty it looks alone. In the illustration, the new seed drifts. The glow slides toward frame centre and the plate goes flat and cool, which breaks the warm window light from screen right that every neighbouring shot carries. It is rejected. The reworded slower push and the shorter clip both hold the light and the plate, and both pass. All three get sidecars naming their parent render and the one input that changed. The rejected take is kept and marked, because its render time counts toward the cost of each accepted shot just as Runway credits did.

Now try it on something of your own. Pick one still you made. Load the Wan 2.2 image-to-video template in ComfyUI Desktop or Comfy Cloud, check the four loaders, upload your still, write a short motion prompt, fix the seed and render a short clip. Then drag the output file back onto the canvas. It has worked when the graph reappears with your prompt and seed, a same-seed rerun looks like the first render, and you can say which single input you would change for your first variation.

That leaves the question of where the graph runs, which decides what each accepted clip costs. On a computer of your own, the graphics card's memory, called VRAM, sets the limit. About twenty-four gigabytes is a comfortable target for the fourteen-billion Wan 2.2 model. Sixteen gigabytes needs a quantized version, a smaller compressed copy of the model that trades some quality for space. If your card has eight gigabytes, the smaller Wan 2.2 five-billion hybrid template should fit using ComfyUI's native offloading, which moves parts of the model out of graphics memory while it works. For comparison, the LTX-2 model needs roughly thirty-two gigabytes in its full BF16 form and about sixteen in FP8. Render times on home hardware vary widely and the reports are anecdotal, so time your own first render.

Without a big card, there are three hosted routes. Comfy Cloud bills from a subscription credit pool, and charges GPU use per second of active runtime, so idle time on the canvas costs nothing. Its published hourly rates for top cards conflict, so check the pricing page before you plan around a figure. RunPod rents a machine by the hour and is the cheapest. One snapshot put an RTX 4090 at about thirty-four cents an hour, but rates vary by tier and date, and you install ComfyUI and download the models yourself, plus pay for storage. The Runway API, the route the course used before, charges per second generated, as of November 2026 twelve credits a second on Gen-4.5 and five on Gen-4 Turbo. You pay for every second whether you keep the clip or not, and only Runway's own closed models are available.

One rough estimate puts a ten-second clip at about a dollar twenty on Gen-4.5 or fifty cents on Gen-4 Turbo, against roughly two to ten cents of compute on a rented 4090-class card. That gap looks large, but treat it carefully. The figures come from conflicting sources, they price compute alone, and they leave out your setup time, storage, failed installs and the rejected takes. In the name plate illustration one of three variations was rejected, so every accepted clip carries half of a rejected render's cost on top of its own. Comparing cost per accepted clip, not cost per render, keeps that honest on every route.

The courier project now has a saved graph that rebuilds shot nine, reruns it from one dragged file and makes variations, each with a record. A graph you can rerun by hand can also be run by a script with nobody at the screen. Running a batch that way, with cost limits and a check on each result, is the job that comes next.

Want a book of your own?

Gnothi wrote and narrated this chapter. Name a subject and it writes you a course, or a story that teaches it, one chapter at a time, delivered to your podcast app.

Get started free