Friday, October 30, 2026

Introducing grpc-over-datachannels: gRPC over WebRTC DataChannels, without HTTP/2

Today we are launching grpc-over-datachannels: gRPC running over a single WebRTC RTCDataChannel instead of HTTP/2. Many concurrent calls — unary, server-streaming, client-streaming, and bidirectional streaming — are multiplexed onto one ordered, reliable data channel using a small frame protocol, with no HTTP/2 stack and no server endpoint to reach.

The runtimes are generated and dependency-free. From one source of truth, recursive metaprogramming generates the gRPC runtime and protoc plugins for Rust, JavaScript, Go, Python, Java, C#, C++, Swift, Kotlin, Dart, Zig, C99, Lua, Ruby, PHP, and Scala — for native clients and servers, and for browser clients (including WASM facades that wrap the JavaScript browser client). Generated tests verify the wire protocol against stock gRPC implementations through a TCP-to-DataChannel proxy, so behaviour is checked against the reference, not just against itself.

Try it in the browser

No install is needed to generate stubs for your own service. Open the live in-browser generator, paste or edit a .proto file, pick your languages, and download generated stubs plus the matching runtimes. Schema compilation and the actual code generators run entirely client-side in the page.

Get the code

Source, specification, quick start, and examples are on GitHub: browser-grpc/grpc-over-datachannels. Documentation lives at browser-grpc.github.io/grpc-over-datachannels. Current release: v0.36.0.

This blog is now the project log for grpc-over-datachannels. The older low-latency and systems posts below — on websockets, AF_XDP, kernel latency, and socket multiplexing — are the background this work grew out of, and they are staying. Next up: the Kafka proxy, and the package ecosystem.

Dig deeper

The wire format under all of this is specified in One data channel, many calls: the grpc-dc frame protocol. Underneath it sits our own WebRTC stack: Rebuilding WebRTC from scratch: ICE, DTLS, SCTP with zero dependencies. And the generated runtimes are graded against Google's implementations, not just themselves: Trust but verify: oracle-testing generated gRPC.

Saturday, February 27, 2021

The next replacement for websockets, UDP.

If you're a dev, please like this post, and "star" the issue below, it's pretty far reaching for the internet. https://bugs.chromium.org/p/chromium/issues/detail?id=1069742

Sunday, December 20, 2020

Software development, are we doing something wrong? Check out the New York Stock Exchange, NYSE Pillar.

At risk of oversimplifying, something worth noting. Since the beginning of man, from an engineering perspective, we have made the biggest jumps when building tools which are used to build other tools. Why shouldn't the same thing apply to software. Why not write systems which generate other systems, etc. etc.?
NYSE Pillar, arguably one of the most critical systems on the planet, was built this way. The brains behind it? Alexei Lebedev. I had the privilege of observing this feat while working at Intercontinental Exchange, when it purchased the New York Stock Exchange.
Interested in seeing the goodies? Think we should have an open source framework? Merry Christmas, see OpenACR

Friday, December 11, 2020

AF_XDP and the linux kernel, this is gonna be big

I've been talking about kernel bypass for a long time. Now, it's being distributed with the linux kernel. It's now possible to intercept packets before they hit the kernel. Xilinx is now taking advantage of the feature. Amazing times!

See the github repo here.

Sunday, January 28, 2018

Howto fix the Spectre and Meltdown exploits

In prod, use bare metal servers which you completely control. Anytime there is a chance of someone running a VM on the same physical server as yourself, which is out of your control, the threat surface exists. Keep it simple, and ensure you have complete control of the bare metal server. AWS is in the process of providing bare metal options. And www.packet.net has already been doing this for quite some time.

Friday, January 5, 2018

Performance workaround for Meltdown and Spectre exploits/vulerabilities

Those of us familiar with kernel-bypass techniques are keenly aware of the overhead in the user/kernel transition, especially when multiplexing many thousands of tcp sockets.

Believe it or not, Windows already has the pieces needed to recover the lost performance, due to the new security fix overhead found in the user/kernel transition when doing socket i/o. We can create what is essentially a user-mode tcpip stack using Windows RIO (aka Registered i/o) to batch many tcpip packets into a single user/kernel transition. Combine with the User Mode Scheduler (UMS), which basically intercepts i/o calls, before incurring the overhead of the user/kernel transition, and batches these calls into our RIO based tcpip engine.

This infrastructure could then be a shim layer within windows docker containers running both windows and linux.

What we need now is a UMS concept on the linux side so the same can be done.

BTW, Intel CEO Brian Krzanich needs to go asap. Given the stock sale, he is doing more harm than good.

Tuesday, April 4, 2017

Low latency, high throughput TCP

For C++ devs looking to push the envelope with respect to latency and throughput when using TCP, checkout mTCP! https://github.com/eunyoung14/mtcp