An open-source stack for real-time audio and video, with a focus on reliability and simplicity.
Report a Bug · Request a Feature · Join our Discord
PulseBeam is an open-source media stack for building real-time applications. Our approach is guided by a focus on creating a robust, simple, and scalable foundation for developers.
At its heart is a minimal Selective Forwarding Unit (SFU) written in Rust. We've intentionally kept the core small, dedicated only to the essential task of routing real-time media. This design choice aims to create a stable and predictable system that is easy to reason about.
For all other features—like recording, analytics, or AI integrations—our design encourages building them as independent, server-side services that connect to the core, keeping the central media server stable and uncluttered.
- A Minimal Core: We believe a small, stable core is the best foundation for a reliable system. It's easier to maintain, debug, and build upon.
- Modular Features: Our goal is to enable powerful functionality without creating a monolith. We favor a design where features are deployed as decoupled services.
- Simple, HTTP-Based Signaling: We use a simple, request/response signaling protocol that is a superset of WHIP/WHEP. This provides out-of-the-box compatibility while allowing for extensions to handle advanced use cases—all without requiring WebSockets for signaling.
- Open and Transparent: The project is open source, and building in Rust helps us create efficient and memory-safe code by design. We aim to be transparent in our work as we build the project with the community.
The architecture of PulseBeam is straightforward. The core SFU sits in the middle and relays media. On either side, different kinds of clients connect to it.
+-----------------+ +--------------------+ +----------------------+
| | | | | |
| End-User Clients| | | | Server-Side Services |
| (Browsers, |<---->| PulseBeam Core SFU |<---->| (Recording, |
| Mobile Apps, | | (Media Relay) | | AI, Analytics) |
| Embedded) | | | | |
+-----------------+ +--------------------+ +----------------------+
Conceptually, we find it helpful to think of every client that connects to the core as an "agent" with a specific job.
From this perspective, a participant in a browser is simply an agent responsible for user interaction and media capture. A recording bot is an agent whose job is to persist media streams to disk.
This mental model helps us keep the core SFU incredibly simple. The core doesn't need to know about different "types" of clients; it just routes media between connected agents. This is the key to the simplicity and robustness we're striving for.
You can get a PulseBeam server running locally in under a minute.
Requirements: Rust and Cargo.
# 1. Clone the repository
git clone https://github.com/pulsebeamdev/pulsebeam.git
cd pulsebeam
# 2. Run the server
cargo run --releaseNext, open http://localhost:7880/demo in two browser tabs to see the media relay in action.
(This is an early version of PulseBeam. Your feedback and contributions are incredibly valuable as we work towards building a truly reliable platform.)
PulseBeam's signaling is designed for both simplicity and flexibility. For basic media exchange, it's compatible with the WHIP/WHEP standard.
This example uses browser-native JavaScript—no proprietary SDKs are required for basic media publishing and viewing.
const pc = new RTCPeerConnection();
// Configure local media
const stream = await navigator.mediaDevices.getUserMedia({ video: true, audio: true });
pc.addTransceiver("video", { direction: "sendonly" }).sender.replaceTrack(stream.getVideoTracks()[0]);
pc.addTransceiver("audio", { direction: "sendonly" }).sender.replaceTrack(stream.getAudioTracks()[0]);
// Negotiate with the PulseBeam server
const offer = await pc.createOffer();
await pc.setLocalDescription(offer);
const res = await fetch("http://localhost:3000?room=test&participant=alice", {
method: "POST",
headers: { "Content-Type": "application/sdp" },
body: offer.sdp,
});
await pc.setRemoteDescription({ type: "answer", sdp: await res.text() });This simple, HTTP-based interaction model is the foundation for how all clients, including server-side services, will communicate with the core.
👉 For a complete implementation with UI controls, see the demo directory.
Our roadmap reflects our focus on building a stable foundation first.
| Stage | Status & Focus |
|---|---|
| Prototype | ✅ Minimal core SFU is functional with a working demo. |
| Core Relay Stability | 🚧 Current Focus: Hardening the core SFU. Our main effort is on improving stability, connection recovery, and resilience. |
| Signaling & Agent API | 📅 Next: Defining and documenting our full HTTP-based signaling API, ensuring it's robust for all types of clients. |
| Essential Services & SDKs | 📅 Planned: Releasing official server-side services (e.g., recording) and a lightweight JavaScript SDK. |
| Scaling & Deployment | 📅 Future: Developing guides and tools for multi-node deployments and high-availability configurations. |
PulseBeam is a community-driven project, and we welcome contributions of all kinds.
- Improve the Rust core: Help us enhance the robustness and reliability of the SFU.
- Prototype new services: Experiment with new server-side capabilities in a decoupled way.
- Build SDKs: Help create developer-friendly wrappers for web, mobile, or native platforms.
- Write docs, tests, or tutorials: Your help makes PulseBeam more accessible and dependable for everyone.
If our approach to building simpler, more robust real-time tools resonates with you, we'd love for you to get involved. By contributing, you can help shape a foundational piece of open infrastructure.
💬 Join us on Discord to connect with the team and other developers.
PulseBeam is open source, licensed under the GNU Affero General Public License v3.0.