Merge branch 'develop' of https://github.com/isaac-sim/IsaacLab into zhengyuz/kitless-visual-color-randomization

# Conflicts:
#	source/isaaclab/test/envs/test_color_randomization.py

Author: ooctipus

.github/actions/upload-omni-github-test-results/junit_to_omni_github_results.py

@@ -54,6 +54,28 @@ def _test_id(testcase: ET.Element) -> str:
     return "::".join(part for part in parts if part) or "unknown-testcase"
 
 
+def _testcase_markers(testcase: ET.Element) -> list[str]:
+    """Return the intent markers recorded on a testcase, in stable order.
+
+    pytest serializes ``item.user_properties`` as ``<property>`` elements under a
+    ``<properties>`` child of the testcase. The repo-root ``conftest.py`` records the
+    auto-applied intent markers there under the ``markers`` property as a comma-separated
+    string. Missing or empty values yield an empty list.
+    """
+    properties = _first_child(testcase, {"properties"})
+    if properties is None:
+        return []
+    markers: list[str] = []
+    for prop in properties:
+        if _local_name(prop.tag) != "property" or prop.attrib.get("name") != "markers":
+            continue
+        for value in prop.attrib.get("value", "").split(","):
+            value = value.strip()
+            if value:
+                markers.append(value)
+    return markers
+
+
 def _short_message(element: ET.Element | None) -> str | None:
     """Return a compact message from a failure, error, or skip element."""
     if element is None:
