Day 0 Support for MiniMax-H3 on AMD Instinct GPUs

Aug 02, 2026

MiniMax-H3 is MiniMax’s third-generation video model and a generational leap over its predecessors. Previous MiniMax video models (the Hailuo series) fragmented generation into separate expert pipelines for T2V, I2V, editing, and reference-driven tasks. H3 collapses all of these into a single unified model that jointly understands text, images, video, and audio, and generates video with native stereo audio at up to 2K resolution (1440p) and 15 seconds — up from 1080p and ~10 s in the prior generation. It also adds instruction-based video editing and omni-reference input, enabling subject-driven animation, voice cloning, and lip-sync in one pipeline. With open weights released under the MiniMax Community License, H3 is the strongest open-weight video generation model available today.

Under the hood, H3 is a flow-matching diffusion transformer that denoises joint video and audio latents, backed by a multimodal text encoder and dedicated video and audio VAEs. Serving it means driving a compute-heavy denoiser across a long spatiotemporal sequence split over many GPUs, plus heavyweight encode and decode stages — a workload shaped very differently from autoregressive LLM decoding. In this post we show how MiniMax-H3 runs on AMD Instinct™ MI355X and MI300X GPUs on Day 0 using SGLang on ROCm, with 8-way sequence parallelism and AMD’s AITER kernels. We cover the model architecture and weights, a complete SGLang deployment recipe for all three generation tasks through both entry points, and a walk-through of the AMD diffusion serving stack.

Generated by H3 on 8 × AMD Instinct MI355X GPUs, the following clip demonstrates the end-to-end result — a text-to-video+audio (t2va) output at 1344×768 with synchronized soundtrack, produced in a single diffusion pass:

MiniMax-H3 Architecture and Weights

MiniMax-H3 is not a single monolithic checkpoint but a diffusion pipeline of cooperating components, shipped as two task partitions that share the same runtime. Understanding how those pieces fit together explains how the model maps onto the AMD serving stack.

Generation tasks and model partitions

H3 exposes three generation tasks, split across two weight packages:

Partition

Task

Input conditioning

Output

FL2VA

t2va

Text only

Video + synchronized audio

FL2VA

fl2va

Text + first/last keyframe image

Video + synchronized audio

Ref2VA

ref2va

Text + reference image and/or reference audio

Video + synchronized audio with lip-sync

The FL2VA partition handles pure text-to-audio-video (t2va) and frame-conditioned generation (fl2va, where a supplied image pins the first or last frame). The Ref2VA partition handles reference-driven generation (ref2va): given a subject image and a reference audio track, it animates the subject and lip-syncs it to the audio. Each partition is a self-contained MiniMaxH3Pipeline and is served as its own SGLang instance; switching tasks across partitions means swapping the loaded model.

The pipeline components

Each partition bundles the following modules, loaded from the model directory via trust_remote_code (the custom model classes ship with the weights):

Component

Class

Role

Text encoder

Multimodal vision-language model

Encodes the prompt (and any image conditioning) into cross-attention states

Processor / tokenizer

Multimodal processor + tokenizer

Multimodal preprocessing of text and images

Diffusion transformer (DiT)

MiniMaxH3DiTModel

The core denoiser that jointly models video and audio latents

Video VAE

MiniMaxH3VideoVAE

Encodes/decodes the 24-channel video latent; temporal clip length 17, tiled decode

Audio VAE

MiniMaxH3AudioVAE

Decodes the 32-channel audio latent to 32 kHz stereo waveform

Scheduler

MiniMax-H3 Euler-ancestral flow-matching sampler

Flow-matching denoising, separate video/audio shift schedules

The diffusion transformer (DiT)

The heart of H3 is MiniMaxH3DiTModel, a joint audio-video diffusion transformer with the following configuration:

Property

Value

Hidden size

5376

Transformer layers

50 (+ 2 token-refiner layers)

Attention heads

56 × head dim 128 (7168 attention dim)

FFN hidden size

14336

Video latent channels

24

Audio latent channels

32

Patch size (T, H, W)

(1, 2, 2)

Text conditioning dim

5120

Position encoding

Rotary (RoPE)

Conditioning

