Debian mandates reproducible builds for all packages ⭐️ 9.0/10

Debian announced that all packages in its next release must be reproducible, with over 97% of packages already meeting the requirement on amd64. This is a major milestone in software supply chain security, ensuring that binaries match source code and protecting against attacks that tamper with binaries. As of the announcement, 97.02% of packages on amd64 for the 'forky' release are reproducible, with statistics for other architectures available at reproduce.debian.net.

hackernews · robalni · May 10, 05:26 · Discussion

Background: Reproducible builds, also known as deterministic compilation, ensure that building the same source code produces identical binaries. This creates a verifiable chain of trust from source to binary, mitigating supply chain attacks where binaries might be compromised without source changes. Debian has been working on this effort for many years, and achieving near-total reproducibility is a significant technical accomplishment.

Discussion: The community celebrated the achievement, with tofflos providing exact statistics. uecker recalled that in 2007, the idea was dismissed as a waste of time, but now it is recognized as a huge achievement. Zopieux congratulated Debian for setting high standards in the current era.

Tags: #reproducible builds, #Debian, #software supply chain, #security, #open source

DeepSeek V4 Paper: FP4 QAT and Stability Tricks ⭐️ 9.0/10

DeepSeek released the full V4 paper detailing FP4 quantization aware training (QAT) for MoE models, achieving up to 90% FLOPs reduction and 93% KV cache reduction compared to V3.2, along with two training stability mechanisms: anticipatory routing and SwiGLU clamping. This breakthrough dramatically reduces inference costs for trillion-parameter MoE models, shifting the economics of large-scale AI deployment and making multi-agent workloads more feasible. The stability fixes address persistent training divergence issues that have hindered scaling. The FP4 QAT is applied to MoE expert weights and QK activations in the CSA indexer, achieving 2x speedup on QK selector with 99.7% recall. Anticipatory routing desyncs router updates (20% overhead, active only during spikes), and SwiGLU clamping limits activation values to ±10.

reddit · r/MachineLearning · Dramatic_Spirit_8436 · May 9, 08:10

Background: Quantization aware training (QAT) simulates low-precision arithmetic during training to adapt model weights, enabling efficient inference at reduced precision. Mixture-of-Experts (MoE) models use multiple specialized sub-networks per layer, but suffer from loss spikes and training instability at scale. FP4 is a 4-bit floating point format that balances range and precision. DeepSeek V3.2 served as the baseline for this work.

Discussion: Commenters praised the FP4 QAT as a 'game changer' for inference economics, particularly for multi-agent workloads, and noted the anticipatory routing as a clever engineering fix. They also highlighted the insane KV cache reductions for long-context serving.

Tags: #DeepSeek, #FP4 quantization, #MoE, #training stability, #efficiency

Bun's experimental Rust rewrite achieves 99.8% test compatibility ⭐️ 8.0/10

Bun, the JavaScript runtime originally built in Zig, has achieved 99.8% test compatibility on Linux x64 glibc with an experimental Rust rewrite, accomplished rapidly using LLM-assisted code porting. This milestone demonstrates the potential of LLMs to drastically accelerate large-scale software rewrites, and could influence the future of Bun's reliability and performance by moving from Zig to Rust, which is known for its memory safety. The rewrite is still experimental and a Bun developer noted that the code may be entirely discarded. The 99.8% test compatibility applies only to Linux x64 glibc, and the Rust version may still contain unsafe code that could affect safety guarantees.

hackernews · heldrida · May 9, 10:12 · Discussion

Background: Bun is a high-performance JavaScript runtime that bundles, transpiles, and runs JavaScript and TypeScript. glibc is the GNU C Library, providing essential runtime functions for Linux systems. LLM-assisted porting uses large language models to translate code between programming languages, which has gained attention for reducing manual effort.