@@ -83,7 +105,6 @@ def _convert_testcase(
         "test_id": _test_id(testcase),
         "passed": failure_or_error is None and skipped is None,
         "duration": _duration_seconds(testcase),
-        "test_type": test_type,
         "group_id": group_id,
         "retries": retries,
         "log_paths": log_paths,
@@ -106,6 +127,12 @@ def _convert_testcase(
             if any(pattern in detail_text for pattern in patterns):
                 row[flag] = True
 
+    markers = _testcase_markers(testcase)
+    if markers:
+        row["test_type"] = ",".join([test_type, *markers])
+    else:
+        row["test_type"] = test_type
+
     return row
 
 

.github/actions/upload-omni-github-test-results/test_junit_to_omni_github_results.py

@@ -167,3 +167,42 @@ def test_convert_junit_adds_log_paths_for_junit_and_comparison_artifacts(tmp_pat
         junit_log_url,
         comparison_images_url,
     ]
+
+
+def test_convert_junit_appends_markers_to_test_type_with_separator(tmp_path: Path) -> None:
+    """Recorded intent markers should append to the base test_type with comma separators."""
+    converter = _load_converter_module()
+    junit_file = tmp_path / "report.xml"
+    output_dir = tmp_path / "out"
+    junit_file.write_text(
+        """<?xml version="1.0" encoding="utf-8"?>
+<testsuite name="pytest" tests="2" failures="0" errors="0" skipped="0" time="2">
+  <testcase classname="test_camera" name="test_rgb" time="1">
+    <properties>
+      <property name="markers" value="integration,rendering"/>
+    </properties>
+  </testcase>
+  <testcase classname="test_math" name="test_quat" time="1"/>
+</testsuite>
+""",
+        encoding="utf-8",
+    )
+
+    converter.convert_junit(
+        junit_file=junit_file,
+        output_dir=output_dir,
+        test_tool_id="pytest",
+        test_type="pytest",
+        app_platform="linux-x86_64",
+        app_config="test-job",
+        group_name="Docker + Tests / isaaclab",
+        junit_log_url="",
+        comparison_images_url="",
+        retries=0,
+    )
+
+    marked, unmarked = _load_rows(output_dir)
+    # The base type must be separated from the first marker, not fused into "pytestintegration".
+    assert marked["test_type"] == "pytest,integration,rendering"
+    # Testcases without markers keep the bare base type.
+    assert unmarked["test_type"] == "pytest"

.github/workflows/daily-compatibility.yml

@@ -95,6 +95,19 @@ jobs:
         fetch-depth: 1
         lfs: true
 
+    # Single source of truth: read the OV runtime pins from [tool.isaaclab.versions].
+    - name: Resolve OV runtime pins from pyproject
+      id: ov_pins
+      run: |
+        PINS=$(python3 <<'PY'
+        import re
+        block = re.search(r"^\[tool\.isaaclab\.versions\]\n(.*?)(?:\n\[|\Z)", open("pyproject.toml").read(), re.S | re.M).group(1)
+        vals = dict(re.findall(r'(\w+)\s*=\s*"([^"]+)"', block))
+        print(f"ovphysx=={vals['ovphysx']} ovrtx{vals['ovrtx']}")
+        PY
+        )
+        echo "pins=$PINS" >> "$GITHUB_OUTPUT"
+
     - name: Build Docker Image
       uses: ./.github/actions/docker-build
       with:
@@ -111,7 +124,7 @@ jobs:
         image-tag: ${{ env.DOCKER_IMAGE_TAG }}
         pytest-options: ""
         filter-pattern: "isaaclab_tasks"
-        extra-pip-packages: "ovrtx ovphysx==0.4.13"
+        extra-pip-packages: ${{ steps.ov_pins.outputs.pins }}
 
     - name: Copy All Test Results from IsaacLab Tasks Container
       run: |

.github/workflows/license-check.yaml

@@ -15,14 +15,145 @@ concurrency:
 
 jobs:
   license-check:
+    # Fork PRs cannot access NGC_API_KEY, so they cannot resolve the immutable
+    # OVPhysX wheel required by the development extras.
+    if: github.event.pull_request.head.repo.full_name == github.repository
     runs-on: ubuntu-24.04
+    env:
+      NGC_API_KEY: ${{ secrets.NGC_API_KEY }}
 
     steps:
     - name: Checkout code
       uses: actions/checkout@v6
       with:
         filter: tree:0
 
+    - name: Load OVPhysX wheelhouse configuration
+      id: config
+      shell: bash
+      run: |
+        set -euo pipefail
+        resource=$(yq -r .ovphysx_wheelhouse_resource .github/workflows/config.yaml)
+        echo "wheelhouse_resource=${resource}" >> "$GITHUB_OUTPUT"
+
+    - name: Restore NGC CLI cache
+      uses: actions/cache@v4
+      with:
+        path: ${{ runner.temp }}/ngc-cli-cache/ngccli_linux.zip
+        key: ngc-cli-${{ runner.os }}-${{ runner.arch }}-4.20.0-5cf084c88998c58ad8abf7849d2d1b41d578423886eb03018df10194e341d35b
+
+    - name: Extract OVPhysX wheelhouse
+      id: extract-wheelhouse
+      shell: bash
+      env:
+        WHEELHOUSE_RESOURCE: ${{ steps.config.outputs.wheelhouse_resource }}
+      run: |
+        set -euo pipefail
+
+        if [ -z "${NGC_API_KEY:-}" ]; then
+          echo "::error::NGC_API_KEY is unavailable; cannot download the configured OVPhysX wheelhouse"
+          exit 1
+        fi
+
+        NGC_CLI_VERSION="4.20.0"
+        NGC_CLI_SHA256="5cf084c88998c58ad8abf7849d2d1b41d578423886eb03018df10194e341d35b"
+        NGC_CLI_URL="https://api.ngc.nvidia.com/v2/resources/nvidia/ngc-apps/ngc_cli/versions/${NGC_CLI_VERSION}/files/ngccli_linux.zip"
+
+        wheelhouse_root="$(mktemp -d "${RUNNER_TEMP:-/tmp}/ovphysx-wheelhouse.XXXXXX")"
+        download_root="$(mktemp -d "${RUNNER_TEMP:-/tmp}/ovphysx-wheelhouse-download.XXXXXX")"
+        ngc_home="$(mktemp -d "${RUNNER_TEMP:-/tmp}/ovphysx-ngc-home.XXXXXX")"
+        ngc_unpack_dir=""
+        preserve_wheelhouse_root=false
+        cleanup() {
+          if [ "$preserve_wheelhouse_root" != "true" ]; then
+            rm -rf "$wheelhouse_root"
+          fi
+          rm -rf "$download_root" "$ngc_home"
+          if [ -n "$ngc_unpack_dir" ]; then
+            rm -rf "$ngc_unpack_dir"
+          fi
+        }
+        trap cleanup EXIT
+
+        cache_dir="${RUNNER_TEMP:-/tmp}/ngc-cli-cache"
+        ngc_zip="${cache_dir}/ngccli_linux.zip"
+        mkdir -p "$cache_dir"
+        if [ ! -f "$ngc_zip" ]; then
+          echo "Downloading NGC CLI ${NGC_CLI_VERSION}"
+          curl -fsSL -o "$ngc_zip" "$NGC_CLI_URL"
+        fi
+        echo "${NGC_CLI_SHA256}  ${ngc_zip}" | sha256sum -c -
+        ngc_unpack_dir="$(mktemp -d "${RUNNER_TEMP:-/tmp}/ngc-cli.XXXXXX")"
+        unzip -q "$ngc_zip" -d "$ngc_unpack_dir"
+        export PATH="${ngc_unpack_dir}/ngc-cli:${PATH}"
+
+        export NGC_CLI_API_KEY="$NGC_API_KEY"
+        export NGC_CLI_ORG=nvidian
+        export NGC_CLI_TEAM=no-team
+        export NGC_CLI_HOME="$ngc_home"
+
+        ngc --version
+        echo "Downloading wheelhouse resource: $WHEELHOUSE_RESOURCE"
+        ngc registry resource download-version "$WHEELHOUSE_RESOURCE" --dest "$download_root"
+
+        mapfile -t manifests < <(find "$download_root" -type f -name manifest.json)
+        if [ "${#manifests[@]}" -ne 1 ]; then
+          echo "::error::expected exactly one manifest.json in downloaded wheelhouse resource, found ${#manifests[@]}"
+          printf '%s\n' "${manifests[@]}"
+          exit 1
+        fi
+
+        payload_dir="$(dirname "${manifests[0]}")"
+        if [ ! -d "${payload_dir}/wheelhouse" ]; then
+          echo "::error::downloaded wheelhouse resource is missing wheelhouse/ next to manifest.json"
+          exit 1
+        fi
+
+        mkdir -p "$wheelhouse_root/wheelhouse"
+        cp "${payload_dir}/manifest.json" "$wheelhouse_root/manifest.json"
+        cp "${payload_dir}/wheelhouse/"*.whl "$wheelhouse_root/wheelhouse/"
+
+        python3 - <<'PY' "$wheelhouse_root/manifest.json" "$wheelhouse_root/wheelhouse"
+        import hashlib
+        import json
+        import pathlib
+        import sys
+
+        manifest_path = pathlib.Path(sys.argv[1])
+        wheelhouse_dir = pathlib.Path(sys.argv[2])
+        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+
+        expected = {
+            "artifact": "ovphysx-wheelhouse",
+            "platform": "manylinux_2_35_x86_64",
+        }
+        for key, value in expected.items():
+            actual = manifest.get(key)
+            if actual != value:
+                raise SystemExit(f"manifest {key!r} mismatch: expected {value!r}, got {actual!r}")
+
+        wheels = manifest.get("wheels")
+        if not isinstance(wheels, list) or not wheels:
+            raise SystemExit("manifest has no wheels list")
+
+        for wheel in wheels:
+            filename = wheel.get("file")
+            expected_sha = wheel.get("sha256")
+            if not filename or not expected_sha:
+                raise SystemExit(f"invalid wheel manifest entry: {wheel!r}")
+            wheel_path = wheelhouse_dir / filename
+            if not wheel_path.is_file():
+                raise SystemExit(f"manifest wheel is missing from wheelhouse: {filename}")
+            actual_sha = hashlib.sha256(wheel_path.read_bytes()).hexdigest()
+            if actual_sha != expected_sha:
+                raise SystemExit(f"sha256 mismatch for {filename}: expected {expected_sha}, got {actual_sha}")
+
+        print(f"Validated {len(wheels)} wheelhouse wheels from {manifest_path}")
+        PY
+
+        echo "wheelhouse_root=$wheelhouse_root" >> "$GITHUB_OUTPUT"
+        echo "wheelhouse_dir=$wheelhouse_root/wheelhouse" >> "$GITHUB_OUTPUT"
+
     # - name: Install jq
     #   run: sudo apt-get update && sudo apt-get install -y jq
 
@@ -60,10 +191,13 @@ jobs:
         OMNI_KIT_ACCEPT_EULA: yes
         ACCEPT_EULA: Y
         ISAACSIM_ACCEPT_EULA: YES
+        UV_FIND_LINKS: ${{ steps.extract-wheelhouse.outputs.wheelhouse_dir }}
       run: |
         uv sync --extra all
-        # Isaac Sim isn't in the dev pyproject; sync first so it isn't pruned.
-        uv pip install 'isaacsim[all,extscache]==${{ vars.ISAACSIM_BASE_VERSION || '6.0.0' }}'
+        # Isaac Sim conflicts with --extra all under uv, so install it imperatively
+        # after the sync. Read the pinned spec from pyproject (single source of truth).
+        ISAACSIM_SPEC=$(.venv/bin/python -c "import tomllib; print(tomllib.load(open('pyproject.toml','rb'))['project']['optional-dependencies']['isaacsim'][0])")
+        uv pip install "$ISAACSIM_SPEC"
         uv pip install pip-licenses pipdeptree \
           -r tools/template/requirements.txt \
           -r docs/requirements.txt
@@ -153,3 +287,9 @@ jobs:
         else
           echo "All packages were checked."
         fi
+
+    - name: Clean up OVPhysX wheelhouse
+      if: always()
+      shell: bash
+      run: |
+        rm -rf "${{ steps.extract-wheelhouse.outputs.wheelhouse_root }}"

.github/workflows/license-exceptions.json

@@ -488,6 +488,11 @@
     "license": "LicenseRef-NVIDIA-SOFTWARE-LICENSE",
     "comment": "NVIDIA"
   },
+  {
+    "package": "cuda-toolkit",
+    "license": null,
+    "comment": "NVIDIA CUDA Toolkit EULA (LicenseRef-NVIDIA-SOFTWARE-LICENSE); wheel ships no license metadata"
+  },
   {
     "package": "omniverseclient",
     "license": "NVIDIA Proprietary Software, https://www.nvidia.com/en-us/agreements/enterprise-software/nvidia-software-license-agreement/",
@@ -507,5 +512,15 @@
     "package": "pytetwild",
     "license": "Mozilla Public License 2.0 (MPL 2.0)",
     "comment": "MPL-2.0 / OSRB"
+  },
+  {
+    "package": "distlib",
+    "license": "Python Software Foundation License",
+    "comment": "PSFL / OSRB"
+  },
+  {
+    "package": "ovrtx",
+    "license": "NVIDIA Proprietary Software",
+    "comment": "NVIDIA"
   }
 ]

