AI Video System Requirements Checker

What the three-light checker checks

The checker above takes a machine and a model preset and returns three lights: one for the graphics card's memory, one for system RAM, and one for the CPU. It does not score a machine out of ten and it does not rank hardware. It asks a narrower question: for the workloads this site has actually measured, would this machine finish, finish badly, or not finish.

The inputs are the ones that change the answer — GPU, its VRAM, system RAM, logical CPU cores, swap or pagefile, and whether pinned memory is on. Nothing is inferred from a machine name.

The GPU and VRAM light

Pick the card, then state its memory. The card matters for the timing estimate; the memory decides the light. For the default stack the bands are: below 8,192 MiB red, 8,192 to 12,287 MiB amber, 12,288 MiB and up green. Amber means clips come out and the reports describe long cold runs, not a setup you would work in. Green means a run finished in this band on this site's own bench — it is not a promise of headroom.

Bands move with the acceleration stack, not just the card. The Ref2VA VSA port goes out of memory on 12GB cards, so under that stack the same 12GB machine is red, amber only starts at 16,384 MiB and green at 24,576 MiB. Tier-by-tier evidence for each band is in the VRAM calculator section below.

The system RAM light

This is the light most machines fail, and the one a GPU spec sheet never warns about. Local video models keep weights and working buffers resident on the host, so the host peak can sit four times higher than the card peak. With pinned memory on, the bands used here come out of measured runs: below 43,587 MiB red, 43,587 to 45,957 MiB still red because it is inside the operating system's margin, 45,958 to 65,535 MiB amber, and 65,536 MiB and up green.

Turning pinned memory off changes the ladder entirely — below 16,384 MiB red, 16,384 to 32,767 MiB amber, 32,768 MiB and up green — because one first-hand report dropped system RAM from 29.8GB to 7.5GB with that single launch flag. The switch is in the form because one flag moves a machine two lights, and pretending there is one ladder would be wrong in both directions.

The CPU light

The CPU light is advisory and never decides the overall verdict on its own. Under 8 logical cores it warns that offloading will run slower than on the 16-thread bench these numbers come from. It does not turn a machine red, because no run in this site's evidence failed on CPU.

Swap, pagefile and the operating-system side

There is no operating-system dropdown, because no measured difference in this site's evidence is attributable to the OS by itself. Two inputs cover that side instead. Swap or pagefile is collected and deliberately not credited: the bench had none, so no recorded run proves that a job which spills into swap finishes rather than crawling or freezing. And Apple silicon is handled as a platform, not a card — unified memory is not split into VRAM and system RAM, so both hardware lights go amber and neither goes green. The only first-hand Apple timing here is an M3 Max at about one hour per second of video.

Why the RAM thresholds matter more than the resolution slider

The usual first instinct when a run dies is to lower the resolution. On the measured evidence that buys time, not memory, which is why the thresholds above are absolute numbers rather than a function of canvas size. A job roughly 40× smaller in pixel-frames moved peak system RAM by 411 MiB — under one percent — while wall time fell by a factor of 46. The memory budget is set by resident weights and working buffers, not by the size of the output.

That is also why the red band is split in two. A 32GB machine and a machine that reaches the peak but eats into the operating system's share are different situations and get different verdicts. The red line is drawn at the highest peak in the whole evidence set, 43,910 MiB, plus a 2,048 MiB margin for the operating system, while the explanatory sentence quotes 43,587 MiB, the peak from this page's own two runs. Two numbers on purpose: the conservative one sets the threshold, the familiar one explains it.

If your machine clears both hardware lights, the bottleneck moves to the workflow rather than the hardware, and the templates on the ComfyUI workflow page are the next step. If it does not, the symptom paths on the ComfyUI troubleshooting page match a failure to a check before you change anything.

MiniMax H3 preset

