Qwen3-VL-32B H3-Compatible Text Encoders

Use case

This repository provides Qwen3-VL-32B-derived text/vision conditioning encoders for MiniMax H3 workflows in stock ComfyUI, with a lossless BF16 reference build and an INT8 TensorWise build intended for substantially lower memory use and strong performance on AMD ROCm 7-capable GPUs with Triton support.

These files are not standalone Qwen chat models and do not contain a MiniMax H3 diffusion model, VAE, LoRA, or sampler. They are drop-in text-encoder files for ComfyUI MiniMax H3 workflows that use CLIPLoader with type minimax.

H3-compatible describes the retained Qwen topology, key layout, and ComfyUI conditioning contract. The released weight tensors are derived from the official Qwen/Qwen3-VL-32B-Instruct checkpoint; no MiniMax-trained tensor values were introduced into these encoder weights.

Files

What was changed from upstream Qwen

The official source is Qwen/Qwen3-VL-32B-Instruct, pinned for this build to commit:

0cfaf48183f594c314753d30a4c4974bc75f3ccb

The H3-compatible BF16 build is a lossless structural extraction/repack:

Qwen3-VL token embedding          retained
full Qwen3-VL vision tower        retained
language layers 0..49             retained
language layers 50..63            omitted
final language-model RMSNorm      omitted
lm_head                            omitted

ComfyUI MiniMax H3 consumes the unnormalized hidden state after language layer 50, so the truncated checkpoint ends at layer index 49 and intentionally has no final language-model norm or LM head.

The BF16 reconstruction retained 902 tensors. All 902/902 were verified as exact dtype/shape/value matches to the pinned official Qwen checkpoint.

INT8 TensorWise variant

The INT8 model was quantized from the clean BF16 build, not from a MiniMax-trained encoder.

format                         int8_tensorwise
ConvRot                        false
quantized linear weights       467
language-model matrices        350  (50 layers x 7 projections)
vision matrices                117
stored weight scale            FP32 [out_features, 1]
activation quantization        dynamic rowwise INT8 at runtime
reproducible quantization      source-dtype division on CPU

The release INT8 tensor data is byte-identical to the validated high-quality/high-performance golden INT8 baseline. Only the top-level safetensors provenance metadata was changed for release.

Requirements

• Current ComfyUI with MiniMax H3 support.
• A working PyTorch/ROCm stack for your AMD GPU.
• For the INT8 TensorWise model: comfy-kitchen with a working Triton backend.
• ROCm users should use Triton 3.7 or newer for the INT8 path. Older ROCm Triton builds have had backend issues that can cause failures rather than merely reduced performance.

The BF16 model does not require the INT8 Triton kernel, but it uses considerably more memory.

Enable Triton in ComfyUI

Start ComfyUI with:

python main.py --enable-triton-backend

A Docker/container launch can equivalently append the same flag, for example:

python /root/ComfyUI/main.py \
  --listen 0.0.0.0 \
  --enable-triton-backend

On startup, verify that ComfyUI reports that Triton was found and the comfy-kitchen Triton backend was enabled. Do not assume that installing a package named triton means the accelerated INT8 path is actually active.

If your current ComfyUI build exposes --disable-triton-backend, make sure you are not passing it.

AMD ROCm environment variables

Do not copy an environment-variable block from another AMD GPU without checking your own hardware and software stack. Relevant settings can change with GPU architecture, PyTorch wheel, ROCm release, kernel, container/runtime, and whether the PyTorch build contains native kernels for your GPU.

Before adding GPU-specific overrides, identify at least:

rocminfo | grep -m1 -E 'gfx[0-9]+'
python - <<'PY'
import torch
print('torch:', torch.__version__)
print('HIP:', torch.version.hip)
print('GPU:', torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'not visible')
if torch.cuda.is_available():
    print('arch:', torch.cuda.get_device_properties(0).gcnArchName)
PY

Then research the recommendations for that exact GPU architecture + ROCm/PyTorch build. In particular, do not blindly set HSA_OVERRIDE_GFX_VERSION: native architecture-aware ROCm builds may not need it, while compatibility stacks may require a specific value.

Strix Halo example from this project

The native ROCm 7.2.4 environment used while building and validating these artifacts used a dedicated ROCm userspace under $HOME with the following environment structure:

ROCM_ROOT="$HOME/amd-rocm/rocm-7.2.4"

export ROCM_PATH="$ROCM_ROOT"
export HIP_PATH="$ROCM_ROOT"
export PATH="$ROCM_ROOT/bin:$PATH"
export LD_LIBRARY_PATH="$ROCM_ROOT/lib:$ROCM_ROOT/lib64:$ROCM_ROOT/llvm/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"

The project setup script additionally discovers required ROCm library directories and appends them to LD_LIBRARY_PATH when necessary. This example is not a universal Strix Halo prescription and is not a recommendation to add architecture overrides to other installations. Use the variables appropriate for your own ROCm package layout and GPU support status.

Install in ComfyUI

Place either text encoder in:

ComfyUI/models/text_encoders/

For example:

