carrot_in_pot_sim_raw — raw HDF5 + MP4 teleop logs from MuJoCo (UR7e, "Put carrot in pot")

The simulated twin of carrot_in_pot_raw: the same task, the same file format, the same GELLO leader arm and the same ROS end-effector teleop math — but the follower is a MuJoCo UR7e instead of the physical one. A human moved the real 3D-printed GELLO leader by hand; the simulated arm followed.

Because everything is simulated, this release ships something the real one cannot: the exact MJCF scene and the complete generalized state at every physics tick, so any take can be rebuilt bit-for-bit and re-rendered from any camera, at any frame rate, forever.

• 22 takes · 359.13 s (6.0 min) · 1.32 GB total (0.66 GB per set), shipped twice:
  • takes/ — the original live recording. Cameras actually captured at 23.4 – 27.3 fps while the MP4 is stamped 30 fps. 9,173 cam1 frames (9,173 cam2).
  • retimed_30hz/ — both videos re-rendered from the recorded MuJoCo state on an exact 30.000 Hz grid. 10,725 cam1 frames (10,725 cam2), cam1 and cam2 frame counts equal in every take. This is the set the LeRobot conversion is built from, and the one to train on.
• Per take: vectors.h5 + cam1.mp4 + cam2.mp4 (no depth — depth recording was off).
• Nothing resampled inside vectors.h5 — each stream keeps its own t_rel_s clock and native rate. The two sets share identical vectors.h5 content except the cam*_frames tables and one extra sim_meta.retimed block.
• Recorded in a single session on 2026-09-15 (00:09–00:19 local), one operator, sim_collect at git commit 4bac8657be5a66adca0b5ccfacc11982420080a1, MuJoCo 3.10.0.
• All 22 takes end with the carrot in the pot — and here that is not an operator's word, it is the simulator's geometry: sim_control/task_success is recorded per tick.

Every number on this page was measured directly from the 44 vectors.h5 and the 88 MP4s; the machine-readable versions are dataset_stats.json (for takes/) and retimed_30hz/dataset_stats.json, produced by the same release script make_carrot_raw_stats.py (h5py + cv2 + ffprobe -count_frames) that generated the real release's stats, in its depth-free mode.

Setup

Everything below is simulation. There is no physical robot, no camera, no table in this release.

