AI tools: The Forge, sculpting and painting

Making models: the Forge, sculpt, paint, bake, import. 72 tools. You see every step your AI takes and can undo any of them.

apply_look

Set the whole photographic mood in one step, the way a lighting artist would: sun height and strength, sky, haze and color grade together. Presets: cinematic (default), golden_hour, overcast, noir, night, war_torn, neutral, stylized, retro. Stylized defaults to 3 bands, softness 0.08, rim 0.2 and a hard highlight. Fine-tune afterwards with edit_entity on Camera_Look.

bake_lights

Baked lamp light (light_volume): a room's still lamps marked point_light baked are worked out once, with real ray-traced shadows, into the light_volume's grid; while the camera is in or near it, those lamps leave the lit pass and the shadow atlas (a room of many lamps runs like one of few). Reports each volume's grid, the lamps it holds and whether it is ready; rebake: true bakes them all again (after moving walls or furniture: lamp changes rebake by themselves). Measure with frame_profile before and after.

bake_weapon_aim

Bake a weapon pose set so a character holds a gun in play (locomotion, aiming, recoil, reloads) with Pose & Grip's hold: the full hold is solved at the ready and aiming (shouldered for long guns; held out for a pistol) at aim pitches -60...60° and saved as Assets/Motion/Poses/<name>.weaponaim.json. The character's animator upper becomes "Weapon/<name>" and the gun is attached to its right hand: in play the trunk turns to the aim, the gun rides the chest with its kick, and both hands stay locked on it (never stretched). In first person (character view "first_person") the gun is held for the eyes instead, with the same grip: drawn as view model, sights on the screen's centre when aiming (check_sights). Reports each hand's worst distance from its seat over the pitches.

bake_world_map

Bake the scene's open-world map picture (top down, north up): sea shaded by depth, land by height with hill shading and sandy shores, every road of the road network by class (freeway/ramp amber, avenue light, street grey, trail brown, runway). Writes Assets/Map/<scene>_map.png and <scene>_map.json (bounds [min x, min z, max x, max z] in metres, for a minimap widget's image and bounds). size: pixels on the long side (default 4096); bounds: the area (default: all the land plus a margin).

blockout_to_buildings

