Skip to main content
skill CX Codex

blender · digitalsamba — Claude Code skill: render 3D scenes

blender is a Claude Code skill that turns a JSON shot spec into Blender footage. It handles character animation, product shots, and clips for Remotion.

MIT 255 installs ★ 2,697 updated 2026-11-20

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add digitalsamba/claude-code-video-toolkit --skill blender -a claude-code
Open on GitHub

What blender does

The skill builds a 3D scene from a JSON shot spec and renders it as a film, separate clips, or both. The tools/blender_render.py script checks shots and camera placement, then records timed events for matching sound to motion.

Outputs go to out/, including scene.blend, events.json, a contact sheet, and, after rendering, an .mp4 or a clips folder. Clips can be prepared with alpha for Remotion or used in another editing workflow. Blender 4.2 or later is required.

What it helps with

  • render 3D scenes from a shot spec
  • create transparent clips for Remotion
  • make a 3D product or device shot
  • sync character actions to narration

Example prompts for the agent

  • Render a 3D film from spec.json.
  • Create transparent clips for Remotion in public/blender.
  • Make a product shot of a phone and model from spec.json.

How to install blender

1Skills CLI (Vercel)

npx skills add digitalsamba/claude-code-video-toolkit --skill blender -a claude-code

2Manually: put the files in place

~/.claude/skills/blender/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/blender/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about blender

How do I install blender in Claude Code?

Run npx skills add digitalsamba/claude-code-video-toolkit --skill blender -a claude-code. The skill file is at ~/.claude/skills/blender/SKILL.md.

What does blender do?

It turns a JSON shot spec into a Blender-rendered film or a set of clips. The spec describes scenes and character actions.

What does blender require?

Blender 4.2 or later is required.

Source text

SKILL.md · MIT
---
name: blender
description: 3D scenes, character acting and product shots from a shot spec, rendered in Blender, as a finished film, as clips for any other build (moviepy, a video job, an editor), or as elements of a Remotion video (transparent characters over a scene, a Remotion render on a 3D laptop, phone or floating card that the camera pulls back from, an imported 3D model on a studio stage), or a brand's opening and closing ident built from its SVG logo. A rigged cartoon cast described in JSON (build, face, hair, clothes, a seed), sets, shots by type, acting beats in seconds or on narration words, every camera checked by geometry, sound placed on the motion. Use when a video needs a consistent directable character (parody, explainer gag, reaction shot), a 3D reveal or element in a Remotion video, a device or product shot of an app or a model, or exact acting timing that AI video clips can't hold. Triggers include Blender, 3D, character animation, rigged character, cast, shot spec, acting, camera angles, transparent clip, alpha, pull out from the screen, phone mockup, device mockup, product shot, turntable, orbit, glTF, GLB, BlenderClip, logo animation, ident, logo reveal, sting, SVG in 3D.
---

# Blender shot specs

`tools/blender_render.py` turns a JSON **shot spec** into 3D footage: a whole film, one clip per shot for another
build, or both from the same spec. The spec says *what happens*; `lib/blender/`
decides *where things go*: cameras are placed by shot type round their subject and checked (in frame, nothing in
the way) before they are kept; acting is verbs (`expression`, `pose`, `shake_head`) rather than keyframes; every
moment worth a sound is exported with its time, so the sound is on the motion by construction.

Four worked examples:

- `examples/blender-product-shot/spec.json`: a studio stage with no character: a picture on a floating card and
  on a phone, and an imported model, with `reveal`, `orbit` and `product` shots.
- `examples/blender-disk-panic/spec.json`: a film from one spec (22.5 s, 8 shots, 37 beats).
- `examples/blender-in-remotion/`: Blender clips inside a Remotion video. A terminal scene cuts to itself on a 3D
  laptop and the camera pulls back; then a transparent character acts beside the list of beats it is acting.
- `examples/blender-kitchen/`: a fitted character (experimental). Mara, a generated model seated on the rig with
  `fit`, walks in with a mug, sits, puts it down, opens the laptop and drinks. Its README says what the spec
  works round.

