Fast · Lightweight · Columnar · Browser-native

Features · Quick Start · Desktop App · Architecture · Server · Performance · Contributing

Overview

IFClite parses, processes, and renders IFC files in the browser using Rust + WebAssembly and WebGPU. Smaller and faster than the alternatives. Supports both IFC4 (STEP) and IFC5 (IFCX/JSON).

~650 KB WASM (~260 KB gzipped)  •  2.6x faster  •  IFC4X3 + IFC5 support

Features

Quick Start

Option 1: Create a New Project (Recommended)

Get started instantly without cloning the repo:

npx create-ifc-lite my-ifc-app
cd my-ifc-app
npm install && npm run parse

Or create a React viewer:

npx create-ifc-lite my-viewer --template react
cd my-viewer
npm install && npm run dev

Option 2: Install Packages Directly

Add IFClite to your existing project:

npm install @ifc-lite/parser

import { IfcParser } from '@ifc-lite/parser';

const parser = new IfcParser();
const result = await parser.parse(ifcBuffer);

console.log(`Found ${result.entityCount} entities`);

For full 3D rendering, add geometry and renderer packages:

npm install @ifc-lite/parser @ifc-lite/geometry @ifc-lite/renderer

Option 3: Rust/Cargo

For Rust projects:

cargo add ifc-lite-core

use ifc_lite_core::parse_ifc;

let result = parse_ifc(&ifc_bytes)?;
println!("Parsed {} entities", result.entities.len());

Option 4: Clone the Repo (Contributors)

For contributing or running the full demo app:

git clone https://github.com/louistrue/ifc-lite.git
cd ifc-lite
pnpm install
pnpm build    # Build all packages first
pnpm dev      # Start the viewer

Open http://localhost:5173 and load an IFC file.

Note: Requires Node.js 18+ and pnpm 8+. No Rust toolchain needed - WASM is pre-built.

Important: The pnpm build step is required before running pnpm dev because the viewer depends on local packages that need to be compiled first.

📖 Full Guide: See Installation for detailed setup options including troubleshooting.

Option 5: Desktop App (Tauri)

Run IFClite as a native desktop application with enhanced performance:

cd apps/desktop
pnpm install
pnpm dev          # Development mode
pnpm build        # Build for current platform

Build for specific platforms:

pnpm build:windows   # Windows (.exe, .msi)
pnpm build:macos     # macOS (.app, .dmg)
pnpm build:linux     # Linux (.deb, .AppImage)

Note: Requires Rust toolchain for building. See Tauri Prerequisites.

Basic Usage

import { IfcParser } from '@ifc-lite/parser';
import { Renderer } from '@ifc-lite/renderer';

// Parse IFC file
const parser = new IfcParser();
const result = await parser.parse(ifcArrayBuffer);

// Access entities (Map<expressId, IfcEntity>)
const walls = [...result.entities.values()].filter(e => e.type === 'IFCWALL');
console.log(`Found ${walls.length} walls`);

// Render geometry (requires @ifc-lite/renderer + @ifc-lite/geometry)
const renderer = new Renderer(canvas);
await renderer.init();
renderer.loadGeometry(meshData); // MeshData[] from geometry processing
renderer.render();

Documentation

Architecture

flowchart LR
    IFC[IFC/IFCX Files] --> Tokenize
    Tokenize --> Scan --> Decode
    Decode --> Tables[Columnar Tables]
    Decode --> Graph[Relationship Graph]
    Tables --> Federation[Multi-Model Federation]
    Federation --> Renderer[WebGPU Renderer]
    Federation --> Drawing2D[2D Drawings]
    Graph --> Export[glTF / Parquet / IFC]

    BCF[BCF File] --> Viewer
    IDS[IDS Rules] --> Validator[IDS Validator]
    Validator --> Viewer
    Renderer --> Viewer[Viewer App]

    style IFC fill:#6366f1,stroke:#312e81,color:#fff
    style Tokenize fill:#2563eb,stroke:#1e3a8a,color:#fff
    style Scan fill:#2563eb,stroke:#1e3a8a,color:#fff
    style Decode fill:#10b981,stroke:#064e3b,color:#fff
    style Tables fill:#f59e0b,stroke:#7c2d12,color:#fff
    style Graph fill:#f59e0b,stroke:#7c2d12,color:#fff
    style Federation fill:#f59e0b,stroke:#7c2d12,color:#fff
    style Renderer fill:#a855f7,stroke:#581c87,color:#fff
    style Drawing2D fill:#a855f7,stroke:#581c87,color:#fff
    style Export fill:#a855f7,stroke:#581c87,color:#fff
    style BCF fill:#ec4899,stroke:#831843,color:#fff
    style IDS fill:#ec4899,stroke:#831843,color:#fff
    style Validator fill:#ec4899,stroke:#831843,color:#fff
    style Viewer fill:#06b6d4,stroke:#164e63,color:#fff