MiniMax H3 is the first preset in this checker and, so far, the only one with site-measured numbers behind it. Everything from here down to the closing questions is that preset's record, reproduced unchanged: the two runs the thresholds were drawn from, the environment they ran in, and the band table the engine reads.

The short answer

Peak system RAM reached 43,587 MiB on our test machine. A 32GB machine has 32,768 MiB in total, leaving a shortfall of about 10.6GB before the operating system takes its share.

Two runs, 40x apart in workload

Both site-measured workloads used the shared environment listed under Test conditions, including the same official R2V template, Ref2VA pruned INT8 and a fixed seed.

The workload increased by roughly 40x and wall time by roughly 46x, while peak system RAM increased by only 411 MiB, under 1%.

The smoke run rendered 512×288 for 22 frames; the full run rendered 1344×768 for 124 frames. That is 3,244,032 pixel-frames against 127,991,808, a factor of 39.5.

Why lowering resolution does not help

For these measured runs, the memory budget was determined by resident model weights and working buffers rather than output size. Lowering resolution bought time, not memory: the much smaller workload completed sooner without materially changing the system-RAM peak.

Do not treat two points as a curve. These are two measurements from the same configuration, not a basis for broader extrapolation. They do not establish behavior for other model variants, runs with audio enabled, or outputs large enough to exceed VRAM.

Test conditions

• RTX 3060 12GB on physical GPU 0.
• Proxmox VE VM 100 with 16 vCPU, 47.05 GiB RAM and no swap.
• ComfyUI 0.31.0 and PyTorch 2.13.0+cu130.
• Official R2V template with Ref2VA pruned INT8 and a fixed seed.
• The smoke run rendered 512×288 for 22 frames at 24fps; the full run rendered 1344×768 for 124 frames.
• Audio, Turbo LoRA and SageAttention were not enabled.
• System memory was measured from cgroup memory.peak, supported by VmHWM and MemAvailable_min.

Where each line comes from

Every band the checker uses, with its lower bound, its light and the evidence behind it. Bands marked measured come from this site's own run records; bands marked reported come from first-hand posts with the hardware stated.

The same table, as JSON, sits inside this page and is the file 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.

VRAM calculator: budgeting card memory for a local run

This section is the former standalone VRAM calculator page, folded in unchanged. It answers the memory half of the question the checker above answers as a light.

Quick answer

For the official REF2VA workflow, budget a 12GB card and — more importantly — well over 32GB of system RAM. We measured 11,649 MiB of VRAM and more than 43,000 MiB of system memory, and both figures stayed essentially flat across a 40× range of output sizes. Lower resolution makes the job faster, not smaller. Reports of MiniMax H3 running on 6GB and 8GB cards exist, but they use different model combinations and we have not verified them on our own hardware.

The one tier we can speak to first-hand

Everything in this subsection is from our own machine. Every other tier on this page is somebody else's report, labelled as such.

11,649 MiB — Peak VRAM of 12,288 available — 94.8%, identical on two independent runs.

43,587 MiB — Peak system memory on the same run. The second run reached 43,907 MiB.

0.5% — How much peak VRAM fell when we cut the workload by roughly 40×.

Hardware was an RTX 3060 12GB on Ubuntu 24.04.4 with the official REF2VA pruned INT8 model, no Turbo LoRA and no SageAttention, producing 1344×768 at 124 frames. The complete environment, version numbers, file hashes and both runs' raw values are on the RTX 3060 test card.

VRAM is the number people ask about, not the one that stops them

A MiniMax H3 run has to fit three separate resources at once. Most guides discuss only the first. In our runs the first was the one with the most margin.

1 · Video memory

Ours peaked at 11,649 MiB of 12,288, leaving 639 MiB. Tight, but it completed twice without a single out-of-memory error. This is the budget that scales least with what you ask for: the model has to be resident regardless.

2 · System memory — the binding constraint

Ours peaked above 43,000 MiB on every run, including a workload that finished in 55 seconds. A machine advertised as 32GB cannot hold that at all. If you are choosing where to spend money for MiniMax H3 on a 12GB card, this is where it goes, and swap is not a real substitute.

