GigaWorld-1: Building World Models for Robot Policy Evaluation

What GigaWorld-1 is for in a robot policy loop

Evaluating a robot policy on real hardware is slow, and every policy revision costs another round of physical trials. GigaWorld-1 takes the other route: it is a world model that generates video rollouts conditioned on actions, so a policy can be scored against generated futures before it touches a robot. The README frames the whole repository as "A Roadmap to World Models for Robot Policy Evaluation", and the release history shows the intent is broader than a single checkpoint. The project also ran a CVPR 2026 World Model Challenge and publishes a leaderboard, which tells you the authors expect outside submissions rather than a closed internal benchmark.

The target user is a robotics or video-generation researcher with a Linux workstation and enough GPU memory to train or at least run a 1.3B or 5B diffusion model. The repository assumes you can read a DeepSpeed launch command and a YAML config without hand-holding. If you want a packaged simulator with a Python API and no training step, this is not that project, and the open-source progress table says so plainly.

How the training and inference pipeline is put together

The architecture visible in the repository is a two-stage diffusion pipeline. Stage 1 is controllable pre-training, driven by train_gigaworld_functrl_uni_stage1.py, with separate Nano (1.3B) and Pro (5B) configurations and DeepSpeed ZeRO-2/3 support. Stage 2 is DMD2 distillation, driven by train_gigaworld_functrl_uni_stage2_dmd.py, which the README describes as producing 4 to 6 step sampling. The two-stage split is the core design choice: train a large model for quality, then distill it for a sampling budget that makes rollout generation practical.

Inference is split into image-to-video and text-to-video one-click scripts, and the README states the output runs at 10 FPS with 33 second rollouts. Data enters through a LeRobot-style pipeline that is converted into the GigaWorld format, with Qwen3-VL used for captions and Depth Anything V2 for depth. That preprocessing stage is marked beta, which matters: caption and depth quality feed directly into what the world model learns, so a schema mismatch upstream shows up as bad rollouts downstream, not as an error message.

The dependency list confirms the stack. requirements.txt pins diffusers>=0.35.0, transformers>=4.45.0, peft>=0.12.0, xformers>=0.0.28.post3 and deepspeed==0.19.2. The diffusers entry is worth noting because the README labels it "Custom" in the badge row, so the project is not tracking stock diffusers behaviour exactly.

Installing GigaWorld-1 and running a first inference

The README documents Linux as the supported platform, Python 3.10 or newer, and PyTorch 2.x. The repository ships an install.sh at the top level alongside requirements.txt, so the intended path is to run the script rather than install packages one at a time. The README does not document what install.sh does internally, so read it before running it on a shared machine.

Start by cloning the repository and running the installer from the repository root:

cd giga-world-1
bash install.sh

If you prefer to manage the environment yourself, requirements.txt is the authoritative list. Note the pinned DeepSpeed version and the xformers floor:

pip install -r requirements.txt

Model weights are not in the repository. The README points to open-gigaai/Giga-World-1 on Hugging Face and to the ModelScope mirror at modelscope.cn/models/GigaAI/Giga-World-1. The repository also contains a tools/ directory and an example/ directory with .ms_upload_cache, which suggests the download tooling is scripted rather than manual. The README does not spell out the exact download command, so check tools/ for the entry point.

For a first real run, the README lists one-click image-to-video and text-to-video scripts under the inference section, with the code living in infer/. The expected result is a video file at 10 FPS covering a 33 second rollout. Before pointing it at your own robot data, run it against the toy dataset at open-gigaai/Giga-World-1-Toydata, which exists specifically so you can confirm the pipeline works end to end without preparing a full dataset.

What is not released yet, and where that bites

The open-source progress table is unusually candid, and it is the single most important thing to read before committing engineering time. Stage-2 distilled weights are marked red, meaning the 4 to 6 step checkpoints are not available. The training code for DMD2 distillation is green, so you can produce those weights yourself, but you cannot download them and skip the compute.

