Step-by-step recipe for a task: the tool calls in order, the numbers to check and the known traps. Call it before a task of these kinds: a character from reference images, a hard-surface prop, a weapon or object from an orthographic sheet, a scene from a perspective photo, a level blockout, materials and a final render, export for a game. Without topic it lists the topics, one line each. With a topic it returns the universal rules and that recipe. An unknown topic is an error that lists the topics. It works when Blender is closed.

Call it first. Blender version, add-on version, open file, scene and its object count, and the toolsets of this server. It compares the tools of this server with the handlers of the add-on: server_is_stale means restart the MCP server, addon_is_stale means restart Blender. When Blender is not reachable it says where Blender is installed.

Every object with type, collection, parent (by indent), world size, world minimum corner and triangle count. Shows the first limit objects.

World-space size, min, max, center, origin position, origin inside the bounding box (0..1 per axis), rotation in degrees and scale. Notes say 'scale not applied' or 'negative scale'. Use it after every move. Use measure_profile to measure a reference image instead of an object.

Run Python in Blender (bpy, bmesh, mathutils, Vector, np, math are ready). Returns stdout, and the added, changed and removed objects with their world sizes, so silent mistakes show up. Prefer the other tools for moving, sizing and checking. With session the variables, functions and imports stay between calls under that name (reset=true clears them; rollback clears all sessions). paths are folders added to the import path: keep your helper modules there and import them once.

State of a background job: running with progress, done with its result, failed with the error. Long tools (fit_to_reference, match_camera, bake_maps) return a job id when they run longer than their wait seconds. Without job it lists all jobs of this Blender session. cancel=true stops the job; the scene keeps the changes the job already made: use rollback to undo them.

Move part (with its children) so a point of its world bounding box lands on a point of the bounding box of to. Anchors are fractions 0..1 per axis: (0.5,0.5,0) is bottom centre, (0.5,0.5,1) is top centre. Default puts the part on top of the target. offset is in metres. Both boxes include the children of each object; with_children=false measures the two objects alone (the children still move with the part). The answer gives boxes_used (objects, min, max, size of both boxes after the move) and moved_by; min and max at the top level are of part alone. Boxes do not follow round or slanted surfaces: use move_to_contact to close the real gap, place_on to drop onto uneven ground, transform_objects for a known offset.

Move objects (all top-level objects when names is empty) so their lowest point sits at height z. Use place_on instead when the floor is another object or not level.

Set the size in metres. Empty axes stay. With uniform=true the first given axis sets a factor for all axes. The anchor point of the bounding box (fractions 0..1) stays where it is; (0.5,0.5,0) keeps the bottom. With apply=true the scale is baked into the mesh, so the object keeps scale 1 and exports cleanly.

Move, turn and scale objects together with their children. Order: scale, then rotate, then move. rotate_deg [rx, ry, rz] turns around the world X, then Y, then Z axis. scale is a number or [x, y, z] along the world axes. pivot is a world point for the turn and the scale; the default is the centre of the bounding box of all the objects and their children. Several objects turn as one group. Scaling a turned object by different factors on each axis shears it a little: set the size with set_dimensions first. The answer lists every object after the change. Use it when you know the numbers; to place a part against another use attach or move_to_contact.

Bake the transform of meshes into their vertices, as Ctrl+A does. mode all also bakes the position: the origin goes to the world origin. Shared meshes are made single-user first, children keep their place in the world, mirrored (negative) scale is handled without flipped normals.

Set shading of meshes. smooth: every face and edge smooth. flat: every face flat. auto: smooth faces, but edges sharper than angle degrees stay sharp (a cube stays crisp, a sphere becomes smooth). Cheap and exports as is. weighted_normals=true (with smooth or auto) adds a Weighted Normal modifier that keeps sharp edges: large flat faces stay flat and only the bevels blend. Use it for parts with both bevels and flat chamfers, where no single angle works. export_glb writes these normals while apply_modifiers is true. A later shade call without it removes it. It changes normals only: to move vertices use sculpt with op smooth.

Round the whole geometry with Catmull-Clark subdivision (each level quadruples the faces). apply=true bakes it into the mesh and sets smooth shading. Watch the triangle count in the answer against your budget. Use subdivide_faces to cut picked faces into a grid without rounding, remesh for an even skin over merged parts.

Create a primitive with a real size in metres (no hidden scale). For a torus size is [outer width, outer depth, tube thickness], segments is the count around the ring. The anchor point of its bounding box (fractions 0..1) is placed at world point at: anchor (0.5,0.5,0) with at (0,0,0) stands the shape on the ground. size is the size before rotation. rotate_deg [rx, ry, rz] turns the shape about the point at around the world X, then Y, then Z axis, after it is placed. A barrel along +X: a cylinder with rotate_deg [0, 90, 0]. The answer shows the size and box after the turn.

Make a smooth tube along a polyline of world points (Skin plus Subdivision). One radius per point, or one radius for all. Good for arms, legs, tails, tentacles, branches. Ends are rounded and stay inside the path.

Make a closed body from cross-sections you give as numbers along an axis. A section is {"at": [x,y,z], "size": [w,d], "roundness": 2}: roundness 2 is an ellipse, 4 is a rounded box. Sections go in order along the axis. Good for torsos, heads, bottles, columns. With a front and a side image of the form use loft_from_masks: it reads the sections from the images.

Make a mirrored copy of a mesh across the plane at at on the axis. Normals stay outward. The name swaps L/R, Left/Right (arm_L becomes arm_R), or gets '_mirror'. The origin of the copy is the mirror image of the source origin; the copy has no rotation and scale 1.

Make child follow to. With keep_world the child stays where it is.

Copy an object and move the copy by offset metres. linked=true shares the mesh data. rotate_deg [rx, ry, rz] then turns the copy around the world X, Y, Z axes (in that order) about pivot, a world point. The default pivot is the centre of the copy's bounding box, after the offset.

Delete whole objects. Take a checkpoint first if you are not sure. Give at least one of: names; prefix (every object whose name starts with it: 'bl_light_' removes the setup_lighting preset); lights (added: the lights made by add_light, all: every light). with_children=true also deletes everything parented to them. Otherwise the children stay where they are in the world and lose the parent: the answer lists them as unparented. Use delete_faces to remove a part of a mesh.

Write a GLB of the named objects (with children), or of all visible geometry. glTF uses +Y up and triangulates every face. influences 4 (or 8) is the bones per vertex that the game engine reads. draco compresses geometry (the game needs the Draco decoder). Options this Blender does not know are reported as ignored_options. scale multiplies the whole export about the world origin (a 0.1 m model with scale 10 leaves as 1 m). The scene is restored after the export; the scale is written as the node scale of the top objects. max_texture_size (pixels on the longer side) writes smaller copies of larger textures into the GLB; the images in the scene and on disk stay as they are. Nine 2048 px maps make a file of about 25 MB: 1024 or 512 is enough for a small prop. The answer has textures: count, bytes, and name, size and bytes of each image in the file.