adaptive LayerNorm (adaLN) from the diffusion timestep

Weights

BF16

The DiT flattens the video latent and the audio latent into a single long token sequence and denoises them together, so cross-modal attention is what keeps motion and sound aligned. Sampling uses flow matching over 50 steps by default, with separate flow-shift schedules for the two modalities (flow_shift = 12 for video, audio_flow_shift = 3 for audio).

Deploying MiniMax-H3 with SGLang on AMD Instinct GPUs

All results in this post were produced on a single node of 8 × AMD Instinct MI355X (gfx950) GPUs. The same recipe also targets MI300X (gfx942), where the AITER variable-length attention path is used. SGLang exposes two entry points for diffusion models — an asynchronous OpenAI-style HTTP service and an in-process offline DiffGenerator — and we validated all three tasks through both.

Environment setup

Pull and launch the ROCm SGLang image, mounting your model directory and a working directory:

		docker pull aigmkt/minimax-h3-sglang-gfx950-260801
	
		docker run -it --rm --network=host --privileged \ 
  --device=/dev/kfd --device=/dev/dri \ 
  --ipc=host --shm-size 32G --group-add video \ 
  --cap-add=SYS_PTRACE --security-opt seccomp=unconfined \ 
  -v /path/to/models:/models \ 
  -v /path/to/work:/work \ 
  aigmkt/minimax-h3-sglang-gfx950-260801 /bin/bash

For MI300X (gfx942), use the corresponding image:

		docker pull aigmkt/minimax-h3-sglang-gfx942-260801

The MiniMax-H3 model classes and the ROCm-specific adaptations are provided by an SGLang build with H3 support. Install it editable on top of the image’s ROCm PyTorch stack, using --no-deps so the working torch 2.9.1+rocm7.2.0 wheel is preserved:

		pip install --no-deps -e /work/sglang/python

Note: The AMD support PRs for MiniMax-H3 have been merged into SGLang. Upstream SGLang docker images with built-in H3 + ROCm support will be available soon.

Set up the environment. H3 uses 8-way sequence parallelism across all visible GPUs; ROCm PyTorch honors HIP_VISIBLE_DEVICES (and maps CUDA_VISIBLE_DEVICES), so export both:

		export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7
export HIP_VISIBLE_DEVICES=0,1,2,3,4,5,6,7

export MINIMAX_H3_FL2VA_MODEL_PATH=/models/MiniMax-H3/FL2VA   # serves t2va + fl2va
export MINIMAX_H3_REF2VA_MODEL_PATH=/models/MiniMax-H3/Ref2VA # serves ref2va

MP4 muxing relies on ffmpeg/ffprobe; install them if the image does not already ship them (apt-get install -y ffmpeg).

Option A — the asynchronous HTTP service

Launch a diffusion server for the FL2VA partition (which serves t2va and fl2va) on 8 GPUs with TP=1 and 8-way SP/Ulysses:

		sglang serve \
  --model-type diffusion \
  --model-path "$MINIMAX_H3_FL2VA_MODEL_PATH" \
  --num-gpus 8 --sp-degree 8 --ulysses-degree 8 \
  --trust-remote-code --warmup-mode off \
  --attention-backend aiter \
  --host 0.0.0.0 --port 30010 --strict-ports \
  --output-path /work/outputs/server-30010

Submit a text-to-audio-video (t2va) request. The target block controls resolution and duration; flow_shift / audio_flow_shift are the per-modality flow-matching schedules:

		curl -s http://localhost:30010/v1/videos \
  -H 'Content-Type: application/json' \
  -d '{
    "prompt": "In a snow-cloaked twilight forest, a small luminous spirit creeps along a fallen log while a huge sleeping beast slowly opens one eye. Footsteps crunch softly on snow; the creature breathes in a low rumble; the clip ends with a soft grunt and thud. overall_soundscape: quiet, atmospheric, crunching snow over deep breathing.",
    "task": "t2va",
    "conditions": [],
    "target": { "short_edge": 768, "aspect_ratio": "16:9", "duration_seconds": 8.7 },
    "seed": 1101, "n": 1,
    "num_inference_steps": 50, "flow_shift": 12, "audio_flow_shift": 3
  }'

