Rhino and AI

Rhino AI connects an AI assistant directly to a live Rhino document. Ask for geometry and it appears in the viewport; describe a Grasshopper definition and it gets built on the canvas; point the assistant at what is already on screen and it can read the model, the selection, and the view. It runs inside Rhino in its own panel, or from the assistant you already use.

Download a fully functioning 90-day evaluation…

Rhino AI

Rhino AI is open source and in active development. It is available now for anyone who wants to work with it early and tell us what breaks.

Inside Rhino

Run the AIPanel command and the assistant docks alongside your other Rhino panels. Describe what you want built and watch it happen in the document: no copying code between windows, no switching applications, no second copy of your model.

• Pick your agent - Claude, Codex, or Gemini, selected in the panel header and switchable per conversation.
• Point at what matters - type @ to hand the assistant a specific object, layer, or view instead of letting it guess.
• It can see the result - the assistant reads the document and captures the viewport, so it works from what is actually there rather than from your description of it.
• Runs in Rhino 8 and Rhino 9 - creating a reusable Rhino command from a prompt requires Rhino 9.

You decide what it can touch

The AISettings command is where you set the boundaries. Every tool the assistant can reach is listed and grouped by what it does to your work, and each one can be switched off individually.

• Read-only - inspect the document, list objects, search Grasshopper components, read the canvas. Nothing changes.
• Modify - place and wire components, solve the canvas, set the camera, capture a view.
• Destructive - run scripts, run Rhino commands, open, save, or close documents, clear a canvas.
• Your agents, your keys - configure Claude, Codex, and Gemini independently, each with its own model and its own standing instructions.

Unchecking a tool hides it from agents running inside Rhino. External clients connected over the Model Context Protocol still see every tool.

Bring your own assistant

Rhino AI speaks the Model Context Protocol, so the assistant you already work in can drive Rhino and Grasshopper without leaving its own window.

• Claude Desktop - the quickest route: install the connector and it sets up the Rhino plugin for you.
• Terminal assistants - Claude Code, OpenAI Codex, and Gemini CLI point at the Rhino MCP router from their own configuration.
• In your editor - GitHub Copilot in VS Code, switched to Agent mode. Cursor and other MCP-capable assistants connect the same way.
• Local models - run an open-weight model on your own machine and work without sending anything over the Internet.

What you can ask it to do

The documented examples are deliberately ordinary: the work you would otherwise do by hand.

• Model from an image - hand it a reference and get geometry back.
• Build a Grasshopper definition - describe the behavior you want and it places and wires the components, then solves the canvas.
• Sketch to model - drop in a sketch, agree on an interpretation, get a first-pass parametric build.
• Organize a document - sort what is in the view onto sensible layers.

AI in the Design Process

An assistant that can read your model and act on it changes what is worth trying. These are the places it shows up first.

Design Iteration

Parametric models were always meant to be explored rather than admired. The bottleneck was never the solver; it was the time it took to build and rebuild the definition. An assistant that can place components, wire them, and solve the canvas takes that cost down far enough that trying the other idea stops being a decision.

• Build the definition by describing it - state the behavior you want; let the assistant assemble the graph.
• Rebuild rather than patch - restructuring a definition stops being a reason not to change your mind.
• Move between Grasshopper versions - port a definition onto a Grasshopper 2 canvas and check that both solve to the same result.
• Stay in review - the assistant does the assembly. The judgment about whether it is any good stays yours.

Visualization

Rhino AI is not an image generator. What it does is see: it can frame a view, set the camera, and capture the viewport, which means the assistant works from the model as it actually looks rather than from a description of it. That closes the loop on everything else on this page.

• Set up the shot - describe the view you want and let the assistant position the camera.
• Capture and compare - take viewport images as you iterate and put versions side by side.
• Hand it back - give the assistant a render and ask what is wrong with it.
• Bring your own renderer - the growing ecosystem of AI imaging tools for Rhino sits alongside this rather than inside it.

Model Organization

Some of the most useful work an assistant does is the work nobody wants to do. Layers, names, materials, and the state of an imported file are exactly the kind of structured, tedious, rule-following task that a model is good at and a designer resents.

• Sort what you have - organize a messy import onto sensible layers by name, type, or location.
• Query the model - ask what is on a layer, what is currently selected, or what a given object actually is.
• Set up the document - layers, materials, and named views described rather than clicked.
• Handle the batch - open, process, and save across a set of files.

Building with AI

Rhino has always been scriptable. What changed is who writes the script.

AI-Assisted Scripting

• Python 3 and C# - the assistant writes and runs scripts against the open document, reads back what happened, and fixes what did not work.
• Discover before you write - it can list the available Rhino commands and look up Grasshopper components by name, category, and parameters.
• Make it reusable - turn a working prompt into a proper Rhino command, available immediately. Rhino 9 or later.
• You stay the reviewer - scripting tools sit in the Destructive group, switchable off in AISettings.

Vibe Coding

The term is loose; what it means in Rhino is specific. You describe the outcome in plain language, the assistant writes and runs the code against your live document, and you judge the result by looking at it rather than by reading the source. It works because the feedback loop is short and visual: if the geometry is wrong, you say so and it tries again.

• Describe, run, look, adjust - the loop is conversational, not a specification handed over a wall.
• The model is the test - correctness is visible in the viewport, not buried in a log.
• Keep what works - a prompt that produces the right result can become a saved command.
• Know the limits - it is fast at the first eighty percent and still needs you for the rest.

For Developers

Rhino AI is as useful pointed at a plugin project as at a model.

• Upgrade a plugin to .NET Core - move a net48 project onto current targets with an assistant doing the mechanical work.
• Port components to Grasshopper 2 - scaffold the equivalents and verify them side by side on both canvases.
• Extend it - the project is open source under an MIT license, with issues and pull requests open.
• Add your own servers - merge additional MCP servers alongside the built-in Rhino server so agents reach your tools too.