AI Video Generation Tools

GPU benchmark: what one consumer card actually finished in AI video

Before buying a card or renting one, the question is narrow: will this hardware finish a local AI video job, and how long will it take. The GPU benchmark ledger answers that from run records rather than from vendor specifications. Every row states the card, the workload, the acceleration stack and the outcome, and failures are kept alongside successes instead of being dropped.

The ledger is generic — it is built to hold any local video model — but today the measured rows come from one bench. MiniMax H3 is the first preset, measured on an RTX 3060 12GB in a Proxmox VM with 16 vCPU, 47.05 GiB of RAM and no swap, running ComfyUI 0.31.0 and PyTorch 2.13.0+cu130 (the test conditions listed on the system RAM page). At 1344×768 for 124 frames the first formal run of each track came in at 2,175.5 s for the FL2VA text-to-video path at 11,023 MiB peak VRAM, 2,373.7 s for FL2VA image-to-video at 11,125 MiB, and 2,581.8 s for Ref2VA reference-to-video at 11,649 MiB — 94.8% of a 12,288 MiB card (the "What this bench measured" section of the GPU page).

Each row carries an evidence grade, and reading the grade first is the point. Measured means this bench ran it. Reported means a first-hand post stated the hardware, and the handle and date stay attached. Estimate means the engine extrapolated from an anchor and says so. The 26 retained run records share one environment line, so a difference between two rows is a difference in the workload, not in the machine.

Which benchmark numbers on this site were actually measured?

The rows graded measured — currently the 26 run records taken on the RTX 3060 12GB bench. Everything else is a community report with its source attached, or an estimate the engine labels as one. There is no averaged figure anywhere: the GPU page publishes both runs of a pair as separate observations, such as the two R2V runs at 2,581.8 s and 2,579.8 s that produced byte-identical output under a fixed seed.

Does the card or the acceleration stack decide the run time?

Within one VRAM class, the stack moves the number further than the model name on the box. On an RTX 4070 12GB the same five-second clip took 64 min 51 s on the base 20-step path, 14 min 33 s with LightX2V 4-step and 5 min 0 s with Fast H3 VSA — a 12.97× spread on one card, wider than the 4.33× between the fastest and slowest consumer card this site has a timing factor for at all (reported by @sep_is_heim, 2026-08-31, cited on the GPU page).

Can an 8GB card finish a job?

There is a detailed community report of an RTX 4060 Ti 8GB completing a 640p five-second job in about 20 minutes cold, or 12 with EasyCache. It used a different model combination than the one measured here, so the VRAM page grades it medium rather than confirmed. The 8GB row on the benchmark is a queued inventory item, not an inference from the 12GB measurements.

System requirements checker: three lights for AI video generation, not a shopping list

Hardware threads answer "will it run" with a number for the graphics card and nothing else. The system requirements checker takes GPU, VRAM, system RAM and CPU, then returns a red, amber or green verdict per resource with the evidence behind each band. It runs in the browser; nothing is uploaded.

The bands are not opinions. They come from a threshold table whose lower bounds were derived from run records and first-hand reports, and the same table is what the site's estimation engine reads — the checker is one implementation of it, the engine another. Pinned memory decides which system-RAM ladder applies, because one report moved a machine two lights by turning it off.

The number that surprises people is system RAM. On this bench peak system RAM reached 43,587 MiB. A 32GB machine has 32,768 MiB in total, a shortfall of about 10.6GB before the operating system takes its share — which is why the AI video model system requirements page leads with memory rather than with the card. MiniMax H3 is the first preset in the model dropdown because it is the one with measured data behind it.

Is 32GB of system RAM enough?

Not for the configuration measured here. Peak system RAM stayed above 43,000 MiB on every run, including a workload that finished in 55.6 seconds, so a 32GB machine cannot hold it at all. The short answer section of the system RAM page states the shortfall as roughly 10.6GB, and swap is not a real substitute.

Does lowering the resolution reduce what the machine needs?

