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.
Table of Contents
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.”
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.