Import a GLB or glTF file and list the new objects with their world sizes.

Triangle and n-gon count, open holes, loose parts, zero-area faces, doubled vertices, inward normals and unapplied scale. 'issues' is ['none'] when the mesh is clean. uv is the quality of the UV map: island count, used area, faces outside 0..1, degenerate faces and texel_density_spread (largest to smallest UV area per surface area: 1 is even, above 4 is stretched), or 'none' when the mesh has no UV map.

Mirror all vertices of the objects across a plane and count those without a partner within tolerance. at is the plane position on the axis; empty means the middle of the bounding box. Empty tolerance means 0.005 m for objects of 0.3 m and more, and less for small ones (it follows the size). The answer shows the value used.

Find parts that hang in the air. Meshes that touch or overlap form groups; the main group is the one that stands on ground_z (or the largest). Every other group is floating: the answer names its nearest part and the gap. tiny_gaps lists pairs that miss by touch..near metres (seams you cannot see). Run it after assembling a model, then fix with move_to_contact or attach. Long lists are folded to max_listed entries with a count. Empty touch and search follow the part size: 0.001 m and 1 m for parts of 0.3 m and more, less for small parts (a 5 cm part gets about a sixth). Empty near is 2 percent of the size of each pair (the diagonal of both parts together), at most 0.03 m: about 6 mm for a pair 0.3 m across. Each tiny gap shows the near it was held against. Give numbers in metres to fix them.

Move a (with children) until its surface touches the surface of to. Without axis it takes the shortest way; with an axis it slides along that axis only, so other coordinates stay. depth sinks the part into the target by that many metres to hide the seam: use 0.005..0.02 for limbs and necks. If the parts already overlap nothing moves. The whole object moves, never only its end: for a long part that must stay put at the other end, resize it with set_dimensions and anchor, or rebuild it with limb. Use attach to align by bounding boxes, combine to merge meshes into one object.

State of two meshes: 'intersecting' (one pushes into the other), 'touching' or 'apart' (with the smallest vertex distance). For an overlap it gives the deepest sample, the median depth and the share of each mesh that lies inside the other: a glaze shell on a donut may have a deep spot (a drip) but a small median. Use it to find floating or sunken parts.

Overview: one image with several fixed views. The flat views are orthographic and share one scale. A grid shows metres, coloured lines show the world axes (X red, Y green, Z blue). names limits the objects (with children). color_by object gives every object its own colour and the answer has a legend of name to '#rrggbb' (the lit picture is a little darker or lighter). Use render_view for one free angle, a close-up or a check mode, render_final for the lit picture through the scene camera.

Check picture from any angle with its own camera and light. The camera frames the bounding volume of target (with children; empty means everything), so a tall figure and a small bolt both fill the picture. Azimuth 0 looks at the front (from -Y), 90 from +X, 180 from the back; elevation 0 is level, 90 is from above. fov 0 means orthographic. isolate=false draws the whole scene but still frames target: use it for close-ups of joints in context. Modes: solid (studio light, material colours), clay (one grey, shows form only), xray (see-through), flat (material colours without light), wire (edges: topology, hidden parts; lines are about 2 pixels wide at the centre of the frame at any zoom), ids (one flat colour per object, with a legend), normals (world normal as colour), backfaces (red where you see the inside of a face: flipped normals, open shells). Use render_sheet for the overview with a metre grid, render_final for the scene lights, materials and camera.

Write what the model must be, run all checks in one call, get pass or fail with the real numbers. State your expectations before you look at the result, then fix only the failures. Each check is a dict with "type" and optional "label". Types and fields: size {object, axis x|y|z, equals+tol | min | max, with_children?} world size in metres. position {object, axis, which min|max|center, equals+tol | min | max} world coordinate. ratio {a, b, axis, min | max | equals+tol} size of a divided by size of b (head vs body proportions). gap {a, b, min | max | equals+tol} distance between two meshes (0 if they overlap). contact {a, b, state touching|intersecting|apart|connected, max_depth?} 'connected' is touching or overlapping. symmetry {objects, axis, at?, tolerance?, max_unmatched_share?} mirror match of all vertices. inside {object, container, margin?} bounding box inside another's. on_ground {object, z?, tol?} lowest point of the object and its children. clean {object, ignore?} no open holes, loose parts, zero faces, inward normals. budget {names?, max_tris?, max_objects?, max_materials?, max_draw_calls?}. connected {names?, ground_z?} no floating groups. A failure shows 'actual', 'expected' and a 'fix' tool. A bad check or a missing object is reported as an 'error' and the rest still run.

Shoot one ray in world space. Returns the first object hit, the distance, the point and the surface normal. Use it to find floors, ceilings, wall thickness and free space.

Can point or object a see b? Each is a world point or an object name (its bounding-box centre). The two named objects never block the ray. Returns the first blocker. Use it for sight lines, cover and corridors.

Check where an agent of this size can walk, then flood from start (default: the largest area). Floors are found by rays, so ramps, stairs and several levels work. Returns the reachable, unreachable and blocked areas in m2 and a top-down image. Use it to prove that every room, spawn and objective connects.

Exposure of a level. For every reachable cell it shoots rays around at eye height and measures how far one can see. Returns a heat map (blue enclosed, red exposed), the longest sight lines with their positions and the area that has a sight line longer than long_sightline. Use it to find sniper alleys and to check that cover and corners break long views. Same agent settings as walkable_map.

Shortest walkable route between two world points. Returns the length, the straight-line length, the narrowest free width on the route with its position, the highest step and waypoints, plus an image. min_width forbids narrower passages: use it to ask 'can a group or a wide vehicle go from A to B?'. If the points are in different regions it says so and why.

Read a GLB file without Blender: triangles, vertices, materials, textures with sizes, extensions, file size and warnings (missing normals or UV, oversized or non-power-of-two textures, duplicate node names). Run it on the file you exported, because that is what the game loads.

Pre-export gate. Errors: bad names, unapplied scale, no material, faces without a material (a boolean cutter without one leaves them), inward normals, zero-area faces, oversized textures, budget overruns (the max_* limits). Warnings: duplicate suffixes (.001), many material slots, empty material slots, missing UV, n-gons, open shells, and a mesh that is nearly but not fully symmetric about symmetry_axis: under 10 percent of its vertices have no mirror partner (plane: the middle of its box, or 0). That is a side broken by an uneven selection; a silhouette does not show it. symmetry_axis=null skips it. ready is true when there are no errors. budget_only=true is the cheap budget question at any stage: it only counts tris, objects, materials and estimated draw calls of names (or all visible meshes) and lists the limits exceeded in over_budget. It also gives draw_calls_if_instanced: objects that repeat one mesh with the same materials cost one call with GPU instancing; the hint says when merging them with combine pays off.

