RhinoCommon is meant to be version 2 of the Rhino.NET SDK, and it improves on the design and implementation of the current SDK. Some of the goals of RhinoCommon are: Faster for some data types: All data types in Rhino.NET were wrappers around C++ pointers created on the unmanaged heap. This was a mistake when working with primitive data types (like 3D points and vectors). Primitive Rhino data types in RhinoCommon are written as value classes and implemented entirely in .NET. Allows data type to be placed on the stack when only temporarily needed in a function There is no requirement to call through to C++ to simply get the value of something like X,Y,Z in a point No potential fragmentation of the C++ unmanaged heap because the type is entirely inside of .NET and under the control of the garbage collector Operator overloading works much cleaner since value types can not have a value of null A .NET style SDK: Multiple appropriately named namespaces in an attempt to better organize the SDK Properties are used when they make sense All parameter arguments are clearly named to describe their purpose Standard .NET style events are used instead of forced subclassing when it makes sense Descriptive enumerations are used instead of vague int for function parameters and returns .NET attributes are used where appropriate This is not a one-to-one conversion from C++ SDK to .NET Removal of separate const/non-const versions of classes Improved documentation: We are making an effort to provide descriptive XML comments for all classes/functions/properties The current SDK documentation can be found here Platform neutral: RhinoCommon is built to run on Windows 32 bit, Windows 64 bit, and Mac OSX (currently only 32 bit)

RhinoCommon is meant to be version 2 of the Rhino.NET SDK, and it improves on the design and implementation of the current SDK. Some of the goals of RhinoCommon are: Faster for some data types: All data types in Rhino.NET were wrappers around C++ pointers created on the unmanaged heap. This was a mistake when working with primitive data types (like 3D points and vectors). Primitive Rhino data types in RhinoCommon are written as value classes and implemented entirely in .NET. Allows data type to be placed on the stack when only temporarily needed in a function There is no requirement to call through to C++ to simply get the value of something like X,Y,Z in a point No potential fragmentation of the C++ unmanaged heap because the type is entirely inside of .NET and under the control of the garbage collector Operator overloading works much cleaner since value types can not have a value of null A .NET style SDK: Multiple appropriately named namespaces in an attempt to better organize the SDK Properties are used when they make sense All parameter arguments are clearly named to describe their purpose Standard .NET style events are used instead of forced subclassing when it makes sense Descriptive enumerations are used instead of vague int for function parameters and returns .NET attributes are used where appropriate This is not a one-to-one conversion from C++ SDK to .NET Removal of separate const/non-const versions of classes Improved documentation: We are making an effort to provide descriptive XML comments for all classes/functions/properties The current SDK documentation can be found here Platform neutral: RhinoCommon is built to run on Windows 32 bit, Windows 64 bit, and Mac OSX (currently only 32 bit)

RhinoCommon is meant to be version 2 of the Rhino.NET SDK, and it improves on the design and implementation of the current SDK. Some of the goals of RhinoCommon are: Faster for some data types: All data types in Rhino.NET were wrappers around C++ pointers created on the unmanaged heap. This was a mistake when working with primitive data types (like 3D points and vectors). Primitive Rhino data types in RhinoCommon are written as value classes and implemented entirely in .NET. Allows data type to be placed on the stack when only temporarily needed in a function There is no requirement to call through to C++ to simply get the value of something like X,Y,Z in a point No potential fragmentation of the C++ unmanaged heap because the type is entirely inside of .NET and under the control of the garbage collector Operator overloading works much cleaner since value types can not have a value of null A .NET style SDK: Multiple appropriately named namespaces in an attempt to better organize the SDK Properties are used when they make sense All parameter arguments are clearly named to describe their purpose Standard .NET style events are used instead of forced subclassing when it makes sense Descriptive enumerations are used instead of vague int for function parameters and returns .NET attributes are used where appropriate This is not a one-to-one conversion from C++ SDK to .NET Removal of separate const/non-const versions of classes Improved documentation: We are making an effort to provide descriptive XML comments for all classes/functions/properties The current SDK documentation can be found here Platform neutral: RhinoCommon is built to run on Windows 32 bit, Windows 64 bit, and Mac OSX (currently only 32 bit)

