the year of dynamo by archi-lab

image by archi-lab

Dynamo, for some is just what the official Dynamo website says it is: “Open source graphical programming for design”. However, for me its much more than a design tool. For me its more about the second part of its description: “Dynamo extends building information modeling with the data and logic environment of a graphical algorithm editor”. Yes, Building Information and graphical algorithm editor is where the power lies. For me, harnessing the power of Dynamo to tap into Revit’s database and manage information contained within is just as important as extended modeling capabilities that Dynamo offers to Revit users. The only thing that makes this half of Dynamo more appealing to me is that while there are already a handful of other great modeling software packages available, there is none that makes accessing Revit DB as easy as it is with Dynamo. Dynamo offers the ability to harvest information from a Revit model and creating connections between information that Revit simply cannot. I mean, how do you calculate room area while subtracting some random filled regions area from it? Using Revit you just cannot do it, but Dynamo can handle it without any problems.

Previously Revit DB was only accessible to those with serious C+/VB programming chops. Later on came an extension for those skilled in Python, which was great as Python is a bit more user friendly, and much more forgiving programming language. Yet, they still required that you knew how to program and were familiar with Revit API. Then Dynamo came along and all of a sudden you didn’t have to be a code magician to perform some basic tasks. My first custom Dynamo node was a simple one liner for querying Arc’s Radius value:

This one line of code in essence illustrates how powerful Dynamo could be. This one-liner was everything that I needed to get me hooked on Dynamo. Why? Because it showed me that with a very little programming skills I could really easily extend the abilities of Revit. Previously I was just like any other Revit user, constantly frustrated with its slow development, yet unable to do anything about it myself. With this single line of code I realized that I can create my own extensions using a visual programming application that even though I never used before I felt like I knew well (I was already a Grasshopper user). What is interesting enough, this single line of code allowed me to demonstrate to my manager at work, that Dynamo is more than just another geometry software from Autodesk. You ask me how? Well I have long been using Chameleon (Grasshopper plugin)  to create adaptive points families and write data, like Arc Radius, to their shared parameters so I could schedule them. We do that quite often at work since I frequently get asked to generate set out geometry schedules with curve radius, curve length and XYZ coordinates. This is one example of such schedule generated for project called “disney”:


At the time Dynamo wasn’t able to fully generate such schedule but it was perfectly capable of giving me all of the information that I needed to create it. I still had to create “dummy” information holding families and write all of that data to their shared parameters so I could schedule them, but at least I knew I could now use Dynamo to generate all of that information. From that point on, my passion for Dynamo grew and so did my Python skills, Revit API knowledge and many other skills that I would not have acquired if it wasn’t for Dynamo.

I have later moved on to a different project called “duke” and a whole new set of challenges. It was a much different project, and it didn’t really offer as many geometrical challenges, but instead it offered me plenty of practical challenges. What I mean by practical is that now I wasn’t sort of “consulting” on how to best document an irregular piece of geometry, but instead I was a full fledged model manager with responsibilities such as: managing drawing lists, making sure that models are warning free, making sure that Revit line styles don’t get mixed up with AutoCAD imported line styles etc. All of a sudden I was using Dynamo for every day tasks of a BIM Model Manager. This is when I started developing workflows and tools using Dynamo that would change how I use Revit. This is my “year of Dynamo”.

Door/Window Numbering with Dynamo:

It all started when my PA (Project Architect) on “duke” asked if I could number all of the doors/windows in some reasonable fashion. The standard method for that, and the only one I knew at the time, was to manually march through all of the floor plans and give every room a number (100 series for the first floor, 200 series for the second floor and so on), and then based on room numbers I could number all of the doors with a room number plus a suffix. So for a door in room 100 it would be 100A then second door in that room would be 100B and they would get that number in a clockwise order. Simple enough, right? Well it is, only if you don’t have to do this for some 10,000 rooms on 25 floors of a multi-million square meter hospital complex (glad I didn’t have to do it on such a large project this time, but I had that pleasure before). Instead I created a Dynamo definition that would handle that for me, and a couple days long task changed into a couple minute Dynamo task. Here’s a full post as it originally appeared on archi-lab: door/window numbering with dynamo

Room Occupancy Load with Dynamo:

Later on I was tasked with generating a Life Safety Drawings. The main objective was to make sure that we are indicating proper Occupancy Loads for each space. Given the fact that building that I was working on was mostly occupancy type A with lots of assembly spaces it was crucial that we dedicated some of the areas in each room as “built in furniture” (cabinets, built in seating etc) and reduce each space actual square footage, which in turn would reduce Occupancy Load and hopefully we wouldn’t have to add more exits (I know this doesn’t sound very safe but it’s not like you would throw a party and expect people to stand on a table so why account for people in space occupied by a table). I certainly didn’t want to go around the floor plans and manually type in that number by figuring out what the square footage of each space is, then dividing it by occupancy type max allowed number. Instead, I created a Dynamo definition that did that for me, and I have to admit it was a life saver. Building’s layout changed about one million more times and I needed to update my life safety drawings every time with accurate numbers. Here’s a full post as it originally appeared on archi-lab: room occupancy load with dynamo