```bash
uv run tools/blender_render.py doctor                                         # Blender found? s/frame on this machine
uv run tools/blender_render.py check  examples/blender-disk-panic/spec.json   # ~5 s: checks + stills + contact sheet
uv run tools/blender_render.py render examples/blender-disk-panic/spec.json   # ~15 min (M4, EEVEE, 1080p)
uv run tools/blender_render.py render spec.json --res 640x360                 # a draft to judge motion, 0.35 s/frame
uv run tools/blender_render.py render spec.json --engine cycles               # physical light; ~10x slower (17 s/frame)
uv run tools/blender_render.py render spec.json --clips --alpha --to projects/my-video/public/blender
uv run tools/blender_render.py open   spec.json                               # the built scene in Blender
uv run tools/blender_render.py sheet  kits/acme/cast/lead.json --out sheet/   # a character from every angle, in every face and stretching pose
```

**Tell the person how long it will take before you start.** A fitted character acting in a room renders at about
2.2 s a frame at 1080p (45 s of film is close to an hour, and is rendered more than once), so a film of this kind
is two to three hours of unattended work a session, and takes a few sessions with the person's notes between
them. End each session with the film, its checks, a decisions file and a prompt for the next session that leaves
a gap for their notes: `docs/blender.md`, "A film over several sessions".

Output in `<spec dir>/out/` (`out/<name>/` for a spec not called `spec.json`): `checks.json`, `contact_sheet.png`, `stills/`, `events.json`, `scene.blend` (open it
in Blender and scrub), and after `render` the `.mp4` named after the spec's folder, or `clips/` with `--clips`.

Requires Blender 4.2 or later. It has been run on 5.3 (macOS) and 4.2 LTS (Linux, in a container); Windows is
supported by the code and not yet run. Optional component: nothing else in the toolkit needs it.
Install, timings and troubleshooting: `docs/blender.md`.

## What the render is for

These are uses of one spec format, not separate modes: the same spec renders as a film and as clips, and a video
can mix them (a product shot between two Remotion scenes, a character film with a Remotion title card).

| The video is | Do | Then |
|---|---|---|
| A 3D short on its own (a gag, a parody shot) | `render spec.json` | `qc.py --render`, add music with `addmusic.py` |
| A Remotion video with a 3D character in some scenes | `render --clips --alpha --to <project>/public/blender`, set kind `desk` | `<BlenderClip>` over the scene's field |
| A Remotion video that turns out to be on a screen in a room | render the scene with Remotion, name it in `set.screen.video`, a `pull_out` shot, `render --clips` | hard cut from the flat scene to the clip |
| An app, a UI or a product shown as an object | set kind `studio` with a `phone`, `card` or `model` prop; `reveal`, `orbit`, `product` shots | a clip between scenes, or `--alpha` over the scene's field |
| A moviepy build, a video job or an edit in another tool that wants a 3D shot | `render --clips` (a picture-only `.mp4` per shot, its effects as a `.wav`; `--prores` for editors) | `VideoFileClip`, a `file` scene in `video_job.py`, `cutdown.py` for 9:16 |
| Narrated, with acting on the words | a `voice` block and `"at": "cue:..."` | the spec follows the voice when it is re-timed |

For Remotion, set the spec's `"fps": 30` (the composition's): a clip plays frame for frame.

**When to suggest it.** While planning any video, if `blender_render.py doctor --no-bench` exits 0, offer a
Blender shot where one fits: a character reacting, a reveal, a product or device shot. If Blender isn't
installed, don't propose it unless the user asks for 3D; then say what it needs (`docs/blender.md`).

## The loop (do this, in this order)

1. **Write the spec** from the brief or narration (below: *From a brief to beats*).
2. **`check`** and read the report. Every shot prints PASS/FAIL, its exposure, and any camera fix the solver made
   ("swung +24 deg: nominal had view blocked by dev_hood"). Exit 1 on a failure, 2 on a spec error.