RhinoCommon is meant to be version 2 of the Rhino.NET SDK, and it improves on the design and implementation of the current SDK. Some of the goals of RhinoCommon are: Faster for some data types: All data types in Rhino.NET were wrappers around C++ pointers created on the unmanaged heap. This was a mistake when working with primitive data types (like 3D points and vectors). Primitive Rhino data types in RhinoCommon are written as value classes and implemented entirely in .NET. Allows data type to be placed on the stack when only temporarily needed in a function There is no requirement to call through to C++ to simply get the value of something like X,Y,Z in a point No potential fragmentation of the C++ unmanaged heap because the type is entirely inside of .NET and under the control of the garbage collector Operator overloading works much cleaner since value types can not have a value of null A .NET style SDK: Multiple appropriately named namespaces in an attempt to better organize the SDK Properties are used when they make sense All parameter arguments are clearly named to describe their purpose Standard .NET style events are used instead of forced subclassing when it makes sense Descriptive enumerations are used instead of vague int for function parameters and returns .NET attributes are used where appropriate This is not a one-to-one conversion from C++ SDK to .NET Removal of separate const/non-const versions of classes Improved documentation: We are making an effort to provide descriptive XML comments for all classes/functions/properties The current SDK documentation can be found here Platform neutral: RhinoCommon is built to run on Windows 32 bit, Windows 64 bit, and Mac OSX (currently only 32 bit)

RhinoCommon is meant to be version 2 of the Rhino.NET SDK, and it improves on the design and implementation of the current SDK. Some of the goals of RhinoCommon are: Faster for some data types: All data types in Rhino.NET were wrappers around C++ pointers created on the unmanaged heap. This was a mistake when working with primitive data types (like 3D points and vectors). Primitive Rhino data types in RhinoCommon are written as value classes and implemented entirely in .NET. Allows data type to be placed on the stack when only temporarily needed in a function There is no requirement to call through to C++ to simply get the value of something like X,Y,Z in a point No potential fragmentation of the C++ unmanaged heap because the type is entirely inside of .NET and under the control of the garbage collector Operator overloading works much cleaner since value types can not have a value of null A .NET style SDK: Multiple appropriately named namespaces in an attempt to better organize the SDK Properties are used when they make sense All parameter arguments are clearly named to describe their purpose Standard .NET style events are used instead of forced subclassing when it makes sense Descriptive enumerations are used instead of vague int for function parameters and returns .NET attributes are used where appropriate This is not a one-to-one conversion from C++ SDK to .NET Removal of separate const/non-const versions of classes Improved documentation: We are making an effort to provide descriptive XML comments for all classes/functions/properties The current SDK documentation can be found here Platform neutral: RhinoCommon is built to run on Windows 32 bit, Windows 64 bit, and Mac OSX (currently only 32 bit)

RhinoCommon is meant to be version 2 of the Rhino.NET SDK, and it improves on the design and implementation of the current SDK. Some of the goals of RhinoCommon are: Faster for some data types: All data types in Rhino.NET were wrappers around C++ pointers created on the unmanaged heap. This was a mistake when working with primitive data types (like 3D points and vectors). Primitive Rhino data types in RhinoCommon are written as value classes and implemented entirely in .NET. Allows data type to be placed on the stack when only temporarily needed in a function There is no requirement to call through to C++ to simply get the value of something like X,Y,Z in a point No potential fragmentation of the C++ unmanaged heap because the type is entirely inside of .NET and under the control of the garbage collector Operator overloading works much cleaner since value types can not have a value of null A .NET style SDK: Multiple appropriately named namespaces in an attempt to better organize the SDK Properties are used when they make sense All parameter arguments are clearly named to describe their purpose Standard .NET style events are used instead of forced subclassing when it makes sense Descriptive enumerations are used instead of vague int for function parameters and returns .NET attributes are used where appropriate This is not a one-to-one conversion from C++ SDK to .NET Removal of separate const/non-const versions of classes Improved documentation: We are making an effort to provide descriptive XML comments for all classes/functions/properties The current SDK documentation can be found here Platform neutral: RhinoCommon is built to run on Windows 32 bit, Windows 64 bit, and Mac OSX (currently only 32 bit)