3 · Disk

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. We treat 45GB free as the floor for setting this up, and verified that before starting.

Why this ordering matters: the standard advice for a memory error is to lower the resolution. On our configuration that advice is close to inert for memory, because resolution is not what is consuming it. If you are hitting a hard limit at 32GB of system RAM, no resolution setting will get you under it.

A 40× smaller job, and almost the same memory

We ran two workloads on the same card, same model files and same software, differing only in output size. Both used the same fixed seed and the same derived workflow file.

Same six numbers as the table below, plotted for scale. The system-memory panel includes a reference line at 32GB because that is the ceiling most community guides quote as sufficient.

What this shows: for this model and workflow, memory is dominated by resident model weights and working buffers that are allocated regardless of output dimensions. Time scales with the work; memory largely does not.

What it does not show: that this holds for every MiniMax H3 model variant, for audio-enabled runs, or past the point where a larger output would exceed the card. We measured two points on one configuration, not a curve.

VRAM requirements at each tier: what is actually known

Each row records one configuration that was reported to work, not a minimum for that tier. The confidence column is the point of the table: only one row is ours.

Read the model column before the VRAM column. The 8GB report and our 12GB measurement are not in tension: they load different diffusion models and different text encoders. A smaller quantization can fit a smaller card, which is exactly why a single "MiniMax H3 needs X GB" number does not exist.

Note on the system RAM column: several of these reports pair a small card with 32GB of system memory. Our own measurements exceeded that figure on every run, so if you are planning a build from these rows, treat their RAM values as reported rather than as verified sufficient.

Seven things that change the requirement more than resolution

Model precision

Full, INT8, NVFP4 and GGUF variants load different amounts and use different kernels. This is the single largest lever, and it is why the 8GB and 12GB rows above are not comparable. Smaller is not automatically faster or more compatible.

Which model, not just which size

REF2VA, FL2VA and the text-to-video variants are separate files with separate footprints. "MiniMax H3" is not one weight file.

Text encoder

An NVFP4 encoder and a full-precision one are a large difference in resident memory, and an out-of-memory error during encoding happens before sampling ever starts.

Frames, not seconds

Two clips both described as five seconds can carry different frame counts. Our 124 frames at 24fps is 5.166667 seconds, not five. Record frames and fps.

Audio

Audio adds models and a decode stage. We ran with audio off, so every figure on this page excludes it. Note that disabling the audio decode does not necessarily stop audio latents being generated during sampling.

Cache and offload

Cache can cut repeat time while consuming system RAM. CPU offload can fit VRAM by moving pressure onto system memory and storage — which, given the section above, is the budget you can least afford to spend.

Software versions

ComfyUI, PyTorch, CUDA and custom-node versions change whether a workflow runs at all, which makes any memory figure without version numbers difficult to act on.

Start small, then change one limit

1. Confirm free system memory first, then free disk, then VRAM — in our runs that is the order in which they actually bind.
2. Use the official template or a well-documented quantized workflow, and note which model variant it loads.
3. Run once with audio off and a fixed seed to establish a baseline you can compare against.
4. Close other GPU applications and record free VRAM before loading. Our headroom was 639 MiB.
5. After one success, change either frames or resolution — not both — and expect the time to move far more than the memory.

Hit an OOM?

Note which stage it happened at: text encoding, diffusion start, later sampling, VAE decode, or model handoff. The stage determines whether a smaller encoder, a different quantization, 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.

Open the MiniMax H3 troubleshooting guide.

Can this machine run it, by VRAM tier

Four tiers, answered with what this site can actually stand behind. One of them is measured here; the other three are somebody's report or nothing at all. Where nothing exists, the section says not tested and stops.

8GB