cp qwen3vl_32b_h3_compatible_int8_tensorwise.safetensors \
  /path/to/ComfyUI/models/text_encoders/

Restart ComfyUI with Triton enabled. In the MiniMax H3 workflow, use a CLIPLoader and select:

clip_name: qwen3vl_32b_h3_compatible_int8_tensorwise.safetensors
type:      minimax
device:    default

For the reference BF16 build, select qwen3vl_32b_h3_compatible_bf16.safetensors instead.

The official ComfyUI MiniMax H3 workflow templates also store the H3 text encoder under models/text_encoders/ and use CLIPLoader with type minimax.

Download example

Replace OWNER/REPO with this repository ID:

REPO_ID="OWNER/REPO"

hf download "$REPO_ID" \
  --include "text_encoders/qwen3vl_32b_h3_compatible_int8_tensorwise.safetensors" \
  --local-dir /tmp/qwen3vl-h3

cp /tmp/qwen3vl-h3/text_encoders/qwen3vl_32b_h3_compatible_int8_tensorwise.safetensors \
  /path/to/ComfyUI/models/text_encoders/

Provenance and exact hashes

Official source

Repository: Qwen/Qwen3-VL-32B-Instruct
Revision:   0cfaf48183f594c314753d30a4c4974bc75f3ccb
License:    Apache-2.0
Source shards verified: 14/14 by SHA256
Official source tensors: 1058

BF16 artifact

File:       qwen3vl_32b_h3_compatible_bf16.safetensors
SHA256:     80524a15e345a434e0875d30dc769a2c29e2c6f2da650ad5fea969ceb13a606e
Tensors:    902
Payload:    47.969 GiB
Retained:   embedding + full vision tower + language layers 0..49
Omitted:    language layers 50..63 + final LM norm + lm_head
Repack numerical loss: 0.0

INT8 TensorWise release artifact

File:       qwen3vl_32b_h3_compatible_int8_tensorwise.safetensors
SHA256:     438036c50abff3292ebc9d891ad8454fb5e7ff53fe6e7622643358ea9d2f2e55
Tensors:    1836
INT8 weights: 467
FP32 scales: 467
Markers:      467
Payload:      24.726 GiB

Validated pre-release golden INT8 SHA256:

b129bb43c8995b9bbb4d68119f2070933d678f733d223efe44f9d5547ebcad58

The release artifact differs from that golden file only in top-level provenance/reproducibility metadata. Their tensor data-region SHA256 is identical:

49ffc28657581caa4ac74a8e47e40a8adff9b3fc25733bad4314ebfa59a90297

Detailed machine-readable and Markdown validation reports are included under provenance/.

Scope and limitations

• These are H3 conditioning encoders, not full MiniMax H3 checkpoints.
• The H3-specific prompt/tokenizer behavior is implemented by ComfyUI; it is not embedded solely in these safetensors weights.
• Hardware/runtime support depends on ComfyUI, comfy-kitchen, Triton, PyTorch, ROCm, and your GPU architecture.
• INT8 quality/performance claims apply to the validated TensorWise recipe represented by this artifact; other quantization implementations are not necessarily equivalent.

License and attribution

The upstream Qwen/Qwen3-VL-32B-Instruct repository declares Apache License 2.0. This repository includes the full Apache-2.0 text in LICENSE and records the upstream source and modifications in NOTICE.

The released artifacts are modified/repacked derivatives: the BF16 file changes topology/key layout for H3-compatible conditioning; the INT8 file additionally applies the documented TensorWise INT8 quantization. See PROVENANCE.md for the complete derivation chain.

Qwen, MiniMax, ComfyUI, AMD, and ROCm names are used only to describe source, compatibility, and target runtime. No endorsement by those projects or companies is implied.

Work with me / More projects

If this repository saved you some VRAM, debugging time, or helped make a demanding AI workflow more practical, there is a lot more where this came from.

I’m currently looking for full-time opportunities as an AI Systems Engineer, particularly work involving model optimization, inference systems, GPU acceleration, quantization, generative AI infrastructure, and the engineering needed to make large models run reliably in real-world environments. If your team is hiring and this kind of work is relevant, please reach out to me on LinkedIn.

Want to see more of what I build? Visit PuppetVisionAI on YouTube for more projects, experiments, and practical AI systems work, or visit puppetvision.nl for my website.

References

• Upstream Qwen model: https://huggingface.co/Qwen/Qwen3-VL-32B-Instruct
• ComfyUI MiniMax H3 encoder implementation: https://github.com/Comfy-Org/ComfyUI/blob/master/comfy/text_encoders/minimax.py
• ComfyUI Triton backend flag: https://github.com/Comfy-Org/ComfyUI/blob/master/comfy/cli_args.py
• ComfyUI comfy-kitchen backend selection: https://github.com/Comfy-Org/ComfyUI/blob/master/comfy/quant_ops.py
• comfy-kitchen INT8 implementation: https://github.com/Comfy-Org/comfy-kitchen/blob/main/comfy_kitchen/tensor/int8.py
• Apache License 2.0: https://www.apache.org/licenses/LICENSE-2.0

Technical provenance reports are provided for reproducibility; they are not legal advice.