Check the toolchain: Python deps, Node (official spine-core runtime for validation and previews) and the Spine editor CLI (editable .spine export).

Create a procedural sample project to try the tools on. kind: "symbol" (slot symbol: plate, gem, letter, highlight) or "character" (mascot with arms, cape, hair locks, face features, ears).

List a PSD's layers (names, groups, visibility, blend, bounds, [tags]) without writing anything. Run before import_psd.

PSD → project: one slot per visible layer, placed exactly as on the canvas, PNGs cropped to content, Photoshop blend modes mapped. origin "center" for symbols, "bottom" for characters standing on y=0.

Bones (with world head positions), slots (bone, attachment type, blend), constraints and animations of a project.

Add bones in WORLD coordinates (y up). Each item: {"name", "parent" (default "root"), "x", "y", "rotation" (world degrees, default 0), "length" (default 0)}. Art never moves; only bones are added.

Bones along a polyline of world points (n points → n-1 bones, each reaching the next point). Use for limbs, spines, tails, tentacles.

Move a slot to another bone without moving its art.

Turn a slot's region into a clean contour mesh (or re-mesh a mesh) with bone-heat weights.

Outline traced from alpha and simplified without clipping art; interior vertices denser at joints; conforming Delaunay (valid for Spine's importer). Weights diffuse from bone segments over the mesh, so they blend smoothly across joints and never leak across gaps in the art.

bones bones to weight to; omit with auto_bones=True to pick the slot bone + descendants that touch the part; [] with auto_bones=False gives an unweighted mesh. detail vertex density (0.5 light … 1 balanced … 2 dense) smooth >1 widens weight blending across joints, <1 tightens

1- or 2-bone IK (e.g. ["upper_arm", "forearm"]). Creates a target bone at the chain tip unless target names one. Bend direction defaults to the setup pose's own bend. The target goes under juice_core when juice bones exist (so slams carry it), else under root.

Spine 4.2 physics constraints (runtime secondary motion, no baked keys). presets: hair, cloth, tail, ribbon, jiggle, antenna, tassel. Down a chain each bone is taper looser. overrides: any physics field (inertia, strength, damping, mass, wind, gravity, limit, rotate, x, y, scaleX, shearX).

Transform constraint: bones copy target's transform by the mixes. local+relative adds the target's local offset (drivers, parallax).

Hair lock / cape / ribbon / tail in one call: a bone chain along the part's own centre line, a heat-weighted mesh and physics. root_end: auto(top)|top|bottom|left|right. physics: preset name or "none".

2.5D head turn driven by ONE control bone (turn_ctrl).

face_slot becomes a mesh whose middle travels with the control while its outline stays pinned (a surface turning, not a sticker sliding). features {slot: depth}: nose 1.25, mouth 1.0, brows 0.95, eyes 0.9, fringe 0.8; parts behind the head negative: ears -0.35, back hair -0.5. Adds a turn_test animation. Animate turn_ctrl's translate to turn.

Slot-symbol juice. Default clips = the symbol contract: idle, land, win, win_loop, anticipation, dim. Extras: scatter_trigger, wild_expand, flip, flip_depth, multiplier_fly, win_big, win_mega, win_epic.

Animates only two inserted bones (juice_ground at the base, juice_core at the centre) so the artist's own keys are never touched. One-shots end on the setup pose; loops are seamless; events fire for SFX (sfx_land, sfx_win…). intensity 0.5 subtle … 1.6 loud. fx=True layers matching FX. shine_slot adds a clipped shine sweep in win. options: back= (flip), rows (wild_expand), to=[x,y] (multiplier_fly), darkness (dim).

Add an FX preset built from Spine primitives with procedural textures (tinted per slot, so the atlas stays tiny).

presets: explosion (flash + shockwave + sparks + smoke), shockwave, coin_burst (spinning flipbook coins on true parabolas), coin_shower, ripple (seamless water rings), glow_pulse, sparkle, shine_sweep (needs slot=; light band clipped to that part's outline). into: merge into an existing animation (e.g. "win") instead of a new one. Each preset fires an event fx_ so the engine can add heavy particles (pixi emitters) at the same moment.

Authored FX layers lifted from real reference clips: lotus set (rune_ring, burst_flare, rim_wisps, bloom_aura, floor_glow, fireflies, twinkles, plus magic_reveal = all seven timed like the clip, 13.2 s), light_beam (style gold | ribbon | blue), crosshair / hit_burst / lock_on (reticle locks on, fires, impact), cell_glow (resizable 9-slice glowing cells that pop), puff (cartoon smoke puff, or flash + ring for an AE smoke_puff), smoke_glow (rising haze with a base glow), meteor_trace (comet racing around a frame), projectile (shot on an arc + impact), ice and water (frost, icicles, ice_shatter, bubbles, water_splash; AE template caustics), explosion and shine, the reel moments reel_stop (spring thud, squash, dust, screen shake on your reel/screen bones through inserted carrier bones) and anticipation_reel (accelerating heartbeat glow, edge flames or sparks, dimmed neighbours), the slot families (spin: near_miss, spin_blur, turbo_spin, screen_shake; wins: payline, win_highlight, multiplier_stack, win_rollup; payouts: coin_fountain, cascade_pop; features: wild_land, expanding_wild, scatter_trigger, free_spins_transition; bonus: pick_reveal, hold_respin, jackpot_wheel, meter_fill; ambient: weather, god_rays, water_surface, heat_shimmer, fog_roll, lightning_storm; UI: button_press, idle_shimmer, focus_glow, padlock, popup; saber = a port of Video Copilot's Saber beams with 12 presets and an ae_hint for the saber AE template; pinata family = wild_glow, wild_transform, mult_cell_glow, cell_pop, confetti_burst, mult_streak, wild_merge, coins_to_bar, bar_sweep, pinata_hit, jar_burst, banner_backdrop from one picture kit (swap a texture pack in by name with art=, retune it with options gain / thick); recipes that move your reel / symbol / screen / button bones do it through inserted carrier bones, never your own keys), and the hybrids portal and electric_frame, whose plasma / lightning part is After Effects: they return a ring_hint to pass to ae_fx_to_spine (guide explains). Procedural textures, additive only (one draw call), one group bone per recipe so it recolours, resizes and retimes as one piece, and it merges into any animation with into=.

recipe="" lists every recipe with its options and defaults; recipe="guide" returns the guide (how to use, fork and mix them, how they were made, and the traps). x, y = the subject centre in the parent bone's space; scale 1 = a ~720-unit canvas with a ~420-wide subject; start = seconds into the animation; duration = life window (window recipes) or a time scale (one-shots); color = main tint; intensity = alpha gain; count = tufts / motes / stars / sparks; options = recipe-specific values (see the listing). magic_reveal takes options={skip: [recipe, ...], overrides: {recipe: {param: value}}}. Each recipe fires an fx_ event.

art = your own pictures instead of the generated ones, keeping all the motion: {role: "file.png" | "file.psd#Layer" | {path, blend, scale, slice, px, anchor}}; the roles of each recipe are in the listing (e.g. crosshair: reticle). For lock_on / magic_reveal key it by member: {"crosshair": {"reticle": ...}}.

tier = small | medium | big | mega | epic: one recipe covers every win size (scale, counts, one-shot time and the recipe's own tier overrides; see the listing's tiers). Bundles: sequence = any list of recipes with offsets into one animation (options={steps: [{recipe, start, dx, dy, ...any fx_recipe argument}]}); win_banner = Big/Mega/Epic banner from one recipe (tier= picks the layers; options={banner: bone} slams your banner art in on an exact spring).

Render an After Effects comp and play it in Spine as a frame sequence, timing matched to the comp.

Source: aep + comp (rendered headless with aerender from the SAVED .aep, over the work area, never touching the project open in the AE window), or frames_dir + fps (frames already rendered: .tif premultiplied, or .png). mode: "alpha" (the comp's own transparency; normal blend) or "additive" (light on black: alpha from brightness; additive blend). blend overrides the slot blend. Timing: playback speed equals the comp's (delay = 1/comp fps). Place it with start= (seconds into the Spine animation) or, to land an AE moment on a Spine one, hit_ae= (seconds in the comp, e.g. the impact) + hit_at= (Spine time it should coincide with). fit_duration= stretches the sequence to span that many seconds (loops that must divide the symbol's loop). seq_mode: once | loop | pingpong; a loop runs to until= (default: the end of the animation it is merged into). max_frames/max_size shrink it (every Nth frame; longest side in px), scale = game units per comp pixel, fade = fade-out seconds. animation= merges into an existing animation, otherwise ae_ is created. Leading and trailing empty frames are trimmed. Frames land in images/ae/NN.png; an event ae fires at the start.

Build an After Effects FX comp from a template: returns a script to run in AE (nothing is rendered here).

name="" lists the templates with their parameters and defaults. Otherwise name is one of: glow_pulse, shockwave, sparkle, relief_shimmer (light wave over a picture, traced by its relief or a depth map), fire, fire_aura (flame ring shooting out of a hole: fists, scatters, power-ups), lightning, burst (parabolic sparks), splash. params override the defaults (comp= names the comp; save_as= saves the open AE project to that .aep right after, which aerender needs). Then: run the returned run_with with the After Effects MCP's ae_run_script (it creates the comp in an ae_fx_templates folder of the OPEN project and returns its name, size, fps, frames), save the project, and pass the comp to ae_fx_to_spine (use mode="additive" when the result says so). After Effects caches rendered frames by comp name: when tuning, give each attempt a new comp name.

Key one timeline with named easing (Spine curves are written for you).

Bone timelines: rotate [t, deg], translate/scale/shear [t, x, y], translatex/translatey/scalex/scaley [t, v]. Slot timelines: rgba/rgb [t, "RRGGBBAA"], attachment [t, name-or-null]. Values are offsets from the setup pose (Spine semantics). Append an easing name to a key to override ease for the segment leaving it. Easings: anticipate, back_in, back_in_out, back_out, cubic_in, cubic_in_out, cubic_out, ease, expo_in, expo_in_out, expo_out, in, in_out, linear, out, quad_in, quad_in_out, quad_out, sine_in, sine_in_out, sine_out, snap, stepped

Fire a Spine event (SFX cue, rollup start/stop, particle trigger) in an animation.

Structural validation (references, weights, triangulations, UV range, curves, events) plus — when Node is available — loading the skeleton in the official spine-core runtime and applying every animation frame by frame (non-finite vertices, missing regions).

Performance budget for mobile web. Profiles: mobile_symbol, mobile_banner, mobile_character, desktop. Counts bones, slots, vertices, weighted vertices, clipping, physics, deform keys, influences, atlas pages, and estimates draw calls (every blend-mode or page change along the draw order breaks the batch). Returns what is over budget and how to fix it.

Render animations through the official spine-core runtime (IK, physics, clipping all solved) to GIFs + contact sheets, plus a setup-pose PNG.

Pack every image the skeleton references (sequence frames included) into a Spine 4.x .atlas + pages. Copies the skeleton JSON next to it, so out_dir is a ready runtime folder.

Import the project into an editable .spine file with the licensed Spine editor CLI. Reports any repairs the importer made.

Export a .spine project to runtime data with the Spine CLI (json|binary or a path to an export-settings JSON).

Create the procedural sample face: a mascot head drawn as separate layers named exactly as import_psd names a PSD that follows the face convention (face/head, face/eye_L/{white,iris,pupil,highlight,lid_upper,lid_lower}, face/brow_L, face/nose, face/mouth/{A,E,I,O,U,M,F,L,smile,frown}, face/jaw, face/cheek_L, face/ear_L, hair/back, hair/bangs, hair/strand_L ...), all on root. Run rig_face on it.

Rig a whole face from named layers in one call, then build its clips.

Recognises parts by layer name (case-insensitive, L/R sides, any group prefix): face/head (REQUIRED; also face, skin, base), face/eye_L/{white, iris, pupil, highlight, lid_upper, lid_lower}, face/brow_L, face/nose, face/mouth/{A,E,I,O,U,M,F,L} (+ rest, smile, frown) or one plain mouth layer, face/jaw (chin art), face/cheek_L, face/ear_L, hair/back, hair/bangs (fringe), hair/strand* / lock*. Missing parts are skipped and reported. project="" returns the naming convention (FACE_LAYERS) without changing anything.

Builds: the 2.5D turn (rig_turn) as the base layer; eyes whose iris follows face_look and is CLAMPED inside the socket ellipse (one-bone IK with compress inside a (1, ry/rx)-scaled space) with pupil dilation and lid meshes that blink to the white's own 70/30 meeting line; 3-bone brows on a mesh; a viseme mouth slot riding a jaw that opens by stretching the lower face (scaleX = scaleY^-1/2); cheek bones in the face mesh, stretched by the jaw and lifted by face_smile (which also pushes the lower lids: smiling squints); hair strands (chain + mesh + physics) and a separate bangs swing bone.

clips (default all): idle (seamless: breath, Poisson micro-saccades with the head 100 ms behind, Poisson blinks 80 ms down / 160 ms up), happy, sad, angry, surprised (spring envelopes with exact overshoot, brows a frame ahead, surprised anticipates with a 2-frame squash), talk (lipsync of talk_text). Events: sfx_blink, sfx_, sfx_talk, talk_word (string = word), talk_end. parent = the character's head bone (default juice_core or root); spine = a body bone that joins look_at two frames after the head. Scales are stored in bone lengths (face_rig = face height, turn_base = turn range, face_look_base = full gaze, lid bones = blink travel).

(Re)build one face clip on a rigged face: idle | happy | sad | angry | surprised | talk. duration 0 = the clip's default (idle 4 s loop, expressions ~1.8-2 s; talk = the speech + 0.35 s). intensity scales amplitudes, seed drives idle's Poisson saccades/blinks, text/phonemes/wpm feed talk, name renames the animation (e.g. happy_big).

Bake a lagged look chain into an animation: eyes -> head -> spine (or any bones: works for bodies).

gaze [[t, gx, gy], ...]: fixations in normalised gaze units (-1..1, +x = viewer's right, +y = up); saccades are instant. Or target = a bone whose translate keys in that animation are the gaze path (divided by target_range, default the length of the target's parent bone: face_look_base on a face rig). levels [{bone, channel: translate|rotate, range: [x, y] (px, or degrees per unit gaze), weight (share of the gaze it takes), lag (dead time s), hz + zeta (damped-spring response), limit (normalised radius for translate, degrees for rotate), role: "eyes"}]. Default on a face rig: face_look (eyes, instant), turn_ctrl (0.4 of the gaze, 100 ms later, slight overshoot), and spine= (0.15, two frames after the head, via an inserted carrier bone so the artist's keys stay). counter=True: the eyes take gaze minus the other levels, so they jump first and roll back as the head arrives (vestibulo-ocular reflex). loop=True solves the response periodically.

Viseme + jaw keys from text or phonemes into an animation (works on any rig with a mouth slot whose attachments are named A E I O U M F L [rest], and/or a jaw bone).

text: plain English through a tiny grapheme-to-viseme table (digraphs th/sh/ch/ee/oo/ou..., a silent final e dropped), timed by wpm (each word 60/wpm s, vowels 1.6x a consonant, , ; . ! ? pause). phonemes: ARPAbet (HH AH0 L OW1), viseme letters or rest/sil, optionally [phoneme, seconds]; durations={viseme: s} sets defaults. Visemes are stepped attachment keys lead s ahead of the sound; the jaw (default face_jaw) eases between openness values (A 1, O .8, L .55, E .5, U .4, I .35, F .15, M 0) by scale. A missing viseme falls back to the nearest shape. Ends on rest. Events: sfx_talk, talk_word (string = word), talk_end.

Fish, eel, snake, dragon body or tentacle: ONE long chain along the body layer with a travelling wave.

Layers by name (case-insensitive): body (required, one long layer), head + eye*/jaw/mouth (ride the first bone), fin* (2-bone strands with physics on the nearest body bone), tail_fin / fluke (strand on the last bone).

Physics: y(s,t) = A(s) sin(2 pi (s/lambda - f t)) head -> tail, amplitude growing toward the tail (head_amp = the head's share). speed (body lengths/s) sets the beat like a fish: f = speed / (0.7 lambda); the tail amplitude follows Strouhal St = 0.3 (x exaggerate) unless amp (fraction of length) is given; the head recoils sideways and thrust surges the body at 2f. Clips: swim (exact loop, cycles beats, event sfx_swim per beat), idle_float (slow hover wave + heave), turn (fish C-start: curl, tail kick, spring decay; sfx_turn). mode="tentacle": the root is the base (root_end auto = the bottom), wave 1.3 lengths, plus 2-bone reach IK on the tip and a reach clip (wind-up, constant-curvature strike on an exact spring, grab; sfx_reach). reach = [x, y] in the tentacle's frame (x along it from the base). Clips merge by name into existing ones.

Bird / flier (front view, wings to the sides). Layers by name: body (required), head (stabilised), beak/eye*/head_* (ride the head), wing_l / wing_r (3-bone chains, shoulder = the end nearest the body), wing__feather (primary feathers fanning off the hand, strands with physics), tail (strand, physics).

flap: a warped sine per joint, downstroke = 58% of the beat, each joint lag degrees of phase behind the last (shoulder leads, tip trails), the hand flexes and the primaries fan shut on the upstroke; the body bobs once per beat (lift on the downstroke) while the HEAD stays still (transform constraint to a non-bobbing anchor). amp = [shoulder, elbow, hand] degrees (default 40, 15, 20). Clips: flap (loop, sfx_flap per downstroke), glide (loop), perch (folded, body bobs, head still with a glance), takeoff (crouch, launch, power strokes; ends on setup; sfx_takeoff, sfx_flap), land (flare, braking strokes, touchdown spring; ends EXACTLY on perch's first frame so land -> perch is seamless; sfx_land).

Plug a sub-rig into a named bone of ANY rig; its clips MERGE by name into the host's clips (same name = same animation, timelines added; a host clip keeps its length, loops refit to divide it exactly, one-shots retime).

kind="" lists the kinds with their layer names, default bones and options. Kinds (default bone): ears (head): ear_l/ear_r 2-bone strands with physics; clips ear_perk (exact spring overshoot), ear_flatten, ear_swivel (toward options.sound, the far ear lags), idle twitches. tail (hips): strand with physics; options.tail_mood happy | alert | angry drives idle; clips tail_happy, tail_alert, tail_angry; reacts in walk / run / win if the host has them. wings (chest): wing_l/wing_r (+ wing__feather); options.wing_type feathered | bat | insect; idle = slow breathing fold, excited = flutter; win reaction. horns (head): horn*/antler*: rigid, tiny inertia lag on head turns (physics on shear only). digitigrade (hips): leg_l/leg_r zigzag layers -> thigh, shin, metatarsus with the reversed hock, IK feet (foot_l/r ride them); walk (planted feet, sfx_step with l/r in the string), run reaction. mermaid (hips): mermaid_tail (+ fluke) as a rig_serpent chain; legs hidden; swim, idle_float, idle. snake_hair (head): snake (8-12): each a serpent with its own randomised idle; snake_look (shared IK target). fur (any): options.slots or fur*/coat*/mane*/ruff*: outline bones with physics; fur_ruffle (wind gust). glow (any): options.slots or eye*/rune*/vein*: the FX shine pulse (eyes) or electric_frame (runes) via fx_recipes.apply, tiled into options.clips (default idle) with exact loops and fx* events. name prefixes the new bones (attach the same kind twice).

Procedural sample for rig_serpent. kind "fish": a koi (body, head, eye, fin_dorsal, fin_pectoral, tail_fin), head to the right. kind "tentacle": one tapered tentacle with suckers, base at the bottom.

Procedural front-view bird for rig_flier: tail, wing_l/r with wing_feather1..N, body, head, beak, eyes.

Procedural minimal biped host for attach_rig (bones root > hips > chest > head, legs, arms; clips idle 2.4 s loop, walk 1.0 s loop, win 1.2 s one-shot) with the layers for the add-ons in parts (ears, tail, wings, horns, snake_hair, mermaid, fur, glow, digitigrade; default ears, tail, wings).

Key a gait on ANY rig that has foot IK targets and a body bone: planted stance, swing arc, toe roll, body bob and pitch coupled to the footfalls, and an sfx_step event (string = leg name) at every touch-down. Call with no project to list the gaits.

gait: walk (4-beat LH LF RH RF), trot (diagonals), pace (laterals), canter (3-beat), gallop (rotary, two flights), bound (hind pair / fore pair) for 4 legs; tripod (L1 R2 L3 / R1 L2 R3) and wave for 6; biped_walk / biped_run for 2 ("walk"/"run" resolve by leg count). legs: the foot IK target bones, e.g. ["ik_front_L", "ik_front_R", "ik_hind_L", "ik_hind_R"]; side and end are read from the name (_L/_R, front/hind/middle, LF, RH, L1..R3) or given as dicts {"target", "side": "L|R", "end": "front|middle|hind", "name", "roll", "hip", "reach", "offset", "bias"}. Hip, reach and the hock offset are found from the IK constraint that serves each target. body: the bone that bobs and pitches (its children carry the hips/shoulders; the targets must NOT be under it). speed: units/s (default: the gait's typical speed in leg lengths/s x the hip height). The cycle is in place; the game scrolls the world at this speed. Frequency f = c sqrt(speed / leg_length), stride = speed / f, so speed scales both by sqrt; if a stride would over-stretch a leg the frequency is raised (reported). frequency / duty / clearance / bob / pitch / roll: overrides (0 or -1 = gait default; clearance and bob in units, pitch and roll in degrees). exaggerate scales clearance, bob, pitch and roll. facing: 1 right, -1 left, 0 auto (front feet ahead of hind feet). Loops close exactly; keys go into animation name (default the gait's name), at start, cycles strides long.

Rig a four-legged animal from its layers and build its clips in one call.

Layers (case-insensitive, R = near side, L = far side, the animal faces right or left; see QUADRUPED_LAYERS): REQUIRED body, head, {front|hind}{upper|lower|foot}{L|R}; optional {front|hind}mid{L|R} (metapodial), neck, tail, ear_L/ear_R, eye_L/eye_R, mane*, tuft*, wattle*, snout/nose/jaw/... (ride the head); anything else rides the nearest body bone. Missing optional parts are skipped; missing required ones are listed in the error.

leg_type: plantigrade (2-bone IK, flat foot), digitigrade (3 segments: 2-bone IK to a hock/carpus target + 1-bone IK on the metapodial; made by splitting the lower leg if there is no mid layer), unguligrade (long cannon + pastern bone for the hoof). Spine q_body -> spine_back/hips + spine_front/shoulders, neck1/neck2, head, eye bones, physics strands (tail loose and wild, ears, mane, tufts, wattles).

clips (default all): idle, alert, walk, trot, gallop, bound, pounce, sleep, shake (+ pace, canter). Loops are exact, one-shots end on the setup pose. Events: sfx_step (string = foot), sfx_idle (ear_flick / tail_swish / blink), sfx_alert, sfx_pounce, sfx_sleep, sfx_shake. speeds: {clip: units/s} for the gait clips. seed drives the idle's ear flick / tail swish / blink timer. exaggerate scales every amplitude.

A procedural dog-like side view (faces right, stands on y = 0) with one layer per part, named by the QUADRUPED_LAYERS convention, to try rig_quadruped and gait on. rig=True also runs rig_quadruped (all clips). with_mid=False leaves out the metapodial layers (the rig then splits the lower legs).

Create a procedural biped (a chibi adventurer, side view) whose layers follow BIPED_LAYERS, exactly as import_psd would bring in a PSD with origin="bottom": torso, head, arm_l/r, hand_l/r, leg_l/r, foot_l/r (or upper_arm/lower_arm and thigh/shin with split_limbs=true), plus cape, ponytail, belt_tail, pouch and head features (eye_r, brow_r, mouth, ear_r, hat). Try rig_biped → clip_set → qa_character on it.

Rig a biped from its PSD layers in one call (import_psd origin="bottom" first).

Layers are recognised by name (BIPED_LAYERS, case-insensitive, sides _l/_r, "Arm L", "arm.l", "left_arm"): required torso (body), head, arm_l/r (or upper_arm + lower_arm / forearm), leg_l/r (or thigh + shin / calf); optional pelvis, neck, hand_l/r, foot_l/r (boot/shoe), eye*, mouth, and strand layers (hair, cape, scarf, belt_tail, chain, feather, tail, pouch...). Missing required layers → a clear error listing them.

Builds root → ground → hips → spine1-3 → chest → neck → head, shoulders/arms/hands, thighs/shins, floor-pinned foot IK (ik_foot_l/r under ground: the body bobs and the feet stay put), arm IK (ik_hand_l/r ride the chest), bones placed from each layer's own centre line, the knee/elbow bend taken from the art (straight art: knees forward, elbows back). One weighted mesh across each joint (shoulders, hips, elbows, knees) so bends cannot crack. breathing adds the 4 s breathe loop; look_at adds the look_target hook (eyes first, head look_lag_frames behind at 30 fps, spine twists spine_twist of the turn); secondary_motion runs secondary. Facing: auto (the way the feet point) | right | left.

The character contract: the SAME clip names for every character, so game code never changes.

idle (loop 4 s: one real breath), idle_fidget, walk (loop), run (loop), jump, land, hit, attack, win, lose, talk (loop). Loops close exactly, one-shots end exactly on the setup pose, the artist's setup never moves. Events: sfx_step on every footfall (string = the foot bone, float = the ground speed in px/s: move the character at that speed and the feet do not slide), sfx_jump, sfx_land, sfx_hit, sfx_attack + attack_hit (damage frame), sfx_win, sfx_lose, sfx_talk, sfx_idle_fidget. Physics: walk = inverted pendulum, run = spring-mass + gravity-parabola flight, land = exact spring squash 0.85 → overshoot 1.05 (volume kept), hit = 2-frame anticipation against the blow then a spring recoil lagging up the chain, attack = wind-up, strike, spring follow-through. Strands get a headwind ~ v^2 in walk/run.

Works on any rig that has the bones a clip needs (canonical names from rig_biped; bone_map renames them, e.g. {"hips": "hip", "ik_hand_r": "arm_r2_ik"}); clips whose bones are missing are skipped and listed with what is missing. intensity 0.5 subtle … 1 standard … 1.6 cartoon. durations {clip: seconds}. blow_from front|back.

Secondary motion in one call: find every strand-like layer and give it a chain along its own centre line, a weighted mesh and Spine physics. By name (hair/lock/ponytail/braid → hair; cape/cloak/skirt → cloth; scarf/ribbon/sash → silk; belt_tail/strap → leather; chain/necklace → chain; feather/plume → feather; tail; pouch/bag/charm/pendant → a one-bone pendulum) and, with by_shape, any other elongated layer (cloth). The chain starts at the end that overlaps the body and hangs from the body bone nearest it. presets {slot: hair|cloth|silk|leather|chain|feather|tail|ear|pouch} overrides; n_bones 0 = the preset's.

Volume-preserving squash & stretch of any bone chain on an exact spring, keyed into clip from start. The first extreme of the along-chain scale is exactly squash (< 1 squashes first, > 1 stretches first), the next exactly overshoot on the other side of 1, then it settles exactly to rest. volume 3d: across = along^-1/2 (a cylinder keeps its volume); area: across = 1/along. Keys go on a carrier bone ss_<chain[0]> inserted at the chain base and aligned with it (the artist's bones and keys are never touched); several calls multiply.

Character QA played in spine-core: joint cracks (where two parts' art separates at a bending joint, or a single mesh folds), foot slide (a planted foot drifting from the clip's ground speed) and the mobile bone budget for the rig type (biped, quadruped, flier, serpent, face; auto detects) plus mobile_character. Returns fix: what to change, joint by joint and clip by clip.

Rig a non-humanoid creature from its layers and build its clip set, composing the existing rigs (gait / rig_quadruped, rig_serpent chains, rig_flier wings, clip merge by name, fx recipes). kind="" lists every kind with its layer convention (case-insensitive, last group/ part of a PSD name counts), clips and options.

Kinds (clips): slime (idle, hop, hit, win): body = one mesh on a core + n_outline (6-8) outline bones with soft physics; squash keeps the volume (scaleY 0.7 -> scaleX 1.195; options.law="area" -> 1/scaleY); hop = anticipation squash, ballistic parabola (stretch ~ speed), splat recovering on an exact spring; outline wobble in Rayleigh drop modes (mode 3 at 1.936 x mode 2). Events sfx_hop, sfx_land, sfx_hit, sfx_win. golem (idle, stomp, hit): rigid parts with gaps, each lagging its parent through a critically / over-damped filter (zeta >= 1: never overshoots; fists lag two levels); glowing seams (additive glow slot per crack*); stomp = slow heavy rise, gravity drop, dust, event screen_shake (float = px, int = ms) + sfx_stomp. ghost (idle, swoop, fade_out, fade_in): strand-chain body with physics, no legs; bob and sway from two incommensurate periods closed exactly over the loop; alpha breathing; trailing wisp* strands. fade_out ends invisible (bones on setup), fade_in starts there. tentacle (idle, reach, slam): tentacle layers each a rig_serpent tentacle chain off the core with reach IK on the tip; idle phases per tentacle; reach = spring strike + IK grab (sfx_reach, sfx_grab); sucker template clones swap to stretched art while the tentacle stretches; slam whips (screen_shake). dragon (idle, walk, fly, breath, roar): rig_quadruped body + serpent neck and tail + bat wings (rig_flier stroke); breath = generated fire flipbook from the mouth (fx_fire, sfx_breath) with an ae_hint for the AE fire template; roar with screen_shake. insect (idle, walk, fly): leg_{L|R}{1|2|3}_{upper|lower}, tripod (or wave) gait with sfx_step per foot, antenna strands, wing-blur flipbook in fly. plant (idle, grow, attack): trunk chain, branch* strands, root* IK feet, leaf* physics fans; grow is diffusion-limited (front s = sqrt(2 k t)), leaves pop on a spring; attack whips a branch (screen_shake). mimic (idle, open, bite, land, win): spring hinge lid (exact overshoot), gravity close with restitution bounces, tongue strand, teeth; open fires the FX shine; land / win through the juice_apply contract.

Loops close exactly, one-shots end on the setup pose; the artist's setup never moves. The result reports the bones / slots / constraints and qa.budget(mobile_character).

Procedural sample for rig_creature (slime | golem | ghost | tentacle | dragon | insect | plant | mimic): simple readable parts drawn with PIL, one image per layer, named exactly as import_psd names a PSD that follows the kind's convention. Not rigged: run rig_creature on it.