---
name: set-anima-character-models
description: How to use and download Anima, Set's rigged 3D base character model. Use when a game needs a body for a generated Set character, a rigged GLB, the model's coordinate frame, size and triangle counts, the schema of its published metadata file, or a body colour derived from the character's traits.
license: Free to use when obtained from set.world, commercially too (the API, what it returns, the skills and downloaded models). The source code of Set is © Jimmy Lee under CC BY-NC 4.0 and its commercial use needs a paid waiver.
metadata:
  version: "0.8.9"
  title: Character models
---

# Character models

Anima is Set's one base character model, an original work by Jimmy Lee. A copy downloaded from set.world is free to use in any project, commercial ones included ([AGENTS.md](https://set.world/AGENTS.md) has the license). Every character Set shows (portraits, the scene, the army, the dungeon's enemies) is the same body, coloured by its traits and dressed in its generated equipment. It belongs to AnimaSystem, Set's own game layer in the browser: no API response contains a model, and your game can use any model it likes.

## Facts

| Property | Value |
| --- | --- |
| Geometry | 24,216 rendered body triangles (12,143 vertices), plus two projected eyes |
| Rig | 48 bones (`anima-rig-5`): pelvis, spine, chest, head; per arm upper arm, forearm, forearm twist, hand and three joints per digit; per leg thigh, shin, foot |
| Skinning | Linear blend, four influences per vertex |
| Coordinates | Y up, forward −Z, feet on y = 0, torso centre x = 0 |
| Size | 4.16 model units to the top of the head. Set's scenes place actors at a uniform scale of 0.60 |
| Material | One opaque metal. Exports carry the plain base colour, not the runtime liquid-metal shader |
| Variants | None. No LOD, no gender or shape variants; identity comes from colour and equipment |
| Versions | Form `anima-base-14`, visual `anima-metal-49`, motion `anima-motion-56` |

## Download the model

The GLB is built in the browser; there is no static GLB URL and no model API.

1. Open `https://set.world/anima`.
2. In the **Base avatar** column, wait for the model, then choose **Download model**.
3. The browser saves `anima.glb`: the rigged body and eyes with a Breathing clip, its version stamps, and `author` and `license` in the root node's `extras`. The floor is not included.

An agent with a browser tool can do the same. With Playwright:

```js
await page.goto('https://set.world/anima');
const [download] = await Promise.all([
  page.waitForEvent('download'),
  page.getByRole('button', { name: 'Download model' }).first().click(),
]);
await download.saveAs('anima.glb');
```

## Load it

```ts
import { AnimationMixer } from 'three';
import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';

const asset = await new GLTFLoader().loadAsync('/assets/anima.glb');
scene.add(asset.scene);
const mixer = new AnimationMixer(asset.scene);
if (asset.animations[0]) mixer.clipAction(asset.animations[0]).play();
```

