Branch Concept extends Branch Concept Lite to provide a full-featured structural concept design tool usable to deliver real buildings. It offers a dramatically expanded design space, a novel modeling system that meshes smart parametric generation with individual manual refinements; detailed structural calculations and sizing using finite-element analysis with introspection into every structural member and decision; automatic 2D drawing generation; and comparison tools to evaluate across design alternatives; and novel AI features that let users not only have agents manipulate their design, but also use agent-generated code to extend the tool itself.

I currently lead the development team. The stack extends beyond Typescript to include WebGPU for high-performance local analysis, and maintains a simple Postgres backend for user authentication and design sharing -- but the core still aims to be a snappy, local-first app. The project is currently in private alpha with a small group of architects and engineers.

Branch Concept Lite re-envisions what concept-stage structural design can be. The concept design stage is where the highest-leverage decisions get made on a building project, but architects are often flying blind. Branch Concept Lite provides high-level structural feedback instantly -- you can push and pull on faces of your building and it will regenerate structural framing, recompute optimal structural sizing, and estimate embodied carbon instantly. While the building is an approximation, the tool provides a number of features to dive in deeper: you can and position individual gridlines, understand structural validity for individual members and bays, and dive in to each individual carbon statistic and understand the levers behind the embodied carbon given your design.

While on the Branch team, I was the architect and lead developer behind the app. I implemented all of the 3D geometry, interactions, structural computation, and carbon system in a 2.5 month spike to validate our product thesis for Branch Concept. Written in pure Typescript using React Three Fiber, the app runs entirely client-side and local-first: the only feature that uses or needs a server is the ability to share designs between users. The project contained a number of interesting challenges necessitates by its performance and graphical polish goals --- fast rendering of dynamically-changing geometry, transparent rendering, real-time dynamic outlines and soft-shadows, and a custom action system on top of React Three Fiber's events. Branch Concept Lite is entirely free, no login required, and maintains a small but loyal following of architects and engineers who, despite its approximate nature, use it to inform real-world design direction.

Branch Detailing came from StructureCraft's need to scale their mass-timber fabrication detailing process. StructureCraft operates under a unique, vertically-integrated engineer-build model, where they'll both design and fabricate mass-timber buildings. This allows for optimized designs that make optimal use of mass-timber products, leading to beautiful and efficient structures. In order to make that a reality, they need high-fidelity building models, down to the individual fastener and countersink, to be able to generate fabrication-ready drawings and CNC files.

Branch Detailing is written in C# as a plug-in into Rhino. During my time at StructureCraft, I was the technical lead on the team and contributed major components to its development, including interactive manipulation of dynamically-generated Rhino geometry; a custom undo/redo system responding to Rhino's native interactions; algorithms for identifying and auditing differences between unique building components; dynamic blocks that allow parametric, reactive relationships to other elements; a high-performance graphics pipeline, and query language for filtering and selecting modeled elements. Branch Detailing is now used to generate fabrication models for all of StructureCraft's fabrication projects, and has been used to detail over 1M+ square feet of mass-timber construction.

Referring to elements in a parametric CAD model is a fundamental primitive that allows designs to be expressed concisely. Existing parametric tools allow users to click an element (point, edge, or shape), and when model parameters change, use heuristics to determine which element that refers to. While this can work, it is error-prone and breaks in surprising and subtle ways, making it difficult to define a design space to explore.

This project introduces a referencing system for identifying elements based on the concept of lineage, a constructed graph of themodel's computational history. The lineage graph can be queried to identify elements in a way that is robust to both parameter and program edits. This makes the fundamental selection primitive user-defined, robust, and introspectable; bringing us a step closer to being able to realize the dream of interleaving manual and parametric modeling.

This system is implemented in Scala, using Scala.js to compile it to the web. Check out a live demo of the language creating parametric models in the browser as well as documentation of the language and API.

Manipulating parametric CAD programs purely by their parameters can be an arduous ordeal. On models with many parameters, it is difficult to tell what effect a parameter change will have on the geometric output, and to express design intent in terms of a model's parameters.

This project offers a bidirectional interface, where users can drag vertices on the geometry, and the model's parameters will update such that the vertex appears in the specified location. As a result, users can interchangably interact with both the generated geometry and underlying program, using whichever representation is more convenient for a given edit.

Under the hood, the project performs a series of optimizations according to different heuristics -- after all, while it is clear where the target vertices should go, there might be many ways to get there, or none. In these cases we aim to get as close as possible, offering a range of possible model alternatives for the user to select between in a rapid iteration loop. We are able to solve the optimizations quickly and at scale by providing a domain-specific language for CAD that is limited to operations that can be automatically differentiated. This takes the form of a plugin for Blender that exposes a scripting interface inline.

Grasshopper3D is a visual programming language for creating parametric models embedded in the CAD platform Rhino3D. It works as a directed graph of components, each performing an operation, that send trees of data along edges to trigger recomputation.

Impala dramatically improves the performance of Grasshopper on models that handle large amounts of data. At its core, it provides a reimplementation of standard components to run in parallel as a drop-in replacement to the Grasshopper standard library. Impala is excellent for processing point clouds, landscape data, and physical simulations.

Impala combines this strategy with a few key insights to maximize performance:

• Minimize allocation overhead. Impala re-implements the basic data tree structure. This allows space to be preallocated, trees to be filled in parallel, and a compact encoding of tree paths.
• Restrict type-casts. Impala assumes a homogenous type of data in a tree, as is nearly always the case in practice. This prevents copies and allows type conversions to happen much more quickly for large data trees.
• Algorithmic optimization. Impala replaces some quadratic implementations in the standard library with custom strategies that have improved parallel complexity.

Drop-in replacement of existing components with Impala variants yielded speedups of 10-20x relative to the base Grasshopper implementation, on a mix of standard and randomly-generated workloads. Greater speedups are seen in adversarial cases, or where several Impala components can be chained together. Additionally, using Impala can significantly reduce the memory overhead of a Grasshopper script, resulting in smoother overall interactions.

Rendered view of full-resolution geometry generated by the Facade Painter (above). Under the supervision of Nate Holland.

In the design computation team at NBBJ, we worked on solutions to aid the design and modeling process of building facades, which are often complex and unwieldy to manipulate and iterate on in existing building information modeling pipelines. Our solution allowed users to model a module or a set of pattern modules responsively with constraints in Rhino3D and pattern them adaptively and parameterically using Grasshopper3D. After the initial design is set, further work exports the geometry and parameters to a higher-detail format for processing in Autodesk Revit.

In this work, the designer is able to quickly insert and remove constraints, and constraints are responsive and flexible to user editing. Our custom implementation allows users to model flexibly and quickly, and immediately see the impact of their changes at a building level in an interactive tool.

In practice, this tool was able to save tens of hours on each project in the early design phase for teams iterating quickly on facade curtain wall design compared to modeling traditionally or within Revit directly. This work was presented and demonstrated in an industry talk at Autodesk University 2018.