UE5 Core Concepts: Understanding Actor, Component, Blueprint, Level, and GameMode

Start learning UE5 and the jargon comes at you fast: Actor? Component? Blueprint? These are the vocabulary of the UE5 world, and pushing forward without knowing what they mean leaves you able to follow tutorial steps but never able to answer "why do it this way," which means you cannot apply anything.

For example, the place you put a chest is the Level, the chest you placed is an Actor, and the part that gives it its look is a Component. This article organizes the five terms by tying them to concrete things like that. At the end we open the Third Person template and confirm where the character and camera settings live.

What You'll Learn

• Actor: the base class for the "things" you can place in a level
• Component: the "parts" that add capabilities to an Actor
• Blueprint: how logic is built by connecting nodes, and when to use C++ instead
• Level / GameMode: the game's "world" and its "rulebook"
• A hands-on reading of the Third Person template through all five terms

---

Actor

An Actor is the base type for anything you can place in a level. Players, enemies, lights, cameras, and treasure chests are all built as Actors. Think of it as the unit you select and move when you say "move this chest to the right."

In other engines: this corresponds to Unity's GameObject and Godot's Node2D / Node3D. The idea of "one thing placed in the scene" is the same across all three.

A placed Actor can have its location, rotation, and scale changed. That bundle of "where, facing which way, at what size" is called the Transform.

Creating an Actor while the game runs is called Spawn, and removing one is called Destroy. For example, you might spawn a healing item where an enemy died and remove it once it is picked up. Not every speck on screen is an Actor: sparks and confetti are often drawn in bulk by a different mechanism.

For now it is enough to note that some things are placed in the level from the start and some are created during play.

---

Component

A Component is a part that adds capability or appearance to an Actor. A treasure chest, for instance, gets a part that displays the box shape and a part that detects an approaching player. Select the Actor and you are handling the whole chest; select a Component and you are handling one part inside it.

• Static Mesh Component: displays a 3D model such as a wall, floor, or box. The part itself can also be moved and rotated.
• Skeletal Mesh Component: displays a model whose body and joints move using a skeleton. Used for things like a character's appearance.
• Camera Component: adds a viewpoint (camera)
• Movement Component: adds movement logic (walking, flying, and so on)

The character in the diagram uses a capsule to decide the area that hits walls and floors, a Skeletal Mesh to display the body, and a Camera to create the viewpoint. Appearance and collision are separate parts, so shrinking only the appearance will not necessarily change the size of gap it can pass through.

Note that the "Static" in Static Mesh does not mean the model can never move. It also works for things like a door that rotates while keeping its shape.

---

Blueprint

A Blueprint is a system for assembling logic as a diagram. The parts that represent operations are called nodes, and connecting them with lines decides "when to do what." Line up "the game starts → wait 3 seconds → display text," for example, and it runs in that order.

For a hands-on exercise displaying text to confirm behavior, go to the Print String article; for how to hold values, go to Blueprint Variables Basics.

A Blueprint Class is the plan, an Actor is the placed object

"If I am making an Actor, why am I making a Blueprint?" is an easy point to confuse. A Blueprint Class is a plan that bundles the composition of parts and the behavior. Make one BP_Chest based on Actor and you can place many chests in the level from that one plan.

Each individual object created by placing it is called an instance. Even Chest A and Chest B built from the same plan can each hold their own position and their own opened-or-not state. Distinguishing "am I editing the plan, or one placed object?" keeps you from getting lost about where a setting lives.

Choosing between Blueprint and C++

Blueprint writes logic with nodes; C++ writes it with code. UE lets you combine both, so there is no need to commit to one up front. Get something moving in Blueprint first, and when you want to add features in code, the article on dividing responsibility covers how to decide.

---

Level

A Level is the map or scene the player experiences. Actors such as terrain, buildings, lights, and characters are placed in it, and their initial state is saved with it. The "world" we work in inside the UE5 editor is a level. Switching between separate levels — from a title screen into the game, or from a town into a dungeon — is covered in the level transition (Open Level) article.

On big maps, load only what you need

Large games do not pack the entire world into one level; they load only the parts they need.

One approach used on large maps is World Partition. It manages the map as a grid of cells and loads the range you need, such as the area around the player. There is no need to set up partitioning right away for the small room you are building now.

There is also the older approach of manually splitting into two kinds of level. You will often still see this in existing projects.

• Persistent Level: the main level that is always loaded. Holds global settings and Actors that always exist
• Sub-Level: a partial level loaded and unloaded as needed

