DM0.5 Open-Source VLA: Deploy Robot Policies on a 4090 - Aoyii

DM0.5 is the strongest open-source Vision-Language-Action (VLA) model you can deploy today: 4B parameters, Apache-2.0 license, #1 on the RoboDojo sim-and-real benchmark, and fine-tunable on a single RTX 4090 in about 18 hours. This guide goes end to end with the OpenDM repository — Docker setup, inference service, dataset registration, and SFT — so you can get from git clone to a working robot-policy endpoint in one afternoon.

Why this matters

Open robot foundation models are rare; open ones that beat closed competition are rarer. Dexmal released DM0.5's weights (Hugging Face, ModelScope) and code (GitHub, Apache-2.0) right after the model topped RoboDojo, a vendor-neutral sim-and-real benchmark run by a non-profit academic consortium. On RoboChallenge Table 30 v2 it scores 54.42 (43% success) vs Pi0.5's 31.48 (14.3%), and it hits 99.0% on LIBERO. The leaderboard is secondary — the real signal is that a 4B model achieves this with one GPU for inference and one 4090 for fine-tuning. That changes who can build on top of robot foundation models.

What DM0.5 is

DM0.5 is Dexmal's second-generation embodied-native VLA, trained from scratch on 150,000 hours of data: 50,000 hours of high-precision real-robot manipulation plus 100,000 hours of egocentric video, with 1M m² of scene reconstruction data to shrink the sim-to-real gap. Four architecture decisions stand out:

Context abstraction layer — native memory of up to 60 seconds (most VLAs keep under 10), so long-horizon multi-step tasks don't lose state.
Embodied chain-of-thought — the model decomposes an instruction into subtasks, plans the order, then executes, instead of mapping pixels to actions in a single shot.
Trajectory alignment layer — learns motion regularity rather than point-to-point targets, which is what makes cross-embodiment transfer work.
Sys1/Sys2 split — fast reactive control plus deliberate planning, hardened against camera shake and human interruptions.

It also unlocks video prompting: show the model a human demonstration clip and it follows the task directly, no language needed. Benchmarks vs Pi0.5: LIBERO 99.0% vs 96.9%, RoboTwin2.0 clean 93.6% vs 82.7%, VLA-Arena L0 89.0% vs 64.3%. Inference runs at about 90ms on a 4090 and 50ms on an H100.

Environment setup: Docker or local

The repo recommends Docker first — it sidesteps CUDA/PyTorch/flash-attn version mismatches. Requirements: Ubuntu 20.04/22.04, NVIDIA driver, Docker, NVIDIA Container Toolkit.

git clone https://github.com/dexmal/opendm.git
cd opendm

docker run -it --rm --gpus all --network host \
  --name opendm --shm-size=16g \
  -v "$PWD":/app/opendm -w /app/opendm \
  dexmal/opendm:latest /bin/bash

# inside the container
conda activate opendm
pip install -e .

Prefer local install? Use a Conda env with Python 3.10, PyTorch from the cu128 index, and flash-attn:

conda create -n opendm python=3.10 -y
conda activate opendm
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu128
pip install ninja packaging
MAX_JOBS=2 pip install flash-attn --no-build-isolation
cd opendm && pip install -e .

There is also a fast inference backend (pip install -e ".[fast-infer]") built on TensorRT + Triton + PyTorch FlexAttention; skip it unless you need low startup latency.

Run inference

Download the DM05 base checkpoint and launch the HTTP service (default port 7891):

huggingface-cli download Dexmal/DM05 --local-dir ./checkpoints/DM05

script/dm05_launcher.sh \
  --exp opendm/exp/dm05_exp.py \
  --task inference \
  --model-config.model-name-or-path ./checkpoints/DM05 \
  --model-config.chunk-size 50 \
  --inference-config.output-action-dim 14 \
  --inference-config.image-prompts "Head" "Left wrist" "Right wrist" \
  --inference-config.port 7891

This example uses three camera streams and a 14-dim state/action space. Use /v1/infer for new integrations (the legacy /process_frame API is being phased out). Check the inference guide for robot profiles, request fields, and the fast-backend setup.

Fine-tune on your own robot data

# opendm/dataset/my_robot.py
from opendm.constants.robot import RobotStateDesc, RobotType
from opendm.dataset.register import register_dataset

MY_ROBOT_STATE_DESC = (
    [RobotStateDesc.JOINT] * 6 + [RobotStateDesc.GRIPPER]
    + [RobotStateDesc.JOINT] * 6 + [RobotStateDesc.GRIPPER]
)

register_dataset({
    "my_robot": {
        "jsonl_dir": "./assets/my_robot/",
        "image_dir": "./assets/my_robot/",
        "image_keys": ["images_1", "images_2", "images_3"],
        "image_prompts": ["Head", "Left wrist", "Right wrist"],
        "robot_type": RobotType.ALOHA,
        "state_desc": MY_ROBOT_STATE_DESC,
    },
})

Then run SFT. Eight GPUs are recommended for training (one GPU is fine for inference):

script/dm05_launcher.sh \
  --exp playground/dm05_sft_demo.py \
  --task train --nproc_per_node 8 \
  --data-config.dataset-name my_robot \
  --model-config.model-name-or-path ./checkpoints/DM05 \
  --model-config.chunk-size 50 \
  --trainer-config.num-train-steps 50000

Dexmal says a new downstream task can be fine-tuned to expert level on one RTX 4090 in about 18 hours — a 60% cost cut vs the previous generation. The repo ships end-to-end benchmark guides (LIBERO, RoboTwin2.0, VLA-Arena, SO101 LoRA, RoboChallenge Table 30 v2) if you want to reproduce the numbers yourself.

Practice advice

Start with the built-in demo dataset and playground/dm05_sft_demo.py before touching your own robot data — verify the data format, normalization stats, and the inference round-trip first.
One GPU is enough to serve inference; scale to 8 for training. Consumer 4090s work for both.
If you have a non-standard arm, register it through the dataset config — DM0.5 already covers ALOHA, ARX, UR, W1, Unitree G1, and more, and the same base model transfers across embodiments.
For production, enable the fast backend and budget for the one-time ONNX export plus TensorRT engine build on first launch.
The model is hardened against camera disturbance and human interruption, but retest those failure modes on your own rig before deploying.

For broader context on getting embodied models into real deployments, see our piece on the embodied AI mass-production wall, and for training-environment tooling, check out EnvHarness.

Resources

Code: github.com/dexmal/opendm (Apache-2.0)
Weights: Hugging Face Dexmal/DM05 | ModelScope
Technical blog: dexmal.com/blog/dm0.5
RoboDojo benchmark: github.com/RoboDojo-Benchmark/RoboDojo (arXiv:2607.04434)
MaaS: maas.dexmal.com

FAQ

Q: Can I try DM0.5 without owning a robot?
A: Yes. The repo includes simulation benchmarks (LIBERO, RoboTwin2.0) that run on a single GPU inside the Docker image, so you can evaluate the checkpoint before touching hardware.

Q: What GPU do I need to fine-tune DM0.5?
A: One RTX 4090 is enough — about 18 hours for a new downstream task at expert level. Scale to 8 GPUs (A100/H100/H20) for larger training runs.

Q: Does DM0.5 work with my robot arm?
A: It ships with multi-embodiment support covering ALOHA, ARX, UR, W1, Unitree G1 and others. For a new arm, register your joint and gripper layout in a dataset config, then fine-tune.