Turn blockout boxes into buildings: every object drawn as builtin:cube in a group whose name starts with `group_prefix` (default "Blockout") becomes a `building` standing where the box stood (its footprint the box's x and z size, its height the box's height, its yaw kept), styled by its KIND (the object's name without a leading M and number: M12house is "house") through `styles` {kind: style}. Kinds not in `styles` are left as boxes. Then run rebuild_buildings. One undo step.

build_from_spec

Build an object that works from a mechanical spec (.mech.json: parts with shapes and sizes in mm, joints with pivots, axes and limits, couplings, interactions, checks): every part's mesh (box, cylinder, tube, torus, disc, wedge, panel, sweep, lathe) with its material, the parts as objects riding on their parents, hinged doors/hood/trunk that open through actions (E, game.act, cutscene act events), wheels that turn and steer when it's driven (three or more wheels on the ground make it a vehicle), couplings (a steering wheel to the front wheels, a crank to the rear wheel by the selected gear). Runs the spec's checks against what was built and reports PASS/FAIL with numbers.

building_styles

The building styles and looks this project can use: the engine's built-ins and the project's own (Assets/Buildings/<name>.style.json, based_on a style and naming only what differs; Assets/Buildings/looks.json: {name: {surface, tile, color, roughness, metallic, glow}}), what's wrong with those files, and every key a style file takes.

craft

In Play: what an object (default the player) can make, at a station (an object with station tags, or the tags), with have/need for each input and why not; with "recipe" it makes it (times, all or nothing per time) as the crafting screen would. "learn": teach it a recipe that starts unknown.

detail_pass

The Detail Pass on any native Forge model, without touching its recipe: the 'looks real' layer for hero objects. Shape detail at the seams, placed by rule from the model's own faces: rivets, hex bolts, nuts, screws, nails and carriage bolts round a face's border, at its corners, in a grid or along panel gaps (skipping spots another part covers); trims swept round a face's border (bead, glazing putty, gasket, angle iron, edge cap, any moulding); panel gaps (plates with grooves and their own shades); real bevels on every hard edge; repeated small parts merged. Shape-aware wear from the model's crevices, edges and hand spots: chipped coats on exposed edges, grime in gaps and round every fastener, rust bleeding from steel heads, brass tarnished in crevices and polished where touched, dust on upward faces, material recipes in the model's own colours. Writes Assets/Forge/<out>.js (f.include of the original plus one f.detailPass call) and builds it; the original stays. Runs in the background on a small, low-priority CPU pool: build returns a job id at once, status follows it, cancel stops it; a big model is painted within budget_seconds (default 600) and max_parts (default 400) and comes back marked partial if it needs more. action help lists every option.

forge_body

Build a whole person from a full-body reference sheet (one person in an A-pose, front view and profile side by side on a plain backdrop: make one with Nano Banana in Google Flow). Apple Vision finds the joints and the person; the body is sculpted from the views' widths and depths, rigged with the engine's bone names (it plays the shared animation library) and skinned with the photos. Into Assets/Characters/<name>.glb. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

forge_body_native

Make a rigged human body with TTR Body, the engine's own generator (no MakeHuman data, about two seconds): an anthropometric skeleton, muscles and fat as soft volumes, one fixed template mesh wrapped onto them (every body has the same vertices, so bodies blend and clothes fit), heat-diffusion skin weights, twist joints and joint correctives, a generated skin. The head is a placeholder until a face is attached at the neck ring (listed in <name>.human.json). Into Assets/Characters/<name>.glb; give the entity mesh_renderer { mesh "Characters/<name>.glb" } and animator { clip "auto" library "Characters/Mannequin.glb" }. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

forge_cave

Carve a walkable cave out of rock: tunnels along a path (its first point is the mouth) and rounded chambers, flat-floored, walls broken by ledges and knobs, stalactites and stalagmites, meshed as one shell facing into the air. World coordinates; with `ground` (the land's heightmap) everything above the ground is cut away, so the tunnel opens from the hillside. Writes Assets/Forge/<name>.glb with its origin at the mouth. Place it there with mesh_renderer, collider { shape "mesh" } and a surface (a photo rock), open the land over the mouth with terrain_hole, light it (point lights, glowing crystals, fireflies). HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

forge_character

One call: original pictures of a character, creature or figure → a painted, rigged model, marked by the Forge itself. Cuts each figure out (front and side, back, high view: one picture may hold several), reads depth, finds the parts with no generator (head, ears or horns, two or four arms, legs, tail), makes the panels agree, carves, paints each part from the pictures that show it, adds the fine material, and builds a skeleton and skin from the parts (humanoid bone names, so the motion library drives it; extra chains for a tail and ears). The report ends GRADE n of m pass and names what to look at. Pass it again with cloth colours from the report's 'colour families' note, or with sharp_pictures, for finer material. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

forge_creator_kit

Make the in-game character creator's kit from a forged person (make one first with forge_person; an in-between build reads best, e.g. sex 0.5): TTR Body rebuilt at each body slider's ends (build, age, height, weight, muscle, shoulders, hips, legs, arms, neck) and carried onto the whole person (welded head, eyes, teeth, brows, hands) with the joints' moves; face sliders round their own features (head size, face width, jaw, chin, cheekbones, brow, eye size and spacing, nose size and width, lips, ears); hair styles grown as card meshes; irises on a grey map so the eye colour tints only the iris; the scalp painted as skin; an outfit (default t-shirt and jeans). Kit making is Mac-only for now; the kits it makes work on every platform. Into Assets/Characters/<name>.glb with <name>.glb.creator.json; players' looks (CharacterLook) are built from it at load. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

forge_creature core

Make a cartoon creature (built by the engine itself, no Blender, in about a second): a soft sculpted body with a big head, long ears, a fluffy tail, mitten hands and big glossy eyes, painted fur/belly/inner ears, rigged, with its own generated idle, walk, jog, sprint and jump cycles. Into Assets/Characters/<name>.glb. Use mesh_renderer { mesh "Characters/<name>.glb" } and animator { clip "auto" library "" } (it plays its own cycles); set the character's height to about its size. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

forge_edit

Edit a forged model by hand at the picked spot (forge_pick), written into its recipe so every rebuild keeps it, then rebuilt in place. op: round or chamfer (the edge nearest the spot, or edge: its number from forge_pick; radius_mm), raise (size_mm [w, h], height_mm, falloff soft or hard), pocket (size_mm [w, h] or [d], depth_mm, shape rect | round | slot, rim_mm for a raised lip), fastener (kind rivet | hex_screw | slot_screw | cross_screw | torx_screw | roll_pin | qd_socket | nut | nail | carriage_bolt, size_mm, count with to [x, y, z] world for a row, or pattern ring with radius_mm), stamp (kind knurl | serrations | stipple over size_mm [w, h], pitch_mm; kind text: text engraved depth_mm deep, letters size_mm [h] tall, raised: true stands them proud), boss (a rounded housing standing proud: kind capsule | teardrop, size_mm [length, width], height_mm, along [x, y, z] world direction). Undo with forge_edit_undo. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

forge_edit_bake

Keep a forged model light: its fine stamped detail (knurl and serration edits) becomes baked stipple in the surface's normal detail instead of geometry (the recipe needs f.detailPass), then it rebuilds. Housings, pockets, raised regions, rounded edges and fasteners stay geometry. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

forge_edit_list

The hand edits in a forged model's recipe (its edit layer), in order, with their ids, parts and settings.

forge_edit_undo

Remove a hand edit from a forged model's recipe (the last one, or id) and rebuild it without it. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

forge_from_reference

Make a detailed, realistic made object (furniture, doors, cushions, cars) from a reference sheet: views of one object on a plain backdrop (2 × 2: front, side facing left, top with the front down, three-quarter; make one with Nano Banana in Google Flow). The family's part grammar is fitted to the sheet, then refined by rendering the model from each view and comparing outlines and inner lines until it matches; colours are read off the views; materials are procedural (wood grown from tree rings per board, car paint, brass, chrome, glass, rubber tread, woven fabric with stitched seams) with edge wear, dust in crevices and scratches. Writes Assets/Forge/<name>.glb, <name>_LOD1/_LOD2.glb and <name>.recipe.json (variants: same recipe, new seed). Reports per-view silhouette match before and after fitting. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

forge_from_views

Good for one-piece organic or sculpted shapes (a creature, a statue, a rock, a toy figure). Weak for vehicles and other hard objects made of separate parts: it makes one carved lump with the sheet's paint projected on (no wheels, seat or bumper of their own), so for those, try forge_model per part from an exploded-parts sheet, stickers, then assemble_vehicle. Carve a solid model of any object from a sheet of views on a plain backdrop: 2 × 2 (front, side facing left, top with the front down, three-quarter; a Nano Banana sheet on magenta) or a row (front, side, back, other side, e.g. on grey). Every straight-on outline carves a signed distance field, the three-quarter view's camera angle is solved from its outline and carves too, and without a top view the cross-sections are rounded; Surface Nets makes one closed, manifold, outward-facing mesh. With `normals` (the same sheet as a camera-space normal render, pixel-aligned: in Flow, edit the sheet with "convert this into a surface normal map render, same framing, same layout, background 128,128,255") the concave detail outlines can't see (a canopy recess, intakes, dents) is integrated from the normals and carved in. Writes Assets/Forge/<name>.glb, <name>.views.json (size, per-view silhouette IoU, solved three-quarter camera) and <name>.views.png (per view: sheet | carved model | outlines, white both, red sheet only, blue model only). Shape only: one plain material, no UVs yet. Recipes: f.from_views(name, sheet, {dimension, views, layout, grid, normals}). HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

forge_garment

Dress a person made with forge_human in clothes the engine tailors for their body: sewing patterns drafted from the body's measurements, sewn round it and draped as real cloth, with fabric maps (weave, seams, topstitching, hems, buttons). Rebuilds Characters/<name>.glb from its recipe with the garments added (live in the editor). Loose garments (skirts, dresses, coats, capes) swing as cloth with animator { cloth ["<garment name>"] }. Only forge_human people: characters from other generators (forge_body_native, forge_scan_human, creatures...) are refused unchanged, since rebuilding them would make a different person. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

forge_head

Build a realistic head from a reference sheet (a front view and a side profile of one person side by side on a plain background: make one with Nano Banana in Google Flow). No base mesh: the head is shaped row by row from the views (Apple Vision finds the face's landmarks, sizes from the pupils), with eye sockets and eyeballs, and the photos projected on as skin. Into Assets/Characters/<name>.glb. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

forge_human

Make a realistic, rigged, clothed person (built by the engine itself from the CC0 MakeHuman body kit, in seconds) from a description, into Assets/Characters/<name>.glb. It plays the shared animation library: give the entity mesh_renderer { mesh "Characters/<name>.glb" } and animator { clip "auto" library "Characters/Mannequin.glb" } (upper "pistol" to aim). Hold things with attach { bone "hand_r" }. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

forge_litter

Generate forest-floor pieces as real textured geometry from our photo materials (never downloaded), several variants per call into Assets/Forge/Nature/Litter (+ _LOD1), listed in LITTER.json: needle_clump (fallen pine needles, a low dome 0.3-1 m), leaf_patch (single photo leaves, curled), twig, stick, branch (a fallen broadleaf limb 1.2-4 m forked into twigs, snapped ends, moss on top, sometimes dead leaves still on it, settled resting on its forks; length, radius), pine_cone, stones (sculpted rock 3-40 cm, a third sunk, moss on top of big ones), bark_chunk, moss_pad, stump_cut, stump_broken, log (2-6 m, moss along its top, broken stubs, sawn or snapped ends), root_flare, outcrop (bedrock breaking out of the ground 1.5-12 m across: limestone beds as ledges, broken blocks, moss on top, its base growing out of the land's own ground; size, height, rock). Place the small ones as ground cover (add_ground_cover kind mesh) and the big ones with scatter. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

forge_look

Rebuild a character from its look recipe (Assets/Characters/<name>.look.json: a TTR Body, tailored garments, worn parts such as a Forge-made visor, materials matched to a reference sheet, tears, wet/blood states) into Characters/<name>.glb and <name>_crowd.glb, and reload it in the open scene. Built in the forge worker: edit the recipe (or a worn part's Forge recipe, then forge_model) and call this again; no engine build. The face head is cached while its face sheet is unchanged. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

forge_model core

Good for hard-surface props and every part of a multi-part object (a vehicle, a machine), one recipe per part from an exploded-parts sheet; for cartoon parts use lofts with square 2-2.6 (soft, pillowy), boxes only for real flat plates. Weak for organic one-piece shapes (forge_from_views or forge_creature). Make a model from a recipe: native JavaScript built inside the engine in about a second (or Python run by headless Blender), exported to Assets/Forge/<name>.glb with the recipe saved beside it. Returns size, triangles and a studio preview so you can check and refine. Rebuilding the same name updates it everywhere in the scene. Native recipes stream partial geometry at at (or an existing instance/camera pivot); f.step(text) names the current work. The viewport card can Stop or Resume; live_forge status/stop/resume controls the same session. This tool builds an asset; place it separately. For guns, props, furniture, signs, vehicles parts. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

forge_person

Make a new person. Describe them (describe: "a tired 50-year-old man", or sex/age/ancestry/weight/tired/beard) and the Face Forger mixes the scanned people of the reference sheets (rigged template faces, 52 face shapes, photo skin, strand hair), ages, fills out or tires the face as asked, welds it onto a TTR Body built for them (with close-up hands and nails), with strand lashes and a strand groom (<name>.groom beside the model). Skin carries cavity, estimated anatomical thickness, pore and oil maps for two-lobe highlights and shadowed thin-skin transmission. The first use of a library person builds it from its sheet (a few minutes, then cached). Without a description: the older photo-head blend, mix (sheet → weight) or seed. Into Assets/Characters/<name>.glb. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

forge_pick

Pick a spot on a forged model: point [x, y, z] (world; the camera's line through it finds the surface), or screen [x, y] (0...1 across the viewport). Returns the point, the way the surface faces, the part it's on, the flat face round it and the sharp edges near it; the spot shows highlighted in the viewport. on: true lets the person click spots on this model instead (their pick then shows in the activity feed and comes back here); on: false stops that. With nothing else, returns the spot picked last.

forge_prepare_sheet

Original pictures → a clean sheet and depth picture for forge_from_views, all on this machine. Each picture may hold several figures (front and side, back and high): each is cut out with Apple Vision's subject mask (keeps white fur on a white backdrop, tail tips, fingers; no floor shadows), then all panels go side by side on magenta at one figure height. Depth Anything V2 reads each panel for a 16-bit depth picture beside the sheet (<sheet>_depth.png). HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

forge_scan_human

Face v2: a whole rigged person whose face is fitted from a reference sheet (front + profile of one person, as for forge_head). Instead of a one-off head, the shared template head (MakeHuman topology: eyelids, inner lips, mouth, teeth, tongue, 52 face shapes) is fitted to the sheet's 3D scan, so expressions, blinks and speech work and every person made this way can be blended. Photos become the skin; body, clothes and hair as for forge_human. Into Assets/Characters/<name>.glb (a few minutes). HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

forge_toon_tree

Forge a storybook tree for painted worlds: a trunk and limbs with a crown of lumpy leaf clumps, one closed mesh wearing a painted leaf-scallop texture (no leaf cards), a few thousand triangles, with two coarser levels. Forms: round (oak-like dome), cone (fir tiers), tall (poplar flame), bush (low mound). Writes Assets/Forge/Nature/<name>.glb + _LOD1 + _LOD2; plant it with a forest object or mesh_renderer. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

forge_tree

Grow a tree natively (no downloads, no Blender): trunk flaring into roots, forking tapering limbs, procedural bark and cut-out leaf clusters, from a species recipe. Into Assets/Forge/<name>.glb; place it with mesh_renderer { mesh "Forge/<name>.glb" } and a collider for the trunk. Same species + another seed = another tree of that kind. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

forge_views_proof

Check shape-from-views against ground truth: a known object (the built-in 6.4 m test racer with a canopy recess and side intakes, or a model from the project) is drawn as a 2 × 2 colour sheet and a pixel-aligned normal sheet, carved back from those pictures alone (forge_from_views), and measured: silhouette IoU per view, depth error per view in cm (outlines alone and with the normal relief), and how much of each known concavity came back. Writes Assets/Forge/<name>_truth.glb, <name>_carved.glb, <name>_relief.glb, <name>_sheet.png, <name>_normals.png, <name>_views.png and <name>_relief.png. Use it to see how well a kind of object can be recovered before relying on forge_from_views. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

import_asset

Download a Poly Haven model or surface into the project, with its license and source recorded. Models: use the returned mesh path in mesh_renderer. Surfaces: use surface { name "id" }. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

import_files

Import files, folders or .zip asset packs from this computer into the project: 3D models (glTF/GLB, FBX, OBJ, USD/USDA/USDZ), pictures (PNG, JPG, TGA, BMP, PSD, GIF, HDR, EXR, WebP/TIFF on Mac), texture sets (albedo/normal/roughness/metal/AO by name → a surface), sounds (WAV, FLAC; MP3/OGG/M4A/AIFF on Mac → WAV), fonts (TTF/OTF → Fonts/<Family>), sprite sheets (Aseprite .ase, PNG + JSON), video (MP4/MOV/WebM). Units and up-axis are fixed, LODs and a fitted collision shape are made for models. Returns the import report: what came in (with mesh refs to place), what was fixed, what failed and why.

import_sprites

Turn a 2D pack's sprites into sheets the sprite component plays: a TextureAtlas XML (Kenney, Starling), a TexturePacker JSON (hash or array, trimmed or rotated frames) or a folder of PNG frames. Frames are grouped by name into characters and clips ("alienBeige_walk1, _walk2" → sheet alienBeige, clip walk; single pictures share a sheet called loose), laid out as an even grid bottom-centred (feet stay put) and saved in Assets/Sprites/<name>/. Answers the exact sprite { image, frame_width, frame_height, clips } for each sheet; entity puts it on an object. as: "tileset" makes level tiles into a ttr.tileset instead. The pack's files are only read.

import_web_game

Import a web game into this project: a three.js game (a folder with its index.html, anywhere on this Mac) is opened in a hidden browser inside the editor, left to build its world for `wait` seconds, and its 3D world is read out of the running page: every visible mesh at its world position (instanced ones expanded), its material (colour, roughness, metalness, emissive, vertex colours, opacity, its colour picture), lights, fog, background and camera. Writes Assets/Imported/<name>/<name>.glb (one model) and Scenes/<name>_Imported.ttrscene (the model, the lights as lamps, a look from the page's fog and exposure), and copies the game's code to Assets/Imported/<name>/web/ with PORTING.md: the world comes across by itself; the game logic is ported to Arcwright scripts by the agent. macOS editor only. Then upgrade it: real lighting, characters, materials, sound. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

live_forge

Make an object while the person watches it happen in the viewport: reference picture → shape fitted to it → blockout → parts snapping on → rounded edges → unwrapping → paint → use-driven wear → a check against the picture → placed in the scene. Every stage is one undoable step (Undo walks back through them); a failed stage says why in plain words and keeps the last good one. Give request (plain words: a recipe in Assets/Forge whose name matches is used), recipe (forge_model JavaScript; f.param(name, default, [min, max]) marks sizes a picture may change) or recipe_file. Recipes stream partial geometry while running; f.step(text) supplies plain progress words. action start returns at once with a session id; action status reports the stages so far; stop cancels and clears the marker; resume replays the saved recipe while retaining the previous checkpoint. Safety limits are reported with a Resume option.

make_cover_atlas

Make a ground-cover atlas of the game's own from Nano Banana sheets: each sheet is four plant clumps (dry scrub, desert grass, alpine flowers...) in 2 x 2 cells on a plain background (pure white, flat light, nothing touching the cell edges). The background is keyed out (its colour read from the sheet's border; the tint taken back out of the edge pixels) into Assets/Library/cover_atlas/<name>_<n>.png, and the project's library (Assets/Library/CATALOG.json) gets the entry, so add_ground_cover {atlas: "<name>"} grows it and the game ships it. Reports each cell's coverage (a near-empty or overfull cell means a bad sheet: make it again). Two or three sheets of one plant give variety.

make_material

Material Maker: realistic surfaces from a recipe instead of photos. list shows the engine's and the project's materials (worn painted wood, oak floor, floral wallpaper, plaster, tile, linoleum, metals, cloth...) and the recipe format; create saves a new recipe (Assets/Materials/<name>.material.json: a base like wood, plaster, wallpaper, tile or metal, an optional coat like paint or varnish, ageing, and wear from each object's shape: chipped edges, grime in crevices and corners, scuffs near the floor, dust on top, drawn rounded edges on boxes) and makes its maps; show describes one. Both return a swatch picture; apply_to puts it on objects as their surface (one undoable step).

material_library

The engine's own photo materials (made from our Nano Banana photos, never downloads): barks by tree species, ground layers by biome (forest soil, leaf litter, moss, trail dirt...), rock, leaf atlases. Search by words, category (bark, ground, rock, leaf_atlas) or biome. grow_plant picks a species' bark and leaves from here by default; paint_terrain and terrain layers take the ground names.

model_sheet

Draw models alone in neutral studio light from four sides (front three-quarter, side, back three-quarter, other side; each scaled to fit and stood on the ground), a row per model, into one PNG, to judge them side by side against their reference pictures and the builder guide's QUALITY BAR (nothing in the player's reach may look like a placeholder or a toy-block game). meshes: model paths ("Forge/mg_bumper_cars.glb"), or folder: every model in an Assets folder (prefix narrows it: "mg_"). Writes Renders/model_sheets/<name>.png (or out) and lists each row with its size. Doesn't touch the scene.

paint_art2d

2D code art (free, always available): paints an Art2D recipe (format ttr.art2d: a sprite sheet of posed frames, an auto-tiling terrain tileset, or a parallax backdrop) into PNG (and tileset JSON) in Assets. Recipes live in the project (Art2D/...); see kit_playbook 2d-platformer.

paint_asset

Paint an asset's own albedo, roughness, metal, tangent normal and AO as editable layers. Preserves its original textures and Detail Pass. points are model-local meters (omit for whole selected materials); masks multiply: all, curvature (convex edge wear), cavity, up, height, ao, world gradient, filtered noise, contact paths, 15 cm kick scuffs, gravity streaks, floor traffic lanes, boundary dirt and separate rust blooms. Bakes off the UI thread, saves <asset>.paint.json and shows the result; paint_layers undo restores it. Unique non-overlapping 0...1 UVs required. Select object to capture its transform for world masks. Human controls: Inspector > Paint. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

paint_bake

Bake editable paint layers to final texture maps and a new GLB under Assets/Painted/<output>, preserving the original asset/layers. GLB baking retains the original geometry, skeleton, animations and extensions. Sculpted or .gltf sources export maps plus a manifest; bake the sculpt to GLB first for combined GLB export. Existing output folders are never replaced; choose another output. PNGs remain ordinary PBR textures with no extra per-frame paint shader cost. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

paint_decal

Place a lit box-projected decal: image/label/sticker/sign/poster or built-in grime/dust/chipped_paint/crack/scorch. Defaults to hard surfaces (standard materials and glass: fridge-door smudges, window cracks); receivers:all also paints skin, eyes, hair and foliage. Projects along local -Z; rotation [-90,0,0] paints a floor. Color, tangent-normal and roughness maps share uv_rect [u,v,width,height] into a label atlas. Angle fade avoids stretched side walls, pixel/edge feather cleans curved cans and bottles; higher layer draws last. One undoable scene edit, saved with the scene. Normal/roughness-only decals use color_weight:0.

paint_ground_cover

Paint a ground-cover layer like a brush: strokes [{x, z, radius, density 0...1}] set how thick it grows (0 erases softly), {..., erase: true} clears a circle, {..., trample: true} presses a worn path (blades flattened and browned). `path` [[x,z],...] with `radius` paints along a line (a footpath). One undoable change; reports the plants it expects in the strokes.

paint_layers

List or edit an asset's saved paint layers: add/select/remove/visible/opacity/move/rename, undo or redo. Each edit saves and updates the texture set. Scriptable action replace accepts a complete AssetPaintDocument JSON (source,resolution,layers), validates and bakes it as one undo step; use list's structured document as a template. Painting comes after Detail Pass and sculpt/heal; neither source is overwritten. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

paint_preset

Give an asset a non-destructive lived-in paint layer: dusty, scuffed_floor, worn_painted_metal, greasy, grimy_wall, rain_wet or sun_faded_label. Wear lands only where it really collects, in soft patches: chipped flakes of dull primer/steel on convex corners (never chrome), shiny hand grease at contact paths, a dirt line and shoe scuffs at the base of walls (grimy_wall), traffic lanes that wear any floor finish toward scuffed satin (polish goes duller, concrete gets a sheen) with dirt at the boundaries and in grout, irregular drips. intensity light, medium (default) or heavy-grimy. Supply paths in local meters or author paint_contact/handle_grip, paint_traffic, paint_boundary, paint_drip and paint_rust model points. Contact/traffic/boundary are paths; dripSources and rustSources are independent locations. No contact path means no guessed handle grease, no rustSources means no guessed screw rust. Empty traffic/boundary use asset center/perimeter. strength 0...1, deterministic; minimum_resolution 2048 gives close-up mask detail. materials can restrict it (a vest without the skin). The original GLB stays intact; paint_layers can hide, reduce, reorder or undo the layer. For one-off marks on a repeated module (a stained ceiling tile, a lane across many floor modules) use paint_decal instead: a painted texture repeats with every instance. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

paint_terrain

Paint a ground layer onto land: forest_soil, leaf_litter, moss_ground, trail_dirt (photo materials from material_library) or any surface. Up to 8 layers sit over the land's slope-and-height base and blend by height, so dirt fills low spots first. Every layer is anti-tiled and varied over large areas. Modes: brush (strokes [{x, z, radius, strength}]), path ([[x, z], ...] with radius: a strip with a ragged edge), fill (all of the land), patches (`share` 0...1: natural patches over the whole land, with their own noise per layer), erase (brush or path that clears every layer), clear (remove the layer). One undoable change.

paint_wear_mask

The wear brush for agents: more (amount up to 1) or less (down to -1, the eraser) of the object's natural use-driven wear in places, e.g. less on the backrest and more on the seat's front edge. Each stroke names a part (from set_wear explain), covering it, or gives at: [x, y, z] in the object's own frame (meters, Y up) with a radius; hardness 0 soft ... 1 hard. Or describe how it's USED and the places are found for you: uses [{action: hold|stand|sit|scrape|kick|grind|bump|clean, part, where: top|bottom|front|back|left|right|nose|tail|ends|edges|all, amount}] ("ollies scrape the tail" = {action: scrape, part: Deck, where: tail}; "grinds scratch the hangers" = {action: grind, part: Hanger}). The wear still follows the real edges and grain (it's a weight, not a decal). One undoable step; clear: true drops earlier strokes first. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

photo_surface

Turn a reference photo in the project's Assets (a Nano Banana texture picture: flat, straight-on) into a seamless PBR surface, Assets/Surfaces/<name>/ (color, normal, roughness, occlusion), with the engine's photo-material pipeline (lighting flattened, quilted to tile with no seam, height from the photo's features, normals, occlusion, roughness). height: the photo's own depth picture (an aligned Nano Banana depth map of the same sheet: light = high), cropped and quilted in register with the photo, so stones, joints and cracks keep their real shapes instead of a height guessed from the colour (a dark stain isn't a dip). crop [x, y, w, h] (0...1) takes part of the picture (and of height); upright keeps its direction (wood grain, bark: only mirrored, never turned); size 1024/2048/4096; normal (relief strength, default 5), feature (the broadest bumps as a share of the tile: 0.05 default, ~0.015 for wood grain), roughness (the mean, default 0.75), gloss (0...1: how much smoother the high, sealed surface is than its pores and cracks). Then use it in a material recipe: make_material {recipe: {"name": ..., "surface": {"name": "<name>"}, "finish": ..., "age": ..., "wear": ...}}. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

product_forge

Build a reusable catalog of parametric retail packaging: glass_bottle, pet_bottle, soda_bottle, can, carton, chip_bag, box, cup_noodles, drink_shot, jar, tube, sachet, bread_loaf (a sliced loaf in a clear bag with a printed band and twist tie), bun_pack (six rolls in a clear clamshell). Creates K variants per family, or exactly label_count products from one supplied PNG label sheet. Each label maps once to an editable Forge recipe and glTF model with clean wrap/front UVs. Defaults to generated fictional labels. Models share one label image on disk and use the GPU texture cache (shared when color space and residency cap match); shelf_fill reuses mesh references for instancing. Optional parameters by family set dimensions, proportions, closure, material, seed and detail. action list reads an existing catalog. Builds publish only after all products read back; existing catalogs are never overwritten. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

rebuild_buildings

Build the scene's buildings (objects with a `building` component: style, width, depth, height, floors, seed, front) into their models: one object per look and 64 m chunk ("bldg:<look>@<x>_<z>", near, middle and far levels) and a box collider on each building. Reads the project's Assets/Buildings style and look files again. One undo step. Reports triangles per level and anything wrong with the style files.

No arguments.

reference_pack

The research behind a model, kept with it (Assets/References/<subject>/pack.json): hard facts (official dimensions, measured feature stations, materials, performance) and every source with license and whether it may ship. Give a target to check the model's real scale and feature positions against the facts (separate from compare_reference's shape match). Add facts, sources or materials to grow it. Quick level for ordinary props (a few views, one size); deep for things that must be authentic (drawings, several measurements, close-ups, performance, sound).

reference_planes

Blueprint planes: stand a model's reference orthos (side, front, rear, top) around it at true scale, the way car studios model against their drawings. Each picture's subject is found (Vision foreground or a plain background), cut out and scaled so one real size fixes every view (side and top by the length, front and rear by the height); it reports where the pictures disagree. Each view is a glowing quad that shows from its own side only (never covers the model), one object per view in group Blueprints. Re-run with only the settings to tune live (opacity, brightness, cutout, outline, placement, gap), show/hide views, remove the set, or look along a view with a long lens.

reset_wear

Put a forged object's wear back to how it was forged (its sliders and brush strokes cleared). One undoable step. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

sculpt_bake

Bake a sculpt's fine detail into maps so the model stays light in game: a normal map and a displacement map (PNG, beside the model), from the full sculpt onto the base model plus the layers before from_layer (the big forms). Also writes <model>_baked.glb: the light model wearing the normal map (not for rigged characters yet).

sculpt_edit

Precise, named shape edits for a TTR Body or creature, anchored to regions so they survive rebuilds: move (mm [x, y, z]; +x the model's left, +y up, +z forward), scale (factor about the region's centre), inflate (mm along the surface, negative deflates), crease (deepen, or raise if negative, along a line of landmarks, width mm) and widen (total mm at a cross-section height). Each fades out smoothly over falloffMM. Saved in the character's recipe and replayed on every rebuild; inspect_bench suggests them. action preview reports what would move without saving; clear removes all edits. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

sculpt_layer

A model's sculpt layers: list them (with the model's regions and size), add a layer, select the one strokes go into, set a layer's strength (0 none … 1 as sculpted … 4), show or hide one, delete, rename, move, undo or redo the last sculpt change. Layers apply in order on top of the base model, so a rebuilt base keeps the sculpt and a layer can be dialled down later.

sculpt_new

Start a sculpt from clay: a model of even triangles (sphere or plane, size meters across) saved as Assets/Sculpts/<name>.glb and placed in the scene, ready for sculpt_stroke and sculpt_stamp.

sculpt_snapshot

Close-up pictures of a model being sculpted, from named angles (front, back, left, right, top, bottom, three_quarter, three_quarter_right), clay-shaded so the form reads: framed on a point (focus + radius, meters) or a region (tinted red), with the wireframe (to see added detail) or side by side with the model before sculpting (before: true).

sculpt_stamp

Press a height pattern (an alpha) into a model's surface at each point: carvings and ornament (rosette, scroll, leaf, rope, beads, rings, dome, scales, knurl) or skin and stone detail (pores, wrinkles, stone), or a greyscale image under Assets (white raises). radius = half the stamp's width (meters), depth = meters of the alpha's full height (negative carves in); angle turns it, up sets which way is up on the surface, aspect stretches it. Adds the detail it needs (default edges radius/32; set detail). Mirror with symmetry "x". Saved as a sculpt layer beside the model.

sculpt_stroke

Sculpt a model like Blender's sculpt mode, by numbers: a brush stroke along points (meters, the model's own frame: +x its left, +y up, +z forward). Brushes: draw (push out along the surface, negative pulls in; strength = meters at the centre, a stroke of 0.002 raises exactly 2 mm), inflate (swell along each normal), smooth / flatten / pinch (strength 0…1 per dab), crease (a sharp groove, strength = depth in meters; negative = a sharp ridge), grab (move by delta [x, y, z]). Mirror with symmetry "x"; keep it to a region ("nose.bridge", "cheek_l", "calf.left", "head", "material:Skin", "a+b", "-eye_l"); add detail where it goes with detail = the longest edge wanted (meters, e.g. 0.0005). Saved as a layer in <model>.sculpt.json beside the model (re-applied whenever the model loads or is rebuilt; rigged characters keep their bones and face shapes). Undo with sculpt_layer.

sculpt_terrain

Shape land with a brush: raise, lower, flatten (toward a height), smooth, or level (flat pad for a building). Give one point, or a path of points to sculpt along it (roads, rivers, trenches). Coordinates are world x, z.

shelf_fill

Stock a shelf, fridge or rack from a product_forge catalog. Set width/depth in metres, shelf levels, facings per SKU, rows behind each facing, gaps, small seeded position/yaw variation and front or pushed-back alignment. All products keep shared mesh references for GPU instancing and shared label textures. Optional price_strip and price_tags use the existing image decals; price_every spaces tags without repeating products. Returns actual count, unique SKUs and capacity. One undo step; existing objects are preserved. dry_run validates and reports the fit without placing anything.

texture_from_views

Good for painting one model from pictures of that same object. Weak for stickers and logos on separate parts of a stylised model (the paint smears across part joins): for those, try an f.material image on a thin plate, or paint_decal. Texture any model from reference pictures: the model gets automatic UVs (our own unwrap: charts by surface direction, flattened as-rigid-as-possible, packed into one 0-1 atlas) and each view of the sheet is projected onto it with its camera found from the outline, visibility tested, blended by how squarely each view sees the surface, exposures harmonised between views, unseen parts inpainted, seams dilated. Sheets: sheet_2x2 (front, side, top, three-quarter: the Nano Banana layout), grid (columns × rows of named views: front, back, side, top, bottom, three_quarter, skip) or turnaround (equal steps around). Writes Assets/Forge/<name>.glb (the painted model), <name>_basecolor.png and <name>.viewpaint.json; returns per-view colour error (ΔE under neutral light), the seam score at 4 angles (DetailCritic seam gate) and pictures: each sheet view beside the painted model from the same camera, and the four test angles. hold_out leaves a view out of painting and measures it (the honest check). Use the delit (albedo) version of a sheet when there is one. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

texture_heal

Heal a model's textures: remove something baked into them (a photo's outline left on the cheek, a logo, a watermark, a stain, a seam) and refill it from the surface around it: the broad colour is filled in smoothly from the patch's edge so it matches, and the fine grain (pores, weave, scratches) is copied from nearby (or from around `source`), on the colour, roughness and normal maps together. Where: points (meters, the model's frame) with a radius, and/or a region. Saved as a heal in a sculpt layer beside the model (undo, layer strength). Returns a before/after close-up.

type_forge

Make a real TrueType font from pictures of letters (Type Forge). Each sheet is a picture of black letters on white (a Nano Banana specimen sheet works best: ask for exact rows, even spacing, nothing touching, no guides) and the characters it shows, row by row. The engine cuts the letters out, reads each row's baseline and capital height, traces the outlines (corners kept sharp, curves fitted within the tolerance), checks every letter against its drawing and writes Assets/Fonts/<Name>/<Name>-Regular.ttf with a specimen.png and the source sheets. Give several sheets for one font (capitals, lowercase, numbers and marks); lowercase it lacks uses the capitals. Use the font in ui_theme / game.ui.json fonts ({"file": "Fonts/<Name>/<Name>-Regular.ttf"}).

vertex_snap

Move an object so one of its corners (vertices) sits exactly on a corner of another: wall to wall, track piece to track piece, a pipe onto its joint, with no gap or overlap. Its corner nearest `near` (default: nearest the other object) goes onto the other's corner nearest it; the other stays put. One undo step. The editor's Vertex snap (⌥V, or hold V while moving) does the same by hand.

wear_model

Dress a character in forged gear: a forge_model recipe with f.wear({skeleton: "Characters/Mannequin.glb"}) (armour, helmet, gauntlets, a cape's plates authored on that skeleton's bind pose) is split by bone at build; this puts every piece on the person, each riding its bone (attach { bone } turn true), so the gear follows idle, run and attack clips. One undoable step; run it again after rebuilding the gear.