Co-Gestures

Two-person gesture-and-response motions, for humans and for a humanoid robot. In every clip person A makes a communicative gesture (points to a spot, waves, signals stop, beckons, sends someone onward, ...) and person B responds with their whole body (walks over, turns, halts, steps aside, follows, or ignores a gesture that was not meant for them). Each clip comes twice: as two human characters on the MHR body model, and with B replaced by a Unitree G1 humanoid performing B's response.

Purpose: data for multi-person co-gestures: learning and evaluating how a humanoid should move in response to another person's gesture.

beckon_follow: A beckons and walks off; B follows and stops when A stops.

urgent_stop: B walks toward A; A throws up a palm-out stop and B halts.

direct_onward: A sweeps an arm to send B onward; B turns and walks the indicated way.

Left: A and B as MHR characters. Right: the same clip with the G1 in B's place. Rendered from the released files.

At a glance

• 2,098 clips, 5.3 hours, 5-14 s each, 13 scenarios (table).
• Humans: A and B as skinned MHR characters (126 joints, with fingers), 30 fps, in GLB.
• Robot: A as an MHR character and B as a Unitree G1 (29 joints), 30 fps in GLB, and the G1 motion as MuJoCo qpos at 50 Hz in npz. 1,725 clips carry a motion tracked by a whole-body controller in physics simulation, 373 the kinematic retarget (see Files).
• Command: one short instruction per clip, addressed to B, that describes B's response (beckon_follow above: "Someone, about two meters from you, curls their fingers toward themselves twice, then sets off walking away from you. Follow right away, about one and a half meters behind them, at their pace and without passing them. Stop when they stop and turn back toward you, about one and a half meters from them.").
• 152 GB in all; the robot motion and metadata alone (g1/*.npz, *.json, manifest) are 0.4 GB.

Uses

Research on humanoid behaviour around people: gesture-conditioned motion models for humans or robots, command-to-motion for a humanoid, gesture understanding from body motion, and evaluation of human-robot interaction.

Out of scope: commercial use (see License). The scenes have no objects, no contact between the two people and a flat floor, so the data says nothing about manipulation, handovers or uneven ground.

Layout

manifest.csv / manifest.jsonl   one row per clip
humans/<clip_id>.glb            A and B as MHR characters
humans/<clip_id>.json           clip metadata
g1/<clip_id>.glb                A as an MHR character, the G1 in B's place
g1/<clip_id>.npz                the G1 motion
g1/<clip_id>.json               clip metadata
assets/                         the three renders above
LICENSES.md                     third-party licenses

clip_id is p<number>_<scenario>_<setting>; the setting is a label only, every clip is on an empty flat floor.

Files

humans/*.glb: two skinned MHR characters (126 joints, with fingers), one armature each, A_body_world and B_body_world (meshes A_MHR_Mesh, B_MHR_Mesh; the bones have the same names in both), in one shared world frame, Y up, metres, 30 fps. Each person's motion is its own glTF animation, so play all of them together. (Blender's importer keeps only the first one active and stashes the others as muted NLA tracks: unmute them.)

g1/*.glb: the same A_body_world, and the G1 (root node g1, links g1_*) in B's place, on one timeline at 30 fps. The G1 stands on the plane y = 0.

g1/*.npz: the G1 motion at 50 Hz.

key
qpos	(T, 36) the motion to use: MuJoCo layout, 0-2 root position (m, Z up), 3-6 root quaternion (w, x, y, z), 7-35 the 29 joint angles (rad) in joint_names order
motion_source	policy or kinematic: which of the next two qpos is
policy_qpos	the motion tracked by a whole-body controller in physics simulation
ref_qpos	the retargeted motion the controller tracked (kinematic, no physics)
root_drift_peak_m, root_err_*, joint_err_mean_rad, body_err_*, fell, completed	how closely the simulated robot followed ref_qpos
gltf_offset	places the motion in the GLB's world: glTF (x, y, z) = MuJoCo (x, z, -y) + gltf_offset
fps, joint_names	50, the 29 joint names

qpos is the simulated motion when the robot stayed within 20 cm of its reference (1,725 clips), otherwise the kinematic one (373 clips). The robot's path is B's path scaled to the robot's size, starting where B starts.

In all files, hands and forearms have been moved out of the body where they intersected it (decollide in the metadata says how much).

*.json / manifest: clip_id, scenario, command, duration and frame counts, the G1 motion's source and tracking errors, B's and the robot's path lengths, and the decollide statistics.

Quick start

from huggingface_hub import snapshot_download
import json, numpy as np

# the robot motion and the metadata only (0.4 GB); add "humans/*" or "g1/*.glb" for the characters
root = snapshot_download("andrew-cartwheel/co-gestures", repo_type="dataset",
                         allow_patterns=["manifest.csv", "g1/*.npz", "*/*.json"])

clip = "p00239_beckon_follow_warehouse"
z = np.load(f"{root}/g1/{clip}.npz")
qpos = z["qpos"]                         # (T, 36) at 50 Hz
print(z["motion_source"], qpos.shape, list(z["joint_names"])[:3])
print(json.load(open(f"{root}/g1/{clip}.json"))["command"])

To play qpos in MuJoCo, load a 29-joint G1 model (for example unitree_g1 from MuJoCo Menagerie), map the joints by joint_names, and set data.qpos frame by frame.

Scenarios

scenario	clips	A	B
point_to_spot	304	points to a spot on the floor	walks to the spot and turns back to face A
wave_attention	259	waves for the attention of B, who faces away	turns around and comes over
urgent_stop	184	throws up a palm-out stop	halts mid-walk and backs up
make_room	154	motions B to shift over	sidesteps away; A steps into the gap
beckon_follow	234	beckons and walks off	follows and stops when A stops
not_addressee	120	gestures to someone else	glances over and stays put
wait_then_come	196	signals to wait, then beckons	waits, then comes over
palm_down_beckon	179	beckons with the palm down	approaches
slow_down	60	presses both palms down	slows from a brisk walk
go_back	123	waves B back	turns around and retraces their steps
direct_onward	182	sweeps an arm to send B onward	turns and walks the indicated way
inhibit	85	shakes their head and crosses their forearms	pulls back from the step they had started
repair	18	points again after B goes the wrong way	corrects course to the indicated spot

Limitations

• The G1 is about 1.32 m tall. B's path is scaled to its size from B's starting position, so the robot ends near, but not always exactly where, B ends, and its distance to A differs from B's.
• In the 373 kinematic clips the simulated controller fell or strayed more than 20 cm from the reference; their qpos has no physics (feet can slide). The simulated motion is still in policy_qpos.
• The G1 has no fingers; finger motion exists only on the human characters.
• After the decollide, a hand can still sit slightly inside the body on a few frames (the robot's primary motion never more than 3 cm).
• No objects, no contact between A and B, flat floor only.

License

The dataset is released under CC BY-NC 4.0: you may share and adapt it for non-commercial purposes, with attribution. For commercial use, open a discussion on this repository.

The files also carry third-party components under their own licenses (see LICENSES.md):

• MHR (Momentum Human Rig, Meta): the character mesh and skeleton in humans/*.glb and g1/*.glb. Apache License 2.0.
• Unitree G1 model (Unitree Robotics, via MuJoCo Menagerie): the robot meshes in g1/*.glb and the joint layout of g1/*.npz. BSD 3-Clause License.

Citation

@misc{cogestures2026,
  title        = {Co-Gestures: Two-Person Gesture and Response Motions for Humans and a Humanoid Robot},
  author       = {Cartwheel},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/datasets/andrew-cartwheel/co-gestures}}
}