The call returns a job id. Poll for completion and download the finished MP4:

		# Poll status until "completed"
curl -s http://localhost:30010/v1/videos/<job_id>

# Download the muxed video+audio MP4
curl -s "http://localhost:30010/v1/videos/<job_id>/content?output_index=0" -o t2va.mp4

First-frame conditioned (fl2va) requests add an image condition that pins a keyframe:

		{
  "prompt": "A man in a navy blazer stands by a yellow car and speaks to the camera.",
  "task": "fl2va",
  "conditions": [
    { "type": "image", "uri": "/work/assets/first_frame.jpg", "role": "keyframe", "frame_index": 0 }
  ],
  "target": { "short_edge": 768, "aspect_ratio": "auto", "duration_seconds": 8.7 },
  "seed": 1101, "n": 1,
  "num_inference_steps": 50, "flow_shift": 12, "audio_flow_shift": 3
}

Reference-driven (ref2va) requests target the Ref2VA partition. Launch a second server pointing at $MINIMAX_H3_REF2VA_MODEL_PATH, then submit a request with reference image and audio conditions — the model lip-syncs the subject to the supplied audio:

		{
  "prompt": "A white cat with black mustache-like markings sits on a couch and lip-syncs to the reference audio, its expression shifting from confusion to deadpan.",
  "task": "ref2va",
  "conditions": [
    { "type": "image", "uri": "/work/assets/ref_image.jpg", "role": "reference" },
    { "type": "audio", "uri": "/work/assets/ref_audio.ogg", "role": "reference" }
  ],
  "target": { "short_edge": 768, "aspect_ratio": "auto", "duration_seconds": 5 },
  "seed": 3101, "n": 1,
  "num_inference_steps": 50, "flow_shift": 12, "audio_flow_shift": 3
}

Conditioning assets can be referenced as local paths / file://, http(s)://, or inline data: (base64) URIs.

Option B — the offline DiffGenerator

For batch or scripted generation, DiffGenerator runs the whole pipeline in-process without an HTTP server:

		import json, os, multiprocessing as mp
from pathlib import Path
from sglang.multimodal_gen import DiffGenerator

def main():
    request = json.loads(Path("request.t2va.json").read_text())
    request["num_outputs_per_prompt"] = request.pop("n", 1)
    request.update(save_output=True, return_file_paths_only=True,
                   output_path="./outputs/t2va", output_file_name="t2va.mp4")

    with DiffGenerator.from_pretrained(
        model_path=os.environ["MINIMAX_H3_FL2VA_MODEL_PATH"],
        num_gpus=8, sp_degree=8, ulysses_degree=8,
        trust_remote_code=True, warmup_mode="off",
        output_path="./outputs/t2va",
    ) as generator:
        result = generator.generate(sampling_params_kwargs=request)
    for item in (result if isinstance(result, list) else [result]):
        print(item.output_file_path)

if __name__ == "__main__":
    mp.freeze_support()   # required on ROCm: the diffusion runtime uses spawn
    main()

ROCm note: SGLang’s diffusion runtime uses the multiprocessing spawn start method (safer with HIP), which re-imports the launching module in each worker. The if __name__ == "__main__": guard plus mp.freeze_support() is therefore required — without it, the re-import re-runs generation and the process crashes during bootstrapping

AMD Diffusion Serving Stack with SGLang

Serving H3 at production quality requires every layer of the stack — from the ROCm runtime up through SGLang’s diffusion orchestration — to cooperate on a workload that looks very different from LLM decoding.

SGLang (diffusion runtime) provides a serving layer for diffusion models like H3. It exposes an OpenAI-style asynchronous /v1/videos API and an in-process DiffGenerator, and manages the full generation pipeline — input validation, partition admission, text/visual/audio encoding, latent and timestep preparation, denoising, and decoding. It handles sequence/Ulysses parallelism for splitting the joint spatiotemporal sequence across GPUs, CPU offload of the DiT and VAEs to conserve HBM, and remote-code loading of model-specific classes. On ROCm it drives distributed execution over RCCL with the multiprocessing spawn start method.

