Dynamo BIM https://dynamobim.org/ Dynamo is a visual programming tool that aims to be accessible to both non-programmers and programmers alike. Thu, 22 Feb 2024 20:57:41 +0000 en-US hourly 1 https://wordpress.org/?v=6.4.3 Dynamo Core 3.0.3 Release https://dynamobim.org/dynamo-core-3-0-3-release/ https://dynamobim.org/dynamo-core-3-0-3-release/#respond Thu, 22 Feb 2024 18:25:44 +0000 https://dynamobim.org/?p=54710 Hello, Dynamites, and welcome to Dynamo’s next chapter with release 3.0.3! This is the first major release since Dynamo 2.0 way back in 2018 (has it really been six years?). …

The post Dynamo Core 3.0.3 Release appeared first on Dynamo BIM.

]]>
Hello, Dynamites, and welcome to Dynamo’s next chapter with release 3.0.3! This is the first major release since Dynamo 2.0 way back in 2018 (has it really been six years?). Below, we’ll go into more detail on what precipitated this change and what it means for users, along with a link to a blog post with the full scoop. To celebrate this milestone, we’ve added a stunning new splash screen image that depicts mountains reminiscent of lunar landscapes, generated with a NurbsCurve surface and colorized with a gradient. As a sneak preview, it’s also this blog post’s featured image.

In this post, we highlight a selection of the top features and fixes in Dynamo 3.0.3. Ready to try it out? Download it from dynamobuilds.com. Got questions, comments, feedback, or just want to join the conversation? Join us on the forum!

TL:DR

Dynamo 3.0.3 targets .NET8 and updates Dynamo’s major version to address technical needs, with impact to package authors. This release consolidates the package management experience, with a single Package Manager dialog to search, install, publish, and maintain packages. This release also adds improvements to node search, makes long text in Watch nodes more readable, and adds a suite of updated Revit sample graphs. You’ll find out-of-the-box Gate and Remember nodes, additional data type support for Data.ParseJson and Data.StringifyJson, updates to the Graph Node Manager, more predictable Zoom Extents for background previews, and other fixes and improvements.

For full details on this release, check out the release notes!

What is Dynamo and its flavors?

What is Dynamo Core?

Dynamo Core is a collection of bundled components that consist of the graphical interface, the compute engine, the scripting language DesignScript, and the out-of-the-box nodes that are not specific to another program like Revit or Civil 3d.

What is Dynamo for <INSERT HOST HERE>?

Dynamo for [Revit, Civil 3d, FormIt, Advance Steel, Alias or Robot Structural Analysis] is a collection of host-specific nodes that work with Dynamo Core and runs inside of said host.

What is Dynamo Sandbox?

Dynamo Sandbox is for package developers and other folks working with Dynamo code who want to stay up to date with the latest and greatest stuff coming out. Sandbox is Dynamo’s “Core” functionality distributed in a way that doesn’t interfere with other Dynamo installations and doesn’t require any other applications (except for a few windows components and some optional extras). You can read more about this distinction here.

So, what’s dropping with Dynamo 3.0.3?

.NET 8 upgrade and major version 3.0

Starting with version 3.0.0, Dynamo is targeting .NET 8. This allows Dynamo to take advantage of the latest improvements from the .NET community, including improved performance and stability, and unlock new features that were not possible until now. Along with Dynamo, most Autodesk hero products (Revit 2025, AutoCAD, Civil3D, etc.) will be migrating to .NET 8 as well. As this brings about backwards incompatible API changes, we are upgrading Dynamo’s major version, following the Semantic Versioning scheme. This change unlocks exciting possibilities, and the Dynamo team is currently working on performance gains that we hope to unveil soon.

While there are no significant disruptions to graph authors and users, there is impact for both authors and consumers of packages. The Dynamo team has reached out to those package authors whose packages will be affected.

Check out this blog post to learn more about the technical aspects of what this transition means for Dynamo package users and authors, including how to migrate packages.

A new world of package management

Dynamo 3.0.3 introduces a consolidated package usage and upload experience, delivered through the new Package Manager dialog. The Package Manager serves as a one-stop-shop for all your package-related needs, making it more efficient than ever to find, install, upload, and manage packages. Access it in the top menu under Packages > Package Manager. The new Package Manager is packed full of features both familiar and new, so let’s take a quick tour into the world of better package management.

  • Package search, available in the Package Manager’s first tab, includes some new goodies:
    • [ 1 ] We’ve added filters for package status and dependencies. For example, if you only want to see new stand-alone packages with no dependencies, this will help you narrow down the search.
    • [ 2 ] Package details now open in the same window, as opposed to a separate panel.
    • [ 3 ] You can select a version directly from the search results by using the version selector drop-down. The versions are listed in descending order, with the latest version at the top.
    • [ 4 ] We’ve brought back a feature that went missing for a while: You can select the folder to install the package to by clicking the arrow next to the Install button.
    • [ 5] Voting is back! You can vote for installed packages from the package details by clicking the heart icon (but exercise caution—at this time, you can’t unvote once you’ve cast your vote).

New features in the Search for Packages tab

  • Publishing a package has a new workflow, along with some smaller improvements:
    • [ 1 ] With the updated version picker, you can either type a number or use the convenient up/down buttons to increment or decrement the number.
    • [ 2 ] We’ve renamed the Dependency field to Host, to better describe the options available in the drop-down.
    • [ 3 ] A brand-new package file upload workflow helps you manage the intricacies of package files! This is especially helpful if you’re uploading a package with a complex file structure.
    • [ 4 ] A new feature of note is the Retain Folder Structure toggle. This toggle is helpful for package authors whose packages rely on a specific folder structure that’s different from Dynamo’s default.

New features in the Publish a Package tab

  • If you’ve uploaded any packages online, they will be listed in the My Packages tab based on your logged-in username. You can install your packages from here directly, without having to search for them. You can also publish a new version or deprecate the package. When publishing a new version, you’ll enter a similar workflow as when publishing a new package, with the existing details filled in. You again have the option to Retain Folder Structure to ensure your package remains functional in the new version.
  • The Package Manager also includes a tab to view your Package Settings. Here, you can view your package download path and package/library search paths. To change the settings, click the link to open the Preferences panel.

As you can see, the entire package experience has undergone a major overhaul, and we can’t wait to have you try it out. Let us know what you think!

An even better node search

Dynamo users have been enjoying a vastly improved node search since version 2.19, but we’re not done making improvements. In our latest release, you can use a period to specify node categories. For example, typing in “list.r” will return nodes that belong to the List category and start with the letter R.

Node search showcasing category search by using a period

Node search is now also able to return nodes that it previously struggled with, such as “And,” “+”, and “*”.

Demonstrating node search with "and" and + nodes

More predictable Zoom Extents

Zoom Extents for the background preview are now more accurate and predictable regardless of the size of the Dynamo application window. Previously, results would vary depending on the size and height/width ratio of background preview view window, making Zoom Extents appear fully incorrect in some cases. In this release, we have dramatically improved the algorithm for Zoom Extents, making it fully predictable regardless of background preview view window size or height/width ratio.

An example of zoom extents before and after the improvement

Data collection for machine learning features

Autodesk collects Dynamo usage data to personalize and improve our users’ experience. But we want to keep you informed and help you stay in charge of your data. That’s why we’ve added new Agreements for Data Collection in the top menu under Dynamo. This dialog provides information about how and why data is collected during Dynamo usage.

In the new section about Node Autocomplete, you can click a link to read more about how the Node Autocomplete feature works and what data is and isn’t collected to power it.

At the bottom of the dialog, you can select the checkbox if you’d like to participate in data collection, or you can click the button to Configure Autodesk Analytics Program for more granular control. It’s up to you if you want to participate in data collection, but please note that the Recommended Nodes ranking method of Node Autocomplete is powered by machine learning and will only be available to those users who have opted in. You can still use the Node Type Match method without opting in. And you can change your selection at any time from this dialog.

Agreements for Data Collection for machine learning features

Graph Node Manager improvements

The Graph Node Manager extension is your command center for graph management, giving you an at-a-glance view of all the nodes in your graph and their current status. And now, Graph Node Manager is better than ever, with a selection of quality-of-life improvements:

  • [ 1 ] There’s a new way to examine node outputs. In the Outputs column of Graph Node Manager, new icons show if the output is a single item or a list, and for lists shows the number of top-level items (up to 9).
  • [ 2 ] When copying error or warning text to clipboard, the text now includes both the original and renamed node name. This makes it easier to troubleshoot issues with colleagues and the Dynamo community.
  • [ 3 ] The Function icon has a new, more legible appearance.
  • [ 4 ] The Export option for exporting node data in CSV or JSON format has been moved to the bottom right.

Updates to the Graph Node Manager

Refreshed Revit sample files

Good news for users of Dynamo for Revit: We’ve cleaned up and improved the suite of sample files available in the top menu under Help > Samples. In addition to eliminating deprecated nodes and overlap, we’ve added helpful groupings and notes to explain how the graph works. With this update, it’s never been easier for new users of Dynamo for Revit to start exploring Dynamo’s possibilities!

More readable Watch nodes

Using long text in Watch nodes? With this release, you’ll find it’s more readable than ever! Scroll bars now appear by default, without needing to hover, and you can use the resize handle to display more text without scrolling.

Example of long text in a Watch node

Data.ParseJson and Data.StringifyJson data support

Data.ParseJson and Data.StringifyJson nodes now support most Dynamo standard data types. This includes all Geometry types except Topology, Color, Location, and Image.

Gate and Remember nodes, right out of the box!

The standard Dynamo library now includes the Gate and Remember nodes. The Gate node allows you control the execution in sections of your graph. An open Gate passes data through unchanged, while a closed Gate sends no data downstream—similar to freezing a node, but in the form of a separate node. A Remember node stores the data passing through it to the Dynamo file and returns the stored data if the input is null.

Gate and Remember nodes

Formula nodes auto-converted to Code Blocks

If you’ve been using Formula nodes, note that they have been deprecated and are no longer available due to the .NET upgrade. Any Formula nodes used in graphs will be automatically converted to Code Blocks where possible. A warning will alert you to converted nodes, as well as any nodes that failed to convert.

Better Node Autocomplete results for custom node output ports

Previously, Dynamo may have struggled when using Node Autocomplete with the Node Type Match method on custom node output ports, failing to find results even for valid type names. Now, you should start seeing improved results for custom node output ports.

Offline mode

We’ve added a new “NoNetwork” mode to command line arguments used in starting up Sandbox, DynamoCLI, and DynamoWPFCLI. This mode runs Dynamo offline and disables the following features:

  • Sign-in and the ability to publish packages online
  • Notification center
  • Node autocomplete Recommended Nodes requests are blocked
  • Usage agreement (consent dialog)

Additionally, the DisableAnalytics flag can be used to disable analytics even when Dynamo is running online.

Element Binding support

Element Binding has dropped support for the deserialization technique in older versions of Dynamo. Dynamo 3.0 and beyond uses Strings. To migrate existing graphs that contain Element Binding, you will need to resave them. If your graph contains element binding data in the legacy format, you’ll see the following message:

Element binding message

