framefields

framefields 3

The engine your coding agent drives now has a 3D world, a path tracer, physics, on-device vision, cloud rendering and a layer you shade yourself.

29 releases236 commits17 Oct to 11 Nov 2026

See what's new

Playing: a Schwarzschild black hole, ray traced in one Layer.shader. From the film in examples/41_hawking_radiation.

New in 3.0

Write the pixel yourself.

Layer.shader is a layer drawn by your own WGSL fragment. Uniforms take numbers, signals or a function of the frame. It is an ordinary layer after that: animate it, put effects on it, use it as a matte.

shade.wgsl Running in your browser

This is the same contract the engine gives you: a shade(uv) function and a uniform block u. Change the code. A fragment that does not compile reports the error with line numbers counted in your own source, here and in the engine.

The hole evaporating. Mass and temperature are uniforms keyed on the timeline.
Particle pairs at the horizon, a second fragment under ordinary text layers.

2.3 to 2.15

A 3D engine moved in.

Landscapes, sculpted solids, layered materials, glass that bends the scene behind it, things that shatter, and a camera that can travel near the speed of light. All of it from TypeScript, in the same timeline as your type and footage.


						
  • Worlds Layer3D.terrain, sdf and scatter build landscapes, smooth-CSG sculptures and foliage. Any layer can texture a mesh.
  • Light Volumetric fog, rect lights, HDRI and EXR environments, screen-space reflections and diffuse GI.
  • Surfaces Clearcoat, sheen, anisotropy, iridescence and energy-conserving skin, read straight from glTF materials.
  • Characters Clip layers, two-bone IK, look-at, spring bones, joint drivers, named morphs and skinned crowds in one draw call.
  • Lenses Equirectangular 360° and fisheye cube cameras, per-object shutter motion blur, Doppler shift and beaming.
  • Footage in the scene Depth Anything lifts a clip into a relief the 3D camera can move around.

3.0.1

Light, traced.

Turn on pathTrace and the scene's 3D layers are path traced instead of rasterized. Glass bends what's behind it, reflections show what the camera can't see, shadows soften with distance, light bounces between surfaces, and a glowing mesh lights the room. Same lights, materials and tone mapping as before, only worked out properly.

Glass from glTF models, path traced: an iridescent lamp globe, glasses of flowers and a mosquito in amber, lit by a studio's window. Models from the Khronos glTF samples (Wayfair and Sketchfab, CC-BY 4.0; vase CC0), light from Poly Haven (CC0).
A skinned glTF character, a chrome ball and a neon ring that lights them both, with motion blur and bloom on top of the traced frame.
// trace the 3D layers; quality: "draft" while you iterate
Layer.environment({ hdri: "studio.hdr", pathTrace: true });
Layer.glb("vase.glb", { x: 960, y: 640, z: 0, scale: 1000 });
  • WebGPU compute A two-level BVH, refitted every frame for skinned and morphed meshes, traced in a compute shader on any GPU WebGPU runs on.
  • Light sampling Every light, the HDRI and glowing meshes are sampled directly and weighed against the surfaces, so small bright lights stay clean.
  • Same picture everywhere A render takes exactly its samples per pixel on any GPU, so split cloud renders join without seams. The preview fits your GPU instead.
  • Presets draft, standard, high (default) and an unfiltered reference.
  • Materials from other tools openPBR and parseMtlx bring OpenPBR, Standard Surface and MaterialX materials in by their own names.
  • Not traced yet Text on a 3D plane, toon shading and instanced crowds; the render names what it hit.

3.1

Sculpt in code.

Layer3D.clay is a sculpture written as moves, the way you'd work clay: add and carve with solids and brush strokes, pull with an elastic grab, swell a cheek, rough it into stone. Every pixel is worked out from the moves themselves, so it stays sharp however close the camera gets. When it's done, export it as glTF and keep going in Blender.

The bust being made, one move after another, from examples/45_sculpture: 1080p in about 0.2 seconds a frame on an M1 Pro.
// moves run in order; symmetry mirrors what you do at +x
Layer3D.clay({ symmetry: "x", ops: [
  { type: "sphere", center: [0, -70, 0], radius: 72 },
  { type: "stroke", path: [[40, -122, 10], [72, -160, 30], [86, -200, 72]], radius: 16 },
  { type: "sphere", center: [30, -74, -66], radius: 15, mode: "carve" },
  { type: "grab", center: [0, -14, -104], radius: 26, delta: [0, 16, -6] },
  { type: "detail", amplitude: 2.2, scale: 22, ridged: true },
]});
await comp.exportModel({ frame: 180, outputPath: "bust.glb" });
  • Solids and strokes Spheres, boxes, capsules, tori and brush strokes that add, carve or intersect, with smooth joins and their own colors.
  • Elastic brushes grab, twist and bulge move what's already sculpted as a soft solid would; inflate swells a region.
  • Detail that holds Stone, skin or hammered metal from detail, fading where it would be smaller than a pixel, so it never shimmers.
  • No polygon count Drawn per pixel, with shadows like any mesh. Path tracing, glass and physics use a mesh of it at the resolution you choose.
  • Any frame as glTF exportModel or render --model writes meshes, materials, textures, camera and lights for Blender, Unreal, Unity or the web.
  • In meters, y up 100 px to the meter, so what stands in the scene stands in the file.

