IfcGeomSharp.dll, IfcParseSharp.dll

Where did you find this info?

I would recommend looking at https://github.com/xBimTeam/XbimEssentials/ or interact with IfcOpenShell by means of running a subprocess python/ifcconvert

We might have a C# binding in the future, but it's currently not something actively worked on.

Following @aothms recommendation to interact with IfcOpenShell via subprocess, I want to share a working implementation in case it helps others facing the same question

What I built

A WPF / .NET 8 desktop application for BIM quantity takeoff that:

• Loads any IFC file (tested with Revit and ArchiCAD exports)
• Computes net volume (openings subtracted), gross volume, net area, and bounding box dimensions per element
• Falls back to geometry calculation when Qto_* psets are not present in the IFC
• Renders the model in 3D with color per IFC type, element highlight, and zoom-to-element
• Works fully offline — no Python required on the user's machine

Architecture

WPF app (C#)
└── Process.Start() → ifc_engine.exe
└── Python + IfcOpenShell (bundled by PyInstaller)
→ returns JSON via stdout (quantities)
→ writes OBJ files to temp folder (geometry)

WPF app (C#)
└── WebView2 + Babylon.js
→ loads OBJ files from temp folder
→ renders 3D model, handles highlight and zoom
The Python script is compiled with PyInstaller into a standalone ~41MB exe. The C# app calls it via Process.Start() and reads JSON from stdout. No Python installation required on client machines.

Key patterns

C# side — calling the engine:
var psi = new ProcessStartInfo
{
FileName = "ifc_engine.exe",
Arguments = $""{ifcPath}" "{types}"",
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false,
CreateNoWindow = true,
StandardOutputEncoding = Encoding.UTF8,
};
using var process = Process.Start(psi)!;
var json = await process.StandardOutput.ReadToEndAsync();
var results = JsonSerializer.Deserialize<List>(json);

Python side — net vs gross volume:

import ifcopenshell, ifcopenshell.geom, ifcopenshell.util.shape

ifc = ifcopenshell.open(ifc_path)

settings_net = ifcopenshell.geom.settings()
settings_gross = ifcopenshell.geom.settings()
settings_gross.set("disable-opening-subtractions", True)

for element in ifc.by_type("IfcWall"):
shape_net = ifcopenshell.geom.create_shape(settings_net, element)
shape_gross = ifcopenshell.geom.create_shape(settings_gross, element)

vol_neto  = ifcopenshell.util.shape.get_volume(shape_net.geometry)
vol_bruto = ifcopenshell.util.shape.get_volume(shape_gross.geometry)
area_neta = ifcopenshell.util.shape.get_area(shape_net.geometry)

Python side — OBJ export with correct coordinate system (IFC Z-up → Babylon.js Y-up):

IfcOpenShell 0.8.x returns transformation matrix as a plain tuple (column-major, 16 values)
raw = shape.transformation.matrix
flat = list(raw.data) if hasattr(raw, "data") else list(raw)

for i in range(0, len(verts), 3):
x, y, z = verts[i], verts[i+1], verts[i+2]
tx = flat[0]*x + flat[4]*y + flat[8]*z + flat[12]
ty = flat[1]*x + flat[5]*y + flat[9]*z + flat[13]
tz = flat[2]*x + flat[6]*y + flat[10]*z + flat[14]
# Swap Y/Z for Babylon.js (Y-up convention)
obj_file.write(f"v {tx:.4f} {tz:.4f} {ty:.4f}\n")

Tradeoffs

• Distributable size: ~41MB (ifc_engine.exe with Python + IfcOpenShell bundled)
• First call startup: ~2-3 seconds (PyInstaller extraction)
• Subsequent calls: Fast
• Python on client machine: Not required
• Offline capable: Yes

One gotcha worth documenting
The transformation matrix returned by shape.transformation.matrix in IfcOpenShell 0.8.x is a plain tuple (column-major, 16 values), not an object with a .data attribute as in some older versions. If you need to support both:

raw = shape.transformation.matrix
flat = list(raw.data) if hasattr(raw, "data") else list(raw)

Hope this is useful for anyone trying to bridge IfcOpenShell with a .NET desktop app.
Happy to share more details or answer questions.
José Laks