Barely. The same model ran on the same card at a workload roughly 40× smaller — 512×288 for 22 frames against 1344×768 for 124 — and peak system RAM moved by 411 MiB, under 1%, while peak VRAM moved 58 MiB, or 0.5%. Lower resolution buys time, not memory. Two points are not a curve, and the page says so.

How much free disk does a local setup need?

The Ref2VA diffusion model alone is 20,970,379,616 bytes, roughly 19.5 GiB in one file, before the text encoder, VAE, cache, temporary files and outputs. The VRAM page treats 45GB free as the floor and verified that before starting.

ComfyUI workflows for AI video generation: the graphs, frozen and hash-checked

A workflow JSON that changed under you is not a reproducible setup. The ComfyUI workflow downloads page serves copies of the graphs pinned to one upstream revision, each with its byte count and SHA-256 printed next to it, so the file the page describes is the file the button returns.

For the MiniMax H3 preset the official ComfyUI video templates come to six: three that run on your own GPU — text-to-video, image-to-video and reference-to-video — and three that call a hosted API instead. The two families are not mirror images. There is no local first-and-last-frame template and no hosted single-image one, which decides where some jobs can run at all.

These templates ship with the ComfyUI front end, not with the model, so the set can change under you when the front end updates. On 2026-08-13 the upstream repository held 590 JSON templates, 56 of them carrying the local-video prefix, counted from the GitHub Trees API with a complete rather than truncated listing. Once a run succeeds, the copy you save from your own canvas is the more stable artifact to keep.

Which template should a first run use?

Text-to-video when you only have a prompt, image-to-video when one image has to control the composition, reference-to-video when you need a reference person, action, shot or sound. The workflows page states this as a three-line rule and then lists what each graph loads.

What do the local templates cost on a 12GB card?

Two independent runs of each at 1344×768 and 124 frames took 2,175.5 and 2,176.2 seconds for T2V, 2,373.7 and 2,378.1 for I2V, and 2,581.8 and 2,579.8 for R2V. Every run peaked between 10,863 and 11,649 MiB against the card's 12,288, and all six finished between 36 and 43 minutes. The three rows are not a controlled comparison — they were taken seven days apart with audio on for two of them.

Do the sample images ship with the download?

No. Two of the three local graphs open with sample media this site does not redistribute, so every image selection has to be replaced with a local file you are allowed to use before queuing. The workflow templates themselves are MIT-licensed and the notice travels beside them.

Troubleshooting AI video generation: start from the symptom, not from random flags

Most failed runs are diagnosed by pasting an error into a search box and trying whichever launch flag comes back. The ComfyUI troubleshooting guide inverts that: pick the symptom, get the likely area, the first thing to check and the section that covers it, with the original report linked so you can see the environment it came from.

Behind it sits an error and symptom library of 15 seeded entries — six taken from this site's own symptom guide, nine from a first-hand social sweep. Only three carry a paste-matchable error string; the rest describe a symptom in prose and stay reachable through the symptom tree, because pasting a topic word is not a diagnosis. Flag advice attached to an entry is advice, never a match rule.

The five symptoms the guide covers in depth are an out-of-memory error before sampling, per-step time that keeps increasing, a whole-machine freeze, a model the loader cannot find, and an AMD ROCm address-reservation error. Each section ends with the same discipline: save the baseline launch command, locate the stage, change one thing, keep the evidence.

Why does per-step time keep increasing?

One community report on an RTX 4070 Ti 12GB with 64GB of RAM on Windows and ComfyUI 0.30.1 described a GGUF run starting around 18 seconds per step and eventually exceeding 400 seconds per step, which the author associated with DynamicVRAM and a GGUF memory leak. The guide prints the test flags that author used and tells you to revert if the change makes things worse. It is not a universal diagnosis.

An out-of-memory error appeared — which resource ran out?

