Every version, with what got added, changed, and fixed. Switch between the Unreal Engine plugin and the cfa CLI.
CodeFizz Editor Agent, the Unreal Engine 5 plugin.
v1.15.4
Latest
Nodes added to an existing Blueprint graph now land where a person would put them: next to the node they wire to, pins aligned, on the grid, and your own nodes stay where you left them.
Added
add_blueprint_node accepts from_node and from_pin: the new node is wired to that pin and placed beside it, the same as dragging a wire off a pin in the editor. Conversion nodes the wiring creates ride along.
insert_node_in_exec now positions the spliced node after its upstream node with the exec pins aligned and, when the chain is too tight, slides the downstream chain right just far enough to fit. The result reports moved_downstream_nodes. The same slide applies when a built piece is spliced between an existing entry and return node.
Fixed
build_blueprint_graph dropped every new piece in a band under the whole graph, far from the node it connected to, which drew long looping wires. Each connected piece now lands 100 px to the right of the existing node it wires from, with the linked pin rows aligned, snapped to the 16 px editor grid, and pushed clear of anything already on the graph. Pieces that wire to different existing nodes are placed independently.
build_blueprint_graph moved nodes it only reused. A function entry, a return node or a custom event that already existed was stamped to (0,0) and then re-arranged. Reused nodes are now left exactly where they were unless you pass a position for that node.
add_blueprint_node with no position put every node at (0,0), on top of whatever was there. It now takes the engine's own free spot below the existing content.
build_graph and apply_graph_patch place restored Blueprint nodes that carry no position instead of leaving them at (0,0). add_function_output puts the new return node at the engine's own offset from the entry node instead of a fixed spot.
v1.15.3
get_project_context reads the running editor in one call (engine, project, plugins, capabilities, assets by class), so an assistant can adapt its plan to what is actually there.
Added
get_project_context: the engine version, platform and RHI, the project name, path, engine association and open map, what this plugin build can do (profiling, 5.7 and 5.8 features), enabled plugins (or a yes/no check of names you pass), and the project's assets counted by class under a content path. World Partition external actors and folders are not counted as assets.
v1.15.2
The character pipeline: 70 new commands retarget animation libraries between skeletons, edit skeletal meshes down to the skin weights, and build physics assets, on UE 5.6, 5.7 and 5.8.
Added
Retargeting (32 commands). create_ik_rig runs the engine auto characterizer (UE4 and UE5 mannequins, Mixamo, MetaHuman, Daz, CC4 and more) so a rig gets its retarget root and chains in one call. create_retargeter performs the same automatic setup as the editor Retarget Animations dialog: exact chain mapping, an auto aligned retarget pose with the feet kept flat, root motion configured, IK helper bones pinned. batch_retarget converts whole folders of sequences, montages and blend spaces and moves the results where you asked.
Every automatic retarget choice can be changed by hand: chains, retarget root, chain mapping (exact or fuzzy), retarget poses per bone, retarget ops with generic settings patching, IK solvers, goals and per bone settings. list_ik_solver_types and list_retarget_op_types read what the running engine version offers, so ops added in 5.7 and 5.8 work without an update.
Skeletal meshes (25 commands). Read a mesh or skeleton, list bones with transforms, add and edit sockets on the mesh or the skeleton, virtual bones, bone retarget modes, compatible skeletons, edit_skeleton for adding, removing, renaming and reparenting bones, LOD settings and regeneration, materials, morph targets and skin weights read and written through the mesh data, and validate_skinning.
Physics assets (13 commands). Generate from a mesh with the editor generator, or build body by body: add_physics_body fits the shapes from the skinned vertices like the editor New Body, sets up the constraint to the parent body and turns off collision between the pair. Shapes, constraints with limits, collision pairs, assignment to a mesh, and validate_physics_asset.
validate_ik_rig, validate_retarget, validate_skinning and validate_physics_asset return a verdict with the exact errors and warnings, so an assistant can prove a setup before using it.
Changed
The IK Rig plugin is used by reflection only, so the editor agent loads even in a project that has it turned off, and every retarget command then says so by name.
Fixed
Reading a retargeter or any asset with a map that had entries removed could crash the editor on 5.6 and 5.7. Sparse containers are now walked safely.
Bone vertex measurements (physics fitting, bone bounds, Control Rig collider sizing) came back empty once LOD streaming had touched a project mesh. They now read the mesh data, which is always available in the editor.
v1.15.1
Editing a curve table from the CLI while it is open in its editor no longer crashes the editor.
Fixed
set_curve_table_row, delete_curve_table_row, rename_curve_table_row and import_curve_table now tell an open Curve Table editor that the rows changed, the same way the data table commands always did. The editor rebuilds its curve list right away instead of holding on to a curve that was just removed, which is what crashed it on the next frame when a row was selected.
The open editor now shows the live rows after each command (new rows appear, renamed and deleted rows update) instead of a stale list.
v1.15.0
Sequencer is now a full cinematics toolkit: 188 commands (up from 65) that author, animate, verify, and render Level Sequences without opening the Sequencer window, on UE 5.6, 5.7, and 5.8.
Added
Control Rig on the timeline. Put a Control Rig on a character, key its controls, read or bake the values, set spaces, and validate the rig track, all headless. Epic's own tools only key controls with a Sequencer window open.
Keyframe editing that animators expect: copy and paste keys, offset, retime, reduce, tween, key every channel at a frame, and bake a channel to keys. Works on every channel type (float, double, integer, bool, byte, string, object).
Shots and camera work. Add shots, sub-sequences with time scale, camera cuts with blending and ease, camera cut tracks, marked frames, and time warp.
Outliner control from the CLI: mute and solo tracks, disable evaluation per track or row, section flags, folders with colours and nesting, selection, playhead and playback speed, loop mode.
Composition: spawnable templates and ownership, custom bindings, binding tags, conditions on tracks, rows and sections, event keys with payloads, copy and paste of whole tracks and sections between sequences, repair of broken bindings.
Director Blueprint endpoints: dynamic binding resolvers, condition endpoints, and event endpoints are created, wired, and compiled for you. The result reports whether the function is bound, so you know it actually works.
Import and export: FBX in and out of a sequence, animation sequence export and linking both ways, and FBX to or from a Control Rig track.
Movie Render Queue management: list, add, remove, and duplicate jobs, apply presets and per-job settings, enable or override shots, save and load the queue, cancel a render, and a render_status verdict that checks every output file exists and is not empty.
Take Recorder: start, stop, and cancel a take, add actor sources, list takes, all headless. The Takes plugin stays optional, so nothing changes for projects that do not use it.
Animation Mixer on UE 5.8: layers, animations on layers, child tracks, crossfade and inertial transitions, decorations (mask, mirroring, root motion), per-layer weight, and a mixer validator. On 5.6 and 5.7 the commands say clearly that they need 5.8.
Verification for cinematics: validate_sequence gives a verdict on bindings, tracks, and sections, and evaluate_sequence scrubs to a frame and reads back real bone transforms, property values, and control values, so a keyed change is proven, not assumed.
validate_anim_asset now checks animation sequences: skeleton, data model, length, bone tracks, frame rate mismatch, additive base pose, and notify classes.
Changed
All time inputs take a time_unit of frames, seconds, or ticks. Every list command takes filter and max_results and reports truncation.
Fixed
tag_binding no longer drops earlier bindings from a tag when a new one is added.
validate_sequence and repair_bindings no longer flag bindings that resolve through a director Blueprint as broken.
v1.14.13
Adding nested components on a Blueprint now matches the editor Add button, so extras under a mesh no longer cook as a cycle. Illegal moves return a clear error.
Changed
take_screenshot no longer takes asset_path. That used to photograph a docked tab that often never painted. Open the asset with open_asset, then capture the editor window with take_screenshot --mode window.
Fixed
add_component_to_blueprint on a Blueprint class now uses the same editor path as clicking Add in the Components panel. Nested extras (Ears, Belt, and so on under Mesh) are children of that mesh, not also roots. Cook and map load no longer hit the cyclic parent warning that used to fail the build.
The same path is used when you add or reparent a component on a placed actor in the level. Instance extras attach and persist like the Details panel Add button.
Moves the editor would refuse now fail with a plain error instead of succeeding or crashing. You cannot reparent inherited Mesh or Capsule, attach something to itself or to its child, reparent the scene root or a Timeline, delete the default scene root, or replace an inherited root on a placed Blueprint actor.
v1.14.12
Cloning a Niagara Fluids system is now a real asset duplicate, so 3D fire and water templates save instead of hitting Illegal reference to private object.
Changed
Verified clone_mode=duplicate_asset plus a successful save of Grid3D_Gas_Explosion on UE 5.6.1, 5.7.4, and 5.8.2.
Fixed
create_niagara_system with a Niagara system template (including NiagaraFluids Grid3D fire, smoke, and FLIP water) now duplicates the whole asset. The old path added emitters into an empty system and left FunctionScript pointing at private inners such as SpinPosition, so SaveAsset refused the package.
After a clone or add_niagara_emitter, leftover private FunctionScript references are detected and the command errors instead of writing an unsavable asset.
v1.14.11
Play after compiling Widget Blueprints no longer hits Old World not cleaned up by GC. Undo no longer pins throwaway designer previews.
Changed
compile_blueprint, open_asset, get_widget_tree, and take_screenshot are no longer wrapped in a CFA undo transaction, so a read or compile cannot snapshot a designer preview world.
Fixed
Compiling or opening a Widget Blueprint could leave REINST_ preview instances in the undo buffer, inside Transient worlds. The next Play then failed Epic GC with Old World not cleaned up. Compile and designer preview no longer record those throwaways into undo, and Play drops any leftover Transient-world undo entries first.
v1.14.10
Widget wrap instead of wipe, display-label rename, dry-run, and a screenshot that refuses a blank or Level frame.
Added
set_root_widget, remove_widget, and delete_blueprint_node take --dry-run. They report wrap vs discard and the names that would die, without mutating the tree.
list_blueprint_nodes inventories a graph. list_animation_keys reads UMG animation keys. build_blueprint_graph takes --defer-compile so you can wire first and compile once.
Changed
take_screenshot --asset-path opens like open_asset (no Close, no NewWindow). It recaptures if the first frame is blank or still the Level floor, and refuses a black window instead of saving it as success. Trust get_widget_tree for a rename, not that PNG.
Fixed
set_root_widget wraps the existing tree by default. Wiping still needs --replace-tree, so a CanvasPanel no longer silently deletes children.
rename_widget now sets the designer Display Label the way a human rename does, instead of UObject::Rename on top of an existing name (that path could crash the editor).
reload_asset keeps the real package name. It no longer saves a _DEADPACKAGE_ after a replace-tree reload.
v1.14.9
See exactly why an environment query picked the spot it did: every test, every score, and every candidate it threw away.
Added
run_env_query now returns the engine’s own debugger view instead of a bare list of points. You get the option that actually produced items, the tests in the order they really ran (which is not the order you authored them in, because the engine sorts by cost), each surviving item with the raw value and weighted score of every test applied to it, and per step timings so you can see where the cost is.
Every candidate the query rejected is reported with the test that rejected it and the engine’s own reason, lines like "Value 1087.24 is above maximum value set to 900.000000". That single line is usually the whole answer to why a query returns nothing.
A new get_eqs_runtime command reads the live queries an AI ran while the game is playing, with the same breakdown. A pawn’s list includes the queries its controller ran, which is where a Run EQS Query task runs them, so you ask about the character you can see rather than hunting for its controller.
Discovery and inspection now surface item types. search_eqs_nodes and get_eqs_node_type_info report what a generator produces and what a test accepts, get_env_query flags a test as unsupported, and get_env_query lists the named parameters a query reads. So a query can be assembled correctly the first time instead of debugged afterwards.
Changed
run_env_query runs in the play world whenever Play In Editor is active, and says which world it used. A query whose context reads the player resolves to nothing in the editor world, so every test passed and the result looked healthy while measuring nothing at all.
Fixed
Binding an environment query value to a query parameter, then reading that query back, crashed the editor. The provider class was being stored where an instance belongs, and the crash came on the first virtual call through it. Naming a class on any instanced property now creates the instance, the same as the details panel class picker does, so this is fixed everywhere and not just in EQS.
Editing a query did not invalidate the compiled copy the engine caches, so the next run silently replayed the query as it was before your change. Every authoring command now clears that cache, which is what the editor itself does.
A named query parameter you did not pass read as zero rather than falling back to the value you authored, because that is what the engine returns for a missing key. run_env_query now supplies every declared parameter exactly as a Run EQS Query task does, and reports which ones came from defaults. Integer parameters are also written correctly now (they travel inside a float’s bits, so writing one as a plain number produced a garbage value).
validate_env_query now fails a query whose test cannot run on the items its generator makes. The engine removes such a test at run time with only a log line, so the query succeeds and quietly never applies it, which is one of the easier ways to spend an afternoon.
Setting a property on a Behavior Tree node now notifies the node the way the details panel does, so a Run EQS Query task rebuilds its parameter list when you point it at a query. Before, the list stayed empty and the task could never override a parameter.
get_bt_runtime finds a tree by the character’s name. A brain lives on the AI controller, so filtering by the pawn you see in the outliner previously found nothing, and the reply now names both.
v1.14.8
Debug Mass Entity live on UE 5.8: every archetype, entity, fragment value and processor, straight from the bridge.
Added
A new mass command group, 19 commands over the same runtime facade that powers the built in Mass Debugger window. List every live entity manager, every archetype with its memory and chunk numbers, and every registered fragment and tag type with usage counts. Read the live values of any fragment on any entity through reflection, so project fragments work with no per type code, and write them back the same way.
Create entities from a list of fragment and tag names with initial values, no config asset needed, and destroy them by handle or whole archetype through the engine bulk path. Add and remove fragments or tags on live entities, with values written before observers fire so systems never see a half built fragment.
Run ad hoc archetype queries with all, any, none and optional element lists, and ask the engine to explain in its own words why a given archetype does or does not match. Inspect any processor with its full query requirements, and dump the solved per phase execution order with the dependencies of each processor.
It all works in the editor world without pressing Play, and entity listings stream chunk views with exact totals, so a world with hundreds of thousands of entities still answers in a small, capped response. The group is UE 5.8 only, where Mass became built in engine code; on 5.6 and 5.7 every command answers with a clear note saying so.
Safety guards shaped by a full audit against engine source: mutations are refused while Mass is mid processing, destroying or stripping replicated entities is refused while clients are connected (it can crash the replication sweep or orphan agents on clients), and sparse elements follow the engine rules for matching and presence.
Changed
Commands that require a list parameter now reject an empty list instead of quietly doing nothing, across the whole command surface.
v1.14.5
Widget Blueprints keep their references when you rename or delete, and the Output Log is quiet again.
Changed
The plugin logs under its own CodeFizzEditorAgent category instead of the shared scratch one, and routine per command lines are off by default. Turn them on with "log LogCodeFizzEditorAgent Verbose" when you need to see what the bridge is doing.
Fixed
Deleting a widget no longer leaves its variable behind in the Blueprint. The widget was detached from the tree but still counted as present, so its entry was saved to the asset, and the next time you opened that Blueprint the editor reported that a variable was deleted but still had a GUID. On a Development build that arrives as an error dialog, once for every widget you had removed.
Renaming a widget now carries its references with it. Animations that drove the widget, explicit navigation rules pointing at it, old style property bindings, and the desired focus widget all kept the previous name, so they quietly stopped working. All of them follow the rename now, and the hierarchy shows the new name straight away.
Replacing a widget no longer raises an editor error. The replacement deliberately takes the name of the widget it replaces so that references keep working, but it was also being registered as a brand new variable, which the editor refuses. It now keeps the existing entry, which is what preserves those references.
v1.14.4
The panel shows which agent version it is running, and explains what it is doing on your behalf.
Added
A "How this panel works" button at the foot of the sidebar. It explains what actually runs when you type: that the panel has no AI of its own and starts one already installed on your machine, that it works in your project folder, that it changes the editor by running the same cfa commands you could type yourself, and what each of the four access modes allows.
The agent version is shown under it, so you can tell at a glance which one you are on when reporting a problem.
Fixed
The panel now releases the text input system when it closes. Nothing visible was broken by this, but it left the editor pointing at a panel that had gone.
v1.14.3
Closing the editor now shuts down the agent it started, instead of leaving it running until you reboot.
Changed
The agent is now shut down properly rather than forced to quit, so its database is closed and tidied instead of needing repair on the next start.
If the editor is closed in a way that leaves no chance to shut anything down, such as a crash, the agent notices it has nobody connected and stops on its own after fifteen minutes.
Fixed
The agent kept running after you closed the editor, holding around 160 MB per project until the machine was restarted. Closing the last editor for a project now stops that project's agent. Other projects are untouched, and an editor still open on the same project keeps it running.
v1.14.2
The panel shows the agent downloading when it updates itself, instead of sitting on a blank starting message.
Added
When the agent updates, the panel now says so and shows the progress, for example "Downloading the CodeFizz agent 1.0.19... 62%". The download is around 40 MB, which is long enough that a silent panel looks like it has hung.
Fixed
A slow download could make the panel give up and report that the agent did not start in time. The panel now treats visible progress as proof it is still working, so only a download that genuinely stalls hits the timeout.
v1.14.1
The chat panel no longer opens black on a cold editor, its links work again, and it now tells you when your AI assistant is missing the CodeFizz skill.
Added
The panel checks whether the assistant you have selected actually has the CodeFizz skill installed, and says so when it is missing or out of date. It gives you the exact command to fix it and offers to restart the session afterwards so the assistant picks it up.
A beta notice sits at the top of the panel. The panel is new, and driving the editor from your own AI assistant with the cfa CLI is still the more capable route, so the notice links to the install guide for it.
Changed
The panel updates itself, so the two additions above reach you without reinstalling the plugin.
Fixed
The panel opened black the first time you used it after starting the editor, and stayed that way until you closed the tab and opened it again. If the editor is still busy loading when the panel starts, Unreal throws away the surface the panel draws on and never builds another one. The panel now notices and rebuilds it, which is what closing and reopening the tab was doing by hand. Unreal 5.7 and 5.8 only, 5.6 was never affected.
Links in the panel did nothing when you clicked them. Anything pointing at an external page, including links the agent writes into its replies, was being dropped. They now open in your normal browser.
v1.14.0
The chat panel is rebuilt. Same tab in the editor, a far more capable agent workspace inside it, on Unreal 5.7 and 5.8.
Changed
The chat panel is a new one. The tab is in the same place and still drives the agent CLI you already have installed and signed in, so nothing changes about how you authenticate, but the panel itself is a full agent workspace now rather than the earlier native one.
It opens on the project you already have open, with no picker to fill in. Two projects open at once each get their own panel, their own conversations and their own settings, and neither can write over the other.
Unreal 5.6 no longer has a chat panel. The toolbar there keeps the license and changelog tab instead. 5.6 ships a browser engine from 2021 that cannot run the new panel, while 5.7 and 5.8 ship a current one, so it is offered only where it genuinely works. If you need the chat panel on 5.6, stay on 1.13.0.
Fixed
The panel could take the agent down with it. Closing the tab killed the whole process tree, including the agent it had just started, so reopening it showed a connection error.
The panel drew over the rest of the editor when the window was not maximised, appearing on top of the level viewport and other tabs instead of staying inside its own.
The panel could sit on a loading screen forever. It was waiting for a callback the editor never fires unless a widget asks for it, so the address it needed was read and then thrown away.
v1.13.0
A real debugger. Put a breakpoint on a Blueprint node, watch the game stop on it, and read the actual values at that moment, the same way you would by hand.
Added
Breakpoints on Blueprint nodes. Play stops on the node, exactly like clicking one in the editor, and you can see it sitting there with the red marker on it.
Read the real values at the moment it stopped. Variables, pins and properties on the actual instance running in the level, not a guess from reading the graph.
Step through the logic. Step into a function, over a node, out of a function, continue, or abort the run, with the call stack at every point.
See which nodes just ran. Useful when the graph took a branch you did not expect and you want to know where it actually went.
Pick which copy you are debugging. With ten enemies in the level you choose the one to inspect, and in a networked test it tells you whether you are looking at the server or a particular client.
Behavior Tree breakpoints. Pause the game when the tree reaches a node, then read the blackboard and the running branch.
The plugin reports its own version to the CLI, so an out of date plugin is recognised as out of date instead of quietly rejecting commands it has never heard of.
The Updates panel says what an update is for, showing the release headline above the commands to run rather than only a version number.
Changed
The editor keeps answering while it is stopped on a breakpoint. Without that, the command to resume could not get through and the editor would sit there stuck.
Fixed
Reading assets during play used to come back empty on around a hundred and ninety commands, because the editor blocks those reads while the game runs. They work during play now.
Creating a Blueprint, a Blueprint interface or a function library failed on every call in 1.12.0, including with default settings.
v1.12.0
The Gameplay Ability System. Health and stamina that actually exist, buffs and damage that apply themselves, abilities, and the effects and sounds that play when they fire, all built from commands instead of by hand.
Added
Attributes without writing any C++. Create an attribute set with Health, Max Health, Speed and whatever else your game needs, all in one call, and they are real attributes the ability system recognises and replicates.
Buffs, damage and status effects. Build a gameplay effect, say what it changes and by how much, give it a duration or make it instant, and attach the behaviour you want: tags it grants while active, immunity, a chance to apply, effects that follow on from it.
Abilities, with their logic. Create the ability asset and build its graph in the same run, so an ability that applies a buff, plays its effect and ends itself is a few commands rather than an afternoon in the editor.
A gameplay tag library you can actually manage. Add tags with the comments that explain them, organise them into separate files instead of one growing list, rename one and keep every asset pointing at it working, and see which tags exist only because something deeper was declared under them.
Gameplay cues, wired up correctly. Create the notify that plays when an effect fires and it binds to its tag properly, including the second field the engine actually searches on, which is the usual reason a cue looks perfectly set up and never plays.
One search across all of it. Ask for several things at once, like buff, protect and attack, and get a ranked shortlist for each. Point it at one branch of your tags and it looks only inside that branch, so a project with thousands of tags stays workable instead of drowning you in a list.
Checks that tell you what is wrong before the game does. An effect that would do nothing when applied, a cue tag with no notify behind it, a notify pointing at a tag that no longer exists, an attribute set with nothing in it. The effect check runs the validation Unreal itself ships, so the wording comes from the engine rather than from us.
Changed
Attribute sets built in Blueprint now tell you what they cannot do. They hold and replicate attributes perfectly well, but Unreal does not let a Blueprint clamp a value, turn incoming damage into lost health, or correct a predicted value on a client. The check says so, so you find out while prototyping rather than during a multiplayer test.
Fixed
Creating an asset where one already exists used to take the editor down. It now refuses and tells you to pick another name.
A path typed with a slash on the end used to take the editor down as well, across audio, AI, blueprints, curves and rigs. It is now refused with the corrected path shown.
Undo could leave a newly created asset half built and its name unusable. Asset creation is now left out of undo, the way the rest of the tool already handles it.
Some edits to an effect could not be undone at all, silently. They record properly now, and undo and redo both put it back.
v1.11.2
World building. Landscape, terrain that erodes itself, rivers that carve their own valleys, foliage, lighting, navigation, and World Partition streaming, all driven from commands.
Added
A landscape from nothing, then a whole terrain in one call. Ridged peaks, hydraulic erosion that cuts real drainage networks, thermal slippage so the ridges do not end up as knife edges, and stream power incision that makes valleys concave the way real ones are. It reports the slope distribution it actually produced, so you can judge the result against real terrain rather than assume it worked.
Rivers that carve their own valleys. These are real Water plugin bodies, so the river lowers the landscape itself instead of you sculpting a channel first and hoping the water lines up with it.
Paint layers from the erosion history itself. Beyond height and slope, a layer can key off where water flowed, where sediment settled, where rock wore away and where debris collected, so the texturing follows what actually happened to the terrain instead of a guess.
World Partition, nineteen commands. Find actors that are streamed out, which an ordinary search cannot see at all, load and pin and unload regions, manage data layers and HLOD layers and runtime grids, and run all seven builders. The builders take minutes to hours and block the editor, so they refuse to start until you confirm.
Foliage scattering, volumes, sky and lighting presets, landscape and actor splines, and navigation builds with a check that proves a point is genuinely reachable rather than reporting a tile count that is non zero even when the navmesh is empty.
Regional terrain regeneration. Change one area in the middle of a finished landscape and have it blended back into the surrounding ground, rather than regenerating everything or leaving a visible rim.
Changed
create_landscape_material has been removed, and this one will break scripts that call it. It added nothing you could not already do, because the material commands build any graph, and freezing a recipe into a command meant nobody could adapt it. The full recipe now ships in the bundled guide instead, along with the traps that decide whether terrain looks real or looks like plastic.
Fixed
Water rendered sometimes and not others. Four separate conditions have to hold for a water body to appear, and only some of them did: the zone has to cover the river, its texture resolution has to scale with the zone or the engine coarsens the landscape and smooths the channel away, and only a user triggered change binds a body to its zone.
A landscape created on 5.6 came up with no edit layers, which silently killed the water brush and the spline tool. 5.6 defaults them off and only creates them if the flag is already set before import, unlike 5.7 and 5.8 where they are always on.
Asking for a landscape larger than the project allows used to take the editor down with no error. It now refuses and tells you the resolution it worked out.
The top down capture came back white, or as soft blobs. It was rendering through its own offscreen camera, which never converges its exposure and drops the landscape several detail levels down. It now aims the editor viewport itself, and can be pointed at a specific area from any angle.
v1.11.0
Trees and plants. You can grow vegetation from commands now: a trunk that branches, bends under its own weight and drops the limbs that sit in shade, skinned into a real mesh with foliage scattered over it, then exported to assets without touching the editor. UE 5.8 and later.
Added
Grow a plant end to end. Create the asset empty or from one of Epic's samples, wire the growth pipeline, and tune the simulation: how tall it gets, how often it forks, how far branches reach, how much they droop, and which ones die off because nothing reaches them.
Read a node before you touch it. Ask any vegetation node for its full schema and get every property path with its type, its default, the description Unreal itself carries for it, the valid values of every enum, the slider and clamp ranges, and the condition that decides whether a setting does anything at all. The Grower alone has 179 of them, so there is also a mode that writes the whole schema to a file instead of burying you in it.
Search the menu the editor actually renders. Node names, categories and descriptions come from the plugin's own add node menu rather than a list written down somewhere, so they are always what your engine really has. Ask several things at once and each search reports how many it found and whether it held any back.
Export with no click. Unreal offers no scripted way to export a plant, so this drives the editor's own Export command and answers its dialog for you. It works the same whether the editor is sitting in front of you or running unattended, and it checks the things Unreal would otherwise skip over in silence, like an export node with no name set.
Preview without regrowing. Selecting a node is what drives the viewport, so you can look at the branch skeleton, the bone colouring or the finished tree by asking for that node. It reads what is already there instead of running the graph again, which turns a wait of over a minute into about half a second.
Everything you already know still works. A vegetation asset is a PCG graph underneath, so the whole PCG command set applies to it: add and connect nodes, set any property, lay the graph out, validate it, batch a run of edits into one undo step.
Changed
A value outside the range its author intended now says so. Writes still go through, because Unreal treats those bounds as a hint rather than a rule, but you get told rather than left wondering why nothing looks right.
Fixed
Nodes that share a class no longer collapse into one another. Some menu entries are variants of the same node, and they were all being reported as whichever one happened to be found first, so a list of 50 nodes read as 90 with most of the names wrong. Each variant is now listed with the index that selects it.
Asking for one of those variants now gives you the one you asked for. The index shown when you list them and the index used when you place one were two different numbers, so every index a listing reported was rejected as out of range, and the low ones silently placed the wrong node.
v1.10.0
Modular characters. You can build a character out of interchangeable parts now: one body, a wardrobe of garments that swap at runtime, and skin and colour driven by parameters. Mutable is how Unreal does this, and the whole graph side of it is now available from commands. UE 5.8 and later.
Added
Customizable Objects, end to end. Create the graph that describes every variation a character can have, place and wire its nodes, compile it, then make instances and set their parameters. One recipe, as many different looks as you want out of it.
A wardrobe that lives in separate assets. Build each outfit as its own Customizable Object and attach it to a character as one option of a group, so the same jacket can be shared by every character that wants it instead of being copied into each one.
Parameters you can drive at runtime. Read what a compiled object exposes, then set outfits, colours, skins and numbers on an instance and rebuild its mesh. Copy a whole configuration from one instance onto others, or reset it back to defaults.
Reusable graph pieces. Put a fragment you keep rebuilding into a macro library once and drop it into any Customizable Object as a single node, with its own inputs and outputs.
Find the node you need without knowing its name. Search several ideas at once and get ranked matches back, then ask any of them for its exact pins, properties and the description Unreal itself carries for it.
Graphs that come out readable. Nodes are arranged automatically and a wire that would run across the graph gets reroute points added so it follows a lane instead of cutting through everything in its path.
Mutable joins the round trip format. Pull a whole graph out as one document, edit it, and compare or patch it back. There is also a full export of an entire Customizable Object, every parameter with its options and UI metadata, its states, components and the assets it references.
The traps are handled for you rather than left to bite. Two components sharing a name compile perfectly and then fail when the character is built, so that is caught. A parameter node nothing reaches produces no parameter at all, so an empty list tells you why. Setting a value that did not take is reported instead of returned as success.
v1.9.0
Sound. You can build audio from commands now: MetaSounds that generate music and ambience as they play, Sound Cues that pick and layer wave files, and every other audio asset around them. The graphs come out laid out and readable, not stacked in a pile.
Added
MetaSounds, end to end. Create a source or a patch, place nodes, wire them, set values, and build a whole graph in one call. Enough to make a track that plays itself: a drifting pad, a melody that never repeats the same way twice, or an ambience that shifts from calm morning to something uneasy at night.
Reusable patches. Build a voice, a sequencer or a filter chain once, then drop it into any MetaSound as a single node and give it different settings each time. Your own library, referred to by name.
Find the node you need without knowing its name. Search several ideas at once, pitch, volume, filter, delay, and get ranked matches back, then ask any of them for its exact inputs and outputs. No more guessing at spellings.
Sound Cues with everything on them. Build the tree, assign wave files, randomise between them with weights, mix and delay branches, and set any value on any node. Hold a whole bank of sounds in one input and let the graph pick between them.
The rest of the audio family. Attenuation, concurrency, sound classes, submixes, buses and effect chains, created and configured by name, plus the hierarchy links that are easy to leave half connected by hand.
Graphs that are actually readable. Both kinds get laid out automatically, measured from the real editor so tall nodes get the room they need, and wires that would cut across a node are routed around it instead. Nothing lands in a heap at the origin any more.
Audio joins the round trip format. Pull a whole MetaSound or Sound Cue out as one document, edit it, and build it back, or compare two and apply just the difference. Node values travel with it, so nothing quietly resets to default.
Checks that tell you if it will be silent. Both kinds report what is wrong before you play them, an output nothing writes to, an input with nothing behind it, a wave player with no wave.
v1.8.0
Behavior Trees, Blackboards and Environment Queries. You can build an AI setup from commands now: a tree with its composites, tasks, decorators and services, the blackboard it reads from, and the environment queries it uses to pick a spot to move to or a target to attack.
Added
Behavior Trees, end to end. Create a tree, place composites and tasks, attach decorators and services, wire the branches, compile it, and tidy the layout. A whole branch with its conditions can be placed in one call, and if any part of that call is wrong the entire branch is rolled back rather than leaving half a tree behind.
Blackboards. Create one, add and remove keys of any type, set defaults, and attach it to a tree. The key types available in your project are discoverable, so you are never guessing at what a key can hold.
Environment Queries. Build a query, add its options and tests, tune scoring, and run it to see what it actually returns. Useful for the questions AI asks constantly: where should I stand, which cover is best, which target is worth chasing.
See what a running tree is doing. Inspect live state while the game plays, and control it, so you can tell why a character chose one branch over another instead of guessing from the outside.
Behavior Trees join the round trip format. Pull a whole tree out as one document, edit it, and build it back, or compare two trees and patch the difference. Decorators and services travel with the node they are attached to.
Checks for both. A tree reports what is wrong with it, and a query does the same, so you find out before running the game rather than during it.
Fixed
The order children run in is now the order you asked for. Unreal never stores that order, it infers it from where the nodes sit, so an added child could tie with its siblings and a Sequence would run its steps in an order nobody chose. Children are now placed deliberately, left to right, so what you see is what runs.
v1.7.0
Checking your work. Seven commands that answer whether something is actually correct rather than whether a call succeeded: run the asset validators your project defines, compile a Blueprint and see which node failed, find meshes with unusable collision, catch silent multiplayer mistakes, and read the real shader cost of a material.
Added
Run the validators your project already defines, across a folder or the whole project, and get back which assets failed and why. These are the rules your studio already defines, not ours, so the answer matches what your team already considers correct. A stock project with no validators of its own still gets the always on check for a corrupt asset file on disk.
Compile a Blueprint and see the compiler messages attached to the node and graph that produced them, instead of a flat wall of text. It also reports pins left orphaned when a function signature changed, and exec chains that nothing drives, which is the usual reason a graph silently never runs. Compiling this way never saves the asset, even in a project set to save on compile.
Find static meshes whose collision will not work. A mesh with no simple collision is reported as an error, and one set to use complex collision as simple is a warning, because it cannot be simulated. The whole sweep reads counts the engine already publishes about each mesh, so checking an entire project loads nothing.
Catch multiplayer mistakes without starting a session: properties marked for replication but never registered, RepNotify properties whose OnRep function does not exist, server events with no validation, and reliable multicasts, whose cost grows with every connected player.
Read the real cost of a material. Instruction counts per shader, samplers used against the platform limit, texture and virtual texture lookups, and interpolators, taken from the counters the engine itself keeps. Going over the sampler limit is reported as a failure, because the material will not compile on that platform at all.
Wait for the editor to finish compiling before you measure anything, and read the Message Logs the editor keeps (map check, asset check, Blueprint log, PIE) with counts by severity. Those logs carry detail the result of a command does not, such as which asset failed to load and why.
Changed
Every check reports what it actually measured, not just a verdict, so you can tell the difference between a clean result and a check that had nothing to look at.
Fixed
The same project now gets the same answer on UE 5.6, 5.7 and 5.8. Asset validation treated warnings differently on the older engines, so a project could be reported as failing on 5.6 and passing on 5.8.
A critical error in a Message Log is reported as an error rather than being quietly listed as information, and a compiler note is no longer counted as a warning.
v1.6.0
Animation Blueprints, end to end. You can build a complete animation setup from commands now: a state machine with its states, conduits, aliases and transition rules, blend spaces and aim offsets, montages with sections and notifies, animation layers, and the slots on the skeleton.
Added
Animation Blueprints. Create one against a skeleton, add a state machine, fill it with states, conduits and aliases, wire the transitions and bind their rules, and drop animations into each state. The whole locomotion setup, built from commands, with every authoring step having a matching check that tells you whether the result is actually sound.
Blend spaces and aim offsets. Build 1D or 2D blend spaces, name and range the axes, and place samples. Aim offsets refuse an animation that is not the right kind of additive and say what the animation actually is, instead of accepting it and producing a broken pose later.
Montages, notifies and notify states. Assemble a montage from several animations, add named sections and chain them, add notify tracks, and place both point notifies and notify states with durations. Notify Blueprints can be created and their events filled in like any other Blueprint.
Animation layers and layer interfaces, plus full control of the slots on a skeleton. Add, rename and remove slots and slot groups, and see them update in the Anim Slot Manager while it is open rather than after a restart.
State machines arrange themselves. Ask for a tidy up and the states are laid out in a readable block with each transition sitting on the line between the two states it joins, instead of wherever they happened to be dropped.
Screenshots can be aimed at a particular asset or window. Ask for a picture of an asset and you get that asset, even when its editor is a tab behind the main window, and even when Unreal is not the application you are looking at. There are also commands to list what is open and to bring a given asset to the front.
Fixed
Commands that take a class now accept the asset path you were just given. Handing back the path a create command returned used to be refused, because that path names the asset rather than the class it generates. This affected every command that takes a class, not just the animation ones.
v1.5.3
Graphs now round-trip. You can pull a whole Blueprint, Material or Niagara graph out as one document, edit it, and build it back, instead of adding nodes one call at a time. Niagara graphs can also be tidied automatically, and a Widget Blueprint can finally be switched to its Graph tab.
Added
export_graph and build_graph. Read an entire graph out as a single document and write it back, for Blueprints, Materials and Niagara. This is the difference between describing a graph once and making thirty separate calls to build it, so it is much cheaper for an AI to work with and far easier for you to review before it lands.
diff_graph and apply_graph_patch. Compare a live graph against a document and see exactly what differs, then apply only the difference. Useful for checking that an edit did what you meant, and for keeping a graph in step with a file you keep under version control.
layout_niagara_graph. Tidies a Niagara graph the way the Material one already could, laying nodes out by how they feed each other and inserting reroute knots so long wires stay readable instead of cutting across the whole graph.
set_widget_editor_mode. Switches a Widget Blueprint between its Designer and Graph tabs, the same way the buttons do. A Widget Blueprint always opens on Designer, so until now its graph could not be reached at all from a command.
Fixed
Material connections that named their input all landed on the first one. If you wrote a connection targeting an input by name, say the B pin of a Multiply, it silently went to input 0 instead. Two connections would collide on the same pin and one would vanish. Graphs written by hand or by an AI were affected, graphs that came from export_graph were not.
Niagara graphs moved between projects or engine versions could come back with the wrong parameter types. The type was being stored as a position in a list that is built fresh each time the editor starts, so the same number meant something different elsewhere. It now stores the type itself.
Scratch pad commands aimed at an emitter through its system appeared to work but produced nothing you could see or edit, because a system editor only ever shows its own scratch pads. Those calls are now refused up front, with a message explaining which path to use instead.
Deleting an asset could report success while the file was still there, usually because something else still referenced it. The result is now checked against what is actually on disk, and a failed delete says why.
v1.5.2
A safety fix worth having if you ever keep more than one project open. The editor now refuses any command that was meant for a different project, so a stale or hardcoded port can no longer edit the wrong game.
Added
The editor checks that a command was actually meant for it. Every command now arrives saying which project it is for, and if that is not this project the editor turns it away without running it. You get a plain message naming the project it expected and the one it reached, and nothing is changed.
Changed
Why this matters: a port is not a project. The editor takes the first free port when it starts, so if you open two projects the numbers can swap between sessions, and anything that remembered a port from last time would quietly talk to the wrong one. That is now caught by the editor itself, so it holds for any tool, not just ours.
v1.5.1
Undo now works. Every change your AI makes is a single, named step in the editor's undo history, so one Ctrl+Z takes it back. Your own edits stay protected, and a run of changes can be sent as one batch that undoes in one press.
Added
One Ctrl+Z undoes one command. Every change the agent makes now lands in the editor's undo history as a single entry named after the command that made it, so you can see what it did and take it back the same way you would take back your own work. Nothing to turn on, it applies to every command.
The agent can undo its own mistakes without touching yours. Ask it to roll something back and it walks backwards through its own changes only, stopping the moment it reaches an edit you made and telling you that is why it stopped. Your hand edits are never quietly thrown away.
See what a change actually did. The undo history can be read back, with each entry marked as the agent's work or yours, and optionally the exact objects and property names that changed. It is the quickest way to answer what did that just do without re-reading the whole asset.
Send fifty changes as one. A run of commands can go in a single batch that collapses into one undo step, so building a hundred actors or a row of table entries is one press to reverse instead of a hundred. It is also a single round trip, which makes bulk work noticeably faster.
A failed batch cleans up after itself. By default, if any step in a batch fails the whole batch is rolled back, so you are not left with half a change to unpick. You can also ask it to run everything and report which steps failed, or to check the whole batch for mistakes without changing anything.
Changed
Creating, deleting, renaming and importing assets deliberately stays outside undo, exactly as it does in the editor, where New Asset has never been undoable. Editing the contents of an existing asset is always undoable. Making asset creation undoable corrupted Blueprint state, so it is left alone on purpose.
Fixed
Some changes applied but could not be undone. Moving an actor, every Enhanced Input command, setting a property on an asset and adding a Niagara user parameter all changed the asset without recording anything, so Ctrl+Z did nothing. They now record properly. This was always the case, the new undo history is simply what made it visible.
Moving an actor now tells the editor it moved, so lighting and navigation update instead of quietly going stale.
v1.5.0
Control Rig arrives. Your AI can now rig a character end to end: build the controls, wire the IK, assemble a modular rig from Epic's module library, add jiggle and cloth physics, and then prove the rig actually works before an animator ever opens it. Over 120 new commands, on UE 5.6, 5.7 and 5.8.
Added
Rig a character from a Skeletal Mesh. Point at a mesh and you get a Control Rig with that skeleton already in place, then build the whole control hierarchy in one call: controls, nulls, sockets and curves, each born with its parent, offset, shape, colour and limits already set instead of created and then patched one property at a time.
Control shapes get sized to the character. Every gizmo is fitted from the mesh actually skinned to its bone, so a wrist ring is wrist sized and a hip ring is hip sized, instead of every control arriving at the same library default size and being dragged by hand.
Build the solve graph. Place and wire nodes in one batch with their values already filled in, add the Construction, Forwards and Backwards solve events, and pull repeated work out into reusable functions so a leg is written once and called for both sides. On a real rig that turned a 122 node flat chain into a 13 node top level graph over 11 functions.
Graphs lay themselves out. Nodes are arranged into readable columns, the small helper nodes feeding a node sit tidily beside it, long wires are routed through knots rather than dragged across the canvas, and each solve event gets its own band. You get a graph you can actually read, not a pile you have to untangle first.
Assemble a modular rig instead of building the graph yourself. Add arm, leg, spine and tail modules from Epic's library, connect them in one pass, mirror a limb to the other side, and rename, reorder, reparent or swap a module without unpicking the rest. You can also author your own module and reuse it across characters.
Pole vectors get placed properly. Knees and elbows need a direction to bend in, and a pole control left sitting on the joint is the one position where the solver cannot tell which way the limb should fold, which is what makes a leg roll or splay as it bends. Poles are now pushed out along the limb's own bend plane, scaled to that limb, so it works on a chicken leg and a dragon leg alike.
Secondary motion: hair, tails, cloth, ears, cables and soft tissue. Add a jiggle chain, and get colliders fitted to the body it rests against, sized from the real mesh rather than a rough guess, so hair swings across a shoulder instead of sinking into it.
Five validation gates that check the rig rather than trusting it. They cover the solve graph, the controls, the gizmo sizes, the deformation (the actual skinning, so melted, sheared or mirrored bones are caught) and the physics. Each returns a plain verdict of pass, pass with warnings, or fail.
Run the rig before an animator does. Play an animation through the rig headless and get back what actually happened: which bones the rig drove, whether limbs crossed through each other, whether anything sank below the floor, how far the result drifted from the input, and whether it blew up. There is also a report on how the rig behaves once it is inside an Animation Blueprint, so you know whether it passes animation through, gates it, or overrides it.
Find dead controls. Ask whether moving a control does anything at all, and the rig is actually driven to find out rather than being read on paper. On one rig the paper check reported nothing wrong while eight controls moved nothing in the viewport. Each flagged control comes with a suggested cure: wire it up, review it, or delete it.
Prove the physics is alive. Shake a control, stop, and keep watching: a plain bone stops dead with its control while a simulated one keeps moving and settles. That is the difference between physics that is running and physics that is silently switched off, which is otherwise very hard to tell apart from a still screenshot.
Animation channels arrive with a usable range. A channel created without one is born with its minimum and maximum both at zero, and the editor and Sequencer feed the slider straight from those, so the slider looks alive and every drag snaps back to zero. You can set the range when you create it.
Measure a character properly. Read a bone's true size from the mesh skinned to it, with the same fit Unreal's own Create Physics Asset uses, and choose between how thick the bone itself is and everything it can move. Also included: preview animation playback, rig profiling, reading and writing any control or channel value, and exporting a whole rig to readable text.
It works on any skeleton. Nothing keys off human bone names, so a quadruped, bird, fish, snake, insect or vehicle rigs the same way a biped does. Sizes and distances are worked out as fractions of the creature's own geometry, so a setting tuned on a human is not a teleport for an insect or a rounding error on a 30 metre dragon.
Changed
Compiling a rig from the CLI now does what the Compile button does. A plain compile skips the modular rig refresh, the pose propagation and the instance restart that the button also runs, which left the live rig on the pre-compile version and made later reads report an empty or stale rig.
Graph layout reads like something a person arranged. A Sequence and the nodes it drives sit together in a tidy column instead of sprawling down the canvas on long diagonal wires, and separate solve events sit side by side instead of stacked. On a real rig that turned a tall thin layout into a balanced one, so you can read both chains without scrolling past one to reach the other.
Long running commands stopped looking broken. Twenty six commands were meant to be given extra time to finish and were quietly using the short timeout instead, so anything run on a big rig or a large batch appeared to fail when it was simply still working.
Fixed
Pole vector placement survives a compile. The offset was written to the live preview copy of the rig, which is thrown away and rebuilt every time the rig compiles, so the pole snapped straight back onto the knee or elbow and limbs rolled sideways the moment they bent. It writes to the saved rig now, and it proves the control moved by reading the saved rig back rather than the copy it just wrote, which is what let the old check pass while the rig was wrong.
IK axis validation actually runs on real rigs. The two bone IK checks were skipped whenever the axis arrived through a wire, which is always the case once the IK lives in a reusable function. Since that shape is the recommended one, the check was silently off on exactly the rigs that needed it, and a rig with two limbs rotated a full 180 degrees passed clean with no warnings. It now checks every place the function is called and names the limb that is wrong.
Fitted gizmos were ten times too large. The fitter applied the shape library's own scale twice, so every automatically sized control came out badly oversized, and the checker made the same mistake and agreed with it. Both were corrected together, so the sizes and the check that grades them finally match.
Controls stopped being sized off the wrong bone. A control was matched to whatever bone was nearest with no sanity test, so a body control could be sized from a toe less than a centimetre across. IK controls parented under a tidy organising folder, which is normal rigging practice, were also misread as top level and sized to the entire character.
A bad control colour is no longer accepted in silence. Colours written in a form the engine could not read were reported as success while leaving every control default red, or black. Both are rejected now with the valid forms listed, and a rejected colour leaves the existing one alone.
Graph building tells you when it changed your names or your wiring. If a node name was already taken the engine quietly renamed it while you went on wiring the original, and connecting to part of a pin silently disconnected the whole pin feeding it, leaving the rest on defaults. That one mirrored a foot to the wrong side of a body. Both are now reported.
The physics check stopped failing correct rigs. It judged bodies as about to roll over from the joint limits alone and ignored the drive holding them in place, which is exactly how Epic's own chain physics ships, so every correct chain physics rig failed its own gate and the fix it suggested was not even reachable. One rig went from fourteen false alarms to none.
Hair hanging normally is no longer called broken. Gravity drape was measured against a fixed distance, which cannot tell a long braid from a short chain, so normal hanging read as a critical failure. It is now judged against the chain's own length, since a chain cannot travel further from its anchor than it can reach. Genuine breakage is still caught, loudly.
Hair resting against a back is no longer reported as buried inside it. The body was measured with a deliberately generous shape that bulges well outside a wide flat bone and swallowed the empty space behind it, turning contact into hundreds of phantom overlapping points. Real overlap is still caught, and light contact is now called grazing rather than failure.
The movement check stopped failing every rig. Some markers in Epic's own skeletons are not meant to move, and an IK hand or foot correctly stays put while the body moves around it, so both were being reported as stuck. It now groups them together, treats it as information rather than a failure, and singles out the one case that really is a bug.
Module connection no longer reports failure on a healthy rig. The engine clears its result flag for any unmatched optional connector, so a fully connected rig came back as failed. Success now means the pass ran, with anything genuinely missing listed separately so a real problem still stands out.
Gizmo fitting can no longer paint itself into a corner. Torso rings were pulled toward the average size of the torso, which on a wide bone could push the gizmo under the size the checker demands, producing a control called buried where the recommended fix could never satisfy it.
Reroute knots stopped sprouting on short, ordinary wires. The router measured node widths differently than the layout did, so it read a normal left to right connection as running backwards and sent it on a loop below the graph. On one rig that removed seven of nine knots, leaving only the two that were genuinely earned.
Validation now looks inside functions. It only ever read the top level graph, so nothing inside a reusable function was checked, and controls used in there were reported as never used. That produced dozens of false warnings on a well structured rig and pushed you toward flattening the very structure that makes it readable.
Physics probe reports are tied to a rig. The result is shared, so asking for it while thinking about a different rig used to hand back the other rig's numbers without a word. Name the rig and a mismatch is an error instead.
v1.2.44
Fixes the plugin failing to load on Unreal 5.8 with a "module could not be loaded" error (GetLastError 126) on projects opened with the stock launcher engine.
Changed
The four Insights profiling backends (World Streaming, Render Trace, IoStore, and Chaos locks) are read on demand instead of being linked into the plugin. The matching profiling queries still work when those engine plugins are enabled, and just return a short "enable this plugin" note when they are not, rather than ever stopping the editor from opening. Verified opening cleanly on 5.6, 5.7, and 5.8.
Fixed
The plugin no longer fails to load on Unreal 5.8. On projects opened with the launcher-installed engine, the editor could stop at startup with "Plugin CodeFizzEditorAgent failed to load because module could not be loaded", pointing at a missing WorldStreamingInsights import even though that file was present. The cause was that the plugin hard-linked a couple of experimental profiling plugins that ship turned off in the stock editor, so their DLLs were never on the load path. It now reads those profiling providers without linking their DLLs at all, so there is nothing left to go missing.
v1.2.43
Materials get a production pass: build a whole material function in one call, errors that name the valid pins and types, smarter pin matching, cleaner auto layout, and richer JSON export for functions and function instances.
Added
Material functions are ready to compile the moment you make one. Every new function comes with its output node already in place (the same one the editor adds on first open), so there is no more reading it, deleting it, and recreating it. If you build a function graph without an output, one is created for you and reported back.
Connections can target a function's output or a named input directly. Write "output", "output:Name", or "input:Name" in a connection instead of hunting for the node index.
Material function interface and comments are now in the JSON export, and material function instances export as a first class asset with their parent and overrides. So you can read any material, function, instance, or function instance as text and see everything about it.
Changed
Building a material or material function checks every node type before it touches the existing graph, so a typo can never wipe a graph you meant to keep.
Pin names match more forgivingly. Writing "Position" connects to a node's "World Position" pin and "Coordinates" connects to a texture sample's UVs, while a genuinely ambiguous name still stops and lists the choices.
Reading a material function is adjustable now: ask for just the interface, a summary with node counts, or the full node list, so you only pull what you need.
Auto layout keeps the final output node on the right, gives each unconnected branch its own row, and parks stray nodes off to the side, so a laid out graph reads cleanly.
Fixed
Assigning the wrong type to a material property or a function input returns a clear error listing the valid values, instead of silently accepting a wrong default.
A failed connection tells you exactly which input pins are valid on the target node, so you fix it in one step instead of guessing.
v1.2.42
The profiling system grows up: thirteen new analysis queries reaching into memory callstacks, per actor network bandwidth, Mass ECS, animation, and physics, plus a long list of hardening fixes so every query is safe to run and every error tells you what to do next.
Added
Allocation history queries (alloc_query). Ask questions like "which callstacks hold the most live memory" or "what was allocated between these two bookmarks and never freed", the same investigation Unreal Insights does in its memory tab. Results group by callstack with resolved function names when the trace was recorded with callstacks.
Per actor network bandwidth (net_objects) and per packet detail (net_packets). See exactly which replicated actors eat your bandwidth, packet sizes over time, bursts, and drops. Built for multiplayer tuning.
Mass ECS profiling (mass). Fragment and tag registry with sizes, entities created and destroyed over time, archetype churn, and processing phase timings, read straight from the Mass trace channel on both 5.7 and 5.8.
Skeletal animation profiling (animation). List every animated object in a trace, then drill into blend weights per asset, anim graph phase cost, notifies, and montage playback.
More new queries: memory_series (one memory tag over time with start to end delta), stack_tree (a weighted call tree from CPU samples), cook (per package cook timings), iostore (pak reads per package), chaos_locks (physics lock contention), world_streaming (World Partition cell churn, 5.8), render_trace (RDG pass pipeline, 5.8), and trace_channels (which channels a trace actually recorded, the first thing to check when a query comes back empty).
Changed
Every list a query returns is now capped with a clear "showing X of Y" note, so a trace with two thousand counters can never flood the output. Errors name valid alternatives: a wrong category lists the categories, a wrong thread lists real thread names, an unknown query lists every query.
Queries that target a frame (hotpath, compare, frame_details, inspect_frame) now default to the worst frame instead of failing when no frame index is given.
Fixed
The loading and file_io queries never returned data because the engine ships their analysis module disabled. It is now enabled, so asset loading and disk activity work out of the box. The same fix covers cook.
Asking for a call tree of a timer that exists but never ran used to return an empty tree full of zeros, which read like "this costs nothing". It now says the matched timer has no recorded instances and lists similar timer names that do.
A crash inside Unreal 5.8 itself: analyzing a mid session trace that contains rendertrace data asserts in the engine and takes the whole editor down. The plugin now keeps that analyzer off by default so loading any trace is safe, and render_trace explains how to opt in for traces recorded from startup.
Memory leak checks no longer give a false all clear when LLM was not running, network stats no longer return an empty success when there is no network data, and a dozen smaller cases where an empty result looked like a real answer now explain what was missing and how to record it.
v1.2.41
Full support for curve assets: float, vector, and color curves, curve tables, and curve atlases, all created and edited straight from the editor with careful protection against bad input.
Added
Create and edit Curve assets: float, vector (x, y, z), and linear color (r, g, b, a). You can set every key the way the curve editor does, with per key interpolation (cubic, linear, constant), tangent modes (auto, smart auto, user, break) and explicit tangent slopes, weighted tangents, pre and post infinity extrapolation, and a default value. You can also merge keys into an existing curve, delete keys by time or clear them, and evaluate the curve at any time to check the result.
Create and edit Curve Tables, including Composite Curve Tables that stack other tables. Add, update, delete, and rename rows, with rich curves (per key interpolation) or simple curves (one interpolation per row). Read any row back with its keys and evaluated values, or export the whole table.
Create and edit Curve Atlases from linear color curves, with resize, add, remove, and replace. The atlas texture rebuilds and any materials using it refresh automatically, just like editing it by hand.
Full fidelity import and export. Read a curve or table as the engine's own JSON and re import it exactly, or work in plain CSV. Ease Curve Libraries are supported too (on the engine versions that ship them).
Fixed
Bad input can no longer corrupt your data. Every value in a request is checked before anything is written, so a typo in one key never leaves a curve half rewritten, and an import that fails restores the previous data instead of clearing it. Oversized atlas sizes, reserved row names, and JSON from the wrong curve type are all caught with a clear message, and the editor is never left in a bad state.
v1.2.40
Blueprint Interfaces and Function Libraries land, every function property is now editable, and graph auto layout routes wires much more cleanly.
Added
Full Blueprint Interface support. Create an interface asset, add its functions the same way you add any function, implement the interface on any Blueprint class, list what a Blueprint implements, and remove an interface again (optionally keeping its generated functions as normal ones). When you implement an interface, the response tells you exactly what to do next for each function: void functions become placeable event nodes, and functions with a return value arrive as ready-made function graphs.
Two new graph node kinds for interfaces. interface_event places the event for an implemented interface function, and interface_call places a message call that invokes an interface function on any object, safely doing nothing at runtime if the target does not implement it.
Blueprint Function Libraries. Create a library asset whose functions compile as static and can be called from any Blueprint in the project.
A new set_function_properties command that edits any function the way the Details panel does: pure, const, exec, access specifier (public, protected, private), category, tooltip, keywords, and every editor metadata field such as compact node title, call in editor, thread safe, and deprecation. The same options can be passed when creating a function, and function details read all of it back.
A reparent_blueprint command that changes a Blueprint class parent, refreshes every node, recompiles, and reports the real compile diagnostics.
Changed
Graph auto layout places far fewer reroute knots and routes them much more intelligently. Wires fanning out from one pin now share a single clean bus instead of stacking a pile of knots, loop wires travel on one clear lane above everything they cross, short backwards wires stay as normal splines instead of circling the whole graph, and knots no longer land on top of nodes. Re-running the arrange command stays stable instead of accumulating knots.
Graph analysis now reports when a node is Development Only or disabled, so an agent reading the graph sees the same state you see in the editor.
Fixed
Nodes for development-only functions such as Print String now show their Development Only banner the moment they are placed. Before, the banner only appeared after restarting the editor.
A failed graph build could delete a function entry or return node while rolling back, leaving the function gutted. Rollback now never touches nodes that already existed before the build.
Creating a function with a return type silently produced a void function. The requested return value is now actually applied.
Function graphs created by implementing an interface were invisible to graph targeting, analysis, and function details. They now resolve everywhere a normal function does.
Closing the editor or deleting an asset while a Blueprint graph right-click menu was open could crash the editor. Open menus are now dismissed first, and deleting an asset closes any editor that has it open.
v1.2.39
Right-click any asset in the Content Browser and export it to JSON. One click writes the asset as reflection JSON to your Saved folder and opens the folder for you.
Added
A new Export to JSON (CodeFizz) item in the Content Browser right-click menu. Select one or more assets, and it writes each one as reflection JSON into Saved/CodeFizzEditorAgent/Exports, then opens that folder. It produces the same complete export the export_asset command does, so Blueprints, materials, PCG graphs, data tables, textures, and any other asset are all covered, with a human readable text version written alongside the JSON. Selecting several assets exports each of them and opens the Exports folder once. A short notification tells you how many were written. Both the plugin and the CLI take the exact same export path, so what you get from the right-click matches what an agent gets from the command. It works the same on Unreal 5.6, 5.7, and 5.8.
v1.2.38
License messages in the editor now point at browser account login. Run cfa login, sign in on the website, then click Refresh. No key paste in the editor.
Changed
When the plugin is not licensed, the Settings license panel tells you to run cfa login from the terminal. That opens your browser so you can sign in with your CodeFizz account, then click Refresh in the panel. The shared license file is the same as before, so once the CLI has activated this machine the editor picks it up without pasting a key.
Status messages for offline grace end, revoked keys, deactivated machines, machine mismatch, seat limits, and missing trials or subscriptions all say cfa login (browser) instead of cfa login --key. You can still use a key with the CLI if you need to, but the default path is account sign in.
v1.2.37
Materials are now first class from the tool. Read the material slots of any mesh and assign materials per slot, on placed actors and on Blueprint component defaults alike, and property edits show in the viewport right away.
Added
A new command to read material slots. Point it at a placed actor, a Blueprint, or a static mesh asset and it lists every mesh component and each of its element slots, with the slot name, the material currently on it, and whether that slot is an instance override or the mesh default. It works the same for static, skeletal, and instanced meshes, so you can see exactly what a model exposes before you change anything.
A new command to assign materials by slot, one target or many in a single call. Set a material on a specific slot, by slot name, or on every slot at once, on a single actor, on all actors matching a name prefix, or on a Blueprint component default. Setting it on a Blueprint applies to the class defaults and carries through to the instances you place, and you can still override an individual placed actor afterward. Pass an empty material to clear a slot back to the mesh default. A wrong slot is refused with the valid slot indices and names, so a mistake tells you how to fix it.
Fixed
Setting a property on a placed actor now updates the viewport immediately. Before, changing something like a component material through set_actor_property saved the value but the change did not show until the component was touched again, because the edit did not refresh the render state. It now runs the same pre and post edit path the Details panel uses, so the change appears at once.
The default scene lighting no longer triggers the on screen warning about cached lighting being clipped. When a lighting preset uses a strong manual exposure, the tool now matches the cached lighting pre exposure to that exposure, so Lumen and the real time sky capture stay in range and the red warning does not appear.
v1.2.36
The editor agent no longer pulls its editor only tools into your packaged game. It is an editor tool, so its plugin dependencies are now scoped to editor builds and are left out of shipping builds.
Fixed
The plugin now marks its dependencies (Movie Render Pipeline, the Python plugin, and the other plugins it uses only inside the editor) as editor only, so enabling the editor agent no longer forces them into a packaged game. Before, because the dependency list had no target restriction, installing this editor tool quietly enabled its editor dependencies, and their runtime modules, for game builds too, so they ended up compiled into shipping builds. The editor module itself was always editor only, this closes the remaining path where the dependencies leaked. Plugins your own project uses, like Enhanced Input, Niagara, PCG, or StateTree, are unaffected. They stay in your game because your project enables them, not because of this tool.
v1.2.35
Author and render cinematics from the command line. A full Sequencer command family builds a Level Sequence end to end, animates it with keyframes, points a camera at it, and renders it to an image sequence, and it now works the same on Unreal 5.6, 5.7, and 5.8.
Added
A complete Sequencer command family (about 65 commands) to build and render cinematics without opening the Sequencer panel. Create a Level Sequence, set its rate and playback range, add bindings, add tracks and sections, keyframe transforms and properties, add a camera and a camera cut, then render the shot through Movie Render Queue to a PNG sequence you can encode to video. Every step is addressable and queryable, so you can read a binding, evaluate the animated value at any frame, and scrub the timeline.
Self contained sequences using spawnables. Bake a configured object (a light, a mesh, a camera) into the sequence as a spawnable, and it spawns its own content in any level, so what you see when you scrub matches what the render produces, with no missing or red bindings. This is the recommended way to build a demo or a showcase that stays consistent and shippable.
Rich animation: keyframe a light color and intensity through a component binding, play an animation on a skeletal mesh, animate transforms, and shape the curves with interpolation, tangents, and extrapolation. Plus audio tracks, subsequences, folders, timeline markers, and a global time warp on 5.8.
Wrong operations are rejected with the valid options instead of failing quietly. Adding a skeletal animation to a light is refused by name, a mistyped property suggests the closest match, a bad channel lists the valid channels, and a component that does not exist lists the ones that do. So a mistake tells you how to fix it.
Fixed
The plugin now packages cleanly on Unreal 5.6. The Sequencer commands were rebuilt on the core Movie Scene modules so they no longer depend on editor only modules that are not available to link in the installed 5.6 engine, which previously failed the 5.6 package with unresolved symbols. All three engines, 5.6, 5.7, and 5.8, now build and behave the same.
v1.2.34
Safer project settings edits: assigning a class or asset that does not exist, or that is the wrong type, is now caught with a clear error, and a Blueprint class is stored in the correct form.
Changed
Class settings now say clearly whether a value could not be found or is the wrong type, and asset settings point you at find_assets to locate a valid one.
Fixed
Assigning a Blueprint class to a class setting like the Game Instance class or the Default Game Mode now stores the generated class path (the one with the _C suffix), the same value the editor stores. Before, passing the plain Blueprint asset path saved a reference that does not resolve to a class at runtime. You can pass it with or without the _C now, either way it is stored correctly.
Assigning a map or asset that does not exist to a setting like the Game Default Map is now rejected with a clear error, instead of being accepted silently and failing to load at runtime. Assigning an asset of the wrong type, for example a Blueprint where a World is required, is rejected too, matching what the settings picker allows.
v1.2.33
Read and edit any Project or Editor setting from the command line through reflection, and have it written to the right Default config file exactly the way the editor Project Settings window does.
Added
Three new commands, search_project_settings, get_project_settings, and set_project_settings, drive the whole Project Settings tree. Search finds the section you mean and tells you which Default config file it writes to, get returns every property with its current value and what it accepts, and set changes one property or a batch and then saves it to the correct file, DefaultEngine.ini, DefaultGame.ini, and so on. It goes through Unreal own settings registry and property reflection, so nothing is hardcoded per setting, and Maps and Modes, Collision, Rendering, Asset Manager, Data Driven CVars, and any custom developer settings all work the same way. Console variable backed settings save under their real variable name, the same as the editor.
Full collision setup from the terminal: add object channels and trace channels, add collision presets, and edit a preset responses, for example set the Camera response on a preset to Block or Ignore. Everything is written to the config and is live in the editor, so a new channel or preset shows up in the collision dropdowns without a restart.
Errors tell you what a property actually wants. Assign the wrong class to a class property, like a Character where a Game Instance is required, and it names the base class it needs. Give an enum value that does not exist, even one nested inside a struct, and it lists the valid values. Mistype a property name and it suggests the closest matches.
Changed
Settings edits now fire the same change notification the editor details panel uses, so a setting rebuilds its state exactly like a manual edit. Settings are also reachable by class name even when their Project Settings page has not been opened yet, so a section that registers late is never missed.
v1.2.32
Level lifecycle and lighting from the command line: create, open, and save a level, read the New Level templates, and drop a full lighting setup in one call with physically grounded presets for clear, noon, sunset, overcast, snowy, and night.
Added
create_level makes and opens a level, either blank, a World Partition open world, or from a template like Basic or Open World. open_level opens an existing map, save_level and save_level_as write it, and list_level_templates returns the same entries the editor New Level dialog shows with their real template map paths. These mirror Unreal own level tools, so nothing is hand rolled. Creating or saving rejects engine and other read only paths so a map cannot land in the wrong place, and opening a map that does not exist reports a clear error instead of silently doing nothing.
setup_default_scene drops a ready to light environment into the current level in one call: the sun as an atmosphere light, a sky atmosphere, a real time capture sky light, height fog, and a floor, all filed under an Environment folder, so a fresh empty map is viewable right away. Options add volumetric clouds, an unbound post process volume, and a player start.
setup_default_scene takes a preset, clear, noon, sunset, overcast, snowy, or night, and applies a physically grounded grade on top of the rig. Each preset sets the sun angle and a real world intensity in lux, the sky atmosphere and fog, and a fixed manual exposure on the post process volume, so the look is the same in any project and nothing in the project settings is touched. It follows Unreal own outdoor lighting rules, a neutral light temperature that does not fight the sky color, subtle fog, and cloud coverage driven from the cloud material instance rather than reinvented.
v1.2.31
A set of level design commands: place a whole layout at once, understand a level as a compact clustered summary instead of a giant actor list, read a mesh true shape before placing it, aim the viewport from any angle, and organize the outliner with folders, groups, and parent-child attachment.
Added
get_mesh_info reads a static mesh asset native bounds, its pivot offset (where the pivot sits relative to the mesh, so you know if it is centered or at a corner), and its real collision shape (convex hulls with vertex counts, boxes, spheres, capsules), plus sockets and vertex, triangle, LOD, and material counts. So a wedge reads as a wedge and placement is planned from the mesh true size and pivot rather than guessed.
spawn_actors_batch places a whole computed layout, hundreds to thousands of actors, in one call and one undo step, caching each mesh so a shared-mesh batch loads it once. delete_actors_batch removes a batch by name prefix or list, so a layout can be reverted in a single call.
get_scene_map now returns a clustered, context-friendly summary of the level instead of a flat per-actor dump. Actors are grouped by mesh into spatial structures, each tagged with its arrangement (grid, ring, line, or scattered), count, bounds, and outliner folder, with an ASCII density map of the whole level, and a drill option to page through one cluster raw actors. It scales from a handful of actors to very large levels without flooding the reader, and a label filter isolates a group you placed.
capture_top_down renders an orthographic floor plan of the level to a PNG off screen, auto fitting to the placed content and dropping atmosphere and fog, which reads a layout far more clearly than a perspective screenshot.
focus_viewport can frame an actor from a chosen direction (top, bottom, front, back, left, right, iso, or an exact pitch and yaw) at a set distance or fill fraction, not just the default framing.
Outliner organization and hierarchy: move actors into folders and create, rename, delete, and list folders, group and ungroup actors, and attach or detach actors as a parent-child transform hierarchy so moving the parent moves the children. The folder commands resolve a folder real identity on World Partition maps, so they remove and rename correctly there.
v1.2.30
A new export_statetree command writes a whole StateTree to one JSON file, everything about how it runs in one place, and the Blueprint export now includes the class defaults a Blueprint overrides, so a character export shows its AI controller and a controller export shows the StateTree its component runs.
Added
export_statetree writes a full JSON export of a StateTree. It captures the schema, the theme colors, the tree parameters with their values, and the whole state hierarchy, and for every task, condition, evaluator, consideration, and global task it records whether the node is C++ or Blueprint, its C++ struct path or its Blueprint asset path, the values on it, and the property bindings feeding it (both on the node itself and as a full binding table).
Every state in the export carries its resolved color (display name, RGBA, and hex), its type, selection behavior, tag, and description, and its full transitions with their triggers, priorities, delays, target states, and the conditions on each one.
The Blueprint export has a new class defaults section that lists the inherited properties a Blueprint overrides, like a character Auto Possess AI and AI Controller Class, so cross references between assets are visible: a character points at its controller, and a controller StateTree component points at the tree it runs.
Changed
StateTree reads now report each node identity: whether it is a C++ or a Blueprint node, the C++ struct path, and for a Blueprint node the asset path and its exposed pins, so it is clear what every task and condition actually is and where it comes from.
v1.2.29
You can now author a complete StateTree AI from the command line, the custom Blueprint task and condition nodes, the tree with its parameters and bindings, and assigning it to a component, plus a new command that sets properties on a Blueprint component template, which the class defaults could not reach.
Added
set_blueprint_component_property sets a property on a component inside a Blueprint (the ones in the Components panel), both components added in the editor and native C++ ones. It reaches things set_blueprint_class_defaults cannot, like the mesh on a Static Mesh Component, takes a single property or a batch, and recompiles so already placed instances pick up the new default.
override_blueprint_function implements a parent class event or function the way the My Blueprint Override menu does. A plain event becomes an event node, and one that returns a value (like a StateTree test condition) becomes a function graph with the entry and result nodes ready to wire.
Tree parameters can carry a value now. add_statetree_parameter takes a value, and a new set_statetree_parameter updates one later, so a global like a sight range or a speed is a real number instead of being stuck at zero.
add_component_to_blueprint can set initial property values on the new component in the same call.
Changed
set_statetree_component_tree assigns a StateTree to a StateTree or AI component, on a placed actor or on a Blueprint, syncs the parameter values, and reports the tree schema so a mismatch shows up right away.
set_statetree_node_property can write the values on a Blueprint task or condition node, so a custom node can be configured differently at each place it is used.
Fixed
create_blueprint saves the new asset right away, so a freshly created Blueprint is not lost if the editor closes before the next save.
v1.2.28
A new export_niagara command writes a whole Niagara system, or a single module, dynamic input, function script, or emitter, to one JSON file. It is the fastest way to read and understand an effect, everything in one place grounded in the engine reflection, instead of clicking through the editor or running a dozen separate queries.
Added
export_niagara writes a full JSON export of any Niagara asset. For a system it captures the system properties, the user parameters with their default values, every emitter (its properties, renderers, and the ordered module stack of each stage), and the values set on every module input. It auto-detects whether you point it at a system, a module or dynamic input or function script, or an emitter.
The full module screen is exported for every script, the category, the module usage bitmask (with the usage flags spelled out), the library visibility (exposed, unexposed, or hidden), the suggested flag, the provided and required dependencies, the note message, the description, the keywords, and the numeric output selection mode. The module inputs and outputs are listed as a clean contract as well.
Dynamic inputs are captured at the place they are used, showing which dynamic input it is (name and path), what type it outputs, and the values set on its own inputs, including nested dynamic inputs. Scratch pad and other in system local scripts are exported in full with their node graph and their custom HLSL.
Changed
Modules and dynamic inputs that live as their own asset (the engine ones or your own) are referenced by path with their description and their input and output contract, rather than copying the full node graph into every place they are used. That keeps a system export small (around a megabyte instead of six) while still saying exactly what is used and where, and you can export any of those assets on its own to see the internals.
v1.2.27
Niagara authoring, revamped. Building an effect from nothing (custom script modules, dynamic inputs, emitters, renderers) is now reliable end to end: scripts compile and apply themselves, values you set actually stick, and the two most common ways a generated script can fail to compile are caught up front.
Added
build_niagara_graph now finalizes the script for you. After building the node graph it compiles and applies the module, dynamic input, or function in the same call, so the script is immediately usable in an emitter stack instead of sitting there uncompiled. You can turn it off per call if you want to batch.
Guardrails for the two HLSL mistakes that used to fail deep in the Niagara VM compile with a cryptic error. Writing Particles.Position with a plain Vector type is now auto-corrected to the proper Position type (with a warning telling you it happened), and using the integer modulo operator in custom HLSL warns up front, since the Niagara VM does not allow it (use fmod instead). Well-known particle and engine attributes are type-checked against the engine list of known attributes.
Adding an emitter or a module twice no longer stacks duplicates. add_niagara_emitter and add_niagara_module now detect an existing emitter with the same name, or the same module script already in that stage, and report it instead of adding it again. A force_add option keeps the old behavior for when you really want two.
The Niagara preview viewport refreshes on compile. If the asset is open in the editor, compiling through the tools resets the simulation so you see the new behavior immediately, no need to close and reopen the asset.
Fixed
set_niagara_module_input no longer lies about success. It used to write module values to a store that the very next recompile regenerated from the graph, so the call returned success but the value silently reverted to the default. Values now go through the stack override, the same place the editor UI writes, so they survive recompiles and read back correctly.
pin_defaults on set_niagara_dynamic_input actually sets the values now. It used to write to node pins that do not exist on modern dynamic inputs, leaving every nested input at zero. The defaults are now applied through the stack after the dynamic input is wired in, and the response reports how many were applied.
Module input listing works for custom script modules. get_niagara_modules used to show only the input map for modules built from your own scripts; it now enumerates the real module inputs with their names and types, the same list the stack UI shows.
Fixed an editor crash when spawning an actor with the same name as one deleted moments before. Unreal asserts fatally on the name collision until the deleted actor is garbage collected; spawn_actor now asks for the name instead of requiring it, letting the engine pick a free one, and sets the label you asked for on top.
v1.2.26
Fixed
Fixed a crash on Unreal Engine 5.7 when reading per-object property data. The objectproperties query could hard close the editor on 5.7, because the GameplayInsights provider there does not support the per-provider read lock that 5.8 uses. It now reads under the session lock on 5.7 and works the same as on 5.8. Only 5.7 was affected, and only when object property tracing was in use.
v1.2.25
Full performance profiling arrives. Record an Unreal Insights trace from the running editor and analyze it in place: frame timing, CPU hot paths, GPU cost per pass, memory, and more, plus a live frame-rate sampler that needs no trace.
Added
Trace recording and analysis, built in. Pick what to capture with channels and named presets, record a trace from the running editor, then run analysis queries for frame timing, CPU self time, GPU cost, memory, loading, and tasks, all without leaving your tools.
GPU per-pass breakdown. The self (exclusive) time of every named GPU pass, the same ones stat GPU shows (the base pass, Lumen, shadow depths including virtual shadow maps, ray tracing, post processing), read straight from the trace so the names follow your engine version and include your own passes.
A live multi-frame stats sampler. Frame rate and game, render, RHI, and GPU thread milliseconds averaged over many frames with a 1% low, no trace and no stat unit needed, so a single odd frame cannot mislead you.
Per-object property tracing. Register an actor, record its property values every frame, then read the history back by actor name or by id.
Channel discovery and live control, bookmarks, snapshots, and screenshots into the trace timeline, and Play In Editor start and stop so you can profile real gameplay instead of an idle editor.
v1.2.24
The toolbar now tells you when a new version is out. The CodeFizz button turns amber when a newer plugin or CLI is available, and the panel shows what you have versus the latest, with the commands to update.
Added
The CodeFizz toolbar button warns you when an update is waiting. When your license is active but a newer plugin or CLI has been published, the status icon turns amber instead of green and the tooltip says an update is available. A license problem still shows red, and everything current still shows green.
An Updates section in the panel that lists your installed plugin and CLI versions next to the latest published ones, marks anything out of date, and shows the exact commands to update (cfa update-all for the plugin, the npm command for the CLI), with a link to the changelog. It checks a few seconds after the editor starts, again every hour, and whenever you open the panel, so it stays current on its own without slowing startup.
v1.2.23
Building onto an existing blueprint or PCG graph through the bridge now adds the new nodes below what is already there, and the nodes you placed yourself never move. The graph grows down the page as you add to it, instead of getting wider and wider or rearranging on you.
Changed
When you build onto a PCG or blueprint graph, the new nodes are now placed below the existing content instead of off to the right. The graph grows downward as you keep adding to it (rather than stretching endlessly wide), and each new batch stacks under the previous one with a sensible gap, left aligned with the rest of the graph.
Fixed
Building a PCG graph no longer rearranges the whole graph. It used to lay out every node on each build, which moved nodes you had positioned by hand. Now it only places the nodes it just added and leaves everything else exactly where it was.
v1.2.22
PCG graph auto-layout, plus the open graph now updates live and in place on Unreal 5.6, 5.7 and 5.8. Build or lay out a PCG graph through the bridge and the nodes rearrange in front of you, with reroutes threaded onto the long wires, and no closing and reopening of the asset editor.
Added
Auto-layout for PCG graphs. It sorts the nodes into clean left to right columns the way the engine does its own layout, keeps straight one to one chains straight, sizes each column from the real node widths when the editor is open, and drops reroute nodes onto the wires that skip a column so the graph stays readable.
Live, in place updates for an open PCG graph on every supported engine. After the bridge changes the model (adding a node, wiring a pin, laying out, inserting reroutes) the open graph rebuilds its view from the model right away, so you watch the change happen instead of finding out about it later.
Fixed
A PCG graph no longer looks stale or empty after an edit on 5.6 and 5.7. Those versions had no built in way to refresh an open PCG editor from an outside change (only 5.8 did), so edits seemed to do nothing until you reopened the asset. The plugin now rebuilds the open editor view itself using only public editor graph calls, and it only ever touches the throwaway view copy, so the saved asset is never changed and your comments are kept.
v1.2.20
A round of fixes from real usage: user widgets resolve by their plain name, a material instance gives a clear message instead of a not found error, color fields take a plain color value, graph nodes carry one stable id everywhere, and a node can be described without a blueprint.
Changed
The graph analysis lists a stable node id for every node and for both ends of every connection, the same id the export and the pin links already use, so a node has one identity across all the commands instead of three different ones.
A node can be described by its class and function without passing a blueprint to host it. A throwaway context is created for the lookup, and a blueprint is only required when you describe a node by its search id.
Fixed
Adding a user-made widget (a Widget Blueprint) by its short name works now. Native widgets like Text Block always resolved by their plain name, but a name like WBP_MaterialButton failed unless you passed the full generated class path. It now resolves the plain name to the right class whether the widget is loaded or not, and still accepts the full path and the asset path.
Asking for material info on a Material Instance no longer comes back as Material not found. It now says the asset is a Material Instance and points you at the material instance parameters command, so a valid instance is never mistaken for a missing asset.
A color field that stores a styling rule, like a Text Block color, accepts a plain {R,G,B,A} object or an [r,g,b,a] array now, the same simple form every other color takes. The longer specified-color form still works, and an invalid field is still reported as an error instead of being silently accepted.
v1.2.19
The editor can be closed from the agent the same way you close it by hand, with a choice to save first or discard.
Added
You can now close the editor the same way File > Exit does, instead of killing the process. It either saves every unsaved map and asset first or discards the unsaved changes, whichever you ask for, and then runs the engine's normal shutdown so nothing is left half-written. The save and confirm popups are skipped, and only the editor you are connected to closes, so any other editors you have open are left alone.
v1.2.18
The agent chat box wraps long lines instead of running them off the edge.
Fixed
A long line typed or pasted into the chat box now wraps onto as many lines as it needs and re-wraps as you resize the panel, instead of stretching into one endless line behind a horizontal scrollbar. Even an unbroken run with no spaces, like a long asset path or URL, breaks to fit the width.
v1.2.17
A large materials expansion lands, with a complete material export, layered materials, parameter collections, function instances, fuller material instances, and a real material graph auto-layout, alongside a deeper semantic Blueprint export, MVVM in the widget export, and a pass of graph edit validation that refuses the edits the editor itself would not allow.
Added
The editor can export a material as one complete document. A single export carries every parameter (scalar, vector, texture, static switch, runtime virtual texture, sparse volume texture, and font) with its group, sort order, description, and slider range, the layer stack, the textures and material functions each node references, which node ultimately drives each material output, and a full settings block built by reflection that lists every editable property the Details panel shows, so it never goes stale. A material instance lists only the parameters and base settings it actually overrode, with an option to include everything inherited from its parent.
Layered materials. A base material or a material instance can have its whole layer stack set and read back, built from a background layer and the blend functions between the layers. A layer or blend path that fails to load comes back as a warning instead of silently leaving an empty slot.
Material Parameter Collections. Create a collection, add or update its scalar and vector entries, read them back, and remove one. A material instance also reports the group, sort order, and slider range next to each of its parameters now.
Material function instances. Make an instance of a material function, override its scalar, vector, and static switch parameters, and read the parent, base, and overrides back. Material functions can also be created as layer or blend functions for use in a layer stack.
Fuller material instances. Component mask, runtime virtual texture, and sparse volume texture parameters can be set, an instance can be reparented, and a single overridden parameter can be reverted to the value it inherits from its parent.
A real auto-layout for material and material function graphs. Nodes are placed by data flow with the ones feeding the output on the right, and long or crossing wires are routed through reroute knots, the same way Blueprint graphs are arranged.
The editor can export a Blueprint as a semantic document an AI can read like source. Every function and event comes out as a first-class entity with a clean signature, the local variables it declares and where each is read and written, the member variables it touches, the functions and macros it calls, and its event dispatcher work, and each dispatcher is listed with every place it is broadcast, bound, or cleared across all the graphs. Event bodies are followed along their execution flow, so two events linked by a dispatcher bind are never merged into one.
Widget Blueprint export now includes the MVVM layer: the view models, the bindings with both ends resolved to a view model, widget, or self along with the conversion functions they use, the older designer bindings, and a short note on each widget for which bindings drive it.
New authoring for event graphs and local variables. A Blueprint can have a secondary event graph created, renamed, or deleted, nodes can be built into a named graph instead of only the default one, and a function can be given real function-local variables that get and set nodes then use.
Changed
Material edits are addressed by a stable node identity now, so an edit lands on the right node even after other nodes are added, deleted, or reordered, and every place that lists nodes hands that identity back.
Connecting material nodes is more forgiving. A node with a single input, like a function output or a One Minus, can be wired by its output name instead of the connection silently failing, so a function whose output was left unconnected now connects.
The MVVM binding commands refuse a binding the engine would reject before creating it, like a two-way binding that needs a forward-only conversion, and report the binding that actually persisted rather than leaving one that quietly fails to compile.
Editing a material refreshes an open Material Editor consistently and marks the asset dirty whether the editor is open or closed.
Fixed
Fixed an editor crash while exporting a material that uses hidden output pins, such as a post process, UI, light function, decal, or volume material, or a Substrate material, where reading a hidden pin came back null.
The Blueprint export no longer reports phantom events. The editor's greyed-out, never-called event suggestions were being written out as real events, which produced duplicate handlers, and an event dispatcher was being listed both as a variable and as a dispatcher. A dispatcher appears once now, signature types read the same as everywhere else, and each graph is tagged so a function and an event graph with the same name are never confused.
The graph commands now refuse edits the editor itself does not allow, instead of producing a broken Blueprint. A custom event, an input event, a timeline, or a latent node like Delay can no longer be dropped into a function or macro graph, a new variable, function, event, or dispatcher cannot take a name already used by another member or inherited from the parent class, retyping a variable to a type that does not exist is reported as an error, and the function entry and result nodes can no longer be deleted out from under a graph.
v1.2.16
Material edits can be committed to the asset the way the editor's Apply button does, so changes made with the Material Editor open no longer sit on the preview copy.
Added
The editor can apply a material the way the Apply button does. Edits made through the bridge land on the Material Editor's transient preview copy, so with the editor open the asset stayed stale and the Apply button stayed lit. It now marks the material dirty and runs the editor's own Apply command, which copies the preview back onto the asset, recompiles the shaders, and switches the Apply button off, the same as pressing it by hand. With the editor closed, where there is no preview, it recompiles the asset directly.
Changed
Because it goes through the editor's real Apply command rather than reaching into editor-internal code, it behaves the same on UE 5.6, 5.7, and 5.8.
v1.2.15
A full Widget Blueprint authoring toolset lands, covering the widget tree, properties and slots, navigation, real animations, and MVVM, alongside a new Blueprint graph auto-layout engine and a run of Blueprint authoring reliability fixes.
Added
A whole Widget Blueprint authoring surface. The editor can build and edit a widget tree (add, remove, move, rename, duplicate, wrap, and replace widgets), read and write widget and slot properties through the same pipeline the Details panel uses so canvas anchors and offsets resync, set per-direction navigation rules, wire the designer's property bindings, reparent a Widget Blueprint, and address and fill its named slots the way the editor sees them.
Real widget animations. Create, list, and remove animations, bind and unbind the widgets they drive, and build actual MovieScene tracks and keyframes for opacity, render transform (translate, scale, shear, and angle), and color, so an animation made through the bridge actually plays instead of coming out empty.
MVVM view models and bindings. Add, list, rename, and remove a view model, and create bindings that pick the right conversion on their own when the source and destination types differ, like wrapping an int or a string so it can drive a Text field.
A new clean-room Blueprint graph auto-layout engine. Graphs come out with straight, pin-aligned execution lines, data nodes gathered into tidy clusters below the row they feed, and long or crossing wires routed through stacked reroute knots, with node sizes measured from the real widgets so the spacing is exact.
New graph edit operations: break a single link or every link on a pin, and splice an already-placed node into a running execution chain, so you can drop logic into an existing BeginPlay without rebuilding the graph. A connection can also target an existing node by its GUID, not just a node created in the same call.
A standalone MakeArray, MakeSet, or MakeMap can be given its element type directly, so a container with nothing wired to it still compiles instead of staying an undetermined wildcard. Maps take both a key type and a value type.
Changed
The whole Blueprint graph command surface moved onto the editor's reflection layer, so every graph command exposes its real schema and is checked automatically, the same migration the rest of the tool already went through.
Building a graph now arranges only the nodes it just added, dropped clear of anything already there, so appending to a graph you laid out by hand never moves your existing nodes. A separate pass re-arranges the whole graph on demand and is safe to run again.
add_pin and remove_pin work for Sets and Maps now, not just Arrays, through the engine's own add-pin interface, so a multi-entry set or map can be built up one pin at a time.
Standard macros like ForEachLoop, ForEachLoopWithBreak, WhileLoop, Gate, and DoOnce are searchable on a fresh editor now, without first opening a Blueprint that already uses them.
Fixed
Fixed an editor crash when two custom events were built with the same name, which left the Blueprint invalid and brought down the node menu. A same-named event is reused now, or given a unique name the way the editor does.
Rebuilding a graph can no longer lose it. The clear step is held back until the new nodes are known good, so a failed build keeps what was there instead of wiping it.
The widget toolset builds on UE 5.6, 5.7, and 5.8. A version check that misfired on 5.7 patch releases had been pulling 5.8-only code into 5.7, and the MVVM binding path was using a call that only exists on 5.8.
Saving a Blueprint edited through the bridge no longer triggers the "Blueprint requires updating, please resave" prompt the next time you open it. A dirty Blueprint is compiled before it is saved, so it lands on disk already up to date.
Fixed a counter loop that never advanced because a math node reset its typed-in value the moment it was wired, so a spawn loop on BeginPlay could run forever and hang the editor on Play. Pin values are re-applied after wiring now.
Layout no longer pulls a pure node off the execution spine, looping and multi-chain graphs no longer fling nodes far to the right, and wiring into an existing node no longer trips an internal check.
Finding assets by name alone works now, across every mounted content root including plugin and engine content, instead of coming back empty when no class or path was given.
v1.2.14
PCG editing through the bridge now behaves exactly like editing in the Details panel, with the graph and compute side deepened, plus a free trial in the editor.
Added
A free trial is recognised and enforced in the editor. A trial license runs the plugin fully for three days, and when it lapses the license panel says so and points you to subscribe, told apart from a cancelled paid key, which keeps working on its offline grace.
A Static Mesh Spawner's weighted mesh list can be set in one go, which ensures the weighted selector, replaces the entries, and populates each one's display name, and a Custom HLSL node's kernel type can be set directly.
Changed
Every PCG edit made through the bridge now runs the editor's real change pipeline, so it behaves exactly like a value typed into the Details panel. It refreshes the settings, recaches the node's cached output, and runs the per-node refresh the editor runs, like rebuilding a weighted mesh selector's display names or a Custom HLSL node's pins.
Graph-level property changes, like the Hierarchical Generation grid settings, now fire the graph's real change notification, so grid linkage and compilation rebuild and any open PCG editor refreshes, instead of the value being written silently underneath the editor.
Fixed
Fixed a correctness bug where a property written straight through reflection left the node's cached output marked valid but stale, so PCG kept reusing the old result. The cache is recached on every edit now.
A weighted mesh entry no longer shows None for its name after it is set, because the editor's display name refresh now runs as part of the edit.
v1.2.13
A reflection exporter that turns any Blueprint, object, asset, or placed actor into a document an AI can read like source, plus a run of Blueprint authoring reliability fixes found by building a whole feature through the tool.
Added
The editor can now export a Blueprint as a complete, reflection-grounded document, so an AI can read it the way it reads C++ source. It captures the class origin and compile status, every variable with its current value, all the graphs with each node's pins, connections, enabled state, and per-node compiler errors, the component hierarchy (native, the Blueprint's own, and inherited), the widget tree for Widget Blueprints with slots and animations, and the implemented interfaces and timelines.
The same export reaches past Blueprints. Any object, asset, or struct can be written out through reflection, materials come out as their full expression graph with parameters and comments, PCG graphs export every node with its enabled and debug state and resolved connections, and Animation Blueprints export their state machines, states, transitions, and the animation assets they play.
A placed actor in the level can be exported with its real live component tree, including components added to that one actor in the Details panel that never exist on the Blueprint itself.
Every export also writes a readable text version next to the data, rendered as an execution-flow tree with markers for disabled and errored nodes, so you can skim a graph without reading the raw export. Large graphs can be paged through a whole node at a time, so nothing is ever silently cut off.
A Call node built into a graph now becomes the exact specialized node the editor's palette would place, so a wildcard node like Array Length works out its type the moment you connect something to it instead of failing to compile. There is also a way to list a node's pins without placing it, by spawning it into a throwaway graph and reading the pins back, so pin names no longer have to be guessed.
Component editing now works on a placed actor's own components, not just the Blueprint class, going through the same editor subsystem the Components panel uses, so a component added this way registers, attaches, and persists with the actor like a manual add. Deleting a component, and deleting a Blueprint variable along with the nodes that referenced it, are both supported now.
Changed
Adding, reparenting, or re-rooting a component now runs the compiler and reports the real result, the way every other structural edit already did, so a change that leaves the Blueprint in an error state is reported as a failure instead of a success.
Fixed
Native and inherited components, the ones declared in C++ or a parent Blueprint, are now found by the name shown in the Components panel rather than their internal object name, so you can attach under one of them, like putting a mesh under a Character's inherited Mesh. Trying to reparent or re-root one gives a clear message that its attachment is fixed in code, told apart from a name that simply does not exist.
PCG export was dropping data. A static mesh spawner's mesh list and its bound data assets came back empty because instanced sub-objects were written as a bare path and soft references to assets that were not loaded got lost. Both are captured now, and a component parented to a native one that used to be mislabelled as a root with no parent now reports its real native parent.
v1.2.12
Editor-side reliability across Blueprint graph building and material error reporting, plus two editor crash fixes.
Added
Building a Blueprint graph now runs the engine compiler and reports the real outcome: whether it compiled, the error and warning counts, the messages, and the compile status. A graph that builds but fails to compile is reported as a failure instead of a success.
Graphs are arranged automatically after they are built, with a deterministic left-to-right layered layout, so nodes no longer land in a pile at the origin. Existing graphs can be tidied on demand as well.
Materials can be created with a specific domain, such as the UI domain used for widget backgrounds, and UserWidget child classes are now constructed properly through the widget tree.
Changed
Node edits in the editor bridge are keyed on the stable node GUID through a single resolver, so an edit lands on the right node even after the graph is rebuilt, and node spawning resolves to the exact editor node, the real Set Text for example, rather than an empty placeholder.
Blueprint asset paths resolve the way the editor resolves them, so a plain path without the _C suffix works as a class or object reference everywhere, including soft references and inside arrays.
Fixed
Reading a material's errors now gathers the real shader compiler errors the Material Editor's Stats panel shows, including SM6, instead of reporting none when the material actually failed to compile. It compiles the material for each shader platform, waits for it to finish, and reads the errors from each, the same way the editor does.
Fixed two editor crashes: one while gathering a material's errors, where the temporary compile resources are now released on the render thread so they are never freed while still in use, and one when deleting a Blueprint function that is open in its own tab, where the open document is now closed first the way the Blueprint editor does it.
Function inputs are created with the correct pin type. Types like double, int64, and structs were becoming object reference pins; they now use the same type resolver the variable system uses, arrays included.
Rebuilding a graph with clear_graph clears leftover macro instances, like a stack of old ForLoop nodes, using the editor's own delete rule, while genuine function and macro boundary nodes are preserved and the existing entry node is reused instead of a stray event being added.
v1.2.11
A second agent backend, mid-chat switching, and your chats now live outside the project folder.
Added
Codex is now available as a second agent backend next to Claude Code. Pick whichever one you want from a dropdown in the chat panel.
You can switch agents in the middle of a conversation. The transcript stays put; the new agent just starts with a fresh context, since it cannot read the other one's memory.
A reasoning effort dropdown for the agents that support it.
The system prompt is now editable from Settings, with a Reset to Default button if you want to go back.
Drag assets or folders from the Content Browser straight onto the chat box to reference them instead of typing the path. They show up as clickable links the agent can open.
Changed
Chats and your custom system prompt now live in the CodeFizz app-data folder, kept per project, instead of the project's Saved folder. Clearing Saved no longer wipes your history, and anything from older versions is migrated over automatically on first launch.
Fixed
Inline formatting like bold wrapped around a code span no longer leaks raw style tags into the message.
v1.2.10
Rich chat rendering with real code blocks, clickable assets, and image paste.
Added
Syntax-highlighted code blocks with a language label and a Copy button. C++, Python, JavaScript, and JSON get proper tokenizing.
Fuller markdown in replies: inline code, bold and italic, ordered and nested lists, blockquotes, rules, and clickable links.
Tool chips show the command being run with a link that opens or focuses the asset it touched. Plugin mounts like /Jiggify/ resolve correctly, and asset paths written in plain text get linked too.
Paste an image with Ctrl+V and it attaches as a chip above the composer, then gets handed to the agent when you send (Windows for now).
Fixed
The chat no longer flickers or jumps while the agent is typing. Only the message that is actually changing re-renders, and auto-scroll only follows along when you are already at the bottom.
v1.2.9
Fixed
Removed the deprecated StructUtils dependency that printed a "deprecated in 5.5" warning on every build and project-file generation. The types it used to provide now come straight from CoreUObject, checked on 5.6, 5.7, and 5.8.
v1.2.8
Fixed
Fixed a link failure when the plugin was dropped into a C++ project. Code projects rebuild plugins from source, and the binary drop ships without the .cpp files, so the module came up empty. It now links the shipped DLL instead of trying to recompile.
v1.2.7
The chat panel grew up: document-style replies, a modern rounded look, and settings inside the tab.
Added
Agent replies render as a real document, with headings, lists, fenced code, and inline formatting, instead of raw markup.
A full Settings view (License and Advanced) now lives inside the chat tab, so it stops opening a second window.
Changed
Reworked the whole panel in pure Slate to feel like a modern chat app: rounded message bubbles, a rounded input pill, colors that follow the editor's Dark or Light theme, and a clean composer row with model and permission dropdowns.
v1.2.6
The in-editor CodeFizz Editor Agent Chat panel landed.
Added
A native chat panel inside the editor that drives your installed AI coding CLI (Claude Code) through your own subscription login. No API keys to handle, and the agent edits your project through the same cfa commands, so nothing about the tool layer changes.
Chat sessions are saved as transcripts you can browse, reload, resume, and delete.
v1.2.5
Fixed
An engine-installed plugin now enables itself by default. Packaging was stripping the enabled flag, so an engine install (unlike a project install) came up disabled and had to be turned on by hand in every project.
v1.2.4
Locked down the editor bridge.
Changed
The editor bridge now requires a per-connection session token on every command, so another local process can no longer connect to the loopback port and run code once you are licensed.
Fixed
Fixed a crash on commands that arrived with missing parameters, and moved the bridge handshake to a single atomic file.
v1.2.3
Clear license messaging and self-serve seats.
Added
Self-serve seat management from the panel: release this machine's seat, or deactivate all devices with the option to keep this one active.
Changed
The license panel now shows clear, friendly messages for every state (seat limit, revoked, not found, inactive, deactivated) and points you to the right next step instead of a raw reason code.
v1.2.1
Fixed
The PCG inspection commands build on UE 5.7 and 5.8 now, and the plugin declares its own dependencies so packaging resolves them cleanly in isolation.
v1.0
The first release.
Added
A TCP bridge plugin that exposes the Unreal editor to MCP, with native data table and material commands plus asset, blueprint, and level operations.
Before this
The list above starts where I began packaging and tracking the plugin properly. There was a long run of work before that which never got version numbers. It began as a personal tool I kept rebuilding while making my own games, so most of the core bridge, the command handlers, and the early editor integration were written and reworked many times over before any of it shipped as a release.
