Add the lightx2v Minimax-h3-Turbo LoRA as a per-request alternative

h3_lora.py now loads both turbo LoRAs and switches the folded set in
place per request (unfold old / fold new, one bf16 rounding, AoTI-safe).
The lightx checkpoint is PEFT-style against the diffusers tree (rank
128, alpha 8 -> fold scale 0.0625); the larry one keeps the reference
key conversion. The UI checkbox becomes a LoRA dropdown (larry / lightx
/ off) that suggests each design point in steps (6 / 4 / 28), and the
API gains a 'lora' string parameter — the legacy use_lora bool still
works.

README.md

@@ -48,11 +48,12 @@ callers get the same treatment the old upload event gave.
 
 The transformer runs with [`larryvrh/MiniMax-H3-Turbo-Lora`](https://huggingface.co/larryvrh/MiniMax-H3-Turbo-Lora)
 folded into its bf16 weights at startup (`h3_lora.py`), so the default is **6 sampling steps** instead of 28 
-card's comfort zone at the current checkpoint; 4 is the design point but softer). The fold mirrors the diffusers key
-conversion exactly (fused-QKV thirds, the `SwiGLU` gate/value swap, the shared AdaLN row layout) and happens before
-the AoTI package is patched in, so compiled blocks carry the update too. The low-rank factors stay resident, so the
-**Turbo LoRA checkbox** (or the `use_lora` API parameter) folds/unfolds `lora_B @ lora_A` in place per request —
-off gives the base model at whatever step count you pick. `H3_LORA` selects the file (`off` disables entirely), `H3_LORA_STRENGTH` scales the update (the card's sharpness/artifact dial: >1 against smear, <1 against over-sharp grain).
+card's comfort zone at the current checkpoint; 4 is the design point but softer). The larry fold mirrors the diffusers key
+conversion exactly (fused-QKV thirds, the `SwiGLU` gate/value swap, the shared AdaLN row layout); lightx keys are
+already diffusers-native. Both happen before the AoTI package is patched in, so compiled blocks carry the update too,
+and the low-rank factors stay resident so switching is an in-place unfold/fold through one bf16 rounding.
+`H3_LORA` selects the larry file (`off` skips it), `H3_LIGHTX=off` skips lightx, `H3_LORA_DEFAULT` picks which set
+starts folded, and `H3_LORA_STRENGTH` scales the larry update (the card's sharpness/artifact dial).
 
 ## AoTI-compiled blocks
 
@@ -178,7 +179,9 @@ one-time `PIPE.to("cuda")` is inside the first row's 339 s and does not reappear
 | `H3_GPU_SIZE` | `xlarge` | ZeroGPU allocation size. `large` does not fit. |
 | `H3_LORA` | `minimax_h3_turbo_4step_ema_ckpt850.safetensors` | Turbo LoRA file folded into the transformer at startup. `off` disables. |
 | `H3_LORA_REPO` | `larryvrh/MiniMax-H3-Turbo-Lora` | Hub repo the LoRA is fetched from. |
-| `H3_LORA_STRENGTH` | `1.0` | Scales the folded LoRA delta (sharpness/artifact trade-off). |
+| `H3_LORA_STRENGTH` | `1.0` | Scales the larry LoRA delta (sharpness/artifact trade-off). |
+| `H3_LIGHTX` | `on` | Set to `off` to skip loading the lightx2v LoRA set. |
+| `H3_LORA_DEFAULT` | `larry` | Which loaded LoRA set starts folded (`larry` / `lightx`). |
 
 ## Whose GPU quota pays
 

app.py

@@ -224,7 +224,7 @@ _DECODE_BASE, _DECODE_PER_DEFAULT_CANVAS, _DEFAULT_CANVAS_PIXELS = 15, 15, 960 *
 _PLACEMENT_ALLOWANCE, _PAD = 12, 10
 
 
-def get_duration(prompt_embeds, text_token_tags, image, last_image, height, width, num_frames, steps, seed, use_lora=True, *a, **k):
+def get_duration(prompt_embeds, text_token_tags, image, last_image, height, width, num_frames, steps, seed, lora="larry", *a, **k):
     height, width, num_frames, steps = int(height), int(width), int(num_frames), int(steps)
     latent_frames = (num_frames - LATENTS_PER_CHUNK) // FRAMES_PER_CHUNK * LATENTS_PER_CHUNK + 2
     patches = (height // 32) * (width // 32)
@@ -235,7 +235,7 @@ def get_duration(prompt_embeds, text_token_tags, image, last_image, height, widt
 
 
 @spaces.GPU(duration=get_duration, size=GPU_SIZE)
-def _generate(prompt_embeds, text_token_tags, image, last_image, height, width, num_frames, steps, seed, use_lora=True):
+def _generate(prompt_embeds, text_token_tags, image, last_image, height, width, num_frames, steps, seed, lora="larry"):
     """The only thing on GPU time: the packed-sequence denoise loop and the two decoders.
 
     Only the three generated outputs come back — a `@spaces.GPU` return crosses a process boundary by pickling, and
@@ -245,8 +245,9 @@ def _generate(prompt_embeds, text_token_tags, image, last_image, height, width,
 
     import h3_lora
 
-    # Fold/unfold the turbo LoRA in place to match the request (a no-op when the state already matches).
-    h3_lora.set_enabled(PIPE.transformer, bool(use_lora))
+    # Fold the requested LoRA in place (a no-op when the state already matches). AoTI blocks read the same
+    # live storage, so the compiled forward carries the switch too.
+    active_lora = h3_lora.set_active(PIPE.transformer, lora)
 
     if PLACEMENT == "lazy":
         PIPE.to("cuda")
@@ -265,7 +266,7 @@ def _generate(prompt_embeds, text_token_tags, image, last_image, height, width,
         num_inference_steps=int(steps),
         generator=torch.Generator("cpu").manual_seed(int(seed)),
     )
-    return state.get("videos")[0], state.get("audio")[0].cpu(), state.get("sampling_rate")
+    return state.get("videos")[0], state.get("audio")[0].cpu(), state.get("sampling_rate"), active_lora
 
 
 def _fit_keyframe(image_path, current_canvas):
@@ -302,8 +303,15 @@ def _fit_keyframe(image_path, current_canvas):
     return image_path, label
 
 
-def generate(prompt, image_path=None, last_image_path=None, canvas=DEFAULT_CANVAS, duration=5, steps=6, seed=42, upsample=False, use_lora=True, ip_token=None):
-    """One request. `upsample` is last and defaults off, so a positional API client that predates it is unaffected."""
+def _resolve_lora(lora, use_lora) -> str:
+    """`lora` (`larry` / `lightx` / `off`) wins; the legacy `use_lora` bool maps onto `larry` / `off`."""
+    if isinstance(lora, str) and lora in ("larry", "lightx", "off"):
+        return lora
+    return "larry" if use_lora else "off"
+
+
+def generate(prompt, image_path=None, last_image_path=None, canvas=DEFAULT_CANVAS, duration=5, steps=6, seed=42, upsample=False, use_lora=True, lora="", ip_token=None):
+    """One request. `upsample`/`use_lora` keep their defaults so a positional API client that predates them is unaffected."""
     if LOAD_ERROR:
         raise Exception(LOAD_ERROR)
     if PIPE is None:
@@ -315,6 +323,8 @@ def generate(prompt, image_path=None, last_image_path=None, canvas=DEFAULT_CANVA
 
     from diffusers.utils import encode_video
 
+    lora = _resolve_lora(lora, use_lora)
+
     # Server mode: keyframes arrive as FileData dicts, and the cover-crop / canvas-fit that used to be an upload
     # event in the Blocks UI runs here instead, so API callers get the same treatment.
     first = image_path["path"] if isinstance(image_path, dict) else image_path
@@ -340,7 +350,7 @@ def generate(prompt, image_path=None, last_image_path=None, canvas=DEFAULT_CANVA
         return ImageOps.exif_transpose(Image.open(path)).convert("RGB") if path else None
 
     started = time.time()
-    frames, audio, sampling_rate = _generate(
+    frames, audio, sampling_rate, active_lora = _generate(
         prompt_embeds,
         text_token_tags,
         keyframe(first),
@@ -350,7 +360,7 @@ def generate(prompt, image_path=None, last_image_path=None, canvas=DEFAULT_CANVA
         num_frames,
         steps,
         seed,
-        use_lora,
+        lora,
     )
     generate_seconds = time.time() - started
 
@@ -363,7 +373,7 @@ def generate(prompt, image_path=None, last_image_path=None, canvas=DEFAULT_CANVA
         f"conditioner {condition_seconds:.0f}s ({plan['num_text_tokens']} tokens"
         f"{', upsampled' if refined else ''}) · "
         f"denoise + decode {generate_seconds:.0f}s ({generate_seconds / int(steps):.1f} s/step) · "
-        f"turbo LoRA {'on' if use_lora else 'off'} · seed {int(seed)}"
+        f"turbo LoRA {active_lora} · seed {int(seed)}"
     )
     print(f"[gen] {report}", flush=True)
     return FileData(path=path), report, refined
@@ -380,11 +390,15 @@ app = Server(title="MiniMax-H3 Studio")
 @app.api(name="generate")
 def _generate_api(prompt: str, image_path: FileData | None = None, last_image_path: FileData | None = None,
                   canvas: str = DEFAULT_CANVAS, duration: float = 5, steps: int = 6, seed: float = 42,
-                  upsample: bool = False, use_lora: bool = True, request: Request = None) -> tuple[FileData, str, str]:
-    """Generate a video with a synchronized soundtrack. Returns (video, report, refined prompt)."""
+                  upsample: bool = False, use_lora: bool = True, lora: str = "", request: Request = None) -> tuple[FileData, str, str]:
+    """Generate a video with a synchronized soundtrack. Returns (video, report, refined prompt).
+
+    `lora` selects the turbo LoRA: `larry` (default), `lightx`, or `off`. The legacy `use_lora` bool still works
+    when `lora` is empty.
+    """
     # `request` is injected by the event system, not an API input; its x-ip-token bills the conditioner to the caller.
     ip_token = request.headers.get("x-ip-token") if request is not None else None
-    return generate(prompt, image_path, last_image_path, canvas, duration, steps, seed, upsample, use_lora, ip_token=ip_token)
+    return generate(prompt, image_path, last_image_path, canvas, duration, steps, seed, upsample, use_lora, lora, ip_token=ip_token)
 
 
 @app.get("/status")
@@ -397,11 +411,24 @@ def studio_status():
 @app.get("/studio-config")
 def studio_config():
     """The canvas table and slider ranges, so the frontend never hardcodes a label the backend would reject."""
+    import h3_lora
+
+    state = getattr(PIPE.transformer, "_lora_state", None) if PIPE is not None else None
+    sets = state["sets"] if state else {}
     return {
         "canvases": list(CANVASES),
         "default_canvas": DEFAULT_CANVAS,
         "min_duration": MIN_UI_DURATION,
         "max_duration": MAX_UI_DURATION,
+        # The LoRA dropdown: value -> {label, suggested steps}.
+        "loras": {
+            **{
+                name: {"label": spec["label"], "steps": {"larry": 6, "lightx": 4}.get(name, 6)}
+                for name, spec in sets.items()
+            },
+            "off": {"label": "off (base model)", "steps": 28},
+        },
+        "default_lora": state["active"] if state else "off",
     }
 
 

h3_lora.py

@@ -1,23 +1,28 @@
-"""Fold the MiniMax-H3 Turbo LoRA (`larryvrh/MiniMax-H3-Turbo-Lora`) into the diffusers transformer.
-
-The LoRA ships against the *reference* (ComfyUI) module tree — `blocks.N.attn.qkv_proj`, `blocks.N.mlp.fc1`,
-`token_refiner.blocks.N`, `final_layer.adaln_proj.linear` — with `alpha == rank`, so the update is exactly
-`W + lora_B @ lora_A`. The diffusers checkpoint is the same weights under different names and two layout transforms
-(see `scripts/convert_minimax_h3_to_diffusers.py` in huggingface/diffusers#14371), so each delta gets the same
-transform the base weight got:
-
-* fused `attn.qkv_proj` rows are `[q_all; k_all; v_all]` in both in-memory layouts -> split into contiguous thirds
-  onto `attn.to_q` / `to_k` / `to_v`;
-* fused `mlp.fc1` is `[gate; value]` while diffusers' `SwiGLU` fuses `[value; gate]` -> swap the halves onto
-  `ff.net.0.proj`;
-* `mlp.fc2` -> `ff.net.2`, `attn.out_proj` -> `attn.to_out.0`, `blocks.` -> `transformer_blocks.`,
-  `token_refiner.blocks.` -> `token_refiner.refiner_blocks.`, `final_layer.adaln_proj.linear` -> `norm_out.linear`;
-* the `adaln_proj.linear` modulation tables share the `[timestep][modality][param]` row layout in both trees, so
-  they map name-for-name with no reordering.
-
-The delta is folded into the bf16 weights rather than applied as a runtime wrapper for one reason: the AoTI block
-package (`h3_aoti`) reads each block's live weights, and a wrapper module would be invisible to it. The fold computes
-`lora_B @ lora_A` in float32 and rounds once on the way back into bf16.
+"""Turbo LoRA support for the diffusers MiniMax-H3 transformer: two 4-step LoRAs, one fold mechanism.
+
+Both LoRAs are applied by folding `scale * (lora_B @ lora_A)` into the bf16 weights rather than as runtime wrappers,
+because the AoTI block package (`h3_aoti`) reads each block's live weights and a wrapper module would be invisible
+to it. Deltas are computed in float32 and round once on the way back into bf16. The low-rank factors of every loaded
+LoRA stay resident, so the active one can be switched per request (`set_active`) — unfold the old, fold the new, in
+place, through one bf16 rounding.
+
+The two supported LoRAs ship in different layouts:
+
+* `larry` (`larryvrh/MiniMax-H3-Turbo-Lora`) targets the *reference* (ComfyUI) module tree — `blocks.N.attn.qkv_proj`,
+  `blocks.N.mlp.fc1`, `token_refiner.blocks.N`, `final_layer.adaln_proj.linear` — with `alpha == rank` (scale 1).
+  Each delta gets the same transform the base weights got in the diffusers conversion
+  (`scripts/convert_minimax_h3_to_diffusers.py`, huggingface/diffusers#14371): fused-QKV row thirds onto
+  `attn.to_q/k/v`, the `SwiGLU` gate/value swap onto `ff.net.0.proj`, `fc2` -> `ff.net.2`,
+  `blocks.` -> `transformer_blocks.`, `token_refiner.blocks.` -> `token_refiner.refiner_blocks.`,
+  `final_layer.adaln_proj.linear` -> `norm_out.linear`. The row transforms are applied to `lora_B` directly
+  (rows of `B @ A` are rows of `B`), so no full delta is ever materialized at load.
+
+* `lightx` (`lightx2v/Minimax-h3-Turbo`) is a PEFT checkpoint against the diffusers tree itself —
+  `transformer_blocks.N.attn.to_q.lora_A.default.weight` and friends — rank 128, `alpha == 8`, so the fold scale is
+  `8 / 128 = 0.0625` (matching `set_adapters(weights=1.0)` in their inference script). Keys map name-for-name.
+
+`H3_LORA` selects the larry file (`off` skips loading it), `H3_LIGHTX=off` skips lightx, `H3_LORA_DEFAULT` picks
+which set starts folded, and `H3_LORA_STRENGTH` is the larry card's sharpness/artifact dial.
 """
 
 from __future__ import annotations
@@ -26,16 +31,19 @@ import os
 
 import torch
 
-LORA_REPO = os.environ.get("H3_LORA_REPO", "larryvrh/MiniMax-H3-Turbo-Lora")
+LARRY_REPO = os.environ.get("H3_LORA_REPO", "larryvrh/MiniMax-H3-Turbo-Lora")
 # The recommended default per the model card: ckpt850 EMA (final checkpoint of the round, sharp at 4 steps).
-# `off` disables.
-LORA_FILE = os.environ.get("H3_LORA", "minimax_h3_turbo_4step_ema_ckpt850.safetensors")
-# The card's sharpness/artifact dial: >1 against blurry ghosting/smear, <1 against over-sharp grain.
-LORA_STRENGTH = float(os.environ.get("H3_LORA_STRENGTH", "1.0"))
+LARRY_FILE = os.environ.get("H3_LORA", "minimax_h3_turbo_4step_ema_ckpt850.safetensors")
+LIGHTX_REPO = os.environ.get("H3_LIGHTX_REPO", "lightx2v/Minimax-h3-Turbo")
+LIGHTX_FILE = os.environ.get("H3_LIGHTX_FILE", "minimax_h3_fl2v_turbo_4step_v0.1.safetensors")
+LIGHTX_ALPHA = 8
+# The card's sharpness/artifact dial for the larry LoRA: >1 against blurry ghosting/smear, <1 against grain.
+LARRY_STRENGTH = float(os.environ.get("H3_LORA_STRENGTH", "1.0"))
+DEFAULT_LORA = os.environ.get("H3_LORA_DEFAULT", "larry")
 
 
-def _delta_targets(name: str, delta: torch.Tensor, inner_dim: int) -> list[tuple[str, torch.Tensor]]:
-    """Map one reference-tree LoRA base name and its `lora_B @ lora_A` delta onto diffusers parameter key(s)."""
+def _larry_targets(name: str, b: torch.Tensor, inner_dim: int) -> list[tuple[str, torch.Tensor]]:
+    """Map one reference-tree base name and its `lora_B` onto diffusers parameter key + row-transformed B."""
     if name.startswith("token_refiner.blocks."):
         target = name.replace("token_refiner.blocks.", "token_refiner.refiner_blocks.", 1)
     elif name.startswith("blocks."):
@@ -48,78 +56,117 @@ def _delta_targets(name: str, delta: torch.Tensor, inner_dim: int) -> list[tuple
         prefix = target.removesuffix("qkv_proj")
         return [
             (f"{prefix}to_{kind}.weight", part.contiguous())
-            for kind, part in zip(("q", "k", "v"), delta.split(inner_dim, dim=0))
+            for kind, part in zip(("q", "k", "v"), b.split(inner_dim, dim=0))
         ]
     if target.endswith(".mlp.fc1"):
-        gate, value = delta.chunk(2, dim=0)
+        gate, value = b.chunk(2, dim=0)
         return [(target.replace(".mlp.fc1", ".ff.net.0.proj") + ".weight", torch.cat([value, gate]).contiguous())]
     if target.endswith(".mlp.fc2"):
-        return [(target.replace(".mlp.fc2", ".ff.net.2") + ".weight", delta)]
+        return [(target.replace(".mlp.fc2", ".ff.net.2") + ".weight", b)]
     if target.endswith(".attn.out_proj"):
-        return [(target.replace(".attn.out_proj", ".attn.to_out.0") + ".weight", delta)]
+        return [(target.replace(".attn.out_proj", ".attn.to_out.0") + ".weight", b)]
     # `adaln_proj.linear` (block-level and the final `norm_out.linear`): identical row layout on both sides.
-    return [(target + ".weight", delta)]
+    return [(target + ".weight", b)]
 
 
-def apply_lora(transformer) -> str | None:
-    """Fold the configured Turbo LoRA into `transformer` in place. Returns a status line, or `None` when disabled."""
-    if LORA_FILE.lower() in ("", "off", "none"):
-        return None
-
+def _load_larry(inner_dim: int) -> dict:
     from huggingface_hub import hf_hub_download
     from safetensors.torch import load_file
 
-    path = hf_hub_download(LORA_REPO, LORA_FILE)
-    lora = load_file(path)
+    lora = load_file(hf_hub_download(LARRY_REPO, LARRY_FILE))
     bases = sorted({key.rsplit(".lora_", 1)[0] for key in lora})
-
-    config = transformer.config
-    inner_dim = config.num_attention_heads * config.attention_head_dim
-    params = dict(transformer.named_parameters())
-
-    folded = 0
     entries = []
     for name in bases:
-        a = lora[f"{name}.lora_A.weight"].float()
-        b = lora[f"{name}.lora_B.weight"].float()
-        delta = (b @ a) * LORA_STRENGTH  # alpha == rank, so the base scale is 1
-        targets = _delta_targets(name, delta, inner_dim)
-        for key, converted in targets:
-            param = params.get(key)
-            if param is None:
-                raise KeyError(f"LoRA target `{key}` (from `{name}`) not found in the transformer")
-            param.data = (param.data.float() + converted).to(param.dtype)
-            folded += 1
-        entries.append(name)
-
-    # Keep the low-rank factors (~744 MB in bf16) so the fold can be toggled per request: adding/subtracting
-    # B @ A in place round-trips through one bf16 rounding, and the AoTI blocks read the same live storage.
-    transformer._lora_state = {
-        "enabled": True,
-        "inner_dim": inner_dim,
-        "strength": LORA_STRENGTH,
-        "entries": [
-            (name, lora[f"{name}.lora_A.weight"], lora[f"{name}.lora_B.weight"])
-            for name in entries
-        ],
+        a = lora[f"{name}.lora_A.weight"]
+        b = lora[f"{name}.lora_B.weight"]
+        entries.extend((key, a, b_part) for key, b_part in _larry_targets(name, b, inner_dim))
+    return {
+        "label": f"{LARRY_REPO}/{LARRY_FILE}",
+        "scale": LARRY_STRENGTH,  # alpha == rank, so the base scale is 1
+        "entries": entries,
     }
-    strength = "" if LORA_STRENGTH == 1.0 else f" @ strength {LORA_STRENGTH}"
-    return f"LoRA `{LORA_REPO}/{LORA_FILE}`{strength} folded into {folded} weights ({len(bases)} modules)"
 
 
-def set_enabled(transformer, enabled: bool) -> bool:
-    """Fold/unfold the LoRA in place. No-op when no LoRA was loaded or the state already matches."""
-    state = getattr(transformer, "_lora_state", None)
-    if state is None or state["enabled"] == enabled:
-        return state["enabled"] if state else False
-    import torch
+def _load_lightx() -> dict:
+    from huggingface_hub import hf_hub_download
+    from safetensors.torch import load_file
+
+    lora = load_file(hf_hub_download(LIGHTX_REPO, LIGHTX_FILE))
+    suffix_a, suffix_b = ".lora_A.default.weight", ".lora_B.default.weight"
+    bases = sorted({key[: -len(suffix_a)] for key in lora if key.endswith(suffix_a)})
+    ranks = {lora[f"{name}{suffix_a}"].shape[0] for name in bases}
+    if len(ranks) != 1:
+        raise ValueError(f"Mixed LoRA ranks in {LIGHTX_FILE}: {sorted(ranks)}")
+    entries = [(f"{name}.weight", lora[f"{name}{suffix_a}"], lora[f"{name}{suffix_b}"]) for name in bases]
+    return {
+        "label": f"{LIGHTX_REPO}/{LIGHTX_FILE}",
+        "scale": LIGHTX_ALPHA / ranks.pop(),
+        "entries": entries,
+    }
+
+
+def _apply(entries, params, sign: float) -> None:
+    for key, a, b in entries:
+        param = params.get(key)
+        if param is None:
+            raise KeyError(f"LoRA target `{key}` not found in the transformer")
+        delta = sign * (b.to(torch.float32) @ a.to(torch.float32))
+        param.data = (param.data.float() + delta.to(param.device)).to(param.dtype)
+
 
-    sign = (1.0 if enabled else -1.0) * state.get("strength", 1.0)
+def available() -> list[str]:
+    """The LoRA sets that were loaded at startup, plus `off`."""
+    state = getattr(_PIPE_TRANSFORMER, "_lora_state", None) if _PIPE_TRANSFORMER is not None else None
+    return sorted(state["sets"]) + ["off"] if state else ["off"]
+
+
+_PIPE_TRANSFORMER = None
+
+
+def apply_lora(transformer) -> str | None:
+    """Load every enabled LoRA set, fold the default one into `transformer`, and stash the factors for per-request
+    switching. Returns a status line, or `None` when everything is disabled."""
+    global _PIPE_TRANSFORMER
+    _PIPE_TRANSFORMER = transformer
+
+    inner_dim = transformer.config.num_attention_heads * transformer.config.attention_head_dim
+    sets = {}
+    if LARRY_FILE.lower() not in ("", "off", "none"):
+        sets["larry"] = _load_larry(inner_dim)
+    if os.environ.get("H3_LIGHTX", "on").lower() not in ("", "off", "none"):
+        sets["lightx"] = _load_lightx()
+    if not sets:
+        return None
+
+    active = DEFAULT_LORA if DEFAULT_LORA in sets else sorted(sets)[0]
     params = dict(transformer.named_parameters())
-    for name, a, b in state["entries"]:
-        delta = b.to(torch.float32) @ a.to(torch.float32)
-        for key, converted in _delta_targets(name, delta, state["inner_dim"]):
-            param = params[key]
-            param.data = (param.data.float() + sign * converted.to(param.device)).to(param.dtype)
-    state["enabled"] = enabled
-    return enabled
+    _apply(sets[active]["entries"], params, sets[active]["scale"])
+    transformer._lora_state = {"active": active, "sets": sets}
+    return (
+        f"LoRAs loaded: "
+        + ", ".join(f"`{name}` ({spec['label']}, {len(spec['entries'])} weights)" for name, spec in sets.items())
+        + f" · active `{active}`"
+    )
+
+
+def set_active(transformer, name: str) -> str:
+    """Switch the folded LoRA in place. No-op when the state already matches. Returns the active set."""
+    state = getattr(transformer, "_lora_state", None)
+    if state is None:
+        return "off"
+    name = name if name in state["sets"] else "off"
+    if state["active"] == name:
+        return name
+    params = dict(transformer.named_parameters())
+    if state["active"] != "off":
+        old = state["sets"][state["active"]]
+        _apply(old["entries"], params, -old["scale"])
+    if name != "off":
+        _apply(state["sets"][name]["entries"], params, state["sets"][name]["scale"])
+    state["active"] = name
+    return name
+
+
+def set_enabled(transformer, enabled: bool) -> bool:
+    """Backwards-compatible boolean toggle over the default set."""
+    return set_active(transformer, DEFAULT_LORA if enabled else "off") != "off"

index.html

@@ -225,7 +225,10 @@
       <div class="deck-label">Prompt</div>
       <textarea id="prompt" spellcheck="false">A red fox trotting through a snowy pine forest at dawn, snow crunching underfoot</textarea>
     </div>
-    <label class="check"><input type="checkbox" id="use_lora" checked> Turbo LoRA (fast steps)</label>
+    <div>
+      <div class="deck-label">Turbo LoRA</div>
+      <select id="lora"></select>
+    </div>
     <label class="check"><input type="checkbox" id="upsample"> Upsample prompt</label>
 
     <div>
@@ -307,6 +310,21 @@ fetch("/studio-config").then(r => r.json()).then(cfg => {
     sel.appendChild(o);
   }
   $("duration").min = cfg.min_duration; $("duration").max = cfg.max_duration;
+
+  const loraSel = $("lora");
+  for (const [value, spec] of Object.entries(cfg.loras || { larry: { label: "larry", steps: 6 } })) {
+    const o = document.createElement("option");
+    o.value = value;
+    o.textContent = value === "off" ? "off (base model)" : value;
+    o.title = spec.label;
+    if (value === cfg.default_lora) o.selected = true;
+    loraSel.appendChild(o);
+  }
+  // Each LoRA has a design point: suggest it on switch (the slider stays free).
+  loraSel.addEventListener("change", () => {
+    const spec = (cfg.loras || {})[loraSel.value];
+    if (spec && spec.steps) { $("steps").value = spec.steps; $("steps-out").textContent = spec.steps; }
+  });
 });
 
 async function pollStatus() {
@@ -405,7 +423,7 @@ $("run").addEventListener("click", async () => {
       steps: Number($("steps").value),
       seed: Number($("seed").value),
       upsample: $("upsample").checked,
-      use_lora: $("use_lora").checked,
+      lora: $("lora").value,
     });
     let data = null;
     for await (const msg of submission) {