As a part of this change, Dynamo is discontinuing use of SoapFormatter and switching to JSON serialization. SoapFormatter was previously used to serialize element binding data and is no longer recommended due to security risks.

Bug fixes

  • We fixed a bug that caused BoundingBox.ToCuboid to return null for a zero-height (2D) bounding box.
  • The coordinate system of a bounding box created by BoundingBox.ByMinimumVolume is now less likely to flip its axes when the input geometry varies.

Good stuff! So where can I grab Dynamo 3.0.3?

Dynamo 3.0.3 will be made available in our host integrations at a future date and can be explored right now through the dynamobuilds.com website or the GitHub build page – available in the Sandbox version of Dynamo.

If you’re curious, you can also read our Release Notes

For more information on other minor features, bug fixes, and known issues in Dynamo 3.0.3, take a look at the release notes!

We’d like to extend a huge thank-you to everyone who made this release possible and to the entire Dynamo community for continuing to support our work. Be sure to stay tuned to the Dynamo Roadmap, where you can take a look at current and upcoming work, express your support for features you want to see, and let us know what you think by adding a comment.

The Dynamo Team

 

 

 

 

 

The post Dynamo Core 3.0.3 Release appeared first on Dynamo BIM.

]]>
https://dynamobim.org/dynamo-core-3-0-3-release/feed/ 0
Dynamo on .NET 8 https://dynamobim.org/dynamo-on-net-8/ https://dynamobim.org/dynamo-on-net-8/#respond Thu, 22 Feb 2024 16:15:45 +0000 https://dynamobim.org/?p=54754 Dynamo is migrating to .NET 8 We are happy to announce that Dynamo 3.0 will run on top of the .NET 8 framework. Dynamo is taking this important step to keep …

The post Dynamo on .NET 8 appeared first on Dynamo BIM.

]]>
Dynamo is migrating to .NET 8

We are happy to announce that Dynamo 3.0 will run on top of the .NET 8 framework. Dynamo is taking this important step to keep up to date with the major evolution of the .NET.

.NET represents the unified successor of the various .NET frameworks and platforms: .NET Framework, .NET Standard, .NET Core, and Mono. In contrast to the old .NET 4.8 technology, .NET 8 is a more modern, cross-platform, and open-source framework. Along with Dynamo, most of Autodesk AEC products (Revit 2025, AutoCAD, Civil 3D, etc.) will migrate to .NET 8 as well.

The transition to .NET 8 will allow Dynamo to take advantage of the latest improvements from the .NET community, including improved performance and stability. It will also unlock new features that were not possible until now.

Here are some of the cool features that Dynamo will start using (some are not yet fully supported in the 3.0 release):

  • Assembly isolation – this will allow Dynamo packages to coexist without the fear of conflicting dependencies.
  • Assembly unload – this will allow Dynamo packages to be unloaded completely from the application without needing a restart.
  • New language features that will have a great impact on performance – too many to list here
  • Cross-platform support – DynamoCore (core part of Dynamo) has renounced its mono build in favor of targeting .NET 8. This means DynamoCore can run on any platform that supports .NET 8 (such as Linux, Mac, etc.).

In this blog post, we will focus more on the technical aspects of what this transition means for Dynamo package users and authors.

What this means for the Dynamo community

While the transition from .NET 4.8 to .NET 8 is a major undertaking, it does provide a lot of benefits, like compatibility with the latest tools, performance enhancements, easier and more concise code, etc. Going forward, we are planning on transitioning Dynamo to new versions of .NET on a regular schedule. This in turn will most likely require package authors to do the same with their packages. To ensure compatibility with both Dynamo and .NET, we encourage package authors to migrate to the same versions of .NET that Dynamo is targeting.

Looking forward, we expect the effort for future .NET migrations (for example, from .NET 8 to .NET 9) to be significantly smaller (mostly, you’ll only need to change the TargetFramework property in your project file).

Along with the migration to .NET 8, Dynamo has also upgraded its major version. We made this transition at the same time as the migration to .NET 8 because it seemed like a good opportunity to enhance and improve the Dynamo codebase.

Here are some of the highlights:

  • Dynamo 3.0 has some new requirements. For example, you will need to have .NET 8 runtime (or the SDK) installed on your system. More on the requirements can be found in the Dynamo GitHub Readme and the Dynamo wiki pages.
  • The transition to .NET 8 will likely have an impact on existing Dynamo packages that use .NET assemblies that target older versions of .NET (like net48). To ensure compatibility, we recommend that Dynamo packages migrate to .NET 8 along with Dynamo. If there are cases where you need to deliver package updates for older versions of Dynamo (on net48), please see the FAQ section of this post on multitargeting.
  • The core runtime of Dynamo (DynamoCore) is now cross-platform by targeting .NET 8 core. This allows DynamoCore to run on any OS that also supports .NET 8 (for example, Linux, Mac, etc.).
  • Dynamo 3.0 has introduced some changes to its API layer:
    1. A large part of the Dynamo obsolete APIs have been removed and/or replaced with new APIs.
    2. Dynamo no longer uses binary serializers because of new .NET 8 security guidelines.
    3. New geometry node improvements (functionality and performance enhancements).

More info on the Dynamo 3.0 changes can be found in the Release Notes.

  • The Dynamo team will scan all packages on dynamopackages.com for .NET 8 compatibility issues and will notify their maintainers that an upgrade will be necessary. We will also consider running this analysis for all new package uploads as well to hopefully catch any packages that are using older .NET versions than the targeted Dynamo version and warn authors of potential issues. More information on the analysis tool can be found here.

Will my package be affected?

The Dynamo migration to .NET 8 will most likely affect packages that use .NET 4.8 framework (or older) assemblies. There’s a small chance that some packages will still work without having to migrate (depending on what .NET APIs were used), but there is no guarantee of compatibility. If your package is already somewhere in between .NET 4.8 and .NET 8 (for example on .NET 6) compatibility has a higher chance of success, but it is still not guaranteed. Our recommendation is that packages should be on the same versions of .NET that Dynamo is targeting.

Packages that do not have .NET assemblies will not be affected. Some examples here could be packages with only Python scripts, custom nodes with no assemblies, or zero touch packages that were already targeting .NETStandard 2.0.

Compatibility could also be affected by package dependencies. If a dependency has not yet been migrated to .NET 8, it may cause compatibility issues when installing your package. An example that would fall in this category would be custom nodes that depend on outdated Dynamo packages. If your package has dependencies on other Dynamo packages that are not compatible with .NET 8, there are some options you could explore:

  1. Reach out to the package maintainer to address the migration. The Dynamo team will also contact all package maintainers to notify if any of their packages need to migrate.
  2. Replace the dependency with a package that has already been migrated or with your own implementation, if possible.
  3. Run the incompatible code (that has the dependency) in a separate process. This might be highly technical, but it would isolate the offending code from Dynamo.

A special mention for packages containing .NET assemblies that target .NETStandard 2.0 (or older .NETStandard versions): These will be compatible with .NET8 and additionally will still be compatible with .NET 48 without any need to migrate them. .NET 48 framework and all new .NET framework versions (like .NET 8) are based on .NETStandard 2.0, so compatibility is assured. The pros and cons of using .NETStandard as a target are covered in the migration steps below and in the FAQ section.

How to upgrade my existing package to Dynamo 3.0

To ensure your package will continue to run smoothly in Dynamo after version 3.0 is released, you will need to migrate it to .NET 8 (or netstandard2.0 if possible). Before the migration can start, package authors will have to do some groundwork. Most of this prep work can be done (or at least started) by using the Upgrade Assistant from Microsoft. This tool can migrate your projects to the new format and also look for any .NET 8 incompatible dependencies. There is also comprehensive documentation on how to create a migration plan written in the Microsoft docs.

Here are the basic steps you should take to get your project .NET 8 compatible:

  • Use the PackageReference format.

Remove any packages.config files in your project and convert all references from your .csproj files to the PackageReference format.

  • Update dependencies.

Update your project’s NuGet dependencies to first match Dynamo’s dependencies or to their latest available version. If your package has a common dependency with Dynamo, you need to make sure that the dependency versions do not conflict. If a dependency conflict is found, Dynamo will show a warning message at startup and your package will probably not be loaded (or will be left in an error state).

Dynamo’s dependencies can be found in the licensing information or by running the dotnet list package command on the Dynamo solution file. An example of generating a unique list of all Dynamo’s dependencies can be found here.

Below you will find an example of how a conflict of dependencies can occur:

Lets take the case of Newtonsoft.Json (version 13.0.1), a very popular and widely used NuGet package, which happens to also be a dependency for Dynamo 3.0. If a Dynamo package brings in Newtonsoft.Json with a version greater than 13.0.1, it will cause a dependency conflict and the package will most likely fail to load. This issue might be mitigated by using ALCs (assembly load contexts) to load packages in isolation; however, at the moment Dynamo has a very limited use of this technology for package loading (only a very few select packages are loaded using ALCs).

Note: When looking into NuGet replacements, please keep in mind that some .NET APIs might have been moved to dedicated NuGet packages or to other system assemblies. Also some NuGet packages might not be .NET 8 compatible yet.

  • Update the <TargetFramework> property in your C# projects.

You can choose to target either .NETStandard 2.0 or .NET 8.
If you need your package to be compatible with both .NET 4.8 (Dynamo 2.19) and .NET 8 (Dynamo 3.0), you should try to target .NETStandard2.0 (<TargetFramework>netstandard2.0</TargetFramework>). More on this can be found here.
If your package needs Dynamo, Revit, Windows, or WPF APIs (or simply does not need to run on Dynamo 2.19), then you can target .NET 8 directly (<TargetFramework>net8.0</TargetFramework>).

If you package is already on a lower version of .NET (like .NET 6), we still recommend that you migrate to the same .NET version that Dynamo is targeting, in order to ensure compatibility.

  • Add Windows API or WPF API support as needed.
    If your package is a view extension, or has need of Dynamo’s UI API layer, you will need to add references to the WPF APIs and/or Windows APIs. This can be done by adding <TargetFramework>net8-windows</TargetFramework> for Windows APIs access and <UseWPF>true<UseWPF> for WPF API access. Here is an example.
  • Optional: Use the <EnableDynamicLoading>true<EnableDynamicLoading/>  property to ensure all required NuGet references (i.e., NuGet package assemblies) are copied to your output folder. More info on this property can be found here.
  • Ensure that Dynamo assemblies are not delivered with your packages.
    This can be done by using the ExcludeAssets = "Runtime"  property in Dynamo package references. 
    Packages in Dynamo follow a standard plugin model. This means that packages should not have any Dynamo assemblies in their package/bin folder. All Dynamo assemblies will already be loaded by Dynamo, so it would be redundant for packages to have them too.
    Another example of unnecessary assemblies would be those from a Dynamo host application (like Revit, Civil 3D, or any other). Some Dynamo packages for Revit might reference the RevitAPI.dll and RevitAPIUI.dll. These should not be delivered with your package because they will already be loaded by Revit.

 

How to create a new Dynamo package

