StoreAlloysDownloadsHow it worksRelayPricingDocs

modular multiplayer infrastructure · unity 6.3 + .net 10

Multiplayer, assembled from pieces.

Crossplay is a genre-agnostic framework for Unity 6.3 and .NET 10. Take the kernel, snap on only the pieces your game needs, and ship. The same kernel powers a card game and an MMO.

Download for Windows macOS — coming soon
Explore the 83 pieces →

Crossplay moves data and syncs state. It does not know what game you are making.

Unity 6.3 · URP .NET 10 dedicated server MemoryPack wire LiteNetLib · WebSocket · QUIC
what-it-is

Infrastructure that stays out of your game's way.

Crossplay moves data and syncs state — nothing more. Everything that makes your game yours lives above the framework, plugged into the sockets it exposes.

loadtest · 3,000 bots · one 8-core box

Tested with thousands of clients before it ever meets yours.

concurrent clients, zero drops
3,000
CPU on one 8-core box
<10%
hot-path allocations, steady state
0 B/op
databases — one config key
5
transports: UDP · WebSocket · QUIC
3

Measured, never guessed

A bot harness hammers the .NET server with thousands of simulated players — logging in, roaming, sprinting through interest churn at ~28k spawn/despawn deltas a second, ~400k messages a second going out. Every optimization ships with before/after numbers from those runs — pooled buffers, serialize-once broadcasts, delta state — and a change that doesn’t move the numbers gets reverted.

One node or a fleet

Scale out by adding nodes: Redis-backed sessions and reconnect, cross-node rooms, matchmaking and lobbies that span machines, split-brain-safe distributed locks, and an Instance Director that spreads zones and dungeons across the fleet.

Host anywhere, store anywhere

Docker and Kubernetes manifests ship in the box, with Agones, GameLift and PlayFab hosting — drain, warm pools and region routing included. Run it on a laptop, bare metal, or any cloud. Persistence is a seam: SQLite for dev, Postgres for production, Redis, MongoDB or DynamoDB — swapped by config, with cross-restorable backups.

one kernel, any genre

The base never learns your game

The kernel is transport, identity, rooms and a messaging SDK — no avatars, no rules, no spatial assumptions. It works unchanged for a card game, a hide-and-seek, an MMO or a rhythm game.

83 composable pieces

Snap on only what you need

Chat, world, movement, inventory, economy, combat, guilds, quests, voice — each an independent puzzle piece. Add or remove one at composition time; the game keeps running, minus that feature.

client + server, generated

A Unity client and a .NET server

The Hub takes your chosen pieces and builds both tiers for you: a Unity 6.3 client package set and a .NET 10 dedicated server — protected, licensed, and updatable in place.

presentation is always yours

The wire carries ids, not art

Every piece syncs abstract state — ids, numbers, opaque blobs. One game renders an emote as a chat line, another as a full 3D dance. You bind the look through clean SPIs; the framework never sees it.

the-catalog

83 pieces. Take only what you need.

Every piece is the same trio — shared contracts, a .NET server, a Unity client — stacked by dependency. Browse the full family below; buy à la carte or get everything with a plan.

zenject core

Zenject DI Container

The Zenject/Extenject dependency-injection container the whole client stack binds through. A must for Core — auto-installed, cannot be unselected. Client-only.
init core

Init & DI Framework

The client initialization + DI framework: the [Singleton*]/IAppInitializable attributes, context-scoped installers, and the app bootstrap every Crossplay client package registers into. A must for Core — auto-installed, cannot be unselected. Client-only.
core core

Core Multiplayer

The always-on kernel: connect, login, sessions, rooms/groups, and the messaging SDK.
content core

Game Content

Genre-agnostic authored-content store: define content types + records (entities, items, levels, classes, quests, anything) over a metaschema — every domain type is DATA, not code. Saved in the DB, served to clients on demand (manifest -> lazy fetch -> live push), asset-load-path binding. A must for Core — auto-installed, cannot be unselected.
characters spatial

Characters

Create / select / roster of characters with an opaque appearance blob (ICharacterFactory SPI).
world spatial

World

