diff --git a/docs/source/en/_toctree.yml b/docs/source/en/_toctree.yml
index 8466cebe2a8c..2d0bf5707ad9 100644
--- a/docs/source/en/_toctree.yml
+++ b/docs/source/en/_toctree.yml
@@ -375,6 +375,8 @@
         title: Lumina2Transformer2DModel
       - local: api/models/lumina_nextdit2d
         title: LuminaNextDiT2DModel
+      - local: api/models/minimax_h3_transformer3d
+        title: MiniMaxH3Transformer3DModel
       - local: api/models/mochi_transformer3d
         title: MochiTransformer3DModel
       - local: api/models/motif_video_transformer_3d
@@ -459,6 +461,10 @@
         title: AutoencoderKLLTXVideo
       - local: api/models/autoencoderkl_magvit
         title: AutoencoderKLMagvit
+      - local: api/models/autoencoderkl_minimax_h3
+        title: AutoencoderKLMiniMaxH3
+      - local: api/models/autoencoderkl_minimax_h3_audio
+        title: AutoencoderKLMiniMaxH3Audio
       - local: api/models/autoencoderkl_mochi
         title: AutoencoderKLMochi
       - local: api/models/autoencoderkl_qwenimage
@@ -691,6 +697,8 @@
         title: LTX-2
       - local: api/pipelines/ltx_video
         title: LTXVideo
+      - local: api/pipelines/minimax_h3
+        title: MiniMax-H3
       - local: api/pipelines/mochi
         title: Mochi
       - local: api/pipelines/motif_video
@@ -770,6 +778,8 @@
       title: LCMScheduler
     - local: api/schedulers/lms_discrete
       title: LMSDiscreteScheduler
+    - local: api/schedulers/minimax_h3
+      title: MiniMaxH3Scheduler
     - local: api/schedulers/pndm
       title: PNDMScheduler
     - local: api/schedulers/repaint
diff --git a/docs/source/en/api/models/autoencoderkl_minimax_h3.md b/docs/source/en/api/models/autoencoderkl_minimax_h3.md
new file mode 100644
index 000000000000..2fc7f4a07a69
--- /dev/null
+++ b/docs/source/en/api/models/autoencoderkl_minimax_h3.md
@@ -0,0 +1,38 @@
+<!-- Copyright 2026 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License. -->
+
+# AutoencoderKLMiniMaxH3
+
+The video variational autoencoder (VAE) model with KL loss used in [MiniMax-H3](https://huggingface.co/MiniMaxAI) by MiniMax. It pairs a causal 3D CNN encoder with a non-causal ViT decoder and compresses 16x spatially and 4x temporally.
+
+Three things set it apart from most autoencoders in the library:
+
+- **Latents are normalized per channel.** There is no `scaling_factor`: a pipeline encodes with `(latent - latents_mean) / latents_std` and decodes with `latent * latents_std + latents_mean`.
+- **The pixel convention is ImageNet-normalized RGB over a `[0, 1]` base range**, not the usual `[-1, 1]`. `encode` expects `(pixel - imagenet_mean) / imagenet_std` and `decode` returns values in that same space, so a pipeline applies `sample * imagenet_std + imagenet_mean` and clamps to `[0, 1]` before postprocessing.
+- **Spatial tiling is on by default.** MiniMax-H3 was released with tiling enabled for both encoding and decoding and the released frames are the blended-tile ones, so turning it off changes the output. Use `enable_tiling` to change the tile geometry and `disable_tiling` to switch it off.
+
+The temporal geometry is fixed by `clip_length` (17 pixel frames per encoder chunk) and `token_drop` (3 trailing latent frames dropped per encode), so `17 * n + 5` pixel frames map to `5 * n + 2` latent frames.
+
+```python
+import torch
+from diffusers import AutoencoderKLMiniMaxH3
+
+vae = AutoencoderKLMiniMaxH3.from_pretrained(
+    "MiniMaxAI/MiniMax-H3", subfolder="vae", dtype=torch.float32
+).to("cuda")
+```
+
+## AutoencoderKLMiniMaxH3
+
+[[autodoc]] AutoencoderKLMiniMaxH3
+    - encode
+    - decode
+    - all
diff --git a/docs/source/en/api/models/autoencoderkl_minimax_h3_audio.md b/docs/source/en/api/models/autoencoderkl_minimax_h3_audio.md
new file mode 100644
index 000000000000..ab78da3f5e32
--- /dev/null
+++ b/docs/source/en/api/models/autoencoderkl_minimax_h3_audio.md
@@ -0,0 +1,36 @@
+<!-- Copyright 2026 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License. -->
+
+# AutoencoderKLMiniMaxH3Audio
+
+The audio autoencoder used in [MiniMax-H3](https://huggingface.co/MiniMaxAI) by MiniMax. It is waveform in and waveform out, with no mel front-end and no separate vocoder: a DAC-lineage strided convolutional encoder, a causal-attention projection onto the diffusion latent width, and a BigVGAN decoder.
+
+The encoder hops 800 samples at 32 kHz, i.e. 40 latents per second, so a waveform of `800 * n` samples encodes to `n` latents. Waveforms that are not a whole number of hops are right-padded.
+
+The causal-attention projection goes through the attention dispatcher, so `set_attention_backend` applies to it; its mask is `is_causal=True`, which every backend honours except `_native_npu`, whose kernel takes no causal flag.
+
+The autoencoder is **mono**, and it normalizes latents per channel with `latents_mean` / `latents_std` rather than a scalar `scaling_factor`. MiniMax-H3 carries stereo as two *batch* items, and it always consumes the posterior mean (`latent_dist.mode()`), never a sample.
+
+```python
+import torch
+from diffusers import AutoencoderKLMiniMaxH3Audio
+
+audio_vae = AutoencoderKLMiniMaxH3Audio.from_pretrained(
+    "MiniMaxAI/MiniMax-H3", subfolder="audio_vae", dtype=torch.float32
+).to("cuda")
+```
+
+## AutoencoderKLMiniMaxH3Audio
+
+[[autodoc]] AutoencoderKLMiniMaxH3Audio
+    - encode
+    - decode
+    - all
diff --git a/docs/source/en/api/models/minimax_h3_transformer3d.md b/docs/source/en/api/models/minimax_h3_transformer3d.md
new file mode 100644
index 000000000000..b027a6ed0f0c
--- /dev/null
+++ b/docs/source/en/api/models/minimax_h3_transformer3d.md
@@ -0,0 +1,41 @@
+<!-- Copyright 2026 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License. -->
+
+# MiniMaxH3Transformer3DModel
+
+A Diffusion Transformer model for joint video and audio generation, introduced in [MiniMax-H3](https://huggingface.co/MiniMaxAI) by MiniMax.
+
+MiniMax-H3 runs a single stack of blocks over **one packed 1-D sequence** that holds the text conditioning, the conditioning image and video rows, the audio rows and the target video rows at once. Attention is full self-attention over that sequence, so there is no cross-attention and no per-modality block weights. Modality-specific behaviour comes only from the two input patch projections, the per-row modality tag that selects the AdaLN modulation parameters, and the two output heads.
+
+Building the packed layout is the caller's job, which is why the forward signature takes the layout apart from the latents: the `(t, h, w)` position grid, the per-row modality tags, the per-row timestep indices and the three index tensors that address the video, audio and text rows. [`MiniMaxH3Blocks`] and [`MiniMaxH3Ref2VABlocks`] build all of it.
+
+A layout that carries padding rows (tag `-1`) needs a masked attention backend, since those rows are kept in their own attention document by a boolean mask; a padless sequence needs no mask and keeps every backend available.
+
+One repository holds both released checkpoint partitions, so the subfolder is what selects the task: `transformer/` for the text and keyframe tasks, `transformer_ref/` for the omni-reference task.
+
+```python
+import torch
+from diffusers import MiniMaxH3Transformer3DModel
+
+transformer = MiniMaxH3Transformer3DModel.from_pretrained(
+    "MiniMaxAI/MiniMax-H3", subfolder="transformer", dtype=torch.bfloat16
+).to("cuda")
+```
+
+The checkpoint is mixed precision: the two input patch projections, the timestep MLP and the two output heads are float32 while the block stack is bfloat16. `from_pretrained` keeps that layout through `_keep_in_fp32_modules`, so pass `dtype=torch.bfloat16` and let it place the float32 modules rather than casting the model with `.to(torch.bfloat16)` afterwards.
+
+## MiniMaxH3Transformer3DModel
+
+[[autodoc]] MiniMaxH3Transformer3DModel
+
+## MiniMaxH3TransformerOutput
+
+[[autodoc]] models.transformers.transformer_minimax_h3.MiniMaxH3TransformerOutput
diff --git a/docs/source/en/api/pipelines/minimax_h3.md b/docs/source/en/api/pipelines/minimax_h3.md
new file mode 100644
index 000000000000..cccf2d712b64
--- /dev/null
+++ b/docs/source/en/api/pipelines/minimax_h3.md
@@ -0,0 +1,270 @@
+<!-- Copyright 2026 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License. -->
+
+# MiniMax-H3
+
+<!-- Remove this note once the pull request is merged. -->
+> [!TIP]
+> MiniMax-H3 is not part of a diffusers release yet. Install diffusers from the pull request to use it:
+> `pip install git+https://github.com/huggingface/diffusers.git@refs/pull/14355/head`
+
+
+MiniMax-H3 generates video and its soundtrack **jointly**. One transformer denoises a single packed sequence that holds the text conditioning, the conditioning image, video and audio rows, the target audio rows and the target video rows at once, with full self-attention over all of it. There is no separate vocoder and no audio post-hoc pass: video and audio come out of the same denoising loop.
+
+You can find the original MiniMax-H3 checkpoints under the [MiniMaxAI](https://huggingface.co/MiniMaxAI) organization.
+
+MiniMax-H3 is integrated as [Modular Diffusers](../../modular_diffusers/overview) blocks only, the way [Anima](./anima) is: the blocks and their [`MiniMaxH3ModularPipeline`] are the whole integration, and there is no `DiffusionPipeline` half.
+
+## Checkpoint layout
+
+MiniMax-H3 was released as two checkpoint partitions that share every component except the transformer, so the diffusers conversion puts both in **one repository**:
+
+| Subfolder | Blocks | Tasks |
+|---|---|---|
+| `transformer/` | [`MiniMaxH3Blocks`] | `t2va` (text only) and `fl2va` (first and/or last keyframe) |
+| `transformer_ref/` | [`MiniMaxH3Ref2VABlocks`] | `ref2va` (an ordered mix of image, video and audio references) |
+
+Everything but the transformer, i.e. the video VAE, the audio VAE, the Qwen3-VL conditioner, its tokenizer and processor, and the two schedulers, is shared and stored once.
+
+The repository carries one `modular_model_index.json`, which names every component of both halves with its own loading spec. Each blockset declares only the components it runs, and `load_components` fetches exactly those subfolders: loading the `t2va` / `fl2va` half never touches `transformer_ref/`, and loading the `ref2va` half never touches `transformer/`. Nothing else in the repository is fetched either, which is what lets one repository carry the two partitions, and the original checkpoint folders next to the converted ones.
+
+`modular_model_index.json` names the `t2va` / `fl2va` half as its own class, so [`~ModularPipeline.from_pretrained`] resolves that half. The `ref2va` half reads the very same file through its own blocks:
+
+```py
+import torch
+from diffusers import ModularPipeline
+from diffusers.modular_pipelines import MiniMaxH3Ref2VABlocks
+
+# `t2va` / `fl2va`: loads `transformer/`, and never `transformer_ref/`.
+pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3")
+
+# `ref2va`: loads `transformer_ref/`, and never `transformer/`, out of the same repository.
+pipe = MiniMaxH3Ref2VABlocks().init_pipeline("MiniMaxAI/MiniMax-H3")
+
+pipe.load_components(dtype=torch.bfloat16)
+```
+
+Each blockset also carries the workflows it serves — `t2va`, `fl2va` and `fl2va_last_frame` for [`MiniMaxH3Blocks`], `ref2va` for [`MiniMaxH3Ref2VABlocks`] — which name the inputs each task requires.
+
+The conditioner is a `Qwen3VLForConditionalGeneration`, and MiniMax-H3 reads the *unnormalized* hidden state after its 50th decoder layer rather than the last one, so the full released checkpoint is used with its language-model head unused.
+
+## Two schedulers
+
+Video and audio latents step down two different schedules inside a single transformer call per step, which is why both blocksets expect two [`MiniMaxH3Scheduler`] instances: `scheduler` for the video latents (`shift=12.0` in the released checkpoints) and `audio_scheduler` for the audio latents (`shift=3.0`).
+
+The checkpoint is guidance-distilled: guidance is baked into the weights, so there is no guider, no `negative_prompt` and no `guidance_scale`, and every step runs exactly one forward pass.
+
+## Generation constraints
+
+- **24 fps, 5 to 15 seconds.** `num_frames` is snapped up to the next `17 * n + 5` the video VAE can decode, and the resulting duration has to stay in that window.
+- **A 768 pixel short edge.** `height` and `width` default to MiniMax-H3's own canvas for the aspect ratio of the first keyframe (or 16:9 without one) and must be multiples of 32.
+- **One generator, three draws.** A request draws the keyframe or reference conditioning noise first, then the video noise, then the audio noise, all from the `generator` it is passed, so two runs from the same generator state return the same video and soundtrack. Passing `latents` or `audio_latents` replaces the corresponding draw.
+- **`num_inference_steps` counts sigma grid points**, the terminal `0` included, so it drives one model evaluation less.
+
+## Memory
+
+The transformer alone is 61.7 GB in bfloat16 and the Qwen3-VL conditioner is another 62.1 GB, so the loading recipe depends on the hardware. Smaller canvases are the biggest speed lever on every setup: `height` and `width` only have to be multiples of 32, and 960x544 runs about 2.3x faster per step than the trained 1344x768.
+
+On one 80 GB card, register the components in a [`ComponentsManager`] and let it move them on and off the accelerator:
+
+```py
+import torch
+from diffusers import ComponentsManager, ModularPipeline
+
+manager = ComponentsManager()
+pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3", components_manager=manager)
+pipe.load_components(dtype=torch.bfloat16)
+manager.enable_auto_cpu_offload(device="cuda", memory_reserve_margin="12GB")
+pipe.transformer.set_attention_backend("_flash_3_hub")  # Hopper, roughly 3x faster; kernels fetched from the Hub
+```
+
+On a consumer card (24 to 32 GB), quantize the two large components to int8 as they load and stream the transformer's blocks from CPU RAM. Everything below uses supported loaders only, no patches, and works straight from the bfloat16 checkpoint:
+
+```py
+import torch
+from diffusers import MiniMaxH3Transformer3DModel, ModularPipeline, TorchAoConfig
+from diffusers.hooks import apply_group_offloading
+from transformers import Qwen3VLForConditionalGeneration
+from transformers import TorchAoConfig as TransformersTorchAoConfig
+from torchao.quantization import Int8WeightOnlyConfig
+
+pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3")
+pipe.update_components(
+    transformer=MiniMaxH3Transformer3DModel.from_pretrained(
+        "MiniMaxAI/MiniMax-H3", subfolder="transformer", dtype=torch.bfloat16,
+        quantization_config=TorchAoConfig(
+            Int8WeightOnlyConfig(version=2),
+            modules_to_not_convert=[
+                "proj_in", "audio_proj_in", "context_embedder", "time_embedder", "time_proj",
+                "token_refiner", "norm_out", "proj_out", "audio_proj_out",
+            ],
+        ),
+        low_cpu_mem_usage=False,
+    ),
+    text_encoder=Qwen3VLForConditionalGeneration.from_pretrained(
+        "MiniMaxAI/MiniMax-H3", subfolder="text_encoder", dtype=torch.bfloat16,
+        quantization_config=TransformersTorchAoConfig(
+            Int8WeightOnlyConfig(version=2),
+            modules_to_not_convert=["model.visual", "model.language_model.embed_tokens", "model.language_model.norm", "lm_head"],
+        ),
+    ),
+)
+pipe.load_components(dtype=torch.bfloat16)
+
+# version=2 int8 tensors are pinnable, which streamed offload needs, and freezing removes the one autograd
+# path the quantized tensors cannot serve.
+pipe.transformer.requires_grad_(False)
+pipe.text_encoder.requires_grad_(False)
+
+offload = dict(onload_device=torch.device("cuda"), offload_device=torch.device("cpu"), use_stream=True)
+pipe.transformer.enable_group_offload(offload_type="block_level", num_blocks_per_group=1, **offload)
+apply_group_offloading(pipe.text_encoder.model, offload_type="leaf_level", **offload)
+pipe.vae.to("cuda")
+pipe.audio_vae.to("cuda")
+```
+
+On 12 to 16 GB the same recipe works with the video VAE group offloaded too (`offload_type="leaf_level"`, no stream) and a small canvas such as 960x544. Expect the weights to live in host RAM: around 75 GB of it at int8.
+
+With two cards nothing has to be offloaded: the conditioner takes the second card through a `device_map` and the denoiser keeps the first.
+
+```py
+import torch
+from diffusers import ComponentsManager, ModularPipeline
+from transformers import Qwen3VLForConditionalGeneration
+
+manager = ComponentsManager()
+pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3", components_manager=manager)
+pipe.update_components(
+    text_encoder=Qwen3VLForConditionalGeneration.from_pretrained(
+        "MiniMaxAI/MiniMax-H3", subfolder="text_encoder", dtype=torch.bfloat16, device_map={"": "cuda:1"}
+    ),
+)
+pipe.load_components(dtype=torch.bfloat16)
+pipe.transformer.to("cuda:0")
+pipe.vae.to("cuda:0")
+pipe.audio_vae.to("cuda:0")
+```
+
+Two 80 GB cards run full bfloat16 this way with nothing streaming; two 48 GB cards do the same with the int8 loading above on both components.
+
+## Text and keyframes
+
+[`MiniMaxH3Blocks`] covers text-to-video-and-audio and keyframe conditioning. A keyframe can be the frame the video starts from (`image`), the frame it ends on (`last_image`), or both.
+
+```py
+import torch
+from diffusers import ModularPipeline
+from diffusers.utils import load_image
+from diffusers.utils.export_utils import encode_video
+
+pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3")
+pipe.load_components(dtype=torch.bfloat16)
+pipe.to("cuda")
+
+prompt = "A red fox trotting through a snowy pine forest, snow crunching underfoot"
+
+# Text to video + audio.
+state = pipe(prompt=prompt, generator=torch.Generator().manual_seed(42))
+
+# First frame (and optionally last frame) to video + audio. The canvas follows the first keyframe.
+image = load_image(
+    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg"
+)
+state = pipe(prompt=prompt, image=image, generator=torch.Generator().manual_seed(42))
+
+encode_video(
+    state.get("videos")[0],
+    fps=24,
+    output_path="minimax_h3_fl2va.mp4",
+    audio=state.get("audio")[0],
+    audio_sample_rate=state.get("sampling_rate"),
+)
+```
+
+Video and audio are generated jointly and come out of the call as separate outputs, `videos` and `audio`, next to the `sampling_rate` the soundtrack carries; muxing them into one file is left to the caller, e.g. with [`~utils.export_utils.encode_video`].
+
+## Omni-references
+
+[`MiniMaxH3Ref2VABlocks`] conditions on an ordered list of references: up to 9 images, 3 videos and 3 audio clips, 12 in total. The order is semantic. It labels the references in the prompt presentation (`"<Picture 1>"`, `"<Audio 1>"`, `"<Video 1>"`) and it advances the shared audio/video rotary clock, so reordering the same references is a different request.
+
+Unlike the keyframes above, references do not bind the generated geometry: they are encoded at their own resolution and the target canvas defaults to MiniMax-H3's 16:9.
+
+Every reference is a [`~modular_pipelines.minimax_h3.MiniMaxH3Reference`], and it takes a path or a URL as well as in-memory media: a path is decoded when the reference is built, with [`~utils.load_image`] for an image and [PyAV](https://github.com/PyAV-Org/PyAV) for a video or an audio file, so the blocks themselves never open a media file. Decoding brings the rates along, which is what the model needs: a video reference reads its frame rate off the container and adopts the container's soundtrack when it has one, and an audio reference its sample rate.
+
+In-memory media declares the rates it carries instead, defaulting to MiniMax-H3's own: `fps=24.0` and the audio VAE's sample rate, so only self-generated data at another rate has to say so. An explicit `fps` or `sample_rate` also wins over a container whose metadata is wrong. Frames are resampled onto MiniMax-H3's own 24 fps by dropping and duplicating whole frames, and a waveform onto the audio VAE's sample rate. A video reference conditions on its motion **and**, when it carries an `audio` waveform, on that soundtrack, which is then packed as this reference's own.
+
+```py
+import torch
+from diffusers.modular_pipelines import MiniMaxH3Ref2VABlocks
+from diffusers.modular_pipelines.minimax_h3 import MiniMaxH3Reference
+from diffusers.utils import load_image, load_video
+from diffusers.utils.export_utils import encode_video
+
+pipe = MiniMaxH3Ref2VABlocks().init_pipeline("MiniMaxAI/MiniMax-H3")
+pipe.load_components(dtype=torch.bfloat16)
+pipe.to("cuda")
+
+subject = load_image(
+    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg"
+)
+
+# A reference decodes a path or a URL as it is built, rates included: the video brings its own frame rate and its
+# soundtrack, the audio clip its sample rate.
+state = pipe(
+    prompt="The character speaks in time with the reference recording, natural lip movement",
+    references=[
+        MiniMaxH3Reference(image=subject),
+        MiniMaxH3Reference(
+            video="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/hiker.mp4"
+        ),
+        MiniMaxH3Reference(audio="voice.wav"),
+    ],
+    num_frames=124,
+)
+
+# In-memory media says which rates it carries, MiniMax-H3's own by default.
+motion = load_video("motion_ref.mp4")
+state = pipe(
+    prompt="The subject walks toward camera, matching the reference video's shot rhythm",
+    references=[MiniMaxH3Reference(image=subject), MiniMaxH3Reference(video=motion, fps=30.0)],
+    num_frames=124,
+)
+
+encode_video(
+    state.get("videos")[0],
+    fps=24,
+    output_path="minimax_h3_ref2va.mp4",
+    audio=state.get("audio")[0],
+    audio_sample_rate=state.get("sampling_rate"),
+)
+```
+
+`num_frames` may be left out, but only when exactly one reference carries audio: the duration is then that soundtrack's, snapped up to the next `17 * n + 5` the video VAE can decode. A soundtrack whose *aligned* duration falls outside the 5 to 15 seconds MiniMax-H3 generates is rejected rather than silently stretched, so a clip just under 15 seconds — which rounds up to 362 frames, i.e. 15.083 seconds — has to name a shorter `num_frames` explicitly.
+
+## MiniMaxH3ModularPipeline
+
+[[autodoc]] MiniMaxH3ModularPipeline
+
+## MiniMaxH3Blocks
+
+[[autodoc]] MiniMaxH3Blocks
+
+## MiniMaxH3Ref2VAModularPipeline
+
+[[autodoc]] MiniMaxH3Ref2VAModularPipeline
+
+## MiniMaxH3Ref2VABlocks
+
+[[autodoc]] MiniMaxH3Ref2VABlocks
+
+## MiniMaxH3Reference
+
+[[autodoc]] modular_pipelines.minimax_h3.MiniMaxH3Reference
diff --git a/docs/source/en/api/schedulers/minimax_h3.md b/docs/source/en/api/schedulers/minimax_h3.md
new file mode 100644
index 000000000000..83c178fa3ac8
--- /dev/null
+++ b/docs/source/en/api/schedulers/minimax_h3.md
@@ -0,0 +1,23 @@
+<!--Copyright 2026 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+-->
+
+# MiniMaxH3Scheduler
+
+`MiniMaxH3Scheduler` is the rectified-flow Euler scheduler (`eta = 0`) with an exponential sigma shift used by [MiniMax-H3](https://huggingface.co/MiniMaxAI), `sigma' = s * sigma / (1 + (s - 1) * sigma)`.
+
+The MiniMax-H3 pipelines register **two** of them, because video and audio latents step down two different schedules inside a single transformer call per step: `scheduler` carries the video schedule (`shift=12.0` in the released checkpoints) and `audio_scheduler` the audio one (`shift=3.0`).
+
+## MiniMaxH3Scheduler
+[[autodoc]] MiniMaxH3Scheduler
+
+## MiniMaxH3SchedulerOutput
+[[autodoc]] schedulers.scheduling_minimax_h3.MiniMaxH3SchedulerOutput
diff --git a/scripts/convert_minimax_h3_to_diffusers.py b/scripts/convert_minimax_h3_to_diffusers.py
new file mode 100644
index 000000000000..337d6c0e6816
--- /dev/null
+++ b/scripts/convert_minimax_h3_to_diffusers.py
@@ -0,0 +1,947 @@
+"""Convert an original MiniMax-H3 checkpoint into the diffusers layout.
+
+The transformer checkpoint is streamed shard by shard, so peak memory stays close to a single shard (~4.9 GiB) and
+never approaches the 62 GiB of the full 33B DiT.
+
+Every source key maps onto a diffusers module by renaming alone, except for three things:
+
+* the fused QKV projection is split into `to_q` / `to_k` / `to_v`. Raw checkpoint shards store QKV per-head
+  interleaved; the shard streamer first reorders them into the reference's in-memory `[q_all; k_all; v_all]` layout
+  (`reorder_interleaved_qkv`, mirroring the reference's load-time transform), then `convert_transformer_key` splits
+  contiguous thirds (`split_fused_qkv`),
+* the gated FFN's fused `mlp.fc1` becomes `ff.net.0.proj` and its two halves are swapped, because diffusers'
+  [`SwiGLU`] reads `[value; gate]` where the reference stores `[gate; value]` (the same transform the video VAE needs,
+  see `convert_video_vae_key`); `mlp.fc2` becomes `ff.net.2`,
+* `rope.inv_freq` is dropped: it is a pure function of `rope_theta` and `rope_freq_dim`, the port recomputes it in a
+  non-persistent buffer, and the recomputed value is bitwise equal to the shipped one for both released variants.
+
+There are no transposes anywhere.
+
+The FL2VA and Ref2VA variants differ only in the transformer weights, so the variant is selected by pointing
+`--checkpoint_path` at the corresponding folder. Both land in one repository, which carries a single
+`modular_model_index.json`: MiniMax-H3 is integrated as Modular Diffusers blocks only, so no `model_index.json` is
+written.
+
+Usage:
+
+```bash
+# Validate the key mapping without any weights present.
+python scripts/convert_minimax_h3_to_diffusers.py \
+    --checkpoint_path /path/to/MiniMax-H3/FL2VA --output_path /tmp/h3-diffusers --dry_run
+
+# Convert, and point the component loading specs at the Hub id the result is published under.
+python scripts/convert_minimax_h3_to_diffusers.py \
+    --checkpoint_path /path/to/MiniMax-H3/FL2VA --output_path /tmp/h3-diffusers \
+    --modular_repo_id MiniMaxAI/MiniMax-H3
+```
+"""
+
+import argparse
+import glob
+import json
+import math
+import os
+import struct
+from typing import Any
+
+import torch
+from safetensors import safe_open
+from safetensors.torch import save_file
+
+from diffusers.models.autoencoders.autoencoder_kl_minimax_h3_audio import AutoencoderKLMiniMaxH3Audio
+from diffusers.utils.constants import SAFE_WEIGHTS_INDEX_NAME
+
+
+# `MiniMaxH3Transformer3DModel` argument names. The original config uses the sglang-native names listed in the
+# comments; everything else in the original config (`adaln_out_features`, `final_adaln_out_features`) is derived.
+MINIMAX_H3_TRANSFORMER_CONFIG = {
+    "num_attention_heads": 56,
+    "attention_head_dim": 128,
+    "hidden_size": 5376,
+    "num_layers": 50,
+    "num_refiner_layers": 2,  # token_refiner_num_layers
+    "ffn_dim": 14336,  # ffn_hidden_size
+    "in_channels": 24,  # latents_dim
+    "audio_in_channels": 32,  # audio_latents_dim
+    "patch_size": [1, 2, 2],
+    "text_dim": 5120,
+    "freq_dim": 256,  # timestep_input_dim
+    "time_embed_hidden_dim": 5376,  # time_embed_hidden_size
+    "time_embed_dim": 2688,
+    "rope_freq_dim": 16,  # rope_inv_freq_len
+    "rope_theta": 10000.0,
+    "norm_eps": 1e-05,
+    "qk_norm_eps": 1e-05,
+    "final_norm_eps": 1e-05,
+}
+
+# A tiny configuration with the checkpoint-tied dimensions left intact, for building fixtures.
+MINIMAX_H3_TEST_TRANSFORMER_CONFIG = {
+    **MINIMAX_H3_TRANSFORMER_CONFIG,
+    "num_attention_heads": 2,
+    "attention_head_dim": 32,
+    "hidden_size": 64,
+    "num_layers": 2,
+    "num_refiner_layers": 2,
+    "ffn_dim": 128,
+    "text_dim": 48,
+    "freq_dim": 16,
+    "time_embed_hidden_dim": 64,
+    "time_embed_dim": 32,
+    "rope_freq_dim": 4,
+}
+
+# MiniMax-H3 ships a mixed-precision checkpoint. These *original* keys are float32; everything else is bfloat16 —
+# including the AdaLN projections.
+MINIMAX_H3_FP32_SOURCE_PREFIXES = (
+    "video_patch_proj.",
+    "audio_patch_proj.",
+    "time_embedder.",
+    "final_layer.video_out.",
+    "final_layer.audio_out.",
+)
+
+# `rope.inv_freq` is `1 / rope_theta ** (arange(0, 2 * rope_freq_dim, 2) / (2 * rope_freq_dim))`, which
+# `MiniMaxH3RotaryPosEmbed` recomputes into a non-persistent buffer. The recomputed tensor is bitwise equal to the
+# shipped one in both released variants, so the key is not carried into the diffusers checkpoint.
+MINIMAX_H3_TRANSFORMER_DROPPED_KEYS = ("rope.inv_freq",)
+
+
+def reorder_interleaved_qkv(weight: torch.Tensor, num_attention_heads: int, attention_head_dim: int) -> torch.Tensor:
+    """Reorder a *raw-checkpoint* per-head-interleaved fused QKV weight into `[q_all; k_all; v_all]`.
+
+    The original checkpoint shards store rows as `[head0: q(head_dim) k(head_dim) v(head_dim), head1: q, k, v, ...]`.
+    The reference implementation applies exactly this reorder at load time (`_reorder_grouped_qkv_to_qkv` with one head
+    per query group), so `[q_all; k_all; v_all]` is the reference's in-memory / state-dict layout. There is no
+    transpose.
+    """
+    expected_rows = num_attention_heads * 3 * attention_head_dim
+    if weight.shape[0] != expected_rows:
+        raise ValueError(
+            f"fused qkv weight has {weight.shape[0]} rows, expected "
+            f"{expected_rows} = {num_attention_heads} heads * 3 * {attention_head_dim}."
+        )
+    grouped = weight.reshape(num_attention_heads, 3 * attention_head_dim, *weight.shape[1:])
+    query, key, value = grouped.split(attention_head_dim, dim=1)
+    return torch.cat(
+        [
+            tensor.reshape(num_attention_heads * attention_head_dim, *weight.shape[1:])
+            for tensor in (query, key, value)
+        ],
+        dim=0,
+    )
+
+
+def split_fused_qkv(
+    weight: torch.Tensor, num_attention_heads: int, attention_head_dim: int
+) -> tuple[torch.Tensor, ...]:
+    """Split a fused `[q_all; k_all; v_all]` QKV weight into separate `to_q` / `to_k` / `to_v` weights.
+
+    The input is the *reference model* layout — what `MiniMaxH3DiTModel.state_dict()` holds after the reference's
+    load-time reorder — i.e. the three logical projection matrices stacked contiguously, NOT the raw checkpoint's
+    per-head interleave (see `reorder_interleaved_qkv`, which the shard streamer applies first).
+    """
+    inner_dim = num_attention_heads * attention_head_dim
+    if weight.shape[0] != 3 * inner_dim:
+        raise ValueError(
+            f"fused qkv weight has {weight.shape[0]} rows, expected "
+            f"{3 * inner_dim} = 3 * {num_attention_heads} heads * {attention_head_dim}."
+        )
+    query, key, value = weight.split(inner_dim, dim=0)
+    return tuple(tensor.contiguous() for tensor in (query, key, value))
+
+
+def get_transformer_key_plan(config: dict[str, Any]) -> dict[str, list[tuple[str, list[int]]]]:
+    """Map every original transformer key to the diffusers key(s) it produces, with the resulting shapes.
+
+    The plan is derived from the config alone, so it can be printed and checked without any weights present.
+    """
+    hidden_size = config["hidden_size"]
+    heads = config["num_attention_heads"]
+    head_dim = config["attention_head_dim"]
+    inner_dim = heads * head_dim
+    ffn_dim = config["ffn_dim"]
+    time_embed_dim = config["time_embed_dim"]
+    video_patch_dim = (
+        config["in_channels"] * config["patch_size"][0] * config["patch_size"][1] * config["patch_size"][2]
+    )
+
+    plan: dict[str, list[tuple[str, list[int]]]] = {
+        "video_patch_proj.weight": [("proj_in.weight", [hidden_size, video_patch_dim])],
+        "video_patch_proj.bias": [("proj_in.bias", [hidden_size])],
+        "audio_patch_proj.weight": [("audio_proj_in.weight", [hidden_size, config["audio_in_channels"]])],
+        "audio_patch_proj.bias": [("audio_proj_in.bias", [hidden_size])],
+        "condition_proj.weight": [("context_embedder.weight", [hidden_size, config["text_dim"]])],
+        "condition_proj.bias": [("context_embedder.bias", [hidden_size])],
+        # `Timesteps` + `TimestepEmbedding` reproduce the reference sinusoid and MLP exactly, so the timestep MLP is
+        # renamed onto `TimestepEmbedding`'s `linear_1` / `linear_2`.
+        "time_embedder.proj_in.weight": [
+            ("time_embedder.linear_1.weight", [config["time_embed_hidden_dim"], config["freq_dim"]])
+        ],
+        "time_embedder.proj_in.bias": [("time_embedder.linear_1.bias", [config["time_embed_hidden_dim"]])],
+        "time_embedder.proj_out.weight": [
+            ("time_embedder.linear_2.weight", [time_embed_dim, config["time_embed_hidden_dim"]])
+        ],
+        "time_embedder.proj_out.bias": [("time_embedder.linear_2.bias", [time_embed_dim])],
+        "token_refiner.final_norm.weight": [("token_refiner.final_norm.weight", [hidden_size])],
+        "final_layer.norm.weight": [("norm_out.norm.weight", [hidden_size])],
+        "final_layer.adaln_proj.linear.weight": [("norm_out.linear.weight", [2 * hidden_size, time_embed_dim])],
+        "final_layer.adaln_proj.linear.bias": [("norm_out.linear.bias", [2 * hidden_size])],
+        "final_layer.video_out.weight": [("proj_out.weight", [video_patch_dim, hidden_size])],
+        "final_layer.video_out.bias": [("proj_out.bias", [video_patch_dim])],
+        "final_layer.audio_out.weight": [("audio_proj_out.weight", [config["audio_in_channels"], hidden_size])],
+        "final_layer.audio_out.bias": [("audio_proj_out.bias", [config["audio_in_channels"]])],
+    }
+    for key in MINIMAX_H3_TRANSFORMER_DROPPED_KEYS:
+        plan[key] = []
+
+    block_specs = [
+        ("blocks", "transformer_blocks", config["num_layers"], True),
+        ("token_refiner.blocks", "token_refiner.refiner_blocks", config["num_refiner_layers"], False),
+    ]
+    for source_prefix, target_prefix, num_layers, has_adaln in block_specs:
+        for i in range(num_layers):
+            source = f"{source_prefix}.{i}"
+            target = f"{target_prefix}.{i}"
+            plan[f"{source}.norm1.weight"] = [(f"{target}.norm1.weight", [hidden_size])]
+            plan[f"{source}.norm2.weight"] = [(f"{target}.norm2.weight", [hidden_size])]
+            plan[f"{source}.attn.qkv_proj.weight"] = [
+                (f"{target}.attn.to_q.weight", [inner_dim, hidden_size]),
+                (f"{target}.attn.to_k.weight", [inner_dim, hidden_size]),
+                (f"{target}.attn.to_v.weight", [inner_dim, hidden_size]),
+            ]
+            plan[f"{source}.attn.q_norm.weight"] = [(f"{target}.attn.norm_q.weight", [head_dim])]
+            plan[f"{source}.attn.k_norm.weight"] = [(f"{target}.attn.norm_k.weight", [head_dim])]
+            plan[f"{source}.attn.out_proj.weight"] = [(f"{target}.attn.to_out.0.weight", [hidden_size, inner_dim])]
+            # `fc1` stays fused, as diffusers' `SwiGLU` also fuses its two projections, but the halves are swapped
+            # from `[gate; value]` to `[value; gate]` (see `convert_transformer_key`).
+            plan[f"{source}.mlp.fc1.weight"] = [(f"{target}.ff.net.0.proj.weight", [2 * ffn_dim, hidden_size])]
+            plan[f"{source}.mlp.fc2.weight"] = [(f"{target}.ff.net.2.weight", [hidden_size, ffn_dim])]
+            if has_adaln:
+                plan[f"{source}.adaln_proj.linear.weight"] = [
+                    (f"{target}.adaln_proj.linear.weight", [6 * 3 * hidden_size, time_embed_dim])
+                ]
+                plan[f"{source}.adaln_proj.linear.bias"] = [
+                    (f"{target}.adaln_proj.linear.bias", [6 * 3 * hidden_size])
+                ]
+
+    return plan
+
+
+def convert_transformer_key(
+    source_key: str, tensor: torch.Tensor, config: dict[str, Any]
+) -> list[tuple[str, torch.Tensor]]:
+    """Convert one original key/tensor pair into the diffusers key/tensor pair(s) it maps to."""
+    if source_key in MINIMAX_H3_TRANSFORMER_DROPPED_KEYS:
+        return []
+
+    target_key = source_key
+    if target_key.startswith("token_refiner.blocks."):
+        target_key = target_key.replace("token_refiner.blocks.", "token_refiner.refiner_blocks.", 1)
+    elif target_key.startswith("blocks."):
+        target_key = target_key.replace("blocks.", "transformer_blocks.", 1)
+    target_key = target_key.replace("time_embedder.proj_in.", "time_embedder.linear_1.")
+    target_key = target_key.replace("time_embedder.proj_out.", "time_embedder.linear_2.")
+    target_key = target_key.replace("video_patch_proj.", "proj_in.")
+    target_key = target_key.replace("audio_patch_proj.", "audio_proj_in.")
+    target_key = target_key.replace("condition_proj.", "context_embedder.")
+    target_key = target_key.replace("final_layer.norm.", "norm_out.norm.")
+    target_key = target_key.replace("final_layer.adaln_proj.linear.", "norm_out.linear.")
+    target_key = target_key.replace("final_layer.video_out.", "proj_out.")
+    target_key = target_key.replace("final_layer.audio_out.", "audio_proj_out.")
+    target_key = target_key.replace(".attn.q_norm.", ".attn.norm_q.")
+    target_key = target_key.replace(".attn.k_norm.", ".attn.norm_k.")
+    target_key = target_key.replace(".attn.out_proj.", ".attn.to_out.0.")
+
+    if target_key.endswith(".attn.qkv_proj.weight"):
+        # `convert_transformer_key` consumes tensors in the reference model's state-dict layout, where the fused QKV
+        # rows are already `[q_all; k_all; v_all]`. Raw checkpoint shards are per-head interleaved instead; the shard
+        # streamer (`convert_transformer`) normalizes them with `reorder_interleaved_qkv` before calling this.
+        query, key, value = split_fused_qkv(tensor, config["num_attention_heads"], config["attention_head_dim"])
+        prefix = target_key.removesuffix("qkv_proj.weight")
+        return [(f"{prefix}to_q.weight", query), (f"{prefix}to_k.weight", key), (f"{prefix}to_v.weight", value)]
+
+    if target_key.endswith(".mlp.fc1.weight"):
+        # The reference computes `fc2(silu(gate) * value)` from a fused `[gate; value]`; diffusers' `SwiGLU` computes
+        # `value * silu(gate)` from a fused `[value; gate]`, so the two halves swap places. Identical transform to the
+        # video VAE's `ff.w1` (see `convert_video_vae_key`).
+        gate, value = tensor.chunk(2, dim=0)
+        target_key = target_key.replace(".mlp.fc1.weight", ".ff.net.0.proj.weight")
+        return [(target_key, torch.cat([value, gate], dim=0).contiguous())]
+
+    target_key = target_key.replace(".mlp.fc2.", ".ff.net.2.")
+    return [(target_key, tensor)]
+
+
+#
+# ---------------------------------------------------------------------------------------------------------------
+# Video VAE
+# ---------------------------------------------------------------------------------------------------------------
+#
+
+# `AutoencoderKLMiniMaxH3` argument names. Field-for-field equal to `video_vae/source/config.json`, with the original
+# names in the comments. The keys that only ever take one value in the release (`use_3d_conv`, `use_vit_decoder`,
+# `causal_encoder`, `causal_decoder`, `use_t_isolated_gn`, `space_up` / `time_up`, `zq_ch_*`, `num_res_blocks_decoder`,
+# `shift_factor` / `scaling_factor`) are baked into the port instead of being config knobs.
+MINIMAX_H3_VIDEO_VAE_CONFIG = {
+    "in_channels": 3,
+    "out_channels": 3,  # out_ch
+    "latent_channels": 24,  # z_channels == embed_dim
+    "block_out_channels": [128, 256, 256, 512, 512, 1024],  # ch * ch_mult
+    "layers_per_block": 2,  # num_res_blocks
+    "spatial_downsample_factors": [2, 2, 2, 2, 1, 1],  # space_down
+    "temporal_downsample_factors": [1, 2, 2, 1, 1, 1],  # time_down
+    "norm_num_groups": 32,
+    "norm_eps": 1e-06,
+    "spatial_padding_mode": "reflect",  # padding_mode
+    "decoder_num_layers": 36,  # vit_decoder_kwargs.num_layers
+    "decoder_num_attention_heads": 32,  # vit_decoder_kwargs.heads
+    "decoder_attention_head_dim": 64,  # vit_decoder_kwargs.dim_head
+    "decoder_num_register_tokens": 4,  # ViT3DDecoder default
+    "decoder_ffn_mult": 4,  # FeedForward default
+    "decoder_rope_theta": 100.0,  # vit_decoder_kwargs.rope_theta
+    "decoder_rope_dim_ratio": 0.75,  # vit_decoder_kwargs.rope_dim_ratio
+    "decoder_norm_eps": 1e-05,  # ViT3DDecoder eps
+    "clip_length": 17,  # video_vae/config.json vae_clip_length
+    "token_drop": 3,  # video_vae/config.json vae_token_drop
+}
+
+# A tiny configuration with the checkpoint-tied dimensions (`latent_channels`, the temporal geometry and the rotary
+# ratio) left intact, for building fixtures and for the CPU parity check.
+MINIMAX_H3_TEST_VIDEO_VAE_CONFIG = {
+    **MINIMAX_H3_VIDEO_VAE_CONFIG,
+    "block_out_channels": [32, 64],
+    "layers_per_block": 1,
+    "spatial_downsample_factors": [2, 2],
+    "temporal_downsample_factors": [2, 2],
+    "decoder_num_layers": 4,
+    "decoder_num_attention_heads": 4,
+    "decoder_attention_head_dim": 32,
+}
+
+# `decoder.mask_token` is an all-zero buffer belonging to the masked-autoencoding training objective; the released
+# decoder never reads it, so the port does not carry the module and the conversion drops the key.
+MINIMAX_H3_VIDEO_VAE_DROPPED_KEYS = ("decoder.mask_token",)
+
+
+def convert_video_vae_key(
+    source_key: str, tensor: torch.Tensor, config: dict[str, Any]
+) -> list[tuple[str, torch.Tensor]]:
+    """Convert one original video-VAE key/tensor pair into the diffusers key/tensor pair(s) it maps to.
+
+    `quant_conv` / `post_quant_conv`, the encoder's `conv_in` / `norm_out` / `conv_out` and the ViT decoder's
+    `register_tokens` / `norm_out` / `proj_out` / `norm{1,2}` / `scale{1,2}` are pure pass-throughs. What moves:
+
+    * the encoder's CNN levels are renamed from the original CompVis spelling onto the diffusers autoencoder idiom:
+      `down.{i}.block.{j}` -> `down_blocks.{i}.resnets.{j}`, `nin_shortcut` -> `conv_shortcut`, and
+      `down.{i}.downsample` -> `down_blocks.{i}.downsamplers.0`,
+    * the ViT decoder's `x_embedder` becomes `proj_in`, the counterpart of the `proj_out` it already ships,
+    * the fused per-head-interleaved `attn.to_qkv` is split into `attn.to_q` / `to_k` / `to_v`,
+    * `attn.to_out` becomes `attn.to_out.0` (diffusers wraps the output projection in an `nn.ModuleList`),
+    * the gated FFN's `w1` / `w2` become `ff.net.0.proj` / `ff.net.2`, and the two halves of `w1` are swapped because
+      diffusers' `SwiGLU` reads `[up; gate]` where the reference stores `[gate; up]`.
+    """
+    if source_key in MINIMAX_H3_VIDEO_VAE_DROPPED_KEYS:
+        return []
+
+    if ".attn.to_qkv." in source_key:
+        # Same per-head interleave as the DiT: `[head0: q k v, head1: q k v, ...]`.
+        reordered = reorder_interleaved_qkv(
+            tensor, config["decoder_num_attention_heads"], config["decoder_attention_head_dim"]
+        )
+        query, key, value = split_fused_qkv(
+            reordered, config["decoder_num_attention_heads"], config["decoder_attention_head_dim"]
+        )
+        prefix, suffix = source_key.split(".attn.to_qkv.")
+        return [
+            (f"{prefix}.attn.to_q.{suffix}", query),
+            (f"{prefix}.attn.to_k.{suffix}", key),
+            (f"{prefix}.attn.to_v.{suffix}", value),
+        ]
+
+    target_key = _rename_video_vae_key(source_key)
+
+    if ".ff.w1." in source_key:
+        gate, up = tensor.chunk(2, dim=0)
+        return [(target_key, torch.cat([up, gate], dim=0).contiguous())]
+
+    return [(target_key, tensor)]
+
+
+def _rename_video_vae_key(source_key: str) -> str:
+    """Rename one original video-VAE key onto its diffusers module path (no tensor transform)."""
+    target_key = source_key
+    if target_key.startswith("encoder.down."):
+        level, rest = target_key.removeprefix("encoder.down.").split(".", 1)
+        rest = rest.replace("block.", "resnets.", 1).replace("nin_shortcut.", "conv_shortcut.", 1)
+        rest = rest.replace("downsample.", "downsamplers.0.", 1)
+        target_key = f"encoder.down_blocks.{level}.{rest}"
+    target_key = target_key.replace("decoder.x_embedder.", "decoder.proj_in.")
+    target_key = target_key.replace(".attn.to_out.", ".attn.to_out.0.")
+    target_key = target_key.replace(".ff.w1.", ".ff.net.0.proj.")
+    target_key = target_key.replace(".ff.w2.", ".ff.net.2.")
+    return target_key
+
+
+def get_video_vae_key_plan(config: dict[str, Any]) -> dict[str, list[str]]:
+    """Map every original video-VAE key to the diffusers key(s) it produces, derived from the config alone."""
+    block_out_channels = config["block_out_channels"]
+    block_in_channels = [block_out_channels[0]] + block_out_channels[:-1]
+    plan: dict[str, list[str]] = {}
+
+    def renamed(*keys: str) -> None:
+        """Register keys whose diffusers name is `_rename_video_vae_key(key)` and whose tensor is unchanged."""
+        for key in keys:
+            plan[key] = [_rename_video_vae_key(key)]
+
+    renamed("quant_conv.weight", "quant_conv.bias", "post_quant_conv.weight", "post_quant_conv.bias")
+    renamed("encoder.conv_in.weight", "encoder.conv_in.bias")
+    for level, (in_channels, out_channels) in enumerate(zip(block_in_channels, block_out_channels)):
+        for i in range(config["layers_per_block"]):
+            prefix = f"encoder.down.{level}.block.{i}"
+            for name in ("norm1", "conv1", "norm2", "conv2"):
+                renamed(f"{prefix}.{name}.weight", f"{prefix}.{name}.bias")
+            if (in_channels if i == 0 else out_channels) != out_channels:
+                renamed(f"{prefix}.nin_shortcut.weight", f"{prefix}.nin_shortcut.bias")
+        if config["spatial_downsample_factors"][level] * config["temporal_downsample_factors"][level] > 1:
+            renamed(f"encoder.down.{level}.downsample.conv.weight", f"encoder.down.{level}.downsample.conv.bias")
+    renamed("encoder.norm_out.weight", "encoder.norm_out.bias", "encoder.conv_out.weight", "encoder.conv_out.bias")
+
+    renamed("decoder.x_embedder.weight", "decoder.x_embedder.bias", "decoder.register_tokens")
+    renamed("decoder.norm_out.weight", "decoder.norm_out.bias", "decoder.proj_out.weight", "decoder.proj_out.bias")
+    for i in range(config["decoder_num_layers"]):
+        prefix = f"decoder.transformer_blocks.{i}"
+        renamed(f"{prefix}.norm1.weight", f"{prefix}.norm2.weight", f"{prefix}.scale1", f"{prefix}.scale2")
+        for suffix in ("weight", "bias"):
+            plan[f"{prefix}.attn.to_qkv.{suffix}"] = [
+                f"{prefix}.attn.to_q.{suffix}",
+                f"{prefix}.attn.to_k.{suffix}",
+                f"{prefix}.attn.to_v.{suffix}",
+            ]
+            plan[f"{prefix}.attn.to_out.{suffix}"] = [f"{prefix}.attn.to_out.0.{suffix}"]
+            plan[f"{prefix}.ff.w1.{suffix}"] = [f"{prefix}.ff.net.0.proj.{suffix}"]
+            plan[f"{prefix}.ff.w2.{suffix}"] = [f"{prefix}.ff.net.2.{suffix}"]
+    for key in MINIMAX_H3_VIDEO_VAE_DROPPED_KEYS:
+        plan[key] = []
+    return plan
+
+
+def convert_video_vae(
+    checkpoint_path: str, output_path: str, config: dict[str, Any], diffusers_version: str, max_shard_size: int
+) -> None:
+    """Convert the video VAE and emit its config.
+
+    The original weights live one level deeper than the rest of the checkpoint
+    (`video_vae/source/model.safetensors`, resolved by a hook in the reference); the diffusers layout flattens that to
+    `vae/`. `latents_mean` / `latents_std` and the tiling geometry come from `video_vae/config.json` — MiniMax-H3
+    normalizes latents per channel instead of with a `scaling_factor`.
+    """
+    source_dir = os.path.join(checkpoint_path, "video_vae")
+    with open(os.path.join(source_dir, "config.json")) as f:
+        wrapper_config = json.load(f)
+    for key in ("latents_mean", "latents_std"):
+        if key not in wrapper_config:
+            raise KeyError(f"{source_dir}/config.json does not carry `{key}`.")
+
+    weights_path = os.path.join(source_dir, wrapper_config["source_path"], wrapper_config["source_safetensors_path"])
+    plan = get_video_vae_key_plan(config)
+
+    os.makedirs(output_path, exist_ok=True)
+    weight_map: dict[str, str] = {}
+    total_size = 0
+    written: list[str] = []
+    buffer: dict[str, torch.Tensor] = {}
+    buffer_size = 0
+    seen_source_keys: set[str] = set()
+
+    def flush() -> None:
+        nonlocal buffer, buffer_size
+        if not buffer:
+            return
+        path = os.path.join(output_path, f".tmp-shard-{len(written):05d}.safetensors")
+        save_file(buffer, path, metadata={"format": "pt"})
+        for key in buffer:
+            weight_map[key] = path
+        written.append(path)
+        buffer = {}
+        buffer_size = 0
+
+    # `safe_open` memory-maps the file, so only the tensor being read is materialized.
+    with safe_open(weights_path, framework="pt", device="cpu") as f:
+        for source_key in f.keys():
+            if source_key not in plan:
+                raise KeyError(f"Unexpected key in {weights_path}: {source_key}")
+            seen_source_keys.add(source_key)
+            for target_key, tensor in convert_video_vae_key(source_key, f.get_tensor(source_key), config):
+                if tensor.dtype != torch.float32:
+                    raise ValueError(f"{source_key}: expected torch.float32, got {tensor.dtype}.")
+                buffer[target_key] = tensor
+                buffer_size += tensor.numel() * tensor.element_size()
+                total_size += tensor.numel() * tensor.element_size()
+            if buffer_size >= max_shard_size:
+                flush()
+    flush()
+
+    missing = sorted(set(plan) - seen_source_keys)
+    if missing:
+        raise KeyError(f"{len(missing)} planned key(s) missing from {weights_path}, e.g. {missing[:5]}.")
+
+    renames = {
+        path: os.path.join(output_path, f"diffusion_pytorch_model-{i + 1:05d}-of-{len(written):05d}.safetensors")
+        for i, path in enumerate(written)
+    }
+    for old, new in renames.items():
+        os.rename(old, new)
+    index = {
+        "metadata": {"total_size": total_size},
+        "weight_map": {key: os.path.basename(renames[path]) for key, path in weight_map.items()},
+    }
+    with open(os.path.join(output_path, SAFE_WEIGHTS_INDEX_NAME), "w") as f:
+        json.dump(index, f, indent=2, sort_keys=True)
+
+    with open(os.path.join(output_path, "config.json"), "w") as f:
+        json.dump(
+            {
+                "_class_name": "AutoencoderKLMiniMaxH3",
+                "_diffusers_version": diffusers_version,
+                **config,
+                "latents_mean": wrapper_config["latents_mean"],
+                "latents_std": wrapper_config["latents_std"],
+            },
+            f,
+            indent=2,
+        )
+
+    print(
+        f"video_vae: {len(seen_source_keys)} original keys -> {len(weight_map)} diffusers keys in "
+        f"{len(written)} shard(s), {total_size / 1024**3:.2f} GiB "
+        f"(latents_mean/latents_std: {len(wrapper_config['latents_mean'])}/"
+        f"{len(wrapper_config['latents_std'])} channels; tiling {wrapper_config['vae_tile_size']}px / "
+        f"{wrapper_config['vae_tile_overlap_min']}px min overlap)."
+    )
+
+
+# Not present in `audio_vae/metadata.json`: the reference implementation hardcodes these in its DAC audio VAE and its
+# attention projection, keyed off the sample rate.
+MINIMAX_H3_AUDIO_VAE_FIXED_CONFIG = {
+    "num_attention_heads": 8,
+    "resblock_kernel_sizes": [3, 7, 11],
+    "resblock_dilation_sizes": [[1, 3, 5], [1, 3, 5], [1, 3, 5]],
+}
+
+
+def get_audio_vae_config(checkpoint_path: str) -> dict[str, Any]:
+    """Build the `AutoencoderKLMiniMaxH3Audio` config from the original audio-VAE metadata.
+
+    `audio_vae/metadata.json` carries the constructor kwargs the checkpoint was built with, and
+    `audio_vae/config.json` carries the per-channel `latents_mean` / `latents_std` MiniMax-H3 normalizes with. The two
+    are cross-checked here because they duplicate the latent width and sample rate.
+    """
+    source_dir = os.path.join(checkpoint_path, "audio_vae")
+    with open(os.path.join(source_dir, "metadata.json")) as f:
+        kwargs = json.load(f)["metadata"]["kwargs"]
+    with open(os.path.join(source_dir, "config.json")) as f:
+        wrapper_config = json.load(f)
+
+    if kwargs["decoder_type"] != "bigvgan":
+        raise ValueError(f"Only the BigVGAN decoder is supported, got {kwargs['decoder_type']!r}.")
+    if not kwargs["attn_proj"]:
+        raise ValueError("The audio VAE is expected to carry the causal-attention latent projection.")
+    latent_channels = kwargs["vae_latent_channels"]
+    if wrapper_config["latent_channels"] != latent_channels:
+        raise ValueError(
+            f"latent width disagreement: metadata.json says {latent_channels}, "
+            f"config.json says {wrapper_config['latent_channels']}."
+        )
+    if wrapper_config["sample_rate"] != kwargs["sample_rate"]:
+        raise ValueError(
+            f"sample rate disagreement: metadata.json says {kwargs['sample_rate']}, "
+            f"config.json says {wrapper_config['sample_rate']}."
+        )
+    for key in ("latents_mean", "latents_std"):
+        if len(wrapper_config[key]) != latent_channels:
+            raise KeyError(f"{source_dir}/config.json `{key}` does not have {latent_channels} entries.")
+
+    return {
+        "encoder_dim": kwargs["encoder_dim"],
+        "encoder_rates": kwargs["encoder_rates"],
+        "latent_dim": kwargs["latent_dim"],
+        "latent_channels": latent_channels,
+        "decoder_dim": kwargs["decoder_dim"],
+        "decoder_rates": kwargs["decoder_rates"],
+        # The reference's two hardcoded BigVGAN tables (16 kHz and 32 kHz) both pair rate `u` with kernel
+        # `2u` for even `u` and `2u - 1` for odd `u`, i.e. [5, 5, 2, ...] -> [9, 9, 4, ...].
+        "decoder_kernel_sizes": [2 * rate - (rate % 2) for rate in kwargs["decoder_rates"]],
+        **MINIMAX_H3_AUDIO_VAE_FIXED_CONFIG,
+        # Renamed from the original `sample_rate` to the diffusers audio convention.
+        "sampling_rate": kwargs["sample_rate"],
+        "latents_mean": wrapper_config["latents_mean"],
+        "latents_std": wrapper_config["latents_std"],
+    }
+
+
+def convert_audio_vae(checkpoint_path: str, output_path: str, diffusers_version: str) -> None:
+    """Convert the audio VAE and emit its config.
+
+    The mapping is an identity: `AutoencoderKLMiniMaxH3Audio` reproduces the original module tree name for name,
+    including `torch.nn.utils.weight_norm`'s `weight_g` / `weight_v` spelling and the Kaiser-window `filter` buffers of
+    the anti-aliased activations. The keys are therefore only *validated* against a freshly built model, not renamed.
+    """
+    config = get_audio_vae_config(checkpoint_path)
+    expected_keys = set(AutoencoderKLMiniMaxH3Audio(**config).state_dict())
+
+    weights_path = os.path.join(checkpoint_path, "audio_vae", "model.safetensors")
+    state_dict: dict[str, torch.Tensor] = {}
+    total_size = 0
+    with safe_open(weights_path, framework="pt", device="cpu") as f:
+        for key in f.keys():
+            if key not in expected_keys:
+                raise KeyError(f"Unexpected key in {weights_path}: {key}")
+            tensor = f.get_tensor(key)
+            if tensor.dtype != torch.float32:
+                raise ValueError(f"{key}: expected torch.float32, got {tensor.dtype}.")
+            state_dict[key] = tensor
+            total_size += tensor.numel() * tensor.element_size()
+
+    missing = sorted(expected_keys - set(state_dict))
+    if missing:
+        raise KeyError(f"{len(missing)} key(s) missing from {weights_path}, e.g. {missing[:5]}.")
+
+    os.makedirs(output_path, exist_ok=True)
+    save_file(
+        state_dict,
+        os.path.join(output_path, "diffusion_pytorch_model.safetensors"),
+        metadata={"format": "pt"},
+    )
+    with open(os.path.join(output_path, "config.json"), "w") as f:
+        json.dump(
+            {"_class_name": "AutoencoderKLMiniMaxH3Audio", "_diffusers_version": diffusers_version, **config},
+            f,
+            indent=2,
+        )
+
+    print(
+        f"audio_vae: {len(state_dict)} keys carried over unchanged, {total_size / 1024**3:.2f} GiB "
+        f"({config['sampling_rate'] // math.prod(config['encoder_rates'])} latents/s, "
+        f"latents_mean/latents_std: {len(config['latents_mean'])}/{len(config['latents_std'])} channels)."
+    )
+
+
+def write_scheduler_configs(checkpoint_path: str, output_path: str, diffusers_version: str) -> None:
+    """Emit the two `MiniMaxH3Scheduler` configs, one per modality.
+
+    The source `model_index.json` leaves `scheduler` null and instead carries the schedule constants in its
+    `_minimax_h3.sigma_shift_scales` block. The sigma shift is the only per-modality difference, so it becomes two
+    scheduler folders holding the same class at different `shift` values.
+    """
+    with open(os.path.join(checkpoint_path, "model_index.json")) as f:
+        shift_scales = json.load(f)["_minimax_h3"]["sigma_shift_scales"]
+
+    for folder, modality in (("scheduler", "video"), ("audio_scheduler", "audio")):
+        folder_path = os.path.join(output_path, folder)
+        os.makedirs(folder_path, exist_ok=True)
+        with open(os.path.join(folder_path, "scheduler_config.json"), "w") as f:
+            json.dump(
+                {
+                    "_class_name": "MiniMaxH3Scheduler",
+                    "_diffusers_version": diffusers_version,
+                    "shift": float(shift_scales[modality]),
+                },
+                f,
+                indent=2,
+            )
+    print(f"scheduler: shift={shift_scales['video']} (video), audio_scheduler: shift={shift_scales['audio']} (audio).")
+
+
+def read_safetensors_header(path: str) -> dict[str, Any]:
+    """Read the metadata header of a safetensors file without touching the tensor payload."""
+    with open(path, "rb") as f:
+        header_size = struct.unpack("<Q", f.read(8))[0]
+        header = json.loads(f.read(header_size))
+    header.pop("__metadata__", None)
+    return header
+
+
+def dry_run(checkpoint_path: str, config: dict[str, Any]) -> None:
+    plan = get_transformer_key_plan(config)
+
+    transformer_dir = os.path.join(checkpoint_path, "transformer")
+    shards = sorted(glob.glob(os.path.join(transformer_dir, "*.safetensors")))
+    header: dict[str, Any] = {}
+    for shard in shards:
+        header.update(read_safetensors_header(shard))
+    if shards:
+        print(f"Read headers of {len(shards)} shard(s) in {transformer_dir}: {len(header)} keys present.\n")
+    else:
+        print(f"No shards found under {transformer_dir}; validating the plan against the config only.\n")
+
+    print(f"{'original key':<48} {'->':^4} {'diffusers key':<52} {'shape':<24} dtype")
+    print("-" * 150)
+    num_target_keys = 0
+    shape_mismatches: list[str] = []
+    for source_key, targets in plan.items():
+        present = source_key in header
+        if not targets:
+            print(f"{source_key:<48} {'-x':^4} {'(dropped, recomputed by the port)':<52}")
+            continue
+        for index, (target_key, shape) in enumerate(targets):
+            num_target_keys += 1
+            expected_dtype = "F32" if source_key.startswith(MINIMAX_H3_FP32_SOURCE_PREFIXES) else "BF16"
+            if present:
+                actual_dtype = header[source_key]["dtype"]
+                actual_shape = header[source_key]["shape"]
+                if index == 0 and len(targets) == 1 and actual_shape != shape:
+                    shape_mismatches.append(f"{source_key}: header {actual_shape} != planned {shape}")
+                if actual_dtype != expected_dtype:
+                    shape_mismatches.append(f"{source_key}: header dtype {actual_dtype} != expected {expected_dtype}")
+                marker = "->"
+            else:
+                marker = "->?"
+            left = source_key if index == 0 else ""
+            print(f"{left:<48} {marker:^4} {target_key:<52} {str(shape):<24} {expected_dtype}")
+
+    missing = [key for key in plan if key not in header]
+    unexpected = [key for key in header if key not in plan]
+
+    print("\n" + "=" * 150)
+    print(f"planned original keys : {len(plan)}")
+    print(f"planned diffusers keys: {num_target_keys}")
+    print(
+        f"dropped original keys : {len(MINIMAX_H3_TRANSFORMER_DROPPED_KEYS)} {list(MINIMAX_H3_TRANSFORMER_DROPPED_KEYS)}"
+    )
+    print(f"fp32 diffusers keys   : {sum(1 for key in plan if key.startswith(MINIMAX_H3_FP32_SOURCE_PREFIXES))}")
+    if shards:
+        print(f"keys present in shards: {len(header)}")
+        print(f"planned but absent    : {len(missing)}" + (" (shards still downloading?)" if missing else ""))
+        print(f"present but unplanned : {len(unexpected)}")
+        if unexpected:
+            print(f"  {unexpected}")
+        print(f"header disagreements  : {len(shape_mismatches)}")
+        for line in shape_mismatches:
+            print(f"  {line}")
+    total_bytes = sum(
+        (4 if source_key.startswith(MINIMAX_H3_FP32_SOURCE_PREFIXES) else 2) * torch.Size(shape).numel()
+        for source_key, targets in plan.items()
+        for _, shape in targets
+    )
+    print(f"total output bytes    : {total_bytes} ({total_bytes / 1024**3:.2f} GiB)")
+
+
+def convert_transformer(checkpoint_path: str, output_path: str, config: dict[str, Any], max_shard_size: int) -> None:
+    plan = get_transformer_key_plan(config)
+    transformer_dir = os.path.join(checkpoint_path, "transformer")
+    shards = sorted(glob.glob(os.path.join(transformer_dir, "*.safetensors")))
+    if not shards:
+        raise FileNotFoundError(f"No `*.safetensors` shards found under {transformer_dir}.")
+
+    os.makedirs(output_path, exist_ok=True)
+    weight_map: dict[str, str] = {}
+    total_size = 0
+    written: list[str] = []
+    buffer: dict[str, torch.Tensor] = {}
+    buffer_size = 0
+    seen_source_keys: set[str] = set()
+
+    def flush() -> None:
+        nonlocal buffer, buffer_size
+        if not buffer:
+            return
+        path = os.path.join(output_path, f".tmp-shard-{len(written):05d}.safetensors")
+        save_file(buffer, path, metadata={"format": "pt"})
+        for key in buffer:
+            weight_map[key] = path
+        written.append(path)
+        buffer = {}
+        buffer_size = 0
+
+    for shard in shards:
+        # `safe_open` memory-maps the file, so only the tensor being read is materialized.
+        with safe_open(shard, framework="pt", device="cpu") as f:
+            for source_key in f.keys():
+                if source_key not in plan:
+                    raise KeyError(f"Unexpected key in {os.path.basename(shard)}: {source_key}")
+                seen_source_keys.add(source_key)
+                source_tensor = f.get_tensor(source_key)
+                if source_key.endswith(".attn.qkv_proj.weight"):
+                    # Raw shards store fused QKV per-head interleaved; normalize to the reference's
+                    # `[q_all; k_all; v_all]` layout (the same transform the reference applies at load time) so
+                    # `convert_transformer_key` sees its state-dict-layout contract. The composition is bit-identical
+                    # to de-interleaving the raw tensor directly.
+                    source_tensor = reorder_interleaved_qkv(
+                        source_tensor, config["num_attention_heads"], config["attention_head_dim"]
+                    )
+                for target_key, tensor in convert_transformer_key(source_key, source_tensor, config):
+                    expected_dtype = (
+                        torch.float32 if source_key.startswith(MINIMAX_H3_FP32_SOURCE_PREFIXES) else torch.bfloat16
+                    )
+                    if tensor.dtype != expected_dtype:
+                        raise ValueError(f"{source_key}: expected {expected_dtype}, got {tensor.dtype}.")
+                    buffer[target_key] = tensor
+                    buffer_size += tensor.numel() * tensor.element_size()
+                    total_size += tensor.numel() * tensor.element_size()
+                if buffer_size >= max_shard_size:
+                    flush()
+    flush()
+
+    missing = sorted(set(plan) - seen_source_keys)
+    if missing:
+        raise KeyError(f"{len(missing)} planned key(s) missing from the checkpoint, e.g. {missing[:5]}.")
+
+    # The shard count is only known once every source shard has been streamed, so the files are written under
+    # provisional names and renamed here.
+    renames = {
+        path: os.path.join(output_path, f"diffusion_pytorch_model-{i + 1:05d}-of-{len(written):05d}.safetensors")
+        for i, path in enumerate(written)
+    }
+    for old, new in renames.items():
+        os.rename(old, new)
+    index = {
+        "metadata": {"total_size": total_size},
+        "weight_map": {key: os.path.basename(renames[path]) for key, path in weight_map.items()},
+    }
+    with open(os.path.join(output_path, SAFE_WEIGHTS_INDEX_NAME), "w") as f:
+        json.dump(index, f, indent=2, sort_keys=True)
+
+    print(
+        f"transformer: {len(seen_source_keys)} original keys -> {len(weight_map)} diffusers keys "
+        f"in {len(written)} shard(s), {total_size / 1024**3:.2f} GiB."
+    )
+
+
+def write_transformer_config(output_path: str, config: dict[str, Any], diffusers_version: str) -> None:
+    os.makedirs(output_path, exist_ok=True)
+    with open(os.path.join(output_path, "config.json"), "w") as f:
+        json.dump(
+            {"_class_name": "MiniMaxH3Transformer3DModel", "_diffusers_version": diffusers_version, **config},
+            f,
+            indent=2,
+        )
+
+
+# The components a MiniMax-H3 repository holds, and the class each one loads as. `video_processor` is absent: the
+# blocks create it from config rather than loading it.
+MINIMAX_H3_COMPONENTS = {
+    # The source names a checkpoint-local wrapper class (`MiniMaxH3Qwen3VLHFEncoder`); the conditioner is the
+    # released Qwen3-VL, read at its 50th decoder layer with its language-model head unused.
+    "text_encoder": ["transformers", "Qwen3VLForConditionalGeneration"],
+    "tokenizer": ["transformers", "Qwen2TokenizerFast"],
+    "processor": ["transformers", "Qwen3VLProcessor"],
+    # Renamed to the diffusers audio/video VAE convention (see `LTX2Pipeline`).
+    "vae": ["diffusers", "AutoencoderKLMiniMaxH3"],
+    "audio_vae": ["diffusers", "AutoencoderKLMiniMaxH3Audio"],
+    "transformer": ["diffusers", "MiniMaxH3Transformer3DModel"],
+    # One repository holds both checkpoint partitions: `transformer/` serves `MiniMaxH3Blocks` (`t2va` / `fl2va`) and
+    # `transformer_ref/` serves `MiniMaxH3Ref2VABlocks`, while every other component is shared and converted once.
+    "transformer_ref": ["diffusers", "MiniMaxH3Transformer3DModel"],
+    # The source leaves `scheduler` null. MiniMax-H3 samples with Euler at eta=0 over shifted flow-matching sigmas, at
+    # a different shift per modality, so it needs two scheduler entries (see `write_scheduler_configs`).
+    "scheduler": ["diffusers", "MiniMaxH3Scheduler"],
+    "audio_scheduler": ["diffusers", "MiniMaxH3Scheduler"],
+}
+
+
+def write_model_index(output_path: str, repo_id: str, diffusers_version: str) -> None:
+    """Emit `modular_model_index.json`, the only index a MiniMax-H3 repository carries.
+
+    MiniMax-H3 is integrated as Modular Diffusers blocks only, so there is no `model_index.json`: a modular repository
+    declares one entry per component with its full loading spec rather than just its class, and a blockset then fetches
+    exactly the subfolders it declares. That is what lets one repository hold both transformer partitions, and the
+    original checkpoint folders next to the converted ones, without either half pulling the rest down.
+
+    `_class_name` and `_blocks_class_name` name the `t2va` / `fl2va` half, which is what
+    `ModularPipeline.from_pretrained` resolves to. The `ref2va` half reads the very same file through
+    `MiniMaxH3Ref2VABlocks().init_pipeline(repo_id)`.
+
+    The component map is the static one above, so this needs no source checkpoint: an index can be regenerated for a
+    repository that is already published.
+    """
+    modular_index = {
+        "_class_name": "MiniMaxH3ModularPipeline",
+        "_diffusers_version": diffusers_version,
+        "_blocks_class_name": "MiniMaxH3Blocks",
+    }
+    for name, (library, class_name) in MINIMAX_H3_COMPONENTS.items():
+        modular_index[name] = [
+            library,
+            class_name,
+            {
+                "type_hint": [library, class_name],
+                "pretrained_model_name_or_path": repo_id,
+                "subfolder": name,
+                "variant": None,
+                "revision": None,
+            },
+        ]
+    os.makedirs(output_path, exist_ok=True)
+    with open(os.path.join(output_path, "modular_model_index.json"), "w") as f:
+        json.dump(modular_index, f, indent=2)
+    print(f"modular_model_index.json: {len(MINIMAX_H3_COMPONENTS)} components load from {repo_id}.")
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--checkpoint_path",
+        type=str,
+        required=True,
+        help="Local path to an original MiniMax-H3 variant folder (the one holding `transformer/`, `audio_vae/`, ...).",
+    )
+    parser.add_argument("--output_path", type=str, required=True, help="Where the diffusers checkpoint is written.")
+    parser.add_argument(
+        "--modular_repo_id",
+        type=str,
+        default=None,
+        help=(
+            "Repository the component entries of `modular_model_index.json` point at. Defaults to `--output_path`, so "
+            "pass the Hub id the checkpoint is published under. Every entry carries its own loading spec, so a "
+            "blockset fetches exactly the subfolders it declares out of that repository."
+        ),
+    )
+    parser.add_argument(
+        "--version",
+        type=str,
+        default="h3",
+        choices=["h3", "test"],
+        help="`test` emits the tiny config used for fixtures.",
+    )
+    parser.add_argument(
+        "--max_shard_size",
+        type=int,
+        default=5 * 1024**3,
+        help="Maximum size of an output safetensors shard, in bytes.",
+    )
+    parser.add_argument(
+        "--dry_run",
+        action="store_true",
+        help="Print the full planned key mapping (and cross-check any shard headers already present) without writing.",
+    )
+    return parser.parse_args()
+
+
+def main(args):
+    from diffusers import __version__ as diffusers_version
+
+    config = MINIMAX_H3_TEST_TRANSFORMER_CONFIG if args.version == "test" else MINIMAX_H3_TRANSFORMER_CONFIG
+
+    if args.dry_run:
+        dry_run(args.checkpoint_path, config)
+        return
+
+    transformer_path = os.path.join(args.output_path, "transformer")
+    convert_transformer(args.checkpoint_path, transformer_path, config, args.max_shard_size)
+    write_transformer_config(transformer_path, config, diffusers_version)
+    video_vae_config = MINIMAX_H3_TEST_VIDEO_VAE_CONFIG if args.version == "test" else MINIMAX_H3_VIDEO_VAE_CONFIG
+    convert_video_vae(
+        args.checkpoint_path,
+        os.path.join(args.output_path, "vae"),
+        video_vae_config,
+        diffusers_version,
+        args.max_shard_size,
+    )
+    convert_audio_vae(args.checkpoint_path, os.path.join(args.output_path, "audio_vae"), diffusers_version)
+    write_scheduler_configs(args.checkpoint_path, args.output_path, diffusers_version)
+    write_model_index(args.output_path, args.modular_repo_id or args.output_path, diffusers_version)
+
+
+if __name__ == "__main__":
+    main(get_args())
diff --git a/src/diffusers/__init__.py b/src/diffusers/__init__.py
index 7a8d727aefea..3c8a46426d2a 100644
--- a/src/diffusers/__init__.py
+++ b/src/diffusers/__init__.py
@@ -248,6 +248,8 @@
             "AutoencoderKLLTX2Video",
             "AutoencoderKLLTXVideo",
             "AutoencoderKLMagvit",
+            "AutoencoderKLMiniMaxH3",
+            "AutoencoderKLMiniMaxH3Audio",
             "AutoencoderKLMochi",
             "AutoencoderKLQwenImage",
             "AutoencoderKLTemporalDecoder",
@@ -309,6 +311,7 @@
             "LTXVideoTransformer3DModel",
             "Lumina2Transformer2DModel",
             "LuminaNextDiT2DModel",
+            "MiniMaxH3Transformer3DModel",
             "MochiTransformer3DModel",
             "ModelMixin",
             "MotifVideoTransformer3DModel",
@@ -443,6 +446,7 @@
             "KDPM2DiscreteScheduler",
             "LCMScheduler",
             "LTXEulerAncestralRFScheduler",
+            "MiniMaxH3Scheduler",
             "PNDMScheduler",
             "RePaintScheduler",
             "SASolverScheduler",
@@ -531,6 +535,10 @@
             "Krea2TurboModularPipeline",
             "LTXAutoBlocks",
             "LTXModularPipeline",
+            "MiniMaxH3Blocks",
+            "MiniMaxH3ModularPipeline",
+            "MiniMaxH3Ref2VABlocks",
+            "MiniMaxH3Ref2VAModularPipeline",
             "QwenImageAutoBlocks",
             "QwenImageEditAutoBlocks",
             "QwenImageEditModularPipeline",
@@ -1089,6 +1097,8 @@
             AutoencoderKLLTX2Video,
             AutoencoderKLLTXVideo,
             AutoencoderKLMagvit,
+            AutoencoderKLMiniMaxH3,
+            AutoencoderKLMiniMaxH3Audio,
             AutoencoderKLMochi,
             AutoencoderKLQwenImage,
             AutoencoderKLTemporalDecoder,
@@ -1150,6 +1160,7 @@
             LTXVideoTransformer3DModel,
             Lumina2Transformer2DModel,
             LuminaNextDiT2DModel,
+            MiniMaxH3Transformer3DModel,
             MochiTransformer3DModel,
             ModelMixin,
             MotifVideoTransformer3DModel,
@@ -1280,6 +1291,7 @@
             KDPM2DiscreteScheduler,
             LCMScheduler,
             LTXEulerAncestralRFScheduler,
+            MiniMaxH3Scheduler,
             PNDMScheduler,
             RePaintScheduler,
             SASolverScheduler,
@@ -1351,6 +1363,10 @@
             Krea2TurboModularPipeline,
             LTXAutoBlocks,
             LTXModularPipeline,
+            MiniMaxH3Blocks,
+            MiniMaxH3ModularPipeline,
+            MiniMaxH3Ref2VABlocks,
+            MiniMaxH3Ref2VAModularPipeline,
             QwenImageAutoBlocks,
             QwenImageEditAutoBlocks,
             QwenImageEditModularPipeline,
diff --git a/src/diffusers/models/__init__.py b/src/diffusers/models/__init__.py
index 167ee7a534de..a78702ab34fa 100755
--- a/src/diffusers/models/__init__.py
+++ b/src/diffusers/models/__init__.py
@@ -46,6 +46,8 @@
     _import_structure["autoencoders.autoencoder_kl_ltx2"] = ["AutoencoderKLLTX2Video"]
     _import_structure["autoencoders.autoencoder_kl_ltx2_audio"] = ["AutoencoderKLLTX2Audio"]
     _import_structure["autoencoders.autoencoder_kl_magvit"] = ["AutoencoderKLMagvit"]
+    _import_structure["autoencoders.autoencoder_kl_minimax_h3"] = ["AutoencoderKLMiniMaxH3"]
+    _import_structure["autoencoders.autoencoder_kl_minimax_h3_audio"] = ["AutoencoderKLMiniMaxH3Audio"]
     _import_structure["autoencoders.autoencoder_kl_mochi"] = ["AutoencoderKLMochi"]
     _import_structure["autoencoders.autoencoder_kl_qwenimage"] = ["AutoencoderKLQwenImage"]
     _import_structure["autoencoders.autoencoder_kl_temporal_decoder"] = ["AutoencoderKLTemporalDecoder"]
@@ -128,6 +130,7 @@
     _import_structure["transformers.transformer_ltx"] = ["LTXVideoTransformer3DModel"]
     _import_structure["transformers.transformer_ltx2"] = ["LTX2VideoTransformer3DModel"]
     _import_structure["transformers.transformer_lumina2"] = ["Lumina2Transformer2DModel"]
+    _import_structure["transformers.transformer_minimax_h3"] = ["MiniMaxH3Transformer3DModel"]
     _import_structure["transformers.transformer_mochi"] = ["MochiTransformer3DModel"]
     _import_structure["transformers.transformer_motif_video"] = ["MotifVideoTransformer3DModel"]
     _import_structure["transformers.transformer_nucleusmoe_image"] = ["NucleusMoEImageTransformer2DModel"]
@@ -180,6 +183,8 @@
             AutoencoderKLLTX2Video,
             AutoencoderKLLTXVideo,
             AutoencoderKLMagvit,
+            AutoencoderKLMiniMaxH3,
+            AutoencoderKLMiniMaxH3Audio,
             AutoencoderKLMochi,
             AutoencoderKLQwenImage,
             AutoencoderKLTemporalDecoder,
@@ -260,6 +265,7 @@
             LTXVideoTransformer3DModel,
             Lumina2Transformer2DModel,
             LuminaNextDiT2DModel,
+            MiniMaxH3Transformer3DModel,
             MochiTransformer3DModel,
             MotifVideoTransformer3DModel,
             NucleusMoEImageTransformer2DModel,
diff --git a/src/diffusers/models/autoencoders/__init__.py b/src/diffusers/models/autoencoders/__init__.py
index 145f62376192..dc481370204b 100644
--- a/src/diffusers/models/autoencoders/__init__.py
+++ b/src/diffusers/models/autoencoders/__init__.py
@@ -16,6 +16,8 @@
 from .autoencoder_kl_ltx2 import AutoencoderKLLTX2Video
 from .autoencoder_kl_ltx2_audio import AutoencoderKLLTX2Audio
 from .autoencoder_kl_magvit import AutoencoderKLMagvit
+from .autoencoder_kl_minimax_h3 import AutoencoderKLMiniMaxH3
+from .autoencoder_kl_minimax_h3_audio import AutoencoderKLMiniMaxH3Audio
 from .autoencoder_kl_mochi import AutoencoderKLMochi
 from .autoencoder_kl_qwenimage import AutoencoderKLQwenImage
 from .autoencoder_kl_temporal_decoder import AutoencoderKLTemporalDecoder
diff --git a/src/diffusers/models/autoencoders/autoencoder_kl_minimax_h3.py b/src/diffusers/models/autoencoders/autoencoder_kl_minimax_h3.py
new file mode 100644
index 000000000000..586138fc884e
--- /dev/null
+++ b/src/diffusers/models/autoencoders/autoencoder_kl_minimax_h3.py
@@ -0,0 +1,922 @@
+# Copyright 2026 The MiniMax and HuggingFace Teams. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import math
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from ...configuration_utils import ConfigMixin, register_to_config
+from ...utils import logging
+from ...utils.accelerate_utils import apply_forward_hook
+from ..attention import AttentionMixin, AttentionModuleMixin, FeedForward
+from ..attention_dispatch import dispatch_attention_fn
+from ..modeling_outputs import AutoencoderKLOutput
+from ..modeling_utils import ModelMixin
+from .vae import AutoencoderMixin, DecoderOutput, DiagonalGaussianDistribution
+
+
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
+
+
+class MiniMaxH3VideoCausalConv3d(nn.Conv3d):
+    r"""
+    3D convolution used throughout the MiniMax-H3 video encoder.
+
+    Spatial padding is symmetric and uses `spatial_padding_mode` (`"reflect"` in the released checkpoint); temporal
+    padding is causal, i.e. `kernel_size_t - 1` zero frames are prepended and nothing is appended.
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        kernel_size: int | tuple[int, int, int],
+        stride: int | tuple[int, int, int] = 1,
+        spatial_padding: int = 0,
+        temporal_padding: int = 0,
+        spatial_padding_mode: str = "reflect",
+    ) -> None:
+        super().__init__(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=0)
+        self.spatial_padding = spatial_padding
+        self.temporal_padding = temporal_padding
+        self.spatial_padding_mode = spatial_padding_mode
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        if self.spatial_padding > 0:
+            padding = self.spatial_padding
+            hidden_states = F.pad(
+                hidden_states, (padding, padding, padding, padding, 0, 0), mode=self.spatial_padding_mode
+            )
+        if self.temporal_padding > 0:
+            hidden_states = F.pad(hidden_states, (0, 0, 0, 0, self.temporal_padding, 0), mode="constant")
+        return F.conv3d(hidden_states, self.weight, self.bias, stride=self.stride, padding=0, dilation=self.dilation)
+
+
+class MiniMaxH3VideoGroupNorm(nn.GroupNorm):
+    r"""
+    Group normalization applied to each latent frame in isolation (`use_t_isolated_gn` in the original config): the
+    temporal axis is folded into the batch axis so statistics never mix across frames.
+    """
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        batch_size, num_channels, num_frames, height, width = hidden_states.shape
+        hidden_states = hidden_states.permute(0, 2, 1, 3, 4).contiguous()
+        hidden_states = hidden_states.view(batch_size * num_frames, num_channels, 1, height, width)
+        hidden_states = super().forward(hidden_states)
+        hidden_states = hidden_states.view(batch_size, num_frames, num_channels, height, width)
+        return hidden_states.permute(0, 2, 1, 3, 4).contiguous()
+
+
+class MiniMaxH3VideoResnetBlock3d(nn.Module):
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        norm_num_groups: int = 32,
+        norm_eps: float = 1e-6,
+        spatial_padding_mode: str = "reflect",
+    ) -> None:
+        super().__init__()
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+
+        self.norm1 = MiniMaxH3VideoGroupNorm(norm_num_groups, in_channels, eps=norm_eps, affine=True)
+        self.conv1 = MiniMaxH3VideoCausalConv3d(
+            in_channels,
+            out_channels,
+            kernel_size=3,
+            spatial_padding=1,
+            temporal_padding=2,
+            spatial_padding_mode=spatial_padding_mode,
+        )
+        self.norm2 = MiniMaxH3VideoGroupNorm(norm_num_groups, out_channels, eps=norm_eps, affine=True)
+        self.conv2 = MiniMaxH3VideoCausalConv3d(
+            out_channels,
+            out_channels,
+            kernel_size=3,
+            spatial_padding=1,
+            temporal_padding=2,
+            spatial_padding_mode=spatial_padding_mode,
+        )
+        self.conv_shortcut = None
+        if in_channels != out_channels:
+            self.conv_shortcut = MiniMaxH3VideoCausalConv3d(in_channels, out_channels, kernel_size=1)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        residual = hidden_states
+        hidden_states = F.silu(self.norm1(hidden_states))
+        hidden_states = self.conv1(hidden_states)
+        hidden_states = F.silu(self.norm2(hidden_states))
+        hidden_states = self.conv2(hidden_states)
+        if self.conv_shortcut is not None:
+            residual = self.conv_shortcut(residual)
+        return residual + hidden_states
+
+
+class MiniMaxH3VideoDownsample3d(nn.Module):
+    r"""
+    Strided 3x3x3 downsampling convolution. A spatial stride of 2 is preceded by an asymmetric bottom/right pad of 1
+    (the convolution itself carries no spatial padding), so the output is exactly `ceil(size / 2)`.
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        temporal_stride: int = 1,
+        spatial_stride: int = 2,
+        spatial_padding_mode: str = "reflect",
+    ) -> None:
+        super().__init__()
+        self.spatial_stride = spatial_stride
+        self.spatial_padding_mode = spatial_padding_mode
+        self.conv = MiniMaxH3VideoCausalConv3d(
+            in_channels,
+            out_channels,
+            kernel_size=3,
+            stride=(temporal_stride, spatial_stride, spatial_stride),
+            spatial_padding=0,
+            temporal_padding=2,
+            spatial_padding_mode=spatial_padding_mode,
+        )
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        if self.spatial_stride == 2:
+            hidden_states = F.pad(hidden_states, (0, 1, 0, 1, 0, 0), mode=self.spatial_padding_mode)
+        return self.conv(hidden_states)
+
+
+class MiniMaxH3VideoDownBlock3d(nn.Module):
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        num_layers: int,
+        temporal_downsample_factor: int,
+        spatial_downsample_factor: int,
+        norm_num_groups: int = 32,
+        norm_eps: float = 1e-6,
+        spatial_padding_mode: str = "reflect",
+    ) -> None:
+        super().__init__()
+        self.resnets = nn.ModuleList(
+            [
+                MiniMaxH3VideoResnetBlock3d(
+                    in_channels=in_channels if i == 0 else out_channels,
+                    out_channels=out_channels,
+                    norm_num_groups=norm_num_groups,
+                    norm_eps=norm_eps,
+                    spatial_padding_mode=spatial_padding_mode,
+                )
+                for i in range(num_layers)
+            ]
+        )
+        self.downsamplers = None
+        if temporal_downsample_factor * spatial_downsample_factor > 1:
+            self.downsamplers = nn.ModuleList(
+                [
+                    MiniMaxH3VideoDownsample3d(
+                        out_channels,
+                        out_channels,
+                        temporal_stride=temporal_downsample_factor,
+                        spatial_stride=spatial_downsample_factor,
+                        spatial_padding_mode=spatial_padding_mode,
+                    )
+                ]
+            )
+
+        self.gradient_checkpointing = False
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        for resnet in self.resnets:
+            if torch.is_grad_enabled() and self.gradient_checkpointing:
+                hidden_states = self._gradient_checkpointing_func(resnet, hidden_states)
+            else:
+                hidden_states = resnet(hidden_states)
+        if self.downsamplers is not None:
+            for downsampler in self.downsamplers:
+                hidden_states = downsampler(hidden_states)
+        return hidden_states
+
+
+class MiniMaxH3VideoEncoder3d(nn.Module):
+    r"""
+    Causal 3D CNN encoder. `block_out_channels` gives the channel count of every level; the per-level
+    `spatial_downsample_factors` / `temporal_downsample_factors` multiply out to the total compression ratios.
+    """
+
+    def __init__(
+        self,
+        in_channels: int = 3,
+        out_channels: int = 48,
+        block_out_channels: tuple[int, ...] = (128, 256, 256, 512, 512, 1024),
+        layers_per_block: int = 2,
+        spatial_downsample_factors: tuple[int, ...] = (2, 2, 2, 2, 1, 1),
+        temporal_downsample_factors: tuple[int, ...] = (1, 2, 2, 1, 1, 1),
+        norm_num_groups: int = 32,
+        norm_eps: float = 1e-6,
+        spatial_padding_mode: str = "reflect",
+    ) -> None:
+        super().__init__()
+
+        self.conv_in = MiniMaxH3VideoCausalConv3d(
+            in_channels,
+            block_out_channels[0],
+            kernel_size=3,
+            spatial_padding=1,
+            temporal_padding=2,
+            spatial_padding_mode=spatial_padding_mode,
+        )
+
+        block_in_channels = (block_out_channels[0],) + tuple(block_out_channels[:-1])
+        self.down_blocks = nn.ModuleList(
+            [
+                MiniMaxH3VideoDownBlock3d(
+                    in_channels=block_in_channels[i],
+                    out_channels=block_out_channels[i],
+                    num_layers=layers_per_block,
+                    temporal_downsample_factor=temporal_downsample_factors[i],
+                    spatial_downsample_factor=spatial_downsample_factors[i],
+                    norm_num_groups=norm_num_groups,
+                    norm_eps=norm_eps,
+                    spatial_padding_mode=spatial_padding_mode,
+                )
+                for i in range(len(block_out_channels))
+            ]
+        )
+
+        self.norm_out = MiniMaxH3VideoGroupNorm(norm_num_groups, block_out_channels[-1], eps=norm_eps, affine=True)
+        self.conv_out = MiniMaxH3VideoCausalConv3d(
+            block_out_channels[-1],
+            out_channels,
+            kernel_size=3,
+            spatial_padding=1,
+            temporal_padding=2,
+            spatial_padding_mode=spatial_padding_mode,
+        )
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.conv_in(hidden_states)
+        for down_block in self.down_blocks:
+            hidden_states = down_block(hidden_states)
+        hidden_states = F.silu(self.norm_out(hidden_states))
+        return self.conv_out(hidden_states)
+
+
+class MiniMaxH3VideoRotaryPosEmbed(nn.Module):
+    r"""
+    3-axis rotary embedding for the ViT decoder. Coordinates are length-normalized to `[-1, 1)` per axis and scaled by
+    `2 * pi`, and the resulting `(t, h, w)` angles are concatenated and then duplicated, so the first
+    `rope_dim_ratio * attention_head_dim` channels of every head are rotated.
+    """
+
+    def __init__(self, dim: int, theta: float = 100.0, num_axes: int = 3) -> None:
+        super().__init__()
+        if dim % (2 * num_axes) != 0:
+            raise ValueError(f"`dim` {dim} must be divisible by `2 * num_axes` {2 * num_axes}.")
+        inv_freq = 1.0 / theta ** torch.arange(0, 1, 2 * num_axes / dim, dtype=torch.float32)
+        self.register_buffer("inv_freq", inv_freq, persistent=False)
+
+    def forward(self, position_ids: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+        angles = 2.0 * math.pi * position_ids[:, :, :, None] * self.inv_freq[None, None, None, :]
+        angles = angles.flatten(2, 3).tile(2).unsqueeze(2)
+        return angles.cos(), angles.sin()
+
+
+class MiniMaxH3VideoAttnProcessor:
+    _attention_backend = None
+    _parallel_config = None
+
+    def __call__(
+        self,
+        attn: "MiniMaxH3VideoAttention",
+        hidden_states: torch.Tensor,
+        rotary_emb: tuple[torch.Tensor, torch.Tensor] | None = None,
+    ) -> torch.Tensor:
+        query = attn.to_q(hidden_states).unflatten(2, (attn.heads, -1))
+        key = attn.to_k(hidden_states).unflatten(2, (attn.heads, -1))
+        value = attn.to_v(hidden_states).unflatten(2, (attn.heads, -1))
+
+        # The reference normalizes Q/K in float32 regardless of the compute dtype.
+        query = attn.norm_q(query.float()).to(query.dtype)
+        key = attn.norm_k(key.float()).to(key.dtype)
+
+        if rotary_emb is not None:
+            cos, sin = rotary_emb
+            cos = cos.to(query.dtype)
+            sin = sin.to(query.dtype)
+            rotary_dim = cos.shape[-1]
+            query_rotary, query_pass = query[..., :rotary_dim], query[..., rotary_dim:]
+            key_rotary, key_pass = key[..., :rotary_dim], key[..., rotary_dim:]
+            query_first, query_second = query_rotary.chunk(2, dim=-1)
+            key_first, key_second = key_rotary.chunk(2, dim=-1)
+            query_rotated = torch.cat([-query_second, query_first], dim=-1)
+            key_rotated = torch.cat([-key_second, key_first], dim=-1)
+            query = torch.cat([query_rotary * cos + query_rotated * sin, query_pass], dim=-1)
+            key = torch.cat([key_rotary * cos + key_rotated * sin, key_pass], dim=-1)
+
+        hidden_states = dispatch_attention_fn(
+            query,
+            key,
+            value,
+            attn_mask=None,
+            backend=self._attention_backend,
+            parallel_config=self._parallel_config,
+        )
+        hidden_states = hidden_states.flatten(2, 3)
+        return attn.to_out[0](hidden_states)
+
+
+class MiniMaxH3VideoAttention(nn.Module, AttentionModuleMixin):
+    _default_processor_cls = MiniMaxH3VideoAttnProcessor
+    _available_processors = [MiniMaxH3VideoAttnProcessor]
+
+    def __init__(self, dim: int, heads: int, dim_head: int, eps: float = 1e-5, bias: bool = True) -> None:
+        super().__init__()
+        self.heads = heads
+        self.dim_head = dim_head
+        self.use_bias = bias
+        inner_dim = heads * dim_head
+
+        self.norm_q = nn.RMSNorm(dim_head, eps=eps, elementwise_affine=False)
+        self.norm_k = nn.RMSNorm(dim_head, eps=eps, elementwise_affine=False)
+        self.to_q = nn.Linear(dim, inner_dim, bias=bias)
+        self.to_k = nn.Linear(dim, inner_dim, bias=bias)
+        self.to_v = nn.Linear(dim, inner_dim, bias=bias)
+        self.to_out = nn.ModuleList([nn.Linear(inner_dim, dim, bias=bias), nn.Dropout(0.0)])
+
+        self.set_processor(MiniMaxH3VideoAttnProcessor())
+
+    def forward(
+        self, hidden_states: torch.Tensor, rotary_emb: tuple[torch.Tensor, torch.Tensor] | None = None
+    ) -> torch.Tensor:
+        return self.processor(self, hidden_states, rotary_emb)
+
+
+class MiniMaxH3VideoTransformerBlock(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        heads: int,
+        dim_head: int,
+        ffn_mult: int = 4,
+        eps: float = 1e-5,
+        bias: bool = True,
+    ) -> None:
+        super().__init__()
+        self.norm1 = nn.RMSNorm(dim, eps=eps, elementwise_affine=True)
+        self.attn = MiniMaxH3VideoAttention(dim=dim, heads=heads, dim_head=dim_head, eps=eps, bias=bias)
+        self.scale1 = nn.Parameter(torch.zeros(dim))
+        self.norm2 = nn.RMSNorm(dim, eps=eps, elementwise_affine=True)
+        self.ff = FeedForward(dim, mult=ffn_mult, activation_fn="swiglu", bias=bias)
+        self.scale2 = nn.Parameter(torch.zeros(dim))
+
+    def forward(
+        self, hidden_states: torch.Tensor, rotary_emb: tuple[torch.Tensor, torch.Tensor] | None = None
+    ) -> torch.Tensor:
+        # The reference normalizes in float32 regardless of the compute dtype.
+        norm_hidden_states = self.norm1(hidden_states.float()).to(hidden_states.dtype)
+        hidden_states = hidden_states + self.attn(norm_hidden_states, rotary_emb) * self.scale1
+        norm_hidden_states = self.norm2(hidden_states.float()).to(hidden_states.dtype)
+        hidden_states = hidden_states + self.ff(norm_hidden_states) * self.scale2
+        return hidden_states
+
+
+class MiniMaxH3VideoViTDecoder3d(nn.Module):
+    r"""
+    Non-causal ViT decoder. Every latent voxel becomes one token; `num_register_tokens` learned register tokens plus a
+    single all-zero token are appended (all at position `0`), attended over with full self-attention, and dropped
+    again before the patch projection expands each token into a `patch_size_t x patch_size x patch_size` pixel block.
+    """
+
+    def __init__(
+        self,
+        in_channels: int = 24,
+        out_channels: int = 3,
+        patch_size: int = 16,
+        patch_size_t: int = 4,
+        num_layers: int = 36,
+        num_attention_heads: int = 32,
+        attention_head_dim: int = 64,
+        num_register_tokens: int = 4,
+        ffn_mult: int = 4,
+        rope_theta: float = 100.0,
+        rope_dim_ratio: float = 0.75,
+        norm_eps: float = 1e-5,
+    ) -> None:
+        super().__init__()
+        dim = num_attention_heads * attention_head_dim
+        self.patch_size = patch_size
+        self.patch_size_t = patch_size_t
+        self.out_channels = out_channels
+        self.num_register_tokens = num_register_tokens
+
+        self.rope = MiniMaxH3VideoRotaryPosEmbed(int(attention_head_dim * rope_dim_ratio), theta=rope_theta)
+        self.proj_in = nn.Linear(in_channels, dim)
+        self.register_tokens = nn.Parameter(torch.zeros(1, num_register_tokens, dim))
+        self.transformer_blocks = nn.ModuleList(
+            [
+                MiniMaxH3VideoTransformerBlock(
+                    dim=dim,
+                    heads=num_attention_heads,
+                    dim_head=attention_head_dim,
+                    ffn_mult=ffn_mult,
+                    eps=norm_eps,
+                )
+                for _ in range(num_layers)
+            ]
+        )
+        self.norm_out = nn.LayerNorm(dim, elementwise_affine=True, eps=norm_eps)
+        self.proj_out = nn.Linear(dim, out_channels * patch_size_t * patch_size * patch_size)
+
+        self.gradient_checkpointing = False
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        batch_size, num_channels, num_frames, height, width = hidden_states.shape
+
+        hidden_states = hidden_states.permute(0, 2, 3, 4, 1).reshape(
+            batch_size, num_frames * height * width, num_channels
+        )
+        hidden_states = self.proj_in(hidden_states)
+        num_patches = hidden_states.shape[1]
+
+        register_tokens = self.register_tokens.expand(batch_size, -1, -1)
+        cls_token = torch.zeros_like(hidden_states[:, :1, :])
+        hidden_states = torch.cat([hidden_states, register_tokens, cls_token], dim=1)
+
+        grids = [
+            2.0 * (torch.arange(0.5, size, dtype=torch.float32, device=hidden_states.device) / size) - 1.0
+            for size in (num_frames, height, width)
+        ]
+        position_ids = torch.stack(torch.meshgrid(*grids, indexing="ij"), dim=-1).flatten(0, 2)
+        position_ids = position_ids.unsqueeze(0).expand(batch_size, -1, -1)
+        suffix_ids = position_ids.new_zeros((batch_size, self.num_register_tokens + 1, 3))
+        position_ids = torch.cat([position_ids, suffix_ids], dim=1)
+        rotary_emb = self.rope(position_ids)
+
+        for block in self.transformer_blocks:
+            if torch.is_grad_enabled() and self.gradient_checkpointing:
+                hidden_states = self._gradient_checkpointing_func(block, hidden_states, rotary_emb)
+            else:
+                hidden_states = block(hidden_states, rotary_emb)
+
+        hidden_states = self.norm_out(hidden_states)
+        hidden_states = self.proj_out(hidden_states)
+        hidden_states = hidden_states[:, :num_patches, :]
+
+        patch_size, patch_size_t = self.patch_size, self.patch_size_t
+        hidden_states = hidden_states.view(
+            batch_size,
+            num_frames,
+            height,
+            width,
+            self.out_channels,
+            patch_size_t,
+            patch_size,
+            patch_size,
+        )
+        hidden_states = hidden_states.permute(0, 4, 1, 5, 2, 6, 3, 7).contiguous()
+        return hidden_states.reshape(
+            batch_size,
+            self.out_channels,
+            num_frames * patch_size_t,
+            height * patch_size,
+            width * patch_size,
+        )
+
+
+class AutoencoderKLMiniMaxH3(ModelMixin, ConfigMixin, AttentionMixin, AutoencoderMixin):
+    r"""
+    A VAE model with a causal 3D CNN encoder and a non-causal ViT decoder, used in
+    [MiniMax-H3](https://huggingface.co/MiniMaxAI).
+
+    This model inherits from [`ModelMixin`]. Check the superclass documentation for it's generic methods implemented
+    for all models (such as downloading or saving).
+
+    Latents are normalized with per-channel `latents_mean` / `latents_std` rather than a `scaling_factor`; a pipeline
+    encodes with `(latent - latents_mean) / latents_std` and decodes with `latent * latents_std + latents_mean`.
+
+    The pixel convention is ImageNet-normalized RGB over a `[0, 1]` base range, not the usual `[-1, 1]`: `encode`
+    expects `(pixel - imagenet_mean) / imagenet_std` and `decode` returns values in that same space, so a pipeline has
+    to apply `sample * imagenet_std + imagenet_mean` (mean `(0.485, 0.456, 0.406)`, std `(0.229, 0.224, 0.225)`) and
+    clamp to `[0, 1]` before postprocessing.
+
+    The temporal geometry is fixed by `clip_length` (17 pixel frames per encoder chunk) and `token_drop` (3 trailing
+    latent frames dropped per encode): `17 * n + 5` pixel frames map to `5 * n + 2` latent frames.
+
+    Unlike most autoencoders in the library, spatial tiling is **on by default**: MiniMax-H3 was released with tiling
+    enabled for both encoding and decoding, and the released frames are the blended-tile ones, so disabling tiling
+    changes the output. Use `enable_tiling` to change the tile geometry, `disable_tiling` to turn it off.
+    """
+
+    _supports_gradient_checkpointing = True
+    _no_split_modules = ["MiniMaxH3VideoResnetBlock3d", "MiniMaxH3VideoTransformerBlock"]
+    _repeated_blocks = ["MiniMaxH3VideoTransformerBlock"]
+    _skip_layerwise_casting_patterns = ["norm"]
+    # The released checkpoint is float32 and the verified decode recipe is float16 *autocast over float32 weights*
+    # (see `decode`). A pipeline-level `torch_dtype=torch.bfloat16` must therefore not downcast the weights, so every
+    # top-level module is pinned, mirroring the transformer's mixed-precision contract.
+    _keep_in_fp32_modules = ["encoder", "decoder", "quant_conv", "post_quant_conv"]
+
+    @register_to_config
+    def __init__(
+        self,
+        in_channels: int = 3,
+        out_channels: int = 3,
+        latent_channels: int = 24,
+        block_out_channels: tuple[int, ...] = (128, 256, 256, 512, 512, 1024),
+        layers_per_block: int = 2,
+        spatial_downsample_factors: tuple[int, ...] = (2, 2, 2, 2, 1, 1),
+        temporal_downsample_factors: tuple[int, ...] = (1, 2, 2, 1, 1, 1),
+        norm_num_groups: int = 32,
+        norm_eps: float = 1e-6,
+        spatial_padding_mode: str = "reflect",
+        decoder_num_layers: int = 36,
+        decoder_num_attention_heads: int = 32,
+        decoder_attention_head_dim: int = 64,
+        decoder_num_register_tokens: int = 4,
+        decoder_ffn_mult: int = 4,
+        decoder_rope_theta: float = 100.0,
+        decoder_rope_dim_ratio: float = 0.75,
+        decoder_norm_eps: float = 1e-5,
+        clip_length: int = 17,
+        token_drop: int = 3,
+        latents_mean: tuple[float, ...] = (0.0,) * 24,
+        latents_std: tuple[float, ...] = (1.0,) * 24,
+    ) -> None:
+        super().__init__()
+
+        self.spatial_compression_ratio = math.prod(spatial_downsample_factors)
+        self.temporal_compression_ratio = math.prod(temporal_downsample_factors)
+
+        self.encoder = MiniMaxH3VideoEncoder3d(
+            in_channels=in_channels,
+            out_channels=2 * latent_channels,
+            block_out_channels=block_out_channels,
+            layers_per_block=layers_per_block,
+            spatial_downsample_factors=spatial_downsample_factors,
+            temporal_downsample_factors=temporal_downsample_factors,
+            norm_num_groups=norm_num_groups,
+            norm_eps=norm_eps,
+            spatial_padding_mode=spatial_padding_mode,
+        )
+        self.quant_conv = nn.Conv3d(2 * latent_channels, 2 * latent_channels, kernel_size=1)
+        self.post_quant_conv = nn.Conv3d(latent_channels, latent_channels, kernel_size=1)
+        self.decoder = MiniMaxH3VideoViTDecoder3d(
+            in_channels=latent_channels,
+            out_channels=out_channels,
+            patch_size=self.spatial_compression_ratio,
+            patch_size_t=self.temporal_compression_ratio,
+            num_layers=decoder_num_layers,
+            num_attention_heads=decoder_num_attention_heads,
+            attention_head_dim=decoder_attention_head_dim,
+            num_register_tokens=decoder_num_register_tokens,
+            ffn_mult=decoder_ffn_mult,
+            rope_theta=decoder_rope_theta,
+            rope_dim_ratio=decoder_rope_dim_ratio,
+            norm_eps=decoder_norm_eps,
+        )
+
+        # Derived temporal-chunking geometry. `clip_length` pixel frames are encoded at a time; because
+        # `clip_length` is not a multiple of `temporal_compression_ratio`, the decoder has to re-derive the
+        # implicit leading pad (`frame_pre_padding`) and the overlap that `token_drop` leaves behind.
+        self.frame_pre_padding = (-clip_length) % self.temporal_compression_ratio
+        self.tokens_chunk_size = math.ceil(clip_length / self.temporal_compression_ratio)
+        self.token_overlap = (-token_drop) % self.tokens_chunk_size
+        self.frame_overlap = max(self.token_overlap * self.temporal_compression_ratio - self.frame_pre_padding, 0)
+
+        # When decoding a batch of video latents at a time, one can save memory by slicing across the batch dimension
+        # to perform decoding of a single video latent at a time.
+        self.use_slicing = False
+
+        # When encoding/decoding spatially large videos, the memory requirement is very high. By splitting the frames
+        # into smaller tiles, running the encoder/decoder per tile and blending the overlaps, the memory requirement
+        # can be lowered. MiniMax-H3 ships with tiling enabled.
+        self.use_tiling = True
+
+        # The tile size in pixel space, and the minimum overlap between two neighbouring tiles. The actual overlaps are
+        # widened (in multiples of `spatial_compression_ratio`) so that the tiles cover the frame exactly.
+        self.tile_sample_min_height = 256
+        self.tile_sample_min_width = 256
+        self.tile_sample_min_overlap_height = 64
+        self.tile_sample_min_overlap_width = 64
+
+    def enable_tiling(
+        self,
+        tile_sample_min_height: int | None = None,
+        tile_sample_min_width: int | None = None,
+        tile_sample_min_overlap_height: int | None = None,
+        tile_sample_min_overlap_width: int | None = None,
+    ) -> None:
+        r"""
+        Enable tiled VAE encoding/decoding. When this option is enabled, the VAE splits the frames into tiles, encodes
+        or decodes each tile separately and linearly blends the overlaps back together. This lowers the memory
+        requirement and allows processing larger frames.
+
+        Args:
+            tile_sample_min_height (`int`, *optional*):
+                The tile height in pixel space. Frames taller than this are split along the height dimension.
+            tile_sample_min_width (`int`, *optional*):
+                The tile width in pixel space. Frames wider than this are split along the width dimension.
+            tile_sample_min_overlap_height (`int`, *optional*):
+                The minimum overlap, in pixels, between two consecutive vertical tiles.
+            tile_sample_min_overlap_width (`int`, *optional*):
+                The minimum overlap, in pixels, between two consecutive horizontal tiles.
+        """
+        self.use_tiling = True
+        self.tile_sample_min_height = tile_sample_min_height or self.tile_sample_min_height
+        self.tile_sample_min_width = tile_sample_min_width or self.tile_sample_min_width
+        self.tile_sample_min_overlap_height = tile_sample_min_overlap_height or self.tile_sample_min_overlap_height
+        self.tile_sample_min_overlap_width = tile_sample_min_overlap_width or self.tile_sample_min_overlap_width
+
+    def _split_tiles(self, length: int, tile_size: int, min_overlap: int) -> tuple[list[int], list[int], list[int]]:
+        r"""
+        Lay `tile_size`-wide tiles over `length` pixels. The number of tiles is the smallest one whose union can cover
+        `length` while keeping every overlap at least `min_overlap`; the slack is then distributed round-robin over the
+        overlaps in whole `spatial_compression_ratio` steps so that every tile boundary stays latent-aligned.
+        """
+        if tile_size >= length:
+            return [0], [length], []
+
+        num_tiles = math.ceil(length / tile_size)
+        while tile_size * num_tiles - min_overlap * (num_tiles - 1) - length < 0:
+            num_tiles += 1
+
+        overlaps = [min_overlap] * (num_tiles - 1)
+        remaining = tile_size * num_tiles - sum(overlaps) - length
+        for i in range(remaining // self.spatial_compression_ratio):
+            overlaps[i % (num_tiles - 1)] += self.spatial_compression_ratio
+
+        tile_start_indices = [0]
+        for i in range(num_tiles - 1):
+            tile_start_indices.append(tile_start_indices[-1] + tile_size - overlaps[i])
+        return tile_start_indices, [tile_size] * num_tiles, overlaps
+
+    def _blend(self, a: torch.Tensor, b: torch.Tensor, blend_extent: int, dim: int) -> torch.Tensor:
+        blend_extent = min(a.shape[dim], b.shape[dim], blend_extent)
+        positions = torch.arange(blend_extent, device=b.device, dtype=b.dtype)
+        shape = [1] * a.ndim
+        shape[dim] = blend_extent
+        weight_a = (1 - positions / blend_extent).view(shape)
+        weight_b = (positions / blend_extent).view(shape)
+
+        slice_a = [slice(None)] * a.ndim
+        slice_a[dim] = slice(-blend_extent, None)
+        slice_b = [slice(None)] * b.ndim
+        slice_b[dim] = slice(0, blend_extent)
+        blended = a[tuple(slice_a)] * weight_a + b[tuple(slice_b)] * weight_b
+
+        if blend_extent == b.shape[dim]:
+            return blended
+        slice_rest = [slice(None)] * b.ndim
+        slice_rest[dim] = slice(blend_extent, None)
+        return torch.cat([blended, b[tuple(slice_rest)]], dim=dim)
+
+    def _stitch_tiles(
+        self,
+        tiles: list[list[torch.Tensor]],
+        height_overlaps: list[int],
+        width_overlaps: list[int],
+    ) -> torch.Tensor:
+        result_rows = []
+        for i, row in enumerate(tiles):
+            result_row = []
+            for j, tile in enumerate(row):
+                if i > 0:
+                    tile = self._blend(tiles[i - 1][j], tile, height_overlaps[i - 1], dim=-2)
+                if j > 0:
+                    tile = self._blend(row[j - 1], tile, width_overlaps[j - 1], dim=-1)
+                if i < len(tiles) - 1:
+                    tile = tile[..., : -height_overlaps[i], :]
+                if j < len(row) - 1:
+                    tile = tile[..., :, : -width_overlaps[j]]
+                result_row.append(tile)
+            result_rows.append(torch.cat(result_row, dim=-1))
+        return torch.cat(result_rows, dim=-2)
+
+    @apply_forward_hook
+    def _encode_clip(self, x: torch.Tensor) -> torch.Tensor:
+        r"""
+        Encode one temporal clip, spatially tiled when tiling is enabled.
+
+        MiniMax-H3 encodes a keyframe or an image reference through this method rather than through [`~encode`],
+        because a single frame must not go through the temporal chunking, so it carries the offload hook too.
+        """
+        if not self.use_tiling:
+            return self.quant_conv(self.encoder(x))
+
+        height, width = x.shape[-2], x.shape[-1]
+        y_indices, y_lengths, y_overlaps = self._split_tiles(
+            height, self.tile_sample_min_height, self.tile_sample_min_overlap_height
+        )
+        x_indices, x_lengths, x_overlaps = self._split_tiles(
+            width, self.tile_sample_min_width, self.tile_sample_min_overlap_width
+        )
+
+        rows = []
+        for i_pos, i_len in zip(y_indices, y_lengths):
+            row = []
+            for j_pos, j_len in zip(x_indices, x_lengths):
+                tile = x[..., i_pos : i_pos + i_len, j_pos : j_pos + j_len]
+                row.append(self.quant_conv(self.encoder(tile)))
+            rows.append(row)
+
+        latent_y_overlaps = [overlap // self.spatial_compression_ratio for overlap in y_overlaps]
+        latent_x_overlaps = [overlap // self.spatial_compression_ratio for overlap in x_overlaps]
+        return self._stitch_tiles(rows, latent_y_overlaps, latent_x_overlaps)
+
+    def _decode_clip(self, z: torch.Tensor) -> torch.Tensor:
+        r"""Decode one temporal clip, spatially tiled when tiling is enabled."""
+        if not self.use_tiling:
+            return self.decoder(self.post_quant_conv(z))
+
+        # Tiles are laid out in pixel space and then mapped back onto the latent grid.
+        height = z.shape[-2] * self.spatial_compression_ratio
+        width = z.shape[-1] * self.spatial_compression_ratio
+        y_indices, y_lengths, y_overlaps = self._split_tiles(
+            height, self.tile_sample_min_height, self.tile_sample_min_overlap_height
+        )
+        x_indices, x_lengths, x_overlaps = self._split_tiles(
+            width, self.tile_sample_min_width, self.tile_sample_min_overlap_width
+        )
+
+        ratio = self.spatial_compression_ratio
+        rows = []
+        for i_pos, i_len in zip(y_indices, y_lengths):
+            row = []
+            for j_pos, j_len in zip(x_indices, x_lengths):
+                tile = z[
+                    ...,
+                    i_pos // ratio : i_pos // ratio + i_len // ratio,
+                    j_pos // ratio : j_pos // ratio + j_len // ratio,
+                ]
+                row.append(self.decoder(self.post_quant_conv(tile)))
+            rows.append(row)
+
+        return self._stitch_tiles(rows, y_overlaps, x_overlaps)
+
+    @apply_forward_hook
+    def _encode(self, x: torch.Tensor) -> torch.Tensor:
+        r"""
+        Encode a video in `clip_length`-frame chunks and drop the `token_drop` trailing latent frames.
+
+        MiniMax-H3 encodes a video reference through this method rather than through [`~encode`], because the
+        posterior is sampled under a fixed generator rather than through the distribution object, so it carries the
+        offload hook too.
+        """
+        clip_length = self.config.clip_length
+        num_frames = x.shape[2]
+        if num_frames % clip_length != 0:
+            pad_frames = x[:, :, -1:].repeat(1, 1, (-num_frames) % clip_length, 1, 1)
+            x = torch.cat([x, pad_frames], dim=2)
+
+        moments = torch.cat(
+            [
+                self._encode_clip(x[:, :, i * clip_length : (i + 1) * clip_length])
+                for i in range(x.shape[2] // clip_length)
+            ],
+            dim=2,
+        )
+        if self.config.token_drop > 0:
+            moments = moments[:, :, : -self.config.token_drop]
+        return moments
+
+    def _decode(self, z: torch.Tensor) -> torch.Tensor:
+        r"""
+        Decode a latent video, mirroring the chunking that `_encode` applied.
+
+        `token_drop` removed the tail of every encoded chunk, so consecutive decoded chunks overlap by
+        `frame_overlap` pixel frames and are linearly cross-faded. Latent frames are repeated at the end when the
+        length is not a whole number of chunks; the extra pixel frames are cut off again at the end.
+        """
+        tokens_chunk_size = self.tokens_chunk_size
+        token_drop = self.config.token_drop
+        temporal_ratio = self.temporal_compression_ratio
+        chunk_num_frames = tokens_chunk_size * temporal_ratio
+
+        num_tokens = z.shape[2] + token_drop
+        pad_tokens = (-num_tokens) % tokens_chunk_size
+        num_chunks = (num_tokens + pad_tokens) // tokens_chunk_size - int(token_drop > 0)
+        if pad_tokens > 0:
+            z = torch.cat([z, z[:, :, -1:].repeat(1, 1, pad_tokens, 1, 1)], dim=2)
+
+        decoded_chunks = []
+        overlap = None
+        for i in range(num_chunks):
+            start = i * tokens_chunk_size
+            clip = self._decode_clip(z[:, :, start : start + tokens_chunk_size + self.token_overlap])
+            for j in range(int(token_drop > 0) + 1):
+                frame_start = j * chunk_num_frames
+                chunk = clip[:, :, frame_start : frame_start + chunk_num_frames]
+                chunk = chunk[:, :, self.frame_pre_padding :]
+                if j == 0:
+                    if overlap is not None:
+                        chunk = self._blend(overlap, chunk, self.frame_overlap, dim=-3)
+                    decoded_chunks.append(chunk)
+                else:
+                    overlap = chunk
+        if overlap is not None:
+            decoded_chunks.append(overlap)
+
+        dec = torch.cat(decoded_chunks, dim=2)
+
+        # `pad_tokens` repeated latent frames produced trailing pixel frames that were never requested. A chunk's
+        # last latent frame only covers `clip_length % temporal_ratio` pixel frames, the others cover `temporal_ratio`.
+        if pad_tokens > 0:
+            intra_tail = self.config.clip_length % temporal_ratio
+            num_tokens_before_pad = z.shape[2] - pad_tokens
+            pad_frames = sum(
+                intra_tail if intra_tail and (num_tokens_before_pad + k) % tokens_chunk_size == 0 else temporal_ratio
+                for k in range(pad_tokens)
+            )
+            dec = dec[:, :, :-pad_frames]
+        return dec
+
+    @apply_forward_hook
+    def encode(self, x: torch.Tensor, return_dict: bool = True) -> AutoencoderKLOutput | tuple[torch.Tensor]:
+        r"""
+        Encode a batch of videos into latents.
+
+        Args:
+            x (`torch.Tensor`):
+                Input batch of videos, shape `(batch_size, in_channels, num_frames, height, width)`.
+            return_dict (`bool`, *optional*, defaults to `True`):
+                Whether to return a [`~models.autoencoders.autoencoder_kl.AutoencoderKLOutput`] instead of a plain
+                tuple.
+
+        Returns:
+            The latent distribution of the encoded videos. Note that MiniMax-H3 normalizes the sampled latents with
+            `latents_mean` / `latents_std` afterwards.
+        """
+        if self.use_slicing and x.shape[0] > 1:
+            moments = torch.cat([self._encode(x_slice) for x_slice in x.split(1)])
+        else:
+            moments = self._encode(x)
+        posterior = DiagonalGaussianDistribution(moments)
+        if not return_dict:
+            return (posterior,)
+        return AutoencoderKLOutput(latent_dist=posterior)
+
+    @apply_forward_hook
+    def decode(self, z: torch.Tensor, return_dict: bool = True) -> DecoderOutput | tuple[torch.Tensor]:
+        r"""
+        Decode a batch of latent videos.
+
+        Args:
+            z (`torch.Tensor`):
+                Input batch of latent videos, shape `(batch_size, latent_channels, num_latent_frames, height, width)`.
+            return_dict (`bool`, *optional*, defaults to `True`):
+                Whether to return a [`~models.autoencoders.vae.DecoderOutput`] instead of a plain tuple.
+
+        Returns:
+            [`~models.autoencoders.vae.DecoderOutput`] or `tuple`:
+                The decoded videos, shape `(batch_size, out_channels, num_frames, height, width)`.
+        """
+        if self.use_slicing and z.shape[0] > 1:
+            decoded = torch.cat([self._decode(z_slice) for z_slice in z.split(1)])
+        else:
+            decoded = self._decode(z)
+        if not return_dict:
+            return (decoded,)
+        return DecoderOutput(sample=decoded)
+
+    def forward(
+        self,
+        sample: torch.Tensor,
+        sample_posterior: bool = False,
+        generator: torch.Generator | None = None,
+        return_dict: bool = True,
+    ) -> DecoderOutput | tuple[torch.Tensor]:
+        r"""
+        Encode then decode a batch of videos.
+
+        Args:
+            sample (`torch.Tensor`):
+                Input batch of videos, shape `(batch_size, in_channels, num_frames, height, width)`.
+            sample_posterior (`bool`, *optional*, defaults to `False`):
+                Whether to sample the posterior instead of taking its mode.
+            generator (`torch.Generator`, *optional*):
+                Generator used when `sample_posterior=True`.
+            return_dict (`bool`, *optional*, defaults to `True`):
+                Whether to return a [`~models.autoencoders.vae.DecoderOutput`] instead of a plain tuple.
+
+        Returns:
+            [`~models.autoencoders.vae.DecoderOutput`] or `tuple`:
+                The round-tripped videos, shape `(batch_size, out_channels, num_frames, height, width)`.
+        """
+        posterior = self.encode(sample).latent_dist
+        z = posterior.sample(generator=generator) if sample_posterior else posterior.mode()
+        return self.decode(z, return_dict=return_dict)
diff --git a/src/diffusers/models/autoencoders/autoencoder_kl_minimax_h3_audio.py b/src/diffusers/models/autoencoders/autoencoder_kl_minimax_h3_audio.py
new file mode 100644
index 000000000000..c35c62e28ec3
--- /dev/null
+++ b/src/diffusers/models/autoencoders/autoencoder_kl_minimax_h3_audio.py
@@ -0,0 +1,679 @@
+# Copyright 2025 The MiniMax authors and The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""MiniMax-H3 audio autoencoder.
+
+Waveform in / waveform out — there is no mel front-end and no separate vocoder:
+
+* the **encoder** is a DAC-lineage strided convolutional stack (Snake activations, weight-normed
+  `Conv1d`) that downsamples by `prod(encoder_rates) = 800`, i.e. 40 latents/s at 32 kHz;
+* a **causal-attention projection** (`pre_block`) rewires the 2048-wide encoder trunk to the
+  32-channel latent width, followed by the `mean_proj` / `logs_proj` posterior heads;
+* the **decoder** is BigVGAN (anti-aliased SnakeBeta activations, transposed-conv upsamplers, AMP
+  residual blocks) preceded by `dec_in_proj`, upsampling by `prod(decoder_rates) = 800`.
+
+The autoencoder is **mono**. MiniMax-H3 carries stereo as two *batch* items — the pipeline decodes
+`[2, 32, T]` into `[2, 1, samples]` and interleaves at the output boundary — so no stereo handling
+belongs here.
+
+Latents are normalized with per-channel `latents_mean` / `latents_std` (32 floats each) rather than a
+scalar `scaling_factor`; both live in the config and are applied by the pipeline.
+
+Module and parameter names are identical to the original checkpoint, so conversion is a passthrough.
+That includes `torch.nn.utils.weight_norm` (the `weight_g` / `weight_v` spelling, as used by the
+other diffusers audio autoencoders) and the registered Kaiser-window resampling `filter` buffers of
+the anti-aliased activations.
+"""
+
+import math
+from dataclasses import dataclass
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.nn.utils import weight_norm
+
+from ...configuration_utils import ConfigMixin, register_to_config
+from ...utils import BaseOutput
+from ...utils.accelerate_utils import apply_forward_hook
+from ...utils.torch_utils import randn_tensor
+from ..attention import AttentionMixin, AttentionModuleMixin
+from ..attention_dispatch import dispatch_attention_fn
+from ..modeling_utils import ModelMixin, get_parameter_dtype
+from .vae import DecoderOutput
+
+
+class MiniMaxH3AudioDiagonalGaussianDistribution:
+    r"""Posterior of the MiniMax-H3 audio autoencoder, parameterized as `(mean, log_std)`.
+
+    The checkpoint keeps two separate `Conv1d` heads (`mean_proj`, `logs_proj`) instead of one fused
+    moments projection, and the second head predicts the **log standard deviation**, not the log
+    variance. The two tensors are therefore stored as produced, and `mode()` is bit-for-bit
+    `mean_proj`'s output.
+
+    Args:
+        mean (`torch.Tensor`): Posterior mean, `[batch_size, latent_channels, num_frames]`.
+        logs (`torch.Tensor`): Posterior log standard deviation, same shape as `mean`.
+    """
+
+    def __init__(self, mean: torch.Tensor, logs: torch.Tensor):
+        self.mean = mean
+        self.logs = logs
+        self.std = torch.exp(logs)
+
+    def mode(self) -> torch.Tensor:
+        return self.mean
+
+    def sample(self, generator: torch.Generator | None = None) -> torch.Tensor:
+        noise = randn_tensor(self.mean.shape, generator=generator, device=self.mean.device, dtype=self.mean.dtype)
+        return self.mean + self.std * noise
+
+
+@dataclass
+class MiniMaxH3AudioEncoderOutput(BaseOutput):
+    r"""
+    Output of [`AutoencoderKLMiniMaxH3Audio.encode`].
+
+    Args:
+        latent_dist (`MiniMaxH3AudioDiagonalGaussianDistribution`):
+            Posterior over the audio latents. MiniMax-H3 always consumes `latent_dist.mode()`.
+    """
+
+    latent_dist: MiniMaxH3AudioDiagonalGaussianDistribution
+
+
+def _wn_conv1d(*args, **kwargs) -> nn.Module:
+    return weight_norm(nn.Conv1d(*args, **kwargs))
+
+
+def kaiser_sinc_filter1d(cutoff: float, half_width: float, kernel_size: int) -> torch.Tensor:
+    r"""Kaiser-windowed sinc low-pass filter of shape `[1, 1, kernel_size]`.
+
+    Kept arithmetically identical to the `alias-free-torch` implementation the checkpoint was trained
+    with, because the resulting tensor is stored as a persistent buffer.
+    """
+    half_size = kernel_size // 2
+
+    attenuation = 2.285 * (half_size - 1) * math.pi * (4 * half_width) + 7.95
+    if attenuation > 50.0:
+        beta = 0.1102 * (attenuation - 8.7)
+    elif attenuation >= 21.0:
+        beta = 0.5842 * (attenuation - 21) ** 0.4 + 0.07886 * (attenuation - 21.0)
+    else:
+        beta = 0.0
+    window = torch.kaiser_window(kernel_size, beta=beta, periodic=False)
+
+    if kernel_size % 2 == 0:
+        time = torch.arange(-half_size, half_size) + 0.5
+    else:
+        time = torch.arange(kernel_size) - half_size
+
+    filter_ = 2 * cutoff * window * torch.sinc(2 * cutoff * time)
+    # Normalize to sum 1 so a constant input does not leak through the resampler.
+    filter_ /= filter_.sum()
+    return filter_.view(1, 1, kernel_size)
+
+
+class MiniMaxH3AudioSnake1d(nn.Module):
+    r"""`x + (alpha + 1e-9)^-1 * sin(alpha * x)^2` over `[batch_size, channels, length]`, with a
+    per-channel learnable `alpha` of shape `[1, channels, 1]`. Used throughout the DAC encoder."""
+
+    def __init__(self, channels: int):
+        super().__init__()
+        self.alpha = nn.Parameter(torch.ones(1, channels, 1))
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        return hidden_states + (self.alpha + 1e-9).reciprocal() * torch.sin(self.alpha * hidden_states).pow(2)
+
+
+class MiniMaxH3AudioSnakeBeta(nn.Module):
+    r"""`x + (exp(beta) + 1e-9)^-1 * sin(exp(alpha) * x)^2` over `[batch_size, channels, length]`.
+
+    The BigVGAN decoder's activation: separate frequency (`alpha`) and magnitude (`beta`) parameters,
+    both stored in log space as `[channels]` vectors.
+    """
+
+    def __init__(self, channels: int):
+        super().__init__()
+        self.alpha = nn.Parameter(torch.zeros(channels))
+        self.beta = nn.Parameter(torch.zeros(channels))
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        alpha = torch.exp(self.alpha.unsqueeze(0).unsqueeze(-1))
+        beta = torch.exp(self.beta.unsqueeze(0).unsqueeze(-1))
+        return hidden_states + (beta + 1e-9).reciprocal() * torch.sin(alpha * hidden_states).pow(2)
+
+
+class MiniMaxH3AudioLowPassFilter1d(nn.Module):
+    r"""Depthwise Kaiser-sinc low-pass filter with a stride, i.e. the anti-aliased downsampler."""
+
+    def __init__(self, cutoff: float, half_width: float, stride: int, kernel_size: int):
+        super().__init__()
+        even = kernel_size % 2 == 0
+        self.pad_left = kernel_size // 2 - int(even)
+        self.pad_right = kernel_size // 2
+        self.stride = stride
+        self.register_buffer("filter", kaiser_sinc_filter1d(cutoff, half_width, kernel_size))
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        num_channels = hidden_states.shape[1]
+        hidden_states = F.pad(hidden_states, (self.pad_left, self.pad_right), mode="replicate")
+        return F.conv1d(
+            hidden_states, self.filter.expand(num_channels, -1, -1), stride=self.stride, groups=num_channels
+        )
+
+
+class MiniMaxH3AudioUpSample1d(nn.Module):
+    r"""Anti-aliased `ratio`x upsampler (transposed depthwise Kaiser-sinc convolution)."""
+
+    def __init__(self, ratio: int, kernel_size: int):
+        super().__init__()
+        self.ratio = ratio
+        self.stride = ratio
+        self.pad = kernel_size // ratio - 1
+        self.pad_left = self.pad * self.stride + (kernel_size - self.stride) // 2
+        self.pad_right = self.pad * self.stride + (kernel_size - self.stride + 1) // 2
+        self.register_buffer(
+            "filter",
+            kaiser_sinc_filter1d(cutoff=0.5 / ratio, half_width=0.6 / ratio, kernel_size=kernel_size),
+        )
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        num_channels = hidden_states.shape[1]
+        hidden_states = F.pad(hidden_states, (self.pad, self.pad), mode="replicate")
+        hidden_states = self.ratio * F.conv_transpose1d(
+            hidden_states, self.filter.expand(num_channels, -1, -1), stride=self.stride, groups=num_channels
+        )
+        return hidden_states[..., self.pad_left : -self.pad_right]
+
+
+class MiniMaxH3AudioDownSample1d(nn.Module):
+    r"""Anti-aliased `ratio`x downsampler."""
+
+    def __init__(self, ratio: int, kernel_size: int):
+        super().__init__()
+        self.lowpass = MiniMaxH3AudioLowPassFilter1d(
+            cutoff=0.5 / ratio, half_width=0.6 / ratio, stride=ratio, kernel_size=kernel_size
+        )
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        return self.lowpass(hidden_states)
+
+
+class MiniMaxH3AudioActivation1d(nn.Module):
+    r"""Upsample -> activation -> downsample: the alias-free activation wrapper used by BigVGAN."""
+
+    def __init__(self, activation: nn.Module, ratio: int = 2, kernel_size: int = 12):
+        super().__init__()
+        self.act = activation
+        self.upsample = MiniMaxH3AudioUpSample1d(ratio, kernel_size)
+        self.downsample = MiniMaxH3AudioDownSample1d(ratio, kernel_size)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.upsample(hidden_states)
+        hidden_states = self.act(hidden_states)
+        return self.downsample(hidden_states)
+
+
+class MiniMaxH3AudioResidualUnit(nn.Module):
+    r"""DAC residual unit: `Snake -> dilated Conv1d(k=7) -> Snake -> Conv1d(k=1)`, plus a shortcut
+    that is center-cropped when the dilated convolution shrinks the time axis."""
+
+    def __init__(self, dim: int, dilation: int):
+        super().__init__()
+        self.block = nn.Sequential(
+            MiniMaxH3AudioSnake1d(dim),
+            _wn_conv1d(dim, dim, kernel_size=7, dilation=dilation, padding=((7 - 1) * dilation) // 2),
+            MiniMaxH3AudioSnake1d(dim),
+            _wn_conv1d(dim, dim, kernel_size=1),
+        )
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        residual = self.block(hidden_states)
+        pad = (hidden_states.shape[-1] - residual.shape[-1]) // 2
+        if pad > 0:
+            hidden_states = hidden_states[..., pad:-pad]
+        return hidden_states + residual
+
+
+class MiniMaxH3AudioEncoderBlock(nn.Module):
+    r"""Three residual units at dilations 1/3/9, then a strided channel-doubling convolution."""
+
+    def __init__(self, dim: int, stride: int):
+        super().__init__()
+        self.block = nn.Sequential(
+            MiniMaxH3AudioResidualUnit(dim // 2, dilation=1),
+            MiniMaxH3AudioResidualUnit(dim // 2, dilation=3),
+            MiniMaxH3AudioResidualUnit(dim // 2, dilation=9),
+            MiniMaxH3AudioSnake1d(dim // 2),
+            _wn_conv1d(
+                dim // 2,
+                dim,
+                kernel_size=2 * stride,
+                stride=stride,
+                padding=math.ceil(stride / 2),
+            ),
+        )
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        return self.block(hidden_states)
+
+
+class MiniMaxH3AudioEncoder(nn.Module):
+    r"""DAC waveform encoder: `[batch_size, 1, samples] -> [batch_size, latent_dim, samples / 800]`."""
+
+    def __init__(self, d_model: int, strides: tuple[int, ...], d_latent: int):
+        super().__init__()
+        block: list[nn.Module] = [_wn_conv1d(1, d_model, kernel_size=7, padding=3)]
+        for stride in strides:
+            d_model *= 2
+            block.append(MiniMaxH3AudioEncoderBlock(d_model, stride=stride))
+        block += [
+            MiniMaxH3AudioSnake1d(d_model),
+            _wn_conv1d(d_model, d_latent, kernel_size=3, padding=1),
+        ]
+        self.block = nn.Sequential(*block)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        return self.block(hidden_states)
+
+
+class MiniMaxH3AudioGeGluMlp(nn.Module):
+    r"""Pre-norm GeGLU MLP used inside the attention projection block."""
+
+    def __init__(self, in_features: int, hidden_features: int):
+        super().__init__()
+        self.norm = nn.LayerNorm(in_features)
+        self.act = nn.GELU(approximate="tanh")
+        self.w0 = nn.Linear(in_features, hidden_features)
+        self.w1 = nn.Linear(in_features, hidden_features)
+        self.w2 = nn.Linear(hidden_features, in_features)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.norm(hidden_states)
+        hidden_states = self.act(self.w0(hidden_states)) * self.w1(hidden_states)
+        return self.w2(hidden_states)
+
+
+class MiniMaxH3AudioAttnProcessor:
+    r"""Processor of [`MiniMaxH3AudioCausalAttention`].
+
+    The causal mask is expressed as `is_causal=True` rather than as a materialized mask. Every
+    attention backend honours that flag, with two exceptions: `_native_npu`, whose kernel takes no
+    causal argument and would compute *bidirectional* attention, and context parallelism, which
+    raises for causal attention.
+    """
+
+    _attention_backend = None
+    _parallel_config = None
+
+    def __call__(self, attn: "MiniMaxH3AudioCausalAttention", hidden_states: torch.Tensor) -> torch.Tensor:
+        batch_size, seq_len, _ = hidden_states.shape
+        qkv = F.linear(
+            input=hidden_states,
+            weight=attn.qkv.weight,
+            bias=torch.cat((attn.q_bias, attn.zero_k_bias, attn.v_bias)),
+        )
+        query, key, value = (
+            qkv.reshape(batch_size, seq_len, 3, attn.num_heads, attn.head_dim).permute(2, 0, 1, 3, 4).unbind(0)
+        )
+        hidden_states = dispatch_attention_fn(
+            query,
+            key,
+            value,
+            attn_mask=None,
+            is_causal=True,
+            backend=self._attention_backend,
+            parallel_config=self._parallel_config,
+        )
+        # The heads are mean-pooled away instead of being concatenated, and the head dimension that
+        # remains is adaptively average-pooled down to `out_dim`.
+        hidden_states = torch.mean(hidden_states, dim=2)
+        hidden_states = F.adaptive_avg_pool1d(hidden_states, attn.out_dim)
+        return attn.proj(hidden_states)
+
+
+class MiniMaxH3AudioCausalAttention(nn.Module, AttentionModuleMixin):
+    r"""Causal self-attention that narrows the feature width from `in_dim` to `out_dim`.
+
+    QKV is a single bias-less `nn.Linear`; query and value biases are separate parameters and the key
+    bias is a frozen zero buffer (`zero_k_bias`), exactly as stored in the checkpoint. Heads are
+    `in_dim // num_heads` wide; instead of being concatenated they are **mean-pooled away**, and the
+    remaining head dimension is adaptively average-pooled down to `out_dim`.
+    """
+
+    _default_processor_cls = MiniMaxH3AudioAttnProcessor
+    _available_processors = [MiniMaxH3AudioAttnProcessor]
+    # The checkpoint stores one fused `qkv` projection, so there is nothing to fuse.
+    _supports_qkv_fusion = False
+
+    def __init__(self, in_dim: int, out_dim: int, num_heads: int):
+        super().__init__()
+        self.out_dim = out_dim
+        self.num_heads = num_heads
+        self.head_dim = in_dim // num_heads
+        self.qkv = nn.Linear(in_dim, in_dim * 3, bias=False)
+        self.q_bias = nn.Parameter(torch.zeros(in_dim))
+        self.v_bias = nn.Parameter(torch.zeros(in_dim))
+        self.register_buffer("zero_k_bias", torch.zeros(in_dim))
+        self.proj = nn.Linear(out_dim, out_dim)
+
+        self.set_processor(MiniMaxH3AudioAttnProcessor())
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        return self.processor(self, hidden_states)
+
+
+class MiniMaxH3AudioAttnProjection(nn.Module):
+    r"""`pre_block`: residual causal-attention + GeGLU block that rewires `latent_dim` -> `latent_channels`."""
+
+    def __init__(self, in_dim: int, out_dim: int, num_heads: int, mlp_ratio: int = 2):
+        super().__init__()
+        self.norm1 = nn.LayerNorm(in_dim)
+        self.attn = MiniMaxH3AudioCausalAttention(in_dim, out_dim, num_heads)
+        self.proj = nn.Linear(in_dim, out_dim)
+        self.norm3 = nn.LayerNorm(in_dim)
+        self.norm2 = nn.LayerNorm(out_dim)
+        self.mlp = MiniMaxH3AudioGeGluMlp(in_features=out_dim, hidden_features=out_dim * mlp_ratio)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.proj(self.norm3(hidden_states)) + self.attn(self.norm1(hidden_states))
+        return hidden_states + self.mlp(self.norm2(hidden_states))
+
+
+class MiniMaxH3AudioAMPBlock(nn.Module):
+    r"""BigVGAN anti-aliased multi-periodicity block (`AMPBlock1`).
+
+    Each dilation contributes a `(dilated conv, dilation-1 conv)` pair, and every convolution is
+    preceded by its own alias-free SnakeBeta activation.
+    """
+
+    def __init__(self, channels: int, kernel_size: int, dilation: tuple[int, ...]):
+        super().__init__()
+        self.convs1 = nn.ModuleList(
+            [
+                _wn_conv1d(channels, channels, kernel_size, dilation=d, padding=(kernel_size * d - d) // 2)
+                for d in dilation
+            ]
+        )
+        self.convs2 = nn.ModuleList(
+            [_wn_conv1d(channels, channels, kernel_size, dilation=1, padding=(kernel_size - 1) // 2) for _ in dilation]
+        )
+        self.activations = nn.ModuleList(
+            [
+                MiniMaxH3AudioActivation1d(activation=MiniMaxH3AudioSnakeBeta(channels))
+                for _ in range(2 * len(dilation))
+            ]
+        )
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        acts1, acts2 = self.activations[::2], self.activations[1::2]
+        for conv1, conv2, act1, act2 in zip(self.convs1, self.convs2, acts1, acts2):
+            residual = conv1(act1(hidden_states))
+            residual = conv2(act2(residual))
+            hidden_states = residual + hidden_states
+        return hidden_states
+
+
+class MiniMaxH3AudioBigVGANDecoder(nn.Module):
+    r"""BigVGAN decoder: `[batch_size, latent_dim, num_frames] -> [batch_size, 1, num_frames * 800]`."""
+
+    def __init__(
+        self,
+        in_channels: int,
+        upsample_initial_channel: int,
+        upsample_rates: tuple[int, ...],
+        upsample_kernel_sizes: tuple[int, ...],
+        resblock_kernel_sizes: tuple[int, ...],
+        resblock_dilation_sizes: tuple[tuple[int, ...], ...],
+    ):
+        super().__init__()
+        self.num_kernels = len(resblock_kernel_sizes)
+        self.num_upsamples = len(upsample_rates)
+
+        self.conv_pre = _wn_conv1d(in_channels, upsample_initial_channel, 7, 1, padding=3)
+
+        # Each upsampler is wrapped in a one-element `ModuleList` in the original checkpoint
+        # (`ups.<i>.0`); the extra nesting is kept so the state dict stays a passthrough.
+        self.ups = nn.ModuleList()
+        for i, (rate, kernel) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
+            self.ups.append(
+                nn.ModuleList(
+                    [
+                        weight_norm(
+                            nn.ConvTranspose1d(
+                                upsample_initial_channel // (2**i),
+                                upsample_initial_channel // (2 ** (i + 1)),
+                                kernel,
+                                rate,
+                                padding=(kernel - rate) // 2,
+                            )
+                        )
+                    ]
+                )
+            )
+
+        self.resblocks = nn.ModuleList()
+        for i in range(self.num_upsamples):
+            channels = upsample_initial_channel // (2 ** (i + 1))
+            for kernel, dilation in zip(resblock_kernel_sizes, resblock_dilation_sizes):
+                self.resblocks.append(MiniMaxH3AudioAMPBlock(channels, kernel, tuple(dilation)))
+
+        self.activation_post = MiniMaxH3AudioActivation1d(activation=MiniMaxH3AudioSnakeBeta(channels))
+        self.conv_post = _wn_conv1d(channels, 1, 7, 1, padding=3, bias=False)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.conv_pre(hidden_states)
+
+        for i in range(self.num_upsamples):
+            hidden_states = self.ups[i][0](hidden_states)
+            residual = None
+            for j in range(self.num_kernels):
+                block = self.resblocks[i * self.num_kernels + j](hidden_states)
+                residual = block if residual is None else residual + block
+            hidden_states = residual / self.num_kernels
+
+        hidden_states = self.activation_post(hidden_states)
+        hidden_states = self.conv_post(hidden_states)
+        return torch.clamp(hidden_states, min=-1.0, max=1.0)
+
+
+class AutoencoderKLMiniMaxH3Audio(ModelMixin, ConfigMixin, AttentionMixin):
+    r"""
+    The audio autoencoder used by [MiniMax-H3](https://huggingface.co/MiniMaxAI): a DAC-lineage
+    convolutional encoder and a BigVGAN decoder, operating directly on mono 32 kHz waveforms.
+
+    This model inherits from [`ModelMixin`]. Check the superclass documentation for the generic methods the library
+    implements for all models (such as downloading or saving).
+
+    Args:
+        encoder_dim (`int`, defaults to `64`):
+            Channel width of the encoder's first convolution; doubles at every downsampling stage.
+        encoder_rates (`tuple[int]`, defaults to `(2, 4, 4, 5, 5)`):
+            Encoder strides. Their product (`800`) is the hop length, i.e. 40 latents/s at 32 kHz.
+        latent_dim (`int`, defaults to `2048`):
+            Width of the encoder trunk and of the decoder input, before/after the latent projections.
+        latent_channels (`int`, defaults to `32`):
+            Width of the diffusion latent, i.e. the `mean_proj` / `logs_proj` output channels.
+        num_attention_heads (`int`, defaults to `8`):
+            Number of heads in the causal-attention projection `pre_block`.
+        decoder_dim (`int`, defaults to `1024`):
+            BigVGAN initial channel count; halved at every upsampling stage.
+        decoder_rates (`tuple[int]`, defaults to `(5, 5, 2, 2, 2, 2, 2)`):
+            BigVGAN upsampling rates. Their product must equal `prod(encoder_rates)`.
+        decoder_kernel_sizes (`tuple[int]`, defaults to `(9, 9, 4, 4, 4, 4, 4)`):
+            Transposed-convolution kernel size per upsampling stage.
+        resblock_kernel_sizes (`tuple[int]`, defaults to `(3, 7, 11)`):
+            Kernel sizes of the parallel AMP residual blocks at each upsampling stage.
+        resblock_dilation_sizes (`tuple[tuple[int]]`, defaults to `((1, 3, 5), (1, 3, 5), (1, 3, 5))`):
+            Per-AMP-block dilations.
+        sampling_rate (`int`, defaults to `32000`):
+            Waveform sampling rate.
+        latents_mean (`list[float]`, *optional*):
+            Per-channel latent mean the pipeline uses to normalize / denormalize latents.
+        latents_std (`list[float]`, *optional*):
+            Per-channel latent standard deviation the pipeline uses to normalize / denormalize latents.
+    """
+
+    _supports_gradient_checkpointing = False
+    # The released checkpoint is float32 and the DAC/BigVGAN stack (weight-normalized convolutions, Snake
+    # activations) degrades audibly under bfloat16 (roughly 20 dB quieter decodes), so a pipeline-level
+    # `torch_dtype=torch.bfloat16` must not downcast the weights.
+    _keep_in_fp32_modules = ["encoder", "decoder", "pre_block", "dec_in_proj", "mean_proj", "logs_proj"]
+
+    @register_to_config
+    def __init__(
+        self,
+        encoder_dim: int = 64,
+        encoder_rates: tuple[int, ...] = (2, 4, 4, 5, 5),
+        latent_dim: int = 2048,
+        latent_channels: int = 32,
+        num_attention_heads: int = 8,
+        decoder_dim: int = 1024,
+        decoder_rates: tuple[int, ...] = (5, 5, 2, 2, 2, 2, 2),
+        decoder_kernel_sizes: tuple[int, ...] = (9, 9, 4, 4, 4, 4, 4),
+        resblock_kernel_sizes: tuple[int, ...] = (3, 7, 11),
+        resblock_dilation_sizes: tuple[tuple[int, ...], ...] = ((1, 3, 5), (1, 3, 5), (1, 3, 5)),
+        sampling_rate: int = 32000,
+        latents_mean: list[float] | None = None,
+        latents_std: list[float] | None = None,
+    ):
+        super().__init__()
+
+        encoder_rates = tuple(int(rate) for rate in encoder_rates)
+        decoder_rates = tuple(int(rate) for rate in decoder_rates)
+        self.hop_length = math.prod(encoder_rates)
+        if math.prod(decoder_rates) != self.hop_length:
+            raise ValueError(
+                f"`decoder_rates` must upsample by the encoder hop length {self.hop_length}, got "
+                f"{math.prod(decoder_rates)}."
+            )
+        if latent_dim % latent_channels != 0:
+            raise ValueError(
+                f"`latent_dim` ({latent_dim}) must be a multiple of `latent_channels` ({latent_channels})."
+            )
+
+        self.encoder = MiniMaxH3AudioEncoder(d_model=encoder_dim, strides=encoder_rates, d_latent=latent_dim)
+        self.pre_block = MiniMaxH3AudioAttnProjection(latent_dim, latent_channels, num_heads=num_attention_heads)
+        self.mean_proj = nn.Conv1d(latent_channels, latent_channels, 1)
+        self.logs_proj = nn.Conv1d(latent_channels, latent_channels, 1)
+
+        self.dec_in_proj = nn.Conv1d(latent_channels, latent_dim, 1)
+        self.decoder = MiniMaxH3AudioBigVGANDecoder(
+            in_channels=latent_dim,
+            upsample_initial_channel=decoder_dim,
+            upsample_rates=decoder_rates,
+            upsample_kernel_sizes=tuple(int(kernel) for kernel in decoder_kernel_sizes),
+            resblock_kernel_sizes=tuple(int(kernel) for kernel in resblock_kernel_sizes),
+            resblock_dilation_sizes=tuple(tuple(int(d) for d in dilation) for dilation in resblock_dilation_sizes),
+        )
+
+    @apply_forward_hook
+    def encode(
+        self, sample: torch.Tensor, return_dict: bool = True
+    ) -> MiniMaxH3AudioEncoderOutput | tuple[MiniMaxH3AudioDiagonalGaussianDistribution]:
+        r"""
+        Encode a waveform into the audio latent posterior.
+
+        The waveform is right-padded to a multiple of `hop_length` (800 samples) first. MiniMax-H3
+        always consumes the posterior **mean** (`latent_dist.mode()`) — the `logs_proj` head is never
+        evaluated by the reference pipeline.
+
+        Args:
+            sample (`torch.Tensor`):
+                Mono waveform of shape `[batch_size, 1, samples]`. MiniMax-H3 passes the two stereo
+                channels of a reference clip as `batch_size = 2`.
+            return_dict (`bool`, defaults to `True`):
+                Whether to return a [`MiniMaxH3AudioEncoderOutput`] instead of a plain tuple.
+
+        Returns:
+            [`MiniMaxH3AudioEncoderOutput`] or `tuple`:
+                The latent posterior over `[batch_size, latent_channels, samples / 800]`.
+        """
+        if sample.ndim != 3 or sample.shape[1] != 1:
+            raise ValueError(f"`sample` must have shape [batch_size, 1, samples], got {tuple(sample.shape)}.")
+
+        right_pad = math.ceil(sample.shape[-1] / self.hop_length) * self.hop_length - sample.shape[-1]
+        if right_pad > 0:
+            sample = F.pad(sample, (0, right_pad))
+
+        encoder_dtype = get_parameter_dtype(self.encoder)
+        hidden_states = self.encoder(sample.to(encoder_dtype))
+        hidden_states = self.pre_block(hidden_states.transpose(1, 2)).transpose(1, 2)
+        mean, logs = self.mean_proj(hidden_states), self.logs_proj(hidden_states)
+        if encoder_dtype != torch.float32:
+            mean, logs = mean.float(), logs.float()
+
+        posterior = MiniMaxH3AudioDiagonalGaussianDistribution(mean, logs)
+        if not return_dict:
+            return (posterior,)
+        return MiniMaxH3AudioEncoderOutput(latent_dist=posterior)
+
+    @apply_forward_hook
+    def decode(self, latents: torch.Tensor, return_dict: bool = True) -> DecoderOutput | tuple[torch.Tensor]:
+        r"""
+        Decode audio latents into a waveform.
+
+        Args:
+            latents (`torch.Tensor`):
+                Denormalized latents of shape `[batch_size, latent_channels, num_frames]`. MiniMax-H3
+                passes the two stereo channels as `batch_size = 2`.
+            return_dict (`bool`, defaults to `True`):
+                Whether to return a [`~models.autoencoders.vae.DecoderOutput`] instead of a plain tuple.
+
+        Returns:
+            [`~models.autoencoders.vae.DecoderOutput`] or `tuple`:
+                Waveform of shape `[batch_size, 1, num_frames * 800]`, clamped to `[-1, 1]`.
+        """
+        if latents.ndim != 3:
+            raise ValueError(
+                f"`latents` must have shape [batch_size, latent_channels, num_frames], got {tuple(latents.shape)}."
+            )
+
+        decoder_dtype = get_parameter_dtype(self.decoder)
+        decoded = self.decoder(self.dec_in_proj(latents.to(decoder_dtype)))
+        if decoder_dtype != torch.float32:
+            decoded = decoded.float()
+
+        if not return_dict:
+            return (decoded,)
+        return DecoderOutput(sample=decoded)
+
+    def forward(
+        self,
+        sample: torch.Tensor,
+        sample_posterior: bool = False,
+        return_dict: bool = True,
+        generator: torch.Generator | None = None,
+    ) -> DecoderOutput | tuple[torch.Tensor]:
+        r"""
+        Encode then decode a waveform.
+
+        Args:
+            sample (`torch.Tensor`):
+                Mono waveform of shape `[batch_size, 1, samples]`.
+            sample_posterior (`bool`, defaults to `False`):
+                Whether to sample the posterior instead of taking its mode. MiniMax-H3 uses the mode.
+            return_dict (`bool`, defaults to `True`):
+                Whether to return a [`~models.autoencoders.vae.DecoderOutput`] instead of a plain tuple.
+            generator (`torch.Generator`, *optional*):
+                Generator used when `sample_posterior=True`.
+
+        Returns:
+            [`~models.autoencoders.vae.DecoderOutput`] or `tuple`:
+                The round-tripped waveform of shape `[batch_size, 1, num_frames * 800]`, clamped to `[-1, 1]`.
+        """
+        posterior = self.encode(sample).latent_dist
+        latents = posterior.sample(generator=generator) if sample_posterior else posterior.mode()
+        return self.decode(latents, return_dict=return_dict)
diff --git a/src/diffusers/models/transformers/__init__.py b/src/diffusers/models/transformers/__init__.py
index 21f5cb853643..7a1213639e3d 100755
--- a/src/diffusers/models/transformers/__init__.py
+++ b/src/diffusers/models/transformers/__init__.py
@@ -50,6 +50,7 @@
     from .transformer_ltx import LTXVideoTransformer3DModel
     from .transformer_ltx2 import LTX2VideoTransformer3DModel
     from .transformer_lumina2 import Lumina2Transformer2DModel
+    from .transformer_minimax_h3 import MiniMaxH3Transformer3DModel
     from .transformer_mochi import MochiTransformer3DModel
     from .transformer_motif_video import MotifVideoTransformer3DModel
     from .transformer_nucleusmoe_image import NucleusMoEImageTransformer2DModel
diff --git a/src/diffusers/models/transformers/transformer_minimax_h3.py b/src/diffusers/models/transformers/transformer_minimax_h3.py
new file mode 100644
index 000000000000..5170f149a8ee
--- /dev/null
+++ b/src/diffusers/models/transformers/transformer_minimax_h3.py
@@ -0,0 +1,644 @@
+# Copyright 2025 The MiniMax Team and The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass
+from typing import Any
+
+import torch
+import torch.nn as nn
+
+from ...configuration_utils import ConfigMixin, register_to_config
+from ...loaders import PeftAdapterMixin
+from ...utils import BaseOutput, apply_lora_scale, logging
+from ..attention import AttentionMixin, AttentionModuleMixin, FeedForward
+from ..attention_dispatch import dispatch_attention_fn
+from ..cache_utils import CacheMixin
+from ..embeddings import TimestepEmbedding, Timesteps
+from ..modeling_utils import ModelMixin
+
+
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
+
+
+# MiniMax-H3 tags every row of the packed sequence with the modality it belongs to and keeps one set of AdaLN
+# modulation parameters per (timestep, modality) pair: 0 = video, 1 = text, 2 = audio.
+MINIMAX_H3_MODALITY_NUM = 3
+
+
+@dataclass
+class MiniMaxH3TransformerOutput(BaseOutput):
+    r"""
+    The output of [`MiniMaxH3Transformer3DModel`].
+
+    Args:
+        sample (`torch.Tensor` of shape `(batch_size, num_video_tokens, in_channels * prod(patch_size))`):
+            The video velocity prediction for the rows addressed by `video_indices`, in the same order. Conditioning
+            rows are returned unmasked — masking them out before the scheduler step is the caller's job.
+        audio_sample (`torch.Tensor` of shape `(batch_size, num_audio_tokens, audio_in_channels)`):
+            The audio velocity prediction for the rows addressed by `audio_indices`, in the same order.
+    """
+
+    sample: torch.Tensor
+    audio_sample: torch.Tensor
+
+
+def _apply_rotary_emb(hidden_states: torch.Tensor, cos: torch.Tensor, sin: torch.Tensor) -> torch.Tensor:
+    r"""
+    Rotate the leading `rotary_dim` channels of every head and pass the remaining channels through unchanged.
+    `hidden_states` is `(batch_size, seq_len, num_heads, head_dim)` and `cos`/`sin` are `(seq_len, rotary_dim)`.
+    """
+    rotary_dim = cos.shape[-1]
+    hidden_states_rotary = hidden_states[..., :rotary_dim]
+    hidden_states_pass = hidden_states[..., rotary_dim:]
+
+    cos = cos.to(hidden_states.dtype)[None, :, None, :]
+    sin = sin.to(hidden_states.dtype)[None, :, None, :]
+    x1, x2 = hidden_states_rotary.chunk(2, dim=-1)
+    hidden_states_rotated = torch.cat((-x2, x1), dim=-1)
+    hidden_states_rotary = hidden_states_rotary * cos + hidden_states_rotated * sin
+    return torch.cat((hidden_states_rotary, hidden_states_pass), dim=-1).contiguous()
+
+
+class MiniMaxH3RotaryPosEmbed(nn.Module):
+    r"""
+    3-axis rotary embedding over the `(t, h, w)` coordinates of the packed sequence.
+
+    A single `inv_freq` buffer of `rope_freq_dim` frequencies is shared by the three axes. Each axis contributes
+    `rope_freq_dim` angles, the three blocks are concatenated to `3 * rope_freq_dim` and then concatenated with
+    themselves so that the `rotate_half` convention rotates `2 * 3 * rope_freq_dim` of the `head_dim` channels.
+    """
+
+    def __init__(self, rope_freq_dim: int = 16, rope_theta: float = 10000.0):
+        super().__init__()
+        self.rope_freq_dim = rope_freq_dim
+        inv_freq = 1.0 / (
+            rope_theta ** (torch.arange(0, 2 * rope_freq_dim, 2, dtype=torch.float32) / (2 * rope_freq_dim))
+        )
+        self.register_buffer("inv_freq", inv_freq, persistent=False)
+
+    def forward(self, position_ids: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+        # position_ids: (seq_len, 3) -> cos/sin: (seq_len, 2 * 3 * rope_freq_dim)
+        position_ids = position_ids.to(torch.float32)
+        freqs = position_ids.unsqueeze(-1) * self.inv_freq.view(1, 1, -1)  # (seq_len, 3, rope_freq_dim)
+        freqs_t, freqs_h, freqs_w = freqs.unbind(dim=1)
+        freqs = torch.cat((freqs_t, freqs_h, freqs_w), dim=-1)
+        freqs = torch.cat((freqs, freqs), dim=-1)
+        return freqs.cos(), freqs.sin()
+
+
+class MiniMaxH3AdaLayerNormModulation(nn.Module):
+    r"""
+    Projects the shared timestep embedding into the six per-(timestep, modality) modulation parameters of one
+    transformer block.
+
+    `(num_timesteps, time_embed_dim)` -> six tensors of shape `(num_timesteps * MINIMAX_H3_MODALITY_NUM,
+    hidden_size)`, in the diffusers `shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp` order. The row
+    layout of the returned tensors is `[t0_mod0, t0_mod1, t0_mod2, t1_mod0, ...]`, which is what `timestep_indices *
+    MINIMAX_H3_MODALITY_NUM + token_tags` addresses.
+
+    A single projection is shared by `norm1` and `norm2` and by the three modalities, so it cannot be folded into
+    either norm the way [`~models.normalization.AdaLayerNormZero`] does. It is therefore a block-level module of its
+    own, named after the checkpoint's `adaln_proj`, with the modulation projection under the `linear` name diffusers
+    uses inside every AdaLN module.
+    """
+
+    def __init__(self, time_embed_dim: int, hidden_size: int):
+        super().__init__()
+        self.hidden_size = hidden_size
+        self.linear = nn.Linear(time_embed_dim, 6 * hidden_size * MINIMAX_H3_MODALITY_NUM, bias=True)
+
+    def forward(self, temb: torch.Tensor) -> tuple[torch.Tensor, ...]:
+        # The activation runs at `temb`'s own precision — float32, since `time_embedder` is a float32 module in this
+        # mixed-precision checkpoint — and only its result is cast down to the bfloat16 projection. Every block reads
+        # the same `temb`, so a rounding applied before the activation biases every block's modulation parameters
+        # identically at every sampling step, which accumulates coherently over the denoising trajectory.
+        temb = self.linear(nn.functional.silu(temb).to(self.linear.weight.dtype))
+        temb = temb.view(-1, 6 * self.hidden_size)
+        return temb.chunk(6, dim=-1)
+
+
+class MiniMaxH3AdaLayerNormOut(nn.Module):
+    r"""
+    Final norm of the packed sequence, shift/scale modulated per row.
+
+    Same module layout and checkpoint keys as [`~models.normalization.AdaLayerNormContinuous`] (`norm` plus a `linear`
+    projecting the conditioning embedding to `2 * hidden_size`), with two MiniMax-H3 specifics: the modulation table
+    holds one row per *timestep* and is addressed per row of the packed sequence rather than per batch item, and the
+    two halves of the projection are `shift` then `scale`, the order `LTX2Transformer3DModel` and
+    `WanTransformer3DModel` also use in their output layers.
+    """
+
+    def __init__(self, hidden_size: int, time_embed_dim: int, eps: float):
+        super().__init__()
+        self.norm = nn.RMSNorm(hidden_size, eps=eps)
+        self.linear = nn.Linear(time_embed_dim, 2 * hidden_size, bias=True)
+
+    def forward(self, hidden_states: torch.Tensor, temb: torch.Tensor, timestep_indices: torch.Tensor) -> torch.Tensor:
+        # As in `MiniMaxH3AdaLayerNormModulation`: activate at `temb`'s precision, cast to the projection's dtype after.
+        shift, scale = self.linear(nn.functional.silu(temb).to(self.linear.weight.dtype)).chunk(2, dim=-1)
+        # The modulation itself stays at the block stack's precision; `forward` casts to the output heads' dtype.
+        hidden_states = self.norm(hidden_states)
+        return hidden_states * (1.0 + scale.index_select(0, timestep_indices)) + shift.index_select(
+            0, timestep_indices
+        )
+
+
+class MiniMaxH3AttnProcessor:
+    r"""
+    Full self-attention over one packed sequence. There is no cross-attention anywhere in MiniMax-H3.
+    """
+
+    _attention_backend = None
+    _parallel_config = None
+
+    def __call__(
+        self,
+        attn: "MiniMaxH3Attention",
+        hidden_states: torch.Tensor,
+        rotary_emb: tuple[torch.Tensor, torch.Tensor] | None = None,
+        attention_mask: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        if attn.fused_projections:
+            query, key, value = attn.to_qkv(hidden_states).chunk(3, dim=-1)
+        else:
+            query = attn.to_q(hidden_states)
+            key = attn.to_k(hidden_states)
+            value = attn.to_v(hidden_states)
+
+        query = query.unflatten(-1, (attn.heads, -1))
+        key = key.unflatten(-1, (attn.heads, -1))
+        value = value.unflatten(-1, (attn.heads, -1))
+
+        query = attn.norm_q(query)
+        key = attn.norm_k(key)
+
+        if rotary_emb is not None:
+            query = _apply_rotary_emb(query, *rotary_emb)
+            key = _apply_rotary_emb(key, *rotary_emb)
+
+        # Without padding rows the packed sequence is a single attention document and no mask is needed (passing an
+        # all-zero float mask here would hard-fail the flash / sage backends). When padding rows are present, the
+        # caller supplies a boolean mask that keeps them in their own attention document, mirroring the reference's
+        # `cu_seqlens = [0, used, S]` split; masked backends (SDPA & co.) are required in that case.
+        hidden_states = dispatch_attention_fn(
+            query,
+            key,
+            value,
+            attn_mask=attention_mask,
+            dropout_p=0.0,
+            is_causal=False,
+            backend=self._attention_backend,
+            parallel_config=self._parallel_config,
+        )
+        hidden_states = hidden_states.flatten(2, 3).type_as(query)
+        hidden_states = attn.to_out[0](hidden_states)
+        hidden_states = attn.to_out[1](hidden_states)
+        return hidden_states
+
+
+class MiniMaxH3Attention(nn.Module, AttentionModuleMixin):
+    _default_processor_cls = MiniMaxH3AttnProcessor
+    _available_processors = [MiniMaxH3AttnProcessor]
+
+    def __init__(
+        self,
+        hidden_size: int,
+        heads: int,
+        dim_head: int,
+        qk_norm_eps: float = 1e-5,
+        processor=None,
+    ):
+        super().__init__()
+        self.heads = heads
+        self.head_dim = dim_head
+        self.inner_dim = heads * dim_head
+        self.use_bias = False
+
+        self.to_q = nn.Linear(hidden_size, self.inner_dim, bias=False)
+        self.to_k = nn.Linear(hidden_size, self.inner_dim, bias=False)
+        self.to_v = nn.Linear(hidden_size, self.inner_dim, bias=False)
+        self.norm_q = nn.RMSNorm(dim_head, eps=qk_norm_eps)
+        self.norm_k = nn.RMSNorm(dim_head, eps=qk_norm_eps)
+        self.to_out = nn.ModuleList([nn.Linear(self.inner_dim, hidden_size, bias=False), nn.Dropout(0.0)])
+
+        if processor is None:
+            processor = self._default_processor_cls()
+        self.set_processor(processor)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        rotary_emb: tuple[torch.Tensor, torch.Tensor] | None = None,
+        attention_mask: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        return self.processor(self, hidden_states, rotary_emb, attention_mask)
+
+
+class MiniMaxH3TokenRefinerBlock(nn.Module):
+    r"""
+    Plain pre-norm transformer block used to refine the projected text stream. No AdaLN and no rotary embedding.
+    """
+
+    def __init__(
+        self,
+        hidden_size: int,
+        num_attention_heads: int,
+        attention_head_dim: int,
+        ffn_dim: int,
+        norm_eps: float,
+        qk_norm_eps: float,
+    ):
+        super().__init__()
+        self.norm1 = nn.RMSNorm(hidden_size, eps=norm_eps)
+        self.attn = MiniMaxH3Attention(
+            hidden_size=hidden_size,
+            heads=num_attention_heads,
+            dim_head=attention_head_dim,
+            qk_norm_eps=qk_norm_eps,
+        )
+        self.norm2 = nn.RMSNorm(hidden_size, eps=norm_eps)
+        self.ff = FeedForward(hidden_size, inner_dim=ffn_dim, activation_fn="swiglu", bias=False)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        hidden_states = hidden_states + self.attn(self.norm1(hidden_states))
+        hidden_states = hidden_states + self.ff(self.norm2(hidden_states))
+        return hidden_states
+
+
+class MiniMaxH3TokenRefiner(nn.Module):
+    def __init__(
+        self,
+        hidden_size: int,
+        num_attention_heads: int,
+        attention_head_dim: int,
+        ffn_dim: int,
+        num_layers: int,
+        norm_eps: float,
+        qk_norm_eps: float,
+        final_norm_eps: float,
+    ):
+        super().__init__()
+        self.refiner_blocks = nn.ModuleList(
+            [
+                MiniMaxH3TokenRefinerBlock(
+                    hidden_size=hidden_size,
+                    num_attention_heads=num_attention_heads,
+                    attention_head_dim=attention_head_dim,
+                    ffn_dim=ffn_dim,
+                    norm_eps=norm_eps,
+                    qk_norm_eps=qk_norm_eps,
+                )
+                for _ in range(num_layers)
+            ]
+        )
+        self.final_norm = nn.RMSNorm(hidden_size, eps=final_norm_eps)
+        self.gradient_checkpointing = False
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        for block in self.refiner_blocks:
+            if torch.is_grad_enabled() and self.gradient_checkpointing:
+                hidden_states = self._gradient_checkpointing_func(block, hidden_states)
+            else:
+                hidden_states = block(hidden_states)
+        return self.final_norm(hidden_states)
+
+
+class MiniMaxH3TransformerBlock(nn.Module):
+    r"""
+    MiniMax-H3 block: pre-norm self-attention and feed-forward, each modulated by AdaLN parameters selected per row of
+    the packed sequence from the `(timestep, modality)` table.
+    """
+
+    def __init__(
+        self,
+        hidden_size: int,
+        num_attention_heads: int,
+        attention_head_dim: int,
+        ffn_dim: int,
+        time_embed_dim: int,
+        norm_eps: float,
+        qk_norm_eps: float,
+    ):
+        super().__init__()
+        self.norm1 = nn.RMSNorm(hidden_size, eps=norm_eps)
+        self.attn = MiniMaxH3Attention(
+            hidden_size=hidden_size,
+            heads=num_attention_heads,
+            dim_head=attention_head_dim,
+            qk_norm_eps=qk_norm_eps,
+        )
+        self.norm2 = nn.RMSNorm(hidden_size, eps=norm_eps)
+        self.ff = FeedForward(hidden_size, inner_dim=ffn_dim, activation_fn="swiglu", bias=False)
+        self.adaln_proj = MiniMaxH3AdaLayerNormModulation(time_embed_dim=time_embed_dim, hidden_size=hidden_size)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        temb: torch.Tensor,
+        adaln_indices: torch.Tensor,
+        rotary_emb: tuple[torch.Tensor, torch.Tensor],
+        attention_mask: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.adaln_proj(temb)
+
+        residual = hidden_states
+        norm_hidden_states = self.norm1(hidden_states)
+        norm_hidden_states = norm_hidden_states * (
+            1.0 + scale_msa.index_select(0, adaln_indices)
+        ) + shift_msa.index_select(0, adaln_indices)
+        attn_output = self.attn(norm_hidden_states, rotary_emb, attention_mask)
+        hidden_states = residual + gate_msa.index_select(0, adaln_indices) * attn_output
+
+        residual = hidden_states
+        norm_hidden_states = self.norm2(hidden_states)
+        norm_hidden_states = norm_hidden_states * (
+            1.0 + scale_mlp.index_select(0, adaln_indices)
+        ) + shift_mlp.index_select(0, adaln_indices)
+        ff_output = self.ff(norm_hidden_states)
+        hidden_states = residual + gate_mlp.index_select(0, adaln_indices) * ff_output
+
+        return hidden_states
+
+
+class MiniMaxH3Transformer3DModel(ModelMixin, ConfigMixin, AttentionMixin, PeftAdapterMixin, CacheMixin):
+    r"""
+    A Transformer model for joint video + audio generation, introduced in MiniMax-H3.
+
+    MiniMax-H3 runs a single stack of blocks over **one packed 1-D sequence** that holds the text condition, the
+    conditioning image / video rows, the audio rows and the target video rows. Attention is full self-attention over
+    that sequence; there is no cross-attention and no per-modality block weights. Modality-specific behaviour comes
+    only from the two input patch projections, the per-row AdaLN modality tag, and the two output heads.
+
+    The caller is responsible for building the packed layout: patchifying the video latents, ordering the rows, and
+    producing the `(t, h, w)` position grid, the per-row modality tags and the per-row timestep indices. Padding rows
+    (tag `-1`) are kept in a separate attention document, matching the reference implementation, which pads to a
+    multiple of 64 for FlashAttention with `cu_seqlens = [0, used, S]`. Prefer dropping them — a padless sequence
+    needs no attention mask, keeping the unmasked attention backends available.
+
+    The batch axis is a pure replication axis: the structural arguments (`timestep`, `timestep_indices`, `token_tags`,
+    `position_ids` and the three index tensors) describe one packed layout that every batch item shares, and each item
+    is a single attention document.
+
+    Args:
+        num_attention_heads (`int`, defaults to `56`):
+            The number of heads to use for multi-head attention.
+        attention_head_dim (`int`, defaults to `128`):
+            The number of channels in each attention head. Note that `num_attention_heads * attention_head_dim` is
+            *larger* than `hidden_size` in MiniMax-H3.
+        hidden_size (`int`, defaults to `5376`):
+            The number of channels of the packed sequence (the residual stream).
+        num_layers (`int`, defaults to `50`):
+            The number of transformer blocks.
+        num_refiner_layers (`int`, defaults to `2`):
+            The number of token refiner blocks applied to the projected text stream.
+        ffn_dim (`int`, defaults to `14336`):
+            The inner dimension of the SwiGLU feed-forward layers.
+        in_channels (`int`, defaults to `24`):
+            The number of channels of the video latents.
+        audio_in_channels (`int`, defaults to `32`):
+            The number of channels of the audio latents.
+        patch_size (`tuple[int, int, int]`, defaults to `(1, 2, 2)`):
+            The `(t, h, w)` patch used to pack the video latents into rows.
+        text_dim (`int`, defaults to `5120`):
+            The number of channels of the text conditioning produced by the text encoder.
+        freq_dim (`int`, defaults to `256`):
+            The dimension of the sinusoidal timestep embedding. Timesteps are consumed unscaled in `[0, 1]`.
+        time_embed_hidden_dim (`int`, defaults to `5376`):
+            The inner dimension of the timestep MLP.
+        time_embed_dim (`int`, defaults to `2688`):
+            The output dimension of the timestep MLP, i.e. the input of every AdaLN projection.
+        rope_freq_dim (`int`, defaults to `16`):
+            The number of rotary frequencies per axis. The `(t, h, w)` axes share one `inv_freq` buffer of this length
+            and `2 * 3 * rope_freq_dim` of the `attention_head_dim` channels are rotated.
+        rope_theta (`float`, defaults to `10000.0`):
+            The base of the rotary frequency schedule the `rope.inv_freq` buffer is computed from.
+        norm_eps (`float`, defaults to `1e-5`):
+            Epsilon of the pre-attention and pre-feed-forward norms.
+        qk_norm_eps (`float`, defaults to `1e-5`):
+            Epsilon of the per-head query/key norms.
+        final_norm_eps (`float`, defaults to `1e-5`):
+            Epsilon of the token refiner output norm and of `norm_out`.
+    """
+
+    _supports_gradient_checkpointing = True
+    _no_split_modules = ["MiniMaxH3TransformerBlock", "MiniMaxH3TokenRefinerBlock", "MiniMaxH3AdaLayerNormOut"]
+    _repeated_blocks = ["MiniMaxH3TransformerBlock", "MiniMaxH3TokenRefinerBlock"]
+    _skip_layerwise_casting_patterns = ["norm"]
+    # MiniMax-H3 ships a mixed-precision checkpoint: the two input patch projections, the timestep MLP and the two
+    # output heads are float32 while everything else (including the AdaLN projections) is bfloat16. The `rope.inv_freq`
+    # buffer is computed rather than loaded and is kept float32 for the same reason the reference ships it float32.
+    # Entries are matched as substrings of the parameter name, so `proj_in` / `proj_out` also cover the audio heads.
+    _keep_in_fp32_modules = [
+        "proj_in",
+        "audio_proj_in",
+        "time_embedder",
+        "proj_out",
+        "audio_proj_out",
+        "rope",
+    ]
+
+    @register_to_config
+    def __init__(
+        self,
+        num_attention_heads: int = 56,
+        attention_head_dim: int = 128,
+        hidden_size: int = 5376,
+        num_layers: int = 50,
+        num_refiner_layers: int = 2,
+        ffn_dim: int = 14336,
+        in_channels: int = 24,
+        audio_in_channels: int = 32,
+        patch_size: tuple[int, int, int] = (1, 2, 2),
+        text_dim: int = 5120,
+        freq_dim: int = 256,
+        time_embed_hidden_dim: int = 5376,
+        time_embed_dim: int = 2688,
+        rope_freq_dim: int = 16,
+        rope_theta: float = 10000.0,
+        norm_eps: float = 1e-5,
+        qk_norm_eps: float = 1e-5,
+        final_norm_eps: float = 1e-5,
+    ) -> None:
+        super().__init__()
+
+        video_patch_dim = in_channels * patch_size[0] * patch_size[1] * patch_size[2]
+
+        # 1. Per-modality input projections
+        self.proj_in = nn.Linear(video_patch_dim, hidden_size, bias=True)
+        self.audio_proj_in = nn.Linear(audio_in_channels, hidden_size, bias=True)
+        self.context_embedder = nn.Linear(text_dim, hidden_size, bias=True)
+
+        # 2. Timestep embedding, shared by every AdaLN projection
+        self.time_proj = Timesteps(num_channels=freq_dim, flip_sin_to_cos=True, downscale_freq_shift=0)
+        self.time_embedder = TimestepEmbedding(
+            in_channels=freq_dim, time_embed_dim=time_embed_hidden_dim, out_dim=time_embed_dim
+        )
+
+        # 3. Rotary embedding over the packed (t, h, w) grid
+        self.rope = MiniMaxH3RotaryPosEmbed(rope_freq_dim=rope_freq_dim, rope_theta=rope_theta)
+
+        # 4. Text stream refiner
+        self.token_refiner = MiniMaxH3TokenRefiner(
+            hidden_size=hidden_size,
+            num_attention_heads=num_attention_heads,
+            attention_head_dim=attention_head_dim,
+            ffn_dim=ffn_dim,
+            num_layers=num_refiner_layers,
+            norm_eps=norm_eps,
+            qk_norm_eps=qk_norm_eps,
+            final_norm_eps=final_norm_eps,
+        )
+
+        # 5. The block stack
+        self.transformer_blocks = nn.ModuleList(
+            [
+                MiniMaxH3TransformerBlock(
+                    hidden_size=hidden_size,
+                    num_attention_heads=num_attention_heads,
+                    attention_head_dim=attention_head_dim,
+                    ffn_dim=ffn_dim,
+                    time_embed_dim=time_embed_dim,
+                    norm_eps=norm_eps,
+                    qk_norm_eps=qk_norm_eps,
+                )
+                for _ in range(num_layers)
+            ]
+        )
+
+        # 6. Shared output norm and the two per-modality output heads. Both heads run over every row of the packed
+        # sequence; the rows of each modality are selected afterwards.
+        self.norm_out = MiniMaxH3AdaLayerNormOut(
+            hidden_size=hidden_size, time_embed_dim=time_embed_dim, eps=final_norm_eps
+        )
+        self.proj_out = nn.Linear(hidden_size, video_patch_dim, bias=True)
+        self.audio_proj_out = nn.Linear(hidden_size, audio_in_channels, bias=True)
+
+        self.gradient_checkpointing = False
+
+    @apply_lora_scale("attention_kwargs")
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        audio_hidden_states: torch.Tensor,
+        encoder_hidden_states: torch.Tensor,
+        timestep: torch.Tensor,
+        timestep_indices: torch.Tensor,
+        token_tags: torch.Tensor,
+        position_ids: torch.Tensor,
+        video_indices: torch.Tensor,
+        audio_indices: torch.Tensor,
+        text_indices: torch.Tensor,
+        attention_kwargs: dict[str, Any] | None = None,
+        return_dict: bool = True,
+    ) -> MiniMaxH3TransformerOutput | tuple[torch.Tensor, torch.Tensor]:
+        r"""
+        Args:
+            hidden_states (`torch.Tensor` of shape `(batch_size, num_video_tokens, in_channels * prod(patch_size))`):
+                Patchified video latent rows — conditioning rows and target rows — ordered as they appear in the packed
+                sequence, i.e. matching `video_indices`.
+            audio_hidden_states (`torch.Tensor` of shape `(batch_size, num_audio_tokens, audio_in_channels)`):
+                Audio latent rows, ordered to match `audio_indices`.
+            encoder_hidden_states (`torch.Tensor` of shape `(batch_size, num_text_tokens, text_dim)`):
+                Text conditioning, ordered to match `text_indices`.
+            timestep (`torch.Tensor` of shape `(num_timesteps,)`):
+                The *distinct* timestep values present in the packed sequence, in `[0, 1]` and unscaled. One forward
+                serves rows at different noise levels (target video, target audio, conditioning rows).
+            timestep_indices (`torch.Tensor` of shape `(seq_len,)`):
+                For every row of the packed sequence, the index of its timestep in `timestep`.
+            token_tags (`torch.Tensor` of shape `(seq_len,)`):
+                For every row of the packed sequence, its modality: `0` video, `1` text, `2` audio, `-1` padding.
+                Padding rows form their own attention document and never reach the outputs.
+            position_ids (`torch.Tensor` of shape `(seq_len, 3)`):
+                The `(t, h, w)` rotary coordinates of every row of the packed sequence.
+            video_indices (`torch.Tensor` of shape `(num_video_tokens,)`):
+                Positions of the video rows in the packed sequence.
+            audio_indices (`torch.Tensor` of shape `(num_audio_tokens,)`):
+                Positions of the audio rows in the packed sequence.
+            text_indices (`torch.Tensor` of shape `(num_text_tokens,)`):
+                Positions of the text rows in the packed sequence.
+            attention_kwargs (`dict`, *optional*):
+                A kwargs dictionary that, if specified, may carry a `scale` entry which is applied to the LoRA layers.
+            return_dict (`bool`, defaults to `True`):
+                Whether to return a [`MiniMaxH3TransformerOutput`] instead of a plain tuple.
+
+        Returns:
+            [`MiniMaxH3TransformerOutput`] or `tuple`:
+                The video velocity of shape `(batch_size, num_video_tokens, in_channels * prod(patch_size))` and the
+                audio velocity of shape `(batch_size, num_audio_tokens, audio_in_channels)`, in the row order of
+                `video_indices` and `audio_indices`.
+        """
+        # `attention_kwargs` is consumed by the `@apply_lora_scale` decorator on this method.
+        if position_ids.ndim != 2 or position_ids.shape[-1] != 3:
+            raise ValueError(f"`position_ids` must be a `(seq_len, 3)` tensor, got {list(position_ids.shape)}.")
+        sequence_length = position_ids.shape[0]
+        if token_tags.shape != (sequence_length,) or timestep_indices.shape != (sequence_length,):
+            raise ValueError(
+                "`token_tags` and `timestep_indices` must both be `(seq_len,)` tensors matching `position_ids`, got "
+                f"{list(token_tags.shape)} and {list(timestep_indices.shape)} for seq_len={sequence_length}."
+            )
+
+        rotary_emb = self.rope(position_ids)
+
+        # 1. Project each modality and scatter the rows into the packed sequence buffer. The checkpoint is
+        # mixed-precision (the two patch projections are float32 while `context_embedder` and the block stack are
+        # bfloat16 — see `_keep_in_fp32_modules`), so every input is aligned with its projection's parameter dtype,
+        # mirroring the reference's explicit casts. The text stream sets the dtype of the packed sequence.
+        video_embeds = self.proj_in(hidden_states.to(self.proj_in.weight.dtype))
+        audio_embeds = self.audio_proj_in(audio_hidden_states.to(self.audio_proj_in.weight.dtype))
+        text_embeds = self.context_embedder(encoder_hidden_states.to(self.context_embedder.weight.dtype))
+        text_embeds = self.token_refiner(text_embeds)
+
+        hidden_states = text_embeds.new_zeros((text_embeds.shape[0], sequence_length, text_embeds.shape[-1]))
+        hidden_states = hidden_states.index_copy(1, text_indices, text_embeds)
+        hidden_states = hidden_states.index_copy(1, video_indices, video_embeds.to(text_embeds.dtype))
+        hidden_states = hidden_states.index_copy(1, audio_indices, audio_embeds.to(text_embeds.dtype))
+
+        # 2. One timestep embedding per distinct noise level. `temb` is shared by all AdaLN projections, which are
+        # bfloat16 in the checkpoint while `time_embedder` is float32, so it stays at the time embedder's precision:
+        # each AdaLN module applies its own activation to it and casts to its projection's dtype afterwards.
+        temb = self.time_proj(timestep)
+        temb = self.time_embedder(temb.to(self.time_embedder.linear_1.weight.dtype))
+
+        # 3. Row -> AdaLN table row. `clamp(min=0)` mirrors the reference, where padding rows carry the tag `-1`; the
+        # clamp keeps the `-1` from indexing backwards (padding rows never reach the outputs, which are selected by
+        # `video_indices` / `audio_indices`).
+        adaln_indices = timestep_indices * MINIMAX_H3_MODALITY_NUM + token_tags.clamp(min=0)
+
+        # 4. Padding rows (tag `-1`) must not exchange attention with live rows: the reference keeps the padding tail
+        # as a separate attention document (`cu_seqlens = [0, used, S]`). A boolean mask that pairs live rows with live
+        # rows and padding rows with padding rows reproduces that split exactly. Padless sequences keep `None` so the
+        # unmasked fast paths (flash & co.) stay available.
+        attention_mask = None
+        is_pad = token_tags < 0
+        if bool(is_pad.any()):
+            attention_mask = is_pad[None, :] == is_pad[:, None]
+
+        for block in self.transformer_blocks:
+            if torch.is_grad_enabled() and self.gradient_checkpointing:
+                hidden_states = self._gradient_checkpointing_func(
+                    block, hidden_states, temb, adaln_indices, rotary_emb, attention_mask
+                )
+            else:
+                hidden_states = block(hidden_states, temb, adaln_indices, rotary_emb, attention_mask)
+
+        # 5. Both heads run over every row, then the rows of each modality are selected. The heads are listed in
+        # `_keep_in_fp32_modules`, so they stay float32 while the block stack runs in the requested `torch_dtype`;
+        # align the activation with their parameter dtype.
+        hidden_states = self.norm_out(hidden_states, temb, timestep_indices).to(self.proj_out.weight.dtype)
+        video_output = self.proj_out(hidden_states).index_select(1, video_indices)
+        audio_output = self.audio_proj_out(hidden_states).index_select(1, audio_indices)
+
+        if not return_dict:
+            return (video_output, audio_output)
+        return MiniMaxH3TransformerOutput(sample=video_output, audio_sample=audio_output)
diff --git a/src/diffusers/modular_pipelines/__init__.py b/src/diffusers/modular_pipelines/__init__.py
index 6471b951285a..a107a004b7f2 100644
--- a/src/diffusers/modular_pipelines/__init__.py
+++ b/src/diffusers/modular_pipelines/__init__.py
@@ -121,6 +121,12 @@
         "LTXAutoBlocks",
         "LTXModularPipeline",
     ]
+    _import_structure["minimax_h3"] = [
+        "MiniMaxH3Blocks",
+        "MiniMaxH3ModularPipeline",
+        "MiniMaxH3Ref2VABlocks",
+        "MiniMaxH3Ref2VAModularPipeline",
+    ]
     _import_structure["z_image"] = [
         "ZImageAutoBlocks",
         "ZImageModularPipeline",
@@ -175,6 +181,12 @@
             Krea2TurboModularPipeline,
         )
         from .ltx import LTXAutoBlocks, LTXModularPipeline
+        from .minimax_h3 import (
+            MiniMaxH3Blocks,
+            MiniMaxH3ModularPipeline,
+            MiniMaxH3Ref2VABlocks,
+            MiniMaxH3Ref2VAModularPipeline,
+        )
         from .modular_pipeline import (
             AutoPipelineBlocks,
             BlockState,
diff --git a/src/diffusers/modular_pipelines/minimax_h3/__init__.py b/src/diffusers/modular_pipelines/minimax_h3/__init__.py
new file mode 100644
index 000000000000..6f492f17eff1
--- /dev/null
+++ b/src/diffusers/modular_pipelines/minimax_h3/__init__.py
@@ -0,0 +1,49 @@
+from typing import TYPE_CHECKING
+
+from ...utils import (
+    DIFFUSERS_SLOW_IMPORT,
+    OptionalDependencyNotAvailable,
+    _LazyModule,
+    get_objects_from_module,
+    is_torch_available,
+    is_transformers_available,
+)
+
+
+_dummy_objects = {}
+_import_structure = {}
+
+try:
+    if not (is_transformers_available() and is_torch_available()):
+        raise OptionalDependencyNotAvailable()
+except OptionalDependencyNotAvailable:
+    from ...utils import dummy_torch_and_transformers_objects  # noqa F403
+
+    _dummy_objects.update(get_objects_from_module(dummy_torch_and_transformers_objects))
+else:
+    _import_structure["modular_blocks_minimax_h3"] = ["MiniMaxH3Blocks", "MiniMaxH3Ref2VABlocks"]
+    _import_structure["modular_pipeline"] = ["MiniMaxH3ModularPipeline", "MiniMaxH3Ref2VAModularPipeline"]
+    _import_structure["packing_ref2va"] = ["MiniMaxH3Reference"]
+
+if TYPE_CHECKING or DIFFUSERS_SLOW_IMPORT:
+    try:
+        if not (is_transformers_available() and is_torch_available()):
+            raise OptionalDependencyNotAvailable()
+    except OptionalDependencyNotAvailable:
+        from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
+    else:
+        from .modular_blocks_minimax_h3 import MiniMaxH3Blocks, MiniMaxH3Ref2VABlocks
+        from .modular_pipeline import MiniMaxH3ModularPipeline, MiniMaxH3Ref2VAModularPipeline
+        from .packing_ref2va import MiniMaxH3Reference
+else:
+    import sys
+
+    sys.modules[__name__] = _LazyModule(
+        __name__,
+        globals()["__file__"],
+        _import_structure,
+        module_spec=__spec__,
+    )
+
+    for name, value in _dummy_objects.items():
+        setattr(sys.modules[__name__], name, value)
diff --git a/src/diffusers/modular_pipelines/minimax_h3/before_denoise.py b/src/diffusers/modular_pipelines/minimax_h3/before_denoise.py
new file mode 100644
index 000000000000..ef874b1e0100
--- /dev/null
+++ b/src/diffusers/modular_pipelines/minimax_h3/before_denoise.py
@@ -0,0 +1,425 @@
+# Copyright 2026 The MiniMax and HuggingFace Teams. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+
+from ...schedulers import MiniMaxH3Scheduler
+from ...utils import logging
+from ...utils.torch_utils import randn_tensor
+from ..modular_pipeline import ModularPipelineBlocks, PipelineState
+from ..modular_pipeline_utils import ComponentSpec, InputParam, OutputParam
+from .modular_pipeline import MiniMaxH3ModularPipeline, MiniMaxH3Ref2VAModularPipeline
+from .packing import (
+    MINIMAX_H3_AUDIO_CHANNELS,
+    MINIMAX_H3_KEYFRAME_NOISE_AUG,
+    MiniMaxH3PackedSequence,
+    build_packed_sequence,
+    build_row_timesteps,
+    patchify_video_latents,
+)
+from .packing_ref2va import MiniMaxH3PreparedReference, build_ref2va_packed_sequence
+
+
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
+
+
+def _layout_inputs() -> list[InputParam]:
+    r"""What both packed layouts are built from, beyond the conditioning of the task itself."""
+    return [
+        InputParam(
+            name="text_token_tags",
+            type_hint=torch.Tensor,
+            required=True,
+            description="The per-row modality tag of every row of `prompt_embeds`.",
+        ),
+        InputParam(
+            name="num_latent_frames", type_hint=int, required=True, description="Number of video latent frames."
+        ),
+        InputParam(name="latent_height", type_hint=int, required=True, description="Height of the video latents."),
+        InputParam(name="latent_width", type_hint=int, required=True, description="Width of the video latents."),
+        InputParam(
+            name="num_audio_latents",
+            type_hint=int,
+            required=True,
+            description="Number of audio latents per channel.",
+        ),
+    ]
+
+
+def _layout_outputs() -> list[OutputParam]:
+    r"""The row layout of the packed sequence, shared by the two tasks."""
+    return [
+        OutputParam(
+            "layout",
+            type_hint=MiniMaxH3PackedSequence,
+            description="The structural description of the packed sequence.",
+        ),
+        OutputParam(
+            "position_ids",
+            type_hint=torch.Tensor,
+            description="The `(t, h, w)` rotary coordinate of every row, in float64.",
+        ),
+        OutputParam("token_tags", type_hint=torch.Tensor, description="The modality tag of every row."),
+        OutputParam(
+            "video_indices",
+            type_hint=torch.Tensor,
+            description="Sequence positions of the video rows, conditioning rows first.",
+        ),
+        OutputParam(
+            "audio_indices",
+            type_hint=torch.Tensor,
+            description="Sequence positions of the audio rows, reference rows first.",
+        ),
+        OutputParam("text_indices", type_hint=torch.Tensor, description="Sequence positions of the text rows."),
+        OutputParam(
+            "num_condition_video_rows",
+            type_hint=int,
+            description="How many leading video rows are conditioning rows rather than generated rows.",
+        ),
+        OutputParam(
+            "num_condition_audio_rows",
+            type_hint=int,
+            description="How many leading audio rows are reference rows rather than generated rows.",
+        ),
+    ]
+
+
+def _set_layout_state(block_state, layout: MiniMaxH3PackedSequence, device: torch.device) -> None:
+    block_state.layout = layout
+    block_state.position_ids = layout.position_ids.to(device)
+    block_state.token_tags = layout.token_tags.to(device)
+    block_state.video_indices = layout.video_indices.to(device)
+    block_state.audio_indices = layout.audio_indices.to(device)
+    block_state.text_indices = layout.text_indices.to(device)
+    block_state.num_condition_video_rows = layout.num_condition_video_rows
+    block_state.num_condition_audio_rows = layout.num_condition_audio_rows
+
+
+class MiniMaxH3PrepareLayoutStep(ModularPipelineBlocks):
+    model_name = "minimax-h3"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Builds the packed layout of a `t2va` / `fl2va` request — `[text | keyframe conditions | target audio | "
+            "target video]` — and its fp64 rotary grid. MiniMax-H3 runs full self-attention over this one sequence, "
+            "so the layout is what every later block addresses rows through."
+        )
+
+    @property
+    def inputs(self) -> list[InputParam]:
+        return [
+            *_layout_inputs(),
+            InputParam(
+                name="keyframe_anchors",
+                type_hint=tuple,
+                default=(),
+                description="Which end of the video every keyframe is anchored to, in packed order.",
+            ),
+        ]
+
+    @property
+    def intermediate_outputs(self) -> list[OutputParam]:
+        return _layout_outputs()
+
+    @torch.no_grad()
+    def __call__(self, components: MiniMaxH3ModularPipeline, state: PipelineState) -> PipelineState:
+        block_state = self.get_block_state(state)
+
+        layout = build_packed_sequence(
+            block_state.text_token_tags,
+            block_state.num_latent_frames,
+            block_state.latent_height,
+            block_state.latent_width,
+            block_state.num_audio_latents,
+            components.patch_size,
+            block_state.keyframe_anchors,
+        )
+        _set_layout_state(block_state, layout, components._execution_device)
+
+        self.set_block_state(state, block_state)
+        return components, state
+
+
+class MiniMaxH3Ref2VAPrepareLayoutStep(ModularPipelineBlocks):
+    model_name = "minimax-h3-ref2va"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Builds the packed layout of a `ref2va` request — `[text | reference blocks | target audio | target "
+            "video]` — and its fp64 rotary grid. The reference order advances the shared audio/video rotary clock, so "
+            "it is part of the layout rather than a detail of the presentation."
+        )
+
+    @property
+    def inputs(self) -> list[InputParam]:
+        return [
+            *_layout_inputs(),
+            InputParam(
+                name="prepared_references",
+                type_hint=list[MiniMaxH3PreparedReference],
+                required=True,
+                description="The prepared references, in packed order, with their latent geometry filled in.",
+            ),
+        ]
+
+    @property
+    def intermediate_outputs(self) -> list[OutputParam]:
+        return _layout_outputs()
+
+    @torch.no_grad()
+    def __call__(self, components: MiniMaxH3Ref2VAModularPipeline, state: PipelineState) -> PipelineState:
+        block_state = self.get_block_state(state)
+
+        layout = build_ref2va_packed_sequence(
+            block_state.text_token_tags,
+            block_state.prepared_references,
+            block_state.num_latent_frames,
+            block_state.latent_height,
+            block_state.latent_width,
+            block_state.num_audio_latents,
+            components.patch_size,
+        )
+        _set_layout_state(block_state, layout, components._execution_device)
+
+        self.set_block_state(state, block_state)
+        return components, state
+
+
+class MiniMaxH3PrepareLatentsStep(ModularPipelineBlocks):
+    model_name = "minimax-h3"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Draws the initial noise of the generated rows and prepends the conditioning rows. MiniMax-H3 draws the "
+            "video noise as a latent tensor and patchifies it afterwards, then the audio noise directly in row "
+            "layout — both off the request's generator, after the conditioning noise of the encoder step."
+        )
+
+    @property
+    def inputs(self) -> list[InputParam]:
+        return [
+            InputParam(
+                name="num_latent_frames", type_hint=int, required=True, description="Number of video latent frames."
+            ),
+            InputParam(name="latent_height", type_hint=int, required=True, description="Height of the video latents."),
+            InputParam(name="latent_width", type_hint=int, required=True, description="Width of the video latents."),
+            InputParam(
+                name="num_audio_latents",
+                type_hint=int,
+                required=True,
+                description="Number of audio latents per channel.",
+            ),
+            InputParam.template(
+                "generator",
+                description=(
+                    "The generator of the request. The video noise is drawn from it first, then the audio noise."
+                ),
+            ),
+            InputParam(
+                name="latents",
+                type_hint=torch.Tensor,
+                description=(
+                    "Pre-generated video noise of shape `(1, 24, num_latent_frames, latent_height, latent_width)`, "
+                    "used instead of the draw."
+                ),
+            ),
+            InputParam(
+                name="audio_latents",
+                type_hint=torch.Tensor,
+                description="Pre-generated audio noise of shape `(2, 32, num_audio_latents)`.",
+            ),
+            InputParam(
+                name="condition_latents",
+                type_hint=torch.Tensor,
+                description="The video conditioning rows to prepend, or None for a request that has none.",
+            ),
+            InputParam(
+                name="audio_condition_latents",
+                type_hint=torch.Tensor,
+                description="The audio conditioning rows to prepend, or None for a request that has none.",
+            ),
+        ]
+
+    @property
+    def intermediate_outputs(self) -> list[OutputParam]:
+        return [
+            OutputParam(
+                "latents",
+                type_hint=torch.Tensor,
+                description="The video rows of the packed sequence, conditioning rows first.",
+            ),
+            OutputParam(
+                "audio_latents",
+                type_hint=torch.Tensor,
+                description="The channel-major audio rows of the packed sequence, reference rows first.",
+            ),
+        ]
+
+    @staticmethod
+    def prepare_latents(
+        components,
+        num_latent_frames: int,
+        latent_height: int,
+        latent_width: int,
+        num_audio_latents: int,
+        device: torch.device,
+        generator: torch.Generator | list[torch.Generator] | None = None,
+        latents: torch.Tensor | None = None,
+        audio_latents: torch.Tensor | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        r"""
+        Draw the initial noise of both modalities and pack it into transformer rows.
+
+        A request draws every stream from the one generator it is given, and the order is part of what that generator
+        reproduces: the conditioning noise of the keyframes or references first (one draw per condition, in
+        [`~modular_pipelines.minimax_h3.packing.keyframe_condition_noise`]), then the video noise here, as a latent tensor
+        that is patchified afterwards, then the audio noise, directly in row layout. Passing `latents` or
+        `audio_latents` skips its draw and shifts the ones after it.
+
+        Args:
+            num_latent_frames (`int`): Number of video latent frames.
+            latent_height (`int`): Latent height.
+            latent_width (`int`): Latent width.
+            num_audio_latents (`int`): Number of audio latents per channel.
+            device (`torch.device`): The device the rows are drawn on.
+            generator (`torch.Generator`, *optional*): The generator of the request.
+            latents (`torch.Tensor`, *optional*):
+                Pre-generated video noise of shape `(1, latent_channels, num_latent_frames, latent_height,
+                latent_width)`, used instead of the draw.
+            audio_latents (`torch.Tensor`, *optional*):
+                Pre-generated audio noise of shape `(2, audio_latent_channels, num_audio_latents)`.
+
+        Returns:
+            `tuple[torch.Tensor, torch.Tensor]`: the video rows and the channel-major audio rows.
+        """
+        if latents is None:
+            latents = randn_tensor(
+                (1, components.vae_latent_channels, num_latent_frames, latent_height, latent_width),
+                generator=generator,
+                device=device,
+                dtype=torch.float32,
+            )
+        video_rows = patchify_video_latents(latents.to(torch.float32), components.patch_size)
+
+        if audio_latents is None:
+            audio_rows = randn_tensor(
+                (num_audio_latents * MINIMAX_H3_AUDIO_CHANNELS, components.audio_latent_channels),
+                generator=generator,
+                device=device,
+                dtype=torch.float32,
+            )
+        else:
+            audio_rows = audio_latents.to(torch.float32).permute(0, 2, 1).reshape(-1, components.audio_latent_channels)
+        return video_rows.to(device), audio_rows.to(device)
+
+    @torch.no_grad()
+    def __call__(self, components: MiniMaxH3ModularPipeline, state: PipelineState) -> PipelineState:
+        block_state = self.get_block_state(state)
+
+        latents, audio_latents = self.prepare_latents(
+            components,
+            block_state.num_latent_frames,
+            block_state.latent_height,
+            block_state.latent_width,
+            block_state.num_audio_latents,
+            components._execution_device,
+            block_state.generator,
+            block_state.latents,
+            block_state.audio_latents,
+        )
+        if block_state.condition_latents is not None:
+            latents = torch.cat([block_state.condition_latents, latents])
+        if block_state.audio_condition_latents is not None:
+            audio_latents = torch.cat([block_state.audio_condition_latents, audio_latents])
+        block_state.latents, block_state.audio_latents = latents, audio_latents
+
+        self.set_block_state(state, block_state)
+        return components, state
+
+
+class MiniMaxH3SetTimestepsStep(ModularPipelineBlocks):
+    model_name = "minimax-h3"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Initializes the two schedules — `shift = 12.0` for video, `shift = 3.0` for audio — and stages the "
+            "row-to-timestep plan of every step. One forward serves every modality and every noise level at once: "
+            "the generated rows step down their own schedule while the conditioning rows stay pinned at their "
+            "noise-augmentation level, and that assignment is static per step."
+        )
+
+    @property
+    def expected_components(self) -> list[ComponentSpec]:
+        return [
+            ComponentSpec("scheduler", MiniMaxH3Scheduler),
+            ComponentSpec("audio_scheduler", MiniMaxH3Scheduler),
+        ]
+
+    @property
+    def inputs(self) -> list[InputParam]:
+        return [
+            InputParam.template("num_inference_steps", required=True),
+            InputParam(
+                name="layout",
+                type_hint=MiniMaxH3PackedSequence,
+                required=True,
+                description="The structural description of the packed sequence.",
+            ),
+        ]
+
+    @property
+    def intermediate_outputs(self) -> list[OutputParam]:
+        return [
+            OutputParam("timesteps", type_hint=torch.Tensor, description="Timesteps of the video schedule."),
+            OutputParam("audio_timesteps", type_hint=torch.Tensor, description="Timesteps of the audio schedule."),
+            OutputParam(
+                "row_timestep_plan",
+                type_hint=list,
+                description=(
+                    "One `(timestep, timestep_indices)` pair per step: the distinct timesteps of the sequence and the "
+                    "index of every row into them."
+                ),
+            ),
+        ]
+
+    @torch.no_grad()
+    def __call__(self, components: MiniMaxH3ModularPipeline, state: PipelineState) -> PipelineState:
+        block_state = self.get_block_state(state)
+        device = components._execution_device
+
+        components.scheduler.set_timesteps(block_state.num_inference_steps, device=device)
+        components.audio_scheduler.set_timesteps(block_state.num_inference_steps, device=device)
+        block_state.timesteps = components.scheduler.timesteps
+        block_state.audio_timesteps = components.audio_scheduler.timesteps
+
+        block_state.row_timestep_plan = [
+            tuple(
+                tensor.to(device)
+                for tensor in build_row_timesteps(
+                    block_state.layout,
+                    float(timestep),
+                    float(audio_timestep),
+                    max(float(timestep), MINIMAX_H3_KEYFRAME_NOISE_AUG),
+                    1.0,
+                )
+            )
+            for timestep, audio_timestep in zip(block_state.timesteps, block_state.audio_timesteps)
+        ]
+
+        self.set_block_state(state, block_state)
+        return components, state
diff --git a/src/diffusers/modular_pipelines/minimax_h3/before_encoder.py b/src/diffusers/modular_pipelines/minimax_h3/before_encoder.py
new file mode 100644
index 000000000000..88978bb6ff77
--- /dev/null
+++ b/src/diffusers/modular_pipelines/minimax_h3/before_encoder.py
@@ -0,0 +1,408 @@
+# Copyright 2026 The MiniMax and HuggingFace Teams. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import PIL
+import torch
+from PIL import Image, ImageOps
+
+from ...utils import logging
+from ..modular_pipeline import ModularPipelineBlocks, PipelineState
+from ..modular_pipeline_utils import InputParam, OutputParam
+from .modular_pipeline import MiniMaxH3ModularPipeline, MiniMaxH3Ref2VAModularPipeline
+from .packing import (
+    MINIMAX_H3_CANVAS_MULTIPLE,
+    MINIMAX_H3_FPS,
+    MINIMAX_H3_MAX_DURATION,
+    MINIMAX_H3_MIN_DURATION,
+    align_num_frames,
+    audio_latent_num_frames,
+    prepare_keyframe_image,
+    resolve_canvas_size,
+    video_latent_num_frames,
+)
+from .packing_ref2va import (
+    MINIMAX_H3_MAX_REFERENCE_AUDIOS,
+    MINIMAX_H3_MAX_REFERENCE_IMAGES,
+    MINIMAX_H3_MAX_REFERENCE_VIDEOS,
+    MINIMAX_H3_MAX_REFERENCES,
+    MiniMaxH3PreparedReference,
+    MiniMaxH3Reference,
+    prepare_reference_frames,
+    prepare_reference_image,
+    prepare_reference_waveform,
+    reference_kind,
+    reference_media_to_uint8,
+    resample_reference_frames,
+    resolve_reference_image_size,
+)
+
+
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
+
+
+def _latent_geometry(components, height: int, width: int, num_frames: int) -> tuple[int, int, int, int]:
+    r"""The latent geometry the packed layout, the noise draws and the decoders all key off."""
+    ratio = components.vae_spatial_compression_ratio
+    return video_latent_num_frames(num_frames), height // ratio, width // ratio, audio_latent_num_frames(num_frames)
+
+
+def _latent_geometry_outputs() -> list[OutputParam]:
+    r"""The declaration of what [`_latent_geometry`] resolves, shared by the two setup blocks."""
+    return [
+        OutputParam("num_latent_frames", type_hint=int, description="Number of generated video latent frames."),
+        OutputParam("latent_height", type_hint=int, description="Height of the generated video latents."),
+        OutputParam("latent_width", type_hint=int, description="Width of the generated video latents."),
+        OutputParam("num_audio_latents", type_hint=int, description="Number of generated audio latents per channel."),
+    ]
+
+
+class MiniMaxH3SetupStep(ModularPipelineBlocks):
+    model_name = "minimax-h3"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Resolves the plan shared by the `t2va` and `fl2va` tasks: the canvas (MiniMax-H3's own 768-short-edge "
+            "geometry for the aspect ratio of the first keyframe, or 16:9 without keyframes), the `17 * n + 5` frame "
+            "count the video VAE can decode, the latent geometry every later block keys off, and the keyframes put "
+            "onto that canvas."
+        )
+
+    @staticmethod
+    def _check_inputs(block_state) -> None:
+        if (block_state.height is None) != (block_state.width is None):
+            raise ValueError("`height` and `width` have to be passed together, or neither of them.")
+        if block_state.height is not None and (
+            block_state.height % MINIMAX_H3_CANVAS_MULTIPLE or block_state.width % MINIMAX_H3_CANVAS_MULTIPLE
+        ):
+            raise ValueError(
+                f"`height` and `width` must be multiples of {MINIMAX_H3_CANVAS_MULTIPLE}, got "
+                f"{block_state.height}x{block_state.width}."
+            )
+        # The duration the request generates is the one of the *aligned* frame count, so that is what the ceiling has
+        # to hold for: 346 frames would otherwise pass the check and then be rounded up to 362, i.e. 15.083 seconds.
+        aligned_num_frames = align_num_frames(block_state.num_frames)
+        duration = aligned_num_frames / MINIMAX_H3_FPS
+        if not MINIMAX_H3_MIN_DURATION <= duration <= MINIMAX_H3_MAX_DURATION:
+            raise ValueError(
+                f"MiniMax-H3 generates between {MINIMAX_H3_MIN_DURATION} and {MINIMAX_H3_MAX_DURATION} seconds at "
+                f"{MINIMAX_H3_FPS} fps, so `num_frames`, rounded up to the next `17 * n + 5` the video VAE can "
+                f"encode, must be between {int(MINIMAX_H3_MIN_DURATION * MINIMAX_H3_FPS)} and "
+                f"{int(MINIMAX_H3_MAX_DURATION * MINIMAX_H3_FPS)}, got {block_state.num_frames} (rounded up to "
+                f"{aligned_num_frames})."
+            )
+
+    @property
+    def inputs(self) -> list[InputParam]:
+        return [
+            InputParam(
+                name="image",
+                type_hint=PIL.Image.Image,
+                description=(
+                    "Keyframe the video starts from. It is *stretched* onto the target canvas, which by default is "
+                    "derived from its own aspect ratio."
+                ),
+            ),
+            InputParam(
+                name="last_image",
+                type_hint=PIL.Image.Image,
+                description=(
+                    "Keyframe the video ends on. Can be passed on its own to generate *up to* a frame. Combined with "
+                    "`image` it is the follower of the two and is cover-cropped onto the canvas."
+                ),
+            ),
+            InputParam.template("height", description="Height of the generated video in pixels, a multiple of 32."),
+            InputParam.template("width", description="Width of the generated video in pixels, a multiple of 32."),
+            InputParam(
+                name="num_frames",
+                type_hint=int,
+                default=124,
+                description=(
+                    "Number of frames to generate, at the fixed 24 fps. Snapped up to the next `17 * n + 5` the video "
+                    "VAE can decode; the resulting duration must stay between 5 and 15 seconds."
+                ),
+            ),
+        ]
+
+    @property
+    def intermediate_outputs(self) -> list[OutputParam]:
+        return [
+            OutputParam("height", type_hint=int, description="Resolved height of the generated video in pixels."),
+            OutputParam("width", type_hint=int, description="Resolved width of the generated video in pixels."),
+            OutputParam("num_frames", type_hint=int, description="Resolved number of frames, of the form 17 * n + 5."),
+            *_latent_geometry_outputs(),
+            OutputParam(
+                "keyframes",
+                type_hint=list,
+                description="The keyframes put onto the target canvas, in packed order (empty for `t2va`).",
+            ),
+            OutputParam(
+                "keyframe_anchors",
+                type_hint=tuple,
+                description="Which end of the video every keyframe is anchored to, in packed order.",
+            ),
+        ]
+
+    @torch.no_grad()
+    def __call__(self, components: MiniMaxH3ModularPipeline, state: PipelineState) -> PipelineState:
+        block_state = self.get_block_state(state)
+        self._check_inputs(block_state)
+
+        keyframes = [
+            ImageOps.exif_transpose(keyframe).convert("RGB")
+            for keyframe in (block_state.image, block_state.last_image)
+            if keyframe is not None
+        ]
+        block_state.keyframe_anchors = tuple(
+            anchor
+            for anchor, keyframe in (("first", block_state.image), ("last", block_state.last_image))
+            if keyframe is not None
+        )
+        if block_state.height is None:
+            block_state.height, block_state.width = resolve_canvas_size(*(keyframes[0].size if keyframes else (16, 9)))
+
+        aligned_num_frames = align_num_frames(block_state.num_frames)
+        if aligned_num_frames != block_state.num_frames:
+            logger.warning(
+                f"`num_frames` has to be of the form 17 * n + 5 for the video VAE; rounding {block_state.num_frames} "
+                f"up to {aligned_num_frames}."
+            )
+            block_state.num_frames = aligned_num_frames
+
+        (
+            block_state.num_latent_frames,
+            block_state.latent_height,
+            block_state.latent_width,
+            block_state.num_audio_latents,
+        ) = _latent_geometry(components, block_state.height, block_state.width, block_state.num_frames)
+
+        block_state.keyframes = [
+            prepare_keyframe_image(keyframe, block_state.height, block_state.width, stretch=index == 0)
+            for index, keyframe in enumerate(keyframes)
+        ]
+        self.set_block_state(state, block_state)
+        return components, state
+
+
+class MiniMaxH3Ref2VASetupStep(ModularPipelineBlocks):
+    model_name = "minimax-h3-ref2va"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Resolves the `ref2va` plan: the canvas (MiniMax-H3's own 16:9 unless asked otherwise — references never "
+            "bind the generated geometry), the references prepared at their own resolutions, the frame count they "
+            "imply when it was left open, and the latent geometry every later block keys off."
+        )
+
+    @staticmethod
+    def _check_inputs(components, block_state) -> None:
+        if (block_state.height is None) != (block_state.width is None):
+            raise ValueError("`height` and `width` have to be passed together, or neither of them.")
+        if block_state.height is not None and (
+            block_state.height % MINIMAX_H3_CANVAS_MULTIPLE or block_state.width % MINIMAX_H3_CANVAS_MULTIPLE
+        ):
+            raise ValueError(
+                f"`height` and `width` must be multiples of {MINIMAX_H3_CANVAS_MULTIPLE}, got "
+                f"{block_state.height}x{block_state.width}."
+            )
+        # The duration the request generates is the one of the *aligned* frame count, so that is what the ceiling has
+        # to hold for: 346 frames would otherwise pass the check and then be rounded up to 362, i.e. 15.083 seconds.
+        aligned_num_frames = None if block_state.num_frames is None else align_num_frames(block_state.num_frames)
+        duration = None if aligned_num_frames is None else aligned_num_frames / MINIMAX_H3_FPS
+        if duration is not None and not MINIMAX_H3_MIN_DURATION <= duration <= MINIMAX_H3_MAX_DURATION:
+            raise ValueError(
+                f"MiniMax-H3 generates between {MINIMAX_H3_MIN_DURATION} and {MINIMAX_H3_MAX_DURATION} seconds at "
+                f"{MINIMAX_H3_FPS} fps, so `num_frames`, rounded up to the next `17 * n + 5` the video VAE can "
+                f"encode, must be between {int(MINIMAX_H3_MIN_DURATION * MINIMAX_H3_FPS)} and "
+                f"{int(MINIMAX_H3_MAX_DURATION * MINIMAX_H3_FPS)}, got {block_state.num_frames} (rounded up to "
+                f"{aligned_num_frames})."
+            )
+
+        if not block_state.references:
+            raise ValueError(
+                "`ref2va` needs at least one reference; use `MiniMaxH3ModularPipeline` for text-only requests."
+            )
+        kinds = [reference_kind(index, entry) for index, entry in enumerate(block_state.references)]
+        for kind, limit in (
+            ("image", MINIMAX_H3_MAX_REFERENCE_IMAGES),
+            ("video", MINIMAX_H3_MAX_REFERENCE_VIDEOS),
+            ("audio", MINIMAX_H3_MAX_REFERENCE_AUDIOS),
+        ):
+            if kinds.count(kind) > limit:
+                raise ValueError(f"MiniMax-H3 accepts at most {limit} {kind} references, got {kinds.count(kind)}.")
+        if len(kinds) > MINIMAX_H3_MAX_REFERENCES:
+            raise ValueError(
+                f"MiniMax-H3 accepts at most {MINIMAX_H3_MAX_REFERENCES} references in total, got {len(kinds)}."
+            )
+        if set(kinds) == {"audio"}:
+            raise ValueError(
+                "An audio reference has to be paired with at least one image or video reference and cannot be used "
+                "on its own."
+            )
+
+    @property
+    def inputs(self) -> list[InputParam]:
+        return [
+            InputParam(
+                name="references",
+                type_hint=list[MiniMaxH3Reference],
+                required=True,
+                description=(
+                    "The references to condition on, **in the order the model should read them**: the order labels "
+                    "them in the prompt presentation and lays them out on the shared rotary clock, so a different "
+                    "order is a different request. Every [`MiniMaxH3Reference`] carries exactly one medium, a path or "
+                    "in-memory media — `image` (at most 9), `video` at its own `fps` (at most 3, whose `audio` "
+                    "soundtrack is conditioned on as well), or `audio` at its own `sample_rate` (at most 3) — for at "
+                    "most 12 references in total, and audio references cannot be the only ones. A path is decoded "
+                    "when the reference is built, so these blocks only ever see pixels and samples."
+                ),
+            ),
+            InputParam.template("height", description="Height of the generated video in pixels, a multiple of 32."),
+            InputParam.template("width", description="Width of the generated video in pixels, a multiple of 32."),
+            InputParam(
+                name="num_frames",
+                type_hint=int,
+                description=(
+                    "Number of frames to generate, at the fixed 24 fps. Snapped up to the next `17 * n + 5` the video "
+                    "VAE can decode. May be left out, but only when exactly one reference carries audio, in which "
+                    "case the duration is that soundtrack's."
+                ),
+            ),
+        ]
+
+    @property
+    def intermediate_outputs(self) -> list[OutputParam]:
+        return [
+            OutputParam("height", type_hint=int, description="Resolved height of the generated video in pixels."),
+            OutputParam("width", type_hint=int, description="Resolved width of the generated video in pixels."),
+            OutputParam("num_frames", type_hint=int, description="Resolved number of frames, of the form 17 * n + 5."),
+            *_latent_geometry_outputs(),
+            OutputParam(
+                "prepared_references",
+                type_hint=list[MiniMaxH3PreparedReference],
+                description="The references prepared at their own resolutions, in packed order.",
+            ),
+        ]
+
+    @staticmethod
+    def prepare_references(
+        components, references: list[MiniMaxH3Reference], num_frames: int | None
+    ) -> tuple[list[MiniMaxH3PreparedReference], int]:
+        r"""
+        Resolve the references and, if it was left open, the duration they imply.
+
+        Every reference is prepared at its own resolution: an image is resized to a 2048 pixel short edge, a video is
+        resampled onto MiniMax-H3's own 24 fps, rescaled onto the 768 pixel canvas of *its own* aspect ratio and
+        truncated to the generated frame count, and a soundtrack is put on the audio VAE's sample rate and truncated to
+        the generated duration. None of this touches the target canvas.
+
+        A reference that left its `fps` or its `sample_rate` out is taken to already be at MiniMax-H3's own rate, and
+        its frames or its samples then flow through untouched.
+
+        A video reference goes through the two passes the reference implementation's `ffmpeg` decode applied, in the
+        same order: the constant frame rate resample of `resample_reference_frames` and the LANCZOS rescale of
+        `prepare_reference_frames`. Frames handed over at 24 fps and already at the canvas their own aspect ratio
+        resolves to therefore reach the VAE untouched, which is the parity-exact route.
+
+        Args:
+            references (`list[MiniMaxH3Reference]`):
+                The `references` input of a [`MiniMaxH3Ref2VABlocks`] request.
+            num_frames (`int`, *optional*):
+                The requested frame count, or `None` to derive it from the single audio-bearing reference.
+
+        Returns:
+            `tuple[list[MiniMaxH3PreparedReference], int]`: the prepared references, in packed order, and the frame
+            count.
+        """
+        resolved = [
+            MiniMaxH3PreparedReference(kind=reference_kind(index, entry), has_audio=entry.has_audio)
+            for index, entry in enumerate(references)
+        ]
+
+        # The duration may be left open, but then exactly one reference may carry audio, or the request is ambiguous.
+        if num_frames is None:
+            audio_bearing = [index for index, reference in enumerate(resolved) if reference.has_audio]
+            if len(audio_bearing) != 1:
+                raise ValueError(
+                    "`num_frames` may only be left to the references when exactly one of them carries audio, got "
+                    f"{len(audio_bearing)}."
+                )
+            index = audio_bearing[0]
+            sample_rate = references[index].sample_rate or components.audio_sampling_rate
+            duration = references[index].audio.shape[-1] / sample_rate
+            if not MINIMAX_H3_MIN_DURATION <= duration <= MINIMAX_H3_MAX_DURATION:
+                raise ValueError(
+                    f"`references[{index}]` is {duration:g} seconds long, outside the "
+                    f"{MINIMAX_H3_MIN_DURATION} to {MINIMAX_H3_MAX_DURATION} seconds MiniMax-H3 generates."
+                )
+            num_frames = align_num_frames(round(duration * MINIMAX_H3_FPS))
+            # The duration the request generates is the one of the *aligned* frame count, so that is what the
+            # ceiling has to hold for: a 14.99 second soundtrack rounds up to 362 frames, i.e. 15.083 seconds.
+            if num_frames / MINIMAX_H3_FPS > MINIMAX_H3_MAX_DURATION:
+                raise ValueError(
+                    f"`references[{index}]` is {duration:g} seconds long, which rounds up to {num_frames} frames "
+                    f"(`17 * n + 5`), i.e. {num_frames / MINIMAX_H3_FPS:g} seconds — past the "
+                    f"{MINIMAX_H3_MAX_DURATION} seconds MiniMax-H3 generates. Pass `num_frames` to generate a "
+                    "shorter video from this soundtrack."
+                )
+        num_frames = align_num_frames(num_frames)
+
+        for reference, entry in zip(resolved, references):
+            if reference.kind == "image":
+                image = entry.image
+                if not isinstance(image, Image.Image):
+                    image = Image.fromarray(reference_media_to_uint8(image))
+                image = ImageOps.exif_transpose(image).convert("RGB")
+                height, width = resolve_reference_image_size(*image.size)
+                reference.image = prepare_reference_image(image, height, width)
+            elif reference.kind == "video":
+                frames = resample_reference_frames(reference_media_to_uint8(entry.video), float(entry.fps))
+                reference.frames = prepare_reference_frames(frames, num_frames)
+            if reference.has_audio:
+                reference.waveform = prepare_reference_waveform(
+                    entry.audio,
+                    entry.sample_rate or components.audio_sampling_rate,
+                    components.audio_sampling_rate,
+                    max_duration=num_frames / MINIMAX_H3_FPS,
+                )
+        return resolved, num_frames
+
+    @torch.no_grad()
+    def __call__(self, components: MiniMaxH3Ref2VAModularPipeline, state: PipelineState) -> PipelineState:
+        block_state = self.get_block_state(state)
+        self._check_inputs(components, block_state)
+
+        if block_state.height is None:
+            block_state.height, block_state.width = resolve_canvas_size(16, 9)
+
+        requested_num_frames = block_state.num_frames
+        block_state.prepared_references, block_state.num_frames = self.prepare_references(
+            components, block_state.references, block_state.num_frames
+        )
+        if requested_num_frames is not None and requested_num_frames != block_state.num_frames:
+            logger.warning(
+                f"`num_frames` has to be of the form 17 * n + 5 for the video VAE; rounding {requested_num_frames} up "
+                f"to {block_state.num_frames}."
+            )
+
+        (
+            block_state.num_latent_frames,
+            block_state.latent_height,
+            block_state.latent_width,
+            block_state.num_audio_latents,
+        ) = _latent_geometry(components, block_state.height, block_state.width, block_state.num_frames)
+
+        self.set_block_state(state, block_state)
+        return components, state
diff --git a/src/diffusers/modular_pipelines/minimax_h3/decoders.py b/src/diffusers/modular_pipelines/minimax_h3/decoders.py
new file mode 100644
index 000000000000..fc4ee359267b
--- /dev/null
+++ b/src/diffusers/modular_pipelines/minimax_h3/decoders.py
@@ -0,0 +1,198 @@
+# Copyright 2026 The MiniMax and HuggingFace Teams. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+
+from ...configuration_utils import FrozenDict
+from ...models import AutoencoderKLMiniMaxH3, AutoencoderKLMiniMaxH3Audio
+from ...utils import logging
+from ...video_processor import VideoProcessor
+from ..modular_pipeline import ModularPipelineBlocks, PipelineState
+from ..modular_pipeline_utils import ComponentSpec, InputParam, OutputParam
+from .modular_pipeline import MiniMaxH3ModularPipeline
+from .packing import (
+    MINIMAX_H3_PIXEL_MEAN,
+    MINIMAX_H3_PIXEL_STD,
+    unpack_audio_tokens,
+    unpatchify_video_tokens,
+)
+
+
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
+
+
+class MiniMaxH3VideoDecodeStep(ModularPipelineBlocks):
+    model_name = "minimax-h3"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Unpacks the generated video rows back into latents, denormalizes them and decodes them into video. The "
+            "spatial tiling of the video VAE covers the canvas exactly, so the decoded frames need no crop back, but "
+            "the decode itself runs under float16 autocast even though the VAE weights are float32, and the VAE "
+            "produces ImageNet-normalized RGB that is reverted here."
+        )
+
+    @property
+    def expected_components(self) -> list[ComponentSpec]:
+        return [
+            ComponentSpec("vae", AutoencoderKLMiniMaxH3),
+            ComponentSpec(
+                "video_processor",
+                VideoProcessor,
+                # The video VAE decodes into ImageNet-normalized RGB over a [0, 1] base range, which this block
+                # reverts itself, so the processor must not denormalize a second time.
+                config=FrozenDict({"vae_scale_factor": 16, "do_normalize": False}),
+                default_creation_method="from_config",
+            ),
+        ]
+
+    @property
+    def inputs(self) -> list[InputParam]:
+        return [
+            InputParam(
+                name="latents",
+                type_hint=torch.Tensor,
+                required=True,
+                description="The denoised video rows of the packed sequence, conditioning rows first.",
+            ),
+            InputParam(
+                name="num_condition_video_rows",
+                type_hint=int,
+                default=0,
+                description="How many leading video rows are conditioning rows and are dropped here.",
+            ),
+            InputParam(
+                name="num_latent_frames", type_hint=int, required=True, description="Number of video latent frames."
+            ),
+            InputParam(name="latent_height", type_hint=int, required=True, description="Height of the video latents."),
+            InputParam(name="latent_width", type_hint=int, required=True, description="Width of the video latents."),
+            InputParam.template(
+                "output_type", description="Output format: 'pil', 'np', 'pt' or 'latent' for the raw latents."
+            ),
+        ]
+
+    @property
+    def intermediate_outputs(self) -> list[OutputParam]:
+        return [OutputParam.template("videos", description="The generated video.")]
+
+    @torch.no_grad()
+    def __call__(self, components: MiniMaxH3ModularPipeline, state: PipelineState) -> PipelineState:
+        block_state = self.get_block_state(state)
+        device = components._execution_device
+
+        latents = unpatchify_video_tokens(
+            block_state.latents[block_state.num_condition_video_rows :],
+            block_state.num_latent_frames,
+            block_state.latent_height,
+            block_state.latent_width,
+            components.vae_latent_channels,
+            components.patch_size,
+        )
+        latents_mean = torch.tensor(components.vae.config.latents_mean, device=device).view(1, -1, 1, 1, 1)
+        latents_std = torch.tensor(components.vae.config.latents_std, device=device).view(1, -1, 1, 1, 1)
+        latents = latents * latents_std + latents_mean
+
+        if block_state.output_type == "latent":
+            block_state.videos = latents
+        else:
+            with torch.autocast(device_type=device.type, dtype=torch.float16, enabled=device.type == "cuda"):
+                video = components.vae.decode(latents, return_dict=False)[0]
+            pixel_mean = torch.tensor(MINIMAX_H3_PIXEL_MEAN, device=device).view(1, -1, 1, 1, 1)
+            pixel_std = torch.tensor(MINIMAX_H3_PIXEL_STD, device=device).view(1, -1, 1, 1, 1)
+            video = (video.float() * pixel_std + pixel_mean).clamp(0, 1)
+            block_state.videos = components.video_processor.postprocess_video(
+                video, output_type=block_state.output_type
+            )
+
+        self.set_block_state(state, block_state)
+        return components, state
+
+
+class MiniMaxH3AudioDecodeStep(ModularPipelineBlocks):
+    model_name = "minimax-h3"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Unpacks the generated audio rows back into latents, denormalizes them and decodes them into a stereo "
+            "waveform. The audio VAE is mono and takes the two stereo channels as two batch items."
+        )
+
+    @property
+    def expected_components(self) -> list[ComponentSpec]:
+        return [ComponentSpec("audio_vae", AutoencoderKLMiniMaxH3Audio)]
+
+    @property
+    def inputs(self) -> list[InputParam]:
+        return [
+            InputParam(
+                name="audio_latents",
+                type_hint=torch.Tensor,
+                required=True,
+                description="The denoised audio rows of the packed sequence, reference rows first.",
+            ),
+            InputParam(
+                name="num_condition_audio_rows",
+                type_hint=int,
+                default=0,
+                description="How many leading audio rows are reference rows and are dropped here.",
+            ),
+            InputParam(
+                name="num_audio_latents",
+                type_hint=int,
+                required=True,
+                description="Number of audio latents per channel.",
+            ),
+            InputParam.template(
+                "output_type", description="Output format: 'pil', 'np', 'pt' or 'latent' for the raw latents."
+            ),
+        ]
+
+    @property
+    def intermediate_outputs(self) -> list[OutputParam]:
+        return [
+            OutputParam(
+                "audio",
+                type_hint=torch.Tensor,
+                description="The generated soundtrack, of shape `(1, 2, num_samples)`.",
+            ),
+            OutputParam(
+                "sampling_rate",
+                type_hint=int,
+                description="Sample rate of the generated soundtrack in Hz.",
+            ),
+        ]
+
+    @torch.no_grad()
+    def __call__(self, components: MiniMaxH3ModularPipeline, state: PipelineState) -> PipelineState:
+        block_state = self.get_block_state(state)
+        device = components._execution_device
+
+        audio_latents = unpack_audio_tokens(
+            block_state.audio_latents[block_state.num_condition_audio_rows :], block_state.num_audio_latents
+        )
+        audio_latents_mean = torch.tensor(components.audio_vae.config.latents_mean, device=device).view(1, -1, 1)
+        audio_latents_std = torch.tensor(components.audio_vae.config.latents_std, device=device).view(1, -1, 1)
+        audio_latents = audio_latents * audio_latents_std + audio_latents_mean
+
+        if block_state.output_type == "latent":
+            block_state.audio = audio_latents
+        else:
+            audio = components.audio_vae.decode(audio_latents, return_dict=False)[0]
+            block_state.audio = audio.float().permute(1, 0, 2)
+        block_state.sampling_rate = components.audio_sampling_rate
+
+        self.set_block_state(state, block_state)
+        return components, state
diff --git a/src/diffusers/modular_pipelines/minimax_h3/denoise.py b/src/diffusers/modular_pipelines/minimax_h3/denoise.py
new file mode 100644
index 000000000000..d149273371bb
--- /dev/null
+++ b/src/diffusers/modular_pipelines/minimax_h3/denoise.py
@@ -0,0 +1,325 @@
+# Copyright 2026 The MiniMax and HuggingFace Teams. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+
+from ...models import MiniMaxH3Transformer3DModel
+from ...schedulers import MiniMaxH3Scheduler
+from ...utils import logging
+from ..modular_pipeline import (
+    BlockState,
+    LoopSequentialPipelineBlocks,
+    ModularPipelineBlocks,
+    PipelineState,
+)
+from ..modular_pipeline_utils import ComponentSpec, InputParam, OutputParam
+from .modular_pipeline import MiniMaxH3ModularPipeline, MiniMaxH3Ref2VAModularPipeline
+
+
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
+
+
+def _denoiser_inputs() -> list[InputParam]:
+    r"""Everything one MiniMax-H3 forward reads, beyond the transformer itself."""
+    return [
+        InputParam(
+            name="latents",
+            type_hint=torch.Tensor,
+            required=True,
+            description="The video rows of the packed sequence, conditioning rows first.",
+        ),
+        InputParam(
+            name="audio_latents",
+            type_hint=torch.Tensor,
+            required=True,
+            description="The channel-major audio rows of the packed sequence, reference rows first.",
+        ),
+        InputParam.template("prompt_embeds"),
+        InputParam(
+            name="row_timestep_plan",
+            type_hint=list,
+            required=True,
+            description="One `(timestep, timestep_indices)` pair per step.",
+        ),
+        InputParam(
+            name="token_tags", type_hint=torch.Tensor, required=True, description="The modality tag of every row."
+        ),
+        InputParam(
+            name="position_ids",
+            type_hint=torch.Tensor,
+            required=True,
+            description="The `(t, h, w)` rotary coordinate of every row.",
+        ),
+        InputParam(
+            name="video_indices",
+            type_hint=torch.Tensor,
+            required=True,
+            description="Sequence positions of the video rows.",
+        ),
+        InputParam(
+            name="audio_indices",
+            type_hint=torch.Tensor,
+            required=True,
+            description="Sequence positions of the audio rows.",
+        ),
+        InputParam(
+            name="text_indices",
+            type_hint=torch.Tensor,
+            required=True,
+            description="Sequence positions of the text rows.",
+        ),
+        InputParam.template("attention_kwargs"),
+    ]
+
+
+def _denoiser_outputs() -> list[OutputParam]:
+    return [
+        OutputParam(
+            "noise_pred", type_hint=torch.Tensor, description="Predicted velocity of the video rows of the sequence."
+        ),
+        OutputParam(
+            "audio_noise_pred",
+            type_hint=torch.Tensor,
+            description="Predicted velocity of the audio rows of the sequence.",
+        ),
+    ]
+
+
+def _predict_velocity(transformer: MiniMaxH3Transformer3DModel, block_state: BlockState, i: int):
+    r"""One MiniMax-H3 forward pass: every row of the packed sequence, at its own noise level, at once."""
+    unique_timesteps, timestep_indices = block_state.row_timestep_plan[i]
+    return transformer(
+        hidden_states=block_state.latents[None],
+        audio_hidden_states=block_state.audio_latents[None],
+        encoder_hidden_states=block_state.prompt_embeds,
+        timestep=unique_timesteps,
+        timestep_indices=timestep_indices,
+        token_tags=block_state.token_tags,
+        position_ids=block_state.position_ids,
+        video_indices=block_state.video_indices,
+        audio_indices=block_state.audio_indices,
+        text_indices=block_state.text_indices,
+        attention_kwargs=block_state.attention_kwargs,
+        return_dict=False,
+    )
+
+
+class MiniMaxH3LoopDenoiser(ModularPipelineBlocks):
+    model_name = "minimax-h3"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Runs the one MiniMax-H3 forward pass of a denoising iteration, which predicts the velocity of every row "
+            "of the packed sequence at once. The checkpoint is guidance-distilled, so there is no unconditional pass "
+            "and no guider."
+        )
+
+    @property
+    def expected_components(self) -> list[ComponentSpec]:
+        return [ComponentSpec("transformer", MiniMaxH3Transformer3DModel)]
+
+    @property
+    def inputs(self) -> list[InputParam]:
+        return _denoiser_inputs()
+
+    @property
+    def intermediate_outputs(self) -> list[OutputParam]:
+        return _denoiser_outputs()
+
+    @torch.no_grad()
+    def __call__(self, components: MiniMaxH3ModularPipeline, block_state: BlockState, i: int, t: torch.Tensor):
+        block_state.noise_pred, block_state.audio_noise_pred = _predict_velocity(
+            components.transformer, block_state, i
+        )
+        return components, block_state
+
+
+class MiniMaxH3Ref2VALoopDenoiser(ModularPipelineBlocks):
+    model_name = "minimax-h3-ref2va"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Runs the one MiniMax-H3 forward pass of a `ref2va` denoising iteration, against the `transformer_ref` "
+            "partition of the checkpoint."
+        )
+
+    @property
+    def expected_components(self) -> list[ComponentSpec]:
+        return [ComponentSpec("transformer_ref", MiniMaxH3Transformer3DModel)]
+
+    @property
+    def inputs(self) -> list[InputParam]:
+        return _denoiser_inputs()
+
+    @property
+    def intermediate_outputs(self) -> list[OutputParam]:
+        return _denoiser_outputs()
+
+    @torch.no_grad()
+    def __call__(self, components: MiniMaxH3Ref2VAModularPipeline, block_state: BlockState, i: int, t: torch.Tensor):
+        block_state.noise_pred, block_state.audio_noise_pred = _predict_velocity(
+            components.transformer_ref, block_state, i
+        )
+        return components, block_state
+
+
+class MiniMaxH3LoopSchedulerStep(ModularPipelineBlocks):
+    model_name = "minimax-h3"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Steps the generated video and audio rows down their own schedule. The conditioning rows are re-imposed "
+            "by construction: only the generated rows are ever written, so the anchors survive the whole loop."
+        )
+
+    @property
+    def expected_components(self) -> list[ComponentSpec]:
+        return [
+            ComponentSpec("scheduler", MiniMaxH3Scheduler),
+            ComponentSpec("audio_scheduler", MiniMaxH3Scheduler),
+        ]
+
+    @property
+    def inputs(self) -> list[InputParam]:
+        return [
+            InputParam(
+                name="latents",
+                type_hint=torch.Tensor,
+                required=True,
+                description="The video rows of the packed sequence, conditioning rows first.",
+            ),
+            InputParam(
+                name="audio_latents",
+                type_hint=torch.Tensor,
+                required=True,
+                description="The channel-major audio rows of the packed sequence, reference rows first.",
+            ),
+            InputParam(
+                name="noise_pred",
+                type_hint=torch.Tensor,
+                required=True,
+                description="Predicted velocity of the video rows.",
+            ),
+            InputParam(
+                name="audio_noise_pred",
+                type_hint=torch.Tensor,
+                required=True,
+                description="Predicted velocity of the audio rows.",
+            ),
+            InputParam(
+                name="audio_timesteps",
+                type_hint=torch.Tensor,
+                required=True,
+                description="Timesteps of the audio schedule.",
+            ),
+            InputParam(
+                name="num_condition_video_rows",
+                type_hint=int,
+                default=0,
+                description="How many leading video rows are conditioning rows.",
+            ),
+            InputParam(
+                name="num_condition_audio_rows",
+                type_hint=int,
+                default=0,
+                description="How many leading audio rows are reference rows.",
+            ),
+        ]
+
+    @property
+    def intermediate_outputs(self) -> list[OutputParam]:
+        return [
+            OutputParam(
+                "latents",
+                type_hint=torch.Tensor,
+                description="The video rows of the packed sequence after one step.",
+            ),
+            OutputParam(
+                "audio_latents",
+                type_hint=torch.Tensor,
+                description="The audio rows of the packed sequence after one step.",
+            ),
+        ]
+
+    @torch.no_grad()
+    def __call__(self, components: MiniMaxH3ModularPipeline, block_state: BlockState, i: int, t: torch.Tensor):
+        num_condition_video_rows = block_state.num_condition_video_rows
+        num_condition_audio_rows = block_state.num_condition_audio_rows
+
+        block_state.latents[num_condition_video_rows:] = components.scheduler.step(
+            block_state.noise_pred[0, num_condition_video_rows:].float(),
+            t,
+            block_state.latents[num_condition_video_rows:],
+            return_dict=False,
+        )[0]
+        block_state.audio_latents[num_condition_audio_rows:] = components.audio_scheduler.step(
+            block_state.audio_noise_pred[0, num_condition_audio_rows:].float(),
+            block_state.audio_timesteps[i],
+            block_state.audio_latents[num_condition_audio_rows:],
+            return_dict=False,
+        )[0]
+        return components, block_state
+
+
+class MiniMaxH3DenoiseLoopWrapper(LoopSequentialPipelineBlocks):
+    model_name = "minimax-h3"
+
+    @property
+    def description(self) -> str:
+        return "Iteratively denoises the packed MiniMax-H3 sequence over the two schedules."
+
+    @property
+    def loop_expected_components(self) -> list[ComponentSpec]:
+        return [
+            ComponentSpec("scheduler", MiniMaxH3Scheduler),
+            ComponentSpec("audio_scheduler", MiniMaxH3Scheduler),
+        ]
+
+    @property
+    def loop_inputs(self) -> list[InputParam]:
+        return [
+            InputParam.template("timesteps", required=True, description="Timesteps of the video schedule."),
+        ]
+
+    @torch.no_grad()
+    def __call__(self, components: MiniMaxH3ModularPipeline, state: PipelineState) -> PipelineState:
+        block_state = self.get_block_state(state)
+        with self.progress_bar(total=len(block_state.timesteps)) as progress_bar:
+            for i, t in enumerate(block_state.timesteps):
+                components, block_state = self.loop_step(components, block_state, i=i, t=t)
+                progress_bar.update()
+        self.set_block_state(state, block_state)
+        return components, state
+
+
+class MiniMaxH3DenoiseStep(MiniMaxH3DenoiseLoopWrapper):
+    block_classes = [MiniMaxH3LoopDenoiser, MiniMaxH3LoopSchedulerStep]
+    block_names = ["denoiser", "update"]
+
+    @property
+    def description(self) -> str:
+        return "Runs the `t2va` / `fl2va` MiniMax-H3 denoising loop, one forward pass per step."
+
+
+class MiniMaxH3Ref2VADenoiseStep(MiniMaxH3DenoiseLoopWrapper):
+    model_name = "minimax-h3-ref2va"
+    block_classes = [MiniMaxH3Ref2VALoopDenoiser, MiniMaxH3LoopSchedulerStep]
+    block_names = ["denoiser", "update"]
+
+    @property
+    def description(self) -> str:
+        return "Runs the `ref2va` MiniMax-H3 denoising loop, one forward pass per step."
diff --git a/src/diffusers/modular_pipelines/minimax_h3/encoders.py b/src/diffusers/modular_pipelines/minimax_h3/encoders.py
new file mode 100644
index 000000000000..da2d611eaba0
--- /dev/null
+++ b/src/diffusers/modular_pipelines/minimax_h3/encoders.py
@@ -0,0 +1,638 @@
+# Copyright 2026 The MiniMax and HuggingFace Teams. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+import torch
+from transformers import Qwen2TokenizerFast, Qwen3VLForConditionalGeneration, Qwen3VLProcessor
+
+from ...models import AutoencoderKLMiniMaxH3, AutoencoderKLMiniMaxH3Audio
+from ...models.autoencoders.vae import DiagonalGaussianDistribution
+from ...schedulers import MiniMaxH3Scheduler
+from ...utils import logging
+from ..modular_pipeline import ModularPipelineBlocks, PipelineState
+from ..modular_pipeline_utils import ComponentSpec, InputParam, OutputParam
+from .modular_pipeline import MiniMaxH3ModularPipeline, MiniMaxH3Ref2VAModularPipeline
+from .packing import (
+    MINIMAX_H3_KEYFRAME_ENCODE_SEED,
+    MINIMAX_H3_KEYFRAME_NOISE_AUG,
+    MINIMAX_H3_PIXEL_MEAN,
+    MINIMAX_H3_PIXEL_STD,
+    MINIMAX_H3_TEXT_ENCODER_LAYER,
+    MINIMAX_H3_TEXT_TAG,
+    MINIMAX_H3_VIDEO_TAG,
+    keyframe_condition_noise,
+    patchify_video_latents,
+)
+from .packing_ref2va import (
+    MiniMaxH3PreparedReference,
+    build_ref2va_presentation,
+    sample_reference_video_frames,
+    trim_reference_num_frames,
+)
+
+
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
+
+
+def _check_prompt(prompt) -> None:
+    r"""MiniMax-H3 packs one request into one sequence, so a batch of prompts is not a thing."""
+    if not isinstance(prompt, str):
+        raise ValueError(
+            f"MiniMax-H3 packs one request into one sequence, so `prompt` must be a single string, got {type(prompt)}."
+        )
+
+
+def _conditioner_components() -> list[ComponentSpec]:
+    r"""MiniMax-H3's conditioner: a Qwen3-VL read at its 50th decoder layer, with its language-model head unused."""
+    return [
+        ComponentSpec("text_encoder", Qwen3VLForConditionalGeneration),
+        ComponentSpec("tokenizer", Qwen2TokenizerFast),
+        ComponentSpec("processor", Qwen3VLProcessor),
+    ]
+
+
+def _conditioner_outputs() -> list[OutputParam]:
+    return [
+        OutputParam.template(
+            "prompt_embeds",
+            description=(
+                "The hidden state MiniMax-H3 conditions on, of shape `(1, num_text_tokens, 5120)`, read after the "
+                "50th decoder layer of the Qwen3-VL conditioner."
+            ),
+        ),
+        OutputParam(
+            "text_token_tags",
+            type_hint=torch.Tensor,
+            description="The per-row modality tag of every row of `prompt_embeds`; a vision block is tagged as video.",
+        ),
+    ]
+
+
+class MiniMaxH3TextEncoderStep(ModularPipelineBlocks):
+    model_name = "minimax-h3"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Encodes MiniMax-H3's presentation of a `t2va` / `fl2va` request: the prompt verbatim, preceded by a "
+            '`"<Picture i>: "` label and a vision block per keyframe, with no chat template and no special tokens. '
+            "The checkpoint is guidance-distilled, so there is no negative prompt and no unconditional branch."
+        )
+
+    @property
+    def expected_components(self) -> list[ComponentSpec]:
+        return _conditioner_components()
+
+    @property
+    def inputs(self) -> list[InputParam]:
+        return [
+            InputParam.template("prompt", description="The prompt to guide generation, a single string."),
+            InputParam(
+                name="keyframes",
+                type_hint=list,
+                description="The keyframes put onto the target canvas, in packed order (empty or None for `t2va`).",
+            ),
+        ]
+
+    @property
+    def intermediate_outputs(self) -> list[OutputParam]:
+        return _conditioner_outputs()
+
+    @staticmethod
+    def encode_prompt(
+        components,
+        prompt: str,
+        images: list | None = None,
+        device: torch.device | None = None,
+        dtype: torch.dtype | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        r"""
+        Build MiniMax-H3's presentation of a request and encode it.
+
+        The presentation is the verbatim prompt for `t2va`. Every keyframe prepends a `"<Picture i>: "` label and a
+        vision block (`<|vision_start|>`, one `<|image_pad|>` per vision patch, `<|vision_end|>`) — no chat template
+        and no special tokens. The rows of a vision block are tagged as *video* rather than text, which is what the
+        transformer's AdaLN modulation keys off.
+
+        Args:
+            prompt (`str`): The prompt to encode.
+            images (`list[PIL.Image.Image]`, *optional*):
+                The keyframes, already prepared onto the target canvas, in packed order.
+            device (`torch.device`, *optional*): The device to run the conditioner on.
+            dtype (`torch.dtype`, *optional*): The dtype of the returned embeddings.
+
+        Returns:
+            `tuple[torch.Tensor, torch.Tensor]`: the `(1, num_text_tokens, 5120)` hidden states and the
+            `(num_text_tokens,)` per-row modality tags.
+        """
+        device = device or components._execution_device
+        dtype = dtype or components.transformer.dtype
+
+        num_layers = components.text_encoder.config.text_config.num_hidden_layers
+        if num_layers <= MINIMAX_H3_TEXT_ENCODER_LAYER:
+            raise ValueError(
+                f"MiniMax-H3 conditions on `hidden_states[{MINIMAX_H3_TEXT_ENCODER_LAYER}]` of its Qwen3-VL "
+                f"conditioner, which needs more than {MINIMAX_H3_TEXT_ENCODER_LAYER} decoder layers, but "
+                f"`text_encoder` has {num_layers}. The last hidden state of a stack truncated to exactly "
+                f"{MINIMAX_H3_TEXT_ENCODER_LAYER} layers is post-norm and is not the conditioning MiniMax-H3 expects."
+            )
+
+        pixel_values, image_grid_thw = None, None
+        token_ids, token_tags = [], []
+        if images:
+            vision = components.processor.image_processor(images=images, return_tensors="pt")
+            pixel_values, image_grid_thw = vision["pixel_values"], vision["image_grid_thw"]
+            merge_size = components.processor.image_processor.merge_size**2
+            for index in range(len(images)):
+                num_image_tokens = int(image_grid_thw[index].prod()) // merge_size
+                label_ids = components.tokenizer(f"<Picture {index + 1}>: ", add_special_tokens=False)["input_ids"]
+                vision_ids = (
+                    [components.tokenizer.convert_tokens_to_ids("<|vision_start|>")]
+                    + [components.tokenizer.convert_tokens_to_ids("<|image_pad|>")] * num_image_tokens
+                    + [components.tokenizer.convert_tokens_to_ids("<|vision_end|>")]
+                )
+                token_ids += label_ids + vision_ids
+                token_tags += [MINIMAX_H3_TEXT_TAG] * len(label_ids) + [MINIMAX_H3_VIDEO_TAG] * len(vision_ids)
+        prompt_ids = components.tokenizer(prompt, add_special_tokens=False)["input_ids"]
+        token_ids += prompt_ids
+        token_tags += [MINIMAX_H3_TEXT_TAG] * len(prompt_ids)
+
+        input_ids = torch.tensor([token_ids], dtype=torch.long, device=device)
+        # Qwen3-VL lays its 3D rotary positions out per modality run, which it reads off the token type ids the
+        # processor derives from the vision pad ids (`0` text, `1` image, `2` video).
+        mm_token_type_ids = torch.tensor(
+            components.processor.create_mm_token_type_ids([token_ids]), dtype=torch.long, device=device
+        )
+        # `text_encoder.model` is a submodule, and a CPU-offload hook — accelerate's or the one the
+        # `ComponentsManager` attaches — wraps the *top-level* module's `forward` alone, so calling the submodule
+        # directly would leave the conditioner on the CPU. Fire the hook by hand instead of routing through
+        # `text_encoder(...)`: MiniMax-H3 reads `hidden_states[50]` and never uses the language-model head, whose
+        # vocabulary-wide projection over every token is all the top-level forward would add.
+        hook = getattr(components.text_encoder, "_hf_hook", None)
+        if hook is not None and hasattr(hook, "pre_forward"):
+            hook.pre_forward(components.text_encoder)
+        outputs = components.text_encoder.model(
+            input_ids=input_ids,
+            attention_mask=torch.ones_like(input_ids),
+            mm_token_type_ids=mm_token_type_ids,
+            pixel_values=None if pixel_values is None else pixel_values.to(device, components.text_encoder.dtype),
+            image_grid_thw=None if image_grid_thw is None else image_grid_thw.to(device),
+            use_cache=False,
+            output_hidden_states=True,
+        )
+        prompt_embeds = outputs.hidden_states[MINIMAX_H3_TEXT_ENCODER_LAYER].to(device=device, dtype=dtype)
+        return prompt_embeds, torch.tensor(token_tags, dtype=torch.long)
+
+    @torch.no_grad()
+    def __call__(self, components: MiniMaxH3ModularPipeline, state: PipelineState) -> PipelineState:
+        block_state = self.get_block_state(state)
+        _check_prompt(block_state.prompt)
+
+        # `encode_prompt` defaults the embedding dtype to the denoiser's; a text encoder block has no denoiser of
+        # its own — it is meant to run on its own — so it emits the conditioner's dtype, as every other model does.
+        block_state.prompt_embeds, block_state.text_token_tags = self.encode_prompt(
+            components,
+            block_state.prompt,
+            block_state.keyframes,
+            device=components._execution_device,
+            dtype=components.text_encoder.dtype,
+        )
+
+        self.set_block_state(state, block_state)
+        return components, state
+
+
+class MiniMaxH3KeyframeVaeEncoderStep(ModularPipelineBlocks):
+    model_name = "minimax-h3"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Encodes the `fl2va` keyframes into packed conditioning rows and noises them to MiniMax-H3's "
+            "conditioning level. The rows are the anchors of the whole denoising loop: the loop only ever writes the "
+            "generated rows, so they are never updated again."
+        )
+
+    @property
+    def expected_components(self) -> list[ComponentSpec]:
+        return [
+            ComponentSpec("vae", AutoencoderKLMiniMaxH3),
+            ComponentSpec("scheduler", MiniMaxH3Scheduler),
+        ]
+
+    @property
+    def inputs(self) -> list[InputParam]:
+        return [
+            InputParam(
+                name="keyframes",
+                type_hint=list,
+                required=True,
+                description="The keyframes put onto the target canvas, in packed order.",
+            ),
+            InputParam(name="latent_height", type_hint=int, required=True, description="Height of the video latents."),
+            InputParam(name="latent_width", type_hint=int, required=True, description="Width of the video latents."),
+            InputParam.template(
+                "generator",
+                description=(
+                    "The generator of the request. The conditioning noise is drawn from it before the target noise "
+                    "of the prepare-latents step."
+                ),
+            ),
+        ]
+
+    @property
+    def intermediate_outputs(self) -> list[OutputParam]:
+        return [
+            OutputParam(
+                "condition_latents",
+                type_hint=torch.Tensor,
+                description="The noise-augmented video conditioning rows, in packed order.",
+            )
+        ]
+
+    @staticmethod
+    def encode_keyframes(components, images: list, device: torch.device | None = None) -> torch.Tensor:
+        r"""
+        Encode the `fl2va` keyframes into packed conditioning rows.
+
+        The keyframes go through the video VAE's spatial encoder only — they are single frames, so none of its
+        17-frame temporal chunking applies — and the posterior is *sampled*, under a generator seeded with 42
+        independently of the request seed. The sampled latent is rounded to float16 before being normalized, as in the
+        reference implementation; both are part of reproducing the released model's conditioning.
+
+        Args:
+            images (`list[PIL.Image.Image]`):
+                The keyframes, already prepared onto the target canvas, in packed order.
+            device (`torch.device`, *optional*): The device to run the VAE on.
+
+        Returns:
+            `torch.Tensor` of shape `(num_condition_rows, latent_channels * prod(patch_size))`: the float32
+            conditioning rows.
+        """
+        device = device or components._execution_device
+        latents_mean = torch.tensor(components.vae.config.latents_mean).view(1, -1, 1, 1, 1)
+        latents_std = torch.tensor(components.vae.config.latents_std).view(1, -1, 1, 1, 1)
+        pixel_mean = torch.tensor(MINIMAX_H3_PIXEL_MEAN, device=device).view(1, -1, 1, 1, 1)
+        pixel_std = torch.tensor(MINIMAX_H3_PIXEL_STD, device=device).view(1, -1, 1, 1, 1)
+
+        rows = []
+        for image in images:
+            pixels = torch.from_numpy(np.array(image)).to(device).permute(2, 0, 1)[None, :, None]
+            pixels = (pixels.to(torch.float32).div(255.0) - pixel_mean) / pixel_std
+            # `vae.encode` chunks along time for videos; a keyframe is one frame and is encoded by the (tiled)
+            # spatial encoder alone, which is what the released model conditions on.
+            moments = components.vae._encode_clip(pixels)
+            posterior = DiagonalGaussianDistribution(moments)
+            latents = posterior.sample(generator=torch.Generator().manual_seed(MINIMAX_H3_KEYFRAME_ENCODE_SEED))
+            # The sampled latent is rounded to float16 before it is normalized: ~11 bits of every conditioning
+            # latent, so the released model's conditioning cannot be reproduced without it.
+            latents = latents.to(torch.float16).float().cpu()
+            rows.append(patchify_video_latents((latents - latents_mean) / latents_std, components.patch_size))
+        return torch.cat(rows)
+
+    @torch.no_grad()
+    def __call__(self, components: MiniMaxH3ModularPipeline, state: PipelineState) -> PipelineState:
+        block_state = self.get_block_state(state)
+        device = components._execution_device
+
+        condition_latents = self.encode_keyframes(components, block_state.keyframes, device=device)
+        noise = keyframe_condition_noise(
+            ((1, block_state.latent_height, block_state.latent_width),) * len(block_state.keyframes),
+            components.patch_size,
+            components.vae_latent_channels,
+            generator=block_state.generator,
+            device=device,
+        )
+        block_state.condition_latents = components.scheduler.scale_noise(
+            condition_latents.to(device), MINIMAX_H3_KEYFRAME_NOISE_AUG, noise
+        )
+
+        self.set_block_state(state, block_state)
+        return components, state
+
+
+class MiniMaxH3Ref2VATextEncoderStep(ModularPipelineBlocks):
+    model_name = "minimax-h3-ref2va"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Encodes MiniMax-H3's presentation of a `ref2va` request: a label per reference, numbered per modality "
+            '(`"<Picture i>: "` plus a vision block, `"<Audio j>: "` alone, `"<Video k>: "` plus one timestamped '
+            "vision block per merged frame pair), then the prompt verbatim. The checkpoint is guidance-distilled, so "
+            "there is no negative prompt and no unconditional branch."
+        )
+
+    @property
+    def expected_components(self) -> list[ComponentSpec]:
+        return _conditioner_components()
+
+    @property
+    def inputs(self) -> list[InputParam]:
+        return [
+            InputParam.template("prompt", description="The prompt to guide generation, a single string."),
+            InputParam(
+                name="prepared_references",
+                type_hint=list[MiniMaxH3PreparedReference],
+                required=True,
+                description="The prepared references, in packed order.",
+            ),
+        ]
+
+    @property
+    def intermediate_outputs(self) -> list[OutputParam]:
+        return _conditioner_outputs()
+
+    @staticmethod
+    def encode_prompt(
+        components,
+        prompt: str,
+        references: list[MiniMaxH3PreparedReference],
+        device: torch.device | None = None,
+        dtype: torch.dtype | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        r"""
+        Build MiniMax-H3's presentation of a `ref2va` request and encode it.
+
+        Every reference prepends a label, in request order and numbered per modality: `"<Picture i>: "` plus a vision
+        block for an image, `"<Audio j>: "` alone for audio (a waveform never reaches the conditioner), and
+        `"<Video k>: "` plus one timestamped vision block per merged frame pair for a video. A video that carries
+        sound is labelled `"<Audio j>: "` *before* `"<Video k>: "`, mirroring the order its rows are packed in. The
+        prompt then follows, verbatim, with no chat template and no special tokens. The rows of a vision block are
+        tagged as *video* rather than text, which is what the transformer's AdaLN modulation keys off.
+
+        Args:
+            prompt (`str`): The prompt to encode.
+            references (`list[MiniMaxH3PreparedReference]`):
+                The prepared references, in packed order, as returned by
+                [`~MiniMaxH3Ref2VASetupStep.prepare_references`].
+            device (`torch.device`, *optional*): The device to run the conditioner on.
+            dtype (`torch.dtype`, *optional*): The dtype of the returned embeddings.
+
+        Returns:
+            `tuple[torch.Tensor, torch.Tensor]`: the `(1, num_text_tokens, 5120)` hidden states and the
+            `(num_text_tokens,)` per-row modality tags.
+        """
+        device = device or components._execution_device
+        dtype = dtype or components.transformer_ref.dtype
+
+        num_layers = components.text_encoder.config.text_config.num_hidden_layers
+        if num_layers <= MINIMAX_H3_TEXT_ENCODER_LAYER:
+            raise ValueError(
+                f"MiniMax-H3 conditions on `hidden_states[{MINIMAX_H3_TEXT_ENCODER_LAYER}]` of its Qwen3-VL "
+                f"conditioner, which needs more than {MINIMAX_H3_TEXT_ENCODER_LAYER} decoder layers, but "
+                f"`text_encoder` has {num_layers}. The last hidden state of a stack truncated to exactly "
+                f"{MINIMAX_H3_TEXT_ENCODER_LAYER} layers is post-norm and is not the conditioning MiniMax-H3 expects."
+            )
+
+        merge_size = components.processor.image_processor.merge_size**2
+        pixel_values, image_grid_thw, image_token_counts = None, None, []
+        images = [reference.image for reference in references if reference.kind == "image"]
+        if images:
+            vision = components.processor.image_processor(images=images, return_tensors="pt")
+            pixel_values, image_grid_thw = vision["pixel_values"], vision["image_grid_thw"]
+            image_token_counts = [int(grid.prod()) // merge_size for grid in image_grid_thw]
+
+        pixel_values_videos, video_grid_thw, video_block_token_counts = None, None, []
+        videos = [reference for reference in references if reference.kind == "video"]
+        if videos:
+            sampled = [sample_reference_video_frames(reference.frames) for reference in videos]
+            for reference, (_, block_timestamps) in zip(videos, sampled):
+                reference.block_timestamps = block_timestamps
+            vision = components.processor.video_processor(
+                videos=[np.stack(frames) for frames, _ in sampled], do_sample_frames=False, return_tensors="pt"
+            )
+            pixel_values_videos, video_grid_thw = vision["pixel_values_videos"], vision["video_grid_thw"]
+            video_block_token_counts = [int(grid[1]) * int(grid[2]) // merge_size for grid in video_grid_thw]
+            for reference, grid in zip(videos, video_grid_thw):
+                if int(grid[0]) != len(reference.block_timestamps):
+                    raise ValueError(
+                        f"The processor merged a reference video into {int(grid[0])} vision blocks, but MiniMax-H3 "
+                        f"labels {len(reference.block_timestamps)} of them."
+                    )
+
+        token_ids, token_tags = build_ref2va_presentation(
+            components.tokenizer, prompt, references, image_token_counts, video_block_token_counts
+        )
+        input_ids = torch.tensor([token_ids], dtype=torch.long, device=device)
+        # Qwen3-VL lays its 3D rotary positions out per modality run, which it reads off the token type ids the
+        # processor derives from the vision pad ids (`0` text, `1` image, `2` video).
+        mm_token_type_ids = torch.tensor(
+            components.processor.create_mm_token_type_ids([token_ids]), dtype=torch.long, device=device
+        )
+        # `text_encoder.model` is a submodule, and a CPU-offload hook — accelerate's or the one the
+        # `ComponentsManager` attaches — wraps the *top-level* module's `forward` alone, so calling the submodule
+        # directly would leave the conditioner on the CPU. Fire the hook by hand instead of routing through
+        # `text_encoder(...)`: MiniMax-H3 reads `hidden_states[50]` and never uses the language-model head, whose
+        # vocabulary-wide projection over every token is all the top-level forward would add.
+        hook = getattr(components.text_encoder, "_hf_hook", None)
+        if hook is not None and hasattr(hook, "pre_forward"):
+            hook.pre_forward(components.text_encoder)
+        outputs = components.text_encoder.model(
+            input_ids=input_ids,
+            attention_mask=torch.ones_like(input_ids),
+            mm_token_type_ids=mm_token_type_ids,
+            pixel_values=None if pixel_values is None else pixel_values.to(device, components.text_encoder.dtype),
+            image_grid_thw=None if image_grid_thw is None else image_grid_thw.to(device),
+            pixel_values_videos=(
+                None if pixel_values_videos is None else pixel_values_videos.to(device, components.text_encoder.dtype)
+            ),
+            video_grid_thw=None if video_grid_thw is None else video_grid_thw.to(device),
+            use_cache=False,
+            output_hidden_states=True,
+        )
+        prompt_embeds = outputs.hidden_states[MINIMAX_H3_TEXT_ENCODER_LAYER].to(device=device, dtype=dtype)
+        return prompt_embeds, torch.tensor(token_tags, dtype=torch.long)
+
+    @torch.no_grad()
+    def __call__(self, components: MiniMaxH3Ref2VAModularPipeline, state: PipelineState) -> PipelineState:
+        block_state = self.get_block_state(state)
+        _check_prompt(block_state.prompt)
+
+        # `encode_prompt` defaults the embedding dtype to the denoiser's; a text encoder block has no denoiser of
+        # its own — it is meant to run on its own — so it emits the conditioner's dtype, as every other model does.
+        block_state.prompt_embeds, block_state.text_token_tags = self.encode_prompt(
+            components,
+            block_state.prompt,
+            block_state.prepared_references,
+            device=components._execution_device,
+            dtype=components.text_encoder.dtype,
+        )
+
+        self.set_block_state(state, block_state)
+        return components, state
+
+
+class MiniMaxH3Ref2VAReferenceEncoderStep(ModularPipelineBlocks):
+    model_name = "minimax-h3-ref2va"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Encodes the `ref2va` references into packed conditioning rows — image and video references through the "
+            "video VAE, soundtracks through the audio VAE — and noises the visual ones to MiniMax-H3's conditioning "
+            "level. Audio references ride along clean, at `t = 1.0`. Both are anchors of the whole denoising loop, "
+            "which only ever writes the generated rows. The latent geometry of every reference is resolved here, so "
+            "this runs before the packed layout is built."
+        )
+
+    @property
+    def expected_components(self) -> list[ComponentSpec]:
+        return [
+            ComponentSpec("vae", AutoencoderKLMiniMaxH3),
+            ComponentSpec("audio_vae", AutoencoderKLMiniMaxH3Audio),
+            ComponentSpec("scheduler", MiniMaxH3Scheduler),
+        ]
+
+    @property
+    def inputs(self) -> list[InputParam]:
+        return [
+            InputParam(
+                name="prepared_references",
+                type_hint=list[MiniMaxH3PreparedReference],
+                required=True,
+                description="The prepared references, in packed order. Their latent geometry is filled in here.",
+            ),
+            InputParam.template(
+                "generator",
+                description=(
+                    "The generator of the request. The conditioning noise is drawn from it before the target noise "
+                    "of the prepare-latents step."
+                ),
+            ),
+        ]
+
+    @property
+    def intermediate_outputs(self) -> list[OutputParam]:
+        return [
+            OutputParam(
+                "condition_latents",
+                type_hint=torch.Tensor,
+                description=(
+                    "The noise-augmented video conditioning rows of the image and video references, in packed order, "
+                    "or None when the references carry none."
+                ),
+            ),
+            OutputParam(
+                "audio_condition_latents",
+                type_hint=torch.Tensor,
+                description=(
+                    "The clean audio conditioning rows of the reference soundtracks, in packed order, or None when "
+                    "the references carry none."
+                ),
+            ),
+        ]
+
+    @staticmethod
+    def encode_references(
+        components, references: list[MiniMaxH3PreparedReference], device: torch.device | None = None
+    ) -> tuple[torch.Tensor | None, torch.Tensor | None]:
+        r"""
+        Encode the references into packed conditioning rows, and resolve their latent geometry.
+
+        Image and video references go through the video VAE with the same recipe the `fl2va` keyframes use: the
+        posterior is *sampled* under a generator seeded with 42 independently of the request seed, and the sampled
+        latent is rounded to float16 before being normalized. An image is a single frame and is encoded by the spatial
+        encoder alone, while a video reference goes through the 17-frames-per-5-latents temporal chunking. Reference
+        soundtracks instead take the posterior *mean*, and are never sampled.
+
+        Args:
+            references (`list[MiniMaxH3PreparedReference]`):
+                The prepared references, in packed order. Their latent geometry is filled in here.
+            device (`torch.device`, *optional*): The device to run the VAEs on.
+
+        Returns:
+            `tuple[torch.Tensor, torch.Tensor]`: the `(num_condition_video_rows, latent_channels * prod(patch_size))`
+            video rows and the `(num_condition_audio_rows, audio_latent_channels)` audio rows, both float32 on CPU and
+            both `None` when the references carry no such rows.
+        """
+        device = device or components._execution_device
+        latents_mean = torch.tensor(components.vae.config.latents_mean).view(1, -1, 1, 1, 1)
+        latents_std = torch.tensor(components.vae.config.latents_std).view(1, -1, 1, 1, 1)
+        pixel_mean = torch.tensor(MINIMAX_H3_PIXEL_MEAN, device=device).view(1, -1, 1, 1, 1)
+        pixel_std = torch.tensor(MINIMAX_H3_PIXEL_STD, device=device).view(1, -1, 1, 1, 1)
+        audio_latents_mean = torch.tensor(components.audio_vae.config.latents_mean).view(1, 1, -1)
+        audio_latents_std = torch.tensor(components.audio_vae.config.latents_std).view(1, 1, -1)
+
+        video_rows, audio_rows = [], []
+        for reference in references:
+            if reference.kind != "audio":
+                if reference.kind == "image":
+                    pixels = torch.from_numpy(np.array(reference.image)).to(device).permute(2, 0, 1)[None, :, None]
+                else:
+                    frames = reference.frames[: trim_reference_num_frames(reference.frames.shape[0])]
+                    pixels = torch.from_numpy(frames.copy()).to(device).permute(3, 0, 1, 2)[None]
+                pixels = (pixels.to(torch.float32).div(255.0) - pixel_mean) / pixel_std
+                # A single frame is encoded by the (tiled) spatial encoder alone; a video goes through the temporal
+                # chunking, which is what turns `17 * n + 5` frames into `5 * n + 2` latent frames.
+                moments = (
+                    components.vae._encode_clip(pixels)
+                    if reference.kind == "image"
+                    else components.vae._encode(pixels)
+                )
+                posterior = DiagonalGaussianDistribution(moments)
+                latents = posterior.sample(generator=torch.Generator().manual_seed(MINIMAX_H3_KEYFRAME_ENCODE_SEED))
+                # The sampled latent is rounded to float16 before it is normalized: ~11 bits of every conditioning
+                # latent, so the released model's conditioning cannot be reproduced without it.
+                latents = latents.to(torch.float16).float().cpu()
+                reference.num_latent_frames = latents.shape[2]
+                reference.latent_height, reference.latent_width = latents.shape[3], latents.shape[4]
+                video_rows.append(
+                    patchify_video_latents((latents - latents_mean) / latents_std, components.patch_size)
+                )
+
+            if reference.has_audio:
+                posterior = components.audio_vae.encode(reference.waveform.to(device)[:, None], return_dict=False)[0]
+                # Channel-major rows: the two stereo channels are two batch items of the mono audio VAE.
+                latents = posterior.mode().float().cpu().transpose(1, 2)
+                reference.num_audio_latents = latents.shape[1]
+                normalized = (latents - audio_latents_mean) / audio_latents_std
+                audio_rows.append(normalized.reshape(-1, components.audio_latent_channels))
+
+        return (
+            torch.cat(video_rows) if video_rows else None,
+            torch.cat(audio_rows) if audio_rows else None,
+        )
+
+    @torch.no_grad()
+    def __call__(self, components: MiniMaxH3Ref2VAModularPipeline, state: PipelineState) -> PipelineState:
+        block_state = self.get_block_state(state)
+        device = components._execution_device
+
+        condition_latents, audio_condition_latents = self.encode_references(
+            components, block_state.prepared_references, device=device
+        )
+        if condition_latents is not None:
+            noise = keyframe_condition_noise(
+                tuple(
+                    (reference.num_latent_frames, reference.latent_height, reference.latent_width)
+                    for reference in block_state.prepared_references
+                    if reference.kind != "audio"
+                ),
+                components.patch_size,
+                components.vae_latent_channels,
+                generator=block_state.generator,
+                device=device,
+            )
+            condition_latents = components.scheduler.scale_noise(
+                condition_latents.to(device), MINIMAX_H3_KEYFRAME_NOISE_AUG, noise
+            )
+        if audio_condition_latents is not None:
+            audio_condition_latents = audio_condition_latents.to(device)
+
+        block_state.condition_latents = condition_latents
+        block_state.audio_condition_latents = audio_condition_latents
+
+        self.set_block_state(state, block_state)
+        return components, state
diff --git a/src/diffusers/modular_pipelines/minimax_h3/modular_blocks_minimax_h3.py b/src/diffusers/modular_pipelines/minimax_h3/modular_blocks_minimax_h3.py
new file mode 100644
index 000000000000..b1a7b4f69724
--- /dev/null
+++ b/src/diffusers/modular_pipelines/minimax_h3/modular_blocks_minimax_h3.py
@@ -0,0 +1,345 @@
+# Copyright 2026 The MiniMax and HuggingFace Teams. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+
+from ..modular_pipeline import ConditionalPipelineBlocks, SequentialPipelineBlocks
+from ..modular_pipeline_utils import OutputParam
+from .before_denoise import (
+    MiniMaxH3PrepareLatentsStep,
+    MiniMaxH3PrepareLayoutStep,
+    MiniMaxH3Ref2VAPrepareLayoutStep,
+    MiniMaxH3SetTimestepsStep,
+)
+from .before_encoder import MiniMaxH3Ref2VASetupStep, MiniMaxH3SetupStep
+from .decoders import MiniMaxH3AudioDecodeStep, MiniMaxH3VideoDecodeStep
+from .denoise import MiniMaxH3DenoiseStep, MiniMaxH3Ref2VADenoiseStep
+from .encoders import (
+    MiniMaxH3KeyframeVaeEncoderStep,
+    MiniMaxH3Ref2VAReferenceEncoderStep,
+    MiniMaxH3Ref2VATextEncoderStep,
+    MiniMaxH3TextEncoderStep,
+)
+
+
+def _generation_outputs() -> list[OutputParam]:
+    r"""Video and audio are generated jointly; muxing them into one file is up to the caller."""
+    return [
+        OutputParam.template("videos", description="The generated video."),
+        OutputParam(
+            "audio",
+            type_hint=torch.Tensor,
+            description="The generated soundtrack, of shape `(1, 2, num_samples)`.",
+        ),
+        OutputParam("sampling_rate", type_hint=int, description="Sample rate of the generated soundtrack in Hz."),
+    ]
+
+
+# auto_docstring
+class MiniMaxH3AutoKeyframeVaeEncoderStep(ConditionalPipelineBlocks):
+    """
+    Keyframe conditioning block.
+       - MiniMaxH3KeyframeVaeEncoderStep runs for the `fl2va` task, whichever of the two keyframes is given.
+       - when neither `image` nor `last_image` is provided (`t2va`), this block is skipped.
+
+      Components:
+          vae (`AutoencoderKLMiniMaxH3`) scheduler (`MiniMaxH3Scheduler`)
+
+      Inputs:
+          keyframes (`list`, *optional*):
+              The keyframes put onto the target canvas, in packed order.
+          latent_height (`int`, *optional*):
+              Height of the video latents.
+          latent_width (`int`, *optional*):
+              Width of the video latents.
+          generator (`Generator`, *optional*):
+              The generator of the request. The conditioning noise is drawn from it before the target noise of the
+              prepare-latents step.
+
+      Outputs:
+          condition_latents (`Tensor`):
+              The noise-augmented video conditioning rows, in packed order.
+    """
+
+    model_name = "minimax-h3"
+    block_classes = [MiniMaxH3KeyframeVaeEncoderStep]
+    block_names = ["keyframes"]
+    block_trigger_inputs = ["image", "last_image"]
+    default_block_name = None
+
+    def select_block(self, **kwargs) -> str | None:
+        if kwargs.get("image") is not None or kwargs.get("last_image") is not None:
+            return "keyframes"
+        return None
+
+    @property
+    def description(self):
+        return (
+            "Keyframe conditioning block.\n"
+            + " - MiniMaxH3KeyframeVaeEncoderStep runs for the `fl2va` task, whichever of the two keyframes is given.\n"
+            + " - when neither `image` nor `last_image` is provided (`t2va`), this block is skipped."
+        )
+
+
+# auto_docstring
+class MiniMaxH3DecodeStep(SequentialPipelineBlocks):
+    """
+    Decodes the denoised rows of the packed sequence into the generated video and its soundtrack.
+
+      Components:
+          vae (`AutoencoderKLMiniMaxH3`) video_processor (`VideoProcessor`) audio_vae (`AutoencoderKLMiniMaxH3Audio`)
+
+      Inputs:
+          latents (`Tensor`):
+              The denoised video rows of the packed sequence, conditioning rows first.
+          num_condition_video_rows (`int`, *optional*, defaults to 0):
+              How many leading video rows are conditioning rows and are dropped here.
+          num_latent_frames (`int`):
+              Number of video latent frames.
+          latent_height (`int`):
+              Height of the video latents.
+          latent_width (`int`):
+              Width of the video latents.
+          output_type (`str`, *optional*, defaults to pil):
+              Output format: 'pil', 'np', 'pt' or 'latent' for the raw latents.
+          audio_latents (`Tensor`):
+              The denoised audio rows of the packed sequence, reference rows first.
+          num_condition_audio_rows (`int`, *optional*, defaults to 0):
+              How many leading audio rows are reference rows and are dropped here.
+          num_audio_latents (`int`):
+              Number of audio latents per channel.
+
+      Outputs:
+          videos (`list`):
+              The generated video.
+          audio (`Tensor`):
+              The generated soundtrack, of shape `(1, 2, num_samples)`.
+          sampling_rate (`int`):
+              Sample rate of the generated soundtrack in Hz.
+    """
+
+    model_name = "minimax-h3"
+    block_classes = [MiniMaxH3VideoDecodeStep, MiniMaxH3AudioDecodeStep]
+    block_names = ["video", "audio"]
+
+    @property
+    def description(self):
+        return "Decodes the denoised rows of the packed sequence into the generated video and its soundtrack."
+
+    @property
+    def outputs(self):
+        return _generation_outputs()
+
+
+# auto_docstring
+class MiniMaxH3Blocks(SequentialPipelineBlocks):
+    """
+    Modular pipeline blocks for joint video + audio generation with MiniMax-H3, covering the `t2va` (text only) and
+    `fl2va` (first and/or last keyframe) tasks of the FL2VA checkpoint.
+
+      Supported workflows:
+        - `t2va`: requires `prompt`
+        - `fl2va`: requires `prompt`, `image`
+        - `fl2va_last_frame`: requires `prompt`, `last_image`
+
+      Components:
+          text_encoder (`Qwen3VLForConditionalGeneration`) tokenizer (`Qwen2Tokenizer`) processor (`Qwen3VLProcessor`)
+          vae (`AutoencoderKLMiniMaxH3`) scheduler (`MiniMaxH3Scheduler`) audio_scheduler (`MiniMaxH3Scheduler`)
+          transformer (`MiniMaxH3Transformer3DModel`) video_processor (`VideoProcessor`) audio_vae
+          (`AutoencoderKLMiniMaxH3Audio`)
+
+      Inputs:
+          image (`Image`, *optional*):
+              Keyframe the video starts from. It is *stretched* onto the target canvas, which by default is derived
+              from its own aspect ratio.
+          last_image (`Image`, *optional*):
+              Keyframe the video ends on. Can be passed on its own to generate *up to* a frame. Combined with `image`
+              it is the follower of the two and is cover-cropped onto the canvas.
+          height (`int`, *optional*):
+              Height of the generated video in pixels, a multiple of 32.
+          width (`int`, *optional*):
+              Width of the generated video in pixels, a multiple of 32.
+          num_frames (`int`, *optional*, defaults to 124):
+              Number of frames to generate, at the fixed 24 fps. Snapped up to the next `17 * n + 5` the video VAE can
+              decode; the resulting duration must stay between 5 and 15 seconds.
+          prompt (`str`):
+              The prompt to guide generation, a single string.
+          generator (`Generator`, *optional*):
+              The generator of the request. The conditioning noise is drawn from it before the target noise of the
+              prepare-latents step.
+          latents (`Tensor`, *optional*):
+              Pre-generated video noise of shape `(1, 24, num_latent_frames, latent_height, latent_width)`, used
+              instead of the draw.
+          audio_latents (`Tensor`, *optional*):
+              Pre-generated audio noise of shape `(2, 32, num_audio_latents)`.
+          condition_latents (`Tensor`, *optional*):
+              The video conditioning rows to prepend, or None for a request that has none.
+          audio_condition_latents (`Tensor`, *optional*):
+              The audio conditioning rows to prepend, or None for a request that has none.
+          num_inference_steps (`int`):
+              The number of denoising steps.
+          attention_kwargs (`dict`, *optional*):
+              Additional kwargs for attention processors.
+          output_type (`str`, *optional*, defaults to pil):
+              Output format: 'pil', 'np', 'pt' or 'latent' for the raw latents.
+
+      Outputs:
+          videos (`list`):
+              The generated video.
+          audio (`Tensor`):
+              The generated soundtrack, of shape `(1, 2, num_samples)`.
+          sampling_rate (`int`):
+              Sample rate of the generated soundtrack in Hz.
+    """
+
+    model_name = "minimax-h3"
+    block_classes = [
+        MiniMaxH3SetupStep,
+        MiniMaxH3TextEncoderStep,
+        MiniMaxH3AutoKeyframeVaeEncoderStep,
+        MiniMaxH3PrepareLayoutStep,
+        MiniMaxH3PrepareLatentsStep,
+        MiniMaxH3SetTimestepsStep,
+        MiniMaxH3DenoiseStep,
+        MiniMaxH3DecodeStep,
+    ]
+    block_names = [
+        "setup",
+        "text_encoder",
+        "vae_encoder",
+        "prepare_layout",
+        "prepare_latents",
+        "set_timesteps",
+        "denoise",
+        "decode",
+    ]
+    # One repository holds both checkpoint partitions, so the two blocksets are two workflows over one shared
+    # `modular_model_index.json`, and each declares only the components its own half loads. The keys below are the
+    # task names a `workflow=` argument to `ModularPipeline.from_pretrained` would take, so that the component subset
+    # of a task can be resolved from the index without instantiating the blocks first.
+    _workflow_map = {
+        "t2va": {"prompt": True},
+        "fl2va": {"prompt": True, "image": True},
+        "fl2va_last_frame": {"prompt": True, "last_image": True},
+    }
+
+    @property
+    def description(self):
+        return (
+            "Modular pipeline blocks for joint video + audio generation with MiniMax-H3, covering the `t2va` (text "
+            "only) and `fl2va` (first and/or last keyframe) tasks of the FL2VA checkpoint."
+        )
+
+    @property
+    def outputs(self):
+        return _generation_outputs()
+
+
+# auto_docstring
+class MiniMaxH3Ref2VABlocks(SequentialPipelineBlocks):
+    """
+    Modular pipeline blocks for joint video + audio generation from an ordered list of image, video and audio
+    references with MiniMax-H3, the `ref2va` task of the Ref2VA checkpoint.
+
+      Supported workflows:
+        - `ref2va`: requires `prompt`, `references`
+
+      Components:
+          text_encoder (`Qwen3VLForConditionalGeneration`) tokenizer (`Qwen2Tokenizer`) processor (`Qwen3VLProcessor`)
+          vae (`AutoencoderKLMiniMaxH3`) audio_vae (`AutoencoderKLMiniMaxH3Audio`) scheduler (`MiniMaxH3Scheduler`)
+          audio_scheduler (`MiniMaxH3Scheduler`) transformer_ref (`MiniMaxH3Transformer3DModel`) video_processor
+          (`VideoProcessor`)
+
+      Inputs:
+          references (`list`):
+              The references to condition on, **in the order the model should read them**: the order labels them in the
+              prompt presentation and lays them out on the shared rotary clock, so a different order is a different
+              request. Every [`MiniMaxH3Reference`] carries exactly one medium, a path or in-memory media — `image` (at
+              most 9), `video` at its own `fps` (at most 3, whose `audio` soundtrack is conditioned on as well), or
+              `audio` at its own `sample_rate` (at most 3) — for at most 12 references in total, and audio references
+              cannot be the only ones. A path is decoded when the reference is built, so these blocks only ever see
+              pixels and samples.
+          height (`int`, *optional*):
+              Height of the generated video in pixels, a multiple of 32.
+          width (`int`, *optional*):
+              Width of the generated video in pixels, a multiple of 32.
+          num_frames (`int`, *optional*):
+              Number of frames to generate, at the fixed 24 fps. Snapped up to the next `17 * n + 5` the video VAE can
+              decode. May be left out, but only when exactly one reference carries audio, in which case the duration is
+              that soundtrack's.
+          prompt (`str`):
+              The prompt to guide generation, a single string.
+          generator (`Generator`, *optional*):
+              The generator of the request. The conditioning noise is drawn from it before the target noise of the
+              prepare-latents step.
+          latents (`Tensor`, *optional*):
+              Pre-generated video noise of shape `(1, 24, num_latent_frames, latent_height, latent_width)`, used
+              instead of the draw.
+          audio_latents (`Tensor`, *optional*):
+              Pre-generated audio noise of shape `(2, 32, num_audio_latents)`.
+          num_inference_steps (`int`):
+              The number of denoising steps.
+          attention_kwargs (`dict`, *optional*):
+              Additional kwargs for attention processors.
+          output_type (`str`, *optional*, defaults to pil):
+              Output format: 'pil', 'np', 'pt' or 'latent' for the raw latents.
+
+      Outputs:
+          videos (`list`):
+              The generated video.
+          audio (`Tensor`):
+              The generated soundtrack, of shape `(1, 2, num_samples)`.
+          sampling_rate (`int`):
+              Sample rate of the generated soundtrack in Hz.
+    """
+
+    # The `ref2va` task family has its own `MODULAR_PIPELINE_MAPPING` key, so that `init_pipeline` resolves
+    # `MiniMaxH3Ref2VAModularPipeline` (and its `transformer_ref` partition) rather than the FL2VA one.
+    model_name = "minimax-h3-ref2va"
+    block_classes = [
+        MiniMaxH3Ref2VASetupStep,
+        MiniMaxH3Ref2VATextEncoderStep,
+        MiniMaxH3Ref2VAReferenceEncoderStep,
+        MiniMaxH3Ref2VAPrepareLayoutStep,
+        MiniMaxH3PrepareLatentsStep,
+        MiniMaxH3SetTimestepsStep,
+        MiniMaxH3Ref2VADenoiseStep,
+        MiniMaxH3DecodeStep,
+    ]
+    block_names = [
+        "setup",
+        "text_encoder",
+        "reference_encoder",
+        "prepare_layout",
+        "prepare_latents",
+        "set_timesteps",
+        "denoise",
+        "decode",
+    ]
+    # The `ref2va` task name, i.e. the value a `workflow=` argument to `ModularPipeline.from_pretrained` would take
+    # to resolve this half — and its `transformer_ref` partition — out of the shared `modular_model_index.json`.
+    _workflow_map = {
+        "ref2va": {"prompt": True, "references": True},
+    }
+
+    @property
+    def description(self):
+        return (
+            "Modular pipeline blocks for joint video + audio generation from an ordered list of image, video and "
+            "audio references with MiniMax-H3, the `ref2va` task of the Ref2VA checkpoint."
+        )
+
+    @property
+    def outputs(self):
+        return _generation_outputs()
diff --git a/src/diffusers/modular_pipelines/minimax_h3/modular_pipeline.py b/src/diffusers/modular_pipelines/minimax_h3/modular_pipeline.py
new file mode 100644
index 000000000000..97ab2314beaa
--- /dev/null
+++ b/src/diffusers/modular_pipelines/minimax_h3/modular_pipeline.py
@@ -0,0 +1,115 @@
+# Copyright 2026 The MiniMax and HuggingFace Teams. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from ...utils import logging
+from ..modular_pipeline import ModularPipeline
+
+
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
+
+
+class MiniMaxH3ModularPipeline(ModularPipeline):
+    """
+    A ModularPipeline for joint video + audio generation with MiniMax-H3, covering the `t2va` (text only) and `fl2va`
+    (first and/or last keyframe) tasks of the FL2VA checkpoint.
+
+    MiniMax-H3 denoises **one packed sequence** that holds the text conditioning, the keyframe conditioning latents,
+    the audio latents and the video latents at once, which is why the blocks pass a row layout around rather than
+    per-modality tensors, and why the pipeline carries two schedulers (`shift = 12.0` for video, `shift = 3.0` for
+    audio) that are stepped inside a single transformer call.
+
+    The checkpoint is guidance-distilled: guidance is baked into the weights, so there is no guider, no
+    `negative_prompt` and no `guidance_scale`, and every step runs exactly one forward pass.
+
+    MiniMax-H3 is modular only: this pipeline and its blocks are the whole integration, there is no
+    `DiffusionPipeline` half. This class carries the config-derived geometry the blocks read off the components, the
+    packed-sequence geometry lives in `modular_pipelines.minimax_h3.packing`, and the conditioning, encoding and noise
+    contracts live on the blocks themselves.
+
+    ```py
+    import torch
+    from diffusers import ModularPipeline
+
+    pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3")
+    pipe.load_components(dtype=torch.bfloat16)
+    ```
+
+    > [!WARNING] > This is an experimental feature and is likely to change in the future.
+    """
+
+    default_blocks_name = "MiniMaxH3Blocks"
+
+    @property
+    def vae_spatial_compression_ratio(self):
+        if getattr(self, "vae", None) is not None:
+            return self.vae.spatial_compression_ratio
+        return 16
+
+    @property
+    def vae_latent_channels(self):
+        if getattr(self, "vae", None) is not None:
+            return self.vae.config.latent_channels
+        return 24
+
+    @property
+    def audio_sampling_rate(self):
+        if getattr(self, "audio_vae", None) is not None:
+            return self.audio_vae.config.sampling_rate
+        return 32000
+
+    @property
+    def audio_latent_channels(self):
+        if getattr(self, "audio_vae", None) is not None:
+            return self.audio_vae.config.latent_channels
+        return 32
+
+    @property
+    def patch_size(self):
+        if getattr(self, "transformer", None) is not None:
+            return tuple(self.transformer.config.patch_size)
+        return (1, 2, 2)
+
+
+class MiniMaxH3Ref2VAModularPipeline(MiniMaxH3ModularPipeline):
+    """
+    A ModularPipeline for joint video + audio generation from omni-references with MiniMax-H3, the `ref2va` task of the
+    Ref2VA checkpoint.
+
+    A request carries an ordered list of references — up to 9 images, 3 videos and 3 audio clips, 12 in total — and
+    MiniMax-H3 packs one block per reference in front of the generated rows. The order is semantic: it labels the
+    references in the prompt presentation and it advances the shared audio/video rotary clock, so reordering the same
+    references is a different request.
+
+    The transformer is registered as `transformer_ref`, so one repository can hold both checkpoint partitions
+    (`transformer/` for [`MiniMaxH3ModularPipeline`], `transformer_ref/` for this one) and either pipeline loads only
+    its own weights. One repository also means one `modular_model_index.json`, which names the `t2va` / `fl2va` half;
+    load this one through its blocks instead, which reads the very same file:
+
+    ```py
+    pipe = MiniMaxH3Ref2VABlocks().init_pipeline("MiniMaxAI/MiniMax-H3")
+    pipe.load_components(dtype=torch.bfloat16)
+    ```
+
+    The blocks carry the `ref2va` conditioning, encoding and noise contracts themselves.
+
+    > [!WARNING] > This is an experimental feature and is likely to change in the future.
+    """
+
+    default_blocks_name = "MiniMaxH3Ref2VABlocks"
+
+    @property
+    def patch_size(self):
+        if getattr(self, "transformer_ref", None) is not None:
+            return tuple(self.transformer_ref.config.patch_size)
+        return (1, 2, 2)
diff --git a/src/diffusers/modular_pipelines/minimax_h3/packing.py b/src/diffusers/modular_pipelines/minimax_h3/packing.py
new file mode 100644
index 000000000000..c84f7e7f9aa8
--- /dev/null
+++ b/src/diffusers/modular_pipelines/minimax_h3/packing.py
@@ -0,0 +1,538 @@
+# Copyright 2026 The MiniMax and HuggingFace Teams. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+r"""
+Packed-sequence and conditioning machinery of the MiniMax-H3 blocks.
+
+This module holds no block of its own: it is the checkpoint's geometry and its constants, imported by every block
+of `modular_pipelines.minimax_h3` that has to place a row, so that none of them reimplements it.
+
+MiniMax-H3 runs its transformer over a single packed 1-D sequence that holds every modality at once. For the
+text/keyframe tasks the row order is
+
+```
+[ text (L) | keyframe conditions (C) | target audio (A) | target video (V) ]
+```
+
+and every piece of geometry in this module exists to place a row in that sequence and to give it its `(t, h, w)`
+rotary coordinate. The coordinates are built in float64 because video and audio share one 40-units-per-second
+rotary clock — video advances `5/3` rotary units per pixel frame at 24 fps, audio advances one unit per latent at
+40 latents/s — and that shared clock *is* the audio/video alignment.
+
+The reference implementation pads the packed sequence up to a multiple of 64 and keeps the padding tail as a
+separate attention document. Padding therefore cannot influence a live row, and this module builds the sequence
+without it: `MiniMaxH3Transformer3DModel` then needs no attention mask, which keeps the unmasked attention
+backends available.
+"""
+
+from dataclasses import dataclass
+
+import numpy as np
+import torch
+from PIL import Image
+
+from ...utils.torch_utils import randn_tensor
+
+
+# Per-row modality tags. They index the transformer's AdaLN table, so the values are a checkpoint contract.
+MINIMAX_H3_VIDEO_TAG = 0
+MINIMAX_H3_TEXT_TAG = 1
+MINIMAX_H3_AUDIO_TAG = 2
+
+# MiniMax-H3 generates at a fixed 24 fps and was released for a 768 pixel short edge only, with a soft area cap of
+# 768x1344 and both axes rounded to a multiple of 32.
+MINIMAX_H3_FPS = 24
+MINIMAX_H3_SHORT_EDGE = 768
+MINIMAX_H3_MAX_PIXELS = 768 * 1344
+MINIMAX_H3_CANVAS_MULTIPLE = 32
+MINIMAX_H3_MIN_ASPECT_RATIO = 1 / 4
+MINIMAX_H3_MAX_ASPECT_RATIO = 4
+MINIMAX_H3_MIN_DURATION = 5.0
+MINIMAX_H3_MAX_DURATION = 15.0
+
+# The video VAE encodes 17 pixel frames per chunk and drops the 3 trailing latent frames of every chunk, so
+# `17 * n + 5` pixel frames map to `5 * n + 2` latent frames.
+MINIMAX_H3_FRAMES_PER_CHUNK = 17
+MINIMAX_H3_LATENTS_PER_CHUNK = 5
+
+# The pixel convention of the video VAE: ImageNet-normalized RGB over a `[0, 1]` base range.
+MINIMAX_H3_PIXEL_MEAN = (0.485, 0.456, 0.406)
+MINIMAX_H3_PIXEL_STD = (0.229, 0.224, 0.225)
+
+# MiniMax-H3 conditions on the *unnormalized* hidden state its Qwen3-VL conditioner produces after the 50th of its 64
+# decoder layers, i.e. `hidden_states[50]` (`hidden_states[0]` being the embedding output).
+MINIMAX_H3_TEXT_ENCODER_LAYER = 50
+
+# The audio VAE hops 800 samples at 32 kHz, i.e. 40 latents per second. Stereo is carried as two channel-major
+# blocks of audio rows (and as two batch items at the audio VAE boundary, which is mono).
+MINIMAX_H3_AUDIO_LATENTS_PER_SECOND = 40
+MINIMAX_H3_AUDIO_CHANNELS = 2
+
+# Conditioning rows are not fully clean: the released model noises keyframe latents to `t = 0.999` and runs them at
+# that timestep for every denoising step.
+MINIMAX_H3_KEYFRAME_NOISE_AUG = 0.999
+
+# The seeded posterior sample of the keyframe VAE encode. Fixed at 42 independently of the request seed.
+MINIMAX_H3_KEYFRAME_ENCODE_SEED = 42
+
+# Rotary-time constants. One latent frame spans `5/3 * frames_per_latent` rotary units, where the pattern
+# `(1, 4, 4, 4, 4)` mirrors the VAE's 17-pixel-frames-to-5-latent-frames grouping; the spatial axes are normalized
+# by the square root of the latent area and scaled by 32.
+_ROPE_FRAME_RESCALE = 5.0 / 3.0
+_ROPE_FRAMES_PER_LATENT = (1, 4, 4, 4, 4)
+_ROPE_SPATIAL_SCALE = 32
+
+
+@dataclass
+class MiniMaxH3PackedSequence:
+    r"""
+    The structural description of one packed MiniMax-H3 sequence.
+
+    Attributes:
+        sequence_length (`int`):
+            Total number of rows, `L + C + A + V`.
+        position_ids (`torch.Tensor` of shape `(sequence_length, 3)`, float64):
+            The `(t, h, w)` rotary coordinate of every row.
+        token_tags (`torch.Tensor` of shape `(sequence_length,)`):
+            The modality tag of every row.
+        video_indices (`torch.Tensor`):
+            Sequence positions of the video rows: the keyframe conditioning rows first, then the target rows.
+        audio_indices (`torch.Tensor`):
+            Sequence positions of the audio rows: reference rows first (`ref2va` only), then the target rows.
+        text_indices (`torch.Tensor`):
+            Sequence positions of the text rows.
+        num_condition_video_rows (`int`):
+            How many leading entries of `video_indices` are conditioning rows rather than generated rows.
+        num_condition_audio_rows (`int`):
+            How many leading entries of `audio_indices` are reference rows rather than generated rows.
+    """
+
+    sequence_length: int
+    position_ids: torch.Tensor
+    token_tags: torch.Tensor
+    video_indices: torch.Tensor
+    audio_indices: torch.Tensor
+    text_indices: torch.Tensor
+    num_condition_video_rows: int
+    num_condition_audio_rows: int
+
+
+def resolve_canvas_size(aspect_width: float, aspect_height: float) -> tuple[int, int]:
+    r"""
+    Resolve a display aspect ratio into a MiniMax-H3 canvas.
+
+    The short edge starts at 768, the area is capped at `768 * 1344` and both axes are then rounded to the nearest
+    multiple of 32 — so the final area may end up slightly above the pre-rounding budget. Only the ratio of the two
+    arguments matters; pass either the aspect ratio (`16, 9`) or the source dimensions of a keyframe.
+
+    Args:
+        aspect_width (`float`): Width of the target ratio.
+        aspect_height (`float`): Height of the target ratio.
+
+    Returns:
+        `tuple[int, int]`: the `(height, width)` of the canvas.
+    """
+    if aspect_width <= 0 or aspect_height <= 0:
+        raise ValueError(f"The aspect ratio must be positive, got {aspect_width}:{aspect_height}.")
+
+    ratio = aspect_width / aspect_height
+    if not MINIMAX_H3_MIN_ASPECT_RATIO <= ratio <= MINIMAX_H3_MAX_ASPECT_RATIO:
+        raise ValueError(
+            f"MiniMax-H3 supports aspect ratios from 1:4 to 4:1, got {aspect_width}:{aspect_height} ({ratio:g})."
+        )
+
+    if ratio >= 1.0:
+        width, height = MINIMAX_H3_SHORT_EDGE * ratio, float(MINIMAX_H3_SHORT_EDGE)
+    else:
+        width, height = float(MINIMAX_H3_SHORT_EDGE), MINIMAX_H3_SHORT_EDGE / ratio
+
+    area = width * height
+    if area > MINIMAX_H3_MAX_PIXELS:
+        scale = (MINIMAX_H3_MAX_PIXELS / area) ** 0.5
+        width, height = width * scale, height * scale
+
+    multiple = MINIMAX_H3_CANVAS_MULTIPLE
+    return max(multiple, round(height / multiple) * multiple), max(multiple, round(width / multiple) * multiple)
+
+
+def align_num_frames(num_frames: int) -> int:
+    r"""
+    Snap a frame count up to the next `17 * n + 5` the video VAE can encode.
+
+    Args:
+        num_frames (`int`): The requested number of frames.
+
+    Returns:
+        `int`: The aligned number of frames.
+    """
+    if num_frames < 1:
+        raise ValueError(f"`num_frames` must be positive, got {num_frames}.")
+    while num_frames % MINIMAX_H3_FRAMES_PER_CHUNK != MINIMAX_H3_LATENTS_PER_CHUNK:
+        num_frames += 1
+    return num_frames
+
+
+def video_latent_num_frames(num_frames: int) -> int:
+    r"""
+    The number of latent frames the video VAE produces for a `17 * n + 5` frame count.
+
+    Args:
+        num_frames (`int`): An aligned number of frames.
+
+    Returns:
+        `int`: The number of latent frames, `5 * n + 2`.
+    """
+    if num_frames % MINIMAX_H3_FRAMES_PER_CHUNK != MINIMAX_H3_LATENTS_PER_CHUNK:
+        raise ValueError(f"`num_frames` must be of the form 17 * n + 5, got {num_frames}.")
+    return (
+        num_frames - MINIMAX_H3_LATENTS_PER_CHUNK
+    ) // MINIMAX_H3_FRAMES_PER_CHUNK * MINIMAX_H3_LATENTS_PER_CHUNK + 2
+
+
+def audio_latent_num_frames(num_frames: int) -> int:
+    r"""
+    The number of audio latents that covers a video of `num_frames` frames at 24 fps.
+
+    Args:
+        num_frames (`int`): The number of video frames.
+
+    Returns:
+        `int`: The number of audio latents, rounded at the 40 Hz latent grid.
+    """
+    return int(round(num_frames / MINIMAX_H3_FPS * MINIMAX_H3_AUDIO_LATENTS_PER_SECOND))
+
+
+def prepare_keyframe_image(image, height: int, width: int, stretch: bool):
+    r"""
+    Put a keyframe onto the target canvas.
+
+    The first keyframe of a request is the geometry anchor and is *stretched* onto the canvas, while a second
+    keyframe follows that canvas and is cover-cropped (aspect-preserving max-scale LANCZOS resize plus a centre
+    crop). An image that already is the canvas is returned untouched, without a resampling pass.
+
+    Args:
+        image (`PIL.Image.Image`): The keyframe, in RGB and already EXIF-transposed.
+        height (`int`): Canvas height.
+        width (`int`): Canvas width.
+        stretch (`bool`): Whether to stretch (geometry anchor) instead of cover-cropping (follower).
+
+    Returns:
+        `PIL.Image.Image`: The prepared keyframe.
+    """
+    if image.size == (width, height):
+        return image
+    if stretch:
+        return image.resize((width, height), Image.Resampling.LANCZOS)
+
+    scale = max(width / image.size[0], height / image.size[1])
+    resized_size = (max(width, round(image.size[0] * scale)), max(height, round(image.size[1] * scale)))
+    left = max(0, (resized_size[0] - width) // 2)
+    top = max(0, (resized_size[1] - height) // 2)
+    resized = image.resize(resized_size, Image.Resampling.LANCZOS)
+    return resized.crop((left, top, left + width, top + height))
+
+
+def patchify_video_latents(latents: torch.Tensor, patch_size: tuple[int, int, int]) -> torch.Tensor:
+    r"""
+    Pack video latents into transformer rows.
+
+    Args:
+        latents (`torch.Tensor` of shape `(batch_size, channels, num_frames, height, width)`):
+            The latents to pack.
+        patch_size (`tuple[int, int, int]`): The `(t, h, w)` patch.
+
+    Returns:
+        `torch.Tensor` of shape `(batch_size * num_patches, channels * prod(patch_size))`: The packed rows, ordered
+        frame-major then row-major.
+    """
+    patch_t, patch_h, patch_w = patch_size
+    batch_size, channels, num_frames, height, width = latents.shape
+    if num_frames % patch_t or height % patch_h or width % patch_w:
+        raise ValueError(f"Latents of shape {tuple(latents.shape)} are not divisible by the patch {patch_size}.")
+
+    latents = latents.reshape(
+        batch_size,
+        channels,
+        num_frames // patch_t,
+        patch_t,
+        height // patch_h,
+        patch_h,
+        width // patch_w,
+        patch_w,
+    )
+    latents = latents.permute(0, 2, 4, 6, 1, 3, 5, 7)
+    return latents.reshape(-1, channels * patch_t * patch_h * patch_w).contiguous()
+
+
+def unpatchify_video_tokens(
+    rows: torch.Tensor,
+    num_latent_frames: int,
+    latent_height: int,
+    latent_width: int,
+    channels: int,
+    patch_size: tuple[int, int, int],
+) -> torch.Tensor:
+    r"""
+    Unpack transformer rows back into video latents. The inverse of [`patchify_video_latents`].
+
+    Args:
+        rows (`torch.Tensor` of shape `(num_patches, channels * prod(patch_size))`): The packed rows.
+        num_latent_frames (`int`): Number of latent frames.
+        latent_height (`int`): Latent height.
+        latent_width (`int`): Latent width.
+        channels (`int`): Number of latent channels.
+        patch_size (`tuple[int, int, int]`): The `(t, h, w)` patch.
+
+    Returns:
+        `torch.Tensor` of shape `(batch_size, channels, num_latent_frames, latent_height, latent_width)`.
+    """
+    patch_t, patch_h, patch_w = patch_size
+    rows = rows.reshape(
+        -1,
+        num_latent_frames // patch_t,
+        latent_height // patch_h,
+        latent_width // patch_w,
+        channels,
+        patch_t,
+        patch_h,
+        patch_w,
+    )
+    rows = rows.permute(0, 4, 1, 5, 2, 6, 3, 7)
+    return rows.reshape(-1, channels, num_latent_frames, latent_height, latent_width).contiguous()
+
+
+def unpack_audio_tokens(rows: torch.Tensor, num_audio_latents: int) -> torch.Tensor:
+    r"""
+    Unpack the channel-major audio rows into audio VAE latents.
+
+    Args:
+        rows (`torch.Tensor` of shape `(num_audio_latents * 2, latent_channels)`): The packed audio rows.
+        num_audio_latents (`int`): Number of audio latents per channel.
+
+    Returns:
+        `torch.Tensor` of shape `(2, latent_channels, num_audio_latents)`: One batch item per stereo channel, which
+        is what the mono audio VAE consumes.
+    """
+    rows = rows.reshape(MINIMAX_H3_AUDIO_CHANNELS, num_audio_latents, rows.shape[-1])
+    return rows.permute(0, 2, 1).contiguous()
+
+
+def _spatial_position_grid(dim: int, patch: int, sqrt_area: float) -> torch.Tensor:
+    r"""
+    One aspect-normalized spatial rotary axis: `dim // patch` coordinates centred on the unit interval, scaled up by
+    32. The right endpoint is excluded, so a square canvas spans `[0, 32)`.
+    """
+    ratio = dim / sqrt_area
+    left = (1.0 - ratio) / 2.0
+    # Built with numpy: `np.linspace(..., endpoint=False)` is `start + arange(num) * (stop - start) / num`, which is
+    # not what `torch.linspace` computes, and the float64 grid has to be reproduced exactly.
+    grid = np.linspace(left, left + ratio, dim // patch, endpoint=False) * _ROPE_SPATIAL_SCALE
+    return torch.from_numpy(grid).to(torch.float64)
+
+
+def _temporal_position_grid(num_latent_frames: int, origin: float) -> torch.Tensor:
+    r"""The rotary time of every latent frame, starting at `origin`. Spacing is non-uniform: `5/3 * (1, 4, 4, 4, 4)`."""
+    spans = torch.tensor(
+        [
+            _ROPE_FRAME_RESCALE * _ROPE_FRAMES_PER_LATENT[index % len(_ROPE_FRAMES_PER_LATENT)]
+            for index in range(num_latent_frames)
+        ],
+        dtype=torch.float64,
+    )
+    return origin + torch.cat([torch.zeros(1, dtype=torch.float64), spans[:-1].cumsum(0)])
+
+
+def _temporal_position_span(num_latent_frames: int) -> float:
+    r"""
+    The rotary time spanned by `num_latent_frames` latent frames.
+
+    Summed by numpy (pairwise summation) rather than sequentially: the reference computes the keyframe anchor this
+    way and the two summation orders differ in the last ulp from 16 latent frames onwards.
+    """
+    spans = np.ones(num_latent_frames, dtype=np.float64) * _ROPE_FRAME_RESCALE
+    for index in range(len(_ROPE_FRAMES_PER_LATENT)):
+        spans[index :: len(_ROPE_FRAMES_PER_LATENT)] *= _ROPE_FRAMES_PER_LATENT[index]
+    return float(spans.sum())
+
+
+def build_packed_sequence(
+    text_token_tags: torch.Tensor,
+    num_latent_frames: int,
+    latent_height: int,
+    latent_width: int,
+    num_audio_latents: int,
+    patch_size: tuple[int, int, int],
+    keyframe_anchors: tuple[str, ...] = (),
+) -> MiniMaxH3PackedSequence:
+    r"""
+    Build the `[text | keyframe conditions | target audio | target video]` layout used by the `t2va` and `fl2va`
+    tasks.
+
+    Args:
+        text_token_tags (`torch.Tensor` of shape `(num_text_tokens,)`):
+            The modality tag of every text row. Text is tagged `1`, except for the rows of a keyframe's vision block,
+            which MiniMax-H3 tags `0` (video).
+        num_latent_frames (`int`): Number of target latent frames.
+        latent_height (`int`): Target latent height.
+        latent_width (`int`): Target latent width.
+        num_audio_latents (`int`): Number of target audio latents per channel.
+        patch_size (`tuple[int, int, int]`): The transformer's `(t, h, w)` patch.
+        keyframe_anchors (`tuple[str, ...]`):
+            One entry per keyframe conditioning block, in packed order: `"first"` anchors the block at the first
+            latent frame, `"last"` at the last one.
+
+    Returns:
+        [`MiniMaxH3PackedSequence`]
+    """
+    _, patch_h, patch_w = patch_size
+    rows_per_frame = (latent_height // patch_h) * (latent_width // patch_w)
+    num_text_tokens = text_token_tags.shape[0]
+    num_condition_rows = len(keyframe_anchors) * rows_per_frame
+    num_audio_rows = num_audio_latents * MINIMAX_H3_AUDIO_CHANNELS
+    num_video_rows = num_latent_frames * rows_per_frame
+    sequence_length = num_text_tokens + num_condition_rows + num_audio_rows + num_video_rows
+
+    condition_start = num_text_tokens
+    audio_start = condition_start + num_condition_rows
+    video_start = audio_start + num_audio_rows
+
+    # 1. The (t, h, w) grid. Text rows sit on the time axis at their row index, and the media rows continue the time
+    # axis from there, so text length shifts the whole media clock.
+    position_ids = torch.zeros(sequence_length, 3, dtype=torch.float64)
+    position_ids[:num_text_tokens, 0] = torch.arange(num_text_tokens, dtype=torch.float64)
+
+    sqrt_area = np.sqrt(latent_height * latent_width)
+    height_grid = _spatial_position_grid(latent_height, patch_h, sqrt_area)
+    width_grid = _spatial_position_grid(latent_width, patch_w, sqrt_area)
+    frame_grid = torch.stack([grid.reshape(-1) for grid in torch.meshgrid(height_grid, width_grid, indexing="ij")], -1)
+
+    for index, anchor in enumerate(keyframe_anchors):
+        if anchor == "first":
+            anchor_time = float(num_text_tokens)
+        elif anchor == "last":
+            anchor_time = float(num_text_tokens) + _temporal_position_span(num_latent_frames) - _ROPE_FRAME_RESCALE
+        else:
+            raise ValueError(f"A keyframe anchor must be 'first' or 'last', got {anchor!r}.")
+        rows = slice(condition_start + index * rows_per_frame, condition_start + (index + 1) * rows_per_frame)
+        position_ids[rows, 0] = anchor_time
+        position_ids[rows, 1:] = frame_grid
+
+    # Audio rows are channel-major and share the video's rotary clock: one unit per latent at 40 latents/s equals
+    # 24 fps * 5/3. They carry no height coordinate and are pinned to the two extremes of the width grid.
+    audio_time = float(num_text_tokens) + torch.arange(num_audio_latents, dtype=torch.float64)
+    position_ids[audio_start:video_start, 0] = audio_time.repeat(MINIMAX_H3_AUDIO_CHANNELS)
+    position_ids[audio_start:video_start, 2] = torch.cat(
+        [
+            torch.full((num_audio_latents,), float(width_grid[0]), dtype=torch.float64),
+            torch.full((num_audio_rows - num_audio_latents,), float(width_grid[-1]), dtype=torch.float64),
+        ]
+    )
+
+    video_position_ids = torch.empty(num_latent_frames, rows_per_frame, 3, dtype=torch.float64)
+    video_position_ids[:, :, 0] = _temporal_position_grid(num_latent_frames, float(num_text_tokens))[:, None]
+    video_position_ids[:, :, 1:] = frame_grid[None]
+    position_ids[video_start:] = video_position_ids.reshape(-1, 3)
+
+    # 2. Row indices and modality tags.
+    video_indices = torch.cat([torch.arange(condition_start, audio_start), torch.arange(video_start, sequence_length)])
+    audio_indices = torch.arange(audio_start, video_start)
+    text_indices = torch.arange(num_text_tokens)
+
+    token_tags = torch.empty(sequence_length, dtype=torch.long)
+    token_tags[text_indices] = text_token_tags.to(torch.long)
+    token_tags[audio_indices] = MINIMAX_H3_AUDIO_TAG
+    token_tags[video_indices] = MINIMAX_H3_VIDEO_TAG
+
+    return MiniMaxH3PackedSequence(
+        sequence_length=sequence_length,
+        position_ids=position_ids,
+        token_tags=token_tags,
+        video_indices=video_indices,
+        audio_indices=audio_indices,
+        text_indices=text_indices,
+        num_condition_video_rows=num_condition_rows,
+        num_condition_audio_rows=0,
+    )
+
+
+def build_row_timesteps(
+    layout: MiniMaxH3PackedSequence,
+    video_timestep: float,
+    audio_timestep: float,
+    condition_video_timestep: float,
+    condition_audio_timestep: float,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    r"""
+    Assign a timestep to every row of the packed sequence and reduce it to the transformer's `(timestep,
+    timestep_indices)` pair.
+
+    One forward serves rows at different noise levels: the generated video and audio rows step down their own
+    schedules while the conditioning rows stay pinned at their noise-augmentation level. Text rows never reach an
+    output head and inherit the video timestep.
+
+    Args:
+        layout ([`MiniMaxH3PackedSequence`]): The packed layout.
+        video_timestep (`float`): Timestep of the generated video rows.
+        audio_timestep (`float`): Timestep of the generated audio rows.
+        condition_video_timestep (`float`): Timestep of the video conditioning rows.
+        condition_audio_timestep (`float`): Timestep of the audio reference rows.
+
+    Returns:
+        `tuple[torch.Tensor, torch.Tensor]`: the distinct timesteps, sorted, and the index of every row into them.
+    """
+    row_timesteps = torch.full((layout.sequence_length,), video_timestep, dtype=torch.float32)
+    row_timesteps[layout.video_indices[: layout.num_condition_video_rows]] = condition_video_timestep
+    row_timesteps[layout.audio_indices[layout.num_condition_audio_rows :]] = audio_timestep
+    row_timesteps[layout.audio_indices[: layout.num_condition_audio_rows]] = condition_audio_timestep
+    return torch.unique(row_timesteps, sorted=True, return_inverse=True)
+
+
+def keyframe_condition_noise(
+    condition_latent_shapes: tuple[tuple[int, int, int], ...],
+    patch_size: tuple[int, int, int],
+    latent_channels: int,
+    generator: torch.Generator | list[torch.Generator] | None = None,
+    device: torch.device | None = None,
+    dtype: torch.dtype = torch.float32,
+) -> torch.Tensor:
+    r"""
+    Draw the noise that the keyframe (or reference) conditioning rows are mixed with.
+
+    One draw per condition, in packed order, off the request's generator. The conditioning rows are prepared before
+    the target rows, so these are the *first* draws of a request, ahead of the video and audio noise of
+    [`~MiniMaxH3PrepareLatentsStep.prepare_latents`] — the order is part of what a generator reproduces.
+
+    Args:
+        condition_latent_shapes (`tuple[tuple[int, int, int], ...]`):
+            The `(num_latent_frames, latent_height, latent_width)` of every condition, in packed order.
+        patch_size (`tuple[int, int, int]`): The transformer's `(t, h, w)` patch.
+        latent_channels (`int`): Number of video latent channels.
+        generator (`torch.Generator`, *optional*): The generator of the request.
+        device (`torch.device`, *optional*): The device the noise is drawn on.
+        dtype (`torch.dtype`, defaults to `torch.float32`): The dtype of the noise.
+
+    Returns:
+        `torch.Tensor` of shape `(num_condition_rows, latent_channels * prod(patch_size))`: the noise rows,
+        concatenated in packed order.
+    """
+    rows = []
+    for num_latent_frames, latent_height, latent_width in condition_latent_shapes:
+        noise = randn_tensor(
+            (1, latent_channels, num_latent_frames, latent_height, latent_width),
+            generator=generator,
+            device=device,
+            dtype=dtype,
+        )
+        rows.append(patchify_video_latents(noise, patch_size))
+    return torch.cat(rows)
diff --git a/src/diffusers/modular_pipelines/minimax_h3/packing_ref2va.py b/src/diffusers/modular_pipelines/minimax_h3/packing_ref2va.py
new file mode 100644
index 000000000000..3518c9558a0c
--- /dev/null
+++ b/src/diffusers/modular_pipelines/minimax_h3/packing_ref2va.py
@@ -0,0 +1,841 @@
+# Copyright 2026 The MiniMax and HuggingFace Teams. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+r"""
+The `ref2va` half of MiniMax-H3's packed sequence: omni-reference conditioning.
+
+`ref2va` takes an ordered list of references — images, videos (with their soundtrack) and audio clips — and packs one
+block per reference ahead of the generated rows:
+
+```
+[ text (L) | reference block 1 | reference block 2 | ... | target audio (A) | target video (V) ]
+```
+
+The blocks are packed in **request order**, and a video reference packs its soundtrack rows immediately *before* its
+own video rows. Order is semantic twice over: it fixes the `"<Picture i>"` / `"<Audio j>"` / `"<Video k>"` labels of
+the prompt presentation, and it advances the shared rotary clock — an image reference occupies one rotary slot, an
+audio reference as many as it has latents, and a video reference the longer of its own two spans, its soundtrack and
+its frames sharing one origin.
+
+Unlike a `fl2va` keyframe, a reference never binds the target geometry: every reference is prepared at its own
+resolution (2048 pixel short edge for images, MiniMax-H3's 768 pixel canvas for videos) and carries its own
+aspect-normalized spatial grid.
+
+References reach the blocks as in-memory media: a video is decoded frames plus the `fps` they carry, and a soundtrack
+a waveform plus its sample rate. A [`MiniMaxH3Reference`] takes a path or a URL too, but it decodes it when it is
+built, so that no block of this model ever opens a media file.
+"""
+
+import contextlib
+import math
+import os
+import tempfile
+from dataclasses import dataclass, field
+from typing import Any
+from urllib.parse import unquote, urlparse
+
+import numpy as np
+import requests
+import torch
+from PIL import Image
+
+from ...utils import is_av_available, load_image
+from ...utils.constants import DIFFUSERS_REQUEST_TIMEOUT
+from .packing import (
+    _ROPE_FRAME_RESCALE,
+    _ROPE_FRAMES_PER_LATENT,
+    MINIMAX_H3_AUDIO_CHANNELS,
+    MINIMAX_H3_AUDIO_TAG,
+    MINIMAX_H3_CANVAS_MULTIPLE,
+    MINIMAX_H3_FPS,
+    MINIMAX_H3_FRAMES_PER_CHUNK,
+    MINIMAX_H3_LATENTS_PER_CHUNK,
+    MINIMAX_H3_TEXT_TAG,
+    MINIMAX_H3_VIDEO_TAG,
+    MiniMaxH3PackedSequence,
+    _spatial_position_grid,
+    _temporal_position_grid,
+    resolve_canvas_size,
+)
+
+
+# Reference images are resized to a 2048 pixel short edge — upscaling included — and both axes are rounded to a
+# multiple of 32 independently. There is no area cap, so a 4:1 reference is 8192x2048.
+MINIMAX_H3_REFERENCE_IMAGE_SHORT_EDGE = 2048
+
+# The conditioner sees a reference video at 2 fps, and Qwen3-VL merges every two of those frames into one vision
+# block labelled with the mean timestamp of the pair.
+MINIMAX_H3_QWEN_VIDEO_SAMPLE_FPS = 2.0
+MINIMAX_H3_QWEN_TEMPORAL_PATCH = 2
+
+# Documented per-request limits of the omni-reference task.
+MINIMAX_H3_MAX_REFERENCE_IMAGES = 9
+MINIMAX_H3_MAX_REFERENCE_VIDEOS = 3
+MINIMAX_H3_MAX_REFERENCE_AUDIOS = 3
+MINIMAX_H3_MAX_REFERENCES = 12
+
+
+@contextlib.contextmanager
+def _local_media_file(media):
+    r"""The reference media as a local file: a URL is downloaded to a temporary file, removed on the way out."""
+    path = str(media)
+    if not path.startswith(("http://", "https://")):
+        if not os.path.isfile(path):
+            raise ValueError(
+                f"Incorrect path or URL. URLs must start with `http://` or `https://`, and {path} is not a valid path."
+            )
+        yield path
+        return
+
+    response = requests.get(path, stream=True, timeout=DIFFUSERS_REQUEST_TIMEOUT)
+    if response.status_code != 200:
+        raise ValueError(f"Failed to download {path}. Status code: {response.status_code}")
+    suffix = os.path.splitext(os.path.basename(unquote(urlparse(path).path)))[1]
+    download = tempfile.NamedTemporaryFile(suffix=suffix, delete=False)
+    try:
+        with download as file:
+            for chunk in response.iter_content(chunk_size=8192):
+                file.write(chunk)
+        yield download.name
+    finally:
+        os.remove(download.name)
+
+
+def _import_av():
+    r"""PyAV, the soft dependency a reference decodes a media file with."""
+    if not is_av_available():
+        raise ImportError(
+            "Decoding a MiniMax-H3 reference from a file needs PyAV. You can install it with `pip install av`, or "
+            "pass the decoded media itself: frames and the `fps` they carry for a video, a `(channels, num_samples)` "
+            "waveform and its `sample_rate` for audio."
+        )
+
+    import av
+
+    return av
+
+
+def _decode_reference_soundtrack(av, container, stream) -> tuple[torch.Tensor, int]:
+    r"""
+    An audio stream's samples as a `(channels, num_samples)` float32 waveform, at the rate the container carries them.
+
+    Args:
+        av (`module`): PyAV.
+        container (`av.container.InputContainer`): The open container.
+        stream (`av.audio.stream.AudioStream`): The stream to decode.
+
+    Returns:
+        `tuple[torch.Tensor, int]`: the waveform and its sample rate.
+    """
+    sample_rate = int(stream.codec_context.sample_rate)
+    # Planar float is a format conversion only: the sample rate and the channel layout stay the container's own, and a
+    # mono soundtrack is upmixed later, by `prepare_reference_waveform`.
+    resampler = av.audio.resampler.AudioResampler(format="fltp", layout=stream.layout, rate=sample_rate)
+    chunks = []
+    for frame in container.decode(stream):
+        chunks += [torch.from_numpy(resampled.to_ndarray()) for resampled in resampler.resample(frame)]
+    # Whatever the resampler is still holding.
+    chunks += [torch.from_numpy(resampled.to_ndarray()) for resampled in resampler.resample(None)]
+    return torch.cat(chunks, dim=-1).to(torch.float32), sample_rate
+
+
+def decode_reference_video(media) -> tuple[np.ndarray, float, tuple[torch.Tensor, int] | None]:
+    r"""
+    Decode a reference video file into `uint8` RGB frames, at the resolution and the frame rate it carries.
+
+    Args:
+        media (`str` or `os.PathLike`): Path or URL of the video.
+
+    Returns:
+        `tuple[np.ndarray, float, tuple[torch.Tensor, int]]`: the `(num_frames, height, width, 3)` frames, the frame
+        rate the container reports, and its soundtrack with that soundtrack's own sample rate, `None` when the
+        container carries no audio stream.
+    """
+    av = _import_av()
+    with _local_media_file(media) as path, av.open(path) as container:
+        stream = container.streams.video[0]
+        frames, rotation = [], 0.0
+        for frame in container.decode(stream):
+            # The display matrix rotation belongs to the stream, and PyAV surfaces it on every frame of it.
+            rotation = frame.rotation
+            frames.append(frame.to_ndarray(format="rgb24"))
+        frame_rate = float(stream.average_rate or stream.guessed_rate)
+        soundtrack = None
+        if container.streams.audio:
+            # Decoding the frames drained the container, so the soundtrack is read in a second pass over it.
+            container.seek(0)
+            soundtrack = _decode_reference_soundtrack(av, container, container.streams.audio[0])
+
+    if not frames:
+        raise ValueError(f"No video frames to decode in {media}.")
+    frames = np.stack(frames)
+    # `ffmpeg` displays a frame upright by undoing the counterclockwise rotation the display matrix carries, which is
+    # what this reproduces, snapped to the nearest quarter turn. A non-square pixel aspect ratio is left alone: the
+    # reference implementation resolved a reference's canvas from its *display* geometry, so a stream that carries a
+    # sample aspect ratio is conditioned on at the wrong shape, and correcting it is untested guesswork here.
+    turns = round(rotation / 90.0) % 4
+    if turns:
+        frames = np.ascontiguousarray(np.rot90(frames, k=-turns, axes=(1, 2)))
+    return frames, frame_rate, soundtrack
+
+
+def decode_reference_audio(media) -> tuple[torch.Tensor, int]:
+    r"""
+    Decode a reference audio file into a waveform, at the sample rate it carries.
+
+    Args:
+        media (`str` or `os.PathLike`): Path or URL of the audio, or of a video whose soundtrack is taken.
+
+    Returns:
+        `tuple[torch.Tensor, int]`: the `(channels, num_samples)` float32 waveform and its sample rate.
+    """
+    av = _import_av()
+    with _local_media_file(media) as path, av.open(path) as container:
+        if not container.streams.audio:
+            raise ValueError(f"No audio stream to decode in {media}.")
+        return _decode_reference_soundtrack(av, container, container.streams.audio[0])
+
+
+@dataclass
+class MiniMaxH3Reference:
+    r"""
+    One omni-reference of a [`MiniMaxH3Ref2VABlocks`] request: an image, a video, or an audio clip.
+
+    A reference carries exactly one medium — plus, for a video, the `audio` of its own soundtrack, which is then
+    conditioned on as that reference's own. References are passed to the blocks as a list, **in the order the model
+    should read them**: the order labels them in the prompt presentation and lays them out on the shared rotary clock,
+    so a different order is a different request.
+
+    Every medium may be a path or a URL as well as in-memory media. A path is decoded here, when the reference is
+    built, and with it the rates that come with it: no MiniMax-H3 block opens a media file. Decoding a video or an
+    audio file needs [PyAV](https://github.com/PyAV-Org/PyAV).
+
+    ```py
+    >>> from diffusers.modular_pipelines.minimax_h3 import MiniMaxH3Reference
+
+    >>> # A file or a URL is decoded on the spot, at the rate the container reports.
+    >>> references = [
+    ...     MiniMaxH3Reference(video="motion_ref.mp4"),
+    ...     MiniMaxH3Reference(image="subject.png"),
+    ...     MiniMaxH3Reference(audio="voice.wav"),
+    ... ]
+
+    >>> # In-memory media instead carries the rates it was produced at, MiniMax-H3's own by default.
+    >>> import numpy as np
+
+    >>> frames = np.zeros((30, 480, 854, 3), dtype="uint8")
+    >>> reference = MiniMaxH3Reference(video=frames, fps=30.0)
+    ```
+
+    Attributes:
+        image (`str`, `os.PathLike`, `PIL.Image.Image`, `np.ndarray` or `torch.Tensor`, *optional*):
+            A subject, style or scene reference: at most 9 per request. A path or a URL, which is read with
+            [`~utils.load_image`], a `(height, width, 3)` array or a `(3, height, width)` tensor, `uint8` or floating
+            point over `[0, 1]`. Mutually exclusive with `video`.
+        video (`str`, `os.PathLike`, `list[PIL.Image.Image]`, `np.ndarray` or `torch.Tensor`, *optional*):
+            A motion and camera reference: at most 3 per request. A path or a URL, which PyAV decodes into frames, a
+            list of images, a `(num_frames, height, width, 3)` array or a `(num_frames, 3, height, width)` tensor.
+            Mutually exclusive with `image`. A decoded file brings its soundtrack along, as this reference's own, so
+            conditioning on a file's motion alone means decoding its frames first, with [`~utils.load_video`].
+        fps (`float`, *optional*):
+            The frame rate `video` carries its frames at, which is what places its vision blocks on the conditioner's
+            2 fps grid. Left out, it is the rate the container reports for a decoded file and MiniMax-H3's own 24 fps
+            for in-memory frames, and `fps` holds that resolved rate once the reference is built. Passing it wins over
+            both, which is only needed when a container's metadata is wrong. MiniMax-H3's clock is 24 fps, so any other
+            rate is resampled onto it by dropping and duplicating whole frames.
+        audio (`str`, `os.PathLike` or `torch.Tensor` of shape `(channels, num_samples)`, *optional*):
+            A voice or music reference, mono or stereo: at most 3 per request, and never on its own — an audio
+            reference has to be paired with at least one image or video reference. A path or a URL, which PyAV decodes
+            into a waveform, or the waveform itself. Passed next to `video`, it is that video's soundtrack instead of a
+            reference of its own. An audio reference never reaches the conditioner and is encoded by the audio VAE
+            alone.
+        sample_rate (`int`, *optional*):
+            The rate `audio` carries its samples at. Left out, it is the rate the container reports for a decoded file,
+            and for an in-memory waveform the audio VAE's own, which leaves the samples untouched. Passing it wins over
+            both, which is only needed when a container's metadata is wrong. Any other rate is resampled onto the audio
+            VAE's own.
+    """
+
+    image: str | os.PathLike | Image.Image | np.ndarray | torch.Tensor | None = None
+    video: str | os.PathLike | list[Image.Image] | np.ndarray | torch.Tensor | None = None
+    fps: float | None = None
+    audio: str | os.PathLike | torch.Tensor | None = None
+    sample_rate: int | None = None
+
+    def __post_init__(self):
+        # A video reference conditions on its soundtrack too, so `audio` is a second medium of a video reference.
+        media = [name for name in ("image", "video", "audio") if getattr(self, name) is not None]
+        if media not in (["image"], ["video"], ["audio"], ["video", "audio"]):
+            raise ValueError(
+                "A `MiniMaxH3Reference` must carry exactly one of `image`, `video` or `audio` — plus, for a video, "
+                f"the `audio` of its soundtrack — got {media if media else 'none of them'}."
+            )
+
+        # A path is decoded on the spot, so that the blocks only ever see in-memory media. A rate the request
+        # passed explicitly wins over the one the container reports, for a container whose metadata is wrong.
+        if isinstance(self.image, (str, os.PathLike)):
+            self.image = load_image(str(self.image))
+        if isinstance(self.video, (str, os.PathLike)):
+            frames, frame_rate, soundtrack = decode_reference_video(self.video)
+            self.video = frames
+            self.fps = frame_rate if self.fps is None else self.fps
+            if soundtrack is not None and self.audio is None:
+                self.audio, soundtrack_sample_rate = soundtrack
+                self.sample_rate = soundtrack_sample_rate if self.sample_rate is None else self.sample_rate
+        if isinstance(self.audio, (str, os.PathLike)):
+            self.audio, sample_rate = decode_reference_audio(self.audio)
+            self.sample_rate = sample_rate if self.sample_rate is None else self.sample_rate
+        if self.fps is None:
+            self.fps = float(MINIMAX_H3_FPS)
+
+    @property
+    def kind(self) -> str:
+        r"""The modality this reference is packed as: `"image"`, `"video"` or `"audio"`."""
+        if self.image is not None:
+            return "image"
+        return "video" if self.video is not None else "audio"
+
+    @property
+    def has_audio(self) -> bool:
+        r"""Whether this reference contributes audio rows, i.e. whether it carries a waveform."""
+        return self.audio is not None
+
+
+def reference_kind(index: int, entry: Any) -> str:
+    r"""
+    The modality of one `references` entry, which the [`MiniMaxH3Reference`] validated at construction.
+    """
+    if not isinstance(entry, MiniMaxH3Reference):
+        raise ValueError(
+            f"`references[{index}]` must be a [`MiniMaxH3Reference`], got {type(entry)}. A request is built from "
+            "the dataclass: `MiniMaxH3Reference(image=...)`, `MiniMaxH3Reference(video=...)` or "
+            "`MiniMaxH3Reference(audio=...)`."
+        )
+    # A reference decodes a path when it is built, so the blocks only ever see in-memory media.
+    for name in ("image", "video", "audio"):
+        if isinstance(getattr(entry, name), (str, os.PathLike)):
+            raise ValueError(
+                f"`references[{index}].{name}` is a path. MiniMax-H3 blocks never open media files: rebuild "
+                "the reference, which decodes a path as it is built."
+            )
+    return entry.kind
+
+
+@dataclass
+class MiniMaxH3PreparedReference:
+    r"""
+    One `ref2va` reference prepared for packing, in packed order.
+
+    A [`MiniMaxH3Reference`] is resolved in three passes: the blocks read the modality off the request (`kind`,
+    `has_audio`), prepares the pixels or samples (`image`, `frames`, `waveform`), and finally encodes them, which is
+    what fixes the latent geometry (`num_latent_frames`, `latent_height`, `latent_width`, `num_audio_latents`) the
+    packed layout is built from.
+
+    Attributes:
+        kind (`str`):
+            `"image"`, `"video"` or `"audio"`.
+        has_audio (`bool`):
+            Whether this reference contributes audio rows. Always `True` for `"audio"`, and `True` for a `"video"` the
+            request passed a soundtrack with.
+        image (`PIL.Image.Image`):
+            The prepared reference image.
+        frames (`np.ndarray` of shape `(num_frames, height, width, 3)`):
+            The prepared reference video, `uint8` RGB at 24 fps.
+        waveform (`torch.Tensor` of shape `(2, num_samples)`):
+            The prepared soundtrack, stereo at the audio VAE's sample rate.
+        block_timestamps (`list[float]`):
+            The timestamp of every vision block the conditioner sees for a video reference.
+        num_latent_frames (`int`), latent_height (`int`), latent_width (`int`):
+            Latent geometry of the visual rows.
+        num_audio_latents (`int`):
+            Number of audio latents per channel.
+    """
+
+    kind: str
+    has_audio: bool = False
+    image: Any = None
+    frames: Any = None
+    waveform: torch.Tensor | None = None
+    block_timestamps: list[float] = field(default_factory=list)
+    num_latent_frames: int = 1
+    latent_height: int = 0
+    latent_width: int = 0
+    num_audio_latents: int = 0
+
+    @property
+    def num_video_rows(self) -> int:
+        r"""The number of packed video rows, for the `(1, 2, 2)` patch MiniMax-H3 packs video latents with."""
+        return self.num_latent_frames * (self.latent_height // 2) * (self.latent_width // 2)
+
+    @property
+    def num_audio_rows(self) -> int:
+        r"""The number of packed audio rows: one per latent and per stereo channel."""
+        return self.num_audio_latents * MINIMAX_H3_AUDIO_CHANNELS
+
+
+def _temporal_position_span(num_latent_frames: int) -> float:
+    r"""
+    The rotary time a video reference advances the clock by.
+
+    Summed sequentially in float64, which is *not* how [`~modular_pipelines.minimax_h3.packing._temporal_position_span`] sums
+    the same series: that one reproduces a numpy pairwise sum, and the two orders differ in the last ulp from 16
+    latent frames onwards. The reference implementation keeps both, one per call site, so the port has to as well.
+    """
+    return sum(
+        _ROPE_FRAME_RESCALE * _ROPE_FRAMES_PER_LATENT[index % len(_ROPE_FRAMES_PER_LATENT)]
+        for index in range(num_latent_frames)
+    )
+
+
+def _frame_position_grid(
+    latent_height: int, latent_width: int, patch_h: int, patch_w: int
+) -> tuple[torch.Tensor, torch.Tensor]:
+    r"""The `(h, w)` rotary coordinates of one latent frame, and the width axis they were built from."""
+    sqrt_area = np.sqrt(latent_height * latent_width)
+    height_grid = _spatial_position_grid(latent_height, patch_h, sqrt_area)
+    width_grid = _spatial_position_grid(latent_width, patch_w, sqrt_area)
+    grids = torch.meshgrid(height_grid, width_grid, indexing="ij")
+    return torch.stack([grid.reshape(-1) for grid in grids], dim=-1), width_grid
+
+
+def _fill_audio_positions(
+    position_ids: torch.Tensor,
+    rows: slice,
+    num_audio_latents: int,
+    rotary_time: float,
+    width_grid: torch.Tensor,
+) -> None:
+    r"""
+    Place one channel-major audio block.
+
+    Audio rows carry no height coordinate and are pinned to the two extremes of the width grid of *their own* block —
+    the target grid for a standalone audio reference, the video's grid for a soundtrack.
+    """
+    time = rotary_time + torch.arange(num_audio_latents, dtype=torch.float64)
+    position_ids[rows, 0] = time.repeat(MINIMAX_H3_AUDIO_CHANNELS)
+    position_ids[rows, 2] = torch.cat(
+        [
+            torch.full((num_audio_latents,), float(width_grid[0]), dtype=torch.float64),
+            torch.full((num_audio_latents,), float(width_grid[-1]), dtype=torch.float64),
+        ]
+    )
+
+
+def build_ref2va_packed_sequence(
+    text_token_tags: torch.Tensor,
+    references: list[MiniMaxH3PreparedReference],
+    num_latent_frames: int,
+    latent_height: int,
+    latent_width: int,
+    num_audio_latents: int,
+    patch_size: tuple[int, int, int],
+) -> MiniMaxH3PackedSequence:
+    r"""
+    Build the `[text | reference blocks | target audio | target video]` layout of the `ref2va` task.
+
+    Args:
+        text_token_tags (`torch.Tensor` of shape `(num_text_tokens,)`):
+            The modality tag of every text row. Text is tagged `1`, except for the rows of a reference's vision block,
+            which MiniMax-H3 tags `0` (video).
+        references (`list[MiniMaxH3PreparedReference]`):
+            The references, in packed order, with their latent geometry already resolved.
+        num_latent_frames (`int`): Number of target latent frames.
+        latent_height (`int`): Target latent height.
+        latent_width (`int`): Target latent width.
+        num_audio_latents (`int`): Number of target audio latents per channel.
+        patch_size (`tuple[int, int, int]`): The transformer's `(t, h, w)` patch.
+
+    Returns:
+        [`MiniMaxH3PackedSequence`]
+    """
+    _, patch_h, patch_w = patch_size
+    num_text_tokens = text_token_tags.shape[0]
+    num_target_video_rows = num_latent_frames * (latent_height // patch_h) * (latent_width // patch_w)
+    num_target_audio_rows = num_audio_latents * MINIMAX_H3_AUDIO_CHANNELS
+    num_reference_video_rows = sum(reference.num_video_rows for reference in references if reference.kind != "audio")
+    num_reference_audio_rows = sum(reference.num_audio_rows for reference in references)
+    sequence_length = (
+        num_text_tokens
+        + num_reference_video_rows
+        + num_reference_audio_rows
+        + num_target_audio_rows
+        + num_target_video_rows
+    )
+
+    position_ids = torch.zeros(sequence_length, 3, dtype=torch.float64)
+    position_ids[:num_text_tokens, 0] = torch.arange(num_text_tokens, dtype=torch.float64)
+    target_frame_grid, target_width_grid = _frame_position_grid(latent_height, latent_width, patch_h, patch_w)
+
+    # Reference blocks, in request order. `rotary_time` is the shared audio/video clock: it starts where the text
+    # rows end and every block pushes it forward by the time that block occupies.
+    video_indices, audio_indices = [], []
+    cursor = num_text_tokens
+    rotary_time = float(num_text_tokens)
+    for reference in references:
+        if reference.kind == "image":
+            rows = slice(cursor, cursor + reference.num_video_rows)
+            cursor = rows.stop
+            video_indices.append(torch.arange(rows.start, rows.stop))
+            frame_grid, _ = _frame_position_grid(reference.latent_height, reference.latent_width, patch_h, patch_w)
+            position_ids[rows, 0] = rotary_time
+            position_ids[rows, 1:] = frame_grid
+            # An image is a single frame and takes a single integer rotary slot, not a latent frame's 5/3 units.
+            rotary_time += 1.0
+        elif reference.kind == "audio":
+            rows = slice(cursor, cursor + reference.num_audio_rows)
+            cursor = rows.stop
+            audio_indices.append(torch.arange(rows.start, rows.stop))
+            _fill_audio_positions(position_ids, rows, reference.num_audio_latents, rotary_time, target_width_grid)
+            rotary_time += float(reference.num_audio_latents)
+        elif reference.kind == "video":
+            # A video reference's soundtrack rows are packed immediately before its video rows and share their
+            # origin, so the two are rotary-aligned exactly as the generated audio and video are.
+            audio_rows = slice(cursor, cursor + reference.num_audio_rows)
+            video_rows = slice(audio_rows.stop, audio_rows.stop + reference.num_video_rows)
+            cursor = video_rows.stop
+            audio_indices.append(torch.arange(audio_rows.start, audio_rows.stop))
+            video_indices.append(torch.arange(video_rows.start, video_rows.stop))
+
+            frame_grid, width_grid = _frame_position_grid(
+                reference.latent_height, reference.latent_width, patch_h, patch_w
+            )
+            _fill_audio_positions(position_ids, audio_rows, reference.num_audio_latents, rotary_time, width_grid)
+            frame_time = _temporal_position_grid(reference.num_latent_frames, rotary_time)
+            position_ids[video_rows, 0] = frame_time.repeat_interleave(frame_grid.shape[0])
+            position_ids[video_rows, 1:] = frame_grid.repeat(reference.num_latent_frames, 1)
+            rotary_time += max(
+                float(reference.num_audio_latents), _temporal_position_span(reference.num_latent_frames)
+            )
+        else:
+            raise ValueError(f"A reference must be an 'image', a 'video' or an 'audio', got {reference.kind!r}.")
+
+    # The generated rows. Target audio and target video share the origin the reference blocks left behind.
+    audio_start = cursor
+    video_start = audio_start + num_target_audio_rows
+    _fill_audio_positions(
+        position_ids, slice(audio_start, video_start), num_audio_latents, rotary_time, target_width_grid
+    )
+    frame_time = _temporal_position_grid(num_latent_frames, rotary_time)
+    position_ids[video_start:, 0] = frame_time.repeat_interleave(target_frame_grid.shape[0])
+    position_ids[video_start:, 1:] = target_frame_grid.repeat(num_latent_frames, 1)
+
+    video_indices = torch.cat(video_indices + [torch.arange(video_start, sequence_length)])
+    audio_indices = torch.cat(audio_indices + [torch.arange(audio_start, video_start)])
+    text_indices = torch.arange(num_text_tokens)
+
+    token_tags = torch.empty(sequence_length, dtype=torch.long)
+    token_tags[text_indices] = text_token_tags.to(torch.long)
+    token_tags[audio_indices] = MINIMAX_H3_AUDIO_TAG
+    token_tags[video_indices] = MINIMAX_H3_VIDEO_TAG
+
+    return MiniMaxH3PackedSequence(
+        sequence_length=sequence_length,
+        position_ids=position_ids,
+        token_tags=token_tags,
+        video_indices=video_indices,
+        audio_indices=audio_indices,
+        text_indices=text_indices,
+        num_condition_video_rows=num_reference_video_rows,
+        num_condition_audio_rows=num_reference_audio_rows,
+    )
+
+
+def resolve_reference_image_size(width: int, height: int) -> tuple[int, int]:
+    r"""
+    Resolve the resolution a reference image is encoded at: a 2048 pixel short edge, both axes rounded to a multiple
+    of 32. Upscaling is intended, and unlike the target canvas there is no area cap.
+
+    Args:
+        width (`int`): Width of the source image.
+        height (`int`): Height of the source image.
+
+    Returns:
+        `tuple[int, int]`: the `(height, width)` the reference is resized to.
+    """
+    if width <= 0 or height <= 0:
+        raise ValueError(f"A reference image must have a positive size, got {width}x{height}.")
+    if width > 4 * height or height > 4 * width:
+        raise ValueError(f"A reference image must be within 1:4 and 4:1, got {width}x{height}.")
+
+    scale = MINIMAX_H3_REFERENCE_IMAGE_SHORT_EDGE / min(width, height)
+    multiple = MINIMAX_H3_CANVAS_MULTIPLE
+    return (
+        max(multiple, round(height * scale / multiple) * multiple),
+        max(multiple, round(width * scale / multiple) * multiple),
+    )
+
+
+def reference_media_to_uint8(media) -> np.ndarray:
+    r"""
+    An in-memory reference image or video as channels-last `uint8` RGB.
+
+    Args:
+        media (`PIL.Image.Image`, `np.ndarray`, `torch.Tensor` or `list`):
+            One image, one video, or a list of either. A `torch.Tensor` is channels-first, as everywhere else in
+            diffusers, and a `np.ndarray` channels-last; floating point values are read over `[0, 1]`.
+
+    Returns:
+        `np.ndarray`: the `uint8` RGB pixels, `(height, width, 3)` for a single image and `(num_frames, height, width,
+        3)` for a video or a list.
+    """
+    if isinstance(media, list):
+        return np.stack([reference_media_to_uint8(item) for item in media])
+    if isinstance(media, Image.Image):
+        return np.asarray(media.convert("RGB"))
+    if isinstance(media, torch.Tensor):
+        media = media.movedim(-3, -1).cpu().numpy()
+    media = np.asarray(media)
+    if media.dtype != np.uint8:
+        media = (media * 255.0).round().clip(0, 255).astype(np.uint8)
+    return media
+
+
+def prepare_reference_image(image, height: int, width: int):
+    r"""
+    Resize a reference image onto its own resolution with LANCZOS. An image that already is that size is returned
+    untouched, without a resampling pass.
+
+    Args:
+        image (`PIL.Image.Image`): The reference, in RGB and already EXIF-transposed.
+        height (`int`): Target height, as resolved by [`resolve_reference_image_size`].
+        width (`int`): Target width.
+
+    Returns:
+        `PIL.Image.Image`: The prepared reference.
+    """
+    if image.size == (width, height):
+        return image
+    return image.resize((width, height), Image.Resampling.LANCZOS)
+
+
+def resample_reference_frames(frames: np.ndarray, fps: float) -> np.ndarray:
+    r"""
+    Resample a reference video onto MiniMax-H3's own 24 fps, dropping and duplicating whole frames.
+
+    The reference implementation decoded every video reference through `ffmpeg`'s `fps` filter, a constant frame rate
+    resampler: every source frame lands on the output slot its timestamp rounds to, `round(index * 24 / fps)`, and a
+    slot holds the last frame that landed on it, so a frame whose successor lands on the same slot is dropped and a
+    frame whose successor skips slots is repeated. The end of the stream is rounded onto the grid the very same way,
+    which is what fixes the length at `round(num_frames * 24 / fps)` slots and decides whether the last frame is
+    repeated to reach it or dropped for overshooting it.
+
+    Reproducing that selection is what makes a constant frame rate reference give the very frames the reference's
+    decode gave, and it is an exact identity — the same array, no copy — for frames already at 24 fps.
+
+    Args:
+        frames (`np.ndarray` of shape `(num_frames, height, width, 3)`): The reference video, `uint8` RGB.
+        fps (`float`): The frame rate `frames` was decoded at.
+
+    Returns:
+        `np.ndarray`: the frames on MiniMax-H3's 24 fps grid, `frames` itself when they already are.
+    """
+    if fps <= 0:
+        raise ValueError(f"A reference video must have a positive frame rate, got {fps}.")
+    if fps == MINIMAX_H3_FPS:
+        return frames
+
+    scale = MINIMAX_H3_FPS / fps
+    slots = np.floor(np.arange(frames.shape[0]) * scale + 0.5).astype(np.int64)
+    # Every frame is held until the slot of the next one, and the last one until the slot the stream's end rounds to.
+    return np.repeat(frames, np.diff(slots, append=math.floor(frames.shape[0] * scale + 0.5)), axis=0)
+
+
+def prepare_reference_frames(frames: np.ndarray, num_frames: int) -> np.ndarray:
+    r"""
+    Put a reference video onto the canvas its own aspect ratio resolves to, and cap it at the generated frame count.
+
+    Frames that already are that canvas flow through untouched, with no resampling pass and no copy, and that is the
+    parity-exact route: the reference implementation rescaled the frames with `ffmpeg`'s own LANCZOS scaler while
+    decoding them, so only frames decoded at the canvas reproduce its pixels bit for bit. Any other size is resized
+    frame by frame with PIL, the very path [`prepare_reference_image`] takes.
+
+    Args:
+        frames (`np.ndarray` of shape `(num_frames, height, width, 3)`):
+            The reference video, `uint8` RGB at 24 fps, as returned by [`resample_reference_frames`].
+        num_frames (`int`): The frame count the reference is truncated to, i.e. the target's own frame count.
+
+    Returns:
+        `np.ndarray` of shape `(num_frames, height, width, 3)`: The prepared reference.
+    """
+    if frames.ndim != 4 or frames.shape[3] != 3:
+        raise ValueError(
+            f"A reference video must be `(num_frames, height, width, 3)` RGB frames, got {tuple(frames.shape)}."
+        )
+    frames = frames[:num_frames]
+    height, width = resolve_canvas_size(frames.shape[2], frames.shape[1])
+    if frames.shape[1:3] == (height, width):
+        return frames
+    return np.stack(
+        [np.asarray(Image.fromarray(frame).resize((width, height), Image.Resampling.LANCZOS)) for frame in frames]
+    )
+
+
+def sample_reference_video_frames(frames: np.ndarray) -> tuple[list[np.ndarray], list[float]]:
+    r"""
+    Sample the frames the conditioner sees from a prepared reference video, and label their vision blocks.
+
+    The conditioner reads a reference at 2 fps: every 12th of the 24 fps frames, deduplicated. Qwen3-VL then merges
+    the sampled frames in pairs — repeating the last one when there is an odd number of them — and a merged pair is
+    labelled with the mean of its two timestamps, which `"<{timestamp:.1f} seconds>"` renders with Python's
+    round-half-to-even, so the first block of a 2 fps pair is `"<0.2 seconds>"` rather than `"<0.3 seconds>"`.
+
+    Args:
+        frames (`np.ndarray` of shape `(num_frames, height, width, 3)`): The prepared reference video, at 24 fps.
+
+    Returns:
+        `tuple[list[np.ndarray], list[float]]`: the sampled frames and one timestamp per vision block.
+    """
+    stride = MINIMAX_H3_FPS / MINIMAX_H3_QWEN_VIDEO_SAMPLE_FPS
+    indices, cursor = [], 0.0
+    while round(cursor) < frames.shape[0]:
+        if not indices or round(cursor) > indices[-1]:
+            indices.append(round(cursor))
+        cursor += stride
+
+    timestamps = [index / MINIMAX_H3_QWEN_VIDEO_SAMPLE_FPS for index in range(len(indices))]
+    timestamps += [timestamps[-1]] * (-len(timestamps) % MINIMAX_H3_QWEN_TEMPORAL_PATCH)
+    block_timestamps = [
+        (timestamps[index] + timestamps[index + MINIMAX_H3_QWEN_TEMPORAL_PATCH - 1]) / 2
+        for index in range(0, len(timestamps), MINIMAX_H3_QWEN_TEMPORAL_PATCH)
+    ]
+    return [frames[index] for index in indices], block_timestamps
+
+
+def prepare_reference_waveform(
+    waveform: torch.Tensor, sample_rate: int, target_sample_rate: int, max_duration: float
+) -> torch.Tensor:
+    r"""
+    Put a reference soundtrack on the audio VAE's sample rate, as a stereo waveform.
+
+    The reference implementation extracts a soundtrack at a native rate, truncates it there and resamples it once, in
+    torch, which this mirrors: the truncation is applied at `sample_rate` and the resampling is a single `torchaudio`
+    pass. A mono waveform is upmixed by repeating its channel.
+
+    Args:
+        waveform (`torch.Tensor` of shape `(channels, num_samples)`): The soundtrack, mono or stereo.
+        sample_rate (`int`): The sample rate `waveform` carries its samples at.
+        target_sample_rate (`int`): The audio VAE's sample rate, i.e. what the waveform is resampled to.
+        max_duration (`float`): Truncate the reference to this many seconds.
+
+    Returns:
+        `torch.Tensor` of shape `(2, num_samples)`: the float32 waveform.
+    """
+    waveform = torch.as_tensor(waveform)
+    if waveform.ndim != 2 or waveform.shape[0] not in (1, MINIMAX_H3_AUDIO_CHANNELS):
+        raise ValueError(
+            "A reference soundtrack must be a `(channels, num_samples)` mono or stereo waveform, got "
+            f"{tuple(waveform.shape)}."
+        )
+    waveform = waveform.to(torch.float32)[:, : int(max_duration * sample_rate)]
+    if waveform.shape[0] != MINIMAX_H3_AUDIO_CHANNELS:
+        waveform = waveform.expand(MINIMAX_H3_AUDIO_CHANNELS, -1).contiguous()
+    if sample_rate == target_sample_rate:
+        return waveform
+
+    try:
+        import torchaudio
+    except ImportError as error:
+        raise ImportError(
+            f"Resampling a MiniMax-H3 reference soundtrack from {sample_rate} Hz to {target_sample_rate} Hz needs "
+            "`torchaudio`. Pass a waveform already at the audio VAE's sample rate to do without it."
+        ) from error
+    return torchaudio.transforms.Resample(sample_rate, target_sample_rate)(waveform)
+
+
+def build_ref2va_presentation(
+    tokenizer,
+    prompt: str,
+    references: list[MiniMaxH3PreparedReference],
+    image_token_counts: list[int],
+    video_block_token_counts: list[int],
+) -> tuple[list[int], list[int]]:
+    r"""
+    Tokenize MiniMax-H3's presentation of a `ref2va` request.
+
+    Every reference prepends a label, in packed order and numbered per modality: `"<Picture i>: "` plus a vision block
+    for an image, `"<Audio j>: "` alone for audio — a waveform never reaches the conditioner — and `"<Video k>: "`
+    plus one timestamped vision block per merged frame pair for a video. A video that carries sound is labelled
+    `"<Audio j>: "` *before* `"<Video k>: "`, mirroring the order its rows are packed in. The prompt follows verbatim,
+    with no chat template and no special tokens.
+
+    Args:
+        tokenizer (`Qwen2TokenizerFast`): Tokenizer of the conditioner.
+        prompt (`str`): The prompt, appended verbatim.
+        references (`list[MiniMaxH3PreparedReference]`): The prepared references, in packed order.
+        image_token_counts (`list[int]`): Number of vision tokens of every image reference's block.
+        video_block_token_counts (`list[int]`): Number of vision tokens per block of every video reference.
+
+    Returns:
+        `tuple[list[int], list[int]]`: the token ids and their modality tags. A vision block is tagged `0` (video) and
+        everything else `1` (text).
+    """
+
+    def text(value: str) -> tuple[list[int], list[int]]:
+        token_ids = tokenizer(value, add_special_tokens=False)["input_ids"]
+        return token_ids, [MINIMAX_H3_TEXT_TAG] * len(token_ids)
+
+    def vision(pad_token: str, num_tokens: int) -> tuple[list[int], list[int]]:
+        token_ids = (
+            [tokenizer.convert_tokens_to_ids("<|vision_start|>")]
+            + [tokenizer.convert_tokens_to_ids(pad_token)] * num_tokens
+            + [tokenizer.convert_tokens_to_ids("<|vision_end|>")]
+        )
+        return token_ids, [MINIMAX_H3_VIDEO_TAG] * len(token_ids)
+
+    token_ids, token_tags = [], []
+
+    def emit(segment: tuple[list[int], list[int]]) -> None:
+        token_ids.extend(segment[0])
+        token_tags.extend(segment[1])
+
+    counts = {"image": 0, "video": 0, "audio": 0}
+    for reference in references:
+        if reference.has_audio:
+            counts["audio"] += 1
+            emit(text(f"<Audio {counts['audio']}>: "))
+        if reference.kind == "image":
+            counts["image"] += 1
+            emit(text(f"<Picture {counts['image']}>: "))
+            emit(vision("<|image_pad|>", image_token_counts[counts["image"] - 1]))
+        elif reference.kind == "video":
+            counts["video"] += 1
+            emit(text(f"<Video {counts['video']}>: "))
+            for timestamp in reference.block_timestamps:
+                # `"{:.1f}"` rounds half to even, so the mean of a 2 fps pair renders as "<0.2 seconds>".
+                emit(text(f"<{timestamp:.1f} seconds>"))
+                emit(vision("<|video_pad|>", video_block_token_counts[counts["video"] - 1]))
+    emit(text(prompt))
+    return token_ids, token_tags
+
+
+def trim_reference_num_frames(num_frames: int) -> int:
+    r"""
+    Snap a reference video's frame count *down* to a `17 * n + 5` the video VAE encodes without padding.
+
+    A reference is truncated to the target's own frame count, which already is of that form, so this only bites when
+    the reference is shorter than the video being generated.
+
+    Args:
+        num_frames (`int`): The number of frames the reference carries.
+
+    Returns:
+        `int`: The number of frames to encode.
+    """
+    if num_frames < 1:
+        raise ValueError(f"A reference video must have at least one frame, got {num_frames}.")
+    return (
+        max(1, (num_frames - MINIMAX_H3_LATENTS_PER_CHUNK) // MINIMAX_H3_FRAMES_PER_CHUNK)
+        * MINIMAX_H3_FRAMES_PER_CHUNK
+        + MINIMAX_H3_LATENTS_PER_CHUNK
+    )
diff --git a/src/diffusers/modular_pipelines/modular_pipeline.py b/src/diffusers/modular_pipelines/modular_pipeline.py
index fe0448acbde6..45d98775708b 100644
--- a/src/diffusers/modular_pipelines/modular_pipeline.py
+++ b/src/diffusers/modular_pipelines/modular_pipeline.py
@@ -149,6 +149,8 @@ def _helios_pyramid_map_fn(config_dict=None):
         ("helios-pyramid", _helios_pyramid_map_fn),
         ("hunyuan-video-1.5", _create_default_map_fn("HunyuanVideo15ModularPipeline")),
         ("ltx", _create_default_map_fn("LTXModularPipeline")),
+        ("minimax-h3", _create_default_map_fn("MiniMaxH3ModularPipeline")),
+        ("minimax-h3-ref2va", _create_default_map_fn("MiniMaxH3Ref2VAModularPipeline")),
         ("ernie-image", _create_default_map_fn("ErnieImageModularPipeline")),
     ]
 )
diff --git a/src/diffusers/schedulers/__init__.py b/src/diffusers/schedulers/__init__.py
index 9b54c669293c..c0e46ef445df 100644
--- a/src/diffusers/schedulers/__init__.py
+++ b/src/diffusers/schedulers/__init__.py
@@ -72,6 +72,7 @@
     _import_structure["scheduling_k_dpm_2_discrete"] = ["KDPM2DiscreteScheduler"]
     _import_structure["scheduling_lcm"] = ["LCMScheduler"]
     _import_structure["scheduling_ltx_euler_ancestral_rf"] = ["LTXEulerAncestralRFScheduler"]
+    _import_structure["scheduling_minimax_h3"] = ["MiniMaxH3Scheduler"]
     _import_structure["scheduling_pndm"] = ["PNDMScheduler"]
     _import_structure["scheduling_repaint"] = ["RePaintScheduler"]
     _import_structure["scheduling_sasolver"] = ["SASolverScheduler"]
@@ -155,6 +156,7 @@
         from .scheduling_k_dpm_2_discrete import KDPM2DiscreteScheduler
         from .scheduling_lcm import LCMScheduler
         from .scheduling_ltx_euler_ancestral_rf import LTXEulerAncestralRFScheduler
+        from .scheduling_minimax_h3 import MiniMaxH3Scheduler
         from .scheduling_pndm import PNDMScheduler
         from .scheduling_repaint import RePaintScheduler
         from .scheduling_sasolver import SASolverScheduler
diff --git a/src/diffusers/schedulers/scheduling_minimax_h3.py b/src/diffusers/schedulers/scheduling_minimax_h3.py
new file mode 100644
index 000000000000..db3217060c15
--- /dev/null
+++ b/src/diffusers/schedulers/scheduling_minimax_h3.py
@@ -0,0 +1,288 @@
+# Copyright 2025 The MiniMax authors and The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Rectified-flow Euler scheduler for MiniMax-H3.
+
+Three things make this incompatible with a [`FlowMatchEulerDiscreteScheduler`] config, which is why
+it is a separate class:
+
+1. **The velocity sign is reversed.** MiniMax-H3's transformer predicts a *data-ward* velocity, so
+   `x0 = x_t + sigma * v` instead of diffusers' `x0 = x_t - sigma * v`.
+2. **Timesteps are `t = 1 - sigma` in `[0, 1]`**, with `t = 1` meaning *clean*. Flow-match
+   schedulers expose `timesteps = sigma * num_train_timesteps`, i.e. the opposite direction on a
+   1000x scale. The transformer's AdaLN consumes the H3 convention directly.
+3. **The sigma grid starts from `linspace(1, 0, num_inference_steps)`** — the terminal zero is part
+   of the requested step count, and duplicates created by the shift are collapsed with
+   `unique_consecutive`. `FlowMatchEulerDiscreteScheduler` instead builds
+   `linspace(1, 1/num_train_timesteps, ...)` and appends a terminal sigma afterwards, so
+   `len(sigmas)` and every interior value differ.
+
+Everything else is ordinary rectified flow: the exponential shift `sigma' = s*sigma / (1 + (s-1)*sigma)`,
+and an Euler update written as the `x_t` / `x0` blend `x_next = r*x_t + (1 - r)*x0` with
+`r = sigma_next / sigma`, evaluated in float32. Despite the reference class being named
+"euler ancestral", `eta` is 0 — no noise is ever re-injected.
+
+MiniMax-H3 runs **two schedules per request**, one per modality (`shift=12.0` for video,
+`shift=3.0` for audio). The modality is not a property of the scheduler: a pipeline holds two
+instances, e.g. `scheduler` and `audio_scheduler`.
+"""
+
+from dataclasses import dataclass
+
+import torch
+
+from ..configuration_utils import ConfigMixin, register_to_config
+from ..utils import BaseOutput
+from .scheduling_utils import SchedulerMixin
+
+
+@dataclass
+class MiniMaxH3SchedulerOutput(BaseOutput):
+    """
+    Output class for the scheduler's `step` function output.
+
+    Args:
+        prev_sample (`torch.FloatTensor`):
+            Computed sample `x_{t+1}` for the next step of the denoising loop.
+    """
+
+    prev_sample: torch.FloatTensor
+
+
+class MiniMaxH3Scheduler(SchedulerMixin, ConfigMixin):
+    r"""
+    Rectified-flow Euler scheduler (`eta = 0`) with an exponential sigma shift, as used by MiniMax-H3.
+
+    Args:
+        shift (`float`, defaults to `12.0`):
+            Exponential shift applied to the sigma grid, `sigma' = s*sigma / (1 + (s-1)*sigma)`. The
+            released checkpoints use `12.0` for video latents and `3.0` for audio latents.
+    """
+
+    _compatibles = []
+    order = 1
+
+    @register_to_config
+    def __init__(self, shift: float = 12.0):
+        if shift <= 0:
+            raise ValueError(f"`shift` must be positive, got {shift}.")
+
+        self.num_inference_steps: int | None = None
+        self.sigmas: torch.Tensor | None = None
+        self.timesteps: torch.Tensor | None = None
+        self._shift = float(shift)
+        self._step_index: int | None = None
+        self._begin_index: int | None = None
+
+    @property
+    def shift(self) -> float:
+        """The exponential shift currently applied to the sigma grid."""
+        return self._shift
+
+    @property
+    def step_index(self) -> int | None:
+        """Index of the step the scheduler is about to take. Increases by one after each `step`."""
+        return self._step_index
+
+    @property
+    def begin_index(self) -> int | None:
+        """Index of the first step, set from a pipeline through [`~MiniMaxH3Scheduler.set_begin_index`]."""
+        return self._begin_index
+
+    def set_begin_index(self, begin_index: int = 0) -> None:
+        """
+        Sets the begin index for the scheduler.
+
+        Args:
+            begin_index (`int`, defaults to `0`):
+                The begin index for the scheduler.
+        """
+        self._begin_index = begin_index
+
+    def set_shift(self, shift: float) -> None:
+        """
+        Overrides the configured sigma shift; call before [`~MiniMaxH3Scheduler.set_timesteps`].
+
+        MiniMax-H3 exposes this per request as `flow_shift` (video) / `audio_flow_shift` (audio).
+
+        Args:
+            shift (`float`):
+                The exponential shift to use for the next schedule.
+        """
+        if shift <= 0:
+            raise ValueError(f"`shift` must be positive, got {shift}.")
+        self._shift = float(shift)
+
+    def set_timesteps(
+        self,
+        num_inference_steps: int | None = None,
+        device: str | torch.device | None = None,
+        sigmas: list[float] | torch.Tensor | None = None,
+    ) -> None:
+        r"""
+        Build the sigma / timestep schedule.
+
+        The grid is `linspace(1, 0, num_inference_steps)` pushed through the exponential shift, with
+        consecutive duplicates collapsed. The terminal `0` is already part of that grid — the shift maps
+        `0` to exactly `0` — so the schedule holds `num_inference_steps` sigmas and drives
+        `num_inference_steps - 1` model evaluations, exposed as `self.timesteps = 1 - sigmas[:-1]`.
+
+        Args:
+            num_inference_steps (`int`, *optional*):
+                Number of sigma grid points, terminal `0` included. Ignored when `sigmas` is given.
+            device (`str` or `torch.device`, *optional*):
+                Device the schedule tensors are moved to. The grid itself is always built on CPU in
+                float32 so the schedule does not depend on the accelerator.
+            sigmas (`list[float]` or `torch.Tensor`, *optional*):
+                A fully-formed sigma schedule, used verbatim (no shifting, no deduplication). It must be
+                strictly decreasing and terminate at `0.0`.
+        """
+        if sigmas is None:
+            if num_inference_steps is None or num_inference_steps < 2:
+                raise ValueError(
+                    "`set_timesteps` requires either an explicit `sigmas` schedule or "
+                    f"`num_inference_steps` >= 2, got {num_inference_steps}."
+                )
+
+            # The rectified-flow sigma range is fixed at [1.0, 0.0].
+            base = torch.linspace(1.0, 0.0, int(num_inference_steps), dtype=torch.float32)
+            sigmas = self._shift * base / (1 + (self._shift - 1) * base)
+            # The shift compresses the grid near sigma = 1; collapse any float32 collisions it creates.
+            sigmas = torch.unique_consecutive(sigmas)
+        else:
+            sigmas = torch.as_tensor(sigmas, dtype=torch.float32).flatten().cpu()
+            if sigmas.numel() < 2 or not bool((sigmas[1:] < sigmas[:-1]).all()) or sigmas[-1].item() != 0.0:
+                raise ValueError("`sigmas` must hold at least two strictly decreasing values ending at 0.0.")
+
+        self.sigmas = sigmas.to(device=device)
+        # t = 1 - sigma, and t = 1 is clean. The terminal sigma has no model evaluation.
+        self.timesteps = (1.0 - sigmas[:-1]).to(device=device)
+        self.num_inference_steps = int(self.timesteps.numel())
+        self._step_index = None
+        self._begin_index = None
+
+    def index_for_timestep(self, timestep: float | torch.Tensor) -> int:
+        """
+        Map a timestep value to its index in the schedule.
+
+        Args:
+            timestep (`float` or `torch.Tensor`):
+                A value taken from `self.timesteps`. The schedule is strictly increasing in `t`, so the
+                match is unique.
+
+        Returns:
+            `int`: The index of `timestep`.
+        """
+        if isinstance(timestep, torch.Tensor):
+            timestep = timestep.to(self.timesteps.device)
+        indices = (self.timesteps == timestep).nonzero()
+        if len(indices) == 0:
+            raise ValueError(
+                "Passed `timestep` is not in `self.timesteps`. Make sure to use values from `scheduler.timesteps`."
+            )
+        return indices[0].item()
+
+    def scale_noise(
+        self,
+        sample: torch.FloatTensor,
+        timestep: float | torch.FloatTensor,
+        noise: torch.FloatTensor,
+    ) -> torch.FloatTensor:
+        r"""
+        Rectified-flow forward process, in MiniMax-H3's `t` convention: `x_t = t*x_0 + (1 - t)*noise`.
+
+        MiniMax-H3 uses this to noise its conditioning anchors, where `t` is the `noise_aug` level
+        rather than a schedule entry, so `timestep` is taken at face value and is *not* looked up in
+        `self.timesteps`.
+
+        Args:
+            sample (`torch.FloatTensor`):
+                The clean sample `x_0`.
+            timestep (`float` or `torch.FloatTensor`):
+                The target time in `[0, 1]`; `1` returns `sample` unchanged.
+            noise (`torch.FloatTensor`):
+                The noise to mix in.
+
+        Returns:
+            `torch.FloatTensor`: The noised sample.
+        """
+        if not isinstance(timestep, torch.Tensor):
+            timestep = torch.tensor(timestep, dtype=sample.dtype, device=sample.device)
+        timestep = timestep.to(device=sample.device, dtype=sample.dtype)
+        while timestep.ndim < sample.ndim:
+            timestep = timestep.unsqueeze(-1)
+        return timestep * sample + (1.0 - timestep) * noise
+
+    def step(
+        self,
+        model_output: torch.FloatTensor,
+        timestep: float | torch.FloatTensor,
+        sample: torch.FloatTensor,
+        return_dict: bool = True,
+    ) -> MiniMaxH3SchedulerOutput | tuple:
+        r"""
+        Take one Euler (`eta = 0`) step.
+
+        The model output is a data-ward velocity, so the denoised estimate is
+        `x0 = x_t + (1 - t) * v` — note the `+`, the opposite of the usual flow-match convention.
+        The update is then the blend `x_next = r*x_t + (1 - r)*x0` with `r = sigma_next / sigma`,
+        evaluated in float32 for half-precision samples.
+
+        Args:
+            model_output (`torch.FloatTensor`):
+                The transformer's velocity prediction at `timestep`.
+            timestep (`float` or `torch.FloatTensor`):
+                The current timestep, one of `self.timesteps` (so `timestep == 1 - sigma`).
+            sample (`torch.FloatTensor`):
+                The current sample `x_t`.
+            return_dict (`bool`, defaults to `True`):
+                Whether to return a [`MiniMaxH3SchedulerOutput`] instead of a plain tuple.
+
+        Returns:
+            [`MiniMaxH3SchedulerOutput`] or `tuple`: the sample for the next step.
+        """
+        if isinstance(timestep, int) or (isinstance(timestep, torch.Tensor) and not timestep.is_floating_point()):
+            raise ValueError(
+                "Passing integer indices (e.g. from `enumerate(timesteps)`) as timesteps to"
+                " `MiniMaxH3Scheduler.step()` is not supported. Make sure to pass one of the"
+                " `scheduler.timesteps` values."
+            )
+
+        if self._step_index is None:
+            self._step_index = self.index_for_timestep(timestep) if self._begin_index is None else self._begin_index
+
+        # x0 from the data-ward velocity. The sigma used here is recovered from the *timestep* the
+        # transformer was conditioned on, whereas the Euler ratio below uses the sigma grid: for
+        # sigma < 0.5 the float32 round trip `1 - (1 - sigma)` is not exact, and the reference keeps
+        # the two sources apart.
+        if not isinstance(timestep, torch.Tensor):
+            timestep = torch.tensor(timestep, dtype=sample.dtype)
+        sigma_from_timestep = 1 - timestep.to(device=sample.device, dtype=sample.dtype)
+        while sigma_from_timestep.ndim < sample.ndim:
+            sigma_from_timestep = sigma_from_timestep.unsqueeze(-1)
+        denoised = sample + sigma_from_timestep * model_output
+
+        # Euler with eta = 0, written as an x_t / x0 blend and evaluated in float32.
+        compute_dtype = torch.float32 if sample.dtype in (torch.float16, torch.bfloat16) else sample.dtype
+        sigma = self.sigmas[self._step_index].to(device=sample.device, dtype=compute_dtype)
+        sigma_next = self.sigmas[self._step_index + 1].to(device=sample.device, dtype=compute_dtype)
+        ratio = sigma_next / sigma
+        prev_sample = ratio * sample.to(dtype=compute_dtype) + (1.0 - ratio) * denoised.to(dtype=compute_dtype)
+        prev_sample = prev_sample.to(dtype=sample.dtype)
+
+        self._step_index += 1
+
+        if not return_dict:
+            return (prev_sample,)
+        return MiniMaxH3SchedulerOutput(prev_sample=prev_sample)
diff --git a/src/diffusers/utils/dummy_pt_objects.py b/src/diffusers/utils/dummy_pt_objects.py
index 9035efb3e6e2..f7a8b6ec9de7 100644
--- a/src/diffusers/utils/dummy_pt_objects.py
+++ b/src/diffusers/utils/dummy_pt_objects.py
@@ -765,6 +765,36 @@ def from_pretrained(cls, *args, **kwargs):
         requires_backends(cls, ["torch"])
 
 
+class AutoencoderKLMiniMaxH3(metaclass=DummyObject):
+    _backends = ["torch"]
+
+    def __init__(self, *args, **kwargs):
+        requires_backends(self, ["torch"])
+
+    @classmethod
+    def from_config(cls, *args, **kwargs):
+        requires_backends(cls, ["torch"])
+
+    @classmethod
+    def from_pretrained(cls, *args, **kwargs):
+        requires_backends(cls, ["torch"])
+
+
+class AutoencoderKLMiniMaxH3Audio(metaclass=DummyObject):
+    _backends = ["torch"]
+
+    def __init__(self, *args, **kwargs):
+        requires_backends(self, ["torch"])
+
+    @classmethod
+    def from_config(cls, *args, **kwargs):
+        requires_backends(cls, ["torch"])
+
+    @classmethod
+    def from_pretrained(cls, *args, **kwargs):
+        requires_backends(cls, ["torch"])
+
+
 class AutoencoderKLMochi(metaclass=DummyObject):
     _backends = ["torch"]
 
@@ -1680,6 +1710,21 @@ def from_pretrained(cls, *args, **kwargs):
         requires_backends(cls, ["torch"])
 
 
+class MiniMaxH3Transformer3DModel(metaclass=DummyObject):
+    _backends = ["torch"]
+
+    def __init__(self, *args, **kwargs):
+        requires_backends(self, ["torch"])
+
+    @classmethod
+    def from_config(cls, *args, **kwargs):
+        requires_backends(cls, ["torch"])
+
+    @classmethod
+    def from_pretrained(cls, *args, **kwargs):
+        requires_backends(cls, ["torch"])
+
+
 class MochiTransformer3DModel(metaclass=DummyObject):
     _backends = ["torch"]
 
@@ -3422,6 +3467,21 @@ def from_pretrained(cls, *args, **kwargs):
         requires_backends(cls, ["torch"])
 
 
+class MiniMaxH3Scheduler(metaclass=DummyObject):
+    _backends = ["torch"]
+
+    def __init__(self, *args, **kwargs):
+        requires_backends(self, ["torch"])
+
+    @classmethod
+    def from_config(cls, *args, **kwargs):
+        requires_backends(cls, ["torch"])
+
+    @classmethod
+    def from_pretrained(cls, *args, **kwargs):
+        requires_backends(cls, ["torch"])
+
+
 class PNDMScheduler(metaclass=DummyObject):
     _backends = ["torch"]
 
diff --git a/src/diffusers/utils/dummy_torch_and_transformers_objects.py b/src/diffusers/utils/dummy_torch_and_transformers_objects.py
index 417aa9ad18ff..d5abf9efa891 100644
--- a/src/diffusers/utils/dummy_torch_and_transformers_objects.py
+++ b/src/diffusers/utils/dummy_torch_and_transformers_objects.py
@@ -512,6 +512,66 @@ def from_pretrained(cls, *args, **kwargs):
         requires_backends(cls, ["torch", "transformers"])
 
 
+class MiniMaxH3Blocks(metaclass=DummyObject):
+    _backends = ["torch", "transformers"]
+
+    def __init__(self, *args, **kwargs):
+        requires_backends(self, ["torch", "transformers"])
+
+    @classmethod
+    def from_config(cls, *args, **kwargs):
+        requires_backends(cls, ["torch", "transformers"])
+
+    @classmethod
+    def from_pretrained(cls, *args, **kwargs):
+        requires_backends(cls, ["torch", "transformers"])
+
+
+class MiniMaxH3ModularPipeline(metaclass=DummyObject):
+    _backends = ["torch", "transformers"]
+
+    def __init__(self, *args, **kwargs):
+        requires_backends(self, ["torch", "transformers"])
+
+    @classmethod
+    def from_config(cls, *args, **kwargs):
+        requires_backends(cls, ["torch", "transformers"])
+
+    @classmethod
+    def from_pretrained(cls, *args, **kwargs):
+        requires_backends(cls, ["torch", "transformers"])
+
+
+class MiniMaxH3Ref2VABlocks(metaclass=DummyObject):
+    _backends = ["torch", "transformers"]
+
+    def __init__(self, *args, **kwargs):
+        requires_backends(self, ["torch", "transformers"])
+
+    @classmethod
+    def from_config(cls, *args, **kwargs):
+        requires_backends(cls, ["torch", "transformers"])
+
+    @classmethod
+    def from_pretrained(cls, *args, **kwargs):
+        requires_backends(cls, ["torch", "transformers"])
+
+
+class MiniMaxH3Ref2VAModularPipeline(metaclass=DummyObject):
+    _backends = ["torch", "transformers"]
+
+    def __init__(self, *args, **kwargs):
+        requires_backends(self, ["torch", "transformers"])
+
+    @classmethod
+    def from_config(cls, *args, **kwargs):
+        requires_backends(cls, ["torch", "transformers"])
+
+    @classmethod
+    def from_pretrained(cls, *args, **kwargs):
+        requires_backends(cls, ["torch", "transformers"])
+
+
 class QwenImageAutoBlocks(metaclass=DummyObject):
     _backends = ["torch", "transformers"]
 
diff --git a/tests/models/autoencoders/test_models_autoencoder_kl_minimax_h3.py b/tests/models/autoencoders/test_models_autoencoder_kl_minimax_h3.py
new file mode 100644
index 000000000000..cb6c4ebb12df
--- /dev/null
+++ b/tests/models/autoencoders/test_models_autoencoder_kl_minimax_h3.py
@@ -0,0 +1,156 @@
+# coding=utf-8
+# Copyright 2026 HuggingFace Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pytest
+import torch
+
+from diffusers import AutoencoderKLMiniMaxH3
+from diffusers.utils.torch_utils import randn_tensor
+
+from ...testing_utils import enable_full_determinism, torch_device
+from ..testing_utils import (
+    AttentionTesterMixin,
+    BaseModelTesterConfig,
+    MemoryTesterMixin,
+    ModelTesterMixin,
+    TorchCompileTesterMixin,
+    TrainingTesterMixin,
+)
+from .testing_utils import NewAutoencoderTesterMixin
+
+
+enable_full_determinism()
+
+
+# The temporal geometry is fixed by the released `clip_length` / `token_drop` pair: `17 * n + 5` pixel frames map to
+# `5 * n + 2` latent frames, so 22 frames is the shortest video this autoencoder can round-trip.
+NUM_FRAMES = 22
+HEIGHT = WIDTH = 8
+
+
+class AutoencoderKLMiniMaxH3TesterConfig(BaseModelTesterConfig):
+    @property
+    def model_class(self):
+        return AutoencoderKLMiniMaxH3
+
+    @property
+    def main_input_name(self) -> str:
+        return "sample"
+
+    @property
+    def input_shape(self) -> tuple[int, ...]:
+        return (3, NUM_FRAMES, HEIGHT, WIDTH)
+
+    @property
+    def output_shape(self) -> tuple[int, ...]:
+        return (3, NUM_FRAMES, HEIGHT, WIDTH)
+
+    @property
+    def generator(self):
+        return torch.Generator("cpu").manual_seed(0)
+
+    def get_init_dict(self) -> dict:
+        # `clip_length` and `token_drop` are left at their released values, so the temporal chunking the decoder
+        # re-derives from them (`frame_pre_padding`, `token_overlap`, `frame_overlap`) is the real one; so is
+        # `decoder_rope_dim_ratio`, which keeps the partial-rotary path of the ViT decoder in play.
+        return {
+            "in_channels": 3,
+            "out_channels": 3,
+            "latent_channels": 4,
+            "block_out_channels": (8, 16),
+            "layers_per_block": 1,
+            "spatial_downsample_factors": (2, 2),
+            "temporal_downsample_factors": (2, 2),
+            "norm_num_groups": 8,
+            "decoder_num_layers": 2,
+            "decoder_num_attention_heads": 2,
+            "decoder_attention_head_dim": 8,
+            "decoder_num_register_tokens": 2,
+            "decoder_ffn_mult": 2,
+            "clip_length": 17,
+            "token_drop": 3,
+            "latents_mean": (0.0,) * 4,
+            "latents_std": (1.0,) * 4,
+        }
+
+    def get_dummy_inputs(self) -> dict:
+        return {
+            "sample": randn_tensor((2, 3, NUM_FRAMES, HEIGHT, WIDTH), generator=self.generator, device=torch_device),
+        }
+
+
+class TestAutoencoderKLMiniMaxH3(AutoencoderKLMiniMaxH3TesterConfig, ModelTesterMixin):
+    """Core model tests for the MiniMax-H3 video autoencoder."""
+
+    @pytest.mark.parametrize("dtype", [torch.float16, torch.bfloat16], ids=["fp16", "bf16"])
+    def test_from_save_pretrained_dtype(self, tmp_path, dtype):
+        # `_keep_in_fp32_modules` pins every module: the released checkpoint is float32 and decoding through
+        # downcast weights degrades (the bfloat16 audio VAE decodes roughly 20 dB too quiet), so a requested
+        # `torch_dtype` cast at load time must be refused and the weights must stay float32.
+        model = self.model_class(**self.get_init_dict())
+        model.save_pretrained(tmp_path)
+        new_model = self.model_class.from_pretrained(tmp_path, torch_dtype=dtype)
+        assert new_model.dtype == torch.float32
+
+    @pytest.mark.parametrize("dtype", [torch.float16, torch.bfloat16], ids=["fp16", "bf16"])
+    def test_from_pretrained_dtype_alias(self, tmp_path, dtype):
+        # Same contract through the `dtype` alias.
+        model = self.model_class(**self.get_init_dict())
+        model.save_pretrained(tmp_path)
+        new_model = self.model_class.from_pretrained(tmp_path, dtype=dtype)
+        assert new_model.dtype == torch.float32
+
+    def test_encode_decode_temporal_geometry(self):
+        r"""
+        `17 * n + 5` pixel frames encode to `5 * n + 2` latent frames and decode back to the original length.
+
+        The encoder pads up to a whole number of `clip_length` chunks and drops `token_drop` latent frames per
+        encode, and the decoder cross-fades the resulting overlap back together, so the round trip only recovers the
+        requested frame count if both halves agree on that geometry.
+        """
+        model = self.model_class(**self.get_init_dict()).to(torch_device).eval()
+        sample = self.get_dummy_inputs()["sample"]
+
+        with torch.no_grad():
+            latents = model.encode(sample, return_dict=False)[0].mode()
+            decoded = model.decode(latents, return_dict=False)[0]
+
+        assert latents.shape == (2, 4, 7, HEIGHT // 4, WIDTH // 4)
+        assert decoded.shape == sample.shape
+
+
+class TestAutoencoderKLMiniMaxH3Memory(AutoencoderKLMiniMaxH3TesterConfig, MemoryTesterMixin):
+    """Memory optimization tests for the MiniMax-H3 video autoencoder."""
+
+
+class TestAutoencoderKLMiniMaxH3Training(AutoencoderKLMiniMaxH3TesterConfig, TrainingTesterMixin):
+    """Training tests for the MiniMax-H3 video autoencoder."""
+
+    def test_gradient_checkpointing_is_applied(self):
+        super().test_gradient_checkpointing_is_applied(
+            expected_set={"MiniMaxH3VideoDownBlock3d", "MiniMaxH3VideoViTDecoder3d"}
+        )
+
+
+class TestAutoencoderKLMiniMaxH3Attention(AutoencoderKLMiniMaxH3TesterConfig, AttentionTesterMixin):
+    """Attention processor tests for the MiniMax-H3 video autoencoder."""
+
+
+class TestAutoencoderKLMiniMaxH3TorchCompile(AutoencoderKLMiniMaxH3TesterConfig, TorchCompileTesterMixin):
+    """Torch compile tests for the MiniMax-H3 video autoencoder."""
+
+
+class TestAutoencoderKLMiniMaxH3SlicingTiling(AutoencoderKLMiniMaxH3TesterConfig, NewAutoencoderTesterMixin):
+    """Slicing and tiling tests for the MiniMax-H3 video autoencoder."""
diff --git a/tests/models/autoencoders/test_models_autoencoder_kl_minimax_h3_audio.py b/tests/models/autoencoders/test_models_autoencoder_kl_minimax_h3_audio.py
new file mode 100644
index 000000000000..676cae58d335
--- /dev/null
+++ b/tests/models/autoencoders/test_models_autoencoder_kl_minimax_h3_audio.py
@@ -0,0 +1,150 @@
+# coding=utf-8
+# Copyright 2026 HuggingFace Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pytest
+import torch
+
+from diffusers import AutoencoderKLMiniMaxH3Audio
+from diffusers.utils.torch_utils import randn_tensor
+
+from ...testing_utils import enable_full_determinism, torch_device
+from ..testing_utils import (
+    AttentionTesterMixin,
+    BaseModelTesterConfig,
+    MemoryTesterMixin,
+    ModelTesterMixin,
+    TorchCompileTesterMixin,
+    TrainingTesterMixin,
+)
+
+
+enable_full_determinism()
+
+
+# `prod(encoder_rates)` is the hop length, so a waveform of `HOP_LENGTH * NUM_LATENTS` samples encodes to
+# `NUM_LATENTS` latents. MiniMax-H3 carries stereo as two batch items of this mono autoencoder.
+HOP_LENGTH = 4
+NUM_LATENTS = 8
+BATCH_SIZE = 2
+
+
+class AutoencoderKLMiniMaxH3AudioTesterConfig(BaseModelTesterConfig):
+    @property
+    def model_class(self):
+        return AutoencoderKLMiniMaxH3Audio
+
+    @property
+    def main_input_name(self) -> str:
+        return "sample"
+
+    @property
+    def input_shape(self) -> tuple[int, ...]:
+        return (1, HOP_LENGTH * NUM_LATENTS)
+
+    @property
+    def output_shape(self) -> tuple[int, ...]:
+        return (1, HOP_LENGTH * NUM_LATENTS)
+
+    @property
+    def generator(self):
+        return torch.Generator("cpu").manual_seed(0)
+
+    def get_init_dict(self) -> dict:
+        # `latent_dim // num_attention_heads` (16) is kept different from `latent_channels` (8), as it is at full
+        # scale, so the adaptive-average-pool branch of the causal-attention projection is exercised.
+        return {
+            "encoder_dim": 4,
+            "encoder_rates": (2, 2),
+            "latent_dim": 32,
+            "latent_channels": 8,
+            "num_attention_heads": 2,
+            "decoder_dim": 16,
+            "decoder_rates": (2, 2),
+            "decoder_kernel_sizes": (4, 4),
+            "resblock_kernel_sizes": (3, 7),
+            "resblock_dilation_sizes": ((1, 3), (1, 3)),
+            "sampling_rate": 32000,
+            "latents_mean": [0.0] * 8,
+            "latents_std": [1.0] * 8,
+        }
+
+    def get_dummy_inputs(self) -> dict:
+        return {
+            "sample": randn_tensor(
+                (BATCH_SIZE, 1, HOP_LENGTH * NUM_LATENTS), generator=self.generator, device=torch_device
+            ),
+        }
+
+
+class TestAutoencoderKLMiniMaxH3Audio(AutoencoderKLMiniMaxH3AudioTesterConfig, ModelTesterMixin):
+    """Core model tests for the MiniMax-H3 audio autoencoder."""
+
+    @pytest.mark.parametrize("dtype", [torch.float16, torch.bfloat16], ids=["fp16", "bf16"])
+    def test_from_save_pretrained_dtype(self, tmp_path, dtype):
+        # `_keep_in_fp32_modules` pins every module: the released checkpoint is float32 and decoding through
+        # downcast weights degrades (the bfloat16 audio VAE decodes roughly 20 dB too quiet), so a requested
+        # `torch_dtype` cast at load time must be refused and the weights must stay float32.
+        model = self.model_class(**self.get_init_dict())
+        model.save_pretrained(tmp_path)
+        new_model = self.model_class.from_pretrained(tmp_path, torch_dtype=dtype)
+        assert new_model.dtype == torch.float32
+
+    @pytest.mark.parametrize("dtype", [torch.float16, torch.bfloat16], ids=["fp16", "bf16"])
+    def test_from_pretrained_dtype_alias(self, tmp_path, dtype):
+        # Same contract through the `dtype` alias.
+        model = self.model_class(**self.get_init_dict())
+        model.save_pretrained(tmp_path)
+        new_model = self.model_class.from_pretrained(tmp_path, dtype=dtype)
+        assert new_model.dtype == torch.float32
+
+    def test_encode_pads_to_the_hop_length(self):
+        r"""
+        A waveform that is not a whole number of hops is right-padded rather than rejected, and decoding always
+        returns `num_frames * hop_length` samples.
+        """
+        model = self.model_class(**self.get_init_dict()).to(torch_device).eval()
+        unaligned = randn_tensor(
+            (BATCH_SIZE, 1, HOP_LENGTH * NUM_LATENTS + 1), generator=self.generator, device=torch_device
+        )
+
+        with torch.no_grad():
+            latents = model.encode(unaligned, return_dict=False)[0].mode()
+            decoded = model.decode(latents, return_dict=False)[0]
+
+        assert latents.shape == (BATCH_SIZE, 8, NUM_LATENTS + 1)
+        assert decoded.shape == (BATCH_SIZE, 1, (NUM_LATENTS + 1) * HOP_LENGTH)
+
+
+class TestAutoencoderKLMiniMaxH3AudioMemory(AutoencoderKLMiniMaxH3AudioTesterConfig, MemoryTesterMixin):
+    """Memory optimization tests for the MiniMax-H3 audio autoencoder."""
+
+
+class TestAutoencoderKLMiniMaxH3AudioTraining(AutoencoderKLMiniMaxH3AudioTesterConfig, TrainingTesterMixin):
+    """Training tests for the MiniMax-H3 audio autoencoder."""
+
+
+class TestAutoencoderKLMiniMaxH3AudioAttention(AutoencoderKLMiniMaxH3AudioTesterConfig, AttentionTesterMixin):
+    """Attention processor tests for the MiniMax-H3 audio autoencoder."""
+
+    @pytest.mark.skip(
+        "The audio autoencoder holds exactly one attention module (the `pre_block` latent projection), so a dict of "
+        "processors can never have a length that mismatches the number of attention layers."
+    )
+    def test_attention_processor_count_mismatch_raises_error(self):
+        pass
+
+
+class TestAutoencoderKLMiniMaxH3AudioTorchCompile(AutoencoderKLMiniMaxH3AudioTesterConfig, TorchCompileTesterMixin):
+    """Torch compile tests for the MiniMax-H3 audio autoencoder."""
diff --git a/tests/models/transformers/test_models_transformer_minimax_h3.py b/tests/models/transformers/test_models_transformer_minimax_h3.py
new file mode 100644
index 000000000000..f7a5b1d6f65d
--- /dev/null
+++ b/tests/models/transformers/test_models_transformer_minimax_h3.py
@@ -0,0 +1,239 @@
+# coding=utf-8
+# Copyright 2026 HuggingFace Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pytest
+import torch
+
+from diffusers import MiniMaxH3Transformer3DModel
+from diffusers.models.transformers.transformer_minimax_h3 import MiniMaxH3TransformerOutput
+from diffusers.utils.torch_utils import randn_tensor
+
+from ...testing_utils import enable_full_determinism, torch_device
+from ..testing_utils import (
+    AttentionTesterMixin,
+    BaseModelTesterConfig,
+    MemoryTesterMixin,
+    ModelTesterMixin,
+    TorchCompileTesterMixin,
+    TrainingTesterMixin,
+)
+
+
+enable_full_determinism()
+
+
+# The packed layout the dummy inputs describe: a text block, then the audio rows, then the target video rows. It is
+# the layout `MiniMaxH3Blocks` builds, minus the padding tail the blocks never emit.
+NUM_TEXT_TOKENS = 4
+NUM_AUDIO_TOKENS = 6
+NUM_VIDEO_TOKENS = 8
+
+
+class MiniMaxH3TransformerTesterConfig(BaseModelTesterConfig):
+    @property
+    def model_class(self):
+        return MiniMaxH3Transformer3DModel
+
+    @property
+    def main_input_name(self) -> str:
+        return "hidden_states"
+
+    @property
+    def input_shape(self) -> tuple[int, int]:
+        return (NUM_VIDEO_TOKENS, 16)
+
+    @property
+    def output_shape(self) -> tuple[int, int]:
+        return (NUM_VIDEO_TOKENS, 16)
+
+    @property
+    def generator(self):
+        return torch.Generator("cpu").manual_seed(0)
+
+    def get_init_dict(self) -> dict:
+        # `num_attention_heads * attention_head_dim` (32) is deliberately different from `hidden_size` (24), as it is
+        # in the released checkpoint, and `2 * 3 * rope_freq_dim` (12) is smaller than `attention_head_dim` so the
+        # partial-rotary path is exercised rather than aliased away.
+        return {
+            "num_attention_heads": 2,
+            "attention_head_dim": 16,
+            "hidden_size": 24,
+            "num_layers": 2,
+            "num_refiner_layers": 2,
+            "ffn_dim": 32,
+            "in_channels": 4,
+            "audio_in_channels": 6,
+            "patch_size": (1, 2, 2),
+            "text_dim": 8,
+            "freq_dim": 8,
+            "time_embed_hidden_dim": 24,
+            "time_embed_dim": 16,
+            "rope_freq_dim": 2,
+        }
+
+    def get_packed_layout(self, num_video_tokens: int = NUM_VIDEO_TOKENS) -> dict:
+        r"""
+        Build the structural arguments of one packed sequence.
+
+        The transformer does not build the layout itself: the caller orders the rows, tags every row with its
+        modality and its noise level, and hands over the `(t, h, w)` grid plus the three index tensors. The layout
+        here mirrors what the pipelines pack, with two distinct timesteps so the `(timestep, modality)` AdaLN table
+        is addressed on more than one row, and without a padding tail so attention needs no mask.
+        """
+        sequence_length = NUM_TEXT_TOKENS + NUM_AUDIO_TOKENS + num_video_tokens
+        text_indices = torch.arange(NUM_TEXT_TOKENS, device=torch_device)
+        audio_indices = torch.arange(NUM_TEXT_TOKENS, NUM_TEXT_TOKENS + NUM_AUDIO_TOKENS, device=torch_device)
+        video_indices = torch.arange(NUM_TEXT_TOKENS + NUM_AUDIO_TOKENS, sequence_length, device=torch_device)
+
+        # 0 = video, 1 = text, 2 = audio.
+        token_tags = torch.empty(sequence_length, dtype=torch.long, device=torch_device)
+        token_tags[text_indices] = 1
+        token_tags[audio_indices] = 2
+        token_tags[video_indices] = 0
+
+        # The conditioning-free rows share the video timestep; the audio rows step down their own schedule.
+        timestep_indices = torch.zeros(sequence_length, dtype=torch.long, device=torch_device)
+        timestep_indices[audio_indices] = 1
+
+        position_ids = torch.zeros(sequence_length, 3, dtype=torch.float32, device=torch_device)
+        position_ids[:, 0] = torch.arange(sequence_length, dtype=torch.float32, device=torch_device)
+        position_ids[video_indices, 1] = torch.arange(num_video_tokens, dtype=torch.float32, device=torch_device) % 4
+        position_ids[video_indices, 2] = torch.arange(num_video_tokens, dtype=torch.float32, device=torch_device) % 2
+
+        return {
+            "timestep": torch.tensor([0.7, 0.3], device=torch_device),
+            "timestep_indices": timestep_indices,
+            "token_tags": token_tags,
+            "position_ids": position_ids,
+            "video_indices": video_indices,
+            "audio_indices": audio_indices,
+            "text_indices": text_indices,
+        }
+
+    def get_dummy_inputs(self, num_video_tokens: int = NUM_VIDEO_TOKENS) -> dict:
+        generator = self.generator
+        init_dict = self.get_init_dict()
+        patch_size = init_dict["patch_size"]
+        video_patch_dim = init_dict["in_channels"] * patch_size[0] * patch_size[1] * patch_size[2]
+        batch_size = 2
+
+        return {
+            "hidden_states": randn_tensor(
+                (batch_size, num_video_tokens, video_patch_dim), generator=generator, device=torch_device
+            ),
+            "audio_hidden_states": randn_tensor(
+                (batch_size, NUM_AUDIO_TOKENS, init_dict["audio_in_channels"]),
+                generator=generator,
+                device=torch_device,
+            ),
+            "encoder_hidden_states": randn_tensor(
+                (batch_size, NUM_TEXT_TOKENS, init_dict["text_dim"]), generator=generator, device=torch_device
+            ),
+            **self.get_packed_layout(num_video_tokens),
+        }
+
+
+class TestMiniMaxH3Transformer(MiniMaxH3TransformerTesterConfig, ModelTesterMixin):
+    """Core model tests for the MiniMax-H3 transformer."""
+
+    def test_output_format(self):
+        model = self.model_class(**self.get_init_dict()).to(torch_device).eval()
+
+        with torch.no_grad():
+            output = model(**self.get_dummy_inputs())
+            output_tuple = model(**self.get_dummy_inputs(), return_dict=False)
+
+        assert isinstance(output, MiniMaxH3TransformerOutput)
+        assert output.sample.shape == (2, NUM_VIDEO_TOKENS, self.output_shape[-1])
+        assert output.audio_sample.shape == (2, NUM_AUDIO_TOKENS, self.get_init_dict()["audio_in_channels"])
+        torch.testing.assert_close(output.sample, output_tuple[0])
+        torch.testing.assert_close(output.audio_sample, output_tuple[1])
+
+    @torch.no_grad()
+    def test_padding_rows_form_their_own_attention_document(self):
+        r"""
+        A padding tail (tag `-1`) must not change the live rows.
+
+        The reference pads the packed sequence to a multiple of 64 for FlashAttention and splits it with
+        `cu_seqlens = [0, used, S]`; the port reproduces that split with a boolean mask. Appending padding rows to a
+        layout therefore has to leave the video and audio predictions of the live rows untouched.
+        """
+        model = self.model_class(**self.get_init_dict()).to(torch_device).eval()
+        inputs = self.get_dummy_inputs()
+        padless_output = model(**inputs, return_dict=False)
+
+        num_padding_rows = 3
+        sequence_length = inputs["position_ids"].shape[0]
+        padded = dict(inputs)
+        padded["token_tags"] = torch.cat(
+            [inputs["token_tags"], torch.full((num_padding_rows,), -1, dtype=torch.long, device=torch_device)]
+        )
+        padded["timestep_indices"] = torch.cat(
+            [inputs["timestep_indices"], torch.zeros(num_padding_rows, dtype=torch.long, device=torch_device)]
+        )
+        padded["position_ids"] = torch.cat(
+            [
+                inputs["position_ids"],
+                torch.arange(
+                    sequence_length, sequence_length + num_padding_rows, dtype=torch.float32, device=torch_device
+                )[:, None].repeat(1, 3),
+            ]
+        )
+        padded_output = model(**padded, return_dict=False)
+
+        for padless, padded_ in zip(padless_output, padded_output):
+            torch.testing.assert_close(padless, padded_, atol=1e-5, rtol=1e-5)
+
+
+class TestMiniMaxH3TransformerMemory(MiniMaxH3TransformerTesterConfig, MemoryTesterMixin):
+    """Memory optimization tests for the MiniMax-H3 transformer."""
+
+
+class TestMiniMaxH3TransformerTraining(MiniMaxH3TransformerTesterConfig, TrainingTesterMixin):
+    """Training tests for the MiniMax-H3 transformer."""
+
+    def test_gradient_checkpointing_is_applied(self):
+        super().test_gradient_checkpointing_is_applied(
+            expected_set={"MiniMaxH3Transformer3DModel", "MiniMaxH3TokenRefiner"}
+        )
+
+
+class TestMiniMaxH3TransformerAttention(MiniMaxH3TransformerTesterConfig, AttentionTesterMixin):
+    """Attention processor tests for the MiniMax-H3 transformer."""
+
+
+class TestMiniMaxH3TransformerTorchCompile(MiniMaxH3TransformerTesterConfig, TorchCompileTesterMixin):
+    """Torch compile tests for the MiniMax-H3 transformer.
+
+    Regional compilation (`compile_repeated_blocks`) and full-model compilation with graph breaks allowed both work.
+    Whole-model `fullgraph=True` and `torch.export` do not: `forward` decides whether the packed sequence needs an
+    attention mask with `if bool(is_pad.any())`, reading the padding tag out of `token_tags`, and a data-dependent
+    branch has no fullgraph representation. Dropping the branch is not an option, because a padless sequence has to
+    keep `attention_mask=None` so the unmasked flash and sage backends stay available.
+    """
+
+    @pytest.mark.skip(
+        "`forward` branches on `bool(is_pad.any())` to decide whether the packed sequence needs an attention mask, "
+        "which `fullgraph=True` cannot trace. Regional compilation is covered by "
+        "`test_torch_compile_repeated_blocks`."
+    )
+    def test_torch_compile_recompilation_and_graph_break(self):
+        pass
+
+    @pytest.mark.skip(
+        "`torch.export` hits the same data-dependent `bool(is_pad.any())` branch as `fullgraph=True` compilation."
+    )
+    def test_compile_works_with_aot(self, tmp_path):
+        pass
diff --git a/tests/modular_pipelines/minimax_h3/__init__.py b/tests/modular_pipelines/minimax_h3/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/tests/modular_pipelines/minimax_h3/test_modular_pipeline_minimax_h3.py b/tests/modular_pipelines/minimax_h3/test_modular_pipeline_minimax_h3.py
new file mode 100644
index 000000000000..6e1bf9f4236a
--- /dev/null
+++ b/tests/modular_pipelines/minimax_h3/test_modular_pipeline_minimax_h3.py
@@ -0,0 +1,868 @@
+# Copyright 2026 The HuggingFace Team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+import pytest
+import torch
+from PIL import Image
+
+from diffusers.modular_pipelines import (
+    MiniMaxH3Blocks,
+    MiniMaxH3ModularPipeline,
+    MiniMaxH3Ref2VABlocks,
+    MiniMaxH3Ref2VAModularPipeline,
+)
+from diffusers.modular_pipelines.minimax_h3 import MiniMaxH3Reference, packing, packing_ref2va
+from diffusers.modular_pipelines.minimax_h3.before_encoder import MiniMaxH3Ref2VASetupStep
+from diffusers.modular_pipelines.minimax_h3.encoders import MiniMaxH3Ref2VATextEncoderStep, MiniMaxH3TextEncoderStep
+
+from ...testing_utils import torch_device
+from ..test_modular_pipelines_common import ModularPipelineTesterMixin, _get_specified_components
+
+
+# MiniMax-H3 generates 5 to 15 seconds at a fixed 24 fps, so the shortest admissible request is 124 frames
+# (`17 * 7 + 5`, the next length the video VAE can decode). It is affordable on CPU because the canvas is tiny: 32
+# pixels is a single `(1, 2, 2)` patch row per latent frame.
+NUM_FRAMES = 124
+RESOLUTION = 32
+NUM_LATENT_FRAMES = 37
+NUM_AUDIO_LATENTS = 207
+# `prod(encoder_rates)` of the tiny audio VAE, standing in for the released 800 samples per latent.
+AUDIO_HOP_LENGTH = 4
+# The tiny audio VAE's own sample rate, so a reference soundtrack is never resampled.
+AUDIO_SAMPLE_RATE = 40 * AUDIO_HOP_LENGTH
+
+# The released short edge of an image reference is 2048 pixels, which packs thousands of conditioning rows.
+TEST_REFERENCE_IMAGE_SHORT_EDGE = 64
+
+# Both blocksets read the same repository, as the released one does: `transformer/` serves the `t2va` / `fl2va` half
+# and `transformer_ref/` the `ref2va` one, every other component is shared.
+TINY_MODULAR_REPO_ID = "hf-internal-testing/tiny-minimax-h3-modular-pipe"
+
+
+T2VA_WORKFLOW = [
+    ("setup", "MiniMaxH3SetupStep"),
+    ("text_encoder", "MiniMaxH3TextEncoderStep"),
+    ("prepare_layout", "MiniMaxH3PrepareLayoutStep"),
+    ("prepare_latents", "MiniMaxH3PrepareLatentsStep"),
+    ("set_timesteps", "MiniMaxH3SetTimestepsStep"),
+    ("denoise", "MiniMaxH3DenoiseStep"),
+    ("decode.video", "MiniMaxH3VideoDecodeStep"),
+    ("decode.audio", "MiniMaxH3AudioDecodeStep"),
+]
+# A keyframe adds the one block that encodes it; whether it anchors the first or the last frame is a matter of the
+# packed layout, not of which blocks run.
+FL2VA_WORKFLOW = [
+    *T2VA_WORKFLOW[:2],
+    ("vae_encoder", "MiniMaxH3KeyframeVaeEncoderStep"),
+    *T2VA_WORKFLOW[2:],
+]
+MINIMAX_H3_WORKFLOWS = {
+    "t2va": T2VA_WORKFLOW,
+    "fl2va": FL2VA_WORKFLOW,
+    "fl2va_last_frame": FL2VA_WORKFLOW,
+}
+MINIMAX_H3_REF2VA_WORKFLOWS = {
+    "ref2va": [
+        ("setup", "MiniMaxH3Ref2VASetupStep"),
+        ("text_encoder", "MiniMaxH3Ref2VATextEncoderStep"),
+        ("reference_encoder", "MiniMaxH3Ref2VAReferenceEncoderStep"),
+        ("prepare_layout", "MiniMaxH3Ref2VAPrepareLayoutStep"),
+        ("prepare_latents", "MiniMaxH3PrepareLatentsStep"),
+        ("set_timesteps", "MiniMaxH3SetTimestepsStep"),
+        ("denoise", "MiniMaxH3Ref2VADenoiseStep"),
+        ("decode.video", "MiniMaxH3VideoDecodeStep"),
+        ("decode.audio", "MiniMaxH3AudioDecodeStep"),
+    ]
+}
+
+
+def _video_frames(num_frames: int, size: int) -> np.ndarray:
+    """Synthesized video reference frames: `uint8` RGB at MiniMax-H3's own 24 fps."""
+    return (np.random.default_rng(0).random((num_frames, size, size, 3)) * 255).astype("uint8")
+
+
+def _waveform(duration: float) -> torch.Tensor:
+    """A synthesized soundtrack: a stereo waveform at the tiny audio VAE's own sample rate, so nothing is resampled."""
+    return torch.rand(2, round(duration * AUDIO_SAMPLE_RATE), generator=torch.Generator("cpu").manual_seed(1)) * 2 - 1
+
+
+def _reference_video(num_frames: int, size: int) -> MiniMaxH3Reference:
+    """A silent video reference at MiniMax-H3's own 24 fps."""
+    return MiniMaxH3Reference(video=_video_frames(num_frames, size), fps=float(packing.MINIMAX_H3_FPS))
+
+
+def _reference_audio(duration: float) -> MiniMaxH3Reference:
+    """A standalone audio reference at the tiny audio VAE's own sample rate."""
+    return MiniMaxH3Reference(audio=_waveform(duration), sample_rate=AUDIO_SAMPLE_RATE)
+
+
+# The synthesized media fixtures the file-decoding tests are built from: a tiny 8 fps clip with a stereo soundtrack.
+FIXTURE_FPS = 8.0
+FIXTURE_NUM_FRAMES = 8
+FIXTURE_SAMPLE_RATE = 8000
+
+
+def _write_video(path, with_audio: bool) -> None:
+    """Encode a tiny 64x32 clip, with a stereo soundtrack when asked, with PyAV."""
+    av = pytest.importorskip("av")
+
+    with av.open(str(path), "w") as container:
+        # Both streams are declared before anything is muxed, which is what the muxer needs to lay out the file.
+        video_stream = container.add_stream("libx264", rate=int(FIXTURE_FPS))
+        video_stream.width, video_stream.height, video_stream.pix_fmt = 64, 32, "yuv420p"
+        audio_stream = None
+        if with_audio:
+            audio_stream = container.add_stream("aac", rate=FIXTURE_SAMPLE_RATE)
+            audio_stream.codec_context.layout = "stereo"
+
+        for index in range(FIXTURE_NUM_FRAMES):
+            pixels = np.full((32, 64, 3), index * 16, dtype="uint8")
+            frame = av.VideoFrame.from_ndarray(pixels, format="rgb24")
+            frame.pts = index
+            container.mux(video_stream.encode(frame))
+        container.mux(video_stream.encode())
+
+        if audio_stream is None:
+            return
+        num_samples = int(FIXTURE_NUM_FRAMES / FIXTURE_FPS * FIXTURE_SAMPLE_RATE)
+        samples = np.zeros((1, 2 * num_samples), dtype="int16")
+        frame = av.AudioFrame.from_ndarray(samples, format="s16", layout="stereo")
+        frame.sample_rate = FIXTURE_SAMPLE_RATE
+        resampler = av.audio.resampler.AudioResampler(format="fltp", layout="stereo", rate=FIXTURE_SAMPLE_RATE)
+        pts = 0
+        for resampled in resampler.resample(frame):
+            resampled.pts = pts
+            pts += resampled.samples
+            container.mux(audio_stream.encode(resampled))
+        container.mux(audio_stream.encode())
+
+
+def _media_fixtures(directory) -> tuple:
+    """A video with a soundtrack, a still image and an audio clip, as files a reference can be built from."""
+    av = pytest.importorskip("av")
+
+    video_path, image_path, audio_path = (
+        directory / "reference.mp4",
+        directory / "reference.png",
+        directory / "reference.wav",
+    )
+    _write_video(video_path, with_audio=True)
+    Image.new("RGB", (64, 32), color=(10, 20, 30)).save(image_path)
+    with av.open(str(audio_path), "w") as container:
+        stream = container.add_stream("pcm_s16le", rate=FIXTURE_SAMPLE_RATE)
+        stream.codec_context.layout = "stereo"
+        frame = av.AudioFrame.from_ndarray(
+            np.zeros((1, 2 * FIXTURE_SAMPLE_RATE), dtype="int16"), format="s16", layout="stereo"
+        )
+        frame.sample_rate = FIXTURE_SAMPLE_RATE
+        frame.pts = 0
+        container.mux(stream.encode(frame))
+        container.mux(stream.encode())
+    return video_path, image_path, audio_path
+
+
+@pytest.fixture(autouse=True, scope="module")
+def small_references():
+    """
+    Encode references at `TEST_REFERENCE_IMAGE_SHORT_EDGE` instead of the released 2048 pixels.
+
+    A 2048 pixel short edge packs thousands of conditioning rows, which is minutes per pipeline call on CPU. Every
+    request of this module passes `height` and `width`, so the canvas of a generated video is never derived from
+    these. `TestMiniMaxH3ReferenceGeometry` restores the released value where it pins it.
+    """
+    with pytest.MonkeyPatch.context() as patch:
+        patch.setattr(packing_ref2va, "MINIMAX_H3_REFERENCE_IMAGE_SHORT_EDGE", TEST_REFERENCE_IMAGE_SHORT_EDGE)
+        patch.setattr(packing, "MINIMAX_H3_SHORT_EDGE", TEST_REFERENCE_IMAGE_SHORT_EDGE)
+        patch.setattr(packing, "MINIMAX_H3_MAX_PIXELS", TEST_REFERENCE_IMAGE_SHORT_EDGE**2 * 2)
+        yield
+
+
+class MiniMaxH3ModularTesterBase(ModularPipelineTesterMixin):
+    """What the two blocksets share: the repository, the output surface and the tests that do not apply."""
+
+    pretrained_model_name_or_path = TINY_MODULAR_REPO_ID
+    # MiniMax-H3 packs one request into one sequence and rejects a list of prompts, so nothing is batched.
+    batch_params = frozenset()
+    # The checkpoint is guidance-distilled and generates a video, so neither `guidance_scale` nor
+    # `num_images_per_prompt` exists.
+    optional_params = frozenset(["num_inference_steps", "latents", "output_type"])
+    output_name = "videos"
+
+    @pytest.mark.skip(reason="MiniMax-H3 packs one request into one sequence, so a batch of prompts is not a thing.")
+    def test_inference_batch_consistent(self):
+        pass
+
+    @pytest.mark.skip(reason="MiniMax-H3 packs one request into one sequence, so a batch of prompts is not a thing.")
+    def test_inference_batch_single_identical(self):
+        pass
+
+    @pytest.mark.skip(reason="One request generates one video, so there is no `num_images_per_prompt`.")
+    def test_num_images_per_prompt(self):
+        pass
+
+    def test_load_expected_components_from_pretrained(self, tmp_path):
+        r"""
+        Every component the repository holds *for this half* is loaded from it.
+
+        The repository holds both checkpoint partitions, as the released one does, so its index also names the
+        transformer of the other half — which these blocks never declare and must therefore never load.
+        """
+        pipe = self.get_pipeline()
+        specified = _get_specified_components(self.pretrained_model_name_or_path, cache_dir=tmp_path)
+
+        expected = {name for name in specified if name in pipe.components}
+        actual = {
+            name
+            for name in pipe.components
+            if getattr(pipe, name, None) is not None
+            and getattr(getattr(pipe, name), "_diffusers_load_id", None) not in (None, "null")
+        }
+
+        assert expected == actual, f"Component mismatch: missing={expected - actual}, unexpected={actual - expected}"
+        assert "transformer_ref" in specified and "transformer" in specified
+
+    def injected_noise(self, pipe, seed=3):
+        r"""The video and audio noise a request would otherwise draw, in the shapes the blocks expect back."""
+        latents = torch.randn(
+            1,
+            pipe.vae_latent_channels,
+            NUM_LATENT_FRAMES,
+            RESOLUTION // pipe.vae_spatial_compression_ratio,
+            RESOLUTION // pipe.vae_spatial_compression_ratio,
+            generator=torch.Generator("cpu").manual_seed(seed),
+        )
+        audio_latents = torch.randn(
+            2, pipe.audio_latent_channels, NUM_AUDIO_LATENTS, generator=torch.Generator("cpu").manual_seed(seed + 1)
+        )
+        return latents, audio_latents
+
+    def test_duration_ceiling_holds_for_the_aligned_count(self):
+        r"""
+        346 frames are 14.417 seconds, but they are rounded up to 362, i.e. 15.083 seconds: the ceiling holds for the
+        aligned count, so this is rejected rather than silently generating too long a video.
+        """
+        pipe = self.get_pipeline()
+
+        inputs = self.get_dummy_inputs()
+        inputs["num_frames"] = 346
+
+        with pytest.raises(ValueError, match="rounded up to 362"):
+            pipe(**inputs)
+
+
+class TestMiniMaxH3ModularPipelineFast(MiniMaxH3ModularTesterBase):
+    pipeline_class = MiniMaxH3ModularPipeline
+    pipeline_blocks_class = MiniMaxH3Blocks
+
+    params = frozenset(["prompt", "image", "last_image", "height", "width", "num_frames"])
+    expected_workflow_blocks = MINIMAX_H3_WORKFLOWS
+
+    def get_dummy_inputs(self, seed=0):
+        return {
+            "prompt": "a robot dancing",
+            "generator": self.get_generator(seed),
+            "num_inference_steps": 2,
+            "height": RESOLUTION,
+            "width": RESOLUTION,
+            "num_frames": NUM_FRAMES,
+            "output_type": "pt",
+        }
+
+    def test_video_and_audio_outputs(self):
+        r"""One call denoises both modalities out of the one packed sequence, and returns both."""
+        pipe = self.get_pipeline()
+
+        state = pipe(**self.get_dummy_inputs())
+        video, audio = state.get("videos"), state.get("audio")
+
+        assert video.shape == (1, NUM_FRAMES, 3, RESOLUTION, RESOLUTION)
+        # The audio VAE is mono and takes the two stereo channels as two batch items, which the decoder block stacks
+        # back into `(batch, 2, samples)`.
+        assert audio.shape == (1, 2, NUM_AUDIO_LATENTS * AUDIO_HOP_LENGTH)
+        assert video.min() >= 0.0 and video.max() <= 1.0
+        assert state.get("sampling_rate") == pipe.audio_vae.config.sampling_rate
+
+    @pytest.mark.parametrize(
+        "keyframes,num_condition_rows",
+        [(("image",), 1), (("last_image",), 1), (("image", "last_image"), 2)],
+        ids=["first", "last", "first_and_last"],
+    )
+    def test_fl2va_keyframes(self, keyframes, num_condition_rows):
+        r"""
+        A keyframe contributes one conditioning row per latent patch, and those rows are pinned for the whole loop.
+
+        They are packed in front of the generated video rows and ride along at their own `t = 0.999`. The loop only
+        ever writes the generated rows, so the conditioning rows the encoder block produced survive it untouched,
+        which is what the denoised sequence is checked against here. On a `RESOLUTION` canvas a keyframe is a single
+        `(1, 2, 2)` patch row.
+        """
+        pipe = self.get_pipeline()
+        keyframe = Image.fromarray((np.random.default_rng(0).random((48, 80, 3)) * 255).astype("uint8"))
+
+        inputs = self.get_dummy_inputs()
+        inputs.update(dict.fromkeys(keyframes, keyframe))
+        state = pipe(**inputs)
+
+        assert state.get("videos").shape == (1, NUM_FRAMES, 3, RESOLUTION, RESOLUTION)
+        assert state.get("num_condition_video_rows") == num_condition_rows
+        condition_latents = state.get("condition_latents")
+        assert condition_latents.shape[0] == num_condition_rows
+        assert torch.equal(state.get("latents")[:num_condition_rows], condition_latents)
+
+    @pytest.mark.parametrize("with_keyframe", [False, True], ids=["t2va", "fl2va"])
+    def test_generator_reproducibility(self, with_keyframe):
+        r"""
+        Two runs from the same generator state are identical, two seeds differ.
+
+        The blocks draw from the one generator the request carries, in the order they run — the keyframe conditioning
+        noise in the VAE encoder step, then the video and the audio noise in the prepare-latents step — which is the
+        whole reproducibility contract of a request.
+        """
+        pipe = self.get_pipeline()
+        keyframe = Image.new("RGB", (48, 80))
+
+        def run(seed):
+            inputs = self.get_dummy_inputs()
+            inputs["generator"] = torch.Generator("cpu").manual_seed(seed)
+            if with_keyframe:
+                inputs["image"] = keyframe
+            state = pipe(**inputs)
+            return state.get("videos"), state.get("audio")
+
+        video, audio = run(7)
+        same_video, same_audio = run(7)
+        other_video, other_audio = run(8)
+
+        assert torch.equal(video, same_video)
+        assert torch.equal(audio, same_audio)
+        assert not torch.equal(video, other_video)
+        assert not torch.equal(audio, other_audio)
+
+    def test_injected_latents_replace_the_draws(self):
+        r"""
+        `latents` and `audio_latents` stand in for their draw, which is how a sample is reproduced from outside.
+
+        With both passed in, a `t2va` request draws nothing at all, so two runs with different generators return the
+        very same video and soundtrack.
+        """
+        pipe = self.get_pipeline()
+        latents, audio_latents = self.injected_noise(pipe)
+
+        outputs = []
+        for seed in (7, 8):
+            inputs = self.get_dummy_inputs()
+            inputs["generator"] = torch.Generator("cpu").manual_seed(seed)
+            inputs["latents"] = latents
+            inputs["audio_latents"] = audio_latents
+            state = pipe(**inputs)
+            outputs.append((state.get("videos"), state.get("audio")))
+
+        assert torch.equal(outputs[0][0], outputs[1][0])
+        assert torch.equal(outputs[0][1], outputs[1][1])
+
+    @pytest.mark.parametrize("num_keyframes", [0, 1, 2], ids=["text_only", "one_keyframe", "two_keyframes"])
+    def test_encode_prompt(self, num_keyframes):
+        r"""
+        The presentation is encoded in one conditioner call, whatever it carries.
+
+        A keyframe prepends a `"<Picture i>: "` label and a vision block, whose rows are tagged as *video*; a
+        text-only presentation is the verbatim prompt and is tagged as text throughout. Every vision block also makes
+        Qwen3-VL lay its rotary positions out per modality, which it reads off the `mm_token_type_ids` the processor
+        derives from the vision pad ids.
+        """
+        pipe = self.get_pipeline()
+        keyframe = Image.fromarray((np.random.default_rng(0).random((32, 32, 3)) * 255).astype("uint8"))
+
+        prompt_embeds, text_token_tags = MiniMaxH3TextEncoderStep.encode_prompt(
+            pipe, "a robot dancing", [keyframe] * num_keyframes, device=torch_device
+        )
+
+        assert prompt_embeds.shape[0] == 1
+        assert prompt_embeds.shape[-1] == pipe.transformer.config.text_dim
+        assert prompt_embeds.shape[1] == text_token_tags.shape[0]
+        assert torch.isfinite(prompt_embeds).all()
+        # `0` tags a row of a vision block and `1` a text row, so a text-only presentation carries text rows alone.
+        assert set(text_token_tags.tolist()) == ({0, 1} if num_keyframes else {1})
+
+    def test_text_encoder_block_standalone(self):
+        r"""
+        The text encoder block runs on its own, without the denoiser or the VAEs.
+
+        Encoding a presentation once and reusing it across requests is the modular way of passing `prompt_embeds`,
+        so the block may only touch the components it declares.
+        """
+        pipe = MiniMaxH3TextEncoderStep().init_pipeline(self.pretrained_model_name_or_path)
+        pipe.load_components(dtype=torch.float32)
+
+        outputs = pipe(prompt="a robot dancing", output=["prompt_embeds", "text_token_tags"])
+
+        assert set(pipe.components) == {"text_encoder", "tokenizer", "processor"}
+        assert outputs["prompt_embeds"].shape[0] == 1
+        assert outputs["prompt_embeds"].shape[1] == outputs["text_token_tags"].shape[0]
+        # `1` tags a text row, and a text-only presentation is the verbatim prompt.
+        assert set(outputs["text_token_tags"].tolist()) == {1}
+
+    @pytest.mark.parametrize("output_type", ["np", "pil", "latent"])
+    def test_output_type(self, output_type):
+        r"""`"latent"` stops before both VAEs and keeps the denormalized latents of either modality."""
+        pipe = self.get_pipeline()
+
+        inputs = self.get_dummy_inputs()
+        inputs["output_type"] = output_type
+        state = pipe(**inputs)
+        video, audio = state.get("videos"), state.get("audio")
+
+        if output_type == "np":
+            assert video.shape == (1, NUM_FRAMES, RESOLUTION, RESOLUTION, 3)
+        elif output_type == "pil":
+            assert len(video[0]) == NUM_FRAMES
+            assert video[0][0].size == (RESOLUTION, RESOLUTION)
+        else:
+            # The video as `(1, C, F, H, W)` and the audio channel-major.
+            assert video.shape == (1, 4, NUM_LATENT_FRAMES, RESOLUTION // 16, RESOLUTION // 16)
+            assert audio.shape == (2, 8, NUM_AUDIO_LATENTS)
+
+    @pytest.mark.parametrize(
+        "overrides,message",
+        [
+            ({"prompt": ["a robot", "a fox"]}, "must be a single string"),
+            ({"height": 30, "width": 30}, "multiples of 32"),
+            ({"width": None}, "have to be passed together"),
+            ({"num_frames": 96}, "must be between"),
+            ({"num_frames": 400}, "must be between"),
+        ],
+        ids=[
+            "prompt_list",
+            "canvas_not_a_multiple_of_32",
+            "height_without_width",
+            "shorter_than_five_seconds",
+            "longer_than_fifteen_seconds",
+        ],
+    )
+    def test_check_inputs(self, overrides, message):
+        pipe = self.get_pipeline()
+
+        inputs = self.get_dummy_inputs()
+        inputs.update(overrides)
+
+        with pytest.raises(ValueError, match=message):
+            pipe(**inputs)
+
+
+class TestMiniMaxH3Ref2VAModularPipelineFast(MiniMaxH3ModularTesterBase):
+    pipeline_class = MiniMaxH3Ref2VAModularPipeline
+    pipeline_blocks_class = MiniMaxH3Ref2VABlocks
+
+    params = frozenset(["prompt", "references", "height", "width", "num_frames"])
+    expected_workflow_blocks = MINIMAX_H3_REF2VA_WORKFLOWS
+
+    def get_dummy_inputs(self, seed=0):
+        return {
+            "prompt": "a robot dancing",
+            "references": [MiniMaxH3Reference(image=Image.new("RGB", (48, 80)))],
+            "generator": self.get_generator(seed),
+            "num_inference_steps": 2,
+            "height": RESOLUTION,
+            "width": RESOLUTION,
+            "num_frames": NUM_FRAMES,
+            "output_type": "pt",
+        }
+
+    def test_video_and_audio_outputs(self):
+        r"""A reference conditions the request without binding the generated geometry."""
+        pipe = self.get_pipeline()
+
+        state = pipe(**self.get_dummy_inputs())
+        video, audio = state.get("videos"), state.get("audio")
+
+        assert video.shape == (1, NUM_FRAMES, 3, RESOLUTION, RESOLUTION)
+        assert audio.shape == (1, 2, NUM_AUDIO_LATENTS * AUDIO_HOP_LENGTH)
+        assert video.min() >= 0.0 and video.max() <= 1.0
+
+    def test_generator_reproducibility(self):
+        r"""
+        Two runs from the same generator state are identical, two seeds differ.
+
+        A `ref2va` request draws the reference conditioning noise before the video and the audio noise, all three off
+        the one generator it carries, so this covers the whole stream.
+        """
+        pipe = self.get_pipeline()
+
+        def run(seed):
+            inputs = self.get_dummy_inputs()
+            inputs["generator"] = torch.Generator("cpu").manual_seed(seed)
+            state = pipe(**inputs)
+            return state.get("videos"), state.get("audio")
+
+        video, audio = run(7)
+        same_video, same_audio = run(7)
+        other_video, other_audio = run(8)
+
+        assert torch.equal(video, same_video)
+        assert torch.equal(audio, same_audio)
+        assert not torch.equal(video, other_video)
+        assert not torch.equal(audio, other_audio)
+
+    def test_injected_latents_replace_the_draws(self):
+        r"""
+        `latents` and `audio_latents` stand in for their draw, and only for theirs.
+
+        A `ref2va` request draws the reference conditioning noise *before* the two target draws, so injecting the
+        targets replaces those two alone: the same seed with other noise is another sample, and another seed with the
+        same noise is still another sample, through the conditioning noise the references are augmented with.
+        """
+        pipe = self.get_pipeline()
+        latents, audio_latents = self.injected_noise(pipe)
+        other_latents, other_audio_latents = self.injected_noise(pipe, seed=11)
+
+        def run(seed, video_noise, audio_noise):
+            inputs = self.get_dummy_inputs()
+            inputs["generator"] = torch.Generator("cpu").manual_seed(seed)
+            inputs["latents"] = video_noise
+            inputs["audio_latents"] = audio_noise
+            state = pipe(**inputs)
+            return state.get("videos"), state.get("audio")
+
+        video, audio = run(7, latents, audio_latents)
+        same_video, same_audio = run(7, latents, audio_latents)
+        other_noise_video, other_noise_audio = run(7, other_latents, other_audio_latents)
+        other_seed_video, _ = run(8, latents, audio_latents)
+
+        assert torch.equal(video, same_video)
+        assert torch.equal(audio, same_audio)
+        assert not torch.equal(video, other_noise_video)
+        assert not torch.equal(audio, other_noise_audio)
+        assert not torch.equal(video, other_seed_video)
+
+    @pytest.mark.parametrize(
+        "kinds,num_frames",
+        [(("video",), NUM_FRAMES), (("image", "audio"), None), (("video", "image"), NUM_FRAMES)],
+        ids=["video", "image_audio", "video_image"],
+    )
+    def test_reference_combinations(self, kinds, num_frames):
+        r"""
+        Any ordered mix of image, video and audio references is packed, in request order.
+
+        A video reference conditions on its motion *and*, when the request passes one with it, on its soundtrack, so
+        it contributes both visual and audio rows; an audio reference contributes audio rows alone and never reaches
+        the conditioner. The `image_audio` case also leaves `num_frames` to the references, which is admissible
+        because exactly one of them carries audio: the duration is that soundtrack's, snapped up to the next
+        `17 * n + 5` the video VAE can decode.
+
+        The reference rows are pinned for the whole loop, which is what the denoised sequence is checked against: the
+        visual anchors keep their noise-augmented values and the audio anchors stay exactly as the encoder produced
+        them.
+        """
+        media = {
+            "image": MiniMaxH3Reference(image=Image.new("RGB", (48, 80))),
+            # A one-second video reference, soundtrack included, and a six-second standalone soundtrack.
+            "video": MiniMaxH3Reference(
+                video=_video_frames(packing.MINIMAX_H3_FPS, 64),
+                fps=float(packing.MINIMAX_H3_FPS),
+                audio=_waveform(1.0),
+                sample_rate=AUDIO_SAMPLE_RATE,
+            ),
+            "audio": _reference_audio(6.0),
+        }
+
+        pipe = self.get_pipeline()
+        inputs = self.get_dummy_inputs()
+        inputs["references"] = [media[kind] for kind in kinds]
+        inputs["num_frames"] = num_frames
+
+        state = pipe(**inputs)
+
+        num_condition_rows = state.get("num_condition_video_rows")
+        num_audio_condition_rows = state.get("num_condition_audio_rows")
+        assert num_condition_rows > 0
+        assert (num_audio_condition_rows > 0) == any(kind in ("video", "audio") for kind in kinds)
+        assert state.get("videos").shape == (1, state.get("num_frames"), 3, RESOLUTION, RESOLUTION)
+        # The loop only ever writes the generated rows, so the anchors the encoder block produced survive it.
+        assert torch.equal(state.get("latents")[:num_condition_rows], state.get("condition_latents"))
+        if num_audio_condition_rows:
+            assert torch.equal(
+                state.get("audio_latents")[:num_audio_condition_rows], state.get("audio_condition_latents")
+            )
+
+    @pytest.mark.parametrize(
+        "kinds", [("image",), ("video",), ("video", "image")], ids=["image", "video", "video_image"]
+    )
+    def test_encode_prompt(self, kinds):
+        r"""
+        The presentation is encoded in one conditioner call, whatever references it labels.
+
+        The rows of a reference's vision block are tagged as *video*, and those blocks are what makes Qwen3-VL lay its
+        rotary positions out per modality run, which it reads off the `mm_token_type_ids` the processor derives from
+        the vision pad ids. A video reference contributes one timestamped block per merged frame pair.
+        """
+        pipe = self.get_pipeline()
+        media = {"image": MiniMaxH3Reference(image=Image.new("RGB", (48, 80))), "video": _reference_video(25, 32)}
+        references, _ = MiniMaxH3Ref2VASetupStep.prepare_references(pipe, [media[kind] for kind in kinds], NUM_FRAMES)
+
+        prompt_embeds, text_token_tags = MiniMaxH3Ref2VATextEncoderStep.encode_prompt(
+            pipe, "a robot dancing", references, device=torch_device
+        )
+
+        assert prompt_embeds.shape[0] == 1
+        assert prompt_embeds.shape[-1] == pipe.transformer_ref.config.text_dim
+        assert prompt_embeds.shape[1] == text_token_tags.shape[0]
+        assert torch.isfinite(prompt_embeds).all()
+        # `0` tags a row of a vision block and `1` a text row, and every reference here carries a vision block.
+        assert set(text_token_tags.tolist()) == {0, 1}
+        # A 25 frame reference decoded at 24 fps is read at 2 fps, so it is three frames merged into two blocks.
+        for reference in references:
+            if reference.kind == "video":
+                assert reference.block_timestamps == [0.25, 1.0]
+
+    @pytest.mark.parametrize("media_type", ["pil", "np", "pt"], ids=["pil", "numpy", "torch"])
+    def test_reference_media_layouts(self, media_type):
+        r"""
+        Image and video references are in-memory media, in any of the layouts diffusers accepts: images, a
+        channels-last `np.ndarray` or a channels-first `torch.Tensor`, `uint8` or floating point over `[0, 1]`. All
+        three carry the same pixels, and media that already is at the resolution the reference resolves to reaches the
+        VAE untouched.
+        """
+        pipe = self.get_pipeline()
+        pixels = _video_frames(4, TEST_REFERENCE_IMAGE_SHORT_EDGE)
+        if media_type == "pil":
+            image, frames = Image.fromarray(pixels[0]), [Image.fromarray(frame) for frame in pixels]
+        elif media_type == "np":
+            image, frames = pixels[0] / 255.0, pixels
+        else:
+            image, frames = torch.from_numpy(pixels[0]).permute(2, 0, 1), torch.from_numpy(pixels).permute(0, 3, 1, 2)
+
+        references, _ = MiniMaxH3Ref2VASetupStep.prepare_references(
+            pipe,
+            [MiniMaxH3Reference(image=image), MiniMaxH3Reference(video=frames, fps=float(packing.MINIMAX_H3_FPS))],
+            NUM_FRAMES,
+        )
+
+        assert np.array_equal(np.asarray(references[0].image), pixels[0])
+        assert np.array_equal(references[1].frames, pixels)
+
+    def test_reference_rates_default_to_the_model_rates(self):
+        r"""
+        A reference that leaves its rates out is taken to already be at MiniMax-H3's own: the frames flow through
+        untouched, without a resampling pass and without a copy, and so do the samples of a waveform.
+        """
+        pipe = self.get_pipeline()
+        frames = _video_frames(NUM_FRAMES, TEST_REFERENCE_IMAGE_SHORT_EDGE)
+        waveform = _waveform(2.0)
+
+        references, _ = MiniMaxH3Ref2VASetupStep.prepare_references(
+            pipe, [MiniMaxH3Reference(video=frames), MiniMaxH3Reference(audio=waveform)], NUM_FRAMES
+        )
+
+        assert np.shares_memory(references[0].frames, frames)
+        assert torch.equal(references[1].waveform, waveform)
+
+    def test_reference_sample_rate_override_resamples(self):
+        r"""A waveform that says it carries another rate is resampled onto the audio VAE's own."""
+        pipe = self.get_pipeline()
+        waveform = _waveform(2.0)
+
+        references, _ = MiniMaxH3Ref2VASetupStep.prepare_references(
+            pipe,
+            [
+                MiniMaxH3Reference(image=Image.new("RGB", (48, 80))),
+                MiniMaxH3Reference(audio=waveform, sample_rate=AUDIO_SAMPLE_RATE // 2),
+            ],
+            NUM_FRAMES,
+        )
+
+        # Half the audio VAE's rate, so the same samples span twice as many of the VAE's own.
+        assert references[1].waveform.shape == (2, 2 * waveform.shape[-1])
+
+    def test_num_frames_left_open_needs_exactly_one_audio_reference(self):
+        r"""Leaving `num_frames` out is ambiguous unless exactly one reference carries audio."""
+        pipe = self.get_pipeline()
+
+        inputs = self.get_dummy_inputs()
+        inputs["num_frames"] = None
+
+        with pytest.raises(ValueError, match="may only be left to the references"):
+            pipe(**inputs)
+
+    def test_num_frames_left_open_holds_the_ceiling_for_the_aligned_count(self):
+        r"""
+        A soundtrack just under 15 seconds is rejected rather than silently stretched past the ceiling.
+
+        14.99 seconds round to 360 frames, which the video VAE's `17 * n + 5` grid rounds up to 362, i.e. 15.083
+        seconds. The duration the request generates is the aligned one, so that is what the bound holds for.
+        """
+        pipe = self.get_pipeline()
+
+        inputs = self.get_dummy_inputs()
+        inputs["num_frames"] = None
+        inputs["references"] = [MiniMaxH3Reference(image=Image.new("RGB", (48, 80))), _reference_audio(14.99)]
+
+        with pytest.raises(ValueError, match="rounds up to 362 frames"):
+            pipe(**inputs)
+
+    @pytest.mark.parametrize(
+        "references,message",
+        [
+            ([], "at least one reference"),
+            ([_reference_audio(6.0)], "cannot be used"),
+            ([MiniMaxH3Reference(image=Image.new("RGB", (32, 32)))] * 10, "at most 9 image references"),
+            (
+                [MiniMaxH3Reference(image=Image.new("RGB", (32, 32)))] + [_reference_video(2, 32)] * 4,
+                "at most 3 video references",
+            ),
+            ([{"image": Image.new("RGB", (32, 32))}], "must be a \\[`MiniMaxH3Reference`\\]"),
+        ],
+        ids=["no_references", "audio_alone", "too_many_images", "too_many_videos", "dict_entry"],
+    )
+    def test_check_inputs_references(self, references, message):
+        pipe = self.get_pipeline()
+
+        inputs = self.get_dummy_inputs()
+        inputs["references"] = references
+
+        with pytest.raises(ValueError, match=message):
+            pipe(**inputs)
+
+
+class TestMiniMaxH3Reference:
+    """
+    [`MiniMaxH3Reference`] resolves a request's media at construction, before any block sees it.
+
+    None of this needs a pipeline: a reference validates its own modality, decodes a path with PyAV and carries the
+    rates that come with it, which is exactly what makes the blocks able to assume in-memory media throughout.
+    """
+
+    @pytest.mark.parametrize(
+        "kwargs,message",
+        [
+            ({}, "exactly one of"),
+            ({"image": Image.new("RGB", (32, 32)), "video": _video_frames(2, 32)}, "exactly one of"),
+            ({"image": Image.new("RGB", (32, 32)), "audio": _waveform(1.0)}, "exactly one of"),
+            ({"image": "astronaut.png"}, "not a valid path"),
+            ({"video": "motion.mp4"}, "not a valid path"),
+            ({"audio": "voice.wav"}, "not a valid path"),
+        ],
+        ids=[
+            "no_medium",
+            "image_and_video",
+            "image_and_audio",
+            "missing_image_file",
+            "missing_video_file",
+            "missing_audio_file",
+        ],
+    )
+    def test_reference_construction(self, kwargs, message):
+        r"""
+        A reference resolves itself at construction: exactly one medium, bar a video's own soundtrack, and a path that
+        names a file it can actually open.
+        """
+        with pytest.raises(ValueError, match=message):
+            MiniMaxH3Reference(**kwargs)
+
+    def test_reference_decodes_files(self, tmp_path):
+        r"""
+        A reference takes a path as well as in-memory media, and decodes it as it is built: the frames and the samples
+        themselves, plus the rates the container reports, which is what the model conditions on.
+        """
+        video_path, image_path, audio_path = _media_fixtures(tmp_path)
+
+        video = MiniMaxH3Reference(video=str(video_path))
+        image = MiniMaxH3Reference(image=str(image_path))
+        audio = MiniMaxH3Reference(audio=str(audio_path))
+
+        assert video.kind == "video"
+        assert video.video.shape == (FIXTURE_NUM_FRAMES, 32, 64, 3) and video.video.dtype == np.uint8
+        assert video.fps == FIXTURE_FPS
+        # The container carries a soundtrack, which a video reference conditions on as its own.
+        assert video.has_audio and video.audio.shape[0] == 2 and video.sample_rate == FIXTURE_SAMPLE_RATE
+        assert image.kind == "image" and image.image.size == (64, 32)
+        assert audio.kind == "audio" and audio.audio.shape[0] == 2 and audio.sample_rate == FIXTURE_SAMPLE_RATE
+        assert audio.audio.dtype == torch.float32
+
+    def test_reference_silent_file_carries_no_soundtrack(self, tmp_path):
+        r"""There is nothing to adopt from a container without an audio stream."""
+        silent_path = tmp_path / "silent.mp4"
+        _write_video(silent_path, with_audio=False)
+
+        reference = MiniMaxH3Reference(video=str(silent_path))
+
+        assert not reference.has_audio and reference.sample_rate is None
+        assert reference.fps == FIXTURE_FPS
+
+    def test_reference_rates_override_the_container(self, tmp_path):
+        r"""A rate the request passes wins over the one the container reports, whose metadata may be wrong."""
+        video_path, _, audio_path = _media_fixtures(tmp_path)
+
+        video = MiniMaxH3Reference(video=str(video_path), fps=12.0, sample_rate=16000)
+        audio = MiniMaxH3Reference(audio=str(audio_path), sample_rate=16000)
+
+        # The container reports `FIXTURE_FPS` and `FIXTURE_SAMPLE_RATE`, and the request overrides both.
+        assert video.fps == 12.0 and video.sample_rate == 16000
+        assert audio.sample_rate == 16000
+
+    def test_reference_file_needs_pyav(self, tmp_path, monkeypatch):
+        r"""Decoding a video or an audio file is a PyAV job, and says so when PyAV is not installed."""
+        video_path, image_path, audio_path = _media_fixtures(tmp_path)
+        monkeypatch.setattr(packing_ref2va, "is_av_available", lambda: False)
+
+        with pytest.raises(ImportError, match="pip install av"):
+            MiniMaxH3Reference(video=str(video_path))
+        with pytest.raises(ImportError, match="pip install av"):
+            MiniMaxH3Reference(audio=str(audio_path))
+        # An image never needs it.
+        assert MiniMaxH3Reference(image=str(image_path)).image.size == (64, 32)
+
+    def test_reference_defaults(self):
+        r"""A reference knows its own modality, and defaults to MiniMax-H3's own frame rate for its frames."""
+        assert MiniMaxH3Reference(video=_video_frames(2, 32)).fps == float(packing.MINIMAX_H3_FPS)
+        assert MiniMaxH3Reference(image=Image.new("RGB", (32, 32))).kind == "image"
+        assert not MiniMaxH3Reference(image=Image.new("RGB", (32, 32))).has_audio
+        assert _reference_video(2, 32).kind == "video"
+        assert _reference_audio(6.0).kind == "audio"
+        assert _reference_audio(6.0).has_audio
+
+
+class TestMiniMaxH3ReferenceGeometry:
+    """
+    How a reference is prepared, which is pure geometry over the packing module and needs no components.
+
+    These are the passes `MiniMaxH3Ref2VASetupStep` runs a reference through before any VAE sees it.
+    """
+
+    def test_reference_image_geometry(self, monkeypatch):
+        r"""
+        A reference image is encoded at a 2048 pixel short edge, both axes rounded to a multiple of 32, with no area
+        cap. The `small_references` fixture shrinks that short edge for every other test, so restore it here.
+        """
+        monkeypatch.setattr(packing_ref2va, "MINIMAX_H3_REFERENCE_IMAGE_SHORT_EDGE", 2048)
+
+        assert packing_ref2va.resolve_reference_image_size(80, 48) == (2048, 3424)
+        assert packing_ref2va.resolve_reference_image_size(48, 80) == (3424, 2048)
+
+    def test_video_reference_resampled_to_the_model_frame_rate(self):
+        r"""
+        A video reference is resampled onto MiniMax-H3's own 24 fps by dropping and duplicating whole frames, which is
+        what `ffmpeg`'s `fps` filter did in the reference implementation: a frame whose successor rounds onto the same
+        output slot is dropped, so a 30 fps reference loses one frame in five, the later of the two that tie for a
+        slot. Frames already at 24 fps are returned as they are, without a copy.
+        """
+        # Every frame carries its own index as its pixel value, so the resampled frames name the ones that survived.
+        frames = np.arange(30, dtype="uint8").reshape(-1, 1, 1, 1) * np.ones((1, 2, 2, 3), dtype="uint8")
+
+        resampled = packing_ref2va.resample_reference_frames(frames, 30.0)
+
+        assert [int(frame[0, 0, 0]) for frame in resampled] == [
+            index for index in range(30) if index not in (2, 7, 12, 17, 22, 27)
+        ]
+        assert packing_ref2va.resample_reference_frames(frames, float(packing.MINIMAX_H3_FPS)) is frames