CamelGraph

Dynamo-style visual programming for Autodesk Navisworks.

Two ways to get it: free for personal use, the Autodesk App Store for professional use

• Personal use is free. Download the installer from the GitHub releases or from bimcamel.com. It covers learning, hobby projects and research, and charities, schools, universities, public research bodies and government institutions, under the PolyForm Noncommercial License 1.0.0. These copies are marked Personal use in the installer, the About window and the start screen.
• Professional use: a copy for the Autodesk App Store is coming soon. Using CamelGraph for your job (at a contractor, consultancy, design office or any company) or inside a paid project or product is commercial use. The copy for the Autodesk App Store will come with a commercial licence from BIMCamel and will be updated by the store; the store listing will show the terms.

It is the same program in both; only the licence and where you get it differ. The source is readable and changeable on the noncommercial terms (so this is "source-available" rather than OSI-certified open source). Releases up to v0.45.1 were published under Apache 2.0 with the Commons Clause, and copies you already have stay under that licence (details).

CamelGraph brings the visual-programming workflow that Dynamo made famous in Revit to Autodesk Navisworks 2024, 2025 & 2026. Wire nodes together on a canvas, watch data flow from outputs into inputs, and let the dataflow engine run your graph against the live Navisworks document — no code, no macros, no SDK boilerplate.

Search a federated model by property, color-code it by system, bulk-create selection sets, dump quantities to CSV, triage clashes by rule, and batch-generate viewpoints — as reusable, shareable .dyc graph files.

The editor with the "Table Summary from Text" sample after a run: nodes, wires, the values under each node and a Watch Table. The same editor has a light theme. It docks inside Navisworks as a pane.

More pictures: start screen · light theme · quick node search · command palette · keyboard and mouse sheet · settings · Script Player

Documentation: the CamelGraph wiki — installing and removing it, a first script, the editor, how-to guides (clash report, BCF, Excel, quantities), the Script Player, an FAQ and every node with its inputs and outputs.

---

What's new in v0.12–v0.23 — site safety & spatial analysis

