Skip to content
Back to search

robot-reel

SkillWorks with Claude CodeGitHub

Make a voiced showcase video of a robot from its URDF (robot description file with links, joints and meshes) and a short shot list, on this machine, with no real robot, no camera and no paid service. Loads the robot, poses and animates its joints within their limits, moves a virtual camera in a lit studio, adds voice, word-by-word captions, labels on parts and music, and encodes an MP4 (vertical, square or landscape) plus a web copy, poster and looping preview. Use whenever the user wants a video, demo reel, promo, explainer or animation of a robot, robot arm, mobile robot, humanoid or any URDF model, or wants to inspect a URDF's joints and size.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/vinvirtual--robot-reel/badge.svg)](/listings/vinvirtual--robot-reel)

HTML

<a href="/listings/vinvirtual--robot-reel"><img src="/api/listings/vinvirtual--robot-reel/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

git clone https://github.com/VinVirtual/robot-reel
cd robot-reel

# 1. Playwright (drives the browser) and a browser with WebGL
npm i -g playwright-core
# if Google Chrome or Chromium is not installed:
npx playwright install chromium

# 2. The voice: a Python environment with kokoro-onnx, and the model files
python3 -m venv ~/kokoro/.venv
~/kokoro/.venv/bin/pip install kokoro-onnx soundfile numpy imageio-ffmpeg
cd ~/kokoro
curl -LO https://github.com/thewh1teagle/kokoro-onnx/releases/download/model-files-v1.0/kokoro-v1.0.onnx
curl -LO https://github.com/thewh1teagle/kokoro-onnx/releases/download/model-files-v1.0/voices-v1.0.bin
cd -

# 3. Check
./robot-reel check

To use it as a Claude Code skill, put this folder at `~/.claude/skills/robot-reel`.

Where tools are found, and how to point elsewhere:

| Variable | Default | |---|---| | `KOKORO_HOME` | `~/kokoro` (model files) | | `KOKORO_MODEL`, `KOKORO_VOICES` | the two model files in `KOKORO_HOME` | | `ROBOT_REEL_PYTHON` | `$KOKORO_HOME/.venv/bin/python`, else `python3` | | `FF` | `ffmpeg` on the PATH, else the one inside `imageio-ffmpeg` | | `PLAYWRIGHT_CORE` | `playwright-core` next to the skill, else from the global npm folder; never the current folder | | `ROBOT_REEL_CHROME` | installed Chrome, else Chromium, else Playwright's Chromium |

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 41 lines
  1. ---
  2. name: robot-reel
  3. description: Make a voiced showcase video of a robot from its URDF (robot description file with links, joints and meshes) and a short shot list, on this machine, with no real robot, no camera and no paid service. Loads the robot, poses and animates its joints within their limits, moves a virtual camera in a lit studio, adds voice, word-by-word captions, labels on parts and music, and encodes an MP4 (vertical, square or landscape) plus a web copy, poster and looping preview. Use whenever the user wants a video, demo reel, promo, explainer or animation of a robot, robot arm, mobile robot, humanoid or any URDF model, or wants to inspect a URDF's joints and size.
  4. ---
  5. # robot-reel
  6. Pipeline: **URDF** -> joint motion over time (clamped to limits) -> **three.js** in headless Chrome (each frame a pure function of t) -> **Kokoro** voice and word timings -> **ffmpeg**. It animates the model; it is not a physics simulation and not a generative video model.
  7. Skill folder (written `$R` below): this folder. Every command is `$R/robot-reel <command> ...`; `$R/robot-reel help` lists them. `README.md` documents every field of the shot list and the brand file.
  8. ## Workflow
  9. 1. `$R/robot-reel check`: Python, Kokoro, ffmpeg, Playwright, a browser and WebGL. Fix anything it reports.
  10. 2. `$R/robot-reel new <dir>`: scaffold. Put the user's URDF and meshes in `<dir>/robot/` and set `"robot"` in `shots.json`. Xacro files must be expanded first (`xacro x.urdf.xacro > x.urdf`).
  11. 3. `$R/robot-reel inspect <dir>/robot/<file>.urdf`: read the joint names, types and limits, the link names, the size in metres and any missing or unsupported meshes (supported: STL, OBJ, DAE and primitives). Write the shot list only from these names.
  12. 4. Write `shots.json` with the user:
  13. - 4 to 8 shots, one idea each, 20 to 40 seconds in total. A `title` card first and an `end` card last.
  14. - One short spoken line per shot (`say`), 6 to 14 words.
  15. - Show what the line says: a close-up on the part it names, a `sweep` to show a joint's range, `drive` or `spin` for wheels, `look` for a head.
  16. - Put a callout on the part being named, appearing on the word that names it (`"at": "wheels,"`; punctuation and case do not matter). At most 2 or 3 per shot, 34 characters or fewer.
  17. - Only state facts that come from the URDF (joint counts, ranges, sizes) or from the user. Never invent specs, payloads, speeds or prices.
  18. - If the robot is not the user's own design, check that its model's licence allows a published video.
  19. 5. `$R/robot-reel lint <dir>`: fix every ERROR (unknown joints and links, values beyond limits, cue words never spoken, missing files, shots shorter than their voice, robot or labels out of frame, labels overlapping). Warnings about motions cut off at the end of a shot: shorten `over` or add `hold`.
  20. 6. `$R/robot-reel audio <dir>`, then lint again (now against the real voice timings).
  21. 7. `$R/robot-reel sheet <dir>` and **Read the PNG**. Check: robot fully in frame, close-ups on the right part, labels pointing at the right part and not covering it, captions readable, title text not on the robot. Use `stills <dir> shots <seconds...>` and Read them for moments inside a shot (mid-sweep, mid-drive). Fix camera `zoom`, `azimuth`, `elevation` or the poses and look again. Do not say it looks right without having viewed it.
  22. 8. `$R/robot-reel video <dir> --web` (or `build <dir>` for steps 5 to 8 at once). Rendering uses software WebGL when there is no GPU and is slow (roughly 1 to 4 frames a second per page); `--workers 2` keeps the machine usable.
  23. 9. Optional: `$R/robot-reel preview <dir> --from 5 --to 9` for a small silent WebP loop (`--gif` for GIF).
  24. ## Reporting back
  25. - Say plainly that the video is an animation of the model: no balance, collision, torque or speed checks, motions illustrative. Put this on the end card's `note` when the video is for the public.
  26. - You cannot hear the audio. Check it numerically instead (duration matches the timeline; loudness with `ffmpeg -i out/shots.mp4 -af volumedetect -f null -`) and say that you did.
  27. - Give the paths of the MP4, the web copy, the poster and the sheet you viewed.
  28. ## Changing a video
  29. - Camera, motion, callout or colour changes: no new audio needed; go straight to `sheet` and `video`.
  30. - Any change to `say`, `keys`, a callout's `at`, shot ids or order, `hold`, `duration`, `lead`, `pause`, `tail`, `fps`, `caption_words`, or the voice, speed, language, pronunciations or music in `brand.json`: run `audio` again (the renderer refuses an out-of-date voice track).
  31. - A robot from a ROS package (URDF in `urdf/`, meshes in `meshes/`): set `"package"` in the shot list to the package folder (or `inspect --package <dir>`). Meshes outside the URDF and package folders are refused on purpose.
  32. - Another format: `--format vertical` (or `square`) on `sheet` and `video`, or set `format` in `brand.json`.
