Get the current Blockbench state: open project, format, counts of cubes/groups/textures/animations, and edit mode. Call this first to understand the workspace. If you are about to BUILD or TEXTURE a model, call get_guide first.

Return a playbook. Pass topic: 'modeling' (default — proportions, detail, rotation), 'texturing' (the smooth @volmur/Hytale look, no dirty noise), 'vfx' (pixelated flames/energy/projectiles/trails/auras via planes + emissive textures + animation), 'animation' (rigging, gaits, easing), or 'reference' (how to ACTUALLY match a reference image instead of 'almost'). READ the relevant topic BEFORE building/texturing/animating — it dramatically improves results.

List all model formats available in this Blockbench install (e.g. free, java_block, bedrock, and any added by plugins such as GeckoLib's animated_entity). Use the returned id with new_project.

Create a new project from the start screen, choosing a format. This is the entry point for any new model.

Update the open project's name, geometry name, or texture resolution.

Close the currently open project.

Save the open project as a .bbmodel. Provide path to save to a specific file (desktop), otherwise Blockbench's save flow is used.

Export the project through its format's codec (e.g. Java model JSON, Bedrock geometry, GeckoLib model). Provide path to write a file directly.

Load a .bbmodel project file from disk (desktop only).

Add a group / bone to the outliner. Groups are the bones used for animation AND the way to apply free 3-axis rotation: a cube alone rotates cleanly on only one axis, so to pose a part at a compound angle, put it in a rotated group (nest groups for multi-axis angles). Set origin to the real joint so rotation pivots correctly. Returns the created group with its uuid.

Add a cube to the model. Coordinates are in Blockbench units. Cubes support rotation (degrees) and inflate (round/shrink without moving) — use them; flat axis-aligned boxes look robotic. For compound multi-axis angles, parent the cube to a rotated group instead. Prefer add_cubes to build many cubes at once. Returns the created cube with uuid and resolved face UVs (paint onto those with paint_faces).

Create many bones/groups in one call — the fast way to lay out a whole skeleton. Pass groups: an array of {name, origin, rotation, parent}. A group's parent may reference another group created earlier in the SAME call by name, so you can build a nested, pre-posed bone hierarchy at once.

Create many cubes in one call — the efficient way to author a detailed model (aim for 20-50+ cubes for a creature, not 6-8). Pass cubes: an array where each item takes the same fields as add_cube ({name, from, to, origin, rotation, inflate, parent, box_uv, uv_offset, faces}). Build symmetric parts by emitting both the left side and its mirror (negate X, flip Y/Z rotation signs) in the same array. AVOID Z-FIGHTING: when cubes overlap, make one clearly penetrate the other (by >=0.1) and never align two faces to the exact same coordinate; stagger decorative pieces' depths. Returns all created cubes with their face UVs.

Audit the model for problems that make results look broken: untextured faces (the 'gaps'), zero-area or out-of-bounds UVs, degenerate cube sizes, cubes not parented to a bone in animated formats, and Z-FIGHTING (coplanar_overlap — two faces on the same plane that flicker/clip, the 'two squares inside one another'). Run this after building and before/after texturing, then fix what it reports (for coplanar_overlap, nudge one cube by >=0.1 so the faces aren't coplanar). Returns a grouped issue list.

Shelf-pack the box UVs so every cube gets its own region of the texture. REQUIRED before texturing a box_uv model (GeckoLib/Bedrock): newly created cubes all sit at uv_offset [0,0] and otherwise paint onto the same pixels. Re-run after adding or resizing cubes. Auto-grows the texture (preserving paint) if the layout overflows.

Create a flat 2-sided plane (billboard) — the building block of pixel VFX (flames, energy sheets, slashes, motion trails) and for thin details (fins, leaves, paper). It is a zero-depth cube whose two large faces carry the texture; pair it with a VFX texture set to render_sides 'double'. crossed:true makes an X of two perpendicular planes for a volumetric particle look. Parent it to a bone to animate it.

Create a non-cuboid MESH primitive so models aren't limited to axis-aligned boxes — crystals/gems/shards, pyramids, wedges, cones, cylinders, planes. Great for crystal cores, blades, horns, teeth, gems and stylised VFX. NOTE: meshes need a mesh-capable format (free/generic/bedrock); GeckoLib & Java export cubes only — for those build crystals from cubes rotated 45° instead.

Mirror a cube or group (with its children) across an axis about a pivot — build one side of a symmetric model, then mirror it. Flips geometry and the off-axis rotation signs, and renames left<->right. Returns the created clones.

Edit an existing cube or group (rename, move, rotate, reparent, resize, inflate, visibility).

Delete a cube or group (and its children) from the model.

Return the full outliner tree (groups/bones and their nested cubes) with uuids, origins and rotations.

Get detailed info for one cube or group by uuid or name.

Set UV mapping and/or per-face texture on a cube's faces.

Apply a texture to all faces of an element (or all cubes if element omitted).

Create a new texture. Either fill it with a solid color, or supply a full PNG via data_url. Returns the texture uuid.

Generate a pixelated VFX texture: a bright hot core fading to cool edges in quantized colour bands with jagged transparent edges — the look of pixel flames/energy/projectiles. With frames>1 it bakes a vertical FLIPBOOK and starts the animation player so the effect loops. Defaults to an additive/emissive render mode + 2-sided rendering so it glows on a plane. Apply it to add_plane planes (crossed/layered) and animate with bones. See get_guide topic 'vfx'.

Set how a texture renders: render_mode ('default' | 'emissive' = full-bright, ignores light | 'additive' = bright pixels add light & dark vanishes, best for fire/energy on planes | 'layered' | 'normal' | 'height' | 'mer'), render_sides ('auto' | 'front' | 'double' for 2-sided planes), flipbook frame timing, and particle flag. Use this to make VFX glow and to show planes from both sides.

Import a texture from an image file on disk (desktop only).

List all textures in the project.

Read a texture back as an image so you can inspect what it currently looks like. Returns the PNG inline.

Paint directly on a texture with absolute pixel coordinates. Use this for whole-sheet work; for painting onto a specific cube face, paint_faces (face-relative coords) is usually easier. Ops run in order on the canvas (origin top-left, y down).

SMOOTH base texturing — the @volmur/Hytale look. Assigns the texture to every chosen face (no untextured 'gaps'), then per face bakes a soft vertical gradient in the region colour + gentle directional shading (top lighter, underside darker) + a SUBTLE low-contrast mottle, and finally a 3x3 box blur per UV island (the 'smooth brush'). Run pack_uv FIRST, then this right after create_texture, then paint_faces for crisp features. Avoids the dirty/noisy/grid look (no hard edge outline, low noise by default). Cubes named _core/_glow are filled bright (emissive read).

Paint features onto specific cube faces using coordinates RELATIVE to each face (so [0,0] is that face's top-left corner) — no manual UV math, which is what usually causes misplaced/garbled texture. Use it for eyes, nostrils, mouths, claws, fur tufts, stripes, scars, bandages, armour trim, etc. Either pass one {cube, face, base?, ops?} or a faces array of them.

Resize a texture's bitmap to new dimensions (nearest-neighbour).

Create an animation (requires a format that supports animation, e.g. GeckoLib animated_entity or Bedrock entity). Returns the animation uuid.

List all animations and their animated bones.

Add a single keyframe to an animation for a given bone and channel.

Add many keyframes at once — the efficient way to author a full animation. Pass an array of {bone, channel, time, value, interpolation}.

Delete an animation from the project.

Position the preview camera, by named preset and/or explicit camera position & target.

Capture the current 3D preview and return it as an image so you can visually inspect the model and iterate. Optionally specify width/height.

Capture several camera angles in ONE call and return them all as images, so you can see the whole model and catch problems (gaps, wrong rotations, missing detail, asymmetry) from every side. Defaults to iso/front/left/back. This is the main way to review and iterate — do it after each modeling/texturing pass, not just once.

List Blockbench plugins (installed and available in the store). Filter with query or installed_only.

Install a Blockbench plugin from the store (by id, e.g. 'geckolib' for GeckoLib Models & Animations), or from a url, or a local path. Needed before using plugin-specific formats like GeckoLib's 'geckolib_model'.

Uninstall an installed Blockbench plugin by id.

Run arbitrary JavaScript inside Blockbench's renderer for anything not covered by a dedicated tool. The code has access to all Blockbench globals (Project, Cube, Group, Texture, Animation, Undo, Canvas, Outliner, Format, Formats, ...) and receives a params object. Return a JSON-serializable value. Use sparingly; prefer dedicated tools.