The setup below targets ComfyUI on a 12GB GPU with the fp8 distilled checkpoint, and it covers the parts that trip people up: seed handling, image-to-video conditioning, and how to queue twenty variations without babysitting the machine.

Why lock the workflow instead of prompting fresh each time?

Video models are sensitive. Change the seed and the lighting flips. Change CFG and motion speed drifts. A fixed graph removes those variables so the only thing moving between renders is your subject.

That matters for LTX-Video specifically because the base and distilled checkpoints behave differently — a workflow tuned for one will look muddy on the other if you forget the step count.

What does the node graph look like?

Six core nodes carry the whole thing.

• Checkpoint Loader — points at the fp8 distilled file.
• CLIP Text Encode — positive prompt, and a separate negative you never blank out.
• Empty Latent Video — sets width, height, length (frames), and batch size.
• KSampler — 8 steps, CFG 3, euler sampler for the distilled build.
• VAE Decode — pipes latents to pixels.
• Video Combine — writes the MP4 and frame rate.

Wire them in that order and you have a working graph. The negative prompt is worth real effort here: “blurry, warped limbs, text overlay, flicker” removes a chunk of the artifacts people blame on the model.

How do you keep motion consistent across a batch?

Fixed seed plus one changed variable is the rule. Set batch size to 4 in Empty Latent Video, keep the seed static, and vary nothing but the prompt. You get four takes that share lighting and camera feel.

If you are turning a still into motion, feed it through an image-to-video conditioning node and keep the strength between 0.6 and 0.8. Below 0.6 the clip ignores your prompt; above 0.8 the source image barely moves.

How do you queue many clips unattended?

ComfyUI has a queue that keeps running after you close the browser tab, as long as the server process stays up. Load the API-format workflow, then script the prompt swaps with curl against the /prompt endpoint. Each job drops its MP4 into the output folder named by node and counter.

Watch VRAM. Four queued 121-frame jobs at 768×512 fit on 12GB; bumping to 1216×704 will push you into a card that has 24GB or into sequential offload that slows render times to minutes per clip.

Which mistakes waste the most time?

Who should bother with the workflow route?

If you render one clip a month, the default example graph is fine. This pays off when you need 20 clips that match, or when you are handing the graph to an editor who should not be touching sampler settings. Skip it if your GPU has under 12GB and you refuse to use quantized weights — you will fight out-of-memory errors more than you create.

Quick Summary

• A fixed LTX-Video ComfyUI graph keeps lighting and camera stable across a batch of clips.
• Six nodes do the work: checkpoint, text encode, empty latent, KSampler, VAE decode, video combine.
• Use 8 steps and CFG 3 on distilled weights; 20-30 steps on the base model.
• Batch size 4 with a locked seed plus image-to-video strength of 0.6-0.8 gives consistent variations.

This guide walks through the practical setup on a machine with an RTX 3060 12GB, the settings that actually change output quality, and where LTX-Video stops being the right choice.

What is LTX-Video?

LTX-Video is a latent diffusion transformer that outputs video frames directly. Unlike older pipelines that generate frames one at a time and stutter, it denoises the whole clip together, which keeps motion coherent across the sequence.

The base model handles 768×512 at around 24-30 fps for a few seconds. There is a 0.9.x line with distilled variants that cut steps down to 8, so a 5-second clip can finish in under a minute on a mid-range card.

Is LTX-Video free to run?

Yes, the weights are open. You download them once and generate as much as your GPU allows. There is no per-second billing on the local route.

If you skip local hardware, hosted endpoints charge per second of video. Expect roughly $0.10 to $0.30 per generated 5-second clip depending on resolution. For anything past a few test clips a day, local is cheaper after the first month.

How do you install LTX-Video?

The fastest path on Windows or Linux is the ComfyUI node. Two steps get you to a working graph.

1. Clone the LTX-Video ComfyUI nodes into your custom_nodes folder and restart ComfyUI.
2. Drop the model checkpoint into models/checkpoints (the distilled fp8 file is about 8 GB).
3. Load the example workflow, replace the text field with your prompt, and set frames to 121 (roughly 5 seconds at 24 fps).
4. Click Queue. First run downloads the text encoder if it is missing.

For a pure Python route, install the inference package and run the bundled CLI script. It expects a CUDA 12.x build and about 16 GB of VRAM at fp16. On a 12GB card you want the fp8 checkpoint plus sequential CPU offload, which trades maybe 40 percent speed for fitting in memory.

What settings actually matter?

Prompt structure helps more than knobs. Describe subject, action, camera, and lighting in that order. “A red fox trotting through snow, slow dolly-in, overcast light” beats a wall of adjectives.

Where does LTX-Video fall short?

Text rendering inside video is unreliable, so do not plan on captions baked into the footage. Hands and fast lateral motion still smear occasionally. And clips are short by design; stitching five-second segments into a minute-long scene creates visible seams unless you keep the camera locked.

If you need 30-second continuous shots or precise character consistency, a hosted model with longer context is a better fit. LTX-Video shines for b-roll, concept tests, and social loops where a few seconds is the whole deliverable.

Quick Summary

• LTX-Video is an open-weights text-to-video model that generates 2-5 second clips from text.
• It runs locally on 12GB of VRAM with the fp8 checkpoint, or via paid hosted APIs at roughly $0.10-$0.30 per clip.
• Distilled builds need only 8 steps, so short clips render in under a minute on mid-range GPUs.
• It is best for b-roll and concept loops, not long continuous scenes or on-screen text.