The DynaSpace package is developed by Long Nguyen from the Institute for Computational Design and Construction in collaboration with Mohammad Rahmani Asl from the Autodesk Generative Design Group for AEC. As always, please let us know if you have any feedback or suggestions on the public Github repo.


Space planning in Dynamo with DynaSpace

Space planning is a complex process in architectural and urban design. Almost always, the architect has to work with multiple, often-conflicting, requirements about the individual spaces and their inter-relationships. The solution is usually some sort of a compromise where the architect tries to satisfy these requirements as much as possible based on the complexity of the problem, intuition and available time budget. Typically, there is no single perfect answer and it is often desirable to explore at least a few different alternatives to approach a desired design.

During the preliminary design phase, architects often use bubble diagrams to sketch up possible variations of solution scheme for a space planning problem. Figure 1 shows an example of a bubble diagram. In a bubble diagram, each space (e.g. meeting room, lobby, office, toilet, etc…) is represented by rough circles/ellipses (a.k.a “bubble”). The size of each bubble is roughly proportional to the required area of the space. Adjacency requirements (as well as separation requirements) between pairs of spaces or group of spaces are often solved using intuition and rule of thumbs. It is not hard to see that as the number of spaces and constraints increase, it becomes increasingly unwieldy for the architect to intuitively figure out a reasonable or an optimal solution. Moreover, it is also harder to alter an existing solution in order to generate a few more alternative schemes (e.g. “what if I move the meeting room here? What other rooms will be directly and indirectly affected by this change”).

Figure 1. Space planning using hand-drawn space bubble diagram

To augment this process with computational design power, we have been working on an experimental tool for Dynamo that we call DynaSpace. Currently a work-in-progress project, DynaSpace borrows ideas from the bubble diagram and combines it with the geometric constraint solving algorithms (from the DynaShape package) to enforce and optimize for the requirements regarding the space entities and their inter-relationships.

To better illustrate the process and give more details, let’s consider an example of space planning problem as shown in Figure 2a. The goal here is to arrange 10 spaces (e.g. meeting room, toilets, office rooms, etc…)  within the given site boundary. Each space is represented by a circle (i.e. “bubble”) with a known area size. Additionally, each space belongs to one of the three “departments” (colored as red, green and blue departments). We wish to find an arrangement of these bubbles that satisfies the following requirement as much as possible.

  • The space bubbles should avoid overlapping with each other and should lie within the boundary polygons (Figure 2b)
  • The space bubbles within the same department (same color) should try to stay close together (Figure 2c)
  • If there is an adjacency requirement between any two spaces, then the two bubbles should try to stay close together (Figure 2d)

Figure 2. Space planning using bubble diagram and constraint-based optimization based on dynamic relaxation

In order to understand how DynaSpace works, let’s consider a more complicated scenario where we need to arrange 31 spaces in a medical clinic based on the requirements provided in the following table. Each space has an ID numbers, which allows us to succinctly specify the desired adjacency relationship between them. For example, in the table in figure 3, let’s consider the space 4 (named “Workstation Reception”). This space required to be located close to the spaces 0 and 6 (“Patient Visitor Lounge Waiting Area” and the “Entrance Vestibule”). Notice that the adjacency relationship is automatically assumed to be symmetric, so if space 4 needs to be adjacent to space 0, then the algorithm in DynaSpace will automatically assumes that space 0 needs to be adjacent to space 4 as well, even when not explicitly specified in the table.

Table 1: Space planning requirements for a clinic

The video below will give you an idea of how DynaSpace attempts to arrange the spaces according to the requirements and constraints. At any time, we can “nudge” a particular space and move it to some other location at will, and the other spaces will react accordingly as the algorithm tries to keep the all requirements and constraints satisfied as much as possible.

DynaSpace Package

Download package here and examples here.

Note that the package is actually named DynaShape, as DynaSpace is currently implemented as part of the DynaShape package (we might make DynaSpace into an independent package in the future)


  • Dynamo 2.1 or higher
  • MeshToolkit package (can be found and installed using the Package Manager)
  • If you have any other version of DynaShape package installed in your Dynamo, you have to temporarily remove it to avoid conflict.

Now you are ready to have a look at the example dyn script. Open the DynaSpace_Example.dyn file. Make sure that the path to the .csv file is correct (figure 4). If it is not, then you will need to set it to the correct path.

Figure 4. Check if the .csv file is correctly located

Go to the Engine.Execute node (figure 5). This is the node that we will use to run the DynaSpace engine.

Figure 5. The Engine.Execute node

Set the Reset boolean node to True. This will initialize the DynaSpace engine using space specification from the .csv file.

After that, set Reset to False, and set Execute to True. You will see the space bubbles appear and iteratively move to their “desired” location.

With the Enable Manipulation boolean set to True, you can go to the background viewport mode and manipulate any space circle by click-hold its center and drag it around, you will see that the other space circles will automatically react to this manipulation in order to enforce and maintain spatial inter-relationships

If you want to run the Engine.Execute node again, set Reset to True to reinitialize the engine, then set Reset to False, and Execute to True.

Please note that the colorful looking geometries that being displayed in the viewport are a special kind of live preview geometries. There are no Dynamo geometry objects being actually generated at the moment.

Once you are satisfied with the result, you can set the Execute boolean to False. This will “pause” the DynaShape engine (e.g. the space bubbles will stop moving and reacting to the mouse manipulation), and the Engine.Execute node will output actual Dynamo geometries in black color (figure 6).

Figure 6. Getting actual Dynamo geometry objects by setting Execute to False

Advanced settings

To improve the result, you might want to tweak the advanced settings parameters shown in figure 7.

Figure 7. Advance Setting Parameters

  • Boundary Strength: Control the degree to which the space bubbles should respect the site boundary and not cross over it (Note: in this early DynaSpace version, the boundary polygon MUST be a convex polygon)
  • Planar Constraint Strength: Control the degree to which the space bubbles stick the 2D plane horizontal plane. If this value is set to 0 or too low, the space bubbles will deviate from the 2D plane and start floating in 3D space, which is of course will look weird. However, initially setting this value to 0 and slowing increase it might give a better result (more details below)
  • Sphere Collision Strength: Control the degree to which the space bubbles do not overlap with each other
  • Department Cohesion Strength: Control the degree to which space bubbles within the same departments should stay close together
  • Space Adjacency Strength: Control the degree to which an adjacent pair of space bubbles stay close together (the adjacency specifications are defined in the .csv file)

You might find it quite fun to play with the parameters and see how the space bubbles react in real-time. But keep in mind that the final goal here is to find an arrangement such that the adjacency requirements between the spaces are satisfied as much as possible. To achieve this goal, we suggest you try the following parameter tuning strategy to get better results in some cases:

  • First, reset the engine, and before you start executing the engine again. Set these four parameters to 0: Boundary Strength, Planar Constraint Strength, Sphere Collision Strength and Department Cohesion Strength.
  • Now, start executing the engine, and gradually increases these parameters to their maximum values, in the following order: Department Cohesion Strength > Sphere Collision Strength > Planar Constraint Strength > Boundary Strength

Using your own input data

You can modify the content of the .csv file (e.g. with Microsoft Excel) to reflect your own space planning specifications and requirements (figure 8). Please note that in this early version of DynaSpace, the content in the following csv columns will be ignored: Quantity, Width, Height, Total Area, Preference, and Adjacent Department.

Figure 8. The csv spreadsheet where the spaces are specified. The shaded columns are ignored in this early version of DynaSpace