Fusion 360 Multi-User Assembly Design Collaboration

TYLER HENDERSON: Hi. Welcome everybody, to Fusion 360 Multi-user Assembly Design Collaboration. My name is Tyler Henderson, and I'm working with my colleague John Helfen. Go ahead and do a quick introduction of ourselves. So I'm based out of Portland, Oregon. I was previously an Autodesk customer. I worked in the industry-- mechanical engineering industry for about nine years using Autodesk software.

And then I started working at Autodesk, working in Inventor, Autodesk Inventor. I started out working on assemblies and sketching, and then I moved into working in Fusion 360 and simulation areas, generative design, and assemblies. So I've been doing user experience design on those products during that time. So go ahead and let John introduce himself.

JOHN HELFEN: Thanks Tyler. My name is John Helfen. I'm based in Troy, Michigan. I'm a product manager in the Fusion's Design and Engineering team, and I've been at Autodesk for 25 years in a number of different roles. Started out answering phones on the support desk for products like Mechanical, Desktop, Ingenious, and have since then been supporting the Inventor from since before it was even Inventor.

I've spent time in Education, along with managing products like Buzzsaw and Tinkercad. So I've had a lot of experience with cloud-based products. And along the way, became a Maker. I do a lot of work with 3D printing and CNC stuff, and it's kind of led me towards Fusion 360. But I've been doing this quite a long time and been working with Tyler for the last couple of years on improving assemblies in Fusion.

TYLER HENDERSON: Great. Thanks, John. So let's talk a little bit about why we're teaching this class. So John and I started working on different tools for assembly, design, and collaboration in Fusion 360 before the pandemic hit. So you know, we didn't necessarily plan for the pandemic. Nobody does, right?

But when the pandemic hit, it forced a lot of people to work from home. You were no longer being able to be in the office. You couldn't go into meeting rooms and talk to each other, get on whiteboards and hash things out, or just go over to somebody's desk and ask them a question about a model or make a suggestion. Things had to be a lot more remote, right? Also, when you're remote like that and trying to collaborate, it gets a little bit difficult.

Because in the traditional methods, waterfall methods of engineers and designers working on their particular areas, you had to wait for someone to finish their work before you could work on yours. So this causes longer lead times and increased overhead. So being able to collaborate on an assembly in Fusion 360 at the same time makes you a lot more efficient. So I'm going to have John talk about the things that we have been doing in Fusion 360 to facilitate this.

JOHN HELFEN: Thanks, Tyler. Yeah, as Tyler said, who can predict a pandemic, right? We all are experiencing this in a new way, obviously, but what's important here is that we were headed towards the world of cloud for quite some time. The pandemic essentially just accelerated people's need for that.

When everybody was sent home and had to be working remote, those people who are already using Fusion went home and simply logged in on their home systems and had access to their data. So this is really just drawing more attention to the need to have better access to those things, and Fusion provides that.

One of the things we ran into is in these team collaboration environments, too. We have a lot of people coming from places like Inventor or SolidWorks or traditional CAD systems. And what we really wanted to do is make sure as they came into Fusion, the experiences were things that they were familiar with. So when editing external files, being able to edit something within the context of an assembly.

But not only that, as you work closer with people, one of the things, if you've ever worked in a team, that you often run into is bumping into people. Just being in proximity with people in the design space. If you haven't experienced it yet in a team, it's likely going to happen that you bump into people and step on their work. And really, what we wanted to do is help eliminate that.

So we've been spending time on improving the reservation system and Fusion so that you can actually see who's working around the design with you. You rarely get into an office app anymore today where you don't know somebody in the file with you, or in the design, whether it's a PowerPoint or a document. And the same should be true for CAD. And that's what we will be looking at, is ways to better understand who's around you while you're collaborating in teams.

