GD-Sync Godot Multiplayer Tutorial

What is the difference between GD-Sync and Godot's built-in multiplayer API?

Both GD-Sync and Godot's built-in High-Level API are peer-to-peer at their core, meaning gameplay logic runs locally. The difference lies in the infrastructure and workflow.

While Godot’s native networking gives you complete control over your architecture, raw ENet requires the host to manually open a port on their router (port forwarding) or forces you to implement complex NAT punch-through logic, which is notoriously unreliable and often fails. To avoid this, you would have to build and host your own relay server.

GD-Sync removes these infrastructure barriers entirely. It provides a globally managed relay service out of the box, where players connect outbound to GD-Sync servers, bypassing NAT and router configuration completely. Paired with a clean, straightforward API and powerful custom nodes, GD-Sync is significantly easier to use and drastically reduces your setup time.

Full Feature Comparison

Every major decision point between GD-Sync and the built-in API, in one table.
‍

Side-by-Side: Starting a Session

The same goal, two players connected in a shared session. The difference in boilerplate is why most Godot developers choose GD-Sync.

With GD-Sync, you connect to the managed global relay and create a session in about 10 lines of code. With Godot's native ENetMultiplayerPeer, you have to write separate client and server logic, handle IP addresses manually, and crucially, either force your host to configure port forwarding on their router or implement NAT punch-through.

# Connect to the managed relay and automatically handle NAT
extends Node

func _ready() -> void:
    # 1. Listen for connection and lobby events
    GDSync.connected.connect(_on_connected)
    GDSync.lobby_created.connect(_on_lobby_created)
    
    # 2. Connect to the GD-Sync global network
    GDSync.start_multiplayer()

func _on_connected() -> void:
    # 3. Create a public lobby for up to 4 players
    GDSync.lobby_create("MyLobby", "", true, 4)

func _on_lobby_created(lobby_name: String) -> void:
    # 4. Join the lobby you just created.
    #    Other players can join it using the lobby_name.
    GDSync.lobby_join(lobby_name, "")

# NOT global out-of-the-box. Remote play requires manual IP
# configuration, port forwarding, or custom NAT punch-through.
extends Node

func _ready() -> void:
    multiplayer.peer_connected.connect(_on_peer_connected)
    multiplayer.peer_disconnected.connect(_on_peer_disconnected)
    multiplayer.connected_to_server.connect(_on_connected)
    multiplayer.connection_failed.connect(_on_failed)

# --- Server Side (Host) ---
func start_server() -> void:
    var peer = ENetMultiplayerPeer.new()
    if peer.create_server(7777, 32) != OK:
        print("Host error")
        return
        
    multiplayer.multiplayer_peer = peer
    # Global play requires Port Forwarding or NAT punch-through
    print("Server started")

# --- Client Side (Joiner) ---
func join_server(ip: String) -> void:
    var peer = ENetMultiplayerPeer.new()
    if peer.create_client(ip, 7777) != OK:
        print("Connect error")
        return
        
    multiplayer.multiplayer_peer = peer

# --- Network Callbacks ---
func _on_peer_connected(id: int) -> void:
    print("Peer connected: ", id)
    # Still required: Manual RPCs, matchmaking, etc.

func _on_peer_disconnected(id: int) -> void:
    print("Peer disconnected: ", id)

func _on_connected() -> void:
    print("Connected to host")

func _on_failed() -> void:
    print("Connection failed")

Lobbies & Matchmaking

Building a lobby system from scratch in Godot requires a matchmaking server, session browser, and database infrastructure.

GD-Sync includes a first-class lobby system natively. GDSync.lobby_create() allows you to set player limits, passwords, and custom tags (like game mode or map). Players can browse active sessions using GDSync.get_public_lobbies(), and if a host disconnects, GD-Sync automatically handles host migration, firing the host_changed signal on all connected clients.

When to Choose Each

Frequently Asked Questions

Ready to Start?

If GD-Sync is the right fit, the getting started tutorial walks through the full setup in 10 minutes. For the complete API reference see the official documentation.
‍