Latest Posts

The webrtc-rs project is embarking on a significant architectural evolution. With webrtc v0.17.0 marking the final feature release of the Tokio-coupled implementation, we're now designing the next generation: an async-friendly API built on top of our Sans-I/O rtc crate, supporting multiple async runtimes while maintaining clean, ergonomic APIs.

webrtc v0.17.0 marks the final feature release of the Tokio-coupled async WebRTC implementation. This isn't an ending—it's a strategic evolution toward a more sustainable, flexible, and robust architecture built on Sans-I/O rtc.

We discuss the critical issues driving this shift, including systematic memory leaks (~109 KiB per connection), tight Tokio coupling, and protocol/I/O entanglement. The new architecture provides runtime independence, proper resource management, and superior testing capabilities.

How does a Sans-I/O WebRTC implementation in Rust compare to the browser-based W3C WebRTC API? We conducted a comprehensive compliance analysis and found 95%+ compliance despite fundamental architectural differences. Explore how rtc achieves W3C-compliant WebRTC implementation while maintaining the determinism and testability of sans-I/O architecture.

For the complete interface-by-interface comparison, see the Full WebRTC API Compliance Analysis.

Perfect Negotiation is a modern WebRTC pattern that eliminates asymmetry in peer-to-peer connections. This comprehensive deep dive explores the pattern from first principles, examines the rtc implementation, and walks through a complete working example.

Learn how to handle bidirectional calling, collision detection, and rollback mechanics with Sans-I/O WebRTC.

With the release of rtc 0.8.0, the sans-I/O WebRTC implementation has reached a significant milestone: full feature parity with the async-based webrtc crate and comprehensive W3C WebRTC API compliance.

This article reflects on what we've achieved and outlines the roadmap for what comes next, focusing on four key areas: browser interoperability, performance engineering, test coverage, and code quality.

WebRTC statistics are essential for monitoring connection health, debugging issues, and implementing adaptive quality control. This article examines how RTC collects W3C-compliant statistics without async runtimes, background tasks, or locks.

Using an incremental accumulation pattern, stats are updated as packets flow through the handler pipeline, then snapshots are taken instantly on demand via get_stats(). The design achieves zero-cost collection, instant snapshots, and deterministic testing with explicit timestamp parameters.

We're thrilled to announce rtc 0.8.0, a major milestone that brings comprehensive WebRTC statistics collection to our sans-I/O WebRTC implementation.

This release implements the W3C WebRTC Stats API, enabling applications to monitor and diagnose peer connection health, media quality, and network performance—all without sacrificing the zero-overhead design principles of sansio. Features include instant synchronous snapshots, zero-cost accumulation, and the W3C stats selection algorithm with StatsSelector.

We're excited to announce rtc 0.7.0, a significant release that brings multicast DNS (mDNS) support to our sans-I/O WebRTC implementation.

This release enables privacy-preserving peer connections by hiding local IP addresses with .local hostnames, following RFC 6762 and WebRTC best practices. The mDNS implementation spans three layers: a new rtc-mdns crate, seamless ICE agent integration, and user-friendly configuration APIs.

Interceptors sit between the SRTP layer and the application endpoint, processing RTP and RTCP packets to implement features like NACK, RTX, TWCC, and RTCP reports.

This article explains the re-design of the interceptor framework using the sansio::Protocol trait and generic composition instead of async trait objects, achieving zero-cost abstraction and runtime independence.

We're thrilled to announce rtc 0.6.0, a major milestone release that completes the Interceptor framework for our sans-I/O WebRTC implementation.

This release achieves interceptor feature parity with the async-based webrtc crate, bringing RTCP feedback mechanisms for adaptive streaming, packet loss recovery, and congestion control. The simulcast example now achieves highest quality streaming from browsers thanks to proper RTCP feedback!

We're excited to announce rtc 0.5.0, bringing comprehensive simulcast support and significant API improvements to our sans-I/O WebRTC stack.

This release introduces first-class support for multiple RTP encodings per track, enabling advanced features like simulcast and SVC. The API has been refined to better represent WebRTC's multi-encoding model, making it easier to work with modern video streaming scenarios.

WebRTC is not a single protocol but a stack of tightly interrelated protocols: ICE for connectivity, DTLS for security, SCTP for reliable data channels, and SRTP for media transport.

This article explores building WebRTC as a pure protocol pipeline using the sans-I/O pattern. By separating protocol logic from all I/O concerns, we can model WebRTC as a sequence of composable handlers, each acting as a deterministic state machine.

We're excited to announce the first public release of rtc, a pure Rust WebRTC implementation built on a sans-I/O architecture.

Sans-I/O (without I/O) is a design pattern where the library handles all protocol logic, but you control the I/O operations. This architecture provides runtime independence, full control over threading and scheduling, better testability, and flexible integration options.