SECourses Musubi Tuner - 1-Click to Install App for LoRA Training and Full Fine Tuning Krea 2, Ideogram 4, Qwen Image, Qwen Image Edit, Wan 2.1 and Wan 2.2, FLUX Klein, FLUX 2, Z Image, LTX 2.3, MiniMax H3 and Turbo Models with Musubi Tuner with Ready Presets (Patreon)

Patreon exclusive posts index to find our scripts easily, Patreon scripts updates history to see which updates arrived to which scripts and amazing Patreon special generative scripts list that you can use in any of your task.

Join discord to get help, chat, discuss and also tell me your discord username to get your special rank : SECourses Discord

Please also Star, Watch and Fork our Stable Diffusion & Generative AI  GitHub repository and join our Reddit subreddit and follow me on LinkedIn (my real profile)

=======

Latest Zip File : SECourses_Musubi_Trainer_v34.zip

[click here to choose a membership and Join to download zip files]

Main training tutorial to learn training and how to use this app (mandatory to watch) : https://youtu.be/DPX3eBTuO_Y

Wan 2.2 training tutorial : https://youtu.be/ocEkhAsPOs4

SwarmUI : https://www.patreon.com/posts/114517862

ComfyUI : https://www.patreon.com/posts/105023709

=======

Currently 1-click to install on Windows, RunPod and Massed Compute with uv installation - ultra fast

We have model auto downloader that supports below models (run Windows_Download_Training_Model_Files.bat)

The following models have full Fine Tuning / DreamBooth and LoRA training with fully supported Torch Compile (really speeds up training up to 58% with no tradeoff)

All Qwen Image Models, FLUX 2 Dev, FLUX 2 Klein 4B and 9B, Z-Image Base, Z-Image Turbo, Ideogram 4, Krea 2 Raw, Krea 2 Turbo

Also has automatic Qwen VL captioning

The following models only supported with LoRA training with fully supported Torch Compile (really speeds up training up to 58% with no tradeoff)

All Wan 2.1/2.2 variants, LTX 2.3 with audio, MiniMax H3 with Audio, First-Frame, Last-Frame and References

Please use model downloader to not have any issues because your selected models may be wrong

Moreover, the Musubi Tuner automatically does FP8 and FP8 scaled or Int8 ConvRot (my special addition) conversion while loading BF16 model into RAM so we always use BF16 models for training

Our model downloader is ultra optimized and can reach 1GB per second on cloud machines

It also has SHA256 verification to ensure no corrupt model ever used

We are using our own fork of Musubi Trainer does it has many more features and improvements

The installers will generate a Python 3.12 VENV automatically and install everything inside there, thus your system or any other of your APPs will never be impacted

With our pre-compiled abi3 wheels for Windows and Linux, you can run on Python 3.10, 3.11, 3.12 and 3.13 but may require extra work so use Python 3.12.x

The following libraries compiled for Windows and Linux

archs : mslk, xformers, flash_attn, sageattention, torchao,

All of them are abi3 and Windows versions are compiled for Consumer GPUs, Linux versions compiled for Consumer + Cloud GPUs - so we cover all GPUs you have

Windows Requirements

For this auto installer to work you need to have installed Python 3.12.10, Git, FFmpeg, cuDNN 9.17+, CUDA 13.0, Visual Studio Community Edition with All c++ options

Follow this requirements tutorial video exactly : https://youtu.be/DrhUHnYfwC0

Follow its updated post with links and screenshots exactly : https://www.patreon.com/posts/windows-AI-requirements-tutorial-111553210

14 August 2026 Version 34.0 Update

🎬 Full MiniMax H3 Video + Audio Training Added

Brand-new MiniMax H3 Video Training tab.

Supports T2VA, first/last-frame FL2VA, and reference-to-video Ref2VA LoRA training.

Complete one-click pipeline: dataset generation → video/audio latent caching → Qwen3-VL text-embedding caching → training.

Joint audio supervision from embedded audio or matching .wav files. Silent videos are not incorrectly trained toward silence.

Dataset rules are handled automatically: batch size 1, valid 17n+5 frame counts, 24 FPS normalization, and 32-pixel resolution steps.

Guidance-distillation protection is enabled by default to help preserve H3’s CFG-distilled behavior.

Advanced teacher matching with both:

first,last endpoint conditioning.

New ref self-reference teacher with stronger teaching signals and real audio targets.

Exposes sigma protection, timestep focus, DC/magnitude shaping, audio-loss weighting, and video-only controls.

💾 Consumer-GPU Memory Support

Automatic support for the approximately 21 GB pruned ConvRot INT8 H3 transformer.

NVFP4+AWQ Qwen3-VL text encoder support with layer-by-layer CPU streaming.

Up to 48/50 H3 transformer blocks can be swapped using H2D-only block swapping.

Full BF16 checkpoints can use on-the-fly ConvRot INT8 and AdaLN pruning.

Direct loading of compatible ComfyUI pre-quantized ConvRot INT8 checkpoints.

Unsupported H3 FP8 configurations are now blocked with a clear error.

📦 Models and Ready-to-Use Presets

New MiniMax H3 Training Models – Low VRAM downloader bundle.