For those starting out with new packages, please be mindful of what version of Dynamo you are targeting:

  1. Older versions (2.19 or bellow) require .NET 4.8.
  2. Newer version (3.0 or above) require .NET 8 or above (please check what version of .NET is used by the Dynamo version you wish to target)
  3. For multi-targeting (Dynamo 2.19 and Dynamo 3.0), please see the below section on multitargeting.

Here are some examples on how to start out from scratch:

  1. Create an extension for Dynamo: https://github.com/DynamoDS/DynamoSamples/tree/3.1.0/src/SampleExtension
  2. Create a sample UI library for Dynamo: https://github.com/DynamoDS/DynamoSamples/tree/3.1.0/src/SampleLibraryUI
  3. Create a sample zero touch library (a library that does not reference any Dynamo APIs): https://github.com/DynamoDS/DynamoSamples/tree/3.1.0/src/SampleLibraryZeroTouch
  4. Create a sample linter for Dynamo: https://github.com/DynamoDS/DynamoSamples/tree/3.1.0/src/SampleLinter
  5. Create a sample view extension for Dynamo: https://github.com/DynamoDS/DynamoSamples/tree/3.1.0/src/SampleViewExtension

More information on how to get started with creating Dynamo libraries can be found here:
https://primer2.dynamobim.org/6_custom_nodes_and_packages/6-2_packages
https://primer2.dynamobim.org/6_custom_nodes_and_packages/6-1_custom-nodes 
https://github.com/DynamoDS/Dynamo/wiki/How-To-Create-Your-Own-Nodes
https://github.com/DynamoDS/Dynamo/wiki/Zero-Touch-Plugin-Development
https://github.com/DynamoDS/Dynamo/wiki/Building-a-Package-for-Dynamo-in-Visual-Studio

How to add tests for my Dynamo package

We recommend that all Dynamo packages implement some sort of automated tests. This would ensure that your packages do not break functionality/compatibility with the targeted Dynamo version.

To get started, please take a look at some of the examples we have put together:
https://github.com/DynamoDS/DynamoSamples/tree/3.1.0/src/SampleLibraryTests
https://github.com/DynamoDS/DSIronPython/tree/master/IronPythonTests

More on writing unit tests for Dynamo libraries can be found here:
https://github.com/DynamoDS/Dynamo/wiki/Writing-Unit-Test-Libraries-for-Dynamo

FAQ

How can I make my Dynamo package/extension run on both Revit 2024.2 and Revit 2025 (multitarget .NET 4.8 and .NET 8)?

  1. If you plan to only support Dynamo 3.0 (and Revit 2025) going forward, you can just migrate your package to .NET 8 and update the supported engine to Dynamo 3.0. Revit 2024 (and Dynamo 2.19 or older) will still be able to download the old versions of your package (which will still be compatible).
  2. If you plan to keep updating your package for both Dynamo 2.19 (Revit 2024) and Dynamo 3.0 (Revit 2025):
    Dynamo packages do not support multitargeting (.NET 4.8 and .NET 8 at the same time); also, Dynamo packages cannot receive updates for older versions (for example, if you have a package that has the versions 2.0.0 and 3.0.0, you will not be able to push an update for the version version 2.0.1).Here are some solutions:

    1. Try to migrate your package to .NETStandard 2.0. This might not be possible for some packages (that need Windows, WPF, or Dynamo APIs). However, if your package can target .NETStandard2.0, it will be compatible with both net48 and net8 and will run on both Dynamo 2.19 and Dynamo 3.0. .NETstandard is not as much a framework but an API specification, but it can be used as a target via <TargetFramework> in your C# project. More information on NETStandard can be found in the Microsoft docs.The downside to .NETStandard2.0 is that it has a limited API layer (no Windows APIs, no WPF, etc.) and is not compatible with PackageReferences that target any other framework except NETstandard. An example of this limitation is that a package targeting netstandard2.0 would not be able to reference most Dynamo NuGets (because those already target .NET 8 or .NET 4.8). However, a working case would be for ZeroTouch libraries that do not use many Dynamo APIs. The only Dynamo NuGets that specifically target .NETStandard 2.0 are DynamoServices and ZeroTouchLibrary. More on getting stated with Dynamo zero touch libraries can be found on the Dynamo GitHub wiki.If, while targeting .NETStandard 2.0, you see build errors about missing APIs, then you probably need to target .NET 8 (with or without Windows and WPF support).
    2. Duplicate your package and change the name: one for Dynamo 2.19 and one for Dynamo 3.0.
      The package for Dynamo 2.19 will target .NET 4.8 and only work on Dynamo 2.19.
      The package for Dynamo 3.0 will target .NET 8 and will work on Dynamo 3.0.
    3. A more complicated solution is to create a simple entry point assembly (which should target .NET Standard 2.0). This will ensure it is loadable in both net48 and net8.

      Then, have the entry point assembly figure out which environment it is in (either by checking the .NET version or the Dynamo version)
      Based on the environment, it should download the correct package assemblies from the web:* if on Dynamo 2.19 or older, download Package2.19 assemblies
      * if on Dynamo 3.0 or newer, download Package 3.0 assemblies

I am using Dynamo 2.19 on top of Revit 2024.2. Do I need to do anything ?

The .NET 8 transition of Dynamo 3.0.0 will not impact Revit 2024.2 or Dynamo 2.19.x. All Dynamo packages (the specific versions of those packages) that used to work on 2024 will continue to work.

However, there might be issues with the newer versions of Dynamo packages. Once a package is migrated to .NET 8 (to support Dynamo 3.0), it will no longer load in older versions of Dynamo. For example, let’s consider the Dynamo package Rhythm:

  1. Rhythm@2023.8.7 loads with no problem in Revit 2024.2 with Dynamo 2.19.
  2. Let’s assume that the next version of Rhythm (e.g., 2025.0.0) is migrated to .NET 8 to support Revit 2025 and Dynamo 3.0.
  3. If you open up Revit 2024.2 with Dynamo 2.19 and try to install the latest version of Rhythm (2025.0.0), you will most likely get a warning at install time and errors at load time (because some .NET 8 library is not found).

This is a screenshot of what the warning looks like at package install time:

 

Dynamo packages were not designed to support multitargeting (support both net8 and net48), and compatibility (or lack of it) is not communicated very well in the user interface.

I am using Dynamo 3.0 on top of Revit 2025. Do I need to do anything ?

For Dynamo 3.0.0 users, whether sandbox or as part of other Autodesk software like Revit or Civil 3D, you should only keep in mind that some packages might not be migrated to .NET 8 yet. Some old packages (that target net48) might still work with Dynamo 3.0.0, but compatibility is not guaranteed. The best way to proceed is to check if the package you are trying to install supports your current Dynamo version.

More on this in the topic below.

How can I tell if a package is compatible with Revit 2024 (Dynamo 2.19) or Revit 2025 (Dynamo 3.0) ?

At the moment, Dynamo does not explicitly show the .NET (or Dynamo version) compatibility for packages, and though we are working on getting this in a better state, for now let’s go over some alternative ways to get the same information. Some packages have the Dynamo version as part of the package description (this could be seen even on the dynamopackages.com website).

Another way to check if a package is compatible with your current version of Dynamo is to try to install it. If the package version is not compatible, you will see a warning message like so:

However, this only works if the version of the package was built on a newer version of Dynamo than the one you are currently using.

A more convoluted way is to get the Dynamo version of the package directly from your browser. You can access the following link to get the Dynamo version information.

https://dynamopackages.com/package_version/dynamo/name/version
name  should be the package name
version  should be the package version

The response body should contain a field called engine_version. This represents the version of Dynamo that the package was built on. At the very least, the package should work on that version of Dynamo.

Here is an example of the url: https://dynamopackages.com/package_version/dynamo/archi-lab.net/2023.213.1722 with a truncated response: {"timestamp":1708458380283, "success":true,"id":"53e99ce50e5572016a00018a",
"engine_version":"2.12.0.5740","name":"archi-lab.net"}}
.

If you use Dynamo 3.0 (or newer), any package that targets Dynamo 2.19 (or lower) is not guaranteed to work anymore. If you use Dynamo 2.19 (or older), any package that targets Dynamo 3.0 (or newer) will not work (but you will see a warning message at package install time).

 

Thanks – Dynamo Team

The post Dynamo on .NET 8 appeared first on Dynamo BIM.

]]>
https://dynamobim.org/dynamo-on-net-8/feed/ 0
The Red Sea International Airport Project: Pioneering BIM Efficiency https://dynamobim.org/the-red-sea-international-airport/ https://dynamobim.org/the-red-sea-international-airport/#respond Fri, 09 Feb 2024 00:00:46 +0000 https://dynamobim.org/?p=54632 The Project Red Sea International Airport began construction in 2021, 15 kilometers inland from the coast of the Red Sea. It is being designed by Foster + Partners in collaboration with architecture …

The post The Red Sea International Airport Project: Pioneering BIM Efficiency appeared first on Dynamo BIM.

]]>
The Project

Red Sea International Airport began construction in 2021, 15 kilometers inland from the coast of the Red Sea.

The Red Sea International Airport

It is being designed by Foster + Partners in collaboration with architecture studio Jacobs as a gateway to the wider development.

Its curved form and plan are intended to emulate the desert landscape and will be characterized by five dune-like pods arranged around a central drop-off and pick-up space.

Introduction

In the rapidly progressing world of architectural workflows, the quest for innovation is relentless. This blog post casts a spotlight on the groundbreaking strategies implemented in two megaprojects that have recently graced our portfolio. The Al-Wasel Tower, with its workflow detailed in an earlier post, serves as a prelude to our exploration of the Red Sea International Airport project. Both undertakings presented a spectrum of geometrical complexities, from the extreme double-directional curved surfaces to other engineering challenges that necessitated the training of AI models—a topic for a future discussion.

Building upon the knowledge gained from the Al-Wasel Tower, we confronted the Red Sea International Airport project, determined not to repeat past mistakes but to innovate and streamline our approach.

The Al-Wasel Tower Approach Revisited

Al-Wasel Tower Site Image

Before diving into the Red Sea International Airport project, let’s briefly revisit the Al-Wasel Tower’s methodology. The tower’s panels, adaptive component elements rich with fabrication parameters, were designed to configure the geometric behavior of the facade.

Panels at an arbitrary Zone

The technical solution involved creating multiple panel configurations—flat and non-flat—to accommodate the tower’s complex curvature. This approach, it led to a highly nested family structure within Revit, which, while robust, proved to be a time-consuming and cumbersome method for project updates.

As updating each zone, which consists of 4 to 5 levels on average, needed 9-12 hours to finalize the reloading process for each revision.

This time barrier was cumbersome and very stressing with tight deadlines.

Here’s an overview of a small number of nested family’s configuration of the Al-Wasel Panel.

Nested Families structure of the Al-Wasel panel

Formulas inside the panel family of Al-Wasel Tower

The Red Sea International Airport: A New Paradigm

While we handled multiple challenges in the project, that includes Roof cladding (which needed training a coordination prediction-based AI Model), gutters and Ceiling paneling of the Red Sea International Airport.

Overview of the Roof Cladding of the Red Sea Airport

Overview of early design stages of the Ceiling panels and Roof cladding

