Skip to main content
Glama
rhino-mcp

rhino-mcp

by rokibul-mist

rhino-mcp

Drive McNeel Rhino 8 and Grasshopper from Claude through the Model Context Protocol.

PyPI Python License Rhino MCP Platform

English · 한국어


Overview

rhino-mcp is a Model Context Protocol server that lets Claude (or any MCP client) drive Rhino 8 — creating geometry, manipulating layers and materials, baking Grasshopper output, exporting STEP/IGES/STL/OBJ — through plain natural-language tool calls. It runs in two modes:

  • Standalone (default): backed by rhino3dm for headless .3dm file authoring; works without Rhino installed and exposes ~242 tools (geometry, file-I/O, transform, layer, material, analysis, RhinoScript docs, composition, document hygiene, geometry validation, GH template catalogue, freeform skin / panelisation / curvature / fields, drawing-set sheet + title block, schedule / quantity, block definition, sun-position + shadow projection, BIM metadata tagging, 19 physical material presets, BRE daylight factor + Bird DNI clear-sky model, and multi-Rhino announcement-file discovery).

  • Bridge: when the C# bridge plugin is loaded in a live Rhino 8 session, the server transparently forwards every call (booleans, lofts, sweeps, viewport image capture + zoom-to-object / zoom-to-layer, render, scripting (Python and gated Roslyn C# with timeouts and extra references), deformation, NURBS editing, SubD, paneling, freeform analysis with true Gaussian curvature, drawing-set view placement + section cuts + PDF export, accurate Brep-area schedules, block explode/redefine, ray-cast solar exposure + Brep ray probe, IFC / gbXML import-export, HDRI environment, camera / light / render / turntable automation, layer-material binding, and every Grasshopper operation including batched connect_many wiring and slider placement) to RhinoCommon and Grasshopper.Instances, exposing ~245 tools.

Related MCP server: GOLEM-3DMCP-Rhino-

Features

  • Full geometry catalogue — points, lines, polylines, arcs, circles, ellipses, polygons, helixes, NURBS curves, rebuilds.

  • Solids and meshes — boxes, spheres, cylinders, cones, tori, mesh boxes; booleans / sweeps / lofts / fillets via the bridge.

  • Transforms — move, rotate, scale, mirror, plane-to-plane orient, linear/polar/rectangular arrays.

  • Script execution — run arbitrary RhinoScript Python (IronPython) or RhinoCommon C# (Roslyn) code in a live Rhino session, with built-in RhinoScript API documentation search (899 functions).

  • Advanced modeling — deformation (bend/twist/taper/flow), NURBS editing (rebuild/unroll/evaluate), SubD, surface matching, extraction (dup edge/border/isocurve/Make2D), control points, and paneling tools.

  • Drawing-set authoring — sheet / title block / north arrow / scale bar in standalone; multi-view placement, section cuts, and PDF export through the bridge.

  • Quantity & schedule — per-layer / per-material / per-user_text aggregation with CSV export; bridge mode uses AreaMassProperties / VolumeMassProperties for accurate Brep area + volume.

  • Block / instance reuse — define / insert / list blocks in standalone; explode / redefine in bridge mode for synchronized component edits.

  • Environmental analysis — sun position + monthly sun-path polylines + shadow projection (NOAA SPA approximation); ray-cast solar exposure in bridge mode. Daylight precision adds Bird DNI clear-sky model with Kasten-Young air mass and Linke turbidity, plus BRE simplified daylight factor.

  • BIM interchange — IFC2x3 / IFC4 / IFC4x3 import & export, gbXML export, and IFC PropertySet metadata tagging that round-trips through user_text.

  • Material presets + HDRI — 19 bundled physical presets (concrete / brick / steel / aluminium / glass / timber / stone / plaster / fabric / landscape) keyed by category; HDRI environment for rendering.

  • Render automation — camera / light / render-engine setup, render-to-file, and parametric turntable sequences (bridge mode).

  • Undo / redo and batch operations — every bridge operation is wrapped in undo records; batch modify changes many objects in a single call.

  • Layers, materials, blocks, groups — full attribute control on the document.

  • File I/O — open/save .3dm, export OBJ/STL standalone; STEP/IGES/DXF and screenshots via the bridge.

  • Inline base64 screenshots — rhino_screenshot(as_base64=True) returns the PNG payload inline for visual verification by the LLM.

  • Rich object selection — rhino_object_select filters by glob name pattern, layer, RGB color, object type, and user-text key/value pairs.

  • Pagination on bulk queries — rhino_list_objects returns a pagination: {total, offset, limit, returned, has_more} block so large documents stay manageable.

  • Scene composition shortcuts (v0.2) — rhino_place_grid, rhino_stack_floors, rhino_scatter, rhino_replicate_along_curve collapse "loop + transform" into a single tool call.

  • Document hygiene tools (v0.2) — query/set units, tolerances, and base point (rhino_document_units_*, rhino_tolerance_*, rhino_origin_set); rhino_document_summary exposes them so the LLM can verify scale before issuing geometry calls.

  • Geometry validation (v0.2) — rhino_validate_brep, rhino_report_mesh_health, rhino_curve_continuity, plus rhino_check_naked_edges (bridge) for explicit topology diagnostics before booleans / exports.

  • Grasshopper template loader (v0.2) — gh_template_list reads a manifest of pre-wired definitions; gh_load_template, gh_bind_template_parameter, gh_run_template (bridge) load, parameterise, and bake them.

  • Free-form architecture toolkit — rhino_skin_from_sections, rhino_uv_grid_panels, rhino_panel_planarity, rhino_panel_curvature_classify, rhino_surface_developable_score, rhino_attractor_displace_points, rhino_smooth_polyline. Bridge mode adds true Gaussian / mean / principal curvature, world-axis slicing, and waffle ribs.

  • Strategy prompts for the LLM — seven @mcp.prompt() guides (general_strategy, rhinoscript_workflow, viewport_workflow, parametric_workflow, bim_authoring_workflow, design_dialogue_workflow, freeform_workflow) help Claude pick the right tool, avoid hallucinated APIs, and keep the user in the loop on design decisions.

  • Async-capable tools — read-only query tools run on async def so concurrent bridge round-trips don't stall the MCP transport.

  • Robust connection layer — JSON-RPC over named pipe / Unix socket / TCP with MSG_PEEK liveness probes and exponential backoff with jitter on reconnect.

  • Grasshopper automation — open .gh files, drop components, wire them, set sliders/panels/toggles, run, bake, read DataTrees.

  • Three transports — stdio (Claude Desktop), Streamable HTTP, Docker/TCP.

  • Capability-aware registration — bridge-only tools are simply not registered when no bridge is reachable; no stub functions, ever.

  • Actionable errors — every failure carries a category, a remediation hint, and details the agent can act on.

Architecture

