Streamux: from-scratch Go HTTP/2 server passes 145 of 146 h2spec tests with RFC 9218 priorities

A developer publishing as silvern47 has released Streamux, an HTTP/2 server written from scratch in Go and introduced in a post on dev.to. According to the author, the implementation covers the full current HTTP/2 specification, RFC 9113, and passes 145 of the 146 checks in h2spec, the standard conformance suite for the protocol. The distinguishing feature, the author says, is a write scheduler that consumes the priority hints browsers already attach to requests — signals most deployed servers simply discard.

Near-complete RFC 9113 coverage

The post enumerates the components built from scratch: frame handling, HPACK header compression, the stream state machine, flow control, and TLS enforcement. Together those cover essentially the whole surface of HTTP/2 as standardized today; RFC 9113 obsoleted the original 2015 specification and tightened several of its requirements, including constraints on the TLS versions and cipher suites an implementation may accept.

The single remaining h2spec failure is not identified in the post, so anyone evaluating the server for real use would need to run the suite themselves. Even so, landing within one check of a clean sheet is notable for a from-scratch stack: h2spec probes corner cases in framing, error handling and stream state transitions, which is exactly where hand-rolled implementations tend to stumble.

A scheduler that acts on urgency hints

The more unusual part is prioritization. HTTP/2 originally shipped with a dependency-tree priority scheme that saw little real-world adoption, because browsers sent trees that servers rarely honored. RFC 9218 replaced it with a simpler extensible scheme built around two parameters: urgency, from u=0 (most urgent) to u=7, and an incremental flag. Modern browsers send these hints on ordinary requests.

Streamux's answer, per the post, is a pluggable write scheduler that applies deficit round-robin — a classic fair-queuing algorithm — across urgency levels. HTTP/2 flow control grants each stream credit in window-sized chunks, so the scheduler gets a decision point every time a window replenishes: urgent streams have their bytes queued first, while low-priority background traffic waits.

The author reports one benchmark: with 50 concurrent streams and a 16 KiB flow-control window, the deficit round-robin scheduler finished the workload 40% faster than plain round-robin, with content users see first arriving ahead of low-value requests such as analytics beacons. Those figures are the author's own, from a single micro-benchmark, and have not been independently verified — but the direction of the result matches what prioritized scheduling is supposed to deliver.

A C ABI for non-Go code

Streamux also builds as a shared library exporting a C ABI, so services written in other languages can link the HTTP/2 stack directly rather than run it as a standalone process. The post does not detail the API surface, but the stated intent is reuse beyond the Go ecosystem.

Why it matters

Most production HTTP/2 stacks ignore client priority signals, which means the latency benefits RFC 9218 was designed to provide rarely materialize in practice. An implementation that treats urgency as a scheduling input — and publishes numbers showing the effect — is a working demonstration that the standard can do what it promises, at least under controlled conditions.

There is also reference value. A compact, conformant, readable HTTP/2 implementation is rare, and it lowers the barrier for learning the protocol or experimenting with scheduler ideas without wrestling with a large production stack. The C export extends that reach to non-Go codebases.

The usual caveats for a solo project apply: self-reported benchmarks, one failing conformance check, and no evidence yet of behavior under real production load. As open systems work, though, it is a release worth attention from anyone building or operating web infrastructure.