RhinoCommon is meant to be version 2 of the Rhino.NET SDK, and it improves on the design and implementation of the current SDK. Some of the goals of RhinoCommon are: Faster for some data types: All data types in Rhino.NET were wrappers around C++ pointers created on the unmanaged heap. This was a mistake when working with primitive data types (like 3D points and vectors). Primitive Rhino data types in RhinoCommon are written as value classes and implemented entirely in .NET. Allows data type to be placed on the stack when only temporarily needed in a function There is no requirement to call through to C++ to simply get the value of something like X,Y,Z in a point No potential fragmentation of the C++ unmanaged heap because the type is entirely inside of .NET and under the control of the garbage collector Operator overloading works much cleaner since value types can not have a value of null A .NET style SDK: Multiple appropriately named namespaces in an attempt to better organize the SDK Properties are used when they make sense All parameter arguments are clearly named to describe their purpose Standard .NET style events are used instead of forced subclassing when it makes sense Descriptive enumerations are used instead of vague int for function parameters and returns .NET attributes are used where appropriate This is not a one-to-one conversion from C++ SDK to .NET Removal of separate const/non-const versions of classes Improved documentation: We are making an effort to provide descriptive XML comments for all classes/functions/properties The current SDK documentation can be found here Platform neutral: RhinoCommon is built to run on Windows 32 bit, Windows 64 bit, and Mac OSX (currently only 32 bit)

RhinoCommon is meant to be version 2 of the Rhino.NET SDK, and it improves on the design and implementation of the current SDK. Some of the goals of RhinoCommon are: Faster for some data types: All data types in Rhino.NET were wrappers around C++ pointers created on the unmanaged heap. This was a mistake when working with primitive data types (like 3D points and vectors). Primitive Rhino data types in RhinoCommon are written as value classes and implemented entirely in .NET. Allows data type to be placed on the stack when only temporarily needed in a function There is no requirement to call through to C++ to simply get the value of something like X,Y,Z in a point No potential fragmentation of the C++ unmanaged heap because the type is entirely inside of .NET and under the control of the garbage collector Operator overloading works much cleaner since value types can not have a value of null A .NET style SDK: Multiple appropriately named namespaces in an attempt to better organize the SDK Properties are used when they make sense All parameter arguments are clearly named to describe their purpose Standard .NET style events are used instead of forced subclassing when it makes sense Descriptive enumerations are used instead of vague int for function parameters and returns .NET attributes are used where appropriate This is not a one-to-one conversion from C++ SDK to .NET Removal of separate const/non-const versions of classes Improved documentation: We are making an effort to provide descriptive XML comments for all classes/functions/properties The current SDK documentation can be found here Platform neutral: RhinoCommon is built to run on Windows 32 bit, Windows 64 bit, and Mac OSX (currently only 32 bit)

RhinoCommon is meant to be version 2 of the Rhino.NET SDK, and it improves on the design and implementation of the current SDK. Some of the goals of RhinoCommon are: Faster for some data types: All data types in Rhino.NET were wrappers around C++ pointers created on the unmanaged heap. This was a mistake when working with primitive data types (like 3D points and vectors). Primitive Rhino data types in RhinoCommon are written as value classes and implemented entirely in .NET. Allows data type to be placed on the stack when only temporarily needed in a function There is no requirement to call through to C++ to simply get the value of something like X,Y,Z in a point No potential fragmentation of the C++ unmanaged heap because the type is entirely inside of .NET and under the control of the garbage collector Operator overloading works much cleaner since value types can not have a value of null A .NET style SDK: Multiple appropriately named namespaces in an attempt to better organize the SDK Properties are used when they make sense All parameter arguments are clearly named to describe their purpose Standard .NET style events are used instead of forced subclassing when it makes sense Descriptive enumerations are used instead of vague int for function parameters and returns .NET attributes are used where appropriate This is not a one-to-one conversion from C++ SDK to .NET Removal of separate const/non-const versions of classes Improved documentation: We are making an effort to provide descriptive XML comments for all classes/functions/properties The current SDK documentation can be found here Platform neutral: RhinoCommon is built to run on Windows 32 bit, Windows 64 bit, and Mac OSX (currently only 32 bit)

