Example video 1
Update video 1
Update video 2
Update video 3
Discord support

[This repository deals with advanced bypasses of standard Unreal C++, Level Editor & Blueprint bottlenecks. 🟢 Currently available for B2B consulting and remote contract/Co-Dev integration (CET Timezone). Contact form.]

BlueLine is a lightweight, modular editor productivity & visualization plugin for Unreal Engine 5.5+. At its current state (0.4+), it solves the "Spaghetti Code" problem in Blueprints by enforcing strict, circuit-board-style layouts and semantically coloring data. Under the hood, it is split into four elaborate modules, with the graph module wiring up formatting, routing, export, extraction, bookmarks, snippets, auto-routing, and wire snapping at startup, plus separate SmartTags and Level modules for semantic tagging and viewport tools. The implemented surface is fairly broad:

• Graph editing features are substantive: soft align, rigidify, clean graph, linter, export-to-text, subsystem extraction, bookmarks, and snippets.
  
• SmartTags does heuristic clustering and creates colored comment boxes from semantic guesses; it also registers a native BlueLine.Type.* tag set.
  
• Level tools are also available: the module opens a viewport overlay pie menu, supports pivot center/bottom, cursor-based snapping, and radius-based material scope selection with preview/commit flow.

If you're interested, a more evolved and polished branch is available on Fab.
Also, in case you need this adapted or integrated into a production UE5 project: I offer paid Unreal Engine consulting and implementation.

BlueLine's current pillars are:

1. Pathfinding ReRouting (Clean Wires):

   • Instead of the default curved splines that overlap messily, this plugin inserts "Knot" (Reroute) nodes to force wires into grid-snapped 90-degree angles.
   • It builds on existing UE5 logic to more intuitively "Straighten" existing connections via the Context Menu or a hotkey (Shift+Q).
   • A context menu is available on entry/exit node pins that enables selective wire Rerouting / Rigidifying even if no other nodes are selected.
   • BlueLine connection interception toggle: new connections automatically use Pathfinding Rerouting.

2. Smart Tag Customization (Visual Semantics):

   • It intercepts FGameplayTag pins in the Graph Editor. Instead of a plain grey text box, it renders a colored badge and a dropdown picker.
   • The colors are driven by a central Theme Data Asset. For example, you can define Status.Damage as Red and Status.Heal as Green.
   • Semantic Tag Intelligence: a Tag analyzer that performs a multi-factored heuristic scan. Pin-Type Topology detection that identifies logic even when nodes aren't named descriptively.

3. Smart Color System:

   • It implements a Brand Palette (e.g., Cyan for Movement, Red for Combat), providing immediate cognitive mapping. It applies the color alongside the tag, eliminating the friction of manual styling.
   • Reliability: Using FLinearColor directly within the property handle ensures that these colors persist correctly in the asset data and integrate with Unreal's Undo/Redo system.
   • The ✨ Button: Using a SComboButton with a custom menu is idiomatic to Unreal's editor style.
   • Reasoning Engine: Providing a "Reason" for each suggestion (e.g., "Detected spatial or velocity manipulation") is critical.

4. Project-wide Graph Analysis Engine (Shift+C):

   • It performs hierarchical Blueprint organization based on topological ranking.
   • It performs crossing minimization and collision resolution.
   • It performs all operations within a FScopedTransaction, allowing for instant Undo/Redo support.

5. Auto-Tagging System (Shift+T):

   • Semantic Clustering: Automatically identifies groups of related nodes using a graph-topology-aware clustering algorithm.
   • Intelligent Classification: Analyzes each cluster's content (function calls, variable access, pin types) to determine its purpose (e.g., Movement, Combat, AI).
   • Automated Organization: Wraps identified clusters in a UEdGraphNode_Comment (Comment Box).
   • Visual Identity: Automatically sets the Comment Box's Title (e.g., "✨ Movement Logic") and Color based on the identified semantic theme.
   • Seamless Integration: Accessible via the Shift+T shortcut or the BlueLine menu, enabling one-click graph organization.

