Sync Space content from RoboMME_Interactive_Demo_cpu (CPU interactive demo).

Dockerfile

@@ -1,4 +1,4 @@
-FROM nvidia/cuda:12.4.1-cudnn-runtime-ubuntu22.04
+FROM ubuntu:22.04
 
 ENV DEBIAN_FRONTEND=noninteractive
 
@@ -11,10 +11,9 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     git \
     ffmpeg \
     libgl1 \
-    libglvnd-dev \
     libglib2.0-0 \
     libvulkan1 \
-    vulkan-tools \
+    mesa-vulkan-drivers \
     && add-apt-repository ppa:deadsnakes/ppa \
     && apt-get update && apt-get install -y --no-install-recommends \
     python3.11 \
@@ -32,7 +31,6 @@ RUN useradd -m -u 1000 user
 
 ENV PYTHONUNBUFFERED=1 \
     PIP_NO_CACHE_DIR=1 \
-    NVIDIA_DRIVER_CAPABILITIES=compute,utility,graphics \
     HOME=/home/user \
     PATH=/home/user/.local/bin:$PATH \
     OMP_NUM_THREADS=1 \

README.md

@@ -2,19 +2,21 @@
 title: RoboMME Oracle Planner
 sdk: docker
 app_port: 7860
-arxiv: "2603.04639"
 ---
 