Perline’s analysis and Gutter model

Overview of the roof cladding in POD 5

In this blog post I’ll focus on the Ceiling paneling challenge, which presented us with an opportunity to reflect on our previous approach and opt for a more efficient solution.

The project contained more than 10,000 double-directional unique curved ceiling panels.
Which in regular scenarios is impossible to implement manually in a very limited timeframe.

Ceiling paneling different elements and geometry

Dynamo to the Rescue

The powerful workflow we developed in Dynamo and Synthesize toolkit package, allowed us to maintain a “Panel” configuration by utilizing only the coordinates and lines of a very basic Adaptive Component families—a simpler and more maintainable method compared to the complex geometric relationships in the previous Al-Wasel Adaptive Panel.

In addition, through smart coding, we developed an updatable system that significantly reduced the need for laborious updates and maintained the integrity of the project’s annotations and relationships.

Synthesize toolkit is publicly available for community use, created and maintained by Karam Baki

The Synthesize Toolkit package in Dynamo

 

The Workflow in Action

The project had 5 Pods, we started with a set of surfaces, a surface for each Pod, created in Fusion 360, inserted to Revit via [KFamilyInsert] node in Dynamo, which is the smartest geometrical node we’ve ever created, that does automatically heal and translate different sources of data into Revit native geometry (we might discuss later on another post), thus we represented the base surface of the Ceiling Panels.

And with Dynamo, we placed Empty Adaptive Components that represented the Ceiling Panels as Placeholders and used a specialized Dynamo node to align the adaptive points consistently, similarly to Al-Wasel Tower’s auto placement and sorting mechanisms.

Fusion 360 ceiling surface inserted to Revit as a reference

Naming System and Panel Types

A naming system was implemented to automatically assign identifiers [Panel_ID] to each panel, with the flexibility to rename them based on an external Excel file.
In addition, exterior and interior Family Types were assigned to the empty Adaptive Components Placeholders, this system was crucial in managing the Exterior and Interior panels geometry, the latter featuring additional U-Channels for structural support.

Naming and type structure for the ceiling panels

Code-Driven Generation

We introduced a code that is capable of reading profile families from the company’s web server, getting their lines and coordination systems, and map them onto the adaptive components placeholders, generating all parts of the panel.

Code overview

 

We then batch utilized this code, to produce a wide range of panels across multiple Revit instances at the same time!

Distribution of panel creation across multiple instances

As-per the illustrations above, we tricked Revit by utilizing all of the available CPU cores in a machine by splitting the CPU core utilization dynamically, this process was not only efficient but also scalable, generating 1,000 panels in just 15 minutes per instance.

Folder structure long with .SAT and .CSV files generated out of Dynamo

Output and Integration

The generated .SAT files, were handled in another code that mapped subcategories, material colorization, and separation by custom instructions, Concurrently, .CSV files containing panel data were produced, ensuring that all quantity-related information was captured and ready for integration.

Overview of fabrication orders automatically generated.

Workflow In Action

The following is a comparison between Multiple Instances and Single Instance workflows, the difference of time completion is obvious.

Paneling process in action

Multiple (10 Instance) workflow time: 15-20 minutes.

Multiple (4 Instance) workflow time: 1:30 hours.

Single (1 Instance) workflow time: 5-6 hours.

Updatability: Breaking the Time Barrier

The innovative approach taken with the Red Sea International Airport project shattered the constraints of time-consuming updates. By providing the ability to re-generate and re-utilize .SAT and .CSV files automatically, we were able to overwrite existing panels with updated details quickly and efficiently, maintaining project continuity without the need for recreating and placing panel families from scratch.

Updatability in action

Video Presentation:

We also have a video presentation prepared showcasing the ceiling paneling process and a sneak peak of the fabrication orders we were able to automatically generate as well, along with other insightful details, along with some tools to replicate the paneling work at your device, just to get a sense of how smooth the whole process is.

Presented at AU 2023 with Sol Amor and Lilli Smith at Dynamo Briefing Session

Conclusion

Ultimately, the Red Sea International Airport project not only benefited from the lessons learned from the Al-Wasel Tower but also set a new standard for efficiency and adaptability in BIM workflows. The strategic use of adaptive components as placeholders, combined with the power of Dynamo coding, resulted in a workflow that is both precise and flexible, with a precision reaching down to 2mm clash free results for a complex double directional curved geometry.

Navisworks clash test in action

Sign off.

We are certain that sharing these insights and workflows, along with some of the tools, will empower industry professionals to achieve greater efficiencies and foster innovation in their own projects.
The strides made in these projects are a testament to the potential that lies in embracing new technologies and methodologies in the realm of construction and design.

Stay tuned for more updates as we continue to push the boundaries of what is possible in the world of BIM and architectural workflows.

Best Regards,

Karam Baki
Head of R&D / BIM Manager
AEC GROUP

The post The Red Sea International Airport Project: Pioneering BIM Efficiency appeared first on Dynamo BIM.

]]>
https://dynamobim.org/the-red-sea-international-airport/feed/ 0
The Al-Wasel Tower Saga, Part 1 – From Design to BIM https://dynamobim.org/al-wasel-saga-ep1/ https://dynamobim.org/al-wasel-saga-ep1/#respond Thu, 14 Dec 2023 17:27:16 +0000 https://dynamobim.org/?p=54584 The Al-Wasel Saga, Part 1 – From Design to BIM Introduction: Al-Wasel Tower is not just an architectural and artistic triumph. It’s also a testament to Dubai’s commitment to technological …

The post The Al-Wasel Tower Saga, Part 1 – From Design to BIM appeared first on Dynamo BIM.

]]>
The Al-Wasel Saga, Part 1 – From Design to BIM

Introduction:

Al-Wasel Tower is not just an architectural and artistic triumph. It’s also a testament to Dubai’s commitment to technological innovation in the construction industry. Specifically, the project is a shining example of the city’s adoption of Building Information Modeling (BIM) technology. This state-of-the-art approach to building design and management has become a mandatory requirement for certain types of buildings in Dubai, marking a significant step forward in the city’s vision for sustainable and efficient construction.

Al-Wasel Tower, a 63-story mixed-use development in Al Wasl, Sheikh Zayed Road, Dubai, is a 300-meter long, twisted architectural marvel. The design is the brainchild of UNStudio, and the project is being developed by the Wasl Asset Management Group.

The tower employs a twisting, asymmetrical design inspired by the “contrapposto” pose commonly used in classical sculpture, intended to give an effect of dynamic motion.

The building will also feature one of the world’s tallest ceramic facades composed of clay-based materials, with an overlaid lacework of fin-shaped tiles. These are designed for energy efficiency and comfort, providing shade from the fierce Dubai heat that reduces the need for air conditioning, and deflecting light into the interiors.

Source: Wasl Tower in Dubai: The supertall ceramic skyscraper that ‘breathes’ | CNN

Conceptual Images, Renders are Courtesy of Methanoia and Plompmozes

 

On-Site, Images are Courtesy of AEC Group

The Challenge:

For years, numerous other engineers attempted, only to encounter setbacks when the panels initially mounted on the tower, and thus had to be taken down.
The panels, shaped like parallelograms on the twisted tower, along with the aluminum FT10 parts that curved in two directions, proved to be a difficult geometrical challenge to solve.

FT10 Connections

Our Involvement:

After several years, we were summoned to tackle the longstanding complex geometric challenges. We were successful, and many of our solutions are now available for community use in the Synthesize toolkit package in Dynamo. This toolkit is created and maintained by Karam Baki (CEO and Head of R&D in AEC Group)

The Synthesize Toolkit package in Dynamo

The Paneling Process:

In this installment of the Saga, we will guide you through the initial stage of the paneling process, using Dynamo and Revit to create a comprehensive BIM model for the tower panels. This model was a crucial element that allowed the fabrication team to proceed with confidence, ensuring the accuracy and integrity of each fabricated panel.

Panels at an arbitrary Zone

Fabrication Data in Excel, and Formulas in the Panel Component

The Design Stages:

During the design stages, UNStudio design team. delivered a pre-rationalized facade wireframe that aligns with the structural design. This is a best practice that computational designers should do to communicate with each other, especially in massive projects involving numerous parties.

UNStudio Panel Points

Working with a Messy CAD Model:

Due to multiple subconsultants entering the construction process over the years, and the fact that the tower’s concrete floors were already completed on site, we found ourselves working with a CAD model that had been modified multiple times by various parties. The model consisted of “Meshed Panels” and “Extra Yellow” lines meant to split other panels.

In short, we had to start from a messy, geometrically unreliable reference. 

Unreliable Geometrical Reference


Translating the Data (1st Goal):

As tech wizards, we had to translate this data. Our first goal was set to extract the four points of each panel from the chaotic meshed model. We began with Rhino, importing the model and running the DupBorder command to extract the outlines. However, this process produced many points and lines, some of which were faulty. Even with SimplifyCrv command in Rhino, there are still faulty points appearing.

Faulty Outlines


Cleaning Up Panel Borders (2nd Goal):

With Al-Wasel having more than 9000 complex panels, it was impractical to manually place the panels and disregard the intermediate lines and points. So, our second goal was set to automatically clean up the panel borders.

We fired up Dynamo in Revit and having Synthesize toolkit ready. We inserted the resulting wireframe model and used the [GetElementsData Node] to extract the PolyCurves. We simplified them by angle using [SimplifyPolyCurvesByAngle]. This smart node we programmed disregards any intermediate points that form a new line with a smaller angle than a provided tolerance. In our case, half a degree was sufficient.

PolyCurves After Simplification

Now with clean border lines, our second goal is accomplished.


Splitting the Panels (3rd Goal):

We overlooked the splitting “Extra Yellow” lines in the CAD file.

Extra Yellow Splitting Lines

This oversight led us to our third goal: splitting the panels.

To do so, we reconstructed the surfaces from the resulting PolyCurves using the [LoftByFourCurvesPolyCurve Node]. This node does its best to recreate a lightweight lofted surface based on the inserted PolyCurves. In practical terms, it uses the first and third curves (or the second and fourth) – the result is the same in our case.

Panels After Reconstruction

Next, we inserted the “Extra Yellow” Lines CAD file, then used a smart node called [FindNearestSurfaces], it identifies the surfaces closest to the curves, which saves huge computational power when proceeding to the splitting operation. The output from the resulting groups was extended and extruded to form “knife”-like surfaces. These were used to split the reconstructed panels above, as the “Extra Yellow” lines themselves were not accurately aligned with the panels. However, extending and extruding, should solve the problem.

Panels After Splitting

We have now achieved our third goal.

Extracting Points of Each Panel (Returning to the 1st Goal):

Our initial goal was to extract the four points of each panel. Now, with the split and reconstructed panel surfaces, we can readily extract the clean border points of each panel.

Panel Points

Sorting Adaptive Points (4th Goal):

Alright, we have our points ready and our parametric adaptive family on standby.
We used the [AdaptiveComponents.PlaceByPoints node] and placed the initial panels.

Panels Placement

However, we noticed that the points order of the panels was not sorted correctly. This was somewhat anticipated, as generally speaking, extracting arbitrary geometrical data does not guarantee a consistent order.