Component	Spec
Simulator	MuJoCo 3.10.0, timestep 2 ms (500 Hz), implicitfast integrator, elliptic friction cone, impratio 10, gravity compensation on the arm links.
Robot (follower)	UR7e, built from the mujoco_menagerie ur5e.xml structure with the exact UR7e URDF link offsets substituted (ur_description 2.7.0 ships the UR7e config as a byte-identical copy of the UR5e one, so the kinematics are the same: DH d = [0.1625, 0, 0, 0.1333, 0.0997, 0.0996], a = [0, −0.425, −0.3922, 0, 0, 0]). Verified: the MuJoCo attachment_site world pose equals ur_kin.fk(q) to 0.000 mm over 2,000 random configurations. ⚠️ The visual geometry is the UR5e enclosure — do not use it for appearance-critical sim2real.
Gripper	Menagerie Robotiq 2F-85, attached at attachment_site. Driver joint range 0 – 0.871 rad, normalized to 0.0 = open, 1.0 = closed exactly as on the real rig.
Teleoperation (leader)	The physical GELLO arm, read over USB at 30 Hz, using the real robot's ROS calibration file (ur_gello_bringup/config/ur7e_gello.yaml, gello_publisher section) — no sim-only offsets.
Control	EEF delta mode, the same code path as the real rig: the ROS bridge stages (bridge_stages.OneEuro → EefDeltaController.step) at 250 Hz, loading the real ur7e_gello_eef.yaml (pos_scale 1.0, r_align_rpy [0,0,0], tool_l = tool_r = 0.174 m, v_max 0.16, w_max 1.0, max_step_rad 0.0025 @ 250 Hz, One-Euro min_cutoff 1.0 / beta 2.0, soft_start_s 0.7). command therefore means exactly what it means in the real release: absolute UR joint targets from IK on a leader pose delta.
Scene	No table geometry — the work surface is the floor (a 5 m textured plane at z = 0). The robot base sits at the world origin on that floor and the arm faces world +x at the home pose, matching the real cell.
Floor texture	LIBERO seamless_wood_planks_floor.png (MIT, © 2023 Lifelong Robot Learning), texrepeat 20×20.
Objects	A procedural carrot (tapered body with green leaves, ~18.5 cm, 0.08 kg) and a procedural open pot (inner radius 9 cm, rim 11 cm, 0.55 kg). Both are MJCFs written for this project — no third-party mesh is used by the default scene. The unused object library (YCB fruit, LIBERO bowl/basket, robosuite bread) ships in the repo, not here: see assets/object_candidates.jpg.
Layout	Convention "left = food, right = containers", seen from the base looking along +x: carrot at +y, pot at −y. Each RESET SCENE re-samples both from a seeded RNG — carrot nominal (0.45, +0.18) ± 6 cm and ±35° yaw, pot nominal (0.45, −0.22) ± 5 cm and any yaw — then drops them 2 cm and settles 0.5 s. Base keep-out radius 0.22 m, minimum object gap 2 cm. Measured across the 22 takes: carrot x 0.396 – 0.492 m, y +0.124 – +0.242 m; pot x 0.405 – 0.489 m, y −0.191 – −0.258 m; both yaws vary freely.
cam1 — scene camera	Fixed, at (0.70, 0.00, 0.571) m looking back at (0.45, 0, 0), colour fovy 42° (a D435's colour vertical FOV), rendered 1280×720 @ 30 fps.
cam2 — wrist camera	Mounted on wrist_3_link relative to attachment_site: 0.05 m radial along tool +y, 0.08 m axial, pitched 15° toward the fingertips, same fovy, same resolution. The fingers are visible at the bottom of every frame, exactly like the real wrist camera.
Video format	1280×720, 30 fps, MPEG-4 (mpeg4), yuv420p — measured identical across all 88 videos, and identical to the real release's format.
Depth	Not recorded. Depth is opt-in in sim_collect and was off for this session, so there is no depth.h5 and no assets/color_depth_samples.jpg. (The sim can render the same 848×480 uint16 mm PNG sidecar the real rig produces.)

Task

"Put carrot in pot." The floor holds exactly two objects: a carrot on the robot's left (+y) and an open pot on its right (−y). The operator grasps the carrot with the GELLO leader and places it in the pot.

Success is evaluated by the simulator, every tick, and recorded in sim_control/task_success: the carrot's origin is inside the pot's opening cylinder (above the pot floor, below the rim, within the inner radius) and its vertical speed is < 0.05 m/s and the gripper is open (grip_cmd < 0.3). All 22 takes reach success — first at 8.68 s, median 12.26 s, last at 25.28 s into the take — and sim_meta.task_success_at_stop is true in all 22.

⚠️ The success test is a geometric approximation written for the operator's on-screen badge. It is an honest signal and it is in the data, but it was never calibrated as a training label.

cam1 — scene view, first frame of take_01	cam2 — wrist view, first frame of take_01 (gripper fingers at the bottom)

Two takes, both cameras, frame 0 — the layout really does move between takes even though the recorded layout_seed says otherwise (see Known quirks).

Repository layout

takes/<take>/{vectors.h5, cam1.mp4, cam2.mp4}            <- the ORIGINAL live recording
dataset_stats.json                                        <- stats for takes/
retimed_30hz/<take>/{vectors.h5, cam1.mp4, cam2.mp4}      <- videos re-rendered on a 30 Hz grid
retimed_30hz/retime_manifest.json                         <- per-take frame count + render log
retimed_30hz/dataset_stats.json                           <- stats for retimed_30hz/
assets/                                                   <- the images on this page

Both sets contain the same 22 takes with the same names. Take numbers run take_01 … take_23 with take_06 absent by design (discarded during recording) — 22 folders, no partial take anywhere.

HDF5 schema (vectors.h5)

Each group has its own t_rel_s (seconds since take start) at that stream's native rate. All datasets are 1-D float64 in a columnar layout (channel foo is dataset group/foo, not a 2-D table). This is the real recorder's own format — gello_recorder writes it, and the existing converters read sim takes unchanged.

The nine real groups, plus a trailing stamp_s column on six of them (added to the real recorder on 2026-09-14; older real takes do not have it):

group	native rate	rows (22 takes)	fields	units / meaning
cam1_frames	25.5 Hz live / 30.0 Hz retimed	9,173 / 10,725	frame_idx, t_rel_s, stamp_s	index/time of each cam1 MP4 frame
cam2_frames	25.5 Hz live / 30.0 Hz retimed	9,173 / 10,725	frame_idx, t_rel_s, stamp_s	index/time of each cam2 MP4 frame
command	125.5 Hz	44,660	cmd1..cmd6, t_rel_s	commanded absolute UR joint targets (rad) — the action
ur_joint_states	125.5 Hz	44,660	q1..q6, qd1..qd6, eff1..eff6, t_rel_s, stamp_s	simulated joint positions (rad), velocities (d.qvel[:6]), efforts (d.actuator_force[:6])
tcp_pose	125.5 Hz	44,660	x,y,z, qw,qx,qy,qz, t_rel_s, stamp_s	TCP pose in base frame = fk(q) ⊕ 0.174 m
wrench	125.5 Hz	44,660	fx,fy,fz, tx,ty,tz, t_rel_s, stamp_s	flange force/torque sensor, tared at take start
gripper	62.8 Hz	22,336	grip_pos, grip_cmd, gello_grip, t_rel_s	measured opening, commanded, leader trigger — all 0 = open
gello_joint_states	30.2 Hz	10,797	q1..q6, qd1..qd6, t_rel_s, stamp_s	GELLO leader joints (rad) + finite-difference velocities
synchronized	100 Hz	33,848 — FILLED	56 channels	⚠️ the one structural difference from the real release, where this group is empty

And five simulation-only groups, same columnar convention, all prefixed sim_:

group	rate	fields	what it is
sim_object_poses	30 Hz	carrot_{x,y,z,qx,qy,qz,qw}, pot_{…}, t_rel_s	ground-truth object poses. The real release has no equivalent at any price
sim_control	125 Hz	engaged, eef_state_code, pos_scale, sigma_min, gamma, ls_scale, task_success, sim_t, tick, t_rel_s	teleop state machine + IK conditioning + the per-tick success flag
sim_leader_filtered	125 Hz	qf1..qf6, t_rel_s	the One-Euro filter output the controller actually consumed — lets you replay the controller offline
sim_mj_state	125 Hz	qpos0..qpos{nq−1}, qvel0.., ctrl0.., sim_t, tick, t_rel_s (attrs nq/nv/nu)	the complete generalized state at every recorded tick (nq 28, nv 26, nu 7)
sim_frame_capture	~51 Hz	cam, frame_idx, seq, sim_t, tick, t_capture_rel_s, t_rel_s	which physics tick each rendered frame came from

Plus a group /sim_scene holding the exact MJCF the simulator compiled (xml dataset, ~50 kB) with attrs xml_sha256, assets_manifest (per-asset sha256 + size, 29 assets), layout, config, config_path, layout_seed, mujoco_version, timestep — and a file-level attr sim_meta (one JSON string) with the git commit, camera poses and intrinsics, chosen food/container, object list, eef_state_codes, achieved fps, problems, task_success_at_stop and duration_s.

See DATA_DICTIONARY.md for the exhaustive per-field listing (every dataset key, dtype, unit and measured value range), the full sim_* spec, and the per-take table.

Reconstruction — rebuild the scene and replay any take

This is the point of the release. /sim_scene + sim_mj_state reproduce every recorded instant kinematically exactly; the mesh/texture bytes (35 MB) are not copied into each take, they are identified by sha256 in assets_manifest and live in the sim_collect source tree at the recorded git_commit.

# in a checkout of the recording repo at sim_meta.git_commit (4bac865)
.venv/bin/python -m sim_collect.tools.replay_take <take_dir> --check
#  -> model: nq 28 nv 26 nu 7 | rows 3002 | rebuilt xml matches: True | assets 29
#     object pose reconstruction error (replayed vs recorded sim_object_poses): max 0.00 mm

MUJOCO_GL=glfw DISPLAY=:0 .venv/bin/python -m sim_collect.tools.replay_take <take_dir> --viewer
MUJOCO_GL=glfw DISPLAY=:0 .venv/bin/python -m sim_collect.tools.replay_take <take_dir> \
    --render cam1 cam2 --out /tmp/frames --every 15

The tool rebuilds the scene from config + layout, checks each asset's sha256, compiles the stored XML against those assets, then for each row writes qpos/qvel and calls mj_forward — no physics is re-simulated, so there is no divergence. Measured object-pose reconstruction error: 0.00 mm. retimed_30hz/ was produced exactly this way.

Nothing stops you from re-rendering at 60 fps, adding cameras, rendering depth or segmentation masks, or replaying with a different visual theme. The trajectories are fixed; the pixels are not.

Frame-rate quirk — and which set to train on

The renderer runs on software GL (no NVIDIA driver on the recording machine), so it is exposed to CPU load. During this session it delivered 23.4 – 27.3 fps (median 25.5) while the MP4 container is always stamped 30 fps — so takes/*/cam*.mp4 plays about 1.18× fast. The recorder did not hide this: sim_meta.achieved_fps_take carries the measured rate and sim_meta.problems says, per take, e.g.

"cam1 captured at 25.2 fps but cam1.mp4 is stamped 30 (plays 1.19x fast)"

cam*_frames/t_rel_s is correct in both sets — the timestamps never lied, only the container frame rate did. So the live videos are perfectly usable if you align by timestamp.

retimed_30hz/ removes the problem at the source. Both videos were re-rendered from sim_mj_state on an exact 30.000 Hz grid, so:

	takes/ (live)	retimed_30hz/
cam1 frames	9,173	10,725
cam2 frames	9,173	10,725
mean frame rate	25.53 Hz (23.71 – 27.31)	30.00 Hz in every take
median Δt / max Δt	37.3 ms / 117.4 ms	33.3 ms / 33.4 ms
takes where cam1 ≠ cam2 frame count	20 of 22 (−9 … +5)	0
sim_meta.problems	2 entries per take	[] (originals kept in sim_meta.retimed.original_problems)

The worst per-take state-lookup error introduced by snapping to the grid is 19.6 ms in take_01 and at most 37.6 ms over all 22 takes (retime_manifest.json → max_state_lookup_dt_s) — under one and a half physics-tick periods of the 125 Hz state stream.

Train on retimed_30hz/. The derived LeRobot dataset carrot_in_pot_sim_lerobot_v3 is built from it. Use takes/ when you want the literal capture, the real inter-frame jitter, or sim_frame_capture provenance for the frames that were actually rendered live.

Known quirks

• 🐛 layout_seed is recorded as 0 in every take, and it is wrong. sim_meta.layout_seed says 0 and /sim_scene attr layout_seed says -1 in all 22 takes, while /sim_scene attr layout carries one single layout (carrot (0.480, +0.188), pot (0.488, −0.243)) for all of them. The scene really was re-randomized between takes — the stored layout metadata is stale, a bug fixed in the recorder after this session. The truth is in the data, exactly and per take: sim_object_poses row 0 (and sim_mj_state qpos) give the real initial poses, and they span carrot x 0.396 – 0.492 / y +0.124 – +0.242 and pot x 0.405 – 0.489 / y −0.191 – −0.258, with free yaw. take_02 and take_03 share a layout (no reset between them), as do take_22 and take_23. This does not affect reconstruction: replay_take.py overwrites qpos from sim_mj_state, so the replay error is 0.00 mm regardless of the stale attr. Never read layout or layout_seed as ground truth; read sim_object_poses.
• ⚠️ In retimed_30hz/, synchronized/cam1_frame_idx and cam2_frame_idx still point at the ORIGINAL live frame numbers. Only the cam*_frames tables were rewritten. The 56-channel synchronized table is otherwise untouched and internally consistent. If you use synchronized for camera indexing, use takes/; for the retimed videos, index through cam*_frames.
• ⚠️ Nothing is stamped late here — do NOT apply the real release's −0.900 s / −0.41 s fix. The sim recorder stamps each robot row with the physics tick that produced it, and command, ur_joint_states, tcp_pose and wrench all come out of the same tick (their t_rel_s agree to 0.3 ms). dataset_stats.json → timestamp_lag nevertheless reports a ur_joint_states_lag_s of 0.190 – 0.205 s (median 0.198): that is the simulated arm's real tracking lag behind its commanded joint target — bounded by the 250 Hz controller's max_step_rad 0.0025 slew limit and the actuator gains — not a clock error. The stats JSON says so itself (timestamp_lag.applies_to_this_release = false, timestamp_lag.simulation_note); the surrounding note/method prose in that block is inherited verbatim from the real release and its mechanism (rclpy spin-thread starvation) does not exist here. Speed cross-correlation of command against every other robot table measures 0.000 s in all 22 takes.
• ⚠️ Two different clocks live in stamp_s. ur_joint_states, tcp_pose, wrench, cam1_frames and cam2_frames carry unix epoch seconds (1.789e9), but gello_joint_states/stamp_s carries a monotonic clock (1715 – 2362 s, the leader thread's own timebase). They are not comparable to each other. t_rel_s is the common timebase in every group — use it.
• wrench is the simulated flange force/torque sensor, tared at take start. It has never been checked against the real UR's wrench for frame or sign convention. Values are far larger than the real rig's (|f| up to 279 N on contact transients at a 2 ms timestep). Treat it as a sim signal, not as a drop-in replacement for the real one.
• grip_pos does not identify "holding the carrot" the way it does on the real rig. On the real robot the carrot's width pins grip_pos at 0.47 – 0.66. Here the carrot is tapered and the contact is soft, so the closed value while carrying the carrot ranges from 0.565 to 0.913 depending on where along the taper the grasp landed (measured while the carrot is airborne). The fully-open value is 0.000 – 0.003. Use sim_object_poses if you need to know what is held.
• Seven takes contain more than one gripper closure (grip_cmd ≥ 0.7 rising edge): take_04, take_08, take_09, take_14, take_17, take_20, take_21 — a missed first grasp followed by a successful re-grasp, 29 closures over the 22 takes. All seven finish the task and all are included: a recovery is a legitimate demonstration.
• cam1 / cam2 frame counts differ in 20 of 22 live takes (−9 … +5; the two cameras render on independent workers). retimed_30hz/ has them equal in every take. Either way: map between cameras by nearest t_rel_s, never by index.
• synchronized is FILLED here (100 Hz grid, 33,848 rows over 22 takes) whereas the real release's is empty. It is the only structural schema difference. It starts only once both cameras have delivered a frame.
• The leader stream does not mirror the follower — same reason as the real EEF-mode release: command comes from IK on a leader pose delta, so gello_q* is one IK branch of a virtual chain and ur_q* is another solution of a different chain. gello_* is leader-frame telemetry and cannot be used as an inference input.
• retimed_30hz/*/vectors.h5 each contain one absolute path — sim_meta.retimed.from, the source take's directory on the recording machine. It is provenance, it is the only /home/ string in the release, and takes/ has none.
• The operator's very first simulated session. These 22 takes are the first real GELLO→MuJoCo teleop ever run on this stack. Expect the motion style to be less fluent than the real-robot release's.

Data quality

Audited over all 22 takes of both sets (44 vectors.h5, 88 MP4s):

• Zero NaN and zero Inf in any channel of any group of any take.
• Video frame counts match cam*_frames row counts exactly — 88/88 videos, verified with ffprobe -count_frames.
• Uniform schema: the identical 15 groups (9 real + 5 sim_* + sim_scene), identical channel names, all float64, in all 44 files; identical video format (mpeg4 1280×720 yuv420p 30/1) in all 88 MP4s.
• Timestamps are well behaved and, unlike the real release, unshifted. Largest single gap in any 125 Hz robot stream 79.4 ms, in the gripper stream 96.1 ms, in a live camera stream 117.4 ms (a dropped render under load), and in a retimed camera stream 33.4 ms.
• Cleanliness: exactly three files per take folder, no stray files, no hidden files, no sub-directories, in all 44 folders. No /home/ string anywhere in takes/; exactly one provenance path per retimed vectors.h5 (see above).
• Reconstruction verified: replay_take.py --check rebuilds the scene with rebuilt xml matches: True, all 29 assets matching their recorded sha256, and 0.00 mm object-pose error.

No human quality ratings and no policy-performance numbers are claimed. The outcome statement is the simulator's geometric success test, recorded per tick.

Usage

import h5py, json, cv2, numpy as np

take = "retimed_30hz/take_03_20260915_001003"
with h5py.File(f"{take}/vectors.h5", "r") as f:
    ur_q   = np.stack([f["ur_joint_states"][f"q{k+1}"][:] for k in range(6)], axis=1)  # (N125,6) rad
    cmd    = np.stack([f["command"][f"cmd{k+1}"][:]       for k in range(6)], axis=1)  # (N125,6) rad
    grip   = f["gripper"]["grip_pos"][:]                                               # (N63,)
    cam1_t = f["cam1_frames"]["t_rel_s"][:]                                            # 30 Hz grid
    # ground truth the real dataset cannot give you:
    carrot = np.stack([f["sim_object_poses"][f"carrot_{k}"][:] for k in "xyz"], axis=1)
    win    = f["sim_control"]["task_success"][:]                                       # per tick
    meta   = json.loads(f.attrs["sim_meta"])
    mjcf   = f["sim_scene"]["xml"][()]        # the exact model, as bytes
    # each stream has its own f[group]["t_rel_s"] — align by nearest timestamp

cap = cv2.VideoCapture(f"{take}/cam1.mp4")    # 1280x720 colour @ 30 fps

⚠️ columns attribute quirk — inherited from the real recorder. Every group carries an attribute named columns that is a single scalar JSON string, not a list (measured str in all 44 files). Always json.loads(grp.attrs["columns"]); list(...) on it iterates character-by-character and yields garbage.

To go straight to training, use the LeRobot conversion instead (LeRobotDataset("Bigenlight/carrot_in_pot_sim_lerobot_v3")).

Limitations & intended use

• Small, and simulated. 22 takes / 6.0 minutes is pilot scale. It is a seed set, a schema reference and a sim2real probe — not enough on its own for a robust policy.
• Single task, single scene family, single operator, single session.
• The visual gap is large: UR5e enclosure geometry, a wood-plank floor instead of a white desk, procedural objects instead of a plastic carrot and a steel saucepan, software-GL shading. This is a dynamics and schema twin, not a photometric one.
• No depth, no camera noise model, no motion blur, no rolling shutter, no calibration error.
• The success test is geometric, not a curated label (see Task).
• wrench is unvalidated against the real arm (see Known quirks).
• Streams are asynchronous (each has its own clock) — resample against t_rel_s. The synchronized group is filled here, at 100 Hz, if you want a pre-fused table.
• Intended for research in imitation learning, sim2real transfer, teleoperation analysis, and custom dataset construction from replayable simulator state.

Related repositories

repo	contents
Bigenlight/carrot_in_pot_sim_raw	this — raw MuJoCo HDF5 + MP4, 22 takes, live + retimed
Bigenlight/carrot_in_pot_sim_lerobot_v3	LeRobot conversion of this data, built from retimed_30hz/
Bigenlight/carrot_in_pot_raw	the real-robot twin — same task, same format, real UR7e + RealSense, 54 takes, with lossless depth
Bigenlight/carrot_in_pot_lerobot_v3	its LeRobot conversion, 54 episodes / 17,088 frames, RGB + depth
Bigenlight/cube_in_cup_raw	sibling real raw dataset, same rig family, RGB only, 24 takes
Bigenlight/banana_in_pot_raw	sibling real raw dataset, same rig family, different scene

Citation

@misc{theo2026carrotinpotsimraw,
  title        = {carrot_in_pot_sim_raw: raw MuJoCo UR7e + GELLO teleoperation logs (HDF5 + MP4,
                  with full replayable simulator state) for "Put carrot in pot"},
  author       = {Theo and {Bigenlight}},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/datasets/Bigenlight/carrot_in_pot_sim_raw}},
  note         = {22 takes, native multi-rate HDF5 + dual RGB MP4 (live and 30 Hz retimed),
                  exact MJCF scene and per-tick generalized state}
}

License

Apache-2.0 for the recordings, the schema and this documentation.

The scene is built from third-party art, none of which is redistributed in this repository (the takes reference assets by sha256 only) but which you will need in order to replay a take:

what	upstream	licence
floor texture seamless_wood_planks_floor.png	LIBERO — © 2023 Lifelong Robot Learning	MIT
UR5e/UR7e robot meshes	mujoco_menagerie	Apache-2.0
Robotiq 2F-85 model	mujoco_menagerie	Apache-2.0
carrot + pot MJCFs	written for this project	Apache-2.0, as this repo
unused object library (assets/object_candidates.jpg): YCB banana/strawberry/lemon/peach/pear/plum	YCB Object and Model Set	CC BY 4.0
unused: LIBERO bowl + basket, robosuite bread	LIBERO (MIT), robosuite (MIT)	MIT

Required YCB attribution (the objects appear only in assets/object_candidates.jpg, not in any take):

B. Calli, A. Singh, A. Walsman, S. Srinivasa, P. Abbeel and A. M. Dollar, "Benchmarking in Manipulation Research: Using the Yale-CMU-Berkeley Object and Model Set", IEEE Robotics and Automation Magazine, 22(3):36–52, Sept. 2015.