I open sourced a plugin that translates any Blueprint graph to C++ for reasons you might not expect

Development Programming & Scripting
1

Hey everyone, I’m Nick! :wave:

After nearly a decade deep in the Unreal Engine trenches as an XR Rapid Prototyper and Lead Technical Designer, I’m really excited to share an editor plugin that I’ve been working on that has genuinely transformed my UE workflows, and why it should be accessible to every UE creator.

GIF_NodeToCode_BlueprintTranslation_Optimized

(Briefly) How I Got Here

After thousands of hours of intimate work in Unreal Engine, I’ve developed what some might call an obsessive appreciation for Blueprint scripting. This visual scripting system has been my constant companion across a somewhat absurd range of projects thanks to my almost 8 years at the amazing Magnopus, and my insatiable desire to create in my free time.

I’ve spent years building and shipping everything from cutting-edge Mixed Reality apps and experiences on the Meta Quest store, to implementing industry-adopted Virtual Production tools used in public Unreal Engine releases, to operating and rendering final pixels for Sony Music’s mind-bending immersive reality concert, to designing and 3D printing the #1 selling Vision Pro accessory on Etsy, and much more.

I love Unreal Engine!

And I absolutely love Blueprints. It allows me to pull almost any idea from my mind and make it a reality at the speed of thought. I built 95% of Swing Genius for the Quest 3 using Blueprints - including complex MR tracking systems, physics simulations, user auth, fully-fledged LLM-powered voice assistants, spatial UI systems, and even a custom UDP network replication system for offline shared spaces. However…

Hard Truths About Blueprints

As many Blueprint devs probably know, some hard realities emerge as a project scales:

  • Communication is an uphill battle: Explaining/rubber-ducking Blueprint logic to peers (or even AI assistants now) requires screenshots/captures, blueprint sharing platforms, lengthy meetings, tedious manual pseudocode, or worst of all… deciding to just not communicate at all.

  • Documentation is exhausting: Documenting a Blueprint system for future, searchable reference is even more difficult than trying to communicate them.

  • Learning C++ the hard way: There’s no fast bridge to see how your specific Blueprint patterns translate to their UE C++ counterparts.

  • Navigation gets unwieldy: Consistent use of reroute nodes, no crossed wires, logical naming conventions, variable categorization, local/function param variables, interfaces, structs, enums, comments… turns out complex Blueprint systems are just unavoidably cumbersome to navigate as they scale up - no matter how tidy they are.

  • Performance bottlenecks require tedious conversion: Swapping out game thread heavy Blueprint functions into their C++ counterparts can takes hours/days of tedious manual conversion. Constant context switching, UE C++ API & engine source scouring, forum post dead ends… if you know, you know.

After converting one too many Blueprints to C++ and tediously explaining Blueprints countless times (losing a bit of my sanity each time), I finally decided to try building a solution.

Say Hi to Node to Code

