README.md

---
license: other
license_name: minimax-h3-community-license-agreement
license_link: LICENSE
pipeline_tag: text-to-video
library_name: radiance
tags:
- radiance
- rocm
- amd
- rdna4
- fp8
- text-to-video
- text-to-audio-video
- minimax-h3
- latent-upscaler
base_model:
- MiniMaxAI/MiniMax-H3
- LBH-123-AI/Minimax_h3_latent_Upscaler
---

# MiniMax-H3, FP8 — radiance container

[MiniMaxAI/MiniMax-H3](https://huggingface.co/MiniMaxAI/MiniMax-H3) — video with a synchronized stereo
soundtrack from text — as a single `.rad` container for the
[radiance](https://codeberg.org/StillDeadcode/radiance) inference engine (AMD RDNA4, ROCm).

The MiniMax H3 Community License does not cover the European Union, the United Kingdom, the
Republic of Korea or the United States of America; see [License](#license).

| | |
|---|---|
| File | `minimax-h3-fp8.rad` — 60.54 GiB |
| Weights | every linear of the text encoder (the 50 layers of Qwen3-VL-32B the model reads), the token refiner and the DiT's 50 blocks, and the modulation projections, FP8 E4M3 per 128×128 block (bf16 scales); the video decoder bf16; the audio decoder f32 |
| Latent upscaler | [LBH-123-AI/Minimax_h3_latent_Upscaler](https://huggingface.co/LBH-123-AI/Minimax_h3_latent_Upscaler) v1 (3D conv, 345M parameters, bf16; Apache-2.0) |
| Output | MP4: H.264 at 24 fps, up to 1344x768, 5.17 to 14.4 s; AAC at 32 kHz stereo |
| Needs | radiance 1.8.1 or newer (the upscaler, and prompts over 128 tokens, need 1.8.1); two 32 GB cards and about 39 GiB of pinned host memory |

## Serve

```sh
radiance --model minimax-h3-fp8.rad --tp 2 --vision-tower-placement ram --host 0.0.0.0 --port 8000

curl -s http://localhost:8000/v1/videos -H 'Content-Type: application/json' -d '{
  "prompt": "A red fox trotting through a snowy pine forest, snow crunching underfoot",
  "seconds": "5", "size": "1344x768", "seed": 7}'          # -> {"id": "video_...", "status": "queued", ...}
curl -s http://localhost:8000/v1/videos/video_...            # poll until "status": "completed"
curl -s http://localhost:8000/v1/videos/video_.../content -o fox.mp4
```

The server speaks OpenAI's video jobs API (`POST /v1/videos`, `GET /v1/videos/{id}`,
`GET /v1/videos/{id}/content`, list and delete), and SGLang's `target` field:

- `prompt` is read as written, up to 2048 tokens; the model follows long structured descriptions
  (the shot, its soundscape, its music) best.
- `seconds` is rounded up to the model's length steps (17 frames): 5.17 to 14.4 s. `size` is
  `WIDTHxHEIGHT`, multiples of 32, at most 1344x768 pixels of area.
- `seed` makes a video repeatable on the same deployment; `num_inference_steps` counts sigma grid
  points as diffusers does (50 by default, at most 65). The model is guidance-distilled: no guidance
  scale, no negative prompt.
- Text to video and audio only; the image- and reference-conditioned forms are not in this file.

On two Radeon AI PRO R9700s (gfx1201) a 5.17 s clip at 1344x768 takes about 8.8 minutes at the
default 50 steps. The text encoder and the modulation projections are read from pinned host memory,
which `--vision-tower-placement ram` selects. For the eight-step distillation, see
[StillDeadcode/fasth3-8-step-v2-fp8](https://huggingface.co/StillDeadcode/fasth3-8-step-v2-fp8).

From the same conditioning and noise, the first step's velocity is 5.4% (video) and 4.3% (audio)
from diffusers' bf16 pipeline, about what the reference itself moves with its linears rounded to FP8
the same way (6.8% and 4.6%). Given the same latents, the video decoder is 36.9 dB PSNR from the
reference's (H.264 included) and the audio decoder 51.0 dB SNR.

## Latent upscaling

The container carries LBH-123-AI's latent upscaler. A request with `"latent_upscale": 2` runs its
first steps at half the size (672x384 for 1344x768), the upscaler enlarges the clean latent, and the
last `upscale_refine_steps` (12 by default) run at the full size from a re-noised copy of it:

```sh
curl -s http://localhost:8000/v1/videos -H 'Content-Type: application/json' -d '{
  "prompt": "...", "seconds": "5", "size": "1344x768", "seed": 7, "latent_upscale": 2}'
```

| 5.17 s at 1344x768, 50 steps, 2x R9700 | time |
|---|---|
| native | 8.8 min |
| `latent_upscale` 2, 12 refine steps (the default) | 3.4 min |
| `latent_upscale` 2, 20 refine steps | 4.5 min |

The factor goes up to 4, but at 1344x768 a factor of 4 starts from 352x192, which is too small for
the model to lay out a clean scene: expect soft, ghosted frames. The video object of an upscaled
video reports `latent_upscale`, `upscale_refine_steps` and `upscale_from` (the small size).

## How this file was made

```sh
rad-convert MiniMaxAI/MiniMax-H3 --recipe minimax-h3-fp8.recipe -o minimax-h3-fp8.rad
```

`MiniMaxAI/MiniMax-H3` is the downloaded pipeline directory; only its text-to-video-and-audio
components are read (`text_encoder/`, `transformer/`, `vae/`, `audio_vae/`, the processor, the
tokenizer and both schedulers), and the upscaler as a companion folder `latent_upscaler/` (its
`minimax_h3_latent_upscaler_3d_conv_v1/config.json` and bf16 weights, renamed
`diffusion_pytorch_model.safetensors`). This file had it added to the 1.8.0 container in place
(`rad-convert ... --reuse minimax-h3-fp8.rad --in-place`), which leaves every other weight as it
was. The recipe (`minimax-h3-fp8.recipe` in this repository) names what is
quantised; everything it does not name is the checkpoint's own dtype:

```
te.blk.*.attn_qkv.weight             rtn  codes=fp8_e4m3 block=128x128 scale=bf16
te.blk.*.attn_output.weight          rtn  codes=fp8_e4m3 block=128x128 scale=bf16
te.blk.*.ffn_gate_up.weight          rtn  codes=fp8_e4m3 block=128x128 scale=bf16
te.blk.*.ffn_down.weight             rtn  codes=fp8_e4m3 block=128x128 scale=bf16
te.blk.*.attn_norm.weight            cast dtype=f32
te.blk.*.ffn_norm.weight             cast dtype=f32
ref.blk.*.attn_qkv.weight            rtn  codes=fp8_e4m3 block=128x128 scale=bf16
ref.blk.*.attn_output.weight         rtn  codes=fp8_e4m3 block=128x128 scale=bf16
ref.blk.*.ffn_gate_up.weight         rtn  codes=fp8_e4m3 block=128x128 scale=bf16
ref.blk.*.ffn_down.weight            rtn  codes=fp8_e4m3 block=128x128 scale=bf16
dit.blk.*.attn_qkv.weight            rtn  codes=fp8_e4m3 block=128x128 scale=bf16
dit.blk.*.attn_output.weight         rtn  codes=fp8_e4m3 block=128x128 scale=bf16
dit.blk.*.ffn_gate_up.weight         rtn  codes=fp8_e4m3 block=128x128 scale=bf16
dit.blk.*.ffn_down.weight            rtn  codes=fp8_e4m3 block=128x128 scale=bf16
dit.blk.*.ada*.weight                rtn  codes=fp8_e4m3 block=128x128 scale=bf16
vae.blk.*.attn_qkv.weight            cast dtype=bf16
vae.blk.*.attn_out.weight            cast dtype=bf16
vae.blk.*.ffn_up.weight              cast dtype=bf16
vae.blk.*.ffn_down.weight            cast dtype=bf16
vae.proj_out.*                       cast dtype=bf16
aud.*.weight                         cast dtype=f32
ups.embed.*                          cast dtype=f32
ups.*.emb_layers.*                   cast dtype=f32
```

## License

MiniMax H3 is licensed under the MiniMax H3 Community License Agreement, Copyright © 2026 MiniMax
(`LICENSE` in this repository; `NOTICE` carries its notice). The agreement grants its rights only
within its Applicable Territory: worldwide except the European Union, the United Kingdom, the
Republic of Korea and the United States of America, where it does not license using, reproducing or
distributing the model or this file. Its use restrictions and Acceptable Use Policy (Exhibit A of
`LICENSE`) apply to everyone who downloads or uses this file, and to anyone it is passed on to.

This container is a modified copy of MiniMax H3: the linears named above are re-encoded as FP8, the
video decoder's linears cast from f32 to bf16, the audio decoder's weight norms folded, the text
encoder's last 14 layers (which the model does not read) left out, and everything repacked into one
`.rad` file. The text encoder is Qwen3-VL-32B, licensed under the Apache License 2.0
(`LICENSE-Qwen3-VL`). The latent upscaler is LBH-123-AI's Minimax_h3_latent_Upscaler v1, licensed
under the Apache License 2.0 (`LICENSE-latent-upscaler`); its weights are included as published,
its embedding MLP cast from bf16 to f32.