Datasets:

MLL-Lab
/

embodied-exam-data

v2 (2026-10-16): masters must be above 1080p (2560x1440 is the target), and every frame must be ray traced or path traced. Rasterized renders are no longer accepted. See section 9. v1 was 2026-10-07.

The Embodied First Exam site shows two kinds of media from every suite:

one teaser video, which plays in the scrolling wall on the home page and on the suite page;
one media item per task, which appears in the task list.

Most of what we show today is far below the quality of the simulators we use: 360x360 clips, 480p screen grabs at 15 fps, and one generic scene image shared by dozens of tasks. This page sets the bar and explains how to reach it.

1. The bar

Resolution: above 1080p. Render natively at 2560x1440 (2K), 16:9. 1920x1080 is no longer accepted. 3840x2160 counts as excellent.
Ray tracing or path tracing, always. Never rasterization.
- Rasterizers are not accepted. These include OpenGL/EGL renders, MuJoCo's built-in renderer, Genesis's default rasterizer, SAPIEN's default shader, PyBullet's renderer, and Blender Eevee or Workbench.
- Section 2 lists the switch for each simulator.
- If your simulator has no ray tracer, record the poses per frame and render them in Blender Cycles (section 2). A cinematic look is welcome there.
A hard teaser. Pick one of your suite's hardest tasks, ideally one that no evaluated agent solves (for example, GPT-6 Astra fails it), and show it solved.
Every task gets media. A video is the default, made to the same spec. Use a still only when a video is truly impossible, and the still must still be high quality and show the task clearly.

	Required	Excellent
Resolution	above 1920x1080, 16:9, rendered at that size (no upscaling); the target is 2560x1440	3840x2160
Frame rate	30 fps, constant	60 fps
Rendering	ray tracing or path tracing (never rasterization), full-resolution textures	path tracing with a denoiser, e.g. Blender Cycles with a cinematic look
Encoding	H.264 or H.265, yuv420p, CRF 18 or lower	CRF 16, or lossless frames

Deliver master files. The site makes its own web copies, so never compress for the web yourself.

2. Recipes by simulator

All of these were used for the 2026-10-07 renders of BEHAVIOR-1K, RoboLab, ManiGuard and RoboWits. Timings were measured on a shared RTX PRO 6000.

Isaac Sim / Isaac Lab (e.g. RoboLab)

Switch the renderer to path tracing:

import carb
s = carb.settings.get_settings()
s.set("/rtx/rendermode", "PathTracing")
s.set("/rtx/pathtracing/spp", 16)            # samples per pixel per frame
s.set("/rtx/pathtracing/totalSpp", 16)
s.set("/rtx/pathtracing/maxBounces", 6)
s.set("/rtx/pathtracing/optixDenoiser/enabled", True)
s.set("/rtx/pathtracing/fireflyFilter/enabled", True)

After each physics step, render enough sub-frames to accumulate the samples before you capture the frame. With Replicator, that is rt_subframes.
Render only the presentation camera. Shrink or switch off the observation cameras.
Timings:
- 1080p at 16 spp: about 0.45 s per frame;
- 1440p at 32 spp: about 0.95 s per frame.
Reusing one Isaac app for many tasks cuts scene setup from about 140 s to a few seconds.

OmniGibson (BEHAVIOR-1K, ManiGuard)

Path tracing works the same way as in Isaac above.
- RTX Real-Time 2.0 (RealTimePathTracing in recent Isaac Sim) is a good fast option: about 0.3 s per frame at 1080p.
- Full path tracing at 8 spp plus OptiX takes about 1.4 s per frame at 1440p.
Recorded demos with full states (for example the official BEHAVIOR Challenge raw data):
- restore the state per frame with OmniGibson's DataPlaybackWrapper;
- no physics runs between captured frames, so a time-lapse renders only every k-th frame, and the playback is exact.
House-scale scenes:
- use a chase camera with smoothing of about 0.5-1.5 s on position and yaw, aiming at the torso and hands;
- check line of sight against walls, so the robot never disappears behind one.
Switch off the robot's own cameras and the viewer camera while rendering.

