wRPCFast, zero-dependency Web RPC

One router, every web transport — WebSocket, HTTP, SSE, WebTransport, WebRTC — and across Redis, NATS, RabbitMQ and Kafka. Nothing in your lockfile.

Get Started

Why wRPC?

View on GitHub

⚡

WebTransport, with a fallback

HTTP/3 streams with no head-of-line blocking between them and unreliable datagrams for events that may drop — the same router and rooms as your WebSocket clients, and transport: ['wt', 'ws'] falls back where a browser has none. Experimental.

Go HTTP/3

🤝

Peer to peer over WebRTC

Two browsers serve routers to each other with no server in the data path — calls, events, subscriptions and streams over a data channel, a mesh for rooms, built-in signaling, and peer identity bound to the DTLS fingerprint.

Connect peers

📨

Message brokers, injected

Redis, NATS, RabbitMQ or Kafka — durable feeds a client resumes on any instance, queue consumers that deliver into procedures with retry and dead-lettering, and RPC between services with no HTTP between them. Experimental.

Bring your broker

🔌

Runs where you already run

A batteries-included server, or plug into fastify, express, bare node:http or uWebSockets.js; the same protocol rides Server-Sent Events where WebSockets cannot go — with pino-style logging and OTel traces built in.

Adapters

🧩

Router, procedures, hooks

Declare units of procedures with access control, Standard Schema validators, timeouts and queues — and named lifecycle hooks at router, unit and procedure level instead of (ctx, next) middleware.

Write a router

🔔

Subscriptions that resume

An async generator per feed, with real backpressure. Track values with an event id and a reconnecting client replays exactly what it missed — on any instance, when the feed is a broker log.

Push a feed

🧵

Bytes as bytes

A Uint8Array in arguments, results and events travels as bytes, not as JSON digits; binary streams interleave uploads and downloads with backpressure that reaches all the way into TCP. 1 GiB streams at flat memory.

Move bytes

🧭

Real REST, declared on the procedure

http: { method, path, status } turns a procedure into a proper endpoint: path params, /vN version paths, fastify-shaped schemas, and an OpenAPI document from wrpc types --openapi.

Declare an endpoint

🛰️

Rooms and cluster in one

Join, leave and broadcast in one process; add any pub/sub — or your broker's backplane — and a room spans every instance, with presence read from a local map, fetchClients, addressed commands and node-to-node asks.

Go multi-instance

🔐

Sessions and auth, batteries included

Cookie sessions by default; bearer and payload token carriers, client token stores and an authenticate/refresh lifecycle that re-presents the credential before every reconnect restore.

Wire up auth

🛡️

Encryption where TLS ends

Sealed backplane, cluster and broker messages under a rotating keyring, a session store that holds nothing readable, Noise sessions on WebSocket and WebTransport, HPKE per HTTP request, end-to-end helpers — platform crypto only. Experimental.

Seal what matters

🗜️

Compression, chosen per wire

Off by default, because its cost is paid on every frame. Turn it on where bytes are dear — deflate, Brotli or zstd, negotiated as a preference list on every transport and the backplane, with a preset dictionary built from your router.

Pick a codec

📭

Zero dependencies

No runtime dependencies at all — no dependencies field, no peers, no optionals. Redis, Kafka, uWebSockets.js, fastify, the WebRTC and HTTP/3 stacks, TanStack and OpenTelemetry are injected by you, never installed by wRPC.

Why it matters

🧠

Types without a build step

Declare the contract once and connect<Api>() types every call — server-push events included — or generate it from a running server with the wrpc types CLI. No TypeScript at runtime, ever.

Type the client

🌍

Node.js and the browser

One protocol implementation, under 28 KB min+gzip in a browser bundle with no Node builtins — a budget CI enforces — plus one socket for every tab through a Service Worker or a SharedWorker, and TanStack Query bindings at ~1 KB.

Client guide

🔁

Upgrade in any order

The wire protocol is a versioned reference. Revision 2 is negotiated per connection, so a 2.x client or server still speaks 1.0 to a 1.0 peer — and the published 1.0 is tested against this one, both ways.

Read the protocol

One router, every transport

Every procedure on a wRPC server answers on every carrier below, with the same rooms and sessions behind it — a browser on a WebSocket or on HTTP/3, a page behind a proxy that only speaks HTTP, another browser over WebRTC, another service through Kafka. The handler never knows which; the client picks per connection, with a fallback list where it wants one, and an app can talk to several backends at once.

Transport	Reach for it when	Calls	Events & subscriptions	Binary streams	Compression	Encryption
WebSocket	the default — full duplex, from any browser or Node	✅	✅	✅	✅	Noise
HTTP & REST	stateless calls, `curl`, partners, caches	✅	❌	❌	✅	HPKE
Server-Sent Events	no upgrade path — serverless, strict proxies	✅	✅	❌	✅	HPKE
WebTransport exp.	HTTP/3 — streams without head-of-line blocking, datagrams	✅	✅	✅	✅	Noise
WebRTC	browser to browser, no server in the data path	✅	✅	✅	✅	DTLS
Worker port	one connection shared by every tab	✅	✅	✅	—	—
Broker, stateless exp.	service to service — any instance answers	✅	❌	❌	✅	sealed
Broker, session exp.	a long-lived conversation between services	✅	✅	✅	✅	sealed

Compression and encryption are off until you turn them on; encryption here is the layer above TLS, never in place of it. The full matrix — how each transport is chosen, and which carry bytes inside a packet — is in Client › Transports.

Fast where it counts

wRPC's whole call path — router, validation, access check, correlation — against the frameworks that do the same job, one machine, over a WebSocket (gRPC over HTTP/2). Switch the metric: wRPC leads with calls in flight and at 10 KB, and is level with socket.io one small call at a time. Over plain HTTP, fastify answers about a tenth more requests than wRPC does, and express about a fifth fewer — Performance has that too, with raw sockets, every transport, and how to reproduce each number.

RPC frameworks, calls per secondcalls/s · higher is better

wRPC — batch: true201,075
wRPC — own WebSocket116,704
socket.io (emitWithAck)101,455
tRPC (wsLink)23,310
gRPC (grpc-js, HTTP/2)20,921

Node v24.14.1 · Apple M3 Max · loopback · one run (3 October 2026) · bench/rpc-comparison.js