RhinoCommon is meant to be version 2 of the Rhino.NET SDK, and it improves on the design and implementation of the current SDK. Some of the goals of RhinoCommon are: Faster for some data types: All data types in Rhino.NET were wrappers around C++ pointers created on the unmanaged heap. This was a mistake when working with primitive data types (like 3D points and vectors). Primitive Rhino data types in RhinoCommon are written as value classes and implemented entirely in .NET. Allows data type to be placed on the stack when only temporarily needed in a function There is no requirement to call through to C++ to simply get the value of something like X,Y,Z in a point No potential fragmentation of the C++ unmanaged heap because the type is entirely inside of .NET and under the control of the garbage collector Operator overloading works much cleaner since value types can not have a value of null A .NET style SDK: Multiple appropriately named namespaces in an attempt to better organize the SDK Properties are used when they make sense All parameter arguments are clearly named to describe their purpose Standard .NET style events are used instead of forced subclassing when it makes sense Descriptive enumerations are used instead of vague int for function parameters and returns .NET attributes are used where appropriate This is not a one-to-one conversion from C++ SDK to .NET Removal of separate const/non-const versions of classes Improved documentation: We are making an effort to provide descriptive XML comments for all classes/functions/properties The current SDK documentation can be found here Platform neutral: RhinoCommon is built to run on Windows 32 bit, Windows 64 bit, and Mac OSX (currently only 32 bit)

RhinoCommon is meant to be version 2 of the Rhino.NET SDK, and it improves on the design and implementation of the current SDK. Some of the goals of RhinoCommon are: Faster for some data types: All data types in Rhino.NET were wrappers around C++ pointers created on the unmanaged heap. This was a mistake when working with primitive data types (like 3D points and vectors). Primitive Rhino data types in RhinoCommon are written as value classes and implemented entirely in .NET. Allows data type to be placed on the stack when only temporarily needed in a function There is no requirement to call through to C++ to simply get the value of something like X,Y,Z in a point No potential fragmentation of the C++ unmanaged heap because the type is entirely inside of .NET and under the control of the garbage collector Operator overloading works much cleaner since value types can not have a value of null A .NET style SDK: Multiple appropriately named namespaces in an attempt to better organize the SDK Properties are used when they make sense All parameter arguments are clearly named to describe their purpose Standard .NET style events are used instead of forced subclassing when it makes sense Descriptive enumerations are used instead of vague int for function parameters and returns .NET attributes are used where appropriate This is not a one-to-one conversion from C++ SDK to .NET Removal of separate const/non-const versions of classes Improved documentation: We are making an effort to provide descriptive XML comments for all classes/functions/properties The current SDK documentation can be found here Platform neutral: RhinoCommon is built to run on Windows 32 bit, Windows 64 bit, and Mac OSX (currently only 32 bit)

