Using the Revit IFC Export in your own add-on

In September 2011, Autodesk make accessible the Industry Foundation Classes (IFC) exporter for Revit as open source code, licensed through a LGPL v. 2.1 licensing agreement. In 2014, this project evolved to include IFC import as well, and was named “IFC for Revit”.

This source code is available on Source Forge, and everyone can contribute to the part of Revit that deal with IFC.

This source code is now the built-in IFC engine for Revit, and I was told that this engine is also behind the conversion service available through Forge.

When the user clicks on Export to IFC, an even is triggered, and Revit catch this even to run the IFC exporter. This also works when the event is triggered by the Document.Export() used through the Revit API by a third-party add-on, like the one I built last week. This IFC Export engine will then read the Revit model, convert every element into its IFC counterpart, and write the resulting IFC file.

How Revit export to IFC

This IFC engine comes with a special UI, the IFCExporterUI, designed to tap into the capabilities of the open-source IFC exporter to give you more control over the configuration of your export.

There are different add-ons for each Revit version, and each new release of Revit is shipped with the most up-to-date IFC engine available at the time. However, the code for this engine evolve quickly, and you can always download the latest version as an add-on on the Autodesk App Store.

At the time of writing, the landscape looks like this:

Revit Version Built-in IFC Exporter version Latest IFC Exporter version (with the Revit IFC add-on)
2016 Exporter 16.0.490.0 – Default UI Exporter – Alternate UI
2017 Exporter 17.0.1081.0 – Alternate UI Exporter – Alternate UI
2018 Exporter – Alternate UI Exporter – Alternate UI

If you want to know witch version you have, you can check it by opening an IFC file with a text editor and look among the first lines, the FILE_NAME one:

Check you exporter version

I didn’t dig into the subtleties of the different flavors of each Revit version, like R2 and other exotic name, you get the picture.

Last week, I published a Revit add-on to send a model to bimsync. Under the hood, this add-on exports the Revit model to IFC before uploading it to bimsync. As I was building my add-on, I realized that I couldn’t just use the Document.Export() function with whatever IFC export settings Revit could provide me. To be useful, such an add-on must allow the user to set up his own IFC Export configuration.

I look into the code of the IFC Exporter UI to understand how this user interface communicate with the export engine. I found out that you need an IFCExportConfiguration class to use a specific IFC Export configuration. Below is an example of the code needed to export a Revit model to IFC:

//Create an instance of IFCExportOptions
IFCExportOptions IFCOptions = new IFCExportOptions();

//Get an instance of IFCExportConfiguration
IFCExportConfiguration selectedConfig = modelSelection.Configuration;

//Get the current view Id, or -1 if you want to export the entire model
ElementId activeViewId = GenerateActiveViewIdFromDocument(doc);
selectedConfig.ActiveViewId = 
        selectedConfig.UseActiveViewGeometry ? activeViewId.IntegerValue : -1;

//Update the IFCExportOptions
selectedConfig.UpdateOptions(IFCOptions, activeViewId);

string folder = "A path to a folder where you want to save your IFC file";
string name = "the name of your IFC file";

//Export the model to IFC
doc.Export(folder, name, IFCOptions);

You start by creating an instance of the IFCExportOptions found in the Autodesk.Revit.DB namespace. This is standard in all Revit flavors.

Then, you retrieve or create an instance of the IFCExportConfiguration class. This is a class provided by the IFC Export add-on that hold every aspect of your export configuration, from knowing if you want to export the BaseQuanties to the path to the IfcPropertySets mapping files.

You get the Id of the active view and use the UpdateOptions method of IFCExportConfiguration to pass it along with all other properties to the IFCExportOptions.

The IFC Export add-on also provide an IFCExportConfigurationsMap class to get the built-in configurations and store the new ones.

The existing export setups

But where find these IFCExportConfiguration and IFCExportConfigurationMaps classes ?

If the IFC for Revit add-on is installed, you can find these classes in the IFCExporterUIOverride.dll. This dll can be found in your ApplicationPlugins folder, in the IFC plugin install folder (C:\ProgramData\Autodesk\ApplicationPlugins\IFC 2018.bundle\Contents\2018)

Running this on a Revit equipped with the add-on will work nicely, but it will fail miserably when the user doesn’t have the IFC for Revit add-on. In this case, the add-on can’t find the IFCExporterUIOverride.dll containing the IFCExportConfiguration class:

