Breaking Free from the Fork: Meta’s Journey to a Unified WebRTC Stack

Introduction

Real-time communication (RTC) is at the heart of many Meta services, from Messenger and Instagram video calls to low-latency cloud gaming and VR casting on Meta Quest. Supporting billions of users across diverse devices demands a high-performance, reliable RTC engine. For years, Meta relied on a customized fork of open-source WebRTC. However, maintaining a permanent fork creates a well-known industry pitfall known as the “forking trap.” In this article, we share how Meta escaped that trap by building a modular, dual-stack architecture that enables safe A/B testing and continuous upstream upgrades across over 50 use cases.

The Forking Trap: When Good Intentions Go Astray

A fork often starts with a noble goal: adding a specific optimization or fixing a critical bug quickly. Over time, as the upstream WebRTC project evolves and your internal features accumulate, merging external commits becomes increasingly costly. The fork drifts further and further from the mainline, cutting itself off from community improvements, security patches, and performance enhancements. This isolation becomes unsustainable, demanding a massive migration effort to realign with upstream.

The Challenge: Monorepo and the Static Linker

Migrating away from a divergent fork is no trivial task, especially in Meta’s massive monorepo environment. A direct upgrade could introduce regressions affecting billions of users on a wide variety of devices. Rolling back such a change would be difficult. Therefore, Meta prioritized the ability to A/B test the new upstream version alongside the legacy version within the same application, dynamically switching users to verify performance and stability.

One major technical hurdle: the application build graph and size constraints required statically linking two versions of WebRTC. However, static linking violates the C++ linker’s One Definition Rule (ODR), causing thousands of symbol collisions. Meta needed a way to make two versions of the same library coexist in the same address space without conflict.

The Dual-Stack Architecture: A Solution That Works

To solve the ODR problem, Meta engineered a dual-stack architecture within a single library. The key insight was to wrap one version of WebRTC in a namespace or use link-time segmentation to isolate symbols. This allowed both the legacy fork and the upstream-based version to be compiled and linked together without collisions. The architecture also included a dynamic switch mechanism, enabling engineers to route a user’s call to either stack at runtime.

This approach provided a safe sandbox for testing: the new stack could be validated on a small percentage of users, with automatic rollback if any issues were detected. Over time, as confidence grew, the new stack could be gradually rolled out to all users.

A/B Testing Across 50+ Use Cases

Meta’s RTC platform supports a wide range of use cases: voice and video calls, cloud gaming, VR casting, and more. The dual-stack architecture allowed each use case to be independently A/B tested. For example, a cloud gaming session could use the new stack while a Messenger call continued on the legacy fork. This fine-grained control was essential for catching regressions that might only appear under specific workloads or device types.

Continuous Upgrade Workflow

With the dual-stack in place, Meta established a streamlined process for integrating each new upstream WebRTC release. Instead of a large, risky upgrade, the team now regularly pulls the latest upstream changes, applies Meta-specific patches on top, and then A/B tests the resulting build against the current production stack. Any issues are caught early, and fixes can be upstreamed or patched internally. This continuous integration cycle keeps Meta’s RTC stack up to date with community improvements while preserving customizations.

Results: Performance, Size, and Security Gains

The migration away from the divergent fork brought significant benefits:

• Improved performance – Upstream optimizations, such as better codec support and network adaptation, were now readily available.
• Reduced binary size – The modular architecture allowed Meta to strip unused components, leading to smaller downloads and faster app startups.
• Enhanced security – Regular upstream security patches were no longer delayed; they could be tested and deployed quickly.
• Lower maintenance burden – Engineers no longer spent large portions of time resolving merge conflicts with upstream.

Conclusion

Meta’s escape from the forking trap demonstrates a viable path for large-scale organizations that rely on open-source libraries. By investing in a dual-stack architecture and a continuous A/B testing workflow, Meta now safely upgrades WebRTC across more than 50 use cases, serving billions of users with improved performance, smaller binaries, and robust security. This approach can serve as a blueprint for any team struggling to balance custom features with upstream alignment.