by staryone
Video as code: canvas scenes rendered with WebCodecs in headless Chrome, a review viewer, and agent skills that build the video from your references.
Available after the catalog security scan passes.
⚠️ Third-Party Software Notice
This skill is third-party open-source software developed and hosted independently on GitHub. SkillsLLM is an informational directory and does not control or maintain the underlying repository.
Any security checks, ratings, or warnings displayed by SkillsLLM are automated and limited in scope. They do not constitute a security certification or guarantee that the software is safe, error-free, or free from malicious code, vulnerabilities, compromised dependencies, or prompt-injection risks.
Review the source code, permissions, dependencies, and configuration before installing or running any third-party skill. Use is at your own risk. To the maximum extent permitted by applicable law, SkillsLLM is not liable for losses arising from third-party software.
The deep catalog scan for this skill is still queued. Run an instant dependency check now instead.
# Add to your Claude Code skills
git clone https://github.com/staryone/motlabGuides for using ai agents skills like motlab.
See how motlab compares with popular alternatives.
A video engine where every scene is code, and an agent skill that writes the scenes for you.
npm install -g @motlab/cli && npx @motlab/cli setup
Demo · Install · Quick start · Speed · How it works · Docs · FAQ · Roadmap
Every scene is a canvas page with one function, renderAt(t), that draws the frame at time t. motlab plays the pages in a web viewer where you step through them frame by frame, and renders them to MP4 in headless Chrome. You hand your agent a folder of references (logos, screenshots, footage, fonts, music, voice) and a direction, and it builds every scene, opens the viewer and revises from your notes. No AI image or video model is involved.
The ad above (19 seconds, 7 scenes) was made with motlab and its skill, reviewed in the viewer and exported at 4K. The preview is silent; watch it with sound.
selection.json and works through them by number.motlab-assets, builds reusable asset kits the same way: icons, illustrations, 2D characters with a rig, transitions, 3D objects and textures, rendered to transparent PNG plus SVG, or GLB, FBX and OBJ with PBR textures. Every video that uses the kit shares one look.Two minutes in English, made with motlab too: the install, the brief to the agent, the build, playing it in the viewer, notes on frames, versions, the revision and the export.
https://github.com/user-attachments/assets/522d1db2-a0bd-43bd-84b7-9f071f224854
You need Node 24 or newer, Google Chrome or Chromium, and ffmpeg with ffprobe on PATH. Python 3 is optional and only used by the skills' helper scripts. Blender is optional too, for the asset skill's main 3D path.
npm install -g @motlab/cli
npx @motlab/cli setup
npm installs the engine. Setup copies both skills to your agent's skill folder, checks the machine, and makes sure the motlab command works: where npm's folder is not on PATH (nvm for Windows), it adds the command to ~/.local/bin. After that it is motlab everywhere, and motlab doctor checks the machine again at any time.
Setup installs the skills for Claude Code unless you name another agent:
| Your agent | Setup command |
|---|---|
| Claude Code | npx @motlab/cli setup |
| Codex, Cursor, OpenCode, GitHub Copilot, Gemini CLI, Amp, Windsurf | npx @motlab/cli setup --skill agents |
| Antigravity (App and CLI) | npx @motlab/cli setup --skill antigravity |
| Several of them | npx @motlab/cli setup --skill claude,agents,antigravity |
| Any other agent | npx @motlab/cli setup --skill-dir <its skill folder> |
Running it again for another agent adds the skills there too. --dry-run shows every step first, and --link links the skills instead of copying them. Start a new agent session afterwards so it loads them.
git clone https://github.com/staryone/motlab.git
cd motlab
node install.js
The installer runs npm ci, puts a motlab command in ~/.local/bin and copies the skills. It takes the same options, plus --skill none for no skills.
Later, motlab update tells you when a new version is out and how to get it (from a clone it pulls it from GitHub itself), and motlab uninstall removes the skills and motlab's own files again.
Install guide and per-OS notes · Instructions for an agent doing the install
Run motlab edit example in a folder that holds the sample project. In a clone that is the clone itself; after an npm install, copy example/ out of the engine folder that motlab --help prints. It starts the viewer in the background, opens the sample project and prints its address, http://127.0.0.1:4173/p/example/. Space plays, the arrow keys on the timeline step one frame, Ctrl+scroll zooms the timeline, and a drag on the preview marks a box.
To make your own video, put your references in a folder and ask your agent, for example:
Make a 20 second portrait promo for my app with motlab. The references are in ./promo-refs.
The agent plans the shots, writes the scenes and starts the viewer. Click the frame you mean, or drag a box over the part and type a note right on it. Notes can be left all over the video and handed over at once, so "this one" or "all the notes" is enough.
When you are happy, press Export in the top right. The video goes to the project's out/ folder.
The viewer keeps running in the background for every project: motlab stop ends it, motlab restart starts it again, and motlab start starts it without opening a project. Its text is in English or Indonesian, following your browser, and the project menu switches it. You can also render from the command line:
motlab render example --scale 1
The same scene (a moving gradient, 160 animated cards with numbers, text) at 1080p, 300 frames, rendered by three tools on one laptop (Ryzen 7 5800H, RTX 3060 Laptop, Windows 11) with the same Chrome:
| Tool | Render time | Frames per second | Compared with motlab |
|---|---|---|---|
| motlab | 9.5 s (--encoder sw), 12.6 s (default) |
31.5, 23.7 | |
| HyperFrames 0.9.52, fastest setting (1 worker) | 27.2 s | 11.0 | 2.2 to 2.9 times as long |
| Remotion 4.0.543, fastest setting (concurrency 1) | 30.7 s | 9.8 | 2.4 to 3.2 times as long |
Time is the whole command, the median of three runs. At 4K the same scene took motlab 13.1 to 19.4 s and the fastest of the other two 48.9 s.
Remotion and HyperFrames drew on the laptop's integrated Radeon. motlab on the same Radeon took 8.0 to 12.0 s at 1080p and 13.2 to 22.5 s at 4K. With Chrome drawing in software instead of on a GPU, motlab was still the fastest at 1080p (19.2 s against 28.3 s for HyperFrames), but at 4K HyperFrames was faster (43.4 s against 60.7 s).
This is one scene on one machine; macOS and Linux were not measured. The other settings, quality (SSIM) and file sizes are in the benchmark, and bench/ runs it again.
project.json that lists scene pages and audio files.<canvas id="c">, window.renderAt(t), window.TOTAL and window.ready. Everything visible is a function of time, so the preview, the stills and the render draw the same frames.motlab start, or motlab edit to open a project in it) shows the real pages in iframes with their audio through WebAudio, and saves your clicks and notes to selection.json.motlab render opens headless Chrome per scene and encodes the frames with VideoEncoder inside the page. ffmpeg only copies streams, joins the parts, sets the colour tags and adds the audio.project.json + scene pages (canvas, renderAt(t)) + audio files
|
+-- motlab edit viewer: the real pages in iframes, WebAudio audio, selection.json
+-- motlab render headless Chrome per scene -> VideoEncoder in the page -> MP4 parts
-> ffmpeg -c copy: join, colour tags, audio -> out/<name>.mp4
Footage is decoded inside the page with Mediabunny, so a scene can cut and trim video files and draw over them. DOM-based engines take a screenshot of every frame and pipe the images to ffmpeg; encoding inside the page skips that, which is where the gap in Speed comes from. The encoder rules and the measured quirks are in rendering.
| Need | Read |
|---|---|
| Install, update, per-OS notes | Install, Agent install |
| Projects, scenes, audio and footage | Projects |
The viewer, keys and selection.json |
Viewer |
| Commands, options and the page contract | Command line |
| How a render works, encoders, measurements, quirks | Rendering |
| What the skill does and its references | SKILL.md, skill references |
| Asset kits: tokens, 2D, 3D | motlab-assets SKILL.md, its references |
| The viewer's visual design | DESIGN.md |
| What is not built or not tested yet | [Roa |
motlab is an open-source ai agents skill for AI coding assistants such as Claude Code, Codex CLI, and ChatGPT, built by staryone. Video as code: canvas scenes rendered with WebCodecs in headless Chrome, a review viewer, and agent skills that build the video from your references. It has 88 GitHub stars.
motlab's catalog security scan is still queued. You can run an instant dependency and prompt-injection check now with the "Scan for vulnerabilities" button above.
Clone the repository with "git clone https://github.com/staryone/motlab" and add it to your Claude Code skills directory (see the Installation section above).
motlab is primarily written in JavaScript. It is open-source under staryone on GitHub, so you can review or fork the full source.
Yes. SkillsLLM lists many other AI Agents skills you can browse and compare side by side. Open the AI Agents category from the badge at the top of this page, or use the Related Skills and comparison links further down to weigh motlab against similar tools.
No comments yet. Be the first to share your thoughts!