Note the stage: text encoding, diffusion start, later sampling, VAE decode or model handoff. The stage decides whether a smaller encoder, a different quantisation, cache cleanup, offload or a launch flag is the relevant next test, and whether the failure was VRAM or system memory in the first place.

Do cache nodes fix a slow run?

Sometimes, and you can check. Against a three-run baseline of 597.0 seconds on the 12GB bench, eight cache nodes measured between 1.3× and 1.9× faster, and none of them reduced peak VRAM. A cache node can install cleanly, appear in the menu and do nothing — if a fixed-seed run produces identical video data with the node added, it is loaded but not touching the computation.

VRAM calculator: the AI video number people ask about, not the one that stops them

The VRAM calculator takes a model variant, a quantisation, a text encoder, a resolution and a frame count, and returns a VRAM figure with the evidence grade attached. When no row supports a combination it says so rather than interpolating a number.

The page it sits on argues that video memory is usually not the binding constraint. On this bench VRAM peaked at 11,649 MiB of 12,288 — 639 MiB spare, tight but never once out of memory — while system memory peaked above 43,000 MiB on every run including the 55-second one. Disk came third at a 45GB floor. If you are deciding where to spend money, the VRAM requirements by tier table is the place to look before the card.

That table records one configuration per tier that was reported to work, not a minimum for the tier: a 6GB RTX 3050 comment, an 8GB RTX 4060 Ti post, this site's own 12GB measurement, five reported 4070 Ti SUPER runs between 2:09 and 6:55, a 20GB RX 7900 XT at about 58 minutes, and a 24GB row left empty because no comparable measurement exists. Read the model column before the VRAM column — a smaller quantisation fits a smaller card, which is exactly why no single "needs X GB" number exists.

Will a smaller resolution fit a run into less VRAM?

Much less than most guides suggest. Across a roughly 40× workload change, peak VRAM moved from 11,649 MiB to 11,591 MiB — 58 MiB, half a percent. Most of the memory is the model sitting resident in the card whatever size clip you ask for.

Why count frames instead of seconds?

Two clips both described as five seconds can carry different frame counts. The measured runs here are 124 frames at 24fps, which is 5.166667 seconds, not five. The calculator asks for frames and fps for that reason.

Model review: the verdict page

A tool tells you whether something will run. A review tells you whether it is worth running. The planned MiniMax H3 review takes a position on where an open model with native audio sits against a stitched pipeline of a video model plus a separate lip-sync stage, and states the honest alternatives rather than ending on a score.

It is written last on purpose: a hands-on model review that is not downstream of the run records above is just an opinion with screenshots. Until it ships, the GPU ledger and the troubleshooting library carry the parts of that judgement that can be measured.

Model profiles: what the preset actually is

Each tool takes a model preset, and a planned MiniMax H3 model profile will say what one is before you pick it — the weight files it needs, what ships with it, and which of this site's measurements apply to which variant.

For the first preset the short version is that "MiniMax H3" is not one weight file. Ref2VA and FL2VA are separate downloads with separate footprints, the Qwen3-VL text encoder and two VAE files are shared, and the full local set is roughly 42GB on disk. Knowing what MiniMax H3 is at that level of detail is what makes a tier table readable, because two reports that look contradictory usually loaded different files.

Guides: the long-form write-ups behind the tools

Not everything belongs in a tool. The AI video generation guides section holds the write-ups the tools were built from: the full ComfyUI setup walkthrough, the RTX 3060 test card with its environment and file hashes, the eight-node cache comparison, the Turbo LoRA step-and-shift rules, and the hosted-endpoint notes.

These are the pages where the reasoning lives. A tool has to give one answer; a guide can show the two runs it came from, the report that contradicts it and the reason one was preferred. If a tool's output looks wrong for your setup, the matching step-by-step guides entry is usually where the difference is explained.

Independent guide

Independent guide. Not affiliated with MiniMax, Hailuo AI, Hugging Face, or ComfyUI. Product names, model names and template files belong to their respective owners, and every third-party figure on this site is attributed to the post or repository it came from.