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.