Graphify: AI-Ready Graphs

Graphify is the format that makes GraphScribe special. It produces a knowledge graph with stable links between Blueprints and functions across your entire project.

The problem with the other formats

Markdown, Mermaid, and JSON each describe one asset at a time. If you have 50 Blueprints that call each other, you have 50 files, and nothing connects them.

A .uasset is binary and AI can’t read it at all.
A pile of Markdown files is readable, but AI has to guess which Blueprints reference which. There are no actual links.

What Graphify gives you

Every .graphify.json export contains:

Stable IDs for every asset, function, event, and class:
- bp:/GraphScribe/Examples/BP_BaseTest.BP_BaseTest a Blueprint or DataAsset,
- fn:/GraphScribe/Examples/BP_BaseTest.BP_BaseTest::Base_Function_1 a function inside an asset,
- evt:/GraphScribe/Examples/BP_BaseTest.BP_BaseTest::BeginPlay a native engine event (schema v2 makes events first-class callables, the raw engine function is kept in nativeFunction),
- cls:/Script/Engine.Actor a class reference,
- plus per-asset local structure nodes: var_<Name> (variable rows), widget_N (widget-tree rows), comp_<Name> (component groups), graph_<Name> (graph containers), and anim_N (widget animations).
Edges that connect them:
- calls this callable calls that callable (function or event, including cross-asset calls and super-calls like a child’s BeginPlay calling the parent’s),
- defines this asset defines that function, variable, or animation,
- uses this asset references that class,
- contains per-asset local structure (widget tree / variable / graph nesting). The merge step keeps only the cross-asset calls / defines / uses relations.

These IDs are derived from the asset’s path, not from random node GUIDs, so they stay the same across re-exports. A consumer can remember an ID today and look it up again tomorrow.

A complete real per-asset export (example content shipped with the plugin, DA_Test.graphify.json):

{
  "schemaVersion": 2,
  "generator": "GraphScribe",
  "generatorVersion": "1.1.0",
  "dumpMode": "modifiedOnly",
  "nodes": [
    {
      "id": "bp:/GraphScribe/Examples/DA_Test.DA_Test",
      "label": "DA_Test : PDA_BaseAsset_C",
      "file_type": "code",
      "source_file": "/GraphScribe/Examples/DA_Test.DA_Test"
    },
    {
      "id": "var_Base_Bool",
      "label": "Base_Bool (bool) = True",
      "file_type": "code",
      "source_file": "/GraphScribe/Examples/DA_Test.DA_Test",
      "source_location": "Variables",
      "origin": "reflected",
      "hasChildren": false,
      "category": "Default",
      "declaringClass": "PDA_BaseAsset"
    },
    {
      "id": "cls:/GraphScribe/Examples/Data/PDA_BaseAsset.PDA_BaseAsset_C",
      "label": "PDA_BaseAsset_C @ NativeClass",
      "file_type": "code",
      "source_file": "/GraphScribe/Examples/DA_Test.DA_Test",
      "source_location": "ClassRefHard"
    }
  ],
  "edges": [
    {
      "source": "bp:/GraphScribe/Examples/DA_Test.DA_Test",
      "target": "var_Base_Bool",
      "relation": "defines",
      "confidence": "EXTRACTED",
      "source_file": "/GraphScribe/Examples/DA_Test.DA_Test"
    },
    {
      "source": "bp:/GraphScribe/Examples/DA_Test.DA_Test",
      "target": "cls:/GraphScribe/Examples/Data/PDA_BaseAsset.PDA_BaseAsset_C",
      "relation": "uses",
      "confidence": "EXTRACTED",
      "source_file": "/GraphScribe/Examples/DA_Test.DA_Test"
    }
  ],
  "diagnostics": []
}

(Two more var_ nodes and their defines edges condensed out of this listing.)

The dumpMode field tells consumers which property dump mode produced the variable/class-ref content, full, modifiedOnly, or blueprintOnly.

The project-wide graph

When you run a folder batch export with Graphify, GraphScribe merges every per-asset export into one file at the root of the output directory:

ProjectLinkage.graphify.json

The merge re-reads every *.graphify.json already under the output directory (not just the latest batch), so folder-by-folder exports accumulate into one project graph instead of overwriting each other. It deduplicates stable nodes and identical source|relation|target edges, and drops edges whose endpoints aren’t stable IDs.

This single file is a map of how your whole project’s Blueprints connect.

A Graphify batch export also writes Graphify/graphify-out/graph.json a thin, lossless wrapper around ProjectLinkage.graphify.json in the shape the graphify CLI reads, so no converter step is needed to cluster the graph and render the interactive graph.html viewer.

Native events are callables

Since schema v2, native engine events are first-class nodes with their display name as the id (Receive-prefixed events drop the prefix: ReceiveBeginPlay → BeginPlay, ReceiveTick → Tick):

{
  "id": "evt:/GraphScribe/Examples/BP_BaseTest.BP_BaseTest::BeginPlay",
  "label": "BeginPlay",
  "file_type": "code",
  "source_file": "/GraphScribe/Examples/BP_BaseTest.BP_BaseTest",
  "source_location": "EventGraph",
  "kind": "event",
  "nativeFunction": "ReceiveBeginPlay"
}

Events join the same calls graph as functions, so what-runs-on-<event> is explicit, including a child’s event calling the parent’s override (evt:<Child>::BeginPlay → evt:<Parent>::BeginPlay).

What AI can now answer

Feed ProjectLinkage.graphify.json to an AI coding agent or a knowledge graph tool, and it can answer questions that are otherwise impossible to answer from the project alone. The merged graph records calls like this one (from the shipped example’s BP_BaseTest.graphify.json):

{
  "source": "bp:/GraphScribe/Examples/BP_BaseTest.BP_BaseTest",
  "target": "fn:/GraphScribe/Examples/BP_BaseTest.BP_BaseTest::Base_Function_2",
  "relation": "calls",
  "confidence": "EXTRACTED",
  "source_file": "/GraphScribe/Examples/BP_BaseTest.BP_BaseTest"
}

So it can answer questions like:

“Who calls Base_Function_2?” follow the calls edges backward.
“Which Blueprints reference this DataAsset’s class?” follow the uses edges.
“What does Base_CallFunction actually touch?” walk the subgraph.

Does it include noise?

Graphify intentionally filters out Kismet utility noise Branch, Sequence, Get/Set nodes, and internal Kismet*Library calls. It keeps the gameplay linkage: which Blueprints call which functions and use which classes. That’s exactly the signal AI needs. (Markdown, Mermaid, and JSON keep the full node set, Graphify is the trimmed view.)

How to get it

In the Content Browser, right-click the folder you want (e.g. the root game folder) → Export Blueprints with GraphScribe….
In the batch dialog, set Format to Graphify, pick your output directory, and click Export.
GraphScribe writes one .graphify.json per asset under the Graphify/ subfolder of your output directory and rebuilds ProjectLinkage.graphify.json at that subfolder’s root from everything under it, plus the graphify-ready Graphify/graphify-out/graph.json wrapper. With Generate Graphify Viewer on (off by default), it also auto-runs graphify cluster-only so the interactive graph.html viewer is generated, and the batch dialog’s Open Graphify Viewer button opens it.

For the full technical contract (schema versioning, the closed set of relations, merge behavior), see the Schema & Stability reference.

To load these exports into the Graphify tool (install it, point it at your export folder, and query the graph), see Graphify: Install & Use.