In Unreal Engine 5, an Actor is the fundamental building block of a level. Almost everything that exists in the world—whether visible or invisible—is represented as an Actor.

Actors define what exists in the world, where it is located, and how it behaves.

An Actor is an object that can be placed or spawned in a level. It typically contains:

• A Transform (Location, Rotation, Scale)
• One or more Components (mesh, light, collision, etc.)
• Optional logic (via Blueprints or C++)

At its simplest, an Actor can be:

• A static object (e.g., a rock or building)
• A dynamic object (e.g., a moving vehicle)
• A system controller (e.g., PostProcessVolume, GameMode)

Actors themselves are containers. Most of the actual functionality comes from Components attached to them.

Examples:

• A StaticMeshComponent renders geometry
• A LightComponent emits light
• A CameraComponent defines a viewpoint

> Actors organize behavior; Components perform the work.

There are many specialized Actor types in Unreal Engine. Common categories include:

• Static Mesh Actor
• Skeletal Mesh Actor
• Instanced Mesh Actors

• Directional Light
• Point Light
• Spot Light
• Sky Light

• Camera Actor
• Cine Camera Actor

• SkyAtmosphere
• ExponentialHeightFog
• VolumetricCloud

• Pawn (controllable entity)
• Character (Pawn with movement logic)
• PlayerController
• GameMode

• PostProcessVolume
• Trigger Volumes
• Audio Volume
• Physics Volume

Actors can be:

• Placed in a level using the editor
• Spawned dynamically at runtime via Blueprint or C++

Each Actor exists within a Level and participates in the world's update loop.

Every Actor has a Transform:

• Location – position in the world
• Rotation – orientation
• Scale – size

These define where the Actor exists and how it is oriented relative to the world.

Actors can update every frame using Tick:

• Enabled per Actor
• Used for movement, logic, and simulation
• Can be disabled for performance if not needed

Behavior can be implemented via:

• Blueprints (visual scripting)
• C++ (native code)

Actors can interact with each other through:

• Collision and overlap events
• Direct references
• Interfaces
• Event dispatchers

This allows complex systems to be built from many interacting Actors.

Actors are the primary unit of replication in multiplayer:

• Can be marked to replicate
• State changes can be synchronized across clients
• Ownership and authority determine control

An Actor typically goes through:

1. Spawned or placed
2. Initialized (BeginPlay)
3. Updated (Tick, events)
4. Destroyed or removed

Understanding this lifecycle is key to controlling behavior and performance.

• Keep Actors focused on a specific responsibility
• Use Components to modularize functionality
• Avoid excessive Tick usage when not required
• Prefer composition (Components) over inheritance when possible

Actors are the core entities of Unreal Engine:

• Everything in a level is an Actor or part of one
• They define presence, position, and behavior
• They are extended through Components and logic

> If it exists in the world, it is (or is inside) an Actor.