Save the scene as a named restore point. Checkpoints belong to the open file (an id kept in the scene): a new or another file does not see them.

Return to a checkpoint of this file: everything done after it is lost. The open file becomes the checkpoint copy: use Save As before you save. Without name nothing is rolled back: the answer lists the checkpoints of the open file.

Block out a level from a text plan, one string per row, row 0 at the top (+Y), column 0 at the left. Default characters: '#' wall, '.' floor, ' ' nothing, 'D' doorway (floor, with a wall above door_height), 'C' cover box (cover_height high, cover_fill of the cell), 'S' spawn marker, 'O' objective marker. legend adds or changes characters: {"W": {"kind": "wall", "height": 1.2}} makes low walls; kinds are wall, floor, door, cover, marker (with "name"), void. Makes {name}_floor, {name}_walls, {name}_cover meshes and {name}_spawn_1 style empties. Then prove it with walkable_map, route, check_passages, sightline_map. One cell is cell metres: use 1 for rooms, 0.5 for detail.

Place count copies of an object at random on top of surface objects, standing on the surface: trees, rocks, crates, grass, sprinkles. source may be a list: each copy takes one at random and weights sets the odds. area [x0,y0,x1,y1] limits where (default: the surface bounds); min_distance keeps copies apart; max_slope_deg skips steep ground; align_to_normal tilts them with the ground; scale_range [min,max] and yaw_random vary them. The same seed gives the same result. linked=true shares one mesh (cheap). The answer counts the copies per source and why tries were rejected (too_close, not_on_surface, too_steep). For one object at a chosen spot use place_on.

Drop an object (with children) onto a surface: its lowest point lands on the first hit under it (or under world xy at). Use it for props on tables, floors with height changes, terrain. Use ground for a level floor at a known height, attach to align by bounding boxes, scatter for many copies.

What can be seen from a point: for each reachable cell, a ray from the eye to a point target_height above the floor. Returns visible and hidden area, the farthest visible distance and a map. Use it for spawns (what does an enemy see?), sniper spots, hiding places, objective visibility. The area is the one that contains the point.

Find doorways and corridors of a level that are too narrow. It follows the centre line of the walkable area and reports narrow runs: a run up to door_length metres long is a doorway (limit min_door), a longer one a corridor (limit min_corridor). The width is the free width including the agent radius, accurate to about one cell, and it errs on the small side. Returns violations with positions and a map. start picks the area when there are several levels.

Store a list of assert_spec checks under a name inside the scene (it is saved with the .blend). Rerun it with run_spec after every change, in this or a later session.

Run a stored spec (see save_spec) and return the assert_spec result. Without name nothing runs: the answer lists the stored specs with their number of checks.

What changed since a checkpoint: added and removed objects, and objects that moved or changed size by more than tolerance metres, with sizes before and now. A changed object also gets topology (counts of verts, edges, faces and tris, before -> now) and material_slots (the slot lists before and now) when they differ, so an edit that keeps the size still shows. Use it to review a long session or to see what a tool did.

Create or update one light you control (setup_lighting makes a whole preset instead). The same name updates that light; it never makes a copy. spot is a cone, point shines all ways, area is a panel, sun gives parallel rays. location is in world metres; look_at is the point a spot, area or sun aims at. A new light without them sits at [0, 0, 3] and points down; an update keeps what you omit. power_w is watts; for a sun it is W/m2 (1-5, about 3 is a normal day). A point or spot needs about 40 W at 1 m, 150 W at 2 m, 600 W at 4 m for a normal exposure; an area panel a third of that. color is '#rrggbb' or linear [r, g, b]; temperature_k (800-20000) multiplies it with a blackbody tint. Spot: spot_size_deg is the full cone angle (1-180), blend (0-1) softens its edge. cutoff_m stops a spot or point hard at that distance. radius (spot, point) is the source size in metres: bigger means softer shadows. size (area) is [width, height] in metres or one number for a square (1 m when empty). shadow_soft=false makes hard shadows. Names that start with bl_light_ belong to setup_lighting and are refused. Remove lights with delete.

List every light in the scene: name, kind, place, aim (direction), power, colour and the kind's settings. preset is true for the bl_light_* lights that setup_lighting makes. Remove lights with delete (names, prefix or lights).

Set post-processing for render_final: vignette, glare, colour, exposure, contrast. It builds a compositor tree, works with every engine and is not shown in the viewport. A call changes only what you pass and keeps the rest. Pass false to switch one effect off (vignette=false); reset=true removes everything this tool set. vignette {"strength": 0-1 (how dark the corners get), "softness": 0-1 (how far in the fade starts)}; both start at 0.5. The darkening is an ellipse that follows the picture shape. glare {"type": "bloom" | "fog_glow" | "streaks", "threshold": 1.0 (how bright a pixel must be to glow; lower = more glow), "size": 1-9 (8 when empty)}. It needs pixels above 1: strong lights or emission. color {"saturation": 1.0 (0 = grey), "gamma": 1.0 (above 1 brightens the mid-tones)}. exposure is in stops (+1 doubles the light). contrast is -1 to 1. It refuses to replace a compositor tree it did not make. Returns the active settings.

Make a text label as a closed mesh, or engrave text into a mesh. size is the height of a capital letter and depth the thickness, in metres. \n starts a new line. plane: XZ stands upright and reads from the front (-Y), XY lies flat and reads from above, YZ stands and reads from +X. The back face is on the plane. at is the anchor in the world (the origin when empty) and the object origin; align puts the middle, the left end or the right end of the text there; vertically the text is centred. font is a path to a .ttf or .otf file. The built-in font has Latin and Cyrillic; a font without a glyph shows nothing for that character. bevel rounds the edges (0 to depth/2). The same name replaces the earlier text. on_object (a mesh) puts the text on its surface: a ray through at along the plane normal finds the first hit, and the text lands offset metres above it (a decal that does not z-fight). The text stays flat: use it on flat or nearly flat surfaces. engrave=true cuts the letters depth deep into on_object instead, with the checks and clean-up of boolean; no text object stays and bevel is ignored. The mesh must be closed. The answer has the volume before and after.

Counts of vertices, edges and faces, and the faces grouped by direction (+X, -X, +Y, -Y, +Z, -Z, other) with their area and the world range of their centres. Read it before you pick faces with where.

Preview a face selection without changing anything: how many faces, their area, the world range of their centres and the first indices. where picks faces (or vertices, edges) by a condition, all given keys must hold: normal ('+Z', '-X' or [x,y,z]) with angle (degrees, default 25); x, y, z ranges [min, max] (null means open) on the world centre; box [[x0,y0,z0],[x1,y1,z1]]; area [min, max]; index [...]. {} or null picks everything. Look at mesh_info first to see where the faces are.

