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!" }]
});

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, connectionId }) {
    const i = state.online.indexOf(connectionId);
    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, connectionId }) => {
        state.cursors[connectionId] = input;
      },
    },
  },
  onDisconnect({ state, connectionId }) {
    delete state.cursors[connectionId];
  },
});

// 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