Not tested on this bench. Nothing on the owned bench ran under 8,192 MiB, the three Turbo LoRA B-side runs all peaked above it, and the 8GB row in the ledger is not tested rather than failed. Under the default stack the checker puts 8,192 to 12,287 MiB amber, which means a run has been reported to complete in that band and nothing more.

What exists is second-hand, both from the tier table above: an RTX 4060 Ti 8GB with 32GB of system RAM running FL2VA pruned INT8 with an NVFP4 encoder at 640p for 5 seconds — about 20 minutes cold, 12 minutes with EasyCache, about 95% VRAM reported, graded Medium. Separately, an RTX 5060 8GB was reported at 15s@480p, 10s@~540p and 5s@~720p with 32GB of system RAM, with no timings stated (@yume_arasaki, 2026-08-07). Both describe a card that renders, not a card you would work on.

Below this tier there is even less. The only 6GB evidence on this site is the single Reddit comment in the tier table above — an RTX 3050 6GB with 16GB of system RAM, default 480p for 5 seconds, about 17 min — graded Low because it is one comment with no environment stated. It is not verified here, and 6GB sits under the checker's red line either way.

12GB

Measured. This is the only tier with a site run record behind it. On an RTX 3060 12GB at 1344×768 for 124 frames, peak VRAM was 11,649 MiB of 12,288 MiB — 94.8%, leaving 639 MiB — and the run completed twice. That is a card that fits, not a card with room: the 639 MiB is what the runtime happened to leave after filling the card.

The qualifier is the stack, not the card. The Ref2VA VSA port goes out of memory on 12GB cards, so under that stack a 12GB machine is red and amber only starts at 16,384 MiB.

16GB

Not tested on this bench. The strongest report in the tier table is an RTX 4070 Ti SUPER 16GB with 32GB of system RAM running INT8/NVFP4 I2V at 20 steps and 24fps with audio off: five reported runs from 2:09 to 6:55 with no OOM, graded High for a report. A 3.2× spread inside one tier is why this site publishes ranges rather than a single figure for uncarded cards.

16,384 MiB is also where the Ref2VA VSA bands start, so this is the first tier that has a reported configuration under the heavier stack.

24GB

Not tested on this bench, and the tier table's 24GB+ row is graded "Unknown — we will not invent a figure": more headroom, still workflow dependent, no comparable measurement available.

What the reported rows do show is that 24GB of VRAM is not by itself enough. An RTX 3090 24GB run died on 31GB of system RAM with peak VRAM at only 19.8GB (@yume_arasaki relaying tonyd2wild, 2026-08-07), and a separate RTX 3090 report still crashed with ComfyUI offload enabled (@ColtierPat, 2026-09-03). Under the Ref2VA VSA stack, 24,576 MiB is the first green band.

Can this machine run it, by card

RTX 3060 12GB

Measured — this is the bench card. Every site number on this page came off it: 11,649 MiB peak VRAM of 12,288 MiB (94.8%) and 43,587 MiB peak system RAM at 1344×768 for 124 frames in 2,581.8 s, against 11,591 MiB (94.3%) and 43,176 MiB at 512×288 for 22 frames in 55.6 s. It is the only card in this site's catalogue with a measured timing coefficient.

Two second-hand rows temper that. One relayed report put a 10-second clip on a 3060 at about 2 hours with the canvas unstated (@umiyuki_ai, 2026-07-31, relaying @yume_arasaki 2026-08-07), and one post argues the card "cannot" do the job while maintaining quality, speed and audio integrity (@Mobayoman, 2026-09-06). This site measured that it runs, not that it is productive.

RTX 5060 Ti 16GB

Not tested. The only evidence anywhere in this site's two evidence sets is qualitative: a post stating that 16GB is enough to generate a music video (@NeiroAizawa, 2026-09-07). No canvas, no frame count, no step count, no timing, so the card carries no coefficient and the estimator falls back to a bracket.

RTX 5070 Ti 16GB

