Shipping Media Over QUIC at Meta Scale for Instagram Live Ingest¶

Summary¶

Meta shipped Media over QUIC (MoQ) — the emerging IETF open transport for real-time media — as the live-video ingest protocol for Instagram Live on iOS and Android, replacing its own nearly-decade-old in-house QUIC protocol RUSH. The goal of this phase was parity, not improvement: prove MoQ can carry Instagram Live's ingest traffic at Meta scale with no regression across streaming-quality and reliability metrics, establishing a production-tested baseline for extending MoQ end-to-end into playback and other real-time/interactive surfaces. The rollout tackled three constrained sub-problems — client integration across four apps (via Meta's open-source moxygen MoQ library on the mvfst QUIC stack), edge translation that converts MoQ frames to RUSH so the existing backend was untouched, and server-side routing that steers experiment-eligible broadcasts to MoQ endpoints independent of app-version adoption. The strategic motive is protocol consolidation: a single QUIC-based transport across ingest, delivery, and playback collapses the separate stacks Meta runs today for RTMP ingest, HLS/DASH playback, and WebRTC calling.

Key takeaways¶

MoQ is now the Instagram Live ingest transport on iOS and Android, making this "one of the largest application usages of MoQ … in the industry, both by the number of ingest streams and total volume" — the first MoQ workload at Meta shipped at full scale. (Source: this article)
The target was metric parity, and it was met: "The MoQ path matched RUSH across the streaming-quality indicators and reliability measures used for the rollout." Parity is explicitly framed as the prerequisite — a clean baseline — for every subsequent phase (playback, interactive AI). (Source: this article)
RUSH was the predecessor, and the move is as much governance as technology. Meta ran live streaming on RUSH (a QUIC-based answer to RTMP) for "nearly a decade"; lessons from RUSH "shaped our bet on MoQ." The shift moves development "from a protocol operated primarily by Meta to a shared standards effort" where multiple implementers test interoperability and improve the spec. (Source: this article)
The core MoQ abstraction is the Track — an addressable stream of media objects that publishers push and subscribers receive through a network of relays that "cache and forward objects without parsing the media payload" (content-agnostic fan-out as a protocol property, not a bolt-on). (Source: this article)
QUIC is the load-bearing substrate: independent streams avoid TCP-style cross-stream head-of-line blocking, faster connection setup, and connection migration; MoQ "would also automatically benefit from any feature added to QUIC (e.g., FEC)." Meta's earlier QUIC rollout cut request errors, tail latency, and video stalls vs HTTP/2. (Source: this article)
Tunable latency per subscription is a first-class MoQ property: two subscribers to the same Track can run at different latencies simultaneously — "~100 ms for an interactive participant and several seconds for an archival or buffered service" — and relays can drop, prioritize, or replay objects based on metadata (track-aware delivery) for better loss behavior than byte-stream protocols. (Source: this article)
Migration method: translate at the edge, don't rewrite the backend. MoQ ingest terminates on dedicated edge endpoints where a translation layer converts MoQ frames to the RUSH format the existing backend already understands; "Nothing downstream changes while we swap the client transport." The translator is explicitly "temporary scaffolding" — once MoQ is the only ingest path the backend consumes MoQ natively and the shim is removed. A textbook strangler-fig / edge-translation migration. (Source: this article)
Rollout is driven server-side, not by app adoption. Stream-URL generation routes experiment-eligible broadcasts to MoQ-capable endpoints by experiment-group membership, so "phased rollout doesn't depend on app-version adoption and the experiment can be resized in minutes" — and a single config parameter chooses MoQ or RUSH per broadcast (fast, reversible switching). (Source: this article)
Firewalls force transport selection at session start. UDP/443 is "still blocked or rate-limited on a non-trivial slice of enterprise and carrier networks," so Meta picks TCP or QUIC "based on which handshake wins" at stream start and keeps it for the session — a happy-eyeballs-style transport negotiation. Standards-based TCP fallback (WebTransport over HTTP/2, or the emerging QMUX mapping) is the path to removing the current reliance on RUSH's TCP fallback and eventually retiring RUSH. (Source: this article)
Operational hurdles were real: the IETF draft kept evolving during build (Meta pinned to specific draft versions, kept compatibility shims for older clients, and contributed fixes upstream); and QUIC encryption "hides framing from middleboxes, and from our own packet captures," so Meta built MoQ-aware tracing into the edge to see object-level events without decrypting the wire. (Source: this article)

Systems / concepts / patterns extracted¶

Systems: MoQ Transport (the standard), moxygen (Meta's open-source MoQ library — publisher / subscriber / relay roles, mvfst integration, custom media-handler hooks), mvfst (Meta's QUIC implementation that moxygen rides on — named, no page), RUSH (Meta's QUIC-based RTMP successor, the protocol being replaced), QUIC (the transport substrate). RTMP, HLS, DASH, WebRTC, WebTransport, QMUX, and FEC named as plain-text ecosystem context (no pages).
Concepts: head-of-line blocking (QUIC's per-stream independence is the whole reason it carries live media better than TCP); connection migration, tunable per-subscription latency, track-aware partial reliability, and adaptive bitrate on native MoQ constructs recorded as prose (single-source here, below the page-creation bar).
Patterns: strangler-fig (edge-translation shim + per-broadcast routing dial, run old-and-new in parallel, remove the shim once the new path is sole), protocol/transport negotiation (QUIC-vs-TCP chosen by whichever handshake wins at session start).

Operational numbers & specifics¶

Scale: "one of the largest application usages of MoQ … in the industry, both by the number of ingest streams and total volume" (no absolute stream count / bitrate / fleet size disclosed).
RUSH longevity: "stable and performant at scale for nearly a decade."
Latency spectrum example: ~100 ms for an interactive participant vs several seconds for an archival/buffered subscriber, on the same Track.
Firewall constraint: UDP/443 blocked or rate-limited on a "non-trivial slice" of enterprise and carrier networks → per-session transport selection.
Client surface: four apps integrated via moxygen; a single config parameter selects MoQ vs RUSH per broadcast; experiment resizing "in minutes."
Presented at DEMOQED 2026.

Caveats¶

Parity, not improvement — no latency/stall/quality deltas are published because the explicit goal was matching RUSH, not beating it; the loss-recovery, partial-reliability, and adaptive-bitrate gains are described as the next phase's target, not this phase's results.
No absolute production numbers (ingest-stream count, aggregate bitrate, edge-fleet size, translation-layer overhead, or the firewall-affected network percentage).
The MoQ draft is still evolving; Meta's deployment is pinned to specific draft versions and QMUX TCP fallback is not yet adopted (RUSH's TCP fallback is the current expedient).