Claude & GPT with Blender

import bpy
import bmesh
 
def fresh_collection(name: str) -> bpy.types.Collection:
    """Get or create a collection, then empty it."""
    col = bpy.data.collections.get(name)
    if col is None:
        col = bpy.data.collections.new(name)
        bpy.context.scene.collection.children.link(col)
    for ob in list(col.objects):
        data = ob.data
        bpy.data.objects.remove(ob, do_unlink=True)
        mesh = isinstance(data, bpy.types.Mesh)
        if mesh and not data.users:
            bpy.data.meshes.remove(data)
    return col
 
def pbr(name: str, rgb: tuple, rough: float = 0.8):
    """Principled BSDF material, reused by name."""
    mat = bpy.data.materials.get(name)
    if mat is None:
        mat = bpy.data.materials.new(name)
    bsdf = mat.node_tree.nodes["Principled BSDF"]
    bsdf.inputs["Base Color"].default_value = (*rgb, 1)
    bsdf.inputs["Roughness"].default_value = rough
    return mat
 
def box(col, name, size, loc, mat=None):
    """Box of size (x, y, z) meters; loc is its center."""
    me = bpy.data.meshes.new(name)
    bm = bmesh.new()
    bmesh.ops.create_cube(bm, size=1.0)
    bmesh.ops.scale(bm, vec=size, verts=bm.verts)
    bm.to_mesh(me)
    bm.free()
    if mat:
        me.materials.append(mat)
    ob = bpy.data.objects.new(name, me)
    ob.location = loc
    col.objects.link(ob)
    return ob
 
col = fresh_collection("House")
wall = pbr("M_Wall", (0.8, 0.75, 0.65))
roof = pbr("M_Roof", (0.5, 0.15, 0.1), rough=0.6)
box(col, "House_Walls", (6, 4, 3), (0, 0, 1.5), wall)
box(col, "House_Roof", (6.4, 4.4, 0.2), (0, 0, 3.1), roof)

import json
 
def scene_report() -> str:
    """Names, sizes and triangle counts as JSON."""
    rows = []
    for ob in bpy.context.scene.objects:
        row = {"name": ob.name, "type": ob.type,
               "size_m": [round(d, 3)
                          for d in ob.dimensions],
               "loc": [round(v, 3) for v in ob.location]}
        if ob.type == "MESH":
            me = ob.data
            row["tris"] = sum(len(p.vertices) - 2
                              for p in me.polygons)
            row["mats"] = [m.name for m in me.materials if m]
        rows.append(row)
    return json.dumps(rows, indent=1)
 
text = scene_report()
bpy.context.window_manager.clipboard = text  # paste in chat

brew install uv                      # macOS; see uv docs
uvx mcp-for-blender install-addon    # copies the add-on
 
# Claude Code (the -- separates the server command)
claude mcp add --transport stdio blender \
  -- uvx mcp-for-blender
claude mcp list                      # check; /mcp inside
 
# Codex CLI, desktop app, IDE extension, ChatGPT desktop
codex mcp add blender -- uvx mcp-for-blender
codex mcp list

{
  "mcpServers": {
    "blender": {
      "command": "uvx",
      "args": ["mcp-for-blender"],
      "env": {
        "BLENDER_MCP_SAFE_MODE": "1",
        "DISABLE_TELEMETRY": "true"
      }
    }
  }
}

You write Python for Blender 5.2 (bpy). Rules:
- Units are meters. Z is up, -Y is the front, the ground is Z = 0.
- Everything goes in a collection named "<Job>". At the start, get or create it and delete its
  objects, so running the script twice gives the same scene.
- Name every object and material (SM_Wall_2m, M_Brick). Never leave "Cube.001".
- Prefer modifiers (Array, Mirror, Bevel, Solidify, Boolean) over destructive edits.
- Materials: Principled BSDF, image textures only, so they survive glTF export.
- Do only the step I ask for, then stop.
- End by printing JSON: name, size in meters, triangle count per object.
- If you're not sure an API exists in 5.x, say so instead of guessing.

LOW-POLY HOUSE
Step 1: a low-poly cottage on a 1 m grid in collection "Cottage": 6 × 4 m footprint,
3 m walls 0.2 m thick, a 0.9 × 2.1 m door centered on the front (-Y), two 1.2 × 1.0 m
windows at sill height 0.9 m (Boolean modifiers, not applied), gable roof with 0.3 m
overhang, materials M_Plaster, M_RoofTile, M_Wood. Print the JSON summary.

MODULAR WALL KIT
Make a modular wall kit in collection "Kit_Wall", each piece its own object with the
origin at the bottom-left corner on the grid: SM_Wall_2m (2 × 0.2 × 3 m), SM_Wall_Door_2m,
SM_Wall_Window_2m, SM_Corner_Out, SM_Corner_In, SM_Floor_2m. Pieces must tile with no
gaps when snapped at 2 m. Lay them out in a row 3 m apart for review.

STREET SCENE BLOCKOUT (MCP with Poly Haven on)
Block out a 40 m street: 8 m road along Y, 2 m sidewalks, simple box buildings 6-12 m
tall on both sides (separate objects, 0.5 m gaps). Then search Poly Haven for an overcast
HDRI, asphalt and concrete textures, and 3-4 street props (bench, bin, lamp); import them,
scale to real size, and place props on the sidewalks. Screenshot from a street-level camera.

