Your First Multiplayer Prototype in 30 Minutes

Most multiplayer tutorials start by teaching you about sockets, serialization and authoritative servers — and lose you somewhere around hour three. This one is different. By the end you’ll have two clients connected to the same server-authoritative world, and you won’t have written a single line of netcode.

Step 1 — Create your project

Log into the control panel and create a new project. This gives you a server-side environment with a script repository, a default world, and a set of connection credentials. There’s nothing to provision and no server to rent — the platform handles all of it, and it’s free until you launch.

Step 2 — Define an entity

Everything in a Planetary Processing world is an entity, and an entity’s behaviour comes from a Lua script. For a movement prototype we only need one entity type: a player. Create a player script with a tiny update loop.

-- player.lua
function init(self)
  self.data.x = 0
  self.data.y = 0
end

function update(self)
  local input = self.client.input
  if input then
    self.data.x = self.data.x + (input.dx or 0)
    self.data.y = self.data.y + (input.dy or 0)
  end
end

That’s the whole server. The position lives on the server, the server owns the truth, and clients simply send their intended movement. This is what we mean by server-side authority — cheating and desync get much harder when the world’s state is defined entirely by scripts you control.

Step 3 — Install the SDK

Grab the plugin for your engine and drop it into your project. The SDK is the bridge between your client and our servers: it opens the connection, authenticates, and — crucially — keeps your local copy of nearby entities in sync automatically.

• Unity — import the package and add the connection component to your scene.
• Unreal — enable the plugin and drop in the provided subsystem.
• Godot — add the addon and autoload the client singleton.
• Defold & LÖVE — require the module and call connect().

Step 4 — Connect and sync

Point the SDK at your project credentials and connect. The plugin spawns a local representation of every entity the server tells it about and updates their transforms as the server simulation ticks. When your player entity’s x and y change on the server, the SDK moves the matching object on every connected client. You render it; we keep it in sync.

// Unity (C#) — send input each frame
void Update() {
    var dx = Input.GetAxis("Horizontal");
    var dy = Input.GetAxis("Vertical");
    PP.Client.SendInput(new { dx, dy });
}

Step 5 — Run two clients

Build and launch the game twice — or open a second instance — and move one window. The other window sees it move, because both are watching the same authoritative entity on the same server. That’s a working multiplayer prototype.

Where to go next

1. Add a second entity type — a pickup, a projectile, an NPC — and give it its own script.
2. Use the chunk system to let your world grow beyond a single screen.
3. Read up on dimensions if you want isolated matches or instanced rooms.
4. Jump into our Discord and show off your prototype.

The fastest way to learn the platform is to ship something tiny and then keep adding. Thirty minutes in, you already have the foundation — the rest is just your game.