Not tested. The card appears exactly once in this site's evidence, and not as a timing: a 16GB RTX 5070 Ti report on the ComfyUI troubleshooting page, under "OOM when the diffusion model starts", found that the text encoder remained allocated when the diffusion model loaded, and fixed it with a KJNodes VRAM_Debug barrier plus forced cache and garbage collection before the handoff. That is a workflow finding, not a capability finding.

RX 9060 XT

Not tested, and there is no report for it either. Neither this site's run records nor its X sweep contains a single row for the RX 9060 XT, so there is nothing to state — no timing, no peak, not even a qualitative "it runs". The nearest AMD evidence is the RX 7900 XT 20GB row in the AMD section below, which is a different card on a different driver stack and should not be read across.

Multiple RTX 3090s

Not tested. No multi-GPU run exists in either evidence set: every site run record is single-card, and no reported row describes two or more cards sharing one job. This page therefore makes no claim about whether splitting a MiniMax H3 run across two 3090s works, helps, or halves anything.

What is known about a single RTX 3090 24GB, all reported rather than measured: a full 15-second clip completed in 23m17s; a separate run on the same thread died on 31GB of system RAM with peak VRAM at only 19.8GB, and disabling pinned memory dropped system RAM from 29.8GB to 7.5GB (@yume_arasaki relaying tonyd2wild, 2026-08-07); a Motion-Context-MultiRef workflow produced output with no duration given (@OrganoidsAI, 2026-09-07); and one report crashed even with ComfyUI offload enabled (@ColtierPat, 2026-09-03).

AMD cards

Not tested on this bench. This site owns no AMD hardware, so every AMD row is somebody else's.

One row carries numbers: an RX 7900 XT 20GB with 32GB of system RAM on a ROCm nightly, running INT8/INT4 I2V at 1056×608 for 10 seconds at 20 steps, in about 58 minutes. It is graded Medium — detailed environment, no exact workflow file. Note that 1056×608 sits on the 32-multiple grid.

Everything else about AMD is unstated here. The checker treats an AMD card the same way it treats an NVIDIA one — the bands are MiB of card memory, not a vendor test — so entering an AMD card and its memory gives you the band it falls in, and nothing about ROCm driver behaviour is folded into the verdict.

Apple silicon

Not tested on this bench, and handled as a platform rather than as a card. Unified memory is not split into VRAM and system RAM, so on Apple silicon both hardware lights go amber and neither ever goes green. That is a statement about what this site can verify, not about the machine.

The only first-hand Apple timing in either evidence set is a Mac M3 Max running a 10-second local text-to-video at roughly one hour per second of output — 36,000 s for the clip, with no canvas and no step count stated (@tuzibtc, 2026-09-06). For a Mac Mini M4 64GB the evidence says only that an MLX port exists and nobody has published a measured timing (@yume_arasaki, 2026-08-07). M1, M2 and M3 carry no row at all; they are in the picker because the site's hardware list requires them, not because there is data behind them.

GPU benchmark

The former standalone GPU benchmark page, folded in here as one section. The calculator and ledger it describes answer the timing half of "can this card run it": not whether the run fits, but how long it takes once it does.

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 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 three-light checker at the top of this page 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 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

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 subsections below give 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 in the VRAM calculator section above 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 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 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 calculator section 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 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 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.

Frequently asked questions

Is 32GB of RAM enough to run MiniMax H3 locally?

Not on our test machine. Peak system RAM was 43,587 MiB, while a 32GB system has 32,768 MiB in total. That is a shortfall of about 10.6GB before the operating system takes its share.

Does lowering the resolution reduce MiniMax H3 memory use?

Barely. We ran the same workflow at two sizes about 40 times apart in workload. Wall time went from 55.6 seconds to 2,581.8 seconds, but peak system RAM moved only from 43,176 MiB to 43,587 MiB, a difference under one percent. Lowering resolution buys time, not memory.

How much system RAM should I have for MiniMax H3?

