OCCT3D Data Exchange: One API, 20+ Formats, Zero Lock‑In

[dpasukhi]

Open CASCADE Technology ships a unified, production‑grade Data Exchange stack that lets you move geometry, assemblies, metadata, and meshes between more than twenty CAD, BIM, visualization, and scan formats — all through a single C++ API.

This post is a short tour of how the pipeline is wired, what formats are supported, and how to convert between them with real code you can paste into your project today.

Reference: occt3d.com — Data Exchange Formats

---

1. The big picture

Every format in OCCT3D is a library that exposes a Provider plugged into the central DE_Wrapper. Your application talks to the wrapper; the wrapper dispatches to the right provider based on file extension, magic bytes, or an explicit configuration node. The same calling code reads STEP, writes GLTF, imports Parasolid, and exports USD.

flowchart LR
    App["Your Application"] --> DEW["DE_Wrapper<br/>(unified facade)"]
    DEW --> R{"Dispatch"}
    R -->|".step / .stp"| STEP["DESTEP_Provider"]
    R -->|".igs / .iges"| IGES["DEIGES_Provider"]
    R -->|".gltf / .glb"| GLTF["DEGLTF_Provider"]
    R -->|".stl"| STL["DESTL_Provider"]
    R -->|".obj"| OBJ["DEOBJ_Provider"]
    R -->|".wrl / .vrml"| VRML["DEVRML_Provider"]
    R -->|".ply"| PLY["DEPLY_Provider"]
    R -->|".brep / .shape"| BREP["BREP native"]
    R -->|"Commercial"| CASC["DECascade<br/>JT · Parasolid · DXF · ACIS · USD<br/>FBX · IFC · RVM · STP XML · Assimp · …"]
    STEP --> Core["OCCT Core:<br/>TopoDS_Shape · TDocStd_Document"]
    IGES --> Core
    GLTF --> Core
    STL --> Core
    OBJ --> Core
    VRML --> Core
    PLY --> Core
    BREP --> Core
    CASC --> Core

Loading

Two things fall out of this design:

1. Uniform code for any format. The file extension chooses the provider; the API stays the same.
2. Two I/O targets: directly into a TopoDS_Shape (lightweight, geometry only) or into a full TDocStd_Document with XCAF (colors, names, materials, layers, assembly structure).

---

2. Supported formats

Format	Extensions	Support	License	Description
STEP	.stp, .step	Read/Write	Open Source	ISO 10303 standard for product manufacturing information
IGES	.igs, .iges	Read/Write	Open Source	Initial Graphics Exchange Specification
XCAF	.xbf, .xml, .ocf	Read/Write	Open Source	Open CASCADE's native format with extended CAD features
BREP	.brep, .shape	Read/Write	Open Source	Open CASCADE's boundary representation format
VRML	.wrl, .vrml	Read/Write	Open Source	Virtual Reality Modeling Language
STL	.stl	Read/Write	Open Source	Stereolithography, ubiquitous in 3D printing
PLY	.ply	Write only	Open Source	Polygon File Format for scanned objects
glTF	.gltf, .glb	Read/Write	Open Source	The "JPEG of 3D" — efficient web/visualization transport
OBJ	.obj	Read/Write	Open Source	Wavefront OBJ
JT	.jt	Read/Write	Commercial	ISO standard lightweight 3D format
Parasolid	.xt, .xb, .x_t, .x_b	Read only	Commercial	Siemens PLM kernel format
DXF	.dxf	Read/Write	Commercial	AutoCAD Drawing Exchange Format
ACIS	.sat, .sab	Read/Write	Commercial	Spatial Corporation's 3D kernel format
Assimp	.blend, .3ds, .3mf, .ac, .amf, .ase, .dae, .x3d, …	Read only	Commercial	Universal mesh import
USD	.usd, .usda, .usdz, .usdc	Read/Write	Commercial	Universal Scene Description
FBX	.fbx	Read/Write	Commercial	Autodesk's platform-independent 3D exchange
RVM	.rvm	Read only	Commercial	AVEVA PDMS Review Model (plant design)
STP XML	.stpx, .stpxz, .stpa, .stpz	Read/Write	Commercial	XML representation of STEP
XPDMXML	.xpdmxml	Read only	Commercial	XML Product Data Management
MSC/NASTRAN	.nas	Read only	Commercial	Finite Element Analysis
IFC	.ifc	Read only	Commercial	Industry Foundation Classes for BIM
E57	.e57	Read only	Commercial	Point cloud standard
Point Cloud	.ptx, .pts, .psl	Read only	Commercial	3D scan point clouds

