50,000+ monthly active players

Multiplayer for
Godot 4, done right.

Eliminate weeks of networking hassle. GD-Sync is your all-in-one Godot 4 plugin that delivers intuitive lobbies, effortless player synchronization, cloud storage, and leaderboards rapidly and painlessly.
Stop building infrastructure. Start building games.

Get started for free  →See all features
YouTube Discord GitHub

50.000+
Monthly Active Players

Cross Platform
PC, Mobile and Web Export

< 10
Minutes to host your first lobby

Free
To Get Started

SIMPLE BY DESIGN

Multiplayer in three steps.

No dedicated servers to configure. No low-level networking to learn. Get your game online in three simple steps.

01 — INSTALL

One-click install from the Asset Library

Download GD-Sync directly from the Godot Asset Library. Enable the plugin, paste your API key, and you are instantly hooked into our global infrastructure.

02 — CONNECT

Connect players through global relays

Connect your players seamlessly. GD-Sync routes all traffic through our global relay server network, completely eliminating the need for port forwarding or complex network configurations.

03 — BUILD

Build with powerful nodes and an extensive API

Create a seamless multiplayer experience with ease. GD-Sync offers a massive API with over 100 functions, plus a large library of pre-built nodes to instantly synchronize everything from physics and animations to proximity voice chat.

CODE THAT SPEAKS FOR ITSELF

An API built for game developers.

Say goodbye to confusing server logic and endless boilerplate. GD-Sync gives you a streamlined API where a single, intuitive call replaces hundreds of lines of backend setup.

Connection
Remote Calls
Cloud Storage
Leaderboards
GD-Sync Connection & Lobbies
# 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, "")
GD-Sync Remote Functions
# Easily call functions across the network
extends Node

func _ready() -> void:
	# 1. Expose the function so it can be called remotely
	GDSync.expose_func(update_health)

func _process(_delta: float) -> void:
	if Input.is_action_just_pressed("heal"):
		# 2. Call the exposed function on all connected clients
		GDSync.call_func_all(update_health, 100)
		
		# Or call it on a specific client using their ID:
		# GDSync.call_func_on(client_id, update_health, 100)

func update_health(amount: int) -> void:
	print("Health updated to: ", amount)
GD-Sync Cloud Storage
# Save to cloud — any Godot Variant supported natively
func save_progress() -> void:
	var code = await GDSync.account_document_set(
		"saves/slot1", {
			"level": current_level,
			"inventory": player.inventory
		}
	)
	if code == ENUMS.ACCOUNT_DOCUMENT_SET_RESPONSE_CODE.SUCCESS:
		print("Saved to cloud")

# Load your progress on any device
func load_progress() -> void:
	var res = await GDSync.account_document_get("saves/slot1")
	if res.code == OK:
		apply_save(res.document)
GD-Sync Leaderboards
# Submit score — just one line of code
func submit_score(points: int) -> void:
	var code = await GDSync.leaderboard_submit_score("GlobalHighScores", points)
	if code == ENUMS.LEADERBOARD_SUBMIT_SCORE_RESPONSE_CODE.SUCCESS:
		print("Score submitted!")

# Fetch top 10 global rankings instantly
func get_top_scores() -> void:
	var res = await GDSync.leaderboard_get_scores("GlobalHighScores", 0, 10)
	for entry in res.scores:
		print(entry.username, " — ", entry.score)

WHY GODOT DEVELOPERS CHOOSE GD-SYNC

Write game logic.
Not networking code.

Stop reinventing the wheel. GD-Sync comes loaded with powerful, drag-and-drop nodes that handle the hardest parts of multiplayer automatically. Every system you need is built, tested, and designed to stay entirely out of your way.
‍

PropertySynchronizer

Auto-sync any variable or transform. Includes built-in interpolation for buttery smooth movement.
NodeInstantiator

Spawn scenes across the network instantly. Automatically handles state catch-up for late-joining players.
SynchronizedAnimationTree

Drop it in to keep complex animation states and blend trees perfectly synced across all clients.
VoiceChat

Built-in proximity voice chat with full 2D/3D spatial audio support.

FULL FEATURE SET

One plugin. A complete game backend.

Every feature listed here runs on GD-Sync's global infrastructure and works out of the box.

Property Synchronization

Sync any variable with delta-only updates. Built-in interpolation for positions, rotations, colors, and vectors.

PropertySynchronizer

Synchronized Physics

Automatically synchronize rigid bodies and physics nodes across all clients with built-in interpolation.

SynchronizedRigidBody

Node Instantiation

Spawn scenes on every client simultaneously. Late-joining players are automatically caught up with scene states.

