20 Revit Tips, Workflows, or Automations in 60 Minutes

PHILIP RUSSO: Welcome to 20 Revit Tips, Workflows, and Automations in 60 Minutes. We will have a lot of information to present in the next hour. And because of this, we are presenting all 20 of our tips in video format. But the handout will go through much more detail, and most of this content will be downloadable on the Autodesk website.

Oh, my name is Philip Russo, and I work for Ramboll. Ramboll is a global company with over 17,000 employees. I have over 36 years in the AEC industry. My education and background is in architecture.

This is my third time speaking at Autodesk University. I've also spent seven years in the Autodesk Reseller Channel. My role at Ramboll focuses on Revit, the Autodesk Construction Cloud, Scan to BIM Services, and Digital Project Execution.

My co-presenter with me is Antonio Canero.

ANTONIO CANERO: Hi, everyone. My name is Antonio Canero. I'm Principal Implementation Consultant at Autodesk, and I have been working in the AEC industry for about 13 years. My education as well is an architectural education related and building engineering. And my expertise lies on the field of BIM, process optimization, automation, and computational design.

In the context of the Revit API, I'm going to start with the first tip. This tip workflow addresses the creation of views and placement on new sheets, together with the application of view templates within the project, aiming to automate the initial documentation process. We are going to be looking at the first project status. So there are no sheets in the project, as we can see. Neither are general arrangement views per level created.

So we will be triggering the External Command Tool tab within the adding. And we will select our class, which, in this case, is called Create Views and Sheets. What's going to happen in the background? We are triggering the code that has been done using C# language and the Revit API. And the workflow, what it's going to do is it's going to create views by level. It's going to create sheets.

It's going to place those views in the new sheets in the central location. And it's going to apply a view template to it. So we are going to be seeing the output shortly. As you can see, we have a set of newly created sheets with views ready for documentation purposes.

So we are going to be looking at the code quickly. The next step first begins with identifying the active document. The code flashes the title block required for the generation of the sheets, which is the one that we have seen before.

There is a section where we search for a specific view template, so that has been hardcoded. If the view template is available, the code enters in a loop to efficiently create views and corresponding sheets by floor level. So this is the loop that we are going to see before is the try except block that we can see.

And so then, what's happening is a transaction for each level start. And it generates a floor-level plan per view. This view is given a name, which we have defined RNSK, which, in this case, is going to be 1 to 200.

Then, we go into the view template application, so we apply the view template that we have chosen to the views. The desired view template will be applied to the newly created views then. And finally, we have the sheet generation and the placement of the views within the sheet in the center of the desired sheet.

And to finish the transaction, we have a handling error system. And that will be it. Thank you.

The next one is a tip that is about creating dimensions on walls for documentation. So again, in the context of the Revit API, this workflow is about automating documentation. During this tip, we will tackle the wall Revit category, but that could apply to any other category.

The goal is to automate the time-consuming process of adding dimensions across multiple floor plans for potentially very large projects. And so, again, we are going to be targeting the class, the command through the external tool in the Adding tab. So the code will take less than one second to automate the dimensions, as we can see for each wall section. This process, it can automate the documentation massively and free up the designer for more important tasks.

The code has written again in C# and is using the Revit API. The workflow will be then-- it identifies an external command class. This external command has implement the E external command interface.

And this allows the code to be executed in Revit, as we have just done. Within the execute method of the command, the code performs the following steps. So we can see there quickly. So get the active document, create an instance of the external event handler, and execute it.

The external event handler class implements an interface responsible for executing actions in a separate event thread is what we have been doing here. So within the try catch statement, which is what we are going to be seeing just below, I'm going to quickly explain what's happened. And with that, we will finalize the class. So it retrieves the active document and collects all the walls. But that could be done with any other Revit category.

It retrieves the lines from the walls, so we are going to be working with lines here. It creates dimensions for each of the wall sections defined by lines. Any exceptions that occur finally during the executions will be handled and display an error message in the task dialog.

And with that, we ensure that we don't have any problems. And that will finalize this code, having the final set of documentation drawings ready for the designer to work with. I hope you like it, and we are ready for the next.

So the next one is about automation of Revit to IFC export processes to PDF and to DWGs. So this is about a web service application that we have done together with Ramboll and Autodesk. This is supporting design automation different Revit plugins, we think. We are going to run really quickly through it, but it's just to give you an idea of what we can achieve.

So the goal of this application is simplify the data conversion processes. It has been designed to help the user to create schedules, to export files from one software to another. So it this application support, as we have said, Revit to IFC, PDF, and DWG.