IFC files flow through parsing, data storage, and rendering layers. Multiple models can be loaded simultaneously via federation. BCF and IDS provide collaboration and validation capabilities. See the Architecture Documentation for detailed diagrams.

Deep Dive: Data Flow · Parsing Pipeline · Geometry Pipeline · Rendering Pipeline · Federation

Server Paradigm

For production deployments, IFClite provides a Rust server that processes geometry and data model fully upfront, enabling instant loading for repeat visits. Unlike the client-side parser (which uses on-demand property extraction for responsiveness), the server computes everything in parallel and caches the complete result.

flowchart LR
    subgraph Client
        Upload[Upload IFC]
        Viewer[WebGPU Viewer]
    end

    subgraph Server
        Parse[Parse & Process]
        Cache[(Content Cache)]
    end

    Upload -->|hash check| Cache
    Cache -->|hit| Viewer
    Upload -->|miss| Parse
    Parse --> Cache
    Cache --> Viewer

    style Upload fill:#6366f1,stroke:#312e81,color:#fff
    style Parse fill:#10b981,stroke:#064e3b,color:#fff
    style Cache fill:#f59e0b,stroke:#7c2d12,color:#fff
    style Viewer fill:#a855f7,stroke:#581c87,color:#fff

Key Features

Data Flow

1. Cache-First: Client computes SHA-256 hash locally, checks server cache
2. Cache Hit: Geometry served directly from cache (skips upload entirely)
3. Cache Miss: File uploaded, processed in parallel, cached, then served
4. Streaming: Geometry batches streamed via SSE for progressive rendering

When to Use

# Run the server locally
cd apps/server && cargo run --release

# Or with Docker
docker run -p 3001:3001 ghcr.io/louistrue/ifc-lite-server

Project Structure

ifc-lite/
├── rust/                      # Rust/WASM backend
│   ├── core/                  # IFC/STEP parsing
│   ├── geometry/              # Geometry processing
│   └── wasm-bindings/         # JavaScript API
│
├── packages/                  # TypeScript packages (18)
│   ├── parser/                # High-level IFC parser
│   ├── ifcx/                  # IFC5 (IFCX) JSON parser
│   ├── geometry/              # Geometry bridge (WASM)
│   ├── renderer/              # WebGPU rendering
│   ├── data/                  # Columnar data structures
│   ├── spatial/               # Spatial indexing
│   ├── query/                 # Query system
│   ├── cache/                 # Binary cache format
│   ├── export/                # Export formats (glTF, Parquet)
│   ├── bcf/                   # BIM Collaboration Format
│   ├── ids/                   # IDS validation
│   ├── mutations/             # Property editing & change tracking
│   ├── drawing-2d/            # 2D drawings (sections, plans)
│   ├── codegen/               # EXPRESS schema generator
│   ├── wasm/                  # WASM bindings package
│   ├── server-client/         # Server SDK (caching, streaming)
│   ├── server-bin/            # Pre-built server binary
│   └── create-ifc-lite/       # Project scaffolding CLI
│
├── apps/
│   ├── viewer/                # React web application
│   ├── server/                # Rust HTTP server (Axum)
│   └── desktop/               # Tauri desktop application
│
└── docs/                      # Documentation (MkDocs)

Performance

Bundle Size Comparison

Parse Performance

Based on benchmark results across 67 IFC files.