3. **Look at `contact_sheet.png`** (read the PNG). Geometry can't judge everything: a hand over the key text, an
   expression that reads wrong, a beat landing in the wrong shot. Green bar = passed checks, red = failed.
   You wrote the spec, so you will see what you meant: for a film with a brief or a storyboard, also start a
   subagent with only a path to the stills in `out/stills/` copied to numbered names (no brief, board, spec or
   shot names; not the sheet, which prints each shot's name), have it retell what happens in time order and
   where the camera is, and mark each storyboard row seen, partly seen or not seen against that retelling. A
   row it did not name is a fault or a question. Do it again on the finished film, tiled with
   `contact_sheet.py --count`. `docs/blender.md`, "A second reader who has not seen the brief".
4. **Fix in the spec, not in Blender**: change a shot's `type`, `az`, `dist`, `dur`, or a beat's `at`. If the
   solver had to move a camera, consider writing its fix into the spec (`"az": ...`) so the intent is explicit.
5. Repeat 2–4 until it passes and reads right, then **`render`**. Check the result with
   `uv run tools/contact_sheet.py out/<name>.mp4` (cuts are detected), and `uv run tools/qc.py` for loudness.

`check` builds at the film's own shape (the spec's `resolution` scaled down), so a 9:16 spec is solved and judged
in 9:16. Never hand-edit `scene.blend` as the source of truth; it is rebuilt from the spec every run.

## Spec format

```json
{
  "title": "Disk Panic", "fps": 24, "resolution": "1920x1080", "engine": "eevee",
  "look": {"exposure": -0.9, "look": "AgX - Punchy"},
  "set":  {"kind": "desk_room", "palette": {...}, "screen": {...}},
  "cast": [{"id": "dev", "kind": "clay_person", "colors": {"top": "#F26B1F"}}],
  "shots": [{"id": "S1_wide", "dur": 3.0, "type": "wide"}, ...],
  "beats": [{"at": "S1_wide+1.6", "do": "blink"}, ...],
  "score": [{"from": 0, "to": "S2_alert+0.5", "mood": "calm"}, ...]
}
```

Also in `look`: `"raytracing": false` turns off EEVEE's screen-space ray tracing, for a room whose still surfaces shimmer
from frame to frame (the flicker check says so). First look for a light that sits inside a shade or beside what it
lights with a soft shadow: that is the usual cause, and the fix is `use_shadow = False` on that light in the set.

Also at the top level: `"transparent": true` (the same as `--alpha`) and `"voice"` (below), and `"clock"` (seconds): where
this spec starts on a longer film's timeline, so clips made from several specs breathe in step and join without a
jump. Start and end each such clip in the same pose, looking at the same thing.

**Acting takes the same time at any `fps`.** A blink, a typing rhythm and a head shake are written in seconds
inside the rig, so a 24 fps film and a 30 fps clip for Remotion act alike.

**A mistake in a spec is named, with the choices.** An unknown face, pose, shot type, subject or cast member is a
spec error (exit 2) that lists what there is, before anything is rendered.

**Times** are seconds: a number (absolute), or relative to a shot: `"S3"` (its start), `"S3+0.4"`,
`"S3.end-0.2"`, `"end"`. Write beats relative to the shot they play in, so changing one shot's `dur` keeps the
acting in step. Beats are applied in time order; a beat's length is `dur` (seconds) or `until` (a time).

**Times from the narration.** List the caption files `tools/captions.py` wrote, each with where its audio starts,
and a time can be the moment a word is said:

```json
"voice": [{"captions": "../public/audio/scenes/02_alert.captions.json", "at": "S2_alert+0.3"}],
"beats": [{"at": "cue:disk is full", "do": "alert"},
          {"at": "cue:full#2-0.1", "do": "expression", "face": "shocked"}]
```

`cue:` takes a word or a phrase (case and punctuation ignored), `#2` for its second occurrence, and an offset. A
phrase that isn't in the narration is a spec error that prints what the narration does say, as `cue()` does in
Remotion. Paths are relative to the spec.

### Cast

A cast member is a description, and every field is a named choice or a hex colour, so an agent can write one
from a sentence ("a woman in her forties with a grey bob, glasses and a green shirt") or from a photo:

```json
{"id": "maya", "kind": "clay_person", "seed": 12,
 "body":    {"build": "slim", "skin": "brown"},
 "face":    {"shape": "oval", "eyes": "brown", "brows": "thin", "nose": "small", "beard": "none"},
 "hair":    {"style": "bob", "color": "grey"},
 "clothes": {"top": "shirt", "top_color": "#2E7D5B", "pants": "#252B45", "shoes": "#F0F0EC"},
 "accessories": ["glasses"]}
```