This led us to our fourth goal: correctly sorting the adaptive points, as it is extremely important step for further geometry implementation of the panel parts. This would guarantee consistent fabrication orders.
We developed an automatic algorithm that only required one correctly ordered panel for reference.

Automatic Sorting

Our fourth goal was accomplished flawlessly.

Analyzing the Tower (5th Goal):

Now that everything is in order, we still need to analyze the tower and extract some initial values required for fabrication in later stages. Thus, we set a fifth goal: to analyze the panels.

Panel Analyses

Panels that bend less than 5mm are considered flat.

Panels that bend less than 50mm are considered “Cold Bent” panels, which means the glass can be bent without physically failing.

However, there are some complex double-curved ones that exceeds 50mm can’t be fabricated in this manner.

The designer’s intent was to arrange them in a “Fish-like” pattern.

Fish Pattern

Fish Pattern

This design is aesthetically pleasing. So, how did we achieve that? It might seem straightforward, as you can create a plane from the first three points and project the fourth point onto it, right?

Incorrect Point Projection

Well, yes and no. While the idea is sound, the resulting position of the fourth point might be inaccurate. This is because projection doesn’t ensure the newly formed panel edges are equal to the edges of the panel before projection, which can lead to fabrication issues down the line.

To maintain integrity, we created a new node called [Physics.SimulateLastPlanarPoint node]. This node operates more like an “Unfolding” concept. Essentially, it simulates the position of the fourth point using specific goals. In our case, the goal was for the fourth point to be pulled to the plane generated from the first three points, and the lengths of the newly formed edges should remain the same as the original panel edges.

Corrected Point Projection

Perfect! Now we can perform a full simulation!

 

Full Simulation

Dynamo processing time: 1 minute
Revit processing time: 2 hours

Finally, with some clever math, we were able to extract all the required dimensions, twisting angles, and initial calculations for the fabrication team to proceed.

Dimension Extraction

Our fifth goal was successfully accomplished.


Further Developments

We created other helpful nodes along the way to help us navigate through some other issues. For example, some panels needed “better” topology. Some “Fish” panels needed to turn into “Cold Bent”, some of “Cold Bent” panels needed to turn into “Flat”, and some of the Façade parts needed to have better overall harmonic transition behavior.

So, we created [Physics.SimulateCoPlanarPoints node] which consists of state-of-the-art automatic simulation algorithms that tries it’s best to force the target panels to improve their curvature and decrease it without actually hurting the design intents.

Improved Harmonic Transition in Facade Panels

Conclusion:

I would like to extend my deepest gratitude to everyone involved, both directly and indirectly, including all consultants and sub-consultants, especially the facade consultant IBECE group who we worked with during that stage, as well as those who have made positive contributions to the project over the years. Together, we have gained substantial knowledge, fostered innovation, and embarked on a challenging journey. Despite the odds, we triumphed, successfully turning our collective vision into a reality.

It’s also important to acknowledge that without the application of sophisticated mathematical and geometrical techniques within Dynamo, the realization of this project would have remained beyond our reach.

At the end of the day, the Tower panels were fully parametric, smart, and contained useful fabrication-related data, now ready for geometry implementation.

Looking Forward:

By now, we have made a selection of tools publicly available for the wider community to employ. We recognize the industry’s pressing need for such robust and efficient workflows, a void we are determined to fill. By extending these resources, we hope to substantially enhance the industry’s toolbox, promoting a more collaborative and innovative atmosphere for all.

See you in the next parts, where we will discuss geometrical best approaches and explain how we enhanced the implementation especially to minimize loading times for revisions from hours to minutes in other mega-projects.

See you next time.

Best Regards,

Karam Baki
Head of R&D / BIM Manager
AEC GROUP

The post The Al-Wasel Tower Saga, Part 1 – From Design to BIM appeared first on Dynamo BIM.

]]>
https://dynamobim.org/al-wasel-saga-ep1/feed/ 0
Dynamo Daily Builds and .NET6/8 https://dynamobim.org/dynamo-daily-builds-and-net6-8/ https://dynamobim.org/dynamo-daily-builds-and-net6-8/#respond Wed, 29 Nov 2023 21:41:22 +0000 https://dynamobim.org/?p=54579 Hello early Dynamo adopters, Using Dynamo’s Dynamo Builds (Work in progress builds that are not complete, but showcase work in progress features and updates) you may have started running into …

The post Dynamo Daily Builds and .NET6/8 appeared first on Dynamo BIM.

]]>
Hello early Dynamo adopters,

Using Dynamo’s Dynamo Builds (Work in progress builds that are not complete, but showcase work in progress features and updates) you may have started running into a new issue shown below – namely missing the NET6 or NET8 runtime.

Error message when lacking .NET runtime

If you have experienced this error, then you’ll need to either install the NET6 Runtime or the NET8 runtime pending the particular build of Dynamo that you are looking to use. In the short term we are parallel building NET6 and NET8 builds, so there isn’t a simple way to understand which one targets which framework. If you want access to all Daily Builds we suggest you download and install both the NET6 and NET8 Runtime and install them on your machine. The install should be small and install quickly.

If you don’t use Daily Builds or Dynamo Sandbox, then you won’t have to worry as the Dynamo host integrations will bundle the NET8 runtime inside the installer as they will also require you to install this Framework. Easy street!

The post Dynamo Daily Builds and .NET6/8 appeared first on Dynamo BIM.

]]>
https://dynamobim.org/dynamo-daily-builds-and-net6-8/feed/ 0
Adding protection to motorcycles with Dynamo https://dynamobim.org/adding-protection-to-motorcycles-with-dynamo/ https://dynamobim.org/adding-protection-to-motorcycles-with-dynamo/#respond Mon, 13 Nov 2023 10:32:38 +0000 https://dynamobim.org/?p=54526 Introduction For over 30 years, KISKA has designed the brand and motorcycle portfolio for KTM Sports Motorcycles. Nowadays, this task includes KTM, Husqvarna and GASGAS. A few years ago, a …

The post Adding protection to motorcycles with Dynamo appeared first on Dynamo BIM.

]]>

Introduction

For over 30 years, KISKA has designed the brand and motorcycle portfolio for KTM Sports Motorcycles. Nowadays, this task includes KTM, Husqvarna and GASGAS. A few years ago, a trend started to emerge on the market to generate interest in new products by adding parametric pattern elements on certain areas. This idea generated a controversial internal debate for a while, as the KTM Brand (as well as KISKA as an agency) believes in honest and performance-driven design solutions – and a no-nonsense approach. We didn’t want to add patterns just for the sake of them. There had to be a purpose. 

Our design team settled on a simple rule: Patterns are welcome in areas of the bikes where there’s a lot of physical stress involved. Stone impact, crashes from falling to the side when improperly handled, areas which require more grip than others, etc. Patterns will act as protection, and as a tool to hide natural wear-and-tear.  

Brand Impact

The three brands of KTM, Husqvarna and GASGAS represent very different values. For example, KTM sports the “READY TO RACE” approach, focusing on performance, purity and the extremes of motorcycling. Husqvarna is more grounded, with a commitment to smart and dynamic products which feature pure design and progressive features. GASGAS is the playful brand; daring, capable, vibrant and inviting everyone to join in. 

When developing patterns, this meant the system we created needed to be both flexible and strict. The main challenge I identified was keeping things consistent for the development team while allowing for brand freedom.  

It was also clear from the start that traditional modelling techniques had to be reduced to the minimum. In a design environment, changes are the daily bread and butter. Expect them to come often and in the worst moment possible. 

Why Dynamo?

With the briefing sorted, it was time to move forward and provide a workable parametric answer to the questions asked. I knew about both tools available on the market at this point, Grasshopper and Dynamo. Three things influenced my decision on Dynamo: 

  1. Dynamo comes fully integrated with Autodesk Alias, our main tool for production surfacing 
  1. A friend of mine, Pierre-Paul Andriani, came to visit us and gave us an intro to Dynamo and how he uses it 
  1. Dynamo can be extended with ZeroTouch nodes written in C#.  

Seeing is believing, and the potential was clear from the start. I’m not saying this was an easy journey for me, nor that I was always confident to reach the target. But slicing the problem helped, and the great support from the Dynamo community kept me going. 

Why not Dynamo in Alias?

It sounded like a dream, parametric design directly embedded into your main tool of choice, no interfaces, no data conversion inbetween. However, my own limited skills in Dynamo in the beginning and lack of understanding how the two tools interact with each other led to the worst possible result: Crashes, loss of data, loss of input assignments…Recovering my Dynamo work meant: To restart Alias, open a specific file, and edit the Dynamo history feature to open the connected node tree. It was simply too complicated. Luckily at that time Dynamo Sandbox was already a thing, so I jumped on that train and used the well supported SAT interface to exchange data. 

KTM example

Initial sketch input from designer

Starting off with a sketch, I negotiated the elements of the pattern which were supposed to be parametric. Height, length, distance between stars, alignment to neighbours and so on. At the same time, I counter-checked with the current vehicle design. The areas to wrap the elements on were the top part of the spoiler as well as the frame guard. Both are parts that are scratched quickly during usage, by rider boots, leather, stone impact or tree branches hitting the zones.

Spoiler part to receive a pattern

There are, of course, areas that should not be wrapped. To define these, I settled on a traditional approch. Provide separate input surfaces for: 

  • Finding stable element distribution (Carrier).  
  • Defining where elements shall remain (Placement).  
  • Trimming elements at borders (Flange).  
  • The part itself.  

Working on many of these patterns, I learned to keep the input especially simple. The design constantly updates. The part itself as well. There might be manufacturing reasons that trigger changes. The less sophisticated the input logic is (a. k. a. finding targets and attractors), the more stable and agnostic it is to update. Dynamo is visual programming. It adheres to the same principles. Keep It Stupidly Simple. 

Overlay of Carrier (grey) and Placement (blue)

The beauty of ZeroTouch

The beauty of ZeroTouch libraries is the encapsulation. It makes node trees simpler, perform faster, and allows you to use all the benefits of C# code language, like inheritance, interfaces and so on. I mentioned in the beginning that making things consistent for the end user was a goal for me. Interfaces and inheritance were the answer. See this short snippet here: 

Typical header of a pattern node library

This process allowed me to invent a new object type: a pattern element. Using interfaces, I could create a new pattern ensuring I’d at least support a minimum set of nodes for the user that each element offers. Like, FilterByDistance, or PerimeterCurve. Others could be kept flexible. Is this an element that should simply use a ToSolid node? Or do we need something like Extrude instead? That part I kept flexible per pattern. 

Another huge benefit is the ability to draw custom previews per node. So, when a user now instantiates a new KTM_SX_Star in a node tree, he would not need to make it a Solid first. A much quicker low-poly preview would guide him until the moment he really needs those Solids in hand. 

Stars drawn using custom previews

Finding your way

There are repeating tasks to be performed no matter the pattern. You need to find a starting point. You need to define origin points, tangents and normals for each pattern element. Those need to be stable when the underlying references change. It’s surprisingly difficult to find these references when the underlying geometry is not predictable. We are dealing with trimmed NURBS patches here. So, any approach to finding those placements by using UV nodes are futile. Unfortunately, pretty much every tutorial you can find points you towards such a solution. You’d have to remodel the part with a single surface patch, sporting perfect UV spacing. With most parts I was dealing with, this was simply impossible. 