2.3

Things fall, collide and scatter.

Rigid bodies simulate once, deterministically, and replay as signals: every body's impact, speed and pose can drive any prop or effect. Particles run in a compute shader and can be pushed around by a performer's silhouette.

Physics.world2d with comp.vision: the words are bodies, and the dancer's tracked silhouette knocks them and the confetti about.
Layer3D.swarm: the same dancer rebuilt from glowing shards that follow her pose, with the source clip inset.
// runs once while the film is built, replays as per-frame signals
const world = await Physics.world2d({ fps: 24, frames: 150 });
world.walls({ width: W, height: H });
world.body(card, { restitution: 0.35 });
world.simulate();
glow.animate(LayerAnimation.create().signal("opacity", world.impact));

2.3

Twenty-one looks, one line each.

Thirteen new stylize effects, and Styles presets that stack them into finished looks. Every loop below is the same four seconds, rendered for this page.

clip.withEffects(Styles.vhs())

Also in the pack: pixelArt, teletext, cartoon, crt, glitch, watercolor, kaleidoscope, opArt and film. And LayerAnimation.stepped(2) puts any layer on twos.

2.13 to 2.15

Type with every axis. Paths as drawn.

Text takes a variable font's axes by tag, measured and drawn at those axes in 2D and in 3D. Drag the sliders: the code is what you would write.

Layer.text("Variable", {
  fontFamily: "Archivo",
  fontWeight: 800,
  fontVariations: { wdth: 68 },
})
strokeDashArray: "12 8" renders, read by SVG's rules.
Several subpaths fill as contours with holes, not as one bridged polygon.
Keyframe a shape's d and paths morph, even with different point counts.

New in 3.0

A brief, not a blank page.

The style library is creative direction as data: six looks, six formats, six genres and five ways to make the pictures, plus presets that combine them. combineStyles turns a mix into one brief your agent follows.

look
format
genre
media

				
motion
launch-teaser
technical-explainer
brand-film
~/launch-film

				

2.4 to 3.0

Your agent reads the manual that matches.

The guides now ship inside the package, written for that release's API. An agent in your project reads the ones for the framefields it has installed, then starts, checks and renders without asking you a question.

  • framefields init writes a working project and never prompts or overwrites.
  • 26 components copy into your project with framefields add, fonts included.
  • framefields check --json returns schema, lint and timeline findings an agent can act on.
  • import { ai } from "framefields" reaches image, video, music and voice models on one key.

2.11 to 2.13

One film, many GPUs.

A long render splits into chunks that start on keyframes, renders on separate workers and stitches without re-encoding. From the CLI it is one flag.

4
npx framefields render film --cloud --workers 4
  • Named renders framefields.json names each cut once. The CLI, renderCloud and the dashboard pick it by name and write the same file anywhere.
  • Your bucket framefields assets keeps footage out of git on any S3-compatible bucket, pinned by SHA-256.
  • Plan first --plan prints workers, time and estimated cost before anything renders.

And the rest of the cut.

  1. 3.0

    Shape strokes draw their outer half instead of being cut at the layout box.

  2. 2.16

    The preview page embeds in an app and is driven over postMessage: seek, play, pause, build state.

  3. 2.15

    Glass refracts the 3D scene behind it, with IOR and thickness from the glTF file.

  4. 2.14

    Each 3D scene renders in isolation, so transitions blend two finished pictures. overflow defaults to visible, as in CSS.

  5. 2.13

    The preview mixes its soundtrack in the browser around the playhead, sample for sample the export's mix.

  6. 2.13

    Strokes draw in one call per path. Map coastlines and a hundred circles render about twice as fast.

  7. 2.11

    AudioSignal.pitch tracks fundamental frequency on the GPU, for engine RPM or a melody line.

  8. 2.11

    Text, shapes and SVGs stay sharp when a camera pushes in: leaves rasterize at their scale on the canvas, up to 4×.

  9. 2.9

    comp.vision tracks a subject from a point, a box or plain words with SAM 2.1 and SAM 3, on your own machine. ViTMatte keeps hair and motion blur as soft alpha.

  10. 2.7

    Time remapping for video and audio: ramps, holds, reverse, or a signal driving the clock.

  11. 2.6

    Text follows Unicode's emoji presentation rules, so ✓ and © draw from the text font.

  12. 2.4

    Branded unit types (Pixels, Frames, Degrees) catch mixed units at compile time.

  13. 2.4

    Render logs sized for an agent's context: about 15 lines whatever the film's length.

  14. 2.3

    Trails and Datamosh: echoes, light painting and pixels dragged along optical flow.

Read the full changelog. One change to know before upgrading: renders can differ in 3.0 where shape strokes used to be clipped.

Make something with it today.

With your coding agent

Works with Claude Code, Codex, Cursor and any agent that can run a shell. Paste one prompt and it installs framefields, reads the guides and renders a first film.

or start by hand

npx framefields init my-film

With the desktop app

No terminal. Say what you want, watch the preview come together beside the conversation, pin notes on frames, and export when it is right.

See the desktop app

Docs GitHub npm Discord