Latest release: v1.0.2 (Stable) — patch release fixing the WebTransport ALPN mismatch and the oversized Windows bundle, and shipping the signing public key with the release (v1.0.1 remains published and unchanged; the v1.0.0 tag is retained as source milestone only and was never published as a GitHub Release). Public API frozen per ADR-015; NIMRTC_API_VERSION = 10002, NIMRTC_API_VERSION_PRE_RELEASE = "". Chrome ↔ NimRTC data exchange (DC-1) via the Chrome WebTransport JS API (new WebTransport(url), not RTCPeerConnection.createDataChannel()) over QUIC PASS E1–E6 via tests/chrome_interop_harness/run_webtransport_harness.py + interop/chrome/test_chrome_webtransport.html against examples/demo-wtserver (datagram + bidi-stream echo). EngineConfig::datachannel_backend defaults to "web_transport"; the "sctp" backend was retired from the public selectors in v1.2.0 (it was an in-process loopback socket that could never reach a peer). See CHANGELOG.md ## [1.0.2] and docs/plan/v1.0-plan.md §3 + §12.3.6.

Current main (post-v1.0.2, unreleased): the trunk is ahead of the published tag by the v1.1 release, which consolidates the former v1.1 / v1.2 / v1.3 drafts into one version target: the packaging + benchmark track, the transport / media / DTLS hardening track, and the quality-line items (shared adaptive jitter strategy, src/modules/jb_strategy; a simplified Goog-CC-style BWE — delay + loss hybrid estimation, not a full trendline port; RTCP feedback loop; engine-level ref_frame and video stats; GMSSL vendoring as a submodule + the SRTP backend seam; engine source split). Local suite on Windows/MSVC Debug: 651/651 PASS (measured 2026-11-04). The packaging rules (NIMRTC_INSTALL=ON → include/ + lib/ + lib/cmake/NimRTC/) are landed on main and will ship in the next release; the published v1.0.2 bundle does not contain them yet. See Current progress and Roadmap for the full picture.

🌐 Other languages: Simplified Chinese · Try the live demo: nimrtc.github.io/nimrtc/wasm

A native C++ WebRTC alternative — embeddable, scene-assembled, swappable backends.

One source tree ships a P2P client, a relay gateway, and runs on embedded Linux aarch64. DTLS / RTP / 3A codecs are all pluggable; the DTLS crypto path can swap to GMSSL for GM/T-regulated deployments without forking the trunk.

Note on terminology: the gateway shipped by this source tree is the relay profile — single-strategy forwarding with compile-time L2 codec skip, per docs/zh/architecture.md §7.1. A from-scratch SFU module is not a deliverable: the §7 pre-1.0 decision window for SFU-1 / DC-3 / BENCH-1 closed as NO (BDFL, 2026-10-19 — SFU is not a project core goal; see docs/plan/v1.0-plan.md §7 + §12.5). The profiles/sfu.json and profiles/sfu-agent.json files remain in the tree as unregistered JSON — they carry the sfu_enabled marker and the sfu-relay transport strategy, but there is no kProfileSfu constant and they are not part of the shipped Profile set.

Why NimRTC? · Who is it for · Quick Start · Hello, World · Architecture · Benchmarks · Roadmap · FAQ

WebRTC moved on, but the dominant implementation didn't.

• libwebrtc is the de-facto engine, but its build is multi-GB, its crypto and codecs are black-box, and the codebase is monolithic. Embedding it on aarch64 or auditing it against GM/T regulations is an exercise in pain.
• AI Agents / teleop / embodied-AI robotics need things libwebrtc doesn't expose cleanly — a pre/post-3A PCM tap, intra-scheduler strict-priority ordering (DC-2, see sched.hpp Scope note; not a wire-level cross-connection guarantee under the default web_transport backend), and a capture-to-decision frame-time API.
• Xinchuang / regulated environments need a swap-in path to GM/T cryptography, not a fork.

NimRTC is a from-scratch C++20 implementation that keeps the wire-level interop you need (verified against Chrome: Case D media over DTLS-SRTP, Case E data over the Chrome WebTransport JS API) and replaces the opaque monolith with a compile-time layered, plugin-adapted engine you can read, swap, and ship on aarch64.

