Godot 4 for game makers.

Switch from Unity or Unreal, take home free CC0 shaders and starters, and learn the engine in labs that run on the page.

Free library

7 Godot 4.7 projects · CC0 · use them in anything, commercial included Browse the library →
  • A Godot project you can open, not loose files
  • Full source and every parameter on the page
  • Tested on Forward+, Mobile and Compatibility
  • No credit required

Bring your engine with you

Your old term on the left, the Godot name on the right, and the code for both Migration hub →

Same job, three languages

Unity and Unreal on the left, Godot on the right. More recipes on the migration hub →

Run once when the object is ready

Start() BeginPlay _ready()

Unity C#
void Start() { targetHp = maxHp; }
Unreal C++
void BeginPlay() override { Super::BeginPlay(); TargetHp = MaxHp; }
Godot GDScript
func _ready() -> void:
    target_hp = max_hp

_ready() fires once a node and all its children have entered the scene tree — the right place for @onready-dependent setup. Open in the dictionary →

Run every frame

Update() Event Tick _process(delta)

Unity C#
void Update() { transform.position += v * Time.deltaTime; }
Unreal C++
void Tick(float DeltaTime) override { /* ... */ }
Godot GDScript
func _process(delta: float) -> void:
    position += v * delta

Per-frame logic; use _physics_process for physics-step logic. Open in the dictionary →

Spawn a prefab

Instantiate() SpawnActor PackedScene.instantiate()

Unity C#
var bullet = Instantiate(bulletPrefab, muzzle.position, Quaternion.identity);
Unreal C++
AActor* Bullet = GetWorld()->SpawnActor<ABullet>(BulletClass, MuzzleTransform);
Godot GDScript
var bullet := bullet_scene.instantiate()
bullet.global_position = muzzle.global_position
get_tree().current_scene.add_child(bullet)

Load or @export a PackedScene, call instantiate(), then add_child() it into the tree. Open in the dictionary →

Tell listeners something happened

UnityEvent / C# event Event Dispatcher signal

Unity C#
public UnityEvent onDied;
onDied.Invoke();
Unreal C++
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnDied);
OnDied.Broadcast();
Godot GDScript
signal died
died.emit()

Declare a signal, emit it, and connect listeners — no manual unsubscribe needed. Open in the dictionary →

Show a field in the Inspector

[SerializeField] UPROPERTY(EditAnywhere) @export

Unity C#
[SerializeField] private float moveSpeed = 5f;
Unreal C++
UPROPERTY(EditAnywhere, BlueprintReadWrite)
float MoveSpeed = 5.f;
Godot GDScript
@export var move_speed: float = 5.0

@export exposes a typed variable to the Inspector and to scene/resource serialization. Open in the dictionary →

Remove an object

Destroy() DestroyActor / K2_DestroyActor queue_free()

Unity C#
Destroy(gameObject);
Unreal C++
Destroy();
Godot GDScript
queue_free()

queue_free() frees the node at the end of the current frame; use free() only when you need it gone immediately and know it's safe. Open in the dictionary →

Play in the browser

A Godot scene rebuilt in three.js. Pick a node, change a value, and read the same thing in GDScript, Unity C# and Unreal C++
Scene

Click a node. The Inspector and the code follow.

COINS 0 / 6 W A S D move Space jump drag look
Inspector
PlayerCharacterBody3D

Godot has a body for this: CharacterBody3D and move_and_slide() handle slopes, stairs and walls. Unity's CharacterController and Unreal's Character Movement Component do the same job. Unreal measures in centimetres. Try the coin on the platform, then raise Jump Velocity.

Godot player.gd
extends CharacterBody3D
 
@export var speed := 5.0
@export var jump_velocity := 4.5
@export var gravity := 9.8
 
func _physics_process(delta: float) -> void:
    if not is_on_floor():
        velocity.y -= gravity * delta
    if Input.is_action_just_pressed("jump") and is_on_floor():
        velocity.y = jump_velocity
    var input := Input.get_vector("left", "right", "forward", "back")
    var dir := (transform.basis * Vector3(input.x, 0, input.y)).normalized()
    velocity.x = dir.x * speed
    velocity.z = dir.z * speed
    move_and_slide()