Using IFCExportConfiguration without the add-on

If you have a Revit version with the IFC Exporter UI built in (Revit 2017 or 2018), the IFCExportConfiguration and IFCExportConfigurationMaps classes can be found in the IFCExportUI.dll, located in your Revit installation folder (C:\Program Files\Autodesk\Revit 2018\AddIns\IFCExporterUI). In this case, the features available are the same than our previous case, but are in a different dll.

If you don’t have the IFC Exporter UI at all (Revit 2016 and earlier versions), you must fall back to the basic export options.

In a nutshell, we have to manage these three cases:

Class DLL Revit version
IFCExportConfiguration IFCExporterUIOverride.dll

In C:\ProgramData\Autodesk\ ApplicationPlugins\IFC 2018.bundle\Contents\2018

All Revit version equipped with the IFC for Revit add-on
IFCExportConfiguration IFCExportUI.dll

In C:\Program Files\Autodesk\Revit 2018\AddIns\IFCExporterUI

Revit 2017 and 2018 without the IFC for Revit add-on
IFCExportOptions RevitAPI.dll

In C:\Program Files\Autodesk\Revit 2018

Revit 2016 and earlier without the IFC for Revit add-on

To manage these different cases, I created my own export configuration class, named IFCExportConfigurationCustom. This class handle the configuration of the export and is an interface between my code and the possible IFC export options.

I load in my Visual Studio solution the two dll containing the IFCExportConfiguration class, and using alias, I call a different version of it depending on the installation of the user:


I also handle the vanilla Revit 2016 in my IFCExportConfigurationCustom class, without using any version of the IFCExportConfiguration (which is not available in this version of Revit), using instead the plain old IFCExportOptions built-in into Revit.

By managing the different possibilities of the Revit installation, I am able to make use of the best configuration available to export IFC. I am also able to use directly the Setup configuration interface available in the custom UI, and retrieve these user-defined export setups in my add-on.

Edit IFC Export Setup

If you plan on building your own Revit add-on to upload IFC models to a cloud service, don’t hesitate to look into the source code behind this article, the solution can be found on Github.

By opening the source code of its IFC engine, Autodesk make an underrated effort toward interoperability. Even if it’s obviously not for every Revit user, I think that everyone who rely on the Revit IFC export for its own software should look at this engine to get a full understanding of the possibilities offered by this exporter



A very interesting feature of the IFC model is the IfcPropertySet . According to the official IFC specification, the IfcPropertySet is “a container class that holds properties within a property tree”. This allow to add user-defined properties to IFC elements or types. To make an analogy with Revit, it is pretty much like creating shared parameter.

Since the IFC exporter for Revit is accessible as open source code, a new exporter have been developed, and offer far more control over the creation of IFC files from Revit. One of the improvement is the ability to select Revit properties to be exported as IfcPropertySet.

The default option only export common IFC properties, but you can also export the entire set of Revit properties, or just selected ones, through user-defined property sets.


To create one, I download one of the example coming along with the source code of the new exporter.

In this example, we can see the global syntax for creating user defined property sets.

I use it to create my own PropertySet Definition File, and use it to export Creation Phase and Demolition Phase to a new PropertySet called Phases.

PropertySet:     Phases     I     IfcElement
Creation Phase     Text     Phase Created
Demolition Phase     Text     Phase Demolished

In this definition file, we set up the name of the PropertySet, its use (on instances or on types) and the list of elements were we want to apply our properties.
Then we add the mapping between IFC (left member) and Revit properties (right member), along with its data type (Text, Real, Integer or Boolean)

We add this file in the IFC Export configuration, and export our IFC file. We can now see these properties appearing under the Phases set :

Before :


After :


If IFC export and import is still not powerfull enought in many software solutions to enable geometrical modifications directly in the IFC file, there are plenty of opportunities to add metadata to the element, directly in IFC.

Walls in Geometry Gym

A recent webinar about interoperability between Grasshopper and Revit make me look again on these tools, particularly for importing walls, In fact, I generally test these kinds of tools with a set a beams, more or less intricate, but never with walls, so I decide to generate a set of walls using the Geometry Gym IFC Importer for Revit.

