diff --git a/README.md b/README.md
index f0fedb7d9..a6126aeaf 100644
--- a/README.md
+++ b/README.md
@@ -15,6 +15,7 @@ API and command-line option may change frequently.***
 
 ## 🔥Important News
 
+* **2026/08/04** 🚀 stable-diffusion.cpp adds **Day-1 support for MiniMax-H3**
 * **2026/06/25** 🚀 stable-diffusion.cpp now supports **Krea2**
 * **2026/06/04** 🚀 stable-diffusion.cpp now supports **Ideogram4**
 * **2026/05/31** 🚀 stable-diffusion.cpp now supports **PiD**
@@ -66,6 +67,7 @@ API and command-line option may change frequently.***
     - [Mage-Flow-Edit](./docs/mage_flow.md#image-editing)
   - Video Models
     - [Wan2.1/Wan2.2](./docs/wan.md)
+    - [MiniMax-H3](./docs/minimax_h3.md)
     - [LTX-2.3](./docs/ltx2.md)
     - [HunyuanVideo 1.5](./docs/hunyuan_video.md)
     - [LingBot-Video](./docs/lingbot_video.md)
diff --git a/assets/minimax-h3/i2av.mp4 b/assets/minimax-h3/i2av.mp4
new file mode 100644
index 000000000..533c9cbfa
Binary files /dev/null and b/assets/minimax-h3/i2av.mp4 differ
diff --git a/assets/minimax-h3/r2av.mp4 b/assets/minimax-h3/r2av.mp4
new file mode 100644
index 000000000..29b496dba
Binary files /dev/null and b/assets/minimax-h3/r2av.mp4 differ
diff --git a/assets/minimax-h3/t2av.mp4 b/assets/minimax-h3/t2av.mp4
new file mode 100644
index 000000000..4694e5fd3
Binary files /dev/null and b/assets/minimax-h3/t2av.mp4 differ
diff --git a/docs/minimax_h3.md b/docs/minimax_h3.md
new file mode 100644
index 000000000..82d0e2ffb
--- /dev/null
+++ b/docs/minimax_h3.md
@@ -0,0 +1,96 @@
+# MiniMax-H3
+
+MiniMax-H3 jointly generates video and stereo audio with a packed diffusion
+transformer. The implementation supports text-to-audio-video (T2VA), optional
+first-frame conditioning (I2VA), first/last-frame conditioning (FL2VA), and
+image/video/audio reference conditioning (Ref2VA).
+
+## Model files
+
+Pass the four MiniMax-H3 components separately:
+
+- `--diffusion-model`: MiniMax-H3 diffusion transformer
+- `--vae`: MiniMax-H3 video VAE
+- `--audio-vae`: MiniMax-H3 audio VAE
+- `--llm`: the MiniMax-H3 Qwen3-VL-32B text encoder checkpoint
+
+The text encoder must be the MiniMax-H3 variant: Qwen3-VL-32B truncated to 50
+language layers and exported without the final language-model normalization.
+Its Qwen3-VL vision tower, including the three DeepStack mergers, must also be
+present. If the vision tower is stored separately, pass it with `--llm_vision`.
+
+Both the original time-embedder DiT and the smaller AdaLN curve-table variant
+are detected from their weights.
+
+### Download weights
+
+- Download minimax_h3_fl2va/minimax_h3_ref2va
+    - safetensors: https://huggingface.co/Comfy-Org/MiniMax-H3/tree/main/diffusion_models
+    - gguf: https://huggingface.co/leejet/MiniMax-H3-GGUF/tree/main
+- Download qwen3vl_32b_minimax_h3
+    - safetensors: https://huggingface.co/Comfy-Org/MiniMax-H3/tree/main/text_encoders
+    - gguf: https://huggingface.co/leejet/MiniMax-H3-GGUF/tree/main
+- Download vae
+    - safetensors: https://huggingface.co/Comfy-Org/MiniMax-H3/tree/main/vae
+- Download audio vae
+    - safetensors: https://huggingface.co/Comfy-Org/MiniMax-H3/tree/main/vae
+
+## Text-to-audio-video
+
+```sh
+.\bin\Release\sd-cli.exe -M vid_gen --diffusion-model  ..\models\diffusion_models\minimax_h3_fl2va-Q4_K_M.gguf --vae ..\models\vae\minimax_h3_video_vae_fp16.safetensors --audio-vae ..\models\vae\minimax_h3_audio_vae_fp32.safetensors --llm ..\models\text_encoders\qwen3vl_32b_minimax_h3-Q4_K_M.gguf -p "A cute American Shorthair silver tabby kitten surfs on a tropical ocean wave, riding a white surfboard with the clear text 'sd.cpp' on it. Cinematic tracking shot, realistic water, bright sunlight, smooth motion, and consistent character appearance. Add upbeat tropical surf-rock background music with cheerful drums and guitar, synchronized with the kitten’s energetic surfing." --cfg-scale 1.0 -v -W 864 -H 480 --diffusion-fa --offload-to-cpu --rng cpu --fps 24 --video-frames 56
+```
+
+<video src=../assets/minimax-h3/t2av.mp4 controls="controls" muted="muted" type="video/mp4"></video>
+
+Omitting `--audio-vae` still runs the joint diffusion model but produces video without a
+decoded audio track.
+
+## First/last-frame conditioning
+
+Add `--init-img` for I2VA, or both `--init-img` and `--end-img` for FL2VA:
+
+```sh
+.\bin\Release\sd-cli.exe -M vid_gen --diffusion-model  ..\models\diffusion_models\minimax_h3_fl2va-Q4_K_M.gguf --vae ..\models\vae\minimax_h3_video_vae_fp16.safetensors --audio-vae ..\models\vae\minimax_h3_audio_vae_fp32.safetensors --llm ..\models\text_encoders\qwen3vl_32b_minimax_h3-Q4_K_M.gguf -p "a lovely cat" -i ..\assets\ernie_image\turbo_example.png --cfg-scale 1.0 -v -W 864 -H 480 --diffusion-fa --offload-to-cpu --rng cpu --fps 24 --video-frames 56
+```
+
+<video src=../assets/minimax-h3/i2av.mp4 controls="controls" muted="muted" type="video/mp4"></video>
+
+## Reference-to-audio-video conditioning
+
+Ref2VA accepts any combination of reference images, reference videos, paired
+video soundtracks, and standalone audio references:
+
+```sh
+.\bin\Release\sd-cli.exe -M vid_gen --diffusion-model  ..\models\diffusion_models\minimax_h3_ref2va_pruned-Q4_K_M.gguf --vae ..\models\vae\minimax_h3_video_vae_fp16.safetensors --audio-vae ..\models\vae\minimax_h3_audio_vae_fp32.safetensors --llm ..\models\text_encoders\qwen3vl_32b_minimax_h3-Q4_K_M.gguf -p "Use the cat from <Picture 1> as the main character. Keep the cat’s appearance, fur color, facial features, and identity consistent with the reference image. Create a 2-second cinematic video: start with an extreme close-up shot of the cat’s face, focusing on its cute expression and detailed fur texture. The camera slowly rotates around the cat’s head, creating a dynamic reveal. Then smoothly pull back and zoom out to reveal the full scene: the cat is standing confidently on a surfboard, riding ocean waves. Water splashes around the board, sea breeze gently moves the cat’s fur, and the cat maintains a cute and fearless expression while surfing. Smooth camera movement, cinematic orbit shot, seamless zoom-out transition, low-angle wide shot, realistic ocean environment, golden sunlight, dynamic waves, high-quality realistic style, natural motion, no distortion, keep the cat’s identity unchanged." -r ..\assets\ernie_image\turbo_example.png --cfg-scale 1.0 -v -W 864 -H 480 --diffusion-fa --offload-to-cpu --rng cpu --fps 24 --video-frames 56
+```
+
+<video src=../assets/minimax-h3/r2av.mp4 controls="controls" muted="muted" type="video/mp4"></video>
+
+`--ref-image`, `--ref-video`, and `--ref-audio` can each be repeated. A
+reference video is a directory of image frames sorted lexicographically and is
+treated as 24 fps. Repeated `--ref-video-audio` WAV files are paired by index
+with repeated `--ref-video` inputs. WAV PCM (8/16/24/32-bit) and 32/64-bit
+floating-point samples are accepted; audio is converted to stereo 32 kHz by the
+pipeline.
+
+Reference inputs are presented to Qwen3-VL in image, video, then audio order.
+Videos are sampled at 2 fps for the Qwen presentation while their full 24 fps
+latents condition the diffusion transformer. Paired video and audio references
+share the same timeline. Ref2VA cannot be combined with `--init-img` or
+`--end-img` in one request.
+
+Reference images keep their aspect ratio and are only downscaled when their
+pixel area exceeds the requested generation canvas.
+
+The C API exposes the same inputs through `ref_images`, `ref_videos`, and
+`ref_audios` in `sd_vid_gen_params_t`. Each `sd_ref_video_t` supplies its own
+frame rate and optional soundtrack; non-24-fps inputs are resampled internally.
+
+## Shape and runtime notes
+
+- Width and height are aligned upward to a multiple of 32.
+- Frame count is aligned upward to the `17k + 5` grid, with a minimum of 5.
+- MiniMax-H3 runs at 24 fps; another requested value is overridden.
+- The default video flow shift is 12. The audio stream is mapped internally to
+  its shift of 3, so the regular samplers can operate on the packed AV latent.
diff --git a/examples/cli/main.cpp b/examples/cli/main.cpp
index af62a9a93..1cc7a7af4 100644
--- a/examples/cli/main.cpp
+++ b/examples/cli/main.cpp
@@ -754,6 +754,18 @@ int main(int argc, const char* argv[]) {
         return true;
     };
 
+    auto load_audio = [&](const std::string& path, SDAudioOwner& audio) -> bool {
+        std::vector<float> samples;
+        uint32_t sample_rate = 0;
+        uint32_t channels    = 0;
+        if (!load_wav_from_file(path, samples, sample_rate, channels)) {
+            LOG_ERROR("load WAV audio from '%s' failed", path.c_str());
+            return false;
+        }
+        audio.reset(std::move(samples), sample_rate, channels);
+        return true;
+    };
+
     if (gen_params.init_image_path.size() > 0) {
         if (!load_image_and_update_size(gen_params.init_image_path, gen_params.init_image)) {
             return 1;
@@ -777,6 +789,37 @@ int main(int argc, const char* argv[]) {
         }
     }
 
+    if (!gen_params.ref_video_paths.empty()) {
+        gen_params.ref_videos.clear();
+        gen_params.ref_videos.reserve(gen_params.ref_video_paths.size());
+        for (const auto& path : gen_params.ref_video_paths) {
+            std::vector<SDImageOwner> frames;
+            if (!load_images_from_dir(path, frames, 0, 0, 0, cli_params.verbose) || frames.empty()) {
+                LOG_ERROR("load reference video frames from '%s' failed", path.c_str());
+                return 1;
+            }
+            gen_params.ref_videos.push_back(std::move(frames));
+        }
+
+        gen_params.ref_video_audios.clear();
+        gen_params.ref_video_audios.resize(gen_params.ref_videos.size());
+        for (size_t i = 0; i < gen_params.ref_video_audio_paths.size(); ++i) {
+            if (!load_audio(gen_params.ref_video_audio_paths[i], gen_params.ref_video_audios[i])) {
+                return 1;
+            }
+        }
+    }
+
+    if (!gen_params.ref_audio_paths.empty()) {
+        gen_params.ref_audios.clear();
+        gen_params.ref_audios.resize(gen_params.ref_audio_paths.size());
+        for (size_t i = 0; i < gen_params.ref_audio_paths.size(); ++i) {
+            if (!load_audio(gen_params.ref_audio_paths[i], gen_params.ref_audios[i])) {
+                return 1;
+            }
+        }
+    }
+
     if (gen_params.mask_image_path.size() > 0) {
         if (!load_sd_image_from_file(gen_params.mask_image.put(),
                                      gen_params.mask_image_path.c_str(),
diff --git a/examples/common/common.cpp b/examples/common/common.cpp
index ceb781430..d6effe5e5 100644
--- a/examples/common/common.cpp
+++ b/examples/common/common.cpp
@@ -1404,6 +1404,30 @@ ArgOptions SDGenerationParams::get_options() {
         return 1;
     };
 
+    auto on_ref_video_arg = [&](int argc, const char** argv, int index) {
+        if (++index >= argc) {
+            return -1;
+        }
+        ref_video_paths.push_back(argv[index]);
+        return 1;
+    };
+
+    auto on_ref_video_audio_arg = [&](int argc, const char** argv, int index) {
+        if (++index >= argc) {
+            return -1;
+        }
+        ref_video_audio_paths.push_back(argv[index]);
+        return 1;
+    };
+
+    auto on_ref_audio_arg = [&](int argc, const char** argv, int index) {
+        if (++index >= argc) {
+            return -1;
+        }
+        ref_audio_paths.push_back(argv[index]);
+        return 1;
+    };
+
     auto on_cache_mode_arg = [&](int argc, const char** argv, int index) {
         if (++index >= argc) {
             return -1;
@@ -1568,8 +1592,20 @@ ArgOptions SDGenerationParams::get_options() {
          on_high_noise_skip_layers_arg},
         {"-r",
          "--ref-image",
-         "reference image for Flux Kontext models (can be used multiple times)",
+         "reference image for Flux Kontext or MiniMax-H3 Ref2VA (can be used multiple times)",
          on_ref_image_arg},
+        {"",
+         "--ref-video",
+         "MiniMax-H3 Ref2VA reference video frame directory at 24 fps (can be used multiple times)",
+         on_ref_video_arg},
+        {"",
+         "--ref-video-audio",
+         "WAV soundtrack paired by index with --ref-video (can be used multiple times)",
+         on_ref_video_audio_arg},
+        {"",
+         "--ref-audio",
+         "standalone WAV reference for MiniMax-H3 Ref2VA (can be used multiple times)",
+         on_ref_audio_arg},
         {"",
          "--cache-mode",
          "caching method: 'easycache' (DiT), 'ucache' (UNET), 'dbcache'/'taylorseer'/'cache-dit' (DiT block-level), 'spectrum' (UNET/DiT Chebyshev+Taylor forecasting)",
@@ -2366,6 +2402,16 @@ bool SDGenerationParams::validate(SDMode mode) {
         return false;
     }
 
+    if (ref_video_audio_paths.size() > ref_video_paths.size()) {
+        LOG_ERROR("error: each --ref-video-audio needs a corresponding --ref-video");
+        return false;
+    }
+
+    if (mode != VID_GEN && (!ref_video_paths.empty() || !ref_video_audio_paths.empty() || !ref_audio_paths.empty())) {
+        LOG_ERROR("error: reference video and audio inputs require vid_gen mode");
+        return false;
+    }
+
     if (sample_params.shifted_timestep < 0 || sample_params.shifted_timestep > 1000) {
         LOG_ERROR("error: shifted_timestep must be in range [0, 1000]");
         return false;
@@ -2560,6 +2606,35 @@ sd_vid_gen_params_t SDGenerationParams::to_sd_vid_gen_params_t() {
         control_frame_views.push_back(frame.get());
     }
 
+    ref_image_views.clear();
+    ref_image_views.reserve(ref_images.size());
+    for (auto& image : ref_images) {
+        ref_image_views.push_back(image.get());
+    }
+
+    ref_video_frame_views.clear();
+    ref_video_frame_views.resize(ref_videos.size());
+    ref_video_views.clear();
+    ref_video_views.reserve(ref_videos.size());
+    for (size_t i = 0; i < ref_videos.size(); ++i) {
+        auto& frame_views = ref_video_frame_views[i];
+        frame_views.reserve(ref_videos[i].size());
+        for (auto& frame : ref_videos[i]) {
+            frame_views.push_back(frame.get());
+        }
+        sd_audio_t audio = i < ref_video_audios.size() ? ref_video_audios[i].get() : sd_audio_t{};
+        ref_video_views.push_back({frame_views.empty() ? nullptr : frame_views.data(),
+                                   static_cast<int>(frame_views.size()),
+                                   24,
+                                   audio});
+    }
+
+    ref_audio_views.clear();
+    ref_audio_views.reserve(ref_audios.size());
+    for (auto& audio : ref_audios) {
+        ref_audio_views.push_back(audio.get());
+    }
+
     sample_params.guidance.slg.layers                 = skip_layers.empty() ? nullptr : skip_layers.data();
     sample_params.guidance.slg.layer_count            = skip_layers.size();
     high_noise_sample_params.guidance.slg.layers      = high_noise_skip_layers.empty() ? nullptr : high_noise_skip_layers.data();
@@ -2578,6 +2653,12 @@ sd_vid_gen_params_t SDGenerationParams::to_sd_vid_gen_params_t() {
     params.clip_skip                 = clip_skip;
     params.init_image                = init_image.get();
     params.end_image                 = end_image.get();
+    params.ref_images                = ref_image_views.empty() ? nullptr : ref_image_views.data();
+    params.ref_images_count          = static_cast<int>(ref_image_views.size());
+    params.ref_videos                = ref_video_views.empty() ? nullptr : ref_video_views.data();
+    params.ref_videos_count          = static_cast<int>(ref_video_views.size());
+    params.ref_audios                = ref_audio_views.empty() ? nullptr : ref_audio_views.data();
+    params.ref_audios_count          = static_cast<int>(ref_audio_views.size());
     params.control_frames            = control_frame_views.empty() ? nullptr : control_frame_views.data();
     params.control_frames_size       = static_cast<int>(control_frame_views.size());
     params.width                     = get_resolved_width();
@@ -2657,6 +2738,9 @@ std::string SDGenerationParams::to_string() const {
         << "  mask_image_path: \"" << mask_image_path << "\",\n"
         << "  control_image_path: \"" << control_image_path << "\",\n"
         << "  ref_image_paths: " << vec_str_to_string(ref_image_paths) << ",\n"
+        << "  ref_video_paths: " << vec_str_to_string(ref_video_paths) << ",\n"
+        << "  ref_video_audio_paths: " << vec_str_to_string(ref_video_audio_paths) << ",\n"
+        << "  ref_audio_paths: " << vec_str_to_string(ref_audio_paths) << ",\n"
         << "  control_video_path: \"" << control_video_path << "\",\n"
         << "  auto_resize_ref_image: " << (auto_resize_ref_image ? "true" : "false") << ",\n"
         << "  increase_ref_index: " << (increase_ref_index ? "true" : "false") << ",\n"
diff --git a/examples/common/common.h b/examples/common/common.h
index ea90c8c1b..34b4a013b 100644
--- a/examples/common/common.h
+++ b/examples/common/common.h
@@ -212,6 +212,9 @@ struct SDGenerationParams {
     std::string control_image_path;
     std::string ip_adapter_image_path;
     std::vector<std::string> ref_image_paths;
+    std::vector<std::string> ref_video_paths;
+    std::vector<std::string> ref_video_audio_paths;
+    std::vector<std::string> ref_audio_paths;
     std::string control_video_path;
 
     sd_sample_params_t sample_params;
@@ -275,6 +278,9 @@ struct SDGenerationParams {
     SDImageOwner init_image;
     SDImageOwner end_image;
     std::vector<SDImageOwner> ref_images;
+    std::vector<std::vector<SDImageOwner>> ref_videos;
+    std::vector<SDAudioOwner> ref_video_audios;
+    std::vector<SDAudioOwner> ref_audios;
     SDImageOwner mask_image;
     SDImageOwner control_image;
     SDImageOwner ip_adapter_image;
@@ -283,6 +289,9 @@ struct SDGenerationParams {
 
     // Backing storage for sd_img_gen_params_t view fields.
     std::vector<sd_image_t> ref_image_views;
+    std::vector<std::vector<sd_image_t>> ref_video_frame_views;
+    std::vector<sd_ref_video_t> ref_video_views;
+    std::vector<sd_audio_t> ref_audio_views;
     std::vector<sd_image_t> pm_id_image_views;
     std::vector<sd_image_t> control_frame_views;
 
diff --git a/examples/common/media_io.cpp b/examples/common/media_io.cpp
index 506c67f4d..812a8c80e 100644
--- a/examples/common/media_io.cpp
+++ b/examples/common/media_io.cpp
@@ -1374,3 +1374,132 @@ bool write_wav_to_file(const std::string& path,
     file.write(reinterpret_cast<const char*>(pcm.data()), static_cast<std::streamsize>(pcm.size() * sizeof(int16_t)));
     return file.good();
 }
+
+static uint16_t read_le16(const uint8_t* data) {
+    return static_cast<uint16_t>(data[0]) |
+           (static_cast<uint16_t>(data[1]) << 8);
+}
+
+static uint32_t read_le32(const uint8_t* data) {
+    return static_cast<uint32_t>(data[0]) |
+           (static_cast<uint32_t>(data[1]) << 8) |
+           (static_cast<uint32_t>(data[2]) << 16) |
+           (static_cast<uint32_t>(data[3]) << 24);
+}
+
+bool load_wav_from_file(const std::string& path,
+                        std::vector<float>& interleaved_samples,
+                        uint32_t& sample_rate,
+                        uint32_t& channels) {
+    interleaved_samples.clear();
+    sample_rate = 0;
+    channels    = 0;
+
+    std::ifstream file(path, std::ios::binary);
+    uint8_t riff_header[12];
+    if (!file.read(reinterpret_cast<char*>(riff_header), sizeof(riff_header)) ||
+        std::memcmp(riff_header, "RIFF", 4) != 0 ||
+        std::memcmp(riff_header + 8, "WAVE", 4) != 0) {
+        return false;
+    }
+
+    uint16_t audio_format    = 0;
+    uint16_t bits_per_sample = 0;
+    uint16_t block_align     = 0;
+    std::streampos data_pos  = std::streampos(-1);
+    uint32_t data_size       = 0;
+
+    while (file.good()) {
+        uint8_t chunk_header[8];
+        if (!file.read(reinterpret_cast<char*>(chunk_header), sizeof(chunk_header))) {
+            break;
+        }
+        uint32_t chunk_size           = read_le32(chunk_header + 4);
+        std::streampos chunk_data_pos = file.tellg();
+
+        if (std::memcmp(chunk_header, "fmt ", 4) == 0) {
+            if (chunk_size < 16) {
+                return false;
+            }
+            std::vector<uint8_t> fmt(chunk_size);
+            if (!file.read(reinterpret_cast<char*>(fmt.data()), chunk_size)) {
+                return false;
+            }
+            audio_format    = read_le16(fmt.data());
+            channels        = read_le16(fmt.data() + 2);
+            sample_rate     = read_le32(fmt.data() + 4);
+            block_align     = read_le16(fmt.data() + 12);
+            bits_per_sample = read_le16(fmt.data() + 14);
+            if (audio_format == 0xfffe && chunk_size >= 40) {
+                audio_format = read_le16(fmt.data() + 24);
+            }
+        } else if (std::memcmp(chunk_header, "data", 4) == 0) {
+            data_pos  = chunk_data_pos;
+            data_size = chunk_size;
+            file.seekg(chunk_size, std::ios::cur);
+        } else {
+            file.seekg(chunk_size, std::ios::cur);
+        }
+
+        if (!file.good()) {
+            break;
+        }
+        if ((chunk_size & 1) != 0) {
+            file.seekg(1, std::ios::cur);
+        }
+    }
+
+    const uint32_t bytes_per_sample = (bits_per_sample + 7) / 8;
+    if (data_pos == std::streampos(-1) || data_size == 0 || channels == 0 || sample_rate == 0 ||
+        block_align == 0 || bytes_per_sample == 0 || block_align < channels * bytes_per_sample ||
+        (audio_format != 1 && audio_format != 3)) {
+        return false;
+    }
+
+    const uint64_t frame_count = data_size / block_align;
+    if (frame_count == 0 || frame_count > SIZE_MAX / channels) {
+        return false;
+    }
+    std::vector<uint8_t> pcm(data_size);
+    file.clear();
+    file.seekg(data_pos);
+    if (!file.read(reinterpret_cast<char*>(pcm.data()), data_size)) {
+        return false;
+    }
+
+    interleaved_samples.resize(static_cast<size_t>(frame_count * channels));
+    for (uint64_t frame = 0; frame < frame_count; ++frame) {
+        const uint8_t* frame_data = pcm.data() + frame * block_align;
+        for (uint32_t channel = 0; channel < channels; ++channel) {
+            const uint8_t* sample_data = frame_data + channel * bytes_per_sample;
+            float sample               = 0.0f;
+            if (audio_format == 3 && bits_per_sample == 32) {
+                std::memcpy(&sample, sample_data, sizeof(sample));
+            } else if (audio_format == 3 && bits_per_sample == 64) {
+                double value;
+                std::memcpy(&value, sample_data, sizeof(value));
+                sample = static_cast<float>(value);
+            } else if (audio_format == 1 && bits_per_sample == 8) {
+                sample = (static_cast<int>(sample_data[0]) - 128) / 128.0f;
+            } else if (audio_format == 1 && bits_per_sample == 16) {
+                sample = static_cast<int16_t>(read_le16(sample_data)) / 32768.0f;
+            } else if (audio_format == 1 && bits_per_sample == 24) {
+                int32_t value = static_cast<int32_t>(sample_data[0]) |
+                                (static_cast<int32_t>(sample_data[1]) << 8) |
+                                (static_cast<int32_t>(sample_data[2]) << 16);
+                if ((value & 0x800000) != 0) {
+                    value |= ~0xffffff;
+                }
+                sample = value / 8388608.0f;
+            } else if (audio_format == 1 && bits_per_sample == 32) {
+                int32_t value = static_cast<int32_t>(read_le32(sample_data));
+                sample        = value / 2147483648.0f;
+            } else {
+                interleaved_samples.clear();
+                return false;
+            }
+            interleaved_samples[static_cast<size_t>(frame * channels + channel)] = sample;
+        }
+    }
+    return true;
+}
diff --git a/examples/common/media_io.h b/examples/common/media_io.h
index 0f7679d7f..52b9221a2 100644
--- a/examples/common/media_io.h
+++ b/examples/common/media_io.h
@@ -110,4 +110,9 @@ bool write_wav_to_file(const std::string& path,
                        uint32_t channels,
                        uint32_t sample_rate);
 
+bool load_wav_from_file(const std::string& path,
+                        std::vector<float>& interleaved_samples,
+                        uint32_t& sample_rate,
+                        uint32_t& channels);
+
 #endif  // __MEDIA_IO_H__
diff --git a/examples/common/resource_owners.hpp b/examples/common/resource_owners.hpp
index d7525a5fa..73f8bdd81 100644
--- a/examples/common/resource_owners.hpp
+++ b/examples/common/resource_owners.hpp
@@ -141,6 +141,37 @@ class SDImageOwner {
     }
 };
 
+class SDAudioOwner {
+private:
+    uint32_t sample_rate_ = 0;
+    uint32_t channels_    = 0;
+    std::vector<float> samples_;
+
+public:
+    SDAudioOwner() = default;
+
+    void reset(std::vector<float> samples = {}, uint32_t sample_rate = 0, uint32_t channels = 0) {
+        samples_     = std::move(samples);
+        sample_rate_ = sample_rate;
+        channels_    = channels;
+    }
+
+    bool empty() const {
+        return samples_.empty();
+    }
+
+    sd_audio_t get() {
+        return {sample_rate_,
+                channels_,
+                channels_ == 0 ? 0 : static_cast<uint64_t>(samples_.size() / channels_),
+                samples_.empty() ? nullptr : samples_.data()};
+    }
+
+    const std::vector<float>& samples() const {
+        return samples_;
+    }
+};
+
 class SDImageVec {
 private:
     std::vector<sd_image_t> images_;
diff --git a/include/stable-diffusion.h b/include/stable-diffusion.h
index bd568c686..22fbc05e4 100644
--- a/include/stable-diffusion.h
+++ b/include/stable-diffusion.h
@@ -246,6 +246,13 @@ typedef struct {
     uint8_t* data;
 } sd_image_t;
 
+typedef struct {
+    sd_image_t* frames;
+    int frame_count;
+    int fps;
+    sd_audio_t audio;
+} sd_ref_video_t;
+
 typedef struct {
     int* layers;
     size_t layer_count;
@@ -396,6 +403,12 @@ typedef struct {
     int clip_skip;
     sd_image_t init_image;
     sd_image_t end_image;
+    sd_image_t* ref_images;
+    int ref_images_count;
+    sd_ref_video_t* ref_videos;
+    int ref_videos_count;
+    sd_audio_t* ref_audios;
+    int ref_audios_count;
     sd_image_t* control_frames;
     int control_frames_size;
     int width;
diff --git a/scripts/merge_safetensors.py b/scripts/merge_safetensors.py
new file mode 100644
index 000000000..aebae3065
--- /dev/null
+++ b/scripts/merge_safetensors.py
@@ -0,0 +1,335 @@
+#!/usr/bin/env python3
+"""Merge selected tensors from multiple safetensors files without loading weights.
+
+Edit ``OUTPUT_PATH`` and ``SOURCE_RULES`` below, then run:
+
+    python scripts/merge_safetensors.py
+
+Each source rule uses regular expressions against complete tensor names.
+``include`` is required and matches when any expression succeeds. ``exclude``
+wins over ``include``. Expressions are evaluated with ``re.search``.
+"""
+
+import json
+import os
+import re
+import struct
+from dataclasses import dataclass
+from pathlib import Path
+from typing import BinaryIO
+
+
+# -----------------------------------------------------------------------------
+# Configuration
+# -----------------------------------------------------------------------------
+
+OUTPUT_PATH = Path(r"..\models\diffusion_models\minimax_h3_ref2va_pruned_bf16.safetensors")
+
+SOURCE_RULES = [
+    {
+        "path": Path(r"..\models\diffusion_models\minimax_h3_ref2va_bf16.safetensors"),
+        "include": [r".*"],
+        "exclude": [r".*adaln_proj\.linear.*", r"time_embedder.*"],
+    },
+    {
+        "path": Path(r"..\models\diffusion_models\minimax_h3_ref2va_pruned_int8_convrot.safetensors"),
+        "include": [r"^.*adaln_proj\.linear.*", "adaln_t_table"],
+        "exclude": [],
+    },
+]
+
+# Safetensors metadata is optional. Set this to a dict[str, str] if needed.
+OUTPUT_METADATA = None
+
+# Refuse to replace an existing output unless explicitly enabled.
+OVERWRITE_OUTPUT = False
+
+# Only tensor headers and this fixed-size buffer are held in memory.
+COPY_BUFFER_SIZE = 8 * 1024 * 1024
+PROGRESS_INTERVAL = 1024 * 1024 * 1024
+MAX_HEADER_SIZE = 256 * 1024 * 1024
+
+
+@dataclass(frozen=True)
+class TensorEntry:
+    name: str
+    source_path: Path
+    source_data_offset: int
+    source_start: int
+    source_end: int
+    dtype: str
+    shape: list[int]
+
+    @property
+    def size(self) -> int:
+        return self.source_end - self.source_start
+
+
+def format_bytes(size: int) -> str:
+    value = float(size)
+    for unit in ("B", "KiB", "MiB", "GiB", "TiB"):
+        if value < 1024.0 or unit == "TiB":
+            return f"{value:.2f} {unit}"
+        value /= 1024.0
+    raise AssertionError("unreachable")
+
+
+def read_exact(file: BinaryIO, size: int, description: str) -> bytes:
+    data = file.read(size)
+    if len(data) != size:
+        raise ValueError(f"truncated {description}: expected {size} bytes, got {len(data)}")
+    return data
+
+
+def read_safetensors_header(path: Path) -> tuple[dict, int, int]:
+    file_size = path.stat().st_size
+    with path.open("rb") as file:
+        header_size = struct.unpack("<Q", read_exact(file, 8, f"header size in {path}"))[0]
+        if header_size == 0 or header_size > MAX_HEADER_SIZE:
+            raise ValueError(
+                f"invalid header size in {path}: {header_size} "
+                f"(limit: {MAX_HEADER_SIZE})"
+            )
+        header_bytes = read_exact(file, header_size, f"header in {path}")
+
+    try:
+        header = json.loads(header_bytes)
+    except (UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise ValueError(f"invalid safetensors JSON header in {path}: {error}") from error
+    if not isinstance(header, dict):
+        raise ValueError(f"safetensors header in {path} is not an object")
+
+    data_offset = 8 + header_size
+    if data_offset > file_size:
+        raise ValueError(f"safetensors data offset is past end of file: {path}")
+    return header, data_offset, file_size
+
+
+def parse_tensor_entry(
+    name: str,
+    info: object,
+    source_path: Path,
+    source_data_offset: int,
+    source_file_size: int,
+) -> TensorEntry:
+    if not isinstance(info, dict):
+        raise ValueError(f"{source_path}: tensor {name!r} has an invalid header entry")
+
+    dtype = info.get("dtype")
+    shape = info.get("shape")
+    offsets = info.get("data_offsets")
+    if not isinstance(dtype, str):
+        raise ValueError(f"{source_path}: tensor {name!r} has an invalid dtype")
+    if not isinstance(shape, list) or not all(
+        isinstance(dimension, int) and dimension >= 0 for dimension in shape
+    ):
+        raise ValueError(f"{source_path}: tensor {name!r} has an invalid shape")
+    if (
+        not isinstance(offsets, list)
+        or len(offsets) != 2
+        or not all(isinstance(offset, int) for offset in offsets)
+    ):
+        raise ValueError(f"{source_path}: tensor {name!r} has invalid data offsets")
+
+    start, end = offsets
+    if start < 0 or end < start or source_data_offset + end > source_file_size:
+        raise ValueError(
+            f"{source_path}: tensor {name!r} byte range [{start}, {end}) "
+            "is outside the file"
+        )
+
+    return TensorEntry(
+        name=name,
+        source_path=source_path,
+        source_data_offset=source_data_offset,
+        source_start=start,
+        source_end=end,
+        dtype=dtype,
+        shape=list(shape),
+    )
+
+
+def compile_patterns(rule_index: int, field: str, values: object) -> list[re.Pattern[str]]:
+    if not isinstance(values, list) or not all(isinstance(value, str) for value in values):
+        raise TypeError(f"SOURCE_RULES[{rule_index}][{field!r}] must be a list of strings")
+    try:
+        return [re.compile(value) for value in values]
+    except re.error as error:
+        raise ValueError(
+            f"invalid regex in SOURCE_RULES[{rule_index}][{field!r}]: {error}"
+        ) from error
+
+
+def collect_entries() -> list[TensorEntry]:
+    if not SOURCE_RULES:
+        raise ValueError("SOURCE_RULES must contain at least one source")
+
+    entries: list[TensorEntry] = []
+    selected_by_name: dict[str, TensorEntry] = {}
+    header_cache: dict[Path, tuple[dict, int, int]] = {}
+
+    for rule_index, rule in enumerate(SOURCE_RULES):
+        if not isinstance(rule, dict) or "path" not in rule or "include" not in rule:
+            raise TypeError(
+                f"SOURCE_RULES[{rule_index}] must contain 'path' and 'include'"
+            )
+
+        source_path = Path(rule["path"])
+        if not source_path.is_file():
+            raise FileNotFoundError(f"source file does not exist: {source_path}")
+        source_path = source_path.resolve()
+
+        include = compile_patterns(rule_index, "include", rule["include"])
+        exclude = compile_patterns(rule_index, "exclude", rule.get("exclude", []))
+        if not include:
+            raise ValueError(f"SOURCE_RULES[{rule_index}]['include'] must not be empty")
+
+        if source_path not in header_cache:
+            header_cache[source_path] = read_safetensors_header(source_path)
+        header, data_offset, file_size = header_cache[source_path]
+
+        matched = 0
+        for name, info in header.items():
+            if name == "__metadata__":
+                continue
+            if not any(pattern.search(name) for pattern in include):
+                continue
+            if any(pattern.search(name) for pattern in exclude):
+                continue
+
+            entry = parse_tensor_entry(name, info, source_path, data_offset, file_size)
+            previous = selected_by_name.get(name)
+            if previous is not None:
+                raise ValueError(
+                    f"tensor {name!r} was selected more than once:\n"
+                    f"  first:  {previous.source_path}\n"
+                    f"  second: {source_path}"
+                )
+            selected_by_name[name] = entry
+            print(f"entry {entry}")
+            entries.append(entry)
+            matched += 1
+
+        print(f"Rule {rule_index}: selected {matched} tensors from {source_path}")
+        if matched == 0:
+            raise ValueError(
+                f"SOURCE_RULES[{rule_index}] did not select any tensors; check its regexes"
+            )
+
+    if not entries:
+        raise ValueError("no tensors were selected")
+    return entries
+
+
+def build_output_header(entries: list[TensorEntry]) -> tuple[bytes, int]:
+    header: dict[str, object] = {}
+    if OUTPUT_METADATA is not None:
+        if not isinstance(OUTPUT_METADATA, dict) or not all(
+            isinstance(key, str) and isinstance(value, str)
+            for key, value in OUTPUT_METADATA.items()
+        ):
+            raise TypeError("OUTPUT_METADATA must be None or a dict[str, str]")
+        header["__metadata__"] = OUTPUT_METADATA
+
+    output_offset = 0
+    for entry in entries:
+        header[entry.name] = {
+            "dtype": entry.dtype,
+            "shape": entry.shape,
+            "data_offsets": [output_offset, output_offset + entry.size],
+        }
+        output_offset += entry.size
+
+    header_bytes = json.dumps(header, separators=(",", ":"), ensure_ascii=False).encode(
+        "utf-8"
+    )
+    header_bytes += b" " * (-len(header_bytes) % 8)
+    return header_bytes, output_offset
+
+
+def copy_tensor(source: BinaryIO, output: BinaryIO, entry: TensorEntry) -> None:
+    source.seek(entry.source_data_offset + entry.source_start)
+    remaining = entry.size
+    while remaining:
+        chunk = source.read(min(COPY_BUFFER_SIZE, remaining))
+        if not chunk:
+            raise OSError(
+                f"unexpected end of file while copying {entry.name!r} "
+                f"from {entry.source_path}"
+            )
+        output.write(chunk)
+        remaining -= len(chunk)
+
+
+def write_output(entries: list[TensorEntry]) -> None:
+    if COPY_BUFFER_SIZE <= 0:
+        raise ValueError("COPY_BUFFER_SIZE must be positive")
+
+    output_path = OUTPUT_PATH.resolve()
+    source_paths = {entry.source_path.resolve() for entry in entries}
+    if output_path in source_paths:
+        raise ValueError("OUTPUT_PATH must not be one of the source files")
+    if output_path.exists() and not OVERWRITE_OUTPUT:
+        raise FileExistsError(
+            f"output already exists: {output_path}; set OVERWRITE_OUTPUT = True to replace it"
+        )
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    partial_path = output_path.with_name(output_path.name + ".partial")
+    if partial_path.exists():
+        raise FileExistsError(
+            f"partial output already exists: {partial_path}; remove it before retrying"
+        )
+
+    header_bytes, tensor_bytes = build_output_header(entries)
+    print(
+        f"Writing {len(entries)} tensors ({format_bytes(tensor_bytes)}) to {output_path}"
+    )
+
+    current_source_path: Path | None = None
+    current_source: BinaryIO | None = None
+    copied = 0
+    next_progress = PROGRESS_INTERVAL
+    try:
+        with partial_path.open("xb") as output:
+            output.write(struct.pack("<Q", len(header_bytes)))
+            output.write(header_bytes)
+
+            try:
+                for entry in entries:
+                    if entry.source_path != current_source_path:
+                        if current_source is not None:
+                            current_source.close()
+                        current_source = entry.source_path.open("rb")
+                        current_source_path = entry.source_path
+
+                    copy_tensor(current_source, output, entry)
+                    copied += entry.size
+                    if PROGRESS_INTERVAL > 0 and copied >= next_progress:
+                        print(
+                            f"  copied {format_bytes(copied)} / "
+                            f"{format_bytes(tensor_bytes)}"
+                        )
+                        while next_progress <= copied:
+                            next_progress += PROGRESS_INTERVAL
+            finally:
+                if current_source is not None:
+                    current_source.close()
+
+        if copied != tensor_bytes:
+            raise OSError(f"copied {copied} tensor bytes, expected {tensor_bytes}")
+        os.replace(partial_path, output_path)
+    except BaseException:
+        partial_path.unlink(missing_ok=True)
+        raise
+
+    print(f"Done: {output_path} ({format_bytes(output_path.stat().st_size)})")
+
+
+def main() -> None:
+    entries = collect_entries()
+    write_output(entries)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/conditioning/conditioner.hpp b/src/conditioning/conditioner.hpp
index 0b1f0d351..3d7ff0397 100644
--- a/src/conditioning/conditioner.hpp
+++ b/src/conditioning/conditioner.hpp
@@ -2,8 +2,10 @@
 #define __SD_CONDITIONING_CONDITIONER_HPP__
 
 #include <cmath>
+#include <iomanip>
 #include <limits>
 #include <optional>
+#include <sstream>
 
 #include "core/tensor_ggml.hpp"
 #include "core/util.h"
@@ -25,6 +27,8 @@ struct SDCondition {
     sd::Tensor<int32_t> c_vinput_mask;
     std::vector<std::pair<int, sd::Tensor<float>>> c_image_embeds;
     std::vector<sd::Tensor<float>> c_ref_images;
+    std::vector<sd::Tensor<float>> c_ref_audios;
+    std::vector<MiniMaxH3ReferenceBlock> c_reference_blocks;
 
     std::vector<sd::Tensor<float>> extra_c_crossattns;
 
@@ -55,6 +59,12 @@ struct SDCondition {
             }
         }
 
+        for (const auto& tensor : c_ref_audios) {
+            if (!tensor.empty()) {
+                return false;
+            }
+        }
+
         for (const auto& tensor : extra_c_crossattns) {
             if (!tensor.empty()) {
                 return false;
@@ -65,6 +75,18 @@ struct SDCondition {
     }
 };
 
+enum class MiniMaxH3PresentationKind {
+    IMAGE,
+    VIDEO,
+    AUDIO,
+};
+
+struct MiniMaxH3PresentationItem {
+    MiniMaxH3PresentationKind kind = MiniMaxH3PresentationKind::IMAGE;
+    std::vector<sd::Tensor<float>> frames;
+    std::vector<float> timestamps;
+};
+
 static inline sd::Tensor<float> apply_token_weights(sd::Tensor<float> hidden_states,
                                                     const std::vector<float>& weights) {
     if (hidden_states.empty()) {
@@ -102,11 +124,12 @@ static inline sd::Tensor<float> apply_token_weights(sd::Tensor<float> hidden_sta
 
 struct ConditionerParams {
     std::string text;
-    int clip_skip                                    = -1;
-    int width                                        = -1;
-    int height                                       = -1;
-    bool zero_out_masked                             = false;
-    const std::vector<sd::Tensor<float>>* ref_images = nullptr;  // for qwen image edit
+    int clip_skip                                                       = -1;
+    int width                                                           = -1;
+    int height                                                          = -1;
+    bool zero_out_masked                                                = false;
+    const std::vector<sd::Tensor<float>>* ref_images                    = nullptr;  // for qwen image edit
+    const std::vector<MiniMaxH3PresentationItem>* minimax_h3_references = nullptr;
     RefImageParams ref_image_params;
 };
 
@@ -1810,6 +1833,7 @@ struct LLMEmbedder : public Conditioner {
                    sd_version_is_boogu_image(version) ||
                    sd_version_is_sefi_image(version) ||
                    sd_version_is_krea2(version) ||
+                   sd_version_is_minimax_h3(version) ||
                    sd_version_is_mage_flow(version)) {
             arch = LLM::LLMArch::QWEN3_VL;
         } else if (sd_version_is_z_image(version) || version == VERSION_OVIS_IMAGE || version == VERSION_FLUX2_KLEIN) {
@@ -1992,8 +2016,10 @@ struct LLMEmbedder : public Conditioner {
                                     const std::vector<std::pair<int, sd::Tensor<float>>>& image_embeds,
                                     const std::set<int>& out_layers,
                                     int prompt_template_encode_start_idx,
-                                    bool spell_quotes = false,
-                                    int max_length    = 100000000) {
+                                    bool spell_quotes                                       = false,
+                                    int max_length                                          = 100000000,
+                                    const LLM::DeepStackImageEmbeds& deepstack_image_embeds = {},
+                                    const std::vector<LLM::ImageGrid>& image_grids          = {}) {
         auto tokens_weights_mask = tokenize(prompt, prompt_attn_range, min_length, max_length, spell_quotes);
         auto& tokens             = std::get<0>(tokens_weights_mask);
         auto& weights            = std::get<1>(tokens_weights_mask);
@@ -2026,7 +2052,9 @@ struct LLMEmbedder : public Conditioner {
                                           false,
                                           false,
                                           true,
-                                          true);
+                                          true,
+                                          deepstack_image_embeds,
+                                          image_grids);
         GGML_ASSERT(!hidden_states.empty());
         hidden_states = apply_token_weights(std::move(hidden_states), weights);
         GGML_ASSERT(hidden_states.shape()[1] > prompt_template_encode_start_idx);
@@ -2108,6 +2136,8 @@ struct LLMEmbedder : public Conditioner {
         std::vector<std::string> extra_prompts;
         std::vector<std::pair<int, int>> extra_prompts_attn_range;
         std::vector<std::pair<int, sd::Tensor<float>>> image_embeds;
+        LLM::DeepStackImageEmbeds deepstack_image_embeds;
+        std::vector<LLM::ImageGrid> image_grids;
         int prompt_template_encode_start_idx = 34;
         int min_length                       = 0;  // pad tokens
         int max_length                       = 100000000;
@@ -2118,7 +2148,131 @@ struct LLMEmbedder : public Conditioner {
         int64_t t0                     = ggml_time_ms();
         RefImageResizeMode resize_mode = conditioner_params.ref_image_params.vlm_resize_mode;
 
-        if (sd_version_is_hunyuan_video(version)) {
+        if (sd_version_is_minimax_h3(version)) {
+            prompt_template_encode_start_idx = 0;
+            out_layers                       = {50};
+            prompt_attn_range                = {0, 0};
+
+            if (llm->enable_vision) {
+                const std::string placeholder = "<|image_pad|>";
+                const int patch_size          = llm->config.vision.patch_size;
+                const int factor              = patch_size * llm->config.vision.spatial_merge_size;
+
+                auto resize_for_vision = [&](const sd::Tensor<float>& image) {
+                    int height = static_cast<int>(image.shape()[1]);
+                    int width  = static_cast<int>(image.shape()[0]);
+                    int h_bar  = std::max(factor, static_cast<int>(std::round(static_cast<double>(height) / factor)) * factor);
+                    int w_bar  = std::max(factor, static_cast<int>(std::round(static_cast<double>(width) / factor)) * factor);
+                    resize_image_dims(height,
+                                      width,
+                                      h_bar,
+                                      w_bar,
+                                      factor,
+                                      3136,
+                                      12845056,
+                                      RefImageResizeMode::AREA);
+                    auto resized = sd::ops::interpolate(
+                        image,
+                        std::vector<int64_t>{w_bar, h_bar, image.shape()[2], image.shape()[3]});
+                    for (int64_t i = 0; i < resized.numel(); ++i) {
+                        resized[i] = std::clamp(resized[i], 0.f, 1.f) * 2.f - 1.f;
+                    }
+                    return resized;
+                };
+
+                auto add_vision_outputs = [&](std::vector<sd::Tensor<float>> image_outputs,
+                                              int grid_h,
+                                              int grid_w) {
+                    GGML_ASSERT(image_outputs.size() == 4);
+                    auto image_embed = std::move(image_outputs[0]);
+                    prompt += "<|vision_start|>";
+                    int image_embed_idx = static_cast<int>(tokenizer->encode(prompt, nullptr).size());
+                    image_embeds.emplace_back(image_embed_idx, image_embed);
+                    if (deepstack_image_embeds.empty()) {
+                        deepstack_image_embeds.resize(image_outputs.size() - 1);
+                    }
+                    for (size_t layer = 0; layer < deepstack_image_embeds.size(); ++layer) {
+                        deepstack_image_embeds[layer].emplace_back(image_embed_idx, std::move(image_outputs[layer + 1]));
+                    }
+                    image_grids.push_back({image_embed_idx,
+                                           static_cast<int>(image_embed.shape()[1]),
+                                           grid_h,
+                                           grid_w});
+                    for (int64_t i = 0; i < image_embed.shape()[1]; ++i) {
+                        prompt += placeholder;
+                    }
+                    prompt += "<|vision_end|>";
+                };
+
+                const auto* references = conditioner_params.minimax_h3_references;
+                if (references != nullptr && !references->empty()) {
+                    int picture_index = 0;
+                    int video_index   = 0;
+                    int audio_index   = 0;
+                    for (const auto& item : *references) {
+                        if (item.kind == MiniMaxH3PresentationKind::AUDIO) {
+                            prompt += "<Audio " + std::to_string(++audio_index) + ">: ";
+                            continue;
+                        }
+                        if (item.kind == MiniMaxH3PresentationKind::IMAGE) {
+                            GGML_ASSERT(item.frames.size() == 1);
+                            auto resized = resize_for_vision(item.frames[0]);
+                            prompt += "<Picture " + std::to_string(++picture_index) + ">: ";
+                            add_vision_outputs(llm->encode_image_outputs(n_threads,
+                                                                         resized,
+                                                                         false,
+                                                                         true,
+                                                                         true),
+                                               static_cast<int>(resized.shape()[1]) / patch_size,
+                                               static_cast<int>(resized.shape()[0]) / patch_size);
+                            continue;
+                        }
+
+                        GGML_ASSERT(!item.frames.empty());
+                        prompt += "<Video " + std::to_string(++video_index) + ">: ";
+                        for (size_t frame = 0; frame < item.frames.size(); frame += 2) {
+                            size_t next = std::min(frame + 1, item.frames.size() - 1);
+                            float t0    = frame < item.timestamps.size() ? item.timestamps[frame] : frame / 2.f;
+                            float t1    = next < item.timestamps.size() ? item.timestamps[next] : next / 2.f;
+                            std::ostringstream timestamp;
+                            timestamp << '<' << std::fixed << std::setprecision(1) << (t0 + t1) * 0.5f << " seconds>";
+                            prompt += timestamp.str();
+
+                            auto first  = resize_for_vision(item.frames[frame]);
+                            auto second = resize_for_vision(item.frames[next]);
+                            if (first.shape()[0] != second.shape()[0] || first.shape()[1] != second.shape()[1]) {
+                                second = sd::ops::interpolate(second,
+                                                              std::vector<int64_t>{first.shape()[0],
+                                                                                   first.shape()[1],
+                                                                                   second.shape()[2],
+                                                                                   second.shape()[3]});
+                            }
+                            auto pair = sd::ops::concat(first.unsqueeze(2), second.unsqueeze(2), 2);
+                            add_vision_outputs(llm->encode_video_block_outputs(n_threads,
+                                                                               pair,
+                                                                               false,
+                                                                               true,
+                                                                               true),
+                                               static_cast<int>(first.shape()[1]) / patch_size,
+                                               static_cast<int>(first.shape()[0]) / patch_size);
+                        }
+                    }
+                } else if (conditioner_params.ref_images != nullptr) {
+                    for (size_t i = 0; i < conditioner_params.ref_images->size(); ++i) {
+                        auto resized = resize_for_vision((*conditioner_params.ref_images)[i]);
+                        prompt += "<Picture " + std::to_string(i + 1) + ">: ";
+                        add_vision_outputs(llm->encode_image_outputs(n_threads,
+                                                                     resized,
+                                                                     false,
+                                                                     true,
+                                                                     true),
+                                           static_cast<int>(resized.shape()[1]) / patch_size,
+                                           static_cast<int>(resized.shape()[0]) / patch_size);
+                    }
+                }
+            }
+            prompt += conditioner_params.text;
+        } else if (sd_version_is_hunyuan_video(version)) {
             prompt_template_encode_start_idx = 98;
             out_layers                       = {26};
 
@@ -2666,7 +2820,9 @@ struct LLMEmbedder : public Conditioner {
                                            out_layers,
                                            prompt_template_encode_start_idx,
                                            spell_quotes,
-                                           max_length);
+                                           max_length,
+                                           deepstack_image_embeds,
+                                           image_grids);
         std::vector<sd::Tensor<float>> extra_hidden_states_vec;
         if (sd_version_is_hunyuan_video(version) && byt5) {
             std::vector<std::string> quoted_texts;
@@ -2727,6 +2883,17 @@ struct LLMEmbedder : public Conditioner {
         SDCondition result;
         result.c_crossattn        = std::move(hidden_states);
         result.extra_c_crossattns = std::move(extra_hidden_states_vec);
+        if (sd_version_is_minimax_h3(version)) {
+            std::vector<int32_t> tags(static_cast<size_t>(result.c_crossattn.shape()[1]), 1);
+            for (const auto& [index, image_embed] : image_embeds) {
+                int64_t begin = std::max<int64_t>(0, index - 1);
+                int64_t end   = std::min<int64_t>(static_cast<int64_t>(tags.size()),
+                                                index + image_embed.shape()[1] + 1);
+                std::fill(tags.begin() + begin, tags.begin() + end, 0);
+            }
+            int64_t tag_count    = static_cast<int64_t>(tags.size());
+            result.c_token_types = sd::Tensor<int32_t>({tag_count}, std::move(tags));
+        }
         return result;
     }
 };
diff --git a/src/model.h b/src/model.h
index b0cee896b..f59f1de7d 100644
--- a/src/model.h
+++ b/src/model.h
@@ -43,6 +43,7 @@ enum SDVersion {
     VERSION_FLUX2,
     VERSION_FLUX2_KLEIN,
     VERSION_LTXAV,
+    VERSION_MINIMAX_H3,
     VERSION_HIDREAM_O1,
     VERSION_Z_IMAGE,
     VERSION_BOOGU_IMAGE,
@@ -123,6 +124,10 @@ static inline bool sd_version_is_ltxav(SDVersion version) {
     return false;
 }
 
+static inline bool sd_version_is_minimax_h3(SDVersion version) {
+    return version == VERSION_MINIMAX_H3;
+}
+
 static inline bool sd_version_is_wan(SDVersion version) {
     if (version == VERSION_WAN2 || version == VERSION_WAN2_2_I2V || version == VERSION_WAN2_2_TI2V) {
         return true;
@@ -272,6 +277,7 @@ static inline bool sd_version_is_dit(SDVersion version) {
     if (sd_version_is_flux(version) ||
         sd_version_is_flux2(version) ||
         sd_version_is_ltxav(version) ||
+        sd_version_is_minimax_h3(version) ||
         sd_version_is_sd3(version) ||
         sd_version_is_wan(version) ||
         sd_version_is_lingbot_video(version) ||
diff --git a/src/model/diffusion/minimax_h3.hpp b/src/model/diffusion/minimax_h3.hpp
new file mode 100644
index 000000000..d0683166d
--- /dev/null
+++ b/src/model/diffusion/minimax_h3.hpp
@@ -0,0 +1,1178 @@
+#ifndef __SD_MODEL_DIFFUSION_MINIMAX_H3_HPP__
+#define __SD_MODEL_DIFFUSION_MINIMAX_H3_HPP__
+
+#include <algorithm>
+#include <cmath>
+#include <set>
+#include <string>
+#include <tuple>
+#include <utility>
+#include <vector>
+
+#include "core/ggml_graph_cut.h"
+#include "model/diffusion/dit.hpp"
+#include "model/diffusion/model.hpp"
+
+namespace MiniMaxH3 {
+
+    constexpr int H3_GRAPH_SIZE          = 131072;
+    constexpr float FRAME_RESCALE        = 5.f / 3.f;
+    constexpr float VISUAL_COND_TIMESTEP = 0.999f;
+
+    struct Config {
+        int64_t hidden_size              = 5376;
+        int64_t num_layers               = 50;
+        int64_t token_refiner_num_layers = 2;
+        int64_t num_attention_heads      = 56;
+        int64_t attention_head_dim       = 128;
+        int64_t ffn_hidden_size          = 14336;
+        int64_t video_latent_channels    = 24;
+        int64_t audio_latent_channels    = 32;
+        int64_t text_dim                 = 5120;
+        int64_t timestep_input_dim       = 256;
+        int64_t time_embed_hidden_size   = 5376;
+        int64_t time_embed_dim           = 2688;
+        int64_t rope_inv_freq_len        = 16;
+        int64_t adaln_curve_grid         = 0;
+        int patch_t                      = 1;
+        int patch_h                      = 2;
+        int patch_w                      = 2;
+        float norm_eps                   = 1e-5f;
+        float qk_norm_eps                = 1e-5f;
+        float final_norm_eps             = 1e-5f;
+
+        bool uses_adaln_curves() const {
+            return adaln_curve_grid > 0;
+        }
+
+        static int64_t count_blocks(const String2TensorStorage& tensors,
+                                    const std::string& prefix) {
+            std::set<int> indices;
+            for (const auto& [name, _] : tensors) {
+                if (!starts_with(name, prefix)) {
+                    continue;
+                }
+                size_t begin = prefix.size();
+                size_t end   = name.find('.', begin);
+                if (end != std::string::npos) {
+                    indices.insert(std::atoi(name.substr(begin, end - begin).c_str()));
+                }
+            }
+            return static_cast<int64_t>(indices.size());
+        }
+
+        static Config detect_from_weights(const String2TensorStorage& tensors,
+                                          const std::string& prefix) {
+            Config config;
+            auto find = [&](const std::string& suffix) -> const TensorStorage* {
+                auto it = tensors.find(prefix + "." + suffix);
+                return it == tensors.end() ? nullptr : &it->second;
+            };
+
+            if (const auto* weight = find("video_patch_proj.weight")) {
+                config.video_latent_channels = weight->ne[0] / 4;
+                config.hidden_size           = weight->ne[1];
+            }
+            if (const auto* weight = find("audio_patch_proj.weight")) {
+                config.audio_latent_channels = weight->ne[0];
+            }
+            config.num_layers               = count_blocks(tensors, prefix + ".blocks.");
+            config.token_refiner_num_layers = count_blocks(tensors, prefix + ".token_refiner.blocks.");
+            if (const auto* weight = find("blocks.0.attn.q_norm.weight")) {
+                config.attention_head_dim = weight->ne[0];
+            }
+            if (const auto* weight = find("blocks.0.attn.qkv_proj.weight")) {
+                config.num_attention_heads = weight->ne[1] / (3 * config.attention_head_dim);
+            }
+            if (const auto* weight = find("blocks.0.mlp.fc1.weight")) {
+                config.ffn_hidden_size = weight->ne[1] / 2;
+            }
+            if (const auto* weight = find("condition_proj.weight")) {
+                config.text_dim = weight->ne[0];
+            }
+            if (const auto* table = find("adaln_t_table")) {
+                config.time_embed_dim   = table->ne[0];
+                config.adaln_curve_grid = table->ne[1];
+            } else {
+                if (const auto* weight = find("time_embedder.proj_in.weight")) {
+                    config.timestep_input_dim     = weight->ne[0];
+                    config.time_embed_hidden_size = weight->ne[1];
+                }
+                if (const auto* weight = find("time_embedder.proj_out.weight")) {
+                    config.time_embed_dim = weight->ne[1];
+                }
+            }
+            if (const auto* inv_freq = find("rope.inv_freq")) {
+                config.rope_inv_freq_len = inv_freq->ne[0];
+            }
+
+            LOG_DEBUG("minimax_h3: layers=%" PRId64 ", hidden=%" PRId64 ", heads=%" PRId64
+                      ", head_dim=%" PRId64 ", ffn=%" PRId64 ", adaln_curve=%" PRId64,
+                      config.num_layers,
+                      config.hidden_size,
+                      config.num_attention_heads,
+                      config.attention_head_dim,
+                      config.ffn_hidden_size,
+                      config.adaln_curve_grid);
+            return config;
+        }
+    };
+
+    static float time_shift_sigma(float sigma, float from_shift, float to_shift) {
+        float base = sigma / (from_shift + sigma * (1.f - from_shift));
+        return to_shift * base / (1.f + (to_shift - 1.f) * base);
+    }
+
+    static float time_shift_slope(float sigma, float from_shift, float to_shift) {
+        float base = sigma / (from_shift + sigma * (1.f - from_shift));
+        float a    = 1.f + (from_shift - 1.f) * base;
+        float b    = 1.f + (to_shift - 1.f) * base;
+        return to_shift * a * a / (from_shift * b * b);
+    }
+
+    struct TimeEmbedder : public GGMLBlock {
+        TimeEmbedder(int64_t input_dim, int64_t hidden_dim, int64_t output_dim) {
+            blocks["proj_in"]  = std::make_shared<Linear>(input_dim, hidden_dim, true, true);
+            blocks["proj_out"] = std::make_shared<Linear>(hidden_dim, output_dim, true, true);
+        }
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* x) {
+            auto proj_in  = std::dynamic_pointer_cast<Linear>(blocks["proj_in"]);
+            auto proj_out = std::dynamic_pointer_cast<Linear>(blocks["proj_out"]);
+            return proj_out->forward(ctx, ggml_silu(ctx->ggml_ctx, proj_in->forward(ctx, x)));
+        }
+    };
+
+    struct MLP : public UnaryBlock {
+        MLP(int64_t hidden_size,
+            int64_t ffn_hidden_size) {
+            blocks["fc1"] = std::make_shared<Linear>(hidden_size, ffn_hidden_size * 2, false, false, true, 1.f / 128.f);
+            blocks["fc2"] = std::make_shared<Linear>(ffn_hidden_size, hidden_size, false, false, true, 1.f / 128.f);
+        }
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* x) override {
+            auto fc1 = std::dynamic_pointer_cast<Linear>(blocks["fc1"]);
+            auto fc2 = std::dynamic_pointer_cast<Linear>(blocks["fc2"]);
+            auto uv  = ggml_ext_chunk(ctx->ggml_ctx, fc1->forward(ctx, x), 2, 0);
+            return fc2->forward(ctx, ggml_mul(ctx->ggml_ctx,
+                                              ggml_silu(ctx->ggml_ctx, uv[0]),
+                                              uv[1]));
+        }
+    };
+
+    static ggml_tensor* attention_layout(ggml_context* ctx, ggml_tensor* x) {
+        x = ggml_cont(ctx, ggml_permute(ctx, x, 0, 2, 1, 3));
+        return ggml_reshape_3d(ctx, x, x->ne[0], x->ne[1], x->ne[2] * x->ne[3]);
+    }
+
+    static ggml_tensor* apply_partial_rope(ggml_context* ctx,
+                                           ggml_tensor* x,
+                                           ggml_tensor* pe) {
+        int64_t rot_dim = pe->ne[2] * 2;
+        GGML_ASSERT(rot_dim <= x->ne[0]);
+        auto rotated = Rope::apply_rope(ctx,
+                                        ggml_ext_slice(ctx, x, 0, 0, rot_dim),
+                                        pe,
+                                        false);
+        if (rot_dim == x->ne[0]) {
+            return rotated;
+        }
+        auto tail = attention_layout(ctx, ggml_ext_slice(ctx, x, 0, rot_dim, x->ne[0]));
+        return ggml_concat(ctx, rotated, tail, 0);
+    }
+
+    struct Attention : public GGMLBlock {
+        int64_t heads;
+        int64_t head_dim;
+
+        Attention(int64_t hidden_size,
+                  int64_t heads,
+                  int64_t head_dim,
+                  float eps)
+            : heads(heads), head_dim(head_dim) {
+            int64_t inner      = heads * head_dim;
+            blocks["qkv_proj"] = std::make_shared<Linear>(hidden_size, inner * 3, false);
+            blocks["q_norm"]   = std::make_shared<RMSNorm>(head_dim, eps);
+            blocks["k_norm"]   = std::make_shared<RMSNorm>(head_dim, eps);
+            blocks["out_proj"] = std::make_shared<Linear>(inner, hidden_size, false);
+        }
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx,
+                             ggml_tensor* x,
+                             ggml_tensor* pe = nullptr) {
+            auto qkv_proj = std::dynamic_pointer_cast<Linear>(blocks["qkv_proj"]);
+            auto q_norm   = std::dynamic_pointer_cast<RMSNorm>(blocks["q_norm"]);
+            auto k_norm   = std::dynamic_pointer_cast<RMSNorm>(blocks["k_norm"]);
+            auto out_proj = std::dynamic_pointer_cast<Linear>(blocks["out_proj"]);
+
+            int64_t sequence = x->ne[1];
+            int64_t batch    = x->ne[2] * x->ne[3];
+            auto qkv         = ggml_ext_chunk(ctx->ggml_ctx, qkv_proj->forward(ctx, x), 3, 0);
+            auto q           = ggml_reshape_4d(ctx->ggml_ctx, qkv[0], head_dim, heads, sequence, batch);
+            auto k           = ggml_reshape_4d(ctx->ggml_ctx, qkv[1], head_dim, heads, sequence, batch);
+            auto v           = ggml_reshape_4d(ctx->ggml_ctx, qkv[2], head_dim, heads, sequence, batch);
+            q                = q_norm->forward(ctx, q);
+            k                = k_norm->forward(ctx, k);
+            if (pe != nullptr) {
+                q = apply_partial_rope(ctx->ggml_ctx, q, pe);
+                k = apply_partial_rope(ctx->ggml_ctx, k, pe);
+            } else {
+                q = attention_layout(ctx->ggml_ctx, q);
+                k = attention_layout(ctx->ggml_ctx, k);
+            }
+            auto out = ggml_ext_attention_ext(ctx->ggml_ctx,
+                                              ctx->backend,
+                                              q,
+                                              k,
+                                              v,
+                                              static_cast<int>(heads),
+                                              nullptr,
+                                              true,
+                                              ctx->flash_attn_enabled,
+                                              1.f / 128.f);
+            return out_proj->forward(ctx, out);
+        }
+    };
+
+    struct TokenRefinerBlock : public GGMLBlock {
+        TokenRefinerBlock(const Config& config) {
+            blocks["norm1"] = std::make_shared<RMSNorm>(config.hidden_size, config.norm_eps);
+            blocks["norm2"] = std::make_shared<RMSNorm>(config.hidden_size, config.norm_eps);
+            blocks["attn"]  = std::make_shared<Attention>(config.hidden_size,
+                                                         config.num_attention_heads,
+                                                         config.attention_head_dim,
+                                                         config.qk_norm_eps);
+            blocks["mlp"]   = std::make_shared<MLP>(config.hidden_size, config.ffn_hidden_size);
+        }
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* x) {
+            auto norm1 = std::dynamic_pointer_cast<RMSNorm>(blocks["norm1"]);
+            auto norm2 = std::dynamic_pointer_cast<RMSNorm>(blocks["norm2"]);
+            auto attn  = std::dynamic_pointer_cast<Attention>(blocks["attn"]);
+            auto mlp   = std::dynamic_pointer_cast<MLP>(blocks["mlp"]);
+            x          = ggml_add(ctx->ggml_ctx, x, attn->forward(ctx, norm1->forward(ctx, x)));
+            return ggml_add(ctx->ggml_ctx, x, mlp->forward(ctx, norm2->forward(ctx, x)));
+        }
+    };
+
+    struct TokenRefiner : public GGMLBlock {
+        int64_t num_layers;
+
+        explicit TokenRefiner(const Config& config)
+            : num_layers(config.token_refiner_num_layers) {
+            for (int64_t i = 0; i < num_layers; ++i) {
+                blocks["blocks." + std::to_string(i)] = std::make_shared<TokenRefinerBlock>(config);
+            }
+            blocks["final_norm"] = std::make_shared<RMSNorm>(config.hidden_size, config.final_norm_eps);
+        }
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* x) {
+            for (int64_t i = 0; i < num_layers; ++i) {
+                auto block = std::dynamic_pointer_cast<TokenRefinerBlock>(blocks["blocks." + std::to_string(i)]);
+                x          = block->forward(ctx, x);
+            }
+            return std::dynamic_pointer_cast<RMSNorm>(blocks["final_norm"])->forward(ctx, x);
+        }
+    };
+
+    struct AdaLayerNormModulation : public GGMLBlock {
+        int64_t hidden_size;
+        int expand;
+        int modalities;
+        bool apply_silu;
+
+        AdaLayerNormModulation(int64_t time_dim,
+                               int64_t hidden_size,
+                               int expand,
+                               int modalities,
+                               bool apply_silu,
+                               bool force_f32)
+            : hidden_size(hidden_size),
+              expand(expand),
+              modalities(modalities),
+              apply_silu(apply_silu) {
+            blocks["linear"] = std::make_shared<Linear>(time_dim,
+                                                        hidden_size * expand * modalities,
+                                                        true,
+                                                        force_f32);
+        }
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* t_emb) {
+            if (apply_silu) {
+                t_emb = ggml_silu(ctx->ggml_ctx, t_emb);
+            }
+            return std::dynamic_pointer_cast<Linear>(blocks["linear"])->forward(ctx, t_emb);
+        }
+    };
+
+    struct TokenModulationSpan {
+        int64_t start;
+        int64_t end;
+        int64_t modulation_row;
+    };
+
+    enum class SequenceKind {
+        TEXT,
+        CONDITION_VIDEO,
+        CONDITION_AUDIO,
+        TARGET_AUDIO,
+        TARGET_VIDEO,
+    };
+
+    struct SequenceSegment {
+        int64_t start;
+        int64_t end;
+        SequenceKind kind;
+        int32_t source_index = -1;
+    };
+
+    static std::vector<ggml_tensor*> modulation_row(ggml_context* ctx,
+                                                    ggml_tensor* projection,
+                                                    int64_t hidden_size,
+                                                    int expand,
+                                                    int modalities,
+                                                    int64_t row) {
+        int64_t timestep_rows = projection->ne[1];
+        auto reshaped         = ggml_reshape_2d(ctx,
+                                                projection,
+                                                hidden_size * expand,
+                                                timestep_rows * modalities);
+        auto selected         = ggml_ext_slice(ctx, reshaped, 1, row, row + 1);
+        return ggml_ext_chunk(ctx, selected, expand, 0);
+    }
+
+    static ggml_tensor* modulate_segments(ggml_context* ctx,
+                                          ggml_tensor* x,
+                                          ggml_tensor* projection,
+                                          const std::vector<TokenModulationSpan>& segments,
+                                          int64_t hidden_size,
+                                          int expand,
+                                          int modalities,
+                                          int shift_index,
+                                          int scale_index) {
+        ggml_tensor* out = nullptr;
+        for (const auto& segment : segments) {
+            auto mods = modulation_row(ctx,
+                                       projection,
+                                       hidden_size,
+                                       expand,
+                                       modalities,
+                                       segment.modulation_row);
+            auto part = ggml_ext_slice(ctx, x, 1, segment.start, segment.end);
+            part      = ggml_add(ctx,
+                                 ggml_add(ctx, part, ggml_mul(ctx, part, mods[scale_index])),
+                                 mods[shift_index]);
+            out       = out == nullptr ? part : ggml_concat(ctx, out, part, 1);
+        }
+        return out;
+    }
+
+    static ggml_tensor* gated_residual_segments(ggml_context* ctx,
+                                                ggml_tensor* x,
+                                                ggml_tensor* update,
+                                                ggml_tensor* projection,
+                                                const std::vector<TokenModulationSpan>& segments,
+                                                int64_t hidden_size,
+                                                int gate_index) {
+        ggml_tensor* out = nullptr;
+        for (const auto& segment : segments) {
+            auto mods = modulation_row(ctx, projection, hidden_size, 6, 3, segment.modulation_row);
+            auto base = ggml_ext_slice(ctx, x, 1, segment.start, segment.end);
+            auto add  = ggml_ext_slice(ctx, update, 1, segment.start, segment.end);
+            auto part = ggml_add(ctx, base, ggml_mul(ctx, add, mods[gate_index]));
+            out       = out == nullptr ? part : ggml_concat(ctx, out, part, 1);
+        }
+        return out;
+    }
+
+    struct TransformerBlock : public GGMLBlock {
+        Config config;
+
+        explicit TransformerBlock(const Config& config)
+            : config(config) {
+            blocks["norm1"]      = std::make_shared<RMSNorm>(config.hidden_size, config.norm_eps);
+            blocks["norm2"]      = std::make_shared<RMSNorm>(config.hidden_size, config.norm_eps);
+            blocks["attn"]       = std::make_shared<Attention>(config.hidden_size,
+                                                         config.num_attention_heads,
+                                                         config.attention_head_dim,
+                                                         config.qk_norm_eps);
+            blocks["mlp"]        = std::make_shared<MLP>(config.hidden_size,
+                                                  config.ffn_hidden_size);
+            blocks["adaln_proj"] = std::make_shared<AdaLayerNormModulation>(config.time_embed_dim,
+                                                                            config.hidden_size,
+                                                                            6,
+                                                                            3,
+                                                                            !config.uses_adaln_curves(),
+                                                                            config.uses_adaln_curves());
+        }
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx,
+                             ggml_tensor* x,
+                             ggml_tensor* t_emb,
+                             const std::vector<TokenModulationSpan>& segments,
+                             ggml_tensor* pe) {
+            auto norm1 = std::dynamic_pointer_cast<RMSNorm>(blocks["norm1"]);
+            auto norm2 = std::dynamic_pointer_cast<RMSNorm>(blocks["norm2"]);
+            auto attn  = std::dynamic_pointer_cast<Attention>(blocks["attn"]);
+            auto mlp   = std::dynamic_pointer_cast<MLP>(blocks["mlp"]);
+            auto adaln = std::dynamic_pointer_cast<AdaLayerNormModulation>(blocks["adaln_proj"]);
+            auto mods  = adaln->forward(ctx, t_emb);
+
+            auto h = modulate_segments(ctx->ggml_ctx,
+                                       norm1->forward(ctx, x),
+                                       mods,
+                                       segments,
+                                       config.hidden_size,
+                                       6,
+                                       3,
+                                       0,
+                                       1);
+            x      = gated_residual_segments(ctx->ggml_ctx,
+                                             x,
+                                             attn->forward(ctx, h, pe),
+                                             mods,
+                                             segments,
+                                             config.hidden_size,
+                                             2);
+            h      = modulate_segments(ctx->ggml_ctx,
+                                       norm2->forward(ctx, x),
+                                       mods,
+                                       segments,
+                                       config.hidden_size,
+                                       6,
+                                       3,
+                                       3,
+                                       4);
+            return gated_residual_segments(ctx->ggml_ctx,
+                                           x,
+                                           mlp->forward(ctx, h),
+                                           mods,
+                                           segments,
+                                           config.hidden_size,
+                                           5);
+        }
+    };
+
+    struct FinalLayer : public GGMLBlock {
+        Config config;
+
+        explicit FinalLayer(const Config& config)
+            : config(config) {
+            int64_t video_dim    = config.video_latent_channels * config.patch_t * config.patch_h * config.patch_w;
+            blocks["norm"]       = std::make_shared<RMSNorm>(config.hidden_size, config.final_norm_eps);
+            blocks["adaln_proj"] = std::make_shared<AdaLayerNormModulation>(config.time_embed_dim,
+                                                                            config.hidden_size,
+                                                                            2,
+                                                                            1,
+                                                                            !config.uses_adaln_curves(),
+                                                                            config.uses_adaln_curves());
+            blocks["video_out"]  = std::make_shared<Linear>(config.hidden_size, video_dim, true, true);
+            blocks["audio_out"]  = std::make_shared<Linear>(config.hidden_size, config.audio_latent_channels, true, true);
+        }
+
+        std::pair<ggml_tensor*, ggml_tensor*> forward(GGMLRunnerContext* ctx,
+                                                      ggml_tensor* x,
+                                                      ggml_tensor* t_emb,
+                                                      const TokenModulationSpan& video,
+                                                      const TokenModulationSpan& audio) {
+            auto norm      = std::dynamic_pointer_cast<RMSNorm>(blocks["norm"]);
+            auto adaln     = std::dynamic_pointer_cast<AdaLayerNormModulation>(blocks["adaln_proj"]);
+            auto video_out = std::dynamic_pointer_cast<Linear>(blocks["video_out"]);
+            auto audio_out = std::dynamic_pointer_cast<Linear>(blocks["audio_out"]);
+            auto mods      = adaln->forward(ctx, t_emb);
+            auto apply     = [&](const TokenModulationSpan& segment) {
+                auto row   = modulation_row(ctx->ggml_ctx, mods, config.hidden_size, 2, 1, segment.modulation_row);
+                auto value = norm->forward(ctx, ggml_ext_slice(ctx->ggml_ctx, x, 1, segment.start, segment.end));
+                return ggml_add(ctx->ggml_ctx,
+                                    ggml_add(ctx->ggml_ctx, value, ggml_mul(ctx->ggml_ctx, value, row[1])),
+                                    row[0]);
+            };
+            return {video_out->forward(ctx, apply(video)),
+                    audio_out->forward(ctx, apply(audio))};
+        }
+    };
+
+    struct MiniMaxH3Transformer3DModel : public GGMLBlock {
+        Config config;
+
+        explicit MiniMaxH3Transformer3DModel(const Config& config)
+            : config(config) {
+            int64_t video_dim          = config.video_latent_channels * config.patch_t * config.patch_h * config.patch_w;
+            blocks["video_patch_proj"] = std::make_shared<Linear>(video_dim, config.hidden_size, true, true);
+            blocks["audio_patch_proj"] = std::make_shared<Linear>(config.audio_latent_channels, config.hidden_size, true, true);
+            blocks["condition_proj"]   = std::make_shared<Linear>(config.text_dim, config.hidden_size, true);
+            if (!config.uses_adaln_curves()) {
+                blocks["time_embedder"] = std::make_shared<TimeEmbedder>(config.timestep_input_dim,
+                                                                         config.time_embed_hidden_size,
+                                                                         config.time_embed_dim);
+            }
+            blocks["token_refiner"] = std::make_shared<TokenRefiner>(config);
+            for (int64_t i = 0; i < config.num_layers; ++i) {
+                blocks["blocks." + std::to_string(i)] = std::make_shared<TransformerBlock>(config);
+            }
+            blocks["final_layer"] = std::make_shared<FinalLayer>(config);
+        }
+
+        void init_params(ggml_context* ctx,
+                         const String2TensorStorage& tensors = {},
+                         const std::string prefix            = "") override {
+            GGMLBlock::init_params(ctx, tensors, prefix);
+            params["rope.inv_freq"] = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, config.rope_inv_freq_len);
+            if (config.uses_adaln_curves()) {
+                params["adaln_t_table"] = ggml_new_tensor_2d(ctx,
+                                                             GGML_TYPE_F32,
+                                                             config.time_embed_dim,
+                                                             config.adaln_curve_grid);
+            }
+        }
+
+        ggml_tensor* refine_context(GGMLRunnerContext* ctx, ggml_tensor* context) {
+            if (context->ne[0] == config.hidden_size) {
+                return context;
+            }
+            GGML_ASSERT(context->ne[0] == config.text_dim);
+            auto condition_proj = std::dynamic_pointer_cast<Linear>(blocks["condition_proj"]);
+            auto token_refiner  = std::dynamic_pointer_cast<TokenRefiner>(blocks["token_refiner"]);
+            return token_refiner->forward(ctx, condition_proj->forward(ctx, context));
+        }
+
+        ggml_tensor* time_embedding(GGMLRunnerContext* ctx,
+                                    ggml_tensor* timestep_features,
+                                    ggml_tensor* curve_indices,
+                                    ggml_tensor* curve_upper_indices,
+                                    ggml_tensor* curve_fractions) {
+            if (!config.uses_adaln_curves()) {
+                return std::dynamic_pointer_cast<TimeEmbedder>(blocks["time_embedder"])->forward(ctx, timestep_features);
+            }
+            auto lower = ggml_get_rows(ctx->ggml_ctx, params["adaln_t_table"], curve_indices);
+            auto upper = ggml_get_rows(ctx->ggml_ctx, params["adaln_t_table"], curve_upper_indices);
+            return ggml_add(ctx->ggml_ctx,
+                            lower,
+                            ggml_mul(ctx->ggml_ctx,
+                                     ggml_sub(ctx->ggml_ctx, upper, lower),
+                                     curve_fractions));
+        }
+
+        ggml_tensor* build_rope(GGMLRunnerContext* ctx,
+                                ggml_tensor* position_ids) {
+            auto inv            = ggml_reshape_2d(ctx->ggml_ctx,
+                                                  params["rope.inv_freq"],
+                                                  config.rope_inv_freq_len,
+                                                  1);
+            ggml_tensor* angles = nullptr;
+            for (int axis = 0; axis < 3; ++axis) {
+                auto pos          = ggml_ext_slice(ctx->ggml_ctx, position_ids, 0, axis, axis + 1);
+                auto expanded_inv = ggml_repeat_4d(ctx->ggml_ctx,
+                                                   inv,
+                                                   inv->ne[0],
+                                                   pos->ne[1],
+                                                   1,
+                                                   1);
+                auto a            = ggml_mul(ctx->ggml_ctx, expanded_inv, pos);
+                angles            = angles == nullptr ? a : ggml_concat(ctx->ggml_ctx, angles, a, 0);
+            }
+            auto c  = ggml_reshape_4d(ctx->ggml_ctx, ggml_cos(ctx->ggml_ctx, angles), 1, angles->ne[0], angles->ne[1], 1);
+            auto s  = ggml_reshape_4d(ctx->ggml_ctx, ggml_sin(ctx->ggml_ctx, angles), 1, angles->ne[0], angles->ne[1], 1);
+            auto ns = ggml_neg(ctx->ggml_ctx, s);
+            auto pe = ggml_concat(ctx->ggml_ctx, c, ns, 0);
+            pe      = ggml_concat(ctx->ggml_ctx, pe, s, 0);
+            pe      = ggml_concat(ctx->ggml_ctx, pe, c, 0);
+            return ggml_reshape_4d(ctx->ggml_ctx, pe, 2, 2, angles->ne[0], angles->ne[1]);
+        }
+
+        std::pair<ggml_tensor*, ggml_tensor*> forward(GGMLRunnerContext* ctx,
+                                                      ggml_tensor* video,
+                                                      ggml_tensor* audio,
+                                                      ggml_tensor* context,
+                                                      const std::vector<ggml_tensor*>& condition_videos,
+                                                      const std::vector<ggml_tensor*>& condition_audios,
+                                                      ggml_tensor* position_ids,
+                                                      ggml_tensor* timestep_features,
+                                                      ggml_tensor* curve_indices,
+                                                      ggml_tensor* curve_upper_indices,
+                                                      ggml_tensor* curve_fractions,
+                                                      const std::vector<TokenModulationSpan>& segments,
+                                                      const std::vector<SequenceSegment>& sequence_segments,
+                                                      const TokenModulationSpan& video_segment,
+                                                      const TokenModulationSpan& audio_segment,
+                                                      float audio_slope) {
+            auto video_proj = std::dynamic_pointer_cast<Linear>(blocks["video_patch_proj"]);
+            auto audio_proj = std::dynamic_pointer_cast<Linear>(blocks["audio_patch_proj"]);
+
+            std::vector<std::pair<int64_t, int64_t>> condition_video_ranges;
+            ggml_tensor* video_rows = nullptr;
+            int64_t video_offset    = 0;
+            for (auto condition : condition_videos) {
+                auto rows = DiT::patchify_3d(ctx->ggml_ctx,
+                                             condition,
+                                             config.patch_t,
+                                             config.patch_h,
+                                             config.patch_w,
+                                             1,
+                                             true);
+                condition_video_ranges.push_back({video_offset, video_offset + rows->ne[1]});
+                video_offset += rows->ne[1];
+                video_rows = video_rows == nullptr ? rows : ggml_concat(ctx->ggml_ctx, video_rows, rows, 1);
+            }
+            auto target_video_rows                         = DiT::patchify_3d(ctx->ggml_ctx,
+                                                                              video,
+                                                                              config.patch_t,
+                                                                              config.patch_h,
+                                                                              config.patch_w,
+                                                                              1,
+                                                                              true);
+            std::pair<int64_t, int64_t> target_video_range = {video_offset, video_offset + target_video_rows->ne[1]};
+            video_rows                                     = video_rows == nullptr ? target_video_rows
+                                                                                   : ggml_concat(ctx->ggml_ctx, video_rows, target_video_rows, 1);
+            auto video_embeds                              = video_proj->forward(ctx, video_rows);
+
+            auto pack_audio_rows = [&](ggml_tensor* value) {
+                value = ggml_cont(ctx->ggml_ctx, ggml_ext_torch_permute(ctx->ggml_ctx, value, 2, 0, 1, 3));
+                return ggml_reshape_3d(ctx->ggml_ctx,
+                                       value,
+                                       value->ne[0],
+                                       value->ne[1] * value->ne[2],
+                                       value->ne[3]);
+            };
+            std::vector<std::pair<int64_t, int64_t>> condition_audio_ranges;
+            ggml_tensor* audio_rows = nullptr;
+            int64_t audio_offset    = 0;
+            for (auto condition : condition_audios) {
+                auto rows = pack_audio_rows(condition);
+                condition_audio_ranges.push_back({audio_offset, audio_offset + rows->ne[1]});
+                audio_offset += rows->ne[1];
+                audio_rows = audio_rows == nullptr ? rows : ggml_concat(ctx->ggml_ctx, audio_rows, rows, 1);
+            }
+            audio                                          = pack_audio_rows(audio);
+            std::pair<int64_t, int64_t> target_audio_range = {audio_offset, audio_offset + audio->ne[1]};
+            audio_rows                                     = audio_rows == nullptr ? audio : ggml_concat(ctx->ggml_ctx, audio_rows, audio, 1);
+            auto audio_embeds                              = audio_proj->forward(ctx, audio_rows);
+            context                                        = refine_context(ctx, context);
+
+            ggml_tensor* h = nullptr;
+            auto append    = [&](ggml_tensor* value) {
+                h = h == nullptr ? value : ggml_concat(ctx->ggml_ctx, h, value, 1);
+            };
+            for (const auto& sequence : sequence_segments) {
+                if (sequence.kind == SequenceKind::TEXT) {
+                    append(context);
+                } else if (sequence.kind == SequenceKind::CONDITION_VIDEO) {
+                    GGML_ASSERT(sequence.source_index >= 0 &&
+                                sequence.source_index < static_cast<int32_t>(condition_video_ranges.size()));
+                    auto range = condition_video_ranges[static_cast<size_t>(sequence.source_index)];
+                    append(ggml_ext_slice(ctx->ggml_ctx, video_embeds, 1, range.first, range.second));
+                } else if (sequence.kind == SequenceKind::CONDITION_AUDIO) {
+                    GGML_ASSERT(sequence.source_index >= 0 &&
+                                sequence.source_index < static_cast<int32_t>(condition_audio_ranges.size()));
+                    auto range = condition_audio_ranges[static_cast<size_t>(sequence.source_index)];
+                    append(ggml_ext_slice(ctx->ggml_ctx, audio_embeds, 1, range.first, range.second));
+                } else if (sequence.kind == SequenceKind::TARGET_AUDIO) {
+                    append(ggml_ext_slice(ctx->ggml_ctx,
+                                          audio_embeds,
+                                          1,
+                                          target_audio_range.first,
+                                          target_audio_range.second));
+                } else {
+                    append(ggml_ext_slice(ctx->ggml_ctx,
+                                          video_embeds,
+                                          1,
+                                          target_video_range.first,
+                                          target_video_range.second));
+                }
+            }
+            GGML_ASSERT(h != nullptr);
+
+            auto t_emb = time_embedding(ctx,
+                                        timestep_features,
+                                        curve_indices,
+                                        curve_upper_indices,
+                                        curve_fractions);
+            auto pe    = build_rope(ctx, position_ids);
+            for (int64_t i = 0; i < config.num_layers; ++i) {
+                auto block = std::dynamic_pointer_cast<TransformerBlock>(blocks["blocks." + std::to_string(i)]);
+                h          = block->forward(ctx, h, t_emb, segments, pe);
+                sd::ggml_graph_cut::mark_graph_cut(h,
+                                                   "minimax_h3.blocks." + std::to_string(i),
+                                                   "hidden_states");
+            }
+
+            auto final_layer = std::dynamic_pointer_cast<FinalLayer>(blocks["final_layer"]);
+            auto output      = final_layer->forward(ctx, h, t_emb, video_segment, audio_segment);
+            auto video_out   = DiT::unpatchify_3d(ctx->ggml_ctx,
+                                                  output.first,
+                                                  video->ne[2] / config.patch_t,
+                                                  video->ne[1] / config.patch_h,
+                                                  video->ne[0] / config.patch_w,
+                                                  config.patch_t,
+                                                  config.patch_h,
+                                                  config.patch_w,
+                                                  true);
+            auto audio_out   = ggml_reshape_4d(ctx->ggml_ctx,
+                                               output.second,
+                                               config.audio_latent_channels,
+                                               audio->ne[1] / 2,
+                                               2,
+                                               audio->ne[2]);
+            audio_out        = ggml_cont(ctx->ggml_ctx, ggml_ext_torch_permute(ctx->ggml_ctx, audio_out, 1, 2, 0, 3));
+            video_out        = ggml_ext_scale(ctx->ggml_ctx, video_out, -1.f);
+            audio_out        = ggml_ext_scale(ctx->ggml_ctx, audio_out, -audio_slope);
+            return {video_out, audio_out};
+        }
+    };
+
+    struct PackedSequenceLayout {
+        std::vector<float> positions;
+        std::vector<TokenModulationSpan> segments;
+        std::vector<SequenceSegment> sequence_segments;
+        TokenModulationSpan video_segment{};
+        TokenModulationSpan audio_segment{};
+        std::vector<float> timesteps;
+    };
+
+    static float video_span(int64_t frame) {
+        static const int spans[5] = {1, 4, 4, 4, 4};
+        return FRAME_RESCALE * spans[frame % 5];
+    }
+
+    static std::vector<float> spatial_axis(int64_t dim,
+                                           float sqrt_area) {
+        int64_t count = dim / 2;
+        float ratio   = static_cast<float>(dim) / sqrt_area;
+        std::vector<float> result(static_cast<size_t>(count));
+        for (int64_t i = 0; i < count; ++i) {
+            result[static_cast<size_t>(i)] =
+                (static_cast<float>(i) * (ratio / count) + (1.f - ratio) * 0.5f) * 32.f;
+        }
+        return result;
+    }
+
+    static int find_or_add_timestep(std::vector<float>* values, float value) {
+        auto it = std::find(values->begin(), values->end(), value);
+        if (it != values->end()) {
+            return static_cast<int>(it - values->begin());
+        }
+        values->push_back(value);
+        return static_cast<int>(values->size() - 1);
+    }
+
+    static PackedSequenceLayout build_layout(int64_t text_len,
+                                             int64_t latent_t,
+                                             int64_t latent_h,
+                                             int64_t latent_w,
+                                             int64_t audio_t,
+                                             const std::vector<sd::Tensor<float>>& condition_videos,
+                                             const std::vector<sd::Tensor<float>>& condition_audios,
+                                             const sd::Tensor<int32_t>& keyframe_indices,
+                                             const std::vector<MiniMaxH3ReferenceBlock>& reference_blocks,
+                                             const sd::Tensor<int32_t>& text_tags,
+                                             float video_t,
+                                             float audio_timestep) {
+        PackedSequenceLayout layout;
+        float sqrt_area    = std::sqrt(static_cast<float>(latent_h * latent_w));
+        auto h_axis        = spatial_axis(latent_h, sqrt_area);
+        auto w_axis        = spatial_axis(latent_w, sqrt_area);
+        int64_t frame_rows = static_cast<int64_t>(h_axis.size() * w_axis.size());
+        int64_t row        = 0;
+
+        auto append_position = [&](float t, float h, float w) {
+            layout.positions.push_back(t);
+            layout.positions.push_back(h);
+            layout.positions.push_back(w);
+        };
+        for (int64_t i = 0; i < text_len; ++i) {
+            append_position(static_cast<float>(i), 0.f, 0.f);
+        }
+        layout.sequence_segments.push_back({0, text_len, SequenceKind::TEXT});
+
+        int video_time_row           = find_or_add_timestep(&layout.timesteps, video_t);
+        int audio_time_row           = find_or_add_timestep(&layout.timesteps, audio_timestep);
+        int condition_time_row       = find_or_add_timestep(&layout.timesteps,
+                                                            std::max(video_t, VISUAL_COND_TIMESTEP));
+        int audio_condition_time_row = find_or_add_timestep(&layout.timesteps,
+                                                            std::max(audio_timestep, 1.f));
+
+        int64_t run_start = 0;
+        int current_tag   = text_tags.empty() ? 1 : text_tags[0];
+        for (int64_t i = 1; i <= text_len; ++i) {
+            int tag = i < text_len && !text_tags.empty() ? text_tags[i] : -1;
+            if (i == text_len || tag != current_tag) {
+                layout.segments.push_back({run_start,
+                                           i,
+                                           video_time_row * 3 + current_tag});
+                run_start   = i;
+                current_tag = tag;
+            }
+        }
+        row = text_len;
+
+        auto condition_spatial_axes = [&](const sd::Tensor<float>& condition) {
+            float area = std::sqrt(static_cast<float>(condition.shape()[0] * condition.shape()[1]));
+            return std::make_pair(spatial_axis(condition.shape()[1], area),
+                                  spatial_axis(condition.shape()[0], area));
+        };
+        auto append_video_positions = [&](const sd::Tensor<float>& condition,
+                                          float cursor) {
+            auto axes = condition_spatial_axes(condition);
+            for (int64_t t = 0; t < condition.shape()[2]; ++t) {
+                for (float h : axes.first) {
+                    for (float w : axes.second) {
+                        append_position(cursor, h, w);
+                    }
+                }
+                cursor += video_span(t);
+            }
+            return cursor;
+        };
+        auto append_audio_positions = [&](int64_t length,
+                                          float cursor,
+                                          float w_low,
+                                          float w_high) {
+            for (int channel = 0; channel < 2; ++channel) {
+                float w = channel == 0 ? w_low : w_high;
+                for (int64_t t = 0; t < length; ++t) {
+                    append_position(cursor + static_cast<float>(t), 0.f, w);
+                }
+            }
+        };
+
+        float cursor = static_cast<float>(text_len);
+        if (reference_blocks.empty()) {
+            float video_duration = 0.f;
+            for (int64_t t = 0; t < latent_t; ++t) {
+                video_duration += video_span(t);
+            }
+            for (size_t index = 0; index < condition_videos.size(); ++index) {
+                const auto& condition = condition_videos[index];
+                auto axes             = condition_spatial_axes(condition);
+                int64_t count         = condition.shape()[2] *
+                                static_cast<int64_t>(axes.first.size() * axes.second.size());
+                bool is_first    = keyframe_indices.empty() || keyframe_indices[static_cast<int64_t>(index)] == 0;
+                float keyframe_t = is_first ? static_cast<float>(text_len)
+                                            : static_cast<float>(text_len) + video_duration - FRAME_RESCALE;
+                for (int64_t t = 0; t < condition.shape()[2]; ++t) {
+                    for (float h : axes.first) {
+                        for (float w : axes.second) {
+                            append_position(keyframe_t, h, w);
+                        }
+                    }
+                }
+                layout.sequence_segments.push_back({row,
+                                                    row + count,
+                                                    SequenceKind::CONDITION_VIDEO,
+                                                    static_cast<int32_t>(index)});
+                layout.segments.push_back({row, row + count, condition_time_row * 3});
+                row += count;
+            }
+        } else {
+            for (const auto& block : reference_blocks) {
+                const sd::Tensor<float>* ref_video = nullptr;
+                const sd::Tensor<float>* ref_audio = nullptr;
+                if (block.video_index >= 0) {
+                    GGML_ASSERT(block.video_index < static_cast<int32_t>(condition_videos.size()));
+                    ref_video = &condition_videos[static_cast<size_t>(block.video_index)];
+                }
+                if (block.audio_index >= 0) {
+                    GGML_ASSERT(block.audio_index < static_cast<int32_t>(condition_audios.size()));
+                    ref_audio = &condition_audios[static_cast<size_t>(block.audio_index)];
+                }
+
+                float block_end = cursor;
+                if (block.kind == MiniMaxH3ReferenceKind::AUDIO ||
+                    block.kind == MiniMaxH3ReferenceKind::VIDEO_AUDIO) {
+                    GGML_ASSERT(ref_audio != nullptr);
+                    float w_low  = w_axis.front();
+                    float w_high = w_axis.back();
+                    if (ref_video != nullptr) {
+                        auto axes = condition_spatial_axes(*ref_video);
+                        w_low     = axes.second.front();
+                        w_high    = axes.second.back();
+                    }
+                    int64_t count = ref_audio->shape()[0] * 2;
+                    append_audio_positions(ref_audio->shape()[0], cursor, w_low, w_high);
+                    layout.sequence_segments.push_back({row,
+                                                        row + count,
+                                                        SequenceKind::CONDITION_AUDIO,
+                                                        block.audio_index});
+                    layout.segments.push_back({row,
+                                               row + count,
+                                               audio_condition_time_row * 3 + 2});
+                    row += count;
+                    block_end = std::max(block_end, cursor + static_cast<float>(ref_audio->shape()[0]));
+                }
+
+                if (block.kind != MiniMaxH3ReferenceKind::AUDIO) {
+                    GGML_ASSERT(ref_video != nullptr);
+                    auto axes     = condition_spatial_axes(*ref_video);
+                    int64_t count = ref_video->shape()[2] *
+                                    static_cast<int64_t>(axes.first.size() * axes.second.size());
+                    float video_end = append_video_positions(*ref_video, cursor);
+                    layout.sequence_segments.push_back({row,
+                                                        row + count,
+                                                        SequenceKind::CONDITION_VIDEO,
+                                                        block.video_index});
+                    layout.segments.push_back({row, row + count, condition_time_row * 3});
+                    row += count;
+                    block_end = block.kind == MiniMaxH3ReferenceKind::IMAGE
+                                    ? std::max(block_end, cursor + 1.f)
+                                    : std::max(block_end, video_end);
+                }
+                cursor = block_end;
+            }
+        }
+
+        int64_t audio_start = row;
+        append_audio_positions(audio_t, cursor, w_axis.front(), w_axis.back());
+        layout.audio_segment = {audio_start, row + audio_t * 2, audio_time_row};
+        layout.sequence_segments.push_back({audio_start,
+                                            row + audio_t * 2,
+                                            SequenceKind::TARGET_AUDIO});
+        layout.segments.push_back({audio_start,
+                                   row + audio_t * 2,
+                                   audio_time_row * 3 + 2});
+        row += audio_t * 2;
+
+        int64_t video_start = row;
+        for (int64_t t = 0; t < latent_t; ++t) {
+            for (float h : h_axis) {
+                for (float w : w_axis) {
+                    append_position(cursor, h, w);
+                }
+            }
+            cursor += video_span(t);
+        }
+        int64_t video_rows   = latent_t * frame_rows;
+        layout.video_segment = {video_start, video_start + video_rows, video_time_row};
+        layout.sequence_segments.push_back({video_start,
+                                            video_start + video_rows,
+                                            SequenceKind::TARGET_VIDEO});
+        layout.segments.push_back({video_start,
+                                   video_start + video_rows,
+                                   video_time_row * 3});
+        return layout;
+    }
+
+    struct MiniMaxH3Runner : public DiffusionModelRunner {
+        Config config;
+        MiniMaxH3Transformer3DModel model;
+        sd::Tensor<float> video_input_cache;
+        sd::Tensor<float> audio_input_cache;
+        sd::Tensor<float> position_input_cache;
+        sd::Tensor<float> timestep_feature_input_cache;
+        sd::Tensor<int32_t> curve_index_input_cache;
+        sd::Tensor<int32_t> curve_upper_index_input_cache;
+        sd::Tensor<float> curve_fraction_input_cache;
+
+        MiniMaxH3Runner(ggml_backend_t backend,
+                        const String2TensorStorage& tensors,
+                        const std::string& prefix                           = "model.diffusion_model",
+                        std::shared_ptr<RunnerWeightManager> weight_manager = nullptr)
+            : DiffusionModelRunner(backend, prefix, weight_manager),
+              config(Config::detect_from_weights(tensors, prefix)),
+              model(config) {
+            model.init(params_ctx, tensors, prefix);
+        }
+
+        std::string get_desc() override {
+            return "minimax_h3";
+        }
+
+        void get_param_tensors(std::map<std::string, ggml_tensor*>& tensors,
+                               const std::string& prefix) override {
+            model.get_param_tensors(tensors, prefix);
+        }
+
+        std::pair<sd::Tensor<float>, sd::Tensor<float>> split_av_latents(const sd::Tensor<float>& packed,
+                                                                         int audio_length) const {
+            GGML_ASSERT(packed.dim() == 4 || packed.dim() == 5);
+            int64_t spatial      = packed.shape()[0] * packed.shape()[1] * packed.shape()[2];
+            int64_t video_values = spatial * config.video_latent_channels;
+            sd::Tensor<float> video({packed.shape()[0],
+                                     packed.shape()[1],
+                                     packed.shape()[2],
+                                     config.video_latent_channels,
+                                     1});
+            std::copy_n(packed.data(), static_cast<size_t>(video_values), video.data());
+            if (audio_length <= 0) {
+                return {video, {}};
+            }
+            int64_t audio_values = audio_length * 2 * config.audio_latent_channels;
+            GGML_ASSERT(packed.numel() >= video_values + audio_values);
+            sd::Tensor<float> audio({audio_length, 2, config.audio_latent_channels, 1});
+            std::copy_n(packed.data() + video_values,
+                        static_cast<size_t>(audio_values),
+                        audio.data());
+            return {video, audio};
+        }
+
+        ggml_tensor* merge_av_latents(ggml_context* ctx,
+                                      ggml_tensor* video,
+                                      ggml_tensor* audio) const {
+            int64_t divisor = video->ne[0] * video->ne[1] * video->ne[2];
+            int64_t values  = ggml_nelements(audio);
+            int64_t padding = (divisor - values % divisor) % divisor;
+            audio           = ggml_reshape_4d(ctx, ggml_cont(ctx, audio), values, 1, 1, 1);
+            if (padding > 0) {
+                audio = ggml_ext_pad(ctx, audio, static_cast<int>(padding), 0, 0, 0);
+            }
+            audio = ggml_reshape_4d(ctx,
+                                    audio,
+                                    video->ne[0],
+                                    video->ne[1],
+                                    video->ne[2],
+                                    (values + padding) / divisor);
+            return ggml_concat(ctx, video, audio, 3);
+        }
+
+        ggml_cgraph* build_graph(const sd::Tensor<float>& packed,
+                                 const sd::Tensor<float>& timestep,
+                                 const sd::Tensor<float>& context_tensor,
+                                 const std::vector<sd::Tensor<float>>& condition_videos,
+                                 const std::vector<sd::Tensor<float>>& condition_audios,
+                                 const sd::Tensor<int32_t>& text_tags,
+                                 const sd::Tensor<int32_t>& keyframe_indices,
+                                 const std::vector<MiniMaxH3ReferenceBlock>& reference_blocks,
+                                 int audio_length,
+                                 float video_shift,
+                                 float audio_shift) {
+            auto split        = split_av_latents(packed, audio_length);
+            video_input_cache = std::move(split.first);
+            audio_input_cache = std::move(split.second);
+            GGML_ASSERT(!audio_input_cache.empty());
+            GGML_ASSERT(!context_tensor.empty());
+
+            auto video   = make_input(video_input_cache);
+            auto audio   = make_input(audio_input_cache);
+            auto context = make_input(context_tensor);
+            std::vector<ggml_tensor*> condition_inputs;
+            condition_inputs.reserve(condition_videos.size());
+            for (const auto& condition : condition_videos) {
+                condition_inputs.push_back(make_input(condition));
+            }
+            std::vector<ggml_tensor*> audio_condition_inputs;
+            audio_condition_inputs.reserve(condition_audios.size());
+            for (const auto& condition : condition_audios) {
+                audio_condition_inputs.push_back(make_input(condition));
+            }
+
+            float sigma_v = std::clamp(timestep[0] / 1000.f, 1e-6f, 1.f);
+            float t_v     = 1.f - sigma_v;
+            float t_a     = 1.f - time_shift_sigma(sigma_v, video_shift, audio_shift);
+            auto layout   = build_layout(context_tensor.shape()[1],
+                                         video_input_cache.shape()[2],
+                                         video_input_cache.shape()[1],
+                                         video_input_cache.shape()[0],
+                                         audio_length,
+                                         condition_videos,
+                                         condition_audios,
+                                         keyframe_indices,
+                                         reference_blocks,
+                                         text_tags,
+                                         t_v,
+                                         t_a);
+
+            position_input_cache = sd::Tensor<float>(
+                {3, static_cast<int64_t>(layout.positions.size() / 3)},
+                layout.positions);
+            auto positions = make_input(position_input_cache);
+
+            ggml_tensor* timestep_features   = nullptr;
+            ggml_tensor* curve_indices       = nullptr;
+            ggml_tensor* curve_upper_indices = nullptr;
+            ggml_tensor* curve_fractions     = nullptr;
+            if (config.uses_adaln_curves()) {
+                std::vector<int32_t> indices(layout.timesteps.size());
+                std::vector<int32_t> upper_indices(layout.timesteps.size());
+                std::vector<float> fractions(layout.timesteps.size());
+                for (size_t i = 0; i < layout.timesteps.size(); ++i) {
+                    float position   = std::clamp(layout.timesteps[i], 0.f, 1.f) * (config.adaln_curve_grid - 1);
+                    int index        = std::min(static_cast<int>(std::floor(position)),
+                                                static_cast<int>(config.adaln_curve_grid - 2));
+                    indices[i]       = index;
+                    upper_indices[i] = index + 1;
+                    fractions[i]     = position - index;
+                }
+                curve_index_input_cache = sd::Tensor<int32_t>(
+                    {static_cast<int64_t>(indices.size())},
+                    indices);
+                curve_upper_index_input_cache = sd::Tensor<int32_t>(
+                    {static_cast<int64_t>(upper_indices.size())},
+                    upper_indices);
+                curve_fraction_input_cache = sd::Tensor<float>(
+                    {1, static_cast<int64_t>(fractions.size())},
+                    fractions);
+                curve_indices       = make_input(curve_index_input_cache);
+                curve_upper_indices = make_input(curve_upper_index_input_cache);
+                curve_fractions     = make_input(curve_fraction_input_cache);
+            } else {
+                timestep_feature_input_cache = sd::Tensor<float>(
+                    {config.timestep_input_dim, static_cast<int64_t>(layout.timesteps.size())},
+                    timestep_embedding(layout.timesteps,
+                                       static_cast<int>(config.timestep_input_dim),
+                                       10000,
+                                       true,
+                                       1.f));
+                timestep_features = make_input(timestep_feature_input_cache);
+            }
+
+            auto runner_ctx = get_context();
+            auto output     = model.forward(&runner_ctx,
+                                            video,
+                                            audio,
+                                            context,
+                                            condition_inputs,
+                                            audio_condition_inputs,
+                                            positions,
+                                            timestep_features,
+                                            curve_indices,
+                                            curve_upper_indices,
+                                            curve_fractions,
+                                            layout.segments,
+                                            layout.sequence_segments,
+                                            layout.video_segment,
+                                            layout.audio_segment,
+                                            time_shift_slope(sigma_v, video_shift, audio_shift));
+            auto merged     = merge_av_latents(compute_ctx, output.first, output.second);
+            auto graph      = new_graph_custom(H3_GRAPH_SIZE);
+            ggml_build_forward_expand(graph, merged);
+            return graph;
+        }
+
+        sd::Tensor<float> compute(int n_threads,
+                                  const DiffusionParams& params) override {
+            GGML_ASSERT(params.x != nullptr && params.timesteps != nullptr && params.context != nullptr);
+            const auto* extra = diffusion_extra_as<MiniMaxH3DiffusionExtra>(params);
+            static const std::vector<sd::Tensor<float>> empty_conditions;
+            static const std::vector<MiniMaxH3ReferenceBlock> empty_reference_blocks;
+            const auto& conditions       = params.ref_latents == nullptr ? empty_conditions : *params.ref_latents;
+            const auto& audio_conditions = extra->reference_audio_latents == nullptr
+                                               ? empty_conditions
+                                               : *extra->reference_audio_latents;
+            const auto& reference_blocks = extra->reference_blocks == nullptr
+                                               ? empty_reference_blocks
+                                               : *extra->reference_blocks;
+            const sd::Tensor<int32_t> empty_int;
+            auto get_graph = [&]() {
+                return build_graph(*params.x,
+                                   *params.timesteps,
+                                   *params.context,
+                                   conditions,
+                                   audio_conditions,
+                                   extra->text_token_tags == nullptr ? empty_int : *extra->text_token_tags,
+                                   extra->keyframe_indices == nullptr ? empty_int : *extra->keyframe_indices,
+                                   reference_blocks,
+                                   extra->audio_length,
+                                   extra->video_sigma_shift,
+                                   extra->audio_sigma_shift);
+            };
+            return restore_trailing_singleton_dims(GGMLRunner::compute<float>(get_graph,
+                                                                              n_threads,
+                                                                              false,
+                                                                              false,
+                                                                              false),
+                                                   params.x->dim());
+        }
+    };
+
+}  // namespace MiniMaxH3
+
+#endif  // __SD_MODEL_DIFFUSION_MINIMAX_H3_HPP__
diff --git a/src/model/diffusion/model.hpp b/src/model/diffusion/model.hpp
index d7a5f4231..070ca53d4 100644
--- a/src/model/diffusion/model.hpp
+++ b/src/model/diffusion/model.hpp
@@ -87,6 +87,29 @@ struct LTXAVDiffusionExtra {
     const sd::Tensor<float>* video_positions = nullptr;
 };
 
+enum class MiniMaxH3ReferenceKind : int32_t {
+    IMAGE,
+    VIDEO,
+    AUDIO,
+    VIDEO_AUDIO,
+};
+
+struct MiniMaxH3ReferenceBlock {
+    MiniMaxH3ReferenceKind kind = MiniMaxH3ReferenceKind::IMAGE;
+    int32_t video_index         = -1;
+    int32_t audio_index         = -1;
+};
+
+struct MiniMaxH3DiffusionExtra {
+    const sd::Tensor<int32_t>* text_token_tags                    = nullptr;
+    const sd::Tensor<int32_t>* keyframe_indices                   = nullptr;
+    const std::vector<sd::Tensor<float>>* reference_audio_latents = nullptr;
+    const std::vector<MiniMaxH3ReferenceBlock>* reference_blocks  = nullptr;
+    int audio_length                                              = 0;
+    float video_sigma_shift                                       = 12.f;
+    float audio_sigma_shift                                       = 3.f;
+};
+
 struct MiniT2IDiffusionExtra {
     const sd::Tensor<float>* mask = nullptr;
 };
@@ -106,6 +129,7 @@ using DiffusionExtraParams = std::variant<std::monostate,
                                           WanDiffusionExtra,
                                           HiDreamO1DiffusionExtra,
                                           LTXAVDiffusionExtra,
+                                          MiniMaxH3DiffusionExtra,
                                           MiniT2IDiffusionExtra,
                                           HunyuanVideoDiffusionExtra>;
 
diff --git a/src/model/te/llm.hpp b/src/model/te/llm.hpp
index c0651a4a8..f4dfa9f76 100644
--- a/src/model/te/llm.hpp
+++ b/src/model/te/llm.hpp
@@ -79,9 +79,20 @@ namespace LLM {
         int window_size                     = 112;
         int num_position_embeddings         = 0;
         std::set<int> fullatt_block_indexes = {7, 15, 23, 31};
-        bool split_patch_embed              = false;
+        std::vector<int> deepstack_visual_indexes;
+        bool split_patch_embed = false;
     };
 
+    struct ImageGrid {
+        int index  = 0;
+        int size   = 0;
+        int grid_h = 0;
+        int grid_w = 0;
+    };
+
+    using ImageEmbeds          = std::vector<std::pair<int, sd::Tensor<float>>>;
+    using DeepStackImageEmbeds = std::vector<ImageEmbeds>;
+
     struct LLMConfig {
         LLMArch arch                    = LLMArch::QWEN2_5_VL;
         int64_t num_layers              = 28;
@@ -93,6 +104,7 @@ namespace LLM {
         bool qkv_bias                   = true;
         bool attention_out_bias         = false;
         bool qk_norm                    = false;
+        bool final_norm                 = true;
         bool rms_norm_add               = false;
         bool normalize_input            = false;
         int64_t vocab_size              = 152064;
@@ -257,9 +269,20 @@ namespace LLM {
             if ((arch == LLMArch::QWEN3 || arch == LLMArch::QWEN3_VL) && config.num_layers == 28) {
                 config.num_heads = 16;
             }
+            if (arch == LLMArch::QWEN3_VL && config.num_layers == 50 && config.hidden_size == 5120) {
+                config.num_heads  = 64;
+                config.final_norm = false;
+            }
             if (detected_vision_layers > 0) {
                 config.vision.num_layers = detected_vision_layers;
             }
+            if (arch == LLMArch::QWEN3_VL) {
+                if (config.vision.num_layers == 24) {
+                    config.vision.deepstack_visual_indexes = {5, 11, 17};
+                } else if (config.vision.num_layers == 27) {
+                    config.vision.deepstack_visual_indexes = {8, 16, 24};
+                }
+            }
             LOG_DEBUG("llm: num_layers = %" PRId64 ", vocab_size = %" PRId64 ", hidden_size = %" PRId64 ", intermediate_size = %" PRId64,
                       config.num_layers,
                       config.vocab_size,
@@ -541,6 +564,37 @@ namespace LLM {
         return input_embed;
     }
 
+    static ggml_tensor* add_deepstack_image_embeds(GGMLRunnerContext* ctx,
+                                                   ggml_tensor* x,
+                                                   const std::vector<std::pair<int, ggml_tensor*>>& image_embeds) {
+        if (image_embeds.empty()) {
+            return x;
+        }
+
+        GGML_ASSERT(x->ne[2] == 1);
+        auto raw_x          = ggml_cast(ctx->ggml_ctx, x, image_embeds[0].second->type);
+        int64_t token_start = 0;
+        ggml_tensor* output = nullptr;
+        for (const auto& [index, image_embed] : image_embeds) {
+            GGML_ASSERT(index >= token_start);
+            GGML_ASSERT(index + image_embed->ne[1] <= raw_x->ne[1]);
+            if (index > token_start) {
+                auto text_embed = ggml_ext_slice(ctx->ggml_ctx, raw_x, 1, token_start, index);
+                output          = output == nullptr ? text_embed : ggml_concat(ctx->ggml_ctx, output, text_embed, 1);
+            }
+            auto visual_embed = ggml_ext_slice(ctx->ggml_ctx, raw_x, 1, index, index + image_embed->ne[1]);
+            visual_embed      = ggml_add(ctx->ggml_ctx, visual_embed, image_embed);
+            output            = output == nullptr ? visual_embed : ggml_concat(ctx->ggml_ctx, output, visual_embed, 1);
+            token_start       = index + image_embed->ne[1];
+        }
+        if (token_start < raw_x->ne[1]) {
+            auto text_embed = ggml_ext_slice(ctx->ggml_ctx, raw_x, 1, token_start, raw_x->ne[1]);
+            output          = output == nullptr ? text_embed : ggml_concat(ctx->ggml_ctx, output, text_embed, 1);
+        }
+        GGML_ASSERT(output != nullptr && output->ne[1] == raw_x->ne[1]);
+        return output;
+    }
+
     struct VisionMLP : public GGMLBlock {
     protected:
         LLMVisionArch arch_;
@@ -723,6 +777,33 @@ namespace LLM {
         }
     };
 
+    struct Qwen3VLDeepStackMerger : public GGMLBlock {
+    protected:
+        int64_t merge_dim;
+
+    public:
+        Qwen3VLDeepStackMerger(int64_t dim,
+                               int64_t context_dim,
+                               int64_t spatial_merge_size)
+            : merge_dim(context_dim * spatial_merge_size * spatial_merge_size) {
+            blocks["norm"]       = std::make_shared<LayerNorm>(merge_dim, 1e-6f);
+            blocks["linear_fc1"] = std::make_shared<Linear>(merge_dim, merge_dim, true);
+            blocks["linear_fc2"] = std::make_shared<Linear>(merge_dim, dim, true);
+        }
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* x) {
+            auto norm       = std::dynamic_pointer_cast<LayerNorm>(blocks["norm"]);
+            auto linear_fc1 = std::dynamic_pointer_cast<Linear>(blocks["linear_fc1"]);
+            auto linear_fc2 = std::dynamic_pointer_cast<Linear>(blocks["linear_fc2"]);
+
+            x = ggml_reshape_2d(ctx->ggml_ctx, x, merge_dim, ggml_nelements(x) / merge_dim);
+            x = norm->forward(ctx, x);
+            x = linear_fc1->forward(ctx, x);
+            x = ggml_gelu_erf(ctx->ggml_ctx, x);
+            return linear_fc2->forward(ctx, x);
+        }
+    };
+
     struct VisionAttention : public GGMLBlock {
     protected:
         bool llama_cpp_style;
@@ -844,6 +925,7 @@ namespace LLM {
         int spatial_merge_size;
         int num_grid_per_side;
         std::set<int> fullatt_block_indexes;
+        std::vector<int> deepstack_visual_indexes;
 
     public:
         VisionModel(bool llama_cpp_style,
@@ -853,7 +935,8 @@ namespace LLM {
               num_layers(vision_params.num_layers),
               spatial_merge_size(vision_params.spatial_merge_size),
               num_grid_per_side(vision_params.num_position_embeddings > 0 ? static_cast<int>(std::sqrt(vision_params.num_position_embeddings)) : 0),
-              fullatt_block_indexes(vision_params.fullatt_block_indexes) {
+              fullatt_block_indexes(vision_params.fullatt_block_indexes),
+              deepstack_visual_indexes(vision_params.deepstack_visual_indexes) {
             blocks["patch_embed"] = std::shared_ptr<GGMLBlock>(new VisionPatchEmbed(vision_params.split_patch_embed,
                                                                                     arch_,
                                                                                     vision_params.patch_size,
@@ -875,6 +958,11 @@ namespace LLM {
                                                                                 vision_params.out_hidden_size,
                                                                                 vision_params.hidden_size,
                                                                                 spatial_merge_size));
+            for (size_t i = 0; i < deepstack_visual_indexes.size(); ++i) {
+                blocks["deepstack_merger_list." + std::to_string(i)] = std::make_shared<Qwen3VLDeepStackMerger>(vision_params.out_hidden_size,
+                                                                                                                vision_params.hidden_size,
+                                                                                                                spatial_merge_size);
+            }
         }
 
         std::shared_ptr<Embedding> pos_embedder() {
@@ -893,13 +981,13 @@ namespace LLM {
             return spatial_merge_size;
         }
 
-        ggml_tensor* forward(GGMLRunnerContext* ctx,
-                             ggml_tensor* pixel_values,
-                             ggml_tensor* pe,
-                             ggml_tensor* window_index,
-                             ggml_tensor* window_inverse_index,
-                             ggml_tensor* window_mask,
-                             ggml_tensor* pos_embeds = nullptr) {
+        std::vector<ggml_tensor*> forward_outputs(GGMLRunnerContext* ctx,
+                                                  ggml_tensor* pixel_values,
+                                                  ggml_tensor* pe,
+                                                  ggml_tensor* window_index,
+                                                  ggml_tensor* window_inverse_index,
+                                                  ggml_tensor* window_mask,
+                                                  ggml_tensor* pos_embeds = nullptr) {
             // pixel_values: [grid_t*(H/mh/ph)*(W/mw/pw)*mh*mw, C*pt*ph*pw]
             // window_index: [grid_t*(H/mh/ph)*(W/mw/pw)]
             // window_inverse_index: [grid_t*(H/mh/ph)*(W/mw/pw)]
@@ -919,6 +1007,7 @@ namespace LLM {
                 x = ggml_reshape_4d(ctx->ggml_ctx, x, x->ne[0] / spatial_merge_size / spatial_merge_size, x->ne[1] * spatial_merge_size * spatial_merge_size, x->ne[2], x->ne[3]);
             }
 
+            std::vector<ggml_tensor*> deepstack_outputs;
             for (int i = 0; i < num_layers; i++) {
                 auto block = std::dynamic_pointer_cast<VisionBlock>(blocks["blocks." + std::to_string(i)]);
 
@@ -926,8 +1015,12 @@ namespace LLM {
                 if (fullatt_block_indexes.find(i) != fullatt_block_indexes.end()) {
                     mask = nullptr;
                 }
-                x = block->forward(ctx, x, pe, mask);
-                if (i == 0) {
+                x                 = block->forward(ctx, x, pe, mask);
+                auto deepstack_it = std::find(deepstack_visual_indexes.begin(), deepstack_visual_indexes.end(), i);
+                if (deepstack_it != deepstack_visual_indexes.end()) {
+                    size_t deepstack_index = static_cast<size_t>(std::distance(deepstack_visual_indexes.begin(), deepstack_it));
+                    auto deepstack_merger  = std::dynamic_pointer_cast<Qwen3VLDeepStackMerger>(blocks["deepstack_merger_list." + std::to_string(deepstack_index)]);
+                    deepstack_outputs.push_back(deepstack_merger->forward(ctx, x));
                 }
                 sd::ggml_graph_cut::mark_graph_cut(x, "llm.vision.blocks." + std::to_string(i), "x");
             }
@@ -939,7 +1032,19 @@ namespace LLM {
                 x = ggml_get_rows(ctx->ggml_ctx, x, window_inverse_index);
             }
 
-            return x;
+            std::vector<ggml_tensor*> outputs = {x};
+            outputs.insert(outputs.end(), deepstack_outputs.begin(), deepstack_outputs.end());
+            return outputs;
+        }
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx,
+                             ggml_tensor* pixel_values,
+                             ggml_tensor* pe,
+                             ggml_tensor* window_index,
+                             ggml_tensor* window_inverse_index,
+                             ggml_tensor* window_mask,
+                             ggml_tensor* pos_embeds = nullptr) {
+            return forward_outputs(ctx, pixel_values, pe, window_index, window_inverse_index, window_mask, pos_embeds)[0];
         }
     };
 
@@ -1263,7 +1368,9 @@ namespace LLM {
             for (int i = 0; i < num_layers; i++) {
                 blocks["layers." + std::to_string(i)] = std::shared_ptr<GGMLBlock>(new TransformerBlock(config, i));
             }
-            blocks["norm"] = std::shared_ptr<GGMLBlock>(new LLMRMSNorm(config.hidden_size, config.rms_norm_eps, config.rms_norm_add));
+            if (config.final_norm) {
+                blocks["norm"] = std::shared_ptr<GGMLBlock>(new LLMRMSNorm(config.hidden_size, config.rms_norm_eps, config.rms_norm_add));
+            }
         }
 
         ggml_tensor* embed(GGMLRunnerContext* ctx,
@@ -1278,9 +1385,11 @@ namespace LLM {
                                     ggml_tensor* input_pos,
                                     ggml_tensor* attention_mask,
                                     std::set<int> out_layers,
-                                    ggml_tensor* sliding_attention_mask = nullptr,
-                                    bool return_all_hidden_states       = false) {
-            auto norm = std::dynamic_pointer_cast<LLMRMSNorm>(blocks["norm"]);
+                                    const std::vector<std::vector<std::pair<int, ggml_tensor*>>>& deepstack_image_embeds = {},
+                                    ggml_tensor* sliding_attention_mask                                                  = nullptr,
+                                    bool return_all_hidden_states                                                        = false) {
+            auto norm = config.final_norm ? std::dynamic_pointer_cast<LLMRMSNorm>(blocks["norm"])
+                                          : nullptr;
             std::vector<ggml_tensor*> intermediate_outputs;
 
             if (config.normalize_input) {
@@ -1295,6 +1404,9 @@ namespace LLM {
                 auto block = std::dynamic_pointer_cast<TransformerBlock>(blocks["layers." + std::to_string(i)]);
 
                 x = block->forward(ctx, x, input_pos, attention_mask, sliding_attention_mask);
+                if (i < static_cast<int>(deepstack_image_embeds.size())) {
+                    x = add_deepstack_image_embeds(ctx, x, deepstack_image_embeds[static_cast<size_t>(i)]);
+                }
                 if (return_all_hidden_states || out_layers.size() > 1) {
                     x = ggml_cont(ctx->ggml_ctx, x);
                 }
@@ -1308,7 +1420,7 @@ namespace LLM {
                 }
             }
 
-            auto normed_x = norm->forward(ctx, x);
+            auto normed_x = norm == nullptr ? x : norm->forward(ctx, x);
             if (return_all_hidden_states) {
                 intermediate_outputs.push_back(normed_x);
                 x = intermediate_outputs[0];
@@ -1336,6 +1448,7 @@ namespace LLM {
                              ggml_tensor* attention_mask,
                              ggml_tensor* sliding_attention_mask,
                              std::vector<std::pair<int, ggml_tensor*>> image_embeds,
+                             const std::vector<std::vector<std::pair<int, ggml_tensor*>>>& deepstack_image_embeds,
                              std::set<int> out_layers,
                              bool return_all_hidden_states = false) {
             // input_ids: [N, n_token]
@@ -1347,6 +1460,7 @@ namespace LLM {
                                   input_pos,
                                   attention_mask,
                                   std::move(out_layers),
+                                  deepstack_image_embeds,
                                   sliding_attention_mask,
                                   return_all_hidden_states);
         }
@@ -1372,6 +1486,7 @@ namespace LLM {
                              ggml_tensor* attention_mask,
                              ggml_tensor* sliding_attention_mask,
                              std::vector<std::pair<int, ggml_tensor*>> image_embeds,
+                             const std::vector<std::vector<std::pair<int, ggml_tensor*>>>& deepstack_image_embeds,
                              std::set<int> out_layers,
                              bool return_all_hidden_states = false) {
             // input_ids: [N, n_token]
@@ -1383,6 +1498,7 @@ namespace LLM {
                                     attention_mask,
                                     sliding_attention_mask,
                                     image_embeds,
+                                    deepstack_image_embeds,
                                     out_layers,
                                     return_all_hidden_states);
             return x;
@@ -1524,7 +1640,8 @@ namespace LLM {
                                                 std::vector<float>& window_mask_vec,
                                                 std::vector<float>& pe_vec,
                                                 std::array<std::vector<int32_t>, 4>& pos_embed_idx_data,
-                                                std::array<std::vector<float>, 4>& pos_embed_weight_data) {
+                                                std::array<std::vector<float>, 4>& pos_embed_weight_data,
+                                                std::vector<ggml_tensor*>* output_tensors = nullptr) {
             GGML_ASSERT(image->ne[1] % (vision_params.patch_size * vision_params.spatial_merge_size) == 0);
             GGML_ASSERT(image->ne[0] % (vision_params.patch_size * vision_params.spatial_merge_size) == 0);
 
@@ -1556,7 +1673,11 @@ namespace LLM {
                 int pos_len = static_cast<int>(pe_vec.size() / head_dim / 2);
                 auto pe     = ggml_new_tensor_4d(compute_ctx, GGML_TYPE_F32, 2, 2, head_dim / 2, pos_len);
                 runner->set_backend_tensor_data(pe, pe_vec.data());
-                return vision_model->forward(runner_ctx, pixel_values, pe, nullptr, nullptr, nullptr, pos_embeds);
+                auto outputs = vision_model->forward_outputs(runner_ctx, pixel_values, pe, nullptr, nullptr, nullptr, pos_embeds);
+                if (output_tensors != nullptr) {
+                    *output_tensors = outputs;
+                }
+                return outputs[0];
             }
 
             int llm_grid_h             = grid_h / vision_params.spatial_merge_size;
@@ -1622,7 +1743,11 @@ namespace LLM {
             auto pe = ggml_new_tensor_4d(compute_ctx, GGML_TYPE_F32, 2, 2, head_dim / 2, pos_len);
             runner->set_backend_tensor_data(pe, pe_vec.data());
 
-            return vision_model->forward(runner_ctx, pixel_values, pe, window_index, window_inverse_index, window_mask);
+            auto output = vision_model->forward(runner_ctx, pixel_values, pe, window_index, window_inverse_index, window_mask);
+            if (output_tensors != nullptr) {
+                *output_tensors = {output};
+            }
+            return output;
         }
 
     public:
@@ -1667,6 +1792,7 @@ namespace LLM {
                              ggml_tensor* attention_mask,
                              ggml_tensor* sliding_attention_mask,
                              std::vector<std::pair<int, ggml_tensor*>> image_embeds,
+                             const std::vector<std::vector<std::pair<int, ggml_tensor*>>>& deepstack_image_embeds,
                              std::set<int> out_layers,
                              bool return_all_hidden_states = false) {
             auto hidden_states = model.forward(ctx,
@@ -1675,6 +1801,7 @@ namespace LLM {
                                                attention_mask,
                                                sliding_attention_mask,
                                                image_embeds,
+                                               deepstack_image_embeds,
                                                out_layers,
                                                return_all_hidden_states);  // [N, n_token, hidden_size]
             return hidden_states;
@@ -1693,7 +1820,9 @@ namespace LLM {
 
         ggml_cgraph* build_graph(const sd::Tensor<int32_t>& input_ids_tensor,
                                  const sd::Tensor<float>& attention_mask_tensor,
-                                 const std::vector<std::pair<int, sd::Tensor<float>>>& image_embeds_tensor,
+                                 const ImageEmbeds& image_embeds_tensor,
+                                 const DeepStackImageEmbeds& deepstack_image_embeds_tensor,
+                                 const std::vector<ImageGrid>& image_grids,
                                  std::set<int> out_layers,
                                  bool return_all_hidden_states = false) {
             ggml_cgraph* gf        = new_graph_custom(LLM_GRAPH_SIZE);
@@ -1704,6 +1833,13 @@ namespace LLM {
                 ggml_tensor* embed = make_input(embed_tensor);
                 image_embeds.emplace_back(idx, embed);
             }
+            std::vector<std::vector<std::pair<int, ggml_tensor*>>> deepstack_image_embeds(deepstack_image_embeds_tensor.size());
+            for (size_t layer = 0; layer < deepstack_image_embeds_tensor.size(); ++layer) {
+                deepstack_image_embeds[layer].reserve(deepstack_image_embeds_tensor[layer].size());
+                for (const auto& [idx, embed_tensor] : deepstack_image_embeds_tensor[layer]) {
+                    deepstack_image_embeds[layer].emplace_back(idx, make_input(embed_tensor));
+                }
+            }
 
             int64_t n_tokens = input_ids->ne[0];
             if (config.arch == LLMArch::MISTRAL_SMALL_3_2 ||
@@ -1724,6 +1860,30 @@ namespace LLM {
                     input_pos_vec[2 * n_tokens + i] = i;
                     input_pos_vec[3 * n_tokens + i] = 0;
                 }
+                if (config.arch == LLMArch::QWEN3_VL && !image_grids.empty()) {
+                    int offset = 0;
+                    for (const auto& grid : image_grids) {
+                        int end      = grid.index + grid.size;
+                        int grid_h   = grid.grid_h / config.vision.spatial_merge_size;
+                        int grid_w   = grid.grid_w / config.vision.spatial_merge_size;
+                        int len_max  = std::max(grid_h, grid_w);
+                        int next_pos = grid.index + len_max + offset;
+                        GGML_ASSERT(grid.index >= 0 && end <= n_tokens);
+                        GGML_ASSERT(grid_h > 0 && grid_w > 0 && grid.size == grid_h * grid_w);
+                        for (int token = end; token < n_tokens; ++token) {
+                            int pos                             = next_pos + token - end;
+                            input_pos_vec[token]                = pos;
+                            input_pos_vec[n_tokens + token]     = pos;
+                            input_pos_vec[2 * n_tokens + token] = pos;
+                        }
+                        for (int token = 0; token < grid.size; ++token) {
+                            input_pos_vec[grid.index + token]                = grid.index + offset;
+                            input_pos_vec[n_tokens + grid.index + token]     = grid.index + offset + token / grid_w;
+                            input_pos_vec[2 * n_tokens + grid.index + token] = grid.index + offset + token % grid_w;
+                        }
+                        offset += len_max - grid.size;
+                    }
+                }
             }
 
             auto input_pos = ggml_new_tensor_1d(compute_ctx,
@@ -1781,6 +1941,7 @@ namespace LLM {
                                                  attention_mask,
                                                  sliding_attention_mask,
                                                  image_embeds,
+                                                 deepstack_image_embeds,
                                                  out_layers,
                                                  return_all_hidden_states);
 
@@ -1792,16 +1953,20 @@ namespace LLM {
         sd::Tensor<float> compute(const int n_threads,
                                   const sd::Tensor<int32_t>& input_ids,
                                   const sd::Tensor<float>& attention_mask,
-                                  const std::vector<std::pair<int, sd::Tensor<float>>>& image_embeds,
+                                  const ImageEmbeds& image_embeds,
                                   std::set<int> out_layers,
-                                  bool return_all_hidden_states = false,
-                                  bool auto_free                = true,
-                                  bool free_compute_buffer      = true,
-                                  bool free_compute_params      = true) {
+                                  bool return_all_hidden_states                      = false,
+                                  bool auto_free                                     = true,
+                                  bool free_compute_buffer                           = true,
+                                  bool free_compute_params                           = true,
+                                  const DeepStackImageEmbeds& deepstack_image_embeds = {},
+                                  const std::vector<ImageGrid>& image_grids          = {}) {
             auto get_graph = [&]() -> ggml_cgraph* {
                 return build_graph(input_ids,
                                    attention_mask,
                                    image_embeds,
+                                   deepstack_image_embeds,
+                                   image_grids,
                                    out_layers,
                                    return_all_hidden_states);
             };
@@ -1851,6 +2016,24 @@ namespace LLM {
                                        pos_embed_weight_data_);
         }
 
+        std::vector<ggml_tensor*> encode_image_outputs(GGMLRunnerContext* runner_ctx, ggml_tensor* image) {
+            std::vector<ggml_tensor*> outputs;
+            encode_image_common(this,
+                                compute_ctx,
+                                runner_ctx,
+                                image,
+                                config.vision,
+                                model.vision_model(),
+                                window_index_vec,
+                                window_inverse_index_vec,
+                                window_mask_vec,
+                                pe_vec,
+                                pos_embed_idx_data_,
+                                pos_embed_weight_data_,
+                                &outputs);
+            return outputs;
+        }
+
         ggml_cgraph* build_encode_image_graph(const sd::Tensor<float>& image_tensor) {
             ggml_cgraph* gf    = new_graph_custom(LLM_GRAPH_SIZE);
             ggml_tensor* image = make_input(image_tensor);
@@ -1875,6 +2058,166 @@ namespace LLM {
             };
             return take_or_empty(GGMLRunner::compute<float>(get_graph, n_threads, auto_free, free_compute_buffer, free_compute_params));
         }
+
+        ggml_cgraph* build_encode_image_outputs_graph(const sd::Tensor<float>& image_tensor) {
+            ggml_cgraph* gf    = new_graph_custom(LLM_GRAPH_SIZE);
+            ggml_tensor* image = make_input(image_tensor);
+
+            auto runner_ctx = get_context();
+            auto outputs    = encode_image_outputs(&runner_ctx, image);
+            GGML_ASSERT(!outputs.empty());
+            auto combined = outputs[0];
+            for (size_t i = 1; i < outputs.size(); ++i) {
+                combined = ggml_concat(compute_ctx, combined, outputs[i], 0);
+            }
+            ggml_build_forward_expand(gf, combined);
+            return gf;
+        }
+
+        static sd::Tensor<float> process_video_block_tensor(const sd::Tensor<float>& frames,
+                                                            const LLMVisionConfig& vision_params) {
+            GGML_ASSERT(frames.dim() == 5);
+            GGML_ASSERT(frames.shape()[2] == vision_params.temporal_patch_size);
+            GGML_ASSERT(frames.shape()[3] == vision_params.in_channels);
+            GGML_ASSERT(frames.shape()[4] == 1);
+
+            int64_t width       = frames.shape()[0];
+            int64_t height      = frames.shape()[1];
+            int64_t temporal    = frames.shape()[2];
+            int64_t channels    = frames.shape()[3];
+            int64_t patch       = vision_params.patch_size;
+            int64_t merge       = vision_params.spatial_merge_size;
+            int64_t grid_w      = width / patch;
+            int64_t grid_h      = height / patch;
+            int64_t feature     = channels * temporal * patch * patch;
+            int64_t token_count = grid_h * grid_w;
+            sd::Tensor<float> output({feature, token_count});
+
+            int64_t token = 0;
+            for (int64_t block_h = 0; block_h < grid_h / merge; ++block_h) {
+                for (int64_t block_w = 0; block_w < grid_w / merge; ++block_w) {
+                    for (int64_t inner_h = 0; inner_h < merge; ++inner_h) {
+                        for (int64_t inner_w = 0; inner_w < merge; ++inner_w) {
+                            int64_t patch_h = block_h * merge + inner_h;
+                            int64_t patch_w = block_w * merge + inner_w;
+                            int64_t offset  = 0;
+                            for (int64_t c = 0; c < channels; ++c) {
+                                for (int64_t t = 0; t < temporal; ++t) {
+                                    for (int64_t y = 0; y < patch; ++y) {
+                                        for (int64_t x = 0; x < patch; ++x) {
+                                            output.index(offset++, token) =
+                                                frames.index(patch_w * patch + x,
+                                                             patch_h * patch + y,
+                                                             t,
+                                                             c,
+                                                             0);
+                                        }
+                                    }
+                                }
+                            }
+                            ++token;
+                        }
+                    }
+                }
+            }
+            return output;
+        }
+
+        ggml_cgraph* build_encode_video_block_outputs_graph(const sd::Tensor<float>& pixel_values_tensor,
+                                                            int grid_h,
+                                                            int grid_w) {
+            ggml_cgraph* gf   = new_graph_custom(LLM_GRAPH_SIZE);
+            auto pixel_values = make_input(pixel_values_tensor);
+            auto runner_ctx   = get_context();
+            auto vision       = model.vision_model();
+            int head_dim      = static_cast<int>(config.vision.hidden_size / config.vision.num_heads);
+            auto pos_embeds   = build_patch_pos_embeds(&runner_ctx, vision, grid_h, grid_w);
+            window_index_vec.resize(static_cast<size_t>((grid_h / config.vision.spatial_merge_size) *
+                                                        (grid_w / config.vision.spatial_merge_size)));
+            for (int i = 0; i < static_cast<int>(window_index_vec.size()); ++i) {
+                window_index_vec[static_cast<size_t>(i)] = i;
+            }
+            pe_vec      = Rope::gen_qwen2vl_pe(grid_h,
+                                               grid_w,
+                                               config.vision.spatial_merge_size,
+                                               window_index_vec,
+                                               10000,
+                                               {head_dim / 2, head_dim / 2});
+            int pos_len = static_cast<int>(pe_vec.size() / head_dim / 2);
+            auto pe     = ggml_new_tensor_4d(compute_ctx, GGML_TYPE_F32, 2, 2, head_dim / 2, pos_len);
+            set_backend_tensor_data(pe, pe_vec.data());
+            auto outputs = vision->forward_outputs(&runner_ctx,
+                                                   pixel_values,
+                                                   pe,
+                                                   nullptr,
+                                                   nullptr,
+                                                   nullptr,
+                                                   pos_embeds);
+            GGML_ASSERT(!outputs.empty());
+            auto combined = outputs[0];
+            for (size_t i = 1; i < outputs.size(); ++i) {
+                combined = ggml_concat(compute_ctx, combined, outputs[i], 0);
+            }
+            ggml_build_forward_expand(gf, combined);
+            return gf;
+        }
+
+        std::vector<sd::Tensor<float>> encode_image_outputs(const int n_threads,
+                                                            const sd::Tensor<float>& image,
+                                                            bool auto_free           = false,
+                                                            bool free_compute_buffer = false,
+                                                            bool free_compute_params = false) {
+            auto get_graph = [&]() -> ggml_cgraph* {
+                return build_encode_image_outputs_graph(image);
+            };
+            auto combined = take_or_empty(GGMLRunner::compute<float>(get_graph, n_threads, auto_free, free_compute_buffer, free_compute_params));
+            if (combined.empty()) {
+                return {};
+            }
+            size_t output_count = config.vision.deepstack_visual_indexes.size() + 1;
+            GGML_ASSERT(combined.shape()[0] == config.hidden_size * static_cast<int64_t>(output_count));
+            std::vector<sd::Tensor<float>> outputs;
+            outputs.reserve(output_count);
+            for (size_t i = 0; i < output_count; ++i) {
+                outputs.push_back(sd::ops::slice(combined,
+                                                 0,
+                                                 static_cast<int64_t>(i) * config.hidden_size,
+                                                 static_cast<int64_t>(i + 1) * config.hidden_size));
+            }
+            return outputs;
+        }
+
+        std::vector<sd::Tensor<float>> encode_video_block_outputs(const int n_threads,
+                                                                  const sd::Tensor<float>& frames,
+                                                                  bool auto_free           = false,
+                                                                  bool free_compute_buffer = false,
+                                                                  bool free_compute_params = false) {
+            int grid_h        = static_cast<int>(frames.shape()[1] / config.vision.patch_size);
+            int grid_w        = static_cast<int>(frames.shape()[0] / config.vision.patch_size);
+            auto pixel_values = process_video_block_tensor(frames, config.vision);
+            auto get_graph    = [&]() -> ggml_cgraph* {
+                return build_encode_video_block_outputs_graph(pixel_values, grid_h, grid_w);
+            };
+            auto combined = take_or_empty(GGMLRunner::compute<float>(get_graph,
+                                                                     n_threads,
+                                                                     auto_free,
+                                                                     free_compute_buffer,
+                                                                     free_compute_params));
+            if (combined.empty()) {
+                return {};
+            }
+            size_t output_count = config.vision.deepstack_visual_indexes.size() + 1;
+            GGML_ASSERT(combined.shape()[0] == config.hidden_size * static_cast<int64_t>(output_count));
+            std::vector<sd::Tensor<float>> outputs;
+            outputs.reserve(output_count);
+            for (size_t i = 0; i < output_count; ++i) {
+                outputs.push_back(sd::ops::slice(combined,
+                                                 0,
+                                                 static_cast<int64_t>(i) * config.hidden_size,
+                                                 static_cast<int64_t>(i + 1) * config.hidden_size));
+            }
+            return outputs;
+        }
     };
 
     struct LLMEmbedder {
diff --git a/src/model/vae/audio_vae.hpp b/src/model/vae/audio_vae.hpp
new file mode 100644
index 000000000..bec929097
--- /dev/null
+++ b/src/model/vae/audio_vae.hpp
@@ -0,0 +1,28 @@
+#ifndef __SD_MODEL_VAE_AUDIO_VAE_HPP__
+#define __SD_MODEL_VAE_AUDIO_VAE_HPP__
+
+#include "core/ggml_extend.hpp"
+
+struct AudioVAERunner : public GGMLRunner {
+    AudioVAERunner(ggml_backend_t backend,
+                   std::shared_ptr<RunnerWeightManager> weight_manager = nullptr)
+        : GGMLRunner(backend, weight_manager) {}
+
+    virtual void get_param_tensors(std::map<std::string, ggml_tensor*>& tensors) = 0;
+    virtual size_t get_params_mem_size()                                         = 0;
+    virtual std::string get_desc()                                               = 0;
+    virtual sd::Tensor<float> encode(int n_threads,
+                                     const sd::Tensor<float>& waveform) {
+        SD_UNUSED(n_threads);
+        SD_UNUSED(waveform);
+        return {};
+    }
+    virtual sd::Tensor<float> decode(int n_threads,
+                                     const sd::Tensor<float>& latent_tensor) = 0;
+    virtual int input_sample_rate() const {
+        return output_sample_rate();
+    }
+    virtual int output_sample_rate() const = 0;
+};
+
+#endif  // __SD_MODEL_VAE_AUDIO_VAE_HPP__
diff --git a/src/model/vae/ltx_audio_vae.hpp b/src/model/vae/ltx_audio_vae.hpp
index 71070d6a2..3319a5c35 100644
--- a/src/model/vae/ltx_audio_vae.hpp
+++ b/src/model/vae/ltx_audio_vae.hpp
@@ -8,6 +8,7 @@
 #include <vector>
 
 #include "core/ggml_extend.hpp"
+#include "model/vae/audio_vae.hpp"
 #include "model_loader.h"
 #include "model_manager.h"
 
@@ -996,7 +997,7 @@ namespace LTXV {
         }
     };
 
-    struct LTXAudioVAERunner : public GGMLRunner {
+    struct LTXAudioVAERunner : public AudioVAERunner {
         LTXAudioVAEConfig config;
         LTXAudioVAE model;
         std::string weight_prefix;
@@ -1006,7 +1007,7 @@ namespace LTXV {
                           const String2TensorStorage& tensor_storage_map,
                           const std::string& prefix                           = "",
                           std::shared_ptr<RunnerWeightManager> weight_manager = nullptr)
-            : GGMLRunner(backend, weight_manager),
+            : AudioVAERunner(backend, weight_manager),
               weight_prefix(prefix),
               config(LTXAudioVAEConfig::detect_from_weights(tensor_storage_map)),
               model(config) {
@@ -1017,20 +1018,20 @@ namespace LTXV {
             }
         }
 
-        void get_param_tensors(std::map<std::string, ggml_tensor*>& tensors) {
+        void get_param_tensors(std::map<std::string, ggml_tensor*>& tensors) override {
             model.get_param_tensors(tensors, weight_prefix);
         }
 
-        size_t get_params_mem_size() {
+        size_t get_params_mem_size() override {
             return model.get_params_mem_size();
         }
 
-        std::string get_desc() {
+        std::string get_desc() override {
             return "ltx_audio_vae";
         }
 
         sd::Tensor<float> decode(int n_threads,
-                                 const sd::Tensor<float>& latent_tensor) {
+                                 const sd::Tensor<float>& latent_tensor) override {
             int64_t t0     = ggml_time_ms();
             auto get_graph = [&]() -> ggml_cgraph* {
                 auto latent                  = make_input(latent_tensor);
@@ -1047,6 +1048,10 @@ namespace LTXV {
             return result;
         }
 
+        int output_sample_rate() const override {
+            return config.output_sample_rate();
+        }
+
         void test(const std::string& input_path) {
             auto z = sd::load_tensor_from_file_as_tensor<float>(input_path);
             GGML_ASSERT(!z.empty());
diff --git a/src/model/vae/minimax_h3_audio_vae.hpp b/src/model/vae/minimax_h3_audio_vae.hpp
new file mode 100644
index 000000000..5af751e36
--- /dev/null
+++ b/src/model/vae/minimax_h3_audio_vae.hpp
@@ -0,0 +1,497 @@
+#ifndef __SD_MODEL_VAE_MINIMAX_H3_AUDIO_VAE_HPP__
+#define __SD_MODEL_VAE_MINIMAX_H3_AUDIO_VAE_HPP__
+
+#include <array>
+#include <string>
+#include <vector>
+
+#include "model/vae/audio_vae.hpp"
+#include "model/vae/ltx_audio_vae.hpp"
+
+namespace MiniMaxH3 {
+
+    struct AudioSnake1D : public UnaryBlock {
+        int64_t channels;
+
+        explicit AudioSnake1D(int64_t channels)
+            : channels(channels) {}
+
+        void init_params(ggml_context* ctx,
+                         const String2TensorStorage& tensor_storage_map = {},
+                         const std::string prefix                       = "") override {
+            SD_UNUSED(tensor_storage_map);
+            SD_UNUSED(prefix);
+            params["alpha"] = ggml_new_tensor_3d(ctx, GGML_TYPE_F32, 1, channels, 1);
+        }
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* x) override {
+            auto alpha       = params["alpha"];
+            auto oscillation = ggml_sin(ctx->ggml_ctx, ggml_mul(ctx->ggml_ctx, x, alpha));
+            oscillation      = ggml_mul(ctx->ggml_ctx, oscillation, oscillation);
+            auto eps         = ggml_ext_scale(ctx->ggml_ctx, ggml_ext_ones(ctx->ggml_ctx, 1, 1, 1, 1), 1e-9f);
+            return ggml_add(ctx->ggml_ctx,
+                            x,
+                            ggml_div(ctx->ggml_ctx, oscillation, ggml_add(ctx->ggml_ctx, alpha, eps)));
+        }
+    };
+
+    struct AudioEncoderResidualUnit : public GGMLBlock {
+        int64_t channels;
+
+        AudioEncoderResidualUnit(int64_t channels, int dilation)
+            : channels(channels) {
+            blocks["block.0"] = std::make_shared<AudioSnake1D>(channels);
+            blocks["block.1"] = std::make_shared<LTXV::Conv1D>(channels,
+                                                               channels,
+                                                               7,
+                                                               1,
+                                                               3 * dilation,
+                                                               dilation);
+            blocks["block.2"] = std::make_shared<AudioSnake1D>(channels);
+            blocks["block.3"] = std::make_shared<LTXV::Conv1D>(channels, channels, 1);
+        }
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* x) {
+            auto act1  = std::dynamic_pointer_cast<AudioSnake1D>(blocks["block.0"]);
+            auto conv1 = std::dynamic_pointer_cast<LTXV::Conv1D>(blocks["block.1"]);
+            auto act2  = std::dynamic_pointer_cast<AudioSnake1D>(blocks["block.2"]);
+            auto conv2 = std::dynamic_pointer_cast<LTXV::Conv1D>(blocks["block.3"]);
+            auto h     = conv2->forward(ctx, act2->forward(ctx, conv1->forward(ctx, act1->forward(ctx, x))));
+            if (x->ne[0] != h->ne[0]) {
+                int64_t pad = (x->ne[0] - h->ne[0]) / 2;
+                x           = ggml_ext_slice(ctx->ggml_ctx, x, 0, pad, x->ne[0] - pad);
+            }
+            return ggml_add(ctx->ggml_ctx, x, h);
+        }
+    };
+
+    struct AudioEncoderBlock : public GGMLBlock {
+        int64_t out_channels;
+
+        AudioEncoderBlock(int64_t out_channels, int stride)
+            : out_channels(out_channels) {
+            int64_t in_channels = out_channels / 2;
+            blocks["block.0"]   = std::make_shared<AudioEncoderResidualUnit>(in_channels, 1);
+            blocks["block.1"]   = std::make_shared<AudioEncoderResidualUnit>(in_channels, 3);
+            blocks["block.2"]   = std::make_shared<AudioEncoderResidualUnit>(in_channels, 9);
+            blocks["block.3"]   = std::make_shared<AudioSnake1D>(in_channels);
+            blocks["block.4"]   = std::make_shared<LTXV::Conv1D>(in_channels,
+                                                               out_channels,
+                                                               2 * stride,
+                                                               stride,
+                                                               static_cast<int>(std::ceil(stride / 2.f)));
+        }
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* x) {
+            for (int i = 0; i < 3; ++i) {
+                auto unit = std::dynamic_pointer_cast<AudioEncoderResidualUnit>(blocks["block." + std::to_string(i)]);
+                x         = unit->forward(ctx, x);
+            }
+            auto act  = std::dynamic_pointer_cast<AudioSnake1D>(blocks["block.3"]);
+            auto conv = std::dynamic_pointer_cast<LTXV::Conv1D>(blocks["block.4"]);
+            return conv->forward(ctx, act->forward(ctx, x));
+        }
+    };
+
+    struct AudioEncoder : public GGMLBlock {
+        static constexpr std::array<int, 5> strides = {2, 4, 4, 5, 5};
+
+        AudioEncoder() {
+            int64_t channels  = 64;
+            blocks["block.0"] = std::make_shared<LTXV::Conv1D>(1, channels, 7, 1, 3);
+            for (size_t i = 0; i < strides.size(); ++i) {
+                channels *= 2;
+                blocks["block." + std::to_string(i + 1)] = std::make_shared<AudioEncoderBlock>(channels, strides[i]);
+            }
+            blocks["block.6"] = std::make_shared<AudioSnake1D>(channels);
+            blocks["block.7"] = std::make_shared<LTXV::Conv1D>(channels, 2048, 3, 1, 1);
+        }
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* x) {
+            auto input = std::dynamic_pointer_cast<LTXV::Conv1D>(blocks["block.0"]);
+            x          = input->forward(ctx, x);
+            for (size_t i = 0; i < strides.size(); ++i) {
+                auto block = std::dynamic_pointer_cast<AudioEncoderBlock>(blocks["block." + std::to_string(i + 1)]);
+                x          = block->forward(ctx, x);
+            }
+            auto act = std::dynamic_pointer_cast<AudioSnake1D>(blocks["block.6"]);
+            auto out = std::dynamic_pointer_cast<LTXV::Conv1D>(blocks["block.7"]);
+            return out->forward(ctx, act->forward(ctx, x));
+        }
+    };
+
+    struct AudioGeGLUMLP : public GGMLBlock {
+        AudioGeGLUMLP(int64_t hidden_size, int64_t intermediate_size) {
+            blocks["norm"] = std::make_shared<LayerNorm>(hidden_size);
+            blocks["w0"]   = std::make_shared<Linear>(hidden_size, intermediate_size, true);
+            blocks["w1"]   = std::make_shared<Linear>(hidden_size, intermediate_size, true);
+            blocks["w2"]   = std::make_shared<Linear>(intermediate_size, hidden_size, true);
+        }
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* x) {
+            auto norm = std::dynamic_pointer_cast<LayerNorm>(blocks["norm"]);
+            auto w0   = std::dynamic_pointer_cast<Linear>(blocks["w0"]);
+            auto w1   = std::dynamic_pointer_cast<Linear>(blocks["w1"]);
+            auto w2   = std::dynamic_pointer_cast<Linear>(blocks["w2"]);
+            x         = norm->forward(ctx, x);
+            auto gate = ggml_ext_gelu(ctx->ggml_ctx, w0->forward(ctx, x), true);
+            return w2->forward(ctx, ggml_mul(ctx->ggml_ctx, gate, w1->forward(ctx, x)));
+        }
+    };
+
+    struct AudioCausalAttention : public GGMLBlock {
+        static constexpr int64_t in_channels  = 2048;
+        static constexpr int64_t out_channels = 32;
+        static constexpr int64_t num_head     = 8;
+        static constexpr int64_t head_dim     = in_channels / num_head;
+
+        AudioCausalAttention() {
+            blocks["qkv"]  = std::make_shared<Linear>(in_channels, in_channels * 3, false);
+            blocks["proj"] = std::make_shared<Linear>(out_channels, out_channels, true);
+        }
+
+        void init_params(ggml_context* ctx,
+                         const String2TensorStorage& tensor_storage_map = {},
+                         const std::string prefix                       = "") override {
+            GGMLBlock::init_params(ctx, tensor_storage_map, prefix);
+            params["q_bias"] = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, in_channels);
+            params["v_bias"] = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, in_channels);
+        }
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* x) {
+            auto qkv_layer  = std::dynamic_pointer_cast<Linear>(blocks["qkv"]);
+            auto proj       = std::dynamic_pointer_cast<Linear>(blocks["proj"]);
+            auto qkv        = ggml_ext_chunk(ctx->ggml_ctx, qkv_layer->forward(ctx, x), 3, 0);
+            auto bias_shape = [&](ggml_tensor* bias) {
+                return ggml_reshape_4d(ctx->ggml_ctx, bias, bias->ne[0], 1, 1, 1);
+            };
+            auto q = ggml_add(ctx->ggml_ctx, qkv[0], bias_shape(params["q_bias"]));
+            auto k = qkv[1];
+            auto v = ggml_add(ctx->ggml_ctx, qkv[2], bias_shape(params["v_bias"]));
+
+            int64_t sequence = x->ne[1];
+            auto mask        = ggml_diag_mask_inf(ctx->ggml_ctx,
+                                                  ggml_ext_zeros(ctx->ggml_ctx, sequence, sequence, 1, 1),
+                                                  0);
+            auto attn_out    = ggml_ext_attention_ext(ctx->ggml_ctx,
+                                                      ctx->backend,
+                                                      q,
+                                                      k,
+                                                      v,
+                                                      num_head,
+                                                      mask,
+                                                      false,
+                                                      ctx->flash_attn_enabled);
+            int64_t batch    = attn_out->ne[2] * attn_out->ne[3];
+            attn_out         = ggml_reshape_4d(ctx->ggml_ctx, attn_out, head_dim, num_head, sequence, batch);
+            attn_out         = ggml_cont(ctx->ggml_ctx, ggml_permute(ctx->ggml_ctx, attn_out, 1, 0, 2, 3));
+            attn_out         = ggml_mean(ctx->ggml_ctx, attn_out);
+            attn_out         = ggml_reshape_3d(ctx->ggml_ctx, attn_out, head_dim, sequence, batch);
+
+            constexpr int64_t pool = head_dim / out_channels;
+            attn_out               = ggml_reshape_4d(ctx->ggml_ctx, attn_out, pool, out_channels, sequence, batch);
+            attn_out               = ggml_mean(ctx->ggml_ctx, attn_out);
+            attn_out               = ggml_reshape_3d(ctx->ggml_ctx, attn_out, out_channels, sequence, batch);
+            return proj->forward(ctx, attn_out);
+        }
+    };
+
+    struct AudioAttentionProjection : public GGMLBlock {
+        AudioAttentionProjection() {
+            blocks["norm1"] = std::make_shared<LayerNorm>(2048);
+            blocks["attn"]  = std::make_shared<AudioCausalAttention>();
+            blocks["proj"]  = std::make_shared<Linear>(2048, 32, true);
+            blocks["norm3"] = std::make_shared<LayerNorm>(2048);
+            blocks["norm2"] = std::make_shared<LayerNorm>(32);
+            blocks["mlp"]   = std::make_shared<AudioGeGLUMLP>(32, 64);
+        }
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* x) {
+            auto norm1 = std::dynamic_pointer_cast<LayerNorm>(blocks["norm1"]);
+            auto attn  = std::dynamic_pointer_cast<AudioCausalAttention>(blocks["attn"]);
+            auto proj  = std::dynamic_pointer_cast<Linear>(blocks["proj"]);
+            auto norm3 = std::dynamic_pointer_cast<LayerNorm>(blocks["norm3"]);
+            auto norm2 = std::dynamic_pointer_cast<LayerNorm>(blocks["norm2"]);
+            auto mlp   = std::dynamic_pointer_cast<AudioGeGLUMLP>(blocks["mlp"]);
+            x          = ggml_add(ctx->ggml_ctx,
+                                  proj->forward(ctx, norm3->forward(ctx, x)),
+                                  attn->forward(ctx, norm1->forward(ctx, x)));
+            return ggml_add(ctx->ggml_ctx, x, mlp->forward(ctx, norm2->forward(ctx, x)));
+        }
+    };
+
+    struct AudioAMPBlock : public GGMLBlock {
+        int channels;
+
+        AudioAMPBlock(int channels,
+                      int kernel_size,
+                      const std::array<int, 3>& dilations)
+            : channels(channels) {
+            for (int i = 0; i < 3; ++i) {
+                blocks["activations." + std::to_string(i * 2)] =
+                    std::make_shared<LTXV::Activation1D>(channels);
+                blocks["activations." + std::to_string(i * 2 + 1)] =
+                    std::make_shared<LTXV::Activation1D>(channels);
+                blocks["convs1." + std::to_string(i)] =
+                    std::make_shared<LTXV::Conv1D>(channels,
+                                                   channels,
+                                                   kernel_size,
+                                                   1,
+                                                   (kernel_size * dilations[i] - dilations[i]) / 2,
+                                                   dilations[i]);
+                blocks["convs2." + std::to_string(i)] =
+                    std::make_shared<LTXV::Conv1D>(channels,
+                                                   channels,
+                                                   kernel_size,
+                                                   1,
+                                                   kernel_size / 2);
+            }
+        }
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* x) {
+            for (int i = 0; i < 3; ++i) {
+                auto act1 = std::dynamic_pointer_cast<LTXV::Activation1D>(
+                    blocks["activations." + std::to_string(i * 2)]);
+                auto act2 = std::dynamic_pointer_cast<LTXV::Activation1D>(
+                    blocks["activations." + std::to_string(i * 2 + 1)]);
+                auto conv1 = std::dynamic_pointer_cast<LTXV::Conv1D>(
+                    blocks["convs1." + std::to_string(i)]);
+                auto conv2 = std::dynamic_pointer_cast<LTXV::Conv1D>(
+                    blocks["convs2." + std::to_string(i)]);
+
+                auto h = conv1->forward(ctx, act1->forward(ctx, x));
+                h      = conv2->forward(ctx, act2->forward(ctx, h));
+                x      = ggml_add(ctx->ggml_ctx, x, h);
+            }
+            return x;
+        }
+    };
+
+    struct BigVGAN : public GGMLBlock {
+        static constexpr int initial_channels                     = 1024;
+        static constexpr int num_kernels                          = 3;
+        static constexpr int num_upsamples                        = 7;
+        static constexpr std::array<int, num_upsamples> rates     = {5, 5, 2, 2, 2, 2, 2};
+        static constexpr std::array<int, num_upsamples> kernels   = {9, 9, 4, 4, 4, 4, 4};
+        static constexpr std::array<int, num_kernels> res_kernels = {3, 7, 11};
+
+        BigVGAN() {
+            blocks["conv_pre"] = std::make_shared<LTXV::Conv1D>(2048,
+                                                                initial_channels,
+                                                                7,
+                                                                1,
+                                                                3);
+            int channels       = initial_channels;
+            for (int i = 0; i < num_upsamples; ++i) {
+                int next_channels = initial_channels / (1 << (i + 1));
+                blocks["ups." + std::to_string(i) + ".0"] =
+                    std::make_shared<LTXV::ConvTranspose1D>(channels,
+                                                            next_channels,
+                                                            kernels[i],
+                                                            rates[i],
+                                                            (kernels[i] - rates[i]) / 2);
+                for (int j = 0; j < num_kernels; ++j) {
+                    blocks["resblocks." + std::to_string(i * num_kernels + j)] =
+                        std::make_shared<AudioAMPBlock>(next_channels,
+                                                        res_kernels[j],
+                                                        std::array<int, 3>{1, 3, 5});
+                }
+                channels = next_channels;
+            }
+            blocks["activation_post"] = std::make_shared<LTXV::Activation1D>(channels);
+            blocks["conv_post"]       = std::make_shared<LTXV::Conv1D>(channels,
+                                                                 1,
+                                                                 7,
+                                                                 1,
+                                                                 3,
+                                                                 1,
+                                                                 false);
+        }
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* x) {
+            auto conv_pre = std::dynamic_pointer_cast<LTXV::Conv1D>(blocks["conv_pre"]);
+            x             = conv_pre->forward(ctx, x);
+            for (int i = 0; i < num_upsamples; ++i) {
+                auto up = std::dynamic_pointer_cast<LTXV::ConvTranspose1D>(
+                    blocks["ups." + std::to_string(i) + ".0"]);
+                x = up->forward(ctx, x);
+
+                ggml_tensor* sum = nullptr;
+                for (int j = 0; j < num_kernels; ++j) {
+                    auto block = std::dynamic_pointer_cast<AudioAMPBlock>(
+                        blocks["resblocks." + std::to_string(i * num_kernels + j)]);
+                    auto value = block->forward(ctx, x);
+                    sum        = sum == nullptr ? value : ggml_add(ctx->ggml_ctx, sum, value);
+                }
+                x = ggml_ext_scale(ctx->ggml_ctx, sum, 1.f / num_kernels);
+            }
+            auto activation = std::dynamic_pointer_cast<LTXV::Activation1D>(blocks["activation_post"]);
+            auto conv_post  = std::dynamic_pointer_cast<LTXV::Conv1D>(blocks["conv_post"]);
+            return ggml_clamp(ctx->ggml_ctx,
+                              conv_post->forward(ctx, activation->forward(ctx, x)),
+                              -1.f,
+                              1.f);
+        }
+    };
+
+    struct AudioVAE : public GGMLBlock {
+        static constexpr int kLatentChannels = 32;
+
+        AudioVAE() {
+            blocks["encoder"]     = std::make_shared<AudioEncoder>();
+            blocks["pre_block"]   = std::make_shared<AudioAttentionProjection>();
+            blocks["mean_proj"]   = std::make_shared<LTXV::Conv1D>(kLatentChannels, kLatentChannels, 1);
+            blocks["logs_proj"]   = std::make_shared<LTXV::Conv1D>(kLatentChannels, kLatentChannels, 1);
+            blocks["dec_in_proj"] = std::make_shared<LTXV::Conv1D>(kLatentChannels,
+                                                                   2048,
+                                                                   1);
+            blocks["decoder"]     = std::make_shared<BigVGAN>();
+        }
+
+        void init_params(ggml_context* ctx,
+                         const String2TensorStorage& tensor_storage_map = {},
+                         const std::string prefix                       = "") override {
+            SD_UNUSED(tensor_storage_map);
+            SD_UNUSED(prefix);
+            params["latents_mean"] = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, kLatentChannels);
+            params["latents_std"]  = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, kLatentChannels);
+        }
+
+        ggml_tensor* encode(GGMLRunnerContext* ctx, ggml_tensor* waveform) {
+            GGML_ASSERT(waveform->ne[1] == 2);
+            auto encoder   = std::dynamic_pointer_cast<AudioEncoder>(blocks["encoder"]);
+            auto pre       = std::dynamic_pointer_cast<AudioAttentionProjection>(blocks["pre_block"]);
+            auto mean_proj = std::dynamic_pointer_cast<LTXV::Conv1D>(blocks["mean_proj"]);
+
+            waveform = ggml_reshape_3d(ctx->ggml_ctx, waveform, waveform->ne[0], 1, waveform->ne[1]);
+            auto x   = encoder->forward(ctx, waveform);  // [B*S, 2048, T]
+            x        = ggml_cont(ctx->ggml_ctx, ggml_permute(ctx->ggml_ctx, x, 1, 0, 2, 3));
+            x        = pre->forward(ctx, x);
+            x        = ggml_cont(ctx->ggml_ctx, ggml_permute(ctx->ggml_ctx, x, 1, 0, 2, 3));
+            auto z   = mean_proj->forward(ctx, x);
+
+            auto mean = ggml_reshape_4d(ctx->ggml_ctx, params["latents_mean"], 1, kLatentChannels, 1, 1);
+            auto std  = ggml_reshape_4d(ctx->ggml_ctx, params["latents_std"], 1, kLatentChannels, 1, 1);
+            z         = ggml_div(ctx->ggml_ctx, ggml_sub(ctx->ggml_ctx, z, mean), std);
+            return ggml_cont(ctx->ggml_ctx, ggml_permute(ctx->ggml_ctx, z, 0, 2, 1, 3));
+        }
+
+        ggml_tensor* decode(GGMLRunnerContext* ctx, ggml_tensor* latent) {
+            GGML_ASSERT(latent->ne[1] == 2 && latent->ne[2] == kLatentChannels);
+            latent = ggml_cont(ctx->ggml_ctx,
+                               ggml_permute(ctx->ggml_ctx, latent, 0, 2, 1, 3));
+
+            auto mean = ggml_reshape_4d(ctx->ggml_ctx,
+                                        params["latents_mean"],
+                                        1,
+                                        kLatentChannels,
+                                        1,
+                                        1);
+            auto std  = ggml_reshape_4d(ctx->ggml_ctx,
+                                        params["latents_std"],
+                                        1,
+                                        kLatentChannels,
+                                        1,
+                                        1);
+            latent    = ggml_add(ctx->ggml_ctx,
+                                 ggml_mul(ctx->ggml_ctx, latent, std),
+                                 mean);
+
+            auto dec_in           = std::dynamic_pointer_cast<LTXV::Conv1D>(blocks["dec_in_proj"]);
+            auto decoder          = std::dynamic_pointer_cast<BigVGAN>(blocks["decoder"]);
+            int64_t streams       = latent->ne[2] * latent->ne[3];
+            latent                = ggml_reshape_3d(ctx->ggml_ctx,
+                                                    latent,
+                                                    latent->ne[0],
+                                                    latent->ne[1],
+                                                    streams);
+            ggml_tensor* waveform = nullptr;
+            for (int64_t stream = 0; stream < streams; ++stream) {
+                auto stream_latent   = ggml_ext_slice(ctx->ggml_ctx, latent, 2, stream, stream + 1);
+                auto stream_waveform = decoder->forward(ctx, dec_in->forward(ctx, stream_latent));
+                waveform             = waveform == nullptr
+                                           ? stream_waveform
+                                           : ggml_concat(ctx->ggml_ctx, waveform, stream_waveform, 2);
+            }
+            return ggml_reshape_4d(ctx->ggml_ctx,
+                                   waveform,
+                                   waveform->ne[0],
+                                   streams,
+                                   1,
+                                   1);
+        }
+    };
+
+    struct AudioVAERunner : public ::AudioVAERunner {
+        AudioVAE model;
+        std::string weight_prefix;
+
+        AudioVAERunner(ggml_backend_t backend,
+                       const String2TensorStorage& tensor_storage_map,
+                       const std::string& prefix                           = "",
+                       std::shared_ptr<RunnerWeightManager> weight_manager = nullptr)
+            : ::AudioVAERunner(backend, weight_manager),
+              weight_prefix(prefix) {
+            model.init(params_ctx, tensor_storage_map, prefix);
+        }
+
+        void get_param_tensors(std::map<std::string, ggml_tensor*>& tensors) override {
+            model.get_param_tensors(tensors, weight_prefix);
+        }
+
+        size_t get_params_mem_size() override {
+            return model.get_params_mem_size();
+        }
+
+        std::string get_desc() override {
+            return "minimax_h3_audio_vae";
+        }
+
+        int output_sample_rate() const override {
+            return 32000;
+        }
+
+        sd::Tensor<float> encode(int n_threads,
+                                 const sd::Tensor<float>& waveform) override {
+            int64_t t0     = ggml_time_ms();
+            auto get_graph = [&]() -> ggml_cgraph* {
+                auto input      = make_input(waveform);
+                auto runner_ctx = get_context();
+                auto latent     = model.encode(&runner_ctx, input);
+                auto graph      = new_graph_custom(655360);
+                ggml_build_forward_expand(graph, latent);
+                return graph;
+            };
+            auto result = restore_trailing_singleton_dims(
+                GGMLRunner::compute<float>(get_graph, n_threads, false, false, false),
+                4);
+            int64_t t1 = ggml_time_ms();
+            LOG_INFO("MiniMax-H3 audio VAE encode completed, taking %.2fs",
+                     (t1 - t0) / 1000.f);
+            return result;
+        }
+
+        sd::Tensor<float> decode(int n_threads,
+                                 const sd::Tensor<float>& latent_tensor) override {
+            int64_t t0     = ggml_time_ms();
+            auto get_graph = [&]() -> ggml_cgraph* {
+                auto latent     = make_input(latent_tensor);
+                auto runner_ctx = get_context();
+                auto waveform   = model.decode(&runner_ctx, latent);
+                auto graph      = new_graph_custom(655360);
+                ggml_build_forward_expand(graph, waveform);
+                return graph;
+            };
+            auto result = restore_trailing_singleton_dims(
+                GGMLRunner::compute<float>(get_graph, n_threads, false, false, false),
+                4);
+            int64_t t1 = ggml_time_ms();
+            LOG_INFO("MiniMax-H3 audio VAE decode completed, taking %.2fs",
+                     (t1 - t0) / 1000.f);
+            return result;
+        }
+    };
+
+}  // namespace MiniMaxH3
+
+#endif  // __SD_MODEL_VAE_MINIMAX_H3_AUDIO_VAE_HPP__
diff --git a/src/model/vae/minimax_h3_vae.hpp b/src/model/vae/minimax_h3_vae.hpp
new file mode 100644
index 000000000..163a9447a
--- /dev/null
+++ b/src/model/vae/minimax_h3_vae.hpp
@@ -0,0 +1,805 @@
+#ifndef __SD_MODEL_VAE_MINIMAX_H3_VAE_HPP__
+#define __SD_MODEL_VAE_MINIMAX_H3_VAE_HPP__
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <memory>
+#include <string>
+#include <tuple>
+#include <utility>
+#include <vector>
+
+#include "model/common/rope.hpp"
+#include "model/diffusion/dit.hpp"
+#include "model/vae/vae.hpp"
+
+namespace MiniMaxH3VAE {
+
+    constexpr int H3_VIDEO_VAE_GRAPH_SIZE = 262144;
+
+    struct CausalConv3d : public Conv3d {
+        std::tuple<int, int, int> temporal_padding;
+
+        CausalConv3d(int64_t in_channels,
+                     int64_t out_channels,
+                     std::tuple<int, int, int> kernel_size,
+                     std::tuple<int, int, int> stride  = {1, 1, 1},
+                     std::tuple<int, int, int> padding = {0, 0, 0})
+            : Conv3d(in_channels,
+                     out_channels,
+                     kernel_size,
+                     stride,
+                     {0, 0, 0}),
+              temporal_padding(padding) {}
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* x) override {
+            auto reflect_pad = [&](ggml_tensor* value, int dim, int amount) {
+                for (int i = 0; i < amount; ++i) {
+                    GGML_ASSERT(value->ne[dim] > 1);
+                    auto left  = ggml_ext_slice(ctx->ggml_ctx, value, dim, 1, 2);
+                    auto right = ggml_ext_slice(ctx->ggml_ctx,
+                                                value,
+                                                dim,
+                                                value->ne[dim] - 2,
+                                                value->ne[dim] - 1);
+                    value      = ggml_concat(ctx->ggml_ctx, left, value, dim);
+                    value      = ggml_concat(ctx->ggml_ctx, value, right, dim);
+                }
+                return value;
+            };
+
+            x                = reflect_pad(x, 0, std::get<2>(temporal_padding));
+            x                = reflect_pad(x, 1, std::get<1>(temporal_padding));
+            int temporal_pad = std::get<0>(temporal_padding) * 2;
+            if (temporal_pad > 0) {
+                x = ggml_ext_pad_ext(ctx->ggml_ctx,
+                                     ctx->backend,
+                                     x,
+                                     0,
+                                     0,
+                                     0,
+                                     0,
+                                     temporal_pad,
+                                     0,
+                                     0,
+                                     0);
+            }
+            return Conv3d::forward(ctx, x);
+        }
+    };
+
+    struct TemporalGroupNorm : public GroupNorm {
+        explicit TemporalGroupNorm(int64_t channels)
+            : GroupNorm(32, channels, 1e-6f, true) {}
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* x) {
+            ggml_tensor* result = nullptr;
+            for (int64_t t = 0; t < x->ne[2]; ++t) {
+                auto frame = ggml_ext_slice(ctx->ggml_ctx, x, 2, t, t + 1);
+                GGML_ASSERT(frame->ne[3] % num_channels == 0);
+                int64_t batch_size = frame->ne[3] / num_channels;
+                frame              = ggml_cont(ctx->ggml_ctx, frame);
+                frame              = ggml_reshape_4d(ctx->ggml_ctx,
+                                                     frame,
+                                                     frame->ne[0],
+                                                     frame->ne[1],
+                                                     num_channels,
+                                                     batch_size);
+                frame              = GroupNorm::forward(ctx, frame);
+                frame              = ggml_reshape_4d(ctx->ggml_ctx,
+                                                     frame,
+                                                     frame->ne[0],
+                                                     frame->ne[1],
+                                                     1,
+                                                     num_channels * batch_size);
+                result             = result == nullptr ? frame : ggml_concat(ctx->ggml_ctx, result, frame, 2);
+            }
+            return result;
+        }
+    };
+
+    struct Downsample3D : public GGMLBlock {
+        int spatial_stride;
+
+        Downsample3D(int64_t in_channels,
+                     int64_t out_channels,
+                     int temporal_stride,
+                     int spatial_stride)
+            : spatial_stride(spatial_stride) {
+            blocks["conv"] = std::make_shared<CausalConv3d>(in_channels,
+                                                            out_channels,
+                                                            std::tuple{3, 3, 3},
+                                                            std::tuple{temporal_stride, spatial_stride, spatial_stride},
+                                                            std::tuple{1, 0, 0});
+        }
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* x) {
+            if (spatial_stride == 2) {
+                GGML_ASSERT(x->ne[0] > 1 && x->ne[1] > 1);
+                auto right  = ggml_ext_slice(ctx->ggml_ctx, x, 0, x->ne[0] - 2, x->ne[0] - 1);
+                x           = ggml_concat(ctx->ggml_ctx, x, right, 0);
+                auto bottom = ggml_ext_slice(ctx->ggml_ctx, x, 1, x->ne[1] - 2, x->ne[1] - 1);
+                x           = ggml_concat(ctx->ggml_ctx, x, bottom, 1);
+            }
+            return std::dynamic_pointer_cast<CausalConv3d>(blocks["conv"])->forward(ctx, x);
+        }
+    };
+
+    struct ResnetBlock3D : public GGMLBlock {
+        int64_t in_channels;
+        int64_t out_channels;
+
+        ResnetBlock3D(int64_t in_channels,
+                      int64_t out_channels)
+            : in_channels(in_channels), out_channels(out_channels) {
+            blocks["norm1"] = std::make_shared<TemporalGroupNorm>(in_channels);
+            blocks["norm2"] = std::make_shared<TemporalGroupNorm>(out_channels);
+            blocks["conv1"] = std::make_shared<CausalConv3d>(in_channels,
+                                                             out_channels,
+                                                             std::tuple{3, 3, 3},
+                                                             std::tuple{1, 1, 1},
+                                                             std::tuple{1, 1, 1});
+            blocks["conv2"] = std::make_shared<CausalConv3d>(out_channels,
+                                                             out_channels,
+                                                             std::tuple{3, 3, 3},
+                                                             std::tuple{1, 1, 1},
+                                                             std::tuple{1, 1, 1});
+            if (in_channels != out_channels) {
+                blocks["nin_shortcut"] = std::make_shared<CausalConv3d>(in_channels,
+                                                                        out_channels,
+                                                                        std::tuple{1, 1, 1});
+            }
+        }
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* x) {
+            auto norm1 = std::dynamic_pointer_cast<TemporalGroupNorm>(blocks["norm1"]);
+            auto norm2 = std::dynamic_pointer_cast<TemporalGroupNorm>(blocks["norm2"]);
+            auto conv1 = std::dynamic_pointer_cast<CausalConv3d>(blocks["conv1"]);
+            auto conv2 = std::dynamic_pointer_cast<CausalConv3d>(blocks["conv2"]);
+            auto h     = conv1->forward(ctx, ggml_silu(ctx->ggml_ctx, norm1->forward(ctx, x)));
+            h          = conv2->forward(ctx, ggml_silu(ctx->ggml_ctx, norm2->forward(ctx, h)));
+            if (in_channels != out_channels) {
+                x = std::dynamic_pointer_cast<CausalConv3d>(blocks["nin_shortcut"])->forward(ctx, x);
+            }
+            return ggml_add(ctx->ggml_ctx, x, h);
+        }
+    };
+
+    struct Encoder : public GGMLBlock {
+        static constexpr int levels                            = 6;
+        static constexpr std::array<int, levels> multipliers   = {1, 2, 2, 4, 4, 8};
+        static constexpr std::array<int, levels> spatial_down  = {2, 2, 2, 2, 1, 1};
+        static constexpr std::array<int, levels> temporal_down = {1, 2, 2, 1, 1, 1};
+
+        Encoder() {
+            constexpr int ch  = 128;
+            blocks["conv_in"] = std::make_shared<CausalConv3d>(3,
+                                                               ch,
+                                                               std::tuple{3, 3, 3},
+                                                               std::tuple{1, 1, 1},
+                                                               std::tuple{1, 1, 1});
+            int64_t previous  = ch;
+            for (int level = 0; level < levels; ++level) {
+                int64_t current = ch * multipliers[level];
+                for (int block = 0; block < 2; ++block) {
+                    blocks["down." + std::to_string(level) + ".block." + std::to_string(block)] =
+                        std::make_shared<ResnetBlock3D>(block == 0 ? previous : current,
+                                                        current);
+                }
+                if (spatial_down[level] * temporal_down[level] > 1) {
+                    blocks["down." + std::to_string(level) + ".downsample"] =
+                        std::make_shared<Downsample3D>(current,
+                                                       current,
+                                                       temporal_down[level],
+                                                       spatial_down[level]);
+                }
+                previous = current;
+            }
+            blocks["norm_out"] = std::make_shared<TemporalGroupNorm>(previous);
+            blocks["conv_out"] = std::make_shared<CausalConv3d>(previous,
+                                                                48,
+                                                                std::tuple{3, 3, 3},
+                                                                std::tuple{1, 1, 1},
+                                                                std::tuple{1, 1, 1});
+        }
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* x) {
+            x = std::dynamic_pointer_cast<CausalConv3d>(blocks["conv_in"])->forward(ctx, x);
+            for (int level = 0; level < levels; ++level) {
+                for (int block = 0; block < 2; ++block) {
+                    x = std::dynamic_pointer_cast<ResnetBlock3D>(
+                            blocks["down." + std::to_string(level) + ".block." + std::to_string(block)])
+                            ->forward(ctx, x);
+                }
+                auto downsample = blocks.find("down." + std::to_string(level) + ".downsample");
+                if (downsample != blocks.end()) {
+                    x = std::dynamic_pointer_cast<Downsample3D>(downsample->second)->forward(ctx, x);
+                }
+            }
+            auto norm = std::dynamic_pointer_cast<TemporalGroupNorm>(blocks["norm_out"]);
+            auto conv = std::dynamic_pointer_cast<CausalConv3d>(blocks["conv_out"]);
+            return conv->forward(ctx, ggml_silu(ctx->ggml_ctx, norm->forward(ctx, x)));
+        }
+    };
+
+    static ggml_tensor* attention_layout(ggml_context* ctx, ggml_tensor* x) {
+        x = ggml_cont(ctx, ggml_permute(ctx, x, 0, 2, 1, 3));
+        return ggml_reshape_3d(ctx, x, x->ne[0], x->ne[1], x->ne[2] * x->ne[3]);
+    }
+
+    static ggml_tensor* apply_partial_rope(ggml_context* ctx,
+                                           ggml_tensor* x,
+                                           ggml_tensor* pe) {
+        int64_t rot_dim = pe->ne[2] * 2;
+        auto rotated    = Rope::apply_rope(ctx,
+                                           ggml_ext_slice(ctx, x, 0, 0, rot_dim),
+                                           pe,
+                                           false);
+        if (rot_dim == x->ne[0]) {
+            return rotated;
+        }
+        auto tail = attention_layout(ctx,
+                                     ggml_ext_slice(ctx, x, 0, rot_dim, x->ne[0]));
+        return ggml_concat(ctx, rotated, tail, 0);
+    }
+
+    struct DecoderAttention : public GGMLBlock {
+        static constexpr int num_head = 32;
+        static constexpr int head_dim = 64;
+        static constexpr int dim      = num_head * head_dim;
+
+        DecoderAttention() {
+            blocks["to_qkv"] = std::make_shared<Linear>(dim, dim * 3, true);
+            blocks["to_out"] = std::make_shared<Linear>(dim, dim, true);
+        }
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx,
+                             ggml_tensor* x,
+                             ggml_tensor* pe) {
+            auto to_qkv         = std::dynamic_pointer_cast<Linear>(blocks["to_qkv"]);
+            auto to_out         = std::dynamic_pointer_cast<Linear>(blocks["to_out"]);
+            auto qkv_projection = to_qkv->forward(ctx, x);
+            int64_t sequence    = x->ne[1];
+            int64_t batch_size  = x->ne[2] * x->ne[3];
+            qkv_projection      = ggml_reshape_4d(ctx->ggml_ctx,
+                                                  qkv_projection,
+                                                  3 * head_dim,
+                                                  num_head,
+                                                  sequence,
+                                                  batch_size);
+            auto qkv            = ggml_ext_chunk(ctx->ggml_ctx, qkv_projection, 3, 0);
+            auto q              = ggml_reshape_4d(ctx->ggml_ctx,
+                                                  qkv[0],
+                                                  head_dim,
+                                                  num_head,
+                                                  sequence,
+                                                  batch_size);
+            auto k              = ggml_reshape_4d(ctx->ggml_ctx,
+                                                  qkv[1],
+                                                  head_dim,
+                                                  num_head,
+                                                  sequence,
+                                                  batch_size);
+            auto v              = ggml_reshape_4d(ctx->ggml_ctx,
+                                                  qkv[2],
+                                                  head_dim,
+                                                  num_head,
+                                                  sequence,
+                                                  batch_size);
+            q                   = ggml_rms_norm(ctx->ggml_ctx, q, 1e-5f);
+            k                   = ggml_rms_norm(ctx->ggml_ctx, k, 1e-5f);
+            q                   = apply_partial_rope(ctx->ggml_ctx, q, pe);
+            k                   = apply_partial_rope(ctx->ggml_ctx, k, pe);
+            auto out            = ggml_ext_attention_ext(ctx->ggml_ctx,
+                                                         ctx->backend,
+                                                         q,
+                                                         k,
+                                                         v,
+                                                         num_head,
+                                                         nullptr,
+                                                         true,
+                                                         ctx->flash_attn_enabled);
+            return to_out->forward(ctx, out);
+        }
+    };
+
+    struct DecoderFeedForward : public GGMLBlock {
+        static constexpr int dim       = 2048;
+        static constexpr int kInnerDim = dim * 4;
+
+        DecoderFeedForward() {
+            blocks["w1"] = std::make_shared<Linear>(dim, kInnerDim * 2, true);
+            blocks["w2"] = std::make_shared<Linear>(kInnerDim, dim, true);
+        }
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* x) {
+            auto w1   = std::dynamic_pointer_cast<Linear>(blocks["w1"]);
+            auto w2   = std::dynamic_pointer_cast<Linear>(blocks["w2"]);
+            auto gate = ggml_ext_chunk(ctx->ggml_ctx, w1->forward(ctx, x), 2, 0);
+            return w2->forward(ctx,
+                               ggml_mul(ctx->ggml_ctx,
+                                        ggml_silu(ctx->ggml_ctx, gate[0]),
+                                        gate[1]));
+        }
+    };
+
+    struct DecoderBlock : public GGMLBlock {
+        static constexpr int dim = 2048;
+
+        DecoderBlock() {
+            blocks["norm1"] = std::make_shared<RMSNorm>(dim, 1e-5f);
+            blocks["attn"]  = std::make_shared<DecoderAttention>();
+            blocks["norm2"] = std::make_shared<RMSNorm>(dim, 1e-5f);
+            blocks["ff"]    = std::make_shared<DecoderFeedForward>();
+        }
+
+        void init_params(ggml_context* ctx,
+                         const String2TensorStorage& tensor_storage_map = {},
+                         const std::string prefix                       = "") override {
+            SD_UNUSED(tensor_storage_map);
+            SD_UNUSED(prefix);
+            params["scale1"] = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, dim);
+            params["scale2"] = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, dim);
+        }
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx,
+                             ggml_tensor* x,
+                             ggml_tensor* pe) {
+            auto norm1 = std::dynamic_pointer_cast<RMSNorm>(blocks["norm1"]);
+            auto attn  = std::dynamic_pointer_cast<DecoderAttention>(blocks["attn"]);
+            auto norm2 = std::dynamic_pointer_cast<RMSNorm>(blocks["norm2"]);
+            auto ff    = std::dynamic_pointer_cast<DecoderFeedForward>(blocks["ff"]);
+            x          = ggml_add(ctx->ggml_ctx,
+                                  x,
+                                  ggml_mul(ctx->ggml_ctx,
+                                           attn->forward(ctx, norm1->forward(ctx, x), pe),
+                                           params["scale1"]));
+            return ggml_add(ctx->ggml_ctx,
+                            x,
+                            ggml_mul(ctx->ggml_ctx,
+                                     ff->forward(ctx, norm2->forward(ctx, x)),
+                                     params["scale2"]));
+        }
+    };
+
+    struct Decoder : public GGMLBlock {
+        static constexpr int dim                 = 2048;
+        static constexpr int num_layers          = 36;
+        static constexpr int num_register_tokens = 4;
+        static constexpr int patch_size          = 16;
+        static constexpr int patch_size_t        = 4;
+
+        Decoder() {
+            blocks["x_embedder"] = std::make_shared<Linear>(24, dim, true);
+            for (int i = 0; i < num_layers; ++i) {
+                blocks["transformer_blocks." + std::to_string(i)] =
+                    std::make_shared<DecoderBlock>();
+            }
+            blocks["norm_out"] = std::make_shared<LayerNorm>(dim, 1e-5f, true, true);
+            blocks["proj_out"] = std::make_shared<Linear>(dim,
+                                                          3 * patch_size_t * patch_size * patch_size,
+                                                          true,
+                                                          true);
+        }
+
+        void init_params(ggml_context* ctx,
+                         const String2TensorStorage& tensor_storage_map = {},
+                         const std::string prefix                       = "") override {
+            SD_UNUSED(tensor_storage_map);
+            SD_UNUSED(prefix);
+            params["register_tokens"] = ggml_new_tensor_2d(ctx,
+                                                           GGML_TYPE_F32,
+                                                           dim,
+                                                           num_register_tokens);
+            params["mask_token"]      = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, dim);
+        }
+
+        ggml_tensor* forward(GGMLRunnerContext* ctx,
+                             ggml_tensor* z,
+                             ggml_tensor* pe) {
+            int64_t width      = z->ne[0];
+            int64_t height     = z->ne[1];
+            int64_t num_frames = z->ne[2];
+            int64_t batch_size = z->ne[3] / 24;
+            GGML_ASSERT(batch_size == 1);
+
+            z                   = ggml_cont(ctx->ggml_ctx,
+                                            ggml_ext_torch_permute(ctx->ggml_ctx, z, 3, 0, 1, 2));
+            z                   = ggml_reshape_3d(ctx->ggml_ctx,
+                                                  z,
+                                                  24,
+                                                  width * height * num_frames,
+                                                  batch_size);
+            auto x_embedder     = std::dynamic_pointer_cast<Linear>(blocks["x_embedder"]);
+            auto h              = x_embedder->forward(ctx, z);
+            int64_t num_patches = h->ne[1];
+            h                   = ggml_concat(ctx->ggml_ctx, h, params["register_tokens"], 1);
+            auto zero           = ggml_ext_scale(ctx->ggml_ctx,
+                                                 ggml_ext_slice(ctx->ggml_ctx, h, 1, 0, 1),
+                                                 0.f);
+            h                   = ggml_concat(ctx->ggml_ctx, h, zero, 1);
+
+            for (int i = 0; i < num_layers; ++i) {
+                auto block = std::dynamic_pointer_cast<DecoderBlock>(
+                    blocks["transformer_blocks." + std::to_string(i)]);
+                h = block->forward(ctx, h, pe);
+                sd::ggml_graph_cut::mark_graph_cut(h,
+                                                   "minimax_h3_vae.decoder.blocks." + std::to_string(i),
+                                                   "hidden_states");
+            }
+
+            auto norm_out = std::dynamic_pointer_cast<LayerNorm>(blocks["norm_out"]);
+            auto proj_out = std::dynamic_pointer_cast<Linear>(blocks["proj_out"]);
+            h             = proj_out->forward(ctx, norm_out->forward(ctx, h));
+            h             = ggml_ext_slice(ctx->ggml_ctx, h, 1, 0, num_patches);
+            return DiT::unpatchify_3d(ctx->ggml_ctx,
+                                      h,
+                                      num_frames,
+                                      height,
+                                      width,
+                                      patch_size_t,
+                                      patch_size,
+                                      patch_size,
+                                      true);
+        }
+    };
+
+    struct MiniMaxH3VideoVAE : public GGMLBlock {
+        MiniMaxH3VideoVAE() {
+            blocks["encoder"]         = std::make_shared<Encoder>();
+            blocks["quant_conv"]      = std::make_shared<Conv3d>(48,
+                                                            48,
+                                                            std::tuple{1, 1, 1});
+            blocks["post_quant_conv"] = std::make_shared<Conv3d>(24,
+                                                                 24,
+                                                                 std::tuple{1, 1, 1});
+            blocks["decoder"]         = std::make_shared<Decoder>();
+        }
+
+        ggml_tensor* encode(GGMLRunnerContext* ctx,
+                            ggml_tensor* pixels,
+                            ggml_tensor* pixel_mean,
+                            ggml_tensor* pixel_std) {
+            pixels       = ggml_div(ctx->ggml_ctx,
+                                    ggml_sub(ctx->ggml_ctx, pixels, pixel_mean),
+                                    pixel_std);
+            auto encoder = std::dynamic_pointer_cast<Encoder>(blocks["encoder"]);
+            auto quant   = std::dynamic_pointer_cast<Conv3d>(blocks["quant_conv"]);
+            auto moments = quant->forward(ctx, encoder->forward(ctx, pixels));
+            return ggml_ext_slice(ctx->ggml_ctx, moments, 3, 0, 24);
+        }
+
+        ggml_tensor* decode(GGMLRunnerContext* ctx,
+                            ggml_tensor* latent,
+                            ggml_tensor* pe,
+                            ggml_tensor* pixel_mean,
+                            ggml_tensor* pixel_std) {
+            auto post_quant = std::dynamic_pointer_cast<Conv3d>(blocks["post_quant_conv"]);
+            auto decoder    = std::dynamic_pointer_cast<Decoder>(blocks["decoder"]);
+            auto pixels     = decoder->forward(ctx, post_quant->forward(ctx, latent), pe);
+            pixels          = ggml_add(ctx->ggml_ctx,
+                                       ggml_mul(ctx->ggml_ctx, pixels, pixel_std),
+                                       pixel_mean);
+            return ggml_clamp(ctx->ggml_ctx, pixels, 0.f, 1.f);
+        }
+    };
+
+    struct MiniMaxH3VideoVAERunner : public VAE {
+        MiniMaxH3VideoVAE model;
+        sd::Tensor<float> pixel_mean;
+        sd::Tensor<float> pixel_std;
+        sd::Tensor<float> latents_mean;
+        sd::Tensor<float> latents_std;
+        sd::Tensor<float> rope_cache;
+
+        MiniMaxH3VideoVAERunner(ggml_backend_t backend,
+                                const String2TensorStorage& tensor_storage_map,
+                                const std::string& prefix                           = "first_stage_model",
+                                std::shared_ptr<RunnerWeightManager> weight_manager = nullptr)
+            : VAE(VERSION_MINIMAX_H3, backend, prefix, weight_manager),
+              pixel_mean({1, 1, 1, 3}, {0.485f, 0.456f, 0.406f}),
+              pixel_std({1, 1, 1, 3}, {0.229f, 0.224f, 0.225f}),
+              latents_mean({1, 1, 1, 24},
+                           {0.858090341091156f, -0.960659146308899f, 1.066164016723633f, -0.509032547473907f,
+                            -0.272758185863495f, -1.367541432380676f, -0.255325496196747f, -0.269075542688370f,
+                            -0.537684082984924f, -0.046409729868174f, 0.665737032890320f, 0.196901276707649f,
+                            -0.546060800552368f, -0.403534203767776f, -0.236830249428749f, 0.259284526109695f,
+                            -0.301339447498322f, 0.211341992020607f, -1.120684862136841f, 0.358193337917328f,
+                            -0.042251437902451f, 0.260482996702194f, 0.228640928864479f, 0.705603182315826f}),
+              latents_std({1, 1, 1, 24},
+                          {1.222377419471741f, 1.276726365089417f, 1.683177471160889f, 1.754945516586304f,
+                           1.563621640205383f, 2.194143533706665f, 0.965313792228699f, 1.056988596916199f,
+                           0.841948926448822f, 0.772995293140411f, 1.895593762397766f, 0.946841835975647f,
+                           0.799680948257446f, 0.449889004230499f, 0.719739973545075f, 0.693629324436188f,
+                           2.961095094680786f, 2.769419908523560f, 3.049618482589722f, 2.108805418014527f,
+                           3.276226282119751f, 3.162735700607300f, 2.281681299209595f, 2.612784385681153f}) {
+            scale_input = false;
+            model.init(params_ctx, tensor_storage_map, prefix);
+        }
+
+        std::string get_desc() override {
+            return "minimax_h3_video_vae";
+        }
+
+        int get_encoder_output_channels(int input_channels) override {
+            SD_UNUSED(input_channels);
+            return 24;
+        }
+
+        void get_param_tensors(std::map<std::string, ggml_tensor*>& tensors) override {
+            model.get_param_tensors(tensors, weight_prefix);
+        }
+
+        sd::Tensor<float> vae_output_to_latents(const sd::Tensor<float>& vae_output,
+                                                std::shared_ptr<RNG> rng) override {
+            SD_UNUSED(rng);
+            return vae_output;
+        }
+
+        sd::Tensor<float> diffusion_to_vae_latents(const sd::Tensor<float>& latents) override {
+            return latents * latents_std + latents_mean;
+        }
+
+        sd::Tensor<float> vae_to_diffusion_latents(const sd::Tensor<float>& latents) override {
+            return (latents - latents_mean) / latents_std;
+        }
+
+        static sd::Tensor<float> ensure_video_shape(const sd::Tensor<float>& tensor) {
+            if (tensor.dim() == 5) {
+                return tensor;
+            }
+            GGML_ASSERT(tensor.dim() == 4);
+            return tensor.reshape({tensor.shape()[0],
+                                   tensor.shape()[1],
+                                   1,
+                                   tensor.shape()[2],
+                                   tensor.shape()[3]});
+        }
+
+        static sd_tiling_params_t h3_tiling(sd_tiling_params_t params) {
+            params.enabled        = true;
+            params.tile_size_x    = 16;
+            params.tile_size_y    = 16;
+            params.target_overlap = 0.25f;
+            return params;
+        }
+
+        static sd::Tensor<float> repeat_last_frame(const sd::Tensor<float>& input,
+                                                   int64_t count) {
+            auto result = input;
+            auto last   = sd::ops::slice(input, 2, input.shape()[2] - 1, input.shape()[2]);
+            for (int64_t i = 0; i < count; ++i) {
+                result = sd::ops::concat(result, last, 2);
+            }
+            return result;
+        }
+
+        static sd::Tensor<float> blend_temporal(const sd::Tensor<float>& previous,
+                                                const sd::Tensor<float>& current,
+                                                int64_t extent) {
+            auto output            = current;
+            extent                 = std::min({extent, previous.shape()[2], current.shape()[2]});
+            int64_t previous_start = previous.shape()[2] - extent;
+            for (int64_t b = 0; b < current.shape()[4]; ++b) {
+                for (int64_t c = 0; c < current.shape()[3]; ++c) {
+                    for (int64_t t = 0; t < extent; ++t) {
+                        float wb = static_cast<float>(t) / extent;
+                        float wa = 1.f - wb;
+                        for (int64_t h = 0; h < current.shape()[1]; ++h) {
+                            for (int64_t w = 0; w < current.shape()[0]; ++w) {
+                                output.index(w, h, t, c, b) =
+                                    previous.index(w, h, previous_start + t, c, b) * wa +
+                                    current.index(w, h, t, c, b) * wb;
+                            }
+                        }
+                    }
+                }
+            }
+            return output;
+        }
+
+        sd::Tensor<float> encode(int n_threads,
+                                 const sd::Tensor<float>& x,
+                                 sd_tiling_params_t tiling_params,
+                                 bool circular_x = false,
+                                 bool circular_y = false) override {
+            auto input  = ensure_video_shape(x);
+            auto tiling = h3_tiling(tiling_params);
+            if (input.shape()[2] == 1) {
+                auto encoded = VAE::encode(n_threads, input, tiling, circular_x, circular_y);
+                if (!encoded.empty() && encoded.shape()[2] > 1) {
+                    encoded = sd::ops::slice(encoded,
+                                             2,
+                                             encoded.shape()[2] - 1,
+                                             encoded.shape()[2]);
+                }
+                return encoded;
+            }
+
+            int64_t pad = (-input.shape()[2]) % 17;
+            if (pad < 0) {
+                pad += 17;
+            }
+            if (pad > 0) {
+                input = repeat_last_frame(input, pad);
+            }
+            sd::Tensor<float> result;
+            for (int64_t start = 0; start < input.shape()[2]; start += 17) {
+                auto chunk   = sd::ops::slice(input, 2, start, start + 17);
+                auto encoded = VAE::encode(n_threads, chunk, tiling, circular_x, circular_y);
+                if (encoded.empty()) {
+                    return {};
+                }
+                result = result.empty() ? std::move(encoded)
+                                        : sd::ops::concat(result, encoded, 2);
+            }
+            if (result.shape()[2] > 3) {
+                result = sd::ops::slice(result, 2, 0, result.shape()[2] - 3);
+            }
+            return result;
+        }
+
+        sd::Tensor<float> decode(int n_threads,
+                                 const sd::Tensor<float>& x,
+                                 sd_tiling_params_t tiling_params,
+                                 bool decode_video = false,
+                                 bool circular_x   = false,
+                                 bool circular_y   = false,
+                                 bool silent       = false) override {
+            auto input  = ensure_video_shape(x);
+            auto tiling = h3_tiling(tiling_params);
+            if (input.shape()[2] == 1) {
+                auto decoded = VAE::decode(n_threads,
+                                           input,
+                                           tiling,
+                                           decode_video,
+                                           circular_x,
+                                           circular_y,
+                                           silent);
+                if (!decoded.empty() && decoded.shape()[2] > 1) {
+                    decoded = sd::ops::slice(decoded,
+                                             2,
+                                             decoded.shape()[2] - 1,
+                                             decoded.shape()[2]);
+                }
+                return decoded;
+            }
+
+            constexpr int64_t tokens_per_chunk  = 5;
+            constexpr int64_t token_drop        = 3;
+            constexpr int64_t token_overlap     = 2;
+            constexpr int64_t frames_per_chunk  = 20;
+            constexpr int64_t frame_pre_padding = 3;
+            constexpr int64_t frame_overlap     = 5;
+
+            int64_t pseudo_tokens = input.shape()[2] + token_drop;
+            int64_t pad_tokens    = (tokens_per_chunk - pseudo_tokens % tokens_per_chunk) % tokens_per_chunk;
+            pseudo_tokens += pad_tokens;
+            int64_t num_chunks = pseudo_tokens / tokens_per_chunk - 1;
+            if (num_chunks < 1) {
+                pad_tokens += tokens_per_chunk;
+                num_chunks += 1;
+            }
+            if (pad_tokens > 0) {
+                input = repeat_last_frame(input, pad_tokens);
+            }
+
+            sd::Tensor<float> result;
+            sd::Tensor<float> overlap;
+            for (int64_t i = 0; i < num_chunks; ++i) {
+                int64_t start = i * tokens_per_chunk;
+                int64_t end   = std::min(start + tokens_per_chunk + token_overlap,
+                                         input.shape()[2]);
+                auto chunk    = sd::ops::slice(input, 2, start, end);
+                auto decoded  = VAE::decode(n_threads,
+                                            chunk,
+                                            tiling,
+                                            true,
+                                            circular_x,
+                                            circular_y,
+                                            silent);
+                if (decoded.empty()) {
+                    return {};
+                }
+
+                int64_t first_end = std::min<int64_t>(frames_per_chunk, decoded.shape()[2]);
+                auto first        = sd::ops::slice(decoded,
+                                                   2,
+                                                   std::min<int64_t>(frame_pre_padding, first_end),
+                                                   first_end);
+                if (!overlap.empty()) {
+                    first   = blend_temporal(overlap, first, frame_overlap);
+                    overlap = {};
+                }
+                result = result.empty() ? std::move(first)
+                                        : sd::ops::concat(result, first, 2);
+
+                if (decoded.shape()[2] > frames_per_chunk + frame_pre_padding) {
+                    overlap = sd::ops::slice(decoded,
+                                             2,
+                                             frames_per_chunk + frame_pre_padding,
+                                             decoded.shape()[2]);
+                }
+                if (i == num_chunks - 1 && !overlap.empty()) {
+                    result  = sd::ops::concat(result, overlap, 2);
+                    overlap = {};
+                }
+            }
+
+            int64_t expected_frames = input.shape()[2] <= 1 ? 1 : ((x.shape()[2] - 2) / 5) * 17 + 5;
+            expected_frames         = std::max<int64_t>(1, expected_frames);
+            if (result.shape()[2] > expected_frames) {
+                result = sd::ops::slice(result, 2, 0, expected_frames);
+            }
+            return result;
+        }
+
+        sd::Tensor<float> build_rope(int64_t width,
+                                     int64_t height,
+                                     int64_t num_frames) {
+            std::vector<std::vector<float>> ids;
+            ids.reserve(static_cast<size_t>(width * height * num_frames + 5));
+            constexpr float two_pi = 6.28318530717958647692f;
+            for (int64_t t = 0; t < num_frames; ++t) {
+                float pt = (2.f * ((t + 0.5f) / num_frames) - 1.f) * two_pi;
+                for (int64_t h = 0; h < height; ++h) {
+                    float ph = (2.f * ((h + 0.5f) / height) - 1.f) * two_pi;
+                    for (int64_t w = 0; w < width; ++w) {
+                        float pw = (2.f * ((w + 0.5f) / width) - 1.f) * two_pi;
+                        ids.push_back({pt, ph, pw});
+                    }
+                }
+            }
+            for (int i = 0; i < 5; ++i) {
+                ids.push_back({0.f, 0.f, 0.f});
+            }
+            auto values = Rope::embed_nd(ids,
+                                         1,
+                                         100.f,
+                                         std::vector<int>{16, 16, 16});
+            return sd::Tensor<float>({2,
+                                      2,
+                                      24,
+                                      static_cast<int64_t>(ids.size())},
+                                     std::move(values));
+        }
+
+        sd::Tensor<float> _compute(const int n_threads,
+                                   const sd::Tensor<float>& z,
+                                   bool decode_graph) override {
+            auto input = ensure_video_shape(z);
+            if (decode_graph) {
+                rope_cache = build_rope(input.shape()[0],
+                                        input.shape()[1],
+                                        input.shape()[2]);
+            }
+            auto get_graph = [&]() -> ggml_cgraph* {
+                auto value       = make_input(input);
+                auto mean        = make_input(pixel_mean);
+                auto std         = make_input(pixel_std);
+                auto runner_ctx  = get_context();
+                ggml_tensor* out = nullptr;
+                if (decode_graph) {
+                    auto pe = make_input(rope_cache);
+                    out     = model.decode(&runner_ctx, value, pe, mean, std);
+                } else {
+                    out = model.encode(&runner_ctx, value, mean, std);
+                }
+                auto graph = new_graph_custom(H3_VIDEO_VAE_GRAPH_SIZE);
+                ggml_build_forward_expand(graph, out);
+                return graph;
+            };
+            return restore_trailing_singleton_dims(
+                GGMLRunner::compute<float>(get_graph,
+                                           n_threads,
+                                           false,
+                                           false,
+                                           false),
+                5);
+        }
+    };
+
+}  // namespace MiniMaxH3VAE
+
+#endif  // __SD_MODEL_VAE_MINIMAX_H3_VAE_HPP__
diff --git a/src/model/vae/vae.hpp b/src/model/vae/vae.hpp
index e8b4eed38..7013f732a 100644
--- a/src/model/vae/vae.hpp
+++ b/src/model/vae/vae.hpp
@@ -74,7 +74,7 @@ struct VAE : public GGMLRunner {
         int scale_factor = 8;
         if (version == VERSION_LTXAV) {
             scale_factor = 32;
-        } else if (version == VERSION_WAN2_2_TI2V || sd_version_is_hunyuan_video(version) || sd_version_is_mage_flow(version)) {
+        } else if (version == VERSION_WAN2_2_TI2V || sd_version_is_hunyuan_video(version) || sd_version_is_mage_flow(version) || sd_version_is_minimax_h3(version)) {
             scale_factor = 16;
         } else if (sd_version_uses_flux2_vae(version)) {
             scale_factor = 16;
@@ -115,11 +115,11 @@ struct VAE : public GGMLRunner {
         tile_size_y = get_tile_size(params.tile_size_y, params.rel_size_y, latent_y);
     }
 
-    sd::Tensor<float> encode(int n_threads,
-                             const sd::Tensor<float>& x,
-                             sd_tiling_params_t tiling_params,
-                             bool circular_x = false,
-                             bool circular_y = false) {
+    virtual sd::Tensor<float> encode(int n_threads,
+                                     const sd::Tensor<float>& x,
+                                     sd_tiling_params_t tiling_params,
+                                     bool circular_x = false,
+                                     bool circular_y = false) {
         int64_t t0              = ggml_time_ms();
         sd::Tensor<float> input = x;
         sd::Tensor<float> output;
@@ -136,7 +136,8 @@ struct VAE : public GGMLRunner {
             // Image VAE encode is more sensitive to tile boundary context than decode.
             // Keep the smaller legacy factor for video VAEs, but default image encode
             // tiles to 64 latent pixels so a 512px SD image is encoded as one tile.
-            const float encode_tile_factor = (sd_version_is_wan(version) || sd_version_is_hunyuan_video(version) || sd_version_is_ltxav(version)) ? 1.30539f : 2.0f;
+            const float encode_tile_factor = sd_version_is_minimax_h3(version) ? 1.f : (sd_version_is_wan(version) || sd_version_is_hunyuan_video(version) || sd_version_is_ltxav(version)) ? 1.30539f
+                                                                                                                                                                                            : 2.0f;
             get_tile_sizes(tile_size_x, tile_size_y, tile_overlap, tiling_params, W, H, encode_tile_factor);
             LOG_DEBUG("VAE Tile size: %dx%d", tile_size_x, tile_size_y);
             output = tiled_compute(input,
@@ -166,13 +167,13 @@ struct VAE : public GGMLRunner {
         return std::move(output);
     }
 
-    sd::Tensor<float> decode(int n_threads,
-                             const sd::Tensor<float>& x,
-                             sd_tiling_params_t tiling_params,
-                             bool decode_video = false,
-                             bool circular_x   = false,
-                             bool circular_y   = false,
-                             bool silent       = false) {
+    virtual sd::Tensor<float> decode(int n_threads,
+                                     const sd::Tensor<float>& x,
+                                     sd_tiling_params_t tiling_params,
+                                     bool decode_video = false,
+                                     bool circular_x   = false,
+                                     bool circular_y   = false,
+                                     bool silent       = false) {
         int64_t t0              = ggml_time_ms();
         sd::Tensor<float> input = x;
         sd::Tensor<float> output;
diff --git a/src/model_loader.cpp b/src/model_loader.cpp
index 69f3d8915..047c9d996 100644
--- a/src/model_loader.cpp
+++ b/src/model_loader.cpp
@@ -537,6 +537,10 @@ SDVersion ModelLoader::get_sd_version() {
         if (tensor_storage.name.find("model.diffusion_model.adaln_single.emb.timestep_embedder.linear_1.bias") != std::string::npos) {
             return VERSION_LTXAV;
         }
+        if (tensor_storage.name.find("model.diffusion_model.video_patch_proj.weight") != std::string::npos &&
+            tensor_storage_map.find("model.diffusion_model.audio_patch_proj.weight") != tensor_storage_map.end()) {
+            return VERSION_MINIMAX_H3;
+        }
         if (tensor_storage.name.find("model.diffusion_model.blocks.0.cross_attn.norm_k.weight") != std::string::npos) {
             is_wan = true;
         }
diff --git a/src/name_conversion.cpp b/src/name_conversion.cpp
index af8a7f572..04da98aba 100644
--- a/src/name_conversion.cpp
+++ b/src/name_conversion.cpp
@@ -1048,7 +1048,7 @@ std::string convert_diffusers_to_original_wan_vae(std::string name) {
 }
 
 std::string convert_first_stage_model_name(std::string name, std::string prefix, SDVersion version) {
-    if (sd_version_is_hunyuan_video(version) || sd_version_is_mage_flow(version)) {
+    if (sd_version_is_hunyuan_video(version) || sd_version_is_mage_flow(version) || sd_version_is_minimax_h3(version)) {
         return name;
     }
     if (sd_version_uses_wan_vae(version)) {
@@ -1466,7 +1466,7 @@ std::string convert_tensor_name(std::string name, SDVersion version) {
 
     replace_with_prefix_map(name, prefix_map);
 
-    if (sd_version_is_boogu_image(version) || sd_version_is_krea2(version) || sd_version_is_mage_flow(version)) {
+    if (sd_version_is_boogu_image(version) || sd_version_is_krea2(version) || sd_version_is_mage_flow(version) || sd_version_is_minimax_h3(version)) {
         const std::string hf_vision_prefix = "text_encoders.llm.model.visual.";
         if (starts_with(name, hf_vision_prefix)) {
             name = "text_encoders.llm.visual." + name.substr(hf_vision_prefix.size());
diff --git a/src/stable-diffusion.cpp b/src/stable-diffusion.cpp
index 24e6839ae..cb4a3ad05 100644
--- a/src/stable-diffusion.cpp
+++ b/src/stable-diffusion.cpp
@@ -38,6 +38,7 @@
 #include "model/diffusion/lingbot_video.hpp"
 #include "model/diffusion/ltxv.hpp"
 #include "model/diffusion/mage_flow.hpp"
+#include "model/diffusion/minimax_h3.hpp"
 #include "model/diffusion/minit2i.hpp"
 #include "model/diffusion/mmdit.hpp"
 #include "model/diffusion/model.hpp"
@@ -53,6 +54,8 @@
 #include "model/vae/ltx_audio_vae.hpp"
 #include "model/vae/ltx_vae.hpp"
 #include "model/vae/mage_vae.hpp"
+#include "model/vae/minimax_h3_audio_vae.hpp"
+#include "model/vae/minimax_h3_vae.hpp"
 #include "model/vae/tae.hpp"
 #include "model/vae/vae.hpp"
 #include "model/vae/wan_vae.hpp"
@@ -106,6 +109,7 @@ const char* model_version_to_str[] = {
     "Flux.2",
     "Flux.2 klein",
     "LTXAV",
+    "MiniMax-H3",
     "HiDream O1",
     "Z-Image",
     "Boogu Image",
@@ -215,6 +219,7 @@ class StableDiffusionGGML {
     std::shared_ptr<RNG> sampler_rng = nullptr;
     int n_threads                    = -1;
     float default_flow_shift         = INFINITY;
+    float active_flow_shift          = INFINITY;
 
     std::shared_ptr<Conditioner> cond_stage_model;
     std::shared_ptr<FrozenCLIPVisionEmbedder> clip_vision;  // for svd or wan2.1 i2v
@@ -222,7 +227,7 @@ class StableDiffusionGGML {
     std::shared_ptr<DiffusionModelRunner> high_noise_diffusion_model;
     std::shared_ptr<VAE> first_stage_model;
     std::shared_ptr<VAE> preview_vae;
-    std::shared_ptr<LTXV::LTXAudioVAERunner> audio_vae_model;
+    std::shared_ptr<AudioVAERunner> audio_vae_model;
     std::shared_ptr<ControlNet> control_net;
     std::shared_ptr<IPAdapter::IPAdapterRunner> ip_adapter;
     sd::Tensor<float> ip_adapter_tokens;
@@ -837,9 +842,9 @@ class StableDiffusionGGML {
         }
 
         if (strlen(SAFE_STR(sd_ctx_params->audio_vae_path)) > 0) {
-            LOG_INFO("loading LTX audio VAE from '%s'", sd_ctx_params->audio_vae_path);
+            LOG_INFO("loading audio VAE from '%s'", sd_ctx_params->audio_vae_path);
             if (!model_loader.init_from_file(sd_ctx_params->audio_vae_path)) {
-                LOG_WARN("loading LTX audio VAE weights from '%s' failed", sd_ctx_params->audio_vae_path);
+                LOG_WARN("loading audio VAE weights from '%s' failed", sd_ctx_params->audio_vae_path);
             } else {
                 use_audio_vae = true;
             }
@@ -995,6 +1000,11 @@ class StableDiffusionGGML {
             tae_preview_only = false;
             use_tae          = true;
         }
+        if (sd_version_is_minimax_h3(version) && use_tae) {
+            LOG_WARN("MiniMax-H3 does not have a compatible TAE; ignoring --taesd");
+            tae_preview_only = false;
+            use_tae          = false;
+        }
 
         {
             if (!ensure_backend_pair(SDBackendModule::TE) ||
@@ -1101,6 +1111,17 @@ class StableDiffusionGGML {
                                                                       tensor_storage_map,
                                                                       "model.diffusion_model",
                                                                       model_manager);
+            } else if (sd_version_is_minimax_h3(version)) {
+                cond_stage_model = std::make_shared<LLMEmbedder>(backend_for(SDBackendModule::TE),
+                                                                 tensor_storage_map,
+                                                                 version,
+                                                                 "",
+                                                                 true,
+                                                                 model_manager);
+                diffusion_model  = std::make_shared<MiniMaxH3::MiniMaxH3Runner>(backend_for(SDBackendModule::DIFFUSION),
+                                                                               tensor_storage_map,
+                                                                               "model.diffusion_model",
+                                                                               model_manager);
             } else if (sd_version_is_hunyuan_video(version)) {
                 cond_stage_model = std::make_shared<LLMEmbedder>(backend_for(SDBackendModule::TE),
                                                                  tensor_storage_map,
@@ -1393,6 +1414,11 @@ class StableDiffusionGGML {
                                                          false,
                                                          version,
                                                          model_manager);
+                } else if (sd_version_is_minimax_h3(version)) {
+                    return std::make_shared<MiniMaxH3VAE::MiniMaxH3VideoVAERunner>(backend_for(SDBackendModule::VAE),
+                                                                                   tensor_storage_map,
+                                                                                   "first_stage_model",
+                                                                                   model_manager);
                 } else if (sd_version_is_mage_flow(vae_version)) {
                     return std::make_shared<MageVAE::MageVAERunner>(backend_for(SDBackendModule::VAE),
                                                                     tensor_storage_map,
@@ -1478,11 +1504,18 @@ class StableDiffusionGGML {
             }
 
             if (use_audio_vae) {
-                audio_vae_model = std::make_shared<LTXV::LTXAudioVAERunner>(backend_for(SDBackendModule::VAE),
-                                                                            tensor_storage_map,
-                                                                            "",
-                                                                            model_manager);
-                if (!register_runner_params("LTX audio VAE",
+                if (sd_version_is_minimax_h3(version)) {
+                    audio_vae_model = std::make_shared<MiniMaxH3::AudioVAERunner>(backend_for(SDBackendModule::VAE),
+                                                                                  tensor_storage_map,
+                                                                                  "",
+                                                                                  model_manager);
+                } else {
+                    audio_vae_model = std::make_shared<LTXV::LTXAudioVAERunner>(backend_for(SDBackendModule::VAE),
+                                                                                tensor_storage_map,
+                                                                                "",
+                                                                                model_manager);
+                }
+                if (!register_runner_params("audio VAE",
                                             audio_vae_model,
                                             SDBackendModule::VAE,
                                             &vae_params_mem_size)) {
@@ -1595,7 +1628,9 @@ class StableDiffusionGGML {
         ignore_tensors.insert("model.diffusion_model.__index_timestep_zero__");
 
         if (audio_vae_model) {
-            ignore_tensors.insert("audio_vae.encoder");
+            if (!sd_version_is_minimax_h3(version)) {
+                ignore_tensors.insert("audio_vae.encoder");
+            }
         }
         if (version == VERSION_OVIS_IMAGE) {
             ignore_tensors.insert("text_encoders.llm.vision_model.");
@@ -1718,6 +1753,7 @@ class StableDiffusionGGML {
                            sd_version_is_wan(version) ||
                            sd_version_is_hunyuan_video(version) ||
                            sd_version_is_lingbot_video(version) ||
+                           sd_version_is_minimax_h3(version) ||
                            sd_version_is_qwen_image(version) ||
                            sd_version_is_mage_flow(version) ||
                            version == VERSION_HIDREAM_O1 ||
@@ -1732,6 +1768,8 @@ class StableDiffusionGGML {
                         default_flow_shift = 5.f;
                     } else if (sd_version_is_hunyuan_video(version)) {
                         default_flow_shift = 7.f;
+                    } else if (sd_version_is_minimax_h3(version)) {
+                        default_flow_shift = 12.f;
                     } else if (sd_version_is_ernie_image(version)) {
                         default_flow_shift = 4.f;
                     } else if (sd_version_is_pid(version)) {
@@ -2677,6 +2715,15 @@ class StableDiffusionGGML {
                         condition.c_token_types.empty() ? nullptr : &condition.c_token_types,
                         condition.c_vinput_mask.empty() ? nullptr : &condition.c_vinput_mask,
                         condition.c_image_embeds.empty() ? nullptr : &condition.c_image_embeds};
+                } else if (sd_version_is_minimax_h3(version)) {
+                    diffusion_params.extra = MiniMaxH3DiffusionExtra{
+                        condition.c_token_types.empty() ? nullptr : &condition.c_token_types,
+                        condition.c_position_ids.empty() ? nullptr : &condition.c_position_ids,
+                        condition.c_ref_audios.empty() ? nullptr : &condition.c_ref_audios,
+                        condition.c_reference_blocks.empty() ? nullptr : &condition.c_reference_blocks,
+                        audio_length,
+                        std::isfinite(active_flow_shift) ? active_flow_shift : 12.f,
+                        3.f};
                 } else if (sd_version_is_ltxav(version)) {
                     diffusion_params.extra = LTXAVDiffusionExtra{
                         nullptr,
@@ -2850,7 +2897,7 @@ class StableDiffusionGGML {
     int get_diffusion_model_down_factor() {
         int down_factor = 8;  // unet
         if (sd_version_is_dit(version)) {
-            if (sd_version_is_wan(version) || sd_version_is_lingbot_video(version)) {
+            if (sd_version_is_wan(version) || sd_version_is_lingbot_video(version) || sd_version_is_minimax_h3(version)) {
                 down_factor = 2;
             } else {
                 down_factor = 1;
@@ -2864,6 +2911,8 @@ class StableDiffusionGGML {
         if (sd_version_is_dit(version)) {
             if (sd_version_is_ltxav(version)) {
                 latent_channel = 128;
+            } else if (sd_version_is_minimax_h3(version)) {
+                latent_channel = 24;
             } else if (version == VERSION_WAN2_2_TI2V) {
                 latent_channel = 48;
             } else if (sd_version_is_hunyuan_video(version)) {
@@ -2917,6 +2966,8 @@ class StableDiffusionGGML {
         int latent_frames = frames;
         if (sd_version_is_ltxav(version)) {
             latent_frames = ((frames - 1) / 8) + 1;
+        } else if (sd_version_is_minimax_h3(version)) {
+            latent_frames = frames <= 5 ? 2 : ((frames - 5) / 17) * 5 + 2;
         } else if (sd_version_is_wan(version) || sd_version_is_lingbot_video(version) || sd_version_is_hunyuan_video(version)) {
             latent_frames = ((frames - 1) / 4) + 1;
         }
@@ -2930,6 +2981,9 @@ class StableDiffusionGGML {
         if (sd_version_is_ltxav(version)) {
             return (latent_frames - 1) * 8 + 1;
         }
+        if (sd_version_is_minimax_h3(version)) {
+            return latent_frames <= 2 ? 5 : ((latent_frames - 2) / 5) * 17 + 5;
+        }
         if (sd_version_is_wan(version) || sd_version_is_lingbot_video(version) || sd_version_is_hunyuan_video(version)) {
             return (latent_frames - 1) * 4 + 1;
         }
@@ -2937,6 +2991,13 @@ class StableDiffusionGGML {
     }
 
     int align_video_frames(int frames) {
+        if (sd_version_is_minimax_h3(version)) {
+            frames = std::max(frames, 5);
+            while (frames % 17 != 5) {
+                ++frames;
+            }
+            return frames;
+        }
         return latent_frames_to_video_frames(video_frames_to_latent_frames(frames));
     }
 
@@ -3011,6 +3072,7 @@ class StableDiffusionGGML {
                 flow_shift = default_flow_shift;
             }
             flow_denoiser->set_shift(flow_shift);
+            active_flow_shift = flow_shift;
         }
     }
 
@@ -3730,7 +3792,7 @@ struct sd_ctx_t {
 };
 
 static bool sd_version_supports_video_generation(SDVersion version) {
-    return version == VERSION_SVD || sd_version_is_wan(version) || sd_version_is_hunyuan_video(version) || sd_version_is_lingbot_video(version) || sd_version_is_ltxav(version);
+    return version == VERSION_SVD || sd_version_is_wan(version) || sd_version_is_hunyuan_video(version) || sd_version_is_lingbot_video(version) || sd_version_is_ltxav(version) || sd_version_is_minimax_h3(version);
 }
 
 static bool sd_version_supports_image_generation(SDVersion version) {
@@ -3792,7 +3854,7 @@ static sd_audio_t* waveform_to_sd_audio(const StableDiffusionGGML* sd,
         return nullptr;
     }
 
-    audio->sample_rate  = static_cast<uint32_t>(sd->audio_vae_model != nullptr ? sd->audio_vae_model->config.output_sample_rate() : 0);
+    audio->sample_rate  = static_cast<uint32_t>(sd->audio_vae_model != nullptr ? sd->audio_vae_model->output_sample_rate() : 0);
     audio->channels     = static_cast<uint32_t>(channels);
     audio->sample_count = static_cast<uint64_t>(sample_count);
     size_t sample_bytes = waveform.numel() * sizeof(float);
@@ -3997,14 +4059,18 @@ struct GenerationRequest {
     }
 
     GenerationRequest(sd_ctx_t* sd_ctx, const sd_vid_gen_params_t* sd_vid_gen_params) {
-        prompt                      = SAFE_STR(sd_vid_gen_params->prompt);
-        negative_prompt             = SAFE_STR(sd_vid_gen_params->negative_prompt);
-        width                       = sd_vid_gen_params->width;
-        height                      = sd_vid_gen_params->height;
-        requested_frames            = std::max(1, sd_vid_gen_params->video_frames);
-        frames                      = sd_ctx->sd->align_video_frames(requested_frames);
-        clip_skip                   = sd_vid_gen_params->clip_skip;
-        fps                         = std::max(1, sd_vid_gen_params->fps);
+        prompt           = SAFE_STR(sd_vid_gen_params->prompt);
+        negative_prompt  = SAFE_STR(sd_vid_gen_params->negative_prompt);
+        width            = sd_vid_gen_params->width;
+        height           = sd_vid_gen_params->height;
+        requested_frames = std::max(1, sd_vid_gen_params->video_frames);
+        frames           = sd_ctx->sd->align_video_frames(requested_frames);
+        clip_skip        = sd_vid_gen_params->clip_skip;
+        fps              = std::max(1, sd_vid_gen_params->fps);
+        if (sd_version_is_minimax_h3(sd_ctx->sd->version) && fps != 24) {
+            LOG_WARN("MiniMax-H3 uses 24 fps; overriding requested fps %d", fps);
+            fps = 24;
+        }
         vae_scale_factor            = sd_ctx->sd->get_vae_scale_factor();
         diffusion_model_down_factor = sd_ctx->sd->get_diffusion_model_down_factor();
         seed                        = sd_vid_gen_params->seed;
@@ -4244,6 +4310,8 @@ struct SamplePlan {
             if (sd_version_is_ltxav(sd_ctx->sd->version) && request->frames > 0) {
                 int latent_frames = ((request->frames - 1) / 8) + 1;
                 sample_seq_len *= latent_frames;
+            } else if (sd_version_is_minimax_h3(sd_ctx->sd->version) && request->frames > 0) {
+                sample_seq_len *= sd_ctx->sd->video_frames_to_latent_frames(request->frames);
             }
             sigmas = sd_ctx->sd->denoiser->get_sigmas(total_steps,
                                                       sample_seq_len,
@@ -4283,6 +4351,10 @@ struct ImageGenerationLatents {
     sd::Tensor<float> control_image;
     std::vector<sd::Tensor<float>> ref_images;
     std::vector<sd::Tensor<float>> ref_latents;
+    std::vector<sd::Tensor<float>> reference_audio_latents;
+    std::vector<MiniMaxH3ReferenceBlock> minimax_reference_blocks;
+    std::vector<MiniMaxH3PresentationItem> minimax_presentation_refs;
+    std::vector<int32_t> keyframe_indices;
     sd::Tensor<float> denoise_mask;
     sd::Tensor<float> clip_vision_output;
     sd::Tensor<float> vace_context;
@@ -4597,6 +4669,67 @@ static int get_ltxav_num_audio_latents(int frames, int fps) {
     return static_cast<int>(std::ceil((static_cast<float>(frames) / static_cast<float>(fps)) * kLatentsPerSecond));
 }
 
+static int get_minimax_h3_num_audio_latents(int frames, int fps) {
+    GGML_ASSERT(frames > 0 && fps > 0);
+    return std::max(1,
+                    static_cast<int>(std::lround(
+                        static_cast<double>(frames) * 40.0 / fps)));
+}
+
+static sd::Tensor<float> make_minimax_h3_empty_audio_latent(int audio_length) {
+    if (audio_length <= 0) {
+        return {};
+    }
+    return sd::zeros<float>({audio_length, 2, 32, 1});
+}
+
+static sd::Tensor<float> prepare_minimax_h3_reference_waveform(const sd_audio_t& audio,
+                                                               int target_sample_rate = 32000) {
+    if (audio.data == nullptr || audio.sample_count == 0 || audio.channels == 0 || audio.sample_rate == 0) {
+        return {};
+    }
+    uint64_t output_samples = static_cast<uint64_t>(std::llround(
+        static_cast<long double>(audio.sample_count) * target_sample_rate / audio.sample_rate));
+    output_samples          = std::max<uint64_t>(1, output_samples);
+    uint64_t padded_samples = (output_samples + 799) / 800 * 800;
+    sd::Tensor<float> waveform({static_cast<int64_t>(padded_samples), 2, 1, 1});
+
+    for (uint64_t i = 0; i < output_samples; ++i) {
+        long double source_pos = static_cast<long double>(i) * audio.sample_rate / target_sample_rate;
+        uint64_t source0       = std::min<uint64_t>(static_cast<uint64_t>(source_pos), audio.sample_count - 1);
+        uint64_t source1       = std::min<uint64_t>(source0 + 1, audio.sample_count - 1);
+        float fraction         = static_cast<float>(source_pos - source0);
+        for (uint32_t channel = 0; channel < 2; ++channel) {
+            uint32_t source_channel = audio.channels == 1 ? 0 : std::min<uint32_t>(channel, audio.channels - 1);
+            float a                 = audio.data[source0 * audio.channels + source_channel];
+            float b                 = audio.data[source1 * audio.channels + source_channel];
+            waveform.index(static_cast<int64_t>(i), channel, 0, 0) =
+                std::clamp(a + (b - a) * fraction, -1.f, 1.f);
+        }
+    }
+    return waveform;
+}
+
+static sd::Tensor<float> unpack_minimax_h3_audio_latent(const sd::Tensor<float>& packed_latent,
+                                                        int audio_length,
+                                                        int video_channels) {
+    if (packed_latent.empty() || audio_length <= 0) {
+        return {};
+    }
+    GGML_ASSERT(packed_latent.dim() == 4 || packed_latent.dim() == 5);
+    int64_t spatial_size = packed_latent.shape()[0] * packed_latent.shape()[1] * packed_latent.shape()[2];
+    int64_t required     = static_cast<int64_t>(audio_length) * 2 * 32;
+    int64_t available    = (packed_latent.shape()[3] - video_channels) * spatial_size;
+    if (available < required) {
+        return {};
+    }
+    sd::Tensor<float> audio({audio_length, 2, 32, 1});
+    const float* source = packed_latent.data() +
+                          static_cast<size_t>(video_channels) * static_cast<size_t>(spatial_size);
+    std::copy_n(source, static_cast<size_t>(required), audio.data());
+    return audio;
+}
+
 struct ImageGenerationEmbeds {
     SDCondition cond;
     SDCondition uncond;
@@ -5697,6 +5830,248 @@ static std::optional<ImageGenerationLatents> prepare_video_generation_latents(sd
         end_image = sd_image_to_tensor(sd_vid_gen_params->end_image, request->width, request->height);
     }
 
+    if (sd_version_is_minimax_h3(sd_ctx->sd->version)) {
+        if (sd_vid_gen_params->ref_images_count < 0 || sd_vid_gen_params->ref_videos_count < 0 ||
+            sd_vid_gen_params->ref_audios_count < 0 ||
+            (sd_vid_gen_params->ref_images_count > 0 && sd_vid_gen_params->ref_images == nullptr) ||
+            (sd_vid_gen_params->ref_videos_count > 0 && sd_vid_gen_params->ref_videos == nullptr) ||
+            (sd_vid_gen_params->ref_audios_count > 0 && sd_vid_gen_params->ref_audios == nullptr)) {
+            LOG_ERROR("invalid MiniMax-H3 Ref2VA input arrays");
+            return std::nullopt;
+        }
+
+        latents.audio_length = get_minimax_h3_num_audio_latents(request->frames,
+                                                                request->fps);
+        latents.audio_latent = make_minimax_h3_empty_audio_latent(latents.audio_length);
+
+        bool has_references = sd_vid_gen_params->ref_images_count > 0 ||
+                              sd_vid_gen_params->ref_videos_count > 0 ||
+                              sd_vid_gen_params->ref_audios_count > 0;
+        if (has_references && (!start_image.empty() || !end_image.empty())) {
+            LOG_ERROR("MiniMax-H3 keyframes and Ref2VA references cannot be used together");
+            return std::nullopt;
+        }
+
+        if (sd_vid_gen_params->control_frames_size > 0) {
+            LOG_ERROR("MiniMax-H3 control_frames are not implemented");
+            return std::nullopt;
+        }
+
+        auto add_visual_noise = [&](sd::Tensor<float> latent) {
+            auto condition_rng = std::make_shared<PhiloxRNG>();
+            condition_rng->manual_seed(static_cast<uint64_t>(request->seed));
+            return latent * MiniMaxH3::VISUAL_COND_TIMESTEP +
+                   sd::Tensor<float>::randn_like(latent, condition_rng) *
+                       (1.f - MiniMaxH3::VISUAL_COND_TIMESTEP);
+        };
+
+        auto add_keyframe = [&](const sd::Tensor<float>& image,
+                                int32_t frame_index,
+                                const char* name) -> bool {
+            if (image.empty()) {
+                return true;
+            }
+            auto video_image = image.reshape({image.shape()[0],
+                                              image.shape()[1],
+                                              1,
+                                              image.shape()[2],
+                                              image.shape()[3]});
+            auto latent      = sd_ctx->sd->encode_first_stage(video_image);
+            if (latent.empty()) {
+                LOG_ERROR("failed to encode MiniMax-H3 %s keyframe", name);
+                return false;
+            }
+            latents.ref_images.push_back(image);
+            latents.ref_latents.push_back(add_visual_noise(std::move(latent)));
+            latents.keyframe_indices.push_back(frame_index);
+            return true;
+        };
+
+        auto resize_reference = [&](const sd::Tensor<float>& image,
+                                    int width,
+                                    int height) {
+            return sd::ops::interpolate(
+                image,
+                std::vector<int64_t>{width, height, image.shape()[2], image.shape()[3]});
+        };
+
+        auto encode_reference_audio = [&](const sd_audio_t& audio,
+                                          int32_t* audio_index) -> bool {
+            if (sd_ctx->sd->audio_vae_model == nullptr) {
+                LOG_ERROR("MiniMax-H3 Ref2VA audio requires --audio-vae with encoder weights");
+                return false;
+            }
+            auto waveform = prepare_minimax_h3_reference_waveform(
+                audio,
+                sd_ctx->sd->audio_vae_model->input_sample_rate());
+            if (waveform.empty()) {
+                LOG_ERROR("invalid MiniMax-H3 reference audio");
+                return false;
+            }
+            auto encoded = sd_ctx->sd->audio_vae_model->encode(sd_ctx->sd->n_threads, waveform);
+            if (encoded.empty()) {
+                LOG_ERROR("failed to encode MiniMax-H3 reference audio");
+                return false;
+            }
+            *audio_index = static_cast<int32_t>(latents.reference_audio_latents.size());
+            latents.reference_audio_latents.push_back(std::move(encoded));
+            return true;
+        };
+
+        if (has_references) {
+            LOG_INFO("MiniMax-H3 Ref2VA: %d image(s), %d video(s), %d audio clip(s)",
+                     sd_vid_gen_params->ref_images_count,
+                     sd_vid_gen_params->ref_videos_count,
+                     sd_vid_gen_params->ref_audios_count);
+
+            for (int i = 0; i < sd_vid_gen_params->ref_images_count; ++i) {
+                auto image = ensure_image_tensor_channels(
+                    sd_image_to_tensor(sd_vid_gen_params->ref_images[i]),
+                    3);
+                if (image.empty()) {
+                    LOG_ERROR("failed to load MiniMax-H3 reference image %d", i + 1);
+                    return std::nullopt;
+                }
+                int source_w       = static_cast<int>(image.shape()[0]);
+                int source_h       = static_cast<int>(image.shape()[1]);
+                double source_area = static_cast<double>(source_w) * source_h;
+                double target_area = static_cast<double>(request->width) * request->height;
+                double scale       = std::min(1.0, std::sqrt(target_area / source_area));
+                int width          = std::max(32, static_cast<int>(std::round(source_w * scale / 32.f)) * 32);
+                int height         = std::max(32, static_cast<int>(std::round(source_h * scale / 32.f)) * 32);
+                image              = resize_reference(image, width, height);
+                auto latent        = sd_ctx->sd->encode_first_stage(image);
+                if (latent.empty()) {
+                    LOG_ERROR("failed to encode MiniMax-H3 reference image %d", i + 1);
+                    return std::nullopt;
+                }
+                int32_t video_index = static_cast<int32_t>(latents.ref_latents.size());
+                latents.ref_latents.push_back(add_visual_noise(std::move(latent)));
+                latents.minimax_reference_blocks.push_back({MiniMaxH3ReferenceKind::IMAGE,
+                                                            video_index,
+                                                            -1});
+                MiniMaxH3PresentationItem item;
+                item.kind = MiniMaxH3PresentationKind::IMAGE;
+                item.frames.push_back(std::move(image));
+                latents.minimax_presentation_refs.push_back(std::move(item));
+            }
+
+            for (int video_idx = 0; video_idx < sd_vid_gen_params->ref_videos_count; ++video_idx) {
+                const auto& reference = sd_vid_gen_params->ref_videos[video_idx];
+                if (reference.frames == nullptr || reference.frame_count < 1) {
+                    LOG_ERROR("invalid MiniMax-H3 reference video %d", video_idx + 1);
+                    return std::nullopt;
+                }
+                int source_fps        = reference.fps > 0 ? reference.fps : 24;
+                int normalized_frames = static_cast<int>(std::lround(
+                    static_cast<double>(reference.frame_count) * 24.0 / source_fps));
+                normalized_frames     = std::min(normalized_frames, request->frames);
+                if (normalized_frames < 5) {
+                    LOG_ERROR("MiniMax-H3 reference video %d needs at least 5 frames at 24 fps",
+                              video_idx + 1);
+                    return std::nullopt;
+                }
+                while (normalized_frames % 17 != 5) {
+                    --normalized_frames;
+                }
+
+                auto first = ensure_image_tensor_channels(sd_image_to_tensor(reference.frames[0]), 3);
+                if (first.empty()) {
+                    LOG_ERROR("invalid first frame in MiniMax-H3 reference video %d", video_idx + 1);
+                    return std::nullopt;
+                }
+                int source_w     = static_cast<int>(first.shape()[0]);
+                int source_h     = static_cast<int>(first.shape()[1]);
+                double ratio     = static_cast<double>(source_w) / source_h;
+                double nominal_w = ratio >= 1.0 ? 768.0 * ratio : 768.0;
+                double nominal_h = ratio >= 1.0 ? 768.0 : 768.0 / ratio;
+                if (nominal_w * nominal_h > 768.0 * 1344.0) {
+                    double scale = std::sqrt((768.0 * 1344.0) / (nominal_w * nominal_h));
+                    nominal_w *= scale;
+                    nominal_h *= scale;
+                }
+                int width  = std::max(32, static_cast<int>(std::round(nominal_w / 32.0)) * 32);
+                int height = std::max(32, static_cast<int>(std::round(nominal_h / 32.0)) * 32);
+                if (source_w * source_h < width * height) {
+                    width  = std::max(32, static_cast<int>(std::round(source_w / 32.0)) * 32);
+                    height = std::max(32, static_cast<int>(std::round(source_h / 32.0)) * 32);
+                }
+
+                sd::Tensor<float> video({width, height, normalized_frames, 3, 1});
+                for (int frame = 0; frame < normalized_frames; ++frame) {
+                    int source_index = std::min(reference.frame_count - 1,
+                                                static_cast<int>(std::floor(frame * source_fps / 24.0)));
+                    auto source      = ensure_image_tensor_channels(
+                             sd_image_to_tensor(reference.frames[source_index]),
+                             3);
+                    if (source.empty()) {
+                        LOG_ERROR("invalid frame %d in MiniMax-H3 reference video %d",
+                                  source_index + 1,
+                                  video_idx + 1);
+                        return std::nullopt;
+                    }
+                    source = resize_reference(source, width, height);
+                    sd::ops::slice_assign(&video, 2, frame, frame + 1, source.unsqueeze(2));
+                }
+                auto video_latent = sd_ctx->sd->encode_first_stage(video);
+                if (video_latent.empty()) {
+                    LOG_ERROR("failed to encode MiniMax-H3 reference video %d", video_idx + 1);
+                    return std::nullopt;
+                }
+                int32_t audio_index = -1;
+                bool has_audio      = reference.audio.data != nullptr && reference.audio.sample_count > 0;
+                if (has_audio) {
+                    if (!encode_reference_audio(reference.audio, &audio_index)) {
+                        return std::nullopt;
+                    }
+                    MiniMaxH3PresentationItem audio_item;
+                    audio_item.kind = MiniMaxH3PresentationKind::AUDIO;
+                    latents.minimax_presentation_refs.push_back(std::move(audio_item));
+                }
+
+                MiniMaxH3PresentationItem video_item;
+                video_item.kind = MiniMaxH3PresentationKind::VIDEO;
+                for (int frame = 0; frame < normalized_frames; frame += 12) {
+                    auto sampled = sd::ops::slice(video, 2, frame, frame + 1)
+                                       .reshape({width, height, 3, 1});
+                    video_item.frames.push_back(std::move(sampled));
+                    video_item.timestamps.push_back(frame / 24.f);
+                }
+                latents.minimax_presentation_refs.push_back(std::move(video_item));
+
+                int32_t video_index = static_cast<int32_t>(latents.ref_latents.size());
+                latents.ref_latents.push_back(add_visual_noise(std::move(video_latent)));
+                latents.minimax_reference_blocks.push_back({has_audio ? MiniMaxH3ReferenceKind::VIDEO_AUDIO
+                                                                      : MiniMaxH3ReferenceKind::VIDEO,
+                                                            video_index,
+                                                            audio_index});
+            }
+
+            for (int audio_idx = 0; audio_idx < sd_vid_gen_params->ref_audios_count; ++audio_idx) {
+                int32_t encoded_index = -1;
+                if (!encode_reference_audio(sd_vid_gen_params->ref_audios[audio_idx], &encoded_index)) {
+                    return std::nullopt;
+                }
+                MiniMaxH3PresentationItem item;
+                item.kind = MiniMaxH3PresentationKind::AUDIO;
+                latents.minimax_presentation_refs.push_back(std::move(item));
+                latents.minimax_reference_blocks.push_back({MiniMaxH3ReferenceKind::AUDIO,
+                                                            -1,
+                                                            encoded_index});
+            }
+        }
+
+        if (!has_references && (!start_image.empty() || !end_image.empty())) {
+            LOG_INFO(!start_image.empty() && !end_image.empty() ? "MiniMax-H3 FL2VA" : !start_image.empty() ? "MiniMax-H3 I2VA"
+                                                                                                            : "MiniMax-H3 end-frame conditioning");
+        }
+        if (!has_references &&
+            (!add_keyframe(start_image, 0, "start") ||
+             !add_keyframe(end_image, request->frames - 1, "end"))) {
+            return std::nullopt;
+        }
+    }
+
     if (sd_version_is_ltxav(sd_ctx->sd->version)) {
         latents.audio_length = get_ltxav_num_audio_latents(request->frames, request->fps);
         latents.audio_latent = make_ltxav_empty_audio_latent(latents.audio_length);
@@ -6057,7 +6432,8 @@ static std::optional<ImageGenerationLatents> prepare_video_generation_latents(sd
         latents.init_latent = sd_ctx->sd->generate_init_latent(request->width, request->height, request->frames, true);
     }
 
-    if (sd_version_is_ltxav(sd_ctx->sd->version) && !latents.audio_latent.empty()) {
+    if ((sd_version_is_ltxav(sd_ctx->sd->version) || sd_version_is_minimax_h3(sd_ctx->sd->version)) &&
+        !latents.audio_latent.empty()) {
         if (!latents.denoise_mask.empty()) {
             latents.denoise_mask = pack_ltxav_audio_and_video_denoise_mask(latents.denoise_mask,
                                                                            latents.init_latent,
@@ -6077,11 +6453,12 @@ static ImageGenerationEmbeds prepare_video_generation_embeds(sd_ctx_t* sd_ctx,
 
     ImageGenerationEmbeds embeds;
     ConditionerParams condition_params;
-    condition_params.clip_skip       = request.clip_skip;
-    condition_params.text            = request.prompt;
-    condition_params.zero_out_masked = true;
-    condition_params.ref_images      = &latents.ref_images;
-    if (sd_version_is_lingbot_video(sd_ctx->sd->version)) {
+    condition_params.clip_skip             = request.clip_skip;
+    condition_params.text                  = request.prompt;
+    condition_params.zero_out_masked       = true;
+    condition_params.ref_images            = &latents.ref_images;
+    condition_params.minimax_h3_references = &latents.minimax_presentation_refs;
+    if (sd_version_is_lingbot_video(sd_ctx->sd->version) || sd_version_is_minimax_h3(sd_ctx->sd->version)) {
         condition_params.ref_image_params.vlm_resize_mode = RefImageResizeMode::AREA;
     }
 
@@ -6090,12 +6467,28 @@ static ImageGenerationEmbeds prepare_video_generation_embeds(sd_ctx_t* sd_ctx,
                                                                                    condition_params);
     embeds.cond.c_concat     = latents.concat_latent;
     embeds.cond.c_vector     = latents.clip_vision_output;
+    if (sd_version_is_minimax_h3(sd_ctx->sd->version)) {
+        embeds.cond.c_ref_images       = latents.ref_latents;
+        embeds.cond.c_ref_audios       = latents.reference_audio_latents;
+        embeds.cond.c_reference_blocks = latents.minimax_reference_blocks;
+        if (!latents.keyframe_indices.empty()) {
+            embeds.cond.c_position_ids = sd::Tensor<int32_t>(
+                {static_cast<int64_t>(latents.keyframe_indices.size())},
+                latents.keyframe_indices);
+        }
+    }
     if (request.use_uncond) {
         condition_params.text  = request.negative_prompt;
         embeds.uncond          = sd_ctx->sd->cond_stage_model->get_learned_condition(sd_ctx->sd->n_threads,
                                                                                      condition_params);
         embeds.uncond.c_concat = latents.concat_latent;
         embeds.uncond.c_vector = latents.clip_vision_output;
+        if (sd_version_is_minimax_h3(sd_ctx->sd->version)) {
+            embeds.uncond.c_ref_images       = latents.ref_latents;
+            embeds.uncond.c_ref_audios       = latents.reference_audio_latents;
+            embeds.uncond.c_reference_blocks = latents.minimax_reference_blocks;
+            embeds.uncond.c_position_ids     = embeds.cond.c_position_ids;
+        }
     }
 
     int64_t t1 = ggml_time_ms();
@@ -6117,7 +6510,7 @@ static sd_image_t* decode_video_outputs(sd_ctx_t* sd_ctx,
         return nullptr;
     }
     sd::Tensor<float> video_latent = final_latent;
-    if (sd_version_is_ltxav(sd_ctx->sd->version) &&
+    if ((sd_version_is_ltxav(sd_ctx->sd->version) || sd_version_is_minimax_h3(sd_ctx->sd->version)) &&
         video_latent.shape()[3] > sd_ctx->sd->get_latent_channel()) {
         video_latent = sd::ops::slice(video_latent, 3, 0, sd_ctx->sd->get_latent_channel());
     }
@@ -6705,7 +7098,7 @@ SD_API bool generate_video(sd_ctx_t* sd_ctx,
     LOG_INFO("generating latent video completed, taking %.2fs", (latent_end - latent_start) * 1.0f / 1000);
 
     sd_audio_t* generated_audio = nullptr;
-    if (sd_version_is_ltxav(sd_ctx->sd->version) &&
+    if ((sd_version_is_ltxav(sd_ctx->sd->version) || sd_version_is_minimax_h3(sd_ctx->sd->version)) &&
         latents.audio_length > 0 &&
         sd_ctx->sd->audio_vae_model != nullptr) {
         if (sd_ctx->sd->get_cancel_flag() == SD_CANCEL_ALL) {
@@ -6714,9 +7107,13 @@ SD_API bool generate_video(sd_ctx_t* sd_ctx,
         }
         int64_t audio_latent_decode_start = ggml_time_ms();
 
-        auto audio_latent = unpack_ltxav_audio_latent(final_latent,
-                                                      latents.audio_length,
-                                                      sd_ctx->sd->get_latent_channel());
+        auto audio_latent = sd_version_is_minimax_h3(sd_ctx->sd->version)
+                                ? unpack_minimax_h3_audio_latent(final_latent,
+                                                                 latents.audio_length,
+                                                                 sd_ctx->sd->get_latent_channel())
+                                : unpack_ltxav_audio_latent(final_latent,
+                                                            latents.audio_length,
+                                                            sd_ctx->sd->get_latent_channel());
         if (!audio_latent.empty()) {
             LOG_DEBUG("decode audio latent %dx%dx%dx%d",
                       (int)audio_latent.shape()[0],
@@ -6727,7 +7124,7 @@ SD_API bool generate_video(sd_ctx_t* sd_ctx,
             if (!waveform.empty()) {
                 generated_audio = waveform_to_sd_audio(sd_ctx->sd, waveform);
             } else {
-                LOG_WARN("LTX audio latent decode failed; continuing with silent video output");
+                LOG_WARN("audio latent decode failed; continuing with silent video output");
             }
         }
         int64_t audio_latent_decode_end = ggml_time_ms();