Extrude the picked faces as one region. distance is along their average normal (negative digs in); offset is a world vector instead. scale resizes the new cap about its centre (a taper); inset first shrinks the region by that many metres. Typical: raise a roof, make a post, a step, a window recess. where picks faces (or vertices, edges) by a condition, all given keys must hold: normal ('+Z', '-X' or [x,y,z]) with angle (degrees, default 25); x, y, z ranges [min, max] (null means open) on the world centre; box [[x0,y0,z0],[x1,y1,z1]]; area [min, max]; index [...]. {} or null picks everything. Look at mesh_info first to see where the faces are.

Inset the picked faces by thickness metres (empty: 0.02 m, less on objects under 0.3 m), optionally pushing the inner face by depth (negative is a recess). individual=true insets each face on its own. where picks faces (or vertices, edges) by a condition, all given keys must hold: normal ('+Z', '-X' or [x,y,z]) with angle (degrees, default 25); x, y, z ranges [min, max] (null means open) on the world centre; box [[x0,y0,z0],[x1,y1,z1]]; area [min, max]; index [...]. {} or null picks everything. Look at mesh_info first to see where the faces are.

Delete the picked faces of one mesh (makes openings: doors, windows, open boxes). Use delete to remove whole objects. where picks faces (or vertices, edges) by a condition, all given keys must hold: normal ('+Z', '-X' or [x,y,z]) with angle (degrees, default 25); x, y, z ranges [min, max] (null means open) on the world centre; box [[x0,y0,z0],[x1,y1,z1]]; area [min, max]; index [...]. {} or null picks everything. Look at mesh_info first to see where the faces are.

Split the picked faces into a grid; cuts is the number of cuts per edge. The shape stays: it gives geometry to bend, sculpt or displace. Use subdivide to round the whole mesh, remesh for an even skin over merged parts. where picks faces (or vertices, edges) by a condition, all given keys must hold: normal ('+Z', '-X' or [x,y,z]) with angle (degrees, default 25); x, y, z ranges [min, max] (null means open) on the world centre; box [[x0,y0,z0],[x1,y1,z1]]; area [min, max]; index [...]. {} or null picks everything. Look at mesh_info first to see where the faces are.

Round or chamfer the edges sharper than angle degrees (optionally only those whose midpoint is inside where, which uses x, y, z ranges and box). width is in metres (empty: 0.02 m, less on objects under 0.3 m), segments 1 is a chamfer, 3 is round. profile 0.5 is circular. width_type width is the distance between the two new edges. Only edges with two faces can be bevelled. Overlapping bevels are clamped, and one tight edge limits every bevel of the call: the answer gives width (asked), achieved_width (min and median measured on the result, in metres), clamped (edges under 90% of the asked width) and a warning when most are clamped. Doubled vertices and zero-area faces are removed afterwards (merged_vertices, removed_zero_faces).

Cut the mesh with a world plane (across axis at the coordinate at): adds an edge loop there, like a loop cut placed in metres. clear removes one side (the inner side is the negative side of the axis); fill=true closes the cut. Use it to slice, to add a loop for later extrusion, or to trim a part flat.

Merge vertices closer than distance metres (empty: 0.0001 m, less on objects under 0.3 m; optionally only those inside where: x, y, z, box). Fixes doubled vertices and seams after joining parts. For a broken mesh with holes and junk use repair_mesh. A distance wider than the thinnest faces collapses them and opens the mesh: the call then fails, changes nothing, and names the new boundary and non-manifold edges, their world box and a smaller distance that is safe. allow_open=true welds anyway and puts the same report into warning.

Move, scale and rotate the vertices of the picked faces (mode faces) or the picked vertices (mode vertices) in world terms. pivot defaults to the region centre. falloff > 0 drags the neighbours too, like proportional editing: weights fall from 1 at the region to 0 at falloff metres away, shaped by falloff_type. Use it to widen a head, taper a leg, raise a ridge. symmetric adds the mirror twins of the picked vertices about the centre of the mesh box on that world axis (the answer gives mirrored_vertices and without_twin); the transform itself is not mirrored. Without it the answer has a warning when the mesh is mirror-symmetric and the selection lies on both sides of the plane but is not symmetric. where picks faces (or vertices, edges) by a condition, all given keys must hold: normal ('+Z', '-X' or [x,y,z]) with angle (degrees, default 25); x, y, z ranges [min, max] (null means open) on the world centre; box [[x0,y0,z0],[x1,y1,z1]]; area [min, max]; index [...]. {} or null picks everything. Look at mesh_info first to see where the faces are.

Sculpt by numbers: move the vertices under a brush. Brush: either at + radius (a sphere in the world, strongest at the centre), or where (+ mode) with spread, the number of metres around the region that still feel the brush; falloff shapes the fade. The mesh needs enough vertices: subdivide_faces first. op grab: pull the surface by the world vector move. op inflate: push it out (or in, negative) along its normals by amount metres. op smooth: relax it towards the average of the neighbours, iterations times by factor; with no brush it smooths the whole mesh; keep_boundary leaves open edges in place. For shading only use shade. op flatten: press the area onto its own average plane; strength 1 (default) is fully flat. Soles, table tops. op pinch: draw the area towards its centre in the surface plane (sharpens creases, narrows a part); strength 1 collapses it, default 0.5. Parameters of another op are ignored. The answer has vertices_moved. where picks faces (or vertices, edges) by a condition, all given keys must hold: normal ('+Z', '-X' or [x,y,z]) with angle (degrees, default 25); x, y, z ranges [min, max] (null means open) on the world centre; box [[x0,y0,z0],[x1,y1,z1]]; area [min, max]; index [...]. {} or null picks everything. Look at mesh_info first to see where the faces are.

Bend, twist, taper or stretch the whole mesh. bend and twist take amount in degrees, taper and stretch a factor. axis: for twist, taper and stretch it is the long axis of the part; for bend it is the axis the part curls around, so a standing bar (long along Z) bends forward with axis X or sideways with axis Y. origin is a world point (default the object origin); limits [0,1] restrict the effect to a fraction of the length. The mesh needs enough vertices along the axis: subdivide_faces first.

Snap the vertices of object onto the surface of target (clothes onto a body, a clean mesh onto a sculpt, a floor onto terrain). Method project moves them along axis (default Z) in direction. offset keeps a gap in metres. Subdivide the object first for a smooth fit.

Rebuild the mesh as an even voxel surface: fuses overlapping parts into one skin and gives clean topology to sculpt. A smaller voxel_size means more detail and many more triangles. The old topology and UVs are lost. Use subdivide to round a mesh and keep its topology, subdivide_faces to add geometry to picked faces.

Make one smooth organic mesh from overlapping balls (metaballs): the balls merge into a single skin. Good for hands, clouds, bushes, rocks, creature bodies. One radius per point; nearby balls blend, so use radii a bit larger than the surface you want.