• Open Source formats ship with the standard OCCT distribution.
• Commercial formats ship in the OCCT Commercial Components under a perpetual license (see §7).

---

3. Two ways to call the API

OCCT3D gives you two equally valid entry points. Pick whichever fits your codebase.

Path A — DE_Wrapper (recommended: generic, format-agnostic)

One facade, any format. Extension picks the provider at runtime.

#include <DE_Wrapper.hxx>
#include <TDocStd_Document.hxx>
#include <XCAFApp_Application.hxx>

occ::handle<XCAFApp_Application> anApp = XCAFApp_Application::GetApplication();
occ::handle<TDocStd_Document>    aDoc;
anApp->NewDocument("BinXCAF", aDoc);

occ::handle<DE_Wrapper> aWrapper = DE_Wrapper::GlobalWrapper()->Copy();

// Read any supported format — the wrapper dispatches by extension / content
if (!aWrapper->Read("input.step", aDoc))
{
  // handle error
}

// Write the same document out as glTF, STL, OBJ, USD, FBX, …
if (!aWrapper->Write("output.glb", aDoc))
{
  // handle error
}

Path B — Direct provider (full control, per-format tuning)

When you need to tweak format-specific parameters (STEP assembly mode, glTF Draco compression, writer product names, …), instantiate the provider directly.

#include <DESTEP_ConfigurationNode.hxx>
#include <DESTEP_Provider.hxx>

occ::handle<DESTEP_ConfigurationNode> aNode = new DESTEP_ConfigurationNode();

// Tune STEP-specific parameters
aNode->InternalParameters.ReadAssemblyLevel =
  DESTEP_Parameters::ReadMode_AssemblyLevel_All;
aNode->InternalParameters.WriteAssembly =
  DESTEP_Parameters::WriteMode_Assembly_On;
aNode->InternalParameters.WriteProductName = "MyProduct";

occ::handle<DESTEP_Provider> aProvider = new DESTEP_Provider(aNode);

TopoDS_Shape aShape;
if (!aProvider->Read("input.step", aShape))
{
  // handle error
}

if (!aProvider->Write("output.step", aShape))
{
  // handle error
}

Every commercial format (JT, Parasolid, DXF, ACIS, USD, FBX, IFC, Assimp, RVM, STP XML, XPDMXML, NASTRAN, E57, Point Cloud) follows the same pattern: DEXxx_ConfigurationNode + DEXxx_Provider.

---

4. The conversion matrix

Because every provider round-trips through TopoDS_Shape or TDocStd_Document, any read format can be written to any write format. OCCT handles the semantic layers in between: B-Rep ↔ mesh tessellation, assembly flattening, XCAF metadata mapping.

flowchart LR
    subgraph Input["Read sources"]
      direction TB
      IN1["STEP / IGES / BREP<br/>XCAF"]
      IN2["JT · Parasolid · ACIS<br/>USD · FBX · DXF · STP XML"]
      IN3["IFC · RVM · XPDMXML"]
      IN4["glTF · OBJ · STL · VRML<br/>Assimp (.blend, .3ds, .dae, …)"]
      IN5["E57 · PTX / PTS / PSL"]
      IN6["NASTRAN (.nas)"]
    end

    subgraph Core["OCCT in-memory model"]
      direction TB
      BREP["TopoDS_Shape (B-Rep)"]
      XCAF["TDocStd_Document (XCAF)<br/>colors · names · layers · materials · assemblies"]
      MESH["Poly_Triangulation (meshes)"]
      PC["Point cloud buffers"]
    end

    subgraph Output["Write targets"]
      direction TB
      OUT1["STEP / IGES / BREP<br/>XCAF"]
      OUT2["JT · ACIS · USD · FBX<br/>DXF · STP XML"]
      OUT3["glTF · OBJ · STL · VRML · PLY"]
    end

    IN1 --> BREP
    IN1 --> XCAF
    IN2 --> BREP
    IN2 --> XCAF
    IN3 --> XCAF
    IN4 --> MESH
    IN4 --> XCAF
    IN5 --> PC
    IN6 --> MESH

    BREP -->|"BRepMesh_IncrementalMesh"| MESH
    XCAF --> BREP
    XCAF --> MESH

    BREP --> OUT1
    XCAF --> OUT1
    BREP --> OUT2
    XCAF --> OUT2
    MESH --> OUT3
    XCAF --> OUT3