RhinoCommon is meant to be version 2 of the Rhino.NET SDK, and it improves on the design and implementation of the current SDK. Some of the goals of RhinoCommon are: Faster for some data types: All data types in Rhino.NET were wrappers around C++ pointers created on the unmanaged heap. This was a mistake when working with primitive data types (like 3D points and vectors). Primitive Rhino data types in RhinoCommon are written as value classes and implemented entirely in .NET. Allows data type to be placed on the stack when only temporarily needed in a function There is no requirement to call through to C++ to simply get the value of something like X,Y,Z in a point No potential fragmentation of the C++ unmanaged heap because the type is entirely inside of .NET and under the control of the garbage collector Operator overloading works much cleaner since value types can not have a value of null A .NET style SDK: Multiple appropriately named namespaces in an attempt to better organize the SDK Properties are used when they make sense All parameter arguments are clearly named to describe their purpose Standard .NET style events are used instead of forced subclassing when it makes sense Descriptive enumerations are used instead of vague int for function parameters and returns .NET attributes are used where appropriate This is not a one-to-one conversion from C++ SDK to .NET Removal of separate const/non-const versions of classes Improved documentation: We are making an effort to provide descriptive XML comments for all classes/functions/properties The current SDK documentation can be found here Platform neutral: RhinoCommon is built to run on Windows 32 bit, Windows 64 bit, and Mac OSX (currently only 32 bit)

RhinoCommon is meant to be version 2 of the Rhino.NET SDK, and it improves on the design and implementation of the current SDK. Some of the goals of RhinoCommon are: Faster for some data types: All data types in Rhino.NET were wrappers around C++ pointers created on the unmanaged heap. This was a mistake when working with primitive data types (like 3D points and vectors). Primitive Rhino data types in RhinoCommon are written as value classes and implemented entirely in .NET. Allows data type to be placed on the stack when only temporarily needed in a function There is no requirement to call through to C++ to simply get the value of something like X,Y,Z in a point No potential fragmentation of the C++ unmanaged heap because the type is entirely inside of .NET and under the control of the garbage collector Operator overloading works much cleaner since value types can not have a value of null A .NET style SDK: Multiple appropriately named namespaces in an attempt to better organize the SDK Properties are used when they make sense All parameter arguments are clearly named to describe their purpose Standard .NET style events are used instead of forced subclassing when it makes sense Descriptive enumerations are used instead of vague int for function parameters and returns .NET attributes are used where appropriate This is not a one-to-one conversion from C++ SDK to .NET Removal of separate const/non-const versions of classes Improved documentation: We are making an effort to provide descriptive XML comments for all classes/functions/properties The current SDK documentation can be found here Platform neutral: RhinoCommon is built to run on Windows 32 bit, Windows 64 bit, and Mac OSX (currently only 32 bit)

RhinoCommon is meant to be version 2 of the Rhino.NET SDK, and it improves on the design and implementation of the current SDK. Some of the goals of RhinoCommon are: Faster for some data types: All data types in Rhino.NET were wrappers around C++ pointers created on the unmanaged heap. This was a mistake when working with primitive data types (like 3D points and vectors). Primitive Rhino data types in RhinoCommon are written as value classes and implemented entirely in .NET. Allows data type to be placed on the stack when only temporarily needed in a function There is no requirement to call through to C++ to simply get the value of something like X,Y,Z in a point No potential fragmentation of the C++ unmanaged heap because the type is entirely inside of .NET and under the control of the garbage collector Operator overloading works much cleaner since value types can not have a value of null A .NET style SDK: Multiple appropriately named namespaces in an attempt to better organize the SDK Properties are used when they make sense All parameter arguments are clearly named to describe their purpose Standard .NET style events are used instead of forced subclassing when it makes sense Descriptive enumerations are used instead of vague int for function parameters and returns .NET attributes are used where appropriate This is not a one-to-one conversion from C++ SDK to .NET Removal of separate const/non-const versions of classes Improved documentation: We are making an effort to provide descriptive XML comments for all classes/functions/properties The current SDK documentation can be found here Platform neutral: RhinoCommon is built to run on Windows 32 bit, Windows 64 bit, and Mac OSX (currently only 32 bit)