Using Geometry Gym require at least some basic knowledge of the IFC structure. In fact, using this tool can be a really good starting point for studying the model behind Industry Foundation Classes.

Any IFC building object must be included in a (IFC) building, itself included in a (IFC) project, both of them must have a GUID and a name. So we start by placing these components on the Grasshopper’s caneva.

In order to have our NURBS path curve understood by Revit, we approximate it into a set of lines and arcs, using the specific Geometry Gym component.

We create an ggIFCElementParameter component to give a pretty name to our wall.

In order to create the multy-layer structure, we add two materials, both of them linked to a MaterialLayer component where we define the thickness of each layer. These component are merged into a MaterialLayerSet, itself link to a wall type.

The IFC class used by Revit for generating walls is the IFCWallStandardCase, so we use this component in our Grasshopper definition. We link all these components to our IFC Wall Standard Case, had a height parameter, and bake the whole think.

The resulting IFC file contains a pretty good wall, with every expected parameter. We check it in my favorite IFC viewer, the Solibri Model checker.

Once imported in Revit, using the embedded plugin, it creates a generic component looking like our wall. It appears in a schedule with the family name and type as set, but it’s still not an editable Revit wall.

I generally use the massing tool to create walls in Geometry Gym. I create a simple IFCExtrudedAreaSolid (for example) from a base NURBS curve, and then import it in Revit to generate a mass.


I can now use this mass to create my curved walls in Revit, along with the floors slabs. This method need an additional step (creating the wall from the Revit mass faces), but create native Revit walls.

As I write these lines, a new version of the IFC Import plugin for Revit have been posted on the Geometry Gym blog, I still have to review the improvement.

Industry Foundation Classes

Anyone who has worked in the BIM field may have eared something about Industry Foundation Classes. Yes, you know, this little logo…

Generally, it appears when we try to export a building model from proprietary software to another. The IFC exchange format allows us to convert files and, with some luck, open them the other software.

But what really is this IFC file format, and why everybody talk about it ?

Developed by Building Smart, a non-profit association of architects, civil engineers and IT specialists, IFC is a data model specifically designed for building information modeling.

In other terms, it’s a series of definitions, explaining how describe any building element in order to make it comprehensible by a computer. But while each BIM software relies upon its own very private data model to define a building, the IFC data model is open, and freely accessible by anyone here.

These definitions create a language readable by a computer, and written as a text file. This file is even readable by human being, and look more or less like this:

#66= IFCCARTESIANPOINT((-17261.0669833266,3274.73863321424,0.));

#68= IFCAXIS2PLACEMENT3D(#66,$,$);


#70= IFCCARTESIANPOINT((9430.2775637732,0.));

#72= IFCPOLYLINE((#5,#70));

#74= IFCSHAPEREPRESENTATION(#43,'Axis','Curve2D',(#72));

#76= IFCCARTESIANPOINT((9430.2775637732,-100.));

It’s not very convenient, but with some pain, we can find a wall here,

#209= IFCWALLSTANDARDCASE('0EiAvIo0LBOBfvSD8E4HST',#52,'Basic Wall',$,’200 mm’ ,#181,#207,'177171');

create by an extrusion like that,

#92= IFCEXTRUDEDAREASOLID(#90,#91,#15,8000.);

and place at the point define like this:

#76= IFCCARTESIANPOINT((9430.2775637732,-100.));

I have worked some times in order to understand this language, and if I’m still not speaking IFC fluently, I was able to improve myself a little. You will find the result of my work here.

There is plenty of IFC’s approved software, but if everyone is compliant, some are more compliant than other. For example, Revit was well known for its really poor implementation, but I have heard that Autodesk have made great improvement in the 2013 version, I still have to look at it.

For my part, the best implementation I have ever be able to test is the plugin for Grasshopper made by Jon Mirtschin called Geometry Gym. Fully compatible with the latest version of IFC (IFC2x Edition 4 Release Candidate 2), this plug in transform Rhino in a full scale BIM software. This plugin deserve at least a whole article, so I will came back to it.

The IFC model is still in the development part, and is currently in the process of becoming the official International Standard ISO 16739.

If it’s not the leading format in the BIM business, the IFC format is a really interesting attempt to create an open exchange standard, and some software like Solibri Model Checker have understood it well enough to use IFC as the only input models format.