Node to Code is a deeply integrated editor plugin that translates any Blueprint graph to C++ (or C#, Python, JavaScript, Swift, & even pseudocode!) with a single click using state-of-the-art LLMs. And yes, it’s completely open source because not only do I think this will change how we approach UE development, I genuinely believe that every UE creator deserves to have access to it.

To be clear - this isn’t about replacing Blueprints or bypassing the need to learn programming fundamentals. It’s about creating a bridge between worlds: keeping the rapid iteration of Blueprints while unlocking the readability, shareability, and performance benefits of code.

Where to Get It:

Both versions are identical in functionality - the Fab version just offers a more streamlined installation experience and helps fund continued development. Choose whichever works best for you!

What Can Node to Code Do?

Blueprint Communication Solved

  • Share Logic Easily: No more screenshotting Blueprints! Convert any graph to readable, shareable code or pseudocode that everyone can understand
  • Remote Collaboration: Send complete logic via Discord, Slack, or email that anyone can review without opening the editor
  • Forum-Ready Format: When seeking help, share your entire system logic without fear of all of those screenshots being out of order
  • AI-Assistant Compatible: Use the generated text with other AI assistants for advanced troubleshooting (with built-in Blueprint chat coming soon!)

Navigate Complex Blueprint Architectures

  • Visual-to-Text Transformation: Instantly convert sprawling node networks into structured, hierarchical text
  • Nested Graph Translation: Capture entire Blueprint hierarchies with configurable depth (up to 5 levels)
  • Pattern Recognition: Spot duplicated logic and opportunities for refactoring more easily when viewing as text

Learn C++ Through Your Own Blueprints

This was a major motivation for me personally. As someone who loves learning by doing, strengthening my UE C++ skills has always felt like an uphill battle until the advent of LLMs. Node to Code lets you:

  • See Your Logic in C++: Understand how your specific Blueprint implementations translate to industry-standard Unreal C++
  • Get Implementation Notes: Each translation includes explanatory comments about key concepts, patterns, and things to pay attention to
  • Learn by Example: Use reference source files from your project to guide translations and learn your team’s coding style

Performance When You Need It

  • Targeted Optimization: Translate performance-critical Blueprint functions to C++ when needed
  • Blueprint-First Freedom: Keep using Blueprints for rapid iteration, knowing you can get a head-start on converting bottlenecks later
  • Integration Guidance: Clear implementation notes help you incorporate generated code into your project

Built-in Documentation & Knowledge Preservation

  • System Archiving: Maintain a more searchable text history of your Blueprint systems’ evolution
  • Team Knowledge Transfer: Preserve system design decisions in a format accessible to everyone
  • Technical Specification Ready: Generate code snippets for design documents and requirements

Value For All Disciplines

For Blueprint Creators (like me): Communicate your systems clearly, get better feedback, and gradually learn C++ through your own work.

For C++ Programmers: Get a head start on optimization, or understand designer intent without deciphering complex visual graphs and

For Project Leads: Improve team communication, identify optimization opportunities, and maintain better system documentation.

For Educators & Students: Bridge the visual-to-code learning gap and demonstrate programming concepts in multiple contexts.

Under the Hood

For those curious about how it works:

  • Blueprint Graph Collection: The plugin captures your entire Blueprint graph by analyzing K2Nodes and K2Pins - extracting execution flows, data connections, variable references, and even comments you’ve added to nodes

  • Custom Serialization: These nodes are then serialized into a specialized JSON schema that reduces token usage by 60-90% when compared to UE’s native Blueprint text format while preserving all critical logical relationships and type information

  • Translation Depth Management: Configure how deep the system traverses nested content - translate just the current graph or follow function calls, macros, event bindings, math expressions, and collapsed nodes up to 5 levels deep

  • LLM Provider Integration: Choose from multiple LLM providers (Claude, OpenAI, Gemini, DeepSeek) or run 100% locally via Ollama for complete privacy & control, with optimized prompting for each model

  • Reference Source Files: Supply your own C++ files as context to guide the output style and maintain project-specific patterns and conventions

  • Multi-Language Support: Generate not just UE C++ but also C#, Python, JavaScript, or Swift code from your Blueprint logic (your mileage can obviously vary here, but it’s helpful)

  • Smart Response Parsing: The system processes the LLM output into structured graph objects with both implementation and declaration code blocks alongside helpful implementation notes generated by the LLM

  • Integrated Editor UI: Review your translations in a dockable Unreal editor window with syntax highlighting, theming, implementation notes, and a browser for all translated graphs

Get Involved

Final Thoughts

To reiterate, this plugin is not about replacing Blueprints—it’s about enhancing what makes them great while solving their inherent challenges. It’s the bridge I’ve wanted for years between the speed of Blueprint iteration and the benefits of C++.

If you’re curious about my journey, the higher level architecture, and some of my thought processes behind how I got to this point, I also wrote a pretty comprehensive Medium article that you can take a deep dive into!

I’d love to hear how you end up using it in your projects! Feel free to drop any questions or join me on the Discord.

5 Likes