Zero-copy, deterministic, sans-io WebRTC data channels for Kotlin Multiplatform.

com.ditchoom:webrtc is a WebRTC stack built in common Kotlin on top of the DitchOoM buffer and socket libraries. It runs its protocol cores — ICE, DTLS, SCTP — on our own driver over a DatagramChannel seam on every platform, rather than wrapping libwebrtc. The one exception is browsers, where there is no raw UDP, so the implementation delegates to the platform's RTCPeerConnection.

Status: pre-release, W0 (foundations). The module tree builds and publishes across the full target matrix; the protocol cores are being implemented wave by wave. See EXECUTION_PLAN.md.

The precedent is socket-quic-quiche: a full transport protocol (QUIC) already runs on our own driver over a UDP seam on every platform. WebRTC is the same shape — plus ICE in front and SCTP behind — and this time the protocol cores are ours, which is what makes deterministic replay possible.

Phase 1 delivers RTCDataChannel semantics (ICE + DTLS + SCTP + DCEP + JSEP/SDP) — the part with no codec/hardware dependencies, slotting directly into the existing StreamMux/MultiplexingTransport world so MQTT/RPC/codec consumers can ride a peer-to-peer data channel with zero new API. Phase 2 adds RTP/RTCP/SRTP (media transport); codec encode/decode stays platform-native and outside this library.

Signaling is a seam, never an implementation. The library exchanges SessionDescription / IceCandidate values through an interface you supply — no HTTP, no WebSocket, no opinion. This is both correct layering (WebRTC standardizes no signaling protocol) and what makes the offer/answer state machines fully deterministic in tests.

val pc = PeerConnection(config)                       // held; use { } sugar via SessionTransport
pc.createDataChannel("chat")                          // pre-negotiated or DCEP
val offer = pc.createOffer(); pc.setLocalDescription(offer)
// your app ships the offer/candidates over ITS signaling and feeds back
// setRemoteDescription / addIceCandidate

// A data channel IS a buffer-flow StreamMux: openBidirectional() etc. Anything written against
// MultiplexingTransport-style mux code runs over WebRTC unchanged.

./gradlew build                 # all modules, all host-available targets
./gradlew allTests              # tests across every module + platform
./gradlew publishToMavenLocal   # publish 0.0.x to ~/.m2

Requires JDK 21 (via toolchain). Apple targets build on macOS. Per-module build configuration is a single convention plugin (build-logic/) — a module's own build file carries only its dependencies.

Two properties drive every decision — zero-copy throughput and deterministic replay — and both are enforced, not aspirational. See DESIGN_PRINCIPLES.md (type-safety + zero-copy manifesto), RFC_KMP_WEBRTC.md (architecture), TESTING.md (unit → integration → interop strategy), and CLAUDE.md (standing directives).

Because every core is sans-io and caller-clocked, the full stack (ICE + DTLS + SCTP) integration-tests deterministically under virtual time on every platform — a rarity for WebRTC. Foreign-peer interop (Pion, headless Chrome) finds bugs; each one is demoted into a committed deterministic fixture, so it never flakes again. Real STUN/TURN (coturn), real NAT (iptables profiles), and impairment (netem) run in the container harness. Full strategy in TESTING.md.

Apache 2.0 — see LICENSE.md.