Rhino.Scripting
0.16.0
dotnet add package Rhino.Scripting --version 0.16.0
NuGet\Install-Package Rhino.Scripting -Version 0.16.0
<PackageReference Include="Rhino.Scripting" Version="0.16.0" />
<PackageVersion Include="Rhino.Scripting" Version="0.16.0" />
<PackageReference Include="Rhino.Scripting" />
paket add Rhino.Scripting --version 0.16.0
#r "nuget: Rhino.Scripting, 0.16.0"
#:package Rhino.Scripting@0.16.0
#addin nuget:?package=Rhino.Scripting&version=0.16.0
#tool nuget:?package=Rhino.Scripting&version=0.16.0

Rhino.Scripting
Rhino.Scripting is a complete re-implementation of the original RhinoScript syntax in and for F# (and C#).
Before this repo, the high-level RhinoScript API was only available for VBScript and (Iron-)Python.
This repo enables the use of the RhinoScriptSyntax in F# and C#
together with all the great coding experience and editor tooling that come with F# and C#, like:
- automatic code completion while typing.
- automatic error checking and highlighting in the background.
- type info on mouse over.
- type safety even without type annotation (= type inference in F#).
What is RhinoScript?
RhinoScript provides application scripting for the Rhino3D CAD app.
RhinoScript has more than 900 functions to control all kinds of aspects of automating Rhino3D.
It was originally implemented in 2002 in VBScript.
Extensive documentation on the original VBScript-based version is available here.
In 2010, all functions from RhinoScript were reimplemented in IronPython (Python running on .NET).
This allowed the use of a modern, rich, and dynamically typed programming language with a huge standard library and
also access to all functions of the underlying .NET Framework as well as the RhinoCommon SDK.
What is this repo?
This repo has all original RhinoScript functions reimplemented in F#.
It is literally a translation of the open-source IronPython rhinoscriptsyntax implementation to F#.
You can see all 900+ methods in this repo in the docs.
A few minor bugs from the Python implementation are fixed and a few extra methods and optional parameters were added.
I have been using this library extensively for my own professional scripting needs since 2019.
If you have problems, questions, or find a bug, please open an issue.
Get started
The recommended scripting use case is via Fesh, the dedicated F# scripting editor for Rhino.
However, you can use this library just as well in the new Rhino 8 ScriptEditor with C# or in independently compiled F#, C#, or VB.net projects.
Get started in F#
First reference the assemblies.
#r "RhinoCommon"
#r "nuget: Rhino.Scripting"
The main namespace is Rhino.Scripting.
The main class of this library is called RhinoScriptSyntax it has all ~900 functions as static methods.
In F# you can create an alias like this:
open Rhino.Scripting
type rs = RhinoScriptSyntax
then use any of the RhinoScript functions like you would in Python or VBScript.
The CoerceXXXX functions will help you create types if you are too lazy to fully specify them.
let pl = rs.CoercePlane(0 , 80 , 0) // makes World XY plane at point
rs.AddText("Hello, Fesh", pl, height = 50.)
For F# scripting the Rhino.Scripting.Fsharp provides useful extensions and curried functions for piping and partial application.
Get started in C#
You can use it via the new Rhino 8 ScriptEditor. First reference the assemblies.
#r "nuget: Rhino.Scripting"
The main namespace is Rhino.Scripting.
The main class of this library is called RhinoScriptSyntax it has all ~900 functions as static methods.
In C# you can create an alias like this:
using rs = Rhino.Scripting.RhinoScriptSyntax;
then you can use it like the RhinoScriptSyntax in Python:
var pt = rs.GetObject("Select an Object");
rs.ObjectColor(pt, System.Drawing.Color.Blue);
How about the dynamic types and optional parameters from VBScript and Python?
Many RhinoScript functions take variable types of input parameters.
This is implemented with method overloads.
Many RhinoScript functions have optional parameters.
These are also implemented as optional method parameters.
Many RhinoScript functions are getters and setters at the same time.
Depending on if an argument is provided or not, the function acts as a getter or setter.
This is also implemented with method overloads.
Example
For example rs.ObjectLayer can be called in several ways:
To get the layer of one object, returns a string:
rs.ObjectLayer(guid)
To set the layer of one object (fails if layer does not exist), no return value:
rs.ObjectLayer(guid, string)
To set the layer of one object, and create the layer if it does not exist yet, no return value:
rs.ObjectLayer(guid, string, createLayerIfMissing = true )
To set the layer of several objects (fails if layer does not exist), no return value:
rs.ObjectLayer(list of guids, string)
To set the layer of several objects, and create the layer if it does not exist yet, no return value:
rs.ObjectLayer(list of guids, string, createLayerIfMissing = true )
These are implemented with 3 overloads and Optional and DefaultParameterValue parameters:
///<summary>Returns the full layer name of an object.
/// parent layers are separated by <c>::</c>.</summary>
///<param name="objectId">(Guid) The identifier of the object</param>
///<returns>(string) The object's current layer.</returns>
static member ObjectLayer(objectId:Guid) : string = //GET
let obj = RhinoScriptSyntax.CoerceRhinoObject(objectId)
let index = obj.Attributes.LayerIndex
State.Doc.Layers.[index].FullPath
///<summary>Modifies the layer of an object ,
/// optionally creates layer if it does not exist yet.</summary>
///<param name="objectId">(Guid) The identifier of the object</param>
///<param name="layer">(string) Name of an existing layer</param>
///<param name="createLayerIfMissing">(bool) Optional,
/// Default Value: <c>false</c> Set true to create Layer
/// if it does not exist yet.</param>
///<param name="allowAllUnicode">(bool) Optional,
/// Allow Ambiguous Unicode characters too </param>
///<param name="collapseParents">(bool) Optional,
/// Collapse parent layers in Layer UI </param>
///<returns>(unit) void, nothing.</returns>
static member ObjectLayer( objectId:Guid
, layer:string
,[<OPT;DEF(false)>]createLayerIfMissing:bool
,[<OPT;DEF(false:bool)>]allowAllUnicode:bool
,[<OPT;DEF(false:bool)>]collapseParents:bool) : unit = //SET
let obj = RhinoScriptSyntax.CoerceRhinoObject(objectId)
let layerIndex =
if createLayerIfMissing then
UtilLayer.getOrCreateLayer(
layer,
UtilLayer.randomLayerColor,
UtilLayer.ByParent,
UtilLayer.ByParent,
allowAllUnicode,
collapseParents
).Index
else
RhinoScriptSyntax.CoerceLayer(layer).Index
obj.Attributes.LayerIndex <- layerIndex
obj.CommitChanges() |> ignore
State.Doc.Views.Redraw()
///<summary>Modifies the layer of multiple objects, optionally creates
/// layer if it does not exist yet.</summary>
///<param name="objectIds">(Guid seq) The identifiers of the objects</param>
///<param name="layer">(string) Name of an existing layer</param>
///<param name="createLayerIfMissing">(bool) Optional,
/// Default Value: <c>false</c> Set true to create Layer
/// if it does not exist yet.</param>
///<param name="allowUnicode">(bool) Optional,
/// Allow Ambiguous Unicode characters too </param>
///<param name="collapseParents">(bool) Optional,
/// Collapse parent layers in Layer UI </param>
///<returns>(unit) void, nothing.</returns>
static member ObjectLayer( objectIds:Guid seq
, layer:string
, [<OPT;DEF(false)>]createLayerIfMissing:bool
, [<OPT;DEF(false:bool)>]allowUnicode:bool
, [<OPT;DEF(false:bool)>]collapseParents:bool) : unit = //MULTISET
let layerIndex =
if createLayerIfMissing then
UtilLayer.getOrCreateLayer(
layer,
UtilLayer.randomLayerColor,
UtilLayer.ByParent,
UtilLayer.ByParent,
allowUnicode,
collapseParents
).Index
else
RhinoScriptSyntax.CoerceLayer(layer).Index
for objectId in objectIds do
let obj = RhinoScriptSyntax.CoerceRhinoObject(objectId)
obj.Attributes.LayerIndex <- layerIndex
obj.CommitChanges() |> ignore
State.Doc.Views.Redraw()
Objects in the document or plain geometry?
Most functions come in two flavors, chosen by the type of the first argument:
- A
Guid(parameters namedcurveId,objectIds...) refers to an object in the Rhino document. The function reads it, changes it, or, forAddXxxfunctions, adds the result to the document and returns itsGuid. - RhinoCommon geometry (parameters named
curveGeo,surfaceGeo,geometryObject...) is used directly. The function does not touch the document and returns new geometry or a value.
Many AddXxx functions that create geometry from other objects therefore have a matching MakeXxx function.
It does the same calculation on plain geometry, but only creates the result and does not add it to the document.
Use rs.Add to put it into the document when you want it there:
let crv = Circle(Plane.WorldXY, 5.0).ToNurbsCurve()
let brep = rs.MakePlanarSrf(crv) // only geometry, the document is unchanged
let id = rs.Add(brep, "Surfaces", "Disk") // now it is a document object
let ids = rs.AddPlanarSrf([crvId]) // from a curve object in the document, adds the results directly, returns a list of Guids
This is useful to build or test geometry in memory, to filter or transform it before adding it, and to keep temporary results out of the document.
Functions without a Make counterpart, like rs.CurveLength or rs.ExtendCurveLength, have the same overload pairs: one with a Guid and one with geometry.
The API table lists each MakeXxx function right after its matching AddXxx functions.
Full API Documentation
goswinr.github.io/Rhino.Scripting
A single Markdown page with the whole public API in one table, with signatures, default values and summaries, is in skills/rhino.scripting-usage/ApiTable.md.
Agent skill
The NuGet package ships an agent skill, rhino.scripting-usage, for writing scripts with this library. It includes the API table.
To install it into a project, run these from the project folder:
dotnet tool install --global dotnet-package-skills
dotnet-package-skills install
The skill goes to .agents/skills. For Claude Code, use dotnet-package-skills install --destination .claude/skills.
Run the command again after you add or upgrade the package.
.NET Framework or .NET Core?
The NuGet package contains builds for .NET Framework 4.8, .NET 8.0 and .NET 10.0.
Each .NET build can only be loaded when Rhino runs on that .NET runtime or a newer one (see the Rhino command SetDotNetRuntime).
For Rhino 7, and for Rhino 8 running on .NET Framework, use the .NET Framework 4.8 build.
Windows or Mac?
This library should work on Rhino for Mac just as well as on Windows.
Build from source
To build this library from source you need the .NET SDK 10 installed (see global.json)
Then just run in the root folder:
dotnet build ForPublishing.fsproj -c Release
This will first combine all Scripting_*.fs files into one file and compile it.
This is needed because F# type extensions are not visible from C# editor tooling.
Edit the source
While having all 900 methods on one class in one file is needed for publishing via ForPublishing.fsproj
it is not ideal for editing.
The source is split into several files imitating the structure of the original Python implementation.
Open the project ForEditing.fsproj to edit the source.
dotnet build ForEditing.fsproj
After changing the public API, regenerate the API table from the repo root:
dotnet fsi API-Table/ApiTable.fsx
Changelog
see CHANGELOG.md
Thread Safety
While the main Rhino Document is officially not thread safe, this library can be used from any thread.
If running async this library will automatically marshal all calls that affect the UI to the main Rhino UI thread
and wait for switching back till completion on UI thread.
Modifying the Rhino Document from a background thread is actually OK as long as there is only one thread doing it.
The main reason to use this library async is to keep the Rhino UI and Fesh scripting editor UI responsive while doing long running operations.
Contributing
Contributions are welcome even for small things like typos. If you have problems with this library please submit an issue.
License
| Product | Versions Compatible and additional computed target framework versions. |
|---|---|
| .NET | net8.0 is compatible. net8.0-android was computed. net8.0-browser was computed. net8.0-ios was computed. net8.0-maccatalyst was computed. net8.0-macos was computed. net8.0-tvos was computed. net8.0-windows was computed. net9.0 was computed. net9.0-android was computed. net9.0-browser was computed. net9.0-ios was computed. net9.0-maccatalyst was computed. net9.0-macos was computed. net9.0-tvos was computed. net9.0-windows was computed. net10.0 is compatible. net10.0-android was computed. net10.0-browser was computed. net10.0-ios was computed. net10.0-maccatalyst was computed. net10.0-macos was computed. net10.0-tvos was computed. net10.0-windows was computed. |
| .NET Framework | net48 is compatible. net481 was computed. |
-
.NETFramework 4.8
- FSharp.Core (>= 6.0.7)
-
net10.0
- FSharp.Core (>= 6.0.7)
-
net8.0
- FSharp.Core (>= 6.0.7)
NuGet packages (1)
Showing the top 1 NuGet packages that depend on Rhino.Scripting:
| Package | Downloads |
|---|---|
|
Rhino.Scripting.FSharp
The full Rhino.Scripting library and additional functionality for scripting Rhino3D with F# |
GitHub repositories
This package is not used by any popular GitHub repositories.
| Version | Downloads | Last Updated |
|---|---|---|
| 0.16.0 | 83 | 11/15/2026 |
| 0.15.0 | 236 | 10/11/2026 |
| 0.14.0 | 502 | 4/8/2026 |
| 0.13.0 | 344 | 1/17/2026 |
| 0.12.1 | 216 | 1/4/2026 |
| 0.12.0 | 643 | 5/26/2025 |
| 0.11.0 | 310 | 5/24/2025 |
| 0.11.0-net7 | 281 | 4/9/2025 |
| 0.10.1 | 406 | 3/15/2025 |
| 0.10.0 | 392 | 3/6/2025 |
| 0.9.0 | 292 | 3/2/2025 |
| 0.8.2 | 316 | 2/23/2025 |
| 0.8.0 | 369 | 9/28/2024 |
| 0.7.0 | 458 | 9/10/2023 |
| 0.6.2 | 393 | 7/9/2023 |
| 0.6.1 | 368 | 6/18/2023 |
| 0.6.0 | 372 | 5/7/2023 |
| 0.5.1 | 505 | 2/20/2023 |
| 0.5.0 | 460 | 2/18/2023 |
| 0.4.0 | 491 | 1/21/2023 |
### Added
- Overloads taking a plug-in Guid for EnablePlugIn (get and set), GetPlugInObject, IsPlugIn and DefaultRenderer, next to the existing overloads taking a plug-in name.
- UnitSystem setters accept Rhino.UnitSystem enum values for model and page units, preserving the existing integer overloads and validation.
- UnitScale accepts Rhino.UnitSystem enum values for either unit argument, including mixed enum/integer calls and conversion from the current model units.
- JoinSurfacesAll returns every joined result, restoring RhinoPython's return_all mode while JoinSurfaces continues to require one result; document inputs are retained if adding any result fails.
- MatchMaterial accepts a material-table index as well as a source object identifier, restoring the index-based RhinoPython operation.
- GetObjectRef returns the picked ObjRef, retaining selected subobject information; GetObject keeps its Guid return and shares the picking implementation.
- MeshArea accepts collections of mesh identifiers or geometry and returns their total area, retaining the documented scalar return design.
- IsSurfaceFlipped provides the correctly spelled surface-orientation getter.
- UnitScale accepts only the destination unit system and uses the current model units as the source, like in RhinoPython.
- UnitAbsoluteTolerance, UnitAngleTolerance, UnitDistanceDisplayPrecision, UnitRelativeTolerance and UnitSystem have model/page selector overloads, restoring page-unit access without changing existing model-unit calls.
- AddDimStyle accepts an optional name and returns the assigned style name; omitting the name generates one automatically, like in RhinoPython.
- LinetypeNames accepts an optional sort flag, defaulting to false, to return names in ordinal order, like in RhinoPython.
- LayerNames accepts an optional sort flag, defaulting to false, to return names in ordinal order, like in RhinoPython.
- DimStyleNames accepts an optional sort flag, defaulting to false, to return names in ordinal order, like in RhinoPython.
- BlockNames accepts an optional sort flag, defaulting to false, to return names in ordinal order, like in RhinoPython.
- Direct geometry overloads for methods that previously required object identifiers, including collection inputs; geometry-producing operations take and return raw geometry, while document-object operations retain their Guid APIs.
- ContextIsGrasshopper, it checks if the call stack of the current thread goes through the Grasshopper assembly
- MeshTextureCoordinates, like in RhinoPython
- XformScale overloads with a Plane, to scale about the Plane's origin along the Plane's axes, like in RhinoPython
- The NuGet package ships an agent skill, rhino.scripting-usage, with the API table, for installation with dotnet-package-skills.
### Changed
- Breaking: Angle parameters consistently use Degrees or Radians suffixes, including rotation angles and angular tolerances; update named arguments accordingly. XML docs explicitly state input and return units and clarify default tolerances, with no change to angle calculations.
- Breaking: ShrinkTrimmedSurface returns a bool, false when there is nothing to shrink, like in RhinoPython; before, it raised, and returned the input or copy Guid on success. The Brep overload returns a Brep option, None when there is nothing to shrink.
- Breaking: MeshBooleanDifference, MeshBooleanIntersection, MeshBooleanSplit and MeshBooleanUnion check all result meshes before adding any; an invalid result raises with the Rhino mesh log in the message, and nothing is added. MeshBooleanUnion used to skip results it could not add silently.
- Documented that ShootRay returns the start point first, that SurfaceAreaMoments and SurfaceVolumeMoments return 14 tuples, that IsPointOnSurface raises for polysurfaces with several faces, and that BooleanIntersection, AddSweep1, AddSweep2 and FilletSurfaces return an empty list when there is no result.
- ShowToolbar, HideToolbar, IsToolbarVisible and IsToolbarDocked are marked obsolete: RhinoCommon lists no toolbar groups in Rhino 8, and in Rhino 9 a toolbar group can be shown but not hidden again.
- Breaking: Removed the misspelled IsSurfaceFliped methods; use IsSurfaceFlipped for both object identifiers and Brep geometry.
- Breaking: AddDimStyle uses one optional dimStyleName parameter and returns the assigned name for both named and automatically named styles; the named form previously returned unit.
- The Python parity review in API-Table/PythonParityReview.md records retained F# API designs and the fixes made; XML docs clarify cylinder inputs, plane/sphere point results, active linetype counts and local bitmap validation.
- Breaking: IsHatch, IsBlockInstance, IsPoint, IsPointCloud, IsText, IsTextDot, IsClippingPlane, IsBrep, IsPolysurface and IsPolysurfaceClosed return false for missing object identifiers, like in RhinoPython.
- IsObjectSolid returns false for geometry that cannot be solid, like in RhinoPython.
- Breaking: GetObjectGrip and GetObjectGrips raise RhinoUserInteractionException on cancellation, and ObjectGripLocations reports a point count mismatch instead of silently doing nothing, unlike RhinoPython.
- Breaking: Parameter names ending in Id or Ids are reserved for Guid inputs; direct geometry parameters use names such as curveGeo, surfaceGeo and geometryObject, and non-Guid coercion inputs use descriptive names.
- The API table lists each Make factory immediately after its matching Add methods.
- Breaking: AddHatch and AddHatches with Curve geometry, and AddPlanarSrf with a Polyline, a Curve or a Curve seq, are renamed to MakeHatch, MakeHatches and MakePlanarSrf; they added the result to the document and returned its Guid, now they return the new geometry without adding it, use e.g. rs.Add(rs.MakePlanarSrf(curve)) to add it; the Add methods with Guid inputs still add to the document.
- Guid overloads share geometry calculations with the direct overloads and handle document insertion, replacement, deletion, attributes and redraws.
- Breaking: Add, CreatePoint, CreateVector and the Coerce and TryCoerce functions for Guids, lines, arcs, circles, ellipses, polylines, views, points, vectors, planes, transforms and colors have one overload per accepted input type instead of a generic parameter that was checked at runtime, so a wrong input type is a compile error now
- Breaking: these functions take coordinates and color values as separate arguments, like Coerce3dPoint(1, 2, 3) or CoerceColor(255, 0, 0), a tuple value like CoerceColor(rgb) does not compile any more
- Breaking: Coerce3dPoint, Coerce3dVector, CreatePoint and CreateVector don't accept options, tuples of decimals, singles or strings, or sequences of ints or strings any more, and a sequence of floats or a string like "1, 2, 3" must have exactly three values
- Breaking: CoerceGuid raises an exception for a string of the empty Guid
- Breaking: CoercePlane only accepts a Plane, a Point3d or three floats, not all inputs of Coerce3dPoint
- Coerce3dVector with a Guid accepts any curve that is linear within tolerance, not only a LineCurve
- CreateXform accepts nested lists and arrays of floats, like CoerceXform
- Hide AutoOpen modules from editor completion lists with EditorBrowsable(EditorBrowsableState.Never).
- DimStyleTextAlignment sets the text orientation and location for radial dimensions too, like in RhinoPython
- ShowGrid, ShowGridAxes and ShowWorldAxes get and set the grid settings of the view's display mode if it overrides the document grid settings, like in RhinoPython
- CopyObject(s), and TransformObject(s), MirrorObject(s), RotateObject(s), ScaleObject(s) and ShearObject(s) with copy=true, put copies of grouped objects into new groups like the Copy command does, instead of adding them to the original groups, like in RhinoPython
- Breaking: IsDimension, IsLeader and the other dimension checks return false for objects that don't exist, instead of raising an exception, like in RhinoPython
- Breaking: IsCone, IsCylinder, IsPlaneSurface and IsPointLight, IsSpotLight and the other light type checks return false for objects of another type or that don't exist, instead of raising an exception, like in RhinoPython
### Fixed
- AddPipe and MakePipe raise a RhinoScriptingException when the counts of parameters and radii differ or are zero, instead of the ArgumentException of RhinoCommon.
- ObjectsByType with the hidden state (4) but without the normal state (1) now returns hidden objects; before, state 4 returned nothing.
- Breaking: Unset document notes and block descriptions return empty strings instead of null.
- Clarified that ChangeSurfaceDegree raises degrees and SdkVersion returns Rhino's signed SDK value.
- Breaking: String ID validation rejects empty names unless explicitly allowed; empty document user-text keys now raise.
- Breaking: DimStyleFont returns the font quartet name, and empty point and mesh intersection results return empty arrays instead of null.
- Breaking: AddCone and AddTorus raise when geometry cannot be created or added, and MeshVertexFaces raises for an invalid vertex index.
- Fixed group counts after deletion, document user-text deletion, closed-curve orientation, text font styles, mesh normal unification, surface knot direction, hatch creation without a current pattern, named-view titles, wallpaper detection, command counts and ExplodeText error handling.
- AddLeader uses Rhino's textless overload when text is omitted or null, instead of creating empty text.
- ViewRadius defaults the setter mode to false, like in RhinoPython.
- AddLinearLight distinguishes an omitted width from an explicit zero width, like in RhinoPython; the two-argument overload supplies the default.
- AddLeader accepts omitted text to create a leader without text, like in RhinoPython.
- CurveFilletPoints defaults its radius to 1.0 when omitted, like in RhinoPython.
- CurveCurveIntersection uses the same overlap tolerance as RhinoPython instead of substituting the document absolute tolerance.
- StatusBarPoint can be called without a value, like in RhinoPython.
- StatusBarMessage can be called without a value, like in RhinoPython.
- StatusBarDistance can be called without a value, like in RhinoPython.
- SendKeystrokes can be called without a value, like in RhinoPython.
- Prompt can be called without a value, like in RhinoPython.
- GetObjects applies the custom geometry filter as well as the allowed-object list when both are supplied.
- GetObject preserves other preselected objects when select is false, like in RhinoPython.
- Optional view names and empty view names use the active view in view operations, CreatePreviewImage and screen/world transforms, instead of raising in CoerceView.
- SplitBrep, PullCurve, JoinCurves and MeshBooleanDifference, MeshBooleanIntersection and MeshBooleanSplit reject empty results and retain their inputs when adding results fails.
- Breaking: MakeHatches raises when no hatches can be created, instead of returning an empty list.
- Material getters and setters validate indices before indexing the material table, which otherwise silently substitutes the current material, unlike RhinoPython.
- MatchMaterial rejects a source without an assigned material before changing destination objects, unlike RhinoPython.
- LineTransform with copy=true preserves the original object's attributes.
- NextObjectGrip and PrevObjectGrip raise a clear exception when there is no neighboring grip, instead of a NullReferenceException.
- GroupObjects validates the object count before creating a group, so invalid input no longer leaves an empty group.
- Breaking: IsGroupEmpty returns true for an empty group, unlike RhinoPython.
- EdgeAnalysisMode accepts mode 0 to show all edges.
- PlugIns combines the requested type flags instead of treating combinations as a request for every plug-in.
- IsPlugIn accepts a plug-in identifier string as well as a name.
- Breaking: ScreenSize returns physical pixels, accounting for the display scale.
- StatusBarProgressMeterShow, Update and Hide process UI messages so the meter repaints during UI-thread loops.
- Breaking: AddLinearLight converts its default width from inches, like in RhinoPython, instead of millimeters.
- PullPoints accepts plain surfaces and single-face extrusions by converting them to Breps, like in RhinoPython.
- PointClosestObject includes extrusion caps when finding the closest point.
- PointsAreCoplanar uses the documented default tolerance of 1e-12.
- UnitSystem sets the model unit system, including unit system 0, and applies optional scaling; the setter previously did nothing.
- ExtractPreviewImage uses the supplied model filename and reports missing previews and unsaved documents clearly.
- RenderMeshSettings preserves the texture-range flag, and render mesh numeric setters accept 0 to disable a setting.
- Breaking: RenderMeshQuality rejects unsupported values instead of silently disabling the meshing style.
- Breaking: CurveDeviation returns the curve parameters and distances in their documented order.
- CurveFilletPoints evaluates the second fillet point on the second curve.
- ConvertCurveToPolyline uses the documented default angle tolerance of 5 degrees.
- Breaking: CurveLineClosestPoint returns the curve point before the line point, as documented.
- AddTweenCurves and MakeTweenCurves distinguish control-point matching from refitting and accept method 1.
- Breaking: FairCurve writes successful fairing results to the document instead of returning false on success.
- InsertCurveKnot returns the result of insertion and document replacement, including symmetrical insertion.
- ChangeCurveDegree accepts degree 2 when increasing a linear curve's degree.
- OffsetCurveOnSurfaceUV extends the offsets to the surface edges, like in RhinoPython, and curve offset methods redraw after adding results.
- ObjectMaterialIndex accepts valid indices and rejects invalid indices; index -1 resets the assignment.
- SelectObject and SelectObjects can unlock a locked layer when forceVisible is true.
- Object transformations, copies, moves, HideObject and LockObject redraw after modifying document objects.
- PointCoordinates writes the supplied new location instead of the old point.
- TextObjectFont no longer eagerly raises an exception while choosing a font fallback.
- TextObjectRichText with multiple objects and a style applies rich text before replacing each document object.
- PointCloudHidePoints and PointCloudPointColors replace the edited point cloud geometry so changes are saved reliably.
- Area supports hatches using the hatch-specific area calculation.
- AddClippingPlane rejects an empty or unmatched view list.
- AddText warns when a requested bold or italic face is unavailable and still creates the text, like in RhinoPython.
- InvertSelectedObjects selects unselected objects and deselects selected objects, like in RhinoPython.
- WindowPick returns the picked identifiers and transforms full 3D corners to screen coordinates before dropping Z.
- LastObject and ObjectsByName avoid enumerating Rhino's object iterator twice.
- LastCreatedObjects selects only existing objects and redraws once, including when a single object was created.
- GetCurveObject checks whether the picked curve was actually preselected when clearing selection.
- NextObject raises RhinoScriptingException for missing or filtered-out objects instead of an iterator exception.
- UnCollapseLayer expands the requested layer, and recursive layer collapse and expansion handle leaf layers.
- LayerLockedSetFalse unlocks the layer when parentsToo is false, and LayerVisibleSetTrue sets visibility when forceVisible is false.
- AddLayer honors visibility and locking when generating a layer name.
- CurrentLayer, DeleteLayer, ExpandLayer and IsLayer accept short names as well as full layer paths.
- ReplaceBlockObjects updates the block definition before deleting inputs and redraws after success.
- IsBlockEmbedded recognizes Static definitions, which Rhino displays as embedded.
- MeshVertices preserves double-precision vertex coordinates.
- MeshOutline uses the active viewport when no view is supplied.
- Breaking: PlaneCurveIntersection returns the documented curve interval and plane UV coordinates, unlike RhinoPython.
- OffsetSurface preserves tolerance 0 for loose offsets.
- ShootRay includes the starting point when the ray hits a surface, like in RhinoPython.
- Breaking: SurfaceVolume rejects open geometry, and SurfaceEvaluate handles evaluation with no derivatives.
- Breaking: AddLoftSrf and MakeLoftSrf reject unsupported loft type 4 instead of silently creating a normal loft.
- TiltView converts the absolute angle from degrees to radians before rotating the viewport.
- IsDetail looks for the detail name within the requested layout instead of looking it up as a model view.
- DetailLock reports a missing detail identifier clearly instead of raising NullReferenceException.
- ViewProjection uses a 50 mm lens when changing to perspective and preserves the lens when the projection is already correct.
- RotateCamera rejects an unsupported direction before rotating the camera.
- CullDuplicateNumbers retains the first number and every subsequent number outside tolerance, including two-item inputs.
- Polar uses WorldXY when its plane is omitted.
- FxrangePython and FrangePython retain the last value below the stop for nonintegral step counts, while continuing to exclude the stop.
- CreatePlane defaults each omitted axis independently, preserving a supplied axis.
- GetColor returns the color written back by the dialog's reflection arguments.
- GetDistance reads the first point before disposing the getter and returns the supplied distance when Enter is pressed.
- GetPolyline defaults to two required points and honors an explicit maximum point count.
- GetLayer preselects layers by full path, and GetEdgeCurves duplicates line, arc and polycurve edges without an invalid NurbsCurve cast.
- BrowseForFolder displays both the title and message when both are supplied.
- IsDocumentData and IsDocumentUserText use their respective document string counts.
- Breaking: SetUserText rejects empty values before changing any object, because Rhino treats empty strings as deletion; the documentation now requires a nonempty value.
- CullDuplicatePoints uses the documented default ZeroTolerance, and ColorHLSToRGB passes saturation and luminance in the correct order.
- CoerceColor rejects empty and whitespace-only color names, and TryCoerceArc with a curve rejects full circles as documented.
- Add with a layer index and collapseParents collapses the parent layers instead of the target layer and resolves index -1 to the current layer.
- AddLeader fits a plane through all points instead of relying on the first and last segments; two-point leaders use WorldXY with a vertical-plane fallback for vertical segments, and adding a leader redraws.
- AddAlignedDimension uses the active construction plane when the input points are collinear, like in RhinoPython.
- DimStyleExtension and DimStyleLeaderArrowSize accept 0, and dimension style setters report invalid negative values.
- AddHatchPatterns honors replace in Rhino 8; Rhino 7 reports that replacing an existing pattern is unsupported instead of ignoring it, unlike RhinoPython.
- Breaking: LinetypeCount excludes deleted linetypes, unlike RhinoPython.
- Toolbar collection open, close and save operations and toolbar show and hide operations run on the UI thread.
- Breaking: MirrorObject and MirrorObjects mirror about the vertical plane through the start and end point, like in RhinoPython, instead of about the plane perpendicular to the line between them; they raise an exception if the two points are vertically above each other
- Breaking: ExtractSurface removes the extracted faces from the Polysurface only if copy is false, like in RhinoPython, it was the other way round; if all faces are extracted the Polysurface is deleted
- TextObjectStyle sets the font style of a text object, it changed nothing before
- Breaking: CurveCurveIntersection without a second curve does a self-intersection test, like in RhinoPython, instead of reporting the whole curve as an overlap with itself
- Breaking: LineTransform with copy=false transforms the line object in the document, before it returned the Guid without changing the object
- Breaking: TrimBrep replaces the object with the trimmed piece also if only one piece is retained, like in RhinoPython, instead of keeping the untrimmed object and adding the piece as a new object without its attributes
- Breaking: CurveFrame uses the segmentIndex of a PolyCurve, like in RhinoPython, it was ignored before
- ShrinkTrimmedSurface checks ShrinkFaces correctly, raising on failure instead of success.
- PointClosestObject uses the initialized result in the shared object implementation, avoiding a null-reference exception when comparing distances.
- Breaking: DimStyleTextAlignment returns the documented values 1, 2 or 3, instead of the index of the text location
- IsLinetype returned true for any name in Rhino 8, and IsLinetypeReference used the Continuous linetype for unknown names
- ObjectPrintColorSource accepts 2 (print color by display)
- LayerLinetype and GetLinetype used the Continuous linetype for unknown names in Rhino 8
- ObjectLinetype can set the Continuous linetype
- AddMesh sets the given vertex colors, they were all empty before