Autodesk University 2013 Dynamo lecture now online

Take the whirlwind tour through Dynamo!  See how all the pieces fit together, learn basic list management techniques, how to use spreadsheets, read and write family parameters, color your models, and where to find more learning resources:
AB2551 : Enhanced Parametric Design with Dynamo Visual Programming for Revit and Autodesk Vasari.


Dynamo and Design Computation at Autodesk University

I know many of you have already started the party in Vegas, but here’s a little roundup of what’s happening with Dynamo and Design Computation this week at AU.  I’m afraid most of these events are booked up, but the very nice AU organizers sometimes let more folks into the room if you’re ok with standing.  (That’s the only way I ever got into Fuzzy Math, among others).  If you can’t attend these specific talks and want to talk about any of these topics, please feel free to ping me and we can try and set something up during the week.  

We're also going to be bashing away at codes, nodes, and models at Case's Hackathon on Tuesday night. Hope to see you there!

Computational BIM Workshop
Monday, Dec 2, 7:30 AM - 6:30 PM
Learn to combine computational design and BIM with Dynamo visual programming and DesignScript. Use computational design to drive an Autodesk® Revit®-based software model. No programming experience necessary.
Ian Keough, Luke Church, Patrick Tierney, Matt Jezyk

Tuesday, Dec 3, 3:00 PM - 4:00 PM
– Delfino 4004
Project Dynamo is an experimental "wire diagram"-style scripting environment for Autodesk® Revit®-based software and Autodesk® Vasari software. Autodesk 123D Make software takes 3D models and decomposes them into easy-to-fabricate forms. Combine them together, and you've got a powerful solution for conceptual architectural design, form finding, and fast digital fabrication. In this class we present these new free tools, teach the basics on how to work with them, and show just how quickly they can generate, rationalize, and fabricate form.
60 Minutes Lecture
Jeffrey Mcgrew, Because We Can

Wednesday, Dec 4, 8:00 AM - 11:30 AM
– Lido 3103
This year’s theme is “Computational BIM” and will explore how advanced firms are bridging the gap between Computational Design and Building Information Modeling. We have seen the development of different specializations inside firms and would like to explore the bridges and points of interconnection between the two. There are three areas of interest under this theme:
• Incorporating performance-based design, simulation and analysis.
• Digital fabrication and other modifications to streamline the construction process.
• Lastly, leveraging sensor data both for post-occupancy study and as an input into the design process.
  More . . . 
Matt Jezyk, emcee
  • Session 1
    • Jonatan Schumacher - Thornton Tomasetti
    • Greig Paterson - AEDAS R&D
    • Juan Betancur / Anthony Viola – Adrian Smith Gordon Gill
    • Phil Bernstein - Autodesk
  • Session 2
    • Nathan Miller / Daniel Davis – CASE
    • Scott Crawford - LMN Tech Studio
    • Jeff Vaglio - ENCLOS Studio
    • Keynote Speaker- Enric Ruiz-Geli  - Cloud 9

AB2551 - Enhanced Parametric Design with Dynamo Visual Programming for Autodesk® Revit® and Autodesk® Vasari™.
Thursday, Dec 5, 8:00 AM - 9:30 AM
– Marcello 4404
This lecture introduces participants to the fundamentals of visual programming within the Autodesk Vasari and Autodesk Revit conceptual design environment. Custom code gives users the ability to efficiently automate many design tasks while also enabling new generative design capabilities. This lecture shows how to compose useful scripts using Dynamo Visual Programming for Autodesk Revit and Autodesk Vasari software. The lecture provides users with resources and step-by-step examples for automating geometry creation, adjusting family parameters using external data, and sharing information with different design platforms.
90 Minutes Lecture
Zach Kron

AB3362-L - Enhanced Parametric Design with Dynamo Visual Programming for Autodesk® Revit® and Autodesk® Vasari™
Thursday Dec 5, 2:30 PM
- Marcello 4505
This Hands-on Lab introduces participants to the fundamentals of visual programming within the Autodesk Vasari and Autodesk Revit conceptual design environment. Custom code gives users the ability to efficiently automate many design tasks while also enabling new generative design capabilities.  Users will try out resources and step-by-step examples for automating geometry creation, adjusting family parameters using external data, and sharing information with different design platforms.
75 Minutes Hands-on Lab
Zach Kron


Dynamo 0.6.2 update release