Optional higher-quality ConvRot INT8 text encoder and Ref2VA transformer downloads.

New tested demo presets:

24 GB preset: 384px, 124 frames, measured at 22.5 GB peak on an RTX 3090.

Lowest-VRAM preset: 256px, 124 frames, heavy block swapping, measured around 8.5 seconds/iteration on an RTX 5090.

⚡ LTX 2.5 Quantization

New LTX 2.5 model preset in the Model Quantizer.

Converts original BF16 dev or distilled models into an approximately 22 GB ComfyUI-ready mixed BF16/INT8 ConvRot checkpoint.

Automatically detects the model variant.

Applies the benchmark-validated video layer plan.

Performs per-layer ConvRot group-size selection and architecture validation.

Produces a detailed JSON quality report.

Older V32.4 LTX 2.5 workflow configurations are migrated automatically.

🧰 Model Quantizer Improvements

Added or improved profiles for Qwen VLM/Qwen3.5+, Chroma/Distilled, Mistral, NeRF, Radiance, Visual Encoder, and other architectures.

Qwen VLM protection now dynamically handles the final language layer, embeddings, MTP weights, and the visual stack.

Added BF16/FP16 output-dtype selection.

Added regex controls for layers that must preserve their original dtype.

Quantizer panels now appear only when relevant to the selected workflow.

Preset and workflow switching is more consistent.

Improved pre-quantized ConvRot checkpoint validation and mixed group-size handling.

🛡️ Critical Full Fine-Tuning Safety Fix

Configuration loading is now safer across FLUX, FLUX.2, FLUX Klein, Qwen Image, Z-Image, Ideogram 4, and Krea 2.

Runtime TOMLs now preserve whether the run used LoRA or Full Fine-Tuning/DreamBooth.

Older configurations can infer the correct mode from their network settings.

Loading a failed or saved full-finetune run no longer silently switches it back to LoRA.

LoRA and Full Fine-Tuning panels now update correctly after loading a configuration.

🔧 Reliability Improvements

Fixed H3 FlashAttention 2 dtype handling.

Fixed CPU-offloaded activations before the H3 final layer.

Fixed H3 condition-noise random-number aliasing.

Improved audio timestamp-jitter recovery.

Improved JSONL relative-path resolution.

Added official MiniMax H3 processor/configuration handling.

Fixed end-to-end H3 dataset validation and flash_auto launch support.

Expanded regression coverage across configuration round-trips, caching, quantization, teacher matching, and dataset generation.

New training tab interface below

Updated model downloader bat file interface below

Demo presets folder screenshot below

Download latest zip file, extract, overwrite all, run Windows_Install_and_Update.bat and use newest preset tomls for updating or fresh install

13 August 2026 Version 32.3 Update

A bug in FLUX 2 Klein training fixed and related demo presets updated

Extract, overwrite all, run Windows_Install_and_Update.bat and use newest preset tomls

3 August 2026 Version 32.1 Update

Interface fully modernized and upgraded — every screenshot in this post shows the new look.

LTX 2.3 full training capability implemented with demo preset — even higher quality and faster INT8 ConvRot base training supported, same as Krea 2.

Now even if you forget to write 1_folder_name (the repeating number) in dataset preparation, the app counts it automatically as 1 repeat and tells you exactly how to set it explicitly.

Automagic optimizers now fully working — ported from the famous Ostris AI Toolkit (details below).

Full version history is now inside the Gradio app — Version History tab.

The post is fully updated so please read all. To update: get the latest zip file, overwrite previous files and run Windows_Install_and_Update.bat.

LTX 2.3 is unusual among supported families — a single checkpoint carries the DiT transformer, video VAE, audio VAE, vocoder and text-encoder connector weights. The app handles the whole pipeline for you, including the 8k+1 valid frame rule and FPS resampling — here is the built-in explanation of how LTX 2.3 training works:

Automagic optimizers — which one should you pick? Automagic is an experimental family of adaptive optimizers originally from Ostris AI Toolkit, integrated into this trainer — and not limited to Krea 2: it is available for Qwen Image, Wan, FLUX, Z-Image, Ideogram 4, Krea 2 and LTX 2.3 training.

Automagic3 — the recommended starting point. It automatically selects the correct operating mode: fused updates when your configuration is compatible, safe non-fused updates when you use gradient accumulation / clipping or other incompatible features (with a warning), and a compact sign-history state for its adaptive learning rate. Choose Automagic3 when unsure.

Automagic2 — lowest gradient memory, strict requirements. It updates parameters during backward propagation, so it needs: one GPU and one process, Gradient Accumulation Steps = 1, Max Gradient Norm = 0, BF16 or no mixed precision (FP16 unsupported), Fused Backward Pass disabled (it manages its own) and Patch Optimizer for Block Swap disabled. If your configuration is incompatible, the trainer stops before loading the model and explains exactly which settings to change.

Automagic v1 — the most detailed adaptive state. Adafactor-style second moment plus an adaptive per-element learning-rate mask; supports normal stepping, gradient accumulation, clipping and block swapping, at somewhat higher optimizer memory.

