RoboCasa365, a kitchen simulation benchmark for generalist robot policies

From one release to a benchmark, and what changed in between

RoboCasa is a large-scale simulation framework for training generally capable robots to perform everyday tasks. It was originally released in 2024 by UT Austin researchers, and the latest iteration, RoboCasa365, builds upon the original release with significant new functionalities to support large-scale training and benchmarking in sim.

The four pillars are what make it a benchmark rather than a set of environments. Diverse tasks, 365 of them, created with the guidance of large language models. Diverse assets, including more than 2,500 kitchen scenes and more than 3,200 3D objects. High-quality demonstrations, including more than 600 hours of human demonstrations in addition to more than 1,600 hours of robot datasets created with automated trajectory tools. And benchmarking support, covering popular policy learning methods including Diffusion Policy, pi and GR00T, plus user-submitted models on the leaderboard.

The timeline in the Updates section shows the shape of the work. The original v0.2 release on 10/31/2024 used RoboSuite v1.5 as the backend, with improved support for custom robot composition, composite controllers, more teleoperation devices and photo-realistic rendering. The RoboCasa365 release on 2/18/2026 brought the 365 tasks, the 2,500+ kitchen scenes, the 2,200+ hours of robot demonstration data and the benchmarking support.

Since then there have been three changes worth knowing about. On 4/6/2026 the leaderboard was published, comparing generalist robot policies on the multi-task learning benchmark and open to community model submissions. On 5/12/2026, v1.0.1 updated horizon lengths with a 1.5x increase across all tasks for consistency, with a request to update to the latest version for running evals. And on 7/7/2026 the target composite task datasets were updated to include per-frame subtask annotations, where every timestep is labeled with a subtask index, an atomic-skill name, a stage such as pick, place or navigate, and a natural-language instruction, to support hierarchical policy learning.

That last change is the most consequential for anyone doing hierarchical work, and it was followed on 10/14/2026 by the release of the subtask annotation pipeline, with labelers covering all 300 composite tasks, which generates per-frame subtask labels directly from each demo's simulation state.

The homepage is robocasa.ai, the papers are the RoboCasa365 paper for ICLR 2026 and the original RoboCasa paper for RSS 2024, and there is a leaderboard page and a documentation site.

The installation, and where the ten gigabytes go

RoboCasa works across all major computing platforms, and the easiest way to set up is through the Anaconda package management system. The steps are five, and the third one carries a warning in bold.

conda create -c conda-forge -n robocasa python=3.11
conda activate robocasa
git clone https://github.com/ARISE-Initiative/robosuite
cd robosuite
pip install -e .
cd ..
git clone https://github.com/robocasa/robocasa
cd robocasa
pip install -e .

The bold warning is on the robosuite step: important, use the master branch. That is a real constraint rather than a formality, because RoboCasa relies on robosuite features that are not in a released version, so a pinned robosuite will not work.

The optional extras in the same block are worth noting too. pip install pre-commit and pre-commit install sets up the code formatter, and the README gives a specific fallback for problems with numba or numpy, which is conda install -c numba numba=0.56.4 -y. That kind of pin in the documentation usually means the versions are tight, and indeed the setup.py pins numpy at 2.2.5, numba at 0.61.2, scipy at 1.15.3 and mujoco at 3.3.1 exactly.

The last step is where the size comes from:

python -m robocasa.scripts.setup_macros              # Set up system variables.
python -m robocasa.scripts.download_kitchen_assets   # Caution: Assets to be downloaded are around 10GB.

Ten gigabytes of assets, and the caution is in the README rather than buried. Those assets are the 2,500+ kitchen scenes and the 3,200+ objects, and they are the reason the download is large. The first script sets up system variables, which is the macro configuration the rest of the framework reads.

The dependency list also shows the shape of the project. Beyond the numerical stack and MuJoCo there is pygame for the interactive viewers, Pillow and opencv-python for image handling, pynput for input, h5py for the dataset format, hidapi for HID device access, and then two frameworks that matter for the training story: tianshou at 0.4.10, which is the reinforcement learning library, and lerobot at 0.3.3, the Hugging Face robot learning toolkit that the reference policies are built on.

The gym wrapper, and the demos that show what is inside

The basic usage section starts with a gym wrapper, which is the interface a training script actually uses.

import gymnasium as gym
import robocasa
from robocasa.utils.env_utils import run_random_rollouts