Zero-Copy GPU Pipeline

• Zero-copy WASM to WebGPU: Direct memory access from WASM linear memory to GPU buffers
• 60-70% reduction in peak RAM usage
• 74% faster parse time with optimized data flow
• 40-50% faster geometry-to-GPU pipeline

Geometry Processing

• Up to 5x faster overall than web-ifc (median 2.18x, up to 104x on some files)
• Streaming pipeline with batched processing (100 meshes/batch)
• First triangles visible in 300-500ms

On-Demand Property Extraction (Client-Side)

When using @ifc-lite/parser directly in the browser:

• Properties and quantities are extracted lazily when accessed
• Initial parse skips expensive property table building
• Large files (100+ MB) stream geometry instantly while data loads in background
• CPU raycasting for picking in models with 500+ elements (no GPU buffer overhead)

See full benchmark data for per-file comparisons.

Viewer Loading Performance

End-to-end loading times measured with Playwright in headed Chrome (M1 MacBook Pro):

Architecture:

• Dedicated geometry worker: Large files (>50MB) use a Web Worker for geometry processing
• True parallelism: Geometry streams from worker while data model parses on main thread
• First batch < 1.5s: Users see geometry within 1-1.5 seconds, even for 327MB files
• Zero-copy transfer: ArrayBuffers transferred (not copied) between worker and main thread

Run benchmarks on your hardware:

pnpm --filter viewer build && pnpm test:benchmark:viewer

Results saved to tests/benchmark/benchmark-results/ with automatic regression detection.

Browser Requirements

More Info: See Browser Requirements for WebGPU feature detection and fallbacks.

Desktop App (Tauri)

IFClite includes a native desktop application built with Tauri v2, providing enhanced performance over the web version.

Why Desktop?

Architecture

The desktop app reuses the same Rust crates (ifc-lite-core, ifc-lite-geometry) as the WASM build, but compiled natively:

apps/desktop/
├── src/                    # React frontend (shared with web)
├── src-tauri/
│   ├── src/
│   │   ├── commands/       # Tauri IPC commands
│   │   │   ├── ifc.rs      # parse_ifc_buffer, get_geometry
│   │   │   ├── cache.rs    # Binary caching system
│   │   │   └── file_dialog.rs
│   │   └── lib.rs          # Tauri app setup
│   └── Cargo.toml          # Native dependencies
└── package.json

Native Commands

The desktop app exposes these Tauri commands to the frontend:

Building Releases

cd apps/desktop

# Development
pnpm dev

# Production builds
pnpm build              # Current platform
pnpm build:windows      # x86_64-pc-windows-msvc
pnpm build:macos        # universal-apple-darwin (Intel + Apple Silicon)
pnpm build:linux        # x86_64-unknown-linux-gnu

Output binaries are placed in apps/desktop/src-tauri/target/release/bundle/.

Development (Contributors)

For contributing to IFClite itself:

git clone https://github.com/louistrue/ifc-lite.git
cd ifc-lite
pnpm install

pnpm dev          # Start viewer in dev mode
pnpm build        # Build all packages
pnpm test         # Run tests

# Add a changeset when making changes
pnpm changeset    # Describe your changes (required for releases)

# Rust/WASM development (optional - WASM is pre-built)
cd rust && cargo build --release --target wasm32-unknown-unknown
bash scripts/build-wasm.sh  # Rebuild WASM after Rust changes

Packages

Rust Crates

Community Projects

Projects built by the community using IFClite (not officially maintained):

Built something with IFClite? Open a PR to add it here!

Contributing

We welcome contributions!

# Fork and clone
git clone https://github.com/YOUR_USERNAME/ifc-lite.git

# Create a branch
git checkout -b feature/my-feature

# Make changes and test
pnpm test

# Add a changeset to describe your changes
pnpm changeset

# Submit a pull request (include the changeset file)

License

This project is licensed under the Mozilla Public License 2.0.

Acknowledgments

• Built with nom for parsing
• earcutr for polygon triangulation
• nalgebra for linear algebra
• wasm-bindgen for Rust/JS interop

Made with ❤️ for the AEC industry