ifcfastexperimental

an open IFC parser — early & in progress

Open any IFC.
Ask any question.

A native IFC parser with a Python API. It reads a model's data and geometry into pandas tables, triangle meshes, and point clouds — no geometry kernel on the hot path. Built for AI agents, analytics, and pipelines.

Open-source and under active development. It complements ifcopenshell rather than replacing it — different tradeoffs, different jobs.

Install pip install ifcfast Source

$ pip install ifcfast$ python -c "import ifcfast; ifcfast.open(ifcfast.example_path()).summary()"

python

What it is

One parse.
Data and geometry, both.

ifcfast opens a model once and exposes it through ordinary Python objects — DataFrames, numpy arrays, JSON-friendly dicts. The pieces below are what it does today.

Parse

Native, kernel-free reading

A Rust core reads the IFC STEP data section directly into typed tables. ifcopenshell stays an optional dev dependency used for cross-checking — never on the hot path.

Data

Everything as pandas

Property sets, quantities, materials, and classifications come back as long-format DataFrames. Filter, join, pivot, dump to Excel — ordinary data work, no IFC-specific gymnastics.

Graph

Spatial relationships

Containment and aggregation as edge tables, plus traversal helpers. m.ancestors(guid) walks storey → building → site → project in one call.

Geometry

Meshes & point clouds

Per-product triangle meshes, area-weighted point-cloud sampling with normals, and geometric quantities — handed back as numpy / pandas. Drops straight into trimesh, Open3D, or your own pipeline.

Substrate

Geometry + semantics, joined

An optional GeoParquet export that pairs each product's geometry with its data, so a model becomes something DuckDB or pandas can query like any other table.

Agents

MCP server

ifcfast-mcp speaks the Model Context Protocol, so Claude, Cursor, or any MCP client can open and question IFC files directly — point at the server, get tools and a guide resource.

One parse, every lens.

See it. Count it.
Trace it.

A public-license IFC opened once with ifcfast.open(). Click anything in the data panel — the model dims, the graph highlights the path. Three lenses, one model, cross-filtered. A live look at what the parser produces, not a benchmark.

loading…

Source IFC: buildingSMART community sample — Duplex Apartment (CC BY 4.0).ifcfast hands over whatever it can read — mesh volume, AABB volume, per-face area, footprint, length, thickness, author-supplied Qto_*pset values, layer breakdowns. Interpreting them is the consumer's job: the numbers reflect the geometry the modeller authored (a lightbulb's mesh volume is its envelope, not its glass), and they are not yet verified against other tools — cross-check before relying on them.

What we're attempting

An open experiment,
honest about its edges.

The goal is to make IFC files fast and pleasant to query — for agents, analytics, and anyone who wants to ask questions of a model without standing up a full geometry kernel.

ifcfast is early and not yet verified against established tools. Treat its output as provisional and cross-check it against ifcopenshell or your existing toolchain before you rely on it.

Report an issue Contribute

what we're trying to find out

Expose the whole file as tidy data
Every part a model declares — properties, quantities, materials, classifications, relationships — as tables you can reason about, with nothing silently dropped.
Carry geometry far enough for analysis
Meshes, point clouds, and geometric quantities that are good enough to measure, sample, and compare — without trying to be a CAD kernel.
Stay honest about limits
Surface what the parser can't yet handle as explicit, visible gaps rather than hiding them — so you always know what you're looking at.

Found a wrong number, a missed entity, or a faulty assumption? Open a GitHub issue. That feedback is how this becomes trustworthy.

For agents

Plug into Claude.
Or Cursor. Or anything MCP.

ifcfast-mcp exposes the parse, data, and geometry surface as Model Context Protocol tools. Add one line to your MCP client config and your agent can drive IFCs directly — without you writing any glue code.

Paste ifcfast.system_prompt() into the system prompt for instant ramp-up.

Install

pip install 'ifcfast[mcp]'

Add to Claude Desktop

~/Library/Application Support/Claude/claude_desktop_config.json (macOS) %APPDATA%/Claude/claude_desktop_config.json (Windows)

{
  "mcpServers": {
    "ifcfast": {
      "command": "ifcfast-mcp"
    }
  }
}

Restart the client

ifcfast appears as 18 tools + ifcfast://agents-guide resource. Your agent can now open IFCs, walk the spatial graph, run drift, and extract type catalogues — without any glue code.

The API

Pandas and numpy out.

Data layers are long-format DataFrames; geometry is numpy arrays; summaries are JSON-friendly dicts. No ifcopenshell.open() on the hot path — ifcopenshell is an optional dev dependency, used to cross-check output in tests.

Data layers

import ifcfast

m = ifcfast.open("model.ifc")

# Long-format pandas tables, lazy.
m.psets             # property sets
m.quantities        # base quantities
m.materials         # IfcMaterial / layer / constituent / profile
m.classifications   # NS 3451 / Uniformat / OmniClass

Spatial graph

# Spatial-relationship graph
m.contained_in       # product → storey edges
m.aggregates         # child → parent edges
m.storey_building    # storey → building edges

# Traversal helpers
m.parent(g);   m.children(g)
m.ancestors(g);   m.descendants(g)
m.storey_of(g);   m.building_of(g)
m.products_in(parent_g)