Meta relies on WebRTC for real-time audio and video across billions of users on platforms like Messenger, Instagram, and Meta Quest. Maintaining a forked version of the open-source WebRTC library led to a common trap: divergence from upstream, making upgrades costly and risky. To escape this, Meta engineered a dual-stack architecture that allows A/B testing between legacy and upstream versions within the same application, while adhering to monorepo constraints. This approach enabled a gradual migration of over 50 use cases, improved performance, reduced binary size, and enhanced security. Here, we answer key questions about how Meta modernized its WebRTC infrastructure.

What is the "forking trap" and why is it a problem for WebRTC at Meta?

The forking trap begins when a company forks an open-source project like WebRTC to add internal optimizations or quick fixes. Initially, the fork stays close to upstream, but over time, internal features accumulate and upstream evolves rapidly. Merging external commits becomes increasingly labor-intensive, creating a gap that grows with every release. At Meta, this divergence meant that billions of users were on a legacy version missing critical performance and security updates from the community. The fork also became a bottleneck for innovation, as any new feature required extensive integration work. Ultimately, the trap locks teams into a self-contained version that cuts itself off from community improvements, forcing a difficult decision: invest heavily in catching up or remain stuck with outdated technology.

How did Meta enable A/B testing between two WebRTC versions in production?

To safely upgrade WebRTC without risking user experience, Meta prioritized A/B testing capabilities. They needed to run the legacy fork alongside the new upstream version with clean patches, dynamically switching users between them within the same app. The solution was a dual-stack architecture where both versions coexist in a single library. By building both versions simultaneously and applying Meta's proprietary features as modular components, the team could compare performance, stability, and feature parity in real-time. This allowed gradual rollouts, where a small percentage of users received the new version first. If regressions appeared, the team could instantly revert users back to the legacy stack. This approach minimized risk and provided data-driven confidence before full deployment across all 50+ use cases.

How did Meta overcome the C++ One Definition Rule (ODR) violations when linking two WebRTC versions?

Statically linking two versions of the same library inside a single address space violates the C++ One Definition Rule (ODR), causing thousands of symbol collisions. To solve this, Meta engineers devised a technique to isolate each version's symbols. They used namespace mangling and custom linker scripts to prefix symbols from the legacy fork and the upstream version, effectively treating them as separate libraries. Additionally, they employed linker sections to segregate code and data, ensuring that functions and variables from one version do not interfere with the other. This allowed both versions to exist in the same binary without conflicts. The approach also handled dynamic dispatch and virtual tables by tweaking the build system to generate unique type information for each version. Once symbol isolation was achieved, the dual-stack library could be safely linked into Meta's monorepo, enabling the A/B testing infrastructure.

What was the process for migrating over 50 WebRTC use cases?

Meta's migration involved a multiyear effort to move each of the 50+ use cases from the divergent fork to a modular architecture built directly on the latest upstream version. The team first identified all internal customizations—such as optimizations for low-latency cloud gaming, VR casting on Meta Quest, and video filters for Messenger—and reimplemented them as pluggable components that sit on top of the upstream skeleton. For each use case, they ran A/B tests comparing the legacy fork with the new upstream-based stack. If performance or quality metrics matched or improved, the use case was migrated. In cases where upstream lacked a required feature, Meta contributed patches back to the community rather than keeping them private. The step-by-step approach avoided a big-bang migration, allowing teams to validate each scenario independently. After completing all migrations, Meta now has a single, continuously updated WebRTC foundation.

What performance, size, and security benefits did Meta achieve?

By moving to the upstream-based modular architecture, Meta observed improved performance in real-time communication, including lower latency and better video quality under varied network conditions. Binary size was reduced because the modular design allowed stripping unused components—each use case only included the necessary modules. Security also improved significantly, as Meta now receives timely security patches from the WebRTC community without the delay of manual integration. The dual-stack A/B testing framework itself provided a safety net, catching regressions before they reached billions of users. Additionally, the new architecture enabled easier experiments with emerging WebRTC features, such as enhanced codecs and congestion control algorithms. Overall, the modernization made Meta's RTC infrastructure more agile, secure, and performant across all platforms.

What is Meta's current workflow for continuously upgrading WebRTC upstream?

Today, Meta treats each new upstream WebRTC release as a candidate for A/B testing. The team automatically merges the release into an internal branch, applies Meta's proprietary components as patches on top, and builds the dual-stack library. The new version is then dynamically tested against the current production version in controlled experiments. If metrics like call quality, CPU usage, and network resilience meet thresholds, the new version passes. Otherwise, issues are reported to the WebRTC community or fixed internally before retesting. This continuous workflow ensures Meta never falls far behind upstream again. The monorepo structure, combined with automated build and test systems, makes the process efficient. As a result, Meta can adopt community improvements within days rather than months, keeping its real-time services at the cutting edge while maintaining stability for billions of users.