NodeList Pro

What it does

NodeList Pro answers a simple but tedious question: "What Blueprint nodes does this plugin actually expose?" It reflects over everything the engine has loaded and builds a plugin → class → member tree of every Blueprint-facing API surface:

• BlueprintCallable and BlueprintPure functions
• BlueprintImplementableEvent / BlueprintNativeEvent events
• Async (latent) nodes derived from UBlueprintAsyncActionBase
• BlueprintAssignable multicast delegates (event dispatchers)
• BlueprintVisible properties (variables), with read-only / read-write status
• BlueprintType structs and enums

For each entry it shows the C++ signature/type, the node's Category metadata, and its tooltip (the in-editor comment). The whole list is searchable and can be exported to Markdown or materialized into a catalog Blueprint.

Opening the panel

Main menu → Tools → "Blueprint Node List"

The tab is registered as a nomad tab in the editor's Tools workspace category, so you can dock it anywhere. Its tab icon is the Kismet palette icon.

The editor UI

The panel is split into three stacked regions: a header bar, a toolbar, and the results tree.

┌──────────────────────────────────────────────────────────────────────┐
│ ▍ NodeList Pro                              12 plugins • 84 types •     │  ← Header bar
│   Blueprint node explorer                   631 Blueprint nodes        │
├──────────────────────────────────────────────────────────────────────┤
│ Plugin [ MyPlugin ▾ ] │ 🔍 Filter…        │ ☐ Engine plugins          │  ← Toolbar
│ ☐ Screenshot boxes │ [Refresh] [Export Markdown] [Place in Blueprint]  │
├──────────────────────────────────────────────────────────────────────┤
│ [icon] MyPlugin  v1.0.0   3 types, 47 nodes                            │  ← Results tree
│   └ class  UMyLibrary   12 nodes                                       │
│       ├ FN     DoTheThing   void DoTheThing(int32 Count)  [Utilities]  │
│       ├ PURE   GetValue     float GetValue() const        [Utilities]  │
│       └ VAR    bEnabled     [read/write] bool             [Config]     │
└──────────────────────────────────────────────────────────────────────┘

1. Header bar

A dark branded band across the top:

2. Toolbar

A grouped control bar, separated into logical sections by vertical dividers:

3. Results tree

A three-level tree: Plugin → Class (or Struct/Enum) → Member. Each row shows, left to right:

1. Plugin icon (plugin rows only)
2. Kind badge — a colored pill identifying the node type
3. Name — plugin rows show the descriptor's friendly name in bold white
4. Version pill (plugin rows only) — green v1.0.0
5. Detail — node count for groups; C++ signature/type for members
6. Category — the [Category] metadata, when present

Plugin and class rows are tinted as section headers; plugin rows get the brand accent and extra padding. Hovering any row shows a tooltip with its name and full tooltip text.

Node kinds & badges

Plugin icon & version

Plugin rows display metadata read from the plugin's .uplugin descriptor:

• Icon — loaded from the plugin's Resources/Icon128.png (if present) at 18×18. Plugins without an icon simply show none.
• Friendly name — the descriptor's FriendlyName is used when set, otherwise the plugin's code name.
• Version — the descriptor's VersionName, shown as a green v… pill.

Icons are loaded from disk once and cached for the panel's lifetime.

Export to Markdown

Export Markdown writes the currently visible (filtered) list to:

<Project>/Saved/NodeListPro/<Scope>_BlueprintNodes.md

where <Scope> is the selected plugin's name, or AllPlugins. A success notification appears with an Open folder hyperlink. The Markdown groups by plugin (with version and counts), then by class, then lists each node with its kind, signature, category, and tooltip — ready to paste into a wiki or README.

Place in Blueprint

For a selected plugin, Place in Blueprint creates a new catalog Blueprint under /Game/NodeListPro/ and spawns every node of that plugin into its Event Graph, grouped per category inside comment boxes. You're shown a confirmation dialog with the node count first.

• Your own Blueprints are never modified — a fresh asset is always created.
• With Screenshot boxes enabled, a PNG of each comment box is saved under Saved/NodeListPro/Screenshots/<AssetName>/.

This is handy for producing visual node galleries / documentation of a plugin's API.

How it works under the hood

1. Plugin enumeration. FNodeListProCollector::Collect() walks IPluginManager::Get().GetDiscoveredPlugins(), keeping enabled plugins (and engine plugins only when the checkbox is on). For each it records a module→plugin map and captures descriptor metadata (VersionName, FriendlyName, and the Resources/Icon128.png path).
2. Reflection sweep. It iterates all loaded UClass, UScriptStruct, and UEnum objects, skips transient/trash reflection objects (SKEL_, REINST_, TRASHCLASS_, …), and maps each to its owning plugin via its /Script/<Module> package name.
3. Member extraction. For each owned class it collects functions and properties declared on that class (not inherited), classifies each into a kind, and builds a readable C++ signature.
4. Assembly. Items are grouped into a Plugin → Class → Member tree, sorted by kind then name, annotated with counts, and metadata is attached to plugin roots.
5. Filtering. The Slate panel clones a filtered copy of the tree on every search/scope change (CloneFiltered) and feeds it to an STreeView. The original full tree is preserved for Place in Blueprint, which always uses the unfiltered set.

Tips & troubleshooting

File map