BlockbenchMCP
Summary: This MCP server lets an AI assistant control a live Blockbench desktop editor to create, inspect, texture, rig, animate, and export 3D models, especially Minecraft/GeckoLib-style models.
Workspace/project control: get status, list formats, create/load/save/close/export projects, set metadata, and install/uninstall Blockbench plugins.
Modeling: add groups/bones and cubes singly or in bulk, planes, meshes, mirrors, edit/delete/reparent elements, inspect the outliner, and set UVs.
Texturing and VFX: create/import/paint/resize textures, generate pixelated VFX textures, apply smooth shading, paint face-relative features, set render modes, and pack UVs.
Animation: create/remove animations, list animations, add single or bulk keyframes, and inspect animated bones.
Visual review: capture single or multiple screenshots, set camera angles, and get textures back as images for inspection.
Validation: audit models for missing textures, bad UVs, degenerate cubes, z-fighting, and unparented cubes; get playbooks for modeling, texturing, VFX, animation, and reference matching.
Automation: run arbitrary JavaScript inside Blockbench via execute_script for tasks not covered by dedicated tools.
Allows AI assistants to interact with the Blockbench 3D modeling editor, providing tools for modeling, texturing, animation, plugin management, camera control, and screenshots.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@BlockbenchMCP Create a block model for a ruby ore"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Blockbench MCP
An MCP server for Blockbench: an AI models, textures, rigs and animates Minecraft models inside the editor.
Quick start · Gallery · Features · Tools · FAQ
Blockbench MCP is an open-source Model Context Protocol server that connects AI assistants such as Claude Code, Claude Desktop and Cursor to the live Blockbench desktop editor. The AI can create Minecraft Java, Bedrock and GeckoLib models, paint textures pixel by pixel, build rigs, write keyframe animations, install Blockbench plugins and take screenshots to check its own work. You don't have to touch the editor.
It has 86 MCP tools over one local connection. They cover blockout, detailing, texturing, rigging, animation and export, with quality gates between the stages so a model ends up with real detail instead of 15 flat boxes.
Gallery
All three models were built, textured and posed by an AI through Blockbench MCP.
Related MCP server: Blockbench MCP
Quick start
git clone https://github.com/sosadly/blockbench-mcp.git
cd blockbench-mcp
npm install && npm run buildIn Blockbench desktop, open File ▸ Plugins ▸ Load Plugin from File and pick
plugin/blockbench_mcp.js. Allow network access when asked.Add the server to your AI client. Here is Claude Code as an example:
claude mcp add blockbench -- node /absolute/path/to/blockbench-mcp/dist/index.jsAsk for something, for example: "Make a textured GeckoLib bear that can walk, run, sleep and attack."
The full setup is under Installation.
How it works
There are two pieces:
Piece | Runs where | Responsibility |
Bridge plugin ( | Inside Blockbench (desktop) | Hosts a local HTTP endpoint on |
MCP server ( | A Node process your AI client launches | Exposes Blockbench as MCP tools (stdio transport) and forwards every call to the bridge. |
┌────────────┐ stdio (MCP) ┌──────────────────┐ HTTP 127.0.0.1:8787 ┌──────────────────────┐
│ AI client │ ──────────────▶ │ blockbench-mcp │ ──────────────────────▶ │ Blockbench + plugin │
│ (Claude…) │ ◀────────────── │ (Node server) │ ◀────────────────────── │ (live editor) │
└────────────┘ └──────────────────┘ └──────────────────────┘Features
🔎 References from the web. For a known character, creature, item, vehicle or product,
find_referencessearches the web (safe search always on) and returns one numbered contact sheet plus a short description;load_reference {result:N}/{url}loads the chosen ones into Blockbench, andzoom_referenceenlarges details like a face or a buckle.🎨 Palettes.
make_palettereads a reference or concept image into named colour families, each with a 5-step hue-shifted ramp (or builds a harmony from a text brief), stores it on the project and lets texturing usecolor:"$hair"/"$hair.shadow".🧱 Modeling. Create bones (groups) and cubes one at a time or in bulk (
add_groups/add_cubesbuild a whole posed skeleton in one call), with full rotation and inflate. Place cubes bycenter+size,attachthem to a face of another cube (they land on the surface and follow its rotation and bone, so nothing floats), or build both sides at once withmirror. Edit, move, reparent and delete elements, and read the outliner tree.⚙️ Round shapes, mechanisms, cloth and hair.
add_cylinder(solid or tube, an exact regular polygon),add_gear(teeth, spokes, hub, axle;mesh_withplaces the next gear so the teeth interleave),add_pipe,add_flare(pleated skirts, capes, lampshades, roofs),add_hair(bangs, side locks, back strands, tails on bone chains with ribbons), andanimate_mechanism(spinning gear trains with the right ratios and directions, pistons, levers, pulsing lights, seamless loops).✨ No z-fighting. Coplanar faces are detected in world space (rotations, bones and inflate included) and fixed automatically for everything a tool creates;
fix_z_fightingcleans up after manual edits.🏗️ Procedural detail. An LLM cannot compute 200 sets of
[from,to]in its head, so these tools do the math.voxelize_matrixextrudes a character matrix into cubes (draw a blade, an emblem or a horn profile as pixel art).add_hollow_volumebuilds a shell with a real cavity (hoods, helmets, pauldrons, cages).generate_arrayrepeats an element along a line, ring or grid with jitter, taper, rotation and an anti-z-fighting depth stagger (torn hems, scales, plates, teeth, rivets).extrude_chainbuilds a tapering, curving chain with one bone per segment (horns, tails, tentacles, braids).add_wingbuilds a jointed wing with a membrane.📏 Density gate.
audit_complexitygrades the model against a cube budget (prop 30-60, mob 100-180, hero 180-300+) and reports monolithic boxes, overlap, micro-detail density, bare flat faces and bone depth. The verdict (too_primitive/acceptable/high_detail) stops a blockout from reaching texturing.🖌️ Texturing engine.
detail_cubesshades every pixel from its 3D point: hue-shifted light (cool shadows, warm lights), ambient occlusion, edge bevels and per-material detail (skin, cloth folds, hair strands with a shine band, metal sheen and scratches, wood grain, stone, leather stitching, scales, glowing emissive), plus world-space patterns that run across neighbouring cubes (plaid, stripes, panels with rivets, lace and trim borders, hazard, bricks…).paint_facedraws eyes, brows, mouth and blush as pixel art in the face's own grid.pack_uvgives thin cubes per-face UV so every face gets real pixels. Low-level paint ops (pixels, rects, ellipses, polygons, dither, noise, gradients) and face-relativepaint_facesare still there.🦴 Rigging.
create_rigbuilds a segmented humanoid or quadruped skeleton with three bones per limb (so elbows and knees bend), joints on the real pivots and correct*_left/*_rightnaming.check_rigwon't call a two-bone-limb rig animation-ready.🎬 Animation.
generate_animationwrites a complete base cycle (idle / walk / run / attack / cast / jump / hurt / death / fly) with correct gait phasing, bent joints, counter-rotation, follow-through and seamless loops.add_keyframesrefines it in bulk with interpolation control.📐 Measured animation.
analyze_animationevaluates the rig and reports how far each hand, foot and head travels in the model's own axes, whether the loop closes and whether lower limb segments move at all. This is how it catches an attack that swings into the model's back instead of at the target.🧭 Left and right stay correct. The model faces
-Z, so its own right is+X.get_orientation,which_sideandcheck_sidesanswer from coordinates.add_cube/add_grouptakeside:"left"|"right"and refuse a call whose coordinate contradicts it, and every screenshot is labelled with which image edge is the model's right.🙋 Human review gate.
request_reviewrenders labelled views, shows them in the MCP Copilot panel and blocks until you press a button, then returns your verdict and comment inside the same tool call.ask_userdoes the same for a question.🎯 Reference matching. Drop a reference image into the MCP Copilot panel.
compare_referencescores the silhouette match (IoUmatch_percentplus a[reference | model | overlay]composite and "add/trim mass here" advice), andmeasure_modelgives numeric proportions.📸 Vision and close-up inspection.
screenshot,screenshot_viewsandget_texturereturn images inline.check_modelaudits for z-fighting, floating parts, hidden (buried) cubes, stretched UVs and side mistakes;inspect_model(and the close-upsscreenshot_viewsappends) frames each problem spot, x-rays away what stands in front, outlines the cubes involved and captions the fix — then checks the face, hands, feet, joints and gear contacts, which four full-body views never show.🧠 Guidance.
get_guidereturns playbooks for modeling, characters, mechanisms, detailing, inspection, orientation, rigging, texturing, VFX, animation, review and reference matching, and the server sends its workflow (references first, palette, build, inspect) to the client on connect.🪟 In-app panel. The MCP Copilot side panel shows server status, the reference drop zone, a live log of the AI's commands, model stats, the last match score and any pending review.
🧩 Plugins. Search, install (by store id, URL or file) and uninstall Blockbench plugins, so the AI can set up formats like GeckoLib itself.
📦 Export.
export_projectuses the format's own codec.export_modelwrites through any named codec; the default is glTF, a self-contained.gltfthat imports into Godot, Unity or Blender.🔧 Escape hatch.
execute_scriptruns arbitrary Blockbench JS for anything the dedicated tools don't cover.
Requirements
Blockbench desktop app 4.8+. The web app cannot host the bridge; see Limitations.
Node.js 18+ (for global
fetch).An MCP-capable client: Claude Code, Claude Desktop, Cursor, or any other client that speaks MCP over stdio.
Installation
1. Install the bridge plugin in Blockbench
Open the desktop Blockbench app.
File ▸ Plugins ▸ Load Plugin from File and select
plugin/blockbench_mcp.js. You can also copy it into your Blockbenchpluginsfolder.On first start the plugin asks for network permission because it needs the
netmodule to host the local server. Choose "Always allow for this plugin."A toast confirms "MCP server started on port 8787."
Toggle the server any time: Tools ▸ Start / Stop MCP Server
Change the port: Settings ▸ General ▸ MCP Server Port (default
8787)
Verify it's up:
curl http://127.0.0.1:8787/ping
# {"ok":true,"protocol":1,"blockbench_version":"5.x.x","is_app":true,"has_project":false}2. Build the MCP server
git clone https://github.com/sosadly/blockbench-mcp.git
cd blockbench-mcp
npm install
npm run build3. Connect your AI client
Point your client at dist/index.js over stdio, using an absolute path.
Claude Code: add a .mcp.json to your project, or use claude mcp add:
{
"mcpServers": {
"blockbench": {
"command": "node",
"args": ["/absolute/path/to/blockbench-mcp/dist/index.js"],
"env": { "BLOCKBENCH_MCP_PORT": "8787" }
}
}
}Claude Desktop: claude_desktop_config.json. Cursor: .cursor/mcp.json. Both use the same shape:
{
"mcpServers": {
"blockbench": {
"command": "node",
"args": ["C:\\path\\to\\blockbench-mcp\\dist\\index.js"]
}
}
}Env var | Default | Purpose |
|
| Must match the plugin's port setting. |
|
| Bridge host. |
Tool reference
Group | Tools |
Status & guidance |
|
Orientation (left/right) |
|
Human review |
|
References & colour |
|
Project |
|
Geometry |
|
Procedural detail |
|
Quality gates |
|
Rigging |
|
UV & textures |
|
Animation |
|
View |
|
Plugins |
|
Escape hatch |
|
Conventions. Coordinates are Blockbench units, rotations are degrees, and texture pixel ops use a top-left origin with y pointing down. add_cube returns each face's resolved UV rect; detail_cubes then base-coats every face and paint_faces paints features (eyes, nose, claws) in coordinates relative to a face, so you never compute absolute UVs by hand.
Orientation. A model faces -Z, so its own right is +X and its left is -X. This is verified against Blockbench's bundled vanilla data: Bedrock's rightArm, stored at x = -5, is loaded by Blockbench at x = +5 (the Bedrock/Java codecs mirror X on import and export). Camera views are named from the model's point of view (front shows its face), and every capture is captioned with which image edge is the model's right, because a front view is mirrored just like facing a person.
Rotation signs. +X rotation lifts a bone's front, so a down-pointing bone (arm, leg) swings its tip forward while an up-pointing bone (torso, neck) tips backward. Elbows bend +X, knees bend -X, and +Y turns the model toward its own left. generate_animation applies these for you and analyze_animation verifies the result by measurement.
Examples
The sequence an AI follows for "make a textured GeckoLib bear that can walk, run, sleep and attack":
// 0. Read the playbook so the model comes out detailed and rotated, not boxy
get_guide {}
// 1. Install GeckoLib (adds the `geckolib_model` format)
install_plugin { "id": "geckolib" }
// 2. New project, straight from the start screen
new_project { "format": "geckolib_model", "name": "bear",
"texture_width": 64, "texture_height": 64 }
// 3. Lay out the whole posed skeleton in one call; note the rotated bones
add_groups { "groups": [
{ "name": "body", "origin": [0, 12, 0] },
{ "name": "head", "origin": [0, 14, -7], "parent": "body", "rotation": [10, 0, 0] }, // nose down
{ "name": "leg_fl", "origin": [3, 8, -5], "parent": "body", "rotation": [-6, 0, 0] },
{ "name": "leg_fr", "origin": [-3, 8, -5], "parent": "body", "rotation": [-6, 0, 0] }
// ...hind legs, ears, muzzle, tail...
] }
// 4. Build many cubes at once (segment limbs, taper with inflate, mirror left/right)
add_cubes { "cubes": [
{ "name": "torso", "from": [-5, 8, -7], "to": [5, 16, 7], "parent": "body" },
{ "name": "head", "from": [-3.5, 10, -13], "to": [3.5, 16, -7], "parent": "head" },
{ "name": "muzzle", "from": [-2, 10, -16], "to": [2, 13, -13], "parent": "head", "inflate": -0.5 }
// ...
] }
// 5. Texture: shaded base coat on EVERY face (no gaps), then features face-relative
create_texture { "name": "bear", "width": 64, "height": 64, "fill": "#6e4a2b" }
detail_cubes { "base": "#6e4a2b", "noise": 0.12, "bottom_dark": 0.3 }
paint_faces { "faces": [
{ "cube": "head", "face": "north", "ops": [
{ "type": "rect", "x": 2, "y": 2, "width": 1, "height": 1, "color": "#0f0a05" }, // eye
{ "type": "ellipse", "x": 3, "y": 4, "width": 2, "height": 2, "color": "#140e08" } // nose
] }
] }
// 6. Animate (bulk keyframes, smooth interpolation)
create_animation { "name": "animation.bear.walk", "loop": "loop", "length": 1.2 }
add_keyframes {
"animation": "animation.bear.walk",
"keyframes": [
{ "bone": "leg_fl", "channel": "rotation", "time": 0.0, "value": [28, 0, 0], "interpolation": "catmullrom" },
{ "bone": "leg_fl", "channel": "rotation", "time": 0.6, "value": [-28, 0, 0], "interpolation": "catmullrom" },
{ "bone": "leg_fl", "channel": "rotation", "time": 1.2, "value": [28, 0, 0], "interpolation": "catmullrom" }
]
}
// 7. Review from every side + audit, fix what you see, then repeat 4–7
screenshot_views { "views": ["isometric_right_front", "front", "left", "back"] }
check_model {}
// 8. Save / export
save_project { "path": "D:/models/bear.bbmodel" }
export_project { "path": "D:/models/bear.geo.json" }None of these tools knows what a hood or a scale is. They are extrusion, shells, arrays and chains.
// A hood: a shell with a real cavity, open at the face (north = -Z) and the neck (down)
add_hollow_volume {
"bounds": { "from": [-5.5, 23, -5.5], "to": [5.5, 34, 5.5] },
"wall_thickness": 1.5, "open_faces": ["north", "down"],
"name": "hood", "parent": "head"
}
// A torn hem: 11 panels hanging off the cloak, tapering, jittered, staggered in depth so
// neighbours cannot z-fight
generate_array {
"mode": "linear", "count": 11, "element_size": [2.2, 5, 1.2],
"start": [-6, 7, 3.2], "end": [6, 7, 3.2],
"anchor": "top", "jitter": [0.15, 0.4, 0], "size_decay": [0, -0.15, 0],
"depth_stagger": 0.12, "rotation_range": { "min": [-4, 0, -9], "max": [4, 0, 9] },
"seed": 12, "name_prefix": "hem", "parent": "body"
}
// A horn: 6 tapering segments, each bone bending 14° more than the last, animatable
extrude_chain {
"segments": 6, "base_origin": [3.5, 32, -1], "segment_length": 2.4,
"initial_size": [2.4, 2.4], "taper": 0.8, "curvature": [14, 0, -6],
"direction": "up", "name": "horn", "side": "right", "parent": "head"
}
// A dragon wing: arm, forearm, 4 finger bones and a continuous membrane back to the body.
// Repeat with "side": "left" and base_origin x = -3 for the other wing.
add_wing {
"side": "right", "base_origin": [3, 22, 2], "plane": "horizontal",
"fingers": 4, "arm_length": 8, "forearm_length": 10, "finger_length": 18,
"finger_spread": [0, 85], "parent": "chest"
}
// A blade: drawn as pixel art in the side plane, extruded into cubes
voxelize_matrix {
"matrix": ["......####", ".....#####", "...#######", "..######..",
".#####....", "######....", "#####.....", "####......"],
"palette": { "#": { "name": "blade", "depth": 1 } },
"plane": "yz", "origin": [0, 18, -4], "merge_adjacent": true, "parent": "hand_right"
}
// The gate: is this actually a model yet?
audit_complexity { "target": "hero" }
// -> { "verdict": "acceptable", "ready_for_texturing": true, "cubes": 152,
// "metrics": { "micro_pct": 34, "overlapping_pct": 61, "bone_depth": 6 }, "issues": [] }FAQ
What is Blockbench MCP? It is a Model Context Protocol server plus a Blockbench plugin. Together they let an AI assistant control the Blockbench 3D editor: create and edit cubes, bones, textures and animations, and see the result through screenshots.
Which AI clients work with it? Any MCP client that supports stdio servers: Claude Code, Claude Desktop, Cursor, and others.
Which model formats are supported?
Anything your Blockbench install supports: Minecraft Java Edition block/item models, Bedrock entities, GeckoLib animated models, generic models, and formats added by plugins (the AI can install those itself). list_formats shows what is available.
Can I use it to make Minecraft mobs and mod assets?
Yes. The examples above are Minecraft-style mobs, and the GeckoLib workflow produces model, texture and animation files ready for a Forge / Fabric / NeoForge mod. export_model also writes glTF for Godot, Unity and Blender.
Does it work with the Blockbench web app?
No. The bridge needs Node's net module, which only the desktop app exposes to plugins.
Troubleshooting
Blockbench shows "server stopped" and Start does nothing.
The plugin needs the net module. When you click Start MCP Server, Blockbench shows a permission dialog; choose "Always allow for this plugin." If you denied it before, revoke and retry from the plugin's context menu, or restart Blockbench.
MCP tools fail with "Cannot reach Blockbench on 127.0.0.1:8787".
Make sure Blockbench is open, the plugin is loaded and the server is running (green toast, or curl .../ping works). Confirm the port in the plugin settings matches BLOCKBENCH_MCP_PORT.
"Unknown format … the matching plugin must be installed."
Plugin formats like GeckoLib's geckolib_model require install_plugin { "id": "geckolib" } first. Run list_formats to confirm the id appeared.
Console 404s about about.md / the plugin store.
Harmless. Blockbench tries to fetch store metadata for the side-loaded plugin and gets a 404. It does not affect the bridge.
Security
The bridge binds to
127.0.0.1only, so it is not reachable from your network.Binding to localhost does not stop web pages in your browser from sending requests to it, so the bridge also refuses:
any request with an
Originheader (browsers always send one on cross-origin requests; the MCP server does not);any
Hostother than127.0.0.1/localhost/[::1](blocks DNS rebinding);POSTbodies withoutContent-Type: application/json.
It sends no CORS headers, so a page cannot read its responses either.
Trust boundary: the MCP client. Anything that controls the connected client, including a model steered by prompt injection from a file, web page or image it reads, can drive every tool.
Web access is limited to images.
find_references/load_reference {url}run in the MCP server (not in Blockbench), force safe search, only fetch publichttp(s)addresses (localhost, LAN and link-local addresses are refused, including hostnames that resolve to them and every redirect hop), cap downloads at 15 MB and accept a file only if its bytes are a real PNG/JPEG/GIF/WebP/AVIF/BMP image.execute_scriptruns unsandboxed JavaScript with Blockbench's full privileges. Only connect MCP clients you trust, and prefer the dedicated tools where possible. If you don't need it, turn off Settings ▸ General ▸ Allow execute_script. The command is then rejected inside Blockbench and every other tool keeps working.
Limitations
Desktop only. The bridge relies on Node modules (
net), which the Blockbench web app does not expose to plugins.One Blockbench window. The bridge talks to whichever project is currently active.
Formats with box UV only (e.g. Java entity / OptiFine) cannot give thin cubes their own pixels;
pack_uvwarns about them. Java block models only rotate one axis in 22.5° steps, so use 8 or 16 sides for round parts there.find_referencesscrapes public image search pages; if an engine changes its markup it falls back to the next one.
Development
npm run dev # tsc --watch
npm run build # one-off compile to dist/
npm test # build, then run the tool-catalogue tests against dist/MCP tool definitions live in
src/tools.ts, the HTTP client insrc/client.ts, the server entry insrc/index.ts, and tests intest/tools.test.js(Node's built-in runner, no extra dependencies).Bridge command handlers live in
plugin/blockbench_mcp.jsunder thecommandsobject. Add a handler there and a matching tool intools.tsto extend the surface.The Blockbench API used by the bridge is documented in the official type definitions.
Issues and pull requests are welcome.
If Blockbench MCP saved you some modeling time, a ⭐ helps other people find it.
MIT © sosadly · Built on the Model Context Protocol · Not affiliated with Blockbench or GeckoLib.
Available Tools
46 toolsadd_cubeA
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).
Inputs: to (required), from (required), name, faces, +7 more.
add_cubesA
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.
Inputs: cubes (required).
add_groupA
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.
Inputs: name, origin, parent, rotation.
add_groupsA
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.
Inputs: groups (required).
add_keyframeA
Add a single keyframe to an animation for a given bone and channel.
Inputs: bone (required), time (required), value (required), animation (required), +2 more.
add_keyframesB
Add many keyframes at once — the efficient way to author a full animation. Pass an array of {bone, channel, time, value, interpolation}.
Inputs: animation (required), keyframes (required).
add_meshA
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.
Inputs: uv, from, name, size, +6 more.
add_planeA
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.
Inputs: from (required), name, width, facing, +6 more.
apply_textureA
Apply a texture to all faces of an element (or all cubes if element omitted).
Inputs: texture (required), element.
check_modelA
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.
Inputs: no named parameters.
close_projectB
Close the currently open project.
Inputs: no named parameters.
create_animationA
Create an animation (requires a format that supports animation, e.g. GeckoLib animated_entity or Bedrock entity). Returns the animation uuid.
Inputs: loop, name, length.
create_textureB
Create a new texture. Either fill it with a solid color, or supply a full PNG via data_url. Returns the texture uuid.
Inputs: fill, name, width, height, +2 more.
create_vfx_textureA
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'.
Inputs: name, seed, style, width, +10 more.
delete_elementA
Delete a cube or group (and its children) from the model.
Inputs: element (required).
detail_cubesA
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).
Inputs: base, blur, cubes, noise, +7 more.
edit_elementB
Edit an existing cube or group (rename, move, rotate, reparent, resize, inflate, visibility).
Inputs: element (required), to, from, origin, +5 more.
execute_scriptA
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.
Inputs: code (required), params.
export_projectC
Export the project through its format's codec (e.g. Java model JSON, Bedrock geometry, GeckoLib model). Provide path to write a file directly.
Inputs: path.
get_elementA
Get detailed info for one cube or group by uuid or name.
Inputs: element (required).
get_guideA
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.
Inputs: topic.
get_statusA
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.
Inputs: no named parameters.
get_textureA
Read a texture back as an image so you can inspect what it currently looks like. Returns the PNG inline.
Inputs: texture (required).
import_textureB
Import a texture from an image file on disk (desktop only).
Inputs: path (required), name.
install_pluginA
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'.
Inputs: id, url, path.
list_animationsA
List all animations and their animated bones.
Inputs: no named parameters.
list_formatsA
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.
Inputs: no named parameters.
list_outlinerA
Return the full outliner tree (groups/bones and their nested cubes) with uuids, origins and rotations.
Inputs: no named parameters.
list_pluginsA
List Blockbench plugins (installed and available in the store). Filter with query or installed_only.
Inputs: query, installed_only.
list_texturesA
List all textures in the project.
Inputs: no named parameters.
load_projectA
Load a .bbmodel project file from disk (desktop only).
Inputs: path (required).
mirror_elementA
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.
Inputs: axis, pivot, element, elements.
new_projectA
Create a new project from the start screen, choosing a format. This is the entry point for any new model.
Inputs: format (required), name, geometry_name, texture_width, +1 more.
pack_uvA
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.
Inputs: cubes, padding, auto_resize.
paint_facesA
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.
Inputs: ops, base, cube, face, +2 more.
paint_textureA
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).
Inputs: ops (required), texture (required), edit_name.
remove_animationC
Delete an animation from the project.
Inputs: animation (required).
resize_textureC
Resize a texture's bitmap to new dimensions (nearest-neighbour).
Inputs: width (required), height (required), texture (required).
save_projectA
Save the open project as a .bbmodel. Provide path to save to a specific file (desktop), otherwise Blockbench's save flow is used.
Inputs: path.
screenshotA
Capture the current 3D preview and return it as an image so you can visually inspect the model and iterate. Optionally specify width/height.
Inputs: width, height.
screenshot_viewsB
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.
Inputs: views, width, height.
set_camera_angleA
Position the preview camera, by named preset and/or explicit camera position & target.
Inputs: angle, preset, target, position.
set_cube_uvA
Set UV mapping and/or per-face texture on a cube's faces.
Inputs: cube (required), faces (required).
set_project_metaC
Update the open project's name, geometry name, or texture resolution.
Inputs: name, geometry_name, texture_width, texture_height.
set_texture_render_modeA
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.
Inputs: texture (required), animate, particle, frame_time, +4 more.
uninstall_pluginB
Uninstall an installed Blockbench plugin by id.
Inputs: id (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 46 tools
Each tool has a distinct purpose, with clear separation between single-item and batch operations (e.g., add_cube vs add_cubes). Texturing tools are well-differentiated (paint_faces vs paint_texture vs detail_cubes), and even execute_script is reserved for edge cases. No two tools appear to do the same thing.
Tool names follow a consistent verb_noun pattern using snake_case (e.g., add_cube, create_animation, list_formats). Deviations like new_project and check_model are minor and still intuitive. The naming is predictable and easy to navigate.
At 46 tools, the set is larger than typical MCP servers but justified by the complexity of 3D modeling. Each tool addresses a specific, non-trivial operation (e.g., pack_uv, detail_cubes). A few could be merged (e.g., add_cube/add_cubes) but the batch versions are genuinely needed.
The toolset covers the full modeling pipeline: project creation, element construction (cubes, groups, meshes, planes), texturing (creation, UV packing, painting, style application), animation, inspection/auditing (check_model, screenshot_views), and plugin management. There are no major gaps; even edge cases are addressed via execute_script.
Maintenance
Related MCP Connectors
Use AI models for chat, image, and video generation from Claude Code and other MCP hosts.
Generate game-ready 3D models, textures, and audio from natural language, over MCP.
Generate AI video, images and audio, and browse your history, from any MCP client.
Generate AI images and videos from any compatible MCP client.
Related MCP Servers
- AlicenseNot gradedqualityAmaintenanceEnables AI agents to create and edit 3D models in Blockbench via the Model Context Protocol.628GPL 3.0
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to control Blockbench for Minecraft 3D modeling, including project creation, cube placement, UV layout, and texture painting.GPL 3.0
- AlicenseNot gradedqualityBmaintenanceEnables AI assistants to build, texture, animate, and export Minecraft/GeckoLib cube models inside Blockbench via the Model Context Protocol.MIT
- AlicenseNot gradedqualityDmaintenanceConnects Claude AI to Blockbench through the Model Context Protocol, enabling AI-assisted 3D modeling, texture creation, and block model manipulation. It supports creating, modifying, and deleting models, applying textures and materials, and tracking commands in real time.MIT