The diagram above illustrates that manual sub-level approach. Loading ranges in sequence and dropping the ones you do not need is called level streaming. When you get to building large maps, continue to the World Partition and level streaming article.

Note: A similar term is "World." It covers the entire running game world, and levels live inside it. To start with, it is enough to distinguish that the map you save and open in the content browser is a Level.

---

GameMode

GameMode is the class that decides the game's rules and its starting cast. Beyond multiplayer rules such as team deathmatch, it also holds the basic single-player settings of "which character does the player use, and where do they spawn."

Element	Description
Default Pawn Class	The type of controllable object spawned for the player. In Third Person, the character Blueprint
Player Controller Class	The controller mediating between player input and game rules
HUD Class	The type of HUD Actor responsible for the player-facing display. Distinct from the health bar Widget itself
Game State Class	The state of the game as a whole (score, time remaining, and so on)

A Pawn here is an Actor that a player or AI controls. A Character is a kind of Pawn that comes with walking and jumping. To start, note that looking at Default Pawn Class tells you "what you control first."

In networked play, GameMode exists on the server that manages the game. It is not present on every participant's machine. We cover this difference in detail when building multiplayer.

Also, do not write per-character logic such as player movement or attacks in the GameMode. Keep GameMode focused on "the rules of the game as a whole," and put character-specific behavior in the Pawn or Player Controller. The division of responsibility between GameMode, GameState, and PlayerState is explored a level deeper in Understanding the Game Framework.

---

Hands-On: reading the Third Person template with the five terms

From here we use the Third Person template and confirm the five terms on screen. A template is a project starting point where things like a character and camera are already set up. We even run an experiment pulling the camera back a little, to confirm which setting affects what you see.

Create a Blueprint project with "Games → Third Person" and check the following in order. Asset and part names may differ by template version and by the variant you chose.

1. Open the Level: look at the scene with its floors, walls, and stairs. Select the floor or a light in the outliner and you have selected an Actor placed in the level.
2. Look at an Actor during play: press "Play" and move the character. The character you are controlling is an Actor too. Unlike the floor that was placed from the start, this character may be spawned at startup. Once confirmed, press "Stop."
3. Open the Blueprint Class and its Components: search for BP_ThirdPersonCharacter in the content browser and open it. This is the character's plan. Confirm that "Components" contains the collision Capsule Component, the visual Mesh, the Camera Boom that holds the camera at a distance, and the Follow Camera viewpoint.
4. Change one setting: select Camera Boom and note the original value of Target Arm Length (how far the camera sits back). Double it, compile and save, then "Play" the level again. If the camera pulls back in an open area, the part's setting is taking effect. Stop, restore the original value, and save. For the details of how it works, continue to the Spring Arm article.
5. Find where behavior and initial settings live: in the character Blueprint's "Event Graph," look for the logic handling movement and jumping. Then open "Window → World Settings" in the level editor and check GameMode Override. If it is None, the Default GameMode from "Project Settings → Maps & Modes" is used. Open the specified GameMode Blueprint and look at Default Pawn Class under "Class Defaults" to see the plan for the character used at startup.

There are two key points.

• Separate the object from the plan: the Actor you select in the outliner and the Blueprint Class you open from the content browser are different things to edit.
• Tie the setting to the result: change the camera distance, then Play to confirm how it looks. If you get lost, Editor UI Basics covers what each panel is for.

Bonus: Good to Know Up Front

• The Transform really lives on the Root Component: an Actor's location and rotation are strictly held by the component at its base (the Root Component). Knowing that "moving an Actor means moving its Root Component" keeps you from getting lost later when you build component hierarchies
• Actor-to-actor communication is the next topic: when you want to connect Actors, as in "step on the switch and the door opens," continue to three ways to communicate between Actors

Summary: how the five concepts relate

Concept	Role
Actor	The thing (container) you can place in the world
Component	The part that adds a capability to an Actor
Blueprint	The system for building logic with nodes
Level	The game's world, the map itself
GameMode	The rulebook for the game as a whole (server side)

You place Actors in a Level and give them appearance and capability with Components. Bundle the composition and behavior into a Blueprint Class and you can make many Actors from one plan. GameMode decides the game's rules and the character used at startup.

Next, get a "map" of the interface in Editor UI Basics, and set your footing with five settings to check right after creating a project. The overall learning path is laid out in the UE5 learning roadmap.

The next time you want to change a character setting, first ask yourself: "one placed instance, or the shared plan?" and "the whole thing, or a part inside it?" That should narrow down where to look for the setting.

Further Reading

Epic's official docs on Blueprint Class and Setting up a Game Mode cover how plans and initial settings work.