Learning-rate behavior: for all Automagic versions the Learning Rate you set is only the starting rate — Automagic adapts it during training and bypasses external schedulers. Start from the model preset values, don't copy AdamW rates.

Tested successfully with ConvRot (BF16 and INT8 backward) and Scaled FP8 base quantization.

SECourses Musubi Trainer Premium App Full Features

Why This App Exists

Kohya's Musubi Tuner is the best training backend in the open-source world — but out of the box it is a command-line tool: hand-written TOML files, manual model downloads, manual wheel compilation, and no Windows Torch Compile. I maintain my own fork of Musubi Tuner and wrapped it in a complete product: a full GUI, 1-click installers for Windows and every major cloud, an ultra-fast verified model downloader, researched configs for every GPU tier from 6 GB to 96 GB, and performance work that makes trainings up to 53% faster at identical quality.

This is not a thin wrapper. Every feature of Musubi Tuner is exposed — 100% parameter coverage — plus dozens of features that exist only here: INT8 ConvRot quantized training, LTX 2.3 video training, guarded Windows SDPA acceleration, a model quantizer that beats GGUF Q8 quality, Automagic optimizers, and much more. It is updated constantly: 43 releases shipped in 11 months.

Up to 53% Faster Than Stock Musubi Tuner — Zero Quality Loss

I pre-compiled the entire acceleration stack myself (FlashAttention, SageAttention, xFormers, TorchAO, mslk — for Torch 2.13 + CUDA 13.1, abi3 wheels working on Python 3.10–3.13, on consumer and datacenter GPUs), and built an automatic Torch Compile toolchain that discovers and validates your MSVC/CUDA environment on Windows, caches the result for 30 days, and falls back safely if anything fails. The result — measured model by model against default Musubi Trainer settings, same exact output quality:

Z-Image Base / Turbo : 53% faster · FLUX Klein 9B : 46% · Qwen 2511 Edit : 40% · Krea 2 : 36% · Qwen 2512 : 24.5% · Wan 2.1 : 22% · FLUX 2 Dev : 15.6% · Wan 2.2 : 15% · Ideogram 4 : 14%

All of it works out of the box on Windows and Linux — no compiler setup, no environment variables, no praying.

On Krea 2 and LTX 2.3 you can stack the exclusive INT8 ConvRot quantized training on top — the measured speed table is in the Krea 2 section below.

Every Model. One App.

Full Fine-Tuning / DreamBooth and LoRA for all major image models, LoRA for Wan and LTX video models — every single one with fully working Torch Compile:

The Presets We have in the Zip File and the Automatic Installers

Everything in this post ships as one zip file. Extract it and you get the 1-click installers for Windows, RunPod, SimplePod and Massed Compute, the model downloader (Windows_Download_Training_Model_Files.bat / Download_Train_Models.py), the app starter, the instruction files for every cloud — and every researched preset folder shown below:

Ready demo presets for every model family — FLUX 2 (LoRA + Fine-Tuning), FLUX Klein 4B / 9B, Ideogram 4, Krea 2 (including the High-VRAM INT8 ConvRot variant), LTX 2.3, Wan 2.1 and Z-Image Base / Turbo. Load one, point it at your dataset, press Start:

The full Qwen research config library — separate LoRA_Training and Fine_Tuning_Training-DreamBooth tiers for every GPU class, plus complete example datasets for regular training and for Qwen Image Edit control-image training, and a Tutorial_Workflow.html reference:

A ready-made prompt library for testing your trainings — demo prompt sets for style / character / product trainings, Gemini prompt-generator templates, and Grid_Find_Best_Checkpoint prompt files you use to X/Y-grid your saved checkpoints and find the best epoch:

The official Wan 2.2 config sets — Text-to-Video, Image-to-Video and Text-to-Image folders distilled from my 64+ research trainings, with a Configs_Explanation guide image:

The Grand Tour — All 14 Tabs, With Real 4K Screenshots

1 — Qwen Image Training

The flagship tab. Trains Qwen Image, the new Qwen 2512, and Qwen Image Edit Plus 2509 / 2511 (with up to 3 control images and one-click auto-generated control images). LoRA and Full Fine-Tuning / DreamBooth, backed by my research of over 50 complete trainings — the resulting configs cover every GPU from 6 GB to 96 GB in quality tiers, so you load a preset matching your VRAM and press Start.

And this is what one single tab actually contains — every Musubi Tuner parameter, organized, documented with tooltips, and searchable. You never touch a TOML file by hand again. Here is the Qwen tab, section by section:

Configs, Accelerate & checkpointing — preset save / load, the settings search bar, Accelerate launch options (multi-GPU, mixed precision) and complete checkpoint save / resume / retention management:

Dataset preparation — point it at a Kohya-style folder (e.g. 1_ohwx man) and the full dataset TOML is generated for you, including Qwen Edit control-image modes and automatic caption file creation. And if you forget the repeat-count prefix on a folder, the app does not silently guess: it counts the folder as 1 repeat and tells you exactly how to name it to set repeats explicitly:

Model settings, Torch Compile & caching — BF16 model paths with auto-fill, FP8 base + Scaled FP8, Edit / Edit-Plus modes, Torch Compile controls, latent and text-encoder output caching:

Optimizers, scheduler & LoRA — the full optimizer catalog including Automagic 1/2/3 with per-optimizer guidance, learning-rate schedulers, and every LoRA architecture option (DyLoRA, LoRA-FA, custom modules):

Training settings & sample generation — epochs / steps, attention backends, block swap, gradient checkpointing, and live sample image generation during training:

Advanced, metadata & Hugging Face — flow matching and timestep sampling, SwarmUI auto-detection metadata, direct Hugging Face checkpoint upload, and the one-click training start:

2 — Wan Models Training

Everything Wan: 2.1 and 2.2, Text-to-Video, Image-to-Video, Text-to-Image, FramePack and Fun-Control — including proper dual-model Wan 2.2 training with smart CPU/GPU offloading. My Wan 2.2 configs come from 64+ research trainings analyzed on an 8x B200 machine, published for literally every GPU tier.

The Wan tab is the deepest video-training UI in the app — here it is, section by section:

Configs, Accelerate & checkpointing — preset save / load, instant settings search, Accelerate multi-GPU launch, output naming, exact training resume from saved states, LoRA save precision and checkpoint retention (save every N epochs / steps, keep last N, save state on train end):

Video dataset preparation — point it at Kohya-style folders of videos and/or images and the full dataset TOML is generated: frame extraction method (head / chunk / slide / uniform), Frame Stride, Frame Sample Count, Target Frames with Auto Normalize (scans your videos and clamps Target Frames to the shortest one so no clip is silently skipped), Maximum Frames, Source FPS override and automatic caption file creation:

The built-in Complete Wan Dataset Guide — a full reference rendered right inside the tab: the N*4+1 valid frame-count rule, optimal resolutions per model, video / image / mixed dataset folder structures, multiple datasets with different repeat counts, model-specific dataset recommendations (T2V, I2V, T2I, FLF2V, Fun-Control), automatic frame processing behavior, supported file formats and the experimental One Frame Training mode — you never need to leave the app to look any of this up:

Wan model settings — every Wan variant in one dropdown (T2V 1.3B / 14B, I2V, T2I, FLF2V, Fun-Control) with per-model max block swap limits, the Wan 2.2 dual-model system (high-noise + low-noise DiT paths with automatic timestep boundary switching and inactive-model CPU offload), DiT / VAE / T5 / CLIP paths with browse buttons and auto-fill, FP8 base + Scaled FP8 + FP8 T5, block swap with pinned-memory and H2D-only modes, VAE tiling / chunking, and Torch Compile with resident-blocks-only compilation for block-swapped training:

Advanced timestep sampling, loss weighting & CUDA — timestep sampling methods with Discrete Flow Shift guidance per model (Wan 2.2 T2V-A14B needs 12.0, I2V-A14B needs 5.0, Wan 2.1 needs 1.0 — the tooltip tells you), min / max timestep focus training, stratified timestep buckets for small datasets, loss weighting schemes (logit normal, mode), TF32 and cuDNN benchmark switches, and memory-efficient model-loading options:

Training, network, optimizer & caching — epochs / steps, attention backends (SDPA, FlashAttention, SageAttention, xFormers), gradient checkpointing, LoRA network dimension / alpha / dropout, the full optimizer + scheduler catalog, and separate latent-caching and text-encoder-caching controls with skip-existing and keep-cache behavior:

Samples, advanced, metadata & Hugging Face — live sample video generation during training from a prompt file, advanced flags, SwarmUI auto-detection metadata, direct Hugging Face upload, then one click on Start Training runs latent caching → text-encoder caching → training back-to-back:

3 — FLUX Training

FLUX 2 Dev and FLUX Klein 9B / 4B — LoRA and Full Fine-Tuning. LoRA from as low as 5.6 GB VRAM (Klein 4B, rank 128 at 1024px), 9.6 GB for Klein 9B, 18 GB for FLUX 2 Dev. Klein 9B trains 46% faster here than on the stock trainer.

Model family, dataset & model settings — one Model Family dropdown switches the whole tab between FLUX.2 Dev and Klein 9B / 4B, LoRA or Full Fine-Tuning modes, dataset TOML generation with optional control images (for FLUX.1 Kontext-style training), DiT / VAE / text-encoder paths with auto-fill, FP8 base / scaled / text-encoder options and per-model block swap limits (FLUX 2 Dev up to 29 blocks, Klein 9B 16, Klein 4B 13):

Torch Compile, training & sampling — Torch Compile backend / mode / dynamic shapes, flow matching and timestep settings, epochs / batch size / attention backends, live sample generation during training and latent + text-encoder caching controls:

Optimizer, LoRA & advanced — the full optimizer catalog with schedulers, LoRA rank / alpha / dropout, advanced flags, metadata and direct Hugging Face upload — then the one-click start:

4 — Z Image Training

Z-Image Base and Turbo, LoRA and Full Fine-Tuning from 6 GB VRAM — and the single biggest speed win of the whole app: 53% faster than stock. I published the first FP8 Scaled Z-Image Turbo model in the community using this very app's converter.