┌──────────────┐     stdio | HTTP     ┌────────────────┐
│  Claude /    │ ◀──────────────────▶ │   rhino-mcp    │
│  MCP client  │                      │   (Python)     │
└──────────────┘                      └─────┬──────────┘
                                            │
                              JSON-RPC 2.0  │   (named pipe / unix socket / TCP)
                                            │
                                  ┌─────────▼──────────┐
                                  │  C# Bridge Plugin  │
                                  │  (inside Rhino 8)  │
                                  │  ────────────────  │
                                  │  RhinoCommon       │
                                  │  Grasshopper       │
                                  │  Roslyn (C# exec)  │
                                  │  IronPython (Py)   │
                                  └────────────────────┘

In standalone mode the right-hand side is replaced by an in-process rhino3dm.File3dm document; bridge-only tools are unregistered.

Requirements

  • Python 3.11 or newer

  • rhino3dm >= 8.9, mcp[cli] >= 1.2, pydantic >= 2.6 (installed automatically)

  • Optional: McNeel Rhino 8 (any platform) — needed only for bridge mode

  • Optional: .NET 8 SDK — to build the C# bridge plugin (dotnet build)

  • Optional: pywin32 on Windows for the named-pipe transport

Installation

uv tool install rhino-mcp
# or, from a checkout:
uv sync && uv run rhino-mcp

Using pip

pip install rhino3dm-mcp
rhino-mcp --version

One-shot Claude Desktop wiring

After installing the package, register the server with Claude Desktop in a single command instead of editing claude_desktop_config.json by hand:

rhino-mcp install                         # auto-detect launcher (uvx / rhino-mcp / python)
rhino-mcp install --mode bridge           # force bridge mode in the env block
rhino-mcp install --force                 # overwrite an existing entry
rhino-mcp install --dry-run               # preview the JSON without writing

The command writes a timestamped .bak.* copy of the existing config before saving, and is idempotent — re-running with the same flags is a no-op. Restart Claude Desktop afterwards to pick up the change.

From inside Rhino — _McpInstall

If the bridge plugin is loaded, type _McpInstall on the Rhino command line. The command is non-interactive: it locates uvx / rhino-mcp / python on PATH (with ~/.local/bin, ~/.cargo/bin, /opt/homebrew/bin, and /usr/local/bin searched on macOS so the GUI-app PATH is enough), runs the same install pipeline as rhino-mcp install, and streams the outcome to the Rhino command line. The MCP server is registered with --mode auto so Claude Desktop attaches to the bridge when Rhino is running and falls back to standalone (rhino3dm) when it is not.

Docker

docker compose -f docker/docker-compose.yml up --build

The container exposes the server over Streamable HTTP on TCP :8765.

Running the server

rhino-mcp is normally launched by an MCP client (Claude Desktop / Cursor / claude.ai connector) via the command + args you put into the client's config. You can also run it manually for debugging.

Launch modes

Use case

Command

Stdio (Claude Desktop default)

uvx rhino3dm-mcp or rhino-mcp

Streamable HTTP (local dev / Cursor)

rhino-mcp --transport http --host 127.0.0.1 --port 8765

Streamable HTTP (claude.ai connector)

rhino-mcp --transport http --host 0.0.0.0 --port 8765 --allow-external --stateless

Docker (HTTP on :8765)

docker compose -f docker/docker-compose.yml up --build

Force standalone (no Rhino needed)

RHINO_MCP_FORCE_MODE=standalone rhino-mcp

Force bridge (fail fast if Rhino down)

RHINO_MCP_FORCE_MODE=bridge rhino-mcp

Force bridge with HTTP fallback

RHINO_MCP_FORCE_MODE=bridge RHINO_MCP_BRIDGE_OPTIONAL=1 rhino-mcp --transport http

Show all CLI flags

rhino-mcp --help

The HTTP endpoint is http://<host>:<port>/mcp. Use --allow-external only when exposing the server through ngrok / Cloudflare Tunnel / etc. — it disables DNS-rebinding protection.

Claude Desktop (stdio)

claude_desktop_config.json lives at:

OS

Path

macOS

~/Library/Application Support/Claude/claude_desktop_config.json

Windows

%APPDATA%\Claude\claude_desktop_config.json

Linux

~/.config/Claude/claude_desktop_config.json

Paste this entry under mcpServers:

{
  "mcpServers": {
    "rhino-mcp": {
      "command": "uvx",
      "args": ["rhino3dm-mcp"],
      "env": {
        "RHINO_MCP_TRANSPORT": "stdio",
        "RHINO_HOST": "127.0.0.1",
        "RHINO_PORT": "4242",
        "RHINO_MCP_LOG_LEVEL": "INFO"
      }
    }
  }
}

Prefer a checkout? Point command at uv and run from the repo:

{
  "mcpServers": {
    "rhino-mcp": {
      "command": "uv",
      "args": ["--directory", "/absolute/path/to/rhino-mcp", "run", "rhino-mcp"],
      "env": { "RHINO_MCP_LOG_LEVEL": "DEBUG" }
    }
  }
}

Restart Claude Desktop; the rhino-mcp tools and the three strategy prompts (general_strategy, rhinoscript_workflow, viewport_workflow) appear in the palette.

Cursor IDE

Cursor reads ~/.cursor/mcp.json (global) or <project>/.cursor/mcp.json (per-project):

{
  "mcpServers": {
    "rhino-mcp": {
      "command": "uvx",
      "args": ["rhino3dm-mcp"],
      "env": { "RHINO_MCP_FORCE_MODE": "bridge" }
    }
  }
}

claude.ai remote connector (Streamable HTTP)

  1. Run the server with HTTP + external access:

    rhino-mcp --transport http --host 0.0.0.0 --port 8765 --allow-external --stateless
  2. Tunnel it (e.g. ngrok http 8765) and grab the public HTTPS URL.

  3. In claude.ai → Settings → Connectors → Add custom connector, set the URL to https://<your-tunnel>/mcp.

Generic stdio MCP clients

Any MCP-compatible client (mcp-inspector, Continue, Claude Code, etc.) that can spawn a subprocess will work — give it uvx rhino3dm-mcp or the path to your rhino-mcp entry-point and inherit env vars from the table below.

Build and install the C# plugin for full 235 tool support. The included helper script wraps dotnet build and verifies the post-build install location:

./scripts/build-plugin.sh             # debug build + install
./scripts/build-plugin.sh --release   # release build
./scripts/build-plugin.sh --clean     # clean + rebuild

# Or invoke dotnet directly:
dotnet build rhino_plugin/csharp/RhinoMCPPlugin.csproj -c Release

Post-build targets copy the .rhp:

OS

Path

macOS

/Applications/Rhino 8.app/Contents/PlugIns/rhino-mcp.rhp

Windows

%APPDATA%/McNeel/Rhinoceros/8.0/Plug-ins/rhino-mcp/rhino-mcp.rhp

Restart Rhino 8 — the bridge starts automatically on load (TCP :4242 by default). Then restart rhino-mcp (or set RHINO_MCP_FORCE_MODE=bridge) and the bridge-only tools become available.

Quick start

# After "rhino-mcp" is configured in Claude Desktop, ask Claude:
#   "Create a 10-unit sphere at the origin and save the document to /tmp/demo.3dm"
# Behind the scenes Claude calls rhino_sphere → rhino_save.

Strategy prompts

Three MCP prompts are registered automatically and surfaced in the client's prompt picker:

Prompt

When to use

general_strategy

Decision tree for orienting in a document → choosing the right tool → best practices.

rhinoscript_workflow

Mandatory steps before invoking rhino_execute_python so the LLM doesn't hallucinate APIs.

viewport_workflow

How to combine rhino_zoom_extent + rhino_screenshot(as_base64=True) for visual checks.

Telling Claude "use the general_strategy prompt before you start" gives much better tool selection on long sessions.

Visual verification with base64 screenshots

"Build a 5x5x5 box on layer 'Demo', then take a 1280x720 base64 screenshot so you can confirm it landed."

Claude calls rhino_box → rhino_zoom_extent → rhino_screenshot(as_base64=True) and reads the inline PNG from the response (image_base64 field) on the next turn.

Pagination & rich filtering

"List the first 50 curves on the 'Walls' layer, then select every object whose name matches 'Pillar_*' on layer 'Structure'."

rhino_list_objects returns a pagination block; iterate with offset += limit until has_more is false. rhino_object_select accepts name_pattern, layer, color, object_type, user_text, and deselect_first.

Standalone smoke run from the shell:

RHINO_MCP_FORCE_MODE=standalone uv run python - <<'PY'
import asyncio
from rhino_mcp.server import build_server
from rhino_mcp.utils.registry import Mode

mcp, count = build_server(runtime_mode=Mode.STANDALONE, bridge_client=None)
print(f"{count} tools registered")
sphere = asyncio.run(
    mcp._tool_manager._tools["rhino_sphere"].run(
        {"args": {"center": {"x": 0, "y": 0, "z": 0}, "radius": 10.0}}
    )
)
print(sphere)
PY

Tools reference (summary)

Category

Standalone

+ Bridge

Notable members

Geometry

14

14

rhino_point, rhino_circle, rhino_helix, rhino_nurbs_curve, rhino_rebuild_curve

Curves

3

3

rhino_curve_length, rhino_curve_point_at, rhino_curve_split

Solids

5

10

rhino_box, rhino_sphere, rhino_boolean_union (bridge)

Surfaces

0

11

rhino_loft, rhino_sweep1, rhino_revolve

Mesh

1

8

rhino_mesh_box, rhino_weld_mesh (bridge)

Transform

9

11

rhino_array_polar, rhino_orient, rhino_flow (bridge)

Annotation

2

8

rhino_text_dot, rhino_dimension_linear (bridge)

Layer / Object

6

8

rhino_layer_create, rhino_block_insert (bridge)

Material

2

3

rhino_material_create, rhino_render_viewport (bridge)

File I/O

5

9

rhino_save, rhino_export_step (bridge)

Analysis

4

9

rhino_volume, rhino_zebra (bridge)

Query

7

8

rhino_list_objects, rhino_document_summary, rhino_get_selected_objects (bridge)

Display

0

5

rhino_zoom_extent, rhino_named_view_save

Scripting

0

2

rhino_execute_python, rhino_execute_csharp

RS Docs

4

4

rhino_search_rhinoscript_functions, rhino_get_rhinoscript_docs

History

0

2

rhino_undo, rhino_redo

Batch

0

1

rhino_batch_modify

Deformation

0

4

rhino_bend, rhino_twist, rhino_taper, rhino_flow_along_curve

NURBS

0

5

rhino_rebuild_surface, rhino_unroll, rhino_surface_from_points

SubD

0

2

rhino_create_subd, rhino_subd_to_nurbs

Srf Match

0

3

rhino_match_surface, rhino_blend_surface_edges, rhino_merge_surfaces

Extraction

0

4

rhino_dup_edge, rhino_dup_border, rhino_isocurve, rhino_make2d

Ctrl Points

0

2

rhino_get_control_points, rhino_set_control_points

Paneling

0

3

rhino_panelize_surface, rhino_create_uv_grid, rhino_panel_frames

Grasshopper

0

22

gh_set_slider, gh_bake_to_rhino, gh_data_tree_get

Drawing

2

5

rhino_drawing_sheet_create, rhino_drawing_title_block_add, rhino_drawing_view_place (bridge)

Schedule

5

5

rhino_schedule_by_layer, rhino_schedule_by_user_text, rhino_object_quantity

Blocks

3

5

rhino_block_define, rhino_block_insert, rhino_block_explode (bridge)

Environment

3

4

rhino_sun_position, rhino_sun_path, rhino_shadow_project

Freeform

8

11

rhino_skin_from_sections, rhino_panel_curvature_classify, rhino_attractor_displace_points

BIM I/O

1

4

rhino_bim_metadata_set, rhino_export_ifc (bridge), rhino_import_ifc (bridge), rhino_export_gbxml (bridge)

Materials+

2

3

rhino_material_preset_list, rhino_material_preset_create, rhino_environment_set (bridge)

Render

0

5

rhino_camera_set, rhino_light_add, rhino_render_setup, rhino_render_to_file, rhino_turntable_render

Daylight

2

2

rhino_direct_irradiance, rhino_daylight_factor

Detailed signatures live in docs/en/tools-reference.md.

Grasshopper integration

1. Start Rhino 8 → open Grasshopper → load your `.gh` definition.
2. Ensure the C# bridge plugin (`rhino-mcp.rhp`) is loaded in Rhino.
3. Set `RHINO_MCP_FORCE_MODE=bridge` and restart rhino-mcp.
4. From Claude:
   - "Open /work/wing.gh, set the 'span' slider to 12.5, run, bake to layer 'Wing'."
   - "Read the output of the 'Voronoi' component as a DataTree."

See docs/en/grasshopper-guide.md for canvas/component/cluster recipes.

Configuration

Every knob is controlled by an environment variable. CLI flags override env where applicable.

Variable

Default

Purpose

RHINO_MCP_TRANSPORT

stdio

stdio or http (Streamable HTTP)

RHINO_MCP_FORCE_MODE

(auto)

Force standalone or bridge

RHINO_MCP_BRIDGE_OPTIONAL

0

When 1 and RHINO_MCP_FORCE_MODE=bridge, fall back to standalone if the bridge is unreachable (recommended for HTTP connectors).

RHINO_MCP_TRANSPORT_KIND

(auto)

Bridge transport selector: pipe / unix / tcp

RHINO_HOST, RHINO_PORT

localhost:4242

TCP transport endpoint

RHINO_MCP_PIPE

rhino_mcp

Windows named-pipe name

RHINO_MCP_SOCKET

(XDG runtime)

Unix socket path override

RHINO_MCP_BRIDGE_TIMEOUT

1 (auto), 5 (forced)

Seconds to wait for a bridge ping

RHINO_MCP_RECONNECT_RETRIES

1

Max reconnect attempts after a transient transport failure

RHINO_MCP_RECONNECT_BASE_DELAY

0.5

Base delay (seconds) for exponential backoff

RHINO_MCP_RECONNECT_JITTER

0.25

Symmetric jitter ratio (0 disables, useful for tests)

RHINO_MCP_LOG_LEVEL

INFO

Stderr log level. Set DEBUG to see every bridge JSON-RPC call.

Development

git clone https://github.com/easehee/rhino-mcp.git
cd rhino-mcp
uv venv && source .venv/bin/activate
uv pip install -e '.[dev]'

# Tests + coverage
uv run pytest --cov=src/rhino_mcp

# Lint + type check
uv run ruff check src/ tests/
uv run mypy src/rhino_mcp

# Build the C# bridge plugin (auto-installs into Rhino on macOS/Windows)
./scripts/build-plugin.sh --release

# Wheel + sdist
./scripts/build.sh

Manual smoke test against a running server

# Terminal A — start the server with verbose logging
RHINO_MCP_LOG_LEVEL=DEBUG rhino-mcp --transport http --port 8765

# Terminal B — list tools via the MCP inspector or a curl probe
npx @modelcontextprotocol/inspector http://127.0.0.1:8765/mcp

Troubleshooting

Symptom

Likely cause / remediation

Cannot reach Rhino bridge.

Start Rhino 8 with the C# bridge plugin loaded; verify RHINO_HOST/RHINO_PORT.

Bridge-only tool absent in Claude

Server is in standalone mode — load the bridge plugin or set RHINO_MCP_FORCE_MODE=bridge.

Invalid parameter: axis (cylinder)

Standalone supports only {x:0,y:0,z:1}; switch to bridge for arbitrary axes.

non-3DM import error

Standalone import is .3dm-only; use bridge mode for STEP/IGES/DXF.

transport failure on tcp://...

The bridge crashed or Rhino was closed — rhino-mcp will reconnect with exponential backoff (RHINO_MCP_RECONNECT_RETRIES).

Stdout corrupted under stdio transport

Always log to stderr; rhino-mcp does this — verify no third-party libraries print to stdout.

image_base64 missing from screenshot

Caller passed as_base64=False (default) or the screenshot file failed to write — check the summary.path and base64_error fields.

Pagination loops forever

Always advance offset by pagination.returned, not by limit; the last page may be partial.

rhino_object_select returns 0 matches

Filters AND together — try removing one filter at a time; the color filter only works on objects with ColorSource=ColorFromObject.

More in docs/en/troubleshooting.md.

License

MIT — see LICENSE.

Available Tools

542 tools
gh_add_componentB

Drop a Grasshopper component onto the active canvas.

Inputs: args (required). Returns: object

gh_bake_to_rhinoB

Bake the output of one or more components into the active Rhino document.

Inputs: args (required). Returns: object

gh_bind_template_parameterA

Set a single named parameter on a loaded template (slider / panel / toggle).

Inputs: args (required). Returns: object

gh_cluster_createB

Group components into a named cluster.

Inputs: args (required). Returns: object

gh_cluster_expandC

Expand a cluster back into its constituent components.

Inputs: args (required). Returns: object

gh_component_listA
Read-onlyIdempotent

List components currently on the active canvas (optionally filtered).

Inputs: args (required). Returns: object

gh_connect_componentsB

Create a wire from one component output to another component input.

Inputs: args (required). Returns: object

gh_connect_manyA

Add multiple wires in a single round-trip.

    Returns a per-row ``results`` array so partial failures are visible
    (each row carries ``status`` and, on error, ``error``).
    

Inputs: args (required). Returns: object

gh_data_tree_getB
Read-only

Read a component output as a DataTree (list of branches).

Inputs: args (required). Returns: object

gh_data_tree_get_batchA
Read-only

Read multiple component outputs in a single bridge round-trip.

Inputs: args (required). Returns: object

gh_data_tree_setC

Push a DataTree into a component input.

Inputs: args (required). Returns: object

gh_data_tree_set_batchA

Apply many DataTree assignments at once with a single GH solve.

    With ``defer_solve=True`` (default) the GH document is paused while
    the assignments are applied and recomputed exactly once at the end —
    critical for parameter sweeps where N independent ``set`` calls
    would otherwise trigger N solver runs.
    

Inputs: args (required). Returns: object

gh_delete_componentB
Destructive

Remove a component from the canvas.

Inputs: args (required). Returns: object

gh_get_parameterB
Read-only

Read the current value of a component parameter.

Inputs: args (required). Returns: object

gh_load_templateC

Open a bundled template on the canvas and return its template_id + parameter map.

Inputs: args (required). Returns: object

gh_new_canvasB

Create a fresh empty Grasshopper canvas.

Inputs: args (required). Returns: object

gh_open_fileC

Open a Grasshopper definition.

Inputs: args (required). Returns: object

gh_place_sliderA

Create a Number Slider on the canvas with bounds and initial value.

    Returns the new ``component_id`` so subsequent ``gh_connect_components``
    or ``gh_set_slider`` calls can target it.
    

Inputs: args (required). Returns: object

gh_plugin_listA
Read-onlyIdempotent

Enumerate Grasshopper plugin libraries currently loaded.

    Returns one entry per ``GH_AssemblyInfo`` library: id, name, author,
    version, description, and the on-disk path. Useful for the LLM to
    discover whether the user has LunchBox / Ladybug / Kangaroo etc.
    installed before attempting to drop in a custom component.
    

Inputs: args (required). Returns: object

gh_preview_toggleA

Toggle preview on/off for a list of components (or all).

Inputs: args (required). Returns: object

gh_resetA
Destructive

Reset the canvas (clear cached solution).

Inputs: no named parameters. Returns: object

gh_runC

Run the current solution.

Inputs: args (required). Returns: object

gh_run_templateC

Force a fresh solution and (optionally) bake the declared outputs.

Inputs: args (required). Returns: object

gh_save_fileA

Save the active Grasshopper definition.

Inputs: args (required). Returns: object

gh_set_panelB

Set the text contents of a Panel component.

Inputs: args (required). Returns: object

gh_set_parameterC

Push a value into a component parameter.

Inputs: args (required). Returns: object

gh_set_sliderC

Set a Number Slider component to a numeric value.

Inputs: args (required). Returns: object

gh_set_toggleB

Set a Boolean Toggle component to true or false.

Inputs: args (required). Returns: object

gh_template_listA
Read-only

List bundled Grasshopper templates with their parameter contracts.

    ``available=False`` means the .gh binary has not been shipped yet —
    the contract is described in the manifest but loading it will fail
    until the binary is placed alongside the manifest.
    

Inputs: args (required). Returns: object

rhino_1viewA

Maximize the active viewport to fill the entire viewport area.

Inputs: no named parameters. Returns: result

rhino_3viewA

Switch to the three-viewport layout.

Inputs: no named parameters. Returns: result

rhino_4viewA

Switch to the standard four-viewport layout (Top, Front, Right, Perspective).

Inputs: no named parameters. Returns: result

rhino_add_clipping_planeD

Enter clipping plane creation mode.

Inputs: no named parameters. Returns: result

rhino_add_control_pointA

Add a control point to the end of a selected NURBS curve in the U direction.

Inputs: no named parameters. Returns: result

rhino_add_dimension_angularB

Enter angular dimension placement mode.

Inputs: no named parameters. Returns: result

rhino_add_dimension_linearB

Enter linear dimension placement mode.

Inputs: no named parameters. Returns: result

rhino_add_dimension_ordinateC

Enter ordinate dimension placement mode.

Inputs: no named parameters. Returns: result

rhino_add_dimension_radialB

Enter radial (radius) dimension placement mode.

Inputs: no named parameters. Returns: result

rhino_add_directional_lightC
    Add a directional light to the scene.
    
    Args:
    direction_x, direction_y, direction_z: Light direction vector.
    

Inputs: direction_x, direction_y, direction_z. Returns: result

rhino_add_dotC
    Add a small text dot annotation at a 3D location.
    
    Args:
    text: Dot label text.
    x, y, z: Location coordinates.
    

Inputs: x, y, z, text. Returns: result

rhino_add_hatchB
    Add a hatch fill to a selected closed curve.
    
    Args:
    hatch_pattern: Hatch pattern name (e.g. 'Solid', 'Grid', 'Dots').
    scale: Pattern scale factor.
    

Inputs: scale, hatch_pattern. Returns: result

rhino_add_leaderB

Enter leader annotation placement mode.

Inputs: no named parameters. Returns: result

rhino_add_objects_to_blockA
    Add currently selected objects to an existing block definition.
    
    Args:
    name: Block definition name to add objects into.
    

Inputs: name (required). Returns: result

rhino_add_pointA
    Add a single point object at the given coordinates.
    
    Args:
    x, y, z: Point coordinates.
    

Inputs: x, y, z. Returns: result

rhino_add_point_cloudC
    Add a point cloud object from a list of 3D coordinates.
    
    Args:
    points: List of (x, y, z) tuples.
    

Inputs: points (required). Returns: result

rhino_add_point_lightA
    Add an omnidirectional point light at the specified location.
    
    Args:
    x, y, z: Light position.
    

Inputs: x, y, z. Returns: result

rhino_add_spotlightA
    Add a spotlight to the scene.
    
    Args:
    x, y, z: Spotlight position.
    target_x, target_y, target_z: Target/aim point.
    radius: Spotlight cone radius.
    

Inputs: x, y, z, radius, +3 more. Returns: result

rhino_add_textB
    Add a 3D text annotation object at a specific location.
    
    Args:
    text: The text string to display.
    x, y, z: Insertion point coordinates.
    height: Text height in model units.
    font: Font face name.
    

Inputs: text (required), x, y, z, +2 more. Returns: result

rhino_add_text_objectC
    Add a text object via Rhino command.
    
    Args:
    text: Text string.
    x, y, z: Insertion point.
    height: Text height.
    

Inputs: text (required), x, y, z, +1 more. Returns: result

rhino_alignC
    Align selected objects in a given direction.
    
    Valid directions: Left, Right, Top, Bottom, Vertical, Horizontal,
    Center, Middle.
    
    Args:
    controller: RhinoController instance.
    direction: Alignment direction keyword.
    
    Returns:
    Dict with command result.
    

Inputs: direction. Returns: result

rhino_align_mesh_verticesB
    Align mesh vertices that are within the given tolerance of each other.
    
    Args:
    controller: RhinoController instance.
    tolerance: Distance tolerance for vertex alignment.
    

Inputs: tolerance. Returns: result

rhino_angleB
    Measure the angle between two lines (interactive).
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

Inputs: no named parameters. Returns: result

rhino_annotation_calloutC

Add a callout (leader + balloon or boxed label).

Inputs: args (required). Returns: object

rhino_annotation_dimension_styleC

Register a reusable dimension style (bridge only — Rhino DimStyle table).

Inputs: args (required). Returns: object

rhino_annotation_north_arrowA

Draw a north arrow centred on location.

    ``angle_deg`` rotates the arrow clockwise from world +Y so callers can
    adapt to a site whose true north differs from grid north.
    

Inputs: args (required). Returns: object

rhino_annotation_revision_cloudA

Draw a revision cloud (bumpy polyline) around a region of interest with a revision label.

Inputs: args (required). Returns: object

rhino_annotation_scale_barA

Draw a divided scale bar with a label.

    Bar is drawn in document units; the label reports the represented
    real-world distance based on ``scale_denominator``.
    

Inputs: args (required). Returns: object

rhino_arcB

Add an arc by centre, radius, and sweep angle (in degrees).

Inputs: args (required). Returns: object

rhino_areaA
Read-onlyIdempotent

Compute the surface area of a mesh (Brep area requires bridge).

Inputs: args (required). Returns: object

rhino_area_centroidA
    Calculate the area centroid (centre of mass) of selected surfaces.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result containing centroid coordinates.
    

Inputs: no named parameters. Returns: result

rhino_array_linearC

Array objects along a vector with constant spacing.

Inputs: args (required). Returns: object

rhino_array_on_curveB
    Array selected objects along a curve.
    
    The curve must be selected after the objects (interactive).
    
    Args:
    controller: RhinoController instance.
    count: Number of copies along the curve.
    
    Returns:
    Dict with command result.
    

Inputs: count. Returns: result

rhino_array_polarC

Array objects in a polar pattern.

Inputs: args (required). Returns: object

rhino_array_rectangularC

Array objects in a 3D rectangular grid.

Inputs: args (required). Returns: object

rhino_assign_material_to_objectB
    Assign a named material to the currently selected objects.
    
    Args:
    material_name: Name of the render material to assign.
    

Inputs: material_name (required). Returns: result

rhino_attractor_displace_pointsA

Displace each input point along the vector to an attractor with a falloff.

    Positive ``strength`` pulls toward the attractor; negative pushes
    away. The attractor is either a fixed point (``attractor_point``)
    or a curve (``attractor_curve_id``); for curves each point's
    attractor is the closest sample on the curve.

    Returns the *new* point IDs (the originals are deleted; this is a
    form-finding move, not a duplicating one).
    

Inputs: args (required). Returns: object

rhino_axis_ribsA

Generate two orthogonal sets of section ribs (waffle-style fabrication, bridge only).

Inputs: args (required). Returns: object

rhino_batch_callA

Dispatch multiple bridge methods in a single round-trip.

    IMPORTANT: ``steps[].method`` is a **bridge dispatcher route**, not
    an MCP tool name. The MCP tool ``rhino_layer_create`` maps to the
    dispatcher route ``rhino.layer.create``; ``rhino_document_summary``
    maps to ``rhino.query.document_summary`` (NOT ``rhino.document.summary``).
    Standalone-only tools (``rhino_set_user_text`` etc. that have no
    ``bridge_call`` path) cannot be batched. A wrong route name returns
    an ``error`` row with ``HandlerError``; the batch aborts when
    ``on_error='stop'``.

    Measured impact (v0.6.x, localhost): direct sequential layer.create
    ~580ms/op vs batched ~340ms/op — N x ~240ms saved per batch (the
    MCP↔bridge round-trip cost paid once instead of N times). Effective
    for any workflow that issues >5 bridge calls back-to-back.

    Returns ``{summary: {total, ok, failed, on_error}, results: [...]}``
    where each ``results`` entry has ``index``, ``method``, ``status``
    (``"ok"`` | ``"error"``), and either ``result`` or ``error``.
    

Inputs: args (required). Returns: object

rhino_batch_modifyA

Modify many objects in a single call.

    Each spec can include any combination of: translation, rotation,
    scale, colour, layer, visibility, and name.  All changes are wrapped
    in one undo record — ``rhino_undo(steps=1)`` reverts the entire batch.

    When ``apply_to_all`` is ``True``, the modifications from the first
    spec are applied to every object in the document.
    

Inputs: args (required). Returns: object

rhino_bendC

Bend objects along an axis through a specified point.

Inputs: args (required). Returns: object

rhino_bim_metadata_setA

Tag objects with IFC entity + property-set metadata.

    Standalone writes ``Pset_RhinoMcp::<key>`` user_text on each object;
    bridge mode does the same and additionally pushes into Rhino's IFC
    property-set table so a subsequent IFC export carries them across.
    

Inputs: args (required). Returns: object

rhino_bim_pset_deleteB
Destructive

Remove every property under a named PropertySet from an object.

Inputs: args (required). Returns: object

rhino_bim_pset_getA
Read-onlyIdempotent

Read PropertySet entries off an object.

    Bridge mode reads from the live RhinoCommon UserString table; standalone
    mode reads from rhino3dm UserStrings on the saved 3dm document. The
    result groups properties by PropertySet name (``psets`` field).
    

Inputs: args (required). Returns: object

rhino_bim_pset_setC

Persist a PropertySet block on an object.

Inputs: args (required). Returns: object

rhino_blend_srfA
    Create a blend surface between two surface edges.
    
    Pre-select the two naked edges before calling.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: no named parameters. Returns: result

rhino_blend_surfaceB

Create a blend surface between two edges.

Inputs: args (required). Returns: object

rhino_blend_surface_edgesB

Create a blend surface connecting two surface edges with continuity control.

Inputs: args (required). Returns: object

rhino_block_defineA

Create a block definition from a list of objects.

    Standalone uses ``rhino3dm.InstanceDefinitionGeometry`` to register
    the geometry under ``name``. Bridge mode mirrors that and additionally
    replaces the source objects with a single instance at the base point
    when ``replace_objects=True``.
    

Inputs: args (required). Returns: object

rhino_block_explodeC

Explode a block instance into individual objects (bridge only).

Inputs: args (required). Returns: object

rhino_block_insertB

Insert a block instance at insertion_point with optional scale + rotation.

    Standalone constructs a ``rhino3dm.InstanceReferenceGeometry`` and
    applies the transform to it. Bridge mode forwards to RhinoCommon's
    ``Doc.Objects.AddInstanceObject`` which honours the active layer
    and links the instance to the definition.
    

Inputs: args (required). Returns: object

rhino_block_instance_countC
    Return the number of instances of a specific block definition.
    
    Args:
    name: Block definition name.
    

Inputs: name (required). Returns: result

rhino_block_listB
Read-only

List every block definition with a per-definition object + instance count.

Inputs: args (required). Returns: object

rhino_block_managerB

Open the Block Manager dialog.

Inputs: no named parameters. Returns: result

rhino_block_redefineA

Replace a block definition's geometry, propagating to every instance (bridge only).

Inputs: args (required). Returns: object

rhino_boolean_differenceA
Destructive

Subtract b_ids from a_ids. Bridge required.

Inputs: args (required). Returns: object

rhino_boolean_intersectionB
Destructive

Intersect a_ids with b_ids. Bridge required.

Inputs: args (required). Returns: object

rhino_boolean_splitC
    Boolean split: split objects with cutting surfaces / polysurfaces.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_boolean_unionB
Destructive

Boolean-union the given Brep groups. Bridge required.

Inputs: args (required). Returns: object

rhino_bounding_boxB
Read-onlyIdempotent

Return the union bounding box of one or more objects.

Inputs: args (required). Returns: object

rhino_boxC

Add a rectangular box (axis-aligned in standalone mode).

Inputs: args (required). Returns: object

rhino_bridge_list_instancesA
Read-onlyIdempotent

Enumerate live Rhino bridge endpoints discovered via announcement files.

    Returns one row per running Rhino on this host. Each row carries
    ``pid``, ``host``, ``port``, ``doc_path``, ``doc_title``, version, and
    an ``alive`` flag derived from a cheap TCP probe.
    

Inputs: args (required). Returns: object

rhino_bridge_select_instanceA

Switch the next bridge call to target a specific Rhino session.

    Exactly one selector among ``pid``, ``port``, ``doc_path_contains``,
    and ``index`` should be set. The active bridge client is closed; the
    next tool call goes through lazy promotion against the new endpoint.
    

Inputs: args (required). Returns: object

rhino_cage_editC

Deform objects with a control cage (bridge only).

Inputs: args (required). Returns: object

rhino_camera_setB

Position the active viewport's camera (location + target + lens length).

Inputs: args (required). Returns: object

rhino_cap_holesB

Cap all open holes of a Brep.

Inputs: args (required). Returns: object

rhino_cap_planar_holesA
    Cap planar holes in open polysurfaces to create closed solids.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_chamfer_edgesB
    Chamfer the selected edges of a polysurface or solid.
    
    Args:
    controller: RhinoController instance.
    distance: Chamfer distance.
    
    Returns:
    Dict with command result.
    

Inputs: distance. Returns: result

rhino_chamfer_surfaceB
    Create a chamfer surface between two selected surfaces.
    
    Args:
    controller: RhinoController instance.
    distance: Chamfer distance.
    
    Returns:
    Dict with command result.
    

Inputs: distance. Returns: result

rhino_check_bad_objectsA
    Check selected objects for validity and report solid status.
    
    Uses rhinoscriptsyntax to inspect each selected object and report
    whether it is valid/solid or has issues.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result containing validity report.
    

Inputs: no named parameters. Returns: result

rhino_check_naked_edgesA
Read-only

Enumerate naked edges of a Brep with their lengths (bridge only).

    Standalone rhino3dm cannot enumerate naked edges. In bridge mode this
    forwards to ``Rhino.Geometry.Brep.GetNakedEdges`` and returns
    ``[{edge_index, length}, ...]`` plus the gap count.
    

Inputs: args (required). Returns: object

rhino_circleA

Add a circle by centre and radius (optionally on a custom plane).

Inputs: args (required). Returns: object

rhino_clipping_planeB

Add a clipping plane to all viewports.

Inputs: args (required). Returns: object

rhino_close_holeB
    Close (cap) a planar hole in an open polysurface or mesh.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_cmd_arcA
    Draw an arc by center, radius, and angular span.
    
    Rhino's Arc command (center mode) prompts:
    center -> radius -> start angle -> end angle.
    
    Args:
    controller:   RhinoController instance.
    cx, cy, cz:   Center of the arc circle.
    radius:       Arc radius.
    start_angle:  Starting angle in degrees (measured from +X axis).
    end_angle:    Ending angle in degrees.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: cx (required), cy (required), cz (required), radius (required), +2 more. Returns: result

rhino_cmd_areaB
    Calculate the area of selected closed curves, hatches, or surfaces.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result containing area information.
    

Inputs: no named parameters. Returns: result

rhino_cmd_array_linearC
    Create a rectangular/linear array of selected objects.
    
    Args:
    controller: RhinoController instance.
    count_x: Number of items in X direction.
    count_y: Number of items in Y direction.
    count_z: Number of items in Z direction.
    spacing_x: Spacing between items in X.
    spacing_y: Spacing between items in Y.
    spacing_z: Spacing between items in Z.
    
    Returns:
    Dict with command result.
    

Inputs: count_x, count_y, count_z, spacing_x, +2 more. Returns: result

rhino_cmd_array_polarB
    Create a polar array of selected objects around a center point.
    
    Args:
    controller: RhinoController instance.
    count: Total number of items (including original).
    angle: Total angle to fill in degrees.
    cx: X coordinate of the array center.
    cy: Y coordinate of the array center.
    cz: Z coordinate of the array center.
    
    Returns:
    Dict with command result.
    

Inputs: cx, cy, cz, angle, +1 more. Returns: result

rhino_cmd_bendB
    Apply a bend deformation to selected objects.
    
    Args:
    controller: RhinoController instance.
    angle: Bend angle in degrees.
    symmetric: If True, bend is symmetric about the midpoint.
    
    Returns:
    Dict with command result.
    

Inputs: angle, symmetric. Returns: result

rhino_cmd_boolean_differenceC
    Boolean difference: subtract selected cutters from base objects.
    
    Args:
    controller: RhinoController instance.
    delete_input: Delete input cutter objects after the operation.
    

Inputs: delete_input. Returns: result

rhino_cmd_boolean_intersectionC
    Boolean intersection of selected closed polysurfaces / solids.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_cmd_boolean_unionC
    Boolean union of selected closed polysurfaces / solids.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_cmd_bounding_boxA
    Return the world-axis-aligned bounding box of selected objects.
    
    Uses rhinoscriptsyntax so that the result can be parsed programmatically.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result containing bounding-box corner points.
    

Inputs: no named parameters. Returns: result

rhino_cmd_boxA
    Create a box (rectangular cuboid) in Rhino.
    
    The box is defined by its bottom-left-front corner (x, y, z) and its
    opposite corner derived from length/width, then extruded to *height*.
    
    Args:
    controller: RhinoController instance.
    x, y, z:   World-space origin of the box base corner.
    length:     Size along the X axis.
    width:      Size along the Y axis.
    height:     Extrusion height along the Z axis.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: x, y, z, width, +2 more. Returns: result

rhino_cmd_circleB
    Draw a circle by center and radius.
    
    Args:
    controller: RhinoController instance.
    cx, cy, cz: World-space center of the circle.
    radius:     Circle radius.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: cx (required), cy (required), cz (required), radius (required). Returns: result

rhino_cmd_coneA
    Create a cone in Rhino.
    
    Args:
    controller: RhinoController instance.
    x, y, z:   Center of the base circle.
    radius:     Base radius.
    height:     Height of the cone (apex above base).
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: x, y, z, height, +1 more. Returns: result

rhino_cmd_contourA
    Create contour curves on selected surfaces or meshes.
    
    The contour base point and direction are picked interactively.
    
    Args:
    controller: RhinoController instance.
    spacing: Distance between contour planes.
    
    Returns:
    Dict with command result.
    

Inputs: spacing. Returns: result

rhino_cmd_curvature_analysisB
    Display curvature analysis on selected surfaces.
    
    Valid styles: Gaussian, Mean, MinRadius, MaxRadius.
    
    Args:
    controller: RhinoController instance.
    style: Type of curvature analysis to display.
    
    Returns:
    Dict with command result.
    

Inputs: style. Returns: result

rhino_cmd_cylinderB
    Create a closed cylinder in Rhino.
    
    Args:
    controller: RhinoController instance.
    x, y, z:   Center of the base circle.
    radius:     Base radius.
    height:     Height of the cylinder.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: x, y, z, height, +1 more. Returns: result

rhino_cmd_distanceB
    Measure the distance between two points.
    
    If pt1/pt2 are provided they should be formatted as "x,y,z" strings.
    Otherwise the command runs interactively.
    
    Args:
    controller: RhinoController instance.
    pt1: Optional first point as "x,y,z".
    pt2: Optional second point as "x,y,z".
    
    Returns:
    Dict with command result.
    

Inputs: pt1, pt2. Returns: result

rhino_cmd_ellipseB
    Draw an ellipse by center, X semi-axis, and Y semi-axis.
    
    Args:
    controller: RhinoController instance.
    cx, cy, cz: Center of the ellipse.
    rx:         Semi-axis radius along X.
    ry:         Semi-axis radius along Y.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: cx (required), cy (required), cz (required), rx (required), +1 more. Returns: result

rhino_cmd_fillet_surfaceC
    Create a fillet surface between two selected surfaces.
    
    Args:
    controller: RhinoController instance.
    radius: Fillet radius.
    
    Returns:
    Dict with command result.
    

Inputs: radius. Returns: result

rhino_cmd_flow_along_curveA
    Flow (morph) selected objects along a curve.
    
    Requires an existing base curve and a target curve to be selected
    interactively.
    
    Args:
    controller: RhinoController instance.
    preserve_structure: If True, the original NURBS structure is preserved.
    
    Returns:
    Dict with command result.
    

Inputs: preserve_structure. Returns: result

rhino_cmd_get_user_textB
    Retrieve custom user text value for a given key from selected objects.
    
    Args:
    key: Attribute key name.
    

Inputs: key (required). Returns: result

rhino_cmd_helixA
    Create a cylindrical helix curve in Rhino.
    
    This is a special case of rhino_spiral where start_radius == end_radius.
    
    Args:
    controller: RhinoController instance.
    x, y, z:   Base point (axis start).
    pitch:      Vertical distance per full turn.
    turns:      Number of full turns.
    radius:     Constant radius of the helix.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: x (required), y (required), z (required), pitch, +2 more. Returns: result

rhino_cmd_importC
    Import geometry from an external file into the current document.
    
    Args:
    controller: RhinoController instance.
    file_path: Absolute path to the file to import.
    
    Returns:
    Dict with command result.
    

Inputs: file_path (required). Returns: result

rhino_cmd_layer_createB
    Create a new layer.
    
    Args:
    name: Layer name (supports :: for sub-layers, e.g. 'Parent::Child').
    color_rgb: Optional comma-separated RGB string, e.g. '255,0,0'.
    parent: Optional parent layer name.
    

Inputs: name (required), parent, color_rgb. Returns: result

rhino_cmd_layer_deleteB
    Delete a layer and all its objects.
    
    Args:
    name: Name of the layer to delete.
    

Inputs: name (required). Returns: result

rhino_cmd_layer_listA

Return a list of all layer names in the document.

Inputs: no named parameters. Returns: result

rhino_cmd_lineC
    Draw a straight line between two world-space points.
    
    Args:
    controller:       RhinoController instance.
    x1, y1, z1:      Start point.
    x2, y2, z2:      End point.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +2 more. Returns: result

rhino_cmd_loftA
    Loft through a set of profile curves.
    
    The curves are first selected using *curve_selection*, then the Loft
    command is run with the requested style.
    
    Args:
    controller:       RhinoController instance.
    curve_selection:  Rhino command to select the profile curves
    (default '_SelLast').
    style:            Loft style keyword: Normal | Loose | Tight |
    Straight | Developable | Uniform.
    closed:           If True, adds '_Closed=_Yes' to create a
    closed (periodic) loft.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: style, closed, curve_selection. Returns: result

rhino_cmd_mesh_boolean_differenceC
    Boolean difference of selected closed meshes.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_cmd_mesh_boolean_unionC
    Boolean union of selected closed meshes.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_cmd_mirrorB
    Mirror selected objects about a named world plane.
    
    Supported planes: 'WorldXY', 'WorldYZ', 'WorldXZ'.
    
    Args:
    controller: RhinoController instance.
    plane: Mirror plane identifier.
    
    Returns:
    Dict with command result.
    

Inputs: plane. Returns: result

rhino_cmd_moveB
    Move selected objects by a displacement vector (dx, dy, dz).
    
    Uses a Python script via rhinoscriptsyntax so that the displacement can be
    applied programmatically to every currently-selected object.
    
    Args:
    controller: RhinoController instance.
    dx: Displacement along X axis.
    dy: Displacement along Y axis.
    dz: Displacement along Z axis.
    
    Returns:
    Dict with command result.
    

Inputs: dx, dy, dz. Returns: result

rhino_cmd_offset_surfaceB
    Offset a selected surface or polysurface.
    
    Args:
    controller: RhinoController instance.
    distance: Offset distance.
    solid: If True, create a solid (shelled) offset.
    
    Returns:
    Dict with command result.
    

Inputs: solid, distance. Returns: result

rhino_cmd_patchB
    Fit a patch surface to the selected curves or point objects.
    
    Args:
    controller: RhinoController instance.
    u_spans:    Number of surface spans in the U direction.
    v_spans:    Number of surface spans in the V direction.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: u_spans, v_spans. Returns: result

rhino_cmd_plane_surfaceB
    Create a flat rectangular NURBS surface in Rhino.
    
    Args:
    controller: RhinoController instance.
    x, y, z:   First corner of the surface.
    length:     Size along the X axis.
    width:      Size along the Y axis.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: x, y, z, width, +1 more. Returns: result

rhino_cmd_polygonA
    Draw a regular polygon by center and circumradius.
    
    Args:
    controller: RhinoController instance.
    cx, cy, cz: Center of the polygon.
    sides:      Number of sides (>= 3).
    radius:     Circumradius (vertex distance from center).
    inscribed:  If True, polygon is inscribed in a circle of *radius*;
    if False, polygon is circumscribed around that circle.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: cx (required), cy (required), cz (required), sides, +2 more. Returns: result

rhino_cmd_polylineC
    Draw an open polyline through a list of 3-D points.
    
    Args:
    controller: RhinoController instance.
    points:     Ordered list of (x, y, z) tuples (>= 2 required).
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: points (required). Returns: result

rhino_cmd_rebuild_curveB
    Rebuild the selected curve with a specified number of control points and degree.
    
    The curve must be pre-selected before calling this function.
    
    Args:
    controller:   RhinoController instance.
    point_count:  Target number of control points.
    degree:       Target polynomial degree.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: degree, point_count. Returns: result

rhino_cmd_rectangleC
    Draw a planar rectangle defined by two corner points.
    
    Args:
    controller: RhinoController instance.
    x, y, z:   First corner of the rectangle.
    width:      Size along the X axis.
    height:     Size along the Y axis.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: x (required), y (required), z (required), width (required), +1 more. Returns: result

rhino_cmd_redoC
    Redo one or more operations.
    
    Args:
    controller: RhinoController instance.
    steps: Number of redo steps (default 1).
    
    Returns:
    Dict with the result of the last redo command.
    

Inputs: steps. Returns: result

rhino_cmd_reduce_meshB
    Reduce the polygon count of selected meshes.
    
    Args:
    controller: RhinoController instance.
    polygon_percentage: Target polygon count as a percentage of original.
    allow_distortion: Allow some geometric distortion to achieve target count.
    

Inputs: allow_distortion, polygon_percentage. Returns: result

rhino_cmd_render_to_fileB
    Render the scene and save the result to a file.
    
    Args:
    file_name: Output filename (saved to D:/RhinoFiles/).
    width: Render width in pixels.
    height: Render height in pixels.
    

Inputs: width, height, file_name. Returns: result

rhino_cmd_revolveA
    Revolve the selected profile curve around the World Z axis.
    
    The profile curve and axis start/end points must be pre-selected or
    implied by the current selection.  The axis is assumed to run along
    the world Z axis through the origin (0,0,0) -> (0,0,1).
    
    Args:
    controller:   RhinoController instance.
    angle:        Total revolution angle in degrees (360 = full solid).
    start_angle:  Starting angle in degrees (0 = +X direction).
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: angle, start_angle. Returns: result

rhino_cmd_rotateA
    Rotate selected objects around a center point in the active construction plane.
    
    For a true 3-D axis rotation use :func:`rhino_rotate_3d` instead.
    
    Args:
    controller: RhinoController instance.
    cx: X coordinate of the rotation center.
    cy: Y coordinate of the rotation center.
    cz: Z coordinate of the rotation center (ignored for planar rotate).
    angle: Rotation angle in degrees.
    axis: Axis hint ('x', 'y', 'z') – kept for API symmetry; planar Rotate
    always rotates about the CPlane normal.
    
    Returns:
    Dict with command result.
    

Inputs: cx, cy, cz, axis, +1 more. Returns: result

rhino_cmd_saveB
    Save the current document to its existing file path.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

Inputs: no named parameters. Returns: result

rhino_cmd_scaleB
    Uniformly scale selected objects about a center point.
    
    Args:
    controller: RhinoController instance.
    cx: X coordinate of the scale origin.
    cy: Y coordinate of the scale origin.
    cz: Z coordinate of the scale origin.
    factor: Scale factor (>1 enlarges, <1 shrinks).
    
    Returns:
    Dict with command result.
    

Inputs: cx, cy, cz, factor. Returns: result

rhino_cmd_sectionA
    Create a cross-section curve through selected surfaces at a plane.
    
    The plane origin and normal are set interactively in Rhino.
    
    Args:
    controller: RhinoController instance.
    plane: Named plane hint ('WorldXY', 'WorldYZ', 'WorldXZ').
    
    Returns:
    Dict with command result.
    

Inputs: plane. Returns: result

rhino_cmd_set_user_textC
    Attach custom key/value user text metadata to selected objects.
    
    Args:
    key: Attribute key name.
    value: Attribute value string.
    

Inputs: key (required), value (required). Returns: result

rhino_cmd_shellB
    Shell selected solid, removing one or more faces and offsetting the rest.
    
    Args:
    controller: RhinoController instance.
    thickness: Shell wall thickness.
    

Inputs: thickness. Returns: result

rhino_cmd_sphereC
    Create a sphere in Rhino.
    
    Args:
    controller: RhinoController instance.
    x, y, z:   World-space center point.
    radius:     Sphere radius.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: x, y, z, radius. Returns: result

rhino_cmd_spiralA
    Create a spiral (conical helix) curve in Rhino.
    
    Rhino Spiral prompts: axis start -> axis end -> start radius -> end radius.
    We place the axis start at (x, y, z) and axis end at (x, y, z + pitch*turns).
    
    Args:
    controller:    RhinoController instance.
    x, y, z:       Base point (axis start).
    pitch:         Vertical distance per turn.
    turns:         Number of full turns.
    start_radius:  Radius at the base of the spiral.
    end_radius:    Radius at the top of the spiral.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: x (required), y (required), z (required), pitch, +3 more. Returns: result

rhino_cmd_sweep1B
    Sweep a profile curve along a single rail curve.
    
    Typical workflow:
    1. Select the rail curve with *rail_select*.
    2. Select the profile curve(s) with *profile_select*.
    3. Run Sweep1 and accept defaults.
    
    Args:
    controller:      RhinoController instance.
    rail_select:     Rhino command to select the rail curve.
    profile_select:  Rhino command to select the profile curve(s).
    closed:          If True, produces a closed sweep.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: closed, rail_select, profile_select. Returns: result

rhino_cmd_sweep2A
    Sweep a profile along two rail curves.
    
    Pre-select the two rail curves and at least one profile curve before
    calling this function.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: no named parameters. Returns: result

rhino_cmd_taperB
    Apply a taper deformation to selected objects.
    
    The taper axis and extent are picked interactively after the command starts.
    
    Args:
    controller: RhinoController instance.
    angle: Taper angle in degrees.
    
    Returns:
    Dict with command result.
    

Inputs: angle. Returns: result

rhino_cmd_torusB
    Create a torus in Rhino.
    
    Args:
    controller:    RhinoController instance.
    x, y, z:       World-space center of the torus.
    major_radius:  Distance from the torus center to the tube center.
    minor_radius:  Radius of the tube cross-section.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: x, y, z, major_radius, +1 more. Returns: result

rhino_cmd_turntableB
    Animate the viewport in turntable rotation.
    
    Args:
    frames: Number of animation frames.
    pause: Pause duration between frames in seconds.
    

Inputs: pause, frames. Returns: result

rhino_cmd_twistC
    Apply a twist deformation to selected objects.
    
    The twist axis is picked interactively.
    
    Args:
    controller: RhinoController instance.
    angle: Total twist angle in degrees.
    
    Returns:
    Dict with command result.
    

Inputs: angle. Returns: result

rhino_cmd_undoC
    Undo one or more operations.
    
    Args:
    controller: RhinoController instance.
    steps: Number of undo steps (default 1).
    
    Returns:
    Dict with the result of the last undo command.
    

Inputs: steps. Returns: result

rhino_cmd_unweld_meshB
    Unweld mesh vertices where the edge angle exceeds the tolerance.
    
    Args:
    controller: RhinoController instance.
    angle: Minimum angle (degrees) to unweld at.
    

Inputs: angle. Returns: result

rhino_cmd_volumeB
    Calculate the volume of selected closed polysurfaces or meshes.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result containing volume information.
    

Inputs: no named parameters. Returns: result

rhino_cmd_weld_meshB
    Weld mesh vertices within the given angle tolerance.
    
    Args:
    controller: RhinoController instance.
    angle_tolerance: Maximum angle (degrees) between faces to weld vertices.
    

Inputs: angle_tolerance. Returns: result

rhino_coneB

Add a cone primitive (bridge required for non-Z axes).

Inputs: args (required). Returns: object

rhino_contourC

Generate equally spaced section curves (bridge required).

Inputs: args (required). Returns: object

rhino_count_objectsB

Return a count of all objects in the document, broken down by geometry type.

Inputs: no named parameters. Returns: result

rhino_create_blockB
    Create a block definition from currently selected objects.
    
    Args:
    name: Name for the new block definition.
    base_x, base_y, base_z: Base insertion point coordinates.
    

Inputs: name (required), base_x, base_y, base_z. Returns: result

rhino_create_subdB

Create a SubD object from an existing mesh.

Inputs: args (required). Returns: object

rhino_create_uv_gridB

Create a point grid on a surface at even UV intervals.

Inputs: args (required). Returns: object

rhino_curvature_analysisA
Read-only

Sample Gaussian/mean curvature of a surface (bridge required).

Inputs: args (required). Returns: object

rhino_curvature_graphB
    Display a curvature graph on selected curves.
    
    Args:
    controller: RhinoController instance.
    density: Number of hair samples along the curve.
    scale: Scale of the curvature hairs.
    
    Returns:
    Dict with command result.
    

Inputs: scale, density. Returns: result

rhino_curve_continuityB
Read-only

Curve sanity — span count, closed flag, planarity, periodic, validity log.

Inputs: args (required). Returns: object

rhino_curve_lengthA
Read-onlyIdempotent

Return the curve's parametric domain and approximate length.

Inputs: args (required). Returns: object

rhino_curve_point_atA
Read-onlyIdempotent

Evaluate position and tangent at a parameter on the curve.

Inputs: args (required). Returns: object

rhino_curve_splitA

Split a curve at the given parameters; original is preserved.

Inputs: args (required). Returns: object

rhino_cylinderC

Add a cylinder; in standalone mode the axis must be world Z.

Inputs: args (required). Returns: object

rhino_daylight_factorA
Read-onlyIdempotent

BRE simplified daylight factor for a side-lit room.

    DF = (W * theta * tau * M) / (A_total * (1 - R^2)) (% as decimal).
    For early-stage architectural studies; for radiance-grade accuracy
    use ladybug-tools or DAYSIM.
    

Inputs: args (required). Returns: object

rhino_delete_selectedA

Delete the currently selected objects.

Inputs: no named parameters. Returns: result

rhino_dimension_alignedB

Add an aligned dimension between two points.

Inputs: args (required). Returns: object

rhino_dimension_angularC

Add an angular dimension at a vertex.

Inputs: args (required). Returns: object

rhino_dimension_linearC

Add a linear dimension between two points.

Inputs: args (required). Returns: object

rhino_dimension_styleB

Open the Annotation Styles (dimension style) manager.

Inputs: no named parameters. Returns: result

rhino_direct_irradianceA
Read-onlyIdempotent

Direct Normal Irradiance (W/m^2) clear-sky estimate via Bird + Kasten-Young air mass.

Includes Linke turbidity (1 = very clear, 7 = industrial haze) and site altitude. Pure calculation — no doc edits.

Inputs: args (required). Returns: object

rhino_display_mode_setA

Switch the active viewport's display mode.

Inputs: args (required). Returns: object

rhino_display_show_edgesB
    Toggle display of surface/mesh edges.
    
    Args:
    show: True to show edges, False to hide.
    

Inputs: show. Returns: result

rhino_distanceB
Read-onlyIdempotent

Euclidean distance between two points.

Inputs: args (required). Returns: object

rhino_distributeA
    Distribute selected objects evenly along a direction.
    
    Uses rhinoscriptsyntax to compute bounding-box centres and re-space them.
    
    Args:
    controller: RhinoController instance.
    direction: 'Horizontal' (X), 'Vertical' (Y), or 'Depth' (Z).
    
    Returns:
    Dict with command result.
    

Inputs: direction. Returns: result

rhino_document_propertiesC
    Open the Document Properties dialog.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

Inputs: no named parameters. Returns: result

rhino_document_settingsA
Read-only

Bundled units / tolerances / base point in one call.

Inputs: args (required). Returns: object

rhino_document_summaryB
Read-only

Get a high-level summary of the document (object counts, layers, etc.).

Inputs: args (required). Returns: object

rhino_document_units_getB
Read-only

Read the current document unit system.

Inputs: args (required). Returns: object

rhino_document_units_setB

Set the document unit system, optionally scaling existing geometry.

Inputs: args (required). Returns: object

rhino_draft_angleC
Read-only

Compute draft angles relative to the world Z axis (bridge required).

Inputs: args (required). Returns: object

rhino_draft_angle_analysisC
    Display draft-angle analysis on selected surfaces.
    
    Args:
    controller: RhinoController instance.
    draft_angle: Reference draft angle in degrees.
    
    Returns:
    Dict with command result.
    

Inputs: draft_angle. Returns: result

rhino_drawing_export_pdfC

Export a sheet to PDF (bridge only).

Inputs: args (required). Returns: object

rhino_drawing_section_cutC

Cut a section through objects with a plane and place the trace on a sheet (bridge only).

Inputs: args (required). Returns: object

rhino_drawing_sheet_createA

Create a sheet container — a rectangle on layer Sheets::<name> carrying user_text metadata.

    The rectangle's corners define the sheet bounds; user_text holds the
    sheet name, paper size (mm), and scale denominator so subsequent
    view-placement / title-block / export tools can re-derive it.
    

Inputs: args (required). Returns: object

rhino_drawing_title_block_addB

Add the bottom-right title block, north arrow, and scale bar to a sheet.

Inputs: args (required). Returns: object

rhino_drawing_view_placeA

Project objects to a 2-D view (Make2D) and place the result on a sheet (bridge only).

Inputs: args (required). Returns: object

rhino_dup_borderC

Extract border curves from a surface or mesh.

Inputs: args (required). Returns: object

rhino_dup_edgeC

Extract edge curves from a Brep (all or specific indices).

Inputs: args (required). Returns: object

rhino_edge_srfA
    Build a surface from 2, 3, or 4 edge/curve inputs.
    
    Pre-select the bounding edges (2-4) before calling.
    
    Args:
    controller: RhinoController instance.
    num_edges:  Number of edge curves (2, 3, or 4).
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: num_edges. Returns: result

rhino_edit_points_offA

Turn off edit point display for selected curves or surfaces.

Inputs: no named parameters. Returns: result

rhino_edit_points_onA

Turn on edit point display for selected curves or surfaces.

Inputs: no named parameters. Returns: result

rhino_ellipseB

Add an ellipse on the world XY plane (rhino3dm builds it as a NURBS approximation).

Inputs: args (required). Returns: object

rhino_ellipsoidA
    Create an ellipsoid in Rhino.
    
    Rhino prompts: center -> end of first axis -> end of second axis ->
    end of third axis.  We supply the three semi-axis end-points along
    the world X, Y, Z directions respectively.
    
    Args:
    controller: RhinoController instance.
    x, y, z:   Center of the ellipsoid.
    rx:         Semi-axis length along X.
    ry:         Semi-axis length along Y.
    rz:         Semi-axis length along Z.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: x, y, z, rx, +2 more. Returns: result

rhino_environment_setA

Attach an HDRI/EXR environment used for lighting + background (bridge only).

Inputs: args (required). Returns: object

rhino_eval_expressionC
    Evaluate a Python expression inside Rhino and return the result.
    
    Args:
    expression: A valid Python expression string (e.g. '2 + 2' or 'rs.WorldXYPlane()').
    

Inputs: expression (required). Returns: result

rhino_evaluate_surfaceA
Read-only

Evaluate a surface at UV parameters to get 3D point, normal, and tangents.

Inputs: args (required). Returns: object

rhino_execute_csharpA
Destructive

Execute RhinoCommon C# code in a live Rhino session using Roslyn.

    SAFETY: This tool runs arbitrary code with full RhinoCommon access.
    It is gated behind ``RHINO_MCP_ALLOW_CSHARP=1`` so it cannot fire
    accidentally. Set the env var only in trusted sessions.

    Globals available to the script:
    - ``doc``: the active ``RhinoDoc``
    - ``output``: a ``StringBuilder`` — call ``output.AppendLine("...")``
      to return text to the caller.

    Pre-imported namespaces: System, System.Collections.Generic,
    System.Linq, System.Text, Rhino, Rhino.Geometry, Rhino.DocObjects,
    Rhino.Commands. Pass ``references`` to load extra assemblies (e.g.
    ``Grasshopper``).

    Example — create a sphere::

        var sphere = new Sphere(Point3d.Origin, 5.0);
        doc.Objects.AddBrep(sphere.ToBrep());
        doc.Views.Redraw();
        output.AppendLine("Created sphere");

    Changes are wrapped in an undo record. ``timeout_s`` caps total
    execution time (default 30s); on timeout the call returns
    ``success: false`` and the script is best-effort cancelled.
    

Inputs: args (required). Returns: object

rhino_execute_pythonA

Execute RhinoScript Python code in a live Rhino session.

    CRITICAL — BEFORE USING THIS TOOL:
    1. Call rhino_get_rhinoscript_docs(topic) to find correct signatures.
    2. Read the documentation carefully — note exact parameter types.
    3. Write code using ONLY the documented signatures.
    4. Call this tool with the code.

    Code requirements:
    - Import rhinoscriptsyntax: ``import rhinoscriptsyntax as rs``
    - Use ``print()`` to return output/results to the caller.
    - Handle ``None`` returns from functions that might fail.

    Changes are wrapped in an undo record and will be reverted on failure.

    Returns ``success``, ``output`` (print capture), and ``message``
    (error details on failure).
    

Inputs: args (required). Returns: object

rhino_explodeB
    Explode selected polysurfaces, blocks, or groups into component parts.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_explode_blockB

Explode selected block instances into their constituent geometry.

Inputs: no named parameters. Returns: result

rhino_exportA
    Select all geometry and export to a file.
    
    The export format is inferred from the file extension; ``export_type``
    is used as the extension if ``file_name`` has none.
    
    Args:
    controller: RhinoController instance.
    file_name: Output filename (e.g. 'model.stl') or full path.
    folder: Optional folder override.
    export_type: File extension / format if not included in file_name
    (default 'stl').
    
    Returns:
    Dict with command result.
    

Inputs: file_name (required), folder, export_type. Returns: result

rhino_export_dxfB

Export to DXF (bridge required).

Inputs: args (required). Returns: object

rhino_export_gbxmlB

Export thermal / structural BIM payload to gbXML (bridge only).

Inputs: args (required). Returns: object

rhino_export_ifcA

Export the active document (or a subset) to IFC2x3 / IFC4 / IFC4x3 (bridge only).

Inputs: args (required). Returns: object

rhino_export_igesC

Export to IGES (bridge required).

Inputs: args (required). Returns: object

rhino_export_objA

Export selected (or all) objects to a Wavefront OBJ file (mesh-only).

Inputs: args (required). Returns: object

rhino_export_stepA

Export to STEP (bridge required).

Inputs: args (required). Returns: object

rhino_export_stlB

Export meshes to an ASCII STL file.

Inputs: args (required). Returns: object

rhino_extend_curveC
    Extend the selected curve by a fixed length from one or both ends.
    
    The curve must be pre-selected before calling this function.
    
    Args:
    controller: RhinoController instance.
    length:     Extension length.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: length. Returns: result

rhino_extend_surfaceB
    Extend a surface edge by a specified distance.
    
    The edge to extend is selected interactively.
    
    Args:
    controller: RhinoController instance.
    distance: Extension distance.
    
    Returns:
    Dict with command result.
    

Inputs: distance. Returns: result

rhino_extrudeB

Linearly extrude a profile curve by distance along direction.

Inputs: args (required). Returns: object

rhino_extrude_curveB
    Extrude selected curve(s) to create a solid or surface.
    
    Args:
    controller: RhinoController instance.
    distance: Extrusion distance.
    both_sides: Extrude in both directions symmetrically.
    solid: Create a closed solid (cap ends).
    delete_input: Delete the input curve after extrusion.
    

Inputs: solid, distance, both_sides, delete_input. Returns: result

rhino_extrude_surfaceB
    Extrude selected surface(s) by a given distance.
    
    Args:
    controller: RhinoController instance.
    distance: Extrusion distance.
    both_sides: Extrude in both directions symmetrically.
    solid: Create a closed solid.
    

Inputs: solid, distance, both_sides. Returns: result

rhino_fair_curveA
    Fair (smooth) the selected curve using Rhino's FairCrv command.
    
    The curve must be pre-selected before calling this function.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: no named parameters. Returns: result

rhino_fillet_edgesB
    Fillet the selected edges of a polysurface or solid.
    
    Args:
    controller: RhinoController instance.
    radius: Fillet radius.
    
    Returns:
    Dict with command result.
    

Inputs: radius. Returns: result

rhino_fillet_surfaceB

Create a constant-radius fillet between two surfaces.

Inputs: args (required). Returns: object

rhino_flipA
    Flip the normal direction of selected surfaces.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

Inputs: no named parameters. Returns: result

rhino_flip_mesh_normalsB
    Flip the normals of selected mesh faces.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_flowC

Flow objects from one curve onto another (bridge only).

Inputs: args (required). Returns: object

rhino_flow_along_curveC

Reposition objects from a base curve onto a target curve.

Inputs: args (required). Returns: object

rhino_freeform_curveA
    Create a control-point (freeform) NURBS spline.
    
    The curve is defined by its control polygon; it does NOT pass through
    interior points (only through the first and last control point when the
    degree allows).
    
    Args:
    controller: RhinoController instance.
    points:     Control polygon vertices as (x, y, z) tuples.
    degree:     Polynomial degree (default 3 = cubic B-spline).
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: points (required), degree. Returns: result

rhino_get_control_pointsA
Read-only

Get all control points (and weights) of a NURBS curve or surface.

Inputs: args (required). Returns: object

rhino_get_document_textA
    Retrieve a document-level user text value by key.
    
    Args:
    key: Key name.
    

Inputs: key (required). Returns: result

rhino_get_module_functionsA
Read-only

Get all functions in a specific RhinoScript module with signatures.

    Use rhino_list_rhinoscript_modules() first to see available modules,
    then call this to browse a module's full API.
    

Inputs: args (required). Returns: object

rhino_get_object_infoA

Return information (type, layer, name, color) for all currently selected objects.

Inputs: no named parameters. Returns: result

rhino_get_object_nameA

Return the name of each currently selected object.

Inputs: no named parameters. Returns: result

rhino_get_rhinoscript_docsA
Read-only

Get comprehensive RhinoScript documentation for a topic.

    CRITICAL: You MUST call this tool before using rhino_execute_python.
    Returns full signatures, parameter descriptions, return values, and
    optional code examples for the most relevant functions.
    

Inputs: args (required). Returns: object

rhino_get_user_textA
Read-only

Read user text (key-value metadata) attached to an object.

Inputs: args (required). Returns: object

rhino_groupC

Group objects together under a (named) group.

Inputs: args (required). Returns: object

rhino_group_selectedA
    Group the currently selected objects.
    
    Args:
    name: Optional name for the group. If None, Rhino auto-assigns a name.
    

Inputs: name. Returns: result

rhino_hatchC

Add a hatch over the given closed curves.

Inputs: args (required). Returns: object

rhino_helixB

Add a helix sampled into a NURBS curve.

Inputs: args (required). Returns: object

rhino_hide_selectedA

Hide currently selected objects.

Inputs: no named parameters. Returns: result

rhino_importC

Import an external file into the active document (bridge required for non-3DM).

Inputs: args (required). Returns: object

rhino_import_ifcA

Import an IFC file, mapping each entity to a layer under target_layer_root (bridge only).

Inputs: args (required). Returns: object

rhino_insert_blockB
    Insert a block instance into the document.
    
    Args:
    name: Block definition name to insert.
    x, y, z: Insertion point.
    scale: Uniform scale factor.
    rotation: Rotation angle in degrees.
    

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

rhino_interpcrvC
    Create an interpolated NURBS curve that passes through all given points.
    
    Args:
    controller: RhinoController instance.
    points:     Ordered list of (x, y, z) tuples (>= 2).
    degree:     Polynomial degree of the resulting curve (default 3 = cubic).
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: points (required), degree. Returns: result

rhino_interpolate_curveB

Add an interpolated NURBS curve passing through the given points.

Inputs: args (required). Returns: object

rhino_isocurveB

Extract an isocurve from a surface at a specific U or V parameter.

Inputs: args (required). Returns: object

rhino_joinB
    Join selected surfaces, curves, or polysurfaces into a single object.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_launchB
    Launch Rhino and wait for it to become ready.
    
    Args:
    controller: RhinoController instance.
    wait_seconds: Seconds to wait for Rhino to start (default 12).
    
    Returns:
    Dict with launch result.
    

Inputs: wait_seconds. Returns: result

rhino_layer_colorB
    Set a layer's display color.
    
    Args:
    name: Layer name.
    r, g, b: RGB color components (0-255).
    

Inputs: name (required), b, g, r. Returns: result

rhino_layer_countA

Return the total number of layers in the document.

Inputs: no named parameters. Returns: result

rhino_layer_createB

Create a layer with optional colour and visibility.

Inputs: args (required). Returns: object

rhino_layer_deleteA
Destructive

Delete a layer by name (in standalone mode the layer is hidden + name-prefixed).

Inputs: args (required). Returns: object

rhino_layer_get_currentA

Return the name of the current (active) layer.

Inputs: no named parameters. Returns: result

rhino_layer_isolateA
    Isolate a layer by hiding all other layers.
    
    Args:
    name: Layer to keep visible.
    

Inputs: name (required). Returns: result

rhino_layer_listB
Read-only

List all layers with their properties (color, visibility, object count).

Inputs: args (required). Returns: object

rhino_layer_lockB
    Lock or unlock a layer.
    
    Args:
    name: Layer name.
    locked: True to lock, False to unlock.
    

Inputs: name (required), locked. Returns: result

rhino_layer_purge_unusedA

Delete all layers that contain no objects and have no sub-layers.

Inputs: no named parameters. Returns: result

rhino_layer_renameC
    Rename an existing layer.
    
    Args:
    old_name: Current layer name.
    new_name: New layer name.
    

Inputs: new_name (required), old_name (required). Returns: result

rhino_layer_set_colorB

Change a layer's display colour.

Inputs: args (required). Returns: object

rhino_layer_set_currentC
    Set the active (current) layer.
    
    Args:
    name: Name of the layer to make current.
    

Inputs: name (required). Returns: result

rhino_layer_set_materialA

Bind a render material to a layer so layer-source objects inherit it.

    Bridge-only: rhino3dm exposes ``material_index`` on the layer but the
    in-document material table is read-only. Use ``rhino_material_create``
    first to define the material.
    

Inputs: args (required). Returns: object

rhino_layer_unisolateA

Show all layers (undo isolation).

Inputs: no named parameters. Returns: result

rhino_layer_visibleA
    Show or hide a layer.
    
    Args:
    name: Layer name.
    visible: True to show, False to hide.
    

Inputs: name (required), visible. Returns: result

rhino_leaderB

Add a multi-point leader (with optional text).

Inputs: args (required). Returns: object

rhino_lengthB
    Measure the length of selected curves.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result containing curve length.
    

Inputs: no named parameters. Returns: result

rhino_light_addB

Add a point / spot / directional / rectangular / linear light to the document.

Inputs: args (required). Returns: object

rhino_lineB

Add a line between two points.

Inputs: args (required). Returns: object

rhino_list_blocksA

Return a list of all block definition names in the document.

Inputs: no named parameters. Returns: result

rhino_list_objectsA
Read-only

List objects in the document with optional layer/type filter.

    Returns up to ``limit`` objects starting at ``offset`` (after filters).
    The response carries a ``pagination`` block — ``{total, offset, limit,
    returned, has_more}`` — so the caller can iterate without guessing.

    Async so concurrent ``rhino_*`` queries don't block FastMCP's event
    loop while the bridge round-trip is in flight.
    

Inputs: args (required). Returns: object

rhino_list_rhinoscript_modulesA
Read-only

List all available RhinoScript modules with function counts.

Use this to discover what areas of the API are available when you are not sure which module contains the functions you need.

Inputs: no named parameters. Returns: object

rhino_list_saved_filesB
    List all files in the default RhinoFiles directory (D:/RhinoFiles).
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with 'files' key containing list of file info dicts,
    and 'directory' key with the scanned path.
    

Inputs: no named parameters. Returns: result

rhino_lock_selectedA

Lock currently selected objects so they cannot be selected or modified.

Inputs: no named parameters. Returns: result

rhino_loftB

Loft a sequence of profile curves into a surface.

Inputs: args (required). Returns: object

rhino_make2dC

Generate a 2D drawing projection of 3D objects.

Inputs: args (required). Returns: object

rhino_match_srfB
    Match the edge of one surface to another for G0/G1/G2 continuity.
    
    Pre-select the edge to adjust before calling.
    
    Args:
    controller:   RhinoController instance.
    continuity:   Continuity type: 'Position', 'Tangency', or 'Curvature'.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: continuity. Returns: result

rhino_match_surfaceC

Adjust a surface edge to match the continuity of a target surface.

Inputs: args (required). Returns: object

rhino_material_assignB

Assign an existing material to one or more objects.

Inputs: args (required). Returns: object

rhino_material_createB

Create a material with diffuse colour, transparency, and glossiness.

Inputs: args (required). Returns: object

rhino_material_preset_createA

Create a document material from a bundled physical preset.

Standalone uses rhino3dm's basic Material (diffuse / transparency / shine). Bridge mode also pushes the matching Rhino PBR render content + IOR for photoreal output.

Inputs: args (required). Returns: object

rhino_material_preset_listA
Read-onlyIdempotent

List physical-material presets bundled with rhino-mcp.

    Returns the full catalogue (or a single category subset) so the LLM
    can pick a known-good name before calling ``rhino_material_preset_create``.
    

Inputs: args (required). Returns: object

rhino_materials_managerA

Open the Rendering / Materials panel.

Inputs: no named parameters. Returns: result

rhino_merge_all_coplanar_facesA
    Merge all coplanar faces of selected polysurfaces into single faces.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

Inputs: no named parameters. Returns: result

rhino_merge_all_facesB
    Merge all coplanar adjacent faces in selected polysurfaces.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_merge_edgeB
    Merge selected adjacent edges of a surface.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

Inputs: no named parameters. Returns: result

rhino_merge_surfacesC

Merge multiple surfaces into a single surface.

Inputs: args (required). Returns: object

rhino_mesh_boolean_differenceB
Destructive

Boolean-difference meshes (a - b).

Inputs: args (required). Returns: object

rhino_mesh_boolean_intersectionB
    Boolean intersection of selected closed meshes.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_mesh_boolean_unionC
Destructive

Boolean-union meshes.

Inputs: args (required). Returns: object

rhino_mesh_boxC

Add a quad mesh box with the given subdivisions.

Inputs: args (required). Returns: object

rhino_mesh_from_brepC

Mesh a Brep (bridge only).

Inputs: args (required). Returns: object

rhino_mesh_from_nurbsA
    Convert selected NURBS surfaces / polysurfaces to a render mesh.
    
    Args:
    controller: RhinoController instance.
    max_angle: Maximum angle between mesh normals (degrees).
    max_aspect: Maximum aspect ratio of mesh faces (0 = ignore).
    max_distance: Maximum distance from mesh edge to surface.
    max_edge: Maximum mesh edge length (0 = ignore).
    min_edge: Minimum mesh edge length.
    min_initial_grid: Minimum initial grid quads per surface.
    refine: Refine the mesh for better quality.
    jagged_seams: Allow jagged seams between surfaces.
    

Inputs: refine, max_edge, min_edge, max_angle, +4 more. Returns: result

rhino_mesh_from_surfaceC

Mesh a surface (bridge only).

Inputs: args (required). Returns: object

rhino_mesh_repairB
    Launch the MeshRepair wizard for selected meshes.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_mesh_splitB
    Split a mesh with another mesh or surface.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_mesh_to_nurbsB
    Convert selected mesh objects to NURBS surfaces.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_mesh_trimC
    Trim a mesh with a cutting curve or surface.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_mirrorB

Mirror objects across a plane (copies by default).

Inputs: args (required). Returns: object

rhino_modify_offset_curveC
    Offset a selected curve by a given distance.
    
    Args:
    controller: RhinoController instance.
    distance: Offset distance.
    both_sides: If True, offset to both sides of the curve.
    cap: If True, add end caps (for open curves with BothSides=Yes).
    
    Returns:
    Dict with command result.
    

Inputs: cap, distance, both_sides. Returns: result

rhino_moveC

Translate (or copy) the given objects by a vector.

Inputs: args (required). Returns: object

rhino_move_objects_to_layerA
    Move currently selected objects to the specified layer.
    
    Args:
    layer_name: Target layer name.
    

Inputs: layer_name (required). Returns: result

rhino_move_uvnC

Enter MoveUVN mode to move control points along U, V, N directions.

Inputs: no named parameters. Returns: result

rhino_multi_pipeA
    Create a multi-pipe from selected curves.
    
    Args:
    controller: RhinoController instance.
    radius: Pipe radius at each curve.
    

Inputs: radius. Returns: result

rhino_named_viewsB
    Manage named views: list, save, restore, or delete.
    
    Args:
    controller: RhinoController instance.
    action: One of 'list', 'save', 'restore', 'delete'.
    view_name: Name of the view (required for save/restore/delete).
    
    Returns:
    Dict with command result or list of named views.
    

Inputs: action, view_name. Returns: result

rhino_named_view_saveB

Save the current camera as a named view.

Inputs: args (required). Returns: object

rhino_network_srfA
    Build a surface through a network of intersecting curves.
    
    Pre-select the network curves before calling.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: no named parameters. Returns: result

rhino_network_surfaceB

Build a surface from a network of crossing curves.

Inputs: args (required). Returns: object

rhino_new_documentB
    Create a new Rhino document, optionally from a template.
    
    Args:
    controller: RhinoController instance.
    template: Path to a .3dm template file. If empty, opens a blank document.
    
    Returns:
    Dict with command result.
    

Inputs: template. Returns: result

rhino_nurbs_curveB

Add a NURBS curve from a control polygon.

Inputs: args (required). Returns: object

rhino_object_deleteC
Destructive

Delete the given objects from the document.

Inputs: args (required). Returns: object

rhino_object_infoA
Read-only

Get detailed info about a single object (geometry type, layer, bbox, etc.).

Inputs: args (required). Returns: object

rhino_object_move_to_layerB

Reassign one or more objects to a different layer (creating it if absent).

Inputs: args (required). Returns: object

rhino_object_properties_dialogB

Open the Object Properties panel for the selected object.

Inputs: no named parameters. Returns: result

rhino_object_quantityB
Read-only

Per-object measurement table — one row per object_id with the requested fields.

Inputs: args (required). Returns: object

rhino_object_selectB

Select objects by ID and/or attribute filters.

    Filter fields combine with AND semantics. ``object_ids`` short-circuits
    the other filters when provided. Standalone mode marks matches with the
    ``rhino_mcp_selected`` user-string (since rhino3dm has no selection
    state); bridge mode delegates to Rhino's native selection.
    

Inputs: args (required). Returns: object

rhino_offset_curveA
    Offset the currently selected curve by a specified distance.
    
    The curve must be pre-selected before calling this function.
    
    Args:
    controller:    RhinoController instance.
    distance:      Perpendicular offset distance.
    through_point: Optional 'x,y,z' string to offset through a point
    instead of using *distance*.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: distance, through_point. Returns: result

rhino_offset_meshB
    Offset selected mesh faces by a given distance.
    
    Args:
    controller: RhinoController instance.
    distance: Offset distance (along face normals).
    

Inputs: distance. Returns: result

rhino_offset_srfA
    Offset a surface by a specified distance, optionally creating a solid.
    
    Pre-select the surface before calling.
    
    Args:
    controller: RhinoController instance.
    distance:   Offset distance (positive = outward along normals).
    solid:      If True, caps the sides to create a closed solid.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: solid, distance. Returns: result

rhino_offset_subdB
    Offset a SubD object by a given distance, optionally creating a solid.
    
    Args:
    controller: RhinoController instance.
    distance: Offset distance.
    solid: Create a solid (closed) offset.
    

Inputs: solid, distance. Returns: result

rhino_offset_surfaceB

Offset a surface by distance along its normal.

Inputs: args (required). Returns: object

rhino_openC

Open a .3dm file and bind it to a doc_id.

Inputs: args (required). Returns: object

rhino_open_fileC
    Open an existing Rhino file.
    
    Args:
    controller: RhinoController instance.
    file_path: Absolute path to the .3dm file to open.
    
    Returns:
    Dict with command result.
    

Inputs: file_path (required). Returns: result

rhino_orientA

Orient objects from one plane to another (PlaneToPlane transform).

Inputs: args (required). Returns: object

rhino_orient_3ptB
    Orient selected objects using three reference points (interactive).
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

Inputs: no named parameters. Returns: result

rhino_orient_on_crvC
    Orient selected objects along a curve (interactive).
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

Inputs: no named parameters. Returns: result

rhino_orient_on_srfB
    Orient selected objects on a surface (interactive).
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

Inputs: no named parameters. Returns: result

rhino_origin_setA

Set the model base point.

    ``mode='reference'`` stores the point as metadata only — useful for
    geo-referencing without disturbing existing geometry. ``mode='translate'``
    shifts every object so the supplied point becomes the new (0,0,0).
    

Inputs: args (required). Returns: object

rhino_pack_texturesA

Pack all external textures into the document for portability.

Inputs: no named parameters. Returns: result

rhino_panC
    Pan the active viewport.
    
    Args:
    dx: Horizontal pan amount.
    dy: Vertical pan amount.
    

Inputs: dx, dy. Returns: result

rhino_panel_curvature_classifyB
Read-only

Classify each UxV panel by curvature class (planar / single_* / synclastic / anticlastic).

    Standalone uses a 4-corner normal heuristic (no full Gaussian K).
    Bridge mode reports true Gaussian + mean curvature per cell.
    

Inputs: args (required). Returns: object

rhino_panel_framesC
Read-only

Generate oriented frames (planes) at panel centres for construction.

Inputs: args (required). Returns: object

rhino_panelize_surfaceC

Subdivide a surface into panels (quad, triangle, or diamond).

Inputs: args (required). Returns: object

rhino_panel_planarityA
Read-only

Per-panel planarity report on a UxV grid sampled from a surface.

    Each cell's planarity error = distance of the 4th corner from the
    plane fitted through the first three. Cells whose error > tolerance
    are flagged. The returned ``stats`` block summarises max / mean /
    non-planar count for high-level reporting.
    

Inputs: args (required). Returns: object

rhino_paraboloidA
    Create a paraboloid surface in Rhino using the Paraboloid command.
    
    Rhino prompts: focus/apex point -> radius at base -> height.
    
    Args:
    controller: RhinoController instance.
    x, y, z:   Apex (tip) of the paraboloid.
    radius:     Radius of the open base circle.
    height:     Height from apex to base.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: x, y, z, height, +1 more. Returns: result

rhino_patchC

Patch a region defined by boundary curves.

Inputs: args (required). Returns: object

rhino_perspective_angleA
    Set the perspective viewport camera lens angle.
    
    Args:
    angle: Lens angle in degrees (e.g. 45, 60).
    

Inputs: angle. Returns: result

rhino_pipe_from_curveA
    Create a pipe solid around a previously created (or selected) curve.
    
    The function first runs *curve_select_cmd* to select the rail curve,
    then runs the Pipe command with the given radius and cap style.
    
    Args:
    controller:         RhinoController instance.
    curve_select_cmd:   Rhino command used to select the curve before
    piping (default: '_SelLast' selects the most
    recently created object).
    radius:             Pipe outer radius.
    cap:                If True, caps the pipe ends (solid); otherwise
    leaves them open.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: cap, radius, curve_select_cmd. Returns: result

rhino_place_gridA

Replicate a source object on a count_x x count_y grid with given spacing.

    Returns the new object IDs in row-major (x outer, y inner) order. The
    source is preserved; when ``skip_origin`` is True the (0,0) cell is
    left untouched and the source itself fills it.
    

Inputs: args (required). Returns: object

rhino_planar_srfA
    Fill planar closed curves with a planar surface.
    
    Pre-select the boundary curves before calling.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: no named parameters. Returns: result

rhino_plane_surfaceB

Add a finite plane (rectangular trim) on the given plane.

Inputs: args (required). Returns: object

rhino_pointC

Add a single point to the document.

Inputs: args (required). Returns: object

rhino_point_deviationA
    Analyse the deviation between point clouds and a reference surface.
    
    Objects must be selected before calling; the command runs interactively.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

Inputs: no named parameters. Returns: result

rhino_points_offA

Turn off control point display for selected objects.

Inputs: no named parameters. Returns: result

rhino_points_onA

Turn on control point display for selected objects.

Inputs: no named parameters. Returns: result

rhino_points_solid_onB

Enable solid point display for solid/closed objects.

Inputs: no named parameters. Returns: result

rhino_polygonC

Add a regular polygon (inscribed or circumscribed) on the XY plane.

Inputs: args (required). Returns: object

rhino_polylineB

Add a polyline through the given points; optionally closed.

Inputs: args (required). Returns: object

rhino_probe_intersectionB
Read-onlyIdempotent

Cast a ray and report intersection points against Breps/Extrusions.

    Returns ``hits`` sorted by distance from the ray origin. Bridge-only —
    rhino3dm has no ray-shoot primitive.
    

Inputs: args (required). Returns: object

rhino_project_to_cplaneA
    Project selected objects onto the active construction plane.
    
    Original objects are not kept.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

Inputs: no named parameters. Returns: result

rhino_purgeB
    Purge unused document objects to reduce file size.
    
    Args:
    controller: RhinoController instance.
    purge_unused_layers: Remove layers with no geometry (default True).
    purge_unused_blocks: Remove unreferenced block definitions (default True).
    purge_unused_materials: Remove unreferenced materials (default True).
    
    Returns:
    Dict with command result.
    

Inputs: purge_unused_blocks, purge_unused_layers, purge_unused_materials. Returns: result

rhino_push_pullB
    Push or pull a selected sub-face of a solid by a given distance.
    
    Args:
    controller: RhinoController instance.
    distance: Push/pull distance (positive = outward, negative = inward).
    

Inputs: distance. Returns: result

rhino_pyramidB
    Create a regular pyramid in Rhino.
    
    Args:
    controller: RhinoController instance.
    x, y, z:   Center of the base polygon.
    sides:      Number of sides for the base polygon (>= 3).
    radius:     Circumradius of the base polygon.
    height:     Height of the pyramid apex above the base.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: x, y, z, sides, +2 more. Returns: result

rhino_quadrangulate_meshC
    Convert triangular faces in selected meshes to quads where possible.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_quad_remeshB
    Remesh selected objects into a uniform quad mesh.
    
    Args:
    controller: RhinoController instance.
    target_quad_count: Target number of quad faces.
    adaptive_size: Adaptive size percentage (0–100).
    detect_hard_edges: Preserve hard edges during remeshing.
    

Inputs: adaptive_size, detect_hard_edges, target_quad_count. Returns: result

rhino_radiusA
    Measure the radius of a selected arc or circle (interactive).
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

Inputs: no named parameters. Returns: result

rhino_rail_revolveA
    Rail-revolve: revolve a profile along a rail path curve.
    
    Pre-select the profile curve and rail curve before calling.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: no named parameters. Returns: result

rhino_rebuildC
    Rebuild selected curves or surfaces with specified point count and degree.
    
    Args:
    controller: RhinoController instance.
    point_count: Number of control points.
    degree: NURBS degree.
    
    Returns:
    Dict with command result.
    

Inputs: degree, point_count. Returns: result

rhino_rebuild_curveB

Rebuild an existing curve with a new point count and degree.

Inputs: args (required). Returns: object

rhino_rebuild_meshC
    Rebuild selected meshes to clean up topology.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_rebuild_surfaceC

Rebuild a surface with new point counts and degrees in U/V.

Inputs: args (required). Returns: object

rhino_rebuild_uvC
    Rebuild a surface in U and V directions independently.
    
    Args:
    controller: RhinoController instance.
    u_count: Control-point count in U direction.
    v_count: Control-point count in V direction.
    
    Returns:
    Dict with command result.
    

Inputs: u_count, v_count. Returns: result

rhino_rectangleB

Add a rectangle as a closed polyline on the XY plane.

Inputs: args (required). Returns: object

rhino_redoC

Redo the last undone operation(s) in the Rhino document.

Inputs: args (required). Returns: object

rhino_reduce_meshB
Destructive

Reduce a mesh to a target face count.

Inputs: args (required). Returns: object

rhino_refit_trimB
    Refit the trim curves of selected surfaces.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

Inputs: no named parameters. Returns: result

rhino_remove_control_pointA

Remove a selected control point from a NURBS curve or surface.

Inputs: no named parameters. Returns: result

rhino_remove_creaseA
    Remove the crease from selected SubD edges (smooth them).
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_renderC

Render the scene using the current render settings.

Inputs: no named parameters. Returns: result

rhino_render_previewB

Start a quick preview render.

Inputs: no named parameters. Returns: result

rhino_render_queue_cancelA

Cancel a running or queued render job.

Inputs: args (required). Returns: object

rhino_render_queue_listA
Read-onlyIdempotent

List recent render jobs and their progress.

Inputs: args (required). Returns: object

rhino_render_queue_statusA
Read-onlyIdempotent

Inspect a queued render job's status, progress, and completed frames.

Inputs: args (required). Returns: object

rhino_render_queue_submitA

Submit a frame sequence to the bridge render queue (bridge only).

    Returns a ``job_id`` immediately while frames are captured on a
    background worker. Use ``rhino_render_queue_status`` to poll
    progress and ``rhino_render_queue_cancel`` to interrupt. The v0.5
    backend captures viewport frames (``_-ViewCaptureToFile``); true
    photo-realistic engine integration is on the roadmap.
    

Inputs: args (required). Returns: object

rhino_render_setupB

Set render resolution / samples / engine / transparency on the active render context.

Inputs: args (required). Returns: object

rhino_render_to_fileC

Execute the configured render and write the result to output_path.

Inputs: args (required). Returns: object

rhino_render_viewportB

Render the active viewport to an image file (bridge required).

Inputs: args (required). Returns: object

rhino_repair_subdB
    Repair selected SubD objects to fix topology issues.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_reparameterizeB
    Reparameterize selected curves or surfaces to natural parameterization.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

Inputs: no named parameters. Returns: result

rhino_replace_blockC
    Replace selected block instances with a different block definition.
    
    Args:
    new_name: Name of the replacement block definition.
    

Inputs: new_name (required). Returns: result

rhino_replicate_along_curveB

Distribute copies of a source object along a curve at evenly-spaced parameters.

    With ``align_to_tangent`` (default), each copy is reoriented so that
    the world-X direction maps to the curve tangent at its sample point.
    ``include_endpoints`` controls whether the first/last samples land on
    the curve's start/end points.
    

Inputs: args (required). Returns: object

rhino_report_mesh_healthB
Read-only

Mesh health — closed, manifold, vertex/face counts, validity log.

Inputs: args (required). Returns: object

rhino_revertC
    Revert the current document to its last saved state.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

Inputs: no named parameters. Returns: result

rhino_revolveC

Revolve a profile curve about an axis.

Inputs: args (required). Returns: object

rhino_ribC
    Create a rib feature on a solid from selected curves.
    
    Args:
    controller: RhinoController instance.
    width: Rib width.
    thickness: Rib thickness.
    

Inputs: width, thickness. Returns: result

rhino_rotateC

Rotate objects about an axis through a centre point.

Inputs: args (required). Returns: object

rhino_rotate_3dC
    Rotate selected objects around an arbitrary 3-D axis.
    
    Args:
    controller: RhinoController instance.
    axis_start: Start point of the rotation axis.
    axis_end: End point of the rotation axis.
    angle: Rotation angle in degrees.
    
    Returns:
    Dict with command result.
    

Inputs: angle, axis_end, axis_start. Returns: result

rhino_run_commandA
    Send a raw Rhino command string.
    
    Args:
    command: Full Rhino command string (including parameters and Enter tokens).
    rhino_id: Optional Rhino instance ID.
    

Inputs: command (required), rhino_id. Returns: result

rhino_run_macroA
    Execute a sequence of Rhino commands (macro) one step at a time.
    
    Args:
    macro_steps: List of command strings to execute in order.
    
    Returns:
    Dict with 'steps' containing per-step results and overall 'success' flag.
    

Inputs: macro_steps (required). Returns: result

rhino_run_pythonB
    Execute arbitrary Python code inside Rhino's runtime environment.
    
    Args:
    code: Python source code string to execute.
    rhino_id: Optional Rhino instance ID (for multi-instance setups).
    

Inputs: code (required), rhino_id. Returns: result

rhino_run_script_fileB
    Execute a Python script file inside Rhino.
    
    Args:
    file_path: Absolute path to the .py script file.
    

Inputs: file_path (required). Returns: result

rhino_saveC

Write the document to disk.

Inputs: args (required). Returns: object

rhino_save_asA
    Save the current document under a new name/location.
    
    If ``file_name`` is not an absolute path it is resolved relative to
    D:/RhinoFiles (or ``folder`` if provided).
    
    Args:
    controller: RhinoController instance.
    file_name: Desired filename (e.g. 'mymodel.3dm') or full path.
    folder: Optional folder override.
    
    Returns:
    Dict with command result.
    

Inputs: file_name (required), folder. Returns: result

rhino_save_copyA
    Save a copy of the current document without changing the active file path.
    
    Args:
    controller: RhinoController instance.
    file_name: Desired filename or full path for the copy.
    folder: Optional folder override.
    
    Returns:
    Dict with command result.
    

Inputs: file_name (required), folder. Returns: result

rhino_save_script_to_fileB
    Save a Python code string to the temp scripts folder and return its path.
    
    Args:
    code: Python source code to save.
    filename: Filename (e.g. 'my_script.py'); .py extension added if missing.
    
    Returns:
    Dict with 'success', 'path' of saved file.
    

Inputs: code (required), filename (required). Returns: result

rhino_scaleB

Scale objects non-uniformly about a centre.

Inputs: args (required). Returns: object

rhino_scale_1dB
    Scale selected objects in one direction (1-D scale).
    
    The user must pick the origin and scale direction interactively.
    
    Args:
    controller: RhinoController instance.
    factor: Scale factor.
    
    Returns:
    Dict with command result.
    

Inputs: factor. Returns: result

rhino_scale_2dC
    Scale selected objects in two directions simultaneously (2-D scale).
    
    Args:
    controller: RhinoController instance.
    factor: Scale factor applied to both directions.
    
    Returns:
    Dict with command result.
    

Inputs: factor. Returns: result

rhino_scale_nuA
    Scale selected objects non-uniformly along X, Y, Z.
    
    Args:
    controller: RhinoController instance.
    x_factor: Scale factor in X.
    y_factor: Scale factor in Y.
    z_factor: Scale factor in Z.
    
    Returns:
    Dict with command result.
    

Inputs: x_factor, y_factor, z_factor. Returns: result

rhino_scatterA

Scatter count copies of a source inside a 2-D AABB with optional Z-rotation jitter.

    The boundary is interpreted in world XY; Z is taken from
    ``boundary_min.z``. Use ``seed`` for deterministic output.
    

Inputs: args (required). Returns: object

rhino_schedule_by_layerB
Read-only

Aggregate objects per layer with optional filter and sublayer merging.

    Returns ``rows`` (one entry per layer) plus a ``totals`` block.
    

Inputs: args (required). Returns: object

rhino_schedule_by_materialA
Read-only

Aggregate objects grouped by assigned material name.

    Standalone treats ``MaterialIndex == -1`` (default material) as
    'Default'. Bridge mode resolves each object's effective material via
    Rhino's render content lookup.
    

Inputs: args (required). Returns: object

rhino_schedule_by_user_textA
Read-only

Aggregate objects grouping by user_text[group_key] value.

    Useful for BIM-style schedules: ``group_key='assembly_type'`` produces a
    wall/window schedule, ``group_key='material'`` produces a material BOM.
    

Inputs: args (required). Returns: object

rhino_schedule_export_csvA

Write rows produced by any rhino_schedule_* tool to CSV.

Inputs: args (required). Returns: object

rhino_screenshotA

Capture a viewport screenshot (bridge required).

    With ``as_base64=True`` the response includes ``image_base64`` so
    the LLM can inspect the render inline. The PNG is also written to
    ``path`` regardless, for the user to save/share.
    

Inputs: args (required). Returns: object

rhino_seamB
    Adjust the seam location of a closed surface (interactive).
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

Inputs: no named parameters. Returns: result

rhino_search_rhinoscript_functionsA
Read-only

Search RhinoScript functions by keyword or description.

    Use this BEFORE writing any RhinoScript Python code to find correct
    function names and signatures.  Returns matching functions sorted by
    relevance.

    Example queries: "loft surface", "boolean union", "rotate object",
    "create curve", "extrude".
    

Inputs: args (required). Returns: object

rhino_sectionC

Slice the listed objects with a plane (bridge required).

Inputs: args (required). Returns: object

rhino_section_at_axisA

Slice a surface (or Brep / mesh in bridge) into count section curves.

    Standalone supports ``axis='u'`` and ``axis='v'`` (surface isocurves).
    World-axis slicing (``axis='x'/'y'/'z'``) requires bridge mode.
    

Inputs: args (required). Returns: object

rhino_sel_allA

Select all objects in the document.

Inputs: no named parameters. Returns: result

rhino_sel_bad_objectsB

Select geometrically invalid (bad) objects.

Inputs: no named parameters. Returns: result

rhino_sel_by_colorA
    Select objects by display color.
    
    Args:
    color_rgb: Comma-separated RGB string, e.g. '255,0,0' for red.
    

Inputs: color_rgb. Returns: result

rhino_sel_by_nameB

Select objects by their name attribute.

Inputs: name (required). Returns: result

rhino_sel_by_typeA
    Select objects by type.
    
    Supported types:
    'curve', 'surface', 'mesh', 'subd', 'point', 'polysurface',
    'all_curves', 'line', 'polyline', 'arc', 'circle', 'ellipse',
    'solid', 'extrusion', 'annotation', 'block', 'light', 'hatch'
    

Inputs: object_type (required). Returns: result

rhino_sel_chainA

Select a chain of connected curves from the current selection seed.

Inputs: no named parameters. Returns: result

rhino_sel_connectedA

Select all objects connected to the currently selected object.

Inputs: no named parameters. Returns: result

rhino_sel_duplicatesB

Select duplicate objects.

Inputs: no named parameters. Returns: result

rhino_selection_bboxD
Read-only

Return the union bounding box of all objects in the document.

Inputs: args (required). Returns: object

rhino_sel_invertA

Invert the current selection using rhinoscriptsyntax.

Inputs: no named parameters. Returns: result

rhino_sel_lastA

Re-select the previously selected set of objects.

Inputs: no named parameters. Returns: result

rhino_sel_layerC

Select all objects on a specific layer.

Inputs: layer_name (required). Returns: result

rhino_sel_noneA

Deselect all objects.

Inputs: no named parameters. Returns: result

rhino_sel_small_objectsB
    Select objects smaller than the given tolerance.
    
    Args:
    tolerance: Maximum bounding box size threshold.
    

Inputs: tolerance. Returns: result

rhino_set_background_colorA
    Set the viewport background color via a Python script.
    
    Args:
    r, g, b: RGB color components (0-255).
    

Inputs: b, g, r. Returns: result

rhino_set_control_pointsC

Replace control points of a NURBS curve or surface.

Inputs: args (required). Returns: object

rhino_set_cplaneC
    Set the construction plane origin for the specified viewport.
    
    Args:
    controller: RhinoController instance.
    view: Viewport name (Perspective, Top, Front, Right, etc.).
    origin_x: X coordinate of the new CPlane origin.
    origin_y: Y coordinate of the new CPlane origin.
    origin_z: Z coordinate of the new CPlane origin.
    
    Returns:
    Dict with command result.
    

Inputs: view, origin_x, origin_y, origin_z. Returns: result

rhino_set_display_modeA
    Set the active viewport display mode.
    
    Args:
    mode: One of Wireframe, Shaded, Rendered, Ghosted, Raytraced,
    ArtisticRendering, Pen, Technical.
    

Inputs: mode. Returns: result

rhino_set_document_textA
    Store a document-level key/value string (persists in the .3dm file).
    
    Args:
    key: Key name.
    value: Value string.
    

Inputs: key (required), value (required). Returns: result

rhino_set_gridB
    Configure viewport grid settings.
    
    Args:
    controller: RhinoController instance.
    grid_snap: Snap spacing size (default 1.0).
    minor_gridlines: Number of minor grid lines (default 10).
    major_gridlines: Number of major grid lines per minor (default 10).
    
    Returns:
    Dict with command result.
    

Inputs: grid_snap, major_gridlines, minor_gridlines. Returns: result

rhino_set_object_colorA
    Set the display color for selected objects.
    
    Args:
    r, g, b: RGB color components (0-255).
    use_layer_color: If True, reset to layer color instead of setting a custom color.
    

Inputs: b, g, r, use_layer_color. Returns: result

rhino_set_object_layerB
    Move all currently selected objects to the specified layer.
    
    Args:
    layer_name: Target layer name.
    

Inputs: layer_name (required). Returns: result

rhino_set_object_materialC
    Assign a named render material to currently selected objects.
    
    Args:
    material_name: Name of the render material.
    

Inputs: material_name (required). Returns: result

rhino_set_object_nameA
    Set the name attribute on all currently selected objects.
    
    Args:
    name: Name string to assign.
    

Inputs: name (required). Returns: result

rhino_set_osnapB
    Set active object snap modes.
    
    Args:
    controller: RhinoController instance.
    modes: List of osnap mode names to enable, e.g.
    ['End', 'Mid', 'Cen', 'Int', 'Near', 'Point'].
    Pass an empty list to disable all.
    Defaults to ['End', 'Mid', 'Cen', 'Int', 'Near'].
    
    Returns:
    Dict with command result.
    

Inputs: modes. Returns: result

rhino_set_point_weightB
    Set the weight of selected NURBS control points (for rational surfaces/curves).
    
    Args:
    weight: Control point weight value.
    

Inputs: weight. Returns: result

rhino_set_render_resolutionC
    Set the document render output resolution.
    
    Args:
    width: Render width in pixels.
    height: Render height in pixels.
    

Inputs: width, height. Returns: result

rhino_set_snapA
    Enable or disable grid snap and set snap spacing.
    
    Args:
    controller: RhinoController instance.
    enabled: True to enable snap, False to disable.
    snap_size: The snap grid size (default 1.0).
    
    Returns:
    Dict with command result.
    

Inputs: enabled, snap_size. Returns: result

rhino_set_unitsB
    Set the document unit system.
    
    Args:
    controller: RhinoController instance.
    unit_system: One of Millimeters, Meters, Centimeters, Inches, Feet, etc.
    
    Returns:
    Dict with command result.
    

Inputs: unit_system. Returns: result

rhino_set_user_textB

Attach a key-value user text entry to an object.

Inputs: args (required). Returns: object

rhino_set_viewB
    Set the active viewport to a standard view.
    
    Args:
    view_name: One of Top, Front, Right, Perspective, Back, Left, Bottom, Isometric.
    viewport: Optional viewport name to target.
    

Inputs: viewport, view_name. Returns: result

rhino_shadow_projectB

Project objects' bounding-box corners along sun_vector to the ground plane.

    Standalone produces a coarse 4-corner shadow polygon per object
    (suitable for sketch-grade studies). Bridge mode emits accurate
    wireframe-projection shadow polygons.
    

Inputs: args (required). Returns: object

rhino_shellC
Destructive

Hollow a closed Brep, optionally leaving the listed faces open.

Inputs: args (required). Returns: object

rhino_show_dirB
    Show the normal and/or curve direction of selected objects.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

Inputs: no named parameters. Returns: result

rhino_show_edgesB
    Highlight edges of selected surfaces by type.
    
    Valid modes: Naked, Non-manifold, All.
    
    Args:
    controller: RhinoController instance.
    mode: Edge type to display.
    
    Returns:
    Dict with command result.
    

Inputs: mode. Returns: result

rhino_show_endpointsB
    Toggle display of curve endpoints.
    
    Args:
    show: True to show endpoints, False to hide.
    

Inputs: show. Returns: result

rhino_show_selectedC

Show all hidden objects.

Inputs: no named parameters. Returns: result

rhino_shrink_trimmed_srfA
    Shrink the underlying surface to its trim boundary.
    
    Pre-select the trimmed surface before calling.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: no named parameters. Returns: result

rhino_shrink_wrapC
    Shrink-wrap selected geometry into a watertight mesh.
    
    Args:
    controller: RhinoController instance.
    resolution: Target voxel resolution for the wrap.
    

Inputs: resolution. Returns: result

rhino_silhouetteA
    Extract silhouette curves from selected surfaces or meshes.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

Inputs: no named parameters. Returns: result

rhino_skin_from_sectionsA

Generate a skin (loft-equivalent) through ordered section curves.

    - Standalone: chains ``CreateRuledSurface`` between adjacent section
      pairs and returns the list of surface IDs; the caller can join them
      downstream if needed.
    - Bridge: emits a single Brep loft via ``Brep.CreateFromLoft``.
    

Inputs: args (required). Returns: object

rhino_slabC
    Create a slab (extruded planar surface with thickness) from curves.
    
    Args:
    controller: RhinoController instance.
    thickness: Slab thickness.
    

Inputs: thickness. Returns: result

rhino_smoothA
    Smooth selected objects by averaging control-point positions.
    
    Args:
    controller: RhinoController instance.
    strength: Smoothing strength (0–1).
    iterations: Number of smoothing passes.
    
    Returns:
    Dict with command result.
    

Inputs: strength, iterations. Returns: result

rhino_smooth_polylineA

Apply Laplacian smoothing to a polyline (or NURBS curve via its control points).

    Each iteration replaces every interior point P_i with
    ``(1 - factor) * P_i + factor * (P_{i-1} + P_{i+1}) / 2``.
    With ``pin_endpoints=True`` the first and last points are held.
    Returns the new curve's object_id (the input is replaced).
    

Inputs: args (required). Returns: object

rhino_soft_edit_curveB

Apply soft (smooth falloff) editing to a selected curve.

Inputs: no named parameters. Returns: result

rhino_soft_edit_surfaceA

Apply soft (smooth falloff) editing to a selected surface.

Inputs: no named parameters. Returns: result

rhino_solar_exposure_estimateA
Read-only

Estimate cumulative solar exposure (lit minutes / total minutes) on an object (bridge only).

Bridge implementation samples the time range, casts a ray from the target's centroid toward the sun at each step, and counts lit samples (no obstruction along the ray). Returns a 0-1 ratio.

Inputs: args (required). Returns: object

rhino_solid_pt_onB
    Enable solid point editing for selected polysurfaces.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_sphereC

Add a sphere primitive.

Inputs: args (required). Returns: object

rhino_spiralC

Add a tapered spiral sampled into a NURBS curve.

Inputs: args (required). Returns: object

rhino_splitC
    Split selected objects with cutting objects (interactive).
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

Inputs: no named parameters. Returns: result

rhino_srf_from_3_4_ptsB
    Create a surface from 3 or 4 corner points.
    
    Args:
    controller: RhinoController instance.
    pts:        List of 3 or 4 points; each element is an (x, y, z) tuple
    or a 'x,y,z' string.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: pts (required). Returns: result

rhino_stack_floorsA

Replicate a source object N times along world +Z with constant spacing.

    Architectural shortcut for "stack this slab N floors high". The source
    sits at level 0; copies populate levels 1 .. floor_count.
    

Inputs: args (required). Returns: object

rhino_statusC
    Return the current Rhino connection status plus the default files directory.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict containing status info and rhino_files_dir.
    

Inputs: no named parameters. Returns: result

rhino_stitchC
    Stitch selected surface edges together within a tolerance.
    
    Args:
    controller: RhinoController instance.
    tolerance: Stitching tolerance.
    
    Returns:
    Dict with command result.
    

Inputs: tolerance. Returns: result

rhino_subd_boxA
    Create a SubD box primitive.
    
    Args:
    controller: RhinoController instance.
    x: X coordinate of base corner.
    y: Y coordinate of base corner.
    z: Z coordinate of base corner.
    length: Box length along X.
    width: Box width along Y.
    height: Box height along Z.
    face_x: Number of faces along X.
    face_y: Number of faces along Y.
    face_z: Number of faces along Z.
    

Inputs: x, y, z, width, +5 more. Returns: result

rhino_subd_coneB
    Create a SubD cone primitive.
    
    Args:
    controller: RhinoController instance.
    x: X coordinate of base center.
    y: Y coordinate of base center.
    z: Z coordinate of base center.
    radius: Cone base radius.
    height: Cone height.
    

Inputs: x, y, z, height, +1 more. Returns: result

rhino_subd_creaseA
    Add a crease to selected SubD edges, making them sharp.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_subd_cylinderA
    Create a SubD cylinder primitive.
    
    Args:
    controller: RhinoController instance.
    x: X coordinate of base center.
    y: Y coordinate of base center.
    z: Z coordinate of base center.
    radius: Cylinder radius.
    height: Cylinder height.
    

Inputs: x, y, z, height, +1 more. Returns: result

rhino_subd_display_toggleB
    Toggle SubD display between smooth and box (control polygon) modes.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_subd_expand_edgesB
    Expand selected SubD edges outward by a given distance.
    
    Args:
    controller: RhinoController instance.
    distance: Expansion distance.
    

Inputs: distance. Returns: result

rhino_subdivideC
    Subdivide selected SubD objects a given number of times.
    
    Args:
    controller: RhinoController instance.
    count: Number of subdivision iterations.
    

Inputs: count. Returns: result

rhino_subd_loftA
    Create a SubD loft surface through selected curves.
    
    Args:
    controller: RhinoController instance.
    closed: Create a closed (periodic) loft.
    

Inputs: closed. Returns: result

rhino_subd_planeB
    Create a SubD plane primitive.
    
    Args:
    controller: RhinoController instance.
    x: X coordinate of start corner.
    y: Y coordinate of start corner.
    z: Z coordinate of start corner.
    length: Plane length along U.
    width: Plane width along V.
    count_u: Number of faces along U.
    count_v: Number of faces along V.
    

Inputs: x, y, z, width, +3 more. Returns: result

rhino_subd_sphereB
    Create a SubD sphere primitive.
    
    Args:
    controller: RhinoController instance.
    x: X coordinate of center.
    y: Y coordinate of center.
    z: Z coordinate of center.
    radius: Sphere radius.
    subdivisions: Number of subdivision levels.
    

Inputs: x, y, z, radius, +1 more. Returns: result

rhino_subd_sweep1B
    Create a SubD sweep along one rail curve.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_subd_sweep2B
    Create a SubD sweep along two rail curves.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_subd_to_nurbsC

Convert a SubD object to a NURBS polysurface (Brep).

Inputs: args (required). Returns: object

rhino_subd_torusA
    Create a SubD torus primitive.
    
    Args:
    controller: RhinoController instance.
    x: X coordinate of center.
    y: Y coordinate of center.
    z: Z coordinate of center.
    major_radius: Torus major (outer) radius.
    minor_radius: Torus minor (tube) radius.
    

Inputs: x, y, z, major_radius, +1 more. Returns: result

rhino_sun_pathB

Draw monthly sun-path polylines on a hemisphere of given radius around center_point.

    Standalone draws into the active rhino3dm document; bridge mode
    forwards so the path is visible in Rhino's viewport.
    

Inputs: args (required). Returns: object

rhino_sun_positionB
Read-onlyIdempotent

Compute solar azimuth + altitude for a location/time. Pure calculation, no doc edits.

Inputs: args (required). Returns: object

rhino_sun_settingsB
    Configure the Rhino sun/sky system via Python.
    
    Args:
    enabled: Enable or disable the sun.
    latitude: Observer latitude in degrees.
    longitude: Observer longitude in degrees.
    year, month, day: Date settings.
    hour: Hour of day (24h float, e.g. 14.5 = 2:30 PM).
    

Inputs: day, hour, year, month, +3 more. Returns: result

rhino_surface_closest_pointA
Read-only

Find the UV parameters and 3D point closest to a test point on a surface.

Inputs: args (required). Returns: object

rhino_surface_curvature_atB
Read-only

Evaluate true Gaussian / mean / principal curvatures at (u, v) (bridge only).

Inputs: args (required). Returns: object

rhino_surface_developable_scoreA
Read-only

Estimate how far a surface deviates from being developable.

    Samples a (sample_u+1) x (sample_v+1) grid of normals; for each
    interior 2x2 block computes the maximum angle (in radians) between
    adjacent normals. Reports max / mean / RMS over the whole sheet
    plus a 0..1 normalised score (0 = perfectly developable,
    1 = π/2 normal swing within a single cell).

    A truly developable surface (cone, cylinder, plane) returns ~0;
    a sphere section returns a positive value proportional to the
    spanned solid angle.
    

Inputs: args (required). Returns: object

rhino_surface_from_pointsB

Create a NURBS surface from a 2D grid of control points.

Inputs: args (required). Returns: object

rhino_surface_normal_atA
Read-only

Evaluate the surface unit normal at a normalised (u, v).

    ``u`` and ``v`` are 0..1 ratios over the surface's domain; the
    actual parameters are computed internally so the LLM doesn't need
    to know the domain bounds.
    

Inputs: args (required). Returns: object

rhino_sweep1A

Sweep profiles along a single rail.

Inputs: args (required). Returns: object

rhino_sweep2C

Sweep profiles along two rails.

Inputs: args (required). Returns: object

rhino_system_infoB
    Retrieve Rhino system information.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with system info output.
    

Inputs: no named parameters. Returns: result

rhino_taperC

Taper objects along an axis with start/end radii.

Inputs: args (required). Returns: object

rhino_textC

Add 3D text annotation. Bridge mode honours the active dim style; standalone uses text-dot fallback.

Inputs: args (required). Returns: object

rhino_text_dotA

Add a small label that always faces the camera in Rhino.

Inputs: args (required). Returns: object

rhino_thickness_analysisA
    Display a thickness analysis on selected closed polysurfaces.
    
    Args:
    controller: RhinoController instance.
    max_thickness: Maximum thickness value for the colour scale.
    
    Returns:
    Dict with command result.
    

Inputs: max_thickness. Returns: result

rhino_toggle_gridA

Toggle the viewport construction grid on/off.

Inputs: no named parameters. Returns: result

rhino_tolerance_getA
Read-only

Read absolute / angle / relative model tolerances.

Inputs: args (required). Returns: object

rhino_tolerance_setA

Set absolute / angle / (optional) relative tolerances on the document.

Inputs: args (required). Returns: object

rhino_to_nurbsB
    Convert selected SubD objects to NURBS surfaces.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_torusB

Add a torus primitive (mesh approximation in standalone mode).

Inputs: args (required). Returns: object

rhino_to_subdB
    Convert selected NURBS or mesh objects to SubD.
    
    Args:
    controller: RhinoController instance.
    method: Conversion method (e.g., 'FromNURBS', 'FromMesh').
    

Inputs: method. Returns: result

rhino_triangulate_meshA
    Convert all quad faces in selected meshes to triangles.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_trimB
    Trim objects using selected cutting objects (interactive).
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

Inputs: no named parameters. Returns: result

rhino_truncated_coneA
    Create a truncated cone (frustum) in Rhino using the TruncatedCone command.
    
    Rhino prompts: base center -> base radius -> height -> top radius.
    
    Args:
    controller:     RhinoController instance.
    x, y, z:        Center of the base circle.
    bottom_radius:  Radius of the base (larger) circle.
    top_radius:     Radius of the top (smaller) circle.
    height:         Height between the two circles.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: x, y, z, height, +2 more. Returns: result

rhino_tubeB
    Create a hollow cylindrical tube in Rhino.
    
    Args:
    controller:   RhinoController instance.
    x, y, z:      Center of the base annulus.
    outer_radius: Outer radius of the tube.
    thickness:    Wall thickness (inner_radius = outer_radius - thickness).
    height:       Height of the tube.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: x, y, z, height, +2 more. Returns: result

rhino_turntableC

Render a turntable animation to output_path (PNG sequence or GIF).

Inputs: args (required). Returns: object

rhino_turntable_renderC

Render a turntable sequence (camera orbits around target) to output_dir.

Inputs: args (required). Returns: object

rhino_tween_surfacesA
    Generate tween (morphed intermediate) surfaces between two surfaces.
    
    Pre-select the two source surfaces before calling.
    
    Args:
    controller: RhinoController instance.
    count:      Number of intermediate tween surfaces to generate.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: count. Returns: result

rhino_twistC

Twist objects around an axis by a specified angle.

Inputs: args (required). Returns: object

rhino_undoA

Undo the last operation(s) in the Rhino document.

Each step reverses one undo record. Changes made by MCP tools are grouped into undo records automatically.

Inputs: args (required). Returns: object

rhino_ungroupA

Ungroup selected groups, releasing individual objects.

Inputs: no named parameters. Returns: result

rhino_unify_mesh_normalsB
    Unify the normals of selected mesh faces to all point outward.
    
    Args:
    controller: RhinoController instance.
    

Inputs: no named parameters. Returns: result

rhino_unjoin_edgeB
    Un-join selected edges from a polysurface.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

Inputs: no named parameters. Returns: result

rhino_unlock_allA

Unlock all locked objects in the document.

Inputs: no named parameters. Returns: result

rhino_unrollA

Unroll a developable surface or polysurface flat.

Inputs: args (required). Returns: object

rhino_untrimA
    Remove trim boundaries from selected surfaces.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result.
    

Inputs: no named parameters. Returns: result

rhino_unweld_meshC

Unweld vertices to break mesh smoothing.

Inputs: args (required). Returns: object

rhino_uv_grid_panelsA

Sample a surface on a regular UxV grid and emit it as panels.

    ``output='mesh'`` writes a single quad mesh (one face per panel) to
    the doc; ``'curves'`` writes count_u+count_v isocurves; ``'corners'``
    only returns the (count_u+1) x (count_v+1) sample points without
    writing geometry.
    

Inputs: args (required). Returns: object

rhino_validate_brepB
Read-only

Validate a Brep — closed/solid/manifold, face/edge counts, log of issues.

    Standalone surfaces ``IsValid``/``IsSolid``/``IsManifold``/edge+face
    counts and the rhino3dm validation log. Bridge mode adds a list of
    naked-edge identifiers and lengths via RhinoCommon.
    

Inputs: args (required). Returns: object

rhino_variable_blend_srfA
    Create a variable-radius blend surface between two surface edges.
    
    Pre-select the two naked edges before calling.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with 'status' and 'command' keys.
    

Inputs: no named parameters. Returns: result

rhino_variable_filletA
    Create a variable-radius fillet surface between two surfaces.
    
    The start/end radii are passed as option overrides; edge selection
    is performed interactively.
    
    Args:
    controller: RhinoController instance.
    start_radius: Fillet radius at the start of the edge.
    end_radius: Fillet radius at the end of the edge.
    
    Returns:
    Dict with command result.
    

Inputs: end_radius, start_radius. Returns: result

rhino_view_capture_to_clipboardA
    Capture the active viewport to the clipboard.
    
    Args:
    width: Image width in pixels.
    height: Image height in pixels.
    

Inputs: width, height. Returns: result

rhino_view_capture_to_fileA
    Capture the active viewport to a PNG file.
    
    Args:
    file_name: Output filename (saved to D:/RhinoFiles/).
    width: Image width in pixels.
    height: Image height in pixels.
    

Inputs: width, height, file_name. Returns: result

rhino_viewport_imageA

Save the current viewport pixels to a PNG file.

    Lightweight alternative to ``rhino_render_to_file`` — no render engine
    is invoked, just a viewport bitmap dump. Use 0 for ``width``/``height``
    to inherit the on-screen viewport size.
    

Inputs: args (required). Returns: object

rhino_viewport_previewA

Capture a viewport preview restricted to a selection or layer set.

    Spotlights ``selection_ids`` and/or objects on ``layers``; everything
    else is either ghosted (default) or hidden during the capture and
    restored afterwards. Useful for multi-step LLM verification flows
    where only the recently added objects need to be visualised. Bridge
    only.
    

Inputs: args (required). Returns: object

rhino_view_setC

Activate a saved named view.

Inputs: args (required). Returns: object

rhino_volumeA
Read-onlyIdempotent

Compute the volume of a closed mesh (Brep volume requires bridge).

Inputs: args (required). Returns: object

rhino_volume_centroidA
    Calculate the volume centroid of selected closed solids.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result containing centroid coordinates.
    

Inputs: no named parameters. Returns: result

rhino_weld_meshB

Weld coincident vertices in a mesh.

Inputs: args (required). Returns: object

rhino_whatB
    Display detailed properties of selected objects.
    
    Args:
    controller: RhinoController instance.
    
    Returns:
    Dict with command result containing object information.
    

Inputs: no named parameters. Returns: result

rhino_wire_cutB
    Cut a solid with a wire (curve) extruded through the object.
    
    Args:
    controller: RhinoController instance.
    depth: Cut depth (extrusion distance of the wire).
    

Inputs: depth. Returns: result

rhino_zebraC
Read-only

Run zebra-stripe surface continuity analysis (bridge required).

Inputs: args (required). Returns: object

rhino_zebra_analysisC
    Display zebra stripe analysis on selected surfaces.
    
    Args:
    controller: RhinoController instance.
    stripe_direction: 'Horizontal' or 'Vertical'.
    stripe_size: Size of the zebra stripes.
    
    Returns:
    Dict with command result.
    

Inputs: stripe_size, stripe_direction. Returns: result

rhino_zoom_extentA

Zoom the active view to the extent of selected (or all) objects.

Inputs: args (required). Returns: object

rhino_zoom_extentsA
    Zoom to the extents of all geometry.
    
    Args:
    all_viewports: If True, zoom all viewports; otherwise only the active one.
    

Inputs: all_viewports. Returns: result

rhino_zoom_layerA

Zoom the active viewport to fit every object on layer.

Inputs: args (required). Returns: object

rhino_zoom_objectA

Zoom the active viewport to fit the given object ids exactly.

Inputs: args (required). Returns: object

rhino_zoom_selectedA

Zoom to fit the currently selected objects.

Inputs: no named parameters. Returns: result

rhino_zoom_windowA

Enter zoom-window mode (user draws a rectangle to zoom into).

Inputs: no named parameters. Returns: result

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    C2.5/5.0

    Scored across 542 tools

    Disambiguation1/5

    Dozens of tools appear to do the same thing: rhino_box and rhino_cmd_box, rhino_sphere and rhino_cmd_sphere, rhino_boolean_union and rhino_cmd_boolean_union, rhino_execute_python and rhino_run_python, plus many overlapping render/capture tools. An agent cannot reliably tell which variant to call without extensive inferencing.

    Naming Consistency2/5

    The rhino_ prefix and mostly snake_case naming provide some consistency, but conventions are mixed across what look like multiple API generations: rhino_cmd_* coexists with direct rhino_* calls, run_* coexists with execute_*, sel_* coexists with object_select, and some pairs reverse verb order (rhino_set_view vs rhino_view_set, rhino_set_display_mode vs rhino_display_mode_set). The gh_* tools add a second naming world.

    Tool Count1/5

    542 tools is an extreme mismatch for a coherent MCP surface, even for a broad CAD application. The count is inflated by large numbers of duplicate and near-duplicate operations rather than by genuinely distinct capabilities.

    Completeness4/5

    The set covers an unusually broad range of Rhino domains: primitives, curves, surfaces, meshes, SubD, booleans, transforms, layers, materials, rendering, annotations, blocks, BIM, analysis, import/export, and Grasshopper. There are minor gaps such as curve-level fillet/chamfer and some bridge-only limitations, but the generic rhino_run_command and rhino_execute_python tools let agents work around most omissions.

    Maintenance

    ActivityStale
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      GOLEM-3DMCP implements the Model Context Protocol to give AI agents direct, programmatic control of Rhino 8 — create geometry, run booleans, drive Grasshopper, capture viewports, and execute arbitrary Python scripts, all through natural language. Works with Claude Code, Cursor, Windsurf, and any MCP-compatible host.
      16
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Connects Rhino and Grasshopper to Claude AI via the Model Context Protocol, enabling prompt-assisted 3D modeling, scene manipulation, and control through tools like object creation, layer management, and code execution.
      32
      MIT