GPU Benchmark for AI Video Generation

What this GPU benchmark measures

A GPU benchmark for local AI video generation has to answer one question: on this card, with this job, does the run finish, and how long does it take. The calculator above and the ledger below answer it the same way for any local video model — the model is a preset, not the subject. Today one preset carries site-measured numbers, MiniMax H3, and the section further down is its record.

Every row is one job on one card. A job is a canvas (width × height), a frame count, a step count and an acceleration stack. Change any one of those four and the row is a different measurement, which is why a wall time quoted without them is not a benchmark result — it is a number. This page never prints one without its four.

The numbers a GPU benchmark row carries

• Wall time in seconds. Clock time from queue to finished file, not sampler-only time. It includes model load on a cold run, which is why cold and warm runs are kept apart instead of averaged.
• Peak VRAM in MiB, and as a percentage of the card. The percentage is the part that decides whether a run survives, because a card at 94.8% has no room for a larger canvas.
• Peak system RAM in MiB. Local video models keep weights and working buffers resident on the host, so the host number often decides the run before the card does. The system requirements checker judges that side.
• An evidence grade. Measured means this bench ran it and kept the record, failures included. Reported means a first-hand post stated the hardware and the result, and the row shows the handle and the date. Estimate means the engine extrapolated from an anchor, and an estimate is never printed as if it had been measured.

How to read a GPU benchmark row

Read the evidence grade first, the canvas and frame count second, and the wall time last. A row with a green evidence grade and a canvas unlike yours tells you less than a reported row at your canvas. The calculator exists so you do not have to do that translation by hand: it snaps your duration to the model's frame-block grid, picks the nearest measured anchor, and returns a range rather than a single number when the anchors do not bracket your card.

How to compare two cards in a GPU benchmark

Comparing cards is where most published figures fall apart, because the two numbers being compared were produced by two different jobs. Three rules keep a comparison honest.

Compare the same job, not the same card name

Two rows only compare when the canvas, the frame count, the step count and the acceleration stack match. If they do not, you are measuring the difference between two workloads and attributing it to silicon. The comparison strip in the calculator holds your job fixed and swaps only the card, and it shades any bar that is an interpolation instead of a measurement.

VRAM class decides first, the stack decides second

VRAM class decides whether a run finishes at all: below 8,192 MiB there is no configuration this site can point at and call working, between 8,192 and 12,287 MiB the only reports that exist describe long cold runs, and from 12,288 MiB up is the band this bench measured. Inside one class the acceleration stack moves the number further than the model name on the box, and a faster stack can raise the floor instead of lowering it. The section at the foot of this page gives both halves with the runs behind them. Pick the class that finishes, then the stack that clears your quality floor.

A card that fits is not a card with headroom

Fitting and having room are different states. On this bench a run peaked at 11,649 MiB on a 12,288 MiB card: 639 MiB left, which is what the runtime happened to leave after filling the card, not a budget you can spend on a bigger canvas. Treat the last few hundred MiB as noise, not as capacity. If your card is in that position, the tier-by-tier evidence on the VRAM calculator is the next thing to read.

MiniMax H3 preset

MiniMax H3 is the first preset on this page and, so far, the only one with site-measured numbers behind it. Everything from here down to the questions section is that preset's record: the same ledger, the same counters and the same boundaries this site has published since the first run. The numbers are reproduced unchanged.

Read the matrix without guessing

This page exists because there is no controlled single-GPU benchmark matrix for MiniMax H3 — not from MiniMax, not from ComfyUI, a gap called out publicly in August 2026. This ledger is the answer: every row names its GPU, its canvas, its frame count and its wall time.

The gap was stated in those words on X: "No controlled single-GPU benchmark matrix from MiniMax or ComfyUI" (@yume_arasaki, 2026-08-07). The follow-up question under every new clip is just as blunt — "Key question is how long did that 5s take" (@jikkujose, 2026-08-04). A MiniMax H3 GPU benchmark that does not state the canvas, the frame count, the step count and the acceleration stack cannot answer either one, which is why the calculator on this page asks for all four before it returns a number, and why every row of the ledger above repeats them.

Rows are hardware profiles

Each row names the card class and the environment that was actually used. The owned RTX 3060 row is a record, not a promise about every RTX 3060.

Columns are task tracks

Each column combines a model or precision track with a task. A measured cell links to its test_id; it is a projection of that run record.

Untested stays explicit

not tested means this site has not run the combination. It does not mean “unsupported,” “impossible,” or “will fail.”

