The fl2va half of the comfy-native set. If you want ref2va, it is
over here —
same formats, same method, different job.
Stock ComfyUI 0.32+ loads these directly. No ComfyUI-GGUF, no custom loader
node, no dequantise-on-the-fly. ComfyUI carries its own quantisation system
(comfy/quant_ops.py plus the comfy_kitchen kernels) and these files use it,
so the kernels run in the quantised domain instead of unpacking to bf16 first.
Which one is fl2va, and why you would want it
fl2va is the first/last-frame variant. It has no reference rows, so voice
anchoring, the identity bank and reference images do nothing on it. In exchange
it does the one thing ref2va cannot:
it lands on a supplied frame.
Measured against the same target frame:
fl2va — 26.35 dB
ref2va + keyframe, turbo 6 steps — 16.15 dB
ref2va + keyframe, stock 20 steps — 16.81 dB
The stock-20-step control rules out the sampler. The checkpoints genuinely
differ, by about 10 dB. ref2va treats a keyframe as a suggestion; fl2va
treats it as the task.
It can also take a first and a last frame and plan a camera move between
them, which ref2va has no mechanism for at all.
So: ref2va when a face or a voice has to persist across shots, fl2va when
a shot has to start exactly where the last one ended. Stepping through a scene
one shot at a time — render, look at it, feed its last frame to the next — is
the case fl2va is built for.
Note this is not a size decision. fl2va and ref2va are byte-identical in
size at every quantisation. "Lighter" only ever meant fewer tokens per sampling
step, because there are no reference rows riding along.
A file that fits can still run emulated, and nothing in the UI tells you
which you got. ComfyUI prints it at startup — look for the line beginning
Native ops: and check your format is in it.
Emulation is hardware, not a ComfyUI version problem. NVFP4 and microscaling
FP8 are Blackwell tensor-core features; float8_e4m3fn wants Ada or newer. An
Ampere card emulates all three no matter how current ComfyUI is.
Blackwell, 50-series — nvfp4. Fastest thing here.
Ada, 40-series — w4a8. Measured by a user on a 4090 at 17.4 s/it
against 31.0 for fp8 on the same settings — because fp8 at 21 GB does not fit
beside the activation pool on 24 GB and streams weights over PCIe. Native ops
you cannot reach are worth nothing.
Ampere, 30-series — int8. The 4-bit formats will load and run slowly.
Which format, and an honest correction
Corrected 2026-08-15. This section used to say the formats were all the same
quality and that you should take the smallest file your card runs natively. A
user measured otherwise and they were right, so here is the accurate version.
What we tested: on the ref2va set, the same scene through w4a8 and int8 at
704x1280 and 20 steps, both reviewed as video. They showed the same defect
classes - garbled text on instrument dials, reflective safety-tape edges that
warp during movement, limb distortion on fast motion, stiff lip sync. That part
still holds, and it is worth knowing: those are characteristics of the base
model at these shapes, not quantisation damage. If you see them, check against a
GGUF or the unquantised model before blaming the quant.
Where that went wrong: "the same defect classes" is not "the same quality", and
the review was done by an automated video reviewer that is demonstrably blind to
fine texture differences. It was the wrong instrument for the question.
What a user measured by eye, on a 5060 Ti at 0.5 MP, 12 steps,
res_multistep/simple:
int8_convrot (8-bit, ~19.5 GB) - good quality, 193s
4-bit, this repo - moderate quality, 187s
4-bit, a different maintainer's build - moderate quality, 187s
Two independent 4-bit builds landing on the same verdict is a real result, and
~3% on wall clock is not a trade worth making for it.
So: if an 8-bit build fits your card natively, take it. Reach for 4-bit when
8-bit does not fit, when it would stream weights over PCIe, or when you are at a
large enough workload that the format actually shows up in the wall clock - at
0.5 MP over 5 seconds it does not, because load, text encode and VAE dominate.
The one quality line that was always real: 4-bit activations genuinely
damage this model, which is why there is no w4a4 here. 4-bit weights are
usable - just not free.
How these were verified
Honest answer, and it differs from the ref2va set: these were forward-gated,
not render-tested. Every build was run through a GPU forward pass on both an
attention layer and a feed-forward layer before publication, and all five
passed. That catches a format that cannot execute; it does not catch one that
executes and looks wrong.
What that inherits from the ref2va set, which was rendered at matched seed and
shape:
the speed ordering — nvfp4 fastest, then int8, mxfp8, w4a8, fp8, all of them
between 18% and 34% faster than the Q8_0 GGUF
the quality equivalence above
both cuts (see below)
Same architecture, same 200-layer set, same quantiser, same pruned lineage — so
those carry. If you render a fl2va build and it disagrees with any of this, I
want to hear about it.
Two formats that are NOT here, and why
convrot_w4a4 — renders without error and the output is visibly degraded.
It quantises activations to 4 bits; every file here keeps activations at 8.
Instrument text becomes scribble, hi-vis banding dissolves, hands smear.
Caught by render on the ref2va set at seed 4040 against four other builds. It
saves 1.2 GB against w4a8 and costs all of it.
float8_e5m2 — loads cleanly, then throws at the first matmul:
"Multiplication of two Float8_e5m2 matrices is not supported". Same on
LTX-2.5. It would ship as a file that appears fine until you sample.
Neither was built for fl2va. Both failures are properties of the format rather
than of these particular weights, so building 32 GB to quarantine it would have
been busywork.
Why there are no K-quants of this model anywhere
H3's hidden width is 2688, and K-quants need weight rows divisible by 256.
2688 is not, so the whole K-ladder is unavailable for the DiT — which is why the
GGUFs of it are Q4_0/Q5_1/Q8_0 and not Q4_K_M. (The encoder is a stock
Qwen3-VL and its rows do divide, so
that repo has real
K-quants. The two are easy to confuse.)
The comfy-native formats have no such constraint, which is part of why this set
exists.
How these were made
The layer SET is mirrored from Comfy-Org's own
minimax_h3_fl2va_pruned_int8_convrot rather than guessed: exactly 200
Linears, being attn.qkv_proj, attn.out_proj, mlp.fc1 and mlp.fc2
across 50 blocks. Everything else stays bf16/fp16 — adaLN, the timestep
embedders, every norm and bias, token_refiner, the patch projections and the
final layer. Those steer every block and rounding them is how a quantised DiT
dies.
Built from the pruned bf16 lineage. That matters arithmetically: on the
unpruned lineage adaLN is 38% of the file, and 4-bit lands at 19.9 GB — which
the existing GGUF Q4_0 already achieves. Pruned 4-bit lands near 11.7 GB.
What else you need
Text encoder and VAEs — Comfy-Org/MiniMax-H3. Two separate VAEs, video
and audio.
Nothing else. That is the point of these.
Honest limits
No render A/B on the fl2va weights specifically. The speed and quality
findings are inherited from the ref2va set — identical architecture, layer
set, quantiser and lineage — not measured here.
fl2va ignores voice_ref, self_anchor_voice and the identity bank
entirely. If your workflow depends on those, you want ref2va.
Two formats are absent on purpose: convrot_w4a4 (4-bit activations
visibly degrade H3) and float8_e5m2 (loads, then throws at the first
matmul — e5m2 cannot matmul in PyTorch). Both were cut on ref2va evidence
that is not weight-specific, so neither was built here.
