How do I connect a signal in code?

Short answer

$Button.pressed.connect(_on_button_pressed): the signal, .connect, and the function itself without parentheses.

Connect a built-in signal

The script sits on Main, and the button is its child:

• MainNode2Dthe script goes here
  • ButtonButton

In _ready(), take the signal, call .connect() on it, and hand it the function that should run. You pass the function itself, not a call to it, so there are no parentheses after its name:

GDScript

main.gd

extends Node2D

func _ready() -> void:
  $Button.pressed.connect(_on_button_pressed)

func _on_button_pressed() -> void:
  print("Button pressed")

C#

Main.cs

using Godot;

public partial class Main : Node2D
{
    public override void _Ready()
    {
        GetNode<Button>("Button").Pressed += OnButtonPressed;
    }

    private void OnButtonPressed()
    {
        GD.Print("Button pressed");
    }
}

Run the scene and click the button. Every click prints a line, with nothing set up in the editor.

Signals that pass arguments

Some signals send data along. Area2D.body_entered tells you which body came in, so the handler takes that body as a parameter:

main.gd

func _ready() -> void:
  $Area2D.body_entered.connect(_on_body_entered)

func _on_body_entered(body: Node2D) -> void:
  print(body.name, " entered")

The handler must take the same parameters the signal sends, in the same order. To see what a signal sends, select the node, open the Node → Signals dock and read the signature next to its name.

Pass extra values with bind()

Sometimes the handler needs something the signal does not send, like which button was pressed when several share one function. Call .bind() on the function and pass the extra values. They arrive after the signal’s own arguments:

• MainNode2D
  • HBoxContainerHBoxContainer
    • RedButtonButton
    • GreenButtonButton

GDScript

main.gd

extends Node2D

func _ready() -> void:
  $HBoxContainer/RedButton.pressed.connect(_on_color_pressed.bind(Color.RED))
  $HBoxContainer/GreenButton.pressed.connect(_on_color_pressed.bind(Color.GREEN))

func _on_color_pressed(color: Color) -> void:
  print("Picked ", color)

C#

Main.cs

using Godot;

public partial class Main : Node2D
{
    public override void _Ready()
    {
        GetNode<Button>("HBoxContainer/RedButton").Pressed += () => OnColorPressed(Colors.Red);
        GetNode<Button>("HBoxContainer/GreenButton").Pressed += () => OnColorPressed(Colors.Green);
    }

    private void OnColorPressed(Color color)
    {
        GD.Print($"Picked {color}");
    }
}

pressed sends nothing, so color is the only parameter. With a signal that does send data, the signal’s arguments come first and the bound ones after. Binding to body_entered gives a handler of (body: Node2D, side: String):

main.gd

func _ready() -> void:
  $LeftZone.body_entered.connect(_on_zone_entered.bind("left"))
  $RightZone.body_entered.connect(_on_zone_entered.bind("right"))

func _on_zone_entered(body: Node2D, side: String) -> void:
  print(body.name, " entered the ", side, " zone")

In C# there is no Bind. A lambda that calls your method with the extra value does the same job.

Make your own signal

Declare the signal at the top of the script with the parameters it will send, then call .emit() where the value changes:

• MainNode2Dconnects to the signal
  • PlayerCharacterBody2Downs and emits the signal

GDScript

player.gd

extends CharacterBody2D

signal health_changed(new_health: int)

var health := 100

func take_damage(amount: int) -> void:
  health -= amount
  health_changed.emit(health)

main.gd

extends Node2D

func _ready() -> void:
  $Player.health_changed.connect(_on_player_health_changed)

func _on_player_health_changed(new_health: int) -> void:
  print("Health: ", new_health)

C#

Player.cs

using Godot;

public partial class Player : CharacterBody2D
{
    [Signal]
    public delegate void HealthChangedEventHandler(int newHealth);

    private int _health = 100;

    public void TakeDamage(int amount)
    {
        _health -= amount;
        EmitSignal(SignalName.HealthChanged, _health);
    }
}

Main.cs

using Godot;

public partial class Main : Node2D
{
    public override void _Ready()
    {
        GetNode<Player>("Player").HealthChanged += OnPlayerHealthChanged;
    }

    private void OnPlayerHealthChanged(int newHealth)
    {
        GD.Print($"Health: {newHealth}");
    }
}

Notice the direction. Player owns the signal and emits it without knowing who is listening. Main, the node above, connects to it. The child never reaches up to its parent, so you can drop Player into any scene and it still works.

Common mistakes

Calling the function instead of passing it

Parentheses run the function right there and hand its return value, null, to connect(). Drop them:

$Button.pressed.connect(_on_button_pressed())
$Button.pressed.connect(_on_button_pressed)

Wrong number of parameters

If the signal sends one argument and your handler takes none, Godot reports a method call error the moment it fires. Match the handler’s parameters to the signature shown in the Node → Signals dock.

Bound values in the wrong place

Bound values are appended after the signal’s arguments, never before. A handler for body_entered.connect(f.bind("left")) must be func f(body, side), not func f(side, body).

Connecting twice

Connecting the same signal to the same function again raises an error; see Why does it say the signal is already connected?.

Reaching up with get_parent()

get_parent().some_signal.connect(...) or get_parent().do_something() ties the child to one specific parent, so it breaks as soon as you reuse the scene. Emit a signal from the child and let the parent connect.

Related

Why does it say the signal is already connected?Fix the error from connecting the same signal twice.

Using signalsOfficial step-by-step introduction to signals.