Enter-world, spawn/despawn, spatial interest, zones/instancing, server entities, bounds.
movement spatial

Movement

Server-authoritative movement: input, 20Hz broadcast, prediction/reconciliation, interpolation.
culling spatial

Network Culling (LOD)

Per-pair broadcast-rate rings so distant entities cost less bandwidth. Off by default.
navigation spatial

Navigation (A*)

Server-side pathfinding over the world bounds masks for your game's AI. Server-only.
emotes spatial

Emotes

Abstract game-defined emote/action events fanned out to observers as opaque data.
voice spatial

Voice Chat

Relays opaque game-encoded audio frames by proximity (World interest) or voice channel; the framework never decodes — codec + playback are the game's.
interactions spatial

Interactions

"Player used entity X": a validated verb pipeline; the game's policy SPI decides meaning.
entitystate spatial

Entity State

Mutable opaque per-entity state blob, broadcast on change and replayed on interest reveal.
rigidbodies spatial

Rigid Bodies

Optimized networked transform sync for non-player physics bodies (crates/vehicles/debris/doors): quantized position + smallest-three quaternion + velocity, sleep-gated, interest-culled, batched. The game runs its own physics; this only syncs the result.
zonestate spatial

Zone State

Mutable opaque per-zone blob (weather/time/siege), broadcast on change, replayed on entry.
worldgrid spatial

World Grid

Shared spatial cell grid: per-zone chunked opaque cells (terrain edits, tiles, build pieces), streamed to each player's chunk window and delta-batched on change. Seed + persistence SPIs; server-set only.
triggers spatial

Triggers

Spatial enter/exit/dwell volumes over the world. Server-only.
spawner spatial

Spawner

Population spawners over server entities: keep N alive in an area, respawn on removal. Server-only.
loot spatial

Loot

Dropped-item entities: opaque payload, atomic first-claim, timed expiry. Server-only.
agents spatial

Agents (NPC AI)

NPC behavior drivers: wander/patrol/chase built-ins + an IAgentBehavior game SPI. Server-only.
dungeons spatial

Dungeons

Instanced-zone lifecycle: create/seed via IDungeonContent, complete/reset, abandon sweep. Server-only.
mounts spatial

Mounts

A rideable STATE on an entity: mount id + opaque look blob + speed multiplier (applied through Movement's speed seam via a Hosting bridge). Horses, hoverboards, sprint stances, transformation forms — same state machine, the game's render. Ownership/eligibility = IMountPolicy; broadcast on change + replayed on interest reveal; empty catalog = inert.
travel spatial

Travel & Respawn

Bind/recall points, a warp destination table, and death→respawn location resolution through an ORDERED strategy chain (bind → nearest zone point → your own IRespawnStrategy). WHEN travel is allowed is the game's policy SPIs (the default DENIES client respawns until one is composed — the Stats-depletion bridge supplies the classic 'dead may go home'); moves ride the ITravelMover seam (Movement's prediction-aware Teleport when composed).
possession spatial

Possession

Input redirection to server entities (vehicles / mind-control / GM drive) via Movement's seam.
pets spatial

Pets

Companion entities: summon with an opaque look; follow / zone-travel / owner-leave handled. Server-only.
stats combat

Stats

Numbered clamped stats with thresholds and regen.
abilities combat

Abilities

Opaque verbs with server-tracked cooldowns and an IAbilityRules SPI.
projectiles combat

Projectiles

Kinematic projectile entities with deterministic client rendering + click-frame prediction: one launch event per volley, no interpolation buffer.
statuseffects combat

Status Effects

Timed opaque markers (buffs/debuffs) applied to entities.
hostility combat

Hostility (PvP Flags)

WHO MAY HARM WHOM, answered in one place: consent stances (opt-in verb), combat flags on aggression, escalation tiers on innocent kills, safe zones — one IHarmResolver seam every combat consumer asks (Crossplay:Hostility:DriveTargeting bridges Targeting). PvE pairs pass through untouched; defaults = the classic no-PvP baseline.
threat combat

Threat / Aggro

