Hop Between Grasshopper And Revit

No software does it all, which is why interoperability has become such a hot topic. In this How To, I’ll show you how the power of Grasshopper’s parametric modeling tools and customizability can be leveraged to get tons of information into Revit. Furthermore, we’ll put that information into Revit’s native language so we can use and manipulate it.

This How To takes advantage of various panelling procedures in Rhino/Grasshopper. If you are new to such techniques, check out the resources in the Toolbelt. There are a huge variety of grid shell designs and techniques for creating them parametrically. Many procedures may be used towards the end-goal of this How To, but creating them is not the focus here.

Step 1. Build a Grid Shell

We’re going to assume that we’ve created three things that live in Rhino, but they could just as easily be part of your Grasshopper definition:
1. Design Surface.
2. Centerline geometry of the grid shell structure.
3. Individual surfaces for each panel.

Design Surface

The most important thing about a design surface is a recipe, so that anyone could follow it to recreate the surface with a fair degree of accuracy.. So early on, try to create some ‘setting out’ diagrams. Here’s an example of a setting out diagram based on a primitive toroidal shape, and the resulting surface generated from that shape:

base shape

Centerline Geometry

It is probably easiest to create the centerline geometry and panels simultaneously. It could be something as simple as a few LunchBox components, a robust Paneling Tools definition, or an all-customized solution.



The panels should each be a single surface with straight edges. Curved edges are another can of worms entirely…


Before beginning Step 2 make sure you are using the same units in both Rhino and Revit.

Step 2. Chameleon

Chameleon is a free plugin for transferring data between Grasshopper and Revit. If you’re unfamiliar, check out the tutorials on the Chameleon website for more information about the plugin.
1. Every panel that you plug into a Chameleon “AC System” component should have the same number of corners. That is, if you have triangular (tris) and quadrilateral (quads) surfaces, you can’t plug them into the same AC System component, you have to separate them and import them into Revit separately.
2. If you want to include one or more parameters for each panel–a unique ID or a value denoting some analysis data–the data for the parameter can only be a number, and must have the exact same tree structure as the points. Let’s get into each of these issues:

Basic definition for importing panels to Revit:

Pretty simple, right? For a grid shell with panels of a single shape, say triangles, and no extra parameters this would be all you need. We take the triangular surfaces, find the corner points, and give that information to Chameleon to pass along to Revit. We are not importing geometry from Rhino into Revit, we are importing data; specifically we are importing (x, y, z) coordinates. Chameleon will simply tell Revit where to place Revit-native objects using these coordinates.

For each panel, the definition finds the corner points using the Discontinuity (Disc) component. I’m using this component rather than the Deconstruct Brep (DeBrep) with its Vertices output because Disc will always give points in order around the perimeter of the polygon. If you have more than three corner points, DeBrep may mix them up so they aren’t always clockwise or counterclockwise.

Let’s take a look at the data tree structure of the points we’re telling Chameleon to transmit before we import to Revit:

There are 372 panels, so what you see is a data tree structure with 372 branches, each with a list of points. In this case, the lists vary in length between 3 and 4 items. That’s because the grid shell I created slices off some tris and leaves some quads along the edges. Since you have to tell Chameleon to use a specific Adaptive Component in Revit–we’ll get to that in a minute–you have to separate the list into tri's and quads. Here’s one way:


Finally, there are a lot of panels. Chameleon has a tendency to slow down as you translate more and more data, so I’ve found it helpful to keep an individual translation session–that’s what I’ll call each time I push the “Activate” button on the AC System component–to under 3000 panels. Doing 9000 panels all at once would take longer than three sessions of 3000 panels each. We don’t have nearly that many panels in this example, but here’s one way to split the list of tris if you did have more:


So let’s push one of those buttons already! Right? Not so fast.

Preparing Revit

We need to create and load 3- and 4-point Adaptive Components into a Revit project so Chameleon can place instances of them in Revit. Here are my two Adaptive Components:

One of the great things about Revit is we can start with what amounts to proxies–simplified representations of the final object–and develop them as the design develops. These Adaptive Components are simple, single-surface polygons, but eventually we could develop them further like this:


For now we’ll use the simplest version. Load these into a Revit project, switch back to Grasshopper, and click the button that activates the translation for tris:


Switching over to Revit, click Add-Ins tab > AC Connect and choose the appropriate adaptive component:


After you repeat this for the other panel collections, you’ll have all your panels in Revit. That’s it.


One more thing you may want to do, as I mentioned earlier, is bring additional information along with each panel, say a unique ID. What I’ve done is give each panel in Rhino a number in its name property and bring that data along in parallel with the panel’s points.


Chameleon will only pass a single number–integer or decimal–along for each parameter and your Adaptive Component must have an available parameter of type Number–not Integer, Length, Area. Here’s one way of passing along a unique ID using the name of the panel:


Step 3. Structure with Geometry Gym

To create the structure in Rhino and Grasshopper and translate it to Revit, I’ve used Geometry Gym. While Chameleon is bidirectional (you can translate Rhino >> Revit >> Rhino updating changes you make in either software platform), Geometry Gym doesn’t create a direct link to Revit. Rather it creates an IFC file that you then import into Revit. The advantage of this is that what you create in Grasshopper is actually quite platform-independent; many BIM software packages can import and export IFC files. The disadvantage is this translation is slower and there is no direct link back to Grasshopper.

Another advantage of Geometry Gym is that it is proprietary software, a highly tested tool. It really works, rarely breaks, and the creator–Jon Mirtschin–is incredibly responsive for support and feature requests. Another option is Hummingbird, which is free, but I haven’t tried it.

With that intro, let’s take a look at the definition we’ll be using and discuss a few tips:


You’ll notice I’m using the Geometry Pipeline component to get the Centerlines and the Massing. If you are careful about layer management in Rhino, this can be a very efficient way to work and collaborate. Agree with your team members on naming conventions and then you’ll have a much easier time sharing information.

When working with Geometry Gym, I’ve found it helpful to turn on ‘Draw Full Names’ in the Grasshopper View menu.


Create IFC BEAMs

I often like to start at the end, so lets talk about the “IFC Beam” component (ggIFC Beam Standard Case). You need a few pieces of information to define a beam in Geometry Gym:

  1. A line or “Axis” for the beam. In our case, it is the lines we created for the Centerline Geometry above. The input for Axis (A) is quite straight forward. We just put a bunch of lines/curves from Rhino into that input.

  2. A profile or all the stuff plugged into the “IFC Beam Type”. The profile has a few pieces: the actual curve that defines the profile, the material, and the name. If you trace the IFC Beam Type (T) input backwards you’ll see an ggIFC Beam Type (ggIFCBT) component that needs an IFC Mat Profile (M) and a Name (N). The latter is just descriptive text, and the former is another Geometry Gym component, ggIFC MaterialProfile (ggIFCMP).

The IFC MaterialProfile needs a Name (N), Material (M), and the Profile (P) curve. The only part of this that is of consequence for us is the Profile curve. In my case, I’ve chosen to explicitly define it with a series of points for a polyline. The remaining components rotate and offset if necessary.

  1. The rotation of a profile around its axis or “orientation”, is accomplished via vectors. The orientation is a bit trickier and is all contained in the cluster. Here’s what’s inside that cluster:


This is why we need the Design Surface from Step 1. Usually for a curvy surface, beams are oriented normal (aka perpendicular) to the surface. This cluster spits out one vector normal to the surface for each Axis. I’ve chosen to use the midpoint of the Axis to find the normal assuming this is like an average rotation for the structural member.

  1. Whether the Axis defines the centerline of the beam, top, bottom, etc, which is controlled by Right-clicking the “IFC Cardinal Point Reference”. In my case, I’ve chosen TOPMID, so that I’m defining the top of steel along the center of the beam.

  2. An IFC Container. Every IFC file needs an IFC Project and an IFC Building to give it context for the objects within the IFC definition. There can only be one IFC Project and one IFC Building and one ggBake component in a Grasshopper definition.

Once you have this all worked out, you can simply double-click the ggBake component at the top of the definition and write an IFC file.

The remaining components at the end of the definition bake the beam geometry into Rhino. I’ve used the Human bake component because it works with a button rather than a Boolean toggle. The down-side to the Human bake component is it won’t automatically make a new layer if the name you choose doesn’t already exist. You could also use the Lunchbox bake component, which uses the Boolean toggle, but will make a new layer if it doesn’t exist.

Import IFC in Revit

Open Revit and using the Geometry Gym “Import IFC” command:

Bring all your beams in as Revit-native objects. You may or may not want to check the “Cutback Framing Members” or “Cutback Member Families” checkboxes in the Import IFC dialog:


If you do check them, the beams will be pulled back from each other at the nodes where they intersect. This is more accurate for a grid shell–you’ll need a piece of structure at the node to connect all the beams. However, for design and visualization purposes, you may want to keep these unchecked and let the beams intersect. It’s up to you.

better, faster, stronger

Well that’s it! You could create a lot more extrusions for things like gaskets and joints between the panels with this simple structural tool using different profiles, names, and materials. Once you have the panels in Revit, you could develop the AC family further to give the panels thickness, multiple layers of glass, reveals, and more. You can even add more information in Revit, export as IFC, and import back to Grasshopper with the Geometry Gym components to keep manipulating the structure.

As always we welcome feedback on the post, or his us up @section_cutimages of your projects that use this tutorial!

Happy hopping!

Share the Love