MoQ Player & OBS Integration

This Summer Project executed on 2026 marked a continuation of the deep dive into Media over QUIC (MoQ). Unlike the roadmap followed in the Summer Project 2025, this iteration utilized the player found in the moq-dev/moq repository as its foundation.

During this period, efforts were focused on adding support for CMAF. Furthermore, capabilities for ingesting content in HLS format were implemented to serve as a mechanism for rapid prototyping. As a final highlight, a group of summer campers also worked on adding MoQ support to OBS.

This summer project was technically sponsored by Luke Curley and Mike English.

A QUIC intro to MoQ

QUIC

One of the main drawbacks of TCP is the head-of-line (HoL) blocking issue. Since TCP ensures reliable and ordered delivery, when a single packet is lost, all subsequent packets must wait for its retransmission before being processed. This is particularly problematic for modern applications that require low latency, such as video streaming and web browsing.

QUIC addresses this issue by operating over UDP and implementing multiplexed streams within a single connection. Unlike TCP, where all data is sent in a strict sequence, QUIC allows independent streams that can be processed separately. This means that if a packet is lost in one stream, the others continue to be delivered without waiting, significantly reducing delays.

MoQ

Media over QUIC (MoQ) is a new transport protocol currently being standardized by the IETF to enable low-latency, scalable, and efficient delivery of media content over QUIC. MoQ leverages QUIC's advantages, such as multiplexed streams and reduced head-of-line blocking, to improve media streaming, conferencing, and real-time communication.

MoQ is structured into three key components:

MoQT (MoQ Transport): The core transport layer that efficiently manages the delivery of media over QUIC, ensuring low latency and robustness.
Catalog: A metadata layer that describes the available streams, making it easier for clients to discover and request media segments dynamically.
Containers (LOC or CMAF): Media data is packaged using either LOC (Low Overhead Container), a lightweight format optimized for QUIC, or CMAF (Common Media Application Format), a widely used standard for audio and video streaming.

One question you may have is, why LOC if we already have CMAF? When sending real-time streaming, the audio samples that need to be transmitted are very small in terms of data. In this scenario, CMAF is an inefficient container because the size of the headers is comparable to the amount of data in the sample. This issue has led to the need for new, lighter containers such as LOC or WCP (Web Codec Package).

A key advantage of MoQ is MoQT (MoQ Transport), which serves as a single transport layer for both publishing and subscribing to media. This simplifies implementation and reduces latency by ensuring that media segments are efficiently delivered and reused across multiple consumers without requiring separate protocols for ingestion and distribution.

In MoQ, relays play a crucial role in optimizing media delivery by caching media segments. Instead of forwarding all media streams directly from the publisher to each subscriber, relays can store recently transmitted segments and serve them to new subscribers without requiring retransmission from the source.

MoQ is designed to support various media streaming and real-time communication scenarios. It enables different use cases based on how media is published and consumed, including one-to-many, many-to-many, and video-on-demand (VOD/DVR) delivery after FETCH was defined in MoQT draft-07.

The OBS-MoQ Plugin

One of the biggest hurdles for adoption is getting media into the MoQ ecosystem. The team successfully developed a working OBS Studio plugin that allows creators to stream directly to a MoQ relay.

Rust + C/C++ Interop: Developed hang-c, a binding library allowing the Rust-based MoQ library (Hang) to communicate seamlessly with OBS’s C/C++ architecture.
Functional Streaming: Achieved successful streaming of H.264 video and AAC audio from OBS to a relay using LOC packaging.
Development Experience: Created "Mock BS," a custom fork of OBS to streamline development and bypass UI limitations regarding service discovery, while paving the way for upstream contributions.
Cross-Platform Success: Validated builds and streaming on Linux, macOS, and Windows.

Bridging Worlds: HLS to MoQ

To ease the transition for existing infrastructure, the team built tooling to ingest standard HLS streams and transport them over QUIC.

Ingestion CLI: Built a command-line tool capable of parsing HLS manifests (m3u8), consuming segments, and pushing them to a MoQ relay.
CMAF Support: Implemented a "pass-through" mode for CMAF containers. This allows the relay to transport standard fragments, enabling the player to utilize Media Source Extensions (MSE). This is a critical step toward future DRM support and ecosystem compatibility.
Latency Controls: Added dynamic latency configuration and jitter buffer controls to the player to handle the variability of re-transported HLS segment

Core Library & Player Evolution

Working directly with the moq-js and kickstand/hang repositories, the team modernized the browser-based experience.

Draft 14 Compliance: Aligned implementations with IETF MoQ Transport Draft 14 to ensure interoperability with major CDNs and relays (including Cloudflare’s global edge).

UI Overhaul: Refactored the player UI into a separate, bundler-agnostic package. Added a stats panel for network metrics (RTT, bitrate) and a visual latency slider.
Observability: Experimented with Open Telemetry to extract metrics from both the relay and the player, visualizing active streams and connection health via Prometheus and Grafana.

Summer Project Demo

Check out the final demo of the MoQ Player MonteVIDEO Summer Project 2026 and learn about the challenges we faced, the lessons we learned, and the decisions we made

Page updated

Report abuse