Loading

Reading the diagram: B-Rep formats live on the exact-geometry side, mesh formats on the tessellated side, and OCCT gives you the bridge — BRepMesh_IncrementalMesh — whenever you cross it.

---

5. Sample: B-Rep → Mesh (STEP → glTF)

This is the most common conversion in practice: you have engineering geometry (STEP/IGES/Parasolid/JT/ACIS) and you need a visualization payload (glTF/OBJ/STL).

The key point: mesh-only writers need a tessellation. Generate it with BRepMesh_IncrementalMesh before calling Write.

sequenceDiagram
    participant App
    participant Wrapper as DE_Wrapper
    participant Doc as TDocStd_Document
    participant Mesher as BRepMesh_IncrementalMesh
    App->>Wrapper: Read("model.step", aDoc)
    Wrapper-->>Doc: exact B-Rep + XCAF metadata
    App->>Doc: XCAFDoc_ShapeTool::GetOneShape(...)
    Doc-->>App: compound TopoDS_Shape
    App->>Mesher: Perform(shape, deflection)
    Mesher-->>App: triangulation stored on faces
    App->>Wrapper: Write("model.glb", aDoc)
    Wrapper-->>App: glTF with tessellation + colors

Loading

#include <BRepMesh_IncrementalMesh.hxx>
#include <DE_Wrapper.hxx>
#include <IMeshTools_Parameters.hxx>
#include <TDocStd_Document.hxx>
#include <TopoDS_Shape.hxx>
#include <XCAFApp_Application.hxx>
#include <XCAFDoc_DocumentTool.hxx>
#include <XCAFDoc_ShapeTool.hxx>

bool ConvertStepToGltf(const TCollection_AsciiString& theInputStep,
                      const TCollection_AsciiString& theOutputGltf)
{
  // 1. New XCAF document
  occ::handle<XCAFApp_Application> anApp = XCAFApp_Application::GetApplication();
  occ::handle<TDocStd_Document>    aDoc;
  anApp->NewDocument("BinXCAF", aDoc);

  occ::handle<DE_Wrapper> aWrapper = DE_Wrapper::GlobalWrapper()->Copy();

  // 2. Read STEP: exact B-Rep + colors/names/assembly into XCAF
  if (!aWrapper->Read(theInputStep, aDoc))
  {
    return false;
  }

  // 3. Collect every free shape from the document into one compound
  occ::handle<XCAFDoc_ShapeTool> aShapeTool =
    XCAFDoc_DocumentTool::ShapeTool(aDoc->Main());
  const TopoDS_Shape aCompound = aShapeTool->GetOneShape();

  // 4. Mesh the B-Rep (required for glTF / OBJ / STL / PLY / VRML writers)
  IMeshTools_Parameters aMeshParams;
  aMeshParams.Deflection      = 0.1;   // linear deflection, model units
  aMeshParams.Angle           = 0.5;   // angular deflection, radians
  aMeshParams.InParallel      = true;
  aMeshParams.MinSize         = Precision::Confusion();
  aMeshParams.Relative        = false;
  aMeshParams.ControlSurfaceDeflection = true;

  BRepMesh_IncrementalMesh aMesher(aCompound, aMeshParams);
  if (!aMesher.IsDone())
  {
    return false;
  }

  // 5. Write glTF — picks up the tessellation we just generated
  return aWrapper->Write(theOutputGltf, aDoc);
}

The same function trivially becomes STEP → OBJ, STEP → STL, JT → glTF, Parasolid → USD, etc. — just change the output extension. OCCT dispatches to the right writer.