Dynamo is getting bigger, stronger, and faster by the day.  Check out the 0.6.2 build here. As always we have a truckload of fixes and improvments, here are some:

New Samples and updated documentation
While we are very psyched to have some time with folks at AU to talk about design computation, we've also prepared some new documentations for those who can't make it out to Vegas.  Our written tutorial has been in need of an update for some time.  Now called Dynamo Visual Programming for Design (previously Programming for non-programmers), we have revised a number of the existing tutorials, but also have brand new sections on Lists, Color, and Data Interop.  We have also done some cleanup and expansion of the samples that are available in the Help, Samples dropdown menu.   In particular, we have more datasets around lists, color, data import/export, and file sharing (Package Manager).  If you have been hesitant to get involved in Dynamo in the past, start with these documents and we'll have you up and running in no time.

Knowing what you are making and seeing the relationship between nodes and data is supremely important.  With Dynamo working on top of Revit, there is a distinction between making geometry and making Revit elements.  By visualizing any geometric entity in the background of your Dynamo canvas, we are hoping to make the distinction more fluid, but it also gives us the opportunity to increase the quality of the information.  For instance, selecting nodes highlights the geometry that is created, and selecting the geometry highlights the nodes that created it.  We are going to continue to expand how we handle this sort of information and welcome your feedback on what works and what doesn't.
- Increased speed of display
- Background Preview elements highlight when nodes are selected
- Selection of Solids in background highlights nodes
- Resizable Watch 3d windows
- Point and Curve numbering available in node right click "Show Label"

Geometric Operations
- More forgiving inputs for Solid Geometry creation
- Solid Primitives: Boxes, Cylinder, Sphere, Torus
- extraction of Data from Revit elements.  Use Get Family Location to get single origin location from regular families and all placement points from panels and adaptive components.
- XYZ and Vector improvements:  Normalize, Dot product, components, polar and spherical coordinates.  Extract Transform Basis for x, y, and z vector components. XYZ by distance offset from origin.
- Curve Plane Intersection
- transform origin node
- plane from reference plane.
- line by start point direction and length
- More!

General User Interface and Navigation improvements
- Drag and Drop dyn files into canvas to open
- Mouse-less navigation
- No limit to the size of canvas
- Preview data bubbles on nodes
- Browser reorganization
- Search Improvements

Other new nodes and node enhancements
- List handling.  Most nodes now can take lists and lists of lists.  In the past, many nodes needed data to be flattened.  Now nodes will inspect their input and automatically dig deeper into the contents to find the data they need.
RaaS - Cloud based Daylighting Analysis.  More on this later, but we now how the infrastructure to execute cloud based daylighting analysis, retrieve the data and drive it back into the model.
- Added an interval node to Web Request
- Equal can now compare all data types
- Updates to Arduino. Use delimiter instead of new lines.
- Get Family Location now takes single origin and multi-pick placement families
- Asin, Acos, Atan
- Wall and Floor Creation nodes.  WARNING!  Recreated, not modified on change.
- integer slider
- STL export (from file menu)
- Default values added to many nodes
- Separate nodes for solid boolean operations


More Dynamo Sample files

Are you looking for more examples of how to wire stuff up in Dynamo?  There is a large collection of samples available on the Github repository that we use for testing the tools and making sure everything still works as we continue developing.


This folder is divided up into core, pkgs, and Revit.

The core functionality deals with nodes and operations that are independent of Revit, things like list management, math, conditional statements.  You may also note that there are samples here that deal with geometry.  These examples are using the Autodesk Shape Manager geometry kernel (ASM), and reflect development we are working on to be able to expand beyond the geometric capabilities of Revit.  This geometry is still pretty experimental, so it does not yet connect up to Revit (although you can export to SAT.)

Pkgs folder is entirely concerned with making sure that the package manager continues to work. You can download any samples here from the package manager anyway

The Revit folder houses samples that are entirely about operations specific to Revit.  Revit solids creation, family placements, view manipulations, etc.  All of these tests involve some amount of interaction with the Revit document.

In theory, we should have samples that reference EVERY node that is available in Dynamo . . . we aren't there yet, but we are working on it.  If you are looking for a particular node and you can't find an sample for it in this repo, please drop us a note.  You need it, and we need a test to cover it.



Let's do some (more) Dynamo at AU

Were you unable to get a seat for the Thursday afternoon Dynamo class?  We added a lecture Thursday morning with essentially the same content, so bring your laptop with Dynamo installed and we'll drop some parametric knowledge!

