diff --git a/.gitignore b/.gitignore
index 519c1a2..f59928a 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/CMakeLists.txt b/CMakeLists.txt
index 1292d29..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
@@ -291,9 +295,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 +396,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/README.md b/README.md
index b7eb988..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
 
@@ -34,7 +34,7 @@ backend selection.
 - **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, FLUX.2 [klein] 4B, Qwen-Image,
-    Qwen-Image-Edit, and Wan 2.1
+    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
 
@@ -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.
@@ -80,6 +81,7 @@ the 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
@@ -158,6 +160,17 @@ 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. 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
 
 edge-dit.cpp exposes the same runtime through several public integration
diff --git a/docs/cli.md b/docs/cli.md
index 8e54bda..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
 ```
@@ -366,6 +367,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
@@ -401,6 +403,31 @@ 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.
+
+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 \
+  --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-duration 5 --steps 20 --cfg-scale 1 \
+  --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 \
@@ -700,4 +727,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 90c51fc..3ffca88 100644
--- a/docs/minimax-h3.md
+++ b/docs/minimax-h3.md
@@ -1,211 +1,248 @@
 # 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
-
-MiniMax-H3 runs with four model components. The diffusion checkpoint changes by
-mode; the encoder and VAEs are shared.
-
-| 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) |
-
-### FL2VA checkpoint
-
-| Component | File name | Source |
-|---|---|---|
-| Diffusion model | `minimax_h3_fl2va-Q4_K_M.gguf` | [leejet/MiniMax-H3-GGUF](https://huggingface.co/leejet/MiniMax-H3-GGUF) |
+## Checkpoints and inputs
 
-Supported modes:
+FL2VA and Ref2VA share Qwen3-VL and both VAEs, but require different diffusion
+checkpoints.
 
-| Mode | Inputs | Output |
-|---|---|---|
-| T2VA | Text prompt | Video + audio |
-| I2VA | Text prompt + first 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) |
+| Checkpoint | Supported conditioning |
+|---|---|
+| FL2VA | Text; first frame; last frame; first and last frames |
+| Ref2VA | Repeatable reference images, videos, paired video audio, and additional audio |
 
-Supported reference inputs:
+FL2VA uses `--image`/`--init-img` for the first frame and `--end-img` for the
+last frame. Ref2VA uses the following options:
 
-| Input | CLI flag | Notes |
+| Input | CLI option | Behavior |
 |---|---|---|
-| 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. |
+| 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 |
 
-The reference inputs can be combined freely within Ref2VA. Ref2VA cannot be used
-with `--image` or `--end-img` in the same request.
+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.
 
-MiniMax-H3 control frames are not supported for either checkpoint.
-
-## Common parameters
+## Model files
 
-MiniMax-H3 is a 24 fps audio-video model. The usual full-resolution setting is:
+### Downloadable weights
+
+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 |
+|---|---|---|---|
+| 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, 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) |
+
+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.
+
+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.
-
-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.
+### Persistent Q8_0 GGUF
 
-## FL2VA usage
-
-### 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. 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-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 \
-  --image 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
-```
-
-## Ref2VA usage
+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.
 
-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 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_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-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_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-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_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-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
 ```
 
-### Standalone reference audio
+### Ref2VA
+
+Use the Ref2VA DiT for all commands in this section.
 
 ```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
+# 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
 ```
 
-### Mixed references
+## Memory placement
+
+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_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-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
+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
 ```
 