Genesis (e.g. RoboWits)

Use Nyx, the path tracer of Genesis World 1.x:
- packages: pip install genesis-world gs-nyx;
- add it to the scene as a camera sensor: scene.add_sensor(NyxCameraOptions(res=(2560, 1440), ...));
- we rendered with FastPathTracer at 128 spp, the OIDN denoiser, and a Poly Haven HDRI (CC0) plus one key light;
- 0.1-0.2 s per frame at 1440p.
If your suite pins an older Genesis for physics:
1. replay the run in the pinned version and record every link's pose per frame;
2. rebuild the scene in Genesis World 1.x and set those poses frame by frame.
- Check that the rebuilt links match the replay. Ours matched to within 1 micrometre.
Genesis's default camera is a rasterizer and is not accepted. Use Nyx.
Draco-compressed .glb meshes crashed Nyx. Re-export them uncompressed.
Genesis CPU physics can diverge between CPU vendors. Replay on the same kind of machine that recorded the run, and check success.

SAPIEN / ManiSkill

Use the ray-tracing shader packs on the render camera:

env = gym.make(env_id, render_mode="rgb_array",
               human_render_camera_configs=dict(width=2560, height=1440, shader_pack="rt"))

rt-med and rt-fast trade quality for speed. The default shader is a rasterizer and is not accepted.

MuJoCo, robosuite, PyBullet and others

MuJoCo's built-in renderer, robosuite's and PyBullet's are rasterizers, so they are not accepted at any resolution. Render in Blender Cycles instead:

Replay the run and record every body's pose per frame (or the recorded states).
Import the same meshes into Blender and set those poses frame by frame. No physics runs in Blender.
Render with Cycles on the GPU. Eevee and Workbench are rasterizers and are not accepted.

A cinematic look is welcome. This is what the RoboARC re-render of 2026-10-14 used: Blender 4.5 LTS, about 1.4-6 s per frame at 1440p on an RTX 4090.

Sampling: Cycles with OptiX, adaptive sampling (threshold 0.01, at least 64 samples), and the OIDN denoiser with albedo and normal passes.
Set and light: a seamless studio floor, one large soft key light, a weak overhead softbox and a rim light, and a dim sky dome.
Colour: AgX view transform, Medium High Contrast look.
Camera: a slow, eased orbit of about 10 degrees.
Optional: a gentle depth of field and motion blur, as long as the robot and the goal objects stay sharp.

3. Camera and picture

Use a dedicated render camera. Never use the agent's observation camera, a viewer window or a screen recording.
Framing:
- a 3/4 elevated view, fixed or moving slowly;
- the robot and every object the goal mentions stay visible;
- the objects are large enough to read.
Keep the key action inside the central 80% of the frame. The site crops tiles to other shapes.
Clean picture: no text, logos, watermarks, UI, debug markers or axes. Balanced exposure: no blown-out windows, no crushed blacks.
One look per suite: the same camera style and lighting across all of its tasks.
Poster: a frame that reads on its own, usually the solved state with the objects in view. Not a close-up of the robot's back.
Length:
- a teaser runs 10-40 s, a task video 5-60 s;
- long tasks may be sped up, as long as the speed stays constant and is recorded in meta.json.

4. Which run to show

Show the graded task itself: the same scene, instance and goal.
Source, in this order:
1. the reference solution (oracle);
2. a successful agent trial;
3. an official demonstration of the same task.
Do not change physics.
- Re-simulate the recorded actions exactly as the verifier does, or play back recorded states. Only the camera and the render settings may change.
- If your simulator is not deterministic, check the task's success condition at the end of the re-render.
- Never publish a failed replay as a solved run.
No solved run? Render a 6-8 s slow orbit of that task's own initial scene, plus a poster. Never reuse a generic scene image.

5. What to deliver

Upload everything to the private Hugging Face dataset [the review repository](the review repository). Its README has the commands. Uploads arrive as pull requests that a maintainer merges.

For each task, in <suite>/<task_id>/:

File	Content
`video.mp4`	the master video, to the spec in section 1
`poster.png`	one full-resolution frame, chosen as in section 3
`still.png`	only for tasks without a video: above 1920x1080 (2560x1440 target), ray or path traced, showing the robot, every goal object and the goal (for example, start and goal side by side)
`meta.json`	see below

For the suite: <suite>/teaser.mp4, plus its poster.

{"suite": "robolab", "task": "put_two_mugs_on_shelf", "source": "agent-success:<run>/<trial>",
 "renderer": "isaac-rtx PathTracing spp=32 optix", "rendering": "path-tracing", "width": 2560, "height": 1440, "fps": 30,
 "speed": 8.25, "success_check": true, "image": "rcb-robolab:0.1.1"}

source is one of oracle, agent-success:<run>/<trial>, official-demo:<dataset>/<episode> or scene-orbit. rendering is path-tracing or ray-tracing. renderer names the renderer and its settings.

6. Check before you hand in

Run python3 check_media.py <suite_dir>. It needs ffmpeg.

It fails on:
- a resolution of 1920x1080 or lower, a wrong aspect, or a frame rate below the bar;
- a rendering other than path-tracing or ray-tracing, or a renderer that names a rasterizer (OpenGL, EGL, Eevee, Workbench, ...);
- a codec other than H.264/H.265;
- an encode above CRF 18;
- missing files or meta.json fields;
- a failed replay marked as a solved run.
It warns about: a size below the 2560x1440 target, a variable frame rate, black bars, and lengths outside the ranges above.
A maintainer then looks at every teaser and at a sample of task videos before anything goes on the site.

8. Addendum 1 (2026-10-08): every task in motion, and your five hardest

A video for every task. Replay every task and record the robot doing it: the reference solution, a successful agent run, or an official demonstration.
- Use a still, or an orbit of the starting scene, only for a task with no solved run at all.
- Say why in that task's meta.json, as "why_no_video".
The robot moves. In a teaser, and in every video meant for the home page, the robot itself must move: an arm reaching, a hand grasping, a body walking. A moving camera over a still scene does not count.
Your hardest five. Pick at least 5 tasks that are hard and interesting, each with a video where the robot moves. List them in <suite>/highlights.json, best first:
```
{"teaser": "<task_id>", "highlights": ["<task_id>", "<task_id>", "<task_id>", "<task_id>", "<task_id>"], "why_fewer": ""}
```
- Hard means that agents fail it, or that it takes real skill: a long horizon, precision, a tool, two arms, balance.
- The teaser is one of the highlights.
- Fewer than 5? Give the reason in why_fewer, for example "the suite has only 4 tasks" or "only 3 tasks have a solved run".
Why it matters. The home page's wall gives every suite the same number of tiles and fills them from highlights.json. Each suite's cover is its teaser. A suite without highlights gets fewer tiles.

check_media.py now fails a suite in four cases:

it has no highlights.json;
a highlight has no video where the robot moves;
it lists fewer than 5 highlights without a why_fewer;
a still or orbit has no why_no_video.

9. Addendum 2 (2026-10-16): above 1080p, ray or path tracing only

Above 1080p. Masters must be larger than 1920x1080; render natively at 2560x1440 (2K) or at 4K. Posters and stills follow the same rule.
Ray tracing or path tracing only. Never rasterization: no OpenGL/EGL renders, no MuJoCo, robosuite or PyBullet built-in renderers, no Genesis default camera, no SAPIEN default shader, no Blender Eevee or Workbench.
- If the simulator has no ray tracer, render the recorded poses in Blender Cycles. A cinematic look is welcome; section 2 has a recipe.
meta.json gains "rendering": "path-tracing" or "ray-tracing".
Scope. This applies to every upload from 2026-10-16 on, re-uploads included. Media already on the site stays until its suite re-uploads.

check_media.py now also fails on:

a video, poster or still of 1920x1080 or less;
a missing or unknown rendering;
a renderer that names a rasterizer.

The checks in sections 6 and 8 still apply.

High-quality media for exam suites (v2, 2026-10-16)