01 — Real-time audio + video infrastructure
Real-time audio and video. The whole system, in Rust.
videocall.rs is a full-stack system for real-time audio and video, written in Rust. Relay servers, a meetings API with auth and host controls, a browser client, a native CLI, metrics, Helm charts. Run meetings in the browser. Stream from embedded devices with the CLI. Self-host the whole thing. MIT / Apache-2.0.
Three ways to test
Try it, run it, build on it. Three ways in, ordered by how far you want to go: stream from a device, run the whole stack, or embed the client.
Stream a camera in two commands
For the roboticist with a Pi on the desk. No browser, no build — just a camera and a meeting id.
cargo install videocall-cli
videocall-cli stream --user-id cam-01 --meeting-id your-meeting-id --video-device-index 0Then open app.videocall.rs in any browser and pick any meeting id — swap it in for your-meeting-id in the command above so the Pi's camera and your browser land in the same call.
The whole system on your machine
For evaluating the full stack end to end — media servers, meeting API, and UI — before you commit to anything.
git clone https://github.com/security-union/videocall-rs.git
cd videocall-rs
make devThe entire stack — Postgres, NATS, the relays, meeting-api, and the UI — runs natively with hot reload. Open localhost:3001/meeting/you/demo. You are in the call. Going to production? The repo ships Helm charts.
Embed the client in your own app
For building a custom client on the same transport and media pipeline, compiled to WebAssembly.
cargo add videocall-client
// then, in your Rust/WASM app:
use videocall_client::{VideoCallClient, VideoCallClientOptions};
let mut client = VideoCallClient::new(VideoCallClientOptions {
user_id: "cam-01".into(),
meeting_id: "demo".into(),
webtransport_urls: vec!["https://localhost:4433".into()],
websocket_urls: vec!["ws://localhost:8080".into()],
enable_webtransport: true,
// …peer + connection callbacks and tuning — see docs.rs
});
client.connect().unwrap();Transport negotiation, encoding, and peer rendering are handled; you own the UI. The full options struct and callbacks are on docs.rs.
Built in the open
Read the code, file issues, or send a patch.
Relays around the world, one mesh
Subject per meeting
Each meeting is a NATS subject. A relay publishes a frame once and every relay subscribed to that meeting receives it.
Relay to relay
Participants can land on different relay servers anywhere in the world. NATS carries the media between them, so they still share one meeting.
Scale out
Add relay servers to add capacity. WebSocket and WebTransport relays scale independently behind a load balancer.
One system, end to end
A mesh plane forwards media over NATS. A separate control plane handles auth, meeting lifecycle, host controls, and the waiting room. Browser, native, and CLI clients. Pure-Rust Opus and VP9. Prometheus metrics.
01 — Clients
Browser to embedded board
A Dioxus web client in the browser, compiled to WebAssembly — no install. videocall-cli streams from embedded Linux boards like the Raspberry Pi and Jetson.
02 — Control plane
Sign in, get admitted
meeting-api handles auth and SSO, meeting lifecycle, host controls, and the waiting room before a single frame moves. Prometheus metrics export across the stack.
03 — Media pipeline
Codecs written in Rust
Opus audio and VP9 video, encoded and decoded in pure Rust. A NetEQ adaptive jitter buffer runs in every browser client.
04 — Transport
QUIC first, WebSocket as backup
WebTransport over QUIC where the network allows it, an automatic WebSocket fallback where it does not. Encrypted in transit with TLS 1.3, and every connection is authorized with a JWT. No ICE, STUN, TURN, or SDP.
05 — Mesh plane
One publisher, every relay
Relay servers forward every media frame over the NATS mesh. One publisher, every subscriber — the mesh in the band above.
Runs where your hardware runs
From a browser tab to an embedded Linux board. Chromium and Safari on the desktop and on iOS, and headless capture on a Raspberry Pi or Jetson.
Open source, built in Rust
Transparent development, from the transport layer up. Read the code, run it yourself, and extend it.
Our mission
Make real-time audio and video accessible, performant, and reliable through open-source infrastructure that anyone can read, run, and extend.
- Open source first
- Transparency and community-driven development, in the open.
- Built with Rust
- One language from server to browser, for performance and reliability.
Contribute
We are not hiring. We take code. Pick an issue, send a patch, argue with us on Discord.
Growing where it's measured
Open source, and used in production. Numbers sourced straight from the repository.
Run it yourself, or have us run it
Self-host the entire stack, or let us operate it for you.
Self-Hosted
Deploy and manage your own instance with full control.
- Complete source code
- Kubernetes Helm charts
- Community support
- You manage updates and security
Enterprise
Tailored deployments for organizations with specific requirements.
- Custom SLA terms
- Dedicated support team
- Custom feature development
- On-premise deployment options