Combine two meshes: a is changed, b is the tool and is deleted unless keep_tool. difference cuts b out of a. Both should be closed and have outward normals (check_mesh). With repair=true an open mesh is first healed with repair_mesh (the answer lists repaired). If that does not close it, the call fails and names the object, the number of open edges and where they are (world box). a keeps its own material slots: the faces made by b take the material of the faces of a next to them, and empty slots are removed. The result is welded and its zero-area faces are dissolved (merged_vertices, removed_zero_faces; doubled_vertices_left where parts only touch along an edge). The result is checked: when solver leaves new boundary or non-manifold edges, the other solvers and a tool shifted by a few micrometres are tried; the answer names the solver used (and tool_shift_m). If none gives a closed result the call fails, changes nothing, and gives the edge counts and their world box. allow_open=true skips the input check and keeps such a result with a warning. Use it for windows, doors, holes, notches.

Heal one mesh in place: merge doubled vertices (weld in metres; empty follows the size, 0.0001 m for 0.3 m and more; 0 skips it), drop zero-area faces and edges (dissolve_degenerate), delete loose edges and vertices (remove_loose), fill holes of up to hole_sides edges (0 means any size; fill_holes=false skips it), turn normals outward, and remove material slots without a material (remove_empty_slots; their faces go to the first slot left). The answer gives removed (doubled_vertices, zero_area_faces, loose_edges, loose_vertices, empty_material_slots) and before and after counts: open_edges, non_manifold_edges (3 or more faces on one edge, not repaired), doubles, zero_faces, junk_vertices. Run it before boolean on parts you cut or joined by hand.

Move the origin of each object without moving its geometry or its children in the world. Give either at (one world point for all) or anchor (fractions of the world box of each object, without children: (0.5, 0.5, 0) is the bottom centre, (0.5, 0.5, 0.5) the centre). Use it for pivots: a hinge axis, the base of a prop, the grip of a weapon. Mesh data shared with other objects becomes a private copy.

Merge several meshes into one mesh object, as Join (Ctrl+J) does in Blender (in world space, materials kept). Do it before export to save draw calls. The parts are not welded or moved: use move_to_contact to close a gap.

Repeat an object count times along the world vector offset (step in metres) and merge the copies into one mesh. Fences, stairs, windows, planks, teeth.

Repeat an object around a world axis through center, over angle degrees (360 is a full circle), and merge the copies. Wheels' spokes, columns in a ring, petals, gears.

Give a surface thickness in metres (walls from planes, cloth, leaves). offset -1 grows inward, 1 outward, 0 both ways.

Spin a profile around an axis. profile is a list of [radius, height] points from the bottom up. A profile that touches the axis (radius 0) at both ends makes a solid (vase, bottle, column, cone). A profile that stays away from the axis is an open tube: close=true repeats the first point so the loop is closed and the spin gives a ring (donut, tyre, pipe section, torus-like shapes). angle under 360 makes a wedge.

Pull a cross-section along a path of world points: pipes, cables, railings, trims, horns, tails, roads. radii gives one radius per point (a taper). profile is a closed 2D polygon [[right, up], ...] of the cross-section (default a circle with sides); the frame turns smoothly along the path, up is the starting up direction.

Reduce the triangle count. collapse: merges vertices to reach ratio (0..1 of the current triangles) or target_tris; it can distort shapes and UVs, so check with compare_view afterwards. planar: dissolves flat faces whose neighbours differ less than angle degrees (cleans up subdivided flat surfaces without changing the shape).

Give meshes a material (Principled BSDF, exports to glTF). The quick form is names and color: '#rrggbb' or [r, g, b] in 0..1. Without material the name comes from the numbers, so equal parameters reuse one material (fewer draw calls); an existing name is rebuilt. Slot 0 gets it: use assign_material_faces for parts of a mesh. alpha below 1 is glTF BLEND: glass only, transparent faces cost sorting. emission is {"color": "#ffcc66", "strength": 2.0}. coat is a clear layer. subsurface does not reach glTF. Image paths (the meshes need a UV map: unwrap or palette_uv first): texture (base colour; color then tints it, '#ffffff' keeps it; alpha multiplies its alpha), normal_map (tangent space), roughness_map and metallic_map (grey), or orm_map instead of those two (R occlusion, G roughness, B metallic). A map replaces its number. bump {"scale": 20, "strength": 0.3} is a procedural noise for renders only: bake_maps turns it into a normal map. The answer has gltf: alphaMode, the factors and the texture slots that will be written. For patterns (wood, bricks, worn metal) use procedural_material.

Every material: name, colour, number of users, whether it has a texture and which procedural nodes it has. Procedural nodes (noise, gradients, math) are not exported to glTF: not_exported marks those materials. faces_without_material counts, per object, the faces that sit in an empty slot or have no slot. Fix them with assign_material_faces. Use it to find look-alikes before dedupe_materials. With name the answer is the card of that one material: colour, roughness, metallic, alpha, emission, coat, subsurface, the paths of its texture and maps (and the normal map colour space, which must be Non-Color), procedural nodes, users and faces per object. alpha_mode is the glTF alphaMode that export_glb writes (OPAQUE, BLEND or MASK); render_method is the EEVEE draw mode (DITHERED is the normal one for opaque).

Put an existing material on the picked faces of one mesh. Adds a material slot if the object has none for it. Other faces keep their material. One mesh with several materials costs one draw call per material in the engine, so keep the count low. Create the material first with set_material. where picks faces (or vertices, edges) by a condition, all given keys must hold: normal ('+Z', '-X' or [x,y,z]) with angle (degrees, default 25); x, y, z ranges [min, max] (null means open) on the world centre; box [[x0,y0,z0],[x1,y1,z1]]; area [min, max]; index [...]. {} or null picks everything. Look at mesh_info first to see where the faces are.

Merge materials that look the same: same colour, roughness, metallic, alpha, emission, coat and same textures, each within tolerance (0.01 means 1 percent). Users move to the first material of each group, the extras are deleted, and slots that now repeat inside a mesh are joined. Fewer materials means fewer draw calls. names limits the check. Returns how many were removed and the material count before and after. Textured and procedural materials only merge when their images and node types are the same. It also cleans up, on every mesh: clean_slots=true removes empty slots and slots that no face uses (empty_slots_removed, unused_slots_removed); remove_orphans=true deletes materials with zero users (orphans_removed). An empty slot that faces still point at is kept and listed in faces_without_material: assign those faces first. tolerance=0 merges only exact copies.

