Fusion Godot Intro

Overview

Photon Fusion Godot brings scalable multiplayer networking to Godot Engine 4.6 as a drop-in GDExtension addon. It is built on top of the same battle-tested infrastructure that powers thousands of live titles across every major platform. You get room-based matchmaking, efficient state replication with late join support, forecast physics prediction and flexible RPCs. And better, everything is designed from the ground up to feel native to Godot's node-based workflow.

Simple Connection and Matchmaking

Getting players into the same session is the first challenge when creating a multiplayer game. Fusion handles this end to end: game clients connect to Photon Cloud's global network of region clusters, and get matched into a room instance, all done directly in GDScript (or C# with Godot .Net). Rooms are configurable with max player counts, custom properties and lobby filtering, so you can build anything from a quick-match to a private lobby system.

You do not need to provision or maintain any servers. Photon manages hosting, scaling and region routing worldwide.
See Connection & Matchmaking for the full API.

GDScript

FusionClient.connect_to_server("player_42", "us")
FusionClient.connected_to_server.connect(func():
    FusionClient.join_or_create_room("arena", {"max_players": 8})
)

Shared Authority Replication

In traditional client-server networking, one player hosts and every other player depends on that host's connection and hardware. Fusion uses a shared authority model instead: every client owns and simulates its own objects locally, while the Photon Fusion server code maintains a stateful cache of the world. When a new player joins mid-match, they receive the state snapshot automatically, no manual state transfer code required.

Replication works at the property level. Fusion tracks individual values (position, health, score) and only distributes what has actually changed since the last update, keeping bandwidth low while keeping per-object full consistency. For larger worlds and more complex cases, Area of Interest filtering lets you work with dynamic spatial regions so clients only receive updates for nearby objects, scaling gracefully to dozens or even hundreds of players.

If you need extra security, you can even deploy custom server-side plugins that validate state changes before they reach other clients — useful for competitive games or anti-cheat.
See Replication and Interest Area for details.

Engine-First Integration

Fusion was designed with Godot's idioms in mind. FusionReplicator is a regular child node, add it to any spawnable scene and it handles networking for that object tree. There are no special base classes to inherit from, no complicated custom node types to learn and also no engine rebuild (Fusion is a GDExtension you can use with the stock engine, including the version from Steam).

You write gameplay code in GDScript, use the scene tree, connect signals and configure properties in the inspector exactly as you would in a single-player project.

Spawning networked objects follows the same pattern: register a packed scene with FusionSpawner, call spawn() and it will be created on every client in the same room.
The Quick Start Guide walks through a full example in under 10 minutes.

GDScript

var player_scene = preload("res://player.tscn")
spawner.add_spawnable_scene(player_scene)
var player = spawner.spawn()

Smooth Physics and Transform Sync

You do not need to implement any of this manually. Set the built-in root transform replication mode to AUTO and Fusion detects the node type, picks the right smoothing strategy and syncs the appropriate properties (position, rotation, velocity) automatically.

And while network replication usualy updates around 30 times per second, players also expect at least smooth 60 fps motion. For regular nodes like CharacterBody or Node3D, Fusion auto-replication comes with render-frame accurate snapshot-interpolation to smoothly blend toward the latest state coming from the object owner.

For RigidBody nodes (2D and 3D), it goes further with forecast physics prediction, which extrapolates where the body should be using its last known velocity and gravity, then gently correcting drift when the next update arrives. Forecast is fully configurable and works great for Wheeled Vehicles, Boats and many other twitchy physics cases.

Stiffness, damping and teleport thresholds are all tunable in the inspector for fine control.
See Physics Replication for tuning guidelines.

Custom RPCs

Replication keeps continuous state in sync, but games also need one-shot events, like a weapon firing, a chat message, or activating an ability. RPCs let any client invoke a function on other clients without storing anything in the replication buffer. Fusion provides three target strategies: send to everyone, send to a specific role for that object (master client, owner, or server plugin) or send to a specific player by ID.

RPCs also come in two flavors: object-targeted (routed through a FusionReplicator to a specific networked object) and broadcast (delivered globally to all registered receivers). Both use Godot's standard @rpc annotation and support most built-in types including networked node root references.
See RPCs for the full reference.

GDScript

@rpc("any_peer", "call_local")
func take_damage(amount: int):
    health -= amount

func attack():
    FusionClient.rpc(take_damage, 25)

Where to Go Next

• Quick Start Guide — Build a multiplayer demo in 10 steps
• SDK Download — Requirements and installation
• Godot vs Fusion — Comparison with built-in Godot networking
• Connection — Initialization, rooms and signals
• Replication — Authority, replication modes and properties
• Interest Area — Spatial filtering for large worlds
• Spawning — Dynamic networked objects and sub-objects
• RPCs — Remote procedure calls
• Physics Replication — Forecast smoothing for rigid bodies