Compile-time payloads, text diffusion at 1500 TPS, and the C-to-Rust translation problem

00:00:04 The Rust crate arrayref got compromised today. It's a small library — just four macros for slicing arrays — with about 245 million all-time downloads sitting deep under tiny-skia, sctk-adwaita, and winit. Version 0.3.10 slipped in with a dependency on a typosquatted crate called proc-macro1.

00:00:25 The build script of proc-macro1 downloads a remote binary at compile time and runs it. The attacker took down the genuine droundy crates.io accounts first — both arrayref and append-only-vec were yanked or compromised — then published 0.3.10 with that dependency.

00:00:45 proc-macro1 itself is a renamed copy of the real proc-macro2 crate, so the library code works as a drop-in while the build script does something else entirely. It stores the server address as base64 fragments, reassembles them at compile time, downloads an architecture-specific binary over an unvalidated TLS connection, and drops it to /tmp/rust-setup on Unix or runs PowerShell and VBScript launchers on Windows.

00:01:16 Malicious versions have been pulled by the crates.io team. The GitHub repositories for the compromised droundy accounts are all 404ing now. What's interesting here is that this isn't dependency confusion or a confused deputy — it's an active account compromise with a build script payload hidden inside a crate whose source code looks perfectly fine.

00:01:42 Every time you compile something that pulls in arrayref 0.3.10, your compiler downloads and executes arbitrary code from a server at 23.254.165.112. It's a blind spot for most Rust developers, who've treated build scripts as inherently trustworthy — and usually were.

00:02:02 The crates.io team yanked the old clean releases too, which means anyone pointing at the latest version gets the bad one by default. This lands squarely in a pressure zone: the crate graph for GUI tooling on most Linux desktops.

00:02:19 Google's researchers just published a technical report on DiffusionGemma, an experimental text diffusion model that generates around 1500 output tokens per second on a single NVIDIA H100. That's measured as average throughput across GPQA-Diamond and LiveCodeBench.

00:02:37 The approach is different enough from autoregressive decoding to deserve a closer look. Instead of generating one token at a time, DiffusionGemma refines blocks of 256 tokens in parallel through bidirectional attention across a canvas. It starts from a 25.2-billion-parameter Gemma 4 mixture-of-experts model, activating 3.8 billion per step, and uses less than ten percent of the original AR model's training budget.

00:03:07 The two-stage training pipeline does supervised fine-tuning to teach bidirectional denoising, then combines reinforcement learning with sampler distillation to compress the number of forward passes needed for good output quality. The paper shows it achieves about twenty tokens per forward pass on average, which is a meaningful step above speculative decoding's rough draft-and-verify throughput.

00:03:35 It also retains multimodal inputs, long-context support, and thinking mode from its AR starting point. And notably, despite being trained as a diffusion model, it can still generate text autoregressively with only minor performance degradation — suggesting the weights don't have to abandon one regime to use another.

00:03:58 The memory bottleneck that limits per-request generation speed in AR models comes from transferring model weights and the key-value cache from VRAM to the accelerator between each token. Text diffusion shifts execution from a memory-bound regime toward a compute-bound one by predicting entire blocks simultaneously.

00:04:20 Heavier individual forward passes are the trade-off, but the reduction in total passes offsets that cost. The real question is whether this reaches production scale. Measurements were taken on single-H100 setups with a batch size of one — the exact latency regime where diffusion needs to prove it can beat autoregressive models using multi-token prediction.

00:04:45 Canonical is funding a three-year research project with the University of Bristol to make it practical to automatically translate large C codebases into safe Rust. The target repos are sometimes hundreds of thousands of lines of code. The approach is what they call hybrid neurosymbolic — combining machine learning with traditional program analysis, testing, and formal methods.

00:05:12 Large repositories get split into smaller parts that can be translated separately while preserving type information, dependencies, and behavioral invariants. Language models handle the pattern translation; formal methods check whether the output behaves like the original.

00:05:31 Canonical will use AppArmor and snap-confine as real-world case studies. They're clear these aren't immediate rewrite targets — the existing code isn't being replaced with research results. Instead, they're testbeds for validating the translation technology against mature C projects that have years of fixes and compatibility updates baked in.

00:05:55 Current source-to-source translators can handle a lot of code but tend to copy C structures too closely into Rust, producing code that still relies on unsafe features and keeps C-style patterns. LLMs face a different problem — they can create good idiomatic Rust for small, clear pieces of code, but managing the context of an entire repository is much harder.

00:06:20 Code that looks right may not always work the same way as the original C version. The public announcement here matters more than the immediate deliverable. The gap between 'LLMs can translate small C functions to idiomatic Rust' and 'LLMs can translate a 500K-line C codebase while preserving its behavior' is exactly the context window problem, and no amount of prompting closes that gap on a repo scale.

00:06:49 Combining LLMs with traditional analysis is one of the few visible attempts at solving it. uutils/coreutils and sudo-rs have already made their way into the Ubuntu distribution as part of Canonical's broader Rust push. This new research provides the infrastructure layer that ad-hoc efforts are still missing.

00:07:10 Tencent gray-tested its new flagship model Hunyuan Hy4 this morning. A user spotted it appearing in the Tencent Yuanbao App model selection list, labeled 'Expert-Level Model' and positioned above their own Hy3 and DeepSeek. The company confirmed in last week's Q2 earnings report that Hy4 would launch soon with enhanced multimodal capabilities and tool-use focus.

00:07:35 Tencent has been quietly building out a tiered model strategy rather than a single flagship — Hy3 for general-purpose work, Hy4 for expert-level tasks, and DeepSeek positioned alongside for reasoning. The gray test suggests the product is close to public release.

00:07:53 The broader signal here is continued Chinese investment in frontier models despite the global compute constraint. It's one thing to talk about hardware embargoes and export controls; it's another to keep spending on model training at this scale when the path to sufficient GPU capacity gets harder every quarter.

00:08:14 That covers the day — supply chain attacks moving into build scripts, text diffusion breaking the token-by-token bottleneck, and C-to-Rust translation getting a proper research budget. Seln Oriax.