TYLER HENDERSON: Great. Thanks, John. So we're just going to take a quick look at what we're going to talk about today. So we're going to introduce some of these topics, and we're also going to do live demonstrations in the Fusion 360 of these. So we're going to talk about team members and avatars, which give you, basically, the presence of other team members if they're working in the same design as you. Or even if they're not in the same design, at least you can tell where they are and what they're working on.

We'll talk about design reservation, which is a way for people to implicitly reserve a design that they're editing and prevent other people from stomping on their changes or saving other versions over theirs and losing design history. We'll talk about edit and place, which is the ability to edit external components in the context of an assembly.

And Assembly Context, which actually captures reference geometry from the assembly when you do an associative edit in place. And then we'll talk about Reference Objects, which lets you explicitly choose geometry and an assembly to reference in a component, so you don't have to actually work in that assembly. You can get out of the assembly and design that component.

So we're going to switch over to-- actually, we're going to just introduce edit in place first. That's the first thing that we're going to demonstrate. Sorry, not edit in place. We're going to talk about team member avatars and design reservation. So design avatars, as we talked about, they give you the presence of other team members, right?

So they are essentially colored disks that appear in the user interface with that person's initials on them. So you can tell the difference between different team members when you have multiple people working on the same design. They'll appear in the document tab, they'll appear in the model browser, and they'll also appear in the data panel.

And then implicit reservation is, like we said, the ability to implicitly reserve a design that you start editing. So it happens automatically. It's not something you have to do a manual check out or check in, just happens once you start editing. You'll reserve that file.

Other people can actually open that file and start working in it as well, but they can't Save changes as long as you have a reserve. And then once you save your changes or you close that design without saving, the reservation is automatically removed. And so it lets other people save their changes.

So we're going to switch over to Fusion 360 and actually show what this looks like. So here, I have an arcade assembly open. And if we look up here in the document tab, I see John Helfen's avatar. So the yellow avatar with his initials up here. And if I mouse over this, I get a drop-down that tells me exactly what he's working on in here.

So I see he has the controls assembly open, the front plate open, and he has the whole assembly open, obviously. As I mouse over each one of these, I can see them highlighted in the canvas. And if I click one, it's a bit more highlighted and it's actually selected. So I can see really closely where he's working in this assembly.

The other thing I see is, on this avatar on the controls assembly, is a white dot. That white dot indicates that he has that design reserved. So it tells me that he's actually editing that design. And so that's a good indication that I don't really want to be working in that same design or try to save anything. It's not going to let me save anything until he's actually done editing.

If we look over here in the browser, we show the avatars on anything that another team member has reserved. So as I pointed out, John has the controls assembly reserved. That's why I see his avatar in the browser on that component. Now, again, reservation only happens on external components. So John will talk about that here in a minute.

But I also wanted to point out the avatars appear in the data panel over here. So I see John's avatar on the front plate, the controls assembly, and in the arcade assembly here. And so anybody else in the team can go open up Fusion, they can go to the data panel, and they can see who's working on what.

They don't necessarily have to be in the same assembly or open up a design to see who's in there, they can just go to the data panel. You'll also be able to go look at that in Fusion team. So we're going to switch over to John's computer and we're going to see what he sees, and he'll talk a little bit about internal and external components as well.

JOHN HELFEN: Thanks, Tyler. Now that you've heard what the icons look like, I wanted to take a second and show what it looks like from my side. You saw what Tyler was showing. And just like you saw from his side, here at the title bar or in the document tab, I can see that he has this assembly open. And just like he saw, I can actually see that I have this controls assembly open, as well.

And I've got it open in a different window that I'm editing, and this is the assembly I'm viewing. So you can just see-- I also see the same information in the data panel, as well. As Tyler mentioned, it's important to know that a lot of the collaboration functionality that you're seeing here and we're talking about is very specific to distributed designs or external files. And in this assembly, we've chosen to use some internal and some external.

