# Net Forge and Colyseus: when to use each, and using them together

> Colyseus is an open-source multiplayer server framework for Node.js with SDKs for many engines. Net Forge uses Colyseus for its rooms and transport and adds a shared simulation, a three.js renderer, a typed game API and ten finished games on top.

Net Forge, the open-source multiplayer browser game engine built for AI coding agents, is published on npm under `@netforge` with source at https://github.com/netnetdev/net-forge.

Source: https://forge.netnet.capital/docs/compare/colyseus  
Last updated: 2026-10-24. Checked against @netforge/engine 0.2.0.

Pick Colyseus when you want a multiplayer server framework for any engine, with rooms, matchmaking, state sync and managed hosting. Pick Net Forge when you want a complete browser game on top of that kind of room layer: Net Forge's own rooms are built on Colyseus, and it adds one simulation shared by client and server, a three.js renderer, ten finished multiplayer games and a game API made for your coding agent.

```sh
npm create netforge@latest my-game -- --template arena --yes
```

## At a glance

| | Colyseus | Net Forge |
|---|---|---|
| What it is | "An open-source multiplayer framework for Node.js" for authoritative game servers ([Colyseus llms.txt](https://docs.colyseus.io/llms.txt)) | A browser game engine and ten genre templates, with rooms on Colyseus |
| Language | TypeScript or JavaScript on the server; clients in many languages | TypeScript on both sides |
| Rendering | None; bring any engine | three.js, WebGPU with a WebGL2 fallback |
| Multiplayer model | Authoritative rooms, schema state sync, matchmaking, client prediction and server rewind in 0.18 ([Netcode](https://docs.colyseus.io/netcode)) | Authoritative rooms that step a shared ECS and Rapier simulation; the client predicts with the same code |
| Client SDKs | TypeScript, Unity, Godot, Defold, GameMaker, Construct 3, Cocos Creator, Haxe, Flutter, Swift and more ([llms.txt](https://docs.colyseus.io/llms.txt)) | The browser |
| License | MIT ([npm](https://www.npmjs.com/package/colyseus)) | MIT |
| Latest version (checked 2026-10-23) | `colyseus` 0.18.10, `@colyseus/core` 0.18.23, both released 2026-10-22 | `@netforge/engine` 0.2.0 |
| Best for | Multiplayer servers for any client engine | 3D browser games that start from a finished multiplayer template |

## When to pick Colyseus

- **You already have a game client**, in Unity, Godot, Defold, GameMaker, Phaser or your own engine, and need a server. Colyseus documents client SDKs for all of these ([llms.txt](https://docs.colyseus.io/llms.txt)).
- **You want the server framework and nothing else.** Rooms, matchmaking with lobby and queue rooms, and schema state sync with binary patches are its core ([llms.txt](https://docs.colyseus.io/llms.txt)).
- **You want prediction you control.** Colyseus 0.18 runs prediction, reconciliation and rewind loops for you: "the server stays authoritative, and the client predicts", and "you supply the deterministic step function" ([Netcode](https://docs.colyseus.io/netcode)).
- **You want managed hosting.** Colyseus Cloud provides deployment, scaling and monitoring for Colyseus apps ([llms.txt](https://docs.colyseus.io/llms.txt)).

## When to pick Net Forge

- **You want the step function written for you.** In Net Forge that deterministic step is `@netforge/engine-sim`: a bitECS world with Rapier physics at a fixed tick (30 Hz by default), the same module on the server and in the browser. See [Simulation and ECS](https://forge.netnet.capital/docs/concepts/simulation-ecs.md).
- **You want a finished game, not a blank room.** Ten templates ship with rules, rendering, input, touch controls, seat-filling bots and a headless playtest. See [Templates](https://forge.netnet.capital/docs/templates.md).
- **Your coding agent writes the game.** Game rules live in one declarative `src/game.ts` that may import only `@netforge/engine`, so an edit cannot break the netcode. See [The typed game API](https://forge.netnet.capital/docs/concepts/game-api.md).

## Using them together

They already work together. Net Forge's client netcode includes a Colyseus room client (`@colyseus/sdk` in `@netforge/engine`), and the local room host in `@netforge/kit-play` is a Colyseus server (`@colyseus/core` 0.18.18 with `@colyseus/ws-transport` 0.18.4). Net Forge sends its own binary, delta-compressed snapshots over the Colyseus room instead of schema state, because the simulation, not a schema, is the source of truth.

If you know Colyseus, the room lifecycle will feel familiar. What Net Forge adds sits on top: the shared simulation, the snapshot format, interpolation and prediction wired to that simulation, and the games. If your client is Phaser, see [Net Forge vs Phaser + Colyseus](https://forge.netnet.capital/docs/compare/phaser-colyseus.md).

For other engines that pair with Colyseus, see [3D multiplayer browser game engines compared](https://forge.netnet.capital/docs/compare/3d-multiplayer-engines.md) for a roundup.

## Honest limits of Net Forge

Net Forge is young (0.2.0) and browser only. It does not provide SDKs for other engines; for a Unity or Godot client, use Colyseus directly. The public repository's room host is meant for play on your own computer and network; it has no lag-compensation history and no run log. The production room server, with lag compensation, interest management and the referee, is the hosted Net Forge service.

## Moving from Colyseus

| Colyseus | Net Forge |
|---|---|
| `Room` with `onCreate`, `onJoin`, `onMessage` | The template's room, created for you; rules go in `src/game.ts` |
| Schema state (`@type` fields) | The simulation's state, sent as quantized delta snapshots |
| Your deterministic step function for prediction | `step(world, inputs)` from `@netforge/engine-sim` |
| `client.send("move", data)` | Sequence-numbered input commands, quantized so client and server see identical inputs |
| `matchMaker` | Locally, every tab joins the open room until it is full; on the hosted service, matchmaking and room links (`?room=<id>`) |

A first step: start the template nearest your game and play it in two tabs to see the room behaviour.

```sh
npm create netforge@latest my-game -- --template arena --yes
cd my-game
npm run play -- --players 2
```

## FAQ

### Is Net Forge built on Colyseus?

Its room layer is. The local host in `@netforge/kit-play` runs `@colyseus/core`, and the browser connects with the Colyseus SDK. The simulation, snapshots, renderer and games are Net Forge's own.

### Does Colyseus have client prediction?

Yes. Colyseus 0.18 documents client prediction with reconciliation and server-side rewind for hits ([Netcode](https://docs.colyseus.io/netcode)). Net Forge also predicts, using the shared simulation as the step function.

### Can I use a Net Forge template with a Unity or Godot client?

No. Net Forge templates are browser games drawn with three.js. Colyseus is the better fit when the client is another engine.

### Which should I learn first?

If you want to understand game servers in general, Colyseus is a good place to start, and it starts with `npm create colyseus-app@latest ./my-server` ([Create a server](https://docs.colyseus.io/getting-started/server)). If you want a playable online game to change today, start a Net Forge template.