Creating Your First Multiplayer Game in Godot

This comprehensive guide shows you how to create a simple multiplayer game from scratch in Godot that connects to a dedicated server hosted on PlayFlow Cloud. This setup is compatible with both web and desktop platforms using TCP + TLS (“wss” protocol).

Godot 4.x - This guide uses Godot 4.4, but any 4.x version should work. We’ll be using the Compatibility renderer for web platform support.

Complete Project

Download the complete project files from GitHub (community-maintained sample)

What You’ll Build

By the end of this tutorial, you’ll have:

A 3D multiplayer game with player movement
Connection UI for server details
WebSocket networking with TLS support
Multiplayer synchronization using Godot’s built-in systems
A working dedicated server setup on PlayFlow

Before We Begin

Create New Project

Create a new Godot project and select the Compatibility renderer. This ensures web platform compatibility.

Set Up Main Scene

Create a new scene, save it as “main.tscn” and select 3D Scene as the root type. Right-click the file after saving and select Set as Main Scene.

Part 1: Building the Connection UI

Let’s start by creating the user interface that players will use to connect to your PlayFlow server.

Create Connection Display

Open main.tscn and add a child node of type Control
Rename it to “ConnectionDisplay”
Set Custom Minimum Size to X: 256.0px and Y: 128.0px

Add Container Layout

Add a child node to “ConnectionDisplay” of type VBoxContainer
Set Layout Mode to Anchors and Anchors Preset to Full Rect

Create URL Input Field

Add a child node to “VBoxContainer” of type HBoxContainer
Add a TextEdit child to “HBoxContainer” and rename it to “UrlInput”
Set Placeholder Text to “Url”
Toggle on Fit Content Height
Set Custom Minimum Size to X: 192.0px and Y: 32.0px
Toggle on Expand under Horizontal

Create Port Input Field

Add another TextEdit child to “HBoxContainer” and rename it to “PortInput”
Set Placeholder Text to “Port”
Toggle on Fit Content Height
Toggle on Expand under Horizontal

Add Connection Buttons

Add a Button child to “VBoxContainer” and rename it to “ConnectButton”
Set Text to “Connect”
Add another Button child to “VBoxContainer” and rename it to “DisconnectButton”
Set Text to “Disconnect”

Set Unique Names

Right-click each input and button node and select Access as Unique Name. This allows us to reference them easily in scripts.

Create Connection Display Script

Right-click “ConnectionDisplay” and select Attach Script
Create a new script called “connection_display.gd”
Add the following code:

extends Control

@onready var url_input: TextEdit = %UrlInput
@onready var port_input: TextEdit = %PortInput
@onready var connect_button: Button = %ConnectButton
@onready var disconnect_button: Button = %DisconnectButton

func _ready() -> void:
    disconnect_button.visible = false
    multiplayer.connection_failed.connect(_on_connection_failed)

func _on_connect_button_pressed() -> void:
    connect_button.visible = false
    disconnect_button.visible = true
    url_input.editable = false
    port_input.editable = false
    MultiplayerManager.start_client(url_input.text, port_input.text)

func _on_disconnect_button_pressed() -> void:
    connect_button.visible = true
    disconnect_button.visible = false
    url_input.editable = true
    port_input.editable = true
    MultiplayerManager.disconnect_from_server()

# If we are unable to connect then we enable the connect button and text inputs again.
func _on_connection_failed() -> void:
    connect_button.visible = true
    disconnect_button.visible = false
    url_input.editable = true
    port_input.editable = true

Connect Button Signals

Select the “ConnectButton” and go to the Node tab next to the Inspector
Connect the “pressed()” signal to “ConnectionDisplay”
Repeat for “DisconnectButton”

Add Game Environment

Add a child node to “Main” of type MeshInstance3D and rename it to “Ground”
Assign a new PlaneMesh to the Ground
Set the PlaneMesh Size to X: 10m and Y: 10m
Add a child node to “Main” of type Node3D and rename it to “Players”
Add a child node to “Main” of type MultiplayerSpawner
Add a Camera3D as a child to “Main” and position it as desired
Add a DirectionalLight3D as a child to “Main” and rotate it (suggested: X: -60.0)

Part 2: Creating the Multiplayer Manager

Now we’ll create a Multiplayer Manager to handle all networking aspects of our game.

Create Multiplayer Manager Scene

Create a new scene, save it as “multiplayer_manager.tscn”
Select Node as the root type

Create Multiplayer Manager Script