-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>`.
-
-## 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 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
+
+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. 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
+
+- 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 7a98010..d2ae828 100644
--- a/docs/models.md
+++ b/docs/models.md
@@ -19,6 +19,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
@@ -136,9 +137,14 @@ 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. 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/examples/cli/cli_common.hpp b/examples/cli/cli_common.hpp
index c8638ca..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,16 +930,44 @@ 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;
     }
 
+    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/examples/cli/main.cpp b/examples/cli/main.cpp
index 726e737..6dfb294 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>
@@ -89,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"
@@ -102,7 +104,13 @@ 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"
+        "                            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>        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"
@@ -275,6 +283,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;
@@ -759,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;
@@ -808,6 +948,28 @@ int main(int argc, char** argv) {
     }
 
     if (args.video) {
+        int output_fps = args.fps;
+        const char* pipeline_name = ed_context_pipeline_name(ctx);
+        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 = {};
@@ -816,6 +978,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 = [&]() {
@@ -830,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;
@@ -878,14 +1041,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,
+                                      generation_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();
@@ -935,7 +1105,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..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"
@@ -578,6 +579,28 @@ 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);
+    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");
@@ -632,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;
@@ -723,7 +746,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/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_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_fl2va_quantized.py b/scripts/diffusers/run_minimax_h3_fl2va_quantized.py
new file mode 100755
index 0000000..48f83ff
--- /dev/null
+++ b/scripts/diffusers/run_minimax_h3_fl2va_quantized.py
@@ -0,0 +1,410 @@
+#!/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 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)
+    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")
+    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",
+        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():
+        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)
+
+    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},
+        "video_vae_decode": {"calls": 0, "seconds": 0.0},
+        "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_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()
+
+        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)) 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)
+    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()
+
+    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,
+        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" if arguments.last_image is not None else "i2va",
+        "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"],
+        "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),
+            "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")
+    print(json.dumps(results, 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/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..c23f185
--- /dev/null
+++ b/src/core/backend/cuDNN/ed_cudnn_conv_transpose_1d.cu
@@ -0,0 +1,185 @@
+#include "ed_cudnn_conv_transpose_1d.h"
+
+#include <cuda_runtime.h>
+#include <cudnn.h>
+
+#include <cstdlib>
+#include <cstring>
+#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 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 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) || 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/src/core/backend/cuDNN/ed_cudnn_sdpa.cu b/src/core/backend/cuDNN/ed_cudnn_sdpa.cu
index ebb091e..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]);
@@ -203,6 +206,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();
@@ -355,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;
@@ -471,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;
@@ -526,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;
@@ -614,6 +629,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 =
+        (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) ||
+         (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 +648,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_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/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_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/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..45f285e 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);
         }
@@ -1489,11 +1695,24 @@ __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,
                                                           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") ||
@@ -1503,13 +1722,20 @@ __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 =
+        (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);
 #else
     ED_UNUSED(backend);
     ED_UNUSED(L_q);
     ED_UNUSED(L_k);
     ED_UNUSED(d_head);
     ED_UNUSED(mask);
+    ED_UNUSED(allow_short_f16_self_attn);
     return false;
 #endif
 }
@@ -1532,7 +1758,9 @@ __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,
+                                                      bool allow_short_cudnn_self_attn = false) {  // avoid overflow
     int64_t L_q;
     int64_t L_k;
     int64_t C;
@@ -1561,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)) {
@@ -1631,6 +1864,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);
@@ -1655,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);
@@ -1700,7 +1940,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;
         }
 
@@ -1963,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;
@@ -7414,7 +7655,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) {
@@ -7791,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/core/runtime/model_loader.cpp b/src/core/runtime/model_loader.cpp
index 5f80c45..b430b23 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;
     }
 
@@ -371,6 +372,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;
@@ -448,6 +452,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;
             }
@@ -1074,6 +1081,10 @@ std::string ModelLoader::resolve_bare_transformer_prefix(const std::string& reso
         version_ = contains(lower_name, "kontext") ? VERSION_FLUX_KONTEXT : VERSION_FLUX;
         return "transformer.";
     }
+    if (contains(lower_name, "minimax_h3") || contains(lower_name, "minimax-h3")) {
+        version_ = VERSION_MINIMAX_H3;
+        return prefix;
+    }
 
     // A bare diffusers transformer file/shard-index (…/transformer/…) carries no
     // top-level config, so get_ld_version() -- which keys on canonical names --
@@ -1143,12 +1154,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;
@@ -1160,9 +1175,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) {
@@ -1449,6 +1472,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;
     bool has_flux2 = false;
     bool has_single_block_47 = false;
 
@@ -1467,6 +1492,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
@@ -1520,6 +1553,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;
     }
@@ -1804,6 +1840,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;
@@ -1991,6 +2040,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/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 a0977c2..a00b379 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;
     }
@@ -70,8 +79,15 @@ 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]);
+        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);
+            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 +111,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 +132,24 @@ 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;
+        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);
+            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);
         }
@@ -211,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);
             }
@@ -267,6 +301,9 @@ 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));
+            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);
             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 0e5368b..35d6b35 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,50 @@ 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;
+    }
+
+    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());
+        }
+        return tensor;
+    }
+
+    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;
 
@@ -49,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,
@@ -73,6 +138,31 @@ namespace MiniMaxH3VAE {
             : GroupNorm(32, channels, 1e-6f, true) {}
 
         ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* x) {
+            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;
+                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));
+                }
+            }
             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);
@@ -229,18 +319,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 {
@@ -255,10 +352,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,
@@ -267,29 +366,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,
@@ -298,8 +427,16 @@ namespace MiniMaxH3VAE {
                                                          num_head,
                                                          nullptr,
                                                          true,
-                                                         ctx->flash_attn_enabled);
-            return to_out->forward(ctx, out);
+                                                         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");
         }
     };
 
@@ -312,14 +449,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 gate = ggml_ext_chunk(ctx->ggml_ctx, w1->forward(ctx, x), 2, 0);
-            return w2->forward(ctx,
-                               ggml_mul(ctx->ggml_ctx,
-                                        ggml_silu(ctx->ggml_ctx, gate[0]),
-                                        gate[1]));
+            auto projected = w1->forward(ctx, x);
+            h3_profile_name(projected, profile_prefix + ".w1");
+            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");
+            }
+            auto gate = ggml_ext_chunk(ctx->ggml_ctx, projected, 2, 0);
+            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");
         }
     };
 
@@ -344,21 +491,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);
         }
     };
 
@@ -422,7 +577,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");
@@ -459,13 +615,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);
         }
 
@@ -491,6 +651,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,
@@ -557,9 +720,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;
@@ -568,30 +745,88 @@ 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;
         }
 
         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_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];
+                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_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) {
+                    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;
                             }
                         }
                     }
@@ -600,6 +835,47 @@ 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);
+            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) {
+                    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);
+                offset += part.shape()[2];
+            }
+            return result;
+        }
+
         sd::Tensor<float> encode(int n_threads,
                                  const sd::Tensor<float>& x,
                                  ed_tiling_params_t tiling_params,
@@ -625,13 +901,46 @@ 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 {};
                 }
+                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);
+            }
+            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);
             }
@@ -686,13 +995,31 @@ namespace MiniMaxH3VAE {
                 input = repeat_last_frame(input, pad_tokens);
             }
 
+            const bool collect_temporal_parts = h3_env_flag_enabled("ED_MINIMAX_H3_COLLECT_TEMPORAL_PARTS");
+            const bool 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) {
+                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,
@@ -700,21 +1027,104 @@ 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_or_default("ED_MINIMAX_H3_MOVE_TEMPORAL_BLEND", true)
+                                  ? blend_temporal(overlap, std::move(first), frame_overlap)
+                                  : blend_temporal(overlap, first, frame_overlap);
                     overlap = {};
                 }
-                result = result.empty() ? std::move(first)
-                                        : sd::ops::concat(result, first, 2);
+                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 {
+                    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,16 +1133,38 @@ 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 (profile_temporal) collect_us += ggml_time_us() - collect_begin;
             }
 
+            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;
         }
 
@@ -771,26 +1203,56 @@ 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_or_default("ED_MINIMAX_H3_VAE_REUSE_ROPE_CACHE", true);
+                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);
                 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);
                     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/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 14c6125..95ec09b 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};
     };
@@ -275,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 {
@@ -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];
         }
     };
 
@@ -1264,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]
@@ -1276,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,
@@ -1284,7 +1312,13 @@ namespace LLM {
                                        num_heads,
                                        attention_mask,
                                        true,
-                                       ctx->flash_attn_enabled);  // [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) {
@@ -1381,6 +1415,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),
@@ -1488,16 +1552,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);
                 }
@@ -1558,6 +1618,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 +1630,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 +1641,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 +1660,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 +1708,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 +1814,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;
         }
 
@@ -1760,63 +1831,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);
@@ -2056,6 +2111,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 +2247,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 +2264,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 +2513,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 +2537,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/models/minimax_h3_full.hpp b/src/dit_models/models/minimax_h3_full.hpp
index 00c4f5a..8684d8f 100644
--- a/src/dit_models/models/minimax_h3_full.hpp
+++ b/src/dit_models/models/minimax_h3_full.hpp
@@ -3,7 +3,9 @@
 
 #include <algorithm>
 #include <cmath>
+#include <cstdlib>
 #include <set>
+#include <sstream>
 #include <string>
 #include <tuple>
 #include <utility>
@@ -11,6 +13,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"
 
@@ -20,6 +23,28 @@ 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;
+    }
+
+    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;
@@ -83,7 +108,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;
@@ -147,17 +179,43 @@ 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"]);
-            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]));
+            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_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);
+            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 +229,54 @@ 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]));
+        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);
     }
 
+    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 +303,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 +442,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,10 +464,22 @@ namespace MiniMaxH3 {
                                        expand,
                                        modalities,
                                        segment.modulation_row);
-            auto part = ggml_ext_slice(ctx, x, 1, segment.start, segment.end);
-            part      = ggml_add(ctx,
-                                 ggml_add(ctx, part, ggml_mul(ctx, part, mods[scale_index])),
-                                 mods[shift_index]);
+            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);
+            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;
@@ -378,9 +495,17 @@ 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);
-            auto part = ggml_add(ctx, base, ggml_mul(ctx, add, mods[gate_index]));
+            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);
+            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;
@@ -411,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),
@@ -428,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,
@@ -444,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,
@@ -596,7 +762,9 @@ namespace MiniMaxH3 {
                                                       const std::vector<SequenceSegment>& sequence_segments,
                                                       const TokenModulationSpan& video_segment,
                                                       const TokenModulationSpan& audio_segment,
-                                                      float 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"]);
 
@@ -688,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");
@@ -716,7 +907,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};
         }
     };
@@ -792,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;
@@ -959,6 +1154,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;
@@ -1005,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 {
@@ -1071,6 +1315,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);
@@ -1116,6 +1414,13 @@ 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);
+            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,
@@ -1131,8 +1436,12 @@ namespace MiniMaxH3 {
                                             layout.sequence_segments,
                                             layout.video_segment,
                                             layout.audio_segment,
-                                            time_shift_slope(sigma_v, video_shift, audio_shift));
-            auto merged     = merge_av_latents(compute_ctx, output.first, output.second);
+                                            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;
@@ -1164,6 +1473,78 @@ namespace MiniMaxH3 {
                                    params.minimax_video_sigma_shift,
                                    params.minimax_audio_sigma_shift);
             };
+            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);
+                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 eb5b68e..ab005e2 100644
--- a/src/dit_models/pipelines/minimax_h3_pipeline.cpp
+++ b/src/dit_models/pipelines/minimax_h3_pipeline.cpp
@@ -5,10 +5,14 @@
 #include <cmath>
 #include <cstdint>
 #include <cstring>
+#include <fstream>
 #include <limits>
 #include <iomanip>
+#include <regex>
 #include <set>
 #include <sstream>
+#include <thread>
+#include <vector>
 
 #include "dit_models/diffusion_model.hpp"
 #include "dit_models/components/autoencoders/minimax_h3_vae.hpp"
@@ -21,6 +25,32 @@
 namespace edgedit {
 namespace {
 
+constexpr int H3_REF_IMAGE_SHORT_EDGE = 2048;
+
+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;
@@ -33,10 +63,68 @@ 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();
+
+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;
+}
+
+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') {
+        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) {
+        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;
@@ -68,20 +156,33 @@ 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) {
+    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);
+}
+
+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) {
     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() {
@@ -89,6 +190,33 @@ 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;
+}
+
+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;
+}
+
+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 16;
+    }
+    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;
@@ -125,6 +253,95 @@ 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) {
+        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 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) {
+    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);
+}
+
 sd::Tensor<float> h3_pack_audio_and_video_latents(const sd::Tensor<float>& video,
                                                    const sd::Tensor<float>& audio) {
     if (audio.empty()) {
@@ -150,19 +367,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 {
@@ -214,7 +458,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;
@@ -230,6 +481,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 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),
+                 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) {
 }
@@ -256,7 +557,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",
@@ -270,18 +613,49 @@ bool MiniMaxH3Pipeline::prepare(const ed_context_params_t& params,
     diffusion_->alloc_params_buffer();
     diffusion_->get_param_tensors(registry.tensors(), "model.diffusion_model");
 
-    const bool text_offload = runtime.clip_offload_params_to_cpu();
+    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());
+    }
+
+    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");
+    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());
@@ -289,12 +663,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());
@@ -308,6 +679,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{};
@@ -349,6 +721,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,
@@ -357,47 +733,121 @@ 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");
     }
-    std::string presentations;
+    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);
-    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);
-        sd::Tensor<float> image_tensor = h3_image_to_tensor(image, width, height);
+    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) {
+        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) {
+        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;
+        }
+        return embed_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;
+        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;
-        LOG_DEBUG("MiniMax-H3 Ref2VA vision image=%dx%d tensor=%s",
-                  width,
-                  height,
-                  sd::tensor_shape_to_string(image_tensor.shape()).c_str());
+        if (profile != nullptr) profile->vision_image_prepare_ms += ggml_time_ms() - prepare_begin;
+        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);
-        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));
+        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(static_cast<int>(prefix_tokens.size()), std::move(image_outputs[layer + 1]));
+            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});
+        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_reference_image_dimensions(image, &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;
         }
-        image_embed_infos.push_back({static_cast<int>(prefix_tokens.size()), image_tokens, 1, height / 16, width / 16});
     }
     int video_number = 0;
     int audio_number = 0;
@@ -414,58 +864,128 @@ 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;
-        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 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];
+            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;
-            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");
-            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;
+                    }
+                }
+            }
+            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>(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>";
             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);
-            presentations += timestamp + "<|vision_start|>";
-            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});
+            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, 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) + ">: ");
+    }
+    append_text(prompt == nullptr ? "" : prompt);
+    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());
     }
-    const std::string text = "<|im_start|>user\n" + presentations +
-                             std::string(prompt == nullptr ? "" : prompt) +
-                             "<|im_end|>\n<|im_start|>assistant\n";
-    const std::vector<int> tokens = conditioner_->tokenizer->tokenize(text, nullptr, true, 0, 4096, false);
     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);
-    *context = conditioner_->model.compute(runtime_->n_threads(), ids, {}, image_embeds, {50}, image_embed_infos, "", deepstack_image_embeds);
+    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, 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");
     }
-    *token_tags = sd::Tensor<int32_t>({context->shape()[1]},
-                                      std::vector<int32_t>(static_cast<size_t>(context->shape()[1]), 1));
+    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));
     h3_trace_tensor("text_context", *context);
     return true;
 }
@@ -473,13 +993,14 @@ 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;
-    }
+    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);
+    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;
@@ -495,6 +1016,10 @@ 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;
+    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);
@@ -506,29 +1031,66 @@ 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));
+    }
+    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) {
+                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));
+                }
+            }
+        }
+    };
+    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;
+    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");
     }
@@ -541,6 +1103,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);
@@ -550,12 +1113,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;
@@ -590,32 +1157,100 @@ 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;
+    }
+    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;
-    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->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;
+    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;
+    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->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;
     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;
     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});
-        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 = 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>(h3_resolve_seed(params->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, 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);
@@ -630,6 +1265,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) {
@@ -644,7 +1280,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));
@@ -652,26 +1291,31 @@ 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(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");
             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 = 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>(h3_resolve_seed(params->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, 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));
@@ -694,6 +1338,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)));
@@ -707,15 +1360,20 @@ 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 = 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;
         if (reference.audio.data != nullptr && reference.audio.sample_count > 0 && !encode_reference_audio(reference.audio, &audio_index)) {
             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)));
-        latent = latent * MiniMaxH3::VISUAL_COND_TIMESTEP + sd::randn_like<float>(latent, condition_rng) * (1.0f - MiniMaxH3::VISUAL_COND_TIMESTEP);
+        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});
@@ -728,18 +1386,62 @@ 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;
+    }
     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>(h3_resolve_seed(params->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);
+    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;
+    // 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 = 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;
@@ -758,11 +1460,41 @@ 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;
+        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;
+            ++profile.diffusion_calls;
+        }
         if (velocity.empty()) {
             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;
+            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);
             h3_trace_tensor(("step_" + std::to_string(step) + "_velocity").c_str(), velocity);
@@ -773,14 +1505,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..f04579a 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 {
 
@@ -64,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,
@@ -72,13 +79,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/src/utils/model_io/convert.cpp b/src/utils/model_io/convert.cpp
index 3537799..150f491 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>
@@ -162,7 +163,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;
 
diff --git a/src/utils/name_conversion.cpp b/src/utils/name_conversion.cpp
index 63243ca..0de38e0 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;
 }
@@ -1244,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());
diff --git a/third_party/ggml b/third_party/ggml
index e621959..b067f4f 160000
--- a/third_party/ggml
+++ b/third_party/ggml
@@ -1 +1 @@
-Subproject commit e621959f6baea1670d407f801c62a8cde253c9a7
+Subproject commit b067f4f6d48bff332fda61de57a524bb0d33da67
diff --git a/tools/bench_diffusers_flux_transformer_ulysses.py b/tools/bench_diffusers_flux_transformer_ulysses.py
deleted file mode 100644
index 0e95558..0000000
--- a/tools/bench_diffusers_flux_transformer_ulysses.py
+++ /dev/null
@@ -1,230 +0,0 @@
-import argparse
-import json
-import os
-import time
-
-import torch
-import torch.distributed as dist
-import torch.profiler
-from diffusers.models._modeling_parallel import ContextParallelConfig
-from diffusers.models.transformers.transformer_flux import FluxTransformer2DModel
-
-
-def sync():
-    torch.cuda.synchronize()
-    if dist.is_available() and dist.is_initialized():
-        dist.barrier()
-
-
-def make_flux_ids(img_seq, txt_seq, device):
-    side = int(img_seq**0.5)
-    if side * side != img_seq:
-        raise ValueError(f"img_seq must be square for this benchmark, got {img_seq}")
-    img_ids = torch.zeros((img_seq, 3), device=device, dtype=torch.float32)
-    rows = torch.arange(side, device=device, dtype=torch.float32).repeat_interleave(side)
-    cols = torch.arange(side, device=device, dtype=torch.float32).repeat(side)
-    img_ids[:, 1] = rows
-    img_ids[:, 2] = cols
-    txt_ids = torch.zeros((txt_seq, 3), device=device, dtype=torch.float32)
-    return img_ids, txt_ids
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--model", required=True)
-    parser.add_argument("--mode", choices=["single", "ulysses"], default="single")
-    parser.add_argument("--steps", type=int, default=6)
-    parser.add_argument("--warmup", type=int, default=1)
-    parser.add_argument("--img-seq", type=int, default=4096)
-    parser.add_argument("--txt-seq", type=int, default=256)
-    parser.add_argument("--seed", type=int, default=0)
-    parser.add_argument("--dtype", choices=["bf16", "fp16", "fp32"], default="bf16")
-    parser.add_argument("--attention-backend", default=None)
-    parser.add_argument("--profile", action="store_true")
-    parser.add_argument("--profile-steps", type=int, default=2)
-    parser.add_argument("--profile-row-limit", type=int, default=30)
-    parser.add_argument("--profile-sort", default="cuda_time_total")
-    args = parser.parse_args()
-
-    distributed = args.mode == "ulysses"
-    if distributed:
-        dist.init_process_group("nccl")
-        rank = dist.get_rank()
-        world = dist.get_world_size()
-        local_rank = int(os.environ.get("LOCAL_RANK", rank))
-    else:
-        rank = 0
-        world = 1
-        local_rank = 0
-
-    torch.cuda.set_device(local_rank)
-    device = torch.device(f"cuda:{local_rank}")
-    dtype = {
-        "bf16": torch.bfloat16,
-        "fp16": torch.float16,
-        "fp32": torch.float32,
-    }[args.dtype]
-
-    t0 = time.perf_counter()
-    model = FluxTransformer2DModel.from_pretrained(
-        args.model,
-        subfolder="transformer",
-        torch_dtype=dtype,
-    ).to(device)
-    model.eval()
-    if args.attention_backend:
-        model.set_attention_backend(args.attention_backend)
-    if distributed:
-        model.enable_parallelism(config=ContextParallelConfig(ring_degree=1, ulysses_degree=world))
-    t1 = time.perf_counter()
-
-    g = torch.Generator(device=device).manual_seed(args.seed + rank)
-    hidden_states = torch.randn((1, args.img_seq, model.config.in_channels), device=device, dtype=dtype, generator=g)
-    encoder_hidden_states = torch.randn(
-        (1, args.txt_seq, model.config.joint_attention_dim),
-        device=device,
-        dtype=dtype,
-        generator=g,
-    )
-    pooled = torch.randn((1, model.config.pooled_projection_dim), device=device, dtype=dtype, generator=g)
-    timestep = torch.ones((1,), device=device, dtype=dtype)
-    guidance = torch.full((1,), 3.5, device=device, dtype=dtype) if model.config.guidance_embeds else None
-    img_ids, txt_ids = make_flux_ids(args.img_seq, args.txt_seq, device)
-
-    def run_once():
-        with torch.inference_mode():
-            out = model(
-                hidden_states=hidden_states,
-                encoder_hidden_states=encoder_hidden_states,
-                pooled_projections=pooled,
-                timestep=timestep,
-                img_ids=img_ids,
-                txt_ids=txt_ids,
-                guidance=guidance,
-                return_dict=False,
-            )[0]
-        return out
-
-    for _ in range(args.warmup):
-        _ = run_once()
-    sync()
-
-    times = []
-    total_start = time.perf_counter()
-    for _ in range(args.steps):
-        sync()
-        start = time.perf_counter()
-        out = run_once()
-        sync()
-        end = time.perf_counter()
-        times.append((end - start) * 1000.0)
-    total_end = time.perf_counter()
-
-    checksum = float(out.float().mean().detach().cpu())
-    payload = {
-        "mode": args.mode,
-        "rank": rank,
-        "world": world,
-        "local_rank": local_rank,
-        "dtype": args.dtype,
-        "attention_backend": args.attention_backend,
-        "load_s": t1 - t0,
-        "steps": args.steps,
-        "warmup": args.warmup,
-        "img_seq": args.img_seq,
-        "txt_seq": args.txt_seq,
-        "times_ms": times,
-        "mean_ms": sum(times) / len(times),
-        "total_s": total_end - total_start,
-        "checksum": checksum,
-    }
-    print("DIFFUSERS_TRANSFORMER_PROFILE " + json.dumps(payload, sort_keys=True), flush=True)
-
-    if args.profile:
-        sync()
-        activities = [torch.profiler.ProfilerActivity.CPU, torch.profiler.ProfilerActivity.CUDA]
-        with torch.profiler.profile(
-            activities=activities,
-            record_shapes=False,
-            profile_memory=False,
-            with_stack=False,
-        ) as prof:
-            for step in range(args.profile_steps):
-                sync()
-                with torch.profiler.record_function(f"diffusers_transformer_forward_{step}"):
-                    _ = run_once()
-                sync()
-                prof.step()
-        sync()
-
-        events = list(prof.key_averages())
-
-        def event_us(event, *names):
-            for name in names:
-                value = getattr(event, name, None)
-                if value is not None:
-                    return float(value)
-            return 0.0
-
-        def event_count(event):
-            return int(getattr(event, "count", 0))
-
-        def event_payload(event):
-            return {
-                "name": event.key,
-                "count": event_count(event),
-                "cpu_total_ms": event_us(event, "cpu_time_total") / 1000.0,
-                "cpu_self_ms": event_us(event, "self_cpu_time_total") / 1000.0,
-                "cuda_total_ms": event_us(event, "cuda_time_total", "device_time_total") / 1000.0,
-                "cuda_self_ms": event_us(event, "self_cuda_time_total", "self_device_time_total") / 1000.0,
-            }
-
-        top_events = sorted(
-            events,
-            key=lambda event: event_us(event, args.profile_sort, "cuda_time_total", "device_time_total"),
-            reverse=True,
-        )[: args.profile_row_limit]
-        keywords = (
-            "nccl",
-            "all_to_all",
-            "alltoall",
-            "all_gather",
-            "allgather",
-            "send",
-            "recv",
-            "scaled_dot_product",
-            "flash",
-            "attention",
-        )
-        selected_events = [
-            event
-            for event in events
-            if any(keyword in event.key.lower() for keyword in keywords)
-        ]
-        selected_events = sorted(
-            selected_events,
-            key=lambda event: event_us(event, "cuda_time_total", "device_time_total", "cpu_time_total"),
-            reverse=True,
-        )
-        profile_payload = {
-            "mode": args.mode,
-            "rank": rank,
-            "world": world,
-            "steps": args.profile_steps,
-            "sort": args.profile_sort,
-            "top": [event_payload(event) for event in top_events],
-            "selected": [event_payload(event) for event in selected_events[: args.profile_row_limit]],
-        }
-        print("DIFFUSERS_TRANSFORMER_TORCH_PROFILE " + json.dumps(profile_payload, sort_keys=True), flush=True)
-        print(
-            f"DIFFUSERS_TRANSFORMER_TORCH_PROFILE_TABLE rank={rank} world={world} sort={args.profile_sort}",
-            flush=True,
-        )
-        print(prof.key_averages().table(sort_by=args.profile_sort, row_limit=args.profile_row_limit), flush=True)
-
-    if distributed:
-        dist.destroy_process_group()
-
-
-if __name__ == "__main__":
-    main()
diff --git a/tools/bench_diffusers_flux_ulysses.py b/tools/bench_diffusers_flux_ulysses.py
deleted file mode 100644
index da387e1..0000000
--- a/tools/bench_diffusers_flux_ulysses.py
+++ /dev/null
@@ -1,120 +0,0 @@
-import argparse
-import json
-import os
-import time
-from pathlib import Path
-
-import torch
-import torch.distributed as dist
-from diffusers import FluxPipeline
-from diffusers.models._modeling_parallel import ContextParallelConfig
-
-
-def synchronize():
-    if torch.cuda.is_available():
-        torch.cuda.synchronize()
-    if dist.is_available() and dist.is_initialized():
-        dist.barrier()
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--model", required=True)
-    parser.add_argument("--prompt", required=True)
-    parser.add_argument("--width", type=int, default=1024)
-    parser.add_argument("--height", type=int, default=1024)
-    parser.add_argument("--steps", type=int, default=6)
-    parser.add_argument("--seed", type=int, default=0)
-    parser.add_argument("--guidance", type=float, default=3.5)
-    parser.add_argument("--mode", choices=["single", "ulysses"], default="single")
-    parser.add_argument("--output", default="/tmp/diffusers_flux.png")
-    parser.add_argument("--dtype", choices=["bf16", "fp16", "fp32"], default="bf16")
-    parser.add_argument("--max-sequence-length", type=int, default=256)
-    args = parser.parse_args()
-
-    distributed = args.mode == "ulysses"
-    if distributed:
-        dist.init_process_group("nccl")
-        rank = dist.get_rank()
-        world = dist.get_world_size()
-        local_rank = int(os.environ.get("LOCAL_RANK", rank))
-    else:
-        rank = 0
-        world = 1
-        local_rank = 0
-
-    torch.cuda.set_device(local_rank)
-    dtype = {
-        "bf16": torch.bfloat16,
-        "fp16": torch.float16,
-        "fp32": torch.float32,
-    }[args.dtype]
-
-    t0 = time.perf_counter()
-    pipe = FluxPipeline.from_pretrained(args.model, torch_dtype=dtype)
-    pipe.to(f"cuda:{local_rank}")
-    pipe.set_progress_bar_config(disable=True)
-    t1 = time.perf_counter()
-
-    if distributed:
-        cp_config = ContextParallelConfig(ring_degree=1, ulysses_degree=world)
-        pipe.transformer.enable_parallelism(config=cp_config)
-
-    transformer_times = []
-    orig_forward = pipe.transformer.forward
-
-    def timed_forward(*f_args, **f_kwargs):
-        synchronize()
-        s = time.perf_counter()
-        out = orig_forward(*f_args, **f_kwargs)
-        synchronize()
-        e = time.perf_counter()
-        transformer_times.append((e - s) * 1000.0)
-        return out
-
-    pipe.transformer.forward = timed_forward
-
-    generator = torch.Generator(device=f"cuda:{local_rank}").manual_seed(args.seed)
-    synchronize()
-    infer_start = time.perf_counter()
-    result = pipe(
-        prompt=args.prompt,
-        width=args.width,
-        height=args.height,
-        num_inference_steps=args.steps,
-        guidance_scale=args.guidance,
-        generator=generator,
-        output_type="pil" if rank == 0 else "latent",
-        max_sequence_length=args.max_sequence_length,
-    )
-    synchronize()
-    infer_end = time.perf_counter()
-
-    if rank == 0 and hasattr(result, "images") and result.images is not None and args.output:
-        image = result.images[0]
-        if hasattr(image, "save"):
-            Path(args.output).parent.mkdir(parents=True, exist_ok=True)
-            image.save(args.output)
-
-    payload = {
-        "mode": args.mode,
-        "rank": rank,
-        "world": world,
-        "local_rank": local_rank,
-        "dtype": args.dtype,
-        "width": args.width,
-        "height": args.height,
-        "steps": args.steps,
-        "load_s": t1 - t0,
-        "inference_s": infer_end - infer_start,
-        "transformer_ms": transformer_times,
-        "transformer_sum_ms": sum(transformer_times),
-    }
-    print("DIFFUSERS_PROFILE " + json.dumps(payload, sort_keys=True), flush=True)
-
-    if distributed:
-        dist.destroy_process_group()
-
-
-if __name__ == "__main__":
-    main()
diff --git a/tools/bench_diffusers_wan_transformer.py b/tools/bench_diffusers_wan_transformer.py
deleted file mode 100644
index 5ae7e02..0000000
--- a/tools/bench_diffusers_wan_transformer.py
+++ /dev/null
@@ -1,233 +0,0 @@
-import argparse
-import json
-import os
-import time
-
-import torch
-import torch.distributed as dist
-import torch.profiler
-from diffusers import WanTransformer3DModel
-from diffusers.models._modeling_parallel import ContextParallelConfig
-
-
-def sync():
-    torch.cuda.synchronize()
-    if dist.is_available() and dist.is_initialized():
-        dist.barrier()
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--model", required=True)
-    parser.add_argument("--mode", choices=["single", "ulysses"], default="single")
-    parser.add_argument("--width", type=int, default=832)
-    parser.add_argument("--height", type=int, default=480)
-    parser.add_argument("--latent-frames", type=int, default=10)
-    parser.add_argument("--steps", type=int, default=4)
-    parser.add_argument("--warmup", type=int, default=1)
-    parser.add_argument("--seed", type=int, default=0)
-    parser.add_argument("--dtype", choices=["fp16", "bf16", "fp32"], default="fp16")
-    parser.add_argument("--attention-backend", default=None)
-    parser.add_argument("--fuse-qkv", action="store_true")
-    parser.add_argument("--text-seq", type=int, default=512)
-    parser.add_argument("--profile", action="store_true")
-    parser.add_argument("--profile-steps", type=int, default=1)
-    parser.add_argument("--profile-row-limit", type=int, default=30)
-    parser.add_argument("--profile-sort", default="cuda_time_total")
-    args = parser.parse_args()
-
-    distributed = args.mode == "ulysses"
-    if distributed:
-        dist.init_process_group("nccl")
-        rank = dist.get_rank()
-        world = dist.get_world_size()
-        local_rank = int(os.environ.get("LOCAL_RANK", rank))
-    else:
-        rank = 0
-        world = 1
-        local_rank = 0
-
-    torch.cuda.set_device(local_rank)
-    device = torch.device(f"cuda:{local_rank}")
-    dtype = {
-        "fp16": torch.float16,
-        "bf16": torch.bfloat16,
-        "fp32": torch.float32,
-    }[args.dtype]
-
-    t0 = time.perf_counter()
-    model = WanTransformer3DModel.from_pretrained(
-        args.model,
-        subfolder="transformer",
-        local_files_only=True,
-        low_cpu_mem_usage=True,
-    )
-    model.to(device=device, dtype=dtype)
-    model.eval()
-    if args.attention_backend:
-        model.set_attention_backend(args.attention_backend)
-    if args.fuse_qkv:
-        model.fuse_qkv_projections()
-    if distributed:
-        model.enable_parallelism(config=ContextParallelConfig(ring_degree=1, ulysses_degree=world))
-    t1 = time.perf_counter()
-
-    latent_h = args.height // 8
-    latent_w = args.width // 8
-    g = torch.Generator(device=device).manual_seed(args.seed)
-    hidden_states = torch.randn(
-        (1, model.config.in_channels, args.latent_frames, latent_h, latent_w),
-        device=device,
-        dtype=dtype,
-        generator=g,
-    )
-    prompt_embeds = torch.randn(
-        (1, args.text_seq, model.config.text_dim),
-        device=device,
-        dtype=dtype,
-        generator=g,
-    )
-    negative_prompt_embeds = torch.randn(
-        (1, args.text_seq, model.config.text_dim),
-        device=device,
-        dtype=dtype,
-        generator=g,
-    )
-    timestep = torch.full((1,), 999.0, device=device, dtype=torch.float32)
-
-    def forward_pair():
-        with torch.inference_mode():
-            cond = model(
-                hidden_states=hidden_states,
-                timestep=timestep,
-                encoder_hidden_states=prompt_embeds,
-                return_dict=False,
-            )[0]
-            uncond = model(
-                hidden_states=hidden_states,
-                timestep=timestep,
-                encoder_hidden_states=negative_prompt_embeds,
-                return_dict=False,
-            )[0]
-            out = uncond + 5.0 * (cond - uncond)
-        return out
-
-    for _ in range(args.warmup):
-        _ = forward_pair()
-    sync()
-
-    times = []
-    total_start = time.perf_counter()
-    for _ in range(args.steps):
-        sync()
-        start = time.perf_counter()
-        out = forward_pair()
-        sync()
-        end = time.perf_counter()
-        times.append((end - start) * 1000.0)
-    total_end = time.perf_counter()
-
-    payload = {
-        "width": args.width,
-        "height": args.height,
-        "latent_frames": args.latent_frames,
-        "latent_h": latent_h,
-        "latent_w": latent_w,
-        "seq": (args.latent_frames // model.config.patch_size[0])
-        * (latent_h // model.config.patch_size[1])
-        * (latent_w // model.config.patch_size[2]),
-        "dtype": args.dtype,
-        "param_dtype": str(next(model.parameters()).dtype),
-        "attention_backend": args.attention_backend,
-        "fuse_qkv": args.fuse_qkv,
-        "load_s": t1 - t0,
-        "steps": args.steps,
-        "warmup": args.warmup,
-        "pair_times_ms": times,
-        "mean_pair_ms": sum(times) / len(times),
-        "total_s": total_end - total_start,
-        "checksum": float(out.float().mean().detach().cpu()),
-    }
-    print("DIFFUSERS_WAN_TRANSFORMER_PROFILE " + json.dumps(payload, sort_keys=True), flush=True)
-
-    if args.profile:
-        activities = [torch.profiler.ProfilerActivity.CPU, torch.profiler.ProfilerActivity.CUDA]
-        with torch.profiler.profile(
-            activities=activities,
-            record_shapes=False,
-            profile_memory=False,
-            with_stack=False,
-        ) as prof:
-            for _ in range(args.profile_steps):
-                sync()
-                _ = forward_pair()
-                sync()
-                prof.step()
-        events = list(prof.key_averages())
-
-        def event_us(event, *names):
-            for name in names:
-                value = getattr(event, name, None)
-                if value is not None:
-                    return float(value)
-            return 0.0
-
-        def event_payload(event):
-            return {
-                "name": event.key,
-                "count": int(getattr(event, "count", 0)),
-                "cpu_total_ms": event_us(event, "cpu_time_total") / 1000.0,
-                "cpu_self_ms": event_us(event, "self_cpu_time_total") / 1000.0,
-                "cuda_total_ms": event_us(event, "cuda_time_total", "device_time_total") / 1000.0,
-                "cuda_self_ms": event_us(event, "self_cuda_time_total", "self_device_time_total") / 1000.0,
-            }
-
-        top_events = sorted(
-            events,
-            key=lambda event: event_us(event, args.profile_sort, "cuda_time_total", "device_time_total"),
-            reverse=True,
-        )[: args.profile_row_limit]
-        keywords = (
-            "nccl",
-            "all_to_all",
-            "alltoall",
-            "all_gather",
-            "allgather",
-            "send",
-            "recv",
-            "scaled_dot_product",
-            "flash",
-            "attention",
-        )
-        selected_events = [
-            event
-            for event in events
-            if any(keyword in event.key.lower() for keyword in keywords)
-        ]
-        selected_events = sorted(
-            selected_events,
-            key=lambda event: event_us(event, "cuda_time_total", "device_time_total", "cpu_time_total"),
-            reverse=True,
-        )
-        profile_payload = {
-            "mode": args.mode,
-            "rank": rank,
-            "world": world,
-            "steps": args.profile_steps,
-            "sort": args.profile_sort,
-            "top": [event_payload(event) for event in top_events],
-            "selected": [event_payload(event) for event in selected_events[: args.profile_row_limit]],
-        }
-        print("DIFFUSERS_WAN_TRANSFORMER_TORCH_PROFILE " + json.dumps(profile_payload, sort_keys=True), flush=True)
-        print(
-            f"DIFFUSERS_WAN_TRANSFORMER_TORCH_PROFILE_TABLE rank={rank} world={world} sort={args.profile_sort}",
-            flush=True,
-        )
-        print(prof.key_averages().table(sort_by=args.profile_sort, row_limit=args.profile_row_limit), flush=True)
-
-    if distributed:
-        dist.destroy_process_group()
-
-
-if __name__ == "__main__":
-    main()