---
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 and the skills). Its models, animations and textures, Anima included, are CC BY 4.0: free to use with attribution to Jimmy Lee (j@internet.dev). 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.15.35"
  title: Character models
---

# Character models

Anima is Set's one base character model, an original work by Jimmy Lee, Head of Design at Vmax.ai and Partner at Internet Development Studio Company (INTDEV, internet.dev). Anima is CC BY 4.0: free for any project, commercial ones included, with credit ([Credit it](#credit-it)). 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 | 33,500 rendered body triangles (16,775 vertices), plus two projected eyes and a faint tattoo of the author's mark on the right shin |
| Rig | 48 bones (`set-world-0-14-6-anima-rig-1`): 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, 5.027 to the ear tips. Set's scenes place actors at a uniform scale of 0.6 |
| Legs | Mirror images. Left hip (0.42, 1.38, 0.06), knee (0.42, 0.88, 0.02), ankle (0.42, 0.38, 0.06); the right leg negates x. Thigh 0.502 and shin 0.502 long. The knee sits straight in front of the hip–ankle line, so it hinges about the x axis |
| Feet | A flat sole on y = 0, 0.759 from heel to toe, toes turned slightly out. Every horizontal section of a leg and foot is convex, so footwear wraps it without bridging a hollow |
| Ears | Rigid to the head: they rise from the upper sides of the skull in a V, lean back, and turn their hollows forward and out |
| Material | One opaque metal. Exports carry the plain base colour, not the runtime liquid-metal shader |
| Variants | None: no gender or shape variants; identity comes from colour and equipment. In crowds, and in the reflections and shadows of the temple of `/anima-adventure`, the body may drop sub-pixel triangles ([Item models](https://set.world/skills/anima-item-models) states the rule) |
| Versions | Form `set-world-0-15-35-anima-base-1`, visual `set-world-0-15-35-anima-metal-1`, motion `set-world-0-15-35-anima-motion-2` |

A published file keeps the release it was prepared under, so the rig stamp and the `formVersion` inside the file can name an older release than the form above. Compare stamps by the rule after the release, never as whole strings ([API connection](https://set.world/skills/api-connection#rule-stamps)).

## 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, eyes and tattoo, plus every item the preview wears and holds from the sidebars, with a Breathing clip, its version stamps, its attribution in the root node's `extras` and the credit in glTF `asset.copyright`. 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');
```

## Credit it

Anima, its prepared files and every model and clip you download are CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). Use them for anything, commercial games included, and give attribution wherever you use or share them, in your credits, documentation or store listing:

```text
Jimmy Lee (j@internet.dev)
```

Say if you changed the model. Every file states this itself, so a copy that travels without this page still says whose it is:

| Where | What it carries |
| --- | --- |
| `anima.glb` and every motion GLB, root node `extras` | `author`, `contact`, `attribution`, `license`, `licenseUrl`, `notice` |
| The same GLBs, glTF `asset.copyright` | `© 2026 Jimmy Lee (j@internet.dev). CC BY 4.0: free to use with attribution to Jimmy Lee (j@internet.dev). https://creativecommons.org/licenses/by/4.0/` |
| The published metadata file below | The same fields, plus `copyright` |

The notice in full: Made by Jimmy Lee (j@internet.dev). Free to use for any purpose, commercially too, under CC BY 4.0, as long as you credit Jimmy Lee (j@internet.dev) wherever you use or share it.

## 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-v1.json   # readable metadata: versions, coordinate frame, rig, parts
curl -O https://set.world/anima/base-v1.bin    # native format 3: positions, normals, joints and weights (1,355,660 bytes)
```

```ts
type AnimaMetadata = {
  name: 'Anima';
  formVersion: string;
  file: string;                    // the binary beside it
  bytes: number;
  nativeFormat: 3;
  sha256: string;                  // of the binary
  authoringSha256: string;         // of the authoring source the mesh was prepared from
  construction: string;            // the rest mesh, described in prose
  author: string;                  // "Jimmy Lee"
  contact: string;                 // "j@internet.dev"
  attribution: string;             // "Jimmy Lee (j@internet.dev)": the credit to give
  license: 'CC-BY-4.0';
  licenseUrl: string;              // "https://creativecommons.org/licenses/by/4.0/"
  notice: string;                  // the terms in one sentence
  copyright: string;               // the same line the GLB carries in asset.copyright
  rigged: true;
  rig: {
    version: string;
    sourceGeometrySha256: string;  // the mesh this rig was fitted to
    description: string;
    bones: Array<{ name: string; parent: string | null; position: [number, number, number] }>;   // 48 bones, parent first
    arms: Record<'right' | 'left', unknown>;   // joints, digits, palm contact and grip curves
    legs: Record<'right' | 'left', {
      part: string;                          // "left-leg-and-foot"
      sign: -1 | 1;                          // -1 right, 1 left
      bones: [string, string, string];       // thigh, shin, foot
      joints: [[number, number, number], [number, number, number], [number, number, number]];   // hip, knee, ankle
      sole: Array<[number, number, number]>;  // 44 foot contact samples
      instep: { pitch: number; support: number[] };   // the kneeling foot's ankle heights
    }>;
  };
  rawTriangles: number;
  skin: { vertices: number; triangles: number; topology: string };
  charts: { quads: number; singles: number; method: string };   // triangles paired into square surface charts
  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": "set-world-0-14-6-anima-base-1",
  "file": "base-v1.bin",
  "bytes": 1355660,
  "nativeFormat": 3,
  "author": "Jimmy Lee",
  "contact": "j@internet.dev",
  "attribution": "Jimmy Lee (j@internet.dev)",
  "license": "CC-BY-4.0",
  "licenseUrl": "https://creativecommons.org/licenses/by/4.0/",
  "notice": "Made by Jimmy Lee (j@internet.dev). Free to use for any purpose, commercially too, under CC BY 4.0, as long as you credit Jimmy Lee (j@internet.dev) wherever you use or share it.",
  "copyright": "© 2026 Jimmy Lee (j@internet.dev). CC BY 4.0: free to use with attribution to Jimmy Lee (j@internet.dev). https://creativecommons.org/licenses/by/4.0/",
  "rigged": true,
  "rig": {
    "version": "set-world-0-14-6-anima-rig-1",
    "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": 33876,
  "skin": { "vertices": 16775, "triangles": 33500, "topology": "Named parts; the body and each arm/hand and 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": 9216, "firstTriangle": 0, "triangles": 9216, "bounds": { "min": [-0.6651848930975366, 1.043, -0.2977345039297566], "max": [0.6651848930975366, 2.973, 0.581428336078836] }, "topology": { "connectedComponents": 1, "boundaryEdges": 0, "nonManifoldEdges": 0 }, "regions": ["oval-body"] }
    /* … 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.

## Plant the feet

The legs in the metadata are what Set's own motion uses to stand Anima on the floor:

- **Contact.** `sole` holds the front-most and back-most point of the foot at each height from the sole to the ankle. Rotate them about the ankle by the foot's orientation; the lowest one is the point that touches the floor, so a heel strike, a toe-off and a turn all pivot about the right spot. Set raises that point by the surface thickness (0.028) so the visible skin meets the floor.
- **Kneeling.** `instep.support[i]` is the ankle height at which the foot, pitched toes-down by `instep.pitch · i / (n − 1)` radians about x (2.85 at the end, 33 samples), rests its instep and lower shin on the floor. Interpolate between neighbours for any pitch in between. Every eighth value and the last, for the left foot: `[0.38, 0.63882, 0.600862, 0.302032, 0.159618]`.
- **Knees.** Solve each leg with two-joint IK and a pole in front of the knee; the bind pose already bends forward, so the knee hinge is the leg's x axis.

Both are measured from the mesh when it is prepared. Your game may ignore them and solve feet its own way.

## Colour a character by its traits

Each generated character gets one body colour from its advantages and disadvantages alone (`set-world-0-15-35-anima-trait-color-2`), so the same character always looks the same:

- The 9 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, offset a little by a hash of its name. Talents add nothing.
- 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%). A character with no advantage and no disadvantage has no pull and is a neutral grey.

The exported GLB is the default grey (`#7d848e`); tint the material in your engine. The tattoo on the right shin is its own mesh with its own material, a little darker than the body's: tint it slightly darker than the body so it stays a faint watermark. 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;             // "set-world-0-15-35-anima-base-1"
  color: string;                   // the trait colour, as hsl(); this one is the example character's
  scale: number;                   // 0.6 in Set's scenes
  outfit: ItemModelRef[];          // Item models: one per item, from its slot, gear and material
};
```

```json
{
  "characterId": "hero-1",
  "model": "anima",
  "formVersion": "set-world-0-15-35-anima-base-1",
  "color": "hsl(117.1, 56.8%, 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.
