VRGDG LTX Speed Character Lora Training

This is the heavyweight of the pack, and the name is doing real work: it's a character-LoRA trainer for LTX video models that runs inside ComfyUI, pointed at a musubi install. Drop in a handful of reference images, give each a caption, and the node builds a training dataset, runs the trainer, and hands back a MODEL with your freshly-trained LoRA applied to it. If you've ever looked at LTX character-LoRA training tutorials - the kind that involve separate Python environments and a folder full of scripts - you'll recognize this as someone wrapping that whole mess in a node.

The two big dependencies

The node needs three things to be true before it can do anything:

• musubi-tuner-ltx2, installed somewhere on disk. The musubi_root input (default A:/MUSUBI/musubi-tuner-ltx2) points at it. Musubi is one of the real trainers people use for LTX, and the pack assumes a specific folder layout.
• The LTX-2.3 checkpoint. ltx2_checkpoint defaults to A:/MUSUBI/models/ltx2/ltx-2.3-22b-dev.safetensors - that's the 22B LTX-2.3 model, the one whose release the community credit with making LTX actually competitive.
• The Gemma text encoder. gemma_root defaults to A:/MUSUBI/models/gemma3. This is the exact text encoder that caused so much pain on LTX-2/2.3 launch - it's huge, and offloading it badly was the #1 source of OOMs. This node has real answers for that (below).

Notice all those A:/MUSUBI/... defaults. This node was born on a Windows machine with a specific drive layout. You will be editing every path the first time you run it.

The inputs that matter

• image_count (1–20) and the dynamic image1…image20 inputs with matching caption_1…caption_20 fields - your training set. This is the modern no-text-encoder-training approach: you caption the reference images, the node writes them into a dataset folder inside workspace_dir, and the trainer consumes it. workspace_dir is the node's scratch space: cache, output, logs, config, and that managed dataset all live there.
• resolution_width / resolution_height - training bucket resolution, default 1256×1256. LTX-2.3 needs dimensions divisible by 32; the node steps by 8, so pick carefully.
• blocks_to_swap - how many transformer blocks to push to CPU. 0 is fastest if your VRAM allows it; on a 12–16GB card you'll be setting this to something real.
• cache_strategy - auto (reuse the cached text embeddings), force (rebuild them), skip (don't create them). Since text-encoder caching is the single biggest speed lever in modern training, auto is the right default - the Gemma pass is the expensive one.
• gemma_load_in_4bit - loads Gemma in 4-bit during caching. Lowers VRAM more than 8-bit but slower and less stable; this is your OOM escape hatch.
• clear_memory_before_gemma - flushes Comfy and CUDA memory before the Gemma cache stage. Leave it on.
• strength_model - how strongly the newest trained LoRA is applied back onto the returned MODEL (default 1.0).
• run_name / output_name - logs and output naming.

Outputs: model (your trained model), latest_state_path, log_path, video_filename_prefix, output_name, and completed_steps / total_target_steps so you can see training progress in the graph.

Install and the honest expectations

The node itself ships with the pack (Manager → "vrgamedev", or git clone into custom_nodes), but musubi and the model files are on you - the README doesn't set up the trainer, and this node has no download toggle. Plan on: a musubi-tuner-ltx2 clone, the 22B LTX-2.3 checkpoint (that's ~25GB fp8), and a Gemma 3 model. Expect the first run to be slow and memory-hungry, and budget a full pass at blocks_to_swap = 0 with your whole VRAM free.

The take: this is a "for this author's workflow" node more than a general training harness. If you already live in musubi and know its scripts, you may find the node more restrictive than your scripts. If you're new, though, it removes the scariest part - dataset layout and the trainer command line - and gives you progress numbers in the graph. It's opinionated, but for character LoRAs on LTX it's a real path from reference images to a working model.