| Field | Choices |
|---|---|
| `body.build` | `average`, `slim`, `broad` |
| `body.skin` | `pale`, `light`, `tan`, `brown`, `dark`, `deep`, or a hex colour |
| `face.shape` | `round`, `oval`, `square` |
| `face.eyes` | `brown`, `hazel`, `green`, `blue`, `grey`, or a hex colour |
| `face.brows`, `face.nose` | `medium`, `thin`, `thick`; `round`, `small`, `long` |
| `face.beard` | `none`, `moustache`, `full` |
| `hair.style` | `tufts`, `short`, `bob`, `long`, `bun`, `curly`, `bald` |
| `hair.color` | `black`, `dark`, `brown`, `chestnut`, `red`, `blonde`, `grey`, `white`, or a hex colour |
| `clothes.top` | `hoodie`, `tee`, `shirt`; `top_color`, `pants`, `shoes` are hex colours |
| `accessories` | any of `glasses`, `headphones`, `earrings` |

- **Left out with no `seed`:** the defaults, which is the character the examples use.
- **Left out with a `seed`:** drawn from the seed. `{"id": "extra", "seed": 41}` is a whole person, the same one on
  every machine, and another seed is someone else.
- **A standing cast.** Keep a character in its own file and name it: `{"id": "lead", "from":
  "../../kits/acme/cast/maya.json", "clothes": {"top_color": "#B23A48"}}`. Fields beside `from` override the
  file, so one video can change the costume and keep the person. `kits/example/cast/maya.json` is one.
- From a photo: choose the nearest named choice for each field and sample the hex colours from the picture. The
  result is a caricature in the toolkit's style, not a likeness.
- Every character has the same rig, so every verb works on every character. Check a new one with a `closeup` and
  a `medium` shot before writing the beats.
- **Where they start.** A cast member sits at the desk unless told otherwise: `"posture": "stand"`, `"at": [x, y]`
  (a spot on the floor, metres) and `"facing"` (degrees: 0 faces -Y, toward the desk; positive turns to their own
  left) put them on their feet anywhere in the room.

