Ask for a film and it writes an animated three.js scene as native HTML — one file, opens in any browser. Not a video: no player, no build step, and the geometry is drawn live on every frame.
There is no input format — whatever your agent can already read is enough: a repo, a spec, a paper, a screenshot, a stack trace. mitate (見立て) is to see one thing as another: a codebase as a machine, a document as a scene.
An address you evaluate, not a cursor you advance: nothing ever asks what time it is, only what the scene looks like at this address. No simulation state, no wall clock, no random() at runtime. seekTo(8) after seekTo(2) equals seekTo(8) cold. One scene file is both the live HTML and the source of a frame-exact render — and the recorder can shoot frames out of order, because there is no order to be in. Why determinism comes first, and what it is first for, is one page.
An agent is handed the building blocks — geometry, materials, a cinematography solver, a character scaffold — and composes them. Nothing about a character or a shot is hardcoded; each is a point in a parameter space.
Give it whatever you have, ask for whatever you want — it can probably make it, and when it can't yet, you build on top until it can. The tooling tries to abstract this cleanly, and clean abstraction is hard-won here — the engine, its primitives, and the seams between them are the durable part. Models get better at wielding them, not past them; personalize freely on top.
Because the output is code rather than pixels, an agent can reshoot one shot without re-rendering the rest, and swap the entire look by changing one line. The film's own code diffs and versions like source — the shared kit inside each file is stamped from one canonical store, so a diff is the film changing, not boilerplate. It renders at any resolution from the same file, because there is nothing baked in. And determinism means a regression is byte-detectable — the same t either matches the last run or it does not.
This is three.js with no image textures — flat color, node math, GPU noise — so it is stylized by construction: it cannot be photoreal, and no frame of footage ever appears in a film. What that look carries is direction, not rendering: the same kit already does silent-comedy timing and invented creatures, and bake-time simulation is on the roadmap. It will not edit an existing video, a screen recording or a slide deck. The films are silent. Faces are not built yet. The character films spend 4 to 5 seconds compiling shaders on a first visit on capable hardware — slower devices, longer — and captions stop being legible below about 700px of frame width.
A tinkering idea, in the open because it is fun to see what it can do. The films on this page run 12 to 37 seconds, and that is a choice about this page, not a limit: each 3D one embeds its own copy of three.js, so a project site that shipped long films would be a giant cache of code for no reason. Nothing caps duration. A frame at t=18000 costs what a frame at t=1 costs, and the file is the same size either way, because the duration is a number in a table rather than anything accumulated. Longer films have been built; they just do not belong here. Characters are one skeleton family.
Every title below is one self-contained HTML page — zero fetched assets, and three.js embedded in the ones that are 3D. These run 12 to 37 seconds — a film lasts exactly as long as the beats written for it, and the 3D ones are short so the page stays light, since every one of those carries its own three.js. Length costs nothing at runtime. The thumbnails are poster frames rendered from the scenes; open a film and the scene itself runs. Each is tagged with the primitives an agent composed it from. This is what composes easily today — the roadmap is the rest of it, abstracted one primitive at a time.
Read the primitive chips on each film. Nothing there is bespoke: gait is one function that plants feet from distance travelled — biped and quadruped differ only by phase offset. A character is a point in proportion space plus a material choice, never a shipped mascot. A look is one object switched by one line. That is the whole bet — build primitives that generalize, and any register becomes cheap to shoot and re-shoot.
The skill ships the building blocks and the discipline. Any harness — Claude or otherwise — reads them and directs a film: it writes a beats table, scaffolds a scene, reviews it on three axes, passes an automated gate, and delivers. Expect iteration — a few look-and-edit rounds are the method, not a failure of it — and a film that needs a primitive that doesn't exist yet is how the library grows. Here is what it's handed.
A film is written as a short list of named moments — beats — each with a duration and an optional caption. The only place a timestamp exists: retiming one beat is one edit, and every caption and camera keyframe derives from it.
Every shape authored in code, zero fetched assets. Even physics is closed-form — a drop is y₀ − k·(t−t₀)², evaluated from t, never integrated.
Cel, subsurface, physical glass, driven through node slots. GPU-computed MaterialX noise gives surfaces detail with no image files.
A cinematographer's vocabulary — subject, size ladder, angle, lens, cut — compiled onto the camera per frame. Raw keyframes are gone on purpose.
One parametric skeleton family. A proportion vector plus a material choice returns a posable rig — two-bone IK, planted gait, neck and tail chains.
The whole look — palette, exposure, post, lens, cut pace, camera energy — is one object, switched by one line. A hex literal left in a material is a look hiding from the switch.
Always on, pass-through by default. Bloom and depth-of-field are STYLE flags; rack focus is two shots differing only in focus, joined by a blend.
Contact sheets, squint strips, motion profiles, and an automated gate. The lint can reject a scene; it can never approve one. Looking is the method.
Write the beats as text. Check meaning while it's still words — a beat you can't follow is a slideshow.
→Geometry, materials, characters, shots assembled into a self-contained HTML scene on the window contract.
→Composition (inside a frame), continuity (between frames), semantics (captions covered). Looking, not filenames.
→Determinism, a shipped-frame check, aspect containment. The automated floor before any full shoot.
→HTML, MP4, WebP, AVIF — chosen at spec time. Whatever ships, every format renders from the one scene file.
The lesson from every film is the same: don't copy a walk cycle per creature — parameterize the gait. One function plants feet from distance travelled; two legs and four legs are the same function with different phase offsets. The character scaffold ships anatomy; the scene ships character. That is what makes a new register cheap to generate, and cheap to re-shoot.
The scene is a pure function of t. Tooling talks only to a fixed window contract, never to scene internals. Hold those two, and one file is at once the live artifact, the render source — and, later, an interactive experience for free.
Every scene ends by exporting the same few names — this is the driver block from gearbox.html, abridged to its shape. Everything the recorder, the gate, and this page's own hero can do, they do through these. The names are permanent — every tool depends on them — but the list grows: FLASHES and SHOTS joined the day a check needed them. When a tool is tempted to parse a scene's internals, the contract is missing an export. And this page is itself a consumer: the hero at the top is driving gearbox through seekTo right now — view source and watch it.
The thing being built is an engine — primitives, and the abstractions that let you say what you mean instead of how to compute it. Every phase adds a declarative layer: you declare beats and never write timestamps, declare a shot and never write camera coordinates, declare a look as one object and never touch a material value. Films are how each layer gets proven, not the product. So every phase raises the ceiling for all registers at once, because it lands as a reusable primitive rather than a one-off asset. Since August a second track runs beside the phases — about the representation of the films themselves rather than a capability — and it advances without waiting on any phase gate; it sits at the end of this list because it is parallel, not next-in-line. Here is what exists and what comes next.
The node-stack templates, recorder, and instruments — gated green on both backends. Cel, subsurface, and glass material packs, verified under byte-determinism.
One parametric skeleton family with two-bone IK, distance-driven gait, neck and tail chains, and fur/fabric packs. A bear, a human, and an invented creature from one buildCharacter.
A build-time simulation step: simulate once, bake to keyframes, play back pure. Cloth, secondary motion, and soft contact — with runtime determinism fully intact. This is the declarative layer for interaction, the way lighting is one for illumination: declare mass and solidity, and let the system work out what happens when two things meet, instead of hand-tuning sine waves that approximate a swing. Opt-in and per-object, never a global mode — clipping through a wall as a joke is a legitimate authoring choice. Moved ahead of faces by choice.
A face morph basis, an expression library, hands, and hair. The bar: expressions carry the beat in the caption-covered pass — the words are not doing the work. Scaffolded as generalizable primitives, not per-character rigs.
Cutscene and meme film-language extensions; then an input driver over the unchanged kernel — the same characters, materials, and camera solver, now responding to events instead of a clock.
Where does data stop and code start? That boundary is now a recorded decision — data is what a tool can check without running the scene, and every place checking ends is a named, typed hole — and its first consequence has landed: the shared kit inside every film is stamped from one canonical store instead of being held byte-identical across nine files by discipline. Edit the store, regenerate every film; a drifted copy fails loudly against the source instead of outvoting it. And the static validator now reads that same store: the checker and the renderer run the same code, with a standing control that drives both against the review's divergence corpus — a new case becomes an arm, not a memory. Where agreement is unachievable (an input the checker cannot read), the arm pins honesty instead: the checker must declare its stand-in rather than go quietly green. And the two open bags — the look and the config — now police their own keys: a declared key that nothing reads draws a warning naming the nearest real one, with the vocabulary derived from the kit's actual reads rather than kept as a list. Its first run found a dead key in a shipped template. And a subject's framed extent now derives from construction instead of being declared beside it — a hand adjustment rides as a named term, the checker warns on a bare number, and its first run caught the base template framing its own demo a quarter too small. Next on this track: making the promotion counting cheap enough that its triggers actually fire.
mitate installs as a Claude Code plugin. Point it at any input, in any register, and it directs — spec, scaffold, review, gate, deliver — then re-directs until the film is yours.
Where it is pointed: a 200-page terms of service, explained by a figure who keeps falling over. That one is reachable rather than shipped — expect to iterate, and to build a primitive or two on the way. The films above are what today's primitives compose without a fight.
$ /plugin marketplace add fblissjr/mitate $ /plugin install mitate@mitate