Server-only accumulated threat tables ("who do I hate most"): first-seen bonus, exact exponential decay, forget threshold, TargetChanged hooks. Feeding (damage/taunts) and consuming (Targeting selector, Agents brains) are composition bridges — Crossplay:Threat:DriveTargeting flips Targeting to highest-threat-first. Zero wire; inert until fed.
targeting combat

Auto-Targeting

Server-only auto-attack driver: enrolled attackers acquire a target (ITargetSelector) and attack on a cadence (IAttackAction) over World — survivors/auto-shooter auto-fire, turrets, sentries, pet auto-attack. Genre-neutral defaults (nearest-in-cone selection, two-faction PvE hostility, inert attack); zero wire.
combathud combat

Combat HUD

Pooled nameplates + eased HP bars + effect chips + cooldown pips over the combat clients. Client-only UI.
container economy

Container

The generic opaque-item-container engine every item piece sits on: containerId-keyed slots/stacks, policy SPI, persistence, and atomic cross-container moves. Server-only; inventory/bank/vault/equipment are thin roles over it.
inventory economy

Inventory

The character's bag — a container role over the Container engine (opaque item blobs, policy SPI, persistence).
bank economy

Bank / Stash

A personal item-storage container — a role over the Container engine (opaque item blobs; atomic bag<->bank deposit/withdraw via TryExchange; policy SPI; persistence). Depends on Container, not Inventory.
equipment economy

Equipment

Worn/active gear in typed slots — a container role over the Container engine (opaque items + opaque slot ids, IEquipmentPolicy SPI). World-optional visible loadout broadcast; item effects via Equipped/Unequipped events (never references Stats).
trade economy

Trade

Escrowed player-to-player exchange (atomic TryExchange over Inventory).
crafting economy

Crafting

Validated recipe execution (opaque in/out, all-or-nothing) over Inventory; catalog is a game SPI.
economy economy

Economy (Currencies)

Atomic, policy-gated, ledgered currencies; read-only on the wire.
market economy

Market

Escrowed listings + lock-guarded buyout over Inventory + Economy, with durable Scheduler expiry.
shop economy

Shop / Vendors

System-owned stores selling/buying OPAQUE items for game currencies: catalog stock, per-buyer daily caps, finite stock, buyback ring. Currency/access/appraisal/pricing are seams (Economy bridges the wallet); WHAT a shop is — NPC, vending machine, terminal — is the game's. Server-only wire verbs; empty catalog = inert.
mail economy

Mail

Offline delivery with escrowed item attachments.
guildvault economy

Guild Vault

Shared guild inventory of opaque item blobs with per-rank deposit/withdraw/view permissions and an audit trail.
purchases economy

Purchases

Data-driven purchase catalog: wallet stat, per-buyer live price (stored as a stat, so it replicates) with growth, and capped stat effects. Server-only wire verb; empty catalog = inert.
chat social

Chat

Channels and whispers over Core, with profanity masking and rate caps.
guild social

Guild

Persistent guilds: officer ranks, MOTD, invites/kicks, leader handoff.
party social

Party

Ephemeral parties: leader, ready checks, kicks.
teams social

Teams

Server-authoritative in-match sides per game-defined scope: opaque team ids, members, a rankable score + opaque blob, team-scoped broadcast, optional policy-gated self-service joins.
friends social

Friends

Friend lists, requests, and online presence.
matchmaking social

Matchmaking

Queue-based matchmaking with team/role quotas and MMR.
lobbies social

Lobbies

Create/join/list lobbies with slots and metadata.
director social

Instance Director

Allocate game instances (zone/room/lockstep) on match/lobby formation across nodes, hand each player a single-use join token, run the lifecycle, and return them to the hub.
leaderboards progression

Leaderboards

Persistent ranked boards: keep-best, around-me, rolling seasons.
dailyrewards progression

Daily Rewards

Interval claims with grace-window streaks; reward is an IDailyRewardGrantor game SPI.
achievements progression

Achievements

Server-reported counters against game-defined thresholds; catalog/reward are game SPIs.
progression progression

Progression (XP/Levels)

Multi-track server-granted xp/levels; curve is config exponential or an IProgressionCurve SPI.
quests progression

