BeginPlay<\/code> and Visual Studio stutters. It think for ten seconds, then gives up. You find the function you wanted, but it\u2019s a macro, and the macro is in another macro.<\/p>\nThis is normal<\/em>. Unreal Engine uses a vast library of proprietary C++ macros and wrappers to bridge the gap between C++ and its reflection system\u2014something Visual Studio’s IntelliSense wasn’t designed for. And apart from that it’s a large codebase. It breaks away from most C++ workflows taught to you. The problem isn\u2019t you and it isn\u2019t Unreal \u2014 it\u2019s that nobody handed you the map<\/em>.<\/p>\nThis post is the map. It’s the practical, habit-building step-by-step guide for finding your way around your new Unreal solution.<\/p>\n
Stop trying to read it linearly<\/h2>\n
A UE project isn\u2019t one codebase. It\u2019s a stack of three:<\/p>\n
\n- Engine<\/strong> \u2014 Epic\u2019s source, sitting alongside your project if you built UE from source.<\/li>\n
- Plugins<\/strong> \u2014 engine-shipped, third-party, and your own.<\/li>\n
- Your game modules<\/strong> \u2014 what you actually wrote, defined in
.uproject<\/code> and described by Build.cs<\/code> files.<\/li>\n<\/ol>\nThe .uproject<\/code><\/a> file is the manifest. Each Build.cs<\/code><\/a> declares what a module depends on. Read those two files first on any unfamiliar UE project \u2014 they tell you the shape<\/em> before you read a line of gameplay code.<\/p>\nThe mistake most new UE devs make is opening a .cpp<\/code> file and trying to read top-down. You can\u2019t. The codebase isn\u2019t written linearly and it doesn\u2019t reward linear reading. The rest of this post is about reading by question<\/em> instead.<\/p>\n![\"Diagram](\"https:\/\/i0.wp.com\/www.wholetomato.com\/blog\/wp-content\/uploads\/2026\/05\/STACK-DIAGRAM.png?resize=801%2C534&ssl=1\")
<\/a><\/p>\n<\/p>\n
Read by question, not by file<\/h2>\n
Pick a question, then chase it. Here\u2019s one to start with:<\/p>\n
\u201cWhen I press a key, what actually happens?\u201d<\/em><\/p><\/blockquote>\nYou trace it:<\/p>\n
\n- Input mapping fires on the
APlayerController<\/code>.<\/li>\n- The controller forwards it to the possessed
ACharacter<\/code>.<\/li>\n- The character calls into
UCharacterMovementComponent<\/code> \u2014 engine code, not yours.<\/li>\n- The movement component updates position, replicates state, and eventually fires events back up the stack that your gameplay code listens for.<\/li>\n<\/ul>\n
Of course, you won\u2019t memorize that path on the first walk. The point is the habit<\/em>: pick one thread, walk it from input to outcome, and follow it across the boundary from your game module into engine code. Then walk a different thread. After three or four traces, the codebase stops feeling like 800 folders and starts feeling like a network that you can conceptually follow.<\/p>\nThis is the solo dev’s superpower. It’s one of the key skills studios look for<\/a>. Nobody is going to teach you the architecture. So you teach yourself by tracing one thing at a time. Don\u2019t try to understand the rendering pipeline before you understand how a single bullet leaves a gun in your own game.<\/p>\n![\"Flow](\"https:\/\/i0.wp.com\/www.wholetomato.com\/blog\/wp-content\/uploads\/2026\/05\/INPUT-EVENT-DIAGRAM.png?resize=1024%2C512&ssl=1\")
<\/a><\/p>\n<\/p>\n
The reflection macros that defeat your IDE<\/h2>\n
You\u2019ll discover UCLASS()<\/code>, UFUNCTION()<\/code>, UPROPERTY()<\/code>, and GENERATED_BODY()<\/code> on your first day. Here\u2019s what they actually do, and how to read past them.<\/p>\nWhat the macros generate.<\/strong> Unreal Header Tool (UHT)<\/a> scans your headers, finds these macros, and generates code that hooks your C++ classes into Unreal\u2019s reflection system \u2014 the thing that lets Blueprints, the editor, the GC, and the network layer all see your types. Without UHT, none of those work. With UHT, your class is suddenly part of a larger runtime than the C++ standard alone describes.<\/p>\nWhy your IDE struggles.<\/strong> Default Visual Studio IntelliSense doesn\u2019t run UHT. It sees a macro it can\u2019t expand correctly and quietly mis-parses the surrounding class. That\u2019s why you get red squigglies on perfectly valid code, or Go to Definition<\/code> gets confused and you jump to the wrong place. Recent VS versions have improved here, but in macro-heavy UE code the limits still show up daily.<\/p>\nHow to read past them.<\/strong> When you see UFUNCTION(BlueprintCallable, Category=\"Combat\")<\/code>, mentally translate: this is a function, exposed to Blueprints, with this category label.<\/em> Don\u2019t get distracted by the parens.<\/strong> The function signature on the next line is what matters. Same for UPROPERTY<\/code> \u2014 the type and name come after; the macro arguments are metadata for the editor and serializer.<\/p>\nIn plain English: these macros are how Unreal turns your C++ into something Blueprints, the editor, and the engine\u2019s runtime can all talk to. The catch is that Visual Studio doesn\u2019t know that. When IntelliSense looks confused, it usually is \u2014 and it usually isn\u2019t your fault.<\/em><\/p><\/blockquote>\nThree navigation moves that make engine source readable<\/h2>\n
If you only learn three IDE moves, learn these. Use them every day until they\u2019re muscle memory.<\/p>\n
Go to Definition \/ Go to Declaration.<\/strong> UE is header-heavy. Forward declarations are everywhere. Knowing the difference matters: declaration takes you to the header, definition to the .cpp<\/code>. When you see a symbol you don\u2019t recognize, jump first, ask later. You can always come back.<\/p>\nFind All References.<\/strong> The single most-underused feature among new UE devs. UE wires a lot of itself together by name \u2014 Blueprints reference C++ functions by string, Gameplay Ability System abilities by tag \u2014 so the compiler can\u2019t tell you when you\u2019ve broken a caller. Find References can. Before you rename or change the signature of a UFUNCTION<\/code>, run Find References on it. Always.<\/p>\nFuzzy file \/ symbol open.<\/strong> Knowing the rough name of a class is enough. Ctrl+T<\/code> and a fragment beats scrolling Solution Explorer for everything except the smallest projects.<\/p>\n<\/p>\n
![\"Workflow](\"https:\/\/i0.wp.com\/www.wholetomato.com\/blog\/wp-content\/uploads\/2026\/05\/THREE-NAVIGATION-INFOGRAPHIC.png?resize=575%2C575&ssl=1\")
<\/a><\/p>\n