CamelGraph node library — all 589 nodes

The full node reference for CamelGraph (previously Dyncamelo), the Dynamo-style visual-programming add-in for Autodesk Navisworks 2024–2026 (free for personal use). Every node below ships in the current build (v0.51.0) — the list is generated from the add-in's source by its release pipeline, so it is the library, not a copy. On this page each node also documents its input ports (name, type, default value), output ports and search tags; use the search box or category filters to find a node the way you would inside the app.

Annotation (1)

Note — A free-floating text note on the canvas — document your graph for the next person.

Color (17)

Color.ByARGB — Creates a color from alpha, red, green and blue values (0-255).
Color.ByHSV — Creates a color from hue (degrees, wraps around), saturation and value (0-1, clamped).
Color.ByValues — One color per value, equal values sharing a color — feed parameter values in, feed the colors to Appearance.OverrideColor per group, and use the uniqueValues/uniqueColors legend for reports. Optional own palette (cycled). An empty list of values (a search that found nothing) gives empty lists, not an error.
Color.Components — Splits a color into its red, green, blue and alpha channels (0-255).
Color.ContrastText — Black or white, whichever reads better on a background color (WCAG contrast) — for labels on coloured fills and legends.
Color.Darken — Makes a color darker by shifting its HSL lightness down by amount (0-1, clamped); alpha is kept.
Color.FromHex — Parses a hex color string ("#RRGGBB" or "#AARRGGBB").
Color.Gradient — A list of N colors evenly blended between two colors (endpoints included; defaults blue to red) — for heat-map style legends and value ramps. A count of 0 gives an empty list; the most it makes is 1,000,000.
Color.Invert — Inverts a color's red, green and blue channels (the photographic negative); alpha is kept.
Color.Lerp — Interpolates between two colors (t clamped to 0-1). A t that is not a number (NaN) gives the start color and a warning.
Color.Lighten — Makes a color lighter by shifting its HSL lightness up by amount (0-1, clamped); alpha is kept.
Color.Palette — A named palette as a list of colors: colourblind-safe, tableau, pastel, status (green/amber/red/grey) or the viridis, heat and grey ramps interpolated to count; fixed palettes cycle past their size.
Color.Random — A pseudo-random color, stable per seed: the same seed always gives the same color (re-runs stay consistent); change the seed for another one.
Color.RandomList — A list of visually distinct pseudo-random colors (golden-angle hues), stable per seed — ideal for coloring N groups apart. A count of 0 gives an empty list (no groups, no colors); the most it makes is 1,000,000.
Color.ToHex — Formats a color as hex text, "#RRGGBB" (or "#AARRGGBB" with includeAlpha) — the reverse of Color.FromHex.
Color.ToHSV — Splits a color into hue (degrees, 0-360), saturation and value (0-1); greys have hue 0.
Color.WithAlpha — Returns a color with its alpha (opacity) replaced, 0 = transparent to 255 = opaque; red, green and blue are unchanged.

Data (5)

JSON.Parse — Parses a JSON string into dictionaries, lists and values.
JSON.Stringify — Serializes any value to a JSON string.
Snapshot.Diff — Diffs two GUID-keyed dictionaries: added/removed/changed keys (values compared by JSON equality; nested dictionary key order is ignored).
XML.Parse — Parses XML into dictionaries, lists and strings (attributes as "@name", repeated elements as lists, mixed text as "#text"). An element that occurs once is a dictionary or a text, the same element occurring twice is a list, so a graph tried on a file with several items can break on a file with one: name such elements in listElements (for example Task, Resource; or * for all) and they always come as a list. Dictionary.ValueAtPath reads nested results either way. DOCTYPE declarations are accepted but an external entity is never read from disk or the network.
XML.ReadFromFile — Reads an XML file into dictionaries, lists and strings, in the same shape as XML.Parse (attributes as "@name", repeated elements as lists, mixed text as "#text"). The encoding the file declares is honoured - UTF-8, UTF-16, Windows-1252 / ISO-8859-1 - so the accents of an MSP or P6 export survive; reading the file with Text.ReadFromFile and then XML.Parse would decode it as UTF-8 first. A relative path starts in the graph's folder.

DateTime (18)