TURNTABLE
Add a turntable: an empty at the origin with a camera parented 6 m away and 2 m up,
Track To the empty, 120 frames, linear rotation 0-360° (no ease at the loop), and render
settings for a 1080 × 1080 MP4 preview with EEVEE.

BATCH EXPORT
Export every object in collection "Kit_Wall" to its own GLB in //export/, each moved to
the world origin for export and moved back after, modifiers applied, +Y up. Print the file
names and sizes.

import bpy
import math
from bpy_extras import anim_utils
 
def turntable(frames: int = 120, dist: float = 6.0,
              height: float = 2.0) -> bpy.types.Object:
    """Camera orbiting 0,0,0 once, at constant speed."""
    sc = bpy.context.scene
    pivot = bpy.data.objects.new("Turntable", None)
    cam_data = bpy.data.cameras.new("TurntableCam")
    cam = bpy.data.objects.new("TurntableCam", cam_data)
    for ob in (pivot, cam):
        sc.collection.objects.link(ob)
    cam.parent = pivot
    cam.location = (0, -dist, height)
    track = cam.constraints.new("TRACK_TO")
    track.target = pivot  # always look at the center
    sc.camera = cam
    sc.frame_start, sc.frame_end = 1, frames
    pivot.rotation_euler.z = 0
    pivot.keyframe_insert("rotation_euler", index=2,
                          frame=1)
    pivot.rotation_euler.z = 2 * math.pi
    pivot.keyframe_insert("rotation_euler", index=2,
                          frame=frames + 1)  # seamless loop
    ad = pivot.animation_data
    bag = anim_utils.action_get_channelbag_for_slot(
        ad.action, ad.action_slot)  # 4.4+ slotted actions
    for fc in bag.fcurves:
        for kp in fc.keyframe_points:
            kp.interpolation = "LINEAR"
    return cam

 prompt one step ──► script / tool call ──► run in Blender (save first)
      ▲                                           │
      │                                           ▼
 fix: paste the traceback,            inspect: JSON report (sizes, tris, names),
 or say what's wrong in meters  ◄──── viewport screenshot or preview render,
                                      your own eyes in the viewport
      │
      └─► when right: commit (save a numbered .blend copy), next step

def preview(path: str = "//preview.png", px: int = 768):
    """Fast solid-shaded render from the active camera."""
    sc = bpy.context.scene
    sc.render.engine = "BLENDER_WORKBENCH"
    sc.render.resolution_x = sc.render.resolution_y = px
    sc.render.filepath = path
    bpy.ops.render.render(write_still=True)

1. Blender 5.x with MCP for Blender running; Claude Desktop or Claude Code connected.
2. Paste the preamble, then the LOW-POLY HOUSE prompt (walls only first).
3. After each step: "screenshot from the front and from the top; list sizes".
4. Next steps: openings → roof → trim → materials → a ground plane.
5. Save cottage_v01.blend, v02… between steps.
6. Finish by hand: bevels, UVs, textures (/3d/blender/materials-uv/), then export.

1. Paste the preamble and MODULAR WALL KIT into ChatGPT (or Claude).
2. Read the script, paste it into a new text in Blender, Alt P.
3. Run scene_report(), paste the JSON back: "the door piece is 2.1 m wide,
   it must be 2.0 m".
4. Repeat until it tiles; then run export_each() below.

1. MCP for Blender with the Poly Haven checkbox on (no key needed; assets are CC0).
2. STREET SCENE BLOCKOUT prompt.
3. Ask for a camera at 1.7 m eye height and a screenshot; fix scale and gaps.
4. Replace box buildings with kit pieces or AI props (/3d/ai-workflows/ai-generation/).
5. Keep the HDRI for Blender renders; engines need their own sky setup.

1. Model at the origin, on the ground, real size.
2. Run turntable() (above) or the TURNTABLE prompt.
3. Render: EEVEE, 1080 × 1080, 120 frames, FFmpeg MP4 (or a PNG sequence).
4. For an interactive version, export GLB and use OrbitControls with autoRotate.

import os
import bpy
 
def export_each(col_name: str, out_dir: str) -> None:
    """One GLB per object in a collection."""
    os.makedirs(out_dir, exist_ok=True)
    for ob in bpy.data.collections[col_name].objects:
        bpy.ops.object.select_all(action="DESELECT")
        ob.select_set(True)
        bpy.context.view_layer.objects.active = ob
        bpy.ops.export_scene.gltf(
            filepath=os.path.join(out_dir, ob.name + ".glb"),
            export_format="GLB",
            use_selection=True,
            export_apply=True,  # apply modifiers
        )
 
export_each("Kit_Wall", bpy.path.abspath("//export"))

1. Add the Higgsfield connector in Claude; sign in.
2. "Create a new 3D scene: a small market stall under string lights, meter scale,
   camera at eye height, portable Principled materials."
3. Ask for a preview render after each change; name the objects you want changed.
4. Download the .glb (web) or .blend (keep editing locally).
5. Open the .blend in your Blender, review it, then export per target.