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

Please support this podcast by checking out our sponsors: - Consensus: AI for Research. Get a free month - https://get.consensus.app/automated_daily - Effortless AI design for presentations, websites, and more with Gamma - https://try.gamma.app/tad - SurveyMonkey, Using AI to surface insights faster and reduce manual analysis time - https://get.surveymonkey.com/tad Support The Automated Daily directly: Buy me a coffee: https://buymeacoffee.com/theautomateddaily Today's topics: Rust lands inside CUDA kernels - NVIDIA is pushing Rust deeper into CUDA with native GPU kernel support through cuda-oxide and cutile-rs. It matters for GPU programming, memory safety, PTX, and safer high-performance compute without leaving the CUDA ecosystem. AI learns PostgreSQL query planning - A 4B open-weights model was trained to generate better PostgreSQL query plans and cut latency on join-heavy benchmarks. The story highlights reinforcement learning, SQL optimization, database performance, and practical AI for infrastructure. Ternary models get denser storage - Researchers showed that ternary LLMs can be stored more efficiently by exploiting how often weights are zero. The result touches model compression, inference throughput, CPUs, GPUs, and lower-cost LLM serving. .NET 11 stacks quiet speedups - Microsoft says .NET 11 gets faster through many small wins across the JIT, garbage collection, networking, and core libraries. The bigger takeaway is runtime performance, LINQ efficiency, and cumulative gains for real applications. Small engineering knowledge compounds productivity - One essay argues that tiny coding habits and bits of team knowledge can deliver outsized engineering gains. It is a useful reminder about developer productivity, debugging, incident response, and knowledge sharing. AWS data loss sparks backup debate - AWS says some customer data in Bahrain and the UAE cannot be recovered after this year's attacks, raising hard questions about resilience. Paired with a separate backup essay, the story underscores disaster recovery, offsite copies, restore testing, and cloud risk. Why emergency oil lives underground - A deep dive into the U.S. Strategic Petroleum Reserve explains why massive salt caverns are used instead of tanks. It is a strong example of infrastructure engineering, energy security, storage economics, and resilient design. - NVIDIA Introduces Two Rust Paths for CUDA GPU Kernels - Training a 4B Model to Beat Postgres Query Plans - Why Small Programming Tricks Matter - MIMO-v2.6 RL Runs Hit Infrastructure Issues but Continue Training - AWS Says Some Middle East Data May Be Lost After Iran Strikes - Performance Improvements in .NET 11 - Why Backups Are Far More Complex Than They Seem - How the U.S. Strategic Petroleum Reserve Stores Oil Underground - BITCOS Beats Standard Packing for Ternary LLMs Episode Transcript 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