Skip to main content
Glama
Blender Copilot MCP Server

Blender Copilot MCP Server

by dwgx

Blender Copilot

Python · MIT · ★6

docs · issues

The most comprehensive Blender MCP server — AI-powered 3D creation with 308 tools across 25 modules. Full zero-to-published VRChat avatar pipeline.

最全面的 Blender MCP 伺服器 — AI 驅動的 3D 創作,308 種工具橫跨 25 模組。完整的從零到上傳 VRChat Avatar 流水線。

License: MIT Python 3.10+ Blender 4.0+


Features / 功能特色

Core Tools (82 tools in server.py)

Category

Tools

Description

Scene Inspection

4

Get scene info, object details, analysis, viewport screenshots

Object Creation

4

Primitives, curves, 3D text, armatures

Transforms

6

Translate, rotate, scale, apply, snap to ground, set origin

Object Management

9

Duplicate, delete, select, parent, visibility, hierarchy, rename

Mesh Editing

14

Boolean, join, separate, subdivide, extrude, bevel, inset, decimate, remesh, normals, fill holes

Modifiers

5

Add/apply/remove modifiers, linear array, circular array

Materials

9

PBR materials, glass, metal, emission, texture, Principled BSDF, list, batch assign

World/Environment

4

Background color, HDRI, procedural sky, volumetric fog

Camera & Lighting

3

Camera setup, studio lighting presets, custom lights

Render & Export

3

Render to image, configure settings, export (glTF/OBJ/FBX/STL/USD/PLY)

Collections

4

Create, move objects, list, visibility

Constraints

2

Add/remove constraints (Track To, Copy Location, etc.)

Batch Operations

5

Batch transform, delete, align, distribute, center

Animation

4

Keyframes, animation range, set frame, clear animation

Physics

4

Rigid body, cloth, particles, bake physics

UV Mapping

2

Smart UV project, UV unwrap

Code Execution

1

Sandboxed Python execution inside Blender

Optimization

1

Clean orphan data, merge duplicate vertices

Asset Integration (20 tools in server.py)

Source

Tools

Description

PolyHaven

4

Search/download free HDRIs, textures, and 3D models from polyhaven.com

Sketchfab

4

Search/preview/download models from Sketchfab (API key required)

Hyper3D (Rodin)

4

AI text/image-to-3D generation via Rodin API

Hunyuan3D

4

Tencent's text/image-to-3D generation

Wrappers

4

Convenience tools for text-to-3D and image-to-3D workflows

VRC Avatar Pipeline (23 tools in vrc_tools.py)

Category

Tools

Description

Validation

2

Performance rank check (PC/Quest), export readiness

Rigging

5

Humanoid armature, bone renaming, auto-weight, weight check

Visemes & Eyes

2

15 VRC visemes from base shapes, eye tracking setup

PhysBones

3

Chain setup, physics config (hair/tail/ears/skirt), dynamics budget

Accessories

2

Auto-align imported accessories, attach to bones

Optimization

3

Smart decimate (preserves shape keys), material merge, texture atlas bake

Avatar Features

4

Expression menu, contacts (headpat/boop), gestures, animator generation

Import/Export

2

VRC-correct FBX import and export

Advanced Mesh Tools (10 tools in blender_master_tools.py)

Tool

Description

bmesh_operation

Low-level BMesh operations (dissolve, collapse, merge, knife)

topology_edge_loops

Edge loop analysis and insertion

procedural_generate

Parametric mesh generation

precision_weight_paint

Vertex-level weight painting with smoothstep interpolation

build_material_nodes

Programmatic Shader Editor node trees

smart_uv_tools

Advanced UV tools (LSCM, angle-based, pack islands)

rig_tools

IK/FK chains, stretch-to, custom shapes

retopology

Quad-based retopology from high-poly

boolean_cleanup

Post-boolean topology repair

create_facial_topology

Face topology from landmarks

Sculpt & Texture Bake (14 tools in sculpt_bake_tools.py)

Category

Tools

Description

Sculpt Mode

6

Enter sculpt, brush strokes, masking, remesh, detail flood, face set extract

Shape Keys

2

Sculpt to shape key, cloth sim to shape key

Texture Bake

4

Normal map, AO, diffuse atlas, general bake (Cycles)

Paint & Sim

2

Texture paint fill, cloth simulation for modeling

Face Tracking — ARKit 52 + Unified (10 tools in face_tracking_tools.py)

Tool

Description

ft_setup_face_vertex_groups

Auto-detect facial landmarks → 28 vertex groups

ft_create_arkit_shapes

Create all 52 ARKit blend shapes (procedural/template/from_existing)

ft_create_unified_expressions

Generate 70+ VRCFT Unified Expressions

ft_sculpt_shape_key

AI-guided shape key sculpting via vertex displacement

ft_validate_shapes

Validate against ARKit/Unified standard

ft_mirror_shape_key

Mirror Left↔Right shape keys

ft_combine_shape_keys

Combine multiple shapes with weights

ft_setup_tongue_tracking

Tongue bone chain + blend shapes

ft_setup_eye_tracking_full

Extended eye tracking (12 shapes)

ft_export_shape_key_report

Shape key report (JSON/markdown)

Rigify Integration (6 tools in rigify_tools.py)

Tool

Description

rigify_create_metarig

Generate Rigify meta-rig (human/quadruped/bird/etc.)

rigify_fit_metarig

Auto-fit meta-rig to mesh proportions (proportional/snap)

rigify_generate_rig

Generate production rig from meta-rig

rigify_to_vrc

Convert DEF-bones to VRC/Unity Humanoid naming

rigify_add_face_rig

Add face rig bones (full/basic/eyes_only)

rigify_configure_ik

Configure IK for VRC full-body tracking (3/6/10-point)

Unity Automation (15 tools in unity_tools.py)

Category

Tools

Description

Project Setup

1

Verify Unity project, VRC SDK presence

Import

1

Import FBX with humanoid rig, extract materials/textures

Avatar Config

2

Avatar Descriptor setup, pipeline manager

Expressions

2

Expression Menu and Parameters .asset generation

Animation

3

Animator controller, animation clips, gesture layer

Shaders

2

Configure Poiyomi/lilToon/UTS2, material preset generation

Dynamics

2

PhysBone components, ContactSender/Receiver

Build & Publish

2

Build validation, publish to VRChat (CLI + GUI fallback)

Script Execution (4 tools in script_tools.py)

Tool

Description

execute_script_headless

Run Python in headless Blender subprocess (bypasses TCP timeout)

execute_script_on_file

Execute code on an existing .blend file

build_scene_from_json

JSON scene description → bpy script → headless execute

generate_scene_script

Generate bpy script from JSON without executing

Render Presets (8 tools in render_tools.py)

Tool

Description

render_list_presets

List 7 presets (cycles/eevee preview/default/high, workbench)

render_apply_preset

One-click render preset application

render_set_output

Configure output path, format, quality

render_still

Render single frame

render_animation

Render animation (image sequence or FFMPEG video)

render_set_camera

Set/create active render camera

render_get_settings

Get current render config

render_set_world

Set world background (solid color or HDRI)

Scene Profiles (9 tools in scene_tools.py)

Tool

Description

scene_list_profiles

List 10 profiles (preview to 4K, Instagram, YouTube, VRC)

scene_apply_profile

Apply resolution/engine/samples profile

scene_setup_turntable

360° camera turntable animation

scene_create_collection

Create collections with color tags

scene_move_to_collection

Move objects between collections

scene_cleanup

Remove unused materials/meshes/images

scene_stats

Comprehensive scene statistics

scene_set_units

Configure unit system (metric/imperial)

scene_set_visibility

Control object viewport/render visibility

Modifier Registry (9 tools in modifier_tools.py)

Tool

Description

modifier_list_types

List 15 modifier types with validated parameters

modifier_add

Add modifier with type-safe parameter validation

modifier_apply

Apply (finalize) a modifier

modifier_remove

Remove modifier without applying

modifier_list

List all modifiers on an object

modifier_reorder

Move modifier in stack

modifier_apply_all

Apply all modifiers at once

modifier_batch_add

Add same modifier to multiple objects

modifier_preset_smooth_shade

One-click SubD + Smooth + WeightedNormal

Animation (9 tools in animation_tools.py)

Tool

Description

anim_insert_keyframe

Insert keyframe on any property

anim_insert_keyframes_batch

Insert multiple keyframes at once

anim_delete_keyframe

Delete keyframe

anim_clear_all

Clear all animation from object

anim_set_interpolation

Set interpolation type (Bezier, Linear, etc.)

anim_set_frame_range

Set frame range and FPS

anim_bounce

Bouncing animation preset

anim_orbit

Orbital/circular motion preset

anim_get_info

Get animation data summary

Materials (7 tools in material_tools.py)

Tool

Description

material_list_presets

List 12 presets (metals, glass, skin, fabric, etc.)

material_create_preset

Create material from preset

material_create_pbr

Full PBR material with all parameters

material_assign

Assign material to object

material_list

List materials on object or in scene

material_duplicate

Duplicate existing material

material_set_texture

Add image texture (albedo, normal, roughness, etc.)

UV Mapping (8 tools in uv_tools.py)

Tool

Description

uv_smart_unwrap

Smart UV Project (auto, angle-based)

uv_unwrap

Standard unwrap (follows seams)

uv_project_from_view

Cube/cylinder/sphere projection

uv_mark_seams

Mark UV seams (manual or auto by angle)

uv_pack_islands

Pack UV islands efficiently

uv_get_info

Get UV layer info

uv_add_layer

Add new UV layer

uv_remove_layer

Remove UV layer

Curves (7 tools in curve_tools.py)

Tool

Description

curve_create_bezier

Create Bezier curve with custom points

curve_create_nurbs

Create NURBS curve

curve_create_path

Create NURBS path (for follow-path)

curve_create_circle

Create circle curve (bevel profile)

curve_create_text

Create 3D text object

curve_to_mesh

Convert curve to mesh

curve_set_bevel

Set curve bevel (tube/pipe effect)

Physics (7 tools in physics_tools.py)

Tool

Description

physics_add_rigid_body

Rigid body physics (active/passive)

physics_add_cloth

Cloth simulation

physics_add_collision

Collision surface for cloth/particles

physics_add_particle_system

Particle emitter

physics_add_soft_body

Soft body physics

physics_bake

Bake all physics simulations

physics_remove

Remove physics from object

Armature & Bones (7 tools in armature_tools.py)

Tool

Description

armature_create

Create new armature

armature_add_bone

Add individual bone

armature_add_bones_chain

Add connected bone chain (spine, arm, finger)

armature_add_constraint

Add pose bone constraint (IK, Copy Rot, etc.)

armature_auto_weight

Parent mesh to armature with automatic weights

armature_list_bones

List all bones with hierarchy

armature_set_pose

Set bone rotations/positions

File I/O (6 tools in io_tools.py)

Tool

Description

io_import_file

Import any 3D file (auto-detect: FBX, OBJ, glTF, STL, USD, PLY, ABC)

io_export_fbx

Export FBX (VRChat-optimized defaults)

io_export_gltf

Export glTF/GLB (web-ready)

io_export_obj

Export OBJ (universal mesh)

io_export_stl

Export STL (3D printing)

io_export_usd

Export USD (Pixar format)

Lighting (5 tools in lighting_tools.py)

Tool

Description

light_add

Add any light type (point, sun, spot, area)

light_setup_three_point

Classic 3-point lighting rig

light_setup_studio

Professional studio softbox setup

light_list

List all lights with properties

light_modify

Modify existing light properties

Measurement & Verification (6 tools in measurement_tools.py)

Tool

Description

measure_distance

Distance between objects

measure_dimensions

Object bounding box and mesh stats

measure_overlap

Bounding box overlap detection

measure_symmetry

Mesh symmetry analysis

mesh_quality_check

Non-manifold, loose verts, degenerate faces, dupes

measure_alignment

Check multi-object axis alignment

Pipeline Orchestration (5 tools in pipeline_tools.py)

Tool

Description

pipeline_avatar_from_mesh

Full Blender-side: mesh → armature → shape keys → FBX

pipeline_blender_to_unity

Full Unity-side: FBX → import → descriptor → build

pipeline_face_tracking_setup

Complete: vertex groups → ARKit 52 → Unified → validate

pipeline_validate_full

Comprehensive go/no-go report for VRC upload

pipeline_generate_blueprint

Export all config JSONs alongside FBX

Blender Addon (112 commands, 2915 lines)

The addon (addon/__init__.py) runs inside Blender and handles all commands via TCP. Includes full UI panels for:

  • PolyHaven Browser — search and import HDRIs, textures, models

  • Sketchfab Browser — search, preview, download models

  • Hyper3D (Rodin) — text/image to 3D generation with progress tracking

  • Hunyuan3D — Tencent's 3D generation pipeline

  • Copilot Panel — connection management, port config

Related MCP server: BlenderMCP

Architecture / 架構

┌─────────────────┐    stdio/MCP     ┌──────────────────┐    TCP:9876    ┌──────────────┐
│  AI (Claude,    │ ◄──────────────► │  MCP Server      │ ◄────────────► │  Blender     │
│  Cursor, etc.)  │                  │  (server.py)     │                │  Addon       │
└─────────────────┘                  └──────────────────┘                └──────────────┘
                                     │
                                     ├── vrc_tools.py (23 VRC tools)
                                     ├── blender_master_tools.py (10 advanced tools)
                                     ├── sculpt_bake_tools.py (14 sculpt/bake tools)
                                     ├── face_tracking_tools.py (10 ARKit/Unified tools)
                                     ├── rigify_tools.py (6 Rigify tools)
                                     ├── unity_tools.py (15 Unity automation tools)
                                     └── pipeline_tools.py (5 orchestration tools)
  • MCP Server (server.py): FastMCP server exposing 185 tools via stdio transport

  • VRC Tools (vrc_tools.py): VRChat avatar pipeline — validation, rigging, visemes, PhysBones, export

  • Master Tools (blender_master_tools.py): Advanced mesh — BMesh, retopology, procedural generation

  • Sculpt & Bake (sculpt_bake_tools.py): Sculpt mode, brush strokes, texture baking (normal/AO/diffuse)

  • Face Tracking (face_tracking_tools.py): ARKit 52 blend shapes, VRCFT Unified Expressions, tongue/eye tracking

  • Rigify (rigify_tools.py): Meta-rig generation, fitting, VRC bone conversion, IK configuration

  • Unity (unity_tools.py): C# EditorScript generation, Unity CLI automation, avatar descriptor, animator, shaders

  • Pipeline (pipeline_tools.py): End-to-end orchestration — mesh-to-FBX, FBX-to-Unity, face tracking setup

  • Blender Addon (addon/__init__.py): TCP socket server + CommandExecutor with cmd_ dispatch pattern

Installation / 安裝

1. Install the MCP Server / 安裝 MCP 伺服器

# Using uv (recommended / 推薦)
uv pip install -e .

# Or using pip
pip install -e .

2. Install the Blender Addon / 安裝 Blender 外掛

Option A: Copy directly / 直接複製

Copy addon/__init__.py to your Blender addons directory:

# Windows
%APPDATA%\Blender Foundation\Blender\<version>\scripts\addons\blender_copilot.py

# macOS
~/Library/Application Support/Blender/<version>/scripts/addons/blender_copilot.py

# Linux
~/.config/blender/<version>/scripts/addons/blender_copilot.py

Option B: Blender Extension (4.2+) / Blender 擴展

Copy the entire addon/ folder to your extensions directory:

# Windows
%APPDATA%\Blender Foundation\Blender\<version>\extensions\user\blender_copilot\