And this is something you'll need to do or want to do as you prepare for any team driven type collaboration, is have a discussion about who's going to be working on what. And based on that, you'll make decisions of whether those components need to be internal or external or what would be best. If you don't know, it's often better to start with an external file because it's very easy to make those internal. All you have to do on any external file is right click and select break link, and it will make it internal.

If you've got an internal file and you need to get it out of the assembly, you can use the derive functionality. But let's take a look at where those show up here. You see the external files here in the browser. They're represented by the link icon. And then just above that, we have a couple internal components that we've created. And these are really just design tools. They're envelopes that we're using to control the size and shape of the assembly.

But nobody really needs to collaborate on those, and so we kept those internal just for speed and efficiency. But all of the other components we know we might use in other assemblies, we may separate and have specific team members be detailing them out. So we chose to make those external.

So it's important to know that, because you may have certain situations where you create an external file in order to distribute some information, but then even in that external file, use internal components for flexibility reasons and different scenarios. So it's important to know the difference and consider them at the beginning of a design process.

TYLER HENDERSON: So we kind of mentioned edit in place earlier relative to external components. So one of the benefits of external components is the ability to edit them in the context of the assembly. Now, of course, you can do that with internal components, but the external components provide the ability to collaborate in an assembly. So when you have external components in an assembly, you can actually edit them in the context of the assembly without actually having to open them in their own tab.

So when you do Edit-In-Place, you simply right click on the component that you want edit and choose Edit-In-Place from the menu, or you can hover over one of the components and use the flyout pencil button that appears and click on that. It puts you into Edit-In-Place mode, and you'll notice that with a blue border around the screen. And you'll see a toolbar appear at the top of the canvas that tells you you're in Edit-In-Place.

Now, you have two options when you go into Edit-In-Place. You can do associative or non-associative. So non-associative is just basically like opening up that component in its own tab and doing the edit, except you can still see all of the surrounding components from the assembly. You just can't reference any of them. You can't select them for references or anything like that. So you're just focused on only editing that one component.

Now if you do Associative Edit-In-Place, that actually lets you select other geometry in the assembly. Other components, sketches, faces, anything in that assembly that's in other components. You can select them for referencing. So you could do sketches in the component you're editing, and you could project geometry from other components. Now when you do that, it actually creates a reference, or actually, an associative reference, and we captured those references in Assembly Contexts, which we'll discuss in the next section.

When you do Edit-In-Place and you finish, then when you click save, it will actually save a new version of that component that you just edited, as well as a new version of the assembly, so it can consume those changes it made to the component. So we're going to switch back over to Fusion 360 and we're going to show what Edit-In-Place looks like there.

All right, so I have another version of the arcade assembly here. And what I want to do is put some speaker holes in this bottom marquee. So you can see I have the speakers already in this assembly. They're external components in here, and they've been inserted. And so I actually want to use the geometry from the speakers to create the holes in that bottom plate. So I'm going to go ahead and start Edit-In-Place on that bottom marquee.

Just click the pencil button here, it puts me into Edit-In-Place mode. It tells me what component I'm editing, and when I start creating references it'll actually create a context. So you'll see that happen here in a second. So I'm just going to do a sketch, and then I'm going to project geometry from these speakers. And I want to just grab the outside of these speakers so I can get the proper size hole.

So this is a nice way to do this because I don't have to guess the whole size or measure it and draw it manually, I just project it from those speakers and then I have the information I need. Now one of the cool things about this, as we talked about, is collaboration. So while I'm actually working on this bottom marquee plate, John can be working on another part of the assembly and doing Edit-In-Place on components there. So we're going to switch back over to John's computer and see what he's doing.

JOHN HELFEN: All right. Thanks, Tyler. As Tyler mentioned, just because he was editing the assembly doesn't mean that I needed to stop. And this is often in traditional design environments where the stomping happens. This is where we might run into a situation where I have changes that I've made to something, and Tyler has made changes as well, and often those are the cases where it's whoever saves last wins.

