Serverless
realtime backends, fully typed.

Use your schema library of choice, connect from typed clients, and keep realtime state in sync without socket boilerplate.

Get Started GitHub

server.ts

import { actor, createApp, serve } from "@zocket/core";
import { z } from "zod";

const ChatRoom = actor({
  state: z.object({
    messages: z.array(z.object({
      from: z.string(), text: z.string(),
    })).default([]),
  }),
  methods: {
    send: {
      input: z.object({ from: z.string(), text: z.string() }),
      handler: ({ state, input }) => { state.messages.push(input) },
    },
  },
});

export const app = createApp({ actors: { chat: ChatRoom } });
serve(app, { port: 3000 });

client.ts

import { createClient } from "@zocket/client";
import type { app } from "./server";

const client = createClient<typeof app>({
  url: "ws://localhost:3000",
});

const room = client.chat("general");

await room.send({ from: "alice", text: "hello!" });

room.state.subscribe((s) => {
  console.log(s.messages);
  // → [{ from: "alice", text: "hello!" }]
});

Three primitives. That's the API.

Zocket exposes an actor model, not a socket library. You describe state, describe methods, and read state on the client. The runtime handles the rest.

01 — Define

Actors own state.

Describe state with Zod. Describe methods with typed inputs. No classes, no decorators, no codegen.

const Room = actor({
  state: z.object({
    messages: z.array(z.string()).default([]),
  }),
  methods: {
    send: {
      input: z.string(),
      handler: ({ state, input }) => {
        state.messages.push(input);
      },
    },
  },
});

02 — Call

Clients call methods.

Full types flow from server to client. No REST, no OpenAPI, no tRPC boilerplate. Just import the app type.

const room = client.room("general");

await room.send("hello");
// ^ typed. typos fail at compile time.

03 — Subscribe

State streams back.

You subscribe to state, not events. Immer patches flow over WebSocket. React hooks included.

room.state.subscribe((s) => {
  console.log(s.messages);
});

// or in React:
const s = useActorState(room);

Everything realtime apps need, in one runtime.

No separate database service, no queue, no socket server, no scheduler to manage.

State next to compute

State lives in memory where your code runs. Reads and writes take microseconds, not network round-trips.

Live state on the client

Clients always see the latest state. Skip the fetch-cache-revalidate dance entirely.

WebSockets out of the box

Push-based and bidirectional. The right transport for anything that actually changes.

Workflows, queues, scheduling

Long-running jobs, durable queues, and timers. One runtime instead of three services.

No lost requests

Calls survive disconnects. Clients reconnect and the answer is waiting for them.

Scales to zero, scales to anything

Idle actors cost nothing. Traffic spikes get absorbed. No capacity planning, no idle servers.

Same feature, very different runtime model.

Compare the amount of ceremony, infrastructure assumptions, and state management you carry into each use case.

Use case Chat Room

A chat room with message history and online presence.

server.ts Socket.io

const io = new Server(3000);
const rooms = new Map();

io.on("connection", (socket) => {
  let room = null, name = null;

  socket.on("join", ({ room: r, name: n }) => {
    room = r; name = n;
    socket.join(r);
    const state = getRoom(r);
    state.online.add(n);
    socket.emit("history", state.messages);
    io.to(r).emit("presence", [...state.online]);
  });

  socket.on("sendMessage", ({ text }) => {
    if (!room || !name) return;
    const msg = { from: name, text };
    getRoom(room).messages.push(msg);
    io.to(room).emit("newMessage", msg);
  });

  socket.on("disconnect", () => {
    if (!room || !name) return;
    getRoom(room).online.delete(name);
    io.to(room).emit("presence", [...]);
  });
});

chat.ts Zocket

