Low-poly 3D, serif captions

---
name: faceless-lowpoly-3d
description: Make faceless "What if X and couldn't stop?" YouTube videos in flat-shaded low-poly real-time 3D with italic serif captions, a climbing corner counter, first-person long takes and a parametric character, from a script to final.mp4 and thumbnail.png.
---

## Public package setup

Export `KIT` to your extracted kit directory and `SKILL` to this extracted style directory.
Read README.md for dependencies, missing assets and setup. Example media and private review
material mentioned below are not bundled; create your own input/output paths.

# Faceless low-poly 3D, serif captions

One second-person experiment, one number that runs away, seen from inside a simulated world. The whole picture is code:
Three.js scenes rendered frame by frame by the kit, driven by `timeline.json`. Full measured style sheet: `SPEC.md`.

```
SKILL=$SKILL
KIT=$KIT  PY=$KIT/.venv/bin/python
```

## Workflow

```
$SKILL/build.sh script.txt --out out --quality standard            # script -> final.mp4 + thumbnail.png, ends with qc.py
$SKILL/build.sh script.txt --out out --voice none                  # text-only video (11 of 15 channels), reading-speed timings
$SKILL/build.sh script.txt --out out --from 20 --to 40             # render a slice to out/slice.mp4 and stop
$SKILL/tools/stills.sh out/timeline.json look.jpg 3 12 25 40       # contact sheet of stills, SS=2 for supersampled, COLS=3
node $SKILL/planner/plan.mjs --script s.txt --words w.json --out timeline.json --cues cues.json [--rhythm mixed|longtake|cutty]
python3 $SKILL/tools/fake_words.py s.txt w.json                    # timings without a voice, for dry runs
node $SKILL/tools/thumbnail.mjs out/timeline.json thumbnail.png [--shot low|chase|pov] [--value "1,235 km/h"] [--tag "..."]
```

`build.sh` options: `--quality draft|standard|max`, `--rhythm`, `--voice <minimax id>|none`, `--speed`, `--topic "title"`, `--character "..."`,
`--music "prompt"`, `--seed n`, `--no-qc`, `--force`. Existing outputs are reused: delete `timeline.json` to re-plan, `silent.mp4` to re-render.

Before a long render always check 6 to 8 stills with `tools/stills.sh`, covering each shot kind the planner chose. Rendering is about 7 to 9 fps at standard, 1080p.

## Writing the script

**Title formula.** `What if [you did X] and couldn't stop?`, `What if every [action] made you [multiplier] [attribute]?`.
**Hook.** The first line is the end state, in the present tense, 2nd person, one short sentence: "You can't slow down." Then the title, spoken. The planner shows the extreme of the video under the hook, dips to black and starts the story.
**Voice.** Second person, deadpan, plain words, one thought per sentence, 128 wpm. A sentence is under 14 words. No "imagine", no "let's", no questions to the viewer after the title.
**Escalation.** A threshold every 15 to 25 s, each one a concrete comparison ("Faster than a cheetah."). Say numbers the HUD can show.
**Show, don't explain.** Every sentence names something the picture can do: your legs, a car, the sky, your watch, the clock. The planner stages what the sentence says at the second it is said.
**Openings.** With a `home` opening, put the alarm or wake-up line straight after the title, keep the door within the next two sentences, and put "faster" or "your legs" on the sentence where the run must start: the walk is timed to those words. Do not say "traffic" or "blur" before the speed can show it.
**Set pieces.** A train or airliner only exists beside the highway: tag `[stage: highway]` first, or the planner skips it and prints a warning.
**Length.** 90 s to 4 min. About 200 to 500 words. Above 3,600 km/h the road ends: the planner moves to Earth from orbit, above 40,000 km/h to the warp tunnel.

Front matter is optional and on top of the file:

```
---
title: What If You Sped Up and Couldn't Stop?
variable: speed            # speed size money weight temp heat rain time count; inferred from the title if omitted
from: 5                    # start value
to: 1500                   # end value, reached at the end of the video
character: a ripped guy in a red tank top with black shorts
tagline: You can't slow down.
look: golden               # or a sequence: golden,dusk,night  (golden sunset dusk night dawn noon overcast storm snow inferno)
weather: rain              # rain snow flood
opening: home              # home (bedroom to street in one take) or road; inferred from wake/alarm/door words
rhythm: mixed              # mixed longtake cutty
label: Your speed          # HUD label, optional
---
```

Tags go in `[brackets]` anywhere in the text, apply to the next sentence, and are never spoken. Plain text with no tags works; tags are for when you want a specific picture.

| tag | effect |
|---|---|
| `[start]` | everything before this is the cold open |
| `[shot: chase]` | pov chase side lead low passby top aerial crane orbit face feet |
| `[gaze: down]` | POV look: down feet back left right up sky hands wrist side |
| `[cut: whip]` or `[whip]` | cut whip dip flash dissolve blink push tilt blend |
| `[stage: city, Downtown]` | the road reaches this biome on this sentence: suburb strip city highway rural forest desert salt |
| `[prop: clock 6:52]` | extreme close-up: clock, phone TEXT, monitor HEAD\|BIG or HEAD\|LINE\|BIG, calendar MONTH N, scale 70.0, dial, money |
| `[event: truck]` | car truck bus van train airliner passes at this sentence |
| `[pose: flex]` `[face: shocked]` | stand flex point shrug handsOnHead crossed phone watch sit fall victory reach; neutral happy sad shocked scared angry tired focused |
| `[set: earth]` | earth, warp, home |

The planner already maps words to pictures (`planner/lexicon.mjs`): "your legs" looks down, "behind you" looks back, "traffic" stages a car alongside at that word, "the sky" tilts up, "alarm" cuts to the clock, a time like 6:52 appears on it, "the door" opens on that sentence, "faster" starts the run. Check `timeline.json` and tag only what it got wrong.

### What each variable does in the world

| variable | world behaviour |
|---|---|
| `stride` | speed world with the HUD in metres per step (`from`/`to` in m); `horizon: 60` sets the curve of the full video when rendering only an opening, `tail: 0.9` trims the end hold |
| `speed` | the only runner: exponential speed, biomes reached at speed thresholds, HUD comparison ladder, Earth and warp past 3,600 km/h |
| `size` | hero and every camera rig scale together, Earth above 30 km |
| `temp` | golden to night, snow builds on upward faces, snowfall |
| `rain` | rain, a water plane rises with the value and drowns the town; the hero and camera ride it in a red dinghy |
| `heat`, `money`, `weight`, `time`, `count` | the hero walks the sidewalk and the HUD runs away. These need `[prop: ...]`, `[stage: ...]` and `[shot: ...]` tags to feel staged. There is no money-pile set. |

Rules learned in the test: a line about legs gets `[shot: low]` or `[shot: feet]`, not a POV look-down; long trousers read better than bare legs from above; `[shot: x]` tags always start a new shot.

## Character

`character:` takes plain English: body (ripped, athletic, slim, heavy, tall, short, old, kid), sex, skin (pale, light, tan, olive, brown, dark), top (tank, tee, longsleeve, hoodie, suit, coat, dress, shirtless), bottom (shorts, trunks, jeans, pants, skirt), colours by name, shoes (sneakers, boots, dress, barefoot), hair (bald, buzz, short, side, long, ponytail, bun, afro, curly, mohawk, plus colour), hat (cap, beanie, hard hat, helmet, crown, cowboy hat), glasses, sunglasses, watch, backpack, tie, chain, headphones, scarf, beard, moustache, stubble, "faceless mannequin", "robot" for glowing eyes.
The same mesh is third-person hero, POV arms and legs, and thumbnail. Six are shown in `characters.png`; regenerate from `scene/gallery.html`.

## Cinematography rules (coded in `planner/plan.mjs` and `scene/lib/director.js`)