Configs, dataset & model settings — Base or Turbo checkpoints, LoRA or Full Fine-Tuning / DreamBooth, dataset TOML generation with automatic captions, FP8 options, block swap and complete checkpoint management:

Torch Compile, training & sampling — the 53%-faster Torch Compile pipeline, flow matching and timestep settings, epochs / batch / attention backends, live sample generation and full latent + text-encoder caching:

Optimizer, LoRA & advanced — optimizer + scheduler catalog, LoRA architecture settings, advanced flags, checkpoint retention, metadata and Hugging Face upload with the one-click start:

5 — Ideogram 4 Training

Ideogram 4 LoRA and Full Fine-Tuning with ready demo presets. Ideogram 4 loves structured JSON captions — and this tab is built for them: it pairs perfectly with my JSON-prompt captioning workflow (tutorial, Ultimate Image Captioner Pro).

Configs, dataset & model settings — LoRA or Full Fine-Tuning, dataset TOML generation with automatic captions and structured JSON-caption checking (your caption files are validated with clear warnings before training, not after a wasted run), model paths with auto-fill, FP8 options and Torch Compile:

Flow matching, training & sampling — flow matching and timestep settings, epochs / batch / attention backends, Ideogram sampler presets for live sample generation, loss diagnostics, caching and the optimizer catalog:

LoRA, advanced & Hugging Face — LoRA rank / alpha / dropout, advanced flags, SwarmUI metadata and direct Hugging Face upload with the one-click start:

6 — Krea 2 Training (with Exclusive INT8 ConvRot)

Krea 2 Raw and Turbo — LoRA and Full Fine-Tuning, 36% faster than stock. And Krea 2 is where I shipped something nobody else has: INT8 ConvRot quantized training.

ConvRot rotates the frozen base weights with a Hadamard transform before quantizing them to INT8, then runs the forward pass as a real fused Triton INT8 matmul. Scaled FP8 cannot do that — Krea 2's FP8 path has no FP8 matmul at all: it dequantizes the weights back to BF16 on every forward pass and then runs an ordinary BF16 matmul, which is why FP8 only saves VRAM and actually measures slower than BF16 once you are not bandwidth-starved. ConvRot's INT8 tensor-core path is a genuinely cheaper matmul — and INT8 tensor cores exist on every NVIDIA GPU from Turing onward, which finally makes Krea 2 fast on RTX 30 series cards that have no FP8 hardware at all.

Measured end-to-end training speed — real rank-128 LoRA runs at 1024×1024 through the GUI's own pipeline on an RTX 5090 (the shipped presets' exact settings; every number is the steady-state median over long runs):

Same VRAM class as FP8 (1 byte per base weight, and measured ~0.9 GB less peak VRAM than Scaled FP8), roughly 2.5x faster Linear forward than BF16 and 2.7x faster than Scaled FP8 in isolated kernel benchmarks — on both RTX 5090 and RTX 3090.

More accurate than Scaled FP8: mean per-step loss deviation from the BF16 reference is 0.273% for ConvRot (bf16 backward) vs 0.289% for FP8, and generated images deviate from BF16 by the same amount FP8's do (1.25 vs 1.23 grey levels out of 255).

The demo preset now ships with ConvRot INT8 as the default, and a new Krea_2_LoRA_Demo_High_VRAM.toml preset (blocks_to_swap = 16) collects 1.72x the throughput of the old FP8 default on 24 GB+ cards.

Works with block swap, gradient checkpointing and torch.compile — triton ships with the installer on both Windows and Linux.

Here is where it lives in the interface — the Model Settings row with the ConvRot INT8 checkbox and the bf16 / int8 backward selector:

Configs, dataset & INT8 ConvRot model settings — LoRA or Full Fine-Tuning, dataset TOML generation, and the model settings row where ConvRot INT8 lives: one checkbox plus a bf16 / int8 backward selector, next to FP8 Base + Scaled FP8, block swap up to 26 with H2D-only mode, and optional Turbo DiT for training-time samples. The GUI validates every illegal combination (ConvRot + FP8, ConvRot + Turbo sampling, ConvRot + Full Fine-Tuning) before anything launches:

Flow matching, training & sampling — flow matching and timestep settings with the Krea-2-specific shift schedule, epochs / batch / attention backends, live sample generation, caching and the optimizer catalog:

LoRA, advanced & Hugging Face — LoRA architecture settings, advanced flags, metadata and Hugging Face upload — a single click runs caching and training back-to-back:

7 — LTX 2.3 Video Training (NEW in V32)

The newest tab: full LoRA training for LTX-2 19B and LTX-2.3 22B text-to-video models — including audio-video joint training. The complete pipeline is chained behind one Start Training button: dataset TOML generation from your folders (the 8k+1 frame rule and 25 FPS resampling are handled for you), VAE latent caching, Gemma 3 12B text-encoder caching, then training. The demo preset trains a rank-128 LoRA on 24–32 GB GPUs, and the model downloader grabs the full ~59 GB model bundle with no gated-repo login needed.

