@@ -127,6 +127,26 @@ lora_config = LoRA(
 )
 ```
 
+#### LoRA+
+
+[LoRA+](https://arxiv.org/abs/2402.12354) trains the B matrix (`linear_out`) at a higher learning rate than A (`linear_in`) by a fixed ratio `lr_B = lora_plus_ratio * lr_A` (paper default 16). The ratio is set on the optimizer, not the `LoRA` adapter: when it differs from `1.0`, `get_lora_plus_config_overrides` (`megatron.bridge.peft.lora`) builds Megatron-Core per-group overrides giving the `*.linear_out.weight` group `max_lr`/`min_lr` scaled by the ratio. Pass `1.0` (or skip the call) to keep a single learning rate.
+
+```python
+from megatron.bridge.peft.lora import get_lora_plus_config_overrides
+from megatron.core.optimizer import OptimizerConfig, get_megatron_optimizer
+
+opt_config = OptimizerConfig(optimizer="adam", lr=1e-4, bf16=True)
+
+# LoRA+ LR split: lr_B = lora_plus_ratio * lr_A; pass 1.0 (or skip) to disable.
+lora_plus_ratio = 16
+config_overrides = get_lora_plus_config_overrides(opt_config, lora_plus_ratio)
+optimizer = get_megatron_optimizer(
+    config=opt_config,
+    model_chunks=model_chunks,
+    config_overrides=config_overrides,
+)
+```
+
 ### Canonical LoRA: Performant vs Canonical Variants
 
 There are two variants of LoRA implemented in Megatron Bridge: "performant LoRA" (`LoRA`) and "canonical LoRA" (`CanonicalLoRA`).
 
@@ -79,7 +79,16 @@ def _prepare_distributed_output(path: str, *, overwrite: bool, source_paths: Ite
     validate_output_path(path, source_paths=source_paths)
     if torch.distributed.get_rank() == 0:
         prepare_output_directory(path, overwrite=overwrite, source_paths=source_paths)
-    torch.distributed.barrier()
+    # Without device_ids, torch guesses the barrier's device as
+    # rank % local_gpu_count. Slurm assigns SLURM_PROCID cyclically across
+    # nodes (RANK = num_nodes * local_rank + node_id, not block-wise), so
+    # that guess collides across ranks on the same node once more than one
+    # node is used, and NCCL aborts with "Multiple ranks detected using the
+    # same GPU on this node." Passing the real device (already set via
+    # torch.cuda.set_device in _ensure_distributed_initialized) avoids the
+    # guess, matching the pattern used by training/initialize.py's own
+    # first post-init barrier.
+    torch.distributed.barrier(device_ids=[torch.cuda.current_device()])
 
 
 def _maybe_generate_pipeline_layout(bridge: AutoBridge, model_provider: GPTModelProvider, pp: int) -> bool:
 
@@ -14,11 +14,13 @@
 
 import logging
 from dataclasses import dataclass, field
-from typing import List, Literal, Optional
+from typing import Dict, List, Literal, Optional
 
 import torch
 import torch.nn as nn
 from megatron.core import parallel_state
+from megatron.core.optimizer import OptimizerConfig, ParamKey, get_standard_config_overrides
+from megatron.core.optimizer_param_scheduler import ParamGroupOverride
 from megatron.core.transformer.moe.router import TopKRouter
 from megatron.core.utils import unwrap_model
 
@@ -46,6 +48,46 @@
 logger = logging.getLogger(__name__)
 
 
+def get_lora_plus_config_overrides(
+    config: OptimizerConfig,
+    lora_plus_ratio: float,
+) -> Dict[ParamKey, ParamGroupOverride]:
+    """Build Megatron-Core optimizer ``config_overrides`` for LoRA+.
+
+    LoRA+ (https://arxiv.org/abs/2402.12354) trains ``B`` (``linear_out``) at
+    ``lora_plus_ratio`` times the LR of ``A`` (``linear_in``); the ratio is fixed
+    and only the base LR is tuned. Standard overrides (bias/1-D ``wd_mult=0.0``,
+    decoupled LR) are preserved as the starting point.
+
+    Args:
+        config: base optimizer config; ``lr`` / ``min_lr`` are A's learning rates.
+        lora_plus_ratio: ``lr_B / lr_A`` (e.g. 16.0). Must be > 0.
+
+    Returns:
+        Per-group overrides ready for ``get_megatron_optimizer(config_overrides=...)``.
+    """
+    if lora_plus_ratio <= 0:
+        raise ValueError(f"lora_plus_ratio must be > 0, got {lora_plus_ratio}")
+
+    config_overrides = get_standard_config_overrides(config)
+
+    base_lr = config.lr
+    base_min_lr = config.min_lr if config.min_lr is not None else 0.0
+
+    config_overrides[ParamKey(name="*.linear_in.weight")] = ParamGroupOverride(max_lr=base_lr, min_lr=base_min_lr)
+    config_overrides[ParamKey(name="*.linear_out.weight")] = ParamGroupOverride(
+        max_lr=base_lr * lora_plus_ratio, min_lr=base_min_lr * lora_plus_ratio
+    )
+
+    logger.info(
+        "LoRA+ enabled: lora_plus_ratio=%s (linear_in/A max_lr=%s, linear_out/B max_lr=%s)",
+        lora_plus_ratio,
+        base_lr,
+        base_lr * lora_plus_ratio,
+    )
+    return config_overrides
+
+
 @dataclass
 class LoRA(PEFT, ModuleMatcher):
     """
 
@@ -22,6 +22,7 @@
 import torch
 from megatron.core.optimizer import OptimizerConfig, ParamGroupOverride, ParamKey
 
+from megatron.bridge.peft.lora import get_lora_plus_config_overrides
 from megatron.bridge.training.config import SchedulerConfig
 from megatron.bridge.training.optim import (
     memory_efficient_fp32_optimizer_state_loading,
@@ -530,3 +531,98 @@ def test_skips_none_shard_main_param(self):
             synced = sync_hybrid_device_optimizer_fp32_master_copies(distrib_opt)
 
         assert synced is True
+
+
+class TestGetLoraPlusConfigOverrides:
+    """Tests for ``get_lora_plus_config_overrides`` (LoRA+ A/B LR split)."""
+
+    def _make_config(self, lr=3e-5, min_lr=0.0, **kwargs):
+        return OptimizerConfig(optimizer="adam", lr=lr, min_lr=min_lr, bf16=True, **kwargs)
+
+    def _get_override(self, overrides, name):
+        """Find a ParamKey by its ``name`` glob and return its ParamGroupOverride."""
+        for key, val in overrides.items():
+            if (
+                getattr(key, "name", None) == name
+                and not getattr(key, "predicate", None)
+                and not getattr(key, "with_name_predicate", None)
+                and not getattr(key, "attr", None)
+            ):
+                return val
+        return None
+
+    @pytest.mark.parametrize("ratio", [0, -1, -0.5])
+    def test_non_positive_ratio_raises(self, ratio):
+        with pytest.raises(ValueError, match="lora_plus_ratio must be > 0"):
+            get_lora_plus_config_overrides(self._make_config(), ratio)
+
+    def test_a_keeps_base_lr(self):
+        overrides = get_lora_plus_config_overrides(self._make_config(lr=3e-5, min_lr=1e-6), 16.0)
+        a = self._get_override(overrides, "*.linear_in.weight")
+        assert a is not None
+        assert a["max_lr"] == 3e-5
+        assert a["min_lr"] == 1e-6
+
+    def test_b_is_ratio_times_base_lr(self):
+        overrides = get_lora_plus_config_overrides(self._make_config(lr=3e-5, min_lr=1e-6), 16.0)
+        b = self._get_override(overrides, "*.linear_out.weight")
+        assert b is not None
+        assert b["max_lr"] == pytest.approx(3e-5 * 16)
+        assert b["min_lr"] == pytest.approx(1e-6 * 16)
+
+    def test_none_min_lr_defaults_to_zero(self):
+        cfg = OptimizerConfig(optimizer="adam", lr=3e-5, min_lr=None, bf16=True)
+        overrides = get_lora_plus_config_overrides(cfg, 16.0)
+        a = self._get_override(overrides, "*.linear_in.weight")
+        b = self._get_override(overrides, "*.linear_out.weight")
+        assert a["min_lr"] == 0.0
+        assert b["min_lr"] == 0.0
+        assert b["max_lr"] == pytest.approx(3e-5 * 16)
+
+    def test_b_schedule_is_ratio_scaled_copy_of_a(self):
+        """B's max_lr/min_lr are both exactly ratio x A's — the whole schedule scales."""
+        ratio = 8.0
+        overrides = get_lora_plus_config_overrides(self._make_config(lr=5e-5, min_lr=2e-6), ratio)
+        a = self._get_override(overrides, "*.linear_in.weight")
+        b = self._get_override(overrides, "*.linear_out.weight")
+        assert b["max_lr"] / a["max_lr"] == pytest.approx(ratio)
+        assert b["min_lr"] / a["min_lr"] == pytest.approx(ratio)
+
+    def test_ratio_one_keeps_equal_lr(self):
+        """ratio == 1.0 still produces valid overrides with A == B (no-op split)."""
+        overrides = get_lora_plus_config_overrides(self._make_config(lr=3e-5, min_lr=0.0), 1.0)
+        a = self._get_override(overrides, "*.linear_in.weight")
+        b = self._get_override(overrides, "*.linear_out.weight")
+        assert a["max_lr"] == b["max_lr"] == 3e-5
+        assert a["min_lr"] == b["min_lr"] == 0.0
+
+    def test_preserves_standard_bias_wd_override(self):
+        """The standard bias/1-D wd_mult=0.0 override is preserved alongside LoRA+."""
+        overrides = get_lora_plus_config_overrides(self._make_config(), 16.0)
+        wd_skips = [v for v in overrides.values() if v.get("wd_mult") == 0.0]
+        assert wd_skips, "standard wd_mult=0.0 override should be preserved"
+
+    def test_preserves_decoupled_lr_override(self):
+        """A configured decoupled_lr is preserved by get_standard_config_overrides."""
+        cfg = self._make_config(decoupled_lr=1e-4, decoupled_min_lr=1e-5)
+        overrides = get_lora_plus_config_overrides(cfg, 16.0)
+        # The decoupled entry is keyed by attr, not name.
+        decoupled = [v for k, v in overrides.items() if getattr(k, "attr", None)]
+        assert decoupled, "decoupled_lr override should be preserved"
+        assert decoupled[0]["max_lr"] == 1e-4
+
+    def test_returns_param_key_keyed_mapping(self):
+        """Result is keyed by ParamKey; values are dict-like (ParamGroupOverride is a TypedDict)."""
+        overrides = get_lora_plus_config_overrides(self._make_config(), 16.0)
+        assert all(isinstance(k, ParamKey) for k in overrides)
+        assert all(isinstance(v, dict) for v in overrides.values())
+        # Only the LoRA A/B entries carry the LR fields; standard entries may not.
+        assert self._get_override(overrides, "*.linear_in.weight")["max_lr"] is not None
+        assert self._get_override(overrides, "*.linear_out.weight")["max_lr"] is not None
+
+    def test_only_two_lora_name_globs_added(self):
+        """Exactly two name-glob entries are added: linear_in and linear_out."""
+        overrides = get_lora_plus_config_overrides(self._make_config(), 16.0)
+        name_keys = [k for k in overrides if getattr(k, "name", None) and not getattr(k, "attr", None)]
+        names = {k.name for k in name_keys}
+        assert {"*.linear_in.weight", "*.linear_out.weight"}.issubset(names)