6. Unified Runtime Debugging:

   • It provides a blueprint library (BlueLineDebugLib) to draw debug text in the 3D world.
   • Crucially, this debug text automatically matches the colors defined in your Editor Theme. If Status.Fire is Orange in your Blueprint graph, it appears as Orange floating text above your burning character. █ In short: It forces your visual scripting to be as organized and strictly typed as written code, while unifying your team's visual language across Editor and Game.

1. Download: Clone or extract this repository into your project's Plugins folder: YourProject/Plugins/BlueLine
2. Regenerate: Right-click your .uproject file and select Generate Visual Studio Project Files.
3. Compile: Open the solution in Visual Studio/Rider and build your project.
4. Enable: Launch the Editor, go to Edit > Plugins, and ensure BlueLine is enabled.

BlueLine replaces the standard graph rendering pipeline with a high-performance "Manhattan" style renderer.

• Orthogonal Routing: Wires turn at 90-degree angles.
• Ghost Wires: Wires passing behind nodes are automatically rendered with reduced opacity (35%) to reduce visual noise.
• Performance: Uses simple geometric heuristics instead of pathfinding, ensuring zero input lag even in massive Animation Blueprints.

Unlike other auto-formatters that rearrange your entire graph (destroying your specific layout), BlueLine uses a Selection-Only approach.

• Usage: Select a group of nodes and press Shift + Q.
• Behavior: Nodes align grid-relative to their input connections.
• The "Anti-Diff" Philosophy: BlueLine never touches nodes you haven't selected. This ensures your Commit History remains clean and readable.

BlueLine overrides the Details Panel customization for FGameplayTag, replacing the text string with a colored "Chip" widget.

Colors are not stored in local user preferences. they are stored in a Data Asset so the whole team sees the same colors.

1. Create a DataAsset derived from BlueLineThemeData.
2. Name it DA_BlueLineDefault and place it in /Game/BlueLine/ (Content/BlueLine/).
   • Note: This path ensures the plugin finds it automatically without configuration.
3. Add Tag Styles:
   • Tag: Status.Debuff
   • Color: Red
   • Apply To Children: True
   • (Result: Status.Debuff.Fire and Status.Debuff.Ice will automatically inherit Red).

Debug colors shouldn't disappear when you hit PIE (Play In Editor). Use the static library to draw colored tags on the HUD or in World space.

#include "Debug/BlueLineDebugLib.h"

// Draws the tag text at location, using the color defined in your Theme Data Asset.
UBlueLineDebugLib::DrawBlueLineDebugTag(this, MyGameplayTag, GetActorLocation());

// Or get the color manually for your own UI widgets:
FLinearColor TagColor = UBlueLineDebugLib::GetColorForTag(MyGameplayTag);

The library is exposed to Blueprint as "Draw BlueLine Debug Tag".

• Asset: UBlueLineThemeData
• Location: /Game/BlueLine/DA_BlueLineDefault
• Contains: Tag Colors, Wire Thickness, Bubble Sizes.
• Check this file into Git/Perforce.

• Location: Editor Preferences > Plugins > BlueLine Graph
• Contains:
  • Enable Manhattan Routing (Toggle off if you prefer vanilla curves).
  • Dim Wires Behind Nodes.
  • Magnet Snap Sensitivity.
• These settings affect only your machine.

The plugin is split into three distinct modules to ensure proper packaging behavior (Game vs. Editor).

• Type: Runtime (Ships with game).
• Responsibilities:
  • Defines UBlueLineThemeData.
  • Handles runtime color lookup logic.
  • Contains DrawDebug helpers.
• Dependencies: GameplayTags, Core.

• Type: Editor (Stripped from game).
• Responsibilities:
  • Implements IPropertyTypeCustomization.
  • Draws the "Chip" widget in details panels.
• Dependencies: BlueLineCore, PropertyEditor, Slate.

• Type: Editor (Stripped from game).
• Responsibilities:
  • Implements FConnectionDrawingPolicy.
  • Handles wire geometry calculation.
  • Handles "Magnet" formatting logic.