So let's take a closer look into it. So each user can choose the hub. You can choose also the projects within the hub. And now we are seeing the project within the hub that we have selected.

The first thing that we can do is select one of the projects, and then we will see all the schedules created within this project. The information goes from name, frequency, description, but also, we can activate, as we can see, the activities schedule. But also, we can execute it directly from here. But more importantly, we can add schedules or edit them.

So if we want to see the entire user interface when creating an schedule, we can see this is our basic information tab where we are going to add the information of the schedule-- name, description, start date, and end date. And also, at the end, we are going to define the activity that we want to select. So in this case, we are going to have three main activities for different Revit versions. And those are the ones that we have mentioned-- so Revit to IFC, PDF, and DWG.

And once we have done that, the next step will be about selecting the folder within ACC. So this application is actively interfering with ACC. So if we change something in ACC, it will automatically be changed here. We can access to the output folder.

And then in the next slide, we are going to basically be selecting our files. So this is going to be the file that we're going to be working with and the view within the file. And finally, we will have a summary of all the data that we have selected for our schedule to be run.

So if we select Complete, then we can see our newly created schedule. And we can either wait for the execution time on a weekly basis, or we can just execute it. In this case, we are going to execute it.

And finally, we will go to the Schedule Results tab where we can see the status of our schedules. So as we can see, there are many of them in Pending status. That's why we have been triggering couple of them.

And they are still on Executing mode. And once it's finished, the status will become Succeed. If the schedule failed, we will have a status related to it as well.

And that will basically provide us with the output file within the output folder that we have selected, and it says here, ready for consume. And that will end the process.

Next one, next Revit tip is the tip number 4, and this is about automation of model walls from CAD files. So this Revit-related tip is about automating the process of creating geometry within Revit from a CAD file. During this presentation, we will be covering only one model category, but that can be extrapolated to many others. As we have said, that could be extended to floors, roofs, doors, windows, columns, et cetera.

So the tip is based in a C# plugin using the AutoCAD API and the Revit API. We will be triggering our command from the external toolbar from the Add-ins tab as well. The CAD file needs to be well structured. That is quite important for this tip. And we are going to be working with parallel lines for the walls.

It will need to be well structured also for any other model elements, such as doors and so on. So the code will be looking at a specific link file, as we have seen. We have triggered the code now, and it's going to be creating a model element, wall element, for each of the elements that maps from a specific CAD layer within the link CAD file.

And as you can see, we are going to be modeling potentially hundreds of walls in a couple of seconds. This will really speed up the process of modeling from CAD, and it will free up the designer's time for more important tasks, as you shall. And there, you have it. This is the output.

This is a really quick tip, and it's about Auto View Alignment. So as we can see, I have just reshuffled a little bit two views within the sample file of Revit. What we are going to be doing is, again, triggering the external tool command. And basically, what's going to be doing in the background is going to just relocate those two views into the center of the sheet.

The location has been hardcoded in this case, but that could be extrapolated to any potential different layout. So if we have more than two views, the developer can actually create the layout depending on how many views are we going to be working with. So in couple of seconds or probably less, whenever we trigger our command, the views will be nicely located in the center of the sheet. That can be applied across multiple sheets within the project to speed up the documentation process again.

Yeah, there we go. Thank you, Philip. I believe I hand it over to you now.

PHILIP RUSSO: OK. In tip number 6, we're going to talk about a drawing log application. So at Ramboll in the Americas, we have a drawing log that stores our latest sheet information, sheet title, and latest revision information. And this, of course, is a manual process, so we came up with a way to automate this.

We developed an application that allows us to browse to a default, Excel start up template. And then from there, you can select a DST file, which will be a sheet set in AutoCAD. And then, you can select different Revit models based on the discipline.

So you'll see here, the Excel spreadsheet template was selected. Browse and select the DST file. You'll notice that it'll grab all this information externally without launching the AutoCAD application, and you'll see the drawing information show up below.

One thing with Revit, though, when it selects the Revit file, it goes ahead and launches Revit, grabs the sheet information, then closes out of Revit. So this does take a moment when you go through each of your Revit models. But again, you'll see below that it'll populate the data. And one thing that you'll notice when the data comes in that it also is placing all the G sheets for each discipline. So instead of worrying about the order of the sheets, the application goes through and does that for you.

Once this process is done and you're done selecting your models, down at the bottom, you'll notice an Export button. And the Export button will export it to an Excel spreadsheet. And in a moment here, we're going to take a look at that output.

