Design computation is the art and science of getting computers to propose design solutions; it is creative coding, augmenting the creative process with computational techniques to identify, abstract, and resolve complex design scenarios.

Design computation involves developing and deploying semantically rich models that mimic a designer's thinking as closely as possible. These dynamic models:

  1. enable a project-specific, interactive workflow (that follows the "rules" of a given design problem),
  2. automate the quantifiable aspects of the project, and
  3. serve as multipurpose toolsets, apart from commercially available (and often creatively restricting in a detrimental way) software packages.

Computational Models

The most useful definition I've employed for a "design model" is an "abstraction for a something, which is produced in a medium that one can control." The means of control is the operative fact. Without getting into too much detail about what may constitute a medium, I've found that once a designer has a basic understanding of a programming language like Processing, an encouraging thing happens. The language enables him/her to create interactive models and simulations that describe the inner workings of a design idea on its own terms (or at least much more closely to those terms), unfiltered through the predefined mechanisms of a prepackaged tool or physical medium.

The advantages of this approach are nearly limitless. Instead of moving a slider bar or clicking on a line as a means of controlling a 3D model and then interpreting the results visually, a designer can "write" a model that executes according to a set of rules, making the iteration process much more integrated and directed. The resulting model carries its own semantics outside of drawing, rendering, modeling software, or any other tool or medium.

This illustrates a very different thinking process. The designer negotiates with these rules, tweaks them, creates new ones, throws others away, generate results, and interact with them. Automation acts in place of executing a series of UI gestures manually to enforce these rules.

Not "Generative Design"

"Generative design" refers to a process of using software tools to produce multiple variations of a form (or producing a design from patterns) and then choosing among sufficiently differentiated results.

Design computation, however, offers a different approach. It is about using programming languages to describe the intricacies of design decisions as closely as possible to the language of the design problem. It's about extending beyond the limitations of commercial software by building project-specific models that closely mimic the semantics of a design idea. In this sense, design computation can enable and empower generative design, if a designer is willing to step out from behind popular software.

The Semantics of Tools

Consider a parametric software tool like Revit, a tool for building information modeling (BIM). The semantics of Revit are much closer to the semantics of buildings than drafting software, which speaks the semantics of drawing. It provides virtual objects (walls, columns, windows, etc.) that mimic the connectivity rules of building components familiar to architects, engineers, and contractors alike. For example, a wall can "host" an element, like a cornice line or a door.

But a design process typically doesn't operate in terms of walls, it's about decisions we make regarding the ideas that require walls to engender. Revit is a tool for creating 3-dimensional documentation for a construction project, but it is a poor design tool. A designer wants to think in terms of spatial hierarchies, means of expression, etc., not in terms of Revit's database fields.


With design computation, we have the opportunity to imbue our models with rules and behavior, express those models in terms of ideas, explore the possibilities they represent, interact with them, analyze the results, parameterize their rules, iterate, combine them with data sources and other systems, then deploy them as whole systems of architectures. This requires a designer to learn about programming and the power of programming languages to express design decisions, just as we typically deploy spoken language to relate them to each other. Ultimately, design computation is an approach for expression, interrogation, and exploration.