This webinar recap explores effective Unreal Engine 5 development by explaining when to use C++ and when Blueprints are the better choice. It highlights how C++ helps manage growing project complexity, while Blueprints remain ideal for visual workflows such as UI, animation, and gameplay scripting. The article also demonstrates how Visual Assist improves the Unreal Engine C++ development experience with faster code navigation, Unreal-aware refactoring, intelligent code analysis, and productivity tools that address common Visual Studio limitations.
This is the third session in the webinar series on Unreal Engine 5 workflows with Assembla and Visual Assist. Chris Gardner, lead developer at Whole Tomato Software, challenges conventional wisdom about when to use C++ versus Blueprints and demonstrates how Visual Assist solves critical pain points in Unreal Engine C++ development.
Watch the live demo replay here.
The Blueprint vs C++ Debate
Gardner presents a perspective that surprises many developers: “Blueprints should be considered the default go-to. They are the bread and butter of your game.”
When Blueprints Excel
Blueprints offer real-time editing without recompilation. “You can make changes to blueprints and see the change happen in real time,” Gardner explains. While Unreal has experimented with hot reload, Gardner admits, “I never got hot reload to work that well.”
Visual debugging provides unique advantages. Developers can click entities in the level and inspect their Blueprint behavior directly, something impossible with traditional C++ debuggers.
Several Unreal systems practically require Blueprints:
- Animation systems with state machines and blend spaces are “very poorly exposed in C++,” according to Gardner
- AI behavior trees and blackboards lose their editing tools when implemented in C++
- Sequencer assets for cutscenes need Blueprint integration
- UI development through UMG works best visually rather than in hardcoded C++
“Even if you could do this easily in C++, you wouldn’t want to because you’d lose a lot of the value of the editor,” Gardner emphasizes.
The Real Problem with Blueprints
When asked why anyone uses C++, most developers cite performance. Gardner challenges this: “I really don’t think performance is a good reason. Blueprints are fast enough for 99% of things.”
The actual problem is complexity management. “As you add complexity to blueprints, this just explodes. It’s not twice as worse. It’s like squared worse.”
Gardner demonstrates a tangled Blueprint graph. “This is just how code looks when you’re just making your game. You’re just slapping things together.” Even well-organized graphs require constant maintenance. “Now you have to edit it. All of your beautiful structure is gone and you have to redo it again.”
Low information density creates fundamental problems. Gardner shows a simple Blueprint: “This is like one line of C++ right here. You have to scroll scroll scroll scroll scroll.”
His conclusion: “The drawback is that blueprints waste your time. This is the same reason we don’t have programming languages that work like this generally out in the world.”
Why C++ Matters
Gardner contrasts Blueprints with C++ code. “Look at the density. So much code is happening so quickly. Super dense, super readable, easy to modify.”
Beyond density, C++ provides deep debugging. “Let’s say there’s something going on in the base class of your blueprint. Well, you’re essentially done at that point.” C++ debugging allows examining the entire engine source. “You can actually look at what the engine’s doing with your call and say, ‘Here’s where it’s failing, and this is why.'”
Gardner adds a point about AI assistance: “AI can literally hand you code for a lot of this stuff even if you don’t know that much Unreal Engine C++. AI’s got your back in a way that it just can’t with blueprints.”
C++ Challenges in Unreal
Unreal’s non-standard extensions complicate development. “You’re not going to use any of that,” Gardner tells developers familiar with standard C++. “Unreal Engine 5 uses its own STL.”
Visual Studio struggles with Unreal’s custom macros and build system. “Visual Studio honestly struggles. It does struggle with the non-standard extensions to C++.” The root cause: Unreal has its own compiler pipeline. “It’s not really building the solution when you build it. They don’t have to make the Visual Studio projects sensible to Visual Studio.”
Generated files only exist after compilation, causing parsing problems. “Technically this isn’t valid C++. This is totally nonsense when interpreted straightforwardly.”
The result: “Failure to navigate and refactor commonly occur. It really is a problem that I’ve had frequently myself.”
The Optimal Workflow: Bottom-Up Development
Gardner demonstrates the pattern he uses on every project: “Define base classes in C++ that Blueprints inherit from.”
Using Epic’s Lyra sample, he shows Blueprint inheritance from C++ layers. “C++ feeds up into blueprints very elegantly.”
Even minimal base classes provide value. “It can have no code at all. That gives you a blank space that you can fill in later.” When complexity grows, “you can implement it in C++ and expose it to the blueprint. All of a sudden I have access to it.”
Keep the flow unidirectional. “It’s best to keep the flow bottom up. C++ flows into blueprints and then blueprints flow into your game.”
Gardner’s recommendation is absolute: “I have done every single project like this. I don’t think there really is a strong argument for doing things any other way. I don’t think you can write a game entirely in C++, and unless it’s a very simple game, you can’t write a game with just blueprints.”
Visual Assist: Solving Unreal C++ Problems
Visual Assist addresses Visual Studio’s limitations through custom parsing. “We have our own parser that we have maintained over the years. That is an incredibly expensive and time-consuming thing to maintain.”
This custom parser enables Unreal-specific support. “We can modify it to fully understand Unreal Engine syntax, which is what we’ve done.”
Performance comes from parser design. “Our parser doesn’t have to be written as a compiler front end. It can be really super fast and skip over issues instead of just breaking.”
Key Features
- Unreal-specific understanding handles validation patterns. “If you renamed pickup, you might not rename pickup_implementation and pickup_validate. Visual Studio will get confused. We understand these relationships.”
- Fast navigation includes goto related for hierarchy exploration and powerful filtering for files and symbols. “It’s such a powerful quick and reactive system.”
- Code inspections automatically modernize code. Gardner demonstrates fixing shared pointer constructors, detecting unused code, and identifying outdated patterns. “We’ve made sure that every single one of these is something you’re going to want to do. It’s not noise.” Batch corrections work across entire files. “I can select everything. I can apply it. And bam, everything in the file has been improved.”Protip: The primary shortcut is Shift + Alt + Q (Quick Actions & Refactorings menu) for context-based commands. “That’s an incredibly good way to get started.” he adds.
Common Questions Addressed
- Are Blueprints hard for C++ developers? Yes. “It’s hard to know what to use and when. What things get exposed to blueprints can be a little different than C++.”
- Can you mix standard and Unreal STL? Technically yes, but avoid it. “The Unreal Engine memory management system is not going to understand what’s going on when you add things to a std vector.”
- How do you start without feeling overwhelmed? “You just have to get used to being overwhelmed. Start by thinking this is super duper fun. It’s compartmentalized. You can wait to learn AI systems till you need them.”
Key Takeaways
Gardner’s main point: “I think a lot of the information out there is wrong. People think C++ is there for performance. I agree blueprints are fast enough for 99% of things, but that’s not why you use C++.“
The actual reason: “C++ is a powerful method of organizing and writing code. There’s a reason why we don’t use this to actually write code,” pointing to Blueprint graphs. “Because of this low density and all that.”
Blueprints waste time as complexity increases. “If you take one thing away: Why C++? Because blueprints don’t do a good job. As complexity increases, they waste your time.”
Frequently Asked Questions About Unreal Engine 5 C++ and Blueprints
Should I learn C++ or Blueprints first in Unreal Engine 5?
Blueprints are a good starting point because they let you build and test gameplay without recompiling code. As projects become more complex, learning C++ helps with code organization, debugging, and maintainability. A hybrid approach is often the most practical.
When should you move Unreal Engine Blueprint code to C++?
Consider moving functionality to C++ when Blueprint graphs become difficult to read, maintain, or reuse. C++ provides greater code density and stronger debugging capabilities for complex systems. Blueprints can then extend that functionality at the gameplay level.
Can you use C++ and Blueprints together in Unreal Engine 5?
Yes. A common workflow is to create base classes and reusable functionality in C++, then expose them to Blueprints for customization. This keeps complex logic organized while preserving the visual editing and rapid iteration that Blueprints provide.
Why does IntelliSense struggle with Unreal Engine C++?
Unreal Engine uses custom macros, generated code, and build processes that differ from conventional C++ projects. These differences can make standard Visual Studio parsing and navigation less reliable. Developers may experience incorrect suggestions, navigation issues, or refactoring problems.
How do you fix IntelliSense problems in Unreal Engine 5?
Project configuration and generated files can be checked when IntelliSense behaves incorrectly. However, Unreal-specific syntax can still challenge standard Visual Studio parsing. Visual Assist uses its own parser to provide more reliable code navigation, completion, and refactoring for Unreal projects.
Is Visual Assist useful for Unreal Engine C++ development?
Visual Assist is designed to improve C++ development inside Visual Studio, including projects that use Unreal Engine’s macros and generated code. Its Unreal-aware parsing supports navigation, code inspections, refactoring, and other everyday development tasks.
Should Unreal Engine gameplay logic be written in C++ or Blueprints?
There is no need to put all gameplay logic into one system. Complex, reusable, or foundational functionality can live in C++, while Blueprints can handle gameplay customization and rapid iteration. The right balance depends on the project’s complexity and team workflow.
Why do Unreal Engine Blueprints become difficult to manage as projects grow?
Large Blueprint graphs can become increasingly difficult to navigate, modify, and maintain as functionality expands. Complex logic may require extensive visual graphs for relatively small amounts of functionality. Moving foundational logic into C++ can make larger systems easier to organize.
Can Unreal Engine C++ use the standard C++ STL?
Unreal Engine provides its own containers and systems that integrate with the engine’s memory management and architecture. Standard C++ types can technically be used in some situations, but mixing them without understanding the implications can create compatibility and memory-management concerns.
How can you improve C++ navigation and refactoring in Unreal Engine?
Unreal’s custom macros and generated code can make standard Visual Studio navigation and refactoring less reliable. Tools such as Visual Assist provide Unreal-aware parsing and features for finding symbols, navigating class relationships, and applying code improvements more efficiently.
Conclusion
Mastering Unreal Engine 5 requires understanding when to leverage C++ versus Blueprints and combining both effectively. Gardner’s bottom-up workflow—base classes in C++, extensions in Blueprints—provides a scalable foundation that preserves rapid iteration while managing complexity.
This session completes the three-part webinar series. The first session covered project setup and Perforce integration with Assembla. The second demonstrated advanced source builds and branching strategies. This final session addresses the daily development experience: writing, navigating, and maintaining code that runs on that infrastructure.
For teams serious about Unreal Engine 5 development, the combination of proper version control through Assembla and Perforce, well-structured source builds, and enhanced C++ productivity through Visual Assist creates a complete workflow that scales from solo developers to large studios. Visit wholetomato.com to learn more about Visual Assist or getassembla.com for managed Perforce hosting.