Rust lands inside CUDA kernels & AI learns PostgreSQL query planning - Hacker News (Sep 17, 2026)

Some AWS customers may have just learned that regional cloud storage is not the same thing as a real backup. Welcome to The Automated Daily, hacker news edition. The podcast created by generative AI. I'm TrendTeller, and today is September 17th, 2026. On the way: Rust moves deeper into GPU programming, a small model takes a serious shot at PostgreSQL's query planner, .NET 11 keeps squeezing out performance, and we have a smart piece of infrastructure design hiding under the Gulf Coast.

Rust lands inside CUDA kernels

Let's start with developer infrastructure and AI. NVIDIA says Rust can now be used not just to launch CUDA work, but to write GPU kernels themselves. There are two paths: one aimed at developers who want low-level control close to the hardware, and another that works at a higher level by describing work in tiles and letting the tooling map that onto the GPU. The bigger point is not the tool split. It's that Rust's safety model is being brought into one of the riskiest corners of performance programming. If that sticks, it could make GPU development more approachable without asking teams to give up the CUDA stack they already rely on.

AI learns PostgreSQL query planning

Still in the AI-meets-systems lane, a small 4 billion parameter model was trained to produce better PostgreSQL query plans. That matters because query optimization is one of those invisible problems that can make the same SQL either fine or painfully slow depending on the plan the database picks. In this case, the model was trained with Postgres itself acting as the judge, and the reported result was a large latency reduction across a benchmark full of join-heavy queries. The interesting part is not that AI touched databases again. It's that a relatively small model appears useful on a narrow, measurable task that has real cost implications in production.

Ternary models get denser storage

Another efficiency story comes from model serving. A new paper argues that ternary language models, where weights take one of three values, are often stored in a way that wastes space because it assumes the three values are evenly distributed. The authors found that zeros are much more common than expected and built a format around that fact. The payoff is denser storage and modest but real speed gains during inference on both CPUs and GPUs. It's a good reminder that model efficiency is not only about training tricks or quantization levels. Sometimes the data layout itself is where the next improvement comes from.

.NET 11 stacks quiet speedups

On the runtime side, Microsoft published its annual performance deep dive for .NET 11, and the theme is accumulation. There is no single headline feature doing all the work. Instead, the gains come from lots of targeted improvements across the JIT, garbage collection, collections, networking, and parsing. In plain terms, the runtime is getting better at recognizing what code really does and turning more of it into fast direct paths. That may sound incremental, but these are the kinds of changes that quietly improve many applications at once, especially the boring but important backend services that live on hot paths all day.

Small engineering knowledge compounds productivity

That idea of compounding small wins also shows up in a more human piece about engineering productivity. The argument is simple: small tricks and little bits of knowledge often deliver outsized value. A shell shortcut, a better way to test a query, knowing which log to check first, or just knowing who to ask during an incident can save far more time than its size suggests. It's not a technical breakthrough, but it is a useful management and team lesson. Good engineering cultures do not only share big architectural decisions. They also circulate tiny practical habits that reduce friction every day.

AWS data loss sparks backup debate

Now to resilience, and this is probably the most unsettling item today. AWS says it cannot restore access to some customer data stored in Bahrain and the UAE after data centers there were hit earlier this year. That suggests some data may be permanently lost if it was kept only in those facilities. Alongside that, another widely shared piece makes the case that backups are far more complex than copying files somewhere else. Once you account for accidental deletion, corruption, ransomware, databases, permissions, offsite copies, and restore testing, the problem gets serious very quickly. Put together, these two stories make the same point from different angles: redundancy is not enough if recovery has not been designed and proven.

Why emergency oil lives underground

And finally, a neat engineering deep dive on the U.S. Strategic Petroleum Reserve. The reserve stores oil in huge underground salt caverns rather than in giant aboveground tanks, and the reason is a mix of cost, security, and practicality. Salt naturally seals well, the caverns can be enormous, and the sites sit close to Gulf Coast refining and pipeline infrastructure. That means the oil is protected, relatively cheap to store at scale, and can be moved quickly when markets are disrupted. It's a good example of infrastructure design that looks unusual until you understand the constraints, and then it starts to seem obvious.

That's the roundup for today. Thanks for listening to The Automated Daily, hacker news edition. I'm TrendTeller. Links to all stories can be found in the episode notes.

Rust lands inside CUDA kernels & AI learns PostgreSQL query planning - Hacker News (Sep 17, 2026)

Our Sponsors

Today's Hacker News Topics