No cross-row ranking

The rows do not share one machine, workflow, or memory budget. We place facts beside one another and do not calculate a speed ranking across them.

Every row carries its evidence grade

The grade is the first thing to read; the three grades are defined at the top of this page. All 26 site rows share one environment line, printed once above the ledger instead of 26 times, so a difference between two rows is a difference in the workload and not in the machine.

What this bench measured

On this bench, at 1344×768 for 124 frames, the first formal run of each track came in at 2,581.8 s for REF2VA INT8 R2V with a peak of 11,649 MiB (94.8% of the card), 2,175.5 s for FL2VA T2V at 11,023 MiB (89.7%), 2,373.7 s for FL2VA I2V at 11,125 MiB (90.5%), and a median 528.6 s for the 4-step Turbo LoRA pass. That is what a MiniMax H3 GPU benchmark on an RTX 3060 comes to here: a 12GB consumer card that finishes all four tracks while sitting near the top of its memory, not a card with room to spare.

The 12GB row is site-measured on one owned bench. The 8GB row is a queued inventory item, not an inference from the 12GB measurements.

Three facts from this ledger

Each statement is tied to records above and carries its conditions. None is a cross-GPU ranking or a community-result verdict.

Workload scaling did not move VRAM much

In the R2V GPU 0 smoke-to-formal pair, the frame-pixel workload is approximately 40×. Peak VRAM moved from 11,591 to 11,649 MiB (+0.5%), while peak RAM moved from 43,176 to 43,587 MiB (+1.0%). The smoke was cold and the formal run warm, so this is an observation about this pair, not a scaling law.

Records: SITE-3060-R2V-GPU0-SMOKE and SITE-3060-R2V-GPU0-B1.

Cache Phase B telemetry stayed in a narrow VRAM band

The seven Phase B execution records, including the failed C5 telemetry record, span 11,163–11,773 MiB of recorded peak VRAM. C5 has no successful output, and C3/C8 have no Phase B performance record; the range is not evidence that all eight nodes work.

Records: PB-C1, PB-C2, PB-C4-RUN1, PB-C5 (failed), PB-C6, PB-C7.

R2V repeated output bytes matched

The two formal GPU 0 R2V runs each produced the same output SHA-256 prefix recorded in the cards: cc2a6f75…be6060f. Under this fixed seed, workflow and hardware setup, the outputs were byte-identical. The wall times remain 2,581.8 s and 2,579.8 s as separate observations.

Records: SITE-3060-R2V-GPU0-B1 and SITE-3060-R2V-GPU0-B1-RUN2.

Best GPU for MiniMax H3: VRAM class first, then the stack

This ledger measures one card, so it cannot hand you a winner, and the no cross-card ranking boundary below still holds. What the evidence does support is an order of operations.

VRAM class decides whether a run finishes at all, and the calculator reads the same bands the VRAM page publishes. Below 8,192 MiB there is no configuration this site can point at and call working. Between 8,192 and 12,287 MiB clips come out, but the reports that exist describe long cold runs rather than a setup you would work in. From 12,288 MiB up is the band this bench measured, and the measurement is tight rather than comfortable: 11,649 MiB peak on a 12,288 MiB card leaves 639 MiB, which is what ComfyUI left after filling the card, not headroom you can spend on a bigger canvas.

Inside one class the acceleration stack moves the number further than the model name on the box. On an RTX 4070 12GB the same full-HD 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 (@sep_is_heim, 2026-08-31) — a 12.97× spread on one card, wider than the 4.33× that separates the fastest and the slowest consumer card this site has a timing factor for at all. A faster stack can also raise the floor instead of lowering it: the Ref2VA VSA port goes out of memory on 12GB cards, so its bands start at 16,384 MiB and only reach green at 24,576 MiB. That is why the stack is an input and not a footnote, and why a number quoted without one is not a benchmark.

So the order is: pick the class that finishes, then the stack that clears your quality floor, then check the claim against a row that states your canvas, your frame count and your step count.

What makes a row a site GPU benchmark

• Track: every row here is site_benchmark, not a community reproduction.
• Freeze: record the workflow revision and SHA-256, model files, input files, prompt, seed, canvas, frames, sampler, scheduler and audio state.
• Measure: report wall time, peak VRAM in MiB, peak system RAM, temperature, GPU binding and contamination before/after.
• Repeat: a formal site benchmark lasting at least 30 minutes runs twice; both test IDs and raw values remain visible. No average stands in for them.
• Retain failures: a failed execution or hardware incident is a record, not a footnote to delete.
• Separate tracks: smoke checks validate a chain; cache-node compatibility is not performance; rental hardware gets its own row; GPU 0 was used for the owned-bench heavy runs after the GPU 1 incident.