And one thing that you're going to notice in the Excel file is that not only does the drawing log get filled out, which is stored with the project, but it creates an additional tab called Drawing List. So it consolidates that information so that you can link it into AutoCAD or Revit on your cover sheet.

And then, all this information in the app can be stored as an XML file. So before all your deliverables, you can simply open that Excel file and redo the export, and it'll update the spreadsheet, which is also linked into your model. So it's a good way to eliminate that human error when you're maintaining your drawing list information.

Now we're going to take a look at some Dynamo scripts. This one here, it automatically places the correct view title underneath your views in the model. So in this example, for our plan views, we just label the view name, the scale, and the corresponding scale bar. For building sections and elevations, we also include the number of the view, the name, the scale, and, of course, the scale bar. And then for details, we do the view number, the name, and then NTS for Not To Scale, with no scale bar included.

So now we're going to switch over to Dynamo, and we're going to take a look at the script and how this works. So at a high level, there's a couple packages that are required-- the spring nodes 204.1.0 and then archi-lab.net 2022.212.2722.

The script requires some inputs, which are the view-specific families that are used for the view titles and the scale factor, so that Dynamo knows which scale bar to grab based on the view of the scale factor. Once that information is done, the script goes through and collects all the view port scales in the model. It grabs all the different view types.

And then once it has all that information, it passes it through a few different filters, which it'll assign it to the appropriate views. So of course, we have all the section views. And the next one it's going to find all the plan views and apply the appropriate view, title, and scale bar. And lastly is the drafting views.

So if we go ahead and run this script, first on the Revit sheet, I got to spread out these titles here to put them under the appropriate view. And then I'm just going to change them to a generic view title. And now we'll switch back to Dynamo, and we'll go ahead and run the script.

And then when we switch back to Revit, we'll see the correct view titles were placed under the views. And this will do this on all the sheets through the whole project. So the base code is there where you could just swap out your view title families and be able to leverage this code.

This next tip we're going to talk about is creating multiple back references. Revit out of the box will typically only allow you to back reference one sheet where the section or detail callout is referenced. So I'm just going to go a first floor plan here. I'm just going to cut a section.

And then we'll go ahead and place this section on a sheet. And then because this is multiple stories, this section will show up in other drawing sheets. But you can see here initially that the view title has a specific family, and you'll see that the back references currently are not indicated.

So we'll go ahead and take a look at the Dynamo script. And once Dynamo opens, we'll go ahead and open the file, and we'll take a look at how it's organized. at the beginning here, you can see it's going to grab all the views on all the sheets. We have the view title families.

And then we're going to filter it through, collect all the reference views, and then it's filtered. And at the end, there's a Python script which helps set the parameter that it's looking for to assign the correct view title and scale bar. So once the script runs, you'll see that now we have the appropriate view titles with the back references.

OK, this next Dynamo script can be used to auto number mechanical equipment in your project. And we mechanical equipment always has several different things. So in this example, I just have pumps on three different levels.

And I just placed a couple tanks to show that they're going to be ignored because they're going to run through a certain filter. So selecting a pump, you could see that the instance mark is blank. And we want to be able to label them based on what level they're on and then sequentially based on the floor.

So we can see here that we're grabbing everything by category, which, of course, is mechanical equipment. And then, we're going to filter it out based on a parameter, so it just isolates all the pumps. Down below here, there's a dictionary which creates the different levels, assigns it as a prefix, and then there's going to be a range based on the quantities on each level. Once that's done, that all passes through to create the instant marks.

So once we run the script, and we'll switch back, I'm selecting the pump. You can see the label. So we have the level prefix and then the sequential numbering based on how many are located on that floor.

And the tanks are being ignored, of course, because they're not part of the filter that filters out the mechanical equipment. So the framework of this script should be very easy to use to be able to number your mechanical equipment effectively in your models.

ANTONIO CANERO: The next Revit tip is about changing the text to uppercase. So basically what we are going to be doing is we are going to be accessing to all the text nodes from the file and swapping them from lowercase to uppercase. Based on clients requirements or internal standards in the middle of a big project, we might want to swap all our annotations to uppercase. These Dynamo scripts allows you to do so in couple of seconds.

So as soon as we run the Dynamo script, we are going to see that our text becomes uppercase. And that will be effectively done across all the views within the project. And so that's going to save us hundreds of hours, maybe. And we are going to achieve a consistent result super quick.

