The Benefits of Managing your AutoCAD Library in UNIFI

If you’re at all familiar with our suite of UNIFI products, you know that our BIM content management system and Project Analytic solutions integrate seamlessly with Revit. But did you know that we support the storage of more than just Revit families and materials? You may be surprised to learn that UNIFI can also help you sort and manage your AutoCAD libraries as well.

Using UNIFI to Organize Your AutoCAD Blocks

There are several benefits to using UNIFI to maintain your CAD library (as opposed to storing them in a folder location on your network).

First and foremost, any piece of content (virtually any file type) hosted in UNIFI has the opportunity for applying metadata which makes AutoCAD blocks easier to organize, find, and revise.

In screenshot below, you can see an example of some of the metadata that I’m referring to.

Autocad1. Star Ratings: Users have the option to rate AutoCAD blocks. This gives users the ability to sort or filter by how high or low the DWG is rated.

2. Custom Preview Images: By default, we will display the DWG file thumbnail as the preview image in UNIFI, however, users have the option to upload or capture their own preview image for display within UNIFI.

3. File Size: From an CAD perspective, file size can be a critical piece of what determines the quality of an AutoCAD block. Here you can see the file size of the block before inserting it into a drawing.

4. Libraries: Rather than living in a single folder on a network drive, your CAD blocks can now be made available to multiple libraries, which allow for control over who can access this DWG or who has admin rights to modify it.

5. Tags: Similar to libraries, tags allow multiple ways for users to find AutoCAD DWGs stored in UNIFI The main difference is, unlike libraries, tags do not offer permissions control.

The screenshot below is what it looks like to view an AutoCAD block in UNIFI. The added benefit here is the versioning capability. As you can see in #1 below, anytime a DWG is updated in your library, we’ll automatically create a version which records who made the change, when the change was made, and even give users the opportunity to describe what they changed. As you would expect, admins even have the ability to roll back to a previous version if the need should arise.

AutocadAutoCAD Integrated

As mentioned earlier in this post, UNIFI is integrated with Revit, but did you know that we also play nicely with AutoCAD?

It only takes a single click to insert a CAD block into your current AutoCAD drawing. When a user clicks on the preview image from within their Unifi Core library, our add-in downloads the block from the cloud, inserts it into your current AutoCAD drawing, and prompts the user to place it immediately.

Exporting and Uploading

We also install two AutoCAD add-ins which support two functions.

1. Upload Drawing: Uploads the entire DWG that is currently open to UNIFI.

2. Export Objects: Prompts the user to select blocks within the current DWG and batch uploads them to UNIFI.

Conclusion

With the exponential adoption of Revit, we often forget that several firms still rely on AutoCAD as a core application in their daily workflows. So, whether you’re a current UNIFI user or not, I hope that this post has helped shed some light on how our platform not only supports virtually any file type, but also integrates directly with AutoCAD.

Revit Macros and C#: A Quick-Start Revit API Guide For Beginners Part 4

Revit Macros and C#: A Quick-Start Revit API Guide For Beginners Part 4

Welcome to the final post in our series dedicated to helping you get started with the Revit API. In last week’s post, I introduced you to Revit macros and how you can use them to get started on easily tapping into the Revit API using C#. For this post, we’ll continue modifying that macro and add a method that creates a text note in the active view of your current project that says “Hello world!”

Start by opening up last week’s Revit project where we created our macro.

Modifying an Existing Macro

To being editing an existing macro, simply navigate to the Manage Tab > Macro Manager.

Within the Macro Manage Window, select the module or macro that you would like to edit and click the Edit button. Notice that the SharpDevelop window opens and you’ll again see the default code that was automatically generated by the macro manager when we created this macro.

Just Add Code