• What: An embeddable C++20 media engine for real-time communication — a from-scratch WebRTC alternative, not a fork of libwebrtc.
• Why it exists: libwebrtc is large, hard to embed, and its crypto/codecs are opaque. NimRTC keeps the wire-level interop and replaces the monolith with a layered, plugin-adapted engine you can read, swap, and ship on aarch64.
• Current state: v1.0.2 is the latest published release (Stable). The main trunk is post-v1.0.2 and unreleased, carrying one consolidated v1.1 release:
  • v1.1 — Quality + Packaging + Hardening: reproducible transport-floor benchmarks (tools/benchmark_latency.py, tools/benchmark_dc.py) with CI artifacts; install rules (NIMRTC_INSTALL=ON) that produce include/ + lib/ + lib/cmake/NimRTC/ so find_package(NimRTC) works from an installed tree, and the WebRTC APM prebuilt shipped alongside it; the transport-stack residuals (ISctpSocket lifecycle, ICE last_recv_packet() demux, unified make_transport_instance(), p99 strategy validator, non-standard video clock-rate negotiation, DTLS IPv6 set_peer(), NAT-rebinding rehandshake()); and the quality line — the RFC 3550 jitter estimator and the "base + 4·J" target-delay policy now live once in src/modules/jb_strategy, with the audio (jb) and video (video_jb) front-ends sharing it (video-side adaptive playout is opt-in via EngineConfig::video_receiver_tuning.adaptive_playout), plus a simplified Goog-CC-style BWE (delay + loss hybrid estimation — not a full trendline port), the RTCP feedback loop, engine-level ref_frame / video stats, GMSSL vendoring as a submodule, the SRTP backend seam and the engine source split. Public API is frozen per ADR-015 (NIMRTC_API_VERSION = 10002); breaking changes require a MINOR/MAJOR bump. Local suite on Windows/MSVC Debug: 651/651 PASS. In-process SFU relay (nimrtc_sfu), DC forwarding policy (DC-3), and sfu-relay benchmark (BENCH-1) were closed as NO on 2026-10-19 and remain off the critical path per docs/plan/v1.0-plan.md §7 (SFU is not a project core goal).

No single feature here is brand new — but the combination is rare in the open-source WebRTC ecosystem in 2026:

The plugin interfaces are the architectural seam. They make the five points above work together. See § Plugin Architecture below.

Not a fit if: you need a turnkey browser-grade SDK today, or you only target mobile (iOS/Android are roadmap, not a current-track item).

Each platform bundle ships the vendored third-party dependency stack for that platform — the wolfSSL / libsrtp3 / libjuice / msquic headers and libraries — so you can inspect and link the same crypto, SRTP, ICE and QUIC primitives the engine uses without building them yourself.

The v1.0.2 bundle does not yet contain NimRTC's own headers, static library, or NimRTCConfig.cmake. find_package(NimRTC) therefore does not work from the downloaded v1.0.2 bundle, and linking NimRTC itself still requires a source build (see Quick Start below). This is fixed on main: the NIMRTC_INSTALL=ON rules now produce include/ + lib/ + lib/cmake/NimRTC/ (verified downstream on Windows; Linux downstream proof runs in ci.yml on every push), and the next release will ship them.

The v1.0.2 bundles also carry no WebRTC APM archives — there is no lib/webrtc_apm/ directory in any of the four tarballs — so a downloaded bundle provides no audio 3A at all. The release body states the per-platform 3A status as "the build used the real WebRTC APM, but this bundle ships no APM archives"; the archives are installed by the main install rules and will appear in the next release.

• Release page: v1.0.2
• Assets: nimrtc-1.0.2-<platform>.tar.xz + .sha256 + .asc (sbom.json included)

tar -xJf nimrtc-1.0.2-linux-x86_64-gcc.tar.xz
sha256sum -c nimrtc-1.0.2-linux-x86_64-gcc.tar.xz.sha256
gpg --verify nimrtc-1.0.2-linux-x86_64-gcc.tar.xz.asc

Signing key fingerprint: 114154CFEC3F5EE5A8D2D313BEACFBB55871CC06.

• CMake ≥ 3.25
• MSVC 19.43+ (Windows 10/11) · GCC 11+ / Clang 12+ (Linux) · Apple Clang 15+ (macOS 14+)
• Ninja (recommended)
• Python 3.8+ (for the e2e harness)