apps/isaaclab.python.headless.kit

@@ -62,11 +62,11 @@ interceptSysStdOutput = false
 logSysStdOutput = false
 
 [settings]
-# MGPU is always on, you can turn it from the settings, and force this off to save even more resource if you
-# only want to use a single GPU on your MGPU system
-# False for Isaac Sim
-renderer.multiGpu.enabled = true
-renderer.multiGpu.autoEnable = true
+# Use one renderer GPU by default. Applications that need single-process multi-GPU rendering can override these
+# settings through AppLauncher's ``kit_args``.
+renderer.multiGpu.enabled = false
+renderer.multiGpu.autoEnable = false
+renderer.multiGpu.maxGpuCount = 1
 'rtx-transient'.resourcemanager.enableTextureStreaming = true
 app.asyncRendering = false
 app.asyncRenderingLowLatency = false

apps/isaaclab.python.headless.rendering.kit

@@ -76,9 +76,6 @@ rtx.ambientOcclusion.enabled = false
 # Set the DLSS model
 rtx.post.dlss.execMode = 0 # can be 0 (Performance), 1 (Balanced), 2 (Quality), or 3 (Auto)
 
-# Avoids unnecessary GPU context initialization
-renderer.multiGpu.maxGpuCount=1
-
 # Force synchronous rendering to improve training results
 omni.replicator.asyncRendering = false
 