AITER (AI Tensor Engine for ROCm) supplies the inference-critical kernels on the denoising hot path: attention and GEMM across BF16 and FP8, with per-architecture dispatch so each AMD GPU generation runs the fastest available code path. The DiT uses AITER variable-length attention (specified via --attention-backend aiter), which provides the largest denoising speedup (~1.4× faster than the Torch SDPA fallback).

ROCm™ software is the AMD open-source accelerator software platform — the HIP runtime, compiler, and core libraries (RCCL for collectives, plus the math libraries the VAEs and encoder rely on) that all higher layers build on.

ROCm-specific adaptations

A handful of targeted adaptations let H3 run cleanly on AMD Instinct GPUs without touching the model math:

  • Attention backend selection: On ROCm the DiT uses AITER packed variable-length attention on both MI300X (gfx942) and MI355X (gfx950), with a Torch SDPA fallback available when needed. This keeps attention correct and fast across both architectures.
  • Video VAE decode precision: On gfx950 the video VAE decode path is pinned to the numerically robust math SDPA backend to guarantee correct pixel reconstruction.
  • Spawn-safe launching: As noted above, the offline path is made spawn-safe with a __main__ guard so the ROCm multiprocessing model works reliably.

Summary

In this blog, we demonstrated Day 0 support for MiniMax-H3 on AMD Instinct MI355X and MI300X GPUs using SGLang on ROCm. We validated all three generation tasks — text-to-video+audio, first-frame conditioned, and reference-driven lip-sync — through both the asynchronous HTTP API and the offline DiffGenerator, and walked through the model architecture and AMD serving stack. Looking ahead, throughput optimization, batched generation, and further kernel tuning will continue to push diffusion serving performance on AMD hardware.

Additional Resources

Footnotes

Disclaimers

The information presented in this document is for informational purposes only and may contain technical inaccuracies, omissions, and typographical errors. The information contained herein is subject to change and may be rendered inaccurate for many reasons, including but not limited to product and roadmap changes, component and motherboard version changes, new model and/or product releases, product differences between differing manufacturers, software changes, BIOS flashes, firmware upgrades, or the like. Any computer system has risks of security vulnerabilities that cannot be completely prevented or mitigated. AMD assumes no obligation to update or otherwise correct or revise this information. However, AMD reserves the right to revise this information and to make changes from time to time to the content hereof without obligation of AMD to notify any person of such revisions or changes. THIS INFORMATION IS PROVIDED ’AS IS.” AMD MAKES NO REPRESENTATIONS OR WARRANTIES WITH RESPECT TO THE CONTENTS HEREOF AND ASSUMES NO RESPONSIBILITY FOR ANY INACCURACIES, ERRORS, OR OMISSIONS THAT MAY APPEAR IN THIS INFORMATION. AMD SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR ANY PARTICULAR PURPOSE. IN NO EVENT WILL AMD BE LIABLE TO ANY PERSON FOR ANY RELIANCE, DIRECT, INDIRECT, SPECIAL, OR OTHER CONSEQUENTIAL DAMAGES ARISING FROM THE USE OF ANY INFORMATION CONTAINED HEREIN, EVEN IF AMD IS EXPRESSLY ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. AMD, the AMD Arrow logo, and combinations thereof are trademarks of Advanced Micro Devices, Inc. Other product names used in this publication are for identification purposes only and may be trademarks of their respective companies. Third-party content is licensed to you directly by the third party that owns the content and is not licensed to you by AMD. ALL LINKED THIRD-PARTY CONTENT IS PROVIDED “AS IS” WITHOUT A WARRANTY OF ANY KIND. USE OF SUCH THIRD-PARTY CONTENT IS DONE AT YOUR SOLE DISCRETION AND UNDER NO CIRCUMSTANCES WILL AMD BE LIABLE TO YOU FOR ANY THIRD-PARTY CONTENT. YOU ASSUME ALL RISK AND ARE SOLELY RESPONSIBLE FOR ANY DAMAGES THAT MAY ARISE FROM YOUR USE OF THIRD-PARTY CONTENT. (c) 2026 Advanced Micro Devices, Inc. All rights reserved.

Share:

Related Blogs

View All Blogs