If I save my work and then Tyler saves, he stomps on me. And the reverse is true as well. And that's not the case here. As Tyler started editing the assembly, I saw that. The collaboration icons let me know that he was changing things or that he had things open, and that he was changing things actively. And that didn't prevent me from opening the assembly, getting into this design, and doing some work.

And while Tyler was working on getting those contexts set up for reference on adding the speakers, I was adding some fillets. I was using my basic modeling commands to do general updates. Now, what's important here is, because Tyler was working on the assembly, I'm making what are known as non-associative edits. This is really like me opening the file in its own window and making edits and changing it.

Once I come out of this and I save this, Tyler would be notified that a change happened, and he would be able to bring that information into his assembly. But what's important is, when I came in here, I knew Tyler was in the assembly. And if I just saved this and moved on, it wouldn't be any different than what you would be used to in a traditional environment. But what's important here is that Tyler has clearly made changes.

You notice when I came out of Edit-In-Place, I have a new icon here in the root of the browser and here on the top toolbar as well. And that's telling me that Tyler has made changes. And I knew that going in because I had seen his reservation on the feature. So I knew to expect changes coming from him, and that's what we're going to do here. So all I have to do to get Tyler's information is, I can go ahead and say get later.

By doing that, what we end up with is Fusion sending the changes that Tyler has made to me while I have changes in memory. And what's important is, now I can see the changes that Tyler has made. And I can also see the changes I've made. I've rounded these corners. I've enabled some venting. And now, I can see both the changes for all of the assembly components that we need, and now, I have the ability to save those changes.

And by doing that, I'm capturing both the assembly that contains Tyler's changes and the upper side plate that contains mine. So essentially, we avoid the need to stomp on each other or eliminate the chance that we do that, and we have an opportunity to have all the correct information.

TYLER HENDERSON: All right. Thanks, John. So now we're going to take a look at some of the context. John is going to introduce us some of the context that get created when you do Associative Edit-In-Place.

JOHN HELFEN: Thanks, Tyler. As Tyler mentioned, in the previous section when we're working on Edit-In-Place, you saw Tyler creating context. The difference to how he's doing it and what you'll see as we move forward was, he was just doing standard modeling operations. What's important here is contexts make an associative connection between an assembly and an external file during the Edit-In-Place process.

And it's important because, in the assembly when we make these references, essentially, you have the ability to distribute information, positions of things, geometry, construction information, references from the assembly, into the external file. And the reason for that is, most people don't want to be in the main assembly. You want to have this distribution of the information, but you really want to focus on the things that are important to you. And contexts provide that capability.

What this does is, when Tyler was projecting the information from speakers in the assembly, those contexts were being created automatically. And then when he opens that component on its own in its own window, those contacts can be activated. And he has access to what he needs from the assembly without having to have the entire assembly open. And the nice thing about that is, these links are associative.

And the reason that's important is, if something changes in the assembly, those contexts will become out of sync, and Tyler or I on the assembly side or on the component side will have the ability to synchronize those contexts and pull that information in. So even though you're not actually working in the assembly, you have all of the information you need from that assembly in order to move forward with your design.

TYLER HENDERSON: All right. Thanks, John. So let's take a look at what Assembly Contexts look like in Fusion 360. So as you can see, I have a version of the assembly open here that has the holes in the marquee bottom plate. So I created those holes using Edit-In-Place. And when I did that, it created an Assembly Context. So over here in the browser, I expanded the marquee bottom in the browser and I show the Assembly Context here.

Here's the speaker holes context that was created when I projected the geometry from those speakers. If I click on that, you can see down here in the assembly timeline, we have a representation of that context, as well. So I want to show you what this looks like when I open up this component in its own tab.