Discussion: A Bun developer emphasized that the rewrite is experimental and may be thrown out, calling the community reaction an overreaction. Others were impressed by the speed (6 days) and the role of LLMs, while some expressed distrust in Bun's direction and noted that the Zig-based Bun has had memory bugs that Rust could help mitigate.

Tags: #Bun, #Rust, #JavaScript runtime, #software engineering, #LLM-assisted porting

Internet Archive Switzerland Launches Independent Digital Preservation Organization ⭐️ 8.0/10

Internet Archive Switzerland has launched as an independent organization, joining Internet Archive, Internet Archive Canada, and Internet Archive Europe to form a distributed network of mission-aligned digital libraries. This move decentralizes digital preservation, making it more resilient against legal threats like DMCA takedowns, and fosters global cooperation in safeguarding digital knowledge. The new organization is technically independent but shares directors like Brewster Kahle and Caslon; however, early reports note placeholder text on its website, suggesting it is still under development.

hackernews · hggh · May 9, 12:00 · Discussion

Background: A distributed library is a collection of digital materials available from multiple independent nodes, reducing reliance on a single point of failure. Decentralized digital preservation spreads content across organizations to protect against legal, political, or technical threats. Internet Archive Switzerland exemplifies this model, strengthening the global preservation infrastructure.

Discussion: Community comments suggest that Internet Archive should adopt a Usenet-like model where independent organizations peer and replicate content but lack technical capacity to forward DMCA takedown requests. Some commenters question the true independence of the Swiss branch, noting shared board members and infrastructure. Others observe placeholder content on the site, indicating it is a work in progress.

Tags: #digital preservation, #internet archive, #decentralization, #online censorship, #open access

Mathematician Tests ChatGPT 5.5 Pro Reasoning ⭐️ 8.0/10

Field medalist Tim Gowers recounts his experience with ChatGPT 5.5 Pro, noting significantly improved reasoning capabilities compared to previous models. If LLMs can reliably solve 'gentle problems' for beginning researchers, it could shift how PhD students are trained and what constitutes original research in mathematics. Gowers observed that ChatGPT 5.5 Pro still makes many mistakes but can trace its own reasoning and correct itself better than other models; however, the cost per token is high.

hackernews · alternator · May 9, 02:41 · Discussion

Background: ChatGPT 5.5 Pro is an advanced large language model developed by OpenAI. It is designed to improve reasoning and problem-solving, particularly in technical domains like mathematics. This version is not yet widely available and is more expensive than previous iterations.

Discussion: Commenters generally agree with Gowers' assessment, noting the model's improved self-correction but high cost. One physics professor shared that Gemini also helps catch errors but makes conceptual mistakes. Another commenter highlighted philosophical implications about idea value and automation.

Tags: #AI, #LLM, #ChatGPT, #research impact

FreeBSD execve() Local Privilege Escalation Vulnerability ⭐️ 8.0/10

FreeBSD released a security advisory (SA-26:13.exec) addressing a local privilege escalation vulnerability in the execve() system call, with a CVSS score of 8.0. This vulnerability allows a local attacker to gain root privileges, posing a serious risk to FreeBSD systems, and highlights the critical role of code correctness in operating system kernels. The vulnerability is caused by an operator precedence error in the execve() implementation, where missing parentheses lead to an incorrect calculation, allowing memory corruption. It has been patched in FreeBSD 15.0R-p7 and 14.2R-p13.

hackernews · Deeg9rie9usi · May 9, 20:31 · Discussion

Background: The execve() system call is used to execute a new program, replacing the current process image. It is fundamental to process creation in Unix-like operating systems. A local privilege escalation vulnerability in such a core function can allow an unprivileged user to execute arbitrary code with kernel privileges.

Discussion: The community noted the operator precedence mistake as a common pitfall, with one commenter suggesting banning mixed-operator expressions. Researchers from Calif published a detailed walkthrough and an AI-generated exploit, and other users highlighted that the issue was patched on April 28th.

Tags: #FreeBSD, #security, #privilege escalation, #CVE, #vulnerability

