An async-friendly WebRTC implementation in Rust with runtime-agnostic architecture and sans-I/O protocol core.
WebRTC.rs is an async-friendly WebRTC implementation written entirely in Rust. It provides a complete WebRTC stack for building real-time communication applications like video conferencing, voice calls, and data sharing, with a focus on safety, performance, and modern async patterns. The project solves the problem of using complex C++ WebRTC libraries by offering a Rust-native alternative that integrates seamlessly with Rust's ecosystem.
Rust developers building real-time communication applications, especially those who need WebRTC functionality with async/await support and runtime flexibility. It's also suitable for projects requiring a safe, memory-efficient alternative to traditional WebRTC implementations.
Developers choose WebRTC.rs for its runtime-agnostic architecture that works with any async runtime, its sans-I/O design for clean separation of concerns, and its Rust-native implementation that eliminates callback complexity and resource leaks. Unlike C++ WebRTC, it provides Rust's safety guarantees and modern async patterns.
Async-friendly WebRTC implementation in Rust
Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.
Supports Tokio, async-std, smol, or embassy via feature flags, avoiding tight coupling to any specific async runtime for maximum flexibility.
Separates protocol logic from I/O through the `rtc` crate, enabling deterministic testing and zero-cost abstractions as highlighted in the architecture blog post.
Uses trait-based event handlers with native `async fn in trait`, eliminating callback hell and Arc explosion issues common in older implementations.
Achieves 95%+ W3C WebRTC API compliance, ensuring interoperability with browsers and other WebRTC implementations.
The project is between v0.17.x (bug fixes only) and v0.20.0+ (under development), forcing users to navigate deprecated features or unstable new architectures.
Requires updating submodules (e.g., `rtc` crate) and managing runtime feature flags, adding initial configuration overhead compared to drop-in libraries.
Success hinges on familiarity with Rust's async patterns and ownership model, making it less accessible for teams not already invested in Rust.