Unreal Engine plugin

Project Context Export

Your Unreal project as plain text that AI coding agents can read. Blueprints, levels, data tables, data assets, materials, UMG widgets, project settings and the asset dependency graph, exported as Markdown and JSON.

Get it on Fab Read the docs Sample output

$29.99 Personal · $49.99 Professional on Fab
Unreal Engine 5.6, 5.7 and 5.8 · Windows and macOS editors

Why

Your agent sees file names, not logic

.uasset and .umap files are binary. A coding agent working in your repository cannot tell what BP_Door does when the player walks into it, which game mode a level uses, or what columns a data table has, so it guesses.

Project Context Export writes all of that out as Markdown and JSON, next to your project, so the agent reads it like source code. One file per asset, plus PROJECT_CONTEXT.md: an overview and index the agent starts from.

Every function, event graph, macro and collapsed graph as pseudo-code in execution order
Values inlined as expressions; branches, loops and sequences indented
Only properties changed from class defaults, so what you read is what someone changed

BP_Door.md · EventGraphfull file

Event BeginPlay
  Branch(Condition=(OpenAngle > 0.0))
    True:
      PrintString(InString="Door ready")
      [N8] Set bIsOpen = false
    False:
      PrintString(InString="OpenAngle must be positive")
      -> goto [N8] Set bIsOpen

Event ActorBeginOverlap(OtherActor)
  TryOpen(Instigator=OtherActor)
  Branch(Condition=TryOpen.Opened)
    True:
      PrintString(InString="Door opened")

Not connected to any entry point: Reroute Node

Real output

Unedited, from the demo project

This is what the plugin wrote for /Game/Demo/BP_Door, a door that opens for the first actor that walks into it. The demo project with one asset of every supported type ships with the plugin, and its whole export is on this site.

Function: TryOpen(Instigator: Actor Object Reference) -> (Opened: Boolean)

TryOpen(Instigator)
  Branch(Condition=bIsOpen)
    True:
      PrintString(InString="Already open")
    False:
      Set bIsOpen = true  // Remember it so the door opens once
      Return(Opened=true)

Saved/ProjectContext/format

PROJECT_CONTEXT.md     overview and index
project.md / .json     project settings
dependencies.md/.json  asset dependency graph
other_assets.md        listed by path and class
assets/Game/Demo/
  BP_Door.md
  BP_Door.json
  L_Demo.md
  ...

Browse the full sample export · PROJECT_CONTEXT.md · How to read the pseudo-code

Supported types

What gets exported

Textures, meshes, sounds and animations have no text form; they are listed by path and class in other_assets.md.

Asset	What you get
Blueprints	Parent class, interfaces, components with their changed settings, variables with defaults and flags, event dispatchers, timelines, and every function, event graph, macro and collapsed graph as pseudo-code in execution order
Levels	Actors grouped by outliner folder with class, transform, tags and the properties changed from class defaults; world settings; streaming levels; Level Blueprint; World Partition actors from their descriptors
Data tables and data assets	Row struct columns and every row's values; data asset values changed from the class defaults (any `UDataAsset`, including Enhanced Input actions and mapping contexts)
Materials and material instances	Settings, parameters with defaults, what feeds each material output as nested expressions, node counts, functions and textures used; instance parent chain and overrides
UMG widgets	Widget tree with changed properties and slot layout, property bindings, animations, plus the widget's Blueprint graphs
Blueprint structs and enums	Fields with friendly names, types and defaults; enum display names
Project	Engine version, code modules, project plugins, maps and modes, input settings, collision channels and profiles, gameplay tags, config files
Dependencies	What each asset loads, what it references softly, and what uses it

How it works

Three steps, then it keeps itself current

Export
Enable the plugin, then Tools > Project Context > Export Project Context. Or right-click a folder or assets in the Content Browser to export just those.
Files land in Saved/ProjectContext/
One Markdown and one JSON file per asset at its package path, plus PROJECT_CONTEXT.md, the overview and index.
Point your agent at it
One line in your agent instructions file (for example AGENTS.md) tells it to start at PROJECT_CONTEXT.md. Example

After the first export, every asset you save is re-exported automatically. Right-click any asset and choose Copy as Text to paste it straight into a chat.