**A fitted model (experimental).** `"model": "lead.blend"` in a character file swaps the clay body for a
generated 3D character fitted to the rig by `lib/blender/fit_model.py` (an A-pose mesh from an image-to-3D
service, plus a `fit.json` of its joints and face). The model keeps its own shape: it is bound in its A-pose and
the rig poses it, so the same verbs drive it, and the chair, desk and laptop are placed for its legs and arms (seat
at its knee height, keyboard under its hands). `glasses` is the one accessory a model takes. Its face is made from its own marks (a lower
lip, teeth and lids on the model's lip line and eyes, with the cheeks and chin moving for a smile or an open
mouth). If `check` says the rig's eyes are far taller than the ones painted on the model (a stare, on a face
painted nearer to life than a cartoon), put `"paint": "keep"` in the fit's `face` and fit again: the painted face
stays, the eyes that move are cut from it, the painted lips part when the mouth opens, and `happy` becomes a closed smile. A model in a long skirt or dress takes `"skirt": <hem height>` in the fit, or the cloth is cut between the legs. A cloak or cape is its own piece of cloth, simulated and baked for each shot, not part of the generated body (`docs/blender.md`, "A cloak as its own piece of cloth"). With a second model of the same character with open hands the fit gives it fingers: hand shapes, a
grip on a door handle, hands laid flat on the desk, fingertips on the keys. The fit lays a generated thumb in to
the palm (it stands off it on a thick wedge), so the hands type at a typist's slope. The donor's hands are sized to the body's own, the wrist joint
is put at the cuff, and the desk, the keys and how far apart the hands lie come from the body's measures, so one spec
runs on characters of different builds (run a spec on two to find a number tuned on one; `docs/blender.md` has the
method). Head shots aim at a fitted character's own head, whatever its
proportions. A worked example with an invented character is `tests/fixtures/blender-fitted`, and one with bare arms and
her painted face kept is `tests/fixtures/blender-bare`. To make a generated model smaller, use
`uv run tools/blender_render.py reduce --model in.glb --out out.glb --faces 60000`, never Decimate by hand: it
thins the mesh inside the islands of its texture, and a face collapsed across a seam is painted from the wrong
place (shards by an eye). Make the open-hands picture from a hips-up crop so the fingers come out apart. Read the
fit's output: any line with FAIL (a torn thumb web, faces painted from the wrong place, the inside of a forearm
moving with the body) is a fault that will show in a close shot. A body's hand read as over 21 cm from cuff to
fingertip means the sleeve was taken for skin (brown or tan wool): put `"hue": 0.05` in the fit's `hands`. To recolour a generated model's costume, work by mesh faces, not by the picture: its texture is hundreds of scattered islands, and a blur over it bleeds one into the next (`docs/blender.md`, "Lit 3D that reads as paint", which also has a painterly look for lit 3D: banded light as an emission, a Kuwahara pass over the frame). The joints are written for the left and mirrored:
slice both arms of the mesh, and where the right differs give it in `"joints_right"` (a right elbow mirrored 3 cm
outside the arm left a sheet of skin hanging from it to the hip). The steps and their costs are in `docs/blender.md`.
**When a fitted character does not read as the person**, make a review sheet before changing anything:
`blender_render.py sheet cast.json --photos photos.json` renders the character in even light from every angle, in
every face and in the poses a walk-in never reaches (arms up, hands on and behind the head, sitting, typing), and
lays each reference photo beside and over the still from its angle with crown and chin on the same lines.
Compare proportions as shares of the head's height and colours as lightness against the skin, write each finding
down (Seen, Wanted, Layer, Measure, Status), and fix the top ones. The fit file takes `"recolour"` (shift the
model's painted hair, beard or skin to a colour read off a photo, with `fill` for stubble painted as dots) and
`"lid"` in `face` (hooded eyes: the lids rest part of the way down). Glasses are placed and sized by the eyes.
The method is in `docs/blender.md`, "Refining a character".
For a character of a real person, the reference photos come from `uv run tools/reference_capture.py --out <folder>`:
a local page that talks the sitter through eight poses at a webcam. It needs the person at a browser, so ask
them to run it; never commit their photos. Two things to settle on the character sheet, before any 3D spend: the
feet under the hips (a wide stance spreads wide trousers or a skirt), and sleeves if close shots show the hands (on
a bare arm the fit cuts the hand at the wrist, and the join can show).

### Shots

| `type` | Subject | Use for |
|---|---|---|
| `wide` | character (3/4 front) | establishing: who, where |
| `front_wide` | character (straight on) | endings, titles above the head |
| `medium` | character (waist up) | gesture: hands on head, shrug |
| `closeup` | character (face) | the reaction; emotion lives here |
| `side` | character (profile) | effort, leaning in, typing hard |
| `over_shoulder` | `"subject": "screen"` | what they see: the alert lands |
| `insert` | `"subject": "screen"` | the detail: a bar draining, a number changing |
| `screen_fill` | `"subject": "screen"` | the screen covers the frame edge to edge, square on |
| `pull_out` | `"subject": "screen"` | starts as `screen_fill`, holds, then travels back round the shoulder to a side view of the desk |
| `push_in` | `"subject": "screen"` | `pull_out` reversed: ends on the screen, ready to cut to the flat scene |
| `full` | character, on their feet | head to toe; `"follow": true` travels with a walk |
| `feet` | character, on their feet | a low insert on the feet, travelling with them: an entrance before the face |
| `tilt_up` | character, on their feet | starts on the feet, holds, tilts up to the face (`hold` seconds at each end) |
| `fixed` | none: the camera is put where the spec says | `"cam"` and `"aim"` are points in the room (or `"phone"` and `"face"`: see `phone` below), `"dof"` an f-stop and `"shake"` a hand's drift in metres; `"lens"` is for the whole frame, `"push"` moves it that share of the way to the aim over the shot. `"window": [x0, y0, x1, y1]` (from the left and the bottom) renders only that share of the frame, by lens shift, so a clip of the window lies exactly where it would in the whole frame: set the spec's `resolution` to the window's shape |
| `move` | none: from one framing to another | `"from"` and `"to"` are each `{"cam", "aim", "lens"}`; in a `lecture_hall` a point may be `{"hall": [x, out, z]}` (the hall's measure: x from the board's middle, out from its wall, z up) and `"to"` may be `{"cam": "board"}` (the board camera, `lens` 108 unless given). The camera eases out, comes down before it comes in (a crane, then a push), and arrives along the end framing's own axis; the lens changes on the way. `"start"` and `"arrive"` are seconds into the shot, or `"walk"`: it sets off with the subject's first walk and lands on the frame their last walk ends (the turn at the end in it); `"start": "last_walk"` sets off with their last walk instead (after a stop on the way in, so the camera holds the room while they do something there). Checked on every frame: the lens clear of the set (`nearest_set_m`), the board and the walker in view, and once landed on the board, its corners on the frame's to the pixel and nothing but the subject in front of it (`landing`) |
| `product` | a studio prop | a three-quarter view of the prop, pushing in a little |
| `orbit` | a studio prop | the camera travels round the prop from `az` to `az_to` |
| `reveal` | a studio `phone` or `card` | starts on its screen edge to edge, holds, then pulls back to the `product` view |
| `ident` | a studio prop, usually a `logo` | square on, in the prop's own directions; `"from"` / `"to"` are where the camera comes from and leaves for; its last frame (or first, `"mark": "start"`) is tested against the flat SVG |

`"built_only": true` on any shot: it is built (the acting runs through it, so the next shot starts mid-move, or a
spec runs as long as another) and never rendered, so its exposure is not judged and a lecture's board share leaves
it out.

Overrides per shot: `dof` (an f-stop: the subject sharp, the room behind soft), `az` (degrees round the subject; 0 = straight in front, + = the subject's left), `dist` (m),
`h` (camera height above the target, m), `lens` (mm), `push` (fraction of the distance closed during the shot),
`shake` (handheld jitter, m; ~0.012 for urgency), `side` (`"left"`/`"right"` flips `az`).

The solver tries the nominal placement, then pulls back, swings ±12/24/36°, and rises, keeping the first that
passes at the shot's start, middle and end. What it changed is in the report.

A character who has left the chair is filmed where they are at the middle of the shot, facing the way they face
then, and the solver also tries the far side of them when a wall is in the way. `"follow": true` on any character
shot makes the camera travel with them. `"reveal": true` is for a shot the subject enters (through a door): it is
judged on its last frame only. `tilt_up` is judged where it ends, on the face.

The three moves take `az`, `elev` (degrees) and `dist` (m) for their far end, `hold` (seconds on the full screen
before moving, default 0.4) and `lens`. They are checked at 13 points along the way, also for the lens passing
within 0.3 m of a character ("lens 0.16 m from dev_body"), which is what makes a head fill the frame mid-move.
Their contact-sheet still is the far end. They pass in 16:9, 9:16 and 1:1.

`product`, `orbit` and `reveal` take their distance from the prop's size, so a 15 cm phone and a 2 m chair fill
the frame alike: `fill` (0 to 1, the share of the frame the prop takes at its widest moment), `az`, `az_to`,
`elev`, `lens`, or `dist` to set the distance by hand. A prop with a screen also reports `screen_readable`, the
share of the shot in which the screen is within 60 degrees of facing the lens; under half is a failure ("narrow
the orbit").

### Beats (`do`)

Character (`who` defaults to the first cast member):

| verb | fields | |
|---|---|---|
| `type` | `speed`: `calm`/`frantic`, `until` | hands typing; a click per key in the sound |
| `pose` | `pose`, `dur` | `type`, `rest`, `hands_on_head`, `arms_up`, `hands_behind_head` |
| `expression` | `face`, `dur` | `neutral`, `happy`, `content`, `shocked`, `worried`, `determined`, `relieved`, `grin`, `hopeful` (worried brows, a slight smile) |
| `look` | `target`, `dur` | `screen`, `down`, `ahead`, `camera`, `up`, or degrees of head pitch |
| `lean` | `amount`, `dur` | `forward`, `none`, `back`, `far_back`, `recoil`, or degrees |
| `head_bob` / `shake_head` | `until` | idle nod to the work / "no no no" (whoosh each turn) |
| `gulp`, `blink`, `tap` | | single moments (`blink` takes `dur`, or `frames` counted at 24 fps) |
| `sweat`, `tremble` | `until` | a drop slides down / pupils jitter |
| `celebrate` | `until` | arms up, wiggling |
| `hold_arms` | | freeze the arms where they are |
| `stand_up` / `sit_down` | `dur` | off the chair onto their feet (the head lifts, hands to the knees, the chest comes forward over the feet, then up, the arms dropping last) / onto the chair behind them (a look down, the pelvis back before it goes down, hands to the knees, a small settle). Stand them a thigh's length in front of the seat first. About 1.7 s each reads well; under a second looks hurried |
| `walk` | `to`: `[x, y]`, `facing`, `until`, `curve`, `heading`, `stride` | walk to a spot and stop, facing `facing` degrees. They turn on the spot first when the way to go is more than 30 degrees off, and again at the end. With no `until` or `dur` it takes what the steps need. A footstep in the sound per step. `"curve": true` walks a bend in place of a line and two turns: the feet land on the bend, the body banks into it and the head looks along it; `heading` is the way they are going as they arrive (degrees, like `facing`). `stride` is a step's length as a share of the leg (0.5 by default, a stroll; 0.75 to 0.8 is an unhurried lecturer's walk in fewer steps, 0.3 to 0.85) |
| `turn` | `facing`, `dur` | turn on the spot, stepping round: the eyes and head go first, the chest follows, and it swings a little past at the end |
| `wink` | `side`: `left`/`right` | one eye, the brow dipping with it |
| `look_at` | `target`: `[x, y, z]`, `camera` or `screen`, `dur` | head and eyes to a point: the neck turns most of the way, the eyes the rest |
| `glance` | `yaw`, `pitch`, `dur` | the eyes alone, in degrees (up to about 25) |
| `reach` | `target`: `[x, y, z]`, `hand`, `dur` | a hand to a point in the room; an error says how far short it is |
| `point` | `target`: `[x, y, z]`, `camera` or `screen`; `hand`; `back`; `dur` | the arm lifts nearly straight at the target (it reads from across a room), index out, thumb up; held for the beat (1.5 s without `dur`), then back unless `"back": false`. Without `hand`, the one on the target's side. Add a `look_at` to the same target for the eyes. The event gives `aim_deg`. A `lights` beat with `"by"` is a point that arrives: the fingertip (a mitten's knuckles) lands on the switch and presses it, checked as a touch (`touch_miss_m`) |
| `hand` | `shape`: `open`, `relaxed`, `loose`, `grip`, `flat`, `type`, `point`, `fist`; `hand`: `left`/`right`; `dur` | the fingers take a shape (both hands without `hand`). Only a fitted model whose fit found fingers has them: the clay cast's mittens are left as they are. Poses and verbs set shapes themselves (`type` on the keys, flat on the desk, a grip on a door handle, relaxed at the sides), so this is for a point or a fist. `loose` hangs more open than `relaxed`: on a fit whose relaxed hand reads as a fist at the side, set the free hand `loose` at the clip's start (gestures come back to it) |

A presenter on their feet (a `lecture_hall` set for the things that are carried; the rest work anywhere):

| verb | fields | |
|---|---|---|
| `talk` | `until`, `amount` | the mouth opens and closes on the narration's words between the beat and `until` (the spec's `voice` captions): one opening a syllable, wider for an open vowel, rounder for an o or a u, shut on a pause and on b, m and p; the head dips a little on the longer words. A fitted face only |
| `blinks` | `until` | blinks every two to five seconds, now and then twice |
| `whistle` | `until`/`dur` | the lips purse as for a whistle and swell a little on each breath, eased in and out (the sound is yours to lay on: a recording, placed on the same seconds). A fitted face only |
| `gesture` | `kind`: `open`, `both`, `shrug`, `count`; `hand`; `dur` | a talking gesture held for the beat, then the hands go back: one open hand lifting on a point, both hands opening out, a shrug with the head tipping, a raised index. On a fitted body the hand turns on the forearm no further than that body's cuff takes (measured each build; `skin.wrist_twist` in `checks.json`), as in a `point` or a `present` |
| `present` | `target`: `[x, y, z]` or `screen`; `hand`; `dur` | show something beside or behind them (a board): the chest turns part of the way, the head and eyes go to it and stay for the first half, the arm on that side points; then all come back. Follow it with a `look_at` |
| `dust_hands` | `dur` | the hands come up palms together and brush past each other |
| `carry` | `prop`: `cup`; `hand` | from this beat the cup is in a hand held in front of the chest, and that arm stays out of a walk's swing. A mug is held by its handle (the fist closed on it, the mug out past the knuckles); a takeaway cup in a hand round it. The hand goes on carrying through `sit_down` and `pull_in`, level, and lifts the cup clear of the table as it comes under it |
| `put_down` | `prop`: `cup` or `chalk`; `hand`; `to`: `[x, y, z]`; `lean`; `dur` | the hand takes what it holds to its spot on the table and lets go; an error says how far short the arm is. `lean` is how far the chest bends to it (9 degrees unless given). Someone sitting at a kitchen table leans only as far as the table's edge allows, the hand lies flat beside the laptop afterwards, and the other hand stays where it lies on the table |
| `pick_up` | `prop`: `chalk` or the kitchen's `cup`; `hand`; `dur` | a hand takes the chalk off the table; it lies along the index finger and the hand keeps hold of it through every later shape. The kitchen's mug is taken by its handle and lifted to where a cup...

