diff --git a/docs/models/vlm/index.md b/docs/models/vlm/index.md
index 421f8d8faf..d91f780776 100644
--- a/docs/models/vlm/index.md
+++ b/docs/models/vlm/index.md
@@ -12,6 +12,7 @@ ministral3.md
 nemotron-3-omni.md
 nemotron-nano-v2-vl.md
 qwen2.5-vl.md
+qwen3-omni.md
 qwen3-vl.md
 qwen35-vl.md
 ```
diff --git a/docs/models/vlm/qwen3-omni.md b/docs/models/vlm/qwen3-omni.md
new file mode 100644
index 0000000000..eb3f827f26
--- /dev/null
+++ b/docs/models/vlm/qwen3-omni.md
@@ -0,0 +1,43 @@
+# Qwen3-Omni
+
+Qwen3-Omni is a multimodal Qwen family model with text, image, video, and audio inputs. Megatron Bridge support for Qwen3-Omni reuses the existing Qwen3-VL language and vision path, and adds Qwen3-Omni-specific audio handling and checkpoint mappings.
+
+The current implementation focuses on checkpoint conversion, training-oriented multimodal forward paths, and smoke-level validation. It includes a full example workflow (HF -> Megatron -> HF export, single-rank inference) and a multi-node training recipe entrypoint.
+
+## Current Support
+
+- Hugging Face to Megatron Bridge checkpoint conversion for `Qwen/Qwen3-Omni-30B-A3B-Instruct`
+- Megatron Bridge to Hugging Face export for the same model family
+- Text, image, video, and audio multimodal forward paths
+- Qwen3-Omni-specific multimodal RoPE handling for Megatron Bridge runtime
+- Single-GPU smoke validation with a vertically trimmed checkpoint
+- Multi-node training recipe entrypoint (see Qwen3-Omni examples)
+- L0 conversion test coverage for Qwen3-Omni
+
+## Known Limitations
+
+- Megatron inference with `inference_params` is not implemented yet
+- `packed_seq_params` is not implemented yet
+- Automated validation coverage remains single-rank; multi-node training requires user execution
+- Functional smoke tests require user-provided local multimodal assets
+
+## Hugging Face Model Cards
+
+- Qwen3-Omni-30B-A3B-Instruct: `https://huggingface.co/Qwen/Qwen3-Omni-30B-A3B-Instruct`
+
+## Examples
+
+Qwen3-Omni examples are maintained here:
+
+- `examples/models/vlm/qwen3_omni/README.md`
+- `examples/models/vlm/qwen3_omni/conversion.sh`
+- `examples/models/vlm/qwen3_omni/inference.sh`
+- `examples/models/vlm/qwen3_omni/local_train_thinker_4node_tp2_ep8_sp.sh`
+
+## Related Docs
+
+- Related VLM: [Qwen3-VL](qwen3-vl.md)
+- Related VLM: [Qwen 3.5](qwen35-vl.md)
+- Recipe usage: [Recipe usage](../../recipe-usage.md)
+- Customizing the training recipe configuration: [Configuration overview](../../training/config-container-overview.md)
+- Training entry points: [Entry points](../../training/entry-points.md)
diff --git a/examples/conversion/hf_to_megatron_generate_omni_lm.py b/examples/conversion/hf_to_megatron_generate_omni_lm.py
index 510f598863..9d44fb6d5f 100644
--- a/examples/conversion/hf_to_megatron_generate_omni_lm.py
+++ b/examples/conversion/hf_to_megatron_generate_omni_lm.py
@@ -266,6 +266,7 @@ def main(args) -> None:
         model_provider.expert_model_parallel_size = ep
         model_provider.expert_tensor_parallel_size = etp
         model_provider.pipeline_dtype = torch.bfloat16
+        model_provider.gradient_accumulation_fusion = False
         model_provider.finalize()
         model_provider.initialize_model_parallel(seed=0)
 
@@ -292,6 +293,7 @@ def main(args) -> None:
         model_provider.expert_model_parallel_size = ep
         model_provider.expert_tensor_parallel_size = etp
         model_provider.pipeline_dtype = torch.bfloat16
+        model_provider.gradient_accumulation_fusion = False
         model_provider.finalize()
         model_provider.initialize_model_parallel(seed=0)
         model = model_provider.provide_distributed_model(wrap_with_ddp=False)