Unity Player.cs
public class Player : MonoBehaviour
{
    [SerializeField] float speed = 5.0f;
    [SerializeField] float jumpVelocity = 4.5f;
    [SerializeField] float gravity = 9.8f;
    CharacterController controller;
    float verticalVelocity;
 
    void Awake() => controller = GetComponent<CharacterController>();
 
    void Update()
    {
        if (controller.isGrounded && verticalVelocity < 0)
            verticalVelocity = -2f; // stay pressed to the floor instead of piling up gravity
        if (controller.isGrounded && Input.GetButtonDown("Jump"))
            verticalVelocity = jumpVelocity;
        verticalVelocity -= gravity * Time.deltaTime;
        var input = new Vector3(Input.GetAxis("Horizontal"), 0, Input.GetAxis("Vertical"));
        var move = transform.TransformDirection(input) * speed;
        move.y = verticalVelocity;
        controller.Move(move * Time.deltaTime);
    }
}
Unreal PlayerCharacter.cpp
// APlayerCharacter : public ACharacter. Unreal measures in centimetres.
APlayerCharacter::APlayerCharacter()
{
    GetCharacterMovement()->MaxWalkSpeed = 500.f;
    GetCharacterMovement()->JumpZVelocity = 450.f;
    GetCharacterMovement()->GravityScale = 1.00f;
}
 
void APlayerCharacter::Move(const FInputActionValue& Value)
{
    const FVector2D Input = Value.Get<FVector2D>();
    AddMovementInput(GetActorForwardVector(), Input.Y);
    AddMovementInput(GetActorRightVector(), Input.X);
}
// Jump() comes from ACharacter.
Output
Play, and the signals the scene fires show up here.

26 copy-ready recipes

Small GDScript pieces for the things every game needs. Pick one to read it All recipes →
screen_shake.gd UI Open the recipe →
Screen Shake EffectCamera shake effect triggered by events like explosions or damage
extends Camera2D
 
var shake_intensity := 0.0
var shake_decay: float = 5.0
 
func shake(intensity: float = 10.0, duration: float = 0.3) -> void:
    shake_intensity = intensity
 
    var tween := create_tween()
    tween.tween_property(self, "shake_intensity", 0.0, duration)
 
func _process(delta: float) -> void:
    if shake_intensity > 0:
        offset = Vector2(
            randf_range(-shake_intensity, shake_intensity),
            randf_range(-shake_intensity, shake_intensity)
        )
    else:
        offset = Vector2.ZERO
GDScript · Godot 4.719 lines

41 articles, all checked against Godot 4.7

Grouped by what you are building. Every row opens the article All articles →

3D & rendering

5
Why Does My Godot 3D Scene Look So Dark? Godot looks bright in the editor but dark when you run it? Check preview lighting, materials, ambient light, camera overrides, exposure, and renderer differences. Guide · 7 min

2D, physics & animation

5
Build a Godot 2D Platformer That Actually Feels Responsive Tune a responsive Godot 4 platformer controller with acceleration, coyote time, jump buffering, variable jump height, and a repeatable movement test loop. Tutorial · 18 min

Systems & structure

6
State Machines in Godot 4: From an Enum to Node-Based Enemy AI Build state machines in Godot 4 the practical way: an enum FSM for a player, a node-based StateMachine with typed State children, enemy Idle, Patrol, Chase and Attack states that share one actor, NavigationAgent2D pathfinding, and the mistakes that make each approach fall apart. Tutorial · 14 min

GDScript & code

5
Learn GDScript in 30 Minutes: Variables to Signals, With the Errors You Will Hit A 30-minute GDScript course for Godot 4: variables, types, conditions, loops, functions, arrays and dictionaries, node lifecycle, input, @export, @onready, and signals, with the exact parser and runtime errors beginners hit and how to read them. Tutorial · 15 min

Releases, fixes & making games

8
Godot 4.7.2 Update Guide: What to Check in Your Project Godot 4.7.2 is the current stable release as checked September 8, 2026. Review its fixes and use a practical upgrade checklist for 3D, input, and exports. News · 5 min
Migration 12 articles

Unity and Unreal guides live in the migration desk, next to the translations.

Back to the migration desk ↑

Made by Mete.

A small experiment, a clear explanation, then something you can use in your own game. Starting fresh or switching engines, there is room for both here.