🧱 Lesson 2.1: Project & Module Anatomy and the Coding Standard

What Is a Module?

A module is Unreal's unit of C++ compilation and linking — it compiles to one binary (a DLL in editor builds). The engine itself is hundreds of modules (Core, Engine, UMG, Niagara…). Your game has at least one module of its own, and you can add more.

Reading a .Build.cs

Each module has a <ModuleName>.Build.cs file — written in C#, not C++. It's build configuration: which other modules this one links against. Here's a typical game module's build file:

// MyProject.Build.cs
using UnrealBuildTool;

public class MyProject : ModuleRules
{
    public MyProject(ReadOnlyTargetRules Target) : base(Target)
    {
        PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;

        // Modules whose PUBLIC headers you use in YOUR public headers.
        PublicDependencyModuleNames.AddRange(new string[]
        {
            "Core", "CoreUObject", "Engine", "InputCore"
        });

        // Modules you use only in .cpp files (implementation detail).
        PrivateDependencyModuleNames.AddRange(new string[]
        {
            "EnhancedInput"
        });
    }
}

Targets & the Primary Game Module

Where .Build.cs configures a module, a .Target.cs configures a whole build target — the thing you actually produce. A C++ project has two by default:

Every project needs exactly one module declared as its primary game module, via a macro in that module's .cpp:

// MyProject.cpp — the module implementation file
#include "MyProject.h"
#include "Modules/ModuleManager.h"

// Registers this module as the primary game module. Every game needs exactly one.
IMPLEMENT_PRIMARY_GAME_MODULE(FDefaultGameModuleImpl, MyProject, "MyProject");

💡 You rarely edit these by hand. The project wizard writes them. But when a build target behaves oddly — say, editor-only code leaking into a packaged game — the .Target.cs is where the answer lives. We return to targets in Module 8.

Naming Prefixes

Unreal enforces a single-letter prefix on type names. This isn't decoration — the header tool requires the right prefix for the base class, and reading them tells you instantly what a type is.

Beyond prefixes: types and functions are PascalCase, booleans get the b prefix, and Unreal uses sized integer types — int32, int64, uint8 — rather than bare int, for portability across platforms.

Include Conventions

Unreal projects follow IWYU — "Include What You Use." The idea: each file includes exactly the headers it needs, no more, so changing one header doesn't recompile half the project.

The two anchors

• #include "CoreMinimal.h" — a curated, lightweight set of the most common core types (FString, FVector, TArray, basic macros). Start most headers with it.
• #include "<ClassName>.generated.h" — the header tool's generated code. Always the last include in any header declaring a reflected type (you met this rule in Lesson 1.4).

// The canonical header include order for a reflected class:
#pragma once

#include "CoreMinimal.h"              // 1. core types
#include "GameFramework/Actor.h"      // 2. the base class you derive from
// ... any other real includes you truly need in the header ...
#include "MyActor.generated.h"        // 3. ALWAYS LAST

class UStaticMeshComponent;           // forward declares can sit above or below CoreMinimal

Hands-on Exercise & Quiz

Summary

📚 Additional Resources

• Unreal Engine Modules (Epic)
• Epic C++ Coding Standard (Epic)

🚀 What's Next?

You know how the project is organized. Now the centerpiece: the reflection system — what UCLASS, USTRUCT, and UENUM actually do, and why they're the reason C++ and the editor can talk at all.