If you only have a bare TopoDS_Shape (no document), call BRepMesh_IncrementalMesh(aShape, aMeshParams) directly, then aWrapper->Write(path, aShape).

---

6. Sample: Mesh into "B-Rep" formats — what really works

Going from triangles to exact NURBS surfaces is reverse engineering, not file conversion, and OCCT does not try to fabricate that for you automatically. But most of the formats commonly classed as "B-Rep" also carry tessellated geometry natively, and OCCT writes it:

• STEP AP242 — the current edition of ISO 10303 has first-class support for tessellated shape representations (tessellated_solid, tessellated_shell, tessellated_face, …). OCCT's STEP writer emits them when the shape carries triangulations, so a meshed model (from glTF, STL, OBJ, Assimp, scans, …) round-trips through STEP AP242 as a faithful tessellated payload — no fake NURBS.
• STP XML — the XML serialization of STEP AP242 inherits the same tessellated schema. Mesh export works here too.
• JT — JT is designed as a lightweight visualization format and stores LODs of tessellated geometry as its primary representation. Mesh export is native.
• USD — Pixar's Universal Scene Description carries UsdGeomMesh as a first-class primitive. Tessellated shapes write out as USD meshes.
• DXF — carries both exact B-Rep and mesh. Solids/surfaces export as DXF B-Rep entities; triangulated shapes export as polyface meshes / 3DFACE entities.
• ACIS (.sat / .sab) — carries both exact B-Rep and mesh. It's a full kernel format, so solids/faces/edges round-trip as exact geometry; tessellated shapes are also supported.

In short: exact-geometry-only targets are IGES, BREP, and classic STEP AP203/AP214. STEP AP242, STP XML, JT, USD, DXF, and ACIS all accept meshes — and DXF and ACIS also accept exact B-Rep — alongside every dedicated mesh format (glTF, OBJ, STL, PLY, VRML).

flowchart LR
    MESH["Poly_Triangulation<br/>(from glTF / STL / OBJ /<br/>Assimp / scans / IncMesh)"]
    subgraph MeshOK["Mesh-capable writers"]
      direction TB
      A["glTF · OBJ · STL · VRML · PLY"]
      B["STEP AP242 · STP XML<br/>(tessellated_*)"]
      E["JT (native tessellated LODs)"]
      F["USD (UsdGeomMesh)"]
      C["DXF (polyface / 3DFACE)"]
      D["ACIS .sat / .sab (faceted)"]
    end
    NoFit["IGES · BREP · STEP AP203/214<br/>(exact surfaces only)"]
    MESH --> A
    MESH --> B
    MESH --> E
    MESH --> F
    MESH --> C
    MESH --> D
    MESH -. "needs surface<br/>reconstruction" .-> NoFit

Loading

Example — writing a mesh into STEP AP242

Select the AP242 schema on the configuration node and write a triangulated shape. OCCT emits the mesh as AP242 tessellated entities.

#include <DESTEP_ConfigurationNode.hxx>
#include <DESTEP_Provider.hxx>
#include <STEPControl_StepModelType.hxx>

occ::handle<DESTEP_ConfigurationNode> aNode = new DESTEP_ConfigurationNode();
aNode->InternalParameters.WriteSchema =
  DESTEP_Parameters::WriteMode_StepSchema_AP242DIS;     // AP242 is what carries tessellation
aNode->InternalParameters.WriteTessellated =
  DESTEP_Parameters::RWMode_Tessellated_On;             // or RWMode_Tessellated_OnNoBRep to emit
                                                        // only the tessellation and skip B-Rep

occ::handle<DESTEP_Provider> aProvider = new DESTEP_Provider(aNode);
aProvider->Write("mesh_model.stp", aMeshedShape);

Mesh → mesh

For pure visualization / scan / 3D-print pipelines, mesh-to-mesh conversion is a one-liner through DE_Wrapper, and XCAF metadata (colors, names, materials) is preserved across formats that carry it:

// glTF → OBJ with colors/materials preserved via XCAF
aWrapper->Read ("scene.glb",   aDoc);
aWrapper->Write("scene.obj",   aDoc);

