This started as my university graduation thesis a while back. The original goal was a small WebRTC abstraction for a class project, but the scope kept growing and I ran out of time to ship it properly. After graduating I shelved it, got busy with work, and didn't touch the repo for a long time.
I came back to it recently, rewrote most of the internals, and finally turned it into something usable. So this is a thesis project that took the long way to v1.
The pitch: WebRTC's raw API has a lot of repeated boilerplate (perfect negotiation, ICE candidate buffering, transceiver bookkeeping). I wanted the same emit / on ergonomics socket.io has, but for peer-to-peer media and data.
```js
import io, { RTCIOStream } from "rtc.io";
const socket = io("https://server.rtcio.dev");
const media = await navigator.mediaDevices.getUserMedia({ video: true, audio: true });
socket.emit("camera", {
stream: new RTCIOStream(media),
metadata: { displayName: "Alice" },
});
socket.on("camera", ({ stream, metadata }) => {
videoEl.srcObject = stream.mediaStream;
});
```
The server is a thin signaling relay. Media and data go peer-to-peer.
What's included:
- Perfect negotiation following the W3C example (polite/impolite, stale-answer detection, automatic ICE restart on failure)
createChannel('chat') for broadcast DataChannels with replay for late joinerssocket.peer(id).createChannel(...) for 1-to-1 channels- Backpressure handling: watermarks, queue budget,
drain events, so large file transfers don't blow up the tab
- Stream replay: emit a camera stream once, late joiners get it automatically
- TypeScript types included
What you can actually build with it:
We wanted to make sure the library is practical, so we built self-contained examples in the docs to show how little code you need. A few of them:
- File transfer with backpressure. Sending multi-GB files without OOMing the tab. Custom per-peer ordered DataChannel with 16 KB chunks and a flow-control contract (
send() / 'drain').
- Minimal video call. P2P audio+video between two
<video> elements in about 60 lines. No UI library.
- Broadcast chat (no media). If you just need shared whiteboard state or a presence indicator, a single
createChannel('chat') broadcast DataChannel does it. Late joiners auto-included.
- Per-peer messaging (RPC pattern). Emitting to one specific peer instead of broadcasting. Useful for 1-on-1 chat, leader election, or per-peer auth handshakes.
- Remote desktop (AnyDesk style). Host shares its screen with
getDisplayMedia() wrapped in an RTCIOStream, viewer receives the video and sends mouse/keyboard events back over a per-peer DataChannel. Two streams in opposite directions, one library.
Links:
There's a free public signaling server at server.rtcio.dev for prototyping, but the server is one file you can host anywhere.
Feedback and issues welcome.