Call `mixer.update(deltaSeconds)` in your render loop. For a crowd, clone with skeletons (`SkeletonUtils.clone`), share geometry and materials, and give each character its own mixer. The motion clips are in [Animations](https://set.world/skills/anima-animations).

## The published metadata file

Set also publishes the prepared geometry it renders from, as static files:

```sh
curl -O https://set.world/anima/base-v14.json   # readable metadata: versions, coordinate frame, rig, parts
curl -O https://set.world/anima/base-v14.bin    # native format 3: positions, normals, joints and weights (984,500 bytes)
```

```ts
type AnimaMetadata = {
  name: 'Anima';
  formVersion: string;
  file: string;                    // the binary beside it
  bytes: number;
  nativeFormat: 3;
  sha256: string;
  author: string;
  license: string;
  rigged: true;
  rig: { version: string; bones: Array<{ name: string; parent: string | null; position: [number, number, number] }> };   // 48 bones, parent first
  rawTriangles: number;
  skin: { vertices: number; triangles: number; topology: string };
  eyes: { vertices: number; triangles: number };
  headBounds: { min: [number, number, number]; max: [number, number, number] };
  coordinateSystem: { up: [number, number, number]; forward: [number, number, number]; origin: string };
  parts: Array<{ id: string; name: string; material: string; sourceTriangles: number; firstTriangle: number; triangles: number; bounds: { min: number[]; max: number[] }; topology: Record<string, number>; regions?: string[] }>;   // 10 parts
};
```

The main fields, read from the published file (lists shortened):

```jsonc
{
  "name": "Anima",
  "formVersion": "anima-base-14",
  "file": "base-v14.bin",
  "bytes": 984500,
  "nativeFormat": 3,
  "author": "Jimmy Lee",
  "license": "Free to use when obtained from set.world, commercially too (the API, what it returns, the skills and downloaded models). The source code of Set is © Jimmy Lee under CC BY-NC 4.0 and its commercial use needs a paid waiver.",
  "rigged": true,
  "rig": {
    "version": "anima-rig-5",
    "bones": [
      { "name": "pelvis", "parent": null, "position": [0, 1.47, 0.11] },
      { "name": "spine", "parent": "pelvis", "position": [0, 1.91, 0.1] },
      { "name": "chest", "parent": "spine", "position": [0, 2.36, 0.08] }
      /* … 45 more, parent first */
    ]
  },
  "rawTriangles": 24592,
  "skin": { "vertices": 12143, "triangles": 24216, "topology": "Named parts; body and each leg/foot remain closed. Rendered triangles are the authored triangles." },
  "eyes": { "vertices": 192, "triangles": 376 },
  "coordinateSystem": { "up": [0, 1, 0], "forward": [0, 0, -1], "origin": "Ground beneath the torso center; the neck is centered at z=0." },
  "parts": [
    { "id": "body", "name": "Body", "material": "concrete", "sourceTriangles": 8394, "firstTriangle": 0, "triangles": 8394, "bounds": { "min": [-0.6678485003924316, 1.0979999992251397, -0.32421803784395137], "max": [0.6678485003924316, 2.8307043239474297, 0.5769560405337422] }, "topology": { "connectedComponents": 1, "boundaryEdges": 0, "nonManifoldEdges": 0 }, "regions": ["upper-torso", "smooth-rump"] }
    /* … 9 more: right-arm-and-hand, left-arm-and-hand, right-leg-and-foot, left-leg-and-foot, right-ear, left-ear, head, eye-1, eye-2 */
  ]
}
```

The binary layout is Set's own format; use the GLB unless you are porting the renderer.

## Colour a character by its traits

Each generated character gets one body colour from its skills, advantages and disadvantages (`anima-trait-color-1`), so the same character always looks the same:

- The nine stats sit 40° apart on a hue wheel: strength 0°, vitality 40°, resolve 80°, luck 120°, agility 160°, dexterity 200°, perception 240°, intelligence 280°, wisdom 320°.
- Each advantage and disadvantage pulls toward its primary and secondary stat by its signed impact; each skill adds a small pull at a hue hashed from its name.
- The summed pull gives the hue. Agreement between pulls raises saturation (0.28 to 0.82); a net gift lightens and a net burden darkens (lightness 40% to 62%).

The exported GLB is the default grey (`#7d848e`); tint the material in your engine. The eyes stay black with a white highlight, and the iris is the body colour mixed 45% toward white. The exact formula is §13.64 of the reference ([Algorithms](https://set.world/skills/algorithms)).

## A schema for a character's body in your game

```ts
type CharacterBody = {
  characterId: string;
  model: 'anima';
  formVersion: string;             // "anima-base-14"
  color: string;                   // the trait colour, as hsl(); this one is the example character's
  scale: number;                   // 0.6 in Set's scenes
  outfit: Array<{ slot: string; gear: string; material: string }>;   // from each item: slot, props[3].name, props[2].name
};
```

```json
{
  "characterId": "hero-1",
  "model": "anima",
  "formVersion": "anima-base-14",
  "color": "hsl(92.9, 62.1%, 53.3%)",
  "scale": 0.6,
  "outfit": [
    { "slot": "tool", "gear": "sword", "material": "steel" },
    { "slot": "chest", "gear": "tunic", "material": "silk" },
    { "slot": "head", "gear": "helm", "material": "leather" }
  ]
}
```

How each item is held or worn, and its own model, is in [Item models](https://set.world/skills/anima-item-models). To preview an outfit on the body in every motion: `https://set.world/anima?tool=sword&chest=tunic&chestMaterial=silk&head=helm`.

## Source

`three-isometric-engine/avatar/` (model, rig, motion, export), `common/anima-color.ts` (trait colour), `public/anima/` (native geometry). Set has not tested importing the GLB into other engines; check the file in your own pipeline.