DateTime.Add — Adds an amount of time to a date/time in a chosen unit — seconds, minutes, hours, days, weeks, months or years (negative values go back). Days, hours and the smaller units take fractions (0.5 days = 12 hours); months and years are calendar steps that clamp to the end of a shorter month (31 January + 1 month = 28 February) and take whole numbers. For working days use DateTime.AddWorkdays.
DateTime.AddWorkdays — Moves a date/time by a number of working days, skipping the weekend (Saturday and Sunday, or Friday and Saturday): Friday + 1 is Monday, Monday - 1 is Friday, Saturday + 1 is Monday. The time of day is kept. Public holidays are not known: move the result on by hand when one falls in between.
DateTime.ByDate — Creates a date from year, month and day numbers.
DateTime.Compare — Compares two date/times: -1 when the first is earlier, 0 when equal, 1 when it is later.
DateTime.Components — Splits a date/time into year, month, day, hour, minute, second, English weekday name, day of year, ISO week, ISO year and quarter.
DateTime.DaysBetween — Returns the signed number of days between two date/times (end minus start), with the time of day as a fraction. For how old something is, wire the date into start and DateTime.Now into end; a date in the future then gives a negative number. DateTime.Difference gives the same in hours, weeks, months and so on.
DateTime.Difference — How far apart two date/times are in a chosen unit — seconds, minutes, hours, days, weeks, months or years (end minus start, so a negative number means the end is earlier). Months and years count calendar months (10 January to 10 March is exactly 2) with the rest as a fraction; the other units are elapsed time with fractions. For how old something is, wire DateTime.Now into end.
DateTime.EndOf — Returns the last millisecond of the day, week, month, quarter or year containing a date/time (start of the next period minus 1 ms).
DateTime.Format — Formats a date/time as text using a .NET format string (invariant culture): yyyy-MM-dd gives 2026-07-10, dd/MM/yyyy gives 10/07/2026, HH:mm gives 14:30, MMMM gives the English month name.
DateTime.FromExcelSerial — Converts an Excel date serial number (days since 1899-12-30, the time of day as the fraction; 46000.5 is noon) to a date/time — what Excel.ReadFromFile and Table.FromExcelFile hand over for a date cell. Wire the column in and the whole column converts. Use dateSystem 1904 for workbooks that use the 1904 date system. Dates before March 1900 come out one day later than Excel shows them, because Excel counts a 29 February 1900 that never existed.
DateTime.FromUnixSeconds — Converts Unix seconds since 1970-01-01 UTC to a (UTC) date/time.
DateTime.IsWeekend — True when a date falls on the weekend (Saturday and Sunday, or Friday and Saturday) — a mask for filtering a schedule down to working days.
DateTime.Now — Returns the current local date and time (captured at execution). At the top level the value is kept until you run the node again; inside a node group every call asks the clock again, so for one timestamp shared by a whole report make it outside the group and pass it in through a Group Input.
DateTime.Parse — Parses text as a date/time. ISO dates (2026-07-10, 2026-07-10 14:30) always work. Numeric dates with slashes, dots or dashes are ambiguous: 10/07/2026 is 7 October month first (the default) and 10 July with dayFirst on. When a date could be read either way and dayFirst is off, the node says which reading it took. An exact .NET format (dd/MM/yyyy, dd.MM.yyyy HH:mm) overrides both and refuses anything else.
DateTime.Range — Creates a list of dates from a start to an end (both included) with a step in days, weeks, months or years ("every month" lands on the same day of each month, clamped to the month's end); at most 100000 items.
DateTime.StartOf — Returns midnight at the start of the day, week, month, quarter or year containing a date/time.
DateTime.Today — Returns today's local date at midnight (captured at execution). At the top level the value is kept until you run the node again; inside a node group every call asks the clock again, so for one date shared by a whole report make it outside the group and pass it in through a Group Input.
DateTime.ToUnixSeconds — Converts a date/time to Unix seconds since 1970-01-01 UTC (a value without a time zone is taken as UTC).

Dictionary (17)

Dictionary.ByKeysValues — Creates a dictionary from a list of keys and a list of values of the same length.
Dictionary.ContainsKey — Tests whether a dictionary has the given key (case-sensitive). A list of dictionaries and a list of keys on separate inputs pair up item by item and stop at the shorter list (the default Shortest lacing); set Cross-Product lacing (right-click the node) to use every key with every dictionary.
Dictionary.Count — Returns the number of entries in a dictionary.
Dictionary.FromRows — Builds a dictionary from a list of [key, value] rows (a later row wins for a repeated key).
Dictionary.Invert — Swaps keys and values into a new dictionary (values become text keys; for equal values the last entry wins).
Dictionary.Keys — Returns all keys of a dictionary as a list.
Dictionary.Merge — Combines several dictionaries into a new one; for a repeated key the later dictionary wins.
Dictionary.RemoveKey — Returns a copy of the dictionary without the given key (a missing key is fine). A list of dictionaries and a list of keys on separate inputs pair up item by item and stop at the shorter list (the default Shortest lacing); set Cross-Product lacing (right-click the node) to use every key with every dictionary. To leave out several keys of one dictionary use Dictionary.RemoveKeys.
Dictionary.RemoveKeys — Returns a copy of the dictionary without any of the listed keys (a key it does not have is fine). A list of keys gives one dictionary without all of them, unlike Dictionary.RemoveKey, which pairs a list of keys with a list of dictionaries. A list of dictionaries gives one result each; the key list applies to every one of them.
Dictionary.SelectKeys — Returns a copy of the dictionary with only the listed keys, in the order they are listed (trim a property bag to the few keys a report needs). A key the dictionary does not have is left out. A list of dictionaries gives one trimmed dictionary each; the key list applies to every one of them.
Dictionary.SetValueAtKey — Returns a copy of the dictionary with the given key set or updated; the input dictionary is not changed. A list of dictionaries and a list of keys on separate inputs pair up item by item and stop at the shorter list (the default Shortest lacing); set Cross-Product lacing (right-click the node) to use every key with every dictionary. To set several keys at once use Dictionary.SetValues.
Dictionary.SetValues — Returns a copy of the dictionary with several keys set or updated at once, from a list of keys and a list of values of the same length (the several-key version of Dictionary.SetValueAtKey). For a key listed twice the last value wins; the input dictionary is not changed. A list of dictionaries gives one result each; the keys and values apply to every one of them.
Dictionary.ToRows — Converts a dictionary to a list of [key, value] rows.
Dictionary.ValueAtKey — Returns the value stored under the given key; a missing key is an error (Dictionary.ValueOrDefault gives a fallback instead, Dictionary.ValueAtPath follows a path into nested data). A list of dictionaries and a list of keys on separate inputs pair up item by item and stop at the shorter list (the default Shortest lacing); set Cross-Product lacing (right-click the node) to use every key with every dictionary. To read several keys of one dictionary use Dictionary.SelectKeys.
Dictionary.ValueAtPath — Follows a path into nested data (the result of JSON.Parse or XML.Parse) and returns what it finds there, or a default value when any step is missing. The steps are separated by / (or by . when the path has no /): a key (Project/Name), a position in a list (Tasks/Task/0/Name; -1 is the last item) or * for every item of a list (Tasks/Task/*/Name gives a list of names). A position of 0 or -1 also works on a value that is not a list, so the same path reads a file with one <Task> and a file with many. A list of paths gives one result per path.
Dictionary.ValueOrDefault — Returns the value stored under a key, or a default value when the key is missing. A list of dictionaries and a list of keys on separate inputs pair up item by item and stop at the shorter list (the default Shortest lacing); set Cross-Product lacing (right-click the node) to use every key with every dictionary.
Dictionary.Values — Returns all values of a dictionary as a list.

Display (4)

Watch — Displays the incoming value. A long list shows its first 1,000 items and a count of the rest; the value itself passes through whole. When the node does not run (an input failed, was switched off or is not connected) the display is cleared.
Watch Image — Displays the image file at the incoming path (PNG, JPG, BMP). Given a list of paths it shows the first image and says how many there are. When the node does not run the picture is cleared.
Watch List — Displays the elements of a list, one per line. A very long list shows its first 2,000 elements and a count of the rest; the value itself passes through whole. When the node does not run the display is cleared.
Watch Table — Displays a table as a grid: column names on top, one line per row. The grid draws the first 2,000 rows (the summary says how many there are); the value itself passes through whole. When the node does not run the display is cleared.

File (37)

CSV.AppendToFile — Appends rows to a CSV file (same quoting and date format as CSV.WriteToFile), writing the optional headers only when the file is new or empty. In a loop, wire the loop item (or something made from it) into the rows: a node with only fixed inputs belongs to no loop and runs once. A relative path starts in the graph's folder.
CSV.ReadFromFile — Reads a CSV file into a list of rows. Plain numbers become numbers; codes with leading zeros (007), whole numbers of more than 15 digits and the words NaN and Infinity stay text, and Advanced > numbers = text keeps every cell as text. Delimiter: comma, semicolon, bar or tab. The encoding is detected (a file that is not valid UTF-8 is read as Windows-1252). For a table with column names use Table.FromCsvFile. A relative path starts in the graph's folder.
CSV.WriteToFile — Writes a list of rows to a CSV file, replacing what was there, and creates missing folders. Cells with the delimiter, quotes or line breaks are quoted; dates are written as 2026-10-04 14:30:00 (the same in every country); empty cells stay empty. Delimiter: comma, semicolon, bar or tab. Advanced > encoding: "UTF-8 with BOM" makes Excel show accents and symbols correctly. For a table use Table.ToCsvFile; to add rows to a file use CSV.AppendToFile. A relative path starts in the graph's folder.
Directory.Copy — Copies a folder with all its files and sub-folders to another place (creates the destination; files already there are kept, and a file with the same name is only replaced when overwrite is true - checked before anything is copied). The destination cannot be inside the source. A relative path starts in the graph's folder.
Directory.Create — Creates a folder including any missing parent folders (does nothing when it already exists). A relative path starts in the graph's folder.
Directory.Delete — Deletes a folder (an empty one, or with its whole content when recursive is true); returns false when it did not exist. A relative path starts in the graph's folder.
Directory.Exists — Tests whether a folder exists at the given path; a file, a missing folder and a blank path all give false. A relative path starts in the graph's folder.
Directory.Find — Finds files or folders under a folder by wildcard (several allowed, separated by ";"), in every sub-folder unless recursive is off. kind chooses files or folders. The paths come sorted by name, ignoring case and with numbers in order (c2 before c10); Advanced sorts by date or size instead and can keep only the first few - the newest file is sortBy modified + descending + limit 1. A pattern must match the whole name, so "*.ifc" never also finds .ifcxml. A relative path starts in the graph's folder.
Directory.Move — Moves or renames a folder with everything in it. When the destination already exists it is an error unless overwrite is true, which moves the content into it and replaces files with the same name. Moving to another drive copies first and removes the original afterwards. The destination cannot be inside the source. A relative path starts in the graph's folder.
Excel.ReadFromFile — Reads an .xlsx worksheet into rows + headers + the sheet names (dates arrive as Excel serial numbers, convert them with DateTime.FromExcelSerial; .xls is not supported). Text cells such as 007 stay text. Every row is padded with empty cells to the widest row, and empty rows at the end of the sheet - the ones that only carry formatting - are dropped (Advanced > trimEmptyRows; blank rows in the middle are kept so row numbers stay true). For a table use Table.FromExcelFile. A relative path starts in the graph's folder.
Excel.WriteToFile — Writes rows (+ optional headers) to an .xlsx worksheet. Dates become real date cells (shown as dates in Excel), a list in a cell is written as text like [1, 2], and NaN or Infinity as text. Advanced > append adds the sheet to an existing workbook and replaces a sheet of the same name; the workbook is rebuilt from its cell values, so formulas, formatting, charts and pictures of a workbook made in Excel are not kept (a warning says so). The file is built beside the target and then put in place, so a failure never leaves a broken workbook. For a table use Table.ToExcelFile. A relative path starts in the graph's folder.
File.Copy — Copies a file to a new path (creates the destination folder; refuses to replace an existing file unless overwrite is true). A relative path starts in the graph's folder.
File.Delete — Deletes a file; returns true when it was deleted and false when it did not exist. A relative path starts in the graph's folder.
File.Exists — Tests whether a file exists at the given path; a folder, a missing file and a blank path all give false. A relative path starts in the graph's folder.
File.Hash — Computes a checksum of a file's content (SHA256, SHA1 or MD5) as lower-case hex text - handy for change detection. A relative path starts in the graph's folder.
File.Info — Reads a file's name, extension, folder, size in bytes and modified / created dates; a missing file gives exists = false and empty values instead of an error. A relative path starts in the graph's folder.
File.Move — Moves or renames a file (creates the destination folder; refuses to replace an existing file unless overwrite is true). With overwrite, the old destination file is replaced only once the move can succeed: if the source is locked by another program, the destination stays as it was. A relative path starts in the graph's folder.
JSON.ReadFromFile — Reads a JSON file into dictionaries, lists and values (every number becomes a double). The encoding is detected. A relative path starts in the graph's folder.
JSON.WriteToFile — Writes any value to a JSON file, replacing what was there, and creates missing folders. Nothing wired (null) is an error that leaves the file alone. A relative path starts in the graph's folder.
Log.Write — Appends one line "yyyy-MM-dd HH:mm:ss LEVEL message" (local time) to a log file and returns that line. In a loop, wire the loop item (or something made from it) into the message to get one line per pass: a Log.Write with only fixed inputs belongs to no loop and writes once. A relative path starts in the graph's folder.
Path.ChangeExtension — Replaces the extension of a path ("a.nwd" + "nwf" gives "a.nwf"); empty text removes the extension.
Path.Combine — Joins a folder path and a file name with the correct separator. Trap: if the file name is itself a full path (it starts with a drive such as C:\ or with a backslash), the result is that part alone and the folder is dropped; Path.Join does not do that and takes any number of parts.
Path.GetDirectory — Returns the folder part of a path ("C:\Models\site.nwd" gives "C:\Models"); empty text for a root or a bare file name.
Path.GetExtension — Returns the extension of a path with its leading dot (".nwd"), or empty text when there is none.
Path.GetFileName — Returns the file name of a path including its extension ("C:\Models\site.nwd" gives "site.nwd").
Path.GetFileNameWithoutExtension — Returns the file name of a path without its extension ("C:\Models\site.nwd" gives "site").
Path.GetFullPath — Resolves a path to an absolute path the way the file nodes do: a relative path starts in the graph's folder (the folder of the saved graph file; Documents\CamelGraph for a graph that was never saved), and the quotes of a path pasted from Explorer are removed. The file does not have to exist.
Path.GetRelativePath — Expresses a path relative to a base folder; returns the full path when they are on different drives. Relative inputs start in the graph's folder.
Path.IsAbsolute — Tests whether a path is absolute (starts at a drive, network share or root) rather than relative.
Path.Join — Joins any number of folder and file name parts into one path with the correct separator, for example C:\Projects + North + HVAC + model.nwd. Blank parts are skipped, and several wires, lists and lists of lists are joined in order. Unlike Path.Combine, a part that starts with a backslash or slash does not throw away what came before it, and a part with its own drive (D:\x) is an error instead of silently replacing the folder.
Path.Normalize — Cleans a path as text: one separator style, no trailing separator, "." and ".." resolved (the disk is never read).
Text.AppendToFile — Appends text (plus a line break by default) to the end of a text file, creating the file and folder if needed. A list of texts appends every item as its own line. Nothing wired is an error; empty text with the line break on adds a blank line. In a loop, wire the loop item (or something made from it) into the text: a node with only fixed inputs belongs to no loop and runs once. A relative path starts in the graph's folder.
Text.ReadFromFile — Reads the entire content of a text file as one text. The encoding is detected: UTF-8 or UTF-16 as the file marks it, and a file that is not valid UTF-8 is read as Windows-1252 (what a European Excel "CSV (Comma delimited)" export uses); Advanced > encoding forces one. A relative path starts in the graph's folder. To split the text into lines use String.Split.
Text.WriteToFile — Writes text to a file, replacing what was there, and creates missing folders; returns the path. A list of texts is written one item per line (joined with line breaks, no final line break). Nothing wired is an error that leaves the file alone; empty text "" empties it. A list of paths writes every file with the same text - set the text input to @L1 to write one text per path. Advanced > encoding: "UTF-8 with BOM" makes Excel show accents and symbols correctly. A relative path starts in the graph's folder. To add to a file use Text.AppendToFile.
Zip.Create — Packs files and folders into a zip archive (a folder is stored with its structure under its own name); a missing source is an error. Several wires, lists and lists of lists of paths can go into sources (for example a list of files plus one extra folder); they are packed in order. The zip is built beside the target and then put in place, so a failure never leaves a half-written file. A relative path starts in the graph's folder.
Zip.Extract — Unpacks a zip archive into a folder; refuses entries that would escape the folder and files that already exist unless overwrite is true. A relative path starts in the graph's folder.
Zip.List — Lists the entry names inside a zip archive without extracting it. A relative path starts in the graph's folder.

Geometry (42)

BoundingBox.ByCorners — Creates an axis-aligned bounding box spanning two opposite corner points, given in any order (the smaller coordinates become the box's min corner, the larger its max corner).
BoundingBox.Center — Returns the center point of a bounding box.
BoundingBox.Contains — Tests whether a point lies inside a bounding box (points on the boundary count as inside).
BoundingBox.ContainsBox — True when the inner box fits entirely inside the outer box (touching faces count as inside).
BoundingBox.Corners — The 8 corner points of a bounding box: the bottom face counter-clockwise from the Min corner (0-3), then the top face in the same order (4-7).
BoundingBox.Expand — Grows a bounding box by an amount on every side (negative shrinks it; shrinking past zero size is an error) — a clearance or tolerance zone around an element.
BoundingBox.Footprint — The plan (floor) area of a bounding box: size X times size Y, ignoring height.
BoundingBox.Intersects — Tests whether two bounding boxes overlap (touching counts as intersecting).
BoundingBox.Overlap — The bounding box shared by two overlapping boxes; an error when they do not meet, so test with BoundingBox.Intersects first.
BoundingBox.PlanGap — The widest strip of open floor between an inner box (equipment) and the outer box (opening) in plan — the 'space between the equipment and the opening edge'. Returns the largest of the four horizontal side gaps; 0 when the equipment reaches every edge. Threshold it to flag openings that need a handrail.
BoundingBox.Scale — Scales a bounding box about its center by a factor (2 = double, 0.5 = half) — e.g. to pad a box before a section or zoom.
BoundingBox.Size — Returns a bounding box's size along each axis and its min/max corner points.
BoundingBox.SurfaceArea — The total area of a bounding box's six faces (square model units) — e.g. for a coating or cladding estimate.
BoundingBox.Translate — Moves a bounding box by an offset vector, keeping its size.
BoundingBox.Union — ONE bounding box fitting every box and/or point wired in — the geometric union, e.g. one frame around scattered elements' boxes or around a set of points (several wires can feed the one input; [x,y,z] triples work too; lists nest freely, a list of lists included).
BoundingBox.Volume — The volume of a bounding box (cubic model units); a flat box has volume 0.
Point.ByCoordinates — Creates a 3D point from X, Y and Z coordinates.
Point.Centroid — The centroid (average position) of a list of points; several wires can feed the one input. An empty list, a null or a non-point item is an error naming the item.
Point.Components — Splits a point into its X, Y and Z coordinates.
Point.Distance2D — The distance between two points measured in plan (XY only, Z ignored) — for horizontal run lengths and offsets.
Point.DistanceTo — Returns the straight-line distance between two points.
Point.Lerp — Interpolates between two points: t = 0 is the first, t = 1 the second; t is not clamped, so other values extend the line beyond them.
Point.Midpoint — The point halfway between two points.
Point.Round — Rounds a point's X, Y and Z to the given number of decimal digits (midpoints round away from zero) — tidies float noise before comparing or grouping points.
Point.Translate — Offsets a point by a vector, returning a new point.
Vector.Add — Adds two vectors (a + b).
Vector.Angle — The angle between two vectors in degrees, 0 (same direction) to 180 (opposite); a zero-length vector has no direction and is an error.
Vector.ByCoordinates — Creates a 3D direction vector from X, Y and Z components.
Vector.ByPoints — Creates the vector that leads from one point to another (end minus start).
Vector.Components — Splits a vector into its X, Y and Z components.
Vector.Cross — The cross product of two vectors: a vector perpendicular to both (right-hand rule), zero when they are parallel.
Vector.Dot — The dot product of two vectors: positive when they point the same way, 0 when perpendicular, negative when opposed.
Vector.IsParallel — True when two vectors lie along the same line (same or opposite direction) within a length-independent tolerance; zero-length vectors are an error.
Vector.IsPerpendicular — True when two vectors meet at a right angle within a length-independent tolerance; zero-length vectors are an error.
Vector.Length — Returns the length (magnitude) of a vector.
Vector.Negate — Reverses a vector so it points the opposite way.
Vector.Normalize — Scales a vector to length 1, keeping its direction (a zero-length vector has no direction and is an error).
Vector.Scale — Multiplies a vector by a number (2 doubles its length, -1 reverses it). A factor that is not a finite number gives a warning.
Vector.Subtract — Subtracts one vector from another (a - b).
Vector.XAxis — The unit vector along the X axis, (1, 0, 0).
Vector.YAxis — The unit vector along the Y axis, (0, 1, 0).
Vector.ZAxis — The unit vector along the Z axis, (0, 0, 1) — straight up.

IFC (4)

IFC.GuidDecode — Converts a 22-character IFC GlobalId such as "0$WU4A9R19$vKWO$AdOnKA" back to a standard lower-case hyphenated GUID — the form Navisworks shows as an item's GUID. A plain GUID is refused here; for a column that mixes both forms use IFC.Normalize.
IFC.GuidEncode — Converts a standard GUID such as "3f81e10a-25b0-49ff-9520-63f2a763150a" to the 22-character IFC GlobalId (the IFC base-64 form, alphabet 0-9 A-Z a-z _ $) — the format of IFC files and BCF references. A GlobalId is refused here; for a column that mixes both forms use IFC.Normalize.
IFC.IsGlobalId — True when a text is a 22-character IFC GlobalId (alphabet 0-9 A-Z a-z _ $, first character 0 to 3) and false for a plain GUID, any other text or an empty cell, so a column that mixes both forms can be split before IFC.GuidDecode or IFC.GuidEncode. A list gives one answer per item, empty cells included.
IFC.Normalize — Writes an id in one form whichever form it comes in: a 22-character IFC GlobalId or a standard GUID (with hyphens, without, or in braces) becomes the form you choose, a GlobalId (default) or a lower-case hyphenated GUID. Use it on a column that mixes both forms, where IFC.GuidEncode and IFC.GuidDecode would each refuse the other form. A text that is neither is an error naming the text (in a list: an empty result and one warning).

Input (11)

Boolean — A true/false toggle.
Choice — A pick-list with your own options (one per line); gives the chosen text and its position.
Color Picker — A color chosen with a picker.
Date — A date (and optional time), typed as 2026-10-01 or 2026-10-01 14:30.
Directory Path — A path to a directory.
File Path — A path to a file.
Integer — A whole number (no slider range): a count, an index, a level.
Integer Slider — An integer selected with a slider.
Number — A number literal.
Number Slider — A number selected with a slider.
String — A string literal.

List (50)

List.AddItemToEnd — Appends a value to the end of a list (returns a new list).
List.AddItemToFront — Returns a new list with the value prepended — the front-side twin of List.AddItemToEnd.
List.AllIndicesOf — Every zero-based index at which the item occurs in the list — List.IndexOf finds only the first. Values compare as in List.IndexOf. Feed the indices to List.GetItemAtIndex on a parallel list to pull the matching entries.
List.AllTrue — True when EVERY element of the list is true — collapse a mask into one verdict. Only the booleans true and false (or the text "true" and "false") count: an empty list gives false, null items count as not true, and any other value (a number, other text) counts as not true and adds a warning. A list inside the list is an error: set the input to @L2 for one verdict per sublist, or flatten it first. A wire that delivers nothing at all is ignored.
List.AnyTrue — True when AT LEAST ONE element of the list is true — "did anything match?" in one node. Only the booleans true and false (or the text "true" and "false") count: an empty list gives false, null items count as not true, and any other value (a number, other text) counts as not true and adds a warning. A list inside the list is an error: set the input to @L2 for one answer per sublist, or flatten it first. A wire that delivers nothing at all is ignored.
List.Chop — Chops a list into consecutive sublists: one length chops evenly ([1..7] by 3 → [1,2,3],[4,5,6],[7]); a list of lengths is applied in sequence and repeats until the input runs out (Dynamo behavior). Every length must be a whole number of at least 1.
List.Clean — Removes null elements from a list, at every nesting level — the mop-up after laced calls that emitted nulls for missing elements (a yellow node badge points here). removeEmptyLists also drops sublists left empty. Dynamo users: same idea as List.Clean.
List.Contains — Tests whether a list contains a value. Numbers compare by value regardless of numeric type, text with its case, and a list or dictionary by its content, so a [level, type] pair can be looked up too.
List.Count — Returns the number of elements in a list.
List.CountTrue — Counts the true and not-true elements of a mask — "37 of 340 matched" for reports without filtering first. Only the booleans true and false (or the text "true" and "false") count as true or false: null items and any other value (a number, other text) go into the not-true count, and a value that is not a boolean adds a warning. A list inside the list is an error: set the input to @L2 for one count per sublist, or flatten it first. A wire that delivers nothing at all is ignored.
List.Create — Builds a list from the wired item inputs, in order. A wired list is kept whole as ONE item of the new list (a list of lists); List.Merge joins lists into one list instead.
List.Cycle — Repeats the whole list a number of times, end-to-end ([a,b] × 3 → [a,b,a,b,a,b]). The result may hold at most 1,000,000 items; more is an error.
List.DropItems — Drops elements from the start of the list — or from the END with a negative amount (Dynamo behavior). Dropping more than the length gives an empty list.
List.DropWhile — Drops items from the start of the list for as long as the mask is true; keeps everything from the first false. The mask is read as in List.FilterByBoolMask: one true or false per item, a null counts as false, and a list or a value that is not true or false is an error.
List.FilterByBoolMask — Splits a list into elements whose mask entry is true ("in") and the rest ("out"). The mask must have one entry per element: true or false, the text "true" or "false", or a number (0 is false, any other number true); an empty entry (null) counts as false, so the element goes to "out". A list or dictionary in the mask is an error: set both inputs to @L2 (right-click, List Levels) to filter each pair of sublists, or flatten them first.
List.FilterByValue — Keeps the items that pass a test such as > 100, contains "wall", matches "A-*" or in ["L01", "L02"] — optionally testing a parallel list of keys instead; returns the matches, the rest and the mask. The tests > >= < <= never pass an item that has no value (null or blank text) or one that cannot be compared with the value (text against a number; the node then warns and names the first). The test in keeps the items equal to any of the values in a list (or in a text with the values separated by commas or semicolons); notIn keeps the others. Text tests ignore case unless ignoreCase is off; regex needs a pattern of its own and stops after 2 seconds.
List.FirstItem — Returns the first element of a list. An empty list is an error: there is no first element (check List.Count first, or use List.Slice, which gives an empty list).
List.Flatten — Flattens a nested list by a given number of levels (-1 = completely).
List.GetItemAtIndex — Returns the element at the given index (negative indexes count from the end).
List.GroupByKey — Groups list elements by a parallel key list of the same length; returns the groups (in the order each key first appears) and their unique keys. A key can be a list, such as [level, type], and two keys with the same content make one group; text keys keep their case.
List.IndexOf — Returns the index of the first occurrence of a value in a list (-1 when absent). Numbers compare by value, text with its case, and lists and dictionaries by their content.
List.Insert — Returns a new list with the value inserted at the index (0 = front; the list's length = append; negative counts from the end). A list of indices makes one new list per index; the list itself is always taken whole.
List.LastIndexOf — The zero-based index of the LAST occurrence of the item (-1 when absent) — the back-to-front twin of List.IndexOf, with the same rules for comparing values.
List.LastItem — Returns the last element of a list. An empty list is an error: there is no last element (check List.Count first, or use List.Slice, which gives an empty list).
List.MaximumItem — The largest element of a list (numbers, texts or dates). Items are compared as in List.Sort: numbers by value, text ignoring case ("10" and "9" are text, so "9" is the larger; List.Statistics reads such text as numbers); nulls and empty text are ignored. A list with nothing to compare gives an empty result and a warning, not an error.
List.Merge — Concatenates any number of lists into one — a multi-input socket: connect as many wires as you like, in the order you want them.
List.MinimumItem — The smallest element of a list (numbers, texts or dates). Items are compared as in List.Sort: numbers by value, text ignoring case ("10" and "9" are text, so "10" is the smaller; List.Statistics reads such text as numbers); nulls and empty text are ignored. A list with nothing to compare gives an empty result and a warning, not an error.
List.OfRepeatedItem — A list of one value repeated N times — constant columns for tables, or a fixed pairing partner under Longest lacing. At most 1,000,000 copies; more is an error.
List.Pairs — Pairs each item with the next one: [[a, b], [b, c], …] — consecutive points, segments, steps.
List.Range — Creates a sequence of numbers from start to end (both included) using the given step; a negative step counts down, a step that moves away from end gives an empty list. Each number is start + n x step, so 0.1 steps do not drift. At most 1,000,000 numbers: a larger sequence is an error, so a slip of a zero cannot use up the memory of Navisworks.
List.RemoveItemAtIndex — Removes the elements at the given indices and returns one new list (negative indexes count from the end). Wire a single number to remove one element, or a list of numbers, for example from List.AllIndicesOf, to remove them all in one go. Indices count in the original list; an index outside the list is an error.
List.ReplaceItemAtIndex — Returns a new list with the element at the index replaced (negative indexes count from the end). A list of indices makes one new list per index (the first index with the first item, and so on); the list itself is always taken whole.
List.ReplaceNulls — Replaces every null element with a substitute value, at every nesting level — keeps list lengths and alignment intact where List.Clean would shift them. The gap-filler for laced calls that emitted nulls (0 for math, "n/a" for reports).
List.RestOfItems — Everything but the first element — pairs with List.FirstItem for head/tail processing. An empty list is an error: there is no first element to leave out.
List.Reverse — Returns the list in reverse order.
List.SetDifference — The distinct elements of the FIRST list that are NOT in the second — subtract an ignore-list from a result set. Values compare as in List.UniqueItems, lists and dictionaries by content.
List.SetIntersection — The distinct elements present in BOTH lists (ordered as in the first) — what two searches/sets have in common. Values compare as in List.UniqueItems, lists and dictionaries by content.
List.SetUnion — The distinct elements present in EITHER list (first-seen order) — combine two item sets without duplicates. Values compare as in List.UniqueItems, lists and dictionaries by content.
List.ShiftIndices — Rotates the list: +1 moves every element one place towards the end and wraps the last to the front ([a,b,c] → [c,a,b]); negative rotates the other way.
List.Shuffle — Shuffles a list; the same seed always gives the same order, so a run can be repeated.
List.Slice — A sub-range of the list: from start (inclusive) to end (exclusive), taking every step-th element; leave end empty to go to the end of the list. Negative start/end count from the end, Python-style. Start 0 with a step of 3 keeps the 1st, 4th, 7th ... item, which is how to thin a list out.
List.Sort — Returns the list sorted ascending, or largest first with descending. Numbers sort by value; text alphabetically, ignoring upper and lower case ("apple" comes before "Zebra", and "10" before "9" because both are text); text that reads as a number counts as a number against a number; empty items (null or empty text) always go last, in either direction. Equal items keep their order. A list inside the list cannot be put in order: set the input to @L2 to sort each sublist.
List.SortByKey — Sorts list elements by a parallel key list of the same length, smallest key first or largest first with descending; returns the sorted elements and keys. Keys are put in order as in List.Sort (numbers by value, text ignoring case, empty keys last); elements with equal keys keep their order.
List.TakeEveryNthItem — Takes the n-th, 2n-th, 3n-th ... element, optionally after skipping offset elements (n = 3 takes the 3rd, 6th and 9th, which are the indices 2, 5 and 8). To keep the 1st, 4th, 7th ... instead, use List.Slice with a step.
List.TakeItems — Takes elements from the start of the list — or from the END with a negative amount (Dynamo behavior). Taking more than the length gives the whole list.
List.TakeWhile — Takes items from the start of the list for as long as the mask is true (stops at the first false). The mask is read as in List.FilterByBoolMask: one true or false per item, a null counts as false, and a list or a value that is not true or false is an error.
List.Transpose — Swaps rows and columns of a list of lists — the table pivot for Excel/CSV data and property grids. Shorter rows pad with nulls so the result stays rectangular (Dynamo behavior); List.Clean or List.ReplaceNulls deal with the padding.
List.UniqueItems — Removes duplicate elements from a list, keeping the first of each and the original order. Numbers compare by value, text with its case, and lists and dictionaries by their content, so repeated pairs from List.Zip are removed too.
List.WithIndex — Pairs each item with its position: [[0, item0], [1, item1], …].
List.Zip — Pairs two lists by position: [[a0, b0], [a1, b1], …], as long as the shorter list. When the lists differ in length the extra items of the longer one are left out and the node shows a warning that says how many.

List.Statistics (12)

List.Average — The arithmetic mean of the numbers of a list. Nulls and blank text are skipped; with no numbers at all (an empty list) the result is empty and the node shows a warning instead of an error. A list inside the list is an error: set the input to @L2 for one average per sublist.
List.CountValues — Tallies a list: each distinct value, in order of first appearance, with the number of times it occurs. Numbers compare by value, text with its case, and lists and dictionaries by their content. (It tallies the values themselves; List.GroupByKey groups items by a separate list of keys.)
List.CumulativeSum — A running total: each item is the sum of the list up to and including that position. An empty item (null or blank text) is an error, so the totals stay lined up with the list; remove or fill empty items first (List.FilterByValue with the notEmpty test, or List.ReplaceNulls). A list inside the list is an error: set the input to @L2 for one running total per sublist.
List.Duplicates — The values that occur more than once, with how many times each occurs — duplicate GUIDs, marks or names. Values compare as in List.CountValues (text with its case); nulls are not duplicates.
List.Histogram — Splits the range of the numbers into equal bins and counts how many fall in each — the data behind a distribution chart. Nulls and blank text are skipped; with no numbers at all the four lists are empty and the node shows a warning instead of an error.
List.Median — The middle value of the numbers of a list (the mean of the two middle ones when the count is even); the same as List.Percentile at 50. Nulls and blank text are skipped; with no numbers at all the result is empty and the node shows a warning instead of an error.
List.MostCommon — The value that occurs most often in a list (the earliest wins a tie) and how many times. Values compare as in List.CountValues (text with its case); nulls are not counted. A list with nothing but nulls is an error.
List.Percentile — The value below which a given percentage of the numbers lie (linear interpolation, like Excel's PERCENTILE.INC); 50 is the median, 0 the smallest and 100 the largest number. Nulls and blank text are skipped; with no numbers at all the result is empty and the node shows a warning instead of an error.
List.Product — Multiplies the numbers of a list. Nulls and blank text are skipped and an empty list gives 1. A list inside the list is an error: set the input to @L2 for one product per sublist.
List.StandardDeviation — The standard deviation of the numbers of a list (population by default; tick 'sample' to divide by n-1, which needs at least two numbers). Nulls and blank text are skipped; with too few numbers the result is empty and the node shows a warning instead of an error.
List.Statistics — Count, sum, minimum, maximum, average, median and standard deviation of a list of numbers in one node. Nulls and blank text are skipped and not counted; with no numbers at all the count is 0, the sum is 0, the rest is empty and the node shows a warning. Text that reads as a number is compared as a number here (List.MaximumItem compares text as text).
List.Sum — Adds up the numbers of a list. Nulls and blank text (an empty cell) are skipped, text such as "12.5" is read as a number, and an empty list gives 0. A list inside the list is an error: set the input to @L2 for one total per sublist.

Logic (18)

And — Returns true only when both inputs are true.
Equals — Tests whether two values are equal, the same way as Logic.Compare with ==: numbers compare by value (2 equals 2.0), text ignores upper and lower case, text that reads as a number equals that number ("5" equals 5), text that reads as a date equals that date, and two lists are equal when they have the same items in the same order. A list is compared as ONE value; to test every element of a list set List Levels to @L1 on a (an empty element is equal only to another empty one). For a case-sensitive text test use Logic.Compare with ignoreCase off, and for numbers within a tolerance use Math.IsClose.
GreaterThan — Returns true when the first number is greater than the second.
GreaterThanOrEqual — Returns true when the first number is greater than or equal to the second.
If — Returns one of two values depending on a boolean condition. Both branches are always computed, so a node wired into the unused branch still runs: to skip nodes (a modifying node, a slow search) use Flow.When instead. A list of booleans on test gives a list of choices.
IsNull — True when the value is null (nothing came out). Wired to a list it tests the LIST, which is never null; set the input's List Levels to @L1 to test every element instead, and each empty element gives true. That gives the bool mask for List.FilterByBoolMask (pair with Not to keep the non-nulls). Text that is empty or blank is not null: use IsNullOrEmpty or String.IsBlank for that.
IsNullOrEmpty — True when the value is null, an empty string, an empty list or an empty dictionary — the guard for "did anything come out?" checks before If branches. NOTE: wired to a list directly it tests the LIST (empty or not); set the input's List Levels to @L1 to test each element instead, and each empty element gives true. Text of only spaces is not empty here: String.IsBlank counts it as blank.
LessThan — Returns true when the first number is less than the second.
LessThanOrEqual — Returns true when the first number is less than or equal to the second.
Logic.Choose — Picks one of several options by position (0 = first) — a multi-way If. All options are always computed, so a node wired into an option that is not picked still runs: to skip nodes use Flow.When.
Logic.Compare — Compares two values — numbers, text or dates — with a test chosen from a list (==, >, contains, matches, regex …). Text that reads as a number is compared as a number, and text that reads as a date (2026-10-01) is compared as a date when the other side is a date. Text ignores upper and lower case unless ignoreCase is off (the regex test is the same). A missing value (empty or blank) is never greater or less than anything, so it does not pass > >= < <=; use isNull or isEmpty to find it. Equals and Logic.NotEquals follow the same rules for == and !=. A list on a is tested as ONE value: to test every element set List Levels to @L1 on a (or use List.FilterByValue to split a list). For numbers within a tolerance use Math.IsClose.
Logic.IsBetween — True when a number, text or date lies between a lower and an upper bound (bounds included by default). Text that reads as a number or, next to a date, as a date is compared as one. A list on value (or on a bound) gives a list of answers, one per element, so a whole column can be tested at once. A missing value, or text that is not a number next to numbers, is not between; an empty bound is an error. To test a number against a target within a tolerance use Math.IsClose.
Logic.NotEquals — True when two values are different — the opposite of Equals, with the same rules: numbers compare by value, text ignores upper and lower case, text that reads as a number or a date is compared as one, and two lists are equal when they have the same items in the same order. A list is compared as ONE value; to test every element of a list set List Levels to @L1 on a.
Logic.Switch — Gives the result that goes with the first case equal to the value, otherwise the fallback — a status-to-colour or code-to-name mapping. Matching follows Equals: text ignores upper and lower case and text that reads as a number matches that number. A list on value is looked up element by element and gives a list of results. All results are computed whether or not they are picked; to skip nodes use Flow.When.
Logic.TypeOf — Names the kind of a value — number, text, boolean, datetime, list, dictionary, null or the object's type — for debugging what a node really returns.
Logic.Xor — True when exactly one of the two inputs is true.
Not — Inverts a boolean value.
Or — Returns true when at least one input is true.

Math (38)

Add — Adds two numbers.
Divide — Divides the first number by the second. Dividing by zero does not stop the graph: the result is Infinity (NaN for 0 / 0) and the node shows a warning, so check the divisor before using the result.
Math.Abs — Returns the absolute value of a number.
Math.Acos — Inverse cosine: the angle whose cosine is the value (result in degrees by default).
Math.Asin — Inverse sine: the angle whose sine is the value (result in degrees by default).
Math.Atan — Inverse tangent: the angle for a slope (result in degrees by default).
Math.Atan2 — Angle of the direction (x, y) from the X axis, from -180 to 180 degrees — the heading between two points.
Math.Ceiling — Rounds a number up to the nearest integer.
Math.Clamp — Limits a number to a range: below the minimum gives the minimum, above the maximum gives the maximum.
Math.Cos — Cosine of an angle (degrees by default).
Math.Degrees — Converts radians to degrees.
Math.Exp — e raised to a power (the inverse of the natural logarithm).
Math.Floor — Rounds a number down to the nearest integer (-2.5 becomes -3; Math.Truncate drops the decimals towards zero instead).
Math.Formula — Evaluates a formula such as "a * b + 2" or "if(a > 10, a - 10, 0)" over the inputs a to f. Operators + - * / % ^ and comparisons; functions abs sqrt sin cos tan (radians) asin acos atan atan2 ln log exp pow min max round floor ceil trunc sign clamp mod hypot rad deg if; constants pi, tau. A list on any input evaluates once per item.
Math.IsClose — True when two numbers differ by no more than the tolerance (the same unit as the numbers) — the safe way to ask "are these equal?" for lengths and levels read from a model, where 0.1 + 0.2 is not exactly 0.3. Equals compares exactly. A number that is not a finite number is close only to an identical one. A list on a or b gives a list of answers.
Math.Lerp — Linear interpolation: a at t = 0, b at t = 1, in between for values between (not limited, so t = 2 goes past b; Math.Clamp keeps t in 0 to 1).
Math.Ln — Natural logarithm (base e) of a positive number.
Math.Log — Logarithm of a positive number to a base (10 by default).
Math.MapRange — Linearly remaps a value from one range to another (values outside the range extrapolate).
Math.Max — Returns the larger of two numbers.
Math.Min — Returns the smaller of two numbers.
Math.Negate — Flips the sign of a number (5 becomes -5).
Math.Percent — What percentage the part is of the total (37 of 340 gives 10.88); 0 when the total is 0, so an empty model reads 0 % (Divide, in contrast, gives Infinity for a zero divisor).
Math.Pi — The constant pi (3.14159…).
Math.Pow — Raises the first number to the power of the second. A result that is not a real number (a negative base with a fractional exponent is NaN) or too large to hold (Infinity) is still returned, with a warning.
Math.Radians — Converts degrees to radians.
Math.Random — Returns a random number in a range. With a seed of 0 or more the same seed always gives the same number; without one (-1) every run gives a new number. Inside a node group every call draws again, so for one sample shared by a whole report make the number outside the group and pass it in through a Group Input.
Math.Round — Rounds a number to the given number of decimal digits (midpoints round away from zero).
Math.RoundToMultiple — Rounds to the nearest multiple of a step, e.g. a length to the nearest 5 mm or a level to 0.25 m.
Math.Sequence — A list of count numbers starting at start and growing by step (the count-based sibling of List.Range).
Math.Sign — -1 for a negative number, 0 for zero, 1 for a positive number. A value that is not a number (NaN) gives 0 and a warning.
Math.Sin — Sine of an angle (degrees by default).
Math.Sqrt — Returns the square root of a non-negative number.
Math.Tan — Tangent of an angle (degrees by default); slope = tan(angle).
Math.Truncate — Drops the decimals, towards zero (2.7 becomes 2, -2.7 becomes -2).
Modulo — Returns the remainder of dividing the first number by the second. The sign of the answer follows the first number, so Modulo(-1, 3) is -1, not 2: for a wrap-around (an angle, a cyclic index) use Math.Formula with "a - b * floor(a / b)". A zero divisor gives NaN and a warning.
Multiply — Multiplies two numbers.
Subtract — Subtracts the second number from the first.

Navisworks.Analysis (9)

Audit.DuplicateItems — Finds duplicated geometry (double-exported elements) by running a temporary Duplicate clash test over the items. The test is added to the Clash Detective tests for the moment the check runs and removed again, so the node changes the clash tests (and the Script Player says so). tolerance is in the unit of the Advanced input units; "document" means the file's own unit, which is often feet, so name the unit when you know it.
Audit.MissingProperty — Finds every item that does NOT carry the given property — the data-completeness audit. Lace over a property list to batch-audit.
Distance.BetweenItems — Shortest distance between two selections, with the closest (witness) point on each side. method "mesh" = exact surface-to-surface via the Clash engine (can be slow on very large selections); "bbox" = fast bounding-box approximation. Document units — chain Units.Convert. The bbox tier measures between the combined box of each side, a coarser answer than Proximity.NearestDistance, which measures to each target on its own. The default is mesh here and bbox on Proximity.NearestDistance.
FallHazard.EdgeHandrailCheck — Marks the floor edges around voids: green where the gap across the void is under the limit (safe), red where it is over the limit and there is no handrail (needs one), and blue where a handrail covers it — override any of the three colours with the colour inputs. Handrail geometry is projected flat onto the plan — posts and rails, corners and all — and matched per length, so a 1 m handrail on a 5 m edge protects only its 1 m. A dangerous stretch shorter than 'minPassage' also counts as safe (a person cannot fit through the break). Turn on 'showOverage' to print how far each dangerous run exceeds the limit on the image, ready for reports. Set 'units' to the unit your numbers are in (e.g. Meters) — documents often store coordinates in feet even when the measure tool displays metres. Writes a top-down PNG and reports the dangerous / protected / safe edge lengths. Needs a live Navisworks session.
FallHazard.FloorOpeningMap — Whole-floor fall-hazard heat map. At 'level', reads the filled silhouette of the floor and (optional) equipment elements that cross that plane, finds the voids enclosed by floor, subtracts the equipment that plugs them, and writes a top-down PNG heat map coloured by how far each void point is from the nearest floor edge or obstacle: cool below the 'minGap' limit (within reach of a solid), hot beyond it (a genuine fall hazard). Wire 'lowColor'/'highColor' to replace the default ramp with your own two-colour gradient (low = safe end, high = worst hazard; the limit sits at the 50% blend), and turn on 'showOverage' to print each flagged opening's gap-over-limit on the image — ready for reports. Openings that reach past the limit are flagged and get a saved viewpoint (named "Opening 1 — gap 0.35 Meters", the gap in the unit you chose) in the folder "Floor Openings"; running again replaces a viewpoint of the same name instead of adding another, and turning saveViewpoints off leaves the document alone. Set 'units' to the unit your numbers are in (e.g. Meters). Needs a live Navisworks session.
Proximity.Cluster — Groups items into clusters of touching geometry (gap <= tolerance, chained) — turns loose shapes into logical elements, e.g. numbering each ladder. method "bbox" tests bounding boxes (fast); "mesh" confirms every connection with the Clash engine's exact surface clearance (precise, slower). Set propertyName (Advanced) to also stamp every item with its cluster number as a searchable custom property in the tab tabName; without it the node only reads.
Proximity.NearestDistance — For each item, the distance to the NEAREST of the targets (document units), so you can flag items with nothing close by — e.g. openings with no handrail within a distance: compare the result with GreaterThan. Returns +∞ for an item when there are no targets at all. method "bbox" (the default here; Distance.BetweenItems defaults to mesh) = fast, "mesh" = exact surfaces (slower on big sets).
Takeoff.SumPropertyByGroup — One-node QTO rollup: groups items by a property value and sums a numeric property per group (e.g. Volume per Level). Items without the grouping property land in "(none)". keys, sums and counts are three parallel lists; table is the same result as one table (columns: the grouping property, the summed property, Count) that goes straight into Table.ToExcelFile, Table.ToCsvFile, Table.Sort or Report.Html. For sums over several properties use Properties.ToTable and Table.GroupBy.
Zone.AssignByVolumes — Tags each target with the name of the zone volume containing its bounding-box center — the iConstruct Zone Tool as one node. The first zone (in list order) that contains an item wins; items inside no zone are left untouched. Written as a searchable user property tab (persists in NWF/NWD only).

Navisworks.Appearance (14)

Appearance.ColorByValues — One-node color-coding: pairs each item with its value, colors each distinct value (categorical palette, or a blue→red gradient when every value is numeric) and outputs the legend. The colours are permanent overrides, saved with the file; Appearance.ColorByValuesTemporary does the same as a temporary override that Viewpoint.Save can bake into a saved viewpoint.
Appearance.ColorByValuesTemporary — Like Appearance.ColorByValues, but the colours are TEMPORARY (viewpoint-scoped) overrides: nothing is written into the file, Viewpoint.Save with bakeOverrides on keeps them in a saved viewpoint (colour by clash status or by level, one view each), and Appearance.ResetTemporary clears them. Pairs each item with its value, colors each distinct value (categorical palette, or a blue→red gradient when every value is numeric) and outputs the legend.
Appearance.Focus — Focus on some items: they stay as they are and everything else in the model fades by otherTransparency percent (0 = opaque, 100 = invisible) with a TEMPORARY transparency override — the Action.Ghost look in one node, no permanent change. With resetFirst on, every temporary override is cleared first; undo it later with Appearance.ResetTemporary. The scale is percent here; Appearance.OverrideTransparencyTemporary and Action.Ghost take 0 to 1. Touches every item in the model, so allow a moment on large models.
Appearance.Hide — Hides model items in the viewport.
Appearance.Isolate — Shows only these items and hides everything else (undo with Appearance.ShowAll). An empty list does nothing and the node shows a warning: isolating nothing would hide the whole model, and an empty search result is the usual cause.
Appearance.OverrideColor — Overrides the color of model items (a permanent override: saved with the file and undoable).
Appearance.OverrideColorTemporary — Applies a TEMPORARY (viewpoint-scoped) color override — unlike Appearance.OverrideColor (a single global permanent override), a temporary override is what Viewpoint.SaveWithOverrides bakes into each saved view, so every viewpoint keeps its own coloring. Clear with Appearance.ResetTemporary.
Appearance.OverrideTransparency — Overrides the transparency of model items, from 0 (opaque) to 1 (invisible). Appearance.Focus takes percent (0 to 100) instead.
Appearance.OverrideTransparencyTemporary — Applies a TEMPORARY (viewpoint-scoped) transparency override (from 0 = opaque to 1 = invisible; Appearance.Focus takes percent, 0 to 100) — the ghosting that Viewpoint.SaveWithOverrides bakes into each saved view. Fade 'the other' items so the highlighted one stands out. Clear with Appearance.ResetTemporary.
Appearance.Reset — Removes permanent color and transparency overrides from model items, restoring their original materials.
Appearance.ResetAll — Removes every permanent color/transparency override in the model — a clean slate before re-coloring.
Appearance.ResetTemporary — Clears every TEMPORARY color/transparency override in the model — a clean slate before highlighting the next item. Does not touch permanent overrides (Appearance.OverrideColor) or already-saved viewpoints. Wire anything into 'after' to place this INSIDE a loop: without an input the node has nothing to depend on, so it runs once outside the loop body. Per iteration it keeps each saved viewpoint carrying only its own highlighting instead of every earlier iteration's as well.
Appearance.Show — Shows (un-hides) model items in the viewport.
Appearance.ShowAll — Shows (un-hides) every item in the model — undoes Appearance.Hide and Appearance.Isolate.

Navisworks.Camera (9)

Camera.Current — The current camera position, focal distance and vertical field height, read again on every run. To keep the whole camera and put it back later, use Camera.Save and Camera.Restore.
Camera.LookAt — Moves the camera to 'eye' looking at 'target' (up stays +Z). Wire the output of the node that must run before this one into 'after'.
Camera.Restore — Puts a camera back on the current view: the viewpoint kept by Camera.Save, or a saved viewpoint. Only the camera moves; it does not undo hidden items or colour overrides (use Appearance.ShowAll and Appearance.ResetTemporary for those). Wire the last node that moves the camera into 'after' so this one runs at the end.
Camera.Save — Keeps a copy of the current camera inside the graph (nothing is added to the Saved Viewpoints window; for that use Viewpoint.Save). Put it before the nodes that move the camera (Camera.ZoomToItems, SavedViewpoint.Apply, Camera.SetStandardView ...) and wire its viewpoint into Camera.Restore at the end, so the graph leaves the view as it found it. The copy is taken when this node runs: wire what must happen before it into 'after'.
Camera.SetFieldOfView — Sets the camera's vertical field of view in degrees (perspective camera) — smaller = more zoomed/telephoto, larger = wider. Wire the output of the node that must run before this one into 'after'.
Camera.SetProjection — Switches the camera between perspective (true) and orthographic (false) projection. Wire the output of the node that must run before this one into 'after'.
Camera.SetStandardView — Sets the camera to a standard view (top, bottom, front, back, left, right, iso) and frames the given items — or the whole model when none are wired. Convention: Z is up and +Y is north, so top is a plan with north at the top of the screen, front looks north from the south side, left looks east from the west side, and iso looks from the south-east above. Assumes a Z-up model; for others use Camera.LookAt. Wire the output of the node that must run before this one into 'after'.
Camera.ZoomToItems — Frames the given items in the current view (per-item close-ups, screenshot staging). Wire the output of the node that must run before this one into 'after'.
Viewpoint.SetSectionBox — Applies a section box around a region on the current view (Sectioning > Box, scriptable) — chain ModelItem.BoundingBox for the clash-viewpoint close-up look. enabled=false turns sectioning off. It works on Navisworks 2024 only: on 2025 and 2026 the node stops with a message, because the section-box call differs there. It acts on the view like the Camera nodes (hence its place under Camera): set the box first, then save the view with Viewpoint.Save.

Navisworks.Clash.Filter (8)

Clash.Deduplicate — Keeps ONE clash per unique item pair — the same two elements clashing at five points, or mirrored across an A-vs-B and B-vs-A test matrix, count once. Wire the results of ONE test, or of several tests at once (the list of lists from Clash.Tests and ClashTest.Results, or several wires): everything is flattened first, so the pair is recognised across tests and both outputs are flat lists. Pairs are unordered; an element is recognised by its InstanceGuid, or, when the source file has none (DWG, NWC), by the scene node itself, so two sibling elements with the same name are never taken for one. The first result in input order is the representative, the rest come out on duplicates. 400 raw results, 60 real issues.
Clash.FilterByAngle — Keeps only the clash results whose crossing angle (see ClashResult.Angle) is within a degree range — e.g. 80–90 for near-perpendicular crossings, or 0–10 for parallel runs. The angle is always between 0 (parallel) and 90 (perpendicular), so the range stops at 90. Results with no measurable direction are dropped.
Clash.FilterByDepth — Keeps clashes whose penetration depth falls in a range, in the unit you name — minDepth 0.025 with units Meters drops every grazing clash shallower than 25 mm, the #1 noise reducer. Depth is positive for overlaps (hard clashes); clearance-test results carry their gap as a NEGATIVE depth, so a range like -1..0 keeps clearance violations instead.
Clash.FilterByItemProperty — Keeps clashes whose two items' PROPERTY values match a pair of texts, in either order — the semantic clash rule: category "Element", property "Category", value1 "Pipe", value2 "Wall" keeps pipe-vs-wall clashes whichever side the pipe landed on. An empty value matches anything (one-sided rules). Looks up the property on the item and, by default, its ancestors — clash items are often bare geometry while the data lives on the element above. The geometric sibling is Clash.FilterByOrientation.
Clash.FilterByOrientation — Keeps only the clashes between elements of the given box shapes, matched in either order — shape1=run + shape2=wall keeps pipes through walls, run/riser + slab keeps pipes through floors; Clash.FilterByAngle alone cannot tell those apart (both cross at ~90°). Shapes are ClashResult.Orientation's: slab, wall, riser, run, block, or any.
Clash.FilterBySet — Keeps clashes whose items belong to a selection/search set (either one, both, or a specific side) — sets are the coordination scope language: "only my package", "only against the existing building". invert turns it into the classic ignore-list: drop every clash touching the "Accepted penetrations" set. An item counts as in the set when itself OR any ancestor is a member, matching how Navisworks selections include descendants. The set input takes a set, its name, or a list of model items or sets, and a list is read as ONE combined set; to filter once per set, right-click the set socket, choose List Levels and @L1.
Clash.FilterBySnapshot — Turns "what is new since last week" into live clash results you can select, group, assign or report: compares the results with a snapshot saved by Clash.SnapshotToFile, using the same identity as Clash.CompareSnapshots (the test and the pair of items, by InstanceGuid or tree path), and keeps the new ones (not in the snapshot) or the persisting ones (already in it). The other group comes out on others. Clashes that were resolved no longer exist in the model, so they can only be listed by Clash.CompareSnapshots. The same two items clashing at several points are matched one for one, in order.
Clash.FilterByStatus — Keeps only the clash results with the given status(es) — pick one from the dropdown, or wire several comma-separated ("New,Active"; the Clash.Statuses node builds that from toggles). The triage staple: drop the already-Approved ones and work the rest.

Navisworks.Clash.Group (9)

Clash.AllGroups — Every result group of every clash test in the document, as ONE flat list — the whole-project entry point for group workflows: wire it into Loop.Item and let ClashGroup.Info hand each iteration its results, group name and test name. Saves walking Clash.Tests then ClashTest.Groups per test (ClashTest.Groups runs once per test and gives a list of lists). Tests without groups contribute nothing.
Clash.GroupResults — Puts an explicit list of clash results into a named group in Clash Detective — YOUR grouping rule, not a built-in one: filter results any way you like, then group what came out. Results already in other groups are left alone (skipped) unless moveExisting is true, which pulls them into this group. An existing same-named group is extended; re-runs are clean. An empty list (a filter that found nothing) changes nothing and says so; several wires are merged into one list.
Clash.GroupResultsByGridIntersection — Groups a test's results by the model's own grid: each group is named after the nearest grid intersection and level (e.g. "B-3 : Level 2"). Requires a document with grids (Revit/IFC sources). Rebuilds the test's result tree: every group the test already has (also one made by Clash.GroupResults) is dissolved first and a group's own status, assignee and comments are not kept; a bucket with only one result stays ungrouped (a group needs two or more), so a status held by a single result gets no group. Both are reported as warnings.
Clash.GroupResultsByLevel — Groups a test's results by nearest level below each clash point (wire your level names and elevations) — per-floor triage. The elevations are in document units unless units names another unit. Rebuilds the test's result tree: every group the test already has (also one made by Clash.GroupResults) is dissolved first and a group's own status, assignee and comments are not kept; a bucket with only one result stays ungrouped (a group needs two or more), so a status held by a single result gets no group. Both are reported as warnings.
Clash.GroupResultsByProximity — Groups a test's results into clusters whose clash points lie within a radius of the cluster seed — one issue per hotspot. The radius is in document units unless units names another unit. Rebuilds the test's result tree: every group the test already has (also one made by Clash.GroupResults) is dissolved first and a group's own status, assignee and comments are not kept; a bucket with only one result stays ungrouped (a group needs two or more), so a status held by a single result gets no group. Both are reported as warnings.
Clash.GroupResultsBySameItem — Groups a test's results so every clash involving the same element lands in one group (named after the element) — turns thousands of raw clashes into one issue per element. Rebuilds the test's result tree: every group the test already has (also one made by Clash.GroupResults) is dissolved first and a group's own status, assignee and comments are not kept; a bucket with only one result stays ungrouped (a group needs two or more), so a status held by a single result gets no group. Both are reported as warnings.
Clash.GroupResultsByStatus — Groups a test's results by status (New/Active/Reviewed/Approved/Resolved) — one triage bucket per status in Clash Detective. Rebuilds the test's result tree: every group the test already has (also one made by Clash.GroupResults) is dissolved first and a group's own status, assignee and comments are not kept; a bucket with only one result stays ungrouped (a group needs two or more), so a status held by a single result gets no group. Both are reported as warnings.
ClashGroup.ByName — Finds a clash result group by test name + group name and opens it up: the results inside, the group's own status, and the count. The lookup half of group-based triage — feed the results to any filter/report node, or the group to ClashResult.SetStatus/Assign/Rename and SavedItem.AddComment. A list of test names (or tests) with a list of group names runs once per pair, one to one.
ClashGroup.Info — Everything about a clash result group, straight from the group object — the results inside, its name and status, and the TEST it belongs to (object and name). This is what makes whole-project group workflows one flat loop: Clash.Tests to ClashTest.Groups to List.Flatten to Loop.Item to this node, and every iteration knows its results, its group name and its test name without parallel lists. ClashGroup.ByName is the lookup-by-name twin.

Navisworks.Clash.Report (4)

Clash.CompareSnapshots — Diffs two clash snapshots: clashes NEW since the baseline, clashes RESOLVED (disappeared), and clashes PERSISTING in both (with their previous status) — the weekly delta report no plugin does via live API. Pure file IO: needs no open model.
Clash.ResultsTable — Makes a table of the clash results you wire in: one row per result with its test, group, name, GUID, status, distance, assignee, description, creation date, the two items (path and GUID) and the clash point. Wire any filter's output, so "the New clashes deeper than 25 mm" is one row each, ready for the Table nodes, Table.ToCsvFile, Excel.WriteTable or Report.Html. Distance and clash point are in document units unless units names another unit; the creation date is a real date. An empty list gives a table with the headers and no rows.
Clash.SnapshotToFile — Saves a clash-run snapshot (per result: test, item identities, status, distance, clash point) as JSON — one half of the between-runs delta report. Items are identified by InstanceGuid when available, else by their tree path. Leave tests unwired for every test in the document; a wired list means exactly those tests, so an empty list (a filter that found no test) writes a snapshot with no results and says so. A relative file path means next to the graph.
Clash.SummaryTable — Per-test clash counts by status (test × Total/New/Active/Reviewed/Approved/Resolved) — the clash summary matrix. The table output goes straight into the Table nodes, Table.ToCsvFile and Excel.WriteTable; rows and headers are the same data as plain lists. Leave tests unwired for every test in the document; a wired list means exactly those tests, so an empty list (a filter that found no test) gives a table with the headers and no rows, not a report on everything.

Navisworks.Clash.Results (15)

ClashResult.Angle — The angle in degrees (0–90) between the two clashing elements, taken from each element's overall direction (its bounding-box diagonal). ~0° means they run parallel/together, ~90° means they cross perpendicular — so you can filter clashes by crossing angle (e.g. keep only ~90° crossings). Returns NaN when an element has no measurable direction (a point-like box).
ClashResult.Assign — Assigns a clash result, or a whole result group, to a person or trade. A list of results runs the node once per result (lacing), so a list of results and a list of assignees pair up one to one; each result is its own edit. For a long list right-click the result socket, choose List Levels and @L2: the node then gets the whole list and assigns all of it in one step, one undo step. Works on Navisworks 2024 and 2025; on 2026 the node reports that it is not supported yet.
ClashResult.ByGuid — Finds clash results again from their GUIDs — the way back from a BCF topic or a snapshot to the live result: wire the guid output of BCF.ImportIssues and send the results to ClashResult.SetStatus. A GUID that belongs to a result group finds the group (the BCF export writes one topic per result or group). GUIDs may be written with or without braces, in any case. results holds what was found, in the order of the GUIDs; missing holds the GUIDs that matched nothing (not a GUID, or a result that is no longer in the tests you looked in). Leave tests unwired to search every test in the document; a wired list means exactly those tests.
ClashResult.Center — The clash point of a result, in document units.
ClashResult.Documentation — How documented a clash already is — whether it has a saved viewpoint, redline markup, and how many comments. Filter to the reviewed/annotated ones, or find the ones still needing attention (commentCount = 0).
ClashResult.Focus — Focuses the view on clash results the way double-clicking one in Clash Detective does: hides everything else (isolate), zooms the camera to the clashing pair, and optionally selects the elements. Wire one result, or a list to frame a whole group together. Follow with Viewpoint.SaveCurrent to keep the view; Appearance.ShowAll brings the model back. An empty list leaves the view as it is and says so.
ClashResult.Info — Name, status, distance, description, assignee and creation time of a clash result, plus its GUID (what BCF topics and ClashResult.ByGuid use), the name of its test and the name of its group (empty when it is not in a group).
ClashResult.Items — The two model items involved in a clash result.
ClashResult.Orientation — ClashResult.Angle with world context: the crossing angle PLUS each element's bounding-box shape — "slab" (thin horizontal), "wall" (thin upright), "riser" (long vertical), "run" (long horizontal) or "block" — and its slope from horizontal (0–90°). This is what tells a pipe through a wall (run + wall) from a pipe through a floor (run/riser + slab) when the crossing angle alone is 90° in both cases. Box-based: a strongly diagonal linear element can read as planar; "none" means the element has no measurable box.
ClashResult.Rename — Renames a clash result or result group — with lacing and String nodes this is batch renaming ("Clash1" → "Pipe vs Duct L02-B3").
ClashResult.SaveImage — Renders a clash snapshot (scene plus clash highlight) to a .png/.jpg/.bmp file — the picture half of every clash report.
ClashResult.SetDescription — Sets the description text of a clash result, or of a whole result group (context for reports and reviews). A list of results runs the node once per result (lacing), so a list of results and a list of texts pair up one to one. For a long list right-click the result socket, choose List Levels and @L2: the node then gets the whole list and edits all of it in one step, one undo step.
ClashResult.SetStatus — Sets the status of a clash result, or of a whole result group (wire the group from ClashTest.Groups or ClashGroup.ByName) — approve a group in one step. A list of results runs the node once per result (lacing), so a list of results and a list of statuses pair up one to one, e.g. the topic statuses from BCF.ImportIssues; each result is its own edit and its own undo step. For a long list (thousands of results) right-click the result socket, choose List Levels and @L2: the node then gets the whole list and edits all of it in one step, one undo step. Works on Navisworks 2024 and 2025; on 2026 the node reports that it is not supported yet.
ClashResult.Size — The size of the clash overlap region — its bounding-box volume in document units³. Filter out tiny grazing clashes and keep the significant ones. Pair with Units.Convert for readable units.
ClashResult.Viewpoint — The camera viewpoint Navisworks generates for a clash result; optionally applies it to the current view.

Navisworks.Clash.Tests (16)

Clash.RunAllTests — Runs every Clash Detective test in the document — the weekly coordination re-run in one node.
Clash.Status — A clash status as a dropdown (New/Active/Reviewed/Approved/Resolved) — wire it into ClashResult.SetStatus or Clash.FilterByStatus instead of typing the text.
Clash.Statuses — Pick SEVERAL clash statuses with toggles — the multi-select for Clash.FilterByStatus: switch on New and Active to work everything not yet reviewed. Outputs comma-separated text ("New,Active"), which every status input accepts.
Clash.Tests — All Clash Detective tests in a document, including those inside folders.
ClashTest.ByName — Finds a clash test by its display name (searches folders too).
ClashTest.ClearResults — Removes every result (and result group) of a clash test and leaves the test and its settings in place — the clean slate before a re-run. Statuses, assignments and comments on those results are lost.
ClashTest.Create — Creates a clash test between two item selections — script the weekly test matrix instead of clicking it. If a test with that name already exists, ifExists decides: reuse (the default) hands back the existing test untouched, with all its results, statuses, assignments, comments and groups, and says so; update keeps those results and applies the type, tolerance and selections you wired (re-run the test afterwards); replace swaps in a brand-new empty test, so everything triaged on the old one is lost; error stops. A new test goes at the top level, or into the Clash Detective folder named under folder (the folder must exist). The tolerance is in document units unless units names another unit.
ClashTest.Delete — Deletes a clash test and all of its results from the document. Returns false (and changes nothing) when the test is not there, so a clean-up step can run twice. Undoable in Navisworks.
ClashTest.Duplicate — Duplicates a clash test — type, tolerance, rules and both selections — as a new test named "<name> copy" (or newName) in the same folder. The copy starts un-run: its results are cleared, so run it with ClashTest.Run. Errors if a test with that name already exists, so re-runs do not pile up copies — over a list of tests, leave newName empty or give each test its own name.
ClashTest.Edit — Edits an existing clash test in place — name, test type, tolerance, merge-composites and the two selections; every input left at its default ("", "unchanged", -1, unwired) keeps the current value. The tolerance is in document units unless units names another unit. The test's existing results are kept but are stale after a change: re-run it with ClashTest.Run.
ClashTest.Groups — All result groups of a clash test — groups, names, each group's own status and result count, index-aligned. The overview half of group-based triage; ClashGroup.ByName opens a single one. Wire a test, its name, or a list of them: with a list the node runs once per test and every output is one list per test (List.Flatten joins them).
ClashTest.Info — Name, status, type, tolerance, last run time and result count of a clash test. The tolerance is in document units unless units names another unit.
ClashTest.Name — The display name of a clash test — the one-output companion of ClashTest.Info for wiring names into reports, group lookups and file paths.
ClashTest.Rename — Renames a clash test — wire a test or its current name. Batch-rename the whole matrix via lacing: a list of tests (or of names) and a list of new names pair up one to one, one test per name.
ClashTest.Results — The individual results of a clash test (grouped results are flattened).
ClashTest.Run — Runs one clash test now and reports the result count.

Navisworks.Comments (4)

SavedItem.AddComment — Adds a comment to a saved viewpoint, selection/search set, folder, clash result or result group — the Review-tab Comments feature, scriptable; lace over results for review notes in bulk. Every run adds another comment: running the graph twice leaves two identical comments (SavedItem.ClearComments empties the thread first, SavedItem.SetCommentStatus changes the status of one that is already there).
SavedItem.ClearComments — Deletes every comment on a saved viewpoint, selection/search set, folder, clash result or result group (replace-all with an empty thread). Rebuild the thread afterwards with SavedItem.AddComment. A clash test itself has no comment thread here.
SavedItem.Comments — The comment thread on any saved item (viewpoint, set, folder, clash test): bodies, authors, statuses and creation dates, index-aligned.
SavedItem.SetCommentStatus — Changes the status (New, Active, Approved, Resolved) of one comment, or of every comment, on a saved viewpoint, selection/search set, folder, clash result or result group, keeping its text, its author and its place in the thread — close out review comments without clearing the thread. Navisworks cannot edit a comment in place, so a changed comment is replaced by a copy: its date becomes the time of the change. Comments that already have the status are left alone. Wire a list of items to change several threads.

Navisworks.Document (9)

Application.Version — The running Navisworks product name and API version (report headers, compatibility checks).
Document.AppendFiles — Appends design files to the document — Directory.FindFiles → Document.AppendFiles → Document.Save is the Navisworks Batch Utility in three nodes. Takes the whole list of paths (several wires are joined); relative paths mean next to the graph. Cached model items from earlier runs are invalidated.
Document.Current — The active Navisworks document.
Document.Info — File name, title, display units and model count of a document, read again on every run. The units output is the same text as Units.Current.
Document.Merge — Merges another Navisworks file into the document with duplicate resolution — pulls a colleague's review artifacts (sets, viewpoints, comments) into yours. Not a model-diff tool. A list of files merges them one after the other. A relative path means next to the graph. Cached model items from earlier runs are invalidated.
Document.Models — The models (appended source files) loaded in a document, read again on every run.
Document.Open — Opens ONE file into the document, REPLACING its current contents (the headless batch driver). Every model item from before the open is invalidated — re-query items downstream of this node. A list of paths is an error, because each file would replace the one before; to add several files use Document.AppendFiles. A relative path means next to the graph.
Document.Refresh — Refreshes every linked/appended file from disk — Home > Refresh, scriptable. Returns true when anything was updated. Cached model items from earlier runs are invalidated.
Document.Save — Saves the document as .nwf (references to the source files) or .nwd (a published snapshot with the appearance overrides baked in) to the given path; the extension decides. This is the node for publishing an NWD (it replaces Export.NWD). An existing file is replaced. A relative path means next to the graph, and the folder is created when missing. Inside a node group that is used twice, a fixed path is written twice: the second save replaces the first.

Navisworks.Export (12)

BCF.ExportIssues — Exports clash results (or saved viewpoints) as BCF 2.1 issues (.bcfzip: markup, camera viewpoint, component GUIDs, snapshot) — the vendor-neutral bridge into BIMcollab / Konekt / Revizto / ACC. Components use the IFC GlobalId when present, else the InstanceGuid (lossy for non-IFC sources). Cameras are written in meters per the BCF convention. Navisworks numbers clash results per test (Clash1 in every test), so when the results come from more than one test each issue title gets its test in front ("Test - Clash1"), and titles that would still repeat are numbered (2), (3) with a warning.
BCF.ImportIssues — Reads a BCF 2.0/2.1 package: per topic title/status/description/comments/component GUIDs/camera, plus the model items each topic's components resolve to (matched by IFC GlobalId, then InstanceGuid). Optionally applies one topic's camera to the current view — feeds ClashResult.SetStatus and Selection.SetCurrent for the issue-sync return leg.
Export.ClashReport — One-node clash report. A .csv path writes one row per result (test, group, result, status, distance, assignee, description, both item paths and GUIDs, the clash point; Excel-ready). A .html path writes a self-contained page, one section per test, optionally with a snapshot of every result (Advanced: includeImages, imageWidth, imageHeight), shareable as one file. Unwired tests reports every test in the document; an empty list reports none, so a filter that finds nothing gives an empty report instead of a report on everything.
Export.IfcClasses — Lists the friendly IFC class names (Wall, Beam, Door, …) accepted by Export.IfcSetClassMap.
Export.IfcCoordinates — Base-point and georeferencing options for Export.ToIfc: geometry/model/custom origin, rotation and IFC4 georeferencing. eastings, northings and elevation are in metres and are used only when basePoint is Custom.
Export.IfcParameterRule — One property rename/relocate rule for Export.ToIfc — moves/renames a source property into a target IFC Pset/name on export. The search button next to source and sourceCategory lists what the elements selected in Navisworks right now carry.
Export.IfcRoles — Maps Navisworks source properties to IFC roles — Type→IfcElementType, Level→IfcBuildingStorey, Material→IfcMaterial, Classification→IfcClassificationReference — for Export.ToIfc. The search button next to a name lists the tabs and properties of the elements selected in Navisworks right now.
Export.IfcSetClassMap — Assigns an IFC class to every item of the named saved/search sets (set→class), producing the classMap for Export.ToIfc.
Export.IfcSpatialNames — Names for the IFC spatial tree (Project/Site/Building/default Storey) used by Export.ToIfc.
Export.ToCsv — Writes one CSV row per model item with a Name column plus property columns, straight from the model: a quick quantity take-off file. For anything you want to shape first (sort, filter, group, add columns, dates as dates, an Excel workbook) use Properties.ToTable and the Table nodes, then Table.ToCsvFile or Table.ToExcelFile: they share the CSV and Excel options of the rest of the library.
Export.ToIfc — Exports model items to IFC (IFC4/IFC2x3) via the BIMCamel exporter: spatial tree, instancing, property sets, materials, base quantities and georeferencing. The main inputs are the items, the file and the schema and units; the options of the Advanced panel (instancing, property sets, materials, quantities, quality, splitting, validation and the Export.Ifc* option nodes) have sensible defaults. filePath always comes out as ONE text, the first file written; files lists every file (more than one only when splitMegabytes splits the export), so a node after it sees the same kind of value whatever the split.
Export.ViewpointImage — Renders a view to a .png/.jpg/.bmp file via the Navisworks image exporter. Without 'viewpoint' it is the view as it is when the node runs: wire what sets the view into 'after'. Wire saved viewpoints into 'viewpoint' and the node shows each one itself and takes its picture; put {name} in the file path ("C:\Pictures\{name}.png") for one file per viewpoint. That is the batch for a folder: Viewpoints.InFolder into 'viewpoint'. (SavedViewpoint.Apply followed by this node over a list does not work: every Apply runs first, then every picture shows the last view.) The view is left on the last viewpoint shown; Camera.Save and Camera.Restore put it back.

Navisworks.Grids (3)

Grids.ClosestIntersection — The grid intersection and level nearest to any point — ready-made "B-3 : Level 2" location labels for clash naming, reports and zone tagging. Document units. One point per run (a list of three numbers is one point): to label many points, such as the centres of many clashes, right-click the point input, choose List Levels and set L1 (L2 for a list of [x, y, z] lists), and you get one label per point.
Grids.Intersections — All grid intersections of the active grid system, per level — names like "A-1" with positions in document units. The API only answers closest-intersection queries, so intersections are discovered by sampling the model's bounding box and completing the line lattice; raise samples if a very dense grid comes back incomplete.
Grids.Levels — The model's own levels from the active grid system — names and elevations (document units) without hand-typed elevation lists. Grid data comes from source models (e.g. Revit/IFC) and is read-only.

Navisworks.Markup (6)

Markup.AddCloud — EXPERIMENTAL: draws a revision-cloud redline through the given markup-space points (undocumented Navisworks API). Accepts [x,y] pairs or a flat x1,y1,x2,y2,… list. Wire a list of viewpoints and every one gets the cloud (the points input stays one outline).
Markup.AddNumberTag — EXPERIMENTAL: draws a circled number on a saved viewpoint and optionally attaches a comment — a tag substitute (real Find-Tags tags have no public API). Markup-space coordinates; calibrate with Markup.List. Wire a list of viewpoints and every one gets the tag.
Markup.AddShape — EXPERIMENTAL: draws a line, arrow or ellipse redline on a saved viewpoint (undocumented Navisworks API). Markup-space coordinates; calibrate with Markup.List. Wire a list of viewpoints and every one gets the shape.
Markup.AddText — EXPERIMENTAL: draws a text redline on a saved viewpoint (undocumented Navisworks API). Coordinates are markup space — (0,0) is the view centre; calibrate with Markup.List. Wire a list of viewpoints and every one gets the text.
Markup.Clear — EXPERIMENTAL: removes every redline markup from a saved viewpoint (undocumented Navisworks API). Wire a list of viewpoints and every one is cleared.
Markup.List — EXPERIMENTAL: lists the redline markups on a saved viewpoint — types, texts and anchor positions. Draw one markup by hand and read it here to learn the coordinate scale for the Add nodes. Wire a list of viewpoints and you get one result per viewpoint.

Navisworks.Model (5)

Model.Info — The cached and original source file paths of a model, its native units (unit-mismatch audits across appended files) and its root model item — one node for the federated-file inventory.
Model.Remove — Removes a WHOLE appended source model from the document (accepts a Model, a 0-based index, or a file name). Wire a LIST of models, indices or file names to remove several in one go: they are all looked up in the document as it is now and removed from the last to the first, so the indices [0, 1] remove the first two models, not the first and third. No API deletes individual elements — hide them and publish an NWD instead. Returns false when Navisworks refuses a removal. Cached model items from earlier runs are invalidated.
Model.Snapshot — Captures the named properties of the given items as a dictionary keyed by each item's instance GUID (items without one are keyed "path:" plus their tree path) — the input Snapshot.Diff compares, so save one with JSON.WriteToFile now and diff it against a later run to see added, removed and changed items. Nothing in the model is changed.
Model.Statistics — Counts items per model file, class or layer: how many items, how many carry geometry and each group's share of all items. With no items wired it walks every item of the document once, so on a large federated model it takes a while (O(items)); "layer" also reads one property per item. A wired list that is empty, such as a search that found nothing, counts nothing: you get an empty table (headers only) and a warning, never the whole document by accident.
Models.RootItems — The root model items of every model loaded in a document, read again on every run.

Navisworks.ModelItem (15)

ModelItem.AncestorNameMatches — Walks an item's ancestor chain (nearest first) and tests each name against the text: contains / starts with / ends with, or their "doesn't" negations — true when NO ancestor matches. The branch-membership filter: is this item under the "Steel" branch, inside a file starting with "ARCH-", NOT under anything ending in "-DEMO"? Lace over item lists for the bool mask (List.FilterByBoolMask), and the matching ancestor itself comes out too. Names are matched as the tree shows them (class name when unnamed), case-insensitive unless caseSensitive.
ModelItem.AncestorPropertyMatches — The general form of ModelItem.AncestorNameMatches: walks an item's ancestor chain (nearest first) and tests ANY property you name — category + property as the Properties window shows them — against the text: contains / starts with / ends with or their "doesn't" negations (true when NO ancestor matches). "Is this item inside a branch whose Source File contains STEEL?", "under a level whose Name starts with B?" Ancestors without the property simply don't match. Lace over item lists for a List.FilterByBoolMask mask.
ModelItem.Ancestors — The chain of parents of a model item, up to its model root.
ModelItem.BoundingBox — The axis-aligned bounding box of a model item, in document units. Wire a LIST in and lacing gives one box per item — for one box around them all use ModelItem.CombinedBoundingBox. An item with no geometry of its own below it (an empty layer or group) has no box: the result is null and the node shows a warning, so List.Clean drops it and BoundingBox.Center / Size are not fed an empty box.
ModelItem.Children — The direct children of a model item.
ModelItem.CombinedBoundingBox — ONE bounding box fitting all the given items together (per-group when wired a list of groups) — frame a whole cluster for a section box or zoom. For one box per item use ModelItem.BoundingBox.
ModelItem.CommonAncestor — The deepest common ancestor of the given items in the selection tree — the smallest branch (room, level, block, model) that contains them all. Null when they share no ancestor.
ModelItem.Descendants — All descendants of a model item (the whole subtree below it).
ModelItem.IfcGuid — The 22-character IFC GlobalId of an item: the value of its GlobalId / IfcGUID / IFC GUID / Guid property when it has one (as the Navisworks IFC import creates it), otherwise its InstanceGuid encoded the same way; null when it has neither. Wire a list of items to get one id per item.
ModelItem.Info — Everything quick to know about a model item in one node: its display name (the class name when it has none), class name and localized class name (layer/group/geometry detection), instance GUID ("" when absent, a stable cross-run identity for reports), whether it carries geometry and whether it is hidden right now. Use the outputs you need; replaces the single-property nodes ModelItem.DisplayName, ClassInfo, HasGeometry, IsHidden and InstanceGuid. The IFC GlobalId (ModelItem.IfcGuid), the source file (ModelItem.SourceInfo) and the tree path (ModelItem.Path) are separate nodes because they read more.
ModelItem.ModelName — The name of the model/file an item comes from (the root of its selection tree, e.g. "Structure.nwc"). Combine with ClashResult.Items to filter clashes by discipline/source model — e.g. keep only clashes between the MEP model and the Structure model. ModelItem.SourceInfo answers the same question with more detail (the source file name, the item type and the owning model); Model.Statistics labels a model without a name by its file name, this node gives an empty text.
ModelItem.Parent — The parent of a model item (null for a model root).
ModelItem.Path — The selection-tree path of an item as one text, from its model file down to the item ("Structure.nwc > Level 1 > Walls > Basic Wall") — a label for BCF titles, clash names and reports. The same text is the @Path column of Properties.ToTable. ModelItem.Info gives only the item's own name.
ModelItem.ReferencePoints — Candidate base/reference points of an item, in world document units. Navisworks has NO insertion-point API — bboxCenter/bboxMin come from the bounding box; localOrigin is the item's local-frame origin (COM fragment transform), which approximates the source insertion point for many formats (null when unavailable, e.g. non-geometry items or outside a live session). Source properties (Revit "Location" etc.) remain readable via Properties.Value. ModelItem.GetTransform.origin is a third base point: the translation of the item's active transform, which follows ModelItem.Translate and the other transform nodes.
ModelItem.SourceInfo — One-node answer to "which file did this element come from and what is it": the source file name, the Item-tab Type (falling back to the item's class name), and the owning appended model. ModelItem.ModelName is the short form (the model root's name only).

Navisworks.Properties (13)

Properties.AsDictionary — Every property of an item flattened to a "Category.Property" → value dictionary (full data dump).
Properties.Categories — The property category names available on a model item.
Properties.CustomTabs — The user-defined property tabs on an item (discovery/QA before SetCustom or RemoveCustomTab). Built-in source-file categories are not listed — use Properties.Categories for those.
Properties.Discover — Lists every property the given items carry, one row per category and property with how many items have it (Items), how many different values it holds (Distinct, counted up to 10000) and the first few values (Samples) — the answer to "what data does this model actually have?". Reads every property of every item once, so cost grows with items times properties.
Properties.HasProperty — True when the item carries the property — drives model-QA missing-data masks.
Properties.InCategory — All property names and values inside one category of an item. Returns empty lists when the item lacks the category.
Properties.RemoveCustomTab — Removes a user-defined property tab from items. Items without the tab are skipped (see removedCount) — safe for clean re-runs of SetCustom graphs.
Properties.RenameCustomTab — Renames a user-defined property tab in place (same properties, same internal name — search sets targeting the tab stay valid). Items without the tab are skipped.
Properties.SetCustom — Writes ONE set of names and values as a user-defined property tab onto every item you give it — values are searchable, schedulable, and travel with the NWF/NWD (source files are never modified). Each value must be a single text, number, true/false or date: a list in the values is refused with a message, because a property holds one value. For a different row of values per item (a table from Excel) use Properties.SetCustomFromTable. Merge keeps existing same-tab properties; new values win on name collisions. Inside a node group every instance writes the same tab name, so wire the name in from the group's input when instances must not share a tab.
Properties.SetCustomFromTable — Writes a table onto model items as a user-defined property tab, a DIFFERENT row for every item — the spreadsheet-to-model step in one node (Table.FromExcelFile, Table.Join with Properties.ToTable, then this). Each column becomes a property named after its header. Either row 1 goes to item 1, row 2 to item 2 and so on (the counts must match, or nothing is written), or give keyColumn the column that holds each row's GUID and every row finds its item by GUID in one pass (rows that match no item are skipped and listed in missing). Every value must be text, a number, true/false or a date (an empty cell is written as empty text), and all values are checked before the first item is touched. Values are searchable, schedulable, and travel with the NWF/NWD (source files are never modified); merge keeps existing same-tab properties.
Properties.ToTable — Reads the named properties of every item into a table with one row per item and one column per name ("Element.Category", "Item|Layer", a bare property name, or @Name, @Path, @Guid), ready for the Table nodes, Excel or CSV; a property an item lacks is an empty cell. Reads items times names values. Leave properties unwired to read EVERY property the items carry instead, one "Category.Property" column each in the order first met (capped at one million cells; with the Table nodes and Table.ToCsvFile this is the all-properties CSV export). Several wires into properties are joined into one list.
Properties.Value — Reads a property value from a model item, converted to a plain value. Returns null when the property is absent.
Properties.ValueAsString — Reads a property value as text. Returns "" when the property is absent.

Navisworks.Search (2)

Search.ByGuid — Finds the items whose instance GUID equals any of the given GUIDs (text, a 22-character IFC GlobalId, or GUID values) in one pass over the model — not one search per GUID — and lists the GUIDs that matched nothing; walks every item of the document once (O(items)).
Search.ByProperty — Finds every model item by one property, like Find Items with its condition drop-down: equals a value, contains text, matches a wildcard pattern (* and ?), is >, >=, < or <= a number (e.g. pipes with Diameter > 100), or exists (the item carries the property at all, with any value; leave propertyName empty to ask only for the tab). Wire a LIST into value to match ANY of its entries ("is one of") in a single pass over the model; an empty list matches nothing, and List Levels @L1 on value runs one search per entry instead. Wire items into within to look only inside those items and their descendants (a scoped search that refines an earlier result). Replaces Search.HasProperty, Search.HasCategory and Search.InItems.

Navisworks.Selection (9)

Captured Selection — Snapshots the current Navisworks selection and keeps it, so the graph runs on that fixed set even after you select something else (Selection.Current, in contrast, reads the live selection again on every run). Press Capture to (re)store the live selection, Clear to forget it. Each element is stored with its GUID and checked when the graph runs: if the model changed or is another project, the elements are looked up by GUID and any that cannot be found are reported on the node and left out. The capture belongs to the graph file, so use the node outside node groups (every instance of a group would share one set) and capture again for each project.
Selection.AddToCurrent — Adds items to the existing Navisworks selection (union) and returns the result.
Selection.Clear — Clears the interactive Navisworks selection.
Selection.Current — The model items currently selected in Navisworks, read again on every run (press Run after selecting something else and the new selection comes through). The nodes after it run again only when the selection is different from the previous run.
Selection.Invert — The items that are NOT in the current selection (Navisworks' own invert, so whole untouched branches come back as one item each); it does not change the selection — wire it into Selection.SetCurrent to select them. Read again on every run, so it follows the selection as it is now.
Selection.Remove — Takes the given items out of the current Navisworks selection and returns what is still selected; items that are not selected themselves (for example children of a selected parent) are ignored.
Selection.Resolve — Re-selects items at another selection-tree level — File, Layer, FirstObject, LastObject, LastUnique, Geometry — like Navisworks' selection resolution option (Options > Interface > Selection). Level Geometry flattens items to their unique geometry-bearing descendants (the items QTO, colouring and clash selections want; it was ModelItem.GeometryLeaves). Level LastObject walks up from a geometry leaf to the whole object it belongs to, the item you usually want to name, colour or tag (it was ModelItem.ObjectAncestor). The result has no duplicates and keeps the input order; wire a list of groups and lacing gives one resolved list per group.
Selection.SelectAll — Selects everything in the Navisworks UI and returns the selected items.
Selection.SetCurrent — Replaces the interactive Navisworks selection with the given items.

Navisworks.SelectionSets (17)

SelectionSet.ByName — Finds a saved selection or search set by its display name (searches folders too). It only looks: nothing is created or changed. Looks again on every run.
SelectionSet.Create — Creates a saved selection set from the given items, filed in the folder you name (a folder from SelectionSets.CreateFolder, a folder name, or a path such as "Walls/Level 1"; a folder that does not exist yet is created; empty means the top level). An existing set with the same name in the same place is replaced, so re-running a graph updates the set instead of piling up copies. A list of names with a list of item lists makes one set per pair. Inside a node group every instance uses the same name unless you wire it in, so two instances would replace each other's set.
SelectionSet.CreateFromSearch — Creates a live SEARCH set from a property rule, with the same modes as Search.ByProperty (equals, contains, wildcard, >, >=, <, <= or exists; a list in value means any of its entries) — it re-evaluates as the model changes, so "Diameter > 100" or "Name contains DEMO" stays up to date. It is filed in the folder you name (empty means the top level), and an existing set with the same name in the same place is replaced. Inside a node group every instance uses the same name unless you wire it in, so two instances would replace each other's set.
SelectionSet.Delete — Deletes a saved selection or search set by name (searches folders too). Returns false when absent — safe for clean re-runs.
SelectionSet.Duplicate — Duplicates a saved selection or search set in its folder (a search set stays a live search); the copy is named "<name> copy" unless newName is given. Running it again adds another copy.
SelectionSet.Info — What a saved set is: its name, whether it is a fixed "selection" or a live "search" set, how many items it selects right now (a search set is evaluated once to count; turn includeCount off when you only need the name, kind or folder of many sets) and its folder path ("" at the top level). Read again on every run.
SelectionSet.Items — The model items a saved set selects. Search sets are re-evaluated against the model, and the set is read again on every run, so the result follows the set as it is now.
SelectionSet.MoveToFolder — Moves a saved selection or search set into a folder (appended at the end). A set already in the folder is left alone, so re-runs are clean. A list of sets moves each of them; a list of sets with a list of folders pairs them one by one.
SelectionSet.Name — The display name of a saved selection or search set.
SelectionSet.Rename — Renames a saved selection or search set (accepts the set or its current name; searches folders too). Batch-rename by wiring a list of sets and a list of new names: they are paired one by one.
SelectionSets.All — All saved selection and search sets in a document, including those inside folders. Re-reads the Sets window on every run, so a set added or removed since the last run shows up.
SelectionSets.BulkByPropertyValues — One search set per distinct value of a property (e.g. one set per Level) — bulk set generation without the Find Items dialog. A value that is stored as text in one file and as a number in another gets ONE set that finds both. The sets come in value order (numbers by size, so 2 before 10). Existing same-named sets in the target folder are replaced; the folder can be a path such as "By Level/Walls". Reads the property of every item that carries it once.
SelectionSets.CreateFolder — Creates a folder in the Sets window, optionally nested under a parent folder. An existing same-named folder in that location is reused, so re-runs are clean. Inside a node group every instance uses the same name unless you wire it in, so two instances share one folder.
SelectionSets.DeleteFolder — Deletes a Sets window folder. A folder that still holds sets or folders is refused with a message unless deleteContents is on, which deletes everything inside it as well — a run has no single undo, so check the folder first with SelectionSets.InFolder. Returns false when there is no such folder, so a clean-up graph can run again safely.
SelectionSets.InFolder — All saved selection and search sets inside a folder, in Sets window order. Give it a folder object (SelectionSets.CreateFolder / SelectionSet.Info), a folder NAME, or a path like "Walls/Level 1" to pick between same-named folders; leave it empty for the top level. Nested subfolders are included unless recursive is off. A list of folders gives one result per folder (List Levels are not needed). Feeds straight into SelectionSet.Items, SelectionSet.Info or a Loop.Item. Re-reads the Sets window on every run.
SelectionSets.RenameFolder — Renames a Sets window folder (accepts the folder, its current name or a path like "Walls/Level 1"; searches nested folders too). A list of folders with a list of new names renames them pair by pair.
SelectionSets.SortFolder — Sorts a Sets window folder's contents alphabetically by name (A to Z, ignoring case; entries with the same name keep their order) so you never drag sets into order again. Give a folder object, a folder name or a path like "Walls/Level 1"; leave it empty to sort the top level, and turn recursive on to sort the nested folders too. Folders are sorted among the sets by name. A folder that is already in order is not touched, so re-runs are clean.

Navisworks.TimeLiner (11)

TimeLiner.AutoAttachByProperty — For every TimeLiner task (subtasks included), finds all items whose property value equals the task name (or, with matchOn "Display id", the task's display id) and attaches them — the UI's "Auto-Attach Using Rules", scriptable. Replaces each matched task's existing attachment; tasks with no matching items are left untouched and reported in unmatchedTasks. The search buttons next to category and property list what the elements selected in Navisworks right now carry.
TimeLiner.Tasks — All TimeLiner tasks in a document, with subtasks flattened into one list, read again on every run. Each task comes before its subtasks ("parents first"). Navisworks replaces a task's subtasks when the task itself is edited, so when you edit or delete a whole list that holds tasks together with their subtasks (TimelinerTask.SetProgress, SetDates, SetActual, Delete over the list), set order to "children first" in the Advanced panel: the subtasks are then handled before their task and none is already replaced when its turn comes.
TimelinerTask.AttachSet — Attaches a saved selection/search set to a task as a LIVE link (like Attach Set in the UI) — the core 4D-linking automation. Give the set itself, its name, or its folder path and name; a list of tasks and a list of sets link each task to the set at the same position.
TimelinerTask.ByName — Finds a TimeLiner task by its name (subtasks too). When several tasks share the name the first one in the list is used and the node shows a warning; give the path through the parent tasks ("Structure/Level 2") to choose one exactly. Fails when there is no such task.
TimelinerTask.Create — Creates a TimeLiner task with planned dates and optionally attaches model items. Leave parent empty for a top-level task, or give the parent task (TimelinerTask.ByName, or its name or path) to build a schedule hierarchy. A task of the same name under the same parent is updated instead of added again, so running the graph twice does not duplicate the schedule; set onExisting (Advanced) to "add" to always add one or to "error" to stop.
TimelinerTask.Delete — Deletes a TimeLiner task together with its subtasks. Returns false (and changes nothing) when the task is not in the document or was already removed by an earlier delete in the same run, so a clean-up step can run twice and a list holding a task and its subtasks can be deleted whole (set TimeLiner.Tasks to order "children first" for that).
TimelinerTask.Info — Name, id, planned and actual dates, task type and progress of a TimeLiner task, the name of its parent task (empty for a top-level task) and its depth (0 for a top-level task, 1 for a subtask ...).
TimelinerTask.Items — The model items attached to a TimeLiner task. Search and set attachments are re-evaluated.
TimelinerTask.SetActual — Sets a task's ACTUAL start and/or end dates (the planned dates are untouched; use TimelinerTask.SetDates for those) — record what happened on site next to the plan. A date you leave unwired is kept as it is, so "started today, end not known yet" is just the start. With neither date the node changes nothing and shows a warning. Over a list that holds tasks together with their subtasks, set TimeLiner.Tasks to order "children first".
TimelinerTask.SetDates — Updates a task's planned start/end dates in place — bulk schedule edits without a re-import. Over a list that holds tasks together with their subtasks, set TimeLiner.Tasks to order "children first".
TimelinerTask.SetProgress — Sets a task's percent complete (0-100; anything outside is clamped) — update progress from a site report in bulk. Lace over tasks and percentages. Over a list that holds tasks together with their subtasks, set TimeLiner.Tasks to order "children first".

Navisworks.Transform (7)

ModelItem.GetTransform — Reads an item's current (active) transform: origin = its translation (a practical base point), matrix = 16 numbers row-major (feed ModelItem.SetTransform to round-trip), hasOverride = whether a permanent transform override is applied.
ModelItem.MoveTo — Moves model items so the centre of their combined bounding box lands on a target point — place a group by where it should be, not by how far to push it. A permanent override: undoable, saved in the NWF, removed by ModelItem.ResetTransform. Re-running with the same target is a no-op once the items are there. One target per run: a list of targets moves the same items to each in turn and the last one stays (the node warns). Items that sit below another listed item are left out, because moving a container already moves everything under it.
ModelItem.ResetTransform — Removes permanent transform overrides, restoring items to their original position. To reset every override in the whole document, set resetAll to true — an unwired or empty items input alone does nothing (and errors) so an empty upstream filter can never wipe all placement work.
ModelItem.RotateAboutAxis — Rotates model items by an angle (degrees) about an axis through a point. A permanent override: undoable, saved in the NWF, removed by ModelItem.ResetTransform. Re-runs accumulate; in Advanced, switch accumulate off to turn the items exactly this much from where the model had them, so re-running does not pile up. One angle per run: a list of angles against the whole item list turns the same items once per angle and the turns add up ([10, 20] turns them 30 degrees in total, and the node warns). To give every item its own angle, set List Levels L1 on items and on degrees and wire one angle per item. Items that sit below another listed item are left out, because turning a container already turns everything under it.
ModelItem.Scale — Scales model items uniformly about a point — default: the centre of the items' combined bounding box, so the group grows or shrinks in place and keeps its internal layout. A permanent override: undoable, saved in the NWF, removed by ModelItem.ResetTransform. Re-runs accumulate (each run scales again); in Advanced, switch accumulate off to scale from where the model had the items, so re-running does not pile up. One factor per run: a list of factors against the whole item list scales the same items once per factor and the factors multiply ([2, 3] is 6 in total; the node warns). Items that sit below another listed item are left out, because scaling a container already scales everything under it. One override per item, so allow a moment on large selections.
ModelItem.SetTransform — Sets the permanent transform override of model items to an absolute 4×4 matrix (16 numbers, row-major, translation at indices 3/7/11) — mirror-place or scale-in-place for power users. Unlike Translate/RotateAboutAxis this REPLACES any earlier override; re-runs are idempotent. One matrix per run: several matrices against the whole item list would replace each other and only the last stays.
ModelItem.Translate — Moves model items by a vector, in document units (chain Units.Convert for meters/feet). A permanent override: undoable, saved in the NWF, removed by ModelItem.ResetTransform. Re-runs accumulate — each run moves the items again; in Advanced, switch accumulate off to put the items exactly this far from where the model had them, so re-running (or tuning the vector with Auto-run on) does not pile up. One vector per run: to give every item its own vector set List Levels L1 on items and on vector and wire one vector per item; a list of vectors against the whole item list moves the same items once per vector and the moves add up (the node warns). Items that sit below another listed item are left out, because moving a container already moves everything under it. A container has no override of its own to read, so each run on a container starts from where the model had it; use Selection.Resolve with level Geometry first if re-runs should add up.

Navisworks.Units (4)

Units.All — Every unit name accepted by Units.Convert and Units.ScaleFactor.
Units.Convert — Converts a length, an area or a volume from one unit to another (e.g. Feet to Millimeters). Set dimension to Area for square units (square feet to square meters) or Volume for cubic units; the default, Length, converts a length as before.
Units.Current — The display units of a document (all API lengths, areas and volumes use them), read again on every run. The same text is the units output of Document.Info.
Units.ScaleFactor — The multiplier that converts a length, an area or a volume from one unit to another. With dimension Length (the default) it is the factor for lengths; Area gives that factor squared and Volume cubed, which is what quantities such as the areas and volumes from Model.Statistics or takeoffs need (square feet to square meters is the length factor squared).

Navisworks.Viewpoints (15)

SavedViewpoint.Apply — Makes a saved viewpoint the current view (camera, plus any saved overrides). Over a list of viewpoints it applies each in turn, leaving the last one on screen; to take a picture of each use Export.ViewpointImage with the viewpoints wired to its own 'viewpoint' input. Wire the output of the node that must run before this one into 'after'.
SavedViewpoint.ByName — Finds a saved viewpoint by its display name (searches folders too). When several viewpoints share the name the first one in the Saved Viewpoints window is used and the node shows a warning; give the folder path as the name ("Reviews/Week 12/Level 1") to choose one exactly. Read again on every run.
SavedViewpoint.CopyOverrides — Copies the appearance the way one saved view looks — its colour, transparency and hidden-item overrides — onto another saved view, WITHOUT changing that view's camera. Apply one view's highlighting scheme to many others in one graph: a list of target views is handled one view at a time. Both views must have their overrides baked in (Viewpoint.Save with bakeOverrides on).
SavedViewpoint.Delete — Deletes a saved viewpoint: wire the viewpoint itself (so exactly that one goes, whatever its folder), or its name, or its folder path and name ("Reviews/Week 12/Level 1"). A list deletes one viewpoint per entry. A name shared by several viewpoints deletes the first one in the tree and shows a warning. Returns false when there is no such viewpoint, so a clean-up step can run twice.
SavedViewpoint.Duplicate — Duplicates a saved viewpoint in its folder, copying its camera and any baked appearance overrides. Names the copy "<name> copy" unless newName is given. A list of viewpoints makes one copy of each.
SavedViewpoint.Folder — The folder containing a saved viewpoint: its path as "A/B" ("" for top-level viewpoints) and the folder itself — drives folder-based status workflows. A list of viewpoints gives one path and one folder per viewpoint. Read again on every run.
SavedViewpoint.Info — Reads a saved viewpoint: its name, folder path ("A/B", "" at the top level), whether it carries a section box, whether it has baked appearance or visibility overrides, its comment count and its camera — the position and the look-at point (one focal distance ahead of the camera, or one unit when none is stored). hasSection reads nothing on Navisworks 2025 and later (it comes back empty).
SavedViewpoint.MoveToFolder — Moves a saved viewpoint into a folder (appended at the end). A viewpoint already in the folder is left alone, so re-runs are clean. A list of viewpoints moves each one into the folder; a list of folders pairs with the viewpoints one to one.
SavedViewpoint.Name — The display name of a saved viewpoint.
SavedViewpoint.Rename — Renames a saved viewpoint (accepts the viewpoint, its current name or a folder path and name such as "Reviews/Week 12/Level 1"; searches folders too). Batch-rename by wiring a list of viewpoints and a list of new names: each viewpoint gets the new name at the same position.
SavedViewpoint.Update — Re-captures the current view into an existing saved viewpoint — the UI's "Update" — keeping its name, folder and place in the list. Set the camera first (Camera.LookAt, Camera.ZoomToItems, Camera.SetStandardView) and wire the output of the last of those nodes into 'after', because the view is read when this node runs. Compare Viewpoint.Save, which replaces a view by name with a new one.
Viewpoint.Save — Saves the current view as a saved viewpoint in the Saved Viewpoints window. folder files it in a folder (a name, or a path such as "Reviews/Week 12"; folders that do not exist are created); leave it empty for the top level. A viewpoint with the same name in that folder is replaced, so running the graph again updates it instead of piling up. Turn bakeOverrides on to save the temporary colour, transparency and hidden-item overrides (Appearance.OverrideColorTemporary and friends) with the camera, so recalling the viewpoint restores that exact look; off saves the camera only. The view is read when this node runs: set the camera and the overrides first and wire the last of those nodes into 'after'.
Viewpoint.VisibleItems — Checks which of the given items a viewpoint can see (bounding box vs the camera frustum). Feed it a list of items, a selection/search set, a set name or one item; the viewpoint input accepts a saved viewpoint, a viewpoint name, or nothing for the current view, which is read when the node runs (wire the node that sets the camera into 'after'). A list of viewpoints runs the test once per viewpoint. Note: this is a framing test — items behind other objects still count, and the viewpoint's hide overrides are ignored.
Viewpoints.All — All saved viewpoints in a document, including those inside folders. Read again on every run, so a viewpoint added or removed since the last run is seen.
Viewpoints.FromClashResults — Batch-generates one saved viewpoint per clash result, camera aimed at the clash — the clash-triage staple. Existing same-named viewpoints in the folder are replaced. Navisworks numbers results per test (Clash1, Clash2 ... in every test), so when the results come from more than one test each viewpoint is named "Test - Clash1" and none replaces another; nameFormat sets the name yourself ({test}, {name}, {index}). Names that would still repeat are numbered (2), (3) and the node shows a warning.

Navisworks.Viewpoints.Files (2)

Viewpoints.ExportFile — Exports saved viewpoints — camera, section box and folder location — to a portable JSON package for Viewpoints.ImportFile to rebuild in ANOTHER model, even one in different units. Leave viewpoints empty to export them all, or wire specific viewpoints, folders or names. Element overrides are not carried (they only exist relative to the source model's items). A relative file path is next to the graph file; a folder gets a camelgraph-viewpoints.json inside it.
Viewpoints.ImportFile — Rebuilds the viewpoints from a Viewpoints.ExportFile package in THIS model: camera, section box and folder structure. Positions are converted automatically when the source model used different units. Re-runs update same-named views instead of duplicating (overwrite).

Navisworks.Viewpoints.Folders (6)

Viewpoints.CreateFolder — Creates a folder in the Saved Viewpoints window, optionally nested under a parent folder. An existing same-named folder in that location is reused, so re-runs are clean.
Viewpoints.DeleteFolder — Deletes a Saved Viewpoints folder together with every viewpoint and sub-folder in it, or with contentsOnly on empties the folder and keeps it — the clean-up before Viewpoints.FromClashResults fills "Clash Views" again. Accepts the folder, its name or a path such as "Reviews/Week 12". Returns deleted = false when there is no such folder (or it is already empty), so a clean-up step can run twice. A list of folders deletes one folder per entry. This cannot be undone from the graph.
Viewpoints.DuplicateFolder — Duplicates a Saved Viewpoints folder — a new folder (created as a sibling) with copies of every viewpoint and nested sub-folder inside. An existing same-named target folder is reused and topped up: a viewpoint that is already in it under the same name is replaced by the copy, a missing one is added, so re-runs do not pile up. The new name must differ from the source folder's own name. A list of folders and a list of new names duplicate one folder per name.
Viewpoints.InFolder — All saved viewpoints inside a folder, in Saved Viewpoints window order. Give it a folder object (Viewpoints.CreateFolder / SavedViewpoint.Folder), a folder NAME, or a path like "Reviews/Week 12" to pick between same-named folders; leave it empty for the top level. Nested subfolders are included unless recursive is off. A list of folders gives one list of viewpoints per folder. Read again on every run. Feeds straight into SavedViewpoint.Apply, Export.ViewpointImage (wire the viewpoints to its own viewpoint input for a picture of each), Viewpoints.ExportFile or a Loop.Item.
Viewpoints.RenameFolder — Renames a Saved Viewpoints folder (accepts the folder, its current name or a path such as "Reviews/Week 12"; searches nested folders too). A list of folders and a list of new names rename one folder per name.
Viewpoints.SortFolder — Sorts a Saved Viewpoints folder's contents alphabetically by name (A→Z), ignoring case — so you never drag-and-drop views into order again. Pass no folder to sort the top level; set recursive to sort nested folders too. Folders sort among the viewpoints by name. Turn numeric on to put Clash2 before Clash10 (letter by letter, "Clash10" comes first).

Report (2)

Report.Html — Builds a self-contained HTML report from tables and text ("# Heading" makes a heading) — light and dark, printable, ready for Text.WriteToFile or an e-mail. A text section that is the path of an existing image file (.png, .jpg, .gif, .bmp, .webp, .svg; up to 10 MB) becomes the picture itself, embedded in the page; a path that is not found is shown as text with a warning.
Report.Markdown — Builds a Markdown report from tables and text — for Teams, issue trackers and wikis. A text section that is the path of an existing image file (.png, .jpg, .gif, .bmp, .webp, .svg) becomes an image link to that file (the picture is not copied into the text); a path that is not found stays text with a warning.

String (36)

String.Concat — Joins two strings into one. A missing value counts as empty text, also a gap in a list (a column with blank cells keeps every row).
String.Contains — Tests whether a string contains the given substring. Ignores case unless ignoreCase is switched off.
String.EndsWith — Tests whether a string ends with the given suffix. Ignores case unless ignoreCase is switched off.
String.Format — Fills a .NET composite format such as "{0} is {1:0.00} m" with the wired values (invariant culture, "{{" and "}}" are literal braces). It makes one text: all the wired values, and the items of a list wired to 'values', fill {0}, {1}, ... of that one text, and a missing value becomes empty text. For one text per row, wire the rows (a list of lists, for example Table.Rows) to 'values' and set its List Levels to @L2, or use String.Template with Table.ToDictionaries.
String.FromNumber — Formats a number as text with fixed decimals, an optional thousands separator and a prefix/suffix (invariant culture). Formerly called Number.Format; String.ToNumber is the way back.
String.FromObject — Converts any value (including whole lists) to its display string.
String.IndexOf — Returns the zero-based index of the first occurrence of a text (-1 when absent). Ignores case unless ignoreCase is switched off.
String.IsBlank — Tests whether a text is null, empty or only whitespace. With a list it tests every item and a gap in the list counts as blank, so a column of cells gives one true or false per cell.
String.Join — Joins the elements of a list into a single string with a separator. A missing value becomes empty text ("a,,c"), as in String.Concat.
String.LastIndexOf — Returns the zero-based index of the last occurrence of a text (-1 when absent). Ignores case unless ignoreCase is switched off.
String.Left — Returns the first characters of a text (the whole text when the count is larger).
String.Length — Returns the number of characters in a string.
String.Lines — Splits a text into a list of lines (handles \r\n, \n and \r), optionally dropping the empty ones.
String.PadLeft — Pads a text on the left with a character up to a total width ("7" becomes "007" with width 3 and padChar 0).
String.PadRight — Pads a text on the right with a character up to a total width.
String.RegexIsMatch — Tests whether a .NET regular expression matches anywhere in a text (use ^ and $ to match the whole text). Case-sensitive unless ignoreCase is switched on (String.Contains and String.IndexOf ignore case by default).
String.RegexMatch — Finds the first match of a regular expression: whether it was found, the matched text and the capture groups 1..n. Case-sensitive unless ignoreCase is switched on.
String.RegexMatches — Returns the text of every match of a regular expression as a list (empty when nothing matches). Case-sensitive unless ignoreCase is switched on.
String.RegexReplace — Replaces every match of a regular expression; $1, $2, ... in the replacement insert the capture groups. Case-sensitive unless ignoreCase is switched on.
String.RegexSplit — Splits a text into a list of parts wherever a regular expression matches. Case-sensitive; start the pattern with (?i) to ignore case.
String.RemoveDiacritics — Removes accents from letters ("é" becomes "e") so names compare and sort without them.
String.Repeat — Repeats a text a number of times (0 to 10000), optionally with a separator between the copies.
String.Replace — Replaces all occurrences of a substring with another string. Case-sensitive unless ignoreCase is switched on.
String.Reverse — Reverses the characters of a text.
String.Right — Returns the last characters of a text (the whole text when the count is larger).
String.Split — Splits a string into a list of substrings around a separator. Empty parts are kept unless removeEmpty is on; trim removes the spaces around every part ("a, b ,c" with separator "," and trim gives a, b, c).
String.StartsWith — Tests whether a string starts with the given prefix. Ignores case unless ignoreCase is switched off.
String.Substring — Extracts part of a string from a start index (-1 length = to the end). A length that runs past the end gives what is left, like String.Left and String.Right; a start index beyond the end of the text is an error.
String.Template — Replaces {name} placeholders in a text with the values of a dictionary ("{{" and "}}" are literal braces).
String.ToLower — Converts a string to lowercase.
String.ToNumber — Converts a numeric string to a number. By default the whole text must be a plain number with a decimal point ("3.14", "-2", "1.5e3"). Set decimalSeparator to "," for a decimal comma ("1,5"). Switch ignoreUnits on to take the first number out of a text with a unit or a label ("12.5 mm" gives 12.5, "approx. 1,234.5 m" gives 1234.5; thousands separators are read only in this mode). A text without a number still fails; the row shows a warning.
String.ToTitleCase — Capitalises the first letter of every word and lowercases the rest ("bim COORDINATION" becomes "Bim Coordination").
String.ToUpper — Converts a string to uppercase.
String.Trim — Removes whitespace (or the given characters) from both ends of a string. See String.TrimStart and String.TrimEnd for one end only.
String.TrimEnd — Removes whitespace (or the given characters) from the end of a text.
String.TrimStart — Removes whitespace (or the given characters) from the start of a text.

System (7)

Graph.Folder — The folder of the graph file, which is where a relative path in a file node starts (for a graph that was never saved: Documents\CamelGraph; in the Script Player and the command line: the folder of the script). Combine it with a file name using Path.Join to build a path that works wherever the graph and its files are moved together.
System.Environment — Reports the Windows user, computer name, operating system and the current, temp, Documents and AppData folders. currentDirectory is the folder of the running program (for Navisworks its install folder), not the folder of the graph: use Graph.Folder for that.
System.OpenPath — Opens a file or folder with its default application, or shows it selected in Explorer when reveal is true. A relative path starts in the graph's folder.
System.Run — Runs a program with arguments, waits for it (stopped after Advanced > timeoutSeconds, 60 by default) and returns its exit code, output and error text. A bare program name is searched on the PATH; a path with folders that is not a full path starts in the graph's folder. Advanced > workingDirectory chooses the folder it runs in. In a loop, wire the loop item (or something made from it) into arguments: a node with only fixed inputs belongs to no loop and runs once.
Web.Download — Downloads a file (IFC, BCF, zip, picture, anything) from an http(s) address and saves it byte for byte; missing folders are created and an existing file is only replaced when overwrite is true. The file is received beside the target and put in place when complete, so a failed or too slow download leaves nothing half-written. An error status such as 404 is returned (ok = false, path empty) and writes nothing; a network failure or timeout is an error. A relative path starts in the graph's folder.
Web.Get — Downloads text from an http(s) address with GET; an error status such as 404 is returned (ok = false), only a network failure or timeout is an error. The body is decoded as text, so use Web.Download for files such as IFC, zip or pictures.
Web.Post — Sends data to an http(s) address with POST (JSON by default, e.g. a Teams or Slack web hook); an error status is returned (ok = false), only a network failure or timeout is an error.

Table (28)

Table.AddColumn — Adds a column at the end: a list with one value per row, or a single value repeated on every row.
Table.AddFormulaColumn — Adds a column calculated per row from the others, e.g. "Width * Height * Length / 1000000000" (same formula language as Math.Formula; [Names with spaces] in brackets). A blank or text cell is never counted as 0: a row where a column the formula uses is blank or not a number gets an empty cell, and so does a result that is not a finite number (a division by zero). The node turns amber and says how many rows were left empty.
Table.Column — The cells of one column, top to bottom — wire it into List.Sum, List.CountValues, Search or a property writer.
Table.Concat — Stacks tables one below the other, matching columns by name; a column one table lacks is left empty — weekly snapshots, one table per model.
Table.Distinct — Keeps only the first row for each distinct value of the given columns (a list of names or one text with commas), or of the whole row when none are given.
Table.Filter — Splits a table by a test on one column — Level == "L02", Length > 3000, Name matches "W-*", Level in "L01, L02" — into the rows that pass and the rows that do not. A blank cell never passes > >= < <=, and neither does text that is not a number when you compare with a number (the node turns amber and counts them); they land in the rejected table. in and notIn take a list of values, or one text with the values separated by commas; an empty cell is in no list. Regex tests are case sensitive unless ignoreCase is ticked.
Table.FromColumns — Makes a table from columns: a list of lists, one per column, with optional names — for results that come as parallel lists.
Table.FromCsvFile — Reads a CSV file straight into a table (numbers become numbers, everything else stays text). The delimiter is a comma, a semicolon (European Excel), a bar or a tab.
Table.FromDictionaries — Makes a table from a list of dictionaries (one row each); the columns are all their keys — property bags become rows.
Table.FromExcelFile — Reads an Excel worksheet straight into a table. Dates arrive as Excel serial numbers; DateTime.FromExcelSerial turns one into a date.
Table.FromRows — Makes a table from rows of cells and column names (or from the first row) — the doorway from Excel, CSV and list data.
Table.GroupBy — Groups rows by one or more columns (a list of names or one text with commas) and works out count, sum, average, min, max, median, first, last, list or distinct per group — "sum:Volume", "count" — the pivot-table core for quantities. Blank cells are skipped by sum, average and median; text in a number column is an error that names it.
Table.Info — How many rows and columns a table has, and its column names (the headers output is the list of names, in column order).
Table.Join — Joins two tables on one or more key columns (inner, left or outer) — add the Excel columns to the model data by GUID or mark. Keys match as text, so 42 and "42" are the same, and a key that looks like a GUID matches whatever its capitals and small letters (other text keys must match exactly). An empty key never matches anything, not even another empty key. leftKey and rightKey take one column name, several separated by commas (or a list) to join on Level and Mark together; leave rightKey empty when both tables use the same names. Table.Unmatched lists the left rows that found no partner (it replaces Table.JoinByKey's unmatchedKeys).
Table.Pivot — Cross-tabulates: rows from one column, columns from another, each cell the sum (or count, average …) of a third — clashes by level and status.
Table.RemoveColumns — Drops the listed columns and keeps the rest. Names come as a list or as one text separated by commas; a column whose name has a comma in it ("Area, gross") is found by its whole name. An empty list removes nothing and says so.
Table.RenameColumn — Renames one column.
Table.Row — One row of a table as a dictionary from column name to cell (0 is the first row; -1 the last).
Table.Rows — The rows of a table as a list of lists of cells (for Excel.WriteToFile, CSV.WriteToFile and the List nodes).
Table.SelectColumns — Keeps only the listed columns, in that order. Names come as a list or as one text separated by commas; a column whose name has a comma in it ("Area, gross") is found by its whole name. At least one name is needed.
Table.SetColumn — Replaces the cells of a column in place, keeping its position and name, or adds the column at the end when there is none of that name. Give a list with one value per row, or a single value repeated on every row — take a column out with Table.Column, clean it with String or List nodes, and put it back here.
Table.Slice — Takes count rows from a starting row (count -1 takes all the rest) — the first 10 rows: start 0, count 10.
Table.Sort — Sorts the rows by one or more columns, as a list of names or one text ("Level, -Length" sorts by level, then longest first); numbers numerically, text alphabetically, empty cells last. A list of names sorts once by all of them, in that order.
Table.ToCsvFile — Writes one table, with its column names, to a CSV file; a file that is already there is replaced. The delimiter is a comma, a semicolon, a bar or a tab. A list of tables is an error (they would overwrite each other): stack them with Table.Concat first.
Table.ToDictionaries — The rows of a table as dictionaries (column name to cell) — for JSON.WriteToFile or per-row lookups.
Table.ToExcelFile — Writes one table, with its column names, to an Excel worksheet. With append ticked the sheet is added to the workbook that is already there; without it the whole file is replaced, other sheets included. For several sheets in one workbook use one node per table, each with its own sheet name and append ticked, and wire the path of one into the next so they run in order. A list of tables is an error (they would overwrite each other).
Table.ToText — Renders a table as Markdown, CSV, tab-separated or an HTML table — for a report, an e-mail or a log.
Table.Unmatched — The rows of the left table that find no partner in the right table, using the same keys and the same matching as Table.Join (GUIDs match whatever their case, a blank key never matches) — which model elements have no row in the Excel list, which GUIDs were not found.

Utility (1)

Reroute — A wire waypoint that passes its value through unchanged.

Workflow (8)

Flow.Require — Stops with your own error message when a condition is false; when it is true the value passes through unchanged. The nodes wired after it do not run after a false condition, so put it in front of a step that must not run on bad input (replacing the open model, deleting files). Flow.When only skips quietly and Flow.Try only catches. To require that every item of a list passes, wire List.AllTrue into 'condition'.
Flow.Then — Passes a value through unchanged AFTER the wired 'after' nodes have run — makes the execution order of side-effect nodes explicit (e.g. set a section box, THEN save the viewpoint). 'after' takes as many wires as you like, one per node that must run first; what they carry is ignored.
Flow.Try — Carries on after a failure: gives the node's result, or your fallback plus the error text when that node failed — nothing after it turns red.
Flow.Wait — Waits the given number of seconds (at most 600; nothing can stop the wait early, so Navisworks looks frozen meanwhile), then passes the value through unchanged - use it to pause between steps of a workflow. In a loop, wire the loop item (or something made from it) into value: a Flow.Wait with only fixed inputs belongs to no loop and waits once.
Flow.When — Runs the nodes wired after it only when the condition is true; when false they are skipped (idle, not an error) — e.g. export only if there are clashes.
Loop.Collect — Closes a loop and collects one value per iteration. Wire Loop.Item's 'loop' output into 'loop' and the per-item value into 'value'; 'results' is the list of collected values, available after the loop. Downstream of 'results' runs once. An iteration that a Flow.When switched off adds nothing to 'results'. When some iterations fail, their place in 'results' is empty and this node shows a warning that counts them and names the first failure.
Loop.Item — Yields the current item of a loop. Wire a list into 'items', wire 'item' into the nodes that should run per item, and wire 'loop' into a Loop.Collect to close the loop. The engine runs everything between here and Loop.Collect once per item, in order. If the list comes from a node that failed, or from a Flow.When that is false, the loop does not run and the nodes after it wait, like after any failed or switched-off node. Use a loop when the work per item is built from ordinary nodes; use Workflow.ForEach with Action.* nodes when it is a fixed list of steps such as isolate, zoom, save viewpoint.
Workflow.ForEach — Runs a sequence of actions on each item, one item fully before the next (zoom, isolate, save viewpoint, then the next item), the per-item ordered loop that wiring and lacing cannot express. Wire the items and the Action.* nodes into 'actions' (several wires run in the order they were made; a List.Create of them works too). 'results' has one entry per item: what its actions collected (one value as it is, several as a list, the item itself if the actions collect nothing), or empty when that item failed. By default a failing item is skipped and the node ends amber with one line that names the items and actions that failed; set onError to stop to end with an error at the first failure instead (what was already done stays done). Press Stop to end it between two actions. Use this node for a fixed, readable list of actions with {name} and {index1} naming (one viewpoint per item); use Loop.Item and Loop.Collect when the work per item is built from ordinary nodes.

Workflow.Actions (9)

Action.Ghost — Per item: applies a TEMPORARY transparency to the given items (wire the whole found set) so the highlighted item reads against a faded context. Captured per viewpoint. Put before Action.Highlight; reset each item with Action.ResetTemporaryAppearance.
Action.Highlight — Per item: applies a TEMPORARY color to the current item so it stands out — captured per viewpoint by Action.SaveViewpoint, so each view keeps its own highlight. Pair with Action.Ghost to fade the rest.
Action.Isolate — Per item: shows the current item and hides everything else (Appearance.Isolate). Place before Save Viewpoint to bake the isolation into each view.
Action.OverrideColor — Per item: overrides the current item's color (Appearance.OverrideColor).
Action.ResetAppearance — Per item: removes color and transparency overrides from the current item (Appearance.Reset).
Action.ResetTemporaryAppearance — Per item: clears all TEMPORARY color/transparency overrides (Appearance.ResetTemporary) — put first in the sequence so the previous item's highlight/ghost doesn't linger into this view.
Action.SaveViewpoint — Per item: saves the current view as a saved viewpoint named from the item. The name is a template: {name} (or {item}) is the item's name, {index} its position from 0, {index1} (or {n}) its position from 1 and {count} the number of items, so 'View {index1} of {count}: {name}' numbers the views; an empty name uses the item's name, and a viewpoint with the same name in the same folder is replaced. With bakeOverrides on, the current isolation AND temporary color/transparency are stored in the view, so recalling it restores that exact look. Collected as the loop's per-item result.
Action.ShowAll — Per item: un-hides every item in the model (Appearance.ShowAll) — a reset step, e.g. before re-isolating.
Action.ZoomTo — Per item: frames the current item in the view (Camera.ZoomToItems). Place before Save Viewpoint so each view is centred on its item.