C# Wrapper

On this page

Open CASCADE geometry in C# and .NET

The OCCT3D C# Wrapper exposes Open CASCADE Technology classes through generated managed assemblies. Geometry, visualization and data exchange operations execute in the native OCCT libraries while the application calls the wrapped API from .NET.

This lets a .NET application use the CAD kernel without implementing an interop layer for every required class. The commercial source delivery includes generation tools, build scripts and instructions for extending coverage to additional OCCT classes or a project-specific configuration.

NuGet packaging with native runtime assets

The OCCT 8.0.0 wrapper release, published in July 2026, describes NuGet packaging that includes platform-specific native assets:

Platform	Runtime identifiers in the release
Windows	win-x64, win-x86, win-arm64
Linux	linux-x64
macOS	osx-x64, osx-arm64

That release lists .NET Framework 4.0 to 4.8 on Windows and .NET 6.0 to 10.0 for SDK-style builds. Match the selected managed target, native architecture and OCCT build when preparing the application package. Managed assemblies still depend on compatible native libraries; packaging brings these pieces together.

A C# CAD import workflow

A typical import integration opens an XDE document, configures the required reader and loads the model. The application then works with geometry, names, colors and assembly structure before presenting or exporting the result.

The reader determines the available file formats. Native STEP support and a commercial Parasolid reader are different dependencies; wrapping a class does not supply an additional translator license. Compare the data exchange interfaces for the intended input and output.

Generated classes, developer tooling and extension points

The generation process produces C# source files for the wrapped C++ classes and builds them into a managed assembly. The class organization preserves the underlying OCCT API relationships and supports typed use from a C# IDE, including code completion and compile-time checks for exposed signatures.

The interop layer handles calls and data marshaling between managed and native code. Wrapped object lifetime and callbacks are important when a native operation interacts with application-owned .NET objects; use the delivery’s documented ownership and callback conventions for these integrations.

The full source package includes the generation scripts and instructions for adapting the wrapping mechanism. This lets a team extend class coverage and tailor its build for an application or plugin, while keeping the managed interfaces and native libraries aligned.

Reader selection and document configuration

A CAD import application can select a provider through the common data-exchange wrapper or use a format-specific reader such as the STEP XDE reader. The workflow is to choose the provider, configure its reader parameters, create an XCAF document and read into that document. Color and other attribute modes belong in this configuration, followed by checking the read result before using the document.

The exact C# signatures depend on the generated delivery, including how output arguments and document handles are represented. The supplied programming examples are the executable reference for this workflow.

Integration details that matter in production

The OCCT 8.0.0 release adds Unicode and UTF-8 conversion improvements, expanded class coverage and regression checks for strings, collections, messages and file exchange. These details matter when CAD paths, model names or user messages contain non-ASCII text.

Plan object lifetime and error handling at the managed/native boundary. Use the examples delivered with the selected wrapper version to confirm method signatures and document handling. Source delivery also allows a team to inspect generation rules and adapt packaging to its own deployment process under the applicable license.

Discuss C# wrapper evaluation with your framework, runtime identifier, OCCT release and required API coverage. For broader language integration and graph-native operations, see BRepGraph Advance.