So here's that marquee bottom in its own tab. And again, I have the Assembly Context, the same ones that you saw in the assembly, and I can go ahead and activate one of those. When I do that, you actually see the geometry of the components that I projected. So it's actually projecting the bodies that I selected. And if I expand this a bit further, you can see those two bodies here. So it doesn't bring in the entire component. It just pulls in the bodies of the entities that I projected.

Now here's the really cool thing. As I continue-- I can continue using this context to make more edits. And I need to put some mounting holes in this plate for these speakers. And so I'm going to go ahead and do another sketch. And I'm going to project those holes.

Now while I'm doing that, John can still be working in the assembly. So even though I've got this part open in it's own tab and it's got those references from the assembly, John can be working in the assembly and making other changes. So we're going to switch over to John's screen and see what he sees.

JOHN HELFEN: Thanks, Tyler. As Tyler said, he's going to continue on with his work, just as you saw him moving about his business. And I'm going to do the same. While he's editing, and as you can see here in the browser, I can see that he's adding a marquee bottom. I also know that he's only editing on its own because he's not in this assembly and doesn't have any reservations there. So that's where we want to be.

My job was to work on some of the stuff on the side panel. And I know we're going to be making some changes to this marquee, as well. We're going to add some new lighting capabilities in it. So what I'm going to do is, I, from the assembly side, I have the ability to make those changes here. For example, I can say these speakers need to be adjusted. Maybe they need to be moved in just a hair on each side to make some room for some new lights.

I can be editing those positions in the assembly, and Tyler is continuing about his business. Working in his daily work, isolated on his own, not in this assembly. But he still has access to everything that's important to him. So again, just like any other external file that goes out of date, Context will go out of date in the same way. And in a similar way, you'll get a warning or a message.

You can see that we have context down here that are out of date, and those are ways that you could bring that information in. Tyler is going to see the same. Once I make-- save these changes, he will end up getting a notification that the context has gone out of date, and we can trade information back and forth. But really, my working in the assembly wasn't interrupting him.

TYLER HENDERSON: Thanks, John. So let's take a look and see what I have on my screen. So as you can see, the context that I have over here, the speaker holes context, is out of sync. And that's because John made a change in the assembly that affected the geometry that I have referenced in this context. So I can go ahead and update this context or synchronize it. And when I do that, you should see the speakers actually move.

Because the context actually captured the position of those speakers in the assembly, also. Not just the geometry, but their position. So when they move, the features that I created that referenced those speakers also move. So this is a great way to keep things synchronized between a component and an assembly. Now when I go ahead and save my changes, John will see the update in his assembly. And we're going to switch over and see what he sees.

JOHN HELFEN: Thanks, Tyler. Here we can, as we switch back to my screen, you can see Tyler's made a change, he saved something, and I get notified. I can see here in my browser that the marquee needs updating. I can see that the route gives me some information that something in this assembly needs updating, and I get the notification on the toolbar as well. So all I need to do is pull that new information in from Tyler. He's made a save. I saw he was editing it.

And by me pulling in the updates, you can see here that the speakers have moved. Or the speakers didn't move, but the holes for the speakers have moved. And not only that, while I was explaining this to you, Tyler finished doing his work and has added those mounting holes. And those are now available to me in the assembly, as well. So there you can see Tyler and I working together at the assembly level and in the individual components, and passing information back and forth through that context.

TYLER HENDERSON: All right. That was great stuff, John. So now, we're going to switch over and talk about reference objects. So we just showed you a bunch of different tools to assist you in collaboration. So the ability to see where other people are working in assembly, the ability to edit things in the context of the assembly, and the ability to capture references when you're doing edits in the assembly.

But we know that you don't always want to be working in the assembly. We know that when you have a bunch of team members, you don't want everybody working in the assembly at the same time, necessarily. But you still need other people to be detailing components from that assembly. And you want to capture references from that assembly to define the shape, size, or location and position of those components. So that's really where Reference Objects come in.