Verify your toolchain:

python tools/check_prerequisites.py

git clone --recurse-submodules https://github.com/NimRTC/nimrtc.git
cd nimrtc

:: Windows
.\scripts\build.bat
.\scripts\build.bat --release     :: Release config

# Linux / macOS
bash scripts/build.sh
bash scripts/build.sh --preset=release

cmake --preset debug            # or: debug.msvc, debug, release, release.aarch64
cmake --build build --config Debug -j

Preset reference: see CMakePresets.json. The dev.* presets are hidden and inherited by visible ones; use debug.msvc / release.msvc / debug.aarch64 / release.aarch64 etc.

ctest --preset tests --output-on-failure

Two in-process agents handshake over real UDP — no signaling server needed.

cmake -B build -DNIMRTC_BUILD_EXAMPLES=ON -DCMAKE_BUILD_TYPE=Debug
cmake --build build --target loopback-p2p
./build/examples/Debug/loopback-p2p        # or .exe on Windows

python tools/run_e2e_acceptance.py
ls build/e2e/        # artifacts land here

First-build note: all third-party deps are managed via git submodules + SHA-pinned src/third_party/vendor.json. The --recurse-submodules flag on clone handles this.

Two engines complete an SDP exchange, run ICE connectivity checks on the loopback interface, and reach the connected state — in ~30 lines of C++. This is the same code path that ships in examples/loopback-p2p/:

#include <nimrtc/engine/engine.hpp>
#include <thread>
#include <chrono>

using namespace nimrtc::engine;
using namespace std::chrono_literals;

int main() {
    EngineConfig cfg;
    cfg.local_bind_address    = "127.0.0.1";
    // Leave local_port_range_begin / _end at 0: the OS assigns each engine
    // its own ephemeral UDP port, so the two never share a socket.
    cfg.pcm_sample_rate_hz     = 48000;
    cfg.pcm_channels           = 1;

    // Offerer (CONTROLLING)
    NimRTCEngine A(cfg);
    A.pre_open();
    A.open();
    auto offer = A.create_offer();

    // Answerer (CONTROLLED) — pre-set remote ICE so libjuice picks the right role
    NimRTCEngine B(cfg);
    B.pre_open();
    B.set_remote_ice(extract_ice_block(offer));   // helper, see examples/
    B.open();
    auto answer = B.process_remote_sdp(offer);

    A.process_remote_sdp(*answer);

    // Drive both engines until ICE is up on both sides
    while (A.ice_state_string() != "connected" || B.ice_state_string() != "connected") {
        A.tick();
        B.tick();
        std::this_thread::sleep_for(10ms);
    }
    return 0;
}

Three things worth noticing:

1. No mock objects, no test harness — the engine talks to itself over real UDP on 127.0.0.1. The same NimRTCEngine ships in your app; there is no separate "test API".
2. DTLS, SRTP, RTP, jitter buffer, ICE are all wired inside tick() — the user code is intentionally free of any protocol state.
3. The plugin interfaces don't leak into the application. If you later swap wolfSSL for GMSSL, or in-tree 3A for a hardware backend, this code does not change.

Full source: examples/loopback-p2p/loopback-p2p.cpp. For Chrome-baseline interop (offer from Chrome, answer from NimRTC, SDP↔ICE manually bridged), see interop/ and tools/run_e2e_acceptance.py.

