Contents

M16: Any character, not only people

Status: design, 2026-10-06. Phase 1 built on the branch any-character, most of phase 2 on any-character-2 (2026-10-07); see "Phase 1: what was built" and "Phase 2: what was built" at the end.

Read with docs/adr/0004-3d-stage-2d-characters.md (cards on a 3D stage), docs/adr/0007-versioned-builders-and-canon.md (builder majors), docs/design/m1-engine.md (the card and the pose solver), docs/design/m1-compiler.md ("Metrics"), docs/design/m10-3d-characters.md (the figure swap) and docs/design/m14-immersive-editors.md (the character studio).

The question

The owner, 2026-10-06:

the character creation people should be able to literally make any type of character not just from a "People (cartoon character)" pattern, this is obvious.

The short answer:

• Today a character can only be a cartoon human. Every layer says so: the schema's body and head, the one rig template, the builders, the pose solver, the gesture library, the metrics the compiler frames by, the director's verbs and the create flow. A creature has been possible only as a prop: the fourteenth watch-it's kitten is a prop that flies, and the roadmap says "a creature that walks, sits and reacts needs its own rig".
• The fix is a body plan, not a free-form creature editor. A character gets an optional plan: what kind of body it has (a quadruped, a serpent, a blob, a robot, a talking object, and later a bird and an insect) and the few numbers and features that kind needs. Each kind has its own rig template, drawn by the same card on the same stage. Without a plan a character is a biped, so every show made so far reads, compiles and renders exactly as before.
• What a person cannot see the difference in is shared. Faces, expressions and lip sync are the same for every plan: the 2.5D head draws on any head, and each mouth kind (lips, a snout, a beak, a speaker grille, none) reads the same Rhubarb shapes its own way. Staging, framing and look targets go through one set of metrics, now aware of the plan, so a close-up of a snake finds its raised head and a cat's eye line is 25 cm off the floor.
• No new cues. A move is still a move. A robot rolls it, a snake slithers it, a cat walks it on four legs, a kettle hops it. A gesture the director names for a person ("waves") plays the plan's own stand-in (a paw lifted, a tail tip waved, an antenna blinked), chosen by the compiler from the plan's gesture library.
• Made from words. create_character turns "a grumpy three-eyed space slug who runs the cargo bay" into a whole character with no model and no cost; a connected model can say more (the kind, the plan, any field). Studio's New character offers any kind, described in words or picked from a plan, in the installed Studio and on the web alike.

What exists

The create flow and the cast today

• New character (ui/rw_create_dialog.gd) lists the show's CharacterPatterns and a count, and calls generate_characters. On the demo it offers "Marigold crew (cartoon humans)"; on a new show "People (cartoon humans)", the blank kit's pattern (library/blank/people.character-pattern.json). There is no other way to make a character in Studio, and none from a description anywhere: create_character does not exist. The model writes whole documents only for patterns (create_character_pattern).
• The cast is a list of names. A character opens in the character studio (M14 phase 2): turntable, the sheet's angles, expressions, mouths, poses, wardrobe, palette and props.

The character document

schemas/v1/character.schema.json (CharacterInstance 1.0) requires a human body and head:

• body: height, heads tall, build, silhouette, shoulder and hip widths, waist, belly, chest, neck, leg and arm length, hand and foot scale, 3 to 5 fingers, a posture (upright … hunched) and skin.
• head: a head shape (oval … bean), eyes (seven styles), brows, a nose, a mouth (simple, full lips, wide, small, toothy, under a mustache), ears (none, round, small, large, pointed, floppy), fifteen hairstyles, facial hair and face marks.
• costume: up to 16 garment layers in 13 slots and 39 cuts, all human clothes.
• palette, expressions (per emotion, a FACS-like set), mouths (Rhubarb A–H and X overrides), persona (role, traits, wants, fears, speech) and voice (a description and provider bindings). Canon is the approved model sheet and meta.locks.

The engine