Model, quantization & video dataset — LTX-2 19B / LTX-2.3 22B checkpoints with automatic version detection, Gemma 3 12B text encoder (single-file FP8 or HF folder with 8-bit / 4-bit loading), video / audio-video / audio-only training modality, first-frame conditioning probability, attention backends with split-attention VRAM control — and the richest quantization panel in the app: FP8 Base / Scaled with keep-blocks and W8A8 activations, INT8 ConvRot (quantize at load or load pre-quantized checkpoints, group size, MSE clip, per-layer quality report), NF4, block swap up to 47 blocks with pinned-memory and H2D-only modes, blockwise gradient checkpointing with CPU offload, and low main-RAM loading. Below it, the video dataset generator applies the 8k+1 frame rule, target FPS resampling and automatic captions:

Audio, caching, network & training — audio source selection (video container or external .wav) with separate audio buckets, VAE latent caching with spatial / temporal tiling and chunking, Gemma text-encoder caching with pre-connector features for connector LoRA training, LoRA network settings with target presets (t2v / audio / full) and automatic ComfyUI-format export alongside the musubi format, AdaFactor-tuned optimizer defaults, timestep sampling with shifted_logit_normal, and video sample generation during training with tiled VAE decode, sampling presets and optional audio merge into the preview mp4:

Logging, metadata & one-click start — TensorBoard / Weights & Biases logging, metadata, Hugging Face upload and the single Start Training button that chains VAE caching → text-encoder caching → training:

8 — Image Captioning

Automatic dataset captioning with Qwen2.5-VL, built in — and far deeper than a simple "caption my folder" button:

Single-image and batch captioning with recursive subfolder scanning, live progress, ETA and a safe stop button.

TXT and JSONL output formats — JSONL mode can optionally copy the images into a self-contained dataset, ready for structured-caption trainings like Ideogram 4.

FP8 model loading to fit the captioner on smaller GPUs, and automatic model unloading to release VRAM the moment captioning finishes — so you can go straight into training.

Full generation control: custom system prompt, temperature, top-k, top-p, repetition penalty and maximum tokens.

Caption post-processing rules: prefix, suffix and word replacements — applied in the right order so your trigger words always end up exactly where you want them.

Skip-existing or append-to-existing modes — recaption safely without destroying manual edits.

9 — Model Quantizer

Turn your trained checkpoints (or any base model) into deploy-ready quants: FP8 Scaled, INT8 ConvRot, NVFP4, MXFP8. The INT8 Row ConvRot HQ preset produces quants that are 96.2% similar to BF16 while GGUF Q8 manages only 90.0% — and they run about 2x faster than GGUF Q8 on RTX 3000 / 4000 / 5000. ComfyUI and SwarmUI load them natively. This is a full production quantization suite:

13 quality / workflow presets and around 20 model-family profiles — FLUX, Klein, Krea, Ideogram, Wan, LTX, Qwen, Z-Image, Hunyuan, ERNIE, Gemma, T5 and more — each with recommended exclusions and defaults baked in.

Learned ConvRot using SVD and Prodigy optimization, activation calibration and bias correction — the "Best Quality / Slow" preset that beats GGUF Q8.

Optional LoRA-informed calibration — quantize a base model with your LoRA's behavior taken into account.

Per-layer control: layer exclusions, sensitive-layer protection, mixed precision, dry-run analysis and automatic layer-template generation.

Single-file conversion queue and recursive folder batch conversion — both with cancellation — plus low-memory conversion controls for modest machines.

10 — LoRA Extractor

Extract a small, distributable LoRA out of any full fine-tuned / DreamBooth checkpoint — keep the full-quality fine-tune for yourself, ship the LoRA. Single-file and recursive batch extraction, configurable SVD rank and clamp quantile, device and precision selection, metadata preservation, and progress with cancellation:

11 — LoRA Merger

Merge up to three LoRAs simultaneously, each with its own independent multiplier — LoRA into LoRA, or bake LoRAs directly into a DiT base checkpoint. Single and recursive batch modes, model-specific profiles for Qwen, Wan, SkyReels and custom architectures, plus device and output-dtype controls:

12 — LoRA Converter

Move your LoRAs between ecosystems without touching a script: six bidirectional conversion profiles covering Diffusers, Musubi, ComfyUI and SwarmUI formats, dedicated HunyuanVideo 1.5 and Z-Image conversions, single-file and recursive folder batch processing:

13 — Image Preprocessing

A unique safety net: this tool runs your dataset through the actual Musubi Tuner training code and shows you exactly what the trainer will see — final resolutions, aspect ratios, bucketing decisions. It also catches the classic silent killer: EXIF-rotated images that would train sideways. Preview first, never waste a training run again.

14 — Version History

The full changelog of all 43 releases now lives inside the app — every version in its own collapsible section with an Open / Close All button, so you always know exactly what changed and when. This app is in constant, active development: what you subscribe to today keeps getting better every single week.

Preflight Guardrails — It Refuses to Waste Your GPU Time

The most expensive failure in training is the one you discover 20 minutes in — after caching, after model loading, after VRAM allocation. This app validates your configuration before any of that happens, with plain-language messages that tell you exactly what to change:

Invalid full-fine-tuning and quantization combinations are rejected before model loading.

