Unity → Godot 4

Unity to Godot.
Build what you know.

Bring your C# habits. 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

Unity structure

Prefab

Player prefabGameObject + components

A GameObject holds components. In Godot, typed nodes carry responsibilities and child nodes compose the object. A reusable scene is the whole saved tree.

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.

Keep C# if it suits your project. UnityEngine APIs still need replacing with Godot APIs; these examples use GDScript to make the changes easy to read.

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.

Unity · C# excerptFamiliar pattern

// Inside a configured MonoBehaviour.
// moveAction: enabled InputAction (Vector2)
// controller: CharacterController
Vector2 input = moveAction.ReadValue<Vector2>();
Vector3 direction = new(input.x, 0, input.y);
controller.Move(direction * speed * Time.deltaTime);

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.

Prefer C#? See the Godot .NET setup and API changes →

“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 inputInput Actions / PlayerInput → 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 UICanvas / RectTransform / uGUI → 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 dataScriptableObject → 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 & audioProject assets and prefabs → 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