diff --git a/examples/models/vlm/qwen3_omni/README.md b/examples/models/vlm/qwen3_omni/README.md
new file mode 100644
index 0000000000..803f6b3359
--- /dev/null
+++ b/examples/models/vlm/qwen3_omni/README.md
@@ -0,0 +1,144 @@
+# Qwen3-Omni Examples
+
+This directory contains example scripts for **Qwen3-Omni thinker-side support** in Megatron Bridge.
+
+For model introduction and implementation notes, see the [Qwen3-Omni documentation](../../../../docs/models/vlm/qwen3-omni.md).
+
+## Current Scope
+
+These examples cover:
+
+- reduced single-GPU smoke checkpoint creation
+- Hugging Face -> Megatron checkpoint import
+- Megatron -> Hugging Face checkpoint export
+- local inference with reduced HF, imported Megatron, and exported HF checkpoints
+
+These examples do **not** cover:
+
+- distributed parallel validation beyond single-rank smoke
+- talker / code2wav audio-output checkpoints
+- Megatron inference with `inference_params`
+
+## Workspace Configuration
+
+All scripts default to a repo-local cache workspace:
+
+```bash
+export WORKSPACE=$PWD/.cache/qwen3_omni_examples
+```
+
+You can override it if needed. The default directory structure is:
+
+- `${WORKSPACE}/hf/` - reduced local HF smoke checkpoints
+- `${WORKSPACE}/megatron/` - imported Megatron checkpoints
+- `${WORKSPACE}/export/` - exported HF checkpoints
+- `${WORKSPACE}/tmp/` - temporary files
+- `${WORKSPACE}/hf_home/` - Hugging Face cache used by the examples
+
+## Required Local Assets
+
+These examples assume the following local assets are available:
+
+```bash
+export SOURCE_HF_MODEL=/path/to/Qwen3-Omni-30B-A3B-Instruct
+export VIDEO_PATH=/path/to/example.mp4
+```
+
+The example smoke checkpoint keeps the original hidden dimensions intact and only trims layer counts, which keeps the HF config compatible while making single-GPU validation practical.
+
+## Data Preparation (Omni Bench)
+
+If you have the Omni Bench parquet data locally, you can convert it into JSONL plus extracted media assets:
+
+```bash
+python examples/models/vlm/qwen3_omni/convert_omni_bench_to_jsonl.py \
+  --input-root ./Omni_Bench_fix_simple \
+  --output-root ./omni_bench_fix_simple \
+  --splits train test
+```
+
+This produces:
+- `./omni_bench_fix_simple/train/train.jsonl`
+- `./omni_bench_fix_simple/test/test.jsonl`
+- extracted media under `./omni_bench_fix_simple/{split}/media`
+
+## Checkpoint Conversion
+
+Run the full local smoke conversion flow:
+
+```bash
+export SOURCE_HF_MODEL=/path/to/Qwen3-Omni-30B-A3B-Instruct
+bash examples/models/vlm/qwen3_omni/conversion.sh
+```
+
+This script will:
+
+1. create a reduced thinker-only HF smoke checkpoint
+2. import that checkpoint into Megatron format
+3. export the imported Megatron checkpoint back to HF format
+
+## Inference
+
+Run local inference across the reduced HF checkpoint, imported Megatron checkpoint, and exported HF checkpoint:
+
+```bash
+export VIDEO_PATH=/path/to/example.mp4
+bash examples/models/vlm/qwen3_omni/inference.sh
+```
+
+If you want to use the audio track from the video during understanding:
+
+```bash
+export VIDEO_PATH=/path/to/example.mp4
+export USE_AUDIO_IN_VIDEO=1
+bash examples/models/vlm/qwen3_omni/inference.sh
+```
+
+You can also use a remote video URL instead of a local file:
+
+```bash
+export VIDEO_URL=https://example.com/example.mp4
+bash examples/models/vlm/qwen3_omni/inference.sh
+```
+
+This script reuses [examples/conversion/hf_to_megatron_generate_omni_lm.py](../../../conversion/hf_to_megatron_generate_omni_lm.py) and runs:
+
+- inference with the reduced local HF smoke checkpoint
+- inference with the imported Megatron checkpoint
+- inference with the exported HF checkpoint
+
+Useful overrides:
+
+- `PROMPT` (default: `What is happening in this video?`)
+- `MAX_NEW_TOKENS` (default: `50`)
+- `NPROC_PER_NODE` / `TP` / `PP` / `EP` / `ETP` (default: `1`)
+- `DRY_RUN=1` to print commands without executing them
+
+The omni inference helper depends on `qwen-omni-utils[decord]` for video/audio preprocessing.
+
+## Training (local)
+
+The training recipe entrypoint is:
+
+```bash
+bash examples/models/vlm/qwen3_omni/local_train_thinker_full.sh
+```
+
+Required environment variables:
+
+```bash
+export HF_MODEL_PATH=/path/to/Qwen3-Omni-30B-A3B-Instruct
+export TRAIN_JSONL=/path/to/train.jsonl
+```
+
+Optional overrides:
+
+- `WORKSPACE` (default: `${PWD}/.cache/qwen3_omni_train`)
+- `RESULTS_DIR` / `LOG_DIR` (default: under `WORKSPACE`)
+
+To apply the 4-node TP2/PP2/EP8/SP preset used in our 32-GPU validation:
+
+```bash
+export PRESET=4node_tp2_ep8_sp
+bash examples/models/vlm/qwen3_omni/local_train_thinker_full.sh
+```
diff --git a/examples/models/vlm/qwen3_omni/conversion.sh b/examples/models/vlm/qwen3_omni/conversion.sh
new file mode 100755
index 0000000000..5e0bc31d02
--- /dev/null
+++ b/examples/models/vlm/qwen3_omni/conversion.sh
@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+# Copyright (c) 2026, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set -euo pipefail
+
+SCRIPT_DIR=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)
+ROOT_DIR=$(cd -- "${SCRIPT_DIR}/../../../.." && pwd)
+
+WORKSPACE=${WORKSPACE:-${ROOT_DIR}/.cache/qwen3_omni_examples}
+SOURCE_HF_MODEL=${SOURCE_HF_MODEL:-}
+SMOKE_MODEL_NAME=${SMOKE_MODEL_NAME:-Qwen3-Omni-30B-A3B-Instruct-smoke}
+TEXT_LAYERS=${TEXT_LAYERS:-2}
+VISION_DEPTH=${VISION_DEPTH:-2}
+AUDIO_LAYERS=${AUDIO_LAYERS:-2}
+TMPDIR=${TMPDIR:-${WORKSPACE}/tmp}
+HF_HOME=${HF_HOME:-${WORKSPACE}/hf_home}
+PYTHON=${PYTHON:-python}
+PYTHONPATH=${PYTHONPATH:-${ROOT_DIR}/src:${ROOT_DIR}/3rdparty/Megatron-LM}
+
+HF_SMOKE_PATH=${HF_SMOKE_PATH:-${WORKSPACE}/hf/${SMOKE_MODEL_NAME}}
+MEGATRON_PATH=${MEGATRON_PATH:-${WORKSPACE}/megatron/${SMOKE_MODEL_NAME}}
+HF_EXPORT_PATH=${HF_EXPORT_PATH:-${WORKSPACE}/export/${SMOKE_MODEL_NAME}}
+
+export TMPDIR HF_HOME PYTHONPATH
+mkdir -p "${WORKSPACE}/hf" "${WORKSPACE}/megatron" "${WORKSPACE}/export" "${TMPDIR}" "${HF_HOME}"
+cd "${ROOT_DIR}"
+
+if [[ -z "${SOURCE_HF_MODEL}" ]]; then
+  echo "SOURCE_HF_MODEL must point to a local HF Qwen3-Omni checkpoint or model id." >&2
+  exit 1
+fi
+
+"${PYTHON}" examples/models/vlm/qwen3_omni/create_smoke_checkpoint.py \
+  --source-model-path "${SOURCE_HF_MODEL}" \
+  --output-dir "${HF_SMOKE_PATH}" \
+  --text-layers "${TEXT_LAYERS}" \
+  --vision-depth "${VISION_DEPTH}" \
+  --audio-layers "${AUDIO_LAYERS}"
+
+"${PYTHON}" examples/conversion/convert_checkpoints.py import \
+  --hf-model "${HF_SMOKE_PATH}" \
+  --megatron-path "${MEGATRON_PATH}" \
+  --torch-dtype bfloat16
+
+"${PYTHON}" examples/conversion/convert_checkpoints.py export \
+  --hf-model "${HF_SMOKE_PATH}" \
+  --megatron-path "${MEGATRON_PATH}/iter_0000000" \
+  --hf-path "${HF_EXPORT_PATH}"
+
+echo "HF smoke checkpoint: ${HF_SMOKE_PATH}"
+echo "Megatron checkpoint: ${MEGATRON_PATH}/iter_0000000"
+echo "HF export checkpoint: ${HF_EXPORT_PATH}"
diff --git a/examples/models/vlm/qwen3_omni/convert_omni_bench_to_jsonl.py b/examples/models/vlm/qwen3_omni/convert_omni_bench_to_jsonl.py
new file mode 100644
index 0000000000..55d3acfa34
--- /dev/null
+++ b/examples/models/vlm/qwen3_omni/convert_omni_bench_to_jsonl.py
@@ -0,0 +1,289 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Convert Omni Bench parquet data into local JSONL + media assets."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import shutil
+import wave
+from io import BytesIO
+from pathlib import Path
+from typing import Any, Iterable
+
+import numpy as np
+import pandas as pd
+from PIL import Image
+
+
+PLACEHOLDER_PATTERN = re.compile(r"<image>|<audio>|<video>")
+
+
+def strip_placeholders(text: str) -> str:
+    """Remove multimodal placeholders and normalize whitespace."""
+    cleaned = PLACEHOLDER_PATTERN.sub(" ", text)
+    return " ".join(cleaned.split())
+
+
+def _as_list(value: Any) -> list[Any]:
+    """Normalize parquet cell values into a Python list."""
+    if value is None:
+        return []
+    if isinstance(value, list):
+        return value
+    if isinstance(value, tuple):
+        return list(value)
+    if isinstance(value, np.ndarray):
+        return list(value.tolist() if value.dtype != object else value)
+    return [value]
+
+
+def save_image(image_item: Any, output_path: Path) -> Path:
+    """Write one image item to disk and return the output path."""
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    if isinstance(image_item, dict):
+        img_bytes = image_item.get("bytes")
+        img_path = image_item.get("path")
+        if img_bytes:
+            image = Image.open(BytesIO(img_bytes))
+            image.save(output_path)
+            return output_path
+        if img_path:
+            src = Path(img_path)
+            if src.resolve() != output_path.resolve():
+                shutil.copy2(src, output_path)
+            return output_path
+
+    if isinstance(image_item, (bytes, bytearray)):
+        image = Image.open(BytesIO(image_item))
+        image.save(output_path)
+        return output_path
+
+    raise ValueError(f"Unsupported image item type: {type(image_item)!r}")
+
+
+def save_audio(audio_item: Any, output_path: Path, sample_rate: int) -> Path:
+    """Write one audio waveform to a WAV file and return the output path."""
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    if isinstance(audio_item, dict):
+        if "array" in audio_item:
+            sample_rate = int(audio_item.get("sampling_rate", sample_rate))
+            audio_item = audio_item["array"]
+        elif "path" in audio_item and audio_item["path"]:
+            src = Path(audio_item["path"])
+            if src.resolve() != output_path.resolve():
+                shutil.copy2(src, output_path)
+            return output_path
+
+    audio = np.asarray(audio_item, dtype=np.float32)
+    audio = np.nan_to_num(audio)
+    audio = np.clip(audio, -1.0, 1.0)
+    pcm = (audio * 32767.0).astype(np.int16)
+
+    with wave.open(str(output_path), "wb") as wav_file:
+        wav_file.setnchannels(1)
+        wav_file.setsampwidth(2)
+        wav_file.setframerate(sample_rate)
+        wav_file.writeframes(pcm.tobytes())
+
+    return output_path
+
+
+def save_video(video_item: Any, output_path: Path) -> Path:
+    """Write one video item to disk and return the output path."""
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    if isinstance(video_item, dict):
+        if video_item.get("bytes"):
+            output_path.write_bytes(video_item["bytes"])
+            return output_path
+        if video_item.get("path"):
+            src = Path(video_item["path"])
+            if src.resolve() != output_path.resolve():
+                shutil.copy2(src, output_path)
+            return output_path
+
+    if isinstance(video_item, (bytes, bytearray)):
+        output_path.write_bytes(video_item)
+        return output_path
+
+    raise ValueError(f"Unsupported video item type: {type(video_item)!r}")
+
+
+def build_user_content(
+    prompt_text: str,
+    image_paths: list[str],
+    audio_paths: list[str],
+    video_paths: list[str] | None = None,
+) -> list[dict[str, Any]]:
+    """Build multimodal user content by preserving placeholder order from the prompt."""
+    video_paths = video_paths or []
+    image_idx = 0
+    audio_idx = 0
+    video_idx = 0
+    content: list[dict[str, Any]] = []
+    last_end = 0
+
+    for match in PLACEHOLDER_PATTERN.finditer(prompt_text):
+        text_segment = prompt_text[last_end : match.start()]
+        if text_segment.strip():
+            content.append({"type": "text", "text": " ".join(text_segment.split())})
+
+        token = match.group(0)
+        if token == "<image>" and image_idx < len(image_paths):
+            content.append({"type": "image", "image": image_paths[image_idx]})
+            image_idx += 1
+        elif token == "<audio>" and audio_idx < len(audio_paths):
+            content.append({"type": "audio", "audio": audio_paths[audio_idx]})
+            audio_idx += 1
+        elif token == "<video>" and video_idx < len(video_paths):
+            content.append({"type": "video", "video": video_paths[video_idx]})
+            video_idx += 1
+
+        last_end = match.end()
+
+    trailing = prompt_text[last_end:]
+    if trailing.strip():
+        content.append({"type": "text", "text": " ".join(trailing.split())})
+
+    if not content:
+        content.append({"type": "text", "text": strip_placeholders(prompt_text)})
+
+    return content
+
+
+def convert_dataframe(
+    df: pd.DataFrame,
+    split: str,
+    output_root: Path,
+    audio_sample_rate: int,
+) -> tuple[Path, int]:
+    """Convert one parquet dataframe split into JSONL plus extracted media."""
+    split_dir = output_root / split
+    media_dir = split_dir / "media"
+    jsonl_path = split_dir / f"{split}.jsonl"
+    split_dir.mkdir(parents=True, exist_ok=True)
+    media_dir.mkdir(parents=True, exist_ok=True)
+
+    num_written = 0
+    with jsonl_path.open("w", encoding="utf-8") as jsonl_file:
+        for row_idx, (_, row) in enumerate(df.iterrows()):
+            sample_id = int(row.get("extra_info", {}).get("index", row_idx))
+
+            prompt_items = _as_list(row.get("prompt"))
+            prompt_entry = prompt_items[0] if prompt_items else {}
+            prompt_text = prompt_entry.get("content") if isinstance(prompt_entry, dict) else str(prompt_entry)
+            prompt_text = str(prompt_text or row.get("extra_info", {}).get("question", ""))
+
+            answer = row.get("reward_model", {}).get("ground_truth") or row.get("extra_info", {}).get("answer") or ""
+
+            image_paths: list[str] = []
+            for image_idx, image_item in enumerate(_as_list(row.get("images"))):
+                image_path = media_dir / f"{split}_{sample_id:05d}_image_{image_idx}.png"
+                image_paths.append(str(save_image(image_item, image_path)))
+
+            audio_paths: list[str] = []
+            for audio_idx, audio_item in enumerate(_as_list(row.get("audios"))):
+                audio_path = media_dir / f"{split}_{sample_id:05d}_audio_{audio_idx}.wav"
+                audio_paths.append(str(save_audio(audio_item, audio_path, audio_sample_rate)))
+
+            video_paths: list[str] = []
+            if "videos" in row:
+                for video_idx, video_item in enumerate(_as_list(row.get("videos"))):
+                    video_path = media_dir / f"{split}_{sample_id:05d}_video_{video_idx}.mp4"
+                    video_paths.append(str(save_video(video_item, video_path)))
+
+            example = {
+                "conversation": [
+                    {
+                        "role": "user",
+                        "content": build_user_content(prompt_text, image_paths, audio_paths, video_paths),
+                    },
+                    {
+                        "role": "assistant",
+                        "content": [{"type": "text", "text": str(answer)}],
+                    },
+                ],
+                "metadata": {
+                    "data_source": row.get("data_source"),
+                    "ability": row.get("ability"),
+                    "reward_model": row.get("reward_model"),
+                    "extra_info": row.get("extra_info"),
+                },
+            }
+            jsonl_file.write(json.dumps(example, ensure_ascii=False) + "\n")
+            num_written += 1
+
+    return jsonl_path, num_written
+
+
+def infer_splits(input_paths: Iterable[Path]) -> dict[str, Path]:
+    """Infer split names from parquet filenames."""
+    result: dict[str, Path] = {}
+    for path in input_paths:
+        split = path.stem
+        result[split] = path
+    return result
+
+
+def main() -> None:
+    """CLI entry point."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--input-root",
+        type=Path,
+        default=Path("./Omni_Bench_fix_simple"),
+        help="Directory containing train/test parquet files.",
+    )
+    parser.add_argument(
+        "--output-root",
+        type=Path,
+        default=Path("./omni_bench_fix_simple"),
+        help="Output directory for JSONL and extracted media.",
+    )
+    parser.add_argument(
+        "--splits",
+        nargs="*",
+        default=("train", "test"),
+        help="Split names to convert. Defaults to train and test.",
+    )
+    parser.add_argument(
+        "--audio-sample-rate",
+        type=int,
+        default=16000,
+        help="Sample rate to use when writing WAV files from waveform arrays.",
+    )
+    args = parser.parse_args()
+
+    parquet_paths = []
+    for split in args.splits:
+        path = args.input_root / f"{split}.parquet"
+        if not path.exists():
+            raise FileNotFoundError(f"Missing parquet split: {path}")
+        parquet_paths.append(path)
+
+    for split, path in infer_splits(parquet_paths).items():
+        df = pd.read_parquet(path)
+        jsonl_path, num_written = convert_dataframe(df, split, args.output_root, args.audio_sample_rate)
+        print(f"[done] split={split} rows={num_written} jsonl={jsonl_path}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/models/vlm/qwen3_omni/create_smoke_checkpoint.py b/examples/models/vlm/qwen3_omni/create_smoke_checkpoint.py
new file mode 100755
index 0000000000..7d5110c462
--- /dev/null
+++ b/examples/models/vlm/qwen3_omni/create_smoke_checkpoint.py
@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Create a thinker-only Qwen3-Omni smoke checkpoint for local single-GPU validation."""
+
+import argparse
+import json
+import re
+import shutil
+from collections import defaultdict
+from pathlib import Path
+
+from safetensors import safe_open
+from safetensors.torch import save_file
+
+
+ARTIFACTS_TO_COPY = [
+    "chat_template.json",
+    "configuration.json",
+    "generation_config.json",
+    "merges.txt",
+    "preprocessor_config.json",
+    "tokenizer_config.json",
+    "vocab.json",
+]
+
+
+def keep_weight(
+    key: str,
+    text_layers: int,
+    vision_depth: int,
+    audio_layers: int,
+    deepstack_count: int,
+) -> bool:
+    """Return whether a tensor should be kept in the reduced thinker-only checkpoint."""
+    if not key.startswith("thinker."):
+        return False
+
+    merger_match = re.match(r"^thinker\.visual\.merger_list\.(\d+)\.", key)
+    if merger_match is not None:
+        return int(merger_match.group(1)) < deepstack_count
+
+    layer_patterns = [
+        (re.compile(r"^thinker\.model\.layers\.(\d+)\."), text_layers),
+        (re.compile(r"^thinker\.visual\.blocks\.(\d+)\."), vision_depth),
+        (re.compile(r"^thinker\.audio_tower\.layers\.(\d+)\."), audio_layers),
+    ]
+    for pattern, limit in layer_patterns:
+        match = pattern.match(key)
+        if match is not None:
+            return int(match.group(1)) < limit
+
+    return True
+
+
+def create_smoke_checkpoint(
+    source_model_path: Path,
+    output_dir: Path,
+    text_layers: int,
+    vision_depth: int,
+    audio_layers: int,
+) -> Path:
+    """Materialize a reduced thinker-only checkpoint while preserving hidden dimensions."""
+    if output_dir.exists():
+        shutil.rmtree(output_dir)
+    output_dir.mkdir(parents=True)
+
+    config = json.loads((source_model_path / "config.json").read_text())
+    config["enable_audio_output"] = False
+    config["thinker_config"]["text_config"]["num_hidden_layers"] = text_layers
+    config["thinker_config"]["vision_config"]["depth"] = vision_depth
+    config["thinker_config"]["vision_config"]["deepstack_visual_indexes"] = [0]
+    config["thinker_config"]["audio_config"]["encoder_layers"] = audio_layers
+    config["thinker_config"]["audio_config"]["num_hidden_layers"] = audio_layers
+    (output_dir / "config.json").write_text(json.dumps(config, indent=2))
+
+    for artifact in ARTIFACTS_TO_COPY:
+        source = source_model_path / artifact
+        if source.exists():
+            shutil.copy2(source, output_dir / artifact)
+
+    index = json.loads((source_model_path / "model.safetensors.index.json").read_text())
+    selected_keys = [
+        key
+        for key in index["weight_map"]
+        if keep_weight(
+            key,
+            text_layers=text_layers,
+            vision_depth=vision_depth,
+            audio_layers=audio_layers,
+            deepstack_count=1,
+        )
+    ]
+    by_file: dict[str, list[str]] = defaultdict(list)
+    for key in selected_keys:
+        by_file[index["weight_map"][key]].append(key)
+
+    state_dict = {}
+    for filename, keys in sorted(by_file.items()):
+        with safe_open(source_model_path / filename, framework="pt", device="cpu") as handle:
+            for key in keys:
+                state_dict[key] = handle.get_tensor(key)
+
+    save_file(state_dict, str(output_dir / "model.safetensors"))
+    return output_dir
+
+
+def parse_args() -> argparse.Namespace:
+    """Parse command-line arguments for smoke checkpoint creation."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--source-model-path",
+        type=Path,
+        required=True,
+        help="Path to the full Hugging Face Qwen3-Omni checkpoint.",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        required=True,
+        help="Directory where the reduced thinker-only smoke checkpoint will be written.",
+    )
+    parser.add_argument("--text-layers", type=int, default=2, help="Number of thinker text layers to keep.")
+    parser.add_argument("--vision-depth", type=int, default=2, help="Number of thinker vision blocks to keep.")
+    parser.add_argument("--audio-layers", type=int, default=2, help="Number of thinker audio layers to keep.")
+    return parser.parse_args()
+
+
+def main() -> None:
+    """Create the reduced checkpoint and print the output location."""
+    args = parse_args()
+    output_dir = create_smoke_checkpoint(
+        source_model_path=args.source_model_path,
+        output_dir=args.output_dir,
+        text_layers=args.text_layers,
+        vision_depth=args.vision_depth,
+        audio_layers=args.audio_layers,
+    )
+    print(output_dir)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/models/vlm/qwen3_omni/inference.sh b/examples/models/vlm/qwen3_omni/inference.sh
new file mode 100755
index 0000000000..05f913b1e7
--- /dev/null
+++ b/examples/models/vlm/qwen3_omni/inference.sh
@@ -0,0 +1,109 @@
+#!/usr/bin/env bash
+# Copyright (c) 2026, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set -euo pipefail
+
+SCRIPT_DIR=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)
+ROOT_DIR=$(cd -- "${SCRIPT_DIR}/../../../.." && pwd)
+
+WORKSPACE=${WORKSPACE:-${ROOT_DIR}/.cache/qwen3_omni_examples}
+SMOKE_MODEL_NAME=${SMOKE_MODEL_NAME:-Qwen3-Omni-30B-A3B-Instruct-smoke}
+TMPDIR=${TMPDIR:-${WORKSPACE}/tmp}
+HF_HOME=${HF_HOME:-${WORKSPACE}/hf_home}
+PYTHONPATH=${PYTHONPATH:-${ROOT_DIR}/src:${ROOT_DIR}/3rdparty/Megatron-LM}
+
+HF_SMOKE_PATH=${HF_SMOKE_PATH:-${WORKSPACE}/hf/${SMOKE_MODEL_NAME}}
+MEGATRON_MODEL_PATH=${MEGATRON_MODEL_PATH:-${WORKSPACE}/megatron/${SMOKE_MODEL_NAME}/iter_0000000}
+HF_EXPORT_PATH=${HF_EXPORT_PATH:-${WORKSPACE}/export/${SMOKE_MODEL_NAME}}
+
+PROMPT=${PROMPT:-What is happening in this video?}
+VIDEO_PATH=${VIDEO_PATH:-}
+VIDEO_URL=${VIDEO_URL:-}
+USE_AUDIO_IN_VIDEO=${USE_AUDIO_IN_VIDEO:-0}
+MAX_NEW_TOKENS=${MAX_NEW_TOKENS:-50}
+NPROC_PER_NODE=${NPROC_PER_NODE:-1}
+TP=${TP:-1}
+PP=${PP:-1}
+EP=${EP:-1}
+ETP=${ETP:-1}
+TRUST_REMOTE_CODE=${TRUST_REMOTE_CODE:-0}
+DRY_RUN=${DRY_RUN:-0}
+
+export TMPDIR HF_HOME PYTHONPATH
+mkdir -p "${TMPDIR}" "${HF_HOME}"
+cd "${ROOT_DIR}"
+
+if [[ -z "${VIDEO_PATH}" && -z "${VIDEO_URL}" ]]; then
+  echo "Either VIDEO_PATH or VIDEO_URL must be provided for omni inference." >&2
+  exit 1
+fi
+
+if [[ -n "${VIDEO_PATH}" && -n "${VIDEO_URL}" ]]; then
+  echo "Please set only one of VIDEO_PATH or VIDEO_URL." >&2
+  exit 1
+fi
+
+if [[ -n "${VIDEO_PATH}" && ! -f "${VIDEO_PATH}" ]]; then
+  echo "VIDEO_PATH does not exist: ${VIDEO_PATH}" >&2
+  exit 1
+fi
+
+COMMON_ARGS=(
+  --prompt "${PROMPT}"
+  --max_new_tokens "${MAX_NEW_TOKENS}"
+  --tp "${TP}"
+  --pp "${PP}"
+  --ep "${EP}"
+  --etp "${ETP}"
+)
+
+if [[ -n "${VIDEO_PATH}" ]]; then
+  COMMON_ARGS+=(--video_path "${VIDEO_PATH}")
+else
+  COMMON_ARGS+=(--video_url "${VIDEO_URL}")
+fi
+
+if [[ "${USE_AUDIO_IN_VIDEO}" == "1" ]]; then
+  COMMON_ARGS+=(--use_audio_in_video)
+fi
+
+if [[ "${TRUST_REMOTE_CODE}" == "1" ]]; then
+  COMMON_ARGS+=(--trust_remote_code)
+fi
+
+run_cmd() {
+  if [[ "${DRY_RUN}" == "1" ]]; then
+    printf '[dry-run] %q ' "$@"
+    printf '\n'
+    return 0
+  fi
+  "$@"
+}
+
+run_cmd uv run python -m torch.distributed.run --nproc_per_node="${NPROC_PER_NODE}" \
+  examples/conversion/hf_to_megatron_generate_omni_lm.py \
+  --hf_model_path "${HF_SMOKE_PATH}" \
+  "${COMMON_ARGS[@]}"
+
+run_cmd uv run python -m torch.distributed.run --nproc_per_node="${NPROC_PER_NODE}" \
+  examples/conversion/hf_to_megatron_generate_omni_lm.py \
+  --hf_model_path "${HF_SMOKE_PATH}" \
+  --megatron_model_path "${MEGATRON_MODEL_PATH}" \
+  "${COMMON_ARGS[@]}"
+
+run_cmd uv run python -m torch.distributed.run --nproc_per_node="${NPROC_PER_NODE}" \
+  examples/conversion/hf_to_megatron_generate_omni_lm.py \
+  --hf_model_path "${HF_EXPORT_PATH}" \
+  "${COMMON_ARGS[@]}"
diff --git a/examples/models/vlm/qwen3_omni/local_train_thinker_full.sh b/examples/models/vlm/qwen3_omni/local_train_thinker_full.sh
new file mode 100755
index 0000000000..94aa6df85a
--- /dev/null
+++ b/examples/models/vlm/qwen3_omni/local_train_thinker_full.sh
@@ -0,0 +1,470 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd -P)
+ROOT_DIR=$(cd -- "${SCRIPT_DIR}/../../../.." && pwd -P)
+
+export PYTHONNOUSERSITE=1
+export PYTHONPATH="${ROOT_DIR}/src:${ROOT_DIR}/3rdparty/Megatron-LM${PYTHONPATH:+:${PYTHONPATH}}"
+
+WORKSPACE=${WORKSPACE:-${ROOT_DIR}/.cache/qwen3_omni_train}
+HF_HOME=${HF_HOME:-${WORKSPACE}/hf_home}
+TMPDIR=${TMPDIR:-${WORKSPACE}/tmp}
+RESULTS_DIR=${RESULTS_DIR:-${WORKSPACE}/results}
+LOG_DIR=${LOG_DIR:-${WORKSPACE}/logs}
+
+mkdir -p "${WORKSPACE}" "${HF_HOME}" "${TMPDIR}" "${RESULTS_DIR}" "${LOG_DIR}"
+
+PYTHON_BIN=${PYTHON_BIN:-python}
+
+HF_MODEL_PATH=${HF_MODEL_PATH:-}
+THINKER_ONLY_MIRROR_DIR=${THINKER_ONLY_MIRROR_DIR:-${WORKSPACE}/hf_thinker_only}
+LOCAL_DATA_ROOT=${LOCAL_DATA_ROOT:-}
+TRAIN_JSONL=${TRAIN_JSONL:-}
+VALID_JSONL=${VALID_JSONL:-}
+TEST_JSONL=${TEST_JSONL:-}
+DATASET_NUM_WORKERS=${DATASET_NUM_WORKERS:-0}
+DATASET_PERSISTENT_WORKERS=${DATASET_PERSISTENT_WORKERS:-False}
+
+if [[ -z "${HF_MODEL_PATH}" ]]; then
+  echo "[error] HF_MODEL_PATH is required (local HF checkpoint or model id)." >&2
+  exit 1
+fi
+
+if [[ -n "${LOCAL_DATA_ROOT}" ]]; then
+  TRAIN_JSONL=${TRAIN_JSONL:-${LOCAL_DATA_ROOT}/train/train.jsonl}
+  VALID_JSONL=${VALID_JSONL:-${LOCAL_DATA_ROOT}/test/test.jsonl}
+  TEST_JSONL=${TEST_JSONL:-${LOCAL_DATA_ROOT}/test/test.jsonl}
+fi
+
+if [[ -z "${TRAIN_JSONL}" ]]; then
+  echo "[error] TRAIN_JSONL is required (set TRAIN_JSONL or LOCAL_DATA_ROOT)." >&2
+  exit 1
+fi
+
+RECIPE=${RECIPE:-qwen3_omni_30b_a3b_sft_preloaded_config}
+STEP_FUNC=${STEP_FUNC:-qwen3_omni_step}
+SEQ_LENGTH=${SEQ_LENGTH:-4096}
+TRAIN_ITERS=${TRAIN_ITERS:-20}
+GLOBAL_BATCH_SIZE=${GLOBAL_BATCH_SIZE:-8}
+MICRO_BATCH_SIZE=${MICRO_BATCH_SIZE:-1}
+EVAL_ITERS=${EVAL_ITERS:-0}
+EVAL_INTERVAL=${EVAL_INTERVAL:-0}
+LOG_INTERVAL=${LOG_INTERVAL:-1}
+SAVE_INTERVAL=${SAVE_INTERVAL:-0}
+TENSOR_PARALLEL_SIZE=${TENSOR_PARALLEL_SIZE:-1}
+PIPELINE_PARALLEL_SIZE=${PIPELINE_PARALLEL_SIZE:-1}
+CONTEXT_PARALLEL_SIZE=${CONTEXT_PARALLEL_SIZE:-1}
+EXPERT_MODEL_PARALLEL_SIZE=${EXPERT_MODEL_PARALLEL_SIZE:-1}
+EXPERT_TENSOR_PARALLEL_SIZE=${EXPERT_TENSOR_PARALLEL_SIZE:-1}
+SEQUENCE_PARALLEL=${SEQUENCE_PARALLEL:-False}
+VIT_GRADIENT_CHECKPOINTING=${VIT_GRADIENT_CHECKPOINTING:-False}
+MULTIMODAL_ATTN_IMPL=${MULTIMODAL_ATTN_IMPL:-auto}
+ATTENTION_BACKEND=${ATTENTION_BACKEND:-auto}
+RECOMPUTE_GRANULARITY=${RECOMPUTE_GRANULARITY:-}
+RECOMPUTE_METHOD=${RECOMPUTE_METHOD:-}
+RECOMPUTE_NUM_LAYERS=${RECOMPUTE_NUM_LAYERS:-}
+RECOMPUTE_MODULES=${RECOMPUTE_MODULES:-}
+FREEZE_LANGUAGE_MODEL=${FREEZE_LANGUAGE_MODEL:-False}
+FREEZE_VISION_MODEL=${FREEZE_VISION_MODEL:-False}
+FREEZE_AUDIO_MODEL=${FREEZE_AUDIO_MODEL:-False}
+OPTIMIZER_CPU_OFFLOAD=${OPTIMIZER_CPU_OFFLOAD:-}
+OPTIMIZER_OFFLOAD_FRACTION=${OPTIMIZER_OFFLOAD_FRACTION:-}
+USE_PRECISION_AWARE_OPTIMIZER=${USE_PRECISION_AWARE_OPTIMIZER:-}
+OVERLAP_GRAD_REDUCE=${OVERLAP_GRAD_REDUCE:-}
+OVERLAP_PARAM_GATHER=${OVERLAP_PARAM_GATHER:-}
+ALIGN_PARAM_GATHER=${ALIGN_PARAM_GATHER:-}
+USE_PYTORCH_PROFILER=${USE_PYTORCH_PROFILER:-}
+USE_NSYS_PROFILER=${USE_NSYS_PROFILER:-}
+PROFILE_STEP_START=${PROFILE_STEP_START:-}
+PROFILE_STEP_END=${PROFILE_STEP_END:-}
+PROFILE_RANKS=${PROFILE_RANKS:-}
+PYTORCH_PROFILER_COLLECT_SHAPES=${PYTORCH_PROFILER_COLLECT_SHAPES:-}
+PYTORCH_PROFILER_COLLECT_CALLSTACK=${PYTORCH_PROFILER_COLLECT_CALLSTACK:-}
+PYTORCH_PROFILER_COLLECT_CHAKRA=${PYTORCH_PROFILER_COLLECT_CHAKRA:-}
+RECORD_MEMORY_HISTORY=${RECORD_MEMORY_HISTORY:-}
+NVTX_RANGES=${NVTX_RANGES:-}
+NUM_GPUS=${NUM_GPUS:-8}
+NNODES=${NNODES:-${DISTRIBUTED_NODE_COUNT:-${WORLD_SIZE:-1}}}
+TASK_ROLE=${DISTRIBUTED_TASK_ROLE:-}
+TASK_INDEX=${VC_TASK_INDEX:-}
+NODE_RANK=${NODE_RANK:-}
+MASTER_ADDR=${MASTER_ADDR:-${VC_MASTER_HOSTS:-${MASTER_HOST:-${TORCH_MASTER_ADDR:-127.0.0.1}}}}
+MASTER_PORT=${MASTER_PORT:-${PET_MASTER_PORT:-${TORCH_MASTER_PORT:-29500}}}
+WANDB_MODE=${WANDB_MODE:-disabled}
+RUN_NAME=${RUN_NAME:-qwen3_omni_full_train_baseline}
+ENABLE_PERF_SUMMARY=${ENABLE_PERF_SUMMARY:-1}
+PERF_TAG=${PERF_TAG:-full}
+LOG_PATH=${LOG_PATH:-${LOG_DIR}/${RUN_NAME}_${PERF_TAG}.log}
+TENSORBOARD_DIR=${TENSORBOARD_DIR:-${RESULTS_DIR}/${RUN_NAME}/tb_logs}
+PYTORCH_CUDA_ALLOC_CONF=${PYTORCH_CUDA_ALLOC_CONF:-expandable_segments:True}
+
+export WANDB_MODE HF_HOME TMPDIR PYTORCH_CUDA_ALLOC_CONF
+export IMAGE_MAX_TOKEN_NUM=${IMAGE_MAX_TOKEN_NUM:-}
+export VIDEO_MAX_TOKEN_NUM=${VIDEO_MAX_TOKEN_NUM:-}
+export MAX_PIXELS=${MAX_PIXELS:-}
+export VIDEO_MAX_PIXELS=${VIDEO_MAX_PIXELS:-}
+export FPS_MAX_FRAMES=${FPS_MAX_FRAMES:-}
+
+PRESET=${PRESET:-}
+if [[ "${PRESET}" == "4node_tp2_ep8_sp" ]]; then
+    NUM_GPUS=8
+    NNODES=4
+    TENSOR_PARALLEL_SIZE=2
+    PIPELINE_PARALLEL_SIZE=2
+    CONTEXT_PARALLEL_SIZE=1
+    EXPERT_MODEL_PARALLEL_SIZE=8
+    EXPERT_TENSOR_PARALLEL_SIZE=1
+    SEQUENCE_PARALLEL=True
+    SEQ_LENGTH=16384
+    GLOBAL_BATCH_SIZE=16
+    MICRO_BATCH_SIZE=1
+    FREEZE_LANGUAGE_MODEL=False
+    FREEZE_VISION_MODEL=True
+    FREEZE_AUDIO_MODEL=True
+    VIT_GRADIENT_CHECKPOINTING=False
+    MULTIMODAL_ATTN_IMPL=auto
+    ATTENTION_BACKEND=flash
+    RECOMPUTE_GRANULARITY=full
+    RECOMPUTE_METHOD=uniform
+    RECOMPUTE_NUM_LAYERS=12
+    RECOMPUTE_MODULES=core_attn
+    OPTIMIZER_CPU_OFFLOAD=False
+    OPTIMIZER_OFFLOAD_FRACTION=0.0
+    USE_PRECISION_AWARE_OPTIMIZER=False
+    TRAIN_ITERS=${TRAIN_ITERS:-20}
+    LOG_INTERVAL=${LOG_INTERVAL:-5}
+    RUN_NAME=${RUN_NAME:-qwen3_omni_sft32_tp2_pp2_ep8_sp_seq16384}
+fi
+
+if [[ "${MASTER_ADDR}" == *,* ]]; then
+    MASTER_ADDR=${MASTER_ADDR%%,*}
+fi
+
+if [[ -z "${NODE_RANK}" ]]; then
+    if [[ -n "${TASK_ROLE}" && -n "${TASK_INDEX}" ]]; then
+        if [[ "${TASK_ROLE}" == "master" ]]; then
+            NODE_RANK=${TASK_INDEX}
+        else
+            NODE_RANK=$((TASK_INDEX + 1))
+        fi
+    else
+        NODE_RANK=${RANK:-${GROUP_RANK:-${SLURM_PROCID:-0}}}
+    fi
+fi
+
+resolve_master_addr_ipv4() {
+    local addr=$1
+    "${PYTHON_BIN}" - "$addr" <<'PY'
+import re
+import socket
+import sys
+
+addr = sys.argv[1]
+match = re.match(r"^(\d+)-(\d+)-(\d+)-(\d+)(?:\.|$)", addr)
+if match:
+    print(".".join(match.groups()))
+    raise SystemExit(0)
+
+try:
+    infos = socket.getaddrinfo(addr, None, socket.AF_INET, socket.SOCK_STREAM)
+except socket.gaierror:
+    print(addr)
+    raise SystemExit(0)
+
+seen = set()
+for info in infos:
+    ip = info[4][0]
+    if ip not in seen:
+        print(ip)
+        break
+    seen.add(ip)
+else:
+    print(addr)
+PY
+}
+
+MASTER_ADDR=$(resolve_master_addr_ipv4 "${MASTER_ADDR}")
+export MASTER_ADDR MASTER_PORT
+export TORCH_MASTER_ADDR="${MASTER_ADDR}"
+export TORCH_MASTER_PORT="${MASTER_PORT}"
+
+prepare_thinker_only_hf_path() {
+    local src_path=$1
+    local mirror_root=$2
+    local python_bin=$3
+
+    local config_path="${src_path}/config.json"
+    if [[ ! -f "${config_path}" ]]; then
+        echo "${src_path}"
+        return 0
+    fi
+
+    local mirror_path
+    mirror_path=$("${python_bin}" - "${src_path}" "${mirror_root}" <<'PY'
+import json
+import os
+import shutil
+import sys
+from pathlib import Path
+
+src = Path(sys.argv[1]).resolve()
+mirror_root = Path(sys.argv[2]).resolve()
+config_path = src / "config.json"
+
+with config_path.open() as f:
+    config = json.load(f)
+
+if not config.get("enable_audio_output", False):
+    print(str(src))
+    raise SystemExit(0)
+
+mirror = mirror_root / f"{src.name}-thinker-only"
+mirror.mkdir(parents=True, exist_ok=True)
+
+for child in src.iterdir():
+    dst = mirror / child.name
+    if child.name == "config.json":
+        continue
+    if dst.exists() or dst.is_symlink():
+        continue
+    try:
+        os.symlink(child, dst, target_is_directory=child.is_dir())
+    except FileExistsError:
+        pass
+
+patched = dict(config)
+patched["enable_audio_output"] = False
+patched["talker_config"] = None
+patched["code2wav_config"] = None
+
+tmp = mirror / f"config.json.tmp.{os.getpid()}"
+with tmp.open("w") as f:
+    json.dump(patched, f, indent=2, ensure_ascii=False)
+    f.write("\n")
+tmp.replace(mirror / "config.json")
+
+print(str(mirror))
+PY
+)
+
+    echo "${mirror_path}"
+}
+
+mkdir -p "${THINKER_ONLY_MIRROR_DIR}"
+EFFECTIVE_HF_MODEL_PATH=$(prepare_thinker_only_hf_path "${HF_MODEL_PATH}" "${THINKER_ONLY_MIRROR_DIR}" "${PYTHON_BIN}")
+
+CMD=(
+    "${PYTHON_BIN}" -m torch.distributed.run
+    --nproc_per_node="${NUM_GPUS}"
+    --nnodes="${NNODES}"
+    --node_rank="${NODE_RANK}"
+    --master_addr="${MASTER_ADDR}"
+    --master_port="${MASTER_PORT}"
+    "${ROOT_DIR}/scripts/training/run_recipe.py"
+    --mode finetune
+    --recipe "${RECIPE}"
+    --step_func "${STEP_FUNC}"
+    --hf_path "${EFFECTIVE_HF_MODEL_PATH}"
+    checkpoint.pretrained_checkpoint="${EFFECTIVE_HF_MODEL_PATH}"
+    checkpoint.save="${RESULTS_DIR}/${RUN_NAME}"
+    checkpoint.save_interval="${SAVE_INTERVAL}"
+    model.seq_length="${SEQ_LENGTH}"
+    model.tensor_model_parallel_size="${TENSOR_PARALLEL_SIZE}"
+    model.pipeline_model_parallel_size="${PIPELINE_PARALLEL_SIZE}"
+    model.context_parallel_size="${CONTEXT_PARALLEL_SIZE}"
+    model.expert_model_parallel_size="${EXPERT_MODEL_PARALLEL_SIZE}"
+    model.expert_tensor_parallel_size="${EXPERT_TENSOR_PARALLEL_SIZE}"
+    model.sequence_parallel="${SEQUENCE_PARALLEL}"
+    model.freeze_language_model="${FREEZE_LANGUAGE_MODEL}"
+    model.freeze_vision_model="${FREEZE_VISION_MODEL}"
+    model.freeze_audio_model="${FREEZE_AUDIO_MODEL}"
+    model.vit_gradient_checkpointing="${VIT_GRADIENT_CHECKPOINTING}"
+    model.multimodal_attn_impl="${MULTIMODAL_ATTN_IMPL}"
+    model.attention_backend="${ATTENTION_BACKEND}"
+    train.train_iters="${TRAIN_ITERS}"
+    train.global_batch_size="${GLOBAL_BATCH_SIZE}"
+    train.micro_batch_size="${MICRO_BATCH_SIZE}"
+    validation.eval_iters="${EVAL_ITERS}"
+    validation.eval_interval="${EVAL_INTERVAL}"
+    logger.log_interval="${LOG_INTERVAL}"
+    logger.log_throughput=True
+    logger.log_throughput_to_tensorboard=True
+    logger.tensorboard_dir="${TENSORBOARD_DIR}"
+    logger.log_timers_to_tensorboard=False
+    logger.wandb_exp_name="${RUN_NAME}"
+    dataset.seq_length="${SEQ_LENGTH}"
+    dataset.hf_processor_path="${EFFECTIVE_HF_MODEL_PATH}"
+    dataset.train_data_path="${TRAIN_JSONL}"
+    dataset.valid_data_path="${VALID_JSONL}"
+    dataset.test_data_path="${TEST_JSONL}"
+    dataset.num_workers="${DATASET_NUM_WORKERS}"
+    dataset.persistent_workers="${DATASET_PERSISTENT_WORKERS}"
+    dataset.pack_sequences_in_batch=False
+)
+
+if [[ -n "${RECOMPUTE_GRANULARITY}" ]]; then
+    CMD+=(model.recompute_granularity="${RECOMPUTE_GRANULARITY}")
+fi
+if [[ -n "${RECOMPUTE_METHOD}" ]]; then
+    CMD+=(model.recompute_method="${RECOMPUTE_METHOD}")
+fi
+if [[ -n "${RECOMPUTE_NUM_LAYERS}" ]]; then
+    CMD+=(model.recompute_num_layers="${RECOMPUTE_NUM_LAYERS}")
+fi
+if [[ -n "${RECOMPUTE_MODULES}" ]]; then
+    CMD+=(model.recompute_modules="${RECOMPUTE_MODULES}")
+fi
+if [[ -n "${OPTIMIZER_CPU_OFFLOAD}" ]]; then
+    CMD+=(optimizer.optimizer_cpu_offload="${OPTIMIZER_CPU_OFFLOAD}")
+fi
+if [[ -n "${OPTIMIZER_OFFLOAD_FRACTION}" ]]; then
+    CMD+=(optimizer.optimizer_offload_fraction="${OPTIMIZER_OFFLOAD_FRACTION}")
+fi
+if [[ -n "${USE_PRECISION_AWARE_OPTIMIZER}" ]]; then
+    CMD+=(optimizer.use_precision_aware_optimizer="${USE_PRECISION_AWARE_OPTIMIZER}")
+fi
+if [[ -n "${OVERLAP_GRAD_REDUCE}" ]]; then
+    CMD+=(ddp.overlap_grad_reduce="${OVERLAP_GRAD_REDUCE}")
+fi
+if [[ -n "${OVERLAP_PARAM_GATHER}" ]]; then
+    CMD+=(ddp.overlap_param_gather="${OVERLAP_PARAM_GATHER}")
+fi
+if [[ -n "${ALIGN_PARAM_GATHER}" ]]; then
+    CMD+=(ddp.align_param_gather="${ALIGN_PARAM_GATHER}")
+fi
+if [[ -n "${USE_PYTORCH_PROFILER}" ]]; then
+    CMD+=(profiling.use_pytorch_profiler="${USE_PYTORCH_PROFILER}")
+fi
+if [[ -n "${USE_NSYS_PROFILER}" ]]; then
+    CMD+=(profiling.use_nsys_profiler="${USE_NSYS_PROFILER}")
+fi
+if [[ -n "${PROFILE_STEP_START}" ]]; then
+    CMD+=(profiling.profile_step_start="${PROFILE_STEP_START}")
+fi
+if [[ -n "${PROFILE_STEP_END}" ]]; then
+    CMD+=(profiling.profile_step_end="${PROFILE_STEP_END}")
+fi
+if [[ -n "${PROFILE_RANKS}" ]]; then
+    CMD+=(profiling.profile_ranks="${PROFILE_RANKS}")
+fi
+if [[ -n "${PYTORCH_PROFILER_COLLECT_SHAPES}" ]]; then
+    CMD+=(profiling.pytorch_profiler_collect_shapes="${PYTORCH_PROFILER_COLLECT_SHAPES}")
+fi
+if [[ -n "${PYTORCH_PROFILER_COLLECT_CALLSTACK}" ]]; then
+    CMD+=(profiling.pytorch_profiler_collect_callstack="${PYTORCH_PROFILER_COLLECT_CALLSTACK}")
+fi
+if [[ -n "${PYTORCH_PROFILER_COLLECT_CHAKRA}" ]]; then
+    CMD+=(profiling.pytorch_profiler_collect_chakra="${PYTORCH_PROFILER_COLLECT_CHAKRA}")
+fi
+if [[ -n "${RECORD_MEMORY_HISTORY}" ]]; then
+    CMD+=(profiling.record_memory_history="${RECORD_MEMORY_HISTORY}")
+fi
+if [[ -n "${NVTX_RANGES}" ]]; then
+    CMD+=(profiling.nvtx_ranges="${NVTX_RANGES}")
+fi
+
+echo "[info] ROOT_DIR=${ROOT_DIR}"
+echo "[info] WORKSPACE=${WORKSPACE}"
+echo "[info] HF_MODEL_PATH=${HF_MODEL_PATH}"
+echo "[info] EFFECTIVE_HF_MODEL_PATH=${EFFECTIVE_HF_MODEL_PATH}"
+echo "[info] TRAIN_JSONL=${TRAIN_JSONL}"
+echo "[info] VALID_JSONL=${VALID_JSONL}"
+echo "[info] TEST_JSONL=${TEST_JSONL}"
+echo "[info] DATASET_NUM_WORKERS=${DATASET_NUM_WORKERS}"
+echo "[info] DATASET_PERSISTENT_WORKERS=${DATASET_PERSISTENT_WORKERS}"
+echo "[info] NUM_GPUS=${NUM_GPUS}"
+echo "[info] NNODES=${NNODES}"
+echo "[info] TASK_ROLE=${TASK_ROLE:-unset}"
+echo "[info] TASK_INDEX=${TASK_INDEX:-unset}"
+echo "[info] NODE_RANK=${NODE_RANK}"
+echo "[info] MASTER_ADDR=${MASTER_ADDR}"
+echo "[info] MASTER_PORT=${MASTER_PORT}"
+echo "[info] RUN_NAME=${RUN_NAME}"
+echo "[info] TENSORBOARD_DIR=${TENSORBOARD_DIR}"
+echo "[info] FREEZE_LANGUAGE_MODEL=${FREEZE_LANGUAGE_MODEL}"
+echo "[info] FREEZE_VISION_MODEL=${FREEZE_VISION_MODEL}"
+echo "[info] FREEZE_AUDIO_MODEL=${FREEZE_AUDIO_MODEL}"
+echo "[info] VIT_GRADIENT_CHECKPOINTING=${VIT_GRADIENT_CHECKPOINTING}"
+echo "[info] MULTIMODAL_ATTN_IMPL=${MULTIMODAL_ATTN_IMPL}"
+echo "[info] ATTENTION_BACKEND=${ATTENTION_BACKEND}"
+echo "[info] RECOMPUTE_GRANULARITY=${RECOMPUTE_GRANULARITY}"
+echo "[info] RECOMPUTE_METHOD=${RECOMPUTE_METHOD}"
+echo "[info] RECOMPUTE_NUM_LAYERS=${RECOMPUTE_NUM_LAYERS}"
+echo "[info] RECOMPUTE_MODULES=${RECOMPUTE_MODULES}"
+echo "[info] OPTIMIZER_CPU_OFFLOAD=${OPTIMIZER_CPU_OFFLOAD}"
+echo "[info] OPTIMIZER_OFFLOAD_FRACTION=${OPTIMIZER_OFFLOAD_FRACTION}"
+echo "[info] USE_PRECISION_AWARE_OPTIMIZER=${USE_PRECISION_AWARE_OPTIMIZER}"
+echo "[info] OVERLAP_GRAD_REDUCE=${OVERLAP_GRAD_REDUCE}"
+echo "[info] OVERLAP_PARAM_GATHER=${OVERLAP_PARAM_GATHER}"
+echo "[info] ALIGN_PARAM_GATHER=${ALIGN_PARAM_GATHER}"
+echo "[info] USE_PYTORCH_PROFILER=${USE_PYTORCH_PROFILER}"
+echo "[info] USE_NSYS_PROFILER=${USE_NSYS_PROFILER}"
+echo "[info] PROFILE_STEP_START=${PROFILE_STEP_START}"
+echo "[info] PROFILE_STEP_END=${PROFILE_STEP_END}"
+echo "[info] PROFILE_RANKS=${PROFILE_RANKS}"
+echo "[info] PYTORCH_PROFILER_COLLECT_SHAPES=${PYTORCH_PROFILER_COLLECT_SHAPES}"
+echo "[info] PYTORCH_PROFILER_COLLECT_CALLSTACK=${PYTORCH_PROFILER_COLLECT_CALLSTACK}"
+echo "[info] PYTORCH_PROFILER_COLLECT_CHAKRA=${PYTORCH_PROFILER_COLLECT_CHAKRA}"
+echo "[info] RECORD_MEMORY_HISTORY=${RECORD_MEMORY_HISTORY}"
+echo "[info] NVTX_RANGES=${NVTX_RANGES}"
+echo "[info] IMAGE_MAX_TOKEN_NUM=${IMAGE_MAX_TOKEN_NUM}"
+echo "[info] VIDEO_MAX_TOKEN_NUM=${VIDEO_MAX_TOKEN_NUM}"
+echo "[info] MAX_PIXELS=${MAX_PIXELS}"
+echo "[info] VIDEO_MAX_PIXELS=${VIDEO_MAX_PIXELS}"
+echo "[info] FPS_MAX_FRAMES=${FPS_MAX_FRAMES}"
+echo "[info] PYTHON_BIN=${PYTHON_BIN}"
+echo "[info] PYTHONPATH=${PYTHONPATH}"
+echo "[info] PYTHONNOUSERSITE=${PYTHONNOUSERSITE}"
+echo "[info] LOG_PATH=${LOG_PATH}"
+
+if [[ "${DRY_RUN:-0}" == "1" ]]; then
+    printf '[dry-run] %q ' "${CMD[@]}"
+    printf '\n'
+    exit 0
+fi
+
+cd "${ROOT_DIR}"
+SECONDS=0
+set -o pipefail
+"${CMD[@]}" 2>&1 | tee "${LOG_PATH}"
+WALL_TIME=${SECONDS}
+
+if [[ "${ENABLE_PERF_SUMMARY}" != "1" ]]; then
+    exit 0
+fi
+
+python - "${LOG_PATH}" "${GLOBAL_BATCH_SIZE}" "${SEQ_LENGTH}" "${WALL_TIME}" <<'PY'
+import re
+import sys
+from pathlib import Path
+
+log_path = Path(sys.argv[1])
+global_batch = int(sys.argv[2])
+seq_length = int(sys.argv[3])
+wall_time = int(sys.argv[4])
+
+elapsed = []
+throughput = []
+for line in log_path.read_text().splitlines():
+    if m := re.search(r"elapsed time per iteration \(ms\):\s+([\d.]+)", line):
+        elapsed.append(float(m.group(1)))
+    if m := re.search(r"throughput per GPU \(TFLOP/s/GPU\):\s+([\d.]+)", line):
+        throughput.append(float(m.group(1)))
+
+print("[perf] wall_time_s=", wall_time, sep="")
+if elapsed:
+    last_ms = elapsed[-1]
+    avg_ms = sum(elapsed) / len(elapsed)
+    nominal_tokens_per_sec = global_batch * seq_length / (avg_ms / 1000.0)
+    print(f"[perf] last_iter_ms={last_ms:.2f}")
+    print(f"[perf] avg_iter_ms={avg_ms:.2f}")
+    print(f"[perf] nominal_tokens_per_sec={nominal_tokens_per_sec:.2f}")
+else:
+    print("[perf] no iteration timing found in log")
+
+if throughput:
+    print(f"[perf] last_tflops_per_gpu={throughput[-1]:.2f}")
+else:
+    print("[perf] no throughput line found in log")
+PY
diff --git a/scripts/training/run_recipe.py b/scripts/training/run_recipe.py
index b9e92e90a8..6059fd1d7b 100755
--- a/scripts/training/run_recipe.py
+++ b/scripts/training/run_recipe.py
@@ -112,6 +112,7 @@
 # Diffusion forward steps: use class instances so they can be passed as forward_step_func
 from megatron.bridge.diffusion.models.flux.flux_step import FluxForwardStep
 from megatron.bridge.diffusion.models.wan.wan_step import WanForwardStep
+from megatron.bridge.models.qwen_omni.qwen3_omni_step import forward_step as qwen3_omni_forward_step
 from megatron.bridge.models.qwen_vl.qwen3_vl_step import forward_step as qwen3_vl_forward_step
 from megatron.bridge.recipes.utils.dataset_utils import (
     DATASET_TYPES,
@@ -132,6 +133,7 @@
     "audio_lm_step": audio_lm_forward_step,
     "gpt_step": gpt_forward_step,
     "vlm_step": vlm_forward_step,
+    "qwen3_omni_step": qwen3_omni_forward_step,
     "qwen3_vl_step": qwen3_vl_forward_step,
     "llava_step": llava_forward_step,
     "flux_step": FluxForwardStep,
diff --git a/src/megatron/bridge/models/__init__.py b/src/megatron/bridge/models/__init__.py
index 48bbdc9fd9..4c0f3f5760 100644
--- a/src/megatron/bridge/models/__init__.py
+++ b/src/megatron/bridge/models/__init__.py
@@ -128,6 +128,9 @@
     Qwen2AudioModelProvider,
 )
 from megatron.bridge.models.qwen_omni import (
+    Qwen3OmniBridge,
+    Qwen3OmniModel,
+    Qwen3OmniModelProvider,
     Qwen25OmniBridge,
     Qwen25OmniModel,
     Qwen25OmniModelProvider,
@@ -249,6 +252,9 @@
     "Qwen25OmniModel",
     "Qwen25OmniBridge",
     "Qwen25OmniModelProvider",
+    "Qwen3OmniModel",
+    "Qwen3OmniBridge",
+    "Qwen3OmniModelProvider",
     "SarvamMLABridge",
     "SarvamMoEBridge",
 ]
diff --git a/src/megatron/bridge/models/qwen_omni/__init__.py b/src/megatron/bridge/models/qwen_omni/__init__.py
index 4c051916e2..6849178bb8 100644
--- a/src/megatron/bridge/models/qwen_omni/__init__.py
+++ b/src/megatron/bridge/models/qwen_omni/__init__.py
@@ -12,7 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from megatron.bridge.models.qwen_omni.modeling_qwen3_omni.model import Qwen3OmniModel
 from megatron.bridge.models.qwen_omni.modeling_qwen25_omni.model import Qwen25OmniModel
+from megatron.bridge.models.qwen_omni.qwen3_omni_bridge import Qwen3OmniBridge
+from megatron.bridge.models.qwen_omni.qwen3_omni_provider import Qwen3OmniModelProvider
 from megatron.bridge.models.qwen_omni.qwen25_omni_bridge import Qwen25OmniBridge
 from megatron.bridge.models.qwen_omni.qwen25_omni_provider import Qwen25OmniModelProvider
 
@@ -21,4 +24,7 @@
     "Qwen25OmniBridge",
     "Qwen25OmniModel",
     "Qwen25OmniModelProvider",
+    "Qwen3OmniBridge",
+    "Qwen3OmniModel",
+    "Qwen3OmniModelProvider",
 ]
diff --git a/src/megatron/bridge/models/qwen_omni/modeling_qwen3_omni/__init__.py b/src/megatron/bridge/models/qwen_omni/modeling_qwen3_omni/__init__.py
new file mode 100644
index 0000000000..0d06a3a02a
--- /dev/null
+++ b/src/megatron/bridge/models/qwen_omni/modeling_qwen3_omni/__init__.py
@@ -0,0 +1,24 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from megatron.bridge.models.qwen_omni.modeling_qwen3_omni.model import Qwen3OmniModel
+from megatron.bridge.models.qwen_omni.modeling_qwen3_omni.transformer_config import (
+    Qwen3OmniTransformerConfig,
+)
+
+
+__all__ = [
+    "Qwen3OmniModel",
+    "Qwen3OmniTransformerConfig",
+]
diff --git a/src/megatron/bridge/models/qwen_omni/modeling_qwen3_omni/model.py b/src/megatron/bridge/models/qwen_omni/modeling_qwen3_omni/model.py
new file mode 100644
index 0000000000..64a25c8911
--- /dev/null
+++ b/src/megatron/bridge/models/qwen_omni/modeling_qwen3_omni/model.py
@@ -0,0 +1,111 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+from megatron.core import InferenceParams
+from megatron.core.packed_seq_params import PackedSeqParams
+from megatron.core.process_groups_config import ProcessGroupCollection
+from megatron.core.transformer import MegatronModule
+from megatron.core.transformer.spec_utils import ModuleSpec
+from transformers.models.qwen3_omni_moe.configuration_qwen3_omni_moe import (
+    Qwen3OmniMoeCode2WavConfig,
+    Qwen3OmniMoeTalkerConfig,
+    Qwen3OmniMoeThinkerConfig,
+)
+
+from megatron.bridge.models.qwen_omni.modeling_qwen3_omni.thinker_model import Qwen3OmniThinkerModel
+from megatron.bridge.models.qwen_omni.modeling_qwen3_omni.transformer_config import (
+    Qwen3OmniTransformerConfig,
+)
+
+
+class Qwen3OmniModel(MegatronModule):
+    """Qwen3-Omni model wrapper."""
+
+    def __init__(
+        self,
+        language_transformer_config: Qwen3OmniTransformerConfig,
+        language_transformer_layer_spec: ModuleSpec,
+        thinker_transformer_config: Qwen3OmniMoeThinkerConfig,
+        talker_transformer_config: Qwen3OmniMoeTalkerConfig | None = None,
+        code2wav_transformer_config: Qwen3OmniMoeCode2WavConfig | None = None,
+        parallel_output: bool = True,
+        pre_process: bool = True,
+        post_process: bool = True,
+        add_encoder: bool = True,
+        add_decoder: bool = True,
+        pg_collection: ProcessGroupCollection | None = None,
+    ) -> None:
+        super().__init__(config=language_transformer_config)
+
+        self.pre_process = pre_process
+        self.post_process = post_process
+
+        self.thinker = Qwen3OmniThinkerModel(
+            language_transformer_config,
+            language_transformer_layer_spec,
+            thinker_transformer_config,
+            parallel_output,
+            pre_process,
+            post_process,
+            add_encoder,
+            add_decoder,
+            pg_collection,
+        )
+
+        self.talker_transformer_config = talker_transformer_config
+        self.code2wav_transformer_config = code2wav_transformer_config
+        self.share_embeddings_and_output_weights = self.thinker.share_embeddings_and_output_weights
+
+    def shared_embedding_or_output_weight(self):
+        return self.thinker.shared_embedding_or_output_weight()
+
+    def set_input_tensor(self, input_tensor) -> None:
+        return self.thinker.set_input_tensor(input_tensor)
+
+    def freeze(
+        self,
+        freeze_language_model: bool = False,
+        freeze_vision_model: bool = False,
+        freeze_audio_model: bool = False,
+    ):
+        return self.thinker.freeze(
+            freeze_language_model=freeze_language_model,
+            freeze_vision_model=freeze_vision_model,
+            freeze_audio_model=freeze_audio_model,
+        )
+
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        position_ids: torch.Tensor | None = None,
+        attention_mask: torch.Tensor | None = None,
+        labels: torch.Tensor | None = None,
+        loss_mask: torch.Tensor | None = None,
+        inference_params: InferenceParams | None = None,
+        packed_seq_params: PackedSeqParams | None = None,
+        extra_block_kwargs: dict | None = None,
+        **kwargs,
+    ) -> torch.Tensor:
+        return self.thinker(
+            input_ids=input_ids,
+            position_ids=position_ids,
+            attention_mask=attention_mask,
+            labels=labels,
+            loss_mask=loss_mask,
+            inference_params=inference_params,
+            packed_seq_params=packed_seq_params,
+            extra_block_kwargs=extra_block_kwargs,
+            **kwargs,
+        )
diff --git a/src/megatron/bridge/models/qwen_omni/modeling_qwen3_omni/rope.py b/src/megatron/bridge/models/qwen_omni/modeling_qwen3_omni/rope.py
new file mode 100644
index 0000000000..9ba16f1bea
--- /dev/null
+++ b/src/megatron/bridge/models/qwen_omni/modeling_qwen3_omni/rope.py
@@ -0,0 +1,266 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Qwen3-Omni multimodal RoPE helpers ported from the HF thinker implementation."""
+
+import torch
+
+
+def _get_feat_extract_output_lengths(input_lengths: torch.Tensor) -> torch.Tensor:
+    """Compute Qwen3-Omni thinker audio token lengths from feature lengths."""
+    input_lengths_leave = input_lengths % 100
+    feat_lengths = (input_lengths_leave - 1) // 2 + 1
+    output_lengths = ((feat_lengths - 1) // 2 + 1 - 1) // 2 + 1 + (input_lengths // 100) * 13
+    return output_lengths
+
+
+def get_llm_pos_ids_for_vision(
+    start_idx: int,
+    vision_idx: int,
+    spatial_merge_size: int,
+    t_index: torch.Tensor,
+    grid_hs: torch.Tensor,
+    grid_ws: torch.Tensor,
+) -> torch.Tensor:
+    """Build 3D multimodal RoPE ids for image or video features."""
+    llm_grid_h = grid_hs[vision_idx] // spatial_merge_size
+    llm_grid_w = grid_ws[vision_idx] // spatial_merge_size
+    h_index = torch.arange(llm_grid_h).view(1, -1, 1).expand(len(t_index), -1, llm_grid_w).flatten()
+    w_index = torch.arange(llm_grid_w).view(1, 1, -1).expand(len(t_index), llm_grid_h, -1).flatten()
+    t_index = t_index.view(-1, 1).expand(-1, llm_grid_h * llm_grid_w).flatten().long()
+    return torch.stack([t_index, h_index, w_index]) + start_idx
+
+
+def _count_run(tokens: list[int], start: int, token_id: int) -> int:
+    count = 0
+    idx = start
+    while idx < len(tokens) and tokens[idx] == token_id:
+        count += 1
+        idx += 1
+    return count
+
+
+def _next_position_start(llm_pos_ids_list: list[torch.Tensor]) -> torch.Tensor | int:
+    for pos_ids in reversed(llm_pos_ids_list):
+        if pos_ids.numel() > 0:
+            return pos_ids.max() + 1
+    return 0
+
+
+def get_rope_index(
+    spatial_merge_size: int,
+    image_token_id: int,
+    video_token_id: int,
+    audio_token_id: int,
+    vision_start_token_id: int,
+    audio_start_token_id: int,
+    position_id_per_seconds: int,
+    input_ids: torch.LongTensor | None = None,
+    image_grid_thw: torch.LongTensor | None = None,
+    video_grid_thw: torch.LongTensor | None = None,
+    attention_mask: torch.Tensor | None = None,
+    use_audio_in_video: bool = False,
+    audio_seqlens: torch.LongTensor | None = None,
+    second_per_grids: torch.Tensor | None = None,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """Build multimodal RoPE ids for text, image, video, and audio token layouts.
+
+    This mirrors the HF Qwen3-Omni thinker implementation so local Megatron smoke
+    tests exercise the same placeholder ordering and audio/image position handling.
+    """
+
+    mrope_position_deltas = []
+    if input_ids is not None and (
+        image_grid_thw is not None or video_grid_thw is not None or audio_seqlens is not None
+    ):
+        total_input_ids = input_ids
+        if attention_mask is None:
+            attention_mask = torch.ones_like(total_input_ids)
+        elif attention_mask.dim() > 2:
+            # Collapse broadcast attention masks such as [b, 1, s, s] back to [b, s].
+            attention_mask = attention_mask.any(dim=-1)
+            if attention_mask.dim() == 3:
+                attention_mask = attention_mask.squeeze(1)
+            attention_mask = attention_mask.to(dtype=total_input_ids.dtype)
+        attention_mask = attention_mask.to(total_input_ids.device).bool()
+        position_ids = torch.zeros(
+            3,
+            input_ids.shape[0],
+            input_ids.shape[1],
+            dtype=torch.float,
+            device=input_ids.device,
+        )
+        image_idx, video_idx, audio_idx = 0, 0, 0
+        for i, batch_input_ids in enumerate(total_input_ids):
+            batch_input_ids = batch_input_ids[attention_mask[i]]
+            vision_start_indices = torch.argwhere(batch_input_ids == vision_start_token_id).squeeze(1)
+            vision_tokens = batch_input_ids[vision_start_indices + 1]
+            audio_nums = torch.sum(batch_input_ids == audio_start_token_id)
+            image_nums = (vision_tokens == image_token_id).sum()
+            video_nums = (
+                (vision_tokens == audio_start_token_id).sum()
+                if use_audio_in_video
+                else (vision_tokens == video_token_id).sum()
+            )
+            input_tokens = batch_input_ids.tolist()
+            llm_pos_ids_list: list[torch.Tensor] = []
+            st = 0
+            remain_images, remain_videos, remain_audios = image_nums, video_nums, audio_nums
+            multimodal_nums = image_nums + audio_nums if use_audio_in_video else image_nums + video_nums + audio_nums
+            for _ in range(multimodal_nums):
+                st_idx = _next_position_start(llm_pos_ids_list)
+                if (image_token_id in input_tokens or video_token_id in input_tokens) and (
+                    remain_videos > 0 or remain_images > 0
+                ):
+                    ed_vision_start = input_tokens.index(vision_start_token_id, st)
+                else:
+                    ed_vision_start = len(input_tokens) + 1
+                if audio_token_id in input_tokens and remain_audios > 0:
+                    ed_audio_start = input_tokens.index(audio_start_token_id, st)
+                else:
+                    ed_audio_start = len(input_tokens) + 1
+                min_ed = min(ed_vision_start, ed_audio_start)
+
+                text_len = min_ed - st
+                if text_len != 0:
+                    llm_pos_ids_list.append(torch.arange(text_len).view(1, -1).expand(3, -1) + st_idx)
+                    st_idx += text_len
+
+                if min_ed == ed_vision_start and ed_vision_start + 1 == ed_audio_start:
+                    bos_len, eos_len = 2, 2
+                else:
+                    bos_len, eos_len = 1, 1
+                llm_pos_ids_list.append(torch.arange(bos_len).view(1, -1).expand(3, -1) + st_idx)
+                st_idx += bos_len
+
+                if min_ed == ed_audio_start:
+                    if audio_seqlens is not None:
+                        audio_len = _get_feat_extract_output_lengths(audio_seqlens[audio_idx])
+                    else:
+                        audio_len = 0
+                    audio_len = min(
+                        int(audio_len),
+                        _count_run(input_tokens, ed_audio_start + bos_len, audio_token_id),
+                    )
+                    llm_pos_ids = torch.arange(audio_len).view(1, -1).expand(3, -1) + st_idx
+                    llm_pos_ids_list.append(llm_pos_ids)
+
+                    st += int(text_len + bos_len + audio_len + eos_len)
+                    audio_idx += 1
+                    remain_audios -= 1
+                elif min_ed == ed_vision_start and batch_input_ids[ed_vision_start + 1] == image_token_id:
+                    assert image_grid_thw is not None
+                    grid_t = image_grid_thw[image_idx][0]
+                    grid_hs = image_grid_thw[:, 1]
+                    grid_ws = image_grid_thw[:, 2]
+                    t_index = (torch.arange(grid_t) * position_id_per_seconds).float()
+                    llm_pos_ids = get_llm_pos_ids_for_vision(
+                        st_idx, image_idx, spatial_merge_size, t_index, grid_hs, grid_ws
+                    )
+                    image_len = image_grid_thw[image_idx].prod() // (spatial_merge_size**2)
+                    llm_pos_ids_list.append(llm_pos_ids)
+
+                    st += int(text_len + bos_len + image_len + eos_len)
+                    image_idx += 1
+                    remain_images -= 1
+                elif min_ed == ed_vision_start and batch_input_ids[ed_vision_start + 1] == video_token_id:
+                    assert video_grid_thw is not None
+                    assert second_per_grids is not None
+                    grid_t = video_grid_thw[video_idx][0]
+                    grid_hs = video_grid_thw[:, 1]
+                    grid_ws = video_grid_thw[:, 2]
+                    t_index = (
+                        torch.arange(grid_t) * second_per_grids[video_idx].cpu().float() * position_id_per_seconds
+                    ).float()
+                    llm_pos_ids = get_llm_pos_ids_for_vision(
+                        st_idx, video_idx, spatial_merge_size, t_index, grid_hs, grid_ws
+                    )
+                    video_len = video_grid_thw[video_idx].prod() // (spatial_merge_size**2)
+                    llm_pos_ids_list.append(llm_pos_ids)
+
+                    st += int(text_len + bos_len + video_len + eos_len)
+                    video_idx += 1
+                    remain_videos -= 1
+                elif min_ed == ed_vision_start and ed_vision_start + 1 == ed_audio_start:
+                    assert audio_seqlens is not None
+                    assert video_grid_thw is not None
+                    assert second_per_grids is not None
+                    audio_len = _get_feat_extract_output_lengths(audio_seqlens[audio_idx])
+                    audio_len = min(
+                        int(audio_len),
+                        _count_run(input_tokens, ed_audio_start + bos_len, audio_token_id),
+                    )
+                    audio_llm_pos_ids = torch.arange(audio_len).view(1, -1).expand(3, -1) + st_idx
+                    grid_t = video_grid_thw[video_idx][0]
+                    grid_hs = video_grid_thw[:, 1]
+                    grid_ws = video_grid_thw[:, 2]
+                    t_index = (
+                        torch.arange(grid_t) * second_per_grids[video_idx].cpu().float() * position_id_per_seconds
+                    ).float()
+                    video_llm_pos_ids = get_llm_pos_ids_for_vision(
+                        st_idx, video_idx, spatial_merge_size, t_index, grid_hs, grid_ws
+                    )
+                    video_data_index, audio_data_index = 0, 0
+                    while (
+                        video_data_index < video_llm_pos_ids.shape[-1]
+                        and audio_data_index < audio_llm_pos_ids.shape[-1]
+                    ):
+                        if video_llm_pos_ids[0][video_data_index] <= audio_llm_pos_ids[0][audio_data_index]:
+                            llm_pos_ids_list.append(video_llm_pos_ids[:, video_data_index : video_data_index + 1])
+                            video_data_index += 1
+                        else:
+                            llm_pos_ids_list.append(audio_llm_pos_ids[:, audio_data_index : audio_data_index + 1])
+                            audio_data_index += 1
+                    if video_data_index < video_llm_pos_ids.shape[-1]:
+                        llm_pos_ids_list.append(video_llm_pos_ids[:, video_data_index:])
+                    if audio_data_index < audio_llm_pos_ids.shape[-1]:
+                        llm_pos_ids_list.append(audio_llm_pos_ids[:, audio_data_index:])
+                    video_len = video_grid_thw[video_idx].prod() // (spatial_merge_size**2)
+
+                    st += int(text_len + bos_len + audio_len + video_len + eos_len)
+                    audio_idx += 1
+                    video_idx += 1
+                    remain_videos -= 1
+                    remain_audios -= 1
+
+                st_idx = _next_position_start(llm_pos_ids_list)
+                llm_pos_ids_list.append(torch.arange(eos_len).view(1, -1).expand(3, -1) + st_idx)
+
+            if st < len(input_tokens):
+                st_idx = _next_position_start(llm_pos_ids_list)
+                text_len = len(input_tokens) - st
+                llm_pos_ids_list.append(torch.arange(text_len).view(1, -1).expand(3, -1) + st_idx)
+
+            llm_positions = torch.cat([item.float() for item in llm_pos_ids_list], dim=1).reshape(3, -1)
+            valid_token_count = int(attention_mask[i].sum().item())
+            if llm_positions.shape[-1] > valid_token_count:
+                # `input_ids` may already be truncated to `seq_length` while multimodal
+                # metadata (audio/image/video lengths) still reflects the original sample.
+                # Keep RoPE aligned to the surviving prefix tokens actually present.
+                llm_positions = llm_positions[:, :valid_token_count]
+
+            position_ids[..., i, attention_mask[i]] = llm_positions.to(position_ids.device)
+            mrope_position_deltas.append(llm_positions.max() + 1 - len(batch_input_ids))
+        mrope_position_deltas = torch.tensor(mrope_position_deltas, device=input_ids.device).unsqueeze(1)
+
+        return position_ids, mrope_position_deltas
+
+    assert attention_mask is not None
+    position_ids = attention_mask.float().cumsum(-1) - 1
+    position_ids.masked_fill_(attention_mask == 0, 1)
+    position_ids = position_ids.unsqueeze(0).expand(3, -1, -1).to(attention_mask.device)
+    max_position_ids = position_ids.max(0, keepdim=False)[0].max(-1, keepdim=True)[0]
+    mrope_position_deltas = max_position_ids + 1 - torch.sum(attention_mask, dim=-1, keepdim=True)
+
+    return position_ids, mrope_position_deltas
diff --git a/src/megatron/bridge/models/qwen_omni/modeling_qwen3_omni/thinker_model.py b/src/megatron/bridge/models/qwen_omni/modeling_qwen3_omni/thinker_model.py
new file mode 100644
index 0000000000..088047208e
--- /dev/null
+++ b/src/megatron/bridge/models/qwen_omni/modeling_qwen3_omni/thinker_model.py
@@ -0,0 +1,579 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+from megatron.core import InferenceParams, tensor_parallel
+from megatron.core.packed_seq_params import PackedSeqParams
+from megatron.core.process_groups_config import ProcessGroupCollection
+from megatron.core.transformer import MegatronModule
+from megatron.core.transformer.spec_utils import ModuleSpec
+from transformers.models.qwen3_omni_moe.configuration_qwen3_omni_moe import (
+    Qwen3OmniMoeThinkerConfig as Qwen3OmniMoeThinkerConfigHF,
+)
+from transformers.models.qwen3_omni_moe.modeling_qwen3_omni_moe import (
+    Qwen3OmniMoeAudioEncoder as Qwen3OmniMoeAudioEncoderHF,
+)
+from transformers.models.qwen3_omni_moe.modeling_qwen3_omni_moe import (
+    Qwen3OmniMoeVisionEncoder as Qwen3OmniMoeVisionEncoderHF,
+)
+
+from megatron.bridge.models.qwen_omni.modeling_qwen3_omni.rope import get_rope_index
+from megatron.bridge.models.qwen_omni.modeling_qwen3_omni.transformer_config import (
+    Qwen3OmniTransformerConfig,
+)
+from megatron.bridge.models.qwen_vl.modelling_qwen3_vl.text_model import Qwen3VLGPTModel
+from megatron.bridge.models.qwen_vl.modelling_qwen3_vl.utils import (
+    split_data_cp_rank,
+    split_deepstack_embs,
+)
+from megatron.bridge.utils.common_utils import hook_hf_module_setattr_for_tp_grad_sync
+
+
+def _deep_getattr(module: torch.nn.Module, attr_path: str) -> torch.nn.Module:
+    value = module
+    for attr in attr_path.split("."):
+        value = getattr(value, attr)
+    return value
+
+
+def _patch_get_input_embeddings(module: torch.nn.Module, attr_path: str) -> None:
+    """Match ms-swift's tower patching for gradient-checkpoint input hooks."""
+
+    def _get_input_embeddings(self) -> torch.nn.Module:
+        return _deep_getattr(self, attr_path)
+
+    module.get_input_embeddings = _get_input_embeddings.__get__(module, module.__class__)
+
+
+def _build_text_only_mrope_position_ids(input_ids: torch.Tensor) -> torch.Tensor:
+    """Create text-only multimodal rope ids shaped [3, batch, seq]."""
+    batch_size, seq_len = input_ids.shape
+    base = torch.arange(seq_len, device=input_ids.device, dtype=torch.long)
+    base = base.unsqueeze(0).expand(batch_size, -1)
+    return torch.stack([base, base, base], dim=0)
+
+
+def _configure_multimodal_attn_impl(config: object, attn_impl: str | None) -> None:
+    """Apply a requested attention implementation to HF multimodal configs."""
+    if not attn_impl or attn_impl == "auto":
+        return
+
+    setattr(config, "_attn_implementation", attn_impl)
+    setattr(config, "_attn_implementation_internal", attn_impl)
+    setattr(config, "attn_implementation", attn_impl)
+
+    use_flash_attn = attn_impl in {"flash_attn", "flash_attention_2"}
+    setattr(config, "use_flash_attn", use_flash_attn)
+    setattr(config, "_use_flash_attention_2", use_flash_attn)
+    setattr(config, "_flash_attn_2_enabled", use_flash_attn)
+
+
+def _enable_multimodal_gradient_checkpointing(module: torch.nn.Module) -> None:
+    """Best-effort enable gradient checkpointing for HF multimodal towers."""
+    if hasattr(module, "gradient_checkpointing_enable"):
+        try:
+            module.gradient_checkpointing_enable()
+        except TypeError:
+            module.gradient_checkpointing_enable({})
+        except NotImplementedError:
+            pass
+
+    if hasattr(module, "enable_input_require_grads"):
+        try:
+            module.enable_input_require_grads()
+        except AttributeError:
+            pass
+        except NotImplementedError:
+            pass
+
+
+def _trim_feature_sequence(
+    features: torch.Tensor | None,
+    multiscale_features: list[torch.Tensor] | None,
+    expected_tokens: int,
+    feature_name: str,
+) -> tuple[torch.Tensor | None, list[torch.Tensor] | None]:
+    if features is None:
+        return None, multiscale_features
+
+    produced_tokens = int(features.shape[0])
+    if expected_tokens > produced_tokens:
+        raise ValueError(
+            f"{feature_name} placeholders exceed produced features: expected={expected_tokens}, produced={produced_tokens}"
+        )
+    if expected_tokens == produced_tokens:
+        return features, multiscale_features
+
+    trimmed_features = features[:expected_tokens]
+    trimmed_multiscale = None
+    if multiscale_features is not None:
+        trimmed_multiscale = [feature[:expected_tokens] for feature in multiscale_features]
+    return trimmed_features, trimmed_multiscale
+
+
+def _normalize_visual_outputs(outputs: object) -> tuple[torch.Tensor, list[torch.Tensor]]:
+    def _as_feature_list(features: object) -> list[torch.Tensor]:
+        if features is None:
+            return []
+        if isinstance(features, torch.Tensor):
+            return [features]
+        return list(features)
+
+    if hasattr(outputs, "pooler_output") or hasattr(outputs, "last_hidden_state"):
+        hidden_states = getattr(outputs, "pooler_output", None)
+        if hidden_states is None:
+            hidden_states = outputs.last_hidden_state
+        deepstack_features = getattr(outputs, "deepstack_features", None)
+        if deepstack_features is None:
+            deepstack_features = getattr(outputs, "deepstack_feature_lists", None)
+        if deepstack_features is None:
+            deepstack_features = getattr(outputs, "hidden_states", None)
+        return hidden_states, _as_feature_list(deepstack_features)
+
+    if not isinstance(outputs, (tuple, list)) or len(outputs) == 0:
+        raise TypeError(f"Unexpected vision encoder output type: {type(outputs)!r}")
+
+    hidden_states = outputs[0]
+    if len(outputs) == 2 and isinstance(outputs[1], (tuple, list)):
+        deepstack_features = outputs[1]
+    else:
+        deepstack_features = outputs[1:]
+    return hidden_states, _as_feature_list(deepstack_features)
+
+
+class Qwen3OmniThinkerModel(MegatronModule):
+    """Qwen3-Omni thinker model.
+
+    The current implementation supports multimodal thinker-side forward paths
+    for text, vision, and audio inputs.
+    """
+
+    def __init__(
+        self,
+        language_transformer_config: Qwen3OmniTransformerConfig,
+        language_transformer_layer_spec: ModuleSpec,
+        thinker_transformer_config: Qwen3OmniMoeThinkerConfigHF,
+        parallel_output: bool = True,
+        pre_process: bool = True,
+        post_process: bool = True,
+        add_encoder: bool = True,
+        add_decoder: bool = True,
+        pg_collection: ProcessGroupCollection | None = None,
+    ) -> None:
+        super().__init__(config=language_transformer_config)
+
+        self.pre_process = pre_process
+        self.post_process = post_process
+        self.add_encoder = add_encoder
+        self.add_decoder = add_decoder
+
+        self.encoder_hidden_state = None
+        self.visual = None
+        self.audio_model = None
+        self.language_model = None
+
+        self.pg_collection = pg_collection
+        self.image_token_id = language_transformer_config.image_token_id
+        self.video_token_id = language_transformer_config.video_token_id
+        self.audio_token_id = language_transformer_config.audio_token_id
+        self.vision_start_token_id = language_transformer_config.vision_start_token_id
+        self.audio_start_token_id = language_transformer_config.audio_start_token_id
+        self.position_id_per_seconds = language_transformer_config.position_id_per_seconds
+        self.seconds_per_chunk = language_transformer_config.seconds_per_chunk
+        self.thinker_transformer_config = thinker_transformer_config
+
+        if self.pre_process:
+            multimodal_attn_impl = getattr(language_transformer_config, "multimodal_attn_impl", "auto")
+            _configure_multimodal_attn_impl(thinker_transformer_config.vision_config, multimodal_attn_impl)
+            _configure_multimodal_attn_impl(thinker_transformer_config.audio_config, multimodal_attn_impl)
+
+            self.visual = Qwen3OmniMoeVisionEncoderHF._from_config(thinker_transformer_config.vision_config)
+            hook_hf_module_setattr_for_tp_grad_sync(self.visual)
+            self.audio_model = Qwen3OmniMoeAudioEncoderHF._from_config(thinker_transformer_config.audio_config)
+            hook_hf_module_setattr_for_tp_grad_sync(self.audio_model)
+            _patch_get_input_embeddings(self.visual, "patch_embed")
+            _patch_get_input_embeddings(self.audio_model, "conv_out")
+
+            _configure_multimodal_attn_impl(
+                getattr(self.visual, "config", self.thinker_transformer_config.vision_config), multimodal_attn_impl
+            )
+            _configure_multimodal_attn_impl(
+                getattr(self.audio_model, "config", self.thinker_transformer_config.audio_config), multimodal_attn_impl
+            )
+            if getattr(language_transformer_config, "vit_gradient_checkpointing", False):
+                _enable_multimodal_gradient_checkpointing(self.visual)
+                _enable_multimodal_gradient_checkpointing(self.audio_model)
+
+        self.language_model = Qwen3VLGPTModel(
+            config=language_transformer_config,
+            transformer_layer_spec=language_transformer_layer_spec,
+            vocab_size=language_transformer_config.vocab_size,
+            max_sequence_length=language_transformer_config.language_max_sequence_length,
+            parallel_output=parallel_output,
+            position_embedding_type="mrope",
+            rotary_percent=language_transformer_config.rotary_percent,
+            pre_process=self.pre_process,
+            post_process=self.post_process,
+            rotary_base=language_transformer_config.rotary_base,
+            fp16_lm_cross_entropy=language_transformer_config.fp16_lm_cross_entropy,
+            share_embeddings_and_output_weights=language_transformer_config.share_embeddings_and_output_weights,
+            scatter_embedding_sequence_parallel=False,
+            pg_collection=pg_collection,
+        )
+
+        self.share_embeddings_and_output_weights = self.language_model.share_embeddings_and_output_weights
+
+    def shared_embedding_or_output_weight(self):
+        if self.add_decoder:
+            return self.language_model.shared_embedding_or_output_weight()
+        return None
+
+    def set_input_tensor(self, input_tensor) -> None:
+        if not isinstance(input_tensor, list):
+            input_tensor = [input_tensor]
+        assert len(input_tensor) == 1, "input_tensor should only be length 1 for Qwen3Omni"
+
+        if self.pre_process:
+            self.encoder_hidden_state = input_tensor[0]
+        else:
+            self.language_model.set_input_tensor(input_tensor[0])
+
+    def freeze(
+        self,
+        freeze_language_model: bool = False,
+        freeze_vision_model: bool = False,
+        freeze_audio_model: bool = False,
+    ):
+        modules = []
+        if freeze_language_model and self.language_model is not None:
+            modules.append(self.language_model)
+        if freeze_vision_model and self.visual is not None:
+            modules.append(self.visual)
+        if freeze_audio_model and self.audio_model is not None:
+            modules.append(self.audio_model)
+
+        for module in modules:
+            for param in module.parameters():
+                param.requires_grad = False
+
+    @staticmethod
+    def _get_placeholder_mask(
+        input_ids: torch.LongTensor,
+        inputs_embeds: torch.FloatTensor,
+        image_features: torch.FloatTensor | None = None,
+        video_features: torch.FloatTensor | None = None,
+        image_token_id: int = 151655,
+        video_token_id: int = 151656,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        image_mask = input_ids == image_token_id
+        video_mask = input_ids == video_token_id
+
+        expanded_image_mask = image_mask.unsqueeze(-1).expand_as(inputs_embeds)
+        expanded_video_mask = video_mask.unsqueeze(-1).expand_as(inputs_embeds)
+
+        if image_features is not None and inputs_embeds[expanded_image_mask].numel() != image_features.numel():
+            raise ValueError(
+                f"Image features and image tokens do not match: tokens={image_mask.sum()}, "
+                f"features={image_features.shape[0]}"
+            )
+        if video_features is not None and inputs_embeds[expanded_video_mask].numel() != video_features.numel():
+            raise ValueError(
+                f"Video features and video tokens do not match: tokens={video_mask.sum()}, "
+                f"features={video_features.shape[0]}"
+            )
+
+        return image_mask, video_mask
+
+    def get_image_features(
+        self,
+        pixel_values: torch.FloatTensor,
+        image_grid_thw: torch.LongTensor,
+    ) -> tuple[torch.Tensor, list[torch.Tensor]]:
+        target_dtype = getattr(self.visual, "dtype", pixel_values.dtype)
+        image_outputs = self.visual(pixel_values.to(dtype=target_dtype), grid_thw=image_grid_thw)
+        return _normalize_visual_outputs(image_outputs)
+
+    def get_video_features(
+        self,
+        pixel_values_videos: torch.FloatTensor,
+        video_grid_thw: torch.LongTensor,
+    ) -> tuple[torch.Tensor, list[torch.Tensor]]:
+        target_dtype = getattr(self.visual, "dtype", pixel_values_videos.dtype)
+        video_outputs = self.visual(pixel_values_videos.to(dtype=target_dtype), grid_thw=video_grid_thw)
+        return _normalize_visual_outputs(video_outputs)
+
+    def get_audio_features(
+        self,
+        input_features: torch.FloatTensor,
+        feature_attention_mask: torch.LongTensor | None = None,
+        audio_feature_lengths: torch.LongTensor | None = None,
+        expected_audio_token_counts: torch.LongTensor | None = None,
+    ) -> torch.Tensor:
+        if feature_attention_mask is not None:
+            audio_feature_lengths = torch.sum(feature_attention_mask, dim=1)
+            input_features = input_features.permute(0, 2, 1)[feature_attention_mask.bool()].permute(1, 0)
+
+        if audio_feature_lengths is None:
+            raise ValueError("Either feature_attention_mask or audio_feature_lengths must be provided")
+
+        target_dtype = getattr(self.audio_model, "dtype", input_features.dtype)
+        audio_outputs = self.audio_model(
+            input_features.to(dtype=target_dtype),
+            feature_lens=audio_feature_lengths,
+        )
+        audio_embeds = audio_outputs.last_hidden_state
+
+        if expected_audio_token_counts is None:
+            return audio_embeds
+
+        _, produced_output_lengths = self.audio_model._get_feat_extract_output_lengths(audio_feature_lengths)
+        expected_audio_token_counts = expected_audio_token_counts.to(produced_output_lengths.device)
+
+        trimmed_embeds = []
+        start = 0
+        for produced_len, expected_len in zip(
+            produced_output_lengths.tolist(), expected_audio_token_counts.tolist(), strict=True
+        ):
+            end = start + int(produced_len)
+            if expected_len > produced_len:
+                raise ValueError(
+                    f"Audio token placeholders exceed produced audio features: expected={expected_len}, produced={produced_len}"
+                )
+            trimmed_embeds.append(audio_embeds[start : start + int(expected_len)])
+            start = end
+
+        return (
+            torch.cat(trimmed_embeds, dim=0) if trimmed_embeds else audio_embeds.new_zeros((0, audio_embeds.shape[-1]))
+        )
+
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        position_ids: torch.Tensor | None = None,
+        attention_mask: torch.Tensor | None = None,
+        labels: torch.Tensor | None = None,
+        loss_mask: torch.Tensor | None = None,
+        inference_params: InferenceParams | None = None,
+        packed_seq_params: PackedSeqParams | None = None,
+        extra_block_kwargs: dict | None = None,
+        pixel_values: torch.Tensor | None = None,
+        pixel_values_videos: torch.Tensor | None = None,
+        image_grid_thw: torch.Tensor | None = None,
+        video_grid_thw: torch.Tensor | None = None,
+        video_second_per_grid: torch.Tensor | None = None,
+        input_features: torch.Tensor | None = None,
+        feature_attention_mask: torch.Tensor | None = None,
+        audio_feature_lengths: torch.Tensor | None = None,
+        **kwargs,
+    ) -> torch.Tensor:
+        if inference_params is not None:
+            raise NotImplementedError("Qwen3-Omni Megatron inference is not implemented yet.")
+        if packed_seq_params is not None:
+            raise NotImplementedError("Qwen3-Omni packed sequence support is not implemented yet.")
+
+        cp_size = self.pg_collection.cp.size() if self.pg_collection is not None else 1
+        cp_rank = self.pg_collection.cp.rank() if self.pg_collection is not None else 0
+        tp_size = self.pg_collection.tp.size() if self.pg_collection is not None else 1
+        tp_rank = self.pg_collection.tp.rank() if self.pg_collection is not None else 0
+
+        if audio_feature_lengths is None and feature_attention_mask is not None:
+            audio_feature_lengths = torch.sum(feature_attention_mask, dim=1)
+
+        if position_ids is None:
+            has_multimodal_inputs = any(
+                value is not None
+                for value in (pixel_values, pixel_values_videos, input_features, audio_feature_lengths)
+            )
+            if not has_multimodal_inputs:
+                position_ids = _build_text_only_mrope_position_ids(input_ids)
+            else:
+                position_ids, _ = get_rope_index(
+                    self.config.spatial_merge_size,
+                    self.image_token_id,
+                    self.video_token_id,
+                    self.audio_token_id,
+                    self.vision_start_token_id,
+                    self.audio_start_token_id,
+                    self.position_id_per_seconds,
+                    input_ids,
+                    image_grid_thw=image_grid_thw,
+                    video_grid_thw=video_grid_thw,
+                    second_per_grids=video_second_per_grid,
+                    attention_mask=attention_mask,
+                    audio_seqlens=audio_feature_lengths,
+                )
+
+        if self.pre_process:
+            combined_embeddings = self.language_model.embedding(
+                input_ids=input_ids,
+                position_ids=None,
+            ).clone()
+
+            visual_pos_masks = None
+            deepstack_visual_embeds = None
+
+            if pixel_values is not None or pixel_values_videos is not None:
+                inputs_embeds_bsh = combined_embeddings.transpose(0, 1).contiguous()
+
+                image_embeds = None
+                image_embeds_multiscale = None
+                if pixel_values is not None:
+                    if image_grid_thw is None:
+                        raise ValueError("image_grid_thw is required when pixel_values is provided")
+                    image_embeds, image_embeds_multiscale = self.get_image_features(pixel_values, image_grid_thw)
+                    image_embeds = image_embeds.to(inputs_embeds_bsh.device, inputs_embeds_bsh.dtype)
+                    image_embeds_multiscale = [
+                        embed.to(inputs_embeds_bsh.device, inputs_embeds_bsh.dtype)
+                        for embed in image_embeds_multiscale
+                    ]
+                    image_embeds, image_embeds_multiscale = _trim_feature_sequence(
+                        image_embeds,
+                        image_embeds_multiscale,
+                        expected_tokens=int((input_ids == self.image_token_id).sum().item()),
+                        feature_name="Image features",
+                    )
+
+                video_embeds = None
+                video_embeds_multiscale = None
+                if pixel_values_videos is not None:
+                    if video_grid_thw is None:
+                        raise ValueError("video_grid_thw is required when pixel_values_videos is provided")
+                    video_embeds, video_embeds_multiscale = self.get_video_features(
+                        pixel_values_videos, video_grid_thw
+                    )
+                    video_embeds = video_embeds.to(inputs_embeds_bsh.device, inputs_embeds_bsh.dtype)
+                    video_embeds_multiscale = [
+                        embed.to(inputs_embeds_bsh.device, inputs_embeds_bsh.dtype)
+                        for embed in video_embeds_multiscale
+                    ]
+                    video_embeds, video_embeds_multiscale = _trim_feature_sequence(
+                        video_embeds,
+                        video_embeds_multiscale,
+                        expected_tokens=int((input_ids == self.video_token_id).sum().item()),
+                        feature_name="Video features",
+                    )
+
+                image_mask, video_mask = self._get_placeholder_mask(
+                    input_ids=input_ids,
+                    inputs_embeds=inputs_embeds_bsh,
+                    image_features=image_embeds,
+                    video_features=video_embeds,
+                    image_token_id=self.image_token_id,
+                    video_token_id=self.video_token_id,
+                )
+
+                if image_embeds is not None:
+                    inputs_embeds_bsh.masked_scatter_(
+                        image_mask.unsqueeze(-1).expand_as(inputs_embeds_bsh), image_embeds
+                    )
+                    visual_pos_masks = image_mask
+                    deepstack_visual_embeds = image_embeds_multiscale
+
+                if video_embeds is not None:
+                    inputs_embeds_bsh.masked_scatter_(
+                        video_mask.unsqueeze(-1).expand_as(inputs_embeds_bsh), video_embeds
+                    )
+                    if deepstack_visual_embeds is None:
+                        visual_pos_masks = video_mask
+                        deepstack_visual_embeds = video_embeds_multiscale
+                    else:
+                        assert visual_pos_masks is not None
+                        visual_pos_masks = visual_pos_masks | video_mask
+                        joint_embeds: list[torch.Tensor] = []
+                        image_mask_joint = image_mask[visual_pos_masks]
+                        video_mask_joint = video_mask[visual_pos_masks]
+                        for image_embed, video_embed in zip(
+                            deepstack_visual_embeds, video_embeds_multiscale, strict=True
+                        ):
+                            embed_joint = image_embed.new_zeros(
+                                (int(visual_pos_masks.sum().item()), image_embed.shape[-1])
+                            )
+                            embed_joint[image_mask_joint] = image_embed
+                            embed_joint[video_mask_joint] = video_embed
+                            joint_embeds.append(embed_joint)
+                        deepstack_visual_embeds = joint_embeds
+
+                combined_embeddings = inputs_embeds_bsh.transpose(0, 1).contiguous()
+            else:
+                visual_pos_masks = None
+                deepstack_visual_embeds = None
+
+            if input_features is not None:
+                expected_audio_token_counts = (input_ids == self.audio_token_id).sum(dim=1)
+                audio_embeds = self.get_audio_features(
+                    input_features,
+                    feature_attention_mask=feature_attention_mask,
+                    audio_feature_lengths=audio_feature_lengths,
+                    expected_audio_token_counts=expected_audio_token_counts,
+                )
+                audio_embeds = audio_embeds.to(combined_embeddings.device, combined_embeddings.dtype)
+                combined_embeddings_bsh = combined_embeddings.transpose(0, 1).contiguous()
+                audio_mask = input_ids == self.audio_token_id
+                if combined_embeddings_bsh[audio_mask].numel() != audio_embeds.numel():
+                    raise ValueError(
+                        f"Audio features and audio tokens do not match: tokens={audio_mask.sum()}, "
+                        f"features={audio_embeds.shape[0]}"
+                    )
+                combined_embeddings_bsh.masked_scatter_(
+                    audio_mask.unsqueeze(-1).expand_as(combined_embeddings_bsh),
+                    audio_embeds,
+                )
+                combined_embeddings = combined_embeddings_bsh.transpose(0, 1).contiguous()
+
+            if combined_embeddings is not None and cp_size > 1 and packed_seq_params is None:
+                combined_embeddings = split_data_cp_rank(combined_embeddings, cp_size, 0, cp_rank)
+
+            sp_pad_len = 0
+            if self.config.sequence_parallel:
+                seq_len = combined_embeddings.shape[0]
+                sp_pad_len = (tp_size - seq_len % tp_size) % tp_size
+                if sp_pad_len > 0:
+                    combined_embeddings = torch.nn.functional.pad(combined_embeddings, (0, 0, 0, 0, 0, sp_pad_len))
+                    if visual_pos_masks is not None:
+                        visual_pos_masks = torch.nn.functional.pad(visual_pos_masks, (0, sp_pad_len), value=False)
+                combined_embeddings = tensor_parallel.scatter_to_sequence_parallel_region(combined_embeddings)
+                combined_embeddings = combined_embeddings.contiguous()
+        else:
+            combined_embeddings = None
+            visual_pos_masks = None
+            deepstack_visual_embeds = None
+            sp_pad_len = 0
+
+        if sp_pad_len > 0 and position_ids is not None:
+            position_ids = torch.nn.functional.pad(position_ids, (0, sp_pad_len), mode="replicate")
+
+        if self.config.sequence_parallel or cp_size > 1:
+            visual_pos_masks, deepstack_visual_embeds = split_deepstack_embs(
+                visual_pos_masks,
+                deepstack_visual_embeds,
+                tp_size=tp_size,
+                tp_rank=tp_rank,
+                cp_size=cp_size,
+                cp_rank=cp_rank,
+                sequence_parallel=self.config.sequence_parallel,
+            )
+
+        return self.language_model(
+            input_ids=None if combined_embeddings is not None else input_ids,
+            position_ids=position_ids,
+            attention_mask=attention_mask,
+            decoder_input=combined_embeddings,
+            labels=labels,
+            inference_params=inference_params,
+            packed_seq_params=packed_seq_params,
+            extra_block_kwargs=extra_block_kwargs,
+            loss_mask=loss_mask,
+            visual_pos_masks=visual_pos_masks,
+            deepstack_visual_embeds=deepstack_visual_embeds,
+        )
diff --git a/src/megatron/bridge/models/qwen_omni/modeling_qwen3_omni/transformer_config.py b/src/megatron/bridge/models/qwen_omni/modeling_qwen3_omni/transformer_config.py
new file mode 100644
index 0000000000..d9b60dcbea
--- /dev/null
+++ b/src/megatron/bridge/models/qwen_omni/modeling_qwen3_omni/transformer_config.py
@@ -0,0 +1,48 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+
+from megatron.bridge.models.qwen_vl.modelling_qwen3_vl.transformer_config import Qwen3VLTransformerConfig
+
+
+@dataclass
+class Qwen3OmniTransformerConfig(Qwen3VLTransformerConfig):
+    """Qwen3-Omni transformer config.
+
+    This config extends the Qwen3-VL language/vision path with Qwen3-Omni
+    multimodal token ids and audio-related settings.
+    """
+
+    vocab_size: int = 152064
+    language_max_sequence_length: int = 32768
+    patch_size: int = 16
+    temporal_patch_size: int = 2
+    spatial_merge_size: int = 2
+    fp16_lm_cross_entropy: bool = False
+    rotary_percent: float = 1.0
+    rotary_base: float = 1000000.0
+    mrope_section: list[int] = field(default_factory=lambda: [24, 20, 20])
+
+    image_token_id: int = 151655
+    video_token_id: int = 151656
+    audio_token_id: int = 151646
+    vision_start_token_id: int = 151652
+    vision_end_token_id: int = 151653
+    audio_start_token_id: int = 151647
+    audio_end_token_id: int = 151648
+    position_id_per_seconds: int = 25
+    seconds_per_chunk: int = 2
+
+    qk_layernorm: bool = True
diff --git a/src/megatron/bridge/models/qwen_omni/qwen3_omni_bridge.py b/src/megatron/bridge/models/qwen_omni/qwen3_omni_bridge.py
new file mode 100644
index 0000000000..5f1ffbb152
--- /dev/null
+++ b/src/megatron/bridge/models/qwen_omni/qwen3_omni_bridge.py
@@ -0,0 +1,165 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+
+import torch
+from transformers import Qwen3OmniMoeForConditionalGeneration
+
+from megatron.bridge.models.conversion.mapping_registry import MegatronMappingRegistry
+from megatron.bridge.models.conversion.model_bridge import MegatronModelBridge
+from megatron.bridge.models.conversion.param_mapping import (
+    AutoMapping,
+    GatedMLPMapping,
+    QKVMapping,
+    ReplicatedMapping,
+)
+from megatron.bridge.models.hf_pretrained.vlm import PreTrainedVLM
+from megatron.bridge.models.qwen_omni.modeling_qwen3_omni.model import Qwen3OmniModel
+from megatron.bridge.models.qwen_omni.qwen3_omni_provider import Qwen3OmniModelProvider
+
+
+logger = logging.getLogger(__name__)
+
+
+@MegatronModelBridge.register_bridge(
+    source=Qwen3OmniMoeForConditionalGeneration,
+    target=Qwen3OmniModel,
+    provider=Qwen3OmniModelProvider,
+    model_type="qwen3_omni",
+)
+class Qwen3OmniBridge(MegatronModelBridge):
+    """Bridge for Qwen3-Omni."""
+
+    def provider_bridge(self, hf_pretrained: PreTrainedVLM) -> Qwen3OmniModelProvider:
+        hf_config = hf_pretrained.config
+        if getattr(hf_config, "enable_audio_output", False):
+            logger.warning(
+                "Qwen3-Omni talker/code2wav audio-output is not supported yet; "
+                "converting thinker-side weights only. Talker/code2wav modules will be ignored."
+            )
+        thinker_config = hf_config.thinker_config
+        talker_config = getattr(hf_config, "talker_config", None)
+        code2wav_config = getattr(hf_config, "code2wav_config", None)
+        text_config = thinker_config.text_config
+        dtype_config = thinker_config if hasattr(thinker_config, "torch_dtype") else hf_config
+        model_dtype = self.dtype_from_hf(dtype_config, default=torch.float32)
+
+        rope_scaling = (
+            getattr(text_config, "rope_scaling", None) or getattr(text_config, "rope_parameters", None) or {}
+        )
+        vision_config = thinker_config.vision_config
+
+        provider = Qwen3OmniModelProvider(
+            thinker_config=thinker_config,
+            talker_config=talker_config,
+            code2wav_config=code2wav_config,
+            num_layers=text_config.num_hidden_layers,
+            hidden_size=text_config.hidden_size,
+            ffn_hidden_size=text_config.intermediate_size,
+            moe_ffn_hidden_size=getattr(text_config, "moe_intermediate_size", None),
+            num_attention_heads=text_config.num_attention_heads,
+            num_query_groups=text_config.num_key_value_heads,
+            kv_channels=getattr(text_config, "head_dim", None),
+            init_method_std=text_config.initializer_range,
+            layernorm_epsilon=text_config.rms_norm_eps,
+            gated_linear_unit=True,
+            make_vocab_size_divisible_by=self.make_vocab_size_divisible_by(text_config.vocab_size),
+            rotary_base=getattr(text_config, "rope_theta", 1000000.0),
+            share_embeddings_and_output_weights=getattr(text_config, "tie_word_embeddings", False),
+            vocab_size=text_config.vocab_size,
+            seq_length=text_config.max_position_embeddings,
+            language_max_sequence_length=text_config.max_position_embeddings,
+            fp16=(model_dtype == torch.float16),
+            bf16=(model_dtype == torch.bfloat16),
+            params_dtype=model_dtype,
+            add_qkv_bias=getattr(text_config, "attention_bias", False),
+            qk_layernorm=True,
+            num_moe_experts=getattr(text_config, "num_experts", 128),
+            moe_router_topk=getattr(text_config, "num_experts_per_tok", 8),
+            image_token_id=getattr(thinker_config, "image_token_id", 151655),
+            video_token_id=getattr(thinker_config, "video_token_id", 151656),
+            audio_token_id=getattr(thinker_config, "audio_token_id", 151646),
+            vision_start_token_id=getattr(thinker_config, "vision_start_token_id", 151652),
+            vision_end_token_id=getattr(thinker_config, "vision_end_token_id", 151653),
+            audio_start_token_id=getattr(thinker_config, "audio_start_token_id", 151647),
+            audio_end_token_id=getattr(thinker_config, "audio_end_token_id", 151648),
+            bos_token_id=getattr(hf_config, "bos_token_id", 151643),
+            eos_token_id=getattr(hf_config, "eos_token_id", 151645),
+            position_id_per_seconds=getattr(thinker_config, "position_id_per_seconds", 25),
+            seconds_per_chunk=getattr(thinker_config, "seconds_per_chunk", 2),
+            patch_size=getattr(vision_config, "patch_size", 16),
+            temporal_patch_size=getattr(vision_config, "temporal_patch_size", 2),
+            spatial_merge_size=getattr(vision_config, "spatial_merge_size", 2),
+            position_embedding_type="mrope",
+            mrope_section=rope_scaling.get("mrope_section", [24, 20, 20]),
+        )
+        return provider
+
+    def mapping_registry(self) -> MegatronMappingRegistry:
+        param_mappings = {
+            "thinker.language_model.embedding.word_embeddings.weight": "thinker.model.embed_tokens.weight",
+            "thinker.language_model.output_layer.weight": "thinker.lm_head.weight",
+            "thinker.language_model.decoder.final_layernorm.weight": "thinker.model.norm.weight",
+            "thinker.language_model.decoder.layers.*.self_attention.linear_qkv.layer_norm_weight": "thinker.model.layers.*.input_layernorm.weight",
+            "thinker.language_model.decoder.layers.*.pre_mlp_layernorm.weight": "thinker.model.layers.*.post_attention_layernorm.weight",
+            "thinker.language_model.decoder.layers.*.self_attention.q_layernorm.weight": "thinker.model.layers.*.self_attn.q_norm.weight",
+            "thinker.language_model.decoder.layers.*.self_attention.k_layernorm.weight": "thinker.model.layers.*.self_attn.k_norm.weight",
+            "thinker.language_model.decoder.layers.*.self_attention.linear_proj.weight": "thinker.model.layers.*.self_attn.o_proj.weight",
+            "thinker.language_model.decoder.layers.*.mlp.router.weight": "thinker.model.layers.*.mlp.gate.weight",
+        }
+
+        mapping_list = [
+            AutoMapping(megatron_param=megatron_param, hf_param=hf_param)
+            for megatron_param, hf_param in param_mappings.items()
+        ]
+
+        mapping_list.extend(
+            [
+                ReplicatedMapping(
+                    megatron_param="thinker.visual.**",
+                    hf_param="thinker.visual.**",
+                ),
+                ReplicatedMapping(
+                    megatron_param="thinker.audio_model.**",
+                    hf_param="thinker.audio_tower.**",
+                ),
+                QKVMapping(
+                    megatron_param="thinker.language_model.decoder.layers.*.self_attention.linear_qkv.weight",
+                    q="thinker.model.layers.*.self_attn.q_proj.weight",
+                    k="thinker.model.layers.*.self_attn.k_proj.weight",
+                    v="thinker.model.layers.*.self_attn.v_proj.weight",
+                ),
+                GatedMLPMapping(
+                    megatron_param="thinker.language_model.decoder.layers.*.mlp.experts.linear_fc1.weight*",
+                    gate="thinker.model.layers.*.mlp.experts.*.gate_proj.weight",
+                    up="thinker.model.layers.*.mlp.experts.*.up_proj.weight",
+                ),
+                AutoMapping(
+                    megatron_param="thinker.language_model.decoder.layers.*.mlp.experts.linear_fc2.weight*",
+                    hf_param="thinker.model.layers.*.mlp.experts.*.down_proj.weight",
+                ),
+                GatedMLPMapping(
+                    megatron_param="thinker.language_model.decoder.layers.*.mlp.experts.local_experts.*.linear_fc1.weight",
+                    gate="thinker.model.layers.*.mlp.experts.*.gate_proj.weight",
+                    up="thinker.model.layers.*.mlp.experts.*.up_proj.weight",
+                ),
+                AutoMapping(
+                    megatron_param="thinker.language_model.decoder.layers.*.mlp.experts.local_experts.*.linear_fc2.weight",
+                    hf_param="thinker.model.layers.*.mlp.experts.*.down_proj.weight",
+                ),
+            ]
+        )
+
+        return MegatronMappingRegistry(*mapping_list)
diff --git a/src/megatron/bridge/models/qwen_omni/qwen3_omni_provider.py b/src/megatron/bridge/models/qwen_omni/qwen3_omni_provider.py
new file mode 100644
index 0000000000..dca0088d28
--- /dev/null
+++ b/src/megatron/bridge/models/qwen_omni/qwen3_omni_provider.py
@@ -0,0 +1,135 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+from typing import Callable
+
+import torch.nn.functional as F
+from megatron.core.models.gpt import GPTModel as MCoreGPTModel
+from megatron.core.models.gpt.gpt_layer_specs import get_gpt_layer_with_transformer_engine_spec
+from megatron.core.pipeline_parallel.utils import (
+    is_pp_first_stage,
+    is_pp_last_stage,
+    is_vp_first_stage,
+    is_vp_last_stage,
+)
+from transformers.models.qwen3_omni_moe.configuration_qwen3_omni_moe import (
+    Qwen3OmniMoeCode2WavConfig,
+    Qwen3OmniMoeTalkerConfig,
+    Qwen3OmniMoeThinkerConfig,
+)
+
+from megatron.bridge.models.gpt_provider import GPTModelProvider
+from megatron.bridge.models.qwen_omni.modeling_qwen3_omni.model import Qwen3OmniModel
+
+
+@dataclass
+class Qwen3OmniModelProvider(GPTModelProvider):
+    """Provider for Qwen3-Omni.
+
+    The current implementation focuses on thinker-side multimodal training and
+    checkpoint conversion paths.
+    """
+
+    thinker_config: Qwen3OmniMoeThinkerConfig = field(default_factory=lambda: Qwen3OmniMoeThinkerConfig())
+    talker_config: Qwen3OmniMoeTalkerConfig | None = None
+    code2wav_config: Qwen3OmniMoeCode2WavConfig | None = None
+
+    pretrained_model_name: str = "Qwen/Qwen3-Omni-30B-A3B-Instruct"
+
+    normalization: str = "RMSNorm"
+    activation_func: Callable = F.silu
+    gated_linear_unit: bool = True
+    add_bias_linear: bool = False
+    add_qkv_bias: bool = False
+    hidden_dropout: float = 0.0
+    qk_layernorm: bool = True
+    moe_grouped_gemm: bool = True
+    moe_router_load_balancing_type: str = "aux_loss"
+    moe_aux_loss_coeff: float = 1e-3
+    moe_router_pre_softmax: bool = False
+    moe_token_dispatcher_type: str = "alltoall"
+    moe_permute_fusion: bool = True
+
+    image_token_id: int = 151655
+    video_token_id: int = 151656
+    audio_token_id: int = 151646
+    vision_start_token_id: int = 151652
+    vision_end_token_id: int = 151653
+    audio_start_token_id: int = 151647
+    audio_end_token_id: int = 151648
+    bos_token_id: int = 151643
+    eos_token_id: int = 151645
+
+    language_max_sequence_length: int = 32768
+    position_embedding_type: str = "mrope"
+    position_id_per_seconds: int = 25
+    seconds_per_chunk: int = 2
+    patch_size: int = 16
+    temporal_patch_size: int = 2
+    spatial_merge_size: int = 2
+    mrope_section: list[int] = field(default_factory=lambda: [24, 20, 20])
+    scatter_embedding_sequence_parallel: bool = False
+
+    freeze_language_model: bool = False
+    freeze_vision_model: bool = False
+    freeze_audio_model: bool = False
+    vit_gradient_checkpointing: bool = False
+    multimodal_attn_impl: str = "auto"
+
+    def provide(self, pre_process=None, post_process=None, vp_stage=None):
+        pp_group = self._pg_collection.pp if self._pg_collection is not None else None
+        vp_size = self.virtual_pipeline_model_parallel_size
+        if pre_process is None:
+            pre_process = (
+                is_vp_first_stage(vp_stage=vp_stage, vp_size=vp_size) and is_pp_first_stage(pp_group)
+                if pp_group is not None
+                else True
+            )
+        if post_process is None:
+            post_process = (
+                is_vp_last_stage(vp_stage=vp_stage, vp_size=vp_size) and is_pp_last_stage(pp_group)
+                if pp_group is not None
+                else True
+            )
+
+        language_transformer_layer_spec = get_gpt_layer_with_transformer_engine_spec(
+            num_experts=self.num_moe_experts,
+            moe_grouped_gemm=self.moe_grouped_gemm,
+            qk_layernorm=self.qk_layernorm,
+            fp8=False,
+        )
+
+        model = Qwen3OmniModel(
+            language_transformer_config=self,
+            language_transformer_layer_spec=language_transformer_layer_spec,
+            thinker_transformer_config=self.thinker_config,
+            talker_transformer_config=self.talker_config,
+            code2wav_transformer_config=self.code2wav_config,
+            pre_process=pre_process,
+            post_process=post_process,
+            pg_collection=self._pg_collection,
+        )
+
+        if self.freeze_language_model or self.freeze_vision_model or self.freeze_audio_model:
+            model.freeze(
+                freeze_language_model=self.freeze_language_model,
+                freeze_vision_model=self.freeze_vision_model,
+                freeze_audio_model=self.freeze_audio_model,
+            )
+
+        return model
+
+    def provide_language_model(self, pre_process=None, post_process=None, vp_stage=None) -> MCoreGPTModel:
+        return super().provide(pre_process=pre_process, post_process=post_process, vp_stage=vp_stage)
diff --git a/src/megatron/bridge/models/qwen_omni/qwen3_omni_step.py b/src/megatron/bridge/models/qwen_omni/qwen3_omni_step.py
new file mode 100644
index 0000000000..ac6efda805
--- /dev/null
+++ b/src/megatron/bridge/models/qwen_omni/qwen3_omni_step.py
@@ -0,0 +1,211 @@
+# Copyright (c) 2026, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Qwen3-Omni thinker training step helpers."""
+
+from __future__ import annotations
+
+from functools import partial
+from typing import TYPE_CHECKING, Any, Iterable
+
+import torch
+from megatron.core.models.gpt import GPTModel
+from megatron.core.pipeline_parallel.utils import is_pp_first_stage, is_pp_last_stage
+from megatron.core.utils import get_model_config
+
+from megatron.bridge.training.losses import (
+    create_masked_next_token_loss_function as _create_loss_function,
+)
+from megatron.bridge.training.utils.padding_utils import (
+    pad_or_truncate_2d_to_len,
+    pad_or_truncate_attn_to_len,
+    pad_or_truncate_pos_to_len,
+)
+from megatron.bridge.training.utils.pg_utils import get_pg_collection
+
+
+if TYPE_CHECKING:
+    from megatron.bridge.training.config import ConfigContainer
+    from megatron.bridge.training.state import GlobalState
+
+
+_MULTIMODAL_KEYS = (
+    "pixel_values",
+    "image_grid_thw",
+    "pixel_values_videos",
+    "video_grid_thw",
+    "video_second_per_grid",
+    "visual_inputs",
+    "input_features",
+    "feature_attention_mask",
+    "audio_feature_lengths",
+)
+
+
+def get_batch_from_iterator(
+    data_iterator: Iterable,
+    use_mtp: bool = False,
+    skip_getting_attention_mask_from_dataset: bool = True,
+    *,
+    is_first_pp_stage: bool,
+    is_last_pp_stage: bool,
+) -> dict[str, Any]:
+    """Get a thinker-training batch from the iterator."""
+
+    del use_mtp, is_first_pp_stage
+    batch = next(data_iterator)
+
+    required_device_keys = set(_MULTIMODAL_KEYS)
+    required_device_keys.update(("tokens", "input_ids", "position_ids"))
+    if not skip_getting_attention_mask_from_dataset:
+        required_device_keys.add("attention_mask")
+    if is_last_pp_stage:
+        required_device_keys.update(("labels", "loss_mask"))
+
+    batch_required_keys: dict[str, Any] = {}
+    for key, value in batch.items():
+        if key in required_device_keys:
+            if key == "visual_inputs":
+                if value is None:
+                    batch_required_keys[key] = None
+                else:
+                    batch_required_keys[key] = value
+                    for visual_key, visual_value in value.__dict__.items():
+                        value.__dict__[visual_key] = (
+                            visual_value.cuda(non_blocking=True) if visual_value is not None else None
+                        )
+            else:
+                batch_required_keys[key] = value.cuda(non_blocking=True) if value is not None else None
+        else:
+            batch_required_keys[key] = value
+
+    return batch_required_keys
+
+
+def _normalize_multimodal_inputs(batch: dict[str, Any]) -> dict[str, torch.Tensor]:
+    """Normalize multimodal batch tensors for Qwen3-Omni model forward."""
+
+    normalized: dict[str, torch.Tensor] = {}
+    visual_inputs = batch.get("visual_inputs")
+    if visual_inputs is not None:
+        normalized.update(visual_inputs.normalized_for_model())
+    for key in _MULTIMODAL_KEYS:
+        if key == "visual_inputs":
+            continue
+        value = batch.get(key)
+        if value is None:
+            continue
+        if key in ("pixel_values", "pixel_values_videos") and value.dim() == 5:
+            bsz, nitems, channels, height, width = value.shape
+            normalized[key] = value.view(bsz * nitems, channels, height, width)
+        elif key in ("image_grid_thw", "video_grid_thw") and value.dim() == 3:
+            normalized[key] = value.view(-1, value.size(-1))
+        elif key == "video_second_per_grid" and value.dim() > 1:
+            normalized[key] = value.reshape(-1)
+        else:
+            normalized[key] = value
+    return normalized
+
+
+def get_batch(data_iterator: Iterable, cfg: "ConfigContainer", use_mtp: bool = False, *, pg_collection) -> tuple[...]:
+    """Generate a minimal thinker-training batch."""
+
+    is_first = is_pp_first_stage(pg_collection.pp)
+    is_last = is_pp_last_stage(pg_collection.pp)
+    batch = get_batch_from_iterator(
+        data_iterator,
+        use_mtp,
+        getattr(cfg.dataset, "skip_getting_attention_mask_from_dataset", True),
+        is_first_pp_stage=is_first,
+        is_last_pp_stage=is_last,
+    )
+
+    if getattr(cfg.model, "pipeline_model_parallel_size", 1) > 1:
+        seq_len = cfg.model.seq_length
+        tokens_or_input = batch.get("tokens") if batch.get("tokens") is not None else batch.get("input_ids")
+        tokens_or_input = pad_or_truncate_2d_to_len(tokens_or_input, seq_len, seq_len, pad_value=0)
+        if batch.get("tokens") is not None:
+            batch["tokens"] = tokens_or_input
+        else:
+            batch["input_ids"] = tokens_or_input
+        batch["labels"] = pad_or_truncate_2d_to_len(batch.get("labels"), seq_len, seq_len, pad_value=-100)
+        batch["loss_mask"] = pad_or_truncate_2d_to_len(batch.get("loss_mask"), seq_len, seq_len, pad_value=0)
+        batch["position_ids"] = pad_or_truncate_pos_to_len(batch.get("position_ids"), seq_len, seq_len)
+        if batch.get("attention_mask") is not None:
+            batch["attention_mask"] = pad_or_truncate_attn_to_len(batch.get("attention_mask"), seq_len, seq_len)
+
+    multimodal_inputs = _normalize_multimodal_inputs(batch)
+    return (
+        (batch.get("tokens") if batch.get("tokens") is not None else batch.get("input_ids")),
+        batch.get("labels"),
+        batch.get("loss_mask"),
+        batch.get("attention_mask"),
+        batch.get("position_ids"),
+        multimodal_inputs,
+    )
+
+
+def forward_step(
+    state: "GlobalState",
+    data_iterator: Iterable,
+    model: GPTModel,
+    return_schedule_plan: bool = False,
+) -> tuple[torch.Tensor, partial]:
+    """Forward training step for Qwen3-Omni thinker."""
+
+    timers = state.timers
+    straggler_timer = state.straggler_timer
+
+    config = get_model_config(model)
+    use_mtp = (getattr(config, "mtp_num_layers", None) or 0) > 0
+
+    timers("batch-generator", log_level=2).start()
+    pg_collection = get_pg_collection(model)
+    with straggler_timer(bdata=True):
+        tokens, labels, loss_mask, attention_mask, position_ids, multimodal_inputs = get_batch(
+            data_iterator, state.cfg, use_mtp, pg_collection=pg_collection
+        )
+    timers("batch-generator").stop()
+
+    if pg_collection.cp.size() > 1:
+        raise NotImplementedError("Qwen3-Omni training supports SP/EP, but CP is not supported yet.")
+
+    forward_args = {
+        "input_ids": tokens,
+        "position_ids": position_ids,
+        "attention_mask": attention_mask,
+        "labels": labels,
+        "loss_mask": loss_mask,
+    }
+    forward_args.update(multimodal_inputs)
+
+    # The Omni thinker computes multimodal mRoPE internally from full input_ids.
+    forward_args["position_ids"] = None
+
+    check_for_nan_in_loss = state.cfg.rerun_state_machine.check_for_nan_in_loss
+    check_for_spiky_loss = state.cfg.rerun_state_machine.check_for_spiky_loss
+    with straggler_timer:
+        if return_schedule_plan:
+            assert config.overlap_moe_expert_parallel_comm, (
+                "overlap_moe_expert_parallel_comm must be enabled to return the schedule plan"
+            )
+            schedule_plan = model.build_schedule_plan(
+                tokens, position_ids, attention_mask, labels=labels, loss_mask=loss_mask
+            )
+            loss_function = _create_loss_function(loss_mask, check_for_nan_in_loss, check_for_spiky_loss)
+            return schedule_plan, loss_function
+        output_tensor = model(**forward_args)
+
+    loss_function = _create_loss_function(loss_mask, check_for_nan_in_loss, check_for_spiky_loss)
+    return output_tensor, loss_function
diff --git a/src/megatron/bridge/models/qwen_vl/modelling_qwen3_vl/rope.py b/src/megatron/bridge/models/qwen_vl/modelling_qwen3_vl/rope.py
index 0a29163e44..7eb11dc2b1 100644
--- a/src/megatron/bridge/models/qwen_vl/modelling_qwen3_vl/rope.py
+++ b/src/megatron/bridge/models/qwen_vl/modelling_qwen3_vl/rope.py
@@ -17,11 +17,15 @@
 
 import torch
 import torch.nn as nn
+from megatron.core.inference.contexts import BaseInferenceContext
 from megatron.core.models.common.embeddings.rope_utils import (
     _apply_rotary_pos_emb_bshd,
     get_pos_emb_on_this_cp_rank,
 )
 from megatron.core.packed_seq_params import PackedSeqParams
+from megatron.core.transformer.transformer_block import TransformerBlock
+from megatron.core.transformer.transformer_config import TransformerConfig
+from megatron.core.utils import deprecate_inference_params
 from torch import Tensor
 
 from megatron.bridge.models.qwen_vl.modelling_qwen3_vl.transformer_config import Qwen3VLTransformerConfig
@@ -135,6 +139,44 @@ def forward(
             emb = get_pos_emb_on_this_cp_rank(emb, 0, self.cp_group)
         return emb
 
+    def get_rotary_seq_len(
+        self,
+        inference_context: BaseInferenceContext,
+        transformer: TransformerBlock,
+        transformer_input: Tensor,
+        transformer_config: TransformerConfig,
+        packed_seq_params: Optional[PackedSeqParams] = None,
+        *,
+        inference_params: Optional[BaseInferenceContext] = None,
+    ) -> int:
+        """Compatibility shim for newer MCore GPT preprocessing.
+
+        Qwen3-VL/Qwen3-Omni mRoPE uses explicit multimodal `position_ids`, but the upstream
+        GPT preprocess path still queries a rotary sequence length helper when preparing inputs.
+        """
+        inference_context = deprecate_inference_params(inference_context, inference_params)
+
+        if packed_seq_params is not None:
+            return max(packed_seq_params.max_seqlen_q, packed_seq_params.max_seqlen_kv)
+        if inference_context is not None:
+            context_max_seq_len = inference_context.max_sequence_length
+            input_seq_len = 0
+            if transformer_input is not None:
+                input_seq_len = transformer_input.size(0)
+            elif transformer is not None and transformer.input_tensor is not None:
+                input_seq_len = transformer.input_tensor.size(0)
+            return max(context_max_seq_len, input_seq_len)
+
+        if transformer is not None and transformer.input_tensor is not None:
+            rotary_seq_len = transformer.input_tensor.size(0)
+        else:
+            rotary_seq_len = transformer_input.size(0)
+
+        if transformer_config.sequence_parallel:
+            rotary_seq_len *= transformer_config.tensor_model_parallel_size
+
+        return rotary_seq_len
+
 
 # Slightly modified from Qwen3VLModel.get_rope_index
 def get_rope_index(
diff --git a/src/megatron/bridge/recipes/__init__.py b/src/megatron/bridge/recipes/__init__.py
index 1ab50b3368..6c1b119d23 100644
--- a/src/megatron/bridge/recipes/__init__.py
+++ b/src/megatron/bridge/recipes/__init__.py
@@ -36,4 +36,5 @@
 from megatron.bridge.recipes.olmoe import *
 from megatron.bridge.recipes.qwen import *
 from megatron.bridge.recipes.qwen2_audio import *
+from megatron.bridge.recipes.qwen_omni import *
 from megatron.bridge.recipes.qwen_vl import *
diff --git a/src/megatron/bridge/recipes/qwen_omni/__init__.py b/src/megatron/bridge/recipes/qwen_omni/__init__.py
new file mode 100644
index 0000000000..c54879b26a
--- /dev/null
+++ b/src/megatron/bridge/recipes/qwen_omni/__init__.py
@@ -0,0 +1,17 @@
+# Copyright (c) 2026, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Qwen3-Omni recipe exports."""
+
+from megatron.bridge.recipes.qwen_omni.qwen3_omni import *
diff --git a/src/megatron/bridge/recipes/qwen_omni/qwen3_omni.py b/src/megatron/bridge/recipes/qwen_omni/qwen3_omni.py
new file mode 100644
index 0000000000..48183ce482
--- /dev/null
+++ b/src/megatron/bridge/recipes/qwen_omni/qwen3_omni.py
@@ -0,0 +1,153 @@
+# Copyright (c) 2026, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Qwen3-Omni thinker training recipes."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import torch
+
+from megatron.bridge import AutoBridge
+from megatron.bridge.data.vlm_datasets.preloaded_provider import PreloadedVLMConversationProvider
+from megatron.bridge.recipes.common import _sft_common_vlm
+from megatron.bridge.recipes.utils.optimizer_utils import distributed_fused_adam_with_cosine_annealing
+
+
+if TYPE_CHECKING:
+    from megatron.bridge.training.config import ConfigContainer
+
+
+def qwen3_omni_30b_a3b_sft_config(
+    hf_path: str = "Qwen/Qwen3-Omni-30B-A3B-Instruct",
+) -> "ConfigContainer":
+    """Return a minimal thinker-only SFT config for Qwen3-Omni 30B-A3B."""
+
+    cfg = _sft_common_vlm()
+
+    cfg.model = AutoBridge.from_hf_pretrained(hf_path).to_megatron_provider(load_weights=False)
+    cfg.model.seq_length = 4096
+    cfg.model.tensor_model_parallel_size = 1
+    cfg.model.pipeline_model_parallel_size = 1
+    cfg.model.pipeline_dtype = torch.bfloat16
+    cfg.model.virtual_pipeline_model_parallel_size = None
+    cfg.model.context_parallel_size = 1
+    cfg.model.expert_model_parallel_size = 1
+    cfg.model.expert_tensor_parallel_size = 1
+    cfg.model.sequence_parallel = False
+
+    cfg.model.freeze_language_model = False
+    cfg.model.freeze_vision_model = False
+    cfg.model.freeze_audio_model = False
+    cfg.model.vit_gradient_checkpointing = False
+    cfg.model.multimodal_attn_impl = "auto"
+
+    cfg.model.transformer_impl = "transformer_engine"
+    cfg.model.cuda_graph_impl = "none"
+    cfg.model.attention_backend = "auto"
+
+    cfg.train.train_iters = 1000
+    cfg.train.global_batch_size = 32
+    cfg.train.micro_batch_size = 1
+
+    opt_cfg, scheduler_cfg = distributed_fused_adam_with_cosine_annealing(
+        lr_warmup_iters=50,
+        lr_decay_iters=1000,
+        max_lr=5e-6,
+        min_lr=5e-7,
+        adam_beta2=0.98,
+    )
+    cfg.optimizer = opt_cfg
+    cfg.scheduler = scheduler_cfg
+
+    cfg.dataset.seq_length = 4096
+    cfg.dataset.hf_processor_path = hf_path
+    cfg.dataset.pack_sequences_in_batch = False
+
+    cfg.ddp.overlap_grad_reduce = False
+    cfg.ddp.overlap_param_gather = False
+    cfg.ddp.check_for_nan_in_grad = True
+    cfg.ddp.use_distributed_optimizer = True
+    cfg.ddp.grad_reduce_in_fp32 = True
+    cfg.ddp.average_in_collective = True
+    cfg.ddp.data_parallel_sharding_strategy = "optim_grads_params"
+
+    cfg.mixed_precision = "bf16_mixed"
+    return cfg
+
+
+def qwen3_omni_30b_a3b_sft_preloaded_config(
+    hf_path: str = "Qwen/Qwen3-Omni-30B-A3B-Instruct",
+) -> "ConfigContainer":
+    """Return a thinker-only SFT config backed by preloaded local JSON/JSONL data."""
+
+    cfg = _sft_common_vlm()
+
+    cfg.model = AutoBridge.from_hf_pretrained(hf_path).to_megatron_provider(load_weights=False)
+    cfg.model.seq_length = 4096
+    cfg.model.tensor_model_parallel_size = 1
+    cfg.model.pipeline_model_parallel_size = 1
+    cfg.model.pipeline_dtype = torch.bfloat16
+    cfg.model.virtual_pipeline_model_parallel_size = None
+    cfg.model.context_parallel_size = 1
+    cfg.model.expert_model_parallel_size = 1
+    cfg.model.expert_tensor_parallel_size = 1
+    cfg.model.sequence_parallel = False
+
+    cfg.model.freeze_language_model = False
+    cfg.model.freeze_vision_model = False
+    cfg.model.freeze_audio_model = False
+    cfg.model.vit_gradient_checkpointing = False
+    cfg.model.multimodal_attn_impl = "auto"
+
+    cfg.model.transformer_impl = "transformer_engine"
+    cfg.model.cuda_graph_impl = "none"
+    cfg.model.attention_backend = "auto"
+
+    cfg.train.train_iters = 1000
+    cfg.train.global_batch_size = 32
+    cfg.train.micro_batch_size = 1
+
+    opt_cfg, scheduler_cfg = distributed_fused_adam_with_cosine_annealing(
+        lr_warmup_iters=50,
+        lr_decay_iters=1000,
+        max_lr=5e-6,
+        min_lr=5e-7,
+        adam_beta2=0.98,
+    )
+    cfg.optimizer = opt_cfg
+    cfg.scheduler = scheduler_cfg
+
+    cfg.dataset = PreloadedVLMConversationProvider(
+        seq_length=cfg.model.seq_length,
+        hf_processor_path=hf_path,
+        train_data_path=None,
+        valid_data_path=None,
+        test_data_path=None,
+        dataloader_type="single",
+        num_workers=2,
+    )
+    cfg.dataset.pack_sequences_in_batch = False
+
+    cfg.ddp.overlap_grad_reduce = False
+    cfg.ddp.overlap_param_gather = False
+    cfg.ddp.check_for_nan_in_grad = True
+    cfg.ddp.use_distributed_optimizer = True
+    cfg.ddp.grad_reduce_in_fp32 = True
+    cfg.ddp.average_in_collective = True
+    cfg.ddp.data_parallel_sharding_strategy = "optim_grads_params"
+
+    cfg.mixed_precision = "bf16_mixed"
+    return cfg
diff --git a/src/megatron/bridge/training/utils/padding_utils.py b/src/megatron/bridge/training/utils/padding_utils.py
index 58fef05026..5ef746ebe2 100644
--- a/src/megatron/bridge/training/utils/padding_utils.py
+++ b/src/megatron/bridge/training/utils/padding_utils.py
@@ -71,16 +71,27 @@ def pad_or_truncate_pos_to_len(pos: torch.Tensor | None, target_len: int, max_ca
 
 
 def pad_or_truncate_attn_to_len(mask: torch.Tensor | None, target_len: int, max_cap: int) -> torch.Tensor | None:
-    """Pad or truncate a 4D attention mask to the target length with an upper cap.
+    """Pad or truncate a 2D or 4D attention mask to the target length with an upper cap.
 
-    Expects input of shape (batch, heads, seq_len, seq_len). Pads the last two dims.
+    Supports either:
+    - (batch, seq_len), padding/truncating the last dimension
+    - (batch, heads, seq_len, seq_len), padding/truncating the last two dims
     """
     if mask is None:
         return None
-    _, _, s1, s2 = mask.shape
     pad_value = False if mask.dtype == torch.bool else 0
-    if s1 < target_len:
-        return F.pad(mask, (0, target_len - s2, 0, target_len - s1), value=pad_value)
-    if s1 > max_cap:
-        return mask[:, :, :max_cap, :max_cap]
-    return mask
+    if mask.dim() == 2:
+        seq_len = mask.size(1)
+        if seq_len < target_len:
+            return F.pad(mask, (0, target_len - seq_len), value=pad_value)
+        if seq_len > max_cap:
+            return mask[:, :max_cap]
+        return mask
+    if mask.dim() == 4:
+        _, _, s1, s2 = mask.shape
+        if s1 < target_len:
+            return F.pad(mask, (0, target_len - s2, 0, target_len - s1), value=pad_value)
+        if s1 > max_cap:
+            return mask[:, :, :max_cap, :max_cap]
+        return mask
+    raise ValueError(f"attention mask must be 2D or 4D, got shape {tuple(mask.shape)}")
diff --git a/tests/functional_tests/launch_scripts/gb200/active/L0_Launch_models_qwen3_omni.sh b/tests/functional_tests/launch_scripts/gb200/active/L0_Launch_models_qwen3_omni.sh
new file mode 100644
index 0000000000..6819432522
--- /dev/null
+++ b/tests/functional_tests/launch_scripts/gb200/active/L0_Launch_models_qwen3_omni.sh
@@ -0,0 +1,24 @@
+#!/bin/bash
+# Copyright (c) 2026, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set -xeuo pipefail
+
+REPO_ROOT=$(cd "$(dirname "$0")/../../.." && pwd)
+export CUDA_VISIBLE_DEVICES="${CUDA_VISIBLE_DEVICES:-0,1}"
+
+uv run coverage run --data-file="${REPO_ROOT}/.coverage" --source="${REPO_ROOT}" --parallel-mode -m pytest \
+  -o log_cli=true -o log_cli_level=INFO -v -s -x -m "not pleasefixme" --tb=short -rA \
+  tests/functional_tests/models/qwen_omni/test_qwen3_omni_conversion.py
+coverage combine -q
diff --git a/tests/functional_tests/launch_scripts/h100/active/L0_Launch_models_qwen3_omni.sh b/tests/functional_tests/launch_scripts/h100/active/L0_Launch_models_qwen3_omni.sh
new file mode 100644
index 0000000000..6819432522
--- /dev/null
+++ b/tests/functional_tests/launch_scripts/h100/active/L0_Launch_models_qwen3_omni.sh
@@ -0,0 +1,24 @@
+#!/bin/bash
+# Copyright (c) 2026, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set -xeuo pipefail
+
+REPO_ROOT=$(cd "$(dirname "$0")/../../.." && pwd)
+export CUDA_VISIBLE_DEVICES="${CUDA_VISIBLE_DEVICES:-0,1}"
+
+uv run coverage run --data-file="${REPO_ROOT}/.coverage" --source="${REPO_ROOT}" --parallel-mode -m pytest \
+  -o log_cli=true -o log_cli_level=INFO -v -s -x -m "not pleasefixme" --tb=short -rA \
+  tests/functional_tests/models/qwen_omni/test_qwen3_omni_conversion.py
+coverage combine -q
diff --git a/tests/functional_tests/models/qwen_omni/__init__.py b/tests/functional_tests/models/qwen_omni/__init__.py
new file mode 100644
index 0000000000..3f4cf13e54
--- /dev/null
+++ b/tests/functional_tests/models/qwen_omni/__init__.py
@@ -0,0 +1,3 @@
+# Copyright (c) 2026, NVIDIA CORPORATION.  All rights reserved.
+
+"""Qwen3-Omni functional test package."""
diff --git a/tests/functional_tests/models/qwen_omni/test_qwen3_omni_conversion.py b/tests/functional_tests/models/qwen_omni/test_qwen3_omni_conversion.py
new file mode 100644
index 0000000000..8673dcaa99
--- /dev/null
+++ b/tests/functional_tests/models/qwen_omni/test_qwen3_omni_conversion.py
@@ -0,0 +1,217 @@
+# Copyright (c) 2026, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Functional tests for Qwen3-Omni HF <-> Megatron roundtrip conversion."""
+
+import json
+import os
+import subprocess
+from pathlib import Path
+
+import pytest
+import torch
+
+
+try:
+    from transformers.models.qwen3_omni_moe.configuration_qwen3_omni_moe import Qwen3OmniMoeConfig
+    from transformers.models.qwen3_omni_moe.modeling_qwen3_omni_moe import Qwen3OmniMoeForConditionalGeneration
+
+    _HAS_QWEN3_OMNI = True
+except ImportError:
+    _HAS_QWEN3_OMNI = False
+
+
+HF_QWEN3_OMNI_TOY_MODEL_CONFIG = {
+    "architectures": ["Qwen3OmniMoeForConditionalGeneration"],
+    "model_type": "qwen3_omni_moe",
+    "enable_audio_output": False,
+    "torch_dtype": "bfloat16",
+    "thinker_config": {
+        "audio_token_id": 151646,
+        "audio_start_token_id": 151647,
+        "image_token_id": 151655,
+        "video_token_id": 151656,
+        "position_id_per_seconds": 25,
+        "text_config": {
+            "model_type": "qwen3_moe",
+            "vocab_size": 2048,
+            "hidden_size": 256,
+            "intermediate_size": 512,
+            "num_hidden_layers": 4,
+            "num_attention_heads": 4,
+            "num_key_value_heads": 2,
+            "hidden_act": "silu",
+            "max_position_embeddings": 32768,
+            "rope_theta": 1000000.0,
+            "rope_scaling": {"rope_type": "default", "mrope_section": [8, 8, 8]},
+            "rms_norm_eps": 1e-06,
+            "attention_bias": False,
+            "attention_dropout": 0.0,
+            "decoder_sparse_step": 1,
+            "moe_intermediate_size": 128,
+            "num_experts_per_tok": 2,
+            "num_experts": 4,
+            "norm_topk_prob": True,
+            "tie_word_embeddings": False,
+            "torch_dtype": "bfloat16",
+            "use_cache": True,
+        },
+        "vision_config": {
+            "depth": 2,
+            "hidden_size": 128,
+            "hidden_act": "gelu_pytorch_tanh",
+            "intermediate_size": 256,
+            "num_heads": 4,
+            "in_channels": 3,
+            "patch_size": 16,
+            "spatial_merge_size": 2,
+            "temporal_patch_size": 2,
+            "out_hidden_size": 256,
+            "num_position_embeddings": 256,
+            "deepstack_visual_indexes": [1],
+        },
+        "audio_config": {
+            "num_mel_bins": 128,
+            "encoder_layers": 2,
+            "encoder_attention_heads": 4,
+            "encoder_ffn_dim": 512,
+            "d_model": 256,
+            "dropout": 0.0,
+            "attention_dropout": 0.0,
+            "activation_function": "gelu",
+            "activation_dropout": 0.0,
+            "scale_embedding": False,
+            "max_source_positions": 128,
+            "n_window": 8,
+            "output_dim": 256,
+            "n_window_infer": 8,
+            "conv_chunksize": 8,
+            "downsample_hidden_size": 64,
+        },
+    },
+}
+
+
+@pytest.mark.skipif(not _HAS_QWEN3_OMNI, reason="transformers does not have Qwen3-Omni support")
+class TestQwen3OmniConversion:
+    """Test Qwen3-Omni conversion with a tiny self-contained toy checkpoint."""
+
+    @pytest.fixture(scope="class")
+    def qwen3_omni_toy_model_path(self, tmp_path_factory):
+        """Create and save a toy Qwen3-Omni checkpoint for CI-safe conversion testing."""
+        temp_dir = tmp_path_factory.mktemp("qwen3_omni_toy_model")
+        model_dir = temp_dir / "qwen3_omni_toy"
+        model_dir.mkdir(parents=True, exist_ok=True)
+
+        config = Qwen3OmniMoeConfig(**HF_QWEN3_OMNI_TOY_MODEL_CONFIG)
+        config.torch_dtype = torch.bfloat16
+
+        model = Qwen3OmniMoeForConditionalGeneration(config)
+        model = model.to(dtype=torch.bfloat16)
+        model.save_pretrained(model_dir, safe_serialization=True)
+
+        with open(model_dir / "tokenizer_config.json", "w") as f:
+            json.dump({"tokenizer_class": "Qwen2Tokenizer", "vocab_size": 2048}, f, indent=2)
+
+        return str(model_dir)
+
+    def test_toy_model_creation(self, qwen3_omni_toy_model_path):
+        """Verify the toy Qwen3-Omni checkpoint can be created and reloaded."""
+        model_path = Path(qwen3_omni_toy_model_path)
+        assert model_path.exists()
+        assert (model_path / "config.json").exists()
+        assert (model_path / "model.safetensors").exists()
+        assert (model_path / "tokenizer_config.json").exists()
+
+        with open(model_path / "config.json") as f:
+            config_data = json.load(f)
+
+        assert config_data["model_type"] == "qwen3_omni_moe"
+        assert config_data["enable_audio_output"] is False
+        assert config_data["thinker_config"]["text_config"]["hidden_size"] == 256
+        assert config_data["thinker_config"]["text_config"]["num_hidden_layers"] == 4
+        assert config_data["thinker_config"]["vision_config"]["depth"] == 2
+        assert config_data["thinker_config"]["audio_config"]["encoder_layers"] == 2
+
+        _ = Qwen3OmniMoeForConditionalGeneration.from_pretrained(
+            qwen3_omni_toy_model_path,
+            dtype=torch.bfloat16,
+            low_cpu_mem_usage=False,
+        )
+
+    @pytest.mark.run_only_on("GPU")
+    def test_qwen3_omni_conversion(self, qwen3_omni_toy_model_path, tmp_path):
+        """Run the HF -> Megatron -> HF roundtrip conversion on the toy checkpoint."""
+        if torch.cuda.device_count() < 2:
+            pytest.skip("Qwen3-Omni conversion test requires at least 2 GPUs.")
+        output_dir = tmp_path / "qwen3_omni_test"
+        output_dir.mkdir(exist_ok=True)
+        repo_root = Path(__file__).resolve().parents[4]
+        env = os.environ.copy()
+        env["PYTHONPATH"] = f"{repo_root / 'src'}:{repo_root / '3rdparty' / 'Megatron-LM'}"
+
+        cmd = [
+            "python",
+            "-m",
+            "torch.distributed.run",
+            "--nproc_per_node=2",
+            "--nnodes=1",
+            "-m",
+            "coverage",
+            "run",
+            f"--data-file={repo_root / '.coverage'}",
+            f"--source={repo_root}",
+            "--parallel-mode",
+            "examples/conversion/hf_megatron_roundtrip_multi_gpu.py",
+            "--hf-model-id",
+            qwen3_omni_toy_model_path,
+            "--output-dir",
+            str(output_dir),
+            "--tp",
+            "2",
+            "--pp",
+            "1",
+            "--ep",
+            "1",
+            "--etp",
+            "1",
+        ]
+
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            cwd=repo_root,
+            env=env,
+        )
+
+        if result.returncode != 0:
+            print(f"STDOUT: {result.stdout}")
+            print(f"STDERR: {result.stderr}")
+            assert False, f"Qwen3-Omni conversion failed with return code {result.returncode}"
+
+        model_name = Path(qwen3_omni_toy_model_path).name
+        converted_model_dir = output_dir / model_name
+        assert converted_model_dir.exists()
+        assert (converted_model_dir / "config.json").exists()
+        assert (converted_model_dir / "model.safetensors").exists() or any(
+            converted_model_dir.glob("model-*-of-*.safetensors")
+        )
+
+        with open(converted_model_dir / "config.json") as f:
+            saved_config = json.load(f)
+
+        assert saved_config["model_type"] == "qwen3_omni_moe"
+        assert saved_config["enable_audio_output"] is False
+        assert saved_config["thinker_config"]["text_config"]["num_hidden_layers"] == 4
diff --git a/tests/functional_tests/models/qwen_omni/test_qwen3_omni_smoke.py b/tests/functional_tests/models/qwen_omni/test_qwen3_omni_smoke.py
new file mode 100644
index 0000000000..f17abc831f
--- /dev/null
+++ b/tests/functional_tests/models/qwen_omni/test_qwen3_omni_smoke.py
@@ -0,0 +1,198 @@
+# Copyright (c) 2026, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""End-to-end smoke tests for local HF and Megatron Qwen3-Omni thinker paths."""
+
+import datetime
+import os
+import socket
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+import torch
+import torch.distributed as dist
+from megatron.core import parallel_state
+from megatron.core.tensor_parallel.random import model_parallel_cuda_manual_seed
+from transformers import Qwen3OmniMoeForConditionalGeneration
+
+from tests.functional_tests.models.qwen_omni.utils import (
+    SMOKE_MODEL_CACHE_PATH,
+    build_real_sample_inputs,
+    create_qwen3_omni_smoke_model,
+    move_inputs_to_device,
+    smoke_assets_available,
+)
+
+
+pytestmark = [
+    pytest.mark.run_only_on("GPU"),
+    pytest.mark.skipif(not smoke_assets_available(), reason="Qwen3-Omni local smoke assets are unavailable"),
+]
+
+
+class TestQwen3OmniSmoke:
+    """End-to-end smoke coverage for local HF and Megatron Qwen3-Omni thinker paths."""
+
+    @pytest.fixture(scope="class")
+    def qwen3_omni_smoke_model_path(self, tmp_path_factory):
+        """Create or reuse the cached local Qwen3-Omni smoke checkpoint."""
+        del tmp_path_factory
+        return str(create_qwen3_omni_smoke_model(SMOKE_MODEL_CACHE_PATH))
+
+    @staticmethod
+    def _init_dist(master_port: str) -> None:
+        """Initialize a single-process distributed group for Megatron smoke tests."""
+        if dist.is_initialized():
+            return
+        os.environ["MASTER_ADDR"] = "127.0.0.1"
+        os.environ["MASTER_PORT"] = master_port
+        os.environ["RANK"] = "0"
+        os.environ["LOCAL_RANK"] = "0"
+        os.environ["WORLD_SIZE"] = "1"
+        dist.init_process_group(
+            backend="nccl" if torch.cuda.is_available() else "gloo",
+            world_size=1,
+            rank=0,
+            timeout=datetime.timedelta(minutes=30),
+        )
+
+    @staticmethod
+    def _init_model_parallel() -> None:
+        """Initialize 1x1 Megatron model-parallel state for local smoke execution."""
+        if parallel_state.model_parallel_is_initialized():
+            parallel_state.destroy_model_parallel()
+        parallel_state.initialize_model_parallel(
+            tensor_model_parallel_size=1,
+            pipeline_model_parallel_size=1,
+            virtual_pipeline_model_parallel_size=None,
+            context_parallel_size=1,
+        )
+        if torch.cuda.is_available():
+            torch.cuda.set_device(0)
+            model_parallel_cuda_manual_seed(123)
+        else:
+            torch.manual_seed(123)
+
+    @staticmethod
+    def _find_free_port() -> str:
+        """Reserve and return an ephemeral localhost TCP port."""
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+            sock.bind(("127.0.0.1", 0))
+            return str(sock.getsockname()[1])
+
+    @staticmethod
+    def _run_megatron_smoke_subprocess(qwen3_omni_smoke_model_path: str) -> None:
+        """Run the Megatron smoke path in a subprocess to isolate NCCL state from pytest."""
+        repo_root = Path(__file__).resolve().parents[4]
+        script = """
+import datetime
+import os
+import torch
+import torch.distributed as dist
+from megatron.core import parallel_state
+from megatron.core.tensor_parallel.random import model_parallel_cuda_manual_seed
+
+from megatron.bridge.models.conversion.auto_bridge import AutoBridge
+from tests.functional_tests.models.qwen_omni.test_qwen3_omni_smoke import TestQwen3OmniSmoke
+from tests.functional_tests.models.qwen_omni.utils import (
+    SMOKE_LOCK_DIR,
+    build_real_sample_inputs,
+    move_inputs_to_device,
+)
+
+model_path = os.environ["QWEN3_OMNI_SMOKE_MODEL_PATH"]
+master_port = os.environ["QWEN3_OMNI_MASTER_PORT"]
+
+TestQwen3OmniSmoke._init_dist(master_port)
+TestQwen3OmniSmoke._init_model_parallel()
+
+try:
+    inputs = build_real_sample_inputs(model_path)
+    SMOKE_LOCK_DIR.mkdir(parents=True, exist_ok=True)
+    os.environ["MEGATRON_CONFIG_LOCK_DIR"] = str(SMOKE_LOCK_DIR)
+    bridge = AutoBridge.from_hf_pretrained(model_path, dtype=torch.bfloat16)
+    provider = bridge.to_megatron_provider(load_weights=True)
+    provider.tensor_model_parallel_size = 1
+    provider.pipeline_model_parallel_size = 1
+    provider.pipeline_dtype = torch.bfloat16
+    provider.params_dtype = torch.bfloat16
+    provider.finalize()
+    model = provider.provide_distributed_model(wrap_with_ddp=False)
+    if isinstance(model, list):
+        model = model[0]
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = model.to(device)
+    prepared = move_inputs_to_device(
+        inputs,
+        device,
+        dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
+    )
+    prepared["labels"] = prepared["input_ids"].clone()
+
+    with torch.no_grad():
+        outputs = model(**prepared)
+
+    assert outputs is not None
+finally:
+    os.environ.pop("MEGATRON_CONFIG_LOCK_DIR", None)
+    if parallel_state.model_parallel_is_initialized():
+        parallel_state.destroy_model_parallel()
+    if dist.is_initialized():
+        dist.destroy_process_group()
+"""
+        env = os.environ.copy()
+        env["PYTHONPATH"] = "src"
+        env["QWEN3_OMNI_SMOKE_MODEL_PATH"] = qwen3_omni_smoke_model_path
+        env["QWEN3_OMNI_MASTER_PORT"] = TestQwen3OmniSmoke._find_free_port()
+        try:
+            result = subprocess.run(
+                [sys.executable, "-c", script],
+                capture_output=True,
+                text=True,
+                cwd=repo_root,
+                env=env,
+                timeout=1800,
+            )
+        except subprocess.TimeoutExpired as exc:
+            pytest.fail(f"Qwen3-Omni Megatron smoke subprocess timed out after {exc.timeout} seconds")
+        if result.returncode != 0:
+            print(f"STDOUT: {result.stdout}")
+            print(f"STDERR: {result.stderr}")
+            pytest.fail(f"Qwen3-Omni Megatron smoke subprocess failed with return code {result.returncode}")
+
+    def test_hf_thinker_e2e_smoke(self, qwen3_omni_smoke_model_path):
+        """Validate HF thinker forward on one real image+audio local sample."""
+        inputs = build_real_sample_inputs(qwen3_omni_smoke_model_path)
+        model = Qwen3OmniMoeForConditionalGeneration.from_pretrained(
+            qwen3_omni_smoke_model_path,
+            dtype=torch.bfloat16,
+            low_cpu_mem_usage=False,
+        )
+        model.eval()
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        model = model.to(device)
+        prepared = move_inputs_to_device(inputs, device, dtype=model.dtype)
+
+        with torch.no_grad():
+            outputs = model.thinker(**prepared)
+
+        assert outputs.logits.shape[:2] == prepared["input_ids"].shape
+        assert outputs.logits.shape[-1] == model.config.thinker_config.text_config.vocab_size
+
+    def test_megatron_e2e_smoke(self, qwen3_omni_smoke_model_path):
+        """Validate Megatron thinker forward on the same real local multimodal sample."""
+        self._run_megatron_smoke_subprocess(qwen3_omni_smoke_model_path)
diff --git a/tests/functional_tests/models/qwen_omni/utils.py b/tests/functional_tests/models/qwen_omni/utils.py
new file mode 100644
index 0000000000..fd2b0af7eb
--- /dev/null
+++ b/tests/functional_tests/models/qwen_omni/utils.py
@@ -0,0 +1,190 @@
+# Copyright (c) 2026, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Shared helpers for Qwen3-Omni smoke-model generation and local E2E test inputs."""
+
+import io
+import json
+import os
+import re
+import shutil
+import time
+from collections import defaultdict
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import torch
+from PIL import Image
+from safetensors import safe_open
+from safetensors.torch import save_file
+from transformers import Qwen3OmniMoeProcessor
+
+
+_SOURCE_MODEL_PATH = os.environ.get("QWEN3_OMNI_SOURCE_MODEL_PATH")
+_SOURCE_DATA_PATH = os.environ.get("QWEN3_OMNI_SOURCE_DATA_PATH")
+_SMOKE_MODEL_CACHE_PATH = os.environ.get("QWEN3_OMNI_SMOKE_MODEL_CACHE_PATH", ".cache/qwen3_omni_smoke")
+_SMOKE_LOCK_DIR = os.environ.get("QWEN3_OMNI_SMOKE_LOCK_DIR", ".cache/qwen3_omni_locks")
+
+SOURCE_MODEL_PATH = Path(_SOURCE_MODEL_PATH) if _SOURCE_MODEL_PATH else None
+SOURCE_DATA_PATH = Path(_SOURCE_DATA_PATH) if _SOURCE_DATA_PATH else None
+SMOKE_MODEL_CACHE_PATH = Path(_SMOKE_MODEL_CACHE_PATH)
+SMOKE_LOCK_DIR = Path(_SMOKE_LOCK_DIR)
+
+SMOKE_TEXT_LAYERS = 2
+SMOKE_VISION_DEPTH = 2
+SMOKE_AUDIO_LAYERS = 2
+SMOKE_DEEPSTACK_INDEXES = [0]
+
+_ARTIFACTS_TO_COPY = [
+    "chat_template.json",
+    "configuration.json",
+    "generation_config.json",
+    "merges.txt",
+    "preprocessor_config.json",
+    "tokenizer_config.json",
+    "vocab.json",
+]
+
+_LAYER_PATTERNS = [
+    (re.compile(r"^thinker\.model\.layers\.(\d+)\."), SMOKE_TEXT_LAYERS),
+    (re.compile(r"^thinker\.visual\.blocks\.(\d+)\."), SMOKE_VISION_DEPTH),
+    (re.compile(r"^thinker\.audio_tower\.layers\.(\d+)\."), SMOKE_AUDIO_LAYERS),
+]
+_MERGER_PATTERN = re.compile(r"^thinker\.visual\.merger_list\.(\d+)\.")
+
+
+def smoke_assets_available() -> bool:
+    """Return whether the local source checkpoint and OmniBench parquet are available."""
+    return (
+        SOURCE_MODEL_PATH is not None
+        and SOURCE_MODEL_PATH.exists()
+        and SOURCE_DATA_PATH is not None
+        and SOURCE_DATA_PATH.exists()
+    )
+
+
+def create_qwen3_omni_smoke_model(output_dir: Path) -> Path:
+    """Create or reuse a single-GPU Qwen3-Omni smoke checkpoint in `output_dir`.
+
+    The smoke model keeps the original hidden dimensions so the HF config stays compatible,
+    while trimming only thinker layer counts to fit a single 48 GB GPU.
+    """
+    if (output_dir / "config.json").exists() and (output_dir / "model.safetensors").exists():
+        return output_dir
+
+    SMOKE_LOCK_DIR.mkdir(parents=True, exist_ok=True)
+    lock_dir = SMOKE_LOCK_DIR / f"{output_dir.name}.lock"
+    while True:
+        try:
+            lock_dir.mkdir()
+            break
+        except FileExistsError:
+            if (output_dir / "config.json").exists() and (output_dir / "model.safetensors").exists():
+                return output_dir
+            time.sleep(1)
+
+    try:
+        if (output_dir / "config.json").exists() and (output_dir / "model.safetensors").exists():
+            return output_dir
+
+        if output_dir.exists():
+            shutil.rmtree(output_dir)
+        output_dir.mkdir(parents=True)
+
+        config = json.loads((SOURCE_MODEL_PATH / "config.json").read_text())
+        config["enable_audio_output"] = False
+        config["thinker_config"]["text_config"]["num_hidden_layers"] = SMOKE_TEXT_LAYERS
+        config["thinker_config"]["vision_config"]["depth"] = SMOKE_VISION_DEPTH
+        config["thinker_config"]["vision_config"]["deepstack_visual_indexes"] = SMOKE_DEEPSTACK_INDEXES
+        config["thinker_config"]["audio_config"]["encoder_layers"] = SMOKE_AUDIO_LAYERS
+        config["thinker_config"]["audio_config"]["num_hidden_layers"] = SMOKE_AUDIO_LAYERS
+        (output_dir / "config.json").write_text(json.dumps(config, indent=2))
+
+        for artifact in _ARTIFACTS_TO_COPY:
+            source = SOURCE_MODEL_PATH / artifact
+            if source.exists():
+                shutil.copy2(source, output_dir / artifact)
+
+        index = json.loads((SOURCE_MODEL_PATH / "model.safetensors.index.json").read_text())
+        selected_keys = [key for key in index["weight_map"] if _keep_smoke_weight(key)]
+        by_file: dict[str, list[str]] = defaultdict(list)
+        for key in selected_keys:
+            by_file[index["weight_map"][key]].append(key)
+
+        state_dict = {}
+        for filename, keys in sorted(by_file.items()):
+            with safe_open(SOURCE_MODEL_PATH / filename, framework="pt", device="cpu") as handle:
+                for key in keys:
+                    state_dict[key] = handle.get_tensor(key)
+
+        temp_weights = output_dir / "model.safetensors.tmp"
+        save_file(state_dict, str(temp_weights))
+        temp_weights.replace(output_dir / "model.safetensors")
+        return output_dir
+    finally:
+        shutil.rmtree(lock_dir, ignore_errors=True)
+
+
+def build_real_sample_inputs(model_path: str | Path) -> dict[str, torch.Tensor]:
+    """Build one real image+audio sample from local OmniBench data with the model processor."""
+    row = pd.read_parquet(SOURCE_DATA_PATH).iloc[0]
+    image = Image.open(io.BytesIO(row["images"][0]["bytes"])).convert("RGB")
+    audio = np.asarray(row["audios"][0], dtype=np.float32)
+    processor = Qwen3OmniMoeProcessor.from_pretrained(model_path)
+    conversation = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image"},
+                {"type": "audio"},
+                {"type": "text", "text": "What is likely to happen next?"},
+            ],
+        }
+    ]
+    text = processor.apply_chat_template(conversation, add_generation_prompt=False, tokenize=False)
+    return processor(text=text, images=[image], audio=[audio], return_tensors="pt")
+
+
+def move_inputs_to_device(
+    batch: dict[str, torch.Tensor],
+    device: torch.device | str,
+    dtype: torch.dtype | None = None,
+) -> dict[str, torch.Tensor]:
+    """Move a processor batch to `device` and cast multimodal float tensors when needed."""
+    moved = {}
+    for key, value in batch.items():
+        if hasattr(value, "to"):
+            value = value.to(device)
+            if dtype is not None and key in {"pixel_values", "pixel_values_videos", "input_features"}:
+                value = value.to(dtype=dtype)
+        moved[key] = value
+    return moved
+
+
+def _keep_smoke_weight(key: str) -> bool:
+    """Return whether a checkpoint tensor should be kept in the reduced smoke checkpoint."""
+    if not key.startswith("thinker."):
+        return False
+
+    merger_match = _MERGER_PATTERN.match(key)
+    if merger_match is not None:
+        return int(merger_match.group(1)) < len(SMOKE_DEEPSTACK_INDEXES)
+
+    for pattern, limit in _LAYER_PATTERNS:
+        match = pattern.match(key)
+        if match is not None:
+            return int(match.group(1)) < limit
+
+    return True
diff --git a/tests/unit_tests/examples/test_convert_omni_bench_to_jsonl.py b/tests/unit_tests/examples/test_convert_omni_bench_to_jsonl.py
new file mode 100644
index 0000000000..1843e8bf06
--- /dev/null
+++ b/tests/unit_tests/examples/test_convert_omni_bench_to_jsonl.py
@@ -0,0 +1,92 @@
+# Copyright (c) 2026, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Unit tests for Qwen3-Omni Omni Bench parquet conversion."""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+from io import BytesIO
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from PIL import Image
+
+
+def _load_module():
+    script_path = (
+        Path(__file__).resolve().parents[3]
+        / "examples"
+        / "models"
+        / "vlm"
+        / "qwen3_omni"
+        / "convert_omni_bench_to_jsonl.py"
+    )
+    spec = importlib.util.spec_from_file_location("convert_omni_bench_to_jsonl", script_path)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def test_convert_dataframe_writes_jsonl_and_media(tmp_path):
+    module = _load_module()
+
+    image = Image.new("RGB", (8, 8), color="red")
+    buffer = BytesIO()
+    image.save(buffer, format="PNG")
+    image_bytes = buffer.getvalue()
+
+    df = pd.DataFrame(
+        [
+            {
+                "data_source": "unit-test",
+                "prompt": np.array([{"role": "user", "content": "<image> <audio> What happens next?"}], dtype=object),
+                "images": np.array([{"bytes": image_bytes, "path": None}], dtype=object),
+                "audios": np.array([np.linspace(-0.5, 0.5, 1600, dtype=np.float32)], dtype=object),
+                "ability": "multimodal",
+                "reward_model": {"ground_truth": "A person speaks.", "style": "rule"},
+                "extra_info": {
+                    "answer": "A person speaks.",
+                    "index": 7,
+                    "question": "<image> <audio> What happens next?",
+                },
+            }
+        ]
+    )
+
+    jsonl_path, num_written = module.convert_dataframe(df, "train", tmp_path, audio_sample_rate=16000)
+
+    assert num_written == 1
+    assert jsonl_path.exists()
+
+    lines = jsonl_path.read_text(encoding="utf-8").splitlines()
+    assert len(lines) == 1
+    payload = json.loads(lines[0])
+    assert payload["conversation"][0]["role"] == "user"
+    assert payload["conversation"][1]["content"][0]["text"] == "A person speaks."
+
+    user_content = payload["conversation"][0]["content"]
+    assert user_content[0]["type"] == "image"
+    assert user_content[1]["type"] == "audio"
+    assert user_content[2]["type"] == "text"
+    assert Path(user_content[0]["image"]).exists()
+    assert Path(user_content[1]["audio"]).exists()
+
+
+def test_strip_placeholders_normalizes_spaces():
+    module = _load_module()
+    assert module.strip_placeholders("<image>  <audio> Hello   world") == "Hello world"
diff --git a/tests/unit_tests/models/qwen_omni/conftest.py b/tests/unit_tests/models/qwen_omni/conftest.py
new file mode 100644
index 0000000000..161a8004bf
--- /dev/null
+++ b/tests/unit_tests/models/qwen_omni/conftest.py
@@ -0,0 +1,39 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def clear_lru_cache():
+    """Preserve cache clearing when available, otherwise degrade to a no-op.
+
+    The repository-wide fixture imports training config modules that are
+    currently incompatible with the local Megatron-Core version in this
+    environment. When those imports work, keep the original cache-clearing
+    behavior for isolation.
+    """
+    try:
+        from megatron.bridge.training.utils.checkpoint_utils import read_run_config, read_train_state
+    except (ImportError, ModuleNotFoundError):
+        yield
+        return
+
+    read_run_config.cache_clear()
+    read_train_state.cache_clear()
+
+    yield
+
+    read_run_config.cache_clear()
+    read_train_state.cache_clear()
diff --git a/tests/unit_tests/models/qwen_omni/modeling_qwen3_omni/__init__.py b/tests/unit_tests/models/qwen_omni/modeling_qwen3_omni/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/unit_tests/models/qwen_omni/modeling_qwen3_omni/test_omni_model.py b/tests/unit_tests/models/qwen_omni/modeling_qwen3_omni/test_omni_model.py
new file mode 100644
index 0000000000..f00ba1a857
--- /dev/null
+++ b/tests/unit_tests/models/qwen_omni/modeling_qwen3_omni/test_omni_model.py
@@ -0,0 +1,515 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import copy
+import datetime
+import os
+import socket
+from types import SimpleNamespace
+
+import pytest
+import torch
+import torch.distributed as dist
+import torch.nn.functional as F
+from megatron.core import parallel_state
+from megatron.core.models.gpt.gpt_layer_specs import (
+    get_gpt_layer_local_spec,
+    get_gpt_layer_with_transformer_engine_spec,
+)
+from megatron.core.process_groups_config import ProcessGroupCollection
+from megatron.core.tensor_parallel.random import model_parallel_cuda_manual_seed
+from transformers.models.qwen3_omni_moe.configuration_qwen3_omni_moe import (
+    Qwen3OmniMoeThinkerConfig,
+)
+
+from megatron.bridge.models.qwen_omni.modeling_qwen3_omni.model import Qwen3OmniModel
+from megatron.bridge.models.qwen_omni.modeling_qwen3_omni.rope import get_rope_index
+from megatron.bridge.models.qwen_omni.modeling_qwen3_omni.thinker_model import _trim_feature_sequence
+from megatron.bridge.models.qwen_omni.modeling_qwen3_omni.transformer_config import (
+    Qwen3OmniTransformerConfig,
+)
+
+
+HIDDEN_SIZE = 128
+IMAGE_TOKEN_ID = 900
+VIDEO_TOKEN_ID = 901
+AUDIO_TOKEN_ID = 902
+VISION_START_TOKEN_ID = 903
+AUDIO_START_TOKEN_ID = 904
+
+
+def _make_toy_thinker_config():
+    return Qwen3OmniMoeThinkerConfig(
+        vision_config={
+            "depth": 2,
+            "hidden_size": 32,
+            "intermediate_size": 64,
+            "num_heads": 4,
+            "patch_size": 2,
+            "spatial_merge_size": 1,
+            "temporal_patch_size": 1,
+            "out_hidden_size": HIDDEN_SIZE,
+            "num_position_embeddings": 16,
+            "deepstack_visual_indexes": [0],
+        },
+        audio_config={
+            "num_mel_bins": 8,
+            "d_model": 32,
+            "encoder_attention_heads": 4,
+            "encoder_ffn_dim": 64,
+            "encoder_layers": 2,
+            "output_dim": HIDDEN_SIZE,
+            "downsample_hidden_size": 16,
+        },
+        text_config={
+            "num_hidden_layers": 2,
+            "hidden_size": HIDDEN_SIZE,
+            "intermediate_size": 256,
+            "moe_intermediate_size": 64,
+            "num_attention_heads": 4,
+            "num_key_value_heads": 2,
+            "num_experts": 8,
+            "num_experts_per_tok": 2,
+            "vocab_size": 1000,
+            "max_position_embeddings": 128,
+            "rms_norm_eps": 1e-6,
+            "attention_bias": False,
+            "rope_theta": 1000000.0,
+            "rope_scaling": {"rope_type": "default", "mrope_section": [4, 6, 6]},
+        },
+        image_token_id=IMAGE_TOKEN_ID,
+        video_token_id=VIDEO_TOKEN_ID,
+        audio_token_id=AUDIO_TOKEN_ID,
+        vision_start_token_id=VISION_START_TOKEN_ID,
+        audio_start_token_id=AUDIO_START_TOKEN_ID,
+    )
+
+
+@pytest.fixture(scope="module")
+def thinker_config():
+    return _make_toy_thinker_config()
+
+
+class TestQwen3OmniModel:
+    _original_env: dict[str, str | None] = {}
+
+    @classmethod
+    def setup_class(cls):
+        if not dist.is_initialized():
+            cls._original_env = {
+                key: os.environ.get(key) for key in ("MASTER_ADDR", "MASTER_PORT", "RANK", "LOCAL_RANK", "WORLD_SIZE")
+            }
+
+            os.environ["MASTER_ADDR"] = "127.0.0.1"
+            os.environ["MASTER_PORT"] = cls._find_free_port()
+            os.environ["RANK"] = "0"
+            os.environ["LOCAL_RANK"] = "0"
+            os.environ["WORLD_SIZE"] = "1"
+
+            device_count = torch.cuda.device_count()
+            if device_count > 0:
+                torch.cuda.set_device(0)
+
+            dist.init_process_group(
+                backend="nccl" if device_count > 0 else "gloo",
+                world_size=1,
+                rank=0,
+                timeout=datetime.timedelta(minutes=30),
+            )
+
+    @classmethod
+    def teardown_class(cls):
+        if dist.is_initialized():
+            dist.destroy_process_group()
+        for key, value in cls._original_env.items():
+            if value is None:
+                os.environ.pop(key, None)
+            else:
+                os.environ[key] = value
+
+    @staticmethod
+    def _find_free_port() -> str:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+            sock.bind(("127.0.0.1", 0))
+            return str(sock.getsockname()[1])
+
+    def _setup_parallel_state(self, tp_size=1, pp_size=1):
+        if parallel_state.model_parallel_is_initialized():
+            parallel_state.destroy_model_parallel()
+
+        parallel_state.initialize_model_parallel(
+            tensor_model_parallel_size=tp_size,
+            pipeline_model_parallel_size=pp_size,
+            virtual_pipeline_model_parallel_size=None,
+            context_parallel_size=1,
+        )
+        if torch.cuda.is_available():
+            model_parallel_cuda_manual_seed(123)
+        else:
+            torch.manual_seed(123)
+
+    def teardown_method(self):
+        parallel_state.destroy_model_parallel()
+
+    @staticmethod
+    def _make_language_config():
+        return Qwen3OmniTransformerConfig(
+            num_layers=2,
+            hidden_size=HIDDEN_SIZE,
+            num_attention_heads=4,
+            num_query_groups=2,
+            kv_channels=HIDDEN_SIZE // 4,
+            ffn_hidden_size=256,
+            moe_ffn_hidden_size=64,
+            num_moe_experts=8,
+            moe_router_topk=2,
+            vocab_size=1000,
+            language_max_sequence_length=128,
+            normalization="RMSNorm",
+            activation_func=F.silu,
+            gated_linear_unit=True,
+            add_bias_linear=False,
+            add_qkv_bias=False,
+            qk_layernorm=True,
+            layernorm_epsilon=1e-6,
+            bf16=False,
+            use_cpu_initialization=True,
+            hidden_dropout=0.0,
+            attention_dropout=0.0,
+            mrope_section=[4, 6, 6],
+            image_token_id=IMAGE_TOKEN_ID,
+            video_token_id=VIDEO_TOKEN_ID,
+            audio_token_id=AUDIO_TOKEN_ID,
+            vision_start_token_id=VISION_START_TOKEN_ID,
+            audio_start_token_id=AUDIO_START_TOKEN_ID,
+            position_id_per_seconds=25,
+            seconds_per_chunk=2,
+        )
+
+    @staticmethod
+    def _make_layer_spec():
+        if not torch.cuda.is_available():
+            return get_gpt_layer_local_spec(
+                num_experts=8,
+                moe_grouped_gemm=True,
+                qk_layernorm=True,
+                normalization="RMSNorm",
+            )
+        return get_gpt_layer_with_transformer_engine_spec(
+            num_experts=8,
+            moe_grouped_gemm=True,
+            qk_layernorm=True,
+            fp8=False,
+        )
+
+    def _build_model(self, thinker_config):
+        self._setup_parallel_state(tp_size=1, pp_size=1)
+        pg_collection = ProcessGroupCollection.use_mpu_process_groups()
+        return Qwen3OmniModel(
+            language_transformer_config=self._make_language_config(),
+            language_transformer_layer_spec=self._make_layer_spec(),
+            thinker_transformer_config=thinker_config,
+            parallel_output=True,
+            pre_process=True,
+            post_process=True,
+            pg_collection=pg_collection,
+        )
+
+    def test_multimodal_runtime_switches_are_applied(self, thinker_config, monkeypatch):
+        self._setup_parallel_state(tp_size=1, pp_size=1)
+        thinker_config = copy.deepcopy(thinker_config)
+
+        calls = {"vision_gc": 0, "audio_gc": 0, "vision_inputs_grad": 0, "audio_inputs_grad": 0}
+
+        class _FakeTower(torch.nn.Module):
+            def __init__(self, gc_key: str, input_key: str, embed_attr: str):
+                super().__init__()
+                self.config = SimpleNamespace()
+                self._gc_key = gc_key
+                self._input_key = input_key
+                setattr(self, embed_attr, torch.nn.Linear(4, 4, bias=False))
+
+            def gradient_checkpointing_enable(self):
+                calls[self._gc_key] += 1
+
+            def enable_input_require_grads(self):
+                calls[self._input_key] += 1
+
+        monkeypatch.setattr(
+            "megatron.bridge.models.qwen_omni.modeling_qwen3_omni.thinker_model.Qwen3OmniMoeVisionEncoderHF._from_config",
+            lambda _cfg: _FakeTower("vision_gc", "vision_inputs_grad", "patch_embed"),
+        )
+        monkeypatch.setattr(
+            "megatron.bridge.models.qwen_omni.modeling_qwen3_omni.thinker_model.Qwen3OmniMoeAudioEncoderHF._from_config",
+            lambda _cfg: _FakeTower("audio_gc", "audio_inputs_grad", "conv_out"),
+        )
+
+        cfg = self._make_language_config()
+        cfg.vit_gradient_checkpointing = True
+        cfg.multimodal_attn_impl = "flash_attention_2"
+
+        model = Qwen3OmniModel(
+            language_transformer_config=cfg,
+            language_transformer_layer_spec=self._make_layer_spec(),
+            thinker_transformer_config=thinker_config,
+            parallel_output=True,
+            pre_process=True,
+            post_process=True,
+            pg_collection=ProcessGroupCollection.use_mpu_process_groups(),
+        )
+
+        assert calls["vision_gc"] == 1
+        assert calls["audio_gc"] == 1
+        assert calls["vision_inputs_grad"] == 1
+        assert calls["audio_inputs_grad"] == 1
+        assert getattr(model.thinker.visual.config, "_attn_implementation") == "flash_attention_2"
+        assert getattr(model.thinker.audio_model.config, "_attn_implementation") == "flash_attention_2"
+        assert getattr(model.thinker.visual.config, "use_flash_attn") is True
+        assert getattr(model.thinker.audio_model.config, "use_flash_attn") is True
+        assert model.thinker.visual.get_input_embeddings() is model.thinker.visual.patch_embed
+        assert model.thinker.audio_model.get_input_embeddings() is model.thinker.audio_model.conv_out
+
+    def test_model_freeze_api(self, thinker_config):
+        model = self._build_model(thinker_config)
+        model.freeze(freeze_language_model=True)
+
+        for name, param in model.named_parameters():
+            if name.startswith("thinker.language_model"):
+                assert param.requires_grad is False
+
+    def test_set_input_tensor(self, thinker_config):
+        model = self._build_model(thinker_config)
+        test_tensor = torch.randn(2, 4, HIDDEN_SIZE)
+        model.set_input_tensor([test_tensor])
+        assert model.thinker.encoder_hidden_state is not None
+
+    def test_text_only_forward(self, thinker_config):
+        model = self._build_model(thinker_config)
+        if torch.cuda.is_available():
+            model = model.to("cuda")
+            device = "cuda"
+        else:
+            device = "cpu"
+
+        input_ids = torch.randint(0, 1000, (1, 16), device=device)
+        labels = torch.randint(0, 1000, (1, 16), device=device)
+        output = model(
+            input_ids=input_ids,
+            labels=labels,
+            attention_mask=None,
+        )
+        assert output is not None
+
+    def test_image_forward(self, thinker_config):
+        model = self._build_model(thinker_config)
+        if torch.cuda.is_available():
+            model = model.to("cuda")
+            device = "cuda"
+        else:
+            device = "cpu"
+
+        input_ids = torch.tensor(
+            [[VISION_START_TOKEN_ID, IMAGE_TOKEN_ID, IMAGE_TOKEN_ID, IMAGE_TOKEN_ID, IMAGE_TOKEN_ID, 12, 13, 14]],
+            device=device,
+        )
+        labels = torch.randint(0, 1000, input_ids.shape, device=device)
+        pixel_values = torch.randn(4, 3 * 1 * 2 * 2, device=device)
+        image_grid_thw = torch.tensor([[1, 2, 2]], device=device)
+
+        output = model(
+            input_ids=input_ids,
+            labels=labels,
+            pixel_values=pixel_values,
+            image_grid_thw=image_grid_thw,
+        )
+        assert output is not None
+
+    def test_image_forward_sequence_parallel_path(self, thinker_config, monkeypatch):
+        model = self._build_model(thinker_config)
+        model.thinker.config.sequence_parallel = True
+
+        calls = {"scatter": 0, "split": 0}
+
+        def _identity_scatter(x):
+            calls["scatter"] += 1
+            return x
+
+        def _identity_split(visual_pos_masks, deepstack_visual_embeds, **kwargs):
+            calls["split"] += 1
+            return visual_pos_masks, deepstack_visual_embeds
+
+        monkeypatch.setattr(
+            "megatron.bridge.models.qwen_omni.modeling_qwen3_omni.thinker_model.tensor_parallel.scatter_to_sequence_parallel_region",
+            _identity_scatter,
+        )
+        monkeypatch.setattr(
+            "megatron.bridge.models.qwen_omni.modeling_qwen3_omni.thinker_model.split_deepstack_embs",
+            _identity_split,
+        )
+
+        if torch.cuda.is_available():
+            model = model.to("cuda")
+            device = "cuda"
+        else:
+            device = "cpu"
+
+        input_ids = torch.tensor(
+            [[VISION_START_TOKEN_ID, IMAGE_TOKEN_ID, IMAGE_TOKEN_ID, IMAGE_TOKEN_ID, IMAGE_TOKEN_ID, 12, 13, 14]],
+            device=device,
+        )
+        labels = torch.randint(0, 1000, input_ids.shape, device=device)
+        pixel_values = torch.randn(4, 3 * 1 * 2 * 2, device=device)
+        image_grid_thw = torch.tensor([[1, 2, 2]], device=device)
+
+        output = model(
+            input_ids=input_ids,
+            labels=labels,
+            pixel_values=pixel_values,
+            image_grid_thw=image_grid_thw,
+        )
+
+        assert output is not None
+        assert calls["scatter"] == 1
+        assert calls["split"] == 1
+
+    def test_audio_forward(self, thinker_config):
+        model = self._build_model(thinker_config)
+        if torch.cuda.is_available():
+            model = model.to("cuda")
+            device = "cuda"
+        else:
+            device = "cpu"
+
+        input_ids = torch.tensor(
+            [[AUDIO_START_TOKEN_ID, AUDIO_TOKEN_ID, AUDIO_TOKEN_ID, 21, 22, 23]],
+            device=device,
+        )
+        labels = torch.randint(0, 1000, input_ids.shape, device=device)
+        input_features = torch.randn(1, 8, 10, device=device)
+        feature_attention_mask = torch.ones(1, 10, dtype=torch.long, device=device)
+
+        output = model(
+            input_ids=input_ids,
+            labels=labels,
+            input_features=input_features,
+            feature_attention_mask=feature_attention_mask,
+        )
+        assert output is not None
+
+    def test_audio_only_rope_index(self):
+        input_ids = torch.tensor([[AUDIO_START_TOKEN_ID, AUDIO_TOKEN_ID, AUDIO_TOKEN_ID, 17, 18]])
+        audio_seqlens = torch.tensor([16])
+
+        position_ids, mrope_position_deltas = get_rope_index(
+            spatial_merge_size=1,
+            image_token_id=IMAGE_TOKEN_ID,
+            video_token_id=VIDEO_TOKEN_ID,
+            audio_token_id=AUDIO_TOKEN_ID,
+            vision_start_token_id=VISION_START_TOKEN_ID,
+            audio_start_token_id=AUDIO_START_TOKEN_ID,
+            position_id_per_seconds=25,
+            input_ids=input_ids,
+            audio_seqlens=audio_seqlens,
+        )
+
+        assert position_ids.shape == (3, 1, input_ids.shape[1])
+        assert mrope_position_deltas.shape == (1, 1)
+
+    def test_video_rope_index_requires_second_per_grid(self):
+        input_ids = torch.tensor([[VISION_START_TOKEN_ID, VIDEO_TOKEN_ID, VIDEO_TOKEN_ID, 17, 18]])
+        video_grid_thw = torch.tensor([[1, 1, 2]])
+        video_second_per_grid = torch.tensor([2.0])
+
+        position_ids, mrope_position_deltas = get_rope_index(
+            spatial_merge_size=1,
+            image_token_id=IMAGE_TOKEN_ID,
+            video_token_id=VIDEO_TOKEN_ID,
+            audio_token_id=AUDIO_TOKEN_ID,
+            vision_start_token_id=VISION_START_TOKEN_ID,
+            audio_start_token_id=AUDIO_START_TOKEN_ID,
+            position_id_per_seconds=25,
+            input_ids=input_ids,
+            video_grid_thw=video_grid_thw,
+            second_per_grids=video_second_per_grid,
+        )
+
+        assert position_ids.shape == (3, 1, input_ids.shape[1])
+        assert mrope_position_deltas.shape == (1, 1)
+
+    def test_audio_rope_index_accepts_multidim_attention_mask(self):
+        input_ids = torch.tensor([[AUDIO_START_TOKEN_ID, AUDIO_TOKEN_ID, AUDIO_TOKEN_ID, 17, 18]])
+        audio_seqlens = torch.tensor([16])
+        attention_mask = torch.zeros(1, 1, input_ids.shape[1], input_ids.shape[1], dtype=torch.long)
+        attention_mask[:, :, :, : input_ids.shape[1]] = 1
+
+        position_ids, mrope_position_deltas = get_rope_index(
+            spatial_merge_size=1,
+            image_token_id=IMAGE_TOKEN_ID,
+            video_token_id=VIDEO_TOKEN_ID,
+            audio_token_id=AUDIO_TOKEN_ID,
+            vision_start_token_id=VISION_START_TOKEN_ID,
+            audio_start_token_id=AUDIO_START_TOKEN_ID,
+            position_id_per_seconds=25,
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            audio_seqlens=audio_seqlens,
+        )
+
+        assert position_ids.shape == (3, 1, input_ids.shape[1])
+        assert mrope_position_deltas.shape == (1, 1)
+
+    def test_audio_rope_index_truncates_positions_to_surviving_tokens(self):
+        seq_len = 8
+        input_ids = torch.tensor([[AUDIO_START_TOKEN_ID] + [AUDIO_TOKEN_ID] * (seq_len - 1)])
+        attention_mask = torch.ones(1, seq_len, dtype=torch.long)
+        audio_seqlens = torch.tensor([512])
+
+        position_ids, mrope_position_deltas = get_rope_index(
+            spatial_merge_size=1,
+            image_token_id=IMAGE_TOKEN_ID,
+            video_token_id=VIDEO_TOKEN_ID,
+            audio_token_id=AUDIO_TOKEN_ID,
+            vision_start_token_id=VISION_START_TOKEN_ID,
+            audio_start_token_id=AUDIO_START_TOKEN_ID,
+            position_id_per_seconds=25,
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            audio_seqlens=audio_seqlens,
+        )
+
+        assert position_ids.shape == (3, 1, seq_len)
+        assert mrope_position_deltas.shape == (1, 1)
+
+    def test_trim_feature_sequence_clips_to_surviving_placeholders(self):
+        features = torch.randn(12, HIDDEN_SIZE)
+        multiscale = [torch.randn(12, HIDDEN_SIZE), torch.randn(12, HIDDEN_SIZE)]
+
+        trimmed_features, trimmed_multiscale = _trim_feature_sequence(
+            features,
+            multiscale,
+            expected_tokens=5,
+            feature_name="Image features",
+        )
+
+        assert trimmed_features is not None
+        assert trimmed_multiscale is not None
+        assert trimmed_features.shape == (5, HIDDEN_SIZE)
+        assert all(feature.shape == (5, HIDDEN_SIZE) for feature in trimmed_multiscale)
+
+    def test_model_wrapper_exposes_pipeline_flags(self, thinker_config):
+        model = self._build_model(thinker_config)
+
+        assert model.pre_process is True
+        assert model.post_process is True
+        assert model.share_embeddings_and_output_weights == model.thinker.share_embeddings_and_output_weights
diff --git a/tests/unit_tests/models/qwen_omni/test_qwen3_omni_bridge.py b/tests/unit_tests/models/qwen_omni/test_qwen3_omni_bridge.py
new file mode 100644
index 0000000000..fa490014e2
--- /dev/null
+++ b/tests/unit_tests/models/qwen_omni/test_qwen3_omni_bridge.py
@@ -0,0 +1,156 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from unittest.mock import Mock, patch
+
+import pytest
+import torch
+import torch.nn.functional as F
+
+from megatron.bridge.models.conversion.mapping_registry import MegatronMappingRegistry
+from megatron.bridge.models.hf_pretrained.vlm import PreTrainedVLM
+from megatron.bridge.models.qwen_omni import Qwen3OmniBridge, Qwen3OmniModelProvider
+
+
+@pytest.fixture
+def mock_text_config():
+    text_config = Mock(spec=[])
+    text_config.num_hidden_layers = 48
+    text_config.hidden_size = 2048
+    text_config.intermediate_size = 6144
+    text_config.moe_intermediate_size = 768
+    text_config.num_attention_heads = 32
+    text_config.num_key_value_heads = 4
+    text_config.head_dim = 128
+    text_config.num_experts = 128
+    text_config.num_experts_per_tok = 8
+    text_config.initializer_range = 0.02
+    text_config.rms_norm_eps = 1e-6
+    text_config.vocab_size = 152064
+    text_config.max_position_embeddings = 32768
+    text_config.rope_theta = 1000000.0
+    text_config.attention_bias = False
+    text_config.rope_scaling = {"mrope_section": [24, 20, 20]}
+    return text_config
+
+
+@pytest.fixture
+def mock_thinker_config(mock_text_config):
+    thinker = Mock(spec=[])
+    thinker.text_config = mock_text_config
+    thinker.torch_dtype = torch.float32
+    thinker.image_token_id = 151655
+    thinker.video_token_id = 151656
+    thinker.audio_token_id = 151646
+    thinker.vision_start_token_id = 151652
+    thinker.vision_end_token_id = 151753
+    thinker.audio_end_token_id = 151748
+    vision_config = Mock(spec=[])
+    vision_config.patch_size = 32
+    vision_config.temporal_patch_size = 4
+    vision_config.spatial_merge_size = 3
+    thinker.vision_config = vision_config
+    return thinker
+
+
+@pytest.fixture
+def mock_hf_config(mock_thinker_config):
+    config = Mock()
+    config.thinker_config = mock_thinker_config
+    config.torch_dtype = torch.float32
+    config.enable_audio_output = False
+    config.talker_config = Mock()
+    config.code2wav_config = Mock()
+    config.tie_word_embeddings = True
+    config.bos_token_id = 151743
+    config.eos_token_id = 151745
+    return config
+
+
+@pytest.fixture
+def mock_hf_pretrained(mock_hf_config):
+    pretrained = Mock(spec=PreTrainedVLM)
+    pretrained.config = mock_hf_config
+    return pretrained
+
+
+class TestQwen3OmniBridge:
+    def test_provider_bridge_basic_config(self, mock_hf_pretrained):
+        bridge = Qwen3OmniBridge()
+        provider = bridge.provider_bridge(mock_hf_pretrained)
+
+        assert isinstance(provider, Qwen3OmniModelProvider)
+        assert provider.num_layers == 48
+        assert provider.hidden_size == 2048
+        assert provider.ffn_hidden_size == 6144
+        assert provider.moe_ffn_hidden_size == 768
+        assert provider.num_attention_heads == 32
+        assert provider.num_query_groups == 4
+        assert provider.kv_channels == 128
+        assert provider.activation_func is F.silu
+        assert provider.gated_linear_unit is True
+        assert provider.num_moe_experts == 128
+        assert provider.moe_router_topk == 8
+        assert provider.share_embeddings_and_output_weights is False
+        assert provider.mrope_section == [24, 20, 20]
+        assert provider.language_max_sequence_length == 32768
+        assert provider.patch_size == 32
+        assert provider.temporal_patch_size == 4
+        assert provider.spatial_merge_size == 3
+        assert provider.image_token_id == 151655
+        assert provider.video_token_id == 151656
+        assert provider.audio_token_id == 151646
+        assert provider.vision_start_token_id == 151652
+        assert provider.vision_end_token_id == 151753
+        assert provider.audio_start_token_id == 151647
+        assert provider.audio_end_token_id == 151748
+        assert provider.bos_token_id == 151743
+        assert provider.eos_token_id == 151745
+
+    @patch.object(Qwen3OmniBridge, "dtype_from_hf")
+    def test_provider_bridge_dtype(self, mock_dtype_from_hf, mock_hf_pretrained):
+        mock_dtype_from_hf.return_value = torch.bfloat16
+        bridge = Qwen3OmniBridge()
+        provider = bridge.provider_bridge(mock_hf_pretrained)
+
+        assert provider.bf16 is True
+        assert provider.fp16 is False
+        assert provider.params_dtype == torch.bfloat16
+
+    def test_mapping_registry(self):
+        bridge = Qwen3OmniBridge()
+        registry = bridge.mapping_registry()
+
+        assert isinstance(registry, MegatronMappingRegistry)
+        mapping_names = []
+        for mapping in registry.mappings:
+            if hasattr(mapping, "megatron_param"):
+                mapping_names.append(str(getattr(mapping, "megatron_param")))
+
+        assert any("thinker.language_model.embedding.word_embeddings.weight" in name for name in mapping_names)
+        assert any(
+            "thinker.language_model.decoder.layers.*.self_attention.linear_qkv.weight" in name
+            for name in mapping_names
+        )
+        assert any("thinker.language_model.decoder.layers.*.mlp.router.weight" in name for name in mapping_names)
+
+    def test_provider_bridge_warns_for_audio_output_stack(self, mock_hf_pretrained, caplog):
+        mock_hf_pretrained.config.enable_audio_output = True
+        caplog.set_level("WARNING")
+
+        bridge = Qwen3OmniBridge()
+        provider = bridge.provider_bridge(mock_hf_pretrained)
+
+        assert isinstance(provider, Qwen3OmniModelProvider)
+        assert "converting thinker-side weights only" in caplog.text
diff --git a/tests/unit_tests/models/qwen_omni/test_qwen3_omni_provider.py b/tests/unit_tests/models/qwen_omni/test_qwen3_omni_provider.py
new file mode 100644
index 0000000000..203256b3a0
--- /dev/null
+++ b/tests/unit_tests/models/qwen_omni/test_qwen3_omni_provider.py
@@ -0,0 +1,104 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from unittest.mock import patch
+
+import pytest
+from transformers.models.qwen3_omni_moe.configuration_qwen3_omni_moe import (
+    Qwen3OmniMoeThinkerConfig,
+)
+
+from megatron.bridge.models.qwen_omni import Qwen3OmniModelProvider
+
+
+pytestmark = pytest.mark.unit
+
+
+class TestQwen3OmniModelProvider:
+    def test_qwen3_omni_model_provider_initialization(self):
+        provider = Qwen3OmniModelProvider(
+            num_layers=48,
+            hidden_size=2048,
+            num_attention_heads=32,
+        )
+
+        assert provider.num_layers == 48
+        assert provider.hidden_size == 2048
+        assert provider.num_attention_heads == 32
+        assert provider.position_embedding_type == "mrope"
+        assert provider.scatter_embedding_sequence_parallel is False
+        assert provider.qk_layernorm is True
+        assert provider.image_token_id == 151655
+        assert provider.video_token_id == 151656
+        assert provider.audio_token_id == 151646
+        assert provider.vision_start_token_id == 151652
+
+    def test_qwen3_omni_custom_thinker_config(self):
+        thinker_config = Qwen3OmniMoeThinkerConfig(
+            text_config={
+                "num_hidden_layers": 2,
+                "hidden_size": 128,
+                "intermediate_size": 256,
+                "moe_intermediate_size": 64,
+                "num_attention_heads": 4,
+                "num_key_value_heads": 2,
+                "num_experts": 8,
+                "num_experts_per_tok": 2,
+                "vocab_size": 1000,
+                "max_position_embeddings": 128,
+                "rms_norm_eps": 1e-6,
+            }
+        )
+        provider = Qwen3OmniModelProvider(
+            num_layers=2,
+            hidden_size=128,
+            num_attention_heads=4,
+            thinker_config=thinker_config,
+        )
+
+        assert provider.thinker_config.text_config.hidden_size == 128
+
+    def test_qwen3_omni_freeze_flags(self):
+        provider = Qwen3OmniModelProvider(
+            num_layers=48,
+            hidden_size=2048,
+            num_attention_heads=32,
+            freeze_language_model=True,
+            freeze_vision_model=True,
+            freeze_audio_model=True,
+        )
+
+        assert provider.freeze_language_model is True
+        assert provider.freeze_vision_model is True
+        assert provider.freeze_audio_model is True
+
+    def test_provide_defaults_to_single_stage_pre_post_process(self):
+        provider = Qwen3OmniModelProvider(
+            num_layers=2,
+            hidden_size=128,
+            ffn_hidden_size=256,
+            num_attention_heads=4,
+            num_query_groups=2,
+            kv_channels=32,
+            vocab_size=1024,
+            use_cpu_initialization=True,
+            bf16=False,
+        )
+
+        with patch("megatron.bridge.models.qwen_omni.qwen3_omni_provider.Qwen3OmniModel") as mock_model_cls:
+            provider.provide()
+
+        _, kwargs = mock_model_cls.call_args
+        assert kwargs["pre_process"] is True
+        assert kwargs["post_process"] is True
diff --git a/tests/unit_tests/models/qwen_omni/test_qwen3_omni_step.py b/tests/unit_tests/models/qwen_omni/test_qwen3_omni_step.py
new file mode 100644
index 0000000000..a4cb9b44f3
--- /dev/null
+++ b/tests/unit_tests/models/qwen_omni/test_qwen3_omni_step.py
@@ -0,0 +1,329 @@
+# Copyright (c) 2026, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+
+from megatron.bridge.models.qwen_omni.qwen3_omni_step import (
+    _normalize_multimodal_inputs,
+    forward_step,
+    get_batch,
+    get_batch_from_iterator,
+)
+from megatron.bridge.training.utils.visual_inputs import Qwen2_5_VLVisualInputs
+
+
+class _Iterator:
+    def __init__(self, batch):
+        self.batch = batch
+        self._done = False
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self._done:
+            raise StopIteration
+        self._done = True
+        return self.batch
+
+
+def _as_nocuda(tensor: torch.Tensor) -> torch.Tensor:
+    class _NoCudaTensor(torch.Tensor):
+        def cuda(self, non_blocking=False):  # type: ignore[override]
+            return self
+
+    return tensor.as_subclass(_NoCudaTensor)
+
+
+def _make_batch():
+    tokens = torch.tensor([[1, 2, 3, 4]])
+    return {
+        "input_ids": tokens,
+        "position_ids": torch.arange(tokens.size(1)).unsqueeze(0),
+        "labels": torch.tensor([[2, 3, 4, -100]]),
+        "loss_mask": torch.ones(1, 4),
+        "attention_mask": torch.ones(1, 4, dtype=torch.bool),
+        "pixel_values": torch.randn(1, 2, 3, 4, 4),
+        "image_grid_thw": torch.tensor([[[1, 2, 2], [1, 2, 2]]]),
+        "pixel_values_videos": torch.randn(1, 1, 3, 4, 4),
+        "video_grid_thw": torch.tensor([[[1, 2, 2]]]),
+        "video_second_per_grid": torch.tensor([[0.5]]),
+        "input_features": torch.randn(1, 80, 6),
+        "feature_attention_mask": torch.tensor([[1, 1, 1, 1, 0, 0]], dtype=torch.long),
+        "audio_feature_lengths": torch.tensor([4], dtype=torch.long),
+    }
+
+
+def test_get_batch_from_iterator_moves_omni_tensors_to_cuda():
+    batch = _make_batch()
+    for key, value in list(batch.items()):
+        if isinstance(value, torch.Tensor):
+            batch[key] = _as_nocuda(value)
+
+    out = get_batch_from_iterator(
+        _Iterator(batch),
+        use_mtp=False,
+        skip_getting_attention_mask_from_dataset=False,
+        is_first_pp_stage=True,
+        is_last_pp_stage=True,
+    )
+
+    assert out["pixel_values"] is not None
+    assert out["input_features"] is not None
+    assert out["video_second_per_grid"] is not None
+
+
+def test_normalize_multimodal_inputs_flattens_expected_shapes():
+    normalized = _normalize_multimodal_inputs(_make_batch())
+
+    assert normalized["pixel_values"].shape == (2, 3, 4, 4)
+    assert normalized["image_grid_thw"].shape == (2, 3)
+    assert normalized["pixel_values_videos"].shape == (1, 3, 4, 4)
+    assert normalized["video_grid_thw"].shape == (1, 3)
+    assert normalized["video_second_per_grid"].shape == (1,)
+    assert normalized["input_features"].shape == (1, 80, 6)
+
+
+def test_normalize_multimodal_inputs_accepts_visual_inputs_container():
+    normalized = _normalize_multimodal_inputs(
+        {
+            "visual_inputs": Qwen2_5_VLVisualInputs(
+                pixel_values=torch.randn(1, 2, 3, 4, 4),
+                image_grid_thw=torch.tensor([[[1, 2, 2], [1, 2, 2]]]),
+            ),
+            "input_features": torch.randn(1, 80, 6),
+        }
+    )
+
+    assert normalized["pixel_values"].shape == (2, 3, 4, 4)
+    assert normalized["image_grid_thw"].shape == (2, 3)
+    assert normalized["input_features"].shape == (1, 80, 6)
+
+
+def test_forward_step_passes_omni_multimodal_args(monkeypatch):
+    class _MockProcessGroup:
+        def rank(self):
+            return 0
+
+        def size(self):
+            return 1
+
+    class _MockPGCollection:
+        def __init__(self):
+            self.pp = _MockProcessGroup()
+            self.cp = _MockProcessGroup()
+
+    class _Model:
+        def __init__(self):
+            self.config = type("Cfg", (), {"mtp_num_layers": 0, "overlap_moe_expert_parallel_comm": True})()
+            self.kwargs = None
+
+        def __call__(self, **kwargs):
+            self.kwargs = kwargs
+            return torch.tensor(0.0)
+
+        def build_schedule_plan(self, *args, **kwargs):  # noqa: ARG002
+            return torch.tensor(1)
+
+    class _Timer:
+        def __call__(self, *args, **kwargs):  # noqa: ARG002
+            return self
+
+        def start(self):
+            return self
+
+        def stop(self):
+            return self
+
+    class _Strag:
+        def __call__(self, *args, **kwargs):  # noqa: ARG002
+            return self
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *exc):  # noqa: ARG002
+            return False
+
+    state = type("State", (), {})()
+    state.cfg = type(
+        "Cfg",
+        (),
+        {
+            "dataset": type("D", (), {"skip_getting_attention_mask_from_dataset": False})(),
+            "model": type("M", (), {"pipeline_model_parallel_size": 1, "seq_length": 16})(),
+            "rerun_state_machine": type("R", (), {"check_for_nan_in_loss": False, "check_for_spiky_loss": False})(),
+        },
+    )()
+    state.timers = _Timer()
+    state.straggler_timer = _Strag()
+
+    monkeypatch.setattr(
+        "megatron.bridge.models.qwen_omni.qwen3_omni_step.get_pg_collection",
+        lambda model: _MockPGCollection(),
+    )
+    monkeypatch.setattr(
+        "megatron.bridge.models.qwen_omni.qwen3_omni_step.get_model_config",
+        lambda model: model.config,
+    )
+    monkeypatch.setattr(
+        "megatron.bridge.models.qwen_omni.qwen3_omni_step.is_pp_first_stage",
+        lambda pg: True,
+    )
+    monkeypatch.setattr(
+        "megatron.bridge.models.qwen_omni.qwen3_omni_step.is_pp_last_stage",
+        lambda pg: True,
+    )
+    monkeypatch.setattr(
+        "megatron.bridge.models.qwen_omni.qwen3_omni_step.get_batch",
+        lambda data_iterator, cfg, use_mtp, pg_collection: (
+            torch.tensor([[1, 2, 3, 4]]),
+            torch.tensor([[2, 3, 4, -100]]),
+            torch.ones(1, 4),
+            torch.ones(1, 4, dtype=torch.bool),
+            torch.arange(4).unsqueeze(0),
+            {
+                "pixel_values": torch.randn(2, 3, 4, 4),
+                "image_grid_thw": torch.tensor([[1, 2, 2], [1, 2, 2]]),
+                "input_features": torch.randn(1, 80, 6),
+                "feature_attention_mask": torch.tensor([[1, 1, 1, 1, 0, 0]]),
+                "audio_feature_lengths": torch.tensor([4]),
+            },
+        ),
+    )
+
+    model = _Model()
+    output, loss_fn = forward_step(state, iter([{}]), model)
+
+    assert isinstance(output, torch.Tensor)
+    assert callable(loss_fn)
+    assert model.kwargs is not None
+    assert model.kwargs["position_ids"] is None
+    assert "pixel_values" in model.kwargs
+    assert "input_features" in model.kwargs
+    assert "audio_feature_lengths" in model.kwargs
+
+
+def test_forward_step_rejects_context_parallel(monkeypatch):
+    class _MockProcessGroup:
+        def rank(self):
+            return 0
+
+        def size(self):
+            return 2
+
+    class _MockPGCollection:
+        def __init__(self):
+            self.pp = _MockProcessGroup()
+            self.cp = _MockProcessGroup()
+
+    class _Model:
+        def __init__(self):
+            self.config = type("Cfg", (), {"mtp_num_layers": 0, "overlap_moe_expert_parallel_comm": True})()
+
+        def __call__(self, **kwargs):  # noqa: ARG002
+            raise AssertionError("model forward should not run when CP is enabled")
+
+    class _Timer:
+        def __call__(self, *args, **kwargs):  # noqa: ARG002
+            return self
+
+        def start(self):
+            return self
+
+        def stop(self):
+            return self
+
+    class _Strag:
+        def __call__(self, *args, **kwargs):  # noqa: ARG002
+            return self
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *exc):  # noqa: ARG002
+            return False
+
+    state = type("State", (), {})()
+    state.cfg = type(
+        "Cfg",
+        (),
+        {
+            "dataset": type("D", (), {"skip_getting_attention_mask_from_dataset": False})(),
+            "model": type("M", (), {"pipeline_model_parallel_size": 1, "seq_length": 8})(),
+            "rerun_state_machine": type("R", (), {"check_for_nan_in_loss": False, "check_for_spiky_loss": False})(),
+        },
+    )()
+    state.timers = _Timer()
+    state.straggler_timer = _Strag()
+
+    tokens = torch.tensor([[1, 2, 3, 4, 5, 6, 7, 8]])
+    labels = torch.tensor([[2, 3, 4, 5, 6, 7, 8, -100]])
+    loss_mask = torch.ones(1, 8)
+
+    monkeypatch.setattr(
+        "megatron.bridge.models.qwen_omni.qwen3_omni_step.get_pg_collection",
+        lambda model: _MockPGCollection(),
+    )
+    monkeypatch.setattr(
+        "megatron.bridge.models.qwen_omni.qwen3_omni_step.get_model_config",
+        lambda model: model.config,
+    )
+    monkeypatch.setattr(
+        "megatron.bridge.models.qwen_omni.qwen3_omni_step.get_batch",
+        lambda data_iterator, cfg, use_mtp, pg_collection: (
+            tokens,
+            labels,
+            loss_mask,
+            torch.ones(1, 8, dtype=torch.bool),
+            torch.arange(8).unsqueeze(0),
+            {},
+        ),
+    )
+
+    model = _Model()
+    try:
+        forward_step(state, iter([{}]), model)
+    except NotImplementedError as exc:
+        assert "CP is not supported yet" in str(exc)
+    else:
+        raise AssertionError("expected NotImplementedError for Qwen3-Omni CP")
+
+
+def test_get_batch_pads_2d_attention_mask_for_pipeline_parallel():
+    batch = _make_batch()
+    for key, value in list(batch.items()):
+        if isinstance(value, torch.Tensor):
+            batch[key] = _as_nocuda(value)
+
+    cfg = type(
+        "Cfg",
+        (),
+        {
+            "dataset": type("D", (), {"skip_getting_attention_mask_from_dataset": False})(),
+            "model": type("M", (), {"pipeline_model_parallel_size": 2, "seq_length": 8})(),
+        },
+    )()
+    pg_collection = type("PG", (), {"pp": object()})()
+
+    tokens, labels, loss_mask, attention_mask, position_ids, multimodal_inputs = get_batch(
+        _Iterator(batch), cfg, pg_collection=pg_collection
+    )
+
+    assert tokens.shape == (1, 8)
+    assert labels.shape == (1, 8)
+    assert loss_mask.shape == (1, 8)
+    assert attention_mask.shape == (1, 8)
+    assert position_ids.shape == (1, 8)
+    assert multimodal_inputs["pixel_values"].shape == (2, 3, 4, 4)
diff --git a/tests/unit_tests/models/qwen_omni/test_qwen3_omni_training_smoke.py b/tests/unit_tests/models/qwen_omni/test_qwen3_omni_training_smoke.py
new file mode 100644
index 0000000000..48b7118ab9
--- /dev/null
+++ b/tests/unit_tests/models/qwen_omni/test_qwen3_omni_training_smoke.py
@@ -0,0 +1,269 @@
+# Copyright (c) 2026, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import datetime
+import os
+import socket
+
+import pytest
+import torch
+import torch.distributed as dist
+import torch.nn.functional as F
+from megatron.core import parallel_state
+from megatron.core.models.gpt.gpt_layer_specs import (
+    get_gpt_layer_local_spec,
+    get_gpt_layer_with_transformer_engine_spec,
+)
+from megatron.core.process_groups_config import ProcessGroupCollection
+from megatron.core.tensor_parallel.random import model_parallel_cuda_manual_seed
+from transformers.models.qwen3_omni_moe.configuration_qwen3_omni_moe import (
+    Qwen3OmniMoeThinkerConfig,
+)
+
+from megatron.bridge.models.qwen_omni.modeling_qwen3_omni.model import Qwen3OmniModel
+from megatron.bridge.models.qwen_omni.modeling_qwen3_omni.transformer_config import (
+    Qwen3OmniTransformerConfig,
+)
+
+
+HIDDEN_SIZE = 128
+IMAGE_TOKEN_ID = 900
+VIDEO_TOKEN_ID = 901
+AUDIO_TOKEN_ID = 902
+VISION_START_TOKEN_ID = 903
+AUDIO_START_TOKEN_ID = 904
+
+
+def _make_toy_thinker_config():
+    return Qwen3OmniMoeThinkerConfig(
+        vision_config={
+            "depth": 2,
+            "hidden_size": 32,
+            "intermediate_size": 64,
+            "num_heads": 4,
+            "patch_size": 2,
+            "spatial_merge_size": 1,
+            "temporal_patch_size": 1,
+            "out_hidden_size": HIDDEN_SIZE,
+            "num_position_embeddings": 16,
+            "deepstack_visual_indexes": [0],
+        },
+        audio_config={
+            "num_mel_bins": 8,
+            "d_model": 32,
+            "encoder_attention_heads": 4,
+            "encoder_ffn_dim": 64,
+            "encoder_layers": 2,
+            "output_dim": HIDDEN_SIZE,
+            "downsample_hidden_size": 16,
+        },
+        text_config={
+            "num_hidden_layers": 2,
+            "hidden_size": HIDDEN_SIZE,
+            "intermediate_size": 256,
+            "moe_intermediate_size": 64,
+            "num_attention_heads": 4,
+            "num_key_value_heads": 2,
+            "num_experts": 8,
+            "num_experts_per_tok": 2,
+            "vocab_size": 1000,
+            "max_position_embeddings": 128,
+            "rms_norm_eps": 1e-6,
+            "attention_bias": False,
+            "rope_theta": 1000000.0,
+            "rope_scaling": {"rope_type": "default", "mrope_section": [4, 6, 6]},
+        },
+        image_token_id=IMAGE_TOKEN_ID,
+        video_token_id=VIDEO_TOKEN_ID,
+        audio_token_id=AUDIO_TOKEN_ID,
+        vision_start_token_id=VISION_START_TOKEN_ID,
+        audio_start_token_id=AUDIO_START_TOKEN_ID,
+    )
+
+
+def _make_language_config():
+    return Qwen3OmniTransformerConfig(
+        num_layers=2,
+        hidden_size=HIDDEN_SIZE,
+        num_attention_heads=4,
+        num_query_groups=2,
+        kv_channels=HIDDEN_SIZE // 4,
+        ffn_hidden_size=256,
+        moe_ffn_hidden_size=64,
+        num_moe_experts=8,
+        moe_router_topk=2,
+        vocab_size=1000,
+        language_max_sequence_length=128,
+        normalization="RMSNorm",
+        activation_func=F.silu,
+        gated_linear_unit=True,
+        add_bias_linear=False,
+        add_qkv_bias=False,
+        qk_layernorm=True,
+        layernorm_epsilon=1e-6,
+        bf16=False,
+        use_cpu_initialization=True,
+        hidden_dropout=0.0,
+        attention_dropout=0.0,
+        mrope_section=[4, 6, 6],
+        image_token_id=IMAGE_TOKEN_ID,
+        video_token_id=VIDEO_TOKEN_ID,
+        audio_token_id=AUDIO_TOKEN_ID,
+        vision_start_token_id=VISION_START_TOKEN_ID,
+        audio_start_token_id=AUDIO_START_TOKEN_ID,
+        position_id_per_seconds=25,
+        seconds_per_chunk=2,
+    )
+
+
+def _make_layer_spec():
+    if not torch.cuda.is_available():
+        return get_gpt_layer_local_spec(
+            num_experts=8,
+            moe_grouped_gemm=True,
+            qk_layernorm=True,
+            normalization="RMSNorm",
+        )
+    return get_gpt_layer_with_transformer_engine_spec(
+        num_experts=8,
+        moe_grouped_gemm=True,
+        qk_layernorm=True,
+        fp8=False,
+    )
+
+
+@pytest.fixture(scope="module", autouse=True)
+def _distributed_env():
+    original_env = {
+        key: os.environ.get(key) for key in ("MASTER_ADDR", "MASTER_PORT", "RANK", "LOCAL_RANK", "WORLD_SIZE")
+    }
+
+    if not dist.is_initialized():
+        os.environ["MASTER_ADDR"] = "127.0.0.1"
+        os.environ["MASTER_PORT"] = _find_free_port()
+        os.environ["RANK"] = "0"
+        os.environ["LOCAL_RANK"] = "0"
+        os.environ["WORLD_SIZE"] = "1"
+
+        if torch.cuda.device_count() > 0:
+            torch.cuda.set_device(0)
+
+        dist.init_process_group(
+            backend="nccl" if torch.cuda.is_available() else "gloo",
+            world_size=1,
+            rank=0,
+            timeout=datetime.timedelta(minutes=30),
+        )
+
+    yield
+
+    if dist.is_initialized():
+        dist.destroy_process_group()
+    for key, value in original_env.items():
+        if value is None:
+            os.environ.pop(key, None)
+        else:
+            os.environ[key] = value
+
+
+def _find_free_port() -> str:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.bind(("127.0.0.1", 0))
+        return str(sock.getsockname()[1])
+
+
+def _setup_parallel_state():
+    if parallel_state.model_parallel_is_initialized():
+        parallel_state.destroy_model_parallel()
+
+    parallel_state.initialize_model_parallel(
+        tensor_model_parallel_size=1,
+        pipeline_model_parallel_size=1,
+        virtual_pipeline_model_parallel_size=None,
+        context_parallel_size=1,
+    )
+    if torch.cuda.is_available():
+        model_parallel_cuda_manual_seed(123)
+    else:
+        torch.manual_seed(123)
+
+
+def _build_model():
+    _setup_parallel_state()
+    pg_collection = ProcessGroupCollection.use_mpu_process_groups()
+    return Qwen3OmniModel(
+        language_transformer_config=_make_language_config(),
+        language_transformer_layer_spec=_make_layer_spec(),
+        thinker_transformer_config=_make_toy_thinker_config(),
+        parallel_output=True,
+        pre_process=True,
+        post_process=True,
+        pg_collection=pg_collection,
+    )
+
+
+def test_qwen3_omni_toy_training_step():
+    model = _build_model()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = model.to(device)
+    model.train()
+
+    optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4)
+
+    input_ids = torch.tensor(
+        [
+            [
+                VISION_START_TOKEN_ID,
+                IMAGE_TOKEN_ID,
+                IMAGE_TOKEN_ID,
+                IMAGE_TOKEN_ID,
+                IMAGE_TOKEN_ID,
+                AUDIO_START_TOKEN_ID,
+                AUDIO_TOKEN_ID,
+                AUDIO_TOKEN_ID,
+                31,
+                32,
+                33,
+            ]
+        ],
+        device=device,
+    )
+    labels = torch.randint(0, 1000, input_ids.shape, device=device)
+    pixel_values = torch.randn(4, 3 * 1 * 2 * 2, device=device)
+    image_grid_thw = torch.tensor([[1, 2, 2]], device=device)
+    input_features = torch.randn(1, 8, 10, device=device)
+    feature_attention_mask = torch.ones(1, 10, dtype=torch.long, device=device)
+
+    optimizer.zero_grad(set_to_none=True)
+    output = model(
+        input_ids=input_ids,
+        labels=labels,
+        pixel_values=pixel_values,
+        image_grid_thw=image_grid_thw,
+        input_features=input_features,
+        feature_attention_mask=feature_attention_mask,
+    )
+
+    loss = output.float().mean() if output.ndim > 0 else output.float()
+    assert torch.isfinite(loss), f"Expected finite loss, got {loss}"
+    loss.backward()
+
+    grads = [param.grad for name, param in model.named_parameters() if param.requires_grad and param.grad is not None]
+    assert grads, "Expected at least one trainable parameter to receive gradients"
+    assert any(torch.isfinite(grad).all() for grad in grads), "Expected finite gradients after backward"
+
+    optimizer.step()
+
+    if parallel_state.model_parallel_is_initialized():
+        parallel_state.destroy_model_parallel()
diff --git a/tests/unit_tests/recipes/qwen_omni/test_qwen3_omni_recipes.py b/tests/unit_tests/recipes/qwen_omni/test_qwen3_omni_recipes.py
new file mode 100644
index 0000000000..3c6459e0dc
--- /dev/null
+++ b/tests/unit_tests/recipes/qwen_omni/test_qwen3_omni_recipes.py
@@ -0,0 +1,177 @@
+# Copyright (c) 2026, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import importlib
+import importlib.util
+import pathlib
+import sys
+import types
+import typing
+from types import SimpleNamespace
+
+
+if "megatron.energon" not in sys.modules:
+    fake_energon = types.ModuleType("megatron.energon")
+    fake_energon.WorkerConfig = object
+    fake_energon.get_savable_loader = lambda *args, **kwargs: None
+    fake_energon.get_train_dataset = lambda *args, **kwargs: None
+    sys.modules["megatron.energon"] = fake_energon
+
+if not hasattr(typing, "override"):
+    typing.override = lambda func: func  # type: ignore[attr-defined]
+
+if "megatron.bridge.recipes.common" not in sys.modules:
+    fake_common = types.ModuleType("megatron.bridge.recipes.common")
+
+    def _fake_sft_common_vlm():
+        return SimpleNamespace(
+            model=None,
+            train=SimpleNamespace(train_iters=0, global_batch_size=0, micro_batch_size=0),
+            optimizer=SimpleNamespace(lr=0.0),
+            scheduler=SimpleNamespace(),
+            dataset=SimpleNamespace(seq_length=0, hf_processor_path=None, pack_sequences_in_batch=True),
+            tokenizer=SimpleNamespace(),
+            checkpoint=SimpleNamespace(),
+            ddp=SimpleNamespace(
+                overlap_grad_reduce=True,
+                overlap_param_gather=True,
+                check_for_nan_in_grad=False,
+                use_distributed_optimizer=False,
+                grad_reduce_in_fp32=False,
+                average_in_collective=False,
+                data_parallel_sharding_strategy=None,
+            ),
+            peft=None,
+            mixed_precision=None,
+        )
+
+    fake_common._sft_common_vlm = _fake_sft_common_vlm
+    sys.modules["megatron.bridge.recipes.common"] = fake_common
+
+if "megatron.bridge.recipes.utils.optimizer_utils" not in sys.modules:
+    fake_optimizer_utils = types.ModuleType("megatron.bridge.recipes.utils.optimizer_utils")
+
+    def _fake_distributed_fused_adam_with_cosine_annealing(**kwargs):
+        return SimpleNamespace(lr=kwargs["max_lr"]), SimpleNamespace()
+
+    fake_optimizer_utils.distributed_fused_adam_with_cosine_annealing = (
+        _fake_distributed_fused_adam_with_cosine_annealing
+    )
+    sys.modules["megatron.bridge.recipes.utils.optimizer_utils"] = fake_optimizer_utils
+
+if "megatron.bridge.data.vlm_datasets.preloaded_provider" not in sys.modules:
+    fake_preloaded = types.ModuleType("megatron.bridge.data.vlm_datasets.preloaded_provider")
+
+    class _FakePreloadedVLMConversationProvider:
+        def __init__(self, **kwargs):
+            for key, value in kwargs.items():
+                setattr(self, key, value)
+            self.pack_sequences_in_batch = False
+
+    fake_preloaded.PreloadedVLMConversationProvider = _FakePreloadedVLMConversationProvider
+    sys.modules["megatron.bridge.data.vlm_datasets.preloaded_provider"] = fake_preloaded
+
+_RECIPE_PATH = (
+    pathlib.Path(__file__).resolve().parents[4]
+    / "src"
+    / "megatron"
+    / "bridge"
+    / "recipes"
+    / "qwen_omni"
+    / "qwen3_omni.py"
+)
+_SPEC = importlib.util.spec_from_file_location("_test_qwen3_omni_recipe_module", _RECIPE_PATH)
+assert _SPEC is not None and _SPEC.loader is not None
+_qwen3_omni_module = importlib.util.module_from_spec(_SPEC)
+_SPEC.loader.exec_module(_qwen3_omni_module)
+
+
+class _FakeProvider:
+    def __init__(self, **kwargs):
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+        self.tensor_model_parallel_size = 1
+        self.pipeline_model_parallel_size = 1
+        self.pipeline_dtype = None
+        self.virtual_pipeline_model_parallel_size = None
+        self.context_parallel_size = 1
+        self.expert_model_parallel_size = 1
+        self.expert_tensor_parallel_size = 1
+        self.sequence_parallel = False
+        self.seq_length = 64
+        self.freeze_language_model = False
+        self.freeze_vision_model = False
+        self.freeze_audio_model = False
+        self.vit_gradient_checkpointing = False
+        self.multimodal_attn_impl = "auto"
+        self.transformer_impl = "transformer_engine"
+        self.cuda_graph_impl = "none"
+        self.attention_backend = "auto"
+
+    def finalize(self):
+        return None
+
+
+class _FakeAutoBridge:
+    @staticmethod
+    def from_hf_pretrained(_hf_path: str):
+        return _FakeAutoBridge()
+
+    def to_megatron_provider(self, load_weights: bool = False):
+        assert load_weights is False
+        return _FakeProvider()
+
+
+def test_qwen3_omni_sft_recipe_builds_config(monkeypatch):
+    monkeypatch.setattr(_qwen3_omni_module, "AutoBridge", _FakeAutoBridge)
+
+    cfg = _qwen3_omni_module.qwen3_omni_30b_a3b_sft_config()
+
+    assert cfg.model is not None
+    assert cfg.train is not None
+    assert cfg.optimizer is not None
+    assert cfg.scheduler is not None
+    assert cfg.dataset is not None
+    assert cfg.tokenizer is not None
+    assert cfg.checkpoint is not None
+    assert cfg.peft is None
+
+    assert cfg.model.tensor_model_parallel_size == 1
+    assert cfg.model.pipeline_model_parallel_size == 1
+    assert cfg.model.sequence_parallel is False
+    assert cfg.model.freeze_language_model is False
+    assert cfg.model.freeze_vision_model is False
+    assert cfg.model.freeze_audio_model is False
+    assert cfg.model.vit_gradient_checkpointing is False
+    assert cfg.model.multimodal_attn_impl == "auto"
+
+    assert cfg.dataset.seq_length == 4096
+    assert cfg.dataset.pack_sequences_in_batch is False
+    assert cfg.dataset.hf_processor_path == "Qwen/Qwen3-Omni-30B-A3B-Instruct"
+
+    assert cfg.optimizer.lr == 5e-6
+
+
+def test_qwen3_omni_preloaded_recipe_uses_preloaded_provider(monkeypatch):
+    monkeypatch.setattr(_qwen3_omni_module, "AutoBridge", _FakeAutoBridge)
+
+    cfg = _qwen3_omni_module.qwen3_omni_30b_a3b_sft_preloaded_config()
+
+    assert cfg.dataset is not None
+    assert cfg.dataset.seq_length == 4096
+    assert cfg.dataset.hf_processor_path == "Qwen/Qwen3-Omni-30B-A3B-Instruct"
+    assert cfg.dataset.train_data_path is None
+    assert cfg.dataset.valid_data_path is None
+    assert cfg.dataset.test_data_path is None
+    assert cfg.dataset.pack_sequences_in_batch is False
diff --git a/tests/unit_tests/training/test_run_recipe_qwen3_omni.py b/tests/unit_tests/training/test_run_recipe_qwen3_omni.py
new file mode 100644
index 0000000000..70d6f7df59
--- /dev/null
+++ b/tests/unit_tests/training/test_run_recipe_qwen3_omni.py
@@ -0,0 +1,203 @@
+# Copyright (c) 2026, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Unit tests for Qwen3-Omni training entry wiring in run_recipe.py."""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+import types
+from pathlib import Path
+from unittest.mock import Mock
+
+
+def _load_run_recipe_module():
+    """Load run_recipe.py with lightweight stub modules for local unit testing."""
+
+    script_path = Path(__file__).resolve().parents[3] / "scripts" / "training" / "run_recipe.py"
+    module_name = "test_run_recipe_qwen3_omni_module"
+
+    recipe_config = object()
+    megatron_module = types.ModuleType("megatron")
+    bridge_module = types.ModuleType("megatron.bridge")
+    models_module = types.ModuleType("megatron.bridge.models")
+    qwen_omni_models_module = types.ModuleType("megatron.bridge.models.qwen_omni")
+    qwen_vl_models_module = types.ModuleType("megatron.bridge.models.qwen_vl")
+    diffusion_module = types.ModuleType("megatron.bridge.diffusion")
+    diffusion_models_module = types.ModuleType("megatron.bridge.diffusion.models")
+    flux_models_module = types.ModuleType("megatron.bridge.diffusion.models.flux")
+    wan_models_module = types.ModuleType("megatron.bridge.diffusion.models.wan")
+    training_module = types.ModuleType("megatron.bridge.training")
+    training_utils_module = types.ModuleType("megatron.bridge.training.utils")
+    recipes_utils_module = types.ModuleType("megatron.bridge.recipes.utils")
+
+    recipes_module = types.ModuleType("megatron.bridge.recipes")
+    recipes_module.qwen3_omni_30b_a3b_sft_config = lambda **_: recipe_config
+
+    qwen3_omni_step = types.ModuleType("megatron.bridge.models.qwen_omni.qwen3_omni_step")
+    qwen3_omni_step.forward_step = object()
+
+    qwen3_vl_step = types.ModuleType("megatron.bridge.models.qwen_vl.qwen3_vl_step")
+    qwen3_vl_step.forward_step = object()
+
+    gpt_step = types.ModuleType("megatron.bridge.training.gpt_step")
+    gpt_step.forward_step = object()
+
+    vlm_step = types.ModuleType("megatron.bridge.training.vlm_step")
+    vlm_step.forward_step = object()
+
+    llava_step = types.ModuleType("megatron.bridge.training.llava_step")
+    llava_step.forward_step = object()
+
+    audio_lm_step = types.ModuleType("megatron.bridge.training.audio_lm_step")
+    audio_lm_step.forward_step = object()
+
+    flux_step = types.ModuleType("megatron.bridge.diffusion.models.flux.flux_step")
+
+    class FluxForwardStep:
+        pass
+
+    flux_step.FluxForwardStep = FluxForwardStep
+
+    wan_step = types.ModuleType("megatron.bridge.diffusion.models.wan.wan_step")
+
+    class WanForwardStep:
+        def __init__(self, mode=None):
+            self.mode = mode
+
+    wan_step.WanForwardStep = WanForwardStep
+
+    finetune_module = types.ModuleType("megatron.bridge.training.finetune")
+    finetune_module.finetune = Mock(name="finetune")
+
+    pretrain_module = types.ModuleType("megatron.bridge.training.pretrain")
+    pretrain_module.pretrain = Mock(name="pretrain")
+
+    config_module = types.ModuleType("megatron.bridge.training.config")
+    config_module.ConfigContainer = object
+
+    omegaconf_module = types.ModuleType("megatron.bridge.training.utils.omegaconf_utils")
+    omegaconf_module.process_config_with_overrides = lambda config, cli_overrides=None: config
+
+    dataset_utils_module = types.ModuleType("megatron.bridge.recipes.utils.dataset_utils")
+    dataset_utils_module.DATASET_TYPES = ["llm-finetune", "llm-pretrain-mock"]
+    dataset_utils_module.infer_mode_from_dataset = lambda dataset: "finetune"
+    dataset_utils_module.apply_dataset_override = (
+        lambda config, dataset_type, packed_sequence, seq_length, cli_overrides: config
+    )
+
+    stub_modules = {
+        "megatron": megatron_module,
+        "megatron.bridge": bridge_module,
+        "megatron.bridge.models": models_module,
+        "megatron.bridge.models.qwen_omni": qwen_omni_models_module,
+        "megatron.bridge.models.qwen_vl": qwen_vl_models_module,
+        "megatron.bridge.diffusion": diffusion_module,
+        "megatron.bridge.diffusion.models": diffusion_models_module,
+        "megatron.bridge.diffusion.models.flux": flux_models_module,
+        "megatron.bridge.diffusion.models.wan": wan_models_module,
+        "megatron.bridge.training": training_module,
+        "megatron.bridge.training.utils": training_utils_module,
+        "megatron.bridge.recipes": recipes_module,
+        "megatron.bridge.recipes.utils": recipes_utils_module,
+        "megatron.bridge.recipes.utils.dataset_utils": dataset_utils_module,
+        "megatron.bridge.diffusion.models.flux.flux_step": flux_step,
+        "megatron.bridge.diffusion.models.wan.wan_step": wan_step,
+        "megatron.bridge.models.qwen_omni.qwen3_omni_step": qwen3_omni_step,
+        "megatron.bridge.models.qwen_vl.qwen3_vl_step": qwen3_vl_step,
+        "megatron.bridge.training.audio_lm_step": audio_lm_step,
+        "megatron.bridge.training.gpt_step": gpt_step,
+        "megatron.bridge.training.vlm_step": vlm_step,
+        "megatron.bridge.training.llava_step": llava_step,
+        "megatron.bridge.training.finetune": finetune_module,
+        "megatron.bridge.training.pretrain": pretrain_module,
+        "megatron.bridge.training.config": config_module,
+        "megatron.bridge.training.utils.omegaconf_utils": omegaconf_module,
+    }
+
+    previous_modules = {name: sys.modules.get(name) for name in stub_modules}
+    sys.modules.update(stub_modules)
+
+    try:
+        spec = importlib.util.spec_from_file_location(module_name, script_path)
+        assert spec is not None and spec.loader is not None
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+    finally:
+        for name, previous in previous_modules.items():
+            if previous is None:
+                sys.modules.pop(name, None)
+            else:
+                sys.modules[name] = previous
+
+    test_handles = {
+        "omni_forward_step": qwen3_omni_step.forward_step,
+        "finetune": finetune_module.finetune,
+        "pretrain": pretrain_module.pretrain,
+        "recipe_config": recipe_config,
+    }
+    return module, test_handles
+
+
+class TestRunRecipeQwen3Omni:
+    """Tests for wiring Qwen3-Omni into the generic training entrypoint."""
+
+    def test_load_forward_step_returns_qwen3_omni_handler(self):
+        """The run_recipe registry should expose qwen3_omni_step."""
+
+        module, _ = _load_run_recipe_module()
+
+        assert module.load_forward_step("qwen3_omni_step") is not None
+
+    def test_qwen3_omni_step_is_exposed_in_cli_choices(self):
+        """The CLI parser should advertise qwen3_omni_step as a valid step function."""
+
+        module, _ = _load_run_recipe_module()
+
+        original_argv = sys.argv
+        sys.argv = ["run_recipe.py", "--recipe", "qwen3_omni_30b_a3b_sft_config"]
+        try:
+            args, _ = module.parse_args()
+        finally:
+            sys.argv = original_argv
+
+        assert "qwen3_omni_step" in module.STEP_FUNCTIONS
+        assert args.step_func == "gpt_step"
+
+    def test_main_routes_qwen3_omni_step_to_finetune(self):
+        """The generic training entry should pass the Omni step function into finetune."""
+
+        module, handles = _load_run_recipe_module()
+
+        original_argv = sys.argv
+        sys.argv = [
+            "run_recipe.py",
+            "--recipe",
+            "qwen3_omni_30b_a3b_sft_config",
+            "--dataset",
+            "llm-finetune",
+            "--step_func",
+            "qwen3_omni_step",
+        ]
+        try:
+            module.main()
+        finally:
+            sys.argv = original_argv
+
+        handles["finetune"].assert_called_once_with(
+            config=handles["recipe_config"],
+            forward_step_func=handles["omni_forward_step"],
+        )
+        handles["pretrain"].assert_not_called()