FP8 conflicts are detected (e.g. fp8_base without fp8_scaled, FP8 + ConvRot).

Unsafe block-swap combinations and per-model block-swap limits are enforced.

Multi-GPU incompatibilities are caught before the run starts.

Optimizer and mixed-precision conflicts are explained before VRAM is allocated — including the strict Automagic2 requirements, with a recommendation to switch to Automagic3 when appropriate.

Krea 2 ConvRot conflicts with FP8, Turbo sampling and full fine-tuning are prevented outright.

1-Click Installation — Windows, RunPod, Massed Compute, SimplePod

Windows : run Windows_Install_and_Update.bat — that's it. The installer creates an isolated Python 3.12 venv (your system and other apps are never touched), and uses ultra-fast uv installation with my pre-compiled wheels. The same bat file also updates existing installs.

RunPod / SimplePod : follow Runpod_SimplePod_Musubi_Trainer_Instructions.txt — Python 3.12 is installed automatically. Installation is literally ~100x faster than pip thanks to uv.

Massed Compute & local Linux : follow Massed_Compute_Instructions_READ.txt.

Everything runs on Torch 2.13 + CUDA 13.1 with pre-compiled FlashAttention, SageAttention, xFormers, TorchAO and mslk — supporting effectively every NVIDIA GPU: RTX 3000 / 4000 / 5000, A40, L40S, A100, H100, B200 and more.

Windows Requirements

Python 3.12.10 (3.10 / 3.11 / 3.13 also work), Git, FFmpeg, cuDNN 9.17+, CUDA 13.0, Visual Studio Community Edition with all C++ options, NVIDIA driver 590+.

Follow this requirements tutorial video exactly : https://youtu.be/DrhUHnYfwC0

Follow its updated post with links and screenshots exactly : https://www.patreon.com/posts/windows-AI-requirements-tutorial-111553210

Cloud Registration Links

Massed Compute (recommended) : register here — special SECourses coupon : SECourses — how-to starts at 12:58 : https://youtu.be/KW-MHmoNcqo

RunPod : register here — how-to starts at 22:03 : https://youtu.be/KW-MHmoNcqo

SimplePod (cheaper than RunPod — RTX 5090 at $0.45/hr vs $0.89/hr) : register here — use our ready template — tutorial from 21:51 : https://youtu.be/yOj9PYq3XYM

Built-In Model Downloader — Never Hunt for Model Files Again

Run Windows_Download_Training_Model_Files.bat (or the cloud equivalents) and pick from 16 model bundles: all Qwen variants, Wan 2.1 / 2.2 T2V and I2V, FLUX 2 Dev, Klein 9B / 4B, Z-Image Base / Turbo, Ideogram 4, Krea 2 and LTX 2.3. Select several at once with comma lists or ranges — e.g. 1-3,5.

My own downloader engine (not the Hugging Face client): up to 16 parallel connections reaching ~1 GB/s on cloud machines, with an automatic aria2 → Python range-downloader → Hugging Face hub fallback chain, retry with exponential backoff, and resume that preserves partial downloads.

Integrity you can trust: SHA-256 (or Git-SHA) verification of every file, immutable Hugging Face revision pinning, and atomic installation — an incomplete file can never replace a good one. Already-verified local files are reused across model folders instead of re-downloading.

It protects your disk and your time: total download size is calculated and free disk space checked before anything starts; offline and force-redownload modes are available.

Always BF16 weights (best training quality) — Musubi converts to FP8 / FP8-scaled on the fly while loading, so you get low VRAM without keeping FP8 files around.

When you load any config, the app validates its model paths and auto-fills them from the downloader's default locations — on Windows, Linux and every cloud.

Researched Presets — Not Guesses

Qwen Image : LoRA + Fine-Tuning configs from my 50+ full training research runs, tiered from 6 GB to 96 GB GPUs, in 75 / 150 / 200-epoch quality variants (folder: Qwen_Training_Configs). 30+ result examples: see this article.

Wan 2.2 : official configs distilled from 64+ unique research trainings — Text-to-Video, Image-to-Video and Text-to-Image, for every GPU tier (folder: Wan22_Training_Configs).

Krea 2 : the demo preset ships with INT8 ConvRot as the default (faster and slightly more accurate than the old Scaled FP8 default at the same VRAM floor), plus the new Krea_2_LoRA_Demo_High_VRAM.toml for 24 GB+ cards at 1.72x the old throughput.

Everything else : ready demo presets for FLUX 2, Klein 4B/9B, Z-Image Base/Turbo, Ideogram 4 and LTX 2.3 (folder: Demo_Training_Configs_FLUX-2_Z-Image_FLUX-Klein_WAN-21_Krea2_Ideogram4).

Sample generation during training, TensorBoard / Weights & Biases logging with gradient statistics, exact mid-epoch training resume, checkpoint retention policies and direct Hugging Face upload are all built in.

Quality of Life You Will Not Find Anywhere Else

Search bar over 500+ settings — type "block swap" and jump straight to the option, no panel hunting.

Tooltips everywhere — every single parameter documented in plain language, with recommended values.