apps/isaaclab.python.kit

@@ -249,6 +249,12 @@ omni.replicator.asyncRendering = false
 app.asyncRendering = false
 app.asyncRenderingLowLatency = false
 
+# Use one renderer GPU by default. Applications that need single-process multi-GPU rendering can override these
+# settings through AppLauncher's ``kit_args``.
+renderer.multiGpu.enabled = false
+renderer.multiGpu.autoEnable = false
+renderer.multiGpu.maxGpuCount = 1
+
 ### FSD
 app.useFabricSceneDelegate = true
 rtx.hydra.readTransformsFromFabricInRenderDelegate = true

apps/isaaclab.python.rendering.kit

@@ -71,9 +71,6 @@ rtx.ambientOcclusion.enabled = false
 # Set the DLSS model
 rtx.post.dlss.execMode = 0 # can be 0 (Performance), 1 (Balanced), 2 (Quality), or 3 (Auto)
 
-# Avoids unnecessary GPU context initialization
-renderer.multiGpu.maxGpuCount=1
-
 # Force synchronous rendering to improve training results
 omni.replicator.asyncRendering = false
 

apps/isaaclab.python.xr.openxr.kit

@@ -24,6 +24,8 @@ app.asyncRendering = true
 app.asyncRenderingLowLatency = true
 
 # For XR, set this back to default "#define OMNI_MAX_DEVICE_GROUP_DEVICE_COUNT 16"
+renderer.multiGpu.enabled = true
+renderer.multiGpu.autoEnable = true
 renderer.multiGpu.maxGpuCount = 16
 renderer.gpuEnumeration.glInterop.enabled = true # Allow Kit XR OpenXR to render headless