---
license: apache-2.0
base_model: ethanfel/Qwen3-VL-32B-Ultra-Heretic-MiniMax-H3-ComfyUI-INT8-ConvRot
base_model_relation: quantized
tags:
  - minimax-h3
  - text-encoder
  - qwen3-vl
  - nvfp4
  - comfyui
  - video-generation
  - uncensored
  - abliterated
library_name: comfyui
---

# Qwen3-VL-32B Heretic (MiniMax-H3 text encoder) — NVFP4

**The uncensored MiniMax-H3 text encoder, in 15.7 GB — it fits on a single 16 GB card.**

This is a mixed-precision **NVFP4** re-quantization of
[ethanfel/Qwen3-VL-32B-Ultra-Heretic-MiniMax-H3-ComfyUI-INT8-ConvRot](https://huggingface.co/ethanfel/Qwen3-VL-32B-Ultra-Heretic-MiniMax-H3-ComfyUI-INT8-ConvRot),
the Heretic (uncensored) text encoder for [MiniMax-H3](https://huggingface.co/MiniMaxAI/MiniMax-H3)
video generation.

| build | size | fits 16 GB card? |
|---|---|---|
| Heretic INT8-ConvRot (upstream) | 26.4 GB | no (needs offload) |
| **Heretic NVFP4 (this repo)** | **15.7 GB** | **yes** |
| Comfy-Org NVFP4 (censored) | 15.7 GB | yes |

Same size as Comfy-Org's official NVFP4 encoder, so it is a **drop-in replacement**:
point `CLIPLoader` at this file instead and the rest of your MiniMax-H3 workflow is unchanged.

## Why

80 GB cards always had the choice. This is for the people who don't have one.
Creative work shouldn't require datacenter hardware — that's the whole point of quantizing it.

## Measured

Generated 6 s of 480×864 vertical video with audio, MiniMax-H3 `fl2va` pruned INT8 diffusion model,
`res_multistep` 20 steps, ComfyUI 0.30.0, Sage Attention on:

| | value |
|---|---|
| GPU | 1× RTX PRO 2000 Blackwell (16 GB, sm_120) |
| peak VRAM during generation | **~9.9 GB** |
| encoder staged in VRAM | 14.9 GB (dynamic loading) |
| system RAM used by the ComfyUI process | ~36 GB |

Output was compared against the upstream INT8-ConvRot build on identical prompt and seed.
The two are visually equivalent — the quantization does not change what the encoder will describe.

## Files

```
qwen3vl_32b_heretic_minimax_h3_nvfp4.safetensors   15.7 GB
```

Place in `ComfyUI/models/text_encoders/` and select it in `CLIPLoader` (type: `minimax`).
You still need the diffusion model and VAEs from
[Comfy-Org/MiniMax-H3](https://huggingface.co/Comfy-Org/MiniMax-H3).

## How it was made (and the trap you must avoid)

**The upstream weights are rotated.** Its `comfy_quant` metadata reads:

```json
{"format": "int8_tensorwise", "convrot": true, "convrot_groupsize": 256, "per_row": true}
```

ConvRot stores each weight already multiplied by a normalized Hadamard matrix
(`W_stored = W @ Hᵀ`, per 256-wide group) and rotates activations to match at runtime.
If you dequantize those weights and re-quantize them to plain NVFP4 **without undoing the
rotation**, you get a file that loads, runs, and produces *completely unrelated video* —
in our first attempt a prompt for a war-torn street rendered a speedboat on open water.
Nothing errors. The conditioning is simply meaningless.

Because the Hadamard is orthogonal, the fix is to multiply by `H` again before re-quantizing:

```python
from comfy_kitchen.backends.eager.convrot_w4a4 import _build_hadamard

def unrotate(w, gs=256):                      # w: dequantized [out, in]
    out_f, in_f = w.shape
    h = _build_hadamard(gs, device=w.device, dtype=torch.float32).to(w.dtype)
    return torch.matmul(w.reshape(out_f, in_f // gs, gs), h).reshape(out_f, in_f)
```

**Mixed precision.** 350 linear layers are NVFP4 (`TensorCoreNVFP4Layout`, group size 16).
`model.embed_tokens` (151936 × 5120 = 778 M params) is **left as INT8** — the same choice
Comfy-Org made in the official NVFP4 build. Quantizing it gives little size benefit and it is
the one layer whose temporaries will OOM a 16 GB card during baking. ComfyUI reads per-layer
`comfy_quant` metadata, so the mixed file loads with no special handling.

The bake runs on a single 16 GB GPU in about two minutes.

## Provenance

- Uncensoring / Heretic work: **[ethanfel](https://huggingface.co/ethanfel)**
- Original encoder: **Qwen3-VL-32B** (Alibaba / Qwen team), as adapted for MiniMax-H3
- MiniMax-H3: **[MiniMaxAI](https://huggingface.co/MiniMaxAI/MiniMax-H3)**
- ComfyUI packaging conventions and quantization layouts: **[Comfy-Org](https://huggingface.co/Comfy-Org/MiniMax-H3)**
- This NVFP4 re-quantization: **Lna-Lab** ([@Tono_Ken3](https://x.com/Tono_Ken3))

Licensing follows the upstream repositories; the MiniMax-H3 model weights themselves are
subject to the MiniMax H3 Community License.

## Notes

- Re-quantizing INT8 → NVFP4 means this build inherits the upstream INT8 rounding.
  A bake straight from BF16 would be marginally cleaner; we did not have those weights.
- Blackwell (sm_120) was used for both baking and inference. NVFP4 needs hardware support.
- If output looks unrelated to your prompt rather than merely lower quality, suspect a
  rotation mismatch, not the quantization.