Murow

A lightweight TypeScript game engine for server-authoritative multiplayer games.

Installation

npm install murow

Usage

import { FixedTicker, EventSystem, BinaryCodec, generateId, lerp, PrefabBucket } from 'murow';
// or
import { FixedTicker } from 'murow/core';
import { WebGPU2DRenderer } from 'murow/webgpu';

Modules

Core — Low-level utilities and systems

• BinaryCodec — Schema-driven binary serialization
• PooledCodec — Object-pooled binary codec with array support
• EventSystem — High-performance event handling
• FixedTicker — Deterministic fixed-rate update loop
• Driver — Event-driven update orchestration
• generateId — Cryptographically secure ID generation
• lerp — Linear interpolation utility
• NavMesh — Pathfinding with dynamic obstacles
• IntentTracker & Reconciliator — Client-side prediction
• InputTracker — Cross-platform input state tracking
• FreeList — Slot allocator for reusable handles
• SparseBatcher — Layer/sheet bucketing for batched rendering
• SimpleRNG — Seedable deterministic random number generator
• Ray2D / Ray3D — Zero-allocation ray intersection tests (segment, circle/sphere, AABB, plane, triangle)

ECS — Entity Component System

High-performance ECS with SoA (Structure of Arrays) storage, bitmask queries, and zero-allocation hot paths:

• World — Manages entities and components
• defineComponent — Define typed components with binary schemas
• EntityHandle — Fluent chainable entity API

Game — Game loop abstractions

• GameLoop — Client/server tick loop with sync / pre-tick / tick / post-tick / render phases, every(...) interval scheduling, plus input tracking and frame interpolation

Protocol — Networking primitives

Minimalist networking primitives:

• IntentRegistry — Type-safe intent codec registry
• SnapshotCodec & SnapshotRegistry — Binary encoding for state deltas
• Snapshot<T> — Delta-based state updates
• applySnapshot() — Deep merge snapshots into state
• RpcRegistry & defineRpc() — Type-safe RPC definitions

Network — Transport-agnostic networking

Transport-agnostic client/server abstractions:

• ServerNetwork — Multiplayer game server with per-peer snapshot registries
• ClientNetwork — Game client with intent/snapshot handling
• TransportAdapter — Pluggable transport interface
• BunWebSocketTransport — Bun WebSocket implementation (reference)

Key features:

• Per-peer snapshot registries for fog of war and interest management
• Transport agnostic — works with WebSocket, WebRTC, UDP, etc.
• Type-safe protocol integration with IntentRegistry and SnapshotRegistry

Renderer — Abstract renderer interfaces + asset pipeline

Renderer-agnostic primitives consumed by any backend (@murow/webgpu, future PixiJS, Three.js, …).

• BaseRenderer / Base2DRenderer / Base3DRenderer — abstract contracts
• PrefabBucket — typed registry for spawnable assets. Declare → load → typed lookup; the renderer self-sizes from the bucket
• parseGltf / parseSpritesheet — pure CPU parsers (no GPU, no canvas)
• SkeletalAnimation — CPU-side bone evaluation for skinned meshes

WebGPU — WebGPU rendering backend

The WebGPU renderer is bundled with murow and accessible via murow/webgpu:

import { WebGPU2DRenderer, WebGPU3DRenderer } from 'murow/webgpu';

See WebGPU README for full documentation.

Netcode — Multiplayer layer

Opinionated multiplayer layer built on the Protocol and Network primitives above. Adds snapshot-based state sync, client-side prediction with rollback, jitter interpolation, server-pushed entity assignment, and spatial-interest plugins.

import { GameServer, GameClient, defineIntents, definePredictions } from 'murow/netcode';

See Netcode README for full documentation. If its opinions don't fit, drop down to the Protocol and Network primitives directly.

Building

npm install
npm run build

License

MIT