Let-go: Clojure-like language in Go, boots in 7ms ⭐️ 8.0/10

Let-go, a Clojure-like language written in pure Go, has been released with a cold boot time of ~7ms and ~90% compatibility with JVM Clojure. It includes an nREPL server and can be embedded in Go programs. This is significant because it boots 50x faster than JVM Clojure and 3x faster than Babashka, making it ideal for command-line tools and scripting where fast startup is crucial. It also enables Clojure-like syntax for systems programming and embedded applications. Let-go ships as a ~10MB static binary with a custom compiler and stack VM, supports AOT compilation, and provides seamless interop with Go functions, structs, and channels. However, it does not load JARs or provide full Java API compatibility, so existing Clojure projects may need modifications to run.

hackernews · marcingas · May 9, 17:52 · Discussion

Background: Clojure is a Lisp dialect that traditionally runs on the JVM, which can have slow startup times due to JVM initialization. Babashka uses GraalVM native-image to achieve fast startup for Clojure scripting. Let-go takes a different approach by implementing a Clojure-like language from scratch in Go, avoiding the JVM entirely. nREPL is a networked REPL protocol used by Clojure development tools like Calva and CIDER.

Discussion: Comments are generally positive, with users praising the fast startup and small binary size. Some discuss alternative projects like Joker and Janet, and one user noticed a minor inconsistency in the README (7ms vs 6ms). There is also mention of collaboration with the Glojure/Gloat ecosystem.

Tags: #Clojure, #Go, #programming language, #performance, #nREPL

Using HTML Output from Claude for Richer Explanations ⭐️ 8.0/10

Thariq Shihipar, a member of the Claude Code team at Anthropic, advocates for using HTML instead of Markdown as the output format from Claude, enabling richer and more structured results with SVG diagrams, interactive widgets, and in-page navigation. This approach challenges the long-standing default of Markdown for LLM output, potentially improving clarity and interactivity of explanations, which benefits developers reviewing code, understanding exploits, or learning complex concepts. Historically, Markdown's token efficiency was preferred due to context window limits, but modern models like GPT-5.5 and Claude can handle HTML's verbosity for richer output; examples include generating HTML artifacts for PR reviews and security exploit explanations.

rss · Simon Willison · May 8, 21:00

Background: Claude Code is an AI-powered tool by Anthropic used for software development and content marketing, built on the Claude large language model which uses constitutional AI for alignment. Markdown has been a common output format for LLMs due to its simplicity and token efficiency, but HTML offers more formatting options for complex information.

Tags: #prompt engineering, #llm, #html, #markdown, #anthropic

NVIDIA's Star Elastic Checkpoint Enables Dynamic Model Scaling ⭐️ 8.0/10

NVIDIA has released Star Elastic, a single checkpoint that nests 30B, 23B, and 12B reasoning models, extractable via zero-shot slicing without additional training. This approach enables dynamic compute scaling for LLMs, reducing storage and memory overhead by sharing a single checkpoint across model sizes, and allows flexible trade-offs between inference speed and accuracy. The Star Elastic checkpoint supports BF16, FP8, and NVFP4 formats, and uses a shared KV cache across submodels to avoid recomputation; for NVFP4, a short Quantization-Aware Distillation phase recovers 97.79% of BF16 accuracy.

reddit · r/LocalLLaMA · phazei · May 10, 00:48

Background: Traditional LLM deployment requires separate checkpoints for different model sizes, increasing storage and memory costs. Star Elastic introduces a nested architecture where smaller submodels are embedded within a larger parent model, and a learnable router selects the appropriate submodel for inference. This is analogous to scalable video coding, where a single file contains multiple quality layers.

Discussion: Community comments express confusion about the benefits of nested submodels versus traditional MoE, with some noting that the results are not groundbreaking compared to models like Qwen. However, interest is high in the shared KV cache feature, which could reduce VRAM overhead for dynamic scaling. Overall, the approach is seen as clever but with limited immediate practical advantage over existing techniques.