Right-click the root node and select Attach Script
Create a new script called “multiplayer_manager.gd”
Add the following code:

extends Node

# Internal server port
const PORT: int = 8080

@onready var peer = WebSocketMultiplayerPeer.new()

func _ready() -> void:
    # The server should always automatically start
    if is_server():
        start_server()

func start_server() -> void:
    var err: Error = peer.create_server(PORT)
    if err == 0:
        multiplayer.multiplayer_peer = peer
        multiplayer.peer_disconnected.connect(_on_peer_disconnected)

func start_client(url: String, port: String) -> void:
    # If you want to use localhost (i.e you run a windows server export on your PC for testing), then it must be ws:// instead.
    var err: Error = peer.create_client("wss://" + url + ":" + port)
    if err == 0:
        multiplayer.multiplayer_peer = peer

func disconnect_from_server() -> void:
    peer.close()

func is_server() -> bool:
    # Exports have tags and this lets us identify if the build is a dedicated server.
    return OS.has_feature("dedicated_server")

func _on_peer_disconnected(id: int) -> void:
    var nodes = get_tree().get_nodes_in_group("Players")
    for node in nodes:
        if node.get_multiplayer_authority() == id:
            node.queue_free()
            break

Add as Autoload Singleton

Go to Project → Project Settings → Autoload
Set Path to “res://multiplayer_manager.tscn”
Set Node Name to “MultiplayerManager”
Click Add

This makes the MultiplayerManager available globally throughout your project.

Part 3: Creating the Player

Let’s create the player character with movement and networking synchronization.

Create Player Scene

Create a new scene, save it as “player.tscn”
Select 3D Scene as the root type (this creates a Node3D)
Add MeshInstance3D as a child to Player
Assign a CapsuleMesh to the MeshInstance3D
Move the MeshInstance3D up by Y: 1.0m so it sits on the ground

Add Network Synchronization

Add a MultiplayerSynchronizer as a child to Player
In the MultiplayerSynchronizer, click Add property to sync
Select Player → position under Node3D

This ensures player positions are automatically synchronized across all clients.

Add Player to Group

Select the Player root node
Go to the Groups tab next to the Inspector
Add the player to group “Players” (type “Players” and click Add)

Create Player Script

Right-click the Player root node and select Attach Script
Create a new script called “player.gd”
Add the following movement code:

extends Node3D

@export var speed: float = 5.0

func _process(delta: float) -> void:
    if not is_multiplayer_authority(): return
    var input_dir: Vector2 = Input.get_vector("move_left", "move_right", "move_forward", "move_backward")
    var offset: Vector3 = (transform.basis * Vector3(input_dir.x, 0, input_dir.y)).normalized() * speed * delta
    translate(offset)

Part 4: Input Mapping and Player Spawning

Configure Input Map

Go to Project → Project Settings → Input Map
Add these input actions (click Add New Action for each):
- move_forward - Assign W key and Up Arrow
- move_backward - Assign S key and Down Arrow
- move_left - Assign A key and Left Arrow
- move_right - Assign D key and Right Arrow

Create Player Spawning System

In main.tscn, select the MultiplayerSpawner node
Right-click and Attach Script, create “spawner.gd”
Add the following code:

extends MultiplayerSpawner

func _ready() -> void:
    spawn_function = spawn_player
    # We only want the server spawning new players when new peers connect
    if MultiplayerManager.is_server():
        multiplayer.peer_connected.connect(_on_peer_connected)

func spawn_player(peer_id: int) -> Node:
    var player: Node = load(get_spawnable_scene(0)).instantiate()
    player.set_multiplayer_authority(peer_id)
    return player

func _on_peer_connected(id: int) -> void:
    spawn(id)

Configure MultiplayerSpawner

Set Spawn Path to “Players” (the Node3D we created earlier)
Under Auto Spawn List, click Add Element
Set the scene path to “res://player.tscn”

This tells the spawner which scene to instantiate and where to place new players.

Part 5: Server Export Configuration

Add Linux Export Preset

Go to Project → Export
Click Add… and select Linux/X11
Rename the preset to “Linux Server”
Set the export path filename to “Server”. Note the exact name you use here — when you upload the build, the executable path you configure must match this exported binary name so PlayFlow knows which file to run.

Configure for Dedicated Server

In the Linux Server preset, go to the Resources tab
Set Export Mode to “Export as dedicated server”
This will create a headless server build suitable for PlayFlow

Export the Server

