Package Exports

@ifc-lite/wasm

Readme

IFC-Lite

High-performance browser-native IFC platform

Features • Quick Start • Documentation • Architecture • Performance • Contributing

Overview

IFC-Lite is a next-generation IFC (Industry Foundation Classes) platform built with Rust + WebAssembly for parsing, geometry processing, and WebGPU for 3D visualization. It's designed to be a 95x smaller and significantly faster alternative to existing web-based IFC solutions.

~86 KB total • 1.9x faster • 100% IFC4 schema

Features

Feature	Description
STEP/IFC Parsing	Zero-copy tokenization at ~1,259 MB/s with full IFC4 schema support (776 entities)
Streaming Pipeline	Progressive geometry processing - first triangles render in 300-500ms
WebGPU Rendering	Modern GPU-accelerated 3D visualization with depth testing and frustum culling
Columnar Storage	Memory-efficient TypedArray storage with 30% string deduplication
Zero-Copy GPU	Direct WASM memory binding to GPU buffers

Quick Start

Prerequisites

Node.js 18.0+ with pnpm 8.0+
Rust toolchain with wasm32-unknown-unknown target
Modern browser with WebGPU support (Chrome 113+, Edge 113+, Firefox 127+, Safari 18+)

Installation

# Clone the repository
git clone https://github.com/louistrue/ifc-lite.git
cd ifc-lite

# Install dependencies
pnpm install

# Build all packages
pnpm build

# Run the viewer
cd apps/viewer
pnpm dev

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
const walls = result.entities.filter(e => e.type === 'IFCWALL');
console.log(`Found ${walls.length} walls`);

// Render geometry
const renderer = new Renderer(canvas);
await renderer.loadGeometry(result.geometry);
renderer.render();

Documentation

Resource	Description
User Guide	Complete guide with tutorials and examples
API Reference	Rustdoc API documentation
Architecture	System design and data flow
Contributing	How to contribute to the project

Architecture

IFC files flow through three layers:

Parser (Rust/WASM) — Zero-copy STEP tokenizer, entity scanner, and geometry processor using nom, earcutr, and nalgebra.

Data (TypeScript) — Columnar TypedArrays for properties, CSR graph for relationships, GPU-ready geometry buffers.

Output — WebGPU renderer, Parquet analytics, glTF/JSON-LD/CSV export.

Project Structure

ifc-lite/
├── rust/                      # Rust/WASM backend
│   ├── core/                  # IFC/STEP parsing (~2,000 LOC)
│   ├── geometry/              # Geometry processing (~2,500 LOC)
│   └── wasm-bindings/         # JavaScript API (~800 LOC)
│
├── packages/                  # TypeScript packages
│   ├── parser/                # High-level IFC parser
│   ├── geometry/              # Geometry bridge (WASM)
│   ├── renderer/              # WebGPU rendering
│   ├── query/                 # Query system
│   ├── data/                  # Columnar data structures
│   ├── spatial/               # Spatial indexing
│   ├── export/                # Export formats
│   └── codegen/               # Schema generator
│
├── apps/
│   └── viewer/                # React web application
│
├── docs/                      # Documentation (MkDocs)
└── plan/                      # Technical specifications

Performance

Bundle Size Comparison

Library	Size	Gzipped
IFC-Lite	~86 KB	~28 KB
Traditional WASM	8+ MB	N/A
Reduction	93%	-

Parse Performance

Model Size	IFC-Lite	Notes
10 MB	~800ms	Small models
50 MB	~2.7s	Typical models
100+ MB	~5s+	Complex geometry

Geometry Processing

1.9x faster mesh extraction than traditional solutions
Streaming pipeline with batched processing (100 meshes/batch)
First triangles visible in 300-500ms

Browser Requirements

Browser	Minimum Version	WebGPU
Chrome	113+	✅
Edge	113+	✅
Firefox	127+	✅
Safari	18+	✅

Development

# Watch mode for all packages
pnpm -r dev

# Build specific package
cd packages/parser && pnpm build

# Run tests
pnpm test

# Build Rust/WASM
cd rust && cargo build --release --target wasm32-unknown-unknown

# Generate Rustdoc
cd rust && cargo doc --no-deps --open

# Build documentation site
cd docs && mkdocs serve

Packages

Package	Description	Status
`@ifc-lite/parser`	STEP tokenizer & entity extraction	✅ Stable
`@ifc-lite/geometry`	Geometry processing bridge	✅ Stable
`@ifc-lite/renderer`	WebGPU rendering pipeline	✅ Stable
`@ifc-lite/query`	Fluent & SQL query system	🚧 Beta
`@ifc-lite/data`	Columnar data structures	✅ Stable
`@ifc-lite/spatial`	Spatial indexing & culling	🚧 Beta
`@ifc-lite/export`	Export (glTF, Parquet, etc.)	🚧 Beta

Rust Crates

Crate	Description	Status
`ifc-lite-core`	STEP/IFC parsing	✅ Stable
`ifc-lite-geometry`	Mesh triangulation	✅ Stable
`ifc-lite-wasm`	WASM bindings	✅ Stable

Contributing

We welcome contributions! Please see our Contributing Guide for details.

# 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

# Submit a pull request

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

@ifc-lite/wasm