Concepts & Naming | Unreal to Unity Guide

The Big Picture

Unreal Engine and Unity share many of the same concepts, but they use different names for them. If you've been working in UE for a while, your instincts are right — you just need to learn the new vocabulary.

Don't think of this as "starting over." Think of it as translating what you already know into a new dialect.

Core Terminology

Here's the fundamental mapping between Unreal Engine and Unity concepts:

Core Concepts

Unreal Engine	Unity	Note
`Actor`	`GameObject`	The fundamental entity in a scene
`Component`	`Component`	Modular behavior attached to entities
`Level`	`Scene`	A loaded environment/map
`World`	`Scene (active)`	The currently loaded environment
`Blueprint`	`C# Script / Prefab`	Visual scripting → code; template → prefab
`Pawn`	`GameObject (with controller)`	A possessable entity
`Character`	`GameObject + CharacterController`	A pawn with built-in movement
`PlayerController`	`MonoBehaviour (custom)`	Input handling and possession logic
`GameMode`	`GameManager (custom)`	Game rules and state — you build this yourself
`GameInstance`	`DontDestroyOnLoad singleton`	Persistent data across levels/scenes
`HUD`	`Canvas + UI components`	Unity uses a Canvas-based UI system

Project Structure

How you organize assets and code also differs:

Project Organization

Unreal Engine	Unity	Note
`Content Browser`	`Project Window`	Where you browse all assets
`World Outliner`	`Hierarchy Window`	Scene object tree
`Details Panel`	`Inspector Window`	Properties of selected object
`Content/ folder`	`Assets/ folder`	Root asset directory
`Source/ folder`	`Assets/Scripts/`	C++ → C# code lives here
`.uasset files`	`Various formats + .meta`	Unity uses standard formats + metadata

The Component Model

Both engines use a component-based architecture, but Unity goes all-in on composition. In Unreal, you often inherit from base classes (AActor, APawn, ACharacter). In Unity, everything starts as an empty GameObject and you add components.

  
cpp 
// Unreal: Inherit from a base class
UCLASS()
class AMyCharacter : public ACharacter
{
    GENERATED_BODY()
public:
    AMyCharacter();
    virtual void BeginPlay() override;
    virtual void Tick(float DeltaTime) override;
};
 10 lines

  
C# 
// Unity: Add components to a GameObject
public class MyCharacter : MonoBehaviour
{
    private CharacterController controller;
    
    void Start()
    {
        // Get or add components at runtime
        controller = GetComponent<CharacterController>();
    }
    
    void Update()
    {
        // Your game logic here
    }
}
 16 lines

In Unity, MonoBehaviour is the base class for all scripts that attach to GameObjects — similar to how most gameplay classes in UE inherit from AActor.

Key Philosophical Differences

Understanding these differences will help you avoid fighting the engine:

Composition over Inheritance

Unreal encourages deep class hierarchies (AActor → APawn → ACharacter → AMyCharacter). Unity favors flat hierarchies with behavior composed from multiple small components.

This means you'll write more small scripts in Unity instead of one large class. Each script handles one responsibility — movement, health, input, etc.

No Visual Scripting by Default

Blueprints are a core part of Unreal's workflow. Unity's equivalent (Visual Scripting, formerly Bolt) exists but is rarely used in production. C# is the standard.

The good news: if you've used C++ in Unreal, C# will feel familiar but simpler — no header files, no manual memory management, and a cleaner syntax.

Scenes vs Levels

Unreal levels are self-contained worlds. Unity scenes are more lightweight and composable — you can load multiple scenes additively and use them as building blocks.

This is covered in depth in the next chapter.