So looking at the workflow, what we are going to be doing basically is gather all the text nodes from the project. Then, we will be harvesting all the text from the text nodes. And a Dynamo script is going to be in charge of swapping those lowercase to uppercase.

Of course, we have already uppercase in the project, and those will stay static as they are. But those lowercase will become to be uppercase for consistency. And at the very end, we are going to be just swapping those lower cases for the uppercase in our project. Like that, we will be just automating the process of, yeah, documentation in this case.

We can go to the next one. In this Revit tip, we are going to be looking at adding and removing shared parameters. So and this can be really useful when managing big projects with many files that we need to standardize, so our project share parameters across all of them. And we will be using a Dynamo script for that.

And what we are going to be doing first is add the shared parameter from a shared parameter file. And after, we will delete it on request. So this file initially did not have any shared parameters added into the project.

So once we run the shared parameter, added the Dynamo script, we will be seeing how, in a couple of seconds or even less, we are going to be adding hundreds of shared parameters to our project. As soon as the DynamoDB script finished, we are going to be quickly checking how many of those we have. So we have there many of those parameters added into the project, and they become available for the user to use.

The next thing we are going to be doing is we are going to be opening our new DynamoDB script that is about deleting the shared parameters. So we are going to be deleting shared parameters on request. That's going to allow the user to basically select which shared parameters we want to delete and do it in an efficient way, which is normally pretty complicated without using Dynamo Because of the UID. So here, we are going to be looking at all the shared parameters that we have been just added.

We can select them on request. We can select them all. Depending on how many shared parameters we have, it may take a couple of seconds, maybe. In this case, we are adding many of them. And then we can unselect them all as well.

And finally, just for the purpose of the demonstration, we are to be selecting a couple of them. And when we select parameters, they will be added to our project for the use. So yeah, this is the Revit tip of adding and deleting shared parameters.

Next one is about manipulating with revisions. So what we are going to be doing here is adding revisions to sheet automatically. And we will use a Dynamo script for it. So if we review the current document, we can see that there is no revisions assigned to the project. Sorry, there is a single revision assigned to the project that hasn't been added to any of the sheets.

So we are going to open another sheet just to clarify that. So we can see that none of the sheets has been added the revision. So what we are going to be doing with this Dynamo script is we are going to gather all the elements of the category sheet. We have the revision on the project, so we are going to select this revision straight away. We have only one.

We have a Boolean operator. This is going to be triggering the Python, script and it's going to be allowing the Python script to run and to apply the revision to all the sheets. So if we open the Dynamo script-- sorry-- the Python node, this is the core of this script.

So what we are going to be doing here is we are going to import all the required statements. We have the initialization. Then, we have the input data process where we have three lists, and the lists are the list of sheets, the list of revisions, and the Boolean value, which is called run it in this case.

Then, we have the main logic straight out. So this is the run it. So the main logic is a conditional block. So if the Boolean operator called run it is true, then the script enters in a try/accept mechanism.

So this is to try to avoid any potential errors. Inside the try block, it iterates through each sheet and revisions in the input list. For each sheet, it will retrieve the existing revision IDs.

So basically, what it does is check if the current revision ID is not within the list of the revisions within each sheet. So if this ID is not, it will add it into the sheet. So it basically check, OK, does this sheet have the revision assigned to it? If not, it will assign it.

And finally, it will ensure that the transaction has added the revision, and it will just finalize the script. So if we run it-- that, we are going to be doing it that in a second-- we can see how the revisions will be added into the sheet. And that will happen across all the sheets in the project. So yeah, this is a really good process automation for documentation as well.

And with that, we finalize this tip. Next one is about adding room tags by level. So this is going to be a really quick one. And basically what we are going to be doing is adding room tags across different levels from a link instance.

So what we have here is we are working on our NEP model. And we have our link architectural Revit instance. The architectural link is going to have all the geometry and rooms. So we are going to use a Dynamo script for it, and it's going to be applying room tags to all our rooms by level.

The code of the script is a Python script that basically what it does is gathers all the views-- the elements-- in this case, the rooms, the tags, a couple of parameters associated with the tag, and the location of the tag. And finally, it's going to select the link instance. And if we run it, we will see that it's going to add the room tag by level across all our views-- really good for automating as well documentation processes.

And that's the end of our tip. Next one is tightly related, so what we are going to be doing is we are going to be renumbering our rooms using a split line. So we are going to be using a Dynamo script as well for it. The first thing that we need to do is select and split line.