Isolating Revit Warnings by Category with Dynamo:

Another thing that I got to do as a BIM Model Manager was to try and keep the architectural models clean of errors as those left unchecked can increase model opening and synching times. I certainly don’t like tracking down room separation lines that overlap each other causing Revit to report a warning, so instead of writing down element ids of two clashing lines and looking for them in a 3D view, I wrote a tool for Dynamo that would parse through warning file and isolate the two clashing elements. From there it was easy to figure out which one to delete and which one to keep. I wrote about it previously here: isolating revit warnings by category with dynamo

Interference Report parsing with Dynamo:

That post and a video was spotted by Julien Benoit and this is how our long distance friendship, centered around solving common Revit problems, figuring out how to use Dynamo and bitching about Autodesk, started. At the time Julien and I were merely beginners in Dynamo sorcery while now I can proudly say that he’s become a full fledged Dynamo guru with his own widely popular set of tools known as SteamNodes that can be found at his blog called AEC, you and me.

Our collaboration quickly produced a variation of my warning parsing workflow and interference parser was born: interference report parsing with dynamo

I haven’t since used it and I am deeply saddened that it might not be working properly in the latest versions of Dynamo, but it was fun at the time. Probably the most gratifying part of creating this workflow was that I created it for someone else. It was the sense of contributing to the community rather than sheer benefit of using it since I never used the internal clash detection tools that Revit offered (I was, and still am a Navisworks user).

Delete Duplicate Families with Dynamo:

Sometimes while I was chugging along as a full time model manager on “duke”, I would get approached by other model managers and asked for input. This one time we had a consultant send us back comments about one of the casework schedules that our office produced, saying that numbers didn’t add up between the schedule and actual casework shown on plans. So, after investigating the model I quickly realized that there was an unknown number of duplicate families placed on top of each other. This is when I put together a quick definition with Dynamo that would look for any two pieces of casework in the exact same location and simply delete one. For Dynamo it was just a few lines of code, and I was done checking the whole model within minutes. Imagine doing that manually. It would have taken days if not weeks since it was quite large “airport” project. Here’s a full post as it originally appeared on archi-lab: delete duplicate families from revit model

Room Numbering with Dynamo:

This one goes back to when I had to number all of the windows and doors. At the time we had a junior member of our staff comb through the rooms and number them all beforehand (don’t ask me why you would want to do this manually), so I only developed a Dynamo workflow to handle Doors and Windows. However, as we got pinched on the next deadline and PA realized that rooms got re-arranged and now needed re-numbering he asked me if I could have a look. Being the helping man that I am, I said: “Sure I will have a look”. This was a perfect opportunity for me to practice some Dynamo sorcery and this is what I came up with: room numbering with dynamo

Managing Family Types with Dynamo:

Then came this post about family types. The whole thing was a big misunderstanding as in my opinion wall rating should have been declared in a wall type, but this time it was “decided” to declare it as an instance for each wall. This forced me to create two Wall Tags, one that had just the wall type and one that had a wall type and a fire rating. Well, as you can imagine, giving your staff a choice between two wall tags is like telling them: “Yeah, go ahead, just use both freely whenever you feel like it and pay no attention to it”. As it turned out, it was a minor disaster where everyone used the wrong one and either it didn’t display wall fire rating on walls that were meant to be rated or it showed “0” for ones that were not. Ugly, that’s what it was. So I turned to Dynamo and asked it to clean it up for me. I put together a small definition that made an association between a wall tag and a wall that it was tagging. Then based on whether that wall had a rating it would use one wall tag type or the other. Doing this manually? – hours, days, weeks. Dynamo? Minutes, and I kept using this definition basically for the remainder of the project before every issuance to make sure that we are good to go with correct tag types. Here’s a full post as it originally appeared on archi-lab: managing family types with dynamo

Drawing List Management with Dynamo:

This was another one of those things that we kind of walked ourselves into, by making a bad decision early on a project and then there was no backing out of it. Anyways, the problem was that I needed to sort a drawing list by a number that had a prefix and it was totally throwing it off. I ended up asking Dynamo to take every Sheet Number, strip it off that prefix and then write the rest of it to a separate parameter that I used for sorting. Easy. Here’s a full post as it originally appeared on archi-lab: drawing list management with dynamo

Element Tagging with Dynamo:

This was another one of those things that I kind of ventured out into a different project. This one was called a “tram stop” and I was asked to document panel types for a glass canopy roof. Simple task of creating a roof plan and hitting Tag All button turned into a Dynamo task because as it happens Revit just randomly placed all of the tags off center and overlapping each other. Now, I was either facing a task of moving them all manually or creating a definition in Dynamo that would place those tags in a location of my choosing. Using Revit’s User Interface (UI) you cannot specify where the tag get’s placed and sometimes they just run off the panel and cramp all on top of each other. Instead, I used Dynamo and tapped into Revit API’s ability to specify exact position of my tag. Here’s a full post as it originally appeared on archi-lab: element tagging with dynamo Here are before and after images:

Create Views and Place on Sheets with Dynamo:

This workflow never was fully realized, but for the same “tram stop” canopy I thought it would be a good idea to have a view for each panel type in which I would dimension each panel. Unfortunately, there were some 100 different types so instead of creating views and dragging them on sheet for couple days, while in the process slaughtering all of the remaining grey cells in my brain, I put together a little Dynamo workflow. It automatically created a view for each panel, applied a template to it then placed it on a sheet. Now, that was fun! Here’s the original post: create views and place on sheets with dynamo

Checking if Schedules are on Sheets with Dynamo:

I am not sure why, but this post has became quite popular and it was actually featured in Zach Krone’s presentation to NYCRUG as well as in Sean Burke’s AU presentation. I don’t know what it is about schedules and making sure that they are placed on sheets, but let it be. I did it because I noticed that we had a lot of redundant or so called “working schedules” hanging around the model, and wanted to make sure that I am not deleting anything that is actually on a sheet. This definition was however originally developed by Jeremy Tammik and I only “translated” it from a Revit Macro to Dynamo Custom Python node. Here’s the original post: checking if schedules are on sheets with dynamo

Sheets from Excel with Dynamo:

As we were chugging along happily on “duke” towards our 100% DD deadline I kept being tasked with managing drawing lists. The only problem was that most of our consultants were working in AutoCAD and we were not getting Revit models from them. Well, that meant that I had to create placeholder sheets for every sheet that they were issuing so that they appeared correctly on our drawing list. This was somewhat easy early on, but towards the end I quickly realized that I was in over my head trying to do this manually. At one point, it was after midnight, the day of 100% DD deadline and I was still some 180 sheets away from having created all of the “dummy” sheets for our kitchen consultant. Right then and there I knew that I needed a better way to manage that process. Before our next issuance I had a Dynamo workflow that would take an Excel list of sheet numbers and names, and create all of them for me in about 2 seconds. Guess what? I didn’t stay up until 2am next time. Here’s actually two posts since I made some improvements to it later on: sheets from excel with dynamo and create placeholder sheets using excel with dynamo v.1.5

Ripples Component for Dynamo:

This had nothing to do with a project, but was a request by another one of people that I know consider friends even though we had no chance to meet in person yet. Havard Vassaug was introduced to me by previously mentioned Julien Benoit. I was told the the two of them often collaborated using Dynamo and asked me to “join up” with them. I said, “Sure, it will be my pleasure”, and that’s how mine and Havard’s jurney started. At the time, he was just getting his feet wet with Dynamo, but since has became an expert and a real force in spreading the gospel of Dynamo. You can find out more about him here: The Dark Arts of Revit Anyways, before he was a Dynamo guru, we used to talk about doing things in Dynamo and one time he asked about this Wave Node that Nate Miller created. The question was more of sort: “How do you really use this thing?”, but as it turned out I realized that as much as it was a great node it lacked some functionality so I used David Mans’ Ripple Component (Grasshopper) as an example to write one for Dynamo. Here’s a full post: ripples component for dynamo

Door Set Handing with Dynamo:

Our (Havard’s and mines) Dynamo talks eventually produced another node for determining appropriate door hardware. I had no idea, that this was such a huge issue over on the other side of the pond, but Havard insisted that I somehow managed to save him countless hours by putting this node together. Its really a basic conditional function that assigns a parameter to a door with an appropriate Door Set Handing. You can see it in action here: door set handing

Delete All Linked Model Keynote Tags with Dynamo:

Back on “duke” I was, and more issues were arising as it happens with project nearing its end of CD phase. We were now drawing away, making details, creating detail items and happily keynoting everything in sight. Problem with that is that when you keynote tag an element in a linked model that doesn’t use the same keynote file, you get a warning. Well, let’s just say that some folks thought that it was a good idea to tag some structural columns from consultants model. Now, we were getting a warning every time we opened Revit and it was not going away. On top of that, Revit as sophisticated as it is wasn’t giving away the culprit that generated such warning so I was stuck blindly looking for keynotes tagging structural elements. As it turned out to be, there were more than few of those, mixed in with some tagging elements in a linked model coming from other architectural models that I actually wanted to keep, since they were using the same keynote file. Instead of wasting my time, I turned to Dynamo to save the day once again, and put together a search and rescue Dynamo definition. Its job was to find all keynote tags that were tagging something coming from a linked model and at the same time check what model it was coming from, and delete only ones that were not architectural. Success! I ended up developing couple of new nodes for this workflow as well as using some old ones. Here’s an original post: delete all linked model keynote tags