3. Enable the Addon / 啟用外掛

  1. Open Blender → Edit → Preferences → Add-ons

  2. Search for "Blender Copilot"

  3. Enable it

  4. In the 3D Viewport sidebar (N key) → Copilot tab → Click "Connect to AI"

4. Configure Your AI Client / 配置 AI 客戶端

Add to your .mcp.json or MCP config:

{
  "mcpServers": {
    "blender-copilot": {
      "command": "uv",
      "args": ["--directory", "/path/to/blender-copilot", "run", "blender-copilot"]
    }
  }
}

Or if installed globally:

{
  "mcpServers": {
    "blender-copilot": {
      "command": "blender-copilot"
    }
  }
}

Auto-Start (Optional) / 自動啟動(可選)

Create a startup script to automatically start the Copilot server when Blender launches:

Save as mcp_autostart.py in Blender's startup folder:

# Windows: %APPDATA%\Blender Foundation\Blender\<version>\scripts\startup\
# macOS: ~/Library/Application Support/Blender/<version>/scripts/startup/
# Linux: ~/.config/blender/<version>/scripts/startup/
import bpy

def _auto_start():
    try:
        bpy.context.scene.copilot_port = 9876
        bpy.ops.copilot.start()
        print("[Copilot] Auto-started")
    except:
        pass
    return None

def register():
    bpy.app.timers.register(_auto_start, first_interval=3.0)

def unregister():
    pass

Environment Variables / 環境變數

Variable

Default

Description

BLENDER_HOST

localhost

Blender addon TCP host

BLENDER_PORT

9876

Blender addon TCP port

Compatibility / 相容性

  • Blender: 4.0+ (tested on 4.2, 5.0, 5.1)

  • Python: 3.10+

  • OS: Windows, macOS, Linux

  • AI Clients: Claude Code, Claude Desktop, Cursor, Windsurf, Cline, or any MCP-compatible client

Documentation / 文檔

  • docs/MODELER_KNOWLEDGE_BASE.md — VRChat avatar pipeline reference (performance ranks, export settings, weight painting rules)

  • docs/MAYO_VRC_MANUAL.md — Complete operation manual for the Mayo avatar project

License / 授權

MIT License - see LICENSE

Credits / 致謝

Original work by DWGX. Not a fork.

Inspired by the Blender MCP ecosystem, with features consolidated and expanded from research across 17+ community projects.

本項目為原創作品,非 fork。靈感來自 Blender MCP 生態系統,整合並擴展了 17+ 個社群項目的功能。

Available Tools

307 tools
add_clothC

Add cloth simulation to a mesh object. Quality controls simulation accuracy (1-10). Mass in kg.

Inputs: name (required), mass, quality.

add_constraintC

Add a constraint to an object. Common types: TRACK_TO (aim at target), COPY_LOCATION, COPY_ROTATION, COPY_SCALE, LIMIT_LOCATION, LIMIT_ROTATION, FOLLOW_PATH, CLAMP_TO, DAMPED_TRACK, LOCKED_TRACK. Properties dict sets constraint attributes.

Inputs: name (required), constraint_type (required), properties, target_name.

add_lightB

Add a light to the scene. Types: POINT, SUN, SPOT, AREA. Energy in watts. Color is [R,G,B]. Size controls shadow softness (AREA/POINT). Rotation in degrees (for SPOT/AREA directional lights).

Inputs: name, size, type, color, +3 more.

add_modifierC

Add a modifier to an object. Common types: SUBSURF, MIRROR, ARRAY, SOLIDIFY, BEVEL, BOOLEAN, SHRINKWRAP, REMESH, DECIMATE, SMOOTH, CAST, WAVE, DISPLACE, LATTICE. Properties dict sets modifier attributes, e.g. {"levels": 2} for SUBSURF.

Inputs: name (required), modifier_type (required), properties, modifier_name.

add_particlesA

Add a particle system to an object. Types: EMITTER (emit over time), HAIR (static strands). Count = number of particles. Lifetime in frames. Velocity = emission speed.

Inputs: name (required), size, type, count, +2 more.

add_rigid_bodyB

Add rigid body physics to an object. Types: ACTIVE (affected by gravity), PASSIVE (static collider). collision_shape: BOX, SPHERE, CAPSULE, CYLINDER, CONE, CONVEX_HULL (default, fits shape), MESH (exact, slow).

Inputs: name (required), mass, type, friction, +2 more.

align_objectsB

Align multiple objects along an axis. Axis: X, Y, or Z. Align_to: CENTER (average), MIN (lowest), MAX (highest), CURSOR (3D cursor).

Inputs: names (required), axis, align_to.

analyze_sceneA

Analyze the entire scene for statistics and potential issues. Returns total vertex/face/triangle counts, object type breakdown, material count, top objects by triangle count, and issues like non-uniform scale, missing materials, n-gons.

Inputs: no named parameters.

anim_bounceB

Create a bouncing animation preset.

Object bounces up and down with decreasing amplitude.

Args: object_name: Target object height: Initial bounce height frames: Total animation duration in frames bounces: Number of bounces

Inputs: object_name (required), frames, height, bounces.

anim_clear_allC

Remove all animation data from an object.

Inputs: object_name (required).

anim_delete_keyframeB

Delete a keyframe from an object property.

Args: object_name: Target object name data_path: Property path frame: Frame number to delete index: Channel index (-1 = all)

Inputs: frame (required), data_path (required), object_name (required), index.

anim_get_infoA

Get animation info — keyframe counts, frame range, actions.

Args: object_name: Specific object (empty = scene-wide summary)

Inputs: object_name.

anim_insert_keyframeB

Insert a keyframe on an object property.

Args: object_name: Target object name data_path: Property path (location, rotation_euler, scale, etc.) frame: Frame number value: Optional value to set before keying index: Channel index (-1 = all channels, 0=X, 1=Y, 2=Z)

Inputs: frame (required), data_path (required), object_name (required), index, +1 more.

anim_insert_keyframes_batchA

Insert multiple keyframes at once.

Args: object_name: Target object name keyframes: List of dicts, each with: - frame (int): Frame number - data_path (str): Property path - value: Value to set (single float or [x,y,z] list) - index (int, optional): Channel index (-1 for all)

Example keyframes: [ {"frame": 1, "data_path": "location", "value": [0, 0, 0]}, {"frame": 30, "data_path": "location", "value": [5, 0, 2]}, {"frame": 60, "data_path": "location", "value": [0, 0, 0]} ]

Inputs: keyframes (required), object_name (required).

anim_orbitA

Create an orbital/circular motion animation.

Args: object_name: Object to animate center: Center point [x, y, z] (default [0,0,0]) radius: Orbit radius frames: Frames for one complete orbit axis: Rotation axis (X, Y, or Z)

Inputs: object_name (required), axis, center, frames, +1 more.

anim_set_frame_rangeC

Set the scene frame range and optionally FPS.