Tags: #NVIDIA, #LLM, #efficient inference, #model compression, #MoE

BeeLlama.cpp: 2-3x Faster Qwen 27B on 3090 with DFlash & TurboQuant ⭐️ 8.0/10

A new llama.cpp fork called BeeLlama.cpp has been released, featuring DFlash speculative decoding and TurboQuant KV-cache compression, enabling a Qwen 3.6 27B Q5 model with 200k context to run on a single RTX 3090 at 2-3x the speed of baseline llama.cpp, peaking at 135 tokens per second. This optimization significantly lowers the hardware barrier for running large language models locally, allowing high-quality 27B models with long context and vision capabilities on consumer GPUs. The community validation suggests these techniques could be upstreamed, benefiting the entire local LLM ecosystem. DFlash is a block diffusion-based speculative decoding method that accelerates inference by generating multiple draft tokens per step, while TurboQuant compresses the KV cache with near-lossless quality. The fork also includes adaptive draft control, reasoning-loop protection, and full multimodal support, with a plug-and-play setup for Qwen 3.6 27B.

reddit · r/LocalLLaMA · Anbeeld · May 9, 16:05

Background: llama.cpp is a popular C++ implementation for running quantized LLMs efficiently on consumer hardware. Speculative decoding uses a small draft model to generate candidate tokens, which are then verified by the larger target model, reducing latency. GGUF quantization reduces model size and memory usage, with Q5 offering a good balance of quality and performance. DFlash and TurboQuant are recent research techniques that further improve throughput and memory efficiency.

Discussion: Community comments are largely positive, with users reporting 200 tps on a 5090 and outperforming the mainline MTP PR. However, some express concern about the project's heavy use of AI in development and the sustainability of yet another fork, with one user calling it 'layers of slop.' Others hope the optimizations will be merged into mainline llama.cpp.

Tags: #llama.cpp, #inference optimization, #quantization, #speculative decoding, #local LLM

80 tok/s and 128K context on 12GB VRAM with Qwen3.6 35B A3B ⭐️ 8.0/10

A Reddit user shared a configuration achieving over 80 tokens per second and 128K context length on a 12GB VRAM GPU (RTX 4070 Super) using the Qwen3.6 35B A3B Mixture-of-Experts model with llama.cpp's Multi-Token Prediction (MTP) speculative decoding. This demonstrates that large language models with 35B total parameters (3B active) can run efficiently on consumer-grade GPUs with only 12GB VRAM, making advanced AI capabilities more accessible to individual users and researchers. The use of speculative decoding significantly boosts throughput without requiring additional hardware. The configuration uses a GGUF quantized model (Q4_K_XL) and specific llama.cpp command-line flags such as --no-mmap, --mlock, and --spec-type mtp with --spec-draft-n-max 2. The system runs on CachyOS with an AMD Ryzen 7 9700X and 48GB RAM, and achieves a draft acceptance rate over 80%.

reddit · r/LocalLLaMA · janvitos · May 9, 11:57

Background: Qwen3.6-35B-A3B is a Mixture-of-Experts (MoE) model with 35 billion total parameters but only 3 billion active per token, making it efficient for inference. llama.cpp is a popular open-source C++ library for running LLMs locally, and it supports speculative decoding via Multi-Token Prediction (MTP), where a draft model predicts multiple tokens ahead that are then verified by the main model, speeding up generation.

Discussion: Community comments were positive and engaged. Users shared additional benchmarks, e.g., one user achieved 13.6 t/s at 125K context on an 8GB GTX 1070 using a Q2 quantized version. Others expressed interest in reproducing results on different hardware like AMD GPUs or RTX 3080 Ti, and noted the importance of specific flags like -fitt for long-context workflows.

Tags: #LLM inference, #llama.cpp, #Qwen, #speculative decoding, #GPU optimization