​

moq-lite Protocol

​

Overview

• Built-in concurrency: Multiple streams delivered in parallel
• Automatic deduplication: Efficient use of network resources
• Flexible prioritization: Control delivery order based on importance
• Partial reliability: Trade reliability for latency when needed
• CDN-compatible: Simple rules that relays can enforce without application knowledge

​

The Hierarchy

Origin
 └── Broadcast(s)
      └── Track(s)
           └── Group(s)
                └── Frame(s)

​

Origin

use moq_lite::Origin;

let origin = Origin::new();

​

Broadcast

let broadcast = origin.create("my-broadcast");

• A live video stream (with video, audio, and chat tracks)
• A telemetry feed (with sensor data tracks)
• A real-time game state (with player position tracks)

• Has a unique name/path
• Published by a single source
• Can contain multiple tracks
• Can be announced for discovery

​

Track

let track = broadcast.create_track("video/720p");

• Video renditions (e.g., “video/1080p”, “video/720p”)
• Audio channels (e.g., “audio/en”, “audio/es”)
• Chat messages (e.g., “chat”)
• Telemetry (e.g., “metrics”)

• Out-of-order delivery: Groups within a track can arrive in any order
• Time-based expiration: Old groups can be dropped
• Independent: Each track is delivered independently
• Metadata: Contains delivery hints (priority, caching rules)

​

Group

let group = track.create_group(timestamp);

• A video Group of Pictures (GOP)
• An audio frame
• A chat message
• A complete JSON document

• In-order delivery: Frames arrive in sequence
• Atomic: Either all frames arrive or the group is abandoned
• Cancellable: Can be aborted mid-delivery if no longer relevant
• Independent: Each group uses a separate QUIC stream

​

Frame

let frame = group.write(Bytes::from(data)).await?;

• Encoded video frame
• Audio sample
• Text message
• Binary data

• Fixed size: Size is known upfront
• Ordered: Delivered in sequence within a group
• Chunked: Can be split across multiple QUIC packets

​

Producer/Consumer API

use moq_lite::{Origin, Broadcast, Track, Group};
use bytes::Bytes;

// Create an origin
let origin = Origin::new();

// Create a broadcast
let mut broadcast = origin.create("livestream");

// Create a track
let mut track = broadcast.create_track("video/1080p");

// Create a group (e.g., for a video GOP)
let mut group = track.create_group(timestamp);

// Write frames
for frame_data in video_frames {
    group.write(Bytes::from(frame_data)).await?;
}

// Close the group
group.close().await?;

import { Client, Broadcast } from '@moq/lite'

// Connect to relay
const client = await Client.connect('https://relay.example.com')

// Create a broadcast
const broadcast = new Broadcast(client, 'livestream')

// Create a track
const track = broadcast.createTrack('video/1080p')

// Create a group
const group = track.createGroup(timestamp)

// Write frames
for (const frameData of videoFrames) {
  await group.write(frameData)
}

// Close the group
await group.close()

use moq_lite::Session;

// Subscribe to a broadcast
let broadcast = session.subscribe("livestream").await?;

// Get tracks
while let Some(track) = broadcast.next_track().await? {
    println!("Track: {}", track.name());

    // Get groups
    while let Some(group) = track.next_group().await? {
        // Get frames
        while let Some(frame) = group.next_frame().await? {
            process_frame(frame.data());
        }
    }
}

import { Client } from '@moq/lite'

// Subscribe to a broadcast
const client = await Client.connect('https://relay.example.com')
const broadcast = await client.subscribe('livestream')

// Get tracks
for await (const track of broadcast.tracks()) {
  console.log('Track:', track.name)

  // Get groups
  for await (const group of track.groups()) {
    // Get frames
    for await (const frame of group.frames()) {
      processFrame(frame.data)
    }
  }
}

​

Delivery Semantics

​

Priority

• Higher priority: Delivered before lower priority (e.g., audio > video)
• Same priority: Delivered in order of creation
• Dynamic: Can change based on network conditions

​

Caching

• Cacheable: Stored and forwarded to late joiners
• Ephemeral: Discarded if no active subscribers

​

Expiration

• Time-based: Discard after N seconds
• Sequence-based: Discard after N newer groups
• Explicit: Discard when marked as expired

​

Network Characteristics

​

Deduplication

1. Relay receives one copy from publisher
2. Relay forwards to all subscribers
3. Network bandwidth scales with subscriber count, not stream count

​

Concurrency

• Each group uses a separate QUIC stream
• Tracks are multiplexed automatically
• No head-of-line blocking between groups

​

Partial Reliability

• Groups can be abandoned if they fall behind
• Newer content prioritized over old
• Application controls trade-off between completeness and latency

​

Relay Behavior

[server]
listen = "[::]:4443"

[server.tls]
cert = "cert.pem"
key = "key.pem"

[auth]
key = "auth.jwk"
public = "demo"  # Allow anonymous access to /demo

• Accepts publish and subscribe connections
• Forwards groups based on subscriptions
• Deduplicates identical subscriptions
• Enforces authentication rules
• Does not inspect or understand media

​

Protocol Specification

• moq-lite specification

​

Next Steps