RhinoCommon is meant to be version 2 of the Rhino.NET SDK, and it improves on the design and implementation of the current SDK. Some of the goals of RhinoCommon are: Faster for some data types: All data types in Rhino.NET were wrappers around C++ pointers created on the unmanaged heap. This was a mistake when working with primitive data types (like 3D points and vectors). Primitive Rhino data types in RhinoCommon are written as value classes and implemented entirely in .NET. Allows data type to be placed on the stack when only temporarily needed in a function There is no requirement to call through to C++ to simply get the value of something like X,Y,Z in a point No potential fragmentation of the C++ unmanaged heap because the type is entirely inside of .NET and under the control of the garbage collector Operator overloading works much cleaner since value types can not have a value of null A .NET style SDK: Multiple appropriately named namespaces in an attempt to better organize the SDK Properties are used when they make sense All parameter arguments are clearly named to describe their purpose Standard .NET style events are used instead of forced subclassing when it makes sense Descriptive enumerations are used instead of vague int for function parameters and returns .NET attributes are used where appropriate This is not a one-to-one conversion from C++ SDK to .NET Removal of separate const/non-const versions of classes Improved documentation: We are making an effort to provide descriptive XML comments for all classes/functions/properties The current SDK documentation can be found here Platform neutral: RhinoCommon is built to run on Windows 32 bit, Windows 64 bit, and Mac OSX (currently only 32 bit)

RhinoCommon is meant to be version 2 of the Rhino.NET SDK, and it improves on the design and implementation of the current SDK. Some of the goals of RhinoCommon are: Faster for some data types: All data types in Rhino.NET were wrappers around C++ pointers created on the unmanaged heap. This was a mistake when working with primitive data types (like 3D points and vectors). Primitive Rhino data types in RhinoCommon are written as value classes and implemented entirely in .NET. Allows data type to be placed on the stack when only temporarily needed in a function There is no requirement to call through to C++ to simply get the value of something like X,Y,Z in a point No potential fragmentation of the C++ unmanaged heap because the type is entirely inside of .NET and under the control of the garbage collector Operator overloading works much cleaner since value types can not have a value of null A .NET style SDK: Multiple appropriately named namespaces in an attempt to better organize the SDK Properties are used when they make sense All parameter arguments are clearly named to describe their purpose Standard .NET style events are used instead of forced subclassing when it makes sense Descriptive enumerations are used instead of vague int for function parameters and returns .NET attributes are used where appropriate This is not a one-to-one conversion from C++ SDK to .NET Removal of separate const/non-const versions of classes Improved documentation: We are making an effort to provide descriptive XML comments for all classes/functions/properties The current SDK documentation can be found here Platform neutral: RhinoCommon is built to run on Windows 32 bit, Windows 64 bit, and Mac OSX (currently only 32 bit)

RhinoCommon is meant to be version 2 of the Rhino.NET SDK, and it improves on the design and implementation of the current SDK. Some of the goals of RhinoCommon are: Faster for some data types: All data types in Rhino.NET were wrappers around C++ pointers created on the unmanaged heap. This was a mistake when working with primitive data types (like 3D points and vectors). Primitive Rhino data types in RhinoCommon are written as value classes and implemented entirely in .NET. Allows data type to be placed on the stack when only temporarily needed in a function There is no requirement to call through to C++ to simply get the value of something like X,Y,Z in a point No potential fragmentation of the C++ unmanaged heap because the type is entirely inside of .NET and under the control of the garbage collector Operator overloading works much cleaner since value types can not have a value of null A .NET style SDK: Multiple appropriately named namespaces in an attempt to better organize the SDK Properties are used when they make sense All parameter arguments are clearly named to describe their purpose Standard .NET style events are used instead of forced subclassing when it makes sense Descriptive enumerations are used instead of vague int for function parameters and returns .NET attributes are used where appropriate This is not a one-to-one conversion from C++ SDK to .NET Removal of separate const/non-const versions of classes Improved documentation: We are making an effort to provide descriptive XML comments for all classes/functions/properties The current SDK documentation can be found here Platform neutral: RhinoCommon is built to run on Windows 32 bit, Windows 64 bit, and Mac OSX (currently only 32 bit)