Now that we’re all caught up, I’d like to share the code for the HelloWorld method. Remember, this method will replace the method at line 39 in yesterday’s post and all the tasks that this method is meant to perform needs to be within the curly braces.

        public void HelloWorld()
        {
            // Get the active view of the current document.
            // http://www.revitapidocs.com/2018/043960ac-dde4-0f45-249f-8161646a4362.htm
            Autodesk.Revit.DB.View view = this.ActiveView;
            
            // Create XYZ object at coordinates x=0, y=0, z=0
            // http://www.revitapidocs.com/2018/c2fd995c-95c0-58fb-f5de-f3246cbc5600.htm
            XYZ noteCoordinates = new XYZ(0, 0, 0);
            
            // Create string object for text note
            // http://msdn2.microsoft.com/en-us/library/s1wwdcbf
            string content = "Hello world!";
            
            // Create a transaction so that we can modify the model
            // http://www.revitapidocs.com/2018/308ebf8d-d96d-4643-cd1d-34fffcea53fd.htm
            Transaction trans = new Transaction(this.Document, "Add text note");
            
            // Start the transaction
            trans.Start();
            
            // Get text note type by name
            ElementId textNoteTypeId = GetTextTypeIdByName(this.Document, "3/32\" Arial");
            
            // Create text options from text note type ID
            TextNoteOptions textNoteOptions = new TextNoteOptions(textNoteTypeId);
            
            // Create text note in view
            TextNote newTextNote = TextNote.Create(this.Document, view.Id, noteCoordinates, content, textNoteTypeId);
            
            // Commit the transaction change
            trans.Commit();
        }

As you’re reading through the code block above, pay attention to the comments that I’ve added; they’re the lines in green which start with two slashes. In general (and this applies to any time you’re writing code) comments have no effect on the program itself and are only added to help anyone reading the source code in the future, including the future you!

I’ve added a comment at nearly every line to help you understand exactly what the macro is doing following the comment. Included in these comments are URLs to specific pages on RevitApiDocs.com. On a side note, this website will prove to be your best friend as you’re leaning the Revit API because it makes the task of sifting through the Revit API documentation much less painful. It’s worth also noting that you should start getting used to the process of wading through pages and pages of documentation, as this is fairly typical when working with any API.

Helper Method

Aside from the code that is within the HelloWorld method, this macro also relies on a “helper method”. A helper method essentially helps another method perform a task. Occasionally, developers will break out code into helper methods when the smaller tasks can make the main macro method less readable.

Below is the code for the helper method that I created for this tutorial. You can add this code to the ThisDocument.cs file and ensure that it is outside of the HelloWorld method curly braces.

        public static ElementId GetTextTypeIdByName(Document doc, string name)
        {
            ElementId textId = null;

            // Collect all text note types
            FilteredElementCollector collector = new FilteredElementCollector(doc);
            ICollection<ElementId> textNoteTypes
                = collector.OfClass(typeof(TextNoteType))
                  .ToElementIds()
                  .ToList();

            // Get text note types as elements
            List<Element> elements = new List<Element>();
            foreach (ElementId noteId in textNoteTypes)
            {
                elements.Add(doc.GetElement(noteId));
            }

            // Get the text note type element ID by name
            foreach (Element e in elements)
            {
                if (e.Name == name)
                    textId = e.Id;
            }

            return textId;
        }

The helper method could have easily been added to the macro’s HelloWorld method, however for the sake of this example it is worth demonstrating that all of your code for Revit macros never have to live entirely within a single method. These helper methods can be reused across multiple macros as well, so keep that in mind as you’re writing your code.

The Complete Code

I realize that the code blocks above can be slightly confusing for beginners, so here is the macro in its entirety for those of you who would like to paste in the entire code to ThisDocument.cs:

/*
 * Created by SharpDevelop.
 * User: Jay Merlan
 * Date: 3/12/2019
 * Time: 7:07 AM
 * 
 * To change this template use Tools | Options | Coding | Edit Standard Headers.
 */
using System;
using Autodesk.Revit.UI;
using Autodesk.Revit.DB;
using Autodesk.Revit.UI.Selection;
using System.Collections.Generic;
using System.Linq;

