# ComfyUI MiniMax-H3 Dual-Clock Euler Sampler

[简体中文](README.md) | [English](README_EN.md)

A MiniMax-H3 audio/video sampling compatibility node. It originally supplied dual-clock Euler integration to prevent blown-out, clipped, or noise-like audio with the four-step [MiniMax-H3 Turbo LoRA](https://huggingface.co/larryvrh/MiniMax-H3-Turbo-Lora). Since ComfyUI commit [`bdcb886`](https://github.com/comfyanonymous/ComfyUI/commit/bdcb886a4705a03cf40f4a7226de9fc7c059fc90), MiniMax-H3 AV flow is handled natively. On those newer builds this node delegates to stock `euler` and mainly preserves old workflows.

This repository does not contain or redistribute MiniMax-H3, its VAEs, its text encoder, or the Turbo LoRA weights.

> [!IMPORTANT]
> **Check your ComfyUI build first.** Starting with commit [`bdcb886`](https://github.com/comfyanonymous/ComfyUI/commit/bdcb886a4705a03cf40f4a7226de9fc7c059fc90) (2026-08-06 nightly), ComfyUI includes native MiniMax-H3 AV sampling. That commit and newer builds can use stock `KSamplerSelect: euler`; this plugin is no longer required to prevent the audio explosion. ComfyUI still reported source version `0.30.0` at that point, so use the commit or the presence of `comfy.model_sampling.ModelSamplingAV`, not only the displayed version string.

> [!WARNING]
> **Native sampling support does not make the validated Turbo LoRA directly loadable.** For the initial `minimax_h3_turbo_4step.safetensors` covered by this README, still add the `diffusion_model.` prefix to its keys, then load it through `Load LoRA (Bypass, Model Only)` at strength `1.0`. Do not skip conversion or switch to a normal weight-folding LoRA loader merely because current ComfyUI fixed the sampler.

> [!TIP]
> If you must run a ComfyUI build older than `bdcb886`, install this plugin and connect `MiniMax H3 Dual-Clock Euler` to `SamplerCustomAdvanced.sampler`; the legacy manual dual-clock path will be used. The node may also remain in current workflows, where it automatically delegates to stock Euler.

> [!NOTE]
> This is a third-party compatibility node, not an official release from the LoRA author or Comfy-Org. Its legacy sampling path follows the author's [`generate.py`](https://huggingface.co/larryvrh/MiniMax-H3-Turbo-Lora/blob/main/generate.py). It is tested against legacy ComfyUI commit `14b05228cef127ce529bc0c08660770d4af3e9a8` and the native AV path in `a464ac33588ae182f81a090d910cfbf21e255b73`.

## Quick start

Follow these six steps without changing the scheduler, LoRA strength, or shifts until you have completed a clean baseline render.

### 1. Select a full, non-pruned FL2VA base model

Download one of these diffusion models from [Comfy-Org/MiniMax-H3](https://huggingface.co/Comfy-Org/MiniMax-H3):

```text
minimax_h3_fl2va_bf16.safetensors
```

Or use the lower-resource version that has been tested locally in ComfyUI:

```text
minimax_h3_fl2va_int8_convrot.safetensors
```

Do not use a filename containing `pruned`. BF16 and full INT8 ConvRot are both valid starting points; retaining the complete AdaLN layer structure is what matters. Use an official BF16 or INT8 ConvRot text encoder together with `minimax_h3_video_vae_fp16.safetensors` and `minimax_h3_audio_vae_fp32.safetensors`.

### 2. Install this node (optional on current ComfyUI)

```bash
cd ComfyUI/custom_nodes
git clone https://github.com/shuaixn/ComfyUI-MiniMaxH3DualClockSampler.git
```

Current ComfyUI can use stock `KSamplerSelect: euler` without this plugin. Install or update it when an existing workflow contains this node ID and you want that workflow to remain valid. Fully restart ComfyUI and search for:

```text
MiniMax H3 Dual-Clock Euler
```

### 3. Download and convert the author's Turbo LoRA

Download the regular non-EMA checkpoint:

```text
minimax_h3_turbo_4step.safetensors
```

Source: [larryvrh/MiniMax-H3-Turbo-Lora](https://huggingface.co/larryvrh/MiniMax-H3-Turbo-Lora/tree/main)

The original keys are missing the `diffusion_model.` prefix expected by ComfyUI. From this repository directory, run:

```bash
python convert_h3_lora_for_comfyui.py \
  /path/to/minimax_h3_turbo_4step.safetensors \
  /path/to/ComfyUI/models/loras/minimax_h3_turbo_4step_comfyui.safetensors
```

For a Windows portable build, use its bundled Python, for example:

```powershell
C:\ComfyUI_windows_portable\python_embeded\python.exe .\convert_h3_lora_for_comfyui.py `
  "D:\Downloads\minimax_h3_turbo_4step.safetensors" `
  "C:\ComfyUI_windows_portable\ComfyUI\models\loras\minimax_h3_turbo_4step_comfyui.safetensors"
```

The converter changes only the key prefix. It preserves and verifies tensor dtype, shape, LoRA pairs, and safetensors metadata.

### 4. Load the converted LoRA through the bypass loader

Use:

```text
Load LoRA (Bypass, Model Only)
```

Select the converted `_comfyui.safetensors` file and set `strength_model` to `1.0`. This loader preserves the author's runtime `base(x) + B(A(x))` behavior; do not replace it with a weight-folding LoRA loader.

Connect its model output to both `BasicGuider` and `BasicScheduler`.

### 5. Select the sampler

Start from an official [T2V](https://github.com/Comfy-Org/workflow_templates/blob/main/templates/video_minimax_h3_t2v.json), [I2V](https://github.com/Comfy-Org/workflow_templates/blob/main/templates/video_minimax_h3_i2v.json), or [R2V](https://github.com/Comfy-Org/workflow_templates/blob/main/templates/video_minimax_h3_r2v.json) template.

On current ComfyUI builds containing the native AV fix, keep `KSamplerSelect` and choose `euler`. Alternatively, replace it with this node; the node delegates to the same stock Euler. On legacy ComfyUI, it automatically keeps the manual dual-clock implementation. Keep all other official wiring unchanged.

![Replace KSamplerSelect with MiniMax H3 Dual-Clock Euler](docs/images/quick-start-sampler-replacement.png)

### 6. Use the validated baseline settings

```text
LoRA loader: Load LoRA (Bypass, Model Only)
LoRA strength: 1.0
sampler: KSamplerSelect/euler (current) or MiniMax H3 Dual-Clock Euler
scheduler: simple
steps: 4 for speed or 8 for a cleaner result
denoise: 1.0
guider: BasicGuider
video shift: 12
audio shift: 3
```

Current ComfyUI uses `ModelSamplingAV` to align both stream schedules in core, so this node does not apply a second correction. When this compatibility node is used, a current build logs:

```text
[MiniMaxH3DualClock] Native ComfyUI AV sampling detected; delegating to stock Euler.
```

Only the legacy path runs the strict sigma checks and manual dual-clock loop; it logs:

```text
[MiniMaxH3DualClock] Euler sampling with video shift 12.0, audio shift 3.0, ...
[MiniMaxH3DualClock] Rebuilt 4-step sigma grid from the author's multiplicative shift-12 schedule.
```

## What it fixes

MiniMax-H3 jointly denoises video and stereo-audio latents, but the two streams use different flow schedules:

- video shift: `12`
- audio shift: `3`

The legacy model path returned audio velocity pre-scaled by `dσ_audio / dσ_video`, allowing a stock single-clock sampler to approximate both streams with the video delta. At four steps, large intervals could severely overshoot the audio schedule.

On legacy ComfyUI this node divides out that slope and integrates with the audio delta. On current ComfyUI, `ModelSamplingAV` carries the audio latent onto the video sampling coordinates, so stock Euler can advance both streams correctly; this node detects that capability and returns stock Euler instead of correcting twice.

## Known-good starting configuration

| Setting | Recommended value |
|---|---|
| Base DiT | Full, non-pruned FL2VA BF16 or INT8 ConvRot |
| LoRA file | `minimax_h3_turbo_4step.safetensors` (non-EMA) |
| LoRA format | ComfyUI-prefixed keys (`diffusion_model.`) |
| LoRA loader | `Load LoRA (Bypass, Model Only)` |
| LoRA strength | `1.0` |
| Sampler | Current: stock `KSamplerSelect: euler`; compatibility node: `MiniMax H3 Dual-Clock Euler` |
| Scheduler | `BasicScheduler: simple` |
| Steps | `4` for speed, `8` for a cleaner result |
| Denoise | `1.0` |
| Guider | `BasicGuider` |

On legacy ComfyUI without `ModelSamplingAV`, stock Euler is not a substitute for the manual dual-clock path. Current ComfyUI is the exception because core performs the AV flow transform natively. `Euler + Beta`, `res_multistep`, and hand-written sigma lists are still not the recommended baseline.

## Compatibility

Base weights and official workflow templates are published at [Comfy-Org/MiniMax-H3](https://huggingface.co/Comfy-Org/MiniMax-H3).

| Base model | Status with this Turbo LoRA |
|---|---|
| `minimax_h3_fl2va_bf16.safetensors` | Best match to the author's validation environment |
| `minimax_h3_fl2va_int8_convrot.safetensors` | Locally tested and recommended when resources matter |
| `minimax_h3_fl2va_pruned_bf16.safetensors` | Not recommended; AdaLN LoRA targets are incompatible |
| `minimax_h3_fl2va_pruned_int8_convrot.safetensors` | Not recommended; AdaLN LoRA targets are incompatible |
| FL2VA pruned FP8 | Not validated |
| Ref2VA variants | Not officially validated by the LoRA author |

Precision and pruning are separate questions. A full INT8 ConvRot model retains the original logical layer structure and can use the bypass LoRA path. The checked pruned files replace full AdaLN projections shaped `(96768, 2688)` with low-rank representations shaped `(96768, 8)`. The Turbo LoRA targets the original full projections, so 50 transformer blocks plus the final layer report shape mismatches. A pruned model may continue running, but part of the LoRA is not being applied correctly and community users have reported degraded audio.

### Required model files

A typical FL2VA tree is:

```text
ComfyUI/
└─ models/
   ├─ diffusion_models/
   │  └─ minimax_h3_fl2va_int8_convrot.safetensors
   ├─ text_encoders/
   │  └─ qwen3vl_32b_minimax_h3_bf16.safetensors
   └─ vae/
      ├─ minimax_h3_video_vae_fp16.safetensors
      └─ minimax_h3_audio_vae_fp32.safetensors
```

The official INT8 ConvRot text encoder is also a reasonable lower-memory choice. This Turbo LoRA patches the diffusion model only, not the text encoder.

## Which Turbo LoRA file to download

Source: [larryvrh/MiniMax-H3-Turbo-Lora](https://huggingface.co/larryvrh/MiniMax-H3-Turbo-Lora/tree/main)

| File | Recommendation |
|---|---|
| `minimax_h3_turbo_4step.safetensors` | Use this first. It is crisper and holds up better on fast motion. |
| `minimax_h3_turbo_4step_ema.safetensors` | Smoother, but the current EMA is immature and may look soft. |
| `experimental_step_149.bin` | Do not download for normal inference. |
| `experimental_step_490.bin` | Do not download for normal inference. |

The two safetensors files are displayed as roughly 780 MB each on Hugging Face. The two experimental `.bin` files are 10.9 GB each and are not ordinary ComfyUI LoRA files.

## Installation

Clone this repository into `ComfyUI/custom_nodes`:

```bash
cd ComfyUI/custom_nodes
git clone https://github.com/shuaixn/ComfyUI-MiniMaxH3DualClockSampler.git
```

Or copy the repository folder manually to:

```text
ComfyUI/custom_nodes/ComfyUI-MiniMaxH3DualClockSampler/
```

The runtime node only needs `__init__.py` and `dual_clock_sampler.py`. The converter and tests do not run during generation. Fully restart ComfyUI after installation, then search for:

```text
MiniMax H3 Dual-Clock Euler
```

The stable ComfyUI node type is `MiniMaxH3DualClockEulerSampler`.

## Convert the author's LoRA for ComfyUI

### Why conversion is needed

The original checkpoint uses keys such as:

```text
blocks.0.attn.qkv_proj.lora_A.weight
```

Native ComfyUI expects:

```text
diffusion_model.blocks.0.attn.qkv_proj.lora_A.weight
```

The included converter only adds `diffusion_model.` where missing. It does not change tensor data, dtype, shape, rank, or scale. It also preserves safetensors metadata and validates the written file.

The current non-EMA checkpoint contains 518 tensor keys and 259 LoRA A/B pairs.

### Inspect without writing

```bash
python convert_h3_lora_for_comfyui.py \
  /path/to/minimax_h3_turbo_4step.safetensors \
  --check-only
```

Expected summary for the author's original file:

```text
Tensor keys: 518
LoRA A/B pairs: 259
Already prefixed: 0/518
```

### Convert

```bash
python convert_h3_lora_for_comfyui.py \
  /path/to/minimax_h3_turbo_4step.safetensors \
  /path/to/ComfyUI/models/loras/minimax/minimax_h3_turbo_4step_comfyui.safetensors
```

Example for a bundled Windows Python layout:

```powershell
D:\AI\ComfyUI\py313\python.exe .\convert_h3_lora_for_comfyui.py `
  "D:\Downloads\minimax_h3_turbo_4step.safetensors" `
  "D:\AI\ComfyUI\models\loras\minimax\minimax_h3_turbo_4step_comfyui.safetensors"
```

Official Windows portable builds commonly use a path such as
`C:\ComfyUI_windows_portable\python_embeded\python.exe` instead.

The converter:

- refuses to use the same path for input and output;
- refuses to overwrite by default;
- verifies LoRA A/B pairs;
- preserves checkpoint metadata;
- writes a temporary file and validates it before replacement;
- checks that every output key has the correct prefix;
- checks that the tensor count is unchanged;
- verifies every output tensor's dtype and shape against the input.

Use `--force` only when you intentionally want to replace an existing converted file. Keep roughly 1 GB of free disk space during conversion. Once the converted checkpoint has loaded without key errors and completed a generation, storage-sensitive users may archive or remove the original duplicate.

## Workflow wiring

Start from an official template:

- [I2V](https://github.com/Comfy-Org/workflow_templates/blob/main/templates/video_minimax_h3_i2v.json)
- [T2V](https://github.com/Comfy-Org/workflow_templates/blob/main/templates/video_minimax_h3_t2v.json)
- [R2V](https://github.com/Comfy-Org/workflow_templates/blob/main/templates/video_minimax_h3_r2v.json)

Current ComfyUI can keep the official advanced sampling section and set `KSamplerSelect` to `euler`. To preserve an old workflow or support legacy ComfyUI, replace only `KSamplerSelect` with this compatibility node:

```mermaid
flowchart LR
    UNET["Full non-pruned FL2VA DiT"] --> LORA["Load LoRA Bypass Model Only\nstrength 1.0"]
    LORA --> GUIDE["BasicGuider"]
    LORA --> SCHED["BasicScheduler\nsimple / 4 steps / denoise 1.0"]
    NOISE["RandomNoise"] --> ADV["SamplerCustomAdvanced"]
    GUIDE --> ADV
    SCHED -->|SIGMAS| ADV
    DUAL["MiniMax H3 Dual-Clock Euler"] -->|SAMPLER| ADV
    LATENT["MiniMax H3 AV latent"] --> ADV
```

Detailed steps:

1. Load a full, non-pruned FL2VA DiT.
2. Connect it to `Load LoRA (Bypass, Model Only)`.
3. Select the converted `_comfyui.safetensors` checkpoint.
4. Set model strength to `1.0`.
5. Send the patched model to both `BasicGuider` and `BasicScheduler`.
6. Current ComfyUI: keep `KSamplerSelect` on `euler`, or replace it with this compatibility node.
7. When using this node, connect its `SAMPLER` output to `SamplerCustomAdvanced.sampler`.
8. Keep `BasicScheduler` on `simple`, 4 steps, denoise 1.0.
9. Keep the official MiniMax-H3 conditioning, AV latent, video VAE, audio VAE, and video assembly wiring unchanged.

### Why the bypass LoRA loader matters

The author's native path evaluates:

```text
output = base(x) + B(A(x))
```

The LoRA update remains a separate activation-space path instead of being folded into the base weight. The author notes that small updates can be rounded away when folded into large BF16 weights; a separate path is also the appropriate approach for the current INT8/mixed-precision ComfyUI setup.

## Parameters

### Reproducible baseline

```text
sampler: stock euler (current) or MiniMax H3 Dual-Clock Euler
scheduler: simple
steps: 4
denoise: 1.0
LoRA strength: 1.0
guider/CFG baseline: 1.0
video shift: 12
audio shift: 3
```

The legacy path fixes the shifts at 12/3. The current native path uses the H3 shift settings maintained by ComfyUI core.

### Step-count guidance

| Steps | Suggested use |
|---:|---|
| 4 | Fast preview or speed-first final output; coherent audio may still be rougher than 20 steps. |
| 8 | Recommended quality/speed balance; the author says it is a little cleaner. |
| 10 | Additional quality testing; community users report results approaching 20 steps. |
| 20 | Native base-model quality baseline; disable the Turbo LoRA for a clean comparison. |

Only change `BasicScheduler.steps`. Current ComfyUI uses stock Euler; the legacy node path validates the full sigma schedule and rebuilds the author's grid. Keep `simple` and `denoise = 1.0` for the four-step Turbo baseline.

Community posts recommending LoRA strength around 1.8–2.2 were based on an earlier stock Euler + Beta workaround. The author's checkpoint has `alpha == rank`, so its native scale is `1.0`. Start at 1.0 and tune only after establishing a clean baseline. Increasing LoRA strength cannot repair a wrong audio schedule.

Avoid `res_multistep` for the four-step baseline. Users have reported colored flashes or “disco lights.” Start with stock Euler or this compatibility node.

## Algorithm

### Current native ComfyUI path

Since ComfyUI `bdcb886`, MiniMax-H3 uses `ModelSamplingAV`. Core carries the audio latent onto the video sampling coordinates using the configured video/audio shifts, restores the stream's own latent and timestep for the model forward pass, and transforms the output back to the shared coordinates. Stock samplers can therefore advance the packed AV Tensor correctly. When this class is available, the compatibility node returns `comfy.samplers.sampler_object("euler")` and does not apply the legacy slope correction again.

The formulas and packed-latent unpacking below describe only the legacy fallback.

The author defines the shifted flow grid as:

```text
shift_sigma(u, s) = s*u / (1 + (s - 1)*u)
σv[i] = shift_sigma(1 - i/n, 12)
```

At four steps this is approximately:

```text
[1.0000, 0.9730, 0.9231, 0.8000, 0.0000]
```

Legacy ComfyUI's `ModelSamplingFlux` and the author's script do not parameterize `shift` in exactly the same way, so the fallback rebuilds the author's grid and updates `transformer_options["sample_sigmas"]` before its Euler loop.

The video sigma is mapped back to the common base clock and then forward to audio shift 3. Let `slope = dσa / dσv`. The model returns audio velocity already multiplied by this slope.

Stock flat Euler approximately performs:

```text
xv_next = xv + Δσv * ov
xa_next = xa + Δσv * oa_scaled
```

The dual-clock update is:

```text
oa_raw = oa_scaled / slope
xv_next = xv + (σv_next - σv) * ov
xa_next = xa + (σa_next - σa) * oa_raw
```

This is why a sigma-list node by itself is insufficient: the sampler must recover the raw audio velocity and use a different delta for the packed audio region.

### ComfyUI packed latent handling

MiniMax-H3 conditioning creates a `NestedTensor(video, audio)`. Before calling a sampler, ComfyUI flattens the streams into a packed `[batch, 1, values]` Tensor and preserves the original shapes in guider conditioning metadata. This node reads those shapes, unpacks both streams for each Euler update, and repacks the result. No ComfyUI core files are modified.

## Verification

A current ComfyUI run through this compatibility node logs:

```text
[MiniMaxH3DualClock] Native ComfyUI AV sampling detected; delegating to stock Euler.
```

A legacy run logs:

```text
[MiniMaxH3DualClock] Euler sampling with video shift 12.0, audio shift 3.0, steps 4, video shape (...), audio shape (...)
```

Also verify that:

- there are no repeated `lora key not loaded` messages;
- there are no repeated `adaln_proj.linear.weight` shape errors;
- audio is coherent rather than blown out or noise-like;
- an eight-step render with the same seed is usually cleaner than four steps.

Direct use of stock `KSamplerSelect: euler` does not emit a plugin marker and is expected on current ComfyUI.

## Troubleshooting

### `lora key not loaded`

You probably loaded the original unprefixed checkpoint. Run `--check-only`; a converted file should report `Already prefixed: 518/518`.

### `adaln_proj.linear.weight shape '[96768, 8]' is invalid`

You selected a pruned base model. Switch to full FL2VA BF16 or full FL2VA INT8 ConvRot. Do not treat a run that ignores 51 AdaLN errors as the complete Turbo LoRA result.

### `requires a two-stream NestedTensor ... latent has type Tensor`

This came from an early version of this plugin. Update the repository and fully restart ComfyUI. The current version handles ComfyUI's packed Tensor sampler input.

### `cannot import name 'time_shift_slope'`

ComfyUI has native `ModelSamplingAV`, but the plugin checkout is old. Update this repository and fully restart ComfyUI. The current plugin no longer imports the removed helper and delegates to stock Euler on native builds.

### `requires a full denoise schedule starting at sigma 1.0`

The input is a truncated schedule, usually because `denoise < 1`. Restore `BasicScheduler` with `simple`, `denoise = 1.0`, and 4 or 8 steps. Do not connect reversed or truncated sigmas. Intermediate values are rebuilt internally, so Beta, Karras, and hand-written sigma lists provide no benefit.

### `only supports the validated MiniMax H3 shifts`

Another model patch changed the H3 video or audio shift through `transformer_options`. Remove that override; the current Turbo LoRA path is validated only for video 12 and audio 3.

### Video is fine but audio is clipped or noise-like

Check the dual-clock log marker, sampler connection, `simple` scheduler, strength 1.0, non-pruned base, and the official FP32 audio VAE. Temporarily disable other LoRAs and cache/approximation patches for isolation.

### Audio works at four steps but sounds worse than 20 steps

That is an expected speed/quality tradeoff for this early preview checkpoint. Change the step count to 8 while keeping the same sampler.

### Colored flashes or “disco lights”

Remove `res_multistep` and return to this node plus `simple` at 4 or 8 steps.

### Node is missing

Check that `__init__.py` is directly inside the plugin folder, avoid a duplicated nested repository folder, and fully restart ComfyUI. Inspect startup logs for a custom-node import error.

## Development and tests

The runtime node uses only dependencies already shipped with ComfyUI: PyTorch, tqdm, ComfyUI sampler utilities, and MiniMax-H3 schedule helpers.

The test suite covers:

- delegation to stock Euler when native AV sampling exists;
- retention of the legacy dual-clock sampler on older ComfyUI;
- the author's four-step sigma grid;
- replacement of current ComfyUI `simple` intermediate sigmas before model calls;
- a state-dependent velocity field compared with the author's two-tensor reference loop;
- independent video and audio integration;
- ComfyUI packed Tensor unpack/repack behavior;
- H3 shape metadata lookup through multiple `inner_model` wrappers;
- callbacks with an audio-clock-correct x0;
- invalid, out-of-range, reversed, and truncated sigma schedules;
- incompatible model-side shift overrides;
- clear failure when H3 shape metadata is missing.

Run tests with the Python bundled with your ComfyUI installation while putting the ComfyUI root on `sys.path`. See the Chinese README for a Windows command example.

## Known limitations

- Current ComfyUI has replaced the manual sampler path with native AV support; the plugin mainly preserves old workflows there.
- The legacy fallback only accepts joint MiniMax-H3 video/audio latents and is not a general-purpose Euler sampler.
- The legacy fallback fixes shifts at 12/3 and supports only full sigma 1-to-0 schedules with `denoise = 1.0`; current behavior otherwise follows ComfyUI core.
- The author officially validates full BF16 FL2VA. Full INT8 ConvRot is locally validated but is not bit-exact with BF16.
- Ref2VA, GGUF, FP8, pruned checkpoints, and future architecture variants are outside the current support promise.
- Correct scheduling removes schedule-induced audio explosions; it does not make a four-step preview checkpoint equal to the full detail of a normal 20-step generation.

## Credits and licenses

- Turbo LoRA and reference sampler: [larryvrh/MiniMax-H3-Turbo-Lora](https://huggingface.co/larryvrh/MiniMax-H3-Turbo-Lora)
- ComfyUI model repack and workflow templates: [Comfy-Org/MiniMax-H3](https://huggingface.co/Comfy-Org/MiniMax-H3)
- Original model: [MiniMaxAI/MiniMax-H3](https://huggingface.co/MiniMaxAI/MiniMax-H3)
- ComfyUI: [comfyanonymous/ComfyUI](https://github.com/comfyanonymous/ComfyUI)
- The prefix-conversion idea was shared in [discussion #6](https://huggingface.co/larryvrh/MiniMax-H3-Turbo-Lora/discussions/6); this repository's converter adds metadata, pair, overwrite, and post-write validation.

This repository's source code is released under the [Apache License 2.0](LICENSE). The Turbo LoRA model card also currently declares Apache-2.0, while MiniMax-H3 uses its own community license. Review the current upstream terms before downloading, using, or redistributing any weights. This source-code license grants no additional rights to third-party model files.

## Issue report template

Please include:

```text
ComfyUI commit/version:
GPU / VRAM:
Exact base model filename:
Text encoder filename:
LoRA filename and strength:
Bypass Model Only used: yes/no
sampler / scheduler / steps:
Other LoRAs or cache/attention patches:
[MiniMaxH3DualClock] log line:
Full stack trace:
```

Do not attach copyrighted model weights to issues.