So when I did Edit-In-Place, I did features while I was doing that Edit-In-Place, and it implicitly created references to that assembly. But Reference Objects allows you to explicitly create references. So when you're in Edit-In-Place, you can actually use the dropdown menu in the toolbar, the Edit-In-Place toolbar, to choose reference objects. And that pops up a command where you can actually choose objects to reference without having to do any features or real editing on that component.

So this is a great way to set up an assembly, create components, and have other people detail them outside of the assembly, and still have that reference information from the assembly. So we're going to switch over to Fusion 360, and John's going to demonstrate this.

JOHN HELFEN: Thanks, Tyler. As Tyler mentioned, the setup process is where you're going to leverage reference objects most frequently, is our estimation. Really, as a project leader, as I mentioned before, before a project like this, you're typically going to sit down and discuss how the assembly is broken down, who's going to be working on what. And there's typically somebody who's assigned a project lead.

And this is one of those places where we see efficiency happening, where I'm playing the role of the project lead. And I see we've got parts of this cabinet started, and I know Tyler is going to be detailing out some and working on some of the control panel assembly. And we talked about internal and external components earlier. And now, we're going to actually create a few and look how we can use Reference Objects to prepare a design for Tyler to start working on while I'm working in the assembly.

So to do that, I'm going to go ahead and begin by creating a new component. And when I do that, I have an option for internal components or external components. I have an option to pick where I'm going to save this. For example, I'm going to go ahead and save in our AU3 folder. It tells you what parent object the object will be created in, and finally, it tells you whether or not you want to-- or ask whether or not you want to activate that component after you've created it.

So I'm going to go ahead and begin by creating a controls assembly. And I've left it external and set it to be activated. So when I begin, I'm able to create that external component, I'm active in that component, and I can continue. And to do that, I'm going to go ahead and create one more component. I'm going to leave it to external. And this time, I'm going to create the control panel. I'm going to leave everything as active. I'm going to go ahead and move forward.

And now as you can see, I'm in the control panel, I'm active in it, and I can continue working. And then this is the point where I'm ready to start adding new information using Reference Objects. I know that Tyler is going to need a few components from the assembly in order to detail out and build the control panel. So what I'm going to do is, now that I'm in Edit-In-Place, you can tell that from the blue outline on my screen and from the in-canvas toolbar.

And this is where the Reference Objects command is, is in this toolbar. Here, I can select the Reference Objects command, which brings up a dialog box. And if you've used Derive in the past, this should look very familiar. If you haven't used Derive and you leave this class and go back to learn about Derive, this should look familiar when you're learning Derive. We tried to make these very similar, and the technology underneath is using the Derive technology when contexts are created.

So with this dialog box open, I have a couple of different options. I can start very quickly by just starting to left click on geometry that I need in the graphics window. And by doing that, you can see that the dialog box is populated. And I'm getting the bodies that I've selected in the window. The other option I have is to, for example, select entire components from the browser.

If I were to, for example, select the marquee bottom and then look at what I get here, by selecting from the component in the browser, I actually get more information. I get things like the origin. I get the bodies. I get the sketches and the construction geometry. So really, you have a couple of different ways to select geometry so that you can get very specific information that you need.

And in this case, I don't need that. I wanted to just show how a component was selected. So it's very easy to edit this list, as well. I can select an item and remove it. And again, what's important is, you can always come back and adjust this. If you're moving along and you realize Tyler decides or finds that he's missing a component, we can always come back and edit this and pass that information out.

Here, I'll go ahead and continue the last couple of pieces. I'm going to select that bottom plate. And there's a construction reference that I want to pull in as well. And you can see that it's all represented here in the dialog box. So now, all I have to do is hit OK. And you can see, in the browser, that we now have a context created, and the bodies that were projected and the construction information that was selected is available.

So now, all I have to do has come out of Edit-In-Place. I can go ahead and save those changes. You can see here, in the saved dialog box, that I'm going to save the assembly and then each of the components I created. And by doing that, I'm creating the information that Tyler needs so he can get started. And not only that, I dropped the information he's going to need from the assembly in there, so he's ready to go.