NimRTC is four compile-time layers (L0–L3) sitting on top of a Plugin Adaptation Layer (PAL). A profile (also chosen at build time) decides which layers are even linked into the binary — this is how the same source tree ships both a P2P client and a relay gateway (relay profile skips L2 codecs; per docs/zh/architecture.md §7.1). An from-scratch SFU module is not a deliverable — the §7 pre-1.0 decision window closed as NO (BDFL, 2026-10-19; see docs/plan/v1.0-plan.md §7 + §12.5).

            ┌──────────────────────────────────────────────────────┐
            │  PROFILE  —  compile-time selection                  │
            │  call (P2P) │ transport │ relay │ agent │            │
            │  agent-gateway │ agent-low-latency │ teleop │ live   │
            └──────────────────────────────────────────────────────┘
                                    │
                                    ▼
            ┌──────────────────────────────────────────────────┐
            │  L3  Engine façade                                │
            │  NimRTCEngine wires the chosen profile + plugins  │
            └──────────────────────────────────────────────────┘
                                    │
                                    ▼
            ┌──────────────────────────────────────────────────┐
            │  L2  Codecs + 3A          (skipped by `relay`)       │
            │  Opus / G.711 / VP8 / H.264 / H.265 / AV1 · audio 3A  │
            └──────────────────────────────────────────────────┘
                                    │
                                    ▼
            ┌──────────────────────────────────────────────────┐
            │  L1  Wire / state                                 │
            │  RTP · RTCP · SDP · ICE · DTLS · SRTP · JB · BWE  │
            └──────────────────────────────────────────────────┘
                                    │
                                    ▼
            ┌──────────────────────────────────────────────────┐
            │  L0  Primitives                                   │
            │  bytes · log · time · status codes                │
            └──────────────────────────────────────────────────┘

       ┌──────────────────────────────────────────────────────┐
       │  PAL  —  Plugin Adaptation Layer                       │
       │  Every capability is resolved at build time.           │
       │  Zero runtime indirection, public API unchanged.       │
       └──────────────────────────────────────────────────────┘
                                    │
                                    ▼
       ┌──────────────────────────────────────────────────────┐
       │  PLUGIN INTERFACES  (header-only, in `src/plugins/`)   │
       │                                                       │
       │  ITransport · IICETransport · IRTP · ISDP · IJB       │
       │  IAudio3A · ICodec                                    │
       │  IVideoSource · IVideoSink · IDataChannel             │
       │  IHwCodec · IHw3A                                     │
       └──────────────────────────────────────────────────────┘

The same diagram, rendered natively by GitHub:

flowchart TB
    subgraph PROF["Profile - compile-time selection"]
        P1["transport: P2P client"]
        P2["relay: forwarding only"]
        P3["agent-gateway: PCM dual-tap"]
        P4["teleop: intra-scheduler priority (DC-2)"]
    end

    PROF --> L3
    L3["L3 - Engine facade / NimRTCEngine"] --> L2["L2 - Codecs + 3A (skipped by relay profile)"]
    L2 --> L1["L1 - RTP / RTCP / SDP / ICE / DTLS / SRTP / JB / BWE"]
    L1 --> L0["L0 - Bytes / log / time / status codes"]

    L3 -. resolved at build time .-> PAL["PAL - Plugin Adaptation Layer / zero-overhead resolver"]
    PAL --> PLG["Plugin interfaces: ITransport, IICETransport, IRTP, ISDP, IJB, IAudio3A, ICodec, IVideoSource/Sink, IDataChannel, IHwCodec, IHw3A"]

    classDef profile fill:#fef3c7,stroke:#92400e,color:#1f2937
    classDef layer   fill:#dbeafe,stroke:#1e40af,color:#1f2937
    classDef pal     fill:#dcfce7,stroke:#166534,color:#1f2937
    classDef plugin  fill:#f3e8ff,stroke:#6b21a8,color:#1f2937
    class P1,P2,P3,P4 profile
    class L0,L1,L2,L3 layer
    class PAL pal
    class PLG plugin

A frame enters via IVideoSource (or microphone capture for audio), gets RTP-packeted in L1, sent down ITransport, protected by IDTLS/ISRTP on the wire. On the receive side, the peer runs the inverse: ITransport → jitter buffer (IJB) → decoder in L2 → audio 3A (IAudio3A) → IVideoSink / audio render. BWE feedback loops close on RTCP. Everything above L0 is replaceable through a plugin interface — that’s why a fork-free swap to GMSSL or a HW 3A backend is a one-CMake-option change.

Detailed design: docs/zh/architecture.md (canonical, Chinese) · see ADR-012 for the docs-layout decision. English technical deep-dives are on the roadmap.

The headline reason to choose NimRTC over libwebrtc is size — both binary footprint and source-tree complexity.

Measured on: Windows 10 x86_64, MSVC, Release (local build/, nimrtc_engine.lib 13,164,084 bytes = 12.55 MB; example binaries from build/examples/Release/). Run python tools/benchmark_size.py build --markdown to re-measure after any build or option change.