Thursday, Dec 5, 8:00 AM - 9:30 AM
AB2551 - Enhanced Parametric Design with Dynamo Visual Programming for Autodesk® Revit® and Autodesk® Vasari™.
This lecture introduces participants to the fundamentals of visual programming within the Autodesk Vasari and Autodesk Revit conceptual design environment. Custom code gives users the ability to efficiently automate many design tasks while also enabling new generative design capabilities. This lecture shows how to compose useful scripts using Dynamo Visual Programming for Autodesk Revit and Autodesk Vasari software. The lecture provides users with resources and step-by-step examples for automating geometry creation, adjusting family parameters using external data, and sharing information with different design platforms.
Additional Information
Top of Form
Class Discipline:
Architecture, Structural Engineering, Education

Autodesk University
Bottom of Form
Class Format:
Class Length:

1h 30m


Happy Halloween V

(Ritchie Jackson, in solidarity with the Boston Red Sox, submitted the proper interpretation of a pumpkin carving.  I'm under slept, so it took me a little while to figure that one out.)

But on to the BIMkins!  A lovely batch again this year, with segmented orange harvest season parametric goodness.

The Goodest

This years award for the pumpkin that shows all that is harmonious and ordered, hack free and quantifiable in a parametric pumpkin goes to Alfredo Medina.
Alfredo Medina's MEP pumpkin asks the question "have you ever scheduled a pumpkin?"

And what exactly are we scheduling?  All MEP fixtures!  Ducts, connectors, conduits, all counted and measured.
And you don't have to look too closely before asking . . . is that a commode nose?
Yes . . .. yes it is.
Download Alfredo's pumpkin from here.

The Baddest

Kelvin Tam's PumPin
The award for the pumpkin embodying uncanny scariness, a serious and terrifying aspect.

Something happened to the staff at Buildz in the late 80's.  We all uniformly have a debilitating terror associated with the Pinhead character from Hellraiser.
Don't get us wrong Kelvin.  We appreciate the deft handling of surface normals, and the satisfying bounce and spring in the resizable and pleasingly rounded aspect of this submission.  All masterful.

But Manni, the summer intern (who thinks we are still paying into his direct deposit and hasn't gone back to school) hasn't been able to sleep in his nest in the server room since seeing this.  And Franz, our web guru, LEED expert, and coffee gopher, has been completely useless . . . just rocking back and forth muttering "come to daddy"  So, thanks for that, Kelvin.

The Mostest Parametric

Philip Chan's the Nightmare Before Halloween.
Remember those little rubber squeezy toys that, when you sat on it, or gave it to your dog, the eyes would pop out like a chihuahua on amphetamines?
Well, unlike the chihuahua, this one has a an actual check box to pop out the eyes.
The scale factor can go any size 1 or below, which changes the head size. You can control the smile length (mouth_length) as well as the teeth number. It's also hella big . . . coming in at a hefty 241mb, which Philip attributes to the rather elaborate eyelashes
We tend to agree.  (Also, since when do pumpkins have eyelashes?)

Philip also gives a shout out to Kelvin Tam and Andy Milburn for the tips and tricks he has learned from them to make this pumpkin.

Best in Breed/Off topic

We really don't know what to do with Andy Milburn's fabulous stuff anymore. Last year it was close enough to pumpkin based that we welcomed his Sleeping Beauty/Archimboldo extravaganza of harvest vegetables into the general arena of pumpkin carving.  This year we are treated to another BIM opera of taste, color, form, and visual excitement . . . and once again it is a stunning tour of the parametric capabilities of Revit.

But it just isn't a pumpkin carving!
It is however an 11 blog post long study in proportion, perspective, perception, art history and MEP hash pipes.   Words fail, yet again Andy.  Thanks so much for being you. And dear readers, please please please frequent Andy's site for some profound insights.
Read more about this work and download the models from here.

A final heartfelt thank you to all our contestants.  Philip, Kelvin, Alfredo, and Andy, please send in your mailing addresses and shirt sizes!


Late Pumpkins

The team at Buildz is extending the deadline for pumpkin submissions!  Please submit before dawn (approx at 7am eastern standard) Oct 29!


Dynamo Update release 0.6.1

The next incremental release of Dynamo visual programming is out, with lots of fixes and shiny new tools.  

Undo/Redo now available:  yes, we know this has been a long time in coming and is a pretty basic thing.

Visualization in canvas (available in Vasari only):  By default, whenever you make any kind of geometric entity, Dynamo will create preview geometry in the Vasari canvas.  This is a lightweight, quickly regenerating temporary visualization that will only be active during the session, nothing is saved in the file and these are not true Revit elements.    Because Vasari is on a slightly different development schedule than Revit, it has a few additional tools available for that we can take advantage of.

Override Colors in View:  this node allows users to create arbitrarily override default colors of Revit families on a per-view basis.  You can use this to create your own analysis outputs, diagram relationships, or whatever you need color for.

View creation nodes:  Programmatically create section, axo, crop controls,element isolation, more.  In Revit, use them in conjunction with sheet creation and view placement nodes and they will update like any other good BIM element.

Package manager improvements:  Search for nodes is now instant (no commit needed).  Deprecation of existing packages is available, so you can remove existing nodes from search and indicate that you have a node that is no longer supported. We also have improved save functionality to allow for creating variations of existing custom nodes.

Raybounce node: this is a very general implementation of a ray casting tool, which is appropriate for doing all sorts of analysis or form finding.  Use it for glare studies, acoustic simulations, view analysis, and much more. Input a starting point for for the ray and its direction, get a list of objects that are hit and the xyz coordinate of the intersection of rays and elements

Check the readme for a full list of fixes and improvements.
- Project to Face/Plane corrections
- many excel node fixes and performance improvements
- Python output improvements for integers
- Best Fit Plane Orientation consistency
- Conditional statements don't break formula node
- Custom node fixes
- Package Manager download fixes

- Undo/Redo now available
- Many UI improvements
- Visualization in canvas (available in Vasari only)
- Background and watch 3d can now draw from any node with geometric output
- Coloring preview geometry based on node selection
- navigation without with key commands
- navigation with onscreen commands
- View creation nodes: section, axo, crop controls,element isolation, more
- Sheet creation and View placement
- Override Colors in View
- Package manager search is now instant, no commit needed
- Deprecation of Packages
- Drop down menus sorted by name
- name inputs for levels
- better reference line/model line creation methods
- Model Text nodes
- Raybounce nodes


5th Annual Parametric Pumpkin Carving

Do you ever feel like stabbing something . . . over and over. Maybe ripping the top off and pulling its innards out? Well this is the season for you! 

It's time for the 5th Annual Buildz Parametric Pumpkin Carving! Sharpen your knives and dull your mind, time to express the design intent and relational organization of pumpkins! 

Prizes, as always, will be awarded for The Goodest, The Baddest, and The Mostest Parametric. 

Remember that we at Buildz Open Sores Software and Vegetable Perforations LLP are platform agnostic. Submit entries from whatever platform you are comfortable in: Fusion, Digital Project, Processing, Live Buildings, Bit Blocks, interpretive dance, all are welcome. Our factory judges are not judgy (but we will ridicule you for thoughtless use of knee-jerk anti-skeuomorphism). 

Along with receiving bragging rights, the winners will have their work showcased on these pages to the other reader of Buildz, and receive a valuable piece of Buildz schwag. Entries must be received by 12 noon EST Oct 28. Winners will be announced at midnight on Halloween. 

So pour yourself a Cement Mixer, upgrade the firmware on your Digi-Comp II, and make a generative, SAAS, data-matched, debt-ceilinged, always on, sledge-hammer licking Jack O’Lantern. Post entries to zachkron@gmail.com, at least a screenshot, but feel free to send models, journals, parameters, videos, scripts, whatever, modeled in whatever you like. If you have some ginormous file, please send a link or let me know and we can work out some kind of upload. 

It makes the pumpkin or else it gets the hose!


Data from Others

Yes.  It turns out that there are people who use tools other than Revit and Vasari to make their stuff.

Crazy, I know!  But it's true.

Regardless, we in the Dynamo anarcho-syndicalist commune are less interested in your platform and more interested in your DATA.  We love your data, we want to be close to it, reference it, parse it, and convert it into high grade BIM.  

Spreadsheets are, in many ways, the lingua franca of the AEC world, and Dynamo is working to speak that language.  Here is one example.

Datasets available for download here.  (These files are made using the latest "bleeding edge" development builds from here)


Making Revit Views and Sheet Layouts in Dynamo

Ian Keough has mixed the cauldron and made some excellent new Dynamo functionality that I think you will really like.  Essentially, we now have lots of new view creation tools, including a node that lays out and packs automatically created views on sheets.  The result is that you can derive perpendicular views from model elements to automate flat layout.  Here is an example that Ian put together:

While there are a lot of directions I think people can take this, fabrication  is definitely one.  But I think this is significantly different than the general method of actually drawing new geometry to create cut sheets, and much more BIMy.  

Very curious to get your reactions to the new tools,  what else can you do with them?   

You can get at it from the fresh baked builds here (scroll to the bottom for the latest):
as it is not yet in the “last stable” build. 

If you download the most recent builds, also download these files and have a look at the workflow shown above.  Keep in mind, you have to use Revit, as there are no Sheets in Vasari.


Surface Remixing with Dynamo

Buildz is very pleased to Welcome Andreas Dieckmann for this guest post.  I met Andreas in Spring of 2012 at the WoodStEx Autodesk European Student Experts conference in Spain.  This meeting was a exhausting and jittery time (the conference was sponsored by Redbull) and I had a pretty solid case of jetlag.  A handful of people also got food poisoning, so that was fun.  The students were fantastic, engaged and ready to learn, and Andreas was presenting these meticulous matrices of divide and repeat functionalities that blew me away.  Since then we have collaborated on presentations and been sharing work and ideas around parametrics, building technology, and teaching.  Andreas teaches BIM and Parametric Design as the Chair for Computer Aided Architectural Design (CAAD) at RWTH Aachen University / Germany.

Surface Remixing with Dynamo
Last year, I had the privilege and the pleasure to teach an AU2012 class together with Zach called "Echo Chamber: Complex Parametric Arrays in Autodesk Revit" (http://au.autodesk.com/au-online/classes-on-demand/class-catalog/2012/autodesk-revit-for-architects/echo-chamber-complex-parametric-arrays-in-autodesk-revit). At the very end of the class Zach showed a method to map the distance between two arrays of nodes of two separate divided surfaces on the second divided surfaces and create an entirely new form in the process. To make this work, he made use of an adaptive component, some reporting parameters, some formulas and the divide/repeat functionality introduced in Revit 2013:

And here's an image of the resulting form when you map a torus onto a sphere (BTW: My boss's first reaction was: "Oh nice, now we can also make turds with Revit!"):

Enter Dynamo. I had been following the project's progress ever since Zach posted about it in 2011 (http://buildz.blogspot.de/2011/10/dynamo-hum.html). In early summer this year, I started working with Dynamo (again) on a regular basis when a bug was fixed that had previously made it rather hard to work with on a computer with German regional settings. I was thoroughly impressed with all the new functionality that had been added to it in a relatively short amount of time, so I decided I would create some examples for my upcoming parametrics class in fall. This is one of them.

Dynamo has a lot of nodes that allow you to work with XYZ coordinates. In order to learn more about how all of these XYZ nodes interact with each other I set out to recreate Zach's AU2012 TurdMakerTM without the use of smart (i.e. reporting parameters & formulas) adaptive components. I ended up not only doing that, but also creating some more functionality because it was just a matter of adding a few extra nodes. Here's an overview of what I came up with:

The basic idea of this definition is to select two faces, go through some additional settings and then have Dynamo create a new surface for you based on the inputs, hence surface remixing. Although I am not a big fan of the term “form finding”, this really is just a tool for form exploration (and maybe for learning a little something about Dynamo in the process).

So how does it work? First we need XYZs, so I built a custom node called XYZGridFromFace to create coordinates from both selected faces – it also provides us with the surface normals at those coordinates (which we might need later on):

We can then perform some basic operations on those XYZs: Invert the XYZs if we so choose – which is basically a point reflection through (0,0,0) – and scale them, i.e. increase the magnitude of one surface's XYZs versus the other surface's XYZs to make one surface more dominant than the other.

When combining the XYZs of both faces, we can choose between four different methods:
a) Add the XYZs of face #2 to those of face #1
b) Subtract the XYZs of face #2 from those of face #1
c) Use the cross-product of both XYZs
d) Measure the distance between a set of points on both faces and use it to drive the offset of new XYZs over the normals of face#2 (and that actually is Zach's original method described above)
To accommodate all of these options I used a set of nested IF nodes and Boolean switches – I hope that at some point in Dynamo's future this can be solved more elegantly with a switch that allows you to select several (custom) options.

As I had previously tried to recreate the functionality of the Parameter Values From Image plugin in Dynamo (http://autodeskvasari.com/forum/topics/parameter-values-from-image-for-dynamo), I thought I might as well include the option to further deform the resulting face based on an image in this definition as well. This includes the ability to invert and mirror (horizontally and vertically) the image data. Apart from all the above, there are also some other settings available like an overall scale for the resulting form and the ability to move the form in X, Y and Z direction.

Finally, the resulting XYZs are fed into a Watch 3D node. Once we've found some settings that we like, we can connect it to either one of two series of nodes, one of which will create a lofted form while the other will create quadrilateral adaptive components. The latter option should always work, but not every resulting form can be lofted as the resulting geometry might self-intersect. When the geometry cannot be created, try changing the loft direction (U vs. V) – sometimes it helps.

To wrap this up, here are some images of various resulting forms based on Zach's original setup (sphere & torus). As you can see, turds come in all shapes and sizes. ;-)

Download the full dataset here.

Watch this short video to see how to operate the files

Andreas Dieckmann teaches BIM and Parametric Design at the Chair for Computer Aided Architectural Design (CAAD) at RWTH Aachen University / Germany. You can find CAAD on Facebook (https://www.facebook.com/pages/CAAD/252048391538317) as well as on YouTube (http://www.youtube.com/user/caadtv).


Sequences and Ranges in Dynamo

Usually when a person is making stuff in Dynamo, they aren't making just one or 2 things.  More often than not, you are actually making a ton of stuff, series or related ranges of items.  This can require inputting lists of numbers to position and arrange your stuff.

Some standard nodes exist for this, namely Number Range and Number Sequence

But you can also insert ranges and sequences directly into certain nodes following this syntax

0..4 will yield  0,1,2,3,4

0..4..2 will yield 0,2,4

0..1..#5 will yield 0, 0.25, 0.5, 0.75, 1

Start..#List Length..Interval
0..#4..10 will yield 0,10,20,30

Additionally, you can insert variables within the ranges and sequences like 0..#a..50


Dynamo 0.6 Released

Dynamo 0.6.0 takes a big step into the future with the ability to easily share functionality between users. Dynamo already had the ability to create custom nodes by collapsing collections of functions into single nodes.  This allows users to create their own libraries of repeated or more generic workflows that they do not want to rebuild over and over.  The Package Manager enables users to share these repeatable workflows with others, and do it directly through the application.

Here's the Package Manger in action:

So, what kind of things can you find on the Package Manager?  One example, Andreas Dieckmann has added a "Highest Value" custom node, which iterates through a list of numbers and extracts the highest one
It's not a complicated custom node, but it is elegant, and now you don't have to make it yourself

Another from Andreas takes a small Python script and embeds it in a custom node to Sum a list:

With recursion and other higher level computation that is allowed through custom nodes, advanced users can also significantly enhance the "out-of-the-box" functionality.  Stephen Elliot's Serpinski Arrowhead creates a fractal design that might not be buildable by the casual Dynamo user.

Take a look around.  I have some basic form generators (look for "Box" and "Cylinder"), and a couple tools for organizing point collections into Quadrilateral sets ("Quads from Rectangular Grid"), and a replacement for the old Parameters from an Image addin ("Parameters from Image").  More to come, hopefully from you too!

Moving forward, we have the infrastructure in place for users to subscribe to nodes or authors to find updates to Custom Nodes, as well as the ability to see how popular nodes are and to vote up or down a particular functionality.  We also hope to expand the Package Manager to allow for the distribution of more complex libraries and references to build out the functionality of Dynamo.

Download the latest build and look in the Packages dropdown menu to get started.

More improvements in Dynamo 0.6
- Can now use material parameters (Get Material by Name node)
- Intersection nodes return more granular results
- Adaptive Component By Face and By Curve nodes
- Default values for some nodes
- Root finding nodes
- Convert anything to a String (To String node)
- Is XYZ Zero Length & XYZ Length nodes
- New Slice List node (get a sublist from a given list)
- Custom nodes differentiated from built in nodes in search
- Domain node (specify a domain by Min and Max)
- For Each node
- Multithreading nodes
- Nodes to perform explicit lacing (Lace Shortest, Longest, Cartesian)
- Divided Surface Selection node (returns a list of hosted components)
- Add basic instrumentation infrastructure to report usage
- Allow writing a range of data to excel
- Face Face intersection node
- Default value capability for ports

For the full list of Fixes and Improvements, see the ReadMe for 0.6