Our runs peaked just under 43GB on a machine with 47.05 GiB available, leaving very little headroom. Anything at or below 32GB was short on every run we measured.

Does MiniMax H3 need 64GB of RAM?

Not strictly. With pinned memory on, every completed run this site has recorded peaked between 42,060 and 43,910 MiB, so a 48GB machine finishes with a few gigabytes to spare and 64GB is the first common size with comfortable headroom. With pinned memory off, one RTX 3090 report dropped system RAM from 29.8GB to 7.5GB, which is why the checker above turns a 32GB machine green in that mode. That flag has not been measured on this site's own bench.

Questions about system requirements for local video models

The answers below 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.

Which spec should I check first, VRAM or system RAM?

Check both, but expect system RAM to be the one that fails. On this bench the card peaked at 11,649 MiB and the host peaked at 43,587 MiB, and peak system memory stayed above 43,000 MiB at every workload we ran, including the smallest one: the machine that owns the card is doing four times as much memory work as the card. A 12GB card is a common, well-documented starting point; a 48GB host is not. That is the order this checker uses — the overall verdict takes the worse of the VRAM and system RAM lights, and the CPU light never decides it alone.

Is a 12GB card enough?

On this site's measured preset, yes: 1344×768 for 124 frames finished on all four tracks, with the R2V pair peaking at 11,649 MiB of a 12,288 MiB card. That is 94.8% of the card and leaves 639 MiB, so it is enough rather than comfortable — a larger canvas or a heavier stack has nowhere to go, and a stack whose bands start at 16,384 MiB, such as the Ref2VA VSA port, will not run there at all. The per-band evidence is in the VRAM calculator section above, and the wall times each band produces are in the GPU benchmark section.

Does swap or a pagefile count toward the requirement?

Not in this checker. The bench had no swap, so there is no recorded run proving that a job which spills into swap finishes rather than crawling or freezing. Enter it anyway — the checker reports it back with an explicit caveat instead of quietly folding it into the verdict.

What does an amber light actually mean?

That a run in that band has been recorded as completing, and that nothing in the evidence says it will be pleasant. Amber on system RAM means the bench's own 47.05 GiB machine with no swap: every recorded run finished, peaking at 43,910 MiB at most. Amber on VRAM means cards that produced clips in long cold runs — about 20 minutes for five seconds at 640p on an 8GB RTX 4060 Ti, or 15-second 480p clips on an RTX 5060 with 32GB of system RAM. Amber is a finished run with no margin, not a recommendation.

My whole machine freezes instead of the run failing. Is that a RAM problem?

Usually yes, and it is the clearest signal that the host and not the card is the limit. A CUDA out-of-memory error points at the VRAM light; a freeze, a hard kill, or a reboot with nothing in the log points at the system RAM light. One RTX 3090 report dropped system RAM from 29.8GB to 7.5GB by launching with pinned memory disabled, and an Ubuntu RTX 3060 report stopped whole-machine freezes with the same flag — which is why that switch is an input here and not a footnote. The freeze path on the ComfyUI troubleshooting page walks through it symptom by symptom.

MiniMax H3 memory questions

How much VRAM does MiniMax H3 need?

On the one configuration we measured ourselves, 11,649 MiB of a 12,288 MiB card, or 94.8%. That figure is for the official REF2VA pruned INT8 model with audio off. Other model variants have different footprints, so there is no single number that covers every MiniMax H3 workflow.

Can MiniMax H3 run with 8GB of VRAM?

There is a detailed community report of a 4060 Ti 8GB completing a 640p five-second job, but it used a different model combination than the one we measured. 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 — the 4060 Ti report, roughly 20 minutes from cold for five seconds at 640p, and 15-second clips at 480p on an RTX 5060 with 32GB of system RAM. We have not tested an 8GB card, so these are graded as community evidence rather than a confirmed requirement: cards that render, not cards you would work on.

Choosing a card

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.

Does system RAM matter for a 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 three-light checker at the top of this page 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.

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.