Automation

Built for agents and CI

Commandlet. Your agent or CI refreshes the export without opening the editor window. Exit code 0 when every asset exported, 1 when any failed.
Incremental. Only assets whose files changed are exported again. Unchanged files are not touched, so a committed export produces small diffs.
Scoped. Include and exclude folders, or pass -Paths= to export only what you need.
Shared settings. Markdown, JSON or both, plus size limits, live in Config/DefaultProjectContextExport.ini so the whole team and CI use the same settings.
Scriptable. Python and Editor Utility Blueprint functions.

Command line reference

Command line

# Windows
UnrealEditor-Cmd.exe C:/Projects/MyGame/MyGame.uproject -run=ProjectContextExport -Incremental -unattended -nullrhi

# macOS
"/Users/Shared/Epic Games/UE_5.8/Engine/Binaries/Mac/UnrealEditor-Cmd" ~/Projects/MyGame/MyGame.uproject -run=ProjectContextExport -Incremental -unattended -nullrhi

Python

import unreal
unreal.PceLibrary.export_project_context(True)                       # incremental
unreal.PceLibrary.export_project_context_paths(["/Game/UI"], False)
text = unreal.PceLibrary.asset_to_text(unreal.load_asset("/Game/Demo/BP_Door"))
folder = unreal.PceLibrary.get_project_context_directory()

Technical details

Specifications

Engine versions	Unreal Engine 5.6, 5.7 and 5.8
Platforms	Windows and macOS editors
Code module	ProjectContextExport (C++, Editor)
Runtime cost	None. Editor-only: nothing is added to your packaged game
Network	No network calls, no AI service, no account or subscription. Your project never leaves your machine
Your assets	Read-only: the plugin never modifies them, and the text cannot be turned back into assets
Output	Markdown and JSON in `Saved/ProjectContext/`, or any folder you choose
Interfaces	Tools menu, Content Browser context menus, commandlet, Python and Editor Utility Blueprints
Included	Demo project with one asset of every supported type and its export
Not included	It does not edit your project and does not call any AI model. Textures, meshes, sounds and animations are listed by path and class only

FAQ

Questions

Does it send my project anywhere?

No. It runs entirely on your machine, makes no network calls, and does not call any AI model or service. It writes text files into a folder of your project and nothing else.

Which engine versions and platforms are supported?

Unreal Engine 5.6, 5.7 and 5.8, in the Windows and macOS editors. It is an editor-only plugin: nothing is added to packaged games.

Can I export only part of the project?

Yes. Right-click a folder in the Content Browser and choose Export Project Context for Folder, pass -Paths= to the commandlet, or set Included Paths and Excluded Paths in Project Settings.

Can the text be turned back into assets?

No. The export is one-way: it is for reading and understanding the project, not for editing it. The plugin never modifies your assets.

Which AI tools does it work with?

Any tool that can read files: terminal coding agents, IDE assistants and chat tools. The output is plain Markdown and JSON with no tool-specific format. Point the agent at PROJECT_CONTEXT.md (see Usage).

How big is the output?

It depends on the project. Blueprints and data are small; levels with thousands of actors are the largest files. Use Excluded Paths for marketplace packs you do not work on, turn off Graph Nodes In Json, or turn off Actor Properties to shrink it.

Should I commit the output to version control?

Both work. The default folder is Saved/ProjectContext, which most projects ignore. Set Output Directory to a folder outside Saved and commit it if teammates or cloud agents should see it without running Unreal. Unchanged assets keep their files untouched, so diffs show only real changes.

Some actors in my World Partition map have no properties.

Actors that are not loaded are listed from their descriptors only. Load the region in the editor and export again to get their properties.

What is the difference from the free Asset to Text plugin?

Asset to Text copies one Blueprint or data table to the clipboard. Project Context Export covers levels, data assets, materials, UMG, structs, enums, project settings and dependencies, exports the whole project to files, updates them on save and runs from the command line for agents and CI.

Give your agent the whole project

$29.99 Personal · $49.99 Professional · Unreal Engine 5.6, 5.7 and 5.8 · Windows and macOS editors

Get it on Fab Questions? Contact us