So we are going to be selecting the model element. And for that, we actually need to draw the split line. So we are going to be drawing a fancy split line across all the rooms.

And at the moment, we have a specific room numbering sequence applied to our rooms. But we want to modify it, and we want to do it in a fancy way. So we are going to be going up and down, up and down again.

As soon as we have finished our split line, we are going to be triggering our Dynamo script. Select the split line and run our script. So whenever we have run it, we can see that we have changed the sequential number and name of our rooms.

In this case, we have used a specific prefix and a basic sequential sequence, but that can be implemented in many different ways. We can add suffix, prefix, and the sequence required. Yeah, it's great as well for documentation purposes.

So the next tip is, again, using a Dynamo script. And what we're going to be doing is basically upgrading Revit families from, in this case, 2023 to 2024. That can be applied to Revit families, Revit files, or templates.

So in this case, we're going to be using this Dynamo script with the assistance of a recent package, which is a great one. And the workflow basically is what we're going to be doing is we are going to be selecting a folder where we are storing all our files. In this case, I have just stored a simple file. It's the sample architectural Revit file in 2023.

Within the folder, we might want to add as many files as we wish. So then what we are doing is, basically, we are opening a Revit session in 2024. We are opening our DynamoDB script in 2024. And what we are going to be doing basically is we are going to be selecting our directory file. We are going to be opening those files in the background in Revit 23 in our Revit session in 2024.

And basically we are going to be closing them. So in this way, we are going to be opening all the version and saving it back. Since we are having our Revit 2024 version open, it's going to be saved in the latest version. And that can happen for a single file, but for multiple files as well. And it will automate the process of upgrading all our content to a newer version and save it back into the folder.

So yeah, now it's finalizing the process. And it will be saved consequently in the desired folder that we have just selected. Yeah, there we go. It will trigger another one, and so on, but that's the process of upgrading Revit family content into 2024. And with that, we have finished our Dynamo tip this time.

PHILIP RUSSO: OK, now we're going to take a look at some Revit families. So the first one we're going to look at is using formulas to size a structural footing. This is a basic family just to leverage global parameters and formulas within your Revit families. So a simple formula for sizing a structural footing is to take the load from the column placed on the footing and divide it by the soil capacity. What that'll give you is the overall surface area required to size the footing.

So in a moment here, we're going to go up and, we're going to first set up our global parameter. So by making a global parameter for the soil capacity, that may be able to be leveraged elsewhere in my project or other formulas within family. So it makes sense to create a global parameter out of this value.

Next, we'll take a look at the family itself. And a footing, of course, is about as simple as they come. Just having the length, width, and height.

And if we take a look at the properties, we'll see there's some basic parameters here- one for the footing length. Then, we have the structural load. Those will be my two manual entries.

And then the soil capacity, we're going to link to the global parameter. So that's the benefit of global parameters. You can link them to your parameters within your families.

Some of the other formulas that you see in here simply is just dividing by 1, just to round up the number. So they work in the formulas to calculate the footing width. And when we switch back to the project here, you'll see that we can make one adjustment-- the length or the structural load.

And then the width will be dynamically updated based on the Formulas embedded in this family. So it's just showing the structural load divided by the soil capacity gets the required area. And then, of course, you get area by multiplying your length and the width.

So now we can see in the project when I select the footing, I can go ahead and adjust my length. You'll see the footing adjust automatically. And the same goes with the structural load. Once I adjust that, it goes ahead and adjusts it. So the purpose of this is just to give you an idea how you could leverage global parameters and formulas within your families.

This next tip we're going to take a look at is just how do you create a barrel tile roof in Revit? A little better than just assigning a generic material, you get more of a 3D view and actually the tile shapes. So to break this down, we'll take a look at the ridge. And the ridge is just a simple array family.

So we just model one tile. We do an array, and we can control the array distance and the number of tiles required. So that'll allow you to adjust it to match the width of your gable ridge. And then, the main roof is just a sloped glazing roof.

The one roof is just showing the thickness that might represent the trusses. And then the other roof that was drawn is just a sloped glazing roof. And if we take a look at that, we can see that it's made up of a curtain panel.

So the curtain panel family is actually one barrel tile, which is 1 foot by 2 foot in size, and then the grid spacing is 1 foot by 2 foot. So basically each panel gets one barrel tile.

But within that family, there is a variable to control the length of the tile, so we have a little bit of overlap. So the tile can be a little bit bigger than the 2-foot and length, so each tile overlaps. And then just a generic 1-by-1 frame was added, just some thickness thicknesses there to fill in the blanks during a rendering. But again, just a simple way it can be done very quickly to create a barrel tile roof.