GDSync.multiplayer_instantiate()

Lobbies & Matchmaking

Create public or private lobbies with names, passwords, and custom tags. Includes automatic host migration.

GDSync.lobby_create()

Steam Integration

Seamlessly integrates with GodotSteam. Steam friends can easily join each other directly from their friends list.

GodotSteam Integration

Remote Functions

Cleanly expose functions and call them on specific clients, the host, or broadcast to everyone in the lobby.

GDSync.call_func_all()

Player Accounts

Full authentication system with email verification, bans, and reporting. Fully managed from your dashboard.

GDSync.account_create()

Cloud Storage

Full cloud storage support tied to player accounts. Upload game data, cross-device saves, or anything you would want.

GDSync.account_document_set()

Global Leaderboards

Paginated, global competitive rankings tied directly to the player account system. Fully manageable from your dashboard.

GDSync.leaderboard_submit_score()

Analytics Dashboard

Monitor player counts, data usage, and engagement. Generate separate API keys to track multiple games.

GD-Sync Control Panel

LAN / Offline Mode

Build and ship full LAN multiplayer games for free at no cost. Full sync support included without requiring an account.

GDSync.start_local_multiplayer()

C# & GDScript

The entire API is fully supported in both GDScript and C#. Switch languages without losing any functionality.

Multi-Language Support

Ready to skip the infrastructure work?

Stop building backend systems from scratch. Focus on your gameplay while we handle the heavy lifting.

See all features

COMMUNITY SHOWCASE

Powered by GD-Sync.

Discover how developers are using our infrastructure to bring their multiplayer visions to life across every genre.

Senet: Households

Senet: Households

By Stichting VALUE

Senet: Households is a free digital adaptation of the ancient Egyptian game Senet, featuring unique house rules and three authentic settings, a farm, festival, and palace.

View on Steam →
Battle of the Bookworms

Battle of the Bookworms

By Erik Dusschooten

Battle of the Bookworms is a 2D strategy game where you spawn units, unlock powerups, and advance through ages to defeat the enemy base. Play solo or cross-platform multiplayer.

View on Steam →
The Black and White Doors

The Black and White Doors

By Animatronic Games Studios

A 3D first-person co-op horror game for up to four players. You play as the White Passenger, a robot trapped in a mysterious simulation. Each door you and friends enter could lead to doom. What secrets lie behind them?

View Website →
GD-Sync Shooter Demo

GD-Sync Shooter Demo

By GD-Sync

A simple multiplayer shooter demo showcasing GD-Sync features like basic hit detection and state syncing. Built to demonstrate fully synchronized gameplay in Godot.

View Source Code →

WHO WE ARE

Built by developers who felt the pain firsthand.

We are a small team of game developers who spent way too many hours wiring up networking infrastructure instead of actually shipping games. GD-Sync started as our own personal solution, and we decided to open it up to the entire Godot community.

Our goal is simple: make multiplayer as easy as singleplayer. You shouldn't have to spend months fighting with netcode, port forwarding, or hosting just to let two players share the same world. GD-Sync handles the heavy lifting for you.

We built this to be indie-friendly by design. The free tier is real, and over 50,000 monthly active players are already using it. You only upgrade when your game grows.

Frequently Asked Questions

No. GD-Sync routes all traffic through its own managed global relay network. You don't need to configure, host, or maintain any server infrastructure. Install the plugin, add your API key, and your players are connected.

Yes. GD-Sync offers a free tier with no credit card required. Over 50,000 monthly active players use GD-Sync, and you only need to upgrade when your game grows beyond the free tier limits.

Nakama is a powerful backend but requires self-hosting with Docker, a database, and ongoing server management. GD-Sync is fully managed with no hosting or ops work required. For indie Godot developers who want lobbies, sync, and leaderboards without infrastructure overhead, GD-Sync is significantly faster to ship with.

Most Godot multiplayer solutions require either managing your own server infrastructure or mastering low-level networking concepts, both of which take weeks to get right. GD-Sync is the only solution built exclusively for Godot 4 that combines a fully managed relay network with ready-to-use lobbies, player sync, cloud storage, and leaderboards in a single plugin. No networking expertise required.

GD-Sync is built for the long term and is actively maintained. In the highly unlikely event we ever discontinue the service, our Terms of Service guarantee that we will open-source the complete backend server code. Any game built on GD-Sync can continue running indefinitely on self-hosted infrastructure. Your game is never held hostage by a third-party dependency.

Your multiplayer game is
closer than you think.

Install from the Godot Asset Library in minutes.

Create a free account  →Read the docs
Terms of ServicePrivacy Policy
© 2026 GD-Sync. All rights reserved.