Note: the static archive alone is 12.55 MB; the "~5.6 MB" figure quoted on the GitHub About page and in older docs predated the current module set and referred to an older build. The About page now quotes ~12.6 MB, matching the measured value above.

Source-LoC numbers are rough, measured via cloc excluding vendored dependencies. libwebrtc's number is widely cited and varies by platform/branch.

• Embeddable — NimRTC links into your host app at a few MB instead of pulling in a 100+ MB blob.
• Inspectable — You can grep the entire engine source tree. Auditing a security fix or a regulatory review against libwebrtc is impractical.
• Buildable on a laptop — NimRTC builds end-to-end in minutes on commodity hardware. libwebrtc's source fetch alone is GB-scale.
• Embedded-friendly — On aarch64 with -Os, NimRTC's link footprint drops further; libwebrtc's is rarely deployed outside x86_64 / arm64 servers.

• libwebrtc numbers are public reference values that vary by platform, branch, and codec set. Re-validate before publishing marketing claims.
• NimRTC numbers depend on which plugins / codecs you build (-DNIMRTC_PLUGINS_NVENC=ON etc.). Run benchmark_size.py after any option change.

Track A baselines are transport-floor numbers, not engine glass-to-glass claims. Typical ranges on Windows 10 x86_64 (local build/; loopback numbers vary run to run):

Reproduce with python tools/benchmark_latency.py --count 1000, python tools/benchmark_dc.py, and python tools/benchmark_weaknet.py --count 200 --size 1200; artifacts land in build/e2e/bench_latency.json + build/e2e/bench_dc.json + build/e2e/bench_weaknet.json. Exact numbers are machine- and load-dependent — the checked-in JSON is one local sample, not a pass/fail threshold. The weak-network tiers run through an in-process userspace shaper over localhost UDP (deterministic seeded impairments), so they are reproducible without root; the Linux tc qdisc netem counterpart is tools/benchmark_weaknet_netem.sh (needs root + iproute2) and lands in build/e2e/bench_weaknet_netem.json. A rate-limited tier is paced at 90% of the cap and its reading includes the link's serialization time, so the numbers above are the link's delay rather than a queue the sender built up itself. Engine glass-to-glass latency/jitter/MOS still depend on platform, codec, network, and target use case — profile-specific benchmarks land once P2 (PCM tap) and P3 (BWE + ref_frame) land.

See tools/benchmark_size.py, tools/benchmark_latency.py, tools/benchmark_dc.py, tools/benchmark_weaknet.py, and tools/benchmark_weaknet_netem.sh for the measurement tools.

