Skip to content

3D engine that AI agents drive

274 KB
Raw Blame

Changelog

0.21.0

  • Breaking: bake.irradianceGrid takes 8 to 40 nodes, so a value that passes validation always fits the 65,536 node cap; 41 to 48 is no longer accepted (use true, which still reaches 48 along the longest side). The recipe bake also honours the sun link environment.keyAffects (#1218)
  • Breaking: an HDRI (a file, environment.hdri, a bundled look) now faces as in three.js and Cycles, a quarter turn from before; add Math.PI / 2 to environmentRotation to get an old scene's look back (#1371)
  • Breaking: a grid volume's blackbodyIntensity now gives the physical brightness and Planck colour of Blender's Principled Volume, so existing grid fires render 3 to 4 times dimmer; raise blackbodyIntensity or the exposure to get the old look back (#1733)
  • A local volume that emits now feeds bloom in the rasterizer: the volumes are drawn before bloom extraction for a frame with bloom on (#1046).
  • A local volume takes emissionRamp, a blackbody (kelvin) or a colour ramp (stops) read by density, so one fireball grades from a white core to an orange edge in the rasterizer and the CPU path tracer (#1046)
  • A local volume with lightsScene: true adds a point light at its emission, so a fireball lights the floor and props around it in the rasterizer (#1046).
  • A scattering local volume takes scatterOctaves from 1 to 4, the octave sum of volumeFog for the key light, in the rasterizer and the CPU path tracer; 1 draws as before (#1047).
  • A box or sphere local volume can shade the opaque surfaces under it from the key light, in the rasterizer and the CPU path tracer, when castShadow: true is set; it is off by default so the default frame does not change (#1047).
  • A scattering box or sphere volume with shadowDetail: true shades itself by its own noisy density along the sun, in the rasterizer and the CPU path tracer (#1047).
  • backend: "webgpu" draws box and sphere environment.localVolumes (smoke, glow, fire) at the same look as the CPU tracer, 23 times faster at 480 by 300 and 13 times at 1080p (#1048)
  • scene_apply add-explosion writes a whole blast into plain recipe sections from one call: a gas-sim fireball and smoke volume with a white-hot core that lights the floor, sparks, flash, shock ring, dust, rubble, scorch, camera shake and optional fractured debris; particle systems take a delay, and exported recipes and render jobs need no extra files (#1050)
  • A scene node takes rayVisibility in scene_create and scene_apply, with 'glass' as a shorthand that lets shadow rays through a window pane so the path tracer samples sun and sky through it; emitters hidden from bounce rays stay refused, with the reason in docs/path-tracer.md (#1081)
  • The showcase page shows three Cook path-traced stills with their credits (#1083)
  • Cook reads a tangent-space normal map as Cycles' Normal Map node does, so a normal-mapped mesh on a non-uniformly scaled object no longer renders brighter or darker than in Cycles, and render-cycles.py builds a Normal Map node for parity scenes (#1111)
  • Native film frames get their 8-bit picture from Cook's GPU post stage and a faster PNG encoder, taking a 1080p frame from traced film to PNG in 22 ms instead of 276 ms (#1123)
  • Ambient occlusion no longer draws vertical bands on flat walls seen at a slant (#1126) The corner scene with ambient occlusion 0.5: the walls are smooth, with darkening only at the crates, the sphere and the wall corner.
  • Guides tag fields newer than the last npm release with {since X.Y.Z}, a test fails when one is left untagged, and an MCP refusal of an unknown field names the installed version (#1131)
  • parseGaussianSplatSpz and parseGaussianSplatSpzAsync read gzip SPZ splat files (versions 2 and 3, as written by Niantic tools and World Labs Atlas) into the same data as the PLY parser, with the same limits (#1140)
  • parseGaussianSplatPlyAsync and createGaussianSplatsAsync load large splat files in slices with progress and abort, so the page keeps responding (#1142)
  • The WebGPU path tracer samples the sky through light portals (areaLights with portal: true) with the same density as the CPU tracer and Cook; only the WebGL tracer still ignores them (#1144).
  • The CPU path tracer samples the sky through light portals (areaLights with portal: true), so a room lit through a window converges faster at the same mean; the WebGL and WebGPU tracers still ignore them (#1144).
  • The Blender add-on and the Cycles parity bridge now multiply a light's energy by its Emission node's constant Strength and its colour by a constant colour or a constant-temperature Blackbody, and report other light node setups as not reproduced with the light name (#1153).
  • A chunked native trace packs up to the unique triangles the adapter reports (maxUniqueTriangles, 4.79 million on a 12 GB RTX 3060) instead of a fixed 4,000,000, up to a ceiling of 16,000,000, and a scene over the bound is refused with the count, the limit and how many triangles too many (#1158)
  • A native render job and render:file-cook check a scene against the adapter capacity before exporting it, fail with one error naming the count, the limit and what to drop, and report the capacity used (#1158)
  • A native trace of zero parts is refused with a message that says to pass a part, and the docs name the tracers that still keep 1,024 parts (#1158)
  • A native trace takes maximumParts (up to 1,000,000) instead of 1,024 parts or distinct geometries, so scenes of thousands of separate meshes export without merging, and a scene past it is refused with the count and what to do (#1158)
  • The native cycles tracer now starts camera rays at camera.clipStart, so a wall between the eye and the clip start is not drawn, and report.ignored no longer lists it (#1159).
  • Add camera.clipStart to the CPU and WebGPU path tracers, so camera rays start that far along the view axis and a wall between the eye and the clip start is not drawn; the WebGL tracer and native kernel name it in report.ignored (#1159).
  • MCP render jobs, scene_create and scene_apply draw grid volumes (.67vg files in the grid folder, still or a sequence): the server hands the grid bytes to the preview page by name (#1161)
  • generateGeometryLods keeps uvs, colours and normals, so a textured part with levels draws, and addLodsToDenseParts(parts, { pixels }) gives levels to the big parts of a scene with more than one triangle per pixel (#1163)
  • denseSamples is judged on the same part list at construction, on resize and after replaceParts (a scene near the threshold no longer flips on its first resize because the ground was counted, and a scene that gains or loses triangles is re-judged) (#1163).
  • denseSamples renders scenes with more than one triangle per pixel with fewer MSAA samples (default off), which took a 1.6 million triangle frame from about 3.7 to 3.0 ms at 2 samples (#1163).
  • The colour shader computes the sun shadow coordinate from the world position instead of carrying it as a varying, which cuts about 15 percent of the opaque pass on scans with about one triangle per pixel (#1163)
  • The Cook path tracer matches Cycles more closely: bokeh corners sit at Cycles' blade rotation, metals and glass mixes keep their energy, and soft shadows from many lights clean up faster (#1172)
  • A glTF with its base color map on TEXCOORD_1 beside maps on TEXCOORD_0 keeps its base color: the base color map, layer maps and shadow alpha pass now read the second UV set when the map asks for it (#1175)
  • A glTF map whose texCoord is above 1 (a normal map on a third UV set, for example) is dropped with a warning naming the material instead of refusing the whole file; a normal map on TEXCOORD_1 already loads (#1177)
  • Flat water that transmits light (glTF KHR_materials_transmission with an ior near 1.33) now shows the water reflection of the scene around it (#1178)
  • A glTF file with lights no longer gets the renderer's studio key and fill lights on top of its own: on a test scene mean luma went from 224 to 204, within 1 level of three.js with the same ACES curve (#1178)
  • The home page hero says "67js is now Crucible" under the hero buttons, with the new package name and a link to the changelog (#1183)
  • Native render jobs get 640 MiB of fixed memory allowance instead of 256, sized from measured native + OIDN video jobs, so a 960 x 540 film no longer runs within 50 MiB of the guard (#1186)
  • A native render job on a software Vulkan adapter (lavapipe on a Linux runner without a GPU) gets 2304 MiB more memory allowance, so the first 960 x 540 job no longer fails the memory guard (#1186)
  • Native path traced video jobs with OIDN get a memory allowance of 256 MiB plus 1 KiB a pixel, capped at 2 GiB, and the memory guard error names the limit and the observed and allowed MiB (#1186)
  • The browser GPU path tracer (WebGL2 and WebGPU) takes as many triangles as the device's texture or buffer limits hold, up to 2,000,000, so a skinned crowd over 400,000 triangles can be traced; a scene past the limit is refused with its triangle count, the limit and what to do (#1188).
  • The agent skills match the code again: path traced stills and video jobs, the 1920x1080 pixel cap, all pass names, and the mesh and walkmap tools (#1191).
  • scene_capabilities reports jobs.maximumFps as 60 and jobs.maximumFrames from the same constants the render job validator uses, instead of a stale 30 (#1193)
  • Fixed render jobs with passes (depth, normal, albedo, objectId, emission) failing with WebGL error 1282 on a scene with a smooth metal part: the reflection probe now looks up its uniforms again when a pass links a new shader program (#1196).
  • exportGlb and scene_export_glb keep the JPEG, PNG or WebP bytes of an imported texture instead of re-encoding it as an uncompressed PNG, so an imported 1.8 MB catalog asset no longer exports at about 6.5 times its size (#1197)
  • scene_look steps a busy PNG down by 0.75 until it fits the 1 MiB budget and reports the size it returned, and closed-room-without-bake no longer fires on a lone object whose bounds centre is inside it (#1197)
  • The site wears the Crucible brand: the pot mark and Plus Jakarta Sans Bold wordmark, Paper and charcoal themes with a light and dark switch, and the shared brand fonts (#1199) The Crucible mark over a container port rendered by Crucible
  • A render job with passes no longer fails with GL error 1282 on a scene that has a baked irradiance grid: the grid looks its uniforms up again for the program a pass links (#1204).
  • glTF accessors are now decoded one primitive at a time during conversion and released after their last use, and maxDecodedBytes sets the decoded-bytes budget (#1210)
  • A native film or stills job waits one event-loop turn after each frame, so the addon's frame planes are freed and the Node process no longer grows about 9 to 13 MB per frame (#1211).
  • A big thin ground box beside dense props no longer fails scene_create with "Set maximum size exceeded": the flush search stops at its tested-pair limit and reports the part as unchecked, and a 2 cm slab is no longer flagged collapsed-node (#1216)
  • A placed asset material override (and a recipe material) takes an emissionMask ramp along an object axis, so a part glows only at one end while its texture and shading stay (#1217)
  • A placed asset's asset.materials[] override can take an id that motion material tracks drive, so emission and emissiveColor fade a heat glow without rebuilding the scene (#1217).
  • A scene_apply whose rebake cannot run (part cap, path work limit) now keeps the edit, drops the old bake and returns a bake-skipped warning with how to fit, and the irradiance grid and probe part errors say they trace on the CPU (#1218)
  • A pose edit through scene.apply at 961 parts now takes about 2 ms instead of about 60 ms, and a game frame that sends the same poses as the last one skips scene.apply (#1219)
  • A render job whose frame is cut to fit the render budget now names the budget the full frame needs and the --memory value to restart with, instead of only the smaller size (#1221)
  • Line art can be set per node: environment.lines.nodes takes { "<node id>": { lines: false | silhouetteOnly, color } }, and the objectId pass metrics carry objectNodes (#1223)
  • The WebGL2 GPU path tracer draws every part again: on ANGLE D3D11 it drew only the first part of a scene, because a nested texel fetch read every later material as shadow-only (#1228)
  • An image render job takes up to 3840x2160 pixels instead of 1920x1080, and an image frame the --memory budget would shrink is refused with the --memory it needs; stills and video keep 1920x1080 (#1241)
  • The WebGPU real-time tracer and the GPU light bake bound their scene by the device's triangle limit, up to 2,000,000, like the still render, instead of 400,000 (#1242).
  • The path tracers, native Cook included, read a map on TEXCOORD_1 with the second UV set, so a glTF base color on TEXCOORD_1 beside a TEXCOORD_0 normal map no longer samples UV (0, 0); a part with a map on uvChannel 1 and no geometry.lightUvs is refused with what to set (#1243)
  • crucible-mcp stops at startup with the real message for a bad --packs, --assets, --audio, --ffmpeg, --browser or --branches/--relations/--findings value, scene_restore rejects two targets, and terrain and geometry-budget errors name the range, id and numbers (#1244)
  • Docs and llms.txt now say the quality render setting ships, the checkpoint limit is 16, and the tool-cost total points to scripts/measure-tool-cost.mjs instead of a stale number; a test keeps the limit in step (#1245).
  • A failed job release, status write or browser launch no longer breaks the MCP runtime: a retry finishes the release, close always frees the store lock, and a recipe over the 64 MiB asset limit is refused before any file is read (#1246)
  • Scene builders refuse bad input when it is set: text outside printable ASCII names the character and font, motion tracks are checked for out-of-range values, and a terrain seed must be a whole number from 0 to 2147483647 (#1247)
  • glTF import names the field and index of a null or non-object entry in nodes, meshes, accessors and the other arrays instead of a "Cannot read properties" TypeError (#1248)
  • glTF import and export reject more bad files by name: dangling indices name their field, meshopt buffer views count against maxDecodedBytes, and exportGlb throws when a light map or uvChannel: 1 map has no geometry.lightUvs (#1248)
  • The site build now publishes every guide that llms.txt and the other guides link to, the install guide no longer links a release the site dropped, the docs say the three optional packages are source-checkout only, and the addon check accepts release candidate versions (#1249)
  • A render job's deadline counts render time only, its queue wait is bounded apart, and scene_create starts a fresh runtime after a failed one without a server restart (#1256)
  • A render job that hits its elapsed deadline under a shared GPU now gives the scene page 120 seconds to come back, and its failure says to submit the job again (#1256, #1224).
  • crucible-mcp takes --gpu-queue and --gpu-queue-wait: an optional queue command that looks, reviews, bakes and render jobs wait for before they take the GPU, so the server can share a card queue (#1258)
  • The path tracer export keeps an area light aimed along up as a rectangle, reads texture wrapS and wrapT per axis on every tracer, and turns skinned normals correctly (#1259)
  • A client or authority restarted on the same peer id now resyncs on its own instead of staying silent (#1262)
  • startGame no longer moves a player or NPC under a translated parent on the first frame, and the restart rule action, the R key and the new game.restart() put the game back at its start, so a won or lost exported game can be played again (#1263)
  • Render jobs count frames without float noise, render-media refuses audio shorter than the video, and a tiny audio.offset reaches ffmpeg as a plain decimal (#1264)
  • crucible-addon-check resolves the entry like the server, rejects unsatisfiable peer ranges, accepts --version=X and has --help; crucible-mcp --help lists every flag (#1265)
  • Disposing a renderer made with deferProgramLink now frees the programs still linking, and resize() on a lost context returns instead of throwing (#1266)
  • A looping clip retargeted with retargetClip or exported from an authored rig now ends on its end pose instead of the first pose, and createCrowd throws a RangeError for bad columns and size (#1267)
  • Volume fog detail fields, the volume fog density motion track (now 0 to 10), a mesh volume's missing part and a second grid volume fail when the scene or an edit is built, with the render-time messages (#1268)
  • Mesh bevel caps profile at 0.99 and shrinks the overlap clamp for concave profiles, inset_region clamps thickness at the face limit and reports it, and lintMesh with geometry: true flags folded-face (#1269).
  • The games runtime calls onEvent for every event and caps only the stored log, a rules part starts as hidden as the scene node it is named after unless it sets visible, and reportContact is ignored after the game is won or lost (#1281).
  • Asset loading counts a textured pack GLB at its embedded size, and the PLY splat loader skips elements before vertex, accepts CRLF headers, and rejects non-finite scales and a non-positive maximumCount with a clear error (#1282).
  • remesh no longer returns an inflated or non-manifold shell for a cube, remesh and boolean reject an inside-out mesh and name flip_normals, and subdivide no longer fails on a loose vertex (#1283)
  • render-media keeps the audio on the browser-encoded H.264 path and ends PCM and AAC audio with the picture, fails a video that lost its audio, writes 8 distinct stills as frame-0 to frame-7, and rounds a derived video size to even (#1284)
  • remesh no longer returns an edge shared by four quads on thin, bumpy surfaces; when it cannot separate the sheets, it throws and names a different voxelSize (#1291)
  • The WebGL and WebGPU path tracers read each map of a material with its own UV set, so a floor with a TEXCOORD_0 base colour and a TEXCOORD_1 emissive map matches the CPU tracer; a device with limited texture or buffer size now holds about 10 percent fewer triangles (#1300)
  • An sdf geometry now splits saddle cell vertices the way remesh does, so every edge joins exactly two quads when parts touch along an edge; a saddle it cannot separate throws an error that names the fix (#1302).
  • A placed asset takes flatten: { color?, unlit? }, which sets one flat colour or unlit on every material of that asset in one call and leaves the rest of the scene unchanged (#1303)
  • The smokes film-timeline, object-motion-blur and path-tracer ask scene_render_result for the detailed answer, and the render docs and skill say file digests come with response_format: "detailed" (#1304).
  • scene_create and set-environment accept everything scene_export_recipe writes, including all joint fields and motion track extrapolation, and a malformed motion track names its bad field and the allowed ones (#1311)
  • The shipped guides and the build-crucible-scene skill now import only public subpaths, and new addon entries crucible/addons/reflection-probes, fracture, morph and skinning back the examples that had none (#1312)
  • Memory and size limits now agree with their messages: an .hdr over 8 MiB is refused like a .cube over 4 MiB, and scene_asset_catalog skips an oversized .hdr, .cube or image with a reason in skipped instead of failing the listing (#1313)
  • Pack zips and the sha256 in /packs/index.json no longer change with the checkout's line endings: .gitattributes pins text files to LF, and createZip turns CRLF into LF in text entries, so a Windows checkout and CI publish the same archive hash for the same SHA (#1314).
  • An image whose size cannot be read from its header is refused before decoding with an error that names the file and the frame limits, and a JPEG with a restart marker before its frame header can no longer slip past the size limit (#1319)
  • MCP errors name what to change: a review camera lists the fields it rejects, a stale revision gives the current one, a path traced job far over the 400000 triangle cap of the cpu tracer is refused at scene_render_submit with the count, and an unknown scene_capabilities topic suggests the nearest one (#1325)
  • The docs and the render jobs skill now say npm install @codepawlhq/crucible-denoise-oidn instead of "not on npm yet", and the guides document jobs.maximumFps, jobs.maximumFrames, emissionFresnel and the adaptive resolution raiseBelow option (#1327)
  • @codepawlhq/crucible-denoise-oidn is now published to npm beside Crucible, so OIDN installs with an npm install of Crucible (#1327)
  • The website matches codepawl.com: light by default with a dark mode on the header button, a plain header bar, captions under the showcase pictures, 8 px controls and the pot's metal as the only orange (#1333)
  • A closed room's walls, ceiling and props now get the sky they can see traced into their vertices, so a sealed room renders near black like the path tracer instead of as bright as a room with a window (#1334).
  • The wavelet denoiser leaves far less blotchy grain on flat walls at 256 samples: its luminance guide ignores a lone noisy pixel (#1335)
  • A recipe path such as environment.lightDirection written as a motion track (target, keys) now fails with an error that names the sun track (direction, color, intensity) that moves the key light under any sky; the docs say so (#1342).
  • The flush-face search keeps its triangles in flat arrays instead of one object each, so a 200k triangle GLB peaks at about half the browser heap while a scene loads, and scripts/measure-glb-heap.mjs measures it (#1343)
  • loadGltf keeps a KHR_materials_ior above 2.5 (exporters write 1000) at 2.5 with a warning instead of refusing the file (#1347)
  • The WebGPU path tracer megakernel now compiles with FXC, so the bundled Chromium on Windows can run the GPU tests, and the render stays byte for byte the same on DXC (#1350).
  • A camera clipStart at or past far is refused with a message that says what to pass; the MCP preview's native export and both real-time tracers now report that they ignore clipStart (#1351)
  • A recipe scene that leaves shadow out and is wider than the default 7 m view now gets a sun shadow view fitted to its bounds (three automatic cascades past 40 m), so a sealed room stops leaking sun; a recipe that sets shadow is unchanged (#1359)
  • Look change: the light an HDRI gives a surface is now an exact cosine convolution of the map, so shade next to a strong sun no longer comes out up to 50 percent off and matches three.js within 5 percent (#1374)
  • The site header gives Marketplace an icon, live-example code sits on a tinted surface, and the sliders in docs examples show their value with brand colours and focus states (#1375)
  • Glass that transmits light now reflects the reflection probe placed on it, and a blended part keeps its specular at full strength when its opacity drops, so a glass wall and a faint blend glass show the room and the sky instead of fading with alpha (#1385)
  • A rules input trigger on an action the game does not bind (anything but jump or run) is now refused by set-game with the actions to use, instead of crashing startGame on its first step (#1387)
  • Game rules arithmetic whose result overflows or is not a number now gives 0 instead of leaving a variable at Infinity or NaN (#1388)
  • Live physics fixedUpdate rejects a NaN step, and raycast, shapeCast and overlap give the query options error for null, both naming what to pass (#1389)
  • A film timeline frame that lands on a shot cut now shows the later shot even when shot lengths such as 0.1 s and 0.2 s sum with float error (#1393)
  • A particle emitter from a scaled mesh now emits from vertices at the stated normalSpeed and orients instances with unit normals (#1396)
  • A sound with pitchVariance no longer throws a range error from play at low pitches (#1397)
  • motionBlur.objects now rejects negative, NaN and text values instead of ignoring them (#1398)
  • A curve through a repeated point, with a duplicated end control point or with repeated trailing points (poly and NURBS) now builds instead of throwing "Cannot read properties of null"; the direction there comes from the nearest distinct point (#1399)
  • A glTF accessor or sparse block with a negative or fractional byteOffset now fails with an error naming byteOffset instead of reading the wrong bytes (#1400).
  • A glTF accessor that sets normalized on floats or 32-bit integers now keeps its values instead of decoding to NaN (#1401).
  • Library calls bevelEdges, subdivideMesh, loopCut, bisectPlane, resampleCurve, resampleSamples and filletCurve refuse NaN, missing and unbounded inputs with an error that names the parameter, the value and the allowed range, and share their limits with the recipe layer (#1405)
  • Make fitOrthographicHeight throw for a view whose up is parallel to the view direction, whose eye equals its target or whose vectors are not finite, instead of returning 0 or a meaningless height (#1406)
  • Make createCameraSampler reject empty frames, a non-positive fps, malformed frames and a non-finite sample time with errors that say what to pass (#1407)
  • A glTF node with a matrix, translation, rotation or scale of the wrong shape, or a zero quaternion, is refused with the field named instead of reported as a singular node (#1409)
  • A glTF data URI accepts a capitalised ;BASE64 marker, and a bad payload says to use standard base64 instead of throwing a bare decoder message (#1410)
  • A glTF TRIANGLE_STRIP, TRIANGLE_FAN or unknown primitive mode is refused with its name, mesh and primitive and the fix (#1411)
  • Editing an imported mesh keeps the UVs of a face that has a real corner at UV 0,0 and rebuilds only faces with no UVs (#1416).
  • scatterVegetation, createGrassClump and createFlowerPatch check their options and throw a RangeError with a valid example instead of crashing, hanging or running out of memory (#1417).
  • The MCP catalog decode refuses an external glTF buffer or image uri instead of fetching it, with an error that names the uri (#1418).
  • Fix the material snapshot so a fast-path update with a changed emissionFresnel or emissionMask throws instead of being ignored (#1419).
  • Terrain ground normals on the outer border now use the real span between samples, height accepts plain and Float64 arrays and rejects other non-object values, and update rejects a non-finite eye position (#1420)
  • GLB export now rejects lightUvs of the wrong length and empty, non-finite or unsorted animation keyframes with errors that name the fix, and writes a Float32Array light map tint as a JSON array (#1425, #1426, #1428).
  • Navmesh and crowd bake refuse a reversed obstacle footprint, non-finite or out-of-range geometry (#1427, #1429) and a palette of more than 7200 frames (#1430), instead of building a silently wrong or oversized result.
  • Cloth step takes zero time as a no-op and rejects a negative, NaN or over one second deltaSeconds, bakeCloth rejects a bad frameCount or framesPerSecond, sampleClothFrames rejects a NaN time, and wakeTrail no longer returns NaN points for a zero lifetime or a missing speed (#1431)
  • Pose solvers refuse a zero aim forward or two-bone bendToward, and a morph-only layer refuses a non-finite reference, instead of silently doing nothing or writing NaN weights (#1436, #1437, #1438)
  • GLB export no longer crashes on a skinned part without a matrix, folds an emission below 1 into emissiveFactor instead of an invalid emissiveStrength, and keeps the negative scale of an animated mirrored node (#1441, #1442, #1443).
  • A scene query now hits a part after its world matrix moves in place, raycast throws on a NaN or non-number maxDistance instead of reporting a miss, and a rig with a zero-scale rootMatrix throws instead of filling the pose with NaN (#1444, #1445, #1446).
  • Fix trianglesIntersect for a zero-area first triangle, floatToHalf rounding of subnormal halves, and make RenderTargetLedger.record throw on an unknown format or bad size instead of reporting NaN bytes (#1450, #1448, #1449).
  • A light linked to a group node is now reported as an unknown name instead of lighting nothing (#1453)
  • Kernel offload no longer reuses another call's cached result for look-alike inputs, no longer hangs when a worker answer cannot be read, and runs a self-referencing input inline (#1455, #1456, #1457).
  • Fix three silent faults in the fog and local volume code: a moved fog box leaks its old sky texture, the shadow ambient cache ignores the measure it is given, and packing accepts a grid volume that was never bound (#1463)
  • scene_apply fracture-node on a node that already has a physics body now names node and says to drop that body with set-physics first, instead of blaming physics.bodies[n].node after the node was replaced (#1466).
  • A path-traced scene with a negative, fractional or missing index, or a NaN in uvs or colors, and a real-time tracer with a bad historyLimit, filterIterations, cacheCellSize or resolutionDivisor, now stop with a message that names the part or option (#1467, #1461, #1462)
  • A pack JSON string that a browser reads as a remote address, such as a backslash form or a scheme with a tab inside, is now refused (#1468)
  • An addon file in a folder whose name starts with two dots is no longer refused as outside its package (#1469)
  • The pack index build refuses an --out folder that overlaps --packs instead of deleting the packs (#1470)
  • A .cube look with a bad DOMAIN line or a malformed row is refused, and a NaN or infinite channel gives a finite display colour instead of a NaN pixel (#1476, #1475).
  • A zero-size fog box no longer gets NaN sky grid cells, tree sky matching no longer writes NaN when leaf coverage is zero, and an empty crown says what to pass (#1477, #1478, #1479).
  • Closed-mesh check for softBody.pressure now rejects a triangle wound the wrong way, and liquid optics keep the default for an undefined field and reject an unknown field (#1483)
  • Compressed textures with a zero, negative or fractional base size or a mip chain whose levels do not halve, and texture sequences given a NaN or infinite time, now throw an error that says what to pass instead of failing later (#1489, #1490).
  • Name the track and keyframe in motion validation errors for a non-array value, repeated times and an empty or malformed keyframe list (#1492, #1493, #1494).
  • Object reflections are traced again when only environment.sky changes (#1495)
  • A meshEdits entry that is not an object is reported as that entry instead of a character index (#1496)
  • lintMesh with geometry: true no longer reports a false self-intersection on a prism over a concave outline, and the occlusion measure of vertex_group skips zero-area faces instead of throwing (#1497, #1498)
  • A drive wheel that gives both node and nodes is rejected with a field error instead of silently ignoring node (#1502)
  • exportGlb throws on texture sampler wrap or filter values that are not glTF enums and on a boxMapAxis outside 0, 1 and 2, and exportObj throws when geometry.uvs or geometry.normals does not match the vertex count, instead of writing an invalid file or dropping the data (#1503, #1505)
  • A part that the flush pass ranks and that carries baked lightUvs, skyVisibility or surfaceMasks no longer reaches the path tracer with NaN lightmap coordinates (the demo room window-top had 507 of them), and the path tracer now refuses non-finite lightUvs (#1504)
  • A mesh particle emitter no longer emits from a triangle or edge outside its vertex group when the random draw is exactly 0 (#1511)
  • maximumInstances and maximumVoices must be whole numbers; a fractional limit used to let one more voice play (#1512)
  • markersCrossed and emitMarkers throw for a NaN or missing clip time instead of firing no cues (#1513)
  • A looping clip or a repeating cycles modifier sampled on a cycle start at a fractional frame rate, such as frame 9 of 30 fps on a 0.1 s clip, now shows the first pose instead of the last (#1514, #1515)
  • An animated vehicle player now defaults to the speed drive and refuses an intentSpeed drive at set-game, instead of crashing on the first step (#1517); a physics listener that disposes the system no longer lets later listeners run on the freed world (#1518).
  • createTerrain rejects a non-positive or non-finite lodDistance, and scatterVegetation rejects a bad scale maximum or an infinite mix weight, instead of silently building empty terrain or NaN instances (#1519, #1520, #1521).
  • crucible-addon-check now fails a package.json that is not a JSON object, refuses a repeated --version, and fails an entry that is a folder (#1524, #1525, #1526).
  • A shadow casting light with a range of 0.05 or less no longer writes a NaN or flipped shadow matrix, and cascaded shadows keep their splits ordered when maximumDistance is nearer than the camera near plane (#1530, #1531).
  • Calling createNetcode(...).init twice without dispose no longer leaves the first transport subscription live, so messages are not handled twice (#1532).
  • A game.restart() whose physics rebuild fails now sets game.physicsError and makes the physics step throw the cause, instead of leaving a silent dead world (#1533).
  • A camera with an fStop now focuses the raster depth of field at camera.focusDistance when it is set (the path tracer and Blender already did), and a non-positive fStop throws (#1536)
  • The real-time path tracer refuses a width or height that is not a whole number of pixels, and names width and resolutionDivisor when the traced size leaves 16 to 4096 (#1538)
  • edgeAngle reads 0 next to a zero-area face, mesh volumes measure the positions and indices a part holds now, and empty or NaN positions get a clear error (#1539, #1540, #1541)
  • A cached modifier stack result is checked against the current vertex and face limits, and realized instance geometry keeps one geometry record per distinct content, so the same scene builds to the same recipe (#1545, #1546).
  • knife_project no longer fails on a line along existing edges, grid_fill handles long loops within a vertex budget, and fill_holes stops reporting an Infinity limit (#1547, #1548, #1549)
  • meshFromGeometry refuses uvs or colors of the wrong length, a face tag with values above 1 now combines correctly in selectFaces, and a sculpt edit with non-array strokes names the field (#1552, #1553, #1554)
  • The splat PLY loader drops a splat with any non-finite field (a scale that overflows included, which used to throw) and reports skipped: { count, fields }, throwing only when no splat is usable; createGaussianSplats refuses a covariance that overflows 32-bit floats, naming the splat (#1558)
  • A glTF sparse accessor with a fractional, negative, missing or too large count, or without indices or values, now fails with an error naming sparse.count, sparse.indices or sparse.values instead of a typed array error or a silent skip (#1563).
  • Light profiles with a near zero axis value, IES headers with a fractional angle count and GPU bakes of spot cones narrower than cosine precision no longer give Infinity, a wrong error or a NaN edge (#1566, #1567, #1568).
  • An animation graph state with loop: false over a looping clip now holds the clip's last frame instead of snapping back to its first frame (#1569)
  • glTF import normalizes the direction of a scaled spot or directional light, skips one scaled to a zero direction with a warning that names the node, and ignores a non-numeric light range with a warning (#1573)
  • createCameraSampler rejects a frame whose eye equals its target and an fps that makes the duration infinite (#1574)
  • A kernel worker request with an unregistered name (including toString or constructor) now answers an unknown kernel error, encodeVolumeGrid refuses channel names and sizes that decodeVolumeGrid rejects, and a grid header that is not a JSON object says so (#1575, #1576, #1577).
  • Vegetation scatter errors and clearings are exact: an area off the ground names vegetation.scatter.area, a node exclusion follows the node's world position, and vertex group errors in particles, cloth and exclusions name their list index (#1579, #1580, #1581)
  • A motion track on the environment kind with keyIntensity, keyColor or keyDirection now says the key light is the sun kind and names the sun track to use (#1585)
  • Refuse mismatched OIDN buffers, release the OrbitControls listeners on dispose and refuse short or out-of-range geometry in toThreeObject (#1586, #1587, #1588).
  • The Blender add-on keeps a Roughness, Metallic or Alpha constant when its image has no pixels instead of exporting an empty texture, and notes an anamorphic aperture ratio it cannot render (#1589, #1591).
  • Terrain hole errors and scene_inspect path query errors now name the exact field (terrain.holes[1].radius, path.from, path.avoid[1]) instead of a bare message or a generic id (#1592)
  • glTF import clamps negative skin weights to 0 and renormalises each vertex (an all-negative vertex binds to joint 0), with one warning per primitive that counts them, instead of refusing the file (#1595)
  • Grass and clutter fields refuse an area that needs over 262144 tiles, filletCurve rejects an arc segment count of 0, a fraction or over 64, and field div and mod give 0 for a divisor so small the result overflows (#1596, #1597, #1598)
  • three-compat sums several DirectionalLights, honours every rotation.order and rejects a torus radius of 0; three-bridge clamps an InstancedMesh count to its matrix array with a warning (#1599)
  • A vegetation exclusion that mixes min/max with center, radius or node, a hair swayRate without sway, and a radius on a box particle emitter are now refused with an error that names the fix instead of being ignored (#1603, #1604, #1605).
  • The Blender add-on exports the camera's own clip end, says so when every mesh has no triangles, expands // paths for the tracer folder, and refuses a NaN or infinite environment cap (#1608, #1609, #1610, #1611).
  • triangulate, createStreaming, createInput and the crowd setTimes refuse bad input with a named error, crowdFrameBlend shows the first frame for a non-finite time, and input dispose finishes every source before rethrowing (#1617, #1618, #1619, #1620)
  • Physics collider limit errors name the node by its list index, nodes[1].geometry, instead of putting the node ID in the brackets (#1622)
  • A crowd farDistance is measured in the space of the crowd instances, so a crowd under a moved parent switches to the far rate by its real distance from the camera (#1623)
  • The live runtime retries a system whose init threw, keeps time finite after one NaN clock reading, and an arc shape refuses a span wider than half a turn (#1625, #1626, #1627).
  • Look up a part's matrix by the part before its name in the closed-room, sky openness, ground bounce and sun bounce tests, so glTF parts that share a name keep their own matrix (#1628)
  • Crowd farDistance follows a parent group that has a motion track: the camera distance is measured from where the parent is at that time, not where it was when the scene was built (#1629)
  • Mesh normals: weighted_normal falls back to the face normal, then +Z, for a zero-area face instead of writing a zero normal (#1631), and cornerNormals refuses a NaN, negative or oversized sharpAngle (#1632).
  • A ragdoll rig with a later parent, a repeated bone id or a bone that is its own parent is refused when built, camera rigs ignore a time step that is not above zero, and buildSprayGeometry refuses a bad maxPoints or radius (#1633, #1634, #1636)
  • projectUv, packUvIslands, unwrapUv and bisectPlane refuse an unknown mode or axis, a margin outside 0 to 0.2 and a bad distance with an error that names the field (#1638, #1640, #1641).
  • Fix three edge cases from a bug hunt: the render target ledger refuses negative sizes, assembly layouts ignore inherited object keys, and a clutter mask returning NaN places nothing (#1642, #1643, #1644).
  • A sealed room whose glTF parts share one name is now recognised as a closed room by the floor sky trace, and object motion blur gives each part of a shared name its own motion (#1645, #1646)
  • Radiance .hdr files in the original format, where a 1,1,1 pixel repeats the previous pixel, now load instead of reading wrong or failing as truncated (#1650)
  • createClutter refuses a seed that is not a finite number, as grass and terrain already do, instead of scattering one fixed layout or joining a string seed into its hashes (#1652).
  • Refuse a NaN, Infinity or non-number seed in createGrass and createTerrain (noise height), and a non-finite budget in createSlicer, with errors that name the field; fractional seeds still truncate (#1652)
  • Fix unsubdivide losing every face tag, and boolean cutterFaces counting faces of earlier booleans when a cutTag is reused (#1653)
  • Spume whitewater skips points with NaN or infinite values and partsForFrame clamps an out-of-range frame instead of throwing (#1655).
  • Hair roots stay finite when a surface vertex has a NaN or infinite position or normal (#1656).
  • Game setup no longer hangs on scene nodes whose parents form a cycle, the NPC path follower system skips the loop's zero-length first frame, and createLookAt and createFootPlacement ignore a non-finite pose time instead of staying NaN (#1660, #1661, #1662)
  • uploadTextureInSlices refuses short RGBA data and a zero size before any GL call, and effectsWithFStop accepts a camera without a target like the renderer does (#1664, #1663)
  • Refuse a NaN or out-of-range minVertices and angle in triangulateFaces and splitSharpEdges when called directly, instead of returning an unchanged mesh (#1666)
  • Fixed three agent-facing bugs: a branch snapshot now copies the forked recipe instead of sharing it, a tail light with a non-numeric off or on emission is refused instead of driving NaN, and an image sequence time that overflows frame arithmetic is refused instead of picking frame NaN (#1669)
  • Refuse an irradiance grid resolution under 2 or samples under 1, an odd probe map width and an unreachable adaptive raiseBelow, instead of writing NaN grids, dropping probe rows or pinning the resolution at its minimum (#1672)
  • A non-finite look-at target or foot groundOffset no longer throws each frame: it keeps the last good value and warns once per controller (#1675)
  • flatten without a normal now refuses a closed mesh instead of squashing it onto a random plane (#1679)
  • buildWithKernels no longer hangs when its kernel worker goes silent: a new kernelTimeoutMilliseconds option (default 60000, above 0, at most 3600000) ends the worker and finishes the build inline (#1681).
  • Fix three LOD input bugs: generateMeshLods gives relativeError 0 instead of NaN for a zero-extent mesh (#1682), addLodsToDenseParts checks ratios on a sparse scene too (#1683), and generateAssetLods names a part that has no geometry (#1685).
  • split_edges and delete_loose (and the other edits that rebuild from polygons) now keep vertex groups and other point attributes: a split vertex copies its source vertex's values and removed vertices drop theirs (#1684)
  • box() now refuses a bevel too small to move its core instead of returning NaN normals, and text() draws a glyph whose overlapping contours start inside each other instead of throwing a TypeError (#1686, #1687)
  • A world renderer with no shadowBounds target or extent fits the sun shadow view to its shadow casters, so the shadow bias stays thinner than 0.2 m walls and a closed room no longer shows sun lines along its seams (#1695).
  • The MCP server decodes Draco-compressed GLBs in the asset catalog and packs with the optional draco3d package, so an agent can place a Sketchfab or NASA download as it is (#1698)
  • subdivide and loop_cut keep point attributes such as vertex groups: new points blend their sources, and integer values take the first one (#1704)
  • The MCP server transcodes KTX2 textures of catalog GLBs to PNG with the optional three package, so an agent can place an optimised download as it is (#1709)
  • Add focusDistance (metres, with fStop) to the recipe camera so an agent can focus on a subject without moving the camera target (#1711)
  • Dispersive glass keeps signed spectral weights as Cycles does, so prism fringes match its saturation, and negative pixels are clamped before OIDN and the display transform (#1714)
  • Glass can fringe into colour: a material dispersion from 0 to 10 reaches the native path tracer, and glTF KHR_materials_dispersion is read instead of ignored (#1714)
  • Two soft volumes that overlap are marched together, so a soft edge no longer shows a hard slab where the other volume starts (#1722)
  • scene_look no longer fails on a mesh local volume that names a node added by scene_apply: the renderer now keeps its part list after a topology change, which also keeps volume shadow ambient and irradiance grid fog current after an edit (#1723).
  • Local volumes take noiseOctaves (1 to 5, default 1): finer octaves of noise on top of the large lumps give smoke and fire a ragged edge, in the rasterizer and the CPU path tracer (#1725)
  • Native video jobs that blend frames over time trace natively again: the temporal blend accepted only a 320-byte kernel parameter block, but Cook sends 336 since its anamorphic aperture ratio, so every such job fell back to another backend on its first frame (#1729).
  • bakeGasSim takes detail (0 to 1, default 0): a noise upres of each frame's smoke density, so a coarse sim breaks into puffs and gaps below its cell size; 0 keeps the bytes of every existing bake (#1735)
  • The gas-sim bake keeps smoke and fuel mass constant between sources and sinks: advection no longer swells the plume (a 3 s blast used to roughly double its smoke) (#1735).
  • bakeGasSim bakes an explosion from a grid gas simulation (advection, pressure projection, vorticity, fuel burning into flame and heat) into grid volume frames, in src/gas-sim.js (#1735)
  • add-explosion fireball emission is 9.5 instead of 14 at the reference size, so the core no longer clips to white and the edge falloff reaches 0.79 of the Cycles frame on a flat background, with the RMSE against it down from 0.030 to 0.020 (#1736)
  • add-explosion bakes with turbulence 1 and vorticity 40, so the fireball outline breaks up more (silhouette roughness 5.4 to 6.1 and edge falloff 0.74 to 0.82 against a Cycles reference 10.1 and 1.06); scripts/measure-explosion-breakup.mjs scores a blast against it (#1736)
  • vdb-to-grid.py reads Blosc compressed VDBs, openvdb's default, when run with uv run --no-project --with blosc (#1742)
  • createGaussianSplats takes palette (2 to 256 colours) and dither (bayer4 or bayer8) to snap alphaCut splats to a palette for a pixel-art look (#1744)
  • createGaussianSplats takes alphaCut to draw opaque, unblended discs and parseGaussianSplatPly takes upAxis: 'z' to load Z-up files such as Blender splats upright (#1744)
  • A grid volume with castShadow: true now shades the surfaces under it from the sun, so an explosion no longer floats over a lit floor (#1748)
  • render() takes linearOutput: true with a float outputFramebuffer to write linear scene radiance after fog and volumes, with no view transform or clamp, and compare-volume-render.mjs reads it as a .f32 candidate (#1749)
  • Grid fires no longer show vertical streaks, cross lines between voxels or a hard flat bottom edge in Glaze and the CPU path tracer (#1752)
  • An agent can place a part by its top, bottom or centre face with a new level node relation ({ "kind": "level", "at": "top", "y": 0.5 }), so it no longer adds half the thickness by hand. Existing recipes are unchanged. (#1755)
  • Particle systems of type: "sparks" throw emissive streaks that cool along the blackbody curve with gravity and drag, and preset: "explosion" makes a blast (#1758)
  • A grid volume blurs along the gas velocity when the scene's motion blur shutter is on: bake with velocity: true and a fireball or smoke smears along its expansion in Glaze and the CPU path tracer, as in Cycles (#1759)
  • The shadow a grid volume casts on surfaces blurs along the gas velocity when the motion blur shutter is on, so a blurred blast no longer casts a sharp shadow (#1763)
  • A render job or still no longer draws its first frame with the fallback post program while the driver builds the real one, so a cold first frame matches a warm one (#1767)
  • The fireball bake that every explosion scene sends with scene_create runs about a third to a half faster (72 frames at 32 cubed, same bytes): the gas solver locates each traced position once per step instead of once per field (#1768)
  • The MCP server keeps baked add-explosion frames in a cache folder, so a second process that needs the same blast loads it instead of simulating for about 5 seconds (#1768)
  • A scene_create whose recipe has a grid volume may run 60 s instead of 30 s, the same limit add-explosion already had, because the first draw compiles its shader in the graphics driver (#1768)
  • The MCP server keeps Chrome's compiled GPU shaders between runs, so the first volume scene_create of a new server process takes about 0.8 s instead of 4.9 s; CRUCIBLE_SHADER_CACHE=0 turns it off (#1768)
  • A scene with only grid volumes, or only box and sphere volumes, builds the shader of that kind alone, about half the shader build of the combined program, with the same pixels (#1768)
  • A glowing or shadow-casting grid volume no longer stalls the first draw: its shader builds in about 8 s instead of 45 s on ANGLE d3d11, and a cold scene_create fits well inside the 30 s preview limit (#1768)
  • Environment variables now take the CRUCIBLE_ name first (CRUCIBLE_NO_UPDATE_CHECK, CRUCIBLE_MCP_LOG); the SIXTYSEVENJS_ names keep working as aliases (#1770)
  • scene_apply refuses an add-node that would take the scene's unique assets past the 64 MiB combined limit, with a clear message, instead of letting the later render job crash the page ('Target page closed') (#1771)
  • add-explosion takes sparks and motionBlur options, on by default: spark streaks and a velocity motion blur of the fireball (#1775)
  • crucible-mcp --memory goes up to half of the machine RAM (at most 4096 MiB) and the render job memory guard and the native tracer allowance follow it, so 1080p and native path trace jobs of heavier scenes finish (#1776, #1696)
  • Particle emitter systems take start (the same field as delay) and stop in seconds, so a system with a rate can begin partway through a film and stop before it ends; nothing is born at or after stop, and systems without them are unchanged (#1777)
  • The WebGPU path tracer now draws local volumes with emissionRamp and noiseOctaves, matching the CPU tracer; before, backend "webgpu" threw for both (#1785).
  • The WebGPU path tracer now draws grid volumes (the #1735 blast, smoke and fire baked to a grid): density, flame, baked blackbody and, with volumeShutter, the motion blur along the velocity, matching the CPU tracer; before, backend "webgpu" threw and named "cpu" (#1785).
  • Native sequence jobs keep one Cook session through moving geometry such as particles: new triangles rebuild only the changed meshes, and each frame's route reports changedMeshes (#1786)
  • backend: "native" path traces a grid volume with Cook, and the Cook pin has grid volumes (#1789)
  • The CPU tracer no longer traces a hidden part as a wall in a scene with local volumes, so a soft volume next to an idle hidden part is not cut by a hard edge any more (#1793)
  • The CPU path tracer never traces a part marked visible: false any more, so a hidden box casts no shadow and is not drawn, as in Glaze, while a mesh volume that names a hidden part still takes its shape from it (#1806)
  • scripts/render-file-native.mjs serves a GLB above 32 MiB over a local HTTP server instead of a Playwright route, so a single-mesh GLB of 4.8 million triangles (about 82 MiB) no longer closes the loader tab and reaches the native trace's triangle-count error (#1811).
  • A light list over its cap now throws an error that names the cap, says it comes from the 32 bit light-linking mask (1 sun, 16 point, 8 spot, 7 area) and points to merging lights, an HDRI or emissive parts, or backend: native (#1812)
  • Materials take retro: { vertexSnap: [width, height], affineUV: true } for the PS1 look in the raster renderer: vertices snap to a screen grid and UVs interpolate without perspective correction. Materials without it render as before.
  • Blender export reports a light's max bounces below the scene's as not reproduced (Cook has one global bounce limit, no per-light field) (#1825)
  • The path tracer lights a scene with environment.keyIntensity (a scene with no sun, sky or lamp traces black) and applies effects.exposure to the traced picture, as the rasterizer does (#1833)
  • A post pass or material fragment is measured at 4096 bytes of code: comments and extra white space no longer count, and the error gives both sizes (#1834).
  • A post pass reads its time from the motion time when the frame has one (a still at motion.start: 6.5 gets 6.5, as the video frame does), instead of the renderer time, which stayed 0 in a still (#1835)
  • A recipe places a catalog GLB by file name, asset: { "name": "sheep_body.glb" }, in scene_create, scene_apply and (as assetName) scene_create_asset, so a re-exported file no longer breaks it; the scene keeps the resolved SHA-256 (#1843)
  • Native "cycles" exports keep a part with a base or coat normal map and a non-uniform matrix as an instance, so Cook tilts the normal map from the matrix like Cycles instead of from baked unit normals (#1844).
  • scene_apply, scene_render_submit and scene_review count the scene's grid (.67vg) files toward the 64 MiB combined cap, and a scene already over it fails with the cap message instead of crashing the page (#1848)
  • A folder of more than 256 consecutively numbered images is now one sequences entry in scene_asset_catalog (pattern, first, last, frames, size) instead of one entry per frame, and a material map.sequence can name it with catalog instead of listing the frame IDs; the frames are hashed when named, not at startup (#1852).
  • A material map.sequence may list up to 4096 frames of 2048 pixels: a sequence over 64 frames streams, decoding the frame of each time and keeping two, so a canvas that changes over a whole film can be textured (#1852)
  • A stills render job takes stillCount (2 to 300) and writes that many numbered PNGs, one per 1/fps s of the motion clock, so a transparent overlay comes from one job; scene_capabilities jobs also states the largest square frame (#1853).
  • A local volume with noiseOctaves above 1 takes its march steps from its finest noise cell (up to 96), so its edge no longer comes out wider than the real density field (#1855)
  • A native render job and npm run render:file-cook read the scene tables from the page as one Blob over the DevTools stream, which cuts the per-frame export of a dense scene with 1,000 particles from about 125 ms to about 64 ms (#1861)
  • scene_capabilities takes topic as a list of up to 8 names and answers each one in one call, keyed by name (#1872)
  • A native render that falls back because the installed Cook addon is stale now says so, with Cook's own fix (npx cook fetch-addon), instead of blaming a missing Vulkan ray query adapter (#1892)
  • Shape and grid volumes weight each march step's glow by the exact integral over the step, (1 - exp(-tau)) / tau per channel, in the rasterizer, the CPU path tracer and the WebGPU path tracer, so a dense glowing volume is dimmer and its edge narrower: the 1-octave sphere edge goes from 0.2926 to 0.2295 sphere radii against Cycles 0.2330 (#1894)
  • The shipped scene skill now matches the tools: the scene contract says up to seven area lights, light.md says an area light casts a shadow with castShadow: true, and look.md gives 8 MiB as the .hdr file limit (#1897)
  • createGaussianSplats and createGaussianSplatsAsync now refuse a fractional count, a missing or short positions, scales, rotations or colors array, and matrix: null or options: null, each with an error that names the field, the expected length and what to pass (#1899)
  • simplifyGeometry throws a RangeError that names the bad index, its place in indices and the vertex count (or the positions length when it is not a multiple of three) instead of crashing in the collapser, and treats options: null as the defaults (#1900)
  • A scene_apply or scene_create call with several distinct add-explosion operations is now refused at once when its grids pass the 64 MiB combined limit: the check counts each blast at its exact size before baking, instead of after minutes of synchronous baking (#1903).
  • scene_capabilities no longer answers names inherited from Object.prototype (environment.constructor, parts.toString) as fields or entries; a dotted suffix that is not an entry of a plain topic now fails with the list of entries (#1904)
  • EXT_meshopt_compression views are checked before decoding: a bad byteStride, byteOffset, byteLength, count, mode or filter now throws an error naming the buffer view, the field, the value and what to pass, instead of Malformed buffer data: -1.
  • A Draco GLB whose point or face count disagrees with its accessor count, or whose decoded buffer would pass the asset byte limit, is refused with an error naming the primitive, the attribute and both numbers before the decoder heap allocates it (#1913)
  • readGlb in the catalog scripts now refuses a GLB with a wrong header version or total length, an unaligned or past-the-end chunk length, a zero or second BIN chunk, and a bad JSON chunk, each with an error that names the chunk and the lengths (#1919).
  • A glTF primitive compressed with KHR_draco_mesh_compression now applies a sparse block on its accessors on top of the decoded data instead of ignoring it (#1921).
  • scene_render_status of a finished job now returns its record while a newer job runs, instead of failing with "The renderer is leased".
  • A render job with animation on a scene that has no clips now fails with an error that says to drop animation or add a clip, and a missing clips list counts as empty instead of a TypeError (#1928)
  • scene_capabilities with a topic list answers the valid topics and reports unknown names (at most 4) with suggestions in unknown, and an unknown op name suggests the dotted meshEdit.<op> form.
  • The shipped skills now cover review links with reviewFile, placing a GLB by file name, catalog image sequences, topic lists with unknown, stillCount stills jobs and the no-clips animation error (#1938)
  • The agent bench passes the skill prompt to claude as a file, so --skill-mode references runs on Windows instead of failing with spawn ENAMETOOLONG (#1939)
  • detachedPartFlight now settles a part with a size on its most stable face (the largest it can reach by falling or tipping with its landing energy) instead of the nearest face, so a bumper no longer ends standing on its narrow edge (#1971).
  • A finished path traced job reports noise (relative noise before denoising and a one-line verdict) in scene_render_result (#905).
  • scene_look and render jobs name the strongest lights, with the field to lower, in an exposure-clipped finding, so an over-exposed light can be fixed without opening the image (#905).
  • scene_ask_user can show its annotate view inline in chat apps that support MCP Apps, with the same marks as the browser flow (#923)
  • A scene can be exported as a phone review page (scene_export_web with review: true) whose saved marks scene_ask_user reads back with reviewFile (#924)
  • hingedDoorSwing in crucible/addons/vehicle swings a damaged door open on its hinge: a torque-driven, damped swing that stops at maxAngle with a small bounce and rests (#983)
  • detachedPartFlight in crucible/addons/vehicle gives a loose part torn off by a crash a seeded flight: launch from the impulse above its threshold, tumble, bounce and rest on the ground (#983)
  • crucible/addons/vehicle dents vehicle parts on impact, finds the moment a drive meets a wall and lists the parts that tear off, and recipes get a dented geometry (#983)
  • scene_capabilities answers meshEdit and meshStack with each op's arguments (name:type, ? for optional) and the face, edge and vertex rules once, so one call is enough before editing a mesh (#1929)
  • The agent bench can answer scene_ask_user from a test-only fixture file (CRUCIBLE_ASK_USER_FIXTURE, set only by whoever starts the server), with a new ask-user-pin task, so tool schema changes to that tool can be benched (#1956)
  • scene_ask_user: a pin on a part whose material other parts also use returns materialSharedWith (and materialSharedWithMore) like a lasso part, so an agent gives the part its own material before recolouring it; the bench has a new task, ask-user-pin-shared (#1972).
  • Auto-framed camera and the preview ground of a skinned asset now use the drawn (skinned) bounds instead of the bind-pose bounds (#1976).
  • The render-crucible-media skill matches 0.21.0 again: quality tiers, estimate and budget, transparent stillCount sequences, grid volumes in Cook, streamed texture sequences, caches, new limits and error rows (#1979)
  • Audit the scene skill for 0.21.0: fix stale claims (motion duration range, emissiveColor tracks, ask-user wording), add explosion, retro, vehicle damage, pins and lasso, review page, splat palette and turntable how-tos in a new effects-and-feedback reference, and steer agents to the asset catalog, scene_capabilities and scene_look before guessing, boxing real objects or rendering (#1979).
  • The showcase page has a Made with Crucible section for picked community work, and Show and tell asks for the credit, the licence and permission to feature it (#1980)
  • scene_ask_user: the annotate page has a lasso tool; a lasso mark comes back with kind "lasso", its points and the parts under the outline (most covered first, with coverage, edge below 0.15 and materialSharedWith for a material also used outside the mark), and the test-only answer fixture accepts lasso marks (#922).
  • scene_ask_user takes an optional motionTime: the person marks the scene at that moment of its authored motion, and the answer's view.motionTime names it (#922).
  • The marketplace lists the companion packages CodePawl publishes on npm (@codepawlhq/crucible-*) in their own section with an install command, and @codepawlhq/crucible-three-bridge drops the crucible-addon keyword because it is a library that registers nothing (#1988)

0.20.0

  • 67js is now Crucible: the package is @codepawlhq/crucible (addons @codepawlhq/crucible-*), the commands are crucible-mcp and crucible-addon-check, the renderer class is CrucibleRenderer and the skills are build-crucible-scene and render-crucible-media. 67js-mcp, 67js-addon-check and Renderer67 keep working for one release and print a rename notice, and recipes, assets and packs saved with the old 67js.scene, 67js.asset, 67js.pack and 67js-pack.json names still load. (#1183)
  • The Cook native renderer gives the same image for the same scene, seed and settings whatever the dispatch split, so two renders no longer differ in a few bytes (#1006)
  • A mirrored copy (negative determinant matrix) in a flattened path trace now keeps its triangles facing outward, so the native cycles kernel renders it like the instanced scene (#1014)
  • A render job films a recipe whose only motion is physics, cloth or particles with motion: { start: 0 }, no bake-motion first and no 32 node cap (#1017)
  • A native render job without Open Image Denoise now filters with the GPU a-trous filter of the native tracer instead of the slow CPU wavelet filter, and the report says denoiser: "atrous" (#1018)
  • Native render jobs and the Cook comparison keep one OIDN device and filter loaded in the render-native addon, so a denoise after the first skips the tool start, device creation and PFM files, and createOidnDenoiser and findOidnLibrary in the denoise package expose it (#1025)
  • The cycles kernel now matches Cycles on textured cutouts and emitters: a light sample on an emission map reads the map at its point, and a shadow ray no longer lets light through the solid texels of a cutout whose alpha is below 1 (#1030)
  • The Cycles kernel decodes an 8-bit sRGB colour map after filtering it, as Blender Cycles does, so textured surfaces no longer render 2 to 5 percent brighter than Cycles (#1030)
  • Native render jobs on the cycles kernel send each material whole, so blend opacity, sheen, specular tint, anisotropy, iridescence, attenuation and the layer textures reach the kernel instead of rendering opaque or without the layer (#1036)
  • The Cycles reference script renders point and spot lights with a radius as spheres (Soft Falloff off, which Cook models) instead of Blender's default oriented disk, so Cook and Cycles agree on sphere lights again, and render-cycles.py --soft-falloff default|on|off picks the other behaviour (#1040).
  • A scene built for the native path tracer can take more than 400,000 triangles: buildTraceScene accepts maximumTriangles (up to 4,000,000 unique triangles, and four times that with every copy counted), native render jobs on the cycles kernel use it, and the CPU and WebGL path tracers keep the 400,000 limit and its error text (#1041)
  • The README and the site changelog lead with renders, led by the Blender Classroom demo scene (Christophe Seux, CC0) drawn by 67js, and the README states what 67js is for before the install steps (#1043) A sunlit classroom with wooden desks and chairs, a green chalkboard and tall windows, rendered by 67js
  • Change notes can carry a picture or clip with a media: <url> <alt text> line, shown on the site changelog and in the GitHub release notes (#1043)
  • A grid volume takes frames (a list of .67vg files) with fps and loop and plays at the scene time in the rasterizer and the CPU path tracer; scripts/vdb-to-grid.py --sequence converts a numbered VDB sequence in one run (#1045)
  • Local volumes take shape: "grid": a 3D texture of density, temperature and flame from an OpenVDB frame (scripts/vdb-to-grid.py), drawn by the rasterizer and the CPU path tracer with Blender-style density, blackbody and anisotropy inputs (#1045)
  • Post steps distortion (an expanding shock ring and heat haze that bend the picture by depth) and flash (a timed brightness lift that feeds bloom) can be placed at a point or on a node and follow the scene clock and motion tracks (#1049) A street before and after a shock ring and heat haze
  • A native render job packs its maps straight into the FORMAT-v2 texture pool, so a scene with more than the 4096 by 16384 texels of the old atlas renders instead of failing with "The material textures do not fit the GPU atlas" (#1053)
  • A part takes rayVisibility: { camera, diffuse, glossy, transmission, shadow, volumeScatter } to hide itself from ray kinds in the native path tracer, so a glazed window can stop blocking the sun and sky (#1054)
  • A scene built for the native path tracer can hold up to 500,000 instances of shared geometry instead of 65,536: buildTraceScene accepts maximumInstances, native render jobs on the cycles kernel use it, and the CPU and WebGL path tracers keep 65,536 (#1055)
  • The native cycles kernel draws thin sheets that let light through, such as curtains, leaves and lampshades, from the material fields diffuseTransmission and diffuseTransmissionColor, checked against Blender Cycles (#1058)
  • Added packCameraParams(kernelParams, camera, { seed }) and session.render({ camera, seed }) to the native render package, so a film with a static scene sends only the camera per frame instead of packing the scene again; a frame seed is now written into the frame (it was ignored before) and an invalid seed throws.
  • The cycles native kernel draws a point or spot light with softFalloff: true as the oriented disk of Blender's Soft Falloff (sampling, hits of a path, light tree), carried by the light record flag 32, the recipe light field and buildTraceScene; a light without the field stays a sphere, and render-cycles.py follows each light's softFalloff unless --soft-falloff is given (#1060).
  • Fix render jobs of a fractured wall tripping the browser heap guard: the guard collects garbage before it judges the heap, so only live memory counts.
  • The MCP asset catalog now loads a GLB whose textures sit next to it, such as a Kenney kit's Textures/colormap.png, and embeds them, so a CC0 download works as it is (#1062)
  • scene_apply can place the first instance of a catalog asset, so an agent builds a scene step by step and adds a model in any step (#1063)
  • A sun below 14 degrees now gives a warm golden hour from the sun alone (orange horizon, dimmer blue zenith, stronger warm key, fitted to Blender's sky at 2, 6 and 15 degrees; a sun at 14 degrees and above is unchanged), and environment.sky.preset accepts golden-hour, sunset and blue-hour (#1072).
  • --scene file renders staged showcase scenes: each glbRest part loads with the shared textures and joins in the showcase page's rank order, so the airport and datacenter scenes film with every part (#1085)
  • A render job holds a recipe camera locked for the whole physics, cloth or particle film, and a regression test now checks it (#1089)
  • A render job or a look at a time keeps the automatic floor and horizon fixed by the pose at time 0, so physics shards flying or falling no longer resize the floor or move the horizon of a fixed camera (#1089)
  • Parts of a native path-traced scene whose materials are equal now share one material record, so a copy of a mesh costs 160 bytes in the input instead of 416 and a native render job takes up to 1,000,000 instances (#1100)
  • Agents now read the cylinder and sphere radius right: the geometry notes say node scale is the radius and give the flat and corner widths of a 6-segment cylinder, so hex parts stop coming out twice too wide (#1116)
  • Cook's cycles kernel supports light portals: a rect area light with portal: true emits nothing and the sky is sampled through it, so a room lit only through a window converges; the other tracers ignore it and say so (#1118).
  • A native path traced video blends each denoised frame into the ones before it, reprojected with the first-hit distance and the camera, so denoised frames stop shimmering under a moving camera; JS67_NATIVE_TEMPORAL=off turns it off (#1120)
  • Added environment.cameraIntensity to the native cycles kernel: the strength of the sky for camera rays, also through glass and cutouts, apart from the strength that lights the scene, so a window view can be drawn at 0.2 in one pass (#1121).
  • Cook's cycles kernel writes the distance to the first surface as the depth guide for a sample that scatters in fog before it (it held the scatter distance, so a pixel in light fog came out short), and the README now explains the unit of clampDirect and clampIndirect (Cycles' unit, sent to the kernel times 3) (#1122)
  • Cook native: dispatchBudgetMs cuts each frame into dispatches that cover a tile of pixels and a number of samples, sized from the measured time of the earlier ones, so no dispatch holds the GPU longer than the budget and a display on the same GPU can draw between them; the picture is byte-identical to the one without it, and the result reports dispatchCount and the tile size range (#1124).
  • A process that rendered with the Cook native renderer no longer crashes with SIGSEGV when it exits on Linux with an NVIDIA GPU: the addon now closes its GPU device during Node shutdown, so node --test stops failing files whose tests all passed and a CLI render exits 0 (#1136)
  • Renderer67 takes a background option and a setBackground() method for the clear colour behind the scene, with alpha for transparent canvases (#1141).
  • A render job store lock left by a killed MCP server is taken over by the next start when its owner process is gone, instead of asking for a manual repair; a live owner or an unrecognized lock file is still refused (#1147).
  • Import glTF files with KHR_materials_specular colours above 4, normal maps on TEXCOORD_1, base color maps on TEXCOORD_1 and textures on primitives without their UV set: they load instead of failing, and warnings name the materials that lost a map.
  • Render a very large GLB (200 MB and up) from a scene file without losing the browser tab, and use less memory while loading it (#1151)
  • npm run render:file-cook path traces a GLB with an HDRI and a camera on Cook and writes the picture with a timing report (#1152)
  • The unused home hero prototypes under src/hero-lab/ (three candidate heroes, their scene files and style sheet) are removed; the home page hero is unchanged.
  • render:file-cook traces up to 256 point, spot and area lights together instead of stopping at 7 area lights (#1158)
  • A native render job and render:file-cook read the scene from the page in chunks, so a scene is no longer bounded by one message: the triangle bound rises from 1,500,000 to 4,000,000 (#1158)
  • Load a glTF with a negative texCoord or a metallic or roughness factor outside 0..1 the way three.js does: drop that map or clamp the factor, and name the material in a warning.
  • Load glTF meshes with up to 256 morph targets (face rigs have 175): all stay stored, and a draw applies the 64 with the largest weights.
  • Normal maps that point into the surface or reflect the view ray below it are bent back above it, the way Cycles does, so a colour photo wired in as a normal map no longer turns a floor green (#1167)
  • Cook no longer pays for an emission map read on every light sample in a scene whose emitters have no emission map: a 349k triangle interior sampled about three times faster on an RTX 3090 (#1170)
  • Cook no longer pays for texture mip code on a frame that leaves texture mips off: a fogged, textured scene sampled about five times faster on an RTX 3090 (#1170)
  • Cook reads an environment map as it is, as Cycles does: the default limit of 16 on HDRI texels is gone, so a scene lit by an HDRI with a real sun is no longer too dark (#1172)
  • Cook lights a scene from an alpha-blended emitter by the share its opacity covers, as Cycles does: a window sheet of opacity 0.25 no longer lights a room four times too much (#1172)
  • @codepawlhq/67js-render-native takes a kernel option ("legacy" or "cycles", with JS67_NATIVE_KERNEL fallback) and splits the native host and Cycles v2 ABI modules (#626)
  • A post pass can list parts in objects and call objectSlotAt(uv) to read the object ID pass, so a snippet grades or blurs one object (#707)
  • A recipe that places a glTF asset now loads the flush code on its own, so asset facades a few millimetres apart are cut or ranked in hosts that did not call loadAllAgentSceneModules(); tests pin both on asset parts and show that 24-bit and float depth separate all 16 ranks from 1 m to 1 km (#751).
  • Measured what the #751 flicker fix costs in bundle bytes, render-target and geometry memory and frame time, and noted it in the size file (#751) A low camera pan over a warehouse floor with yellow lines and racks, drawn without flicker
  • The path tracer lifts faces the flush pass ranked instead of cutting, so the face in front is hit first and the one behind no longer shows through (#751)
  • The flicker probe has an exact ground truth: every triangle is drawn unlit as its own number and compared with a float64 ray cast, so it counts true visibility flips and not colour-test false positives (#751)
  • The path tracer lifts ranked faces of skinned parts at their pose too, and the flicker probe draws its face-id frame without MSAA, so ids round-trip exactly (#751)
  • The flicker probe splits offRay pixels into edge, colour-step and unexplained ones, reports an upper bound of true flips, and keeps a configurable number of ray hits (#751)
  • The build-67js-scene skill now says what the flush pass leaves for the agent: no hand offsets or decal for near-flush faces, and a rank-overflow diagnostic means remove the duplicate faces (#751).
  • The flicker probe reads the trap scenes with the exact per-triangle ground truth (facets=2), --assert judges true flips instead of swaps the flush pass asked for, and the committed trap results show 0 flips on every trap with the flush pass on (#751)
  • set-game can drive the player as an arcade car (controller: "vehicle", maximumSpeed) with a chase camera, and the web smoke plays a driving course next to the creature run (#777)
  • A game with game.physics: true now exports to the web: the page steps the recipe physics section live with Jolt at a fixed 60 Hz, the engine and its wasm ship beside the page and load by relative URL, and a crate-pocket physics puzzle joins the creature and driving samples (#777)
  • The netcode addon gains createDataChannelTransport: one WebRTC data channel per peer, so a host player or server can sync players and props over WebRTC with the same authority and prediction code (part of #778)
  • Loading a world no longer stalls the page on the GPU process: a linked shader program is accepted without reading shader status and logs, the shadow framebuffer is checked once per size and the anisotropy limit is read once; sliced replaceParts also groups appended parts that share a geometry or batch with earlier ones (#779)
  • renderer.preloadTextures(parts) uploads large textures in bands of at most 1 MiB with a yield after each, so a world switch no longer hands the driver a whole image in one call, and measure-hero-load.mjs --watch-seconds counts the main-thread tasks over 50 ms after first paint (#779)
  • A particle system with spin no longer turns every vertex to NaN while its first particle is unborn or dead, which made the coplanar diagnostics of a video render throw at the frame where that happened (#839)
  • water ripples keep every wave a pixel can still show, so far open sea matches a supersampled render more closely and shimmers less when the camera moves (#853)
  • A local volume blurs the light seen through it by its optical depth (new blur field, 0 to 1, default 1, at most 14 px of a 540 row frame, never smearing objects in front of the volume), and density is documented as extinction per metre with a table of thin haze and thick smoke values (#855)
  • The noise of a local volume also ripples its faded edge, so a wide-falloff box or sphere reads as a cloud and not as a rounded rectangle; the blur behind a thin volume reaches 24 px of a 540 row frame and no longer carries the edge of an object in front into it; the sun's shadow depth is 1.2 and the fringe saturates at profile 1/6 so the lit side of a smoke has no bright rim around a dark body (#855)
  • A scattering local volume no longer glows along its faded skin or outshines a sunlit surface: the depth the sun and sky cross counts the faded outer share at up to three times its density, so a sun ray running along the top or side skin is shaded like the body, and the key gain drops from 8 to 4 so the smoke never returns more than a sunlit surface of its albedo, in the rasterizer and the CPU path tracer; scatter: 0 is unchanged (#855)
  • environment.localVolumes[].scatter (0 to 1, default 0 draws as before) lights a local volume with the key light (shadow map, phase function and the volume's own depth toward the sun) and the sky, in the rasterizer and the CPU path tracer (#855)
  • A local volume's march starts from interleaved gradient noise instead of a sine hash, so low step counts no longer leave clumped grain in smoke (#855)
  • A noisy local volume is marched with at least two samples per noise cell along the ray (up to 32), so a low steps no longer leaves a pixel-pitch dither in smoke (#855)
  • A box local volume with a falloff fades out round at its edges and corners (the distance past its core box) instead of along boxes with mitred creases, so a faded smoke has no visible box outline or corner crease; the fade along a face is unchanged, and the key gain is now 3 (#855)
  • The sky light of a scattering local volume passes through the volume's own depth (up and four side directions, one tap each, in the rasterizer and the CPU path tracer), so the core of a thick smoke is darker than its rim; scatter: 0 is unchanged (#855)
  • The sun side of a scattering local volume is clearly brighter than its shade side without a glowing top or side rim: the depth toward the sun is measured along the sun's direction with its elevation cut to a tenth, the key gain rises to 8 and the shadow strength to 5, and the sky term keeps a fifth of its share, in the rasterizer and the CPU path tracer; scatter: 0 is unchanged (#855)
  • A scattering local volume lights its key term through the smooth depth toward the sun (counted four times, scaled by a key gain of 3) and its sky term through the smooth depth in five directions, so the sunward side is brighter than the shaded side and the core of a thick smoke is darker than its rim; the depth taps skip the noise, which cuts the cost of a lit volume by more than half; scatter: 0 is unchanged (#855)
  • Make the scene_capabilities graph text say fresnel works as an emission factor and name what is still missing, and drop the pass argument scene_look does not take from the post mask docs.
  • A material graph takes a fresnel node as a factor of emission (Part of #860): the rasterizer and the CPU path tracer scale the emission by Schlick's Fresnel of the IOR per pixel, so glass-like rims glow toward grazing angles.
  • Cloth sheets take bendModel: 'dihedral' for many soft folds instead of one crease, bendYield and bendSet so a fold keeps its crease instead of being pulled flat again, staticFriction so a layer rests on the floor or a slope below its friction angle, and pinTo.releaseAt to let a carried cloth go, self collision handles up to 5000 particles and runs about 3 times faster, and a 64 by 64 flag bakes a 4 second film in about 13 seconds (#866)
  • A game recipe drives the animation state graph, blend spaces and path-following NPCs with player.animation and npcs, and the exported web page plays them, checked in headless Chrome by smoke-game-web (#872)
  • The home hero starts its first view with the page, in parallel with the poster, instead of after the poster loads (#884)
  • The home hero asks for the build's two on-demand chunks while the first view downloads (#884)
  • The home hero draws its first live 3D frame from a 2 MB first view of the Port and swaps in the full world when it has arrived, so on a slow link the 3D shows in about 3.5 s instead of after the whole 9.7 MB (#884)
  • The home hero starts its first world's download as soon as the poster has loaded, ships a lighter Port with valid WebP textures, and shows the poster with a "Play live 3D" button instead of fetching 3D on save-data, 2g/3g or 4 GB devices (#884)
  • The README, home page, llms.txt, package keywords and plugin text name each renderer backend (Glaze on WebGL2, Cook on CPU and WebGL2, and on Vulkan with the optional packages/render-native, with opt-in WebGPU) (#890)
  • The README and home page show the measured tier table across six scenes on an idle card, with realtime-high marked as planned and Cook against Cycles stated per sample and at equal error (#890)
  • The native path tracer package takes a kernel option ("legacy" or "cycles", default "legacy") and documents its v2 scene pack format (#893)
  • traceNative adds a kernel: 'cycles' path tracer matching Blender Cycles 5.3 across Principled v2 closures, solid-angle lights, and FORMAT-v2 scene buffers (#894)
  • The Cook cycles kernel reads area light shape (disk, ellipse) and spread and a blended material's opacity (transparent shadows) from the parity scene description, with two new reference scenes (#894)
  • The Cook cycles kernel passes the first transparent surface at a transparent bounce limit of 0 and gives shadow rays only the transparent limit the camera path has left, both as Cycles does (#894)
  • Cook, the native path tracer, has an opt-in cycles kernel (kernel: 'cycles' or JS67_NATIVE_KERNEL=cycles) that matches Blender Cycles 5.3 on six reference scenes; the default image does not change (#894)
  • The Cook cycles kernel picks next event lights through the Cycles light tree (lightSampling: auto, tree or uniform; --light-sampling in trace-native.mjs), built by the host over analytic lights, a sun and emissive triangles; useLightTree: true|false is another name for lightSampling: 'tree'|'uniform' (#895)
  • A packed FORMAT-v2 input without light tree emitter tables is rejected when it asks for the tree (traceNative throws for lightSampling: 'tree' and uses the flat pick for auto), filterType and filterWidth now apply to an already packed input, and buildLightTree throws above 32 distant lights (#895)
  • Add the parity scene many-lights-500 (a 60 m hall with 500 small point, spot and emissive lights) and let the parity harness build scenes with more than 32 analytic lights, to measure the Cook light tree against the flat pick and against Cycles 5.3 (#895)
  • The Cook cycles kernel samples with Cycles' Sobol-Burley blue-noise pattern by default; sampler: "white" (--sampler white in trace-native.mjs) keeps the old hash sampler, and sampler: 'pcg' is another name for it (#895)
  • The Cook cycles kernel samples the pixel filter from the Cycles 1024-entry table (filterType: box, gaussian or blackman-harris; filterWidth 0.01 to 16), and bad filter values now throw instead of falling back to box (#895)
  • A camera with an fStop now renders with depth of field in the native path tracer's cycles kernel, with Cycles' thin lens (round or polygonal aperture, focus distance along the view axis), and a pinhole camera renders the same pixels as before (#896) The native path tracer focusing from a red sphere in front to a gold and a purple sphere behind it
  • Native render jobs keep repeated geometry as instances on the cycles kernel, and a copy whose material makes the shared mesh emissive is sampled as a light at the right triangle (#896)
  • buildTraceScene takes { instancing: true } to keep copies of one geometry as instances for the native "cycles" kernel, counting triangles once per shared geometry and allowing more parts than the flattened limit (#896)
  • createNativeSession in @codepawlhq/67js-render-native keeps a scene on the GPU between Cook frames, so a later frame of the same scene compiles no shader and builds no acceleration structure (#896)
  • Native render jobs with several frames keep one persistent session, so a camera move builds nothing after frame 1 and each frame's report names the route it took (#896)
  • A native session builds one image over several render calls (accumulate, targetSamples, reset(), resolve()) and applies new material values, lights and instance transforms with update() without a new pipeline or BLAS build (#896)
  • The Cycles kernel reads cutout alpha through the same texture sampler as shading, a masked or blended material no longer multiplies its alpha by the colour map's red, and a texture set past the 1 GiB pool fails at packing with its size and the limit (#896)
  • The native cycles kernel can read texture mip levels: textureMips: true stores a mip chain after level 0 and picks the level from a ray cone (off by default, so pictures match Blender Cycles and every existing scene stays byte-identical) (#896)
  • traceNative takes denoise: "atrous" for the Cook kernel and returns a second, GPU wavelet filtered image in denoisedRgba (biased, off by default), and denoiseAtrous filters any traced image with its guide buffers (#897)
  • The Cook cycles kernel can sample the environment map with MIS compensation (envCompensation: true or a fraction from 0 to 1; --env-compensation in trace-native.mjs), which lowers the error under a sunny HDRI and is off by default (#897)
  • The Cook cycles kernel now starts a pixel's next sample as soon as a path ends by default (pathRegeneration: false or --no-path-regeneration in trace-native.mjs restores the old order), which cuts sampling time with the same image (#897)
  • The Cook cycles kernel starts a pixel's next sample as soon as a path ends when you pass pathRegeneration: true (--path-regeneration in trace-native.mjs), which cut sampling time by 9% to 37% on four scenes with the same image (#897)
  • Cook, the native path tracer, now lives in its own repository and npm package @codepawlhq/cook; 67js finds it by name (or at COOK_PACKAGE_PATH), and without it renderer.backend "native" falls back with a note that names the install command (#898)
  • A Blender add-on (packages/blender-addon) adds Cook as a render engine: it exports the scene with instances, lights, the world, the camera and Principled BSDF materials, and renders it with the native path tracer (#900)
  • scene_render_submit takes settings.quality (draft, realtime, realtime-high or final) to render a scene in the tier you need, falls back one tier with the missing capability named, and scene_capabilities jobs lists the tiers this device can run (#904)
  • scene_render_submit takes settings.budget (secondsPerFrame or framesPerSecond, optional memoryMiB), picks the path tracer samples or the raster frame size whose estimate fits, and returns what it picked and why (#904)
  • scene_render_submit returns the expected time and peak memory of a render job before it runs, and scene_render_result ends with one report of the measured time, peak memory, samples drawn and what fell back and why (#905)
  • scene_look and render jobs also report materials whose texture is missing and parts that z-fight, naming the parts, and a path traced job says why exposure findings and render passes are unavailable (#905)
  • scene_look lists floating parts, intersecting parts, parts outside the camera and the share of a blown-out or black frame as findings with part names and numbers, so an agent can catch them without reading the picture (#905)
  • The MCP server checks the npm registry once a day in the background and tells the agent when a newer 67js exists, so it can ask the user to update; 67js-mcp --check-update asks by hand and SIXTYSEVENJS_NO_UPDATE_CHECK=1, NO_UPDATE_NOTIFIER=1 or CI turn it off (#907)
  • A game recipe animates a placed, retargeted character: player.animation and npcs[].animation take clips of asset files (from: { asset, clip }), the graph blends idle, walk and run by speed with planted feet holding to under 1e-4 m, and the web export writes the placed assets to assets/<id>.glb for the page to load (Part of #913)
  • set-game over MCP can turn a placed asset into an animated player or NPC: the server now loads the extra decoded copy the game's animation needs, so a retargeted character set up by scene_apply no longer fails with "copy 1 is not loaded"; smoke-game-web.mjs character walks a retargeted humanoid to a goal on the exported page, and the build-67js-scene skill has a game reference on animating a placed character (Closes #913)
  • The home hero's first-view sky is now 256 by 128 (131 KB, was 128 by 64), so the sky at the swap to the full world differs 3 to 6 times less in mean colour (#918)
  • scene_ask_user opens the current view in the browser so a person can pin points with notes, and returns each pin as a part ID, world point and normal (#922)
  • A node takes shadowOnly: true to cast a shadow while staying out of the picture, for a gobo such as a window frame outside the shot (#926)
  • The chip fab engineers on the home page now face the way they walk, swing their arms and keep walking for as long as the world stays on screen, where before they glided sideways and froze after 12 s (#927)
  • The albedo, object ID and other render passes now draw with the same reversed-Z 32-bit float depth as the beauty pass, so near-flush faces no longer flip in those buffers where the beauty image shows them steady (#934)
  • With resolveCoplanar: false, the near-flush pair report now reaches as far as the flush search (2 mm or more by scene size, never under 1 mm), so a 1.5 mm pair is reported; the pair count in the report stays bounded as before (#943).
  • scene_apply nodes take shadowOnly: true, and the Cook cpu backend leaves a shadow-only node out of camera rays while it still blocks shadow rays and shows in bounces (#958)
  • Cook keeps the light that bounces between microfacets on rough metal and widens glossy lobes after a diffuse bounce as Cycles does, so the metal reference scene lands 5 times closer to Cycles at 256 samples (#959)
  • Cook native renders split themselves into dispatches that each stay under about half a second, so a heavy scene such as 500 lights at 960x540 and 256 samples no longer loses the Vulkan device, and a lost device now raises an error that names how to lower the work per dispatch (#960)
  • The agent bench no longer passes --max-budget-usd to claude -p, which Haiku read as a nearly spent budget and quit on; bench/agent-modeling/run-guard.mjs now adds up streamed token cost and kills a runaway run by cost or time (#962).
  • The cycles native kernel ends paths by Russian roulette like Cycles (survival is the square root of the throughput), cutting the error on emissive scenes by about 20 percent at equal samples, for about 10 percent more time per sample (#966)
  • The wavelet denoiser keeps the input pixel where every neighbour weight is zero (background pixels with a zero normal), so the Cook cycles kernel no longer returns NaN there (#969).
  • Render jobs with backend: "native" trace with the Cycles-matching kernel, pass noiseThreshold to it and denoise with OIDN and the albedo and normal guides by default (the wavelet filter with a note when OIDN is missing); a source checkout now finds packages/denoise-oidn without an install, and JS67_NATIVE_KERNEL=legacy keeps the old kernel (#970)
  • The README and the home page have a Sponsors section that links to GitHub Sponsors (#971)
  • The Cook gpu, webgpu and native backends leave a shadowOnly node out of camera rays like the cpu backend, while it still casts shadows and shows in bounces, and docs/agent-scene.md lists the backends that honour it (#973)
  • A --jobs folder that is a directory link (a Windows junction) now works: it is resolved once at startup, scene_capabilities works without a job store, and a job store that failed to open is retried on the next call instead of failing until restart (#976)
  • A web game export with a pattern or map material keeps playing after a rules part is hidden or shown; the creature smoke now covers a textured floor with hidden coins (#978)
  • scene_apply takes a fracture-node operation that breaks a convex node into 2 to 64 glued Voronoi pieces with physics bodies and breakable joints (#979)
  • Physics joints take breakImpulse and src/fracture.js fractures a convex part into glued Voronoi fragments that break on impact (#979)
  • The new settle step (addons/settle, and the settle operation of scene_apply) drops scattered boxes and balls onto scene colliders as rigid bodies and keeps where they rest as static parts, with density, spacing, size and rotation variation, max slope, no initial overlap and stacking on earlier settles, the same seed giving the same transforms (#980)
  • Spring bones: motion.springs makes hair, tails and soft parts lag behind the animated pose, swing and settle (VRM spring bone model with sphere and capsule colliders), deterministic at a fixed 1/60 s step in the live scene, imported assets and bake-motion (before and after) (#981)
  • A floating hull becomes a steerable boat with float.boat: throttle and rudder push the stern, keyframed in a bake or set live by the new boat player controller, and an optional wake leaves white water behind it on the ocean (#982)
  • Floating bodies sit on the wave the ocean edit draws at their place: the buoyancy read the waves with the two horizontal axes swapped, so a body rode the mirror of the drawn sea (#982) A fishing boat turning through waves with a wake
  • Bodies that float now sample the ocean waves on the same horizontal axes as the drawn ocean mesh edit, so a hull rides the wave it sits on and not its mirror (#982)
  • Rigid bodies float on the ocean: physics.ocean and a body float field make crates and hulls bob, roll and settle on the drawn waves, at the height of the drawn sea (#982) Crates and a boat riding ocean waves
  • Packs refuse remote URLs hidden in JSON keys and JSON nested more than 64 levels deep, and a pack folder may hold only the manifest, its listed files and LICENSE, README, NOTICE, CHANGELOG or AUTHORS text documents (#984)
  • Add a Marketplace page that lists the data packs built from packs/ (zip, size and SHA-256) and the third-party addons found on npm (#984, #985)
  • 67js-mcp --packs <folder> loads data-only packs of materials, recipes, looks, HDRIs and GLBs from a 67js-pack.json manifest, checked at load, listed and read through scene_asset_catalog, with npm run pack:check for authors (#984).
  • The MCP server loads third-party addons the owner allowlists at startup (--addons, --allow-addon) and recipes accept the controller and camera kinds they register (#985)
  • Third-party addons have a contract, a checker (npx 67js-addon-check), a guide (docs/addons.md) and a starter template (#985)
  • The optional @codepawlhq/67js-three-compat addon accepts the common three.js names and builds 67js parts from them, and "If you know three.js" maps each three.js idiom to the 67js call (#986)
  • Added a blind pairwise look judge for 67js and three.js renders of one task (seeded first and second order, a same-render control for position bias, wins per system with an exact binomial p), printed by compare-threejs.mjs --pairwise, and a fixRounds count in run records (#987).
  • @codepawlhq/67js-three-bridge is a new optional addon: fromThreeObject imports a three.js object tree as 67js parts with a warning list, toThreeObject builds three.js meshes from parts, and exportGlb writes the GLB (#989) A three.js scene on the left and the same scene after import into 67js on the right
  • The npm package now ships build/67.standalone.js, one self-contained ES module with no relative chunk import, so https://cdn.jsdelivr.net/npm/@codepawlhq/67js@<version>/build/67.standalone.js loads from a single script tag. It is also exported as @codepawlhq/67js/standalone, and the site copy at /releases/<version>/67.module.js is checked to have the same bytes. docs/learn/install.md has the jsdelivr snippet. (#990)
  • Balanced the unit test shards from measured timings: untimed test files are dealt by the median timing instead of a hash, the timings are refreshed, node scripts/shard-test-files.mjs --from-run <run id> refreshes the timings (#996).

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.