Researching this problem, a co-worker pointed me at the work of Russian math scientist Pafnuti Chebyshev. His work on describing geometry using quads, so-called Chebyshev nets, was the inspiration to a complete ZeroTouch Library I developed for our company.

The principle behind

Starting from a triangle, which touches the target surface (quilt), take a copy of that triangle and roll it along one of its own sides, until the free tip touches the target geometry again. The resulting shape is a quad, the roll axis is its diagonal. Now take another copy of the initial triangle, and move it along one of its sides. You need to place it coincident with the corner of the diagonal, and the new 4th point. Roll this triangle’s tip onto the target surface. You now have created a new diagonal to work with. Then, roll along the new diagonal again, repeating the process. 

Repeating this you can expand a strip of quads across an arbitrary surface, where all quads have stable lengths in X and Y. Mind though that the angles can collapse. Google ‘Chebyshev nets’, and you will find illustrations of the results. 

The final implementation I found would preview the resulting triangles, their origin point and their normals nicely. The triangle itself is also a custom class, with custom drawing code. The resulting Chebyshev net on the part in this example looks like this: 

Chebyshev net spawned across the placement surface

Filtered triangle candidates where pattern elements shall be drawn in

Divide et impera

That simple-looking red or green triangle is the base of every pattern I create. It’s an easy and controllable way of finding a local coordinate system, and within that local coordinate system the pattern element itself exists. The net is “water tight”, there are no gaps between the triangles. So as long as the pattern element does not exceed the triangles, element collisions are impossible. This is the key learning I made over the years: 

Keep finding local placement (origin, normal, direction) and pattern element creation (drawing the design of a single element) strictly separated. 

As long as one task does not depend on the other, you have your patterns under control. Fail to be strict about the rule above, and prepare for some late nights at work.

Putting it together

So the idea in my workflow is: I give you a triangle, you draw a pattern element within it. This way you could even split the task between two people. Human multithreading if you wish. All the other things needed from here are traditional: You filter by distance, map parameter ranges to attractors, derive solids and trim with flanges. 

Custom map range nodes map between supplier negotiated boundary values. I store these hard-coded

Finally the node that draws the pattern element

In this case, the result is:

Final designed pattern on part

You can see the one triangle in the middle. This is the one from which all the rest grows. Even though many steps are encapsulated in ZeroTouch nodes, the tree is rather involved:

Complete node tree

Conclusion

After lots of initial struggle on all fronts, Dynamo has become a joy for me. There’s always new things coming up in the software. There’s an answer to many intricate challenges possible. It produces output at a surface quality which I can pass on to production. It’s very extensible. And most of all, fun! 

Finally, a huge shout-out to the Dynamo forum members that supported me all this time, Michael Kirschner, Jacob Small and Sol Amour come to my mind spontaneously. I hope I did not forget someone else. Well, I can always edit this article, come to think of it… 

Current KTM MX, with pattern from this article applied

The post Adding protection to motorcycles with Dynamo appeared first on Dynamo BIM.

]]>
https://dynamobim.org/adding-protection-to-motorcycles-with-dynamo/feed/ 0
Dynamo in Forma Beta https://dynamobim.org/dynamo-in-forma/ https://dynamobim.org/dynamo-in-forma/#respond Fri, 10 Nov 2023 19:36:35 +0000 https://dynamobim.org/?p=54475 Dynamo In Forma Beta now available!  Introducing  the Dynamo in Forma Beta, the highly anticipated beta extension that empowers architects, urban designers, and real estate developers with design automation capabilities. …

The post Dynamo in Forma Beta appeared first on Dynamo BIM.

]]>
Dynamo In Forma Beta now available! 

Introducing  the Dynamo in Forma Beta, the highly anticipated beta extension that empowers architects, urban designers, and real estate developers with design automation capabilities. The Dynamo in Forma Beta  allows users to streamline their workflows and make informed decisions in the early stages of urban development projects. In this blog post, we will explore the key advantages of using Dynamo Player beta with Forma and walk you through the installation process. While this is an early effort with a developing set of functionalities, we hope you join us for the ride as we continue to unlock even more Dynamo capabilities in Forma over time, with the help of your ideas, use cases, and feedback. Let’s dive in and start envisioning the potential of automation in Forma with Dynamo Player beta.

What is Forma? 

Autodesk Forma is an AI-powered platform that helps architects, urban designers, and real estate developers optimize and design better urban environments. It provides advanced tools and insights to support decision-making in the early stages of urban development projects. 

What is Dynamo Player in Forma? 

Dynamo Player is an extension that brings a variety of design automation capabilities to Forma users. Some key advantages of using Dynamo Player with Forma: 

  • Streamlined Automation: Dynamo Player simplifies the process of automating repetitive tasks and workflows in Forma. Custom graphs created with Dynamo’s visual programming environment can be executed directly within Forma with just a few clicks. The graphs are displayed as a list within Dynamo Player, making it easy to select and run them whenever needed. This streamlined process allows you to quickly execute repetitive tasks, reducing errors and boosting efficiency. 
  • Easy-to-Use Interface: Dynamo Player provides a user-friendly interface that makes it accessible to Forma users, with no Dynamo expertise required. In the future, we plan on releasing more sample graphs that give you access to Dynamo-powered automations without having to rely on developers or advanced coding skills.
  • Customizable Parameters: Dynamo Player allows you to define input parameters for your automation graphs, enabling you to customize graph behavior based on your specific project requirements. You can set up options and values that can be easily modified each time the graph is executed, providing flexibility and adaptability to different scenarios. 
  • Reusability and Sharing: Dynamo Player promotes collaboration and knowledge sharing among Forma users. Automation graphs can be saved and reused across multiple projects, ensuring consistency and efficiency. Additionally, you can share your scripts with others in the Forma community, enabling them to benefit from your automation solutions and vice versa. 

If you’d like to be one of the first people to try out Dynamo Player in Forma, read on!  

Install Dynamo Player 

To access the Dynamo Player beta version in Forma, you’ll need to install the DynamoFormaBeta package in Dynamo, then set up the extension in Forma. Let’s get started. 

Note: The beta version currently works with Dynamo 2.19.3 Sandbox or Revit 2024.1 or Civil 2024.1 with the same Dynamo version, as well as future versions. You can download the sandbox version from Dynamo Builds. 

Dynamo side 

  1. Go to Packages > Search for a Package, and search for the DynamoFormaBeta package. 
  2. Install the DynamoFormaBeta package to your computer. 

DynamoFormaBeta package

This package enables the connection between Dynamo and Forma and contains a set of Forma-specific nodes. 

With that, let’s finish up the setup on the Forma side! 

Forma side 

In Forma, you’ll need to add the Dynamo Player extension. 

  1. Go to http://app.autodeskforma.com/ and sign in to your account. If you don’t already have access to Forma, you can purchase it or start a free trial.  
  2. Open a project, and go to Extensions in the left-side panel.  
  3. Click Add Extension, then click Add next to Dynamo Player. Dynamo Player will be added to your list of extensions. Close the Extensions window. 

Extensions panel in Forma

  1. In the Extensions panel, click the Dynamo Player extension to open it, then enter a path for the folder where you want to store your graphs.  
    1. Note that this folder must be designated as a trusted file location in Dynamo, or you’ll get an error. Read more about trusted files in our blog post for Dynamo 2.15. To designate a trusted file location, in Dynamo, go to Preferences > Security > Trusted File Locations, then add path. 

 

Graph folder path

  1. Finally, if Dynamo 2.19.3 isn’t already running in the background, start it now to begin using Dynamo Player beta in Forma! 

Getting started: Accessing graphs 

You can try out your custom graphs in Forma by placing them in your designated graph folder. Alternatively, Dynamo Player beta comes prepackaged with sample graphs for you to experiment with. 

Installing a sample graph: 

  1. At the top of the Dynamo Player window, click the Show button next to Sample Files. You’ll see a list of samples along with a brief description and a Download link. 
  2. Click Download under the sample you want to try. Then, move the DYN file you just downloaded into your designated graph folder. 
  3. For convenience, hide the Sample Files list, then click the Load button to refresh the list of graphs. The graph you just downloaded should appear. 

Using a sample graph:

  1. Click the newly installed graph to start using it. If you already had a graph open in Dynamo, you’ll need to save or discard changes to that graph before a new one can be opened. 
  2. The graph’s inputs and controls change from graph to graph and can include sliders, checkboxes, input fields, canvas selections, and more. Once you’re done configuring the graph, hit Run to apply the changes. 
  3. Once the Run is complete, depending on the graph, you may have the option to add the preview geometry from Dynamo into your Forma proposal by clicking the Add button in Dynamo Player. 

Sample graph: Pixelated tower

Let’s take a closer look at one of the sample graphs that come with Dynamo Player. Pixelated Tower is a simplified homage to the MahanNakhon tower, a mixed-use high-rise in Bangkok, Thailand, designed by Büro Ole Scheeren Group. This sample gives you a taste of architectural exploration in Forma, and you can use it to start investigating the various analysis options available.

Pixelated tower in Forma

Once you’ve installed the Dynamo Player beta extension, follow the steps below to create your own pixelated tower in Forma. If you haven’t created a project in Forma yet, follow the instructions in this tutorial, then continue with the steps below.

  • Open a project, and click Dynamo Player in your Extensions panel. Remember, Dynamo must be running in the background. Select the Geometry-CreatePixelTower sample.

Dynamo Player in Forma extensions panel

  • Once the sample opens, you’ll see several inputs you can manipulate. Use the sliders [ 1 ] , then click Run [ 2 ] when you are ready to generate the tower.

Inputs in Create Pixel Tower sample

  • When you are satisfied with the tower’s inputs and want to add it to your project, click Add [ 1 ]. If you want to move or rotate the tower, click the Move icon [ 2 ] in the right toolbar. With this tool activated, you can click the tower, then the spot you want to move it to. Refer to the popup [ 3 ] for exact dimensions.

Adding the tower to the project, then moving it

  • Next, let’s create a site limit, which will allow us to explore analytics options. First, hover over the Limits icon [ 1 ], and click Site Limit. This will allow you to draw the site limit [ 2 ], either by using shape tools or by drawing freeform.

Drawing a site limit

  • Coming soon: Edit in 3D Sketch! Adding the tower to the project adds it as a mesh, so we’ll need to convert it to an object. And very soon, you’ll be able to do that using 3D Sketch. Select the tower, and click Edit in 3D Sketch [ 1 ].

Activating 3D sketch

  • In 3D Sketch mode, we can add floors to our tower. Select the tower, and click Add Floors [ 1 ].

Adding floors to the tower

  • Next, we’ll default height to 5m [ 1 ] to match our input slider in the Dynamo Player graph for Cube Size so our floor slices make sense.

Updating the default floor height

  • You can set taller-height floors at the base of the tower (see lower right in the screenshot) if they are in increments of the same height as in the graph. In our example, they are 5m, so we can use 5, 10, 15, 20, etc.