// STL → PLY (simple geometry pass-through)
aWrapper->Read ("scan.stl",    aShape);
aWrapper->Write("scan.ply",    aShape);

For exact surface reconstruction from a triangulated mesh (mesh → NURBS B-Rep for IGES / classic STEP / modeling kernels), pair OCCT with a surface-fitting component — we're happy to discuss options.

---

7. Real-world conversion scenarios

A quick tour of the conversions customers actually run in production. Each one is the same five-line shape of code — the extension picks the format, OCCT does the work.

7.1 ACIS → STEP — share models with partners on a different kernel

Your team works in an ACIS-based tool; a supplier or customer needs STEP. Classical interop problem, one call.

aWrapper->Read ("part.sat",  aDoc);
aWrapper->Write("part.step", aDoc);

7.2 Parasolid → glTF — put Siemens/Solid Edge/NX data on the web

Executive dashboards, digital-twin viewers, and online product configurators want glTF. Source data is Parasolid. Mesh the B-Rep once, publish anywhere.

aWrapper->Read ("assembly.x_t", aDoc);
BRepMesh_IncrementalMesh(
  XCAFDoc_DocumentTool::ShapeTool(aDoc->Main())->GetOneShape(),
  aMeshParams);
aWrapper->Write("assembly.glb", aDoc);

7.3 ACIS → glTF — 3D product catalogs and e-commerce

Same story as Parasolid, different source. Engineering data captured in .sat turns into the compact binary glTF that web/mobile viewers render instantly.

aWrapper->Read ("catalog_item.sat", aDoc);
BRepMesh_IncrementalMesh(
  XCAFDoc_DocumentTool::ShapeTool(aDoc->Main())->GetOneShape(),
  aMeshParams);
aWrapper->Write("catalog_item.glb", aDoc);

7.4 JT → STEP — normalize supplier deliverables into an ISO standard

Tier-1/tier-2 suppliers ship JT; your archival and downstream tools require STEP. Colors, names, and assembly structure survive via XCAF.

aWrapper->Read ("supplier.jt",    aDoc);
aWrapper->Write("supplier.step",  aDoc);

7.5 IFC → glTF — BIM models into web dashboards, AR, VR

IFC is the BIM exchange standard but not browser-friendly. glTF is. One step.

aWrapper->Read ("building.ifc",   aDoc);
BRepMesh_IncrementalMesh(
  XCAFDoc_DocumentTool::ShapeTool(aDoc->Main())->GetOneShape(),
  aMeshParams);
aWrapper->Write("building.glb",   aDoc);

7.6 RVM → glTF — plant/PDMS review models on the web

AVEVA RVM review models are huge and hard to share. glTF makes them viewable in a browser — useful for remote reviews and operator training.

aWrapper->Read ("plant.rvm", aDoc);
BRepMesh_IncrementalMesh(
  XCAFDoc_DocumentTool::ShapeTool(aDoc->Main())->GetOneShape(),
  aMeshParams);
aWrapper->Write("plant.glb", aDoc);

7.7 FBX → STEP AP242 — game/visualization assets into the engineering pipeline

DCC tools (Blender, Maya, 3ds Max) export FBX. When the production side needs the same asset in a CAD-standard container, STEP AP242's tessellated schema accepts it as-is — no surface fitting, no data loss.

// 1) Read FBX into the document
aWrapper->Read("asset.fbx", aDoc);

// 2) Configure a STEP provider for AP242 + tessellated write (see §6)
occ::handle<DESTEP_ConfigurationNode> aNode = new DESTEP_ConfigurationNode();
aNode->InternalParameters.WriteSchema      = DESTEP_Parameters::WriteMode_StepSchema_AP242DIS;
aNode->InternalParameters.WriteTessellated = DESTEP_Parameters::RWMode_Tessellated_On;
occ::handle<DESTEP_Provider> aProvider = new DESTEP_Provider(aNode);

// 3) Write as AP242 tessellated STEP
aProvider->Write("asset.stp", aDoc);

7.8 USD ↔ glTF — bridge two visualization ecosystems

USD is the studio / virtual-production standard; glTF is the web standard. Convert either way with the same call pattern.

aWrapper->Read ("scene.usd", aDoc);
aWrapper->Write("scene.glb", aDoc);

// …or the other direction
aWrapper->Read ("scene.glb", aDoc);
aWrapper->Write("scene.usd", aDoc);

7.9 STEP → DXF — push 3D models into AutoCAD-centric workflows

Downstream CAM shops and drawing-review tools live in DXF. Meshed STEP output writes out cleanly via DXF polyface entities.

aWrapper->Read ("part.step", aShape);
BRepMesh_IncrementalMesh(aShape, aMeshParams);
aWrapper->Write("part.dxf",  aShape);

7.10 Assimp (.blend / .3ds / .dae / …) → glTF — unify mixed-source content

Your content library contains historical assets in every format imaginable. The Assimp provider reads them all; glTF gives you one target to standardize on.

aWrapper->Read ("legacy.3ds", aDoc);
aWrapper->Write("legacy.glb", aDoc);

7.11 The matrix at a glance

flowchart LR
    subgraph Sources["Common sources"]
      A1["ACIS (.sat)"]
      A2["Parasolid (.x_t)"]
      A3["JT"]
      A4["STEP / IGES"]
      A5["IFC (BIM)"]
      A6["RVM (plant)"]
      A7["FBX / USD"]
      A8["Assimp (.blend, .3ds, .dae, …)"]
    end
    subgraph Targets["Common targets"]
      B1["STEP / STEP AP242"]
      B2["glTF (.glb)"]
      B3["DXF"]
      B4["USD"]
    end
    A1 --> B1
    A1 --> B2
    A1 --> B3
    A2 --> B1
    A2 --> B2
    A3 --> B1
    A3 --> B2
    A4 --> B2
    A4 --> B3
    A4 --> B4
    A5 --> B2
    A6 --> B2
    A7 --> B1
    A7 --> B2
    A7 --> B4
    A8 --> B2

Loading

aMeshParams is the same IMeshTools_Parameters struct shown in §5 — deflection, angle, parallel meshing. Tune it once, reuse everywhere.

---

8. Commercial components: the licensing story

The commercial format providers (JT, Parasolid, DXF, ACIS, Assimp, USD, FBX, RVM, STP XML, XPDMXML, MSC/NASTRAN, IFC, E57, Point Cloud) are distributed under OCCT's commercial license, with terms that matter to production deployments:

• Perpetual license. Pay once, use forever. No subscription expiry, no annual renewals, no license-cliff risk for long-lived products.
• No device locking / no hardware dongle. Deploy to any number of machines permitted by your license — no per-seat activation servers, no node-locking, no MAC-address files.
• No internet connection required. The libraries run fully offline. No phone-home, no license-server check-in, no telemetry. Ship them into air-gapped, classified, regulated, or embedded environments with confidence.
• No royalties, no runtime fees. Ship your application to as many end customers as you want. We don't bill per unit, per end-user, or per conversion.
• No re-distribution fees. Bundle the DLLs/SOs into your installer. That's the deal.
• Source-code option. The standard commercial delivery is pre-built binaries with full documentation, headers, and support. For teams that need deeper access — security review, compliance audit, long-term self-maintenance, or builds for unusual platforms and toolchains — source code is available as a separate commercial option. It's not part of the default package; it's a dedicated purchase with its own terms. Talk to us if that's a requirement for your procurement or regulatory process.

In short: the license fits how modern CAD / CAM / CAE / visualization applications actually ship — on-premise, offline, in regulated industries, and on customers' own hardware.

---

9. Running in the browser?

Need these conversions to run inside a browser tab instead of on a server? OCCT3D can be delivered as a WebAssembly build — we're open to that option and can provide variants on request. Tell us the formats and the use case and we'll scope the right build.

---

10. Getting started

• Website & downloads: occt3d.com
• Format matrix: occt3d.com/data-exchange-formats
• Source: github.com/Open-Cascade-SAS/OCCT
• Commercial licensing & support: contact us via occt3d.com

If you're evaluating a format migration, replacing a legacy translator, or stitching together a pipeline that crosses the B-Rep/mesh boundary — drop your use case in the comments and we'll sketch the right provider chain for it.

OCCT3D — one API, every CAD format, no lock-in.