README.md

---
license: other
license_name: adobe-mixamo-terms
license_link: https://www.mixamo.com/#/faq
pretty_name: Mixamo Animations and Characters
language:
- en
size_categories:
- 1K<n<10K
task_categories:
- text-to-3d
tags:
- 3d
- animation
- motion
- character
- fbx
- skeletal-animation
- retargeting
- mocap
configs:
- config_name: animations
  default: true
  data_files: metadata.csv
- config_name: characters
  data_files: characters.csv
---

# Mixamo Animations and Characters

A complete snapshot of the [Mixamo](https://www.mixamo.com/) library: **2,317 motion clips** and
**114 rigged characters**, exported as binary FBX (FBX 7.7 / `fbx7_2019`) with per-file metadata.

All animations share one uniform 65-joint `mixamorig` skeleton, so any clip can drive any
compatible character without remapping.

**Use `animation_motion/` and `character_refined/`.** The full export contains 2,446 animation
files, but 129 are single-pose assets that carry no motion (Mixamo's `*_Pose*` library, plus
`T-Pose` and `Leaning`); `animation_motion/` is the 2,317 that actually move.

## Dataset structure

```
animation_motion/           2,317 .fbx   clips that move  <- use this
animation/                  2,446 .fbx   the full export, poses included
character/                    114 .fbx   T-pose characters with skin mesh, as exported
character_refined/            114 .fbx   same characters, bone namespaces normalised  <- use this
character_refined_glb/        114 .glb   character_refined/ converted to GLB, same stems
character_tpose/              114 .png   rest-pose render grid per character
animation_motion_ybot/      2,317 .fbx   every moving clip baked onto Y Bot — mesh + motion
                                         in one ready-to-play file
animation_motion_render/    2,317 dirs   four-view render of every moving clip on Y Bot
                                         (MP4 + camera JSON per view)

animation_motion_prompts.json            filename -> text label + Mixamo id, 2,317 entries
animation_motion_frames.json             filename -> keyframe count, 2,317 entries
static_clips.csv                         the 129 files left out, with the measurement behind it

animation_prompts.json                   the same, over all 2,446
animation_frames.json                    the same, over all 2,446
animation_bones.json                     the 65 bone names used by every animation
metadata.csv                             browsable index of all 2,446 animations
characters.csv                           browsable index of all 114 characters
characters.json                          filename -> character name + uuid
character_bones.json                     filename -> that character's bone list
character_bone_fix_applied.txt           the 27 characters whose bones were renamed
character_nonstandard_rig.txt            the 4 characters not using `mixamorig:` naming
scripts/                                 download, indexing, normalisation and validation code
```

Every JSON index is keyed by FBX filename and maps 1:1 onto the files. The `animation_motion_*`
pair covers exactly the 2,317 files in `animation_motion/`; the unsuffixed pair covers all 2,446.
Files in `animation_motion/` are the same bytes as their counterparts in `animation/`.

## Static clips

The 129 pose files were found by decoding every animation curve and measuring its peak-to-peak
range, not by filename — the split is unambiguous (largest static reading 0.024, smallest moving
one 1.115, nothing between). Quiet clips like breathing idles and held guards are kept.
`static_clips.csv` lists all 129 with the measurement and the reason.

## Tabular index

Two CSVs make the dataset browsable in the dataset viewer and loadable without downloading any
FBX. `metadata.csv` — one row per animation, covering all 2,446 files:

| column | meaning |
|---|---|
| `file` | path to the FBX, e.g. `animation/Jab_Cross.fbx` |
| `prompt` | Mixamo's catalogue name |
| `description` | Mixamo's longer description (empty for 51 clips) |
| `text` | `description` if present, else `prompt` — a ready-to-use label |
| `frames` | keyframe count |
| `motion_id` | Mixamo motion UUID |

`characters.csv` — one row per character, with `bone_count` and `covers_animation_rig`
(`true` for the 97 characters whose skeleton covers all 65 animation bones).

```python
from datasets import load_dataset

anims = load_dataset("Linzhan/Mixamo-Animations-Characters", "animations", split="train")
chars = load_dataset("Linzhan/Mixamo-Animations-Characters", "characters", split="train")

mid = anims.filter(lambda r: 30 <= r["frames"] <= 300)                 # 1–10 s at 30 fps
ok  = chars.filter(lambda r: r["covers_animation_rig"] == "true")      # drop-in retargetable
```

## Animations

- **Count**: 2,317 clips that move (2,446 including poses)
- **Format**: binary FBX 7.7, 30 fps, skeleton + animation curves only (no mesh)
- **Skeleton**: identical 65-joint `mixamorig` rig in *every* clip
- **Length**: 8 – 1,884 keyframes in `animation_motion/`

Files are named after the motion, e.g. `Jab_Cross.fbx`; distinct motions sharing a Mixamo name
get a numeric suffix (`Waving.fbx`, `Waving_2.fbx`).

### `animation_motion_prompts.json`

```json
"180_Turn_W_Briefcase.fbx": {
  "prompt": "180 Turn W/ Briefcase",
  "description": "180 Turn With Briefcase",
  "motion_id": "c9c9f110-b96c-11e4-a802-0aaa78deedf9"
}
```

| field | meaning |
|---|---|
| `prompt` | Mixamo's catalogue name. Present for every clip; short (mean 2.6 words), sometimes abbreviated (`W/`, `2hand`, `L`/`R`) |
| `description` | Mixamo's longer description; fuller and usually more specific. Present for every entry — filled with `prompt` where Mixamo ships none, so it can be read without a fallback |
| `motion_id` | Mixamo's internal motion UUID |

For text-conditioned tasks, `description or prompt` is the more discriminative label
(2,134 unique strings vs 1,541 from `prompt` alone).

### `animation_motion_frames.json`

`"180_Turn_W_Briefcase.fbx": 68` — keyframe count parsed from each FBX, not a nominal duration.

### `animation_bones.json`

`{ "mixamo": ["mixamorig:Head", "mixamorig:HeadTop_End", "mixamorig:Hips", ...] }` — the 65
bone names present in every animation: hips/spine/neck/head chain, both arms with full
four-joint fingers, and both legs with toes.

## Animated characters (`animation_motion_ybot/`)

The raw animation FBXs carry no mesh, so this folder ships every clip in `animation_motion/`
baked onto `character_refined/Y_Bot.fbx` — the character whose skeleton the animations are
authored on, so no retargeting touches the motion. One FBX per clip, same stems as
`animation_motion/`: armature, skinned mesh, materials and the full-length clip in a single
ready-to-play file (~3 MB each, 6.8 GB total). Drop one into Blender or any FBX viewer and
press play; these are also the exact inputs the renders below were made from.

## Renders (`animation_motion_render/`)

A four-view render of every clip in `animation_motion/`, driven on Y Bot
(the files in `animation_motion_ybot/`). One folder per clip, named after the FBX stem:

```
animation_motion_render/Jab_Cross/
  v000.mp4  v000.json      front  (azimuth  -90°)
  v001.mp4  v001.json      back   (azimuth  +90°)
  v002.mp4  v002.json      left   (azimuth  180°)
  v003.mp4  v003.json      right  (azimuth    0°)
```

Rendered with Blender EEVEE at 512×512, 30 fps, elevation 0, and composed into one H.264 MP4
per view — the transparent-film frames flattened onto a light-grey background, since H.264
carries no alpha. The MP4s preview each motion directly on the Hub; the per-frame RGBA PNGs
behind them are not hosted (they would add over 800k files), so extract stills from the MP4s
(`ffmpeg -i v000.mp4 frames/%04d.png`) if you need them.

Rendering covers the first 200 frames of a clip (~6.7 s); 375 of the 2,317 clips are longer
and are truncated — `frame_start`/`frame_end` in the per-view JSON record the covered range.
Frame counts otherwise match `animation_motion_frames.json` exactly.

Each `v00X.json` holds the camera in NeRF convention: `view`, `azimuth`/`elevation` (radians),
`resolution`, `camera_angle_x` (horizontal FoV, radians), the 4×4 camera-to-world
`transform_matrix`, the `scene_scale`/`scene_offset` that normalised the character into frame,
and `frame_start`/`frame_end`/`fps`.

## Characters

- **Count**: 114 characters, T-pose, **with skin mesh and materials**
- **Rig size**: 37 – 112 bones (Mixamo characters genuinely differ; some omit finger joints,
  others add eyes or extra joints)

`characters.json` maps each file to its Mixamo name and uuid; `character_bones.json` lists the
actual bone names per character.

### `character/` vs `character_refined/`

27 of the 114 characters export with a **numbered bone namespace** — `mixamorig1:Hips` instead
of `mixamorig:Hips` — which does not match the animations, so retargeting silently fails.
`character/` keeps the files exactly as exported; `character_refined/` renames the namespace
back to `mixamorig:` with a surgical binary-FBX rewrite that leaves every non-string property
byte-identical (verified both ways by `scripts/verify_refined.py`). **Use `character_refined/`.**
The affected files are listed in `character_bone_fix_applied.txt`.

### `character_refined_glb/`

The same 114 characters converted one-to-one to GLB — mesh, rig and materials with textures
embedded, no animation — for toolchains that read glTF rather than FBX. Same stems as the FBXs.

### `character_tpose/`

One 1024×1024 PNG per character, named after the FBX stem: a 2×2 grid of its rest pose —
front and back on the top row, left and right below — rendered (EEVEE) from
`character_refined/`. A visual index of the 114 characters.

## Retargeting compatibility

| | count | notes |
|---|---|---|
| Cover all 65 animation bones | **97 / 114** | drop-in retargetable |
| Reduced `mixamorig` rig | 13 | 37–64 bones, nearly always fewer finger joints. Retargeting works; absent bones simply receive no data |
| Different bone naming | 4 | listed in `character_nonstandard_rig.txt`; three use standard names with a different prefix, one (`Aiden`) uses 3ds Max Biped naming |

## Usage

```python
import json

prompts = json.load(open("animation_motion_prompts.json"))
frames  = json.load(open("animation_motion_frames.json"))

# text label for a motion-conditioned model
text = {f: (v.get("description") or v["prompt"]) for f, v in prompts.items()}

# clips between 60 and 300 frames
clips = [f for f, n in frames.items() if 60 <= n <= 300]
```

Load an animation onto a character in Blender:

```python
import bpy
bpy.ops.import_scene.fbx(filepath="character_refined/Adam.fbx")
bpy.ops.import_scene.fbx(filepath="animation_motion/Jab_Cross.fbx")
# both armatures now share the `mixamorig:` bone namespace
```

## Known limitations

- **62 clips have no `description`**; 23 of those share a `prompt` with other clips and cannot
  be told apart from text alone. Even preferring `description`, 341 clips share a label with
  another clip.
- In `animation_motion_prompts.json`, `Female`/`Male` style prefixes and leading
  `Sequence -` markers have been stripped from `prompt`/`description` — they describe
  animation style, not motion semantics. `animation_prompts.json`, `metadata.csv` and the
  filenames keep the original Mixamo labels.
- Mixamo `MotionPack` bundles are excluded, as their constituent clips are present individually.

## Provenance

Exported from Mixamo through its own export API (`format=fbx7_2019`, `skin=false` for
animations, `skin=true` for characters), retargeted onto the standard Y Bot skeleton. Every FBX
parses without truncation, every index key matches its file, and all names/ids were
cross-checked against the Mixamo API; `scripts/` reproduces the download, the indexes and all
checks.

## Terms

Mixamo content is provided by Adobe and remains subject to
[Adobe's Mixamo terms](https://www.mixamo.com/#/faq). This repository is a convenience mirror for
research use; consult those terms before redistributing or using the assets in a product.

## Citation

```bibtex
@misc{mixamo_animations_characters,
  title  = {Mixamo Animations and Characters},
  author = {Linzhan Mou},
  year   = {2026},
  url    = {https://huggingface.co/datasets/Linzhan/Mixamo-Animations-Characters},
  note   = {FBX motion clips and rigged characters exported from Adobe Mixamo}
}
```