Move the vertices by fractal noise. Use it for bumps on a surface, worn stone, uneven ground. amount is the largest shift in metres: no vertex moves further. scale is the size of the biggest bumps in metres (smaller scale gives finer bumps). octaves 1 to 8 adds finer detail on top, each at half strength. The same seed gives the same result. Another seed gives other bumps. The noise is sampled in world space. mode: normal (along each vertex normal), z (up and down only, for ground), vector (any direction, rough lumps). where picks faces like extrude_faces does (normal, x, y, z ranges, box, area, index); nothing outside is moved. spread is a soft border in metres around the picked faces, shaped by falloff. Without where the whole mesh moves. The mesh needs enough vertices to show the bumps: subdivide_faces or subdivide first. Returns the largest shift that happened.

Make a ground mesh from a noise height map, for outdoor levels. Same seed, same ground. size is [width along X, depth along Y] and resolution the grid step, in metres (0.5 looks low-poly). Over 160000 vertices is an error: raise resolution. height is the full range above the z of the object. scale is the size of the biggest hills in metres; octaves adds finer bumps. at is the world position of the centre and the origin. edge_falloff 0-1 makes an island: the share of the half size at the border where the ground sinks to zero. flat_center is the radius of a level circle in the middle (for a building); it blends out over half that radius. plateau_levels (2 or more) makes terraces of equal height. The bottom is open. skirt (a world z below the lowest border point) adds walls down to that z and a flat bottom: a closed block. Faces are flat shaded unless smooth=true. Returns the vertex count and height range. Then use path_carve for roads and scatter for rocks and trees.

Press a road, a ditch or a path into a terrain mesh along a polyline. points are world [x, y] pairs (extra values are ignored); give at least two. width is the full width in metres of the level floor. depth is how far the floor sinks, in metres (a negative value raises a bank). falloff is the width in metres of the sloped edge on each side; default is half of width. 0 gives a hard edge. The terrain needs a grid fine enough for the width: resolution of at most a third of width looks right. Existing vertices move only down by depth times a weight, so the road follows the hills. Use this on a mesh from the terrain tool.

Make a closed rock mesh: an icosphere roughened by noise and squashed. Same seed, same rock. radius is the half width in metres: the wider of the X and Y extents is 2 x radius. roughness 0 to 1 is how far the shape departs from a ball. flatness 0 to below 1 squashes it down (0.5 is a flat boulder). detail 1 to 5 is the subdivision: 1 gives 20 triangles, 2 gives 80, 3 gives 320, 4 gives 1280. For a low-poly game use detail 1 or 2 with facets=true. facets=true shades each face flat (hard crystal look); false shades smooth. at is where the bottom centre of the rock sits in world space; the object origin is there, so the rock stands on the ground. Vary seed, radius and flatness to make a set of different stones. The mesh passes check_mesh.

Give meshes a procedural node material for renders. It does NOT reach glTF: run bake_maps afterwards to turn it into images. Kinds: wood (rings, fibres, knots), checker, diamond (knurled bump), bricks (with mortar), noise (mottled), marble (veins), worn_metal (used steel: dirt in cavities, bright edges, scratches, rounded edges). color_a is the main colour, color_b the second (dark grain, mortar, veins, dirt), both '#rrggbb'; each kind has its own when empty. scale is the pattern frequency; seed shifts the pattern. roughness is 0-1; for worn_metal it is the clean metal, dirt and scratches add to it. Patterns lie on the UV map (a mesh without one is unwrapped with smart project and listed in unwrapped), so their size follows the UV islands. worn_metal works in object space instead: no seams, sizes follow the object. Its dirt, edge wear and rounding use ray-traced nodes: seen in cycles and bake_maps, not in eevee, and neighbour objects darken the cavities, so build the model first. params (optional): bump_strength; wood: grain_stretch (6), knots (true), distortion; marble: distortion; bricks: mortar (0.03); noise: detail_scale; worn_metal: dirt (0.6), edge_wear (0.5), scratches (0.3), metallic (1.0), and in metres bevel_radius, wear_width, ao_distance. The same material name rebuilds it. Slot 0 of each mesh gets it. For a plain colour or image maps use set_material.

Bake the material of one mesh into PNG maps on its UV, so glTF can carry a procedural or layered material. Uses Cycles on the CPU. maps: base_color (sRGB), normal (tangent space), roughness, metallic, ao, orm (one image: R occlusion, G roughness, B metallic). Empty means base_color, normal, roughness, ao. For a metal ask for base_color, normal, orm. Files are _.png in out_dir (the work folder, bakes/, when empty). size is pixels, a power of two: 512-1024 for props, 2048 for a hero asset. margin is the pixel padding around UV islands. samples: 16 is enough for colour and normal, raise it for a clean ao. bevel_radius (metres, about 0.2-0.5% of the object size) rounds hard edges in the normal map only; it needs a material without an image normal map. The mesh needs a UV map without overlaps (check_mesh reports the UV); without one it is unwrapped with smart project. uv_layer picks another layer. A material without bump gives a flat normal map and the answer says so. replace_material=true builds the Principled material <object>_baked from the images and puts it on the mesh, so export_glb writes the textures. ao alone stays a file; inside orm it becomes occlusionTexture. One call bakes one object. Background job, one map per step (a 2048 px map takes 20-60 s): after wait seconds the answer is a job id for job_status (cancel=true stops it). Do not edit the object while it runs.

Clean a real-world reference for the other reference tools: crop it, remove the background and keep only the biggest object (a photo with two donuts and a caption becomes one donut with a transparent background). crop is [x0, y0, x1, y1] as fractions of the image from the top left (one panel of a sheet of views). keep=all keeps every blob. threshold is the colour distance from the background; leave it out and it is set just above the noise of the picture border (the answer shows the value). The background must be plain. fill_holes closes holes inside the object that are smaller than this share of the object area (glare on steel that looks like background); bigger openings such as a trigger guard stay. 0 closes nothing, 1 closes all. flip 'x' mirrors left-right, 'y' top-bottom; rotate turns clockwise by degrees (flip first). Use them to bring a panel to the picture a view expects (see compare_view). The result is an RGBA PNG cropped to the silhouette with pad margin; use its path as the reference of compare_view, fit_to_reference, visual_hull, measure_profile. The answer has the hole count and hole area share before and after filling, the blobs dropped, a warning (many open holes, the object touches the crop border, a big part dropped) and a preview picture: the cut-out over magenta and the mask (white object, green filled holes, red open holes). Look at the preview: alpha is not visible in the PNG itself.

Measure a silhouette in a reference image in metres (use measure for an object of the scene). The image height is mapped to height_m. Returns, for each horizontal band from the bottom: width, left and right edge from the centre, the separate runs (arms and legs are separate runs) and the filled width. Use the numbers for loft sections, assert_spec checks or to find where the model differs. The outline comes from alpha or from the corner colour (see prepare_reference). grid=true also returns the reference with a metric grid (labels in millimetres, the same coordinates as the bands: x from the centre of the silhouette box, z from its bottom), to read where parts and details are. region [x0, z0, x1, z1] in metres zooms the grid picture into a part; grid_size is its long side in pixels; out saves it to a file.

