What is MOQOM?

MOQOM (Media Over QUIC Orchestration Mesh) is a real-time media platform for interactive video and audio rooms, live broadcast, and everything between them. It is built on the IETF’s Media over QUIC Transport protocol (draft-ietf-moq-transport-19) and consists of:

• Relays that receive media from publishers once and fan it out to subscribers.
• A control plane that owns tenants, rooms, policy, moderation, tokens and billing.
• Client SDKs that join rooms, publish and play media — Swift today, with Web, Android, Desktop and an OBS plugin on the way.
• Backend SDKs for Go and Rust that your server uses to mint tokens, manage rooms, moderate, and follow room events.

You can use the hosted service, MOQOM Cloud (moqom.cloud), or run relays yourself and pay only a platform fee.

What you can build

• Video and audio calls — 1:1 and small groups, with optional end-to-end encryption.
• Live rooms with a stage — hosts and cohosts on stage, an interactive audience that can be invited up, and backstage for guests waiting to go live.
• Broadcast — one or a few publishers to very large audiences at low latency.
• Moderated communities — kicks, bans, force-mutes, spotlight and an audit log, all callable from your backend and enforced on live sessions.

Why Media over QUIC

Traditional real-time stacks force a choice between WebRTC (interactive, but expensive to fan out) and HLS/DASH-style streaming (cheap to fan out, but seconds of latency). Media over QUIC gives a single protocol that does both: publishers push media to relays over QUIC, and relays forward it to subscribers with publish/subscribe semantics, caching and prioritisation.

MOQOM’s protocol implementation is its own — independently written in Rust (relay) and in Swift (client) against the draft — rather than a fork.

• Glass-to-glass latency of 56–57 ms median and 70 ms p95 at 720p30 (1.25 Mbit/s HEVC), two iPhones publishing to each other through a relay in Los Angeles.
• 6,000 subscribers from one 4-vCPU relay at 5.46 Gbit/s with zero loss.

Conditions and method are on the Benchmarks page.

Benchmark note

* Built to scale: a Rust media plane and a Go control plane, each scaling out horizontally. Measured in lab, tested to 6,000 viewers on one 4-vCPU relay with zero loss; pending further load testing.

How it fits together

flowchart LR
    subgraph You["Your product"]
        App["Your app<br/>(MoqomKit)"]
        Backend["Your backend<br/>(moqom-go / moqom-rust)"]
    end
    subgraph MOQOM["MOQOM"]
        Control["Control plane<br/>rooms · moderation · tokens · billing"]
        Relay["Relay mesh<br/>QUIC / WebTransport"]
    end
    App -- "1. sign in (your auth)" --> Backend
    Backend -- "2. MintClientToken (gRPC + API key)" --> Control
    Backend -- "3. token" --> App
    App -- "4. connect with token, publish / subscribe" --> Relay
    Control -. "policy & moderation" .- Relay

MOQOM never sees your user database: your backend authenticates users however it already does, then asks MOQOM for a short-lived token naming that user, their device, the room, and exactly what they may do.

Next steps

• Learn the vocabulary in Concepts.
• Get a call running in the 5-minute quickstart.