env = gym.make(
    "robocasa/PickPlaceCounterToCabinet",
    split="pretrain", # use 'pretrain' or 'target' kitchen scenes and objects
    seed=0 # seed environment as needed. set seed=None to run unseeded
)

# run rollouts with random actions and save video
run_random_rollouts(
    env, num_rollouts=3, num_steps=100, video_path="/tmp/test.mp4"
)

The split parameter is the one to understand. The environment is chosen by a string identifier in the form robocasa/TaskName, and the split decides whether you get the pretrain or the target kitchen scenes and objects. That is a deliberate evaluation design: a policy is trained on one set of scenes and objects and evaluated on a different one, so a policy that has memorised a layout does not get credit.

The rest of the section is a set of scripts that are worth more than the API reference for understanding what is in the framework.

python -m robocasa.demos.demo_tasks plays back a sample demonstration for a selected task, and the README notes that Mac users should prepend the python command with mj. python -m robocasa.demos.demo_kitchen_scenes explores the 2,500+ kitchen scenes, and python -m robocasa.demos.demo_objects views and interacts with both human-designed and AI-generated objects, with a flag --obj_types aigen to show the AI-generated ones instead of the objaverse ones by default.

The teleoperation script, python -m robocasa.demos.demo_teleop, lets you control the robot directly through a keyboard controller or a spacemouse, and it renders the robot semi-translucent to minimise occlusions and enable better visibility. There is one configuration detail: if you are using a SpaceMouse you may need to set SPACEMOUSE_PRODUCT_ID to your model in robocasa/macros_private.py.

Those four scripts are the fastest way to understand the framework, because they show the three things the benchmark is made of, the tasks, the scenes and the objects, without requiring you to write a training loop.

Licensing, citation and where the community sits

The licensing is split, and the split is worth reading before you build on the assets.

Code: MIT License. Assets and Datasets: CC BY 4.0.

So the framework itself is permissive, and the ten gigabytes of kitchens and objects plus the demonstration data carry an attribution requirement. For a research project that is usually fine. For a commercial product, the assets are the part that needs a look, since CC BY 4.0 allows commercial use but requires attribution and applies to adaptations.

The citation section gives the two references you need. RoboCasa365 is the inproceedings entry for the International Conference on Learning Representations, ICLR, 2026, with the title RoboCasa365: A Large-Scale Simulation Framework for Training and Benchmarking Generalist Robots, and the authors Soroush Nasiriany, Sepehr Nasiriany, Abhiram Maddukuri and Yuke Zhu. The original RoboCasa release has its own inproceedings entry for 2024. The setup.py carries the same four names as the package authors and a contact address at utexas.edu.

The repository itself is a Python package with a setup.py, a requirements.txt that contains only -e ., meaning the requirements are declared in setup.py rather than in the requirements file, a MANIFEST.in, a .pre-commit-config.yaml, a docs/ directory, a robocasa/ package directory and a tests/ directory. The package name is robocasa and the version in setup.py is 1.0.1, matching the May 2026 release.

The contact address for questions about the benchmark or the submission process is [email protected], which is a group rather than an individual, and the README points to the documentation site for the material on tasks, datasets and benchmarking rather than duplicating it.

The overall picture is a benchmark that has made a deliberate shift from being a research demonstration to being an evaluation standard, with the leaderboard, the released assets and the annotation pipeline as the evidence. For someone entering the field, that shift is the reason to use it rather than to build a private environment set: the numbers are comparable because everyone is using the same scenes, the same horizon lengths and the same subtask labels.

Editorial conclusion

RoboCasa365 suits a robotics researcher who wants a single benchmark with enough scene and object diversity to expose a policy that has overfitted to a handful of kitchen layouts, and it suits someone who wants to compare against published numbers through the leaderboard. It is the wrong choice for a team that just needs a MuJoCo environment to test a grasping idea, because the ten gigabyte asset download and the robosuite master branch requirement are a large commitment for that, and it is the wrong choice if you need a permissive licence for your assets, since the code is MIT but the assets and datasets are CC BY 4.0. Before starting, read the version notes for v1.0.1, because the horizon lengths increased by 1.5x across all tasks and the README asks you to update before running evals.

Frequently asked questions

Official sources

1. Issues
2. Project website
3. README
4. Releases
5. robocasa/robocasa on GitHub