What is the Script Explainer?

Your team has working Dynamo graphs and Python scripts that are hard to modify because the logic inside them isn't documented. This tool reads each script and produces a plain-language explanation:

• What it does — A clear description anyone on the team can understand, without needing to read the code
• Inputs — Which Revit categories, parameters, and family names the script expects to find in your model
• Outputs — What the script writes back to Revit and whether those changes are reversible
• Risks — Any operations that could affect large numbers of elements or make irreversible changes
• Dependencies — Whether the script needs third-party Dynamo packages (Clockwork, Archi-lab, etc.)
• Registry candidate — Whether the script is safe enough to register as a trusted building block for the Automation Builder

How to use: Upload your .dyn or .py files below, then click Explain on any script — or use Explain All Scripts to process your entire library at once. Once explained, click a script row to see its full analysis. Explained scripts are also listed in the Script Registry at the bottom of this page — your team's permanent knowledge base of documented scripts.

Scripts that have been explained are saved here. This is your team's knowledge base of documented scripts.

These scripts are hidden from the main list. Click Unarchive to bring them back.

How does the Automation Builder work?

This is a two-step process that keeps you in control at every stage:

• Step 1 — Generate Plan: Describe what you want in plain English. The AI interprets your request using your Revit Settings and produces a step-by-step automation plan. If anything is unclear, it asks clarifying questions instead of guessing.
• Step 2 — Assemble .dyn: Once you approve the plan, the system assembles a Dynamo graph from pre-validated, reviewed building blocks. It never invents node structures — only uses trusted scripts from the registry.

Every generated graph is validated before you can download it. The system checks for missing parameters, bulk write operations, and anything that could affect your model unexpectedly. You always see a dry-run summary before running anything in Revit.

Your Request

Automation Plan

Clarification Needed

Generated Graph

What is Keynote Sync?

Your office maintains keynotes and specifications in an Excel file. This tool maps those Excel columns to Revit parameter names and produces a sync payload that updates your Revit model — no manual re-entry.

• Column Mapping — Your Excel column names (e.g. Spec_Code) are mapped to Revit parameters (e.g. Keynote) via Revit Settings
• Dry Run — Always preview what will change before committing. See exactly which parameters will be set and on how many elements
• Commit — Once you've reviewed the preview, commit the changes. The operation is logged with a timestamp
• Validation — The system checks that all mapped parameters actually exist in your Revit Settings before allowing a commit

To change how columns map to parameters, update the keynoteMapping in Revit Settings.

Keynote Data

Paste JSON array of keynote objects. Use your Excel column names as keys.

Sync Result

Sync History

What it checks

The audit scans every family loaded in your Revit project and flags common issues that slow down your model, cause errors, or make maintenance harder:

• Imported CAD/DWG — Hidden geometry from imported files that bloats family size
• Too many parameters — Families with excessive parameters that slow down schedules and editing
• Wrong category — Families placed in Generic Models that should be in a specific category
• Excessive nesting — Too many nested families inside one family, impacting performance
• Type catalog needed — Families with many types that should use an external type catalog
• Too many materials — Embedded materials that should be project-based instead

How to run the audit

Want to test without Revit? Load sample audit data to see how the dashboard looks.

Previous Audits

Describe your export

Tell the system what you need in plain language. It will configure the export settings for you.

Output Purpose

What is this export for? This determines the recommended formats, quality, and naming.

Export Formats

Recommended formats are pre-selected based on your purpose. Toggle to add or remove.

File Naming

Export Preview

What is the Plugin Builder?

This is where you turn your reviewed Dynamo scripts into a proper Revit plugin — a custom "Arrow" tab in the Revit ribbon, just like DiRoots or other commercial plugins. Your team installs it once and uses your scripts without ever opening Dynamo.

• Select scripts — Choose which reviewed scripts from your registry to include in the plugin
• Organize by category — Group scripts into ribbon panels (Organisation, Keynotes, Sheets, Modeling, etc.)
• Set labels & tooltips — Give each button a clear name and description
• Generate manifest — Export a plugin manifest that the Revit add-in reads to build the ribbon
• Distribute — Share the plugin as an installer (.msi) that anyone can install

Plugin Configuration

Only promoted scripts (Production Ready) appear here. Review and promote scripts in the Script Explainer first.

Publishing Presets

Saved publishing presets appear as buttons in the ribbon. Create presets in the Publishing tab.

Ribbon Preview

This is how your plugin will appear in the Revit ribbon.

Invite a team member

New members must use your company email domain. Generic emails (Gmail, Yahoo, etc.) are not accepted.

Revit Versions

Simulate a device check-in

Test the deployment tracking by simulating a Revit plugin heartbeat.

What are Revit Settings?

The Automation Builder and Keynote Sync use these settings to understand your Revit projects. When you type a request like "Set the fire rating on all interior walls", the AI looks up the exact parameter name (Fire_Rating) and category (Walls) from here instead of guessing.

These settings help the AI interpret your requests. They don't affect your Dynamo scripts directly.

Do I need this?

Only if you're using the Automation Builder (plain language → Dynamo scripts) or Keynote Sync (Excel → Revit parameters). If you're only using the Script Explainer and Plugin Builder, you can skip this.

How to set up

Choose one of three options:

import clr, json
clr.AddReference('RevitAPI')
clr.AddReference('RevitServices')
from Autodesk.Revit.DB import *
from RevitServices.Persistence import DocumentManager

OUTPUT_PATH = r"C:\Temp\office-profile-export.json"
doc = DocumentManager.Instance.CurrentDBDocument

categories = [{"name": cat.Name, "builtInCategory": str(cat.Id.IntegerValue)}
  for cat in doc.Settings.Categories
  if cat.CategoryType == CategoryType.Model and cat.AllowsBoundParameters]

parameters = []
it = doc.ParameterBindings.ForwardIterator()
while it.MoveNext():
  parameters.append({"name": it.Key.Name, "type": "text",
    "isShared": hasattr(it.Key, 'GUID'), "group": "Custom"})

families = sorted(set(f.Name for f in FilteredElementCollector(doc).OfClass(Family) if f.Name))
title_blocks = sorted(set(Element.Name.GetValue(t) for t in
  FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_TitleBlocks).WhereElementIsElementType()
  if Element.Name.GetValue(t)))
view_templates = sorted(v.Name for v in FilteredElementCollector(doc).OfClass(View) if v.IsTemplate)
levels = [{"name": l.Name, "elevation": round(l.Elevation * 0.3048, 3)}
  for l in FilteredElementCollector(doc).OfClass(Level)]

export = {
  "projectInfo": {"name": doc.ProjectInformation.Name},
  "categories": categories, "parameters": parameters,
  "families": families, "titleBlocks": title_blocks,
  "viewTemplates": view_templates, "levels": sorted(levels, key=lambda x: x["elevation"]),
  "namingRules": {"sheets": "", "views": "", "families": "", "levels": ""}
}

with open(OUTPUT_PATH, 'w') as f:
  json.dump(export, f, indent=2)

OUT = "Saved to " + OUTPUT_PATH

Upload settings file

Upload the JSON file created by the export script above.

Don't have a Revit project handy? Load demo data to see how it works.

Current Settings