Quests

Accept/track/turn-in over game-defined objectives; catalog/policy/reward are game SPIs.
dialogs progression

Dialogs

Server-resolved conversation graphs: opaque node/choice payloads, per-choice conditions evaluated SERVER-side and stripped from the wire, choice actions via game SPIs. NPC talk, visual novels, tutorials, quest givers — one engine; Core-only, stateless, empty graph table = inert.
playerdata meta

Player Data

Per-player key/value store of opaque blobs.
matches meta

Matches

Match lifecycle (countdown/duration/return-zone) with results bridged to Leaderboards.
rounds meta

Rounds

Server-authoritative phase/round state machine per game-defined scope: opaque phase ids, per-phase deadlines, IRoundFlow SPI transitions, and an authoritative elimination set. No client verbs (unforgeable).
voting meta

Voting

Server-opened proposals over opaque choice ids: one ballot per eligible voter, live anonymous tallies, deadline/everyone-voted close, outcome decided by an IVoteRules SPI (plurality default). The game acts on Closed; the piece never executes outcomes.
roles meta

Roles (Hidden/Asymmetric)

Server-assigned opaque role ids with per-viewer visibility filtering (a hidden assignment never touches the wire), per-holder private payloads, role-scoped sends, and an end-of-game reveal. IRoleVisibilityPolicy SPI; no client verbs (unforgeable).
draft meta

Draft (Pick/Ban)

Server-authoritative timed ordered selection over opaque option ids: the game supplies the step order (snake/alternating/captains — all just step lists) and the pool; the piece runs the clocks, validates turn + availability, resolves timeouts, and pushes idempotent snapshots.
remoteconfig meta

Remote Config

Live tuning values pushed to clients.
scheduler meta

Scheduler

Persistent fire-at-time callbacks that survive restarts. Server-only.
analytics meta

Analytics

Genre-agnostic gameplay-event pipeline: server-authoritative Track + a rate-capped client wire, batched off-thread to the game's IAnalyticsSink SPI (Segment/Amplitude/BigQuery/…). Ships inert (null sink counts + drops).
reports meta

Reports

Report-a-player: rate-capped, recorded, surfaced via an admin decorator.
upgrades economy

Upgrades

Coin-priced, persistent, server-authoritative meta-upgrades: price from the buyer's stored tier (ceil(InitialPrice*Growth^tier)), atomic currency debit, tier persisted per-character. Currency + persistence via seams bridged to Economy + PlayerData.
lockstep meta

Lockstep (Rollback Netcode)

Server = input authority (order/relay/ack/checksum); client RollbackEngine + IDeterministicSim SPI.
tournaments meta

Tournaments

Single-elimination brackets: winners reported by server code (never client-trusted); join policy + champion reward are game SPIs.
pooling infra

Object Pooling

Generic rent/return instance pooling on the client. Client-only.
gameflow meta

Game Flow

Genre-agnostic boot -> connect -> auth -> character -> world lifecycle FSM (IGameFlow); the game binds its screens to StateChanged. Client-only, Core-only.
localization meta

Localization

Resolves keys (notification codes etc.) to localized, interpolated strings with locale fallback; strings are game data via ILocalizationCatalog. Client-only, Core-only.
replay meta

Replay

Record broadcasts server-side (archive) + play a .cdrp recording back through the live client dispatch with play/pause/speed/seek.
diagnostics infra

Diagnostics Overlay

Net/sim overlay: RTT, rates, interp delay, prediction error, cull tiers. Client-only.
ugui infra

uGUI Panel Toolkit

The MVP uGUI panel toolkit the client UI packages build on. Client-only.
audio infra

Audio Service

Channel/one-shot/music service over asset keys. Client-only.
input infra

Input Schemes

FPS/MMO/click-to-move/ARPG/cards control schemes over the intent SPI. Client-only.
assets infra

Addressables Service

Ref-counted Addressables asset service with load scopes. Client-only.
editor core

Crossplay for Unity (Editor)