namespace FirstModule
{
    [Autodesk.Revit.Attributes.Transaction(Autodesk.Revit.Attributes.TransactionMode.Manual)]
    [Autodesk.Revit.DB.Macros.AddInId("11B5DF7E-A80F-4038-88EA-7E3F9E2AEF9A")]
    public partial class ThisDocument
    {
        private void Module_Startup(object sender, EventArgs e)
        {
            // This method is called when a module is loaded
        }

        private void Module_Shutdown(object sender, EventArgs e)
        {
            // This method is called when a module unloads
        }

        #region Revit Macros generated code
        private void InternalStartup()
        {
            this.Startup += new System.EventHandler(Module_Startup);
            this.Shutdown += new System.EventHandler(Module_Shutdown);
        }
        #endregion</pre><pre>        public void HelloWorld()
        {
            // Get the active view of the current document.
            // http://www.revitapidocs.com/2018/043960ac-dde4-0f45-249f-8161646a4362.htm
            Autodesk.Revit.DB.View view = this.ActiveView;
            
            // Create XYZ object at coordinates x=0, y=0, z=0
            // http://www.revitapidocs.com/2018/c2fd995c-95c0-58fb-f5de-f3246cbc5600.htm
            XYZ noteCoordinates = new XYZ(0, 0, 0);
            
            // Create string object for text note
            // http://msdn2.microsoft.com/en-us/library/s1wwdcbf
            string content = "Hello world!";
            
            // Create a transaction so that we can modify the model
            // http://www.revitapidocs.com/2018/308ebf8d-d96d-4643-cd1d-34fffcea53fd.htm
            Transaction trans = new Transaction(this.Document, "Add text note");
            
            // Start the transaction
            trans.Start();
            
            // Get text note type by name
            ElementId textNoteTypeId = GetTextTypeIdByName(this.Document, "3/32\" Arial");
            
            // Create text options from text note type ID
            TextNoteOptions textNoteOptions = new TextNoteOptions(textNoteTypeId);
            
            // Create text note in view
            TextNote newTextNote = TextNote.Create(this.Document, view.Id, noteCoordinates, content, textNoteTypeId);
            
            // Commit the transaction change
            trans.Commit();
        }
        
