Runtimes & compatibility

@pipedog/core and @pipedog/asyncio are runtime-agnostic: they run unchanged on Bun, Node.js (22 or later), Deno and Cloudflare Workers (workerd). Code that only works on some runtimes lives in its own package, and every package records where it is verified.

Compatibility tableCopy Anchor Link

Generated at build time from the pipecat.runtimes field of each packages/*/package.json:

runtimes lists only what is verified: the compat harness runs each package's smoke test (its compat/smoke.ts, or a default that imports every public entry) on each runtime, and bun run compat --write records the runtimes that passed. It is never edited by hand. An empty row means the package has not been run through the harness yet.

A package that cannot work on a runtime (SmallWebRTC on Workers, which has no UDP) lists it in pipecat.compat.unsupportedRuntimes; the harness skips it there. Optional peers a package's users are expected to install go in pipecat.compat.usesOptionalPeers; all other optional peers are made unresolvable during the run, so a package that silently depends on one fails.

Every package is verified on all four runtimes except @pipedog/transport-smallwebrtc (no UDP on Workers), @pipedog/transport-livekit, @pipedog/heygen and @pipedog/transport-heygen (LiveKit's media SDK is a native addon, which Workers can't load), the local models @pipedog/kokoro, @pipedog/moonshine, @pipedog/funasr, @pipedog/pocket-tts and the eSpeak NG phonemizer @pipedog/espeak-ng (model files and memory exceed what Workers allow), @pipedog/transport-local (it runs sox or ffmpeg on your machine), @pipedog/mcp (a stdio tool for Bun and Node) and @pipedog/cli (a command line tool: Bun, Node and Deno). The harness checks that each package loads and runs its smoke test; inside a verified package, a few entry points still need a server runtime:

Local turn detection (@pipedog/audio-silero, @pipedog/audio-smart-turn) runs on Workers with onnxruntime-web, but the models and runtime are large; provider-side turn detection is the usual choice there. See Turn detection.

What core avoidsCopy Anchor Link

To stay portable, @pipedog/core and @pipedog/asyncio:

• import no node:* modules except node:async_hooks (for AsyncLocalStorage, in asyncio);
• use Uint8Array for bytes, never Buffer (PCM is 16-bit little-endian);
• use no Bun- or Deno-specific APIs;
• use the global fetch and WebSocket for network I/O;
• treat process signals as optional (WorkerRunner handles SIGINT/SIGTERM only where the runtime has them).

Bun, Node and DenoCopy Anchor Link

The npm packages ship compiled JavaScript, and from a checkout Bun and Deno run the TypeScript sources directly (Node with its built-in type stripping). WorkerRunner installs a SIGINT handler by default, so Ctrl-C cancels the bot cleanly. Node needs version 22 or later.

On Bun and Node, a WebSocket is upgraded by the server rather than from the Request: serveFetch() from @pipedog/transport-websocket/serve serves a fetch handler with upgrades on Bun, Node (with the ws package) and Deno, and on Bun you can also pass the server Bun.serve gives fetch to websocketFetchHandler's handler. See WebSocket.

Cloudflare WorkersCopy Anchor Link

Workers are a good fit for pipedog bots that talk to clients over WebSockets, with a few constraints:

• Enable nodejs_compat. Task tracking uses AsyncLocalStorage from node:async_hooks, which workerd provides under the nodejs_compat compatibility flag.

  Copy Text

  {
    "compatibility_flags": ["nodejs_compat"]
  }

• No WebRTC. Workers can't run WebRTC, so the WebRTC-based transports (Daily, SmallWebRTC, LiveKit) don't work there. Use a WebSocket transport instead; WebSocket-based transports and serializers must work on Workers. Pipecat clients can connect over WebSocket with RTVI as usual. For WebRTC users, Cloudflare Realtime is the WebRTC peer and streams the audio to the bot over WebSockets.

• WASM is imported as a module. workerd refuses to compile WebAssembly from bytes at runtime (WebAssembly.compile(buffer)), so a .wasm file must be imported. Packages with WASM ship two entries selected by the workerd export condition, which wrangler resolves automatically:

  Copy Text

  {
    "exports": {
      ".": {
        "types": "./src/index.ts",
        "workerd": "./src/workerd.ts",
        "default": "./src/index.ts"
      }
    }
  }

  The workerd entry does import wasm from "../wasm/x.wasm" and instantiates that WebAssembly.Module; the default entry loads the bytes (a fetch of new URL(..., import.meta.url)). Both accept an explicit WebAssembly.Module | BufferSource so apps can supply their own. @pipedog/resampler-wasm is built this way.

• Models are never bundled. Packages that need a model (Silero VAD, Smart Turn) load it from a path or URL you give them, with the upstream file name as the default. On Workers, serve it from R2, KV, static assets or a fetch.

• No threads, limited CPU. Upstream work done in a thread pool (run_in_executor) runs inline or in an injected runner. Keep per-call CPU low: Workers have CPU-time limits.

• No process signals. handleSigint is a no-op; end the runner from your Worker code (for example when the WebSocket closes) with runner.end() or runner.cancel().

• Many sessions per isolate. One isolate serves many requests and Durable Objects. @pipedog/asyncio runs each callback in the I/O context that scheduled it, so parallel sessions in separate Durable Objects don't do each other's I/O. examples/workers-durable-voice-agent tests this with parallel sessions on workerd.

Native and ML dependenciesCopy Anchor Link

Where Pipecat uses native modules (onnxruntime, Krisp, Koala, soxr), the pipedog package takes the model as an external file or URL and accepts an injected runtime: onnxruntime-node on Bun/Node, onnxruntime-web (WASM) on Workers. Pure-algorithm fallbacks, such as a linear resampler, may live in core.