The Video Lab Handbook

How we test video models, how we make video with them, and what we won't do. This is the reference. If you want the story of how the method came together, read How we test video models: the Video Lab method. This page is the version you keep open while you work.

Last updated: Nov 2 2026. Numbers come from the Nov 2 test run on one NVIDIA DGX Spark unless a line says "Nov 1" (the lab's earlier baseline run). Where something hasn't been measured yet, it says "not measured yet." This page gets updated as results land.

What the Video Lab is

The Video Lab is where we figure out how to make the best video we can with what we actually have: one desktop GPU box, open-weights models, a voice API and a code-based video editor. Every post on the Video Lab is a test or a technique, and every one ships with four things:

1. A short film: a finished 30-90 second example of what the technique makes.
2. An instructional video hosted on camera by one of our AI hosts, teaching you how to do it.
3. Narration of the article, read by an AI voice.
4. An interactive player on the page (a comparison, a scorecard, a little lab you can click around in).

The setup:

• Hardware: one NVIDIA DGX Spark. GB10 chip, about 121 GB of unified memory shared by the GPU, the CPU and everything else running on the box.
• Video and image models: open weights, run locally in ComfyUI. LTX 2.5, Wan 2.2, InfiniteTalk, SeedVR2, RIFE and FILM for video; Z-Image Turbo and FLUX.2 klein 4B for stills.
• Voices: ElevenLabs, with word-level timestamps.
• Editing and graphics: Remotion (video as React code) for titles, captions, diagrams, comparisons and the final cut.
• Hosts: a recurring cast of ten AI-generated characters, each with an AI voice. They're labeled as AI on screen every time.

Three ideas decide almost every choice on this page:

1. Memory is the hard limit, not speed. On unified memory, running out doesn't crash a process. It freezes the whole box. So heavy jobs run one at a time, always.
2. Never ask a video model to write. Text, numbers, diagrams, UI and captions are built in code. The video model makes people, objects and motion.
3. Measure it or say you didn't. If a number isn't in a log, it isn't on this site.

How we test

The short version: a fixed set of prompts, fixed seeds, fixed sizes, the same measurements on every run, and a written rubric scored from frames. Comparisons only between identical setups.

The prompt suite

Ten prompts. Each one is built to stress one specific thing a video model can get wrong:

Each prompt has two texts: a motion prompt for text-to-video and image-to-video, and a still prompt for the source image. Every image-to-video test starts from the same pixels: the Z-Image Turbo render of that still prompt at seed 42.

Prompts are frozen once tests run against them. A new idea gets a new id (P11 and up exist for later posts). Nobody quietly edits P06 and keeps comparing.

Seeds and sizes

• Seeds: 42 and 1234, for every prompt on every model. Same prompt, different seed, different clip, sometimes very different. Two seeds make that variance visible.
• Clip length: 5 seconds. That's 121 frames at 24 fps for LTX 2.5 and 81 frames at 16 fps for Wan 2.2. It's the shot length our edits actually use, both models do it natively, and it keeps a full sweep affordable on one GPU. Drift over long takes is its own test.
• Fixed sizes per model family:

Honest status: on Nov 2 only the seed-42 sweep ran. The seed-1234 repeats were parked to make room for host renders. So every family comparison on this page is single-seed, and it says so.

What gets measured on every run

Every test writes the same files: the exact settings, the timing, the outputs, a contact sheet and a written verdict. These are the numbers, and where each one comes from:

Two things worth knowing:

• Cold vs warm matters a lot. The first LTX text-to-video test after the stills (test 011) took 21.4 s/s because it included loading the model. The next one on the warm model (test 012) took 14.9 s/s. Same settings. Quote the cold number as "LTX speed" and you're 44 percent off. Speed claims on this page say warm or cold.
• Memory figures are GiB (the unit the system reports), written GB here. On the GB10, nvidia-smi reports memory as N/A, so free system memory is the only real gauge.

Wall times are for this box with whatever else was loaded at the time (a voice model, a second ComfyUI server, other work). They compare fairly with each other inside a run, not with a clean machine.

The rubric

Seven criteria, scored 1 to 5, whole numbers only. Each criterion has written anchors at 1, 3 and 5, so two reviewers looking at the same frames should land on the same score. A score without an anchor is just a mood.

The rules that go with it:

• If the frames can't tell you, the note says so. No defaulting to a 3.
• Lip-sync and audio are scored only on lip-sync tests. Everywhere else they're N/A.
• Text counts under artifacts only when the prompt asks for text. Text nobody asked for (an invented logo, say) is an artifact and a prompt miss.
• A failed run gets no scores, just the error.

Who scores: an AI reviewer (Claude Opus 5.5) looking at the frame sheets below, writing one line per score that says what it saw, with the frame time. The reviewer scores one test at a time and never picks winners. Comparisons are made later, by the rules further down.

Contact sheets

Every clip gets a contact sheet: 12 frames spread evenly across it at 480 px, about one every 0.45 seconds on a 5 second clip. The reviewer scores from that and grabs extra frames whenever something needs a closer look.

Identity strips

To check drift, we take 8 evenly spaced frames (first and last included), crop the center 60 percent, and lay them in one row. Compare the first and last cells, then look for the frame where a change starts. The call is none, slight or clear, plus what changed: skin tone, hair, outfit, background, eye size. "Clear" caps temporal consistency at 2.

Consistency isn't correctness. Test 016 (LTX 2.5 text-to-video on P06) spelled the sign "VIDDEO LAB" in all 12 sampled frames. Drift: none. It was perfectly stable and perfectly wrong. That's why they're separate columns.

Counting lip-sync on frames

A talking head that moves its mouth looks synced at normal speed. The real question is whether the mouth closes when the speech stops and opens when there's speech. So we count, using the narration's word timestamps from ElevenLabs:

1. Where a word ends: at its last letter or digit. (ElevenLabs hangs the silence after a sentence on the punctuation, so if you use the punctuation's end time, the pause disappears.)
2. A pause is any gap longer than 0.35 s between one word's end and the next word's start. Pull the frame at the midpoint of each pause. The mouth should be closed.
3. A speech point is the midpoint of every 4th word. The mouth should be open or visibly moving.
4. Lay the pause frames on one row and the speech frames on another, cropped to the face, with every sampled time written to a file so anyone can check the count.
5. Report it as fractions: "closed at 5/6 pauses, open at 7/8 speech points." The lead-in and the tail are sampled but reported separately; the headline fraction leaves out the tail.

The 1-5 score follows from the fractions: both at or above 0.9 is a 5; both at or above 0.6 with one miss is a 3; worse is a 1 or 2. Those thresholds are a convention we picked, not a law of nature. The fractions are the real number.

A counting rule for edge cases: lips touching or a closed line counts as closed. A slightly parted, relaxed mouth at a pause counts as closed on a cartoon and open on a photoreal face. A smile with parted lips is open.

The gate: for a host take to pass, the mouth has to be closed at 4 of 6 sampled pauses (two thirds) or better.

One timing gotcha: on ElevenLabs eleven_v3, the timestamp for the word after a pause starts a median 346 ms before the voice actually comes back (40 pauses across 5 clips; eleven_v4 was within 37 ms). That shortens every measured pause and pulls its midpoint early. We snap word starts to the real end of the silence (ffmpeg's silencedetect) before counting or captioning. Details in Captions that land on the word.

Comparison rules

• Same prompt, same seed, or it isn't a comparison. P01 seed 42 on LTX against P01 seed 42 on Wan is a comparison. P01 against P02 is two different tests.
• Model A beats model B on a criterion only when both of A's seeds beat both of B's. If the seeds disagree, it's "mixed" and both get quoted. While only one seed exists, a claim says "seed 42 only."
• A one-point gap is noise unless both seeds agree.
• Speed claims quote s/s with the test id and say warm or cold.
• 720p compares with 720p. 1080p is its own column.
• Scores get quoted with their source: "scored 5/5 on motion by the reviewer (test 027)," never a bare number.
• Never compare across prompts, across clip lengths, or against the Nov 1 clips (different prompts, approximate timestamps).

How we make video

Which tool for which job

Speed is seconds of compute per second of finished video (s/s): wall time divided by output length. Lower is faster. "Memory floor" is the lowest free memory seen on the box during the job, which includes everything else that was running, not just the model. Scores are the rubric above, seed 42 only, averaged across the tests named.

What the table says, in plain terms:

• B-roll is LTX 2.5 image-to-video from a Z-Image still. It beat text-to-video on every rubric line (overall 3.9 vs 3.1 over the same ten prompts, seed 42 only) at about the same cost, because the still pins down identity, color and any text. Same prompt, same seed: text-to-video misspelled the neon sign in 12 of 12 frames (test 016); image-to-video from a correctly spelled still kept it right (test 026). Text-to-video is for when there's no still and the shot doesn't matter much.
• The talking host is LTX 2.5 image+audio at about 17 s/s, and its lips are loose at pauses. InfiniteTalk was better on Nov 1 at about four times the cost. That cost is why each instructional gets at most 60 seconds of on-camera speech.
• Remotion is cheap and exact, and it eats memory if you let it run wide. It got every on-screen word right where LTX got less than half. It renders faster than real time, but it's not free: it's CPU and memory, on the same pool the GPU uses.

Known LTX 2.5 habits from our verdicts: it invents brand marks (an Apple-style logo on test 018, a swoosh on test 024), it gives a kickflip about 1.8 seconds of hang time (024), and it didn't orbit the camera on P03 in either mode (013, 023). Put "text, letters, logo, watermark" in the negative prompt and keep hands out of focus. Fair warning: at CFG 1.0 the negative prompt may do nothing at all (workflow templates issue #919). We have a test for that queued; not measured yet.

The rule of thumb, from Animated HTML vs generative video: if the shot has to say something exactly, build it in code. If it has to feel like something, generate it.

House recipes

Talking host segment

1. Start from the host's on-set still, not a fresh portrait. Face at least a quarter of the frame height, mouth neutral. We tested the alternatives: a tight mouth-closed portrait closed the mouth no more often (0 of 6 pauses), and the model pulled the camera back mid-take to show the host's shirt.
2. Write lines in the host's own personality, short sentences, 20 seconds or less per take. Keep numbers out of on-camera lines; put them on a panel where viewers can read them.
3. Voice it with the host's ElevenLabs voice on eleven_v4 at the cast settings. Use eleven_v3 with "..." only where you need a real silence to cut on.
4. Render it with LTX 2.5 image+audio at 1280x704, one seed. A second seed rarely rescues a take, and it costs about 15 minutes of GPU per post. (Posts that are about lip-sync use two.)
5. Count it on frames (pauses closed, speech points open) and write the count down.
6. Edit around the weakness: wherever the voice pauses longer than about 0.5 seconds, cut away to a panel, b-roll or the other host instead of holding on the face. If a take still misses the gate, the page says so: "sync is loose at pauses."
7. Composite with a nameplate that says "AI host" in type big enough to read, and captions on a fixed baseline at the bottom.

Budget: about 17-18 minutes of GPU for 60 seconds of on-camera speech.

B-roll shot

1. One beat per shot, 4-5 seconds. Write the voice-over first, then time the shots to it.
2. Still: Z-Image Turbo at 1344x768, with one shared style line in every prompt so the shots match.
3. Motion: LTX 2.5 image-to-video, 1280x704, 121 frames. Prompt: subject, one action, one camera move, the light. Two seeds; pick from the contact sheets.
4. If LTX breaks the shot, take Wan 2.2 image-to-video, then RIFE 2x to get from 16 fps to 32.
5. LTX writes its own ambient audio track. Keep it as a bed or mute it.

Cost: about 80 seconds of GPU per 5 second shot.

Explainer panel (no generation)

For anything that's text, numbers, a process, a UI or a comparison. CPU only, about 7 seconds of render per 5 seconds of 1080p.

• Panels with a title, bullets, a simple node-and-arrow diagram, a terminal window or a cropped screenshot.
• Side-by-side clip grids (2x1, 2x2) for comparisons.
• Title cards, lower thirds, captions.
• The same compositions can be built as an interactive player for the page, one self-contained HTML file under 6 MB.

Short film (30-90 seconds)

1. A shot list of 8-12 shots from the post's topic.
2. Stills (Z-Image Turbo, FLUX.2 klein 4B as the alternate), then LTX 2.5 image-to-video per shot, two seeds on character shots, Wan on hero shots when LTX misbehaves, SeedVR2 3B on the chosen hero takes if they need it, always in chunks.
3. One AI-generated instrumental music bed per post, loudness-normalized, credited in the caption. Re-renders reuse it.
4. Cut in Remotion: shots, captions on a scrim, title card, end card, crossfades.

Measured: a 36.8 second film cut in 49-94 seconds of wall time. The GPU side of a full 12-shot film from scratch: not measured yet.

Instructional (2-4 minutes, hosted)

1. Script in two kinds of blocks: host (on camera) and voice-over (the host's voice under a panel).
2. At most 60 seconds of on-camera host speech, in 3-4 takes of 20 seconds or less: an intro, one or two bridges, an outro. Everything else is voice-over under Remotion panels, which costs no GPU.
3. Order: title card, host intro, explainer and comparison panels with voice-over, host bridges, host outro.
4. If the host takes miss the lip-sync gate and are already rendered, we don't burn GPU re-rendering them. The caption says "sync is loose at pauses."

Measured: a 197 second instructional with 59.5 seconds on camera rendered in 254-309 seconds of CPU wall time, 36.3 MB.

Article narration

1. A narration script written for the ear, not the eye. Tables become "see the table on the page."
2. Voiced in chunks of 4,500 characters or less, joined into one mp3.
3. Measured: 363 seconds of narration voiced in 89 seconds of wall time.
4. Re-renders reuse the existing audio when the script hasn't changed, so we don't pay for the same voice twice.

From post to YouTube

One post in, a published Video Lab page and a YouTube-ready package out. The full walkthrough is in From post to YouTube: the LEJ video pipeline. The stages and what they cost:

Steady state on Nov 2: about 30-40 minutes from the last host render finishing to the page going live. The host GPU job and the queue in front of it dominate the clock, not the edit.

The YouTube package for each post contains:

• The video: H.264 High, quality-targeted (CRF 18) and capped at YouTube's recommended 8 Mbps for 1080p at 24-30 fps, AAC 48 kHz audio, limited-range BT.709 color, fast-start. YouTube gets a full-quality master, not the smaller copy on the site.
• Loudness: two-pass normalization to -14 LUFS. That target is a platform convention measured by third parties, not a published YouTube spec. (Our Remotion output came in at -17.4 LUFS before it.)
• Captions: an .srt built from the same word timestamps as the on-screen captions, offset per block, so they always match the cut. The packager refuses to build if the edit and the video length disagree.
• Chapters: first at 0:00, at least three, each at least 10 seconds long, per YouTube's rules. Otherwise they're left out with a warning.
• Thumbnail: 1280x720, picked by a person (or a reviewer) from a sheet of candidates. The automatic pick landed mid-blink once, and 2 of the first 3 production auto-picks got replaced.
• Title, description (with the AI-host disclosure and a link back to the post), tags.

Not done yet: an actual YouTube upload. Until then, how YouTube treats our color tags, chapters and captions is not measured.

Quality gates

Nothing publishes until all of these pass.

1. Someone looks at the frames

A contact sheet of every video: faces, hands, mouths, text, black frames. Identity strips and lip-sync counts for every host take. Before a motion score gets quoted in a post, a denser frame grab (6 frames per second), because a 12-frame sheet can miss a 3-frame glitch.

2. Automated checks

A script checks every post against the site's own schema and checks the media. It fails the post on:

• video not H.264, no audio, films and instructionals not 16:9 at 1920x1080 or 1280x720, no fast-start, decode errors, any video over 45 MB;
• narration whose real length is more than 1.5 s off what the page says, or that doesn't decode to the end;
• a player that isn't one self-contained HTML file under 6 MB;
• any leftover placeholder, any em dash, any private file path, any missing file or poster;
• after publishing: the page must answer 200 with its title, and every media URL must answer 200.

It also enforces the rating rules (below).

3. The lip-sync gate

Closed at 4 of 6 sampled pauses or better, counted as described above. Takes that miss it are either cut around in the edit or disclosed on the page. Usually both.

4. An independent editor

After the automated checks pass, a separate AI editor that didn't write the post reads all of it like a skeptical fact-checker. It works from a written brief, in this order:

1. Leftovers: placeholders, template variables, "TODO," anywhere in the page, captions, on-screen cards, voice lines or narration.
2. Every number, in the article, captions, cards and narration: verified, wrong or unsupported, against the test files and logs. Units get special attention.
3. Consistency: the film, the instructional, the narration and the article say the same thing. No video asserting a cause the article calls unproven. No claim that a later test made stale.
4. The media: frame grabs of every video for typos, cut-off text, wrong numbers on cards, captions over faces, black or frozen frames, any third-party logo a model invented, and honesty about host sync. Narration plays its full length.
5. Voice and readability: jargon without a plain explanation, sentences over about 30 words, anything that oversells. AI hosts and voices are marked as AI.
6. Ratings and privacy.

It writes must-fix, should-fix and nice-to-have lists. Every must-fix gets fixed, the automated checks run again, then the post publishes.

Why this exists: the first post of the run passed both automated checks and still went live with five real errors. A literal template variable printed in seven table cells. A unit mix-up (ComfyUI's "MB" is really MiB; dividing by 1,000 and comparing with free memory in GiB made a 37.6 GiB server read as 38.5). A claim a later restart had made wrong. A wrong port number in a diagram. And a video caption asserting a cause the article itself said was unproven. The editor found must-fixes on every one of the first six posts: 5, 4, 9, 5, 5 and 5. Scripts check that the parts are there. It takes a reader to check that they're right.

5. Ratings

Every post and every clip gets a rating: G, PG, PG-13 or R, plus plain-language content descriptors like "violence," "intimacy (suggestive)," "drug use," "alcohol," "language" or "crime scene."

• Every clip and player carries its own rating. In a PG-13 or R post, an unmarked clip fails the check; the post's rating doesn't cover it.
• Anything above G gets a short note saying what's in it.
• PG-13 and R clips sit behind a tap-to-view cover that says what's in them, so you can skip what you'd rather not see.
• Every post has at least one G or PG clip for the index card. An R clip is never the thumbnail.
• When in doubt, we rate higher.

6. No borrowed logos

Video models make up brand marks: an Apple-style logo on a laptop, a swoosh on a shirt. Before anything publishes, frames get checked for recognizable logos or trademarks, and the clip gets cropped, blurred or swapped. If the failure is instructive, the post names it without showing the mark.

What we don't do

• No real people. Every face in the Video Lab is an AI-generated character. No celebrities, no lookalikes, no real person's face, including mine. Any clip that comes out looking like a real, identifiable person gets held back.
• AI is always labeled. Hosts say "AI host" on screen, voices are credited as AI voices, and every clip is disclosed as machine-generated. (The LTX-2 license requires that disclosure anyway. We'd do it regardless.)
• Our hosts don't flirt or call you pet names. Each has a character (playful, warm, calm, dry), and none of them is flirty. Scripts get checked for pet names before any voice is rendered, and a line that slips through gets rewritten and re-voiced.
• Nothing beyond an R rating, ever. We do test where models draw lines on mature themes (true crime, violence, intimacy, drugs), because people make that kind of content. The hard limits: no nudity of genitals and no explicit sex acts; nothing sexual or intimate involving anyone who looks under 21 (our cast are all fictional adults aged 21-29, written to read clearly as adults); no real or identifiable people; no gore past R (aftermath and implication, not graphic wounds).

• We only publish what a model's license allows. Some models we can run but can't publish from:

  • FLUX.2 dev: non-commercial license. Never published.
  • MiniMax-H3: its license doesn't permit our use. We may test it; we never publish its output.
  • A research-only identity LoRA for LTX 2.3: research-only. Not published.
  • LTX 2.5 is fine for us under the LTX-2 Community License (free for companies under $10M in annual revenue).
• We don't quote numbers we didn't measure. Unknown is "not measured yet." Old baselines are labeled with their date.
• We don't run two heavy jobs at once. One queue, one lock. Covered next.

Running it on one box without freezing it

Everything in this section exists because something went wrong. The full story is in Running video gen in 128 GB of unified memory.

• One heavy job at a time. Every render goes through a single queue that takes a lock, so two jobs never overlap (and wall times aren't polluted by a neighbor). Jobs are batched by model family to avoid reloads.
• Before a job, tell the other ComfyUI server to unload its models. We run two: one for LTX and the image models, one for Wan, InfiniteTalk, SeedVR2 and interpolation.
• Unloading isn't a restart. Asking ComfyUI to free memory unloads models from the GPU side, but the process keeps its host RAM. An idle server sat at 14.2 GB. "Free" gave back 4 GB; a restart gave back about 17. So the queue now restarts an idle server automatically when it's holding more than 6 GB. Before that fix, host renders bottomed out at 8 GB free, which is too close. After it: 12-34 GB.
• Leave headroom. More than 15 GB free before a Wan 14B job. SeedVR2 always runs in chunks; unchunked, one 12 second clip took the box to zero.
• CPU work shares the same memory. At 10 parallel browser processes, Remotion held 8 GB of RAM while an LTX job ran, and free memory fell from 21 to 13 GB over four tests. One render's video-frame cache alone grabbed 12.9 GB (its default is half of free memory). So Remotion renders take their own lock, wait for more than 20 GB free, run 6 processes, and cap that cache at 2 GB.

Known limits

These are real, measured, and every post that leans on them carries them.

• Host lips at pauses. LTX 2.5 image+audio opens the mouth on speech almost every time and closes it at pauses about 1 time in 3. In a controlled test on our lead host, one window, nine renders, changing one thing at a time: closed at 6 of 51 pauses, open at 90 of 90 speech points. Voice model, seed, a "lips close at every pause" prompt and a different reference image didn't move it. It also splits by host: every take that passed the gate so far was one of our two calmer hosts. Our fix is editorial (cut away at pauses, disclose the rest). InfiniteTalk is the last lever, and it's in the test queue.
• eleven_v4 can't really pause. It caps sentence-end pauses near 0.55 seconds and ignores both "..." and break tags. eleven_v3 honors "..." (1.1-1.8 s); multilingual v2 honors a break tag (1.32 s for a 1.0 s request).
• Video models can't write and do make up logos. Text comes from Remotion. Negative prompts may be inert at CFG 1.0.
• LTX audio isn't sound design. Its generated audio adds voices even when the prompt says no voices.
• No re-sync of existing footage on stock nodes yet.
• Local models don't refuse, they drift. We ran 54 stills up graded intimacy, violence and drug ladders to an R ceiling. Zero refusals, zero filters. Z-Image escalated past the prompt (sheerer fabric, a second gun, more blood than asked) and sometimes mixed up who was who; FLUX.2 klein followed coverage and lighting cues best and softened injuries and intoxication. ElevenLabs read 6 of 6 mature script lines as written. With local models, the control is the prompt and the reviewer, not the model.
• Frames, not motion. The reviewer scores frame sheets. Flicker and short glitches can fall between samples.
• One reviewer, one seed. Each test is scored once, by an AI reviewer, and the Nov 2 suite has only seed 42. Two counts of the same lip-sync sheet once came out a point or two apart. Inter-rater agreement hasn't been measured yet.
• The scores are a convention. Anchored, repeatable, useful. Not physics.
• Wall times are this box, that day, with other things loaded. Compare within a run.
• Music rights. Our music beds are AI-generated with ElevenLabs Music. Whether our plan covers commercial use is being confirmed; if it doesn't, we switch to synthesized beds and re-cut.

What we're still testing

Each of these has a test queued. When it lands, this page changes.

1. Wan 2.2 vs LTX 2.5 image-to-video on the same ten prompts and seeds.
2. InfiniteTalk on our cast at today's settings, and whether it's worth four times the GPU for an intro.
3. LTX 2.5 at 1080p: how much better, at what cost.
4. Wan 2.2 S2V without the Lightning LoRA (20 steps): does it become usable?
5. SeedVR2 3B vs 7B on our clips. (The SeedVR2 paper's own user study preferred the 3B.)
6. RIFE vs FILM on Wan clips.
7. Long takes: chaining 20 second windows vs cutting per sentence.
8. How low LTX image strength can go before a host drifts off-model.
9. Whether the negative prompt does anything at CFG 1.0.
10. A real YouTube upload of a package.

Terms used on this page

• s/s: seconds of compute per second of finished video. 16 s/s means a 5 second clip takes 80 seconds.
• Warm / cold: whether the model was already loaded. Cold runs include the load.
• Memory floor: the lowest free memory on the box during a job, in GiB (written GB).
• Gate: the pass line for host lip-sync, closed at 4 of 6 sampled pauses.
• Seed 42 only: a result from one seed, which can't yet pass our two-seed rule for comparisons.

More terms in the Video Lab glossary.