Tuesday, November 17, 2026

Authenticating a rendezvous server with passkeys, and a Kafka client in every language

Two releases of grpc-over-datachannels landed together this month, and they share a theme: closing the "yes, but in production?" gaps. 0.42.0 adds authentication and authorization to the rendezvous server. 0.41.0 extracts the Kafka client into its own native library with wrappers in every language we generate for.

v0.42.0 release · v0.41.0 release · kafka-native repo

Who is allowed to open a channel?

The rendezvous server brokers peer introductions, and until now it trusted any caller who could reach it. It can now require an HMAC-SHA256 bearer token on every call:

base64url(protobuf claims) + "." + base64url(HMAC-SHA256)

The claims are sub/iss/aud/exp/nbf/iat/scopes[]/jti — one wire layout, implemented identically in the generated JS, Go, and Rust servers and pinned by a single shared test vector, so a token minted for one stack validates on the other two. Verification happens before dispatch: bad, missing, or expired tokens fail UNAUTHENTICATED; a valid token without the scope a method needs fails PERMISSION_DENIED. Required scopes are a per-method-path map in the serve options, and verified claims reach the handler (ctx.claims in JS, ClaimsFromContext in Go, CallCtx.claims in Rust). Clients attach tokens per call with rendezvousChannel(descriptor, { token | getToken }), so token refresh is a callback, not a rebuild. Auth is rendezvous-only by design — there is no protoc option, because the DataChannel itself is the authenticated channel once the introduction is made.

Where do tokens come from? examples/rendezvous-auth/ is a stdlib-only WebAuthn issuer in Node: it verifies passkey registration and login over HTTPS and mints rendezvous tokens. The rendezvous server never sees WebAuthn data — it checks HMACs, the issuer checks passkeys, and the two meet only at the shared secret. A browser-free synthetic credential test covers the ceremony end to end.

One Kafka client, every language

browser-grpc/kafka-native is the in-process Kafka protocol client extracted from the kafka-proxy sidecar, published as a Rust crate and a Python wheel via Trusted Publishing. Every native wrapper binds the same C ABI (kafka_native_new_v2, with SASL PLAIN/SCRAM and TLS): Python, Ruby (Fiddle), Dart (dart:ffi), C# (P/Invoke), Java (JNI), PHP (FFI), JavaScript (N-API), and Go (cgo). The generated kafka-grpc clients and the in-process form factor cross-check each other record-for-record in a differential gate — all compression codecs, consumer groups, offsets — and since 0.42.0 the KIP-932 share-group session RPCs (OpenShareGroup, SharePoll, ShareAck, CloseShareGroup) dispatch through the FFI too, matching the proxy surface in every generated wrapper. KIP-848 next-generation consumer groups (server-side assignment, epoch fencing) are in, with the classic protocol as automatic fallback.

The pattern worth stealing: generate the protocol once, bind it everywhere, and make the form factors grade each other's homework in CI. Two independent paths to the same broker leave very few places for a bug to hide.

Both releases are live on npm, PyPI, pub.dev, crates.io, NuGet, Maven Central, RubyGems, LuaRocks, and JSR. If you put rendezvous auth in front of a real deployment, we'd like to hear which scopes you ended up needing — the per-method map is deliberately boring, and boring is what you want from an authorization surface.

gRPC over DataChannels 0.43.0: host/plugin support and packet-loss instrumentation