Floor heights

  • Now that we’ve created our floors, we can go ahead and select individual floors and specify their function:
    • Residential
    • Commercial
    • Unspecified

Adding a function to floors

  • Once floor functions are specified, commercial floors show up in yellow, and residential floors show up in purple. At this point, you’ll also be able to look at area metrics [ 1 ].

 

Area metrics for the tower

  • Explore some of the analysis options Forma has to offer! Featured below:
    • [ 1 ] Solar analysis
    • [ 2 ] Wind comfort
    • [ 3 ] Daylight potential
    • [ 4 ] Wind direction

Analysis options in Forma

Troubleshooting 

Running into issues trying to launch Dynamo Player beta in Forma? Check out some of these possible causes and solutions: 

  • Make sure you are on the correct version of Dynamo: Either Dynamo Sandbox 2.19.3, Dynamo for Revit 2024.1+, or Dynamo for Civil 2024.1+
  • If you downloaded the DynamoFormaBeta extension files instead of installing them via package search, you’ll need to unblock the files before they can be used. You can do this in one of two ways:
    • Right click the file, go to Properties, and tick the Unblock checkbox at the bottom of the General tab.
    • Extract the files with 7-Zip, a free, open-source file archiver tool.
  • Ensure that the unzipped DynamoFormaBeta package folder is directly under the Packages folder for Dynamo 2.19, rather than nested under an extra folder named DynamoFormaBeta. 
  • Confirm that the graph folder in Forma is a trusted file location in Dynamo. See step 4a under the Install Dynamo Player: Forma Side section, above. 
  • Dynamo needs to be running while you are using Dynamo Player beta in Forma. If it is running, but you are getting an error, check Dynamo for any message dialogs that may be blocking the desired action.  

Check it out, and join the conversation! 

We hope you’re as excited to dive into the Dynamo Player beta in Forma as we are to be offering it to you! This is still an early version, with plenty of room for improvement and endless possibilities, and we want you to join us on the journey to making Dynamo Player as powerful as it can be. So give it a try, and let us know what you think by posting on the forum. All bug reports, suggestions, questions, and comments are welcome. See you in Forma!

The post Dynamo in Forma Beta appeared first on Dynamo BIM.

]]>
https://dynamobim.org/dynamo-in-forma/feed/ 0
Machine Learning in Dynamo https://dynamobim.org/machine-learning-in-dynamo/ https://dynamobim.org/machine-learning-in-dynamo/#respond Wed, 01 Nov 2023 18:00:40 +0000 https://dynamobim.org/?p=54467 Summary With advancing technology, we see the widespread use of Machine Learning in almost all industries. But can a vector-based numerical design program work with ML? The answer to this …

The post Machine Learning in Dynamo appeared first on Dynamo BIM.

]]>
Summary

With advancing technology, we see the widespread use of Machine Learning in almost all industries. But can a vector-based numerical design program work with ML? The answer to this question is a definite “Yes, it can.” The “Shapely geometry” package not only allows users to manipulate 2D geometries but also integrates seamlessly with ML. In other words, the “Shapely” package comes equipped with ML capabilities, making it more functional and significantly expanding its processing capacity.

But how does Shapely do that with ML?

In order to work with ML, you do need Numpy. Unfortunately, you cannot directly use Dynamo geometries within an ML model. This is where « Shapely geometry » comes into play. It allows you to perform these operations directly using Numpy, making it a valuable tool for integrating geometry operations into your ML workflows.

Converting Dynamo geometry to Shapely geometry

Meaning, we need to first convert any 2D geometry into  « Shapely geometry » and then into ‘Numpy’ data. Don’t worry, we don’t lose any data during all these conversions. In summary, we are transforming the geometry into another format without losing any data. This is truly a very functional and flexible data interchange.

 

So what awaits us after making our data ready for the model?

To utilize machine learning models, there are two different approaches:

  1. Enabling predictions with a pre-trained model using a dataset (Fast, simple, and sustainable) – Here’s an example dataset. A pre-trained model based on the dataset provides us with a list of potential Dynamo nodes that might be used in the given scenario when an example Dynamo node is provided to the model. In other words, it offers an ‘Autocomplete’ feature.

    Pre-trained dataset example

    Autocomplete feature

     

  2. I’m talking about creating the dataset within your scenario, which means training the ML model within the scenario (Slow, laborious, and one-time use). Here’s an example. In a scenario, the trained model is expected to predict which points in the example point list provided to the model are inside the circle and which ones are outside (Red: Points inside the circle, Blue: Points outside the circle). The dataset varies according to the list series specified by the user within the scenario and won’t be reused in another scenario.

    Using Shapely package to find all points within a circle

So the dataset is prepared and the model is ready for training. Which ML model should I use?

Unfortunately, there is no simple answer to this question. You must define your scenario carefully because a poorly chosen ML training model will not adapt well to your scenario and will not provide a good and stable result. Here’s an example: An ML model trained on points on the surface of a CurtainWall, based on changes in direction, is expected to predict how the changes in direction on the surface of another wall should be classified for testing. Both ML training models (K-NN and DecisionTree) use the same dataset. However, after processing, the DecisionTree model presents us with 2 symmetrical groups, whereas the K-NN training model correctly predicts each group as expected. The reason for obtaining 2 different results here is entirely due to the design of the two training models. The K-NN training model always takes neighboring groups into account when making decisions, which is why it has adapted better to my scenario.

ML training model exploration

To understand machine learning training models well, you need to know that, in brief:

  1. Supervised Learning: You need a pre-existing dataset. The ML model selected by the user makes predictions based on this dataset.
  2. Unsupervised Learning: You don’t need a pre-existing dataset. The ML model selected by the user analyzes the data provided for predictions and determines its predictions based on this analysis.
  3. Reinforcement Learning: You don’t need a pre-existing dataset. The ML model selected by the user learns by continuously repeating the task specified by the agent, changing actions, and collecting rewards. In short, it learns from.

    Machine Learning approaches

     

I have compiled various machine learning training models within the « Shapely » package. These are some of the fundamental training models and have been shared with users as open source. Of course, in future versions of the package, more machine learning training models will be included.

So, at the end of the day, with Dynamo, we can easily work on machine learning in our scenarios and have fun with it. In the office where I work, we have a lot of fun with this because we can classify, analyze, and perform data mining without using any parameters. With a well-trained model and the right scenario, we can design a floor plan in just a few seconds. Here’s an example: A curve or polycurve drawn by the user is analyzed using ShapelyBuffer with the specified width and line length. Then, a pre-trained machine learning training model predicts potential building typology (T1-T2-T3-T4, etc.) based on the analyzed data and assigns a color to each building typology group. This color scale is specified in the dataset. It does this while preserving circulation areas (elevator, stairs). – The scenario is produced according to the French NF standard.

Floor plan design in Shapely

Final

With Machine Learning, we can analyse, classify and data mine geometries almost without using any parameters, we can simply vectorsize very complex geometries and even use the generated datasets in other scenarios. In short, I am talking about using a tool with incredible processing capacity together with a computational design. All you need to do is to create a correctly selected training model, a suitable dataset and a simple scenario. To tell the truth, we have a lot of fun with this in the office where we work.

The post Machine Learning in Dynamo appeared first on Dynamo BIM.

]]>
https://dynamobim.org/machine-learning-in-dynamo/feed/ 0
How to Enforce Dynamo Graph Standards with a Custom Linter https://dynamobim.org/how-to-enforce-dynamo-graph-standards-with-a-custom-linter/ https://dynamobim.org/how-to-enforce-dynamo-graph-standards-with-a-custom-linter/#respond Tue, 24 Oct 2023 13:00:25 +0000 https://dynamobim.org/?p=54358 What is a linter? Before we get into the real content of this post, we need to establish what the heck a linter is. In a nutshell, a linter is …

The post How to Enforce Dynamo Graph Standards with a Custom Linter appeared first on Dynamo BIM.

]]>
What is a linter?

Before we get into the real content of this post, we need to establish what the heck a linter is.

In a nutshell, a linter is a tool used to analyze your code for problems and flag them.

In the Dynamo world, this is very common for Generative Design graphs. As you may know, Generative Design has a set of requirements in order to be successful. This includes the requirement of having inputs, outputs, and serialized Revit geometry. This is achieved through a custom linter!

Background

Dynamo has had a linter for quite a while to enable Generative Design to run how it does. However, the linter API was not ready for public use until recently. Thankfully, it is ready and has been enabled as of Dynamo 2.18.1. Personally speaking, as soon as I saw that a linter was being used, I was excited. Until I realized the API was internal only. But when it became public, I was excited again.

Use-Case

If you’ve used Dynamo for any time, you probably know some Dynamo graphs are imperfect. These include graphs without notes, groups, annotation, or appropriate documentation.

Previously, I had a bot that would use a machine-learning dataset to see if a graph had any annotations. But this was after the fact and mostly made for fun.

If you are curious about this bot, check it out here: https://twitter.com/DynamoFacadeBot/with_replies

Implementation

With the opening of the linter APIs, we can now define our linters as a package. This has resulted in a new sample for Dynamo users to learn from. Check that out here:

https://github.com/DynamoDS/DynamoSamples

The sample linter (once installed) is available under graph status:

Once the linter is enabled, there are 3 rules activated (at this time):

  • Slider as input rule: This rule alerts the end user that they might want to do so if the slider is not input or renamed. If a slider is not being used as input, it is typically unnecessary, and a number node or a code block would suffice.
  • Dropdown as Input Rule: Similar to the slider rule, but for dropdowns. It is worth considering an alternative if you aren’t using it as an input.
  • Nodes not in Groups: Having ungrouped nodes is a bad practice. This section allows the linter to flag this behavior based on linter settings in the extra folder in the extension directory.

 

Who is this for?

This is an addition to the Dynamo samples repo. This means that if you are a developer, you now have the infrastructure to build your own linters. At this time, it isn’t for end-users directly, but I hope to see development that allows defining linters through XML files or JSON.

How do I use it?

First, head on over to the Dynamo Samples Github repository.

https://github.com/DynamoDS/DynamoSamples

You can star (save) the repo or even create your own private fork. But, to get started quickly, download the source code as a zip.

After After downloading, it is best to unzip the source code with 7Zip. This helps with blocked references since they were downloaded from the internet.

Once the files are unzipped, you can navigate to the solution file and double-click to open it in Visual Studio.

As you can see, several projects in the Dynamo samples solution exist. You will see all related files in the SampleLinter project for linter workflows.

a

How is the Sample Structured?

Rules

The rules folder contains the appropriate checks to be run on the given Dynamo graph. Each rule consists of a GUID, a Rule Set, and the methods to check the nodes.

SampleLinter Extension Implementation (SampleLinter.cs)

This file loads the rules when Dynamo loads. It is similar to view extensions because it uses an XML to load the file. The XML is included in the sample dataset and is placed in the extra folder in the package directory.

SampleLinter_ExtensionDefinition

This file instructs the linter to load and be available in Dynamo.

 

Next Steps