Config save / load with automatic validation, model-path auto-fix and cross-platform path normalization (spaces in paths just work).

Dataset folder safety — forget the N_ repeat prefix on a training folder and the generator counts it as 1 repeat and tells you exactly how to fix the name; a 0_ prefix (which would silently skip the dataset) is caught and corrected too, and every generated dataset reports its final num_repeats so you can verify at a glance.

Built-in dataset guides — the Wan tab renders a complete dataset reference (frame rules, folder structures, per-model recommendations) right inside the app.

Errors and warnings surface as Gradio notice bubbles — no more scanning terminal walls.

Accurate step-speed display almost immediately after training starts (fixed in my fork).

Automagic 1 / 2 / 3 optimizers (from Ostris AI-Toolkit) with adaptive learning rates — plus the full standard optimizer catalog, each with guidance and unsafe-combination validation before training starts.

Guarded SDPA acceleration on Windows — external FlashAttention is used only after passing real CUDA forward/backward probes, with automatic fallback, so you get maximum speed without mystery crashes.

The active quantization is always visible — training stdout states exactly which base quantization is live (e.g. "base weights quantized to ConvRot INT8 (224 Linears, fused Triton INT8 GEMM)"), so a silently slow fallback can never hide.

Who Am I and Why Trust This

I am Dr. Furkan Gözükara (PhD in Computer Engineering) — SECourses is my full-time work: tutorials, research and production-grade AI apps. This trainer alone has shipped 43 versions in 11 months, each one announced with full changelogs (now built into the app itself). My configs are not copied defaults — they come from hundreds of paid-GPU research trainings that I publish and document. When something breaks upstream, my fork usually has the fix before the issue is even triaged.

What Your Subscription Gets You

The full SECourses Musubi Trainer app with 1-click installers (this post's zip file, updated constantly).

All researched training configs — Qwen tiers, Wan 2.2 official configs, and demo presets for every supported model.

Every other SECourses app and script in the Patreon posts index — SwarmUI installers, ComfyUI installers, captioners, upscalers and much more.

Private Discord support — tell me your username and get your special rank : SECourses Discord.

Constant updates: when a new model drops, this app gets it fast — Krea 2, Ideogram 4 and LTX 2.3 were all added within days of becoming trainable.

→ Join SECourses on Patreon and download SECourses_Musubi_Trainer_v32.zip now ←

How To Install and Use

Windows

Install the requirements (see the requirements section above), then just run Windows_Install_and_Update.bat for install and update.

Run Windows_Download_Training_Model_Files.bat to download the exact right model files for your training.

Start the app with Windows_Start_App.bat, load a preset config matching your GPU, generate your dataset TOML with the Generate Dataset Configuration button (Kohya folder logic, e.g. parent folder > 1_ohwx man), and press Start Training.

Follow the main tutorial for the complete workflow : https://youtu.be/DPX3eBTuO_Y

Massed Compute (Recommended Cloud)

Register via this link — coupon SECourses for all GPUs. GPU guide : https://www.patreon.com/posts/126671823

Select RTX A6000 or better (L40S, A6000 ADA, A100, H100, RTX 6000 PRO), pick the SECourses image from the Creator dropdown, then follow Massed_Compute_Instructions_READ.txt.

RunPod / SimplePod (Cloud)

Register via RunPod or SimplePod and follow Runpod_SimplePod_Musubi_Trainer_Instructions.txt — use the template written in the instructions file.

Auxiliary Tools & Resources

Ultimate Batch Image Preprocessing app : https://www.patreon.com/posts/120352012

Batch Image Caption Editor app : https://www.patreon.com/posts/108992085

How to install and use SwarmUI with ComfyUI backend : https://youtu.be/c3gEoAyL2IE

Extremely fast Hugging Face upload / download notebook : https://youtu.be/X5WVZ0NMaTg

Training style images dataset : GTA5_Style_Dataset.zip — model : on CivitAI

Example training images dataset : https://www.patreon.com/posts/114972274

Version History

The complete changelog of every release from V1 (28 August 2025) to V32.1 (3 August 2026) is now built into the app — open the Version History tab and expand any release. Recent highlights:

V32.1 — Interface fully modernized; Automagic optimizers fully working; dataset repeat-count safety (forgotten N_ folder prefixes counted as 1 repeat with a clear notification); full version history moved into the app.

V32 — LTX 2.3 (22B) / LTX-2 (19B) video training tab with INT8 ConvRot and audio-video modes.

V31 — Krea 2 INT8 ConvRot quantized training (faster than BF16, more accurate than Scaled FP8).

V30 — Massive performance release: up to 53% faster; Full Fine-Tuning for FLUX 2, Klein, Ideogram 4 and Krea 2; guarded Windows SDPA.

V29 — Torch 2.13 + CUDA 13.1 stack with self-compiled abi3 wheels; Krea 2 and Ideogram 4 training added; auto model-path detection.

V25 → V27 — uv installers (~100x faster), Qwen Edit 2511, Wan 2.2 official configs, FLUX / Z-Image tabs, Model Quantizer.

Ready to train? Join SECourses, grab latest zip file, watch the main tutorial — and your first LoRA can be training within the hour.