From 5472c67f296971438ed0d177697719d04ceaf4f7 Mon Sep 17 00:00:00 2001
From: Komorebi623 <wang-ty22@mails.tsinghua.edu.cn>
Date: Fri, 7 Aug 2026 15:32:01 +0800
Subject: [PATCH 01/25] Align MiniMax H3 conditioning with sd.cpp

---
 docs/minimax-h3.md                            |   3 +
 examples/cli/main.cpp                         |   8 +-
 examples/cli/sample_main.cpp                  |   8 +-
 .../components/autoencoders/vae.hpp           |   3 +-
 .../components/text_encoders/llm.hpp          | 244 +++++++++++++++++-
 .../pipelines/minimax_h3_pipeline.cpp         |  82 ++++--
 6 files changed, 315 insertions(+), 33 deletions(-)

diff --git a/docs/minimax-h3.md b/docs/minimax-h3.md
index 90c51fc..f793ab8 100644
--- a/docs/minimax-h3.md
+++ b/docs/minimax-h3.md
@@ -61,6 +61,9 @@ MiniMax-H3 is a 24 fps audio-video model. The usual full-resolution setting is:
 The frame count must satisfy `17k + 5` (for example `5`, `22`, `39`, `56`). The
 examples below use 56 frames and 20 steps.
 
+`ed-cli` writes MiniMax-H3 output at 24 fps even if another `--fps` value is
+provided, matching sd.cpp and preserving the model's audio-video timing.
+
 Use `--video-format mp4` for H.264/AAC MP4 output when `ffmpeg` is available.
 Without `--audio-vae`, the model can still generate video, but no generated audio
 is decoded or muxed.
diff --git a/examples/cli/main.cpp b/examples/cli/main.cpp
index 726e737..af23a8a 100644
--- a/examples/cli/main.cpp
+++ b/examples/cli/main.cpp
@@ -808,6 +808,12 @@ int main(int argc, char** argv) {
     }
 
     if (args.video) {
+        int output_fps = args.fps;
+        const char* pipeline_name = ed_context_pipeline_name(ctx);
+        if (pipeline_name != nullptr && std::strcmp(pipeline_name, "minimax-h3") == 0 && output_fps != 24) {
+            std::fprintf(stderr, "MiniMax-H3 uses 24 fps; overriding requested fps %d\n", output_fps);
+            output_fps = 24;
+        }
         ed_video_generation_params_t gen_params;
         ed_video_generation_params_init(&gen_params);
         ed_image_t init_image = {};
@@ -935,7 +941,7 @@ int main(int argc, char** argv) {
         const std::string output_path = video_output_path(args.output_path, args.video_format);
         auto ed_wall_save0 = ed_wall_clock::now();
         bool audio_muxed = false;
-        bool ed_save_ok = save_video_with_audio(output_path.c_str(), output, args.fps, &audio_muxed);
+        bool ed_save_ok = save_video_with_audio(output_path.c_str(), output, output_fps, &audio_muxed);
         ed_wall_save = ed_wall_ms(ed_wall_save0, ed_wall_clock::now());
         if (!ed_save_ok) {
             std::fprintf(stderr, "failed to save output video: %s\n", output_path.c_str());
diff --git a/examples/cli/sample_main.cpp b/examples/cli/sample_main.cpp
index afd772f..198110e 100644
--- a/examples/cli/sample_main.cpp
+++ b/examples/cli/sample_main.cpp
@@ -578,6 +578,12 @@ int main(int argc, char** argv) {
     }
     const double load_seconds = std::chrono::duration<double>(load_t1 - load_t0).count();
     const bool is_root = ed_context_parallel_is_root(ctx);
+    int output_fps = args.fps;
+    const char* pipeline_name = ed_context_pipeline_name(ctx);
+    if (args.video && pipeline_name != nullptr && std::strcmp(pipeline_name, "minimax-h3") == 0 && output_fps != 24) {
+        std::fprintf(stderr, "MiniMax-H3 uses 24 fps; overriding requested fps %d\n", output_fps);
+        output_fps = 24;
+    }
 
     if (is_root) {
         std::printf("=== ed-sample ===\n");
@@ -723,7 +729,7 @@ int main(int argc, char** argv) {
                 }
                 std::snprintf(fname, sizeof(fname), "vid_%06d.avi", idx);
                 save_ok = save_mjpg_avi((out_path / fname).string().c_str(),
-                                        video_output, args.fps, 95);
+                                        video_output, output_fps, 95);
             } else {
                 if (output.count <= 0 || output.images == nullptr) {
                     std::fprintf(stderr, "empty output for prompt %d\n", idx);
diff --git a/src/dit_models/components/autoencoders/vae.hpp b/src/dit_models/components/autoencoders/vae.hpp
index bc109e7..711a76e 100644
--- a/src/dit_models/components/autoencoders/vae.hpp
+++ b/src/dit_models/components/autoencoders/vae.hpp
@@ -126,7 +126,8 @@ struct VAE : public GGMLRunner {
             int64_t H              = input.shape()[1] / scale_factor;
             float tile_overlap;
             int tile_size_x, tile_size_y;
-            get_tile_sizes(tile_size_x, tile_size_y, tile_overlap, tiling_params, W, H, 1.30539f);
+            const float encode_tile_factor = version == VERSION_MINIMAX_H3 ? 1.0f : 1.30539f;
+            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,
                                    n_threads,
diff --git a/src/dit_models/components/text_encoders/llm.hpp b/src/dit_models/components/text_encoders/llm.hpp
index b110f3a..28c35c9 100644
--- a/src/dit_models/components/text_encoders/llm.hpp
+++ b/src/dit_models/components/text_encoders/llm.hpp
@@ -260,6 +260,7 @@ namespace LLM {
         int patch_size                      = 14;
         int spatial_merge_size              = 2;
         int window_size                     = 112;
+        int num_position_embeddings         = 0;
         std::vector<int> deepstack_visual_indexes;
         std::set<int> fullatt_block_indexes = {7, 15, 23, 31};
     };
@@ -998,6 +999,7 @@ namespace LLM {
         LLMVisionArch arch_;
         int num_layers;
         int spatial_merge_size;
+        int num_grid_per_side;
         std::set<int> fullatt_block_indexes;
         std::vector<int> deepstack_visual_indexes;
 
@@ -1006,9 +1008,13 @@ namespace LLM {
                     const LLMVisionParams& vision_params,
                     float eps                           = 1e-6f)
             : arch_(vision_params.arch), 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), deepstack_visual_indexes(vision_params.deepstack_visual_indexes) {
             blocks["patch_embed"] = std::shared_ptr<GGMLBlock>(new VisionPatchEmbed(llama_cpp_style, arch_, vision_params.patch_size,
                                                                                     vision_params.temporal_patch_size, vision_params.in_channels, vision_params.hidden_size));
+            if (vision_params.num_position_embeddings > 0) {
+                blocks["pos_embed"] = std::make_shared<Embedding>(vision_params.num_position_embeddings, vision_params.hidden_size);
+            }
             for (int i = 0; i < num_layers; i++) {
                 blocks["blocks." + std::to_string(i)] = std::shared_ptr<GGMLBlock>(new VisionBlock(llama_cpp_style,
                                                                                                    arch_, vision_params.hidden_size,
@@ -1022,6 +1028,22 @@ namespace LLM {
             }
         }
 
+        std::shared_ptr<Embedding> pos_embedder() {
+            auto it = blocks.find("pos_embed");
+            if (it == blocks.end()) {
+                return nullptr;
+            }
+            return std::dynamic_pointer_cast<Embedding>(it->second);
+        }
+
+        int get_num_grid_per_side() const {
+            return num_grid_per_side;
+        }
+
+        int get_spatial_merge_size() const {
+            return spatial_merge_size;
+        }
+
         std::vector<ggml_tensor*> forward_outputs(GGMLRunnerContext* ctx,
                              ggml_tensor* pixel_values,
                              ggml_tensor* pe,
@@ -1029,6 +1051,7 @@ namespace LLM {
                              ggml_tensor* window_inverse_index,
                              ggml_tensor* window_mask,
                              const std::vector<int>* cu_window_seqlens = nullptr,
+                             ggml_tensor* pos_embeds = nullptr,
                              const std::string& debug_target = "") {
             // 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)]
@@ -1039,6 +1062,9 @@ namespace LLM {
 
             auto x = patch_embed->forward(ctx, pixel_values);
             sd::ggml_graph_cut::mark_graph_cut(x, "llm.vision.prelude", "x");
+            if (pos_embeds != nullptr) {
+                x = ggml_add(ctx->ggml_ctx, x, pos_embeds);
+            }
             if (debug_target == "patch_embed") {
                 return {x};
             }
@@ -1109,8 +1135,9 @@ namespace LLM {
                              ggml_tensor* window_inverse_index,
                              ggml_tensor* window_mask,
                              const std::vector<int>* cu_window_seqlens = nullptr,
+                             ggml_tensor* pos_embeds = nullptr,
                              const std::string& debug_target = "") {
-            return forward_outputs(ctx, pixel_values, pe, window_index, window_inverse_index, window_mask, cu_window_seqlens, debug_target)[0];
+            return forward_outputs(ctx, pixel_values, pe, window_index, window_inverse_index, window_mask, cu_window_seqlens, pos_embeds, debug_target)[0];
         }
     };
 
@@ -1558,6 +1585,11 @@ namespace LLM {
             return x;
         }
 
+        std::shared_ptr<VisionModel> vision_model() {
+            GGML_ASSERT(enable_vision);
+            return std::dynamic_pointer_cast<VisionModel>(blocks["visual"]);
+        }
+
         ggml_tensor* vision_forward(GGMLRunnerContext* ctx,
                                     ggml_tensor* pixel_values,
                                     ggml_tensor* pe,
@@ -1565,10 +1597,10 @@ namespace LLM {
                                     ggml_tensor* window_inverse_index,
                                     ggml_tensor* window_mask,
                                     const std::vector<int>* cu_window_seqlens = nullptr,
+                                    ggml_tensor* pos_embeds = nullptr,
                                     const std::string& debug_target = "") {
             GGML_ASSERT(enable_vision);
-            auto vision_model = std::dynamic_pointer_cast<VisionModel>(blocks["visual"]);
-            return vision_model->forward(ctx, pixel_values, pe, window_index, window_inverse_index, window_mask, cu_window_seqlens, debug_target);
+            return vision_model()->forward(ctx, pixel_values, pe, window_index, window_inverse_index, window_mask, cu_window_seqlens, pos_embeds, debug_target);
         }
 
         std::vector<ggml_tensor*> vision_forward_outputs(GGMLRunnerContext* ctx,
@@ -1576,10 +1608,10 @@ namespace LLM {
                                                           ggml_tensor* pe,
                                                           ggml_tensor* window_index,
                                                           ggml_tensor* window_inverse_index,
-                                                          ggml_tensor* window_mask) {
+                                                          ggml_tensor* window_mask,
+                                                          ggml_tensor* pos_embeds = nullptr) {
             GGML_ASSERT(enable_vision);
-            auto vision_model = std::dynamic_pointer_cast<VisionModel>(blocks["visual"]);
-            return vision_model->forward_outputs(ctx, pixel_values, pe, window_index, window_inverse_index, window_mask);
+            return vision_model()->forward_outputs(ctx, pixel_values, pe, window_index, window_inverse_index, window_mask, nullptr, pos_embeds);
         }
     };
 
@@ -1595,6 +1627,8 @@ namespace LLM {
         std::vector<int> window_inverse_index_vec;
         std::vector<int> cu_window_seqlens_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;
 
         LLMRunner(LLMArch arch,
                   ggml_backend_t backend,
@@ -1641,6 +1675,10 @@ namespace LLM {
                     if (contains(tensor_name, "visual.patch_embed.proj.bias")) {
                         params.vision.hidden_size = pair.second.ne[0];
                     }
+                    if (contains(tensor_name, "visual.pos_embed.weight")) {
+                        params.vision.hidden_size             = pair.second.ne[0];
+                        params.vision.num_position_embeddings = static_cast<int>(pair.second.ne[1]);
+                    }
                     if (contains(tensor_name, "visual.blocks.")) {
                         auto items = split_string(tensor_name.substr(pos), '.');
                         if (items.size() > 2) {
@@ -1743,7 +1781,7 @@ namespace LLM {
                                     ggml_tensor* window_inverse_index,
                                     ggml_tensor* window_mask,
                                     const std::string& debug_target = "") {
-            auto hidden_states = model.vision_forward(ctx, pixel_values, input_pos, window_index, window_inverse_index, window_mask, &cu_window_seqlens_vec, debug_target);
+            auto hidden_states = model.vision_forward(ctx, pixel_values, input_pos, window_index, window_inverse_index, window_mask, &cu_window_seqlens_vec, nullptr, debug_target);
             return hidden_states;
         }
 
@@ -2056,6 +2094,128 @@ namespace LLM {
             return patches;
         }
 
+        sd::Tensor<float> process_video_block_patches_host(const sd::Tensor<float>& frames) {
+            if (frames.empty() || frames.dim() != 5 ||
+                frames.shape()[2] != params.vision.temporal_patch_size ||
+                frames.shape()[3] != params.vision.in_channels ||
+                frames.shape()[4] != 1) {
+                return {};
+            }
+
+            const int64_t width       = frames.shape()[0];
+            const int64_t height      = frames.shape()[1];
+            const int64_t temporal    = frames.shape()[2];
+            const int64_t channels    = frames.shape()[3];
+            const int64_t patch       = params.vision.patch_size;
+            const int64_t merge       = params.vision.spatial_merge_size;
+            const int64_t grid_w      = width / patch;
+            const int64_t grid_h      = height / patch;
+            const int64_t feature     = channels * temporal * patch * patch;
+            const int64_t token_count = grid_h * grid_w;
+            if (width <= 0 || height <= 0 || grid_w <= 0 || grid_h <= 0 ||
+                grid_w % merge != 0 || grid_h % merge != 0) {
+                return {};
+            }
+
+            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_tensor* build_qwen3_vl_patch_pos_embeds(GGMLRunnerContext* runner_ctx,
+                                                     std::shared_ptr<VisionModel> vision,
+                                                     int grid_h,
+                                                     int grid_w) {
+            auto pos_embed = vision->pos_embedder();
+            GGML_ASSERT(pos_embed != nullptr);
+            const int num_grid_per_side = vision->get_num_grid_per_side();
+            const int merge_size        = vision->get_spatial_merge_size();
+            GGML_ASSERT(num_grid_per_side > 0);
+            GGML_ASSERT(grid_h % merge_size == 0);
+            GGML_ASSERT(grid_w % merge_size == 0);
+
+            for (int index = 0; index < 4; ++index) {
+                pos_embed_idx_data[index].clear();
+                pos_embed_weight_data[index].clear();
+                pos_embed_idx_data[index].reserve(static_cast<size_t>(grid_h * grid_w));
+                pos_embed_weight_data[index].reserve(static_cast<size_t>(grid_h * grid_w));
+            }
+
+            const double max_index = static_cast<double>(num_grid_per_side - 1);
+            for (int block_h = 0; block_h < grid_h / merge_size; ++block_h) {
+                for (int block_w = 0; block_w < grid_w / merge_size; ++block_w) {
+                    for (int inner_h = 0; inner_h < merge_size; ++inner_h) {
+                        const int h = block_h * merge_size + inner_h;
+                        const double h_pos = grid_h == 1 ? 0.0 : max_index * h / static_cast<double>(grid_h - 1);
+                        const int h_floor = static_cast<int>(std::floor(h_pos));
+                        const int h_ceil = std::min(h_floor + 1, num_grid_per_side - 1);
+                        const double dh = h_pos - h_floor;
+                        for (int inner_w = 0; inner_w < merge_size; ++inner_w) {
+                            const int w = block_w * merge_size + inner_w;
+                            const double w_pos = grid_w == 1 ? 0.0 : max_index * w / static_cast<double>(grid_w - 1);
+                            const int w_floor = static_cast<int>(std::floor(w_pos));
+                            const int w_ceil = std::min(w_floor + 1, num_grid_per_side - 1);
+                            const double dw = w_pos - w_floor;
+                            const int ids[4] = {
+                                h_floor * num_grid_per_side + w_floor,
+                                h_floor * num_grid_per_side + w_ceil,
+                                h_ceil * num_grid_per_side + w_floor,
+                                h_ceil * num_grid_per_side + w_ceil,
+                            };
+                            const float weights[4] = {
+                                static_cast<float>((1.0 - dh) * (1.0 - dw)),
+                                static_cast<float>((1.0 - dh) * dw),
+                                static_cast<float>(dh * (1.0 - dw)),
+                                static_cast<float>(dh * dw),
+                            };
+                            for (int index = 0; index < 4; ++index) {
+                                pos_embed_idx_data[index].push_back(ids[index]);
+                                pos_embed_weight_data[index].push_back(weights[index]);
+                            }
+                        }
+                    }
+                }
+            }
+
+            ggml_tensor* result = nullptr;
+            for (int index = 0; index < 4; ++index) {
+                auto idx_tensor = ggml_new_tensor_1d(compute_ctx, GGML_TYPE_I32, static_cast<int64_t>(pos_embed_idx_data[index].size()));
+                set_backend_tensor_data(idx_tensor, pos_embed_idx_data[index].data());
+                auto embed = pos_embed->forward(runner_ctx, idx_tensor);
+                embed = ggml_reshape_2d(compute_ctx, embed, embed->ne[0], embed->ne[1] * embed->ne[2]);
+                auto weight_tensor = ggml_new_tensor_2d(compute_ctx, GGML_TYPE_F32, 1, static_cast<int64_t>(pos_embed_weight_data[index].size()));
+                set_backend_tensor_data(weight_tensor, pos_embed_weight_data[index].data());
+                embed = ggml_mul(compute_ctx, embed, weight_tensor);
+                result = result == nullptr ? embed : ggml_add(compute_ctx, result, embed);
+            }
+            return result;
+        }
+
         ggml_cgraph* build_encode_image_graph(const sd::Tensor<float>& pixel_values_tensor,
                                               int64_t image_width,
                                               int64_t image_height,
@@ -2070,6 +2230,9 @@ namespace LLM {
                 const int grid_h = static_cast<int>(image_height) / params.vision.patch_size;
                 const int grid_w = static_cast<int>(image_width) / params.vision.patch_size;
                 const int head_dim = static_cast<int>(params.vision.hidden_size / params.vision.num_heads);
+                auto runner_ctx = get_context();
+                auto vision = model.vision_model();
+                auto pos_embeds = build_qwen3_vl_patch_pos_embeds(&runner_ctx, vision, grid_h, grid_w);
                 window_index_vec.resize(static_cast<size_t>((grid_h / params.vision.spatial_merge_size) *
                                                             (grid_w / params.vision.spatial_merge_size)));
                 for (size_t index = 0; index < window_index_vec.size(); ++index) {
@@ -2084,13 +2247,13 @@ namespace LLM {
                 const 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 runner_ctx = get_context();
                 auto outputs = model.vision_forward_outputs(&runner_ctx,
                                                             pixel_values,
                                                             pe,
                                                             nullptr,
                                                             nullptr,
-                                                            nullptr);
+                                                            nullptr,
+                                                            pos_embeds);
                 ggml_build_forward_expand(gf, outputs[0]);
                 return gf;
             }
@@ -2333,13 +2496,15 @@ namespace LLM {
                 const int grid_h = static_cast<int>(image_height / params.vision.patch_size);
                 const int grid_w = static_cast<int>(image_width / params.vision.patch_size);
                 const int head_dim = static_cast<int>(params.vision.hidden_size / params.vision.num_heads);
+                auto runner_ctx = get_context();
+                auto vision = model.vision_model();
+                auto pos_embeds = build_qwen3_vl_patch_pos_embeds(&runner_ctx, vision, grid_h, grid_w);
                 window_index_vec.resize(static_cast<size_t>((grid_h / params.vision.spatial_merge_size) * (grid_w / params.vision.spatial_merge_size)));
                 for (size_t index = 0; index < window_index_vec.size(); ++index) window_index_vec[index] = static_cast<int>(index);
                 pe_vec = Rope::gen_qwen2vl_pe(grid_h, grid_w, params.vision.spatial_merge_size, window_index_vec, 10000, {head_dim / 2, head_dim / 2});
                 auto pe = ggml_new_tensor_4d(compute_ctx, GGML_TYPE_F32, 2, 2, head_dim / 2, static_cast<int>(pe_vec.size() / head_dim / 2));
                 set_backend_tensor_data(pe, pe_vec.data());
-                auto runner_ctx = get_context();
-                auto outputs = model.vision_forward_outputs(&runner_ctx, pixels, pe, nullptr, nullptr, nullptr);
+                auto outputs = model.vision_forward_outputs(&runner_ctx, pixels, pe, nullptr, nullptr, nullptr, pos_embeds);
                 auto combined = outputs[0];
                 for (size_t index = 1; index < outputs.size(); ++index) combined = ggml_concat(compute_ctx, combined, outputs[index], 0);
                 ggml_build_forward_expand(graph, combined);
@@ -2355,6 +2520,63 @@ namespace LLM {
             }
             return outputs;
         }
+
+        std::vector<sd::Tensor<float>> encode_video_block_outputs(const int n_threads,
+                                                                  const sd::Tensor<float>& frames) {
+            if (params.vision.arch != LLMVisionArch::QWEN3_VL) {
+                return encode_image_outputs(n_threads, frames);
+            }
+            const int grid_h = static_cast<int>(frames.shape()[1] / params.vision.patch_size);
+            const int grid_w = static_cast<int>(frames.shape()[0] / params.vision.patch_size);
+            const auto pixel_values = process_video_block_patches_host(frames);
+            if (pixel_values.empty()) {
+                return {};
+            }
+            auto get_graph = [&]() -> ggml_cgraph* {
+                ggml_cgraph* graph = new_graph_custom(LLM_GRAPH_SIZE);
+                auto pixels = make_input(pixel_values);
+                auto runner_ctx = get_context();
+                auto vision = model.vision_model();
+                const int head_dim = static_cast<int>(params.vision.hidden_size / params.vision.num_heads);
+                auto pos_embeds = build_qwen3_vl_patch_pos_embeds(&runner_ctx, vision, grid_h, grid_w);
+                window_index_vec.resize(static_cast<size_t>((grid_h / params.vision.spatial_merge_size) *
+                                                            (grid_w / params.vision.spatial_merge_size)));
+                for (size_t index = 0; index < window_index_vec.size(); ++index) {
+                    window_index_vec[index] = static_cast<int>(index);
+                }
+                pe_vec = Rope::gen_qwen2vl_pe(grid_h,
+                                               grid_w,
+                                               params.vision.spatial_merge_size,
+                                               window_index_vec,
+                                               10000,
+                                               {head_dim / 2, head_dim / 2});
+                const 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 = model.vision_forward_outputs(&runner_ctx,
+                                                            pixels,
+                                                            pe,
+                                                            nullptr,
+                                                            nullptr,
+                                                            nullptr,
+                                                            pos_embeds);
+                auto combined = outputs[0];
+                for (size_t index = 1; index < outputs.size(); ++index) {
+                    combined = ggml_concat(compute_ctx, combined, outputs[index], 0);
+                }
+                ggml_build_forward_expand(graph, combined);
+                return graph;
+            };
+            auto combined = take_or_empty(GGMLRunner::compute<float>(get_graph, n_threads, true));
+            if (combined.empty()) return {};
+            const size_t count = params.vision.deepstack_visual_indexes.size() + 1;
+            std::vector<sd::Tensor<float>> outputs;
+            outputs.reserve(count);
+            for (size_t index = 0; index < count; ++index) {
+                outputs.push_back(sd::ops::slice(combined, 0, static_cast<int64_t>(index) * params.hidden_size, static_cast<int64_t>(index + 1) * params.hidden_size));
+            }
+            return outputs;
+        }
     };
 
     struct LLMEmbedder {
diff --git a/src/dit_models/pipelines/minimax_h3_pipeline.cpp b/src/dit_models/pipelines/minimax_h3_pipeline.cpp
index eb5b68e..d181b27 100644
--- a/src/dit_models/pipelines/minimax_h3_pipeline.cpp
+++ b/src/dit_models/pipelines/minimax_h3_pipeline.cpp
@@ -365,6 +365,8 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
     std::vector<std::pair<int, sd::Tensor<float>>> image_embeds;
     std::vector<LLM::LLMImageEmbedInfo> image_embed_infos;
     std::vector<std::vector<std::pair<int, sd::Tensor<float>>>> deepstack_image_embeds(3);
+    std::vector<std::pair<int, int64_t>> vision_token_ranges;
+    const int vision_patch_size = conditioner_->model.params.vision.patch_size;
     for (int image_index = 0; image_index < ref_image_count; ++image_index) {
         const ed_image_t& image = ref_images[image_index];
         int width = 0;
@@ -397,7 +399,9 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
         for (size_t layer = 0; layer < deepstack_image_embeds.size(); ++layer) {
             deepstack_image_embeds[layer].emplace_back(static_cast<int>(prefix_tokens.size()), std::move(image_outputs[layer + 1]));
         }
-        image_embed_infos.push_back({static_cast<int>(prefix_tokens.size()), image_tokens, 1, height / 16, width / 16});
+        const int embed_index = static_cast<int>(prefix_tokens.size());
+        image_embed_infos.push_back({embed_index, image_tokens, 1, height / vision_patch_size, width / vision_patch_size});
+        vision_token_ranges.emplace_back(embed_index, image_tokens);
     }
     int video_number = 0;
     int audio_number = 0;
@@ -418,9 +422,17 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
         }
         presentations += "<Video " + std::to_string(++video_number) + ">: ";
         while (normalized_frames % 17 != 5) --normalized_frames;
-        for (int presentation_frame = 0; presentation_frame < normalized_frames; presentation_frame += 12) {
-            const int first_index = std::min(reference.frame_count - 1, static_cast<int>(std::floor(presentation_frame * source_fps / 24.0)));
-            const int second_index = std::min(reference.frame_count - 1, static_cast<int>(std::floor(std::min(presentation_frame + 12, normalized_frames - 1) * source_fps / 24.0)));
+        std::vector<int> sampled_frames;
+        sampled_frames.reserve(static_cast<size_t>((normalized_frames + 11) / 12));
+        for (int frame = 0; frame < normalized_frames; frame += 12) {
+            sampled_frames.push_back(frame);
+        }
+        for (size_t sampled_index = 0; sampled_index < sampled_frames.size(); sampled_index += 2) {
+            const size_t next_sampled_index = std::min(sampled_index + 1, sampled_frames.size() - 1);
+            const int first_frame = sampled_frames[sampled_index];
+            const int second_frame = sampled_frames[next_sampled_index];
+            const int first_index = std::min(reference.frame_count - 1, static_cast<int>(std::floor(first_frame * source_fps / 24.0)));
+            const int second_index = std::min(reference.frame_count - 1, static_cast<int>(std::floor(second_frame * source_fps / 24.0)));
             const ed_image_t& first_image = reference.frames[first_index];
             int width = 0;
             int height = 0;
@@ -428,13 +440,19 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
             auto first = h3_image_to_tensor(first_image, width, height);
             auto second = h3_image_to_tensor(reference.frames[second_index], width, height);
             if (first.empty() || second.empty()) return set_minimax_error(error, "MiniMax-H3 Ref2VA video frame is invalid");
-            sd::Tensor<float> pair({width, height, 3, 2});
-            const size_t frame_values = static_cast<size_t>(width) * height * 3;
-            for (size_t value = 0; value < frame_values; ++value) { pair.data()[value] = first.data()[value] * 2.f - 1.f; pair.data()[value + frame_values] = second.data()[value] * 2.f - 1.f; }
-            auto outputs = conditioner_->model.encode_image_outputs(runtime_->n_threads(), pair);
+            sd::Tensor<float> pair({width, height, 2, 3, 1});
+            for (int channel = 0; channel < 3; ++channel) {
+                for (int y = 0; y < height; ++y) {
+                    for (int x = 0; x < width; ++x) {
+                        pair.index(x, y, 0, channel, 0) = first.index(x, y, channel, 0) * 2.f - 1.f;
+                        pair.index(x, y, 1, channel, 0) = second.index(x, y, channel, 0) * 2.f - 1.f;
+                    }
+                }
+            }
+            auto outputs = conditioner_->model.encode_video_block_outputs(runtime_->n_threads(), pair);
             if (outputs.size() != 4 || outputs[0].empty()) return set_minimax_error(error, "MiniMax-H3 Ref2VA video vision encoder failed");
-            const float first_time = static_cast<float>(presentation_frame) / 24.0f;
-            const float second_time = static_cast<float>(std::min(presentation_frame + 12, normalized_frames - 1)) / 24.0f;
+            const float first_time = static_cast<float>(first_frame) / 24.0f;
+            const float second_time = static_cast<float>(second_frame) / 24.0f;
             std::ostringstream timestamp_stream;
             timestamp_stream << '<' << std::fixed << std::setprecision(1)
                              << (first_time + second_time) * 0.5f << " seconds>";
@@ -444,9 +462,11 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
             const int64_t tokens = outputs[0].shape()[1];
             for (int64_t token = 0; token < tokens; ++token) presentations += "<|image_pad|>";
             presentations += "<|vision_end|>";
-            image_embeds.emplace_back(static_cast<int>(prefix_tokens.size()), std::move(outputs[0]));
-            for (size_t layer = 0; layer < deepstack_image_embeds.size(); ++layer) deepstack_image_embeds[layer].emplace_back(static_cast<int>(prefix_tokens.size()), std::move(outputs[layer + 1]));
-            image_embed_infos.push_back({static_cast<int>(prefix_tokens.size()), tokens, 1, height / 16, width / 16});
+            const int embed_index = static_cast<int>(prefix_tokens.size());
+            image_embeds.emplace_back(embed_index, std::move(outputs[0]));
+            for (size_t layer = 0; layer < deepstack_image_embeds.size(); ++layer) deepstack_image_embeds[layer].emplace_back(embed_index, std::move(outputs[layer + 1]));
+            image_embed_infos.push_back({embed_index, tokens, 1, height / vision_patch_size, width / vision_patch_size});
+            vision_token_ranges.emplace_back(embed_index, tokens);
         }
     }
     for (int audio_index = 0; audio_index < ref_audio_count; ++audio_index) {
@@ -464,8 +484,14 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
     if (context->empty()) {
         return set_minimax_error(error, "MiniMax-H3 text encoder compute failed");
     }
-    *token_tags = sd::Tensor<int32_t>({context->shape()[1]},
-                                      std::vector<int32_t>(static_cast<size_t>(context->shape()[1]), 1));
+    std::vector<int32_t> tags(static_cast<size_t>(context->shape()[1]), 1);
+    for (const auto& range : vision_token_ranges) {
+        const int64_t begin = std::max<int64_t>(0, static_cast<int64_t>(range.first) - 1);
+        const int64_t end = std::min<int64_t>(static_cast<int64_t>(tags.size()), static_cast<int64_t>(range.first) + range.second + 1);
+        std::fill(tags.begin() + begin, tags.begin() + end, 0);
+    }
+    const int64_t tag_count = static_cast<int64_t>(tags.size());
+    *token_tags = sd::Tensor<int32_t>({tag_count}, std::move(tags));
     h3_trace_tensor("text_context", *context);
     return true;
 }
@@ -590,9 +616,17 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
         set_minimax_error(error, "MiniMax-H3 Ref2VA reference arrays are invalid");
         return ED_STATUS_INVALID_ARGUMENT;
     }
+    const int64_t resolved_seed = h3_resolve_seed(params->seed);
     sd::Tensor<float> context;
     sd::Tensor<int32_t> token_tags;
     if (!build_text_context(params->prompt, params->ref_images, params->ref_image_count, params->ref_videos, params->ref_video_count, params->ref_audio_count, frames, &context, &token_tags, error)) return ED_STATUS_GENERATION_FAILED;
+    const float cfg_scale = params->sample.cfg_scale;
+    const bool use_cfg = cfg_scale != 1.0f;
+    sd::Tensor<float> uncond_context;
+    sd::Tensor<int32_t> uncond_token_tags;
+    if (use_cfg && !build_text_context(params->negative_prompt, params->ref_images, params->ref_image_count, params->ref_videos, params->ref_video_count, params->ref_audio_count, frames, &uncond_context, &uncond_token_tags, error)) {
+        return ED_STATUS_GENERATION_FAILED;
+    }
     const int latent_frames = frames <= 5 ? 2 : ((frames - 5) / 17) * 5 + 2;
     const int audio_length = std::max(1, static_cast<int>(std::lround(static_cast<double>(frames) * 40.0 / 24.0)));
     const int latent_width = params->width / 16;
@@ -613,7 +647,7 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
             return set_minimax_error(error, "MiniMax-H3 keyframe VAE encode failed");
         }
         sd::Tensor<float> latent = vae_->vae_to_diffusion_latents(vae_latent);
-        auto condition_rng = std::make_shared<PhiloxRNG>(static_cast<uint64_t>(h3_resolve_seed(params->seed)));
+        auto condition_rng = std::make_shared<PhiloxRNG>(static_cast<uint64_t>(resolved_seed));
         latent = latent * MiniMaxH3::VISUAL_COND_TIMESTEP +
                  sd::randn_like<float>(latent, condition_rng) * (1.0f - MiniMaxH3::VISUAL_COND_TIMESTEP);
         h3_trace_tensor((std::string(name) + "_keyframe_latent").c_str(), latent);
@@ -669,7 +703,7 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
             return ED_STATUS_GENERATION_FAILED;
         }
         sd::Tensor<float> latent = vae_->vae_to_diffusion_latents(vae_latent);
-        auto condition_rng = std::make_shared<PhiloxRNG>(static_cast<uint64_t>(h3_resolve_seed(params->seed)));
+        auto condition_rng = std::make_shared<PhiloxRNG>(static_cast<uint64_t>(resolved_seed));
         latent = latent * MiniMaxH3::VISUAL_COND_TIMESTEP +
                  sd::randn_like<float>(latent, condition_rng) * (1.0f - MiniMaxH3::VISUAL_COND_TIMESTEP);
         h3_trace_tensor(("ref_image_" + std::to_string(reference_index) + "_latent").c_str(), latent);
@@ -714,7 +748,7 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
             set_minimax_error(error, "MiniMax-H3 Ref2VA video audio encode failed"); return ED_STATUS_GENERATION_FAILED;
         }
         auto latent = vae_->vae_to_diffusion_latents(vae_latent);
-        auto condition_rng = std::make_shared<PhiloxRNG>(static_cast<uint64_t>(h3_resolve_seed(params->seed)));
+        auto condition_rng = std::make_shared<PhiloxRNG>(static_cast<uint64_t>(resolved_seed));
         latent = latent * MiniMaxH3::VISUAL_COND_TIMESTEP + sd::randn_like<float>(latent, condition_rng) * (1.0f - MiniMaxH3::VISUAL_COND_TIMESTEP);
         const int32_t encoded_video_index = static_cast<int32_t>(reference_latents.size());
         reference_latents.push_back(std::move(latent));
@@ -731,7 +765,7 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
     sd::Tensor<float> video = sd::zeros<float>({latent_width, latent_height, latent_frames, 24, 1});
     sd::Tensor<float> audio = sd::zeros<float>({audio_length, 2, 32, 1});
     sd::Tensor<float> packed = h3_pack_audio_and_video_latents(video, audio);
-    auto rng = std::make_shared<PhiloxRNG>(static_cast<uint64_t>(h3_resolve_seed(params->seed)));
+    auto rng = std::make_shared<PhiloxRNG>(static_cast<uint64_t>(resolved_seed));
     packed = sd::randn_like<float>(packed, rng);
     h3_trace_tensor("initial_packed_noise", packed);
     const int steps = params->sample.steps > 0 ? params->sample.steps : 20;
@@ -763,6 +797,16 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
             set_minimax_error(error, "MiniMax-H3 diffusion compute failed");
             return ED_STATUS_GENERATION_FAILED;
         }
+        if (use_cfg) {
+            diffusion_params.context = &uncond_context;
+            diffusion_params.minimax_text_token_tags = &uncond_token_tags;
+            sd::Tensor<float> uncond_velocity = diffusion_->compute(runtime_->n_threads(), diffusion_params);
+            if (uncond_velocity.empty()) {
+                set_minimax_error(error, "MiniMax-H3 unconditional diffusion compute failed");
+                return ED_STATUS_GENERATION_FAILED;
+            }
+            velocity = uncond_velocity + (velocity - uncond_velocity) * cfg_scale;
+        }
         if (h3_trace_enabled()) {
             LOG_INFO("minimax-h3 trace step=%d sigma=%.8g sigma_next=%.8g", step, sigma, sigma_next);
             h3_trace_tensor(("step_" + std::to_string(step) + "_velocity").c_str(), velocity);

From a761c7c5eda3cf2dc2a7a3519c6ff1f5d16085f7 Mon Sep 17 00:00:00 2001
From: Komorebi623 <wang-ty22@mails.tsinghua.edu.cn>
Date: Fri, 7 Aug 2026 21:08:15 +0800
Subject: [PATCH 02/25] Optimize MiniMax H3 CUDA inference

---
 .../minimax-h3-handoff-2026-08-07.md          | 668 ++++++++++++++++++
 scripts/diffusers/run_minimax_h3_fl2va.py     | 119 ++++
 scripts/diffusers/run_minimax_h3_fl2va.sh     |  16 +
 .../run_minimax_h3_fl2va_quantized.py         | 241 +++++++
 src/dit_models/models/minimax_h3_full.hpp     |  79 ++-
 .../pipelines/minimax_h3_pipeline.cpp         | 158 ++++-
 .../pipelines/minimax_h3_pipeline.hpp         |   6 +
 third_party/ggml                              |   2 +-
 8 files changed, 1259 insertions(+), 30 deletions(-)
 create mode 100644 docs/optimization/minimax-h3-handoff-2026-08-07.md
 create mode 100755 scripts/diffusers/run_minimax_h3_fl2va.py
 create mode 100755 scripts/diffusers/run_minimax_h3_fl2va.sh
 create mode 100755 scripts/diffusers/run_minimax_h3_fl2va_quantized.py

diff --git a/docs/optimization/minimax-h3-handoff-2026-08-07.md b/docs/optimization/minimax-h3-handoff-2026-08-07.md
new file mode 100644
index 0000000..3d3b539
--- /dev/null
+++ b/docs/optimization/minimax-h3-handoff-2026-08-07.md
@@ -0,0 +1,668 @@
+# MiniMax-H3 optimization and Diffusers handoff (2026-08-07)
+
+## Scope and constraints
+
+- Repository: `/export/home/wangtianyang.21/code1/edge-dit.cpp`
+- Current branch: `main`; last committed H3 baseline: `5472c67 Align MiniMax H3 conditioning with sd.cpp`.
+- Use **one CUDA GPU only** for inference/performance work. Do not run CPU inference.
+- This is a shared machine. Do not kill processes that are not created by this task.
+- Do not commit or push without an explicit user request.
+- The user wants eventual quality and performance comparison against official Hugging Face Diffusers, not just sd.cpp.
+
+## Current working tree
+
+Intentional, uncommitted source changes that predate this handoff:
+
+- `src/dit_models/pipelines/minimax_h3_pipeline.cpp`
+- `src/dit_models/pipelines/minimax_h3_pipeline.hpp`
+
+These add `ED_MINIMAX_H3_PROFILE=1` phase timing and make H3 honor explicit VAE tiling disablement. Keep them unless separately reviewed.
+
+New, uncommitted Diffusers benchmark launcher files:
+
+- `scripts/diffusers/run_minimax_h3_fl2va.py`
+- `scripts/diffusers/run_minimax_h3_fl2va.sh`
+
+Other untracked paths shown by `git status` (assets, benchmarks, `.codex-tmp`, `third_party/onednn`, and so on) were already present or are unrelated; do not clean them blindly.
+
+## Current edge-dit H3 implementation
+
+The project supports both MiniMax-H3 checkpoint families through the existing H3 pipeline:
+
+- FL2VA: text-to-audio-video and first/last-keyframe-to-audio-video.
+- Ref2VA: ordered image/video/audio reference conditioning.
+
+The C++ model baseline is quantized GGUF:
+
+- `/models/MiniMax-H3-GGUF/minimax_h3_fl2va-Q4_K_M.gguf`
+- `/models/MiniMax-H3-GGUF/qwen3vl_32b_minimax_h3-Q4_K_M.gguf`
+- `/models/MiniMax-H3-GGUF/minimax_h3_video_vae_fp16.safetensors`
+- `/models/MiniMax-H3-GGUF/minimax_h3_audio_vae_fp32.safetensors`
+
+The main H3 implementation is in:
+
+- `src/dit_models/models/minimax_h3_full.hpp`
+- `src/dit_models/pipelines/minimax_h3_pipeline.cpp`
+- `src/dit_models/pipelines/minimax_h3_pipeline.hpp`
+
+sd.cpp reference source is read-only at `../stable-diffusion.cpp`.
+
+## CUDA build and runtime state
+
+The active container is `wty-edgedit-dev`; workspace inside it is `/workspace/edge-dit.cpp`.
+
+The active CUDA build is `build-cuda-docker`, built successfully with:
+
+```bash
+docker exec wty-edgedit-dev bash -lc \
+  'cd /workspace/edge-dit.cpp && cmake --build build-cuda-docker -j64'
+```
+
+Relevant active CMake options:
+
+```text
+ED_ENABLE_CUDA_MODULATION=ON
+ED_ENABLE_CUDA_NORM=ON
+ED_ENABLE_CUDA_ROPE=ON
+GGML_CUDA_FA=ON
+GGML_CUDA_FORCE_MMQ=OFF
+GGML_CUDA_FORCE_CUBLAS=OFF
+GGML_CUDA_GRAPHS=OFF
+```
+
+`GGML_CUDA_GRAPHS=ON` was tested with an isolated rebuild. It produced identical first-frame output but did not improve H3: 5-step diffusion changed from `25.593s` to `25.619s`. It is intentionally restored to `OFF`.
+
+## Performance baseline and operator profile
+
+Primary small regression case (FL2VA):
+
+```text
+Resolution: 864x480
+Frames: 56 at 24 fps
+Steps: 5
+Seed: 42
+CFG: 2
+VAE tiling: explicitly off
+```
+
+Baseline script and output:
+
+- `outputs/minimax-h3/perf-fl2va-regression-2026-08-07/run.sh`
+- `outputs/minimax-h3/perf-fl2va-regression-2026-08-07/final.mp4`
+- `outputs/minimax-h3/perf-fl2va-regression-2026-08-07/run.log`
+
+Baseline phase timing:
+
+```text
+generation total: 34.221s
+diffusion:        25.593s (10 forwards: conditional + unconditional per step)
+conditioning:      0.916s
+decode:            7.524s
+end-to-end wall:  42.811s
+```
+
+For the larger mixed Ref2VA baseline (`864x480`, 56 frames, 20 steps, CFG 2):
+
+```text
+total:                     260.523s
+diffusion:                 222.113s (85.3%)
+reference video VAE encode: 24.498s
+```
+
+CUDA op profiling for the FL2VA 5-step probe:
+
+```text
+one DiT CUDA graph:       about 2.46s
+Q4_K x FP32 MMQ/GEMM:     1.61-1.64s (about 66%)
+attention:                0.30-0.32s (about 12-13%)
+layout/materialization:   about 0.44s (about 18%)
+elementwise/norm/RoPE:    about 0.23s (about 9%)
+```
+
+Percentages are profiler buckets and overlap slightly; do not force them to sum exactly to 100%.
+
+Heavy MMQ shapes observed:
+
+```text
+m=28672 n=7919 k=5376, 50 calls: about 642ms
+m=21504 n=7919 k=5376, 50 calls: about 480ms
+m=5376  n=7919 k=14336, 50 calls: about 329ms
+m=5376  n=7919 k=7168, 50 calls: about 166ms
+```
+
+Relevant artifacts:
+
+- `outputs/minimax-h3/perf-baseline-mixed-2026-08-07/baseline.mp4`
+- `outputs/minimax-h3/perf-runner-probe-2026-08-07/run.log`
+- `outputs/minimax-h3/perf-cuda-op-profile-fl2va-2026-08-07/run.log`
+- `outputs/minimax-h3/perf-cudnn-sdpa-fl2va-2026-08-07/run.log`
+
+## MMQ, Tensor Cores, and cuDNN
+
+The main Q4_K DiT linear layers use GGML CUDA MMQ. On the H200 (SM90), this takes GGML's Turing-or-newer MMA path, so it does use Tensor Cores. The activation is dynamically quantized to `Q8_1` and multiplied with `Q4_K` weights; it is not a normal BF16 GEMM dispatched through cuBLAS/cuDNN.
+
+This is not unique to H3: the CUDA backend dispatches every quantized matrix multiplication meeting the same conditions (quantized weights, F32 activation/output, compatible layout and sufficiently large batch) through the common MMQ route. Different models and quantization types select different MMQ specializations; unsupported layouts or small/vector cases use MMVQ or fall back to cuBLAS after conversion. H3's main Q4_K projections meet the MMQ conditions.
+
+cuDNN still helps a separate part of the model: H3 long self-attention successfully hits cuDNN SDPA (`b=1`, `h=56`, `d=128`, sequence length around `7919`). Some padded/unsupported attention shapes fall back. MMQ is the primary throughput limit and is not replaced by cuDNN SDPA.
+
+Existing Flux/Qwen fused modulation or QKV paths do not automatically match H3. H3 has multi-span AdaLN modulation and concatenation in `minimax_h3_full.hpp`; a specialized implementation is needed rather than reusing those model-specific fusions blindly.
+
+## Attempted H3 modulation fusion — rejected
+
+An experiment temporarily connected H3 spans in `minimax_h3_full.hpp` to the existing generic CUDA custom ops:
+
+- `edgedit::ggml_ext::fused_modulate_custom`
+- `edgedit::ggml_ext::fused_residual_gate_custom`
+
+The experiment was fully reverted. There is no remaining H3 fusion change in the source tree.
+
+Why it was rejected:
+
+- It made the 5-step diffusion timer look better: `25.593s -> 25.174s` (about 1.6%).
+- Although mathematically equivalent, the fused kernel's floating-point instruction path differs from the original graph's `mul -> add -> add` scheduling.
+- Diffusion amplifies tiny differences. The resulting 56-frame video diverged visibly: middle frames were around `23dB` PSNR against the baseline, so the output is not quality-equivalent.
+
+Experimental artifacts (use only for diagnosis, not as accepted outputs):
+
+- `outputs/minimax-h3/perf-fused-modulation-fl2va-2026-08-07/final.mp4`
+- `outputs/minimax-h3/perf-fused-modulation-fl2va-2026-08-07/run.log`
+
+Any future H3 fusion must use a strict quality gate:
+
+1. Preserve the original operation/rounding order where possible; do not use algebraic rewrites or FMA that change it.
+2. Run the same deterministic input and seed.
+3. Compare all decoded frames and audio, not just MP4 hashes or the first frame.
+4. Only retain an optimization after proving quality is acceptable and timing improvement survives repeated trials.
+
+The likely next low-risk target is a H3-specific, rounding-preserving span implementation that reduces temporary layout/copy work without changing `mul -> add -> add` semantics. It should be profiled before implementation; it can only address the layout/elementwise portion, not the approximately 66% MMQ limit.
+
+## Official Diffusers baseline
+
+Official model URL: `https://huggingface.co/MiniMaxAI/MiniMax-H3`.
+
+Official Diffusers documentation: `https://huggingface.co/docs/diffusers/main/en/api/pipelines/minimax_h3`.
+
+The installed release `diffusers==0.39.0` did not contain MiniMax-H3. Diffusers main was cloned to:
+
+```text
+/mnt/cfs/9n-das-admin/llm_models/MiniMax-H3-Diffusers/code/diffusers-main
+revision 53e5b00
+```
+
+Inside the container, use it without editable installation because `/models` is read-only:
+
+```bash
+export PYTHONPATH=/models/MiniMax-H3-Diffusers/code/diffusers-main/src${PYTHONPATH:+:$PYTHONPATH}
+```
+
+Runtime dependency state inside `wty-edgedit-dev`:
+
+```text
+torch 2.7.1+cu128
+transformers 5.12.0
+accelerate 1.14.0
+torchao 0.15.0
+fbgemm-gpu-genai 1.2.0
+PyAV installed
+imageio-ffmpeg installed
+sentencepiece installed
+```
+
+Do not upgrade `torchao` blindly: `torchao 0.18.0` was incompatible with the container's PyTorch 2.7.1. `torchao==0.15.0` plus `fbgemm-gpu-genai==1.2.0` is the currently verified combination for TorchAO int4 smoke tests and the MiniMax-H3 FL2VA int4 run. `fbgemm-gpu-genai==1.8.0` was rejected because it tried to load CUDA 13 runtime (`libcudart.so.13`) on this CUDA 12.8 container.
+
+### Important comparison caveat
+
+The edge benchmark uses quantized GGUF and CFG 2 with two DiT forwards per step. Official Diffusers uses original BF16 weights and documents CFG-distilled behavior: no negative prompt or guidance scale, one model forward per step. These are not yet an apples-to-apples timing configuration. The official run is necessary to establish its own quality/timing baseline; do not claim direct speed parity until equivalent workflow parameters are analyzed.
+
+The edge H3 pipeline already has the matching fast path: `cfg_scale == 1.0f` skips unconditional context construction and the unconditional DiT call. The existing performance probe deliberately used `--cfg-scale 2`, hence its 5 steps produce 10 DiT calls. Switching to CFG 1 changes the sampling configuration/output and is not a lossless optimization of the CFG 2 baseline; measure it separately as the official distilled-model comparison configuration.
+
+Measured on the 864x480, 56-frame, 5-step FL2VA probe on one H200:
+
+```text
+CFG 2: 10 DiT calls, diffusion 25.519s
+CFG 1:  5 DiT calls, diffusion 12.798s
+```
+
+### MMQ versus forced cuBLAS experiment — rejected
+
+`GGML_CUDA_FORCE_CUBLAS=ON` was compiled and tested on the same CFG 1 probe. It made DiT much faster (`12.798s -> 8.314s` for five forwards), but it did not preserve the quantized execution's output: decoded frame comparison gave minimum PSNR `28.86dB`, average PSNR `35.15dB`, and maximum RGB difference `207`. This is a genuine deterministic difference because two default-MMQ runs produced byte-identical MP4 files and all 56 decoded frames were pixel-identical.
+
+The CMake build was restored to both `GGML_CUDA_FORCE_CUBLAS=OFF` and `GGML_CUDA_FORCE_MMQ=OFF`. Do not enable forced cuBLAS as an accepted H3 optimization without an explicit quality/compatibility decision. The likely reason is that the fallback uses a different quantized-weight conversion/accumulation path than MMQ.
+
+### Download and automatic benchmark state
+
+Writable host/CFS target:
+
+```text
+/mnt/cfs/9n-das-admin/llm_models/MiniMax-H3-Diffusers
+```
+
+Inside container the same target is `/models/MiniMax-H3-Diffusers` and is read-only.
+
+The correct Diffusers components are at repository root (`transformer/`, `text_encoder/`, `vae/`, `audio_vae/`, scheduler/tokenizer/processor), not in `FL2VA/`. `FL2VA/` is original-format deployment material and was not retained. The active download selects exactly the official Diffusers FL2VA components (61 files, about 134.16 GiB).
+
+Do not kill these two task-owned background processes; both are detached with `setsid` and resumable curl:
+
+```text
+PID stored in .../logs/download-diffusers-fl2va.pid
+script: /mnt/cfs/9n-das-admin/llm_models/MiniMax-H3-Diffusers/download_diffusers_fl2va.sh
+
+PID stored in .../logs/run-when-ready.pid
+script: /mnt/cfs/9n-das-admin/llm_models/MiniMax-H3-Diffusers/run_when_diffusers_fl2va_ready.sh
+```
+
+The watcher performs exact file-size completeness checks, waits for GPU 0 to be under 1GiB used, then runs:
+
+```bash
+docker exec wty-edgedit-dev bash -lc \
+  'cd /workspace/edge-dit.cpp && CUDA_VISIBLE_DEVICES=0 scripts/diffusers/run_minimax_h3_fl2va.sh'
+```
+
+It writes:
+
+```text
+/mnt/cfs/9n-das-admin/llm_models/MiniMax-H3-Diffusers/logs/diffusers-fl2va-benchmark.log
+/mnt/cfs/9n-das-admin/llm_models/MiniMax-H3-Diffusers/logs/diffusers-fl2va-benchmark-status.log
+outputs/minimax-h3/diffusers-fl2va-768p/final.mp4
+outputs/minimax-h3/diffusers-fl2va-768p/final.json
+```
+
+The generated Python runner records component loading, CUDA generation, mux, and end-to-end time. It uses official `ComponentsManager.enable_auto_cpu_offload(device="cuda:0")`: model execution occurs on CUDA, while components not active in the current stage reside in host memory. This is the official single-GPU recipe for this combined model size.
+
+### Diffusers TorchAO quantized comparison
+
+Artifacts and scripts added for Diffusers quantized comparison:
+
+- `scripts/diffusers/run_minimax_h3_fl2va_quantized.py`
+- `outputs/minimax-h3/diffusers-fl2va-480p124-int8-gpu3/final.mp4`
+- `outputs/minimax-h3/diffusers-fl2va-480p124-int4-gpu0/final.mp4`
+- `outputs/minimax-h3/diffusers-fl2va-480p124-int4-resident-gpu0/final.mp4`
+- `outputs/minimax-h3/compare-diffusers-fl2va-480p124-q4-cfg1-noneg-2026-08-07/final.mp4`
+
+Common benchmark configuration:
+
+```text
+Workflow: FL2VA
+Prompt: Create a smooth cinematic transition between the supplied first and last frame, preserving the subject, lighting, and composition with natural coherent motion and synchronized ambient audio.
+Negative prompt: none
+Inputs: outputs/minimax-h3/fl2va/edge/frames/first.png and outputs/minimax-h3/fl2va/edge/frames/last.png
+Resolution: 864x480
+Frames: 124 at 24 fps, duration 5.175s
+Steps: 20
+Seed: 42
+Guidance: edge uses --cfg-scale 1, giving one DiT forward per step; Diffusers MiniMax-H3 uses the official CFG-distilled one-forward path.
+```
+
+Important quantization scope caveat: neither implementation is fully 4-bit end to end. Edge uses GGUF `Q4_K_M` mixed quantization for the DiT and Qwen3VL conditioner, but the video VAE is FP16 and the audio VAE is FP32. Diffusers TorchAO int4/int8 uses weight-only quantization for the `transformer` and `text_encoder` large linear weights only; `vae`, `audio_vae`, schedulers, tokenizer, and processor are not quantized. Some transformer and text encoder modules are intentionally excluded from quantization (`proj_in`, `audio_proj_in`, time/context embeddings, output projections, norms/rope, Qwen visual tower, embeddings, and `lm_head`).
+
+MiniMax-H3 GGUF component sizes inside the container:
+
+```text
+/models/MiniMax-H3-GGUF/minimax_h3_fl2va-Q4_K_M.gguf                    18G, 18779848448 bytes
+/models/MiniMax-H3-GGUF/minimax_h3_ref2va_pruned-Q4_K_M.gguf            11G, 11420663904 bytes
+/models/MiniMax-H3-GGUF/qwen3vl_32b_minimax_h3-Q4_K_M.gguf              17G, 18218065024 bytes
+/models/MiniMax-H3-GGUF/minimax_h3_video_vae_fp16.safetensors          4.9G, 5207808496 bytes
+/models/MiniMax-H3-GGUF/minimax_h3_audio_vae_fp32.safetensors          578M, 605254808 bytes
+```
+
+Observed edge weight stats for the comparable FL2VA Q4 run:
+
+```text
+overall:          f32:930 | f16:562 | q4_0:50 | q4_K:458 | q6_K:100 | bf16:816
+conditioner:      q4_K:250 | q6_K:100 | bf16:552
+diffusion model:  f32:13 | q4_0:50 | q4_K:208 | bf16:264
+VAE:              f32:917 | f16:562
+```
+
+Measured timings:
+
+| Runner | Quantization | Residency | Generation timing | End-to-end |
+| --- | --- | --- | ---: | ---: |
+| edge.cpp | GGUF Q4_K_M mixed Q4/Q6/BF16/F32 | GPU resident | `108.619s` diffusion, `131.870s` generation | `141.249s` wall |
+| Diffusers | TorchAO int4 weight-only | GPU resident | `62.511s` `generate_cuda` | `105.194s` |
+| Diffusers | TorchAO int4 weight-only | CPU/GPU group offload | `144.141s` `generate_cuda` | `181.148s` |
+| Diffusers | TorchAO int8 weight-only | CPU/GPU group offload | `256.031s` `generate_cuda` | `271.528s` |
+
+The resident Diffusers int4 path is the closest current timing comparison to edge's GPU-resident Q4 run. It is faster for this task, but it is still not identical quantization: GGUF `Q4_K_M` and TorchAO int4 weight-only use different layouts, skipped-module sets, activation handling, kernels, and numerical behavior.
+
+File identity and quality sanity checks:
+
+```text
+edge Q4 resident:         d63a9dad18f65001674a763d89630f308a181dc5b04c9fbafbcb8dc4a11c930a
+Diffusers int8 offload:   f6cddc3d6f466a3627c83c22c2b2410558b7b582dedb2e950dea267932414d86
+Diffusers int4 offload:   78bee7947ffb0cd0ae09e660183de3a3b5f2e5f2ad73885915e7d6f5059d577f
+Diffusers int4 resident:  38eb05e9eb8b69cfe570c6ba1bf3267fd4dad4b537f3c89f9678a9312053e351
+```
+
+The edge Q4 and Diffusers int8 videos can look similar at the endpoints because FL2VA strongly constrains the first and last frames, but they are not the same file or the same generated video. Sample decoded-frame PSNR for edge Q4 versus Diffusers int8 was about `35.70dB` on the first sampled frame, `10.50dB` on the middle sampled frame, and `35.95dB` on the last sampled frame.
+
+Dependency notes for reproducing Diffusers int4:
+
+```bash
+docker exec wty-edgedit-dev bash -lc \
+  'python3 -m pip install --user --no-cache-dir -i https://pypi.tuna.tsinghua.edu.cn/simple torchao==0.15.0 fbgemm-gpu-genai==1.2.0'
+```
+
+`fbgemm-gpu-genai==1.8.0` should not be used on this container because it requires CUDA 13 runtime. The verified int4 smoke test is a CUDA BF16 `torch.nn.Linear` quantized with `Int4WeightOnlyConfig(group_size=128)`.
+
+To inspect progress safely:
+
+```bash
+ROOT=/mnt/cfs/9n-das-admin/llm_models/MiniMax-H3-Diffusers
+cat "$ROOT/logs/diffusers-fl2va-benchmark-status.log"
+tail -100 "$ROOT/logs/diffusers-fl2va-benchmark.log"
+ps -p "$(cat "$ROOT/logs/download-diffusers-fl2va.pid")" -o pid,stat,etimes,cmd
+```
+
+## Suggested continuation order
+
+1. Let the official download and watcher complete; inspect the automatic Diffusers benchmark output/logs.
+2. Verify official run success, MP4 streams, video dimensions/frame count, audio, and JSON phase times.
+3. Make a documented comparison: original BF16 Distilled Diffusers vs Q4_K edge-dit. Separate model-format/config differences from framework overhead.
+4. If optimizing edge H3 further, profile a stable repeated baseline first, then target layout/materialization with a strict output-quality gate.
+5. Consider MMQ specialization only after the above: it is the principal bottleneck and requires SM90/H3-shape-specific kernel work plus robust correctness testing.
+
+## 2026-08-07 DiT performance follow-up
+
+Strict timing clarification for the 864x480, 124-frame, steps=20, seed=42 FL2VA keyframe benchmark:
+
+- Diffusers TorchAO int4 resident with transformer forward hooks measured `generate_cuda=62.748s`, `transformer_forward_cuda=56.724s`, `transformer_forward_calls=19`.
+- Edge before scheduler alignment had `diffusion=110.552s`, `diffusion_calls=20` in the profiled run, so `108.6s vs 62.5s` was not DiT-only vs DiT-only and edge also ran one extra transformer call.
+- MiniMax-H3 official scheduler treats `num_inference_steps` as sigma grid points including the terminal clean point. Therefore `steps=20` runs 19 model evaluations.
+- Edge was fixed to loop while `step + 1 < steps`, matching Diffusers. Correct FL2VA keyframe run now reports `diffusion=103.062s`, `diffusion_calls=19`, total generation `125.974s`.
+- The per-forward gap remains large: edge is about `5.42s/forward`; Diffusers transformer-only is about `2.99s/forward`.
+
+Validation artifacts:
+
+- Diffusers transformer-only profile: `outputs/minimax-h3/diffusers-fl2va-480p124-int4-resident-profile3-gpu0/final.json`
+- Edge corrected full run: `outputs/minimax-h3/perf-fl2va-keyframes-480p124-cfg1-steps20-scheduler19-2026-08-07/run.log`
+- Edge 56-frame smoke baseline: `outputs/minimax-h3/perf-fl2va-keyframes-480p56-cfg1-steps5-default-mmq-2026-08-07/run.log`
+
+Experiments rejected or left off by default:
+
+- `GGML_CUDA_FORCE_MMQ=ON`, which permits larger MMQ tiles on SM90, did not improve the 56-frame/5-step smoke case: `diffusion=10.308s` vs default `10.321s` for four calls, within noise.
+- H3 compiled-graph reuse was prototyped behind `ED_MINIMAX_H3_REUSE_GRAPHS=1` and left disabled by default. The current small benchmark showed no measurable DiT improvement (`10.360s` for four calls). Do not enable it by default without further investigation.
+- The previous `ED_CUDA_DISABLE_MMQ_STREAM_K` experiment was reverted; stream-k disabling was much slower.
+
+Current bottleneck after the scheduler alignment is still GGML Q4_K MMQ for H3's large projection shapes. Diffusers TorchAO/fbgemm int4 resident is likely using a Hopper-friendlier weight-only int4 layout/kernel. A real next performance step requires either a better SM90 Q4_K kernel/layout, or an optional prepacked resident int4/fp16-weight path for H3's DiT projections. Layout/materialization remains a secondary target, but it cannot close the main 5.42s vs 2.99s per-forward gap alone.
+
+## 2026-08-07 SM90 Q4_K DiT optimization
+
+The first practical DiT speedup came from revisiting the cuBLAS fallback instead of treating GGML MMQ as always best on Hopper.
+
+Change made:
+
+- `third_party/ggml/src/ggml-cuda/mmq.cu` now sends NVIDIA SM90+ `Q4_K` matrix multiplications with `ne11 >= 512` through the existing dequantize + cuBLAS path instead of MMQ.
+- Small-column `Q4_K` calls still use MMQ, preserving the fast small-batch path used by text/auxiliary projections.
+- The rule is disabled by compiling with `GGML_CUDA_FORCE_MMQ`; it can also be disabled at runtime with `GGML_CUDA_SM90_Q4K_CUBLAS=0`.
+
+Measured impact on the H200 FL2VA benchmark (`864x480`, `124` frames, `24fps`, `steps=20`, `cfg=1`, seed `42`, one DiT forward per scheduler step):
+
+| Build | Total generation | DiT diffusion | DiT calls | Decode | Artifact |
+| --- | ---: | ---: | ---: | ---: | --- |
+| Baseline scheduler-aligned edge | `125.974s` | `103.062s` | `19` | `21.573s` | `outputs/minimax-h3/perf-fl2va-keyframes-480p124-cfg1-steps20-scheduler19-2026-08-07/run.log` |
+| SM90 Q4_K cuBLAS rule | `92.378s` | `67.220s` | `19` | `23.586s` | `outputs/minimax-h3/perf-dit-sm90-q4-cublas-480p124-cfg1-steps20-2026-08-07/run.log` |
+
+The DiT part improved by about `34.8%` (`103.062s -> 67.220s`). This moves edge much closer to the Diffusers TorchAO int4 resident reference (`transformer_forward_cuda=56.724s`, `19` calls), though Diffusers is still faster.
+
+Small validation task (`864x480`, `56` frames, `steps=5`, effective `4` DiT calls):
+
+| Build | Total generation | DiT diffusion | Artifact |
+| --- | ---: | ---: | --- |
+| Baseline MMQ | `20.912s` | `10.845s` | `outputs/minimax-h3/perf-dit-default-56f5s-2026-08-07/run.log` |
+| SM90 Q4_K cuBLAS rule | `16.926s` | `7.239s` | `outputs/minimax-h3/perf-dit-sm90-q4-cublas-56f5s-2026-08-07/run.log` |
+
+Kernel-path evidence from the 56-frame run:
+
+- Baseline large H3 projections used `path=mmq` for `Q4_K` shapes such as `m=28672 n=7919 k=5376`, totaling about `2.559s` across the profiled calls for that shape.
+- Optimized run used `path=op_cublas` for the same large shapes, totaling about `1.242s` for `m=28672 n=7919 k=5376`.
+- Small `n=38` `Q4_K` calls remained on `path=mmq` in the 124-frame run, confirming the threshold did not force every quantized GEMM through cuBLAS.
+
+Quality/numerics note:
+
+- This is not bit-identical to MMQ. The cuBLAS route dequantizes and accumulates through a different path, so diffusion can diverge slightly even with the same seed.
+- On the first eight decoded frames of the 56-frame smoke output, baseline-vs-optimized frame PSNR was roughly `44.3dB` on frame 1 and `33.5-40.7dB` on frames 2-8. The output remains visually close in this smoke check, but quality should be spot-checked on representative prompts before release.
+- The change is framework-level for SM90+ large `Q4_K` GEMMs, not MiniMax-H3-specific. It may also benefit other large-Q4_K video DiTs on H100/H200, but it should be validated per model because numerical differences are possible.
+
+Next bottlenecks after this change:
+
+1. Diffusion still trails Diffusers int4 resident by about `10.5s` transformer time on the 124-frame benchmark (`67.2s` vs `56.7s`). TorchAO/fbgemm likely benefits from a prepacked TensorCoreTiled int4 layout, while GGUF `Q4_K` still pays dequantization/materialization costs in the cuBLAS path.
+2. Layout/materialization remains around the next largest category in the old profile. Re-run `ED_PROFILE_CUDA_OPS=1` with the new rule and target the top layout nodes next.
+3. A true longer-term fix is an SM90-native prepacked int4/Q4_K GEMM kernel or conversion path for resident H3 projections, with strict image/video quality gates.
+
+## 2026-08-07 MLP SwiGLU materialization optimization
+
+After the SM90 Q4_K cuBLAS rule, the next DiT profile showed layout/materialization as the second-largest category. In the 56-frame/5-step DiT-only graph subset:
+
+```text
+GEMM        2.873s
+LAYOUT      1.771s
+ELEMENTWISE 0.927s
+FLASH_ATTN  0.831s
+```
+
+The top layout nodes were `CONT` materializations of the two strided halves of the MLP `fc1` output:
+
+```text
+CONT [14336,7919] from chunk/view: ~0.478s over 4 DiT calls
+CONT [7168,7919]  from chunk/view: ~0.362s over 4 DiT calls
+```
+
+Change made:
+
+- `src/dit_models/models/minimax_h3_full.hpp` now uses `ggml_swiglu(ctx, fc1(x))` for H3 MLP instead of `chunk(fc1(x), 2) -> silu(first) * second`.
+- This reuses ggml's existing CUDA `SWIGLU` unary-gated kernel and removes the largest `[14336, seq]` materialization path.
+- Semantics match the previous expression because `ggml_swiglu` treats the first half as the activated value and the second half as the gate, which is exactly `silu(uv[0]) * uv[1]`.
+
+Measured impact on the same H200 FL2VA benchmark:
+
+| Build | Total generation | DiT diffusion | DiT calls | Artifact |
+| --- | ---: | ---: | ---: | --- |
+| SM90 Q4_K cuBLAS rule | `92.378s` | `67.220s` | `19` | `outputs/minimax-h3/perf-dit-sm90-q4-cublas-480p124-cfg1-steps20-2026-08-07/run.log` |
+| SM90 Q4_K cuBLAS + MLP SwiGLU | `86.592s` | `62.061s` | `19` | `outputs/minimax-h3/perf-dit-sm90-q4-cublas-swiglu-480p124-cfg1-steps20-2026-08-07/run.log` |
+
+This second step improves DiT by another `7.7%` (`67.220s -> 62.061s`). Combined with scheduler alignment and SM90 Q4_K cuBLAS, edge's comparable 124-frame DiT time moved from `103.062s` to `62.061s`, now close to Diffusers TorchAO int4 resident transformer-only time (`56.724s`).
+
+56-frame op-profile validation:
+
+| Build | DiT diffusion | DiT layout category | Artifact |
+| --- | ---: | ---: | --- |
+| SM90 Q4_K cuBLAS rule | `7.276s` | `1.771s` | `outputs/minimax-h3/perf-dit-sm90-q4-cublas-opprofile-56f5s-2026-08-07/run.log` |
+| + MLP SwiGLU | `6.730s` | `1.311s` | `outputs/minimax-h3/perf-dit-sm90-q4-cublas-swiglu-56f5s-2026-08-07/run.log` |
+
+Remaining DiT gap vs Diffusers:
+
+- Diffusers TorchAO/fbgemm int4 resident still has the better int4 GEMM layout: `TensorCoreTiledLayout(inner_k_tiles=8)` + TinyGEMM, packed as `[n/8, k/(inner_k_tiles*16), 32, inner_k_tiles/2]`, called through `aten._weight_int4pack_mm`.
+- Edge still uses GGUF `Q4_K` weights. On SM90 the large projections now dequantize and use cuBLAS, which is faster than GGML MMQ for H3's large-column shapes, but still not as specialized as a resident prepacked int4 Tensor Core layout.
+- Remaining layout hotspots are mostly attention layout/rope materialization (`[96,56,seq]`, `[128,seq,56]`, `[32,seq,56]`) and the second MLP half materialization (`[7168,seq]`). A larger next step would be an H3-specific fused QKV/RoPE/attention pack path, similar in spirit to the existing MMDiT attention pair-pack helpers.
+
+### 2026-08-07 DiT layout optimization checkpoints and quality guardrails
+
+Current H3 DiT optimization changes are intentionally split into independently-disableable checkpoints so any quality regression can be bisected quickly:
+
+| # | Area | Code path | Default | Disable switch | Quality risk |
+|---|---|---|---|---|---|
+| 1 | SM90 large `Q4_K` GEMM routing | GGML CUDA `Q4_K` uses dequantize + cuBLAS for large H3 matrices instead of MMQ | Off; experimental opt-in | enable with `GGML_CUDA_SM90_Q4K_CUBLAS=1` | High: caused all-black 124-frame H3 output on the FL2VA quality probe |
+| 2 | H3 MLP SwiGLU materialization | `fc2(ggml_swiglu(fc1(x)))` instead of chunk + silu + mul | On | `ED_MINIMAX_H3_DISABLE_SWIGLU_FUSION=1` | Low/medium: same formula, but fused kernel/order can differ slightly |
+| 3 | H3 QKV split materialization | Q/K/V are `ggml_view_4d` views into `qkv_proj` output instead of three `ggml_cont` chunks | On | `ED_MINIMAX_H3_DISABLE_QKV_VIEW=1` | Low: layout-only view rewrite, intended mathematically identical |
+| 4 | H3 partial-RoPE slice materialization | RoPE rotated prefix and unrotated tail use non-contiguous views instead of eager slice copies | On | `ED_MINIMAX_H3_DISABLE_ROPE_SLICE_VIEW=1` | Low: layout-only view rewrite; custom RoPE kernel reads strides |
+| 5 | H3 modulation/segment materialization | segment/modulation slices and chunks use views instead of eager copies | On | `ED_MINIMAX_H3_DISABLE_SEGMENT_VIEW=1` | Low: layout-only view rewrite |
+| 6 | H3 MLP Tensor Core experiment | allow MLP `fc1/fc2` to avoid `force_prec_f32` and use fp16 Tensor Core cuBLAS | Off | enable with `ED_MINIMAX_H3_MLP_FP16_CUBLAS=1` | High/experimental: faster but PSNR smoke checks dropped to `36-37dB` |
+
+Performance checkpoints on the 56-frame / 5-step FL2VA smoke case (`864x480`, `cfg=1`, `steps=5`, 4 actual DiT calls):
+
+| Checkpoint | Diffusion time | DiT graph layout time | Notes |
+|---|---:|---:|---|
+| SM90 cuBLAS + SwiGLU baseline | `6.730s` | `1.311s` total previously; DiT graph layout around `330ms`/call group in older op profile | Before H3-specific view rewrites |
+| + QKV view | `6.017s` unprofiled / `6.402s` profiled | `236.151ms` | Removes the former `~91ms` qkv chunk copy group |
+| + RoPE slice view | `6.184s` profiled | `175.416ms` | Removes `~46ms` rotated-prefix slice copy group |
+| + Segment view | `5.777s` profiled | `128.197ms` | Removes many small segment/modulation copies and elementwise materializations |
+| Current default with bisection switches | `5.821s` unprofiled | Not re-profiled in this run | Build after adding switches; profile-free timing is comparable to `+ Segment view` |
+
+Quality guardrails:
+
+- The low-risk view rewrites should preserve mathematical values, but CUDA graph execution and video/audio encode paths are not bit-exact across repeated runs; do not rely on byte equality.
+- A quick PSNR check between `+ Segment view` and the current default rerun produced `average=39.775dB`, `min=33.590dB`, `max=50.368dB` for 56 frames, so this smoke check did not show a catastrophic visual drift, but it is not a substitute for visual inspection.
+- If a quality regression appears, first ensure `GGML_CUDA_SM90_Q4K_CUBLAS` is not set to `1`, then try `ED_MINIMAX_H3_DISABLE_SWIGLU_FUSION=1`, then the three low-risk view switches one by one.
+- For release-quality validation, run at least one 124-frame task against the pre-optimization baseline and Diffusers/TorchAO with the same prompt, seed, frames, scheduler semantics, `cfg=1`, VAE tiling off, and one DiT forward per scheduler step.
+
+### 2026-08-07 Q4_K GEMM and attention follow-up
+
+Internal profiling of the rejected SM90-cuBLAS path showed the post-layout bottleneck was no longer GGML MMQ. For the 56-frame / 5-step FL2VA smoke case, that experimental DiT graph time was dominated by cuBLAS-backed large `Q4_K` GEMMs plus cuDNN SDPA:
+
+| Run | Diffusion | DiT graph GEMM | DiT graph attention | DiT graph layout | Artifact |
+|---|---:|---:|---:|---:|---|
+| Current default + internal profile | `5.825s` | `793.597ms` | `394.973ms` | `127.410ms` | `outputs/minimax-h3/perf-dit-current-internal-56f5s-2026-08-07/run.log` |
+| MLP Tensor Core opt-in | `5.184s` | `638.170ms` | `407.586ms` | `122.620ms` | `outputs/minimax-h3/perf-dit-mlp-fp16-cublas-56f5s-2026-08-07/run.log` |
+| MLP Tensor Core + forced f32 dst | `4.859s` | large `Q4_K` GEMMs down to `191.689/145.587/109.936/56.921ms` groups | not separately op-profiled | not separately op-profiled | `outputs/minimax-h3/perf-dit-mlp-fp16-cublas-f32dst-56f5s-2026-08-07/run.log` |
+
+Key finding for the rejected experimental path:
+
+- The old statement "Q4_K MMQ is the main bottleneck" was outdated only while the SM90 routing experiment was enabled. Because that path caused black 124-frame output, current quality-safe default is back to MMQ for large `Q4_K`; MMQ is again the principal safe-path DiT bottleneck.
+- The largest MLP matrices were intentionally constructed with `force_prec_f32=true`, so even with quantized weights they take the f32 SGEMM branch. Internal profile examples: `m=28672,n=7919,k=5376` spent `297.116ms` in `f32/sgemm`, and `m=5376,n=7919,k=14336` spent `146.245ms` in `f32/sgemm` over 50 calls.
+- Enabling the experimental `ED_MINIMAX_H3_MLP_FP16_CUBLAS=1` switches those MLP projections to fp16 Tensor Core cuBLAS. It improves smoke diffusion from `5.825s` to `5.184s`, but PSNR vs current default is only `average=37.029dB`, `min=30.218dB`; with `GGML_CUDA_FORCE_CUBLAS_COMPUTE_32F=1`, speed improves further to `4.859s`, but PSNR drops to `average=36.214dB`, `min=30.106dB`.
+- Because of that quality risk, `ED_MINIMAX_H3_MLP_FP16_CUBLAS=1` remains opt-in and should not be enabled by default without visual/full-length validation against Diffusers and the previous edge baseline.
+
+Attention finding:
+
+| Run | Diffusion | DiT graph attention | Artifact |
+|---|---:|---:|---|
+| cuDNN SDPA enabled | `5.783s` | `395.983ms` | `outputs/minimax-h3/perf-dit-attn-default-56f5s-2026-08-07/run.log` |
+| cuDNN SDPA disabled | `10.922s` | `1442.747ms` | `outputs/minimax-h3/perf-dit-attn-nocudnn-56f5s-2026-08-07/run.log` |
+
+- H3 is already using the cuDNN SDPA path for long attention. Disabling it roughly doubles diffusion time on the smoke case, so keeping cuDNN SDPA enabled is mandatory for H200/Hopper performance.
+- The remaining attention-adjacent layout hotspot is mostly output layout materialization before `out_proj` (`CONT [128,7919,56,1]`, about `30-33ms` per profiled DiT graph group). Removing it safely likely needs a fused attention-output-projection layout or an out-projection matmul variant that consumes the attention output layout directly.
+
+TorchAO/fbgemm comparison update:
+
+- Diffusers TorchAO `Int4WeightOnlyConfig` keeps weights in a resident Tensor Core tiled layout and calls `aten._weight_int4pack_mm`; edge GGUF `Q4_K` remains a GGUF block layout and must either use MMQ or dequantize/convert into cuBLAS-compatible fp16/f32 buffers.
+- The current fastest edge opt-in path still pays `src0_to_f16`, `src1_to_f16`, and sometimes `dst_to_f32`, while TorchAO/fbgemm avoids repeated GGUF block unpacking by construction. Matching that class of performance likely requires a resident prepacked H3 weight layout or a dedicated Q4_K Tensor Core kernel, not just more graph-level layout cleanup.
+
+### 2026-08-07 124-frame full baseline after view optimizations
+
+A full 124-frame FL2VA run was executed after the low-risk view optimizations, with MLP Tensor Core experiment **disabled**. This run used the now-rejected SM90 large-`Q4_K` cuBLAS route and produced an all-black MP4, so the timing is **not quality-valid**:
+
+| Framework/path | End-to-end / total | DiT / transformer | Calls | Notes | Artifact |
+|---|---:|---:|---:|---|---|
+| Edge rejected SM90 cuBLAS default | `79.780s` profiled total, `87.878s` wall | `54.912s` | `19` | all-black output; invalid quality benchmark | `outputs/minimax-h3/perf-dit-current-default-480p124-cfg1-steps20-2026-08-07/run.log` |
+| Edge previous SM90 cuBLAS + SwiGLU | `86.592s` total | `62.061s` | `19` | all-black output; invalid quality benchmark | `outputs/minimax-h3/perf-dit-sm90-q4-cublas-swiglu-480p124-cfg1-steps20-2026-08-07/run.log` |
+| Diffusers TorchAO int4 resident | `104.725s` end-to-end, `62.748s` generation CUDA | `56.724s` | `19` | TorchAO 4-bit transformer + text encoder, VAE/audio VAE not quantized | `outputs/minimax-h3/diffusers-fl2va-480p124-int4-resident-profile3-gpu0/final.json` |
+
+The rejected SM90-cuBLAS edge DiT timing (`54.912s`) must not be compared as a valid result against Diffusers because the output is black. The comparison remains useful only as a performance diagnostic:
+
+- Diffusers timing is official PyTorch/TorchAO path with different kernel/layout/numerics and includes its own surrounding scheduler/pipeline behavior.
+- Edge output MP4 in this run is not valid for visual quality because decoded sample frames had mean/std `0/0`.
+- The remaining performance work should focus on either preserving quality while reducing MLP cuBLAS precision overhead, or implementing a resident prepacked int4/Q4 layout to avoid repeated GGUF block conversion. The fp16 MLP Tensor Core experiment is fast but currently too risky for default quality.
+
+### 2026-08-07 MLP Tensor Core quality check on real-world FL2VA inputs
+
+The 124-frame FL2VA keyframe benchmark was visually uninformative: decoded frames were identical and near-static, so it could not validate MLP Tensor Core quality. A second 56-frame FL2VA check used high-variance real-world frames from `outputs/minimax-h3/ref2va-realworld-full-benchmark-2026-08-07/inputs/video-frames/001.png` and `056.png`.
+
+| Path | Diffusion | Total | Artifact |
+|---|---:|---:|---|
+| Current default | `5.832s` | `14.499s` | `outputs/minimax-h3/perf-quality-fl2va-realworld-current-vs-mlp-56f5s-2026-08-07/current/final.mp4` |
+| `ED_MINIMAX_H3_MLP_FP16_CUBLAS=1` | `5.226s` | `14.040s` | `outputs/minimax-h3/perf-quality-fl2va-realworld-current-vs-mlp-56f5s-2026-08-07/mlp/final.mp4` |
+
+Quality metric: `ffmpeg` PSNR current-vs-MLP is `average=11.195dB`, `min=10.582dB`, `max=12.735dB`, with visual contact sheet at `outputs/minimax-h3/perf-quality-fl2va-realworld-current-vs-mlp-56f5s-2026-08-07/summary/contact_current_vs_mlp.jpg`.
+
+Conclusion: keep `ED_MINIMAX_H3_MLP_FP16_CUBLAS=1` strictly opt-in. It is a useful performance experiment, but it changes generation materially on realistic inputs and should not be enabled by default.
+
+### 2026-08-07 black-frame regression fix
+
+The user-reported all-black output was reproduced on the 124-frame FL2VA keyframe task. The root cause was the experimental SM90 large-`Q4_K` cuBLAS routing being enabled by default.
+
+Repro and bisection artifacts:
+
+| Path | MP4 size | Sample frame brightness | Artifact |
+|---|---:|---:|---|
+| Rejected default with SM90 cuBLAS | `90,514` bytes | all sampled frames mean/std `0.0/0.0` | `outputs/minimax-h3/black-regression-124-bisect-2026-08-07/default/final.mp4` |
+| Same build with `GGML_CUDA_SM90_Q4K_CUBLAS=0` | `4,199,541` bytes | means `115.12`, `119.23`, `135.72`, `154.29`, `166.02`; std around `52-55` | `outputs/minimax-h3/black-regression-124-bisect-2026-08-07/no_sm90_cublas/final.mp4` |
+| Fixed current default after making SM90 cuBLAS opt-in | `4,199,541` bytes | same non-black sample stats as the disabled run | `outputs/minimax-h3/quality-fix-sm90-q4k-default-mmq-124f-2026-08-07/final.mp4` |
+
+Current code status:
+
+- `third_party/ggml/src/ggml-cuda/mmq.cu` keeps MMQ as the default for SM90 `Q4_K`; the cuBLAS route now requires explicit `GGML_CUDA_SM90_Q4K_CUBLAS=1`.
+- The opt-in path is retained only for future diagnosis/performance work and must not be used for quality or benchmark claims until the black-frame cause is fixed.
+- Contact sheet for the fixed default: `outputs/minimax-h3/quality-fix-sm90-q4k-default-mmq-124f-2026-08-07/contact_sheet.jpg`.
+
+### 2026-08-07 safe SM90 Q4_K cuBLAS partial re-enable
+
+The all-or-nothing SM90 `Q4_K` cuBLAS route was too broad: it made the 124-frame FL2VA output black. A shape bisection showed the long-sequence H3 `fc2` projection is the unsafe part, while the long-sequence QKV and `fc1` projections remain visually non-black on the same probe.
+
+Current switch behavior:
+
+- `GGML_CUDA_SM90_Q4K_CUBLAS=1` enables only the validated H3 shapes: mid-sequence `n=7919` QKV/FC1 shapes plus long-sequence `n>=16000` QKV and FC1 shapes.
+- Long-sequence FC2 (`m=5376`, `k=14336` or `7168`, `n>=16000`) remains on MMQ by default because it reproduced the all-black output.
+- `GGML_CUDA_SM90_Q4K_CUBLAS_LONG_FC2=1` exists only as an explicit unsafe diagnostic switch; do not use it for quality benchmarks or user-facing runs.
+
+124-frame, 5-step FL2VA quality/speed bisection (`864x480`, `cfg=1`, seed `42`, 4 DiT calls):
+
+| Variant | Diffusion | Output | Artifact |
+|---|---:|---|---|
+| MMQ quality-safe baseline | `21.799s` | non-black | `outputs/minimax-h3/quality-speed-q4k-long-shape-bisect-124f5s-2026-08-07/mid_only/final.mp4` |
+| Long QKV only | `19.069s` | non-black | `outputs/minimax-h3/quality-speed-q4k-long-shape-bisect-124f5s-2026-08-07/long_qkv/final.mp4` |
+| Long FC1 only | `19.444s` | non-black | `outputs/minimax-h3/quality-speed-q4k-long-shape-bisect-124f5s-2026-08-07/long_fc1/final.mp4` |
+| Long FC2 only | `19.019s` | all-black | `outputs/minimax-h3/quality-speed-q4k-long-shape-bisect-124f5s-2026-08-07/long_fc2/final.mp4` |
+| Safe QKV+FC1 | `16.893s` | non-black | `outputs/minimax-h3/quality-speed-q4k-safe-default-124f5s-2026-08-07/final.mp4` |
+
+The safe partial route recovers most of the speedup without reproducing black frames on this probe: `21.799s -> 16.893s` diffusion, about `22.5%` faster for the 124-frame/5-step task. The fixed contact sheet is at `outputs/minimax-h3/quality-speed-q4k-safe-default-124f5s-2026-08-07/contact_sheet.jpg`.
+
+Important quality caveat: this is a non-black and visually sane validation, not a proof of exact equivalence. Before making this path a default user-facing optimization, run the full 20-step task and compare against the MMQ baseline and Diffusers with the same seed/prompt/input.
+
+### 2026-08-07 FC2 cuBLAS quality fix
+
+FC2 meaning: in MiniMax-H3 each Transformer MLP uses `fc1 -> SwiGLU -> fc2`. `fc1` expands hidden features from `5376` to the gated FFN width (`28672`, two `14336` halves), and `fc2` projects the SwiGLU result back from FFN width to hidden size (`5376`). It is a major DiT GEMM hotspot.
+
+Root cause of the FC2 black-frame regression:
+
+- Routing long-sequence H3 FC2 `Q4_K` weights through cuBLAS with the default Hopper fp16 accumulation/output path caused all-black 124-frame output.
+- Running the same FC2 cuBLAS route with `GGML_CUDA_FORCE_CUBLAS_COMPUTE_32F=1` fixed the black output, proving the problem is the fp16 cuBLAS compute/output mode for this FC2 shape, not cuBLAS routing in general.
+- The code now forces f32 cuBLAS compute/destination only for the H3 SM90 long-sequence FC2 shape when `GGML_CUDA_SM90_Q4K_CUBLAS=1` is enabled. This keeps the QKV/FC1 fast path and makes FC2 usable without requiring the global `GGML_CUDA_FORCE_CUBLAS_COMPUTE_32F` environment variable.
+
+Current switch behavior after the fix:
+
+- `GGML_CUDA_SM90_Q4K_CUBLAS=1` enables validated H3 QKV, FC1, and FC2 `Q4_K` cuBLAS routes on SM90/Hopper.
+- Long FC2 automatically uses f32 cuBLAS compute/output to preserve quality.
+- `GGML_CUDA_SM90_Q4K_CUBLAS_DISABLE_LONG_FC2=1` disables only the long FC2 cuBLAS route for rollback/bisection.
+
+124-frame, 5-step FL2VA timing summary (`864x480`, `cfg=1`, seed `42`, 4 DiT calls):
+
+| Variant | Diffusion | Output | Artifact |
+|---|---:|---|---|
+| MMQ quality-safe baseline | `21.799s` | non-black | `outputs/minimax-h3/quality-speed-q4k-long-shape-bisect-124f5s-2026-08-07/mid_only/final.mp4` |
+| Safe QKV+FC1, FC2 on MMQ | `16.893s` | non-black | `outputs/minimax-h3/quality-speed-q4k-safe-default-124f5s-2026-08-07/final.mp4` |
+| QKV+FC1+FC2 with global f32 cuBLAS compute | `13.848s` | non-black | `outputs/minimax-h3/quality-speed-q4k-long-fc2-f32compute-124f5s-2026-08-07/final.mp4` |
+| QKV+FC1+FC2 with code-level FC2 f32 fix | `13.185s` to `15.095s` observed | non-black | `outputs/minimax-h3/quality-speed-q4k-fc2-f32fix-124f5s-2026-08-07/final.mp4`, `outputs/minimax-h3/quality-speed-q4k-fc2-default-f32fix-124f5s-2026-08-07/final.mp4` |
+
+Net effect: compared with the MMQ baseline, using FC2 after the f32 compute fix improves this short 124-frame DiT probe by roughly `31-40%` (`21.799s -> 15.095s` best conservative repeat, or `13.185s` in the faster repeat) while avoiding the previous all-black failure.
+
+Quality caveat: current validation proves the FC2 path no longer collapses to black on the 124-frame/5-step probe. It still needs a full 20-step visual/metric comparison before treating it as release-quality default.
+
+### 2026-08-07 full 20-step FC2 f32-fix validation
+
+A full 124-frame, 20-step FL2VA task was rerun with the current FC2 f32 cuBLAS fix enabled through `GGML_CUDA_SM90_Q4K_CUBLAS=1`.
+
+Configuration:
+
+- `--video-frames 124`, `--steps 20`, `--cfg-scale 1`, `--seed 42`
+- `864x480`, `24fps`, VAE tiling off, `--diffusion-fa`
+- First/end frame FL2VA prompt: `Create a smooth cinematic transition between the supplied first and last frame, preserving the subject, lighting, and composition with natural coherent motion and synchronized ambient audio.`
+
+Result:
+
+| Metric | Value |
+|---|---:|
+| Total generation | `85.129s` |
+| DiT diffusion | `62.367s` |
+| DiT calls | `19` |
+| Decode | `21.451s` |
+| Wall time | `94.077s` |
+
+Quality sanity check:
+
+- Output MP4: `outputs/minimax-h3/quality-speed-q4k-fc2-f32fix-124f20s-2026-08-07/final.mp4`
+- Contact sheet: `outputs/minimax-h3/quality-speed-q4k-fc2-f32fix-124f20s-2026-08-07/contact_sheet.jpg`
+- Sampled frame means: `116.31`, `115.57`, `134.97`, `155.41`, `166.60`
+- Sampled frame stddevs: `54.66`, `56.61`, `55.93`, `57.80`, `52.85`
+
+Conclusion: the full 20-step run is not black and visually sane on the contact sheet. The FC2 f32 cuBLAS fix keeps the long-sequence FC2 speed path usable for this probe. A broader quality comparison against MMQ baseline and Diffusers is still needed before treating this as final release-quality parity.
diff --git a/scripts/diffusers/run_minimax_h3_fl2va.py b/scripts/diffusers/run_minimax_h3_fl2va.py
new file mode 100755
index 0000000..736d95b
--- /dev/null
+++ b/scripts/diffusers/run_minimax_h3_fl2va.py
@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""Run the official Diffusers MiniMax-H3 FL2VA pipeline on one CUDA GPU."""
+
+import argparse
+import json
+import time
+from pathlib import Path
+
+import torch
+from diffusers import ComponentsManager, ModularPipeline
+from diffusers.utils import load_image
+from diffusers.utils.export_utils import encode_video
+
+
+DEFAULT_PROMPT = (
+    "Create a smooth cinematic transition between the supplied first and last frame, "
+    "preserving the subject, lighting, and composition with natural coherent motion "
+    "and synchronized ambient audio."
+)
+
+
+def sync_time() -> float:
+    torch.cuda.synchronize()
+    return time.perf_counter()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model", type=Path, required=True)
+    parser.add_argument("--image", type=Path, required=True)
+    parser.add_argument("--last-image", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--prompt", default=DEFAULT_PROMPT)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--height", type=int, default=768)
+    parser.add_argument("--width", type=int, default=1376)
+    parser.add_argument("--num-frames", type=int, default=124)
+    parser.add_argument("--steps", type=int, default=20)
+    parser.add_argument("--device", default="cuda:0")
+    arguments = parser.parse_args()
+
+    if not torch.cuda.is_available():
+        raise RuntimeError("MiniMax-H3 Diffusers benchmark requires CUDA")
+    if arguments.height % 32 or arguments.width % 32:
+        raise ValueError("height and width must be divisible by 32")
+
+    arguments.output.parent.mkdir(parents=True, exist_ok=True)
+    manager = ComponentsManager()
+    manager.enable_auto_cpu_offload(device=arguments.device)
+
+    started = time.perf_counter()
+    pipeline = ModularPipeline.from_pretrained(
+        arguments.model,
+        workflow="fl2va",
+        components_manager=manager,
+        local_files_only=True,
+    )
+    pipeline.load_components(
+        dtype=torch.bfloat16,
+        pretrained_model_name_or_path=str(arguments.model),
+        local_files_only=True,
+    )
+    loaded = time.perf_counter()
+
+    first_image = load_image(str(arguments.image))
+    last_image = load_image(str(arguments.last_image))
+    generator = torch.Generator(device="cpu").manual_seed(arguments.seed)
+
+    sync_time()
+    generated = pipeline(
+        prompt=arguments.prompt,
+        image=first_image,
+        last_image=last_image,
+        height=arguments.height,
+        width=arguments.width,
+        num_frames=arguments.num_frames,
+        num_inference_steps=arguments.steps,
+        generator=generator,
+        output=["videos", "audio", "sampling_rate"],
+    )
+    generated_at = sync_time()
+
+    encode_video(
+        generated["videos"][0],
+        fps=24,
+        output_path=str(arguments.output),
+        audio=generated["audio"][0],
+        audio_sample_rate=generated["sampling_rate"],
+    )
+    finished = time.perf_counter()
+
+    results = {
+        "framework": "diffusers-main",
+        "workflow": "fl2va",
+        "model": str(arguments.model),
+        "device": arguments.device,
+        "dtype": "bfloat16",
+        "offload": "official ComponentsManager auto_cpu_offload",
+        "prompt": arguments.prompt,
+        "seed": arguments.seed,
+        "height": arguments.height,
+        "width": arguments.width,
+        "requested_num_frames": arguments.num_frames,
+        "num_inference_steps": arguments.steps,
+        "output": str(arguments.output),
+        "seconds": {
+            "component_load": loaded - started,
+            "generate_cuda": generated_at - loaded,
+            "mux": finished - generated_at,
+            "end_to_end": finished - started,
+        },
+    }
+    result_path = arguments.output.with_suffix(".json")
+    result_path.write_text(json.dumps(results, ensure_ascii=False, indent=2) + "\n")
+    print(json.dumps(results, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/diffusers/run_minimax_h3_fl2va.sh b/scripts/diffusers/run_minimax_h3_fl2va.sh
new file mode 100755
index 0000000..c45afe2
--- /dev/null
+++ b/scripts/diffusers/run_minimax_h3_fl2va.sh
@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT=/workspace/edge-dit.cpp
+MODEL=/models/MiniMax-H3-Diffusers
+OUTPUT=${1:-$ROOT/outputs/minimax-h3/diffusers-fl2va-768p/final.mp4}
+
+export CUDA_VISIBLE_DEVICES=${CUDA_VISIBLE_DEVICES:-0}
+export PYTHONPATH=/models/MiniMax-H3-Diffusers/code/diffusers-main/src${PYTHONPATH:+:$PYTHONPATH}
+
+python3 "$ROOT/scripts/diffusers/run_minimax_h3_fl2va.py" \
+  --model "$MODEL" \
+  --image "$ROOT/outputs/minimax-h3/fl2va/edge/frames/first.png" \
+  --last-image "$ROOT/outputs/minimax-h3/fl2va/edge/frames/last.png" \
+  --output "$OUTPUT" \
+  --height 768 --width 1376 --num-frames 124 --steps 20 --seed 42
diff --git a/scripts/diffusers/run_minimax_h3_fl2va_quantized.py b/scripts/diffusers/run_minimax_h3_fl2va_quantized.py
new file mode 100755
index 0000000..6b69a23
--- /dev/null
+++ b/scripts/diffusers/run_minimax_h3_fl2va_quantized.py
@@ -0,0 +1,241 @@
+#!/usr/bin/env python3
+"""Run official Diffusers MiniMax-H3 FL2VA with TorchAO weight-only quantization."""
+
+import argparse
+import inspect
+import json
+import time
+from pathlib import Path
+
+import torch
+from diffusers import MiniMaxH3Transformer3DModel, ModularPipeline, TorchAoConfig
+from diffusers.hooks import apply_group_offloading
+from diffusers.utils import load_image
+from diffusers.utils.export_utils import encode_video
+from torchao.quantization import Int4WeightOnlyConfig, Int8WeightOnlyConfig
+from transformers import Qwen3VLForConditionalGeneration
+from transformers import TorchAoConfig as TransformersTorchAoConfig
+
+
+DEFAULT_PROMPT = (
+    "Create a smooth cinematic transition between the supplied first and last frame, "
+    "preserving the subject, lighting, and composition with natural coherent motion "
+    "and synchronized ambient audio."
+)
+
+TRANSFORMER_NOT_QUANTIZED = [
+    "proj_in",
+    "audio_proj_in",
+    "context_embedder",
+    "time_embedder",
+    "time_proj",
+    "token_refiner",
+    "norm_out",
+    "proj_out",
+    "audio_proj_out",
+]
+
+TEXT_ENCODER_NOT_QUANTIZED = [
+    "model.visual",
+    "model.language_model.embed_tokens",
+    "model.language_model.norm",
+    "lm_head",
+]
+
+
+def sync_time() -> float:
+    torch.cuda.synchronize()
+    return time.perf_counter()
+
+
+def make_quant_config(bits: int):
+    if bits == 8:
+        if "version" in inspect.signature(Int8WeightOnlyConfig).parameters:
+            return Int8WeightOnlyConfig(version=2)
+        return Int8WeightOnlyConfig()
+    if bits == 4:
+        return Int4WeightOnlyConfig(group_size=128)
+    raise ValueError(f"unsupported quantization bits: {bits}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model", type=Path, required=True)
+    parser.add_argument("--image", type=Path, required=True)
+    parser.add_argument("--last-image", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--prompt", default=DEFAULT_PROMPT)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--height", type=int, default=480)
+    parser.add_argument("--width", type=int, default=864)
+    parser.add_argument("--num-frames", type=int, default=124)
+    parser.add_argument("--steps", type=int, default=20)
+    parser.add_argument("--bits", type=int, choices=(4, 8), default=8)
+    parser.add_argument("--device", default="cuda")
+    parser.add_argument("--no-stream-offload", action="store_true")
+    parser.add_argument("--resident", action="store_true", help="keep quantized components resident on the CUDA device")
+    parser.add_argument("--profile-transformer", action="store_true", help="synchronize and time every transformer forward")
+    arguments = parser.parse_args()
+
+    if not torch.cuda.is_available():
+        raise RuntimeError("MiniMax-H3 Diffusers benchmark requires CUDA")
+    if arguments.height % 32 or arguments.width % 32:
+        raise ValueError("height and width must be divisible by 32")
+
+    arguments.output.parent.mkdir(parents=True, exist_ok=True)
+    quant_config = make_quant_config(arguments.bits)
+
+    started = time.perf_counter()
+    pipeline = ModularPipeline.from_pretrained(
+        arguments.model,
+        workflow="fl2va",
+        local_files_only=True,
+    )
+    initialized = time.perf_counter()
+
+    pipeline.update_components(
+        transformer=MiniMaxH3Transformer3DModel.from_pretrained(
+            arguments.model,
+            subfolder="transformer",
+            dtype=torch.bfloat16,
+            quantization_config=TorchAoConfig(
+                quant_config,
+                modules_to_not_convert=TRANSFORMER_NOT_QUANTIZED,
+            ),
+            low_cpu_mem_usage=True,
+            local_files_only=True,
+        ),
+        text_encoder=Qwen3VLForConditionalGeneration.from_pretrained(
+            arguments.model,
+            subfolder="text_encoder",
+            dtype=torch.bfloat16,
+            quantization_config=TransformersTorchAoConfig(
+                quant_config,
+                modules_to_not_convert=TEXT_ENCODER_NOT_QUANTIZED,
+            ),
+            local_files_only=True,
+        ),
+    )
+    quantized_loaded = time.perf_counter()
+
+    pipeline.load_components(dtype=torch.bfloat16, pretrained_model_name_or_path=str(arguments.model), local_files_only=True)
+    pipeline.transformer.requires_grad_(False)
+    pipeline.text_encoder.requires_grad_(False)
+
+    device = torch.device(arguments.device)
+    if arguments.resident:
+        pipeline.transformer.to(device)
+        pipeline.text_encoder.to(device)
+        offload_summary = {
+            "transformer": str(device),
+            "text_encoder": str(device),
+            "vae": str(device),
+            "audio_vae": str(device),
+            "use_stream": False,
+        }
+    else:
+        offload = {
+            "onload_device": device,
+            "offload_device": torch.device("cpu"),
+            "use_stream": not arguments.no_stream_offload,
+            "low_cpu_mem_usage": True,
+        }
+        pipeline.transformer.enable_group_offload(offload_type="block_level", num_blocks_per_group=1, **offload)
+        apply_group_offloading(pipeline.text_encoder.model, offload_type="leaf_level", **offload)
+        offload_summary = {
+            "transformer": "block_level group offload",
+            "text_encoder": "leaf_level group offload",
+            "vae": str(device),
+            "audio_vae": str(device),
+            "use_stream": not arguments.no_stream_offload,
+        }
+    pipeline.vae.to(device)
+    pipeline.audio_vae.to(device)
+    components_ready = time.perf_counter()
+
+    transformer_profile = {"calls": 0, "seconds": 0.0}
+    transformer_profile_stack = []
+    if arguments.profile_transformer:
+        def profile_forward_pre_hook(module, args, kwargs):
+            torch.cuda.synchronize()
+            transformer_profile_stack.append(time.perf_counter())
+
+        def profile_forward_hook(module, args, kwargs, output):
+            torch.cuda.synchronize()
+            forward_started = transformer_profile_stack.pop()
+            transformer_profile["calls"] += 1
+            transformer_profile["seconds"] += time.perf_counter() - forward_started
+
+        pipeline.transformer.register_forward_pre_hook(profile_forward_pre_hook, with_kwargs=True)
+        pipeline.transformer.register_forward_hook(profile_forward_hook, with_kwargs=True)
+
+    first_image = load_image(str(arguments.image))
+    last_image = load_image(str(arguments.last_image))
+    generator = torch.Generator(device="cpu").manual_seed(arguments.seed)
+
+    sync_time()
+    generated = pipeline(
+        prompt=arguments.prompt,
+        image=first_image,
+        last_image=last_image,
+        height=arguments.height,
+        width=arguments.width,
+        num_frames=arguments.num_frames,
+        num_inference_steps=arguments.steps,
+        generator=generator,
+        output=["videos", "audio", "sampling_rate"],
+    )
+    generated_at = sync_time()
+
+    encode_video(
+        generated["videos"][0],
+        fps=24,
+        output_path=str(arguments.output),
+        audio=generated["audio"][0],
+        audio_sample_rate=generated["sampling_rate"],
+    )
+    finished = time.perf_counter()
+
+    results = {
+        "framework": "diffusers-main",
+        "workflow": "fl2va",
+        "model": str(arguments.model),
+        "device": arguments.device,
+        "dtype": "bfloat16",
+        "quantization": {
+            "method": "TorchAO weight-only",
+            "bits": arguments.bits,
+            "transformer_quantized": True,
+            "text_encoder_quantized": True,
+            "vae_quantized": False,
+            "audio_vae_quantized": False,
+            "scheduler_quantized": False,
+            "transformer_modules_to_not_convert": TRANSFORMER_NOT_QUANTIZED,
+            "text_encoder_modules_to_not_convert": TEXT_ENCODER_NOT_QUANTIZED,
+        },
+        "offload": offload_summary,
+        "prompt": arguments.prompt,
+        "seed": arguments.seed,
+        "height": arguments.height,
+        "width": arguments.width,
+        "requested_num_frames": arguments.num_frames,
+        "num_inference_steps": arguments.steps,
+        "output": str(arguments.output),
+        "seconds": {
+            "pipeline_init": initialized - started,
+            "quantized_component_load": quantized_loaded - initialized,
+            "component_finalize": components_ready - quantized_loaded,
+            "generate_cuda": generated_at - components_ready,
+            "transformer_forward_cuda": transformer_profile["seconds"],
+            "mux": finished - generated_at,
+            "end_to_end": finished - started,
+        },
+        "transformer_forward_calls": transformer_profile["calls"],
+    }
+    result_path = arguments.output.with_suffix(".json")
+    result_path.write_text(json.dumps(results, ensure_ascii=False, indent=2) + "\n")
+    print(json.dumps(results, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/dit_models/models/minimax_h3_full.hpp b/src/dit_models/models/minimax_h3_full.hpp
index 00c4f5a..de5d343 100644
--- a/src/dit_models/models/minimax_h3_full.hpp
+++ b/src/dit_models/models/minimax_h3_full.hpp
@@ -3,6 +3,7 @@
 
 #include <algorithm>
 #include <cmath>
+#include <cstdlib>
 #include <set>
 #include <string>
 #include <tuple>
@@ -20,6 +21,11 @@ namespace MiniMaxH3 {
     constexpr float FRAME_RESCALE        = 5.f / 3.f;
     constexpr float VISUAL_COND_TIMESTEP = 0.999f;
 
+    static bool h3_env_flag_enabled(const char* name) {
+        const char* value = std::getenv(name);
+        return value != nullptr && value[0] != '\0' && std::atoi(value) != 0;
+    }
+
     struct Config {
         int64_t hidden_size              = 5376;
         int64_t num_layers               = 50;
@@ -154,10 +160,16 @@ namespace MiniMaxH3 {
         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]));
+            const bool use_mlp_tensor_cores = h3_env_flag_enabled("ED_MINIMAX_H3_MLP_FP16_CUBLAS");
+            fc1->set_force_prec_f32(!use_mlp_tensor_cores);
+            fc2->set_force_prec_f32(!use_mlp_tensor_cores);
+            if (h3_env_flag_enabled("ED_MINIMAX_H3_DISABLE_SWIGLU_FUSION")) {
+                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]));
+            }
+            return fc2->forward(ctx, ggml_swiglu(ctx->ggml_ctx, fc1->forward(ctx, x)));
         }
     };
 
@@ -171,17 +183,42 @@ namespace MiniMaxH3 {
                                            ggml_tensor* pe) {
         int64_t rot_dim = pe->ne[2] * 2;
         GGML_ASSERT(rot_dim <= x->ne[0]);
+        const bool use_slice_views = !h3_env_flag_enabled("ED_MINIMAX_H3_DISABLE_ROPE_SLICE_VIEW");
         auto rotated = Rope::apply_rope(ctx,
-                                        ggml_ext_slice(ctx, x, 0, 0, rot_dim),
+                                        ggml_ext_slice(ctx, x, 0, 0, rot_dim, !use_slice_views),
                                         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]));
+        auto tail = attention_layout(ctx, ggml_ext_slice(ctx, x, 0, rot_dim, x->ne[0], !use_slice_views));
         return ggml_concat(ctx, rotated, tail, 0);
     }
 
+    static std::vector<ggml_tensor*> h3_qkv_views(ggml_context* ctx,
+                                                  ggml_tensor* qkv,
+                                                  int64_t head_dim,
+                                                  int64_t heads,
+                                                  int64_t sequence,
+                                                  int64_t batch) {
+        const int64_t inner = head_dim * heads;
+        std::vector<ggml_tensor*> views;
+        views.reserve(3);
+        for (int i = 0; i < 3; ++i) {
+            views.push_back(ggml_view_4d(ctx,
+                                         qkv,
+                                         head_dim,
+                                         heads,
+                                         sequence,
+                                         batch,
+                                         head_dim * qkv->nb[0],
+                                         qkv->nb[1],
+                                         qkv->nb[2],
+                                         static_cast<size_t>(i) * inner * qkv->nb[0]));
+        }
+        return views;
+    }
+
     struct Attention : public GGMLBlock {
         int64_t heads;
         int64_t head_dim;
@@ -208,10 +245,19 @@ namespace MiniMaxH3 {
 
             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);
+            auto qkv_out     = qkv_proj->forward(ctx, x);
+            std::vector<ggml_tensor*> qkv;
+            if (h3_env_flag_enabled("ED_MINIMAX_H3_DISABLE_QKV_VIEW")) {
+                qkv = ggml_ext_chunk(ctx->ggml_ctx, qkv_out, 3, 0);
+                qkv[0] = ggml_reshape_4d(ctx->ggml_ctx, qkv[0], head_dim, heads, sequence, batch);
+                qkv[1] = ggml_reshape_4d(ctx->ggml_ctx, qkv[1], head_dim, heads, sequence, batch);
+                qkv[2] = ggml_reshape_4d(ctx->ggml_ctx, qkv[2], head_dim, heads, sequence, batch);
+            } else {
+                qkv = h3_qkv_views(ctx->ggml_ctx, qkv_out, head_dim, heads, sequence, batch);
+            }
+            auto q           = qkv[0];
+            auto k           = qkv[1];
+            auto v           = qkv[2];
             q                = q_norm->forward(ctx, q);
             k                = k_norm->forward(ctx, k);
             if (pe != nullptr) {
@@ -338,8 +384,9 @@ namespace MiniMaxH3 {
                                                 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);
+        const bool use_views  = !h3_env_flag_enabled("ED_MINIMAX_H3_DISABLE_SEGMENT_VIEW");
+        auto selected         = ggml_ext_slice(ctx, reshaped, 1, row, row + 1, !use_views);
+        return ggml_ext_chunk(ctx, selected, expand, 0, !use_views);
     }
 
     static ggml_tensor* modulate_segments(ggml_context* ctx,
@@ -359,7 +406,8 @@ namespace MiniMaxH3 {
                                        expand,
                                        modalities,
                                        segment.modulation_row);
-            auto part = ggml_ext_slice(ctx, x, 1, segment.start, segment.end);
+            const bool use_views = !h3_env_flag_enabled("ED_MINIMAX_H3_DISABLE_SEGMENT_VIEW");
+            auto part = ggml_ext_slice(ctx, x, 1, segment.start, segment.end, !use_views);
             part      = ggml_add(ctx,
                                  ggml_add(ctx, part, ggml_mul(ctx, part, mods[scale_index])),
                                  mods[shift_index]);
@@ -378,8 +426,9 @@ namespace MiniMaxH3 {
         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);
+            const bool use_views = !h3_env_flag_enabled("ED_MINIMAX_H3_DISABLE_SEGMENT_VIEW");
+            auto base = ggml_ext_slice(ctx, x, 1, segment.start, segment.end, !use_views);
+            auto add  = ggml_ext_slice(ctx, update, 1, segment.start, segment.end, !use_views);
             auto part = ggml_add(ctx, base, ggml_mul(ctx, add, mods[gate_index]));
             out       = out == nullptr ? part : ggml_concat(ctx, out, part, 1);
         }
diff --git a/src/dit_models/pipelines/minimax_h3_pipeline.cpp b/src/dit_models/pipelines/minimax_h3_pipeline.cpp
index d181b27..c8215a1 100644
--- a/src/dit_models/pipelines/minimax_h3_pipeline.cpp
+++ b/src/dit_models/pipelines/minimax_h3_pipeline.cpp
@@ -37,6 +37,23 @@ int64_t h3_resolve_seed(int64_t seed) {
     return seed >= 0 ? seed : static_cast<int64_t>(std::time(nullptr));
 }
 
+bool h3_profile_enabled();
+
+ed_tiling_params_t h3_vae_tiling(const ModelRuntime& runtime) {
+    ed_tiling_params_t tiling = runtime.vae_tiling();
+    if (tiling.force_disable) {
+        tiling.enabled = false;
+    }
+    if (h3_profile_enabled()) {
+        LOG_INFO("minimax-h3 profile VAE tiling: enabled=%d force-disable=%d rel=%.3f,%.3f",
+                 tiling.enabled,
+                 tiling.force_disable,
+                 tiling.rel_size_x,
+                 tiling.rel_size_y);
+    }
+    return tiling;
+}
+
 void h3_resize_for_vision(int source_width, int source_height, int* width, int* height) {
     constexpr int factor = 32;
     constexpr int min_pixels = 3136;
@@ -89,6 +106,11 @@ bool h3_trace_enabled() {
     return value != nullptr && value[0] != '\0' && std::strcmp(value, "0") != 0;
 }
 
+bool h3_profile_enabled() {
+    const char* value = std::getenv("ED_MINIMAX_H3_PROFILE");
+    return value != nullptr && value[0] != '\0' && std::strcmp(value, "0") != 0;
+}
+
 void h3_trace_tensor(const char* name, const sd::Tensor<float>& tensor) {
     if (!h3_trace_enabled()) {
         return;
@@ -230,6 +252,56 @@ MiniMaxH3DetectedConfig detect_minimax_config(const String2TensorStorage& tensor
 
 }  // namespace
 
+struct MiniMaxH3Profile {
+    int64_t total_ms = 0;
+    int64_t cond_context_ms = 0;
+    int64_t uncond_context_ms = 0;
+    int64_t vision_image_prepare_ms = 0;
+    int64_t vision_image_encode_ms = 0;
+    int64_t vision_video_prepare_ms = 0;
+    int64_t vision_video_encode_ms = 0;
+    int64_t text_tokenize_ms = 0;
+    int64_t text_encode_ms = 0;
+    int64_t keyframe_vae_encode_ms = 0;
+    int64_t reference_video_vae_encode_ms = 0;
+    int64_t reference_audio_prepare_ms = 0;
+    int64_t reference_audio_vae_encode_ms = 0;
+    int64_t noise_init_ms = 0;
+    int64_t diffusion_cond_ms = 0;
+    int64_t diffusion_uncond_ms = 0;
+    int64_t cfg_combine_ms = 0;
+    int64_t video_vae_decode_ms = 0;
+    int64_t video_postprocess_ms = 0;
+    int64_t audio_vae_decode_ms = 0;
+    int64_t audio_postprocess_ms = 0;
+    int diffusion_steps = 0;
+    int diffusion_calls = 0;
+
+    void log() const {
+        const int64_t diffusion_ms = diffusion_cond_ms + diffusion_uncond_ms + cfg_combine_ms;
+        const int64_t conditioning_ms = cond_context_ms + uncond_context_ms + keyframe_vae_encode_ms +
+                                        reference_video_vae_encode_ms + reference_audio_prepare_ms +
+                                        reference_audio_vae_encode_ms;
+        const int64_t decode_ms = video_vae_decode_ms + video_postprocess_ms + audio_vae_decode_ms + audio_postprocess_ms;
+        LOG_INFO("minimax-h3 profile: total=%lld ms | conditioning=%lld ms | diffusion=%lld ms (%d steps, %d calls) | decode=%lld ms | noise=%lld ms",
+                 static_cast<long long>(total_ms), static_cast<long long>(conditioning_ms),
+                 static_cast<long long>(diffusion_ms), diffusion_steps, diffusion_calls,
+                 static_cast<long long>(decode_ms), static_cast<long long>(noise_init_ms));
+        LOG_INFO("minimax-h3 profile conditioning: context cond=%lld ms uncond=%lld ms | vision image prepare=%lld ms encode=%lld ms | vision video prepare=%lld ms encode=%lld ms | text tokenize=%lld ms encode=%lld ms | keyframe vae=%lld ms | ref video vae=%lld ms | ref audio prepare=%lld ms vae=%lld ms",
+                 static_cast<long long>(cond_context_ms), static_cast<long long>(uncond_context_ms),
+                 static_cast<long long>(vision_image_prepare_ms), static_cast<long long>(vision_image_encode_ms),
+                 static_cast<long long>(vision_video_prepare_ms), static_cast<long long>(vision_video_encode_ms),
+                 static_cast<long long>(text_tokenize_ms), static_cast<long long>(text_encode_ms),
+                 static_cast<long long>(keyframe_vae_encode_ms), static_cast<long long>(reference_video_vae_encode_ms),
+                 static_cast<long long>(reference_audio_prepare_ms), static_cast<long long>(reference_audio_vae_encode_ms));
+        LOG_INFO("minimax-h3 profile diffusion: conditional=%lld ms unconditional=%lld ms cfg-combine=%lld ms | decode video-vae=%lld ms video-copy=%lld ms audio-vae=%lld ms audio-copy=%lld ms",
+                 static_cast<long long>(diffusion_cond_ms), static_cast<long long>(diffusion_uncond_ms),
+                 static_cast<long long>(cfg_combine_ms), static_cast<long long>(video_vae_decode_ms),
+                 static_cast<long long>(video_postprocess_ms), static_cast<long long>(audio_vae_decode_ms),
+                 static_cast<long long>(audio_postprocess_ms));
+    }
+};
+
 MiniMaxH3Pipeline::MiniMaxH3Pipeline(SDVersion version)
     : version_(version) {
 }
@@ -357,6 +429,7 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
                                            int max_video_frames,
                                            sd::Tensor<float>* context,
                                            sd::Tensor<int32_t>* token_tags,
+                                           MiniMaxH3Profile* profile,
                                            std::string* error) {
     if (context == nullptr || token_tags == nullptr || conditioner_ == nullptr || runtime_ == nullptr) {
         return set_minimax_error(error, "MiniMax-H3 text conditioner is not initialized");
@@ -368,6 +441,7 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
     std::vector<std::pair<int, int64_t>> vision_token_ranges;
     const int vision_patch_size = conditioner_->model.params.vision.patch_size;
     for (int image_index = 0; image_index < ref_image_count; ++image_index) {
+        const int64_t prepare_begin = profile != nullptr ? ggml_time_ms() : 0;
         const ed_image_t& image = ref_images[image_index];
         int width = 0;
         int height = 0;
@@ -377,11 +451,14 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
             return set_minimax_error(error, "MiniMax-H3 Ref2VA image reference is invalid");
         }
         image_tensor = image_tensor * 2.0f - 1.0f;
+        if (profile != nullptr) profile->vision_image_prepare_ms += ggml_time_ms() - prepare_begin;
         LOG_DEBUG("MiniMax-H3 Ref2VA vision image=%dx%d tensor=%s",
                   width,
                   height,
                   sd::tensor_shape_to_string(image_tensor.shape()).c_str());
+        const int64_t encode_begin = profile != nullptr ? ggml_time_ms() : 0;
         std::vector<sd::Tensor<float>> image_outputs = conditioner_->model.encode_image_outputs(runtime_->n_threads(), image_tensor);
+        if (profile != nullptr) profile->vision_image_encode_ms += ggml_time_ms() - encode_begin;
         if (image_outputs.size() != 4 || image_outputs[0].empty()) {
             return set_minimax_error(error, "MiniMax-H3 Ref2VA vision encoder failed");
         }
@@ -428,6 +505,7 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
             sampled_frames.push_back(frame);
         }
         for (size_t sampled_index = 0; sampled_index < sampled_frames.size(); sampled_index += 2) {
+            const int64_t prepare_begin = profile != nullptr ? ggml_time_ms() : 0;
             const size_t next_sampled_index = std::min(sampled_index + 1, sampled_frames.size() - 1);
             const int first_frame = sampled_frames[sampled_index];
             const int second_frame = sampled_frames[next_sampled_index];
@@ -449,7 +527,10 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
                     }
                 }
             }
+            if (profile != nullptr) profile->vision_video_prepare_ms += ggml_time_ms() - prepare_begin;
+            const int64_t encode_begin = profile != nullptr ? ggml_time_ms() : 0;
             auto outputs = conditioner_->model.encode_video_block_outputs(runtime_->n_threads(), pair);
+            if (profile != nullptr) profile->vision_video_encode_ms += ggml_time_ms() - encode_begin;
             if (outputs.size() != 4 || outputs[0].empty()) return set_minimax_error(error, "MiniMax-H3 Ref2VA video vision encoder failed");
             const float first_time = static_cast<float>(first_frame) / 24.0f;
             const float second_time = static_cast<float>(second_frame) / 24.0f;
@@ -475,12 +556,16 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
     const std::string text = "<|im_start|>user\n" + presentations +
                              std::string(prompt == nullptr ? "" : prompt) +
                              "<|im_end|>\n<|im_start|>assistant\n";
+    const int64_t tokenize_begin = profile != nullptr ? ggml_time_ms() : 0;
     const std::vector<int> tokens = conditioner_->tokenizer->tokenize(text, nullptr, true, 0, 4096, false);
+    if (profile != nullptr) profile->text_tokenize_ms += ggml_time_ms() - tokenize_begin;
     if (tokens.empty()) {
         return set_minimax_error(error, "MiniMax-H3 prompt tokenization produced no tokens");
     }
     sd::Tensor<int32_t> ids({static_cast<int64_t>(tokens.size())}, tokens);
+    const int64_t text_encode_begin = profile != nullptr ? ggml_time_ms() : 0;
     *context = conditioner_->model.compute(runtime_->n_threads(), ids, {}, image_embeds, {50}, image_embed_infos, "", deepstack_image_embeds);
+    if (profile != nullptr) profile->text_encode_ms += ggml_time_ms() - text_encode_begin;
     if (context->empty()) {
         return set_minimax_error(error, "MiniMax-H3 text encoder compute failed");
     }
@@ -499,13 +584,13 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
 ed_status_t MiniMaxH3Pipeline::decode_video_latent(const sd::Tensor<float>& latent,
                                                     int requested_frames,
                                                     ed_video_t* out,
+                                                    MiniMaxH3Profile* profile,
                                                     std::string* error) {
     sd::Tensor<float> vae_latent = vae_->diffusion_to_vae_latents(latent);
-    ed_tiling_params_t tiling = runtime_->vae_tiling();
-    if (tiling.force_disable) {
-        tiling.enabled = false;
-    }
+    ed_tiling_params_t tiling = h3_vae_tiling(*runtime_);
+    const int64_t decode_begin = profile != nullptr ? ggml_time_ms() : 0;
     sd::Tensor<float> video = vae_->decode(runtime_->n_threads(), vae_latent, tiling, true);
+    if (profile != nullptr) profile->video_vae_decode_ms += ggml_time_ms() - decode_begin;
     if (video.empty() || video.dim() != 5) {
         set_minimax_error(error, "MiniMax-H3 video VAE decode failed");
         return ED_STATUS_GENERATION_FAILED;
@@ -521,6 +606,7 @@ ed_status_t MiniMaxH3Pipeline::decode_video_latent(const sd::Tensor<float>& late
     const size_t height = static_cast<size_t>(video.shape()[1]);
     const size_t channels = static_cast<size_t>(video.shape()[3]);
     const size_t pixels = width * height;
+    const int64_t postprocess_begin = profile != nullptr ? ggml_time_ms() : 0;
     for (int frame = 0; frame < frames_count; ++frame) {
         frames[frame].width = static_cast<int>(width);
         frames[frame].height = static_cast<int>(height);
@@ -545,16 +631,20 @@ ed_status_t MiniMaxH3Pipeline::decode_video_latent(const sd::Tensor<float>& late
     }
     out->frames = frames;
     out->frame_count = frames_count;
+    if (profile != nullptr) profile->video_postprocess_ms += ggml_time_ms() - postprocess_begin;
     return ED_STATUS_OK;
 }
 
 bool MiniMaxH3Pipeline::decode_audio_latent(const sd::Tensor<float>& latent,
                                             ed_video_t* out,
+                                            MiniMaxH3Profile* profile,
                                             std::string* error) {
     if (audio_vae_ == nullptr || latent.empty()) {
         return set_minimax_error(error, "MiniMax-H3 audio VAE is not initialized");
     }
+    const int64_t decode_begin = profile != nullptr ? ggml_time_ms() : 0;
     sd::Tensor<float> waveform = audio_vae_->decode(runtime_->n_threads(), latent);
+    if (profile != nullptr) profile->audio_vae_decode_ms += ggml_time_ms() - decode_begin;
     if (waveform.empty() || waveform.dim() != 4 || waveform.shape()[1] != 2) {
         return set_minimax_error(error, "MiniMax-H3 audio VAE decode failed");
     }
@@ -567,6 +657,7 @@ bool MiniMaxH3Pipeline::decode_audio_latent(const sd::Tensor<float>& latent,
     if (samples == nullptr) {
         return set_minimax_error(error, "failed to allocate MiniMax-H3 audio output");
     }
+    const int64_t postprocess_begin = profile != nullptr ? ggml_time_ms() : 0;
     for (int64_t sample = 0; sample < sample_count; ++sample) {
         for (int channel = 0; channel < channels; ++channel) {
             samples[sample * channels + channel] = std::clamp(waveform.index(sample, channel, 0, 0), -1.0f, 1.0f);
@@ -576,12 +667,16 @@ bool MiniMaxH3Pipeline::decode_audio_latent(const sd::Tensor<float>& latent,
     out->audio_sample_count = static_cast<int>(sample_count);
     out->audio_channels = channels;
     out->audio_sample_rate = 32000;
+    if (profile != nullptr) profile->audio_postprocess_ms += ggml_time_ms() - postprocess_begin;
     return true;
 }
 
 ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t* params,
                                               ed_video_t* out,
                                               std::string* error) {
+    MiniMaxH3Profile profile;
+    MiniMaxH3Profile* profile_ptr = h3_profile_enabled() ? &profile : nullptr;
+    const int64_t generation_begin = profile_ptr != nullptr ? ggml_time_ms() : 0;
     if (out == nullptr || params == nullptr) {
         set_minimax_error(error, "MiniMax-H3 video parameters or output are null");
         return ED_STATUS_INVALID_ARGUMENT;
@@ -619,14 +714,18 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
     const int64_t resolved_seed = h3_resolve_seed(params->seed);
     sd::Tensor<float> context;
     sd::Tensor<int32_t> token_tags;
-    if (!build_text_context(params->prompt, params->ref_images, params->ref_image_count, params->ref_videos, params->ref_video_count, params->ref_audio_count, frames, &context, &token_tags, error)) return ED_STATUS_GENERATION_FAILED;
+    const int64_t cond_context_begin = profile_ptr != nullptr ? ggml_time_ms() : 0;
+    if (!build_text_context(params->prompt, params->ref_images, params->ref_image_count, params->ref_videos, params->ref_video_count, params->ref_audio_count, frames, &context, &token_tags, profile_ptr, error)) return ED_STATUS_GENERATION_FAILED;
+    if (profile_ptr != nullptr) profile.cond_context_ms = ggml_time_ms() - cond_context_begin;
     const float cfg_scale = params->sample.cfg_scale;
     const bool use_cfg = cfg_scale != 1.0f;
     sd::Tensor<float> uncond_context;
     sd::Tensor<int32_t> uncond_token_tags;
-    if (use_cfg && !build_text_context(params->negative_prompt, params->ref_images, params->ref_image_count, params->ref_videos, params->ref_video_count, params->ref_audio_count, frames, &uncond_context, &uncond_token_tags, error)) {
+    const int64_t uncond_context_begin = profile_ptr != nullptr ? ggml_time_ms() : 0;
+    if (use_cfg && !build_text_context(params->negative_prompt, params->ref_images, params->ref_image_count, params->ref_videos, params->ref_video_count, params->ref_audio_count, frames, &uncond_context, &uncond_token_tags, profile_ptr, error)) {
         return ED_STATUS_GENERATION_FAILED;
     }
+    if (profile_ptr != nullptr && use_cfg) profile.uncond_context_ms = ggml_time_ms() - uncond_context_begin;
     const int latent_frames = frames <= 5 ? 2 : ((frames - 5) / 17) * 5 + 2;
     const int audio_length = std::max(1, static_cast<int>(std::lround(static_cast<double>(frames) * 40.0 / 24.0)));
     const int latent_width = params->width / 16;
@@ -642,7 +741,9 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
             return set_minimax_error(error, "MiniMax-H3 keyframe image is invalid");
         }
         sd::Tensor<float> video_image = image_tensor.reshape({params->width, params->height, 1, 3, 1});
-        sd::Tensor<float> vae_latent = vae_->encode(runtime_->n_threads(), video_image, runtime_->vae_tiling());
+        const int64_t vae_encode_begin = profile_ptr != nullptr ? ggml_time_ms() : 0;
+        sd::Tensor<float> vae_latent = vae_->encode(runtime_->n_threads(), video_image, h3_vae_tiling(*runtime_));
+        if (profile_ptr != nullptr) profile.keyframe_vae_encode_ms += ggml_time_ms() - vae_encode_begin;
         if (vae_latent.empty()) {
             return set_minimax_error(error, "MiniMax-H3 keyframe VAE encode failed");
         }
@@ -664,6 +765,7 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
     std::vector<MiniMaxH3ReferenceBlock> reference_blocks;
     auto encode_reference_audio = [&](const ed_audio_t& source, int32_t* index) -> bool {
         if (audio_vae_ == nullptr || source.data == nullptr || source.sample_count == 0 || source.channels == 0 || source.sample_rate == 0) return false;
+        const int64_t prepare_begin = profile_ptr != nullptr ? ggml_time_ms() : 0;
         const uint64_t samples = std::max<uint64_t>(1, (source.sample_count * 32000ULL + source.sample_rate / 2) / source.sample_rate);
         sd::Tensor<float> waveform({static_cast<int64_t>(((samples + 799) / 800) * 800), 2, 1, 1});
         for (uint64_t sample = 0; sample < samples; ++sample) {
@@ -678,7 +780,10 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
                 waveform.index(sample, channel, 0, 0) = std::clamp(a + (b - a) * fraction, -1.f, 1.f);
             }
         }
+        if (profile_ptr != nullptr) profile.reference_audio_prepare_ms += ggml_time_ms() - prepare_begin;
+        const int64_t vae_encode_begin = profile_ptr != nullptr ? ggml_time_ms() : 0;
         auto encoded = audio_vae_->encode(runtime_->n_threads(), waveform);
+        if (profile_ptr != nullptr) profile.reference_audio_vae_encode_ms += ggml_time_ms() - vae_encode_begin;
         if (encoded.empty()) return false;
         *index = static_cast<int32_t>(reference_audio_latents.size());
         reference_audio_latents.push_back(std::move(encoded));
@@ -697,7 +802,9 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
             return ED_STATUS_INVALID_ARGUMENT;
         }
         sd::Tensor<float> video_image = image_tensor.reshape({reference_width, reference_height, 1, 3, 1});
-        sd::Tensor<float> vae_latent = vae_->encode(runtime_->n_threads(), video_image, runtime_->vae_tiling());
+        const int64_t vae_encode_begin = profile_ptr != nullptr ? ggml_time_ms() : 0;
+        sd::Tensor<float> vae_latent = vae_->encode(runtime_->n_threads(), video_image, h3_vae_tiling(*runtime_));
+        if (profile_ptr != nullptr) profile.reference_video_vae_encode_ms += ggml_time_ms() - vae_encode_begin;
         if (vae_latent.empty()) {
             set_minimax_error(error, "MiniMax-H3 Ref2VA image VAE encode failed");
             return ED_STATUS_GENERATION_FAILED;
@@ -741,7 +848,9 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
                 }
             }
         }
-        auto vae_latent = vae_->encode(runtime_->n_threads(), video_reference, runtime_->vae_tiling());
+        const int64_t vae_encode_begin = profile_ptr != nullptr ? ggml_time_ms() : 0;
+        auto vae_latent = vae_->encode(runtime_->n_threads(), video_reference, h3_vae_tiling(*runtime_));
+        if (profile_ptr != nullptr) profile.reference_video_vae_encode_ms += ggml_time_ms() - vae_encode_begin;
         if (vae_latent.empty()) { set_minimax_error(error, "MiniMax-H3 Ref2VA video VAE encode failed"); return ED_STATUS_GENERATION_FAILED; }
         int32_t audio_index = -1;
         if (reference.audio.data != nullptr && reference.audio.sample_count > 0 && !encode_reference_audio(reference.audio, &audio_index)) {
@@ -764,16 +873,21 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
     }
     sd::Tensor<float> video = sd::zeros<float>({latent_width, latent_height, latent_frames, 24, 1});
     sd::Tensor<float> audio = sd::zeros<float>({audio_length, 2, 32, 1});
+    const int64_t noise_begin = profile_ptr != nullptr ? ggml_time_ms() : 0;
     sd::Tensor<float> packed = h3_pack_audio_and_video_latents(video, audio);
     auto rng = std::make_shared<PhiloxRNG>(static_cast<uint64_t>(resolved_seed));
     packed = sd::randn_like<float>(packed, rng);
+    if (profile_ptr != nullptr) profile.noise_init_ms = ggml_time_ms() - noise_begin;
     h3_trace_tensor("initial_packed_noise", packed);
     const int steps = params->sample.steps > 0 ? params->sample.steps : 20;
     const float video_sigma_shift = params->sample.flow_shift > 0.0f ? params->sample.flow_shift : 12.0f;
-    for (int step = 0; step < steps; ++step) {
+    // MiniMax-H3's official scheduler treats `steps` as the number of sigma grid
+    // points, including the terminal clean point at sigma=0. The terminal point
+    // has no model evaluation, so `steps=20` runs 19 DiT forwards.
+    for (int step = 0; step + 1 < steps; ++step) {
+        if (profile_ptr != nullptr) ++profile.diffusion_steps;
         const float sigma = h3_discrete_flow_sigma(step, steps, video_sigma_shift);
-        const float sigma_next = step + 1 == steps ? 0.0f
-                                                    : h3_discrete_flow_sigma(step + 1, steps, video_sigma_shift);
+        const float sigma_next = h3_discrete_flow_sigma(step + 1, steps, video_sigma_shift);
         sd::Tensor<float> timestep({1}, {sigma * 1000.0f});
         DiffusionParams diffusion_params{};
         diffusion_params.x = &packed;
@@ -792,7 +906,12 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
         diffusion_params.minimax_audio_length = audio_length;
         diffusion_params.minimax_video_sigma_shift = video_sigma_shift;
         diffusion_params.minimax_audio_sigma_shift = 3.0f;
+        const int64_t cond_begin = profile_ptr != nullptr ? ggml_time_ms() : 0;
         sd::Tensor<float> velocity = diffusion_->compute(runtime_->n_threads(), diffusion_params);
+        if (profile_ptr != nullptr) {
+            profile.diffusion_cond_ms += ggml_time_ms() - cond_begin;
+            ++profile.diffusion_calls;
+        }
         if (velocity.empty()) {
             set_minimax_error(error, "MiniMax-H3 diffusion compute failed");
             return ED_STATUS_GENERATION_FAILED;
@@ -800,12 +919,19 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
         if (use_cfg) {
             diffusion_params.context = &uncond_context;
             diffusion_params.minimax_text_token_tags = &uncond_token_tags;
+            const int64_t uncond_begin = profile_ptr != nullptr ? ggml_time_ms() : 0;
             sd::Tensor<float> uncond_velocity = diffusion_->compute(runtime_->n_threads(), diffusion_params);
+            if (profile_ptr != nullptr) {
+                profile.diffusion_uncond_ms += ggml_time_ms() - uncond_begin;
+                ++profile.diffusion_calls;
+            }
             if (uncond_velocity.empty()) {
                 set_minimax_error(error, "MiniMax-H3 unconditional diffusion compute failed");
                 return ED_STATUS_GENERATION_FAILED;
             }
+            const int64_t cfg_combine_begin = profile_ptr != nullptr ? ggml_time_ms() : 0;
             velocity = uncond_velocity + (velocity - uncond_velocity) * cfg_scale;
+            if (profile_ptr != nullptr) profile.cfg_combine_ms += ggml_time_ms() - cfg_combine_begin;
         }
         if (h3_trace_enabled()) {
             LOG_INFO("minimax-h3 trace step=%d sigma=%.8g sigma_next=%.8g", step, sigma, sigma_next);
@@ -817,14 +943,18 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
         }
     }
     auto av = diffusion_->split_av_latents(packed, audio_length);
-    ed_status_t status = decode_video_latent(av.first, frames, out, error);
+    ed_status_t status = decode_video_latent(av.first, frames, out, profile_ptr, error);
     if (status != ED_STATUS_OK) {
         return status;
     }
-    if (audio_vae_ != nullptr && !decode_audio_latent(av.second, out, error)) {
+    if (audio_vae_ != nullptr && !decode_audio_latent(av.second, out, profile_ptr, error)) {
         ed_free_video(out);
         return ED_STATUS_GENERATION_FAILED;
     }
+    if (profile_ptr != nullptr) {
+        profile.total_ms = ggml_time_ms() - generation_begin;
+        profile.log();
+    }
     return ED_STATUS_OK;
 }
 
diff --git a/src/dit_models/pipelines/minimax_h3_pipeline.hpp b/src/dit_models/pipelines/minimax_h3_pipeline.hpp
index 1d1eab5..61489ca 100644
--- a/src/dit_models/pipelines/minimax_h3_pipeline.hpp
+++ b/src/dit_models/pipelines/minimax_h3_pipeline.hpp
@@ -17,6 +17,9 @@ struct MiniMaxH3VideoVAERunner;
 namespace MiniMaxH3Audio {
 struct AudioVAERunner;
 }
+namespace edgedit {
+struct MiniMaxH3Profile;
+}
 
 namespace edgedit {
 
@@ -72,13 +75,16 @@ class MiniMaxH3Pipeline final : public DiTPipeline {
                             int max_video_frames,
                             sd::Tensor<float>* context,
                             sd::Tensor<int32_t>* token_tags,
+                            MiniMaxH3Profile* profile,
                             std::string* error);
     ed_status_t decode_video_latent(const sd::Tensor<float>& latent,
                                     int requested_frames,
                                     ed_video_t* out,
+                                    MiniMaxH3Profile* profile,
                                     std::string* error);
     bool decode_audio_latent(const sd::Tensor<float>& latent,
                              ed_video_t* out,
+                             MiniMaxH3Profile* profile,
                              std::string* error);
 };
 
diff --git a/third_party/ggml b/third_party/ggml
index b389935..b988216 160000
--- a/third_party/ggml
+++ b/third_party/ggml
@@ -1 +1 @@
-Subproject commit b38993515cc6129cbb7ea00041ff44484bac3baf
+Subproject commit b98821604f6434d9378eb2745e0f01701b920827

From 19a0fc61c0375a63243fa8e06a928e92c2c64d1c Mon Sep 17 00:00:00 2001
From: Komorebi623 <wang-ty22@mails.tsinghua.edu.cn>
Date: Fri, 7 Aug 2026 21:16:36 +0800
Subject: [PATCH 03/25] Document H3 Diffusers gap and FC1 experiments

---
 .../minimax-h3-handoff-2026-08-07.md          | 63 +++++++++++++++++++
 src/dit_models/models/minimax_h3_full.hpp     |  6 +-
 2 files changed, 67 insertions(+), 2 deletions(-)

diff --git a/docs/optimization/minimax-h3-handoff-2026-08-07.md b/docs/optimization/minimax-h3-handoff-2026-08-07.md
index 3d3b539..bcda824 100644
--- a/docs/optimization/minimax-h3-handoff-2026-08-07.md
+++ b/docs/optimization/minimax-h3-handoff-2026-08-07.md
@@ -666,3 +666,66 @@ Quality sanity check:
 - Sampled frame stddevs: `54.66`, `56.61`, `55.93`, `57.80`, `52.85`
 
 Conclusion: the full 20-step run is not black and visually sane on the contact sheet. The FC2 f32 cuBLAS fix keeps the long-sequence FC2 speed path usable for this probe. A broader quality comparison against MMQ baseline and Diffusers is still needed before treating this as final release-quality parity.
+
+### 2026-08-07 committed state and Diffusers gap
+
+Committed locally after the FC2 f32-fix validation:
+
+- Main repository commit: `a761c7c Optimize MiniMax H3 CUDA inference`
+- GGML submodule commit: `b9882160 Optimize H3 Q4_K CUDA routing`
+
+Current closest same-task timing comparison on the 124-frame FL2VA benchmark (`864x480`, `steps=20`, actual 19 DiT/transformer forwards, `cfg=1`, seed `42`):
+
+| Framework/path | Transformer/DiT time | Calls | Per-call | Notes |
+|---|---:|---:|---:|---|
+| Diffusers TorchAO int4 resident | `56.724s` | `19` | `2.985s` | `outputs/minimax-h3/diffusers-fl2va-480p124-int4-resident-profile3-gpu0/final.json` |
+| edge.cpp Q4_K cuBLAS + FC2 f32-fix | `62.367s` | `19` | `3.282s` | `outputs/minimax-h3/quality-speed-q4k-fc2-f32fix-124f20s-2026-08-07/run.log` |
+
+Current gap: edge DiT is `5.643s` slower over 19 calls, or about `9.95%` slower than Diffusers transformer time. Per model call the gap is about `0.297s`.
+
+Important apples-to-apples caveat: the runs match the high-level task, resolution, frames, steps, seed, and one-forward CFG-distilled setting. They still do not have identical quantization kernels/layouts: edge uses GGUF `Q4_K_M` with selective cuBLAS fallback and FC2 f32 compute; Diffusers uses TorchAO/fbgemm int4 resident packed TensorCore layout. Therefore the remaining gap is best interpreted as backend/kernel/layout overhead, not model semantics alone.
+
+Current short op-profile after FC2 f32-fix (`56` frames, `5` steps, 4 DiT calls):
+
+- Artifact: `outputs/minimax-h3/perf-op-profile-q4k-fc2-f32fix-56f5s-2026-08-07/run.log`
+- Diffusion time: `6.666s` for 4 calls.
+- Main DiT graphs show GEMM still dominant: around `990-1003ms` GEMM per graph group, followed by attention (`155-362ms`), elementwise (`~152ms`), and layout (`~122ms`) on the main transformer graphs.
+- Full decode graph remains a separate non-DiT cost and should not be mixed into DiT-vs-Diffusers transformer comparisons.
+
+Next optimization candidates from this profile:
+
+1. Reduce remaining H3 DiT elementwise/layout overhead without changing math order: view/materialization cleanup and possibly fusing strictly layout-only paths.
+2. Inspect remaining GEMM internals, especially repeated activation conversion (`src1_to_f16`) and fp16 destination conversion (`dst_to_f32`) in cuBLAS fallback. TorchAO's advantage is still its resident packed layout avoiding repeated GGUF dequant/activation conversion in hot paths.
+3. Avoid globally forcing f32 compute except for FC2 long-sequence shape; the quality fix is intentionally shape-scoped.
+
+### 2026-08-07 FC1 fp16-only experiment
+
+A new split switch was added for diagnosis:
+
+- `ED_MINIMAX_H3_FC1_FP16_CUBLAS=1` enables fp16 Tensor Core cuBLAS for H3 MLP `fc1` only.
+- `ED_MINIMAX_H3_FC2_FP16_CUBLAS=1` enables the analogous path for `fc2` only.
+- `ED_MINIMAX_H3_MLP_FP16_CUBLAS=1` still enables both and remains experimental.
+
+56-frame, 5-step FL2VA probe with `GGML_CUDA_SM90_Q4K_CUBLAS=1`:
+
+| Variant | Diffusion | Output | Artifact |
+|---|---:|---|---|
+| Baseline FC1 f32 path | `6.853s` | non-black | `outputs/minimax-h3/perf-quality-fc1-fp16-only-56f5s-2026-08-07/baseline/final.mp4` |
+| `ED_MINIMAX_H3_FC1_FP16_CUBLAS=1` | `6.693s` | non-black but diverges | `outputs/minimax-h3/perf-quality-fc1-fp16-only-56f5s-2026-08-07/fc1_fp16/final.mp4` |
+
+Frame PSNR baseline-vs-FC1-fp16 over 56 frames: min `25.034dB`, average `33.162dB`, max `44.824dB`.
+
+Conclusion: FC1 fp16-only is not suitable as a default quality-preserving optimization. It saves only about `2.3%` diffusion time on this probe while causing visible numerical divergence. Keep it opt-in only.
+
+### 2026-08-07 FC1 fp16 with f32 compute experiment
+
+To test whether FC1 quality loss came only from fp16 accumulation/output, FC1 was rerun with `ED_MINIMAX_H3_FC1_FP16_CUBLAS=1` plus global `GGML_CUDA_FORCE_CUBLAS_COMPUTE_32F=1` on the same 56-frame, 5-step FL2VA probe.
+
+| Variant | Diffusion | Artifact |
+|---|---:|---|
+| Baseline FC1 f32 path | `6.821s` | `outputs/minimax-h3/perf-quality-fc1-fp16-f32compute-56f5s-2026-08-07/baseline/final.mp4` |
+| FC1 fp16 inputs + f32 cuBLAS compute | `6.356s` | `outputs/minimax-h3/perf-quality-fc1-fp16-f32compute-56f5s-2026-08-07/fc1_f32compute/final.mp4` |
+
+Frame PSNR baseline-vs-FC1-fp16-f32compute over 56 frames: min `24.403dB`, average `31.772dB`, max `44.441dB`.
+
+Conclusion: FC1 divergence is not fixed by f32 accumulation alone. The lossy part is dequantizing the `Q4_K` FC1 weights and/or activations into fp16 for Tensor Core GEMM. FC1 fp16 should remain diagnostic-only; keep the quality-safe FC1 path on f32 SGEMM unless a resident int4 kernel/layout is implemented.
diff --git a/src/dit_models/models/minimax_h3_full.hpp b/src/dit_models/models/minimax_h3_full.hpp
index de5d343..e13f81c 100644
--- a/src/dit_models/models/minimax_h3_full.hpp
+++ b/src/dit_models/models/minimax_h3_full.hpp
@@ -161,8 +161,10 @@ namespace MiniMaxH3 {
             auto fc1 = std::dynamic_pointer_cast<Linear>(blocks["fc1"]);
             auto fc2 = std::dynamic_pointer_cast<Linear>(blocks["fc2"]);
             const bool use_mlp_tensor_cores = h3_env_flag_enabled("ED_MINIMAX_H3_MLP_FP16_CUBLAS");
-            fc1->set_force_prec_f32(!use_mlp_tensor_cores);
-            fc2->set_force_prec_f32(!use_mlp_tensor_cores);
+            const bool use_fc1_tensor_cores = use_mlp_tensor_cores || h3_env_flag_enabled("ED_MINIMAX_H3_FC1_FP16_CUBLAS");
+            const bool use_fc2_tensor_cores = use_mlp_tensor_cores || h3_env_flag_enabled("ED_MINIMAX_H3_FC2_FP16_CUBLAS");
+            fc1->set_force_prec_f32(!use_fc1_tensor_cores);
+            fc2->set_force_prec_f32(!use_fc2_tensor_cores);
             if (h3_env_flag_enabled("ED_MINIMAX_H3_DISABLE_SWIGLU_FUSION")) {
                 auto uv = ggml_ext_chunk(ctx->ggml_ctx, fc1->forward(ctx, x), 2, 0);
                 return fc2->forward(ctx, ggml_mul(ctx->ggml_ctx,

From a6296abcfb43c16bad618f5f855950c9ea502728 Mon Sep 17 00:00:00 2001
From: Komorebi623 <wang-ty22@mails.tsinghua.edu.cn>
Date: Fri, 7 Aug 2026 21:23:27 +0800
Subject: [PATCH 04/25] Document H3 RoPE tail-view experiment

---
 .../optimization/minimax-h3-handoff-2026-08-07.md | 15 +++++++++++++++
 src/dit_models/models/minimax_h3_full.hpp         | 14 +++++++++++++-
 2 files changed, 28 insertions(+), 1 deletion(-)

diff --git a/docs/optimization/minimax-h3-handoff-2026-08-07.md b/docs/optimization/minimax-h3-handoff-2026-08-07.md
index bcda824..d3d0ef0 100644
--- a/docs/optimization/minimax-h3-handoff-2026-08-07.md
+++ b/docs/optimization/minimax-h3-handoff-2026-08-07.md
@@ -729,3 +729,18 @@ To test whether FC1 quality loss came only from fp16 accumulation/output, FC1 wa
 Frame PSNR baseline-vs-FC1-fp16-f32compute over 56 frames: min `24.403dB`, average `31.772dB`, max `44.441dB`.
 
 Conclusion: FC1 divergence is not fixed by f32 accumulation alone. The lossy part is dequantizing the `Q4_K` FC1 weights and/or activations into fp16 for Tensor Core GEMM. FC1 fp16 should remain diagnostic-only; keep the quality-safe FC1 path on f32 SGEMM unless a resident int4 kernel/layout is implemented.
+
+### 2026-08-07 RoPE tail-view experiment
+
+A local H3 partial-RoPE experiment added `ED_MINIMAX_H3_ROPE_TAIL_VIEW=1`, which keeps the unrotated tail dimensions as a stride view instead of materializing the `[32, seq, heads]` tail before concatenating it with the rotated prefix.
+
+56-frame, 5-step FL2VA probe with `GGML_CUDA_SM90_Q4K_CUBLAS=1`:
+
+| Variant | Diffusion | Main graph tail-cont cost | Artifact |
+|---|---:|---:|---|
+| Baseline | `6.748s` | `62.469ms` over 4 DiT calls | `outputs/minimax-h3/perf-quality-rope-tail-view-56f5s-2026-08-07/baseline/final.mp4` |
+| `ED_MINIMAX_H3_ROPE_TAIL_VIEW=1` | `6.666s` | eliminated from top nodes | `outputs/minimax-h3/perf-quality-rope-tail-view-56f5s-2026-08-07/tail_view/final.mp4` |
+
+Frame PSNR baseline-vs-tail-view over 56 frames: min `31.263dB`, average `36.053dB`, max `45.292dB`.
+
+Conclusion: the layout optimization does remove the targeted tail materialization, but the end-to-end diffusion improvement is small on this probe and the output is not pixel-equivalent. Keep `ED_MINIMAX_H3_ROPE_TAIL_VIEW=1` opt-in only; it is not enabled by default.
diff --git a/src/dit_models/models/minimax_h3_full.hpp b/src/dit_models/models/minimax_h3_full.hpp
index e13f81c..8ada3b1 100644
--- a/src/dit_models/models/minimax_h3_full.hpp
+++ b/src/dit_models/models/minimax_h3_full.hpp
@@ -193,7 +193,19 @@ namespace MiniMaxH3 {
         if (rot_dim == x->ne[0]) {
             return rotated;
         }
-        auto tail = attention_layout(ctx, ggml_ext_slice(ctx, x, 0, rot_dim, x->ne[0], !use_slice_views));
+        ggml_tensor* tail = nullptr;
+        if (h3_env_flag_enabled("ED_MINIMAX_H3_ROPE_TAIL_VIEW") && x->ne[3] == 1) {
+            tail = ggml_view_3d(ctx,
+                                x,
+                                x->ne[0] - rot_dim,
+                                x->ne[2],
+                                x->ne[1],
+                                x->nb[2],
+                                x->nb[1],
+                                static_cast<size_t>(rot_dim) * x->nb[0]);
+        } else {
+            tail = attention_layout(ctx, ggml_ext_slice(ctx, x, 0, rot_dim, x->ne[0], !use_slice_views));
+        }
         return ggml_concat(ctx, rotated, tail, 0);
     }
 

From 0d8f711d90ed9f23445fc2a8d2279bf891693513 Mon Sep 17 00:00:00 2001
From: Komorebi623 <wang-ty22@mails.tsinghua.edu.cn>
Date: Sat, 8 Aug 2026 01:43:01 +0800
Subject: [PATCH 05/25] Document H3 full-task FC2 experiment

---
 .../minimax-h3-handoff-2026-08-07.md          | 224 ++++++++++++++++++
 third_party/ggml                              |   2 +-
 2 files changed, 225 insertions(+), 1 deletion(-)

diff --git a/docs/optimization/minimax-h3-handoff-2026-08-07.md b/docs/optimization/minimax-h3-handoff-2026-08-07.md
index d3d0ef0..8acfcd1 100644
--- a/docs/optimization/minimax-h3-handoff-2026-08-07.md
+++ b/docs/optimization/minimax-h3-handoff-2026-08-07.md
@@ -744,3 +744,227 @@ A local H3 partial-RoPE experiment added `ED_MINIMAX_H3_ROPE_TAIL_VIEW=1`, which
 Frame PSNR baseline-vs-tail-view over 56 frames: min `31.263dB`, average `36.053dB`, max `45.292dB`.
 
 Conclusion: the layout optimization does remove the targeted tail materialization, but the end-to-end diffusion improvement is small on this probe and the output is not pixel-equivalent. Keep `ED_MINIMAX_H3_ROPE_TAIL_VIEW=1` opt-in only; it is not enabled by default.
+
+### 2026-08-07 SageAttention CUDA dispatch validation
+
+The first SageAttention comparison was not a valid CUDA-kernel measurement: the build cache had `ED_ENABLE_CUDA_SAGE_ATTN=OFF`, so `ED_SAGE_ATTN=1` only changed graph construction and the CUDA backend fell through to the normal attention path. The CUDA build was reconfigured with `-DED_ENABLE_CUDA_SAGE_ATTN=ON`, then rerun with the same one-GPU FL2VA probe (`864x480`, `56` frames, `5` steps, `cfg=1`, seed `42`, VAE tiling off, and `GGML_CUDA_SM90_Q4K_CUBLAS=1`).
+
+| Variant | DiT diffusion | Result | Artifact |
+|---|---:|---|---|
+| Normal attention | `6.829s` | baseline | `outputs/minimax-h3/sage-real-kernel-baseline-56f5s-2026-08-07/final.mp4` |
+| `ED_SAGE_ATTN=1` | `6.811s` | real fused CUDA dispatch, rejected | `outputs/minimax-h3/sage-real-kernel-56f5s-2026-08-07/final.mp4` |
+
+The Sage log contains `1080` `dispatch: running fused INT8-QK+F16-PV kernel` lines, proving that the custom CUDA kernel ran. Its target shape was `d_head=64`, `L_q=L_k=1797`, and `HN=32`; this is a VAE attention shape, not the H3 DiT self-attention shape. The measured DiT difference is only `18ms` over four calls (within normal run variation), while the generated-video comparison gives min/average/max PSNR `24.906/31.876/44.398dB`. Sampled optimized-frame mean/std values remain non-black (`114.95/54.04` through `166.02/52.02`), but the numerical divergence is too large for a default quality-safe optimization.
+
+Conclusion: keep `ED_SAGE_ATTN` runtime-disabled by default. Do not treat SageAttention as a MiniMax-H3 DiT optimization unless it is redesigned for the DiT's `d=128`, `h=56`, `seq=7919` attention shape and passes the same quality gate. Contact sheet and machine-readable quality result: `outputs/minimax-h3/sage-real-kernel-56f5s-2026-08-07/contact_sheet.jpg` and `outputs/minimax-h3/sage-real-kernel-56f5s-2026-08-07/quality.txt`.
+
+### 2026-08-07 cuDNN SDPA H3 dispatch confirmation
+
+With `ED_PROFILE_CUDNN_SDPA=1`, a short one-call H3 probe confirms that the existing cuDNN SDPA backend already handles the DiT's long self-attention:
+
+```text
+b=1, h=56, sq=7919, sk=7919, d=128, scale=11.3137, dst_type=f32
+```
+
+At 16 accumulated calls the profile reported `46.847ms` execution, `1.698ms` Q conversion, and `2.286ms` output conversion, or roughly `2.93ms` execution per attention call. The much more numerous `d=64`, `sq=1797`, padded `sk=2048` VAE attention calls are intentionally rejected by the current padding-mask gate. Artifact: `outputs/minimax-h3/cudnn-sdpa-dispatch-probe-56f2s-2026-08-07/run.log`.
+
+Conclusion: H3 DiT already uses cuDNN SDPA; attention is not the remaining dominant gap to Diffusers. Further H3 work should prioritize Q4_K FC1 kernel/layout efficiency and only pursue attention changes after a profile shows a material regression there.
+
+### 2026-08-07 TF32 status and FC1 bottleneck check
+
+The dominant quality-safe FC1 route is still `Q4_K -> FP32` dequantization followed by FP32 `cublasSgemm` (`m=28672`, `n=7919`, `k=5376`). Its 56-frame operator profile gives about `5.83ms` per FC1 projection; dequantization is only about `0.37ms` per projection. Caching dequantized FP32 FC1 weights would consume substantial persistent VRAM while having an upper-bound benefit of only about 6% of FC1 time (and roughly 1% of whole DiT time), so it is not the next worthwhile change.
+
+An isolated one-call GPU diagnostic compared the default cuBLAS configuration with `NVIDIA_TF32_OVERRIDE=0`:
+
+| Variant | DiT diffusion | Interpretation |
+|---|---:|---|
+| Default | `2.391s` | Hopper TF32 Tensor Core path active |
+| TF32 explicitly disabled | `4.300s` | FP32 CUDA-core fallback, `~80%` slower |
+
+The CUDA backend sets `CUBLAS_TF32_TENSOR_OP_MATH` when it creates the cuBLAS handle, so the current quality-safe FC1 SGEMM is already using Tensor Cores. A cuBLASLt rewrite would need cached descriptors/algorithms and a demonstrated advantage over this already-TF32-accelerated route before it is worth adding another runtime switch.
+
+### 2026-08-07 cuBLASLt FC1 algorithm scan
+
+A standalone H200 GPU microbenchmark measured the exact FC1 SGEMM shape (`m=28672`, `n=7919`, `k=5376`, FP32 inputs/output, TF32 compute) without changing repository code. Current `cublasSgemm` measured `5.299ms`. A `128MiB`-workspace cuBLASLt scan returned eight algorithms; the fastest measured `5.294ms`, while the others ranged from `5.383ms` to `6.625ms`.
+
+Conclusion: there is no material cuBLASLt algorithm advantage for the current quality-safe FP32/TF32 FC1 path on H200. Do not add a descriptor cache or a runtime switch for this equivalent path. The remaining meaningful route to close the roughly 10% Diffusers gap is a resident packed int4 kernel/layout compatible with `Q4_K`, avoiding the FP32 SGEMM path itself; this is a larger backend project and must be separately quality-gated.
+
+### 2026-08-07 Torch int4 packed-kernel feasibility check
+
+The CUDA environment includes TorchAO/fbgemm SM90 int4 support. Its `aten._weight_int4pack_mm` accepts group size `32`, so the group granularity can in principle represent the GGUF Q4_K block's 32-value scale/min pairs. A real H3 FC1 shape probe (`M=7919`, `K=5376`, `N=28672`) completed successfully with BF16 activations and group size `32`, but measured `83.97ms` per matrix multiplication.
+
+That is far slower than edge.cpp's current quality-safe Q4_K-to-FP32 TF32 SGEMM path (`~5.8ms` FC1 projection). The generic Aten packed kernel therefore is not the kernel/layout used by the faster Diffusers H3 benchmark, or is not intended for this extreme H3 matrix aspect ratio. It must not be integrated into edge.cpp.
+
+The installed TorchAO CUTLASS int4 interfaces exposed in this environment are rowwise-scaled `s8s4/s4s4` paths rather than a direct reusable C++ library API for GGUF's asymmetric Q4_K blocks. A future high-value path needs either the exact TorchAO weight-only kernel/layout used by the Diffusers run or a purpose-built Hopper kernel; it cannot be obtained by calling the generic Aten int4-pack op.
+
+### 2026-08-07 TorchAO v2 rowwise kernel follow-up
+
+The preceding generic `aten._weight_int4pack_mm` result is not the operator used by the current Diffusers MiniMax-H3 TorchAO run. `Int4WeightOnlyConfig(group_size=128)` dispatches `fbgemm::bf16i4bf16_rowwise`, a CUTLASS SM90 Hopper Tensor Core kernel. A direct H200 probe at the exact H3 FC1 shape (`M=7919`, `K=5376`, `N=28672`) measured the following steady-state forward times:
+
+| Group size | Scale/zero dtype | Result | Minimum time |
+|---:|---|---|---:|
+| `32` | BF16 | CUTLASS `can_implement` rejects it | n/a |
+| `32` | FP32 | CUTLASS `can_implement` rejects it | n/a |
+| `64` | BF16 | supported | `3.396ms` |
+| `64` | FP32 | supported | `4.352ms` |
+| `128` | BF16 | supported | `3.756ms` |
+| `128` | FP32 | supported | `4.341ms` |
+
+This corrects the earlier interpretation: the official TorchAO path is genuinely much faster than the current Edge quality-safe FC1 (`Q4_K -> FP32 -> TF32 SGEMM`, approximately `5.3-5.8ms` per FC1), and it is the right performance comparison. It is not directly reusable for the existing GGUF weights. Q4_K has eight independent 32-value groups in every 256-value block, with exact decode `q * (d * scale) - (dmin * min)`. Since fbgemm stores signed INT4, its exact rowwise representation requires `group_size=32`, `q_signed=q-8`, `scale=d*scale`, and `zero_point=8*scale-dmin*min`; the stock Hopper kernel rejects that group size even when its scale/zero inputs remain FP32.
+
+Therefore the remaining roughly 10% end-to-end DiT gap is now attributable to a concrete format/kernel incompatibility, not to attention, cuBLAS algorithm selection, or a missed Tensor Core setting. A quality-safe improvement requires a dedicated SM90 mixed-dtype Q4_K kernel (or a modified CUTLASS/fbgemm mainloop that supports exact 32-value groups) plus resident packed Q4_K weights. Re-quantizing 32-value groups into the supported 64/128 format would change weights and is not an acceptable default optimization without a separate full-generation quality evaluation.
+
+### 2026-08-08 SM90 32-group source-level feasibility follow-up
+
+The `group_size=32` rejection is now traced to a specific fbgemm/CUTLASS mainloop restriction, not an undocumented Hopper limitation. In the installed `bf16i4bf16_rowwise` source, `TileShapeK` is `64` for BF16 mixed input. CUTLASS checks `group_size == K || group_size % TileShapeK == 0`; consequently stock `64/128` groups pass while exact Q4_K `32` groups fail.
+
+A throwaway, out-of-tree prototype changed only `TileShapeK` from `64` to `32`. It was compiled for `sm_90a` after first confirming that a plain `sm_90` target cannot issue Hopper GMMA instructions. The valid-target compilation then failed in the CUTLASS mixed-input mainloop with the deliberate assertion `K_BLOCK_MAX >= 4`. This is expected: a 32-value threadblock K tile contains only two BF16 GMMA K-blocks (`16` elements each), while the pipelined mainloop requires at least four for its prefetch/commit schedule.
+
+More importantly, the existing mainloop assumes only one scale/zero row per threadblock K tile. It calculates `reload_factor = ceil(group_size / TileShapeK)`, TMA-loads one scale/zero row for each tile, and `copy_tensors_MK` copies that metadata only when `k_block == 0`. Simply removing the divisibility assertion would therefore silently apply one 32-value Q4_K scale/min to the other 32 values in a 64-value tile; the source explicitly warns that relaxing the related scale-layout assertion without changing transaction accounting can hang.
+
+The correct implementation scope is now concrete:
+
+1. Preserve a practical K tile (`64` or preferably `128`) for Hopper GMMA occupancy.
+2. Extend the mixed-input scale shared-memory layout, TMA transaction bytes, and producer reload logic to load two/four scale-plus-zero rows per K tile.
+3. Select the correct 32-value row inside `dequantize_A_kblock` for each GMMA K-block, while retaining FP32 Q4_K-derived scale/zero values where numerical equivalence requires it.
+4. Add a resident Q4_K-to-rowwise packed-weight cache, including Q4_K's interleaved nibble reorder, so this conversion is not performed per DiT call.
+
+This is a real kernel/mainloop extension rather than a safe one-line fbgemm configuration change. No repository inference code was changed by the prototype. The prototype source/build output lives only under container `/tmp/q4k_g32_proto`; its failed build and the earlier `sm_90` invalid execution are diagnostic only and must not be used as performance or quality data.
+
+### 2026-08-08 Hopper W4A8 group-32 feasibility result
+
+CUTLASS has an upstream mixed-input W4A8 route that is materially closer to GGML MMQ than the Diffusers BF16×W4 route. The official CUTLASS `v3.5.0` Hopper mixed-dtype example was built out of tree for `sm_90a`, then changed exactly as documented by CUTLASS maintainers in issue `#1332`: INT8 activation, INT4 weight, `TileShapeK=32`, and INT32 accumulation/output. It passed the example reference check both on a small shape and on the exact H3 FC1 shape with `group_size=32`:
+
+| Shape (`M x N x K`) | Group size | Result | Average time |
+|---|---:|---|---:|
+| `128 x 512 x 1024` | `32` | passed | `0.0173ms` |
+| `7919 x 28672 x 5376` | `32` | passed | `3.388ms` |
+
+This is important evidence that H200 Hopper hardware and CUTLASS's W4A8 GMMA path can efficiently execute a 32-value group. The stock BF16×W4 fbgemm dispatch rejects 32 only because its BF16 tile-K is 64; its 32-tile experiment is not evidence against the W4A8 route.
+
+It still cannot be substituted for GGML Q4_K MMQ unchanged. The mixed-input collective accepts scale/zero metadata for only the narrow INT4 operand. GGML MMQ has two independently quantized operands for Q4_K projections:
+
+```text
+weight[g, n, k]     = q4[g, n, k] * weight_scale[n, k_group]
+                    - weight_min[n, k_group]
+activation[m, k]    = q8[m, k] * activation_scale[m, k_group]
+```
+
+The product needs both per-output-channel Q4_K scale/min and per-token Q8_1 scale. The existing W4A8 collective can apply the former before INT8 MMA, but has no second activation-side 32-value scale input. Pre-multiplying them is impossible because the required scale product varies across both `m` and `n`; ignoring the activation scale would change the model result. Therefore this benchmark proves a promising kernel foundation and performance target, not a quality-safe drop-in replacement.
+
+The next exact route is a dual-quantized W4A8 Hopper kernel: retain CUTLASS's group-32 W4A8 GMMA pipeline, add an activation `Q8_1` scale stream and accumulate the Q4_K min correction using the activation block sum (which GGML already stores). This directly mirrors GGML's Q4_K×Q8_1 algebra and avoids BF16 re-quantization. It needs an independent CUDA prototype plus numerical comparison against the existing MMQ output before any edge.cpp integration.
+
+### 2026-08-08 W4A8 group-32 semantic caveat
+
+The W4A8 `3.388ms` result is a hardware-throughput feasibility result only, not yet a numerically compatible Q4_K implementation. Reading the v3.5 collective shows that its scale/zero path upcasts narrow INT4 values to the scale type, applies `q * scale + zero`, **then converts the result to the MMA type**. In the maintained W4A8 configuration the MMA type is INT8, so group-scale values are rounded into INT8 before GMMA. Its reference path uses the same conversion and therefore correctly validates that specific integer GEMM, but does not validate the floating-point Q4_K decode used by Edge.
+
+For Q4_K, `d * scale_group` and `dmin * min_group` are FP16-derived floating values and the existing GGML MMQ accumulates their contribution in floating point. Feeding them through the stock W4A8 converter would change the decoded weight before the dot product. This is not acceptable for a default generation path, even though the raw `group=32` GMMA timing is attractive.
+
+The exact custom-kernel requirement is consequently narrower and stricter: use the W4A8 GMMA instruction only for the integer dot product, retain Q4_K and Q8_1 scales/min/sums in FP16/FP32 registers, and apply
+
+```text
+output += activation_scale * (weight_scale * dot_int8_int4 - weight_min * sum_int8)
+```
+
+in floating point for every 32-value group. That is closer to GGML's existing `vec_dot_q8_1_q8_1_mma` algebra than to stock CUTLASS's scale-and-convert collective. No quality claim or speed projection from the stock W4A8 scale path should be used until this exact post-MMA scaling prototype is measured.
+
+### 2026-08-08 actual H3 Q4_K repacking error check
+
+A read-only mmap sample of the actual `blocks.0.mlp.fc1.weight` H3 GGUF tensor (`256 x 5376` values) was decoded with the same Q4_K scale/min and nibble rules as GGML. It was then independently affine-requantized into ordinary unsigned int4 groups. This evaluates the *additional* distortion after the existing Q4_K quantization, not the original BF16-model quantization error.
+
+| Repacked affine group size | Additional weight RMSE | Maximum absolute error | Weight SNR |
+|---:|---:|---:|---:|
+| `32` | `0.00554` | `0.04049` | `27.60dB` |
+| `64` | `0.01098` | `0.04496` | `21.66dB` |
+| `128` | `0.01330` | `0.05068` | `19.99dB` |
+
+The actual sampled Q4_K decoded weights have RMS `0.13290` and range `[-1.0334, 0.9273]`. Even a fresh 32-value ordinary affine representation is not lossless because Q4_K's stored 6-bit superblock scale/min construction is different; the 64/128 representations accepted by stock fbgemm add materially more error.
+
+Conclusion: converting current H3 Q4_K weights into a TorchAO/fbgemm-compatible 64/128-group format is not a responsible default performance optimization. It can only be considered as an explicitly experimental, full-video quality-gated alternative. The quality-safe route remains an exact Q4_K×Q8_1 Hopper kernel with FP16/FP32 post-MMA scale/min handling.
+
+### 2026-08-08 signed-int4 mapping correction and TF32×INT4 check
+
+The fbgemm/CUTLASS `int4b_t` storage was probed directly. It is signed two's-complement INT4: nibble `0..7` decodes to `0..7`, while `8..15` decodes to `-8..-1`. Its affine operation is `signed_q * scale + zero_point` (the zero-point is added, not subtracted).
+
+The exact static Q4_K weight mapping is therefore:
+
+```text
+q_signed   = q4_unsigned - 8
+scale       = d * scale_group
+zero_point  = 8 * scale - dmin * min_group
+weight      = q_signed * scale + zero_point
+```
+
+A GPU probe using the supported fbgemm group-64 path confirmed this mapping; against a BF16-activation FP32 reference, the remaining output RMSE was `0.00858` and is attributable to fbgemm's BF16 output storage, rather than an affine-mapping error. The prior text that stated `zero=dmin*min` was incomplete because it omitted this signed-nibble offset; it is superseded by the formula above.
+
+A second out-of-tree prototype replaced fbgemm's BF16 activation/output types with F32 to look for a fused `TF32×INT4` analogue of the current quality-safe `Q4_K -> F32 -> cublasSgemm` path. It failed at CUTLASS mixed-input layout instantiation before launch. Searching SM90 GMMA definitions shows native integer S8/U8×S8/U8 operations and FP16/BF16/TF32 homogeneous operations, but no Hopper TF32×INT4 GMMA operation. This is a hardware instruction-set boundary rather than a missed cuBLAS setting.
+
+Consequences:
+
+- Stock BF16×INT4 fused kernels can represent Q4_K weights after signed-nibble packing, but necessarily convert the activation/weight computation to BF16 and produce BF16 output; this must remain opt-in until full video quality validation.
+- The current F32/TF32 cuBLAS route remains the quality-safe implementation because Hopper has no direct TF32×INT4 MMA to fuse exact F32 Q4_K decoding into that GEMM.
+- An exact fast path must instead retain the existing Q8_1 integer activation representation and implement Q4_K/Q8_1 scale/min/sum correction around Hopper integer GMMA, as described in the dual-quantized route.
+
+### 2026-08-08 TorchAO W4A8 and Marlin reuse audit
+
+Two additional TorchAO CUDA paths were audited to avoid overlooking an existing dual-scale implementation:
+
+1. `rowwise_scaled_linear_cutlass_s8s4` has an INT32 accumulator and a CUTLASS epilogue visitor that multiplies a per-token FP32 input scale and per-output-channel FP32 weight scale. Its public schema is `input_scale[M]`, `weight_scale[N]`. It has no K-group scale/min dimension, so it cannot express Q4_K's `weight_scale[K_group,N]` or `weight_min[K_group,N]`. The installed `torchao==0.15.0` wheel also omitted its CUDA implementation; its source is useful only as an epilogue-visitor reference.
+
+2. `marlin_qqq_gemm` accepts `s_tok[M]`, `s_ch[N]`, and `s_group[K/group,N]`, which initially appears closer. Its actual checks accept only `group_size=128`; its group dequantization is symmetric INT4 (`q-8`) with a scale only, no per-group zero/min. It uses Ampere-style `mma.m16n8k16` INT8 Tensor Core instructions, not Hopper GMMA. Like the CUTLASS W4A8 group-scale path, it folds the group scale into an integer operand before MMA, so it cannot preserve Q4_K's FP scale/min arithmetic. It is not a quality-safe reuse target.
+
+The exact Q4_K×Q8_1 path therefore has no available stock TorchAO/fbgemm/Marlin operator. It requires a dedicated kernel that uses S8×S8 GMMA to obtain a separate INT32 partial for each 32-value group, then applies the FP correction `activation_scale * (weight_scale * dot - weight_min * sum_q8)` before adding to the FP output accumulator. This is the remaining kernel-design task, not a dispatcher or layout flag.
+
+### 2026-08-08 mid-sequence FC2 TF32 routing experiment
+
+The existing SM90 Q4_K cuBLAS route already uses FP32 decode plus TF32 Tensor Cores for the H3 mid-sequence QKV and FC1 projections. The `n=7919` FC2 projections were intentionally left on exact GGML MMQ because the prior long-sequence FC2 route was quality-sensitive. A new **default-off** diagnostic switch was added:
+
+```text
+GGML_CUDA_SM90_Q4K_CUBLAS_MID_FC2=1
+```
+
+It routes only these two H3 Q4_K shapes through the existing FP32/TF32 cuBLAS path:
+
+```text
+m=5376, n=7919, k=14336
+m=5376, n=7919, k=7168
+```
+
+On the fixed-seed FL2VA probe (`864x480`, 56 frames, 5 steps, cfg=1, four DiT calls), the FC2 matmul timings and end-to-end DiT time improved materially:
+
+| Metric | Current quality-safe route | Mid-FC2 experiment |
+|---|---:|---:|
+| FC2 `k=14336` | MMQ `6.65ms` | FP32/TF32 cuBLAS `3.11ms` |
+| FC2 `k=7168` | MMQ `3.33ms` | FP32/TF32 cuBLAS `1.59ms` |
+| Four-call DiT diffusion | `6.666s` | `5.844s` |
+
+The experimental video is non-black and structurally coherent, but it does **not** satisfy the default quality gate. Decoded fixed-seed frames against the current MMQ-FC2 baseline had mean PSNR `32.70dB`, minimum `25.19dB` (first/middle/last: `44.74/33.72/40.37dB`). The contact comparison is `outputs/minimax-h3/exp-mid-fc2-f32-tf32-56f5s-2026-08-08/contact_sheet_compare.jpg`.
+
+Conclusion: retain the switch solely as a performance diagnostic. Diffusion amplifies the numerical difference between MMQ's exact Q4_K×Q8_1 accumulation and Q4_K-to-FP32 TF32 SGEMM even though both outputs look plausible. Do not enable it by default; the exact integer-GMMA Q4_K route remains the quality-preserving performance path.
+
+### 2026-08-08 mid-sequence FC2 full-task validation
+
+The mid-sequence FC2 experiment was validated on the full FL2VA comparison task, not only the 56-frame smoke task: `864x480`, `124` frames, `20` requested steps / `19` actual forwards, `cfg=1`, seed `42`, VAE tiling off, identical prompt and first/last frames.
+
+The matching Diffusers run was recovered from the **local** source tree shipped alongside the model, rather than downloading source code:
+
+```text
+PYTHONPATH=/models/MiniMax-H3-Diffusers/code/diffusers-main/src
+diffusers source revision: 53e5b00
+```
+
+This is the H3-capable `diffusers 0.40.0.dev0` source. The container-global PyPI package is `diffusers==0.39.0`, which does not contain `MiniMaxH3Transformer3DModel`; no model weight download is required to restore the benchmark environment.
+
+| Path | DiT / transformer time | Calls | Per-call | End-to-end / generation metric |
+|---|---:|---:|---:|---:|
+| Edge Q4_K quality-safe baseline | `62.367s` | `19` | `3.282s` | `85.129s` generation |
+| Edge Q4_K mid-FC2 TF32 experiment | `60.766s` | `19` | `3.198s` | `87.663s` generation |
+| Diffusers TorchAO int4 resident | `55.680s` | `19` | `2.930s` | `61.646s` generate CUDA / `102.121s` process end-to-end |
+
+The experiment improves Edge DiT by `1.601s` (`2.57%`) versus the quality-safe baseline, but remains `5.086s` (`9.14%`) slower than the restored Diffusers resident transformer benchmark. Its full-task decoded-frame comparison against the Edge MMQ-FC2 baseline measured mean PSNR `42.38dB`, minimum `40.69dB`; frames are visually coherent but not numerically equivalent. Artifacts:
+
+- `outputs/minimax-h3/exp-mid-fc2-f32-tf32-124f20s-2026-08-08/final.mp4`
+- `outputs/minimax-h3/exp-mid-fc2-f32-tf32-124f20s-2026-08-08/contact_sheet_compare.jpg`
+- `outputs/minimax-h3/diffusers-fl2va-480p124-int4-resident-profile4-gpu1-2026-08-08/final.json`
+
+Conclusion remains unchanged: the switch is a diagnostic only and must not become the default Q4_K route. It quantifies the maximum gain available from switching the remaining FC2 projections to dequantize-plus-TF32 SGEMM, leaving an exact Q4_K packed kernel as the only route to close the remaining quality-safe gap.
diff --git a/third_party/ggml b/third_party/ggml
index b988216..731488e 160000
--- a/third_party/ggml
+++ b/third_party/ggml
@@ -1 +1 @@
-Subproject commit b98821604f6434d9378eb2745e0f01701b920827
+Subproject commit 731488e405133d7f39a767b4b425f98732ed8eb6

From 7dec884dc22f256335cfc11e80e52945899561cd Mon Sep 17 00:00:00 2001
From: Komorebi623 <wang-ty22@mails.tsinghua.edu.cn>
Date: Sat, 8 Aug 2026 02:15:16 +0800
Subject: [PATCH 06/25] Optimize MiniMax H3 audio VAE decode

---
 CMakeLists.txt                                |   5 +-
 .../minimax-h3-handoff-2026-08-07.md          |  29 +++
 .../run_minimax_h3_fl2va_quantized.py         |  49 +++++
 .../cuDNN/ed_cudnn_conv_transpose_1d.cu       | 178 ++++++++++++++++++
 .../cuDNN/ed_cudnn_conv_transpose_1d.h        |  15 ++
 third_party/ggml                              |   2 +-
 6 files changed, 275 insertions(+), 3 deletions(-)
 create mode 100644 src/core/backend/cuDNN/ed_cudnn_conv_transpose_1d.cu
 create mode 100644 src/core/backend/cuDNN/ed_cudnn_conv_transpose_1d.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1292d29..a646996 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -291,9 +291,10 @@ if(ED_ENABLE_CUDNN_SDPA)
         PRIVATE
             ${CMAKE_CURRENT_SOURCE_DIR}/src/core/backend/cuDNN/ed_cudnn_conv2d.cu
             ${CMAKE_CURRENT_SOURCE_DIR}/src/core/backend/cuDNN/ed_cudnn_conv3d.cu
+            ${CMAKE_CURRENT_SOURCE_DIR}/src/core/backend/cuDNN/ed_cudnn_conv_transpose_1d.cu
             ${CMAKE_CURRENT_SOURCE_DIR}/src/core/backend/cuDNN/ed_cudnn_sdpa.cu
     )
-    target_compile_definitions(ggml-cuda PRIVATE ED_ENABLE_CUDNN_SDPA ED_ENABLE_CUDNN_CONV2D ED_ENABLE_CUDNN_CONV3D)
+    target_compile_definitions(ggml-cuda PRIVATE ED_ENABLE_CUDNN_SDPA ED_ENABLE_CUDNN_CONV2D ED_ENABLE_CUDNN_CONV3D ED_ENABLE_CUDNN_CONV_TRANSPOSE_1D)
     target_include_directories(ggml-cuda
         PRIVATE
             ${CMAKE_CURRENT_SOURCE_DIR}/src/core/backend/cuDNN
@@ -391,7 +392,7 @@ target_compile_definitions(edgedit
 )
 
 if(ED_ENABLE_CUDNN_SDPA)
-    target_compile_definitions(edgedit PRIVATE ED_ENABLE_CUDNN_SDPA ED_ENABLE_CUDNN_CONV2D ED_ENABLE_CUDNN_CONV3D)
+    target_compile_definitions(edgedit PRIVATE ED_ENABLE_CUDNN_SDPA ED_ENABLE_CUDNN_CONV2D ED_ENABLE_CUDNN_CONV3D ED_ENABLE_CUDNN_CONV_TRANSPOSE_1D)
 endif()
 
 if(ED_ENABLE_CUDA_MODULATION AND ED_GGML_CUDA)
diff --git a/docs/optimization/minimax-h3-handoff-2026-08-07.md b/docs/optimization/minimax-h3-handoff-2026-08-07.md
index 8acfcd1..a8a72db 100644
--- a/docs/optimization/minimax-h3-handoff-2026-08-07.md
+++ b/docs/optimization/minimax-h3-handoff-2026-08-07.md
@@ -968,3 +968,32 @@ The experiment improves Edge DiT by `1.601s` (`2.57%`) versus the quality-safe b
 - `outputs/minimax-h3/diffusers-fl2va-480p124-int4-resident-profile4-gpu1-2026-08-08/final.json`
 
 Conclusion remains unchanged: the switch is a diagnostic only and must not become the default Q4_K route. It quantifies the maximum gain available from switching the remaining FC2 projections to dequantize-plus-TF32 SGEMM, leaving an exact Q4_K packed kernel as the only route to close the remaining quality-safe gap.
+
+### 2026-08-08 cuDNN audio VAE transposed-convolution path
+
+The MiniMax-H3 audio VAE's BigVGAN decoder uses seven repeated F32 `ConvTranspose1D` upsampling layers per audio stream. The previous CUDA implementation used one output element per thread and iterated over the input sequence and channels directly. This made audio decode a major end-to-end cost despite the DiT being relatively close to Diffusers.
+
+A guarded cuDNN backward-data-convolution route now maps the supported 1D transposed convolution form to NCHW 2D (`H=1`) and keeps the original CUDA kernel as the fallback. It only accepts contiguous F32 tensors with one group, zero padding, dilation one, and stride greater than one—the exact form used by H3's BigVGAN decoder.
+
+- Build integration: enabled whenever the existing `ED_ENABLE_CUDNN_SDPA` build option is enabled.
+- Runtime switch: `ED_CUDNN_CONV_TRANSPOSE_1D=1`.
+- Default: disabled; unset or `0` always uses the original CUDA kernel.
+- No new third-party dependency: uses the already-linked cuDNN runtime.
+
+Full fixed-seed FL2VA validation used `864x480`, `124` frames, `24fps`, `20` requested steps (`19` DiT forwards), `cfg=1`, seed `42`, VAE tiling off, `--diffusion-fa`, and the first/last images `assets/minimax-h3-ref2va/video-frames/001.png` and `056.png`. Prompt:
+
+```text
+Create a smooth cinematic transition between the supplied first and last frame, preserving the subject, lighting, and composition with natural coherent motion and synchronized ambient audio.
+```
+
+| Variant | Generation | Wall total | Video comparison | Audio comparison |
+|---|---:|---:|---|---|
+| Original CUDA transposed convolution | `85.974s` | `94.626s` | baseline | baseline |
+| cuDNN path (`ED_CUDNN_CONV_TRANSPOSE_1D=1`) | `78.063s` | `86.443s` | PSNR `inf` (pixel-identical decoded frames) | same `331,776` samples; PSNR `48.109dB`, correlation `0.999796` |
+
+This saves `7.911s` generation time (`9.20%`) without changing the generated video frames. The retained artifacts are:
+
+- `outputs/minimax-h3/audio-convt1d-baseline-124f20s-2026-08-08/final.mp4`
+- `outputs/minimax-h3/audio-convt1d-cudnn-124f20s-2026-08-08/final.mp4`
+- `outputs/minimax-h3/audio-convt1d-cudnn-124f20s-2026-08-08/quality/audio-comparison.json`
+- `outputs/minimax-h3/audio-convt1d-cudnn-124f20s-2026-08-08/quality/video-psnr-summary.log`
diff --git a/scripts/diffusers/run_minimax_h3_fl2va_quantized.py b/scripts/diffusers/run_minimax_h3_fl2va_quantized.py
index 6b69a23..15d3c72 100755
--- a/scripts/diffusers/run_minimax_h3_fl2va_quantized.py
+++ b/scripts/diffusers/run_minimax_h3_fl2va_quantized.py
@@ -75,6 +75,11 @@ def main() -> None:
     parser.add_argument("--no-stream-offload", action="store_true")
     parser.add_argument("--resident", action="store_true", help="keep quantized components resident on the CUDA device")
     parser.add_argument("--profile-transformer", action="store_true", help="synchronize and time every transformer forward")
+    parser.add_argument(
+        "--profile-components",
+        action="store_true",
+        help="synchronize and time text encoder and VAE encode/decode calls without changing inference results",
+    )
     arguments = parser.parse_args()
 
     if not torch.cuda.is_available():
@@ -169,10 +174,49 @@ def profile_forward_hook(module, args, kwargs, output):
         pipeline.transformer.register_forward_pre_hook(profile_forward_pre_hook, with_kwargs=True)
         pipeline.transformer.register_forward_hook(profile_forward_hook, with_kwargs=True)
 
+    component_profile = {
+        "text_encoder": {"calls": 0, "seconds": 0.0},
+        "video_vae_encode": {"calls": 0, "seconds": 0.0},
+        "video_vae_decode": {"calls": 0, "seconds": 0.0},
+        "audio_vae_encode": {"calls": 0, "seconds": 0.0},
+        "audio_vae_decode": {"calls": 0, "seconds": 0.0},
+    }
+
+    def profile_method(component_name, method):
+        def wrapped(*args, **kwargs):
+            torch.cuda.synchronize(device)
+            started_at = time.perf_counter()
+            result = method(*args, **kwargs)
+            torch.cuda.synchronize(device)
+            component_profile[component_name]["calls"] += 1
+            component_profile[component_name]["seconds"] += time.perf_counter() - started_at
+            return result
+
+        return wrapped
+
+    if arguments.profile_components:
+        def text_encoder_profile_pre_hook(module, args, kwargs):
+            torch.cuda.synchronize(device)
+            component_profile["text_encoder"]["started_at"] = time.perf_counter()
+
+        def text_encoder_profile_hook(module, args, kwargs, output):
+            torch.cuda.synchronize(device)
+            started_at = component_profile["text_encoder"].pop("started_at")
+            component_profile["text_encoder"]["calls"] += 1
+            component_profile["text_encoder"]["seconds"] += time.perf_counter() - started_at
+
+        pipeline.text_encoder.model.register_forward_pre_hook(text_encoder_profile_pre_hook, with_kwargs=True)
+        pipeline.text_encoder.model.register_forward_hook(text_encoder_profile_hook, with_kwargs=True)
+        pipeline.vae.encode = profile_method("video_vae_encode", pipeline.vae.encode)
+        pipeline.vae.decode = profile_method("video_vae_decode", pipeline.vae.decode)
+        pipeline.audio_vae.encode = profile_method("audio_vae_encode", pipeline.audio_vae.encode)
+        pipeline.audio_vae.decode = profile_method("audio_vae_decode", pipeline.audio_vae.decode)
+
     first_image = load_image(str(arguments.image))
     last_image = load_image(str(arguments.last_image))
     generator = torch.Generator(device="cpu").manual_seed(arguments.seed)
 
+    torch.cuda.reset_peak_memory_stats(device)
     sync_time()
     generated = pipeline(
         prompt=arguments.prompt,
@@ -231,6 +275,11 @@ def profile_forward_hook(module, args, kwargs, output):
             "end_to_end": finished - started,
         },
         "transformer_forward_calls": transformer_profile["calls"],
+        "component_profile": component_profile if arguments.profile_components else None,
+        "memory_bytes": {
+            "max_allocated_during_generate": torch.cuda.max_memory_allocated(device),
+            "max_reserved_during_generate": torch.cuda.max_memory_reserved(device),
+        },
     }
     result_path = arguments.output.with_suffix(".json")
     result_path.write_text(json.dumps(results, ensure_ascii=False, indent=2) + "\n")
diff --git a/src/core/backend/cuDNN/ed_cudnn_conv_transpose_1d.cu b/src/core/backend/cuDNN/ed_cudnn_conv_transpose_1d.cu
new file mode 100644
index 0000000..6d1bd58
--- /dev/null
+++ b/src/core/backend/cuDNN/ed_cudnn_conv_transpose_1d.cu
@@ -0,0 +1,178 @@
+#include "ed_cudnn_conv_transpose_1d.h"
+
+#include <cuda_runtime.h>
+#include <cudnn.h>
+
+#include <cstdlib>
+#include <memory>
+#include <mutex>
+#include <unordered_map>
+
+namespace {
+
+constexpr size_t ED_CUDNN_CONV_TRANSPOSE_1D_MAX_WORKSPACE = 1152ull * 1024ull * 1024ull;
+
+struct workspace_key {
+    int device;
+    cudaStream_t stream;
+    bool operator==(const workspace_key & other) const { return device == other.device && stream == other.stream; }
+};
+
+struct workspace_key_hash {
+    size_t operator()(const workspace_key & key) const {
+        return std::hash<int>()(key.device) ^ (std::hash<uintptr_t>()((uintptr_t) key.stream) << 1);
+    }
+};
+
+struct workspace {
+    int device = 0;
+    void * ptr = nullptr;
+    size_t size = 0;
+    ~workspace() {
+        if (ptr != nullptr) {
+            int previous_device = 0;
+            cudaGetDevice(&previous_device);
+            cudaSetDevice(device);
+            cudaFree(ptr);
+            cudaSetDevice(previous_device);
+        }
+    }
+};
+
+std::mutex g_workspace_mutex;
+std::unordered_map<workspace_key, std::unique_ptr<workspace>, workspace_key_hash> g_workspaces;
+
+static bool enabled() {
+    static const bool value = [] {
+        const char * env = getenv("ED_CUDNN_CONV_TRANSPOSE_1D");
+        return env != nullptr && atoi(env) != 0;
+    }();
+    return value;
+}
+
+static bool contiguous(const ggml_tensor * tensor) {
+    return ggml_is_contiguous(tensor);
+}
+
+static bool supported(const ggml_tensor * dst, int & stride) {
+    if (!enabled() || dst == nullptr || dst->op != GGML_OP_CONV_TRANSPOSE_1D ||
+        dst->src[0] == nullptr || dst->src[1] == nullptr) {
+        return false;
+    }
+    const ggml_tensor * weight = dst->src[0];
+    const ggml_tensor * input = dst->src[1];
+    if (weight->type != GGML_TYPE_F32 || input->type != GGML_TYPE_F32 || dst->type != GGML_TYPE_F32 ||
+        !contiguous(weight) || !contiguous(input) || !contiguous(dst) ||
+        weight->ne[3] != 1 || input->ne[3] != 1 || dst->ne[3] != 1 ||
+        input->ne[1] != weight->ne[2] || dst->ne[1] != weight->ne[1] ||
+        input->ne[2] != dst->ne[2]) {
+        return false;
+    }
+    const int32_t * params = reinterpret_cast<const int32_t *>(dst->op_params);
+    stride = params[0];
+    return stride > 1 && params[1] == 0 && params[2] == 1 &&
+           dst->ne[0] == (input->ne[0] - 1) * stride + weight->ne[0];
+}
+
+static void * get_workspace(int device, cudaStream_t stream, size_t required) {
+    if (required == 0) {
+        return nullptr;
+    }
+    std::lock_guard<std::mutex> lock(g_workspace_mutex);
+    workspace_key key{device, stream};
+    auto & entry = g_workspaces[key];
+    if (!entry) {
+        entry = std::make_unique<workspace>();
+        entry->device = device;
+    }
+    if (entry->size >= required) {
+        return entry->ptr;
+    }
+    void * replacement = nullptr;
+    if (cudaMalloc(&replacement, required) != cudaSuccess) {
+        return nullptr;
+    }
+    cudaFree(entry->ptr);
+    entry->ptr = replacement;
+    entry->size = required;
+    return replacement;
+}
+
+} // namespace
+
+ed_cudnn_conv_transpose_1d_result_t ed_cudnn_conv_transpose_1d_compute(
+        ggml_tensor * dst, ed_cudnn_conv_transpose_1d_stream_t stream_ptr) {
+    int stride = 0;
+    if (!supported(dst, stride)) {
+        return ED_CUDNN_CONV_TRANSPOSE_1D_UNSUPPORTED;
+    }
+
+    const ggml_tensor * weight = dst->src[0];
+    const ggml_tensor * input = dst->src[1];
+    cudaStream_t stream = reinterpret_cast<cudaStream_t>(stream_ptr);
+    int device = 0;
+    if (cudaGetDevice(&device) != cudaSuccess) {
+        return ED_CUDNN_CONV_TRANSPOSE_1D_BUILD_FAILED;
+    }
+
+    cudnnHandle_t handle = nullptr;
+    cudnnTensorDescriptor_t input_desc = nullptr;
+    cudnnTensorDescriptor_t output_desc = nullptr;
+    cudnnFilterDescriptor_t filter_desc = nullptr;
+    cudnnConvolutionDescriptor_t conv_desc = nullptr;
+    auto cleanup = [&] {
+        if (conv_desc) cudnnDestroyConvolutionDescriptor(conv_desc);
+        if (filter_desc) cudnnDestroyFilterDescriptor(filter_desc);
+        if (output_desc) cudnnDestroyTensorDescriptor(output_desc);
+        if (input_desc) cudnnDestroyTensorDescriptor(input_desc);
+        if (handle) cudnnDestroy(handle);
+    };
+    if (cudnnCreate(&handle) != CUDNN_STATUS_SUCCESS || cudnnSetStream(handle, stream) != CUDNN_STATUS_SUCCESS ||
+        cudnnCreateTensorDescriptor(&input_desc) != CUDNN_STATUS_SUCCESS ||
+        cudnnCreateTensorDescriptor(&output_desc) != CUDNN_STATUS_SUCCESS ||
+        cudnnCreateFilterDescriptor(&filter_desc) != CUDNN_STATUS_SUCCESS ||
+        cudnnCreateConvolutionDescriptor(&conv_desc) != CUDNN_STATUS_SUCCESS) {
+        cleanup();
+        return ED_CUDNN_CONV_TRANSPOSE_1D_BUILD_FAILED;
+    }
+
+    const int n = (int) input->ne[2];
+    const int input_channels = (int) input->ne[1];
+    const int output_channels = (int) dst->ne[1];
+    const int input_width = (int) input->ne[0];
+    const int output_width = (int) dst->ne[0];
+    const int kernel_width = (int) weight->ne[0];
+    const int filter_dims[] = {input_channels, output_channels, 1, kernel_width};
+    const int pad[] = {0, 0};
+    const int strides[] = {1, stride};
+    const int dilation[] = {1, 1};
+    if (cudnnSetTensor4dDescriptor(input_desc, CUDNN_TENSOR_NCHW, CUDNN_DATA_FLOAT,
+                                   n, input_channels, 1, input_width) != CUDNN_STATUS_SUCCESS ||
+        cudnnSetTensor4dDescriptor(output_desc, CUDNN_TENSOR_NCHW, CUDNN_DATA_FLOAT,
+                                   n, output_channels, 1, output_width) != CUDNN_STATUS_SUCCESS ||
+        cudnnSetFilterNdDescriptor(filter_desc, CUDNN_DATA_FLOAT, CUDNN_TENSOR_NCHW, 4, filter_dims) != CUDNN_STATUS_SUCCESS ||
+        cudnnSetConvolutionNdDescriptor(conv_desc, 2, pad, strides, dilation, CUDNN_CROSS_CORRELATION, CUDNN_DATA_FLOAT) != CUDNN_STATUS_SUCCESS) {
+        cleanup();
+        return ED_CUDNN_CONV_TRANSPOSE_1D_BUILD_FAILED;
+    }
+
+    int returned = 0;
+    cudnnConvolutionBwdDataAlgoPerf_t perf{};
+    if (cudnnGetConvolutionBackwardDataAlgorithm_v7(handle, filter_desc, input_desc, conv_desc, output_desc, 1, &returned, &perf) != CUDNN_STATUS_SUCCESS ||
+        returned == 0 || perf.status != CUDNN_STATUS_SUCCESS || perf.memory > ED_CUDNN_CONV_TRANSPOSE_1D_MAX_WORKSPACE) {
+        cleanup();
+        return ED_CUDNN_CONV_TRANSPOSE_1D_BUILD_FAILED;
+    }
+    void * scratch = get_workspace(device, stream, perf.memory);
+    if (perf.memory != 0 && scratch == nullptr) {
+        cleanup();
+        return ED_CUDNN_CONV_TRANSPOSE_1D_BUILD_FAILED;
+    }
+    const float alpha = 1.0f;
+    const float beta = 0.0f;
+    const cudnnStatus_t status = cudnnConvolutionBackwardData(handle, &alpha, filter_desc, weight->data,
+                                                               input_desc, input->data, conv_desc, perf.algo,
+                                                               scratch, perf.memory, &beta, output_desc, dst->data);
+    cleanup();
+    return status == CUDNN_STATUS_SUCCESS ? ED_CUDNN_CONV_TRANSPOSE_1D_SUCCESS : ED_CUDNN_CONV_TRANSPOSE_1D_EXECUTE_FAILED;
+}
diff --git a/src/core/backend/cuDNN/ed_cudnn_conv_transpose_1d.h b/src/core/backend/cuDNN/ed_cudnn_conv_transpose_1d.h
new file mode 100644
index 0000000..d3ab594
--- /dev/null
+++ b/src/core/backend/cuDNN/ed_cudnn_conv_transpose_1d.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "ggml.h"
+
+using ed_cudnn_conv_transpose_1d_stream_t = void *;
+
+enum ed_cudnn_conv_transpose_1d_result_t {
+    ED_CUDNN_CONV_TRANSPOSE_1D_SUCCESS = 0,
+    ED_CUDNN_CONV_TRANSPOSE_1D_UNSUPPORTED,
+    ED_CUDNN_CONV_TRANSPOSE_1D_BUILD_FAILED,
+    ED_CUDNN_CONV_TRANSPOSE_1D_EXECUTE_FAILED,
+};
+
+ed_cudnn_conv_transpose_1d_result_t ed_cudnn_conv_transpose_1d_compute(
+    ggml_tensor * dst, ed_cudnn_conv_transpose_1d_stream_t stream);
diff --git a/third_party/ggml b/third_party/ggml
index 731488e..c17c9bd 160000
--- a/third_party/ggml
+++ b/third_party/ggml
@@ -1 +1 @@
-Subproject commit 731488e405133d7f39a767b4b425f98732ed8eb6
+Subproject commit c17c9bdf5cf1a2a5e6149d13f3de34021954b269

From 9abcff5dae74f1a73664e3d6de695c505013a69f Mon Sep 17 00:00:00 2001
From: Komorebi623 <wang-ty22@mails.tsinghua.edu.cn>
Date: Sat, 8 Aug 2026 02:46:31 +0800
Subject: [PATCH 07/25] Add opt-in CUDA Graph support

---
 CMakeLists.txt                                |  4 +++
 .../minimax-h3-handoff-2026-08-07.md          | 25 +++++++++++++++++++
 third_party/ggml                              |  2 +-
 3 files changed, 30 insertions(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index a646996..f472f74 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -29,6 +29,7 @@ option(ED_ENABLE_CUDNN_SDPA "Enable experimental cuDNN SDPA backend for CUDA fla
 option(ED_ENABLE_CUDA_NORM "Enable edge CUDA norm fast paths for ggml CUDA backend" ON)
 option(ED_ENABLE_CUDA_ROPE "Enable edge CUDA RoPE fast paths for ggml CUDA backend" ON)
 option(ED_ENABLE_CUDA_MODULATION "Enable edge CUDA fused modulation fast paths for ggml CUDA backend" ON)
+option(ED_ENABLE_CUDA_GRAPHS "Compile CUDA Graph support for opt-in edge inference" ON)
 option(ED_ENABLE_CUDA_SAGE_ATTN "Enable SageAttention2-style INT8-QK + F16-PV fused attention for ggml CUDA backend" OFF)
 option(ED_ENABLE_PARALLEL "Enable edge-dit lightweight parallel runtime" OFF)
 option(ED_ENABLE_NCCL "Enable NCCL communication backend" OFF)
@@ -254,6 +255,9 @@ if(ED_ENABLE_CUDA_MODULATION AND ED_GGML_CUDA)
 endif()
 
 if(ED_GGML_CUDA)
+    if(ED_ENABLE_CUDA_GRAPHS)
+        set(GGML_CUDA_GRAPHS ON CACHE BOOL "ggml: use CUDA graphs" FORCE)
+    endif()
     find_package(CUDAToolkit REQUIRED)
     target_sources(ggml-cuda
         PRIVATE
diff --git a/docs/optimization/minimax-h3-handoff-2026-08-07.md b/docs/optimization/minimax-h3-handoff-2026-08-07.md
index a8a72db..9d87221 100644
--- a/docs/optimization/minimax-h3-handoff-2026-08-07.md
+++ b/docs/optimization/minimax-h3-handoff-2026-08-07.md
@@ -997,3 +997,28 @@ This saves `7.911s` generation time (`9.20%`) without changing the generated vid
 - `outputs/minimax-h3/audio-convt1d-cudnn-124f20s-2026-08-08/final.mp4`
 - `outputs/minimax-h3/audio-convt1d-cudnn-124f20s-2026-08-08/quality/audio-comparison.json`
 - `outputs/minimax-h3/audio-convt1d-cudnn-124f20s-2026-08-08/quality/video-psnr-summary.log`
+
+### 2026-08-08 opt-in CUDA Graph capture
+
+The CUDA build previously compiled without CUDA Graph support, so repeated H3 video-VAE tile graphs (each `2491` graph nodes) were directly launched for every tile. CUDA Graph support is now compiled by default when `ED_ENABLE_CUDA_GRAPHS=ON`, but remains runtime-disabled unless explicitly requested:
+
+```bash
+ED_CUDA_GRAPHS=1 ed-cli ...
+```
+
+`GGML_CUDA_DISABLE_GRAPHS` remains an emergency override. The runtime gate is global because the backend captures compatible graph executions, not a model-specific arithmetic path. It does not alter weights, operators, numerical precision, or sampling.
+
+A full FL2VA comparison used the same configuration as the cuDNN audio-VAE validation: `864x480`, 124 frames, 24fps, 20 requested steps / 19 DiT forwards, cfg `1`, seed `42`, VAE tiling on, `--diffusion-fa`, and `ED_CUDNN_CONV_TRANSPOSE_1D=1` in both variants.
+
+| Variant | Generation | Wall total | Video | Audio |
+|---|---:|---:|---|---|
+| CUDA Graph runtime disabled | `78.063s` | `86.443s` | baseline | baseline |
+| `ED_CUDA_GRAPHS=1` | `77.881s` | `86.504s` | PSNR `inf` | exact waveform (PSNR `inf`) |
+
+The path is numerically exact on this task, but the end-to-end win is only `0.182s` (`0.23%`). It is retained as an independent opt-in scheduling control rather than enabled by default. The repeated VAE tile graph did capture and replay successfully; the limited end-to-end result means the primary remaining gap is compute, not launch overhead.
+
+Artifacts:
+
+- `outputs/minimax-h3/cuda-graphs-124f20s-2026-08-08/final.mp4`
+- `outputs/minimax-h3/cuda-graphs-124f20s-2026-08-08/quality/video-psnr-summary.log`
+- `outputs/minimax-h3/cuda-graphs-124f20s-2026-08-08/quality/audio-comparison.json`
diff --git a/third_party/ggml b/third_party/ggml
index c17c9bd..cac93ee 160000
--- a/third_party/ggml
+++ b/third_party/ggml
@@ -1 +1 @@
-Subproject commit c17c9bdf5cf1a2a5e6149d13f3de34021954b269
+Subproject commit cac93ee079478004b5c9abbb8f081b401f6a46ac

From 783af5798933ce828c1dbc8b7f2e3356dc4e5318 Mon Sep 17 00:00:00 2001
From: Komorebi623 <wang-ty22@mails.tsinghua.edu.cn>
Date: Sat, 8 Aug 2026 03:10:01 +0800
Subject: [PATCH 08/25] Optimize MiniMax H3 video postprocess

---
 .../minimax-h3-handoff-2026-08-07.md          | 33 +++++++++++++++
 .../pipelines/minimax_h3_pipeline.cpp         | 40 +++++++++++++++----
 2 files changed, 65 insertions(+), 8 deletions(-)

diff --git a/docs/optimization/minimax-h3-handoff-2026-08-07.md b/docs/optimization/minimax-h3-handoff-2026-08-07.md
index 9d87221..76a9de1 100644
--- a/docs/optimization/minimax-h3-handoff-2026-08-07.md
+++ b/docs/optimization/minimax-h3-handoff-2026-08-07.md
@@ -1022,3 +1022,36 @@ Artifacts:
 - `outputs/minimax-h3/cuda-graphs-124f20s-2026-08-08/final.mp4`
 - `outputs/minimax-h3/cuda-graphs-124f20s-2026-08-08/quality/video-psnr-summary.log`
 - `outputs/minimax-h3/cuda-graphs-124f20s-2026-08-08/quality/audio-comparison.json`
+
+### 2026-08-08 opt-in H3 video output postprocess fast path
+
+MiniMax-H3 video decode returns a contiguous host `Tensor<float>` in `[width, height, frames, channels, batch]` storage order. The original final conversion loop used `Tensor::index(...)` for every output channel, constructing and bounds-checking an index vector per value. This is outside the VAE math but was a measurable end-to-end CPU postprocess cost at 480p.
+
+The guarded fast path reads the equivalent contiguous offset directly while retaining the existing float clamp and `round(... * 255)` conversion. It is disabled by default:
+
+```bash
+ED_MINIMAX_H3_FAST_VIDEO_POSTPROCESS=1 ed-cli ...
+```
+
+For debugging the direct offset can be checked against every original `Tensor::index(...)` lookup during a run:
+
+```bash
+ED_MINIMAX_H3_FAST_VIDEO_POSTPROCESS=1 \
+ED_MINIMAX_H3_VERIFY_FAST_VIDEO_POSTPROCESS=1 ed-cli ...
+```
+
+The verification run completed without an assertion, establishing that the two paths read identical source floats. The full FL2VA validation used the same fixed task as the current performance baseline: `864x480`, `124` frames, `24fps`, `20` requested steps (`19` DiT forwards), cfg `1`, seed `42`, first/last frames `001.png`/`056.png`, `--diffusion-fa`, `GGML_CUDA_SM90_Q4K_CUBLAS=1`, and `ED_CUDNN_CONV_TRANSPOSE_1D=1`.
+
+| Variant | Generation | DiT | Video VAE | Video conversion | Video quality | Audio quality |
+|---|---:|---:|---:|---:|---|---|
+| Original conversion | `77.629s` | `62.454s` | `10.886s` | `1.960s` | baseline | baseline |
+| Fast conversion | `78.417s` | `62.307s` | `12.683s` | `1.048s` | PSNR `inf` | PCM exact, PSNR `inf` |
+
+The VAE phase has normal run-to-run variation (the second run was about `1.8s` slower in VAE compute), so the isolated conversion measurement is the relevant result: `0.912s` saved for this full task (`46.5%` of conversion time). The decoded 124-frame videos are pixel-identical, and decoded audio contains `331,776` identical samples. This does not affect GPU memory or model arithmetic.
+
+Artifacts are intentionally local and ignored by Git:
+
+- `outputs/minimax-h3/fast-video-postprocess-full-124f20s-2026-08-08/baseline/final.mp4`
+- `outputs/minimax-h3/fast-video-postprocess-full-124f20s-2026-08-08/fast/final.mp4`
+- `outputs/minimax-h3/fast-video-postprocess-full-124f20s-2026-08-08/quality/video-psnr-summary.log`
+- `outputs/minimax-h3/fast-video-postprocess-full-124f20s-2026-08-08/quality/audio-comparison.json`
diff --git a/src/dit_models/pipelines/minimax_h3_pipeline.cpp b/src/dit_models/pipelines/minimax_h3_pipeline.cpp
index c8215a1..a0d9041 100644
--- a/src/dit_models/pipelines/minimax_h3_pipeline.cpp
+++ b/src/dit_models/pipelines/minimax_h3_pipeline.cpp
@@ -111,6 +111,16 @@ bool h3_profile_enabled() {
     return value != nullptr && value[0] != '\0' && std::strcmp(value, "0") != 0;
 }
 
+bool h3_fast_video_postprocess_enabled() {
+    const char* value = std::getenv("ED_MINIMAX_H3_FAST_VIDEO_POSTPROCESS");
+    return value != nullptr && value[0] != '\0' && std::strcmp(value, "0") != 0;
+}
+
+bool h3_verify_fast_video_postprocess_enabled() {
+    const char* value = std::getenv("ED_MINIMAX_H3_VERIFY_FAST_VIDEO_POSTPROCESS");
+    return value != nullptr && value[0] != '\0' && std::strcmp(value, "0") != 0;
+}
+
 void h3_trace_tensor(const char* name, const sd::Tensor<float>& tensor) {
     if (!h3_trace_enabled()) {
         return;
@@ -607,6 +617,9 @@ ed_status_t MiniMaxH3Pipeline::decode_video_latent(const sd::Tensor<float>& late
     const size_t channels = static_cast<size_t>(video.shape()[3]);
     const size_t pixels = width * height;
     const int64_t postprocess_begin = profile != nullptr ? ggml_time_ms() : 0;
+    const bool fast_postprocess = h3_fast_video_postprocess_enabled();
+    const bool verify_fast_postprocess = fast_postprocess && h3_verify_fast_video_postprocess_enabled();
+    const float* video_data     = video.data();
     for (int frame = 0; frame < frames_count; ++frame) {
         frames[frame].width = static_cast<int>(width);
         frames[frame].height = static_cast<int>(height);
@@ -618,14 +631,25 @@ ed_status_t MiniMaxH3Pipeline::decode_video_latent(const sd::Tensor<float>& late
             set_minimax_error(error, "failed to allocate MiniMax-H3 frame pixels");
             return ED_STATUS_OUT_OF_MEMORY;
         }
-        for (size_t pixel = 0; pixel < pixels; ++pixel) {
-            for (size_t channel = 0; channel < channels; ++channel) {
-                frames[frame].data[pixel * channels + channel] =
-                    h3_to_u8(video.index(pixel % width,
-                                         pixel / width,
-                                         std::min(frame, decoded_frames - 1),
-                                         channel,
-                                         0));
+        const int source_frame = std::min(frame, decoded_frames - 1);
+        if (fast_postprocess) {
+            for (size_t pixel = 0; pixel < pixels; ++pixel) {
+                const size_t x = pixel % width;
+                const size_t y = pixel / width;
+                for (size_t channel = 0; channel < channels; ++channel) {
+                    const size_t offset = x + width * (y + height * (source_frame + decoded_frames * channel));
+                    if (verify_fast_postprocess) {
+                        GGML_ASSERT(video_data[offset] == video.index(x, y, source_frame, channel, 0));
+                    }
+                    frames[frame].data[pixel * channels + channel] = h3_to_u8(video_data[offset]);
+                }
+            }
+        } else {
+            for (size_t pixel = 0; pixel < pixels; ++pixel) {
+                for (size_t channel = 0; channel < channels; ++channel) {
+                    frames[frame].data[pixel * channels + channel] =
+                        h3_to_u8(video.index(pixel % width, pixel / width, source_frame, channel, 0));
+                }
             }
         }
     }

From c8e2e70e2924f2eeb430fd1c5bc10f678498c6cc Mon Sep 17 00:00:00 2001
From: Komorebi623 <wang-ty22@mails.tsinghua.edu.cn>
Date: Sat, 8 Aug 2026 03:14:00 +0800
Subject: [PATCH 09/25] Parallelize MiniMax H3 video conversion

---
 .../minimax-h3-handoff-2026-08-07.md          | 27 ++++++++++++++
 .../pipelines/minimax_h3_pipeline.cpp         | 36 +++++++++++++++++++
 2 files changed, 63 insertions(+)

diff --git a/docs/optimization/minimax-h3-handoff-2026-08-07.md b/docs/optimization/minimax-h3-handoff-2026-08-07.md
index 76a9de1..c8c144a 100644
--- a/docs/optimization/minimax-h3-handoff-2026-08-07.md
+++ b/docs/optimization/minimax-h3-handoff-2026-08-07.md
@@ -1055,3 +1055,30 @@ Artifacts are intentionally local and ignored by Git:
 - `outputs/minimax-h3/fast-video-postprocess-full-124f20s-2026-08-08/fast/final.mp4`
 - `outputs/minimax-h3/fast-video-postprocess-full-124f20s-2026-08-08/quality/video-psnr-summary.log`
 - `outputs/minimax-h3/fast-video-postprocess-full-124f20s-2026-08-08/quality/audio-comparison.json`
+
+### 2026-08-08 opt-in parallel H3 video output conversion
+
+The direct H3 output conversion path above can now parallelize independent decoded frames. It is only activated after the direct-offset path is explicitly enabled, and is otherwise absent from the normal execution path:
+
+```bash
+ED_MINIMAX_H3_FAST_VIDEO_POSTPROCESS=1 \
+ED_MINIMAX_H3_FAST_VIDEO_POSTPROCESS_THREADS=8 ed-cli ...
+```
+
+The thread count is bounded by the number of output frames; unset, invalid, or `1` leaves the single-threaded direct-offset path in use. Worker threads only read the decoded host float tensor and write their own `ed_image_t` frame allocation, so it neither changes model arithmetic nor allocates GPU memory.
+
+The full fixed-seed FL2VA validation used the same `864x480`, 124-frame, 20-step/cfg-1 task and runtime options as the direct-offset validation. The comparison uses the single-thread direct-offset run as the reference:
+
+| Variant | Generation | DiT | Video VAE | Video conversion | Video quality | Audio quality |
+|---|---:|---:|---:|---:|---|---|
+| Single-thread direct conversion | `78.417s` | `62.307s` | `12.683s` | `1.048s` | baseline | baseline |
+| Parallel direct conversion (`8` threads) | `75.420s` | `62.173s` | `10.813s` | `0.119s` | PSNR `inf` | PCM exact |
+
+The conversion phase improves by `0.929s` (`88.6%`) compared to the already optimized single-thread path and by `1.841s` compared to the original indexed path. The complete run was additionally faster by `2.997s`, though only the conversion saving should be attributed to this change because video-VAE timing varies modestly between cold model loads. Decoded video has infinite PSNR for all 124 frames and the `331,776` decoded audio samples match byte-for-byte.
+
+Artifacts:
+
+- `outputs/minimax-h3/parallel-video-postprocess-full-124f20s-2026-08-08/parallel/final.mp4`
+- `outputs/minimax-h3/parallel-video-postprocess-full-124f20s-2026-08-08/quality/video-psnr-summary.log`
+- `outputs/minimax-h3/parallel-video-postprocess-full-124f20s-2026-08-08/quality/serial.f32le`
+- `outputs/minimax-h3/parallel-video-postprocess-full-124f20s-2026-08-08/quality/parallel.f32le`
diff --git a/src/dit_models/pipelines/minimax_h3_pipeline.cpp b/src/dit_models/pipelines/minimax_h3_pipeline.cpp
index a0d9041..a49e855 100644
--- a/src/dit_models/pipelines/minimax_h3_pipeline.cpp
+++ b/src/dit_models/pipelines/minimax_h3_pipeline.cpp
@@ -9,6 +9,8 @@
 #include <iomanip>
 #include <set>
 #include <sstream>
+#include <thread>
+#include <vector>
 
 #include "dit_models/diffusion_model.hpp"
 #include "dit_models/components/autoencoders/minimax_h3_vae.hpp"
@@ -121,6 +123,18 @@ bool h3_verify_fast_video_postprocess_enabled() {
     return value != nullptr && value[0] != '\0' && std::strcmp(value, "0") != 0;
 }
 
+int h3_fast_video_postprocess_threads() {
+    const char* value = std::getenv("ED_MINIMAX_H3_FAST_VIDEO_POSTPROCESS_THREADS");
+    if (value == nullptr || value[0] == '\0') {
+        return 0;
+    }
+    char* end = nullptr;
+    const long requested = std::strtol(value, &end, 10);
+    return end != value && requested > 1 && requested <= std::numeric_limits<int>::max()
+               ? static_cast<int>(requested)
+               : 0;
+}
+
 void h3_trace_tensor(const char* name, const sd::Tensor<float>& tensor) {
     if (!h3_trace_enabled()) {
         return;
@@ -631,6 +645,8 @@ ed_status_t MiniMaxH3Pipeline::decode_video_latent(const sd::Tensor<float>& late
             set_minimax_error(error, "failed to allocate MiniMax-H3 frame pixels");
             return ED_STATUS_OUT_OF_MEMORY;
         }
+    }
+    auto convert_frame = [&](int frame) {
         const int source_frame = std::min(frame, decoded_frames - 1);
         if (fast_postprocess) {
             for (size_t pixel = 0; pixel < pixels; ++pixel) {
@@ -652,6 +668,26 @@ ed_status_t MiniMaxH3Pipeline::decode_video_latent(const sd::Tensor<float>& late
                 }
             }
         }
+    };
+    const int requested_threads = fast_postprocess ? h3_fast_video_postprocess_threads() : 0;
+    const int conversion_threads = std::min(frames_count, requested_threads);
+    if (conversion_threads > 1) {
+        std::vector<std::thread> workers;
+        workers.reserve(static_cast<size_t>(conversion_threads));
+        for (int worker = 0; worker < conversion_threads; ++worker) {
+            workers.emplace_back([&, worker]() {
+                for (int frame = worker; frame < frames_count; frame += conversion_threads) {
+                    convert_frame(frame);
+                }
+            });
+        }
+        for (std::thread& worker : workers) {
+            worker.join();
+        }
+    } else {
+        for (int frame = 0; frame < frames_count; ++frame) {
+            convert_frame(frame);
+        }
     }
     out->frames = frames;
     out->frame_count = frames_count;

From 230b302ba2a57a86b6cc3f17741da1fd617dc6a4 Mon Sep 17 00:00:00 2001
From: Komorebi623 <wang-ty22@mails.tsinghua.edu.cn>
Date: Sat, 8 Aug 2026 03:19:24 +0800
Subject: [PATCH 10/25] Optimize MiniMax H3 temporal VAE assembly

---
 .../minimax-h3-handoff-2026-08-07.md          | 26 +++++++++
 .../autoencoders/minimax_h3_vae.hpp           | 53 +++++++++++++++++--
 2 files changed, 76 insertions(+), 3 deletions(-)

diff --git a/docs/optimization/minimax-h3-handoff-2026-08-07.md b/docs/optimization/minimax-h3-handoff-2026-08-07.md
index c8c144a..c89a852 100644
--- a/docs/optimization/minimax-h3-handoff-2026-08-07.md
+++ b/docs/optimization/minimax-h3-handoff-2026-08-07.md
@@ -1082,3 +1082,29 @@ Artifacts:
 - `outputs/minimax-h3/parallel-video-postprocess-full-124f20s-2026-08-08/quality/video-psnr-summary.log`
 - `outputs/minimax-h3/parallel-video-postprocess-full-124f20s-2026-08-08/quality/serial.f32le`
 - `outputs/minimax-h3/parallel-video-postprocess-full-124f20s-2026-08-08/quality/parallel.f32le`
+
+### 2026-08-08 opt-in H3 temporal VAE-part collection
+
+H3 video decoding processes long videos in overlapping five-latent-token chunks. The historical code appended every decoded chunk with `sd::ops::concat`, which reallocates and recopies all already-collected full-resolution frames on every append. A guarded alternative accumulates the unchanged per-chunk tensors and performs one final temporal allocation/copy:
+
+```bash
+ED_MINIMAX_H3_COLLECT_TEMPORAL_PARTS=1 ed-cli ...
+```
+
+The default stays on the original append behavior. The alternative retains the same VAE chunks, overlap blend loop, first/last segment handling, and final frame crop; it only changes host tensor ownership and copies. It composes with the independent parallel output conversion switch, which was enabled in both full-task variants.
+
+The full 124-frame fixed-seed FL2VA validation compared it against the accepted parallel-output baseline:
+
+| Variant | Generation | DiT | Video VAE | Video conversion | Video quality | Audio quality |
+|---|---:|---:|---:|---:|---|---|
+| Original temporal appends | `75.420s` | `62.173s` | `10.813s` | `0.119s` | baseline | baseline |
+| Collected temporal parts | `74.875s` | `62.131s` | `10.324s` | `0.121s` | PSNR `inf` | PCM exact |
+
+The measured VAE-stage difference is `0.489s`; because VAE GPU timing has modest cold-run variation, treat this as a low-risk reduction in host copying rather than a guaranteed GPU compute gain. All 124 decoded frames compare at infinite PSNR and all `331,776` audio samples are byte-identical. The change does not affect GPU memory requirements or model arithmetic.
+
+Artifacts:
+
+- `outputs/minimax-h3/collect-temporal-parts-full-124f20s-2026-08-08/collect/final.mp4`
+- `outputs/minimax-h3/collect-temporal-parts-full-124f20s-2026-08-08/quality/video-psnr-summary.log`
+- `outputs/minimax-h3/collect-temporal-parts-full-124f20s-2026-08-08/quality/reference.f32le`
+- `outputs/minimax-h3/collect-temporal-parts-full-124f20s-2026-08-08/quality/collect.f32le`
diff --git a/src/dit_models/components/autoencoders/minimax_h3_vae.hpp b/src/dit_models/components/autoencoders/minimax_h3_vae.hpp
index 0e5368b..f3bb7e0 100644
--- a/src/dit_models/components/autoencoders/minimax_h3_vae.hpp
+++ b/src/dit_models/components/autoencoders/minimax_h3_vae.hpp
@@ -4,6 +4,8 @@
 #include <algorithm>
 #include <array>
 #include <cmath>
+#include <cstdlib>
+#include <cstring>
 #include <memory>
 #include <string>
 #include <tuple>
@@ -18,6 +20,11 @@ namespace MiniMaxH3VAE {
 
     constexpr int H3_VIDEO_VAE_GRAPH_SIZE = 262144;
 
+    static bool h3_env_flag_enabled(const char* name) {
+        const char* value = std::getenv(name);
+        return value != nullptr && value[0] != '\0' && std::strcmp(value, "0") != 0;
+    }
+
     struct CausalConv3d : public Conv3d {
         std::tuple<int, int, int> temporal_padding;
 
@@ -600,6 +607,29 @@ namespace MiniMaxH3VAE {
             return output;
         }
 
+        static sd::Tensor<float> concatenate_temporal_parts(const std::vector<sd::Tensor<float>>& parts) {
+            GGML_ASSERT(!parts.empty());
+            std::vector<int64_t> shape = parts.front().shape();
+            int64_t total_frames       = 0;
+            for (const auto& part : parts) {
+                GGML_ASSERT(part.dim() == static_cast<int64_t>(shape.size()));
+                for (size_t dim = 0; dim < shape.size(); ++dim) {
+                    if (dim != 2) {
+                        GGML_ASSERT(part.shape()[dim] == shape[dim]);
+                    }
+                }
+                total_frames += part.shape()[2];
+            }
+            shape[2] = total_frames;
+            sd::Tensor<float> result(shape);
+            int64_t offset = 0;
+            for (const auto& part : parts) {
+                sd::ops::slice_assign(&result, 2, offset, offset + part.shape()[2], part);
+                offset += part.shape()[2];
+            }
+            return result;
+        }
+
         sd::Tensor<float> encode(int n_threads,
                                  const sd::Tensor<float>& x,
                                  ed_tiling_params_t tiling_params,
@@ -686,7 +716,12 @@ namespace MiniMaxH3VAE {
                 input = repeat_last_frame(input, pad_tokens);
             }
 
+            const bool collect_temporal_parts = h3_env_flag_enabled("ED_MINIMAX_H3_COLLECT_TEMPORAL_PARTS");
             sd::Tensor<float> result;
+            std::vector<sd::Tensor<float>> temporal_parts;
+            if (collect_temporal_parts) {
+                temporal_parts.reserve(static_cast<size_t>(num_chunks + 1));
+            }
             sd::Tensor<float> overlap;
             for (int64_t i = 0; i < num_chunks; ++i) {
                 int64_t start = i * tokens_per_chunk;
@@ -713,8 +748,12 @@ namespace MiniMaxH3VAE {
                     first   = blend_temporal(overlap, first, frame_overlap);
                     overlap = {};
                 }
-                result = result.empty() ? std::move(first)
-                                        : sd::ops::concat(result, first, 2);
+                if (collect_temporal_parts) {
+                    temporal_parts.push_back(std::move(first));
+                } else {
+                    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,
@@ -723,11 +762,19 @@ namespace MiniMaxH3VAE {
                                              decoded.shape()[2]);
                 }
                 if (i == num_chunks - 1 && !overlap.empty()) {
-                    result  = sd::ops::concat(result, overlap, 2);
+                    if (collect_temporal_parts) {
+                        temporal_parts.push_back(std::move(overlap));
+                    } else {
+                        result = sd::ops::concat(result, overlap, 2);
+                    }
                     overlap = {};
                 }
             }
 
+            if (collect_temporal_parts) {
+                result = concatenate_temporal_parts(temporal_parts);
+            }
+
             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) {

From b48a229b22235b58a899b8cadb8875394abce410 Mon Sep 17 00:00:00 2001
From: Komorebi623 <wang-ty22@mails.tsinghua.edu.cn>
Date: Sat, 8 Aug 2026 04:01:17 +0800
Subject: [PATCH 11/25] Document MiniMax H3 VAE optimization audit

---
 .../minimax-h3-handoff-2026-08-07.md          | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/docs/optimization/minimax-h3-handoff-2026-08-07.md b/docs/optimization/minimax-h3-handoff-2026-08-07.md
index c89a852..8b5d12d 100644
--- a/docs/optimization/minimax-h3-handoff-2026-08-07.md
+++ b/docs/optimization/minimax-h3-handoff-2026-08-07.md
@@ -1108,3 +1108,36 @@ Artifacts:
 - `outputs/minimax-h3/collect-temporal-parts-full-124f20s-2026-08-08/quality/video-psnr-summary.log`
 - `outputs/minimax-h3/collect-temporal-parts-full-124f20s-2026-08-08/quality/reference.f32le`
 - `outputs/minimax-h3/collect-temporal-parts-full-124f20s-2026-08-08/quality/collect.f32le`
+
+### 2026-08-08 rejected H3 VAE batching and decoder-layout experiments
+
+After the accepted output-copy and temporal-part collection work, a fresh GPU phase profile was taken on the fixed FL2VA task (`864x480`, 56 frames, 5 requested steps / 4 DiT calls, cfg `1`, seed `42`, first/last `assets/minimax-h3-ref2va/video-frames/001.png` and `056.png`). The accepted runtime options were `GGML_CUDA_SM90_Q4K_CUBLAS=1`, `ED_CUDNN_CONV_TRANSPOSE_1D=1`, `ED_MINIMAX_H3_FAST_VIDEO_POSTPROCESS=1`, `ED_MINIMAX_H3_FAST_VIDEO_POSTPROCESS_THREADS=8`, and `ED_MINIMAX_H3_COLLECT_TEMPORAL_PARTS=1`.
+
+The profile confirms that text encoding is not a useful target for this cfg-1 workload (`~100ms` versus Diffusers' roughly `0.6s`), and audio output copying is negligible (`2-3ms`). The short run spent about `4.3-4.7s` in video VAE decode and `~0.58s` in audio VAE decode. A CUDA op profile of the repeated decoder tiles found that each warm tile spends roughly `31ms` in layout conversions, `17.5ms` in Flash Attention, `3.8ms` in normalization, and `6.6ms` in other elementwise work. The encoder graph is instead dominated by `IM2COL_3D` / GEMM. Therefore future VAE work should focus on the decoder's required attention layout or a quality-equivalent 3D convolution path, rather than audio/video host copies.
+
+Four runtime-guarded experiments were evaluated and all source changes were reverted because they either violated the quality gate or did not improve the full task:
+
+| Experiment | Runtime switch | Short result | Full result / disposition |
+|---|---|---|---|
+| Batch stereo BigVGAN streams | `ED_MINIMAX_H3_AUDIO_BATCH_STREAMS=1` | Audio PSNR `21.13dB`, correlation `0.9789` | Rejected for audio divergence. |
+| Batch temporal GroupNorm over time | `ED_MINIMAX_H3_BATCH_TEMPORAL_GROUP_NORM=1` | Video min PSNR `35.66dB`; audio PSNR `17.86dB` | Rejected: changing the CUDA reduction batch changes diffusion output. |
+| Balanced temporal GroupNorm concat tree | `ED_MINIMAX_H3_BALANCED_TEMPORAL_GROUP_NORM_CONCAT=1` | Video/audio exact, but video VAE `4.315s -> 4.820s` | Rejected: no speed benefit. |
+| `pad_reflect_1d` for CausalConv3D width reflection | `ED_MINIMAX_H3_USE_PAD_REFLECT_1D=1` | Video/audio exact, but video VAE `4.315s -> 4.408s` | Rejected: no speed benefit. |
+
+A fifth quality-safe experiment exposed the largest decoder-layout conversion: decoder FFN `w1` chunks materialize two `8192 x 1797` F32 halves on every one of 36 blocks. `ED_MINIMAX_H3_DECODER_FFN_VIEW_CHUNKS=1` kept those chunks as strided views. The 56-frame run was bit-exact and appeared faster (`4.548s -> 4.168s` video VAE), but the required full 124-frame / 20-step validation was slower:
+
+| Variant | Total | DiT (19 calls) | Video VAE | Video | Audio |
+|---|---:|---:|---:|---|---|
+| Baseline | `75.197s` | `62.214s` | `10.486s` | baseline | baseline |
+| FFN view chunks | `76.718s` | `62.385s` | `11.811s` | all `124` decoded frames exact | `331,776` PCM samples exact |
+
+The view-chunk source change was also reverted. The likely reason is that later SiLU/multiply/linear kernels pay a non-contiguous-stride cost larger than the removed explicit copies. Do not re-enable or reimplement it without testing the full 124-frame task.
+
+Retained local artifacts (Git-ignored):
+
+- `outputs/minimax-h3/profile-video-vae-ops-56f5s-2026-08-08/run.log`
+- `outputs/minimax-h3/audio-batch-streams-56f5s-2026-08-08/`
+- `outputs/minimax-h3/batch-temporal-group-norm-56f5s-2026-08-08/`
+- `outputs/minimax-h3/balanced-temporal-group-norm-concat-56f5s-2026-08-08/`
+- `outputs/minimax-h3/pad-reflect-1d-56f5s-2026-08-08/`
+- `outputs/minimax-h3/decoder-ffn-view-chunks-full-124f20s-2026-08-08/`

From 2f74ed70638518094860f5fe6f6f14885ca6ceef Mon Sep 17 00:00:00 2001
From: Komorebi623 <wang-ty22@mails.tsinghua.edu.cn>
Date: Sat, 8 Aug 2026 04:07:05 +0800
Subject: [PATCH 12/25] Document H3 decoder QKV layout constraint

---
 docs/optimization/minimax-h3-handoff-2026-08-07.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/docs/optimization/minimax-h3-handoff-2026-08-07.md b/docs/optimization/minimax-h3-handoff-2026-08-07.md
index 8b5d12d..450ce21 100644
--- a/docs/optimization/minimax-h3-handoff-2026-08-07.md
+++ b/docs/optimization/minimax-h3-handoff-2026-08-07.md
@@ -1141,3 +1141,7 @@ Retained local artifacts (Git-ignored):
 - `outputs/minimax-h3/balanced-temporal-group-norm-concat-56f5s-2026-08-08/`
 - `outputs/minimax-h3/pad-reflect-1d-56f5s-2026-08-08/`
 - `outputs/minimax-h3/decoder-ffn-view-chunks-full-124f20s-2026-08-08/`
+
+### 2026-08-08 rejected H3 decoder QKV view attempt
+
+The decoder-tile CUDA profile showed `108` Q/K/V chunk materializations per tile (`64x32x1797` F32), about `4.8ms` per warm tile. A default-off `ED_MINIMAX_H3_DECODER_QKV_VIEW_CHUNKS=1` prototype was built to retain the three chunks as views. It cannot pass graph construction: `DecoderAttention` immediately reshapes each chunk from the packed QKV layout, and `ggml_reshape_4d` requires contiguous storage. The run aborts before output generation at that reshape. The source change was reverted; this is a structural layout requirement of the current Flash Attention input representation, not removable materialization.

From 345561aacbdaf8b34f1f2f203546b760ea9bec7a Mon Sep 17 00:00:00 2001
From: Komorebi623 <wang-ty22@mails.tsinghua.edu.cn>
Date: Sun, 9 Aug 2026 11:33:19 +0800
Subject: [PATCH 13/25] Optimize MiniMax H3 generation performance

---
 ...-edge-generation-performance-2026-08-09.md | 542 ++++++++++++++++++
 src/core/backend/cuDNN/ed_cudnn_sdpa.cu       |  16 +-
 .../backend/ggml/cuda/ed_cuda_modulation.cu   | 146 ++---
 .../backend/ggml/ed_ggml_modulation_ext.hpp   |  10 +-
 src/core/backend/ggml/ggml_extend.hpp         | 255 +++++++-
 .../autoencoders/minimax_h3_audio_vae.hpp     |  36 +-
 .../autoencoders/minimax_h3_vae.hpp           | 288 +++++++++-
 src/dit_models/models/minimax_h3_full.hpp     | 122 +++-
 .../pipelines/minimax_h3_pipeline.cpp         | 280 +++++++--
 .../pipelines/minimax_h3_pipeline.hpp         |   4 +
 third_party/ggml                              |   2 +-
 11 files changed, 1525 insertions(+), 176 deletions(-)
 create mode 100644 docs/optimization/minimax-h3-edge-generation-performance-2026-08-09.md

diff --git a/docs/optimization/minimax-h3-edge-generation-performance-2026-08-09.md b/docs/optimization/minimax-h3-edge-generation-performance-2026-08-09.md
new file mode 100644
index 0000000..18f4f59
--- /dev/null
+++ b/docs/optimization/minimax-h3-edge-generation-performance-2026-08-09.md
@@ -0,0 +1,542 @@
+# MiniMax-H3 Edge Generation Performance Baseline — 2026-08-09
+
+This document preserves the baseline and optimization context for the MiniMax-H3 Edge generation performance work planned for the evening of 2026-08-09.
+
+## Primary objective
+
+Reduce Edge's resident/warm video generation time while preserving the current output quality. The primary comparison target is the diffusers TorchAO INT4 generation path, not cold-start wall time.
+
+## Benchmark task
+
+- Workflow: I2VA
+- Content: adult woman raises a selfie stick, waves, makes a V-sign, then triggers a synchronized flash and shutter sound
+- Resolution: 864x480
+- Frames: 124
+- FPS: 24
+- Output duration: 5.1667 seconds
+- Inference steps: 20, resulting in 19 transformer calls
+- Seed: 314159
+- CFG scale: 1 for Edge and sd.cpp
+- Hardware: one NVIDIA H200
+- Input: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/inputs/first.png`
+- Prompt: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/prompt.txt`
+
+## Weight and runtime configurations
+
+### Edge
+
+- DiT: `minimax_h3_fl2va-Q4_K_M.gguf`
+- Text encoder: `qwen3vl_32b_minimax_h3-Q4_K_M.gguf`
+- Video VAE: FP16 safetensors
+- Audio VAE: FP32 safetensors
+- Flash attention enabled
+- Forced MiniMax-H3 VAE tiling remains active despite the CLI `--vae-tiling off` setting
+
+### sd.cpp
+
+- Uses the same GGUF DiT, GGUF text encoder, video VAE, and audio VAE files as Edge
+- Flash attention and VAE tiling enabled
+- CPU RNG
+- Unmodified downloaded sd.cpp build
+
+### diffusers
+
+- Official MiniMax-H3 diffusers checkpoint
+- Transformer and text encoder use TorchAO weight-only INT4, group size 128
+- BF16 activations/compute where applicable
+- Components remain resident on CUDA during generation
+
+The Edge/sd.cpp and diffusers weights and quantization formats are not numerically identical. Performance comparisons therefore measure practical framework configurations rather than identical kernels over identical quantized tensors.
+
+## Timing results
+
+| Framework | Cold script wall | Framework pipeline/generate | Denoising/transformer | Decode |
+|---|---:|---:|---:|---:|
+| Edge Q4_K_M | 117.140 s | 107.921 s generation | 94.445 s | 11.914 s |
+| sd.cpp Q4_K_M | 274.124 s | 271.120 s generation | 239.050 s sampling | included in remaining time |
+| diffusers TorchAO INT4 | 118.724 s | 59.397 s CUDA generation | 53.621 s transformer | 3.731 s video VAE + 0.129 s audio VAE |
+
+Additional cold-start data:
+
+- Edge model load: 6.572 s
+- Edge output save: 1.425 s
+- diffusers pipeline initialization, checkpoint loading, quantization, and finalization: 46.492 s
+- diffusers mux: 0.640 s
+- diffusers internal end-to-end time: 106.530 s
+
+## Important interpretation
+
+- Edge and diffusers have similar cold script wall time only because diffusers spends about 46.5 seconds loading and quantizing components.
+- The relevant steady-state comparison is Edge generation `107.921 s` versus diffusers CUDA generation `59.397 s`.
+- Edge generation is currently about **1.82x slower** than diffusers after components are ready.
+- Edge DiT diffusion is about **1.76x slower** than diffusers transformer forwards: `94.445 / 53.621`.
+- Edge decode is about **3.09x slower** than the measured diffusers video and audio VAE decode total: `11.914 / 3.859`.
+- Edge is about **2.34x faster** than sd.cpp in cold script wall time for this task.
+
+## Edge profile breakdown
+
+```text
+total=107921 ms
+conditioning=1047 ms
+diffusion=94445 ms (19 steps, 19 calls)
+decode=11914 ms
+noise=258 ms
+
+conditioning:
+  context=647 ms
+  vision image prepare=130 ms
+  vision encode=208 ms
+  text tokenize=20 ms
+  text encode=289 ms
+  keyframe VAE=400 ms
+
+decode:
+  video VAE=10831 ms
+  video copy=109 ms
+  audio VAE=969 ms
+  audio copy=5 ms
+```
+
+## diffusers profile breakdown
+
+```text
+generate_cuda=59.397 s
+transformer_forward_cuda=53.621 s (19 calls)
+text_encoder=0.477 s
+video_vae_encode=0.156 s
+video_vae_decode=3.731 s
+audio_vae_decode=0.129 s
+```
+
+## Quality checkpoint
+
+All three frameworks generated a usable video with:
+
+- a selfie stick and attached phone;
+- a friendly wave;
+- a V-sign pose;
+- a late flash near frames 118-120;
+- a synchronized late audio transient near 4.91-4.99 seconds.
+
+No obvious small pixel-block artifact was observed in this task. Edge produced the strongest visible flash. sd.cpp remained slightly softer. The optimization must preserve this Edge quality baseline.
+
+## Optimization priority
+
+1. Profile each Edge DiT block and operator over the 19 calls; diffusion represents 87.5% of Edge generation time.
+2. Compare Edge attention, linear/Q4_K, modulation, RoPE, and graph-launch timings with the diffusers transformer profile.
+3. Verify CUDA graph coverage, graph breaks, temporary allocations, synchronization, and host-device traffic during each DiT call.
+4. Investigate the video VAE decode path, especially forced spatial tiling, repeated tile graph execution, overlap blending, and per-tile launch overhead.
+5. Re-run this exact benchmark after each change and report warm generation time separately from load/save time.
+6. Reject optimizations that regress selfie-stick geometry, hands, flash timing, audio transient, or introduce block artifacts.
+
+## Reproduction and artifacts
+
+- Edge command: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge/run.sh`
+- Edge log: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge/run.log`
+- sd.cpp command: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/sdcpp/run.sh`
+- sd.cpp log: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/sdcpp/run.log`
+- diffusers command: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/diffusers/run.sh`
+- diffusers profile: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/diffusers/final.json`
+- Consolidated timing: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/review/summary.json`
+- Visual montage: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/review/montage.jpg`
+- Audio transient analysis: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/review/audio-transients.json`
+- Edge video: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge/final.mp4`
+- sd.cpp video: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/sdcpp/final.mp4`
+- diffusers video: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/diffusers/final.mp4`
+
+## 2026-08-09 SM90 Q4_K result
+
+A full clean CUDA rebuild confirmed that the original selfie baseline used the
+quality-safe GGUF Q4_K MMQ route. The earlier 124-frame result that was close to
+Diffusers used the existing Hopper-specific dequantize + cuBLAS route via
+`GGML_CUDA_SM90_Q4K_CUBLAS=1`; omitting that environment switch explains the
+large apparent regression. This is an execution-kernel choice, not a reduction
+in frames, steps, resolution, conditioning, or VAE quality settings.
+
+The final same-task run used the SM90 Q4_K route plus the previously validated
+equivalent decode/backend switches. Request parameters, model files, seed,
+scheduler calls, flash attention, and forced 16x16 latent VAE tiling remained
+unchanged.
+
+| Metric | Original Edge | Optimized Edge | Diffusers | Edge improvement |
+|---|---:|---:|---:|---:|
+| Generation | `107.921s` | `73.114s` | `59.397s` | `32.3%` |
+| DiT diffusion / transformer | `94.445s` | `61.769s` | `53.621s` | `34.6%` |
+| Decode | `11.914s` | `9.768s` | `3.859s` | `18.0%` |
+| Script wall | `117.140s` | `82.076s` | `118.724s` cold | `29.9%` |
+
+The optimized Edge DiT is now `1.15x` the Diffusers transformer time rather
+than `1.76x`. The remaining generation gap is about `13.7s`, split between an
+approximately `8.1s` DiT gap and an approximately `5.9s` non-DiT gap.
+
+Quality gates:
+
+- Output has 124 frames at 864x480 with a 5.17-second audio stream.
+- The person identity, selfie stick, wave, V-sign, and late camera flash remain.
+- The optimized video has no visible black-frame failure or obvious micro-block artifact.
+- Mean block-boundary metrics changed only slightly: b4 `0.01085 -> 0.01099`,
+  b8 `0.01128 -> 0.01152`, b16 `0.01169 -> 0.01200`.
+- The late audio transient remains at `4.998s` versus `4.997s` in the original.
+- The optimized trajectory is not numerically equivalent to MMQ (`22.18dB`
+  average encoded-video PSNR), so the SM90 route remains an explicit validated
+  performance profile rather than an unconditional global default.
+
+Artifacts:
+
+- Reproduction: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-sm90-safe-full/run.sh`
+- Optimized log: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-sm90-safe-full/run.log`
+- Optimized video: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-sm90-safe-full/final.mp4`
+- Visual comparison: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/review-sm90/base-vs-sm90.jpg`
+- Block metrics: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/review-sm90/block-metrics.json`
+- Audio transients: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/review-sm90/audio-transients.json`
+
+## Layered DiT and VAE profiling
+
+A same-shape `864x480`, 124-frame, 3-step probe (two DiT forwards) was used
+before repeating the full 20-step task. Existing runner timing and CUDA-event
+operator profiling were enabled together. Nsight Compute was attempted, but
+this node denies hardware performance counters (`ERR_NVGPUCTRPERM`).
+
+The first DiT call took `5.374s` (`5.369s` GPU compute), while the steady call
+took `3.122s` (`3.105s` GPU compute). Build, allocation, and copy were only
+about `17ms` in the steady call, ruling them out as the remaining DiT gap.
+
+CUDA-event profiling covered `2.903s` of a `3.170s` profiled steady call:
+
+| Operator | Device time | Share |
+|---|---:|---:|
+| `MUL_MAT` | `1.549s` | `53.4%` |
+| `FLASH_ATTN_EXT` | `0.710s` | `24.5%` |
+| `SCALE` | `0.255s` | `8.8%` |
+| `CONCAT` | `0.124s` | `4.3%` |
+| `CONT` | `0.074s` | `2.5%` |
+| `CPY` | `0.056s` | `1.9%` |
+| fused RoPE custom op | `0.053s` | `1.8%` |
+| `GLU` | `0.049s` | `1.7%` |
+
+The matmul internal profile identifies the backend-format bottleneck: 150
+large Q4_K MLP projections per forward use quality-safe FP32/TF32 SGEMM,
+while 50 QKV projections use FP16 Tensor Core GEMM. FC1 SGEMM costs `637.3ms`,
+the two FC2 groups cost `319.4ms + 161.1ms`, QKV GEMM costs `270.2ms`, and QKV
+output conversion costs `70.1ms` per forward. The remaining quality-safe gap
+is primarily GGUF Q4_K layout and repeated dequantization versus Diffusers'
+resident packed INT4 Hopper kernel, not graph/framework overhead.
+
+The video VAE executes seven temporal chunks with ten spatial tiles each. A
+representative call-chain split was:
+
+| Stage | Time |
+|---|---:|
+| 70 tile runner calls | `5.806s` |
+| tile split | `0.041s` |
+| spatial tile merge | `0.436s` |
+| temporal output slicing | `0.141s` |
+| temporal overlap blend | `1.427s` |
+| final temporal collection | `0.758s` |
+
+The VAE device operator profile totals about `4.27s`; `CONT` (`1.60s`) and
+flash attention (`1.20s`) are the largest categories. Three explicit,
+mathematically equivalent copy-path experiments were added:
+
+- `ED_VAE_PLANE_PARALLEL_TILE_COPY=1`
+- `ED_MINIMAX_H3_MOVE_TEMPORAL_BLEND=1`
+- `ED_MINIMAX_H3_PARALLEL_TEMPORAL_COPY=1`
+
+On a same-binary short A/B, the combined path reduced video VAE
+`9.269s -> 8.208s` (`11.4%`). Input VAE latent SHA256 matched and decoded video
+PSNR was `inf`. On the full same-binary task, control and combined video VAE
+were `8.810s` and `8.744s`; full decoded-video PSNR was also `inf`, but the
+`66ms` timing difference is within run variance. Keep these switches explicit
+until repeated full runs demonstrate stable benefit.
+
+Artifacts:
+
+- Operator profile: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/profile-2026-08-09/op-profile-3step.log`
+- Parsed operators: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/profile-2026-08-09/op-profile-summary.json`
+- Temporal profile: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/profile-2026-08-09/vae-temporal-breakdown-3step.log`
+- Full control: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-current-control-full/run.log`
+- Full combined VAE path: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-vae-all-copy-full/run.log`
+- Full quality check: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/profile-2026-08-09/full-control-vs-vae-all-copy-psnr.log`
+
+## 2026-08-09 clean-build and three-framework recheck
+
+The current Edge worktree was rebuilt from an empty `build-cuda-docker`
+directory at commit `2f74ed70638518094860f5fe6f6f14885ca6ceef`. The build used
+Release mode, CUDA architecture 90, cuDNN SDPA, CUDA norm, CUDA RoPE, CUDA
+modulation, and benchmark markers. Because the clean tree did not contain a
+vendored `cudnn-frontend`, CMake fetched the project's pinned `07b368a`
+revision through `ED_FETCH_CUDNN_FRONTEND=ON`; no backend capability was
+removed to make the clean build pass.
+
+All three frameworks were then run sequentially on GPU 0 with the same input,
+prompt, seed `314159`, `864x480`, 124 requested frames, 24 fps, CFG 1, and 20
+requested steps. All resulting MP4 files contain 124 frames at `864x480` and a
+5.175-second audio stream.
+
+| Framework | Generation / sampling | DiT / transformer | Video VAE | Script wall |
+|---|---:|---:|---:|---:|
+| Edge clean rebuild | `72.819s` | `61.710s` | `8.449s` | `81.784s` |
+| Diffusers rerun | `59.430s` CUDA | `53.461s` | `3.760s` | `112.073s` cold |
+| unmodified sd.cpp rerun | `271.27s` generate | `239.17s` sampling | `17.20s` video + `9.29s` audio | `274.462s` |
+
+The reruns are consistent with the previous measurements. Edge's previous
+same-path DiT result was `61.749s`, and Diffusers' previous transformer result
+was `53.621s`. The clean binary therefore does not remove the remaining gap:
+Edge DiT is `8.249s`, or `15.4%`, slower than the practical Diffusers TorchAO
+INT4 configuration. Edge video VAE is `4.689s`, or `2.25x`, slower.
+
+The earlier apparent `94.445s` versus `53.621s` DiT regression came from an
+Edge run that omitted `GGML_CUDA_SM90_Q4K_CUBLAS=1`. Restoring that existing
+Hopper Q4_K execution path reduced Edge DiT to about `61.7s` without changing
+resolution, frame count, steps, prompt, conditioning, seed, or model files.
+This is the large non-parameter-tuning acceleration that should be preserved.
+It changes floating-point execution order and is not bit-exact with the MMQ
+trajectory, so it remains an explicit quality-validated profile rather than a
+global unconditional default. The clean-rebuild MP4 is bit-identical after
+decode to the previous same-path control (`PSNR inf`).
+
+The request-level benchmark parameters are aligned, but the three numerical
+pipelines are not identical:
+
+- Edge and sd.cpp load the same Q4_K_M GGUF DiT and Q4_K_M GGUF conditioner.
+- Diffusers loads the official BF16 checkpoint and quantizes selected linear
+  layers to resident TorchAO group-size-128 INT4 at startup.
+- Edge and sd.cpp therefore do not execute the same quantized tensors or INT4
+  kernel as Diffusers; performance and generated trajectories may differ.
+- Edge reports forced 16x16 latent spatial tiling even when the CLI requests
+  `--vae-tiling off`, executing seven temporal chunks and ten spatial tiles per
+  chunk. The official Diffusers decoder also enables spatial tiling by default;
+  its single profiled Python decode call contains the internal tiled decode and
+  blending work. The remaining VAE gap is therefore an implementation and data
+  residency difference, not simply "Edge tiles while Diffusers does not".
+- sd.cpp explicitly enables VAE tiling and uses `--rng cpu`. It is the
+  downloaded, unmodified commit `c6beeef35526c6dc94b74a7fb69f9d2e6a2a7a12`
+  with binary SHA256
+  `3e840a252f480116d5fc8fc58236ee95b8f6cc50b1738c91afa1464638a6fcea`.
+
+The steady Edge runner profile still attributes only about `17ms` per DiT
+forward to graph build/allocation/copy. The remaining DiT gap is therefore not
+explained by stale binaries or generic framework overhead. Operator profiling
+continues to point to repeated GGUF Q4_K dequantization plus FP32/TF32 SGEMM,
+especially the MLP projections, versus Diffusers' resident packed INT4 Hopper
+kernel. The next quality-preserving acceleration target should retain exact
+Q4_K weights in a resident prepacked representation or provide a dedicated
+SM90 kernel, rather than reducing generation parameters or widening selected
+layers to a trajectory-changing FP16 path.
+
+Recheck artifacts:
+
+- Edge command and manifest: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/rebuild-2f74ed7-full/`
+- Diffusers command, manifest, and JSON: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/recheck-diffusers-2026-08-09/`
+- sd.cpp command and binary manifest: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/recheck-sdcpp-2026-08-09/`
+- Clean-build equivalence check: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/recheck-diffusers-2026-08-09/edge-old-vs-clean-rebuild-psnr.log`
+
+## 2026-08-09 independent clean-build optimized recheck
+
+To rule out stale incremental objects again after adding the QKV, FC1, and VAE
+blend experiments, a second independent build was configured from an empty
+`build-cuda-clean-20260809` directory. It uses the same Release, SM90, CUDA
+graph, cuDNN SDPA, CUDA norm, CUDA RoPE, and CUDA modulation options as the
+active build. Only the pinned `cudnn-frontend` source checkout at revision
+`07b368a` was reused; no object files or binaries were reused. The first clean
+configure attempt also confirmed that the project-level switch must be
+`ED_GGML_CUDA=ON`, not the lower-level `GGML_CUDA=ON`, because the former adds
+the Edge CUDA extension sources, definitions, and include paths.
+
+The full 124-frame benchmark was rerun from that independent binary with the
+same prompt, input, model files, seed, dimensions, frame count, CFG, and step
+count. No resolution, frame, step, scheduler, or cache tuning was used. The
+following explicit experimental switches were enabled:
+
+- `ED_MINIMAX_H3_QKV_F32_OUTPUT=1`
+- `ED_MINIMAX_H3_FC1_F32_OUTPUT=1`
+- `ED_MINIMAX_H3_FAST_TEMPORAL_BLEND=1`
+
+The CLI still says `--vae-tiling off`, but the H3 decoder overrides the generic
+flag and logs ten 16x16-latent spatial tiles for every temporal chunk. Thus the
+actual H3 VAE remains tiled, matching the established Edge benchmark behavior.
+
+| Path | Generation | DiT | Video VAE | Audio VAE | Script wall |
+|---|---:|---:|---:|---:|---:|
+| Edge independent clean build | `63.914s` | `53.836s` | `7.441s` | `0.974s` | `72.821s` |
+| Diffusers TorchAO INT4 | `59.430s` | `53.461s` | `3.760s` | `0.125s` | `112.073s` cold |
+
+The optimized Edge DiT is only `0.375s` (`0.7%`) slower than Diffusers on this
+task. This closes the practical DiT timing gap, but it does not yet establish
+an exact or generally quality-safe replacement: the FC1 route converts Q4_K
+weights and FP32 activations to FP16 Tensor Core inputs with FP32 accumulation
+and output. It changes numerical precision and remains behind an explicit
+switch. A second task with different content must pass a full visual quality
+check before considering it for a default performance profile. The QKV route
+has the same precision caveat, although its smaller scope makes it the safer
+candidate.
+
+The temporal blend optimization is mathematically equivalent and preserves the
+original operation order per output pixel. Its short same-binary A/B produced
+decoded-video `PSNR=inf`, reducing temporal overlap blend from about `1.44s` to
+`0.37s`. In the independent full run it took `0.205s`; retain this optimization
+while pursuing the remaining VAE gap.
+
+The clean-build video contains 124 frames at 864x480 and preserves the person,
+selfie stick, wave, V-sign, and final flash. Fixed-frame inspection found no
+new micro-block or seam artifact. Mean boundary differences were b4 `0.01189`,
+b8 `0.01265`, and b16 `0.01321`, compared with Diffusers b4 `0.01368`, b8
+`0.01450`, and b16 `0.01581`. These metrics do not prove quality, but they do
+not indicate a new periodic block-boundary regression.
+
+The clean-build trajectory differs from the previous FC1 run (`33.73dB` decoded
+video PSNR), confirming that this Tensor Core precision path is not bit-exact
+and can vary with GEMM algorithm/build details. It must not be described as a
+lossless optimization. The visible output remains usable, so it is retained as
+an experimental high-performance path rather than enabled unconditionally.
+
+Artifacts:
+
+- Build and run manifest: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-build-qkv-fc1-fast-vae-full/build-manifest.txt`
+- Reproduction command: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-build-qkv-fc1-fast-vae-full/run.sh`
+- Full timing log: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-build-qkv-fc1-fast-vae-full/run.log`
+- Output video: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-build-qkv-fc1-fast-vae-full/final.mp4`
+- Fixed-frame comparison: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-build-qkv-fc1-fast-vae-full/review/three-way-frames.jpg`
+- Boundary metrics: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-build-qkv-fc1-fast-vae-full/review/block-metrics.json`
+- Previous-FC1 PSNR check: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-build-qkv-fc1-fast-vae-full/review/psnr.txt`
+
+## 2026-08-09 forced clean rebuild and benchmark-accounting audit
+
+The current working tree at Edge commit `2f74ed70638518094860f5fe6f6f14885ca6ceef`
+was reconfigured, cleaned with the CMake `clean` target, and rebuilt through all
+CPU, CUDA, Edge extension, library, and CLI targets. The resulting binary was
+linked at `2026-08-09 04:35:32 +0800`. Its cache explicitly records Release,
+SM90, `ED_GGML_CUDA=ON`, CUDA graphs, CUDA modulation/norm/RoPE, cuDNN SDPA,
+and benchmark markers. This rules out both the earlier `ED_GGML_CUDA=OFF`
+configuration mistake and stale incremental objects for the result below.
+
+The full benchmark retained `864x480`, 124 frames at 24 FPS, 20 requested
+steps/19 transformer forwards, seed 314159, CFG 1, the same input and prompt,
+the same Edge model files, and the forced H3 16x16-latent VAE tiling. No
+resolution, frame-count, step-count, scheduler, cache, or quality setting was
+reduced.
+
+| Path | Generation | DiT | Video VAE | Audio VAE | Script wall |
+|---|---:|---:|---:|---:|---:|
+| Edge forced clean rebuild | `62.615s` | `53.905s` | `5.978s` | `0.992s` | `72.413s` |
+| Previous optimized Edge run | `62.194s` | `53.820s` | `5.605s` | `0.977s` | `71.109s` |
+| Diffusers TorchAO INT4 | `59.397s` | `53.621s` | `3.731s` | `0.129s` | `106.530s` cold |
+
+The clean Edge DiT is only `0.284s` (`0.5%`) slower than Diffusers. Therefore,
+the previously observed large DiT gap is not present in the current build and
+was not caused by this node's current source revision. Run-to-run VAE variance
+accounts for most of the `0.421s` generation change versus the immediately
+preceding optimized run. The remaining generation gap is now concentrated in
+video VAE (`2.247s`) and audio VAE (`0.863s`), not DiT.
+
+The benchmark is aligned for workload and timing comparison, but it is not a
+strict same-weight numerical A/B. Edge loads a Q4_K_M GGUF transformer and
+Q4_K_M GGUF conditioner. Diffusers loads the original Diffusers safetensors
+and applies TorchAO 4-bit weight-only quantization at runtime, with selected
+input/output, embedding, normalization, token-refiner, and vision modules left
+unquantized. These representations can quantize the same source checkpoint
+differently, so different denoising trajectories and visible motion are
+expected even with the same seed. This does not invalidate the performance
+comparison, but it prevents attributing cross-framework visual differences to
+the pipeline alone.
+
+The rebuilt video is exactly equal to the previous optimized Edge video after
+decode (`PSNR=inf`). An eight-frame visual review preserves the person,
+selfie stick, wave, V-sign, and final flash and shows no new micro-block or
+tile-seam artifact. Its fixed-frame boundary means are b4 `0.01256`, b8
+`0.01331`, and b16 `0.01391`. These metrics are only regression indicators;
+the fixed-frame and full-video visual checks remain authoritative.
+
+Future acceleration must retain the fixed workload. Material speedups should
+remain available behind explicit switches until a second, different-content
+full task passes visual review. Mathematically exact copy/blend reductions may
+be retained directly. The next optimization target is VAE execution and data
+movement, especially the `5.004s` temporal tile decode plus `0.971s` measured
+output slicing, blending, and collection, rather than reducing generation
+parameters.
+
+Artifacts:
+
+- Build manifest: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-rebuild-verified-2026-08-09/build-manifest.txt`
+- Full timing log: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-rebuild-verified-2026-08-09/run.log`
+- Output video: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-rebuild-verified-2026-08-09/final.mp4`
+- Fixed-frame comparison: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-rebuild-verified-2026-08-09/review/three-way-frames.jpg`
+- Exact-output check: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-rebuild-verified-2026-08-09/review/psnr-vs-prior.log`
+- Boundary metrics: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-rebuild-verified-2026-08-09/review/block-metrics.json`
+
+## 2026-08-09 VAE and audio acceleration update
+
+The latest full run keeps the same benchmark contract: `864x480`, 124 frames at
+24 FPS, 20 requested steps/19 DiT forwards, seed `314159`, CFG 1, the same
+prompt/input, the same Edge model files, and forced MiniMax-H3 VAE tiling. No
+resolution, frame count, diffusion step count, scheduler, or quality knob was
+reduced.
+
+| Path | Generation | DiT | Video VAE | Audio VAE | Script wall |
+|---|---:|---:|---:|---:|---:|
+| Original Edge baseline | `107.921s` | `94.445s` | about `10.831s` | not isolated | not comparable |
+| Edge forced clean rebuild | `62.615s` | `53.905s` | `5.978s` | `0.992s` | `72.413s` |
+| Latest optimized Edge | `60.889s` | `53.842s` | `5.181s` | `0.161s` | `70.030s` |
+| Diffusers TorchAO INT4 | `59.397s` | `53.621s` | `3.731s` | `0.129s` | `106.530s` cold |
+
+From the original Edge baseline to the latest optimized Edge, generation time
+dropped by `47.032s`, or `43.6%`. Relative to the verified clean rebuild, the
+latest VAE/audio work saves another `1.726s` generation time and `2.383s` script
+wall time. Edge is now only `1.492s` slower than Diffusers for measured CUDA
+generation; DiT itself differs by only `0.221s`, so the remaining gap is almost
+entirely video VAE (`1.450s`) plus a small audio VAE delta (`0.032s`).
+
+Latest retained switches for this run:
+
+- `ED_MINIMAX_H3_FUSED_TEMPORAL_ASSEMBLY=1` writes temporal chunks directly into
+  the final video buffer and blends overlap frames in place, removing legacy
+  slice/concat/full-video copy work.
+- `ED_VAE_PLANE_PARALLEL_TILE_COPY=1`, `ED_VAE_PARALLEL_TILE_COPY=1`, and
+  `ED_VAE_PARALLEL_TILE_COPY_THREADS=8` parallelize spatial tile merging; the
+  merge path now precomputes destination ranges and smootherstep weights once
+  per tile instead of once per plane.
+- `ED_MINIMAX_H3_AUDIO_DIRECT_DEPTHWISE=1` maps the BigVGAN depthwise Conv1D and
+  depthwise transpose/downsample stages to the direct depthwise CUDA path instead
+  of expanding them through IM2COL plus MUL_MAT.
+- Existing high-performance DiT/VAE switches remain enabled for this artifact:
+  `ED_MINIMAX_H3_QKV_F32_OUTPUT=1`, `ED_MINIMAX_H3_FC1_F32_OUTPUT=1`,
+  `ED_MINIMAX_H3_FAST_TEMPORAL_BLEND=1`, `ED_CUDNN_SDPA_SHORT_F16_SELF_ATTN=1`,
+  and `ED_MINIMAX_H3_VAE_FUSED_SWIGLU=1`.
+
+Validation performed:
+
+- Fused temporal assembly was checked inside one candidate run against a legacy
+  reconstruction from the exact same decoded chunks; raw tensor `max_abs=0`, so
+  the assembly/blend math and memory layout are exact for identical inputs.
+- Spatial tile merge precompute was checked against the previous implementation;
+  decoded-video PSNR was `inf` and fixed frames matched.
+- Audio direct depthwise was checked after MP4 s16 packaging against the control
+  path; audio PSNR was about `171dB`, consistent with negligible floating-point
+  differences rather than an audible change.
+- Full-video fixed-frame review on the person/selfie-stick prompt showed normal
+  identity, selfie stick, hand gesture, and final flash, with no new visible
+  micro-block or tile seam artifact. The last video-path review reported b4
+  `0.0125115`, b8 `0.0134006`, and b16 `0.0142055` boundary means.
+- CUDA/operator profiling was used to attribute remaining video VAE time. With
+  fused SwiGLU, the 70-tile video VAE profile still spends roughly `1.400s` in
+  layout operations, `0.473s` in attention, `0.371s` in elementwise work, and
+  `0.269s` in norm. The top remaining removable cost appears to be repeated
+  `CONT` layout copies around MiniMax-H3 VAE decoder attention Q/K/V and RoPE
+  packing, not DiT denoising.
+
+Rejected or not-retained experiments:
+
+- Cross-temporal-chunk CUDA graph reuse was tested and was not faster
+  (`5.203s` video VAE with reuse versus `5.042s` without in the A/B run), while
+  preserving `PSNR=inf`; it remains disabled.
+- General Conv1D cuDNN reshaping, FP16 ordinary Conv1D weights, and two-channel
+  batched BigVGAN experiments did not beat the conservative direct-depthwise
+  audio path and were removed from the code path.
+
+Artifacts:
+
+- Latest full run script: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-final-vae-audio-optimized-full/run.sh`
+- Latest full timing log: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-final-vae-audio-optimized-full/run.log`
+- Latest output video: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-final-vae-audio-optimized-full/final.mp4`
+- Previous visual review frame sheet: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-qkv-fc1-fast-vae-fused-assembly-plane-merge-full/review/comparison.jpg`
+- VAE CONT node profile: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/profile-2026-08-09/vae-swiglu-node-top400/run.log`
diff --git a/src/core/backend/cuDNN/ed_cudnn_sdpa.cu b/src/core/backend/cuDNN/ed_cudnn_sdpa.cu
index ebb091e..88c92d5 100644
--- a/src/core/backend/cuDNN/ed_cudnn_sdpa.cu
+++ b/src/core/backend/cuDNN/ed_cudnn_sdpa.cu
@@ -203,6 +203,11 @@ static bool cudnn_sdpa_wan_sp_cross_attn_enabled() {
     return enabled;
 }
 
+static bool cudnn_sdpa_short_f16_self_attn_enabled() {
+    static const bool enabled = env_flag_enabled_or_default("ED_CUDNN_SDPA_SHORT_F16_SELF_ATTN", false);
+    return enabled;
+}
+
 static double now_ms() {
     using clock = std::chrono::steady_clock;
     return std::chrono::duration<double, std::milli>(clock::now().time_since_epoch()).count();
@@ -614,6 +619,12 @@ static bool should_use_cudnn_sdpa(const ed_cudnn_sdpa_key & key) {
     const bool supported_self_sequence = key.sq >= MIN_CUDNN_SDPA_FAST_SEQ &&
                                          ((key.sq == key.sk && !key.padding_mask) ||
                                           (key.padding_mask && key.sk_actual == key.sq && key.sk >= key.sq));
+    const bool supported_short_f16_self_sequence =
+        cudnn_sdpa_short_f16_self_attn_enabled() &&
+        key.io_type == GGML_TYPE_F16 &&
+        key.sq >= 1024 &&
+        ((key.sq == key.sk && !key.padding_mask) ||
+         (key.padding_mask && key.sk_actual == key.sq && key.sk >= key.sq));
     const bool supported_small_bf16_self_sequence =
         key.io_type == GGML_TYPE_BF16 &&
         !key.padding_mask &&
@@ -627,7 +638,10 @@ static bool should_use_cudnn_sdpa(const ed_cudnn_sdpa_key & key) {
         key.sk > 0 &&
         key.sk <= 1024 &&
         key.sk_actual == key.sk;
-    const bool supported_sequence = supported_self_sequence || supported_small_bf16_self_sequence || supported_cross_sequence;
+    const bool supported_sequence = supported_self_sequence ||
+                                    supported_short_f16_self_sequence ||
+                                    supported_small_bf16_self_sequence ||
+                                    supported_cross_sequence;
     const bool use_cudnn = supported_head_dim && supported_sequence;
 
     if (!use_cudnn && profile_enabled()) {
diff --git a/src/core/backend/ggml/cuda/ed_cuda_modulation.cu b/src/core/backend/ggml/cuda/ed_cuda_modulation.cu
index 6303ca1..cfd9a2d 100644
--- a/src/core/backend/ggml/cuda/ed_cuda_modulation.cu
+++ b/src/core/backend/ggml/cuda/ed_cuda_modulation.cu
@@ -3,6 +3,7 @@
 #include "backend/ggml/ed_ggml_modulation_ext.hpp"
 
 #include <cuda_runtime.h>
+#include <cstdlib>
 #include <cstring>
 
 namespace {
@@ -24,6 +25,11 @@ static bool is_aligned_to(const void* ptr, uintptr_t alignment) {
     return (reinterpret_cast<uintptr_t>(ptr) % alignment) == 0;
 }
 
+static bool env_flag_enabled(const char* name) {
+    const char* value = std::getenv(name);
+    return value != nullptr && value[0] != '\0' && value[0] != '0';
+}
+
 static bool can_vec4_modulate(const ggml_tensor* x,
                               const ggml_tensor* shift,
                               const ggml_tensor* scale,
@@ -88,14 +94,14 @@ __global__ void fused_modulate_f32_kernel(const float* x,
                                           int64_t scale_s1,
                                           int64_t scale_s2,
                                           int64_t scale_s3,
-                                          int shift_b0,
-                                          int shift_b1,
-                                          int shift_b2,
-                                          int shift_b3,
-                                          int scale_b0,
-                                          int scale_b1,
-                                          int scale_b2,
-                                          int scale_b3) {
+                                          int64_t shift_ne0,
+                                          int64_t shift_ne1,
+                                          int64_t shift_ne2,
+                                          int64_t shift_ne3,
+                                          int64_t scale_ne0,
+                                          int64_t scale_ne1,
+                                          int64_t scale_ne2,
+                                          int64_t scale_ne3) {
     const int64_t total = ne0 * ne1 * ne2 * ne3;
     int64_t idx = static_cast<int64_t>(blockIdx.x) * blockDim.x + threadIdx.x;
     if (idx >= total) {
@@ -110,14 +116,14 @@ __global__ void fused_modulate_f32_kernel(const float* x,
     const int64_t i3 = rest / ne2;
 
     const int64_t x_idx = i0 * x_s0 + i1 * x_s1 + i2 * x_s2 + i3 * x_s3;
-    const int64_t shift_idx = (shift_b0 ? 0 : i0) * shift_s0 +
-                              (shift_b1 ? 0 : i1) * shift_s1 +
-                              (shift_b2 ? 0 : i2) * shift_s2 +
-                              (shift_b3 ? 0 : i3) * shift_s3;
-    const int64_t scale_idx = (scale_b0 ? 0 : i0) * scale_s0 +
-                              (scale_b1 ? 0 : i1) * scale_s1 +
-                              (scale_b2 ? 0 : i2) * scale_s2 +
-                              (scale_b3 ? 0 : i3) * scale_s3;
+    const int64_t shift_idx = (i0 % shift_ne0) * shift_s0 +
+                              (i1 % shift_ne1) * shift_s1 +
+                              (i2 % shift_ne2) * shift_s2 +
+                              (i3 % shift_ne3) * shift_s3;
+    const int64_t scale_idx = (i0 % scale_ne0) * scale_s0 +
+                              (i1 % scale_ne1) * scale_s1 +
+                              (i2 % scale_ne2) * scale_s2 +
+                              (i3 % scale_ne3) * scale_s3;
 
     const float xv = x[x_idx];
     const float prod = __fmul_rn(xv, scale[scale_idx]);
@@ -142,12 +148,12 @@ __global__ void fused_modulate_f32_vec4_kernel(const float* x,
                                                int64_t scale_s1,
                                                int64_t scale_s2,
                                                int64_t scale_s3,
-                                               int shift_b1,
-                                               int shift_b2,
-                                               int shift_b3,
-                                               int scale_b1,
-                                               int scale_b2,
-                                               int scale_b3) {
+                                               int64_t shift_ne1,
+                                               int64_t shift_ne2,
+                                               int64_t shift_ne3,
+                                               int64_t scale_ne1,
+                                               int64_t scale_ne2,
+                                               int64_t scale_ne3) {
     const int64_t ne0_vec = ne0 / 4;
     const int64_t total = ne0_vec * ne1 * ne2 * ne3;
     int64_t idx = static_cast<int64_t>(blockIdx.x) * blockDim.x + threadIdx.x;
@@ -165,13 +171,13 @@ __global__ void fused_modulate_f32_vec4_kernel(const float* x,
 
     const int64_t x_idx = i0 + i1 * x_s1 + i2 * x_s2 + i3 * x_s3;
     const int64_t shift_idx = i0 +
-                              (shift_b1 ? 0 : i1) * shift_s1 +
-                              (shift_b2 ? 0 : i2) * shift_s2 +
-                              (shift_b3 ? 0 : i3) * shift_s3;
+                              (i1 % shift_ne1) * shift_s1 +
+                              (i2 % shift_ne2) * shift_s2 +
+                              (i3 % shift_ne3) * shift_s3;
     const int64_t scale_idx = i0 +
-                              (scale_b1 ? 0 : i1) * scale_s1 +
-                              (scale_b2 ? 0 : i2) * scale_s2 +
-                              (scale_b3 ? 0 : i3) * scale_s3;
+                              (i1 % scale_ne1) * scale_s1 +
+                              (i2 % scale_ne2) * scale_s2 +
+                              (i3 % scale_ne3) * scale_s3;
 
     const float4 xv = reinterpret_cast<const float4*>(x + x_idx)[0];
     const float4 sv = reinterpret_cast<const float4*>(scale + scale_idx)[0];
@@ -208,15 +214,15 @@ __global__ void fused_residual_gate_f32_kernel(const float* residual,
                                                int64_t x_s0,
                                                int64_t x_s1,
                                                int64_t x_s2,
-                                               int64_t x_s3,
-                                               int64_t gate_s0,
-                                               int64_t gate_s1,
-                                               int64_t gate_s2,
-                                               int64_t gate_s3,
-                                               int gate_b0,
-                                               int gate_b1,
-                                               int gate_b2,
-                                               int gate_b3) {
+                                                   int64_t x_s3,
+                                                   int64_t gate_s0,
+                                                   int64_t gate_s1,
+                                                   int64_t gate_s2,
+                                                   int64_t gate_s3,
+                                                   int64_t gate_ne0,
+                                                   int64_t gate_ne1,
+                                                   int64_t gate_ne2,
+                                                   int64_t gate_ne3) {
     const int64_t total = ne0 * ne1 * ne2 * ne3;
     int64_t idx = static_cast<int64_t>(blockIdx.x) * blockDim.x + threadIdx.x;
     if (idx >= total) {
@@ -232,10 +238,10 @@ __global__ void fused_residual_gate_f32_kernel(const float* residual,
 
     const int64_t residual_idx = i0 * residual_s0 + i1 * residual_s1 + i2 * residual_s2 + i3 * residual_s3;
     const int64_t x_idx = i0 * x_s0 + i1 * x_s1 + i2 * x_s2 + i3 * x_s3;
-    const int64_t gate_idx = (gate_b0 ? 0 : i0) * gate_s0 +
-                             (gate_b1 ? 0 : i1) * gate_s1 +
-                             (gate_b2 ? 0 : i2) * gate_s2 +
-                             (gate_b3 ? 0 : i3) * gate_s3;
+    const int64_t gate_idx = (i0 % gate_ne0) * gate_s0 +
+                             (i1 % gate_ne1) * gate_s1 +
+                             (i2 % gate_ne2) * gate_s2 +
+                             (i3 % gate_ne3) * gate_s3;
 
     const float prod = __fmul_rn(x[x_idx], gate[gate_idx]);
     dst[idx] = __fadd_rn(residual[residual_idx], prod);
@@ -258,9 +264,9 @@ __global__ void fused_residual_gate_f32_vec4_kernel(const float* residual,
                                                     int64_t gate_s1,
                                                     int64_t gate_s2,
                                                     int64_t gate_s3,
-                                                    int gate_b1,
-                                                    int gate_b2,
-                                                    int gate_b3) {
+                                                    int64_t gate_ne1,
+                                                    int64_t gate_ne2,
+                                                    int64_t gate_ne3) {
     const int64_t ne0_vec = ne0 / 4;
     const int64_t total = ne0_vec * ne1 * ne2 * ne3;
     int64_t idx = static_cast<int64_t>(blockIdx.x) * blockDim.x + threadIdx.x;
@@ -279,9 +285,9 @@ __global__ void fused_residual_gate_f32_vec4_kernel(const float* residual,
     const int64_t residual_idx = i0 + i1 * residual_s1 + i2 * residual_s2 + i3 * residual_s3;
     const int64_t x_idx = i0 + i1 * x_s1 + i2 * x_s2 + i3 * x_s3;
     const int64_t gate_idx = i0 +
-                             (gate_b1 ? 0 : i1) * gate_s1 +
-                             (gate_b2 ? 0 : i2) * gate_s2 +
-                             (gate_b3 ? 0 : i3) * gate_s3;
+                             (i1 % gate_ne1) * gate_s1 +
+                             (i2 % gate_ne2) * gate_s2 +
+                             (i3 % gate_ne3) * gate_s3;
 
     const float4 rv = reinterpret_cast<const float4*>(residual + residual_idx)[0];
     const float4 xv = reinterpret_cast<const float4*>(x + x_idx)[0];
@@ -537,7 +543,7 @@ static bool ed_cuda_fused_modulate_op_compute(ggml_tensor * dst, ed_cuda_modulat
     const int64_t total = ggml_nelements(dst);
     constexpr int threads = 256;
     auto cuda_stream = reinterpret_cast<cudaStream_t>(stream);
-    if (can_vec4_modulate(x, shift, scale, dst)) {
+    if (!env_flag_enabled("ED_CUDA_FUSED_MODULATION_DISABLE_VEC4") && can_vec4_modulate(x, shift, scale, dst)) {
         const int64_t total_vec = total / 4;
         const int blocks = static_cast<int>((total_vec + threads - 1) / threads);
         fused_modulate_f32_vec4_kernel<<<blocks, threads, 0, cuda_stream>>>(
@@ -558,12 +564,12 @@ static bool ed_cuda_fused_modulate_op_compute(ggml_tensor * dst, ed_cuda_modulat
             elem_stride(scale, 1),
             elem_stride(scale, 2),
             elem_stride(scale, 3),
-            shift->ne[1] == 1 ? 1 : 0,
-            shift->ne[2] == 1 ? 1 : 0,
-            shift->ne[3] == 1 ? 1 : 0,
-            scale->ne[1] == 1 ? 1 : 0,
-            scale->ne[2] == 1 ? 1 : 0,
-            scale->ne[3] == 1 ? 1 : 0);
+            shift->ne[1],
+            shift->ne[2],
+            shift->ne[3],
+            scale->ne[1],
+            scale->ne[2],
+            scale->ne[3]);
     } else {
         const int blocks = static_cast<int>((total + threads - 1) / threads);
         fused_modulate_f32_kernel<<<blocks, threads, 0, cuda_stream>>>(
@@ -587,14 +593,14 @@ static bool ed_cuda_fused_modulate_op_compute(ggml_tensor * dst, ed_cuda_modulat
             elem_stride(scale, 1),
             elem_stride(scale, 2),
             elem_stride(scale, 3),
-            shift->ne[0] == 1 ? 1 : 0,
-            shift->ne[1] == 1 ? 1 : 0,
-            shift->ne[2] == 1 ? 1 : 0,
-            shift->ne[3] == 1 ? 1 : 0,
-            scale->ne[0] == 1 ? 1 : 0,
-            scale->ne[1] == 1 ? 1 : 0,
-            scale->ne[2] == 1 ? 1 : 0,
-            scale->ne[3] == 1 ? 1 : 0);
+            shift->ne[0],
+            shift->ne[1],
+            shift->ne[2],
+            shift->ne[3],
+            scale->ne[0],
+            scale->ne[1],
+            scale->ne[2],
+            scale->ne[3]);
     }
     return true;
 }
@@ -611,7 +617,7 @@ static bool ed_cuda_fused_residual_gate_op_compute(ggml_tensor * dst, ed_cuda_mo
     const int64_t total = ggml_nelements(dst);
     constexpr int threads = 256;
     auto cuda_stream = reinterpret_cast<cudaStream_t>(stream);
-    if (can_vec4_residual_gate(residual, x, gate, dst)) {
+    if (!env_flag_enabled("ED_CUDA_FUSED_MODULATION_DISABLE_VEC4") && can_vec4_residual_gate(residual, x, gate, dst)) {
         const int64_t total_vec = total / 4;
         const int blocks = static_cast<int>((total_vec + threads - 1) / threads);
         fused_residual_gate_f32_vec4_kernel<<<blocks, threads, 0, cuda_stream>>>(
@@ -632,9 +638,9 @@ static bool ed_cuda_fused_residual_gate_op_compute(ggml_tensor * dst, ed_cuda_mo
             elem_stride(gate, 1),
             elem_stride(gate, 2),
             elem_stride(gate, 3),
-            gate->ne[1] == 1 ? 1 : 0,
-            gate->ne[2] == 1 ? 1 : 0,
-            gate->ne[3] == 1 ? 1 : 0);
+            gate->ne[1],
+            gate->ne[2],
+            gate->ne[3]);
     } else {
         const int blocks = static_cast<int>((total + threads - 1) / threads);
         fused_residual_gate_f32_kernel<<<blocks, threads, 0, cuda_stream>>>(
@@ -658,10 +664,10 @@ static bool ed_cuda_fused_residual_gate_op_compute(ggml_tensor * dst, ed_cuda_mo
             elem_stride(gate, 1),
             elem_stride(gate, 2),
             elem_stride(gate, 3),
-            gate->ne[0] == 1 ? 1 : 0,
-            gate->ne[1] == 1 ? 1 : 0,
-            gate->ne[2] == 1 ? 1 : 0,
-            gate->ne[3] == 1 ? 1 : 0);
+            gate->ne[0],
+            gate->ne[1],
+            gate->ne[2],
+            gate->ne[3]);
     }
     return true;
 }
diff --git a/src/core/backend/ggml/ed_ggml_modulation_ext.hpp b/src/core/backend/ggml/ed_ggml_modulation_ext.hpp
index c8696ad..ce73c9c 100644
--- a/src/core/backend/ggml/ed_ggml_modulation_ext.hpp
+++ b/src/core/backend/ggml/ed_ggml_modulation_ext.hpp
@@ -69,7 +69,7 @@ inline bool fused_where_select_params_valid(const FusedWhereSelectCustomParams&
 }
 
 inline bool fused_modulate_broadcast_dim_supported(int64_t src, int64_t dst) {
-    return src == 1 || src == dst;
+    return src > 0 && dst > 0 && dst % src == 0;
 }
 
 inline bool fused_modulate_shape_supported(const ggml_tensor* x,
@@ -145,10 +145,10 @@ inline float fused_modulate_tensor_f32_at_broadcast(const ggml_tensor* t,
                                                     int64_t i1,
                                                     int64_t i2,
                                                     int64_t i3) {
-    const int64_t j0 = t->ne[0] == 1 ? 0 : i0;
-    const int64_t j1 = t->ne[1] == 1 ? 0 : i1;
-    const int64_t j2 = t->ne[2] == 1 ? 0 : i2;
-    const int64_t j3 = t->ne[3] == 1 ? 0 : i3;
+    const int64_t j0 = i0 % t->ne[0];
+    const int64_t j1 = i1 % t->ne[1];
+    const int64_t j2 = i2 % t->ne[2];
+    const int64_t j3 = i3 % t->ne[3];
     const char* base = static_cast<const char*>(t->data);
     const char* ptr = base + j0 * t->nb[0] + j1 * t->nb[1] + j2 * t->nb[2] + j3 * t->nb[3];
     return *reinterpret_cast<const float*>(ptr);
diff --git a/src/core/backend/ggml/ggml_extend.hpp b/src/core/backend/ggml/ggml_extend.hpp
index 8025195..aa95d4e 100644
--- a/src/core/backend/ggml/ggml_extend.hpp
+++ b/src/core/backend/ggml/ggml_extend.hpp
@@ -22,6 +22,7 @@
 #include <set>
 #include <sstream>
 #include <string>
+#include <thread>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
@@ -835,6 +836,54 @@ __STATIC_INLINE__ int64_t sd_tensor_plane_size(const sd::Tensor<float>& tensor)
     return tensor.shape()[0] * tensor.shape()[1];
 }
 
+template <typename Fn>
+__STATIC_INLINE__ void sd_parallel_for(int64_t begin, int64_t end, int threads, Fn&& fn) {
+    if (threads <= 1 || end - begin <= 1) {
+        for (int64_t index = begin; index < end; ++index) {
+            fn(index);
+        }
+        return;
+    }
+    threads = std::min<int64_t>(threads, end - begin);
+    std::vector<std::thread> workers;
+    workers.reserve(static_cast<size_t>(threads));
+    for (int thread_index = 0; thread_index < threads; ++thread_index) {
+        const int64_t start = begin + (end - begin) * thread_index / threads;
+        const int64_t stop  = begin + (end - begin) * (thread_index + 1) / threads;
+        workers.emplace_back([&, start, stop]() {
+            for (int64_t index = start; index < stop; ++index) {
+                fn(index);
+            }
+        });
+    }
+    for (std::thread& worker : workers) {
+        worker.join();
+    }
+}
+
+__STATIC_INLINE__ int sd_vae_parallel_tile_copy_threads() {
+    static const int threads = []() {
+        const char* enabled = std::getenv("ED_VAE_PARALLEL_TILE_COPY");
+        if (enabled == nullptr || enabled[0] == '\0' || std::strcmp(enabled, "0") == 0) {
+            return 1;
+        }
+        const char* value = std::getenv("ED_VAE_PARALLEL_TILE_COPY_THREADS");
+        if (value != nullptr && value[0] != '\0') {
+            return std::max(1, std::atoi(value));
+        }
+        return 8;
+    }();
+    return threads;
+}
+
+__STATIC_INLINE__ bool sd_vae_plane_parallel_tile_copy_enabled() {
+    static const bool enabled = []() {
+        const char* value = std::getenv("ED_VAE_PLANE_PARALLEL_TILE_COPY");
+        return value != nullptr && value[0] != '\0' && std::strcmp(value, "0") != 0;
+    }();
+    return enabled;
+}
+
 __STATIC_INLINE__ sd::Tensor<float> sd_tensor_split_2d(const sd::Tensor<float>& input, int width, int height, int x, int y) {
     GGML_ASSERT(input.dim() >= 4);
     std::vector<int64_t> output_shape = input.shape();
@@ -846,28 +895,43 @@ __STATIC_INLINE__ sd::Tensor<float> sd_tensor_split_2d(const sd::Tensor<float>&
     int64_t input_plane  = sd_tensor_plane_size(input);
     int64_t output_plane = sd_tensor_plane_size(output);
     int64_t plane_count  = input.numel() / input_plane;
-    for (int iy = 0; iy < height; iy++) {
-        for (int ix = 0; ix < width; ix++) {
-            int64_t src_xy = (ix + x) % input_width + input_width * ((iy + y) % input_height);
-            int64_t dst_xy = ix + width * iy;
-            for (int64_t plane = 0; plane < plane_count; ++plane) {
-                output[plane * output_plane + dst_xy] = input[plane * input_plane + src_xy];
+    const int threads = sd_vae_parallel_tile_copy_threads();
+    if (threads > 1 && sd_vae_plane_parallel_tile_copy_enabled()) {
+        sd_parallel_for(0, plane_count, threads, [&](int64_t plane) {
+            const int64_t src_plane_offset = plane * input_plane;
+            const int64_t dst_plane_offset = plane * output_plane;
+            for (int iy = 0; iy < height; ++iy) {
+                for (int ix = 0; ix < width; ++ix) {
+                    const int64_t src_xy = (ix + x) % input_width + input_width * ((iy + y) % input_height);
+                    const int64_t dst_xy = ix + width * iy;
+                    output[dst_plane_offset + dst_xy] = input[src_plane_offset + src_xy];
+                }
             }
-        }
+        });
+        return output;
     }
+    sd_parallel_for(0, static_cast<int64_t>(width) * height, threads, [&](int64_t xy) {
+        const int iy = static_cast<int>(xy / width);
+        const int ix = static_cast<int>(xy - static_cast<int64_t>(iy) * width);
+        int64_t src_xy = (ix + x) % input_width + input_width * ((iy + y) % input_height);
+        int64_t dst_xy = ix + width * iy;
+        for (int64_t plane = 0; plane < plane_count; ++plane) {
+            output[plane * output_plane + dst_xy] = input[plane * input_plane + src_xy];
+        }
+    });
     return output;
 }
 
-__STATIC_INLINE__ void sd_tensor_merge_2d(const sd::Tensor<float>& input,
-                                          sd::Tensor<float>* output,
-                                          int x,
-                                          int y,
-                                          int overlap_x,
-                                          int overlap_y,
-                                          bool circular_x,
-                                          bool circular_y,
-                                          int x_skip = 0,
-                                          int y_skip = 0) {
+__STATIC_INLINE__ void sd_tensor_merge_2d_serial(const sd::Tensor<float>& input,
+                                                 sd::Tensor<float>* output,
+                                                 int x,
+                                                 int y,
+                                                 int overlap_x,
+                                                 int overlap_y,
+                                                 bool circular_x,
+                                                 bool circular_y,
+                                                 int x_skip,
+                                                 int y_skip) {
     GGML_ASSERT(output != nullptr);
     int64_t width        = input.shape()[0];
     int64_t height       = input.shape()[1];
@@ -876,12 +940,10 @@ __STATIC_INLINE__ void sd_tensor_merge_2d(const sd::Tensor<float>& input,
     int64_t input_plane  = sd_tensor_plane_size(input);
     int64_t output_plane = sd_tensor_plane_size(*output);
     int64_t plane_count  = input.numel() / input_plane;
-    GGML_ASSERT(output->numel() / output_plane == plane_count);
 
-    // unclamped -> expects x in the range [0-1]
-    auto smootherstep_f32 = [](const float x) -> float {
-        GGML_ASSERT(x >= 0.f && x <= 1.f);
-        return x * x * x * (x * (6.0f * x - 15.0f) + 10.0f);
+    auto smootherstep_f32 = [](const float v) -> float {
+        GGML_ASSERT(v >= 0.f && v <= 1.f);
+        return v * v * v * (v * (6.0f * v - 15.0f) + 10.0f);
     };
 
     for (int iy = y_skip; iy < height; iy++) {
@@ -910,6 +972,122 @@ __STATIC_INLINE__ void sd_tensor_merge_2d(const sd::Tensor<float>& input,
     }
 }
 
+__STATIC_INLINE__ void sd_tensor_merge_2d(const sd::Tensor<float>& input,
+                                          sd::Tensor<float>* output,
+                                          int x,
+                                          int y,
+                                          int overlap_x,
+                                          int overlap_y,
+                                          bool circular_x,
+                                          bool circular_y,
+                                          int x_skip = 0,
+                                          int y_skip = 0) {
+    GGML_ASSERT(output != nullptr);
+    int64_t width        = input.shape()[0];
+    int64_t height       = input.shape()[1];
+    int64_t img_width    = output->shape()[0];
+    int64_t img_height   = output->shape()[1];
+    int64_t input_plane  = sd_tensor_plane_size(input);
+    int64_t output_plane = sd_tensor_plane_size(*output);
+    int64_t plane_count  = input.numel() / input_plane;
+    GGML_ASSERT(output->numel() / output_plane == plane_count);
+
+    const int threads = sd_vae_parallel_tile_copy_threads();
+    if (threads <= 1) {
+        sd_tensor_merge_2d_serial(input, output, x, y, overlap_x, overlap_y, circular_x, circular_y, x_skip, y_skip);
+        return;
+    }
+
+    if (sd_vae_plane_parallel_tile_copy_enabled()) {
+        auto smootherstep_f32 = [](const float value) -> float {
+            GGML_ASSERT(value >= 0.f && value <= 1.f);
+            return value * value * value * (value * (6.0f * value - 15.0f) + 10.0f);
+        };
+        std::vector<int64_t> destination_x(static_cast<size_t>(width));
+        std::vector<int64_t> destination_y(static_cast<size_t>(height));
+        std::vector<float> weight_x(static_cast<size_t>(width), 1.f);
+        std::vector<float> weight_y(static_cast<size_t>(height), 1.f);
+        for (int ix = x_skip; ix < width; ++ix) {
+            destination_x[static_cast<size_t>(ix)] = (x + ix) % img_width;
+            if (overlap_x > 0 || overlap_y > 0) {
+                const float x_f_0 = (circular_x || (overlap_x > 0 && x > 0))
+                                        ? (ix - x_skip) / float(overlap_x)
+                                        : 1.f;
+                const float x_f_1 = (circular_x || (overlap_x > 0 && x < (img_width - width)))
+                                        ? (width - ix) / float(overlap_x)
+                                        : 1.f;
+                weight_x[static_cast<size_t>(ix)] = smootherstep_f32(std::min(std::min(x_f_0, x_f_1), 1.f));
+            }
+        }
+        for (int iy = y_skip; iy < height; ++iy) {
+            destination_y[static_cast<size_t>(iy)] = (y + iy) % img_height;
+            if (overlap_x > 0 || overlap_y > 0) {
+                const float y_f_0 = (circular_y || (overlap_y > 0 && y > 0))
+                                        ? (iy - y_skip) / float(overlap_y)
+                                        : 1.f;
+                const float y_f_1 = (circular_y || (overlap_y > 0 && y < (img_height - height)))
+                                        ? (height - iy) / float(overlap_y)
+                                        : 1.f;
+                weight_y[static_cast<size_t>(iy)] = smootherstep_f32(std::min(std::min(y_f_0, y_f_1), 1.f));
+            }
+        }
+        sd_parallel_for(0, plane_count, threads, [&](int64_t plane) {
+            const int64_t src_plane_offset = plane * input_plane;
+            const int64_t dst_plane_offset = plane * output_plane;
+            for (int iy = y_skip; iy < height; ++iy) {
+                for (int ix = x_skip; ix < width; ++ix) {
+                    const int64_t src_xy = ix + width * iy;
+                    const int64_t ox = destination_x[static_cast<size_t>(ix)];
+                    const int64_t oy = destination_y[static_cast<size_t>(iy)];
+                    const int64_t dst_xy = ox + img_width * oy;
+                    const float new_value = input[src_plane_offset + src_xy];
+                    if (overlap_x > 0 || overlap_y > 0) {
+                        const float old_value = (*output)[dst_plane_offset + dst_xy];
+                        (*output)[dst_plane_offset + dst_xy] =
+                            old_value + new_value * weight_y[static_cast<size_t>(iy)] * weight_x[static_cast<size_t>(ix)];
+                    } else {
+                        (*output)[dst_plane_offset + dst_xy] = new_value;
+                    }
+                }
+            }
+        });
+        return;
+    }
+
+    // unclamped -> expects x in the range [0-1]
+    auto smootherstep_f32 = [](const float x) -> float {
+        GGML_ASSERT(x >= 0.f && x <= 1.f);
+        return x * x * x * (x * (6.0f * x - 15.0f) + 10.0f);
+    };
+
+    const int64_t active_width  = width - x_skip;
+    const int64_t active_height = height - y_skip;
+    sd_parallel_for(0, active_width * active_height, threads, [&](int64_t active_xy) {
+        const int iy = y_skip + static_cast<int>(active_xy / active_width);
+        const int ix = x_skip + static_cast<int>(active_xy - static_cast<int64_t>(iy - y_skip) * active_width);
+        int64_t src_xy = ix + width * iy;
+        int64_t ox     = (x + ix) % img_width;
+        int64_t oy     = (y + iy) % img_height;
+        int64_t dst_xy = ox + img_width * oy;
+        for (int64_t plane = 0; plane < plane_count; ++plane) {
+            float new_value = input[plane * input_plane + src_xy];
+            if (overlap_x > 0 || overlap_y > 0) {
+                float old_value   = (*output)[plane * output_plane + dst_xy];
+                const float x_f_0 = (circular_x || (overlap_x > 0 && x > 0)) ? (ix - x_skip) / float(overlap_x) : 1.f;
+                const float x_f_1 = (circular_x || (overlap_x > 0 && x < (img_width - width))) ? (width - ix) / float(overlap_x) : 1.f;
+                const float y_f_0 = (circular_y || (overlap_y > 0 && y > 0)) ? (iy - y_skip) / float(overlap_y) : 1.f;
+                const float y_f_1 = (circular_y || (overlap_y > 0 && y < (img_height - height))) ? (height - iy) / float(overlap_y) : 1.f;
+                const float x_f   = std::min(std::min(x_f_0, x_f_1), 1.f);
+                const float y_f   = std::min(std::min(y_f_0, y_f_1), 1.f);
+                (*output)[plane * output_plane + dst_xy] =
+                    old_value + new_value * smootherstep_f32(y_f) * smootherstep_f32(x_f);
+            } else {
+                (*output)[plane * output_plane + dst_xy] = new_value;
+            }
+        }
+    });
+}
+
 template <typename Fn>
 __STATIC_INLINE__ sd::Tensor<float> process_tiles_2d(const sd::Tensor<float>& input,
                                                      int output_width,
@@ -970,6 +1148,11 @@ __STATIC_INLINE__ sd::Tensor<float> process_tiles_2d(const sd::Tensor<float>& in
     bool last_y     = false;
     bool last_x     = false;
     float last_time = 0.0f;
+    const bool profile_tiles = std::getenv("ED_PROFILE_VAE_TILES") != nullptr;
+    int64_t split_us = 0;
+    int64_t process_us = 0;
+    int64_t allocate_us = 0;
+    int64_t merge_us = 0;
     if (!silent) {
         LOG_DEBUG("num tiles : %d, %d ", num_tiles_x, num_tiles_y);
         LOG_DEBUG("optimal overlap : %f, %f (targeting %f)", tile_overlap_factor_x, tile_overlap_factor_y, tile_overlap_factor);
@@ -1008,8 +1191,13 @@ __STATIC_INLINE__ sd::Tensor<float> process_tiles_2d(const sd::Tensor<float>& in
             int overlap_y_out = decode ? tile_overlap_y * scale : tile_overlap_y;
 
             int64_t t1       = ggml_time_ms();
+            const int64_t split_begin = profile_tiles ? ggml_time_us() : 0;
             auto input_tile  = sd_tensor_split_2d(input, input_tile_size_x, input_tile_size_y, x_in, y_in);
+            const int64_t process_begin = profile_tiles ? ggml_time_us() : 0;
+            if (profile_tiles) split_us += process_begin - split_begin;
             auto output_tile = on_processing(input_tile);
+            const int64_t allocate_begin = profile_tiles ? ggml_time_us() : 0;
+            if (profile_tiles) process_us += allocate_begin - process_begin;
             if (output_tile.empty()) {
                 return {};
             }
@@ -1020,7 +1208,10 @@ __STATIC_INLINE__ sd::Tensor<float> process_tiles_2d(const sd::Tensor<float>& in
                 output_shape[1]                   = output_height;
                 output                            = sd::Tensor<float>::zeros(std::move(output_shape));
             }
+            const int64_t merge_begin = profile_tiles ? ggml_time_us() : 0;
+            if (profile_tiles) allocate_us += merge_begin - allocate_begin;
             sd_tensor_merge_2d(output_tile, &output, x_out, y_out, overlap_x_out, overlap_y_out, circular_x, circular_y, dx, dy);
+            if (profile_tiles) merge_us += ggml_time_us() - merge_begin;
 
             if (!silent) {
                 int64_t t2 = ggml_time_ms();
@@ -1037,6 +1228,14 @@ __STATIC_INLINE__ sd::Tensor<float> process_tiles_2d(const sd::Tensor<float>& in
     if (output.empty()) {
         return {};
     }
+    if (profile_tiles) {
+        LOG_INFO("ED_VAE_TILE_PROFILE tiles=%d split_ms=%.3f process_ms=%.3f allocate_ms=%.3f merge_ms=%.3f",
+                 num_tiles,
+                 split_us / 1000.0,
+                 process_us / 1000.0,
+                 allocate_us / 1000.0,
+                 merge_us / 1000.0);
+    }
     return output;
 }
 
@@ -1111,7 +1310,8 @@ __STATIC_INLINE__ ggml_tensor* ggml_ext_linear(ggml_context* ctx,
                                                ggml_tensor* w,
                                                ggml_tensor* b,
                                                bool force_prec_f32 = false,
-                                               float scale         = 1.f) {
+                                               float scale         = 1.f,
+                                               const char* matmul_name = nullptr) {
     if (scale != 1.f) {
         x = ggml_ext_scale(ctx, x, scale);
     }
@@ -1121,12 +1321,18 @@ __STATIC_INLINE__ ggml_tensor* ggml_ext_linear(ggml_context* ctx,
         int64_t ne3 = x->ne[3];
         x           = ggml_reshape_2d(ctx, x, x->ne[0], x->ne[1] * x->ne[2] * x->ne[3]);
         x           = ggml_mul_mat(ctx, w, x);
+        if (matmul_name != nullptr && matmul_name[0] != '\0') {
+            ggml_set_name(x, matmul_name);
+        }
         if (force_prec_f32) {
             ggml_mul_mat_set_prec(x, GGML_PREC_F32);
         }
         x = ggml_reshape_4d(ctx, x, x->ne[0], x->ne[1] / ne2 / ne3, ne2, ne3);
     } else {
         x = ggml_mul_mat(ctx, w, x);
+        if (matmul_name != nullptr && matmul_name[0] != '\0') {
+            ggml_set_name(x, matmul_name);
+        }
         if (force_prec_f32) {
             ggml_mul_mat_set_prec(x, GGML_PREC_F32);
         }
@@ -7414,7 +7620,8 @@ class Linear : public UnaryBlock {
             forward_params.linear.scale          = effective_scale;
             return ctx->weight_adapter->forward_with_lora(ctx->ggml_ctx, ctx->backend, x, w, b, prefix, forward_params);
         }
-        x = ggml_ext_linear(ctx->ggml_ctx, x, w, b, force_prec_f32, effective_scale);
+        const std::string matmul_name = prefix + "weight";
+        x = ggml_ext_linear(ctx->ggml_ctx, x, w, b, force_prec_f32, effective_scale, matmul_name.c_str());
         if (cast_output_to_input_type &&
             (output_type == GGML_TYPE_F16 || output_type == GGML_TYPE_BF16) &&
             x->type != output_type) {
diff --git a/src/dit_models/components/autoencoders/minimax_h3_audio_vae.hpp b/src/dit_models/components/autoencoders/minimax_h3_audio_vae.hpp
index a0977c2..488d4eb 100644
--- a/src/dit_models/components/autoencoders/minimax_h3_audio_vae.hpp
+++ b/src/dit_models/components/autoencoders/minimax_h3_audio_vae.hpp
@@ -70,8 +70,16 @@ namespace Ops {
                                          int stride,
                                          int padding) {
         auto ctx = runner_ctx->ggml_ctx;
-        GGML_ASSERT(x->ne[3] == 1);
+        GGML_ASSERT(x->ne[2] == 1 && x->ne[3] == 1);
         auto tiled = tile_depthwise_filter_1d(runner_ctx, filter, x->ne[1]);
+        const char* direct = std::getenv("ED_MINIMAX_H3_AUDIO_DIRECT_DEPTHWISE");
+        if (direct != nullptr && direct[0] != '\0' && direct[0] != '0' &&
+            sd_backend_is(runner_ctx->backend, "CUDA") && tiled->type == GGML_TYPE_F32 && x->type == GGML_TYPE_F32) {
+            auto kernel = ggml_reshape_4d(ctx, tiled, tiled->ne[0], 1, 1, x->ne[1]);
+            auto input = ggml_reshape_4d(ctx, x, x->ne[0], 1, x->ne[1], 1);
+            auto out = ggml_conv_2d_dw_direct(ctx, kernel, input, stride, 1, padding, 0, 1, 1);
+            return ggml_reshape_4d(ctx, out, out->ne[0], out->ne[2], 1, 1);
+        }
         auto out   = ggml_conv_1d_dw(ctx, tiled, x, stride, padding, 1);
         return ggml_reshape_4d(ctx, out, out->ne[0], out->ne[1], 1, 1);
     }
@@ -95,7 +103,7 @@ namespace Ops {
                                                    ggml_tensor* x,
                                                    ggml_tensor* filter,
                                                    int stride) {
-        GGML_ASSERT(x->ne[2] == 1 && x->ne[3] == 1);
+        GGML_ASSERT(x->ne[3] == 1);
         GGML_ASSERT(filter->ne[1] == 1);
         GGML_ASSERT(filter->ne[2] == 1 && filter->ne[3] == 1);
 
@@ -116,7 +124,25 @@ namespace Ops {
         x_flat = ggml_reshape_3d(ctx, x_flat, time * stride, 1, channels);
 
         auto reversed_filter = reverse_1d_filter(ctx, filter);
-        auto out             = ggml_conv_1d(ctx, reversed_filter, x_flat, 1, static_cast<int>(kernel_size - 1), 1);
+        ggml_tensor* out = nullptr;
+        const char* direct = std::getenv("ED_MINIMAX_H3_AUDIO_DIRECT_DEPTHWISE");
+        if (direct != nullptr && direct[0] != '\0' && direct[0] != '0' &&
+            reversed_filter->type == GGML_TYPE_F32 && x_flat->type == GGML_TYPE_F32) {
+            auto kernel = ggml_reshape_4d(ctx, reversed_filter, kernel_size, 1, 1, 1);
+            auto input = ggml_reshape_4d(ctx, x_flat, time * stride, 1, 1, channels);
+            out = ggml_conv_2d_dw_direct(ctx,
+                                         kernel,
+                                         input,
+                                         1,
+                                         1,
+                                         static_cast<int>(kernel_size - 1),
+                                         0,
+                                         1,
+                                         1);
+            out = ggml_reshape_3d(ctx, out, out->ne[0], 1, channels);
+        } else {
+            out = ggml_conv_1d(ctx, reversed_filter, x_flat, 1, static_cast<int>(kernel_size - 1), 1);
+        }
         if (out->ne[0] > out_time) {
             out = ggml_ext_slice(ctx, out, 0, 0, out_time);
         }
@@ -267,6 +293,10 @@ namespace Ops {
                          const String2TensorStorage& tensor_storage_map = {},
                          const std::string prefix                       = "") override {
             ggml_type down_type                 = audio_conv_weight_type(get_type(prefix + "downsample.lowpass.filter", tensor_storage_map, GGML_TYPE_F16));
+            const char* direct_depthwise = std::getenv("ED_MINIMAX_H3_AUDIO_DIRECT_DEPTHWISE");
+            if (direct_depthwise != nullptr && direct_depthwise[0] != '\0' && direct_depthwise[0] != '0') {
+                down_type = GGML_TYPE_F32;
+            }
             params["downsample.lowpass.filter"] = ggml_new_tensor_3d(ctx, down_type, down_kernel_size, 1, 1);
             params["upsample.filter"]           = ggml_new_tensor_3d(ctx, GGML_TYPE_F32, up_kernel_size, 1, 1);
         }
diff --git a/src/dit_models/components/autoencoders/minimax_h3_vae.hpp b/src/dit_models/components/autoencoders/minimax_h3_vae.hpp
index f3bb7e0..40766f7 100644
--- a/src/dit_models/components/autoencoders/minimax_h3_vae.hpp
+++ b/src/dit_models/components/autoencoders/minimax_h3_vae.hpp
@@ -25,6 +25,30 @@ namespace MiniMaxH3VAE {
         return value != nullptr && value[0] != '\0' && std::strcmp(value, "0") != 0;
     }
 
+    struct ScopedEnvFlag {
+        std::string name;
+        std::string old_value;
+        bool had_value = false;
+
+        ScopedEnvFlag(const char* key, const char* value)
+            : name(key) {
+            const char* current = std::getenv(key);
+            if (current != nullptr) {
+                had_value = true;
+                old_value = current;
+            }
+            setenv(name.c_str(), value, 1);
+        }
+
+        ~ScopedEnvFlag() {
+            if (had_value) {
+                setenv(name.c_str(), old_value.c_str(), 1);
+            } else {
+                unsetenv(name.c_str());
+            }
+        }
+    };
+
     struct CausalConv3d : public Conv3d {
         std::tuple<int, int, int> temporal_padding;
 
@@ -322,7 +346,11 @@ namespace MiniMaxH3VAE {
         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);
+            auto projected = w1->forward(ctx, x);
+            if (h3_env_flag_enabled("ED_MINIMAX_H3_VAE_FUSED_SWIGLU")) {
+                return w2->forward(ctx, ggml_swiglu(ctx->ggml_ctx, projected));
+            }
+            auto gate = ggml_ext_chunk(ctx->ggml_ctx, projected, 2, 0);
             return w2->forward(ctx,
                                ggml_mul(ctx->ggml_ctx,
                                         ggml_silu(ctx->ggml_ctx, gate[0]),
@@ -466,13 +494,17 @@ namespace MiniMaxH3VAE {
         ggml_tensor* encode(GGMLRunnerContext* ctx,
                             ggml_tensor* pixels,
                             ggml_tensor* pixel_mean,
-                            ggml_tensor* pixel_std) {
+                            ggml_tensor* pixel_std,
+                            bool return_moments = false) {
             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));
+            if (return_moments) {
+                return moments;
+            }
             return ggml_ext_slice(ctx->ggml_ctx, moments, 3, 0, 24);
         }
 
@@ -564,9 +596,23 @@ namespace MiniMaxH3VAE {
         }
 
         static ed_tiling_params_t h3_tiling(ed_tiling_params_t params) {
+            const char* disable_forced_tiling = std::getenv("ED_MINIMAX_H3_DISABLE_FORCED_VAE_TILING");
+            if (disable_forced_tiling != nullptr && disable_forced_tiling[0] != '\0' && disable_forced_tiling[0] != '0') {
+                params.enabled = false;
+                return params;
+            }
+            auto tile_size_from_env = [](const char* name, int fallback) {
+                const char* value = std::getenv(name);
+                if (value == nullptr || value[0] == '\0') {
+                    return fallback;
+                }
+                char* end = nullptr;
+                const long parsed = std::strtol(value, &end, 10);
+                return end != value && parsed >= 4 && parsed <= 256 ? static_cast<int>(parsed) : fallback;
+            };
             params.enabled        = true;
-            params.tile_size_x    = 16;
-            params.tile_size_y    = 16;
+            params.tile_size_x    = tile_size_from_env("ED_MINIMAX_H3_VAE_TILE_SIZE_X", 16);
+            params.tile_size_y    = tile_size_from_env("ED_MINIMAX_H3_VAE_TILE_SIZE_Y", 16);
             params.rel_size_x     = 0.0f;
             params.rel_size_y     = 0.0f;
             params.target_overlap = 0.25f;
@@ -584,21 +630,62 @@ namespace MiniMaxH3VAE {
         }
 
         static sd::Tensor<float> blend_temporal(const sd::Tensor<float>& previous,
-                                                const sd::Tensor<float>& current,
+                                                sd::Tensor<float> current,
                                                 int64_t extent) {
-            auto output            = current;
-            extent                 = std::min({extent, previous.shape()[2], current.shape()[2]});
+            auto output            = std::move(current);
+            extent                 = std::min({extent, previous.shape()[2], output.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) {
+            if (h3_env_flag_enabled("ED_MINIMAX_H3_FAST_TEMPORAL_BLEND")) {
+                const int64_t frame_size = output.shape()[0] * output.shape()[1];
+                const int64_t frames_per_outer = output.shape()[2];
+                const int64_t previous_frames_per_outer = previous.shape()[2];
+                const int64_t outer_count = output.shape()[3] * output.shape()[4];
+                float* output_data = output.values().data();
+                const float* previous_data = previous.values().data();
+                sd_parallel_for(0, outer_count * extent, 8, [&](int64_t index) {
+                    const int64_t t = index % extent;
+                    const int64_t outer = index / extent;
+                    const float wb = static_cast<float>(t) / extent;
+                    const float wa = 1.f - wb;
+                    float* output_frame = output_data + frame_size * (t + frames_per_outer * outer);
+                    const float* previous_frame = previous_data +
+                        frame_size * (previous_start + t + previous_frames_per_outer * outer);
+                    for (int64_t pixel = 0; pixel < frame_size; ++pixel) {
+                        output_frame[pixel] = previous_frame[pixel] * wa + output_frame[pixel] * wb;
+                    }
+                });
+                return output;
+            }
+            if (h3_env_flag_enabled("ED_MINIMAX_H3_PARALLEL_TEMPORAL_COPY")) {
+                const int64_t channels = output.shape()[3];
+                const int64_t batches = output.shape()[4];
+                sd_parallel_for(0, batches * channels * extent, 8, [&](int64_t index) {
+                    const int64_t t = index % extent;
+                    const int64_t channel_batch = index / extent;
+                    const int64_t c = channel_batch % channels;
+                    const int64_t b = channel_batch / channels;
+                    const float wb = static_cast<float>(t) / extent;
+                    const float wa = 1.f - wb;
+                    for (int64_t h = 0; h < output.shape()[1]; ++h) {
+                        for (int64_t w = 0; w < output.shape()[0]; ++w) {
+                            output.index(w, h, t, c, b) =
+                                previous.index(w, h, previous_start + t, c, b) * wa +
+                                output.index(w, h, t, c, b) * wb;
+                        }
+                    }
+                });
+                return output;
+            }
+            for (int64_t b = 0; b < output.shape()[4]; ++b) {
+                for (int64_t c = 0; c < output.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) {
+                        for (int64_t h = 0; h < output.shape()[1]; ++h) {
+                            for (int64_t w = 0; w < output.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;
+                                    output.index(w, h, t, c, b) * wb;
                             }
                         }
                     }
@@ -622,6 +709,24 @@ namespace MiniMaxH3VAE {
             }
             shape[2] = total_frames;
             sd::Tensor<float> result(shape);
+            if (h3_env_flag_enabled("ED_MINIMAX_H3_PARALLEL_TEMPORAL_COPY")) {
+                const int64_t frame_size = shape[0] * shape[1];
+                const int64_t outer_count = shape[3] * shape[4];
+                sd_parallel_for(0, outer_count, 8, [&](int64_t outer) {
+                    int64_t temporal_offset = 0;
+                    for (const auto& part : parts) {
+                        const int64_t part_frames = part.shape()[2];
+                        const int64_t part_size = frame_size * part_frames;
+                        const int64_t source_offset = outer * part_size;
+                        const int64_t destination_offset = frame_size * (temporal_offset + total_frames * outer);
+                        std::copy_n(part.values().data() + source_offset,
+                                    part_size,
+                                    result.values().data() + destination_offset);
+                        temporal_offset += part_frames;
+                    }
+                });
+                return result;
+            }
             int64_t offset = 0;
             for (const auto& part : parts) {
                 sd::ops::slice_assign(&result, 2, offset, offset + part.shape()[2], part);
@@ -671,6 +776,38 @@ namespace MiniMaxH3VAE {
             return result;
         }
 
+        sd::Tensor<float> encode_moments(int n_threads,
+                                         const sd::Tensor<float>& x,
+                                         ed_tiling_params_t tiling_params) {
+            ScopedEnvFlag flag("ED_MINIMAX_H3_VAE_RETURN_MOMENTS", "1");
+            auto input = ensure_video_shape(x);
+            auto tiling = h3_tiling(tiling_params);
+            if (input.shape()[2] == 1) {
+                return VAE::encode(n_threads, input, tiling, false, false);
+            }
+            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, false, false);
+                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,
                                  ed_tiling_params_t tiling_params,
@@ -717,17 +854,30 @@ namespace MiniMaxH3VAE {
             }
 
             const bool collect_temporal_parts = h3_env_flag_enabled("ED_MINIMAX_H3_COLLECT_TEMPORAL_PARTS");
+            const bool fused_temporal_assembly =
+                h3_env_flag_enabled("ED_MINIMAX_H3_FUSED_TEMPORAL_ASSEMBLY");
             sd::Tensor<float> result;
             std::vector<sd::Tensor<float>> temporal_parts;
-            if (collect_temporal_parts) {
+            if (collect_temporal_parts && !fused_temporal_assembly) {
                 temporal_parts.reserve(static_cast<size_t>(num_chunks + 1));
             }
             sd::Tensor<float> overlap;
+            sd::Tensor<float> previous_overlap;
+            int64_t assembled_frames = 0;
+            const bool profile_temporal = h3_env_flag_enabled("ED_PROFILE_MINIMAX_H3_VAE_TEMPORAL");
+            int64_t chunk_slice_us = 0;
+            int64_t decode_us = 0;
+            int64_t output_slice_us = 0;
+            int64_t blend_us = 0;
+            int64_t collect_us = 0;
             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]);
+                const int64_t chunk_slice_begin = profile_temporal ? ggml_time_us() : 0;
                 auto chunk    = sd::ops::slice(input, 2, start, end);
+                const int64_t decode_begin = profile_temporal ? ggml_time_us() : 0;
+                if (profile_temporal) chunk_slice_us += decode_begin - chunk_slice_begin;
                 auto decoded  = VAE::decode(n_threads,
                                             chunk,
                                             tiling,
@@ -735,19 +885,98 @@ namespace MiniMaxH3VAE {
                                             circular_x,
                                             circular_y,
                                             silent);
+                const int64_t output_slice_begin = profile_temporal ? ggml_time_us() : 0;
+                if (profile_temporal) decode_us += output_slice_begin - decode_begin;
                 if (decoded.empty()) {
                     return {};
                 }
 
+                if (fused_temporal_assembly) {
+                    const int64_t first_begin = std::min<int64_t>(frame_pre_padding, decoded.shape()[2]);
+                    const int64_t first_end = std::min<int64_t>(frames_per_chunk, decoded.shape()[2]);
+                    const int64_t first_frames = std::max<int64_t>(0, first_end - first_begin);
+                    if (result.empty()) {
+                        std::vector<int64_t> shape = decoded.shape();
+                        shape[2] = std::max<int64_t>(1, ((x.shape()[2] - 2) / 5) * 17 + 5);
+                        result = sd::Tensor<float>(std::move(shape));
+                    }
+                    const int64_t frame_size = decoded.shape()[0] * decoded.shape()[1];
+                    const int64_t outer_count = decoded.shape()[3] * decoded.shape()[4];
+                    const int64_t decoded_frames = decoded.shape()[2];
+                    const int64_t result_frames = result.shape()[2];
+                    const int64_t blend_frames = previous_overlap.empty()
+                                                     ? 0
+                                                     : std::min<int64_t>(frame_overlap, first_frames);
+                    sd_parallel_for(0, outer_count, 8, [&](int64_t outer) {
+                        const float* source = decoded.values().data() +
+                                              frame_size * (first_begin + decoded_frames * outer);
+                        float* destination = result.values().data() +
+                                             frame_size * (assembled_frames + result_frames * outer);
+                        if (blend_frames > 0) {
+                            const int64_t previous_frames = previous_overlap.shape()[2];
+                            const float* previous = previous_overlap.values().data() +
+                                                    frame_size * (previous_frames * outer);
+                            for (int64_t t = 0; t < blend_frames; ++t) {
+                                const float wb = static_cast<float>(t) / blend_frames;
+                                const float wa = 1.f - wb;
+                                for (int64_t pixel = 0; pixel < frame_size; ++pixel) {
+                                    destination[t * frame_size + pixel] =
+                                        previous[t * frame_size + pixel] * wa +
+                                        source[t * frame_size + pixel] * wb;
+                                }
+                            }
+                        }
+                        const int64_t copy_frames = first_frames - blend_frames;
+                        if (copy_frames > 0) {
+                            std::copy_n(source + blend_frames * frame_size,
+                                        copy_frames * frame_size,
+                                        destination + blend_frames * frame_size);
+                        }
+                    });
+                    assembled_frames += first_frames;
+
+                    if (i == num_chunks - 1 && decoded_frames > frames_per_chunk + frame_pre_padding) {
+                        const int64_t tail_begin = frames_per_chunk + frame_pre_padding;
+                        const int64_t tail_frames = std::min<int64_t>(
+                            decoded_frames - tail_begin, result.shape()[2] - assembled_frames);
+                        sd_parallel_for(0, outer_count, 8, [&](int64_t outer) {
+                            const float* source = decoded.values().data() +
+                                                  frame_size * (tail_begin + decoded_frames * outer);
+                            float* destination = result.values().data() +
+                                                 frame_size * (assembled_frames + result_frames * outer);
+                            std::copy_n(source, tail_frames * frame_size, destination);
+                        });
+                        assembled_frames += tail_frames;
+                    }
+                    if (decoded_frames > frames_per_chunk + frame_pre_padding) {
+                        previous_overlap = sd::ops::slice(decoded,
+                                                          2,
+                                                          frames_per_chunk + frame_pre_padding,
+                                                          decoded_frames);
+                    } else {
+                        previous_overlap = {};
+                    }
+                    if (profile_temporal) {
+                        collect_us += ggml_time_us() - output_slice_begin;
+                    }
+                    continue;
+                }
+
                 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);
+                const int64_t blend_begin = profile_temporal ? ggml_time_us() : 0;
+                if (profile_temporal) output_slice_us += blend_begin - output_slice_begin;
                 if (!overlap.empty()) {
-                    first   = blend_temporal(overlap, first, frame_overlap);
+                    first   = h3_env_flag_enabled("ED_MINIMAX_H3_MOVE_TEMPORAL_BLEND")
+                                  ? blend_temporal(overlap, std::move(first), frame_overlap)
+                                  : blend_temporal(overlap, first, frame_overlap);
                     overlap = {};
                 }
+                const int64_t collect_begin = profile_temporal ? ggml_time_us() : 0;
+                if (profile_temporal) blend_us += collect_begin - blend_begin;
                 if (collect_temporal_parts) {
                     temporal_parts.push_back(std::move(first));
                 } else {
@@ -769,17 +998,31 @@ namespace MiniMaxH3VAE {
                     }
                     overlap = {};
                 }
+                if (profile_temporal) collect_us += ggml_time_us() - collect_begin;
             }
 
-            if (collect_temporal_parts) {
+            const int64_t final_collect_begin = profile_temporal ? ggml_time_us() : 0;
+            if (collect_temporal_parts && !fused_temporal_assembly) {
                 result = concatenate_temporal_parts(temporal_parts);
             }
+            if (profile_temporal) collect_us += ggml_time_us() - final_collect_begin;
 
             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);
+            const int64_t trim_begin = profile_temporal ? ggml_time_us() : 0;
             if (result.shape()[2] > expected_frames) {
                 result = sd::ops::slice(result, 2, 0, expected_frames);
             }
+            if (profile_temporal) {
+                LOG_INFO("ED_MINIMAX_H3_VAE_TEMPORAL_PROFILE chunks=%lld chunk-slice_ms=%.3f decode_ms=%.3f output-slice_ms=%.3f blend_ms=%.3f collect_ms=%.3f trim_ms=%.3f",
+                         static_cast<long long>(num_chunks),
+                         chunk_slice_us / 1000.0,
+                         decode_us / 1000.0,
+                         output_slice_us / 1000.0,
+                         blend_us / 1000.0,
+                         collect_us / 1000.0,
+                         (ggml_time_us() - trim_begin) / 1000.0);
+            }
             return result;
         }
 
@@ -832,12 +1075,25 @@ namespace MiniMaxH3VAE {
                     auto pe = make_input(rope_cache);
                     out     = model.decode(&runner_ctx, value, pe, mean, std);
                 } else {
-                    out = model.encode(&runner_ctx, value, mean, std);
+                    out = model.encode(&runner_ctx,
+                                       value,
+                                       mean,
+                                       std,
+                                       h3_env_flag_enabled("ED_MINIMAX_H3_VAE_RETURN_MOMENTS"));
                 }
                 auto graph = new_graph_custom(H3_VIDEO_VAE_GRAPH_SIZE);
                 ggml_build_forward_expand(graph, out);
                 return graph;
             };
+            if (h3_env_flag_enabled("ED_MINIMAX_H3_VAE_TILE_GRAPH_REUSE")) {
+                std::vector<const sd::Tensor<float>*> ordered_inputs = {&input, &pixel_mean, &pixel_std};
+                if (decode_graph) {
+                    ordered_inputs.push_back(&rope_cache);
+                }
+                if (auto out = GGMLRunner::compute_reuse<float>(get_graph, ordered_inputs, n_threads, false)) {
+                    return restore_trailing_singleton_dims(std::move(*out), 5);
+                }
+            }
             return restore_trailing_singleton_dims(
                 GGMLRunner::compute<float>(get_graph, n_threads, false),
                 5);
diff --git a/src/dit_models/models/minimax_h3_full.hpp b/src/dit_models/models/minimax_h3_full.hpp
index 8ada3b1..45aa217 100644
--- a/src/dit_models/models/minimax_h3_full.hpp
+++ b/src/dit_models/models/minimax_h3_full.hpp
@@ -12,6 +12,7 @@
 
 #include "backend/ggml/ggml_graph_cut.h"
 #include "dit_models/components/common/common_dit.hpp"
+#include "backend/ggml/ed_ggml_modulation_ext.hpp"
 #include "backend/ggml/ggml_extend.hpp"
 #include "dit_models/components/common/rope.hpp"
 
@@ -89,7 +90,14 @@ namespace MiniMaxH3 {
                 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);
+                int64_t qkv_out_dim = weight->ne[1];
+                if (const auto* k_weight = find("blocks.0.attn.qkv_proj.weight.1")) {
+                    qkv_out_dim += k_weight->ne[1];
+                }
+                if (const auto* v_weight = find("blocks.0.attn.qkv_proj.weight.2")) {
+                    qkv_out_dim += v_weight->ne[1];
+                }
+                config.num_attention_heads = qkv_out_dim / (3 * config.attention_head_dim);
             }
             if (const auto* weight = find("blocks.0.mlp.fc1.weight")) {
                 config.ffn_hidden_size = weight->ne[1] / 2;
@@ -161,7 +169,9 @@ namespace MiniMaxH3 {
             auto fc1 = std::dynamic_pointer_cast<Linear>(blocks["fc1"]);
             auto fc2 = std::dynamic_pointer_cast<Linear>(blocks["fc2"]);
             const bool use_mlp_tensor_cores = h3_env_flag_enabled("ED_MINIMAX_H3_MLP_FP16_CUBLAS");
-            const bool use_fc1_tensor_cores = use_mlp_tensor_cores || h3_env_flag_enabled("ED_MINIMAX_H3_FC1_FP16_CUBLAS");
+            const bool use_fc1_tensor_cores = use_mlp_tensor_cores ||
+                                              h3_env_flag_enabled("ED_MINIMAX_H3_FC1_FP16_CUBLAS") ||
+                                              h3_env_flag_enabled("ED_MINIMAX_H3_FC1_F32_OUTPUT");
             const bool use_fc2_tensor_cores = use_mlp_tensor_cores || h3_env_flag_enabled("ED_MINIMAX_H3_FC2_FP16_CUBLAS");
             fc1->set_force_prec_f32(!use_fc1_tensor_cores);
             fc2->set_force_prec_f32(!use_fc2_tensor_cores);
@@ -422,9 +432,20 @@ namespace MiniMaxH3 {
                                        segment.modulation_row);
             const bool use_views = !h3_env_flag_enabled("ED_MINIMAX_H3_DISABLE_SEGMENT_VIEW");
             auto part = ggml_ext_slice(ctx, x, 1, segment.start, segment.end, !use_views);
-            part      = ggml_add(ctx,
-                                 ggml_add(ctx, part, ggml_mul(ctx, part, mods[scale_index])),
-                                 mods[shift_index]);
+            if (h3_env_flag_enabled("ED_MINIMAX_H3_FUSED_SEGMENT_MODULATION") ||
+                h3_env_flag_enabled("ED_MINIMAX_H3_FUSED_SEGMENT_MODULATE")) {
+                if (auto fused = edgedit::ggml_ext::fused_modulate_custom(ctx, part, mods[shift_index], mods[scale_index])) {
+                    part = fused;
+                } else {
+                    part = ggml_add(ctx,
+                                    ggml_add(ctx, part, ggml_mul(ctx, part, mods[scale_index])),
+                                    mods[shift_index]);
+                }
+            } else {
+                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;
@@ -443,7 +464,14 @@ namespace MiniMaxH3 {
             const bool use_views = !h3_env_flag_enabled("ED_MINIMAX_H3_DISABLE_SEGMENT_VIEW");
             auto base = ggml_ext_slice(ctx, x, 1, segment.start, segment.end, !use_views);
             auto add  = ggml_ext_slice(ctx, update, 1, segment.start, segment.end, !use_views);
-            auto part = ggml_add(ctx, base, ggml_mul(ctx, add, mods[gate_index]));
+            ggml_tensor* part = nullptr;
+            if (h3_env_flag_enabled("ED_MINIMAX_H3_FUSED_SEGMENT_MODULATION") ||
+                h3_env_flag_enabled("ED_MINIMAX_H3_FUSED_SEGMENT_RESIDUAL_GATE")) {
+                part = edgedit::ggml_ext::fused_residual_gate_custom(ctx, base, add, mods[gate_index]);
+            }
+            if (part == nullptr) {
+                part = ggml_add(ctx, base, ggml_mul(ctx, add, mods[gate_index]));
+            }
             out       = out == nullptr ? part : ggml_concat(ctx, out, part, 1);
         }
         return out;
@@ -659,7 +687,7 @@ namespace MiniMaxH3 {
                                                       const std::vector<SequenceSegment>& sequence_segments,
                                                       const TokenModulationSpan& video_segment,
                                                       const TokenModulationSpan& audio_segment,
-                                                      float audio_slope) {
+                                                      ggml_tensor* 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"]);
 
@@ -779,7 +807,7 @@ namespace MiniMaxH3 {
                                                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);
+            audio_out        = ggml_mul(ctx->ggml_ctx, audio_out, ggml_neg(ctx->ggml_ctx, audio_slope));
             return {video_out, audio_out};
         }
     };
@@ -1022,6 +1050,7 @@ namespace MiniMaxH3 {
         sd::Tensor<float> audio_input_cache;
         sd::Tensor<float> position_input_cache;
         sd::Tensor<float> timestep_feature_input_cache;
+        sd::Tensor<float> audio_slope_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;
@@ -1179,6 +1208,10 @@ namespace MiniMaxH3 {
             }
 
             auto runner_ctx = get_context();
+            audio_slope_input_cache = sd::Tensor<float>(
+                {1},
+                {time_shift_slope(sigma_v, video_shift, audio_shift)});
+            auto audio_slope_tensor = make_input(audio_slope_input_cache);
             auto output     = model.forward(&runner_ctx,
                                             video,
                                             audio,
@@ -1194,7 +1227,7 @@ namespace MiniMaxH3 {
                                             layout.sequence_segments,
                                             layout.video_segment,
                                             layout.audio_segment,
-                                            time_shift_slope(sigma_v, video_shift, audio_shift));
+                                            audio_slope_tensor);
             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);
@@ -1227,6 +1260,77 @@ namespace MiniMaxH3 {
                                    params.minimax_video_sigma_shift,
                                    params.minimax_audio_sigma_shift);
             };
+            if (h3_env_flag_enabled("ED_MINIMAX_H3_REUSE_GRAPH")) {
+                auto split_for_reuse = split_av_latents(*params.x, params.minimax_audio_length);
+                video_input_cache = std::move(split_for_reuse.first);
+                audio_input_cache = std::move(split_for_reuse.second);
+                const float sigma_v = std::clamp((*params.timesteps)[0] / 1000.f, 1e-6f, 1.f);
+                const float t_v     = 1.f - sigma_v;
+                const float t_a     = 1.f - time_shift_sigma(sigma_v,
+                                                              params.minimax_video_sigma_shift,
+                                                              params.minimax_audio_sigma_shift);
+                auto layout_for_reuse = build_layout(params.context->shape()[1],
+                                                     video_input_cache.shape()[2],
+                                                     video_input_cache.shape()[1],
+                                                     video_input_cache.shape()[0],
+                                                     params.minimax_audio_length,
+                                                     conditions,
+                                                     audio_conditions,
+                                                     params.minimax_keyframe_indices == nullptr ? empty_int : *params.minimax_keyframe_indices,
+                                                     reference_blocks,
+                                                     params.minimax_text_token_tags == nullptr ? empty_int : *params.minimax_text_token_tags,
+                                                     t_v,
+                                                     t_a);
+                position_input_cache = sd::Tensor<float>(
+                    {3, static_cast<int64_t>(layout_for_reuse.positions.size() / 3)},
+                    layout_for_reuse.positions);
+                if (config.uses_adaln_curves()) {
+                    std::vector<float> fractions(layout_for_reuse.timesteps.size());
+                    for (size_t i = 0; i < layout_for_reuse.timesteps.size(); ++i) {
+                        float position = std::clamp(layout_for_reuse.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));
+                        fractions[i]   = position - index;
+                    }
+                    curve_fraction_input_cache = sd::Tensor<float>(
+                        {1, static_cast<int64_t>(fractions.size())},
+                        fractions);
+                } else {
+                    timestep_feature_input_cache = sd::Tensor<float>(
+                        {config.timestep_input_dim, static_cast<int64_t>(layout_for_reuse.timesteps.size())},
+                        timestep_embedding(layout_for_reuse.timesteps,
+                                           static_cast<int>(config.timestep_input_dim),
+                                           10000,
+                                           true,
+                                           1.f));
+                }
+                audio_slope_input_cache = sd::Tensor<float>(
+                    {1},
+                    {time_shift_slope(sigma_v,
+                                      params.minimax_video_sigma_shift,
+                                      params.minimax_audio_sigma_shift)});
+                std::vector<const sd::Tensor<float>*> ordered_inputs;
+                ordered_inputs.reserve(8 + conditions.size() + audio_conditions.size());
+                ordered_inputs.push_back(&video_input_cache);
+                ordered_inputs.push_back(&audio_input_cache);
+                ordered_inputs.push_back(params.context);
+                for (const auto& condition : conditions) {
+                    ordered_inputs.push_back(&condition);
+                }
+                for (const auto& condition : audio_conditions) {
+                    ordered_inputs.push_back(&condition);
+                }
+                ordered_inputs.push_back(&position_input_cache);
+                if (config.uses_adaln_curves()) {
+                    ordered_inputs.push_back(&curve_fraction_input_cache);
+                } else {
+                    ordered_inputs.push_back(&timestep_feature_input_cache);
+                }
+                ordered_inputs.push_back(&audio_slope_input_cache);
+                if (auto out = GGMLRunner::compute_reuse<float>(get_graph, ordered_inputs, n_threads, false)) {
+                    return restore_trailing_singleton_dims(std::move(*out), params.x->dim());
+                }
+            }
             return restore_trailing_singleton_dims(GGMLRunner::compute<float>(get_graph,
                                                                               n_threads,
                                                                               false,
diff --git a/src/dit_models/pipelines/minimax_h3_pipeline.cpp b/src/dit_models/pipelines/minimax_h3_pipeline.cpp
index a49e855..b4ee029 100644
--- a/src/dit_models/pipelines/minimax_h3_pipeline.cpp
+++ b/src/dit_models/pipelines/minimax_h3_pipeline.cpp
@@ -5,6 +5,7 @@
 #include <cmath>
 #include <cstdint>
 #include <cstring>
+#include <fstream>
 #include <limits>
 #include <iomanip>
 #include <set>
@@ -23,6 +24,30 @@
 namespace edgedit {
 namespace {
 
+struct ScopedEnvVar {
+    std::string name;
+    std::string old_value;
+    bool had_value = false;
+
+    ScopedEnvVar(const char* key, const std::string& value)
+        : name(key) {
+        const char* current = std::getenv(key);
+        if (current != nullptr) {
+            had_value = true;
+            old_value = current;
+        }
+        setenv(name.c_str(), value.c_str(), 1);
+    }
+
+    ~ScopedEnvVar() {
+        if (had_value) {
+            setenv(name.c_str(), old_value.c_str(), 1);
+        } else {
+            unsetenv(name.c_str());
+        }
+    }
+};
+
 bool set_minimax_error(std::string* error, const char* message) {
     if (error != nullptr) {
         *error = message;
@@ -35,12 +60,38 @@ uint8_t h3_to_u8(float value) {
     return static_cast<uint8_t>(std::round(std::clamp(value, 0.0f, 1.0f) * 255.0f));
 }
 
+float h3_round_to_fp16(float value) {
+    return ggml_fp16_to_fp32(ggml_fp32_to_fp16(value));
+}
+
 int64_t h3_resolve_seed(int64_t seed) {
     return seed >= 0 ? seed : static_cast<int64_t>(std::time(nullptr));
 }
 
 bool h3_profile_enabled();
 
+void h3_dump_vae_latent_if_requested(const sd::Tensor<float>& latent) {
+    const char* base_path = std::getenv("ED_MINIMAX_H3_DUMP_VAE_LATENT");
+    if (base_path == nullptr || base_path[0] == '\0') {
+        return;
+    }
+    std::ofstream data_out(std::string(base_path) + ".f32.bin", std::ios::binary);
+    if (data_out) {
+        data_out.write(reinterpret_cast<const char*>(latent.values().data()),
+                       static_cast<std::streamsize>(latent.values().size() * sizeof(float)));
+    }
+    std::ofstream shape_out(std::string(base_path) + ".shape");
+    if (shape_out) {
+        for (size_t index = 0; index < latent.shape().size(); ++index) {
+            if (index > 0) {
+                shape_out << ' ';
+            }
+            shape_out << latent.shape()[index];
+        }
+        shape_out << '\n';
+    }
+}
+
 ed_tiling_params_t h3_vae_tiling(const ModelRuntime& runtime) {
     ed_tiling_params_t tiling = runtime.vae_tiling();
     if (tiling.force_disable) {
@@ -171,6 +222,40 @@ void h3_trace_tensor(const char* name, const sd::Tensor<float>& tensor) {
              maximum);
 }
 
+sd::Tensor<float> h3_sample_vae_moments(const sd::Tensor<float>& moments,
+                                        std::shared_ptr<RNG> rng) {
+    if (moments.empty() || moments.shape().size() < 4 || moments.shape()[3] != 48) {
+        return {};
+    }
+    sd::Tensor<float> mean = sd::ops::slice(moments, 3, 0, 24);
+    sd::Tensor<float> logvar = sd::ops::slice(moments, 3, 24, 48);
+    sd::Tensor<float> stddev = sd::ops::exp(0.5f * sd::ops::clamp(logvar, -30.0f, 20.0f));
+    sd::Tensor<float> noise = sd::randn_like<float>(mean, rng);
+    sd::Tensor<float> latents = mean + stddev * noise;
+    for (int64_t index = 0; index < latents.numel(); ++index) {
+        latents[index] = h3_round_to_fp16(latents[index]);
+    }
+    return latents;
+}
+
+sd::Tensor<float> h3_encode_vae_condition(MiniMaxH3VAE::MiniMaxH3VideoVAERunner* vae,
+                                          int n_threads,
+                                          const sd::Tensor<float>& video,
+                                          ed_tiling_params_t tiling) {
+    auto moments = vae->encode_moments(n_threads, video, tiling);
+    auto rng = std::make_shared<PhiloxRNG>(42);
+    auto latent = h3_sample_vae_moments(moments, rng);
+    if (!latent.empty()) {
+        return latent;
+    }
+    return vae->encode(n_threads, video, tiling);
+}
+
+void h3_apply_condition_noise(sd::Tensor<float>* latent, std::shared_ptr<RNG> rng) {
+    *latent = *latent * MiniMaxH3::VISUAL_COND_TIMESTEP +
+              sd::randn_like<float>(*latent, rng) * (1.0f - MiniMaxH3::VISUAL_COND_TIMESTEP);
+}
+
 sd::Tensor<float> h3_pack_audio_and_video_latents(const sd::Tensor<float>& video,
                                                    const sd::Tensor<float>& audio) {
     if (audio.empty()) {
@@ -196,19 +281,46 @@ sd::Tensor<float> h3_image_to_tensor(const ed_image_t& image, int width, int hei
     const int source_width = static_cast<int>(image.width);
     const int source_height = static_cast<int>(image.height);
     const int source_channels = static_cast<int>(image.channels);
-    sd::Tensor<float> tensor({width, height, 3, 1});
+    sd::Tensor<float> source({source_width, source_height, 3, 1});
+    for (int y = 0; y < source_height; ++y) {
+        for (int x = 0; x < source_width; ++x) {
+            const uint8_t* pixel = image.data +
+                                   (static_cast<size_t>(y) * source_width + static_cast<size_t>(x)) * source_channels;
+            for (int channel = 0; channel < 3; ++channel) {
+                source.index(x, y, channel, 0) = static_cast<float>(pixel[std::min(channel, source_channels - 1)]) / 255.0f;
+            }
+        }
+    }
+    return sd::ops::interpolate(source,
+                                std::vector<int64_t>{width, height, 3, 1},
+                                sd::ops::InterpolateMode::Lanczos,
+                                false,
+                                true);
+}
+
+sd::Tensor<float> h3_image_to_tensor_cover_crop(const ed_image_t& image, int width, int height) {
+    if (image.data == nullptr || image.width <= 0 || image.height <= 0 || image.channels <= 0) {
+        return {};
+    }
+    const double scale = std::max(static_cast<double>(width) / static_cast<double>(image.width),
+                                  static_cast<double>(height) / static_cast<double>(image.height));
+    const int resized_width = std::max(width, static_cast<int>(std::round(static_cast<double>(image.width) * scale)));
+    const int resized_height = std::max(height, static_cast<int>(std::round(static_cast<double>(image.height) * scale)));
+    sd::Tensor<float> resized = h3_image_to_tensor(image, resized_width, resized_height);
+    if (resized.empty()) {
+        return {};
+    }
+    const int left = std::max(0, (resized_width - width) / 2);
+    const int top = std::max(0, (resized_height - height) / 2);
+    sd::Tensor<float> cropped({width, height, 3, 1});
     for (int y = 0; y < height; ++y) {
-        const int source_y = std::min(source_height - 1, static_cast<int>((static_cast<int64_t>(y) * source_height) / height));
         for (int x = 0; x < width; ++x) {
-            const int source_x = std::min(source_width - 1, static_cast<int>((static_cast<int64_t>(x) * source_width) / width));
-            const uint8_t* pixel = image.data +
-                                   (static_cast<size_t>(source_y) * source_width + static_cast<size_t>(source_x)) * source_channels;
             for (int channel = 0; channel < 3; ++channel) {
-                tensor.index(x, y, channel, 0) = static_cast<float>(pixel[std::min(channel, source_channels - 1)]) / 255.0f;
+                cropped.index(x, y, channel, 0) = resized.index(x + left, y + top, channel, 0);
             }
         }
     }
-    return tensor;
+    return cropped;
 }
 
 struct MiniMaxH3DetectedConfig {
@@ -260,7 +372,14 @@ MiniMaxH3DetectedConfig detect_minimax_config(const String2TensorStorage& tensor
         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);
+        int64_t qkv_out_dim = weight->ne[1];
+        if (const auto* k_weight = find("blocks.0.attn.qkv_proj.weight.1")) {
+            qkv_out_dim += k_weight->ne[1];
+        }
+        if (const auto* v_weight = find("blocks.0.attn.qkv_proj.weight.2")) {
+            qkv_out_dim += v_weight->ne[1];
+        }
+        config.num_attention_heads = qkv_out_dim / (3 * config.attention_head_dim);
     }
     if (const auto* weight = find("blocks.0.mlp.fc1.weight")) {
         config.ffn_hidden_size = weight->ne[1] / 2;
@@ -404,6 +523,7 @@ bool MiniMaxH3Pipeline::prepare(const ed_context_params_t& params,
     registry.ignore_prefix("first_stage_model.encoder.");
     registry.ignore_prefix("text_encoders.llm.visual.");
     registry.ignore_prefix("text_encoders.llm.");
+    registry.ignore_prefix("model.diffusion_model.rope.inv_freq");
 
     if (sentinel_ctx_ == nullptr) {
         ggml_init_params init_params{};
@@ -445,6 +565,10 @@ ed_status_t MiniMaxH3Pipeline::generate_image(const ed_image_generation_params_t
 }
 
 bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
+                                           const ed_image_t* init_image,
+                                           const ed_image_t* end_image,
+                                           int canvas_width,
+                                           int canvas_height,
                                            const ed_image_t* ref_images,
                                            int ref_image_count,
                                            const ed_ref_video_t* ref_videos,
@@ -464,45 +588,72 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
     std::vector<std::vector<std::pair<int, sd::Tensor<float>>>> deepstack_image_embeds(3);
     std::vector<std::pair<int, int64_t>> vision_token_ranges;
     const int vision_patch_size = conditioner_->model.params.vision.patch_size;
-    for (int image_index = 0; image_index < ref_image_count; ++image_index) {
+    auto add_vision_image = [&](const ed_image_t& image,
+                                int image_index,
+                                int width,
+                                int height,
+                                bool keyframe) -> bool {
         const int64_t prepare_begin = profile != nullptr ? ggml_time_ms() : 0;
-        const ed_image_t& image = ref_images[image_index];
-        int width = 0;
-        int height = 0;
-        h3_resize_for_vision(image.width, image.height, &width, &height);
-        sd::Tensor<float> image_tensor = h3_image_to_tensor(image, width, height);
+        sd::Tensor<float> image_tensor = keyframe && image_index > 0
+                                             ? h3_image_to_tensor_cover_crop(image, width, height)
+                                             : h3_image_to_tensor(image, width, height);
         if (image_tensor.empty()) {
-            return set_minimax_error(error, "MiniMax-H3 Ref2VA image reference is invalid");
+            return set_minimax_error(error, keyframe ? "MiniMax-H3 keyframe vision image is invalid"
+                                                     : "MiniMax-H3 Ref2VA image reference is invalid");
         }
         image_tensor = image_tensor * 2.0f - 1.0f;
         if (profile != nullptr) profile->vision_image_prepare_ms += ggml_time_ms() - prepare_begin;
-        LOG_DEBUG("MiniMax-H3 Ref2VA vision image=%dx%d tensor=%s",
-                  width,
-                  height,
-                  sd::tensor_shape_to_string(image_tensor.shape()).c_str());
         const int64_t encode_begin = profile != nullptr ? ggml_time_ms() : 0;
         std::vector<sd::Tensor<float>> image_outputs = conditioner_->model.encode_image_outputs(runtime_->n_threads(), image_tensor);
         if (profile != nullptr) profile->vision_image_encode_ms += ggml_time_ms() - encode_begin;
         if (image_outputs.size() != 4 || image_outputs[0].empty()) {
-            return set_minimax_error(error, "MiniMax-H3 Ref2VA vision encoder failed");
+            return set_minimax_error(error, keyframe ? "MiniMax-H3 keyframe vision encoder failed"
+                                                     : "MiniMax-H3 Ref2VA vision encoder failed");
         }
         sd::Tensor<float> image_embed = std::move(image_outputs[0]);
         const int64_t image_tokens = image_embed.shape()[1];
         const std::string prefix = "<Picture " + std::to_string(image_index + 1) + ">: <|vision_start|>";
-        const std::string prefix_text = "<|im_start|>user\n" + presentations + prefix;
-        const std::vector<int> prefix_tokens = conditioner_->tokenizer->tokenize(prefix_text, nullptr, true, 0, 4096, false);
+        const std::vector<int> prefix_tokens = conditioner_->tokenizer->tokenize(presentations + prefix, nullptr, true, 0, 4096, false);
         presentations += prefix;
         for (int64_t token = 0; token < image_tokens; ++token) {
             presentations += "<|image_pad|>";
         }
-        presentations += "<|vision_end|>\n";
-        image_embeds.emplace_back(static_cast<int>(prefix_tokens.size()), std::move(image_embed));
-        for (size_t layer = 0; layer < deepstack_image_embeds.size(); ++layer) {
-            deepstack_image_embeds[layer].emplace_back(static_cast<int>(prefix_tokens.size()), std::move(image_outputs[layer + 1]));
+        presentations += "<|vision_end|>";
+        if (!keyframe) {
+            presentations += "\n";
         }
         const int embed_index = static_cast<int>(prefix_tokens.size());
+        image_embeds.emplace_back(embed_index, std::move(image_embed));
+        for (size_t layer = 0; layer < deepstack_image_embeds.size(); ++layer) {
+            deepstack_image_embeds[layer].emplace_back(embed_index, std::move(image_outputs[layer + 1]));
+        }
         image_embed_infos.push_back({embed_index, image_tokens, 1, height / vision_patch_size, width / vision_patch_size});
         vision_token_ranges.emplace_back(embed_index, image_tokens);
+        return true;
+    };
+    int keyframe_image_index = 0;
+    if (init_image != nullptr && init_image->data != nullptr) {
+        if (!add_vision_image(*init_image, keyframe_image_index++, canvas_width, canvas_height, true)) {
+            return false;
+        }
+    }
+    if (end_image != nullptr && end_image->data != nullptr) {
+        if (!add_vision_image(*end_image, keyframe_image_index++, canvas_width, canvas_height, true)) {
+            return false;
+        }
+    }
+    for (int image_index = 0; image_index < ref_image_count; ++image_index) {
+        const ed_image_t& image = ref_images[image_index];
+        int width = 0;
+        int height = 0;
+        h3_resize_for_vision(image.width, image.height, &width, &height);
+        LOG_DEBUG("MiniMax-H3 Ref2VA vision image=%dx%d tensor=%s",
+                  width,
+                  height,
+                  "");
+        if (!add_vision_image(image, image_index, width, height, false)) {
+            return false;
+        }
     }
     int video_number = 0;
     int audio_number = 0;
@@ -562,10 +713,10 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
             timestamp_stream << '<' << std::fixed << std::setprecision(1)
                              << (first_time + second_time) * 0.5f << " seconds>";
             const std::string timestamp = timestamp_stream.str();
-            const auto prefix_tokens = conditioner_->tokenizer->tokenize("<|im_start|>user\n" + presentations + timestamp + "<|vision_start|>", nullptr, true, 0, 4096, false);
+            const auto prefix_tokens = conditioner_->tokenizer->tokenize(presentations + timestamp + "<|vision_start|>", nullptr, true, 0, 4096, false);
             presentations += timestamp + "<|vision_start|>";
             const int64_t tokens = outputs[0].shape()[1];
-            for (int64_t token = 0; token < tokens; ++token) presentations += "<|image_pad|>";
+            for (int64_t token = 0; token < tokens; ++token) presentations += "<|video_pad|>";
             presentations += "<|vision_end|>";
             const int embed_index = static_cast<int>(prefix_tokens.size());
             image_embeds.emplace_back(embed_index, std::move(outputs[0]));
@@ -577,9 +728,7 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
     for (int audio_index = 0; audio_index < ref_audio_count; ++audio_index) {
         presentations += "<Audio " + std::to_string(++audio_number) + ">: ";
     }
-    const std::string text = "<|im_start|>user\n" + presentations +
-                             std::string(prompt == nullptr ? "" : prompt) +
-                             "<|im_end|>\n<|im_start|>assistant\n";
+    const std::string text = presentations + std::string(prompt == nullptr ? "" : prompt);
     const int64_t tokenize_begin = profile != nullptr ? ggml_time_ms() : 0;
     const std::vector<int> tokens = conditioner_->tokenizer->tokenize(text, nullptr, true, 0, 4096, false);
     if (profile != nullptr) profile->text_tokenize_ms += ggml_time_ms() - tokenize_begin;
@@ -611,6 +760,7 @@ ed_status_t MiniMaxH3Pipeline::decode_video_latent(const sd::Tensor<float>& late
                                                     MiniMaxH3Profile* profile,
                                                     std::string* error) {
     sd::Tensor<float> vae_latent = vae_->diffusion_to_vae_latents(latent);
+    h3_dump_vae_latent_if_requested(vae_latent);
     ed_tiling_params_t tiling = h3_vae_tiling(*runtime_);
     const int64_t decode_begin = profile != nullptr ? ggml_time_ms() : 0;
     sd::Tensor<float> video = vae_->decode(runtime_->n_threads(), vae_latent, tiling, true);
@@ -775,14 +925,42 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
     sd::Tensor<float> context;
     sd::Tensor<int32_t> token_tags;
     const int64_t cond_context_begin = profile_ptr != nullptr ? ggml_time_ms() : 0;
-    if (!build_text_context(params->prompt, params->ref_images, params->ref_image_count, params->ref_videos, params->ref_video_count, params->ref_audio_count, frames, &context, &token_tags, profile_ptr, error)) return ED_STATUS_GENERATION_FAILED;
+    if (!build_text_context(params->prompt,
+                            params->init_image,
+                            params->end_image,
+                            params->width,
+                            params->height,
+                            params->ref_images,
+                            params->ref_image_count,
+                            params->ref_videos,
+                            params->ref_video_count,
+                            params->ref_audio_count,
+                            frames,
+                            &context,
+                            &token_tags,
+                            profile_ptr,
+                            error)) return ED_STATUS_GENERATION_FAILED;
     if (profile_ptr != nullptr) profile.cond_context_ms = ggml_time_ms() - cond_context_begin;
     const float cfg_scale = params->sample.cfg_scale;
     const bool use_cfg = cfg_scale != 1.0f;
     sd::Tensor<float> uncond_context;
     sd::Tensor<int32_t> uncond_token_tags;
     const int64_t uncond_context_begin = profile_ptr != nullptr ? ggml_time_ms() : 0;
-    if (use_cfg && !build_text_context(params->negative_prompt, params->ref_images, params->ref_image_count, params->ref_videos, params->ref_video_count, params->ref_audio_count, frames, &uncond_context, &uncond_token_tags, profile_ptr, error)) {
+    if (use_cfg && !build_text_context(params->negative_prompt,
+                                       params->init_image,
+                                       params->end_image,
+                                       params->width,
+                                       params->height,
+                                       params->ref_images,
+                                       params->ref_image_count,
+                                       params->ref_videos,
+                                       params->ref_video_count,
+                                       params->ref_audio_count,
+                                       frames,
+                                       &uncond_context,
+                                       &uncond_token_tags,
+                                       profile_ptr,
+                                       error)) {
         return ED_STATUS_GENERATION_FAILED;
     }
     if (profile_ptr != nullptr && use_cfg) profile.uncond_context_ms = ggml_time_ms() - uncond_context_begin;
@@ -792,25 +970,29 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
     const int latent_height = params->height / 16;
     std::vector<sd::Tensor<float>> keyframe_latents;
     std::vector<int32_t> keyframe_indices;
+    auto request_rng = std::make_shared<PhiloxRNG>(static_cast<uint64_t>(resolved_seed));
     auto add_keyframe = [&](const ed_image_t* image, int32_t frame_index, const char* name) -> bool {
         if (image == nullptr || image->data == nullptr) {
             return true;
         }
-        sd::Tensor<float> image_tensor = h3_image_to_tensor(*image, params->width, params->height);
+        sd::Tensor<float> image_tensor = frame_index == 0
+                                             ? h3_image_to_tensor(*image, params->width, params->height)
+                                             : h3_image_to_tensor_cover_crop(*image, params->width, params->height);
         if (image_tensor.empty()) {
             return set_minimax_error(error, "MiniMax-H3 keyframe image is invalid");
         }
         sd::Tensor<float> video_image = image_tensor.reshape({params->width, params->height, 1, 3, 1});
         const int64_t vae_encode_begin = profile_ptr != nullptr ? ggml_time_ms() : 0;
-        sd::Tensor<float> vae_latent = vae_->encode(runtime_->n_threads(), video_image, h3_vae_tiling(*runtime_));
+        sd::Tensor<float> vae_latent = h3_encode_vae_condition(vae_.get(),
+                                                               runtime_->n_threads(),
+                                                               video_image,
+                                                               h3_vae_tiling(*runtime_));
         if (profile_ptr != nullptr) profile.keyframe_vae_encode_ms += ggml_time_ms() - vae_encode_begin;
         if (vae_latent.empty()) {
             return set_minimax_error(error, "MiniMax-H3 keyframe VAE encode failed");
         }
         sd::Tensor<float> latent = vae_->vae_to_diffusion_latents(vae_latent);
-        auto condition_rng = std::make_shared<PhiloxRNG>(static_cast<uint64_t>(resolved_seed));
-        latent = latent * MiniMaxH3::VISUAL_COND_TIMESTEP +
-                 sd::randn_like<float>(latent, condition_rng) * (1.0f - MiniMaxH3::VISUAL_COND_TIMESTEP);
+        h3_apply_condition_noise(&latent, request_rng);
         h3_trace_tensor((std::string(name) + "_keyframe_latent").c_str(), latent);
         keyframe_latents.push_back(std::move(latent));
         keyframe_indices.push_back(frame_index);
@@ -863,16 +1045,17 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
         }
         sd::Tensor<float> video_image = image_tensor.reshape({reference_width, reference_height, 1, 3, 1});
         const int64_t vae_encode_begin = profile_ptr != nullptr ? ggml_time_ms() : 0;
-        sd::Tensor<float> vae_latent = vae_->encode(runtime_->n_threads(), video_image, h3_vae_tiling(*runtime_));
+        sd::Tensor<float> vae_latent = h3_encode_vae_condition(vae_.get(),
+                                                               runtime_->n_threads(),
+                                                               video_image,
+                                                               h3_vae_tiling(*runtime_));
         if (profile_ptr != nullptr) profile.reference_video_vae_encode_ms += ggml_time_ms() - vae_encode_begin;
         if (vae_latent.empty()) {
             set_minimax_error(error, "MiniMax-H3 Ref2VA image VAE encode failed");
             return ED_STATUS_GENERATION_FAILED;
         }
         sd::Tensor<float> latent = vae_->vae_to_diffusion_latents(vae_latent);
-        auto condition_rng = std::make_shared<PhiloxRNG>(static_cast<uint64_t>(resolved_seed));
-        latent = latent * MiniMaxH3::VISUAL_COND_TIMESTEP +
-                 sd::randn_like<float>(latent, condition_rng) * (1.0f - MiniMaxH3::VISUAL_COND_TIMESTEP);
+        h3_apply_condition_noise(&latent, request_rng);
         h3_trace_tensor(("ref_image_" + std::to_string(reference_index) + "_latent").c_str(), latent);
         const int32_t encoded_image_index = static_cast<int32_t>(reference_latents.size());
         reference_latents.push_back(std::move(latent));
@@ -909,7 +1092,10 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
             }
         }
         const int64_t vae_encode_begin = profile_ptr != nullptr ? ggml_time_ms() : 0;
-        auto vae_latent = vae_->encode(runtime_->n_threads(), video_reference, h3_vae_tiling(*runtime_));
+        auto vae_latent = h3_encode_vae_condition(vae_.get(),
+                                                  runtime_->n_threads(),
+                                                  video_reference,
+                                                  h3_vae_tiling(*runtime_));
         if (profile_ptr != nullptr) profile.reference_video_vae_encode_ms += ggml_time_ms() - vae_encode_begin;
         if (vae_latent.empty()) { set_minimax_error(error, "MiniMax-H3 Ref2VA video VAE encode failed"); return ED_STATUS_GENERATION_FAILED; }
         int32_t audio_index = -1;
@@ -917,8 +1103,7 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
             set_minimax_error(error, "MiniMax-H3 Ref2VA video audio encode failed"); return ED_STATUS_GENERATION_FAILED;
         }
         auto latent = vae_->vae_to_diffusion_latents(vae_latent);
-        auto condition_rng = std::make_shared<PhiloxRNG>(static_cast<uint64_t>(resolved_seed));
-        latent = latent * MiniMaxH3::VISUAL_COND_TIMESTEP + sd::randn_like<float>(latent, condition_rng) * (1.0f - MiniMaxH3::VISUAL_COND_TIMESTEP);
+        h3_apply_condition_noise(&latent, request_rng);
         const int32_t encoded_video_index = static_cast<int32_t>(reference_latents.size());
         reference_latents.push_back(std::move(latent));
         reference_blocks.push_back({audio_index >= 0 ? MiniMaxH3ReferenceKind::VIDEO_AUDIO : MiniMaxH3ReferenceKind::VIDEO, encoded_video_index, audio_index});
@@ -934,9 +1119,9 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
     sd::Tensor<float> video = sd::zeros<float>({latent_width, latent_height, latent_frames, 24, 1});
     sd::Tensor<float> audio = sd::zeros<float>({audio_length, 2, 32, 1});
     const int64_t noise_begin = profile_ptr != nullptr ? ggml_time_ms() : 0;
+    video = sd::randn_like<float>(video, request_rng);
+    audio = sd::randn_like<float>(audio, request_rng);
     sd::Tensor<float> packed = h3_pack_audio_and_video_latents(video, audio);
-    auto rng = std::make_shared<PhiloxRNG>(static_cast<uint64_t>(resolved_seed));
-    packed = sd::randn_like<float>(packed, rng);
     if (profile_ptr != nullptr) profile.noise_init_ms = ggml_time_ms() - noise_begin;
     h3_trace_tensor("initial_packed_noise", packed);
     const int steps = params->sample.steps > 0 ? params->sample.steps : 20;
@@ -967,6 +1152,7 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
         diffusion_params.minimax_video_sigma_shift = video_sigma_shift;
         diffusion_params.minimax_audio_sigma_shift = 3.0f;
         const int64_t cond_begin = profile_ptr != nullptr ? ggml_time_ms() : 0;
+        ScopedEnvVar current_step_env("ED_MINIMAX_H3_CURRENT_STEP", std::to_string(step));
         sd::Tensor<float> velocity = diffusion_->compute(runtime_->n_threads(), diffusion_params);
         if (profile_ptr != nullptr) {
             profile.diffusion_cond_ms += ggml_time_ms() - cond_begin;
diff --git a/src/dit_models/pipelines/minimax_h3_pipeline.hpp b/src/dit_models/pipelines/minimax_h3_pipeline.hpp
index 61489ca..f04579a 100644
--- a/src/dit_models/pipelines/minimax_h3_pipeline.hpp
+++ b/src/dit_models/pipelines/minimax_h3_pipeline.hpp
@@ -67,6 +67,10 @@ class MiniMaxH3Pipeline final : public DiTPipeline {
     ggml_tensor* sentinel_tensor_ = nullptr;
 
     bool build_text_context(const char* prompt,
+                            const ed_image_t* init_image,
+                            const ed_image_t* end_image,
+                            int canvas_width,
+                            int canvas_height,
                             const ed_image_t* ref_images,
                             int ref_image_count,
                             const ed_ref_video_t* ref_videos,
diff --git a/third_party/ggml b/third_party/ggml
index cac93ee..5c68bd3 160000
--- a/third_party/ggml
+++ b/third_party/ggml
@@ -1 +1 @@
-Subproject commit cac93ee079478004b5c9abbb8f081b401f6a46ac
+Subproject commit 5c68bd346bf6ec5114b60409d7a18534ee9f92da

From a82256e772596cecb7806e92f1b4f0523d2be14d Mon Sep 17 00:00:00 2001
From: Komorebi623 <wang-ty22@mails.tsinghua.edu.cn>
Date: Sun, 9 Aug 2026 11:36:08 +0800
Subject: [PATCH 14/25] Improve MiniMax H3 diffusers benchmark profiling

---
 .../run_minimax_h3_fl2va_quantized.py         | 128 +++++++++++++++++-
 1 file changed, 124 insertions(+), 4 deletions(-)

diff --git a/scripts/diffusers/run_minimax_h3_fl2va_quantized.py b/scripts/diffusers/run_minimax_h3_fl2va_quantized.py
index 15d3c72..48f83ff 100755
--- a/scripts/diffusers/run_minimax_h3_fl2va_quantized.py
+++ b/scripts/diffusers/run_minimax_h3_fl2va_quantized.py
@@ -58,11 +58,45 @@ def make_quant_config(bits: int):
     raise ValueError(f"unsupported quantization bits: {bits}")
 
 
+def export_operator_profile(profiler, output_prefix: Path, captured_call: int) -> dict:
+    output_prefix.parent.mkdir(parents=True, exist_ok=True)
+    trace_path = output_prefix.with_suffix(".trace.json.gz")
+    summary_path = output_prefix.with_suffix(".json")
+    table_path = output_prefix.with_suffix(".txt")
+    profiler.export_chrome_trace(str(trace_path))
+    key_averages = profiler.key_averages(group_by_input_shape=True)
+    rows = []
+    for event in key_averages:
+        rows.append(
+            {
+                "key": event.key,
+                "input_shapes": event.input_shapes,
+                "count": event.count,
+                "self_cpu_time_total_us": event.self_cpu_time_total,
+                "cpu_time_total_us": event.cpu_time_total,
+                "self_cuda_time_total_us": event.self_device_time_total,
+                "cuda_time_total_us": event.device_time_total,
+                "cpu_memory_usage_bytes": event.cpu_memory_usage,
+                "cuda_memory_usage_bytes": event.device_memory_usage,
+            }
+        )
+    rows.sort(key=lambda row: row["self_cuda_time_total_us"], reverse=True)
+    summary_path.write_text(json.dumps(rows, indent=2))
+    table_path.write_text(key_averages.table(sort_by="self_cuda_time_total", row_limit=300, max_name_column_width=100))
+    return {
+        "captured_call": captured_call,
+        "summary": str(summary_path),
+        "table": str(table_path),
+        "trace": str(trace_path),
+        "self_cuda_time_total_us": sum(row["self_cuda_time_total_us"] for row in rows),
+    }
+
+
 def main() -> None:
     parser = argparse.ArgumentParser()
     parser.add_argument("--model", type=Path, required=True)
     parser.add_argument("--image", type=Path, required=True)
-    parser.add_argument("--last-image", type=Path, required=True)
+    parser.add_argument("--last-image", type=Path)
     parser.add_argument("--output", type=Path, required=True)
     parser.add_argument("--prompt", default=DEFAULT_PROMPT)
     parser.add_argument("--seed", type=int, default=42)
@@ -75,6 +109,27 @@ def main() -> None:
     parser.add_argument("--no-stream-offload", action="store_true")
     parser.add_argument("--resident", action="store_true", help="keep quantized components resident on the CUDA device")
     parser.add_argument("--profile-transformer", action="store_true", help="synchronize and time every transformer forward")
+    parser.add_argument(
+        "--profile-operators-call",
+        type=int,
+        default=0,
+        help="capture a PyTorch CPU/CUDA operator profile for this 1-based transformer forward call",
+    )
+    parser.add_argument(
+        "--profile-operators-output",
+        type=Path,
+        help="write operator key averages as JSON and a Chrome trace using this path prefix",
+    )
+    parser.add_argument(
+        "--profile-component-operators",
+        choices=("video_vae_encode", "video_vae_decode", "audio_vae_encode", "audio_vae_decode"),
+        help="capture a PyTorch CPU/CUDA operator profile for one component method call",
+    )
+    parser.add_argument(
+        "--profile-component-operators-output",
+        type=Path,
+        help="write component operator profile files using this path prefix",
+    )
     parser.add_argument(
         "--profile-components",
         action="store_true",
@@ -174,6 +229,38 @@ def profile_forward_hook(module, args, kwargs, output):
         pipeline.transformer.register_forward_pre_hook(profile_forward_pre_hook, with_kwargs=True)
         pipeline.transformer.register_forward_hook(profile_forward_hook, with_kwargs=True)
 
+    operator_profile = {"calls": 0, "profiler": None, "captured_call": None}
+    if arguments.profile_operators_call:
+        if arguments.profile_operators_call < 1:
+            raise ValueError("--profile-operators-call must be a positive 1-based call index")
+        if arguments.profile_operators_output is None:
+            raise ValueError("--profile-operators-output is required with --profile-operators-call")
+
+        def operator_profile_pre_hook(module, args, kwargs):
+            operator_profile["calls"] += 1
+            if operator_profile["calls"] != arguments.profile_operators_call:
+                return
+            torch.cuda.synchronize(device)
+            profiler = torch.profiler.profile(
+                activities=[torch.profiler.ProfilerActivity.CPU, torch.profiler.ProfilerActivity.CUDA],
+                record_shapes=True,
+                profile_memory=True,
+                with_stack=False,
+            )
+            profiler.__enter__()
+            operator_profile["profiler"] = profiler
+            operator_profile["captured_call"] = operator_profile["calls"]
+
+        def operator_profile_hook(module, args, kwargs, output):
+            profiler = operator_profile["profiler"]
+            if profiler is None:
+                return
+            torch.cuda.synchronize(device)
+            profiler.__exit__(None, None, None)
+
+        pipeline.transformer.register_forward_pre_hook(operator_profile_pre_hook, with_kwargs=True)
+        pipeline.transformer.register_forward_hook(operator_profile_hook, with_kwargs=True)
+
     component_profile = {
         "text_encoder": {"calls": 0, "seconds": 0.0},
         "video_vae_encode": {"calls": 0, "seconds": 0.0},
@@ -181,20 +268,37 @@ def profile_forward_hook(module, args, kwargs, output):
         "audio_vae_encode": {"calls": 0, "seconds": 0.0},
         "audio_vae_decode": {"calls": 0, "seconds": 0.0},
     }
+    component_operator_profile = {"profiler": None, "component": None}
 
     def profile_method(component_name, method):
         def wrapped(*args, **kwargs):
             torch.cuda.synchronize(device)
             started_at = time.perf_counter()
+            profiler = None
+            if arguments.profile_component_operators == component_name:
+                profiler = torch.profiler.profile(
+                    activities=[torch.profiler.ProfilerActivity.CPU, torch.profiler.ProfilerActivity.CUDA],
+                    record_shapes=True,
+                    profile_memory=True,
+                    with_stack=False,
+                )
+                profiler.__enter__()
             result = method(*args, **kwargs)
             torch.cuda.synchronize(device)
+            if profiler is not None:
+                profiler.__exit__(None, None, None)
+                component_operator_profile["profiler"] = profiler
+                component_operator_profile["component"] = component_name
             component_profile[component_name]["calls"] += 1
             component_profile[component_name]["seconds"] += time.perf_counter() - started_at
             return result
 
         return wrapped
 
-    if arguments.profile_components:
+    if arguments.profile_component_operators and arguments.profile_component_operators_output is None:
+        raise ValueError("--profile-component-operators-output is required with --profile-component-operators")
+
+    if arguments.profile_components or arguments.profile_component_operators:
         def text_encoder_profile_pre_hook(module, args, kwargs):
             torch.cuda.synchronize(device)
             component_profile["text_encoder"]["started_at"] = time.perf_counter()
@@ -213,7 +317,7 @@ def text_encoder_profile_hook(module, args, kwargs, output):
         pipeline.audio_vae.decode = profile_method("audio_vae_decode", pipeline.audio_vae.decode)
 
     first_image = load_image(str(arguments.image))
-    last_image = load_image(str(arguments.last_image))
+    last_image = load_image(str(arguments.last_image)) if arguments.last_image is not None else None
     generator = torch.Generator(device="cpu").manual_seed(arguments.seed)
 
     torch.cuda.reset_peak_memory_stats(device)
@@ -231,6 +335,20 @@ def text_encoder_profile_hook(module, args, kwargs, output):
     )
     generated_at = sync_time()
 
+    operator_profile_summary = None
+    profiler = operator_profile["profiler"]
+    if profiler is not None:
+        operator_profile_summary = export_operator_profile(
+            profiler, arguments.profile_operators_output, operator_profile["captured_call"]
+        )
+
+    component_operator_profile_summary = None
+    if component_operator_profile["profiler"] is not None:
+        component_operator_profile_summary = export_operator_profile(
+            component_operator_profile["profiler"], arguments.profile_component_operators_output, 1
+        )
+        component_operator_profile_summary["component"] = component_operator_profile["component"]
+
     encode_video(
         generated["videos"][0],
         fps=24,
@@ -242,7 +360,7 @@ def text_encoder_profile_hook(module, args, kwargs, output):
 
     results = {
         "framework": "diffusers-main",
-        "workflow": "fl2va",
+        "workflow": "fl2va" if arguments.last_image is not None else "i2va",
         "model": str(arguments.model),
         "device": arguments.device,
         "dtype": "bfloat16",
@@ -275,6 +393,8 @@ def text_encoder_profile_hook(module, args, kwargs, output):
             "end_to_end": finished - started,
         },
         "transformer_forward_calls": transformer_profile["calls"],
+        "operator_profile": operator_profile_summary,
+        "component_operator_profile": component_operator_profile_summary,
         "component_profile": component_profile if arguments.profile_components else None,
         "memory_bytes": {
             "max_allocated_during_generate": torch.cuda.max_memory_allocated(device),

From 7c8bf632413de7e61da78d08235348e94b07e038 Mon Sep 17 00:00:00 2001
From: Komorebi623 <wang-ty22@mails.tsinghua.edu.cn>
Date: Sun, 9 Aug 2026 11:36:33 +0800
Subject: [PATCH 15/25] Support MiniMax H3 diffusers weight names

---
 src/core/runtime/model_loader.cpp | 16 +++++++
 src/utils/name_conversion.cpp     | 71 +++++++++++++++++++++++++++++++
 2 files changed, 87 insertions(+)

diff --git a/src/core/runtime/model_loader.cpp b/src/core/runtime/model_loader.cpp
index cf63a0c..2718e9a 100644
--- a/src/core/runtime/model_loader.cpp
+++ b/src/core/runtime/model_loader.cpp
@@ -368,6 +368,9 @@ static SDVersion infer_transformer_file_version(const std::string& file_path) {
         if (contains(klass, "Wan")) {
             return VERSION_WAN2;
         }
+        if (contains(klass, "MiniMaxH3") || contains(klass, "MiniMax-H3")) {
+            return VERSION_MINIMAX_H3;
+        }
     }
 
     return VERSION_COUNT;
@@ -441,6 +444,9 @@ static SDVersion infer_diffusers_version(const std::string& dir_path) {
             if (contains(klass, "Wan")) {
                 return VERSION_WAN2;
             }
+            if (contains(klass, "MiniMaxH3") || contains(klass, "MiniMax-H3")) {
+                return VERSION_MINIMAX_H3;
+            }
             if (contains(klass, "QwenImageEdit") || contains(klass, "Qwen Image Edit")) {
                 return VERSION_QWEN_IMAGE_EDIT;
             }
@@ -1886,6 +1892,16 @@ bool ModelLoader::load_tensors(std::map<std::string, ggml_tensor*>& tensors,
         if (starts_with(item.first, "__ed_")) {
             continue;
         }
+        bool ignored = false;
+        for (const std::string& ignore_tensor : ignore_tensors) {
+            if (starts_with(item.first, ignore_tensor)) {
+                ignored = true;
+                break;
+            }
+        }
+        if (ignored) {
+            continue;
+        }
         if (tensor_names_in_file.find(item.first) == tensor_names_in_file.end()) {
             LOG_ERROR("tensor '%s' not in model file", item.first.c_str());
             return false;
diff --git a/src/utils/name_conversion.cpp b/src/utils/name_conversion.cpp
index 63243ca..21713a4 100644
--- a/src/utils/name_conversion.cpp
+++ b/src/utils/name_conversion.cpp
@@ -655,6 +655,75 @@ std::string convert_diffusers_dit_to_original_flux(std::string name) {
     return name;
 }
 
+std::string convert_diffusers_dit_to_original_minimax_h3(std::string name) {
+    constexpr int num_layers         = 50;
+    constexpr int num_refiner_layers = 2;
+    static std::unordered_map<std::string, std::string> minimax_h3_name_map;
+
+    if (minimax_h3_name_map.empty()) {
+        minimax_h3_name_map["proj_in.weight"]       = "video_patch_proj.weight";
+        minimax_h3_name_map["proj_in.bias"]         = "video_patch_proj.bias";
+        minimax_h3_name_map["audio_proj_in.weight"] = "audio_patch_proj.weight";
+        minimax_h3_name_map["audio_proj_in.bias"]   = "audio_patch_proj.bias";
+
+        minimax_h3_name_map["context_embedder.weight"] = "condition_proj.weight";
+        minimax_h3_name_map["context_embedder.bias"]   = "condition_proj.bias";
+
+        minimax_h3_name_map["time_embedder.linear_1.weight"] = "time_embedder.proj_in.weight";
+        minimax_h3_name_map["time_embedder.linear_1.bias"]   = "time_embedder.proj_in.bias";
+        minimax_h3_name_map["time_embedder.linear_2.weight"] = "time_embedder.proj_out.weight";
+        minimax_h3_name_map["time_embedder.linear_2.bias"]   = "time_embedder.proj_out.bias";
+
+        auto add_block = [](std::unordered_map<std::string, std::string>& map,
+                            const std::string& src_prefix,
+                            const std::string& dst_prefix) {
+            map[src_prefix + "norm1.weight"] = dst_prefix + "norm1.weight";
+            map[src_prefix + "norm2.weight"] = dst_prefix + "norm2.weight";
+
+            map[src_prefix + "attn.to_q.weight"] = dst_prefix + "attn.qkv_proj.weight";
+            map[src_prefix + "attn.to_q.bias"]   = dst_prefix + "attn.qkv_proj.bias";
+            map[src_prefix + "attn.to_k.weight"] = dst_prefix + "attn.qkv_proj.weight.1";
+            map[src_prefix + "attn.to_k.bias"]   = dst_prefix + "attn.qkv_proj.bias.1";
+            map[src_prefix + "attn.to_v.weight"] = dst_prefix + "attn.qkv_proj.weight.2";
+            map[src_prefix + "attn.to_v.bias"]   = dst_prefix + "attn.qkv_proj.bias.2";
+
+            map[src_prefix + "attn.norm_q.weight"]     = dst_prefix + "attn.q_norm.weight";
+            map[src_prefix + "attn.norm_k.weight"]     = dst_prefix + "attn.k_norm.weight";
+            map[src_prefix + "attn.to_out.0.weight"]   = dst_prefix + "attn.out_proj.weight";
+            map[src_prefix + "attn.to_out.0.bias"]     = dst_prefix + "attn.out_proj.bias";
+            map[src_prefix + "ff.net.0.proj.weight"]   = dst_prefix + "mlp.fc1.weight";
+            map[src_prefix + "ff.net.0.proj.bias"]     = dst_prefix + "mlp.fc1.bias";
+            map[src_prefix + "ff.net.2.weight"]        = dst_prefix + "mlp.fc2.weight";
+            map[src_prefix + "ff.net.2.bias"]          = dst_prefix + "mlp.fc2.bias";
+            map[src_prefix + "adaln_proj.linear.weight"] = dst_prefix + "adaln_proj.linear.weight";
+            map[src_prefix + "adaln_proj.linear.bias"]   = dst_prefix + "adaln_proj.linear.bias";
+        };
+
+        for (int i = 0; i < num_layers; ++i) {
+            add_block(minimax_h3_name_map,
+                      "transformer_blocks." + std::to_string(i) + ".",
+                      "blocks." + std::to_string(i) + ".");
+        }
+        for (int i = 0; i < num_refiner_layers; ++i) {
+            add_block(minimax_h3_name_map,
+                      "token_refiner.refiner_blocks." + std::to_string(i) + ".",
+                      "token_refiner.blocks." + std::to_string(i) + ".");
+        }
+
+        minimax_h3_name_map["token_refiner.final_norm.weight"] = "token_refiner.final_norm.weight";
+        minimax_h3_name_map["norm_out.norm.weight"]            = "final_layer.norm.weight";
+        minimax_h3_name_map["norm_out.linear.weight"]          = "final_layer.adaln_proj.linear.weight";
+        minimax_h3_name_map["norm_out.linear.bias"]            = "final_layer.adaln_proj.linear.bias";
+        minimax_h3_name_map["proj_out.weight"]                 = "final_layer.video_out.weight";
+        minimax_h3_name_map["proj_out.bias"]                   = "final_layer.video_out.bias";
+        minimax_h3_name_map["audio_proj_out.weight"]           = "final_layer.audio_out.weight";
+        minimax_h3_name_map["audio_proj_out.bias"]             = "final_layer.audio_out.bias";
+    }
+
+    replace_with_prefix_map(name, minimax_h3_name_map);
+    return name;
+}
+
 std::string convert_diffusers_dit_to_original_lumina2(std::string name) {
     int num_layers         = 30;
     int num_refiner_layers = 2;
@@ -744,6 +813,8 @@ std::string convert_diffusion_model_name(std::string name, std::string prefix, S
         name = convert_diffusers_dit_to_original_lumina2(name);
     } else if (ed_version_is_anima(version)) {
         name = convert_other_dit_to_original_anima(name);
+    } else if (ed_version_is_minimax_h3(version)) {
+        name = convert_diffusers_dit_to_original_minimax_h3(name);
     }
     return name;
 }

From 08b14a0d6ea38b24d8f85c1f16dffb907cacd7b1 Mon Sep 17 00:00:00 2001
From: Komorebi623 <wang-ty22@mails.tsinghua.edu.cn>
Date: Sun, 9 Aug 2026 14:09:58 +0800
Subject: [PATCH 16/25] Optimize MiniMax H3 VAE short attention

---
 ...-edge-generation-performance-2026-08-09.md | 218 ++++++++++++++++++
 .../ggml/cuda/ed_cuda_attention_v_prep.cu     | 106 +++++++++
 .../ggml/cuda/ed_cuda_attention_v_prep.h      |   4 +
 .../backend/ggml/ed_ggml_attention_ext.hpp    |  90 ++++++++
 src/core/backend/ggml/ggml_extend.hpp         |   7 +-
 .../autoencoders/minimax_h3_vae.hpp           | 137 ++++++++---
 third_party/ggml                              |   2 +-
 7 files changed, 536 insertions(+), 28 deletions(-)

diff --git a/docs/optimization/minimax-h3-edge-generation-performance-2026-08-09.md b/docs/optimization/minimax-h3-edge-generation-performance-2026-08-09.md
index 18f4f59..491871d 100644
--- a/docs/optimization/minimax-h3-edge-generation-performance-2026-08-09.md
+++ b/docs/optimization/minimax-h3-edge-generation-performance-2026-08-09.md
@@ -540,3 +540,221 @@ Artifacts:
 - Latest output video: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-final-vae-audio-optimized-full/final.mp4`
 - Previous visual review frame sheet: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-qkv-fc1-fast-vae-fused-assembly-plane-merge-full/review/comparison.jpg`
 - VAE CONT node profile: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/profile-2026-08-09/vae-swiglu-node-top400/run.log`
+
+## 2026-08-09 Follow-up VAE experiments
+
+Follow-up VAE work focused on preserving quality first. The same short
+`864x480`, 124-frame, 3-step probe was used to iterate quickly, with all DiT
+and prompt settings unchanged. No diffusion parameter, resolution, frame count,
+or scheduler changes were used.
+
+Retained as default-off safety candidates:
+
+- `ED_MINIMAX_H3_VAE_FAST_TEMPORAL_GROUP_NORM=1` now uses an equivalent
+  `permute -> GroupNorm -> permute back` path when the effective batch is one.
+  It avoids the earlier incorrect reshape that mixed temporal and channel
+  dimensions. The corrected path is bit-exact in the MP4 A/B probe (`PSNR=inf`),
+  but the speed win is small: video VAE `5.041s -> 5.002s` in the short run.
+- `ED_MINIMAX_H3_VAE_REUSE_ROPE_CACHE=1` caches the host RoPE table for repeated
+  same-shape VAE decode tiles. It is low risk because the tensor contents are
+  unchanged for identical width/height/frame shapes. The short probe showed a
+  small video VAE change (`5.027s -> 4.988s`); encoded MP4 PSNR was about
+  `49.08dB`, so keep it explicit/default-off until a raw-frame or full-run
+  validation is performed.
+
+Rejected experiments:
+
+- The first attempted `FAST_TEMPORAL_GROUP_NORM` reshape was unsafe. It was
+  faster, but it grouped channels incorrectly across temporal frames, producing
+  visible drift and only `36.06dB` average MP4 PSNR. This implementation was
+  replaced by the bit-exact permute version above.
+- Increasing forced VAE tile size improved speed but damaged visual quality.
+  `32x30` latent tiles reduced short-run video VAE to `4.074s` versus the
+  `16x16` baseline `4.825s`, but fixed-frame review showed obvious fine block
+  and seam artifacts. `16x30` and `18x30` reduced the number of vertical tiles
+  but still introduced visible texture/block changes. These should not be used
+  as quality-preserving acceleration knobs.
+- VAE QKV view slicing remained rejected from the previous experiment: it looked
+  fast but produced severe output drift, so it was not reintroduced.
+
+Current conclusion: the remaining quality-safe VAE gap is mostly inside the
+per-tile GPU compute graph, not CPU tile splitting/merging. `ED_PROFILE_RUNNER`
+shows each steady `16x16` VAE tile decode is about `60ms`, with roughly `54ms`
+in GPU compute and near-zero host copy/allocation. The main actionable path is
+therefore exact kernel/layout work inside the MiniMax-H3 VAE decoder graph
+(`CONT`, Q/K/V materialization, RoPE packing, attention/norm), not larger tile
+sizes or other quality-changing tiling shortcuts.
+
+Follow-up artifacts:
+
+- Bit-exact temporal GN A/B: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/vae-fast-temporal-gn-permute-review/psnr.log`
+- Unsafe GN A/B review: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/vae-fast-temporal-gn-ab-review/ab.jpg`
+- Tile-size quality review: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/vae-tile-size-review/tile32_ab.jpg`
+- Tile-XY quality review: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/vae-tile-xy-review/ab.jpg`
+- Runner profile log: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/vae-runner-profile-3step/run.log`
+
+## 2026-08-09 VAE call-chain profiling update
+
+A new VAE named-node CUDA profile was added for MiniMax-H3 decoder blocks. The
+instrumentation is gated by `ED_MINIMAX_H3_VAE_NAME_NODES=1` and names decoder
+attention QKV projection/split, Q/K RMSNorm, partial RoPE packing, attention,
+feed-forward SwiGLU, and block residual outputs. The profile confirms that the
+remaining video VAE gap is not CPU tile merge/split: the steady 70 tile-decode
+CUDA graphs spend most time inside decoder attention layout and padding.
+
+Short `864x480`, 124-frame, 3-step profile highlights:
+
+| Path | Video VAE decode | Profiled video graphs | Main operator buckets |
+|---|---:|---:|---|
+| Current optimized Edge | `6.213s` under profiler | `2.519s` CUDA op time | `LAYOUT 1.377s`, `ELEMENTWISE 0.361s`, `FLASH_ATTN 0.348s`, `NORM 0.266s` |
+| Diffusers TorchAO INT4 profile | component trace only | `3.400s` CUDA kernels in PyTorch trace | `linear/GEMM` dominates, then layout/copy and attention |
+
+The Edge profile is profiler-inflated, but the call-chain ranking is clear. In
+warm video VAE graphs, `LAYOUT` averages about `19.7ms` per tile graph, while
+FlashAttention averages about `4.0ms`. The largest single named removable item
+was the three materialized Q/K/V chunks from the decoder `to_qkv` projection:
+`vae.b*.attn.qkv (view) (cont)` summed to `335.7ms` across the 70 profiled tile
+graphs. The rest of the layout time is distributed across FlashAttention's
+current 256-KV padding path (`PAD/CPY/CONCAT`) and smaller output projection
+layout copies.
+
+A default-off exact candidate was added:
+
+- `ED_MINIMAX_H3_VAE_FUSED_QKV_SPLIT=1` replaces the three `ggml_ext_chunk(...,
+  cont=true)` materializations in MiniMax-H3 VAE decoder attention with one CUDA
+  custom `ed_fused_attention_qkv_split_pack_f32` pack and three views. It changes
+  only data movement, not math.
+
+Validation on the same short A/B:
+
+| Path | Video VAE | Decode video-vae | MP4 PSNR vs control |
+|---|---:|---:|---:|
+| Control | temporal decode `4.759s` | `5.171s` | reference |
+| Fused QKV split | temporal decode `4.743s` | `5.051s` | `inf` |
+
+The fused split removes the named QKV `CONT` cost (`335.7ms -> 0` in the node
+profile), but replaces it with `212.1ms` of custom pack work and exposes no
+large end-to-end win yet (`~0.12s` in this short A/B, within some run variance).
+Keep it default-off until a full-run and second-content visual validation show a
+stable benefit.
+
+The next likely quality-safe target is avoiding or reducing the FlashAttention
+KV padding/materialization for H3 VAE's short sequence (`L=1797`, `d=64`). The
+existing cuDNN unpadded path is normally preferred for `L>=4096`; it also has an
+`ED_CUDNN_SDPA_SHORT_F16_SELF_ATTN=1` gate for shorter self-attention, but H3 VAE
+currently feeds the ggml attention path with F32 Q and F16 K/V packing semantics,
+so it does not hit that F16 short-sequence cuDNN route as-is. H3 VAE therefore
+falls back to ggml FlashAttention with KV padding to 2048. That accounts for much
+of the remaining layout bucket and explains why simply optimizing CPU tile merge
+no longer moves the needle.
+
+Artifacts:
+
+- Edge named profile: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/vae-rope-detail-node-profile-3step/run.log`
+- Fused QKV split A/B: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/vae-fused-qkv-split-ab-3step/psnr.log`
+- Fused QKV split profile: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/vae-fused-qkv-split-node-profile-3step/run.log`
+- Diffusers VAE trace: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/diffusers-video-vae-profile-3step/video_vae_decode.trace.json.gz`
+
+## 2026-08-09 VAE short-sequence cuDNN SDPA experiment
+
+The FlashAttention padding hypothesis was validated with an explicit experiment.
+`ggml_ext_prefer_cudnn_sdpa_unpadded()` was extended so that
+`ED_CUDNN_SDPA_SHORT_F16_SELF_ATTN=1` also suppresses KV-256 padding for
+self-attention with `L>=1024` and `d=64/128`. With this change, MiniMax-H3 VAE
+attention uses cuDNN SDPA directly at `sq=sk=1797`, instead of padding `sk` to
+`2048` and falling back to the ggml FlashAttention padded path.
+
+Short `864x480`, 124-frame, 3-step A/B without CUDA op profiler:
+
+| Path | Temporal VAE decode | Reported video-vae | Generation | Notes |
+|---|---:|---:|---:|---|
+| Control padded FlashAttention | `5.705s` | `6.311s` | `24.875s` | baseline same binary |
+| Short cuDNN unpadded | `4.173s` | `4.472s` | `23.010s` | `ED_CUDNN_SDPA_SHORT_F16_SELF_ATTN=1` |
+| Short cuDNN + fused QKV split | `4.141s` | `4.439s` | `22.940s` | plus `ED_MINIMAX_H3_VAE_FUSED_QKV_SPLIT=1` |
+
+This is a meaningful VAE win: short cuDNN saves about `1.84s` reported video VAE
+on the short run, and the QKV split pack adds only a small additional `~33ms`.
+The comparison is not bit-exact. Control versus short cuDNN MP4 PSNR was
+`42.29dB`; short cuDNN versus short cuDNN + QKV split was `49.01dB`. Fixed-frame
+visual review did not show obvious new blocking or seam artifacts on this sample,
+but because the attention implementation changes numerical order, this should
+remain an explicit quality-validated path until full and second-content checks
+complete.
+
+CUDA-op profile confirmed the targeted bottleneck moved as expected:
+
+| Path | Profiled video graph op time | Layout | PAD | CPY | CONCAT | Attention |
+|---|---:|---:|---:|---:|---:|---:|
+| Padded FlashAttention | `2.519s` | `1.377s` | `0.227s` | `0.182s` | `0.170s` | `0.348s` |
+| Short cuDNN unpadded | `1.890s` | `0.816s` | `0.000s` | `0.057s` | `0.075s` | `0.319s` |
+
+The main remaining named layout hotspot after short cuDNN is still the decoder
+QKV chunk materialization (`vae.b*.attn.qkv (view) (cont)`), about `335.5ms` in
+the profile. The fused QKV split candidate removes that hotspot, but its current
+custom pack kernel gives only modest net speedup. A better follow-up would fuse
+Q/K/V split with the subsequent Q/K norm or attention input packing, rather than
+only replacing three CONT copies with one standalone custom copy.
+
+Artifacts:
+
+- Short cuDNN A/B logs: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/vae-short-unpad-combo-ab-3step`
+- Fixed-frame review: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/vae-short-unpad-combo-ab-3step/review/control-vs-short-vs-short-qkv.jpg`
+- Short cuDNN node profile: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/vae-cudnn-short-unpad-node-profile-3step/run.log`
+
+### Full-run validation for short cuDNN SDPA
+
+A full 20-step run was repeated with the same final optimized Edge environment
+as `edge-final-vae-audio-optimized-full`, plus the short-sequence cuDNN SDPA
+change. The earlier full rerun that omitted fast video/audio postprocess envs is
+not used for comparison because it inflated `video-copy` and `audio-vae`.
+
+Aligned full-run result:
+
+| Path | Generation | DiT | Video VAE | Video copy | Audio VAE | Script wall |
+|---|---:|---:|---:|---:|---:|---:|
+| Previous optimized Edge | `60.889s` | `53.842s` | `5.181s` | `0.102s` | `0.161s` | `70.030s` |
+| Short cuDNN SDPA Edge | `60.082s` | `53.860s` | `4.419s` | `0.114s` | `0.153s` | `69.057s` |
+
+The full run confirms a stable video VAE improvement of `0.762s` (`14.7%`) and
+a generation improvement of `0.807s` (`1.3%`) on the 5-second benchmark. The run
+kept the same resolution, frame count, steps, seed, model files, and forced H3
+16x16 latent VAE tiling.
+
+Quality notes:
+
+- Full MP4 PSNR versus the previous optimized Edge output was `49.18dB`, so the
+  path is not bit-exact but remains visually close.
+- Fixed-frame review showed no new obvious micro-block, tile seam, or motion
+  instability on this sample.
+- Because cuDNN and ggml FlashAttention use different numerical order, keep the
+  path quality-gated until the pending second-content robustness clip is checked.
+
+Full-run artifacts:
+
+- Full log: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-short-cudnn-final-env-full-2026-08-09/run.log`
+- Full video: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-short-cudnn-final-env-full-2026-08-09/final.mp4`
+- Full PSNR: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-short-cudnn-final-env-full-2026-08-09/review/psnr-vs-previous.log`
+- Frame review: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-short-cudnn-final-env-full-2026-08-09/review/previous-vs-short-cudnn.jpg`
+
+### Rejected QKV+RMS split fusion experiment
+
+After short cuDNN SDPA removed the FlashAttention padding overhead, the next
+largest named cost was QKV materialization plus Q/K RMSNorm. A more aggressive
+prototype, `ED_MINIMAX_H3_VAE_FUSED_QKV_RMS_SPLIT=1`, fused QKV split and Q/K
+RMSNorm into one custom CUDA op, skipping the following ggml `RMS_NORM` nodes.
+
+The prototype is rejected for now. It ran, but the short A/B versus the short
+cuDNN control produced only `36.06dB` MP4 PSNR and visible drift risk, indicating
+that the fused norm is not numerically equivalent enough to retain. The likely
+cause is different RMSNorm accumulation/precision/order versus ggml's existing
+CUDA RMSNorm implementation. Do not enable this path without rewriting it to
+match the backend norm semantics and revalidating.
+
+The safer default-off `ED_MINIMAX_H3_VAE_FUSED_QKV_SPLIT=1` remains available as
+a copy-only candidate. It is much closer (`49.01dB` versus short cuDNN in the
+short A/B) but only gives a small speed improvement, so the preferred retained
+VAE acceleration remains short cuDNN SDPA.
+
+Artifact:
+
+- Rejected QKV+RMS A/B: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/vae-qkv-rms-split-ab-3step`
diff --git a/src/core/backend/ggml/cuda/ed_cuda_attention_v_prep.cu b/src/core/backend/ggml/cuda/ed_cuda_attention_v_prep.cu
index 1a944bd..6aafe66 100644
--- a/src/core/backend/ggml/cuda/ed_cuda_attention_v_prep.cu
+++ b/src/core/backend/ggml/cuda/ed_cuda_attention_v_prep.cu
@@ -11,6 +11,7 @@ namespace {
 using edgedit::ggml_ext::AttentionVPrepCustomParams;
 using edgedit::ggml_ext::AttentionPairPackCustomParams;
 using edgedit::ggml_ext::AttentionQKVPairPackCustomParams;
+using edgedit::ggml_ext::AttentionQKVSplitPackCustomParams;
 
 static inline int64_t elem_stride(const ggml_tensor* t, int dim) {
     return t->nb[dim] / ggml_type_size(t->type);
@@ -23,6 +24,14 @@ static bool is_contiguous_3d_f16_output(const ggml_tensor* t) {
            t->nb[2] == static_cast<size_t>(t->ne[0]) * static_cast<size_t>(t->ne[1]) * sizeof(__half);
 }
 
+static bool is_contiguous_4d_f32_output(const ggml_tensor* t) {
+    return t->type == GGML_TYPE_F32 &&
+           t->nb[0] == sizeof(float) &&
+           t->nb[1] == static_cast<size_t>(t->ne[0]) * sizeof(float) &&
+           t->nb[2] == static_cast<size_t>(t->ne[0]) * static_cast<size_t>(t->ne[1]) * sizeof(float) &&
+           t->nb[3] == static_cast<size_t>(t->ne[0]) * static_cast<size_t>(t->ne[1]) * static_cast<size_t>(t->ne[2]) * sizeof(float);
+}
+
 static bool is_aligned_to(const void* ptr, uintptr_t alignment) {
     return (reinterpret_cast<uintptr_t>(ptr) % alignment) == 0;
 }
@@ -108,6 +117,41 @@ __global__ void attention_v_prep_f16_vec2_kernel(const float* v,
     reinterpret_cast<half2*>(dst + dst_idx)[0] = __float22half2_rn(value);
 }
 
+__global__ void attention_qkv_split_pack_f32_kernel(const float* qkv,
+                                                    float* dst,
+                                                    int head_dim,
+                                                    int n_head,
+                                                    int seq,
+                                                    int batch,
+                                                    int64_t qkv_s0,
+                                                    int64_t qkv_s1,
+                                                    int64_t qkv_s2,
+                                                    int64_t qkv_s3) {
+    const int64_t total = static_cast<int64_t>(3) * batch * seq * n_head * head_dim;
+    int64_t idx = static_cast<int64_t>(blockIdx.x) * blockDim.x + threadIdx.x;
+    if (idx >= total) {
+        return;
+    }
+
+    int64_t t = idx;
+    const int d = t % head_dim;
+    t /= head_dim;
+    const int h = t % n_head;
+    t /= n_head;
+    const int s = t % seq;
+    t /= seq;
+    const int b = t % batch;
+    t /= batch;
+    const int plane = t;
+
+    const int64_t src_idx = static_cast<int64_t>(d + plane * head_dim) * qkv_s0 +
+                            static_cast<int64_t>(h) * qkv_s1 +
+                            static_cast<int64_t>(s) * qkv_s2 +
+                            static_cast<int64_t>(b) * qkv_s3;
+    const int64_t dst_idx = (((static_cast<int64_t>(b + plane * batch) * seq + s) * n_head + h) * head_dim + d);
+    dst[dst_idx] = qkv[src_idx];
+}
+
 __global__ void attention_pair_pack_f16_kernel(const float* first,
                                                const float* second,
                                                __half* dst,
@@ -629,3 +673,65 @@ bool ed_cuda_attention_qkv_pair_pack_custom_compute(ggml_tensor * dst, ed_cuda_a
     }
     return true;
 }
+
+bool ed_cuda_attention_qkv_split_pack_custom_supported(const ggml_tensor * dst) {
+    if (dst == nullptr || dst->op != GGML_OP_CUSTOM || dst->src[0] == nullptr) {
+        return false;
+    }
+
+    struct ggml_custom_op_params {
+        ggml_custom_op_t fun;
+        int n_tasks;
+        void* userdata;
+    };
+    ggml_custom_op_params op_params{};
+    static_assert(sizeof(op_params) <= GGML_MAX_OP_PARAMS, "custom op params do not fit");
+    memcpy(&op_params, dst->op_params, sizeof(op_params));
+
+    const AttentionQKVSplitPackCustomParams params = edgedit::ggml_ext::attention_qkv_split_pack_params_from_userdata(op_params.userdata);
+    if (!edgedit::ggml_ext::attention_qkv_split_pack_params_valid(params)) {
+        return false;
+    }
+
+    const ggml_tensor* qkv = dst->src[0];
+    if (!edgedit::ggml_ext::attention_qkv_split_pack_shape_supported(qkv)) {
+        return false;
+    }
+    if (!is_contiguous_4d_f32_output(dst)) {
+        return false;
+    }
+
+    const int64_t head_dim = qkv->ne[0] / 3;
+    return dst->ne[0] == head_dim &&
+           dst->ne[1] == qkv->ne[1] &&
+           dst->ne[2] == qkv->ne[2] &&
+           dst->ne[3] == qkv->ne[3] * 3;
+}
+
+bool ed_cuda_attention_qkv_split_pack_custom_compute(ggml_tensor * dst, ed_cuda_attention_v_prep_stream_t stream) {
+    if (!ed_cuda_attention_qkv_split_pack_custom_supported(dst)) {
+        return false;
+    }
+
+    const ggml_tensor* qkv = dst->src[0];
+    const int head_dim = static_cast<int>(qkv->ne[0] / 3);
+    const int n_head = static_cast<int>(qkv->ne[1]);
+    const int seq = static_cast<int>(qkv->ne[2]);
+    const int batch = static_cast<int>(qkv->ne[3]);
+
+    const int64_t total = static_cast<int64_t>(3) * batch * seq * n_head * head_dim;
+    constexpr int threads = 256;
+    const int blocks = static_cast<int>((total + threads - 1) / threads);
+    attention_qkv_split_pack_f32_kernel<<<blocks, threads, 0, reinterpret_cast<cudaStream_t>(stream)>>>(
+        static_cast<const float*>(qkv->data),
+        static_cast<float*>(dst->data),
+        head_dim,
+        n_head,
+        seq,
+        batch,
+        elem_stride(qkv, 0),
+        elem_stride(qkv, 1),
+        elem_stride(qkv, 2),
+        elem_stride(qkv, 3));
+    return true;
+}
diff --git a/src/core/backend/ggml/cuda/ed_cuda_attention_v_prep.h b/src/core/backend/ggml/cuda/ed_cuda_attention_v_prep.h
index 2fad858..08093e9 100644
--- a/src/core/backend/ggml/cuda/ed_cuda_attention_v_prep.h
+++ b/src/core/backend/ggml/cuda/ed_cuda_attention_v_prep.h
@@ -15,3 +15,7 @@ bool ed_cuda_attention_pair_pack_custom_compute(ggml_tensor * dst, ed_cuda_atten
 bool ed_cuda_attention_qkv_pair_pack_custom_supported(const ggml_tensor * dst);
 
 bool ed_cuda_attention_qkv_pair_pack_custom_compute(ggml_tensor * dst, ed_cuda_attention_v_prep_stream_t stream);
+
+bool ed_cuda_attention_qkv_split_pack_custom_supported(const ggml_tensor * dst);
+
+bool ed_cuda_attention_qkv_split_pack_custom_compute(ggml_tensor * dst, ed_cuda_attention_v_prep_stream_t stream);
diff --git a/src/core/backend/ggml/ed_ggml_attention_ext.hpp b/src/core/backend/ggml/ed_ggml_attention_ext.hpp
index cbc5fdb..8168ad6 100644
--- a/src/core/backend/ggml/ed_ggml_attention_ext.hpp
+++ b/src/core/backend/ggml/ed_ggml_attention_ext.hpp
@@ -10,6 +10,7 @@ namespace edgedit::ggml_ext {
 constexpr uint32_t kAttentionVPrepCustomMagic = 0x45565050u; // "EVPP"
 constexpr uint32_t kAttentionPairPackCustomMagic = 0x45505150u; // "EPQP"
 constexpr uint32_t kAttentionQKVPairPackCustomMagic = 0x45514b50u; // "EQKP"
+constexpr uint32_t kAttentionQKVSplitPackCustomMagic = 0x45515350u; // "EQSP"
 
 struct AttentionVPrepCustomParams {
     uint32_t magic = kAttentionVPrepCustomMagic;
@@ -26,6 +27,10 @@ struct AttentionQKVPairPackCustomParams {
     int32_t n_head = 0;
 };
 
+struct AttentionQKVSplitPackCustomParams {
+    uint32_t magic = kAttentionQKVSplitPackCustomMagic;
+};
+
 inline bool attention_v_prep_enabled() {
     const char* env = std::getenv("ED_DISABLE_CUDA_ATTENTION_V_PREP");
     return !(env != nullptr && std::atoi(env) != 0);
@@ -41,6 +46,11 @@ inline bool attention_qkv_pair_pack_enabled() {
     return !(env != nullptr && std::atoi(env) != 0);
 }
 
+inline bool attention_qkv_split_pack_enabled() {
+    const char* env = std::getenv("ED_MINIMAX_H3_VAE_FUSED_QKV_SPLIT");
+    return env != nullptr && std::atoi(env) != 0;
+}
+
 inline AttentionVPrepCustomParams attention_v_prep_params_from_userdata(void* userdata) {
     AttentionVPrepCustomParams params;
     uintptr_t packed = reinterpret_cast<uintptr_t>(userdata);
@@ -83,6 +93,17 @@ inline void* attention_qkv_pair_pack_params_to_userdata(int64_t n_head) {
     return reinterpret_cast<void*>(packed);
 }
 
+inline AttentionQKVSplitPackCustomParams attention_qkv_split_pack_params_from_userdata(void* userdata) {
+    AttentionQKVSplitPackCustomParams params;
+    uintptr_t packed = reinterpret_cast<uintptr_t>(userdata);
+    params.magic = static_cast<uint32_t>(packed & 0xffffffffu);
+    return params;
+}
+
+inline void* attention_qkv_split_pack_params_to_userdata() {
+    return reinterpret_cast<void*>(static_cast<uintptr_t>(kAttentionQKVSplitPackCustomMagic));
+}
+
 inline bool attention_v_prep_params_valid(const AttentionVPrepCustomParams& params) {
     return params.magic == kAttentionVPrepCustomMagic &&
            (params.v_is_seq_major == 0 || params.v_is_seq_major == 1);
@@ -96,6 +117,10 @@ inline bool attention_qkv_pair_pack_params_valid(const AttentionQKVPairPackCusto
     return params.magic == kAttentionQKVPairPackCustomMagic && params.n_head > 0;
 }
 
+inline bool attention_qkv_split_pack_params_valid(const AttentionQKVSplitPackCustomParams& params) {
+    return params.magic == kAttentionQKVSplitPackCustomMagic;
+}
+
 inline float attention_tensor_f32_at(const ggml_tensor* t, int64_t i0, int64_t i1, int64_t i2, int64_t i3) {
     const char* base = static_cast<const char*>(t->data);
     const char* ptr = base + i0 * t->nb[0] + i1 * t->nb[1] + i2 * t->nb[2] + i3 * t->nb[3];
@@ -176,6 +201,71 @@ inline bool attention_qkv_pair_pack_shape_supported(const ggml_tensor* q_first,
     return true;
 }
 
+inline bool attention_qkv_split_pack_shape_supported(const ggml_tensor* qkv) {
+    if (!attention_qkv_split_pack_enabled() || qkv == nullptr || qkv->type != GGML_TYPE_F32) {
+        return false;
+    }
+    if (qkv->ne[0] <= 0 || qkv->ne[1] <= 0 || qkv->ne[2] <= 0 || qkv->ne[3] <= 0) {
+        return false;
+    }
+    return qkv->ne[0] % 3 == 0;
+}
+
+inline void attention_qkv_split_pack_cpu_custom_op(ggml_tensor* dst, int ith, int nth, void* userdata) {
+    const AttentionQKVSplitPackCustomParams params = attention_qkv_split_pack_params_from_userdata(userdata);
+    GGML_ASSERT(attention_qkv_split_pack_params_valid(params));
+    GGML_ASSERT(dst->src[0] != nullptr);
+    const ggml_tensor* qkv = dst->src[0];
+    GGML_ASSERT(attention_qkv_split_pack_shape_supported(qkv));
+    GGML_ASSERT(dst->type == GGML_TYPE_F32);
+
+    const int64_t head_dim = qkv->ne[0] / 3;
+    const int64_t n_head = qkv->ne[1];
+    const int64_t seq = qkv->ne[2];
+    const int64_t batch = qkv->ne[3];
+    GGML_ASSERT(dst->ne[0] == head_dim && dst->ne[1] == n_head && dst->ne[2] == seq && dst->ne[3] == batch * 3);
+
+    const int64_t total = 3 * batch * seq * n_head * head_dim;
+    for (int64_t idx = ith; idx < total; idx += nth) {
+        int64_t t = idx;
+        const int64_t d = t % head_dim;
+        t /= head_dim;
+        const int64_t h = t % n_head;
+        t /= n_head;
+        const int64_t s = t % seq;
+        t /= seq;
+        const int64_t b = t % batch;
+        t /= batch;
+        const int64_t plane = t;
+
+        const float value = attention_tensor_f32_at(qkv, d + plane * head_dim, h, s, b);
+        char* base = static_cast<char*>(dst->data);
+        char* ptr = base + d * dst->nb[0] + h * dst->nb[1] + s * dst->nb[2] + (b + plane * batch) * dst->nb[3];
+        *reinterpret_cast<float*>(ptr) = value;
+    }
+}
+
+inline ggml_tensor* attention_qkv_split_pack_custom_f32(ggml_context* ctx, ggml_tensor* qkv) {
+    if (!attention_qkv_split_pack_shape_supported(qkv)) {
+        return nullptr;
+    }
+    ggml_tensor* args[] = { qkv };
+    const int64_t head_dim = qkv->ne[0] / 3;
+    ggml_tensor* out = ggml_custom_4d(ctx,
+                                      GGML_TYPE_F32,
+                                      head_dim,
+                                      qkv->ne[1],
+                                      qkv->ne[2],
+                                      qkv->ne[3] * 3,
+                                      args,
+                                      1,
+                                      attention_qkv_split_pack_cpu_custom_op,
+                                      GGML_N_TASKS_MAX,
+                                      attention_qkv_split_pack_params_to_userdata());
+    ggml_set_name(out, "ed_fused_attention_qkv_split_pack_f32");
+    return out;
+}
+
 inline void attention_v_prep_cpu_custom_op(ggml_tensor* dst, int ith, int nth, void* userdata) {
     const AttentionVPrepCustomParams params = attention_v_prep_params_from_userdata(userdata);
     GGML_ASSERT(attention_v_prep_params_valid(params));
diff --git a/src/core/backend/ggml/ggml_extend.hpp b/src/core/backend/ggml/ggml_extend.hpp
index aa95d4e..eb78ab1 100644
--- a/src/core/backend/ggml/ggml_extend.hpp
+++ b/src/core/backend/ggml/ggml_extend.hpp
@@ -1709,7 +1709,12 @@ __STATIC_INLINE__ bool ggml_ext_prefer_cudnn_sdpa_unpadded(ggml_backend_t backen
     }
 
     const bool supported_head_dim = d_head == 64 || d_head == 128;
-    return supported_head_dim && L_q == L_k && L_q >= 4096;
+    const bool supported_long_self_attn = L_q == L_k && L_q >= 4096;
+    const bool supported_short_f16_self_attn =
+        ggml_ext_env_flag_enabled("ED_CUDNN_SDPA_SHORT_F16_SELF_ATTN") &&
+        L_q == L_k &&
+        L_q >= 1024;
+    return supported_head_dim && (supported_long_self_attn || supported_short_f16_self_attn);
 #else
     ED_UNUSED(backend);
     ED_UNUSED(L_q);
diff --git a/src/dit_models/components/autoencoders/minimax_h3_vae.hpp b/src/dit_models/components/autoencoders/minimax_h3_vae.hpp
index 40766f7..af4adc9 100644
--- a/src/dit_models/components/autoencoders/minimax_h3_vae.hpp
+++ b/src/dit_models/components/autoencoders/minimax_h3_vae.hpp
@@ -25,6 +25,13 @@ namespace MiniMaxH3VAE {
         return value != nullptr && value[0] != '\0' && std::strcmp(value, "0") != 0;
     }
 
+    static ggml_tensor* h3_profile_name(ggml_tensor* tensor, const std::string& name) {
+        if (tensor != nullptr && h3_env_flag_enabled("ED_MINIMAX_H3_VAE_NAME_NODES")) {
+            ggml_set_name(tensor, name.c_str());
+        }
+        return tensor;
+    }
+
     struct ScopedEnvFlag {
         std::string name;
         std::string old_value;
@@ -104,6 +111,16 @@ namespace MiniMaxH3VAE {
             : GroupNorm(32, channels, 1e-6f, true) {}
 
         ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* x) {
+            if (h3_env_flag_enabled("ED_MINIMAX_H3_VAE_FAST_TEMPORAL_GROUP_NORM")) {
+                GGML_ASSERT(x->ne[3] % num_channels == 0);
+                const int64_t temporal_size = x->ne[2];
+                const int64_t batch_size    = x->ne[3] / num_channels;
+                if (batch_size == 1 && temporal_size > 1) {
+                    x = ggml_cont(ctx->ggml_ctx, ggml_permute(ctx->ggml_ctx, x, 0, 1, 3, 2));
+                    x = GroupNorm::forward(ctx, x);
+                    return ggml_cont(ctx->ggml_ctx, ggml_permute(ctx->ggml_ctx, x, 0, 1, 3, 2));
+                }
+            }
             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);
@@ -260,18 +277,25 @@ namespace MiniMaxH3VAE {
 
     static ggml_tensor* apply_partial_rope(ggml_context* ctx,
                                            ggml_tensor* x,
-                                           ggml_tensor* pe) {
+                                           ggml_tensor* pe,
+                                           const std::string& profile_prefix = "vae.attn.rope") {
         int64_t rot_dim = pe->ne[2] * 2;
+        auto rot_src     = h3_profile_name(ggml_ext_slice(ctx, x, 0, 0, rot_dim),
+                                           profile_prefix + ".rot_slice");
         auto rotated    = Rope::apply_rope(ctx,
-                                           ggml_ext_slice(ctx, x, 0, 0, rot_dim),
+                                           rot_src,
                                            pe,
                                            false);
+        h3_profile_name(rotated, profile_prefix + ".rotated");
         if (rot_dim == x->ne[0]) {
             return rotated;
         }
+        auto tail_src = h3_profile_name(ggml_ext_slice(ctx, x, 0, rot_dim, x->ne[0]),
+                                        profile_prefix + ".tail_slice");
         auto tail = attention_layout(ctx,
-                                     ggml_ext_slice(ctx, x, 0, rot_dim, x->ne[0]));
-        return ggml_concat(ctx, rotated, tail, 0);
+                                     tail_src);
+        h3_profile_name(tail, profile_prefix + ".tail_layout");
+        return h3_profile_name(ggml_concat(ctx, rotated, tail, 0), profile_prefix + ".concat");
     }
 
     struct DecoderAttention : public GGMLBlock {
@@ -286,10 +310,12 @@ namespace MiniMaxH3VAE {
 
         ggml_tensor* forward(GGMLRunnerContext* ctx,
                              ggml_tensor* x,
-                             ggml_tensor* pe) {
+                             ggml_tensor* pe,
+                             const std::string& profile_prefix = "vae.attn") {
             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);
+            h3_profile_name(qkv_projection, profile_prefix + ".qkv_proj");
             int64_t sequence    = x->ne[1];
             int64_t batch_size  = x->ne[2] * x->ne[3];
             qkv_projection      = ggml_reshape_4d(ctx->ggml_ctx,
@@ -298,29 +324,59 @@ namespace MiniMaxH3VAE {
                                                   num_head,
                                                   sequence,
                                                   batch_size);
-            auto qkv            = ggml_ext_chunk(ctx->ggml_ctx, qkv_projection, 3, 0);
+            h3_profile_name(qkv_projection, profile_prefix + ".qkv");
+            auto packed_qkv     = edgedit::ggml_ext::attention_qkv_split_pack_custom_f32(ctx->ggml_ctx, qkv_projection);
+            if (packed_qkv != nullptr && !ggml_backend_supports_op(ctx->backend, packed_qkv)) {
+                packed_qkv = nullptr;
+            }
+            h3_profile_name(packed_qkv, profile_prefix + ".qkv_split_pack");
+            std::vector<ggml_tensor*> qkv;
+            if (packed_qkv != nullptr) {
+                qkv.reserve(3);
+                for (int plane = 0; plane < 3; ++plane) {
+                    qkv.push_back(ggml_view_4d(ctx->ggml_ctx,
+                                               packed_qkv,
+                                               head_dim,
+                                               num_head,
+                                               sequence,
+                                               batch_size,
+                                               packed_qkv->nb[1],
+                                               packed_qkv->nb[2],
+                                               packed_qkv->nb[3],
+                                               plane * batch_size * packed_qkv->nb[3]));
+                }
+            } else {
+                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);
+            h3_profile_name(q, profile_prefix + ".q");
             auto k              = ggml_reshape_4d(ctx->ggml_ctx,
                                                   qkv[1],
                                                   head_dim,
                                                   num_head,
                                                   sequence,
                                                   batch_size);
+            h3_profile_name(k, profile_prefix + ".k");
             auto v              = ggml_reshape_4d(ctx->ggml_ctx,
                                                   qkv[2],
                                                   head_dim,
                                                   num_head,
                                                   sequence,
                                                   batch_size);
+            h3_profile_name(v, profile_prefix + ".v");
             q                   = ggml_rms_norm(ctx->ggml_ctx, q, 1e-5f);
+            h3_profile_name(q, profile_prefix + ".q_norm");
             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);
+            h3_profile_name(k, profile_prefix + ".k_norm");
+            q                   = apply_partial_rope(ctx->ggml_ctx, q, pe, profile_prefix + ".q_rope_pack");
+            h3_profile_name(q, profile_prefix + ".q_rope");
+            k                   = apply_partial_rope(ctx->ggml_ctx, k, pe, profile_prefix + ".k_rope_pack");
+            h3_profile_name(k, profile_prefix + ".k_rope");
             auto out            = ggml_ext_attention_ext(ctx->ggml_ctx,
                                                          ctx->backend,
                                                          q,
@@ -330,7 +386,8 @@ namespace MiniMaxH3VAE {
                                                          nullptr,
                                                          true,
                                                          ctx->flash_attn_enabled);
-            return to_out->forward(ctx, out);
+            h3_profile_name(out, profile_prefix + ".attn");
+            return h3_profile_name(to_out->forward(ctx, out), profile_prefix + ".out");
         }
     };
 
@@ -343,18 +400,24 @@ namespace MiniMaxH3VAE {
             blocks["w2"] = std::make_shared<Linear>(kInnerDim, dim, true);
         }
 
-        ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* x) {
+        ggml_tensor* forward(GGMLRunnerContext* ctx,
+                             ggml_tensor* x,
+                             const std::string& profile_prefix = "vae.ff") {
             auto w1   = std::dynamic_pointer_cast<Linear>(blocks["w1"]);
             auto w2   = std::dynamic_pointer_cast<Linear>(blocks["w2"]);
             auto projected = w1->forward(ctx, x);
+            h3_profile_name(projected, profile_prefix + ".w1");
             if (h3_env_flag_enabled("ED_MINIMAX_H3_VAE_FUSED_SWIGLU")) {
-                return w2->forward(ctx, ggml_swiglu(ctx->ggml_ctx, projected));
+                auto activated = ggml_swiglu(ctx->ggml_ctx, projected);
+                h3_profile_name(activated, profile_prefix + ".swiglu");
+                return h3_profile_name(w2->forward(ctx, activated), profile_prefix + ".out");
             }
             auto gate = ggml_ext_chunk(ctx->ggml_ctx, projected, 2, 0);
-            return w2->forward(ctx,
-                               ggml_mul(ctx->ggml_ctx,
-                                        ggml_silu(ctx->ggml_ctx, gate[0]),
-                                        gate[1]));
+            auto activated = ggml_mul(ctx->ggml_ctx,
+                                      ggml_silu(ctx->ggml_ctx, gate[0]),
+                                      gate[1]);
+            h3_profile_name(activated, profile_prefix + ".swiglu_legacy");
+            return h3_profile_name(w2->forward(ctx, activated), profile_prefix + ".out");
         }
     };
 
@@ -379,21 +442,29 @@ namespace MiniMaxH3VAE {
 
         ggml_tensor* forward(GGMLRunnerContext* ctx,
                              ggml_tensor* x,
-                             ggml_tensor* pe) {
+                             ggml_tensor* pe,
+                             const std::string& profile_prefix = "vae.block") {
             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"]);
+            auto norm1_out = norm1->forward(ctx, x);
+            h3_profile_name(norm1_out, profile_prefix + ".norm1");
+            auto attn_out = attn->forward(ctx, norm1_out, pe, profile_prefix + ".attn");
+            auto attn_scaled = ggml_mul(ctx->ggml_ctx, attn_out, params["scale1"]);
+            h3_profile_name(attn_scaled, profile_prefix + ".attn_scaled");
             x          = ggml_add(ctx->ggml_ctx,
                                   x,
-                                  ggml_mul(ctx->ggml_ctx,
-                                           attn->forward(ctx, norm1->forward(ctx, x), pe),
-                                           params["scale1"]));
+                                  attn_scaled);
+            h3_profile_name(x, profile_prefix + ".attn_residual");
+            auto norm2_out = norm2->forward(ctx, x);
+            h3_profile_name(norm2_out, profile_prefix + ".norm2");
+            auto ff_out = ff->forward(ctx, norm2_out, profile_prefix + ".ff");
+            auto ff_scaled = ggml_mul(ctx->ggml_ctx, ff_out, params["scale2"]);
+            h3_profile_name(ff_scaled, profile_prefix + ".ff_scaled");
             return ggml_add(ctx->ggml_ctx,
                             x,
-                            ggml_mul(ctx->ggml_ctx,
-                                     ff->forward(ctx, norm2->forward(ctx, x)),
-                                     params["scale2"]));
+                            ff_scaled);
         }
     };
 
@@ -457,7 +528,8 @@ namespace MiniMaxH3VAE {
             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);
+                h = block->forward(ctx, h, pe, "vae.b" + std::to_string(i));
+                h3_profile_name(h, "vae.b" + std::to_string(i) + ".out");
                 sd::ggml_graph_cut::mark_graph_cut(h,
                                                    "minimax_h3_vae.decoder.blocks." + std::to_string(i),
                                                    "hidden_states");
@@ -530,6 +602,9 @@ namespace MiniMaxH3VAE {
         sd::Tensor<float> latents_mean;
         sd::Tensor<float> latents_std;
         sd::Tensor<float> rope_cache;
+        int64_t rope_cache_width  = 0;
+        int64_t rope_cache_height = 0;
+        int64_t rope_cache_frames = 0;
 
         MiniMaxH3VideoVAERunner(ggml_backend_t backend,
                                 bool offload_params_to_cpu,
@@ -1061,9 +1136,19 @@ namespace MiniMaxH3VAE {
                                    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]);
+                const bool reuse_rope = h3_env_flag_enabled("ED_MINIMAX_H3_VAE_REUSE_ROPE_CACHE");
+                if (!reuse_rope ||
+                    rope_cache.empty() ||
+                    rope_cache_width != input.shape()[0] ||
+                    rope_cache_height != input.shape()[1] ||
+                    rope_cache_frames != input.shape()[2]) {
+                    rope_cache        = build_rope(input.shape()[0],
+                                                   input.shape()[1],
+                                                   input.shape()[2]);
+                    rope_cache_width  = input.shape()[0];
+                    rope_cache_height = input.shape()[1];
+                    rope_cache_frames = input.shape()[2];
+                }
             }
             auto get_graph = [&]() -> ggml_cgraph* {
                 auto value       = make_input(input);
diff --git a/third_party/ggml b/third_party/ggml
index 5c68bd3..3834c4d 160000
--- a/third_party/ggml
+++ b/third_party/ggml
@@ -1 +1 @@
-Subproject commit 5c68bd346bf6ec5114b60409d7a18534ee9f92da
+Subproject commit 3834c4d669c06bfcdd4608fe5e91a8ce4e5a7aa0

From 8b0ee8b37a42390c0f88338d8ca43a1e4993736f Mon Sep 17 00:00:00 2001
From: Komorebi623 <wang-ty22@mails.tsinghua.edu.cn>
Date: Tue, 11 Aug 2026 15:19:45 +0800
Subject: [PATCH 17/25] Fix MiniMax H3 Ref2VA conditioning fidelity

Stage 11 code files only: 573 insertions and 158 deletions. No benchmark scripts, generated assets, docs, or submodule changes are included.

Align Qwen3-VL text attention with the sd.cpp-compatible non-flash path to restore Ref2VA reference-image fidelity.

Add Ref2VA conditioning support for mixed reference images, videos, paired video audio, and standalone audio, including CLI validation that audio-only references are rejected.

Add MiniMax H3 profiling and tensor-name mappings used to audit conditioning, diffusion, VAE decode, and model loading stages.

Enable the validated CUDA/cuDNN and VAE fast paths by default while keeping environment variables available for opt-out debugging.

Validation: full CUDA build completed in build-cuda-refvideo-align-20260810; reran Ref2VA image/video/video-audio/mixed benchmark and strong-prompt image rerun on CUDA.
---
 examples/cli/cli_common.hpp                   |   5 +
 .../cuDNN/ed_cudnn_conv_transpose_1d.cu       |   2 +-
 src/core/backend/cuDNN/ed_cudnn_sdpa.cu       |   2 +-
 src/core/backend/ggml/ggml_extend.hpp         |  27 +-
 src/core/runtime/model_loader.cpp             |  16 +-
 .../autoencoders/minimax_h3_audio_vae.hpp     |  18 +-
 .../autoencoders/minimax_h3_vae.hpp           |  24 +-
 .../components/text_encoders/llm.hpp          | 136 ++++----
 src/dit_models/models/minimax_h3_full.hpp     | 184 ++++++++++-
 .../pipelines/minimax_h3_pipeline.cpp         | 305 ++++++++++++++----
 src/utils/name_conversion.cpp                 |  12 +
 11 files changed, 573 insertions(+), 158 deletions(-)

diff --git a/examples/cli/cli_common.hpp b/examples/cli/cli_common.hpp
index c8638ca..a532e99 100644
--- a/examples/cli/cli_common.hpp
+++ b/examples/cli/cli_common.hpp
@@ -908,6 +908,11 @@ inline bool parse_args(int argc, char** argv, FluxCliArgs* args) {
         return false;
     }
 
+    if (!args->ref_audio_paths.empty() && args->ref_image_paths.empty() && args->ref_video_paths.empty()) {
+        std::fprintf(stderr, "MiniMax-H3 Ref2VA --ref-audio must be paired with at least one --ref-image or --ref-video\n");
+        return false;
+    }
+
     const std::string video_format = normalized_video_format(args->video_format);
     if (video_format != "auto" &&
         video_format != "avi" &&
diff --git a/src/core/backend/cuDNN/ed_cudnn_conv_transpose_1d.cu b/src/core/backend/cuDNN/ed_cudnn_conv_transpose_1d.cu
index 6d1bd58..a417244 100644
--- a/src/core/backend/cuDNN/ed_cudnn_conv_transpose_1d.cu
+++ b/src/core/backend/cuDNN/ed_cudnn_conv_transpose_1d.cu
@@ -45,7 +45,7 @@ std::unordered_map<workspace_key, std::unique_ptr<workspace>, workspace_key_hash
 static bool enabled() {
     static const bool value = [] {
         const char * env = getenv("ED_CUDNN_CONV_TRANSPOSE_1D");
-        return env != nullptr && atoi(env) != 0;
+        return env == nullptr || env[0] == '\0' || atoi(env) != 0;
     }();
     return value;
 }
diff --git a/src/core/backend/cuDNN/ed_cudnn_sdpa.cu b/src/core/backend/cuDNN/ed_cudnn_sdpa.cu
index 88c92d5..0f3107f 100644
--- a/src/core/backend/cuDNN/ed_cudnn_sdpa.cu
+++ b/src/core/backend/cuDNN/ed_cudnn_sdpa.cu
@@ -204,7 +204,7 @@ static bool cudnn_sdpa_wan_sp_cross_attn_enabled() {
 }
 
 static bool cudnn_sdpa_short_f16_self_attn_enabled() {
-    static const bool enabled = env_flag_enabled_or_default("ED_CUDNN_SDPA_SHORT_F16_SELF_ATTN", false);
+    static const bool enabled = env_flag_enabled_or_default("ED_CUDNN_SDPA_SHORT_F16_SELF_ATTN", true);
     return enabled;
 }
 
diff --git a/src/core/backend/ggml/ggml_extend.hpp b/src/core/backend/ggml/ggml_extend.hpp
index eb78ab1..90e9580 100644
--- a/src/core/backend/ggml/ggml_extend.hpp
+++ b/src/core/backend/ggml/ggml_extend.hpp
@@ -864,7 +864,7 @@ __STATIC_INLINE__ void sd_parallel_for(int64_t begin, int64_t end, int threads,
 __STATIC_INLINE__ int sd_vae_parallel_tile_copy_threads() {
     static const int threads = []() {
         const char* enabled = std::getenv("ED_VAE_PARALLEL_TILE_COPY");
-        if (enabled == nullptr || enabled[0] == '\0' || std::strcmp(enabled, "0") == 0) {
+        if (enabled != nullptr && enabled[0] != '\0' && std::strcmp(enabled, "0") == 0) {
             return 1;
         }
         const char* value = std::getenv("ED_VAE_PARALLEL_TILE_COPY_THREADS");
@@ -879,7 +879,7 @@ __STATIC_INLINE__ int sd_vae_parallel_tile_copy_threads() {
 __STATIC_INLINE__ bool sd_vae_plane_parallel_tile_copy_enabled() {
     static const bool enabled = []() {
         const char* value = std::getenv("ED_VAE_PLANE_PARALLEL_TILE_COPY");
-        return value != nullptr && value[0] != '\0' && std::strcmp(value, "0") != 0;
+        return value == nullptr || value[0] == '\0' || std::strcmp(value, "0") != 0;
     }();
     return enabled;
 }
@@ -1695,6 +1695,18 @@ __STATIC_INLINE__ bool ggml_ext_env_flag_enabled(const char* name) {
            std::strcmp(value, "OFF") != 0;
 }
 
+__STATIC_INLINE__ bool ggml_ext_env_flag_enabled_or_default(const char* name, bool default_enabled) {
+    const char* value = std::getenv(name);
+    if (value == nullptr || value[0] == '\0') {
+        return default_enabled;
+    }
+    return std::strcmp(value, "0") != 0 &&
+           std::strcmp(value, "false") != 0 &&
+           std::strcmp(value, "FALSE") != 0 &&
+           std::strcmp(value, "off") != 0 &&
+           std::strcmp(value, "OFF") != 0;
+}
+
 __STATIC_INLINE__ bool ggml_ext_prefer_cudnn_sdpa_unpadded(ggml_backend_t backend,
                                                           int64_t L_q,
                                                           int64_t L_k,
@@ -1711,7 +1723,7 @@ __STATIC_INLINE__ bool ggml_ext_prefer_cudnn_sdpa_unpadded(ggml_backend_t backen
     const bool supported_head_dim = d_head == 64 || d_head == 128;
     const bool supported_long_self_attn = L_q == L_k && L_q >= 4096;
     const bool supported_short_f16_self_attn =
-        ggml_ext_env_flag_enabled("ED_CUDNN_SDPA_SHORT_F16_SELF_ATTN") &&
+        ggml_ext_env_flag_enabled_or_default("ED_CUDNN_SDPA_SHORT_F16_SELF_ATTN", true) &&
         L_q == L_k &&
         L_q >= 1024;
     return supported_head_dim && (supported_long_self_attn || supported_short_f16_self_attn);
@@ -1743,7 +1755,8 @@ __STATIC_INLINE__ ggml_tensor* ggml_ext_attention_ext(ggml_context* ctx,
                                                       bool pad_kv_for_flash_attn = true,
                                                       bool v_is_seq_major = false,
                                                       int sage_layer_idx = -1,
-                                                      int sage_total_layers = -1) {  // avoid overflow
+                                                      int sage_total_layers = -1,
+                                                      bool allow_masked_flash_attn = false) {  // avoid overflow
     int64_t L_q;
     int64_t L_k;
     int64_t C;
@@ -1842,6 +1855,10 @@ __STATIC_INLINE__ ggml_tensor* ggml_ext_attention_ext(ggml_context* ctx,
 
         if (mask_in != nullptr) {
             mask_in = ggml_transpose(ctx, mask_in);
+            if (kv_pad > 0) {
+                auto pad_tensor = ggml_ext_full(ctx, -INFINITY, kv_pad, L_q, 1, 1);
+                mask_in = ggml_concat(ctx, mask_in, pad_tensor, 0);
+            }
         } else {
             if (kv_pad > 0) {
                 mask_in         = ggml_ext_zeros(ctx, L_k, L_q, 1, 1);
@@ -1911,7 +1928,7 @@ __STATIC_INLINE__ ggml_tensor* ggml_ext_attention_ext(ggml_context* ctx,
             kv_pad = GGML_PAD(L_k, 256) - static_cast<int>(L_k);
         }
 
-        if (mask != nullptr) {
+        if (mask != nullptr && !allow_masked_flash_attn) {
             can_use_flash_attn = false;
         }
 
diff --git a/src/core/runtime/model_loader.cpp b/src/core/runtime/model_loader.cpp
index 2718e9a..3806666 100644
--- a/src/core/runtime/model_loader.cpp
+++ b/src/core/runtime/model_loader.cpp
@@ -337,7 +337,8 @@ static SDVersion infer_transformer_file_version(const std::string& file_path) {
     if (contains(lower_normalized, "kontext")) {
         return VERSION_FLUX_KONTEXT;
     }
-    if (!contains(normalized, "/transformer/")) {
+    if (!contains(normalized, "/transformer/") &&
+        !contains(normalized, "/transformer_ref/")) {
         return VERSION_COUNT;
     }
 
@@ -1365,6 +1366,8 @@ SDVersion ModelLoader::get_ld_version() {
     bool has_transformer_blocks = false;
     bool has_unet = false;
     bool has_second_text_encoder = false;
+    bool has_qwen3_vl_language = false;
+    bool has_qwen3_vl_vision = false;
 
     TensorStorage input_block_weight;
     TensorStorage token_embedding_weight;
@@ -1381,6 +1384,14 @@ SDVersion ModelLoader::get_ld_version() {
             tensor_storage_map_.find("model.diffusion_model.audio_patch_proj.weight") != tensor_storage_map_.end()) {
             return VERSION_MINIMAX_H3;
         }
+        if (contains(name, "model.language_model.layers.") ||
+            contains(name, "text_encoders.llm.model.language_model.layers.")) {
+            has_qwen3_vl_language = true;
+        }
+        if (contains(name, "model.visual.blocks.") ||
+            contains(name, "text_encoders.llm.model.visual.blocks.")) {
+            has_qwen3_vl_vision = true;
+        }
         // Wan video DiT: blocks carry a cross_attn sub-module (text conditioning)
         // that no other supported architecture uses, and a 3-D patch_embedding.
         // Diffusers loading recognizes Wan via config.json's "Wan" class, but a
@@ -1421,6 +1432,9 @@ SDVersion ModelLoader::get_ld_version() {
         }
         return VERSION_FLUX;
     }
+    if (has_qwen3_vl_language && has_qwen3_vl_vision) {
+        return VERSION_MINIMAX_H3;
+    }
     if (has_unet && has_second_text_encoder) {
         return VERSION_SDXL;
     }
diff --git a/src/dit_models/components/autoencoders/minimax_h3_audio_vae.hpp b/src/dit_models/components/autoencoders/minimax_h3_audio_vae.hpp
index 488d4eb..531ad95 100644
--- a/src/dit_models/components/autoencoders/minimax_h3_audio_vae.hpp
+++ b/src/dit_models/components/autoencoders/minimax_h3_audio_vae.hpp
@@ -2,12 +2,21 @@
 #define __ED_MINIMAX_H3_AUDIO_VAE_HPP__
 #include <array>
 #include <cmath>
+#include <cstdlib>
 #include <memory>
 #include <string>
 #include <vector>
 #include "backend/ggml/ggml_extend.hpp"
 namespace MiniMaxH3Audio {
 namespace Ops {
+    static bool h3_audio_env_flag_enabled_or_default(const char* name, bool default_enabled) {
+        const char* value = std::getenv(name);
+        if (value == nullptr || value[0] == '\0') {
+            return default_enabled;
+        }
+        return value[0] != '0';
+    }
+
     static ggml_type audio_conv_weight_type(ggml_type type) {
         return type == GGML_TYPE_BF16 ? GGML_TYPE_F16 : type;
     }
@@ -72,8 +81,7 @@ namespace Ops {
         auto ctx = runner_ctx->ggml_ctx;
         GGML_ASSERT(x->ne[2] == 1 && x->ne[3] == 1);
         auto tiled = tile_depthwise_filter_1d(runner_ctx, filter, x->ne[1]);
-        const char* direct = std::getenv("ED_MINIMAX_H3_AUDIO_DIRECT_DEPTHWISE");
-        if (direct != nullptr && direct[0] != '\0' && direct[0] != '0' &&
+        if (h3_audio_env_flag_enabled_or_default("ED_MINIMAX_H3_AUDIO_DIRECT_DEPTHWISE", true) &&
             sd_backend_is(runner_ctx->backend, "CUDA") && tiled->type == GGML_TYPE_F32 && x->type == GGML_TYPE_F32) {
             auto kernel = ggml_reshape_4d(ctx, tiled, tiled->ne[0], 1, 1, x->ne[1]);
             auto input = ggml_reshape_4d(ctx, x, x->ne[0], 1, x->ne[1], 1);
@@ -125,8 +133,7 @@ namespace Ops {
 
         auto reversed_filter = reverse_1d_filter(ctx, filter);
         ggml_tensor* out = nullptr;
-        const char* direct = std::getenv("ED_MINIMAX_H3_AUDIO_DIRECT_DEPTHWISE");
-        if (direct != nullptr && direct[0] != '\0' && direct[0] != '0' &&
+        if (h3_audio_env_flag_enabled_or_default("ED_MINIMAX_H3_AUDIO_DIRECT_DEPTHWISE", true) &&
             reversed_filter->type == GGML_TYPE_F32 && x_flat->type == GGML_TYPE_F32) {
             auto kernel = ggml_reshape_4d(ctx, reversed_filter, kernel_size, 1, 1, 1);
             auto input = ggml_reshape_4d(ctx, x_flat, time * stride, 1, 1, channels);
@@ -293,8 +300,7 @@ namespace Ops {
                          const String2TensorStorage& tensor_storage_map = {},
                          const std::string prefix                       = "") override {
             ggml_type down_type                 = audio_conv_weight_type(get_type(prefix + "downsample.lowpass.filter", tensor_storage_map, GGML_TYPE_F16));
-            const char* direct_depthwise = std::getenv("ED_MINIMAX_H3_AUDIO_DIRECT_DEPTHWISE");
-            if (direct_depthwise != nullptr && direct_depthwise[0] != '\0' && direct_depthwise[0] != '0') {
+            if (h3_audio_env_flag_enabled_or_default("ED_MINIMAX_H3_AUDIO_DIRECT_DEPTHWISE", true)) {
                 down_type = GGML_TYPE_F32;
             }
             params["downsample.lowpass.filter"] = ggml_new_tensor_3d(ctx, down_type, down_kernel_size, 1, 1);
diff --git a/src/dit_models/components/autoencoders/minimax_h3_vae.hpp b/src/dit_models/components/autoencoders/minimax_h3_vae.hpp
index af4adc9..46f4568 100644
--- a/src/dit_models/components/autoencoders/minimax_h3_vae.hpp
+++ b/src/dit_models/components/autoencoders/minimax_h3_vae.hpp
@@ -25,6 +25,14 @@ namespace MiniMaxH3VAE {
         return value != nullptr && value[0] != '\0' && std::strcmp(value, "0") != 0;
     }
 
+    static bool h3_env_flag_enabled_or_default(const char* name, bool default_enabled) {
+        const char* value = std::getenv(name);
+        if (value == nullptr || value[0] == '\0') {
+            return default_enabled;
+        }
+        return std::strcmp(value, "0") != 0;
+    }
+
     static ggml_tensor* h3_profile_name(ggml_tensor* tensor, const std::string& name) {
         if (tensor != nullptr && h3_env_flag_enabled("ED_MINIMAX_H3_VAE_NAME_NODES")) {
             ggml_set_name(tensor, name.c_str());
@@ -111,7 +119,7 @@ namespace MiniMaxH3VAE {
             : GroupNorm(32, channels, 1e-6f, true) {}
 
         ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* x) {
-            if (h3_env_flag_enabled("ED_MINIMAX_H3_VAE_FAST_TEMPORAL_GROUP_NORM")) {
+            if (h3_env_flag_enabled_or_default("ED_MINIMAX_H3_VAE_FAST_TEMPORAL_GROUP_NORM", true)) {
                 GGML_ASSERT(x->ne[3] % num_channels == 0);
                 const int64_t temporal_size = x->ne[2];
                 const int64_t batch_size    = x->ne[3] / num_channels;
@@ -407,7 +415,7 @@ namespace MiniMaxH3VAE {
             auto w2   = std::dynamic_pointer_cast<Linear>(blocks["w2"]);
             auto projected = w1->forward(ctx, x);
             h3_profile_name(projected, profile_prefix + ".w1");
-            if (h3_env_flag_enabled("ED_MINIMAX_H3_VAE_FUSED_SWIGLU")) {
+            if (h3_env_flag_enabled_or_default("ED_MINIMAX_H3_VAE_FUSED_SWIGLU", true)) {
                 auto activated = ggml_swiglu(ctx->ggml_ctx, projected);
                 h3_profile_name(activated, profile_prefix + ".swiglu");
                 return h3_profile_name(w2->forward(ctx, activated), profile_prefix + ".out");
@@ -710,7 +718,7 @@ namespace MiniMaxH3VAE {
             auto output            = std::move(current);
             extent                 = std::min({extent, previous.shape()[2], output.shape()[2]});
             int64_t previous_start = previous.shape()[2] - extent;
-            if (h3_env_flag_enabled("ED_MINIMAX_H3_FAST_TEMPORAL_BLEND")) {
+            if (h3_env_flag_enabled_or_default("ED_MINIMAX_H3_FAST_TEMPORAL_BLEND", true)) {
                 const int64_t frame_size = output.shape()[0] * output.shape()[1];
                 const int64_t frames_per_outer = output.shape()[2];
                 const int64_t previous_frames_per_outer = previous.shape()[2];
@@ -731,7 +739,7 @@ namespace MiniMaxH3VAE {
                 });
                 return output;
             }
-            if (h3_env_flag_enabled("ED_MINIMAX_H3_PARALLEL_TEMPORAL_COPY")) {
+            if (h3_env_flag_enabled_or_default("ED_MINIMAX_H3_PARALLEL_TEMPORAL_COPY", true)) {
                 const int64_t channels = output.shape()[3];
                 const int64_t batches = output.shape()[4];
                 sd_parallel_for(0, batches * channels * extent, 8, [&](int64_t index) {
@@ -784,7 +792,7 @@ namespace MiniMaxH3VAE {
             }
             shape[2] = total_frames;
             sd::Tensor<float> result(shape);
-            if (h3_env_flag_enabled("ED_MINIMAX_H3_PARALLEL_TEMPORAL_COPY")) {
+            if (h3_env_flag_enabled_or_default("ED_MINIMAX_H3_PARALLEL_TEMPORAL_COPY", true)) {
                 const int64_t frame_size = shape[0] * shape[1];
                 const int64_t outer_count = shape[3] * shape[4];
                 sd_parallel_for(0, outer_count, 8, [&](int64_t outer) {
@@ -930,7 +938,7 @@ namespace MiniMaxH3VAE {
 
             const bool collect_temporal_parts = h3_env_flag_enabled("ED_MINIMAX_H3_COLLECT_TEMPORAL_PARTS");
             const bool fused_temporal_assembly =
-                h3_env_flag_enabled("ED_MINIMAX_H3_FUSED_TEMPORAL_ASSEMBLY");
+                h3_env_flag_enabled_or_default("ED_MINIMAX_H3_FUSED_TEMPORAL_ASSEMBLY", true);
             sd::Tensor<float> result;
             std::vector<sd::Tensor<float>> temporal_parts;
             if (collect_temporal_parts && !fused_temporal_assembly) {
@@ -1045,7 +1053,7 @@ namespace MiniMaxH3VAE {
                 const int64_t blend_begin = profile_temporal ? ggml_time_us() : 0;
                 if (profile_temporal) output_slice_us += blend_begin - output_slice_begin;
                 if (!overlap.empty()) {
-                    first   = h3_env_flag_enabled("ED_MINIMAX_H3_MOVE_TEMPORAL_BLEND")
+                    first   = h3_env_flag_enabled_or_default("ED_MINIMAX_H3_MOVE_TEMPORAL_BLEND", true)
                                   ? blend_temporal(overlap, std::move(first), frame_overlap)
                                   : blend_temporal(overlap, first, frame_overlap);
                     overlap = {};
@@ -1136,7 +1144,7 @@ namespace MiniMaxH3VAE {
                                    bool decode_graph) override {
             auto input = ensure_video_shape(z);
             if (decode_graph) {
-                const bool reuse_rope = h3_env_flag_enabled("ED_MINIMAX_H3_VAE_REUSE_ROPE_CACHE");
+                const bool reuse_rope = h3_env_flag_enabled_or_default("ED_MINIMAX_H3_VAE_REUSE_ROPE_CACHE", true);
                 if (!reuse_rope ||
                     rope_cache.empty() ||
                     rope_cache_width != input.shape()[0] ||
diff --git a/src/dit_models/components/text_encoders/llm.hpp b/src/dit_models/components/text_encoders/llm.hpp
index 28c35c9..2ac8277 100644
--- a/src/dit_models/components/text_encoders/llm.hpp
+++ b/src/dit_models/components/text_encoders/llm.hpp
@@ -276,9 +276,9 @@ namespace LLM {
         bool qkv_bias             = true;
         bool qk_norm              = false;
     int64_t vocab_size        = 152064;
-    float rms_norm_eps        = 1e-06f;
-    bool final_norm           = true;
-    LLMVisionParams vision;
+        float rms_norm_eps        = 1e-06f;
+        bool final_norm           = true;
+        LLMVisionParams vision;
     };
 
     struct LLMImageEmbedInfo {
@@ -1291,10 +1291,10 @@ namespace LLM {
                 }
             }
             if (is_debug_target(".attn.q_rope")) {
-                return q;
+                return ggml_cont(ctx->ggml_ctx, q);
             }
             if (is_debug_target(".attn.k_rope")) {
-                return k;
+                return ggml_cont(ctx->ggml_ctx, k);
             }
 
             q = ggml_cont(ctx->ggml_ctx, ggml_ext_torch_permute(ctx->ggml_ctx, q, 0, 2, 1, 3));  // [N, num_heads, n_token, head_dim]
@@ -1311,7 +1311,7 @@ namespace LLM {
                                        num_heads,
                                        attention_mask,
                                        true,
-                                       ctx->flash_attn_enabled);  // [N, n_token, hidden_size]
+                                       false);  // [N, n_token, hidden_size]
             if (diffusers_dtype &&
                 (attention_output_type == GGML_TYPE_F16 || attention_output_type == GGML_TYPE_BF16) &&
                 x->type != attention_output_type) {
@@ -1408,6 +1408,36 @@ namespace LLM {
         bool diffusers_text_dtype;
         bool final_norm;
 
+        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 = x->type == image_embeds[0].second->type ? 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;
+        }
+
     public:
         TextModel(const LLMParams& params)
             : num_layers(params.num_layers),
@@ -1515,16 +1545,12 @@ namespace LLM {
 
                 const std::string block_debug_prefix = "block" + std::to_string(i);
                 x = block->forward(ctx, x, input_pos, attention_mask, debug_target, block_debug_prefix);
-                if (i < static_cast<int>(deepstack_image_embeds.size())) {
-                    for (const auto& [index, image_embed] : deepstack_image_embeds[static_cast<size_t>(i)]) {
-                        auto visual_embed = ggml_ext_slice(ctx->ggml_ctx, x, 1, index, index + image_embed->ne[1]);
-                        visual_embed = ggml_add(ctx->ggml_ctx, visual_embed, image_embed);
-                        x = ggml_set_2d(ctx->ggml_ctx, x, visual_embed, x->nb[1], index * x->nb[1]);
-                    }
-                }
                 if (debug_target.rfind(block_debug_prefix + ".", 0) == 0) {
                     return x;
                 }
+                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 (out_layers.size() > 1) {
                     x = ggml_cont(ctx->ggml_ctx, x);
                 }
@@ -1798,63 +1824,47 @@ namespace LLM {
                           return a.token_index < b.token_index;
                       });
 
-            input_pos_vec.assign(static_cast<size_t>(n_tokens) * 4, 0);
-            auto set_pos = [&](int64_t token, int64_t t, int64_t h, int64_t w) {
-                input_pos_vec[static_cast<size_t>(token)] = static_cast<int>(t);
-                input_pos_vec[static_cast<size_t>(n_tokens + token)] = static_cast<int>(h);
-                input_pos_vec[static_cast<size_t>(2 * n_tokens + token)] = static_cast<int>(w);
+            input_pos_vec.resize(static_cast<size_t>(n_tokens) * 4);
+            for (int64_t token = 0; token < n_tokens; ++token) {
+                input_pos_vec[static_cast<size_t>(token)] = static_cast<int>(token);
+                input_pos_vec[static_cast<size_t>(n_tokens + token)] = static_cast<int>(token);
+                input_pos_vec[static_cast<size_t>(2 * n_tokens + token)] = static_cast<int>(token);
                 input_pos_vec[static_cast<size_t>(3 * n_tokens + token)] = 0;
-            };
-            auto fill_text = [&](int64_t token_start, int64_t text_len, int64_t pos_start) {
-                for (int64_t i = 0; i < text_len; ++i) {
-                    const int64_t pos = pos_start + i;
-                    set_pos(token_start + i, pos, pos, pos);
-                }
-            };
+            }
 
-            int64_t token_cursor = 0;
-            int64_t pos_cursor   = 0;
+            int64_t offset = 0;
             for (const auto& info : infos) {
-                const int64_t visual_start = static_cast<int64_t>(info.token_index);
-                const int64_t grid_t       = std::max<int64_t>(1, info.grid_t);
-                const int64_t grid_h       = info.grid_h;
-                const int64_t grid_w       = info.grid_w;
-                const int64_t token_count  = info.token_count > 0 ? info.token_count : grid_t * grid_h * grid_w;
-                if (visual_start < token_cursor || grid_h <= 0 || grid_w <= 0 ||
-                    token_count != grid_t * grid_h * grid_w ||
-                    visual_start + token_count > n_tokens) {
+                const int64_t index = static_cast<int64_t>(info.token_index);
+                const int64_t size = info.token_count;
+                const int64_t merge = std::max<int64_t>(1, params.vision.spatial_merge_size);
+                if (info.grid_h <= 0 || info.grid_w <= 0 ||
+                    info.grid_h % merge != 0 || info.grid_w % merge != 0) {
                     return false;
                 }
-
-                const int64_t text_len = visual_start - token_cursor;
-                fill_text(token_cursor, text_len, pos_cursor);
-
-                const int64_t visual_pos_start = pos_cursor + text_len;
-                int64_t max_visual_pos         = visual_pos_start;
-                int64_t visual_token           = visual_start;
-                for (int64_t t = 0; t < grid_t; ++t) {
-                    (void)t;
-                    for (int64_t h = 0; h < grid_h; ++h) {
-                        for (int64_t w = 0; w < grid_w; ++w) {
-                            set_pos(visual_token,
-                                    visual_pos_start,
-                                    visual_pos_start + h,
-                                    visual_pos_start + w);
-                            max_visual_pos = std::max(max_visual_pos,
-                                                      std::max(visual_pos_start,
-                                                               std::max(visual_pos_start + h,
-                                                                        visual_pos_start + w)));
-                            ++visual_token;
-                        }
-                    }
+                const int64_t grid_h = info.grid_h / merge;
+                const int64_t grid_w = info.grid_w / merge;
+                const int64_t end = index + size;
+                if (index < 0 || end > n_tokens || grid_h <= 0 || grid_w <= 0 ||
+                    size != grid_h * grid_w) {
+                    return false;
                 }
 
-                token_cursor = visual_start + token_count;
-                pos_cursor   = max_visual_pos + 1;
-            }
-
-            if (token_cursor < n_tokens) {
-                fill_text(token_cursor, n_tokens - token_cursor, pos_cursor);
+                const int64_t len_max = std::max(grid_h, grid_w);
+                const int64_t next_pos = index + len_max + offset;
+                for (int64_t token = end; token < n_tokens; ++token) {
+                    const int64_t pos = next_pos + token - end;
+                    input_pos_vec[static_cast<size_t>(token)] = static_cast<int>(pos);
+                    input_pos_vec[static_cast<size_t>(n_tokens + token)] = static_cast<int>(pos);
+                    input_pos_vec[static_cast<size_t>(2 * n_tokens + token)] = static_cast<int>(pos);
+                }
+                for (int64_t token = 0; token < size; ++token) {
+                    input_pos_vec[static_cast<size_t>(index + token)] = static_cast<int>(index + offset);
+                    input_pos_vec[static_cast<size_t>(n_tokens + index + token)] =
+                        static_cast<int>(index + offset + token / grid_w);
+                    input_pos_vec[static_cast<size_t>(2 * n_tokens + index + token)] =
+                        static_cast<int>(index + offset + token % grid_w);
+                }
+                offset += len_max - size;
             }
             if (qwen_align_debug_enabled()) {
                 LOG_INFO("qwen-align mrope_positions: n_tokens=%" PRId64 " axes=4", n_tokens);
diff --git a/src/dit_models/models/minimax_h3_full.hpp b/src/dit_models/models/minimax_h3_full.hpp
index 45aa217..4a92cfe 100644
--- a/src/dit_models/models/minimax_h3_full.hpp
+++ b/src/dit_models/models/minimax_h3_full.hpp
@@ -5,6 +5,7 @@
 #include <cmath>
 #include <cstdlib>
 #include <set>
+#include <sstream>
 #include <string>
 #include <tuple>
 #include <utility>
@@ -27,6 +28,23 @@ namespace MiniMaxH3 {
         return value != nullptr && value[0] != '\0' && std::atoi(value) != 0;
     }
 
+    static bool h3_env_flag_enabled_or_default(const char* name, bool default_enabled) {
+        const char* value = std::getenv(name);
+        if (value == nullptr || value[0] == '\0') {
+            return default_enabled;
+        }
+        return std::atoi(value) != 0;
+    }
+
+    static bool h3_trace_first_step_enabled() {
+        if (!h3_env_flag_enabled("ED_MINIMAX_H3_TRACE")) {
+            return false;
+        }
+        const char* step = std::getenv("ED_MINIMAX_H3_CURRENT_STEP");
+        return step == nullptr || std::atoi(step) == 0;
+    }
+
+
     struct Config {
         int64_t hidden_size              = 5376;
         int64_t num_layers               = 50;
@@ -161,17 +179,33 @@ namespace MiniMaxH3 {
     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);
+            blocks["fc1"] = std::make_shared<Linear>(hidden_size,
+                                                      ffn_hidden_size * 2,
+                                                      false,
+                                                      false,
+                                                      true,
+                                                      1.f / 128.f,
+                                                      true);
+            blocks["fc2"] = std::make_shared<Linear>(ffn_hidden_size,
+                                                      hidden_size,
+                                                      false,
+                                                      false,
+                                                      true,
+                                                      1.f / 128.f,
+                                                      true);
         }
 
         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"]);
+            if (h3_env_flag_enabled("ED_MINIMAX_H3_DISABLE_MLP_INPUT_SCALE")) {
+                fc1->set_scale(1.f);
+                fc2->set_scale(1.f);
+            }
             const bool use_mlp_tensor_cores = h3_env_flag_enabled("ED_MINIMAX_H3_MLP_FP16_CUBLAS");
             const bool use_fc1_tensor_cores = use_mlp_tensor_cores ||
                                               h3_env_flag_enabled("ED_MINIMAX_H3_FC1_FP16_CUBLAS") ||
-                                              h3_env_flag_enabled("ED_MINIMAX_H3_FC1_F32_OUTPUT");
+                                              h3_env_flag_enabled_or_default("ED_MINIMAX_H3_FC1_F32_OUTPUT", true);
             const bool use_fc2_tensor_cores = use_mlp_tensor_cores || h3_env_flag_enabled("ED_MINIMAX_H3_FC2_FP16_CUBLAS");
             fc1->set_force_prec_f32(!use_fc1_tensor_cores);
             fc2->set_force_prec_f32(!use_fc2_tensor_cores);
@@ -502,13 +536,32 @@ namespace MiniMaxH3 {
                              ggml_tensor* x,
                              ggml_tensor* t_emb,
                              const std::vector<TokenModulationSpan>& segments,
-                             ggml_tensor* pe) {
+                             ggml_tensor* pe,
+                             const std::string& debug_target = {},
+                             ggml_tensor** debug_output = nullptr) {
             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);
+            if (debug_output != nullptr && debug_target == "block0_adaln") {
+                *debug_output = mods;
+                return x;
+            }
+            if (debug_output != nullptr && starts_with(debug_target, "block0_mod_")) {
+                const int component = std::atoi(debug_target.substr(std::strlen("block0_mod_")).c_str());
+                if (component >= 0 && component < 6 && !segments.empty()) {
+                    auto selected = modulation_row(ctx->ggml_ctx,
+                                                   mods,
+                                                   config.hidden_size,
+                                                   6,
+                                                   3,
+                                                   segments.front().modulation_row);
+                    *debug_output = selected[component];
+                    return x;
+                }
+            }
 
             auto h = modulate_segments(ctx->ggml_ctx,
                                        norm1->forward(ctx, x),
@@ -519,13 +572,26 @@ namespace MiniMaxH3 {
                                        3,
                                        0,
                                        1);
+            if (debug_output != nullptr && debug_target == "block0_attn_input") {
+                *debug_output = h;
+                return x;
+            }
+            auto attn_output = attn->forward(ctx, h, pe);
+            if (debug_output != nullptr && debug_target == "block0_attn_output") {
+                *debug_output = attn_output;
+                return x;
+            }
             x      = gated_residual_segments(ctx->ggml_ctx,
                                              x,
-                                             attn->forward(ctx, h, pe),
+                                             attn_output,
                                              mods,
                                              segments,
                                              config.hidden_size,
                                              2);
+            if (debug_output != nullptr && debug_target == "block0_after_attn") {
+                *debug_output = x;
+                return x;
+            }
             h      = modulate_segments(ctx->ggml_ctx,
                                        norm2->forward(ctx, x),
                                        mods,
@@ -535,9 +601,18 @@ namespace MiniMaxH3 {
                                        3,
                                        3,
                                        4);
+            if (debug_output != nullptr && debug_target == "block0_mlp_input") {
+                *debug_output = h;
+                return x;
+            }
+            auto mlp_output = mlp->forward(ctx, h);
+            if (debug_output != nullptr && debug_target == "block0_mlp_output") {
+                *debug_output = mlp_output;
+                return x;
+            }
             return gated_residual_segments(ctx->ggml_ctx,
                                            x,
-                                           mlp->forward(ctx, h),
+                                           mlp_output,
                                            mods,
                                            segments,
                                            config.hidden_size,
@@ -687,7 +762,9 @@ namespace MiniMaxH3 {
                                                       const std::vector<SequenceSegment>& sequence_segments,
                                                       const TokenModulationSpan& video_segment,
                                                       const TokenModulationSpan& audio_segment,
-                                                      ggml_tensor* audio_slope) {
+                                                      ggml_tensor* audio_slope,
+                                                      const std::string& debug_target = {},
+                                                      ggml_tensor** debug_output = nullptr) {
             auto video_proj = std::dynamic_pointer_cast<Linear>(blocks["video_patch_proj"]);
             auto audio_proj = std::dynamic_pointer_cast<Linear>(blocks["audio_patch_proj"]);
 
@@ -779,10 +856,33 @@ namespace MiniMaxH3 {
                                         curve_indices,
                                         curve_upper_indices,
                                         curve_fractions);
+            if (debug_output != nullptr) {
+                if (debug_target == "temb") {
+                    *debug_output = t_emb;
+                    return {nullptr, nullptr};
+                }
+                if (debug_target == "packed_input") {
+                    *debug_output = h;
+                    return {nullptr, nullptr};
+                }
+            }
             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);
+                h          = block->forward(ctx,
+                                            h,
+                                            t_emb,
+                                            segments,
+                                            pe,
+                                            i == 0 ? debug_target : std::string(),
+                                            i == 0 ? debug_output : nullptr);
+                if (debug_output != nullptr && *debug_output != nullptr) {
+                    return {nullptr, nullptr};
+                }
+                if (debug_output != nullptr && debug_target == "block0" && i == 0) {
+                    *debug_output = h;
+                    return {nullptr, nullptr};
+                }
                 sd::ggml_graph_cut::mark_graph_cut(h,
                                                    "minimax_h3.blocks." + std::to_string(i),
                                                    "hidden_states");
@@ -1163,6 +1263,60 @@ namespace MiniMaxH3 {
                                          t_v,
                                          t_a);
 
+            if (h3_trace_first_step_enabled()) {
+                auto reference_kind_name = [](MiniMaxH3ReferenceKind kind) {
+                    switch (kind) {
+                        case MiniMaxH3ReferenceKind::IMAGE: return "image";
+                        case MiniMaxH3ReferenceKind::VIDEO: return "video";
+                        case MiniMaxH3ReferenceKind::VIDEO_AUDIO: return "video_audio";
+                        case MiniMaxH3ReferenceKind::AUDIO: return "audio";
+                    }
+                    return "unknown";
+                };
+                std::ostringstream ref_stream;
+                for (size_t index = 0; index < reference_blocks.size(); ++index) {
+                    const auto& block = reference_blocks[index];
+                    if (index > 0) {
+                        ref_stream << ";";
+                    }
+                    ref_stream << index << ":" << reference_kind_name(block.kind)
+                               << "(v=" << block.video_index
+                               << ",a=" << block.audio_index << ")";
+                }
+                LOG_INFO("minimax-h3 trace dit layout: text=%lld target_video=%lldx%lldx%lld target_audio=%d condition_videos=%zu condition_audios=%zu reference_blocks=%zu [%s] packed_tokens=%lld sequence_segments=%zu segments=%zu timesteps=%zu",
+                         static_cast<long long>(context_tensor.shape()[1]),
+                         static_cast<long long>(video_input_cache.shape()[2]),
+                         static_cast<long long>(video_input_cache.shape()[1]),
+                         static_cast<long long>(video_input_cache.shape()[0]),
+                         audio_length,
+                         condition_videos.size(),
+                         condition_audios.size(),
+                         reference_blocks.size(),
+                         ref_stream.str().c_str(),
+                         static_cast<long long>(layout.positions.size() / 3),
+                         layout.sequence_segments.size(),
+                         layout.segments.size(),
+                         layout.timesteps.size());
+                for (size_t index = 0; index < condition_videos.size(); ++index) {
+                    const auto& condition = condition_videos[index];
+                    LOG_INFO("minimax-h3 trace condition_video[%zu]: shape=%lldx%lldx%lldx%lldx%lld",
+                             index,
+                             static_cast<long long>(condition.shape()[0]),
+                             static_cast<long long>(condition.shape()[1]),
+                             static_cast<long long>(condition.shape()[2]),
+                             static_cast<long long>(condition.shape()[3]),
+                             static_cast<long long>(condition.shape()[4]));
+                }
+                for (size_t index = 0; index < condition_audios.size(); ++index) {
+                    const auto& condition = condition_audios[index];
+                    LOG_INFO("minimax-h3 trace condition_audio[%zu]: shape=%lldx%lldx%lld",
+                             index,
+                             static_cast<long long>(condition.shape()[0]),
+                             static_cast<long long>(condition.shape()[1]),
+                             static_cast<long long>(condition.shape()[2]));
+                }
+            }
+
             position_input_cache = sd::Tensor<float>(
                 {3, static_cast<int64_t>(layout.positions.size() / 3)},
                 layout.positions);
@@ -1212,6 +1366,9 @@ namespace MiniMaxH3 {
                 {1},
                 {time_shift_slope(sigma_v, video_shift, audio_shift)});
             auto audio_slope_tensor = make_input(audio_slope_input_cache);
+            const char* debug_target_env = std::getenv("ED_MINIMAX_H3_DEBUG_TARGET");
+            const std::string debug_target = debug_target_env == nullptr ? std::string() : std::string(debug_target_env);
+            ggml_tensor* debug_output = nullptr;
             auto output     = model.forward(&runner_ctx,
                                             video,
                                             audio,
@@ -1227,8 +1384,12 @@ namespace MiniMaxH3 {
                                             layout.sequence_segments,
                                             layout.video_segment,
                                             layout.audio_segment,
-                                            audio_slope_tensor);
-            auto merged     = merge_av_latents(compute_ctx, output.first, output.second);
+                                            audio_slope_tensor,
+                                            debug_target,
+                                            &debug_output);
+            auto merged     = debug_output == nullptr
+                                  ? merge_av_latents(compute_ctx, output.first, output.second)
+                                  : debug_output;
             auto graph      = new_graph_custom(H3_GRAPH_SIZE);
             ggml_build_forward_expand(graph, merged);
             return graph;
@@ -1260,7 +1421,8 @@ namespace MiniMaxH3 {
                                    params.minimax_video_sigma_shift,
                                    params.minimax_audio_sigma_shift);
             };
-            if (h3_env_flag_enabled("ED_MINIMAX_H3_REUSE_GRAPH")) {
+            if (h3_env_flag_enabled("ED_MINIMAX_H3_REUSE_GRAPH") &&
+                std::getenv("ED_MINIMAX_H3_DEBUG_TARGET") == nullptr) {
                 auto split_for_reuse = split_av_latents(*params.x, params.minimax_audio_length);
                 video_input_cache = std::move(split_for_reuse.first);
                 audio_input_cache = std::move(split_for_reuse.second);
diff --git a/src/dit_models/pipelines/minimax_h3_pipeline.cpp b/src/dit_models/pipelines/minimax_h3_pipeline.cpp
index b4ee029..6b85dee 100644
--- a/src/dit_models/pipelines/minimax_h3_pipeline.cpp
+++ b/src/dit_models/pipelines/minimax_h3_pipeline.cpp
@@ -8,6 +8,7 @@
 #include <fstream>
 #include <limits>
 #include <iomanip>
+#include <regex>
 #include <set>
 #include <sstream>
 #include <thread>
@@ -24,6 +25,8 @@
 namespace edgedit {
 namespace {
 
+constexpr int H3_REF_IMAGE_SHORT_EDGE = 2048;
+
 struct ScopedEnvVar {
     std::string name;
     std::string old_value;
@@ -70,6 +73,26 @@ int64_t h3_resolve_seed(int64_t seed) {
 
 bool h3_profile_enabled();
 
+bool h3_condition_debug_exit_enabled() {
+    const char* value = std::getenv("ED_MINIMAX_H3_CONDITION_DEBUG_EXIT");
+    return value != nullptr && value[0] != '\0' && std::strcmp(value, "0") != 0;
+}
+
+bool h3_ref_image_text_short_edge_2048_enabled() {
+    const char* value = std::getenv("ED_MINIMAX_H3_REF_IMAGE_TEXT_SHORT_EDGE_2048");
+    return value != nullptr && value[0] != '\0' && std::strcmp(value, "0") != 0;
+}
+
+std::string h3_text_debug_target() {
+    const char* value = std::getenv("ED_MINIMAX_H3_TEXT_DEBUG_TARGET");
+    return value == nullptr ? std::string() : std::string(value);
+}
+
+std::string h3_dit_debug_target() {
+    const char* value = std::getenv("ED_MINIMAX_H3_DEBUG_TARGET");
+    return value == nullptr ? std::string() : std::string(value);
+}
+
 void h3_dump_vae_latent_if_requested(const sd::Tensor<float>& latent) {
     const char* base_path = std::getenv("ED_MINIMAX_H3_DUMP_VAE_LATENT");
     if (base_path == nullptr || base_path[0] == '\0') {
@@ -144,14 +167,37 @@ void h3_reference_video_dimensions(const ed_image_t& image, int* width, int* hei
     }
 }
 
+void h3_reference_image_dimensions(const ed_image_t& image, int* width, int* height) {
+    const double scale = static_cast<double>(H3_REF_IMAGE_SHORT_EDGE) /
+                         static_cast<double>(std::min(image.width, image.height));
+    *width = std::max(32, static_cast<int>(std::round(image.width * scale / 32.0)) * 32);
+    *height = std::max(32, static_cast<int>(std::round(image.height * scale / 32.0)) * 32);
+}
+
+void h3_reference_image_dimensions_for_canvas(const ed_image_t& image,
+                                              int canvas_width,
+                                              int canvas_height,
+                                              int* width,
+                                              int* height) {
+    const double source_area = static_cast<double>(image.width) * static_cast<double>(image.height);
+    const double target_area = static_cast<double>(canvas_width) * static_cast<double>(canvas_height);
+    const double scale = std::min(1.0, std::sqrt(target_area / source_area));
+    *width = std::max(32, static_cast<int>(std::round(image.width * scale / 32.0)) * 32);
+    *height = std::max(32, static_cast<int>(std::round(image.height * scale / 32.0)) * 32);
+}
+
 float h3_discrete_flow_sigma(int step, int steps, float shift) {
     if (steps <= 1) {
-        return 1.0f;
+        return step <= 0 ? 1.0f : 0.0f;
     }
-    const float timestep = 999.0f - 999.0f * static_cast<float>(step) / static_cast<float>(steps - 1);
-    const float unit_timestep = (timestep + 1.0f) / 1000.0f;
-    return shift == 1.0f ? unit_timestep
-                         : shift * unit_timestep / (1.0f + (shift - 1.0f) * unit_timestep);
+    if (step >= steps) {
+        return 0.0f;
+    }
+    const float t_max = 999.0f;
+    const float t = t_max - (t_max / static_cast<float>(steps - 1)) * static_cast<float>(step);
+    const float sigma = (t + 1.0f) / 1000.0f;
+    return shift == 1.0f ? sigma
+                         : shift * sigma / (1.0f + (shift - 1.0f) * sigma);
 }
 
 bool h3_trace_enabled() {
@@ -166,7 +212,7 @@ bool h3_profile_enabled() {
 
 bool h3_fast_video_postprocess_enabled() {
     const char* value = std::getenv("ED_MINIMAX_H3_FAST_VIDEO_POSTPROCESS");
-    return value != nullptr && value[0] != '\0' && std::strcmp(value, "0") != 0;
+    return value == nullptr || value[0] == '\0' || std::strcmp(value, "0") != 0;
 }
 
 bool h3_verify_fast_video_postprocess_enabled() {
@@ -177,7 +223,7 @@ bool h3_verify_fast_video_postprocess_enabled() {
 int h3_fast_video_postprocess_threads() {
     const char* value = std::getenv("ED_MINIMAX_H3_FAST_VIDEO_POSTPROCESS_THREADS");
     if (value == nullptr || value[0] == '\0') {
-        return 0;
+        return 16;
     }
     char* end = nullptr;
     const long requested = std::strtol(value, &end, 10);
@@ -222,6 +268,29 @@ void h3_trace_tensor(const char* name, const sd::Tensor<float>& tensor) {
              maximum);
 }
 
+void h3_dump_debug_tensor_if_requested(const std::string& name, const sd::Tensor<float>& tensor) {
+    const char* base_path = std::getenv("ED_MINIMAX_H3_DEBUG_DUMP");
+    if (base_path == nullptr || base_path[0] == '\0' || tensor.empty()) {
+        return;
+    }
+    const std::string prefix = std::string(base_path) + "." + name;
+    std::ofstream data_out(prefix + ".f32.bin", std::ios::binary);
+    if (data_out) {
+        data_out.write(reinterpret_cast<const char*>(tensor.values().data()),
+                       static_cast<std::streamsize>(tensor.values().size() * sizeof(float)));
+    }
+    std::ofstream shape_out(prefix + ".shape");
+    if (shape_out) {
+        for (size_t index = 0; index < tensor.shape().size(); ++index) {
+            if (index > 0) {
+                shape_out << ' ';
+            }
+            shape_out << tensor.shape()[index];
+        }
+        shape_out << '\n';
+    }
+}
+
 sd::Tensor<float> h3_sample_vae_moments(const sd::Tensor<float>& moments,
                                         std::shared_ptr<RNG> rng) {
     if (moments.empty() || moments.shape().size() < 4 || moments.shape()[3] != 48) {
@@ -242,16 +311,11 @@ sd::Tensor<float> h3_encode_vae_condition(MiniMaxH3VAE::MiniMaxH3VideoVAERunner*
                                           int n_threads,
                                           const sd::Tensor<float>& video,
                                           ed_tiling_params_t tiling) {
-    auto moments = vae->encode_moments(n_threads, video, tiling);
-    auto rng = std::make_shared<PhiloxRNG>(42);
-    auto latent = h3_sample_vae_moments(moments, rng);
-    if (!latent.empty()) {
-        return latent;
-    }
     return vae->encode(n_threads, video, tiling);
 }
 
-void h3_apply_condition_noise(sd::Tensor<float>* latent, std::shared_ptr<RNG> rng) {
+void h3_apply_condition_noise(sd::Tensor<float>* latent, uint64_t seed) {
+    auto rng = std::make_shared<PhiloxRNG>(seed);
     *latent = *latent * MiniMaxH3::VISUAL_COND_TIMESTEP +
               sd::randn_like<float>(*latent, rng) * (1.0f - MiniMaxH3::VISUAL_COND_TIMESTEP);
 }
@@ -486,12 +550,27 @@ bool MiniMaxH3Pipeline::prepare(const ed_context_params_t& params,
     diffusion_->get_param_tensors(registry.tensors(), "model.diffusion_model");
 
     const bool text_offload = runtime.clip_offload_params_to_cpu();
+    String2TensorStorage conditioner_tensors = loader.get_tensor_storage_map();
+    const std::regex language_layer_pattern(R"(^text_encoders\.llm\.model\.layers\.(\d+)\.)");
+    for (auto it = conditioner_tensors.begin(); it != conditioner_tensors.end();) {
+        std::smatch match;
+        const bool unused_language_layer = std::regex_search(it->first, match, language_layer_pattern) &&
+                                           std::stoi(match[1].str()) >= 50;
+        const bool unused_language_head = it->first == "text_encoders.llm.model.norm.weight" ||
+                                          starts_with(it->first, "text_encoders.llm.lm_head.");
+        if (unused_language_layer || unused_language_head) {
+            it = conditioner_tensors.erase(it);
+        } else {
+            ++it;
+        }
+    }
     conditioner_ = std::make_unique<LLM::LLMEmbedder>(LLM::LLMArch::QWEN3_VL,
                                                        runtime.clip_backend(),
                                                        text_offload,
-                                                       loader.get_tensor_storage_map(),
+                                                       conditioner_tensors,
                                                        "text_encoders.llm",
                                                        true);
+    conditioner_->model.set_flash_attention_enabled(runtime.flash_attention());
     conditioner_->alloc_params_buffer();
     conditioner_->get_param_tensors(registry.tensors(), "text_encoders.llm");
 
@@ -582,12 +661,32 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
     if (context == nullptr || token_tags == nullptr || conditioner_ == nullptr || runtime_ == nullptr) {
         return set_minimax_error(error, "MiniMax-H3 text conditioner is not initialized");
     }
-    std::string presentations;
+    std::string presentation;
     std::vector<std::pair<int, sd::Tensor<float>>> image_embeds;
     std::vector<LLM::LLMImageEmbedInfo> image_embed_infos;
     std::vector<std::vector<std::pair<int, sd::Tensor<float>>>> deepstack_image_embeds(3);
-    std::vector<std::pair<int, int64_t>> vision_token_ranges;
     const int vision_patch_size = conditioner_->model.params.vision.patch_size;
+    const std::string vision_start = "<|vision_start|>";
+    const std::string vision_end = "<|vision_end|>";
+    const std::string image_pad = "<|image_pad|>";
+    const auto vision_start_tokens = conditioner_->tokenizer->tokenize(vision_start, nullptr, true, 0, 0, false);
+    const auto vision_end_tokens = conditioner_->tokenizer->tokenize(vision_end, nullptr, true, 0, 0, false);
+    const auto image_pad_tokens = conditioner_->tokenizer->tokenize(image_pad, nullptr, true, 0, 0, false);
+    if (vision_start_tokens.size() != 1 || vision_end_tokens.size() != 1 || image_pad_tokens.size() != 1) {
+        return set_minimax_error(error, "MiniMax-H3 tokenizer special tokens are invalid");
+    }
+    auto append_text = [&](const std::string& text) {
+        presentation += text;
+    };
+    auto append_vision = [&](int64_t count) {
+        presentation += vision_start;
+        const int embed_index = static_cast<int>(conditioner_->tokenizer->tokenize(presentation, nullptr, true, 0, 0, false).size());
+        for (int64_t index = 0; index < count; ++index) {
+            presentation += image_pad;
+        }
+        presentation += vision_end;
+        return embed_index;
+    };
     auto add_vision_image = [&](const ed_image_t& image,
                                 int image_index,
                                 int width,
@@ -612,23 +711,13 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
         }
         sd::Tensor<float> image_embed = std::move(image_outputs[0]);
         const int64_t image_tokens = image_embed.shape()[1];
-        const std::string prefix = "<Picture " + std::to_string(image_index + 1) + ">: <|vision_start|>";
-        const std::vector<int> prefix_tokens = conditioner_->tokenizer->tokenize(presentations + prefix, nullptr, true, 0, 4096, false);
-        presentations += prefix;
-        for (int64_t token = 0; token < image_tokens; ++token) {
-            presentations += "<|image_pad|>";
-        }
-        presentations += "<|vision_end|>";
-        if (!keyframe) {
-            presentations += "\n";
-        }
-        const int embed_index = static_cast<int>(prefix_tokens.size());
+        append_text("<Picture " + std::to_string(image_index + 1) + ">: ");
+        const int embed_index = append_vision(image_tokens);
         image_embeds.emplace_back(embed_index, std::move(image_embed));
         for (size_t layer = 0; layer < deepstack_image_embeds.size(); ++layer) {
             deepstack_image_embeds[layer].emplace_back(embed_index, std::move(image_outputs[layer + 1]));
         }
         image_embed_infos.push_back({embed_index, image_tokens, 1, height / vision_patch_size, width / vision_patch_size});
-        vision_token_ranges.emplace_back(embed_index, image_tokens);
         return true;
     };
     int keyframe_image_index = 0;
@@ -646,7 +735,11 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
         const ed_image_t& image = ref_images[image_index];
         int width = 0;
         int height = 0;
-        h3_resize_for_vision(image.width, image.height, &width, &height);
+        if (h3_ref_image_text_short_edge_2048_enabled()) {
+            h3_reference_image_dimensions(image, &width, &height);
+        } else {
+            h3_reference_image_dimensions_for_canvas(image, canvas_width, canvas_height, &width, &height);
+        }
         LOG_DEBUG("MiniMax-H3 Ref2VA vision image=%dx%d tensor=%s",
                   width,
                   height,
@@ -670,9 +763,9 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
             return ED_STATUS_INVALID_ARGUMENT;
         }
         if (reference.audio.data != nullptr && reference.audio.sample_count > 0) {
-            presentations += "<Audio " + std::to_string(++audio_number) + ">: ";
+            append_text("<Audio " + std::to_string(++audio_number) + ">: ");
         }
-        presentations += "<Video " + std::to_string(++video_number) + ">: ";
+        append_text("<Video " + std::to_string(++video_number) + ">: ");
         while (normalized_frames % 17 != 5) --normalized_frames;
         std::vector<int> sampled_frames;
         sampled_frames.reserve(static_cast<size_t>((normalized_frames + 11) / 12));
@@ -689,7 +782,16 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
             const ed_image_t& first_image = reference.frames[first_index];
             int width = 0;
             int height = 0;
-            h3_resize_for_vision(first_image.width, first_image.height, &width, &height);
+            h3_reference_video_dimensions(first_image, &width, &height);
+            if (h3_trace_enabled() && sampled_index == 0) {
+                LOG_INFO("MiniMax-H3 Ref2VA video %d vision geometry: source=%dx%d normalized=%dx%d frames=%d",
+                         video_index + 1,
+                         first_image.width,
+                         first_image.height,
+                         width,
+                         height,
+                         normalized_frames);
+            }
             auto first = h3_image_to_tensor(first_image, width, height);
             auto second = h3_image_to_tensor(reference.frames[second_index], width, height);
             if (first.empty() || second.empty()) return set_minimax_error(error, "MiniMax-H3 Ref2VA video frame is invalid");
@@ -713,40 +815,59 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
             timestamp_stream << '<' << std::fixed << std::setprecision(1)
                              << (first_time + second_time) * 0.5f << " seconds>";
             const std::string timestamp = timestamp_stream.str();
-            const auto prefix_tokens = conditioner_->tokenizer->tokenize(presentations + timestamp + "<|vision_start|>", nullptr, true, 0, 4096, false);
-            presentations += timestamp + "<|vision_start|>";
-            const int64_t tokens = outputs[0].shape()[1];
-            for (int64_t token = 0; token < tokens; ++token) presentations += "<|video_pad|>";
-            presentations += "<|vision_end|>";
-            const int embed_index = static_cast<int>(prefix_tokens.size());
+            append_text(timestamp);
+            const int64_t vision_tokens = outputs[0].shape()[1];
+            const int embed_index = append_vision(vision_tokens);
             image_embeds.emplace_back(embed_index, std::move(outputs[0]));
             for (size_t layer = 0; layer < deepstack_image_embeds.size(); ++layer) deepstack_image_embeds[layer].emplace_back(embed_index, std::move(outputs[layer + 1]));
-            image_embed_infos.push_back({embed_index, tokens, 1, height / vision_patch_size, width / vision_patch_size});
-            vision_token_ranges.emplace_back(embed_index, tokens);
+            image_embed_infos.push_back({embed_index, vision_tokens, 1, height / vision_patch_size, width / vision_patch_size});
         }
     }
     for (int audio_index = 0; audio_index < ref_audio_count; ++audio_index) {
-        presentations += "<Audio " + std::to_string(++audio_number) + ">: ";
+        append_text("<Audio " + std::to_string(++audio_number) + ">: ");
     }
-    const std::string text = presentations + std::string(prompt == nullptr ? "" : prompt);
     const int64_t tokenize_begin = profile != nullptr ? ggml_time_ms() : 0;
-    const std::vector<int> tokens = conditioner_->tokenizer->tokenize(text, nullptr, true, 0, 4096, false);
+    append_text(prompt == nullptr ? "" : prompt);
+    std::vector<int> tokens = conditioner_->tokenizer->tokenize(presentation, nullptr, true, 0, 0, false);
     if (profile != nullptr) profile->text_tokenize_ms += ggml_time_ms() - tokenize_begin;
     if (tokens.empty()) {
         return set_minimax_error(error, "MiniMax-H3 prompt tokenization produced no tokens");
     }
+    std::vector<int32_t> tags(tokens.size(), 1);
+    for (const auto& [index, image_embed] : image_embeds) {
+        const int64_t begin = std::max<int64_t>(0, index - 1);
+        const 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);
+    }
+    if (h3_trace_enabled()) {
+        const auto zero_tags = std::count(tags.begin(), tags.end(), 0);
+        std::ostringstream summary;
+        summary << "MiniMax-H3 presentation: tokens=" << tokens.size()
+                << " video-tags=" << zero_tags
+                << " text-tags=" << tags.size() - static_cast<size_t>(zero_tags)
+                << " head=";
+        for (size_t index = 0; index < std::min<size_t>(tokens.size(), 16); ++index) {
+            if (index > 0) summary << ',';
+            summary << tokens[index];
+        }
+        summary << " tail=";
+        const size_t tail_begin = tokens.size() > 16 ? tokens.size() - 16 : 0;
+        for (size_t index = tail_begin; index < tokens.size(); ++index) {
+            if (index > tail_begin) summary << ',';
+            summary << tokens[index];
+        }
+        LOG_INFO("%s", summary.str().c_str());
+    }
     sd::Tensor<int32_t> ids({static_cast<int64_t>(tokens.size())}, tokens);
     const int64_t text_encode_begin = profile != nullptr ? ggml_time_ms() : 0;
-    *context = conditioner_->model.compute(runtime_->n_threads(), ids, {}, image_embeds, {50}, image_embed_infos, "", deepstack_image_embeds);
+    *context = conditioner_->model.compute(runtime_->n_threads(), ids, {}, image_embeds, {50}, image_embed_infos, h3_text_debug_target(), deepstack_image_embeds);
     if (profile != nullptr) profile->text_encode_ms += ggml_time_ms() - text_encode_begin;
     if (context->empty()) {
         return set_minimax_error(error, "MiniMax-H3 text encoder compute failed");
     }
-    std::vector<int32_t> tags(static_cast<size_t>(context->shape()[1]), 1);
-    for (const auto& range : vision_token_ranges) {
-        const int64_t begin = std::max<int64_t>(0, static_cast<int64_t>(range.first) - 1);
-        const int64_t end = std::min<int64_t>(static_cast<int64_t>(tags.size()), static_cast<int64_t>(range.first) + range.second + 1);
-        std::fill(tags.begin() + begin, tags.begin() + end, 0);
+    if (static_cast<int64_t>(tags.size()) != context->shape()[1]) {
+        return set_minimax_error(error, "MiniMax-H3 presentation tags do not match conditioner output");
     }
     const int64_t tag_count = static_cast<int64_t>(tags.size());
     *token_tags = sd::Tensor<int32_t>({tag_count}, std::move(tags));
@@ -921,6 +1042,10 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
         set_minimax_error(error, "MiniMax-H3 Ref2VA reference arrays are invalid");
         return ED_STATUS_INVALID_ARGUMENT;
     }
+    if (params->ref_audio_count > 0 && params->ref_image_count == 0 && params->ref_video_count == 0) {
+        set_minimax_error(error, "MiniMax-H3 Ref2VA audio references must be paired with at least one image or video reference");
+        return ED_STATUS_INVALID_ARGUMENT;
+    }
     const int64_t resolved_seed = h3_resolve_seed(params->seed);
     sd::Tensor<float> context;
     sd::Tensor<int32_t> token_tags;
@@ -941,6 +1066,10 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
                             profile_ptr,
                             error)) return ED_STATUS_GENERATION_FAILED;
     if (profile_ptr != nullptr) profile.cond_context_ms = ggml_time_ms() - cond_context_begin;
+    if (!h3_text_debug_target().empty()) {
+        set_minimax_error(error, "MiniMax-H3 text debug target completed");
+        return ED_STATUS_GENERATION_FAILED;
+    }
     const float cfg_scale = params->sample.cfg_scale;
     const bool use_cfg = cfg_scale != 1.0f;
     sd::Tensor<float> uncond_context;
@@ -992,7 +1121,7 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
             return set_minimax_error(error, "MiniMax-H3 keyframe VAE encode failed");
         }
         sd::Tensor<float> latent = vae_->vae_to_diffusion_latents(vae_latent);
-        h3_apply_condition_noise(&latent, request_rng);
+        h3_apply_condition_noise(&latent, static_cast<uint64_t>(resolved_seed));
         h3_trace_tensor((std::string(name) + "_keyframe_latent").c_str(), latent);
         keyframe_latents.push_back(std::move(latent));
         keyframe_indices.push_back(frame_index);
@@ -1033,11 +1162,17 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
     };
     for (int reference_index = 0; reference_index < params->ref_image_count; ++reference_index) {
         const ed_image_t& source_image = params->ref_images[reference_index];
-        const double source_area = static_cast<double>(source_image.width) * source_image.height;
-        const double target_area = static_cast<double>(params->width) * params->height;
-        const double scale = std::min(1.0, std::sqrt(target_area / source_area));
-        const int reference_width = std::max(32, static_cast<int>(std::round(source_image.width * scale / 32.0)) * 32);
-        const int reference_height = std::max(32, static_cast<int>(std::round(source_image.height * scale / 32.0)) * 32);
+        if (source_image.width <= 0 || source_image.height <= 0) {
+            set_minimax_error(error, "MiniMax-H3 Ref2VA image reference is invalid");
+            return ED_STATUS_INVALID_ARGUMENT;
+        }
+        int reference_width = 0;
+        int reference_height = 0;
+        h3_reference_image_dimensions_for_canvas(source_image,
+                                                params->width,
+                                                params->height,
+                                                &reference_width,
+                                                &reference_height);
         sd::Tensor<float> image_tensor = h3_image_to_tensor(source_image, reference_width, reference_height);
         if (image_tensor.empty()) {
             set_minimax_error(error, "MiniMax-H3 Ref2VA image reference is invalid");
@@ -1055,7 +1190,7 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
             return ED_STATUS_GENERATION_FAILED;
         }
         sd::Tensor<float> latent = vae_->vae_to_diffusion_latents(vae_latent);
-        h3_apply_condition_noise(&latent, request_rng);
+        h3_apply_condition_noise(&latent, static_cast<uint64_t>(resolved_seed));
         h3_trace_tensor(("ref_image_" + std::to_string(reference_index) + "_latent").c_str(), latent);
         const int32_t encoded_image_index = static_cast<int32_t>(reference_latents.size());
         reference_latents.push_back(std::move(latent));
@@ -1078,6 +1213,15 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
         int reference_width = 0;
         int reference_height = 0;
         h3_reference_video_dimensions(reference.frames[0], &reference_width, &reference_height);
+        if (h3_trace_enabled()) {
+            LOG_INFO("MiniMax-H3 Ref2VA video %d VAE geometry: source=%dx%d normalized=%dx%d frames=%d",
+                     video_index + 1,
+                     reference.frames[0].width,
+                     reference.frames[0].height,
+                     reference_width,
+                     reference_height,
+                     normalized_frames);
+        }
         sd::Tensor<float> video_reference({reference_width, reference_height, normalized_frames, 3, 1});
         for (int frame = 0; frame < normalized_frames; ++frame) {
             const int source_index = std::min(reference.frame_count - 1, static_cast<int>(std::floor(frame * source_fps / 24.0)));
@@ -1103,7 +1247,8 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
             set_minimax_error(error, "MiniMax-H3 Ref2VA video audio encode failed"); return ED_STATUS_GENERATION_FAILED;
         }
         auto latent = vae_->vae_to_diffusion_latents(vae_latent);
-        h3_apply_condition_noise(&latent, request_rng);
+        h3_apply_condition_noise(&latent, static_cast<uint64_t>(resolved_seed));
+        h3_trace_tensor(("ref_video_" + std::to_string(video_index) + "_latent").c_str(), latent);
         const int32_t encoded_video_index = static_cast<int32_t>(reference_latents.size());
         reference_latents.push_back(std::move(latent));
         reference_blocks.push_back({audio_index >= 0 ? MiniMaxH3ReferenceKind::VIDEO_AUDIO : MiniMaxH3ReferenceKind::VIDEO, encoded_video_index, audio_index});
@@ -1116,6 +1261,10 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
         }
         reference_blocks.push_back({MiniMaxH3ReferenceKind::AUDIO, -1, encoded_index});
     }
+    if (h3_condition_debug_exit_enabled()) {
+        set_minimax_error(error, "MiniMax-H3 conditioning debug completed");
+        return ED_STATUS_GENERATION_FAILED;
+    }
     sd::Tensor<float> video = sd::zeros<float>({latent_width, latent_height, latent_frames, 24, 1});
     sd::Tensor<float> audio = sd::zeros<float>({audio_length, 2, 32, 1});
     const int64_t noise_begin = profile_ptr != nullptr ? ggml_time_ms() : 0;
@@ -1124,12 +1273,37 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
     sd::Tensor<float> packed = h3_pack_audio_and_video_latents(video, audio);
     if (profile_ptr != nullptr) profile.noise_init_ms = ggml_time_ms() - noise_begin;
     h3_trace_tensor("initial_packed_noise", packed);
+    if (h3_trace_enabled()) {
+        auto reference_kind_name = [](MiniMaxH3ReferenceKind kind) {
+            switch (kind) {
+                case MiniMaxH3ReferenceKind::IMAGE: return "image";
+                case MiniMaxH3ReferenceKind::VIDEO: return "video";
+                case MiniMaxH3ReferenceKind::VIDEO_AUDIO: return "video_audio";
+                case MiniMaxH3ReferenceKind::AUDIO: return "audio";
+            }
+            return "unknown";
+        };
+        std::ostringstream blocks;
+        for (size_t index = 0; index < reference_blocks.size(); ++index) {
+            const auto& block = reference_blocks[index];
+            if (index > 0) {
+                blocks << ";";
+            }
+            blocks << index << ":" << reference_kind_name(block.kind)
+                   << "(v=" << block.video_index
+                   << ",a=" << block.audio_index << ")";
+        }
+        LOG_INFO("minimax-h3 trace reference summary: video_latents=%zu audio_latents=%zu blocks=%zu [%s]",
+                 reference_latents.size(),
+                 reference_audio_latents.size(),
+                 reference_blocks.size(),
+                 blocks.str().c_str());
+    }
     const int steps = params->sample.steps > 0 ? params->sample.steps : 20;
     const float video_sigma_shift = params->sample.flow_shift > 0.0f ? params->sample.flow_shift : 12.0f;
-    // MiniMax-H3's official scheduler treats `steps` as the number of sigma grid
-    // points, including the terminal clean point at sigma=0. The terminal point
-    // has no model evaluation, so `steps=20` runs 19 DiT forwards.
-    for (int step = 0; step + 1 < steps; ++step) {
+    // Match stable-diffusion.cpp's DiscreteScheduler + FluxFlowDenoiser: `steps`
+    // model evaluations plus a terminal sigma=0 point.
+    for (int step = 0; step < steps; ++step) {
         if (profile_ptr != nullptr) ++profile.diffusion_steps;
         const float sigma = h3_discrete_flow_sigma(step, steps, video_sigma_shift);
         const float sigma_next = h3_discrete_flow_sigma(step + 1, steps, video_sigma_shift);
@@ -1162,6 +1336,13 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
             set_minimax_error(error, "MiniMax-H3 diffusion compute failed");
             return ED_STATUS_GENERATION_FAILED;
         }
+        if (!h3_dit_debug_target().empty()) {
+            const std::string debug_name = "dit_" + h3_dit_debug_target();
+            h3_trace_tensor(debug_name.c_str(), velocity);
+            h3_dump_debug_tensor_if_requested(debug_name, velocity);
+            set_minimax_error(error, "MiniMax-H3 DiT debug target completed");
+            return ED_STATUS_GENERATION_FAILED;
+        }
         if (use_cfg) {
             diffusion_params.context = &uncond_context;
             diffusion_params.minimax_text_token_tags = &uncond_token_tags;
diff --git a/src/utils/name_conversion.cpp b/src/utils/name_conversion.cpp
index 21713a4..0de38e0 100644
--- a/src/utils/name_conversion.cpp
+++ b/src/utils/name_conversion.cpp
@@ -1315,6 +1315,18 @@ std::string convert_tensor_name(std::string name, SDVersion version) {
     replace_with_prefix_map(name, prefix_map);
 
     if (ed_version_is_minimax_h3(version)) {
+        const std::string raw_language_prefix = "model.language_model.";
+        if (starts_with(name, raw_language_prefix)) {
+            name = "text_encoders.llm.model." + name.substr(raw_language_prefix.size());
+        }
+        const std::string hf_language_prefix = "text_encoders.llm.model.language_model.";
+        if (starts_with(name, hf_language_prefix)) {
+            name = "text_encoders.llm.model." + name.substr(hf_language_prefix.size());
+        }
+        const std::string raw_vision_prefix = "model.visual.";
+        if (starts_with(name, raw_vision_prefix)) {
+            name = "text_encoders.llm.visual." + name.substr(raw_vision_prefix.size());
+        }
         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());

From ec063f293743974de57b9a48fe59deef6e2ae595 Mon Sep 17 00:00:00 2001
From: Komorebi623 <wang-ty22@mails.tsinghua.edu.cn>
Date: Tue, 11 Aug 2026 15:59:48 +0800
Subject: [PATCH 18/25] Support media files as MiniMax H3 Ref2VA videos

Allow ed-cli --ref-video to accept either an existing frame directory or a media file such as mp4, mov, mkv, webm, or avi.

Decode media references through ffmpeg into temporary PNG frames and cap extracted frames to the requested generation frame count to avoid expanding long videos unnecessarily.

When a media reference carries embedded audio, extract it to 32 kHz stereo WAV and bind it to the same ed_ref_video_t unless an explicit --ref-video-audio is supplied for that video index.

Document the updated Ref2VA CLI reference flags in --help while preserving the existing repeatable image, video, paired-audio, and standalone-audio behavior.

Validation: rebuilt ed-cli in build-cuda-refvideo-align-20260810; smoke-tested MP4 reference input with embedded audio and without audio on CUDA; compared prompt-only temporal reversal against diffusers with matching seed, size, frames, and steps.
---
 examples/cli/main.cpp | 154 ++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 150 insertions(+), 4 deletions(-)

diff --git a/examples/cli/main.cpp b/examples/cli/main.cpp
index af23a8a..c5e1048 100644
--- a/examples/cli/main.cpp
+++ b/examples/cli/main.cpp
@@ -11,6 +11,7 @@
 #include <cstring>
 #include <filesystem>
 #include <limits>
+#include <random>
 #include <algorithm>
 #include <string>
 #include <vector>
@@ -103,6 +104,11 @@ static void print_usage(const char* prog) {
         "  -H, --height <int>        Image height, default: 1024\n"
         "  --frames, --video-frames <int>  Video frame count, default: 1\n"
         "  --fps <int>               Video fps, default: 16\n"
+        "  --ref-image <path>        MiniMax-H3 Ref2VA reference image; repeatable\n"
+        "  --ref-video <path>        MiniMax-H3 Ref2VA reference video frames directory or media file; repeatable\n"
+        "                            Media files are decoded with ffmpeg; embedded audio is paired automatically\n"
+        "  --ref-video-audio <path>  WAV soundtrack paired with the corresponding --ref-video\n"
+        "  --ref-audio <path>        Standalone MiniMax-H3 Ref2VA WAV audio reference; repeatable\n"
         "  --steps <int>             Sampling steps, default: 20\n"
         "  -s, --seed <int64>        Seed, default: -1\n"
         "  -t, --threads <int>       Thread count, default: 0\n"
@@ -275,6 +281,138 @@ static std::string find_ffmpeg_binary() {
     return "ffmpeg";
 }
 
+struct TemporaryDirectory {
+    fs::path path;
+    bool keep = false;
+
+    TemporaryDirectory() = default;
+    TemporaryDirectory(const TemporaryDirectory&) = delete;
+    TemporaryDirectory& operator=(const TemporaryDirectory&) = delete;
+    TemporaryDirectory(TemporaryDirectory&& other) noexcept : path(std::move(other.path)), keep(other.keep) {
+        other.keep = true;
+    }
+    TemporaryDirectory& operator=(TemporaryDirectory&& other) noexcept {
+        if (this != &other) {
+            if (!keep && !path.empty()) {
+                std::error_code error;
+                fs::remove_all(path, error);
+            }
+            path = std::move(other.path);
+            keep = other.keep;
+            other.keep = true;
+        }
+        return *this;
+    }
+
+    ~TemporaryDirectory() {
+        if (!keep && !path.empty()) {
+            std::error_code error;
+            fs::remove_all(path, error);
+        }
+    }
+};
+
+static bool make_temporary_directory(const std::string& prefix, TemporaryDirectory* directory) {
+    if (directory == nullptr) {
+        return false;
+    }
+    const fs::path base = fs::temp_directory_path();
+    std::random_device random;
+    for (int attempt = 0; attempt < 64; ++attempt) {
+        const fs::path candidate = base / (prefix + std::to_string(static_cast<uint64_t>(random())) + "-" + std::to_string(attempt));
+        std::error_code error;
+        if (fs::create_directory(candidate, error)) {
+            directory->path = candidate;
+            return true;
+        }
+    }
+    return false;
+}
+
+static bool extract_reference_video_frames(const std::string& path, const fs::path& frames_dir, int fps, int max_frames) {
+    if (fps <= 0) {
+        fps = 24;
+    }
+    const std::string pattern = (frames_dir / "frame_%06d.png").string();
+    std::string command = shell_quote(find_ffmpeg_binary().c_str()) +
+                          " -hide_banner -loglevel error -y -i " + shell_quote(path.c_str()) +
+                          " -map 0:v:0 -an -vf " + shell_quote(("fps=" + std::to_string(fps)).c_str());
+    if (max_frames > 0) {
+        command += " -frames:v " + std::to_string(max_frames);
+    }
+    command += " " + shell_quote(pattern.c_str());
+    const int status = std::system(command.c_str());
+    if (status != 0) {
+        std::fprintf(stderr, "ffmpeg failed while extracting reference video frames from '%s', status=%d\n", path.c_str(), status);
+        return false;
+    }
+    return true;
+}
+
+static bool extract_reference_video_audio(const std::string& path, const fs::path& wav_path) {
+    const std::string command = shell_quote(find_ffmpeg_binary().c_str()) +
+                                " -hide_banner -loglevel quiet -y -i " + shell_quote(path.c_str()) +
+                                " -map 0:a:0? -vn -ac 2 -ar 32000 -c:a pcm_s16le " + shell_quote(wav_path.c_str());
+    const int status = std::system(command.c_str());
+    if (status != 0) {
+        return false;
+    }
+    std::error_code error;
+    return fs::is_regular_file(wav_path, error) && fs::file_size(wav_path, error) > 0;
+}
+
+static bool load_reference_video(const std::string& path,
+                                 int fps,
+                                 int max_frames,
+                                 std::vector<TemporaryDirectory>* temporary_directories,
+                                 std::vector<ed_image_t>* frames,
+                                 std::vector<float>* audio_samples,
+                                 ed_ref_video_t* reference,
+                                 bool explicit_audio_supplied) {
+    if (frames == nullptr || audio_samples == nullptr || reference == nullptr) {
+        return false;
+    }
+    if (fs::is_directory(path)) {
+        if (!load_images_from_dir(path, frames)) {
+            return false;
+        }
+        reference->frames = frames->data();
+        reference->frame_count = static_cast<int>(frames->size());
+        reference->fps = fps > 0 ? fps : 24;
+        return true;
+    }
+
+    const std::string ext = path_extension(path);
+    if (!is_supported_video_ext(ext)) {
+        return false;
+    }
+    temporary_directories->emplace_back();
+    TemporaryDirectory& directory = temporary_directories->back();
+    if (!make_temporary_directory("ed-ref-video-", &directory)) {
+        std::fprintf(stderr, "failed to create temporary directory for reference video '%s'\n", path.c_str());
+        return false;
+    }
+    const fs::path frames_dir = directory.path / "frames";
+    std::error_code error;
+    fs::create_directory(frames_dir, error);
+    if (error || !extract_reference_video_frames(path, frames_dir, fps, max_frames) || !load_images_from_dir(frames_dir.string(), frames)) {
+        return false;
+    }
+    reference->frames = frames->data();
+    reference->frame_count = static_cast<int>(frames->size());
+    reference->fps = fps > 0 ? fps : 24;
+    if (!explicit_audio_supplied) {
+        const fs::path wav_path = directory.path / "audio.wav";
+        if (extract_reference_video_audio(path, wav_path)) {
+            if (!load_wav(wav_path.string(), audio_samples, &reference->audio)) {
+                std::fprintf(stderr, "failed to load extracted reference video audio from '%s'\n", wav_path.c_str());
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
 static bool write_rgb_frame(FILE* pipe, const ed_image_t& image, std::vector<uint8_t>* scratch) {
     if (pipe == nullptr || image.data == nullptr || scratch == nullptr) {
         return false;
@@ -822,6 +960,7 @@ int main(int argc, char** argv) {
         std::vector<std::vector<ed_image_t>> ref_video_frames(args.ref_video_paths.size());
         std::vector<std::vector<float>> ref_video_audio_samples(args.ref_video_paths.size());
         std::vector<ed_ref_video_t> ref_videos(args.ref_video_paths.size());
+        std::vector<TemporaryDirectory> ref_video_temp_directories;
         std::vector<std::vector<float>> ref_audio_samples(args.ref_audio_paths.size());
         std::vector<ed_audio_t> ref_audios(args.ref_audio_paths.size());
         auto free_video_references = [&]() {
@@ -884,14 +1023,21 @@ int main(int argc, char** argv) {
         }
         if (!ref_audios.empty()) { gen_params.ref_audios = ref_audios.data(); gen_params.ref_audio_count = static_cast<int>(ref_audios.size()); }
         for (size_t index = 0; index < args.ref_video_paths.size(); ++index) {
-            if (!load_images_from_dir(args.ref_video_paths[index], &ref_video_frames[index])) {
-                std::fprintf(stderr, "failed to load reference video frames from '%s'\n", args.ref_video_paths[index].c_str());
+            const bool explicit_audio_supplied = index < args.ref_video_audio_paths.size();
+            if (!load_reference_video(args.ref_video_paths[index],
+                                      output_fps,
+                                      args.frames,
+                                      &ref_video_temp_directories,
+                                      &ref_video_frames[index],
+                                      &ref_video_audio_samples[index],
+                                      &ref_videos[index],
+                                      explicit_audio_supplied)) {
+                std::fprintf(stderr, "failed to load reference video from '%s'\n", args.ref_video_paths[index].c_str());
                 for (ed_image_t& image : ref_images) ed_free_image(&image);
                 free_video_references();
                 ed_free_image(&init_image); ed_free_image(&end_image); ed_free_context(ctx); return 6;
             }
-            ref_videos[index].frames = ref_video_frames[index].data(); ref_videos[index].frame_count = static_cast<int>(ref_video_frames[index].size()); ref_videos[index].fps = 24;
-            if (index < args.ref_video_audio_paths.size() && !load_wav(args.ref_video_audio_paths[index], &ref_video_audio_samples[index], &ref_videos[index].audio)) {
+            if (explicit_audio_supplied && !load_wav(args.ref_video_audio_paths[index], &ref_video_audio_samples[index], &ref_videos[index].audio)) {
                 std::fprintf(stderr, "failed to load reference video WAV '%s'\n", args.ref_video_audio_paths[index].c_str());
                 for (ed_image_t& image : ref_images) ed_free_image(&image);
                 free_video_references();

From 0f70722dd76e29efb8f388245b30c1afc7a6463e Mon Sep 17 00:00:00 2001
From: Komorebi623 <wang-ty22@mails.tsinghua.edu.cn>
Date: Wed, 12 Aug 2026 00:25:06 +0800
Subject: [PATCH 19/25] Update ggml for validated MiniMax H3 SM90 routing

Advance the ggml submodule to b8a5ef0c. The update enables the validated Hopper Q4_K cuBLAS and F32 QKV/FC1 paths by default with explicit opt-outs, and adds a configurable long-sequence threshold that retains 16000 as the default.
---
 third_party/ggml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/third_party/ggml b/third_party/ggml
index 3834c4d..b8a5ef0 160000
--- a/third_party/ggml
+++ b/third_party/ggml
@@ -1 +1 @@
-Subproject commit 3834c4d669c06bfcdd4608fe5e91a8ce4e5a7aa0
+Subproject commit b8a5ef0c84eb6c1d942f9db2612ce86ee68b76a7

From 03851262187a5abdce7943f17a0543481372ba91 Mon Sep 17 00:00:00 2001
From: yiming-l21 <liuyiming54@jd.com>
Date: Wed, 12 Aug 2026 14:34:49 +0800
Subject: [PATCH 20/25] chore: bump ggml submodule

---
 third_party/ggml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/third_party/ggml b/third_party/ggml
index 019f9bb..e621959 160000
--- a/third_party/ggml
+++ b/third_party/ggml
@@ -1 +1 @@
-Subproject commit 019f9bbfa10054def9e3b5d84f55b39f9ce0caa5
+Subproject commit e621959f6baea1670d407f801c62a8cde253c9a7

From 2d8c93d7882fd5824468f35f02fbc12cd2679e8e Mon Sep 17 00:00:00 2001
From: Komorebi623 <wang-ty22@mails.tsinghua.edu.cn>
Date: Thu, 13 Aug 2026 14:41:39 +0800
Subject: [PATCH 21/25] Support MiniMax-H3 Diffusers Q8 paths and retain
 benchmarks

Infer MiniMax-H3 for standalone and sharded safetensors, normalize Diffusers SwiGLU projection layout before quantization, and synthesize omitted RoPE frequencies at load time.

Teach offline conversion to apply the transformer diffusion prefix, add the validated Diffusers benchmark runners, and preserve the Q4 Edge-vs-Diffusers and H200 8-bit Edge-vs-sd.cpp benchmark reports. The reports retain exact prompts, inputs, stage timings, VRAM peaks, and artifact links.
---
 .gitignore                                    |   1 +
 ...2va-edge-diffusers-benchmark-2026-08-11.md | 226 ++++++++++++++++++
 ...-ref2va-edge-sdcpp-h200-8bit-2026-08-12.md | 155 ++++++++++++
 ...run_minimax_h3_fl2va_optional_quantized.py | 195 +++++++++++++++
 ...imax_h3_ref2va_quantized_official_video.py | 140 +++++++++++
 src/core/runtime/model_loader.cpp             |  37 ++-
 .../pipelines/minimax_h3_pipeline.cpp         |  15 ++
 src/utils/model_io/convert.cpp                |  11 +-
 src/utils/model_io/tensor_storage.h           |   1 +
 9 files changed, 779 insertions(+), 2 deletions(-)
 create mode 100644 docs/optimization/minimax-h3-fl2va-ref2va-edge-diffusers-benchmark-2026-08-11.md
 create mode 100644 docs/optimization/minimax-h3-fl2va-ref2va-edge-sdcpp-h200-8bit-2026-08-12.md
 create mode 100755 scripts/diffusers/run_minimax_h3_fl2va_optional_quantized.py
 create mode 100755 scripts/diffusers/run_minimax_h3_ref2va_quantized_official_video.py

diff --git a/.gitignore b/.gitignore
index 9883f9c..119df3d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -22,6 +22,7 @@ CLAUDE.md
 # local benchmark outputs
 /test_outputs/
 /.wty_results/
+/assets/minimax-h3-ref2va/
 
 # local-only CPU profiling / benchmark tooling (not for commit)
 /scripts/run_image_cmp.sh
diff --git a/docs/optimization/minimax-h3-fl2va-ref2va-edge-diffusers-benchmark-2026-08-11.md b/docs/optimization/minimax-h3-fl2va-ref2va-edge-diffusers-benchmark-2026-08-11.md
new file mode 100644
index 0000000..204a400
--- /dev/null
+++ b/docs/optimization/minimax-h3-fl2va-ref2va-edge-diffusers-benchmark-2026-08-11.md
@@ -0,0 +1,226 @@
+# MiniMax-H3 FL2VA/Ref2VA Edge vs Diffusers CUDA Benchmark（2026-08-11）
+
+## 结论
+
+- 本轮 16 个任务全部完成，`returncode=0`；最终汇总来自 [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/summary.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/summary.json)。
+- Ref2VA 的 `mp4-video` 与 `mixed` 已使用纯正向强约束 prompt、逐帧无损 MP4 和显式原始配对 WAV，在 Edge 与 Diffusers 中重新运行并覆盖原目录。Edge 日志见 [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/edge_mp4_clean_prompt_rerun_2.log`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/edge_mp4_clean_prompt_rerun_2.log)，Diffusers 日志见 [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/diffusers_mp4_clean_prompt_rerun_2.log`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/diffusers_mp4_clean_prompt_rerun_2.log)。
+- Conditioning trace 证明帧目录与无损 MP4 的 `ref_video_0_latent` 哈希一致；旧结果偏离来自否定 prompt 列举无关对象，而非 MP4 解码链路。
+- 已逐项核对 `metrics.json` 与 `cmd.txt`：当前同一任务下 Edge 与 Diffusers 的 prompt 完全相同，语义参考输入完全相同；FL2VA 尾帧参数名不同但路径一致。
+- 全程最大显存峰值为 `79,021 MiB`，来自 `diffusers` 的 `ref2va-mixed`。
+
+## 固定口径
+
+| 项目 | 口径 |
+|---|---|
+| Edge binary | [`build-cuda-refvideo-align-20260810/bin/ed-cli`](../../build-cuda-refvideo-align-20260810/bin/ed-cli) |
+| Diffusers Ref2VA runner | [`scripts/diffusers/run_minimax_h3_ref2va_quantized_official_video.py`](../../scripts/diffusers/run_minimax_h3_ref2va_quantized_official_video.py) |
+| Diffusers FL2VA runner | [`scripts/diffusers/run_minimax_h3_fl2va_optional_quantized.py`](../../scripts/diffusers/run_minimax_h3_fl2va_optional_quantized.py) |
+| FL2VA DiT | `/models/MiniMax-H3-GGUF/minimax_h3_fl2va-Q4_K_M.gguf` |
+| Ref2VA DiT | `/models/MiniMax-H3-GGUF/minimax_h3_ref2va_pruned-Q4_K_M.gguf` |
+| Shared Qwen3-VL | `/models/MiniMax-H3-GGUF/qwen3vl_32b_minimax_h3-Q4_K_M.gguf` |
+| Shared Video VAE | `/models/MiniMax-H3-GGUF/minimax_h3_video_vae_fp16.safetensors` |
+| Shared Audio VAE | `/models/MiniMax-H3-GGUF/minimax_h3_audio_vae_fp32.safetensors` |
+| CUDA 参数 | `864x480`、`124 frames`、`24 fps`、`20 steps`、`seed 424242`、resident/no offload、串行执行 |
+| Ref2VA 无损 MP4 | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4)，逐帧解码相对原 PNG `PSNR=∞` |
+
+## 逐任务口径核对
+
+| 任务 | Prompt 是否一致 | 参考输入是否一致 | Prompt 口径 | Edge 参考 | Diffusers 参考 |
+|---|---:|---:|---|---|---|
+| 文生视频 | 是 | 是 | 强描述 prompt，无参考输入 | 无参考输入 | 无参考输入 |
+| 首帧生视频 | 是 | 是 | 强参考 prompt，显式要求遵循参考并排除无关主体 | 首帧/图片: [`outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png) | 首帧/图片: [`outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png) |
+| 尾帧生视频 | 是 | 是 | 强参考 prompt，显式要求遵循参考并排除无关主体 | 尾帧: [`outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png) | 尾帧: [`outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png) |
+| 首尾帧生视频 | 是 | 是 | 强参考 prompt，显式要求遵循参考并排除无关主体 | 首帧/图片: [`outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png)<br>尾帧: [`outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png) | 首帧/图片: [`outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png)<br>尾帧: [`outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png) |
+| 图片参考 | 是 | 是 | 强参考 prompt，显式要求遵循参考并排除无关主体 | 参考图片: [`assets/minimax-h3-ref2va/images/landscape-reference.png`](../../assets/minimax-h3-ref2va/images/landscape-reference.png) | 参考图片: [`assets/minimax-h3-ref2va/images/landscape-reference.png`](../../assets/minimax-h3-ref2va/images/landscape-reference.png) |
+| 视频 MP4 参考 | 是 | 是 | 更强参考 prompt，要求严格复制参考视频场景并禁止发散 | 参考视频: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4)<br>视频配对音频: [`assets/minimax-h3-ref2va/video-audio.wav`](../../assets/minimax-h3-ref2va/video-audio.wav) | 参考视频: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4)<br>视频配对音频: [`assets/minimax-h3-ref2va/video-audio.wav`](../../assets/minimax-h3-ref2va/video-audio.wav) |
+| 帧序列+音频参考 | 是 | 是 | 更强参考 prompt，要求严格复制参考视频场景并禁止发散 | 参考视频: [`assets/minimax-h3-ref2va/video-frames`](../../assets/minimax-h3-ref2va/video-frames)<br>视频配对音频: [`assets/minimax-h3-ref2va/video-audio.wav`](../../assets/minimax-h3-ref2va/video-audio.wav) | 参考视频: [`assets/minimax-h3-ref2va/video-frames`](../../assets/minimax-h3-ref2va/video-frames)<br>视频配对音频: [`assets/minimax-h3-ref2va/video-audio.wav`](../../assets/minimax-h3-ref2va/video-audio.wav) |
+| 混合参考 | 是 | 是 | 更强 mixed prompt，要求 0-2s 视频场景、2-3s 自然过渡、3-5s 图片场景 | 参考图片: [`assets/minimax-h3-ref2va/images/landscape-reference.png`](../../assets/minimax-h3-ref2va/images/landscape-reference.png)<br>参考视频: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4)<br>视频配对音频: [`assets/minimax-h3-ref2va/video-audio.wav`](../../assets/minimax-h3-ref2va/video-audio.wav)<br>独立音频: [`assets/minimax-h3-ref2va/standalone-audio.wav`](../../assets/minimax-h3-ref2va/standalone-audio.wav) | 参考图片: [`assets/minimax-h3-ref2va/images/landscape-reference.png`](../../assets/minimax-h3-ref2va/images/landscape-reference.png)<br>参考视频: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4)<br>视频配对音频: [`assets/minimax-h3-ref2va/video-audio.wav`](../../assets/minimax-h3-ref2va/video-audio.wav)<br>独立音频: [`assets/minimax-h3-ref2va/standalone-audio.wav`](../../assets/minimax-h3-ref2va/standalone-audio.wav) |
+
+## 输入汇总
+
+| 任务 | 输入 |
+|---|---|
+| 文生视频 | `text only` |
+| 首帧生视频 | [`outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png) |
+| 尾帧生视频 | [`outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png) |
+| 首尾帧生视频 | [`outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png) + [`outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png) |
+| 图片参考 | [`assets/minimax-h3-ref2va/images/landscape-reference.png`](../../assets/minimax-h3-ref2va/images/landscape-reference.png) |
+| 视频 MP4 参考 | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4) + [`assets/minimax-h3-ref2va/video-audio.wav`](../../assets/minimax-h3-ref2va/video-audio.wav) |
+| 帧序列+音频参考 | [`assets/minimax-h3-ref2va/video-frames`](../../assets/minimax-h3-ref2va/video-frames) + [`assets/minimax-h3-ref2va/video-audio.wav`](../../assets/minimax-h3-ref2va/video-audio.wav) |
+| 混合参考 | [`assets/minimax-h3-ref2va/images/landscape-reference.png`](../../assets/minimax-h3-ref2va/images/landscape-reference.png) + [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4) + [`assets/minimax-h3-ref2va/video-audio.wav`](../../assets/minimax-h3-ref2va/video-audio.wav) + [`assets/minimax-h3-ref2va/standalone-audio.wav`](../../assets/minimax-h3-ref2va/standalone-audio.wav) |
+
+## FL2VA Checkpoint 对比
+
+| 任务 | Edge 输出 | Diffusers 输出 | Edge wall | Diffusers wall | Edge 加速 | Edge 显存 | Diffusers 显存 | Edge 阶段耗时 | Diffusers 阶段耗时 |
+|---|---|---|---:|---:|---:|---:|---:|---|---|
+| 文生视频 | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/final.mp4) | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/final.mp4) | 108.1s | 104.4s | 0.97x | 47,239 MiB | 56,803 MiB | load 7.5s / cond 0.1s / DiT 92.3s / decode 5.3s / save 1.3s | init+quant 39.2s / cond 0.3s / DiT 49.3s / decode 4.0s / save 0.7s |
+| 首帧生视频 | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/final.mp4) | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/final.mp4) | 73.1s | 110.2s | 1.51x | 47,609 MiB | 56,599 MiB | load 6.5s / cond 0.9s / DiT 57.6s / decode 4.6s / save 1.2s | init+quant 40.9s / cond 0.7s / DiT 53.1s / decode 3.9s / save 0.6s |
+| 尾帧生视频 | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/final.mp4) | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/final.mp4) | 73.0s | 108.3s | 1.48x | 47,607 MiB | 56,599 MiB | load 6.7s / cond 0.9s / DiT 57.5s / decode 4.5s / save 1.4s | init+quant 38.9s / cond 0.7s / DiT 53.1s / decode 3.9s / save 0.7s |
+| 首尾帧生视频 | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/final.mp4) | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/final.mp4) | 76.7s | 114.1s | 1.49x | 47,785 MiB | 57,331 MiB | load 6.3s / cond 1.6s / DiT 60.9s / decode 4.5s / save 1.3s | init+quant 40.3s / cond 0.8s / DiT 56.7s / decode 3.9s / save 0.7s |
+
+## Ref2VA Checkpoint 对比
+
+| 任务 | Edge 输出 | Diffusers 输出 | Edge wall | Diffusers wall | Edge 加速 | Edge 显存 | Diffusers 显存 | Edge 阶段耗时 | Diffusers 阶段耗时 |
+|---|---|---|---:|---:|---:|---:|---:|---|---|
+| 图片参考 | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/final.mp4) | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/final.mp4) | 71.8s | 189.8s | 2.64x | 40,655 MiB | 66,399 MiB | load 6.0s / cond 0.9s / DiT 57.0s / decode 4.7s / save 1.2s | init+quant 39.9s / cond 1.6s / DiT 131.4s / decode 3.9s / save 0.6s |
+| 视频 MP4 参考 | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/final.mp4) | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/final.mp4) | 136.2s | 242.5s | 1.78x | 46,037 MiB | 64,327 MiB | load 6.2s / cond 23.6s / DiT 93.5s / decode 4.7s / save 2.0s | init+quant 40.1s / cond 7.1s / DiT 174.2s / decode 3.9s / save 1.3s |
+| 帧序列+音频参考 | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/final.mp4) | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/final.mp4) | 135.5s | 242.9s | 1.79x | 46,037 MiB | 63,731 MiB | load 6.0s / cond 24.0s / DiT 93.5s / decode 4.6s / save 2.0s | init+quant 41.7s / cond 7.1s / DiT 175.1s / decode 3.9s / save 1.2s |
+| 混合参考 | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/final.mp4) | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/final.mp4) | 144.5s | 377.6s | 2.61x | 46,037 MiB | 79,021 MiB | load 6.3s / cond 24.5s / DiT 101.1s / decode 4.6s / save 1.8s | init+quant 39.8s / cond 8.7s / DiT 306.9s / decode 3.9s / save 0.9s |
+
+## 详细阶段拆分
+
+### FL2VA
+
+| 任务 | 框架 | 加载/量化 | 文本 | 条件总计 | 参考视频/图像 VAE | 参考音频 VAE | DiT | 视频解码 | 音频解码 | 保存/mux | 端到端 | 外部 wall | 显存峰值 |
+|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|
+| 文生视频 | Edge | 7.5s | 0.1s | 0.1s | 0.0s | 0.0s | 92.3s | 4.9s | 0.3s | 1.3s | 106.9s | 108.1s | 47,239 MiB |
+| 文生视频 | Diffusers | 39.2s | 0.3s | - | 0.0s | 0.0s | 49.3s | 3.9s | 0.2s | 0.7s | 95.1s | 104.4s | 56,803 MiB |
+| 首帧生视频 | Edge | 6.5s | 0.2s | 0.9s | 0.4s | 0.0s | 57.6s | 4.4s | 0.2s | 1.2s | 71.3s | 73.1s | 47,609 MiB |
+| 首帧生视频 | Diffusers | 40.9s | 0.5s | - | 0.2s | 0.0s | 53.1s | 3.8s | 0.1s | 0.6s | 100.7s | 110.2s | 56,599 MiB |
+| 尾帧生视频 | Edge | 6.7s | 0.2s | 0.9s | 0.4s | 0.0s | 57.5s | 4.3s | 0.2s | 1.4s | 71.5s | 73.0s | 47,607 MiB |
+| 尾帧生视频 | Diffusers | 38.9s | 0.6s | - | 0.2s | 0.0s | 53.1s | 3.7s | 0.1s | 0.7s | 99.0s | 108.3s | 56,599 MiB |
+| 首尾帧生视频 | Edge | 6.3s | 0.4s | 1.6s | 0.8s | 0.0s | 60.9s | 4.3s | 0.2s | 1.3s | 75.2s | 76.7s | 47,785 MiB |
+| 首尾帧生视频 | Diffusers | 40.3s | 0.6s | - | 0.3s | 0.0s | 56.7s | 3.8s | 0.1s | 0.7s | 104.2s | 114.1s | 57,331 MiB |
+
+### Ref2VA
+
+| 任务 | 框架 | 加载/量化 | 文本 | 条件总计 | 参考视频/图像 VAE | 参考音频 VAE | DiT | 视频解码 | 音频解码 | 保存/mux | 端到端 | 外部 wall | 显存峰值 |
+|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|
+| 图片参考 | Edge | 6.0s | 0.3s | 0.9s | 0.4s | 0.0s | 57.0s | 4.5s | 0.2s | 1.2s | 70.3s | 71.8s | 40,655 MiB |
+| 图片参考 | Diffusers | 39.9s | 0.0s | - | 1.6s | 0.0s | 131.4s | 3.7s | 0.1s | 0.6s | 180.7s | 189.8s | 66,399 MiB |
+| 视频 MP4 参考 | Edge | 6.2s | 0.6s | 23.6s | 22.0s | 0.0s | 93.5s | 4.4s | 0.3s | 2.0s | 133.5s | 136.2s | 46,037 MiB |
+| 视频 MP4 参考 | Diffusers | 40.1s | 0.0s | - | 7.0s | 0.1s | 174.2s | 3.8s | 0.1s | 1.3s | 229.7s | 242.5s | 64,327 MiB |
+| 帧序列+音频参考 | Edge | 6.0s | 0.6s | 24.0s | 22.4s | 0.0s | 93.5s | 4.4s | 0.2s | 2.0s | 133.5s | 135.5s | 46,037 MiB |
+| 帧序列+音频参考 | Diffusers | 41.7s | 0.0s | - | 7.1s | 0.1s | 175.1s | 3.8s | 0.1s | 1.2s | 232.6s | 242.9s | 63,731 MiB |
+| 混合参考 | Edge | 6.3s | 0.9s | 24.5s | 22.5s | 0.0s | 101.1s | 4.3s | 0.2s | 1.8s | 141.9s | 144.5s | 46,037 MiB |
+| 混合参考 | Diffusers | 39.8s | 0.0s | - | 8.6s | 0.1s | 306.9s | 3.7s | 0.1s | 0.9s | 365.2s | 377.6s | 79,021 MiB |
+
+## Prompt
+
+| 任务 | Prompt |
+|---|---|
+| 文生视频 | A cinematic realistic five-second video of a sunset mountain landscape with layered distant ridges, warm golden light, subtle slow camera motion, coherent quiet natural ambient audio, high detail, no unrelated subjects. |
+| 首帧生视频 | Starting from <Picture 1>, create a cinematic realistic five-second video of the same sunset mountain landscape. Preserve the warm golden lighting, sun flare, distant ridges, wide composition, subtle slow camera motion, and matching quiet natural ambient audio for the whole video. |
+| 尾帧生视频 | Create a cinematic realistic five-second video that naturally ends at <Picture 1>. The final frames must match the sunset mountain landscape, warm golden lighting, sun flare, distant ridges, and wide composition, with coherent motion and matching quiet natural ambient audio. |
+| 首尾帧生视频 | Create a smooth cinematic transition from <Picture 1> to <Picture 2>. Preserve realistic sunset lighting, coherent mountain landscape geometry, distant ridges, natural slow camera motion, and matching quiet natural ambient audio throughout the five-second video. |
+| 图片参考 | Use <Picture 1> as the exact visual subject and composition reference. Generate a realistic five-second slow cinematic video of the same sunset mountain landscape: layered distant mountain ridges, hazy valleys, dark forest silhouettes in the foreground, warm orange sky, and a bright sun starburst near the right side of the frame. Keep the camera motion very subtle, like a gentle slow push-in over the same mountain view. Preserve the color palette, lighting direction, sun flare, atmospheric haze, and wide landscape composition from <Picture 1> for the entire video. The scene should remain a natural mountain sunset panorama from beginning to end, with matching quiet natural ambient audio. |
+| 视频 MP4 参考 | Use <Video 1> as the exact visual motion and scene reference, and use <Audio 1> as the paired soundtrack reference. Generate a realistic five-second video following the same park walkway, green grass, trees, benches, small white dog, camera motion, composition, lighting, and matching audio mood. Preserve only the subjects and environment visible in the reference for the entire video. |
+| 帧序列+音频参考 | Use <Video 1> as a strict visual reference and <Audio 1> as the paired soundtrack reference. The generated five-second video must preserve the park walkway scene from <Video 1> for the entire clip: green grass, trees, benches, the small white dog, similar camera motion, composition, lighting, and audio mood. Do not change the location or subject. Do not introduce vehicles, churches, concerts, city streets, indoor scenes, crowds, or unrelated objects. Follow the reference video frames and paired audio as closely as possible. |
+| 混合参考 | Create a five-second two-part transition that strictly uses all references. From 0 to 2 seconds, reproduce the park walkway scene from <Video 1>, including its trees, grass, path, benches, small white dog, framing, and camera motion. From 2 to 3 seconds, make a smooth natural cinematic transition. From 3 to 5 seconds, reproduce the sunset mountain landscape from <Picture 1>, including its layered ridges, warm orange sky, dark foreground silhouettes, atmospheric haze, and bright sun flare. Use <Audio 1> as standalone audio guidance throughout. Preserve only subjects and environments present in the references. |
+
+## 文件索引
+
+- 文生视频 Edge command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/cmd.txt)
+- 文生视频 Edge prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/prompt.txt)
+- 文生视频 Edge inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/inputs.txt)
+- 文生视频 Edge metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/metrics.json)
+- 文生视频 Edge GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/gpu_mem.csv)
+- 文生视频 Edge contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/contact.jpg)
+- 文生视频 Edge output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/final.mp4)
+- 文生视频 Diffusers command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/cmd.txt)
+- 文生视频 Diffusers prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/prompt.txt)
+- 文生视频 Diffusers inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/inputs.txt)
+- 文生视频 Diffusers metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/metrics.json)
+- 文生视频 Diffusers GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/gpu_mem.csv)
+- 文生视频 Diffusers contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/contact.jpg)
+- 文生视频 Diffusers output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/final.mp4)
+- 首帧生视频 Edge command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/cmd.txt)
+- 首帧生视频 Edge prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/prompt.txt)
+- 首帧生视频 Edge inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/inputs.txt)
+- 首帧生视频 Edge metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/metrics.json)
+- 首帧生视频 Edge GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/gpu_mem.csv)
+- 首帧生视频 Edge contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/contact.jpg)
+- 首帧生视频 Edge output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/final.mp4)
+- 首帧生视频 Diffusers command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/cmd.txt)
+- 首帧生视频 Diffusers prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/prompt.txt)
+- 首帧生视频 Diffusers inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/inputs.txt)
+- 首帧生视频 Diffusers metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/metrics.json)
+- 首帧生视频 Diffusers GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/gpu_mem.csv)
+- 首帧生视频 Diffusers contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/contact.jpg)
+- 首帧生视频 Diffusers output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/final.mp4)
+- 尾帧生视频 Edge command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/cmd.txt)
+- 尾帧生视频 Edge prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/prompt.txt)
+- 尾帧生视频 Edge inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/inputs.txt)
+- 尾帧生视频 Edge metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/metrics.json)
+- 尾帧生视频 Edge GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/gpu_mem.csv)
+- 尾帧生视频 Edge contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/contact.jpg)
+- 尾帧生视频 Edge output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/final.mp4)
+- 尾帧生视频 Diffusers command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/cmd.txt)
+- 尾帧生视频 Diffusers prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/prompt.txt)
+- 尾帧生视频 Diffusers inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/inputs.txt)
+- 尾帧生视频 Diffusers metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/metrics.json)
+- 尾帧生视频 Diffusers GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/gpu_mem.csv)
+- 尾帧生视频 Diffusers contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/contact.jpg)
+- 尾帧生视频 Diffusers output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/final.mp4)
+- 首尾帧生视频 Edge command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/cmd.txt)
+- 首尾帧生视频 Edge prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/prompt.txt)
+- 首尾帧生视频 Edge inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/inputs.txt)
+- 首尾帧生视频 Edge metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/metrics.json)
+- 首尾帧生视频 Edge GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/gpu_mem.csv)
+- 首尾帧生视频 Edge contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/contact.jpg)
+- 首尾帧生视频 Edge output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/final.mp4)
+- 首尾帧生视频 Diffusers command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/cmd.txt)
+- 首尾帧生视频 Diffusers prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/prompt.txt)
+- 首尾帧生视频 Diffusers inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/inputs.txt)
+- 首尾帧生视频 Diffusers metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/metrics.json)
+- 首尾帧生视频 Diffusers GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/gpu_mem.csv)
+- 首尾帧生视频 Diffusers contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/contact.jpg)
+- 首尾帧生视频 Diffusers output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/final.mp4)
+- 图片参考 Edge command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/cmd.txt)
+- 图片参考 Edge prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/prompt.txt)
+- 图片参考 Edge inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/inputs.txt)
+- 图片参考 Edge metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/metrics.json)
+- 图片参考 Edge GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/gpu_mem.csv)
+- 图片参考 Edge contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/contact.jpg)
+- 图片参考 Edge output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/final.mp4)
+- 图片参考 Diffusers command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/cmd.txt)
+- 图片参考 Diffusers prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/prompt.txt)
+- 图片参考 Diffusers inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/inputs.txt)
+- 图片参考 Diffusers metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/metrics.json)
+- 图片参考 Diffusers GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/gpu_mem.csv)
+- 图片参考 Diffusers contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/contact.jpg)
+- 图片参考 Diffusers output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/final.mp4)
+- 视频 MP4 参考 Edge command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/cmd.txt)
+- 视频 MP4 参考 Edge prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/prompt.txt)
+- 视频 MP4 参考 Edge inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/inputs.txt)
+- 视频 MP4 参考 Edge metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/metrics.json)
+- 视频 MP4 参考 Edge GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/gpu_mem.csv)
+- 视频 MP4 参考 Edge contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/contact.jpg)
+- 视频 MP4 参考 Edge output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/final.mp4)
+- 视频 MP4 参考 Diffusers command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/cmd.txt)
+- 视频 MP4 参考 Diffusers prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/prompt.txt)
+- 视频 MP4 参考 Diffusers inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/inputs.txt)
+- 视频 MP4 参考 Diffusers metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/metrics.json)
+- 视频 MP4 参考 Diffusers GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/gpu_mem.csv)
+- 视频 MP4 参考 Diffusers contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/contact.jpg)
+- 视频 MP4 参考 Diffusers output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/final.mp4)
+- 帧序列+音频参考 Edge command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/cmd.txt)
+- 帧序列+音频参考 Edge prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/prompt.txt)
+- 帧序列+音频参考 Edge inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/inputs.txt)
+- 帧序列+音频参考 Edge metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/metrics.json)
+- 帧序列+音频参考 Edge GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/gpu_mem.csv)
+- 帧序列+音频参考 Edge contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/contact.jpg)
+- 帧序列+音频参考 Edge output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/final.mp4)
+- 帧序列+音频参考 Diffusers command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/cmd.txt)
+- 帧序列+音频参考 Diffusers prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/prompt.txt)
+- 帧序列+音频参考 Diffusers inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/inputs.txt)
+- 帧序列+音频参考 Diffusers metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/metrics.json)
+- 帧序列+音频参考 Diffusers GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/gpu_mem.csv)
+- 帧序列+音频参考 Diffusers contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/contact.jpg)
+- 帧序列+音频参考 Diffusers output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/final.mp4)
+- 混合参考 Edge command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/cmd.txt)
+- 混合参考 Edge prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/prompt.txt)
+- 混合参考 Edge inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/inputs.txt)
+- 混合参考 Edge metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/metrics.json)
+- 混合参考 Edge GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/gpu_mem.csv)
+- 混合参考 Edge contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/contact.jpg)
+- 混合参考 Edge output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/final.mp4)
+- 混合参考 Diffusers command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/cmd.txt)
+- 混合参考 Diffusers prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/prompt.txt)
+- 混合参考 Diffusers inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/inputs.txt)
+- 混合参考 Diffusers metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/metrics.json)
+- 混合参考 Diffusers GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/gpu_mem.csv)
+- 混合参考 Diffusers contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/contact.jpg)
+- 混合参考 Diffusers output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/final.mp4)
+- 汇总 JSON: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/summary.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/summary.json)
+- 汇总 CSV: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/summary.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/summary.csv)
diff --git a/docs/optimization/minimax-h3-fl2va-ref2va-edge-sdcpp-h200-8bit-2026-08-12.md b/docs/optimization/minimax-h3-fl2va-ref2va-edge-sdcpp-h200-8bit-2026-08-12.md
new file mode 100644
index 0000000..1ae857d
--- /dev/null
+++ b/docs/optimization/minimax-h3-fl2va-ref2va-edge-sdcpp-h200-8bit-2026-08-12.md
@@ -0,0 +1,155 @@
+# MiniMax-H3 FL2VA/Ref2VA Edge vs sd.cpp H200 8-bit Benchmark（2026-08-12）
+
+## 结论
+
+- 本文主表现已覆盖为 2026-08-13 最终口径：Edge 使用已完成的内部 profile 八项；sd.cpp 使用官方 Comfy INT8 ConvRot DiT，重新以 `--eager-load` 全组件常驻方式串行运行八项。所有任务均为 `rc=0`。
+- Edge 在 8 个任务上的外部 wall 均更短，相对 sd.cpp eager 加速为 `1.56x–2.23x`；最大加速来自 Ref2VA 混合参考。
+- 全程最大单卡显存峰值为 `72,490 MiB`，来自 sd.cpp eager 的 FL2VA 尾帧任务。Edge 全部任务最大值为 `70,673 MiB`。
+- sd.cpp eager 与旧 lazy 结果的 wall 基本相同，差异约在 `-5s–+2s`；常驻并没有带来可辨认的速度收益。它主要改变显存：例如 Ref2VA 视频帧参考从旧 lazy 的 `56,245 MiB` 上升至 eager 的 `62,595 MiB`。
+- 两框架不是相同量化算法：Edge DiT 使用 GGML `Q8_0`，sd.cpp DiT 使用 Comfy `INT8 ConvRot`；Qwen、Video VAE、Audio VAE 相同。因此本表是“各框架可运行的 8-bit 路径”对比，不能把质量差异只归因于框架。
+- Edge FL2VA 本轮仍为官方 Diffusers BF16 shards 加载时动态转 `Q8_0`，不是随后下载的 Comfy FL2VA BF16；对应结果不能标记为“Comfy BF16 转持久化 Q8_0”。
+- 噪声根因不是 Q8 精度、Qwen 或 VAE：官方 Diffusers DiT 的 52 个 SwiGLU 输入投影半区顺序与原生/Comfy 权重相反，且 shards 省略了可推导的 `rope.inv_freq`。Edge 现已在量化前归一化 SwiGLU 布局，并在缺失时合成 16 个 FP32 RoPE 频率。
+- Ref2VA 视频任务实际输入为同一帧目录，不是 MP4。最终视频帧与帧序列+配对音频任务使用字节完全一致的干净视觉 Prompt，唯一输入差异是后者增加 `--ref-video-audio`。
+- 使用不提 Audio、不列举负面实体的同一 Prompt 完成 Edge 单变量 A/B 后，无音频和配对音频两组都严格保持公园帧内容，对输入前 56 帧的 SSIM 分别为 `0.314700` 和 `0.314327`，未观察到参考音频降低画面参考能力。
+- 2026-08-13 使用 `ED_MINIMAX_H3_PROFILE=1` 按相同 H200 参数串行重跑 Edge 八项，补齐 Qwen context、关键帧/参考 VAE、noise、DiT、视频/音频解码等内部阶段时间；八项均为 `rc=0`，wall 与原结果基本一致。
+
+## 固定口径
+
+| 项目 | 口径 |
+|---|---|
+| GPU | NVIDIA H200，串行执行，`CUDA_VISIBLE_DEVICES=0` |
+| Edge binary | [`build-cuda-refvideo-align-20260810/bin/ed-cli`](../../build-cuda-refvideo-align-20260810/bin/ed-cli) |
+| sd.cpp binary | `/mnt/cfs/9n-das-admin/llm_models/MiniMax-H3-8bit-Benchmark/builds/stable-diffusion.cpp-cuda12.8-h200-bcc7e295/bin/sd-cli` |
+| 分辨率与长度 | `864x480`、`124 frames`、`24 fps` |
+| 采样参数 | `20 steps`、Euler、CFG `1`、seed `424242`、CPU RNG |
+| 执行方式 | Edge 默认全组件常驻；sd.cpp `--eager-load` 全参数常驻；均无 CPU offload、启用 `--diffusion-fa`、GPU0 串行执行 |
+| Profile | Edge `ED_MINIMAX_H3_PROFILE=1`；sd.cpp `-v` 原生阶段日志 |
+| Edge FL2VA DiT | 官方 Diffusers BF16 shards，`--tensor-type-rules model.diffusion_model.=q8_0` 动态转 GGML Q8_0 |
+| Edge Ref2VA DiT | 本地持久化 `minimax_h3_ref2va_pruned-Q8_0.gguf`；Comfy BF16 转 GGML Q8_0 |
+| sd.cpp FL2VA DiT | Comfy `minimax_h3_fl2va_int8_convrot.safetensors`，直接加载 INT8 ConvRot |
+| sd.cpp Ref2VA DiT | Comfy `minimax_h3_ref2va_pruned_int8_convrot.safetensors`，直接加载 INT8 ConvRot |
+| Shared Qwen3-VL | Comfy BF16 转本地 `qwen3vl_32b_minimax_h3-Q8_0.gguf`，两框架使用同一文件 |
+| Shared Video VAE | Comfy `minimax_h3_video_vae_fp16.safetensors`，FP16，不量化 |
+| Shared Audio VAE | Comfy `minimax_h3_audio_vae_fp32.safetensors`，FP32，不量化 |
+| Edge manifest/status | [`status.log`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/status.log) |
+| sd.cpp eager manifest | [`manifest.txt`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/manifest.txt) |
+| 正式全量 benchmark | `/mnt/cfs/9n-das-admin/llm_models/MiniMax-H3-8bit-Benchmark/run_h200_8bit_quality_benchmark.sh` |
+| 本轮 sd.cpp-only benchmark | `/mnt/cfs/9n-das-admin/llm_models/MiniMax-H3-8bit-Benchmark/run_h200_sdcpp_eager_int8_profile_20260813.sh` |
+
+## 输入与 Prompt 核对
+
+最终主表中，每个任务的 Edge 与 sd.cpp `prompt.txt` 均通过 `cmp` 字节一致，参考输入路径、顺序、尺寸、seed 和采样参数一致；差异仅为框架与 DiT 8-bit 表示。视频帧与帧序列+配对音频还共同使用同一份视觉 Prompt，以隔离配对音频变量。
+
+| 任务 | 输入 | Prompt | 口径核对 |
+|---|---|---|---|
+| 文生视频 | 无参考输入 | [`prompt.txt`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-t2va/prompt.txt) | Edge/sd.cpp 字节一致 |
+| 首帧生视频 | [`first.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png) | [`prompt.txt`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-i2va/prompt.txt) | Edge/sd.cpp 字节一致；`<Picture 1>` 对应首帧 |
+| 尾帧生视频 | [`last.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png) | [`prompt.txt`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-l2va/prompt.txt) | Edge/sd.cpp 字节一致；`<Picture 1>` 对应尾帧 |
+| 首尾帧生视频 | [`first.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png) + [`last.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png) | [`prompt.txt`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-fl2va/prompt.txt) | Edge/sd.cpp 字节一致；标签顺序为首帧 `<Picture 1>`、尾帧 `<Picture 2>` |
+| 图片参考 | [`landscape-reference.png`](../../assets/minimax-h3-ref2va/images/landscape-reference.png) | [`prompt.txt`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-image/prompt.txt) | Edge/sd.cpp 字节一致 |
+| 视频帧参考 | [`video-frames`](../../assets/minimax-h3-ref2va/video-frames) | [`prompt.txt`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-video-frames/prompt.txt) | Edge/sd.cpp 字节一致；只引用存在的 `<Video 1>` |
+| 帧序列+配对音频 | [`video-frames`](../../assets/minimax-h3-ref2va/video-frames) + [`video-audio.wav`](../../assets/minimax-h3-ref2va/video-audio.wav) | [`prompt.txt`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-frame-audio/prompt.txt) | 与视频帧任务 Prompt 也字节一致；唯一新增输入为配对音频 |
+| 混合参考 | [`landscape-reference.png`](../../assets/minimax-h3-ref2va/images/landscape-reference.png) + [`video-frames`](../../assets/minimax-h3-ref2va/video-frames) + [`video-audio.wav`](../../assets/minimax-h3-ref2va/video-audio.wav) + [`standalone-audio.wav`](../../assets/minimax-h3-ref2va/standalone-audio.wav) | [`prompt.txt`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-mixed/prompt.txt) | Edge/sd.cpp 字节一致；沿用已完成 Edge run 的 Prompt |
+
+混合任务的已完成 Edge Prompt 将 `<Audio 1>` 描述为 standalone guidance；按参考注册顺序，`<Audio 1>` 更可能是视频配对音频、独立音频是 `<Audio 2>`。为遵守“不重跑 Edge、两框架 Prompt 完全相同”的约束，本轮 sd.cpp 原样复用该 Prompt。因此混合任务的 wall/显存对比公平，画面要求也一致，但不能用本轮结果判断独立音频标签是否被正确遵循。正式全量 benchmark 脚本已将后续运行改为 `<Audio 1>` 配对音频、`<Audio 2>` 独立音频。
+
+## FL2VA Checkpoint 对比
+
+| 任务 | Edge 输出 | sd.cpp 输出 | Edge wall | sd.cpp wall | Edge 加速 | Edge 显存 | sd.cpp 显存 | Edge 阶段耗时 | sd.cpp 阶段耗时 |
+|---|---|---|---:|---:|---:|---:|---:|---|---|
+| 文生视频 | [`final.mp4`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-t2va/final.mp4) | [`final.mp4`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-fl2va-t2va/final.mp4) | 140s | 219s | 1.56x | 70,333 MiB | 71,107 MiB | load 44.716s / Qwen 0.141s / noise 0.482s / DiT 87.719s / video 4.895s / audio 0.259s / save 1.143s | load 8.31s / cond 0.14s / DiT 175.62s / video 19.58s / audio 9.10s |
+| 首帧生视频 | [`final.mp4`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-i2va/final.mp4) | [`final.mp4`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-fl2va-i2va/final.mp4) | 146s | 236s | 1.62x | 70,493 MiB | 71,435 MiB | load 44.608s / Qwen 0.505s / keyframe VAE 0.435s / noise 0.482s / DiT 93.043s / video 4.898s / audio 0.215s / save 1.121s | load 8.48s / keyframe VAE 1.41s / cond 0.44s / DiT 190.93s / video 20.11s / audio 9.09s |
+| 尾帧生视频 | [`final.mp4`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-l2va/final.mp4) | [`final.mp4`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-fl2va-l2va/final.mp4) | 147s | 235s | 1.60x | 70,491 MiB | 72,490 MiB | load 45.108s / Qwen 0.562s / keyframe VAE 0.435s / noise 0.493s / DiT 92.976s / video 4.816s / audio 0.206s / save 1.411s | load 8.36s / keyframe VAE 1.40s / cond 0.43s / DiT 190.47s / video 19.68s / audio 9.08s |
+| 首尾帧生视频 | [`final.mp4`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-fl2va/final.mp4) | [`final.mp4`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-fl2va-fl2va/final.mp4) | 153s | 257s | 1.68x | 70,673 MiB | 71,463 MiB | load 45.569s / Qwen 0.836s / keyframe VAE 0.794s / noise 0.480s / DiT 98.761s / video 4.844s / audio 0.177s / save 1.199s | load 8.39s / keyframe VAE 2.53s / cond 0.77s / DiT 209.14s / video 20.89s / audio 9.08s |
+
+## Ref2VA Checkpoint 对比
+
+| 任务 | Edge 输出 | sd.cpp 输出 | Edge wall | sd.cpp wall | Edge 加速 | Edge 显存 | sd.cpp 显存 | Edge 阶段耗时 | sd.cpp 阶段耗时 |
+|---|---|---|---:|---:|---:|---:|---:|---|---|
+| 图片参考 | [`final.mp4`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-image/final.mp4) | [`final.mp4`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-ref2va-image/final.mp4) | 110s | 228s | 2.07x | 57,339 MiB | 59,081 MiB | load 7.778s / Qwen 0.607s / ref VAE 0.443s / noise 0.491s / DiT 93.242s / video 4.783s / audio 0.168s / save 1.106s | load 6.77s / ref VAE 1.27s / cond 0.50s / DiT 184.82s / video 19.80s / audio 9.10s |
+| 视频帧参考 | [`final.mp4`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-video-frames/final.mp4) | [`final.mp4`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-ref2va-video-frames/final.mp4) | 192s | 417s | 2.17x | 62,931 MiB | 62,595 MiB | load 7.508s / Qwen 1.716s / ref VAE 24.293s / noise 0.475s / DiT 145.866s / video 4.848s / audio 0.173s / save 1.843s | load 6.86s / ref VAE 32.71s / cond 1.51s / DiT 334.36s / video 19.73s / audio 9.08s |
+| 帧序列+配对音频 | [`final.mp4`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-frame-audio/final.mp4) | [`final.mp4`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-ref2va-frame-audio/final.mp4) | 192s | 424s | 2.21x | 62,931 MiB | 62,595 MiB | load 7.655s / Qwen 1.689s / ref VAE 24.403s / audio VAE 0.022s / noise 0.478s / DiT 146.078s / video 4.844s / audio 0.171s / save 1.779s | load 6.79s / ref VAE 33.29s / audio VAE 0.07s / cond 1.41s / DiT 338.90s / video 20.14s / audio 9.07s |
+| 混合参考 | [`final.mp4`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-mixed/final.mp4) | [`final.mp4`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-ref2va-mixed/final.mp4) | 204s | 454s | 2.23x | 62,931 MiB | 62,595 MiB | load 7.656s / Qwen 2.289s / ref VAE 24.673s / audio VAE 0.044s / noise 0.477s / DiT 156.592s / video 4.826s / audio 0.222s / save 1.828s | load 6.77s / ref VAE 34.25s / audio VAE 0.09s / cond 2.03s / DiT 368.01s / video 19.83s / audio 9.08s |
+
+## Ref2VA 视频音频单变量复核（2026-08-13）
+
+本节只验证 Edge 中“给相同视频帧增加配对音频是否破坏画面参考”。两组使用同一 Ref2VA Q8 GGUF、Qwen、VAE、56 张输入帧、`864x480`、124 帧、24 fps、20 steps、CFG `1`、seed `424242` 和字节完全一致的 Prompt。为缩短等待时间，两组分别在空闲 H200 GPU0/GPU1 并行执行，因此 wall 只用于确认运行成本接近，不与上方串行框架对比表混用。
+
+| 条件 | 输出 | 命令 | Wall | 峰值显存 | 输入前 56 帧 SSIM | 观察 |
+|---|---|---|---:|---:|---:|---|
+| 仅视频帧 | [`final.mp4`](../../outputs/minimax-h3/h200-ref2va-audio-ablation-20260813/video-only/final.mp4) | [`cmd.txt`](../../outputs/minimax-h3/h200-ref2va-audio-ablation-20260813/video-only/cmd.txt) | 193s | 62,931 MiB | 0.314700 | 保持公园、树林、长椅、白狗和参考运动 |
+| 同视频帧+配对音频 | [`final.mp4`](../../outputs/minimax-h3/h200-ref2va-audio-ablation-20260813/video-with-paired-audio/final.mp4) | [`cmd.txt`](../../outputs/minimax-h3/h200-ref2va-audio-ablation-20260813/video-with-paired-audio/cmd.txt) | 195s | 62,931 MiB | 0.314327 | 与无音频组内容和参考程度接近 |
+
+两组生成视频之间的全 124 帧 SSIM 为 `0.823399`。加入配对音频会改变联合 DiT 条件和逐像素结果，这是 MiniMax-H3 联合音视频 self-attention 的预期行为；但本次受控结果没有显示画面参考质量下降。正式 benchmark 已改为运行时生成一份公共 Prompt 文件，并让 `ref2va-video-frames` 与 `ref2va-frame-audio` 共同读取该文件，二者唯一输入差异是后者增加 `--ref-video-audio`。
+
+## Edge 各阶段耗时（2026-08-13 Profile 重跑）
+
+本表使用 `ED_MINIMAX_H3_PROFILE=1` 在 H200 GPU0 串行重跑。FL2VA 四项使用修复后的官方 Diffusers BF16 在线 Q8 路径；Ref2VA 图片和混合任务沿用原输入与 Prompt，视频帧两项使用修正后的公共 Prompt。完整状态见 [`status.log`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/status.log)。
+
+| 任务 | Profile 日志 | Wall | 峰值显存 | Load | Qwen context | 关键帧 VAE | 参考视觉 VAE | 参考音频准备+VAE | Noise | DiT | 视频解码+复制 | 音频解码+复制 | Save |
+|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|
+| 文生视频 | [`run.log`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-t2va/run.log) | 140s | 70,333 MiB | 44.716s | 0.141s | 0.000s | 0.000s | 0.000s | 0.482s | 87.719s | 4.895s | 0.259s | 1.143s |
+| 首帧生视频 | [`run.log`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-i2va/run.log) | 146s | 70,493 MiB | 44.608s | 0.505s | 0.435s | 0.000s | 0.000s | 0.482s | 93.043s | 4.898s | 0.215s | 1.121s |
+| 尾帧生视频 | [`run.log`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-l2va/run.log) | 147s | 70,491 MiB | 45.108s | 0.562s | 0.435s | 0.000s | 0.000s | 0.493s | 92.976s | 4.816s | 0.206s | 1.411s |
+| 首尾帧生视频 | [`run.log`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-fl2va/run.log) | 153s | 70,673 MiB | 45.569s | 0.836s | 0.794s | 0.000s | 0.000s | 0.480s | 98.761s | 4.844s | 0.177s | 1.199s |
+| 图片参考 | [`run.log`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-image/run.log) | 110s | 57,339 MiB | 7.778s | 0.607s | 0.000s | 0.443s | 0.000s | 0.491s | 93.242s | 4.783s | 0.168s | 1.106s |
+| 视频帧参考 | [`run.log`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-video-frames/run.log) | 192s | 62,931 MiB | 7.508s | 1.716s | 0.000s | 24.293s | 0.000s | 0.475s | 145.866s | 4.848s | 0.173s | 1.843s |
+| 帧序列+配对音频 | [`run.log`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-frame-audio/run.log) | 192s | 62,931 MiB | 7.655s | 1.689s | 0.000s | 24.403s | 0.022s | 0.478s | 146.078s | 4.844s | 0.171s | 1.779s |
+| 混合参考 | [`run.log`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-mixed/run.log) | 204s | 62,931 MiB | 7.656s | 2.289s | 0.000s | 24.673s | 0.044s | 0.477s | 156.592s | 4.826s | 0.222s | 1.828s |
+
+计时口径：
+
+- `Load`、`Save` 来自进程外层 `[ED_WALL]`；其余列来自 pipeline 内部 `minimax-h3 profile`。
+- `Qwen context` 是完整条件上下文阶段，内部包含视觉输入准备、Qwen3-VL vision encode、tokenize 和 text encode；不与关键帧/参考 VAE 重叠。
+- `参考视觉 VAE` 同时承载 Ref2VA 图片和视频参考编码，因此图片任务的 `0.443s` 也列在该列。
+- `DiT` 为 20 次 conditional diffusion call；本轮 CFG 为 `1`，没有 unconditional call 和 CFG combine。
+- `视频解码+复制`、`音频解码+复制` 分别合并 VAE decode 与输出 postprocess/copy；各主阶段可以相加解释内部 generation，但不包含进程启动、模型加载和容器封装。
+
+## sd.cpp 各阶段耗时（2026-08-13 Eager 重跑）
+
+本表使用官方 Comfy INT8 ConvRot DiT 和 `--eager-load` 在 H200 GPU0 串行运行。`run.log` 中 FL2VA/Ref2VA 分别记录 `64,256.98 MiB`/`51,867.89 MiB` 的 prepared params backend buffer，确认模型参数整体常驻 GPU，而非按层 lazy 搬运。
+
+| 任务 | 日志 | Wall | 峰值显存 | Load | 视觉 VAE encode | 音频 VAE encode | Condition | DiT | 视频解码 | 音频解码 |
+|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|
+| 文生视频 | [`run.log`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-fl2va-t2va/run.log) | 219s | 71,107 MiB | 8.31s | 0.00s | 0.00s | 0.14s | 175.62s | 19.58s | 9.10s |
+| 首帧生视频 | [`run.log`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-fl2va-i2va/run.log) | 236s | 71,435 MiB | 8.48s | 1.41s | 0.00s | 0.44s | 190.93s | 20.11s | 9.09s |
+| 尾帧生视频 | [`run.log`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-fl2va-l2va/run.log) | 235s | 72,490 MiB | 8.36s | 1.40s | 0.00s | 0.43s | 190.47s | 19.68s | 9.08s |
+| 首尾帧生视频 | [`run.log`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-fl2va-fl2va/run.log) | 257s | 71,463 MiB | 8.39s | 2.53s | 0.00s | 0.77s | 209.14s | 20.89s | 9.08s |
+| 图片参考 | [`run.log`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-ref2va-image/run.log) | 228s | 59,081 MiB | 6.77s | 1.27s | 0.00s | 0.50s | 184.82s | 19.80s | 9.10s |
+| 视频帧参考 | [`run.log`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-ref2va-video-frames/run.log) | 417s | 62,595 MiB | 6.86s | 32.71s | 0.00s | 1.51s | 334.36s | 19.73s | 9.08s |
+| 帧序列+配对音频 | [`run.log`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-ref2va-frame-audio/run.log) | 424s | 62,595 MiB | 6.79s | 33.29s | 0.07s | 1.41s | 338.90s | 20.14s | 9.07s |
+| 混合参考 | [`run.log`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-ref2va-mixed/run.log) | 454s | 62,595 MiB | 6.77s | 34.25s | 0.09s | 2.03s | 368.01s | 19.83s | 9.08s |
+
+## 阶段耗时说明
+
+- Edge 阶段来自 `ED_MINIMAX_H3_PROFILE=1` 内部 profile；sd.cpp 阶段来自 `-v` 的原生 timing 日志。两套阶段名和边界并不完全相同，适合定位各自热点，不应逐列视为严格同一计时区间。
+- sd.cpp `Load` 是各次 `loading tensors completed` 的累计值；`Condition` 对应 `get_learned_condition`；DiT 对应 sampling；视觉/音频 VAE encode 与 decode 使用日志中各阶段完成时间。
+- 两框架外部 wall 都包含进程启动、模型加载、生成、框架内部保存和正常退出。sd.cpp wall 在外部 FFmpeg 将 `final.webm` 转为 `final.mp4` 前结束，因此不包含文档封装转码时间。
+- 峰值显存均从完整 `gpu_mem.csv` 的 GPU0 `memory.used` 数值列取最大值；修正后的 parser 使用数值转换，避免旧脚本按字符串比较导致错误峰值。
+
+## sd.cpp Eager 与旧 Lazy 对比
+
+| 任务 | Lazy wall | Eager wall | Lazy 峰值显存 | Eager 峰值显存 |
+|---|---:|---:|---:|---:|
+| 文生视频 | 219s | 219s | 65,951 MiB | 71,107 MiB |
+| 图片参考 | 228s | 228s | 54,749 MiB | 59,081 MiB |
+| 视频帧参考 | 422s | 417s | 56,245 MiB | 62,595 MiB |
+| 帧序列+配对音频 | 422s | 424s | 57,389 MiB | 62,595 MiB |
+| 混合参考 | 455s | 454s | 57,433 MiB | 62,595 MiB |
+
+`--eager-load` 对速度没有可辨认的稳定收益：八项 wall 差异为 `-5s–+2s`，属于运行波动；但参数常驻会明显提高峰值显存。本文最终主表采用 eager 数据，是为了让 Edge 与 sd.cpp 都按组件常驻口径比较显存，而不是为了宣称 eager 更快。
+
+## 文件索引
+
+每个任务目录均包含 `cmd.txt`、`prompt.txt`、`run.log`、`gpu_mem.csv`、`metrics.json` 和 `final.mp4`；sd.cpp 目录还包含 `inputs.txt` 并保留原始 `final.webm`。
+
+| 任务 | Edge 目录 | sd.cpp 目录 |
+|---|---|---|
+| 文生视频 | [`fl2va-t2va`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-t2va) | [`sdcpp-fl2va-t2va`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-fl2va-t2va) |
+| 首帧生视频 | [`fl2va-i2va`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-i2va) | [`sdcpp-fl2va-i2va`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-fl2va-i2va) |
+| 尾帧生视频 | [`fl2va-l2va`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-l2va) | [`sdcpp-fl2va-l2va`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-fl2va-l2va) |
+| 首尾帧生视频 | [`fl2va-fl2va`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-fl2va) | [`sdcpp-fl2va-fl2va`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-fl2va-fl2va) |
+| 图片参考 | [`ref2va-image`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-image) | [`sdcpp-ref2va-image`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-ref2va-image) |
+| 视频帧参考 | [`ref2va-video-frames`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-video-frames) | [`sdcpp-ref2va-video-frames`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-ref2va-video-frames) |
+| 帧序列+配对音频 | [`ref2va-frame-audio`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-frame-audio) | [`sdcpp-ref2va-frame-audio`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-ref2va-frame-audio) |
+| 混合参考 | [`ref2va-mixed`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-mixed) | [`sdcpp-ref2va-mixed`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-ref2va-mixed) |
diff --git a/scripts/diffusers/run_minimax_h3_fl2va_optional_quantized.py b/scripts/diffusers/run_minimax_h3_fl2va_optional_quantized.py
new file mode 100755
index 0000000..bfb1b9a
--- /dev/null
+++ b/scripts/diffusers/run_minimax_h3_fl2va_optional_quantized.py
@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""Run official Diffusers MiniMax-H3 FL2VA/T2VA/I2VA/L2VA with optional keyframes and TorchAO quantization."""
+
+import argparse
+import inspect
+import json
+import time
+from pathlib import Path
+
+import torch
+from diffusers import MiniMaxH3Transformer3DModel, ModularPipeline, TorchAoConfig
+from diffusers.hooks import apply_group_offloading
+from diffusers.utils import load_image
+from diffusers.utils.export_utils import encode_video
+from torchao.quantization import Int4WeightOnlyConfig, Int8WeightOnlyConfig
+from transformers import Qwen3VLForConditionalGeneration
+from transformers import TorchAoConfig as TransformersTorchAoConfig
+
+TRANSFORMER_NOT_QUANTIZED = [
+    "proj_in", "audio_proj_in", "context_embedder", "time_embedder", "time_proj",
+    "token_refiner", "norm_out", "proj_out", "audio_proj_out",
+]
+TEXT_ENCODER_NOT_QUANTIZED = [
+    "model.visual", "model.language_model.embed_tokens", "model.language_model.norm", "lm_head",
+]
+
+def sync_time() -> float:
+    torch.cuda.synchronize()
+    return time.perf_counter()
+
+def make_quant_config(bits: int):
+    if bits == 8:
+        if "version" in inspect.signature(Int8WeightOnlyConfig).parameters:
+            return Int8WeightOnlyConfig(version=2)
+        return Int8WeightOnlyConfig()
+    if bits == 4:
+        return Int4WeightOnlyConfig(group_size=128)
+    raise ValueError(bits)
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model", type=Path, required=True)
+    parser.add_argument("--image", type=Path)
+    parser.add_argument("--last-image", type=Path)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--prompt", required=True)
+    parser.add_argument("--seed", type=int, default=424242)
+    parser.add_argument("--height", type=int, default=480)
+    parser.add_argument("--width", type=int, default=864)
+    parser.add_argument("--num-frames", type=int, default=124)
+    parser.add_argument("--steps", type=int, default=20)
+    parser.add_argument("--bits", type=int, choices=(4, 8), default=4)
+    parser.add_argument("--device", default="cuda")
+    parser.add_argument("--resident", action="store_true")
+    parser.add_argument("--no-stream-offload", action="store_true")
+    parser.add_argument("--profile-transformer", action="store_true")
+    parser.add_argument("--profile-components", action="store_true")
+    args = parser.parse_args()
+
+    if not torch.cuda.is_available():
+        raise RuntimeError("CUDA required")
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    device = torch.device(args.device)
+    workflow = "fl2va" if (args.image is not None or args.last_image is not None) else "t2va"
+
+    started = time.perf_counter()
+    pipe = ModularPipeline.from_pretrained(args.model, workflow=workflow, local_files_only=True)
+    initialized = time.perf_counter()
+    qconf = make_quant_config(args.bits)
+    pipe.update_components(
+        transformer=MiniMaxH3Transformer3DModel.from_pretrained(
+            args.model,
+            subfolder="transformer",
+            dtype=torch.bfloat16,
+            quantization_config=TorchAoConfig(qconf, modules_to_not_convert=TRANSFORMER_NOT_QUANTIZED),
+            low_cpu_mem_usage=True,
+            local_files_only=True,
+        ),
+        text_encoder=Qwen3VLForConditionalGeneration.from_pretrained(
+            args.model,
+            subfolder="text_encoder",
+            dtype=torch.bfloat16,
+            quantization_config=TransformersTorchAoConfig(qconf, modules_to_not_convert=TEXT_ENCODER_NOT_QUANTIZED),
+            local_files_only=True,
+        ),
+    )
+    quantized_loaded = time.perf_counter()
+    pipe.load_components(dtype=torch.bfloat16, pretrained_model_name_or_path=str(args.model), local_files_only=True)
+    pipe.transformer.requires_grad_(False)
+    pipe.text_encoder.requires_grad_(False)
+
+    if args.resident:
+        pipe.transformer.to(device)
+        pipe.text_encoder.to(device)
+        pipe.vae.to(device)
+        pipe.audio_vae.to(device)
+        offload_summary = {"transformer": str(device), "text_encoder": str(device), "vae": str(device), "audio_vae": str(device)}
+    else:
+        offload = {"onload_device": device, "offload_device": torch.device("cpu"), "use_stream": not args.no_stream_offload, "low_cpu_mem_usage": True}
+        pipe.transformer.enable_group_offload(offload_type="block_level", num_blocks_per_group=1, **offload)
+        apply_group_offloading(pipe.text_encoder.model, offload_type="leaf_level", **offload)
+        pipe.vae.to(device)
+        pipe.audio_vae.to(device)
+        offload_summary = {"transformer": "block_level group offload", "text_encoder": "leaf_level group offload", "vae": str(device), "audio_vae": str(device), "use_stream": not args.no_stream_offload}
+    components_ready = time.perf_counter()
+
+    transformer_profile = {"calls": 0, "seconds": 0.0}
+    stack = []
+    if args.profile_transformer:
+        def pre(_module, _args, _kwargs):
+            torch.cuda.synchronize(device)
+            stack.append(time.perf_counter())
+        def post(_module, _args, _kwargs, _output):
+            torch.cuda.synchronize(device)
+            transformer_profile["calls"] += 1
+            transformer_profile["seconds"] += time.perf_counter() - stack.pop()
+        pipe.transformer.register_forward_pre_hook(pre, with_kwargs=True)
+        pipe.transformer.register_forward_hook(post, with_kwargs=True)
+
+    component_profile = {k: {"calls": 0, "seconds": 0.0} for k in ["text_encoder", "video_vae_encode", "video_vae_decode", "audio_vae_encode", "audio_vae_decode"]}
+    if args.profile_components:
+        def text_pre(_module, _args, _kwargs):
+            torch.cuda.synchronize(device)
+            component_profile["text_encoder"]["started_at"] = time.perf_counter()
+        def text_post(_module, _args, _kwargs, _output):
+            torch.cuda.synchronize(device)
+            started_at = component_profile["text_encoder"].pop("started_at")
+            component_profile["text_encoder"]["calls"] += 1
+            component_profile["text_encoder"]["seconds"] += time.perf_counter() - started_at
+        def wrap(name, method):
+            def wrapped(*wargs, **wkwargs):
+                torch.cuda.synchronize(device)
+                begin = time.perf_counter()
+                result = method(*wargs, **wkwargs)
+                torch.cuda.synchronize(device)
+                component_profile[name]["calls"] += 1
+                component_profile[name]["seconds"] += time.perf_counter() - begin
+                return result
+            return wrapped
+        pipe.text_encoder.model.register_forward_pre_hook(text_pre, with_kwargs=True)
+        pipe.text_encoder.model.register_forward_hook(text_post, with_kwargs=True)
+        pipe.vae.encode = wrap("video_vae_encode", pipe.vae.encode)
+        pipe.vae.decode = wrap("video_vae_decode", pipe.vae.decode)
+        pipe.audio_vae.encode = wrap("audio_vae_encode", pipe.audio_vae.encode)
+        pipe.audio_vae.decode = wrap("audio_vae_decode", pipe.audio_vae.decode)
+
+    first_image = load_image(str(args.image)) if args.image is not None else None
+    last_image = load_image(str(args.last_image)) if args.last_image is not None else None
+    call_kwargs = dict(
+        prompt=args.prompt,
+        height=args.height,
+        width=args.width,
+        num_frames=args.num_frames,
+        num_inference_steps=args.steps,
+        generator=torch.Generator(device="cpu").manual_seed(args.seed),
+        output=["videos", "audio", "sampling_rate"],
+    )
+    if workflow == "fl2va":
+        call_kwargs["image"] = first_image
+        call_kwargs["last_image"] = last_image
+
+    torch.cuda.reset_peak_memory_stats(device)
+    sync_time()
+    out = pipe(**call_kwargs)
+    generated_at = sync_time()
+    encode_video(out["videos"][0], fps=24, output_path=str(args.output), audio=out["audio"][0], audio_sample_rate=out["sampling_rate"])
+    finished = time.perf_counter()
+
+    result = {
+        "framework": "diffusers-main",
+        "workflow": workflow,
+        "model": str(args.model),
+        "device": args.device,
+        "dtype": "bfloat16",
+        "quantization": {"method": "TorchAO weight-only", "bits": args.bits, "transformer_quantized": True, "text_encoder_quantized": True, "vae_quantized": False, "audio_vae_quantized": False},
+        "offload": offload_summary,
+        "prompt": args.prompt,
+        "seed": args.seed,
+        "height": args.height,
+        "width": args.width,
+        "requested_num_frames": args.num_frames,
+        "num_inference_steps": args.steps,
+        "image": str(args.image) if args.image else None,
+        "last_image": str(args.last_image) if args.last_image else None,
+        "output": str(args.output),
+        "seconds": {"pipeline_init": initialized - started, "quantized_component_load": quantized_loaded - initialized, "component_finalize": components_ready - quantized_loaded, "generate_cuda": generated_at - components_ready, "transformer_forward_cuda": transformer_profile["seconds"], "mux": finished - generated_at, "end_to_end": finished - started},
+        "transformer_forward_calls": transformer_profile["calls"],
+        "component_profile": component_profile if args.profile_components else None,
+        "memory_bytes": {"max_allocated_during_generate": torch.cuda.max_memory_allocated(device), "max_reserved_during_generate": torch.cuda.max_memory_reserved(device)},
+    }
+    args.output.with_suffix(".json").write_text(json.dumps(result, ensure_ascii=False, indent=2) + "\n")
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/diffusers/run_minimax_h3_ref2va_quantized_official_video.py b/scripts/diffusers/run_minimax_h3_ref2va_quantized_official_video.py
new file mode 100755
index 0000000..570a7bd
--- /dev/null
+++ b/scripts/diffusers/run_minimax_h3_ref2va_quantized_official_video.py
@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+import argparse, inspect, json, subprocess, time, wave
+from pathlib import Path
+import numpy as np
+import torch
+from PIL import Image
+from diffusers import MiniMaxH3Transformer3DModel, ModularPipeline, TorchAoConfig
+from diffusers.hooks import apply_group_offloading
+from diffusers.modular_pipelines.minimax_h3 import MiniMaxH3AudioReference, MiniMaxH3ImageReference, MiniMaxH3VideoReference
+from diffusers.utils.export_utils import encode_video
+from torchao.quantization import Int4WeightOnlyConfig, Int8WeightOnlyConfig
+from transformers import Qwen3VLForConditionalGeneration
+from transformers import TorchAoConfig as TransformersTorchAoConfig
+
+TRANSFORMER_NOT_QUANTIZED = ["proj_in","audio_proj_in","context_embedder","time_embedder","time_proj","token_refiner","norm_out","proj_out","audio_proj_out"]
+TEXT_ENCODER_NOT_QUANTIZED = ["model.visual","model.language_model.embed_tokens","model.language_model.norm","lm_head"]
+
+def make_quant_config(bits:int):
+    if bits == 8:
+        return Int8WeightOnlyConfig(version=2) if "version" in inspect.signature(Int8WeightOnlyConfig).parameters else Int8WeightOnlyConfig()
+    if bits == 4:
+        return Int4WeightOnlyConfig(group_size=128)
+    raise ValueError(bits)
+
+def sync_time():
+    torch.cuda.synchronize(); return time.perf_counter()
+
+def read_wav(path: Path):
+    try:
+        with wave.open(str(path), "rb") as wf:
+            channels=wf.getnchannels(); rate=wf.getframerate(); width=wf.getsampwidth(); frames=wf.getnframes(); data=wf.readframes(frames)
+        if width == 2:
+            arr=np.frombuffer(data, dtype="<i2").astype(np.float32) / 32768.0
+        elif width == 4:
+            arr=np.frombuffer(data, dtype="<i4").astype(np.float32) / 2147483648.0
+        elif width == 1:
+            arr=(np.frombuffer(data, dtype=np.uint8).astype(np.float32)-128.0)/128.0
+        else:
+            raise ValueError(f"unsupported wav sample width {width}")
+        arr=arr.reshape(-1, channels).T.copy()
+        return torch.from_numpy(arr), rate
+    except wave.Error:
+        rate=32000
+        cmd=["ffmpeg","-v","error","-i",str(path),"-f","f32le","-acodec","pcm_f32le","-ac","2","-ar",str(rate),"-"]
+        raw=subprocess.check_output(cmd)
+        arr=np.frombuffer(raw, dtype="<f4").reshape(-1, 2).T.copy()
+        return torch.from_numpy(arr), rate
+
+def load_frame_dir(path: Path):
+    files=sorted([p for p in path.iterdir() if p.suffix.lower() in {".png",".jpg",".jpeg",".webp"}])
+    if not files: raise ValueError(f"no frames in {path}")
+    return [Image.open(p).convert("RGB") for p in files]
+
+def build_video_reference(path: Path, audio=None, sample_rate=None):
+    if path.is_dir():
+        return MiniMaxH3VideoReference(frames=load_frame_dir(path), fps=24.0, audio=audio, sample_rate=sample_rate)
+    ref = MiniMaxH3VideoReference.from_file(str(path))
+    if audio is not None:
+        ref.audio = audio
+        ref.sample_rate = sample_rate
+    return ref
+
+def build_refs(args):
+    refs=[]
+    for p in args.ref_image:
+        refs.append(MiniMaxH3ImageReference.from_file(str(p)))
+    for i,p in enumerate(args.ref_video):
+        audio=None; sample_rate=None
+        if i < len(args.ref_video_audio):
+            audio, sample_rate = read_wav(args.ref_video_audio[i])
+        refs.append(build_video_reference(p, audio=audio, sample_rate=sample_rate))
+    for p in args.ref_audio:
+        audio, sample_rate = read_wav(p)
+        refs.append(MiniMaxH3AudioReference(audio=audio, sample_rate=sample_rate))
+    return refs
+
+def main():
+    ap=argparse.ArgumentParser()
+    ap.add_argument("--model", type=Path, required=True)
+    ap.add_argument("--output", type=Path, required=True)
+    ap.add_argument("--prompt", required=True)
+    ap.add_argument("--seed", type=int, default=42)
+    ap.add_argument("--height", type=int, default=480)
+    ap.add_argument("--width", type=int, default=864)
+    ap.add_argument("--num-frames", type=int, default=124)
+    ap.add_argument("--steps", type=int, default=20)
+    ap.add_argument("--bits", type=int, choices=(4,8), default=4)
+    ap.add_argument("--device", default="cuda")
+    ap.add_argument("--resident", action="store_true")
+    ap.add_argument("--profile-transformer", action="store_true")
+    ap.add_argument("--profile-components", action="store_true")
+    ap.add_argument("--ref-image", type=Path, action="append", default=[])
+    ap.add_argument("--ref-video", type=Path, action="append", default=[])
+    ap.add_argument("--ref-video-audio", type=Path, action="append", default=[])
+    ap.add_argument("--ref-audio", type=Path, action="append", default=[])
+    args=ap.parse_args()
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    if not torch.cuda.is_available(): raise RuntimeError("CUDA required")
+    device=torch.device(args.device)
+    refs=build_refs(args)
+    started=time.perf_counter()
+    pipe=ModularPipeline.from_pretrained(args.model, workflow="ref2va", local_files_only=True)
+    initialized=time.perf_counter()
+    qconf=make_quant_config(args.bits)
+    pipe.update_components(
+        transformer_ref=MiniMaxH3Transformer3DModel.from_pretrained(args.model, subfolder="transformer_ref", dtype=torch.bfloat16, quantization_config=TorchAoConfig(qconf, modules_to_not_convert=TRANSFORMER_NOT_QUANTIZED), low_cpu_mem_usage=True, local_files_only=True),
+        text_encoder=Qwen3VLForConditionalGeneration.from_pretrained(args.model, subfolder="text_encoder", dtype=torch.bfloat16, quantization_config=TransformersTorchAoConfig(qconf, modules_to_not_convert=TEXT_ENCODER_NOT_QUANTIZED), local_files_only=True),
+    )
+    quant_loaded=time.perf_counter()
+    pipe.load_components(dtype=torch.bfloat16, pretrained_model_name_or_path=str(args.model), local_files_only=True)
+    pipe.transformer_ref.requires_grad_(False); pipe.text_encoder.requires_grad_(False)
+    if args.resident:
+        pipe.transformer_ref.to(device); pipe.text_encoder.to(device)
+    else:
+        off={"onload_device":device,"offload_device":torch.device("cpu"),"use_stream":True,"low_cpu_mem_usage":True}
+        pipe.transformer_ref.enable_group_offload(offload_type="block_level", num_blocks_per_group=1, **off)
+        apply_group_offloading(pipe.text_encoder.model, offload_type="leaf_level", **off)
+    pipe.vae.to(device); pipe.audio_vae.to(device)
+    ready=time.perf_counter()
+    transformer_profile={"calls":0,"seconds":0.0}; stack=[]
+    if args.profile_transformer:
+        def pre(m,a,k): torch.cuda.synchronize(device); stack.append(time.perf_counter())
+        def post(m,a,k,o): torch.cuda.synchronize(device); transformer_profile["calls"]+=1; transformer_profile["seconds"]+=time.perf_counter()-stack.pop()
+        pipe.transformer_ref.register_forward_pre_hook(pre, with_kwargs=True); pipe.transformer_ref.register_forward_hook(post, with_kwargs=True)
+    comp={k:{"calls":0,"seconds":0.0} for k in ["text_encoder","video_vae_encode","video_vae_decode","audio_vae_encode","audio_vae_decode"]}
+    if args.profile_components:
+        def wrap(name, fn):
+            def inner(*a, **k):
+                torch.cuda.synchronize(device); t=time.perf_counter(); out=fn(*a, **k); torch.cuda.synchronize(device); comp[name]["calls"]+=1; comp[name]["seconds"]+=time.perf_counter()-t; return out
+            return inner
+        pipe.vae.encode=wrap("video_vae_encode", pipe.vae.encode); pipe.vae.decode=wrap("video_vae_decode", pipe.vae.decode)
+        pipe.audio_vae.encode=wrap("audio_vae_encode", pipe.audio_vae.encode); pipe.audio_vae.decode=wrap("audio_vae_decode", pipe.audio_vae.decode)
+    gen=torch.Generator(device="cpu").manual_seed(args.seed)
+    torch.cuda.reset_peak_memory_stats(device); sync_time()
+    out=pipe(prompt=args.prompt, references=refs, height=args.height, width=args.width, num_frames=args.num_frames, num_inference_steps=args.steps, generator=gen, output=["videos","audio","sampling_rate"])
+    generated_at=sync_time()
+    encode_video(out["videos"][0], fps=24, output_path=str(args.output), audio=out["audio"][0], audio_sample_rate=out["sampling_rate"])
+    finished=time.perf_counter()
+    print(json.dumps({"framework":"diffusers-main","workflow":"ref2va","model":str(args.model),"dtype":"bfloat16","quantization":{"method":"TorchAO weight-only","bits":args.bits,"transformer_quantized":True,"text_encoder_quantized":True,"vae_quantized":False,"audio_vae_quantized":False},"prompt":args.prompt,"references":[{"type":type(r).__name__,"kind":getattr(r,"kind",None),"fps":getattr(r,"fps",None),"frames":(len(getattr(r,"frames",[])) if not hasattr(getattr(r,"frames",None),"shape") else int(getattr(r,"frames").shape[0])) if hasattr(r,"frames") else None,"has_audio":bool(getattr(r,"has_audio",False)),"sample_rate":getattr(r,"sample_rate",None)} for r in refs],"height":args.height,"width":args.width,"requested_num_frames":args.num_frames,"num_inference_steps":args.steps,"seconds":{"pipeline_init":initialized-started,"quantized_component_load":quant_loaded-initialized,"component_finalize":ready-quant_loaded,"generate_cuda":generated_at-ready,"transformer_forward_cuda":transformer_profile["seconds"],"mux":finished-generated_at,"end_to_end":finished-started},"transformer_forward_calls":transformer_profile["calls"],"component_profile":comp,"memory_bytes":{"max_allocated_during_generate":torch.cuda.max_memory_allocated(device),"max_reserved_during_generate":torch.cuda.max_memory_reserved(device)}}, indent=2))
+if __name__ == "__main__": main()
diff --git a/src/core/runtime/model_loader.cpp b/src/core/runtime/model_loader.cpp
index 3806666..b73eeac 100644
--- a/src/core/runtime/model_loader.cpp
+++ b/src/core/runtime/model_loader.cpp
@@ -1063,10 +1063,17 @@ bool ModelLoader::init_from_file(const std::string& file_path, const std::string
     if (is_safetensors_file(resolved_path)) {
         LOG_INFO("load %s using safetensors format", resolved_path.c_str());
         std::string effective_prefix = prefix;
+        if (version_ == VERSION_COUNT) {
+            version_ = infer_transformer_file_version(resolved_path);
+        }
         std::string lower_name = fs::path(resolved_path).filename().string();
         std::transform(lower_name.begin(), lower_name.end(), lower_name.begin(), [](unsigned char c) {
             return static_cast<char>(std::tolower(c));
         });
+        if (version_ == VERSION_COUNT &&
+            (contains(lower_name, "minimax_h3") || contains(lower_name, "minimax-h3"))) {
+            version_ = VERSION_MINIMAX_H3;
+        }
         if (effective_prefix.empty() && contains(lower_name, "flux")) {
             version_ = contains(lower_name, "kontext") ? VERSION_FLUX_KONTEXT : VERSION_FLUX;
             effective_prefix = "transformer.";
@@ -1075,6 +1082,9 @@ bool ModelLoader::init_from_file(const std::string& file_path, const std::string
     }
     if (is_safetensors_index_file(resolved_path)) {
         LOG_INFO("load %s using safetensors shard index format", resolved_path.c_str());
+        if (version_ == VERSION_COUNT) {
+            version_ = infer_transformer_file_version(resolved_path);
+        }
         return init_from_safetensors_index_file(resolved_path, prefix);
     }
 
@@ -1083,12 +1093,16 @@ bool ModelLoader::init_from_file(const std::string& file_path, const std::string
 }
 
 void ModelLoader::convert_tensors_name() {
-    SDVersion version = (version_ == VERSION_COUNT) ? get_ld_version() : version_;
+    if (version_ == VERSION_COUNT) {
+        version_ = get_ld_version();
+    }
+    SDVersion version = version_;
     if (version == VERSION_COUNT) {
         LOG_WARN("model version is unknown; tensor names are left mostly unchanged");
     }
 
     String2TensorStorage new_map;
+    size_t swiglu_half_swaps = 0;
     for (auto& item : tensor_storage_map_) {
         TensorStorage tensor_storage = item.second;
         const std::string original_name = tensor_storage.name;
@@ -1100,9 +1114,17 @@ void ModelLoader::convert_tensors_name() {
             contains(original_name, "norm_out.linear.")) {
             tensor_storage.swap_scale_shift = true;
         }
+        if (ed_version_is_minimax_h3(version) &&
+            contains(original_name, ".ff.net.0.proj.")) {
+            tensor_storage.swap_swiglu_halves = true;
+            ++swiglu_half_swaps;
+        }
         new_map[tensor_storage.name] = std::move(tensor_storage);
     }
     tensor_storage_map_.swap(new_map);
+    if (swiglu_half_swaps > 0) {
+        LOG_DEBUG("marked %zu MiniMax-H3 diffusers SwiGLU tensors for half swap", swiglu_half_swaps);
+    }
 }
 
 bool ModelLoader::init_from_file_and_convert_name(const std::string& file_path, const std::string& prefix, SDVersion version) {
@@ -1719,6 +1741,19 @@ bool ModelLoader::load_tensors(on_new_tensor_cb_t on_new_tensor_cb, int n_thread
                         i64_to_i32_vec(reinterpret_cast<int64_t*>(read_buf), reinterpret_cast<int32_t*>(target_buf), tensor_storage.nelements());
                     }
 
+                    if (tensor_storage.swap_swiglu_halves) {
+                        const size_t total = static_cast<size_t>(tensor_storage.nbytes());
+                        if (total % 2 == 0 && target_buf != nullptr) {
+                            const size_t half = total / 2;
+                            std::vector<uint8_t> tmp(target_buf, target_buf + half);
+                            std::memmove(target_buf, target_buf + half, half);
+                            std::memcpy(target_buf + half, tmp.data(), half);
+                        } else {
+                            LOG_WARN("tensor half swap skipped for '%s': odd byte size %zu",
+                                     tensor_storage.name.c_str(), total);
+                        }
+                    }
+
                     if (tensor_storage.type != dst_tensor->type) {
                         if (convert_buf == nullptr) {
                             failed = true;
diff --git a/src/dit_models/pipelines/minimax_h3_pipeline.cpp b/src/dit_models/pipelines/minimax_h3_pipeline.cpp
index 6b85dee..5c807d1 100644
--- a/src/dit_models/pipelines/minimax_h3_pipeline.cpp
+++ b/src/dit_models/pipelines/minimax_h3_pipeline.cpp
@@ -549,6 +549,21 @@ bool MiniMaxH3Pipeline::prepare(const ed_context_params_t& params,
     diffusion_->alloc_params_buffer();
     diffusion_->get_param_tensors(registry.tensors(), "model.diffusion_model");
 
+    const std::string rope_inv_freq_name = "model.diffusion_model.rope.inv_freq";
+    if (loader.get_tensor_storage_map().find(rope_inv_freq_name) == loader.get_tensor_storage_map().end()) {
+        auto rope_it = registry.tensors().find(rope_inv_freq_name);
+        if (rope_it == registry.tensors().end() || rope_it->second == nullptr) {
+            return set_minimax_error(error, "MiniMax-H3 RoPE parameter was not allocated");
+        }
+        ggml_tensor* rope_inv_freq = rope_it->second;
+        std::vector<float> values(static_cast<size_t>(rope_inv_freq->ne[0]));
+        for (size_t i = 0; i < values.size(); ++i) {
+            values[i] = static_cast<float>(std::pow(10000.0, -static_cast<double>(i) / values.size()));
+        }
+        ggml_backend_tensor_set(rope_inv_freq, values.data(), 0, values.size() * sizeof(float));
+        LOG_INFO("MiniMax-H3 synthesized missing rope.inv_freq (%zu values)", values.size());
+    }
+
     const bool text_offload = runtime.clip_offload_params_to_cpu();
     String2TensorStorage conditioner_tensors = loader.get_tensor_storage_map();
     const std::regex language_layer_pattern(R"(^text_encoders\.llm\.model\.layers\.(\d+)\.)");
diff --git a/src/utils/model_io/convert.cpp b/src/utils/model_io/convert.cpp
index 7efc4d3..5308dee 100644
--- a/src/utils/model_io/convert.cpp
+++ b/src/utils/model_io/convert.cpp
@@ -1,4 +1,5 @@
 #include <cstring>
+#include <filesystem>
 #include <map>
 #include <mutex>
 #include <regex>
@@ -159,7 +160,15 @@ bool convert(const char* input_path,
              const char* imatrix_path) {
     ModelLoader model_loader;
 
-    if (!model_loader.init_from_file(input_path)) {
+    std::string input_prefix;
+    std::string normalized_input = input_path != nullptr ? input_path : "";
+    std::replace(normalized_input.begin(), normalized_input.end(), '\\', '/');
+    if (contains(normalized_input, "/transformer/") &&
+        contains(std::filesystem::path(normalized_input).filename().string(), "diffusion_pytorch_model")) {
+        input_prefix = "model.diffusion_model.";
+    }
+
+    if (!model_loader.init_from_file(input_path, input_prefix)) {
         LOG_ERROR("init model loader from file failed: '%s'", input_path);
         return false;
     }
diff --git a/src/utils/model_io/tensor_storage.h b/src/utils/model_io/tensor_storage.h
index 89784b2..e5ef25f 100644
--- a/src/utils/model_io/tensor_storage.h
+++ b/src/utils/model_io/tensor_storage.h
@@ -25,6 +25,7 @@ struct TensorStorage {
     // engine (and BFL checkpoints) expect [scale, shift]; when set, the two halves
     // of dim0 are swapped at load time. See ModelLoader::convert_tensors_name.
     bool swap_scale_shift   = false;
+    bool swap_swiglu_halves = false;
     int64_t ne[ED_MAX_DIMS] = {1, 1, 1, 1, 1};
     int n_dims              = 0;
 

From ad0e04cfc6d32a76f8ee6e65f129f6b1247c0c74 Mon Sep 17 00:00:00 2001
From: Komorebi623 <wang-ty22@mails.tsinghua.edu.cn>
Date: Fri, 14 Aug 2026 13:22:34 +0800
Subject: [PATCH 22/25] Tune MiniMax H3 runtime and full-reference loading

- Support complete Ref2VA weight layouts and improve MiniMax-H3 tensor mapping and conditioning.\n- Scope cuDNN SDPA and transposed-convolution acceleration to validated MiniMax-H3 operations.\n- Improve residency and auto-fit accounting for DiT, Qwen3-VL, video VAE, and audio VAE.\n- Refine SM90 Q8/Q4 projection routing through the updated ggml submodule.\n- Update the CLI and core MiniMax-H3 usage, model, and memory documentation.
---
 README.md                                     |  11 +-
 docs/cli.md                                   |  24 +++-
 docs/minimax-h3.md                            | 135 ++++++++++++++----
 docs/models.md                                |  11 +-
 examples/cli/main.cpp                         |   5 +-
 .../cuDNN/ed_cudnn_conv_transpose_1d.cu       |  13 +-
 src/core/backend/cuDNN/ed_cudnn_sdpa.cu       |  14 +-
 src/core/backend/ggml/ggml_extend.hpp         |  20 ++-
 src/core/runtime/model_runtime.cpp            |  17 ++-
 src/core/runtime/model_runtime.hpp            |   5 +-
 .../autoencoders/minimax_h3_audio_vae.hpp     |   1 +
 .../autoencoders/minimax_h3_vae.hpp           |   9 +-
 src/dit_models/models/minimax_h3_full.hpp     |  72 ++++++++--
 .../pipelines/minimax_h3_pipeline.cpp         |  54 ++++++-
 third_party/ggml                              |   2 +-
 15 files changed, 318 insertions(+), 75 deletions(-)

diff --git a/README.md b/README.md
index 18b9118..9d73add 100644
--- a/README.md
+++ b/README.md
@@ -25,7 +25,7 @@ edge-dit.cpp is a lightweight, DiT-first C/C++ inference engine designed for loc
 
 - **Unified across tasks and model families**
   - **Text-to-image**, **image editing**, and **video generation** in one runtime
-  - SD3/SD3.5, FLUX.1, FLUX.1-Kontext, Qwen-Image, Qwen-Image-Edit, and Wan 2.1
+  - SD3/SD3.5, FLUX.1, FLUX.1-Kontext, Qwen-Image, Qwen-Image-Edit, Wan 2.1, and MiniMax-H3 video+audio
   - **Few-step distilled models** auto-detected — Turbo / Lightning / schnell default to a **4–8 step** schedule
   - Shared **C API, CLI, HTTP server, and Python** interfaces across every family
 
@@ -70,6 +70,7 @@ current support commitment unless documented in
 | **Qwen-Image** | Text-to-image | `Qwen/Qwen-Image` | Qwen-Image Lightning *(LoRA)* | Supported |
 | **Qwen-Image-Edit** | Image editing | `Qwen/Qwen-Image-Edit` | Qwen-Image-Edit Lightning *(LoRA)* | Supported |
 | **Wan 2.1** | Video generation | `Wan-AI/Wan2.1-T2V-1.3B` (and 14B) | Wan2.1-T2V-1.3B Distill | Supported (Vulkan still optimizing) |
+| **MiniMax-H3** | Video + audio generation | FL2VA / Ref2VA component checkpoints | — | Supported (CUDA validated) |
 
 Distilled checkpoints load through the same pipeline as the base model and are
 **auto-detected** (default **4–8 steps** when `--steps` is unset). Most ship as
@@ -148,6 +149,14 @@ Load time follows each runtime's reported initialization boundary and may
 reflect different weight materialization or memory-mapping strategies.
 Generation latency is the primary cross-runtime performance metric.
 
+MiniMax-H3 has a separate 124-frame H200 benchmark because it generates video
+and audio rather than one image. With persistent weights, Edge FL2VA T2VA takes
+`71s` at BF16, `81.1s` at Q8_0, and `73.6s` at Q4_K_M; corresponding peaks are
+`125,051`, `71,393`, and `47,459 MiB`. `--auto-fit` was validated from 120 GB
+down to a 24 GB cap, with observed peaks below every requested budget. See
+[MiniMax-H3 usage and performance](docs/minimax-h3.md) for all four FL2VA modes,
+Ref2VA inputs, memory placement, and framework-comparison links.
+
 ## Open-Source Interfaces
 
 edge-dit.cpp exposes the same runtime through several public integration
diff --git a/docs/cli.md b/docs/cli.md
index 7dce552..53dfe8c 100644
--- a/docs/cli.md
+++ b/docs/cli.md
@@ -360,6 +360,7 @@ Memory-oriented flags:
 --vae-offload
 --max-vram <GB>
 --auto-allocate
+--auto-fit
 ```
 
 `--vae-tiling` is tri-state `on|off|auto` and defaults to `auto`, which enables
@@ -395,6 +396,27 @@ requested resolution (`-W`/`-H`, and `--frames` for video) to size the resident
 headroom, so pass the generation size you intend to use. Without a size it falls
 back to a conservative fixed headroom.
 
+MiniMax-H3 applies this policy to four independently placeable components: DiT,
+Qwen3-VL, video VAE, and audio VAE. Its measurement graph conservatively includes
+mixed image, video, paired-audio, and additional-audio conditioning, so the same
+placement remains valid across FL2VA and Ref2VA workflows. The MiniMax-H3 video
+VAE also keeps its model-specific fixed `16x16` tiling regardless of the generic
+`--vae-tiling`/`--vae-tile-size` values.
+
+```bash
+# MiniMax-H3 Q8_0 under a 40 GiB hard placement budget.
+./build-cuda/bin/ed-cli --video \
+  --diffusion-model /path/to/minimax_h3_fl2va-diffusers-Q8_0.gguf \
+  --vae /path/to/minimax_h3_video_vae_fp16.safetensors \
+  --audio-vae /path/to/minimax_h3_audio_vae_fp32.safetensors \
+  --llm /path/to/qwen3vl_32b_minimax_h3-Q8_0.gguf \
+  --auto-fit --max-vram 40 --vae-tiling auto \
+  -W 864 -H 480 --video-frames 124 --fps 24 --steps 20 \
+  --cfg-scale 1 --diffusion-fa --rng cpu \
+  --prompt "A cinematic sunset over layered mountain ridges." \
+  --video-format mp4 --output minimax-h3-autofit.mp4
+```
+
 ```bash
 # Fully automatic under an 8 GiB budget — system picks DiT quant + placement.
 ./build-cuda/bin/ed-cli \
@@ -651,4 +673,4 @@ See [API and bindings](api.md) for HTTP endpoints and curl examples.
 - [performance (RTX 4090)](performance-4090.md)
 - [performance (H200)](performance-H200.md)
 - [API and bindings](api.md)
-- [Development and contributing](development.md)
\ No newline at end of file
+- [Development and contributing](development.md)
diff --git a/docs/minimax-h3.md b/docs/minimax-h3.md
index f793ab8..9fd81fb 100644
--- a/docs/minimax-h3.md
+++ b/docs/minimax-h3.md
@@ -28,25 +28,33 @@ Supported modes:
 |---|---|---|
 | T2VA | Text prompt | Video + audio |
 | I2VA | Text prompt + first frame image | Video + audio |
+| L2VA | Text prompt + last frame image | Video + audio |
 | FL2VA | Text prompt + first frame image + last frame image | Video + audio |
 
 ### Ref2VA checkpoint
 
 | Component | File name | Source |
 |---|---|---|
-| Diffusion model | `minimax_h3_ref2va_pruned-Q4_K_M.gguf` | [leejet/MiniMax-H3-GGUF](https://huggingface.co/leejet/MiniMax-H3-GGUF) |
+| Diffusion model | `minimax_h3_ref2va-Q4_K_M.gguf` | [leejet/MiniMax-H3-GGUF](https://huggingface.co/leejet/MiniMax-H3-GGUF) |
+
+Use the complete `minimax_h3_ref2va-Q4_K_M.gguf` for quality comparisons. The
+smaller `minimax_h3_ref2va-Q4_K_M.gguf` is loadable, but it is a pruned
+checkpoint and is not directly comparable with the official full Ref2VA DiT.
 
 Supported reference inputs:
 
 | Input | CLI flag | Notes |
 |---|---|---|
 | Reference image | `--ref-image <image>` | Repeatable. Presented as `<Picture N>` to Qwen3-VL. |
-| Reference video | `--ref-video <frame-dir>` | Repeatable. Directory of image frames sorted lexicographically; treated as 24 fps. |
-| Paired video audio | `--ref-video-audio <wav>` | Repeatable. The Nth WAV is paired with the Nth `--ref-video`. |
-| Standalone audio | `--ref-audio <wav>` | Repeatable. Independent audio reference, not attached to a video. |
+| Reference video | `--ref-video <path>` | Repeatable. Accepts a frame directory or `mp4`/`mov`/`mkv`/`webm`/`avi`; media files are decoded at 24 fps with `ffmpeg`. |
+| Paired video audio | `--ref-video-audio <wav>` | Repeatable. The Nth WAV replaces/sets audio for the Nth `--ref-video`. Without it, an input media file's embedded audio is extracted automatically. |
+| Additional audio | `--ref-audio <wav>` | Repeatable, but must be combined with at least one reference image or video. Audio-only Ref2VA requests are rejected. |
 
-The reference inputs can be combined freely within Ref2VA. Ref2VA cannot be used
-with `--image` or `--end-img` in the same request.
+Reference images, videos, paired video audio, and additional audio can be mixed.
+Flags preserve command-line order. `--ref-video-audio` entries map positionally
+to the leading `--ref-video` entries, so keep each video and its explicit WAV in
+the same order. Ref2VA references cannot be combined with `--init-img`/`--image`
+or `--end-img` in the same request.
 
 MiniMax-H3 control frames are not supported for either checkpoint.
 
@@ -92,7 +100,7 @@ ed-cli --video \
   --vae minimax_h3_video_vae_fp16.safetensors \
   --audio-vae minimax_h3_audio_vae_fp32.safetensors \
   --llm qwen3vl_32b_minimax_h3-Q4_K_M.gguf \
-  --image first_frame.png \
+  --init-img first_frame.png \
   -p "Animate the provided first frame into a cinematic shot with matching sound." \
   --cfg-scale 1 -W 864 -H 480 --fps 24 --video-frames 56 --steps 20 \
   --diffusion-fa --rng cpu --video-format mp4 \
@@ -124,7 +132,7 @@ adherence easier to evaluate and avoids text-only prompts dominating the output.
 
 ```bash
 ed-cli --video \
-  --diffusion-model minimax_h3_ref2va_pruned-Q4_K_M.gguf \
+  --diffusion-model minimax_h3_ref2va-Q4_K_M.gguf \
   --vae minimax_h3_video_vae_fp16.safetensors \
   --audio-vae minimax_h3_audio_vae_fp32.safetensors \
   --llm qwen3vl_32b_minimax_h3-Q4_K_M.gguf \
@@ -139,7 +147,7 @@ ed-cli --video \
 
 ```bash
 ed-cli --video \
-  --diffusion-model minimax_h3_ref2va_pruned-Q4_K_M.gguf \
+  --diffusion-model minimax_h3_ref2va-Q4_K_M.gguf \
   --vae minimax_h3_video_vae_fp16.safetensors \
   --audio-vae minimax_h3_audio_vae_fp32.safetensors \
   --llm qwen3vl_32b_minimax_h3-Q4_K_M.gguf \
@@ -154,7 +162,7 @@ ed-cli --video \
 
 ```bash
 ed-cli --video \
-  --diffusion-model minimax_h3_ref2va_pruned-Q4_K_M.gguf \
+  --diffusion-model minimax_h3_ref2va-Q4_K_M.gguf \
   --vae minimax_h3_video_vae_fp16.safetensors \
   --audio-vae minimax_h3_audio_vae_fp32.safetensors \
   --llm qwen3vl_32b_minimax_h3-Q4_K_M.gguf \
@@ -166,26 +174,11 @@ ed-cli --video \
   -o minimax_h3_ref_video_audio.mp4
 ```
 
-### Standalone reference audio
-
-```bash
-ed-cli --video \
-  --diffusion-model minimax_h3_ref2va_pruned-Q4_K_M.gguf \
-  --vae minimax_h3_video_vae_fp16.safetensors \
-  --audio-vae minimax_h3_audio_vae_fp32.safetensors \
-  --llm qwen3vl_32b_minimax_h3-Q4_K_M.gguf \
-  --ref-audio reference_audio.wav \
-  -p "Generate a video with audio inspired by <Audio 1>." \
-  --cfg-scale 1 -W 864 -H 480 --fps 24 --video-frames 56 --steps 20 \
-  --diffusion-fa --rng cpu --video-format mp4 \
-  -o minimax_h3_ref_audio.mp4
-```
-
 ### Mixed references
 
 ```bash
 ed-cli --video \
-  --diffusion-model minimax_h3_ref2va_pruned-Q4_K_M.gguf \
+  --diffusion-model minimax_h3_ref2va-Q4_K_M.gguf \
   --vae minimax_h3_video_vae_fp16.safetensors \
   --audio-vae minimax_h3_audio_vae_fp32.safetensors \
   --llm qwen3vl_32b_minimax_h3-Q4_K_M.gguf \
@@ -203,12 +196,92 @@ In a mixed prompt, paired video audio is presented before the video as `<Audio 1
 Standalone `--ref-audio` entries are numbered after video-paired audio, so the
 first standalone audio in the example is `<Audio 2>`.
 
+## Memory placement
+
+MiniMax-H3 supports the regular component offload flags:
+
+```text
+--dit-offload
+--text-encoder-offload
+--vae-offload
+--vae-tiling on|off|auto
+```
+
+For automatic placement, pass `--auto-fit --max-vram <GB>`. The runtime measures
+a conservative Ref2VA mixed-conditioning graph at the requested width, height,
+and frame count, then independently places the DiT, Qwen3-VL, video VAE, and
+audio VAE. `--max-vram` is a hard placement budget under `--auto-fit`; components
+that do not fit are segmented and staged from host memory while CUDA remains the
+compute backend.
+
+```bash
+ed-cli --video \
+  --diffusion-model minimax_h3_fl2va-diffusers-Q8_0.gguf \
+  --vae minimax_h3_video_vae_fp16.safetensors \
+  --audio-vae minimax_h3_audio_vae_fp32.safetensors \
+  --llm qwen3vl_32b_minimax_h3-Q8_0.gguf \
+  --auto-fit --max-vram 40 --vae-tiling auto \
+  -W 864 -H 480 --video-frames 124 --fps 24 --steps 20 \
+  --cfg-scale 1 --diffusion-fa --rng cpu \
+  -p "A cinematic sunset over layered mountain ridges." \
+  --video-format mp4 -o minimax_h3_autofit.mp4
+```
+
+The explicit offload flags remain useful when placement must be fixed manually.
+Do not combine them merely to emulate `--auto-fit`; automatic placement normally
+chooses a safer component combination for the requested budget.
+
+MiniMax-H3's video VAE always uses its model-specific fixed `16x16` spatial
+tiling path. This intentionally overrides the generic `--vae-tiling` state and
+`--vae-tile-size`; those flags continue to control other VAE implementations.
+The internal override can be disabled only with the diagnostic environment
+variable `ED_MINIMAX_H3_DISABLE_FORCED_VAE_TILING=1`, which is not recommended
+for normal generation.
+
+## H200 performance
+
+The following Edge measurements use CUDA on one H200, `864x480`, 124 frames,
+24 fps, 20 steps, CFG 1, CPU RNG, seed `424242`, resident components, and warmed
+model files. Wall time includes load, generation, mux/save, and cleanup.
+
+| Precision | T2VA | I2VA | L2VA | FL2VA |
+|---|---:|---:|---:|---:|
+| BF16 wall / peak VRAM | 71s / 125,051 MiB | 73s / 125,251 MiB | 81s / 125,247 MiB | 76s / 125,471 MiB |
+| Q8_0 wall / peak VRAM | 81.1s / 71,393 MiB | 84.5s / 71,585 MiB | 84.6s / 71,583 MiB | 90.0s / 71,805 MiB |
+| Q4_K_M wall / peak VRAM | 73.6s / 47,459 MiB | 73.1s / 47,609 MiB | 73.0s / 47,607 MiB | 76.7s / 47,785 MiB |
+
+Use persistent GGUF files for Q8/Q4 production runs. Loading official BF16
+shards with `--tensor-type-rules ...=q8_0` performs quantization on every start;
+in the measured FL2VA run that increased load from about 9.3s to about 45s.
+On SM90, the optimized MiniMax-H3 route applies only to named main-block QKV/FC1
+projections; it does not alter unrelated models.
+
+`--auto-fit` was also validated with the same Q8_0 components at two sampling
+steps. Every observed peak stayed below its requested cap:
+
+| `--max-vram` | DiT | Qwen3-VL | Video/Audio VAE | Peak VRAM | Wall |
+|---:|---|---|---|---:|---:|
+| 120 GB | resident | resident | resident / resident | 71,397 MiB | 28.7s |
+| 60 GB | resident | offloaded | offloaded / offloaded | 45,129 MiB | 39.8s |
+| 40 GB | offloaded | offloaded | resident / resident | 31,699 MiB | 46.5s |
+| 24 GB | offloaded | offloaded | offloaded / offloaded | 18,337 MiB | 50.6s |
+
+The 40 GB configuration additionally passed FL2VA first+last-frame conditioning
+at 31,865 MiB. A Ref2VA mixed image+video+paired-audio+additional-audio run passed
+at a 60 GB budget with a 49,361 MiB peak. Full framework comparisons are in the
+[BF16 benchmark](optimization/minimax-h3-fl2va-ref2va-edge-sdcpp-diffusers-h200-bf16-full-ref-2026-08-13.md),
+[framework-native 8-bit benchmark](optimization/minimax-h3-fl2va-ref2va-edge-sdcpp-diffusers-h200-8bit-full-ref-2026-08-13.md),
+and [Q4 benchmark](optimization/minimax-h3-fl2va-ref2va-edge-sdcpp-diffusers-h200-q4-full-ref-2026-08-14.md).
+
 ## Current limitations
 
-- Ref2VA behavior is functional but still under quality alignment with
-  `stable-diffusion.cpp`; matching seeds do not yet imply matching generated
-  videos.
-- Video reference conditioning can be strong. Use explicit prompts and visually
-  inspect whether the output is following the intended reference semantics.
+- Audio-only Ref2VA is intentionally rejected; `--ref-audio` needs at least one
+  `--ref-image` or `--ref-video`.
+- Matching seeds across Edge, sd.cpp, and Diffusers do not guarantee identical
+  videos because their quantization and numerical kernels differ.
+- Reference adherence remains prompt dependent. Mention `<Picture N>`,
+  `<Video N>`, and `<Audio N>` explicitly and visually inspect the result.
+- Media-file `--ref-video` decoding and embedded-audio extraction require
+  `ffmpeg`; use a frame directory plus `--ref-video-audio` when it is unavailable.
 - Audio reference effects are easiest to judge with listening tests; contact
   sheets only validate the video stream.
diff --git a/docs/models.md b/docs/models.md
index 3b54599..1c736da 100644
--- a/docs/models.md
+++ b/docs/models.md
@@ -18,6 +18,7 @@ support commitment.
 | Qwen-Image | Text-to-image | [`Qwen/Qwen-Image`](https://huggingface.co/Qwen/Qwen-Image) | Diffusers-style directory or components | CUDA first, CPU/Vulkan functional, Metal experimental | Supported |
 | Qwen-Image-Edit | Image editing | [`Qwen/Qwen-Image-Edit`](https://huggingface.co/Qwen/Qwen-Image-Edit) | Diffusers-style directory or components | CUDA first, CPU/Vulkan functional, Metal experimental | Supported |
 | Wan 2.1 | Video generation | [`Wan-AI/Wan2.1-T2V-1.3B-Diffusers`](https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers) (and Wan2.1-T2V-14B-Diffusers) | Diffusers-style directory or components | CUDA first, CPU functional for validation, Metal/Vulkan experimental | Supported (Vulkan still optimizing) |
+| MiniMax-H3 | Video + audio generation | [`MiniMaxAI/MiniMax-H3`](https://huggingface.co/MiniMaxAI/MiniMax-H3), [`Comfy-Org/MiniMax-H3`](https://huggingface.co/Comfy-Org/MiniMax-H3), and [`leejet/MiniMax-H3-GGUF`](https://huggingface.co/leejet/MiniMax-H3-GGUF) | Standalone DiT + Qwen3-VL + video VAE + optional audio VAE | CUDA validated; other backends not performance-qualified | Supported |
 
 Backend availability means the runtime can be built for that backend. Model
 quality, memory use, and speed are workload dependent and should be validated
@@ -135,9 +136,13 @@ Command example: [Qwen-Image-Edit CLI](cli.md#qwen-image-edit).
 
 Wan video generation uses `--video`, `--frames`, and `--fps`.
 
-MiniMax-H3 video + audio generation supports text, first-frame, first+last-frame,
-and Ref2VA conditioning through standalone component loading. See
-[MiniMax-H3 usage](minimax-h3.md).
+MiniMax-H3 video + audio generation supports text, first-frame, last-frame,
+first+last-frame, and Ref2VA conditioning through standalone component loading.
+Ref2VA accepts repeatable images, frame directories or media files, paired or
+embedded video audio, and additional audio (additional audio cannot be used by
+itself). Both checkpoints support `--auto-fit --max-vram`; placement covers the
+DiT, Qwen3-VL, video VAE, and audio VAE. See [MiniMax-H3 usage and H200
+performance](minimax-h3.md).
 
 Supported output formats are `auto`, `avi`, `mp4`, `mov`, `mkv`, and `webm`.
 The CLI uses `ED_FFMPEG` when set and can also find imageio-ffmpeg binaries in
diff --git a/examples/cli/main.cpp b/examples/cli/main.cpp
index c5e1048..9ad243c 100644
--- a/examples/cli/main.cpp
+++ b/examples/cli/main.cpp
@@ -90,7 +90,8 @@ static void print_usage(const char* prog) {
         "Options:\n"
         "  --video, -M vid_gen       Generate video frames instead of an image\n"
         "  --video-format <fmt>      Video format: auto, avi, mp4, mov, mkv, webm. Default: auto\n"
-        "  -i, --image <path>        Input/reference image for image-edit models\n"
+        "  -i, --image, --init-img <path>  Input image or MiniMax-H3 first frame\n"
+        "  --end-img <path>          MiniMax-H3 last-frame image\n"
         "  --diffusion-model <path>  Standalone DiT transformer weights\n"
         "  --vae <path>              Standalone VAE weights\n"
         "  --audio-vae <path>        Standalone audio VAE weights (MiniMax-H3)\n"
@@ -108,7 +109,7 @@ static void print_usage(const char* prog) {
         "  --ref-video <path>        MiniMax-H3 Ref2VA reference video frames directory or media file; repeatable\n"
         "                            Media files are decoded with ffmpeg; embedded audio is paired automatically\n"
         "  --ref-video-audio <path>  WAV soundtrack paired with the corresponding --ref-video\n"
-        "  --ref-audio <path>        Standalone MiniMax-H3 Ref2VA WAV audio reference; repeatable\n"
+        "  --ref-audio <path>        Additional MiniMax-H3 Ref2VA WAV; repeatable; requires an image/video reference\n"
         "  --steps <int>             Sampling steps, default: 20\n"
         "  -s, --seed <int64>        Seed, default: -1\n"
         "  -t, --threads <int>       Thread count, default: 0\n"
diff --git a/src/core/backend/cuDNN/ed_cudnn_conv_transpose_1d.cu b/src/core/backend/cuDNN/ed_cudnn_conv_transpose_1d.cu
index a417244..c23f185 100644
--- a/src/core/backend/cuDNN/ed_cudnn_conv_transpose_1d.cu
+++ b/src/core/backend/cuDNN/ed_cudnn_conv_transpose_1d.cu
@@ -4,6 +4,7 @@
 #include <cudnn.h>
 
 #include <cstdlib>
+#include <cstring>
 #include <memory>
 #include <mutex>
 #include <unordered_map>
@@ -42,20 +43,26 @@ struct workspace {
 std::mutex g_workspace_mutex;
 std::unordered_map<workspace_key, std::unique_ptr<workspace>, workspace_key_hash> g_workspaces;
 
-static bool enabled() {
+static bool explicitly_enabled() {
     static const bool value = [] {
         const char * env = getenv("ED_CUDNN_CONV_TRANSPOSE_1D");
-        return env == nullptr || env[0] == '\0' || atoi(env) != 0;
+        return env != nullptr && env[0] != '\0' && atoi(env) != 0;
     }();
     return value;
 }
 
+static bool enabled(const ggml_tensor * dst) {
+    return explicitly_enabled() ||
+           (dst != nullptr &&
+            std::strcmp(dst->name, "minimax_h3.audio_vae.conv_transpose_1d") == 0);
+}
+
 static bool contiguous(const ggml_tensor * tensor) {
     return ggml_is_contiguous(tensor);
 }
 
 static bool supported(const ggml_tensor * dst, int & stride) {
-    if (!enabled() || dst == nullptr || dst->op != GGML_OP_CONV_TRANSPOSE_1D ||
+    if (!enabled(dst) || dst == nullptr || dst->op != GGML_OP_CONV_TRANSPOSE_1D ||
         dst->src[0] == nullptr || dst->src[1] == nullptr) {
         return false;
     }
diff --git a/src/core/backend/cuDNN/ed_cudnn_sdpa.cu b/src/core/backend/cuDNN/ed_cudnn_sdpa.cu
index 0f3107f..0ff7602 100644
--- a/src/core/backend/cuDNN/ed_cudnn_sdpa.cu
+++ b/src/core/backend/cuDNN/ed_cudnn_sdpa.cu
@@ -52,6 +52,7 @@ struct ed_cudnn_sdpa_key {
     float attn_scale = 0.0f;
     bool padding_mask = false;
     bool allow_short_kv_cross_attn = false;
+    bool allow_short_f16_self_attn = false;
     int64_t q_stride[4] = {};
     int64_t k_stride[4] = {};
     int64_t v_stride[4] = {};
@@ -61,6 +62,7 @@ struct ed_cudnn_sdpa_key {
         return device == other.device && io_type == other.io_type && dst_type == other.dst_type && b == other.b && h == other.h && sq == other.sq && sk == other.sk &&
                sk_actual == other.sk_actual && d == other.d && attn_scale == other.attn_scale && padding_mask == other.padding_mask &&
                allow_short_kv_cross_attn == other.allow_short_kv_cross_attn &&
+               allow_short_f16_self_attn == other.allow_short_f16_self_attn &&
                std::memcmp(q_stride, other.q_stride, sizeof(q_stride)) == 0 &&
                std::memcmp(k_stride, other.k_stride, sizeof(k_stride)) == 0 &&
                std::memcmp(v_stride, other.v_stride, sizeof(v_stride)) == 0 &&
@@ -87,6 +89,7 @@ struct ed_cudnn_sdpa_key_hash {
         mix(scale_bits);
         mix(key.padding_mask ? 1 : 0);
         mix(key.allow_short_kv_cross_attn ? 1 : 0);
+        mix(key.allow_short_f16_self_attn ? 1 : 0);
         for (int i = 0; i < 4; ++i) {
             mix(key.q_stride[i]);
             mix(key.k_stride[i]);
@@ -204,7 +207,7 @@ static bool cudnn_sdpa_wan_sp_cross_attn_enabled() {
 }
 
 static bool cudnn_sdpa_short_f16_self_attn_enabled() {
-    static const bool enabled = env_flag_enabled_or_default("ED_CUDNN_SDPA_SHORT_F16_SELF_ATTN", true);
+    static const bool enabled = env_flag_enabled_or_default("ED_CUDNN_SDPA_SHORT_F16_SELF_ATTN", false);
     return enabled;
 }
 
@@ -360,6 +363,11 @@ static bool is_wan_sp_cross_attn_tensor(const ggml_tensor * dst) {
            std::strstr(dst->name, "_cross_attn") != nullptr;
 }
 
+static bool is_minimax_h3_short_f16_self_attn_tensor(const ggml_tensor * dst) {
+    return dst != nullptr &&
+           std::strcmp(dst->name, "minimax_h3.vae.short_f16_self_attn") == 0;
+}
+
 static void log_unsupported_shape(const char * reason, const ggml_tensor * q, const ggml_tensor * k, const ggml_tensor * v, const ggml_tensor * dst, const ggml_tensor * mask) {
     if (!profile_enabled()) {
         return;
@@ -476,6 +484,7 @@ static bool make_key(const ggml_tensor * dst, ed_cudnn_sdpa_key & key, int devic
     key.attn_scale = attn_scale;
     key.padding_mask = padding_mask;
     key.allow_short_kv_cross_attn = is_wan_sp_cross_attn_tensor(dst);
+    key.allow_short_f16_self_attn = is_minimax_h3_short_f16_self_attn_tensor(dst);
 
     // cuDNN logical dim is [B,H,S,D]. The current ggml attention inputs are contiguous [D,S,H].
     key.q_stride[0] = h * sq * d;
@@ -531,6 +540,7 @@ static bool make_self_attn_key(int device,
     key.attn_scale = attn_scale;
     key.padding_mask = false;
     key.allow_short_kv_cross_attn = false;
+    key.allow_short_f16_self_attn = false;
 
     key.q_stride[0] = h * seq * d;
     key.q_stride[1] = seq * d;
@@ -620,7 +630,7 @@ static bool should_use_cudnn_sdpa(const ed_cudnn_sdpa_key & key) {
                                          ((key.sq == key.sk && !key.padding_mask) ||
                                           (key.padding_mask && key.sk_actual == key.sq && key.sk >= key.sq));
     const bool supported_short_f16_self_sequence =
-        cudnn_sdpa_short_f16_self_attn_enabled() &&
+        (key.allow_short_f16_self_attn || cudnn_sdpa_short_f16_self_attn_enabled()) &&
         key.io_type == GGML_TYPE_F16 &&
         key.sq >= 1024 &&
         ((key.sq == key.sk && !key.padding_mask) ||
diff --git a/src/core/backend/ggml/ggml_extend.hpp b/src/core/backend/ggml/ggml_extend.hpp
index 90e9580..50438e9 100644
--- a/src/core/backend/ggml/ggml_extend.hpp
+++ b/src/core/backend/ggml/ggml_extend.hpp
@@ -1711,7 +1711,8 @@ __STATIC_INLINE__ bool ggml_ext_prefer_cudnn_sdpa_unpadded(ggml_backend_t backen
                                                           int64_t L_q,
                                                           int64_t L_k,
                                                           int64_t d_head,
-                                                          ggml_tensor* mask) {
+                                                          ggml_tensor* mask,
+                                                          bool allow_short_f16_self_attn = false) {
 #ifdef ED_ENABLE_CUDNN_SDPA
     if (mask != nullptr ||
         !sd_backend_is(backend, "CUDA") ||
@@ -1723,7 +1724,8 @@ __STATIC_INLINE__ bool ggml_ext_prefer_cudnn_sdpa_unpadded(ggml_backend_t backen
     const bool supported_head_dim = d_head == 64 || d_head == 128;
     const bool supported_long_self_attn = L_q == L_k && L_q >= 4096;
     const bool supported_short_f16_self_attn =
-        ggml_ext_env_flag_enabled_or_default("ED_CUDNN_SDPA_SHORT_F16_SELF_ATTN", true) &&
+        (allow_short_f16_self_attn ||
+         ggml_ext_env_flag_enabled_or_default("ED_CUDNN_SDPA_SHORT_F16_SELF_ATTN", false)) &&
         L_q == L_k &&
         L_q >= 1024;
     return supported_head_dim && (supported_long_self_attn || supported_short_f16_self_attn);
@@ -1733,6 +1735,7 @@ __STATIC_INLINE__ bool ggml_ext_prefer_cudnn_sdpa_unpadded(ggml_backend_t backen
     ED_UNUSED(L_k);
     ED_UNUSED(d_head);
     ED_UNUSED(mask);
+    ED_UNUSED(allow_short_f16_self_attn);
     return false;
 #endif
 }
@@ -1756,7 +1759,8 @@ __STATIC_INLINE__ ggml_tensor* ggml_ext_attention_ext(ggml_context* ctx,
                                                       bool v_is_seq_major = false,
                                                       int sage_layer_idx = -1,
                                                       int sage_total_layers = -1,
-                                                      bool allow_masked_flash_attn = false) {  // avoid overflow
+                                                      bool allow_masked_flash_attn = false,
+                                                      bool allow_short_cudnn_self_attn = false) {  // avoid overflow
     int64_t L_q;
     int64_t L_k;
     int64_t C;
@@ -1785,7 +1789,12 @@ __STATIC_INLINE__ ggml_tensor* ggml_ext_attention_ext(ggml_context* ctx,
         k = ggml_reshape_4d(ctx, k, d_head, n_kv_head, L_k, N);  // [N, L_k, n_kv_head, d_head]
         const bool will_pad_kv_for_flash_attn =
             pad_kv_for_flash_attn &&
-            !ggml_ext_prefer_cudnn_sdpa_unpadded(backend, L_q, L_k, d_head, mask) &&
+            !ggml_ext_prefer_cudnn_sdpa_unpadded(backend,
+                                                 L_q,
+                                                 L_k,
+                                                 d_head,
+                                                 mask,
+                                                 allow_short_cudnn_self_attn) &&
             L_k % 256 != 0;
         if (flash_attn && mask == nullptr && sd_backend_is(backend, "CUDA") && !will_pad_kv_for_flash_attn) {
             if (auto k_f16 = edgedit::ggml_ext::attention_v_prep_custom_f16(ctx, k, false)) {
@@ -1883,6 +1892,9 @@ __STATIC_INLINE__ ggml_tensor* ggml_ext_attention_ext(ggml_context* ctx,
         }
 
         auto out = ggml_flash_attn_ext(ctx, q_in, k_in, v_in, mask_in, scale / kv_scale, 0, 0);
+        if (allow_short_cudnn_self_attn) {
+            ggml_set_name(out, "minimax_h3.vae.short_f16_self_attn");
+        }
         ggml_flash_attn_ext_set_prec(out, GGML_PREC_F32);
         if (kv_scale != 1.0f) {
             out = ggml_ext_scale(ctx, out, 1.0f / kv_scale);
diff --git a/src/core/runtime/model_runtime.cpp b/src/core/runtime/model_runtime.cpp
index 3be15ca..535712c 100644
--- a/src/core/runtime/model_runtime.cpp
+++ b/src/core/runtime/model_runtime.cpp
@@ -467,13 +467,15 @@ bool ModelRuntime::plan_component_offload(const ::ModelLoader& loader,
 // resident components, minus compute headroom. Because graph_cut_segment_vram_bytes
 // already counts each segment's compute + weights + IO, this cap keeps
 // (resident + max_segment) within the effective budget. No-op outside auto-allocate.
-void ModelRuntime::finalize_auto_segment_budget(size_t effective_budget_bytes) {
+void ModelRuntime::finalize_auto_segment_budget(size_t effective_budget_bytes,
+                                                size_t additional_slack_bytes) {
     if (!auto_allocate_) {
         return;
     }
     size_t leftover = 0;
-    if (effective_budget_bytes > resident_bytes_total_ + kSegmentBudgetSlack) {
-        leftover = effective_budget_bytes - resident_bytes_total_ - kSegmentBudgetSlack;
+    const size_t reserved_slack = kSegmentBudgetSlack + additional_slack_bytes;
+    if (effective_budget_bytes > resident_bytes_total_ + reserved_slack) {
+        leftover = effective_budget_bytes - resident_bytes_total_ - reserved_slack;
     }
     // Floor: if the leftover is tiny (resident nearly filled the budget) an offloaded
     // component still needs *some* budget to segment against; use a 1 GB floor so a
@@ -483,10 +485,11 @@ void ModelRuntime::finalize_auto_segment_budget(size_t effective_budget_bytes) {
         leftover = kMinSegmentBudget;
     }
     max_graph_vram_bytes_ = leftover;
-    LOG_INFO("auto-allocate: segment budget = %.2f GB (effective %.2f GB - resident %.2f GB - headroom)",
+    LOG_INFO("auto-allocate: segment budget = %.2f GB (effective %.2f GB - resident %.2f GB - %.2f GB staging slack)",
              max_graph_vram_bytes_ / (1024.0 * 1024.0 * 1024.0),
              effective_budget_bytes / (1024.0 * 1024.0 * 1024.0),
-             resident_bytes_total_ / (1024.0 * 1024.0 * 1024.0));
+             resident_bytes_total_ / (1024.0 * 1024.0 * 1024.0),
+             reserved_slack / (1024.0 * 1024.0 * 1024.0));
 }
 
 void ModelRuntime::replan_dit_quant_for_budget(::ModelLoader& loader) {
@@ -608,9 +611,9 @@ size_t ModelRuntime::effective_budget_bytes() const {
 //
 // te_params_bytes is the TE's weight-buffer size (conditioner_->get_params_buffer_size()).
 // Resident TE (not offloaded) is untouched: we return the global value unchanged.
-size_t ModelRuntime::text_encoder_segment_budget(size_t te_params_bytes) const {
+size_t ModelRuntime::text_encoder_segment_budget(size_t te_params_bytes, bool component_offloaded) const {
     // Resident TE: no staging, keep the existing global budget (no behavior change).
-    if (!clip_offload_params_to_cpu()) {
+    if (!component_offloaded && !clip_offload_params_to_cpu()) {
         return max_graph_vram_bytes_;
     }
     if (te_params_bytes == 0) {
diff --git a/src/core/runtime/model_runtime.hpp b/src/core/runtime/model_runtime.hpp
index 0cbf491..94b79d3 100644
--- a/src/core/runtime/model_runtime.hpp
+++ b/src/core/runtime/model_runtime.hpp
@@ -160,7 +160,8 @@ class ModelRuntime final {
     // Call once after all components are decided: sets the graph VRAM budget for offloaded
     // components to (effective_budget - resident_total - compute headroom). No-op outside
     // auto-allocate. Resets the internal resident accumulator for the next model load.
-    void finalize_auto_segment_budget(size_t effective_budget_bytes);
+    void finalize_auto_segment_budget(size_t effective_budget_bytes,
+                                      size_t additional_slack_bytes = 0);
     void reset_auto_allocate_state() { resident_bytes_total_ = 0; any_component_offloaded_ = false; }
     // Hard-cap budget = min(user --max-vram, live free VRAM). If no --max-vram, = live free.
     // Used to seed the auto-allocate tally and finalize_auto_segment_budget. 0 if CPU backend.
@@ -169,7 +170,7 @@ class ModelRuntime final {
     // guaranteed below the TE's own weight size (te_params_bytes) so its graph-cut segments
     // don't collapse into one whole-TE stage (the OOM cause). Resident TE returns the global
     // budget unchanged. Pass conditioner_->get_params_buffer_size() as te_params_bytes.
-    size_t text_encoder_segment_budget(size_t te_params_bytes) const;
+    size_t text_encoder_segment_budget(size_t te_params_bytes, bool component_offloaded = false) const;
     // Target generation resolution for compute-buffer measurement (0 = unset).
     int fit_width() const { return fit_width_; }
     int fit_height() const { return fit_height_; }
diff --git a/src/dit_models/components/autoencoders/minimax_h3_audio_vae.hpp b/src/dit_models/components/autoencoders/minimax_h3_audio_vae.hpp
index 531ad95..a00b379 100644
--- a/src/dit_models/components/autoencoders/minimax_h3_audio_vae.hpp
+++ b/src/dit_models/components/autoencoders/minimax_h3_audio_vae.hpp
@@ -244,6 +244,7 @@ namespace Ops {
         ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* x) override {
             GGML_ASSERT(dilation == 1);
             x = ggml_conv_transpose_1d(ctx->ggml_ctx, params["weight"], x, stride, 0, dilation);
+            ggml_set_name(x, "minimax_h3.audio_vae.conv_transpose_1d");
             if (padding > 0) {
                 x = ggml_ext_slice(ctx->ggml_ctx, x, 0, padding, x->ne[0] - padding);
             }
diff --git a/src/dit_models/components/autoencoders/minimax_h3_vae.hpp b/src/dit_models/components/autoencoders/minimax_h3_vae.hpp
index 46f4568..47f4fc1 100644
--- a/src/dit_models/components/autoencoders/minimax_h3_vae.hpp
+++ b/src/dit_models/components/autoencoders/minimax_h3_vae.hpp
@@ -393,7 +393,14 @@ namespace MiniMaxH3VAE {
                                                          num_head,
                                                          nullptr,
                                                          true,
-                                                         ctx->flash_attn_enabled);
+                                                         ctx->flash_attn_enabled,
+                                                         1.0f,
+                                                         true,
+                                                         false,
+                                                         -1,
+                                                         -1,
+                                                         false,
+                                                         true);
             h3_profile_name(out, profile_prefix + ".attn");
             return h3_profile_name(to_out->forward(ctx, out), profile_prefix + ".out");
         }
diff --git a/src/dit_models/models/minimax_h3_full.hpp b/src/dit_models/models/minimax_h3_full.hpp
index 4a92cfe..8684d8f 100644
--- a/src/dit_models/models/minimax_h3_full.hpp
+++ b/src/dit_models/models/minimax_h3_full.hpp
@@ -983,16 +983,20 @@ namespace MiniMaxH3 {
         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;
+        if (text_len > 0 && text_tags.empty()) {
+            layout.segments.push_back({0, text_len, video_time_row * 3 + 1});
+        } else if (text_len > 0) {
+            int64_t run_start = 0;
+            int current_tag   = text_tags[0];
+            for (int64_t i = 1; i <= text_len; ++i) {
+                int tag = i < text_len ? 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;
@@ -1197,6 +1201,54 @@ namespace MiniMaxH3 {
             return {video, audio};
         }
 
+        size_t measure_compute_buffer_at(int latent_width, int latent_height, int frames) {
+            if (latent_width <= 0 || latent_height <= 0 || frames <= 0) {
+                return 0;
+            }
+            const int latent_frames = frames <= 5 ? 2 : ((frames - 5) / 17) * 5 + 2;
+            const int audio_length = std::max(1, static_cast<int>(std::lround(frames * 40.0 / 24.0)));
+            sd::Tensor<float> video = sd::zeros<float>(
+                {latent_width, latent_height, latent_frames, config.video_latent_channels, 1});
+            sd::Tensor<float> audio = sd::zeros<float>(
+                {audio_length, 2, config.audio_latent_channels, 1});
+            const int64_t spatial_size = video.shape()[0] * video.shape()[1] * video.shape()[2];
+            const int64_t extra_channels = (audio.numel() + spatial_size - 1) / spatial_size;
+            std::vector<int64_t> packed_shape = video.shape();
+            packed_shape[3] += extra_channels;
+            sd::Tensor<float> packed = sd::zeros<float>(packed_shape);
+            std::copy_n(video.data(), video.numel(), packed.data());
+            std::copy_n(audio.data(), audio.numel(), packed.data() + video.numel());
+            sd::Tensor<float> timestep({1}, {1000.0f});
+            sd::Tensor<float> context = sd::zeros<float>({config.text_dim, 256, 1});
+            const sd::Tensor<int32_t> empty_int;
+            std::vector<sd::Tensor<float>> condition_videos;
+            condition_videos.push_back(sd::zeros<float>(video.shape()));
+            condition_videos.push_back(sd::zeros<float>(
+                {latent_width, latent_height, 2, config.video_latent_channels, 1}));
+            std::vector<sd::Tensor<float>> condition_audios;
+            condition_audios.push_back(sd::zeros<float>(audio.shape()));
+            condition_audios.push_back(sd::zeros<float>(audio.shape()));
+            const std::vector<MiniMaxH3ReferenceBlock> reference_blocks = {
+                {MiniMaxH3ReferenceKind::VIDEO_AUDIO, 0, 0},
+                {MiniMaxH3ReferenceKind::IMAGE, 1, -1},
+                {MiniMaxH3ReferenceKind::AUDIO, -1, 1},
+            };
+            auto get_graph = [&]() -> ggml_cgraph* {
+                return build_graph(packed,
+                                   timestep,
+                                   context,
+                                   condition_videos,
+                                   condition_audios,
+                                   empty_int,
+                                   empty_int,
+                                   reference_blocks,
+                                   audio_length,
+                                   12.0f,
+                                   3.0f);
+            };
+            return measure_compute_buffer(get_graph);
+        }
+
         ggml_tensor* merge_av_latents(ggml_context* ctx,
                                       ggml_tensor* video,
                                       ggml_tensor* audio) const {
diff --git a/src/dit_models/pipelines/minimax_h3_pipeline.cpp b/src/dit_models/pipelines/minimax_h3_pipeline.cpp
index 5c807d1..fd4bb47 100644
--- a/src/dit_models/pipelines/minimax_h3_pipeline.cpp
+++ b/src/dit_models/pipelines/minimax_h3_pipeline.cpp
@@ -535,7 +535,49 @@ bool MiniMaxH3Pipeline::prepare(const ed_context_params_t& params,
         return set_minimax_error(error, "MiniMax-H3 diffusion transformer signature is incomplete");
     }
 
-    const bool diffusion_offload = runtime.dit_offload_params_to_cpu();
+    const bool has_audio_vae = std::any_of(loader.get_tensor_storage_map().begin(),
+                                           loader.get_tensor_storage_map().end(),
+                                           [](const auto& item) { return starts_with(item.first, "audio_vae."); });
+
+    runtime.reset_auto_allocate_state();
+    runtime.set_measured_dit_headroom(0);
+    if (runtime.auto_fit() && runtime.fit_width() > 0 && runtime.fit_height() > 0 && runtime.fit_frames() > 0) {
+        auto measure_runner = std::make_unique<MiniMaxH3::MiniMaxH3Runner>(runtime.backend(),
+                                                                          loader.get_tensor_storage_map(),
+                                                                          "model.diffusion_model",
+                                                                          false);
+        measure_runner->set_flash_attention_enabled(runtime.flash_attention());
+        const int latent_width = runtime.fit_width() / 16;
+        const int latent_height = runtime.fit_height() / 16;
+        const size_t measured = measure_runner->measure_compute_buffer_at(latent_width,
+                                                                          latent_height,
+                                                                          runtime.fit_frames());
+        if (measured > 0) {
+            runtime.set_measured_dit_headroom(measured);
+        }
+        LOG_INFO("auto-allocate: measured MiniMax-H3 DiT compute buffer = %.2f GB at latent %dx%dx%d",
+                 measured / (1024.0 * 1024.0 * 1024.0),
+                 latent_width,
+                 latent_height,
+                 runtime.fit_frames());
+    }
+
+    constexpr size_t minimax_staging_slack = static_cast<size_t>(3) * 1024 * 1024 * 1024;
+    const size_t effective_budget = runtime.effective_budget_bytes();
+    const size_t placement_budget = effective_budget > minimax_staging_slack
+                                        ? effective_budget - minimax_staging_slack
+                                        : effective_budget;
+    size_t remaining_free = placement_budget;
+    const bool diffusion_offload = runtime.dit_offload_params_to_cpu() ||
+                                   runtime.plan_component_offload(loader, "model.diffusion_model", remaining_free);
+    const bool text_offload = runtime.clip_offload_params_to_cpu() ||
+                              runtime.plan_component_offload(loader, "text_encoders.llm", remaining_free);
+    const bool vae_offload = runtime.vae_offload_params_to_cpu() ||
+                             runtime.plan_component_offload(loader, "first_stage_model", remaining_free);
+    const bool audio_vae_offload = runtime.vae_offload_params_to_cpu() ||
+                                   (has_audio_vae && runtime.plan_component_offload(loader, "audio_vae", remaining_free));
+    runtime.finalize_auto_segment_budget(effective_budget, minimax_staging_slack);
+
     diffusion_ = std::make_unique<MiniMaxH3::MiniMaxH3Runner>(runtime.backend(),
                                                               loader.get_tensor_storage_map(),
                                                               "model.diffusion_model",
@@ -564,7 +606,6 @@ bool MiniMaxH3Pipeline::prepare(const ed_context_params_t& params,
         LOG_INFO("MiniMax-H3 synthesized missing rope.inv_freq (%zu values)", values.size());
     }
 
-    const bool text_offload = runtime.clip_offload_params_to_cpu();
     String2TensorStorage conditioner_tensors = loader.get_tensor_storage_map();
     const std::regex language_layer_pattern(R"(^text_encoders\.llm\.model\.layers\.(\d+)\.)");
     for (auto it = conditioner_tensors.begin(); it != conditioner_tensors.end();) {
@@ -588,9 +629,11 @@ bool MiniMaxH3Pipeline::prepare(const ed_context_params_t& params,
     conditioner_->model.set_flash_attention_enabled(runtime.flash_attention());
     conditioner_->alloc_params_buffer();
     conditioner_->get_param_tensors(registry.tensors(), "text_encoders.llm");
+    conditioner_->model.set_max_graph_vram_bytes(
+        runtime.text_encoder_segment_budget(conditioner_->model.get_params_buffer_size(), text_offload));
 
     vae_ = std::make_unique<MiniMaxH3VAE::MiniMaxH3VideoVAERunner>(runtime.vae_backend(),
-                                                                    runtime.vae_offload_params_to_cpu(),
+                                                                    vae_offload,
                                                                     loader.get_tensor_storage_map(),
                                                                     "first_stage_model");
     vae_->set_max_graph_vram_bytes(runtime.max_graph_vram_bytes());
@@ -598,12 +641,9 @@ bool MiniMaxH3Pipeline::prepare(const ed_context_params_t& params,
     vae_->alloc_params_buffer();
     vae_->get_param_tensors(registry.tensors(), "first_stage_model");
 
-    const bool has_audio_vae = std::any_of(loader.get_tensor_storage_map().begin(),
-                                           loader.get_tensor_storage_map().end(),
-                                           [](const auto& item) { return starts_with(item.first, "audio_vae."); });
     if (has_audio_vae) {
         audio_vae_ = std::make_unique<MiniMaxH3Audio::AudioVAERunner>(runtime.vae_backend(),
-                                                                        runtime.vae_offload_params_to_cpu(),
+                                                                        audio_vae_offload,
                                                                         loader.get_tensor_storage_map(),
                                                                         "audio_vae");
         audio_vae_->set_max_graph_vram_bytes(runtime.max_graph_vram_bytes());
diff --git a/third_party/ggml b/third_party/ggml
index b8a5ef0..0372cdf 160000
--- a/third_party/ggml
+++ b/third_party/ggml
@@ -1 +1 @@
-Subproject commit b8a5ef0c84eb6c1d942f9db2612ce86ee68b76a7
+Subproject commit 0372cdf693f74eeed38f0a4f5a9004abfcef522b

From f369f75f8525102889b629ab484eb95bab3ef67d Mon Sep 17 00:00:00 2001
From: Komorebi623 <wang-ty22@mails.tsinghua.edu.cn>
Date: Fri, 14 Aug 2026 20:13:41 +0800
Subject: [PATCH 23/25] Optimize MiniMax H3 Ref2VA conditioning and profiling

- Align Ref2VA image/video preprocessing, validate aspect ratios, and build multimodal token sequences directly.

- Add conditioning, Qwen Vision, reference VAE, diffusion, and decode phase profiling.

- Enable validated fused video-VAE reflect padding, temporal group norm, Conv3D, and temporal assembly paths.

- Update ggml for Qwen Vision correctness, temporal padding acceleration, and default SM90 Q8 FC2 cuBLAS routing.

- Document the validated FC2, Qwen Vision, and visual VAE optimization gates.
---
 docs/minimax-h3.md                            |  42 +++++
 src/core/backend/ggml/ggml_extend.hpp         |  27 +--
 .../autoencoders/minimax_h3_vae.hpp           |  77 ++++++++-
 .../components/text_encoders/llm.hpp          |   9 +-
 .../pipelines/minimax_h3_pipeline.cpp         | 162 +++++++++++++-----
 third_party/ggml                              |   2 +-
 6 files changed, 254 insertions(+), 65 deletions(-)

diff --git a/docs/minimax-h3.md b/docs/minimax-h3.md
index 9fd81fb..7ef2279 100644
--- a/docs/minimax-h3.md
+++ b/docs/minimax-h3.md
@@ -128,6 +128,15 @@ When using references, write the prompt so it explicitly mentions the reference
 slots, such as `<Picture 1>`, `<Video 1>`, and `<Audio 1>`. This makes reference
 adherence easier to evaluate and avoids text-only prompts dominating the output.
 
+Reference media uses the released Diffusers preprocessing geometry independently
+of the generated `-W`/`-H` canvas. Reference images preserve their aspect ratio
+and resize to a `2048` pixel short edge. Reference videos preserve their aspect
+ratio and resolve from a `768` pixel short edge with a pre-rounding area cap of
+`768x1344`; both axes then round to multiples of `32`. Images and videos outside
+the supported `1:4` through `4:1` aspect-ratio range are rejected. Small inputs
+can therefore be upscaled substantially, which improves conditioning fidelity
+but increases Qwen3-VL and video-VAE time and peak memory.
+
 ### Reference image
 
 ```bash
@@ -238,6 +247,39 @@ The internal override can be disabled only with the diagnostic environment
 variable `ED_MINIMAX_H3_DISABLE_FORCED_VAE_TILING=1`, which is not recommended
 for normal generation.
 
+On CUDA builds with cuDNN Conv3D, MiniMax-H3 reference encoding uses cuDNN for
+the video-VAE encoder and fuses its spatial reflect padding and temporal group
+normalization without changing the conditioning geometry. The reflect-padding
+and group-normalization paths are numerically identical to the legacy graph;
+cuDNN Conv3D can differ slightly because of floating-point reduction order. For
+diagnosis, the individual paths can be disabled with
+`ED_MINIMAX_H3_VAE_ENCODER_CUDNN_CONV3D=0`,
+`ED_MINIMAX_H3_VAE_ENCODER_CUDNN_CONV3D_ALL=0`,
+`ED_MINIMAX_H3_VAE_FUSED_REFLECT_PAD=0`, or
+`ED_MINIMAX_H3_VAE_FUSED_TEMPORAL_GROUP_NORM=0`. Contiguous causal temporal
+zero-padding uses a byte-equivalent 2D memset/copy CUDA path; set
+`ED_CUDA_PAD_TEMPORAL_COPY2D=0` to restore the elementwise padding kernel.
+
+Ref2VA multimodal presentations are assembled directly as token IDs. Visual
+placeholder tokens are no longer serialized into a large string and repeatedly
+tokenized as image and video blocks are appended. Set
+`ED_MINIMAX_H3_VERIFY_DIRECT_TOKEN_BUILD=1` to compare the direct sequence with
+the legacy tokenizer path token by token during debugging.
+
+Qwen3-VL vision FlashAttention synchronizes each long vision block before its
+temporary storage is reused. This avoids asynchronous scratch reuse changing
+the image-conditioning result and substantially reduces high-resolution image
+encoding time on H200. Set `ED_QWEN_VISION_FLASH_ATTN_SYNC=0` only for
+diagnostic comparison with the legacy path.
+
+On SM90 GPUs, long-sequence Q8_0 MiniMax-H3 FC2 projections can be routed from
+GGML MMQ to cuBLAS. This route is enabled by default after its full-video H200
+quality gate reached 50.17 dB PSNR and 0.9932 SSIM while reducing DiT time by
+7.5%. Set `GGML_CUDA_SM90_Q8_CUBLAS_FC2=0` to restore the MMQ path.
+`GGML_CUDA_SM90_Q8_CUBLAS_FC2_STEPS` and
+`GGML_CUDA_SM90_Q8_CUBLAS_FC2_LAYERS` restrict the experiment to selected
+diffusion steps or transformer layers.
+
 ## H200 performance
 
 The following Edge measurements use CUDA on one H200, `864x480`, 124 frames,
diff --git a/src/core/backend/ggml/ggml_extend.hpp b/src/core/backend/ggml/ggml_extend.hpp
index 50438e9..45f285e 100644
--- a/src/core/backend/ggml/ggml_extend.hpp
+++ b/src/core/backend/ggml/ggml_extend.hpp
@@ -2203,6 +2203,7 @@ struct GGMLRunnerContext {
     bool conv2d_direct_enabled                    = false;
     bool conv2d_auto_direct_enabled               = false;
     bool conv3d_auto_direct_enabled               = false;
+    bool conv3d_force_direct_enabled              = false;
     bool circular_x_enabled                       = false;
     bool circular_y_enabled                       = false;
     std::shared_ptr<WeightAdapter> weight_adapter = nullptr;
@@ -8032,19 +8033,19 @@ class Conv3d : public UnaryBlock {
                 b = ctx->weight_adapter->patch_weight(ctx->ggml_ctx, ctx->backend, b, prefix + "bias");
             }
         }
-        const bool use_direct = ctx->conv3d_auto_direct_enabled &&
-                                x != nullptr &&
-                                w != nullptr &&
-                                x->type == GGML_TYPE_F32 &&
-                                w->type == GGML_TYPE_F16 &&
-                                std::get<0>(kernel_size) == 3 &&
-                                std::get<1>(kernel_size) == 3 &&
-                                std::get<2>(kernel_size) == 3 &&
-                                in_channels >= 64 &&
-                                x->ne[0] >= 128 &&
-                                x->ne[1] >= 128 &&
-                                ggml_is_contiguous(x) &&
-                                ggml_is_contiguous(w);
+        const bool direct_compatible = ctx->conv3d_auto_direct_enabled &&
+                                       x != nullptr &&
+                                       w != nullptr &&
+                                       x->type == GGML_TYPE_F32 &&
+                                       w->type == GGML_TYPE_F16 &&
+                                       std::get<0>(kernel_size) == 3 &&
+                                       std::get<1>(kernel_size) == 3 &&
+                                       std::get<2>(kernel_size) == 3 &&
+                                       ggml_is_contiguous(x) &&
+                                       ggml_is_contiguous(w);
+        const bool use_direct = direct_compatible &&
+                                (ctx->conv3d_force_direct_enabled ||
+                                 (in_channels >= 64 && x->ne[0] >= 128 && x->ne[1] >= 128));
         return ggml_ext_conv_3d(ctx->ggml_ctx, x, w, b, in_channels,
                                 std::get<2>(stride), std::get<1>(stride), std::get<0>(stride),
                                 std::get<2>(padding), std::get<1>(padding), std::get<0>(padding),
diff --git a/src/dit_models/components/autoencoders/minimax_h3_vae.hpp b/src/dit_models/components/autoencoders/minimax_h3_vae.hpp
index 47f4fc1..35d6b35 100644
--- a/src/dit_models/components/autoencoders/minimax_h3_vae.hpp
+++ b/src/dit_models/components/autoencoders/minimax_h3_vae.hpp
@@ -95,8 +95,27 @@ namespace MiniMaxH3VAE {
                 return value;
             };
 
-            x                = reflect_pad(x, 0, std::get<2>(temporal_padding));
-            x                = reflect_pad(x, 1, std::get<1>(temporal_padding));
+            const int spatial_pad_x = std::get<2>(temporal_padding);
+            const int spatial_pad_y = std::get<1>(temporal_padding);
+            const bool fused_reflect_supported = sd_backend_is(ctx->backend, "CUDA") ||
+                                                  ggml_backend_is_cpu(ctx->backend);
+            if ((spatial_pad_x > 0 || spatial_pad_y > 0) &&
+                fused_reflect_supported &&
+                h3_env_flag_enabled_or_default("ED_MINIMAX_H3_VAE_FUSED_REFLECT_PAD", true)) {
+                x = ggml_pad_ext_reflect(ctx->ggml_ctx,
+                                         x,
+                                         spatial_pad_x,
+                                         spatial_pad_x,
+                                         spatial_pad_y,
+                                         spatial_pad_y,
+                                         0,
+                                         0,
+                                         0,
+                                         0);
+            } else {
+                x = reflect_pad(x, 0, spatial_pad_x);
+                x = reflect_pad(x, 1, spatial_pad_y);
+            }
             int temporal_pad = std::get<0>(temporal_padding) * 2;
             if (temporal_pad > 0) {
                 x = ggml_ext_pad_ext(ctx->ggml_ctx,
@@ -124,6 +143,21 @@ namespace MiniMaxH3VAE {
                 const int64_t temporal_size = x->ne[2];
                 const int64_t batch_size    = x->ne[3] / num_channels;
                 if (batch_size == 1 && temporal_size > 1) {
+                    const bool fused_group_norm_supported = sd_backend_is(ctx->backend, "CUDA") ||
+                                                            ggml_backend_is_cpu(ctx->backend);
+                    if (fused_group_norm_supported &&
+                        h3_env_flag_enabled_or_default("ED_MINIMAX_H3_VAE_FUSED_TEMPORAL_GROUP_NORM", true)) {
+                        ggml_tensor* result = ggml_group_norm_temporal(ctx->ggml_ctx, x, num_groups, eps);
+                        if (affine) {
+                            ggml_tensor* weight = params["weight"];
+                            ggml_tensor* bias = params["bias"];
+                            weight = ggml_reshape_4d(ctx->ggml_ctx, weight, 1, 1, 1, weight->ne[0]);
+                            bias = ggml_reshape_4d(ctx->ggml_ctx, bias, 1, 1, 1, bias->ne[0]);
+                            result = ggml_mul_inplace(ctx->ggml_ctx, result, weight);
+                            result = ggml_add_inplace(ctx->ggml_ctx, result, bias);
+                        }
+                        return result;
+                    }
                     x = ggml_cont(ctx->ggml_ctx, ggml_permute(ctx->ggml_ctx, x, 0, 1, 3, 2));
                     x = GroupNorm::forward(ctx, x);
                     return ggml_cont(ctx->ggml_ctx, ggml_permute(ctx->ggml_ctx, x, 0, 1, 3, 2));
@@ -711,11 +745,28 @@ namespace MiniMaxH3VAE {
 
         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);
+            if (count <= 0) {
+                return input;
             }
+            std::vector<int64_t> shape = input.shape();
+            const int64_t input_frames = shape[2];
+            shape[2] += count;
+            sd::Tensor<float> result(std::move(shape));
+            const int64_t frame_size = input.shape()[0] * input.shape()[1];
+            const int64_t input_outer_stride = frame_size * input_frames;
+            const int64_t output_outer_stride = frame_size * result.shape()[2];
+            const int64_t outer_count = input.shape()[3] * input.shape()[4];
+            sd_parallel_for(0, outer_count, 1, [&](int64_t outer) {
+                const float* source = input.values().data() + outer * input_outer_stride;
+                float* destination = result.values().data() + outer * output_outer_stride;
+                std::copy_n(source, input_outer_stride, destination);
+                const float* last_frame = source + frame_size * (input_frames - 1);
+                for (int64_t frame = 0; frame < count; ++frame) {
+                    std::copy_n(last_frame,
+                                frame_size,
+                                destination + frame_size * (input_frames + frame));
+                }
+            });
             return result;
         }
 
@@ -850,16 +901,17 @@ namespace MiniMaxH3VAE {
             if (pad > 0) {
                 input = repeat_last_frame(input, pad);
             }
-            sd::Tensor<float> result;
+            std::vector<sd::Tensor<float>> encoded_parts;
+            encoded_parts.reserve(static_cast<size_t>(input.shape()[2] / 17));
             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);
+                encoded_parts.push_back(std::move(encoded));
             }
+            sd::Tensor<float> result = concatenate_temporal_parts(encoded_parts);
             if (result.shape()[2] > 3) {
                 result = sd::ops::slice(result, 2, 0, result.shape()[2] - 3);
             }
@@ -1170,6 +1222,13 @@ namespace MiniMaxH3VAE {
                 auto mean        = make_input(pixel_mean);
                 auto std         = make_input(pixel_std);
                 auto runner_ctx  = get_context();
+                runner_ctx.conv3d_auto_direct_enabled =
+                    !decode_graph &&
+                    h3_env_flag_enabled_or_default("ED_MINIMAX_H3_VAE_ENCODER_CUDNN_CONV3D", true) &&
+                    should_use_cuda_auto_conv3d();
+                runner_ctx.conv3d_force_direct_enabled =
+                    runner_ctx.conv3d_auto_direct_enabled &&
+                    h3_env_flag_enabled_or_default("ED_MINIMAX_H3_VAE_ENCODER_CUDNN_CONV3D_ALL", true);
                 ggml_tensor* out = nullptr;
                 if (decode_graph) {
                     auto pe = make_input(rope_cache);
diff --git a/src/dit_models/components/text_encoders/llm.hpp b/src/dit_models/components/text_encoders/llm.hpp
index 2ac8277..675af4f 100644
--- a/src/dit_models/components/text_encoders/llm.hpp
+++ b/src/dit_models/components/text_encoders/llm.hpp
@@ -1303,6 +1303,7 @@ namespace LLM {
             k = ggml_cont(ctx->ggml_ctx, ggml_ext_torch_permute(ctx->ggml_ctx, k, 0, 2, 1, 3));  // [N, num_kv_heads, n_token, head_dim]
             k = ggml_reshape_3d(ctx->ggml_ctx, k, k->ne[0], k->ne[1], k->ne[2] * k->ne[3]);      // [N*num_kv_heads, n_token, head_dim]
 
+            const bool use_masked_flash_attention = arch == LLMArch::QWEN3_VL && n_token >= 2048;
             x = ggml_ext_attention_ext(ctx->ggml_ctx,
                                        ctx->backend,
                                        q,
@@ -1311,7 +1312,13 @@ namespace LLM {
                                        num_heads,
                                        attention_mask,
                                        true,
-                                       false);  // [N, n_token, hidden_size]
+                                       use_masked_flash_attention,
+                                       1.0f,
+                                       true,
+                                       false,
+                                       -1,
+                                       -1,
+                                       use_masked_flash_attention);  // [N, n_token, hidden_size]
             if (diffusers_dtype &&
                 (attention_output_type == GGML_TYPE_F16 || attention_output_type == GGML_TYPE_BF16) &&
                 x->type != attention_output_type) {
diff --git a/src/dit_models/pipelines/minimax_h3_pipeline.cpp b/src/dit_models/pipelines/minimax_h3_pipeline.cpp
index fd4bb47..ab005e2 100644
--- a/src/dit_models/pipelines/minimax_h3_pipeline.cpp
+++ b/src/dit_models/pipelines/minimax_h3_pipeline.cpp
@@ -78,11 +78,6 @@ bool h3_condition_debug_exit_enabled() {
     return value != nullptr && value[0] != '\0' && std::strcmp(value, "0") != 0;
 }
 
-bool h3_ref_image_text_short_edge_2048_enabled() {
-    const char* value = std::getenv("ED_MINIMAX_H3_REF_IMAGE_TEXT_SHORT_EDGE_2048");
-    return value != nullptr && value[0] != '\0' && std::strcmp(value, "0") != 0;
-}
-
 std::string h3_text_debug_target() {
     const char* value = std::getenv("ED_MINIMAX_H3_TEXT_DEBUG_TARGET");
     return value == nullptr ? std::string() : std::string(value);
@@ -161,10 +156,6 @@ void h3_reference_video_dimensions(const ed_image_t& image, int* width, int* hei
     }
     *width = std::max(32, static_cast<int>(std::round(nominal_width / 32.0)) * 32);
     *height = std::max(32, static_cast<int>(std::round(nominal_height / 32.0)) * 32);
-    if (static_cast<int64_t>(image.width) * image.height < static_cast<int64_t>(*width) * *height) {
-        *width = std::max(32, static_cast<int>(std::round(static_cast<double>(image.width) / 32.0)) * 32);
-        *height = std::max(32, static_cast<int>(std::round(static_cast<double>(image.height) / 32.0)) * 32);
-    }
 }
 
 void h3_reference_image_dimensions(const ed_image_t& image, int* width, int* height) {
@@ -174,16 +165,10 @@ void h3_reference_image_dimensions(const ed_image_t& image, int* width, int* hei
     *height = std::max(32, static_cast<int>(std::round(image.height * scale / 32.0)) * 32);
 }
 
-void h3_reference_image_dimensions_for_canvas(const ed_image_t& image,
-                                              int canvas_width,
-                                              int canvas_height,
-                                              int* width,
-                                              int* height) {
-    const double source_area = static_cast<double>(image.width) * static_cast<double>(image.height);
-    const double target_area = static_cast<double>(canvas_width) * static_cast<double>(canvas_height);
-    const double scale = std::min(1.0, std::sqrt(target_area / source_area));
-    *width = std::max(32, static_cast<int>(std::round(image.width * scale / 32.0)) * 32);
-    *height = std::max(32, static_cast<int>(std::round(image.height * scale / 32.0)) * 32);
+bool h3_reference_aspect_ratio_supported(const ed_image_t& image) {
+    return image.width > 0 && image.height > 0 &&
+           static_cast<int64_t>(image.width) <= 4 * static_cast<int64_t>(image.height) &&
+           static_cast<int64_t>(image.height) <= 4 * static_cast<int64_t>(image.width);
 }
 
 float h3_discrete_flow_sigma(int step, int steps, float shift) {
@@ -311,7 +296,44 @@ sd::Tensor<float> h3_encode_vae_condition(MiniMaxH3VAE::MiniMaxH3VideoVAERunner*
                                           int n_threads,
                                           const sd::Tensor<float>& video,
                                           ed_tiling_params_t tiling) {
-    return vae->encode(n_threads, video, tiling);
+    auto encoded = vae->encode(n_threads, video, tiling);
+    const char* verify_value = std::getenv("ED_MINIMAX_H3_VERIFY_VAE_ENCODER_OPTIMIZATIONS");
+    if (encoded.empty() || verify_value == nullptr || verify_value[0] == '\0' || std::strcmp(verify_value, "0") == 0) {
+        return encoded;
+    }
+    ScopedEnvVar disable_cudnn("ED_MINIMAX_H3_VAE_ENCODER_CUDNN_CONV3D", "0");
+    ScopedEnvVar disable_cudnn_all("ED_MINIMAX_H3_VAE_ENCODER_CUDNN_CONV3D_ALL", "0");
+    ScopedEnvVar disable_reflect_pad("ED_MINIMAX_H3_VAE_FUSED_REFLECT_PAD", "0");
+    ScopedEnvVar disable_group_norm("ED_MINIMAX_H3_VAE_FUSED_TEMPORAL_GROUP_NORM", "0");
+    auto baseline = vae->encode(n_threads, video, tiling);
+    if (baseline.empty() || baseline.shape() != encoded.shape()) {
+        LOG_ERROR("MiniMax-H3 VAE encoder optimization verification failed: output shape mismatch");
+        return {};
+    }
+    double squared_error = 0.0;
+    double squared_baseline = 0.0;
+    double dot = 0.0;
+    double squared_encoded = 0.0;
+    float max_abs_error = 0.0f;
+    for (int64_t index = 0; index < encoded.numel(); ++index) {
+        const double reference = baseline[index];
+        const double candidate = encoded[index];
+        const double error_value = candidate - reference;
+        squared_error += error_value * error_value;
+        squared_baseline += reference * reference;
+        squared_encoded += candidate * candidate;
+        dot += reference * candidate;
+        max_abs_error = std::max(max_abs_error, static_cast<float>(std::abs(error_value)));
+    }
+    const double mse = squared_error / std::max<int64_t>(1, encoded.numel());
+    const double rmse = std::sqrt(mse);
+    const double signal_rms = std::sqrt(squared_baseline / std::max<int64_t>(1, encoded.numel()));
+    const double psnr = mse == 0.0 ? std::numeric_limits<double>::infinity()
+                                   : 20.0 * std::log10(std::max(1e-30, signal_rms) / rmse);
+    const double cosine = dot / std::max(1e-30, std::sqrt(squared_baseline * squared_encoded));
+    LOG_INFO("MiniMax-H3 VAE encoder optimization verification: n=%lld rmse=%.9g signal-rms=%.9g psnr=%.6g dB max-abs=%.9g cosine=%.12g",
+             static_cast<long long>(encoded.numel()), rmse, signal_rms, psnr, max_abs_error, cosine);
+    return encoded;
 }
 
 void h3_apply_condition_noise(sd::Tensor<float>* latent, uint64_t seed) {
@@ -494,7 +516,7 @@ struct MiniMaxH3Profile {
                  static_cast<long long>(total_ms), static_cast<long long>(conditioning_ms),
                  static_cast<long long>(diffusion_ms), diffusion_steps, diffusion_calls,
                  static_cast<long long>(decode_ms), static_cast<long long>(noise_init_ms));
-        LOG_INFO("minimax-h3 profile conditioning: context cond=%lld ms uncond=%lld ms | vision image prepare=%lld ms encode=%lld ms | vision video prepare=%lld ms encode=%lld ms | text tokenize=%lld ms encode=%lld ms | keyframe vae=%lld ms | ref video vae=%lld ms | ref audio prepare=%lld ms vae=%lld ms",
+        LOG_INFO("minimax-h3 profile conditioning: context cond=%lld ms uncond=%lld ms | vision image prepare=%lld ms encode=%lld ms | vision video prepare=%lld ms encode=%lld ms | text tokenize=%lld ms encode=%lld ms | keyframe vae encode=%lld ms | ref visual vae encode=%lld ms | ref audio prepare=%lld ms vae encode=%lld ms",
                  static_cast<long long>(cond_context_ms), static_cast<long long>(uncond_context_ms),
                  static_cast<long long>(vision_image_prepare_ms), static_cast<long long>(vision_image_encode_ms),
                  static_cast<long long>(vision_video_prepare_ms), static_cast<long long>(vision_video_encode_ms),
@@ -716,7 +738,14 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
     if (context == nullptr || token_tags == nullptr || conditioner_ == nullptr || runtime_ == nullptr) {
         return set_minimax_error(error, "MiniMax-H3 text conditioner is not initialized");
     }
-    std::string presentation;
+    std::string pending_text;
+    std::vector<int> tokens;
+    int64_t tokenization_ms = 0;
+    const char* verify_token_build_value = std::getenv("ED_MINIMAX_H3_VERIFY_DIRECT_TOKEN_BUILD");
+    const bool verify_token_build = verify_token_build_value != nullptr &&
+                                   verify_token_build_value[0] != '\0' &&
+                                   std::strcmp(verify_token_build_value, "0") != 0;
+    std::string legacy_presentation;
     std::vector<std::pair<int, sd::Tensor<float>>> image_embeds;
     std::vector<LLM::LLMImageEmbedInfo> image_embed_infos;
     std::vector<std::vector<std::pair<int, sd::Tensor<float>>>> deepstack_image_embeds(3);
@@ -731,15 +760,36 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
         return set_minimax_error(error, "MiniMax-H3 tokenizer special tokens are invalid");
     }
     auto append_text = [&](const std::string& text) {
-        presentation += text;
+        pending_text += text;
+        if (verify_token_build) {
+            legacy_presentation += text;
+        }
+    };
+    auto flush_text = [&]() {
+        if (pending_text.empty()) {
+            return;
+        }
+        const int64_t begin = profile != nullptr ? ggml_time_ms() : 0;
+        auto text_tokens = conditioner_->tokenizer->tokenize(pending_text, nullptr, false, 0, 0, false);
+        if (profile != nullptr) {
+            tokenization_ms += ggml_time_ms() - begin;
+        }
+        tokens.insert(tokens.end(), text_tokens.begin(), text_tokens.end());
+        pending_text.clear();
     };
     auto append_vision = [&](int64_t count) {
-        presentation += vision_start;
-        const int embed_index = static_cast<int>(conditioner_->tokenizer->tokenize(presentation, nullptr, true, 0, 0, false).size());
-        for (int64_t index = 0; index < count; ++index) {
-            presentation += image_pad;
+        flush_text();
+        tokens.push_back(vision_start_tokens[0]);
+        const int embed_index = static_cast<int>(tokens.size());
+        tokens.insert(tokens.end(), static_cast<size_t>(count), image_pad_tokens[0]);
+        tokens.push_back(vision_end_tokens[0]);
+        if (verify_token_build) {
+            legacy_presentation += vision_start;
+            for (int64_t index = 0; index < count; ++index) {
+                legacy_presentation += image_pad;
+            }
+            legacy_presentation += vision_end;
         }
-        presentation += vision_end;
         return embed_index;
     };
     auto add_vision_image = [&](const ed_image_t& image,
@@ -790,11 +840,7 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
         const ed_image_t& image = ref_images[image_index];
         int width = 0;
         int height = 0;
-        if (h3_ref_image_text_short_edge_2048_enabled()) {
-            h3_reference_image_dimensions(image, &width, &height);
-        } else {
-            h3_reference_image_dimensions_for_canvas(image, canvas_width, canvas_height, &width, &height);
-        }
+        h3_reference_image_dimensions(image, &width, &height);
         LOG_DEBUG("MiniMax-H3 Ref2VA vision image=%dx%d tensor=%s",
                   width,
                   height,
@@ -881,10 +927,24 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
     for (int audio_index = 0; audio_index < ref_audio_count; ++audio_index) {
         append_text("<Audio " + std::to_string(++audio_number) + ">: ");
     }
-    const int64_t tokenize_begin = profile != nullptr ? ggml_time_ms() : 0;
     append_text(prompt == nullptr ? "" : prompt);
-    std::vector<int> tokens = conditioner_->tokenizer->tokenize(presentation, nullptr, true, 0, 0, false);
-    if (profile != nullptr) profile->text_tokenize_ms += ggml_time_ms() - tokenize_begin;
+    flush_text();
+    if (profile != nullptr) profile->text_tokenize_ms += tokenization_ms;
+    if (verify_token_build) {
+        const auto legacy_tokens = conditioner_->tokenizer->tokenize(legacy_presentation, nullptr, true, 0, 0, false);
+        if (legacy_tokens != tokens) {
+            size_t mismatch = 0;
+            while (mismatch < legacy_tokens.size() && mismatch < tokens.size() &&
+                   legacy_tokens[mismatch] == tokens[mismatch]) {
+                ++mismatch;
+            }
+            std::ostringstream message;
+            message << "MiniMax-H3 direct token build mismatch at " << mismatch
+                    << ": direct=" << tokens.size() << " legacy=" << legacy_tokens.size();
+            return set_minimax_error(error, message.str().c_str());
+        }
+        LOG_INFO("MiniMax-H3 direct token build verified: tokens=%zu", tokens.size());
+    }
     if (tokens.empty()) {
         return set_minimax_error(error, "MiniMax-H3 prompt tokenization produced no tokens");
     }
@@ -1101,6 +1161,20 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
         set_minimax_error(error, "MiniMax-H3 Ref2VA audio references must be paired with at least one image or video reference");
         return ED_STATUS_INVALID_ARGUMENT;
     }
+    for (int image_index = 0; image_index < params->ref_image_count; ++image_index) {
+        if (!h3_reference_aspect_ratio_supported(params->ref_images[image_index])) {
+            set_minimax_error(error, "MiniMax-H3 Ref2VA reference images must have a positive size and an aspect ratio from 1:4 to 4:1");
+            return ED_STATUS_INVALID_ARGUMENT;
+        }
+    }
+    for (int video_index = 0; video_index < params->ref_video_count; ++video_index) {
+        const ed_ref_video_t& reference = params->ref_videos[video_index];
+        if (reference.frames == nullptr || reference.frame_count <= 0 ||
+            !h3_reference_aspect_ratio_supported(reference.frames[0])) {
+            set_minimax_error(error, "MiniMax-H3 Ref2VA reference videos must have frames with a positive size and an aspect ratio from 1:4 to 4:1");
+            return ED_STATUS_INVALID_ARGUMENT;
+        }
+    }
     const int64_t resolved_seed = h3_resolve_seed(params->seed);
     sd::Tensor<float> context;
     sd::Tensor<int32_t> token_tags;
@@ -1223,11 +1297,7 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
         }
         int reference_width = 0;
         int reference_height = 0;
-        h3_reference_image_dimensions_for_canvas(source_image,
-                                                params->width,
-                                                params->height,
-                                                &reference_width,
-                                                &reference_height);
+        h3_reference_image_dimensions(source_image, &reference_width, &reference_height);
         sd::Tensor<float> image_tensor = h3_image_to_tensor(source_image, reference_width, reference_height);
         if (image_tensor.empty()) {
             set_minimax_error(error, "MiniMax-H3 Ref2VA image reference is invalid");
@@ -1317,6 +1387,16 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
         reference_blocks.push_back({MiniMaxH3ReferenceKind::AUDIO, -1, encoded_index});
     }
     if (h3_condition_debug_exit_enabled()) {
+        if (profile_ptr != nullptr) {
+            profile.total_ms = ggml_time_ms() - generation_begin;
+            profile.log();
+            LOG_INFO("minimax-h3 conditioning debug profile: context=%lld ms tokenize=%lld ms text-encode=%lld ms ref-visual-vae-encode=%lld ms ref-audio-vae-encode=%lld ms",
+                     static_cast<long long>(profile.cond_context_ms),
+                     static_cast<long long>(profile.text_tokenize_ms),
+                     static_cast<long long>(profile.text_encode_ms),
+                     static_cast<long long>(profile.reference_video_vae_encode_ms),
+                     static_cast<long long>(profile.reference_audio_vae_encode_ms));
+        }
         set_minimax_error(error, "MiniMax-H3 conditioning debug completed");
         return ED_STATUS_GENERATION_FAILED;
     }
diff --git a/third_party/ggml b/third_party/ggml
index 0372cdf..2ae540c 160000
--- a/third_party/ggml
+++ b/third_party/ggml
@@ -1 +1 @@
-Subproject commit 0372cdf693f74eeed38f0a4f5a9004abfcef522b
+Subproject commit 2ae540cefa8405e961182a78c54891a0e2e96c08

From 2d318cf8182538195dd7e403f641d32d3d656bc6 Mon Sep 17 00:00:00 2001
From: Komorebi623 <wang-ty22@mails.tsinghua.edu.cn>
Date: Fri, 14 Aug 2026 21:04:34 +0800
Subject: [PATCH 24/25] Add duration-based MiniMax H3 generation

Add a MiniMax-only --video-duration CLI option while retaining exact --video-frames control. Convert seconds at the fixed 24 FPS rate, align to the nearest legal 17k+5 frame count, reject ambiguous combinations, and use the resolved count for auto-fit and reference decoding.

Refresh the formal MiniMax model, CLI, and usage documentation with verified BF16/Q8/Q4 sources, offline Q8 conversion commands, corrected full-versus-pruned checkpoint names, concise inference examples, and clearly separated pre-alignment versus Diffusers-aligned H200 generation/VRAM data. Remove legacy no-op flags from examples and untrack non-formal MiniMax benchmark/handoff documents without deleting their local copies.
---
 docs/cli.md                                   |    9 +-
 docs/minimax-h3.md                            |  487 +++----
 docs/models.md                                |    5 +-
 ...-edge-generation-performance-2026-08-09.md |  760 -----------
 ...2va-edge-diffusers-benchmark-2026-08-11.md |  226 ----
 ...-ref2va-edge-sdcpp-h200-8bit-2026-08-12.md |  155 ---
 .../minimax-h3-handoff-2026-08-07.md          | 1147 -----------------
 examples/cli/cli_common.hpp                   |   55 +
 examples/cli/main.cpp                         |   25 +-
 examples/cli/sample_main.cpp                  |   21 +-
 10 files changed, 312 insertions(+), 2578 deletions(-)
 delete mode 100644 docs/optimization/minimax-h3-edge-generation-performance-2026-08-09.md
 delete mode 100644 docs/optimization/minimax-h3-fl2va-ref2va-edge-diffusers-benchmark-2026-08-11.md
 delete mode 100644 docs/optimization/minimax-h3-fl2va-ref2va-edge-sdcpp-h200-8bit-2026-08-12.md
 delete mode 100644 docs/optimization/minimax-h3-handoff-2026-08-07.md

diff --git a/docs/cli.md b/docs/cli.md
index d06fa07..24e6ee8 100644
--- a/docs/cli.md
+++ b/docs/cli.md
@@ -273,6 +273,7 @@ Video flags:
 ```text
 --video
 --frames <int>
+--video-duration <seconds>  # MiniMax-H3 only
 --fps <int>
 --video-format auto|avi|mp4|mov|mkv|webm
 ```
@@ -409,6 +410,11 @@ placement remains valid across FL2VA and Ref2VA workflows. The MiniMax-H3 video
 VAE also keeps its model-specific fixed `16x16` tiling regardless of the generic
 `--vae-tiling`/`--vae-tile-size` values.
 
+For MiniMax-H3, `--video-duration <seconds>` converts a requested duration at
+the model's fixed 24 fps to the nearest legal `17k+5` frame count. Keep using
+`--video-frames` when an exact legal count is required; the two options are
+mutually exclusive.
+
 ```bash
 # MiniMax-H3 Q8_0 under a 40 GiB hard placement budget.
 ./build-cuda/bin/ed-cli --video \
@@ -417,8 +423,7 @@ VAE also keeps its model-specific fixed `16x16` tiling regardless of the generic
   --audio-vae /path/to/minimax_h3_audio_vae_fp32.safetensors \
   --llm /path/to/qwen3vl_32b_minimax_h3-Q8_0.gguf \
   --auto-fit --max-vram 40 --vae-tiling auto \
-  -W 864 -H 480 --video-frames 124 --fps 24 --steps 20 \
-  --cfg-scale 1 --diffusion-fa --rng cpu \
+  -W 864 -H 480 --video-duration 5 --steps 20 --cfg-scale 1 \
   --prompt "A cinematic sunset over layered mountain ridges." \
   --video-format mp4 --output minimax-h3-autofit.mp4
 ```
diff --git a/docs/minimax-h3.md b/docs/minimax-h3.md
index 7ef2279..daf43be 100644
--- a/docs/minimax-h3.md
+++ b/docs/minimax-h3.md
@@ -1,329 +1,256 @@
 # MiniMax-H3
 
-edge-dit.cpp supports MiniMax-H3 video + audio generation through the standalone
-component-loading path. The implementation follows the MiniMax-H3 interface used
-by `stable-diffusion.cpp`: one diffusion checkpoint, Qwen3-VL text/vision encoder,
-video VAE, and optional audio VAE.
+edge-dit.cpp supports MiniMax-H3 video-and-audio generation through standalone
+components: one FL2VA or Ref2VA diffusion model, one Qwen3-VL text/vision
+encoder, the video VAE, and the optional audio VAE. CUDA is the validated
+backend for this model family.
 
-## Model files
+## Checkpoints and inputs
 
-MiniMax-H3 runs with four model components. The diffusion checkpoint changes by
-mode; the encoder and VAEs are shared.
+FL2VA and Ref2VA share Qwen3-VL and both VAEs, but require different diffusion
+checkpoints.
 
-| Component | File name | Source |
-|---|---|---|
-| Qwen3-VL text/vision encoder | `qwen3vl_32b_minimax_h3-Q4_K_M.gguf` | [leejet/MiniMax-H3-GGUF](https://huggingface.co/leejet/MiniMax-H3-GGUF) |
-| Video VAE | `minimax_h3_video_vae_fp16.safetensors` | [Comfy-Org/MiniMax-H3](https://huggingface.co/Comfy-Org/MiniMax-H3) |
-| Audio VAE | `minimax_h3_audio_vae_fp32.safetensors` | [Comfy-Org/MiniMax-H3](https://huggingface.co/Comfy-Org/MiniMax-H3) |
+| Checkpoint | Supported conditioning |
+|---|---|
+| FL2VA | Text; first frame; last frame; first and last frames |
+| Ref2VA | Repeatable reference images, videos, paired video audio, and additional audio |
 
-### FL2VA checkpoint
+FL2VA uses `--image`/`--init-img` for the first frame and `--end-img` for the
+last frame. Ref2VA uses the following options:
 
-| Component | File name | Source |
+| Input | CLI option | Behavior |
 |---|---|---|
-| Diffusion model | `minimax_h3_fl2va-Q4_K_M.gguf` | [leejet/MiniMax-H3-GGUF](https://huggingface.co/leejet/MiniMax-H3-GGUF) |
+| Image | `--ref-image <path>` | Repeatable; presented as `<Picture N>` |
+| Video | `--ref-video <path>` | Repeatable frame directory or `mp4`/`mov`/`mkv`/`webm`/`avi`; media files require `ffmpeg` |
+| Paired audio | `--ref-video-audio <wav>` | The Nth WAV is paired with the Nth video and overrides embedded audio |
+| Additional audio | `--ref-audio <wav>` | Repeatable; requires at least one image or video reference |
 
-Supported modes:
-
-| Mode | Inputs | Output |
-|---|---|---|
-| T2VA | Text prompt | Video + audio |
-| I2VA | Text prompt + first frame image | Video + audio |
-| L2VA | Text prompt + last frame image | Video + audio |
-| FL2VA | Text prompt + first frame image + last frame image | Video + audio |
-
-### Ref2VA checkpoint
-
-| Component | File name | Source |
-|---|---|---|
-| Diffusion model | `minimax_h3_ref2va-Q4_K_M.gguf` | [leejet/MiniMax-H3-GGUF](https://huggingface.co/leejet/MiniMax-H3-GGUF) |
+When `--ref-video` points to a media file, the CLI decodes it at 24 fps and
+automatically extracts an embedded audio track. Explicit paired WAV files map
+positionally to videos. Additional audio is numbered after paired or embedded
+video audio. Ref2VA references cannot be combined with FL2VA first/last-frame
+options, and audio-only Ref2VA requests are rejected.
 
-Use the complete `minimax_h3_ref2va-Q4_K_M.gguf` for quality comparisons. The
-smaller `minimax_h3_ref2va-Q4_K_M.gguf` is loadable, but it is a pruned
-checkpoint and is not directly comparable with the official full Ref2VA DiT.
-
-Supported reference inputs:
+## Model files
 
-| Input | CLI flag | Notes |
-|---|---|---|
-| Reference image | `--ref-image <image>` | Repeatable. Presented as `<Picture N>` to Qwen3-VL. |
-| Reference video | `--ref-video <path>` | Repeatable. Accepts a frame directory or `mp4`/`mov`/`mkv`/`webm`/`avi`; media files are decoded at 24 fps with `ffmpeg`. |
-| Paired video audio | `--ref-video-audio <wav>` | Repeatable. The Nth WAV replaces/sets audio for the Nth `--ref-video`. Without it, an input media file's embedded audio is extracted automatically. |
-| Additional audio | `--ref-audio <wav>` | Repeatable, but must be combined with at least one reference image or video. Audio-only Ref2VA requests are rejected. |
+### Downloadable weights
 
-Reference images, videos, paired video audio, and additional audio can be mixed.
-Flags preserve command-line order. `--ref-video-audio` entries map positionally
-to the leading `--ref-video` entries, so keep each video and its explicit WAV in
-the same order. Ref2VA references cannot be combined with `--init-img`/`--image`
-or `--end-img` in the same request.
+The complete, unpruned checkpoints are recommended. The smaller files whose
+names contain `pruned` are loadable but are not directly comparable with the
+official full DiTs.
 
-MiniMax-H3 control frames are not supported for either checkpoint.
+| Precision | Component | File | Repository |
+|---|---|---|---|
+| Q4_K_M | FL2VA DiT | `minimax_h3_fl2va-Q4_K_M.gguf` | [`leejet/MiniMax-H3-GGUF`](https://huggingface.co/leejet/MiniMax-H3-GGUF) |
+| Q4_K_M | Ref2VA DiT | `minimax_h3_ref2va-Q4_K_M.gguf` | [`leejet/MiniMax-H3-GGUF`](https://huggingface.co/leejet/MiniMax-H3-GGUF) |
+| Q4_K_M | Qwen3-VL | `qwen3vl_32b_minimax_h3-Q4_K_M.gguf` | [`leejet/MiniMax-H3-GGUF`](https://huggingface.co/leejet/MiniMax-H3-GGUF) |
+| BF16 | FL2VA DiT | `diffusion_models/minimax_h3_fl2va_bf16.safetensors` | [`Comfy-Org/MiniMax-H3`](https://huggingface.co/Comfy-Org/MiniMax-H3) |
+| BF16 | Ref2VA DiT | `diffusion_models/minimax_h3_ref2va_bf16.safetensors` | [`Comfy-Org/MiniMax-H3`](https://huggingface.co/Comfy-Org/MiniMax-H3) |
+| BF16 | Qwen3-VL | `text_encoders/qwen3vl_32b_minimax_h3_bf16.safetensors` | [`Comfy-Org/MiniMax-H3`](https://huggingface.co/Comfy-Org/MiniMax-H3) |
+| FP16 | Video VAE | `vae/minimax_h3_video_vae_fp16.safetensors` | [`Comfy-Org/MiniMax-H3`](https://huggingface.co/Comfy-Org/MiniMax-H3) |
+| FP32 | Audio VAE | `vae/minimax_h3_audio_vae_fp32.safetensors` | [`Comfy-Org/MiniMax-H3`](https://huggingface.co/Comfy-Org/MiniMax-H3) |
 
-## Common parameters
+The official [`MiniMaxAI/MiniMax-H3`](https://huggingface.co/MiniMaxAI/MiniMax-H3)
+Diffusers shard indexes are also accepted for BF16 transformer loading. Merged
+Comfy-Org files are usually more convenient for standalone component commands.
 
-MiniMax-H3 is a 24 fps audio-video model. The usual full-resolution setting is:
+Example downloads with the Hugging Face CLI:
 
 ```bash
--W 864 -H 480 --fps 24 --video-frames 56 --cfg-scale 1.0 --diffusion-fa --rng cpu
+hf download leejet/MiniMax-H3-GGUF \
+  minimax_h3_fl2va-Q4_K_M.gguf minimax_h3_ref2va-Q4_K_M.gguf \
+  qwen3vl_32b_minimax_h3-Q4_K_M.gguf --local-dir models/minimax-h3-q4
+
+hf download Comfy-Org/MiniMax-H3 \
+  diffusion_models/minimax_h3_fl2va_bf16.safetensors \
+  diffusion_models/minimax_h3_ref2va_bf16.safetensors \
+  text_encoders/qwen3vl_32b_minimax_h3_bf16.safetensors \
+  vae/minimax_h3_video_vae_fp16.safetensors \
+  vae/minimax_h3_audio_vae_fp32.safetensors \
+  --local-dir models/minimax-h3
 ```
 
-The frame count must satisfy `17k + 5` (for example `5`, `22`, `39`, `56`). The
-examples below use 56 frames and 20 steps.
-
-`ed-cli` writes MiniMax-H3 output at 24 fps even if another `--fps` value is
-provided, matching sd.cpp and preserving the model's audio-video timing.
-
-Use `--video-format mp4` for H.264/AAC MP4 output when `ffmpeg` is available.
-Without `--audio-vae`, the model can still generate video, but no generated audio
-is decoded or muxed.
-
-## FL2VA usage
+### Persistent Q8_0 GGUF
 
-### Text to video + audio
+Q8_0 benchmark files are offline conversions of the full BF16 DiTs and Qwen3-VL,
+not Comfy-Org INT8 ConvRot weights. Convert once with `ed-convert` instead of
+quantizing during every model load:
 
 ```bash
-ed-cli --video \
-  --diffusion-model minimax_h3_fl2va-Q4_K_M.gguf \
-  --vae minimax_h3_video_vae_fp16.safetensors \
-  --audio-vae minimax_h3_audio_vae_fp32.safetensors \
-  --llm qwen3vl_32b_minimax_h3-Q4_K_M.gguf \
-  -p "A cat surfs on an ocean wave with upbeat surf-rock music." \
-  --cfg-scale 1 -W 864 -H 480 --fps 24 --video-frames 56 --steps 20 \
-  --diffusion-fa --rng cpu --video-format mp4 \
-  -o minimax_h3_t2va.mp4
+ed-convert --model models/minimax-h3/diffusion_models/minimax_h3_fl2va_bf16.safetensors \
+  --type q8_0 --output models/minimax-h3-q8/minimax_h3_fl2va-Q8_0.gguf
+ed-convert --model models/minimax-h3/diffusion_models/minimax_h3_ref2va_bf16.safetensors \
+  --type q8_0 --output models/minimax-h3-q8/minimax_h3_ref2va-Q8_0.gguf
+ed-convert --model models/minimax-h3/text_encoders/qwen3vl_32b_minimax_h3_bf16.safetensors \
+  --type q8_0 --output models/minimax-h3-q8/qwen3vl_32b_minimax_h3-Q8_0.gguf
 ```
 
-### First-frame image to video + audio
+The same converter accepts an official transformer
+`model.safetensors.index.json`; the resulting persistent GGUF is equivalent at
+the selected quantization type and avoids repeated online conversion.
 
-```bash
-ed-cli --video \
-  --diffusion-model minimax_h3_fl2va-Q4_K_M.gguf \
-  --vae minimax_h3_video_vae_fp16.safetensors \
-  --audio-vae minimax_h3_audio_vae_fp32.safetensors \
-  --llm qwen3vl_32b_minimax_h3-Q4_K_M.gguf \
-  --init-img first_frame.png \
-  -p "Animate the provided first frame into a cinematic shot with matching sound." \
-  --cfg-scale 1 -W 864 -H 480 --fps 24 --video-frames 56 --steps 20 \
-  --diffusion-fa --rng cpu --video-format mp4 \
-  -o minimax_h3_i2va.mp4
-```
+## Duration and frame count
 
-### First + last frame to video + audio
+MiniMax-H3 always generates at 24 fps. Its frame count must satisfy `17k + 5`,
+for example `5`, `22`, `39`, `56`, `73`, `90`, `107`, or `124`.
 
-```bash
-ed-cli --video \
-  --diffusion-model minimax_h3_fl2va-Q4_K_M.gguf \
-  --vae minimax_h3_video_vae_fp16.safetensors \
-  --audio-vae minimax_h3_audio_vae_fp32.safetensors \
-  --llm qwen3vl_32b_minimax_h3-Q4_K_M.gguf \
-  --image first_frame.png --end-img last_frame.png \
-  -p "Create a smooth transition from the first frame to the last frame with natural audio." \
-  --cfg-scale 1 -W 864 -H 480 --fps 24 --video-frames 56 --steps 20 \
-  --diffusion-fa --rng cpu --video-format mp4 \
-  -o minimax_h3_fl2va.mp4
-```
+Use `--video-duration <seconds>` for the convenient interface. The CLI converts
+the requested duration at 24 fps and selects the nearest legal frame count. For
+example, `--video-duration 5` resolves to 124 frames, or approximately 5.17
+seconds. The resolved value is printed before generation. Use
+`--video-frames <count>` when an exact legal frame count is required. The two
+options are mutually exclusive.
 
-## Ref2VA usage
+Flash attention is enabled by default; use `--no-flash-attention` only for
+diagnosis. The legacy `--rng` option is accepted for command compatibility but
+does not select a different RNG, so it is intentionally omitted below.
 
-When using references, write the prompt so it explicitly mentions the reference
-slots, such as `<Picture 1>`, `<Video 1>`, and `<Audio 1>`. This makes reference
-adherence easier to evaluate and avoids text-only prompts dominating the output.
+## Usage
 
-Reference media uses the released Diffusers preprocessing geometry independently
-of the generated `-W`/`-H` canvas. Reference images preserve their aspect ratio
-and resize to a `2048` pixel short edge. Reference videos preserve their aspect
-ratio and resolve from a `768` pixel short edge with a pre-rounding area cap of
-`768x1344`; both axes then round to multiples of `32`. Images and videos outside
-the supported `1:4` through `4:1` aspect-ratio range are rejected. Small inputs
-can therefore be upscaled substantially, which improves conditioning fidelity
-but increases Qwen3-VL and video-VAE time and peak memory.
-
-### Reference image
+Set component paths for the desired precision. The video and audio VAE files are
+shared by every precision and checkpoint.
 
 ```bash
-ed-cli --video \
-  --diffusion-model minimax_h3_ref2va-Q4_K_M.gguf \
-  --vae minimax_h3_video_vae_fp16.safetensors \
-  --audio-vae minimax_h3_audio_vae_fp32.safetensors \
-  --llm qwen3vl_32b_minimax_h3-Q4_K_M.gguf \
-  --ref-image reference.png \
-  -p "Use the landscape and lighting from <Picture 1> to create a cinematic video." \
-  --cfg-scale 1 -W 864 -H 480 --fps 24 --video-frames 56 --steps 20 \
-  --diffusion-fa --rng cpu --video-format mp4 \
-  -o minimax_h3_ref_image.mp4
+# Q4_K_M example. Replace the DiT with the Ref2VA file for reference workflows.
+DIT=models/minimax-h3-q4/minimax_h3_fl2va-Q4_K_M.gguf
+LLM=models/minimax-h3-q4/qwen3vl_32b_minimax_h3-Q4_K_M.gguf
+VIDEO_VAE=models/minimax-h3/vae/minimax_h3_video_vae_fp16.safetensors
+AUDIO_VAE=models/minimax-h3/vae/minimax_h3_audio_vae_fp32.safetensors
 ```
 
-### Reference video
+For BF16, point `DIT` and `LLM` to the downloaded BF16 safetensors. For Q8_0,
+point them to the converted GGUF files.
 
-```bash
-ed-cli --video \
-  --diffusion-model minimax_h3_ref2va-Q4_K_M.gguf \
-  --vae minimax_h3_video_vae_fp16.safetensors \
-  --audio-vae minimax_h3_audio_vae_fp32.safetensors \
-  --llm qwen3vl_32b_minimax_h3-Q4_K_M.gguf \
-  --ref-video reference_frames \
-  -p "Follow the camera motion and scene layout from <Video 1>." \
-  --cfg-scale 1 -W 864 -H 480 --fps 24 --video-frames 56 --steps 20 \
-  --diffusion-fa --rng cpu --video-format mp4 \
-  -o minimax_h3_ref_video.mp4
-```
-
-### Reference video with paired audio
+### FL2VA
 
 ```bash
-ed-cli --video \
-  --diffusion-model minimax_h3_ref2va-Q4_K_M.gguf \
-  --vae minimax_h3_video_vae_fp16.safetensors \
-  --audio-vae minimax_h3_audio_vae_fp32.safetensors \
-  --llm qwen3vl_32b_minimax_h3-Q4_K_M.gguf \
-  --ref-video reference_frames \
-  --ref-video-audio reference_soundtrack.wav \
-  -p "Follow the motion from <Video 1> and use its paired soundtrack as audio guidance." \
-  --cfg-scale 1 -W 864 -H 480 --fps 24 --video-frames 56 --steps 20 \
-  --diffusion-fa --rng cpu --video-format mp4 \
-  -o minimax_h3_ref_video_audio.mp4
+# Text to video and audio
+ed-cli --video --diffusion-model "$DIT" --llm "$LLM" \
+  --vae "$VIDEO_VAE" --audio-vae "$AUDIO_VAE" \
+  --video-duration 5 -W 864 -H 480 --steps 20 --cfg-scale 1 \
+  --prompt "A cinematic sunset over layered mountain ridges with quiet natural ambience." \
+  --video-format mp4 --output t2va.mp4
+
+# First frame
+ed-cli --video --diffusion-model "$DIT" --llm "$LLM" \
+  --vae "$VIDEO_VAE" --audio-vae "$AUDIO_VAE" --image first.png \
+  --video-duration 5 -W 864 -H 480 --steps 20 --cfg-scale 1 \
+  --prompt "Starting from <Picture 1>, preserve the scene and add subtle natural motion." \
+  --video-format mp4 --output i2va.mp4
+
+# Last frame: use --end-img last.png
+# First and last frames: use --image first.png --end-img last.png
 ```
 
-### Mixed references
+### Ref2VA
+
+Use the Ref2VA DiT for all commands in this section.
 
 ```bash
-ed-cli --video \
-  --diffusion-model minimax_h3_ref2va-Q4_K_M.gguf \
-  --vae minimax_h3_video_vae_fp16.safetensors \
-  --audio-vae minimax_h3_audio_vae_fp32.safetensors \
-  --llm qwen3vl_32b_minimax_h3-Q4_K_M.gguf \
-  --ref-image reference.png \
-  --ref-video reference_frames \
-  --ref-video-audio reference_soundtrack.wav \
-  --ref-audio extra_audio.wav \
-  -p "Use the style from <Picture 1>, motion from <Video 1>, the paired video soundtrack, and additional ambience from <Audio 2>." \
-  --cfg-scale 1 -W 864 -H 480 --fps 24 --video-frames 56 --steps 20 \
-  --diffusion-fa --rng cpu --video-format mp4 \
-  -o minimax_h3_ref_mixed.mp4
+# Image reference
+ed-cli --video --diffusion-model "$DIT" --llm "$LLM" \
+  --vae "$VIDEO_VAE" --audio-vae "$AUDIO_VAE" \
+  --ref-image reference.png --video-duration 5 -W 864 -H 480 --steps 20 \
+  --cfg-scale 1 --prompt "Use <Picture 1> as the strict visual reference." \
+  --video-format mp4 --output ref-image.mp4
+
+# MP4 reference; embedded audio is paired automatically when present
+ed-cli --video --diffusion-model "$DIT" --llm "$LLM" \
+  --vae "$VIDEO_VAE" --audio-vae "$AUDIO_VAE" \
+  --ref-video reference.mp4 --video-duration 5 -W 864 -H 480 --steps 20 \
+  --cfg-scale 1 --prompt "Preserve <Video 1> and its <Audio 1> throughout the result." \
+  --video-format mp4 --output ref-video.mp4
+
+# Frame directory with explicit paired audio
+ed-cli --video --diffusion-model "$DIT" --llm "$LLM" \
+  --vae "$VIDEO_VAE" --audio-vae "$AUDIO_VAE" \
+  --ref-video reference-frames --ref-video-audio soundtrack.wav \
+  --video-duration 5 -W 864 -H 480 --steps 20 --cfg-scale 1 \
+  --prompt "Preserve <Video 1> and synchronize it with <Audio 1>." \
+  --video-format mp4 --output ref-video-audio.mp4
+
+# Mixed image, video, and additional audio
+ed-cli --video --diffusion-model "$DIT" --llm "$LLM" \
+  --vae "$VIDEO_VAE" --audio-vae "$AUDIO_VAE" \
+  --ref-image reference.png --ref-video reference.mp4 --ref-audio music.wav \
+  --video-duration 5 -W 864 -H 480 --steps 20 --cfg-scale 1 \
+  --prompt "Use <Video 1>, <Picture 1>, and every supplied audio reference in a natural transition." \
+  --video-format mp4 --output ref-mixed.mp4
 ```
 
-In a mixed prompt, paired video audio is presented before the video as `<Audio 1>`.
-Standalone `--ref-audio` entries are numbered after video-paired audio, so the
-first standalone audio in the example is `<Audio 2>`.
-
 ## Memory placement
 
-MiniMax-H3 supports the regular component offload flags:
-
-```text
---dit-offload
---text-encoder-offload
---vae-offload
---vae-tiling on|off|auto
-```
-
-For automatic placement, pass `--auto-fit --max-vram <GB>`. The runtime measures
-a conservative Ref2VA mixed-conditioning graph at the requested width, height,
-and frame count, then independently places the DiT, Qwen3-VL, video VAE, and
-audio VAE. `--max-vram` is a hard placement budget under `--auto-fit`; components
-that do not fit are segmented and staged from host memory while CUDA remains the
-compute backend.
+The explicit component controls are `--dit-offload`,
+`--text-encoder-offload`, and `--vae-offload`. For automatic placement, use
+`--auto-fit --max-vram <GB>`. MiniMax-H3 independently places the DiT,
+Qwen3-VL, video VAE, and audio VAE while retaining CUDA compute.
 
 ```bash
-ed-cli --video \
-  --diffusion-model minimax_h3_fl2va-diffusers-Q8_0.gguf \
-  --vae minimax_h3_video_vae_fp16.safetensors \
-  --audio-vae minimax_h3_audio_vae_fp32.safetensors \
-  --llm qwen3vl_32b_minimax_h3-Q8_0.gguf \
-  --auto-fit --max-vram 40 --vae-tiling auto \
-  -W 864 -H 480 --video-frames 124 --fps 24 --steps 20 \
-  --cfg-scale 1 --diffusion-fa --rng cpu \
-  -p "A cinematic sunset over layered mountain ridges." \
-  --video-format mp4 -o minimax_h3_autofit.mp4
+ed-cli --video --diffusion-model "$DIT" --llm "$LLM" \
+  --vae "$VIDEO_VAE" --audio-vae "$AUDIO_VAE" \
+  --auto-fit --max-vram 40 --video-duration 5 -W 864 -H 480 --steps 20 \
+  --cfg-scale 1 --prompt "A cinematic sunset over layered mountain ridges." \
+  --video-format mp4 --output auto-fit.mp4
 ```
 
-The explicit offload flags remain useful when placement must be fixed manually.
-Do not combine them merely to emulate `--auto-fit`; automatic placement normally
-chooses a safer component combination for the requested budget.
-
-MiniMax-H3's video VAE always uses its model-specific fixed `16x16` spatial
-tiling path. This intentionally overrides the generic `--vae-tiling` state and
-`--vae-tile-size`; those flags continue to control other VAE implementations.
-The internal override can be disabled only with the diagnostic environment
-variable `ED_MINIMAX_H3_DISABLE_FORCED_VAE_TILING=1`, which is not recommended
-for normal generation.
-
-On CUDA builds with cuDNN Conv3D, MiniMax-H3 reference encoding uses cuDNN for
-the video-VAE encoder and fuses its spatial reflect padding and temporal group
-normalization without changing the conditioning geometry. The reflect-padding
-and group-normalization paths are numerically identical to the legacy graph;
-cuDNN Conv3D can differ slightly because of floating-point reduction order. For
-diagnosis, the individual paths can be disabled with
-`ED_MINIMAX_H3_VAE_ENCODER_CUDNN_CONV3D=0`,
-`ED_MINIMAX_H3_VAE_ENCODER_CUDNN_CONV3D_ALL=0`,
-`ED_MINIMAX_H3_VAE_FUSED_REFLECT_PAD=0`, or
-`ED_MINIMAX_H3_VAE_FUSED_TEMPORAL_GROUP_NORM=0`. Contiguous causal temporal
-zero-padding uses a byte-equivalent 2D memset/copy CUDA path; set
-`ED_CUDA_PAD_TEMPORAL_COPY2D=0` to restore the elementwise padding kernel.
-
-Ref2VA multimodal presentations are assembled directly as token IDs. Visual
-placeholder tokens are no longer serialized into a large string and repeatedly
-tokenized as image and video blocks are appended. Set
-`ED_MINIMAX_H3_VERIFY_DIRECT_TOKEN_BUILD=1` to compare the direct sequence with
-the legacy tokenizer path token by token during debugging.
-
-Qwen3-VL vision FlashAttention synchronizes each long vision block before its
-temporary storage is reused. This avoids asynchronous scratch reuse changing
-the image-conditioning result and substantially reduces high-resolution image
-encoding time on H200. Set `ED_QWEN_VISION_FLASH_ATTN_SYNC=0` only for
-diagnostic comparison with the legacy path.
-
-On SM90 GPUs, long-sequence Q8_0 MiniMax-H3 FC2 projections can be routed from
-GGML MMQ to cuBLAS. This route is enabled by default after its full-video H200
-quality gate reached 50.17 dB PSNR and 0.9932 SSIM while reducing DiT time by
-7.5%. Set `GGML_CUDA_SM90_Q8_CUBLAS_FC2=0` to restore the MMQ path.
-`GGML_CUDA_SM90_Q8_CUBLAS_FC2_STEPS` and
-`GGML_CUDA_SM90_Q8_CUBLAS_FC2_LAYERS` restrict the experiment to selected
-diffusion steps or transformer layers.
-
-## H200 performance
-
-The following Edge measurements use CUDA on one H200, `864x480`, 124 frames,
-24 fps, 20 steps, CFG 1, CPU RNG, seed `424242`, resident components, and warmed
-model files. Wall time includes load, generation, mux/save, and cleanup.
-
-| Precision | T2VA | I2VA | L2VA | FL2VA |
-|---|---:|---:|---:|---:|
-| BF16 wall / peak VRAM | 71s / 125,051 MiB | 73s / 125,251 MiB | 81s / 125,247 MiB | 76s / 125,471 MiB |
-| Q8_0 wall / peak VRAM | 81.1s / 71,393 MiB | 84.5s / 71,585 MiB | 84.6s / 71,583 MiB | 90.0s / 71,805 MiB |
-| Q4_K_M wall / peak VRAM | 73.6s / 47,459 MiB | 73.1s / 47,609 MiB | 73.0s / 47,607 MiB | 76.7s / 47,785 MiB |
-
-Use persistent GGUF files for Q8/Q4 production runs. Loading official BF16
-shards with `--tensor-type-rules ...=q8_0` performs quantization on every start;
-in the measured FL2VA run that increased load from about 9.3s to about 45s.
-On SM90, the optimized MiniMax-H3 route applies only to named main-block QKV/FC1
-projections; it does not alter unrelated models.
-
-`--auto-fit` was also validated with the same Q8_0 components at two sampling
-steps. Every observed peak stayed below its requested cap:
-
-| `--max-vram` | DiT | Qwen3-VL | Video/Audio VAE | Peak VRAM | Wall |
-|---:|---|---|---|---:|---:|
-| 120 GB | resident | resident | resident / resident | 71,397 MiB | 28.7s |
-| 60 GB | resident | offloaded | offloaded / offloaded | 45,129 MiB | 39.8s |
-| 40 GB | offloaded | offloaded | resident / resident | 31,699 MiB | 46.5s |
-| 24 GB | offloaded | offloaded | offloaded / offloaded | 18,337 MiB | 50.6s |
-
-The 40 GB configuration additionally passed FL2VA first+last-frame conditioning
-at 31,865 MiB. A Ref2VA mixed image+video+paired-audio+additional-audio run passed
-at a 60 GB budget with a 49,361 MiB peak. Full framework comparisons are in the
-[BF16 benchmark](optimization/minimax-h3-fl2va-ref2va-edge-sdcpp-diffusers-h200-bf16-full-ref-2026-08-13.md),
-[framework-native 8-bit benchmark](optimization/minimax-h3-fl2va-ref2va-edge-sdcpp-diffusers-h200-8bit-full-ref-2026-08-13.md),
-and [Q4 benchmark](optimization/minimax-h3-fl2va-ref2va-edge-sdcpp-diffusers-h200-q4-full-ref-2026-08-14.md).
-
-## Current limitations
-
-- Audio-only Ref2VA is intentionally rejected; `--ref-audio` needs at least one
-  `--ref-image` or `--ref-video`.
-- Matching seeds across Edge, sd.cpp, and Diffusers do not guarantee identical
-  videos because their quantization and numerical kernels differ.
-- Reference adherence remains prompt dependent. Mention `<Picture N>`,
-  `<Video N>`, and `<Audio N>` explicitly and visually inspect the result.
-- Media-file `--ref-video` decoding and embedded-audio extraction require
-  `ffmpeg`; use a frame directory plus `--ref-video-audio` when it is unavailable.
-- Audio reference effects are easiest to judge with listening tests; contact
-  sheets only validate the video stream.
+MiniMax-H3 always uses its fixed `16x16` video-VAE tiling path. Generic
+`--vae-tiling` and `--vae-tile-size` values do not replace this model-specific
+layout.
+
+## H200 BF16 comparison
+
+The tables below use one H200, resident components, `864x480`, 124 frames at
+24 fps, 20 steps, CFG 1, and seed `424242`. Edge uses the complete Comfy-Org
+BF16 DiT/Qwen files, FP16 video VAE, and FP32 audio VAE. Diffusers uses the
+official complete BF16 DiT shards, BF16 Qwen3-VL, and its FP32 VAEs. “Generate”
+excludes model loading, output muxing, and process cleanup. Peak VRAM is sampled
+over the complete process. Values are `Edge / Diffusers`.
+
+FL2VA does not use Ref2VA resize preprocessing:
+
+| Task | Generate | Peak VRAM |
+|---|---:|---:|
+| Text | 51.396s / 53.986s | 125,051 / 128,801 MiB |
+| First frame | 54.810s / 57.817s | 125,353 / 129,957 MiB |
+| Last frame | 55.323s / 57.793s | 125,351 / 129,957 MiB |
+| First + last frames | 58.747s / 61.405s | 125,573 / 130,587 MiB |
+
+### Ref2VA resize correction
+
+The legacy Edge snapshot below predates Diffusers-compatible reference resize.
+It encoded smaller reference images/videos, so its apparent speed and memory
+advantage does not represent equal conditioning geometry. Diffusers values are
+shown only as the comparison baseline.
+
+| Legacy task | Generate | Peak VRAM |
+|---|---:|---:|
+| Image | 54.858s / 136.656s | 125,245 / 139,253 MiB |
+| Video frames | 114.843s / 183.921s | 130,029 / 137,161 MiB |
+| Video frames + paired audio | 115.488s / 185.035s | 130,029 / 137,183 MiB |
+| Mixed references | 121.558s / 319.435s | 130,029 / 141,915 MiB |
+
+Current preprocessing follows Diffusers geometry: image short edge 2048;
+video short edge 768 with a pre-rounding `768x1344` area cap; preserved aspect
+ratio; dimensions rounded to multiples of 32; Lanczos resize. Repeating the same
+BF16 tasks with aligned conditioning gives:
+
+| Aligned task | Generate | Peak VRAM |
+|---|---:|---:|
+| Image | 140.827s / 136.656s | 130,379 / 139,253 MiB |
+| Video frames | 232.816s / 183.921s | 131,225 / 137,161 MiB |
+| Video frames + paired audio | 232.327s / 185.035s | 131,539 / 137,183 MiB |
+| Mixed references | 386.005s / 319.435s | 137,191 / 141,915 MiB |
+
+The two Ref2VA tables differ only in Edge reference preprocessing. They must not
+be combined into one speed trend: the first is historical and geometrically
+under-sized; the second is the cross-framework conditioning comparison.
+
+## Limitations
+
+- Reference adherence is prompt dependent. Name `<Picture N>`, `<Video N>`, and
+  `<Audio N>` explicitly when their roles matter.
+- Matching seeds across frameworks does not guarantee identical videos because
+  numerical kernels and weight formats differ.
+- Media-file reference decoding and embedded-audio extraction require `ffmpeg`.
+- Without `--audio-vae`, video generation works but generated audio is not
+  decoded or muxed.
diff --git a/docs/models.md b/docs/models.md
index dfb1442..d2ae828 100644
--- a/docs/models.md
+++ b/docs/models.md
@@ -142,8 +142,9 @@ first+last-frame, and Ref2VA conditioning through standalone component loading.
 Ref2VA accepts repeatable images, frame directories or media files, paired or
 embedded video audio, and additional audio (additional audio cannot be used by
 itself). Both checkpoints support `--auto-fit --max-vram`; placement covers the
-DiT, Qwen3-VL, video VAE, and audio VAE. See [MiniMax-H3 usage and H200
-performance](minimax-h3.md).
+DiT, Qwen3-VL, video VAE, and audio VAE. Use `--video-duration` for seconds or
+`--video-frames` for an exact legal `17k+5` frame count. See [MiniMax-H3 usage,
+weights, and H200 performance](minimax-h3.md).
 
 Supported output formats are `auto`, `avi`, `mp4`, `mov`, `mkv`, and `webm`.
 The CLI uses `ED_FFMPEG` when set and can also find imageio-ffmpeg binaries in
diff --git a/docs/optimization/minimax-h3-edge-generation-performance-2026-08-09.md b/docs/optimization/minimax-h3-edge-generation-performance-2026-08-09.md
deleted file mode 100644
index 491871d..0000000
--- a/docs/optimization/minimax-h3-edge-generation-performance-2026-08-09.md
+++ /dev/null
@@ -1,760 +0,0 @@
-# MiniMax-H3 Edge Generation Performance Baseline — 2026-08-09
-
-This document preserves the baseline and optimization context for the MiniMax-H3 Edge generation performance work planned for the evening of 2026-08-09.
-
-## Primary objective
-
-Reduce Edge's resident/warm video generation time while preserving the current output quality. The primary comparison target is the diffusers TorchAO INT4 generation path, not cold-start wall time.
-
-## Benchmark task
-
-- Workflow: I2VA
-- Content: adult woman raises a selfie stick, waves, makes a V-sign, then triggers a synchronized flash and shutter sound
-- Resolution: 864x480
-- Frames: 124
-- FPS: 24
-- Output duration: 5.1667 seconds
-- Inference steps: 20, resulting in 19 transformer calls
-- Seed: 314159
-- CFG scale: 1 for Edge and sd.cpp
-- Hardware: one NVIDIA H200
-- Input: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/inputs/first.png`
-- Prompt: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/prompt.txt`
-
-## Weight and runtime configurations
-
-### Edge
-
-- DiT: `minimax_h3_fl2va-Q4_K_M.gguf`
-- Text encoder: `qwen3vl_32b_minimax_h3-Q4_K_M.gguf`
-- Video VAE: FP16 safetensors
-- Audio VAE: FP32 safetensors
-- Flash attention enabled
-- Forced MiniMax-H3 VAE tiling remains active despite the CLI `--vae-tiling off` setting
-
-### sd.cpp
-
-- Uses the same GGUF DiT, GGUF text encoder, video VAE, and audio VAE files as Edge
-- Flash attention and VAE tiling enabled
-- CPU RNG
-- Unmodified downloaded sd.cpp build
-
-### diffusers
-
-- Official MiniMax-H3 diffusers checkpoint
-- Transformer and text encoder use TorchAO weight-only INT4, group size 128
-- BF16 activations/compute where applicable
-- Components remain resident on CUDA during generation
-
-The Edge/sd.cpp and diffusers weights and quantization formats are not numerically identical. Performance comparisons therefore measure practical framework configurations rather than identical kernels over identical quantized tensors.
-
-## Timing results
-
-| Framework | Cold script wall | Framework pipeline/generate | Denoising/transformer | Decode |
-|---|---:|---:|---:|---:|
-| Edge Q4_K_M | 117.140 s | 107.921 s generation | 94.445 s | 11.914 s |
-| sd.cpp Q4_K_M | 274.124 s | 271.120 s generation | 239.050 s sampling | included in remaining time |
-| diffusers TorchAO INT4 | 118.724 s | 59.397 s CUDA generation | 53.621 s transformer | 3.731 s video VAE + 0.129 s audio VAE |
-
-Additional cold-start data:
-
-- Edge model load: 6.572 s
-- Edge output save: 1.425 s
-- diffusers pipeline initialization, checkpoint loading, quantization, and finalization: 46.492 s
-- diffusers mux: 0.640 s
-- diffusers internal end-to-end time: 106.530 s
-
-## Important interpretation
-
-- Edge and diffusers have similar cold script wall time only because diffusers spends about 46.5 seconds loading and quantizing components.
-- The relevant steady-state comparison is Edge generation `107.921 s` versus diffusers CUDA generation `59.397 s`.
-- Edge generation is currently about **1.82x slower** than diffusers after components are ready.
-- Edge DiT diffusion is about **1.76x slower** than diffusers transformer forwards: `94.445 / 53.621`.
-- Edge decode is about **3.09x slower** than the measured diffusers video and audio VAE decode total: `11.914 / 3.859`.
-- Edge is about **2.34x faster** than sd.cpp in cold script wall time for this task.
-
-## Edge profile breakdown
-
-```text
-total=107921 ms
-conditioning=1047 ms
-diffusion=94445 ms (19 steps, 19 calls)
-decode=11914 ms
-noise=258 ms
-
-conditioning:
-  context=647 ms
-  vision image prepare=130 ms
-  vision encode=208 ms
-  text tokenize=20 ms
-  text encode=289 ms
-  keyframe VAE=400 ms
-
-decode:
-  video VAE=10831 ms
-  video copy=109 ms
-  audio VAE=969 ms
-  audio copy=5 ms
-```
-
-## diffusers profile breakdown
-
-```text
-generate_cuda=59.397 s
-transformer_forward_cuda=53.621 s (19 calls)
-text_encoder=0.477 s
-video_vae_encode=0.156 s
-video_vae_decode=3.731 s
-audio_vae_decode=0.129 s
-```
-
-## Quality checkpoint
-
-All three frameworks generated a usable video with:
-
-- a selfie stick and attached phone;
-- a friendly wave;
-- a V-sign pose;
-- a late flash near frames 118-120;
-- a synchronized late audio transient near 4.91-4.99 seconds.
-
-No obvious small pixel-block artifact was observed in this task. Edge produced the strongest visible flash. sd.cpp remained slightly softer. The optimization must preserve this Edge quality baseline.
-
-## Optimization priority
-
-1. Profile each Edge DiT block and operator over the 19 calls; diffusion represents 87.5% of Edge generation time.
-2. Compare Edge attention, linear/Q4_K, modulation, RoPE, and graph-launch timings with the diffusers transformer profile.
-3. Verify CUDA graph coverage, graph breaks, temporary allocations, synchronization, and host-device traffic during each DiT call.
-4. Investigate the video VAE decode path, especially forced spatial tiling, repeated tile graph execution, overlap blending, and per-tile launch overhead.
-5. Re-run this exact benchmark after each change and report warm generation time separately from load/save time.
-6. Reject optimizations that regress selfie-stick geometry, hands, flash timing, audio transient, or introduce block artifacts.
-
-## Reproduction and artifacts
-
-- Edge command: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge/run.sh`
-- Edge log: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge/run.log`
-- sd.cpp command: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/sdcpp/run.sh`
-- sd.cpp log: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/sdcpp/run.log`
-- diffusers command: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/diffusers/run.sh`
-- diffusers profile: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/diffusers/final.json`
-- Consolidated timing: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/review/summary.json`
-- Visual montage: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/review/montage.jpg`
-- Audio transient analysis: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/review/audio-transients.json`
-- Edge video: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge/final.mp4`
-- sd.cpp video: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/sdcpp/final.mp4`
-- diffusers video: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/diffusers/final.mp4`
-
-## 2026-08-09 SM90 Q4_K result
-
-A full clean CUDA rebuild confirmed that the original selfie baseline used the
-quality-safe GGUF Q4_K MMQ route. The earlier 124-frame result that was close to
-Diffusers used the existing Hopper-specific dequantize + cuBLAS route via
-`GGML_CUDA_SM90_Q4K_CUBLAS=1`; omitting that environment switch explains the
-large apparent regression. This is an execution-kernel choice, not a reduction
-in frames, steps, resolution, conditioning, or VAE quality settings.
-
-The final same-task run used the SM90 Q4_K route plus the previously validated
-equivalent decode/backend switches. Request parameters, model files, seed,
-scheduler calls, flash attention, and forced 16x16 latent VAE tiling remained
-unchanged.
-
-| Metric | Original Edge | Optimized Edge | Diffusers | Edge improvement |
-|---|---:|---:|---:|---:|
-| Generation | `107.921s` | `73.114s` | `59.397s` | `32.3%` |
-| DiT diffusion / transformer | `94.445s` | `61.769s` | `53.621s` | `34.6%` |
-| Decode | `11.914s` | `9.768s` | `3.859s` | `18.0%` |
-| Script wall | `117.140s` | `82.076s` | `118.724s` cold | `29.9%` |
-
-The optimized Edge DiT is now `1.15x` the Diffusers transformer time rather
-than `1.76x`. The remaining generation gap is about `13.7s`, split between an
-approximately `8.1s` DiT gap and an approximately `5.9s` non-DiT gap.
-
-Quality gates:
-
-- Output has 124 frames at 864x480 with a 5.17-second audio stream.
-- The person identity, selfie stick, wave, V-sign, and late camera flash remain.
-- The optimized video has no visible black-frame failure or obvious micro-block artifact.
-- Mean block-boundary metrics changed only slightly: b4 `0.01085 -> 0.01099`,
-  b8 `0.01128 -> 0.01152`, b16 `0.01169 -> 0.01200`.
-- The late audio transient remains at `4.998s` versus `4.997s` in the original.
-- The optimized trajectory is not numerically equivalent to MMQ (`22.18dB`
-  average encoded-video PSNR), so the SM90 route remains an explicit validated
-  performance profile rather than an unconditional global default.
-
-Artifacts:
-
-- Reproduction: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-sm90-safe-full/run.sh`
-- Optimized log: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-sm90-safe-full/run.log`
-- Optimized video: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-sm90-safe-full/final.mp4`
-- Visual comparison: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/review-sm90/base-vs-sm90.jpg`
-- Block metrics: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/review-sm90/block-metrics.json`
-- Audio transients: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/review-sm90/audio-transients.json`
-
-## Layered DiT and VAE profiling
-
-A same-shape `864x480`, 124-frame, 3-step probe (two DiT forwards) was used
-before repeating the full 20-step task. Existing runner timing and CUDA-event
-operator profiling were enabled together. Nsight Compute was attempted, but
-this node denies hardware performance counters (`ERR_NVGPUCTRPERM`).
-
-The first DiT call took `5.374s` (`5.369s` GPU compute), while the steady call
-took `3.122s` (`3.105s` GPU compute). Build, allocation, and copy were only
-about `17ms` in the steady call, ruling them out as the remaining DiT gap.
-
-CUDA-event profiling covered `2.903s` of a `3.170s` profiled steady call:
-
-| Operator | Device time | Share |
-|---|---:|---:|
-| `MUL_MAT` | `1.549s` | `53.4%` |
-| `FLASH_ATTN_EXT` | `0.710s` | `24.5%` |
-| `SCALE` | `0.255s` | `8.8%` |
-| `CONCAT` | `0.124s` | `4.3%` |
-| `CONT` | `0.074s` | `2.5%` |
-| `CPY` | `0.056s` | `1.9%` |
-| fused RoPE custom op | `0.053s` | `1.8%` |
-| `GLU` | `0.049s` | `1.7%` |
-
-The matmul internal profile identifies the backend-format bottleneck: 150
-large Q4_K MLP projections per forward use quality-safe FP32/TF32 SGEMM,
-while 50 QKV projections use FP16 Tensor Core GEMM. FC1 SGEMM costs `637.3ms`,
-the two FC2 groups cost `319.4ms + 161.1ms`, QKV GEMM costs `270.2ms`, and QKV
-output conversion costs `70.1ms` per forward. The remaining quality-safe gap
-is primarily GGUF Q4_K layout and repeated dequantization versus Diffusers'
-resident packed INT4 Hopper kernel, not graph/framework overhead.
-
-The video VAE executes seven temporal chunks with ten spatial tiles each. A
-representative call-chain split was:
-
-| Stage | Time |
-|---|---:|
-| 70 tile runner calls | `5.806s` |
-| tile split | `0.041s` |
-| spatial tile merge | `0.436s` |
-| temporal output slicing | `0.141s` |
-| temporal overlap blend | `1.427s` |
-| final temporal collection | `0.758s` |
-
-The VAE device operator profile totals about `4.27s`; `CONT` (`1.60s`) and
-flash attention (`1.20s`) are the largest categories. Three explicit,
-mathematically equivalent copy-path experiments were added:
-
-- `ED_VAE_PLANE_PARALLEL_TILE_COPY=1`
-- `ED_MINIMAX_H3_MOVE_TEMPORAL_BLEND=1`
-- `ED_MINIMAX_H3_PARALLEL_TEMPORAL_COPY=1`
-
-On a same-binary short A/B, the combined path reduced video VAE
-`9.269s -> 8.208s` (`11.4%`). Input VAE latent SHA256 matched and decoded video
-PSNR was `inf`. On the full same-binary task, control and combined video VAE
-were `8.810s` and `8.744s`; full decoded-video PSNR was also `inf`, but the
-`66ms` timing difference is within run variance. Keep these switches explicit
-until repeated full runs demonstrate stable benefit.
-
-Artifacts:
-
-- Operator profile: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/profile-2026-08-09/op-profile-3step.log`
-- Parsed operators: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/profile-2026-08-09/op-profile-summary.json`
-- Temporal profile: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/profile-2026-08-09/vae-temporal-breakdown-3step.log`
-- Full control: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-current-control-full/run.log`
-- Full combined VAE path: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-vae-all-copy-full/run.log`
-- Full quality check: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/profile-2026-08-09/full-control-vs-vae-all-copy-psnr.log`
-
-## 2026-08-09 clean-build and three-framework recheck
-
-The current Edge worktree was rebuilt from an empty `build-cuda-docker`
-directory at commit `2f74ed70638518094860f5fe6f6f14885ca6ceef`. The build used
-Release mode, CUDA architecture 90, cuDNN SDPA, CUDA norm, CUDA RoPE, CUDA
-modulation, and benchmark markers. Because the clean tree did not contain a
-vendored `cudnn-frontend`, CMake fetched the project's pinned `07b368a`
-revision through `ED_FETCH_CUDNN_FRONTEND=ON`; no backend capability was
-removed to make the clean build pass.
-
-All three frameworks were then run sequentially on GPU 0 with the same input,
-prompt, seed `314159`, `864x480`, 124 requested frames, 24 fps, CFG 1, and 20
-requested steps. All resulting MP4 files contain 124 frames at `864x480` and a
-5.175-second audio stream.
-
-| Framework | Generation / sampling | DiT / transformer | Video VAE | Script wall |
-|---|---:|---:|---:|---:|
-| Edge clean rebuild | `72.819s` | `61.710s` | `8.449s` | `81.784s` |
-| Diffusers rerun | `59.430s` CUDA | `53.461s` | `3.760s` | `112.073s` cold |
-| unmodified sd.cpp rerun | `271.27s` generate | `239.17s` sampling | `17.20s` video + `9.29s` audio | `274.462s` |
-
-The reruns are consistent with the previous measurements. Edge's previous
-same-path DiT result was `61.749s`, and Diffusers' previous transformer result
-was `53.621s`. The clean binary therefore does not remove the remaining gap:
-Edge DiT is `8.249s`, or `15.4%`, slower than the practical Diffusers TorchAO
-INT4 configuration. Edge video VAE is `4.689s`, or `2.25x`, slower.
-
-The earlier apparent `94.445s` versus `53.621s` DiT regression came from an
-Edge run that omitted `GGML_CUDA_SM90_Q4K_CUBLAS=1`. Restoring that existing
-Hopper Q4_K execution path reduced Edge DiT to about `61.7s` without changing
-resolution, frame count, steps, prompt, conditioning, seed, or model files.
-This is the large non-parameter-tuning acceleration that should be preserved.
-It changes floating-point execution order and is not bit-exact with the MMQ
-trajectory, so it remains an explicit quality-validated profile rather than a
-global unconditional default. The clean-rebuild MP4 is bit-identical after
-decode to the previous same-path control (`PSNR inf`).
-
-The request-level benchmark parameters are aligned, but the three numerical
-pipelines are not identical:
-
-- Edge and sd.cpp load the same Q4_K_M GGUF DiT and Q4_K_M GGUF conditioner.
-- Diffusers loads the official BF16 checkpoint and quantizes selected linear
-  layers to resident TorchAO group-size-128 INT4 at startup.
-- Edge and sd.cpp therefore do not execute the same quantized tensors or INT4
-  kernel as Diffusers; performance and generated trajectories may differ.
-- Edge reports forced 16x16 latent spatial tiling even when the CLI requests
-  `--vae-tiling off`, executing seven temporal chunks and ten spatial tiles per
-  chunk. The official Diffusers decoder also enables spatial tiling by default;
-  its single profiled Python decode call contains the internal tiled decode and
-  blending work. The remaining VAE gap is therefore an implementation and data
-  residency difference, not simply "Edge tiles while Diffusers does not".
-- sd.cpp explicitly enables VAE tiling and uses `--rng cpu`. It is the
-  downloaded, unmodified commit `c6beeef35526c6dc94b74a7fb69f9d2e6a2a7a12`
-  with binary SHA256
-  `3e840a252f480116d5fc8fc58236ee95b8f6cc50b1738c91afa1464638a6fcea`.
-
-The steady Edge runner profile still attributes only about `17ms` per DiT
-forward to graph build/allocation/copy. The remaining DiT gap is therefore not
-explained by stale binaries or generic framework overhead. Operator profiling
-continues to point to repeated GGUF Q4_K dequantization plus FP32/TF32 SGEMM,
-especially the MLP projections, versus Diffusers' resident packed INT4 Hopper
-kernel. The next quality-preserving acceleration target should retain exact
-Q4_K weights in a resident prepacked representation or provide a dedicated
-SM90 kernel, rather than reducing generation parameters or widening selected
-layers to a trajectory-changing FP16 path.
-
-Recheck artifacts:
-
-- Edge command and manifest: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/rebuild-2f74ed7-full/`
-- Diffusers command, manifest, and JSON: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/recheck-diffusers-2026-08-09/`
-- sd.cpp command and binary manifest: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/recheck-sdcpp-2026-08-09/`
-- Clean-build equivalence check: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/recheck-diffusers-2026-08-09/edge-old-vs-clean-rebuild-psnr.log`
-
-## 2026-08-09 independent clean-build optimized recheck
-
-To rule out stale incremental objects again after adding the QKV, FC1, and VAE
-blend experiments, a second independent build was configured from an empty
-`build-cuda-clean-20260809` directory. It uses the same Release, SM90, CUDA
-graph, cuDNN SDPA, CUDA norm, CUDA RoPE, and CUDA modulation options as the
-active build. Only the pinned `cudnn-frontend` source checkout at revision
-`07b368a` was reused; no object files or binaries were reused. The first clean
-configure attempt also confirmed that the project-level switch must be
-`ED_GGML_CUDA=ON`, not the lower-level `GGML_CUDA=ON`, because the former adds
-the Edge CUDA extension sources, definitions, and include paths.
-
-The full 124-frame benchmark was rerun from that independent binary with the
-same prompt, input, model files, seed, dimensions, frame count, CFG, and step
-count. No resolution, frame, step, scheduler, or cache tuning was used. The
-following explicit experimental switches were enabled:
-
-- `ED_MINIMAX_H3_QKV_F32_OUTPUT=1`
-- `ED_MINIMAX_H3_FC1_F32_OUTPUT=1`
-- `ED_MINIMAX_H3_FAST_TEMPORAL_BLEND=1`
-
-The CLI still says `--vae-tiling off`, but the H3 decoder overrides the generic
-flag and logs ten 16x16-latent spatial tiles for every temporal chunk. Thus the
-actual H3 VAE remains tiled, matching the established Edge benchmark behavior.
-
-| Path | Generation | DiT | Video VAE | Audio VAE | Script wall |
-|---|---:|---:|---:|---:|---:|
-| Edge independent clean build | `63.914s` | `53.836s` | `7.441s` | `0.974s` | `72.821s` |
-| Diffusers TorchAO INT4 | `59.430s` | `53.461s` | `3.760s` | `0.125s` | `112.073s` cold |
-
-The optimized Edge DiT is only `0.375s` (`0.7%`) slower than Diffusers on this
-task. This closes the practical DiT timing gap, but it does not yet establish
-an exact or generally quality-safe replacement: the FC1 route converts Q4_K
-weights and FP32 activations to FP16 Tensor Core inputs with FP32 accumulation
-and output. It changes numerical precision and remains behind an explicit
-switch. A second task with different content must pass a full visual quality
-check before considering it for a default performance profile. The QKV route
-has the same precision caveat, although its smaller scope makes it the safer
-candidate.
-
-The temporal blend optimization is mathematically equivalent and preserves the
-original operation order per output pixel. Its short same-binary A/B produced
-decoded-video `PSNR=inf`, reducing temporal overlap blend from about `1.44s` to
-`0.37s`. In the independent full run it took `0.205s`; retain this optimization
-while pursuing the remaining VAE gap.
-
-The clean-build video contains 124 frames at 864x480 and preserves the person,
-selfie stick, wave, V-sign, and final flash. Fixed-frame inspection found no
-new micro-block or seam artifact. Mean boundary differences were b4 `0.01189`,
-b8 `0.01265`, and b16 `0.01321`, compared with Diffusers b4 `0.01368`, b8
-`0.01450`, and b16 `0.01581`. These metrics do not prove quality, but they do
-not indicate a new periodic block-boundary regression.
-
-The clean-build trajectory differs from the previous FC1 run (`33.73dB` decoded
-video PSNR), confirming that this Tensor Core precision path is not bit-exact
-and can vary with GEMM algorithm/build details. It must not be described as a
-lossless optimization. The visible output remains usable, so it is retained as
-an experimental high-performance path rather than enabled unconditionally.
-
-Artifacts:
-
-- Build and run manifest: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-build-qkv-fc1-fast-vae-full/build-manifest.txt`
-- Reproduction command: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-build-qkv-fc1-fast-vae-full/run.sh`
-- Full timing log: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-build-qkv-fc1-fast-vae-full/run.log`
-- Output video: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-build-qkv-fc1-fast-vae-full/final.mp4`
-- Fixed-frame comparison: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-build-qkv-fc1-fast-vae-full/review/three-way-frames.jpg`
-- Boundary metrics: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-build-qkv-fc1-fast-vae-full/review/block-metrics.json`
-- Previous-FC1 PSNR check: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-build-qkv-fc1-fast-vae-full/review/psnr.txt`
-
-## 2026-08-09 forced clean rebuild and benchmark-accounting audit
-
-The current working tree at Edge commit `2f74ed70638518094860f5fe6f6f14885ca6ceef`
-was reconfigured, cleaned with the CMake `clean` target, and rebuilt through all
-CPU, CUDA, Edge extension, library, and CLI targets. The resulting binary was
-linked at `2026-08-09 04:35:32 +0800`. Its cache explicitly records Release,
-SM90, `ED_GGML_CUDA=ON`, CUDA graphs, CUDA modulation/norm/RoPE, cuDNN SDPA,
-and benchmark markers. This rules out both the earlier `ED_GGML_CUDA=OFF`
-configuration mistake and stale incremental objects for the result below.
-
-The full benchmark retained `864x480`, 124 frames at 24 FPS, 20 requested
-steps/19 transformer forwards, seed 314159, CFG 1, the same input and prompt,
-the same Edge model files, and the forced H3 16x16-latent VAE tiling. No
-resolution, frame-count, step-count, scheduler, cache, or quality setting was
-reduced.
-
-| Path | Generation | DiT | Video VAE | Audio VAE | Script wall |
-|---|---:|---:|---:|---:|---:|
-| Edge forced clean rebuild | `62.615s` | `53.905s` | `5.978s` | `0.992s` | `72.413s` |
-| Previous optimized Edge run | `62.194s` | `53.820s` | `5.605s` | `0.977s` | `71.109s` |
-| Diffusers TorchAO INT4 | `59.397s` | `53.621s` | `3.731s` | `0.129s` | `106.530s` cold |
-
-The clean Edge DiT is only `0.284s` (`0.5%`) slower than Diffusers. Therefore,
-the previously observed large DiT gap is not present in the current build and
-was not caused by this node's current source revision. Run-to-run VAE variance
-accounts for most of the `0.421s` generation change versus the immediately
-preceding optimized run. The remaining generation gap is now concentrated in
-video VAE (`2.247s`) and audio VAE (`0.863s`), not DiT.
-
-The benchmark is aligned for workload and timing comparison, but it is not a
-strict same-weight numerical A/B. Edge loads a Q4_K_M GGUF transformer and
-Q4_K_M GGUF conditioner. Diffusers loads the original Diffusers safetensors
-and applies TorchAO 4-bit weight-only quantization at runtime, with selected
-input/output, embedding, normalization, token-refiner, and vision modules left
-unquantized. These representations can quantize the same source checkpoint
-differently, so different denoising trajectories and visible motion are
-expected even with the same seed. This does not invalidate the performance
-comparison, but it prevents attributing cross-framework visual differences to
-the pipeline alone.
-
-The rebuilt video is exactly equal to the previous optimized Edge video after
-decode (`PSNR=inf`). An eight-frame visual review preserves the person,
-selfie stick, wave, V-sign, and final flash and shows no new micro-block or
-tile-seam artifact. Its fixed-frame boundary means are b4 `0.01256`, b8
-`0.01331`, and b16 `0.01391`. These metrics are only regression indicators;
-the fixed-frame and full-video visual checks remain authoritative.
-
-Future acceleration must retain the fixed workload. Material speedups should
-remain available behind explicit switches until a second, different-content
-full task passes visual review. Mathematically exact copy/blend reductions may
-be retained directly. The next optimization target is VAE execution and data
-movement, especially the `5.004s` temporal tile decode plus `0.971s` measured
-output slicing, blending, and collection, rather than reducing generation
-parameters.
-
-Artifacts:
-
-- Build manifest: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-rebuild-verified-2026-08-09/build-manifest.txt`
-- Full timing log: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-rebuild-verified-2026-08-09/run.log`
-- Output video: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-rebuild-verified-2026-08-09/final.mp4`
-- Fixed-frame comparison: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-rebuild-verified-2026-08-09/review/three-way-frames.jpg`
-- Exact-output check: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-rebuild-verified-2026-08-09/review/psnr-vs-prior.log`
-- Boundary metrics: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-rebuild-verified-2026-08-09/review/block-metrics.json`
-
-## 2026-08-09 VAE and audio acceleration update
-
-The latest full run keeps the same benchmark contract: `864x480`, 124 frames at
-24 FPS, 20 requested steps/19 DiT forwards, seed `314159`, CFG 1, the same
-prompt/input, the same Edge model files, and forced MiniMax-H3 VAE tiling. No
-resolution, frame count, diffusion step count, scheduler, or quality knob was
-reduced.
-
-| Path | Generation | DiT | Video VAE | Audio VAE | Script wall |
-|---|---:|---:|---:|---:|---:|
-| Original Edge baseline | `107.921s` | `94.445s` | about `10.831s` | not isolated | not comparable |
-| Edge forced clean rebuild | `62.615s` | `53.905s` | `5.978s` | `0.992s` | `72.413s` |
-| Latest optimized Edge | `60.889s` | `53.842s` | `5.181s` | `0.161s` | `70.030s` |
-| Diffusers TorchAO INT4 | `59.397s` | `53.621s` | `3.731s` | `0.129s` | `106.530s` cold |
-
-From the original Edge baseline to the latest optimized Edge, generation time
-dropped by `47.032s`, or `43.6%`. Relative to the verified clean rebuild, the
-latest VAE/audio work saves another `1.726s` generation time and `2.383s` script
-wall time. Edge is now only `1.492s` slower than Diffusers for measured CUDA
-generation; DiT itself differs by only `0.221s`, so the remaining gap is almost
-entirely video VAE (`1.450s`) plus a small audio VAE delta (`0.032s`).
-
-Latest retained switches for this run:
-
-- `ED_MINIMAX_H3_FUSED_TEMPORAL_ASSEMBLY=1` writes temporal chunks directly into
-  the final video buffer and blends overlap frames in place, removing legacy
-  slice/concat/full-video copy work.
-- `ED_VAE_PLANE_PARALLEL_TILE_COPY=1`, `ED_VAE_PARALLEL_TILE_COPY=1`, and
-  `ED_VAE_PARALLEL_TILE_COPY_THREADS=8` parallelize spatial tile merging; the
-  merge path now precomputes destination ranges and smootherstep weights once
-  per tile instead of once per plane.
-- `ED_MINIMAX_H3_AUDIO_DIRECT_DEPTHWISE=1` maps the BigVGAN depthwise Conv1D and
-  depthwise transpose/downsample stages to the direct depthwise CUDA path instead
-  of expanding them through IM2COL plus MUL_MAT.
-- Existing high-performance DiT/VAE switches remain enabled for this artifact:
-  `ED_MINIMAX_H3_QKV_F32_OUTPUT=1`, `ED_MINIMAX_H3_FC1_F32_OUTPUT=1`,
-  `ED_MINIMAX_H3_FAST_TEMPORAL_BLEND=1`, `ED_CUDNN_SDPA_SHORT_F16_SELF_ATTN=1`,
-  and `ED_MINIMAX_H3_VAE_FUSED_SWIGLU=1`.
-
-Validation performed:
-
-- Fused temporal assembly was checked inside one candidate run against a legacy
-  reconstruction from the exact same decoded chunks; raw tensor `max_abs=0`, so
-  the assembly/blend math and memory layout are exact for identical inputs.
-- Spatial tile merge precompute was checked against the previous implementation;
-  decoded-video PSNR was `inf` and fixed frames matched.
-- Audio direct depthwise was checked after MP4 s16 packaging against the control
-  path; audio PSNR was about `171dB`, consistent with negligible floating-point
-  differences rather than an audible change.
-- Full-video fixed-frame review on the person/selfie-stick prompt showed normal
-  identity, selfie stick, hand gesture, and final flash, with no new visible
-  micro-block or tile seam artifact. The last video-path review reported b4
-  `0.0125115`, b8 `0.0134006`, and b16 `0.0142055` boundary means.
-- CUDA/operator profiling was used to attribute remaining video VAE time. With
-  fused SwiGLU, the 70-tile video VAE profile still spends roughly `1.400s` in
-  layout operations, `0.473s` in attention, `0.371s` in elementwise work, and
-  `0.269s` in norm. The top remaining removable cost appears to be repeated
-  `CONT` layout copies around MiniMax-H3 VAE decoder attention Q/K/V and RoPE
-  packing, not DiT denoising.
-
-Rejected or not-retained experiments:
-
-- Cross-temporal-chunk CUDA graph reuse was tested and was not faster
-  (`5.203s` video VAE with reuse versus `5.042s` without in the A/B run), while
-  preserving `PSNR=inf`; it remains disabled.
-- General Conv1D cuDNN reshaping, FP16 ordinary Conv1D weights, and two-channel
-  batched BigVGAN experiments did not beat the conservative direct-depthwise
-  audio path and were removed from the code path.
-
-Artifacts:
-
-- Latest full run script: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-final-vae-audio-optimized-full/run.sh`
-- Latest full timing log: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-final-vae-audio-optimized-full/run.log`
-- Latest output video: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-final-vae-audio-optimized-full/final.mp4`
-- Previous visual review frame sheet: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-clean-qkv-fc1-fast-vae-fused-assembly-plane-merge-full/review/comparison.jpg`
-- VAE CONT node profile: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/profile-2026-08-09/vae-swiglu-node-top400/run.log`
-
-## 2026-08-09 Follow-up VAE experiments
-
-Follow-up VAE work focused on preserving quality first. The same short
-`864x480`, 124-frame, 3-step probe was used to iterate quickly, with all DiT
-and prompt settings unchanged. No diffusion parameter, resolution, frame count,
-or scheduler changes were used.
-
-Retained as default-off safety candidates:
-
-- `ED_MINIMAX_H3_VAE_FAST_TEMPORAL_GROUP_NORM=1` now uses an equivalent
-  `permute -> GroupNorm -> permute back` path when the effective batch is one.
-  It avoids the earlier incorrect reshape that mixed temporal and channel
-  dimensions. The corrected path is bit-exact in the MP4 A/B probe (`PSNR=inf`),
-  but the speed win is small: video VAE `5.041s -> 5.002s` in the short run.
-- `ED_MINIMAX_H3_VAE_REUSE_ROPE_CACHE=1` caches the host RoPE table for repeated
-  same-shape VAE decode tiles. It is low risk because the tensor contents are
-  unchanged for identical width/height/frame shapes. The short probe showed a
-  small video VAE change (`5.027s -> 4.988s`); encoded MP4 PSNR was about
-  `49.08dB`, so keep it explicit/default-off until a raw-frame or full-run
-  validation is performed.
-
-Rejected experiments:
-
-- The first attempted `FAST_TEMPORAL_GROUP_NORM` reshape was unsafe. It was
-  faster, but it grouped channels incorrectly across temporal frames, producing
-  visible drift and only `36.06dB` average MP4 PSNR. This implementation was
-  replaced by the bit-exact permute version above.
-- Increasing forced VAE tile size improved speed but damaged visual quality.
-  `32x30` latent tiles reduced short-run video VAE to `4.074s` versus the
-  `16x16` baseline `4.825s`, but fixed-frame review showed obvious fine block
-  and seam artifacts. `16x30` and `18x30` reduced the number of vertical tiles
-  but still introduced visible texture/block changes. These should not be used
-  as quality-preserving acceleration knobs.
-- VAE QKV view slicing remained rejected from the previous experiment: it looked
-  fast but produced severe output drift, so it was not reintroduced.
-
-Current conclusion: the remaining quality-safe VAE gap is mostly inside the
-per-tile GPU compute graph, not CPU tile splitting/merging. `ED_PROFILE_RUNNER`
-shows each steady `16x16` VAE tile decode is about `60ms`, with roughly `54ms`
-in GPU compute and near-zero host copy/allocation. The main actionable path is
-therefore exact kernel/layout work inside the MiniMax-H3 VAE decoder graph
-(`CONT`, Q/K/V materialization, RoPE packing, attention/norm), not larger tile
-sizes or other quality-changing tiling shortcuts.
-
-Follow-up artifacts:
-
-- Bit-exact temporal GN A/B: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/vae-fast-temporal-gn-permute-review/psnr.log`
-- Unsafe GN A/B review: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/vae-fast-temporal-gn-ab-review/ab.jpg`
-- Tile-size quality review: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/vae-tile-size-review/tile32_ab.jpg`
-- Tile-XY quality review: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/vae-tile-xy-review/ab.jpg`
-- Runner profile log: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/vae-runner-profile-3step/run.log`
-
-## 2026-08-09 VAE call-chain profiling update
-
-A new VAE named-node CUDA profile was added for MiniMax-H3 decoder blocks. The
-instrumentation is gated by `ED_MINIMAX_H3_VAE_NAME_NODES=1` and names decoder
-attention QKV projection/split, Q/K RMSNorm, partial RoPE packing, attention,
-feed-forward SwiGLU, and block residual outputs. The profile confirms that the
-remaining video VAE gap is not CPU tile merge/split: the steady 70 tile-decode
-CUDA graphs spend most time inside decoder attention layout and padding.
-
-Short `864x480`, 124-frame, 3-step profile highlights:
-
-| Path | Video VAE decode | Profiled video graphs | Main operator buckets |
-|---|---:|---:|---|
-| Current optimized Edge | `6.213s` under profiler | `2.519s` CUDA op time | `LAYOUT 1.377s`, `ELEMENTWISE 0.361s`, `FLASH_ATTN 0.348s`, `NORM 0.266s` |
-| Diffusers TorchAO INT4 profile | component trace only | `3.400s` CUDA kernels in PyTorch trace | `linear/GEMM` dominates, then layout/copy and attention |
-
-The Edge profile is profiler-inflated, but the call-chain ranking is clear. In
-warm video VAE graphs, `LAYOUT` averages about `19.7ms` per tile graph, while
-FlashAttention averages about `4.0ms`. The largest single named removable item
-was the three materialized Q/K/V chunks from the decoder `to_qkv` projection:
-`vae.b*.attn.qkv (view) (cont)` summed to `335.7ms` across the 70 profiled tile
-graphs. The rest of the layout time is distributed across FlashAttention's
-current 256-KV padding path (`PAD/CPY/CONCAT`) and smaller output projection
-layout copies.
-
-A default-off exact candidate was added:
-
-- `ED_MINIMAX_H3_VAE_FUSED_QKV_SPLIT=1` replaces the three `ggml_ext_chunk(...,
-  cont=true)` materializations in MiniMax-H3 VAE decoder attention with one CUDA
-  custom `ed_fused_attention_qkv_split_pack_f32` pack and three views. It changes
-  only data movement, not math.
-
-Validation on the same short A/B:
-
-| Path | Video VAE | Decode video-vae | MP4 PSNR vs control |
-|---|---:|---:|---:|
-| Control | temporal decode `4.759s` | `5.171s` | reference |
-| Fused QKV split | temporal decode `4.743s` | `5.051s` | `inf` |
-
-The fused split removes the named QKV `CONT` cost (`335.7ms -> 0` in the node
-profile), but replaces it with `212.1ms` of custom pack work and exposes no
-large end-to-end win yet (`~0.12s` in this short A/B, within some run variance).
-Keep it default-off until a full-run and second-content visual validation show a
-stable benefit.
-
-The next likely quality-safe target is avoiding or reducing the FlashAttention
-KV padding/materialization for H3 VAE's short sequence (`L=1797`, `d=64`). The
-existing cuDNN unpadded path is normally preferred for `L>=4096`; it also has an
-`ED_CUDNN_SDPA_SHORT_F16_SELF_ATTN=1` gate for shorter self-attention, but H3 VAE
-currently feeds the ggml attention path with F32 Q and F16 K/V packing semantics,
-so it does not hit that F16 short-sequence cuDNN route as-is. H3 VAE therefore
-falls back to ggml FlashAttention with KV padding to 2048. That accounts for much
-of the remaining layout bucket and explains why simply optimizing CPU tile merge
-no longer moves the needle.
-
-Artifacts:
-
-- Edge named profile: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/vae-rope-detail-node-profile-3step/run.log`
-- Fused QKV split A/B: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/vae-fused-qkv-split-ab-3step/psnr.log`
-- Fused QKV split profile: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/vae-fused-qkv-split-node-profile-3step/run.log`
-- Diffusers VAE trace: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/diffusers-video-vae-profile-3step/video_vae_decode.trace.json.gz`
-
-## 2026-08-09 VAE short-sequence cuDNN SDPA experiment
-
-The FlashAttention padding hypothesis was validated with an explicit experiment.
-`ggml_ext_prefer_cudnn_sdpa_unpadded()` was extended so that
-`ED_CUDNN_SDPA_SHORT_F16_SELF_ATTN=1` also suppresses KV-256 padding for
-self-attention with `L>=1024` and `d=64/128`. With this change, MiniMax-H3 VAE
-attention uses cuDNN SDPA directly at `sq=sk=1797`, instead of padding `sk` to
-`2048` and falling back to the ggml FlashAttention padded path.
-
-Short `864x480`, 124-frame, 3-step A/B without CUDA op profiler:
-
-| Path | Temporal VAE decode | Reported video-vae | Generation | Notes |
-|---|---:|---:|---:|---|
-| Control padded FlashAttention | `5.705s` | `6.311s` | `24.875s` | baseline same binary |
-| Short cuDNN unpadded | `4.173s` | `4.472s` | `23.010s` | `ED_CUDNN_SDPA_SHORT_F16_SELF_ATTN=1` |
-| Short cuDNN + fused QKV split | `4.141s` | `4.439s` | `22.940s` | plus `ED_MINIMAX_H3_VAE_FUSED_QKV_SPLIT=1` |
-
-This is a meaningful VAE win: short cuDNN saves about `1.84s` reported video VAE
-on the short run, and the QKV split pack adds only a small additional `~33ms`.
-The comparison is not bit-exact. Control versus short cuDNN MP4 PSNR was
-`42.29dB`; short cuDNN versus short cuDNN + QKV split was `49.01dB`. Fixed-frame
-visual review did not show obvious new blocking or seam artifacts on this sample,
-but because the attention implementation changes numerical order, this should
-remain an explicit quality-validated path until full and second-content checks
-complete.
-
-CUDA-op profile confirmed the targeted bottleneck moved as expected:
-
-| Path | Profiled video graph op time | Layout | PAD | CPY | CONCAT | Attention |
-|---|---:|---:|---:|---:|---:|---:|
-| Padded FlashAttention | `2.519s` | `1.377s` | `0.227s` | `0.182s` | `0.170s` | `0.348s` |
-| Short cuDNN unpadded | `1.890s` | `0.816s` | `0.000s` | `0.057s` | `0.075s` | `0.319s` |
-
-The main remaining named layout hotspot after short cuDNN is still the decoder
-QKV chunk materialization (`vae.b*.attn.qkv (view) (cont)`), about `335.5ms` in
-the profile. The fused QKV split candidate removes that hotspot, but its current
-custom pack kernel gives only modest net speedup. A better follow-up would fuse
-Q/K/V split with the subsequent Q/K norm or attention input packing, rather than
-only replacing three CONT copies with one standalone custom copy.
-
-Artifacts:
-
-- Short cuDNN A/B logs: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/vae-short-unpad-combo-ab-3step`
-- Fixed-frame review: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/vae-short-unpad-combo-ab-3step/review/control-vs-short-vs-short-qkv.jpg`
-- Short cuDNN node profile: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/vae-cudnn-short-unpad-node-profile-3step/run.log`
-
-### Full-run validation for short cuDNN SDPA
-
-A full 20-step run was repeated with the same final optimized Edge environment
-as `edge-final-vae-audio-optimized-full`, plus the short-sequence cuDNN SDPA
-change. The earlier full rerun that omitted fast video/audio postprocess envs is
-not used for comparison because it inflated `video-copy` and `audio-vae`.
-
-Aligned full-run result:
-
-| Path | Generation | DiT | Video VAE | Video copy | Audio VAE | Script wall |
-|---|---:|---:|---:|---:|---:|---:|
-| Previous optimized Edge | `60.889s` | `53.842s` | `5.181s` | `0.102s` | `0.161s` | `70.030s` |
-| Short cuDNN SDPA Edge | `60.082s` | `53.860s` | `4.419s` | `0.114s` | `0.153s` | `69.057s` |
-
-The full run confirms a stable video VAE improvement of `0.762s` (`14.7%`) and
-a generation improvement of `0.807s` (`1.3%`) on the 5-second benchmark. The run
-kept the same resolution, frame count, steps, seed, model files, and forced H3
-16x16 latent VAE tiling.
-
-Quality notes:
-
-- Full MP4 PSNR versus the previous optimized Edge output was `49.18dB`, so the
-  path is not bit-exact but remains visually close.
-- Fixed-frame review showed no new obvious micro-block, tile seam, or motion
-  instability on this sample.
-- Because cuDNN and ggml FlashAttention use different numerical order, keep the
-  path quality-gated until the pending second-content robustness clip is checked.
-
-Full-run artifacts:
-
-- Full log: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-short-cudnn-final-env-full-2026-08-09/run.log`
-- Full video: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-short-cudnn-final-env-full-2026-08-09/final.mp4`
-- Full PSNR: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-short-cudnn-final-env-full-2026-08-09/review/psnr-vs-previous.log`
-- Frame review: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/edge-short-cudnn-final-env-full-2026-08-09/review/previous-vs-short-cudnn.jpg`
-
-### Rejected QKV+RMS split fusion experiment
-
-After short cuDNN SDPA removed the FlashAttention padding overhead, the next
-largest named cost was QKV materialization plus Q/K RMSNorm. A more aggressive
-prototype, `ED_MINIMAX_H3_VAE_FUSED_QKV_RMS_SPLIT=1`, fused QKV split and Q/K
-RMSNorm into one custom CUDA op, skipping the following ggml `RMS_NORM` nodes.
-
-The prototype is rejected for now. It ran, but the short A/B versus the short
-cuDNN control produced only `36.06dB` MP4 PSNR and visible drift risk, indicating
-that the fused norm is not numerically equivalent enough to retain. The likely
-cause is different RMSNorm accumulation/precision/order versus ggml's existing
-CUDA RMSNorm implementation. Do not enable this path without rewriting it to
-match the backend norm semantics and revalidating.
-
-The safer default-off `ED_MINIMAX_H3_VAE_FUSED_QKV_SPLIT=1` remains available as
-a copy-only candidate. It is much closer (`49.01dB` versus short cuDNN in the
-short A/B) but only gives a small speed improvement, so the preferred retained
-VAE acceleration remains short cuDNN SDPA.
-
-Artifact:
-
-- Rejected QKV+RMS A/B: `outputs/minimax-h3/person-selfie-three-frameworks-5s-2026-08-09/vae-qkv-rms-split-ab-3step`
diff --git a/docs/optimization/minimax-h3-fl2va-ref2va-edge-diffusers-benchmark-2026-08-11.md b/docs/optimization/minimax-h3-fl2va-ref2va-edge-diffusers-benchmark-2026-08-11.md
deleted file mode 100644
index 204a400..0000000
--- a/docs/optimization/minimax-h3-fl2va-ref2va-edge-diffusers-benchmark-2026-08-11.md
+++ /dev/null
@@ -1,226 +0,0 @@
-# MiniMax-H3 FL2VA/Ref2VA Edge vs Diffusers CUDA Benchmark（2026-08-11）
-
-## 结论
-
-- 本轮 16 个任务全部完成，`returncode=0`；最终汇总来自 [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/summary.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/summary.json)。
-- Ref2VA 的 `mp4-video` 与 `mixed` 已使用纯正向强约束 prompt、逐帧无损 MP4 和显式原始配对 WAV，在 Edge 与 Diffusers 中重新运行并覆盖原目录。Edge 日志见 [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/edge_mp4_clean_prompt_rerun_2.log`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/edge_mp4_clean_prompt_rerun_2.log)，Diffusers 日志见 [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/diffusers_mp4_clean_prompt_rerun_2.log`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/diffusers_mp4_clean_prompt_rerun_2.log)。
-- Conditioning trace 证明帧目录与无损 MP4 的 `ref_video_0_latent` 哈希一致；旧结果偏离来自否定 prompt 列举无关对象，而非 MP4 解码链路。
-- 已逐项核对 `metrics.json` 与 `cmd.txt`：当前同一任务下 Edge 与 Diffusers 的 prompt 完全相同，语义参考输入完全相同；FL2VA 尾帧参数名不同但路径一致。
-- 全程最大显存峰值为 `79,021 MiB`，来自 `diffusers` 的 `ref2va-mixed`。
-
-## 固定口径
-
-| 项目 | 口径 |
-|---|---|
-| Edge binary | [`build-cuda-refvideo-align-20260810/bin/ed-cli`](../../build-cuda-refvideo-align-20260810/bin/ed-cli) |
-| Diffusers Ref2VA runner | [`scripts/diffusers/run_minimax_h3_ref2va_quantized_official_video.py`](../../scripts/diffusers/run_minimax_h3_ref2va_quantized_official_video.py) |
-| Diffusers FL2VA runner | [`scripts/diffusers/run_minimax_h3_fl2va_optional_quantized.py`](../../scripts/diffusers/run_minimax_h3_fl2va_optional_quantized.py) |
-| FL2VA DiT | `/models/MiniMax-H3-GGUF/minimax_h3_fl2va-Q4_K_M.gguf` |
-| Ref2VA DiT | `/models/MiniMax-H3-GGUF/minimax_h3_ref2va_pruned-Q4_K_M.gguf` |
-| Shared Qwen3-VL | `/models/MiniMax-H3-GGUF/qwen3vl_32b_minimax_h3-Q4_K_M.gguf` |
-| Shared Video VAE | `/models/MiniMax-H3-GGUF/minimax_h3_video_vae_fp16.safetensors` |
-| Shared Audio VAE | `/models/MiniMax-H3-GGUF/minimax_h3_audio_vae_fp32.safetensors` |
-| CUDA 参数 | `864x480`、`124 frames`、`24 fps`、`20 steps`、`seed 424242`、resident/no offload、串行执行 |
-| Ref2VA 无损 MP4 | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4)，逐帧解码相对原 PNG `PSNR=∞` |
-
-## 逐任务口径核对
-
-| 任务 | Prompt 是否一致 | 参考输入是否一致 | Prompt 口径 | Edge 参考 | Diffusers 参考 |
-|---|---:|---:|---|---|---|
-| 文生视频 | 是 | 是 | 强描述 prompt，无参考输入 | 无参考输入 | 无参考输入 |
-| 首帧生视频 | 是 | 是 | 强参考 prompt，显式要求遵循参考并排除无关主体 | 首帧/图片: [`outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png) | 首帧/图片: [`outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png) |
-| 尾帧生视频 | 是 | 是 | 强参考 prompt，显式要求遵循参考并排除无关主体 | 尾帧: [`outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png) | 尾帧: [`outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png) |
-| 首尾帧生视频 | 是 | 是 | 强参考 prompt，显式要求遵循参考并排除无关主体 | 首帧/图片: [`outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png)<br>尾帧: [`outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png) | 首帧/图片: [`outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png)<br>尾帧: [`outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png) |
-| 图片参考 | 是 | 是 | 强参考 prompt，显式要求遵循参考并排除无关主体 | 参考图片: [`assets/minimax-h3-ref2va/images/landscape-reference.png`](../../assets/minimax-h3-ref2va/images/landscape-reference.png) | 参考图片: [`assets/minimax-h3-ref2va/images/landscape-reference.png`](../../assets/minimax-h3-ref2va/images/landscape-reference.png) |
-| 视频 MP4 参考 | 是 | 是 | 更强参考 prompt，要求严格复制参考视频场景并禁止发散 | 参考视频: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4)<br>视频配对音频: [`assets/minimax-h3-ref2va/video-audio.wav`](../../assets/minimax-h3-ref2va/video-audio.wav) | 参考视频: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4)<br>视频配对音频: [`assets/minimax-h3-ref2va/video-audio.wav`](../../assets/minimax-h3-ref2va/video-audio.wav) |
-| 帧序列+音频参考 | 是 | 是 | 更强参考 prompt，要求严格复制参考视频场景并禁止发散 | 参考视频: [`assets/minimax-h3-ref2va/video-frames`](../../assets/minimax-h3-ref2va/video-frames)<br>视频配对音频: [`assets/minimax-h3-ref2va/video-audio.wav`](../../assets/minimax-h3-ref2va/video-audio.wav) | 参考视频: [`assets/minimax-h3-ref2va/video-frames`](../../assets/minimax-h3-ref2va/video-frames)<br>视频配对音频: [`assets/minimax-h3-ref2va/video-audio.wav`](../../assets/minimax-h3-ref2va/video-audio.wav) |
-| 混合参考 | 是 | 是 | 更强 mixed prompt，要求 0-2s 视频场景、2-3s 自然过渡、3-5s 图片场景 | 参考图片: [`assets/minimax-h3-ref2va/images/landscape-reference.png`](../../assets/minimax-h3-ref2va/images/landscape-reference.png)<br>参考视频: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4)<br>视频配对音频: [`assets/minimax-h3-ref2va/video-audio.wav`](../../assets/minimax-h3-ref2va/video-audio.wav)<br>独立音频: [`assets/minimax-h3-ref2va/standalone-audio.wav`](../../assets/minimax-h3-ref2va/standalone-audio.wav) | 参考图片: [`assets/minimax-h3-ref2va/images/landscape-reference.png`](../../assets/minimax-h3-ref2va/images/landscape-reference.png)<br>参考视频: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4)<br>视频配对音频: [`assets/minimax-h3-ref2va/video-audio.wav`](../../assets/minimax-h3-ref2va/video-audio.wav)<br>独立音频: [`assets/minimax-h3-ref2va/standalone-audio.wav`](../../assets/minimax-h3-ref2va/standalone-audio.wav) |
-
-## 输入汇总
-
-| 任务 | 输入 |
-|---|---|
-| 文生视频 | `text only` |
-| 首帧生视频 | [`outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png) |
-| 尾帧生视频 | [`outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png) |
-| 首尾帧生视频 | [`outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png) + [`outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png) |
-| 图片参考 | [`assets/minimax-h3-ref2va/images/landscape-reference.png`](../../assets/minimax-h3-ref2va/images/landscape-reference.png) |
-| 视频 MP4 参考 | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4) + [`assets/minimax-h3-ref2va/video-audio.wav`](../../assets/minimax-h3-ref2va/video-audio.wav) |
-| 帧序列+音频参考 | [`assets/minimax-h3-ref2va/video-frames`](../../assets/minimax-h3-ref2va/video-frames) + [`assets/minimax-h3-ref2va/video-audio.wav`](../../assets/minimax-h3-ref2va/video-audio.wav) |
-| 混合参考 | [`assets/minimax-h3-ref2va/images/landscape-reference.png`](../../assets/minimax-h3-ref2va/images/landscape-reference.png) + [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/fixed_inputs/ref2va_video_frames_with_audio_lossless.mp4) + [`assets/minimax-h3-ref2va/video-audio.wav`](../../assets/minimax-h3-ref2va/video-audio.wav) + [`assets/minimax-h3-ref2va/standalone-audio.wav`](../../assets/minimax-h3-ref2va/standalone-audio.wav) |
-
-## FL2VA Checkpoint 对比
-
-| 任务 | Edge 输出 | Diffusers 输出 | Edge wall | Diffusers wall | Edge 加速 | Edge 显存 | Diffusers 显存 | Edge 阶段耗时 | Diffusers 阶段耗时 |
-|---|---|---|---:|---:|---:|---:|---:|---|---|
-| 文生视频 | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/final.mp4) | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/final.mp4) | 108.1s | 104.4s | 0.97x | 47,239 MiB | 56,803 MiB | load 7.5s / cond 0.1s / DiT 92.3s / decode 5.3s / save 1.3s | init+quant 39.2s / cond 0.3s / DiT 49.3s / decode 4.0s / save 0.7s |
-| 首帧生视频 | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/final.mp4) | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/final.mp4) | 73.1s | 110.2s | 1.51x | 47,609 MiB | 56,599 MiB | load 6.5s / cond 0.9s / DiT 57.6s / decode 4.6s / save 1.2s | init+quant 40.9s / cond 0.7s / DiT 53.1s / decode 3.9s / save 0.6s |
-| 尾帧生视频 | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/final.mp4) | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/final.mp4) | 73.0s | 108.3s | 1.48x | 47,607 MiB | 56,599 MiB | load 6.7s / cond 0.9s / DiT 57.5s / decode 4.5s / save 1.4s | init+quant 38.9s / cond 0.7s / DiT 53.1s / decode 3.9s / save 0.7s |
-| 首尾帧生视频 | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/final.mp4) | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/final.mp4) | 76.7s | 114.1s | 1.49x | 47,785 MiB | 57,331 MiB | load 6.3s / cond 1.6s / DiT 60.9s / decode 4.5s / save 1.3s | init+quant 40.3s / cond 0.8s / DiT 56.7s / decode 3.9s / save 0.7s |
-
-## Ref2VA Checkpoint 对比
-
-| 任务 | Edge 输出 | Diffusers 输出 | Edge wall | Diffusers wall | Edge 加速 | Edge 显存 | Diffusers 显存 | Edge 阶段耗时 | Diffusers 阶段耗时 |
-|---|---|---|---:|---:|---:|---:|---:|---|---|
-| 图片参考 | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/final.mp4) | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/final.mp4) | 71.8s | 189.8s | 2.64x | 40,655 MiB | 66,399 MiB | load 6.0s / cond 0.9s / DiT 57.0s / decode 4.7s / save 1.2s | init+quant 39.9s / cond 1.6s / DiT 131.4s / decode 3.9s / save 0.6s |
-| 视频 MP4 参考 | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/final.mp4) | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/final.mp4) | 136.2s | 242.5s | 1.78x | 46,037 MiB | 64,327 MiB | load 6.2s / cond 23.6s / DiT 93.5s / decode 4.7s / save 2.0s | init+quant 40.1s / cond 7.1s / DiT 174.2s / decode 3.9s / save 1.3s |
-| 帧序列+音频参考 | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/final.mp4) | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/final.mp4) | 135.5s | 242.9s | 1.79x | 46,037 MiB | 63,731 MiB | load 6.0s / cond 24.0s / DiT 93.5s / decode 4.6s / save 2.0s | init+quant 41.7s / cond 7.1s / DiT 175.1s / decode 3.9s / save 1.2s |
-| 混合参考 | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/final.mp4) | [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/final.mp4) | 144.5s | 377.6s | 2.61x | 46,037 MiB | 79,021 MiB | load 6.3s / cond 24.5s / DiT 101.1s / decode 4.6s / save 1.8s | init+quant 39.8s / cond 8.7s / DiT 306.9s / decode 3.9s / save 0.9s |
-
-## 详细阶段拆分
-
-### FL2VA
-
-| 任务 | 框架 | 加载/量化 | 文本 | 条件总计 | 参考视频/图像 VAE | 参考音频 VAE | DiT | 视频解码 | 音频解码 | 保存/mux | 端到端 | 外部 wall | 显存峰值 |
-|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|
-| 文生视频 | Edge | 7.5s | 0.1s | 0.1s | 0.0s | 0.0s | 92.3s | 4.9s | 0.3s | 1.3s | 106.9s | 108.1s | 47,239 MiB |
-| 文生视频 | Diffusers | 39.2s | 0.3s | - | 0.0s | 0.0s | 49.3s | 3.9s | 0.2s | 0.7s | 95.1s | 104.4s | 56,803 MiB |
-| 首帧生视频 | Edge | 6.5s | 0.2s | 0.9s | 0.4s | 0.0s | 57.6s | 4.4s | 0.2s | 1.2s | 71.3s | 73.1s | 47,609 MiB |
-| 首帧生视频 | Diffusers | 40.9s | 0.5s | - | 0.2s | 0.0s | 53.1s | 3.8s | 0.1s | 0.6s | 100.7s | 110.2s | 56,599 MiB |
-| 尾帧生视频 | Edge | 6.7s | 0.2s | 0.9s | 0.4s | 0.0s | 57.5s | 4.3s | 0.2s | 1.4s | 71.5s | 73.0s | 47,607 MiB |
-| 尾帧生视频 | Diffusers | 38.9s | 0.6s | - | 0.2s | 0.0s | 53.1s | 3.7s | 0.1s | 0.7s | 99.0s | 108.3s | 56,599 MiB |
-| 首尾帧生视频 | Edge | 6.3s | 0.4s | 1.6s | 0.8s | 0.0s | 60.9s | 4.3s | 0.2s | 1.3s | 75.2s | 76.7s | 47,785 MiB |
-| 首尾帧生视频 | Diffusers | 40.3s | 0.6s | - | 0.3s | 0.0s | 56.7s | 3.8s | 0.1s | 0.7s | 104.2s | 114.1s | 57,331 MiB |
-
-### Ref2VA
-
-| 任务 | 框架 | 加载/量化 | 文本 | 条件总计 | 参考视频/图像 VAE | 参考音频 VAE | DiT | 视频解码 | 音频解码 | 保存/mux | 端到端 | 外部 wall | 显存峰值 |
-|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|
-| 图片参考 | Edge | 6.0s | 0.3s | 0.9s | 0.4s | 0.0s | 57.0s | 4.5s | 0.2s | 1.2s | 70.3s | 71.8s | 40,655 MiB |
-| 图片参考 | Diffusers | 39.9s | 0.0s | - | 1.6s | 0.0s | 131.4s | 3.7s | 0.1s | 0.6s | 180.7s | 189.8s | 66,399 MiB |
-| 视频 MP4 参考 | Edge | 6.2s | 0.6s | 23.6s | 22.0s | 0.0s | 93.5s | 4.4s | 0.3s | 2.0s | 133.5s | 136.2s | 46,037 MiB |
-| 视频 MP4 参考 | Diffusers | 40.1s | 0.0s | - | 7.0s | 0.1s | 174.2s | 3.8s | 0.1s | 1.3s | 229.7s | 242.5s | 64,327 MiB |
-| 帧序列+音频参考 | Edge | 6.0s | 0.6s | 24.0s | 22.4s | 0.0s | 93.5s | 4.4s | 0.2s | 2.0s | 133.5s | 135.5s | 46,037 MiB |
-| 帧序列+音频参考 | Diffusers | 41.7s | 0.0s | - | 7.1s | 0.1s | 175.1s | 3.8s | 0.1s | 1.2s | 232.6s | 242.9s | 63,731 MiB |
-| 混合参考 | Edge | 6.3s | 0.9s | 24.5s | 22.5s | 0.0s | 101.1s | 4.3s | 0.2s | 1.8s | 141.9s | 144.5s | 46,037 MiB |
-| 混合参考 | Diffusers | 39.8s | 0.0s | - | 8.6s | 0.1s | 306.9s | 3.7s | 0.1s | 0.9s | 365.2s | 377.6s | 79,021 MiB |
-
-## Prompt
-
-| 任务 | Prompt |
-|---|---|
-| 文生视频 | A cinematic realistic five-second video of a sunset mountain landscape with layered distant ridges, warm golden light, subtle slow camera motion, coherent quiet natural ambient audio, high detail, no unrelated subjects. |
-| 首帧生视频 | Starting from <Picture 1>, create a cinematic realistic five-second video of the same sunset mountain landscape. Preserve the warm golden lighting, sun flare, distant ridges, wide composition, subtle slow camera motion, and matching quiet natural ambient audio for the whole video. |
-| 尾帧生视频 | Create a cinematic realistic five-second video that naturally ends at <Picture 1>. The final frames must match the sunset mountain landscape, warm golden lighting, sun flare, distant ridges, and wide composition, with coherent motion and matching quiet natural ambient audio. |
-| 首尾帧生视频 | Create a smooth cinematic transition from <Picture 1> to <Picture 2>. Preserve realistic sunset lighting, coherent mountain landscape geometry, distant ridges, natural slow camera motion, and matching quiet natural ambient audio throughout the five-second video. |
-| 图片参考 | Use <Picture 1> as the exact visual subject and composition reference. Generate a realistic five-second slow cinematic video of the same sunset mountain landscape: layered distant mountain ridges, hazy valleys, dark forest silhouettes in the foreground, warm orange sky, and a bright sun starburst near the right side of the frame. Keep the camera motion very subtle, like a gentle slow push-in over the same mountain view. Preserve the color palette, lighting direction, sun flare, atmospheric haze, and wide landscape composition from <Picture 1> for the entire video. The scene should remain a natural mountain sunset panorama from beginning to end, with matching quiet natural ambient audio. |
-| 视频 MP4 参考 | Use <Video 1> as the exact visual motion and scene reference, and use <Audio 1> as the paired soundtrack reference. Generate a realistic five-second video following the same park walkway, green grass, trees, benches, small white dog, camera motion, composition, lighting, and matching audio mood. Preserve only the subjects and environment visible in the reference for the entire video. |
-| 帧序列+音频参考 | Use <Video 1> as a strict visual reference and <Audio 1> as the paired soundtrack reference. The generated five-second video must preserve the park walkway scene from <Video 1> for the entire clip: green grass, trees, benches, the small white dog, similar camera motion, composition, lighting, and audio mood. Do not change the location or subject. Do not introduce vehicles, churches, concerts, city streets, indoor scenes, crowds, or unrelated objects. Follow the reference video frames and paired audio as closely as possible. |
-| 混合参考 | Create a five-second two-part transition that strictly uses all references. From 0 to 2 seconds, reproduce the park walkway scene from <Video 1>, including its trees, grass, path, benches, small white dog, framing, and camera motion. From 2 to 3 seconds, make a smooth natural cinematic transition. From 3 to 5 seconds, reproduce the sunset mountain landscape from <Picture 1>, including its layered ridges, warm orange sky, dark foreground silhouettes, atmospheric haze, and bright sun flare. Use <Audio 1> as standalone audio guidance throughout. Preserve only subjects and environments present in the references. |
-
-## 文件索引
-
-- 文生视频 Edge command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/cmd.txt)
-- 文生视频 Edge prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/prompt.txt)
-- 文生视频 Edge inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/inputs.txt)
-- 文生视频 Edge metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/metrics.json)
-- 文生视频 Edge GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/gpu_mem.csv)
-- 文生视频 Edge contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/contact.jpg)
-- 文生视频 Edge output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-t2va/final.mp4)
-- 文生视频 Diffusers command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/cmd.txt)
-- 文生视频 Diffusers prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/prompt.txt)
-- 文生视频 Diffusers inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/inputs.txt)
-- 文生视频 Diffusers metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/metrics.json)
-- 文生视频 Diffusers GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/gpu_mem.csv)
-- 文生视频 Diffusers contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/contact.jpg)
-- 文生视频 Diffusers output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-t2va/final.mp4)
-- 首帧生视频 Edge command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/cmd.txt)
-- 首帧生视频 Edge prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/prompt.txt)
-- 首帧生视频 Edge inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/inputs.txt)
-- 首帧生视频 Edge metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/metrics.json)
-- 首帧生视频 Edge GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/gpu_mem.csv)
-- 首帧生视频 Edge contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/contact.jpg)
-- 首帧生视频 Edge output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-i2va/final.mp4)
-- 首帧生视频 Diffusers command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/cmd.txt)
-- 首帧生视频 Diffusers prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/prompt.txt)
-- 首帧生视频 Diffusers inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/inputs.txt)
-- 首帧生视频 Diffusers metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/metrics.json)
-- 首帧生视频 Diffusers GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/gpu_mem.csv)
-- 首帧生视频 Diffusers contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/contact.jpg)
-- 首帧生视频 Diffusers output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-i2va/final.mp4)
-- 尾帧生视频 Edge command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/cmd.txt)
-- 尾帧生视频 Edge prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/prompt.txt)
-- 尾帧生视频 Edge inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/inputs.txt)
-- 尾帧生视频 Edge metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/metrics.json)
-- 尾帧生视频 Edge GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/gpu_mem.csv)
-- 尾帧生视频 Edge contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/contact.jpg)
-- 尾帧生视频 Edge output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-l2va/final.mp4)
-- 尾帧生视频 Diffusers command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/cmd.txt)
-- 尾帧生视频 Diffusers prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/prompt.txt)
-- 尾帧生视频 Diffusers inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/inputs.txt)
-- 尾帧生视频 Diffusers metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/metrics.json)
-- 尾帧生视频 Diffusers GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/gpu_mem.csv)
-- 尾帧生视频 Diffusers contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/contact.jpg)
-- 尾帧生视频 Diffusers output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-l2va/final.mp4)
-- 首尾帧生视频 Edge command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/cmd.txt)
-- 首尾帧生视频 Edge prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/prompt.txt)
-- 首尾帧生视频 Edge inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/inputs.txt)
-- 首尾帧生视频 Edge metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/metrics.json)
-- 首尾帧生视频 Edge GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/gpu_mem.csv)
-- 首尾帧生视频 Edge contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/contact.jpg)
-- 首尾帧生视频 Edge output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-fl2va-fl2va/final.mp4)
-- 首尾帧生视频 Diffusers command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/cmd.txt)
-- 首尾帧生视频 Diffusers prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/prompt.txt)
-- 首尾帧生视频 Diffusers inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/inputs.txt)
-- 首尾帧生视频 Diffusers metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/metrics.json)
-- 首尾帧生视频 Diffusers GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/gpu_mem.csv)
-- 首尾帧生视频 Diffusers contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/contact.jpg)
-- 首尾帧生视频 Diffusers output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-fl2va-fl2va/final.mp4)
-- 图片参考 Edge command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/cmd.txt)
-- 图片参考 Edge prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/prompt.txt)
-- 图片参考 Edge inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/inputs.txt)
-- 图片参考 Edge metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/metrics.json)
-- 图片参考 Edge GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/gpu_mem.csv)
-- 图片参考 Edge contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/contact.jpg)
-- 图片参考 Edge output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-image/final.mp4)
-- 图片参考 Diffusers command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/cmd.txt)
-- 图片参考 Diffusers prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/prompt.txt)
-- 图片参考 Diffusers inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/inputs.txt)
-- 图片参考 Diffusers metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/metrics.json)
-- 图片参考 Diffusers GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/gpu_mem.csv)
-- 图片参考 Diffusers contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/contact.jpg)
-- 图片参考 Diffusers output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-image/final.mp4)
-- 视频 MP4 参考 Edge command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/cmd.txt)
-- 视频 MP4 参考 Edge prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/prompt.txt)
-- 视频 MP4 参考 Edge inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/inputs.txt)
-- 视频 MP4 参考 Edge metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/metrics.json)
-- 视频 MP4 参考 Edge GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/gpu_mem.csv)
-- 视频 MP4 参考 Edge contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/contact.jpg)
-- 视频 MP4 参考 Edge output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mp4-video/final.mp4)
-- 视频 MP4 参考 Diffusers command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/cmd.txt)
-- 视频 MP4 参考 Diffusers prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/prompt.txt)
-- 视频 MP4 参考 Diffusers inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/inputs.txt)
-- 视频 MP4 参考 Diffusers metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/metrics.json)
-- 视频 MP4 参考 Diffusers GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/gpu_mem.csv)
-- 视频 MP4 参考 Diffusers contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/contact.jpg)
-- 视频 MP4 参考 Diffusers output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mp4-video/final.mp4)
-- 帧序列+音频参考 Edge command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/cmd.txt)
-- 帧序列+音频参考 Edge prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/prompt.txt)
-- 帧序列+音频参考 Edge inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/inputs.txt)
-- 帧序列+音频参考 Edge metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/metrics.json)
-- 帧序列+音频参考 Edge GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/gpu_mem.csv)
-- 帧序列+音频参考 Edge contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/contact.jpg)
-- 帧序列+音频参考 Edge output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-frame-audio/final.mp4)
-- 帧序列+音频参考 Diffusers command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/cmd.txt)
-- 帧序列+音频参考 Diffusers prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/prompt.txt)
-- 帧序列+音频参考 Diffusers inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/inputs.txt)
-- 帧序列+音频参考 Diffusers metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/metrics.json)
-- 帧序列+音频参考 Diffusers GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/gpu_mem.csv)
-- 帧序列+音频参考 Diffusers contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/contact.jpg)
-- 帧序列+音频参考 Diffusers output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-frame-audio/final.mp4)
-- 混合参考 Edge command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/cmd.txt)
-- 混合参考 Edge prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/prompt.txt)
-- 混合参考 Edge inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/inputs.txt)
-- 混合参考 Edge metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/metrics.json)
-- 混合参考 Edge GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/gpu_mem.csv)
-- 混合参考 Edge contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/contact.jpg)
-- 混合参考 Edge output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/edge-ref2va-mixed/final.mp4)
-- 混合参考 Diffusers command: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/cmd.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/cmd.txt)
-- 混合参考 Diffusers prompt: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/prompt.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/prompt.txt)
-- 混合参考 Diffusers inputs: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/inputs.txt`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/inputs.txt)
-- 混合参考 Diffusers metrics: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/metrics.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/metrics.json)
-- 混合参考 Diffusers GPU memory trace: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/gpu_mem.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/gpu_mem.csv)
-- 混合参考 Diffusers contact sheet: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/contact.jpg`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/contact.jpg)
-- 混合参考 Diffusers output: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/final.mp4`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/runs/diffusers-ref2va-mixed/final.mp4)
-- 汇总 JSON: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/summary.json`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/summary.json)
-- 汇总 CSV: [`outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/summary.csv`](../../outputs/minimax-h3/checkpoint-benchmark-edge-diffusers-20260811-162144/summary.csv)
diff --git a/docs/optimization/minimax-h3-fl2va-ref2va-edge-sdcpp-h200-8bit-2026-08-12.md b/docs/optimization/minimax-h3-fl2va-ref2va-edge-sdcpp-h200-8bit-2026-08-12.md
deleted file mode 100644
index 1ae857d..0000000
--- a/docs/optimization/minimax-h3-fl2va-ref2va-edge-sdcpp-h200-8bit-2026-08-12.md
+++ /dev/null
@@ -1,155 +0,0 @@
-# MiniMax-H3 FL2VA/Ref2VA Edge vs sd.cpp H200 8-bit Benchmark（2026-08-12）
-
-## 结论
-
-- 本文主表现已覆盖为 2026-08-13 最终口径：Edge 使用已完成的内部 profile 八项；sd.cpp 使用官方 Comfy INT8 ConvRot DiT，重新以 `--eager-load` 全组件常驻方式串行运行八项。所有任务均为 `rc=0`。
-- Edge 在 8 个任务上的外部 wall 均更短，相对 sd.cpp eager 加速为 `1.56x–2.23x`；最大加速来自 Ref2VA 混合参考。
-- 全程最大单卡显存峰值为 `72,490 MiB`，来自 sd.cpp eager 的 FL2VA 尾帧任务。Edge 全部任务最大值为 `70,673 MiB`。
-- sd.cpp eager 与旧 lazy 结果的 wall 基本相同，差异约在 `-5s–+2s`；常驻并没有带来可辨认的速度收益。它主要改变显存：例如 Ref2VA 视频帧参考从旧 lazy 的 `56,245 MiB` 上升至 eager 的 `62,595 MiB`。
-- 两框架不是相同量化算法：Edge DiT 使用 GGML `Q8_0`，sd.cpp DiT 使用 Comfy `INT8 ConvRot`；Qwen、Video VAE、Audio VAE 相同。因此本表是“各框架可运行的 8-bit 路径”对比，不能把质量差异只归因于框架。
-- Edge FL2VA 本轮仍为官方 Diffusers BF16 shards 加载时动态转 `Q8_0`，不是随后下载的 Comfy FL2VA BF16；对应结果不能标记为“Comfy BF16 转持久化 Q8_0”。
-- 噪声根因不是 Q8 精度、Qwen 或 VAE：官方 Diffusers DiT 的 52 个 SwiGLU 输入投影半区顺序与原生/Comfy 权重相反，且 shards 省略了可推导的 `rope.inv_freq`。Edge 现已在量化前归一化 SwiGLU 布局，并在缺失时合成 16 个 FP32 RoPE 频率。
-- Ref2VA 视频任务实际输入为同一帧目录，不是 MP4。最终视频帧与帧序列+配对音频任务使用字节完全一致的干净视觉 Prompt，唯一输入差异是后者增加 `--ref-video-audio`。
-- 使用不提 Audio、不列举负面实体的同一 Prompt 完成 Edge 单变量 A/B 后，无音频和配对音频两组都严格保持公园帧内容，对输入前 56 帧的 SSIM 分别为 `0.314700` 和 `0.314327`，未观察到参考音频降低画面参考能力。
-- 2026-08-13 使用 `ED_MINIMAX_H3_PROFILE=1` 按相同 H200 参数串行重跑 Edge 八项，补齐 Qwen context、关键帧/参考 VAE、noise、DiT、视频/音频解码等内部阶段时间；八项均为 `rc=0`，wall 与原结果基本一致。
-
-## 固定口径
-
-| 项目 | 口径 |
-|---|---|
-| GPU | NVIDIA H200，串行执行，`CUDA_VISIBLE_DEVICES=0` |
-| Edge binary | [`build-cuda-refvideo-align-20260810/bin/ed-cli`](../../build-cuda-refvideo-align-20260810/bin/ed-cli) |
-| sd.cpp binary | `/mnt/cfs/9n-das-admin/llm_models/MiniMax-H3-8bit-Benchmark/builds/stable-diffusion.cpp-cuda12.8-h200-bcc7e295/bin/sd-cli` |
-| 分辨率与长度 | `864x480`、`124 frames`、`24 fps` |
-| 采样参数 | `20 steps`、Euler、CFG `1`、seed `424242`、CPU RNG |
-| 执行方式 | Edge 默认全组件常驻；sd.cpp `--eager-load` 全参数常驻；均无 CPU offload、启用 `--diffusion-fa`、GPU0 串行执行 |
-| Profile | Edge `ED_MINIMAX_H3_PROFILE=1`；sd.cpp `-v` 原生阶段日志 |
-| Edge FL2VA DiT | 官方 Diffusers BF16 shards，`--tensor-type-rules model.diffusion_model.=q8_0` 动态转 GGML Q8_0 |
-| Edge Ref2VA DiT | 本地持久化 `minimax_h3_ref2va_pruned-Q8_0.gguf`；Comfy BF16 转 GGML Q8_0 |
-| sd.cpp FL2VA DiT | Comfy `minimax_h3_fl2va_int8_convrot.safetensors`，直接加载 INT8 ConvRot |
-| sd.cpp Ref2VA DiT | Comfy `minimax_h3_ref2va_pruned_int8_convrot.safetensors`，直接加载 INT8 ConvRot |
-| Shared Qwen3-VL | Comfy BF16 转本地 `qwen3vl_32b_minimax_h3-Q8_0.gguf`，两框架使用同一文件 |
-| Shared Video VAE | Comfy `minimax_h3_video_vae_fp16.safetensors`，FP16，不量化 |
-| Shared Audio VAE | Comfy `minimax_h3_audio_vae_fp32.safetensors`，FP32，不量化 |
-| Edge manifest/status | [`status.log`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/status.log) |
-| sd.cpp eager manifest | [`manifest.txt`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/manifest.txt) |
-| 正式全量 benchmark | `/mnt/cfs/9n-das-admin/llm_models/MiniMax-H3-8bit-Benchmark/run_h200_8bit_quality_benchmark.sh` |
-| 本轮 sd.cpp-only benchmark | `/mnt/cfs/9n-das-admin/llm_models/MiniMax-H3-8bit-Benchmark/run_h200_sdcpp_eager_int8_profile_20260813.sh` |
-
-## 输入与 Prompt 核对
-
-最终主表中，每个任务的 Edge 与 sd.cpp `prompt.txt` 均通过 `cmp` 字节一致，参考输入路径、顺序、尺寸、seed 和采样参数一致；差异仅为框架与 DiT 8-bit 表示。视频帧与帧序列+配对音频还共同使用同一份视觉 Prompt，以隔离配对音频变量。
-
-| 任务 | 输入 | Prompt | 口径核对 |
-|---|---|---|---|
-| 文生视频 | 无参考输入 | [`prompt.txt`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-t2va/prompt.txt) | Edge/sd.cpp 字节一致 |
-| 首帧生视频 | [`first.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png) | [`prompt.txt`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-i2va/prompt.txt) | Edge/sd.cpp 字节一致；`<Picture 1>` 对应首帧 |
-| 尾帧生视频 | [`last.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png) | [`prompt.txt`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-l2va/prompt.txt) | Edge/sd.cpp 字节一致；`<Picture 1>` 对应尾帧 |
-| 首尾帧生视频 | [`first.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/first.png) + [`last.png`](../../outputs/minimax-h3/fl2va-checkpoint-four-tasks-2026-08-10/inputs/last.png) | [`prompt.txt`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-fl2va/prompt.txt) | Edge/sd.cpp 字节一致；标签顺序为首帧 `<Picture 1>`、尾帧 `<Picture 2>` |
-| 图片参考 | [`landscape-reference.png`](../../assets/minimax-h3-ref2va/images/landscape-reference.png) | [`prompt.txt`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-image/prompt.txt) | Edge/sd.cpp 字节一致 |
-| 视频帧参考 | [`video-frames`](../../assets/minimax-h3-ref2va/video-frames) | [`prompt.txt`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-video-frames/prompt.txt) | Edge/sd.cpp 字节一致；只引用存在的 `<Video 1>` |
-| 帧序列+配对音频 | [`video-frames`](../../assets/minimax-h3-ref2va/video-frames) + [`video-audio.wav`](../../assets/minimax-h3-ref2va/video-audio.wav) | [`prompt.txt`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-frame-audio/prompt.txt) | 与视频帧任务 Prompt 也字节一致；唯一新增输入为配对音频 |
-| 混合参考 | [`landscape-reference.png`](../../assets/minimax-h3-ref2va/images/landscape-reference.png) + [`video-frames`](../../assets/minimax-h3-ref2va/video-frames) + [`video-audio.wav`](../../assets/minimax-h3-ref2va/video-audio.wav) + [`standalone-audio.wav`](../../assets/minimax-h3-ref2va/standalone-audio.wav) | [`prompt.txt`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-mixed/prompt.txt) | Edge/sd.cpp 字节一致；沿用已完成 Edge run 的 Prompt |
-
-混合任务的已完成 Edge Prompt 将 `<Audio 1>` 描述为 standalone guidance；按参考注册顺序，`<Audio 1>` 更可能是视频配对音频、独立音频是 `<Audio 2>`。为遵守“不重跑 Edge、两框架 Prompt 完全相同”的约束，本轮 sd.cpp 原样复用该 Prompt。因此混合任务的 wall/显存对比公平，画面要求也一致，但不能用本轮结果判断独立音频标签是否被正确遵循。正式全量 benchmark 脚本已将后续运行改为 `<Audio 1>` 配对音频、`<Audio 2>` 独立音频。
-
-## FL2VA Checkpoint 对比
-
-| 任务 | Edge 输出 | sd.cpp 输出 | Edge wall | sd.cpp wall | Edge 加速 | Edge 显存 | sd.cpp 显存 | Edge 阶段耗时 | sd.cpp 阶段耗时 |
-|---|---|---|---:|---:|---:|---:|---:|---|---|
-| 文生视频 | [`final.mp4`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-t2va/final.mp4) | [`final.mp4`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-fl2va-t2va/final.mp4) | 140s | 219s | 1.56x | 70,333 MiB | 71,107 MiB | load 44.716s / Qwen 0.141s / noise 0.482s / DiT 87.719s / video 4.895s / audio 0.259s / save 1.143s | load 8.31s / cond 0.14s / DiT 175.62s / video 19.58s / audio 9.10s |
-| 首帧生视频 | [`final.mp4`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-i2va/final.mp4) | [`final.mp4`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-fl2va-i2va/final.mp4) | 146s | 236s | 1.62x | 70,493 MiB | 71,435 MiB | load 44.608s / Qwen 0.505s / keyframe VAE 0.435s / noise 0.482s / DiT 93.043s / video 4.898s / audio 0.215s / save 1.121s | load 8.48s / keyframe VAE 1.41s / cond 0.44s / DiT 190.93s / video 20.11s / audio 9.09s |
-| 尾帧生视频 | [`final.mp4`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-l2va/final.mp4) | [`final.mp4`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-fl2va-l2va/final.mp4) | 147s | 235s | 1.60x | 70,491 MiB | 72,490 MiB | load 45.108s / Qwen 0.562s / keyframe VAE 0.435s / noise 0.493s / DiT 92.976s / video 4.816s / audio 0.206s / save 1.411s | load 8.36s / keyframe VAE 1.40s / cond 0.43s / DiT 190.47s / video 19.68s / audio 9.08s |
-| 首尾帧生视频 | [`final.mp4`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-fl2va/final.mp4) | [`final.mp4`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-fl2va-fl2va/final.mp4) | 153s | 257s | 1.68x | 70,673 MiB | 71,463 MiB | load 45.569s / Qwen 0.836s / keyframe VAE 0.794s / noise 0.480s / DiT 98.761s / video 4.844s / audio 0.177s / save 1.199s | load 8.39s / keyframe VAE 2.53s / cond 0.77s / DiT 209.14s / video 20.89s / audio 9.08s |
-
-## Ref2VA Checkpoint 对比
-
-| 任务 | Edge 输出 | sd.cpp 输出 | Edge wall | sd.cpp wall | Edge 加速 | Edge 显存 | sd.cpp 显存 | Edge 阶段耗时 | sd.cpp 阶段耗时 |
-|---|---|---|---:|---:|---:|---:|---:|---|---|
-| 图片参考 | [`final.mp4`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-image/final.mp4) | [`final.mp4`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-ref2va-image/final.mp4) | 110s | 228s | 2.07x | 57,339 MiB | 59,081 MiB | load 7.778s / Qwen 0.607s / ref VAE 0.443s / noise 0.491s / DiT 93.242s / video 4.783s / audio 0.168s / save 1.106s | load 6.77s / ref VAE 1.27s / cond 0.50s / DiT 184.82s / video 19.80s / audio 9.10s |
-| 视频帧参考 | [`final.mp4`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-video-frames/final.mp4) | [`final.mp4`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-ref2va-video-frames/final.mp4) | 192s | 417s | 2.17x | 62,931 MiB | 62,595 MiB | load 7.508s / Qwen 1.716s / ref VAE 24.293s / noise 0.475s / DiT 145.866s / video 4.848s / audio 0.173s / save 1.843s | load 6.86s / ref VAE 32.71s / cond 1.51s / DiT 334.36s / video 19.73s / audio 9.08s |
-| 帧序列+配对音频 | [`final.mp4`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-frame-audio/final.mp4) | [`final.mp4`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-ref2va-frame-audio/final.mp4) | 192s | 424s | 2.21x | 62,931 MiB | 62,595 MiB | load 7.655s / Qwen 1.689s / ref VAE 24.403s / audio VAE 0.022s / noise 0.478s / DiT 146.078s / video 4.844s / audio 0.171s / save 1.779s | load 6.79s / ref VAE 33.29s / audio VAE 0.07s / cond 1.41s / DiT 338.90s / video 20.14s / audio 9.07s |
-| 混合参考 | [`final.mp4`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-mixed/final.mp4) | [`final.mp4`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-ref2va-mixed/final.mp4) | 204s | 454s | 2.23x | 62,931 MiB | 62,595 MiB | load 7.656s / Qwen 2.289s / ref VAE 24.673s / audio VAE 0.044s / noise 0.477s / DiT 156.592s / video 4.826s / audio 0.222s / save 1.828s | load 6.77s / ref VAE 34.25s / audio VAE 0.09s / cond 2.03s / DiT 368.01s / video 19.83s / audio 9.08s |
-
-## Ref2VA 视频音频单变量复核（2026-08-13）
-
-本节只验证 Edge 中“给相同视频帧增加配对音频是否破坏画面参考”。两组使用同一 Ref2VA Q8 GGUF、Qwen、VAE、56 张输入帧、`864x480`、124 帧、24 fps、20 steps、CFG `1`、seed `424242` 和字节完全一致的 Prompt。为缩短等待时间，两组分别在空闲 H200 GPU0/GPU1 并行执行，因此 wall 只用于确认运行成本接近，不与上方串行框架对比表混用。
-
-| 条件 | 输出 | 命令 | Wall | 峰值显存 | 输入前 56 帧 SSIM | 观察 |
-|---|---|---|---:|---:|---:|---|
-| 仅视频帧 | [`final.mp4`](../../outputs/minimax-h3/h200-ref2va-audio-ablation-20260813/video-only/final.mp4) | [`cmd.txt`](../../outputs/minimax-h3/h200-ref2va-audio-ablation-20260813/video-only/cmd.txt) | 193s | 62,931 MiB | 0.314700 | 保持公园、树林、长椅、白狗和参考运动 |
-| 同视频帧+配对音频 | [`final.mp4`](../../outputs/minimax-h3/h200-ref2va-audio-ablation-20260813/video-with-paired-audio/final.mp4) | [`cmd.txt`](../../outputs/minimax-h3/h200-ref2va-audio-ablation-20260813/video-with-paired-audio/cmd.txt) | 195s | 62,931 MiB | 0.314327 | 与无音频组内容和参考程度接近 |
-
-两组生成视频之间的全 124 帧 SSIM 为 `0.823399`。加入配对音频会改变联合 DiT 条件和逐像素结果，这是 MiniMax-H3 联合音视频 self-attention 的预期行为；但本次受控结果没有显示画面参考质量下降。正式 benchmark 已改为运行时生成一份公共 Prompt 文件，并让 `ref2va-video-frames` 与 `ref2va-frame-audio` 共同读取该文件，二者唯一输入差异是后者增加 `--ref-video-audio`。
-
-## Edge 各阶段耗时（2026-08-13 Profile 重跑）
-
-本表使用 `ED_MINIMAX_H3_PROFILE=1` 在 H200 GPU0 串行重跑。FL2VA 四项使用修复后的官方 Diffusers BF16 在线 Q8 路径；Ref2VA 图片和混合任务沿用原输入与 Prompt，视频帧两项使用修正后的公共 Prompt。完整状态见 [`status.log`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/status.log)。
-
-| 任务 | Profile 日志 | Wall | 峰值显存 | Load | Qwen context | 关键帧 VAE | 参考视觉 VAE | 参考音频准备+VAE | Noise | DiT | 视频解码+复制 | 音频解码+复制 | Save |
-|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|
-| 文生视频 | [`run.log`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-t2va/run.log) | 140s | 70,333 MiB | 44.716s | 0.141s | 0.000s | 0.000s | 0.000s | 0.482s | 87.719s | 4.895s | 0.259s | 1.143s |
-| 首帧生视频 | [`run.log`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-i2va/run.log) | 146s | 70,493 MiB | 44.608s | 0.505s | 0.435s | 0.000s | 0.000s | 0.482s | 93.043s | 4.898s | 0.215s | 1.121s |
-| 尾帧生视频 | [`run.log`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-l2va/run.log) | 147s | 70,491 MiB | 45.108s | 0.562s | 0.435s | 0.000s | 0.000s | 0.493s | 92.976s | 4.816s | 0.206s | 1.411s |
-| 首尾帧生视频 | [`run.log`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-fl2va/run.log) | 153s | 70,673 MiB | 45.569s | 0.836s | 0.794s | 0.000s | 0.000s | 0.480s | 98.761s | 4.844s | 0.177s | 1.199s |
-| 图片参考 | [`run.log`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-image/run.log) | 110s | 57,339 MiB | 7.778s | 0.607s | 0.000s | 0.443s | 0.000s | 0.491s | 93.242s | 4.783s | 0.168s | 1.106s |
-| 视频帧参考 | [`run.log`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-video-frames/run.log) | 192s | 62,931 MiB | 7.508s | 1.716s | 0.000s | 24.293s | 0.000s | 0.475s | 145.866s | 4.848s | 0.173s | 1.843s |
-| 帧序列+配对音频 | [`run.log`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-frame-audio/run.log) | 192s | 62,931 MiB | 7.655s | 1.689s | 0.000s | 24.403s | 0.022s | 0.478s | 146.078s | 4.844s | 0.171s | 1.779s |
-| 混合参考 | [`run.log`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-mixed/run.log) | 204s | 62,931 MiB | 7.656s | 2.289s | 0.000s | 24.673s | 0.044s | 0.477s | 156.592s | 4.826s | 0.222s | 1.828s |
-
-计时口径：
-
-- `Load`、`Save` 来自进程外层 `[ED_WALL]`；其余列来自 pipeline 内部 `minimax-h3 profile`。
-- `Qwen context` 是完整条件上下文阶段，内部包含视觉输入准备、Qwen3-VL vision encode、tokenize 和 text encode；不与关键帧/参考 VAE 重叠。
-- `参考视觉 VAE` 同时承载 Ref2VA 图片和视频参考编码，因此图片任务的 `0.443s` 也列在该列。
-- `DiT` 为 20 次 conditional diffusion call；本轮 CFG 为 `1`，没有 unconditional call 和 CFG combine。
-- `视频解码+复制`、`音频解码+复制` 分别合并 VAE decode 与输出 postprocess/copy；各主阶段可以相加解释内部 generation，但不包含进程启动、模型加载和容器封装。
-
-## sd.cpp 各阶段耗时（2026-08-13 Eager 重跑）
-
-本表使用官方 Comfy INT8 ConvRot DiT 和 `--eager-load` 在 H200 GPU0 串行运行。`run.log` 中 FL2VA/Ref2VA 分别记录 `64,256.98 MiB`/`51,867.89 MiB` 的 prepared params backend buffer，确认模型参数整体常驻 GPU，而非按层 lazy 搬运。
-
-| 任务 | 日志 | Wall | 峰值显存 | Load | 视觉 VAE encode | 音频 VAE encode | Condition | DiT | 视频解码 | 音频解码 |
-|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|
-| 文生视频 | [`run.log`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-fl2va-t2va/run.log) | 219s | 71,107 MiB | 8.31s | 0.00s | 0.00s | 0.14s | 175.62s | 19.58s | 9.10s |
-| 首帧生视频 | [`run.log`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-fl2va-i2va/run.log) | 236s | 71,435 MiB | 8.48s | 1.41s | 0.00s | 0.44s | 190.93s | 20.11s | 9.09s |
-| 尾帧生视频 | [`run.log`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-fl2va-l2va/run.log) | 235s | 72,490 MiB | 8.36s | 1.40s | 0.00s | 0.43s | 190.47s | 19.68s | 9.08s |
-| 首尾帧生视频 | [`run.log`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-fl2va-fl2va/run.log) | 257s | 71,463 MiB | 8.39s | 2.53s | 0.00s | 0.77s | 209.14s | 20.89s | 9.08s |
-| 图片参考 | [`run.log`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-ref2va-image/run.log) | 228s | 59,081 MiB | 6.77s | 1.27s | 0.00s | 0.50s | 184.82s | 19.80s | 9.10s |
-| 视频帧参考 | [`run.log`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-ref2va-video-frames/run.log) | 417s | 62,595 MiB | 6.86s | 32.71s | 0.00s | 1.51s | 334.36s | 19.73s | 9.08s |
-| 帧序列+配对音频 | [`run.log`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-ref2va-frame-audio/run.log) | 424s | 62,595 MiB | 6.79s | 33.29s | 0.07s | 1.41s | 338.90s | 20.14s | 9.07s |
-| 混合参考 | [`run.log`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-ref2va-mixed/run.log) | 454s | 62,595 MiB | 6.77s | 34.25s | 0.09s | 2.03s | 368.01s | 19.83s | 9.08s |
-
-## 阶段耗时说明
-
-- Edge 阶段来自 `ED_MINIMAX_H3_PROFILE=1` 内部 profile；sd.cpp 阶段来自 `-v` 的原生 timing 日志。两套阶段名和边界并不完全相同，适合定位各自热点，不应逐列视为严格同一计时区间。
-- sd.cpp `Load` 是各次 `loading tensors completed` 的累计值；`Condition` 对应 `get_learned_condition`；DiT 对应 sampling；视觉/音频 VAE encode 与 decode 使用日志中各阶段完成时间。
-- 两框架外部 wall 都包含进程启动、模型加载、生成、框架内部保存和正常退出。sd.cpp wall 在外部 FFmpeg 将 `final.webm` 转为 `final.mp4` 前结束，因此不包含文档封装转码时间。
-- 峰值显存均从完整 `gpu_mem.csv` 的 GPU0 `memory.used` 数值列取最大值；修正后的 parser 使用数值转换，避免旧脚本按字符串比较导致错误峰值。
-
-## sd.cpp Eager 与旧 Lazy 对比
-
-| 任务 | Lazy wall | Eager wall | Lazy 峰值显存 | Eager 峰值显存 |
-|---|---:|---:|---:|---:|
-| 文生视频 | 219s | 219s | 65,951 MiB | 71,107 MiB |
-| 图片参考 | 228s | 228s | 54,749 MiB | 59,081 MiB |
-| 视频帧参考 | 422s | 417s | 56,245 MiB | 62,595 MiB |
-| 帧序列+配对音频 | 422s | 424s | 57,389 MiB | 62,595 MiB |
-| 混合参考 | 455s | 454s | 57,433 MiB | 62,595 MiB |
-
-`--eager-load` 对速度没有可辨认的稳定收益：八项 wall 差异为 `-5s–+2s`，属于运行波动；但参数常驻会明显提高峰值显存。本文最终主表采用 eager 数据，是为了让 Edge 与 sd.cpp 都按组件常驻口径比较显存，而不是为了宣称 eager 更快。
-
-## 文件索引
-
-每个任务目录均包含 `cmd.txt`、`prompt.txt`、`run.log`、`gpu_mem.csv`、`metrics.json` 和 `final.mp4`；sd.cpp 目录还包含 `inputs.txt` 并保留原始 `final.webm`。
-
-| 任务 | Edge 目录 | sd.cpp 目录 |
-|---|---|---|
-| 文生视频 | [`fl2va-t2va`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-t2va) | [`sdcpp-fl2va-t2va`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-fl2va-t2va) |
-| 首帧生视频 | [`fl2va-i2va`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-i2va) | [`sdcpp-fl2va-i2va`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-fl2va-i2va) |
-| 尾帧生视频 | [`fl2va-l2va`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-l2va) | [`sdcpp-fl2va-l2va`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-fl2va-l2va) |
-| 首尾帧生视频 | [`fl2va-fl2va`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/fl2va-fl2va) | [`sdcpp-fl2va-fl2va`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-fl2va-fl2va) |
-| 图片参考 | [`ref2va-image`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-image) | [`sdcpp-ref2va-image`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-ref2va-image) |
-| 视频帧参考 | [`ref2va-video-frames`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-video-frames) | [`sdcpp-ref2va-video-frames`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-ref2va-video-frames) |
-| 帧序列+配对音频 | [`ref2va-frame-audio`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-frame-audio) | [`sdcpp-ref2va-frame-audio`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-ref2va-frame-audio) |
-| 混合参考 | [`ref2va-mixed`](../../outputs/minimax-h3/h200-edge-profile-8tasks-20260813/ref2va-mixed) | [`sdcpp-ref2va-mixed`](../../outputs/minimax-h3/h200-sdcpp-eager-int8-profile-20260813/sdcpp-ref2va-mixed) |
diff --git a/docs/optimization/minimax-h3-handoff-2026-08-07.md b/docs/optimization/minimax-h3-handoff-2026-08-07.md
deleted file mode 100644
index 450ce21..0000000
--- a/docs/optimization/minimax-h3-handoff-2026-08-07.md
+++ /dev/null
@@ -1,1147 +0,0 @@
-# MiniMax-H3 optimization and Diffusers handoff (2026-08-07)
-
-## Scope and constraints
-
-- Repository: `/export/home/wangtianyang.21/code1/edge-dit.cpp`
-- Current branch: `main`; last committed H3 baseline: `5472c67 Align MiniMax H3 conditioning with sd.cpp`.
-- Use **one CUDA GPU only** for inference/performance work. Do not run CPU inference.
-- This is a shared machine. Do not kill processes that are not created by this task.
-- Do not commit or push without an explicit user request.
-- The user wants eventual quality and performance comparison against official Hugging Face Diffusers, not just sd.cpp.
-
-## Current working tree
-
-Intentional, uncommitted source changes that predate this handoff:
-
-- `src/dit_models/pipelines/minimax_h3_pipeline.cpp`
-- `src/dit_models/pipelines/minimax_h3_pipeline.hpp`
-
-These add `ED_MINIMAX_H3_PROFILE=1` phase timing and make H3 honor explicit VAE tiling disablement. Keep them unless separately reviewed.
-
-New, uncommitted Diffusers benchmark launcher files:
-
-- `scripts/diffusers/run_minimax_h3_fl2va.py`
-- `scripts/diffusers/run_minimax_h3_fl2va.sh`
-
-Other untracked paths shown by `git status` (assets, benchmarks, `.codex-tmp`, `third_party/onednn`, and so on) were already present or are unrelated; do not clean them blindly.
-
-## Current edge-dit H3 implementation
-
-The project supports both MiniMax-H3 checkpoint families through the existing H3 pipeline:
-
-- FL2VA: text-to-audio-video and first/last-keyframe-to-audio-video.
-- Ref2VA: ordered image/video/audio reference conditioning.
-
-The C++ model baseline is quantized GGUF:
-
-- `/models/MiniMax-H3-GGUF/minimax_h3_fl2va-Q4_K_M.gguf`
-- `/models/MiniMax-H3-GGUF/qwen3vl_32b_minimax_h3-Q4_K_M.gguf`
-- `/models/MiniMax-H3-GGUF/minimax_h3_video_vae_fp16.safetensors`
-- `/models/MiniMax-H3-GGUF/minimax_h3_audio_vae_fp32.safetensors`
-
-The main H3 implementation is in:
-
-- `src/dit_models/models/minimax_h3_full.hpp`
-- `src/dit_models/pipelines/minimax_h3_pipeline.cpp`
-- `src/dit_models/pipelines/minimax_h3_pipeline.hpp`
-
-sd.cpp reference source is read-only at `../stable-diffusion.cpp`.
-
-## CUDA build and runtime state
-
-The active container is `wty-edgedit-dev`; workspace inside it is `/workspace/edge-dit.cpp`.
-
-The active CUDA build is `build-cuda-docker`, built successfully with:
-
-```bash
-docker exec wty-edgedit-dev bash -lc \
-  'cd /workspace/edge-dit.cpp && cmake --build build-cuda-docker -j64'
-```
-
-Relevant active CMake options:
-
-```text
-ED_ENABLE_CUDA_MODULATION=ON
-ED_ENABLE_CUDA_NORM=ON
-ED_ENABLE_CUDA_ROPE=ON
-GGML_CUDA_FA=ON
-GGML_CUDA_FORCE_MMQ=OFF
-GGML_CUDA_FORCE_CUBLAS=OFF
-GGML_CUDA_GRAPHS=OFF
-```
-
-`GGML_CUDA_GRAPHS=ON` was tested with an isolated rebuild. It produced identical first-frame output but did not improve H3: 5-step diffusion changed from `25.593s` to `25.619s`. It is intentionally restored to `OFF`.
-
-## Performance baseline and operator profile
-
-Primary small regression case (FL2VA):
-
-```text
-Resolution: 864x480
-Frames: 56 at 24 fps
-Steps: 5
-Seed: 42
-CFG: 2
-VAE tiling: explicitly off
-```
-
-Baseline script and output:
-
-- `outputs/minimax-h3/perf-fl2va-regression-2026-08-07/run.sh`
-- `outputs/minimax-h3/perf-fl2va-regression-2026-08-07/final.mp4`
-- `outputs/minimax-h3/perf-fl2va-regression-2026-08-07/run.log`
-
-Baseline phase timing:
-
-```text
-generation total: 34.221s
-diffusion:        25.593s (10 forwards: conditional + unconditional per step)
-conditioning:      0.916s
-decode:            7.524s
-end-to-end wall:  42.811s
-```
-
-For the larger mixed Ref2VA baseline (`864x480`, 56 frames, 20 steps, CFG 2):
-
-```text
-total:                     260.523s
-diffusion:                 222.113s (85.3%)
-reference video VAE encode: 24.498s
-```
-
-CUDA op profiling for the FL2VA 5-step probe:
-
-```text
-one DiT CUDA graph:       about 2.46s
-Q4_K x FP32 MMQ/GEMM:     1.61-1.64s (about 66%)
-attention:                0.30-0.32s (about 12-13%)
-layout/materialization:   about 0.44s (about 18%)
-elementwise/norm/RoPE:    about 0.23s (about 9%)
-```
-
-Percentages are profiler buckets and overlap slightly; do not force them to sum exactly to 100%.
-
-Heavy MMQ shapes observed:
-
-```text
-m=28672 n=7919 k=5376, 50 calls: about 642ms
-m=21504 n=7919 k=5376, 50 calls: about 480ms
-m=5376  n=7919 k=14336, 50 calls: about 329ms
-m=5376  n=7919 k=7168, 50 calls: about 166ms
-```
-
-Relevant artifacts:
-
-- `outputs/minimax-h3/perf-baseline-mixed-2026-08-07/baseline.mp4`
-- `outputs/minimax-h3/perf-runner-probe-2026-08-07/run.log`
-- `outputs/minimax-h3/perf-cuda-op-profile-fl2va-2026-08-07/run.log`
-- `outputs/minimax-h3/perf-cudnn-sdpa-fl2va-2026-08-07/run.log`
-
-## MMQ, Tensor Cores, and cuDNN
-
-The main Q4_K DiT linear layers use GGML CUDA MMQ. On the H200 (SM90), this takes GGML's Turing-or-newer MMA path, so it does use Tensor Cores. The activation is dynamically quantized to `Q8_1` and multiplied with `Q4_K` weights; it is not a normal BF16 GEMM dispatched through cuBLAS/cuDNN.
-
-This is not unique to H3: the CUDA backend dispatches every quantized matrix multiplication meeting the same conditions (quantized weights, F32 activation/output, compatible layout and sufficiently large batch) through the common MMQ route. Different models and quantization types select different MMQ specializations; unsupported layouts or small/vector cases use MMVQ or fall back to cuBLAS after conversion. H3's main Q4_K projections meet the MMQ conditions.
-
-cuDNN still helps a separate part of the model: H3 long self-attention successfully hits cuDNN SDPA (`b=1`, `h=56`, `d=128`, sequence length around `7919`). Some padded/unsupported attention shapes fall back. MMQ is the primary throughput limit and is not replaced by cuDNN SDPA.
-
-Existing Flux/Qwen fused modulation or QKV paths do not automatically match H3. H3 has multi-span AdaLN modulation and concatenation in `minimax_h3_full.hpp`; a specialized implementation is needed rather than reusing those model-specific fusions blindly.
-
-## Attempted H3 modulation fusion — rejected
-
-An experiment temporarily connected H3 spans in `minimax_h3_full.hpp` to the existing generic CUDA custom ops:
-
-- `edgedit::ggml_ext::fused_modulate_custom`
-- `edgedit::ggml_ext::fused_residual_gate_custom`
-
-The experiment was fully reverted. There is no remaining H3 fusion change in the source tree.
-
-Why it was rejected:
-
-- It made the 5-step diffusion timer look better: `25.593s -> 25.174s` (about 1.6%).
-- Although mathematically equivalent, the fused kernel's floating-point instruction path differs from the original graph's `mul -> add -> add` scheduling.
-- Diffusion amplifies tiny differences. The resulting 56-frame video diverged visibly: middle frames were around `23dB` PSNR against the baseline, so the output is not quality-equivalent.
-
-Experimental artifacts (use only for diagnosis, not as accepted outputs):
-
-- `outputs/minimax-h3/perf-fused-modulation-fl2va-2026-08-07/final.mp4`
-- `outputs/minimax-h3/perf-fused-modulation-fl2va-2026-08-07/run.log`
-
-Any future H3 fusion must use a strict quality gate:
-
-1. Preserve the original operation/rounding order where possible; do not use algebraic rewrites or FMA that change it.
-2. Run the same deterministic input and seed.
-3. Compare all decoded frames and audio, not just MP4 hashes or the first frame.
-4. Only retain an optimization after proving quality is acceptable and timing improvement survives repeated trials.
-
-The likely next low-risk target is a H3-specific, rounding-preserving span implementation that reduces temporary layout/copy work without changing `mul -> add -> add` semantics. It should be profiled before implementation; it can only address the layout/elementwise portion, not the approximately 66% MMQ limit.
-
-## Official Diffusers baseline
-
-Official model URL: `https://huggingface.co/MiniMaxAI/MiniMax-H3`.
-
-Official Diffusers documentation: `https://huggingface.co/docs/diffusers/main/en/api/pipelines/minimax_h3`.
-
-The installed release `diffusers==0.39.0` did not contain MiniMax-H3. Diffusers main was cloned to:
-
-```text
-/mnt/cfs/9n-das-admin/llm_models/MiniMax-H3-Diffusers/code/diffusers-main
-revision 53e5b00
-```
-
-Inside the container, use it without editable installation because `/models` is read-only:
-
-```bash
-export PYTHONPATH=/models/MiniMax-H3-Diffusers/code/diffusers-main/src${PYTHONPATH:+:$PYTHONPATH}
-```
-
-Runtime dependency state inside `wty-edgedit-dev`:
-
-```text
-torch 2.7.1+cu128
-transformers 5.12.0
-accelerate 1.14.0
-torchao 0.15.0
-fbgemm-gpu-genai 1.2.0
-PyAV installed
-imageio-ffmpeg installed
-sentencepiece installed
-```
-
-Do not upgrade `torchao` blindly: `torchao 0.18.0` was incompatible with the container's PyTorch 2.7.1. `torchao==0.15.0` plus `fbgemm-gpu-genai==1.2.0` is the currently verified combination for TorchAO int4 smoke tests and the MiniMax-H3 FL2VA int4 run. `fbgemm-gpu-genai==1.8.0` was rejected because it tried to load CUDA 13 runtime (`libcudart.so.13`) on this CUDA 12.8 container.
-
-### Important comparison caveat
-
-The edge benchmark uses quantized GGUF and CFG 2 with two DiT forwards per step. Official Diffusers uses original BF16 weights and documents CFG-distilled behavior: no negative prompt or guidance scale, one model forward per step. These are not yet an apples-to-apples timing configuration. The official run is necessary to establish its own quality/timing baseline; do not claim direct speed parity until equivalent workflow parameters are analyzed.
-
-The edge H3 pipeline already has the matching fast path: `cfg_scale == 1.0f` skips unconditional context construction and the unconditional DiT call. The existing performance probe deliberately used `--cfg-scale 2`, hence its 5 steps produce 10 DiT calls. Switching to CFG 1 changes the sampling configuration/output and is not a lossless optimization of the CFG 2 baseline; measure it separately as the official distilled-model comparison configuration.
-
-Measured on the 864x480, 56-frame, 5-step FL2VA probe on one H200:
-
-```text
-CFG 2: 10 DiT calls, diffusion 25.519s
-CFG 1:  5 DiT calls, diffusion 12.798s
-```
-
-### MMQ versus forced cuBLAS experiment — rejected
-
-`GGML_CUDA_FORCE_CUBLAS=ON` was compiled and tested on the same CFG 1 probe. It made DiT much faster (`12.798s -> 8.314s` for five forwards), but it did not preserve the quantized execution's output: decoded frame comparison gave minimum PSNR `28.86dB`, average PSNR `35.15dB`, and maximum RGB difference `207`. This is a genuine deterministic difference because two default-MMQ runs produced byte-identical MP4 files and all 56 decoded frames were pixel-identical.
-
-The CMake build was restored to both `GGML_CUDA_FORCE_CUBLAS=OFF` and `GGML_CUDA_FORCE_MMQ=OFF`. Do not enable forced cuBLAS as an accepted H3 optimization without an explicit quality/compatibility decision. The likely reason is that the fallback uses a different quantized-weight conversion/accumulation path than MMQ.
-
-### Download and automatic benchmark state
-
-Writable host/CFS target:
-
-```text
-/mnt/cfs/9n-das-admin/llm_models/MiniMax-H3-Diffusers
-```
-
-Inside container the same target is `/models/MiniMax-H3-Diffusers` and is read-only.
-
-The correct Diffusers components are at repository root (`transformer/`, `text_encoder/`, `vae/`, `audio_vae/`, scheduler/tokenizer/processor), not in `FL2VA/`. `FL2VA/` is original-format deployment material and was not retained. The active download selects exactly the official Diffusers FL2VA components (61 files, about 134.16 GiB).
-
-Do not kill these two task-owned background processes; both are detached with `setsid` and resumable curl:
-
-```text
-PID stored in .../logs/download-diffusers-fl2va.pid
-script: /mnt/cfs/9n-das-admin/llm_models/MiniMax-H3-Diffusers/download_diffusers_fl2va.sh
-
-PID stored in .../logs/run-when-ready.pid
-script: /mnt/cfs/9n-das-admin/llm_models/MiniMax-H3-Diffusers/run_when_diffusers_fl2va_ready.sh
-```
-
-The watcher performs exact file-size completeness checks, waits for GPU 0 to be under 1GiB used, then runs:
-
-```bash
-docker exec wty-edgedit-dev bash -lc \
-  'cd /workspace/edge-dit.cpp && CUDA_VISIBLE_DEVICES=0 scripts/diffusers/run_minimax_h3_fl2va.sh'
-```
-
-It writes:
-
-```text
-/mnt/cfs/9n-das-admin/llm_models/MiniMax-H3-Diffusers/logs/diffusers-fl2va-benchmark.log
-/mnt/cfs/9n-das-admin/llm_models/MiniMax-H3-Diffusers/logs/diffusers-fl2va-benchmark-status.log
-outputs/minimax-h3/diffusers-fl2va-768p/final.mp4
-outputs/minimax-h3/diffusers-fl2va-768p/final.json
-```
-
-The generated Python runner records component loading, CUDA generation, mux, and end-to-end time. It uses official `ComponentsManager.enable_auto_cpu_offload(device="cuda:0")`: model execution occurs on CUDA, while components not active in the current stage reside in host memory. This is the official single-GPU recipe for this combined model size.
-
-### Diffusers TorchAO quantized comparison
-
-Artifacts and scripts added for Diffusers quantized comparison:
-
-- `scripts/diffusers/run_minimax_h3_fl2va_quantized.py`
-- `outputs/minimax-h3/diffusers-fl2va-480p124-int8-gpu3/final.mp4`
-- `outputs/minimax-h3/diffusers-fl2va-480p124-int4-gpu0/final.mp4`
-- `outputs/minimax-h3/diffusers-fl2va-480p124-int4-resident-gpu0/final.mp4`
-- `outputs/minimax-h3/compare-diffusers-fl2va-480p124-q4-cfg1-noneg-2026-08-07/final.mp4`
-
-Common benchmark configuration:
-
-```text
-Workflow: FL2VA
-Prompt: Create a smooth cinematic transition between the supplied first and last frame, preserving the subject, lighting, and composition with natural coherent motion and synchronized ambient audio.
-Negative prompt: none
-Inputs: outputs/minimax-h3/fl2va/edge/frames/first.png and outputs/minimax-h3/fl2va/edge/frames/last.png
-Resolution: 864x480
-Frames: 124 at 24 fps, duration 5.175s
-Steps: 20
-Seed: 42
-Guidance: edge uses --cfg-scale 1, giving one DiT forward per step; Diffusers MiniMax-H3 uses the official CFG-distilled one-forward path.
-```
-
-Important quantization scope caveat: neither implementation is fully 4-bit end to end. Edge uses GGUF `Q4_K_M` mixed quantization for the DiT and Qwen3VL conditioner, but the video VAE is FP16 and the audio VAE is FP32. Diffusers TorchAO int4/int8 uses weight-only quantization for the `transformer` and `text_encoder` large linear weights only; `vae`, `audio_vae`, schedulers, tokenizer, and processor are not quantized. Some transformer and text encoder modules are intentionally excluded from quantization (`proj_in`, `audio_proj_in`, time/context embeddings, output projections, norms/rope, Qwen visual tower, embeddings, and `lm_head`).
-
-MiniMax-H3 GGUF component sizes inside the container:
-
-```text
-/models/MiniMax-H3-GGUF/minimax_h3_fl2va-Q4_K_M.gguf                    18G, 18779848448 bytes
-/models/MiniMax-H3-GGUF/minimax_h3_ref2va_pruned-Q4_K_M.gguf            11G, 11420663904 bytes
-/models/MiniMax-H3-GGUF/qwen3vl_32b_minimax_h3-Q4_K_M.gguf              17G, 18218065024 bytes
-/models/MiniMax-H3-GGUF/minimax_h3_video_vae_fp16.safetensors          4.9G, 5207808496 bytes
-/models/MiniMax-H3-GGUF/minimax_h3_audio_vae_fp32.safetensors          578M, 605254808 bytes
-```
-
-Observed edge weight stats for the comparable FL2VA Q4 run:
-
-```text
-overall:          f32:930 | f16:562 | q4_0:50 | q4_K:458 | q6_K:100 | bf16:816
-conditioner:      q4_K:250 | q6_K:100 | bf16:552
-diffusion model:  f32:13 | q4_0:50 | q4_K:208 | bf16:264
-VAE:              f32:917 | f16:562
-```
-
-Measured timings:
-
-| Runner | Quantization | Residency | Generation timing | End-to-end |
-| --- | --- | --- | ---: | ---: |
-| edge.cpp | GGUF Q4_K_M mixed Q4/Q6/BF16/F32 | GPU resident | `108.619s` diffusion, `131.870s` generation | `141.249s` wall |
-| Diffusers | TorchAO int4 weight-only | GPU resident | `62.511s` `generate_cuda` | `105.194s` |
-| Diffusers | TorchAO int4 weight-only | CPU/GPU group offload | `144.141s` `generate_cuda` | `181.148s` |
-| Diffusers | TorchAO int8 weight-only | CPU/GPU group offload | `256.031s` `generate_cuda` | `271.528s` |
-
-The resident Diffusers int4 path is the closest current timing comparison to edge's GPU-resident Q4 run. It is faster for this task, but it is still not identical quantization: GGUF `Q4_K_M` and TorchAO int4 weight-only use different layouts, skipped-module sets, activation handling, kernels, and numerical behavior.
-
-File identity and quality sanity checks:
-
-```text
-edge Q4 resident:         d63a9dad18f65001674a763d89630f308a181dc5b04c9fbafbcb8dc4a11c930a
-Diffusers int8 offload:   f6cddc3d6f466a3627c83c22c2b2410558b7b582dedb2e950dea267932414d86
-Diffusers int4 offload:   78bee7947ffb0cd0ae09e660183de3a3b5f2e5f2ad73885915e7d6f5059d577f
-Diffusers int4 resident:  38eb05e9eb8b69cfe570c6ba1bf3267fd4dad4b537f3c89f9678a9312053e351
-```
-
-The edge Q4 and Diffusers int8 videos can look similar at the endpoints because FL2VA strongly constrains the first and last frames, but they are not the same file or the same generated video. Sample decoded-frame PSNR for edge Q4 versus Diffusers int8 was about `35.70dB` on the first sampled frame, `10.50dB` on the middle sampled frame, and `35.95dB` on the last sampled frame.
-
-Dependency notes for reproducing Diffusers int4:
-
-```bash
-docker exec wty-edgedit-dev bash -lc \
-  'python3 -m pip install --user --no-cache-dir -i https://pypi.tuna.tsinghua.edu.cn/simple torchao==0.15.0 fbgemm-gpu-genai==1.2.0'
-```
-
-`fbgemm-gpu-genai==1.8.0` should not be used on this container because it requires CUDA 13 runtime. The verified int4 smoke test is a CUDA BF16 `torch.nn.Linear` quantized with `Int4WeightOnlyConfig(group_size=128)`.
-
-To inspect progress safely:
-
-```bash
-ROOT=/mnt/cfs/9n-das-admin/llm_models/MiniMax-H3-Diffusers
-cat "$ROOT/logs/diffusers-fl2va-benchmark-status.log"
-tail -100 "$ROOT/logs/diffusers-fl2va-benchmark.log"
-ps -p "$(cat "$ROOT/logs/download-diffusers-fl2va.pid")" -o pid,stat,etimes,cmd
-```
-
-## Suggested continuation order
-
-1. Let the official download and watcher complete; inspect the automatic Diffusers benchmark output/logs.
-2. Verify official run success, MP4 streams, video dimensions/frame count, audio, and JSON phase times.
-3. Make a documented comparison: original BF16 Distilled Diffusers vs Q4_K edge-dit. Separate model-format/config differences from framework overhead.
-4. If optimizing edge H3 further, profile a stable repeated baseline first, then target layout/materialization with a strict output-quality gate.
-5. Consider MMQ specialization only after the above: it is the principal bottleneck and requires SM90/H3-shape-specific kernel work plus robust correctness testing.
-
-## 2026-08-07 DiT performance follow-up
-
-Strict timing clarification for the 864x480, 124-frame, steps=20, seed=42 FL2VA keyframe benchmark:
-
-- Diffusers TorchAO int4 resident with transformer forward hooks measured `generate_cuda=62.748s`, `transformer_forward_cuda=56.724s`, `transformer_forward_calls=19`.
-- Edge before scheduler alignment had `diffusion=110.552s`, `diffusion_calls=20` in the profiled run, so `108.6s vs 62.5s` was not DiT-only vs DiT-only and edge also ran one extra transformer call.
-- MiniMax-H3 official scheduler treats `num_inference_steps` as sigma grid points including the terminal clean point. Therefore `steps=20` runs 19 model evaluations.
-- Edge was fixed to loop while `step + 1 < steps`, matching Diffusers. Correct FL2VA keyframe run now reports `diffusion=103.062s`, `diffusion_calls=19`, total generation `125.974s`.
-- The per-forward gap remains large: edge is about `5.42s/forward`; Diffusers transformer-only is about `2.99s/forward`.
-
-Validation artifacts:
-
-- Diffusers transformer-only profile: `outputs/minimax-h3/diffusers-fl2va-480p124-int4-resident-profile3-gpu0/final.json`
-- Edge corrected full run: `outputs/minimax-h3/perf-fl2va-keyframes-480p124-cfg1-steps20-scheduler19-2026-08-07/run.log`
-- Edge 56-frame smoke baseline: `outputs/minimax-h3/perf-fl2va-keyframes-480p56-cfg1-steps5-default-mmq-2026-08-07/run.log`
-
-Experiments rejected or left off by default:
-
-- `GGML_CUDA_FORCE_MMQ=ON`, which permits larger MMQ tiles on SM90, did not improve the 56-frame/5-step smoke case: `diffusion=10.308s` vs default `10.321s` for four calls, within noise.
-- H3 compiled-graph reuse was prototyped behind `ED_MINIMAX_H3_REUSE_GRAPHS=1` and left disabled by default. The current small benchmark showed no measurable DiT improvement (`10.360s` for four calls). Do not enable it by default without further investigation.
-- The previous `ED_CUDA_DISABLE_MMQ_STREAM_K` experiment was reverted; stream-k disabling was much slower.
-
-Current bottleneck after the scheduler alignment is still GGML Q4_K MMQ for H3's large projection shapes. Diffusers TorchAO/fbgemm int4 resident is likely using a Hopper-friendlier weight-only int4 layout/kernel. A real next performance step requires either a better SM90 Q4_K kernel/layout, or an optional prepacked resident int4/fp16-weight path for H3's DiT projections. Layout/materialization remains a secondary target, but it cannot close the main 5.42s vs 2.99s per-forward gap alone.
-
-## 2026-08-07 SM90 Q4_K DiT optimization
-
-The first practical DiT speedup came from revisiting the cuBLAS fallback instead of treating GGML MMQ as always best on Hopper.
-
-Change made:
-
-- `third_party/ggml/src/ggml-cuda/mmq.cu` now sends NVIDIA SM90+ `Q4_K` matrix multiplications with `ne11 >= 512` through the existing dequantize + cuBLAS path instead of MMQ.
-- Small-column `Q4_K` calls still use MMQ, preserving the fast small-batch path used by text/auxiliary projections.
-- The rule is disabled by compiling with `GGML_CUDA_FORCE_MMQ`; it can also be disabled at runtime with `GGML_CUDA_SM90_Q4K_CUBLAS=0`.
-
-Measured impact on the H200 FL2VA benchmark (`864x480`, `124` frames, `24fps`, `steps=20`, `cfg=1`, seed `42`, one DiT forward per scheduler step):
-
-| Build | Total generation | DiT diffusion | DiT calls | Decode | Artifact |
-| --- | ---: | ---: | ---: | ---: | --- |
-| Baseline scheduler-aligned edge | `125.974s` | `103.062s` | `19` | `21.573s` | `outputs/minimax-h3/perf-fl2va-keyframes-480p124-cfg1-steps20-scheduler19-2026-08-07/run.log` |
-| SM90 Q4_K cuBLAS rule | `92.378s` | `67.220s` | `19` | `23.586s` | `outputs/minimax-h3/perf-dit-sm90-q4-cublas-480p124-cfg1-steps20-2026-08-07/run.log` |
-
-The DiT part improved by about `34.8%` (`103.062s -> 67.220s`). This moves edge much closer to the Diffusers TorchAO int4 resident reference (`transformer_forward_cuda=56.724s`, `19` calls), though Diffusers is still faster.
-
-Small validation task (`864x480`, `56` frames, `steps=5`, effective `4` DiT calls):
-
-| Build | Total generation | DiT diffusion | Artifact |
-| --- | ---: | ---: | --- |
-| Baseline MMQ | `20.912s` | `10.845s` | `outputs/minimax-h3/perf-dit-default-56f5s-2026-08-07/run.log` |
-| SM90 Q4_K cuBLAS rule | `16.926s` | `7.239s` | `outputs/minimax-h3/perf-dit-sm90-q4-cublas-56f5s-2026-08-07/run.log` |
-
-Kernel-path evidence from the 56-frame run:
-
-- Baseline large H3 projections used `path=mmq` for `Q4_K` shapes such as `m=28672 n=7919 k=5376`, totaling about `2.559s` across the profiled calls for that shape.
-- Optimized run used `path=op_cublas` for the same large shapes, totaling about `1.242s` for `m=28672 n=7919 k=5376`.
-- Small `n=38` `Q4_K` calls remained on `path=mmq` in the 124-frame run, confirming the threshold did not force every quantized GEMM through cuBLAS.
-
-Quality/numerics note:
-
-- This is not bit-identical to MMQ. The cuBLAS route dequantizes and accumulates through a different path, so diffusion can diverge slightly even with the same seed.
-- On the first eight decoded frames of the 56-frame smoke output, baseline-vs-optimized frame PSNR was roughly `44.3dB` on frame 1 and `33.5-40.7dB` on frames 2-8. The output remains visually close in this smoke check, but quality should be spot-checked on representative prompts before release.
-- The change is framework-level for SM90+ large `Q4_K` GEMMs, not MiniMax-H3-specific. It may also benefit other large-Q4_K video DiTs on H100/H200, but it should be validated per model because numerical differences are possible.
-
-Next bottlenecks after this change:
-
-1. Diffusion still trails Diffusers int4 resident by about `10.5s` transformer time on the 124-frame benchmark (`67.2s` vs `56.7s`). TorchAO/fbgemm likely benefits from a prepacked TensorCoreTiled int4 layout, while GGUF `Q4_K` still pays dequantization/materialization costs in the cuBLAS path.
-2. Layout/materialization remains around the next largest category in the old profile. Re-run `ED_PROFILE_CUDA_OPS=1` with the new rule and target the top layout nodes next.
-3. A true longer-term fix is an SM90-native prepacked int4/Q4_K GEMM kernel or conversion path for resident H3 projections, with strict image/video quality gates.
-
-## 2026-08-07 MLP SwiGLU materialization optimization
-
-After the SM90 Q4_K cuBLAS rule, the next DiT profile showed layout/materialization as the second-largest category. In the 56-frame/5-step DiT-only graph subset:
-
-```text
-GEMM        2.873s
-LAYOUT      1.771s
-ELEMENTWISE 0.927s
-FLASH_ATTN  0.831s
-```
-
-The top layout nodes were `CONT` materializations of the two strided halves of the MLP `fc1` output:
-
-```text
-CONT [14336,7919] from chunk/view: ~0.478s over 4 DiT calls
-CONT [7168,7919]  from chunk/view: ~0.362s over 4 DiT calls
-```
-
-Change made:
-
-- `src/dit_models/models/minimax_h3_full.hpp` now uses `ggml_swiglu(ctx, fc1(x))` for H3 MLP instead of `chunk(fc1(x), 2) -> silu(first) * second`.
-- This reuses ggml's existing CUDA `SWIGLU` unary-gated kernel and removes the largest `[14336, seq]` materialization path.
-- Semantics match the previous expression because `ggml_swiglu` treats the first half as the activated value and the second half as the gate, which is exactly `silu(uv[0]) * uv[1]`.
-
-Measured impact on the same H200 FL2VA benchmark:
-
-| Build | Total generation | DiT diffusion | DiT calls | Artifact |
-| --- | ---: | ---: | ---: | --- |
-| SM90 Q4_K cuBLAS rule | `92.378s` | `67.220s` | `19` | `outputs/minimax-h3/perf-dit-sm90-q4-cublas-480p124-cfg1-steps20-2026-08-07/run.log` |
-| SM90 Q4_K cuBLAS + MLP SwiGLU | `86.592s` | `62.061s` | `19` | `outputs/minimax-h3/perf-dit-sm90-q4-cublas-swiglu-480p124-cfg1-steps20-2026-08-07/run.log` |
-
-This second step improves DiT by another `7.7%` (`67.220s -> 62.061s`). Combined with scheduler alignment and SM90 Q4_K cuBLAS, edge's comparable 124-frame DiT time moved from `103.062s` to `62.061s`, now close to Diffusers TorchAO int4 resident transformer-only time (`56.724s`).
-
-56-frame op-profile validation:
-
-| Build | DiT diffusion | DiT layout category | Artifact |
-| --- | ---: | ---: | --- |
-| SM90 Q4_K cuBLAS rule | `7.276s` | `1.771s` | `outputs/minimax-h3/perf-dit-sm90-q4-cublas-opprofile-56f5s-2026-08-07/run.log` |
-| + MLP SwiGLU | `6.730s` | `1.311s` | `outputs/minimax-h3/perf-dit-sm90-q4-cublas-swiglu-56f5s-2026-08-07/run.log` |
-
-Remaining DiT gap vs Diffusers:
-
-- Diffusers TorchAO/fbgemm int4 resident still has the better int4 GEMM layout: `TensorCoreTiledLayout(inner_k_tiles=8)` + TinyGEMM, packed as `[n/8, k/(inner_k_tiles*16), 32, inner_k_tiles/2]`, called through `aten._weight_int4pack_mm`.
-- Edge still uses GGUF `Q4_K` weights. On SM90 the large projections now dequantize and use cuBLAS, which is faster than GGML MMQ for H3's large-column shapes, but still not as specialized as a resident prepacked int4 Tensor Core layout.
-- Remaining layout hotspots are mostly attention layout/rope materialization (`[96,56,seq]`, `[128,seq,56]`, `[32,seq,56]`) and the second MLP half materialization (`[7168,seq]`). A larger next step would be an H3-specific fused QKV/RoPE/attention pack path, similar in spirit to the existing MMDiT attention pair-pack helpers.
-
-### 2026-08-07 DiT layout optimization checkpoints and quality guardrails
-
-Current H3 DiT optimization changes are intentionally split into independently-disableable checkpoints so any quality regression can be bisected quickly:
-
-| # | Area | Code path | Default | Disable switch | Quality risk |
-|---|---|---|---|---|---|
-| 1 | SM90 large `Q4_K` GEMM routing | GGML CUDA `Q4_K` uses dequantize + cuBLAS for large H3 matrices instead of MMQ | Off; experimental opt-in | enable with `GGML_CUDA_SM90_Q4K_CUBLAS=1` | High: caused all-black 124-frame H3 output on the FL2VA quality probe |
-| 2 | H3 MLP SwiGLU materialization | `fc2(ggml_swiglu(fc1(x)))` instead of chunk + silu + mul | On | `ED_MINIMAX_H3_DISABLE_SWIGLU_FUSION=1` | Low/medium: same formula, but fused kernel/order can differ slightly |
-| 3 | H3 QKV split materialization | Q/K/V are `ggml_view_4d` views into `qkv_proj` output instead of three `ggml_cont` chunks | On | `ED_MINIMAX_H3_DISABLE_QKV_VIEW=1` | Low: layout-only view rewrite, intended mathematically identical |
-| 4 | H3 partial-RoPE slice materialization | RoPE rotated prefix and unrotated tail use non-contiguous views instead of eager slice copies | On | `ED_MINIMAX_H3_DISABLE_ROPE_SLICE_VIEW=1` | Low: layout-only view rewrite; custom RoPE kernel reads strides |
-| 5 | H3 modulation/segment materialization | segment/modulation slices and chunks use views instead of eager copies | On | `ED_MINIMAX_H3_DISABLE_SEGMENT_VIEW=1` | Low: layout-only view rewrite |
-| 6 | H3 MLP Tensor Core experiment | allow MLP `fc1/fc2` to avoid `force_prec_f32` and use fp16 Tensor Core cuBLAS | Off | enable with `ED_MINIMAX_H3_MLP_FP16_CUBLAS=1` | High/experimental: faster but PSNR smoke checks dropped to `36-37dB` |
-
-Performance checkpoints on the 56-frame / 5-step FL2VA smoke case (`864x480`, `cfg=1`, `steps=5`, 4 actual DiT calls):
-
-| Checkpoint | Diffusion time | DiT graph layout time | Notes |
-|---|---:|---:|---|
-| SM90 cuBLAS + SwiGLU baseline | `6.730s` | `1.311s` total previously; DiT graph layout around `330ms`/call group in older op profile | Before H3-specific view rewrites |
-| + QKV view | `6.017s` unprofiled / `6.402s` profiled | `236.151ms` | Removes the former `~91ms` qkv chunk copy group |
-| + RoPE slice view | `6.184s` profiled | `175.416ms` | Removes `~46ms` rotated-prefix slice copy group |
-| + Segment view | `5.777s` profiled | `128.197ms` | Removes many small segment/modulation copies and elementwise materializations |
-| Current default with bisection switches | `5.821s` unprofiled | Not re-profiled in this run | Build after adding switches; profile-free timing is comparable to `+ Segment view` |
-
-Quality guardrails:
-
-- The low-risk view rewrites should preserve mathematical values, but CUDA graph execution and video/audio encode paths are not bit-exact across repeated runs; do not rely on byte equality.
-- A quick PSNR check between `+ Segment view` and the current default rerun produced `average=39.775dB`, `min=33.590dB`, `max=50.368dB` for 56 frames, so this smoke check did not show a catastrophic visual drift, but it is not a substitute for visual inspection.
-- If a quality regression appears, first ensure `GGML_CUDA_SM90_Q4K_CUBLAS` is not set to `1`, then try `ED_MINIMAX_H3_DISABLE_SWIGLU_FUSION=1`, then the three low-risk view switches one by one.
-- For release-quality validation, run at least one 124-frame task against the pre-optimization baseline and Diffusers/TorchAO with the same prompt, seed, frames, scheduler semantics, `cfg=1`, VAE tiling off, and one DiT forward per scheduler step.
-
-### 2026-08-07 Q4_K GEMM and attention follow-up
-
-Internal profiling of the rejected SM90-cuBLAS path showed the post-layout bottleneck was no longer GGML MMQ. For the 56-frame / 5-step FL2VA smoke case, that experimental DiT graph time was dominated by cuBLAS-backed large `Q4_K` GEMMs plus cuDNN SDPA:
-
-| Run | Diffusion | DiT graph GEMM | DiT graph attention | DiT graph layout | Artifact |
-|---|---:|---:|---:|---:|---|
-| Current default + internal profile | `5.825s` | `793.597ms` | `394.973ms` | `127.410ms` | `outputs/minimax-h3/perf-dit-current-internal-56f5s-2026-08-07/run.log` |
-| MLP Tensor Core opt-in | `5.184s` | `638.170ms` | `407.586ms` | `122.620ms` | `outputs/minimax-h3/perf-dit-mlp-fp16-cublas-56f5s-2026-08-07/run.log` |
-| MLP Tensor Core + forced f32 dst | `4.859s` | large `Q4_K` GEMMs down to `191.689/145.587/109.936/56.921ms` groups | not separately op-profiled | not separately op-profiled | `outputs/minimax-h3/perf-dit-mlp-fp16-cublas-f32dst-56f5s-2026-08-07/run.log` |
-
-Key finding for the rejected experimental path:
-
-- The old statement "Q4_K MMQ is the main bottleneck" was outdated only while the SM90 routing experiment was enabled. Because that path caused black 124-frame output, current quality-safe default is back to MMQ for large `Q4_K`; MMQ is again the principal safe-path DiT bottleneck.
-- The largest MLP matrices were intentionally constructed with `force_prec_f32=true`, so even with quantized weights they take the f32 SGEMM branch. Internal profile examples: `m=28672,n=7919,k=5376` spent `297.116ms` in `f32/sgemm`, and `m=5376,n=7919,k=14336` spent `146.245ms` in `f32/sgemm` over 50 calls.
-- Enabling the experimental `ED_MINIMAX_H3_MLP_FP16_CUBLAS=1` switches those MLP projections to fp16 Tensor Core cuBLAS. It improves smoke diffusion from `5.825s` to `5.184s`, but PSNR vs current default is only `average=37.029dB`, `min=30.218dB`; with `GGML_CUDA_FORCE_CUBLAS_COMPUTE_32F=1`, speed improves further to `4.859s`, but PSNR drops to `average=36.214dB`, `min=30.106dB`.
-- Because of that quality risk, `ED_MINIMAX_H3_MLP_FP16_CUBLAS=1` remains opt-in and should not be enabled by default without visual/full-length validation against Diffusers and the previous edge baseline.
-
-Attention finding:
-
-| Run | Diffusion | DiT graph attention | Artifact |
-|---|---:|---:|---|
-| cuDNN SDPA enabled | `5.783s` | `395.983ms` | `outputs/minimax-h3/perf-dit-attn-default-56f5s-2026-08-07/run.log` |
-| cuDNN SDPA disabled | `10.922s` | `1442.747ms` | `outputs/minimax-h3/perf-dit-attn-nocudnn-56f5s-2026-08-07/run.log` |
-
-- H3 is already using the cuDNN SDPA path for long attention. Disabling it roughly doubles diffusion time on the smoke case, so keeping cuDNN SDPA enabled is mandatory for H200/Hopper performance.
-- The remaining attention-adjacent layout hotspot is mostly output layout materialization before `out_proj` (`CONT [128,7919,56,1]`, about `30-33ms` per profiled DiT graph group). Removing it safely likely needs a fused attention-output-projection layout or an out-projection matmul variant that consumes the attention output layout directly.
-
-TorchAO/fbgemm comparison update:
-
-- Diffusers TorchAO `Int4WeightOnlyConfig` keeps weights in a resident Tensor Core tiled layout and calls `aten._weight_int4pack_mm`; edge GGUF `Q4_K` remains a GGUF block layout and must either use MMQ or dequantize/convert into cuBLAS-compatible fp16/f32 buffers.
-- The current fastest edge opt-in path still pays `src0_to_f16`, `src1_to_f16`, and sometimes `dst_to_f32`, while TorchAO/fbgemm avoids repeated GGUF block unpacking by construction. Matching that class of performance likely requires a resident prepacked H3 weight layout or a dedicated Q4_K Tensor Core kernel, not just more graph-level layout cleanup.
-
-### 2026-08-07 124-frame full baseline after view optimizations
-
-A full 124-frame FL2VA run was executed after the low-risk view optimizations, with MLP Tensor Core experiment **disabled**. This run used the now-rejected SM90 large-`Q4_K` cuBLAS route and produced an all-black MP4, so the timing is **not quality-valid**:
-
-| Framework/path | End-to-end / total | DiT / transformer | Calls | Notes | Artifact |
-|---|---:|---:|---:|---|---|
-| Edge rejected SM90 cuBLAS default | `79.780s` profiled total, `87.878s` wall | `54.912s` | `19` | all-black output; invalid quality benchmark | `outputs/minimax-h3/perf-dit-current-default-480p124-cfg1-steps20-2026-08-07/run.log` |
-| Edge previous SM90 cuBLAS + SwiGLU | `86.592s` total | `62.061s` | `19` | all-black output; invalid quality benchmark | `outputs/minimax-h3/perf-dit-sm90-q4-cublas-swiglu-480p124-cfg1-steps20-2026-08-07/run.log` |
-| Diffusers TorchAO int4 resident | `104.725s` end-to-end, `62.748s` generation CUDA | `56.724s` | `19` | TorchAO 4-bit transformer + text encoder, VAE/audio VAE not quantized | `outputs/minimax-h3/diffusers-fl2va-480p124-int4-resident-profile3-gpu0/final.json` |
-
-The rejected SM90-cuBLAS edge DiT timing (`54.912s`) must not be compared as a valid result against Diffusers because the output is black. The comparison remains useful only as a performance diagnostic:
-
-- Diffusers timing is official PyTorch/TorchAO path with different kernel/layout/numerics and includes its own surrounding scheduler/pipeline behavior.
-- Edge output MP4 in this run is not valid for visual quality because decoded sample frames had mean/std `0/0`.
-- The remaining performance work should focus on either preserving quality while reducing MLP cuBLAS precision overhead, or implementing a resident prepacked int4/Q4 layout to avoid repeated GGUF block conversion. The fp16 MLP Tensor Core experiment is fast but currently too risky for default quality.
-
-### 2026-08-07 MLP Tensor Core quality check on real-world FL2VA inputs
-
-The 124-frame FL2VA keyframe benchmark was visually uninformative: decoded frames were identical and near-static, so it could not validate MLP Tensor Core quality. A second 56-frame FL2VA check used high-variance real-world frames from `outputs/minimax-h3/ref2va-realworld-full-benchmark-2026-08-07/inputs/video-frames/001.png` and `056.png`.
-
-| Path | Diffusion | Total | Artifact |
-|---|---:|---:|---|
-| Current default | `5.832s` | `14.499s` | `outputs/minimax-h3/perf-quality-fl2va-realworld-current-vs-mlp-56f5s-2026-08-07/current/final.mp4` |
-| `ED_MINIMAX_H3_MLP_FP16_CUBLAS=1` | `5.226s` | `14.040s` | `outputs/minimax-h3/perf-quality-fl2va-realworld-current-vs-mlp-56f5s-2026-08-07/mlp/final.mp4` |
-
-Quality metric: `ffmpeg` PSNR current-vs-MLP is `average=11.195dB`, `min=10.582dB`, `max=12.735dB`, with visual contact sheet at `outputs/minimax-h3/perf-quality-fl2va-realworld-current-vs-mlp-56f5s-2026-08-07/summary/contact_current_vs_mlp.jpg`.
-
-Conclusion: keep `ED_MINIMAX_H3_MLP_FP16_CUBLAS=1` strictly opt-in. It is a useful performance experiment, but it changes generation materially on realistic inputs and should not be enabled by default.
-
-### 2026-08-07 black-frame regression fix
-
-The user-reported all-black output was reproduced on the 124-frame FL2VA keyframe task. The root cause was the experimental SM90 large-`Q4_K` cuBLAS routing being enabled by default.
-
-Repro and bisection artifacts:
-
-| Path | MP4 size | Sample frame brightness | Artifact |
-|---|---:|---:|---|
-| Rejected default with SM90 cuBLAS | `90,514` bytes | all sampled frames mean/std `0.0/0.0` | `outputs/minimax-h3/black-regression-124-bisect-2026-08-07/default/final.mp4` |
-| Same build with `GGML_CUDA_SM90_Q4K_CUBLAS=0` | `4,199,541` bytes | means `115.12`, `119.23`, `135.72`, `154.29`, `166.02`; std around `52-55` | `outputs/minimax-h3/black-regression-124-bisect-2026-08-07/no_sm90_cublas/final.mp4` |
-| Fixed current default after making SM90 cuBLAS opt-in | `4,199,541` bytes | same non-black sample stats as the disabled run | `outputs/minimax-h3/quality-fix-sm90-q4k-default-mmq-124f-2026-08-07/final.mp4` |
-
-Current code status:
-
-- `third_party/ggml/src/ggml-cuda/mmq.cu` keeps MMQ as the default for SM90 `Q4_K`; the cuBLAS route now requires explicit `GGML_CUDA_SM90_Q4K_CUBLAS=1`.
-- The opt-in path is retained only for future diagnosis/performance work and must not be used for quality or benchmark claims until the black-frame cause is fixed.
-- Contact sheet for the fixed default: `outputs/minimax-h3/quality-fix-sm90-q4k-default-mmq-124f-2026-08-07/contact_sheet.jpg`.
-
-### 2026-08-07 safe SM90 Q4_K cuBLAS partial re-enable
-
-The all-or-nothing SM90 `Q4_K` cuBLAS route was too broad: it made the 124-frame FL2VA output black. A shape bisection showed the long-sequence H3 `fc2` projection is the unsafe part, while the long-sequence QKV and `fc1` projections remain visually non-black on the same probe.
-
-Current switch behavior:
-
-- `GGML_CUDA_SM90_Q4K_CUBLAS=1` enables only the validated H3 shapes: mid-sequence `n=7919` QKV/FC1 shapes plus long-sequence `n>=16000` QKV and FC1 shapes.
-- Long-sequence FC2 (`m=5376`, `k=14336` or `7168`, `n>=16000`) remains on MMQ by default because it reproduced the all-black output.
-- `GGML_CUDA_SM90_Q4K_CUBLAS_LONG_FC2=1` exists only as an explicit unsafe diagnostic switch; do not use it for quality benchmarks or user-facing runs.
-
-124-frame, 5-step FL2VA quality/speed bisection (`864x480`, `cfg=1`, seed `42`, 4 DiT calls):
-
-| Variant | Diffusion | Output | Artifact |
-|---|---:|---|---|
-| MMQ quality-safe baseline | `21.799s` | non-black | `outputs/minimax-h3/quality-speed-q4k-long-shape-bisect-124f5s-2026-08-07/mid_only/final.mp4` |
-| Long QKV only | `19.069s` | non-black | `outputs/minimax-h3/quality-speed-q4k-long-shape-bisect-124f5s-2026-08-07/long_qkv/final.mp4` |
-| Long FC1 only | `19.444s` | non-black | `outputs/minimax-h3/quality-speed-q4k-long-shape-bisect-124f5s-2026-08-07/long_fc1/final.mp4` |
-| Long FC2 only | `19.019s` | all-black | `outputs/minimax-h3/quality-speed-q4k-long-shape-bisect-124f5s-2026-08-07/long_fc2/final.mp4` |
-| Safe QKV+FC1 | `16.893s` | non-black | `outputs/minimax-h3/quality-speed-q4k-safe-default-124f5s-2026-08-07/final.mp4` |
-
-The safe partial route recovers most of the speedup without reproducing black frames on this probe: `21.799s -> 16.893s` diffusion, about `22.5%` faster for the 124-frame/5-step task. The fixed contact sheet is at `outputs/minimax-h3/quality-speed-q4k-safe-default-124f5s-2026-08-07/contact_sheet.jpg`.
-
-Important quality caveat: this is a non-black and visually sane validation, not a proof of exact equivalence. Before making this path a default user-facing optimization, run the full 20-step task and compare against the MMQ baseline and Diffusers with the same seed/prompt/input.
-
-### 2026-08-07 FC2 cuBLAS quality fix
-
-FC2 meaning: in MiniMax-H3 each Transformer MLP uses `fc1 -> SwiGLU -> fc2`. `fc1` expands hidden features from `5376` to the gated FFN width (`28672`, two `14336` halves), and `fc2` projects the SwiGLU result back from FFN width to hidden size (`5376`). It is a major DiT GEMM hotspot.
-
-Root cause of the FC2 black-frame regression:
-
-- Routing long-sequence H3 FC2 `Q4_K` weights through cuBLAS with the default Hopper fp16 accumulation/output path caused all-black 124-frame output.
-- Running the same FC2 cuBLAS route with `GGML_CUDA_FORCE_CUBLAS_COMPUTE_32F=1` fixed the black output, proving the problem is the fp16 cuBLAS compute/output mode for this FC2 shape, not cuBLAS routing in general.
-- The code now forces f32 cuBLAS compute/destination only for the H3 SM90 long-sequence FC2 shape when `GGML_CUDA_SM90_Q4K_CUBLAS=1` is enabled. This keeps the QKV/FC1 fast path and makes FC2 usable without requiring the global `GGML_CUDA_FORCE_CUBLAS_COMPUTE_32F` environment variable.
-
-Current switch behavior after the fix:
-
-- `GGML_CUDA_SM90_Q4K_CUBLAS=1` enables validated H3 QKV, FC1, and FC2 `Q4_K` cuBLAS routes on SM90/Hopper.
-- Long FC2 automatically uses f32 cuBLAS compute/output to preserve quality.
-- `GGML_CUDA_SM90_Q4K_CUBLAS_DISABLE_LONG_FC2=1` disables only the long FC2 cuBLAS route for rollback/bisection.
-
-124-frame, 5-step FL2VA timing summary (`864x480`, `cfg=1`, seed `42`, 4 DiT calls):
-
-| Variant | Diffusion | Output | Artifact |
-|---|---:|---|---|
-| MMQ quality-safe baseline | `21.799s` | non-black | `outputs/minimax-h3/quality-speed-q4k-long-shape-bisect-124f5s-2026-08-07/mid_only/final.mp4` |
-| Safe QKV+FC1, FC2 on MMQ | `16.893s` | non-black | `outputs/minimax-h3/quality-speed-q4k-safe-default-124f5s-2026-08-07/final.mp4` |
-| QKV+FC1+FC2 with global f32 cuBLAS compute | `13.848s` | non-black | `outputs/minimax-h3/quality-speed-q4k-long-fc2-f32compute-124f5s-2026-08-07/final.mp4` |
-| QKV+FC1+FC2 with code-level FC2 f32 fix | `13.185s` to `15.095s` observed | non-black | `outputs/minimax-h3/quality-speed-q4k-fc2-f32fix-124f5s-2026-08-07/final.mp4`, `outputs/minimax-h3/quality-speed-q4k-fc2-default-f32fix-124f5s-2026-08-07/final.mp4` |
-
-Net effect: compared with the MMQ baseline, using FC2 after the f32 compute fix improves this short 124-frame DiT probe by roughly `31-40%` (`21.799s -> 15.095s` best conservative repeat, or `13.185s` in the faster repeat) while avoiding the previous all-black failure.
-
-Quality caveat: current validation proves the FC2 path no longer collapses to black on the 124-frame/5-step probe. It still needs a full 20-step visual/metric comparison before treating it as release-quality default.
-
-### 2026-08-07 full 20-step FC2 f32-fix validation
-
-A full 124-frame, 20-step FL2VA task was rerun with the current FC2 f32 cuBLAS fix enabled through `GGML_CUDA_SM90_Q4K_CUBLAS=1`.
-
-Configuration:
-
-- `--video-frames 124`, `--steps 20`, `--cfg-scale 1`, `--seed 42`
-- `864x480`, `24fps`, VAE tiling off, `--diffusion-fa`
-- First/end frame FL2VA prompt: `Create a smooth cinematic transition between the supplied first and last frame, preserving the subject, lighting, and composition with natural coherent motion and synchronized ambient audio.`
-
-Result:
-
-| Metric | Value |
-|---|---:|
-| Total generation | `85.129s` |
-| DiT diffusion | `62.367s` |
-| DiT calls | `19` |
-| Decode | `21.451s` |
-| Wall time | `94.077s` |
-
-Quality sanity check:
-
-- Output MP4: `outputs/minimax-h3/quality-speed-q4k-fc2-f32fix-124f20s-2026-08-07/final.mp4`
-- Contact sheet: `outputs/minimax-h3/quality-speed-q4k-fc2-f32fix-124f20s-2026-08-07/contact_sheet.jpg`
-- Sampled frame means: `116.31`, `115.57`, `134.97`, `155.41`, `166.60`
-- Sampled frame stddevs: `54.66`, `56.61`, `55.93`, `57.80`, `52.85`
-
-Conclusion: the full 20-step run is not black and visually sane on the contact sheet. The FC2 f32 cuBLAS fix keeps the long-sequence FC2 speed path usable for this probe. A broader quality comparison against MMQ baseline and Diffusers is still needed before treating this as final release-quality parity.
-
-### 2026-08-07 committed state and Diffusers gap
-
-Committed locally after the FC2 f32-fix validation:
-
-- Main repository commit: `a761c7c Optimize MiniMax H3 CUDA inference`
-- GGML submodule commit: `b9882160 Optimize H3 Q4_K CUDA routing`
-
-Current closest same-task timing comparison on the 124-frame FL2VA benchmark (`864x480`, `steps=20`, actual 19 DiT/transformer forwards, `cfg=1`, seed `42`):
-
-| Framework/path | Transformer/DiT time | Calls | Per-call | Notes |
-|---|---:|---:|---:|---|
-| Diffusers TorchAO int4 resident | `56.724s` | `19` | `2.985s` | `outputs/minimax-h3/diffusers-fl2va-480p124-int4-resident-profile3-gpu0/final.json` |
-| edge.cpp Q4_K cuBLAS + FC2 f32-fix | `62.367s` | `19` | `3.282s` | `outputs/minimax-h3/quality-speed-q4k-fc2-f32fix-124f20s-2026-08-07/run.log` |
-
-Current gap: edge DiT is `5.643s` slower over 19 calls, or about `9.95%` slower than Diffusers transformer time. Per model call the gap is about `0.297s`.
-
-Important apples-to-apples caveat: the runs match the high-level task, resolution, frames, steps, seed, and one-forward CFG-distilled setting. They still do not have identical quantization kernels/layouts: edge uses GGUF `Q4_K_M` with selective cuBLAS fallback and FC2 f32 compute; Diffusers uses TorchAO/fbgemm int4 resident packed TensorCore layout. Therefore the remaining gap is best interpreted as backend/kernel/layout overhead, not model semantics alone.
-
-Current short op-profile after FC2 f32-fix (`56` frames, `5` steps, 4 DiT calls):
-
-- Artifact: `outputs/minimax-h3/perf-op-profile-q4k-fc2-f32fix-56f5s-2026-08-07/run.log`
-- Diffusion time: `6.666s` for 4 calls.
-- Main DiT graphs show GEMM still dominant: around `990-1003ms` GEMM per graph group, followed by attention (`155-362ms`), elementwise (`~152ms`), and layout (`~122ms`) on the main transformer graphs.
-- Full decode graph remains a separate non-DiT cost and should not be mixed into DiT-vs-Diffusers transformer comparisons.
-
-Next optimization candidates from this profile:
-
-1. Reduce remaining H3 DiT elementwise/layout overhead without changing math order: view/materialization cleanup and possibly fusing strictly layout-only paths.
-2. Inspect remaining GEMM internals, especially repeated activation conversion (`src1_to_f16`) and fp16 destination conversion (`dst_to_f32`) in cuBLAS fallback. TorchAO's advantage is still its resident packed layout avoiding repeated GGUF dequant/activation conversion in hot paths.
-3. Avoid globally forcing f32 compute except for FC2 long-sequence shape; the quality fix is intentionally shape-scoped.
-
-### 2026-08-07 FC1 fp16-only experiment
-
-A new split switch was added for diagnosis:
-
-- `ED_MINIMAX_H3_FC1_FP16_CUBLAS=1` enables fp16 Tensor Core cuBLAS for H3 MLP `fc1` only.
-- `ED_MINIMAX_H3_FC2_FP16_CUBLAS=1` enables the analogous path for `fc2` only.
-- `ED_MINIMAX_H3_MLP_FP16_CUBLAS=1` still enables both and remains experimental.
-
-56-frame, 5-step FL2VA probe with `GGML_CUDA_SM90_Q4K_CUBLAS=1`:
-
-| Variant | Diffusion | Output | Artifact |
-|---|---:|---|---|
-| Baseline FC1 f32 path | `6.853s` | non-black | `outputs/minimax-h3/perf-quality-fc1-fp16-only-56f5s-2026-08-07/baseline/final.mp4` |
-| `ED_MINIMAX_H3_FC1_FP16_CUBLAS=1` | `6.693s` | non-black but diverges | `outputs/minimax-h3/perf-quality-fc1-fp16-only-56f5s-2026-08-07/fc1_fp16/final.mp4` |
-
-Frame PSNR baseline-vs-FC1-fp16 over 56 frames: min `25.034dB`, average `33.162dB`, max `44.824dB`.
-
-Conclusion: FC1 fp16-only is not suitable as a default quality-preserving optimization. It saves only about `2.3%` diffusion time on this probe while causing visible numerical divergence. Keep it opt-in only.
-
-### 2026-08-07 FC1 fp16 with f32 compute experiment
-
-To test whether FC1 quality loss came only from fp16 accumulation/output, FC1 was rerun with `ED_MINIMAX_H3_FC1_FP16_CUBLAS=1` plus global `GGML_CUDA_FORCE_CUBLAS_COMPUTE_32F=1` on the same 56-frame, 5-step FL2VA probe.
-
-| Variant | Diffusion | Artifact |
-|---|---:|---|
-| Baseline FC1 f32 path | `6.821s` | `outputs/minimax-h3/perf-quality-fc1-fp16-f32compute-56f5s-2026-08-07/baseline/final.mp4` |
-| FC1 fp16 inputs + f32 cuBLAS compute | `6.356s` | `outputs/minimax-h3/perf-quality-fc1-fp16-f32compute-56f5s-2026-08-07/fc1_f32compute/final.mp4` |
-
-Frame PSNR baseline-vs-FC1-fp16-f32compute over 56 frames: min `24.403dB`, average `31.772dB`, max `44.441dB`.
-
-Conclusion: FC1 divergence is not fixed by f32 accumulation alone. The lossy part is dequantizing the `Q4_K` FC1 weights and/or activations into fp16 for Tensor Core GEMM. FC1 fp16 should remain diagnostic-only; keep the quality-safe FC1 path on f32 SGEMM unless a resident int4 kernel/layout is implemented.
-
-### 2026-08-07 RoPE tail-view experiment
-
-A local H3 partial-RoPE experiment added `ED_MINIMAX_H3_ROPE_TAIL_VIEW=1`, which keeps the unrotated tail dimensions as a stride view instead of materializing the `[32, seq, heads]` tail before concatenating it with the rotated prefix.
-
-56-frame, 5-step FL2VA probe with `GGML_CUDA_SM90_Q4K_CUBLAS=1`:
-
-| Variant | Diffusion | Main graph tail-cont cost | Artifact |
-|---|---:|---:|---|
-| Baseline | `6.748s` | `62.469ms` over 4 DiT calls | `outputs/minimax-h3/perf-quality-rope-tail-view-56f5s-2026-08-07/baseline/final.mp4` |
-| `ED_MINIMAX_H3_ROPE_TAIL_VIEW=1` | `6.666s` | eliminated from top nodes | `outputs/minimax-h3/perf-quality-rope-tail-view-56f5s-2026-08-07/tail_view/final.mp4` |
-
-Frame PSNR baseline-vs-tail-view over 56 frames: min `31.263dB`, average `36.053dB`, max `45.292dB`.
-
-Conclusion: the layout optimization does remove the targeted tail materialization, but the end-to-end diffusion improvement is small on this probe and the output is not pixel-equivalent. Keep `ED_MINIMAX_H3_ROPE_TAIL_VIEW=1` opt-in only; it is not enabled by default.
-
-### 2026-08-07 SageAttention CUDA dispatch validation
-
-The first SageAttention comparison was not a valid CUDA-kernel measurement: the build cache had `ED_ENABLE_CUDA_SAGE_ATTN=OFF`, so `ED_SAGE_ATTN=1` only changed graph construction and the CUDA backend fell through to the normal attention path. The CUDA build was reconfigured with `-DED_ENABLE_CUDA_SAGE_ATTN=ON`, then rerun with the same one-GPU FL2VA probe (`864x480`, `56` frames, `5` steps, `cfg=1`, seed `42`, VAE tiling off, and `GGML_CUDA_SM90_Q4K_CUBLAS=1`).
-
-| Variant | DiT diffusion | Result | Artifact |
-|---|---:|---|---|
-| Normal attention | `6.829s` | baseline | `outputs/minimax-h3/sage-real-kernel-baseline-56f5s-2026-08-07/final.mp4` |
-| `ED_SAGE_ATTN=1` | `6.811s` | real fused CUDA dispatch, rejected | `outputs/minimax-h3/sage-real-kernel-56f5s-2026-08-07/final.mp4` |
-
-The Sage log contains `1080` `dispatch: running fused INT8-QK+F16-PV kernel` lines, proving that the custom CUDA kernel ran. Its target shape was `d_head=64`, `L_q=L_k=1797`, and `HN=32`; this is a VAE attention shape, not the H3 DiT self-attention shape. The measured DiT difference is only `18ms` over four calls (within normal run variation), while the generated-video comparison gives min/average/max PSNR `24.906/31.876/44.398dB`. Sampled optimized-frame mean/std values remain non-black (`114.95/54.04` through `166.02/52.02`), but the numerical divergence is too large for a default quality-safe optimization.
-
-Conclusion: keep `ED_SAGE_ATTN` runtime-disabled by default. Do not treat SageAttention as a MiniMax-H3 DiT optimization unless it is redesigned for the DiT's `d=128`, `h=56`, `seq=7919` attention shape and passes the same quality gate. Contact sheet and machine-readable quality result: `outputs/minimax-h3/sage-real-kernel-56f5s-2026-08-07/contact_sheet.jpg` and `outputs/minimax-h3/sage-real-kernel-56f5s-2026-08-07/quality.txt`.
-
-### 2026-08-07 cuDNN SDPA H3 dispatch confirmation
-
-With `ED_PROFILE_CUDNN_SDPA=1`, a short one-call H3 probe confirms that the existing cuDNN SDPA backend already handles the DiT's long self-attention:
-
-```text
-b=1, h=56, sq=7919, sk=7919, d=128, scale=11.3137, dst_type=f32
-```
-
-At 16 accumulated calls the profile reported `46.847ms` execution, `1.698ms` Q conversion, and `2.286ms` output conversion, or roughly `2.93ms` execution per attention call. The much more numerous `d=64`, `sq=1797`, padded `sk=2048` VAE attention calls are intentionally rejected by the current padding-mask gate. Artifact: `outputs/minimax-h3/cudnn-sdpa-dispatch-probe-56f2s-2026-08-07/run.log`.
-
-Conclusion: H3 DiT already uses cuDNN SDPA; attention is not the remaining dominant gap to Diffusers. Further H3 work should prioritize Q4_K FC1 kernel/layout efficiency and only pursue attention changes after a profile shows a material regression there.
-
-### 2026-08-07 TF32 status and FC1 bottleneck check
-
-The dominant quality-safe FC1 route is still `Q4_K -> FP32` dequantization followed by FP32 `cublasSgemm` (`m=28672`, `n=7919`, `k=5376`). Its 56-frame operator profile gives about `5.83ms` per FC1 projection; dequantization is only about `0.37ms` per projection. Caching dequantized FP32 FC1 weights would consume substantial persistent VRAM while having an upper-bound benefit of only about 6% of FC1 time (and roughly 1% of whole DiT time), so it is not the next worthwhile change.
-
-An isolated one-call GPU diagnostic compared the default cuBLAS configuration with `NVIDIA_TF32_OVERRIDE=0`:
-
-| Variant | DiT diffusion | Interpretation |
-|---|---:|---|
-| Default | `2.391s` | Hopper TF32 Tensor Core path active |
-| TF32 explicitly disabled | `4.300s` | FP32 CUDA-core fallback, `~80%` slower |
-
-The CUDA backend sets `CUBLAS_TF32_TENSOR_OP_MATH` when it creates the cuBLAS handle, so the current quality-safe FC1 SGEMM is already using Tensor Cores. A cuBLASLt rewrite would need cached descriptors/algorithms and a demonstrated advantage over this already-TF32-accelerated route before it is worth adding another runtime switch.
-
-### 2026-08-07 cuBLASLt FC1 algorithm scan
-
-A standalone H200 GPU microbenchmark measured the exact FC1 SGEMM shape (`m=28672`, `n=7919`, `k=5376`, FP32 inputs/output, TF32 compute) without changing repository code. Current `cublasSgemm` measured `5.299ms`. A `128MiB`-workspace cuBLASLt scan returned eight algorithms; the fastest measured `5.294ms`, while the others ranged from `5.383ms` to `6.625ms`.
-
-Conclusion: there is no material cuBLASLt algorithm advantage for the current quality-safe FP32/TF32 FC1 path on H200. Do not add a descriptor cache or a runtime switch for this equivalent path. The remaining meaningful route to close the roughly 10% Diffusers gap is a resident packed int4 kernel/layout compatible with `Q4_K`, avoiding the FP32 SGEMM path itself; this is a larger backend project and must be separately quality-gated.
-
-### 2026-08-07 Torch int4 packed-kernel feasibility check
-
-The CUDA environment includes TorchAO/fbgemm SM90 int4 support. Its `aten._weight_int4pack_mm` accepts group size `32`, so the group granularity can in principle represent the GGUF Q4_K block's 32-value scale/min pairs. A real H3 FC1 shape probe (`M=7919`, `K=5376`, `N=28672`) completed successfully with BF16 activations and group size `32`, but measured `83.97ms` per matrix multiplication.
-
-That is far slower than edge.cpp's current quality-safe Q4_K-to-FP32 TF32 SGEMM path (`~5.8ms` FC1 projection). The generic Aten packed kernel therefore is not the kernel/layout used by the faster Diffusers H3 benchmark, or is not intended for this extreme H3 matrix aspect ratio. It must not be integrated into edge.cpp.
-
-The installed TorchAO CUTLASS int4 interfaces exposed in this environment are rowwise-scaled `s8s4/s4s4` paths rather than a direct reusable C++ library API for GGUF's asymmetric Q4_K blocks. A future high-value path needs either the exact TorchAO weight-only kernel/layout used by the Diffusers run or a purpose-built Hopper kernel; it cannot be obtained by calling the generic Aten int4-pack op.
-
-### 2026-08-07 TorchAO v2 rowwise kernel follow-up
-
-The preceding generic `aten._weight_int4pack_mm` result is not the operator used by the current Diffusers MiniMax-H3 TorchAO run. `Int4WeightOnlyConfig(group_size=128)` dispatches `fbgemm::bf16i4bf16_rowwise`, a CUTLASS SM90 Hopper Tensor Core kernel. A direct H200 probe at the exact H3 FC1 shape (`M=7919`, `K=5376`, `N=28672`) measured the following steady-state forward times:
-
-| Group size | Scale/zero dtype | Result | Minimum time |
-|---:|---|---|---:|
-| `32` | BF16 | CUTLASS `can_implement` rejects it | n/a |
-| `32` | FP32 | CUTLASS `can_implement` rejects it | n/a |
-| `64` | BF16 | supported | `3.396ms` |
-| `64` | FP32 | supported | `4.352ms` |
-| `128` | BF16 | supported | `3.756ms` |
-| `128` | FP32 | supported | `4.341ms` |
-
-This corrects the earlier interpretation: the official TorchAO path is genuinely much faster than the current Edge quality-safe FC1 (`Q4_K -> FP32 -> TF32 SGEMM`, approximately `5.3-5.8ms` per FC1), and it is the right performance comparison. It is not directly reusable for the existing GGUF weights. Q4_K has eight independent 32-value groups in every 256-value block, with exact decode `q * (d * scale) - (dmin * min)`. Since fbgemm stores signed INT4, its exact rowwise representation requires `group_size=32`, `q_signed=q-8`, `scale=d*scale`, and `zero_point=8*scale-dmin*min`; the stock Hopper kernel rejects that group size even when its scale/zero inputs remain FP32.
-
-Therefore the remaining roughly 10% end-to-end DiT gap is now attributable to a concrete format/kernel incompatibility, not to attention, cuBLAS algorithm selection, or a missed Tensor Core setting. A quality-safe improvement requires a dedicated SM90 mixed-dtype Q4_K kernel (or a modified CUTLASS/fbgemm mainloop that supports exact 32-value groups) plus resident packed Q4_K weights. Re-quantizing 32-value groups into the supported 64/128 format would change weights and is not an acceptable default optimization without a separate full-generation quality evaluation.
-
-### 2026-08-08 SM90 32-group source-level feasibility follow-up
-
-The `group_size=32` rejection is now traced to a specific fbgemm/CUTLASS mainloop restriction, not an undocumented Hopper limitation. In the installed `bf16i4bf16_rowwise` source, `TileShapeK` is `64` for BF16 mixed input. CUTLASS checks `group_size == K || group_size % TileShapeK == 0`; consequently stock `64/128` groups pass while exact Q4_K `32` groups fail.
-
-A throwaway, out-of-tree prototype changed only `TileShapeK` from `64` to `32`. It was compiled for `sm_90a` after first confirming that a plain `sm_90` target cannot issue Hopper GMMA instructions. The valid-target compilation then failed in the CUTLASS mixed-input mainloop with the deliberate assertion `K_BLOCK_MAX >= 4`. This is expected: a 32-value threadblock K tile contains only two BF16 GMMA K-blocks (`16` elements each), while the pipelined mainloop requires at least four for its prefetch/commit schedule.
-
-More importantly, the existing mainloop assumes only one scale/zero row per threadblock K tile. It calculates `reload_factor = ceil(group_size / TileShapeK)`, TMA-loads one scale/zero row for each tile, and `copy_tensors_MK` copies that metadata only when `k_block == 0`. Simply removing the divisibility assertion would therefore silently apply one 32-value Q4_K scale/min to the other 32 values in a 64-value tile; the source explicitly warns that relaxing the related scale-layout assertion without changing transaction accounting can hang.
-
-The correct implementation scope is now concrete:
-
-1. Preserve a practical K tile (`64` or preferably `128`) for Hopper GMMA occupancy.
-2. Extend the mixed-input scale shared-memory layout, TMA transaction bytes, and producer reload logic to load two/four scale-plus-zero rows per K tile.
-3. Select the correct 32-value row inside `dequantize_A_kblock` for each GMMA K-block, while retaining FP32 Q4_K-derived scale/zero values where numerical equivalence requires it.
-4. Add a resident Q4_K-to-rowwise packed-weight cache, including Q4_K's interleaved nibble reorder, so this conversion is not performed per DiT call.
-
-This is a real kernel/mainloop extension rather than a safe one-line fbgemm configuration change. No repository inference code was changed by the prototype. The prototype source/build output lives only under container `/tmp/q4k_g32_proto`; its failed build and the earlier `sm_90` invalid execution are diagnostic only and must not be used as performance or quality data.
-
-### 2026-08-08 Hopper W4A8 group-32 feasibility result
-
-CUTLASS has an upstream mixed-input W4A8 route that is materially closer to GGML MMQ than the Diffusers BF16×W4 route. The official CUTLASS `v3.5.0` Hopper mixed-dtype example was built out of tree for `sm_90a`, then changed exactly as documented by CUTLASS maintainers in issue `#1332`: INT8 activation, INT4 weight, `TileShapeK=32`, and INT32 accumulation/output. It passed the example reference check both on a small shape and on the exact H3 FC1 shape with `group_size=32`:
-
-| Shape (`M x N x K`) | Group size | Result | Average time |
-|---|---:|---|---:|
-| `128 x 512 x 1024` | `32` | passed | `0.0173ms` |
-| `7919 x 28672 x 5376` | `32` | passed | `3.388ms` |
-
-This is important evidence that H200 Hopper hardware and CUTLASS's W4A8 GMMA path can efficiently execute a 32-value group. The stock BF16×W4 fbgemm dispatch rejects 32 only because its BF16 tile-K is 64; its 32-tile experiment is not evidence against the W4A8 route.
-
-It still cannot be substituted for GGML Q4_K MMQ unchanged. The mixed-input collective accepts scale/zero metadata for only the narrow INT4 operand. GGML MMQ has two independently quantized operands for Q4_K projections:
-
-```text
-weight[g, n, k]     = q4[g, n, k] * weight_scale[n, k_group]
-                    - weight_min[n, k_group]
-activation[m, k]    = q8[m, k] * activation_scale[m, k_group]
-```
-
-The product needs both per-output-channel Q4_K scale/min and per-token Q8_1 scale. The existing W4A8 collective can apply the former before INT8 MMA, but has no second activation-side 32-value scale input. Pre-multiplying them is impossible because the required scale product varies across both `m` and `n`; ignoring the activation scale would change the model result. Therefore this benchmark proves a promising kernel foundation and performance target, not a quality-safe drop-in replacement.
-
-The next exact route is a dual-quantized W4A8 Hopper kernel: retain CUTLASS's group-32 W4A8 GMMA pipeline, add an activation `Q8_1` scale stream and accumulate the Q4_K min correction using the activation block sum (which GGML already stores). This directly mirrors GGML's Q4_K×Q8_1 algebra and avoids BF16 re-quantization. It needs an independent CUDA prototype plus numerical comparison against the existing MMQ output before any edge.cpp integration.
-
-### 2026-08-08 W4A8 group-32 semantic caveat
-
-The W4A8 `3.388ms` result is a hardware-throughput feasibility result only, not yet a numerically compatible Q4_K implementation. Reading the v3.5 collective shows that its scale/zero path upcasts narrow INT4 values to the scale type, applies `q * scale + zero`, **then converts the result to the MMA type**. In the maintained W4A8 configuration the MMA type is INT8, so group-scale values are rounded into INT8 before GMMA. Its reference path uses the same conversion and therefore correctly validates that specific integer GEMM, but does not validate the floating-point Q4_K decode used by Edge.
-
-For Q4_K, `d * scale_group` and `dmin * min_group` are FP16-derived floating values and the existing GGML MMQ accumulates their contribution in floating point. Feeding them through the stock W4A8 converter would change the decoded weight before the dot product. This is not acceptable for a default generation path, even though the raw `group=32` GMMA timing is attractive.
-
-The exact custom-kernel requirement is consequently narrower and stricter: use the W4A8 GMMA instruction only for the integer dot product, retain Q4_K and Q8_1 scales/min/sums in FP16/FP32 registers, and apply
-
-```text
-output += activation_scale * (weight_scale * dot_int8_int4 - weight_min * sum_int8)
-```
-
-in floating point for every 32-value group. That is closer to GGML's existing `vec_dot_q8_1_q8_1_mma` algebra than to stock CUTLASS's scale-and-convert collective. No quality claim or speed projection from the stock W4A8 scale path should be used until this exact post-MMA scaling prototype is measured.
-
-### 2026-08-08 actual H3 Q4_K repacking error check
-
-A read-only mmap sample of the actual `blocks.0.mlp.fc1.weight` H3 GGUF tensor (`256 x 5376` values) was decoded with the same Q4_K scale/min and nibble rules as GGML. It was then independently affine-requantized into ordinary unsigned int4 groups. This evaluates the *additional* distortion after the existing Q4_K quantization, not the original BF16-model quantization error.
-
-| Repacked affine group size | Additional weight RMSE | Maximum absolute error | Weight SNR |
-|---:|---:|---:|---:|
-| `32` | `0.00554` | `0.04049` | `27.60dB` |
-| `64` | `0.01098` | `0.04496` | `21.66dB` |
-| `128` | `0.01330` | `0.05068` | `19.99dB` |
-
-The actual sampled Q4_K decoded weights have RMS `0.13290` and range `[-1.0334, 0.9273]`. Even a fresh 32-value ordinary affine representation is not lossless because Q4_K's stored 6-bit superblock scale/min construction is different; the 64/128 representations accepted by stock fbgemm add materially more error.
-
-Conclusion: converting current H3 Q4_K weights into a TorchAO/fbgemm-compatible 64/128-group format is not a responsible default performance optimization. It can only be considered as an explicitly experimental, full-video quality-gated alternative. The quality-safe route remains an exact Q4_K×Q8_1 Hopper kernel with FP16/FP32 post-MMA scale/min handling.
-
-### 2026-08-08 signed-int4 mapping correction and TF32×INT4 check
-
-The fbgemm/CUTLASS `int4b_t` storage was probed directly. It is signed two's-complement INT4: nibble `0..7` decodes to `0..7`, while `8..15` decodes to `-8..-1`. Its affine operation is `signed_q * scale + zero_point` (the zero-point is added, not subtracted).
-
-The exact static Q4_K weight mapping is therefore:
-
-```text
-q_signed   = q4_unsigned - 8
-scale       = d * scale_group
-zero_point  = 8 * scale - dmin * min_group
-weight      = q_signed * scale + zero_point
-```
-
-A GPU probe using the supported fbgemm group-64 path confirmed this mapping; against a BF16-activation FP32 reference, the remaining output RMSE was `0.00858` and is attributable to fbgemm's BF16 output storage, rather than an affine-mapping error. The prior text that stated `zero=dmin*min` was incomplete because it omitted this signed-nibble offset; it is superseded by the formula above.
-
-A second out-of-tree prototype replaced fbgemm's BF16 activation/output types with F32 to look for a fused `TF32×INT4` analogue of the current quality-safe `Q4_K -> F32 -> cublasSgemm` path. It failed at CUTLASS mixed-input layout instantiation before launch. Searching SM90 GMMA definitions shows native integer S8/U8×S8/U8 operations and FP16/BF16/TF32 homogeneous operations, but no Hopper TF32×INT4 GMMA operation. This is a hardware instruction-set boundary rather than a missed cuBLAS setting.
-
-Consequences:
-
-- Stock BF16×INT4 fused kernels can represent Q4_K weights after signed-nibble packing, but necessarily convert the activation/weight computation to BF16 and produce BF16 output; this must remain opt-in until full video quality validation.
-- The current F32/TF32 cuBLAS route remains the quality-safe implementation because Hopper has no direct TF32×INT4 MMA to fuse exact F32 Q4_K decoding into that GEMM.
-- An exact fast path must instead retain the existing Q8_1 integer activation representation and implement Q4_K/Q8_1 scale/min/sum correction around Hopper integer GMMA, as described in the dual-quantized route.
-
-### 2026-08-08 TorchAO W4A8 and Marlin reuse audit
-
-Two additional TorchAO CUDA paths were audited to avoid overlooking an existing dual-scale implementation:
-
-1. `rowwise_scaled_linear_cutlass_s8s4` has an INT32 accumulator and a CUTLASS epilogue visitor that multiplies a per-token FP32 input scale and per-output-channel FP32 weight scale. Its public schema is `input_scale[M]`, `weight_scale[N]`. It has no K-group scale/min dimension, so it cannot express Q4_K's `weight_scale[K_group,N]` or `weight_min[K_group,N]`. The installed `torchao==0.15.0` wheel also omitted its CUDA implementation; its source is useful only as an epilogue-visitor reference.
-
-2. `marlin_qqq_gemm` accepts `s_tok[M]`, `s_ch[N]`, and `s_group[K/group,N]`, which initially appears closer. Its actual checks accept only `group_size=128`; its group dequantization is symmetric INT4 (`q-8`) with a scale only, no per-group zero/min. It uses Ampere-style `mma.m16n8k16` INT8 Tensor Core instructions, not Hopper GMMA. Like the CUTLASS W4A8 group-scale path, it folds the group scale into an integer operand before MMA, so it cannot preserve Q4_K's FP scale/min arithmetic. It is not a quality-safe reuse target.
-
-The exact Q4_K×Q8_1 path therefore has no available stock TorchAO/fbgemm/Marlin operator. It requires a dedicated kernel that uses S8×S8 GMMA to obtain a separate INT32 partial for each 32-value group, then applies the FP correction `activation_scale * (weight_scale * dot - weight_min * sum_q8)` before adding to the FP output accumulator. This is the remaining kernel-design task, not a dispatcher or layout flag.
-
-### 2026-08-08 mid-sequence FC2 TF32 routing experiment
-
-The existing SM90 Q4_K cuBLAS route already uses FP32 decode plus TF32 Tensor Cores for the H3 mid-sequence QKV and FC1 projections. The `n=7919` FC2 projections were intentionally left on exact GGML MMQ because the prior long-sequence FC2 route was quality-sensitive. A new **default-off** diagnostic switch was added:
-
-```text
-GGML_CUDA_SM90_Q4K_CUBLAS_MID_FC2=1
-```
-
-It routes only these two H3 Q4_K shapes through the existing FP32/TF32 cuBLAS path:
-
-```text
-m=5376, n=7919, k=14336
-m=5376, n=7919, k=7168
-```
-
-On the fixed-seed FL2VA probe (`864x480`, 56 frames, 5 steps, cfg=1, four DiT calls), the FC2 matmul timings and end-to-end DiT time improved materially:
-
-| Metric | Current quality-safe route | Mid-FC2 experiment |
-|---|---:|---:|
-| FC2 `k=14336` | MMQ `6.65ms` | FP32/TF32 cuBLAS `3.11ms` |
-| FC2 `k=7168` | MMQ `3.33ms` | FP32/TF32 cuBLAS `1.59ms` |
-| Four-call DiT diffusion | `6.666s` | `5.844s` |
-
-The experimental video is non-black and structurally coherent, but it does **not** satisfy the default quality gate. Decoded fixed-seed frames against the current MMQ-FC2 baseline had mean PSNR `32.70dB`, minimum `25.19dB` (first/middle/last: `44.74/33.72/40.37dB`). The contact comparison is `outputs/minimax-h3/exp-mid-fc2-f32-tf32-56f5s-2026-08-08/contact_sheet_compare.jpg`.
-
-Conclusion: retain the switch solely as a performance diagnostic. Diffusion amplifies the numerical difference between MMQ's exact Q4_K×Q8_1 accumulation and Q4_K-to-FP32 TF32 SGEMM even though both outputs look plausible. Do not enable it by default; the exact integer-GMMA Q4_K route remains the quality-preserving performance path.
-
-### 2026-08-08 mid-sequence FC2 full-task validation
-
-The mid-sequence FC2 experiment was validated on the full FL2VA comparison task, not only the 56-frame smoke task: `864x480`, `124` frames, `20` requested steps / `19` actual forwards, `cfg=1`, seed `42`, VAE tiling off, identical prompt and first/last frames.
-
-The matching Diffusers run was recovered from the **local** source tree shipped alongside the model, rather than downloading source code:
-
-```text
-PYTHONPATH=/models/MiniMax-H3-Diffusers/code/diffusers-main/src
-diffusers source revision: 53e5b00
-```
-
-This is the H3-capable `diffusers 0.40.0.dev0` source. The container-global PyPI package is `diffusers==0.39.0`, which does not contain `MiniMaxH3Transformer3DModel`; no model weight download is required to restore the benchmark environment.
-
-| Path | DiT / transformer time | Calls | Per-call | End-to-end / generation metric |
-|---|---:|---:|---:|---:|
-| Edge Q4_K quality-safe baseline | `62.367s` | `19` | `3.282s` | `85.129s` generation |
-| Edge Q4_K mid-FC2 TF32 experiment | `60.766s` | `19` | `3.198s` | `87.663s` generation |
-| Diffusers TorchAO int4 resident | `55.680s` | `19` | `2.930s` | `61.646s` generate CUDA / `102.121s` process end-to-end |
-
-The experiment improves Edge DiT by `1.601s` (`2.57%`) versus the quality-safe baseline, but remains `5.086s` (`9.14%`) slower than the restored Diffusers resident transformer benchmark. Its full-task decoded-frame comparison against the Edge MMQ-FC2 baseline measured mean PSNR `42.38dB`, minimum `40.69dB`; frames are visually coherent but not numerically equivalent. Artifacts:
-
-- `outputs/minimax-h3/exp-mid-fc2-f32-tf32-124f20s-2026-08-08/final.mp4`
-- `outputs/minimax-h3/exp-mid-fc2-f32-tf32-124f20s-2026-08-08/contact_sheet_compare.jpg`
-- `outputs/minimax-h3/diffusers-fl2va-480p124-int4-resident-profile4-gpu1-2026-08-08/final.json`
-
-Conclusion remains unchanged: the switch is a diagnostic only and must not become the default Q4_K route. It quantifies the maximum gain available from switching the remaining FC2 projections to dequantize-plus-TF32 SGEMM, leaving an exact Q4_K packed kernel as the only route to close the remaining quality-safe gap.
-
-### 2026-08-08 cuDNN audio VAE transposed-convolution path
-
-The MiniMax-H3 audio VAE's BigVGAN decoder uses seven repeated F32 `ConvTranspose1D` upsampling layers per audio stream. The previous CUDA implementation used one output element per thread and iterated over the input sequence and channels directly. This made audio decode a major end-to-end cost despite the DiT being relatively close to Diffusers.
-
-A guarded cuDNN backward-data-convolution route now maps the supported 1D transposed convolution form to NCHW 2D (`H=1`) and keeps the original CUDA kernel as the fallback. It only accepts contiguous F32 tensors with one group, zero padding, dilation one, and stride greater than one—the exact form used by H3's BigVGAN decoder.
-
-- Build integration: enabled whenever the existing `ED_ENABLE_CUDNN_SDPA` build option is enabled.
-- Runtime switch: `ED_CUDNN_CONV_TRANSPOSE_1D=1`.
-- Default: disabled; unset or `0` always uses the original CUDA kernel.
-- No new third-party dependency: uses the already-linked cuDNN runtime.
-
-Full fixed-seed FL2VA validation used `864x480`, `124` frames, `24fps`, `20` requested steps (`19` DiT forwards), `cfg=1`, seed `42`, VAE tiling off, `--diffusion-fa`, and the first/last images `assets/minimax-h3-ref2va/video-frames/001.png` and `056.png`. Prompt:
-
-```text
-Create a smooth cinematic transition between the supplied first and last frame, preserving the subject, lighting, and composition with natural coherent motion and synchronized ambient audio.
-```
-
-| Variant | Generation | Wall total | Video comparison | Audio comparison |
-|---|---:|---:|---|---|
-| Original CUDA transposed convolution | `85.974s` | `94.626s` | baseline | baseline |
-| cuDNN path (`ED_CUDNN_CONV_TRANSPOSE_1D=1`) | `78.063s` | `86.443s` | PSNR `inf` (pixel-identical decoded frames) | same `331,776` samples; PSNR `48.109dB`, correlation `0.999796` |
-
-This saves `7.911s` generation time (`9.20%`) without changing the generated video frames. The retained artifacts are:
-
-- `outputs/minimax-h3/audio-convt1d-baseline-124f20s-2026-08-08/final.mp4`
-- `outputs/minimax-h3/audio-convt1d-cudnn-124f20s-2026-08-08/final.mp4`
-- `outputs/minimax-h3/audio-convt1d-cudnn-124f20s-2026-08-08/quality/audio-comparison.json`
-- `outputs/minimax-h3/audio-convt1d-cudnn-124f20s-2026-08-08/quality/video-psnr-summary.log`
-
-### 2026-08-08 opt-in CUDA Graph capture
-
-The CUDA build previously compiled without CUDA Graph support, so repeated H3 video-VAE tile graphs (each `2491` graph nodes) were directly launched for every tile. CUDA Graph support is now compiled by default when `ED_ENABLE_CUDA_GRAPHS=ON`, but remains runtime-disabled unless explicitly requested:
-
-```bash
-ED_CUDA_GRAPHS=1 ed-cli ...
-```
-
-`GGML_CUDA_DISABLE_GRAPHS` remains an emergency override. The runtime gate is global because the backend captures compatible graph executions, not a model-specific arithmetic path. It does not alter weights, operators, numerical precision, or sampling.
-
-A full FL2VA comparison used the same configuration as the cuDNN audio-VAE validation: `864x480`, 124 frames, 24fps, 20 requested steps / 19 DiT forwards, cfg `1`, seed `42`, VAE tiling on, `--diffusion-fa`, and `ED_CUDNN_CONV_TRANSPOSE_1D=1` in both variants.
-
-| Variant | Generation | Wall total | Video | Audio |
-|---|---:|---:|---|---|
-| CUDA Graph runtime disabled | `78.063s` | `86.443s` | baseline | baseline |
-| `ED_CUDA_GRAPHS=1` | `77.881s` | `86.504s` | PSNR `inf` | exact waveform (PSNR `inf`) |
-
-The path is numerically exact on this task, but the end-to-end win is only `0.182s` (`0.23%`). It is retained as an independent opt-in scheduling control rather than enabled by default. The repeated VAE tile graph did capture and replay successfully; the limited end-to-end result means the primary remaining gap is compute, not launch overhead.
-
-Artifacts:
-
-- `outputs/minimax-h3/cuda-graphs-124f20s-2026-08-08/final.mp4`
-- `outputs/minimax-h3/cuda-graphs-124f20s-2026-08-08/quality/video-psnr-summary.log`
-- `outputs/minimax-h3/cuda-graphs-124f20s-2026-08-08/quality/audio-comparison.json`
-
-### 2026-08-08 opt-in H3 video output postprocess fast path
-
-MiniMax-H3 video decode returns a contiguous host `Tensor<float>` in `[width, height, frames, channels, batch]` storage order. The original final conversion loop used `Tensor::index(...)` for every output channel, constructing and bounds-checking an index vector per value. This is outside the VAE math but was a measurable end-to-end CPU postprocess cost at 480p.
-
-The guarded fast path reads the equivalent contiguous offset directly while retaining the existing float clamp and `round(... * 255)` conversion. It is disabled by default:
-
-```bash
-ED_MINIMAX_H3_FAST_VIDEO_POSTPROCESS=1 ed-cli ...
-```
-
-For debugging the direct offset can be checked against every original `Tensor::index(...)` lookup during a run:
-
-```bash
-ED_MINIMAX_H3_FAST_VIDEO_POSTPROCESS=1 \
-ED_MINIMAX_H3_VERIFY_FAST_VIDEO_POSTPROCESS=1 ed-cli ...
-```
-
-The verification run completed without an assertion, establishing that the two paths read identical source floats. The full FL2VA validation used the same fixed task as the current performance baseline: `864x480`, `124` frames, `24fps`, `20` requested steps (`19` DiT forwards), cfg `1`, seed `42`, first/last frames `001.png`/`056.png`, `--diffusion-fa`, `GGML_CUDA_SM90_Q4K_CUBLAS=1`, and `ED_CUDNN_CONV_TRANSPOSE_1D=1`.
-
-| Variant | Generation | DiT | Video VAE | Video conversion | Video quality | Audio quality |
-|---|---:|---:|---:|---:|---|---|
-| Original conversion | `77.629s` | `62.454s` | `10.886s` | `1.960s` | baseline | baseline |
-| Fast conversion | `78.417s` | `62.307s` | `12.683s` | `1.048s` | PSNR `inf` | PCM exact, PSNR `inf` |
-
-The VAE phase has normal run-to-run variation (the second run was about `1.8s` slower in VAE compute), so the isolated conversion measurement is the relevant result: `0.912s` saved for this full task (`46.5%` of conversion time). The decoded 124-frame videos are pixel-identical, and decoded audio contains `331,776` identical samples. This does not affect GPU memory or model arithmetic.
-
-Artifacts are intentionally local and ignored by Git:
-
-- `outputs/minimax-h3/fast-video-postprocess-full-124f20s-2026-08-08/baseline/final.mp4`
-- `outputs/minimax-h3/fast-video-postprocess-full-124f20s-2026-08-08/fast/final.mp4`
-- `outputs/minimax-h3/fast-video-postprocess-full-124f20s-2026-08-08/quality/video-psnr-summary.log`
-- `outputs/minimax-h3/fast-video-postprocess-full-124f20s-2026-08-08/quality/audio-comparison.json`
-
-### 2026-08-08 opt-in parallel H3 video output conversion
-
-The direct H3 output conversion path above can now parallelize independent decoded frames. It is only activated after the direct-offset path is explicitly enabled, and is otherwise absent from the normal execution path:
-
-```bash
-ED_MINIMAX_H3_FAST_VIDEO_POSTPROCESS=1 \
-ED_MINIMAX_H3_FAST_VIDEO_POSTPROCESS_THREADS=8 ed-cli ...
-```
-
-The thread count is bounded by the number of output frames; unset, invalid, or `1` leaves the single-threaded direct-offset path in use. Worker threads only read the decoded host float tensor and write their own `ed_image_t` frame allocation, so it neither changes model arithmetic nor allocates GPU memory.
-
-The full fixed-seed FL2VA validation used the same `864x480`, 124-frame, 20-step/cfg-1 task and runtime options as the direct-offset validation. The comparison uses the single-thread direct-offset run as the reference:
-
-| Variant | Generation | DiT | Video VAE | Video conversion | Video quality | Audio quality |
-|---|---:|---:|---:|---:|---|---|
-| Single-thread direct conversion | `78.417s` | `62.307s` | `12.683s` | `1.048s` | baseline | baseline |
-| Parallel direct conversion (`8` threads) | `75.420s` | `62.173s` | `10.813s` | `0.119s` | PSNR `inf` | PCM exact |
-
-The conversion phase improves by `0.929s` (`88.6%`) compared to the already optimized single-thread path and by `1.841s` compared to the original indexed path. The complete run was additionally faster by `2.997s`, though only the conversion saving should be attributed to this change because video-VAE timing varies modestly between cold model loads. Decoded video has infinite PSNR for all 124 frames and the `331,776` decoded audio samples match byte-for-byte.
-
-Artifacts:
-
-- `outputs/minimax-h3/parallel-video-postprocess-full-124f20s-2026-08-08/parallel/final.mp4`
-- `outputs/minimax-h3/parallel-video-postprocess-full-124f20s-2026-08-08/quality/video-psnr-summary.log`
-- `outputs/minimax-h3/parallel-video-postprocess-full-124f20s-2026-08-08/quality/serial.f32le`
-- `outputs/minimax-h3/parallel-video-postprocess-full-124f20s-2026-08-08/quality/parallel.f32le`
-
-### 2026-08-08 opt-in H3 temporal VAE-part collection
-
-H3 video decoding processes long videos in overlapping five-latent-token chunks. The historical code appended every decoded chunk with `sd::ops::concat`, which reallocates and recopies all already-collected full-resolution frames on every append. A guarded alternative accumulates the unchanged per-chunk tensors and performs one final temporal allocation/copy:
-
-```bash
-ED_MINIMAX_H3_COLLECT_TEMPORAL_PARTS=1 ed-cli ...
-```
-
-The default stays on the original append behavior. The alternative retains the same VAE chunks, overlap blend loop, first/last segment handling, and final frame crop; it only changes host tensor ownership and copies. It composes with the independent parallel output conversion switch, which was enabled in both full-task variants.
-
-The full 124-frame fixed-seed FL2VA validation compared it against the accepted parallel-output baseline:
-
-| Variant | Generation | DiT | Video VAE | Video conversion | Video quality | Audio quality |
-|---|---:|---:|---:|---:|---|---|
-| Original temporal appends | `75.420s` | `62.173s` | `10.813s` | `0.119s` | baseline | baseline |
-| Collected temporal parts | `74.875s` | `62.131s` | `10.324s` | `0.121s` | PSNR `inf` | PCM exact |
-
-The measured VAE-stage difference is `0.489s`; because VAE GPU timing has modest cold-run variation, treat this as a low-risk reduction in host copying rather than a guaranteed GPU compute gain. All 124 decoded frames compare at infinite PSNR and all `331,776` audio samples are byte-identical. The change does not affect GPU memory requirements or model arithmetic.
-
-Artifacts:
-
-- `outputs/minimax-h3/collect-temporal-parts-full-124f20s-2026-08-08/collect/final.mp4`
-- `outputs/minimax-h3/collect-temporal-parts-full-124f20s-2026-08-08/quality/video-psnr-summary.log`
-- `outputs/minimax-h3/collect-temporal-parts-full-124f20s-2026-08-08/quality/reference.f32le`
-- `outputs/minimax-h3/collect-temporal-parts-full-124f20s-2026-08-08/quality/collect.f32le`
-
-### 2026-08-08 rejected H3 VAE batching and decoder-layout experiments
-
-After the accepted output-copy and temporal-part collection work, a fresh GPU phase profile was taken on the fixed FL2VA task (`864x480`, 56 frames, 5 requested steps / 4 DiT calls, cfg `1`, seed `42`, first/last `assets/minimax-h3-ref2va/video-frames/001.png` and `056.png`). The accepted runtime options were `GGML_CUDA_SM90_Q4K_CUBLAS=1`, `ED_CUDNN_CONV_TRANSPOSE_1D=1`, `ED_MINIMAX_H3_FAST_VIDEO_POSTPROCESS=1`, `ED_MINIMAX_H3_FAST_VIDEO_POSTPROCESS_THREADS=8`, and `ED_MINIMAX_H3_COLLECT_TEMPORAL_PARTS=1`.
-
-The profile confirms that text encoding is not a useful target for this cfg-1 workload (`~100ms` versus Diffusers' roughly `0.6s`), and audio output copying is negligible (`2-3ms`). The short run spent about `4.3-4.7s` in video VAE decode and `~0.58s` in audio VAE decode. A CUDA op profile of the repeated decoder tiles found that each warm tile spends roughly `31ms` in layout conversions, `17.5ms` in Flash Attention, `3.8ms` in normalization, and `6.6ms` in other elementwise work. The encoder graph is instead dominated by `IM2COL_3D` / GEMM. Therefore future VAE work should focus on the decoder's required attention layout or a quality-equivalent 3D convolution path, rather than audio/video host copies.
-
-Four runtime-guarded experiments were evaluated and all source changes were reverted because they either violated the quality gate or did not improve the full task:
-
-| Experiment | Runtime switch | Short result | Full result / disposition |
-|---|---|---|---|
-| Batch stereo BigVGAN streams | `ED_MINIMAX_H3_AUDIO_BATCH_STREAMS=1` | Audio PSNR `21.13dB`, correlation `0.9789` | Rejected for audio divergence. |
-| Batch temporal GroupNorm over time | `ED_MINIMAX_H3_BATCH_TEMPORAL_GROUP_NORM=1` | Video min PSNR `35.66dB`; audio PSNR `17.86dB` | Rejected: changing the CUDA reduction batch changes diffusion output. |
-| Balanced temporal GroupNorm concat tree | `ED_MINIMAX_H3_BALANCED_TEMPORAL_GROUP_NORM_CONCAT=1` | Video/audio exact, but video VAE `4.315s -> 4.820s` | Rejected: no speed benefit. |
-| `pad_reflect_1d` for CausalConv3D width reflection | `ED_MINIMAX_H3_USE_PAD_REFLECT_1D=1` | Video/audio exact, but video VAE `4.315s -> 4.408s` | Rejected: no speed benefit. |
-
-A fifth quality-safe experiment exposed the largest decoder-layout conversion: decoder FFN `w1` chunks materialize two `8192 x 1797` F32 halves on every one of 36 blocks. `ED_MINIMAX_H3_DECODER_FFN_VIEW_CHUNKS=1` kept those chunks as strided views. The 56-frame run was bit-exact and appeared faster (`4.548s -> 4.168s` video VAE), but the required full 124-frame / 20-step validation was slower:
-
-| Variant | Total | DiT (19 calls) | Video VAE | Video | Audio |
-|---|---:|---:|---:|---|---|
-| Baseline | `75.197s` | `62.214s` | `10.486s` | baseline | baseline |
-| FFN view chunks | `76.718s` | `62.385s` | `11.811s` | all `124` decoded frames exact | `331,776` PCM samples exact |
-
-The view-chunk source change was also reverted. The likely reason is that later SiLU/multiply/linear kernels pay a non-contiguous-stride cost larger than the removed explicit copies. Do not re-enable or reimplement it without testing the full 124-frame task.
-
-Retained local artifacts (Git-ignored):
-
-- `outputs/minimax-h3/profile-video-vae-ops-56f5s-2026-08-08/run.log`
-- `outputs/minimax-h3/audio-batch-streams-56f5s-2026-08-08/`
-- `outputs/minimax-h3/batch-temporal-group-norm-56f5s-2026-08-08/`
-- `outputs/minimax-h3/balanced-temporal-group-norm-concat-56f5s-2026-08-08/`
-- `outputs/minimax-h3/pad-reflect-1d-56f5s-2026-08-08/`
-- `outputs/minimax-h3/decoder-ffn-view-chunks-full-124f20s-2026-08-08/`
-
-### 2026-08-08 rejected H3 decoder QKV view attempt
-
-The decoder-tile CUDA profile showed `108` Q/K/V chunk materializations per tile (`64x32x1797` F32), about `4.8ms` per warm tile. A default-off `ED_MINIMAX_H3_DECODER_QKV_VIEW_CHUNKS=1` prototype was built to retain the three chunks as views. It cannot pass graph construction: `DecoderAttention` immediately reshapes each chunk from the packed QKV layout, and `ggml_reshape_4d` requires contiguous storage. The run aborts before output generation at that reshape. The source change was reverted; this is a structural layout requirement of the current Flash Attention input representation, not removable materialization.
diff --git a/examples/cli/cli_common.hpp b/examples/cli/cli_common.hpp
index a532e99..ae1ccce 100644
--- a/examples/cli/cli_common.hpp
+++ b/examples/cli/cli_common.hpp
@@ -487,6 +487,9 @@ struct FluxCliArgs {
     int width = 1024;
     int height = 1024;
     int frames = 1;
+    bool frames_explicit = false;
+    float video_duration = 0.0f;
+    bool video_duration_explicit = false;
     int fps = 16;
     int steps = -1;  // -1 = auto: distilled models (e.g. FLUX schnell) default to few steps, others to 20
     int threads = 0;
@@ -536,6 +539,28 @@ struct FluxCliArgs {
     int repeat = 1;
 };
 
+inline int resolve_video_frames(const FluxCliArgs& args, bool is_minimax_h3) {
+    if (args.video_duration <= 0.0f) {
+        return args.frames;
+    }
+
+    const int fps = is_minimax_h3 ? 24 : args.fps;
+    const int requested_frames = std::max(1, static_cast<int>(std::lround(args.video_duration * fps)));
+    if (!is_minimax_h3) {
+        return requested_frames;
+    }
+
+    const int sequence_index = std::max(0, static_cast<int>(std::lround((requested_frames - 5) / 17.0)));
+    return sequence_index * 17 + 5;
+}
+
+inline int resolve_video_fit_frames(const FluxCliArgs& args) {
+    if (args.video_duration <= 0.0f) {
+        return args.frames;
+    }
+    return resolve_video_frames(args, true);
+}
+
 // Parses argv into `args`. Returns false on any error or --help (the caller is
 // responsible for printing its own usage text). Accepts both ed-cli's canonical
 // flags and ed-sample's snake_case aliases (--num_steps, --guidance_scale,
@@ -633,6 +658,13 @@ inline bool parse_args(int argc, char** argv, FluxCliArgs* args) {
             const char* v = require_value(key);
             if (!v) return false;
             args->frames = parse_int_value(v, args->frames);
+            args->frames_explicit = true;
+        } else if (std::strcmp(key, "--video-duration") == 0 ||
+                   std::strcmp(key, "--video_duration") == 0) {
+            const char* v = require_value(key);
+            if (!v) return false;
+            args->video_duration = parse_float_value(v, args->video_duration);
+            args->video_duration_explicit = true;
         } else if (std::strcmp(key, "--fps") == 0) {
             const char* v = require_value(key);
             if (!v) return false;
@@ -898,11 +930,34 @@ inline bool parse_args(int argc, char** argv, FluxCliArgs* args) {
         return false;
     }
 
+    if (args->video_duration_explicit &&
+        (!std::isfinite(args->video_duration) || args->video_duration <= 0.0f)) {
+        std::fprintf(stderr, "video duration must be a positive number of seconds\n");
+        return false;
+    }
+
+    if (args->video_duration_explicit && args->frames_explicit) {
+        std::fprintf(stderr, "--video-duration and --video-frames/--frames are mutually exclusive\n");
+        return false;
+    }
+
+    if (args->video_duration_explicit && !args->video) {
+        std::fprintf(stderr, "--video-duration requires --video or -M vid_gen\n");
+        return false;
+    }
+
     if (args->fps <= 0) {
         std::fprintf(stderr, "fps must be positive\n");
         return false;
     }
 
+    if (args->video_duration > 0.0f &&
+        static_cast<double>(args->video_duration) * std::max(args->fps, 24) >
+            static_cast<double>(std::numeric_limits<int>::max())) {
+        std::fprintf(stderr, "video duration is too large\n");
+        return false;
+    }
+
     if (args->ref_video_audio_paths.size() > args->ref_video_paths.size()) {
         std::fprintf(stderr, "each --ref-video-audio needs a corresponding --ref-video\n");
         return false;
diff --git a/examples/cli/main.cpp b/examples/cli/main.cpp
index 9ad243c..6dfb294 100644
--- a/examples/cli/main.cpp
+++ b/examples/cli/main.cpp
@@ -104,6 +104,7 @@ static void print_usage(const char* prog) {
         "  -W, --width <int>         Image width, default: 1024\n"
         "  -H, --height <int>        Image height, default: 1024\n"
         "  --frames, --video-frames <int>  Video frame count, default: 1\n"
+        "  --video-duration <seconds>  MiniMax-H3 duration; aligns to 17k+5 frames\n"
         "  --fps <int>               Video fps, default: 16\n"
         "  --ref-image <path>        MiniMax-H3 Ref2VA reference image; repeatable\n"
         "  --ref-video <path>        MiniMax-H3 Ref2VA reference video frames directory or media file; repeatable\n"
@@ -898,7 +899,7 @@ int main(int argc, char** argv) {
     // reflects the real activation footprint. Harmless when neither mode is on.
     ctx_params.fit_width = args.width;
     ctx_params.fit_height = args.height;
-    ctx_params.fit_frames = args.frames;
+    ctx_params.fit_frames = resolve_video_fit_frames(args);
     ctx_params.vae_offload = args.vae_offload;
     if (args.max_vram > 0.0f) {
         ctx_params.max_vram_gb = args.max_vram;
@@ -949,10 +950,26 @@ int main(int argc, char** argv) {
     if (args.video) {
         int output_fps = args.fps;
         const char* pipeline_name = ed_context_pipeline_name(ctx);
-        if (pipeline_name != nullptr && std::strcmp(pipeline_name, "minimax-h3") == 0 && output_fps != 24) {
+        const bool is_minimax_h3 = pipeline_name != nullptr && std::strcmp(pipeline_name, "minimax-h3") == 0;
+        if (args.video_duration_explicit && !is_minimax_h3) {
+            std::fprintf(stderr, "--video-duration is currently supported only by MiniMax-H3\n");
+            ed_free_context(ctx);
+            return 1;
+        }
+        if (is_minimax_h3 && output_fps != 24) {
             std::fprintf(stderr, "MiniMax-H3 uses 24 fps; overriding requested fps %d\n", output_fps);
             output_fps = 24;
         }
+        const int generation_frames = resolve_video_frames(args, is_minimax_h3);
+        if (args.video_duration_explicit) {
+            std::fprintf(stderr,
+                         "video duration %.3fs resolved to %d frames (%.3fs at %d fps)%s\n",
+                         args.video_duration,
+                         generation_frames,
+                         static_cast<double>(generation_frames) / output_fps,
+                         output_fps,
+                         is_minimax_h3 ? "; MiniMax-H3 requires 17k+5 frames" : "");
+        }
         ed_video_generation_params_t gen_params;
         ed_video_generation_params_init(&gen_params);
         ed_image_t init_image = {};
@@ -976,7 +993,7 @@ int main(int argc, char** argv) {
         gen_params.negative_prompt = args.negative_prompt;
         gen_params.width = args.width;
         gen_params.height = args.height;
-        gen_params.frames = args.frames;
+        gen_params.frames = generation_frames;
         gen_params.seed = args.seed;
         gen_params.sample.sampler = ED_SAMPLER_AUTO;
         gen_params.sample.scheduler = ED_SCHEDULER_AUTO;
@@ -1027,7 +1044,7 @@ int main(int argc, char** argv) {
             const bool explicit_audio_supplied = index < args.ref_video_audio_paths.size();
             if (!load_reference_video(args.ref_video_paths[index],
                                       output_fps,
-                                      args.frames,
+                                      generation_frames,
                                       &ref_video_temp_directories,
                                       &ref_video_frames[index],
                                       &ref_video_audio_samples[index],
diff --git a/examples/cli/sample_main.cpp b/examples/cli/sample_main.cpp
index 198110e..469afaf 100644
--- a/examples/cli/sample_main.cpp
+++ b/examples/cli/sample_main.cpp
@@ -74,6 +74,7 @@ void print_usage(const char* prog) {
         "  --image <path>            Input/reference image for image-editing models\n"
         "  --video, -M vid_gen       Generate video frames (calls ed_generate_video; writes .avi)\n"
         "  --frames, --video-frames <int>  Video frame count (with --video). Default 1\n"
+        "  --video-duration <seconds>  MiniMax-H3 duration; aligns to 17k+5 frames\n"
         "  --fps <int>               Video fps (with --video). Default 16\n"
         "  --start_index <int>       First prompt index (inclusive). Default 0\n"
         "  --end_index <int>         Last prompt index (exclusive). Default all\n"
@@ -580,10 +581,26 @@ int main(int argc, char** argv) {
     const bool is_root = ed_context_parallel_is_root(ctx);
     int output_fps = args.fps;
     const char* pipeline_name = ed_context_pipeline_name(ctx);
-    if (args.video && pipeline_name != nullptr && std::strcmp(pipeline_name, "minimax-h3") == 0 && output_fps != 24) {
+    const bool is_minimax_h3 = pipeline_name != nullptr && std::strcmp(pipeline_name, "minimax-h3") == 0;
+    if (args.video && args.video_duration_explicit && !is_minimax_h3) {
+        std::fprintf(stderr, "--video-duration is currently supported only by MiniMax-H3\n");
+        ed_free_context(ctx);
+        return 1;
+    }
+    if (args.video && is_minimax_h3 && output_fps != 24) {
         std::fprintf(stderr, "MiniMax-H3 uses 24 fps; overriding requested fps %d\n", output_fps);
         output_fps = 24;
     }
+    const int generation_frames = resolve_video_frames(args, is_minimax_h3);
+    if (args.video && args.video_duration_explicit) {
+        std::fprintf(stderr,
+                     "video duration %.3fs resolved to %d frames (%.3fs at %d fps)%s\n",
+                     args.video_duration,
+                     generation_frames,
+                     static_cast<double>(generation_frames) / output_fps,
+                     output_fps,
+                     is_minimax_h3 ? "; MiniMax-H3 requires 17k+5 frames" : "");
+    }
 
     if (is_root) {
         std::printf("=== ed-sample ===\n");
@@ -638,7 +655,7 @@ int main(int argc, char** argv) {
                 }
                 vgen.width = args.width;
                 vgen.height = args.height;
-                vgen.frames = args.frames;
+                vgen.frames = generation_frames;
                 vgen.seed = seed;
                 vgen.sample.sampler = ED_SAMPLER_AUTO;
                 vgen.sample.scheduler = ED_SCHEDULER_AUTO;

From fd672fec668743b99ec1954c3066e0469991dbd6 Mon Sep 17 00:00:00 2001
From: Komorebi623 <wang-ty22@mails.tsinghua.edu.cn>
Date: Fri, 14 Aug 2026 23:46:27 +0800
Subject: [PATCH 25/25] docs: refresh MiniMax-H3 support and benchmarks

Document full and pruned BF16 DiT loading, Q8_0 conversion, and downloadable pruned checkpoint sources. Replace stale Ref2VA resize-era measurements with current BF16 results showing Edge ahead of Diffusers. Refresh README model coverage, latest news, and H200 performance summary.
---
 README.md          | 22 +++++++++-------
 docs/minimax-h3.md | 62 ++++++++++++++++++++--------------------------
 2 files changed, 40 insertions(+), 44 deletions(-)

diff --git a/README.md b/README.md
index 1804c28..694e4df 100644
--- a/README.md
+++ b/README.md
@@ -19,9 +19,9 @@ runtime for image generation, image editing, and video generation across local,
 edge, and resource-constrained deployment environments.
 
 It supports major DiT model families including **FLUX.1, FLUX.2 [klein] 4B,
-Stable Diffusion 3/3.5, Qwen-Image, and Wan**, with explicit control over model
-loading, memory usage, graph execution, quantization, device placement, and
-backend selection.
+Stable Diffusion 3/3.5, Qwen-Image, Wan, and MiniMax-H3**, with explicit control
+over model loading, memory usage, graph execution, quantization, device
+placement, and backend selection.
 
 ## Features
 
@@ -54,6 +54,7 @@ backend selection.
 
 ## Latest News
 
+- **2026-08-14:** 🚀 Added **MiniMax-H3 FL2VA and Ref2VA video+audio generation** with image, video, embedded/paired audio, and mixed references; full or pruned BF16 DiTs, persistent Q8_0 conversion, Q4_K_M weights, and automatic VRAM fitting are supported ([usage and H200 results](docs/minimax-h3.md)).
 - **2026-08-05:** 🚀 Completed the **RTX 4090 (24 GB) benchmark** — full cross-system speed / VRAM / image-quality across text-to-image, editing, and video ([results](docs/performance-4090.md)).
 - **2026-07-30:** 🚀 Added **per-component offload** (`--dit-offload` / `--text-encoder-offload` / `--vae-offload`), unifying all offload paths on one semantics.
 - **2026-07-29:** 🚀 Added **`--auto-fit`** — one flag picks DiT quantization *and* per-component placement to fit a hard VRAM budget.
@@ -160,12 +161,15 @@ reflect different weight materialization or memory-mapping strategies.
 Generation latency is the primary cross-runtime performance metric.
 
 MiniMax-H3 has a separate 124-frame H200 benchmark because it generates video
-and audio rather than one image. With persistent weights, Edge FL2VA T2VA takes
-`71s` at BF16, `81.1s` at Q8_0, and `73.6s` at Q4_K_M; corresponding peaks are
-`125,051`, `71,393`, and `47,459 MiB`. `--auto-fit` was validated from 120 GB
-down to a 24 GB cap, with observed peaks below every requested budget. See
-[MiniMax-H3 usage and performance](docs/minimax-h3.md) for all four FL2VA modes,
-Ref2VA inputs, memory placement, and framework-comparison links.
+and audio rather than one image. In the current resident-component BF16
+comparison, Edge is faster than Diffusers in all four FL2VA and all four Ref2VA
+generation paths while using less peak VRAM. FL2VA text-to-video takes
+`51.396s` versus `53.986s`; Ref2VA image and mixed-reference generation reach
+`1.08x` and `1.06x` speedups. Full and pruned BF16 DiTs are supported directly,
+and either can be converted once to persistent Q8_0 GGUF. `--auto-fit` has also
+been validated down to a 24 GB VRAM budget. See [MiniMax-H3 usage and
+performance](docs/minimax-h3.md) for inputs, weights, memory placement, and the
+complete comparison.
 
 ## Open-Source Interfaces
 
diff --git a/docs/minimax-h3.md b/docs/minimax-h3.md
index daf43be..3ffca88 100644
--- a/docs/minimax-h3.md
+++ b/docs/minimax-h3.md
@@ -35,9 +35,11 @@ options, and audio-only Ref2VA requests are rejected.
 
 ### Downloadable weights
 
-The complete, unpruned checkpoints are recommended. The smaller files whose
-names contain `pruned` are loadable but are not directly comparable with the
-official full DiTs.
+The complete, unpruned checkpoints are recommended for the best quality. Edge
+also supports pruned DiT weights in BF16 safetensors format. Both full and
+pruned BF16 DiTs can be converted to Q8_0 GGUF with `ed-convert`, and the
+resulting Q8_0 DiTs can be loaded directly. Performance and quality results from
+pruned and full DiTs are not directly comparable.
 
 | Precision | Component | File | Repository |
 |---|---|---|---|
@@ -46,6 +48,8 @@ official full DiTs.
 | Q4_K_M | Qwen3-VL | `qwen3vl_32b_minimax_h3-Q4_K_M.gguf` | [`leejet/MiniMax-H3-GGUF`](https://huggingface.co/leejet/MiniMax-H3-GGUF) |
 | BF16 | FL2VA DiT | `diffusion_models/minimax_h3_fl2va_bf16.safetensors` | [`Comfy-Org/MiniMax-H3`](https://huggingface.co/Comfy-Org/MiniMax-H3) |
 | BF16 | Ref2VA DiT | `diffusion_models/minimax_h3_ref2va_bf16.safetensors` | [`Comfy-Org/MiniMax-H3`](https://huggingface.co/Comfy-Org/MiniMax-H3) |
+| BF16, pruned | FL2VA DiT | `diffusion_models/minimax_h3_fl2va_pruned_bf16.safetensors` | [`Comfy-Org/MiniMax-H3 diffusion models`](https://huggingface.co/Comfy-Org/MiniMax-H3/tree/main/diffusion_models) |
+| BF16, pruned | Ref2VA DiT | `diffusion_models/minimax_h3_ref2va_pruned_bf16.safetensors` | [`Comfy-Org/MiniMax-H3 diffusion models`](https://huggingface.co/Comfy-Org/MiniMax-H3/tree/main/diffusion_models) |
 | BF16 | Qwen3-VL | `text_encoders/qwen3vl_32b_minimax_h3_bf16.safetensors` | [`Comfy-Org/MiniMax-H3`](https://huggingface.co/Comfy-Org/MiniMax-H3) |
 | FP16 | Video VAE | `vae/minimax_h3_video_vae_fp16.safetensors` | [`Comfy-Org/MiniMax-H3`](https://huggingface.co/Comfy-Org/MiniMax-H3) |
 | FP32 | Audio VAE | `vae/minimax_h3_audio_vae_fp32.safetensors` | [`Comfy-Org/MiniMax-H3`](https://huggingface.co/Comfy-Org/MiniMax-H3) |
@@ -73,8 +77,9 @@ hf download Comfy-Org/MiniMax-H3 \
 ### Persistent Q8_0 GGUF
 
 Q8_0 benchmark files are offline conversions of the full BF16 DiTs and Qwen3-VL,
-not Comfy-Org INT8 ConvRot weights. Convert once with `ed-convert` instead of
-quantizing during every model load:
+not Comfy-Org INT8 ConvRot weights. A pruned BF16 DiT can be converted with the
+same command when lower storage and memory usage are preferred. Convert once
+with `ed-convert` instead of quantizing during every model load:
 
 ```bash
 ed-convert --model models/minimax-h3/diffusion_models/minimax_h3_fl2va_bf16.safetensors \
@@ -101,10 +106,6 @@ seconds. The resolved value is printed before generation. Use
 `--video-frames <count>` when an exact legal frame count is required. The two
 options are mutually exclusive.
 
-Flash attention is enabled by default; use `--no-flash-attention` only for
-diagnosis. The legacy `--rng` option is accepted for command compatibility but
-does not select a different RNG, so it is intentionally omitted below.
-
 ## Usage
 
 Set component paths for the desired precision. The video and audio VAE files are
@@ -215,35 +216,26 @@ FL2VA does not use Ref2VA resize preprocessing:
 | Last frame | 55.323s / 57.793s | 125,351 / 129,957 MiB |
 | First + last frames | 58.747s / 61.405s | 125,573 / 130,587 MiB |
 
-### Ref2VA resize correction
-
-The legacy Edge snapshot below predates Diffusers-compatible reference resize.
-It encoded smaller reference images/videos, so its apparent speed and memory
-advantage does not represent equal conditioning geometry. Diffusers values are
-shown only as the comparison baseline.
-
-| Legacy task | Generate | Peak VRAM |
-|---|---:|---:|
-| Image | 54.858s / 136.656s | 125,245 / 139,253 MiB |
-| Video frames | 114.843s / 183.921s | 130,029 / 137,161 MiB |
-| Video frames + paired audio | 115.488s / 185.035s | 130,029 / 137,183 MiB |
-| Mixed references | 121.558s / 319.435s | 130,029 / 141,915 MiB |
+### Ref2VA
 
 Current preprocessing follows Diffusers geometry: image short edge 2048;
 video short edge 768 with a pre-rounding `768x1344` area cap; preserved aspect
-ratio; dimensions rounded to multiples of 32; Lanczos resize. Repeating the same
-BF16 tasks with aligned conditioning gives:
-
-| Aligned task | Generate | Peak VRAM |
-|---|---:|---:|
-| Image | 140.827s / 136.656s | 130,379 / 139,253 MiB |
-| Video frames | 232.816s / 183.921s | 131,225 / 137,161 MiB |
-| Video frames + paired audio | 232.327s / 185.035s | 131,539 / 137,183 MiB |
-| Mixed references | 386.005s / 319.435s | 137,191 / 141,915 MiB |
-
-The two Ref2VA tables differ only in Edge reference preprocessing. They must not
-be combined into one speed trend: the first is historical and geometrically
-under-sized; the second is the cross-framework conditioning comparison.
+ratio; dimensions rounded to multiples of 32; Lanczos resize. Edge is faster
+than Diffusers in all four measured Ref2VA generation paths:
+
+| Current task | Generate | Edge speedup | Peak VRAM |
+|---|---:|---:|---:|
+| Image | 126.915s / 136.656s | 1.08x | 130,445 / 139,253 MiB |
+| MP4 video / video frames † | 182.649s / 183.921s | 1.01x | 132,661 / 137,161 MiB |
+| Video frames + paired audio † | 182.667s / 185.035s | 1.01x | 132,663 / 137,183 MiB |
+| Mixed references † | 301.435s / 319.435s | 1.06x | 138,113 / 141,915 MiB |
+
+The image row is a strict same-image, same-prompt comparison. The
+mixed-reference path has a clear 1.06x lead. The two video rows retain smaller
+1.01x measured leads; they are marked † because the MP4 run lets Edge extract
+embedded audio while the Diffusers run uses decoded video frames, and the
+paired-audio prompts differ slightly. A locked-command rerun is required before
+treating the approximately 1% margins as statistically significant.
 
 ## Limitations