ANTONIO CANERO: This is a corner window Revit family. This is a window Revit family that can be used in projects where we may have many windows with different angles inside the project. So as we all know, we want to standardize the changes, and we want to automate the process of updating families when we are working in large projects. That will allow us to use the single family across all our project.

And if any updates are required, we can just update it all the time within the same model element rather than using many different Revit window families for each of the possible angles. And like that, we can ensure consistency and avoid some risk.

So we are going to be looking at the different possibilities. That's going to be pretty quick. I have assigned here this angle, 125.

That could be all set up with global parameters. We didn't do it in this case, but what we are going to be doing is we are going to be changing the angle of this wall to a 90-degree angle. And then we are going to be changing the family type in this case, but that could be instance really easily.

And like that, we can see that the Revit family has been applied nicely for the desired new angle. And we are going to be looking at a new possibility, which is going to be a lower angle-- in this case, 45 degrees. And we will be seeing as well that the family change accordingly to our needs. So yeah, that will be all. Like that, we can ensure consistency and having a single family across all our projects.

PHILIP RUSSO: OK, tip number 19 is going to be a steel lintel family. So this basically is showing the whole family on one drawing sheet. Based on the length of the opening that the lintel is going to cover and the width and height, different steel is within the lintel to support it. So there's different lintel types based on the opening. And then based on the sizes, this is showing the different steel end section that will be used.

And all this is done in one family. So what we're going to do is take a look at the family. And once the family opens, you'll see all the different steel shapes that are in there. If I look at the properties, you can see all the different visibility settings. So we have to figure out which one to turn on, and that's where the formulas come into play.

So here, I just copied and paste the formulas in a Word doc, so you can break it down. So you can see the length and the thickness will define the type of lintel that it is. And then the formula below, based on those results, it's going to assign the visibility number.

Now, you see some strange numbers like 108 and 112. That's just leaving some spaces in case you had to Insert a different lintel type within the formula. So here's where you see those numbers, and it'll allow you to add other visibility values within this family without rewriting all the code.

So back to the project, you can see down the left-hand side here all the different lintel types. And then the section that is cut, it's showing all the different steel. But it is the same family with just a different visibility value turned on. So again, just to get you thinking, build some engineering into your families. And this is just a sample of a steel lintel.

And for the last tip is just a workflow tip, and left this one to the n because we knew we were going to have a full hour here. And this is basically the bridge function in the Autodesk Construction Cloud. So I have two projects set up here.

One project would be an as-built model that is just being maintained, so the client always has an updated as-built model. And then there may be several parallel projects running alongside, maybe an addition, maybe some change within the warehouse or the building that you're working on. And Bridge will allow you to bridge your main model to the other projects.

So going to the Bridge function, you go to Bridge a Project, put in the email address to the person I want to invite to bridge their project. You can put in a little description here. And what that'll do is it's going to fire off an email here that we're going to see in a moment so that the person can accept the invite and activate the bridge between the two projects. OK, so now the email is going to get sent. And show you what the email is going to look like.

OK, so it's telling that I want to bridge a project with myself, basically. So I go ahead and choose that. Now what I do is I drill into the project, select my addition project that I want to bridge to, and bridge the projects.

So now that that is done, I can see that there's a bridge set up in the project. So now I'm going to return back to my as-built model, my as-built project, and I'm going to go ahead and share out the file and folder that contains the as-built model that I want to bring over into my edition project.

Notice here that I want to share with another project, and I want to automatically update. So if the as-built model updates, I want that pushed forward into my addition model or any other project running simultaneously that needs access to that as-built. And so now I'm just picking the project, and then I'm drilling down to put the folder that I want to share this model to.

So now that the bridge has all been established, the file's been established, I can now go back to Revit and start working on my addition project. So now back in Revit, just going to do a standard Revit link here. Going to bring in that Revit model from the shared folder.

And once the model is brought in here, I'm just going to draw a couple of walls indicating the location of the addition. And then once I do that, I don't show the next step, but I'm basically going to jump into the as-built model, add a couple of walls, and once the modification is made, you can see here that they came through into my addition project. So again, this is just demonstrating the Bridge function, which now works with work-shared Revit models.

So thank you for attending our class. The goal was to present some ideas, concepts, and content that you could take away and enhance your own digital design journey.

ANTONIO CANERO: Thank you.