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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
