One codebase, everywhere
Every tool in the OpenAEC ecosystem is developed as a single application that runs on all platforms. No separate versions for web and desktop, no double maintenance. The same code, the same features, everywhere.
We achieve this by building on Tauri and Rust as the foundation, with a modern web frontend that runs both in the browser and in a native shell.
Architecture overview
Technology stack
Tauri 2.0 Core
Framework for building desktop and mobile apps with web technology. Uses the native webview of the OS instead of Chromium — resulting in small installation files (<10MB) and low memory usage.
Rust Backend
The core logic of every tool is written in Rust: IFC parsing, validation, calculations and file processing. Rust offers memory safety, high performance and compiles to every platform.
WebAssembly Web
The same Rust code compiles to WebAssembly (WASM) for the web version. This allows the full computation logic to also run in the browser, with near-native performance.
HTML / CSS / JS UI
The user interface is built with standard web technology. No heavy frameworks — lightweight, fast and maintainable. The same UI runs in Tauri and in the browser.
Three.js 3D
3D visualization of IFC models via Three.js and That Open Engine. WebGL-based, runs everywhere a browser runs.
FastAPI API
Server-side APIs built with Python FastAPI for async validation, document management and integrations. Deployed via Docker.
Local and in the cloud — one system
Every OpenAEC tool works standalone on your own machine, without an internet connection. But when you connect, everything synchronizes seamlessly with the cloud via the OpenAEC platform. Projects, documents and model data flow automatically between local installations and the server. You choose: fully local, fully in the cloud, or a hybrid setup.
Platform comparison
| Feature | Desktop (Tauri) | Web (Browser) | Mobile (Tauri) |
|---|---|---|---|
| Offline work | ✓ | Limited (PWA) | ✓ |
| File access | ✓ Full | Limited (upload) | ✓ |
| IFC processing | ✓ Native Rust | ✓ WASM | ✓ Native Rust |
| 3D Viewer | ✓ | ✓ | ✓ |
| Installation size | <10 MB | 0 MB | <15 MB |
| Auto-update | ✓ | Always current | ✓ |
| Camera access | — | ✓ | ✓ |
| System integration | ✓ Full | Limited | ✓ |
Extensibility & integration
Every tool in the ecosystem is designed to be extended and integrated. Four layers of extensibility:
Open Feedback Studio Feedback
Built-in feedback system in every tool. Users can provide feedback, report bugs and submit feature requests directly from the application. Connected to the central platform.
REST API API
Every tool offers a REST API for integration with external systems. Automate workflows, connect with ERP systems or build your own dashboards on top of the ecosystem.
MCP Servers AI
Model Context Protocol (MCP) servers for every tool. This allows AI agents (like Claude) to communicate directly with the tools — validate models, generate documents or perform calculations via natural language.
Extensions Plugins
Every tool supports extensions for custom functionality. Build your own plugins in TypeScript or Rust and share them with the community via the extension registry.
Building on existing open source projects
We don't reinvent the wheel. The OpenAEC ecosystem builds as much as possible on proven open source projects from the BIM and 3D world:
That Open Engine
The 3D rendering and IFC parsing in our viewers is based on That Open Engine (formerly IFC.js). A powerful TypeScript/Three.js library for BIM in the browser.
Blender & Bonsai
For 3D modeling and BIM authoring we integrate with Blender and the Bonsai add-on (formerly BlenderBIM). The most powerful open source 3D tool in the world.
IfcOpenShell
The industry-standard Python/C++ library for reading, writing and manipulating IFC files. The backbone of our server-side IFC processing.
PDF.js & pdf-lib
Mozilla's PDF.js for rendering and pdf-lib for programmatically creating and editing PDF documents. Proven technology, millions of users.
Why this approach?
Small & fast
No Electron, no Chromium. Tauri uses the native webview — installation files are smaller than 10MB and memory usage is minimal.
Secure
Rust prevents memory errors, buffer overflows and race conditions. The application is secure by design.
Open source
Tauri, Rust, and all libraries used are open source. No vendor lock-in at framework level.
Future-proof
Web standards and Rust are technologies with long lifespans. No framework churn, no breaking changes.