Click Export Project…
Choose your export location
Toggle Export With Debug for development builds
Click Save

Create Archive

Create a .zip archive of all exported files. This is what you’ll upload to PlayFlow.

PlayFlow expects a .zip file containing your server executable and any required assets.

Part 6: Deploy to PlayFlow and Test

Upload to PlayFlow

Create your PlayFlow account at app.playflowcloud.com
Create a new project for your Godot game
Open the project’s Builds page and upload your server .zip file there

Prefer automation? You can upload builds through the API instead: request an upload URL with POST /api/v3/builds/upload-url?name=YOUR_BUILD and PUT the zip to the returned upload_url. See the API guide for details.

Configure Network Port

CRITICAL: When configuring the port in PlayFlow:

Set Port Number to 8080 (matches our server code)
Set Protocol to TCP
Enable TLS - This is required for “wss://” protocol used in browser games

Without TLS enabled, web clients cannot connect to your server. This is essential for browser compatibility.

Start Server Instance

Create and start a server instance in PlayFlow
Copy the Host URL and External Port from the server details

The External Port is allocated by PlayFlow and will differ from your internal 8080. Always read the host and external port from the running server (the network_ports[] array in the API response, or the server details in the dashboard) rather than assuming a fixed port.

Test the Connection

Run your Godot project locally (you can enable Multiple Instances in Debug settings for testing)
Enter the PlayFlow Host URL in the “Url” field
Enter the External Port in the “Port” field
Click Connect
Your player should appear and you can move around with WASD keys!

Testing Multiple Players: Enable Debug → Customize Run Instances → Enable Multiple Instances and set instance count to 2. Run the game and connect both instances to see multiplayer in action.

Technical Architecture

Network Setup

Protocol: WebSocket with TLS (“wss://”)
Server Port: 8080 (internal)
Synchronization: Player position only
Authority: Server-authoritative with client input

Key Components

MultiplayerManager: Handles connection logic and server detection
Player: Networked player with movement and authority management
ConnectionDisplay: UI for entering server connection details
MultiplayerSpawner: Automatically spawns players when clients connect

Platform Support

Desktop: Windows, Linux, macOS
Web: Browser support via WebSocket + TLS
Server: Headless Linux builds for PlayFlow

Next Steps

Lobby System

Add lobbies and matchmaking

WebGL Deployment

Deploy for web browsers

Common Issues

Connection timeout or 'wss://' connection failed

Verify the server URL and port are correct
Ensure TLS is enabled in PlayFlow port configuration
Check that the PlayFlow server instance is running
For local testing, use “ws://” instead of “wss://” (localhost only)

Players not synchronizing or appearing

Check that MultiplayerSynchronizer is properly configured on the player
Verify the player scene is added to MultiplayerSpawner’s Auto Spawn List
Ensure players are being added to the “Players” group
Check that spawn_function is set correctly in spawner.gd

Server not starting automatically

Verify MultiplayerManager is added as an Autoload singleton
Check that OS.has_feature("dedicated_server") returns true in server builds
Ensure the “Export as dedicated server” option is enabled in export settings

Input not working

Check that input actions are properly defined in Project Settings → Input Map
Verify is_multiplayer_authority() check in player movement code
Ensure the player has authority set via set_multiplayer_authority()

Resources

Godot Documentation: docs.godotengine.org
Godot Multiplayer: docs.godotengine.org/en/stable/tutorials/networking
PlayFlow Documentation: docs.playflowcloud.com
Complete Project: GitHub Repository

​Creating Your First Multiplayer Game in Godot

Complete Project

​What You’ll Build

​Before We Begin

​Part 1: Building the Connection UI

​Part 2: Creating the Multiplayer Manager

​Part 3: Creating the Player

​Part 4: Input Mapping and Player Spawning

​Part 5: Server Export Configuration

​Part 6: Deploy to PlayFlow and Test

​Technical Architecture

​Network Setup

​Key Components

​Platform Support

​Next Steps

Lobby System

WebGL Deployment

​Common Issues

​Resources

Creating Your First Multiplayer Game in Godot

What You’ll Build

Before We Begin

Part 1: Building the Connection UI

Part 2: Creating the Multiplayer Manager

Part 3: Creating the Player

Part 4: Input Mapping and Player Spawning

Part 5: Server Export Configuration

Part 6: Deploy to PlayFlow and Test

Technical Architecture

Network Setup

Key Components

Platform Support

Next Steps

Common Issues

Resources