Args: start: Start frame end: End frame fps: Frames per second (0 = don't change)

Inputs: end, fps, start.

anim_set_interpolationB

Set interpolation type for all keyframes on an object.

Args: object_name: Target object interpolation: CONSTANT, LINEAR, BEZIER, SINE, QUAD, CUBIC, etc. easing: EASE_IN, EASE_OUT, EASE_IN_OUT (for non-linear types)

Inputs: object_name (required), easing, interpolation.

apply_modifierC

Apply a modifier to permanently bake its effect into the mesh geometry.

Inputs: name (required), modifier_name (required).

apply_transformA

Apply (freeze) the object's transforms, resetting them to identity. Essential before export or after non-uniform scaling.

Inputs: name (required), scale, location, rotation.

armature_add_boneA

Add a bone to an existing armature.

Args: armature_name: Target armature object bone_name: Name for the new bone head: Bone head position [x, y, z] tail: Bone tail position [x, y, z] parent_bone: Name of parent bone (empty = no parent) connected: Connect to parent bone's tail

Inputs: bone_name (required), armature_name (required), head, tail, +2 more.

armature_add_bones_chainA

Add a chain of connected bones (e.g., spine, arm, finger).

Args: armature_name: Target armature chain_name: Base name for bones (appends .001, .002, etc.) joints: List of [x, y, z] positions for each joint (head of each bone) Needs at least 2 points to form 1 bone. parent_bone: Parent bone for the first bone in chain

Inputs: chain_name (required), armature_name (required), joints, parent_bone.

armature_add_constraintB

Add a constraint to a pose bone.

Args: armature_name: Armature containing the bone bone_name: Bone to constrain constraint_type: COPY_LOCATION, COPY_ROTATION, COPY_SCALE, TRACK_TO, DAMPED_TRACK, IK, LIMIT_ROTATION, STRETCH_TO, FLOOR, CHILD_OF target_armature: Target armature object (for bone targets) target_bone: Target bone name params: Additional constraint parameters dict

Inputs: bone_name (required), armature_name (required), constraint_type (required), params, +2 more.

armature_auto_weightA

Parent mesh to armature with automatic weights.

This is the standard way to skin a mesh to a skeleton.

Args: armature_name: Armature to parent to mesh_name: Mesh to skin

Inputs: mesh_name (required), armature_name (required).

armature_createB

Create a new armature object with a single root bone.

Args: name: Armature object name location: Object location [x, y, z]

Inputs: name, location.

armature_list_bonesB

List all bones in an armature with hierarchy info.

Inputs: armature_name (required).

armature_set_poseA

Set bone poses (rotation/location) on an armature.

Args: armature_name: Target armature bone_poses: List of pose dicts: [{"bone": "Upper Arm.L", "rotation": [45, 0, 0], "location": [0, 0, 0]}] Rotation in degrees (Euler XYZ).

Inputs: armature_name (required), bone_poses.

bake_aoA

Bake ambient occlusion map for a mesh. Simplified single-map bake.

Args: mesh_name: Name of the mesh object. resolution: Texture resolution. samples: Render samples (higher = cleaner). output_path: Custom output path. Auto-generates if empty.

Inputs: mesh_name (required), samples, resolution, output_path.

bake_diffuse_to_atlasB

Bake multiple meshes' diffuse colors to a single texture atlas.

Combines all materials into one atlas, repacking UVs.

Args: mesh_names: JSON array of mesh names to combine. atlas_size: Atlas texture resolution. output_path: Custom output path.

Inputs: atlas_size, mesh_names, output_path.

bake_normal_mapA

Bake a normal map from high-poly to low-poly mesh.

Args: high_poly: Name of the high-poly source mesh. low_poly: Name of the low-poly target mesh. resolution: Texture resolution (2048 recommended for body, 1024 for accessories). cage_extrusion: Ray distance for projection (increase if bake has gaps). samples: Render samples. output_path: Custom output path. Auto-generates if empty.

Inputs: low_poly (required), high_poly (required), samples, resolution, +2 more.

bake_physicsC

Bake all physics simulations in the scene to cache. Must be baked before rendering physics simulations.

Inputs: end, start.

bake_texturesB

Bake texture maps from a mesh (or high-poly to low-poly).

Args: mesh_name: Target mesh (low-poly for high→low bake, or single mesh). bake_types: JSON array of bake types — "NORMAL", "AO", "DIFFUSE", "ROUGHNESS", "EMIT", "COMBINED", "SHADOW". resolution: Texture resolution (512, 1024, 2048, 4096). output_dir: Output directory for baked textures (Blender path format). samples: Render samples for baking. margin: Pixel margin around UV islands. high_poly: Optional high-poly mesh name for high→low baking.

Inputs: mesh_name (required), margin, samples, high_poly, +3 more.

batch_assign_materialA

Assign the same material to multiple objects at once. Provide either a color [R,G,B] to create a new material, or material_name to use existing.

Inputs: names (required), color, material_name.

batch_deleteC

Delete multiple objects at once by their names.

Inputs: names (required).

batch_transformA

Apply the same transform to multiple objects at once. Translate is [x,y,z], rotate is [x,y,z] in degrees, scale is [x,y,z]. If relative=True, transforms are additive/multiplicative.

Inputs: names (required), scale, rotate, relative, +1 more.

bevel_edgesB

Bevel all edges of a mesh. Width controls bevel size, segments controls smoothness.

Inputs: name (required), width, segments.

blender_launchA

Launch Blender with Copilot addon auto-started. No manual UI clicks needed.

file_path: Optional .blend file to open on launch. port: TCP port for the addon server (default 9876). blender_path: Override Blender executable path (auto-detected if empty).

The addon is automatically installed (if needed), enabled, and the TCP server is started. Connection is verified before returning.

Inputs: port, file_path, blender_path. Returns: result

blender_new_fileA

Create a new blank Blender file (General template). Discards unsaved changes.

Inputs: no named parameters.

blender_open_fileA

Open a .blend file in the running Blender instance. Replaces the current scene — save first if needed.

Inputs: file_path (required).

blender_quitA

Quit Blender gracefully. Set save=True to save before quitting.

Inputs: save. Returns: result

blender_saveA

Save the current Blender file. If file_path is given, does Save As. If empty and file was never saved, returns an error.

Inputs: file_path.

blender_statusC

Check Blender connection status, executable path, and scene summary.

Inputs: port. Returns: result

bmesh_operationA

Execute precision BMesh operations on a mesh. BMesh provides direct vertex/edge/face manipulation without operator overhead.

Parameters:

  • mesh_name: Target mesh object name

  • operation: One of: "dissolve_degenerate" — remove zero-area faces & zero-length edges "remove_doubles" — merge vertices by distance (params: {"distance": 0.0001}) "triangulate" — convert all faces to triangles "quads_to_tris" — same as triangulate "tris_to_quads" — convert triangles back to quads where possible "recalc_normals" — recalculate normals (outside) "fill_holes" — fill all holes in mesh (params: {"sides": 4}) "subdivide" — subdivide all faces (params: {"cuts": 1, "smooth": 0}) "smooth_vertices" — smooth vertex positions (params: {"factor": 0.5, "repeat": 1}) "symmetrize" — mirror mesh across axis (params: {"direction": "NEGATIVE_X"}) "convex_hull" — create convex hull from vertices "inset_faces" — inset selected faces (params: {"thickness": 0.02}) "extrude_faces" — extrude faces along normals (params: {"distance": 0.1}) "solidify" — add thickness to mesh (params: {"thickness": 0.01}) "wireframe" — convert to wireframe (params: {"thickness": 0.02}) "custom" — run custom BMesh code (params: {"code": "..."})

  • params: JSON parameters for the operation

Inputs: mesh_name (required), operation (required), params. Returns: result

boolean_cleanupA

Expert boolean operation with automatic cleanup pipeline. Uses EXACT solver + dissolve degenerate + remove doubles + tris to quads.

Parameters:

  • mesh_name: Target mesh

  • cutter_name: Cutter object. If empty, just runs cleanup on existing mesh.

  • operation: "DIFFERENCE", "UNION", "INTERSECT" (default: "DIFFERENCE")

  • auto_cleanup: Run full cleanup pipeline after boolean (default: True)

Inputs: mesh_name (required), operation, cutter_name, auto_cleanup. Returns: result

boolean_operationB

Perform a boolean operation between two mesh objects. Operations: DIFFERENCE (subtract), UNION (add), INTERSECT (overlap only). If apply=True, the modifier is applied and the cutter is removed.

Inputs: cutter (required), target (required), apply, operation.

bridge_edge_loopsA

Bridge two selected edge loops to create connecting faces. The object must have exactly two edge loops selected in edit mode.

Inputs: name (required).

build_material_nodesA

Build complex shader node trees programmatically. Creates materials with proper node connections — far beyond simple color assignment.

Parameters:

  • material_name: Name for the new material

  • preset: Material preset: "pbr" — full PBR setup (provide textures) "toon" — toon/cel shader (VRChat-style) "glass" — realistic glass "hologram" — holographic effect "emission_pulse" — pulsing glow "matcap" — matcap material "skin" — subsurface skin shader "fabric" — cloth/fabric shader

  • textures: JSON map of texture paths: {"albedo": "path.png", "normal": "path.png", "metallic": "path.png", "roughness": "path.png", "ao": "path.png", "emission": "path.png"}

  • custom_nodes: JSON array of custom node definitions (advanced)

Inputs: material_name (required), preset, textures, custom_nodes. Returns: result

build_scene_from_jsonA

Build a complete Blender scene from a JSON description.

Generates a bpy script from the JSON and executes it in headless Blender. Adapted from CLI-Anything's scene building approach.

The JSON format supports:

  • materials: [{name, color, metallic, roughness}]

  • objects: [{mesh_type, name, location, rotation, scale, material, modifiers, collection, smooth}]

  • cameras: [{name, location, rotation, focal_length, active}]

  • lights: [{name, type, location, rotation, power, color, size}]

  • render: {engine, resolution_x, resolution_y, samples}

Example: { "materials": [{"name": "Red", "color": [1,0,0,1]}], "objects": [ {"mesh_type": "sphere", "name": "Ball", "location": [0,0,1], "material": "Red", "smooth": true, "modifiers": [{"type": "subdivision_surface", "params": {"levels": 2}}]} ], "cameras": [{"name": "Cam", "location": [0,-5,2], "rotation": [80,0,0], "focal_length": 85, "active": true}], "lights": [{"name": "Key", "type": "AREA", "location": [2,-2,3], "power": 200}] }

Inputs: scene_json (required), blend_output, render_output.

center_objectsA

Move objects so their collective center is at the world origin. If no names given, centers all objects in the scene.

Inputs: names.

clear_animationC

Remove all animation data from an object.

Inputs: name (required).

clear_parentA

Remove parent from an object. If keep_transform=True, object stays in place.

Inputs: name (required), keep_transform.

cloth_sim_modelB

Run cloth simulation for modeling purposes (e.g., draping fabric).

Simulates cloth physics and applies the result to the mesh. Useful for creating natural fabric drapes, cape rest poses, or skirt shapes.

Args: mesh_name: Name of the mesh to simulate. pin_vertex_group: Vertex group for pinned vertices (e.g., waist for skirt). frames: Number of frames to simulate. quality: Simulation quality steps per frame. gravity: Gravity strength (negative = downward). stiffness: Cloth structural stiffness. damping: Cloth damping.

Inputs: mesh_name (required), frames, damping, gravity, +3 more.

cloth_to_shape_keyA

Run cloth simulation and save result as a shape key.

Useful for creating natural rest poses for skirts, capes, and other clothing that should hang naturally from a pin point.

Args: mesh_name: Name of the mesh object. shape_key_name: Name for the resulting shape key. pin_vertex_group: Vertex group for pinned vertices. frames: Simulation frames. stiffness: Cloth stiffness.

Inputs: mesh_name (required), frames, stiffness, shape_key_name, +1 more.

configure_renderA

Configure render settings without rendering. Engine: CYCLES, BLENDER_EEVEE_NEXT. Resolution is [width, height]. denoise=True enables AI denoising in Cycles. transparent_bg=True for transparent background. color_management can set view_transform, look, exposure, gamma.

Inputs: engine, denoise, samples, use_gpu, +3 more.

create_armatureA

Create an armature (skeleton) with bones for rigging. Each bone dict: {"name": "BoneName", "head": [x,y,z], "tail": [x,y,z], "parent": "ParentBone"}. Parent is optional. Bones are created in edit mode then switched back to object mode.

Inputs: name, bones.

create_arrayB

Create a linear array of an object. Count = number of copies. Offset is [x, y, z]. If use_relative=True, offset is relative to object size. Example: offset=[1,0,0] with relative = one object-width apart on X.

Inputs: name (required), count, offset, use_relative.

create_circular_arrayB

Create a circular array using an empty as rotation pivot. Count = number of copies around the circle. Axis: X, Y, or Z. Radius offsets the object from the pivot center.

Inputs: name (required), axis, count, radius.

create_collectionB

Create a new collection (like a folder for organizing objects). Optionally nest it under a parent collection.

Inputs: name (required), parent.

create_curveB

Create a curve from a list of control points. Each point is [x, y, z] (or [x, y, z, w] for NURBS). Types: BEZIER, NURBS, POLY. Set bevel_depth > 0 for tubular curves. Set close=True for closed loops. Fill modes: FULL, BACK, FRONT, NONE.

Inputs: points (required), fill, name, type, +4 more.

create_emissionB

Apply an emissive (glowing) material to an object. Color is [R,G,B,A]. Strength controls brightness (10+ for visible glow in Cycles).

Inputs: name (required), color, strength.

create_facial_topologyA

Create clean facial topology with concentric edge loops. Proper topology is critical for blend shape deformation.

Parameters:

  • feature: "eye" — eye socket topology with concentric loops "mouth" — mouth topology with radial loops "face_base" — complete face base mesh with eyes + mouth + nose

  • location: JSON [x, y, z] center position

  • params: JSON extra: eye: {"radius_inner": 0.012, "radius_outer": 0.04, "segments": 12, "rings": 4} mouth: {"width": 0.04, "height": 0.015, "segments": 16, "rings": 3}

Inputs: params, feature, location. Returns: result

create_glassC

Apply a glass/transparent material to an object. IOR: 1.0=air, 1.33=water, 1.45=glass, 1.52=window glass, 2.42=diamond.

Inputs: name (required), ior, color, roughness.

create_metalB

Apply a metallic material to an object. Default is silver-ish. Color examples: gold=[1.0,0.76,0.33], copper=[0.72,0.45,0.2], steel=[0.8,0.8,0.8].

Inputs: name (required), color, roughness.

create_objectA

Create a 3D primitive object in the scene. Types: CUBE, SPHERE, UV_SPHERE, ICO_SPHERE, CYLINDER, CONE, TORUS, PLANE, CIRCLE, GRID, MONKEY, EMPTY, CAMERA, LIGHT, POINT_LIGHT, SUN_LIGHT, SPOT_LIGHT, AREA_LIGHT. Location is [x, y, z]. Rotation is in degrees [x, y, z]. Scale is [x, y, z].

Inputs: name, type, scale, location, +1 more.

create_textB

Create a 3D text object. Set extrude > 0 for 3D text depth. Set bevel_depth > 0 for beveled edges. Rotation in degrees. Alignment options: LEFT, CENTER, RIGHT for X; TOP, CENTER, BOTTOM for Y.

Inputs: text (required), name, size, align_x, +6 more.

curve_create_bezierA

Create a Bezier curve with custom control points.

Args: name: Object name points: List of control point dicts: [{"co": [x,y,z], "handle_left": [x,y,z], "handle_right": [x,y,z], "type": "AUTO"}] If empty, creates a default S-curve. location: Object location [x, y, z] fill_mode: FULL, BACK, FRONT, HALF, NONE bevel_depth: Bevel depth for tube-like appearance bevel_resolution: Bevel smoothness resolution_u: Curve resolution extrude: Extrude amount for flat ribbon

Inputs: name, points, extrude, location, +4 more.

curve_create_circleA

Create a circle curve (useful as bevel object for tubes/pipes).

Args: name: Circle name radius: Circle radius location: Object location fill: Fill the circle to create a disk

Inputs: fill, name, radius, location.

curve_create_nurbsA

Create a NURBS curve.

Args: name: Object name points: List of [x, y, z, w] points (w = weight, default 1.0) location: Object location order_u: NURBS order (2-6) bevel_depth: Tube bevel depth use_cyclic: Close the curve into a loop

Inputs: name, points, order_u, location, +2 more.

curve_create_pathA

Create a NURBS path (useful for follow-path animations and hair guides).

Args: name: Path name length: Path length points: Number of control points location: Object location

Inputs: name, length, points, location.

curve_create_textB

Create 3D text object.

Args: text: Text content name: Object name font_size: Size of the text extrude: Extrusion depth for 3D effect bevel_depth: Edge bevel for rounded letters location: Object location align: LEFT, CENTER, RIGHT, JUSTIFY, FLUSH

Inputs: name, text, align, extrude, +3 more.

curve_set_bevelA

Set bevel properties on a curve (creates tube/pipe effect).

Args: object_name: Target curve object bevel_depth: Bevel radius (0 = wireframe, >0 = tube) bevel_resolution: Smoothness of bevel profile bevel_object: Name of curve to use as custom bevel profile

Inputs: object_name (required), bevel_depth, bevel_object, bevel_resolution.

curve_to_meshB

Convert a curve to mesh geometry.

Args: object_name: Curve object to convert keep_original: Keep the original curve object

Inputs: object_name (required), keep_original.

decimateB

Reduce mesh polygon count. Ratio 0.5 = reduce to 50% of original faces. Lower ratio = more reduction. Applies modifier immediately.

Inputs: name (required), ratio.

delete_objectB

Delete an object from the scene by name.

Inputs: name (required).

distribute_objectsA

Evenly distribute objects along an axis. If spacing is given, uses fixed spacing. If spacing is None, distributes evenly between first and last object.

Inputs: names (required), axis, spacing.

download_polyhaven_assetB

Download and import a PolyHaven asset into Blender. asset_type: hdris, textures, models. resolution: 1k, 2k, 4k. file_format: hdr/exr for HDRIs, jpg/png for textures, gltf/fbx for models.

Inputs: asset_id (required), asset_type (required), resolution, file_format.

download_sketchfab_modelC

Download and import a Sketchfab model. Scales to target_size (largest dimension in meters). Examples: chair=1.0, table=0.75, car=4.5, person=1.7, small object=0.1-0.3.

Inputs: uid (required), target_size (required).

duplicate_objectA

Duplicate an object. If linked=True, shares mesh data (instance). If linked=False (default), creates an independent copy.

Inputs: name (required), linked, new_name.

execute_codeA

Execute arbitrary Python code inside Blender. Has access to bpy, mathutils, math, os. Blocked imports: subprocess, shutil, socket, ctypes, multiprocessing, webbrowser. Store results in a variable named 'result' to return them. Use this for advanced operations not covered by other tools.

Inputs: code (required).

execute_script_headlessA

Execute Python code directly in Blender headless mode (no TCP).

Use this for heavy operations that timeout over the socket connection:

  • Complex bmesh mesh creation (many vertices/faces)

  • Batch operations on many objects

  • File import/export operations

  • Any operation that takes > 2 minutes

The code runs in a fresh Blender instance via subprocess. Variable 'result' will be captured as the return value.

Inputs: code (required), timeout.

execute_script_on_fileB

Execute Python code on an existing .blend file in headless mode.

Opens the file, runs the code, optionally saves. Great for batch modifications to existing files.

Inputs: code (required), blend_file (required), save, timeout.

export_sceneC

Export the scene or selected objects to a file. Formats: glTF/GLB (web/game), OBJ, FBX (game engines), STL (3D printing), USD/USDC/USDA (VFX), PLY (point clouds). Creates directories as needed.

Inputs: filepath (required), format, selected_only.

extrude_facesB

Extrude all faces of a mesh along their normals by the given offset distance.

Inputs: name (required), offset.

fill_holesC

Automatically detect and fill holes in a mesh by selecting non-manifold edges and filling.

Inputs: name (required).

flip_normalsA

Flip all face normals of a mesh. Useful when faces appear inside-out.

Inputs: name (required).

ft_combine_shape_keysA

Combine multiple shape keys with weights into a new shape key.

Args: mesh_name: Name of the face mesh. output_name: Name for the combined output shape key. sources: JSON array of {"name": "shape_name", "weight": 0.5} objects.

Inputs: mesh_name (required), output_name (required), sources.

ft_create_arkit_shapesA

Create all 52 ARKit blend shapes on a face mesh.

Args: mesh_name: Name of the face/head mesh (must have face vertex groups from ft_setup_face_vertex_groups for 'procedural' mode). method: Generation method: - 'procedural': Auto-generate shapes using vertex displacement recipes. Requires face vertex groups. Quality depends on topology but works for any mesh with proper groups. - 'template': Create 52 empty shape keys for manual sculpting. Always works, recommended for production avatars. - 'from_existing': Map existing shape keys to ARKit names using fuzzy name matching.

Inputs: mesh_name (required), method.

ft_create_unified_expressionsA

Generate VRCFT Unified Expressions from existing ARKit shapes or from scratch.

Args: mesh_name: Name of the face mesh. source: 'arkit' to map from existing ARKit shapes, or 'template' for empty keys.

Inputs: mesh_name (required), source.

ft_export_shape_key_reportB

Generate a complete report of all shape keys with metadata.

Args: mesh_name: Name of the face mesh. format: Output format — 'markdown' or 'json'.

Inputs: mesh_name (required), format.

ft_mirror_shape_keyA

Mirror a shape key from one side to the other (e.g., Left→Right).

Sculpt mouthSmileLeft, then mirror to mouthSmileRight automatically.

Args: mesh_name: Name of the face mesh. source_shape: Source shape key name to mirror from. target_shape: Target name. Auto-generates by swapping Left/Right if empty. axis: Mirror axis — X (default, left/right), Y, or Z.

Inputs: mesh_name (required), source_shape (required), axis, target_shape.

ft_sculpt_shape_keyA

AI-guided shape key sculpting via vertex displacement.

Displaces vertices in a face region to create or refine a blend shape. Can be called multiple times to build up complex expressions.

Args: mesh_name: Name of the face mesh. shape_key_name: Shape key to modify (created if doesn't exist). region: Vertex group name defining the affected area (from ft_setup_face_vertex_groups). direction: Displacement direction — UP, DOWN, FORWARD, BACK, LEFT, RIGHT, MEDIAL, LATERAL, UP_LATERAL, FORWARD_UP, etc. intensity: Displacement intensity 0.0-1.0 (scaled to head proportions). falloff: Weight falloff — SMOOTH (smoothstep), LINEAR, SHARP, CONSTANT.

Inputs: region (required), mesh_name (required), shape_key_name (required), falloff, +2 more.

ft_setup_eye_tracking_fullB

Extended eye tracking beyond basic blink/lowerlid.

Creates 12 eye shape keys: eyeLookUp/Down/In/Out for both eyes, eyeSquint L/R, eyeWide L/R, plus ensures blink/lowerlid exist.

Args: mesh_name: Name of the face mesh. armature_name: Optional armature for eye bone configuration.

Inputs: mesh_name (required), armature_name.

ft_setup_face_vertex_groupsA

Auto-detect facial landmarks and create vertex groups for all face regions.

Analyzes mesh topology to identify eye loops, mouth loops, brow ridges, cheeks, nose, and jaw regions. These vertex groups are required for procedural ARKit blend shape generation.

Args: mesh_name: Name of the face/head mesh. armature_name: Optional armature for bone-based landmark hints.

Inputs: mesh_name (required), armature_name.

ft_setup_tongue_trackingB

Create tongue bone chain and tongue blend shapes for face tracking.

Creates tongue bones (Tongue, Tongue1, Tongue2) and blend shapes for tongueOut, tongueUp, tongueDown, tongueLeft, tongueRight.

Args: mesh_name: Name of the face mesh. armature_name: Armature to add tongue bones to. create_bones: Whether to create tongue bones (requires armature).

Inputs: mesh_name (required), create_bones, armature_name.

ft_validate_shapesA

Validate blend shapes against ARKit or Unified Expressions standard.

Reports present/missing shapes, empty shapes, excessive displacement, and symmetry issues.

Args: mesh_name: Name of the face mesh. standard: 'arkit' (52 shapes) or 'unified' (70+ shapes).

Inputs: mesh_name (required), standard.

generate_hunyuan3d_modelB

Generate 3D model using Hunyuan3D from text and/or image. text_prompt: English/Chinese description. input_image_url: local or remote image URL.

Inputs: text_prompt, input_image_url.

generate_hyper3d_model_via_imagesA

Generate 3D model from images using Hyper3D Rodin. Provide either input_image_paths (local) or input_image_urls (remote), not both. bbox_condition: optional [L,W,H] ratio.

Inputs: bbox_condition, input_image_urls, input_image_paths.

generate_hyper3d_model_via_textB

Generate 3D model from text description using Hyper3D Rodin. text_prompt: English description. bbox_condition: optional [L,W,H] ratio.

Inputs: text_prompt (required), bbox_condition.

generate_scene_scriptA

Generate a bpy Python script from a JSON scene description WITHOUT executing it.

Returns the script as a string for review or manual execution. See build_scene_from_json for the JSON format.

Inputs: scene_json (required). Returns: result

geonodes_add_nodeB

Add a node to a Geometry Nodes tree.

Args: tree_name: Node tree name node_type: Blender node type (e.g., GeometryNodeMeshPrimitiveCube, GeometryNodeSetPosition, GeometryNodeTransform, ShaderNodeMath, GeometryNodeDistributePointsOnFaces, etc.) name: Custom node label location: [x, y] position in node editor

Inputs: node_type (required), tree_name (required), name, location.

geonodes_connectA

Connect two nodes in a Geometry Nodes tree.

Args: tree_name: Node tree name from_node: Source node name from_socket: Source output socket index to_node: Destination node name to_socket: Destination input socket index

Inputs: to_node (required), from_node (required), to_socket (required), tree_name (required), +1 more.

geonodes_createC

Create a Geometry Nodes modifier on an object with a new node tree.

Args: object_name: Target object tree_name: Name for the node tree

Inputs: object_name (required), tree_name.

geonodes_list_nodesB

List all nodes in a Geometry Nodes tree with their connections.

Inputs: tree_name (required).

geonodes_preset_scatterB

Apply a preset: scatter instances on a surface.

Creates a complete geo-nodes setup that distributes point instances on the object's surface — great for grass, rocks, particles, etc.

Args: object_name: Surface object to scatter on instance_type: SPHERE, CUBE, CONE, or object name for custom instance density: Points per unit area scale: Instance scale seed: Random seed

Inputs: object_name (required), seed, scale, density, +1 more.

geonodes_set_inputB

Set a node input's default value.

Args: tree_name: Node tree name node_name: Node name input_index: Input socket index value: Value to set (float, int, vector list, etc.)

Inputs: value (required), node_name (required), tree_name (required), input_index (required).

get_hierarchyA

Get the parent-child hierarchy tree. If name is given, returns that object's subtree. If no name, returns all root objects and their children.

Inputs: name.

get_hunyuan3d_statusC

Check if Hunyuan3D integration is enabled. Generates 3D models from text or images.

Inputs: no named parameters.

get_hyper3d_statusC

Check if Hyper3D Rodin integration is enabled. Generates 3D models from text or images.

Inputs: no named parameters.

get_object_infoA

Get detailed information about a specific object by name. Returns location, rotation, scale, materials, modifiers, constraints, vertex/edge/face counts, bounding box, and parent/child hierarchy.

Inputs: name (required).

get_polyhaven_categoriesA

Get categories for a PolyHaven asset type. asset_type: hdris, textures, models, all.

Inputs: asset_type.

get_polyhaven_statusA

Check if PolyHaven integration is enabled in Blender. PolyHaven provides free HDRIs, textures, and 3D models.

Inputs: no named parameters.

get_scene_infoA

Get complete scene information including all objects, camera, render settings, and frame range. Returns object names, types, locations, vertex/face counts for meshes, and scene metadata.

Inputs: no named parameters.

get_sketchfab_model_previewA

Get a preview thumbnail of a Sketchfab model by UID. Use before downloading to visually confirm the model.

Inputs: uid (required).

get_sketchfab_statusA

Check if Sketchfab integration is enabled in Blender. Sketchfab has a wide variety of realistic downloadable 3D models.

Inputs: no named parameters.

get_viewport_screenshotA

Capture a screenshot of the 3D viewport. Returns the file path to the saved image. Uses OpenGL render for speed. Useful for visual verification of scene state.

Inputs: max_size.

import_generated_assetA

Import a Hyper3D Rodin generated asset after generation completes. name: object name in scene. Provide task_uuid (MAIN_SITE) or request_id (FAL_AI).

Inputs: name (required), task_uuid, request_id.

import_generated_asset_hunyuanA

Import Hunyuan3D generated asset after generation completes. name: object name. zip_file_url: from the poll step when status is DONE.

Inputs: name (required), zip_file_url (required).

inset_facesC

Inset all faces of a mesh. Thickness controls inset distance, depth controls push in/out.

Inputs: name (required), depth, thickness.

io_export_fbxA

Export to FBX format (standard for Unity/VRChat/game engines).

Default settings are optimized for VRChat/Unity workflow. IMPORTANT: add_leaf_bones=False is critical for VRChat.

Args: filepath: Output .fbx path selected_only: Export only selected objects apply_modifiers: Apply modifiers before export add_leaf_bones: Add leaf bones (FALSE for VRChat!) mesh_smooth_type: FACE, EDGE, OFF apply_scale: FBX_SCALE_ALL, FBX_SCALE_UNITS, FBX_SCALE_CUSTOM, FBX_SCALE_NONE axis_forward: Forward axis (-Z for Unity) axis_up: Up axis (Y for Unity)

Inputs: filepath (required), axis_up, apply_scale, axis_forward, +4 more.

io_export_gltfA

Export to glTF/GLB format (standard for web and universal 3D).

Args: filepath: Output path (.glb or .gltf) export_format: GLB (binary, single file) or GLTF_SEPARATE (separate files) selected_only: Export only selected objects apply_modifiers: Apply modifiers export_materials: EXPORT, PLACEHOLDER, NONE export_textures: Include texture images export_animations: Include animations

Inputs: filepath (required), export_format, selected_only, apply_modifiers, +3 more.

io_export_objB

Export to OBJ format (universal mesh exchange).

Args: filepath: Output .obj path selected_only: Export only selected apply_modifiers: Apply modifiers export_materials: Write .mtl file export_uv: Export UV coordinates export_normals: Export vertex normals

Inputs: filepath (required), export_uv, selected_only, export_normals, +2 more.

io_export_stlB

Export to STL format (3D printing).

Args: filepath: Output .stl path selected_only: Export only selected apply_modifiers: Apply modifiers ascii_format: ASCII STL (True) or binary (False, smaller file)

Inputs: filepath (required), ascii_format, selected_only, apply_modifiers.

io_export_usdA

Export to USD/USDC format (Pixar Universal Scene Description).

Args: filepath: Output .usd/.usdc path selected_only: Export only selected export_materials: Include materials export_animation: Include animation

Inputs: filepath (required), selected_only, export_animation, export_materials.

io_import_fileA

Import a 3D file into the current scene.

Auto-detects format from extension. Supports: FBX, OBJ, glTF/GLB, STL, USD/USDC/USDA, PLY, ABC (Alembic), DAE (Collada), SVG.

Args: filepath: Path to the file to import file_format: Override format detection (fbx, obj, gltf, stl, usd, ply, abc, dae, svg)

Inputs: filepath (required), file_format.

join_objectsB

Join multiple objects into one. All objects are merged into the first one in the list.

Inputs: names (required).

light_addB

Add a light to the scene.

Args: name: Light name light_type: POINT, SUN, SPOT, AREA location: [x, y, z] position rotation: [rx, ry, rz] rotation in degrees power: Light power (Watts for point/spot/area, strength for sun) color: [r, g, b] color (0-1 range) size: Light size (area size, point radius, spot cone) shadow: Cast shadows

Inputs: name, size, color, power, +4 more.

light_listA

List all lights in the scene with their properties.

Inputs: no named parameters.

light_modifyA

Modify an existing light's properties.

Args: light_name: Light object name power: New power value color: New [r, g, b] color shadow: Enable/disable shadows size: New size (area lights)

Inputs: light_name (required), size, color, power, +1 more.

light_setup_studioB

Set up studio lighting with softboxes (4 area lights + white world).

Args: target_location: Scene center point temperature: warm (5000K yellowish), neutral (6500K white), cool (8000K bluish)

Inputs: temperature, target_location.

light_setup_three_pointA

Set up classic 3-point lighting (key + fill + rim/back).

Professional lighting setup for product shots and character renders.

Args: target_location: Center point to light [x, y, z] key_power: Key light power fill_power: Fill light power rim_power: Rim/back light power distance: Distance from target

Inputs: distance, key_power, rim_power, fill_power, +1 more.

list_collectionsA

List all collections in the scene as a tree with their objects.

Inputs: no named parameters.

list_materialsA

List all materials in the scene with their base color and user count.

Inputs: no named parameters.

material_assignB

Assign a material to an object.

Args: object_name: Target object material_name: Material name (must exist in bpy.data.materials) slot_index: Material slot (-1 = append new slot, 0+ = replace slot)

Inputs: object_name (required), material_name (required), slot_index.

material_create_pbrA

Create a custom PBR material with full control.

Args: name: Material name base_color: [r, g, b, a] color (0-1 range) metallic: 0.0 (dielectric) to 1.0 (metal) roughness: 0.0 (mirror) to 1.0 (diffuse) specular: Specular reflection strength transmission: 0.0 (opaque) to 1.0 (transparent) ior: Index of refraction (glass=1.45, water=1.33, diamond=2.42) emission_color: [r, g, b] for self-illumination emission_strength: Emission power alpha: Overall opacity

Inputs: name (required), ior, alpha, metallic, +6 more.

material_create_presetB

Create a material from a preset and optionally assign it.

Args: preset_name: One of the preset names (see material_list_presets) material_name: Custom name for the material (auto if empty) color_override: Override base color [r, g, b, a] (0-1 range)

Inputs: preset_name (required), material_name, color_override.

material_duplicateA

Duplicate an existing material.

Args: material_name: Source material name new_name: Name for the copy (auto if empty)

Inputs: material_name (required), new_name.

material_listA

List materials — on a specific object or all materials in the scene.

Args: object_name: Object name (empty = list all scene materials)

Inputs: object_name.

material_list_presetsA

List all material presets with descriptions.

Presets: glossy_plastic, matte_plastic, brushed_metal, polished_metal, gold, glass, rubber, wood, skin, skin_anime, fabric, emissive.

Inputs: no named parameters.

material_set_textureB

Add an image texture to a material's Principled BSDF.

Args: material_name: Target material texture_path: Path to image file texture_type: Where to connect: - base_color: Albedo/diffuse - normal: Normal map - roughness: Roughness map - metallic: Metallic map - emission: Emission map

Inputs: texture_path (required), material_name (required), texture_type.

measure_alignmentA

Check if multiple objects are aligned along an axis.

Args: objects: List of object names to check alignment axis: Axis to check (X, Y, or Z)

Inputs: objects (required), axis.

measure_dimensionsA

Measure object dimensions (bounding box size in world space).

Returns width (X), depth (Y), height (Z), volume estimate, and world-space bounding box corners.

Inputs: object_name (required).

measure_distanceB

Measure the distance between two objects (center to center).

Args: object_a: First object name object_b: Second object name

Inputs: object_a (required), object_b (required).

measure_overlapA

Check if two objects' bounding boxes overlap.

Returns overlap status, overlap volume, and intersection dimensions.

Inputs: object_a (required), object_b (required).

measure_symmetryB

Check mesh symmetry across an axis.

Analyzes vertex positions to determine how symmetric the mesh is.

Args: object_name: Mesh object to check axis: Symmetry axis (X, Y, or Z) threshold: Distance threshold for considering vertices as symmetric

Inputs: object_name (required), axis, threshold.

merge_by_distanceA

Merge vertices that are closer than the threshold distance. Useful for cleaning up duplicate vertices after boolean operations.

Inputs: name (required), threshold.

mesh_quality_checkA

Analyze mesh quality — find non-manifold edges, loose vertices, degenerate faces, duplicate vertices, and other issues.

Essential for 3D printing, game assets, and VRChat avatars.

Inputs: object_name (required).

modifier_addA

Add a modifier to an object with validated parameters.

Supports 15 modifier types with type checking and range validation. Invalid parameters are caught before sending to Blender.

Args: object_name: Target object name modifier_type: Modifier type (SUBSURF, MIRROR, ARRAY, BEVEL, SOLIDIFY, BOOLEAN, DECIMATE, SMOOTH, SHRINKWRAP, LATTICE, ARMATURE, CLOTH, WEIGHTED_NORMAL, SKIN, WIREFRAME) modifier_name: Custom name for the modifier (auto-generated if empty) params: Dict of parameter overrides (see modifier_list_types for options)

Inputs: object_name (required), modifier_type (required), params, modifier_name.

modifier_applyB

Apply (finalize) a modifier on an object.

This makes the modifier's effect permanent and removes it from the stack.

Inputs: object_name (required), modifier_name (required).

modifier_apply_allC

Apply all modifiers on an object in stack order.

Inputs: object_name (required).

modifier_batch_addB

Add the same modifier to multiple objects at once.

Args: object_names: List of object names modifier_type: Modifier type (see modifier_add) params: Parameter overrides

Inputs: object_names (required), modifier_type (required), params.

modifier_listB

List all modifiers on an object with their current settings.

Inputs: object_name (required).

modifier_list_typesA

List all supported modifier types with descriptions and parameters.

Returns detailed info about each modifier including parameter names, types, defaults, and valid ranges.

Inputs: no named parameters.

modifier_preset_smooth_shadeA

Apply common smooth shading preset: Subdivision Surface + Smooth Shading + Weighted Normal.

A one-click polish for any mesh — adds subdivision, smooth shading, and weighted normals for clean rendering.

Inputs: object_name (required), subdiv_levels.

modifier_removeC

Remove a modifier from an object without applying it.

Inputs: object_name (required), modifier_name (required).

modifier_reorderB

Move a modifier to a specific position in the stack.

Args: object_name: Target object modifier_name: Modifier to move position: Target position (0 = top of stack)

Inputs: position (required), object_name (required), modifier_name (required).

move_to_collectionC

Move an object to a different collection. Removes from current collection(s).

Inputs: object_name (required), collection_name (required).

optimize_sceneA

Optimize the entire scene: remove orphan meshes/materials/images, and merge duplicate vertices on all meshes. Returns a log of all optimizations performed.

Inputs: merge_threshold.

origin_setB

Set the origin point of an object. Types: ORIGIN_GEOMETRY (center of geometry), ORIGIN_CENTER_OF_MASS, ORIGIN_CENTER_OF_VOLUME, ORIGIN_CURSOR, GEOMETRY_ORIGIN.

Inputs: name (required), type.

physics_add_clothB

Add cloth physics simulation to a mesh.

Args: object_name: Target mesh object quality: Simulation quality steps (1-80) mass: Cloth mass stiffness: Structural stiffness damping: Damping factor use_self_collision: Enable self-collision detection

Inputs: object_name (required), mass, damping, quality, +2 more.

physics_add_collisionA

Add collision physics to an object (makes it a collider for cloth/particles).

Args: object_name: Target object thickness_outer: Collision surface thickness

Inputs: object_name (required), thickness_outer.

physics_add_particle_systemB

Add a particle system to an object.

Args: object_name: Emitter object count: Number of particles lifetime: Particle lifetime in frames emit_from: VERT, FACE, VOLUME velocity_normal: Emission velocity along normals gravity: Gravity multiplier size: Particle display/render size physics_type: NEWTON, KEYED, BOIDS, FLUID

Inputs: object_name (required), size, count, gravity, +4 more.

physics_add_rigid_bodyA

Add rigid body physics to an object.

Args: object_name: Target object body_type: ACTIVE (affected by physics) or PASSIVE (static collider) mass: Object mass in kg (ACTIVE only) friction: Surface friction (0-1) restitution: Bounciness (0-1) collision_shape: BOX, SPHERE, CAPSULE, CYLINDER, CONE, CONVEX_HULL, MESH

Inputs: object_name (required), mass, friction, body_type, +2 more.

physics_add_soft_bodyB

Add soft body physics to an object.

Args: object_name: Target object mass: Total mass friction: Surface friction speed: Simulation speed multiplier goal_strength: How strongly mesh holds original shape (0=floppy, 1=rigid)

Inputs: object_name (required), mass, speed, friction, +1 more.

physics_bakeC

Bake physics simulation for all objects in the scene.

Args: frame_start: Bake start frame frame_end: Bake end frame bake_type: ALL (all physics), or specific type

Inputs: bake_type, frame_end, frame_start.

physics_removeA

Remove physics from an object.

Args: object_name: Target object physics_type: RIGID_BODY, CLOTH, COLLISION, SOFT_BODY, PARTICLE, ALL

Inputs: object_name (required), physics_type.

pipeline_avatar_from_meshA

Full Blender-side avatar pipeline: mesh → armature → shape keys → FBX. Chains: validate mesh → create armature → weight paint → visemes → ARKit shapes → export.

Parameters:

  • mesh_name: Name of the mesh to process. If empty, uses active object.

  • avatar_name: Name for the avatar (default: "Avatar")

  • create_shape_keys: Generate face tracking shape keys (default: True)

  • arkit_method: "template" (empty keys for manual sculpt), "procedural" (auto-generate), "skip"

  • export_fbx: Export FBX at the end (default: True)

  • export_path: FBX export path. If empty, exports to ~/Desktop/{avatar_name}.fbx

Inputs: mesh_name, export_fbx, avatar_name, export_path, +2 more. Returns: result

pipeline_blender_to_unityB

Full Unity-side pipeline: FBX → Import → Avatar Descriptor → Expressions → Build. Chains: import FBX → set humanoid → avatar descriptor → expression menu/params → gesture layer → build.

Parameters:

  • fbx_path: Path to the FBX file

  • project_path: Unity project path

  • avatar_name: Avatar display name

  • setup_physbones: Also configure PhysBones (default: False)

  • physbones_json: PhysBone configs if setup_physbones is True

Inputs: fbx_path, avatar_name, project_path, physbones_json, +1 more. Returns: result

pipeline_face_tracking_setupA

Complete face tracking pipeline: vertex groups → ARKit 52 → Unified → validate. Chains: ft_setup_face_vertex_groups → ft_create_arkit_shapes → ft_create_unified_expressions → ft_setup_tongue_tracking → ft_setup_eye_tracking_full → ft_validate_shapes.

Parameters:

  • mesh_name: Target mesh name. If empty, uses active/largest mesh.

  • method: "procedural" (auto-generate), "template" (empty keys), "from_existing" (fuzzy match)

  • include_unified: Also generate Unified Expressions (default: True)

  • include_tongue: Setup tongue tracking (default: True)

  • include_eye_tracking: Setup full eye tracking (default: True)

Inputs: method, mesh_name, include_tongue, include_unified, +1 more. Returns: result

pipeline_generate_blueprintB

Export all configuration JSONs alongside the FBX for Unity import. Generates: avatar_blueprint.json, physbones.json, expression_menu.json, expression_params.json, shape_key_report.json.

Parameters:

  • mesh_name: Target mesh. If empty, uses active/largest.

  • output_dir: Directory to save blueprints. If empty, uses ~/Desktop/{avatar_name}/.

  • avatar_name: Avatar name for the blueprint (default: "Avatar")

Inputs: mesh_name, output_dir, avatar_name. Returns: result

pipeline_validate_fullA

Comprehensive go/no-go validation report for VRChat upload. Checks: mesh stats, armature, shape keys, materials, UV, performance rank.

Parameters:

  • mesh_name: Mesh to validate. If empty, checks all visible meshes.

  • target: "pc" or "quest" (default: "pc")

Inputs: target, mesh_name. Returns: result

poll_hunyuan_job_statusB

Poll Hunyuan3D generation status. Done when status is 'DONE'. In progress when 'RUN'.

Inputs: job_id (required).

poll_rodin_job_statusA

Poll Hyper3D Rodin generation status. Task is done when all statuses are 'Done'. Provide subscription_key (MAIN_SITE) or request_id (FAL_AI) from the generate step.

Inputs: request_id, subscription_key.

precision_weight_paintA

Precision vertex weight operations. Far more control than auto-weights.

Parameters:

  • mesh_name: Target mesh

  • operation: One of: "gradient_along_chain" — paint gradient weights along a bone chain params: {"chain_root": "Hair_01", "falloff": "LINEAR"} "transfer_weights" — transfer weights from source mesh params: {"source": "SourceMesh"} "normalize_all" — normalize all vertex groups "clean" — remove weights below threshold params: {"threshold": 0.01} "limit_total" — limit bone influences per vertex params: {"limit": 4} "smooth" — smooth weights for a vertex group params: {"group": "Left_UpperArm", "factor": 0.5, "iterations": 5} "mirror" — mirror weights X axis "assign_proximity" — weight by proximity to bone params: {"bone": "Hips", "radius": 0.5, "falloff": "SMOOTH"}

Inputs: mesh_name (required), operation (required), params. Returns: result

procedural_generateA

Generate procedural geometry using BMesh. Creates more complex shapes than basic primitives.

Parameters:

  • shape: Type of shape to generate: "spring" — coil/spring (params: radius, height, turns, segments, wire_radius) "torus_knot" — mathematical torus knot (params: p, q, radius, tube_radius, segments) "gear" — gear/cog shape (params: teeth, radius, tooth_height, thickness) "pipe" — pipe along curve (params: radius, segments, points:[[x,y,z],...]) "terrain" — procedural terrain (params: size, subdivisions, height, seed) "tree_trunk" — basic tree trunk (params: height, radius, segments, taper) "staircase" — spiral staircase (params: steps, radius, height, width) "gem" — gemstone shape (params: radius, crown_height, pavilion_height, facets)

  • name: Object name

  • params: JSON parameters for the shape

Inputs: shape (required), name, params. Returns: result

redoB

Redo the last undone operation in Blender.

Inputs: no named parameters.

remeshB

Remesh an object to create clean, uniform topology. Modes: VOXEL (uniform voxels), SMOOTH, SHARP, BLOCKS. Smaller voxel_size = higher detail but more polygons.

Inputs: name (required), mode, voxel_size.

remove_constraintC

Remove a constraint from an object by constraint name.

Inputs: name (required), constraint_name (required).

remove_modifierC

Remove a modifier from an object without applying it.

Inputs: name (required), modifier_name (required).

rename_objectA

Rename an object. Blender may append .001 if the name already exists.

Inputs: name (required), new_name (required).

render_animationA

Render an animation sequence.

Args: filepath: Output path. For image sequences, use # for frame number. frame_start: Start frame (0 = use scene default) frame_end: End frame (0 = use scene default) file_format: Override format (FFMPEG for video, PNG for sequence)

Inputs: filepath, frame_end, file_format, frame_start.

render_apply_presetA

Apply a render preset to the current scene.

Available presets:

  • cycles_preview: Fast Cycles, 32 samples, 50% res

  • cycles_default: Standard Cycles, 128 samples, full HD

  • cycles_high: HQ Cycles, 512 samples, 4K

  • eevee_preview: Fast EEVEE, effects off, 50% res

  • eevee_default: Standard EEVEE, all effects, full HD

  • eevee_high: HQ EEVEE, all effects, 4K

  • workbench: Instant solid view render

Inputs: preset_name (required).

render_get_settingsA

Get current render settings — engine, resolution, samples, output, camera.

Inputs: no named parameters.

render_imageB

Render the scene to an image file. Format is auto-detected from extension (.png, .jpg, .exr, .hdr, .bmp, .tiff). Engine: CYCLES, BLENDER_EEVEE_NEXT. Samples controls quality (more = better but slower).

Inputs: filepath (required), engine, samples, resolution_x, +1 more.

render_list_presetsA

List all available render presets with descriptions.

Presets: cycles_preview, cycles_default, cycles_high, eevee_preview, eevee_default, eevee_high, workbench.

Inputs: no named parameters.

render_set_cameraA

Set the active render camera.

Args: camera_name: Name of camera object. Empty = auto-find or create. create_if_missing: Create a default camera if none exists.

Inputs: camera_name, create_if_missing.

render_set_outputA

Configure render output path and format.

Args: filepath: Output file path (use // for relative to .blend) file_format: PNG, JPEG, OPEN_EXR, TIFF, BMP, HDR color_mode: BW, RGB, RGBA color_depth: 8, 16, 32 (depends on format) compression: PNG compression 0-100 (default 15) quality: JPEG quality 0-100 (default 90)

Inputs: filepath (required), quality, color_mode, color_depth, +2 more.

render_set_worldB

Set world background — solid color or HDRI.

Args: color: RGB [r, g, b] for solid color (0-1 range) hdri_path: Path to .hdr/.exr file for environment lighting strength: Background strength multiplier

Inputs: color, strength, hdri_path.

render_stillB

Render a single frame (still image).

Args: filepath: Optional output path. If empty, uses scene default. open_after: If True, open the rendered image in Blender's viewer.

Inputs: filepath, open_after.

retopologyA

Retopologize a mesh for clean animation-ready topology.

Parameters:

  • mesh_name: Target mesh (typically a high-poly sculpt or scan)

  • method: "quadriflow" — produces clean quads (best for characters) "voxel" — fast voxel remesh (produces tris, good for booleans cleanup) "shrinkwrap" — create low-poly proxy that conforms to surface

  • target_faces: Target face count (default: 5000)

  • params: JSON extra params: voxel: {"voxel_size": 0.01} shrinkwrap: {"source": "HighPoly", "subdivisions": 3}

Inputs: mesh_name (required), method, params, target_faces. Returns: result

rigify_add_face_rigA

Add or configure face rig bones on a Rigify meta-rig. Useful when the meta-rig was created without face bones, or to adjust face rig detail.

Parameters:

  • metarig_name: Name of the meta-rig armature (default: "metarig")

  • detail_level: "full" (all face bones), "basic" (jaw/eyes/brows only), "eyes_only"

Inputs: detail_level, metarig_name. Returns: result

rigify_configure_ikA

Configure IK settings on a Rigify rig for VRChat full-body tracking. Sets up IK pole targets, chain lengths, and optional floor constraints.

Parameters:

  • rig_name: Name of the Rigify-generated rig (default: "rig")

  • tracking_mode: "3point" (head+hands), "6point" (+ hip + feet), "10point" (+ elbows + knees)

  • floor_constraint: Add floor constraints to feet (default: True)

Inputs: rig_name, tracking_mode, floor_constraint. Returns: result

rigify_create_metarigB

Generate a Rigify meta-rig (the template rig that Rigify uses to generate the final rig).

Parameters:

  • rig_type: "human", "human_simple", "quadruped", "bird", "cat", "horse", "shark", "wolf" (default: "human")

  • name: Name for the meta-rig armature (default: "metarig")

  • include_face: Include face rig bones (default: True)

  • include_fingers: Include finger bones (default: True)

Inputs: name, rig_type, include_face, include_fingers. Returns: result

rigify_fit_metarigA

Auto-fit a Rigify meta-rig to match a target mesh's proportions. Analyzes the mesh bounding box and key landmarks to position bones.

Parameters:

  • metarig_name: Name of the meta-rig armature (default: "metarig")

  • mesh_name: Target mesh to fit to. If empty, uses the largest mesh in scene.

  • method: "proportional" (scale bones to mesh proportions) or "snap" (snap key bones to nearest surface)

Inputs: method, mesh_name, metarig_name. Returns: result

rigify_generate_rigA

Generate the final production rig from a Rigify meta-rig. This creates the full control rig with IK/FK switches, custom shapes, etc.

Parameters:

  • metarig_name: Name of the meta-rig armature (default: "metarig")

  • parent_to_mesh: If provided, auto-parent this mesh to the generated rig with automatic weights.

Inputs: metarig_name, parent_to_mesh. Returns: result

rigify_to_vrcA

Convert a Rigify-generated rig to VRC-compatible bone naming. Duplicates DEF-bones into a clean hierarchy with Unity Humanoid naming, ready for FBX export. Non-deform bones are excluded.

Parameters:

  • rig_name: Name of the Rigify-generated rig (default: "rig")

  • export_name: Name for the export-ready armature. If empty, uses "{rig_name}_vrc".

Inputs: rig_name, export_name. Returns: result

rig_toolsA

Advanced rigging operations for animation-ready armatures.

Parameters:

  • armature_name: Target armature

  • operation: "add_ik" — add IK constraint to a bone chain params: {"bone": "Left_LowerArm", "target_bone": "Left_Hand_IK", "chain_length": 2, "pole_bone": "Left_Arm_Pole"} "add_fk_ik_switch" — create FK/IK switching setup params: {"chain": ["Left_UpperArm", "Left_LowerArm", "Left_Hand"]} "create_pole_targets" — auto-create pole target bones for IK params: {"ik_bones": ["Left_LowerArm", "Right_LowerArm", "Left_LowerLeg", "Right_LowerLeg"]} "test_deformation" — rotate bones through range and check for problems params: {"bone": "Left_UpperArm", "axis": "X", "range": [-90, 90]} "setup_twist_bones" — add twist bones for better arm/leg deformation params: {"bone": "Left_UpperArm", "segments": 2}

Inputs: operation (required), armature_name (required), params. Returns: result

rotate_objectB

Rotate an object. Values are in degrees by default. If relative=True, adds to current rotation.

Inputs: name (required), x, y, z, +2 more.

scale_objectB

Scale an object. Set uniform to scale equally on all axes. If relative=True, multiplies current scale. If False, sets absolute scale.

Inputs: name (required), x, y, z, +2 more.

scene_apply_profileA

Apply a scene profile (resolution, engine, samples, etc).

Available profiles:

  • preview: 960x540 EEVEE fast

  • hd720p: 1280x720 EEVEE

  • hd1080p: 1920x1080 Cycles

  • 4k: 3840x2160 Cycles HQ

  • instagram_square: 1080x1080

  • instagram_story: 1080x1920 vertical

  • youtube_thumbnail: 1280x720 fast

  • product_render: 2048x2048 transparent Cycles

  • turntable: 1080p 120-frame rotation

  • vrc_avatar_preview: 1200x1600 portrait transparent

Inputs: profile_name (required).

scene_cleanupB

Clean up unused data blocks from the scene.

Removes orphaned materials, meshes, images, and textures that have zero users. Reduces file size and clutter.

Inputs: remove_unused_images, remove_unused_meshes, remove_unused_textures, remove_unused_materials.

scene_create_collectionB

Create a new collection in the scene.

Args: name: Collection name parent: Parent collection name (empty = Scene Collection) color_tag: COLOR_01 through COLOR_08, or NONE

Inputs: name (required), parent, color_tag.

scene_list_profilesA

List all available scene profiles with descriptions.

Profiles cover: preview, hd720p, hd1080p, 4k, instagram_square, instagram_story, youtube_thumbnail, product_render, turntable, vrc_avatar_preview.

Inputs: no named parameters.

scene_move_to_collectionC

Move objects to a collection.

Args: object_names: List of object names to move collection_name: Target collection name

Inputs: object_names (required), collection_name (required).

scene_set_unitsC

Set scene unit system.

Args: system: METRIC, IMPERIAL, or NONE length: KILOMETERS, METERS, CENTIMETERS, MILLIMETERS, MILES, FEET, INCHES scale_length: Unit scale factor (default 1.0)

Inputs: length, system, scale_length.

scene_setup_turntableA

Set up a 360° turntable camera animation around a target object.

Creates a camera orbiting the target with smooth rotation. Great for showcasing models and avatars.

Args: target_name: Object to orbit around (empty = scene center) frames: Number of frames for full rotation (default 120) radius: Camera orbit radius height: Camera height focal_length: Camera lens mm

Inputs: frames, height, radius, target_name, +1 more.

scene_set_visibilityA

Set object visibility in viewport and render.

Args: object_name: Name of the object viewport: Show in viewport render: Show in renders selectable: Allow selection in viewport

Inputs: object_name (required), render, viewport, selectable.

scene_statsA

Get comprehensive scene statistics.

Returns object counts by type, total vertices/faces/edges, material count, texture memory, collection tree, and frame range.

Inputs: no named parameters.

sculpt_analyze_surfaceA

Analyze mesh surface for sculpting decisions.

analysis_type: 'full' — complete analysis (curvature, density, topology, silhouette) 'curvature' — vertex curvature map (find high/low curvature zones) 'density' — vertex/face density distribution 'topology' — quad/tri/ngon ratio, poles, manifold check 'silhouette' — bounding box, aspect ratios, balance

Returns detailed analysis to guide sculpting decisions.

Inputs: mesh_name (required), analysis_type. Returns: result

sculpt_anatomy_passA

Apply anatomy-aware sculpting pass using built-in knowledge.

pass_type: 'primary' (big forms), 'secondary' (muscles/bones), 'tertiary' (detail) body_region: 'full', 'head', 'torso', 'arm', 'leg', 'hand', 'foot' style: 'realistic', 'semi_realistic', 'anime_standard', 'chibi' intensity: 0.0-1.0 how strong to apply

This tool analyzes the mesh and applies anatomically-informed smoothing/displacement based on the sculpt pass type. It modifies the mesh to improve anatomical correctness within the chosen style.

Inputs: mesh_name (required), style, intensity, pass_type, +1 more. Returns: result

sculpt_brush_fullB

Professional sculpt brush with ALL 30+ brush types and full parameter control.

brush_type: DRAW, DRAW_SHARP, CLAY, CLAY_STRIPS, CLAY_THUMB, LAYER, INFLATE, BLOB, CREASE, SMOOTH, FLATTEN, FILL, SCRAPE, MULTIPLANE_SCRAPE, PINCH, GRAB, ELASTIC_DEFORM, SNAKE_HOOK, THUMB, POSE, NUDGE, ROTATE, BOUNDARY, CLOTH

falloff: SMOOTH, SMOOTHER, SPHERE, ROOT, SHARP, LINEAR, CONSTANT, INVERSE_SQUARE, POW4, GAUSSIAN

direction: ADD (raise/build) or SUBTRACT (carve/lower)

stroke_points: JSON array of {x, y, z} world-space points. radius: Brush radius in Blender units (world space). strength: 0.0-1.0 intensity. auto_smooth: 0.0-1.0 smooth pass after each stroke. accumulate: If true, strength compounds on overlap. plane_offset: Offset from surface plane (for CLAY/FLATTEN types). texture_noise_scale: >0 adds procedural noise to displacement.

Inputs: mesh_name (required), radius, falloff, strength, +10 more. Returns: result

sculpt_brush_strokeA

Execute a programmatic sculpt brush stroke on a mesh.

Uses bmesh vertex displacement for precise, reproducible sculpting that doesn't depend on screen coordinates.

Args: mesh_name: Name of the mesh object. brush_type: Brush to use — DRAW, CLAY_STRIPS, SMOOTH, GRAB, INFLATE, CREASE, FLATTEN, PINCH, SNAKE_HOOK. strength: Brush strength 0.0-1.0. radius: Brush radius in Blender units (world space). stroke_points: JSON array of {"x","y","z"} world-space points defining the stroke path. Each point applies the brush effect. use_symmetry_x: Mirror across X axis (left/right). use_symmetry_y: Mirror across Y axis. use_symmetry_z: Mirror across Z axis.

Inputs: mesh_name (required), radius, strength, brush_type, +4 more.

sculpt_color_attributeB

Manage vertex colors for sculpt-mode painting.

action: 'create' — Create a new color attribute 'fill' — Fill entire mesh with a color 'paint_sphere' — Paint color in a sphere region 'gradient' — Apply gradient along an axis 'curvature_color' — Color by surface curvature (for visualization) 'ao_vertex_color' — Bake simple ambient occlusion to vertex colors

color: JSON [R, G, B, A] (0.0-1.0). params: For paint_sphere: {"center": [x,y,z], "radius": 0.1} For gradient: {"axis": "Z", "color_start": [r,g,b,a], "color_end": [r,g,b,a]} For ao_vertex_color: {"samples": 16, "distance": 0.5}

Inputs: mesh_name (required), color, action, params. Returns: result

sculpt_detail_adaptiveB

Adaptive detail control — add resolution where needed.

action: 'auto_detail' — Analyze and remesh with adaptive density 'add_detail_sphere' — Add detail (subdivide) in a spherical region 'reduce_detail_sphere' — Reduce detail (decimate) in a spherical region 'equalize' — Make vertex density uniform 'info' — Report density statistics

target_density: Target edge length (0 = auto-calculate from mesh). detail_regions: JSON array of {"center": [x,y,z], "radius": r, "detail": 0.5-2.0}

Inputs: mesh_name (required), action, detail_regions, target_density. Returns: result

sculpt_detail_floodA

Flood-fill detail for uniform resolution in dynamic topology sculpting.

Args: mesh_name: Name of the mesh object (must be in sculpt mode with dyntopo). detail_size: Target detail size (smaller = finer).

Inputs: mesh_name (required), detail_size.

sculpt_extractA

Extract part of a sculpted mesh as a new separate object.

method: 'by_mask' — Extract masked region (mask > 0.5) 'by_face_set' — Extract specified face set 'by_position' — Extract faces in a bounding box/sphere 'shell' — Create a thin shell from the surface (like armor/clothing)

thickness: Solidify thickness for extracted piece. offset: Solidify offset (-1 to 1, negative = inward). smooth_iterations: Smooth passes on extraction boundary. params: For by_face_set: {"face_set_id": 1} For by_position: {"center": [x,y,z], "radius": 0.5} or {"min": [x,y,z], "max": [x,y,z]}

Inputs: mesh_name (required), method, offset, params, +2 more. Returns: result

sculpt_extract_face_setB

Extract a face set from a sculpted mesh as a separate object.

Useful for creating accessories, clothing pieces, or separating features from a base sculpt.

Args: mesh_name: Name of the mesh object. face_set_id: Face set ID to extract (starts at 1). thickness: Solidify thickness for the extracted piece.

Inputs: mesh_name (required), thickness, face_set_id.

sculpt_face_setsC

Manage face sets for organized sculpting.

action: 'init_by_normals' — Auto-create face sets from face normal directions 'init_by_loose_parts' — Face sets from disconnected mesh islands 'init_by_materials' — Face sets from material slots 'assign_by_position' — Assign faces in a sphere to a face set 'grow' — Expand a face set by one ring 'shrink' — Contract a face set by one ring 'list' — List all face sets with face counts 'visibility_isolate' — Hide all except specified face set 'visibility_show_all' — Show all face sets

params (JSON): For 'assign_by_position': {"center": [x,y,z], "radius": 0.1}

Inputs: mesh_name (required), action, params, face_set_id. Returns: result

sculpt_layer_workflowC

Layer-based sculpting using shape keys as sculpt layers.

action: 'create' — Create a new sculpt layer (shape key) 'set_active' — Activate a sculpt layer for editing 'set_blend' — Set layer blend value (0.0-1.0) 'flatten' — Merge all layers into the base mesh 'delete' — Delete a sculpt layer 'list' — List all layers with their blend values and displacement stats

layer_name: Name of the sculpt layer. blend_value: 0.0-1.0 visibility/blend of this layer.

Inputs: mesh_name (required), action, layer_name, blend_value. Returns: result

sculpt_maskA

Manage sculpt masks on a mesh.

Args: mesh_name: Name of the mesh object. action: Mask action — CLEAR (remove mask), INVERT (flip), SMOOTH, SHARPEN, GROW, SHRINK, FROM_VERTEX_GROUP. vertex_group: Vertex group name (required for FROM_VERTEX_GROUP action). invert: Invert the resulting mask.

Inputs: mesh_name (required), action, invert, vertex_group.

sculpt_mask_advancedA

Advanced sculpt masking operations.

action: 'by_cavity' — Mask concave areas (crevices) 'by_convex' — Mask convex areas (peaks) 'by_normal_direction' — Mask faces facing a direction 'by_curvature' — Mask by curvature threshold 'by_position' — Gradient mask along an axis 'by_noise' — Procedural noise mask 'blur' — Gaussian blur existing mask 'contrast' — Increase/decrease mask contrast 'border' — Mask only the border between masked/unmasked 'paint_sphere' — Paint mask in a sphere region

params (JSON): by_normal_direction: {"direction": [x,y,z], "threshold": 0.5} by_curvature: {"min": 0.01, "max": 0.1} by_position: {"axis": "Z", "min": 0.0, "max": 1.0} by_noise: {"scale": 0.1, "threshold": 0.5} contrast: {"factor": 2.0} paint_sphere: {"center": [x,y,z], "radius": 0.1, "value": 1.0}

Inputs: mesh_name (required), action, params. Returns: result

sculpt_mesh_filterB

Apply whole-mesh sculpt filter (no stroke needed).

filter_type: SMOOTH, INFLATE, SPHERE, RANDOM, RELAX, SURFACE_SMOOTH, SHARPEN, ENHANCE_DETAILS, SCALE, FLATTEN_BASES

strength: Filter intensity (can be >1.0). iterations: Number of passes. axis_x/y/z: Which axes to affect.

Inputs: mesh_name (required), axis_x, axis_y, axis_z, +3 more. Returns: result

sculpt_mode_enterA

Enter sculpt mode on a mesh object.

Args: mesh_name: Name of the mesh object. multires_levels: If > 0, add a Multires modifier with this many subdivision levels. dyntopo: Enable dynamic topology sculpting (mutually exclusive with Multires). detail_size: Dyntopo detail size (smaller = more detail). Default 12.

Inputs: mesh_name (required), dyntopo, detail_size, multires_levels.

sculpt_multires_workflowA

Full multi-resolution sculpting workflow control.

action: 'setup' — Add multires modifier and subdivide to target levels 'set_level' — Change sculpt subdivision level (low for broad, high for detail) 'apply_base' — Move base mesh toward sculpted shape 'delete_higher' — Delete subdivision levels above current 'unsubdivide' — Reduce base mesh topology 'rebuild' — Rebuild subdivisions from topology 'info' — Show current multires state

levels: Number of subdivision levels for 'setup'. sculpt_level: Target sculpt level for 'set_level' (-1 = max). subdivision_type: CATMULL_CLARK or SIMPLE.

Inputs: mesh_name (required), action, levels, sculpt_level, +1 more. Returns: result

sculpt_referenceA

Manage reference images for sculpting.

action: 'create_turnaround' — Set up standard turnaround reference planes (front/side/back/top images as transparent planes) 'add_image_plane' — Add a single reference image plane 'setup_camera_ref' — Load reference as background image in camera 'list' — List all reference objects

view: 'front', 'side', 'back', 'top' (for image plane orientation). image_path: Path to reference image file. size: Scale of reference plane. opacity: Transparency of reference plane (0.0-1.0).

Inputs: size, view, action, opacity, +1 more. Returns: result

sculpt_remeshA

Remesh a sculpt for uniform topology.

Args: mesh_name: Name of the mesh object. method: VOXEL (uniform density) or DYNTOPO (adaptive, sculpt-mode only). voxel_size: Voxel size for VOXEL method (smaller = more detail). detail_size: Detail size for DYNTOPO method.

Inputs: mesh_name (required), method, voxel_size, detail_size.

sculpt_smooth_groupsA

Targeted smoothing operations for sculpted meshes.

action: 'smooth_by_mask' — Smooth only masked region 'smooth_boundary' — Smooth only mesh boundaries/seams 'smooth_high_curvature' — Smooth only high-curvature areas 'laplacian_smooth' — Volume-preserving Laplacian smooth (whole mesh) 'relax_topology' — Equalize edge lengths without changing shape

iterations: Number of smooth passes. factor: Smooth strength per pass (0.0-1.0). preserve_volume: Scale mesh back to original volume after smoothing.

Inputs: mesh_name (required), action, factor, iterations, +1 more. Returns: result

sculpt_symmetryA

Symmetry operations for sculpting.

action: 'symmetrize' — Mirror mesh from one side to the other 'check' — Analyze symmetry quality (report asymmetric vertices) 'snap_to_symmetry' — Snap near-symmetric vertices to exact symmetry 'enable_mirror' — Enable sculpt mirror on axis

axis: X, Y, or Z. direction: NEGATIVE (positive→negative) or POSITIVE (negative→positive). merge_threshold: Distance threshold for symmetry snapping.

Inputs: mesh_name (required), axis, action, direction, +1 more. Returns: result

sculpt_to_shape_keyB

Save the current mesh state as a shape key relative to the basis.

Critical for face tracking workflow — sculpt a facial pose, then save it as a blend shape (shape key).

Args: mesh_name: Name of the mesh object. shape_key_name: Name for the new shape key (e.g., 'mouthSmileLeft'). basis_name: Name of the basis shape key (auto-created if missing).

Inputs: mesh_name (required), shape_key_name (required), basis_name.

sculpt_trimA

Boolean trim/cut operations for sculpting.

trim_type: 'plane' — Cut mesh with a plane 'box' — Boolean subtract a box 'sphere' — Boolean subtract a sphere 'custom' — Boolean with another object

params (JSON): plane: {"origin": [x,y,z], "normal": [x,y,z], "fill": true} box: {"min": [x,y,z], "max": [x,y,z], "operation": "DIFFERENCE"} sphere: {"center": [x,y,z], "radius": 0.5, "operation": "DIFFERENCE"} custom: {"cutter": "CutterObjectName", "operation": "DIFFERENCE"}

cleanup: Auto-cleanup degenerate geometry after cut.

Inputs: mesh_name (required), params, cleanup, trim_type. Returns: result

search_polyhaven_assetsB

Search PolyHaven assets with optional filtering. asset_type: hdris, textures, models, all. categories: comma-separated list of categories to filter by.

Inputs: asset_type, categories.

search_sketchfab_modelsC

Search Sketchfab for 3D models. query: search text. count: max results. downloadable: only downloadable models.

Inputs: query (required), count, categories, downloadable.

select_objectA

Select an object and make it active. If add=False (default), deselects all others first.

Inputs: name (required), add.

separate_objectA

Separate an object into multiple objects. Modes: LOOSE (by loose parts), MATERIAL (by material), SELECTED (by selection).

Inputs: name (required), mode.

set_animation_rangeB

Set the animation frame range and optionally the FPS. Standard FPS values: 24 (film), 25 (PAL), 30 (NTSC), 60 (smooth).

Inputs: end (required), start (required), fps.

set_cameraB

Configure the scene camera. Location is [x,y,z]. Rotation in degrees [x,y,z]. focal_length in mm (35=normal, 85=portrait, 200=telephoto). target: object name to point at. depth_of_field: {"enabled": true, "aperture": 2.8, "focus_object": "name", "focus_distance": 5.0}.

Inputs: target, location, rotation, focal_length, +1 more.

set_collection_visibilityA

Set viewport and render visibility of a collection and all its objects.

Inputs: name (required), visible, render_visible.

set_fogA

Add volumetric fog to the world. Density controls thickness. Color is [R,G,B] for emission tint. Requires Cycles or EEVEE for volume rendering.

Inputs: color, density.

set_frameC

Set the current frame in the timeline.

Inputs: frame (required).

set_keyframeC

Insert a keyframe on an object property at a specific frame. data_path examples: "location", "rotation_euler", "scale", "hide_viewport". Value sets the property value at that frame (list for vectors, float for scalars).

Inputs: name (required), frame (required), data_path (required), value.

set_materialA

Set PBR material properties on an object using Principled BSDF. base_color: [R,G,B] or [R,G,B,A] (0-1 range). metallic: 0=dielectric, 1=metal. roughness: 0=mirror, 1=diffuse. transmission: 0=opaque, 1=glass. emission_color + emission_strength for glowing materials.

Inputs: name (required), ior, alpha, sheen, +10 more.

set_material_colorB

Set or create a simple color material on an object. color: [R,G,B] or [R,G,B,A] (0-1 range).

Inputs: color (required), object_name (required), material_name.

set_parentB

Set parent-child relationship. If keep_transform=True, child maintains its world position.

Inputs: child (required), parent (required), keep_transform.

set_principled_bsdfC

Full control over Principled BSDF PBR shader. Only set the parameters you need. Colors as [R,G,B] or [R,G,B,A] 0.0-1.0. Scalars 0.0-1.0 except emission_strength and ior.

Inputs: object_name (required), ior, alpha, sheen, +11 more.

set_sky_textureC

Set a procedural Nishita sky texture for realistic outdoor lighting. sun_elevation: degrees above horizon. sun_rotation: compass direction. turbidity: atmospheric haze (2=clear, 10=hazy).

Inputs: turbidity, sun_rotation, sun_elevation, sun_intensity.

set_textureB

Apply a previously downloaded PolyHaven texture to an object. texture_id must have been downloaded first via download_polyhaven_asset.

Inputs: texture_id (required), object_name (required).

setup_studio_lightingA

Set up professional studio lighting. Removes existing lights and creates a new setup. Styles: THREE_POINT (key/fill/rim), REMBRANDT (dramatic), SOFT_BOX (even, soft), or default SUN lighting for outdoor scenes.

Inputs: style.

set_visibilityB

Set viewport and render visibility of an object.

Inputs: name (required), visible, render_visible.

set_world_colorA

Set the world background to a solid color. Color is [R,G,B] (0-1 range). Strength controls brightness. Good for studio-style renders.

Inputs: color, strength.

set_world_hdriA

Set an HDRI image as the world environment for realistic lighting. Provide the full file path to an .hdr or .exr file.

Inputs: filepath (required).

shade_smoothB

Set smooth or flat shading on an object. smooth=True for smooth, False for flat.

Inputs: name (required), smooth.

smart_uv_projectB

Automatically UV unwrap a mesh using Smart UV Project. angle_limit in degrees controls island splitting (66 is good default). island_margin adds padding between UV islands.

Inputs: name (required), angle_limit, island_margin.

smart_uv_toolsB

Advanced UV mapping operations beyond basic smart project.

Parameters:

  • mesh_name: Target mesh

  • operation: "auto_seams" — automatically mark seams at sharp edges + material boundaries params: {"angle": 60} — angle threshold in degrees "pack_islands" — optimize UV island packing params: {"margin": 0.02} "straighten" — straighten UV islands along grid "check_stretching" — analyze UV stretching/distortion "transfer_uv" — transfer UVs from source mesh params: {"source": "SourceMesh"} "lightmap_uv" — create secondary UV for lightmap params: {"margin": 0.1}

Inputs: mesh_name (required), params, operation. Returns: result

snap_to_groundA

Snap an object's lowest point to Z=0 (the ground plane). Useful for placing objects on a floor or surface.

Inputs: name (required).

subdivideA

Subdivide all faces of a mesh. Cuts = number of subdivision levels. Smooth > 0 applies smoothing to subdivided vertices.

Inputs: name (required), cuts, smooth.

texture_paint_fillA

Fill a texture with a solid color. Creates image if it doesn't exist.

Foundation for texture painting workflow — creates a clean base texture.

Args: mesh_name: Name of the mesh object. color: RGBA color as JSON array [R, G, B, A] with values 0.0-1.0. resolution: Image resolution if creating new. image_name: Name for the texture. Auto-generated if empty.

Inputs: mesh_name (required), color, image_name, resolution.

topology_edge_loopsB

Work with edge loops for clean topology. Essential for animation deformation.

Parameters:

  • mesh_name: Target mesh

  • action: "analyze" — report edge loop statistics and topology quality "add_loop_cut" — add loop cuts (params: loop_cuts, edge_index) "select_non_manifold" — find problematic non-manifold geometry "analyze_poles" — find N-poles and E-poles (topology quality indicators)

  • loop_cuts: Number of cuts for add_loop_cut (default: 1)

  • edge_index: Edge to cut along (-1 = auto-detect best edge)

Inputs: mesh_name (required), action, loop_cuts, edge_index. Returns: result

translate_objectA

Move an object. If relative=True (default), adds to current position. If relative=False, sets absolute position. Units are Blender units (meters).

Inputs: name (required), x, y, z, +1 more.

undoA

Undo the last operation in Blender.

Inputs: no named parameters.

unity_build_avatarA

Trigger VRC SDK avatar build (local test build, not publish). Validates the avatar and builds the AssetBundle.

Parameters:

  • project_path: Unity project path

  • avatar_object: Root avatar GameObject name

Inputs: project_path, avatar_object. Returns: result

unity_configure_pipelineA

One-click full Unity avatar setup pipeline. Imports FBX, configures humanoid rig, sets up avatar descriptor, creates expression menu/params, and configures materials.

Parameters:

  • project_path: Unity project path

  • fbx_path: Path to the FBX file

  • avatar_name: Name for the avatar

  • blueprint_json: Optional JSON with full configuration override. If empty, uses intelligent defaults based on the FBX content.

Inputs: fbx_path, avatar_name, project_path, blueprint_json. Returns: result

unity_configure_shaderA

Configure shader properties on a Unity material. Supports Poiyomi, lilToon, UTS2, and Standard shaders.

Parameters:

  • project_path: Unity project path

  • material_name: Name of the material to configure (or .mat asset path)

  • shader_name: "poiyomi", "liltoon", "uts2", "standard" (default: "poiyomi")

  • properties_json: JSON of property overrides. Format depends on shader: Poiyomi: {"_MainTex": "Assets/Tex/body.png", "_Color": "1,0.9,0.8,1", "_EnableEmission": 1} lilToon: {"_MainTex": "...", "_Color": "...", "_ShadowColor": "0.8,0.7,0.7,1"}

Inputs: shader_name, project_path, material_name, properties_json. Returns: result

unity_create_animation_clipA

Generate a Unity AnimationClip .anim file from JSON blueprint. Used for blend shape animations (face tracking, expressions, toggles).

Parameters:

  • project_path: Unity project path

  • clip_json: JSON defining the clip. Format: {"name": "Smile", "length": 0.0, "curves": [ {"path": "Body", "property": "blendShape.jawOpen", "keys": [{"time": 0, "value": 0}, {"time": 1, "value": 100}]}, {"path": "Body", "property": "m_IsActive", "keys": [{"time": 0, "value": 1}]} ]} For single-frame clips (toggles), use length: 0 and one keyframe.

  • output_path: Where to save the .anim file

Inputs: clip_json, output_path, project_path. Returns: result

unity_create_animatorB

Generate an AnimatorController from a JSON blueprint.

Parameters:

  • project_path: Unity project path

  • animator_json: JSON defining layers/states/transitions. Format: {"layers": [{"name": "FaceTracking", "defaultState": "Idle", "states": [{"name": "Idle", "motion": null}, {"name": "Smile", "motion": "Assets/Anims/Smile.anim"}], "transitions": [{"from": "Idle", "to": "Smile", "conditions": [{"param": "SmileWeight", "mode": "Greater", "threshold": 0.5}]}] }]}

  • output_path: Where to save .controller asset

Inputs: output_path, project_path, animator_json. Returns: result

unity_create_material_presetsB

Generate a set of preset materials for common avatar parts.

Parameters:

  • project_path: Unity project path

  • preset: "avatar_basic" (skin/hair/eye/cloth), "avatar_full" (+ accessory/emission/transparent), "custom"

  • shader_name: Base shader for all materials (default: "liltoon")

  • output_dir: Folder to save materials

Inputs: preset, output_dir, shader_name, project_path. Returns: result

unity_import_fbxA

Import an FBX file into a Unity project and configure import settings. Copies FBX to project, sets humanoid rig type, extracts materials/textures.

Parameters:

  • fbx_path: Path to the FBX file to import

  • project_path: Unity project path. If empty, uses UNITY_PROJECT_PATH.

  • destination: Relative path inside Assets/ (default: "Assets/Models")

  • humanoid_rig: Set animation type to Humanoid (default: True)

  • extract_materials: Extract materials to separate folder (default: True)

  • extract_textures: Extract embedded textures (default: True)

Inputs: fbx_path, destination, humanoid_rig, project_path, +2 more. Returns: result

unity_publish_avatarA

Publish avatar to VRChat. Requires VRC SDK and logged-in session. This tool attempts CLI publish first. If that fails (GUI-only publish flow), it returns instructions for using computer-use MCP to click through the SDK GUI.

Parameters:

  • project_path: Unity project path

  • avatar_object: Root avatar GameObject name in scene

  • avatar_name: Display name on VRChat (default: same as avatar_object)

  • description: Avatar description

  • tags: Comma-separated tags

  • release_status: "private" or "public" (default: "private")

Inputs: tags, avatar_name, description, project_path, +2 more. Returns: result

unity_setup_avatar_descriptorA

Add VRC_AvatarDescriptor to a GameObject in Unity. Configures viewpoint, lip sync, and eye tracking defaults.

Parameters:

  • project_path: Unity project path

  • avatar_object: Name of the root GameObject (usually the FBX prefab name)

  • view_position: Viewpoint offset "x,y,z" (default: "0,1.6,0.3" — between eyes)

  • lip_sync_style: "VisemeBlendShape", "JawBone", "JawFlap" (default: "VisemeBlendShape")

  • auto_detect_visemes: Auto-detect and assign viseme blend shapes (default: True)

Inputs: project_path, avatar_object, view_position, lip_sync_style, +1 more. Returns: result

unity_setup_contactsB

Add VRC ContactSender/ContactReceiver components from JSON blueprint.

Parameters:

  • project_path: Unity project path

  • avatar_object: Root avatar GameObject name

  • contacts_json: JSON array. Format: [{"bonePath": "Armature/Hips/Spine/Head", "type": "Receiver", "collisionTags": ["Head"], "radius": 0.3, "position": "0,0,0", "receiverType": "Proximity", "parameter": "HeadPat"}] type: "Sender" or "Receiver" receiverType (for Receivers): "Proximity", "Constant", "OnEnter"

Inputs: project_path, avatar_object, contacts_json. Returns: result

unity_setup_expression_menuC

Generate VRCExpressionsMenu .asset file from a JSON blueprint.

Parameters:

  • project_path: Unity project path

  • menu_json: JSON string defining menu structure. Format: {"controls": [{"name": "Emotes", "type": "SubMenu", "icon": "", "subMenu": "Assets/VRC/EmotesMenu.asset"}, {"name": "Toggle Hat", "type": "Toggle", "parameter": "HatToggle"}]} Types: Button, Toggle, SubMenu, TwoAxisPuppet, FourAxisPuppet, RadialPuppet

  • output_path: Where to save the .asset file (default: "Assets/VRC/ExpressionMenu.asset")

Inputs: menu_json, output_path, project_path. Returns: result

unity_setup_expression_parametersB

Generate VRCExpressionParameters .asset file from JSON blueprint.

Parameters:

  • project_path: Unity project path

  • parameters_json: JSON string. Format: {"parameters": [{"name": "VRCFaceBlendH", "valueType": "Float", "defaultValue": 0, "saved": true, "synced": true}, {"name": "HatToggle", "valueType": "Bool", "defaultValue": 0, "saved": true, "synced": true}]} valueTypes: Int, Float, Bool

  • output_path: Where to save the .asset file

Inputs: output_path, project_path, parameters_json. Returns: result

unity_setup_gesture_layerB

Create a VRChat Gesture FX layer with hand gesture states. Standard 8 gestures: Neutral, Fist, Open, Point, Peace, RockNRoll, Gun, Thumbsup.

Parameters:

  • project_path: Unity project path

  • output_path: Where to save .controller asset

  • hand_gestures: "default" (standard 8 gestures) or "custom" (empty states for manual setup)

Inputs: output_path, project_path, hand_gestures. Returns: result

unity_setup_physbonesA

Add VRCPhysBone components to an avatar from a JSON blueprint.

Parameters:

  • project_path: Unity project path

  • avatar_object: Root avatar GameObject name

  • physbones_json: JSON array of PhysBone configs. Format: [{"bonePath": "Armature/Hips/Spine/Hair_Root", "pull": 0.2, "spring": 0.8, "stiffness": 0.2, "gravity": 0.1, "gravityFalloff": 0.5, "immobile": 0.3, "radius": 0.05, "colliders": [], "limitType": "Angle", "maxAngle": 45}]

Inputs: project_path, avatar_object, physbones_json. Returns: result

unity_setup_projectA

Configure Unity project path and verify VRChat SDK is installed. Checks for VRCSDK3-AVATAR, required assemblies, and project structure.

Parameters:

  • project_path: Path to Unity project root. If empty, uses UNITY_PROJECT_PATH env var.

  • verify_sdk: Check for VRC SDK presence (default: True)

Inputs: verify_sdk, project_path. Returns: result

uv_add_layerA

Add a new UV layer to an object.

Args: object_name: Target mesh object name: Name for the new UV layer set_active: Make the new layer the active one

Inputs: object_name (required), name, set_active.

uv_get_infoA

Get UV layer info for an object — layer names, island count estimate.

Inputs: object_name (required).

uv_mark_seamsA

Mark UV seams on a mesh.

Args: object_name: Target mesh object edge_indices: Specific edge indices to mark as seams sharp_angle: Auto-mark seams at edges sharper than this angle (degrees, 0=disabled) clear_existing: Clear all existing seams first

Inputs: object_name (required), sharp_angle, edge_indices, clear_existing.

uv_pack_islandsB

Pack UV islands to fill UV space efficiently.

Args: object_name: Target mesh object margin: Margin between islands rotate: Allow island rotation for better packing

Inputs: object_name (required), margin, rotate.

uv_project_from_viewB

Project UV coordinates using simple projection methods.

Args: object_name: Target mesh object projection: cube, cylinder, or sphere scale: UV scale factor

Inputs: object_name (required), scale, projection.

uv_remove_layerB

Remove a UV layer from an object.

Args: object_name: Target mesh object layer_name: Name of the UV layer to remove

Inputs: layer_name (required), object_name (required).

uv_smart_unwrapB

Smart UV Project — automatic UV unwrapping based on face angles.

Works well for hard-surface models, mechanical parts, and props.

Args: object_name: Target mesh object angle_limit: Angle limit for projection (degrees, default 66) island_margin: Margin between UV islands (default 0.02) area_weight: Weight given to face area (0-1)

Inputs: object_name (required), angle_limit, area_weight, island_margin.

uv_unwrapB

UV unwrap a mesh using seam-based unwrapping. Methods: ANGLE_BASED (good default), CONFORMAL (preserves angles better). Margin adds padding between UV islands.

Inputs: name (required), margin, method.

viewport_focus_objectB

Focus the viewport on a specific object (zoom to fit).

Args: object_name: Object to focus on

Inputs: object_name (required).

viewport_set_overlaysA

Configure viewport overlays.

Args: show_overlays: Master overlay toggle show_wireframe: Show wireframe overlay on solid show_face_orientation: Color faces by normal direction (useful for debugging) show_stats: Show scene statistics show_floor: Show grid floor show_axis_x: Show X axis line show_axis_y: Show Y axis line

Inputs: show_floor, show_stats, show_axis_x, show_axis_y, +3 more.

viewport_set_shadingB

Set viewport shading mode.

Args: mode: WIREFRAME, SOLID, MATERIAL, RENDERED studio_light: Studio light name for SOLID mode (e.g., 'studio.exr', 'rim.sl') color_type: MATERIAL, SINGLE, OBJECT, RANDOM, VERTEX, TEXTURE (for SOLID mode)

Inputs: mode, color_type, studio_light.

viewport_set_viewA

Set viewport to a standard view angle.

Args: view: FRONT, BACK, LEFT, RIGHT, TOP, BOTTOM perspective: True for perspective, False for orthographic

Inputs: view, perspective.

vrc_accessory_auto_alignA

Auto-detect and fix misaligned accessories (shoes, hats, etc.) by comparing their bounding box to the target bone position and normalizing scale/rotation. Run this BEFORE vrc_attach_accessory.

Parameters:

  • accessory_name: Name of the accessory mesh to align

  • armature_name: Avatar armature. If empty, uses first found.

  • target_bone: Target bone to align near (e.g., "Left foot"). Optional — used for positioning hint.

  • scale_mode: "auto" (detect and fix), "match_armature" (match armature scale), "none" (skip)

Inputs: scale_mode, target_bone, armature_name, accessory_name. Returns: result

vrc_attach_accessoryB

Attach an accessory object to a bone on the avatar armature. Similar to VRCFury's armature link — parents the accessory, sets up proper hierarchy, and optionally generates a toggle parameter.

Parameters:

  • accessory_name: Name of the accessory object (mesh) to attach

  • target_bone: Bone to attach to (e.g., "Head", "Left_Hand", "Hips")

  • armature_name: Avatar armature. If empty, uses first found.

  • create_toggle: Generate an Expression Menu toggle config (default: True)

  • toggle_parameter: Custom parameter name for toggle. Default: "{accessory_name}_On"

  • auto_scale: Auto-normalize accessory scale to match armature (default: True)

  • rotation_correction: Apply rotation before attach, e.g. "X90", "Z-90", "X90,Y180" (default: none)

Inputs: auto_scale, target_bone, armature_name, create_toggle, +3 more. Returns: result

vrc_auto_weightB

Automatically weight paint a mesh to an armature using Blender's automatic weights (heat map). Sets up the armature modifier.

Parameters:

  • mesh_name: Target mesh. If empty, uses "Body" or first mesh.

  • armature_name: Target armature. If empty, uses first armature.

Inputs: mesh_name, armature_name. Returns: result

vrc_bake_atlasA

Bake multiple materials into a single texture atlas. Re-maps UVs so all materials fit into one texture, reducing material count for better VRChat performance rank.

Parameters:

  • mesh_name: Target mesh. If empty, uses "Body" or first mesh.

  • atlas_size: Atlas texture resolution (default: 2048). Use 1024 for Quest.

  • output_path: Where to save the baked atlas image. If empty, saves next to the .blend file.

Inputs: mesh_name, atlas_size, output_path. Returns: result

vrc_check_export_readyA

Run a comprehensive pre-export checklist for VRChat avatar. Checks: transforms applied, bone naming, visemes, eye tracking, vertex weights, scale, T-pose, material count, poly count.

Parameters:

  • armature_name: Target armature. If empty, uses first found.

  • target: "pc" or "quest" (default: "pc")

Inputs: target, armature_name. Returns: result

vrc_check_weightsA

Check vertex weights for VRChat compatibility issues. Finds: unweighted vertices, excessive bone influences, missing vertex groups.

Parameters:

  • mesh_name: Target mesh. If empty, checks all meshes.

Inputs: mesh_name. Returns: result

vrc_create_humanoid_armatureA

Create a complete VRChat-compatible humanoid armature from scratch. Generates a properly proportioned T-pose skeleton with all required bones.

Parameters:

  • height: Avatar height in meters (default: 1.65)

  • include_fingers: Add finger bones (default: True)

  • include_toes: Add toe bones (default: True)

  • name: Armature object name (default: "Armature")

Inputs: name, height, include_toes, include_fingers. Returns: result

vrc_decimateA

Smart decimation to reach a target VRChat performance rank. Calculates the required ratio and applies a Decimate modifier.

Parameters:

  • target_rank: "excellent", "good", "medium", or "poor" (default: "good")

  • platform: "pc" or "quest" (default: "pc")

  • mesh_name: Target mesh. If empty, decimates all meshes.

  • preserve_shape_keys: Use CATS blend_from_shape technique to repair shape keys after decimation (default: True). This is the gold standard for decimating meshes with shape keys.

Inputs: platform, mesh_name, target_rank, preserve_shape_keys. Returns: result

vrc_dynamics_budgetA

Calculate VRChat Avatar Dynamics budget usage. Checks PhysBones, Contacts, and Constraints against performance rank limits.

Parameters:

  • physbone_chains: JSON array of chains: [{"name": "Hair", "bones": 4, "colliders": 1}, {"name": "Tail", "bones": 6, "colliders": 2}]

  • contacts: JSON array: [{"name": "Headpat", "senders": 1, "receivers": 1}, {"name": "Boop", "senders": 1, "receivers": 1}]

  • target: "pc" or "quest" (default: "pc")

Inputs: target, contacts, physbone_chains. Returns: result

vrc_export_fbxA

Export model as FBX with VRChat-optimized settings. Handles axis conversion, disables leaf bones, applies correct scale.

Parameters:

  • filepath: Full output path (e.g., "D:/models/avatar.fbx")

  • apply_modifiers: Apply modifiers before export (default: True)

  • selected_only: Only export selected objects (default: False)

Inputs: filepath (required), selected_only, apply_modifiers. Returns: result

vrc_fix_modelA

One-click model fix for VRChat (similar to CATS "Fix Model"). Joins meshes, applies transforms, cleans weights, standardizes bone names.

Parameters:

  • armature_name: Target armature. If empty, uses the first armature found.

  • join_meshes: Join all child meshes into one (default: True)

  • apply_transforms: Apply all transforms (default: True)

  • remove_zero_weight_bones: Remove bones with no vertex weights (default: True)

  • standardize_bone_names: Rename bones to VRC standard names (default: True)

  • remove_doubles_distance: Merge vertices closer than this distance (default: 0.0001)

Inputs: join_meshes, armature_name, apply_transforms, standardize_bone_names, +2 more. Returns: result

vrc_generate_animatorA

Generate VRChat FX Animator Controller blueprint. Creates the layer/state/transition structure as JSON that can be imported into Unity or used as a reference for manual setup.

Parameters:

  • toggles: JSON array of toggle items: [{"name": "Hat", "parameter": "Hat_On", "object": "Hat_Mesh", "default_on": false}]

  • gestures: JSON array of gesture-driven expressions: [{"gesture": "Fist", "hand": "Left", "blendshape": "happy", "mesh": "Body"}]

  • radials: JSON array of radial puppet driven properties: [{"name": "Tail Speed", "parameter": "Tail_Speed", "property": "blendshape", "target": "Body/Tail_Wag"}]

Inputs: radials, toggles, gestures. Returns: result

vrc_generate_expression_menuA

Generate a VRChat Expression Menu configuration (JSON blueprint). This creates the menu structure and parameter definitions that you import into Unity's VRC Expression Menu and Expression Parameters.

Parameters:

  • items: JSON array of menu items. Each item: {"name": "Hat Toggle", "type": "Toggle", "parameter": "Hat", "icon": "hat"} {"name": "Color", "type": "RadialPuppet", "parameter": "Color_Hue"} {"name": "Emotes", "type": "SubMenu", "sub_items": [...]} {"name": "Movement", "type": "TwoAxisPuppet", "parameters": {"horizontal": "Move_X", "vertical": "Move_Y"}} Types: Button, Toggle, SubMenu, TwoAxisPuppet, FourAxisPuppet, RadialPuppet

  • menu_name: Root menu name (default: "Main")

Returns a complete menu structure + parameter list with memory usage.

Inputs: items, menu_name. Returns: result

vrc_import_modelA

Import a model file (FBX/VRM/OBJ) and optionally auto-fix it for VRChat. Handles axis conversion, applies transforms, and reports model stats.

Parameters:

  • filepath: Path to the model file

  • auto_fix: Run vrc_fix_model after import (default: True)

  • fbx_preset: FBX axis preset — "default", "unity", "mixamo", or "mmd" (default: "default")

  • apply_transforms: Apply location/rotation/scale on imported objects (default: True)

Inputs: filepath (required), auto_fix, fbx_preset, apply_transforms. Returns: result

vrc_merge_materialsA

Analyze and prepare materials for merging to reduce material slot count. Creates a report of current materials and their UV islands for atlas preparation. Can auto-merge materials that share identical settings.

Parameters:

  • mesh_name: Target mesh. If empty, uses "Body" or first mesh.

  • target_count: Desired material count (default: 1)

Inputs: mesh_name, target_count. Returns: result

vrc_physbone_configB

Generate VRChat PhysBone configuration for a bone chain. Creates a JSON config with tuned physics parameters for Unity import.

Parameters:

  • chain_name: Name of the bone chain root (e.g., "Hair_Front_01")

  • preset: Physics preset: "hair_long", "hair_short", "tail", "ears", "skirt", "breast", "ribbon", "chain_accessory"

  • custom_config: JSON override for specific parameters. Example: '{"pull": 0.3, "gravity": 0.5}'

Inputs: preset, chain_name, custom_config. Returns: result

vrc_rename_bonesA

Rename bones from common naming schemes (Mixamo, MMD, VRM, Blender) to VRChat-compatible standard names. Also updates vertex groups.

Parameters:

  • armature_name: Target armature name. If empty, uses first armature found.

Inputs: armature_name. Returns: result

vrc_setup_contactsA

Set up VRChat Contact Senders and Receivers on the avatar. Creates marker bones at the correct positions for contact detection. The actual ContactSender/ContactReceiver components are added in Unity, but this tool places the bones and generates the Unity configuration JSON.

Parameters:

  • preset: Use a preset: "headpat", "boop", "handshake", "hug", or "all"

  • custom_contacts: JSON for custom contacts: [{"name": "MyContact", "parent_bone": "Head", "position": [0,0.1,0], "radius": 0.1, "tags": ["Head"], "role": "receiver", "receiver_type": "Proximity", "parameter": "MyParam"}]

  • armature_name: Target armature. If empty, uses first found.

Inputs: preset, armature_name, custom_contacts. Returns: result

vrc_setup_eye_trackingA

Set up VRChat eye tracking: creates eye tracking blend shapes and optionally eye bones.

Parameters:

  • mesh_name: Target mesh for blend shapes. If empty, auto-detects.

  • create_bones: Create Left_Eye and Right_Eye bones if missing (default: True)

Inputs: mesh_name, create_bones. Returns: result

vrc_setup_gesturesA

Set up gesture-driven blendshapes. Creates shape keys for each hand gesture and generates the Animator Controller configuration.

VRC Gestures: Neutral(0), Fist(1), HandOpen(2), FingerPoint(3), Victory(4), RockNRoll(5), HandGun(6), ThumbsUp(7)

Parameters:

  • mesh_name: Face mesh. If empty, auto-detects.

  • mapping: JSON mapping of gesture to blendshape name. Example: '{"Fist": "angry", "Victory": "peace_sign", "HandOpen": "surprised"}' If empty, creates template shape keys for all gestures.

Inputs: mapping, mesh_name. Returns: result

vrc_setup_physbone_chainA

Create a bone chain for VRChat PhysBones (hair, tail, ears, skirt, etc.). Creates bones in Blender; PhysBone components are configured in Unity.

Parameters:

  • armature_name: Target armature. If empty, uses first found.

  • parent_bone: Name of the bone to attach the chain to (e.g., "Head" for hair)

  • chain_name: Name prefix for the chain (e.g., "Hair_Front", "Tail")

  • bone_count: Number of bones in the chain (default: 4, recommended: 3-6)

  • chain_length: Total length of the chain in meters (default: 0.3)

  • direction: "down" (hair/skirt), "back" (tail), "left", "right" (ears)

Inputs: direction, bone_count, chain_name, parent_bone, +2 more. Returns: result

vrc_setup_visemesA

Set up VRChat viseme shape keys (lip sync) on a mesh.

Parameters:

  • mesh_name: Target mesh. If empty, uses mesh named "Body" or the first mesh found.

  • mode: "template" creates empty viseme shape keys as placeholders. "rename" renames existing shape keys using source_mapping. "from_mmd" auto-maps MMD vowel shapes (あいうえお) to VRC visemes. "from_base_shapes" generates all 15 visemes by blending 3 base mouth shapes (CATS technique). Requires source_mapping with keys: mouth_a, mouth_o, mouth_ch. Example: '{"mouth_a": "あ", "mouth_o": "お", "mouth_ch": "い"}'

  • source_mapping: JSON mapping. Usage depends on mode.

Inputs: mode, mesh_name, source_mapping. Returns: result

vrc_validateA

Validate a model against VRChat performance rank limits. Reports polygon count, bone count, material count, mesh count, and which rank (Excellent/Good/Medium/Poor/Very Poor) the model falls into.

Parameters:

  • target: "pc" or "quest" (default: "pc")

  • object_name: Specific armature/mesh name. If empty, analyzes entire scene.

Inputs: target, object_name. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    C2.7/5.0

    Scored across 307 tools

    Disambiguation1/5

    The tool set is riddled with overlapping and duplicate operations: add_modifier vs modifier_add, set_keyframe vs anim_insert_keyframe, create_armature vs armature_create, material_list vs list_materials, smart_uv_project vs uv_smart_unwrap, add_rigid_body vs physics_add_rigid_body, render_image vs render_still, export_scene vs io_export_*, and many more. An agent would constantly struggle to know which of several near-identical tools to call.

    Naming Consistency1/5

    Naming is chaotic: verb-first names like create_object and delete_object sit alongside domain-first names like modifier_add and anim_insert_keyframe, and the same action appears in both styles (add_modifier/modifier_add, create_collection/scene_create_collection, create_armature/armature_create). Prefixes are applied arbitrarily across dozens of domains, with no consistent pattern.

    Tool Count1/5

    With 307 tools, this is an extreme mismatch for an MCP server's typical scope. The count is 5-10x even what a very heavy integration should expose, and the massive redundancy makes the size worse rather than more useful. It overwhelms agents and violates the principle that each tool should earn its place.

    Completeness4/5

    Coverage across the Blender and VRChat avatar workflow is remarkably broad: modeling, sculpting, materials, modifiers, animation, physics, UV, geometry nodes, rigging, Unity integration, rendering, and import/export are all represented. Minor gaps exist, such as no direct material deletion, no delete_collection, and no bone removal tool, but these are workarounds via execute_code or scene_cleanup.

    Maintenance

    ActivitySlowing
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers