Enables AI agents to query, edit, and interact with BIM data from IFC files through a Model Context Protocol server.
Also known as LTplus-AG/ifc-lite, @ifc-lite/mcp
- Stars
- 473
- Tools
- 125
- Downloads, 30 days
- 3,212
- Latest version
- —
- Last commit
- Nov 15, 2026
- License
- MPL-2.0
What is IFClite MCP?
IFClite enables AI agents to query, edit, and interact with BIM data from IFC files through a Model Context Protocol server. It exposes 125 tools, such as model_info, model_list, model_load.
Summary generated from the project's README
About IFClite MCP server
Interacting with Building Information Modeling data through natural language is what ifc-lite enables for developers building AI-driven construction workflows. This MCP server allows AI agents to query, edit, and inspect BIM data directly from IFC files. It supports various schema versions including IFC2X3, IFC4, IFC4X3, and IFC5 (IFCX), making it compatible with a wide range of industry standards.
Users can deploy the server via stdio or HTTP using the command ifc-lite mcp model.ifc. Once connected, an AI client can perform complex tasks such as counting specific building elements, validating models against IDS requirements, or modifying property values. The underlying technology uses a Rust core compiled to WASM to handle parsing and geometry, ensuring high performance for data automation and agentic workflows.
What you can do with it
- 1Query building element countsAsk an AI agent to determine the total number of specific components like walls or doors within a model.
- 2BIM data validationUse an agent to check if a model complies with specific information delivery specifications.
- 3Model inspection and analysisHave an AI agent extract detailed information about the schema and entities present in an IFC file.
Written from the project's README. Every use case is checked against a quote from it.
How to install IFClite MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall IFClite MCP in Claude Code
$ claude mcp add ifc-lite -- npx -y @ifc-lite/mcpInstall IFClite MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"ifc-lite": {
"command": "npx",
"args": [
"-y",
"@ifc-lite/mcp"
]
}
}
}Install IFClite MCP in VS Code
.vscode/mcp.json
{
"servers": {
"ifc-lite": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@ifc-lite/mcp"
]
}
}
}Install IFClite MCP in VS Code CLI
$ code --add-mcp '{"name":"ifc-lite","type":"stdio","command":"npx","args":["-y","@ifc-lite/mcp"]}'Install IFClite MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"ifc-lite": {
"command": "npx",
"args": [
"-y",
"@ifc-lite/mcp"
]
}
}
}Install IFClite MCP in Codex
$ codex mcp add ifc-lite -- npx -y @ifc-lite/mcpInstall IFClite MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.ifc-lite] command = "npx" args = ["-y", "@ifc-lite/mcp"]
Install IFClite MCP in Gemini CLI
$ gemini mcp add -s user ifc-lite npx -- -y @ifc-lite/mcpInstall IFClite MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"ifc-lite": {
"command": "npx",
"args": [
"-y",
"@ifc-lite/mcp"
]
}
}
}Started by HostedMCP on 16 Nov 2026
We ran this command for @ifc-lite/mcp 0.29.0 in an isolated container with no network and no keys. It answered and listed 125 tools.
IFClite MCP tools 125
Read from the server with tools/listmodel_infoReturn schema, entity counts, file metadata, georeferencing, and units for the active (or named) model.
model_listList all currently loaded models with metadata.
model_loadLoad an IFC file from disk into the session. Requires `mutate` scope. The path must be inside the configured allowedPaths roots (when set).
model_unloadDrop a model from session memory.
schema_describeDescribe an IFC entity type: attributes, parents, inheritance chain. Useful for an agent to know the legal shape before mutating. Classes outside the IFC4_ADD2_TC1 codegen pin (IFC2X3-only and IFC4X3-only ones) are answered from the bundled schema union, which carries names but not attribute types — `schemaSource` says which table answered.
query_entitiesFilter entities by IFC type, property, material, or spatial container. Returns matching IDs and minimal metadata. `selector` (an IfcOpenShell-style selector string, e.g. "IfcWall, Pset_WallCommon.FireRating=2HR") composes with `type`/`types`/`property` — classes union in the same type list; property comparisons AND in the same filter list. Only a lossless subset of the selector grammar is supported here (exact-name Pset_/Qto_ comparisons and class terms, not regex pset/property names, attribute terms, material=/classification=/location=, parent=, query:, "!*=", or "!" class negation) — an unsupported construct is rejected with an error naming it, never silently dropped or run as an empty filter.
count_entitiesCount BIM entities (the same set `query_entities` returns), optionally grouped by a key (type, storey, material). Returns aggregates rather than the full set. For raw STEP record counts use `model_info`.
get_entityFull data for a single entity: attributes, properties, quantities, classifications, materials, relationships.
get_entities_bulkBatch version of get_entity. Up to 1000 IDs per call. Returns a map keyed by globalId, resolved the same way `get_entity` resolves one: an entity this session created wins over a same-GlobalId entity in the file, and deleted entities are never returned. A GlobalId naming more than one entity is listed in `ambiguousGlobalIds`.
spatial_hierarchyProject → Site → Building → Storey → Space tree. Compact form by default (set `include_elements` to expand).
containment_chainFor an entity, return its spatial containment chain from the entity up to the project root.
relationshipsInbound and outbound relationships of an entity (voids, fills, groups, connections, …).
Show all 125 toolsShow fewer tools
properties_uniqueUnique values for a single property across a type set. Useful for filter UIs and stats.
materials_listAll materials present in the model with usage counts.
classifications_listAll classification references in the model with usage counts.
georeferencingCoordinate reference system, MapConversion, project north and true north.
unitsLength unit scale (factor that converts stored lengths to meters) and other unit metadata.
query_roomsRead native mesh-derived room candidates on a loaded storey. Coordinates and settings are storey-local metres. No IFC or Undo operation is written.
geometry_getMesh data (positions, indices, normals) for an entity selection. Requires the WASM geometry pipeline; returns UNSUPPORTED_OPERATION when the server runs without it.
geometry_bboxAxis-aligned bounding box for one or many entities, computed from IfcElementQuantity values when available.
geometry_volumeElement volume (in the file volume unit, typically m³) read from IfcElementQuantity. Returns null per entity when no quantity is present; the response `unit` field reports the resolved symbol.
geometry_areaElement surface area (in the file area unit, typically m²) read from IfcElementQuantity. The response `unit` field reports the resolved symbol.
raycastCast a world-space ray against the model. Requires the WASM geometry pipeline.
clash_checkClash detection on a single model. Omit BOTH a and b to detect ALL clashes inside the model (every element vs every other — no discipline matrix needed). Give only a TYPE selector for a to self-clash within a group (a="IfcDuct*"), or both a and b for a pairwise check (a="IfcDuct*", b="IfcWall*"). Meshes the model headlessly and returns a summary plus the top clashes by distance ascending, so deepest penetration first in hard mode and tightest gap first in clearance mode.
clash_matrixRun the standard discipline clash matrix (MEP x STR, HVAC x ARCH, ...) over the whole model. Returns per-rule and per-severity breakdowns over EVERY clash, plus a sample of clashes selected and capped by distance ascending -- so the breakdowns are complete and the sample is not.
ids_validateRun an IDS rule set against the model. Either pass `ids_xml` inline or `ids_path` to read from disk.
ids_explainProduce a natural-language explanation of a single IDS specification (applicability + requirements).
model_auditComprehensive model health check: required entities, GlobalId uniqueness, orphan detection, naming conventions, broken relationships. Returns Lighthouse-style scores per category.
gherkin_checkRun buildingSMART Gherkin validation rules. Not implemented in v0.1.
check_rulesRun a .rules.json information-validation rule set against every model in scope. Either pass `rules_json` inline or `rules_path` to read from disk.
review_findingsRead captured IDS/information Review facts, or supplied SavedAnalysisRun and SavedValidationReport historical evidence. Supplied imports never attest native execution. Source/identity binding and scope filtering cover complete target sets; unsupported inputs remain explicit.
place_openingPlace IfcOpeningElement in a loaded wall through the same creation core as the Model workspace and SDK. Dimensions are metres in the host frame. Refuses cuts outside the wall, overlapping cuts, and unreadable opening geometry. Writes the complete void/fill graph atomically; one mutation_undo removes the placement.
place_doorPlace IfcDoor in a loaded wall through the same creation core as the Model workspace and SDK. Dimensions are metres in the host frame. Refuses cuts outside the wall, overlapping cuts, and unreadable opening geometry. Writes the complete void/fill graph atomically; one mutation_undo removes the placement.
place_windowPlace IfcWindow in a loaded wall through the same creation core as the Model workspace and SDK. Dimensions are metres in the host frame. Refuses cuts outside the wall, overlapping cuts, and unreadable opening geometry. Writes the complete void/fill graph atomically; one mutation_undo removes the placement.
place_curtain_wallCreate IfcCurtainWall on a loaded storey through the Model workspace/SDK builder. All lengths are metres in the storey frame; grid axes are in the grid frame. Grid columns require actual model-local grid/axis references and a position matching their live crossing. Creates the complete graph atomically; one mutation_undo removes it. This command creates a new element on each call.
place_gridCreate IfcGrid on a loaded storey through the Model workspace/SDK builder. All lengths are metres in the storey frame; grid axes are in the grid frame. Grid columns require actual model-local grid/axis references and a position matching their live crossing. Creates the complete graph atomically; one mutation_undo removes it. This command creates a new element on each call.
place_grid_columnCreate IfcColumn on a loaded storey through the Model workspace/SDK builder. All lengths are metres in the storey frame; grid axes are in the grid frame. Grid columns require actual model-local grid/axis references and a position matching their live crossing. Creates the complete graph atomically; one mutation_undo removes it. This command creates a new element on each call.
edit_hosted_elementMove or resize a live wall-hosted opening, door or window together with its actual cut. Offset and Sill are metres in the host frame; OverallWidth/OverallHeight are metres. Identity and relationships are retained. Overlap, out-of-host and unsupported geometry edits are refused atomically. One mutation_undo restores the preceding graph.
duplicate_elementDuplicate one product with its hosted openings/fillings and assembly parts, new GlobalIds and the viewer Name suffix (copy). Supply the desired storey-local IFC XYZ metre offset; optional Name overrides the suffix. One mutation_undo removes the whole duplicate.
copy_elementsCopy selected products once per transform, with their hosted openings/fillings and assembly parts. Selected children are deduplicated. Offset is storey-local IFC XYZ metres; turn is radians about pivot XY. One mutation_undo removes the complete batch.
array_elementsLinear spacing/fit or polar array using the viewer planner. Count includes the original; a full circle excludes the coincident final copy. Distances and anchor/cursor are storey-local metres; angleDegrees is degrees. One mutation_undo removes all copies.
edit_element_geometryAlign native mesh edges or centres, move/rotate a selection, change extrusion/profile dimensions, move wall endpoints, split a selection or trim/extend an axis. Coordinates are IFC storey-local metres; rotation is radians. Supported-source predicates, hosted cuts, wall joins, identity policy and atomic refusals match the viewer. One mutation_undo restores the whole operation. Shared writable source geometry is refused when editing it would alter an unrelated occurrence.
room_commandNative Room operations from the current tessellated wall geometry. Query candidate faces; Auto creates unoccupied rooms, Pick selects a point, Footprint encloses the storey, Update follows detected boundaries, Edit changes retained native topology and synchronizes IFC spaces. All coordinates/settings are storey-local metres. Requires the installed WASM geometry runtime. Each write is one mutation_undo operation; supported shapes and occupied-room refusals match the viewer.
join_wallsJoin two straight walls in the same placement frame through IfcRelConnectsPathElements. Uses the Model workspace and SDK core, rewrites bodies and axes atomically, and refuses unreadable or stranded hosted openings. One mutation_undo restores the earlier complete graph.
entity_set_propertySet or create a property on an entity. Mutations are queued; call `export_ifc` to persist.
entity_delete_propertyDelete a property from a Pset. Queued — persist via `export_ifc`.
entity_set_attributeSet a top-level IFC attribute (Name, Description, ObjectType, Tag).
entity_createCreate a new IFC entity with raw positional attributes. Returns the new expressId. Optional `global_id` sets the GlobalId of an IfcRoot subtype (attribute 0); it must be a valid 22-character IFC GUID not already used in the model.
entity_deleteDelete an entity. Note: cascades are NOT applied automatically — caller must remove dependent relationships first.
mutation_batchApply N mutation operations in order. Each item names a sub-tool and its arguments. Returns per-step results in order. Not atomic: a failing operation is reported in results[] and does not roll back the ones before it.
mutation_diffInspect pending mutations vs the original parsed state.
mutation_undoRevert the last N pending operations on this session. A hosted placement or wall join is one operation including its complete IFC graph; other mutations count individually.
model_saveWrite the current model (with pending mutations) to disk. Convenience wrapper around export_ifc.
bcf_topic_listList BCF topics in this session, optionally filtered by status.
bcf_topic_createCreate a new BCF topic. Returns the GUID for follow-up calls.
bcf_topic_updateUpdate topic fields or append a comment.
bcf_topic_closeMark a topic resolved (status="Closed").
bcf_viewpoint_createAttach a viewpoint to a topic. Selection-only viewpoints work without camera state; camera/section require a viewer integration.
bcf_exportExport the in-memory BCF project as a .bcfzip file.
bcf_publications_listList credential-free native Flow BCF publication intents, unresolved outcomes and receipts for the current principal. Does not contact a server.
bcf_publication_checkRead the original BCF target under explicitly supplied network.fetch grants and persist actual matching candidate GUIDs. Never sends a write or blindly retries. token_env needs its exact secret.read grant; unsafe credential-bearing results are refused; protocol keys and identifiers are preserved.
bcf_publication_reconcileBind an intent to one GUID previously obtained and durably checked at its original target with the same payload. Makes no network write. Refuses arbitrary GUIDs and live send ownership; the receipt survives process restart.
bcf_publication_confirm_absentExplicitly confirm absence only after the latest complete persisted server check found an empty collection with explicit full original access-scope confirmation. Old markerless or unconfirmed checks cannot release an intent. Makes no write; releases the intent for a separately reviewed later run. Failed or partial checks and live send ownership cannot release it.
bsdd_searchSearch the buildingSMART Data Dictionary for classes by keyword.
bsdd_classFull class details for an IFC entity name (e.g. "IfcWall") from bSDD.
bsdd_property_setsGet all property sets defined for an IFC entity in bSDD (e.g. Pset_WallCommon for IfcWall).
bsdd_matchSuggest matching bSDD classes for an entity in the loaded model. Useful for classifying unclassified elements.
model_diffCompare two loaded models. Reports added/removed entities by GlobalId and per-type count deltas. Set by_content=true when the two models may have been re-exported from scratch (new GlobalIds): that runs the real diff engine, which matches entities by content so a re-GUID stops reading as the whole model deleted and re-added.
quantity_diffPer-entity-type quantity comparison between two models, optionally grouped by storey.
export_ifcWrite the model (with pending mutations) to .ifc/.ifczip on disk.
export_csvTabular property/quantity export. Columns may be plain attributes (Name, Type, GlobalId) or `Pset_X.Property` / `Qto_X.Quantity` paths.
export_jsonStructured JSON dump of attributes/properties/quantities for a type set.
export_glbGeometry-only glTF binary (GLB) export via the Rust mesh pipeline. Optional `type` filter isolates one IFC class.
export_objGeometry-only Wavefront OBJ export via the Rust mesh pipeline. Optional `type` filter isolates one IFC class.
export_ifcxSave to .ifcx (IFC5 / USD-style node graph) via the Rust exporter: spatial hierarchy + classes + known IFC5 properties.
export_usdSave to .usda (OpenUSD ASCII) via the Rust exporter: a real Z-up USD stage — spatial hierarchy of Xform prims, UsdGeomMesh geometry, UsdPreviewSurface materials, and IFC metadata as custom attributes. Whole-model (geometry-backed); opens in usdview / Blender / Omniverse.
export_pdf_reportAudit/IDS report as PDF. Planned for v0.5.
viewer_openBoot the in-process WebGL viewer for a model. Returns the URL to open in a browser. Idempotent for the same model.
viewer_closeStop the in-process viewer and clear its selection state.
viewer_statusReport whether the viewer is open, on what port, and the current selection.
viewer_colorizePaint a set of entities with a color. Pass `type`, `global_ids`, or `express_ids` to pick the set; pass `color` as [r,g,b]/[r,g,b,a] (0–1), a #hex, or a named color.
viewer_isolateHide everything except the listed entities. Great for "show me only the load-bearing walls".
viewer_hideHide a set of entities in the viewer.
viewer_showMake a set of entities visible (un-hide).
viewer_resetReset visibility (show all) and clear all per-element color overrides.
viewer_fly_toAnimate the camera to frame the listed entities.
viewer_set_sectionApply a section plane to the viewer.
viewer_clear_sectionRemove the active section plane.
viewer_color_by_storeyApply a default per-storey color overlay (built-in viewer preset).
viewer_color_by_propertyColor a type set by the value of a property — distinct color per unique value, plus a "missing" group. Returns the legend so the agent can describe what colors mean.
viewer_get_selectionReturn what the user has clicked in the viewer. Both the human-readable text content and the structured payload include type, expressId, globalId, name, description, and any of the optional sections in `include` (default: attributes + classifications + materials).
viewer_describe_selectionLike viewer_get_selection but always pulls the full kitchen sink — attributes, properties, quantities, classifications, materials. Use this when the user asks "tell me everything about what I just clicked".
viewer_wait_for_selectionBlock until the user picks an entity in the viewer (or `timeout_ms` elapses). Useful for "click on the wall you want me to inspect" workflows. Returns the same rich payload as viewer_get_selection.
viewer_askInform the user that the agent would like to open the viewer for visual context. Returns guidance for the agent. The agent is expected to relay this to the user, then call `viewer_open` once they confirm.
cost_dataRead the canonical IFC 5D cost graph from the loaded source snapshot.
cost_evaluateEvaluate one IfcCostItem or IfcCostValue from the loaded source snapshot using decimal arithmetic and return diagnostics.
structural_dataRead the structural analysis model — analysis models, members, connections, actions/reactions and load/result groups — from the loaded model.
describe_flowDescribe a .flow.json graph's typed interface: declared inputs (name, kind, default) and outputs (node/port, value kind, access), plus registry-aware validation diagnostics. Never throws for an invalid graph — check `ok` and `diagnostics` in the result.
run_flowRun a .flow.json graph headlessly against a loaded model, exactly as `ifc-lite flow run` does. `inputs` overrides Player parameters as `{ "nodeId.param": value }`; a key naming no declared parameter is rejected, never silently dropped. A failed node marks the whole run failed (`ok: false`) and outputs downstream of it come back without data — the half-applied model is never reported as success.
propose_flowRun a native read/AI-only graph to a durable pending artifact. Model and external effect nodes are refused before requesting; applying requires a separate authorized resume_flow call.
resume_flowConsume one separately reviewed pending Flow artifact by exact proposal digest. Rechecks current sources, graph, permissions and original budget before restoring completed nodes and running downstream effects. Completed or lost-owner claims cannot run twice.
ids_auditConformance audit of an IDS file: XML and XSD shape, IFC entity/property names, restriction coherence. Answers "is this a valid IDS 1.0 file?". No model needed.
ids_lintLint an IDS document with the IDSL rule catalogue: does it mean what the author intends? Each diagnostic names its node (`nodeId`, `path`) and may carry quick fixes: op batches you can pass to ids_apply_ops unchanged. Pass `doc` (from ids_read / ids_apply_ops) or the XML.
ids_readRead IDS XML into a Studio document (JSON with a stable UUID for every specification, facet and constraint). Pass the returned `doc` to ids_apply_ops, ids_lint and ids_write. Reading the same XML twice gives the same ids.
ids_apply_opsChange an IDS document by applying typed operations. Every op is validated and the batch is checked by the grounding gate against the IFC schema tables (entities, predefined types, attributes, property sets, properties, enumerations, data types). A refused batch changes nothing and returns each problem with a path and ranked candidates; fix the names and resend the whole batch. Starts from `doc`, from the XML, or from an empty document. Returns the new `doc` and its lint diagnostics.
ids_writeSerialise a Studio document to IDS 1.0 XML. The XML is read back to prove nothing was lost and audited; a document with audit errors is refused. Also returns the studio.json sidecar that keeps node ids next to the XML.
ids_diffSemantic diff of two IDS revisions. Specifications and facets are paired by identifier, then name and applicability, then similarity, so a rename or an edited requirement is one change. Returns added / removed / changed entries with XML paths and a plain-language line each.
ids_previewFunnel counts per specification against a loaded model: how many elements each applicability facet keeps, and how many pass each requirement. Not available yet.
ids_inferInfer specifications from the elements a selector picks in a loaded model (IfcOpenShell selector syntax). Returns ops for ids_apply_ops. Not available yet.
ids_coverageElement classes in a loaded model that no specification of the IDS governs. Not available yet.
ids_testRun the test suites stored in an .idsz bundle (fixtures that must pass or fail each specification). Not available yet.
ids_schema_searchFind IFC entity, property set, property or data type names close to a query (typo-tolerant). Use before writing a name into an IDS facet.
ids_schema_entityDescribe an IFC entity for IDS authoring: supertypes, abstract flag, predefined types, attributes and the standard property sets that apply to it.
ids_schema_psetDescribe a standard property or quantity set: the entities it applies to and its properties with data types and enumerations.
create_draft_layerOpen a draft layer (CRDT session) bound to a base ref or layer. All writes land in drafts; `scope` is a list of capability scope-claims that bound what the draft may touch.
draft_apply_opsApply entity operations to a draft layer. Each op is checked against the draft's scope claims before it touches the document; violations return a structured error.
publish_layerFreeze a draft into an immutable content-addressed layer (blake3 id + provenance manifest). Actual ops are re-verified against the manifest scope claims; mismatches are reported.
diff_layerStructured diff of a draft or published layer against a ref, layer, or draft (defaults to the candidate's own base). Same JSON shape the review UI consumes.
dry_run_mergePreview merging a draft or layer into a ref: MergePlan conflicts and auto-op count. No side effects.
list_conflictsConflict records a merge of the candidate into the ref would produce. No side effects.
request_reviewOpen a review (the PR object) proposing a published layer for merge into a ref.
add_review_feedbackRecord per-entity reviewer decisions (and optionally a status change) on an open review.
add_review_topicAttach a review comment as a BCF-shaped topic bound to (review, entity, componentKey?) — 08-review.md §8.6.
get_review_feedbackRead a review's status and per-entity decisions, structured for the agent to act on.
respond_to_reviewOpen a follow-up draft on the reviewed layer's base so the agent can address feedback; the draft is recorded as a response on the review.
Automated checks
Ran Nov 16, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work
- Source repository linked and reachableltplus-ag/ifc-lite is public and reachablegithub.com/ltplus-ag/ifc-lite ↗Pass
- Package names this repository as its source@ifc-lite/mcp names ltplus-ag/ifc-lite as sourcenpmjs.com/package/@ifc-lite/mcp ↗Pass
- Build provenance (Sigstore attestation)Sigstore attestation for @ifc-lite/mcpnpmjs.com/package/@ifc-lite/mcp/v/0.29.0#provenance ↗Pass
- Open source license (OSI)MPL-2.0spdx.org/licenses/MPL-2.0.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-15github.com/ltplus-ag/ifc-lite ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNo popular package one edit away from @ifc-lite/mcpPass
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model125 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNo tool named like delete, drop or execPass
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubIFClite
Parse, view, query, edit, validate, and export IFC files, entirely client-side. A Rust core compiled to WASM does the parsing and geometry, a WebGPU renderer puts it on screen, and modular npm packages let you pick the pieces you need. Geometry runs on an exact-arithmetic CSG kernel, verified element-by-element against IfcOpenShell across the public benchmark corpus.
Works with IFC2X3, IFC4 / IFC4X3 and IFC5 (IFCX). Beside IFC, the web viewer opens glTF/GLB, LandXML, point clouds (LAS/LAZ, E57, PLY, PCD, PTS, XYZ) and Gaussian splat captures (Gaussian PLY, .splat). Live demo at ifclite.com and more info at ifclite.dev.
Get Started
For data automation, start with the headless SDK or CLI:
npm install @ifc-lite/sdk
import { readFile } from 'node:fs/promises';
import { openModel } from '@ifc-lite/sdk/headless';
const model = await openModel(await readFile('model.ifc'));
try {
if (model.report.completeness !== 'complete') throw new Error('Incomplete or unknown record coverage');
console.log(model.bim.query().byType('IfcDoor').count());
} finally {
model.close();
}
Developer workflows provides a reference model, runnable data/IDS/edit/export/geometry/service recipes, and expected results. For the terminal, run npx @ifc-lite/cli info model.ifc --json.
To scaffold a rendering integration:
npx create-ifc-lite my-viewer --template react
cd my-viewer && npm install && npm run dev
That gets you a working WebGPU IFC viewer with drag-and-drop loading and orbit/pan/zoom. Other templates: basic, threejs, babylonjs, server, server-native.
To add IFClite to an existing project:
npm install @ifc-lite/parser @ifc-lite/geometry @ifc-lite/renderer
Prefer the terminal? The whole toolkit is also a CLI:
npm install -g @ifc-lite/cli
ifc-lite info model.ifc
Parse an IFC file
import { IfcParser } from '@ifc-lite/parser';
const parser = new IfcParser();
const buffer = await fetch('model.ifc').then(r => r.arrayBuffer());
const t0 = performance.now();
const store = await parser.parseColumnar(buffer, {
onProgress: ({ phase, percent }) => console.log(`${phase}: ${percent}%`),
});
console.log(`${store.entityCount} entities, schema ${store.schemaVersion}`);
console.log(`Parsed in ${(performance.now() - t0).toFixed(0)}ms`);
View in 3D
import { IfcParser } from '@ifc-lite/parser';
import { GeometryProcessor } from '@ifc-lite/geometry';
import { Renderer } from '@ifc-lite/renderer';
const parser = new IfcParser();
const geometry = new GeometryProcessor();
const renderer = new Renderer(canvas);
await Promise.all([geometry.init(), renderer.init()]);
const arrayBuffer = await file.arrayBuffer();
const store = await parser.parseColumnar(arrayBuffer);
const meshes = [];
for await (const event of geometry.processAdaptive(new Uint8Array(arrayBuffer))) {
if (event.type === 'batch') meshes.push(...event.meshes);
}
renderer.loadGeometry(meshes);
renderer.requestRender();
// Pick an entity at (x, y) in canvas pixels
const hit = await renderer.pick(120, 240);
if (hit) console.log(`Picked expressId ${hit.expressId}`);
For Three.js or Babylon.js, parse and extract geometry the same way and feed meshes to your engine. See Three.js integration and Babylon.js integration.
Query entities
import { IfcQuery } from '@ifc-lite/query';
const query = new IfcQuery(store);
// All external load-bearing walls
const walls = query
.ofType('IfcWall', 'IfcWallStandardCase')
.whereProperty('Pset_WallCommon', 'IsExternal', '=', true)
.whereProperty('Pset_WallCommon', 'LoadBearing', '=', true)
.execute();
console.log(`${walls.length} external load-bearing walls`);
for (const wall of walls) {
console.log(wall.name, wall.globalId);
}
For more complex queries, use SQL via DuckDB-WASM:
const result = await query.sql(`
SELECT type, COUNT(*) AS n FROM entities GROUP BY type ORDER BY n DESC LIMIT 10
`);
console.table(result.rows);
Validate against IDS
import { parseIDS, validateIDS, createTranslationService } from '@ifc-lite/ids';
import { createDataAccessor } from '@ifc-lite/ids/bridge';
const idsSpec = parseIDS(idsXmlContent);
const accessor = createDataAccessor(store);
const modelInfo = {
modelId: 'my-model',
schemaVersion: store.schemaVersion,
entityCount: store.entityCount,
};
const translator = createTranslationService('en');
const report = await validateIDS(idsSpec, accessor, modelInfo, { translator });
for (const spec of report.specificationResults) {
console.log(`${spec.specification.name}: ${spec.passRate}% passed`);
}
Edit properties (with undo)
import { MutablePropertyView } from '@ifc-lite/mutations';
import { PropertyValueType } from '@ifc-lite/data';
const view = new MutablePropertyView(store.properties, 'my-model');
view.setProperty(
wallExpressId,
'Pset_WallCommon',
'FireRating',
'REI 120',
PropertyValueType.Label,
);
console.log(view.getMutations()); // change history for undo / export
Export
import { exportToStep, ParquetExporter, Ifc5Exporter } from '@ifc-lite/export';
import { GeometryProcessor } from '@ifc-lite/geometry';
// Assumes the earlier parse/geometry steps: `store` (parsed IfcDataStore),
// `bytes` (raw IFC Uint8Array), `meshes` + `geometryResult` (from geometry).
// IFC STEP, applies any pending mutations
const stepText = exportToStep(store, { schema: 'IFC4', applyMutations: true });
// glTF / GLB, CSV and JSON-LD are assembled in Rust (ifc-lite-export)
// via the GeometryProcessor
const gp = new GeometryProcessor();
await gp.init();
const glb = gp.exportGlbFromMeshes(meshes); // Uint8Array (no re-mesh)
const csv = gp.exportCsv(bytes, 'entities', ',', /* includeProperties */ true);
const jsonld = gp.exportJsonld(bytes);
// Parquet: columnar, queryable from DuckDB / Polars
const parquet = await new ParquetExporter(store).exportTable('entities');
// IFC5 / IFCX: JSON + USD geometry
const ifcx = new Ifc5Exporter(store, geometryResult).export({ includeGeometry: true });
Work from the terminal
The ifc-lite CLI covers the full toolkit: inspect, query, schedule, validate, export, create, diff, clash-check, merge, convert, and script IFC models without writing a line of app code.
ifc-lite info model.ifc # schema, entities, storeys
ifc-lite query model.ifc --type IfcWall --json # entities with properties
ifc-lite schedule model.ifc --preset door # door schedule, csv/json/md/html
ifc-lite ids model.ifc requirements.ids # IDS validation
ifc-lite clash model.ifc --matrix --bcf clashes.bcfzip # clash detection to BCF
ifc-lite diff model-v1.ifc model-v2.ifc # model comparison
ifc-lite merge arch.ifc struct.ifc mep.ifc --out fed.ifc # federation
ifc-lite convert model.ifc --schema IFC4 --out out.ifc # schema conversion
ifc-lite view model.ifc # 3D viewer + REST API
ifc-lite eval model.ifc "bim.query().byType('IfcWall').count()"
Building AI tooling? ifc-lite mcp model.ifc starts a Model Context Protocol server (stdio or HTTP) so agents can query and edit BIM data directly, and ifc-lite ask model.ifc "how many walls?" answers natural-language questions.
Choose your setup
| Setup | Best for | You get |
|---|---|---|
| Browser (WebGPU) | Viewing and inspecting models | Full-featured 3D viewer, runs entirely client-side |
| Three.js / Babylon.js | Adding IFC support to an existing 3D app | IFC parsing + geometry, rendered by your engine |
| CLI | Scripting, CI pipelines, AI agents | The whole toolkit from the terminal, JSON output everywhere |
| Server | Teams, large files, repeat access | Rust backend with caching, parallel processing, streaming |
| Build for Desktop | Your own offline native app, very large files (500 MB+) | Extension points to wrap the packages in Tauri, with an optional native-Rust geometry fast path |
| Python (native wheel) | Analysis, scripting, scientific Python | pip install ifclite-geom runs the geometry kernel in-process, meshes straight to numpy |
Not sure? Start with the browser setup. You can add a server or switch engines later.
Pick your packages
| I want to... | Packages |
|---|---|
| Parse an IFC file | @ifc-lite/parser |
| View a 3D model (WebGPU) | + @ifc-lite/geometry + @ifc-lite/renderer |
| Use Three.js or Babylon.js | + @ifc-lite/geometry (you handle the rendering) |
| Query properties and types | + @ifc-lite/query |
| Edit properties (with undo) | + @ifc-lite/mutations |
| Validate against IDS rules | + @ifc-lite/ids |
| Generate 2D drawings | + @ifc-lite/drawing-2d |
| Create IFC files from scratch | @ifc-lite/create |
| Export to glTF / IFC / Parquet | + @ifc-lite/export |
| Detect clashes | + @ifc-lite/clash |
| Diff two model versions | + @ifc-lite/diff |
| BCF topic tracking | + @ifc-lite/bcf |
| Filter and colorize in 3D by rules | + @ifc-lite/lens |
| Build schedules and property tables | + @ifc-lite/lists |
Script models with the bim.* API |
+ @ifc-lite/sdk |
| Real-time collaboration (CRDT on IFCX) | + @ifc-lite/collab + @ifc-lite/collab-server |
| Embed the viewer in any page (iframe) | + @ifc-lite/embed-sdk |
| Connect to a server backend | + @ifc-lite/server-client |
| Give AI agents BIM access (MCP) | + @ifc-lite/mcp |
Full list: API Reference (npm packages, Rust crates, and the ifclite-geom Python wheel).
Performance
- Streaming first render: geometry is processed in batches, so the first triangles are on screen while the rest of the file is still parsing.
- Geometry correctness: exact-arithmetic boolean kernel — every opening is cut exactly, and the output is verified element-by-element against IfcOpenShell (99.9%+ agreement on the public benchmark corpus). Engines with approximate booleans are faster on boolean-heavy models; that trade is deliberate.
- Geometry speed: native (server/CLI, multi-threaded) beats
web-ifcon most of the benchmark corpus; in the browser the viewer streams geometry across workers so the first triangles render long before the file finishes processing. - Parse speed: STEP tokenization runs at roughly 1.2 GB/s; a full parse lands around 50 MB/s.
- Schema coverage: 100% of IFC4 (776 entities) and IFC4X3 (876 entities).
- Footprint: one lazily fetched WASM module (~2.6 MB gzipped) plus small per-package JS wrappers.
See benchmarks for full numbers across model sizes and hardware.
Examples
Ready-to-run projects in examples/:
- Three.js Viewer - IFC viewer using Three.js (WebGL)
- Babylon.js Viewer - IFC viewer using Babylon.js (WebGL)
- Collab Demo - real-time collaborative editing over websockets
- Three.js Collab - collaborative 3D viewing in Three.js
Documentation
| Start here | Quick Start · Installation · CLI Toolkit · Browser Requirements |
| Guides | Parsing · Geometry · Rendering · Querying · Exporting |
| BIM features | Federation · Gaussian Captures · BCF · IDS Validation · 2D Drawings · Property Editing |
| Customization | Extensions · Authoring Extensions · Flavors |
| Tutorials | Build a Viewer · Three.js · Babylon.js · Custom Queries · Extending the Parser |
| Deep dives | Architecture · Data Flow · Performance |
| API | TypeScript · Rust · WASM · Python |
Contributing
The WASM bundle is built from rust/ on every fresh build, so a Rust
toolchain is required. rust-toolchain.toml pins the nightly channel
and the wasm32-unknown-unknown target. rustup show (or the
contributing setup guide) installs everything needed.
# 1. Rust toolchain (one-time)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
cargo install wasm-pack # or: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
# 2. Clone and build
git clone https://github.com/LTplus-AG/ifc-lite.git
cd ifc-lite
pnpm install && pnpm build && pnpm dev # opens viewer at localhost:3000
If you need IFC fixtures for tests, benchmarks, or stress tests, fetch them with:
pnpm fixtures # download every fixture (idempotent, hash-verified)
pnpm fixtures:check # CI-friendly: exit 1 if anything is missing or stale
The fixtures are stored on a GitHub Release and catalogued in
tests/models/manifest.json. See
tests/models/README.md for the full design and
maintainer workflow.
See the Contributing Guide and Release Process.
Community
- Discord - share apps and demos, ask integration questions, and meet other builders
- GitHub Discussions - questions, ideas, show-and-tell
- Issues - bug reports and feature requests
- Releases - changelog and version notes
License
MPL-2.0 - use, modify, redistribute. Source files modified under MPL must remain MPL.
IFClite MCP questions
How do I add IFClite MCP to Claude Code?
Run claude mcp add ifc-lite -- npx -y @ifc-lite/mcp in your terminal. Add --scope user to make it available in every project.
How do I add IFClite MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
What tools does IFClite MCP provide?
It exposes 125 tools, including model_info, model_list, model_load, model_unload, schema_describe.
Can I ask natural-language questions about my IFC model?
Yes, you can use the command ifc-lite ask model.ifc "question" to get answers to natural-language questions about the model.
What IFC versions does IFClite support?
The tool works with IFC2X3, IFC4 / IFC4X3, and IFC5 (IFCX).