-[Arxiv Paper](https://arxiv.org/abs/2603.04639) | [HF Paper](https://huggingface.co/papers/2603.04639) | [Website](https://robomme.github.io/) | [Benchmark Code](https://github.com/RoboMME/robomme_benchmark) | [Policy Learning Code](https://github.com/RoboMME/robomme_policy_learning)
-
 This Space runs the RoboMME Gradio interface with the Docker SDK.
+
 The container entrypoint is defined by the root `Dockerfile` and launches:
+
 ```bash
 python3 gradio-web/main.py
 ```
+
 `app_file` is intentionally not set here because this is a Docker Space; the application entrypoint comes from Docker `CMD`, while `app_port: 7860` is the external port published by the Space.
-Local GPU Docker run:
+
+Local CPU Docker run:
+
 ```bash
-docker build -t robomme-gradio:gpu .
-docker run --rm --gpus all -p 7860:7860 robomme-gradio:gpu
-```
+docker build -t robomme-gradio:cpu .
+docker run --rm -p 7860:7860 robomme-gradio:cpu
+```

docker-entrypoint.sh

@@ -1,50 +1,25 @@
 #!/bin/sh
 set -eu
 
-pick_vulkan_icd() {
-    for candidate in \
-        /etc/vulkan/icd.d/nvidia_icd.json \
-        /etc/vulkan/icd.d/nvidia_icd.x86_64.json \
-        /usr/share/vulkan/icd.d/nvidia_icd.json \
-        /usr/share/vulkan/icd.d/nvidia_icd.x86_64.json
-    do
-        if [ -f "$candidate" ]; then
-            printf '%s\n' "$candidate"
-            return 0
-        fi
-    done
-    return 1
-}
-
-run_diagnostic() {
-    label="$1"
-    shift
-    echo "[entrypoint] $label"
-    if "$@"; then
-        return 0
-    else
-        status=$?
-    fi
-    echo "[entrypoint] $label failed with exit code $status"
-    return 0
-}
-
 if [ -z "${OMP_NUM_THREADS:-}" ]; then
     export OMP_NUM_THREADS=1
 fi
 
-if [ -z "${VK_ICD_FILENAMES:-}" ]; then
-    if detected_icd="$(pick_vulkan_icd)"; then
-        export VK_ICD_FILENAMES="$detected_icd"
-        echo "[entrypoint] Using Vulkan ICD: $VK_ICD_FILENAMES"
-    else
-        echo "[entrypoint] Vulkan ICD file not found under /etc or /usr/share"
-    fi
-else
-    echo "[entrypoint] Respecting preset VK_ICD_FILENAMES: $VK_ICD_FILENAMES"
+export CUDA_VISIBLE_DEVICES=-1
+export NVIDIA_VISIBLE_DEVICES=void
+export ROBOMME_RENDER_BACKEND="${ROBOMME_RENDER_BACKEND:-pci:0}"
+unset NVIDIA_DRIVER_CAPABILITIES
+unset SAPIEN_RENDER_DEVICE
+unset MUJOCO_GL
+if [ -z "${VK_ICD_FILENAMES:-}" ] && [ -f /usr/share/vulkan/icd.d/lvp_icd.x86_64.json ]; then
+    export VK_ICD_FILENAMES=/usr/share/vulkan/icd.d/lvp_icd.x86_64.json
 fi
 
+echo "[entrypoint] Starting RoboMME Gradio app in CPU-only mode"
 echo "[entrypoint] OMP_NUM_THREADS=$OMP_NUM_THREADS"
-run_diagnostic "nvidia-smi" nvidia-smi
-run_diagnostic "vulkaninfo --summary" vulkaninfo --summary
+echo "[entrypoint] CUDA_VISIBLE_DEVICES=$CUDA_VISIBLE_DEVICES"
+echo "[entrypoint] NVIDIA_VISIBLE_DEVICES=$NVIDIA_VISIBLE_DEVICES"
+echo "[entrypoint] ROBOMME_RENDER_BACKEND=$ROBOMME_RENDER_BACKEND"
+echo "[entrypoint] SAPIEN_RENDER_DEVICE=${SAPIEN_RENDER_DEVICE:-<unset>}"
+echo "[entrypoint] VK_ICD_FILENAMES=${VK_ICD_FILENAMES:-<unset>}"
 exec "$@"

gradio-web/main.py

@@ -15,6 +15,18 @@ SRC_DIR = PROJECT_ROOT / "src"
 VIDEOS_DIR = APP_DIR / "videos"
 TEMP_DEMOS_DIR = PROJECT_ROOT / "temp_demos"
 CWD_TEMP_DEMOS_DIR = Path.cwd() / "temp_demos"
+DEFAULT_LLVMPipe_ICD = Path("/usr/share/vulkan/icd.d/lvp_icd.x86_64.json")
+DEFAULT_CPU_RENDER_BACKEND = "pci:0"
+CPU_ONLY_ENV_OVERRIDES = {
+    "CUDA_VISIBLE_DEVICES": "-1",
+    "NVIDIA_VISIBLE_DEVICES": "void",
+    "ROBOMME_RENDER_BACKEND": DEFAULT_CPU_RENDER_BACKEND,
+}
+CPU_ONLY_ENV_CLEAR_KEYS = (
+    "NVIDIA_DRIVER_CAPABILITIES",
+    "SAPIEN_RENDER_DEVICE",
+    "MUJOCO_GL",
+)
 
 
 
@@ -27,6 +39,36 @@ if str(SRC_DIR) not in sys.path:
     sys.path.insert(0, str(SRC_DIR))
 
 
+def configure_cpu_only_runtime(logger: logging.Logger | None = None):
+    """Force CPU-only execution before importing project modules."""
+    cleared = {}
+    for key, value in CPU_ONLY_ENV_OVERRIDES.items():
+        os.environ[key] = value
+    for key in CPU_ONLY_ENV_CLEAR_KEYS:
+        previous = os.environ.pop(key, None)
+        if previous is not None:
+            cleared[key] = previous
+    vk_icd_status = "preserved"
+    if "VK_ICD_FILENAMES" not in os.environ:
+        if DEFAULT_LLVMPipe_ICD.exists():
+            os.environ["VK_ICD_FILENAMES"] = str(DEFAULT_LLVMPipe_ICD)
+            vk_icd_status = "auto-set"
+        else:
+            vk_icd_status = "unavailable"
+    if logger is not None:
+        logger.info(
+            "Configured CPU-only runtime overrides=%s cleared=%s vk_icd_status=%s vk_icd=%s",
+            CPU_ONLY_ENV_OVERRIDES,
+            cleared,
+            vk_icd_status,
+            os.environ.get("VK_ICD_FILENAMES"),
+        )
+    return cleared
+
+
+configure_cpu_only_runtime()
+
+
 def setup_logging() -> logging.Logger:
     """Configure structured logging for Spaces runtime."""
     level_name = "DEBUG"
@@ -75,6 +117,7 @@ def log_runtime_graphics_env():
         "NVIDIA_DRIVER_CAPABILITIES",
         "VK_ICD_FILENAMES",
         "OMP_NUM_THREADS",
+        "ROBOMME_RENDER_BACKEND",
         "SAPIEN_RENDER_DEVICE",
         "MUJOCO_GL",
     ]
@@ -116,6 +159,7 @@ def build_allowed_paths():
 
 
 def main():
+    configure_cpu_only_runtime(LOGGER)
     from ui_layout import CSS, create_ui_blocks
 
     LOGGER.info("Starting Gradio real environment entrypoint: %s", __file__)

gradio-web/minimal_maniskill_cpu_step.py

@@ -0,0 +1,79 @@
+"""Minimal ManiSkill CPU sim/render sanity check.
+
+This uses an official ManiSkill environment instead of RoboMME wrappers so the
+execution path stays as small as possible.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+import warnings
+from pathlib import Path
+
+import gymnasium as gym
+import mani_skill.envs  # noqa: F401 - registers ManiSkill environments
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+SRC_DIR = PROJECT_ROOT / "src"
+
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+if str(SRC_DIR) not in sys.path:
+    sys.path.insert(0, str(SRC_DIR))
+
+import robomme  # noqa: F401,E402 - applies ManiSkill PCI render-backend patch
+
+
+os.environ.setdefault("ROBOMME_RENDER_BACKEND", "pci:0")
+
+
+warnings.filterwarnings(
+    "ignore",
+    message=r"CUDA reports that you have .* fork_rng",
+    category=UserWarning,
+)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--env-id", default="PickCube-v1")
+    parser.add_argument("--seed", type=int, default=0)
+    args = parser.parse_args()
+
+    env = gym.make(
+        args.env_id,
+        obs_mode="rgbd",
+        control_mode="pd_joint_pos",
+        render_mode="rgb_array",
+        sim_backend="physx_cpu",
+        render_backend=os.environ["ROBOMME_RENDER_BACKEND"],
+    )
+
+    try:
+        obs, info = env.reset(seed=args.seed)
+        print(f"reset ok: env_id={args.env_id}")
+        print(f"obs keys: {list(obs.keys())}")
+        print(f"info keys: {list(info.keys())}")
+
+        action = env.action_space.sample()
+        obs, reward, terminated, truncated, info = env.step(action)
+
+        rgb = obs["sensor_data"]["base_camera"]["rgb"]
+        depth = obs["sensor_data"]["base_camera"]["depth"]
+
+        print("step ok")
+        print(f"reward={reward}")
+        print(f"terminated={terminated}")
+        print(f"truncated={truncated}")
+        print(f"rgb shape={tuple(rgb.shape)} dtype={rgb.dtype}")
+        print(f"depth shape={tuple(depth.shape)} dtype={depth.dtype}")
+        print(f"info keys after step: {list(info.keys())}")
+    finally:
+        env.close()
+
+
+if __name__ == "__main__":
+    main()

gradio-web/minimal_robomme_env_cpu_step.py

@@ -0,0 +1,96 @@
+"""Minimal RoboMME custom-env CPU sanity check.
+
+This bypasses BenchmarkEnvBuilder/make_env_for_episode and instantiates a
+RoboMME custom environment class directly.
+"""
+
+from __future__ import annotations
+
+import argparse
+import faulthandler
+import os
+import sys
+import warnings
+from pathlib import Path
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+SRC_DIR = PROJECT_ROOT / "src"
+
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+if str(SRC_DIR) not in sys.path:
+    sys.path.insert(0, str(SRC_DIR))
+
+
+def configure_cpu_only_runtime() -> None:
+    os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
+    os.environ["NVIDIA_VISIBLE_DEVICES"] = "void"
+    os.environ.setdefault("ROBOMME_RENDER_BACKEND", "pci:0")
+    os.environ.pop("NVIDIA_DRIVER_CAPABILITIES", None)
+    os.environ.pop("SAPIEN_RENDER_DEVICE", None)
+    os.environ.pop("MUJOCO_GL", None)
+    if "VK_ICD_FILENAMES" not in os.environ:
+        lvp_icd = Path("/usr/share/vulkan/icd.d/lvp_icd.x86_64.json")
+        if lvp_icd.exists():
+            os.environ["VK_ICD_FILENAMES"] = str(lvp_icd)
+
+
+configure_cpu_only_runtime()
+faulthandler.enable(all_threads=True)
+
+warnings.filterwarnings(
+    "ignore",
+    message=r"CUDA reports that you have .* fork_rng",
+    category=UserWarning,
+)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--env-class", default="StopCube")
+    parser.add_argument("--seed", type=int, default=0)
+    args = parser.parse_args()
+
+    import robomme.robomme_env as robomme_env
+    from robomme.env_record_wrapper.episode_config_resolver import resolve_render_backend
+
+    env_cls = getattr(robomme_env, args.env_class)
+    env = None
+
+    print(f"instantiate start: env_class={args.env_class}", flush=True)
+    try:
+        env = env_cls(
+            obs_mode="rgb+depth+segmentation",
+            control_mode="pd_joint_pos",
+            render_mode="rgb_array",
+            reward_mode="dense",
+            sim_backend="physx_cpu",
+            render_backend=resolve_render_backend(),
+            seed=args.seed,
+        )
+        print("instantiate ok", flush=True)
+
+        obs, info = env.reset(seed=args.seed)
+        print(f"reset ok: obs keys={list(obs.keys())}", flush=True)
+        print(f"reset info keys={list(info.keys())}", flush=True)
+
+        action = env.action_space.sample()
+        obs, reward, terminated, truncated, info = env.step(action)
+        rgb = obs["sensor_data"]["base_camera"]["rgb"]
+        depth = obs["sensor_data"]["base_camera"]["depth"]
+
+        print("step ok", flush=True)
+        print(f"reward={reward}", flush=True)
+        print(f"terminated={terminated}", flush=True)
+        print(f"truncated={truncated}", flush=True)
+        print(f"rgb shape={tuple(rgb.shape)} dtype={rgb.dtype}", flush=True)
+        print(f"depth shape={tuple(depth.shape)} dtype={depth.dtype}", flush=True)
+        print(f"step info keys={list(info.keys())}", flush=True)
+    finally:
+        if env is not None:
+            env.close()
+
+
+if __name__ == "__main__":
+    main()

gradio-web/test/test_episode_builder_cpu_backend.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import sys
+import types
+
+
+class _FakeEnv:
+    pass
+
+
+class _FakeDemonstrationWrapper:
+    last_env = None
+    last_kwargs = None
+
+    def __init__(self, env, **kwargs):
+        type(self).last_env = env
+        type(self).last_kwargs = kwargs
+        self.env = env
+
+
+class _FakeFailAwareWrapper:
+    last_env = None
+
+    def __init__(self, env):
+        type(self).last_env = env
+        self.env = env
+
+
+def test_builder_make_env_for_episode_forces_cpu_backends(monkeypatch, reload_module):
+    resolver = reload_module("robomme.env_record_wrapper.episode_config_resolver")
+    captured = {}
+
+    monkeypatch.setitem(
+        sys.modules,
+        "robomme.env_record_wrapper.DemonstrationWrapper",
+        types.SimpleNamespace(DemonstrationWrapper=_FakeDemonstrationWrapper),
+    )
+    monkeypatch.setitem(
+        sys.modules,
+        "robomme.env_record_wrapper.FailAwareWrapper",
+        types.SimpleNamespace(FailAwareWrapper=_FakeFailAwareWrapper),
+    )
+
+    def fake_make(env_id, **kwargs):
+        captured["env_id"] = env_id
+        captured["kwargs"] = kwargs
+        return _FakeEnv()
+
+    monkeypatch.setattr(resolver.gym, "make", fake_make)
+
+    builder = resolver.BenchmarkEnvBuilder(
+        env_id="BinFill",
+        dataset="train",
+        action_space="joint_angle",
+        gui_render=False,
+    )
+    monkeypatch.setattr(builder, "resolve_episode", lambda episode_idx: (123, "hard"))
+
+    env = builder.make_env_for_episode(7)
+
+    assert captured["env_id"] == "BinFill"
+    assert captured["kwargs"]["obs_mode"] == "rgb+depth+segmentation"
+    assert captured["kwargs"]["control_mode"] == "pd_joint_pos"
+    assert captured["kwargs"]["render_mode"] == "rgb_array"
+    assert captured["kwargs"]["reward_mode"] == "dense"
+    assert captured["kwargs"]["sim_backend"] == "physx_cpu"
+    assert captured["kwargs"]["render_backend"] == "pci:0"
+    assert captured["kwargs"]["seed"] == 123
+    assert captured["kwargs"]["difficulty"] == "hard"
+    assert _FakeDemonstrationWrapper.last_kwargs["gui_render"] is False
+    assert _FakeFailAwareWrapper.last_env is env.env
+
+
+def test_builder_make_env_for_episode_honors_render_backend_override(monkeypatch, reload_module):
+    resolver = reload_module("robomme.env_record_wrapper.episode_config_resolver")
+    captured = {}
+
+    monkeypatch.setitem(
+        sys.modules,
+        "robomme.env_record_wrapper.DemonstrationWrapper",
+        types.SimpleNamespace(DemonstrationWrapper=_FakeDemonstrationWrapper),
+    )
+    monkeypatch.setitem(
+        sys.modules,
+        "robomme.env_record_wrapper.FailAwareWrapper",
+        types.SimpleNamespace(FailAwareWrapper=_FakeFailAwareWrapper),
+    )
+
+    def fake_make(env_id, **kwargs):
+        captured["env_id"] = env_id
+        captured["kwargs"] = kwargs
+        return _FakeEnv()
+
+    monkeypatch.setattr(resolver.gym, "make", fake_make)
+    monkeypatch.setenv("ROBOMME_RENDER_BACKEND", "pci:42")
+
+    builder = resolver.BenchmarkEnvBuilder(
+        env_id="BinFill",
+        dataset="train",
+        action_space="joint_angle",
+        gui_render=False,
+    )
+    monkeypatch.setattr(builder, "resolve_episode", lambda episode_idx: (None, None))
+
+    builder.make_env_for_episode(1)
+
+    assert captured["kwargs"]["render_backend"] == "pci:42"
+
+
+def test_robomme_patches_maniskill_to_preserve_pci_render_backend(reload_module):
+    robomme = reload_module("robomme")
+    assert robomme is not None
+
+    from mani_skill.envs.utils.system import backend as ms_backend
+
+    backend_name, device_id = ms_backend.parse_backend_device_id("pci:0000:00:00.0")
+
+    assert backend_name == "pci:0000:00:00.0"
+    assert device_id is None

gradio-web/test/test_main_launch_config.py

@@ -1,7 +1,13 @@
 from __future__ import annotations
 
+import os
 import sys
 import types
+from pathlib import Path
+
+
+DEFAULT_LLVMPipe_ICD = "/usr/share/vulkan/icd.d/lvp_icd.x86_64.json"
+DEFAULT_CPU_RENDER_BACKEND = "pci:0"
 
 
 class _FakeDemo:
@@ -15,7 +21,14 @@ class _FakeDemo:
         return None
 
 
-def test_main_launch_passes_ui_css(monkeypatch, reload_module):
+def test_main_launch_passes_ui_css_and_forces_cpu_runtime(monkeypatch, reload_module):
+    monkeypatch.setenv("CUDA_VISIBLE_DEVICES", "0")
+    monkeypatch.setenv("NVIDIA_VISIBLE_DEVICES", "all")
+    monkeypatch.setenv("SAPIEN_RENDER_DEVICE", "cuda")
+    monkeypatch.setenv("NVIDIA_DRIVER_CAPABILITIES", "compute,utility,graphics")
+    monkeypatch.setenv("VK_ICD_FILENAMES", "/tmp/nvidia_icd.json")
+    monkeypatch.setenv("MUJOCO_GL", "egl")
+
     main = reload_module("main")
     fake_demo = _FakeDemo()
     fake_ui_layout = types.SimpleNamespace(
@@ -25,6 +38,12 @@ def test_main_launch_passes_ui_css(monkeypatch, reload_module):
 
     monkeypatch.setitem(sys.modules, "ui_layout", fake_ui_layout)
     monkeypatch.setenv("PORT", "7861")
+    monkeypatch.setenv("CUDA_VISIBLE_DEVICES", "2")
+    monkeypatch.setenv("NVIDIA_VISIBLE_DEVICES", "all")
+    monkeypatch.setenv("SAPIEN_RENDER_DEVICE", "cuda")
+    monkeypatch.setenv("NVIDIA_DRIVER_CAPABILITIES", "graphics")
+    monkeypatch.setenv("VK_ICD_FILENAMES", "/tmp/another_nvidia_icd.json")
+    monkeypatch.setenv("MUJOCO_GL", "egl")
 
     main.main()
 
@@ -34,3 +53,85 @@ def test_main_launch_passes_ui_css(monkeypatch, reload_module):
     assert fake_demo.launch_kwargs["theme"] == fake_demo.theme
     assert fake_demo.launch_kwargs["css"] == fake_ui_layout.CSS
     assert fake_demo.launch_kwargs["head"] == fake_demo.head
+    assert os.environ["CUDA_VISIBLE_DEVICES"] == "-1"
+    assert os.environ["NVIDIA_VISIBLE_DEVICES"] == "void"
+    assert os.environ["ROBOMME_RENDER_BACKEND"] == DEFAULT_CPU_RENDER_BACKEND
+    assert os.environ["VK_ICD_FILENAMES"] == "/tmp/another_nvidia_icd.json"
+    assert "NVIDIA_DRIVER_CAPABILITIES" not in os.environ
+    assert "SAPIEN_RENDER_DEVICE" not in os.environ
+    assert "MUJOCO_GL" not in os.environ
+
+
+def test_configure_cpu_only_runtime_autosets_llvmpipe_icd(monkeypatch, reload_module):
+    original_exists = Path.exists
+
+    def fake_exists(self):
+        if str(self) == DEFAULT_LLVMPipe_ICD:
+            return True
+        return original_exists(self)
+
+    monkeypatch.setattr(Path, "exists", fake_exists)
+    monkeypatch.delenv("VK_ICD_FILENAMES", raising=False)
+    monkeypatch.setenv("CUDA_VISIBLE_DEVICES", "3")
+    monkeypatch.setenv("NVIDIA_VISIBLE_DEVICES", "all")
+    monkeypatch.setenv("SAPIEN_RENDER_DEVICE", "cuda")
+    monkeypatch.setenv("NVIDIA_DRIVER_CAPABILITIES", "graphics")
+    monkeypatch.setenv("MUJOCO_GL", "egl")
+
+    main = reload_module("main")
+    monkeypatch.delenv("VK_ICD_FILENAMES", raising=False)
+
+    main.configure_cpu_only_runtime()
+
+    assert os.environ["CUDA_VISIBLE_DEVICES"] == "-1"
+    assert os.environ["NVIDIA_VISIBLE_DEVICES"] == "void"
+    assert os.environ["ROBOMME_RENDER_BACKEND"] == DEFAULT_CPU_RENDER_BACKEND
+    assert os.environ["VK_ICD_FILENAMES"] == DEFAULT_LLVMPipe_ICD
+    assert "NVIDIA_DRIVER_CAPABILITIES" not in os.environ
+    assert "SAPIEN_RENDER_DEVICE" not in os.environ
+    assert "MUJOCO_GL" not in os.environ
+
+
+def test_configure_cpu_only_runtime_preserves_existing_vk_icd(monkeypatch, reload_module):
+    monkeypatch.setenv("CUDA_VISIBLE_DEVICES", "4")
+    monkeypatch.setenv("NVIDIA_VISIBLE_DEVICES", "all")
+    monkeypatch.setenv("ROBOMME_RENDER_BACKEND", "pci:9")
+    monkeypatch.setenv("SAPIEN_RENDER_DEVICE", "cuda")
+    monkeypatch.setenv("NVIDIA_DRIVER_CAPABILITIES", "graphics")
+    monkeypatch.setenv("VK_ICD_FILENAMES", "/tmp/custom_icd.json")
+    monkeypatch.setenv("MUJOCO_GL", "egl")
+
+    main = reload_module("main")
+    monkeypatch.setenv("CUDA_VISIBLE_DEVICES", "5")
+    monkeypatch.setenv("NVIDIA_VISIBLE_DEVICES", "all")
+    monkeypatch.setenv("ROBOMME_RENDER_BACKEND", "pci:7")
+    monkeypatch.setenv("SAPIEN_RENDER_DEVICE", "cuda")
+    monkeypatch.setenv("NVIDIA_DRIVER_CAPABILITIES", "graphics")
+    monkeypatch.setenv("VK_ICD_FILENAMES", "/tmp/preserved_icd.json")
+    monkeypatch.setenv("MUJOCO_GL", "egl")
+
+    main.configure_cpu_only_runtime()
+
+    assert os.environ["CUDA_VISIBLE_DEVICES"] == "-1"
+    assert os.environ["NVIDIA_VISIBLE_DEVICES"] == "void"
+    assert os.environ["ROBOMME_RENDER_BACKEND"] == "pci:0"
+    assert os.environ["VK_ICD_FILENAMES"] == "/tmp/preserved_icd.json"
+    assert "NVIDIA_DRIVER_CAPABILITIES" not in os.environ
+    assert "SAPIEN_RENDER_DEVICE" not in os.environ
+    assert "MUJOCO_GL" not in os.environ
+
+
+def test_configure_cpu_only_runtime_clears_stale_sapien_render_device(monkeypatch, reload_module):
+    monkeypatch.setenv("SAPIEN_RENDER_DEVICE", "cpu")
+    monkeypatch.setenv("CUDA_VISIBLE_DEVICES", "7")
+    monkeypatch.setenv("NVIDIA_VISIBLE_DEVICES", "all")
+
+    main = reload_module("main")
+    monkeypatch.setenv("SAPIEN_RENDER_DEVICE", "cuda:0")
+
+    main.configure_cpu_only_runtime()
+
+    assert os.environ["CUDA_VISIBLE_DEVICES"] == "-1"
+    assert os.environ["NVIDIA_VISIBLE_DEVICES"] == "void"
+    assert os.environ["ROBOMME_RENDER_BACKEND"] == DEFAULT_CPU_RENDER_BACKEND
+    assert "SAPIEN_RENDER_DEVICE" not in os.environ

human_readme.md

@@ -15,7 +15,7 @@ uv sync
 uv pip install -e .
 ```
 
-## 🐳 Gradio Docker Deployment (HF Space + GPU)
+## 🐳 Gradio Docker Deployment (HF Space CPU-only)
 
 This repository also supports Docker deployment for the Gradio app entrypoint:
 
@@ -26,23 +26,23 @@ python3 gradio-web/main.py
 Build image:
 
 ```bash
-docker build -t robomme-gradio:gpu .
+docker build -t robomme-gradio:cpu .
 ```
 
-Run container (GPU + Vulkan for ManiSkill/SAPIEN):
+Run container:
 
 ```bash
-docker run --rm --gpus all -p 7860:7860 robomme-gradio:gpu
+docker run --rm -p 7860:7860 robomme-gradio:cpu
 ```
 
-The image sets `NVIDIA_DRIVER_CAPABILITIES=compute,utility,graphics` so the NVIDIA container runtime exposes Vulkan/graphics driver files inside the container. Without graphics capability, ManiSkill/SAPIEN may fail with `vk::createInstanceUnique: ErrorIncompatibleDriver`.
+The container forces CPU-only ManiSkill/SAPIEN backends and does not require NVIDIA runtime or `--gpus all`, which keeps it aligned with Hugging Face Docker Spaces CPU deployments.
 
 Optional metadata override:
 
 ```bash
-docker run --rm --gpus all -p 7860:7860 \
+docker run --rm -p 7860:7860 \
   -e ROBOMME_METADATA_ROOT=/home/user/app/src/robomme/env_metadata/train \
-  robomme-gradio:gpu
+  robomme-gradio:cpu
 ```
 
 Notes:
@@ -148,13 +148,18 @@ Want to add your model? Download the [dataset](https://huggingface.co/datasets/Y
 
 A1: Use a physical display or set up a virtual display for GUI rendering (e.g. install a VNC server and set the `DISPLAY` variable correctly).
 
-**Q2: Failure related to Vulkan installation.**
+**Q2: Failure related to ManiSkill/SAPIEN rendering initialization.**
 
-A2: ManiSkill/SAPIEN requires both Vulkan userspace packages inside the container and NVIDIA graphics capability exposed by the container runtime. This image installs `libvulkan1`, `vulkan-tools`, and `libglvnd-dev`, and sets `NVIDIA_DRIVER_CAPABILITIES=compute,utility,graphics`. If it still does not work, first verify the host machine itself supports Vulkan (`vulkaninfo` on the host), then switch to CPU rendering:
+A2: This Docker image is configured for CPU-only execution and should not rely on NVIDIA runtime settings. If rendering still fails, first check that no external environment variables are forcing GPU paths, then keep the container on the CPU-only defaults:
 
 ```python
-os.environ['SAPIEN_RENDER_DEVICE'] = 'cpu'
-os.environ['MUJOCO_GL'] = 'osmesa'
+os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
+os.environ['NVIDIA_VISIBLE_DEVICES'] = 'void'
+os.environ.setdefault('ROBOMME_RENDER_BACKEND', 'pci:0')  # llvmpipe software Vulkan on CPU
+os.environ.pop('SAPIEN_RENDER_DEVICE', None)
+os.environ.pop('NVIDIA_DRIVER_CAPABILITIES', None)
+os.environ.pop('MUJOCO_GL', None)
+os.environ.setdefault('VK_ICD_FILENAMES', '/usr/share/vulkan/icd.d/lvp_icd.x86_64.json')
 ```
 
 

src/robomme/__init__.py

@@ -0,0 +1,28 @@
+"""RoboMME package initialization."""
+
+from __future__ import annotations
+
+
+def _patch_maniskill_pci_render_backend() -> None:
+    """Allow ManiSkill to pass PCI-style Vulkan device strings through intact."""
+    try:
+        from mani_skill.envs.utils.system import backend as ms_backend
+    except Exception:
+        return
+
+    if getattr(ms_backend, "_robomme_pci_backend_patch", False):
+        return
+
+    original = ms_backend.parse_backend_device_id
+
+    def patched_parse_backend_device_id(backend: str):
+        if isinstance(backend, str) and backend.startswith("pci:"):
+            return backend, None
+        return original(backend)
+
+    ms_backend.parse_backend_device_id = patched_parse_backend_device_id
+    ms_backend._robomme_pci_backend_patch = True
+
+
+_patch_maniskill_pci_render_backend()
+

src/robomme/env_record_wrapper/episode_config_resolver.py

@@ -14,6 +14,7 @@ DATASET_ROOT = Path(__file__).resolve().parents[1] / "env_metadata"
 
 _ALLOWED_DATASETS = {"train", "test"}
 _ALLOWED_ACTION_SPACES = {"joint_angle", "ee_pose", "waypoint", "multi_choice"}
+_DEFAULT_CPU_RENDER_BACKEND = "pci:0"
 _DEFAULT_TASK_LIST = [
     "PickXtimes",
     "StopCube",
@@ -87,6 +88,16 @@ def get_episode_metadata(
     return metadata_index.get((task, episode))
 
 
+def resolve_render_backend(default: str = _DEFAULT_CPU_RENDER_BACKEND) -> str:
+    """Resolve the render backend for CPU-only execution.
+
+    Docker CPU mode uses llvmpipe, which SAPIEN exposes as a Vulkan PCI device
+    rather than the string "cpu".
+    """
+    value = str(os.environ.get("ROBOMME_RENDER_BACKEND", default)).strip()
+    return value or default
+
+
 class BenchmarkEnvBuilder:
     """
     Episode environment builder.
@@ -195,6 +206,8 @@ class BenchmarkEnvBuilder:
             control_mode="pd_joint_pos",
             render_mode=self.render_mode,
             reward_mode="dense",
+            sim_backend="physx_cpu",
+            render_backend=resolve_render_backend(),
         )
         if seed is not None:
             env_kwargs["seed"] = seed