© digitalsamba · MIT · digitalsamba/claude-code-video-toolkit

Similar skills

All skills for Game dev and 3D: Unity, Unreal, Godot, Blender →

blender by other authors comes first.

Blender SFKislev Blender is a Claude Code skill that controls an open Blender scene through the local Flue bridge. It inspects scene data and runs small bpy scripts on request. CX Codex +1 2,900installs blender MonumentalSystems Quick reference for Blender workflows, shortcuts, rigging setups, and 3D export pipelines into Unity and Unreal Engine. CX Codex +1 563installs blender-motion-state-inspection affaan-m blender-motion-state-inspection is a Claude Code skill that inspects 3D rigs, poses, and animations in Blender. It measures bone coordinates and ground contacts directly instead of relying on renders. CX Codex +1 7,000installs blender-animation RobLe3 blender-animation — a skill that lets your coding agent keyframe, ease and morph objects in Blender through an MCP server. CX Codex +1 2,500installs scenario-blender-animation scenario-labs The scenario-blender-animation skill animates characters and objects in Blender using Python scripts. It handles stepped blocking, curve editing, lip sync, and camera-space motion arcs. CX Codex +1 1,200installs blender-image-to-3d majidmanzarpour The blender-image-to-3d skill builds a game-ready 3D asset in Blender from reference images through gated phases with renders. Runs whenever a user supplies a reference image for modeling. CX Codex +1 917installs blender-facial-shapekeys blender-agent-skills blender-facial-shapekeys is a Claude Code skill that configures facial rigs and shape keys in Blender 5.3 for ARKit 52 and engine export. Runs when preparing 3D character faces for animation or export. CX Codex +1 548installs blender-materials RobLe3 blender-materials is a Claude Code skill that creates and assigns PBR materials in Blender via Principled BSDF for requests such as “make it look like copper” or “matte finish”. CX Codex +1 3,100installs