Trace the outer outline of a reference silhouette as a closed polygon of [x, z] points in metres (x from the centre of the silhouette box, z from its bottom). simplify is the largest allowed deviation in metres. Feed the points to extrude_profile, or build a hull with visual_hull. holes=true also returns holes: the openings inside the outline (a trigger guard, a handle) as polygons, largest first, each at least min_hole of the outline area; give them to extrude_profile as holes. The reference must keep its openings (prepare_reference fill_holes).

Make a solid by extruding a closed 2D polygon, centred on its depth. plane XZ: points are [x, z] and the depth runs along Y (front outline); YZ: [y, z], depth along X (side outline); XY: [x, y], depth along Z (top). at shifts the result in the world. holes is a list of polygons in the same coordinates (or the holes of trace_outline as they are): each is cut through the solid with the checks of boolean; a flawed cut is kept and listed in warnings. Good for soles, panels, signs, floor plans, outline-based parts.

Build one rounded body from a front and a side silhouette image (with numbers instead of images use loft): per band the width comes from the front image and the depth and forward offset from the side image, so the cross-sections follow both outlines. part=largest uses the widest run in a band (the torso, not the arms); part=extent uses everything. side_faces says which way the figure looks in the side image (left matches the world: the front is -Y). z_range limits the height as fractions (0.0 to 0.5 builds the lower half). roundness 2 is an ellipse, 4 a rounded box. The body spans the full height (or z_range): the first and the last band end flat at their outer edge.

Make a solid that matches BOTH silhouettes exactly: the front outline extruded and intersected with the side outline extruded. Arms, ears, noses and other outline details come out right in both views. The inside is a straight extrusion, so refine curved surfaces afterwards (sculpt, subdivide). Use it for a precise first form of characters, props and vehicles.

Compare the model with a reference image in one flat view: the main metric of a build from references. The reference is placed in the world: its bottom on the model bottom, horizontal centres equal. Scale: height_m is the real size of the subject along the VERTICAL of the (turned) picture, width_m along its horizontal; give one, and a model that is too big or too small is caught. With none the reference is fitted to the model height and only the outline shape is compared. iou_outline is always that shape-only match. Views (the model front faces -Y, Z up) and the picture each expects. front: +X to the right. back: -X to the right. right (side is the same): camera on +X, the front points LEFT. left: the front points right. top: +X to the right, the front at the BOTTOM. bottom: the front at the top. flip ('x' left-right, 'y' top-bottom) and rotate (degrees clockwise; flip first) turn the reference for this call. names is the model (empty: everything visible but a huge floor or backdrop, listed in excluded). Returns iou_registered, both sizes, a table per band along the vertical (widths, delta, shift, verdict; worst first) and inner_detail: edge_agreement 0..1 between the reference inner edges and the creases and depth steps of the model (the IoU does not see slots and holes inside the outline). Under IoU 0.3 a hint says if a mirrored or turned reference fits far better. The image: reference, model, overlay (red reference outline, green model outline, yellow and blue inner edges), difference; out also saves it. colors=N adds the match of N colour classes of the reference. For a perspective photo use match_camera and overlay_reference.

Move, scale and tilt parts by itself to raise the match with reference silhouettes. Use it when the forms are roughly right: it fixes placement and proportions, not shapes. For each part in parts it keeps the changes that raise the world-registered IoU over all views (as compare_view measures it). references maps a view (as in compare_view) to an image; names is the whole model (everything visible but a huge floor or backdrop when empty). Scale per view, as in compare_view: height_m (vertical of the picture) or width_m (horizontal). Each is one number for all views or a dict per view, and every view needs one: height_m=0.152 with width_m={"top": 0.0325}. A size that names the view wins over a plain number. mirror_pairs [["arm_L","arm_R"]] keeps pairs symmetric (list both in parts). tune picks what may change. Guard: a move that raises the IoU but hides the part is refused: visible_share (the share of the part that the rest of the model does not cover) may drop by max_hide at most (1 turns the guard off). The answer lists rejected moves and visible_share [before, after]. It takes the checkpoint 'before_fit' first: rollback undoes it. Background job: after wait seconds the answer is a job id for job_status.

Draw the model and a reference picture on top of each other, seen through a scene camera: it shows how far the camera and the model are from the photo. The model is rendered from camera (the scene camera when empty; without one call set_camera or match_camera first) at the proportions of the reference; the long side is size pixels. names is the model (everything visible when empty). Modes: blend (the reference at alpha); edges (red reference outline, yellow reference inner edges, green model outline over the dimmed model: best for small shifts); difference (black is a match); split (reference left of a line at the split fraction of the width, model right: lines must continue across it). The answer has the path, the silhouette IoU and the picture. The reference outline comes from alpha or the corner colour; threshold is the colour distance. Give the original photo, not a crop. grid_height_m (the real height of the reference silhouette) draws a metric grid with millimetre labels; zero is the bottom centre of the silhouette box. It is true for a flat-on (orthographic) reference only. Before a model exists, read coordinates with measure_profile grid=true.

Find the camera that shows the model like a perspective photo of the real object (for flat orthographic views use compare_view). It tunes position, rotation, roll and field of view until the model silhouette best matches the reference silhouette. The camera camera is created or updated and becomes the scene camera. The answer has location, rotation, look_at, fov_deg and the IoU before and after. Give the whole original photo, not a crop: the picture frame is the camera frame. The outline comes from alpha or from the corner colour (plain background); threshold is the colour distance. Start: init {"location": [x,y,z], "look_at": [x,y,z], "fov_deg": 40}, else the active perspective camera, else 8 azimuths at 2 elevations are tried. A close start gives a better result. fov_deg fixes the angle across the LONGER image side: a known lens is far more reliable, because distance and field of view trade off. ground_z keeps the camera above that height. size is the working resolution; iterations is how many times the step is halved. A silhouette does not tell front from back on a symmetric model: check with overlay_reference. Background job: after wait seconds the answer is a job id for job_status.

Turn picture pixels into world points. A ray goes from the camera through each pixel and hits the plane z=plane_z (the floor by default) or plane {"point": [x,y,z], "normal": [x,y,z]}. pixels is a list of [x, y]: x to the right, y down, from the top left of a picture of image_size [width, height]. It uses the field of view, the sensor fit, the lens shift and orthographic cameras. A point is null if the ray is parallel to the plane or the plane is behind the camera. Use it to read sizes and positions off a photo after match_camera (for example the width of something that stands on the floor). Heights above the plane cannot be read from one view.

Move an object so that a point of its box lands where a picture pixel points. anchor is the point of the box of the object with its children as fractions (0.5, 0.5, 0 is the middle of the bottom). pixel is [x, y] in a picture of image_size [width, height], y down. With plane_z the ray from camera hits that horizontal plane. Without it the ray stops on the first surface of the scene (the object itself is ignored) and, if there is none, on the plane at the bottom height of the object. It only moves: size and rotation stay. Returns the description of the object and what it was placed on. Use it to put parts where the photo shows them, after match_camera. Without a photo use attach, move_to_contact or place_on.