- Never a static wide. Every shot has a move; inside a take something happens every 3 to 5 s: a gaze beat, a staged event, a threshold.
- House rhythm `mixed`: cold open 2 to 3 shots in 5 s, then a cut or designed transition every 8 to 14 s. POV is the home base and appears every 2 to 3 takes. `longtake` is Minute Zero (1 to 3 cuts/min); `cutty` is FunNotSoFun (12 to 20).
- Shot kinds: `pov` eye level dolly with bob; `chase` behind, backlit by the sun; `side` long lens track; `lead` in front, front-lit; `low` knee height looking up; `passby` planted, the runner flies past; `top` overhead; `aerial` high angle with Dutch; `crane` rising; `orbit`; `face` close-up with DoF; `feet` shoes on asphalt; `insert` object ECU.
- The sun sits at the end of the road. Chase is silhouette, lead is key-lit: use both.
- Cuts land in a sentence gap, never mid-word. Inserts last under 4 s and the simulation keeps running under them.
- One simulation clock: third-person shots show the runner where POV left him, so continuity across cuts is automatic. Cold-open shots just read the sim at a later time.

## Transitions

| type | use |
|---|---|
| `blend` | continuous: the camera leaves the head and flies out to third person, or back in. Default between POV and chase |
| `cut` | new angle, same action |
| `dip` | cold open to story, new chapter |
| `flash` | threshold: white flash, shock ring, boom |
| `whip` | location jump; the cut hides at peak blur |
| `dissolve` | time jump |
| `blink` | POV to POV time skip, eyelids close and open |
| `push` | fly into something, come out of the next |
| `tilt` | POV tilts to the ground, cut there, next shot tilts up |

## Layout

Solved in code, not in QC. Caption, HUD, corner stat, title and card each have a reserved zone (`scene/lib/overlay.js`). `solveCaptions()` in `scene/main.js` projects the yellow centre line through the real camera path for every caption and moves the text sideways, then upward, until it clears the line; `__qc` reports the line as a box so a miss fails the gate. Captions are one sentence or clause; clauses over 70 characters are split.

## Sound

Continuous bed in every video: `music.py` prompt from the timeline (dread, awe or playful), plus `tools/ambience.py`, wind noise driven by the simulated speed, mixed in `bed.wav`. Voice ducks the bed. Effects are sparse and tied to the picture: whoosh on real pass-bys and whips, boom and sub drop on flashes, a soft tick on HUD threshold changes, low hit on cold-open cuts. All cues come from `cues.json`, written by the planner. Default voice `English_Deep-VoicedGentleman` at 0.97, emotion calm.

## Quality levels

| level | render | look | use |
|---|---|---|---|
| `draft` | `--ss 1` | no AO, bloom, SMAA, no motion blur or DoF | layout and timing only, it looks flat |
| `standard` | `--ss 1` | GTAO, bloom, SMAA, motion blur, DoF, 2048 shadows | default |
| `max` | `--ss 2` | same with 4096 shadows, about 2.5x slower | finals |

## QC loop

`build.sh` ends with `qc.py`. A video is finished only when it exits 0.

1. Read `out/qc/report.md` and `out/qc/flagged.jpg`.
2. Fix the cause in the script tags, planner or scene, never by hiding it. Re-render the affected slice.
3. Re-run QC. `ignore.json` is for truly intended findings, with the reason, kept short and honest.

`__qc` tracks the hero and every vehicle within 340 m, and marks everything as allowed to change only on the frames of a planned cut. Between cuts, a pop is a real pop.

## Assets

The world, vehicles and characters are procedural and need no downloads, so everything shares one flat-shaded language. Fonts: Newsreader and Inter (OFL) in `scene/fonts`. See `CREDITS.md`. If you add a Sketchfab or Poly Haven model, log it in `ASSETS.md` and `CREDITS.md`, run `assets.py credits`, and put CC-BY lines in the video description.

## Files

`planner/plan.mjs` script to timeline, `planner/lexicon.mjs` words to pictures; `scene/index.html`, `scene/main.js` page; `scene/lib/` world, road path, props, character, home, inserts, space, weather, traffic, director, overlay, HUD, post, materials, looks; `tools/` thumbnail, stills, ambience, fake_words.