From the same set13

The whole set →
video_toolkit video_toolkit builds short explainer videos from a brief through background jobs with quality control checks. CX Codex +1 1,500installs qwen-edit qwen-edit is a Claude Code skill that prepares prompts and settings for image edits with Qwen-Image. It activates for photo changes such as reframing, outfit edits, pose adjustments, and style transfers. CX Codex +1 1,500installs runpod A skill for running open-source AI models on cloud GPUs through RunPod serverless. Useful when a job needs more VRAM than your machine has. CX Codex +1 1,400installs ideogram4 Generates images with legible in-image text and brand color control via Ideogram 4. Useful for video title cards and thumbnails. CX Codex +1 978installs synthetic-ui-demo The synthetic-ui-demo Claude Code skill builds product videos without screen recording. It recreates selected app screens in React, then scripts cursor and camera movement in Remotion. CX Codex +1 614installs video-design video-design is a Claude Code skill that defines typography scales, act palettes, and layout rules for 16:9 and 9:16 video scenes. Runs during slide styling and scene critique. CX Codex +1 588installs youtube-stats The youtube-stats Claude Code skill gathers performance data for published YouTube videos and channels. It runs for requests about views, retention, traffic sources, or which videos performed well. CX Codex +1 354installs parody-short The parody-short Claude Code skill helps create comedy shorts about a team, family, or shared event in a chosen genre. It activates on requests for a parody, holiday video, or animated photos of people. CX Codex +1 334installs

More in the catalog

Project sponsors

Companies that keep this analytics open