        ///</pre><p> </p><pre>        /// A helper method to return the element ID of a TextNoteType
        /// </pre><p>///The name of the text note type. /// The Element.Id of the TextNoteType. public static ElementId GetTextTypeIdByName(Document doc, string name) { ElementId textId = null; // Collect all text note types FilteredElementCollector collector = new FilteredElementCollector(doc); ICollection textNoteTypes = collector.OfClass(typeof(TextNoteType)) .ToElementIds() .ToList(); // Get text note types as elements List elements = new List(); foreach (ElementId noteId in textNoteTypes) { elements.Add(doc.GetElement(noteId)); } // Get the text note type element ID by name foreach (Element e in elements) { if (e.Name == name) textId = e.Id; } return textId; } } } 

If You Build It, It Will Run

The final step for creating a Revit macro is building the solution. This is where SharpDevelop compiles the code to be machine-readable and also looks for issues in our code. The IDE will notify us if there is a error in the code will attempt to specify what is preventing the IDE from building the solution.

To build your solution, either press the F8 key on your keyboard or navigation to the Build Menu > Build Solution. If you don’t see any errors and the lower left corner of the SharpDevelop window says “Build finished successfully,” congratulations, you’ve now created your first Revit macro!

Errors

Below is an example of what it looks like for the IDE to catch an error while building the solution. Notice the error log tells you which line the error was caught (#93) and the description informs you of exactly what the error is. In this case, I was missing a semicolon at the end of line 93. In addition, you have the option to look up the error code that is in parenthesis (CS1002), where you can find even more information about that specific error online.

Once I added the semicolon to the end of line 93, I hit the F8 key on my keyboard, and the solution was built successfully!

Run Macro, Run!

Now that we’ve built our solution, we can return to the macro manager and run our macro. Simply select the macro in the macro manager and click the run button.

Welcome to the Revit API

Although this concludes our four-part series on getting started with the Revit API, this is only the beginning of your journey. From here, I recommend that you use these fundamentals and put some effort into learning how to model walls, duct, pipe, or other more complex model elements using the Revit API, whether you choose to use Dynamo or Revit macros.

Do you have a better way of writing “Hello world!” on a Revit view? Are you having trouble with following along this tutorial? Leave us a comment and let’s start up some discussion.

Release Notes: UNIFI Core Version 3.2.1 & UNIFI Web Portal Version 2.9.0

Hey UNIFI Customers,

We’re pleased to announce our latest software update was released on March 18, 2019. CORE 3.2.1 updates include content upload email notifications, improved materials and fill patterns support, and several bug fixes.  Portal 2.9.0 includes the frequently requested API access! Please read below for further details.

CORE 3.2.1 Highlights

1. Content Upload Email Notifications:

Overview:

– Library Admins will now receive email notifications when a content upload request is created

– Users who submit upload requests will receive email notifications when the requests are approved or rejected

– Email notification templates for new content requests have been updated

Details:

One of the top requested features on our customer idea portal is content upload email notifications. You asked, and we delivered; library Admins will now receive email notifications when users upload files that require approval. The user who uploaded will also receive email notifications when the upload request has been either approved or rejected. The days of manually notifying admins for upload requests are behind us. 

2. Materials and Fill Patterns Support

Overview:

– Material assets are now extracted locally to enable rendering by users who don’t have access to the file path referenced by the material

– Materials and Fill Patterns can now be transferred using Harvest Project Elements

Details

It’s no longer necessary for users to have access to the file path stored in the material in order to render materials inserted from UNIFI Core. Material assets are now extracted locally if the user does not have access to the file paths referenced by the material.

3. Bug Fixes

Our goal is to keep you happy and confident in our product! We’ve fixed the following bugs: 

– In password reset emails, the link now displays properly

– Files uploaded as part of a content request in the web portal now appear properly in the selected libraries

– Revit material class is now stored for each base file version

– Fields such as tags, family type names, and family categories with non-alphanumeric text are now searchable

– Exported fill patterns will no longer include materials from the project they were exported from

– In content request emails, the company name now displays properly

– Email notifications that indicate a new content request has been created will now be sent to selected notification groups

– When searching in the batch export interface, selecting a category level checkbox now only selects the filtered items for that category

– When inserting a Revit schedule that already exists in a project, column headers are preserved

– Revit 2015 no longer steals focus when Revit and UNIFI are on the same screen

– Content uploaded to a shared library from an external company is now added to the repository of the shared library owner

– Added German keyboard support for ß symbol

– When adding user access to libraries, the user list stays visible

– Knowledge Center link points to the correct URL

– Email notifications are now sent when a content request is completed

– Materials with quotes in the name now parse properly

– Revit content with mixed non-alphanumeric characters and spaces now insert properly

– Fixed an issue where users could not login if the settings folder became hidden

– Revit families with a type catalog can now be copied to a library using the ‘copy to library’ function

– Fixed an issue where some content requests were not visible on the notifications page

– Dates in content requests now display the correct local date and time

– The batch insert dialog now displays the exact file name

– After viewing file details from the search page, selecting the back button now preserves the entered search term

– The default “solid fill” fill pattern can no longer be exported to UNIFI

– Filled regions now appear in the proper category after parsing is complete

– Files are no longer orphaned after being removed from all libraries

– Reviewing file details for uploaded content requiring approval will now display the new revision details rather than the active revision details

– Renaming a Revit family that contains no manually created types will also rename the default family type

– The base file chart now updates when content is uploaded to a shared library

– Harvest Project Contents will no longer load preview images by default

– Subscriptions to channels that are removed from UNIFI Connect are now unsubscribed

– Fixed an issue where inserting some model groups would crash Revit

– Revit families uploaded to UNIFI while still open in the family editor no longer appear under a blank category

Ready to take advantage of these new features? Click here for instructions on updating UNIFI Core. 

Portal 2.9.0

1. Project Analytics

Overview

– API access now available!

– Added date controls to the Sync Times module on the company overview page

– Added a module that displays usage for the current month

Details

We’re thrilled to announce you can now access our Project Analytics API to programmatically setup projects, assign models to projects, and request raw Revit data for a specified commit/sync. This is a game changer for enterprise customers who no longer need to engage in the time consuming process of manually setting up each project in our web interface.

API documentation is available at https://api.unifilabs.com/

2. Materials and Fill Patterns

– File details for materials and fill patterns now display in the web portal when reviewing content requests

3. Notifications Page

– Any sorting and/or filters applied to the content request tables will be maintained after reviewing content and then navigating back to the notifications page

4. Bug Fixes

– The content request notifications table now displays the due date and requested date

– Content request attachments can now be downloaded

– Added description text to the manage subscriptions button in the subscription center

– When viewing library details, the share and protected checkboxes are no longer selectable and only report the proper state

– Changes made to project design phase and status values now save

– The forgot password page now displays properly

– Clicking the model delete button in project analytics now removes the model from the project

– The search result count in portal now matches the desktop application

– The export to excel button for the event stream now properly exports the file

Wrap-Up

Thanks for being a valued UNIFI customer and we hope you find the updates and fixes on this release useful.

Your feedback is very important to us and we’re always looking for ways to improve. If you have suggestions for future updates or changes, please click here to learn how to submit your recommendations directly in the UNIFI platform.

Revit Macros and C#: A Quick-Start Revit API Guide For Beginners Part 3

Revit Macros and C#: A Quick-Start Revit API Guide For Beginners Part 3

Welcome to part three of our quick start guide on getting started with the Revit API. In part two of this series, I shared some insight on how beginners can leverage Dynamo as an alternative to writing code. In this post, I’ll walk you through the more conventional method of using the Revit API to create a text note in your Revit project by writing only a few lines of C# code.

Prerequisites

This tutorial is really designed for the beginner coder, so you don’t need to be a seasoned software engineer to understand what we are going to cover in this post. It would definitely help to understand some basic object-oriented programming concepts, but even if you feel this tutorial might go over your head try to follow along anyway and see if you can learn a thing or two about writing code to tap into the Revit API.

The Revit API and C#

Revit macros currently support several programming languages: C#, VB.NET, Ruby, and Python. For this post, I’ll demonstrate how to use C# to develop a Revit macro, but there’s no reason you couldn’t follow along in your preferred language. If you go that route, obviously watch your syntax because it will be vastly different from my code snippets. The Revit API classes should be the main focus for this exercise.

Revit Macros

When getting started with the Revit API, I typically advise coders to learn using Revit Macros before diving in and developing a full blown Revit add-in. Developing a Revit add-in requires additional configurations and manifest files as well as an .addin file that is copied to the Revit add-ins folder. That means you’ll need to completely close Revit every time you need to test your add-in as you’ll need to overwrite the .addin file to test the newly compiled version. There are some methods that will allow you to reload an add-in without closing Revit, but they do require some additional configuration.

In contrast, using Revit Macros enables the developer to create a Macro within their current project. This provides a more streamlined workflow for coders who just want to dive in without complex configurations. A developer would simply need to open a Revit project, create a module and Macro and they can code, debug, and test on the fly without ever having to close Revit – unless they crash Revit of course!

Creating Your First Module and Macro

Launch Revit and start a new project. Once the project is open, navigate to the Manage tab and click on Macro Manager.

An empty Macro Manager window should open to the Project tab (the tab will display the filename of the current Revit project. Since there aren’t any modules created yet, the only option you have here is to create a module.

Click on the module button to create a new module.

Revit API - Macro Manager - Create Macro

In the Create a New Module window, name the module, choose C# as the language, and click the OK button.

Revit API - Name the module

Once you’re returned to the Macro Manager window, you’ll notice that it is now populated with the module that you had just created. From here, you’ll want to select that module and click the Macro button in the Create group.

Revit API - Create Macro

From here you’ll give the new module a name. For this example, I’m calling it “HelloWorld”.

Revit API - Name Macro

Congratulations, you just created your first Revit macro! Although maybe it isn’t quite time to celebrate, as the macro doesn’t do anything yet. With that being said,let’s start coding!

Revit API in SharpDevelop

Revit API - SharpDevelop C#

When you created your first macro, you may have noticed that an application called SharpDevelop opened. This is Revit’s out-of-the-box integrated development environment (IDE), which is a fancy term for the application that allows you to edit code, build, and debug.

Note: if you need to open SharpDevelop to edit your Revit macros in the future, keep in mind that you can launch it from the Macro Manager and simply by selecting a macro and clicking the Edit button.

You’ll see that there is about 40 lines of code that is automatically generated by the macro manager. This includes the typical using statements that will allow you work with the Revit API.

For reference, below is the code that is automatically generated by the Macro Manager when you created the macro:

/*
 * Created by SharpDevelop.
 * User: Jay Merlan
 * Date: 3/13/2019
 * Time: 11:41 AM
 * 
 * To change this template use Tools | Options | Coding | Edit Standard Headers.
 */
using System;
using Autodesk.Revit.UI;
using Autodesk.Revit.DB;
using Autodesk.Revit.UI.Selection;
using System.Collections.Generic;
using System.Linq;

namespace TestModule
{
    [Autodesk.Revit.Attributes.Transaction(Autodesk.Revit.Attributes.TransactionMode.Manual)]
    [Autodesk.Revit.DB.Macros.AddInId("DA944114-26AD-48FC-A3E1-03E0DC5AB50A")]
    public partial class ThisDocument
    {
        private void Module_Startup(object sender, EventArgs e)
        {

        }

        private void Module_Shutdown(object sender, EventArgs e)
        {

        }

        #region Revit Macros generated code
        private void InternalStartup()
        {
            this.Startup += new System.EventHandler(Module_Startup);
            this.Shutdown += new System.EventHandler(Module_Shutdown);
        }
        #endregion
        public void HelloWorld()
        {
        }
    }
}

Next Week: Just Add Code

Stay tuned for the final installment of the beginners guide to the Revit API where I’ll walk you through the code used to generate “Hello world!” as a text note in your Revit project.

How to Use Dynamo to Tap Into Revit API: A Quick-start Guide For Beginners Part 2

In part one of this series, I shared some insight on how beginners can get started with the Revit API. In summary, I made two recommendations:

1. If you don’t know how to code, use Dynamo

2. If you know how to code, start with Revit Macros

In this post, we’ll cover option #1 and learn some basics on how Dynamo can help you tap into the Revit API without writing a single line of code. It goes without saying that the best way to learn Dynamo is to dive in and learn by doing. Note that this tutorial assumes you are already familiar with Dynamo to the point where you can insert and connect nodes. If you need a refresher on some of basic terminology and usage, have a look at our post from last year which can help you get caught up quickly. Don’t worry about reading up on the Revit API itself, we can save that for part three of this series!

With all of that being said, let’s start with a sample graph that will write “Hello world!” as text in a Revit project.

Your First Dynamo Graph: Hello World

In software development, it is customary to provide sample code to help new users understand how to work with an API. Dynamo is no different, but being a visual scripting tool a screenshot is worth a thousand lines of code. Have a look at the completed graph in the image below. This graph is all you need to create our “Hello world!” text note on a view.

REVIT API DYnamo

What do each of these nodes do?

1. TextNote.ByLocation – This node does all of the work. It will place a text element in the view that you choose. The node has several inputs, but for this example we will only use the first four inputs. Note that if you were creating a text note using the Revit API, the TextNote.Create() method would be used and has parameters that are similar to the inputs of this node.

2. Views – This node’s drop down menu is automatically populated with all of the views in your current project. Choose any view in your active model for this example, as long as your Text Notes model category is visible.

3.Point.ByCoordinates – This node outputs a Point object based on the x, y, z inputs. For this example, I’ve shown three different nodes that you can use to pass number values to another node. Refer to 4, 5, and 6 below. The result is a point with cartesian coordinates. This is where Dynamo tells the Revit API where you would like the text note to be placed on your view.

4. Number – Enter a number to output the value as a number data type

5. Code Block – By simply inputting a number and semicolon in this node, the Code Block node will default to outputting a number data type. Note that Code Blocks are extremely powerful and can contain several lines of code, however for the sake of today’s example we are using it’s most simple form, outputting a number value.

6. Number Slider – The number slider gives users the ability to use a slider to adjust the number that is output.

7. String – The value in the String node goes into the “text” input for the content of the text note element in the Revit view. The output is a string data type, meaning it is a set of characters which can include spaces, numbers, and special characters (e.g., a word or sentence).

8. String – The same node as above, except the output of this String node should be connected to the “alignment” input.

Right about here, you’re probably expecting a link to download the completed graph. Well, in an effort to help you truly get the hang of using Dynamo, I’d like to challenge you to recreate it yourself. Refer to the image and start building – Good luck!

Experiment and Try to Create Something Useful

Once you have the “Hello world!” graph functioning and you fully understand the concept of inputs, outputs, and data types, I encourage you to have a look at some of the other nodes included with Dynamo that use the Revit API to place 3D elements within the model. I think you’ll be surprised at how far the fundamentals taught in this tutorial will take you while on your journey to learn Dynamo.

Coming Up Next

Be sure to check out part three of this series, which will demonstrate how to use C# to tap into the Revit API. We’ll learn how to use the built-in macro manager and SharpDevelop (Revit’s IDE) to add a “Hello world!” text note to a view.

UNIFI and bimstore Join Forces

bimstore

2019 is projected to be a tremendous year of growth at UNIFI Labs. Amidst the exciting expansion underway, our customer experience remains at the forefront of our focus. In an effort to increase access to high-quality BIM content for UNIFI AEC customers and to extend the outreach of top-quality BIM content for manufacturers, we’re pleased to announce our partnership with bimstore, the UK’s original BIM library.

"UNIFI’s AEC customers have requested access to bimstore’s content and we’re thrilled to be able to connect their manufacturers with our user base of leading design firms.”
Virginia Senf
COO, UNIFI Labs

Rob Charlton, CEO of bimstore echoes Virginia’s excitement about the recent team up of UNIFI labs and bimstore, 

“We’ve connected our platforms in order to make all bimstore content accessible through UNIFI, but our partnership goes much deeper than data. UNIFI has a great team and we look forward to continuing to strengthen our relationship in the years to come.”
Rob Charlton
CEO, bimstore

Since its founding in 2011, bimstore has been recognized as the premier provider and distributor of manufacturer BIM content. Virginia shared,

 "bimstore has done a fantastic job of building high quality content for the manufacturers they work with. They’ve built out an impressive database of product information and Revit content that specifiers, including our customers at UNIFI, are excited to use.”
Virginia Senf
COO, UNIFI Labs

UNIFI’s AEC customer base will benefit greatly by leveraging the data from bimstore’s impressive digital content library. They can also expect to speed up their project lifecycle by adding bimstore manufacturer content directly into their models, with a few simple steps, directly in UNIFI. Dwayne Miller, CEO of UNIFI Labs explains,

"UNIFI's partnership with bimstore enables us to streamline and accelerate access to great resources for customers. We are excited to work together in simplifying workflows and accompanying our users in their BIM journey!"
Dwayne Miller
CEO, UNIFI Labs

Are your ready to learn how access bimstore’s global, top quality BIM content, specified to regional standards, directly in your UNIFI platform?

 Watch this:

Interested in accessing bimstore content and trying out the rest of UNIFI’s features for yourself? 

Sign up for your free trial here: 

3.2 CORE Release Notes

Our latest software update for UNIFI CORE was recently released. You can now store, manage, and apply Revit material and fill pattern element types in UNIFI with just one click!

 Release Details:

New Functionality:  The ability to store and manage Revit material and fill pattern element types in UNIFI Core.

Bug Fixes:

– Content that was downloaded from and re-uploaded to UNIFI now overwrites properly in Revit.

– Batch exporting schedules will no longer fail when exported with the Revit French language pack.

– Select categories no longer appear twice.

– Increased the uploadable file size limit from 1GB to 3GB 

– Submitting content requests with an attached file simultaneously open in the Revit family editor will no longer crash UNIFI.

– The list of file extensions will now reset when the user selects the option to upload additional files. 

– The metric/imperial label will no longer appear on non-loadable family file types.

– Inserting a drafting view will no longer make Revit stick to the forefront.

– Exporting drafting views that have references to other views will no longer fail.

Click here for a free trial of UNIFI Core today.

Do you have suggestions for future updates or changes? Submit your recommendations directly in the UNIFI platform.

Revit API: A Quick-Start Guide For Beginners Part 1

By now, I’m sure you’ve heard the term “API”, but what does it mean? More specifically, what is the Revit API? 

A.P.I. is an acronym for “application programming interface”. In simpler terms, it is what software developers use to interact with an existing piece of software. Developers can use API’s to: 

-Execute commands on software programmatically 

-Bridge two pieces of software so they can “talk to each other”

-Extract raw data from a database that another application maintains. 

-And more… 

In regards to the Revit API, software developers have been leveraging this interface to build Revit add-ins and even Dynamo graphs. Yes, even Dynamo uses the Revit API to make changes or extract information from RVTs. 

Learning the Revit API is exceptionally difficult if you don’t have experience in writing code, but here are a few simple tips that will help you get started on automating some repetitive tasks or extracting data from Revit models.

For those of you that don’t know how to code: Learn Dynamo

Dynamo is a great way to tap into the Revit API because rather than writing code, you can handle powerful tasks using nodes. In software developer lingo, a node is like a function or method and is used to manipulate or extract data out of a Revit model. 

Although developers have the ability to create custom nodes using programming languages to speak to the Revit API (typically C# and Python), the good news is, you can create powerful scripts without writing a single line of code because all of the code that interacts with the Revit API is contained within the node itself. 

So, for those of you want to leverage the Revit API but don’t know how to write code, you can now create extremely powerful scripts simply by wiring up nodes, or what I like to call “connecting the dots”. Stay tuned for part two of this series, where I’ll show you how to leverage the Revit API using Dynamo.

For those of you who know how to code: Start with Macros 

The best advice I can give to coders who are looking to break into developing using the Revit API is to start by building macros. Developing macros in Revit is often overlooked; I’m assuming because they are open source (i.e., all of the source code is exposed) or perhaps developers simply don’t know that they exist as an alternative to developing an official Revit add-in. Put simply, a macro is an alternative to building a Revit add-in with some major advantages, particularly while learning the Revit API.

One of the major advantages of using macros for learning the Revit API is that you can compile and run code “on the fly” without needing to build a Revit add-in. In contrast, building a Revit add-in would require you to close your Revit application in order for Revit to overwrite the .addin file to the add-ins directory every single time you test your add-in. This means testing can be excruciating, especially during testing. 

Revit has a built-in macro manager which provides an IDE, Sharp Develop. Admittedly, it’s not the best IDE out there, but it gets the job done. The macro manager also allows you to manage modules at the application or project level, meaning you have the ability to either save macros in a particular Revit model (making it available to anyone who opens it) or save macros to your local machine (making it available to any model).

For both “noders” and coders: Dive In!

For all of you developers out there, I’m sure you’re no stranger to wading through pages and pages of documentation. The Revit API is no different. The Revit API will take some time grasp as Revit is a fairly complex piece of software in itself. If reading the documentation included with the Revit API SDK is painful, I recommend you check out RevitApiDocs.com, as it provides a user-friendly, web-based interface to help you through your journey in learning the Revit API. 

Really, the only way to learn the Revit API, whether using nodes or writing code, is to learn by doing. Start with something simple like a “hello world” application. Get a TaskDialog to display in Revit. Create a view. Model a wall or pipe. Get started and you’ll never look back.

To learn how to use Dynamo to tap into the Revit API, look for part two of this series coming next week.

Good luck!