Rhino, powered by code
Rig is a plugin for Rhino that lets you create parametric, interactive, component-based models using code.
Everything you need for parametric modeling
A modern, developer-friendly plugin that makes 3D modeling in Rhino feel like building software.
Component Architecture
Break complex models into composable components. Each piece is a simple C# class with clear inputs, outputs, and geometry.
Your Favorite IDE
Work in Visual Studio, VS Code, or Rider with full autocomplete, syntax highlighting, debugging, refactoring, and AI agents. All the tools you already love.
Live UI Panel
Expose sliders, color pickers, dropdowns, and buttons directly in a Rhino panel. Tweak parameters interactively while you design.
Dependency Injection
Wire components together automatically. Rig resolves dependencies and configures the entire model tree for you.
Hot Reload
Edit your C# code and see changes instantly in Rhino. No restart needed. Rig watches your source files and rebuilds on the fly.
Model Preview
When your model is ready, bake the entire scene to the Rhino document. All components, attributes, and transforms included.
Why Rig?
There are three popular ways to build parametric models in Rhino today, and each one runs into walls as the model grows.
Record History
Captures the steps used to create geometry so downstream objects update with their inputs. But any edit that bypasses a history-aware command silently breaks the chain, and the dependency graph is invisible, so there's no way to see what's still tracked.
Grasshopper
A joy for small models, but node diagrams become hard to navigate and refactor as they grow. Encapsulation is limited, so logic rarely transfers between projects. And .gh files aren't built for version control.
Scripting
Full language power, but in practice scripts query the document, look objects up by name, and mutate state. There's no dependency tracking, no component boundaries, and renaming or deleting an object breaks every script that referenced it.
How Rig solves it
Rig represents models as plain code organized into components. Each component declares its inputs, geometry, and dependencies as real class members, so the dependency graph is explicit and the engine knows exactly what to recompute when something changes. Geometry from each component is exposed as a strongly-typed property, so referencing another part of the model is just a member access with full autocomplete and compile-time safety.
To make models interactive, you expose sliders, dropdowns, and color pickers in a Rhino panel, and the geometry updates live as designers tweak them. Components are real classes that can be reused, tested, and shared across projects like any other library. And because models are plain code, they work naturally with Git, code review, any editor, and AI agents.
Built for AI
AI is remarkably good at writing code, and a Rig model is just plain, component-based C#. That makes Rig the ideal target for AI-assisted design: an agent can scaffold components, wire up parameters, and refine geometry the same way it works on any other software project.
AI can already generate geometry and Grasshopper definitions directly, but those outputs inherit the same limitations as building them by hand.
AI-generated geometry
Geometry produced directly by AI is baked and rigid. It captures one frozen result with no parameters to adjust, so the moment the design needs to change you are back to regenerating it from scratch rather than tweaking what you have.
AI-generated Grasshopper
AI-generated node definitions still suffer from the complexity of Grasshopper itself. The resulting graphs are tangled and hard to read, which makes them difficult to understand, trust, and maintain as the model evolves.
Why Rig is different
Because a Rig model is parametric, component-based code, AI generates something you can actually live with: real classes with named inputs, an explicit dependency graph, and geometry exposed as strongly-typed properties. The output reads like the rest of your codebase, so it is easy to review, refactor, test, and keep editing — with live sliders in the Rhino panel and full version control, whether the next change comes from you or an agent.
Development Workflow
Rig bridges visual modeling and code-driven logic for a seamless, interactive workflow.
Open Your Project
Open your model project (just a C# project) in your favorite IDE and run it. Rig launches Rhino and loads your model automatically.
Model & Code in Parallel
Visualize and interact with live geometry in Rhino while writing or modifying components in your IDE.
Hot Reload
Save a .cs file and the HotReloadService rebuilds the project via dotnet build and reloads the assembly. All dependent components update automatically.
Tweak in the Live Panel
Adjust parameters with numeric up/downs, dropdowns, sliders, color pickers, and more. Changes trigger re-evaluation of dependent geometry in real time.
Save and Continue Working
Save your .3dm model in Rhino as usual and save your source files in the IDE.