RhinoCommon is meant to be version 2 of the Rhino.NET SDK, and it improves on the design and implementation of the current SDK. Some of the goals of RhinoCommon are: Faster for some data types: All data types in Rhino.NET were wrappers around C++ pointers created on the unmanaged heap. This was a mistake when working with primitive data types (like 3D points and vectors). Primitive Rhino data types in RhinoCommon are written as value classes and implemented entirely in .NET. Allows data type to be placed on the stack when only temporarily needed in a function There is no requirement to call through to C++ to simply get the value of something like X,Y,Z in a point No potential fragmentation of the C++ unmanaged heap because the type is entirely inside of .NET and under the control of the garbage collector Operator overloading works much cleaner since value types can not have a value of null A .NET style SDK: Multiple appropriately named namespaces in an attempt to better organize the SDK Properties are used when they make sense All parameter arguments are clearly named to describe their purpose Standard .NET style events are used instead of forced subclassing when it makes sense Descriptive enumerations are used instead of vague int for function parameters and returns .NET attributes are used where appropriate This is not a one-to-one conversion from C++ SDK to .NET Removal of separate const/non-const versions of classes Improved documentation: We are making an effort to provide descriptive XML comments for all classes/functions/properties The current SDK documentation can be found here Platform neutral: RhinoCommon is built to run on Windows 32 bit, Windows 64 bit, and Mac OSX (currently only 32 bit)

RhinoCommon is meant to be version 2 of the Rhino.NET SDK, and it improves on the design and implementation of the current SDK. Some of the goals of RhinoCommon are: Faster for some data types: All data types in Rhino.NET were wrappers around C++ pointers created on the unmanaged heap. This was a mistake when working with primitive data types (like 3D points and vectors). Primitive Rhino data types in RhinoCommon are written as value classes and implemented entirely in .NET. Allows data type to be placed on the stack when only temporarily needed in a function There is no requirement to call through to C++ to simply get the value of something like X,Y,Z in a point No potential fragmentation of the C++ unmanaged heap because the type is entirely inside of .NET and under the control of the garbage collector Operator overloading works much cleaner since value types can not have a value of null A .NET style SDK: Multiple appropriately named namespaces in an attempt to better organize the SDK Properties are used when they make sense All parameter arguments are clearly named to describe their purpose Standard .NET style events are used instead of forced subclassing when it makes sense Descriptive enumerations are used instead of vague int for function parameters and returns .NET attributes are used where appropriate This is not a one-to-one conversion from C++ SDK to .NET Removal of separate const/non-const versions of classes Improved documentation: We are making an effort to provide descriptive XML comments for all classes/functions/properties The current SDK documentation can be found here Platform neutral: RhinoCommon is built to run on Windows 32 bit, Windows 64 bit, and Mac OSX (currently only 32 bit)

RhinoCommon is meant to be version 2 of the Rhino.NET SDK, and it improves on the design and implementation of the current SDK. Some of the goals of RhinoCommon are: Faster for some data types: All data types in Rhino.NET were wrappers around C++ pointers created on the unmanaged heap. This was a mistake when working with primitive data types (like 3D points and vectors). Primitive Rhino data types in RhinoCommon are written as value classes and implemented entirely in .NET. Allows data type to be placed on the stack when only temporarily needed in a function There is no requirement to call through to C++ to simply get the value of something like X,Y,Z in a point No potential fragmentation of the C++ unmanaged heap because the type is entirely inside of .NET and under the control of the garbage collector Operator overloading works much cleaner since value types can not have a value of null A .NET style SDK: Multiple appropriately named namespaces in an attempt to better organize the SDK Properties are used when they make sense All parameter arguments are clearly named to describe their purpose Standard .NET style events are used instead of forced subclassing when it makes sense Descriptive enumerations are used instead of vague int for function parameters and returns .NET attributes are used where appropriate This is not a one-to-one conversion from C++ SDK to .NET Removal of separate const/non-const versions of classes Improved documentation: We are making an effort to provide descriptive XML comments for all classes/functions/properties The current SDK documentation can be found here Platform neutral: RhinoCommon is built to run on Windows 32 bit, Windows 64 bit, and Mac OSX (currently only 32 bit)