README.md · README · 221 lines
  1. <p align="center"><img src="examples/nib/nib-preview.webp" width="480" height="270" alt="Nib, a small example robot, rolling forward with a label on its drive wheel"></p>
  2. # robot-reel
  3. [![test](https://github.com/VinVirtual/robot-reel/actions/workflows/test.yml/badge.svg)](https://github.com/VinVirtual/robot-reel/actions/workflows/test.yml) [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
  4. A voiced showcase video of a robot, made from its description file and a short shot list, on your own machine. No real robot and no camera are needed.
  5. You give it a **URDF** (the standard robot description file: links, joints, limits, shapes or meshes) and a **shot list** (what the voice says in each shot, how the camera moves, how the joints move, which parts get a label). robot-reel loads the robot, poses and animates its joints, moves a virtual camera around it in a lit studio, speaks the lines with a local text-to-speech model, and encodes an MP4 with word-by-word captions, labels and music.
  6. It is packaged as a [Claude Code](https://claude.com/claude-code) skill (`SKILL.md` tells the assistant how to use it) and also works by hand from the command line.
  7. Example (the robot is made up for this repository; it is not a real product): [`examples/nib/nib.mp4`](examples/nib/nib.mp4), 720p, about 29 seconds, with its [poster](examples/nib/nib.jpg) and [shot list](examples/nib/shots.json).
  8. ## How it works
  9. 1. **Load**: the URDF is parsed into links and joints with their limits. `inspect` prints them with the robot's size in metres.
  10. 2. **Animate**: the shot list becomes joint values over time: named poses, keyframes, and built-in motions (wave, look around, a sweep through a joint's full range, wheel spin, drive). Values are clamped to each joint's limits, and `lint` reports any shot that asks for more.
  11. 3. **Film**: three.js draws the robot in headless Chrome: a studio floor with a soft shadow and a fading grid, key, fill and rim light, and a camera that orbits, dollies, closes in on a named link, or looks from the top, side or front, with easing.
  12. 4. **Voice and finish**: Kokoro speaks each line locally; the word timings drive the captions and the moment each label appears (`"at": "wheels"`). ffmpeg encodes the MP4 with the voice, a generated beat and soft sound effects.
  13. Every frame is a pure function of its time `t`, so frames render in parallel and the same input always gives the same picture.
  14. ## Honest limits
  15. - **It is an animation of the model, not a physics simulation.** Nothing checks balance, collisions, torque, speed limits, contact or whether the robot could really do what the video shows. Joint limits from the URDF are the only rule enforced. Treat every motion as illustrative, and say so when you publish.
  16. - Parts can pass through each other if a shot list tells them to. Look at the review sheet.
  17. - **Mesh formats**: STL, OBJ and COLLADA (`.dae`) meshes, plus URDF boxes, cylinders and spheres. glTF, GLB and other formats are reported by `lint` and `inspect` and are not drawn. Image textures are not loaded (COLLADA files keep their material colours; STL and OBJ take the URDF material colour).
  18. - **Plain URDF only**: xacro files must be expanded first (`xacro robot.urdf.xacro > robot.urdf`). SDF and MJCF are not read. `floating` and `planar` joints are treated as fixed. `package://name/...` paths are looked up inside the URDF's folder, and inside the package folder when the shot list names one with `"package"` (or `inspect --package <dir>`).
  19. - **No generative video**: it does not invent footage, people or places. What you see is the robot model you supplied, in a plain studio.
  20. - Wheels roll by distance divided by radius and the base slides along the floor; there is no steering model or terrain.
  21. - Word timings are estimated from syllable counts inside each spoken phrase, so a label can appear a fraction of a second early or late in a long phrase.
  22. - The voice is Kokoro with its fixed set of voices; it does not clone voices. The music is a simple generated beat.
  23. - Rendering uses WebGL in headless Chrome. Without a graphics card Chrome uses its software renderer (SwiftShader), which works but is slow: about 1 to 4 frames per second per page on a desktop CPU.
  24. - **Tested on Linux only** (Ubuntu with Google Chrome).
  25. ## Files a robot description can reach
  26. A URDF from someone else is untrusted input, so robot-reel limits what it can do:
  27. - Meshes are read only from inside the URDF's folder, or the folder named by `"package"`, after following symbolic links, and only as `.stl`, `.obj` or `.dae`. Absolute paths, `file://` and other schemes, and paths that climb out with `..`, are refused; `lint` and `inspect` say which and why.
  28. - Fonts are read only from inside the project folder or the bundled fonts.
  29. - The page that draws frames talks to a server on 127.0.0.1 that serves only the engine and the files registered for this render. It answers only requests addressed to `127.0.0.1` or `localhost` on its own port. Every other request the page makes, such as a texture URL inside a COLLADA file, is blocked.
  30. - The voice track records everything it was made from (lines, key and cue words, timing, fps, caption grouping, voice settings in the brand), and the renderer refuses a voice track that no longer matches.
  31. ## Requirements
  32. | Needed | Why | Licence |
  33. |---|---|---|
  34. | Node.js 18 or newer | runs the command line and the renderer | MIT |
  35. | [playwright-core](https://www.npmjs.com/package/playwright-core) | drives the browser | Apache-2.0 |
  36. | Google Chrome, Chromium or Playwright's own Chromium, with WebGL 2 | draws the frames | Chrome: proprietary freeware. Chromium: BSD-3-Clause and others |
  37. | Python 3.10 to 3.13 | runs the voice step | PSF-2.0 |
  38. | [kokoro-onnx](https://github.com/thewh1teagle/kokoro-onnx) | text to speech | MIT |
  39. | Kokoro v1.0 model files (`kokoro-v1.0.onnx`, `voices-v1.0.bin`, about 340 MB) | the voice model | Apache-2.0 (see the notes) |
  40. | phonemizer and espeak-ng (installed with kokoro-onnx) | turn text into phonemes | GPL-3.0-or-later |
  41. | onnxruntime, numpy, soundfile | run the model, write audio | MIT, BSD-3-Clause, BSD-3-Clause |
  42. | ffmpeg with libx264, AAC and (for the preview) libwebp | encodes the video | LGPL or GPL depending on the build; the binary from the `imageio-ffmpeg` package (BSD-2-Clause wrapper) is a GPL build |
  43. None of these is included in this repository except the files listed under **Included**. You install them yourself, and their licences apply to your use of them. About 1 GB of disk and 4 GB of free memory are enough. No GPU is needed.
  44. ### Included
  45. - `vendor/three/`: [three.js](https://threejs.org) r170 (`three.module.min.js`) and six add-on files from its `examples/jsm` folder (STL, OBJ, COLLADA and TGA loaders, RoomEnvironment, RoundedBoxGeometry). **MIT**, Copyright 2010-2024 three.js authors; the licence is in `vendor/three/LICENSE`. One import path in `ColladaLoader.js` was changed to point at the file next to it.
  46. - `assets/fonts/Geist.ttf`: Geist, Copyright 2024 The Geist Project Authors, **SIL Open Font License 1.1** (as stated in the licence field inside the font file). The notice and licence are in `assets/fonts/OFL.txt`.
  47. - `templates/robot/nib.urdf`: the example robot, written for this repository from boxes, cylinders and spheres. MIT, like the rest of the code.
  48. ### Licence notes
  49. Checked on 21 November 2026 from each package's own licence file or package metadata. Check again before you rely on them.
  50. - **kokoro-onnx** 0.6.1 is MIT (its `LICENSE` file). **Kokoro-82M** (the model, by hexgrad) is tagged Apache-2.0 on its model card; no separate licence is given for the voice file `voices-v1.0.bin`, and this could not be verified further.
  51. - **phonemizer** 3.6.0 is GPL-3.0-or-later (package metadata) and **espeak-ng** is GPL-3.0-or-later. They run inside the Python process of the voice step. If you redistribute a bundle that contains them, read the GPL. This is not legal advice.
  52. - **ffmpeg** runs as a separate program; its licence depends on how your copy was built.
  53. - The **urdf-loader** npm package was considered and not used: its licence is Apache-2.0 (npm metadata), not MIT. robot-reel has its own small URDF reader in `engine/core/urdf.js`.
  54. - **Videos you make are yours.** Check the licence of any robot model, mesh, font or logo you add: many public robot descriptions do not allow redistribution, and some do not allow commercial use.
  55. ## Install
  56. ```bash
  57. git clone https://github.com/VinVirtual/robot-reel
  58. cd robot-reel
  59. # 1. Playwright (drives the browser) and a browser with WebGL
  60. npm i -g playwright-core
  61. # if Google Chrome or Chromium is not installed:
  62. npx playwright install chromium
  63. # 2. The voice: a Python environment with kokoro-onnx, and the model files
  64. python3 -m venv ~/kokoro/.venv
  65. ~/kokoro/.venv/bin/pip install kokoro-onnx soundfile numpy imageio-ffmpeg
  66. cd ~/kokoro
  67. curl -LO https://github.com/thewh1teagle/kokoro-onnx/releases/download/model-files-v1.0/kokoro-v1.0.onnx
  68. curl -LO https://github.com/thewh1teagle/kokoro-onnx/releases/download/model-files-v1.0/voices-v1.0.bin
  69. cd -
  70. # 3. Check
  71. ./robot-reel check
  72. ```
  73. To use it as a Claude Code skill, put this folder at `~/.claude/skills/robot-reel`.
  74. Where tools are found, and how to point elsewhere:
  75. | Variable | Default |
  76. |---|---|
  77. | `KOKORO_HOME` | `~/kokoro` (model files) |
  78. | `KOKORO_MODEL`, `KOKORO_VOICES` | the two model files in `KOKORO_HOME` |
  79. | `ROBOT_REEL_PYTHON` | `$KOKORO_HOME/.venv/bin/python`, else `python3` |
  80. | `FF` | `ffmpeg` on the PATH, else the one inside `imageio-ffmpeg` |
  81. | `PLAYWRIGHT_CORE` | `playwright-core` next to the skill, else from the global npm folder; never the current folder |
  82. | `ROBOT_REEL_CHROME` | installed Chrome, else Chromium, else Playwright's Chromium |
  83. ## Quick start
  84. ```bash
  85. ./robot-reel new my-video # shots.json, brand.json, robot/nib.urdf, fonts/
  86. ./robot-reel inspect my-video/robot/nib.urdf
  87. ./robot-reel build my-video # lint, voice, review sheet, video, web copy
  88. ```
  89. `build` writes `my-video/stills/shots-sheet.png` (one frame per shot) before the video. Look at it. Then play `my-video/out/shots.mp4`.
  90. For your own robot, copy its URDF and mesh folder into `robot/`, set `"robot"` in `shots.json`, run `inspect` to see the joint names and limits, and write the shots.
  91. ## Commands
  92. ```
  93. robot-reel check check the machine (Python, Kokoro, ffmpeg, Playwright, browser, WebGL)
  94. robot-reel new <dir> start a project (shots.json, brand.json, robot/ with an example URDF)
  95. robot-reel inspect <file.urdf> links, joints with limits, size in metres, missing meshes [--json]
  96. robot-reel lint <project> [name] check a shot list before rendering [--no-browser] [--strict] [--json]
  97. robot-reel audio <project> [name] voice, word timings, music and caption files
  98. robot-reel sheet <project> [name] one frame per shot in one PNG
  99. robot-reel stills <project> [name] 2 7.5 single frames at those seconds
  100. robot-reel video <project> [name] out/<name>.mp4 (+ -voiceonly.mp4, .vtt, .srt) [--web]
  101. robot-reel web <project> [name] out/web/<name>.mp4 (720p, faststart), .jpg poster, .vtt
  102. robot-reel preview <project> [name] out/web/<name>-preview.webp, a small silent loop [--gif]
  103. robot-reel build <project> [name] lint, audio, sheet, video and web copy in one go
  104. robot-reel test run the unit tests
  105. ```
  106. `name` is the shot list's file name without `.json` (default `shots`), so one project can hold several cuts. Options: `--format vertical|square|landscape`, `--no-captions`, `--workers N`, `--lossless`, `--quality`, `--web-size`, `--web-crf`, `--web-dir`, `--poster-at`, and for `preview` `--from`, `--to`, `--width`, `--fps`. Run `robot-reel help` for details.
  107. **lint** checks, before anything is rendered: joints and links that do not exist (with a "did you mean"), values beyond joint limits (including where a wave or keyframe track would carry a joint past one), words in `at` and `keys` that are never spoken, missing mesh, font and robot files, unsupported mesh formats, shots shorter than their voice line, motions that run past the end of their shot, and unknown fields. Then it draws each shot in the real renderer and reports a robot or link out of frame, labels off the frame, on the captions or on top of each other. Before the voice exists, timing is checked against an estimate; after `audio`, against the real voice.
  108. ## The shot list
  109. ```json
  110. {
  111. "robot": "robot/nib.urdf",
  112. "units": "deg",
  113. "poses": { "ready": { "shoulder_lift": 28, "elbow": 96, "wrist": -34 } },
  114. "start": "ready",
  115. "shots": [
  116. {
  117. "id": "wheels",
  118. "say": "It rolls on two drive wheels, with a caster at the back.",
  119. "camera": { "move": "side", "azimuth": 62, "elevation": 9, "zoom": 1.05 },
  120. "motion": [ { "do": "drive", "distance": 0.7, "wheels": ["wheel_left_joint", "wheel_right_joint"] } ],
  121. "callouts": [ { "link": "wheel_left", "text": "2 drive wheels", "at": "wheels," } ]
  122. }
  123. ]
  124. }
  125. ```
  126. **Top level**: `robot` (path of the URDF), `package` (the package folder for `package://` meshes, when it is not the URDF's own folder), `units` (`deg`, the default, or `rad`; sliding joints are always metres), `poses` (named `{ joint: value }` sets), `start` (pose at the first frame), `shots`, and optional `lead`, `pause`, `tail` (seconds before the first line, between shots, after the last), `fps`, `caption_words`, `captions` (false to hide), `poster` (seconds), `voice`, `speed`, `music`.
  127. **A shot**: `id` (letters, digits, `_` and `-` only; it becomes a file name), `say` (the voice line), `type` (`shot`, `title` or `end`; cards add `title`, and `subtitle` or `line`, and `note`), `keys` (spoken words to highlight in the caption), `pose` (a pose name or object to cut to), `motion`, `camera`, `callouts`, `hold` (seconds after the line), `duration` (a minimum length), `voice` and `speed` (for this line only). Every number must be written as a number: `"0.5"` in quotes is a lint error.
  128. **Motion** items, each with `at` (seconds into the shot, or a spoken word), `over` (seconds) and `ease`:
  129. | `do` | fields | what it does |
  130. |---|---|---|
  131. | `pose` | `to` (name or object) | eases the named joints to new values |
  132. | `keys` | `joint`, `keys` `[[seconds, value], ...]` | a keyframe track for one joint |
  133. | `wave` | `joint`, `amplitude`, `cycles` | swings about the current value and settles back |
  134. | `look` | `joint`, `amplitude`, `cycles` | the same, one slow swing by default (for a head) |
  135. | `sweep` | `joint`, `range` (0 to 1) | to one end of the joint's range, the other end, and back |
  136. | `spin` | `joint` or `joints`, `turns` | whole turns of a continuous joint |
  137. | `drive` | `wheels`, `distance` (m), `radius` | slides the base forward and rolls the wheels to match |
  138. Each shot starts where the previous one ended. Motions on the same joint chain: a later motion starts from wherever the earlier one has taken the joint.
  139. **Camera**: `move` is `orbit`, `dolly`, `closeup` (with `link`), `top`, `side`, `front` or `static`. Numbers: `azimuth` (degrees around the robot, 0 is its front, 90 its left side), `elevation` (degrees), `zoom` (1 fits the subject), `distance` (metres, instead of zoom), `lift` (metres). `from` and `to` give the numbers at the start and end of the shot, either as objects or as a single number (azimuth for orbit, side, front and static; zoom for dolly, closeup and top). Also `ease`, `drift` (degrees of slow sideways travel), `blend` (seconds to ease in from the previous shot's camera instead of cutting), `track` (false to stop a close-up following its link), `fov`, and `target` (`robot`, a link name, or `[x, y, z]`).
  140. Easing names: `linear`, `in`, `out`, `inOut` (default), `smooth`, `gentle`.
  141. **Callouts**: `link`, `text` (34 characters or fewer reads best), `at`, `side` (`left`, `right` or `auto`). A label sits beside its link, clear of the robot where there is room, joined by a leader line, and keeps its side for the whole shot.
  142. ## The brand file
  143. `brand.json` sets `format` (`landscape` 1920x1080, `vertical` 1080x1920, `square` 1080x1080), `colors` (`bg`, `bg2`, `grid`, `text`, `soft`, `accent`, `plate`, `plateText`, and `robot` for parts with no colour of their own), `fonts.display` and `fonts.body` (`family`, `file`, `weight`), `captions`, `voice`, `speed`, `lang`, `pronounce` (regex to spoken spelling) and `music` (`on`, `bpm`, `chords`, `volume`).
  144. ## Tests
  145. ```bash
  146. ./robot-reel test # or: npm test
  147. ```
  148. 117 unit tests with `node --test`: URDF parsing of the example robot and of malformed files, forward kinematics and rpy order, limit clamping and mimic chains, keyframe interpolation and easing, every built-in motion, camera paths (orbit, dolly, close-up tracking, top view, blends, floor), lint rules, callout placement, timelines, captions and the stale-voice check, mesh and font containment, the local file server's error paths, the voice step's id checks, and the browser launch retries, and that Python probes and Playwright never load code from the current folder. They do not need a browser or the voice model.
  149. ## Layout
  150. ```
  151. robot-reel the command line
  152. engine/core/ pure code shared by the command line and the page: URDF, kinematics, motion, camera, lint, layout
  153. engine/page/ the page that draws frames: three.js studio, robot builder, 2D overlay
  154. engine/lib/ Node side: finding tools, local server, rendering, ffmpeg, lint, inspect, check
  155. engine/gen_audio.py voice, word timings, music and sound effects
  156. templates/ what "new" copies: shots.json, brand.json, robot/nib.urdf
  157. examples/nib/ the example: shot list, brand, 720p video, poster, preview
  158. ```
  159. ## Credits
  160. The voice step (`engine/gen_audio.py`), browser launch, parallel frame capture, caption files and web export are adapted from [**reel-studio**](https://github.com/VinVirtual/reel-studio), a sister project by the same author under the MIT License.
  161. ## Licence
  162. MIT. See `LICENSE`. three.js and the Geist font keep their own licences, as above.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.