With all of the Dynamo samples in the repo, there is an assumed amount of knowledge for development. We now have a custom package sample, a view extension sample, and a linter sample in the samples. If you are new to Visual Studio and programming in C#, here are a few resources to help get you started.

Dynamo Office Hours – “Discovering a New Environment”

In this office hours, the team covers how to get started with Visual Studio and C# for Dynamo packages.

Become a Dynamo Zero Touch C# Node Developer in 75 Minutes

This resource (provide by Thomas Mahon-Author of the BIMorph package) is an awesome resource for any aspiring C# Dynamo developer.

Become a Dynamo Zero Touch C# Node Developer in 75 Minutes

The post How to Enforce Dynamo Graph Standards with a Custom Linter appeared first on Dynamo BIM.

]]>
https://dynamobim.org/how-to-enforce-dynamo-graph-standards-with-a-custom-linter/feed/ 0
Dynamo Core 2.19 Release https://dynamobim.org/dynamo-core-2-19-release/ https://dynamobim.org/dynamo-core-2-19-release/#respond Wed, 04 Oct 2023 13:36:57 +0000 https://dynamobim.org/?p=54374 Hello, friends of Dynamo! We are thrilled to announce Dynamo version 2.19! Alongside the robust selection of feature updates and bug fixes that you’ve come to expect, this release also …

The post Dynamo Core 2.19 Release appeared first on Dynamo BIM.

]]>
Hello, friends of Dynamo!

We are thrilled to announce Dynamo version 2.19! Alongside the robust selection of feature updates and bug fixes that you’ve come to expect, this release also brings with it game-changing updates to node and package search. Eager to learn more? Join us as we explore the highlights from this release, or, if want to give it a try, go ahead and download 2.19 from dynamobuilds.com. Then join us on the forum to discuss!

TL:DR

Dynamo 2.19 comes with a much-improved search feature that provides more relevant search results. It adds a zoom state, unique shape, and tooltip information for package nodes, improves the Python editor experience, and provides better documentation for chart nodes. This release introduces a variety of quality-of-life updates, including the ability to drag and drop notes to pin them, a new setting to control whether exported image file names include a time stamp, and more.

For full details on this release, check out the release notes!

 

What is Dynamo and its flavors?

What is Dynamo Core?

Dynamo Core is a collection of bundled components that consist of the graphical interface, the compute engine, the scripting language DesignScript, and the out-of-the-box nodes that are not specific to another program like Revit or Civil 3d.

What is Dynamo for <INSERT HOST HERE>?

Dynamo for [Revit, Civil 3d, FormIt, Advance Steel, Alias or Robot Structural Analysis] is a collection of host-specific nodes that work with Dynamo Core and runs inside of said host.

What is Dynamo Sandbox?

Dynamo Sandbox is for package developers and other folks working with Dynamo code who want to stay up to date with the latest and greatest stuff coming out. Sandbox is Dynamo’s “Core” functionality distributed in a way that doesn’t interfere with other Dynamo installations and doesn’t require any other applications (except for a few windows components and some optional extras). You can read more about this distinction here.

 

So, what’s dropping with Dynamo 2.19?

Search, and you will (actually) find! Massive improvements to search

The moment we’ve all been waiting for has arrived! This release unleashes staggering improvements to the node and package search functionality, a feature that has been highly requested by our users for quite some time. We have listened to your feedback and worked tirelessly to make significant improvements to search, making it easier than ever to find the nodes and packages you need. In this section, we’ll dive into the details of these exciting new features. Get ready for a seamless search experience as we walk you through the updated functionality!

Animation showing various scenarios of using the new search

The new search in action!

 

Many of you have reported headaches with Dynamo search in the past. In previous versions, search results could be ordered by descriptions, library names, and other less relevant attributes instead of the node name. Sometimes, none of the results appeared relevant to what you typed in. The new search has been properly weighted to ensure that you are much more likely to get expected results.

Comparing 2.18 search to the more relevant 2.19 search

Where old search results could sometimes be baffling, the new search surfaces more relevant results

 

Did that node have a period in its name? Perhaps a space? Or was it both? You no longer need to think about it—the improved search is able to better handle different ways of expressing a node’s name. As the example below shows, search is much more likely to pull up the desired node whether a period, space, or no space is used.

Animation showing that you can search by using a space, no space, or period in the node name

The new search is less finicky as to how you type the node’s name

 

The new search also introduces typo tolerance, which means that even if you mistyped a letter, the search algorithm will still surface relevant results.

Animation showing relevant results in spite of a typo in the search term

The new search can handle a typo

The improved search is available everywhere you need it—in the node library, in-canvas search, node autocomplete, and package search.

Go ahead and give it a try, and if you spot any lingering issues we missed, let us know in this forum thread! We are making search better and better over time.

 

Tracking packages: Node visuals and tooltip

If package nodes tend to get lost in the complexities of your graphs, don’t worry: Dynamo 2.19 introduces THREE new ways to identify nodes originating from packages. First off, we’ve added package nodes to the beloved zoom states feature. As a recap, zoom states are activated when you zoom out far enough in the workspace, causing nodes in certain states to change color and display an icon. Now, you can identify package nodes by their purple color [ 1 ] and package icon [ 2 ] when zoomed out. In addition, package nodes always feature a small gray triangle [ 3 ] in the bottom left corner, differentiating them from out-of-the-box nodes no matter the zoom level.

Package node in a zoom state

Animation demonstrating the new package node zoom state

Purple package nodes joining the happy zoom state family

 

As one more way to spot package nodes, we’ve added package information to the node’s description, or tooltip. Simply hover over the node’s name, and the tooltip will tell you which package the node originates from. Simple, but so effective!

Animation showing package names in node tooltips

Simply hover, and the package node’s tooltip will tell you which package the node came from

 

Python editor updates

This release introduces more improvements to the Python editor experience, starting with a new way to edit Python script in Dynamo. Place a Python Script node, double click to open the editor, then click the button to dock the editor to the right sidebar. There, you can access all the usual editor tools without obstructing the workspace. If you rename your Python Script node, the sidebar editor name will also change in real time, helping you keep track of multiple nodes/tabs.

Animation showing a Python script editor being docked to the side and undocked

Dock your Python script editor to the side for an unobstructed view of your graph

 

 

We’ve done additional work to ensure the Python editor and DesignScript styles are in alignment, with the addition of the class keyword.

Code block and Python Script node side by side illustrating consistent use of color coding

 

 

We implemented a visual refresh of the Python editor in the previous release, and in this one we round out the refresh with a finishing touch: bringing the Migration Assistant buttons up to date with our visual style.

Updated button visuals for the migration assistant tool

If you need a refresher or just extra information on how to use the Python Script and Python Script From String nodes, we’ve added refreshed and functional example files for both. You can access these in the Documentation Browser by placing the node, right clicking on it, and selecting Help, or selecting the node and pressing F1.

Example file for the Python Script node with graph and background geometry

This cool example file showcases one way to use a Python Script node

 

And finally, we fixed an edge case where Dynamo would crash if you removed or overwrote the last lines in the Python editor.

 

Smaller buckets of work

Better documentation for chart nodes

After we introduced a new suite of improved chart nodes in 2.18, we received some awesome feedback from several of you to help us provide better in-depth guidance around these nodes. As a result, we’ve added more examples, more detailed descriptions, and overall more helpful information around using chart nodes. As a reminder, you can access this documentation by placing a chart node, right clicking it, and selecting Help. Or, with the node selected, press F1.

Updated in-depth documentation for the bar chart node

Rich documentation means better guidance and inspiration for using chart nodes

 

New shortcut for inserting graphs

We’ve changed the shortcut for the File > Insert command, which was introduced in 2.18. You can use this command to insert graphs into your current workspace. Insert now uses Ctrl + Shift + I instead of Ctrl + I. This fixes a conflict with the shortcut for Isolation mode, which fades geometry associated to nodes that are not selected. Our bad!

By the way, you can find all the keyboard shortcuts for Dynamo on this page: Keyboard Shortcuts.

The open File menu shows the Ctrl + Shift + I shortcut for Insert

 

Drag and drop to pin a note

Pinning a note has never been faster than in 2.19: Simply drag and drop the note over a node, and the note will be pinned. While hovering, a gray border appears around the node to help you identify the note’s new home (see demo below).

Animation demonstrating how notes can be pinned by drag and drop

 

Control whether exported image file names include a time stamp

Want to export your workspace as an image and include a time stamp in the file name? Or would you rather just include the file name on its own? We have a new setting that lets you have it your way. Under Preferences > General, you’ll find a toggle to include a time stamp in the export image file path. When toggled on, the current time stamp is included in the exported image’s file name. When toggled off, only the file name is included. This setting is on by default, consistent with previous versions.

Include Timestamp in Export Image Path setting in the General tab of Preferences

Animation showing time stamp being included in the exported image's file name when the setting is enabled, and only the file name being included in the file name when the setting is disabled

 

Watch this: Multiple inputs in Watch 3D

Watch 3D can now handle multiple inputs, without the need to use List.Create. This node, which visualizes background geometry, comes with a single input port by default. With this update, you can use the plus and minus buttons to add and remove extra ports, and Watch 3D will visualize all the geometry you input through these ports. The interactive visualization can also be pulled into Dynamo Player by setting the node As Output!

Watch 3D node with two inputs, a sphere and a cuboid

A more customizable Watch 3D experience — add all the input ports you need!

Bug fixes

  • When we introduced editable port properties for Python nodes in the previous release, the context menu option unintentionally spilled over to other nodes. Now, the Edit Port Properties option will only appear in the context menu for the input ports of Python nodes, as intended.
  • We fixed a bug where the trust warning would incorrectly appear after adjusting Python zoom scale.
  • We fixed a bug where some packages for Civil 3D would trigger a warning about mismatched host even when run under Civil 3D.
  • The Dynamo splash screen now grabs keyboard focus upon launch, enabling you to launch Dynamo by pressing Enter without having to first click on the splash screen. You can also press Escape to dismiss the splash screen and not launch Dynamo.
  • We fixed a bug that caused a crash when inserting XML .dyn graph files into the workspace.
  • We fixed a bug that caused the ordering of package search results to no longer respect the selected sort order after the search term was deleted.
  • We fixed a bug where notes would get detached from groups when a custom node was created from the group.
  • We fixed a bug where undoing an “add group to this group” action would cause Dynamo to crash.

Simply amazing! So where can I grab Dynamo 2.19?

Dynamo 2.19 will be made available in our host integrations at a future date and can be explored right now through the dynamobuilds.com website or the GitHub build page – available in the Sandbox version of Dynamo.

 

If you’re curious, you can also read our Release Notes

For more information on other minor features, bug fixes, and known issues in Dynamo 2.19, take a look at the release notes!

We’d like to extend a huge thank-you to everyone who made this release possible and to the entire Dynamo community for continuing to support our work. Be sure to stay tuned to the Dynamo Roadmap, where you can take a look at current and upcoming work, express your support for features you want to see, and let us know what you think by adding a comment.

The Dynamo Team

 

The post Dynamo Core 2.19 Release appeared first on Dynamo BIM.

]]>
https://dynamobim.org/dynamo-core-2-19-release/feed/ 0