MiniMax H3 study
MiniMax H3 on a Budget: What Actually Works on 4070/5070/5080 (community input consolidation)
A Note on Sources
This article is built entirely from community feedback — Reddit threads, forum comments, and one independent comparison site (jo-nike.github.io/h3-turbo-eval). None of it comes from official documentation or controlled lab testing. Thank you to everyone whose posts, benchmarks, and hard-won troubleshooting notes made this possible, including GrayingGamer, Tystros, Chemical-Painter-485, katsura_otoko, infearia, JoNike, Sixhaunt, dtdisapointingresult, Snoo_64233, mellowanon, Just1Dev, smereces, DefloN92, StuffProfessional587, Creative_Finger_69, backworld_nograv, V4nKw15h, True_Protection6842, clex55, Maskwi2, Perfect-Campaign9551, and many others whose usernames didn't make it into these notes but whose comments shaped the consensus (and disagreements) captured here.
Where the community disagreed with itself, that's presented as an open question rather than resolved — and where direct data for a specific card was simply missing, that gap is called out rather than papered over.
Why This Is Confusing
Most of the detailed benchmarking in the MiniMax H3 community comes from people with RTX 3090s, 4090s, and 5090s — cards with 24GB+ VRAM that can afford to just try everything and report back. If you're on a 4070, 5070, or 5080, you're stuck reverse-engineering advice that wasn't written with your VRAM ceiling in mind. This piece pulls together what budget-card owners actually reported, plus what reasonably carries over from adjacent cards where direct data doesn't exist.
The Three (and a Half) Speed Levers
Every thread assumes you already know these, so here's the plain version:
Turbo LoRAs — swap-in models trained to produce good results in far fewer steps (4-8 instead of 20-32). Fastest option, but quality cost varies a lot depending on which checkpoint version you use.
Spectrum — a node that mathematically forecasts/predicts future denoising steps instead of computing them. Counterintuitively, it needs more steps to work well — it's not a low-step tool.
Sage Attention — an attention backend swap. Broad community agreement that this is close to "free" speed with minimal quality loss, and it's the one piece almost nobody argues against.
EasyCache — a quieter fourth option that came up as a serious alternative to Turbo LoRAs for drafting, not just a bonus add-on.
What "Budget" Card Owners Actually Reported
This is the thin part of the record, so treat it as ground truth before anything else:
RTX 4070 (12GB, 32GB RAM): did quick 0.3MP draft passes in a couple of minutes to tweak prompts and hunt for seeds, reserving longer ~40-minute runs for higher resolution/duration finals. VRAM was sufficient for T2V-style work specifically.
RTX 4070 Ti Super (16GB, 32GB RAM): reported working well, no further detail given.
RTX 5070 Ti (16GB, 32GB DDR4): upgrading from an RTX 2060 (6GB) described the speed difference as "night and day" — notably, without any Sage Attention or acceleration nodes running yet. This suggests raw generational/VRAM gains matter a lot on their own, before you even add speed tricks.
Warning flag for all of the above: reference-heavy Ref2V generation was specifically called "brutal" on modest VRAM cards, compared to plain T2V. If your workflow uses multiple reference images/videos, expect more friction than these numbers suggest.
Gap, named honestly: there's no direct plain-5070 or 5080 speed benchmark in any of the source threads. The one 5080 comment that exists is qualitative ("still great," runs the BF16 pruned model fine) with no timing numbers.
Extrapolation (clearly labeled): Since the 5070 Ti (16GB) and 4070 Ti Super (16GB) both reported comfortable results, and RTX-series cards were noted to benefit meaningfully from tensor cores over older architectures, a plain 5070 (12GB) likely lands closer to the 4070's experience — fine for T2V and quick low-res drafts, tighter on Ref2V with multiple references. A 5080 (16GB) likely performs at least as well as the 4070 Ti Super, probably closer to the low end of what 3090 owners report, given the VRAM parity and newer architecture. This is inference from adjacent data, not a report anyone actually made — treat it as a starting assumption to test, not a promise.
The Draft → Final Two-Stage Workflow
This is the one thing nearly every thread converges on independently, and it's probably the most actionable takeaway for a budget card:
Draft stage (fast iteration, hunting for the right prompt/seed):
Low resolution: 0.2–0.4 megapixels
Low steps: 8–13
Acceleration: either a Turbo LoRA or EasyCache (not both)
Faster VAE decode substitute: BlehTAEVideoDecode instead of the standard node
Final stage (once the shot is locked):
Disable acceleration nodes
Raise steps to 20–32
Switch back to the standard VAE Decode node
Two draft "recipes" show up repeatedly and are reported as similarly fast:
Turbo LoRA + Sage Attention — faster to set up, more established
Sage Attention + EasyCache, params (0.3, 0.2, 0.9), res_multistep sampler + Simple scheduler — one detailed user report (RTX 4060 Ti, 16GB), after testing 1000+ variations, said this drifts less from final quality than Turbo LoRA approaches, at comparable speed
For a 12–16GB budget card, EasyCache is worth trying first specifically because it avoids the quality-consistency debates that follow Turbo LoRAs (see below).
What Worked / What Didn't
| Technique | Verdict | Reported Config | Source Consensus |
|---|---|---|---|
| Sage Attention (alone) | ✅ Works | Any step count | Broad agreement — near-free speed, minimal quality loss |
| Two-stage draft→final workflow | ✅ Works | Draft: 0.2–0.4MP, 8–13 steps → Final: 20–32 steps, no acceleration | Converged on independently across nearly every thread |
| "Clean VRAM" node before VAE Decode | ✅ Works | Placement only, no params | Multiple independent reports, fixed OOM with no downsides |
| EasyCache (draft) | ✅ Works | Params (0.3, 0.2, 0.9), res_multistep + Simple, 10 steps | One deep-dive (1000+ tests) preferred it over turbo LoRAs for drift |
| ema-ckpt500 Turbo LoRA | ✅ Works | Strength ~0.5, 6–8 steps | Beat both ckpt850 and lightx2v in blind testing |
| Spectrum below ~20 steps | ❌ Doesn't work | N/A | Most consistent "don't do this" finding across all sources |
| Spectrum + Turbo LoRA together | ❌ Doesn't work | N/A | Explicitly warned against — Spectrum needs clean high-step data |
| ckpt850 Turbo LoRA (vs ckpt500) | ❌ Doesn't work | Full 1.0 strength = "overfried" | Newer checkpoint tested worse than older one, despite official claims |
| lightx2v LoRA | ❌ Doesn't work | 8 steps, 0.75 strength | Worse faces/lighting vs ema-ckpt500 in direct comparison |
| Raising steps to fix face-warping | ❌ Doesn't work | Tested 8→20, and up to 30 steps | Two separate users found no improvement — not a step-count problem |
| Any acceleration on non-RTX cards | ❌ Doesn't work | N/A | Tensor-core dependent; gains don't transfer to older architectures |
| Turbo LoRAs (general use) | ⚠️ Mixed | Fine for tests/talking-head; risky for motion/long prompts | Depends on shot type, not a clean yes/no |
| Spectrum + First Block Cache | ⚠️ Mixed | N/A | Direct contradiction between two experienced users |
| RTX upscaling node | ⚠️ Mixed | 0.2MP+ | Good on animation, unreliable on photorealistic faces |
GPU-Specific Data: Reported vs. Extrapolated
| GPU | VRAM | Reported Result | Status |
|---|---|---|---|
| RTX 4070 | 12GB | 0.3MP drafts in ~2 min; fine for T2V, tight on Ref2V | Direct report |
| RTX 4070 Ti Super | 16GB | "Works well" (no numbers given) | Direct report |
| RTX 5070 Ti | 16GB | Major generational leap even with zero acceleration | Direct report |
| RTX 5070 | 12GB | (no data) | Extrapolated from 4070 — likely similar |
| RTX 5080 | 16GB | Handles BF16 pruned model fine (qualitative only) | Direct report (thin) + extrapolated timing |
The Unresolved Debates
Worth knowing before you commit to a setup, so you don't over-trust any single comment:
Spectrum below 20 steps? Most experienced users say no — negligible speed gain, real quality loss. But a few 5090 owners reported no measurable time savings even at higher step counts, with no clear explanation (dismissed by one commenter as "not using it right").
Which Turbo LoRA checkpoint is actually best? The lineage went ckpt500 → ckpt850 → ckpt600, with each new version claimed better by its authors. But blind side-by-side testing found ckpt500 at 0.5 strength still beat ckpt850 even at full strength — directly contradicting the official recommendation.
Spectrum + First Block Cache together? One experienced user says combining them is worse than Spectrum alone; another says combining them is the fastest option with no noticeable quality loss. Unresolved.
Turbo LoRA strength values: reports range from 0.5 up to 1.15–1.20 (and one outlier claiming 3.0), so "strength 1.0" isn't a safe universal default — it depends on which checkpoint you're using.
VRAM/RAM Troubleshooting Cheat Sheet
Fixes that came up repeatedly and matter more when you're VRAM-constrained:
Add a "Clean VRAM" node immediately before VAE Decode — fixed OOM issues for multiple users.
System RAM matters too, not just VRAM — one user needed to go from 16GB to 48GB total system RAM to stop hitting errors. 16GB system RAM was described by another as "almost enough."
Launch ComfyUI with
--reserve-vram 2to keep 1-2GB permanently free for system stability, at a small cost to usable VRAM.If Ref2V errors show up on an 8GB VRAM card, don't assume it's a hard VRAM wall first — one such case turned out to be a node-conflict bug, not actually a memory limit.
A Starter Config for Budget Cards
Synthesizing the most-corroborated points into one starting recipe (best-guess synthesis, not a benchmarked config):
Draft pass: Sage Attention + EasyCache (0.3, 0.2, 0.9) → 10 steps → res_multistep sampler, Simple scheduler → BlehTAEVideoDecode → 0.2–0.3 MP
Final pass: Sage Attention only (no EasyCache) → 20–25 steps → standard VAE Decode → 0.4–0.6 MP (push higher only if VRAM allows)
Skip Spectrum entirely unless you're already comfortable at 25+ steps and have time to test it — it's not built for the low-step, fast-iteration use case a budget card usually needs.
Sources
The most rigorous single data point in this set is the JoNike Turbo LoRA comparison site — a 10-scene A/B comparison across checkpoint versions, built and documented far more consistently than typical anecdotal Reddit reports.