const ChatRoom = actor({
  state: z.object({
    messages: z.array(z.object({
      from: z.string(),
      text: z.string(),
    })).default([]),
    online: z.array(z.string()).default([]),
  }),

  methods: {
    join: {
      input: z.object({ name: z.string() }),
      handler: ({ state, input }) => {
        state.online.push(input.name);
      },
    },
    sendMessage: {
      input: z.object({ from: z.string(), text: z.string() }),
      handler: ({ state, input }) => {
        state.messages.push(input);
      },
    },
  },

  onDisconnect({ state, clientId }) {
    const i = state.online.indexOf(clientId);
    if (i !== -1) state.online.splice(i, 1);
  },
});

Takeaway No manual broadcasting, no room management, no untyped events. State syncs automatically.

Use case Live Cursors

Users see each other's cursors in real-time on a shared canvas.

app.tsx Liveblocks

import {
  LiveblocksProvider,
  RoomProvider,
  useOthers,
  useUpdateMyPresence,
} from "@liveblocks/react";

const client = createClient({
  publicApiKey: "pk_live_xxx",
});

function Cursors() {
  const others = useOthers();
  const update = useUpdateMyPresence();

  useEffect(() => {
    const h = (e: MouseEvent) => {
      update({ x: e.clientX, y: e.clientY });
    };
    window.addEventListener("mousemove", h);
    return () => window.removeEventListener("mousemove", h);
  }, []);

  return others.map(({ connectionId, presence }) => (
    <Cursor key={connectionId} x={presence.x} y={presence.y} />
  ));
}

// Must wrap in LiveblocksProvider + RoomProvider
// Data goes through Liveblocks servers
// Pricing per monthly active user

cursors.ts + app.tsx Zocket

// Server
const Workspace = actor({
  state: z.object({
    cursors: z.record(z.object({
      x: z.number(), y: z.number(), name: z.string(),
    })).default({}),
  }),
  methods: {
    updateCursor: {
      input: z.object({ x: z.number(), y: z.number(), name: z.string() }),
      handler: ({ state, input, clientId }) => {
        state.cursors[clientId] = input;
      },
    },
  },
  onDisconnect({ state, clientId }) {
    delete state.cursors[clientId];
  },
});

// Client
function Cursors() {
  const ws = useActor("workspace", "main");
  const cursors = useActorState(ws, s => s.cursors);

  useEffect(() => {
    const h = (e: MouseEvent) => {
      ws.updateCursor({ x: e.clientX, y: e.clientY, name: "Alice" });
    };
    window.addEventListener("mousemove", h);
    return () => window.removeEventListener("mousemove", h);
  }, []);

  return Object.entries(cursors ?? {}).map(([id, c]) => (
    <Cursor key={id} x={c.x} y={c.y} name={c.name} />
  ));
}

Takeaway Self-hosted, no vendor lock-in, no per-user pricing. Same DX, you own the data.

Use case Game Match

Players join a lobby, match starts, server tracks scores.

match.ts Rivet

class MatchActor extends Actor {
  override initialize() {
    return {
      players: [],
      phase: "lobby",
      round: 0,
    };
  }

  join(rpc, playerId) {
    this.state.players.push({ id: playerId, score: 0 });
    this.broadcast("playerJoined", { playerId });
  }

  startRound(rpc) {
    this.state.phase = "playing";
    this.state.round += 1;
    this.broadcast("roundStarted", { round: this.state.round });
  }

  submitAnswer(rpc, playerId, correct) {
    const p = this.state.players.find(p => p.id === playerId);
    if (p && correct) p.score += 10;
    this.broadcast("scoreUpdate", { players: this.state.players });
  }
}

// Client
const match = await client.get({ name: "match", id: "match-123" });
match.on("scoreUpdate", (data) => { /* untyped */ });
await match.submitAnswer("player-1", true);

match.ts Zocket