RhinoCommon is meant to be version 2 of the Rhino.NET SDK, and it improves on the design and implementation of the current SDK. Some of the goals of RhinoCommon are: Faster for some data types: All data types in Rhino.NET were wrappers around C++ pointers created on the unmanaged heap. This was a mistake when working with primitive data types (like 3D points and vectors). Primitive Rhino data types in RhinoCommon are written as value classes and implemented entirely in .NET. Allows data type to be placed on the stack when only temporarily needed in a function There is no requirement to call through to C++ to simply get the value of something like X,Y,Z in a point No potential fragmentation of the C++ unmanaged heap because the type is entirely inside of .NET and under the control of the garbage collector Operator overloading works much cleaner since value types can not have a value of null A .NET style SDK: Multiple appropriately named namespaces in an attempt to better organize the SDK Properties are used when they make sense All parameter arguments are clearly named to describe their purpose Standard .NET style events are used instead of forced subclassing when it makes sense Descriptive enumerations are used instead of vague int for function parameters and returns .NET attributes are used where appropriate This is not a one-to-one conversion from C++ SDK to .NET Removal of separate const/non-const versions of classes Improved documentation: We are making an effort to provide descriptive XML comments for all classes/functions/properties The current SDK documentation can be found here Platform neutral: RhinoCommon is built to run on Windows 32 bit, Windows 64 bit, and Mac OSX (currently only 32 bit)

RhinoCommon is meant to be version 2 of the Rhino.NET SDK, and it improves on the design and implementation of the current SDK. Some of the goals of RhinoCommon are: Faster for some data types: All data types in Rhino.NET were wrappers around C++ pointers created on the unmanaged heap. This was a mistake when working with primitive data types (like 3D points and vectors). Primitive Rhino data types in RhinoCommon are written as value classes and implemented entirely in .NET. Allows data type to be placed on the stack when only temporarily needed in a function There is no requirement to call through to C++ to simply get the value of something like X,Y,Z in a point No potential fragmentation of the C++ unmanaged heap because the type is entirely inside of .NET and under the control of the garbage collector Operator overloading works much cleaner since value types can not have a value of null A .NET style SDK: Multiple appropriately named namespaces in an attempt to better organize the SDK Properties are used when they make sense All parameter arguments are clearly named to describe their purpose Standard .NET style events are used instead of forced subclassing when it makes sense Descriptive enumerations are used instead of vague int for function parameters and returns .NET attributes are used where appropriate This is not a one-to-one conversion from C++ SDK to .NET Removal of separate const/non-const versions of classes Improved documentation: We are making an effort to provide descriptive XML comments for all classes/functions/properties The current SDK documentation can be found here Platform neutral: RhinoCommon is built to run on Windows 32 bit, Windows 64 bit, and Mac OSX (currently only 32 bit)

RhinoCommon is meant to be version 2 of the Rhino.NET SDK, and it improves on the design and implementation of the current SDK. Some of the goals of RhinoCommon are: Faster for some data types: All data types in Rhino.NET were wrappers around C++ pointers created on the unmanaged heap. This was a mistake when working with primitive data types (like 3D points and vectors). Primitive Rhino data types in RhinoCommon are written as value classes and implemented entirely in .NET. Allows data type to be placed on the stack when only temporarily needed in a function There is no requirement to call through to C++ to simply get the value of something like X,Y,Z in a point No potential fragmentation of the C++ unmanaged heap because the type is entirely inside of .NET and under the control of the garbage collector Operator overloading works much cleaner since value types can not have a value of null A .NET style SDK: Multiple appropriately named namespaces in an attempt to better organize the SDK Properties are used when they make sense All parameter arguments are clearly named to describe their purpose Standard .NET style events are used instead of forced subclassing when it makes sense Descriptive enumerations are used instead of vague int for function parameters and returns .NET attributes are used where appropriate This is not a one-to-one conversion from C++ SDK to .NET Removal of separate const/non-const versions of classes Improved documentation: We are making an effort to provide descriptive XML comments for all classes/functions/properties The current SDK documentation can be found here Platform neutral: RhinoCommon is built to run on Windows 32 bit, Windows 64 bit, and Mac OSX (currently only 32 bit)