license: cc0-1.0
pretty_name: Dancing Stick Figures
language:
- en
task_categories:
- text-to-video
- text-to-image
- unconditional-image-generation
- image-to-video
- keypoint-detection
tags:
- synthetic
- video-diffusion
- motion
- stick-figure
- benchmark
- toy-dataset
size_categories:
- 100K<n<1M
dataset_info:
- config_name: frames
features:
- name: color
dtype: image
- name: text
dtype: string
- name: depth
dtype: image
- name: normal
dtype: image
- name: seg
dtype: image
- name: sample_id
dtype: string
- name: clip_id
dtype: string
- name: frame_idx
dtype: int32
- name: n_frames
dtype: int32
- name: fps
dtype: int32
- name: split
dtype: string
- name: group
dtype: string
- name: held_out
dtype: bool
- name: seed
dtype: int32
- name: qa_flags
dtype: string
- name: cam_yaw
dtype: float32
- name: cam_pitch
dtype: float32
- name: cam_center_x
dtype: float32
- name: cam_center_y
dtype: float32
- name: px_per_m
dtype: float32
- name: stroke
dtype: float32
- name: bone_scale
dtype: string
- name: joint_xyz
dtype: binary
- name: joint_xy
dtype: binary
- name: joint_depth
dtype: binary
- name: joint_visible
dtype: binary
- name: root_pos
dtype: binary
- name: root_vel
dtype: binary
- name: root_heading
dtype: binary
splits:
- name: train
num_examples: 385920
- name: validation
num_examples: 48240
- name: test
num_examples: 48240
- config_name: mini
features:
- name: color
dtype: image
- name: text
dtype: string
- name: seg
dtype: image
- name: sample_id
dtype: string
- name: clip_id
dtype: string
- name: frame_idx
dtype: int32
- name: n_frames
dtype: int32
- name: fps
dtype: int32
- name: split
dtype: string
- name: group
dtype: string
- name: held_out
dtype: bool
- name: seed
dtype: int32
- name: qa_flags
dtype: string
- name: cam_yaw
dtype: float32
- name: cam_pitch
dtype: float32
- name: cam_center_x
dtype: float32
- name: cam_center_y
dtype: float32
- name: px_per_m
dtype: float32
- name: stroke
dtype: float32
- name: bone_scale
dtype: string
- name: joint_xyz
dtype: binary
- name: joint_xy
dtype: binary
- name: joint_depth
dtype: binary
- name: joint_visible
dtype: binary
- name: root_pos
dtype: binary
- name: root_vel
dtype: binary
- name: root_heading
dtype: binary
splits:
- name: train
num_examples: 385920
- name: validation
num_examples: 48240
- name: test
num_examples: 48240
- config_name: motion
features:
- name: text
dtype: string
- name: group
dtype: string
- name: clip_id
dtype: string
- name: held_out
dtype: bool
- name: split
dtype: string
- name: seed
dtype: int32
- name: fps
dtype: int32
- name: n_frames
dtype: int32
- name: frame0_basis
dtype: binary
- name: posed_joints
dtype: binary
- name: local_rot_mats
dtype: binary
- name: global_rot_mats
dtype: binary
- name: root_positions
dtype: binary
- name: smooth_root_pos
dtype: binary
- name: global_root_heading
dtype: binary
- name: foot_contacts
dtype: binary
splits:
- name: train
num_examples: 1072
- name: validation
num_examples: 134
- name: test
num_examples: 134
configs:
- config_name: frames
default: true
data_files:
- split: train
path: frames/train-*.parquet
- split: validation
path: frames/val-*.parquet
- split: test
path: frames/test-*.parquet
- config_name: motion
data_files:
- split: train
path: motion/train-*.parquet
- split: validation
path: motion/val-*.parquet
- split: test
path: motion/test-*.parquet
- config_name: mini
data_files:
- split: train
path: mini/train-*.parquet
- split: validation
path: mini/val-*.parquet
- split: test
path: mini/test-*.parquet
Dancing Stick Figures — v0.2
A small, fully-labelled synthetic video dataset for learning (and teaching) video diffusion on one consumer GPU.
1,340 clips · 6 s @ 20 fps · 128×128 RGBA · 482,400 frames · 134 text prompts × 10 seeds × 3 cameras · every frame carries the 3D skeleton, camera and G-buffer (depth, normals, part segmentation) that produced it.
Think of it as an MNIST for video generation: small enough that a 64² video diffusion model trains from scratch in a few hours on a 24 GB card, structured enough that you can measure what the model got wrong (missing arm? detached leg? wrong colour?) instead of eyeballing it. It is also a clean playground for the "image model first, then video" curriculum used by Seedance-class systems.
Start here →
one route, end to end, sized for a 16 GB T4: look at the data → train a 64² image model → warm-start a video model from it → watch the GIF → measure visible topology and motion. The measured optimization phases take about 25 and 22 minutes; validation and diffusion sampling add time afterward. Same five commands in the code repo README.
Sibling dataset: sprited/dancing-chibi-figures — the same motions and cameras rendered as a volumetric chibi character (paired by
clip_id).v0.2 uses an in-domain seed split. Captions remain the raw motion prompts. Seeds 0--7 train, seed 8 validates, and seed 9 tests; every split contains all 134 prompts. Nine of the original 143 prompts were removed after visual QA because their motions do not visibly perform the requested action (see the curation note below). Feedback and issues are welcome.
Which config?
| config | rows | size | contents |
|---|---|---|---|
frames (default) |
482,400 frames | 4.4 GB | 128² RGBA colour + depth16 + normals + seg + all labels |
mini |
482,400 frames | 0.79 GB | 64² RGBA colour + seg + all labels — laptops, Colab, classrooms |
motion |
1,340 clips | 0.33 GB | raw generator output: world joints, rotation matrices, foot contacts |
Quick start
from datasets import load_dataset
ds = load_dataset("sprited/dancing-stick-figures", "frames", split="validation") # 128 px frames + labels ("mini" = 64 px, 0.79 GB)
row = ds[0]
row["color"] # PIL RGBA image (transparent background, colour-coded bones)
row["text"] # "A person does the running man dance."
import numpy as np
xy = np.frombuffer(row["joint_xy"], np.float32).reshape(27, 2) # normalised [0,1] image coords
xyz = np.frombuffer(row["joint_xyz"], np.float32).reshape(27, 3) # metres, figure frame (x left, y up, z fwd)
vis = np.frombuffer(row["joint_visible"], np.uint8) # 1 = joint visible in this camera
Motion (one row per clip, raw generator output):
mo = load_dataset("sprited/dancing-stick-figures", "motion", split="validation")[0]
T = mo["n_frames"]
P = np.frombuffer(mo["posed_joints"], np.float32).reshape(T, 27, 3) # world, metres
Rl = np.frombuffer(mo["local_rot_mats"], np.float32).reshape(T, 27, 3, 3) # per-joint local rotations
fc = np.frombuffer(mo["foot_contacts"], bool).reshape(T, 4)
Training a baseline (code: https://github.com/sprited-ai/dancing-stick-figures, MIT):
python -m train.cache --data frames --out cache # uint8 memmap of all frames
python -m train.video_ddpm --cache cache --size 64 --frames 8 --batch 16 --fast --compile # UNet, ~13 GB
python -m train.video_dit_fm --cache cache --size 64 --frames 8 --batch 16 --patch 2 --fast --compile # DiT-FM
What is in a frame
color (RGBA over white) · seg (bone id per pixel) · depth16 · camera-space normals · joint_xy overlay (green = visible, red = occluded)
frames config — one row per rendered frame (482,400 rows).
| column | type | meaning |
|---|---|---|
sample_id, clip_id, frame_idx, n_frames, fps |
str/int | clip_id = group/prompt_slug_s{seed}/c{cam}; 120 frames per clip, 20 fps |
split, group, held_out |
str/bool | split ∈ train/val/test; group ∈ dance, gesture, locomotion, transitions, idle, sport; held_out is false in the current seed split |
text |
str | the motion prompt the clip was generated from (134 unique) |
seed |
int | generator seed 0–9 |
qa_flags |
str | comma list; levitation (root ever > 1.6 m above floor), frozen (mean joint speed < 0.02 m/s). Kept, not filtered — filter if you like |
cam_yaw, cam_pitch |
float (rad) | orthographic camera; yaw 0 = figure faces the camera, canonical yaws ±6° jitter (70 %) or uniform (30 %); pitch −3°…10° |
cam_center_x/y, px_per_m |
float | projection: x_px = cx + px_per_m·x, figure scale 50–58 px/m |
stroke |
float | line width in px (3–5, per clip) |
bone_scale |
JSON str | per-bone length multipliers (±8 %, applied to the skeleton) |
joint_xyz |
binary f32[27,3] | figure-frame 3D joints, metres, Hips at origin |
joint_xy |
binary f32[27,2] | image coordinates, normalised to [0,1] |
joint_depth |
binary f32[27] | camera-space depth of each joint (m; same convention as the depth map) |
joint_visible |
binary u8[27] | 1 if the joint's pixel is not occluded by another bone |
root_pos, root_vel, root_heading |
binary f32[3], f32[3], f32[2] | Hips trajectory in the frame-0 figure frame; heading = (cos, sin) yaw |
color |
image | 128×128 RGBA PNG, transparent background, premultiply before compositing |
depth |
image | 16-bit PNG, depth = lo + u16/65535·(hi−lo), range [−1.5, 1.5] m around the figure, 0 = background |
normal |
image | RGB PNG, camera-space normal n = rgb/255·2−1 |
seg |
image | 8-bit PNG, value = joint id + 1 of the bone owning the pixel (0 = background), majority over a 4×4 supersample → hard edges |
Binary columns are raw little-endian arrays: np.frombuffer(row[col], dtype).reshape(shape).
Skeleton (cskel27, index order): Hips, Spine, Spine1, Spine2, Spine3, Neck, Head, RightShoulder, RightArm,
RightForeArm, RightHand, RightHandEnd, RightHandThumb1, LeftShoulder, LeftArm, LeftForeArm, LeftHand, LeftHandEnd,
LeftHandThumb1, RightUpLeg, RightLeg, RightFoot, RightToeBase, LeftUpLeg, LeftLeg, LeftFoot, LeftToeBase.
Colour code (figure's own left/right): head, neck, torso, clavicles black; left upper arm ■ #E84030, left forearm+hand ■ #FF9628;
right upper arm ■ #286EE6, right forearm+hand ■ #50C8F0; left thigh ■ #C832A0, left shin+foot ■ #FF78C8;
right thigh ■ #1E965A, right shin+foot ■ #78DC5A (generator/render.py:PALETTE, keyed by the bone's child joint).
Colours are anti-aliased (4× supersampled); if you need hard-edged colour, rebuild it from seg + the palette.
motion config — one row per clip (1,340 rows, 327 MB). Raw output of the motion generator (NVIDIA ARDY):
posed_joints f32[T,27,3] (world, m), local_rot_mats / global_rot_mats f32[T,27,3,3], root_positions,
smooth_root_pos f32[T,3], global_root_heading f32[T,2], foot_contacts bool[T,4], plus frame0_basis f32[3,3]
(rows = figure-frame x/left, y/up, z/forward in world coordinates; figure_joints = (posed_joints − Hips) @ basis.T,
before bone_scale). Same clip_id (minus the camera suffix), split, group as frames.
Splits
Split is by ARDY generation seed: seeds 0--7 train, seed 8 validation, and seed 9 test. All 134 prompts and all camera families occur in every split, while the underlying source-motion realizations remain disjoint. This is an in-domain generation split; it does not claim zero-shot generalisation to unseen prompt vocabulary.
| motion clips (×3 cameras) | frames | prompts | |
|---|---|---|---|
| train | 1,072 | 385,920 | 134 |
| validation | 134 | 48,240 | 134 |
| test | 134 | 48,240 | 134 |
Prompt curation (v0.2). Nine of the 143 generated prompts are excluded from the release because their ARDY
motions do not visibly perform the requested action in this rendered domain: near-static failures (sways to slow
music), motion that cannot render (shakes their head no — the head is a filled circle), unrecognisable or absent
actions (yoga warrior pose, yoga tree pose, sit up, push up, standing long jump — the figure glides without
an airborne phase), interactions with objects that do not exist in the render (climbs over a low wall), and
lies down on the floor. The exclusion list with per-prompt reasons ships as prompts/v02_excluded.txt in the code
repository. Stillness prompts whose stillness is semantically correct (the idle group, stands-* prompts, balances on
one leg) are kept even when the frozen QA flag fires.
How it was made
prompt → NVIDIA ARDY text-to-motion (6 s, 20 fps, seeds 0–9) → 27-joint skeleton in a canonical figure frame,
per-clip body jitter (bone lengths ±8 %, stroke, scale) → 3 orthographic cameras per clip (70 % from a canonical set of
yaws, 30 % uniform) → z-buffered capsule rasteriser writes colour / depth / normal / segmentation in one pass →
parquet. Everything is deterministic from clip_id; the generator is in the repo (generator/).
Motion prompts: 134 hand-written English sentences in 6 groups (dance 33, gesture 29, locomotion 21, transitions 13, idle 10, sport 28); acrobatics and moonwalk were removed during generation QA, and nine further prompts were removed by the v0.2 release curation above (ARDY did not render them faithfully).
Historical v0.1 baselines and the structural evaluator
The results below were produced on the original prompt-disjoint v0.1 partition. They document the released checkpoints, but they are not the official v0.2 seed-split baseline; a matched v0.2 reference run is reported separately.
Because every bone has its own colour, a rendered frame can be parsed: count colour segments per limb, check they touch their parent, and measure colour purity. The v0.1 files called this rule-based checker oracle v0; the current paper uses the more descriptive name structural evaluator. It reports:
- tvr — topology violation rate: fraction of the eight limb colours whose visible mask has a connected-component count other than one (missing, detached/fragmented, or duplicated colour regions)
- lie — limb-identity/adjacency error: fraction of the eight expected torso→proximal or proximal→distal colour adjacencies that are absent (a full left/right chain swap preserves this graph and is not detected by v0)
- cpe — colour purity error: fraction of foreground pixels with an undefined colour
- clean — fraction of frames with lie = tvr = 0
Real frames do not score 0: an occluded arm looks like a missing arm to a pixel parser. So every number is reported next to the score of real validation frames at the same resolution (the floor); a model at the floor makes these kinds of errors no more often than the data itself. The structural evaluator is blind to geometry such as proportions and joint angles; a validated learned rig estimator remains future work.
Unconditional image models, 512 samples each, 50 sampling steps (oracle v0):
| model | res | steps | tvr | lie | cpe | clean | floor tvr / lie / clean |
|---|---|---|---|---|---|---|---|
UNet, v-pred (ia64) |
64² | 30k | .159 | .113 | .041 | .42 | .142 / .106 / .40 |
DiT-FM p4 (ib64) |
64² | 30k | .176 | .122 | .040 | .38 | .143 / .108 / .37 |
UNet, min-SNR-5 (ia64L) |
64² | 96k | .134 | .116 | .039 | .43 | .136 / .103 / .40 |
DiT-FM p2 (ib64L) |
64² | 50k | .164 | .114 | .043 | .40 | .139 / .106 / .37 |
UNet, min-SNR-5 (ia128) |
128² | 20k | .226 | .073 | .020 | .22 | .203 / .047 / .23 |
DiT-FM p4 (ib128) |
128² | 40k | .251 | .065 | .020 | .23 | .209 / .048 / .21 |
Video (64², unconditional, UNet 46 M). Two 8-frame models (from scratch, 85k steps; warm-started from the image model, 61k) and one
autoregressive model (--ar_ctx 8: 8 context + 8 new frames per chunk, 10 fps, rolls out to any length; 60k steps). Oracle vs
real clips of the same length: per-frame anatomy within ~0.03 of real, temporal jitter 1.2–1.3× real, FVD ~80–100 above the
real-vs-real floor. Full table, checkpoints and GIFs: sprited/dancing-stick-figures-baselines.
Warm-starting from the image model reaches the same loss ~2.5× sooner but converges to the same quality. 5.6-second rollout:
DiT-track (Seedance-style two-stage, interim) and class-conditional checkpoints are in the same model repo.
Intended use / limitations
- Teaching and prototyping video/image diffusion, motion-conditioned generation, pose estimation from renders, I2V, and structural evaluation. Not a human-motion dataset: it is stick figures with a single body preset (jittered).
- Motion realism is bounded by the generator (ARDY); some prompts are only loosely followed. Use
qa_flagsand inspect motion samples when prompt semantics are central to an experiment. - 134 prompts is small for text conditioning; captions are the raw motion prompts. Dense templated captions (camera, body, root motion; dynamic + static) remain future work.
- The real-reference TVR is non-zero because occlusion hides coloured limbs at these resolutions (about 14% at 64²).
Versioning
- v0.1 (2026-08-18) — initial public release: 1,430 clips,
frames+motionconfigs, oracle v0, image baselines. - v0.2 (2026-08-25) — seed-disjoint in-domain train/validation/test partitions, visual-QA prompt curation (143 → 134 prompts), public-motion reconstruction and verification, seeded instructor render variants, prompt-conditioned reference models, and an image-to-video Colab lesson. A learned rig estimator remains future work until its generated-video scores are validated.
License and attribution
- Data (this dataset): CC0-1.0. Motion was generated with ARDY's 20-fps Core model; the original generation record did not retain the checkpoint revision. ARDY's source code is Apache-2.0; its released checkpoints are governed by the NVIDIA Open Model Agreement, which states that NVIDIA claims no ownership of generated outputs. The rendering, labels, and skeleton conventions are ours.
- Code (generator, trainers, oracle): MIT, https://github.com/sprited-ai/dancing-stick-figures.
If you use it:
@misc{dancingstickfigures2026,
title = {Dancing Stick Figures: A Synthetic Video Dataset, Renderer, and Diagnostic Evaluation Suite},
author = {Cho, Jin Hyuk},
year = {2026},
url = {https://huggingface.co/datasets/sprited/dancing-stick-figures}
}
Made by Sprited. Questions → open a discussion on this repo.