0.43.0 of grpc-over-datachannels is out. Two headline features: a host/plugin model that lets one public endpoint serve out-of-process plugins (a community request, issue #2), and unified packet-loss instrumentation that follows a call across the SCTP, TCP, and HTTP/2 legs of its path.

Release notes and downloads · Browser code generator

One endpoint, many plugin processes

The request was simple to state: expose one grpc-dc endpoint, and let independent processes register services on it at runtime, without recompiling the host. 0.43.0 builds that from pieces the runtimes already had:

  • IPC transports. The Rust, JS, and Go runtimes speak one length-prefixed framing over stdio and Unix domain sockets, so a plugin is just a grpc-dc server whose transport is a pipe instead of a DataChannel.
  • Runtime registration. Servers can register and unregister services after serve() starts, in all three runtimes — a plugin connecting is a registration, a plugin exiting is an unregistration.
  • Interceptor chains. Server interceptors compose in order; the rendezvous auth check from 0.42.0 is the built-in first interceptor. JS interceptors can supply verified claims to handlers; Go interceptors can replace the call context.
  • DC-to-DC routing. A host forwards by path prefix (route_prefix), so /my.PluginService/ can live in another process — or behind another DataChannel — while everything else stays local.
  • Discovery. The well-known grpcdc.registry.v1.Registry service lists registered services and returns their descriptors, so dynamic clients can call plugin services with no codegen.

The reference deployment is examples/plugin-host: a Rust host with a Node plugin process. Plugin lifecycle (spawn, restart, upgrade) deliberately stays the host application's job — the runtime provides the seams, not a process manager. SPEC.md documents the model.

Packet loss, measured on every leg

DataChannels don't lose packets the way TCP does — SCTP retransmits inside the association — so "is my call slow because of loss?" previously had no answer from the runtime. Now every SCTP association reports AssociationStats: packets and chunks sent/received, retransmits split fast vs timeout, duplicates received. One LinkStats snapshot unifies that with the TCP leg (wire-level counters from the smoltcp sidecar) and the HTTP/2 leg (frames, streams, flow-control stalls), all mirroring the same field shape the generated stats types already used. A live gate exercises all three legs of one call and asserts the counters move.

Also in 0.43.0

  • Rendezvous coverage grew teeth: TURN through a real coturn and STUN browser legs against the Go listener, rendezvous over IPv6, browser auth against Go and Rust servers, and adversarial listener tests (garbage input, 12-peer demux). One finding for coturn users: loopback listeners also need --allow-loopback-peers, or relay candidates silently never work (issue #1, a config fix, now regression-tested).
  • Kafka differentials now run in five languages (Python, JS, Go, Dart, C#): transactional produce through one form factor, read-committed consume through the other.
  • Crypto cross-checks against OpenSSL (P-256 both directions, P-384 ECDH, TLS 1.2 client handshake), and every export now ships CONTRIBUTING/SECURITY community files.

Packages for this release are live on npm (grpc-dc, kafka-grpc, eventbus-grpc), PyPI, pub.dev, crates.io, NuGet, Maven Central, RubyGems, LuaRocks, and JSR, with GitHub Packages mirrors, and generated runtimes for Rust, Go, JS, Python, Java, C#, C++, Swift, Kotlin, Dart, Zig, Lua, Ruby, PHP, Scala, and C. If you build a plugin host, we'd like to hear what lifecycle model you wrap around it — that part is intentionally yours.

Monday, November 9, 2026

gRPC over DataChannels 0.40.0: tracing (beta), Rust proxy, browser-safe SCTP

0.40.0 of grpc-over-datachannels is out. The headline is distributed tracing (beta) that works the same way in every generated runtime — 15 native languages plus the browser — but the release also carries an SCTP delivery overhaul and a measurement about browser packet sizes that changed how every stack in the project sends data.

Release notes and downloads · Browser code generator

Tracing that follows the call

Register a span observer and every generated client and server emits spans with durations and the W3C sampled flag. Unsampled trace contexts still propagate — they just don't record. The part that matters in practice: nested calls parent automatically. When a handler makes its own outbound gRPC call, that call joins the inbound trace with no manual context plumbing (ambient context on native runtimes, explicit trace-context binding in the browser). A client-originated call starts a root span when there is no parent, and the TCP/DataChannel proxy emits its own span for proxied calls, so a trace survives the hop from a stock HTTP/2 client into a DataChannel service.

Every language ships a TRACING.md next to its TESTS.md, and the test suites assert the full client/server parent chain — including the Wasm matrix, which pairs native and facade browser runtimes in both directions and checks that server spans parent to client spans in the same trace. Two real bugs fell out of that coverage: span-id seeding that trapped on wasm32-unknown-unknown, and a Lua span clock that broke in hosts without the os library. Both are fixed and now covered by checks that run against the published packages.

It's designated beta behind one central flag in the generator; the runtime stays dormant until your application registers a tracer.

The 2048-byte wall

While adding large-message legs to the browser matrix, we found something worth sharing: Chromium silently drops SCTP packets larger than 2048 bytes. A 2028-byte packet was acked; a 2128-byte packet was retransmitted forever — no error, no close, just a call that never completes. Chromium's own outgoing datagrams top out around 1225 bytes.

Our three hand-rolled SCTP stacks (Rust, Go, JS) now fragment at 1152-byte payloads: one chunk per packet, the whole packet comfortably inside the datagrams browsers themselves emit, and no IP fragmentation on real network paths. Receivers were always size-agnostic; this is purely a sender-side budget, and it's now enforced everywhere with the measurement recorded in the code.

Alongside that, all three stacks gained RTT-measured retransmit timers (SRTT/RTTVAR feeding the RTO, replacing a fixed 1-second recovery), O(1)-amortized reassembly, and a truthful advertised receive window that shrinks for gap-buffered data. The proxy stress leg grew to 8 MB; the browser matrix now pushes 192 KiB unary calls (just under the RTCDataChannel single-message cap) through 20/20 runtime pairs in Chromium and Firefox. A paced throughput bench (make bench-throughput) baselines our JS stack against Chromium's native one.

Also in 0.40.0

  • A dependency-free Rust TCP/DataChannel proxy in both directions: stock HTTP/2 clients call a grpc-dc server, grpc-dc clients call a stock HTTP/2 backend, TLS on both sides, compression terminated in the proxy. A new malformed-input corpus for the JS ingress proxy (garbage prefaces, truncated frames, gzip bombs, mid-message resets) found and fixed a status-mapping bug.
  • Embedded: the raw-Ethernet Echo proof now fragments a 10 KiB call across ~7 Ethernet frames each way and streams over the no-IP transport.
  • Fresh-consumer gates run against the published packages, so packaging regressions get caught outside the repo.

Packages for this release are live on npm (grpc-dc, kafka-grpc, eventbus-grpc), crates.io, pub.dev, NuGet, Maven Central, LuaRocks, and JSR, with generated runtimes for Rust, Go, JS, Python, Java, C#, C++, Swift, Kotlin, Dart, Zig, Lua, Ruby, PHP, Scala, and C. First published on dev.to. If you try the tracing beta, we'd like to hear where the model chafes — it's the last big surface we expect to iterate on before calling it stable.

Saturday, October 31, 2026

WebRTC-Direct examples in every language: no signaling, plus TURN and STUN modes

The latest grpc-over-datachannels release ships WebRTC-Direct examples for every supported language — generated, like the runtimes themselves. A server listens on a UDP socket and prints a certhash multiaddr (/ip4/…/udp/…/webrtc-direct/certhash/f…); a client dials that address and gets a DTLS/SCTP data channel carrying plain gRPC frames. No signaling server, no SDP exchange.

Three ways to connect

Direct — the client dials the multiaddr straight over UDP. This is the LAN and public-host path, and the server prints everything a client needs on one MULTIADDR line.

Via TURN — a client behind a symmetric NAT allocates a relay on a TURN server and dials the same listener through it. TURN is purely a client-side tool here: the server never changes and never learns TURN exists. Set DIRECT_TURN=host:3478 (plus user/password) or pass --turn to the sidecar.

Full ICE with STUN — a Direct listener gathers no ICE candidates, so STUN belongs to the peer mode: the Go and Rust examples include peer-serve/peer-dial modes where GRPC_DC_STUN=stun.l.google.com:19302 enables server-reflexive candidate gathering, with SDP exchanged through files as a stand-in for any signaling channel. Browsers join through this same full-ICE path — a browser has no UDP sockets, so it can never dial a multiaddr directly.

Every language, one shape

JavaScript, Go, and Rust embed the WebRTC stack and run the examples natively. The other thirteen languages — Python, Ruby, PHP, Lua, C, C++, Dart, Java, Kotlin, Scala, Swift, C#, and Zig — reach WebRTC-Direct through their generated SidecarTransport plus the small Rust direct_sidecar bridge, so the language code is identical whether the path is direct or TURN. Each example has serve and dial modes, and the compose file in examples/direct wires servers and clients together with a shared /signal volume as the whole client→server handoff, coturn fixture included.

Try it

Everything lands in examples/direct in the upcoming v0.36.0 release (December 1): start the Node server, copy its multiaddr, and dial it from any language. The per-language catalog lives at browser-grpc/examples. Two honest limits, documented in the README: a NATted listener still needs a port forward, a public host, or the TURN dial — STUN alone cannot make an inbound UDP listener reachable — and browser + tunnel + TURN is not supported, because the quick tunnels are TCP-only.

Friday, October 30, 2026

v0.35.12: the event bus gets its own repository

Release v0.35.12 of grpc-over-datachannels is out, and its headline is organisational: the generated event bus now has a dedicated home at browser-grpc/eventbus, the same treatment the Kafka proxy got with browser-grpc/kafka-proxy.

What is in the repo

The schema (proto/events.proto, grpcdc.events.v1.EventBus), the complete dependency-free Python and JavaScript trees — broker, clients, demos, and tests that run as-is — and the generated EventBus stubs, brokers, demos, and tests for the other fourteen languages under gen/<lang>/, ready to drop into the main repo's runtime trees. An EVENTBUS.md guide covers the service surface: typed routing tags, containment filters, broker-assigned sequence numbers, and the git-backed log variant.

Run it

The demo ships as a container: docker run --rm ghcr.io/browser-grpc/eventbus-demo:latest starts a broker, subscribes with a topic filter, and publishes three events so you can watch the filter admit two of them. The repo's CI builds the test image and runs the Python and JavaScript suites plus both demos on every push — it is green on the release commit.

Everything else moved too

As usual the release is published across GitHub, npm (grpc-dc), PyPI, NuGet (GrpcDc), Maven Central (io.github.browser-grpc:grpc-dc), and GHCR, all at 0.35.12. Background on the design is in A generated event bus; the main project remains browser-grpc/grpc-over-datachannels.

A generated event bus: publish/subscribe as a gRPC service in sixteen languages

Most systems eventually grow an event bus, and most event buses arrive as a heavyweight broker plus a client library per language. grpc-over-datachannels takes the generator's route instead: define the bus once as a gRPC service — grpcdc.events.v1.EventBus — and generate the broker and clients in all sixteen languages from that one schema.

The whole API is two calls

Publish takes routing tags, an opaque payload (typically your own serialized event proto), and a publisher id, and returns a broker-assigned sequence number. Subscribe takes a containment filter and returns a stream of events. An event carries its tags, payload, the broker-global sequence (1-based, in publish order), publisher id, and the broker's wall-clock timestamp.

Tag-value filtering

Tags are typed values — string, int64, double, bool, or any enum carried by number so it survives peers that do not know the enum. A subscription filter is a list of (tag, value) pairs, and an event is delivered when its tag list contains every pair in the filter; an empty filter receives everything, and the same tag may appear several times when an event must carry several values. There is no query language to learn and no stringly-typed topic hierarchy to govern: matching is set containment, evaluated the same way in every generated implementation.

Why generated matters here

Because the bus is just a .proto, publishers and subscribers can be browser tabs, native services, or mixed pairs over a DataChannel, and the broker itself has a generated implementation per language — including a git-backed event log variant for durable, inspectable history. Sequence numbers make ordering claims testable, and the same generated BDD scenarios that grade the runtimes grade the bus. If your architecture needs events, you already have the client: it was generated with your other stubs.

Update (v0.35.12): the event bus now has a dedicated repository — browser-grpc/eventbus — with the schema, the full Python and JavaScript trees, generated sources for the other fourteen languages, and CI. Run the demo with docker run --rm ghcr.io/browser-grpc/eventbus-demo:latest.

One open port for every peer: PeerMux and single-socket WebRTC serving

Running a WebRTC server usually means socket sprawl: a listener per peer, or a framework that owns your sockets for you. grpc-over-datachannels takes the opposite approach with PeerMux: many signaled peers hosted on one bound UDP socket — the single-port topology popularised by large conferencing systems — implemented in the Rust, Go, and JavaScript (Node) stacks.

Routing packets without addresses

A mux cannot route by source address: peers sit behind NATs, addresses get reused, and two muxes may peer with each other. So PeerMux routes by protocol contents instead. STUN packets route by ICE ufrag. The first DTLS flight routes by a pair-hint extension. Every later DTLS record routes by its RFC 9146 connection id. Once the DataChannel is up, the gRPC frames never see the socket at all — the mux is purely a packet demultiplexer under the stack.

What falls out of the design

A server needs exactly one open port for all its peer connections, which simplifies firewalls, containers, and home hosting. TURN still works on muxed peers (the allocation's UDP leg rides a dedicated per-peer socket). And because routing never depends on who sent a packet from where, two muxes can peer with each other directly.

Verified cross-stack

One generated scenario tests all three stacks, and the cross-stack matrix pairs mux against mux across implementations — Rust serving Go, Go serving JavaScript, and so on — so the routing rules are graded against independent code, not just against the implementation that proposed them. If you are embedding WebRTC serving into a native process, one port is all you have to give it.