Open-Source AEC Design Repositories for Architects
Popular Open-Source AEC Design Repositories
Below are 10 widely-used open-source GitHub repositories in the Architecture, Engineering, and Construction (AEC) industry. Each is known for strong community support (high star counts or active development) and ties into architectural design, BIM, parametric or generative modeling on popular platforms.
FreeCAD (FreeCAD/FreeCAD)
Description: FreeCAD is a free, open-source multiplatform 3D parametric modeler. It offers a modular architecture with workbenches for different domains – including an Arch Workbench for Building Information Modeling (BIM). Architects and engineers use FreeCAD to create and modify geometry parametrically and export designs to standard formats. Its community provides many add-ons for architecture, structural analysis, and more.
Key Features:
• Parametric BIM Modeling: Supports fully parametric design, allowing changes to any part of the model to update dependent components automatically. The Arch workbench enables creating building elements (walls, windows, etc.) and exporting IFC for open BIM workflows.
• Cross-Platform & GUI: Runs on Windows, macOS, and Linux with a flexible GUI. Its open architecture lets users customize the interface or use Python scripting to automate tasks.
• Extensibility: A rich ecosystem of addons (e.g., BIM Workbench, Reinforcement, GIS integration) extend FreeCAD’s capabilities. Users can import/export industry-standard formats like DWG, DXF, STEP, IFC, OBJ, and more.
• OpenCASCADE Kernel: Built on the OpenCASCADE geometry kernel, providing robust 3D CAD operations (NURBS surfaces, Booleans, etc.) similar to commercial CAD, but in an open environment.
Dynamo (DynamoDS/Dynamo)
Description: Dynamo is an open-source visual programming platform for computational design and BIM. Originally created for Autodesk Revit, it provides a node-based editor to build algorithms that generate geometry or automate tasks. Dynamo’s accessible interface lets architects and non-programmers create scripts by connecting nodes instead of writing code. It’s widely used for parametric modeling, generative design explorations, and automating repetitive BIM workflows in tools like Revit.
Key Features:
• Visual Scripting Interface: Intuitive drag-and-drop node interface to construct logic graphically. Users can create complex geometry, data processing, or automation routines without traditional coding.
• BIM Integration: Deep integration with Revit (via DynamoRevit) enables creating and modifying Revit elements through graphs. Dynamo can read/write building parameters, place components, and process BIM data dynamically.
• Extensible and Open: Being open-source, it has a large library of community-contributed packages (for math, geometry, analysis, etc.). It supports custom node development in Python, C#, or zero-touch libraries, extending its functionality with new algorithms.
• Generative Design: Often used for exploring design options by algorithmically varying parameters. With nodes for optimization or randomization, Dynamo allows generative design studies (e.g., facade patterns, space layouts) while evaluating performance criteria.
pyRevit (pyrevitlabs/pyRevit)
Description: pyRevit is a rapid application development (RAD) environment for Autodesk Revit that lets users automate and extend Revit using IronPython or CPython scripting. It installs as an additional tab in Revit, providing a suite of ready-made tools and a framework to develop custom add-ins quickly. Architects and BIM specialists use pyRevit to speed up tedious tasks, create custom commands, and prototype new Revit functionality without C# coding.
Key Features:
• In-Revit Scripting: Allows writing Python scripts that run directly inside Revit’s UI, leveraging Revit API to manipulate models. This lowers the barrier for automating Revit compared to compiled add-ins.
• Built-in Toolset: Comes with an extensive set of pre-built tools (for selection filtering, sheet management, dimensioning, etc.) that showcase what’s possible and provide immediate productivity gains.
• Multi-Language Support: Although focused on Python, it supports creating Revit add-ons in any .NET language (C#, VB.NET) as well. This flexibility means teams can prototype in Python and later port to C# if needed.
• Deployment & Management: Includes a CLI for configuring and deploying custom scripts in a team environment. Firms can share a common pyRevit extension bundle, ensuring all team members have access to the same tools. It also provides telemetry to monitor tool usage across projects.
RevitLookup (jeremytammik/RevitLookup)
Description: RevitLookup is an interactive BIM database exploration tool for Revit. It allows users to inspect the data of any Revit model element – parameters, properties, relationships – in real-time. Essentially a Revit add-in, it opens a window that developers or advanced users can use to navigate the entire Revit object model of a project. This makes it invaluable for troubleshooting, learning the Revit API structure, or verifying BIM data in a model.
Key Features:
• Model Data Inspection: With a simple click, users can drill into any selected object’s properties and parameters. For example, you can pick a wall and see all its parameter values, related elements, geometry objects, etc., which helps in understanding and debugging BIM data.
• Relationship Navigation: The tool lets you traverse relationships – e.g., from a Wall to the Room it bounds, or to the elements hosted in it – revealing how components connect in the Revit database.
• Developer Aid: Favored by Revit API developers, since it exposes class names and property names exactly as the API sees them. This makes writing automation or add-ins easier (you can prototype in RevitLookup to find the data you need).
• Lightweight & Essential: The add-in is lightweight and read-only (it doesn’t modify the model). Its “look but don’t touch” approach makes it a safe tool for anyone – from BIM managers validating data, to programmers understanding Revit internals – and is often considered an essential utility in a Revit power-user’s toolkit.
Ladybug Tools – Environmental Analysis Suite (ladybug-tools on GitHub)
Description: Ladybug Tools is a collection of free, open-source applications that connect 3D CAD modeling to environmental simulation engines. Primarily known as plugins for Rhino/Grasshopper (and recently a core Python library set), Ladybug Tools enable architects and engineers to perform climate analysis, daylight and energy modeling, and building environmental performance studies within their design workflow. The suite includes Ladybug (climate data visualization), Honeybee (energy/daylight simulation interface), Butterfly (CFD via OpenFOAM), among others.
Key Features:
• Climate & Site Analysis: Ladybug imports standard EnergyPlus Weather (EPW) files and provides graphical analysis of climate data (sun paths, radiation rose, wind roses, etc.) directly in the design model. This helps architects make climate-responsive design decisions early on.
• Daylight & Energy Simulation: Through Honeybee, it integrates validated engines like Radiance for daylight and EnergyPlus/OpenStudio for energy simulation. Users can set up simulations (lighting, solar studies, thermal comfort, HVAC energy) in a visual programming environment without hand-coding the simulation inputs.
• Grasshopper and Revit Integration: The tools run inside popular design platforms (originally Grasshopper for Rhino). They provide parametric components so designers can iteratively test performance (e.g., how adjusting a façade shading affects energy use). New integrations also bring Ladybug Tools capabilities to Revit and other apps via the Pollination platform.
• Open-Source Community: Ladybug Tools is completely open-source and heavily community-driven. Its users worldwide contribute to its development and share workflows on the forum. It stands out for uniting many simulation engines under one interface, with consistent data exchange between them.
Speckle (specklesystems/speckle-server)
Description: Speckle is an open-source AEC data platform (“data hub”) that enables real-time collaboration and interoperability between many design tools. It provides an object-based approach to BIM data: instead of exchanging files, Speckle lets you send/receive granular objects (geometry, parameters, etc.) between software like Revit, Rhino, Grasshopper, AutoCAD, Blender, Excel, and more. With a cloud server backend, version control, and web viewer, Speckle is essentially a GitHub for BIM/model data, streamlining how teams share and iterate on models.
Key Features:
• Multi-Platform Connectors: Speckle offers plug-ins (“connectors”) for over a dozen AEC applications (Revit, Rhino, Grasshopper, Blender, Unity, QGIS, etc.). This allows pushing and pulling data between different tools seamlessly – for example, sending a Rhino concept model into Revit as native walls and floors, or exporting structural data from Revit to Excel.
• Versioned BIM Data: It treats BIM and geometry data like code, with commits and branches. Every data transfer (to the Speckle server) creates a version that can be reviewed or reverted. Teams can collaboratively develop design options or track changes over time, bringing software-style version control to design models.
• Web Viewer & API: Shared models can be viewed in 3D in a web browser, with the ability to filter and inspect object attributes. A GraphQL API allows developers to query model data or integrate Speckle into custom workflows. This opens up possibilities for web-based model dashboards or connecting to analysis tools.
• Automation and Collaboration: By eliminating manual import/export, Speckle enables automated workflows (CI/CD for BIM) – for instance, triggering analysis whenever a model is updated. It also facilitates collaboration: multiple contributors can send updates to a central stream, and notifications keep the team in sync with design changes in real-time.
IfcOpenShell (IfcOpenShell/IfcOpenShell)
Description: IfcOpenShell is an open-source toolkit and geometry engine for Building Information Modeling based on the IFC (Industry Foundation Classes) standard. It allows developers to read, write, and modify IFC files – the open, neutral data format for BIM – through an easy-to-use API. IfcOpenShell is the backbone of many open BIM solutions: it powers the BlenderBIM add-on (bringing IFC-based BIM authoring to Blender) and other tools in the OpenBIM community. By providing robust IFC parsing and geometry generation, it enables a true open-source BIM workflow outside of proprietary software.
Key Features:
• IFC Parsing & Writing: Comprehensive support for the IFC schema (IFC2x3, IFC4, etc.) and serialization formats (STEP, XML, JSON). This means it can import an IFC file, give programmatic access to all its building elements and properties, and export modified or new IFC files – crucial for OpenBIM data interoperability.
• Geometry Engine: IfcOpenShell includes a geometry kernel to convert IFC’s parametric shapes into explicit geometry (meshes, breps) for visualization or collision detection. It can generate 3D geometry for all building elements, enabling rendering or analysis of models in any custom application.
• API for BIM Automation: Provides high-level Python and C++ APIs to query and manipulate BIM data. Developers can perform tasks like copying elements between models, modifying object attributes, running clash detection, or generating 2D plan drawings from the model with just a few calls.
• Ecosystem & Integration: As a core library, it’s integrated into multiple projects. The BlenderBIM Add-on uses IfcOpenShell to let users natively author and edit IFC models in Blender. There are also utilities for Revit (IFC importer improvements) and viewers built on it. Its development is community-driven with many contributors, ensuring it stays updated to support new IFC developments.
xBIM Toolkit (xBimTeam/XbimEssentials)
Description: The xBIM Toolkit is an open-source software development kit (SDK) for BIM that is oriented to .NET developers. It provides a set of libraries to work with BuildingSmart IFC data – reading, creating, validating, and visualizing building models. XbimEssentials is the core .NET library for IFC, and additional packages (XbimGeometry, XbimWebUI, etc.) offer geometry processing and viewer components. Many BIM applications and research projects use xBIM as a foundation for working with IFC on the Windows/.NET platform.
Key Features:
• IFC File Read/Write: XbimEssentials allows .NET programs to easily load IFC files into memory and navigate their contents or create new IFC building elements from scratch. It fully supports both IFC2x3 and IFC4 schemas, ensuring compatibility with models from various BIM tools.
• Geometry Generation: The XbimGeometry component uses a C++ geometry engine to generate 3D geometry from the IFC data. Developers can obtain meshes/BRep of building elements for visualization or spatial analysis. It supports boolean operations and other geometric computations on the IFC shapes.
• Viewing and GUI Components: Xbim provides ready-made controls for viewing BIM models. XbimXplorer (Windows WPF-based viewer) and XbimWebUI (WebGL/Three.js based viewer) let you embed model viewers in desktop or web applications. This accelerates development of custom BIM apps by reusing these visualization components.
• Data Interrogation and Conversion: Includes APIs for querying model data (spatial hierarchies, relationships) and even converting to other formats. For example, it supports mapping IFC to COBie (Construction Operations Building information exchange) spreadsheets. Validation tools (IDS validation) help ensure data quality. Overall, xBIM acts as a robust bridge between raw IFC data and functional BIM software solutions.
IFC.js (IFC for Web/Three.js – IFCjs/web-ifc)
Description: IFC.js is a JavaScript toolkit that brings IFC-based BIM data into web environments. It includes web-ifc, a high-performance WASM library for reading/writing IFC, and web-ifc-three, an IFC loader for Three.js. With IFC.js, developers can build browser-based BIM viewers and tools that parse large IFC models directly in the client, allowing interactive exploration of BIM data online. It’s become popular for lightweight web BIM viewers, coordination tools, or embedding BIM data in web apps without needing server-side conversion.
Key Features:
• Three.js IFC Loader: IFC.js provides the official Three.js IFCLoader, enabling direct import of IFC models into Three.js scenes. It translates IFC geometry and properties into Three.js meshes and metadata, both in-browser and in Node.js. This allows web apps to display BIM models with controls for orbit, pan, zoom, etc., entirely client-side.
• Efficient Geometry & Queries: The library focuses on efficiency – it creates geometries in a format optimized for rendering, and provides methods to query and filter the model content on the fly. Features like spatial tree filtering, element selection/highlighting, section cuts, and property retrieval are supported, making it possible to interact with the BIM data (hide/isolate objects, view attributes) in real time.
• Web-Based BIM Tools: Using IFC.js, developers have built web BIM viewers that require no plugins and can handle reasonably large models. It’s often used to create issue trackers, model reviewers, or simple BIM authoring prototypes in the browser. Being open-source, it is a cornerstone of the emerging OpenBIM in Web movement.
• Active Development: The project (part of “That Open” initiative) is active and evolving. Recent developments include modular IFC.js Components (a new, more modular approach) and support for editing or writing IFC in the browser. This opens the door to fully online BIM coordination workflows without proprietary software.
COMPAS (compas-dev/compas)
Description: COMPAS is an open-source, Python-based computational framework designed for research and collaboration in architecture, engineering, fabrication, and construction. Developed by the computational design community (primarily ETH Zurich’s Block Research Group), COMPAS provides a common toolkit for geometry processing, structural analysis, robotic fabrication, and other architectural tech applications. It consists of a core library and various extension modules (for example, compas_fea for finite element analysis, compas_ghpython for Grasshopper integration, etc.), enabling advanced parametric and generative workflows in a flexible, code-based environment.
Key Features:
• Versatile Core Library: The core compas library provides data structures for representing geometry (points, curves, meshes, networks) and a variety of algorithms (for transformations, intersections, topology, etc.) in pure Python. This gives researchers a foundation to quickly implement and test new computational design ideas.
• Extensions to Industry Tools: COMPAS is designed to work across many environments. It has dedicated packages to interface with Rhino/Grasshopper, Blender, and even robot controllers. For instance, one can script complex form-finding in Python and visualize results live in Rhino, or plan robotic fabrication sequences with COMPAS and execute them on real machines.
• Analysis and Simulation: Through extensions, COMPAS connects to powerful engines: e.g., compas_fea links to FEA software like Abaqus or ANSYS, allowing structural optimization; compas_singular provides tools for discrete differential geometry; and more. This makes advanced analysis techniques accessible in a single integrated framework.
• Collaborative & Research-Oriented: Born in academia, COMPAS emphasizes transparency and reproducibility. It’s used to teach computational design, and its open-source nature means researchers around the world contribute improvements. It facilitates collaboration by providing a common language (Python) and platform where architects and engineers can share algorithms and workflows for complex design problems.