Full protocol: site-reproduction-protocol.md, version 0.2-draft.

Submitted benchmarks follow the same protocol through a review queue before they appear anywhere on this page. A submission that states its canvas, frames, steps and stack can be selected into the results below and carries its submitter's evidence grade; one that does not state them stays out, however interesting the number is. Review is also the only way the leaderboard gets longer — it is short because the qualifying rule is narrow, and loosening the rule is not on the table.

What this GPU benchmark does not claim

No second-hand numbers in the matrix

Community reports remain community-reported. Their setup, timing and claims are not inserted into a site-measured cell.

No cross-card speed ranking

Different cards, environments and workflows cannot be reduced to one leaderboard. The 8GB row is not a support or failure verdict.

Turbo A/B stays on this 12GB card

The Turbo LoRA A/B ran once on this owned RTX 3060 12GB bench with the same prompt, seed, canvas, frames and workflow as the FL2VA T2V baseline, changing only the LoRA, steps and shift schedules. The same-environment pairing gives a 4.113×–4.132× wall-time range; it is not a cross-environment comparison and it is not placed beside any community "5×" claim. All three B-side runs peaked above 8,192 MiB, so this page makes no 8GB support or failure claim.

No averaged formal result

Repeat values are separate elements with separate IDs. If a future run changes, the raw ledger can show what changed.

No datacentre row to aim at

The fastest published H3 figure we know of is 5 s at 1344×768 in 1.653 s on eight B300 accelerators (@xieenze_jr, 2026-09-07). It stays out of the calculator's catalogue on purpose: it is context for what the model does when memory and interconnect stop mattering, not a target any consumer card is being measured against.

Choosing a card from this GPU benchmark

These answers are generic to local AI video generation; every number in them comes from the MiniMax H3 preset above, because that is the only preset with measured data on this site today.

Is a 12GB card enough for local AI video generation?

On this bench, yes, for the workloads listed above: 1344×768 for 124 frames finished on all four tracks. It is enough, not comfortable — the R2V pair peaked at 11,649 MiB of a 12,288 MiB card, 94.8%. The margin is 639 MiB, so a larger canvas or a heavier stack has nowhere to go. A stack whose bands start at 16,384 MiB, such as the Ref2VA VSA port, will not run there at all. Check your own card against the bands on the VRAM calculator.

Does system RAM matter for a GPU benchmark?

More than most GPU benchmarks admit. On this bench peak system RAM reached 43,587 MiB while the card peaked at 11,649 MiB, so the host was the binding constraint, not the GPU. A 32GB machine has 32,768 MiB in total and is short by about 10.6GB before the operating system takes its share. Lowering the canvas does not fix it: a job roughly 40× smaller moved peak system RAM by 411 MiB, under 1%. Judge that side with the system requirements checker before you judge the card.

Does a faster GPU always cut the wall time?

No — the acceleration stack often moves it further than the card does. On one RTX 4070 12GB the same five-second full-HD 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× that separates the fastest and the slowest consumer card this site has a timing factor for at all. On this bench the 4-step Turbo LoRA pass ran 4.113× to 4.132× faster than its own 20-step baseline in the same environment. Which stack is installed is a workflow question, so the templates on the ComfyUI workflow page decide it.

Is an 8GB card usable at all?

This site makes no support claim for 8GB. Nothing on the owned bench ran under 8,192 MiB, the three Turbo runs all peaked above it, and the 8GB row in the matrix is not tested rather than failed. What exists is second-hand: about 20 minutes for five seconds at 640p on an RTX 4060 Ti from cold, and 15-second clips at 480p on an RTX 5060 with 32GB of system RAM. Both describe a card that renders, not a card you would work on.

What should I do when a run fails instead of just running slowly?

Separate the two failure modes before changing anything. Out of memory on the card is a VRAM-class problem and moves you down a band or across to a lighter stack. A whole-machine freeze or a kill with no CUDA error is almost always the host side: on this evidence one RTX 3090 report dropped system RAM from 29.8GB to 7.5GB by turning pinned memory off, and an Ubuntu RTX 3060 report stopped freezes with the same flag. Symptom-by-symptom checks live on the ComfyUI troubleshooting page, and the freeze path is the one to start from when the machine, not the run, is what died.