Unreal → Godot 4

Unreal to Godot.
Build what you know.

Bring your Blueprint thinking. Rebuild a player, a pickup, and a HUD with Godot scenes and signals.

Change the structure, keep the idea.

Choose a gameplay object. Map its responsibilities, then build its Godot scene tree.

Your missionBuild a visible, script-controlled 3D character that can collide with the level.

player.tscn

What you know

Unreal structure

Blueprint

BP_Player (Character)Components + behavior

A Blueprint class can combine an Actor, components and behavior. In Godot, a saved scene composes typed nodes, and scripts extend their behavior. Choose the root for its job.

How Godot scenes work

Keep the behavior.
Rebuild who owns it.

Your Godot sceneStructure exercise

player.tscn

PlayerChoose a root below

Add the pieces
this object needs.

Scene illustrationNo root selected

Visible meshCollision shapeUpdates with your choices

1Choose what the root does

Move & collideCharacterBody3DDetect overlapsArea3DArrange an interfaceControlGroup 3D objectsNode3D

2Add its responsibilities

Visible meshMeshInstance3DCollision shapeCollisionShape3DInterface textLabelTime an actionTimer

Choose a root and add children. The diagram shows your choices.

Checks the node structure.
No Godot runtime here.

Build it in Godot

Take this structure into a real project.

Create a CharacterBody3D named Player and save it as player.tscn.
Add MeshInstance3D with a CapsuleMesh, and CollisionShape3D with a CapsuleShape3D. Align their sizes.
Attach player.gd to Player. Instance it in a level with a StaticBody3D floor, a collision shape, and a current Camera3D.

Working in 2D? Use CharacterBody2D / Area2D, Sprite2D, and CollisionShape2D. The same composition idea applies. Explore the editor →

Same behavior. Different code.

Compare a familiar pattern, inspect the changes, and test the idea before opening Godot.

Godot has no built-in Blueprint equivalent. Translate the behavior into scripts; systems such as possession, replication, and Gameplay Ability System need their own design.

Set velocity, then move the body.

Read named actions each physics tick. Godot’s move_and_slide() uses the body’s velocity, in meters per second.

Unreal · Blueprint flowFamiliar pattern

Character Blueprint · Enhanced Input

IA_Move (Vector2D) · Triggered
  → Action Value: X / Y
  → Add Movement Input (Right, X)
  → Add Movement Input (Forward, Y)

Character Movement applies movement.
Choose world or camera-relative directions.

Godot · player.gd

1extends CharacterBody3D
2 
3@export var speed: float = 5.0
4 
5func _physics_process(delta):
6    var input = Input.get_vector(
7        "move_left", "move_right",
8        "move_forward", "move_back")
9    velocity.x = input.x * speed
10    velocity.z = input.y * speed
11    if not is_on_floor():
12        velocity.y -= 9.8 * delta
13    move_and_slide()

Create four actions in Project → Project Settings → Input Map. Forward is negative Z in this world-aligned Godot example.

Try the ideaBrowser model · run the code in Godot

Speed 5 m/s

Start at 0 m. The strip represents 10 meters of unobstructed movement.

Try the code in Godot

Official API guide

Use the Player scene above. Map A/D/W/S to move_left / move_right / move_forward / move_back. This is world-aligned movement without jumping or camera rotation.

Check it worked: Run Main. Hold D for one second on a flat floor: at speed 5, unobstructed motion is about 5 meters along +X.

“How do I do that in Godot?”

Open a task for the exact place to start, what changes, and how to check the result.

Set up inputEnhanced Input actions and mapping contexts → Input Map + Input

Open Project → Project Settings → Input Map.
Add move_left, move_right, move_forward, move_back. Assign A, D, W, S respectively.
Use Input.get_vector() in player.gd. Add gamepad events to the same actions when needed.

Input Map stores named bindings. It does not automatically recreate PlayerInput components or Enhanced Input context priorities.

Check it worked: Change move_right from D to Right Arrow. The same player script should still move right.

Try the input playground Read the 3D migration walkthrough Official documentation ↗

Build UIUMG / Widget Blueprint → Control + Containers

Create a Control scene and use the Full Rect layout preset.
Add a MarginContainer, then a VBoxContainer with two Buttons inside.
Resize the running window. Set Container sizing and anchors rather than hardcoding every position.

Containers arrange their children. A manually positioned child can be repositioned by its parent Container.

Check it worked: Both buttons remain arranged vertically after resizing the window.

Find your way around the editor Read the UI migration guide Official documentation ↗

Share item dataData Asset → Custom Resource

Create item_data.gd: extends Resource, class_name ItemData, and @export var value: int = 1 (each on its own line).
Create a new ItemData resource in the Inspector or FileSystem and save it as coin_data.tres.
Export an ItemData property on a scene script and assign coin_data.tres in the Inspector.

Loaded Resources can be shared. Duplicate a resource or use Local To Scene when instances need independent mutable values.

Check it worked: Assign the same resource to two coins. Changing its saved value updates both references.

Find a data recipe Understand Resources and sharing Official documentation ↗

Move art & audioContent Browser assets and .uasset files → Source assets + Godot import settings

Export one model as glTF/GLB from its source tool; keep textures beside it. Use source PNG textures and WAV/OGG audio.
Copy the files into the Godot project and inspect them in the Import dock.
Instance the model in a test scene. Check scale, materials, animation and collision before importing the rest.

Engine-specific materials, shaders, prefab logic and .uasset files are not portable source assets. Rebuild those systems and check each asset’s usage rights.

Check it worked: One imported model has the intended size and materials in a running Godot scene.

Open the asset import guide Plan the asset and code move Official documentation ↗

Make one small thing work.

Use a fresh test project. Tick these off after checking them in Godot.

0 of 4 checks done

Your checklist stays in this browser.

One player in one roomCreate player.tscn and a Main scene with a floor and camera. The player appears at the right scale.Build the scene

Movement that feels rightMap four actions. Check movement, stopping and collision against a wall.Translate movement

One complete interactionWalk into Coin. It disappears once, and the HUD increases by one.Connect a signal

A build outside the editorInstall export templates and create a build for your target. Check input, art and performance there before expanding the port.Follow the export steps

Go deeper when you need it.

All articles