NimRTC exposes nearly every "swappable" capability through plugin interfaces defined in src/plugins/include/nimrtc/plugins/*.hpp (ADR-001). The engine resolves them through PAL (ADR-009).

Comparison baseline: GStreamer / FFmpeg / OBS / PipeWire all use plugin architectures — but in the WebRTC ecosystem (libwebrtc / Pion / LiveKit / mediasoup / janus), only Pion and libwebrtc internally have similar abstractions. NimRTC exposes them publicly and runs both P2P and relay on the same set of interfaces (the relay profile skips L2 codecs; a from-scratch SFU module is not a deliverable — see docs/plan/v1.0-plan.md §7).

Plugins are the evolution mechanism: P0–P1 use built-in implementations; P2–P3 differentiating features (dual 3A tap, intra-scheduler strict-priority ordering, ref_frame timeline) also ship as plugins (IJB::set_render_delivered, IRTP::set_ref_frame).

A pragmatic matrix for evaluators — read across the rows that matter to you:

Where NimRTC wins outright: aarch64 embedded, GM/T crypto path (DTLS layer), AI Agent hooks, single-trunk P2P+relay (where relay is the single-strategy gateway profile that compiles out L2 codecs; a from-scratch SFU module is not a deliverable — see docs/plan/v1.0-plan.md §7, BDFL 2026-10-19). Where NimRTC loses: ecosystem breadth, codec coverage, browser-engine parity, and years of hardening. Pick accordingly.

Profiles are compile-time configurations, not runtime dispatch. Format: see ADR-010 (JSON is the first-party format).

Full matrix (9 shipped profiles, with per-field JB / 3A / BWE / DC settings) lives in docs/profiles.md. cloudgame (cloud rendering / streaming) is a long-term candidate and is not in the shipped Profile set — see docs/plan/v1.1-plan.md §2 Track V.

The profiles/ directory also carries two unregistered JSON files, sfu.json and sfu-agent.json. They carry the sfu_enabled marker and the sfu-relay transport strategy, but there is no kProfileSfu constant and they are not part of the shipped Profile set — the from-scratch SFU module was closed as NO on 2026-10-19 (see docs/plan/v1.0-plan.md §7).

These are P2 / P3 targets, not P0 features — listed here so you can plan ahead.

The project now plans in versioned tracks rather than the old P1–P4 ladder. The authoritative plan documents are docs/plan/v1.*-plan.md.

Full roadmap: docs/zh/architecture.md §13 · docs/plan/v1.1-plan.md.

What you can do today. The table below covers what shipped up to and including v1.0.2 (the published release); the block after it lists the work that is landed on main but not yet published. Measured on Windows/MSVC Debug against a stock build: 651/651 PASS (2026-11-04; 3 tests skip when the real WebRTC APM is not part of the build).

These are in the trunk and will be part of the next release. There is no ## [1.1.0] CHANGELOG entry yet — the release-hardening track (four-platform release legs, signed tag) has not closed.

v1.0.2 is the published Stable release — public API frozen per ADR-015 (NIMRTC_API_VERSION = 10002, NIMRTC_API_VERSION_PRE_RELEASE = ""); WebTransport / msquic data plane (DC-1) + intra-scheduler ordering (DC-2, see sched.hpp § Scope note); Chrome e2e Case E (DataChannel over the WebTransport JS API — new WebTransport(url), not RTCPeerConnection.createDataChannel(); standard WebRTC DataChannel interop is not claimed; Firefox/Safari WebTransport support is incomplete) PASS E1–E6 — datagram + bidi-stream echo against examples/demo-wtserver via tests/chrome_interop_harness/run_webtransport_harness.py. EngineConfig::datachannel_backend defaults to "web_transport"; the "sctp" backend was retired from the public selectors in v1.2.0 (it was an in-process loopback socket that could never reach a peer). WebTransportDataChannel (id "web_transport") is the production backend per ADR-014. In-process SFU relay (nimrtc_sfu), DC forwarding policy (DC-3), and sfu-relay benchmark (BENCH-1) were closed as NO on 2026-10-19 per docs/plan/v1.0-plan.md §7 (BDFL: SFU is not a project core goal); they stay off the critical path.

Details in CHANGELOG "Platform support matrix".

Per-module NIMRTC_MODULE_* switches (RTP, SDP, JB, JB_STRATEGY, BWE, AUDIO3A, ICE, SRTP, DTLS, OPUS, SCHED, DATACHANNEL, SESSION, ASSEMBLY, VIDEO_*) are also available and all default to ON; see the root CMakeLists.txt.

nimrtc/
├── CMakeLists.txt             # Root CMake (C++20, options above)
├── CMakePresets.json          # Presets: dev, debug, release, asan, ci.{linux,windows,macos}
├── docs/                      # Technical doc (zh/en), ADRs, plans, security notes
├── examples/
│   ├── loopback-p2p/          # Two-agent ICE handshake smoke test
│   ├── demo-p2p/              # Full P2P client demo
│   ├── demo-wtserver/         # WebTransport / QUIC server (Case E peer)
│   ├── demo-agent-gateway/    # PCM tap → ASR/LLM mock on the `agent-gateway` profile
│   └── wasm-demo/             # /wasm/ landing page
├── profiles/                  # Profile library — one JSON per shipped Profile (9)
├── src/
│   ├── core/                  # bytes.hpp, log, time, status codes (L0)
│   ├── log/                   # Logger implementation
│   ├── engine/                # NimRTCEngine façade (top-level entry)
│   ├── dtls/                  # DTLS seam — wolfSSL + GMSSL backends
│   ├── sctp/                  # SCTP seam — stub + usrsctp
│   ├── transport/             # Transport stacks + strategies (webrtc-classic, raw-udp-arq, sfu-relay)
│   ├── raw_udp/              # Raw UDP transport
│   ├── web_transport/         # WebTransport / QUIC session (msquic)
│   ├── modules/               # 24 self-contained modules (see below)
│   ├── plugins/               # Public plugin interfaces (ADR-001)
│   └── third_party/           # Vendored deps (see table below)
├── tests/                     # Cross-module gtest integration tests
├── interop/                   # Chrome interop harness (media + WebTransport DataChannel)
├── cmake/                     # Shared CMake helpers
├── tools/                     # Vendor scripts, benchmarks, fuzzers, profiling helpers
└── .github/workflows/         # ci.yml · interop.yml · release.yml · wasm-demo-pages.yml

The src/modules/ tree holds 24 self-contained modules — each with its own CMakeLists.txt + include/ + src/ + tests/:

assembly · audio3a · bwe · datachannel · dtls · h264 · ice · jb · jb_strategy · opus · rtp · sched · sdp · session · srtp · video_frame · video_jb · video_payload · video_pipeline · video_rtcp_feedback · video_sdp_attributes · video_sink · video_source · video_stats

Pinned in src/third_party/vendor.json (SHA-verified by tools/check_vendor.py in CI). The Submodule column distinguishes a real git submodule (gitlink in the index) from a tree that is still checked into this repository.

usrsctp is also vendored under src/third_party/usrsctp for the SCTP seam.

# Ubuntu / Debian
sudo apt install ninja-build
# Fedora / RHEL
sudo dnf install ninja-build
# macOS
brew install ninja
# Windows (Chocolatey)
choco install ninja

You're in a non-VS-2022 Developer Prompt. Open "x64 Native Tools Command Prompt for VS 2022" and reconfigure.

Skip 3A entirely:

cmake --preset dev -DNIMRTC_VENDORED_WEBRTC_APM=OFF

Or fetch the prebuilt:

python tools/fetch_webrtc_apm.py
cmake --build build

1. Submodules not initialised — git submodule update --init --recursive
2. Compiler < GCC 11 — see table above
3. Stale build cache — rm -rf build && cmake --preset dev && cmake --build build -j

python tools/check_prerequisites.py             # full check
python tools/check_prerequisites.py --compiler  # compiler only

• Canonical technical doc: docs/zh/architecture.md (Chinese — see ADR-012).
• Architecture decisions: docs/adr/ (Chinese summaries, code/identifiers in English).
• RFCs: docs/rfcs/ — formal design records.
  • RFC 001: PCM tap — Final
• Standalone docs site: docs-zh.nimrtc.dev — planned, not live yet. The live demo at nimrtc.github.io/nimrtc/wasm is the currently reachable public artifact.

• Issues: bugs, feature requests, interop compatibility feedback — preferred channel.
• Pull Requests: read CONTRIBUTING.md; commits must be DCO-signed (git commit -s). No CLA.
• Interop CI: the interop/ directory runs in CI on Windows (media Case D + DataChannel Case E). Chrome (pinned stable) is the current baseline browser; Firefox is not part of the automated matrix yet.
• Security: private channel — see SECURITY.md.
• Vendoring policy: crypto / codecs / SCTP / 3A are vendored; RTP / RTCP / SDP / JB / BWE / ICE state machines / timeline scheduling are written in-house. See docs/zh/architecture.md §11.
• End-to-end acceptance standards: ADR-011 clarifies that the engine carries only single-hop budget; DB31/T 1505-2024 / T/SSITS 2003-2023 are the integrator's responsibility.

• Project: Apache-2.0
• Third-party: see NOTICE and docs/zh/architecture.md §11.

💬 GitHub Discussions — structured community channel.

For templates when starting a new thread, see .github/DISCUSSION_TEMPLATE/.

• ⭐ Star this repo — it tells the next evaluator that someone else is paying attention.
• 🐛 File an issue — bugs, interop mismatches against Chrome, missing plugin backends, all welcome.
• 🔌 Write a plugin — pick any interface in src/plugins/, implement it, ship it as a separate CMake target. See CONTRIBUTING.md.
• 🗣️ Discuss the design — start a thread on an ADR or open a docs/plan/*.md PR.
• 🔐 Security disclosures — private channel, see SECURITY.md.

"The plugin interfaces are the architectural seam. Make them easy, and the project scales."