The free in-Editor companion window (Window -> Crossplay): sign in, browse the live catalog + guides, ask Relay in-Editor, wire client options, hand installs to the Hub. Editor-only tooling, no runtime code. A must for Core — auto-installed, cannot be unselected.
multitest infra

Multiplayer Test

Editor-only dev tooling to run 2-4 local clients from one checkout for co-op testing: a 'Multiplayer Test' tab in the Crossplay window launches cloned Editors (symlinked project, private Library) or standalone copies, each pinned to a distinct instance id so they log in as separate players, plus one-click start/stop of the local .NET server. Rides the Core client's CrossplayInstance identity; remove it and single-client dev is unchanged.
Browse all 83 pieces in the store → Buy à la carte or get everything with a plan.
how-it-works

Pieces stack downward. Dependencies flow one way.

Movement → World → Characters → Core. Lower layers never know about higher ones — enforced by the compiler, not by discipline. Feature pieces like Chat or Guilds depend on Core only, so you can add or drop them freely.

Movement Server-auth position · prediction · interpolation
World Spawn · spatial interest · zones · server entities
Characters Roster · selection · opaque appearance
Core always on Connect · login · sessions · rooms · messaging SDK

Different games, one kernel

Card game 3 pieces
Core Matchmaking Chat

No world, no movement. Just rooms and turns.

Hide & seek 4 pieces
Core Characters World Movement

Add your own role & tag messages on top.

MMO 8 pieces
Core Characters World Movement Inventory Combat Guilds +more

The same kernel — just more pieces snapped on.

relay · ai-assistant

The framework, on speaking terms.

Relay is Crossplay's AI assistant. It answers from the generated API reference, the piece catalog and the documentation — nothing else — so the code it gives you is the code that compiles. Ask it which pieces a feature needs, how to implement an SPI, or for the exact wiring between pieces. It cites what it read.

  • Grounded, not guessy Relay only states what it just read in the docs corpus. If the documentation doesn't answer it, Relay says so instead of inventing an API.
  • Thinks in pieces "Inventory with trading?" — Relay knows the catalog, picks the pieces, and explains how they snap together.
  • Writes the wiring Real signatures from the API reference, combined across pieces — SPIs, options, messages — ready to paste into your project.
  • Every answer shows its sources Citation chips link each answer back to the pieces and types it read. No sources, no answer.
More about Relay → See pricing

subscriber perk Relay is included with a Crossplay subscription and lives in the desktop Hub.

pricing

Free to start. Pay for the pieces you ship.

Every account starts with 7 days of full access to all 83 pieces on one PC — no credit card. À la carte pieces and subscription plans are coming soon.

available now

Free trial

Free · 7 days

Full access to every piece — no credit card required.

  • All 83 pieces unlocked
  • 7 days, on 1 PC
  • Unity client + .NET server
  • No credit card

coming soon

Pieces

à la carte

Buy exactly the pieces your game ships with.

  • Everything in the trial
  • Any of the 83 pieces
  • One-time purchase, yours to keep
  • In-place updates via the Hub
Coming soon

coming soon

All-access

Plan

Every piece, every update — one subscription.

  • All current & future pieces
  • Relay — the AI assistant
  • Priority updates
  • Priority support
Coming soon

Final per-piece prices and plan tiers are set at launch. Purchases and entitlements sync across the website and the desktop Hub — buy once, use everywhere. Relay, the AI assistant, is a subscription exclusive: it comes with All-access only — not with the free trial or à la carte pieces.

downloads

Everything ships through crossplay.dev.

Pieces, docs and media all download from the domain — and so does the desktop Hub, the dev-only app that snaps pieces together and generates your server + client. A tiny installer pulls it down and keeps it up to date.

The pieces

All 83 pieces — Unity packages + .NET server projects — delivered as versioned feeds through crossplay.dev.

Go to downloads

Docs & guides

The full guide for every piece, the architecture, and the quickstart — readable online and downloadable.

Read the docs

Media

Reference images and animations for each piece and template — everything you need, from the domain.

Browse media

Desktop Hub

The dev-only app that installs & configures pieces and generates your project. A tiny installer downloads it and keeps it updated.

Get the desktop Hub