• Dependencies: BlueLineCore, GraphEditor, UnrealEd.

Q: The wires look like standard Unreal wires? A: Press F8 to toggle the style. Also, check Editor Preferences > BlueLine Graph to ensure "Enable Manhattan Routing" is checked.

Q: My Debug Tags are Magenta/Pink? A: This indicates the plugin cannot find the Theme Data. Ensure you have created a BlueLineThemeData asset at /Game/BlueLine/DA_BlueLineDefault.

Q: I get linker errors when building? A: Ensure your project has GameplayTags enabled in your .uproject file.

• Magnet Formatting (Shift+Q): Added a non-destructive formatter that aligns selected nodes grid-relative to their input connections without altering the rest of the graph.
• Manhattan Router (Shift+R): Implemented FBlueLineManhattanRouter. Instead of drawing custom wires, this tool physically inserts UK2Node_Knot (Reroute Nodes) to force wires into orthogonal 90-degree shapes.
  • Includes: Type propagation (prevents Wildcard errors), Left-to-Right flow enforcement, and "Knot Collision" prevention.
• Smart Tag Chips (Details Panel): Custom IPropertyTypeCustomization for FBlueLineTagStyle. Displays a colored chip, a native Gameplay Tag dropdown, and a live color preview strip.
• Colored Graph Pins: Implemented FBlueLineGraphPinFactory. Blueprint nodes with Gameplay Tag pins now feature a high-visibility colored border matching the project's Data Asset configuration.
• Runtime Debug Library: Added UBlueLineDebugLib::DrawBlueLineDebugTag to render colored debug text in the game world using the shared editor team colors.
• Auto-Discovery: Logic added to BlueLineDebugLib to automatically scan the Asset Registry for the BlueLineThemeData asset, removing the requirement for hardcoded file paths.

• UE 5.7 Compatibility:
  • Refactored all Slate rendering logic to use strict FVector2f (floats) instead of FVector2D.
  • Updated FPaintGeometry constructors to use FSlateLayoutTransform.
• Tag Picker UI: Switched from a custom button implementation to IGameplayTagsEditorModule::MakeGameplayTagWidget, restoring native functionalities like "Add New Tag," "Rename," and "Search."
• Pin Visualization: Updated SBlueLineGraphPinEnhanced to include visual stubs and "Connection Count" badges for non-tag pins.

• Crash Fix (Undo): Fixed a crash occurring when checking Undo after routing wires. The fix ensures UK2Node_Knot pin types are finalized before being registered in the transaction history.
• Crash Fix (Startup): Fixed a crash on engine launch caused by the Pin Factory attempting to access UGameplayTagsManager before it was allocated. Added GetIfAllocated() safety checks.
• Connectivity: Fixed Shift+R creating tangled knots ("Spaghetti explosion") by filtering out backward-looping connections and enforcing minimum node spacing.
• Linker Errors: Resolved LNK2019 errors by correctly adding dependencies (GameplayTags, GameplayTagsEditor, Kismet, ToolMenus, AssetRegistry) to Build.cs.

• F8 (Wire Rendering): Removed FBlueLineConnectionPolicy. UE 5.7 removed the CreateConnectionPolicy hook from the Global Factory, making custom wire drawing via plugins unsupported without engine modification. Replaced by the Manhattan Router logic.
• Toolbar Button: Removed the "AutoFormat" toolbar button. Clicking the button caused the Graph Editor to lose focus, breaking the selection-context logic necessary for the formatter to work. The workflow is now Hotkey-only (Shift+Q / Shift+R).

• Initial prototype attempts consisting of monolithic modules.
• Attempted to use FExtender for toolbar buttons (Failed in UE5, moved to UToolMenus).
• Attempted to use BlueprintAssist-style global formatting (abandoned for Selection-Only approach to preserve Git Diff history).
• Attempted A* Pathfinding for wires (abandoned due to performance cost in large Animation Blueprints, switched to Geometric Heuristics).
• Initial split into Core (Runtime) and Editor modules to fix packaging errors.

MIT License.