Skip to content

armgit / 67.js

Public Imported from GitHub
0

3D engine that AI agents drive

175 KB
Raw Blame

Changelog

0.19.0

  • scene_review, scene_render_status and scene_render_result return only what an agent acts on by default; response_format: "detailed" keeps the full diagnostics, digests and metrics, and scene_capabilities takes concise to drop the field notes of a topic (#656).
  • scene_capabilities topic examples (and examples.<tool>) serves one valid call each for scene_create, scene_apply, scene_create_asset and scene_render_submit, with no growth of any tool schema (#657)
  • MCP: one server holds up to 4 open scenes under a 96 MiB geometry cap; the least recently used scene is evicted with a clear error. sessionId (returned by scene_create) picks the scene on every tool, and a call without it uses the last used scene. Each scene keeps 16 checkpoints, oldest evicted first (evictedCheckpointIds), and a render job stays tied to its scene (#658).
  • Motion drivers read custom properties on nodes and bones (motion.properties), distance and rotation difference variables, and can drive lights and shape keys (#694)
  • Mesh particle emitters take from: "edges", with an optional group and sharpAngle, so sparks spread along a rim by edge length (#695)
  • Mesh particle emitters take a vertex group (emitter.group) that weights surface and vertex emission, so sparks come off a painted rim (#695)
  • A cloth sheet with selfCollision: true now reads its own thickness as the contact radius (never past half the shortest edge), so a flag dropped to the floor lies as a thin crumpled layer. Behaviour change: a sheet that sets both selfCollision: true and thickness used to ignore the thickness (radius 0.9 of half the shortest edge) and now keeps layers 2 x thickness apart, so its baked frames differ; pass selfCollision: { radius } to keep a fixed radius. Sheets that set no thickness keep the old radius (#696)
  • A cloth sheet takes softBody (shape matching and pressure on a closed mesh), selfCollision and a stiffnessGroup vertex group, all baked and seekable (#696)
  • Field expressions read face area, edge angle, island index and neighbour counts, and accumulate, statistic, blur, sample index and rank over a whole mesh domain (#699)
  • A recipe curve takes grow, morph targets of the curve grown step by step, so a motion morph track grows a vine and seeking equals playing (#701)
  • mesh_edit gains unsubdivide and circularize, and poke, dual, tris to quads and symmetrize now have Blender golden cases (#703).
  • effects.composite keys a green screen (chroma) or a luma range out of the frame and draws it over a colour or gradient background, with the same mask as the other post steps (part of #707)
  • Post steps take a mask by part names or a depth range, and effects.stylize adds sharpen, kuwahara, posterize and pixelate filters (part of #707)
  • Mesh edits gain geometry masks: vertex_group measure curvature, edge or occlusion, and vertex_color gradients along a group, so a mesh with no UVs can carry edge wear and dirt (#708)
  • Materials gain wear: a vertex group blends the material from paint to bare metal per pixel and a second group adds dirt, so a mesh with no UVs shows metal on its edges and dirt in its cavities (#708)
  • Material graphs get brick, whiteNoise, coord and mapping nodes, so a procedural material works on a mesh without UVs (#708)
  • Blended and transmissive parts cast sun shadows weighted by opacity and tinted by colour, so stained glass, curtains and leaf canopies throw coloured and partial shadows; castShadow: false turns it off (#709)
  • environment.localVolumes adds up to 8 box or sphere volumes that absorb and emit light, in the rasterizer and the CPU path tracer (#710)
  • A mesh boolean cutter can be { "geometry": "<id>" }, another recipe geometry, so cuts form a bounded DAG with cycle and missing-ID errors (#730)
  • Render jobs take a wireframe pass that draws polygon edges over the shaded surface and colours boundary, non-manifold, flipped and degenerate edges for visual review (#732)
  • exportObj (OBJ with MTL text) and exportStl (binary STL) in the new addons/export-mesh entry write the same parts as exportGlb, in world space, with deterministic bytes (#747)
  • The jolt adapter builds convexHull colliders from the flat xyz point array and frees its world when setup throws.
  • 67js/addons/physics-jolt adds joltAdapter, a second engine for the live physics runtime built on the optional jolt-physics package: the same contact and sensor events as Rapier on the same scene, queries, kinematic control and force fields, with recorded 500-box step times for both engines (part of #771)
  • 67js/addons/physics-runtime adds createPhysicsSystem, live physics as a runtime system over an engine adapter (Rapier first): stepped in fixedUpdate, contact and sensor events, kinematic control, ray, shape-cast and overlap queries, and interpolated part matrices (part of #771)
  • createCameraClip treats a ground function that returns a non-finite height as ground height 0, so the camera still stays above the floor instead of clipping being switched off (#772).
  • 67js/addons/player adds vehicle and free-flight controllers, orbit, chase and side-scroller camera rigs, createCameraClip (camera pull-in against walls and ground), and a registry (registerController, registerCameraRig, replaceController, replaceCameraRig) for custom kinds and runtime swaps (#772)
  • Fix: the vehicle and flight controllers ignore a zero-length step, so the runtime's first variable-mode tick no longer turns their speed and velocity into NaN.
  • 67js/addons/player adds a character controller (walk, run, jump, kinematic collide-and-slide on a ground plane, heightfield or boxes, with a mover seam for physics) and swappable follow, first-person and top-down camera rigs as runtime systems (#772)
  • 67js/addons/input adds touchSource (virtual sticks, tap, swipe, pinch), deviceMotionSource, axis smoothing, and recordInput with replaySource so one demo runs from keyboard, gamepad, touch or a replay (#773)
  • 67js/addons/input adds createInput, an open input layer: sources register, named actions and axes with rebinding and dead zones, keyboard, mouse and gamepad sources, and per-fixed-step sampling as a runtime system (#773)
  • Animation graph: blended clips now end with their own shares in poseLayers() (the chain of lerp factors ran in the wrong order, so a walk to run blend played as full run); planted feet no longer slide in a blend space (#774)
  • Breaking for tuned graphs: a layer with two or more active slots (blend space or crossfade) now gives a different pose than before, because the old mix was wrong. Graphs tuned around the old output need a fresh look (#774)
  • createPathFollower walks an NPC along a navmesh route through the animation graph, blending idle, walk and run by speed and moving by root motion (#774)
  • 67js/addons/animation-graph adds createAnimationGraph, a live animation state graph: states with clips or 1D and 2D blend spaces, parameter transitions with crossfades, masked layers, deterministic fixed steps, a runtime system and pose layers for createSkeletonPose (#774)
  • 67js/addons/animation-graph adds root motion (rootMotion option, graph.rootMotion, extractRootMotion; the player controller takes it through a new rootMotion option and state.intentSpeed), interruptible transitions (interrupt: true) and the IK hooks createFootPlacement and createLookAt (#774)
  • 67js/addons/audio adds createAudio, spatial audio for live games on Web Audio: sounds on nodes with a listener on the camera, distance falloff and optional occlusion, triggers from input actions, physics contacts and animation markers, buses with a limiter, and a swappable backend (#775)
  • 67js/addons/streaming evicts lowest asset priority first (new evictionOrder: "distance" opts in to farthest-first within a priority; the default stays least recently used) and adds createWorkerLoader to decode assets in a worker (part of #776)
  • 67js/addons/streaming adds createStreaming, a runtime system that loads assets on demand by distance from a focus point or by game request, with a loader plugin registry (GLB first), a byte budget with least-recently-used eviction, level of detail switching with hysteresis and a loading state game code can read (part of #776)
  • MCP can attach a playable game to a scene (set-game, topic game in scene_capabilities) and scene_export_web writes it as a static web build; 67js/addons/game plays it in a page (#777)
  • 67js/addons/game-rules adds createGameRules, a runtime system that plays a bounded JSON rule document of variables, zone, contact, input, timer and variable triggers and actions, with a deterministic event log (#777)
  • Make the reference netcode relay survive an oversize frame or a socket error instead of crashing, so one bad client cannot drop every player (#778)
  • Add createBroadcastChannelTransport to 67js/addons/netcode, so tabs of one browser play together with no server, with a two-player sample page, a reference WebSocket relay (scripts/netcode-relay.mjs) and a headless Chrome test that plays two pages over both transports with 50 ms injected latency (#778)
  • Cut the netcode sample's lag with 50 ms of injected latency to about 95 ms each way (a snapshot every tick, a 40 ms interpolation delay), keep withInjectedLatency stats live, close the transport on pagehide, and make createBroadcastChannelTransport forget peers silent for peerTimeoutMilliseconds (#778)
  • 67js/addons/netcode adds createNetcode, a runtime system for multiplayer state sync: server or host authority, a transport plugin interface with an in-memory loopback (seeded latency, jitter and loss) and a WebSocket wrapper, bounded delta snapshots with quantisation, client prediction with reconciliation and remote interpolation (first slice of #778)
  • replaceParts(parts, { retainedUnchanged: true }) groups only the parts appended since the last call when a world grows by whole geometries, so loading a large world in slices no longer regroups the whole prefix on every call; a floor that shares a geometry with a world part still groups with it (#779)
  • A renderer built with deferProgramLink: true links its shaders without freezing the page: await renderer.programsReady(); shaderFeatureRepresentatives(parts) picks the few parts that compile the program a whole scene needs, and groupParts builds each material key once; await renderer.prepareFrame(frame) then draws the first frame while the canvas is hidden without blocking on the post, liquid, occlusion and reversed-depth programs a first draw links (#779)
  • loadGltf copies accessors and converts geometry in slices of about 8 ms, and loadHdri decodes a Radiance map a row at a time with a yield between slices, so a large model or sky no longer blocks the page in one piece; the sync readAccessor and parseRadianceHdr stay, and the output is byte for byte the same (#779)
  • The home page opens on the five-world loop (container port, data center, chip fab, warehouse, dark store) instead of the airport ramp: scene tabs, the credits of the playing world, a poster for reduced motion and for the first paint, and the first world downloads after the poster; the airport hero code and its styles are gone, and hero-loop.html stays as the standalone page (#780)
  • Fix the MCP recipe schema refusing the curve fields from #701: scene_create and scene_apply add-geometry now take kind, weights, splines (up to 64), shape, trim and grow on a curve, and points is optional when shape or splines is given (#801)
  • environment.localVolumes with shape: "mesh" and fit: "mesh" now draws in the rasterizer: a mesh pass sums the length of each pixel's ray inside the closed part, exact for any number of shells, and the CPU path tracer and the rasterizer agree within 0.03 on the L-room test (#807)
  • environment.localVolumes takes shape: "mesh" with a part: the part's oriented bounds in the rasterizer and the CPU path tracer, or its closed mesh (fit: "mesh") in the CPU path tracer (#807)
  • Local volumes with noiseAmount now draw the same noise field in the CPU path tracer as in the rasterizer, whose noise moved to a hash that rounds the same on every GPU; the WebGL, WebGPU and progressive tracers still refuse local volumes, with a test each (#808)
  • The bake report names the environment.localVolumes the lightmap bake leaves out (skippedLocalVolumes and a warnings line), and the volumes guide states that a volume emission does not light baked surfaces (#809).
  • Path tracer: a texture with no wrap mode now repeats, as the rasteriser and glTF draw it, so box-projected pattern walls such as the brick room keep their bricks instead of stretching the edge row (#813)
  • Path tracer: lightSelection: "tree" (and auto past 8 lights) now draws only the lights a linked part can see, uniformly among them, instead of walking a tree that counts every light, on the CPU, WebGL2 and WebGPU tracers (#814)
  • A motion track { "kind": "geometry", "id": "sea", "property": "oceanTime" } drives the time of the ocean nodes in a mesh stack, so one video job or timeline renders moving waves (#817)
  • Fix mesh edits such as mesh_stack failing with "render vertices exceed maxVertices across the scene" after a few re-evaluations of a large mesh: the oldest undo revisions are released one at a time before the budget refuses and the answer carries an undoNote with the count, and a scene that is really over the limit is still rejected (#818)
  • The water tag reads the sea's foam as lace (a bright core that breaks into veins, soft and antialiased edges), mirrors the sky with a fresnel term over a deep blue-green body, breaks the sun glint into facets with eight wind ripple bands with warped phases, and an ocean mesh smooths over 180 degrees by default; the physical sky draws its sun as a round disc on a 1024 by 512 map and fades the ground into haze over the first 7 degrees below the horizon, so a finite sea ends in haze, not a tan band (#819)
  • The coplanar search no longer throws "reading 'push'" for a touching pair whose shared box overflows to Infinity (a second route to a NaN priority bin, after non-finite bounds).
  • The coplanar diagnostics no longer throw "Cannot read properties of undefined (reading 'push')" mid-render when parts with non-finite bounds (a NaN vertex, an overflowed pose) share a plane; such parts are left out of the search (#839).
  • NURBS splines take order, knots and knotMode, and meshEdgesToSplines turns mesh edge loops and chains into curve splines (#841)
  • Motion drivers can now set the camera eye, target, fov and roll after the camera tracks, and a constraint influence expression can read custom properties, so one property can dolly the camera or fade a constraint in and out (#842)
  • A jelly softBody takes bounce (0 to 1, default 0): the share of its landing speed the body keeps when it turns around, so a jelly cube rebounds 0.07 m at 0, 0.15 m at 0.5 and 0.47 m at 1 from a 1.95 m drop; softness comes from the existing shape and stiffness (#852)
  • A material graph has an image node that reads a catalog image with the graph's coordinates and mapping (#860)
  • The first path traced draw of a page on the WebGL2 backend builds its kernel faster, because the emitter loop now holds one copy of the shadow ray, with the same pixels (53 of 54 test renders byte-identical, one sun-and-sky scene off by 1/255 in one pixel): lit-interior went from 108 s (one run) to 27 to 47 s over three runs on a loaded RTX 3060, and the old and new kernels compiled side by side took 36 and 7.8 s, 23 and 6.5 s (#861)
  • mesh_edit gains split_edges, delete_loose and flatten; unsubdivide, circularize and extrude_vertices (not representable: a mesh has no loose edge) stay open on #703 (#703).

0.18.0

  • Clip layers on an imported asset take a strip with start, scale, repeat, blend in and out, extend and blend mode, so a walk repeated three times can crossfade into an idle (#693)
  • Particle emitters take points from a mesh surface (weighted by area), its vertices or its closed volume, push them along the normal, and draw each particle as one of up to 8 listed nodes with a random or surface-aligned rotation (#695)
  • scene_apply takes bake-motion: it samples nodes over a range into keyframe tracks (tracks, IK, constraints, drivers, ragdoll and rigid bodies), optionally drops keys within a position and angle tolerance, and removes the sources it replaced, so the motion exports as a clip (#697)
  • sdf geometry meshes a tree of sphere, box, round box, capsule, cylinder and torus shapes with union, subtract, intersect, smooth blends and offset by surface nets, so blobby bodies and rounded joins need no hand modeling (#700)
  • curve geometry takes kind poly or nurbs, several splines, arc, spiral and star shapes and a trim, so rails, ropes and a growing vine need no hand-placed points (#701)
  • uv_project (cube, cylinder, sphere) and uv_pack mesh edits write and pack UVs with one texel density (#702)
  • mesh_edit gains poke, dual, tris_to_quads, symmetrize, scale_elements and extrude_edges (#703)
  • Add a build mesh modifier that reveals faces over start and length frames in index, seeded random or axis order, with reverse (#704).
  • scene_restore takes revision to undo the last few scene_apply edits in one call, with no checkpoint made first (#744)
  • Docs: add an FAQ page for the questions from the launch: three.js, size and speed, tokens, what the agent sees, undo and diffs (#745).
  • Set SIXTYSEVENJS_MCP_LOG=<file> to log each MCP tool call (tool, duration, ok, result size, never arguments), and run scripts/summarize-mcp-log.mjs for calls, error rate and median duration per tool (#746)
  • Depth precision by default (#751, phase 1 of 2): the colour pass draws with reversed-Z and a 32-bit float depth buffer wherever EXT_clip_control exists, at any far / near ratio, from the first frame; the 16-bit depth buffer is gone; without the extension the depth buffer is 24-bit and the near plane fits the visible bounds when the camera left near unset; reversedDepth: false opts out; installDepthPrecision, hasFarOverlap and requestReversedDepth are removed (use installCoplanarDiagnostics for the warning); bench/flicker/index.html is a viewer with a flicker probe
  • Flush faces stop flickering by default (#751, phase 2, step 1 of 2): faces that lie on one plane or a few millimetres apart, inside one mesh or across parts, are ranked per triangle and drawn with a small view-space depth bias, so the face in front wins at every distance and on every depth format; agent scenes do it unless environment.resolveCoplanar is false, a renderer does it with resolveCoplanar: resolveFlushParts; decal and depthLayer use the same bias; what cannot be ranked (more than 15 faces stacked on one plane, double-sided faces a gap apart) comes back as a coplanar-overlap warning with a reason; coplanarLayers, resolveCoplanarParts and EXACT_FLUSH_DISTANCE are removed; bench/flicker has trap scenes (?trap=, probe.mjs --traps)
  • Hidden flush faces are cut away (#751, phase 2, step 2 of 2): where an opaque face covers another on exactly the same plane (1 cm2 or more), the covered part is cut out of the copy the hidden face draws with, every vertex array interpolated, so a stack of any depth on one plane stops flickering and no longer reports rank-overflow; parts and their geometry stay as they are (flushOrderOf(part).geometry holds the cut copy), instances of one geometry share a cut, and the path tracer traces the cut geometry; a face under a blended or masked face, or a double-sided face under a one-sided one, is still ranked; bench/flicker gains the plaque-closeup-0.5m trap with an open-pixel count
  • Near-flush faces are cut too (#751): an opaque face in front of another by at most a thousandth of the side of their shared area (from 1 mm to 1 cm) cuts the face behind it, as a flush face does, instead of taking a rank; the Melbourne city model, whose stacked blocks nest facades 5 to 17 mm apart up to 17 deep, now reports no rank-overflow
  • scene_inspect and scene_capabilities take the inputs Haiku sent in the bench: short mesh edit branch names (meshEdit.inset), dotted fields (environment.spotLights), near topic names (uvs, scene.terrain), source nodes without a mesh of their own, includeBounds with kind hierarchy; an unwalkable path start names the nearest walkable point (#761)
  • scene_inspect with a node ID lists the parts below it and tags each with fromNode; a node with no part below it, such as a skeleton joint, returns its transform (parent, joint flag, local translation, rotation and scale, rest world position) instead of an error (#761)
  • 67js/addons/runtime adds createRuntime, a live game loop with fixed, variable or interpolated steps, ordered pluggable systems, pause on a hidden tab and a frame-time readout (#770)

0.17.0

  • bake.gridFog: the sun the fog scatters is dimmed by the fog between it and the sun (#543)
  • bake.gridFog: true (with irradianceGrid) lets the irradiance grid scatter in the scene's volume fog, off by default, for sunlit closed rooms with fog (#543)
  • An irradiance grid bake runs on the kernel worker with its 90 s limit instead of the page's 20 s, so 8 grid bounces fit a hall like temple-hall (#543)
  • Volume fog: opt-in scatterOctaves, multiScatter, multiExtinction, multiAnisotropy, keyTransmittance and surfaceTransmittance approximate multiple scattering of the sun in the haze and dim the sun by the haze between it and a point or surface. Off by default; the scenes without them render the same (#543)
  • The publish workflow waits up to five minutes for the registry to serve a new version instead of two. The 0.16.0 publish succeeded, but the registry took longer than two minutes, so the check failed and skipped the release page.
  • applyAnimation(time, clip, { checks: false }) and renderer.updateParts(parts, { checks: false }) skip the per-frame pose checks for clips you trust, and frames on the same clip no longer reset and snapshot every node. Eight animated characters: update CPU 1.6 ms to 1.3 ms with checks, 0.9 ms without.
  • Skinned character frames cost less CPU: palette math reads joint matrices in place and a normal pose allocates nothing, so eight animated characters update about 0.1 ms faster (#572)
  • Animating an imported glTF character costs about a third of the CPU it did: applyAnimation prepares the pose once instead of twice, reuses its rollback snapshot, and skin validation checks each distinct set of joint weights once instead of every vertex. Eight RobotExpressive characters went from 4.5 ms to about 1.5 ms per frame.
  • Add a per-frame density and velocity field to volume fog (also renderer.setFogField), flow-advected noise (flowStrength, flowPeriod), a profile choice, and scattering from up to 8 point and spot lights in the fog (issue #573). A fog without a field or lights draws exactly as before.
  • Breaking: a renderer that draws environment.volumeFog needs import '@codepawlhq/67js/addons/fog-shader' first (recipes, the film and the MCP server load it on their own), which takes about 2.5 KB gzip out of the core (#577)
  • Motion blur and bloom no longer leave a ghost of the previous frame after a seek (#578)
  • A few mirrored skin vertices (a finger pinched between two joints) no longer fail the frame. They draw pinched, and renderer.diagnostics lists skin-reflected-vertices with the count and the joints and weights of the first one (#581)
  • Materials accept alphaMode: 'add' for additive glow, and the opacity of blend and add parts changes each frame through updateParts without a new batch. (#586)
  • Volume fog takes detailOctaves, detailAmount, warp and contrast for wispier mist, profileSoftness for where a layer top starts to fade, and keyScattering to scale only the key light shafts (#586)
  • Metal with detailed normal and roughness maps no longer sparkles from frame to frame at grazing angles; environment.specularAntiAliasing sets the strength (#588)
  • resolveCoplanar: resolveFlushParts no longer layers pairs that lie on one plane to within a micrometre (the depth buffer already settles them) and settles chains of equal-sized parts, so it stops adding flicker on dense scenes (#593)
  • A film with a very long lens (far / near over 10,000, such as near 0.08 and far 9000) now switches to reversed-Z float depth on its own: Renderer67 loads reversed-depth.js as a separate chunk on the first such frame and every frame after it draws with it (await renderer.reversedDepthReady to have it from frame one; reversedDepth: false keeps the 24-bit buffer). On the metro film, 24-bit depth could not tell surfaces 2 micrometres apart at 2.6 m, and stairs, canopy panels, handrails and steel flickered between frames; those pairs went from thousands of flipping pixels to under 60 (#593)
  • resolveCoplanar is now a function, resolveFlushParts from 67js/addons/coplanar-overlap, so the plane-keyed search stays out of the core bundle. Its depth layers also work under reversed depth: the slope part of the offset is 16 times larger there, because the constant part moves a surface by under a micrometre in a float depth buffer (#593)
  • motion.constraints: adds copy_transforms, limit_distance, limit_scale, stretch_to, locked_track, transformation and action, each one scene_motion call (#595)
  • Recipes gain cone, icoSphere, circle (filled or ring) and line geometries, and plane is accepted as an alias of grid (#596)
  • Fields can read other surfaces: nearest (distance, point or normal of the closest point on a surface) and raycast (hit, distance, point or normal along a direction, with a miss value), plus attr: group to read a vertex group back. In instances the surface is a geometry id, so a scatter can avoid a path mesh and follow terrain; in set_position, displace, vertex_group and vertex_color it is a geometry record, and vertex_group stores the result by name (#597)
  • Force fields: a fields list on the recipe particles and cloth sections accelerates particles, hair and cloth through one shared evaluation, with wind, turbulence, vortex, drag and magnet types, strength, falloff, radius and seed. The same seed gives the same frames (#598).
  • Ocean modifier: the ocean mesh edit and stack node turn a flat grid into a seeded sea (Phillips spectrum for the wind, choppiness, size, seed, time) and write the vertex group foam where the surface folds. The same seed and time give identical vertices. Part of #599.
  • Per-object motion blur: effects.motionBlur.objects (0 to 1, off by default) smears each part that moves during the shutter along its own screen path, while the still background stays sharp; it replaces camera motion blur on that frame and loads on demand (#600)
  • render jobs: passes now include diffuse, glossy, shadow, ao and mist next to albedo, normal, emission, depth and objectId; diffuse + glossy + emission add back to the lit image, and exr keeps values above 1 (#601)
  • Three named post steps join defocus (effects.depthOfField) in the look: effects.colorBalance (lift, gamma, gain, each three numbers), effects.glare (streaks, count, angle, fogGlow, threshold, size) and effects.lensDistortion (distortion, dispersion). Each is off until a recipe names it and draws nothing at its neutral values, so a recipe without them renders the same pixels as before. Their code is a lazy module that loads only for a recipe that names one; installPostSteps(renderer) from src/post-steps.js adds the stages (#602)
  • scene_inspect reports a bake-stale warning when motion has moved a light, the sun or a part off the pose a light bake was traced at; a scene without motion or without a bake pays nothing. bake.rebake: true bakes each pose a render or seek samples (the last 4 are kept, about 0.7 s each on a small room), so the baked light matches the frame and the warning does not apply. Material animation is not checked, see docs/light-bake.md (#603)
  • MCP scene_create and set-environment now accept the 16 point, 8 spot and 7 area lights the engine renders, read from one limits file, not 8 point and 4 area (#604)
  • Motion tracks animate lights, the sun, sky and fog, exposure and focus distance, so a sunset, a lamp flicker or a rack focus plays from a recipe (#605)
  • Nodes take visible (keyable in a motion track), castShadow, receiveShadow, holdout and shadowCatcher, so films hide parts without parking them and renders composite over footage (#606)
  • Scene cameras take projection orthographic with orthoScale, focalLength with sensorWidth (instead of fov), shift [x, y] and fStop for depth of field, in recipes and set-camera (#607)
  • environment.hdri and a .cube environment.look: shipped HDRIs (sky-clouds, studio-softbox) and looks (teal-orange, noir), or catalog files by ID, work from recipes and MCP (#608)
  • Material graphs: new outputs opacity (base texture alpha), clearcoat and transmission (per-pixel masks), and mixing nodes layer (mask-blended layers such as paint over rust), hue and curve. The rasterizer reads opacity and clearcoat, the CPU path tracer all three. Graphs without them bake the same (#609)
  • A recipe mesh takes shapeKeys (named offsets or move-only edits), animated by the existing morph tracks and written as morph targets in a GLB (#610)
  • Render jobs gain four optional output settings, all off by default so a plain job writes the same bytes: transparent: true (PNG with alpha, for image and stills), format: "png16" or "exr" (16-bit PNG and OpenEXR from a half-float frame, passes included: depth in metres as float32 Z, object IDs as float32 id), region: { x, y, width, height } (a crop of the whole frame, for image, stills and video) and fps up to 60. The encoders are small hand-written Node code with no new dependency. docs/agent-render-jobs.md has the details.
  • Area lights can cast soft shadows: castShadow: true on an areaLights entry takes one tile of the local shadow atlas, and the penumbra widens with the rectangle and with the gap between blocker and receiver. Cost is 16 blocker taps and 32 filter taps per lit pixel, only for a shadowed area light.
  • environment.sunAngularRadius (radians, 0.0005 to 0.2) softens the sun shadow in the raster through the cascades (at least one slice is used) and sets the sun disk of the path tracer, which was fixed at 0.0087. Without the field nothing changes.
  • IES profiles: ies on spot and area lights takes a bundled name (wide-flood, downlight, narrow-spot, batwing) or { angles, candela }; parseIesPhotometry reads an LM-63 file into that shape. The raster and the CPU path tracer read the same 16 samples. The GPU path tracer and the light bake ignore profiles.
  • vertex_group and vertex_color mesh edits write named weights and vertex colors; displace and cloth pinGroup read a group, and colors export as COLOR_0 (#613)
  • Particle collision and look (#614): an emitter system takes colliders (static root nodes, bounced off by triangle), bounce and friction (also for the floor), spin, and color and alpha over life. A fast particle cannot tunnel through a thin mesh, a slow bounce settles, and the same seed gives the same frames after any seek. Alpha multiplies the vertex colors, a fade to black, because the renderer has no per-vertex alpha.
  • Field math and curves: field expressions gain rotate, align and transform for rotation and matrix math. Instances take a curve source (points, count, closed, fillet) that places points at equal arc length, rounds corners and, with alignToNormal, turns each instance along the curve. The bounding_box and convex_hull modifiers replace a mesh with its box or hull (#615).
  • Render jobs take settings.renderer.backend: "gpu" to path trace on the GPU, film and stills jobs can path trace every frame with one kernel compile, and recipe bakes run on the GPU when the page can, with scene_inspect naming the backend (#622)
  • The light tree splits by the surface area orientation heuristic, draws 90 percent by the angle-aware measure, runs on the WebGPU tracer (megakernel and wavefront), and lightSelection defaults to "auto": the tree for a scene with more than 8 local lights, uniform otherwise (#623)
  • Path tracer lightSelection: "tree": a light tree after Conty and Kulla (2018) as Cycles builds it, on the CPU reference and the WebGL2 kernel. On the new 24 lamp many-lights scene it scores 0.0617 against Cycles at 64 samples (uniform 0.1471) and takes 38 ms per full size sample against 72 ms; it stays off by default because it scores worse than uniform on brick-room and light-linking (issue #623)
  • 67js/addons/path-tracer-progressive draws the GPU path tracer one sample per pixel per step, starting at a quarter of the size, and samplingPattern: "blue-noise-first" and lightSelection: "importance" are new GPU options, both off by default (#623)
  • Real-time WebGPU path tracer (#624): update({ parts }) with the same part count keeps the history and the radiance cache, follows a part that only moved or turned (its matrix changed) through a per-part motion table, and rejects history on a part whose geometry changed, so a moving object leaves no trail; followPartMotion: false turns the following off for comparison
  • createRealtimeTracer(scene, { backend: 'webgpu' }) runs the real-time path tracer (#624) as WebGPU compute: the WebGPU megakernel with the radiance cache lookup and record built in, a cache update with atomic fixed point sums, and the temporal denoiser, a-trous filter and upsample as compute passes in one command buffer, with the picture copied to canvas. On the RTX 3060 the demo room at its own camera takes about 20 ms a frame at 1920 by 1080 (traced at 960 by 540) against 36 ms on WebGL2, and the kernel compiles in about 0.5 s against 11 s. WebGL2 stays the default and the fallback: without WebGPU the tracer's backend is "gpu" and fallbackReason says why. On the WebGPU backend frame(camera, { wait: true }).done and readFrame() are promises. The denoiser also rejects history where the material at the first hit differs (WebGPU backend only)
  • 67js/addons/path-tracer-realtime (createRealtimeTracer(scene, options), then frame(camera)) is a real-time view of the WebGL2 path tracer: one path per pixel and frame at half the output size, two bounces whose last hit reads a spatial hash radiance cache, and a temporal denoiser (reprojection, variance, a-trous passes) that upsamples to the output size and draws to a canvas; the scene is static, motion vectors come from the camera, and primary hits are traced rather than rasterized (#624)
  • The WebGPU path tracer (backend: 'webgpu') now traces volume fog and subsurface scattering, compiled into the megakernel only for a scene that uses them, and bakeLightmapsAsync(..., { backend: 'webgpu' }) bakes lightmap texels on WebGPU with the same report fields. On the fog and subsurface reference scenes it is within 0.0039 FLIP of WebGL2 (480 by 270, 32 samples, no denoiser), and the lit-interior bake gives the same light as WebGL2 in 0.54 s against 0.76 s. The wavefront kernel still refuses fog and subsurface with a clear error. No default changes (#625)
  • The path tracer has a third backend, backend: 'webgpu': the WebGL2 kernel written as WGSL compute (src/path-tracer-webgpu.js, loaded only for this backend, so the core bundle does not grow). It compiles in about a second instead of 8 to 20, matches the WebGL2 backend within 0.002 FLIP on the 16 reference scenes, and traces the demo room faster. It throws a clear error without navigator.gpu, and names volume fog and subsurface scattering (not ported yet) so callers fall back to gpu. No default changes (#625)
  • Recipe light bakes run on the native ray query tracer when packages/render-native is built: bake.backend is native, with the page's GPU kernel as the fallback (bake.backendNote says why). bakeLightmapsAsync takes backend: "native" with a texelTracer.
  • renderer.maxSeconds is honoured by renderer.backend: "native": a trace that passes it fails the job instead of falling back.
  • The native tracer asks the hardware about alpha cutouts itself: cutout triangles are their own geometry and the kernel confirms a candidate hit when its colour map alpha reaches the cutoff, so rays no longer step through transparent texels (8 steps at most before).
  • Shadow rays on the CPU, WebGL2 and WebGPU tracers no longer leak light through dense alpha cutouts. Their any-hit walk took the first hit traversal met as if it were the nearest, so a transparent texel far along the ray let it skip closer leaves. A solid any-hit still ends the walk; a transparent one now retraces for nearest hits. On 300 masked leaf cards the four backends agree within FLIP 0.0004, down from 0.043 between native and the rest.
  • The native tracer (renderer.backend "native", recipe bakes) now traces volume fog and subsurface scattering with the same walk as the WebGPU megakernel, compiled in only for a scene that uses them, and honours noiseThreshold on the GPU: after 16 samples, and then every 8, a converged pixel draws no more, and metrics.pathTracer.averageSamples reports the mean a pixel drew. JS67_NATIVE_TRACER=off keeps a job on the gpu or cpu backend whatever is installed; a native job without the package gives the cpu backend's bytes and report fields (#626)
  • Fixed: the CPU, WebGL2 and WebGPU path tracers gave up after 8 transparent cutout texels on one ray, so dense foliage showed holes and lost shadows; the limit is now 64, and the foliage reference scene matches the native tracer to FLIP 0.001
  • renderer.backend "native" on render jobs (image, stills, video): hardware ray queries through the optional @codepawlhq/67js-render-native package, then the usual wavelet or OIDN denoise and PNG. Without the package, its binary or a Vulkan ray query adapter the job runs on gpu (cpu on a cpu runtime) and metrics.pathTracer.backendNote says why (#626)
  • @codepawlhq/67js-render-native is an optional Rust addon that traces a scene on the GPU with Vulkan ray queries, with a bench against the browser WGSL kernel (#626)
  • The path tracer draws the textures and cutouts of loaded glTF files, which it used to trace untextured (#635)
  • The agent bench has a committed baseline for main: 28 tasks, 3 runs each, on Haiku (pass@1 99%) and Sonnet (pass@1 95%).
  • bench: bench/agent-modeling/bench.mjs runs a 28-task agent bench (modeling, revision, scene, look, light, camera, animation and film tasks, each with an automatic grader) k times per model through headless claude -p, and prints pass@1, pass^k, calls, tokens and time per model; compare-bench.mjs diffs a branch against a baseline file (#647)
  • MCP tool schemas shrink from 196,826 to about 66,000 bytes (#648). The tools list common fields and one line naming the rest, the strict schema still checks every call, and scene_capabilities answers with a short index and serves each recipe part by topic (motion, environment, materialFields, meshEdit, meshEdit. and more). CI now has absolute ceilings for the schema total and each tool.
  • The build-67js-scene and render-67js-media skills are rewritten for agents that use 67js through MCP: short entry files, references for look, light, camera, film and animation, render jobs and error recovery, and a working tool call for lens and depth of field, light caps, animated lights, sun and sky, catalog HDRIs and looks, bake.gridFog, fog multiple scattering, depth fixes and render flags. Evals under skills/*/evals run through claude -p with scripts/run-skill-evals.mjs (issue #649)
  • A Claude Code plugin: /plugin marketplace add codepawl/67.js then /plugin install 67js@67js adds the 67js MCP server (started with npx from the npm package) and the build-67js-scene and render-67js-media skills (#650)
  • npm run plugin:sync copies the package.json version into the plugin manifests, and a test fails when they differ (#650)
  • scene_apply and mesh_edit answer with one entry per operation (index, op, target, what changed, a warning when nothing changed) and a diff of node, material and geometry IDs added, removed and changed; entries past 20 are counted, not listed (#651)
  • scene_review, scene_look and the render result warn, with a field and a value to try, on an empty frame (empty-frame), a subject out of frame or too small (subject-out-of-frame, subject-too-small) and a black or clipped frame (exposure-black, exposure-clipped). The bake-stale warning of #603 now also arrives in a look, a review shot and a render job's metrics, not only in scene_inspect. They are in the frame's diagnostics, and a render job keeps one entry per warning (#652)
  • Mesh edit validation errors (cut, deform, generator, modifier, normal and attribute edits, and the parameter checks of the edit log) now read edits[2].divisions: got 9; expected a whole number from 2 to 8, such as 2.: the field path, the value received and a range, a list of choices or an example. Inside a recipe the path starts at the geometry (geometries[0].edits[2].levels). Size-limit errors for subdivide, array and subdivide_edges now name the field to lower (#653)
  • Errors for motion tracks and IK, clip layers, part relations, branches, path queries and crowds now name the field, the value and an example: nodes[1].relations[0].side: got "+w"; expected one of +x, -x, +y, -y, +z, -z, the face of "a" it sits against. The shared motion helpers (bounded, denseArray, knownKeys) keep their wording for now (#653)
  • The same readable errors now cover vegetation (nodes[3].vegetation.scatter.density: got 9; expected a number from 0.0001 to 4, such as 1.), environment.wind, particles and hair, cloth sheets and colliders, and image sequence maps: each names the full field path, the value received and an accepted example or range (#653)
  • The same readable errors now cover physics bodies, joints and ragdolls, vehicle drives (motion.drive, wheels, path, speed, lights), asset recipes and operations (root, overrides, animation, inspect, checkpoints), placed assets and the shrinkwrap edit: motion.drive.wheels[1].node: got "Nope"; expected the name of a node in the asset, such as one scene_inspect lists. The mesh-edit parameter checks that still say Mesh edit 2 (...) are not converted yet (#653)
  • Validation errors in the scene core now read nodes[1].decal: got "yes"; expected true or false.: scene operations (remove, set, inspect, checkpoints, revision), camera lens fields, geometry fields (points, holes, base, cutter), armatures, cloth and particle checks (Cloth gravity: got [0,1]; expected three numbers, such as [0, 1, 0].), terrain (terrain.size: got 0; expected a number from 1 to 2000, such as 40.) and mesh regions. Size limits and engine invariants keep their older wording (#653)
  • Validation errors for materials, nodes, the camera, lights, fog, bake, mesh edits and motion now read materials[2].emissiveColor: got [-1,0,0]; expected three numbers of 0 or more, such as [1, 0.5, 0.2].: the full field path, the value received (cut at 40 characters) and a range, a list of choices or an example. Schema errors from the MCP tools add the received value too (recipe.materials.0.color.2: Too big: expected number to be <=1 (got 2)). Mesh edit errors keep the position of the edit (edits[1].segments). Not every message in the engine is converted yet; the rest keep their older wording (#653)
  • llms.txt is now a task map; its tool list is generated from the MCP registry (npm run llms) and a test fails when it is stale (#654)
  • mcp: every tool has a title and annotations (only scene_dispose, scene_render_release and scene_release_checkpoint are destructive), six tools declare a small outputSchema with structuredContent, and scene_render_result returns the PNG as image content plus a resource link to each file (#655)
  • set-environment accepts the optional volumeFog fields (scatterOctaves, multiScatter, multiExtinction, ...) after creation, and the MCP schema names scatterOctaves and multiScatter (#661).
  • set-environment accepts the opt-in volume fog fields (scatterOctaves, multiScatter, multiExtinction, multiAnisotropy, keyTransmittance, surfaceTransmittance and the rest) on a scene that did not set them at creation, and the MCP schema lists them (#661).
  • MCP: shipped HDRI and .cube look names (sky-clouds, teal-orange and the rest) load in the packaged server built by npm run build:lib; they failed with "The URL must be of scheme file" (#664)
  • Parts with a mirrored (negative-determinant) matrix, such as a flipped billboard, now render with the right side lit and culled instead of ghosted or pale; the renderer batches them apart and glTF no longer flips winding itself (#680, #681)
  • Add multi-bone chain IK (with pole, poleAngle, stretch, iterations and per-joint limits) and spline IK along Catmull-Rom curves to addons/skeleton-pose and recipe motion.ik (#689).
  • Motion tracks take extrapolation (constant or linear) and modifiers: cycles (repeat, offset, mirror, with counts), stepped, noise (seeded), generator, limits and envelope, sampled the same in sampleMotion, camera paths and render jobs (#690)
  • Add maintain_volume, damped_track, pivot, follow_path, clamp_to, shrinkwrap and armature motion constraints, plus floor useRotation and copy_transforms/transformation mix modes (#691).
  • Add cylinder, cone and compound collider shapes, spring joints, joint motor controls, timed events (impulse, kinematicPose, jointMotor) and fields (force fields on dynamic rigid bodies) to physics definitions and recipe physics sections (#692).
  • Instancing: instances takes a place record with Poisson-disk spacing, a density field, variants of geometry and material picked at random or by a variant field, per-point rotation and size fields, and at: "vertices" or "faces" on a surface source to place on a mesh's own vertices and face centres. All of it is seeded (#698).
  • Add curve.length spacing and realize (into one mesh per material) for recipe instances.
  • environment.sky: { type: 'physical', sunElevation, sunRotation, turbidity, groundAlbedo, aerialPerspective } drives the key light direction and colour, the sky map, the background gradient and the distance haze from one sun, so a time of day is one parameter. Recipes without sky render byte for byte as before. (#705)
  • Add ozone, sunDisc, and time-of-day environment motion tracks for environment.sky (type: "physical").
  • Add position, velocity, uv, transmission, volume, environment, cryptomatte and aov render passes (material.aov and material graph aov outputs), plus multilayer: true OpenEXR render jobs (#706).
  • Unprojected ambient occlusion samples in view space rather than world space so cameras far from the origin do not quantize distant wall normals into vertical stripes (#713).
  • scene_apply, scene_restore and mesh_edit answers no longer carry the node inspection: they return the revision, the render status, the scene diagnostics when there are any, a result per operation and the diff. The results and diff of a 20-operation batch stay under 2 KB (the render status adds about 1 KB on top) instead of about 8 KB for the whole answer. Call scene_inspect to read the nodes (#718)
  • Keep mesh-leaf tree and blade grass vertex and material colors within [0, 1] while preserving their rendered baseColor * vertexTint product so exportGlb accepts mesh vegetation directly.
  • Report interior vertex valence (regular and poles), quad quality metrics and a normalized topologyScore in lintMesh and mesh_inspect (#731).
  • Fixed: automatic objectReflections skip with a reported reason when a scene has more than 256 other parts instead of failing createAgentScene, and Renderer67.dispose() deletes liquidProgram so transmissive scenes release every WebGL program (#733, #734).
  • The README opens on a Bistro street render under a Poly Haven sky, with two more Bistro views and the three showcase worlds below it. The Bistro scene is credited under CC BY 4.0.
  • Add a Blender 5.2 inventory script and a report that compares it with the ledger and agent surface, with a ranked list of missing features
  • The scene skill lists the film glitches to check before a film goes out: specular sparkle, matte rails, depth of field motes, lens ghosts, sun shaft sources and dot-matrix signs.
  • The goal and its scope now live in docs/goal.md instead of a tracking issue
  • The README banner is a full-width Bistro street render with the wordmark on the left, and the showcase table lists the airport, data center and port worlds again.
  • The README follows the same layout as the other CodePawl repos: a banner with the wordmark and three renders, flat-square badges, a showcase table, an install section that starts with a prompt to paste into an agent, and a License heading.
  • The changelog groups its entries under headings, and 0.16.0 is rewritten as a short summary
  • The scene skill points agents at the scene_capabilities topics for field detail, drops the notes for the fixed fog schema (#661) and packaged catalog (#664) gaps, and its HDRI, look and fog eval checks the shipped names and 3 scatter octaves again.
  • The tagline is now "3D engine that AI agents drive" on the site, the package and the README banner

0.16.0

Highlights

  • GPU path tracer: backend: 'gpu' renders the 1080p demo room in about 40 s, against 586 s on the CPU. The light bake can use it too (#302)
  • Outlines and toon shading with environment.lines (#285)
  • Subsurface scattering for skin, wax and leaves with the material subsurface block (#283)
  • 3D Gaussian splats from a standard PLY file, as an addon (#288)
  • environment.viewTransform picks ACES, AgX or neutral, and AgX now matches Blender 5.2 (#282)
  • Easing curves and cubic-bezier on keyframes, within 1e-4 of Blender (#286)

Agents and MCP

  • Recipes place catalog GLB assets next to terrain and procedural meshes, and render jobs draw them (#320)
  • A vegetation node plants one tree or a seeded forest over terrain, with seasons and wind (#321)
  • motion.drive drives a car model along a path with real steering, reverse and brake lights (#322)
  • Crowds of up to 1,000 walkers draw in one batch per material (#323)
  • Clips retarget between characters, feet stay planted, and morph targets key by name (#325)
  • Materials can play an image sequence as their colour map (#339)
  • The new scene_walkmap tool finds where a character can walk (#553)
  • The MCP schema now accepts every environment and node field the engine reads (#490)

Rendering

  • Up to 16 point, 8 spot and 7 area lights, from 8, 8 and 4 (#261)
  • Water got depth fade, soft shadows on the bed, refraction, and a reflection that survives rough water and costs less (#349)
  • Default fog fits the scene size, so the far side of a big world no longer fades out (#263)
  • volumeFog takes heightFalloff for valley mist that thins with height
  • Sunlit rooms get softer bounced light by default, and bake.irradianceGrid adds Cycles-like multi-bounce light (#506)
  • Far trees no longer pop darker when they switch level, and big forests can use impostor cards (#432)
  • Reversed-Z depth and a z-fighting warning that names both parts and the fix (#310)
  • Mesh blend softens the seam where a rock or a trunk meets the ground (#478)
  • Your own post passes and a GLSL hook on materials (#405)
  • Plain scenes draw faster, and far shadow cascades redraw less often (#388)

glTF

  • Many more real-world files load: meshopt, WebP, spec-gloss, optional extensions, skeleton-only clips and common Sketchfab defects (#496)
  • KTX2 textures stay GPU-compressed, about a quarter of the memory (#304)
  • Large texture sets scale down instead of throwing, and the default limits are higher (#260)

Animation and physics

  • Cloth follows moving characters, and steps live with pins and tearing (#326)
  • renderer.updateParts is about 6 times faster for matrix and colour updates (#299)

Tools, docs and site

  • Video export encodes in the browser: a 4,488-frame film took 21 s instead of 140 s (#301)
  • Path traced jobs can use Intel Open Image Denoise (#303)
  • The docs are now interactive learn pages with live examples, plus an API reference (#508)
  • The showcase worlds show their first frame sooner and stream the rest in (#445)
  • Agent benchmarks against three.js code and the Blender MCP on the same tasks (#31)

Breaking changes

  • Skin, morph, water, foliage, terrain, liquid and splat shaders moved into addons. A renderer that draws those parts without the import throws and names it. Recipes and loaders import them on their own (#281)
  • glTF limit errors are one RangeError that names every limit the file goes over. Match on the option name, not the old message (#458)
  • material.lightMask defaults to -1, every light (#261)
  • normalizeAgentLook returns fogDensity: null for fog that fits the scene (#263)

0.15.0

  • Add fog-valley and fog-room to the reference suite (part of issue #165, which stays open). Against Cycles fog-room scores 0.1953 (EEVEE 0.3730) and fog-valley 0.1967 (EEVEE 0.1952), so the fog constants of #161 hold on both. Scaling the fog ambient by the share of the sky the volume sees was measured and not kept: it worsened the region of temple-hall (0.2305 to 0.2513), so #164 is not fixed. See bench/reference/README.md.

  • Fix a thin bright line at the corners of baked rooms (issue #165). The texel just outside a lightmap chart took the average of the neighbouring chart, so the wall of dark-shaft read 128 of 255 sky visibility at its bottom edge where the interior reads 1. rasterizeTexels in src/light-bake.js now gives that texel to the nearest triangle. Baked dark-shaft goes from 0.0653 to 0.0607 and temple-hall from 0.0578 to 0.0559 against Cycles.

  • Add three options for each grand reference scene, to pick from (part of issue #168, which stays open until An picks). bench/reference/grand-scenes.js holds mountain-valley, temple-hall and megacity-dusk as -a, -b and -c, each with its own composition, light and time of day, drawn by npm run reference -- --grand into grand.json and images/grand-<id>.jpg (baseline.json and the existing images are unchanged). The Blender side gained a gradient world, written as the same equirectangular image 67js draws. bench/reference/grand-sheets.py makes one comparison sheet per scene.

  • Hide sky light where the scene blocks it: inside tree crowns and on a valley floor (issue #191, part of it). createTree bakes a sky visibility into each foliage vertex from the leaf density above it, and createTerrain bakes one into each terrain vertex from the horizon in 16 directions. The shader multiplies it into the environment light only, and meshes without it read 1. On bench/reference, the foliage crown went from 0.298 to 0.200 (Cycles 0.175) and the score from 0.1173 to 0.1023 (EEVEE 0.0888); mountain-valley went from 0.3483 to 0.2623 (EEVEE 0.1879), and its floor from 0.417 to 0.360 (Cycles 0.272). No other scene changed to four digits. The agent scene geometry bound allows 4 more bytes for each terrain vertex.

  • Compare trees like with like (issue #166, part of it). The Blender side of bench/reference now rebuilds the 67js leaf model for foliage materials (back-face normal, colour and normal variation, sky reflection 0.3, and light from behind as a Translucent BSDF with weight 0.3 * pi / (3.7, 3.4, 2.9)), and the 67js back light is now shadowed by the sun shadow. foliage goes from 0.1290 to 0.1173 against Cycles (EEVEE 0.0864 to 0.0888) and mountain-valley from 0.3473 to 0.3483 (EEVEE 0.1828 to 0.1879); no other scene moved. The remaining gap is canopy and valley sky occlusion, recorded in bench/reference/README.md.

  • Make the recipe bake presets bake large rooms (issue #189). A preset that does not fit the 5 million path step budget at 16 samples and 1 texel per unit now gives up bounces one at a time instead of refusing, and bake.reduction tells the agent what it asked for, what ran and that explicit samples, bounces and texelsPerUnit (up to 24 million path steps, 20 s inline) buy more. temple-hall at standard now bakes (16 samples, 1 bounce, 1.37 texels per unit, 0.0705 against 0.1504 unbaked with a probe). fine is now the same as standard: five samples and density mixes within the 20 s limit scored no better on the room scenes. Table in bench/reference/README.md.

  • Score the recipe bake presets against Cycles (part of issue #170, open for the frame costs). standard scores 0.127 to 0.159 on the three rooms (no bake 0.51), fine is no better, and standard and fine refuse temple-hall. Table in bench/reference/README.md.

  • No test asserts real elapsed time any more (issue #179): work counts and a fake clock replace stopwatches. smoke:agent-review-close and smoke:film-physics are wired; the second starts its own server.

  • Show the floor and the other parts in smooth metal (part of issue #167, which stays open). traceObjectProbes in src/probe-trace.js gives each part with metallic of at least 0.5 and roughness of at most 0.6 a reflection probe of its own, traced from the middle of the part without it (up to 8 parts, lit by direct light and the environment's diffuse light), and placeProbes assigns it. metal scores 0.1294 to 0.1036 against Cycles (EEVEE 0.0916), brushed-film 0.1149 to 0.1029, car-paint 0.1059 to 0.1038, material-spheres 0.1312 to 0.1293; every scene without a reflective part is unchanged to four digits and draws the same frame (metal 1.51 ms plain, 1.58 ms with four probes). npm run reference -- --object-probes places them (opt in; the committed baseline is unchanged); recipes do not yet.

  • Make every test file pass on its own, and check it in CI (issue #172). node --test tests/agent-bake.test.js failed 16 of 19 because npm test preloaded every on-demand module into each test process, so 28 files only passed through that preload. The loading path agents use was fine (tests/agent-scene-on-demand.test.js runs it in clean processes). Each of those files now imports tests/support/load-agent-scene-modules.mjs itself, npm test no longer preloads, and npm run test:isolated (scripts/test-each-file.mjs) runs each file in its own process, 4 at a time at below-normal priority, rerunning a failure alone once so a busy machine does not count. It runs in the Test workflow.

  • Fix links in the npm package that pointed at docs it does not ship (issue #178). docs/guide.md, docs/material-maps.md, README.md and ROADMAP.md now link the 20 unshipped docs, CONTRIBUTING.md, the texture credits and the changelog by absolute GitHub URL; shipping those docs would add 64 KB gzip. npm run check:links:package packs the archive, unpacks it and checks every link inside (26 files, 0 broken), and the Test workflow runs it.

  • Take 34 KB of headroom under the npm archive budget without raising it (issue #177). CHANGELOG.md no longer ships in the package, because GitHub serves it; the archive went from 740,972 to 705,961 bytes against the 740,000 budget. bench/size/README.md now says how the budget is set and what it protects.

  • Add a test that fails when the MCP tool count in docs/guide.md, docs/mcp.md, index.html or scripts/smoke-mcp.mjs differs from the tools/list result (issue #180). The server registers 22 tools; the 23rd register( in the file is the function definition, so the documented count was right.

  • Remove the AGPL-3.0 @codepawlhq/orglet-ui package, React and react-dom from the website (issue #176). The site now uses its own tokens and button in src/site-tokens.css and src/site-controls.js, and screenshots of the pages match before and after. The site JavaScript drops from 1,778,425 to 1,531,367 bytes. The published package was never affected.

  • A renderer no longer draws its shadow map a second time on the first frame when the frame has no assembly; the constructor already drew it. On mountain-valley that removes 9.72 million shadow triangles from the first frame, with identical pictures (issue #171). node bench/reference/profile-scene.mjs <scene> prints where a scene's time goes, and frame-time.mjs --plain measures scenes that are too large for the light bake.

  • The shadow pass skips instances outside the light and draws each shadow caster at a level chosen from the world size of one shadow texel (issue #171). A part can carry shadowLods, in the format of lods, and the renderer uses the coarsest level whose error is within one texel of an orthographic shadow map; tree bark carries a trunk-only level. On mountain-valley the shadow pass fell from 9.72 to 2.34 million triangles; the score against Cycles moved from 0.3473 to 0.3478 and the other scenes kept theirs.

  • Tell an agent when its scene is a closed room with no bake (issue #163). scene_inspect now returns a closed-room-without-bake diagnostic when 90 percent or more of 48 rays from the middle of the scene hit a front face, and names bake; measured against Cycles a closed room goes from 0.1430 and 0.1436 (dark-shaft, temple-hall) to 0.0609 and 0.0560 once baked. No frame cost and no schema change; agent scene entry grows 884 bytes gzip. bakeSkyVisibility in light-bake writes only the occlusion map (0.1021 and 0.0856 in under a second) and is not applied automatically. A closed room without a bake now shows a warning in scene_inspect.

  • Clean up docs, media and scripts. Remove stale logs, six unreferenced PNG previews (about 6.1 MB) with their render sidecars, the OpenAI skill metadata and ten scripts that aimed at harness pages that no longer exist. Update the roadmap, the mesh and verification docs and the contributing guide, point the links to unshipped docs at GitHub, and add npm run check:links, smoke:modeling, smoke:material-maps and benchmark:mesh-query.

  • The GitHub repository is anxuanng/67.js, public since 2026-11-02. Links and repository.url point there, which npm provenance needs to match.

  • Follow 3 bounces by default in a light bake, up from 2 (part of issue #159, which stays open). Baked rooms scored worse after the sky visibility change (lit-interior 0.1444 to 0.1915, brick-room 0.1515 to 0.2048 against Cycles) because the occlusion map removed the world light that had been filling the light a 2 bounce path cuts off. With 3 bounces they score 0.1341 and 0.1412, dark-shaft 0.0609 and temple-hall 0.0560. A bake takes about 1.3 to 1.9 times as long (temple-hall 39 to 75 s); pass bounces: 2 for the old light and time. Recipe presets are unchanged.

  • Remove the streaks in baked dark scenes and the speckle in the fog's glow (part of issue #159, which stays open). A bake unwrapped each shared geometry once at unit size, so a 2 x 32 x 180 m wall got texels 90 times longer than wide (carpet 2,867 times), which drew as streaks fanning from the vanishing point; it now unwraps each part at its world size and smooths the gathered light and sky visibility over neighbouring texels of the same surface. The glow reads the frame's mip chain instead of 24 jittered single pixels. bench/reference/noise.py measures what FLIP misses (high frequency energy in dark regions and around the door): temple-hall baked 0.448 to 0.182 and its glow ring 1.826 to 0.990 (Cycles 0.158 and 1.053), dark-shaft baked 0.318 to 0.150; whole frame scores against Cycles stay within 0.006 and temple-hall baked goes from 0.0716 to 0.0578. A baked part's report skyVisibility now weighs texels by area, and baked thin parts get more texels (brick-room 28,576 to 98,848). Core grows 92 bytes gzip and a frame with fog costs about 0.5 ms more on a shared machine. Baked scenes with long or thin parts look smoother and lightmaps are larger.

  • Light the fog around bright sources and keep it dark in closed rooms (part of issue #159, which stays open). volumeFog added a constant ambient everywhere, so the air of a closed room glowed; it now keeps 15 percent of it where the sun's shadow map says the fog is in shadow. It also scatters the light of bright pixels sideways: 24 jittered taps of the frame, weighted by the fog opacity. Against Cycles, dark-shaft goes from 0.2321 to 0.1425 (shaft region 0.2157 to 0.1219), temple-hall from 0.2126 to 0.1438 (region 0.2512 to 0.2341), and the older fog from 0.2643 to 0.2238; all other scenes are unchanged to four digits. Core grows 115 bytes gzip and a frame with fog costs about 0.1 to 0.3 ms more. Fog scenes get brighter around bright sources and darker in shadow.

  • Stop world light from reaching closed spaces in a baked scene, and score bright regions on their own (part of issue #159, which stays open). A bake now records how much sky each texel sees from the rays it already shoots, and a part that sees under 98 percent of it gets that as an occlusionMap read through the lightmap UVs, so the shader's world diffuse light and reflections shrink inside a closed room. A part that sees the sky gets no map, a scene without a bake runs the same shaders, and there is no new recipe field. Against Cycles, dark-shaft (new: a closed room, one roof opening, a sun shaft in fog) goes from 0.2612 with the old bake to 0.1301 and temple-hall from 0.2239 to 0.1129 (EEVEE 0.2653 and 0.2341), and a brightRegion that score.py picks from the Cycles image scores the shaft pixels on their own. The no-bake scores of outdoor-hdri, character, metal, car-paint and foliage are unchanged to four digits. A baked part that sees little sky now draws darker.

  • Let a key shadow block the sun fully. It kept 18 percent of the sun, so a sealed hall was evenly lit and every shadow was too light. This darkens shadows in existing scenes that have no fill light. Against Cycles, temple-hall goes from 0.5841 to 0.2126 (EEVEE 0.2341), mountain-valley from 0.3658 to 0.3473 and long-street from 0.1555 to 0.1407; fog (+0.0031) and megacity-dusk (+0.0044) get worse.

  • Compare reference scenes under one sun, and add mountain-valley, temple-hall and megacity-dusk. The HDRI holds its own sun (6 pixels with 48.1 percent of its light), so Cycles and EEVEE drew two shadows of each object where 67js drew one. Both sides now cap the sky at radiance 16, and the mean of the 16 older scenes against Cycles goes from 0.2001 to 0.1751, then to 0.1732 with the shadow change. khronos.json and path-tracer.json still use the sky with two suns.

  • Add reflection probes and a metal-room reference scene (part of issue #55, which stays open). bake.probes ('room' or up to 4 { position, radius? }) traces the room around a point once, prefilters it through createEnvironmentResources and lets nearby parts reflect it (specular only, no parallax, not in GLB). A recipe with bake places a 'room' probe unless bake.probes is false: against Cycles a probe lowered the score in every baked room (lit-interior 0.1444 to 0.1213, brick-room 0.1515 to 0.1266, metal-room 0.1754 to 0.1537) and in the unbaked rooms (0.02 to 0.06), while a hand placed probe in an open scene scores worse. The bake report now keeps the placed probes under probes (the resolved setting used to hide it). The reference harness --scene option says it does not rescore, and frame-time.mjs prints medians of three rounds. The earlier note that a probe changed nothing on a baked room was wrong. Core growth is 48 bytes gzip (lit-box). npm run reference -- --probes and frame-time.mjs take the new variant.

  • Cut the SwiftShader frame by compiling out what a frame does not use (part of issue #74, which stays open). Measured split of instanced-objects: the lit shader is about 190 ms of 380, the post pass 65, the MSAA resolve 35, the environment background 25 to 30. SwiftShader runs both sides of a choice such as environmentEnabled ? a : b and pays for code behind a uniform that is off, so the main program now takes ENVIRONMENT_ENABLED, USES_SHEEN and USES_CLEARCOAT from the parts and the environment map (features environmentMap, studioLighting, sheen, clearcoat); the post program is built per set of steps in use (createPostFragment: transparent, occlusion, bloom, volume, explosion, finish) and a new variant is built in the background while the full program keeps drawing; the main vertex program takes USES_SKIN, USES_MORPH, USES_WIND, USES_WAVES and USES_EXPLOSION (createVertexShader); and the colour clear is skipped when the environment background covers the frame. No picture changes: all 8 benchmark scenes are pixel for pixel identical. Alternated medians of 3, before to after: large-mesh 1139 to 887 ms, many-materials 983 to 880 ms, instanced-objects 384 to 268 ms. See bench/runtime/PROFILE.md.

  • Add the suite task render-pick and measure branches on it (part of issue #67, which stays open). A gallery with a pillar and a spotlight offered at three places; the litPainting check traces rays from the exported light to 15 painting points against the pillar, so it grades the pick and not the method. 10 runs (Haiku 3 and Sonnet 2, branches on and off) all passed, none called branch, and calls did not drop (Haiku 4 to 6 on, 4 to 5 off; Sonnet 3 either way). With best-of-three that is 22 runs on two tasks with no measured gain from branches. npm run smoke:agent-branches passes on SwiftShader. Bench only; core did not change.

  • Add the weighted_normal and smooth_by_angle modifiers as edits and stack nodes (part of issue #42). smooth_by_angle marks edges over an angle sharp and the rest smooth, overriding the geometry smoothAngle; weighted_normal stores an area-weighted normal per corner that the render extraction uses as is. The edge attribute smooth is new.

  • Add the lattice, curve, hook and wave modifiers as edits and stack nodes (part of issue #42). lattice moves up to 64 control points of a grid over the mesh bounds, curve bends a mesh along a Catmull-Rom path, hook pulls the vertices near a point and wave is a travelling ripple that matches Blender 5.2 at the same frame on two cases. Lists are bounded and the errors name the limit.

  • Add the screw, wireframe and skin modifiers as edits and stack nodes (part of issue #42). screw revolves the edges of a mesh about an axis with steps, iterations and lift, and wireframe leaves a rim on every face with thickness, offset and even offset; both match Blender 5.2 on counts, area and positions (wireframe on three cases, screw on two). skin is a simple version, a closed square tube per edge with a radius per vertex and no branch solver. Sizes are bounded and the errors say what to lower. Details are in scene_capabilities meshModifiers, and the modifier entry of the mesh tool schemas is now one free record that the backend validates, so the schemas no longer grow with each modifier.

  • Compare cloth with a Blender cloth bake by picture and find why the drape did not match (part of issue #62, which stays open: soft bodies are not built). npm run reference -- --cloth renders a pinned banner in wind (1 and 2 s) and a sheet dropped on a ball (0.5, 1 and 2 s) from 67js and from Blender's cloth modifier in Cycles and EEVEE and scores them with FLIP into bench/reference/cloth.json: the banner scores 0.043 against Cycles (EEVEE 0.042) and the drape 0.08 to 0.09 (EEVEE 0.04). The earlier 63 percent drape mismatch was a mirrored vertex order in scripts/blender-cloth.py plus Blender's default air damping, which on a 3 g particle is a drag of about 54 per second against 0.3 here. Cloth damping now accepts up to 100 per second. With the drag matched, the sheet lands like Blender within 5 percent at 0.5 s; Blender then wrinkles into a bell while this solver hangs smooth panels.

  • Add walking routes over terrain with holes (part of issue #64; splat layers stay at four, see docs/terrain.md). addons/navmesh builds a walkable grid from triangles (slope limit, agent radius, holes, obstacle footprints) and findPath runs A* with line-of-sight string pulling, deterministic, with cell and search budgets that throw a RangeError naming what to raise. scene_inspect takes path: { ground, from, to, avoid, ... } and returns keyframes for a node translation track, described in scene_capabilities navigation; the scene_capabilities result grew by 624 bytes and the scene_inspect schema by one record field. The suite gets terrain-path-walk (two holes and a rock) and records pathQueries; the walkPath check takes several openings and avoidNodes. Size: entry:navmesh 3,257 B gzip, agent-scene+lazy +4.5 KB, core entries unchanged.

  • Darken the automatic floor and measure the default look with a blind pairwise judge (part of issue #53). bench/agent-modeling/default-judge.mjs draws the six cold recipes under two defaults from the three-quarter view and the recipe camera (what scene_look draws), shows a Sonnet judge both in a seeded random order and reports wins with an exact binomial p. The current default beats no floor 18 of 18 (p 0.0000076, 9 of 9 in each position); the control, one image against itself, picks "first" 17 of 18, so a tie goes to the first. The floor colour goes from 0.6, 0.6, 0.58 to 0.22, 0.22, 0.21 because the judge named a floor too close to the backdrop: it beats the old floor 18 of 18, while 0.38 won 13 of 18 (p 0.096) and was dropped. Only recipes that get the automatic floor change; the judge spend was $4.50, above its $4 plan. Core did not change.

  • Import SheenChair and score it (part of issue #51). A glTF normal map may now carry its own KHR_texture_transform offset and positive scale (same rotation) on top of the transform the other maps share: the importer bakes the shared one into the UVs and stores the remainder as uvTransform on the normal map descriptor, and the normalMapTransform shader feature in addons/material-layer-shaders applies it (a scene without such a normal map compiles the same shader as before). Any other difference between the maps of one material still fails the import, and an extension texCoord equal to the texture's own is no longer refused. Core grew by 25 bytes gzip (lit-box 60,179 to 60,204): a hook in the normal map lookup, one feature line and the bind argument; the glTF importer grew by about 370.

  • Fix the automatic floor skipping a lone flat object (part of issue #53). A lone part never counts as the recipe's own floor, so a gear lying flat, which spans its whole scene and is the lowest geometry, now gets a floor and a contact shadow (before, agentGroundPlacement returned null for it). The surface judge on the six cold recipes goes from 0 before the floor, to 6 with the first rule, to 7 with this fix (gear 0 to 1; one call per task, so direction only). A flat object with a hub on it is still read as a plate. Core did not change.

  • Try two exact-picture speed-ups for the SwiftShader frame and keep neither (part of issue #74, which stays open; no engine change). Drawing the environment background after the opaque pass on the far plane, and fetching the post pass's extra FXAA taps only on edges, both moved instanced-objects inside the noise (medians 379 to 377 ms and 388 to 386 ms over three alternated pairs). Current ratios against three.js on SwiftShader: large-mesh 6.0, many-materials 5.0, instanced-objects 7.0, so the 3 times target is not met. bench/runtime/PROFILE.md records why: a shader that returns the base colour still costs about 4 times three.js, so the rest needs MSAA, the HDR target or the shadow filter to change, which change the picture.

  • Let the path tracer stop converged pixels, draw normal and roughness maps on box-projected materials, and finish a 1080p still (part of issue #129, which stays open). noiseThreshold (0 to 1, default 0.03, 0 draws every sample) stops a pixel once the standard error of its mean luminance is under that share of the mean plus 0.05, checked from 16 samples on and after every 8 more; the decision reads only the pixel's own samples, so bands and thread counts still give the same bytes, and report.averageSamples says what was used. Shadow rays no longer interpolate the surface they hit unless it is a cutout (pixels unchanged, 1.23 to 1.36 times faster per thread on the demo room). Box-projected parts are traced with the UVs of their projection (boxProjectedGeometry, with columnLengths now exported from src/export-box-uv.js), so their colour, normal and metallic-roughness maps are all read (before, a box-projected colour map read one texel); report.ignored no longer lists them. Render jobs may set maxSeconds up to 600 (was 240; the deadline is maxSeconds plus 60 s): the 1920 by 1080, 64 sample still of tests/fixtures/demo-room.recipe.json took 246.4 s in the tracer (30.7 samples per pixel on average, 8 threads, 257 s per job), 6 s past the old limit. Measured, and not all good: at 24 fixed samples with the filter brick-graph is 0.0024 and character 0.0048 worse than at 64; adaptive sampling costs spot-area 0.0658 to 0.0900 against Cycles at the default threshold; drawing one light at the first hit was tried and dropped (twice as fast, 66 percent more error). brick-graph did not improve against the same tracer at 64 samples (0.1370 to 0.1373); the darker floor of character and outdoor-hdri was narrowed but not found. bench/reference/run.mjs takes --noise-threshold and records averageSamples. Core did not change.

  • Read the textures inside glTF layer extensions and accept TEXCOORD_1 (part of issue #51). clearcoatTexture, clearcoatRoughnessTexture, clearcoatNormalTexture, anisotropyTexture, sheenColorTexture and sheenRoughnessTexture load into material.layerMaps and draw through shader features in material-layer-shaders, and exportGlb writes them back. Occlusion, emissive and metallic-roughness textures may read TEXCOORD_1. Against Cycles, AnisotropyBarnLamp goes from 0.4758 to 0.3584, AnisotropyDiscTest from 0.3481 to 0.2808 and ClearCoatTest from 0.2344 to 0.2306; TransmissionTest is unchanged and SheenChair still waits on per-map texture transforms. The core entry grows by about 345 bytes gzip.

  • Score material scenes and Khronos sample assets against their baseline (parts of issues #50 and #51). brick-flat is the control for brick-graph: the same wall in the graph's average colour with no maps. npm run reference -- --khronos draws Khronos sample assets downloaded into gitignored artifacts/khronos/ and scores them against Cycles reading the same GLB, on the pixels the asset covers (khronos.json, images/khronos-*.jpg; baseline.json is unchanged). The brick bump is not weaker than Blender's: its bright edge is stronger and bump 0 would score better (0.2065 against 0.2269), so no engine change. The assets found two importer faults, fixed in src/gltf.js: KHR_xmp and KHR_xmp_json_ld metadata refused the whole file, and KHR_materials_variants is now accepted with a warning. Still open: texture slots in layer extensions (the anisotropy textures matter, both anisotropy assets score worse with the factor than with none) and occlusion on TEXCOORD_1 (SheenChair).

  • Let recipes reach cascaded sun shadows and light linking (part of issue #52; the lit-interior score goal is still open). environment.shadowCascades (0 to 4) and affects on point, spot and area lights plus environment.keyAffects name nodes; both addons load on demand through src/agent-scene-modules.js, scene_capabilities now reports lightLinking and shadowCascades, unknown node IDs are refused with the next action, and set-environment and scene_export_recipe carry the fields. The light bake honours affects (a linked light adds nothing at a part it skips, even as a bounce) and the path tracer lists linking in report.ignored. Default: a scene without shadowCascades whose shadow.extent is above 40 gets three cascades (the single map is then 4 cm per texel or coarser; long-street scores 0.1555 with one map and 0.1398 with three, for about 0.2 ms on an RTX 3060); every scene at or below 40 draws as before, and shadowCascades: 0 keeps one map. node scripts/smoke-mcp-linking.mjs proves one recipe with both through the MCP server, with a seek giving identical PNG bytes. The MCP schema total stays at its budget by shortening environment descriptions.

  • Add an automatic floor with a contact shadow to the MCP preview, and measure the default look on cold runs (part of issue #53; its done condition is not shown, see below). Breaking look change: a recipe with no floor of its own now draws a light grey disc under its lowest geometry at that height, so the key light's shadow falls on something; before, objects floated on a flat grey backdrop. It is not a recipe node: src/agent-ground.js builds it from world bounds on every draw (agentGroundPlacement), so the exported recipe, scene.parts, silhouettes and the suite's checks do not hold it, and it reaches the renderer through the ground option, which now also accepts a part (about 20 bytes in entry:core). It is left out when a part already forms a floor: one that spans at least 90 percent of the scene's width and depth, is thinner than a quarter of its width, and is the lowest geometry. environment.ground: false switches it off (the field is absent from recipes that do not set it). Nothing else about the default look changed: effects.exposure stays 1 (an exposure of 0.8 was tried and dropped: on the six cold recipes no pixel of the subject reached 250 at either value, and mean luma was 157 to 199 at 1 and 142 to 187 at 0.8), setup daylight, occlusion 0. The suite's look harness drew without the setup's environment map, so its images were darker than the preview shows; it now draws with the map and the floor, and regrade.mjs finds files of runs made with --runs. Measured on six cold Haiku recipes with a reference-free Sonnet vision question ("does the object sit on a surface, with a believable contact shadow", 0 to 3): 0, 0, 0, 0, 0, 0 before and 1, 1, 2, 1, 1, 0 after. The judge named the front and side cameras as the gap: they are orthographic at floor height, so a floor is edge-on and a shadow falls behind the object, and only the three-quarter view shows it. The reference-based judge (shape, proportions, features, surface) tied at 66 of 72 across the dropped exposure change, because it cannot see lighting defaults. Tool schema text was shortened to pay for the ground field.

  • Measure what an equal feature set costs against three.js (part of issue #74; no engine change, no speed-up). bench/runtime gets the engines 67js-ldr, 67js-one-sample, 67js-ldr-one-sample and three-one-sample (run with --engine) and a --cpu-only flag. Measured: with no MSAA and no HDR target 67js is still 5.2 to 5.7 times three.js on SwiftShader in large-mesh, many-materials and instanced-objects (7.8, 5.3 and 7.8 with the defaults), so the gap is the lit shader and not those two features. On the RTX 3060 large-mesh costs 3.6 ms against 0.6 ms and is not explained by HDR, MSAA, the vertex shader or the vertex attributes; on ANGLE Vulkan the ratio is 2.3 instead of 5.8. Skipping zero-intensity fill lights was tried and reverted (inside the noise). The profile is in bench/runtime/PROFILE.md.

  • Add cascaded sun shadows and light linking (part of issue #52; recipes do not reach either, and lit-interior was already improved by the light bake, not by this work). addons/cascaded-shadows: new Renderer67(canvas, parts, { shadowCascades: createCascadedShadows({ count: 3 }) }) fits up to four depth maps to slices of the camera's view, with sphere fitting and texel snapping so edges do not crawl; on the new long-street reference scene the score against Cycles goes from 0.1555 to 0.1398 for about 0.2 ms more a frame on an RTX 3060 (+25 percent on SwiftShader) when the camera moves. addons/light-linking: applyLightLinks(parts, environment) limits a light to the parts named in its affects list (environment.keyAffects for the sun) through a per-part mask in material.lightMask; the new light-linking reference scene scores 0.0998 against Cycles with the same lists as Blender receiver collections. Both keep their GLSL out of the core bundle (registerShaderFeatureCode, new slots sunVisibility, linkSun, linkPoint, linkSpot and linkArea), and npm run reference -- --cascades <n> and frame-time.mjs <scene> <backend> --cascades measure them. No earlier reference scene moved.

  • Fix the recipe light bake budget, which rejected the demo room at samples 96, bounces 2, texelsPerUnit 3 (11.5 s before the budget) and scaled standard there to 16 samples (part of issue #55). The ray work estimate multiplied by every light and so overcounted open scenes by about 4 times. The budget now counts path steps (texels x samples x bounces), which cost about the same per path in a closed 56 part room and in the demo room. A preset scales down to 5 million path steps (the demo room at standard keeps about 52 samples, not 16); explicit settings are limited only by a hard bound of 24 million path steps and by the real 20 s limit, which fails the edit with the scene unchanged and names a lower samples and texelsPerUnit to try. A bake on a worker has 90 s instead of 20 s (the page's own thread keeps 20 s), and the preview's 30 s call deadline grows by 90 s for a scene_create with a bake and a scene_apply with set-bake. bake.used and bake.reduced are unchanged; the capability limit maxRayWork is now maxPathWork.

  • Make room in the npm package without adding a dependency (part of issue #36). The archive fell from 802,581 to 695,041 bytes (353,535 free under 1 MiB; the target was 300,000), and every library and MCP install stays as light as before. Two causes: (1) every one of the 80 built files began with the full LICENSE and THIRD-PARTY-NOTICES.md text, about 4 KB each; they now carry a one-line notice and the complete texts stay once at the package root, about 61,000 bytes saved; (2) the MCP SDK's Node shim pulls in Ajv (the validator for elicitation answers, about 270 KB before minification) that this server never uses, so build/mcp/server.mjs now bundles scripts/mcp-sdk-shims.mjs instead, which fails with a clear message if elicitation is ever requested: server.mjs fell from 677,484 to 484,111 bytes and the archive by about 47,000 bytes. build/mcp/LICENSES.md no longer lists the Ajv family because that code is gone, and its unused copies left licenses/mcp/. Measured, and not worth doing: zod/mini (zod's classic layer is 30 KB of the server before gzip), source maps (none are shipped), standalone core copies (none in the archive), and docs (every packaged page is linked from the README, llms.txt, the MCP guide or the skills). npm run smoke:package now loads every exports entry in a clean consumer. Film and site code were already outside the archive. Separate lazy-loaded packages were not built: the lazy addons together are about 157 KB gzip, so splitting them out could return at most that much, for the cost of a package, a release pipeline and a version matrix each. archiveBytes budget 815,000 to 705,500. Module load of the server is no slower (minimum of 25 runs, 217 and 188 ms against 231 and 209 ms).

  • Run the heavy scene kernels on a worker in the MCP preview (part of issue #38; edits after creation still run on the main thread). The light bake, the cloth solver, uv_unwrap and pattern textures are pure functions of their input, so runKernel in the new src/kernel-offload.js computes them inline as before, or, inside buildWithKernels, throws KernelDeferred, lets a module worker (kernel-worker.js, a package entry like the path tracer's) compute the result, caches it by a hash of the input bytes and runs the synchronous build again. The preview builds scene_create that way when the page has Worker; Node and every other caller keep the synchronous path and the same bytes (a test builds one scene cold in a separate process both ways and compares a digest of geometry, textures and the bake report). A worker error comes back with its class and message, a worker that cannot start or dies leaves the job to the inline path, and an AbortSignal ends the build and the worker. Measured in Node on the demo recipe: the uv_unwrap stack takes 3.6 s, the draft light bake 7.5 s and the standard bake passes the 20 s limit on this machine, cloth at the 10 s limit takes 3.4 s, a 1024 pattern takes 1 to 7 s, a boolean 0.12 s. Measured in headless Chrome on the GPU backend with the demo room recipe (tests/fixtures/demo-room.recipe.json, 9 kernels): the longest stretch the page was unresponsive during scene_create fell from 11.8 and 11.9 s to 1.6 s with workers (two runs each), while the build took 12.3 and 12.5 s instead of 10.9 and 11.0 s, because the kernels run one after another and the build reruns after each. scene_inspect now reports kernels: how many kernels a worker served and how many ran inline, each fallback with its reason (also a 67js kernel fallback line on stderr when a page that has Worker falls back), the build time and the longest block; npm run smoke:kernel-workers installs the package, runs the demo room and fails unless kernels ran on the worker with no fallback. The longtask observer saw nothing in either mode because the browser does not count work run by a remote-debugging call, so the block is measured with a 20 ms timer. scene_apply edits still run on the main thread. Core did not grow (entry:core, lit-box unchanged); the lazy entries rose by about 900 bytes gzip.

  • Fix three gaps a demo film found in the recipe light bake (part of issue #55). A baked scene with cloth failed at render time for every frame after t=0 with "A light map needs lightUvs on rigid geometry, with no skin or morph", because the cloth simulation replaces the sheet's geometry each frame; cloth sheet nodes are now skipped and listed in report.skipped. The bake now lights with spot lights (the renderer's cone and soft edge) and area lights (front side only, one deterministic shadow ray to a point of the rectangle per hit), where it ignored both; a scene without them bakes the same bytes. The presets could not finish a normal scene (standard passed its 20 s limit on a 56 part room, fine hit the 30 s preview limit): a recipe bake now has a ray work budget of 10 million units (texels x samples x bounces x rays per hit), estimated from the unwrap before any ray is traced with no clock involved. A preset is scaled down to fit and scene_inspect bake reports used and reduced; explicit samples, bounces or texelsPerUnit are never reduced and fail with a message naming the number that fits. bakeLightmaps is now planLightmaps, estimateBake and traceLightmaps (still exported as one call). entry:core did not change; entry:light-bake grew by 1,033 bytes gzip (budget 25,900 to 26,900) and the lazy agent entries by about 1,580; the schema stayed within its total budget (the capability notes were shortened to fit).

  • Add sculpt and shrinkwrap mesh edits (part of issue #47; surface patches and a stack form are not built). sculpt applies up to 32 inflate, displace and smooth strokes to the vertices of the selected faces; shrinkwrap moves them onto a primitive, to the nearest point or projected along a direction, with an offset. Both are in scene_capabilities (meshSculpt) and in the mesh_edit schema, with the tool schema total unchanged (the face rule and tag prefix descriptions were shortened to pay for them). The stroke maths moved to src/sculpt-strokes.js and serves sculptGeometry too. Four Blender golden cases (two Shrinkwrap modifier comparisons; the sculpt reference runs the same brush formula on Blender's mesh), hostile input tests, and the suite task ball-badge, which needs a plate bent onto a ball.

  • Add ragdolls (part of issue #96): physics.ragdoll in a recipe with armatures and physics in an asset recipe (set-physics) bind a capsule body to every bone or joint and play the fall back as the pose of those bones, the same bytes for the same seek. New src/ragdoll.js, loaded with the physics code only. New suite task robot-ragdoll. The lazy budgets of agent-scene+lazy and agent-asset+lazy rise by 100 and 800 bytes gzip for it; the core entries did not grow from this. Joints have no swing limits yet.

  • Add terrain holes and a recipe terrain geometry (part of issue #64; layers beyond four and the navmesh are not built). createTerrain({ holes: [{ center: [x, z], radius }] }) leaves no surface where a cell centre is inside a circle, and terrain.isHole(x, z) answers for a point; without holes the seeded meshes are byte-identical (a digest test). A recipe geometry { type: "terrain", size, resolution, seed, amplitude, holes } builds one seeded ground mesh with the same holes; it loads on demand through the new terrain module (core did not grow), the tool schema entry is one line with the fields in scene_capabilities terrain, and the schema total budget did not change (scene_create and scene_apply rose by a few hundred bytes, mesh_edit fell by the same amount). New suite task terrain-hole-walk (ground with a 3 m opening and a walker that has to go around it) with the checks groundRelief and walkPath. Measured: Haiku passed it 2 of 2 (9 and 6 tool calls, $0.29 in all) and both exported recipes used the terrain geometry; there was no control run without the feature, so this shows agents find it, not how many could do without.

  • Bake patterned, textured and emissive parts, and skip hair hosts (part of issue #128). A recipe bake used to skip every part with a pattern, a map or emission (31 parts, the floor and every wall, in the demo room) and failed scene_create with "Textured geometry requires UV channel 0" on a node that hosts hair. Those parts now keep uvs and their look and take the bounced light through a new lightMap material slot on a second UV set (geometry.lightUvs); the fragment shader adds color * (1 - metallic) * lightMap * lightMapScale, so a brick pattern tints its own bounced light. Hair and particle host nodes are skipped and listed in report.skipped. The shader branch compiles out of scenes with no light map; the renderer carries about 650 bytes of gzip for it in entry:core (see docs/light-bake.md for the measured sizes). GLB export writes TEXCOORD_1 and the light map as the emissive texture (an approximation: glTF has no light map slot). The path tracer ignores baked maps by design. New reference scene brick-room (a recipe-built closed brick room).

  • Make the path tracer about 2.8 times faster per thread and draw normal and metallic-roughness maps (part of issue #129; a 1080p still of the 181,708 triangle demo room at 64 samples still does not fit the 240 s job limit). Profiling the demo room showed the ray query dominating: 54 percent of the time sat in the generic BVH visitor, which called a closure per box and per triangle and kept distances in a boxed array. createTracer in src/ray-query.js now walks the BVH with typed stacks, a slab test on inverse directions and triangles packed in leaf order; pixels are bit-identical to before (checksum of a band unchanged) and it runs 1.2 times faster alone. The larger gain is shadow rays: the demo room has 11 light sources, and every bounce traced all of them. The first hit of a path still samples every light; later hits draw one at random and divide by its chance (and the environment multiple importance weights use that chance), which gives 23,300 paths a second per thread against 9,800, with the average moved by less than 1 percent in the demo room and 3 percent allowed by a test. Image jobs now use 8 workers, up from 4 (the machine limit). normalMap (with normalScale, tangent frame from the UVs as in the rasterizer) and metallicRoughnessMap (green scales roughness, blue scales metallic) are drawn on UV-mapped materials; on box-projected materials (boxMapScale) they are still ignored and report.ignored says so. The entry:path-tracer size budget goes from 12,900 to 13,800 bytes gzip for the maps, light selection and the packed ray query; entry:core did not change. Tests: maps tilt and mask the light, one light drawn at random keeps the average, and bands drawn in any order give the pixels of the whole image.

  • Move the anisotropy and iridescence shader code out of the core bundle (part of issue #51). It lives in the new addons/material-layer-shaders entry, which registers it on import; the renderer asks for it only when a part uses a layer, so a lit box no longer pays for it. A scene that uses a layer in code must import the entry first, or the renderer throws a message that names the import. Recipes load it through loadAgentSceneModules, the MCP server does so itself, and the glTF loader loads it for a file that uses either extension. The unused short overloads of environmentLighting are gone. Pictures are unchanged.

  • Add anisotropy and iridescence material layers, and a depth of field for each timeline shot (part of issue #51). Recipe materials take anisotropy and anisotropyRotation (highlights stretch along a grain, as KHR_materials_anisotropy) and iridescence, iridescenceIor and iridescenceThickness (a thin film that shifts reflection colour with the view angle, as KHR_materials_iridescence, after Belcour and Barla). Both are compiled out of the shader unless a part uses them, the MCP schema takes them with one short line each, and glTF import and export read and write the two extensions, so they no longer warn as accepted but not rendered. Transmissive materials draw in their own pass and ignore both; scene_inspect diagnostics say so. Recipe materials already accepted clearcoat, transmission, thickness and ior with the surface tag (a demo film that could not ask for them was running an older build, and its murky marble came from the liquid tag, which absorbs by thickness): scene_capabilities now lists every layer with its range under scene.materialLayers, and npm run smoke:material-layers renders a glass ball through the real MCP server and checks that the stripes behind it are bent. A timeline shot also takes focusDistance (0.01 to 100000 m) and blur (0 to 1), which replace the recipe depth of field for that shot only; sampling stays stateless, so a seek gives the same bytes as the frame in a sequence. bench/reference gets a brushed-film scene scored against Cycles and EEVEE, and the 11 older scenes did not move by more than 0.002 against Cycles.

  • A path trace job keeps its own maxSeconds below the job deadline: the deadline of an image job with settings.renderer now reaches maxSeconds plus 60 s (it was 60 s plus 2 s per frame, so a 1920x1080 trace of 120 s was cancelled at about 67 s), and the traced PNG may be as large as any job frame (12 MiB, not 1 MiB).

  • Add 67js/addons/path-tracer (part of issue #57; the Cycles comparison is partial). renderPathTracedImage({ parts, environment, camera }, options) draws a still by CPU path tracing against the triangle BVH of the light bake, with next-event estimation for the sun, point, spot and area lights, an importance-sampled environment map, GGX metal, clear coat, glass, maps and cutouts, and a wavelet denoiser, on up to eight module workers. An image render job selects it with settings.renderer: { type: "pathTracer", samples, bounces, denoise, seed, maxSeconds }; the same recipe and seed give the same PNG, a job past maxSeconds fails with no image, and samples, size and ray work are bounded. It loads on demand: the core bundle and the agent scene do not carry it (the limits live in src/path-tracer-capabilities.js, listed under jobs.pathTracer in scene_capabilities; the tool schemas gain one renderer field inside the total budget). npm run reference -- --path-tracer scores it against Cycles: better than the rasterizer on 7 of the 11 reference scenes (lit-interior 0.5055 to 0.1993, spot-area 0.1242 to 0.0639), worse on outdoor-hdri, character and fog, mean 0.171 against 0.189. Not drawn: volume fog, normal maps, translucent leaves, caustics, lights seen in mirrors. src/ray-query.js now holds the ray query and light falloff that light-bake used to carry. npm run smoke:path-tracer checks it through MCP.

  • Test the docs and the MCP server on clients other than Claude Code (part of issue #69). New npm run check:tool-schemas and tests/other-clients.test.js check all 22 tool definitions against rules other clients apply: name characters and length, a description under 1024 characters, an object root, a type on every constrained schema, resolvable $ref, declared required fields, a strict JSON Schema 2020-12 compile (Ajv 8, now a dev dependency) and an empty-argument call. Reports for OpenAI strict: true and for Gemini's documented keyword subset list each gap with its schema path; the test fails when a new kind of gap appears. Measured: the MCP SDK client and the MCP Inspector CLI list the 22 tools and call scene_create; a draft-07 Ajv compile rejects every tool ($schema, then prefixItems), strict OpenAI tools would reject the optional-heavy schemas, and nothing was run on Codex, Cursor, Gemini or any non-Anthropic model. A cold Haiku read of only the README and llms.txt installed the package and rendered a box but found no route to a PNG without MCP, so docs/guide.md gains a tested "Render a PNG from a script without MCP" recipe that the README and llms.txt point to; docs/mcp.md gains an "Other clients and models" table and no longer pins the standalone launch to 0.9.1. A test checks that every page llms.txt and the README link to exists. Schema bytes are unchanged.

  • Fix the next agent tool errors (part of issue #66). scene_review and scene_look with labels on an imported asset failed with "needs the mesh code" because asset creation loaded the on-demand scene modules only for mesh edits; it now always does, and a test walks every preview path in a fresh process. geometries and materials are optional in a recipe. A failed scene_create says no scene was created and to call it again. scene_inspect on an asset accepts a source-node ID that holds one part and names the parts of one that holds several.

  • Fix the most common agent tool errors (part of issue #66). scene_look and scene_review with labels on an imported asset threw Cannot read properties of undefined (reading 'map') (an asset recipe has no materials list, and asset mesh reports are keyed by part ID); an engine fault now reaches the agent as one advice message and goes to stderr. A node that names a geometry and no material gets an explicit default material instead of an error. sessionId is optional on every tool and defaults to the active scene (189,159 to 188,872 schema bytes); an ID that names another scene is still rejected. scene_apply names the fix when set-node fields are wrapped in node. The bench look harness loads the on-demand scene modules, so motion recipes get a look score.

  • Rename the project from 67.js to 67js, with no dot. The GitHub repository anxuanng/67.js, the npm package @codepawlhq/67js, the site domain and the Worker name stay.

  • Add a recipe timeline, job audio and an encoder choice (part of issue #60, first slice). A recipe timeline lists named shots played in order over the motion clock, each with a duration, an optional motionStart, a partial camera on top of the sampled one and a dip through black; set-timeline edits it. settings.timeline: { start } renders it as an image, stills or video: one clock drives the shot, the motion and the renderer, so a seek to any time gives the same frame as inside a video. settings.audio: { file, offset } mixes one .wav, .mp3, .ogg or .flac from the new --audio <folder> option into a video, checks that it covers the video, decodes both streams afterwards and reports metrics.sync (a gap over 50 ms fails the job); settings.encoder is cpu or nvenc. File names are plain names without paths, drives or protocols, files must be regular and at most 32 MiB, and ffmpeg gets -protocol_whitelist file; nothing else comes from the agent. Video jobs can last 60 s (was 30), still capped at 900 frames, so a 60 s video runs at 15 fps. Measured through MCP on SwiftShader (npm run smoke:film-timeline): 9 PNG seeks across three shots and a dip match 8 stills byte for byte, and a 60 s, 900 frame video with sound rendered in 58 s (84 s on a loaded machine) at 128 x 128 with the click in the decoded audio on the decoded cut frame (offset 0.1 ms, streams 20 ms apart). Tool schemas stay inside their budgets (the timeline is a record reference; fields are in scene_capabilities filmTimeline). Left out: resumable long renders, several audio tracks, gain, markers inside a shot, animation events, crossfades and timelines for imported assets. The video sequence editor stays a non-goal.

  • Decide on WebGPU (part of issue #56, no engine change): wait, WebGL2 stays the only backend. Headless Chrome 156 has a WebGPU adapter on the RTX 3060 with no flags, but none under the MCP cpu flags (--use-angle=swiftshader); the SwiftShader Vulkan adapter needs --use-webgpu-adapter=swiftshader. With three.js as a proxy on 3 bench scenes, WebGPU frames were 2.6 to 4.4 times WebGL on the GPU and 1.4 to 3.0 times on SwiftShader, and first frames were slower. Browser support, shader rewrite size (about 1,400 GLSL lines and 450 call sites) and bundle cost are in docs/webgpu-decision.md.

  • Add recipe particles and hair (part of issue #63, no new tool). A particles section holds seeded emitter systems (point, box, sphere or disc; gravity, drag, wind, a landing floor, size over life) and hair systems that grow strands from a surface node, loaded on demand with the new particles module (src/particles.js, src/hair.js). Each particle is a closed-form function of its seed, index and time, so a seek never replays: the same time gives the same particles, a seek backwards repeats them and a seeded system gives identical bytes (npm run smoke:agent-particles checks PNG bytes through the MCP preview, including a second session). Counts are bounded to 4 systems, 2000 particles each, 4000 in total and 100000 drawn vertices. New set-particles operation and a particles report in scene_inspect; the schema takes one record reference, so the tool schemas stay within the total budget and the fields live in scene_capabilities. Cloth and particles now share validation helpers (src/agent-recipe-checks.js). Left out: particle collisions and bounce, rotation, colour and alpha, hair collision and combing. The smoke, fire and liquid decision (no browser solver, with measured grid costs) is in docs/physics.md.

  • Add 67js/addons/light-bake (part of issue #55; recipes, MCP, GLB export and reflection probes are not done). bakeLightmaps(parts, lights, options) traces cosine-weighted paths on the CPU against a triangle BVH and returns new parts that carry the light that bounces between surfaces (point lights and the sun, shadowed) as a lightmap texture drawn through the emissive map, with lightmap UVs from the uv_unwrap unwrap. The renderer and its shaders are untouched, so a scene without a bake renders as before and core size is unchanged. Bounded and deterministic: samples, bounces, texelsPerUnit, maxResolution and maxSeconds are range checked, texel, triangle, light and ray-work totals are checked before any ray is traced, and the same input gives the same bytes. Parts with their own maps, pattern, emission, skin or transparency are skipped and listed in the report. npm run reference -- --bake lit-interior takes lit-interior from 0.5055 to 0.1444 against Cycles (6 s bake); no other scene moved by more than 0.002. The package archive grows by 3,525 bytes (717,978 to 721,503). See docs/light-bake.md.

  • Add recipe cloth (part of issue #62, no new tool). A cloth section records sheets with a position-based solver (src/cloth.js, loaded on demand with the new cloth module, no peer dependency): pinned edges, gravity, steady wind, ball and box colliders, thickness and friction, 60 frames a second, bounded by particle, frame and solver-operation limits. A seek blends two recorded frames, so the same time gives the same positions and a seek backwards repeats them (npm run smoke:agent-cloth repeats the PNG bytes through the MCP preview). New grid geometry (a flat sheet, 1 to 64 segments), set-cloth operation and a cloth report in scene_inspect. The tool schemas stay within the total budget: set-physics now takes the same record reference as set-motion, and the physics descriptions are shorter. A hanging sheet matches a Blender cloth bake (scripts/blender-cloth.py) to 0.08 percent of its height; a sheet dropped on a ball does not match, and no parity is claimed. No self collision and no soft bodies yet.

  • Edit the topology of imported GLB parts (part of issue #48, no new tool). mesh_edit and mesh_inspect take a part ID such as mesh-10 of an imported asset: the part becomes a welded polygon mesh with axis tags and a material-<n> tag, the edit log is kept in the asset recipe as meshEdits (checkpoints, export and replay work), and every result passes validateTopology. New vertices take skin weights, morph deltas and vertex colours from the nearest original surface point and faces left without UVs read the nearest UV island; on a skinned or morphed part an edit more than a quarter of the part's bounds diagonal from the original surface is rejected with the next action. mesh_inspect reports localToWorldScale and localAxesInWorld. Measured on RobotExpressive through MCP (npm run smoke:imported-topology): a through hole in the closed left leg (98 to 210 triangles, still one closed part), a cut in the skinned right hand (124 to 109) and the morphed head (154 to 134), a 3 m extrude on the head rejected, GLB export and checkpoint restore intact. Suite task robot-leg-hole.

  • Make room in the npm package (part of issue #36). The MCP preview page, build/mcp/preview.js, is now an entry of the library build and imports the engine chunks that the package entries already ship, instead of bundling its own copy of the engine. The archive drops from 904,975 to 666,214 bytes. build/mcp/manifest.json lists those chunks under previewChunks with their hashes, the MCP runtime serves them next to preview.js, and bench/size/budgets.json gains archiveBytes, which npm run smoke:package checks.

  • Add six whole-mesh modifiers as edits and stack nodes (part of issue #42): weld, triangulate, edge_split, smooth, simple_deform (twist, bend, taper, stretch) and cast (sphere). Each has Blender cases in tests/fixtures/blender/ that match with no listed difference, triangulate and edge_split check their output size before building it, and their fields are described in scene_capabilities meshModifiers so the tool schemas grow by one compact entry. Left for later slices: screw, skin, wireframe, lattice, curve, hook, wave, shrinkwrap, weighted normal, smooth by angle and the other cast shapes. npm run parity now prints the modifier coverage.

  • Add curve and text geometry (part of issue #45). curve sweeps a round or custom profile along a cubic Bezier chain with explicit or automatic handles, a taper along the length and flat caps; text extrudes the outlines of the bundled DejaVu Sans (printable ASCII, 20 KB, loaded on demand with its own text module and never in an entry) or of a font table added with registerAgentSceneFont, with size, depth, alignment, lines and curve resolution. Volume, area and bounds match Blender 5.2 to 2e-5 for two Bezier curves and for a letter and a word set in the same font. Recipes stay plain JSON with bounded, validated fields and vertex estimates checked before generation. The MCP schemas gain two strict entries in the geometry list (1.4 KB of the 190 KB across all tools; not offered as mesh bases or cutters); field types and limits live in scene_capabilities under curveText, and the MCP takes no font file or URL. The DejaVu licence is in THIRD-PARTY-NOTICES.md. Metaballs and NURBS surfaces are recorded as out of scope in docs/parity.md. Not done: a suite task in bench/agent-modeling, kerning, bevelled text, non-ASCII glyphs in the bundled font.

  • Add frustum culling, levels of detail and live adaptive resolution (part of issue #37). Renderer67 tests each instance of a batch against the view frustum with the geometry's bounding sphere and draws only the visible ones (on by default, culling: false turns it off; skinned, morphed, swaying, fire, smoke, water, assembly and blended batches and the shadow passes are not culled). A part's lods, the array from generateGeometryLods, makes each instance pick a level by pixel error (lodPixelError, default 1). Selection is a pure function of the camera and the matrices, so a seek draws the same frame. createGpuTimer and AdaptiveResolution in src/adaptive-quality.js give live viewers GPU timing and a resolution scale with a minimum; an export can not build one, and src/main.js uses it only outside export=1. New large-outdoor scene in bench/runtime with ablations: 1.55 ms against 8.41 ms without culling and 6.0 ms for three.js on an RTX 3060, 517 ms against 4,428 ms and 944 ms on SwiftShader. Core grows 1,845 bytes gzip (budget 81,500). Recipes cannot declare lods yet. See docs/culling-lod.md.

  • Add relations between parts (part of issue #44, no new tool): a mesh node takes relations (attach, gap, flush, align, centered, up to 8) against other mesh nodes, or against the faces of one carrying a mesh tag (region). They work on world bounds, are solved after geometry exists and again on every scene_apply, so one edit to a body keeps the parts that sit against it. Unknown IDs and tags, two relations on one axis and cycles (a part waiting on its own child included) are rejected with the next action; solving is deterministic and independent of node order. The code loads on demand (relations). The schema carries only a generic relations list (597 bytes over scene_create and scene_apply together); the kinds and fields are in scene_capabilities relations, and the engine validates them. Measured on Sonnet (3 runs each), relations did not cut tool calls or errors: the kettle resize took 3.3 calls against 3.0, and a 12-part desk with three inspected resizes took 8 against 8, with 13% fewer output tokens (3,833 against 4,403) and the same cost and pass rate. The suite gains kettle-resize, desk-resize and their plain twins, and touches and centreAt checks.

  • Add render passes, depth of field and camera motion blur (issue #54, first slice). Render jobs of kind image or stills take settings.passes (albedo, normal, emission, depth, objectId) and write each as a raw, unantialiased PNG beside the lit image (render-depth.png, frame-3-objectId.png); depth is 16 bits over 100 m in red and green, object IDs are 24 bits with the part names in the job metrics. In code, renderer.render({ pass }) draws a pass into its own non-multisampled target. effects.depthOfField (blur, focusDistance) and effects.motionBlur (shutter) are new recipe effects: fixed sample patterns and a per-pixel rotation from the pixel position, so a seek to a frame repeats the same pixels. They live in the new 67js/addons/camera-effects entry; the preview installs it, and the core renderer only gains a stage hook and the pass branch (a compiled-out shader feature). Motion blur follows camera tracks only, sampled from time at motion.start + elapsed - shutter. Measured on SwiftShader through MCP (npm run smoke:render-passes): 8 stills with 5 passes each, then four seeks, all byte-identical to the same frame in the sequence. Temporal anti-aliasing, accumulation and the compositing graph of #54 are not part of this slice.

  • Expose clip layers, bone masks and name retargeting through MCP, and morph clips in createAssetPose (issue #59, in part). An asset recipe's motion.layers (up to 8) plays the file's own clips at motion time with a bone mask, weight, speed, offset, loop, additive with reference, bones (clip track to another asset node) and morph, before tracks and IK, so a character walks and waves at once; everything is checked against the asset and bounded, and a seek equals playing. morphClipFromGltfAnimation and a layer's morphs put morph weights through createAssetPose (masks pick parts by their owning bone), createAssetLayerEvaluator serves hosts that stage the pose themselves, and asset.stagePose takes morphWeights. Add the robot-walk-wave task to the agent modeling suite and extend npm run smoke:character. Not done: foot tilt on slopes, full-body IK, and rest-pose retargeting from another asset through MCP. Raise entry:skeleton-pose to 19,000 and entry:agent-asset to 85,200 bytes gzip, and the tool schema budgets by 800 bytes (scene_apply to 47,800, scene_create_asset to 20,150, total to 190,700).

  • Use one expression language for fields and drivers (issue #98). src/expression.js holds the limits, number literals, operator table, syntax and hostile-input checks; src/mesh-fields.js (per mesh element: attributes, noise, random, vectors) and src/motion-expression.js (per time: time, node reads) only add their own inputs, and each rejects the other's with a message that names the context. This changes driver expressions (neither language was released): an operator with one operand may be written bare, {"neg": x}, in drivers as in fields; if takes its second operand when the condition is not 0 (a driver used above 0); sqrt of a negative, pow overflow and mod by 0 give 0 instead of an error; smoothstep with equal edges is a step; div by 0 is still a non-finite error in a driver, because a hostile-input test pins it, and 0 in a field. Drivers gain ceil, round, sign, lte, gte, eq, and, or, not and booleans; fields gain atan2 and saturate. The unknown-operator hint of fields lists operators in a new order. Error messages for a malformed driver changed in wording and are all TypeErrors. The MCP schema for drivers now points at the field language instead of listing operators (schemas 183,741 to 183,762 bytes), and the scene_capabilities budget rises from 3,050 to 3,100 bytes for two operator names.

  • Add branches and labelled images to the agent tools (part of issue #67, no new tool). scene_apply with a branch name runs the operations on a scratch copy and stores the result in a snapshot store that holds one copy per distinct recipe (8 branches), leaving the scene, its revision and its checkpoints untouched. scene_review shots take a branch and render it in a private scene; scene_restore with branch keeps one. labels: true on scene_look and scene_review draws part names, material tags and mesh lint problems on the image and returns them as JSON with pixel positions. Branch names are bounded (^[a-z][a-z0-9_-]{0,23}$). The tool-schema budget rose by 800 bytes in total (150 for scene_apply). npm run smoke:agent-branches drives it through MCP on SwiftShader.

  • Add a bounded material node graph (issue #50): material pattern of type: "graph" bakes noise, voronoi, wave, checker, gradient, ramp, maths and uv nodes on the CPU into base colour, roughness, metallic, emission and height (a normal map, so bump). The graph is data, never shader text; nodes, depth, ramp stops, texture size and work are checked before any pixel is computed. Add mapping: "uv" to every pattern so it follows uv_unwrap UVs instead of box projection; the emissive map now box-maps like the other maps. The 11 presets bake the same bytes as before. Covered in the MCP schema, scene_capabilities (materialGraph, materialMappings), GLB export, docs/agent-scene.md, docs/material-maps.md and the brick-graph reference scene.

  • Add decimate, remesh and generated levels of detail (issue #40). decimate (a ratio of triangles) is a quadric edge collapse of our own that keeps open boundaries, the borders between tags and the tags themselves; it measured 0.25 to 0.85 of the Hausdorff error of meshoptimizer 1.3.0 on the same meshes and adds no dependency, but takes about 2.5 s on 100k triangles where meshoptimizer takes 0.09 s. remesh (voxelSize or resolution, at most 192 per side and 4,194,304 cells, checked before allocation) builds a closed quad surface from a BVH signed distance with surface nets. Both are edits and stack nodes, in the MCP schemas, and load on demand with the mesh code. generateMeshLods, generateGeometryLods and generateAssetLods (also in 67js/addons/mesh) return levels with a measured error for runtime selection (issue #37). Four decimate and two remesh cases join the Blender comparison, compared by volume, area and Hausdorff distance because face counts differ.

  • Make the default look good without tuning. Recipes get an image-based environment: environment.setup (daylight by default, overcast, sunset, studio) selects a small procedural sky map generated in code, plus its key light, with environmentIntensity and environmentRotation; no URLs or files from tool input. effects.ambientOcclusion (0 to 1) and ambientOcclusionRadius add screen-space ambient occlusion from the depth texture. It is off by default: measured with npm run reference -- --ambient-occlusion, it improved no score by more than 0.002 (strength 0.8: -0.0019 in foliage, +0.0047 in lit-interior; strength 0.4, radius 0.3: within +0.0013 everywhere). When used it compiles and allocates on first use and costs about 16 ms on a 190 ms SwiftShader frame (8 percent). scene_capabilities lists lightingSetups, defaultLightingSetup and ambientOcclusion. This changes the look of every existing recipe that sets no lighting: it now has an environment map, a key color of [3, 2.8, 2.5] instead of [5.2, 4.7, 4.1], and a fill intensity of 0 instead of 1. The engine default is unchanged (occlusion off, no map) so code scenes keep their pixels. Screen-space reflections are not part of this. The scene:lit-box size budget rises by 100 bytes gzip for the environment and occlusion code. The reference suite gets --ambient-occlusion, and its Blender renderer drops triangles that repeat a vertex, which crashed Blender on the skinned character

  • Measure and cut the cost of the MCP tools (issue #65). node scripts/measure-tool-cost.mjs reports each tool schema and each typical result in bytes and estimated tokens (3.5 characters a token). The 22 schemas came to 373,388 bytes (about 107,000 tokens) and are now 173,216 (about 49,500): recipe geometries and asset recipes point to mesh_edit, mesh_stack and scene_create for the mesh edit, stack and motion detail instead of repeating about 45 KB and 35 KB in each tool, and vectors, colours, quaternions and IDs are shared $ref definitions. The backend still validates every field. tests/tool-cost.test.js fails when the schema total, one tool's schema or a typical result passes bench/tool-cost-budgets.json. A small mesh change is 187 bytes as mesh_edit against 1,254 as dispose plus a whole-recipe scene_create on a 7-node recipe.

  • Return diagnostics that name the next action (issue #66). mesh_inspect lint adds intersecting-parts, self-intersection, thin-wall, floating-part and asymmetric warnings from the BVH, with face budgets and a skippedChecks list; they never turn ok off and the agent modeling suite does not grade them. scene_inspect adds diagnostics for material fields the renderer ignores, blended transmission and unused materials or geometries, and asset inspection adds decoder warnings (accepted but not drawn features), skinned meshes with no joints, joints with no skin and assets with no clips. Error messages now list allowed fields, known IDs and the next call: a missing session (the largest group, 21 of 68 recorded errors) names the active session or says to call scene_create, and page errors no longer carry the bundle stack. tests/tool-errors.test.js walks 27 error paths and rejects a message with no next action.

  • Add authored rigs (#46): a recipe armatures list (bones with a name, parent, head and tail, or a humanoid or quadruped preset fitted to a mesh node's bounds, with landmarks to move bones), and a skin on a mesh node that binds it with automatic weights, plus a set-armatures operation. Each bone becomes a recipe node, so keyframed bone rotation and motion.ik run through the same paths as imported rigs, and humanoid bones carry the HUMANOID_BONES names so retargetClip maps them. Weights are the distance to each bone segment with an inverse-fourth-power falloff, the nearest four kept; they depend only on position, so hard-edge seams never open. scene_inspect gains rig: unweighted vertices, bones with no vertices, and joint axis problems (zero-length bones, straight limb chains, knees that bend backward). scene_export_glb writes the bones and a walk clip baked at 30 frames a second from tracks and IK. Add the rigged-walker task to the agent modeling suite, with a reference and three failing variants. Blender 5.2 opens the exported walker as 1 armature, 21 bones, 14 meshes with 21 vertex groups each and 1 action of 24 frames; three.js loads 14 skinned meshes and the clip.

  • Load agent scene code on demand: mesh editing, lathe/extrude/tube, material pattern and motion now sit behind loadAgentSceneModules(recipe) (or loadAllAgentSceneModules()), and createAgentScene throws an error naming that call when a needed module is missing. A recipe of primitives drops from 141,241 to 73,581 bytes gzip in scene:agent-scene (every lazy chunk still totals 145,049). npm run size now bundles with code splitting and reports the initial load, plus a +lazy row for the total. npm test preloads every module. The archive no longer carries 29 docs that the site serves (physics, lighting, terrain and the other addon docs); agent docs stay

  • Add joint limits, node constraints and drivers to motion (issue #58). Two-bone IK takes limits per joint and axis in degrees and bendToward; scene_inspect motionIk now carries limited (each pose a limit changed) and warnings (hyperextended, and wrong-bend for a knee or elbow bent the unnatural way, which a wrong pole used to hide behind reached). motion.constraints adds copy_location, copy_rotation, copy_scale, limit_location, limit_rotation, track_to, child_of (with an inverse and an influence blend) and floor, and motion.drivers sets a node component or material property from a bounded JSON expression over time and other nodes (never run as code). The order is tracks, IK, drivers, constraints, with no state between samples, so a seek equals playing. copy_rotation, limit_rotation, track_to, child_of and floor match Blender 5.2 world matrices in 8 recorded cases (tests/fixtures/blender/constraints.json). Joint limits are also in 67js/addons/skeleton-pose. The leg-plant task joins the agent modeling suite. The expression language is a new small one in src/motion-expression.js: the field expressions of the mesh addon were not on main yet

  • Reach Rapier from recipes: a physics section (and a set-physics operation) puts rigid bodies on node IDs with box, ball, capsule, convex or trimesh colliders fitted to their geometry, joints, gravity and a duration of up to 10 seconds. It is recorded once at 60 steps a second and seeks like motion, so a seek back repeats the same frame (checked as identical PNG bytes on SwiftShader through MCP). scene_inspect reports per-body final positions and resting times, contacts and sensor enter and leave events. Rapier stays an optional peer, served to the preview from node_modules like Manifold, so the MCP server bundle does not grow.

  • Add trimesh and convex-hull colliders (bounded triangle and point counts, checked before allocation), sensors with enter and leave events, and 16-bit collision groups and masks to addons/physics, plus contactEvents, restFrames, bakePhysicsScene, loadPhysicsEngine and setPhysicsModuleLoader. A collider with sensor now bakes instead of throwing.

  • Add the tray-drop task to the agent modeling suite: balls dropped into a pocket cut in an authored mesh, graded on a fixed trimesh body, balls resting on the pocket floor and a repeatable seek. Raise four size budgets for the physics code (entry:physics to 17,900, entry:agent-scene to 121,100, entry:agent-asset to 128,500, scene:agent-scene to 147,300 bytes gzip).

  • Add bounded field expressions: a JSON language of math, comparison, logic, vectors, seeded noise and attributes (position, normal, index, tags) that compiles once to closures over typed arrays and never executes a string. It limits nodes (64), depth (12), elements (250,000) and node-evaluations (8 million) before it evaluates, and only reads operator names from a fixed table. It drives a { "field": expression } face selection rule, set_position and displace as edits and stack nodes, and a where filter for instances. displace and set_position match Blender's Displace modifier and a Geometry Nodes Set Position node in five new golden cases

  • Add instances on a recipe node: repeat its geometry at the points of a grid, a seeded scatter in a box or the surface of a geometry, with where, yaw, alignToNormal and scale, at most 2048 candidate points. It expands to ordinary nodes that share geometry and material, so the renderer draws one instanced batch. Add the pillar-court task to the agent modeling suite

  • Add the scene_export_glb MCP tool (22 tools now) and morph weight clips in exportGlb. The tool writes the active recipe or imported asset scene as a GLB under <jobs>/exports/ with a server-chosen name and returns the path, byte count and SHA-256; it takes no path, keeps the newest eight files and refuses more than 32 MiB. It exports the current pose (pattern textures, imported textures, skins, morph weights, IK as posed), motionTime seeks authored motion first, and clip adds an imported asset's source clip. Clip tracks with property: 'weights' write a SCALAR sampler of one weight per target. Checked in Blender 5.2: a patterned recipe opens with 2 meshes and 3 images, the robot with IK opens as 1 armature, 43 bones and 20 meshes, and its Walking clip as one action of 23 frames. Nothing in src/index.js changes, so no size budget moves

  • Add material layers: clearcoat and clearcoatRoughness, transmission with thickness, ior, attenuationColor and attenuationDistance, sheenColor and sheenRoughness, and specular and specularColor. Recipes, the MCP schema, glTF import and export (KHR_materials_clearcoat, transmission, volume, ior, specular, sheen) all take them, each checked at the boundary. Transmission refracts the opaque scene like the liquid material. Anisotropy and iridescence are not rendered yet. Import of those two still warns

  • Change the glTF import of the six layer extensions above from accepted-and-ignored to rendered, so asset.warnings no longer lists them

  • Add spot lights (environment.spotLights, 8), rectangular area lights (environment.areaLights, 4) and shadows for point and spot lights (castShadow: true). Intensity of a spot light is candela, as for a point light, with Blender's cone mask. Area lights use a representative point, within 1.2 percent of Cycles on the axis. Shadows share one 2048 x 3072 depth atlas of 24 tiles (24 MiB, allocated on first use): a point light takes 6 and a spot light 1, and a request for more is an error. The shader code and the atlas exist only in a scene that uses them. Recipes get all of it through set-environment, the MCP schema and scene_capabilities (maxSpotLights, maxAreaLights, localShadows). Cascaded directional shadows and light linking are not part of this

  • Add ten cutting and repair edits: fill_holes, dissolve_faces, dissolve_edges, dissolve_verts, dissolve_limited, bisect_plane (with fill, clearInner, clearOuter), bridge_edge_loops (with segments), subdivide_edges, grid_fill and knife_project. Each tags what it makes, and the edge rule { "open": true } picks boundary edges. The lint message for an open boundary now suggests fill_holes. 18 new cases match Blender in counts, face sizes, area, volume and positions; the knife is compared only with a straight plane cut and differs where a face runs along the projection direction

  • Export textures, skeletons and clips to GLB: exportGlb(parts, { nodes, clips, maxTextureSize }) now writes map, normalMap, metallicRoughnessMap, occlusionMap and emissiveMap as embedded PNG (limit 2048 px by default, with an error that names the option), skins with joint nodes and inverse bind matrices, and animation clips (translation, rotation and scale tracks; SMOOTH becomes cubic with zero tangents). Pattern materials export their baked textures with box projected UVs, so the picture matches without uv_unwrap. It previously threw on skins and on every texture channel. The entry:core size budget goes from 67,100 to 70,500 bytes gzip (+3,400)

  • Make the first frame and the SwiftShader frame cost less, with the same pixels. The main fragment shader now compiles only the features that a scene uses (maps, splat layers, moss, alpha and the special material tags), and a part that needs another feature later recompiles it. All programs, with the environment prefilter, now start together and use KHR_parallel_shader_compile. On an RTX 3060 the first frame went from 3.7 to 4.4 seconds down to 0.5 to 1.0 seconds, and a SwiftShader frame costs 0.4 to 0.5 times what it did. bench/runtime/PROFILE.md has the profile

  • Add subdivide as a mesh edit and stack node: Catmull-Clark subdivision to 4 levels with semi-sharp creases picked by an edge rule, sharp boundaries, kept corners, n-gon support, and tags, UVs and edge attributes carried through each level. The size is checked before it allocates. Counts, area and positions match Blender at levels 1 to 3; the pebble task joins the agent modeling suite

  • Remove 67js/addons/film from the npm package. It held the 187-second trailer demo with its baked physics recording, 75 KB gzip of the archive. Nothing else in the package used it. To keep using it, copy src/film.js, src/film-rig.js, src/film-character.js, src/film-physics-definition.js and src/film-physics-clip.json from the repository, or read the trailer on the site at /film.html. The archive goes from 901,314 to 829,085 bytes

  • Remove three.js from modeling and the agent scene: lathe, extrude and tube no longer import it, and scene:agent-scene drops from 185,681 to 117,290 bytes gzip. lathe and tube output is identical to before, vertex for vertex. extrude walls, bevels, UVs, normals and bounds are identical, and volume matches within 1e-4. Extrusion caps use a new ear-clipping triangulation, so a cap can split along other diagonals, and a cap with collinear points can add or drop a seam vertex. A clockwise hole under a clockwise contour is now flipped to face outward, where it used to keep inward walls

  • Load glTF without Three.js: the addon has its own GLB and glTF parser, node sampler and animation clips, so a box with the addon drops from 159,422 to 67,467 bytes gzip. Draco, meshopt and KTX2 still come from the decoders you pass in options.decoders. Only the default scene is decoded, and a node outside it is decoded only when a skin or an animation names it

  • Remove three.js and three-mesh-bvh from mesh queries, shrinkwrap and surface patches: a typed-array BVH and its own triangle tests replace them, so no source file in src/ except the benchmark page imports three.js and the npm archive drops from 856,115 to 798,532 bytes. entry:mesh-query drops from 85,555 to 15,535 bytes gzip, entry:shrinkwrap from 86,779 to 17,860 and entry:surface from 72,974 to 9,838. Nearest, project, raycast and pair results match three-mesh-bvh on fixtures and random queries. Nearest queries on 100k triangles are about 20 percent slower and a pair query with one mesh shifted against itself is slower (21 ms against 2 ms), while a closed-solid pair is 2.4 times faster. The surface patch clipper follows DecalGeometry and keeps its triangle order

  • Update the bundled zod to 4.6.7, which fixes a memory exhaustion advisory in the validation of oversized collections

  • Make the MCP preview server reject requests with another Host header, which closes DNS rebinding

  • Check the size of a mesh array before it allocates. Before this, the check ran after the copies existed

  • Change the bevel profile to the meaning it has in Blender: 0.5 is a circular arc, 0.25 is flat, 1 is square, and below 0.25 is concave. Before this, 0 was flat and 0.5 was a parabola, so a recipe with a profile other than 0.5 changes shape

  • Stop adding a fan of triangles where one beveled edge ends at a vertex with three faces. The third face now takes the profile's points, as in Blender

  • Add multiple scattering to the direct light specular, as the environment specular has it (part of #167): each light's specular is scaled by the gain from the BRDF table, sampled once per fragment, wherever an environment map is bound. metal goes from 0.0974 to 0.0962 against Cycles (EEVEE 0.0916) and material-spheres from 0.1234 to 0.1185; no scene is worse by more than 0.0002, and the frame cost of brick-flat and metal is unchanged within timer noise.

  • Look up an object probe along the ray from its centre to where the reflected ray meets the floor under it, so chrome shows the floor next to its contact point where the real ray lands (part of issue #167). metal goes from 0.0962 to 0.0957 against Cycles; car-paint, brushed-film and material-spheres also improve and no scene gets worse.

  • Record that casting the part's own shadow onto its reflection probe does not close the metal gap (part of #167, which stays open): a shadowed floor in the probe fixes the bottom edge of the chrome sphere but overshoots the rest, metal 0.0962 to 0.1038, and the floor is not explained by screen-space occlusion either. No engine file changed; the measurements and the parallax-corrected probe that would be needed are in ench/reference/README.md.

  • Add multiple scattering to the environment specular (part of issue #167). environmentLighting in src/environment.js adds the energy a rough microfacet surface bounces a second time (Fdez-Aguera 2019), as Cycles' multiscatter GGX does, so rough metals are no longer dark: metal goes from 0.1036 to 0.0974 against Cycles (EEVEE 0.0916). See bench/reference/README.md.

  • Ground bounce reads the mean of a floor's base-colour texture (linear space, once per image) instead of skipping textured floors (part of issue #191, which stays open): no reference scene has a textured floor, so no score moved; terrain and a bounce under the foliage crown were measured and worsened mountain-valley by 0.0019 and the crown by 0.002, so they are not kept (bench/reference/README.md).

  • Water reflection draws its picture at three quarters of the canvas instead of half and blurs it less, so a river between towers keeps the sharp window bands Cycles mirrors: megacity-dusk-a 0.2072 to 0.1999 (no reflection 0.2084), megacity-dusk-b 0.1459 to 0.1242, mountain-valley-a 0.1946 to 0.1924 against Cycles on the current main (#195).

  • Tried darkening the ground bounce by the share of ground around the parts that sees the sky (part of issue #197): the studio shadow floors moved 0.02 to 0.2 toward Cycles but material-spheres FLIP rose 0.0093 and brick-flat 0.0061, so nothing was kept and the measurements are in bench/reference/README.md.

  • Remeasure shadow depth against Cycles on main for the grand options and the sunlit scenes (part of issue #197, which stays open): dark percentiles, shadow floor, lit-to-shadow contrast and edge width, plus three single changes (no ground bounce, ambient occlusion, less world light) that each failed the 0.002 FLIP limit. No engine change; see bench/reference/README.md.

  • The sun shadow now follows the sun (part of issue #206). When shadowBounds gives no eye, Renderer67 and the cascaded shadows derive it from environment.lightDirection (src/shadow-light.js) and redraw the map when the sun moves, and every reference scene aims its shadow map along its own sun; before, the default eye and several scene eyes sat a few degrees off the shading sun.

  • Fix the sun reaching surfaces that sit behind an open single-sided surface (part of issue #206). The sun shadow pass culled back faces, so a ray that entered a single-sided mesh from behind, such as the open edge of the terrain, wrote no depth and the sun passed through the rock. The shadow depth pass now draws both faces (applyAlphaState in src/renderer.js). mountain-valley with the world light at 0 reads 0.0000 on the floor (0.1727 before, Cycles 0.0003) and scores 0.1792 against Cycles instead of 0.2612; every other reference scene is unchanged to four digits and a shadow map redraw costs 0.05 to 0.1 ms more. The foliage crown leak is not this cause and stays open. See bench/reference/README.md.

  • The sun shadow's depth bias is now a world distance, slope times 3.5 shadow texels converted with the light's extent and far minus near, so the same scene gets the same bias in metres for any depth range; it removes the self-shadow stipple the sun-aligned map put on sloped walls (part of issue #225).

  • Fix the "bright river" of megacity-dusk-a (part of issue #232): the river, and the bay of megacity-dusk-b, stood in the same plane as the ground box, and Cycles picked one of the two surfaces at random per ray, so the Cycles river reflected about a third of a mirror and 67js looked too bright by comparison. Both water boxes now stand 1 cm above the ground, in the reference scenes only; the engine is unchanged. See bench/reference/README.md.

  • Measure the bright river of megacity-dusk-a with the sun off on both sides (issue #232, which stays open): the canyon walls and the street are slightly darker than Cycles under sky light alone, and removing all ambient light from the river closes only about a third of its excess, so the cause is the water's reflection, not missing sky visibility. render-blender.py gained --sun-strength; the numbers are in bench/reference/README.md.

  • Derive ground bounce from the scene: groundBounceEnvironment (67js/addons/ground-bounce) finds the floor part and gives the environment map a diffuse-only copy whose lower half is the light the floor sends back up, so walls and figures on an open floor get bounce light with no bake and no frame cost (brick-flat 0.1264 to 0.0547 against Cycles, brick-graph 0.1518 to 0.0982, eight more scenes better, none worse by more than 0.002; closes #244).

  • Score 67js and EEVEE with the same quantisation (part of issue #258). bench/reference/score.py read 67js from an 8-bit PNG but EEVEE from a float array; it now rounds the EEVEE array to 8 bits too (load_eevee), and tests/reference-quantisation.test.js pins it. The EEVEE columns of baseline.json were regenerated from the stored arrays where they reproduce the committed numbers: foliage EEVEE against Cycles goes from 0.0888 to 0.0924, and no scene changes order against 67js (metal becomes a tie at 0.0944). Some cells and grand.json need a full reference run. See bench/reference/README.md.

  • Record that a graph bump scale per world unit (normalScale [0.8, 1.2] on the 6 by 4 brick-graph wall) does not improve it against Cycles (0.1518 to 0.1525, nothing kept) and that the brick-face colour gap is Cycles-only light, not the colour path (part of issue #50). See bench/reference/README.md.

  • Take the sky light below the surface plane out of the ambient term for a mapped normal, as Cycles does, so the edges of a bump read as dark as Cycles draws them (part of issue #50). brick-graph goes from 0.1584 to 0.1518 against Cycles (EEVEE 0.0875 to 0.0844) and no other scene changes.

  • Compile the two fill lights out of the main fragment shader while fillIntensity is 0 (part of issue #74). A uniform branch did not skip them on SwiftShader, a FILL_ON macro does, and a renderer rebuilds its program once if the intensity later rises above 0, as for spot lights. Pictures are byte identical in all 8 runtime scenes; the SwiftShader frame of skinned-characters goes from about 161 to 125 ms, transparency from 364 to 341 ms and instanced-objects from 100 to 94 ms. The size budgets of the three scene bundles rose by 100 bytes. See bench/runtime/PROFILE.md.

  • Make the sun shadow filter one hardware comparison fetch per tap instead of four texel fetches (part of issue #74). The shadow depth texture now compares on fetch with linear filtering (TEXTURE_COMPARE_MODE), so the 9-tap filter costs 9 fetches, not 36, with the same result (every reference scene is within 0.0001 of Cycles before and after). On SwiftShader, alternated with three.js, the frame fell from 8.4 to 7.1 times three.js on transparency, 7.6 to 6.6 on skinned-characters, 5.5 to 4.0 on instanced-objects and 3.8 to 3.5 on moving-shadows. The fog volume reads the shadow through the same sampler, so its single tap is now filtered over 2 by 2 texels. Cutting the filter to 4 taps saved only 4 percent more and was not kept.

  • Fog near a glowing window or a lamp now picks up that light (part of issue #164). fogSkyVisibility also builds a grid of the light that emissive parts and point lights give their surroundings (fogBounceGrid in src/fog-bounce.js, one bounce, 64 rays per cell, built once per scene and fog box) and the post shader adds it to the fog's scattering. The temple-hall fog region against Cycles goes from 0.2611 to 0.2421, past EEVEE (0.2455), and the baked one from 0.2335 to 0.2236; scenes without emissive parts or point lights, and scenes without the option, draw as before. The sun's bounce is left out because it made dark-shaft worse.

  • The fog's ambient in the sun's shadow now follows a per-point sky visibility when Renderer67 gets the new fogSkyVisibility option from src/fog-sky-visibility.js (the agent preview and the reference harness pass it). It casts 24 upward rays from the centre of each cell of a grid of at most 2,048 cells over the fog box, once per scene and fog box, and uploads one 8-bit 3D texture; fog that sees any sky keeps all of the ambient and fog that sees none keeps 0.1 of it. Without the option, without volumeFog, or when a recipe sets shadowAmbient, the post shader has the sampling compiled out and draws as before. Against Cycles on the GPU: dark-shaft 0.0607 to 0.0559 (region 0.1802 to 0.1282), temple-hall 0.0674 to 0.0640 (region 0.2723 to 0.2611; baked region 0.2439 to 0.2335), fog-room 0.1049 to 0.1036 (region 0.2405 to 0.1625); every other scene is unchanged to four digits. The temple-hall region without a bake does not yet beat EEVEE (0.2455). The core entry grows 141 bytes gzip (part of issue #164).

  • An unset volumeFog.shadowAmbient is now derived from the scene instead of fixed at 0.15. Pass skyOpenness from src/closed-room.js to Renderer67 (the agent preview and the reference harness do) and it shoots 32 upward rays from the middle of the fog box, once per scene and fog box: a closed room keeps 0.15, open ground under a sky gets 1, a partly covered scene lands between. Without the option an unset value stays 0.15, so existing renderers draw as before. A recipe that sets the value keeps it, and the recipe echo no longer lists shadowAmbient when it was unset. The fog-valley reference scene no longer sets it and scores the same 0.1855 against Cycles (EEVEE 0.1952); dark-shaft and fog move by 0.0012 and 0.0014 (better) and temple-hall by 0.0015 (worse), the rest are unchanged (part of issue #165).

  • Add volumeFog.shadowAmbient (0 to 1, default 0.15, the value that was hard coded in src/post.js): the share of the fog's ambient that stays where the sun's shadow covers it. A closed room sees little sky, so 0.15 holds and no existing recipe changes. Open ground under a sky sees all of it, so fog-valley sets 1 and goes from 0.1967 to 0.1855 against Cycles, past EEVEE's 0.1952 (part of issue #165). Measured on the glow weight and the shadow floor first: the glow weight lowered fog-valley only at the cost of fog (+0.02) and temple-hall (+0.008), and a global floor of 0.4 cost fog-room +0.04, so neither could be one constant for rooms and open ground.

  • Trace one bounce in object probes and let the probe's surfaces mirror the sky (part of issue #167). traceProbeMaps also stops overwriting a hit's direct light with the light of the last neighbour the gatherer visited, which is why #209's bounce made the probe floor darker. Against Cycles on the GPU metal goes from 0.0964 to 0.0944 (EEVEE 0.0916), metal-room 0.5071 to 0.5045, material-spheres 0.0956 to 0.0954, car-paint 0.0979 to 0.0978, and brushed-film 0.1017 to 0.1019. The probe trace takes about twice as long (metal 0.12 s to 0.25 s); a scene with no reflective part never runs it.

  • Record three object probe measurements that were not kept (part of issue #167, which stays open): a depth-based parallax lookup (metal 0.0962 to 0.0957 against Cycles, with stepped edges), occlusion of the probe's floor (worse, 0.0982 to 0.1051) and a 1.15 gain on the probe's hits (0.0922 but no better on the other scenes). The probe's lit surfaces are about 15% darker than Cycles shows them. See bench/reference/README.md.

  • Give smooth metal parts a reflection probe by default (part of issue #167, which stays open). A recipe part with metallic 0.5 or more and roughness 0.6 or less (up to 8 such parts) now gets a probe traced from the scene around it, so a chrome sphere shows the floor and its neighbours; environment.objectReflections: false turns it off and scene_inspect reports reflections. Against Cycles metal goes from 0.1294 to 0.1036 (EEVEE 0.0916), brushed-film 0.1149 to 0.1029, car-paint 0.1059 to 0.1038, material-spheres 0.1312 to 0.1293 and metal-room 0.5128 to 0.5076. A scene with no reflective part draws the same parts and keeps its frame time; metal costs about 0.03 ms more on the GPU.

  • Rerun the reference suite under the capped sky with one sun (issue #169): khronos.json and path-tracer.json are rescored against fresh Cycles renders (asset-only 67js against Cycles improved on four of five Khronos assets, for example SheenChair 0.3745 to 0.3316 and ClearCoatTest 0.2306 to 0.2097; the path tracer got worse on outdoor-hdri 0.1016 to 0.1242, character 0.1120 to 0.1289 and material-spheres 0.1187 to 0.1383), and baked scores of lit-interior, brick-room, dark-shaft, temple-hall and metal-room are now stored in bench/reference/bake.json. npm run reference -- --bake <ids> --skip-blender compares a fresh run with it and fails when a score is worse by more than 0.01 FLIP (bench/reference/compare-scores.mjs, tests/reference-bake-regression.test.js, which reads JSON only). --scene takes several ids. The README has one current score table and a History heading.

  • Measure the recipe bake presets and the frame costs on a quiet machine (part of issue #170): draft, standard and fine scored against Cycles on the five room scenes with bake seconds and the settings each preset used, and the frame cost of a baked closed room and of the fog's glow mip chain, each with the GPU and CPU load recorded beside it. frame-time.mjs gains --bake-cost, --glow-mips and --repetitions=N (and prints the range of the per-run medians); the reference run prints used for every preset bake. See bench/reference/README.md.

  • Draw fewer triangles for forests (issue #186). Swaying foliage and grass batches are now frustum culled with a bound that grows with the wind strength, and tree foliage has thinner shadowLods (a third of the leaves, then an eighth) next to the trunk levels from #171. A tree has a fourth level of detail beyond 150 m, with a third of the rings on each limb and crown clumps 1.5 times wider, so createTree returns four levels and TREE_LEVEL_DISTANCES has three entries. mountain-valley draws 2.89 instead of 6.46 million triangles in the main pass and 1.39 instead of 2.34 million in the shadow pass; its score against Cycles stays within 0.001 of before.

  • Measure why foliage crowns and the mountain-valley floor are too light (part of issue #191, which stays open): sky light inside the crown already matches Cycles, and the excess in both scenes is sun light that the sun shadow lets through (bench/reference/README.md). A finer horizon march in terrain-sky.js was tried and not kept because it worsened mountain-valley from 0.2623 to 0.2743.

  • A large flat smooth surface (a lake, a river, a polished floor) now reflects the scene: the new addon 67js/addons/water-reflection draws the scene from the camera's mirror image into a half-size target, with Fresnel, ripples and a slight blur. mountain-valley-a goes from 0.3530 to 0.2562 against Cycles and megacity-dusk-b from 0.1575 to 0.1377. Scenes without such a surface are unchanged (issue #195).

  • Add bench/reference/shadow-depth.py (issue #197), which measures shadow depth of a 67js frame against Cycles from the reference renders: dark percentiles, the shadow tile floor and lit level, lit to shadow contrast and edge width. run.mjs gains --skip-cpu to leave out the slow SwiftShader render.

  • Keep the shadows of a closed room dark (part of issue #197, which stays open for An's blind pick). A world far dimmer than the key light (under 0.01 of it, fading out by 0.06) now gives a quarter of its light where the sun is blocked, so a sealed hall no longer glows from a sky it cannot see. Against Cycles, dark-shaft went from 0.143 to 0.062 FLIP temple-hall from 0.144 to 0.066 and fog-room from 0.195 to 0.105, the three temple-hall options from 0.253, 0.364 and 0.275 to 0.157, 0.152 and 0.102, and the darkest 1 percent of the grand and dark scenes from 1.16 stops too light to 0.68 stops. Outdoor scenes did not move. bench/reference/measure-depth.py measures the darks, render-gpu.mjs draws chosen scenes with measurement switches and depth-sheets.py makes the blind sheets.

  • Stop pull requests from conflicting on CHANGELOG.md (issue #199). GitHub ignores the merge=union driver, so each merge turned every other open pull request DIRTY. A change now adds its own file in changes/ and npm run changes:fold writes the files into CHANGELOG.md as the version's section at release time; npm run changes prints the pending notes. .gitattributes is removed. The earlier unreleased notes moved to changes/000-before-fragments.md.

  • The path tracer now honours light linking (part of issue #215). A light with affects, and the sun with environment.keyAffects, adds nothing at a part it skips, as direct light and at every bounce, and still casts shadows for the others; it reads the same per-part material.lightMask as the renderer and the light bake. report.ignored no longer lists linking. The light-linking scene against Cycles goes from 0.6518 to 0.0213 (the rasterizer scores 0.0998); scenes without links draw the same pixels as before, and the reference harness now passes its path-traced scenes through applyLightLinks.

  • Fix the path tracer drawing rough dielectric surfaces too dark at grazing views (part of #215): the diffuse layer was dimmed by the mirror Fresnel term of the view angle, so a rough floor lost most of its light toward the horizon (outdoor-hdri floor 0.21 against Cycles' 0.47 near the horizon, 0.42 against 0.47 in the front). The diffuse layer now loses only the specular layer's directional albedo for the surface roughness (Karis's fit of the split-sum BRDF), as Cycles' Principled BSDF does. The capped one-sun sky was not the cause: a floor lit from above measures 0.466 in the tracer, the closed form gives 0.458 and Cycles 0.468. FLIP against Cycles in bench/reference/path-tracer.json falls on 14 of 16 scenes (outdoor-hdri 0.1242 to 0.0226, character 0.1289 to 0.0287, material-spheres 0.1383 to 0.0449, glass 0.1406 to 0.0385, foliage 0.1753 to 0.1001, lit-interior 0.2167 to 0.0769, long-street 0.1818 to 0.0291). light-linking rises from 0.6241 to 0.6518 because the tracer still ignores affects and now lights every part more brightly.

  • Add a cabinet resize task and --relations on|off to the agent suite (part of issue #44, which stays open). cabinet-resize and cabinet-resize-plain ask for a 30 percent wider, 10 cm taller edit of a 10-part cabinet; --relations off removes the relations field and capabilities entry from the MCP tools. Measured on Haiku and Sonnet, 3 runs per arm: tool calls do not drop with relations in the start recipe (Sonnet 3 calls on the cabinet and 8 on the desk in every arm), but Haiku passes the cabinet 3 of 3 with relations against 1 of 3 without.

  • Compare the graph bump with Blender's Bump node (part of issue #50, no engine change): the formula has the same form, and the scale differs by 1.25 along U and 0.83 along V on the brick-graph wall. Matching Blender's scale moved brick-graph against Cycles from 0.1602 to 0.1599, so the scale is not the gap; the measurements and the Blender source are in bench/reference/README.md.

  • Agent modeling suite: look-pick offers three colour grades and checks the picture the exported recipe draws (mean brightness, clipped and crushed shares), so the pick cannot be traced from numbers. Branches saved no calls on it (#67).

  • Add the suite task light-pick-hard for branches (part of issue #67): a gallery with six thin posts and five places for one spotlight, where the place that leaves the least of the painting in shadow (10 per cent against 24 to 37) can only be told by rendering each place or tracing 6 posts by hand. litPainting gained blockers and least, and samples a 41 by 21 grid of the painting. The reference and the wrong places and shortcuts are graded in tests/agent-modeling-suite.test.js. Calls with branches on and off are in bench/agent-modeling/README.md.

  • Measure the lit shader cost on SwiftShader (part of issue #74, which stays open): three pixel-safe changes (shadow taps without clamp, no shadow filter on pixels facing away from the sun, multiplications for two pow calls) were each alternated with the unchanged file and none beat the noise (0.5 to 5 percent, or 3 to 5 percent slower), so none is kept. With MSAA and the HDR target off on both sides 67js is 2 to 4 times three.js in the three scenes (it was 5.2 to 5.7 on 2026-11-01), and a constant fragment shader costs the same as the lit one in the busy machine state, so the lit shader is not the proven bottleneck. See bench/runtime/PROFILE.md.

  • Add the opt-in shading: 'light' renderer option for weak machines and software rendering (part of issue #74): at most 2 MSAA samples, one sun shadow fetch, a fitted environment BRDF, the sky reflection taken from the blurred irradiance, first order irradiance only and a cheaper direct specular term. The default 'full' shader is unchanged pixel for pixel; bench/runtime gains the 67js-light engine and docs/guide.md lists the option.

  • Bring the light linking and path tracer rows of docs/parity.md up to date with issue #215: recipes reach light linking, the path tracer honours it, and the darker floor was the diffuse layer at grazing angles.

  • Add a showcase page (showcase.html) of live scenes built from real PBR models: an airport ramp, an AI data center and a container port, each a GLB with a Poly Haven sky and credits in public/showcase/<id>/scene.json. The home page gallery shows these scenes instead of the older demos.

  • The home page and the docs use the CodePawl site theme from codepawl.com: a white page, light grey cards without borders, one black primary button, system type and a faint dot grid behind the hero, with a matching dark theme that follows the system. src/site.css replaces the layered overrides of home.css and site-theme.css on those two pages. The demo pages keep their own app UI. The brand reads "67js" without a dot on every page.

  • Filter mipmapped material textures anisotropically (8x, or less where the GPU caps it). Only terrain texture arrays had it, so glTF floors, roads and aprons seen at a grazing angle fell to a blurred mip level. The far apron joints of the airport showcase read sharper; core grows 40 bytes gzip.

  • The dev server scans only the project's own pages for dependencies and does not watch .claude/. With a few hundred agent worktrees there, the first page load went from 13 s to 1.2 s, and the runtime benchmark no longer times out opening its harness.

0.14.0

  • Add motion.ik to imported assets: IK runs over the selected clip and overrides, moves every skin and rigid part, and takes worldForward, so agents can pose imported characters through MCP without writing quaternions
  • Add npm run smoke:character, which takes a real CC0 character through the MCP server along the path an agent uses

0.13.1

  • Add createAssetPose, which poses a loaded glTF asset's whole hierarchy so every skin and rigid part moves, and clipFromGltfAnimation, which converts its clips for layers and retargetClip
  • Add worldForward to aim IK, because bone axes differ between real rigs
  • Accept skin weights one unit of Float32 rounding above 1, which exporters write and which made such files fail to load

0.13.0

  • Add motion.ik to procedural recipes: two-bone and aim solvers on node hierarchies, with fixed, keyframed or node-following targets, so agents can animate jointed models without writing quaternions; scene_inspect reports whether each solver reaches its target across the clip
  • Add 67js/addons/skeleton-pose: clip layers for skinned rigs with joint masks and additive blending, two-bone IK with poles and aim IK with angle limits and shared chains, all seekable, with joints named by rig name or humanoid bone

0.12.0

  • Add the recipe material field pattern: eleven seeded, tileable procedural surfaces (wood, planks, bricks, tiles, marble, stone, concrete, metal, rust, fabric, noise) that need no UVs, keep their real size under node scale, and can change while a scene is open
  • Add periodic gradient, ridged and cellular noise for those patterns
  • Close extrude solids whose holes have aligned edges: their caps left T-junctions, so the mesh was open and booleans refused it
  • Let mesh_inspect take geometry as well as geometries, matching mesh_edit and mesh_stack
  • Say in the MCP schema that box and cylinder are bevelled by default, and how to get exact sizes

0.11.0

  • Add 67js/addons/grass: terrain-following grass fields of clumped, curved blades with rounded normals, root-to-tip colour, dry patches, masks for paths, four presets and tile level of detail
  • Bend grass tag vertices by blade height and roll wind gusts across the field as a travelling wave
  • Break up grass fields with patchiness (short, thin and dense patches), seed stalks and folded blades, and let sunlight glow through backlit blades
  • Add 67js/addons/clutter: pebbles, chipped rocks with moss, twigs and fallen leaves scattered over terrain in streamed tiles, with four presets
  • Share one tile and level-of-detail system between grass and clutter
  • Add a moss layer to standard materials: its own rough, sheened, light-wrapping material with a sharp shading mask and a blurred cushion mask; clutter rocks use it
  • Add splat parallax (default 0.03 m) for near-ground relief from the layer height maps
  • Add splat variation (brightness and hue drift at three scales that grows with distance) and edgeNoise (ragged layer borders), both on by default
  • Add uv_unwrap as a mesh edit and stack node: seams from an edge rule, automatic cuts until each island is a disk, least-squares conformal maps, axis charts for closed or stretched islands, area-even scaling and shelf packing into 0..1, with a report of islands, flipped triangles, area distortion and utilization
  • Teach the build-67js-scene skill mesh modeling: a workflow, face and edge rules, tested recipes (crate, pillar, drum, bracket, bench row, planter, soap) and an error table; a test builds every recipe in the reference and requires a clean lint
  • Shrink the MCP server bundle from 1,072 KB to 590 KB by keeping the scene engine out of it: capabilities and default limits now come from plain-data modules (agent-scene-capabilities.js, mesh-operations.js), and the MCP build fails if engine code returns; the npm archive drops from 1,003 KB to 887 KB
  • Add 67js/addons/mesh, a polygon mesh core for agent modeling: compact MeshData with attributes on point, edge, face and corner domains, a half-edge EditMesh with typed-array disk and radial cycles, validateTopology, conversion from renderer geometry with welding, quads and axis face tags, hard-edge corner normals, n-gon triangulation, render extraction and lintMesh
  • Add semantic face selection and mesh edits (extrude region and individual, inset region and individual, delete, flip normals, translate with proportional falloff, merge by distance, tag) that tag the faces they create
  • Add the recipe geometry type mesh (a base shape plus a replayable edit log) and the mesh_edit MCP tool, which appends or replaces edits atomically and reports each edit's result
  • Add loop_cut: edge rings across quads picked by an edge rule (including along a direction), evenly spaced cuts or one cut at a factor, band tags, T-junction-free neighbours and interpolated UVs; and alongNormals for extrude_face_region, which extrudes rings and curved bands as one joined region
  • Add edge bevel as a mesh edit and stack node: rim, angle, region-border or all-edge selection, width, segments, profile and overlap clamping, with sliding corners and smooth triangular patches where three rounded edges meet
  • Add mesh booleans (union, difference, intersect) through Manifold WebAssembly as the boolean edit with an inline primitive cutter, tag transfer and polygon rebuilding; manifold-3d is an optional peer dependency, which the MCP runtime serves to its preview page when installed
  • Add mirror, array and solidify as mesh edits and as a non-destructive modifier stack evaluated after the edits, with every prefix cached, and the mesh_stack MCP tool to set the stack or apply its first nodes into the edit log
  • Report hollow cavities as valid in lintMesh instead of as inverted parts
  • Add the mesh_inspect MCP tool: polygon counts, face sizes, parts, face tags, bounds and lint problems with suggested fixes for every recipe geometry

0.10.0

  • Add 67js/addons/terrain for seeded, chunked heightfields with distance level of detail and heightAt for placement
  • Add 67js/addons/texture-set with loadTextureSet and loadLeafTextures, and a four-layer splat material with slope, height and mask rules, height-blended edges, triplanar cliffs and anti-tiling
  • Add 67js/addons/vegetation for seeded trees, bushes, grass and flowers with real branches, Poisson-disk scattering, wind and three levels of detail
  • Accept scanned bark (barkTextures) and scanned leaf cards with normal maps (leafTextures) on trees and scattered vegetation
  • Add 67js/addons/spume to play back liquid baked by the Spume solver, with refracting liquid and soft foam materials
  • Add 67js/addons/vehicle for path-driven wheel spin, steering, body roll, pitch and ground following
  • Add 67js/addons/retarget to move humanoid clips between Mixamo, VRM, Unreal and Rigify rigs and offset crowds
  • Add 67js/addons/hdri and environment maps for image-based lighting with roughness-blurred reflections
  • Add alpha mask, alpha blend, opacity and double-sided materials, with alpha-to-coverage under MSAA
  • Import Draco, meshopt and KTX2 compressed glTF assets, texture transforms and GPU instancing
  • Let agent recipes author liquid, foam, glass and double-sided materials and liquid optics
  • Let streamed parts such as liquid frames share a renderer with retained textured parts
  • Reduce sky reflection on leaf and grass cards so grazing cards no longer turn grey-blue
  • Serve the CC0 textures and HDRI from the site with open CORS, and credit Poly Haven and ambientCG
  • Rewrite the README and add CONTRIBUTING.md

0.9.1

  • Synchronize the roadmap and standalone command with the visual review release

0.9.0

  • Add scene_review to compare up to four labeled camera, motion or imported clip samples in one PNG
  • Preserve source recipes, revisions, preview poses, viewport dimensions and checkpoints through isolated reviews
  • Bound review dimensions, image bytes, pending frames, sampled memory and private-render deadlines
  • Restore the source preview after failed shots and release private renderers during connection closure
  • Document the agent review workflow and verify independent shots through actual CPU-rendered pixel comparisons

0.8.1

  • Refine the film scientist with integrated facial surfaces, inset eyes, swept hair and a shorter neck
  • Add independent blink, brow, mouth and gaze channels with deterministic cues for each set
  • Replace repeating actor motion with held poses and preserve shared geometry through backward seeks
  • Verify eyelid coverage across the complete eye aperture and render isolated blink comparisons on CPU

0.8.0

  • Add stable imported source-node IDs, hierarchy inspection and local joint overrides.
  • Add authored joint, material and camera motion on imported GLBs with independent clip timing.
  • Preserve decoded rigs, morphs and textures through staged pose transactions and failed-pose rollback.
  • Verify a textured nine-joint astronaut through native MCP images, stills and video.

0.7.0

  • Author bounded procedural motion in agent recipes with local node, material and camera tracks.
  • Reuse linear, step, smooth and cubic interpolation with looping and absolute-time preview seeks.
  • Validate the complete sampled pose before publishing transforms, material handles or camera changes.
  • Preserve authored recipes, revisions, geometry identities and checkpoints during transient seeks.
  • Sample procedural motion in PNG, still sequence and MP4 snapshot jobs while retaining the source preview pose.

0.6.0

  • Add five MCP tools for asynchronous snapshot rendering, progress, cancellation, results and output release.
  • Render one PNG, eight stills or a silent H.264 MP4 while preserving the source pose, revision and checkpoints.
  • Retain bounded job records and verify completed artifact hashes when reopening the private store.
  • Share the streamed FFmpeg encoder with the offline renderer and keep one pending frame.
  • Prevent repeated MCP builds from embedding the browser preview in the Node server bundle.

0.5.0

  • Add atomic agent commands for creating, removing and rebinding nodes and shared resources, with bounded checkpoint geometry ownership.
  • Reconcile rigid untextured renderer topology while retaining unchanged batches and sharing immutable geometry buffers across draws.
  • Ship the 67js-mcp npm command with a prebuilt SDK server, browser preview and complete bundled dependency licenses.
  • Add twelve MCP tools with strict scene schemas, persistent CPU/GPU previews and bounded PNG responses.
  • Import local catalog GLBs with supported material maps, rigs, morphs and deterministic clip sampling.
  • Retain authored lighting, volumetric fog, grading and directional shadow coverage across edits and checkpoints.
  • Keep renderer sessions alive across edits and close owned browser resources when the MCP connection ends.
  • Add optional agent scene sessions with stable IDs, shared geometry, revision checks, atomic edits and bounded checkpoints.
  • Prioritize agent authoring, visual feedback and MCP integration in the implementation roadmap.

0.4.1

  • Put installation on the homepage with npm, pnpm, Yarn and Bun controls.

  • Replace the Downloads navigation tab with a legacy redirect to homepage installation.

  • Expand the documentation with modeling, deformation, physics and surface workflows.

  • Add retained rigid surface attachments that follow relative morphs, four-influence skinning and world transforms.

  • Separate source package checks from published npm consumer checks with verified archive integrity.

0.4.0

  • Add four-influence GPU skinning, relative position/normal morphs and glTF morph weight animation.

  • Add camera paths, local lights and depth-clipped volumetric fog.

  • Add optional recorded Rapier physics with contacts, joint limits and bounded motors.

  • Add static sculpt brushes and projector-clipped surface patches with geometric clearance.

  • Preserve opaque vertex colors, UVs and independent HDR emission in static GLB exports.

  • Add bounded nearest-surface and directional shrinkwrap with counted queries, atomic output and shared normal reconstruction.

  • Add owned, bounded BVH mesh queries for static surface contact, ray hits and validated closed-solid containment.

  • Close primitive seams exactly in Float32 and validate detail counts before geometry allocation.

  • Add retained scene hierarchy, pivots and atomic reparenting with world pose preservation.

  • Add bounded lathe, extrusion with holes and bevels, and curve tube modeling through an optional addon.

  • Add a lantern modeling study with textured materials, orbit controls and PNG capture.

  • Add torus surface and cap UVs for textured materials.

  • Add Hermite animation curves with explicit tangents and retained playback buffers.

  • Add absolute-time clip mixing, weighted actions and crossfades with deterministic seeking.

  • Import and render normal, metallic/roughness, occlusion and emissive texture maps.

  • Count and release every material texture channel within the existing render budget.

  • Add sphere UVs and preserve normal mapping across small atlas regions.

  • Reuse instance normal matrices and reject GLB exports that would discard material maps.

  • Keep orbital velocity continuous with fewer showcase keyframes.

0.3.3

  • Smooth WALL·E assembly changes when visitors tap or drag the slider
  • Pause driving during assembly changes and gradually resume after complete reassembly
  • Add head tracking, articulated arms and claws, suspension and continuous forward caterpillar movement
  • Keep the camera and shadows aligned with the moving robot
  • Prevent trailer playback and delayed audio seeks from overriding timeline input
  • Rebuild the trailer with detailed machinery, silhouettes, moving vehicles and practical lighting
  • Add filtered terrain grain and surface relief without additional textures

0.3.2

  • Add transparent render targets with MSAA coverage and continuous homepage animation.
  • Showcase WALL·E with moving caterpillars and a slider that pauses driving until reassembly.
  • Replace the short film with a 187-second Oppenheimer trailer study, 33 shots and 13 procedural sets.
  • Enable HDR in the film player and extend bounded video exports to four minutes.
  • Speed up video capture using high-quality JPEG frames while keeping PNG stills lossless.
  • Add direct CDP capture, fast lossless PNG mode, automatic encoder preflight, stage timings and progress estimates.
  • Simplify Downloads and unify the homepage, Docs and Downloads footer.

0.3.1

  • Rebuild the homepage around the scene-to-film workflow and a real video showcase.
  • Add searchable documentation, a plain-text guide and an AI agent entry point.
  • Align site surfaces with CodePawl and add a transparent outline block logo and local SVG icons.
  • Add WALL·E camera compositions, lighting presets, assembly playback and PNG capture.
  • Add nature light presets and HDR grading, clockwork detail, appearance controls and frame capture.
  • Build a timber footbridge with planks, fasteners, rails and a dedicated viewpoint in Silverwater valley.
  • Replace the asset viewer placeholder with an imported clockwork GLB study.
  • Reflow object controls below the canvas on mobile and allow studio navigation to wrap.

0.3.0

  • Introduce deterministic keyframe animation and persistent instance updates.
  • Add opt-in HDR, bloom and color grading with render budget accounting.
  • Add orthographic cameras and a flat 2D scene viewer.
  • Import bounded glTF/GLB assets with textures, vertex colors and rigid node animation through an optional addon.
  • Export landscape, portrait and square media, including imported asset animation.
  • Add motion and asset studios, implementation roadmap and graphics engine documentation.
  • Keep the website package archive identical to the published npm archive.

0.2.4

  • Publish changed versions through GitHub Actions and npm trusted publishing.
  • Skip versions that already exist on the registry.

0.2.3

  • Publish the package under the CodePawl organization as @codepawlhq/67js.

0.2.2

  • Publish under @codepawl_vn/67js because npm rejects the unscoped name.
  • Install with the local alias 67js to preserve the short import path.

0.2.1

  • Include the bundled gl-matrix copyright notice in package and browser downloads.

0.2.0

  • Distribute the renderer as an installable ESM package with separate scene addons.
  • Add a homepage with release metadata, installation instructions, downloads and previews.
  • Separate small WALL·E components during explosion while preserving the assembled model.
  • Synchronize the package, browser module and website version during each build.
  • Host the site at 67js.codepawl.com through Workers Static Assets.

0.1.0

  • Add the object studio, interactive nature world and original 32-second film.
  • Add anti-aliasing, instanced geometry and GLB export.
  • Add bounded image and video exports for hardware WebGL and software rendering.