This is huge. Probably the biggest realization for open-source @CloudNativeFdn metrics this year.
🔥 Scraping 345,000 active @PrometheusIO series every 15s and sending via Remote Write 2 or @opentelemetry OTLP takes on modern @golang collectors:
• ~1 GiB of RAM (WSS) with ups & downs (WAL compaction, cardinality bumps)
🚀 With @rustlang and @ApacheArrow via @opentelemetry otel-arrow using our new Prometheus https://t.co/BRk0kLe9PX crates:
• ~30 MiB of RAM (WSS, 5 MiB live heap)
• 2.6x–7.3x less CPU, flat for 23 hours 😱
I couldn't believe it. How is this even physically possible?
We have an opportunity to save $2.5B–$4B/yr in collector compute globally, and easily $100M+/yr at single-hyperscaler scale. We can scale 30x per pod, get hardware back, and deprioritize complex scalability band-aids like DaemonSet VPA and sharding.
Yes, I wrote the @OReillyMedia "Efficient Go" book, but for the last 2 weeks I've been becoming a Rust and columnar developer. There is no other way. This is the way.
And yes, we are starting a https://t.co/JfJeRMftO0 (ecosystem-wide) SIG — see #prometheus-rs-sig on CNCF Slack!
Huge thanks to the OpenTelemetry otel-arrow community for doing most of the work, Laurent Quérel for consulting, and the @ThanosMetrics & @PrometheusIO communities for columnar inspirations 💪
(Disclaimer: early numbers without full parity yet—with staleness, relabeling, and K8s discovery, compute needs will grow. Still, starting at 30 MiB WSS gives us tons of room!)
LZ4 new release:
v1.11.0 introduces multithreading in the library, and substantial speed gains for small data.
And more tests. Tons of little tests and minor fixes following a large influx of contributions.
This is a recommended upgrade:
https://t.co/kdYX0FC5pg
JEP 544 (https://t.co/hwtqGrpd4Y), the remaining part of Leyden has landed in JDK mainline. So now we can do this! This source launcher involves javac compilation, that is the bulk of the work here.
@gunnarmorling Yeah, 28 will be a nice release. Just before the next LTS too. You can experiment with AOT compilation via the nightlies btw.
https://t.co/RpLZhALAvV
OpenZL v0.3.0 is released :
https://t.co/H0hQ8KY4Oh
It has a faster LZ engine, close to LZ4 speeds, featuring a novel Huffman backend (PivCo), and a neural network that builds compression graphs on the fly, resulting in much higher compression ratios for numeric sources.
✅ JDK 27 shipped yesterday with Shenandoah Late Barrier Expansion (JDK-8366041), gets us 0..20% throughput bump.
🔄 JDK 28 would hopefully ship in Mar 2027 with Shenandoah Hotpatching (JDK-8384415), gets us another 0..5% throughput bump.
🤘 JDK 29 in Sep 2027 would be awesome.
@starbuxman If you like the compact 64-bit object headers of HotSpot in Java 27, you will love the 32-bit object headers in @GraalVM native image that are the default since Java 25 😉!
"To evaluate the warmup benefit of AOT code, we ran a javac benchmark application which repeatedly compiles the same 50 source files... The AOT cache without AOT code improves startup time by about 30%; adding AOT code brings an additional 45% improvement, for a total of 75%"
The Rust team is calling this the largest single change to the compiler since its initial release. It just landed on nightly. 🦀
After nearly 4 years of work, the next-generation trait solver is close to stabilization. It completely replaces how rustc proves where-clauses, normalizes associated types, and reasons about generics : the deep internals most Rust code depends on without ever seeing directly.
Why it matters, concretely:
→ More than 200 known GitHub issues fixed by this change alone
→ Unblocks Type Alias Impl Trait and Return Type Notation, both stuck behind this for years
→ Opens the door to fixing remaining type system unsoundnesses
→ Fixes real bugs found in production crates like bevy and minijinja
The performance story is the most interesting part. The new solver was, in some cases, quadratically or exponentially slower than the old one. The team benchmarked the top 20,000 crates on https://t.co/TDuQuTLQ6X and spent the last few weeks specifically hunting down the worst outliers.
The results are already dramatic in places: datafusion now compiles over 8x faster. A chess engine implemented entirely in Rust's type system, which used to hang the old solver completely, now compiles in about a minute.
Still nightly-only, still finding edge cases and rough error messages. But four years of foundational compiler work, tested against real-world code at genuine scale, heading toward stabilization in the coming months.
🔗 https://t.co/In9aKWrWwD
#RustLang #CompilerEngineering #TypeSystems