Three more items are red: RL post-training scripts for 3D scene modeling, other-domain weights and their training recipes, and an acceleration framework for distributed inference and training. The data preprocessing pipeline and the WMBench benchmark are both yellow, meaning beta and partial. WMBench is described as 15 fine-grained metrics with a leaderboard and VLM judging, but only part of it is open.

The practical consequence is that the released path is Stage-1 training plus Stage-2 distillation you run yourself, followed by inference. Anyone expecting to download a fast distilled model and generate rollouts in minutes will be disappointed. The README's own advice is to subscribe to releases on GitHub, which is a reasonable signal that the maintainers know the gaps are load-bearing for users.

One more constraint: the repository is Linux-only per the platform badge. There is no documented macOS or Windows path, and the DeepSpeed dependency makes that unlikely to change casually.

GigaWorld-1 against a physics simulator

The obvious alternative for policy evaluation is a conventional physics simulator, and the difference in approach is fundamental rather than incremental. A physics engine computes contact forces and rigid-body dynamics from a scene description; it is deterministic given a seed, its failures are diagnosable, and it does not need training data. GigaWorld-1 learns appearance and motion from video, so it can represent cloth, fluids, deformable objects and camera artefacts that a rigid-body engine handles poorly or not at all.

The cost is that GigaWorld-1 inherits the failure modes of generative video. It can produce visually plausible rollouts that are physically wrong, and there is no solver to inspect when that happens. Its fidelity is bounded by the data it was trained on, which is why the LeRobot-style conversion pipeline and the Qwen3-VL captioning step matter so much. If your evaluation question is about contact-rich manipulation where a wrong contact normal changes the answer, a physics simulator is still the better instrument. If your question is about whether a policy produces sensible behaviour in visually varied scenes, generated rollouts cover ground a simulator will not.

The WMBench leaderboard is the project's own attempt to make that trade-off measurable, with 15 metrics and VLM judging. VLM judging is itself a modelling choice with its own error profile, and the README does not document how judge disagreement is handled.

Maintenance, licence and the cost of staying current

The repository is not archived, and the last push was on 2026-07-12. The README's open-source progress table is dated 2026-07, so the published state and the code state line up. There are no retrieved releases, which means there are no tagged versions to pin against; you are tracking main. For a research codebase that is normal, but it means an upgrade is a diff review rather than a version bump, and you should record the commit hash you built against.

Upgrade cost concentrates in three places. DeepSpeed is pinned exactly at 0.19.2 in requirements.txt, so a DeepSpeed upgrade is a deliberate change, not something pip will do behind you. The diffusers badge reads "Custom", which suggests local modifications or reliance on behaviour that may shift between upstream versions. And the data format is defined by the preprocessing pipeline, which is beta, so a format change would require reprocessing your dataset rather than just reinstalling.

On licensing: the repository is Apache-2.0, which permits commercial use and modification with the usual notice and patent grant conditions. That covers the code in this repository. It does not automatically cover the model weights, the toy dataset, or the CVPR 2026 World Model Track dataset, each of which is hosted separately on Hugging Face and ModelScope under its own terms. Check those pages before using weights or data in anything you ship. This is a description of what the licence identifiers say, not legal advice.

Editorial conclusion

Adopt GigaWorld-1 if you already have a Linux machine with recent PyTorch and you want to train or fine-tune a controllable video world model for policy evaluation, and you accept that the Stage-2 distilled weights, the RL post-training scripts and the acceleration framework are still marked coming soon. Do not adopt it if you need a drop-in simulator with a stable API and no training step, or if you are not on Linux. Verify first that the Hugging Face or ModelScope weights download completes, that install.sh resolves your CUDA and PyTorch versions, and that the toy dataset in example/toy_datapipeline_dataset/ matches the schema your own data will take.

Frequently asked questions

Official sources

1. Issues
2. License: Apache-2.0
3. open-gigaai/giga-world-1 on GitHub
4. README