Create or update a camera for render_final. Place it one of two ways. Explicit: location and look_at in world metres; on an existing camera, one of them keeps the other. Framed: frame is a list of object names (with children); the camera stands so their box fits the view. azimuth (degrees around Z: 0 looks from the front at -Y, 90 from +X; 35 when empty) and elevation (above the horizon; 20 when empty) set the side; margin is spare room (1.15 = 15%); look_at overrides the aim point. fov_deg is the vertical field of view and is applied on every call, so repeat it on updates. fov_deg=0 or an ortho_scale (metres across) makes it orthographic. roll_deg rolls about the view axis. make_active sets the scene camera. Returns the location, the forward vector and the projection. For a camera that matches a photo use match_camera.

Replace the studio lights with a preset. Lights are named bl_light_*; earlier ones are deleted first, so a second call never doubles them. Other lights in the scene are not touched. Presets: three_point (key, fill, rim), sun (one hard sun), soft_studio (large soft panels, even light), night (dim blue moon and a warm lamp), metal (for metal and glossy product shots: an interior HDRI that the surface reflects, a key spot and a rim spot). strength scales all of them (1 is a normal exposure). metal also replaces the world: set_world hdri='interior' at strength 0.6, hidden from the camera, so the backdrop keeps the colour it had. The answer has it under world; call set_world afterwards for another HDRI, rotation or backdrop. The other presets do not touch the world: with area lights only, metal has nothing to reflect and renders black or blown. target is a list of object names; light size and distance follow their box (default: all visible geometry). The key light stands front-right (azimuth 40) so it suits the default set_camera view. color tints the lights: '#rrggbb' or [r, g, b] (0-1). Pair it with set_world for the background.

Set the background and ambient light: a plain colour or an HDRI image. color is '#rrggbb' or [r, g, b] (0-1). An explicit color wins over the preset colour. strength multiplies the light (1 is normal). With neither colour, preset nor hdri only the strength changes. hdri lights the scene with an image and gives metal and glass something to reflect. It is a path to an .hdr or .exr file, or the name of a studio light shipped with Blender: city, courtyard, forest, interior, night, studio, sunrise, sunset (the answer lists them in builtin_hdris; an unknown name gives the list in the error). rotation_deg turns it about Z. visible_to_camera=false keeps the HDRI for light and reflections, and the camera sees the plain color or preset colour instead (without them: the colour the world had). Works in eevee and cycles. A later call without hdri and with a colour or preset makes the world a plain colour again. transparent=true makes the render background transparent (alpha 0) and the world only lights the scene. The flag stays on until set_world is called again with transparent=false.

Render the scene to a file with its own lights, materials and camera, and show the picture. Needs a camera: call set_camera first (or pass camera). For quick check pictures use render_sheet (overview) or render_view (any angle, no set-up). path is absolute, or relative to the work folder; the folder is created. engine: eevee (fast), cycles (slow, CPU, real light), workbench (flat preview, no lights needed). size is pixels for a square, or [width, height]. samples is the quality: 16-64 for eevee, 32-256 for cycles. transparent writes alpha (PNG, WEBP, TIFF, OPEN_EXR) and hides the world. denoise is for cycles only. view_transform: Standard keeps colours true; Filmic, AgX or Khronos PBR Neutral if the Blender build has them. exposure is in stops for this render only (+1 doubles the light); without it the scene exposure (set_post) is used. auto_exposure=true first renders a small probe and picks the exposure that puts the median luminance of the geometry at mid grey; the answer has auto_exposure. meter is a list of object names (with children) to measure instead of all geometry: give the model, so a floor or backdrop does not steer the exposure. Except for OPEN_EXR the answer has tone numbers of the written picture (0-1): frame and, when the geometry is known (meter, auto_exposure or transparent), object: median, mean, clipped_highlights and crushed_blacks. warnings appears when over 10% is clipped or over 50% is black. Read these numbers before you trust the picture. The scene settings are restored afterwards.

Save the scene to a .blend file. By default it saves a copy: the open file and its name stay as they were. make_current=true makes the saved file the open one (like Save As). path is absolute or relative to the work folder; .blend is added if missing. compress=true gives a smaller file.

Make a skeleton from numbers. bones is a list of {"name", "head": [x,y,z], "tail": [x,y,z], "parent": name (optional), "connect": bool (optional)} in world metres; list parents before children. For a biped: root, spine, chest, neck, head, and arms and legs with L/R suffixes. Then bind a mesh with bind, and test with pose.

Bones of an armature with parent, world head and tail, length.

Skin meshes to an armature: adds one vertex group per bone, the Armature modifier and the parent. method 'proximity' weights each vertex by its distance to the nearest bones (up to max_influences, power falloff; fast, works on any mesh, good for stylised low-poly); 'auto' uses Blender's heat-map weights and falls back to proximity when the mesh is not clean. Existing groups with the same names are overwritten. Check with check_weights, then try poses with pose_sheet.

Copy skin weights from a skinned mesh to another mesh by nearest vertex (same rig for clothes, hair, a new character body). Both meshes should stand in the same place. The Armature modifier is set up too.

Skin quality: vertices without weight, with more than max_influences bones (glTF wants 4), weights that do not sum to 1, groups that match no bone, a missing Armature modifier.

Pose bones by numbers: {"bone": [rx, ry, rz]} in degrees (Euler XYZ, local to the bone), or {"bone": {"rot": [..], "loc": [..], "scale": [..]}}. reset=true clears all other bones first. An empty pose returns to rest. A bone along Z bends forward when rotated about X.

One image with the mesh in several poses side by side, left to right in the order given: {"rest": {}, "walk": {"thigh_L": [30,0,0]}}. Use it to see joints bend, find tearing and collapsing, and compare with check_weights. The rest pose is restored afterwards.

Make a UV map. Method smart is Smart UV Project (a larger angle gives fewer, larger islands); angle is angle-based unwrap; cube, cylinder and sphere are projections. margin is the gap between islands (0..1); pack arranges the islands in the 0..1 square. Returns the UV numbers of each mesh: islands, used area, faces outside 0..1, degenerate faces and texel_density_spread (1 is even, above 4 is stretched). check_mesh gives the same numbers for an existing UV map.

Paint vertex colour on the picked faces (see select_faces for where: normal, x/y/z ranges, box, area, index). Colour is '#rrggbb' or [r,g,b]. For stylised models that use vertex colours instead of textures.

Point the UVs of the picked faces at the centre of one cell of a palette texture, so the face takes that flat colour: cell [column, row] with row 0 at the top, grid [columns, rows]. For palette-atlas styles (one small colour grid image shared by all models).