Open-source · MPL-2.0 · Rust + WASM

# Parse, view, query, edit IFC. Right in the browser.

Open-source toolkit for the IFC file format. WebGPU rendering, columnar in-memory store, faster than the alternatives on most models. Runs from a CDN.

Read the API → Open the live demo
Schemas IFC2X3, IFC4, IFC4X3, IFC5
Bundle ~260 KB gzipped
Renderers WebGPU · Three.js · Babylon.js
terminal · ifclite scaffold
$ npx create-ifc-lite my-viewer --template react
✓ scaffolded my-viewer
✓ installed 7 packages · 6.2 MB
✓ wasm core ifc-lite-core@0.9.1 (Rust)
$ cd my-viewer && npm run dev
▲ ready on http://localhost:3000
drop an .ifc file anywhere on the canvas
# includes: drag-drop, hierarchy, properties, 2D drawings
2.72seconds
Parse + geometry, 68 MB office model, 11,123 products
260KB gzipped
Parser + geometry + renderer together
1,259MB/s
Tokenizer throughput on an M1 / M2 laptop
876entities
IFC2X3 through IFC4X3, plus IFC5 (IFCX)
21models
Benchmarked across IfcOpenShell, web-ifc, ifc-lite
§01 Pipeline

## One file. Seven moves.

Most browser IFC libraries stop at parsing or rendering. IFClite covers the whole pipeline. Read a STEP file, look at it, query it, edit it, federate it, validate it, automate it with an agent, and write it back out. Click a stage to try it.

§02 API

## Six packages. TypeScript-first. Async by default.

Each package composes with the rest. Progress events on the long-running calls. No globals. Tree-shakable, so you only pay for the parts you import.

§03 Setups

## Browser, server, or desktop.

Same core, four delivery modes. Start in the browser. Add a server when files get big or teams need caching. Ship a Tauri build when 500 MB models show up on a USB stick.

01 · Browser

### WebGPU viewer

Full client-side viewer. No backend, no upload, no shared state. The model never leaves the browser tab.

- Drag-and-drop, hierarchy, props
- 2D drawings & section planes
- Runs from a CDN
- Chrome / Edge / Firefox / Safari 18

→ Quick start
02 · Engine integration

### Three.js / Babylon.js

You already have a 3D app. IFClite parses, tessellates, and hands you meshes you can feed straight into your scene graph.

- WebGL, no WebGPU needed
- Express IDs preserved across meshes
- Instancing-friendly buffers
- Both engines, ready-made templates

→ Three.js tutorial
03 · Server

### Rust backend

Cache parsed models, stream geometry to many clients, dedupe by content hash. Built for teams and 100 MB+ files.

- Streaming parse + geometry
- Parallel processing
- Content-addressed cache
- Docker, Fly, Render-ready

→ Server guide
04 · Desktop

### Tauri app

Native binary for offline work and very large files. Multi-threaded geometry, direct filesystem access, fast-path desktop optimizations.

- 500 MB+ models handled smoothly
- Multi-threaded geometry
- Offline, air-gapped friendly
- macOS · Windows · Linux

→ Desktop guide
§04 Packages

## Pick what you need.

30+ TypeScript packages and 5 Rust crates. You rarely need all of them. Pick a preset, or tick the bits you want. The bundle estimate updates as you go.

§05 Performance

## Rust core, shipped as WASM.

Hot paths (tokenization, tessellation, federation) run in Rust, compiled to WebAssembly. Your code stays in TypeScript. Browser-shipped, but the math still goes through Rust.

§06 Support

## Schemas and browsers.

Most IFC libraries cover a subset of the schema. IFClite implements every IFC4 and IFC4X3 entity, plus the new IFC5 JSON format.

#### Schema coverage

IFC2X3 653 / 653
IFC4 776 / 776
IFC4X3 876 / 876
IFC5 (IFCX) preview

#### Browser support

WebGPU is required for the built-in renderer. The Three.js and Babylon.js integrations fall back to WebGL and work everywhere those engines do.

§07 Docs

## Guides, tutorials, references.

Organized by what you want to do, not by package. Start with a tutorial. Use a guide for a specific feature. Hit the API reference when you know what you need.

→ guide

### Quick start

Parse your first IFC file. Five minutes, one terminal, one model.

5 min · npm start here
→ tutorial

### Build a viewer

Step-by-step: a WebGPU viewer with picking, hierarchy, and property panel.

30 min · React tutorial
→ guide

### Querying data

Filters, SQL, joins across property sets. Find what you need without parsing twice.

15 min · SQL guide
→ guide

### IDS validation

Write a spec, run it against a model, generate a pass / fail report.

20 min · BCF guide
→ reference

### Architecture

How parsing, federation, and rendering are wired together end to end.

deep dive internals
→ reference

### API reference

Every type, every method, every default. TypeScript and Rust both covered.

30+ packages · 5 crates reference

## Try the demo, or scaffold a project locally.

Drop an .ifc file on ifclite.com to see it in the browser. Or run npx create-ifc-lite for a working WebGPU viewer locally.

Open ifclite.com → Read the docs GitHub →