New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Godot Multiplayer

by gamedev-skills in gamedev-skills/awesome-gamedev-agent-skills

Build networked games with Godot 4.7 high-level multiplayer: set up an ENetMultiplayerPeer server/client, define RPCs with the @rpc annotation (call via rpc()/rpcid()), set per-node multiplayer…

Apache-2.0Auto-check passedGame Development

Install Godot Multiplayer

skills CLI
$ npx skills add gamedev-skills/awesome-gamedev-agent-skills --skill godot-multiplayer -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install gamedev-skills/awesome-gamedev-agent-skills godot-multiplayer --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/gamedev-skills/awesome-gamedev-agent-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/godot/godot-multiplayer .claude/skills/godot-multiplayer && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
godot-multiplayer
GitHub stars
1.4k
Token cost
~1.6k tokens
SKILL.md length
440 words
Files
2 (incl. references)
Skills in repo
53
Repo updated
First seen
Licence
Apache-2.0

At a glance

Build networked games with Godot 4.7 high-level multiplayer: set up an ENetMultiplayerPeer server/client, define RPCs with the @rpc annotation (call via rpc()/rpcid()), set per-node multiplayer…

  • Works in 4 steps: Host or join (ENet) → RPCs: client sends input to the server… → Per-node authority (each player controls… → …
  • Adding multiplayer/networking to a Godot project
  • SKILL.md covers When to use, Core workflow, Patterns and Pitfalls, plus 2 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Godot Multiplayer is an agent skill from gamedev-skills/awesome-gamedev-agent-skills. Build networked games with Godot 4.7 high-level multiplayer: set up an ENetMultiplayerPeer server/client, define RPCs with the @rpc annotation (call via rpc()/rpcid()), set per-node multiplayer authority, and replicate state with MultiplayerSpawner and MultiplayerSynchronizer. Use when adding multiplayer/networking to a Godot project, writing @rpc functions, or syncing player/world state across peers.

Its SKILL.md is about 1.6k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files, including reference files (for example `references/replication-and-rpc.md`).

It sits in Game Development, covering Game development and Multiplayer and networking. It works with Godot. The repository describes itself as: 74 game-dev skills for AI coding agents — Godot, Unity, Unreal, Phaser, PixiJS, three.js, Bevy, pygame, LÖVE, Roblox. Portable SKILL.md Agent Skills (the format Anthropic… The licence is Apache-2.0.

When your agent uses it

  • Adding multiplayer/networking to a Godot project
  • Writing @rpc functions
  • Syncing player/world state across peers

Example prompts

  • “/godot-multiplayer”

Workflow steps

4 steps, taken from the step headings in SKILL.md.

  1. Host or join (ENet)
  2. RPCs: client sends input to the server (any_peer, call_local)
  3. Per-node authority (each player controls their own avatar)
  4. MultiplayerSynchronizer config (editor + replication)

What it can do on your machine

Read from SKILL.md and the folder at commit 0a70cfc. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are gdscript).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Godot Multiplayer loads about 1.6k tokens when it runs, and up to ~2.8k if it reads all its reference files. Until then it costs about 106 tokens; SKILL.md has 440 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~106
When it runs · the whole SKILL.md, loaded when a task matches
~1.6k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~2.8k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from gamedev-skills/awesome-gamedev-agent-skills at commit 0a70cfc, republished under its Apache-2.0 licence (© gamedev-skills). 440 words, ~1,615 tokens.

Download SKILL.mdSave it as .claude/skills/godot-multiplayer/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
godot-multiplayer
description
Build networked games with Godot 4.7 high-level multiplayer: set up an ENetMultiplayerPeer server/client, define RPCs with the @rpc annotation (call via rpc()/rpc_id()), set per-node multiplayer authority, and replicate state with MultiplayerSpawner and MultiplayerSynchronizer. Use when adding multiplayer/networking to a Godot project, writing @rpc functions, or syncing player/world state across peers.

Godot Multiplayer (4.x high-level)

Connect peers, call functions remotely with @rpc, assign authority, and replicate state with MultiplayerSpawner/MultiplayerSynchronizer. Targets Godot 4.7 (ENet). Treat all client input as untrusted; keep the server authoritative.

When to use

  • Use when adding networked multiplayer: hosting/joining over ENet, calling RPCs, assigning per-node authority, or auto-spawning/syncing nodes across peers.

When not to use: local split-screen (no networking); raw TCP/UDP/WebSocket protocol work (low-level PacketPeer); HTTP requests. For save/persistence → save-systems.

Core workflow

  1. Create a peer (ENetMultiplayerPeer), call create_server(port, max) or create_client(ip, port), and assign it to multiplayer.multiplayer_peer. The server's unique ID is always 1; clients get random positive IDs.
  2. Handle connection signals on multiplayer: peer_connected(id), peer_disconnected(id), connected_to_server, connection_failed, server_disconnected.
  3. Define RPCs with @rpc(...). Call them on a Callable via rpc() (all peers) or rpc_id(peer_id) (one peer). Inside, multiplayer.get_remote_sender_id() tells you who sent it.
  4. Keep RPC signatures identical on every peer that runs the script — Godot checksums all @rpc methods in a script; mismatches break silently.
  5. Assign authority per node with set_multiplayer_authority(id); gate input/RPCs by is_multiplayer_authority().
  6. Replicate state with MultiplayerSpawner (auto-instances scenes on clients) and MultiplayerSynchronizer (auto-syncs selected properties).
  7. Validate on the server. Don't trust client-reported positions/results.

Patterns

1. Host or join (ENet)
gdscript
const PORT := 7000
const MAX_PLAYERS := 8

func host() -> void:
    var peer := ENetMultiplayerPeer.new()
    var err := peer.create_server(PORT, MAX_PLAYERS)
    if err != OK:
        push_error("Cannot host: %s" % err); return
    multiplayer.multiplayer_peer = peer
    multiplayer.peer_connected.connect(_on_peer_connected)

func join(ip := "127.0.0.1") -> void:
    var peer := ENetMultiplayerPeer.new()
    peer.create_client(ip, PORT)
    multiplayer.multiplayer_peer = peer
    multiplayer.connected_to_server.connect(func(): print("connected"))

func leave() -> void:
    multiplayer.multiplayer_peer = OfflineMultiplayerPeer.new()
2. RPCs: client sends input to the server (any_peer, call_local)
gdscript
func _unhandled_input(event: InputEvent) -> void:
    if event.is_action_pressed("fire") and is_multiplayer_authority():
        request_fire.rpc_id(1)          # send only to the server (id 1)

# Clients may call this; it runs on the server (and locally if server is a player).
@rpc("any_peer", "call_local", "reliable")
func request_fire() -> void:
    var sender := multiplayer.get_remote_sender_id()
    if not _can_fire(sender):           # server-side validation
        return
    spawn_projectile.rpc(sender)        # tell everyone to spawn it

@rpc("authority", "call_local", "reliable")
func spawn_projectile(owner_id: int) -> void:
    _do_spawn(owner_id)
3. Per-node authority (each player controls their own avatar)
gdscript
extends CharacterBody2D

func _ready() -> void:
    # The node name is the owning peer's id; that peer is the authority.
    set_multiplayer_authority(name.to_int())

func _physics_process(delta: float) -> void:
    if not is_multiplayer_authority():
        return                          # only the owner reads input & moves
    velocity = Input.get_vector("left", "right", "up", "down") * 200.0
    move_and_slide()
4. MultiplayerSynchronizer config (editor + replication)
gdscript
# Add a MultiplayerSynchronizer child; in its Replication editor add the properties to
# sync (e.g. position, velocity). Set "Sync"/"Spawn" flags per property. From code you
# can scope visibility:
@onready var sync: MultiplayerSynchronizer = $MultiplayerSynchronizer

func _ready() -> void:
    # Only replicate this node to a specific peer (e.g. private info).
    sync.set_visibility_for(target_peer_id, true)
Show full SKILL.md (215 more words)Show less

Pitfalls

  • RPC signature checksum. Every @rpc method in a script must exist with the same declaration on both client and server builds — even unused ones. A mismatch causes errors that may point at the wrong function. Argument names/count are not checked, but the set of RPCs and their annotations are.
  • Default @rpc is "authority". Clients calling it are ignored unless you set "any_peer". Use "call_local" so the host (also a player) runs it too.
  • NodePaths must match across peers. RPC routing uses the node's path/name; spawn nodes with identical names on all peers (use MultiplayerSpawner or add_child(node, true) for readable, deterministic names).
  • Trusting the client. Never let clients set authoritative state (health, position, hits) directly. Send intent, validate on the server, then broadcast results.
  • RPC on non-Node classes fails. @rpc methods must be on Node-derived classes, not plain Resource/RefCounted.
  • RPCs don't serialize Objects/Callables. Pass plain data (ints, strings, arrays, dictionaries, PackedArrays).
  • Forgetting to reset the peer. To disconnect cleanly, set multiplayer.multiplayer_peer = OfflineMultiplayerPeer.new().
  • Android needs INTERNET permission in the export preset or all networking is blocked.

References

  • For MultiplayerSpawner setup, transfer modes/channels, SceneMultiplayer authentication (auth_callback/complete_auth), a lobby skeleton, and dedicated-server export notes, read references/replication-and-rpc.md.
  • godot-nodes-scenes — instancing the scenes that get spawned/synced.
  • godot-signals-groups — connection signals and event flow.
  • godot-export — exporting a headless dedicated server build.

© gamedev-skills, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 1 other file (references) in skills/godot/godot-multiplayer of gamedev-skills/awesome-gamedev-agent-skills.

  • SKILL.md
  • references/replication-and-rpc.md

Open the folder on GitHubat commit 0a70cfc

Compare with similar skills

Godot Multiplayer next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Godot Multiplayer compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Godot Multiplayer this skillgamedev-skills/awesome-gamedev-agent-skills1.4k—~1.6kAutomated safety check: PassApache-2.0
Godot Server Architecturethedivergentai/GD-Agentic-Skills821—~2.9kAutomated safety check: PassLGPL-3.0
Godot Adapt Single To Multiplayerthedivergentai/GD-Agentic-Skills821—~3.3kAutomated safety check: PassLGPL-3.0
Godot Genre Fightingthedivergentai/GD-Agentic-Skills821—~3.8kAutomated safety check: PassLGPL-3.0
Godot Multiplayer Networkingthedivergentai/GD-Agentic-Skills821—~3.2kAutomated safety check: PassLGPL-3.0
Gamedev Multiplayerericrisco/rsc-harness180—~3.9kAutomated safety check: PassMIT

Similar skills

  • Godot Server Architecture

    thedivergentai/GD-Agentic-Skills

    Expert blueprint for dedicated / headless multiplayer hosts: ENet/DTLS, authority validation, safe packet decode, matchmaker handoff, and health telemetry.

    821 GitHub stars~2.9k tokensUpdated 1 mo ago
    Game DevelopmentAuto-check passed

  • Godot Adapt Single To Multiplayer

    thedivergentai/GD-Agentic-Skills

    Expert patterns for adding multiplayer to single-player games including client-server architecture, authoritative server design, MultiplayerSynchronizer, lag compensation (client prediction, server…

    821 GitHub stars~3.3k tokensUpdated 1 mo ago
    Game DevelopmentAuto-check passed

  • Godot Genre Fighting

    thedivergentai/GD-Agentic-Skills

    Expert blueprint for fighting games including frame data (startup/active/recovery frames, advantage on hit/block), hitbox/hurtbox systems, input buffering (5-10 frames), motion input detection (QCF…

    821 GitHub stars~3.8k tokensUpdated 1 mo ago
    Game DevelopmentAuto-check passed

  • Godot Multiplayer Networking

    thedivergentai/GD-Agentic-Skills

    Expert multiplayer for desync, rollback, dedicated --headless servers, interest culling, and bandwidth spikes: ENet/WebRTC choice, authority, secure RPCs, client prediction/reconcile, and adaptive…

    821 GitHub stars~3.2k tokensUpdated 1 mo ago
    Game DevelopmentAuto-check passed

  • Gamedev Multiplayer

    ericrisco/rsc-harness

    A skill your agent uses when adding multiplayer or netcode to a game — client-server vs P2P, server authority and anti-cheat, state replication vs RPCs, prediction and reconciliation, lag…

    180 GitHub stars~3.9k tokensUpdated yesterday
    Game DevelopmentAuto-check passed

  • Unity

    ericrisco/rsc-harness

    A skill your agent uses when writing, reviewing or structuring Unity game code in C for Unity 6 LTS — GameObjects and the Transform hierarchy, the MonoBehaviour lifecycle, prefabs and variants…

    180 GitHub stars~4k tokensUpdated yesterday
    Game DevelopmentAuto-check passed

More from gamedev-skills/awesome-gamedev-agent-skills

All 53 skills in this repo

  • Create Game Assets

    gamedev-skills/awesome-gamedev-agent-skills

    Plan, generate, source, normalize, and validate cohesive visual game assets.

    1.4k GitHub stars~2k tokensUpdated 2 days ago
    Auto-check passed

  • Roblox UI

    gamedev-skills/awesome-gamedev-agent-skills

    Build production Roblox interfaces with ScreenGui/PlayerGui lifecycle, responsive UDim2 layouts, safe insets, reusable editable Instances, cross-device input and selection, restrained motion…

    1.4k GitHub stars~2.9k tokensUpdated 2 days ago
    Auto-check passed

  • AI Behavior Trees Utility AI

    gamedev-skills/awesome-gamedev-agent-skills

    Build a production behavior-tree runtime (Blackboard, action/condition leaves, sequence/selector/parallel composites, decorators) and a Utility AI system (response curves — linear, exponential…

    1.4k GitHub stars~2k tokensUpdated 2 days ago
    Auto-check passed

  • Bevy Ecs

    gamedev-skills/awesome-gamedev-agent-skills

    Structure a Bevy app around its Entity Component System: build the App with plugins, define Component/Resource types, write systems with Query/Res/Commands, filter and order systems, and use the…

    1.4k GitHub stars~2.5k tokensUpdated 2 days ago
    Auto-check passed

  • Card Game

    gamedev-skills/awesome-gamedev-agent-skills

    Build a card game: card data, deck/hand/discard zones, draw/shuffle/reshuffle, a turn structure, costs, and effect resolution.

    1.4k GitHub stars~1.6k tokensUpdated 2 days ago
    Auto-check passed

  • Fps Shooter

    gamedev-skills/awesome-gamedev-agent-skills

    Build a first-person shooter: move+mouse-look controller, hitscan or projectile shooting, weapons, health, and enemy AI.

    1.4k GitHub stars~1.5k tokensUpdated 2 days ago
    Auto-check passed

Works with

Categories

Questions about Godot Multiplayer

What does Godot Multiplayer do?

Build networked games with Godot 4.7 high-level multiplayer: set up an ENetMultiplayerPeer server/client, define RPCs with the @rpc annotation (call via rpc()/rpcid()), set per-node multiplayer…. Godot Multiplayer is an agent skill from gamedev-skills/awesome-gamedev-agent-skills.7 high-level multiplayer: set up an ENetMultiplayerPeer server/client, define RPCs with the @rpc annotation (call via rpc()/rpcid()), set per-node multiplayer authority, and replicate state with MultiplayerSpawner and MultiplayerSynchronizer.

When should I use Godot Multiplayer?

Godot Multiplayer fits situations like: adding multiplayer/networking to a Godot project; writing @rpc functions; syncing player/world state across peers.

How do I install Godot Multiplayer in Claude Code?

Run `npx skills add gamedev-skills/awesome-gamedev-agent-skills --skill godot-multiplayer -a claude-code`. Or copy the skill folder (skills/godot/godot-multiplayer in gamedev-skills/awesome-gamedev-agent-skills) into .claude/skills/godot-multiplayer in your project. Claude Code loads it when a task matches its description.

How do I install Godot Multiplayer in Codex?

Run `npx skills add gamedev-skills/awesome-gamedev-agent-skills --skill godot-multiplayer -a codex`. Or copy the skill folder (skills/godot/godot-multiplayer in gamedev-skills/awesome-gamedev-agent-skills) into .agents/skills/godot-multiplayer in your project. Codex loads it when a task matches its description.

Can I use Godot Multiplayer in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add gamedev-skills/awesome-gamedev-agent-skills --skill godot-multiplayer -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/godot-multiplayer, .gemini/skills/godot-multiplayer, .github/skills/godot-multiplayer and .opencode/skills/godot-multiplayer in your project.

What does Godot Multiplayer need to run?

SKILL.md names no scripts, command-line tools or credentials: Godot Multiplayer is instructions for the agent only.

Does Godot Multiplayer access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Godot Multiplayer safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Godot Multiplayer use?

Godot Multiplayer is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Godot Multiplayer use?

About 1.6k tokens (SKILL.md is roughly 6.5k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 1.1k tokens, read only when the agent opens those files.

What are the alternatives to Godot Multiplayer?

Skills that share tags, products or a category with Godot Multiplayer: Godot Server Architecture (thedivergentai/GD-Agentic-Skills, 821 stars), Godot Adapt Single To Multiplayer (thedivergentai/GD-Agentic-Skills, 821 stars), Godot Genre Fighting (thedivergentai/GD-Agentic-Skills, 821 stars) and Godot Multiplayer Networking (thedivergentai/GD-Agentic-Skills, 821 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Godot Multiplayer?

gamedev-skills (a GitHub organization) maintains it in gamedev-skills/awesome-gamedev-agent-skills, which has 1,389 GitHub stars. The repository holds 53 skills in this directory. The repository was last updated on October 9, 2026.

Source: gamedev-skills/awesome-gamedev-agent-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.