• Fall-hazard analysis suite — FallHazard.FloorOpeningMap renders a whole-floor heat map of openings from the real model mesh (limit-pivoting gradient, user colours, printed gap-over-limit labels, one saved viewpoint per flagged opening), and FallHazard.EdgeHandrailCheck classifies every edge around a void as dangerous / protected / safe — with real handrail length-along-edge coverage, a min-passage rule, user colours and printed overages for reports. Both take a units input so metre inputs stay honest in feet-based documents.
• Spatial clustering — Proximity.Cluster groups touching geometry into logical elements (a ladder made of loose shapes becomes ladder #1, #2, …), stamps each item's number as a searchable custom property in the same run, and has a precise mesh mode that confirms every connection with the Clash engine's exact clearance.
• Viewpoint intelligence & markups — Viewpoint.VisibleItems answers "does this view actually show these elements?" (camera-frustum test, flexible set/list/name inputs); the experimental Markup.* nodes draw text, arrows, ellipses, clouds and numbered tag substitutes onto saved viewpoints via the hidden Navisworks redline API.
• Color toolkit — seeded Color.Random / Color.RandomList (stable across re-runs, golden-angle distinct), Color.Gradient between two colors, and Color.ByValues + Appearance.ColorByValues for one-node color-coding by parameter value with a legend.
• Ordering, the industry way — Flow.Then pins the execution order of side-effect nodes as a real data dependency (the Dynamo Passthrough pattern); a Captured Selection node snapshots the live selection and replays it every run.
• Editor quality of life — Space-bar quick node search at the cursor, port tooltips generated from the API docs on all 314 nodes, an inline Watch Image node for the analysis PNGs, an index gutter on Watch List, click-to-expand preview bubbles, a proper Boolean switch, and Create/Modify/Info grouping with symbols throughout the library.
• BIMCamel ribbon tab — CamelGraph, Player and About buttons, a unified About window, and an update check when the editor opens.

The newest release is 0.51.0 (the personal-use edition with the installer and the bundle zip; a review of the whole node library with 210 findings fixed, 42 new node names, node packs that survive updates: see CHANGELOG.md); 0.50.0 was a new logo, a floating node library, a clearer Script Player and Run at the right edge of the header; 0.49.0 renamed Dyncamelo to CamelGraph (new file names, and installing replaces an old Dyncamelo install); 0.48.0 was the last one called Dyncamelo (one header row, a wide Run button, faster nodes on big models, working clash grouping nodes); 0.46.0 was a source-code release (new licence, a question before running graphs from files, Help > Run Self-Test, Copy Diagnostics and Privacy Policy); 0.45.1 was a fix for picking from the node library; 0.45 (tables, conditional flow, about 220 new nodes) is described in docs/WHATS_NEW_0.45.md, with role-by-role recipes. Full details of the 0.23 wave in docs/WHATS_NEW_0.23.md. Earlier waves: v0.10–0.11 universal loops, live element preview & viewpoint organizing; v0.4 instant library search & curated samples; v0.3 "plugin parity"; v0.2 editor quality-of-life — see docs/.

Features

• Dynamo-like editor — a node canvas (built on Nodify) docked inside Navisworks: searchable node library, drag-to-wire connectors, pan/zoom, notes, watch nodes.
• Real dataflow engine — eager evaluation, topological execution, and dirty propagation: change one slider and only its downstream nodes re-run. Manual and Automatic run modes.
• Replication ("lacing") — feed a list into a scalar input and the node maps over it, exactly like Dynamo: Shortest by default, Longest and Cross-Product per node.
• Robust by design — a failing node surfaces a per-node Warning/Error state; it never crashes the graph run or Navisworks.
• Per-item workflows — a universal loop (Loop.Item → body → Loop.Collect) runs any nodes once per item, in order, so stateful "isolate → zoom → save viewpoint → next" jobs work with the real nodes, not just pure data mapping. Flow.Then pins side-effect order explicitly when two writes must happen in sequence.
• Spatial & safety analysis — fall-hazard heat maps and edge/handrail classification straight from the model mesh, touching-geometry clustering with custom-property stamping, camera-frustum visibility tests, and exact clash-engine distances.
• Deep Navisworks node library — properties/QTO extraction and custom property writing, Find-Items-grade search, selection sets, color/transparency/hide overrides (permanent and viewpoint-scoped), transforms, saved viewpoints (incl. experimental redline markups), IFC export, clash triage/grouping/deltas, BCF 2.1 exchange, grids, TimeLiner, CSV/Excel/report export. See the generated node catalogue — every node by category with its inputs and outputs, kept current by CI (also as JSON) — and NODE_LIBRARY.md for the design conventions.
• Zero-touch extensibility — write a public static C# method, tag it with [NodeName]/[NodeCategory], drop the DLL in the Packages folder, and it appears in the library. No base classes required. See Extending CamelGraph.

Part of the BIMCamel toolset

• CamelWorks — the coordination, data and delivery suite: clash, issues, model audit, revision compare, properties, quantities, sets, exports and the site tools. It ships CamelGraph and the IFC exporter inside its own installer, so one download puts all three on one ribbon tab, and its Automate ▸ Graphs tab runs CamelGraph graphs without opening the editor.
• BIMCamel IFC Exporter — free, fast Navisworks → IFC export (IFC4 / IFC2x3): streaming engine, geometry instancing, property sets, classifications and georeferencing. Website: bimcamel.com/Export-Navisworks-to-Ifc. Both plug-ins install the same way; installed together, each adds its own BIMCamel tab.
• bimcamel.com — browser-based IFC tools (validate, compare, upgrade / downgrade schema…).

Architecture at a glance

graph TD
    APP["CamelGraph.App<br/>net48 - Navisworks add-in<br/>(AddInPlugin + DockPanePlugin)"]
    UI["CamelGraph.UI<br/>net48 WPF - node editor<br/>(Nodify canvas, library browser)"]
    NAV["CamelGraph.Navisworks<br/>net48 - Navisworks node library"]
    NODES["CamelGraph.Nodes<br/>netstandard2.0 - general node library<br/>(math, logic, string, list, color, file)"]
    CORE["CamelGraph.Core<br/>netstandard2.0 - graph model, engine,<br/>zero-touch loader, .dyc serialization"]

    APP --> UI
    APP --> NAV
    APP --> NODES
    UI --> CORE
    NAV --> CORE
    NAV --> NODES
    NODES --> CORE

    NWAPI["Autodesk Navisworks 2024–2026 API<br/>(bound from the host at runtime)"]
    NAV -.compile-time reference.-> NWAPI

CamelGraph.Core and CamelGraph.Nodes have zero UI or Navisworks dependencies — they compile and test anywhere (including Linux CI). Everything Navisworks-specific lives in CamelGraph.Navisworks; everything WPF lives in CamelGraph.UI/CamelGraph.App. Details in docs/ARCHITECTURE.md.

Requirements

• To run: Autodesk Navisworks Manage or Simulate 2024, 2025, or 2026 on Windows.
• To build: Windows 10/11 with Visual Studio 2022 (with ".NET desktop development" workload) or the .NET 8 SDK. No Navisworks installation is needed to build — the Navisworks API is referenced through compile-time-only NuGet packages.

Install

Download CamelGraphSetup.exe from the latest release (or the bundle zip next to it), run it (per user, no administrator rights), then start Navisworks 2024, 2025 or 2026 and open CamelGraph from the BIMCamel ribbon tab. The installer is not code-signed, so Windows SmartScreen may warn: choose More info, then Run anyway, after comparing the SHA-256 checksum next to the download. Some releases carry the source code only (v0.46.0 did); the assets list of a release says which kind it is. To build from source instead, see the next section; a Debug build of the solution puts the whole bundle in %APPDATA%\Autodesk\ApplicationPlugins\CamelGraph.bundle for you (see dist/README.md). If Navisworks reports PLUGIN_LOAD_02, see Troubleshooting.

Licence. In plain words: the copies on GitHub and bimcamel.com are free for personal use and other noncommercial use (hobby, learning, research, charities, schools, public bodies). Using CamelGraph for work at a company, or in a paid project or product, needs the professional copy, which is coming soon to the Autodesk App Store and will come with a commercial licence from BIMCamel. The text of LICENSE is what counts for the free copies; this is a summary, not legal advice. If you are not sure whether your use is commercial, assume it is. The third-party parts keep their own licences (THIRD-PARTY-NOTICES.md).

Build from source (Windows)

git clone https://github.com/mrshoma99-rgb/dyncamelo.git
cd camelgraph
dotnet build CamelGraph.sln -c Release
dotnet test CamelGraph.sln -c Release

Or open CamelGraph.sln in Visual Studio 2022 and build the Release configuration.

Linux/macOS note: CamelGraph.Core, CamelGraph.Nodes, CamelGraph.Navisworks, and the test projects build off-Windows (netstandard2.0/net8.0; the Navisworks library compiles against reference assemblies). The WPF projects (CamelGraph.UI, CamelGraph.App) require Windows, so dotnet build CamelGraph.sln only succeeds there; CI builds the full solution on windows-latest and the non-WPF projects on ubuntu-latest:

dotnet build src/CamelGraph.Core/CamelGraph.Core.csproj
dotnet build src/CamelGraph.Nodes/CamelGraph.Nodes.csproj
dotnet build src/CamelGraph.Navisworks/CamelGraph.Navisworks.csproj
dotnet build src/CamelGraph.Cli/CamelGraph.Cli.csproj
dotnet test tests/CamelGraph.Core.Tests/CamelGraph.Core.Tests.csproj
dotnet test tests/CamelGraph.Nodes.Tests/CamelGraph.Nodes.Tests.csproj
dotnet test tests/CamelGraph.Integration.Tests/CamelGraph.Integration.Tests.csproj

You can also run headless graphs (no Navisworks needed) with the cross-platform CLI:

dotnet run --project src/CamelGraph.Cli -- run samples/hello-math.dyc

See samples/README.md for the bundled example graphs.

To run a source build in Navisworks, use the application-bundle layout under %APPDATA%\Autodesk\ApplicationPlugins\CamelGraph.bundle (see dist/README.md); a Debug build sets it up for you.

Your first graph

Open a model in Navisworks and launch CamelGraph from the BIMCamel ribbon tab — the editor opens as a dockable pane. Then follow the Getting Started guide (or the wiki's first-script walkthrough):

Find every item whose Material contains "Concrete", color it red, and save it as a selection set — about six nodes, no code.

Documentation

Document	What it covers
Getting Started	Install, editor tour, your first graph, lacing, saving/loading .dyc
Editor guide	Every command, shortcut, gesture and setting of the editor (generated from the editor itself)
Node Library	The full node catalog: ports, behavior, Navisworks API mapping, tiers
Architecture	Projects, engine pipeline, zero-touch loading, .dyc format, threading
Extending CamelGraph	Write your own node pack; custom NodeModel nodes with custom UI
Implementation Plan	Vision, milestones M0-M5, engineering decisions, testing strategy, risks
Wiki	The user guide at bimcamel.com: installation, a first script, the editor, the Script Player, samples, how-to guides, IFC / BCF / Excel exchange, troubleshooting and a page per node category with inputs and outputs. Its source is docs/wiki-src, built with MkDocs (Material theme) by python tools/build_wiki.py into build/wiki-site; see tools/wiki/README.md
Troubleshooting

Roadmap summary

Milestone	Theme	Highlights
M0 Foundation	Engine + libraries	Graph model, dataflow engine (dirty propagation, lacing, coercion), zero-touch loader, .dyc format, general node library, green tests on Linux
M1 MVP editor	Editor in Navisworks	Dock pane with Nodify canvas, node browser, run modes, save/load, first Navisworks nodes end-to-end
M2 Full MVP node set	The 88 MVP nodes	Search, properties/QTO, selection sets, appearance, viewpoints, clash read-out; all reference workflows runnable
M3 Beta	Depth + reporting	Clash triage writes, TimeLiner, image/CSV report export, node packages loaded from folders
M4 v1.0	Power + reach	IronPython/Roslyn script nodes, Navisworks 2024-2026 multi-targeting, localization
M5 Community	Ecosystem	Package manager, sample graph gallery

Full milestone breakdown with exit criteria and risks: docs/IMPLEMENTATION_PLAN.md.

Status and support

CamelGraph supports Autodesk Navisworks Manage and Simulate 2024, 2025 and 2026 on Windows. Navisworks cannot be run in the automated tests, so the nodes that talk to Navisworks are checked by hand, and so far only Navisworks Manage 2024 has been used in the field; the 2025 and 2026 builds are not yet verified in Navisworks (see the known issues). To report a problem, first look in the troubleshooting guide, then email [email protected] or open an issue with the bug report form. It asks for your versions, %APPDATA%\CamelGraph\errors.log and the output of Help > Copy Diagnostics. Report a security problem privately, as described in SECURITY.md, and read there what a .dyc graph file can do before you run one from someone else.

Feedback

CamelGraph is developed by BIMCamel and is open to the community: bug reports, feature requests and pull requests are all welcome. Open a GitHub issue, read CONTRIBUTING.md before sending a PR, or reach us at bimcamel.com.

License

CamelGraph is source-available under the PolyForm Noncommercial License 1.0.0 (see LICENSE): you may use it for personal and other noncommercial purposes — study, hobby projects, research, charities, schools, public research and government bodies — modify it and share it on those terms. Commercial use is covered by the professional copy for the Autodesk App Store, which is coming soon (see the box at the top of this page). Licensing history: releases up to v0.1.1 were MIT-licensed, v0.1.2–v0.26.1 proprietary and v0.26.2–v0.45.1 Apache 2.0 with the Commons Clause; each grant applies to copies obtained while it was in effect (texts). Third-party components ship under their own licenses: THIRD-PARTY-NOTICES.md.

CamelGraph is not affiliated with or endorsed by Autodesk. Autodesk, Navisworks, Revit, and Dynamo are trademarks of Autodesk, Inc. The Autodesk Navisworks API assemblies are referenced at compile time only and are never redistributed with CamelGraph; at runtime the API is provided by your licensed Navisworks installation.