Delete Imported Line Patterns with Dynamo:

I am not exactly a huge fan of AutoCAD, and often treat myself to a small pleasure of uninstalling that sucker from my machine. Unfortunately not everyone thinks the same way, and because of that lots of fluffy kittens die when AutoCAD drawings are linked to Revit models (you can read more about it at @ShitMyRevitSays). As if killing innocent animals wasn’t enough that bastard child of Autodesk randomly creeps up in most unexpected moments to remind you that as hard as you tried to prevent it, someone did import a CAD drawing into your Revit model. So, this one day I was creating a new Line Style and as I was descending deeper into uncharted depths of Revit’s never-ending options for new line styles, something scary happened. I have accidentally discovered an AutoCAD graveyard of line patterns that were all that remained of once happily living linked CAD drawing. Being the guy that I am I decided that was completely OK to exhume them and then get rid of them (it wasn’t really that bad as I think that weather was still fairly warm so its not like I kicked them out in a middle of the winter :-) ). Dynamo was of great help again, for which I will be forever grateful. You can find out more about this horror story here: delete imported line patterns using dynamo

Mantis Shrimp for Dynamo:

At last “duke” was done, 100% CD documents were submitted and finally I could get out of trenches of every day model management and focus on something that I wanted to do for a long time – develop an interop plug in for Dynamo and Grasshopper. At the time I was aware that Nate Miller was working on one between Dynamo and Rhino, which he happily shared some sneak peeks of on his YouTube channel. However, to be honest with you, I thought it would surely become a subscription project eventually. After all, Case (company Nate works for) as great as it is at developing new tools and workflows is a business, and as all business must do it looks after its best interests and ways to make a buck. I personally cannot blame them, as I am sure that folks at Autodesk don’t think that making new tools and giving them away for free, is a great business plan either. However, I think I need to give Case and Nate props for eventually coming through for the Dynamo community and making Rhynamo an Open Source project. However, as I was setting out to write Mantis Shrimp I was still greatly concerned that this new tool, called Rhynamo would be kept away from all of us, and this great ability to interop with Rhino models would not be available for all.

So, I decided to create my own version of it, write it as a series of Custom Python Nodes, so that everyone at any time could see the source code and share it on my website and GitHub for free. That’s how Mantis Shrimp came to be, and since then it actually became more than I ever imagined it to be (a mere geometry importer of 3DM files) with latest features allowing you to import/export geometry/data directly between Dynamo and Grasshopper as well as Dynamo and Rhino. Mantis Shrimp has been my pet project for few months now, and I can’t express how grateful I am to all that contributed to it in some bigger or smaller capacity. Special thanks go to Mostapha Sadeghipour Roudsari for guiding me through some initial concept ideas and help throughout. Also, David Mans, Giulio Piacentino, Daniel Piker and Andrew Heumann helped in sometimes smaller way via feedback and sometimes bigger with actual coding contributions. Here are some of the posts that deal with Mantis Shrimp:


Mantis Shrimp is by no means a finished product at this point, but in my opinion its a step in the right direction and a great way for me to end the “year of Dynamo”. It doesn’t necessarily make a wholesome change in architectural practice, but I think it can make a small dent and when you add up all of the other tools that make other small dents, we can together make a big difference. That’s exactly what Dynamo was for me this past year, a great difference maker. It allowed me to not only make my Revit better, it enabled me to learn Revit API, Python, Rhino Script and even dig through some Grasshopper stuff. However, most of all it gave me opportunity to meet (directly and indirectly) some great people. Aside from the previously mentioned Julien and Havard I also “befriended” Andreas Dieckmann – the holder of Dynamo record for most packages created/published, Marcello Sgambelluri – the guy that models animals in Dynamo, Adam Sheather – the creator of DynaWorks for Dynamo and many more. I also, had the opportunity to meet and interact with creators and care keepers of Dynamo, the father himself Ian Keough, Colin McCrone, Zach Krone, Matt Jezyk and many more. This was a great year not only for myself personally but also for Dynamo and I am glad that I was part of it. Thank you all and keep up the good work.

– Konrad

Support archi-lab on Patreon!


  1. Cenk says:

    Thank you for sharing your experiences. It’s realy great to see and understand the capabilities of Dynamo in İnformation management.

  2. Mark Rocha says:

    You’re the best Konrad! These tools have been such a huge help!

Leave a Comment