---
license: mit
library_name: pytorch
pipeline_tag: robotics
tags:
- robotics
- world-model
- robot-learning
- manipulation
- flow-matching
- video-action-model
- InternW0
language:
- en
---

# InternW0-Base

[![Paper](https://img.shields.io/badge/Paper-arXiv%202609.27656-b31b1b)](https://arxiv.org/abs/2609.27656)
[![Project](https://img.shields.io/badge/Project-InternW0-2f80ed)](https://internrobotics.github.io/internw0)
[![Code](https://img.shields.io/badge/Code-GitHub-181717?logo=github)](https://github.com/InternRobotics/InternW0)
[![Downloads last month](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fhuggingface.co%2Fapi%2Fmodels%2FInternRobotics%2FInternW0-Base&query=%24.downloads&label=downloads%20last%20month&logo=huggingface)](https://huggingface.co/InternRobotics/InternW0-Base)

## Model description

**InternW0** is a physical world-action model that couples future visual prediction and continuous robot control through an asymmetric video-action architecture. Its high-capacity VideoDiT expert produces reusable longer-horizon predictive context, while a faster ActionDiT expert generates action chunks. Observation-conditioned K/V routing adapts cached video context to newly observed states, so InternW0 can *predict slowly and act quickly*.

This repository releases the model-only **InternW0-Base** initialization derived from heterogeneous pretraining step 30,000. The release contains a native PyTorch checkpoint with the embedded InternW0 behavior contract. It is intended for **RoboTwin target-domain posttraining**; it is not a standalone Transformers model and has not been task-posttrained in this repository.

The InternW0 architecture uses:

- a Wan2.2-TI2V-5B-based VideoDiT planner (30 layers, hidden size 3072);
- a lightweight ActionDiT executor (30 layers, hidden size 1024);
- continuous flow matching for video and action generation;
- observation-conditioned chunk K/V routing between the two experts;
- an external frozen Wan2.2 VAE and UMT5 text encoder;
- an external frozen DINOv3 ViT-B/16 observation encoder (`384x320` input, 768-D features);
- an 8-token target soft-prompt bank and a 37-dimensional canonical action/proprio interface.

## Files and integrity

| File | Purpose | Size | SHA-256 |
|---|---|---:|---|
| `config.json` | Machine-readable model manifest | 1,272 bytes | `3d08fb9d68b8ec2f0a6f0117506850de812d5fbe358370ca7a4cbd799700c602` |
| `InternW0-Base.pt` | Model-only native checkpoint | 29,410,738,430 bytes | `131d00c241c88fdd1f14cafb3d9fe7c33388f3bff55ff10397105d9fe6e5f3ac` |
| `pytorch_model.bin` | Zero-copy LFS alias of `InternW0-Base.pt` for PyTorch download statistics | Same LFS object | `131d00c241c88fdd1f14cafb3d9fe7c33388f3bff55ff10397105d9fe6e5f3ac` |
| `normalization.json` | RoboTwin action/proprio normalization contract | 4,047 bytes | `0ba957c35cd08f05b55f6a4a08b7e19c784e3816dd15fdb73135a4d1b334340f` |
| `InternW0-Base.transfer.json` | Full source-to-target transfer/provenance sidecar | 307,131 bytes | `3d911a075ef680cc8edfa009b4e06a050dc000bc04182341772d9ec35207f568` |
| `LICENSE` | Weight release license | 1,205 bytes | `b1d3d0160bdd9748bfc4e8acb9ab8fbce7ab725c827fd6fc673261f57aae0306` |

Checkpoint summary:

- Source pretraining step: `30000`
- Source format: `rlh-fastwam-canonical-2`
- Parameters/tensor elements: 7,352,528,643 (serialized in float32)
- Checkpoint tensors: 1,977
- Optimizer state: excluded
- Target domain: `robotwin_wam/aloha`
- Target conversion: `new_domain`, seed 42
- Action horizon: 64
- Action chunk size: 16
- Video plan horizon: 96 action ticks
- Video/action stride: 8
- Soft-prompt tokens: 8 per chunk
- Action/proprio dimensionality: 37, with 14 valid RoboTwin ALOHA slots

The conversion copies shared VideoDiT, ActionDiT, OVCR, and projector weights from pretraining step 30,000. The one-row RoboTwin domain bank, action encoder/head, soft-prompt bank, and default proprio encoder are initialized for the target interface with seed 42. This distinction is recorded tensor-by-tensor in `InternW0-Base.transfer.json`.

Hugging Face uses library-specific query files for model download statistics. For the `pytorch` library, the Hub counts HTTP `GET` and `HEAD` requests to `pytorch_model.bin`. This repository therefore provides `pytorch_model.bin` as a second path to the exact same LFS object as `InternW0-Base.pt`; it adds no meaningful storage overhead and has the same SHA-256. The badge above reads the public `downloads` field from the Hub API, which corresponds to downloads in the last 30 days. Hub analytics are aggregated and may lag briefly before counters refresh.

## Required external assets

This checkpoint is not self-contained. To load or posttrain it, obtain the external frozen assets separately and comply with their licenses:

```bash
hf download Wan-AI/Wan2.2-TI2V-5B --local-dir assets/wan22
hf download facebook/dinov3-vitb16-pretrain-lvd1689m \
  --local-dir assets/dinov3-vitb16-pretrain-lvd1689m
```

The code expects the complete Wan2.2 directory, including the diffusion model, VAE, tokenizer/text encoder assets, and the DINOv3 ViT-B/16 weights. RoboTwin data must be prepared with the repository's preprocessing scripts.

## Quick start for RoboTwin posttraining

### 1. Install the codebase

```bash
git clone https://github.com/InternRobotics/InternW0.git
cd InternW0

conda create -n w0 python=3.10 -y
conda activate w0
pip install -U pip setuptools wheel
pip install torch==2.7.1 torchvision==0.22.1 \
  --extra-index-url https://download.pytorch.org/whl/cu128
pip install -e .
```

### 2. Download this checkpoint and its contracts

```bash
hf download InternRobotics/InternW0-Base \
  config.json pytorch_model.bin normalization.json InternW0-Base.transfer.json \
  --local-dir assets/robotwin
mv assets/robotwin/pytorch_model.bin assets/robotwin/InternW0-Base.pt
```

### 3. Prepare assets and launch

```bash
export W0_WAN_MODEL_DIR="$PWD/assets/wan22"
export W0_DINO_WEIGHTS="$PWD/assets/dinov3-vitb16-pretrain-lvd1689m"
export W0_ROBOTWIN_DATA="$PWD/data/robotwin"
export W0_ROBOTWIN_STATS="$PWD/assets/robotwin/normalization.json"
export W0_ROBOTWIN_INIT="$PWD/assets/robotwin/InternW0-Base.pt"

python scripts/prepare_robotwin_text_embeds.py \
  --dataset-root "$W0_ROBOTWIN_DATA"

# If you need to regenerate statistics for a new export:
python scripts/prepare_robotwin_stats.py \
  --root "$W0_ROBOTWIN_DATA" \
  --output "$W0_ROBOTWIN_STATS"

bash scripts/train_zero1.sh 8 \
  --config-name posttrain_robotwin_clean_64gpu
```

Use `init_checkpoint=W0_ROBOTWIN_INIT` semantics: model weights are loaded, while optimizer state and progress begin a new run. Do not treat this file as a resume checkpoint.

## Training overview

InternW0 was pretrained on approximately 7,200 hours of heterogeneous robot and egocentric video data. Robot states and actions are mapped to a unified 37-dimensional interface with validity masks. Action-labeled robot trajectories supervise both future video and action flow matching; action-free egocentric video contributes video supervision. Domain-specific soft prompts and input/output projections support heterogeneous embodiments.

During action-supervised training, an independently denoised video stream supplies layerwise K/V predictive context to the action expert through the observation-conditioned routing interface. At inference, generated future video replaces the ground-truth condition stream, and its K/V cache is reused and adapted for each action chunk.

See [the paper](https://arxiv.org/abs/2609.27656) and [project page](https://internrobotics.github.io/internw0) for the full data recipe, architecture details, and evaluation protocol.

## Intended uses

- Research on world-action models, vision-language-action policies, and robot manipulation.
- RoboTwin target-domain posttraining as an initialization checkpoint.
- Study of asynchronous video/action inference, context routing, soft prompts, and cross-embodiment interfaces.
- Reproduction and extension of InternW0 experiments under the MIT license.

## Limitations

- This artifact is a pre-posttraining initialization, not a deployed robot controller and not a turnkey inference service.
- It requires the InternW0 codebase, external Wan2.2 and DINOv3 assets, task data, normalization statistics, and substantial compute.
- It is not directly compatible with `transformers.AutoModel`; use the native `w0` checkpoint loader.
- Robotic policies must be validated in simulation and under appropriate safety controls before any real-robot experiment.
- The checkpoint does not include the contact-aware posttrained force/tactile extensions described as separate downstream experiments in the paper.

## License

The weights in this repository are released under the [MIT License](./LICENSE), except for third-party assets that users obtain separately and use under their original licenses.

## Citation

If you use InternW0, please cite:

```bibtex
@article{internw0,
  title = {InternW0: A Foundational Physical World Model for Efficient Real-World Interactions},
  author = {Jisong Cai and Yao Mu and Ganlin Yang and Zhe Cao and Zhangzheng Tu and Xing Gao and Kailin Li and Xinyu Zhan and Lixin Yang and Yangkun Zhu and Haoxiang Ma and Ming Zhou and Qiaojun Yu and Yufei Xue and Liqun He and Yifei Yao and Yifan Zhu and Long Ling and Bingqi Jiang and Haoyu Guo and Xueyue Zhu and Bowen Zhou and Bin Zhao and Tianfan Xue and Chunhua Shen and Weinan Zhang},
  journal = {arXiv preprint arXiv:2609.27656},
  year = {2026}
}
```