const Match = actor({
  state: z.object({
    players: z.array(z.object({
      id: z.string(), score: z.number(),
    })).default([]),
    phase: z.enum(["lobby", "playing", "finished"]).default("lobby"),
    round: z.number().default(0),
  }),

  methods: {
    join: {
      input: z.object({ playerId: z.string() }),
      handler: ({ state, input }) => {
        state.players.push({ id: input.playerId, score: 0 });
      },
    },
    startRound: {
      handler: ({ state }) => { state.phase = "playing"; state.round++; },
    },
    submitAnswer: {
      input: z.object({ playerId: z.string(), correct: z.boolean() }),
      handler: ({ state, input }) => {
        const p = state.players.find(p => p.id === input.playerId);
        if (p && input.correct) p.score += 10;
      },
    },
  },
});

// Client — fully typed, state syncs automatically
const match = client.match("match-123");
match.state.subscribe(s => {
  console.log(s.phase);   // "lobby" | "playing" | "finished"
  console.log(s.players); // { id: string; score: number }[]
});
await match.submitAnswer({ playerId: "p1", correct: true });

Takeaway Same actor model, but typed end-to-end. State syncs automatically instead of manual broadcast calls.

Use case AI Agent

Call an LLM, execute tools, timeout if too slow.

workflow.ts + activities.ts + worker.ts Temporal

// workflow.ts — must be deterministic (no Date.now, no I/O)
const { callLLM, executeTool } = proxyActivities({
  startToCloseTimeout: "30s",
});

export async function agentWorkflow(prompt: string) {
  const response = await callLLM(prompt);

  for (const tool of response.toolCalls) {
    await executeTool(tool.name, tool.args);
  }

  return await Promise.race([
    saveResult(response),
    sleep("30s").then(() => "Timeout"),
  ]);
}

// activities.ts — where actual work happens
export async function callLLM(prompt: string) { /* ... */ }
export async function executeTool(name: string, args: unknown) { /* ... */ }

// worker.ts — run the engine
const worker = await Worker.create({
  workflowsPath: require.resolve("./workflows"),
  activities,
  taskQueue: "agent-tasks",
});
await worker.run();

// client.ts — start workflow, poll for result (no streaming)
const handle = await client.workflow.start("agentWorkflow", {
  args: ["Summarize this"], taskQueue: "agent-tasks",
});
const result = await handle.result(); // blocks until done

agent.ts Zocket

const AgentRun = actor({
  state: z.object({
    messages: z.array(z.any()).default([]),
    status: z.enum(["idle", "running", "done", "timeout"]).default("idle"),
  }),

  methods: {
    start: {
      input: z.object({ prompt: z.string() }),
      stream: true,
      handler: async ({ state, input, timer }) => {
        state.status = "running";
        timer.after(30_000).timeout();

        const result = streamText({
          model: openai("gpt-4o"),
          messages: [{ role: "user", content: input.prompt }],
        });

        for await (const chunk of result.textStream) {
          state.messages.push({ role: "assistant", content: chunk });
        }

        state.status = "done";
      },
    },
    timeout: {
      handler: ({ state }) => {
        if (state.status === "running") state.status = "timeout";
      },
    },
  },
});

// Client — real-time streaming, no polling
const agent = client.agent("run-123");
agent.state.subscribe(s => {
  console.log(s.status);   // updates live
  console.log(s.messages); // tokens stream in real-time
});
await agent.start({ prompt: "Summarize this" });

Takeaway One file instead of four. Real-time streaming instead of polling. No replay semantics to reason about.

How it runs

Start with one process. Scale to a distributed cluster when you need it.

ready

Standalone

One process, zero infra. For prototypes and small apps.

❯ serve(app, { port: 3000 })

ready

Distributed

Gateway + NATS + runtime. Self-hosted, scales independently.

❯ docker compose up

❯ zocket deploy

coming soon

Platform

Multi-tenant, Firecracker isolation, fully hosted.

❯ zocket deploy --platform

Coming soon

Timers Cron Actor-to-Actor Streaming AI SDK Integration

These features are designed and in progress. Read the roadmap →

$ bun add @zocket/core @zocket/server @zocket/client zod

Read the Docs