• One template. library/biped_toon.v1.rig.json: 20 bones (root, hips, spine, chest, neck, head, and shoulder, upper arm, forearm, hand, thigh, shin and foot each side), the body and head parts, the 21 emotions' default faces and the 9 mouth shapes. biped_3d.v1 names it as its skeleton. An unknown template is drawn as biped_toon.v1.
• The card (RwCharacterCard) draws an RwCharacterRig 1:1 into its own viewport and stands it on its mark. The rig projects a pseudo-3D joint layout (RwJointLayout) at the view's yaw, skins the body parts (RwBodyBuilder: a torso of elliptical sections, tube limbs, garments as decals, coats in two halves, shoes as unions of ellipsoids) and hands (RwHandBuilder), and draws the continuous 2.5D head (RwHeadBuilder) on the head bone.
• The pose solver (RwPoseSolver) makes a pose from the actor's state: posture (stand, sit, crouch, lean, lie) as hip height and pitch, the stance, gestures from the library with two-bone IK for the aimed ones, breathing, the gait (a stepping cycle on two legs, or hop, slide and float), the arms by posture, prop reaches, the face, the look (eyes, head, body) and the mouth.
• The 3D figure (RwCharacterFigure, biped_3d.v1) builds a lathed torso, capsules and an ellipsoid head, and poses on the same solver.
• Libraries. biped_toon.v1.gestures.json holds 31 gestures, every one on biped bones. Walks are constants in the solver (STEPS, GAITS, the style's WALK_STYLES); postures are in RwCharacterMetrics; expressions and mouths are in the rig template.
• Lip sync. Rhubarb's A–H and X are open, width, round, teeth and tongue on the template (RwMouthParams), drawn as lips with teeth and a tongue.

The core

• Metrics (core/src/compile/metrics.ts, mirrored by RwCharacterMetrics): a vertical stack of head over torso over legs, a rigid upper body pitching about the hip. Height, eye, mouth, chin, shoulder, chest, waist, hip and knee all come from it, and through it framing (framing.ts: a close-up is 1.5 head heights with the eye on a third, a medium shot runs top to waist), look targets (targets.ts: a character is looked at in the eye), props (props.ts: carried at the waist, used at the mouth) and sightlines (sight.ts: a body is a head, a torso and legs).
• Walking. Gait speeds and cycle lengths are per gait (scene.ts), the same for every body.
• The heuristic director (director/action.ts, heuristic-perform.ts) reads human verbs: postures (sits, kneels, lies), gaits (runs, sneaks, "slithers" as a slide), 23 gestures named for biped bones, prop business with hands, floats and drifts. "It" is never a character's pronoun. The model director lists each template's gestures and refuses unknown ones.
• The showrunner's tools. generate_characters samples a pattern; revise_character edits pointers; vary redraws pointers from the character's pattern, else the theme's default pattern; create_character_pattern writes a pattern. A theme's catalog has species, which no code reads. The demo theme has an archetype.anxious_machine ("a ship robot or AI") that no pattern can draw.
• Props. A prop is drawn from a recipe and can fly, ride, be worn and perch on a shoulder, which is how the kitten and a parrot have been staged. It cannot walk, sit, emote or talk.

What that adds up to

Every one of these assumes a person, most of them for good reason: they are tuned, tested and watched. The design keeps all of it for bipeds and adds a way round each assumption that does not hold for another body, at the narrowest point where it can be added.

Prior art

• Toon Boom Harmony. Cutout rigs of drawings on pegs with deformers; turnarounds by swapping each part's drawing per angle; master controllers. Studios rig animals the same way as people, by hand, one rig per character. Taken: nothing new; the card already turns by projecting a pseudo-3D layout instead of swapping drawings, which is what lets a plan turn without anyone drawing its angles. Not taken: hand-built rigs per character.
• Spine and DragonBones. 2D bones, meshes and weights, IK constraints, skins (a set of attachments swapped on the same skeleton) and animations retargeted by bone name. Taken: skins are our extras (horns, a shell, antennae, whiskers on any plan); retargeting by name is why every plan has its own gesture library on its own bone names, and why a gesture names what it stands in for. Not taken: free-form meshes; our shapes are volumes so they can turn.
• Live2D. One illustration deformed by parameters (angle X and Y, eye open, mouth form) with physics on hair and ears. Taken: faces are parameters, as ours already are; secondary motion (a tail, ears, an antenna) as a function of state. Not taken: simulated physics, which would break seeking (ADR-0002: a frame is a pure function of time).
• Adobe Character Animator. Any puppet whose layers are tagged (Head, Mouth, Left Eye) gets lip sync, blinks and head turns, so a teapot can talk; behaviours (Walk, Dangle, Breathe) are added per puppet; its Walk behaviour is a biped's. Taken: the whole idea of a shared face: a plan with a face gets expressions, blinks and lip sync for nothing. Not taken: its viseme set; we keep Rhubarb's, and each mouth kind reads it.
• Cascadeur. Physics-assisted keyframing that keeps a body's balance and makes any rig, quadrupeds included, move plausibly. Taken: its rules of thumb as constants: a walking quadruped keeps three feet down, a gallop gathers and stretches, a small body steps faster (cycle time grows with the square root of leg length). Not taken: the physics solver.
• Spore, and No Man's Sky. Spore rigs any arrangement of limbs and retargets animation authored on limb roles, which makes every creature possible and most of them move generically. No Man's Sky uses a few skeleton families, each morphed by parameters. Taken: the family approach: a closed set of plans, each tuned by hand, morphed by parameters, plus attachable parts. Not taken: an arbitrary limb graph. Words map onto a family reliably; they do not map onto a graph, and a graph needs procedural locomotion we would have to invent and test for every arrangement.

The design

Principles

1. A kind, not a graph. A character's body is one of a closed set of plans, each with its own rig template, tuned by hand, and morphed by a few parameters. Hybrids are a plan plus attachments. New kinds arrive as new templates in new minor versions.
2. Bipeds do not move. No existing character, golden frame, swatch or sampler output changes. Absent plan means biped; the biped path keeps its code.
3. Share what a viewer reads the same. Faces, expressions, blinks, lip sync, looks, voices, personas, canon, palettes and the card on the stage are the same for every plan.
4. One contract for staging. Everything the compiler and directors need to know about a body is in its metrics, computed by the same formulas in the core and the engine and held together by tests, as for bipeds now.
5. No new cues; plans interpret. Moves, postures, gestures, looks, floats and props keep their meaning. The plan decides how its body does them, and the compiler resolves anything a body cannot do into what it can, with a note.
6. Words first. Anything a person can say ("a grumpy three-eyed space slug") becomes a character without a model, the same way with one.

The body plan in the document

CharacterInstance 1.1 adds an optional plan, and a few face features any plan may use.

"plan": {
  "kind": "serpent",
  "shape": "slug",
  "locomotion": "slither",
  "lengthHeads": 4.5,
  "legs": 0,
  "arms": 0,
  "tail": { "style": "none" },
  "markings": { "pattern": "spots", "color": "@markings" },
  "extras": ["antennae"],
  "accent": "@belly",
  "glow": "@glow"
}

• kind (required): biped, quadruped, serpent, blob, robot or object in 1.1; bird and insect follow (phase 2). Ghosts and floating things are blobs that hover; fish are serpents that swim (float); giants and tiny things are any plan at their height.
• shape: the body within its kind. Serpent: snake, slug, worm. Blob: drop, ball, ghost. Robot: box, can, dome. Object: kettle, teapot, mug, lamp, toaster, crate, book. The validator checks a shape fits its kind, as it will check a cut fits its slot.
• locomotion: how it gets about when a cue moves it: walk, hop, slither, roll, hover, waddle. Each kind has a default (a quadruped walks, a serpent slithers, a blob hops, a robot rolls, an object hops) and allows a few.
• drive (robots): wheels, treads, hover or legs.
• lengthHeads: body length front to back in head heights (a quadruped's trunk, a serpent's whole length).
• legs, arms: counts the plan draws (a quadruped 4; an object 0 or 2 stubby legs and 0 or 2 arms; a robot 0 or 2 arms; a blob 0 or 2 pseudopods).
• tail: none, thin, bushy, stub, curl or fin, with a length.
• markings: none, spots, stripes, patches, belly, mask or socks, in a color.
• extras: horns, antennae, antenna, whiskers, spikes, shell, mane: attachments any plan wears (the skins of Spine, the parts of Spore).
• accent (a belly, a muzzle, a robot's panels, a kettle's lid) and glow (a robot's eyes and lights, a ghost's aura, a lamp's bulb) are colors or palette slots.

And on the head, for any plan:

• head.eyes.count 1 to 3 (a cyclops, a three-eyed slug) and head.eyes.stalks (eyes on stalks, 0 to 1);
• head.muzzle (0 none to 1 a long snout);
• head.mouth.style gains snout (an animal's mouth under its nose), beak, grille (a speaker) and none.

body and head keep their fields and their meaning, read per plan: heightCm is the top of the head (or of the body, for a thing with its face on the body) standing at rest; headsTall sizes the head (or the face) against it; legLength is the legs' share of what is under the head; the shoulder and hip widths are the trunk's width; skin is the body's own color (fur, hide, metal, china). Hair is a tuft or a mane; ears, eyes, brows and nose are what they say. The required biped fields stay required: the generators fill them for every plan, a plan reads the ones it uses, and a 1.0 reader of a biped never meets a missing field. Making them optional for plans that do not read them is a 2.0 question, not worth a major now.

Costume layers stay human cuts. A plan draws the slots that fit it (headwear and eyewear on any head; neckwear as a collar on a neck; a badge on a trunk) and says it skips the rest (character.part_unsupported), so a cat in a cap and goggles works and a cat in trousers is told.

Versions and migration

• No existing document changes. A 1.0 character has no plan and is a biped; nothing rewrites it, and its frames do not move.
• Documents are raised, never lowered. As the EpisodeIR does (director/versions.ts), the core knows the minor version each feature needs (plan and the new face features: 1.1), and whatever writes a character (create, revise, vary, generate) raises its schemaVersion to what it uses. The validator says when a document uses a feature its version does not have (character.version). Generated bipeds stay 1.0, so samplers' outputs and hashes do not change.
• Builders. Plans are new templates, not new outputs of an old one, so ADR-0007's rule holds without a new major: builder.major stays 1 and every biped draws byte for byte as before. A plan's own builder output may change within major 1 until 1.0, like everything else (the ADR's addendum); from 1.0 a change to a plan's drawing ships as that template's next version (quadruped_toon.v2), and a locked character keeps its template until a migration is approved.
• Patterns. A CharacterPattern names the template it produces, so a pattern per kind needs no pattern change: its params address /plan/... pointers like any other.

The plans

Each plan below says what it is made of, how it moves, what it can do with its body, its face, how it stands on a mark and is framed, and how it sounds.

All plans share one convention: character space is centimeters, +x the character's left, +y up, +z forward, the floor point the origin; the bone hips is the body's root and is placed by the posture; the bone head carries the face. Each template lists its bones in its rig file, and its gestures in its own library, so a gesture names bones that exist.

Biped (unchanged)

• Parts and slots: torso, neck, arms, hands, legs, feet; the head's ears, eyes, brows, nose, mouth and hair; costume in its slots.
• Rig, locomotion, gestures, postures: as today: biped_toon.v1 and biped_3d.v1.
• Humanoid creatures (an alien with three eyes, a frog-man, a cat-person) are bipeds with the new face features and extras: a three-eyed alien needs no new plan.

Quadruped (cats, dogs, horses, lizards)

• Parts and slots: a trunk (rear and front body, one silhouette), a neck, a head, four legs (upper, lower, paw), a tail of three bones; ears from the head; markings on the trunk; a belly in the accent color.
• Rig (quadruped_toon.v1): root, hips (the rear), chest (the front), neck, head, front_upper/lower/paw_l/r, back_upper/lower/paw_l/r, tail_1..3.
• Locomotion. A walk is a four-beat walk (back left, front left, back right, front right, three feet down); a run is a gallop (the back legs together, the front legs together, the trunk gathering and stretching); a sneak is a stalk, low, the head forward; a hop bounds. Paws are planted by two-bone IK on the floor, so they do not skate. Cycle time grows with the square root of leg length, so a cat's legs blur and a horse's swing.
• Postures. Stand; sit on its haunches, the front legs straight; lie as a loaf, legs tucked; crouch low, ready to pounce; lean as a play bow, the front down and the rear up.
• Gestures (its library): nod, head shake, head tilt, paw lift and paw wave, tail wag, tail up, stretch, startle (a hop up with the back arched), bow (the play bow). Secondary motion: the tail sways always, wags when happy or excited, hangs when sad or afraid.
• Face. A head with a muzzle, a snout mouth under a triangle nose, whiskers as an extra. Every expression and mouth shape: the snout opens below the nose.
• Marks and blocking. Its footprint is long (trunk plus head and tail), its eye line low (a cat's at 25 cm); it stands on a mark like anyone; it has no hands, so it carries nothing in phase 1 (phase 2: in its mouth).
• Framing. A close-up is 1.5 head heights about its eye; a long shot fits its length as well as its height.
• Voice. Any voice, by the persona; small animals lean high and quick.

Bird and winged (phase 2)

• Two legs and two wings on a trunk with a beak: the quadruped builder with legs: 2 and wings, a beak mouth whose lower mandible drops with each shape's open. Hop and walk on the ground; fly as a float that flaps. Wings on any plan (a dragon, a winged cat) are the wings extra.
• As built: its own plan, bird (bird_toon.v1): an egg of a body breast up on two thin legs in the beak's color, the head on the breast, wings of two bones folded back along the sides, a fan of tail feathers. A move is a flight (the compiler's float.ts flightSpan: off the floor as it sets off, at two and a half times its height, down as it gets there, as the Timeline's Actor.floats), and the solver spreads and beats the wings and tucks the feet while the body is off the floor; a short hop stays on the ground. A hen or a penguin (locomotion: walk) walks with its head bobbing. Perched is its sit; it pecks (peck), flaps (wing_flap) and spreads its wings (wing_spread), and its wings stand in for a person's arms. The wings extra on other plans is not built.

Serpent and fish (snakes, slugs, worms, eels)

• Parts and slots: one body along a spine of seven segments, a neck that rises, a head; a slug's mantle and eye stalks; markings along the back; a belly in the accent color.
• Rig (serpent_toon.v1): root, hips (where the neck rises), seg_1..6 behind it, neck, head.
• Drawing. The body is the union of discs along the posed spine, thick to thin, so it is one smooth outline from every side, coiling over itself included.
• Locomotion. Slither: a wave travels back along the body while it moves forward, its cycle the wavelength over the speed. A slug inches: a ripple runs along it, slowly. A fish is a serpent that swims (it floats, and slithers in the air).
• Postures. Stand with the head raised; sit coiled, the head higher; lie flat; crouch in an S, ready to strike; lean forward, stretched.
• Gestures: nod, head shake, head tilt, sway, tail flick (its wave), strike (a lunge, for a startle), coil (held, for arms folded), bow.
• Face. A wide head; a wide mouth or a snout; eyes on stalks for a slug; a tongue flick between lines (phase 2).
• Marks and blocking. Long and low: its footprint is its coiled length; its eye is at the raised head. Framing: a close-up finds the raised head; a long shot fits its length.
• Voice. Anything; a hiss is a delivery note, not a plan.

Insect and many-limbed (phase 2)

• Six or eight legs along a segmented trunk (head, thorax, abdomen), antennae, mandibles: the quadruped builder with more legs and a tripod gait (three legs down at a time) or a spider's alternating tetrapod. Gestures are the quadruped's plus antenna waves.
• As built: its own plan, insect (insect_toon.v1), shaped as a beetle (a seam down its shell), an ant (a narrow waist, jaws) or a spider (eight long legs, fangs): an abdomen and a thorax low on legs that rise to their knees and splay to the floor, each planted by two-bone IK. It scuttles in two sets of legs by turns (three feet down at a time; a spider's four), its feet still while planted. Its gestures wave a front leg, waggle its head and antennae, rear up, hunker and bow.

Blob and amorphous (slimes, jellies, ghosts)

• Parts and slots: a soft body (a drop, a ball, or a ghost's sheet with a wavy hem), its face on the body, up to two pseudopods.
• Rig (blob_toon.v1): root, hips, chest (the top), head (where the face is), and arm_l/r for pseudopods.
• Locomotion. Hop: stretch on take-off, squash on landing, the style's squash and stretch scaling it. A ghost hovers: always off the floor, bobbing, its hem waving, tilting into the move. A sneak is an ooze, low and wide.
• Postures. Sit squashes it; lie is a puddle; crouch is half squashed; lean tilts it.
• Gestures: nod (a bob), head shake (a wobble), wave (a pseudopod, or a bulge if it has none), bounce, melt, stretch up (a startle), shrug (a squash and stretch).
• Face. The face is drawn on the body: the 2.5D face without a head outline, so it turns with the body. Every mouth kind works; a ghost's is usually an open O.
• Marks and blocking. Round footprint; eye line high on the body. A ghost's shadow stays on the floor, small and faint, as a float's does.
• Voice. By persona; ghosts often slow and breathy.

Robot and mechanical (wheels, treads, hover)

• Parts and slots: a chassis on a drive (two wheels, treads, a hover pad, or two stubby legs), a body (a box, a can, a dome), a head on a neck (a box head is the head shape square), up to two jointed arms with claws, an antenna; panels in the accent color, lights in the glow color.
• Rig (robot_toon.v1): root, hips (the chassis), chest (the body), neck, head, upper_arm_l/r, forearm_l/r, hand_l/r (claws). Its arms are named as a biped's, so a held prop goes in a claw the way it goes in a hand.
• Locomotion. Roll: the wheels turn exactly as far as it travels (the compiler sets the cycle to the wheel's circumference over the speed), the body leans into the move. Treads: the lugs run round. Hover: off the floor, a soft bob, a tilt into the move, a thruster glow under it. Legs: a toddling waddle.
• Postures. Sit lowers the chassis; lie powers down (the head droops, the eyes dim); crouch squats; lean leans.
• Gestures: its arms do a biped's arm gestures (wave, point, shrug, thumbs up, clap) on the same bone names; nod, head shake; beep (the antenna flashes, the head bobs); scan (the head sweeps); without arms, the head and antenna stand in.
• Face. Eyes as dots or buttons lit in the glow color; a grille mouth whose bars light with each shape's open; or a screen face (phase 2).
• Marks and blocking. Footprint of its drive; reach of its arms; eye at its head.
• Voice. A clipped, even delivery by default; a vocoder effect is phase 2.

Object with a face (a talking kettle)

• Parts and slots: the object's body (a kettle, a teapot, a mug, a lamp, a toaster, a crate, a book), its fittings (a spout, a handle, a lid, a shade), the face on the body, and up to two stubby arms and legs.
• Rig (object_toon.v1): root, hips (the object), head (the face's anchor), lid, arm_l/r, leg_l/r.
• Locomotion. Hop, with squash and stretch; with legs, a waddle that rocks it.
• Postures. Sit settles it; lie tips it over on its side; crouch squashes it; lean tilts it.
• Gestures: nod (a tip forward), head shake (a twist), hop, lid pop (the lid jumps: a startle, a fist pump), wiggle (a shrug), tilt toward the target (a point).
• Face. On the body, without a head outline; the lid rattles while it speaks.
• Marks and blocking. The footprint of the object; its eye line where its face is, not at its top. Framing: a close-up frames the face.
• Voice. By persona.

Hybrid, giant and tiny

• Hybrids are a plan with extras: a winged cat (a quadruped with wings, phase 2), a horned robot, a snail (a slug with a shell). A centaur (a biped trunk on a quadruped body) and riding are phase 3.
• Giant and tiny are any plan at its height: metrics, framing, reach, footprints and gait cycles scale with it. A tiny character's cycle is quick and a giant's slow; the set and its marks are unchanged, so a giant in a small set is a staging problem the director warns about (blocking.too_tall, phase 2), not a plan.

How the engine draws a plan

• The card is the same. RwCharacterCard stands any rig on its mark, at 1:1 on screen, with its blob shadow, its light and its ink. RwCharacterRig.create makes an RwPlanRig for a plan, which answers the same calls (draw_pose, content_rect, the grip, head-top, face and shoulder points), so the card, the model sheet, the silhouettes task and the character studio need nothing new.
• Drawn from the posed skeleton. A biped builds its body once per view and skins it; a plan builds its body each drawing from the posed bones, projected for the view: ellipsoids (an ellipsoid projects to an ellipse), tubes along posed joints, unions of discs along a spine, boxes and lathed profiles. Every view is exact and a body can coil, sit and roll without skinning artefacts. Its few shapes cost far less than the face, which is already built each drawing.
• The face is the head builder's. A plan's head bone carries RwHeadBuilder, with the new features (eye counts and stalks, a muzzle, the new mouths, whiskers, antennae, horns) and a bare mode that draws the face without a head outline, for faces on a body.
• Depth. Parts are drawn back to front by their depth toward the camera each drawing, the head with them, so a cat's far legs are behind its body from one side and in front from the other, and a snake's head is behind its coils when it turns away.
• Posing. RwPlanSolver (a pose solver for plans) shares the biped solver's face, mouth, look, blink, breathing, speaking accents and gesture tracks, and adds each plan's postures, gaits and secondary motion. The pose is a pure function of the state, as for bipeds.
• Not on plans yet: smears, line boil on the body (the face boils), hand shapes, and the 3D figure (a plan drawn in 3D is phase 3; until then a plan on a 3D template is drawn as a card, with a warning).

Gestures: each plan's own, standing in for a person's

• Each template has its own GestureLibrary (<template>.gestures.json) on its own bones.
• A gesture may say what it stands in for (standsFor, GestureLibrary 1.2): the quadruped's paw_wave stands in for wave, beckon and hand_out; its tail_wag for fist_pump, clap and thumbs_up; its head_tilt for shrug, chin_rub and head_scratch.
• The compiler resolves a cue's gesture against the character's library: the gesture itself if the library has it, else the first gesture standing in for it, else nothing, with a note (gesture.no_stand_in, info). The Timeline then holds the plan's own gesture, timed by its own length, so the engine never guesses and a stand-in is visible in the timeline.
• So the director need not know a body to direct it. The heuristic writes "waves" as wave; the cat lifts a paw. The model director is shown each character's library and its stand-ins.
• A gesture that needs arms (its hands are not none) on a plan without them (a robot with arms: 0) resolves to a stand-in with hands: none.

Lip sync for every mouth

Rhubarb's shapes stay the vocabulary, and the compiler's lip sync does not change. Each mouth kind reads a shape's open, width, round, teeth and tongue its own way:

The contract with the compiler: metrics per plan

metricsOf (core) and the plan's layout (engine) compute the same numbers from the same fields, held together by tests (eye within 5% of the metric in each posture, as for bipeds):

• Height H = body.heightCm; head headM = H / headsTall; face top faceTopM = H, except an object's or a blob's face, which is set into the body.
• Eye = faceTop − head × eyes.height; mouth as for bipeds, on the face.
• Footprint: halfWidthM (across) and lengthM (front to back): a quadruped's trunk, head and tail; a serpent's length coiled to half; a robot's drive.
• Body points (shoulder, chest, waist, hip, knee) by plan: the trunk's top, centre and belly, the leg's top and middle, so a medium shot of a cat runs head to belly.
• Postures keep their names; a plan scales the head's height in each (a cat sitting ×1.0, lying ×0.55, crouching ×0.75; a snake coiled ×1.1, flat ×0.35; a blob's puddle ×0.5), so look targets and framing follow the body.
• Gait speed and cycle per plan: a speed scale (a slug 0.25, a cat 0.9, a robot 1.0) and a cycle from the leg length or, for wheels, the circumference. The Timeline's gait spans carry them, so the engine's cycle is the compiler's.
• Reach: a plan with arms reaches as a biped does; without, a touch is a nose or a paw, within half its height.
• Framing: a long or wide shot of one character fits its footprint as well as its height, so a snake is not cropped.

The showrunner: any character from words

• create_character (new, a proposal like the rest): {description, name?, shortName?, kind?, plan?, edits?, seed?, options?, rationale}.
  • Reelwright's own reader turns the words into a character, deterministically: the kind and shape from nouns ("slug" → serpent/slug, "kettle" → object/kettle, "robot", "droid" → robot), features from adjectives and counts ("three-eyed" → eyes.count 3, "fluffy" → a bushy tail and a mane, "on wheels", "hovering"), size ("giant", "tiny", "knee-high"), colors by name onto the palette, the persona from the rest ("grumpy" → a trait, "who runs the cargo bay" → the role), and a voice to match the persona and size.
  • A connected model may pass the kind, the plan, a name and any edits (pointer and value, as revise_character takes them) on top: what it says wins, field by field, and the result is validated like any character.
  • options 2 to 4 draws a variation group, to pick from as Variations are.
• Patterns per kind. The blank kit gains a pattern per plan (Animals, Robots, Talking objects, Blobs and ghosts, Snakes, slugs and worms), copied into a new show as People is; the Marigold gains a robot pattern for its archetype.anxious_machine and a ship's-pet one. generate_characters needs no change.
• revise_character works on /plan/... like any pointer; vary varies a creature from a pattern that produces its template (the show's, else the kit's), never from the people.
• The brief prints a character's plan; the tool descriptions name the kinds.

The director: non-human performers

• Verbs. The heuristic reads every plan's verbs as moves (slithers, rolls, trundles, trots, pads, scampers, scurries, hovers, glides, oozes, waddles, bounds, prowls, slinks), and a plan's postures ("curls up" is sit, "coils" is crouch, "sprawls" is lie). The gait stays the person's word; the plan interprets it.
• "It." A character whose pronouns are it is "it" in action lines.
• Bodies without hands. Prop business on a plan with nothing to hold with is reported (director.no_hands) and not staged; touches are a nose or a paw.
• The model director sees each character's plan, its library and its stand-ins in its context, and its unknown-gesture check uses the resolution above.

Studio: any kind, in both editions

• New character asks what to make: "Describe it" (a text box, the default: "a grumpy three-eyed space slug who runs the cargo bay") or a kind (Person, Animal, Robot, Talking object, Blob or ghost, Snake or slug), then the show's patterns for that kind. Words call create_character; a kind with a pattern calls generate_characters; a kind without one calls create_character with that kind. The same dialog runs in the installed Studio and the web export.
• The character studio shows any plan: the turntable and the sheet's angles turn it; the expressions and mouths are the face's; the poses panel lists the plan's postures, gaits and library; the wardrobe offers the slots the plan draws; the Fields tab shows plan.
• The cast list says each character's kind.

What is worth building, and what is not

Worth it:

• The plan, its versioning, the five plans of phase 1, shared faces, metrics per plan, gesture stand-ins, the director's verbs, create_character from words, patterns per kind, and Studio. Each is a narrow change at a seam that already exists (the card factory, the rig template, the metrics, the gesture library, the tool registry).
• Proof the people do not move: goldens and swatches byte for byte.

Not worth it (now, or ever):

• A free-form creature editor (bones and limbs by hand, Spore's). It is the long way to a worse result for a show made from words.
• Physics for tails, ears and gaits: it breaks seeking. Secondary motion is a function of the state.
• Per-character hand-made cycles and keyframe posing: plans are tuned once, for everyone.
• New cue types per plan (slither, roll): the move cue and the plan say it.
• Creatures in 3D before the 2D plans settle: the figure is phase 3.
• A creature voice effect stack before pitch shifting works at all: Kokoro's takes ignore pitchSemitones today. Shifting is phase 2.

Phases

1. Phase 1 (this milestone's first build). CharacterInstance 1.1 (plan, the face features) with raising and the validator's checks; the five plans in 2D (quadruped, serpent, blob with ghosts, robot on wheels, treads or hover, and objects), their faces and mouths, locomotion, postures and gesture libraries with stand-ins; metrics per plan in the core and the engine; the director's verbs and "it"; create_character from words; a pattern per kind; New character for any kind in both editions; the character studio on plans; a test copy of the Marigold with a ship's cat, a maintenance robot and a slug.
2. Phase 2. Birds and insects (legs 2, 6, 8; wings; flying), carrying in mouths and claws, creature postures (beg, pounce, coil to strike), ears and tails by emotion everywhere, pitch shifting and a robot voice, a robot's screen face, smears and boil on plans, sightlines and occlusion by footprint, warnings for giants in small sets.
3. Phase 3. Sea life: fish, whales, octopuses, jellyfish, crabs and lobsters, swimming and scuttling sideways, for the product audit's Low Tide Blues.
4. Phase 4. Plans in 3D (the figure's primitives per segment), hybrids beyond extras (centaurs), riding, swarms.

Phase 1: what was built

• The document. CharacterInstance 1.1 adds plan (kind, shape, locomotion, drive, legs, arms, tail, markings, extras, accent, glow, lengthHeads) and the face features (eyes.count, eyes.stalks, the snout, beak, grille and none mouths). A person's file stays 1.0 byte for byte; anything that writes a plan feature raises the version (raiseCharacterVersion), and the validator refuses a plan on the wrong template, a shape, drive, legs or arms its kind does not have, and a 1.0 file that uses 1.1 (core/src/validate/ plan.ts). Costume beyond the head is warned about, not drawn.
• The engine. Five rig templates (quadruped_toon.v1, serpent_toon.v1, blob_toon.v1, robot_toon.v1, object_toon.v1) each with a gesture library. RwCharacterRig.create hands a plan to RwPlanRig (layout, solver and body per plan, drawn each frame from the posed skeleton with the shared 2.5D face of RwHeadBuilder); a person still gets the rig they had, untouched. A plan on the 3D template is drawn as a card and said so.
• Metrics, both sides. core/src/compile/plan.ts and RwPlan hold each plan's head share per posture, face top, leg top and pace, and how far ahead of its floor point it carries its head (POSTURE_FORWARD: a cat's face is at its front, so a close-up aims there, not at its flank); testdata/plans.json (from core/src/compile/plan-vectors.ts) is the contract: gdUnit holds every crew member's eyes, in every posture, within 6% of its height of where the core frames them, up and ahead.
• Moving. The move cue is unchanged; the plan says how: paws (planted while in stance), a slither, a roll whose wheels turn exactly as far as it goes, a hover, an ooze or a hop. Each kind crosses at its own pace (speedScale: a slug slowly, a robot nearly a person's walk). A slower body crossing the room holds its paragraph until it gets there (at most 4 s past it), so its next line is not said, and framed, halfway across; coming in through a door keeps the entrance's own shot.
• The turntable fits a plan whole: its top over every angle (eye stalks, an antenna), its length at the angle it is turned to.
• Gestures. A plan's library answers a person's gesture through standsFor; every one of the 40-odd gestures a person has resolves on every plan, with arms or without. A cat's front paws gesture (gestureLimbs) though it holds nothing (planArms).
• From words. create_character reads the description itself (core/src/generate/ character/describe.ts): kind and shape from the noun, features, size, colors, persona and a voice; kind, plan, name and edits win over the reading; options makes a variation group. The blank kit has a starter pattern per kind (library/blank/*.character-pattern.json); vary on a creature draws from its kind's pattern (the show's, else the kit's), and a color a redraw names that the creature lacks comes from that pattern's palette, solved around its own.
• The director. Creature verbs (rolls, trundles, hovers, oozes, pads, prowls, zooms, flutters, clanks…) as entrances, exits and crossings; "curls up", "coils", "powers down" as postures; a creature named by what it is ("the robot", "the cat") when it is the only one of its kind on the cast; prop business for a body with nothing to hold with is said (director.no_hands), not staged.
• Studio. New character opens on words; kind buttons (Person, Animal, Snake or slug, Blob or ghost, Robot, Talking object) offer the show's patterns of that kind, or make one of that kind from words when it has none. The cast list badges each kind; the character studio turns any plan, and its Variations offer the plan's own fields.
• Not built in phase 1 (phase 2 built the first and the entrance, below): "it" as a creature's pronoun in action lines (the reader's "it" is the last prop, and changing that needs its own care); a robot pattern and a ship's-pet pattern in the Marigold (the demo show stays as it was, so its goldens do; vary uses the kit's); the model director's context lists plans but its unknown-gesture check is unchanged. A small creature's entrance shot is framed for its size and holds still while it walks off; the coverage after a door is a person's. A framed shot is solved where its subject is when it starts, so anyone still walking then (people too) is framed where they were.

What it looks like (tools/crew-watch.sh, node tools/web/crew-check.ts, and model sheets of the crew fixtures):

Phase 2: what was built

• Phase 1's open issues, each with a test that failed first. A look at someone still on their way follows them to where they stop (compile/performance.ts), so the cover and the compile agree on a slow crew; eyes on stalks are framed where the stalks hold them, over the head, and the head's top clears them; a small creature's entrance shot pans with it, or takes a setup of the room that holds it, when the shot framed for it loses it for most of its walk; "it" is a creature the action last named when it starts a clause ("It rolls over to the galley"), and still the thing in hand in "puts it down"; the cast list has an icon per kind; a snake's raised neck is drawn through an S.
• Framing a walker along its path: not changed, on purpose. A framed shot is still solved where its subject is when it starts. Solving it over the subject's path instead moved the people's cameras too: four watch-its, the hat-day showcase and film grammar's screen-direction tests framed shots their screenplays wrote otherwise. The director already holds a slow crosser's paragraph until it arrives, and a small creature's entrance now follows it, so the compiler keeps honouring the shots written.
• CharacterInstance 1.2: the kinds bird and insect, the insect shapes beetle, ant and spider, the locomotions fly and scuttle, and a voice binding's effect. Whatever writes a character raises it to 1.2 when it uses one (characterVersion); a 1.1 or 1.0 character is unchanged. The validator holds a bird to two legs and an insect to six or eight.
• Birds and insects as above: rig templates, gesture libraries standing in for all 31 of a person's gestures, layouts, solvers and bodies drawn from the posed bones; metrics and testdata/plans.json with a parrot (Kipper), a beetle (Skitter) and a spider (Tangle) held to the core's eyes in every posture. A flying bird crosses at 1.8 times a person's walk, whatever its size (FLIGHT_SPEED). The reader knows parrots, crows, hens, penguins, beetles, ants and spiders; the director's verbs gain flies, swoops, soars and flits, and a bird's pecks and flaps and an insect's antenna waves (a person who pecks at his dinner pecks nothing). New character offers a Bird and an Insect or spider; the kit has Birds and Insects and spiders patterns.
• Carrying in a mouth or a beak. A body with no arms but a mouth (a quadruped, a bird, a serpent, an insect) picks up, holds, puts down, lets go of and hands over a prop whose longest side is at most 0.8 of its height; a bigger one is said (director.too_big) and not staged. The compiler holds it in the hand mouth (Timeline 1.23), carried at the mouth point, and the engine draws it at the mouth (a beak's middle, a muzzle's tip), the body bowing and the neck bending to bring the mouth down to it as it takes it and puts it down.
• Creature voices. A binding's pitch (pitchSemitones) and timbre (formant) are the reading's, done by prosody to every take (voices/direction.ts, from the sound branch); its effect (voices/colour.ts: robot, hollow, buzz, chirp, growl) puts the read take through ffmpeg after, cut or padded to its own length so its words and lip sync hold. A plain binding keys and sounds exactly as before; one with an effect keys with it (takeKey's colour). A creature made from words or drawn from a pattern sounds like its kind: a bird chirps a few semitones up and brighter, an insect buzzes, a robot is a machine, a ghost is hollow, a big animal growls; a size word moves its pitch and timbre up or down.
• Not built in phase 2: claws holding props (a robot's claws hold as hands already), creature postures (beg, pounce, coil to strike), ears and tails by emotion on every plan, a robot's screen face, smears and boil on plans, perching up on things (a perched bird sits on the floor where it lands), the wings extra, sightlines and occlusion by footprint, warnings for giants in small sets.

What phase 2 looks like (tools/crew-watch.sh with a parrot, and a scene of the three):

Phase 3: sea life, what was built

The product audit's acceptance test (docs/audits/product-audit-2026-10.md, "Proposed order") makes Low Tide Blues, an underwater noir musical, from nothing with no model. create_character read "a hermit crab private eye in a battered fedora", "an octopus bandleader in a white dinner jacket" and "a humpback whale torch singer" each as a person made from words. They are now a crab, an octopus and a whale.

• CharacterInstance 1.5: three kinds, by how the body is built.
  • fish: a body that swims, afloat at its leg top with the water under it, with fins and a tail. Its shapes are fish, shark, whale, dolphin, seahorse and turtle.
  • octopus: a soft mantle carrying its face, with tentacles under it. Its shapes are octopus, squid and jellyfish.
  • crustacean: a shell on eight legs, with two claws. Its shapes are crab and lobster.
  • The locomotion swim is new. Fish and octopuses swim; crustaceans scuttle, and a crab goes sideways.
  • A fish's flippers, an octopus's front tentacles and a crab's claws are arms named as a person's (upper_arm, forearm, hand). So they wave, point, conduct and hold a prop in the hand, not in the mouth.
  • Whatever writes a character raises it to 1.5 when it uses one of these.
  • Shapes, not more kinds, wherever the skeleton is the same: a whale and a goldfish share fish_toon.v1, a jellyfish and a squid octopus_toon.v1.
  • The face is set into the body (faceOnBody): a fish's on its front, a whale's low on its great head, an octopus's on its mantle, a crab's on its shell with its eyes on stalks. A seahorse's head and a turtle's are their own.
• The engine draws them from the posed bones, as phases 1 and 2 do:
  • A fish's body tapers to its tail and carries a dorsal fin (a shark's tall, a dolphin's swept, a whale's a hump), a tail fin upright or flukes raised in a shallow V, flippers (a humpback's long and knobbed), and a pale belly (a humpback's grooved).
  • An octopus's eight tentacles are smooth curves with suckers. A squid's mantle is tall and finned; a jellyfish is a frilled bell over trailing tentacles.
  • A crab has a wide shell, jointed legs to each side and pincers. A lobster has a ringed tail and a fan.
  • A hermit crab wears its coiled shell (the shell extra) on its back.
  • A seahorse curls its tail; a turtle has a shell in plates, a neck and four flippers.
• They move as they swim:
  • A fish bobs where it hangs. Its tail beats by the distance it swims (a whale's and a dolphin's flukes up and down, a fish's fin side to side), and its flippers tuck back.
  • An octopus stands on tentacles that reach the floor however low it settles. It swims by jetting: up a little, leaning in, tentacles trailing and pulsing.
  • A jellyfish's bell bobs and pulses.
  • A crab's legs step in two sets by turns, across the way it goes (_sideways, from the drawing before).
  • Postures settle each one so its face is where the core frames it.
• Gesture libraries stand in for every gesture a person has, with arms or without:
  • A fish waves a flipper and flicks its tail.
  • An octopus has a robot's arm gestures, softened at the elbow, and conduct: a tentacle up, beating time.
  • A crab waves, points and snaps its claws.
• Metrics. faceTopShare and SHAPE_FORWARD put the face where the engine draws it, shape by shape. testdata/plans.json holds eleven sea fixtures (core/test/fixtures/sea_life, made by the reader from words) to the core's eyes in every posture.
• The reader:
  • It knows fish, sharks, whales (humpback, orca), dolphins, seahorses, sea turtles, octopuses, squid, cuttlefish, jellyfish, crabs, lobsters, crayfish and shrimp. A creature's word wins over a person's job: "a crab captain" is a crab, "a robot pilot" a robot.
  • It reads what follows the noun as the job ("A private eye.", "A bandleader.", "A torch singer.").
  • "Hermit" gives a crab its shell.
  • It reads garments with their own colour and wear words: "a battered fedora" is a worn brimmed hat, "a white dinner jacket" a white jacket with a black bow tie.
  • Their colour words are not the body's: the octopus is not white.
  • A body draws what its kind wears (drawnCostumeSlots): a hat and glasses on any plan, and a jacket and a tie on an octopus. The rest is said ("no pinstripe suit (a sea creature does not wear one)") and the validator warns about it.
• Hats and ties for everyone. A brimmed hat is drawn as itself: a pinched crown with a band on a brim all round, tipped a little. Before, it was drawn as a cap. A necktie is drawn down a person's front (2D and 3D) and as a bow tie on an octopus. toon.v1 draws both.
• The director:
  • It reads swims, paddles and jets as going, for anyone.
  • One who swims floats and drifts where it goes: "drifts over to the bar" is a slow swim, and "floats by the door" is a place to be, not a float. Nobody leaves the floor for it.
  • A crab crosses square to its way, on the side nearer the way it faced, so its face stays to the room (Metrics.sidles).
  • An octopus conducts, a crab snaps its claws, a fish flicks its tail; a person who conducts a survey does not.
  • A creature the script introduces is made of its kind ("OCTAVIUS is new: make an octopus"), with the pronouns the script gives it. "Make all new characters" makes it so too, after the people it draws together from the show's pattern.
• Studio and the kit. New character offers Fish or whale, Octopus or jellyfish and Crab or lobster. The cast list has a fish, an octopus and a crab icon. The blank kit has Fish and whales, Octopuses and jellyfish, and Crabs and lobsters patterns, with archetypes and species in the blank theme. Each kind's voice is shifted (a whale's deep and round).
• Not built:
  • A whale is big for a room: it fills the frame of a living-room set, and blocking keeps its footprint only as well as anyone's.
  • Garments on plans other than an octopus.
  • Ink, bubbles, a whale's spout.
  • A seahorse's crown.
  • Swimming up off the floor to a height (a swimmer stays at its own height, as a fish hangs).

What phase 3 looks like: the audit's three, made by the reading's own fixes in a blank Low Tide Blues with no model, then directed and rendered.

People from words (0.10, the third product audit's finding 2)

The third product audit made Night Ferry from words with no model. "A sixteen-year-old girl deckhand in an oversized yellow rain slicker" came out a naked figure with yellow skin at an adult's 167 cm and they/them: the reader knew no slicker, so its colour went to the skin, and it read no age. "A weathered grandfather in his seventies, ferry captain, wool cap pulled low" was a naked young man with her hair and face; "a very tall pale stranger in a long dark raincoat" a tan coat open over a bare body, with the grandfather's voice. Every proposal warned that its own eye colour broke the style. The script's reading dressed all three in the people pattern's jumpsuit, and made the Stranger she ("walks past her") with a woman's voice; in a kit show the three shared one voice and none had an age.

What changed:

• The words reader (core/src/generate/character/words.ts, readLooks) takes the garments out first, each with its own words: some hundred garment words to a slot and cut (slicker, raincoat and oilskins are coats; overalls and dungarees, uniform and fatigues, dress, jumper, boots, wellies, caps, hats, glasses…), the colour said of it ("dark blue", "navy blue", "charcoal grey"), its fit ("oversized", "two sizes too big"), length ("long" coat), wear ("battered", "muddy") and pattern ("striped"). A garment is read only where it is worn ("in a cap", "and black boots"), never "who can tie a knot", and nothing in double quotes is read. Then hair and beard colours beside their nouns ("grey hair", "red-haired", "a white beard"), eye colours, and skin only from skin words ("pale", "dark-skinned", "green-skinned"). Age, sex and size words count only when said of who someone is (headPhrases: "a very tall pale stranger", ", a stout man", "He is short and round"), so "runs a small café" makes no one short.
• A person is one of the show's people. create_character draws a person from the show's people pattern in its style (Reelwright's own when the show has none) at the age the words give, then dress.ts puts each garment on over the pattern's clothes: a named garment replaces the pattern's in its slot, a whole outfit ("a red dress") drops the pattern's extra coat, and a torso, legs and feet (unless barefoot) are always covered. A named colour keeps its hue but takes the style's saturation and brightness; white, grey and black keep their name and only the brightness. The pattern's own colours are solved under the style, so nothing the generator chooses breaks it.
• The reading reads the same words from the action ("JUNE, sixteen, in an oversized yellow slicker"): "sixteen" is 16, "GRANDPA" before WALT is his title (he, elderly), and pronouns come from who each sentence is about: a he or she opening a sentence after someone spoke or acted is theirs, a his or her in their own sentence is theirs, a her someone else walks past is not.
• A cast told apart (apart.ts): no new character takes a voice the show has, or one waiting in a proposal has (the nearest free Kokoro voice of its presentation, the pattern's first); no new person takes both a hair style and a face someone has. Made from words, a person is the one of up to 12 draws that shares least with the cast: a face counts most (the head's shape, eyes and nose: faceKey), then a hair style (unless the words name it), then each garment (its slot, cut and colour: garmentKeys), but those the words name and uniform pieces in the show's own colours (a colour slot of the style's, as the Marigold crew's marigold work gloves). A drawn cast puts no one face on two people, whatever their hair (distinctLook compares faces, and a shared face outweighs every other miss: cost), and counts a garment two share against the set (distinctGarments). A branch's face sheet had drawn Night Ferry's June as the demo's Otto, and Walt and the Stranger both as Barnaby; kept apart only by hair and face together, 12 of 20 Night Ferries made from the audit's words had two of the three with one face or one hair style.
• One sex, hair, name and voice alike. Someone whose pronouns give no sex was drawn a voice, a hair style and a name each on its own: in the demo line-up the Stranger spoke as a man, in a bob, as Marly. Now the sampler draws the voice first (of the pronouns' sex, or of the one a beard or a given name says), and the hair and the name follow how it sounds (readsAs in voice.ts: their pronouns', else their voice's), as does a freed or varied voice; a described person is named once their voice is chosen. Hair that reads as the other sex's is one table (unlikelyHair in story.ts): long, tied back or bobbed (ponytail, bun, bob, braids, long straight) on a man, balding or buzzed on a woman, unless the words give it.
• No proposal writes another's file. A described person's name was drawn apart from the cast only, so two waiting proposals could draw one name: the second wrote the first's file, counted as its revision, and approving it rejected the first. create_character and generate_characters now take the names (and keep apart the looks and voices) of everyone waiting in a proposal, but those of a redo: the same words again, or the same draw (pattern and seed). When many are waiting, a drawn name that fits the person comes before one that reads apart from every name (drawName's fallbacks).
• A kit's people age. A people pattern with no rules on /body/age (the Marigold's crew) draws a body to its age by Reelwright's people's age rules (ageRulesFor).
• Names, hair and caps that fit (after a look at the first after line-up: the grandfather was Larina, the stranger had grey hair in a bun, the wool cap had a bill). A drawn name reads as the person's sex by its ending (nameReadsAs in names.ts: Halbert, Tobias for he; Marina, Rosette for she), and an old person's is no child's; with nothing known, names are drawn as before. Someone the words describe gets grey hair or a balding style only with age or the words, and a bun only when asked (hairForAge in dress.ts, drawn again from the pattern's own styles and colours). A wool, knit or woolly cap is a beanie, which the part library now draws as itself (_add_beanie in rw_head_builder.gd: a snug crown pulled down to the brows, a folded cuff, no brim) where it was drawn as a cap.
• Yellow is yellow. The reader's yellow was #EDC338, at OKLCh hue 91: nearer a mustard (87.9) than CSS's gold (95.3). It is #F2D43A now (97.5), between gold and khaki; oilskins too. The corpus names yellow as CSS does (gold to yellow, 93 to 116; goldenrod, orange and a mustard out), and has an orange and a mustard slicker that must not pass for yellow.

The corpus (core/test/words-cast.test.ts, core/test/fixtures/words-cast/) holds 78 descriptions (the audit's three, short and long ones, ones naming no clothes, six bearded people the words give no pronouns), five casts made one at a time (the audit's three on a blank show, a kit show and beside the demo's cast, four deckhands from the same words, a family), three women drawn twice into one show from each people pattern, casts of five drawn at five seeds, the audit's three and four deckhands made again at 20 seeds on each people pattern, and the audit's script read and made on a blank show and a kit show, each with what it must come out as. It prints a score rule by rule; the hard rules (never unclothed, each garment a layer, each colour on its noun, skin from skin words only, the pronouns and age the words state, no warning about the style's colours, no shared voice, no shared hair and face, no two newcomers with one face, hair style or garment the words did not name and none a copy of anyone, no hair of the other sex's, by pronouns or else voice, and a beard the words give a man's) must all hold, and drawn names that fit, and hair of the age. Before the change it scored 237 of 600 (39.5%); after, 717 of 717; with the names, hair and caps added, 761 of 827 before their fix and 810 of 810 after; with every newcomer kept apart, 960 of 960. Each part of the change, taken out, fails it: no dressing 497 of 590, no free voice for a description 30 of 34 voices or for a drawn cast 49 of 69, the old first-pronoun reading 47 of 51 pronouns, no style for a creature's colours 80 of 84, no age rules for a kit 33 of 37 ages, no new look for a description 62 of 63 or for a drawn cast 57 of 63, names drawn as before 30 of 73 names, no hair for the age 1 of 19, a wool cap read as a cap 95 of 100 garments. Each part of keeping newcomers apart fails its 90 checks too: hair and face together only, as before, 25 of 90; no preferring a new face 72, a new hair style 50 or new clothes 49; a drawn cast compared by hair and face together 86. With hair, names and garments held to how someone reads, it scored 1635 of 1826 before that fix (names 377 of 460, hair fit 439 of 484, apart 27 of 90) and, with six bearded people and a fifth drawn cast since, 1878 of 1878 after; taken out, hair not from the voice hair fit 469 of 500, names not from the voice names 378 of 471, the old hair table hair fit 484, no garment preference apart 22 of 91, a drawn cast's garments uncounted apart 90, a shared face weighing no more than any other miss apart 90, a name that reads apart before one that fits names 458, no beard's sex hair fit 499. In core/test/any-character.test.ts, two descriptions at one seed wrote one file before the fix, and a drawn cast wrote a waiting description's; each test fails again with the waiting names left free.

The audit's three, made through the CLI as the audit made them (init --blank in its look, create_character over reelwright mcp, changes approve, preview model_sheet and lineup, lavapipe), before (at 9cb24a6a) and after. Before, the show did not validate cleanly: three warnings, one per character, that its eyes broke the style. After: no problems.

The same three words in a copy of the demo (init --demo), beside its own Otto and Barnaby: each their own face, hair, garments and voice (bf_emma, am_fenrir and am_michael beside af_bella and bm_george), none a copy of the demo's two, and the stranger, who speaks as a man, in a man's short hair and a man's name. Only the crew's marigold work gloves, the show's own colour, are worn twice. The line-up, then each one's neutral face and front view from their model sheets.

Drawn as read, and a child's voice (0.11, the fourth product audit)

The fourth product audit made The Volcano from words with no model: "DAD, forties, a bushy beard and a flowery apron", "THEO, ten, freckles, in a red hoodie two sizes too big", "NELL, fifteen, headphones around her neck". The reader read every one right, and the renderer drew them wrong: the part library knew 18 cuts and sent the rest to another garment. Theo's hoodie and trousers were a jumpsuit, Dad's apron overalls, Nell's headphones a cap, each with a character.part_fallback warning no one reads. And Theo, ten, spoke as a grown man: am_fenrir, "gravelly", at 125 Hz.

What changed:

• Every cut is drawn as itself. toon.v1.parts.json draws every cut the reader gives (all but a wristband, which no words make), with no fallbacks left: a cut the library cannot draw is skipped with a warning, never drawn as another garment. A hoodie has its hood, open at the front with strings and lying on the back, and a pouch pocket (_add_hood, also drawn for a hood detail on any top). An apron is worn over the clothes: a bib with a strap round the neck, ties at the waist and a skirt hung in front of the legs (_add_apron, _build_apron_skirt); the clothes under it stay the top (top_garment passes it by). Headphones sit on the ears with a band over the head (_add_headset), or round the neck (_add_neck_headset). Glasses are rims and lenses (_add_glasses), tinted when the layer has a second colour. A helmet is a shell, a headscarf is tied over the hair (_add_helmet, _add_headscarf). A dress or skirt hangs from the hips, closed (the coat's skirt halves), a robe is a long coat, armor a closed shell (_add_armor), sandals leave the foot bare, and a scarf, a neckerchief, a pin badge and a backpack, skipped before, are drawn.
• The reader names the nearest real look, never another garment. A headscarf or headwrap is a bandana on the head, where it was a beanie. Sunglasses are glasses with a dark second colour, so their lenses are dark. Headphones "around her neck" (or hung, slung or draped on it) are worn in neckwear, not on the head.
• A name the words lead with. (0.13) "Theo, a ten-year-old boy…", "Theo the baker", a screenplay's "THEO (10)" and "Mr. Kowalski, the neighbour" are named so, where only "called" or "named" counted, and the voices-by-age listening sheet's Theo was "Finock Witherridge" (leadingName in describe.ts). The rest is read for everything else, so a fox called Red is no red fox; the parentheses are read as words, so THEO is ten; a title stays in what is read ("Grandpa Walt" is old) and says pronouns no other word gives ("Mr." is he). A capital that leads a description but is no name ("A…", "An old sailor, …", "Tall, thin…") is not read as one.
• A child's voice. Kokoro has no child's voices. A child (a biped at the child stage) is drawn the bright, high voice of their pronouns' sex, then raised to a child's pitch, 250 Hz, with a raised formant for a smaller body. (0.13, voices-by-age.md) Now every person speaks where their age and sex do. A child is given the nearest Kokoro voice of either sex, a woman's, raised a few semitones rather than a man's raised an octave, and Studio says Kokoro has no child's voice.

The corpus holds 96 descriptions now: the audit's three, a seven-year-old girl, a little boy in a t-shirt and shorts, and a tank top, tunic, black vest, armor, red bandana, blue headscarf, pin badge and glasses over a grey sweater. It reads The Volcano as well as Night Ferry. Two hard rules are new: drawn, that the part library draws every layer's cut as itself, and voiceage, that a child's voice sits at 220 to 300 Hz with a raised formant, is not gravelly and is their pronouns' sex, and that no grown-up's is raised. Before the change it scored 3598 of 3731 (drawn 1359 of 1441: 20 trousers, 6 sweaters and 6 hoodies drawn as jumpsuits among them; voiceage 174 of 224); after, 3732 of 3732. Each part of the change, taken out, fails it: the part library drawing a hoodie as a jumpsuit again drawn 1435 of 1441; no child's voice voiceage 174 of 224, and a child drawn high and bright but not raised to a child's pitch 180 of 224; a headscarf read as a beanie garment 125 of 126, headphones round the neck read onto the head 123 of 126; with sunglasses' clear lenses, the reader's own test fails (what the reader takes each garment for), as it does for the two before. In engine/tests/character/rw_garments_drawn_test.gd (each cut on the demo's Otto, in four views: its own pieces drawn, none of what it was drawn as, no warning), each piece of the drawing taken out fails a test: the hood, the apron's bib, the headphones, the glasses (and the sunglasses' dark lenses), the apron taken for the top under it, and sandals drawn as shoes.

The audit's own cast files drawn through the CLI (preview model_sheet, lavapipe), at 0.11.0 and after; then the show's people made again from its words, as Studio's reading makes them ("Make all 3 new characters", approved). No sheet warns now; at 0.11.0 each of the three did. The Night Ferry's sheets did not move by a pixel, and neither did the goldens (the Lighthouse stills, the style swatches and the alpha golden, max delta 0).

Each one's line, said through Studio's "Try voice" (audition, local Kokoro) and measured (YIN, trackPitch in prosody.ts): Theo, made at 0.11.0, spoke at 125 Hz (am_fenrir as it is); made again from the words, at 234 Hz (am_fenrir raised 11 semitones, formant 1). Dad (138 Hz) and Nell (175 Hz) did not change.

Brims, hats and hair from every side (0.14, the fourth product audit's finding 6)

The fourth product audit cut the site's showcase videos into contact sheets and found the drawing wrong where no one had looked from that side. The Chief's cap brim was a thin green blade: a flat band from the front and a thin bill in profile, blended point by point when he turned, so three quarters on, or with his head down over the console, it read as a stick through his eye. In Hat Day the Captain's tricorn floated over her head in every single of hers.

What changed:

• One sheet of every head kind (tools/heads-check.sh, engine/tests/support/rw_heads_sheet.gd): a row per head, the demo's cast and the showcase captains as they are, Otto in each kind of headwear, each hair style and fringe bare-headed, and caps and hats over long and full hair; a column per view, turned round in eighths at eye level, then three quarters with the head tipped down (as from above) and up (as from below). 35 heads, 10 views.
• A cap's bill is a peak (_cap_bill in rw_head_builder.gd). It is sewn on round the front of the head along the crown's edge, reaches out about half the head's depth, fanning a little with the brow, and is seen as from 22 degrees above (_bill_lean), the cartoon way, so its top shows as a surface from the front, three quarters and the side; a spine keeps it as thick as a peak at its root, so seen edge on it is a duck's bill, not a line. It throws a shadow on the brow, its lower edge stops above the eyes, it shows its darker underside only when the head tips well back, and from behind only what reaches past the crown shows.
• Hair ends where it lies flat. Side on, curly hair, an afro and a horseshoe stood out their full volume to where they ended, so a ledge stuck out past the forehead, a visor on a bare head. Over the forehead, hair full enough to stand out (a tenth of a head thick) now thins out toward its edge, past the head's edge the hairline rises back toward the brow, and a horseshoe's top edge rises from the temples to the back of the head instead of running level round it. Seen from the front and from behind nothing changes but the horseshoe. Thinner hair (a side part, a ponytail) lies close and keeps its edge: thinned, the Night Watch captain's side part drew her head narrower side on than the framing score has it (core/test/engine-heads.test.ts, 1.19 of it where 1.17 is allowed), and moving the score instead moved the director's framing.
• A hat sits down on the head (sinkOver in core/src/compile/props.ts, see docs/design/m6-props.md). The tricorn was worn, not hung: a worn prop came down over the head only when its recipe was hollow underneath, and recipes build hats solid, so it sat on her hair. A prop whose name's kind is a hat (overHead: a hat, cap, top hat, tricorn or paper hat) now comes down to the brow; a party hat, a crown or a book still rests on top.

engine/tests/character/rw_headwear_test.gd holds the bill to a tenth of the head thick from every level side and off the eyes from every side, tipped too; the old bill was 0.069 to 0.084 thick and fails it at every level view. In core/test/props.test.ts, a solid tricorn, a hat, a paper hat and a cap come down to the brow, and a book, a party hat and a crown do not.

Risks and open questions

• Words are ambiguous. "A dragon" could be a quadruped with wings (phase 2) or a serpent. The reader picks the most common reading and says what it read in the proposal's summary, so a person can say otherwise.
• Stand-ins can surprise. A "facepalm" on a cat is a head tilt. The note in the compile and the timeline's gesture names make it visible; the model director can pick the plan's own.
• Long bodies on small sets. A three-metre snake fills a bridge; blocking keeps its footprint on the walkways only as well as it keeps a person's (its floor point).
• Metrics drift. Two implementations of each plan's metrics must agree; tests hold them.

Proof

• Core tests: the schema and raising; the validator's plan checks; metrics per plan; gesture stand-ins; gait speeds and cycles; the reader's words to plans; create_character; the director's verbs and "it"; Studio's create call. Mutation-checked.
• gdUnit: each plan builds, turns, poses each posture and gait, speaks every mouth shape, and holds its eye to the metrics; the card and the model sheet draw it; the character studio opens it.
• Renders: each plan's model sheet, and a compiled scene where the robot rolls to a mark and talks to Otto and the cat walks in and speaks, looked at frame by frame.
• Studio, live: desktop and web, a creature made from words, seen in the character studio and put in a scene.
• No regressions: the Lighthouse goldens and the style swatches unchanged on lavapipe.