Skip to content
Back to search

moq

Media over QUIC: Real-time latency at massive scale

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/moq-dev/moq with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/moq-dev/moq'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/moq-dev--moq/badge.svg)](/listings/moq-dev--moq)

HTML

<a href="/listings/moq-dev--moq"><img src="/api/listings/moq-dev--moq/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Full documentation lives at **[doc.moq.dev](https://doc.moq.dev)**.

- **[Run the demo](https://doc.moq.dev/setup/)** - try MoQ locally with a relay, demo media, and the web UI. - **[Agent setup](https://doc.moq.dev/setup/agent)** - teach your AI coding agent (Claude Code, Cursor, etc.) how to build with MoQ. The docs are also served as markdown via [llms.txt](https://doc.moq.dev/llms.txt). - **[Linux packages](https://doc.moq.dev/setup/install)** - install the relay and GStreamer plugin from `apt.moq.dev` / `rpm.moq.dev`. - **[Production setup](https://doc.moq.dev/setup/prod)** - deploy a relay with a real domain and TLS.

The quickest way to see it in action (requires [Nix](https://nixos.org/download.html) with [flakes](https://nixos.wiki/wiki/Flakes)):

# Runs a relay, demo media, and the web server
nix develop -c just

Then visit <https://localhost:8080>. Don't have Nix? See the [demo guide](https://doc.moq.dev/setup/) for manual setup.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 165 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <p align="center">
  2. <img height="128px" src="https://github.com/moq-dev/moq/blob/main/.github/logo.svg" alt="Media over QUIC">
  3. </p>
  4. ![License](https://img.shields.io/badge/license-MIT%2FApache--2.0-blue)
  5. [![Discord](https://img.shields.io/discord/1124083992740761730)](https://discord.moq.dev)
  6. [![Crates.io](https://img.shields.io/crates/v/moq-net)](https://crates.io/crates/moq-net)
  7. [![npm](https://img.shields.io/npm/v/@moq/net)](https://www.npmjs.com/package/@moq/net)
  8. # Media over QUIC
  9. [Media over QUIC](https://moq.dev) (MoQ) is a next-generation live media protocol that provides **real-time latency** at **massive scale**.
  10. Built using modern web technologies, MoQ delivers WebRTC-like latency without the constraints of WebRTC.
  11. The core networking is delegated to a QUIC library but the rest is in application-space, giving you full control over your media pipeline.
  12. **Key Features:**
  13. - 🚀 **Real-time latency** using QUIC for prioritization and partial reliability.
  14. - 📈 **Massive scale** designed for fan-out and supports cross-region clustering.
  15. - 🌐 **Modern Web** using [WebTransport](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport_API), [WebCodecs](https://developer.mozilla.org/en-US/docs/Web/API/WebCodecs_API), and [WebAudio](https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API).
  16. - 🎯 **Multi-language** with both Rust (native) and TypeScript (web) libraries.
  17. - 🔧 **Generic** for any live data, not just media. Includes text chat as both an example and a core feature.
  18. > **Note:** This project implements [moq-lite](https://doc.moq.dev/concept/moq-lite), a forwards-compatible subset of the IETF [moq-transport](https://datatracker.ietf.org/doc/draft-ietf-moq-transport/) draft. moq-lite works with any moq-transport CDN (ex. [Cloudflare](https://moq.dev/blog/first-cdn/)). The focus is narrower, prioritizing simplicity and deployability.
  19. ## Getting Started
  20. Full documentation lives at **[doc.moq.dev](https://doc.moq.dev)**.
  21. | I want to | Start here |
  22. | --- | --- |
  23. | Try MoQ | [Local demo](https://doc.moq.dev/setup/) or [live web demo](https://moq.dev/) |
  24. | Add streaming to an app | [Choose a library](https://doc.moq.dev/lib/) and [find an example](https://doc.moq.dev/setup/examples) |
  25. | Connect existing media tools | [CLI, OBS, GStreamer, and gateways](https://doc.moq.dev/bin/) |
  26. | Run a relay | [Install](https://doc.moq.dev/setup/install), then [production setup](https://doc.moq.dev/setup/prod) |
  27. | Understand the design | [Concepts](https://doc.moq.dev/concept/) and [protocol drafts](https://doc.moq.dev/draft/) |
  28. | Diagnose a problem | [Troubleshooting](https://doc.moq.dev/setup/troubleshooting) and [inspect a relay](https://doc.moq.dev/bin/inspect) |
  29. | Change this repository | [Repository map](doc/setup/repository.md), [development guide](doc/setup/dev.md), and [contributing](CONTRIBUTING.md) |
  30. | Work with a coding agent | [Agent setup](doc/setup/agent.md); repository instructions start in [AGENTS.md](AGENTS.md) |
  31. The quickest way to see it in action (requires [Nix](https://nixos.org/download.html) with [flakes](https://wiki.nixos.org/wiki/Flakes)):
  32. ```sh
  33. # Runs a relay, demo media, and the web server
  34. nix develop -c just
  35. ```
  36. It opens the watch, publish, and stats pages in your browser, or visit <http://localhost:5173/watch.html>. Don't have Nix? See the [demo guide](https://doc.moq.dev/setup/) for manual setup.
  37. ## Architecture
  38. MoQ is designed as a layered protocol stack.
  39. **Rule 1**: The CDN MUST NOT know anything about your application, media codecs, or even the available tracks.
  40. Everything could be fully E2EE and the CDN wouldn't care. **No business logic allowed**.
  41. Instead, [`moq-relay`](rs/moq-relay) operates on rules encoded in the [`moq-net`](https://docs.rs/moq-net) header.
  42. These rules are based on video encoding but are generic enough to be used for any live data.
  43. The goal is to keep the server as dumb as possible while supporting a wide range of use-cases.
  44. The media logic is split into another protocol called [`hang`](https://docs.rs/hang).
  45. It's pretty simple and only intended to be used by clients or media servers.
  46. If you want to do something more custom, then you can always extend it or replace it entirely.
  47. Think of `hang` as like HLS/DASH, while `moq-lite` is like HTTP.
  48. ```
  49. ┌─────────────────┐
  50. │ Application │ 🏢 Your business logic
  51. │ │ - authentication, non-media tracks, etc.
  52. ├─────────────────┤
  53. │ hang │ 🎬 Media-specific encoding/streaming
  54. │ │ - codecs, containers, catalog
  55. ├─────────────────├
  56. │ moq-lite │ 🚌 Generic pub/sub transport
  57. │ │ - broadcasts, tracks, groups, frames
  58. ├─────────────────┤
  59. │ WebTransport │ 🌐 Browser-compatible QUIC
  60. │ QUIC │ - HTTP/3 handshake, multiplexing, etc.
  61. └─────────────────┘
  62. ```
  63. ## Libraries
  64. Choose by the job you need done. The [library guide](https://doc.moq.dev/lib/)
  65. compares languages; the [repository map](doc/setup/repository.md) locates the
  66. implementation behind each feature.
  67. | Layer | Rust | TypeScript |
  68. | --- | --- | --- |
  69. | Live pub/sub | [moq-net](rs/moq-net) | [@moq/net](js/net) |
  70. | Media catalog and containers | [hang](rs/hang), [moq-mux](rs/moq-mux) | [@moq/hang](js/hang) |
  71. | Capture and playback | [moq-audio](rs/moq-audio), [moq-video](rs/moq-video) | [@moq/publish](js/publish), [@moq/watch](js/watch) |
  72. | Rooms and chat | | [@moq/room](js/room) |
  73. | Authorization | [moq-auth](rs/moq-auth) | [@moq/auth](js/auth) |
  74. The Rust core also has [Python](https://doc.moq.dev/lib/py/),
  75. [Swift](https://doc.moq.dev/lib/swift/), [Kotlin](https://doc.moq.dev/lib/kt/),
  76. [Go](https://doc.moq.dev/lib/go/), [Dart](https://doc.moq.dev/lib/dart/),
  77. [C++](https://doc.moq.dev/lib/cpp/), and [C](https://doc.moq.dev/lib/c/) bindings.
  78. [Layers](https://doc.moq.dev/lib/layers) maps their namespaces.
  79. ## Protocol
  80. Start with the [layering overview](https://doc.moq.dev/concept/), then use the
  81. [Internet-Drafts index](https://doc.moq.dev/draft/) for the wire and format
  82. specifications. Their editable sources live in [drafts/](drafts/).
  83. ## Stability
  84. The `release` branch is stable and is what gets published; `main` is the trunk where breaking API changes land between releases.
  85. Every package follows [semver](https://semver.org): a breaking API change bumps the first nonzero version number (`1.2.0` to `2.0.0`, `0.3.1` to `0.4.0`, `0.0.5` to `0.0.6`).
  86. Breaking wire changes are extremely rare.
  87. ## Development
  88. Contributions are welcome, and AI-assisted issues, pull requests, reviews, and comments are encouraged. See [CONTRIBUTING.md](CONTRIBUTING.md#ai) for guidance on when to open an issue before writing code.
  89. ```sh
  90. # See all available commands
  91. just --list
  92. # Build everything
  93. just build
  94. # Lint, compile, and test what your branch changed
  95. just check
  96. # Automatically fix some linting errors, same scope
  97. just fix
  98. # Same as the above, over every package
  99. just check --all
  100. just fix --all
  101. ```
  102. Expensive checks and test launchers automatically enter `quest gate` locally,
  103. including direct language recipes and fixture scripts. Admission waits for host
  104. CPU load and available memory before builds or test timeout clocks start;
  105. nested checks reuse that admission. Hosted GitHub Actions keeps its runner
  106. scheduling. Rust builds still use the dev shell's mbx Cargo shim.
  107. `just check` and `just ci` run three module lanes at once, each admitted per
  108. command; set `CHECK_JOBS` to change that, or to 1 to run them in order.
  109. `CHECK_MODULES` runs only the modules it names, or skips each one named with a
  110. leading `-`; `just gate rs` runs only the Rust module over every package.
  111. Local nextest runs default to at most four test workers; set
  112. `NEXTEST_TEST_THREADS` to override it. Bun workspace scripts run sequentially
  113. locally, preserving dependency order, while CI keeps its workspace parallelism.
  114. Selection and an empty JS selection do not wait for admission. For a build
  115. outside these entrypoints, use `bash sh/quest.sh gate COMMAND [ARGS...]`; gate thresholds
  116. come from the host and have no configuration.
  117. Run `just ci` before pushing. Ready PRs into `main` also run Check as a signal; only GitHub's merge queue gates landing. `just ci` runs what the merge queue runs, the same ground as `just check`, plus two settings: `CI_STRICT=1`, which turns a missing tool into an error instead of a skipped check, and `NEXTEST_PROFILE=ci`, which allows a longer hang timeout.
  118. See the [development guide](https://doc.moq.dev/setup/dev) and the [justfile](justfile) for more.
  119. ## License
  120. Licensed under either:
  121. - Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or https://www.apache.org/licenses/LICENSE-2.0)
  122. - MIT license ([LICENSE-MIT](LICENSE-MIT) or https://opensource.org/licenses/MIT)
  123. **Exception:** the OBS plugin under [`cpp/obs/`](cpp/obs) is licensed under **GPL-2.0-or-later** (see [`cpp/obs/LICENSE`](cpp/obs/LICENSE)), because it links OBS Studio's `libobs`, which is GPL-2.0. This is a separately-distributable work; per GPLv2 its presence in this repository is mere aggregation and does not affect the MIT/Apache licensing of the rest of the project. `libmoq` and the other moq crates remain MIT/Apache.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.