So I can go ahead and continue about my business. But we'll switch over and let you see how Tyler is going to interact with things from here.

TYLER HENDERSON: Thanks, John. So as you can see, I have the same assembly open that John was working on. And if we look over here in the data panel, we see a couple of new components that were saved. So this is the control assembly and the control panel that John just created and saved. So we're going to go ahead and open up that control panel.

And to start, there's no geometry because John didn't do any detailing in that design. But he did give me some reference geometry. So I see over here, in the assembly context, context one that John created. So I'm just going to go in and activate that, and we'll zoom in to fit that. And now you can see, all of the things that John selected using Reference Objects are added into this component for me to reference.

So I'm going to go ahead and start detailing that controls panel. And we're just going to do a sketch on here on some of the geometry that was derived in there using Context. And you're going to use that work plan that John brought in for me. And just start doing a profile of this guy so John can start-- or he can take a look at what we have after I create this.

All right, I'm going to go ahead and extrude that. And I'm going to go ahead and mirror that. All right, so we have the basics of the control panel plate that I used based on the reference geometry. I'm going to go ahead and save. And then we're going to switch back over to John's screen and see what he sees.

JOHN HELFEN: Thanks, Tyler. And as you saw Tyler working there, detailing out his control panel, I continued on. I created a new cross panel that we're going to need in a little bit, and it's unsaved currently. And while I was doing that, I see Tyler has made a save, and I have some new information I can pull in. So all I'm going to do here is pull in the updated geometry and continue on my way.

What I see here is, now, I've updated the controls assembly because I pulled in Tyler's new information. So I've edited that. And I have-- I was already working on the assembly, so I have that reserved as well. So now I have the opportunity to go ahead and just simply save. And you can see, I'm able to save the new component that I created. I'm also updating the assembly in the controls assembly, as well.

And just by pulling in that information, because of the context and the positions that were transferred, Tyler was essentially building that component in place in the assembly. Even if he wasn't in the assembly at the time because he used those contexts. So when I brought that information in, his geometry is right where it belongs, saving us time.

TYLER HENDERSON: That's awesome, John. This is so cool. So that's pretty much it. Let's do a quick wrap up of what we talked about here. So we talked about avatars, which let you see who is working on what. It's basically your other team members presence in files that you're working on, or other files in the project.

We talked about Implicit Reservation, that actually lets you reserve a part that you're actually working on or editing, and it prevents other people from stomping on your changes when you're working on it. So they can open it up and do all kinds of things in there, but they won't be able to save while you have it reserved. And then once you are finished with your changes you saved, the reservation goes away.

We talked about Edit-In-Place, that allows you to edit external components in the context of assembly without having to open them up in its own tab. And it allows you to have multiple people editing components at the same time in the same assembly. We talked about Assembly Contexts, which are basically associative references that get captured automatically when you do Edit-In-Place.

And then we talked about Reference Objects, that lets you explicitly grab references from an assembly, without actually having to do modeling in the assembly. So other people could do downstream B-tailing, of those components and still have that reference geometry from the assembly.

So all of these things put together really help more people work together in Fusion 360 at the same time. You don't have to be waiting for someone to finish their work and then start your work. You can do real time collaboration, you can be much more efficient, you can get people working together without losing your work, and you can just create a whole ecosystem of collaboration using Fusion 360 now.

So that's pretty much it. That's our class. So we really appreciate you attending this class. We hope you learned a lot of valuable lessons. We hope that you'll be able to use these tools and these skills to be more efficient and start collaborating with your team members on assemblies.

There will be a handout that you can download from the class resources. We'll also upload this arcade data set. So if you want to use that and follow along and what we did today, you can use that as well. So don't go anywhere folks, because we're going to stick around for live Q&A after this. All right. Thanks a lot.