OpenJev
OpenJev is a browser-only experiment that runs a small local model and compares direct choice-logit reads with token-by-token JSON generation. The demo keeps the weights in the browser, asks the same model to score a fixed set of options, and exposes the latency/quality tradeoff instead of pretending structured generation is free.
The 239-point HN thread liked the low-latency, low-cost decision-model angle but questioned whether the implementation is mainly prefill plus restricted-token scoring. Others found incorrect classifications and prompt-injection behavior in the demo, so treat it as an interesting technique preview rather than a validated Jev replacement.
Headline news
Optioanl text
Docker Sandbox Kit Spec: Packaging AI Agent Permissions as OCI Images
Docker’s Sandbox Kit proposal packages an agent, its tools, and its requested permissions in a standard OCI image, so teams can review and version the requests alongside the workload. The typed capabilities cover resources such as network hosts, credentials, and volumes; Docker says Kits can use ordinary image build, pull, signing, and scanning workflows, and that it is bringing the Apache-2.0 specification to CNCF governance.
The important limit: a Kit declares requested authority; it does not enforce it by itself. The host decides what to grant, and enforcement requires a conforming runtime. Docker Sandboxes is the first such runtime, according to Docker. InfoQ reports that the v3 spec also defines conformance suites and rules for combining workload images with mixins. InfoQ has no reader-comment section, so there are no source-site reactions to summarize.
5x faster Edge Functions: V8 isolates to Firecracker MicroVMs
Netlify says its Edge Functions now run in Unikraft-backed microVMs inside Netlify’s own edge network, replacing a separately hosted execution service. The company reports warm invocations falling from 25–40 ms to about 5–6 ms at p50, with p99 47.4% faster. That is an end-to-end platform comparison, not an apples-to-apples benchmark of V8 isolates against microVMs: commenters noted the old path crossed to an external provider, so moving execution in-house likely accounts for much of the gain.
The Hacker News discussion also contrasts the isolation boundary: V8 isolates share a process and kernel, while microVMs run separate kernels under a hypervisor. Commenters cautioned that these are different tools with different costs; one pointed to the snapshotting/randomness issue and another linked Firecracker’s handling of RNG state. The headline performance and availability figures remain Netlify-reported.
Orphaned VMs aim to keep guests running while the host kernel reboots
An experimental Linux RFC from Google explores keeping virtual machines executing through a host-kernel live update, rather than stopping guests for reboot or security maintenance.
The proposed “Orphaned VM” architecture preserves vCPU state and physical CPUs, then uses a KVM Caretaker Core to handle selected VM exits while the host operating system and VMM are offline. It builds on the Live Update Orchestrator and has been tested on Intel, AMD, and Arm, but the 46-patch series is explicitly very early and not production-ready. The hard parts are exactly the ones expected: timekeeping drift, stray interrupts, guest-to-guest IPI routing, and safely crossing the management gap.
Phoronix reports 13 forum comments, but its forum endpoint was unavailable during review, so I’m not inferring a reaction consensus.
The Async Multiprocessing Has Sound Foundations in Linux, But Further Testing Is Needed
Linux already has the core pieces for asymmetric multiprocessing (AMP), but maintainers need more reviewers, contributors, and repeatable hardware tests to keep them healthy.
Wolfram Sang’s survey follows his effort to upstream a hardware-spinlock driver. It explains how Linux combines remoteproc, RPMsg, mailboxes, shared memory, and SCMI to coordinate application CPUs with real-time cores—and why firmware-specific mailbox arrangements complicate the textbook diagrams. One practical bottleneck is that testing a driver can require modified firmware and U-Boot; OpenAMP’s examples also do not yet run uniformly across supported boards.
InfoQ has no reader-comment section for this article.
Cloudflare Uses an AI Harness to Probe and Harden Its WAF
Cloudflare used a controlled, feedback-driven harness to test whether AI models could find variations of attacks its WAF already blocked; human triage turned the results into three rule changes.
Across 45 scenarios, models generated 1,107 attempts. After filtering, 49 findings remained for review, 48 involving command injection or SSRF. The harness—not the models—constructed and replayed HTTP requests, enforced limits, and retained state; humans checked that each candidate was genuinely malicious, reached the intended target, and fell within the WAF’s responsibility. The article describes a useful security-testing pattern, not an autonomous vulnerability verdict.
InfoQ has no reader-comment section for this article.
Miscompilation with FFI bool return type on x86_64
Rust 1.99.0 can return an invalid non-0/1 value for an extern "C" function returning bool on x86_64 Linux. The Rust compiler team has marked the open report critical and linked an open fix; check the issue before relying on this ABI behavior.
The minimal reproducer returns 16 where C expects 0 or 1. The issue report attributes the missing mask to a change in emitted LLVM IR and says it reproduces with both GCC and Clang; the reporter also observed it on nightly. The four issue comments discuss the ABI’s required zero-extension and how prior compiler changes exposed the problem. The report says it reproduced on x86_64, not AArch64 or LoongArch.
Cloudflare Fixes Cross-Tenant Data Exposure in Containers
A storage-allocation setting—not the Firecracker VM boundary—allowed some Cloudflare Containers customers to read residual bytes from other tenants’ disks. Cloudflare says it fixed the issue and found no evidence of malicious exploitation.
With dm-thin’s 64 KiB blocks and skip_block_zeroing enabled, a 4 KiB write could allocate a block while leaving up to 60 KiB of prior contents untouched. Researchers recovered directory metadata, database pages, and complete SQLite databases across multiple placements. Exposure was opportunistic: an attacker could not select a victim or host, and the report found no cross-tenant writes or availability impact. Cloudflare disabled the setting, then drained hosts and retired existing disks and image caches so already-mapped blocks would be cleared too.
The article links practitioner reactions stressing that tenant isolation must include storage reuse and zeroing—not just the VM boundary. InfoQ has no reader-comment section.
Shipping JPEG XL in Chrome
Chrome is adding JPEG XL decoding in version 155, using a Rust implementation to make a heavily exposed image-decoding path memory-safe without giving up SIMD performance.
Google says JPEG XL offers better compression than JPEG, lossless transcoding, and HDR support; it recommends comparing it with AVIF for each use case. The notable systems work is jxl-rs, a pure-Rust decoder, and a SIMD abstraction that keeps unsafe code narrowly scoped while supporting optimized implementations across platforms. These are Chrome’s reported capabilities and performance claims.
The article was posted on Reddit with 186 points and 39 comments; its thread discusses the format’s trade-offs and the Rust decoder. HN also surfaced the announcement with 509 points and 344 comments.
Google’s “Painful To Maintain” Binder C Linux Driver Being Removed In Favor Of Rust
Android’s long-standing C Binder IPC driver is set to retire after its Rust rewrite was upstreamed in Linux 6.18. The change is a concrete, high-impact Rust-in-the-kernel transition: Binder is a central Android IPC path, and the old implementation is scheduled to disappear during the Linux 7.4 cycle rather than merely coexist indefinitely.
Phoronix reports a 20-comment thread; the accessible feed exposed the implementation and migration context but not detailed comment text.
Un-Mused: How a Single Debug Setting Bypassed macOS Security in Meta’s AI Client
A flaw in Muse’s macOS client let code already running as the logged-in user redirect the app’s dictation endpoint, exposing voice input and an authentication token that could be used to act through the assistant’s granted access. This was a local-code-execution-to-agent-privilege escalation path—not a remote attack that could compromise a Mac by itself—and using the voice path was required.
Meta issued a hotfix on September 22, within hours of the disclosure. The case still illustrates how an AI agent’s broad app permissions can amplify a weaker local compromise. InfoQ has no article comment section; Meta characterized the practical risk as low because local malicious code was required.
Deser: Rethinking Rust Serialization
Deser is an alternative Rust serialization design that trades Serde’s broad format model for lossless buffering, composable adapters, extensible values, and deserialization state kept on the heap rather than recursive calls on the stack.
The author walks through concrete Serde edge cases involving internally tagged enums, flattened integer-key maps, and adapters that do not compose. Deser aims to preserve format metadata and error locations, support pausable streaming, and avoid stack growth on deeply nested input. Those benefits come with real trade-offs: formats that aren’t self-describing, such as protobuf, are deliberately excluded; JSON performance is mixed and averages about 10% slower to read in the author’s measurements; and the implementation uses unsafe internally. The author presents it as an option for workloads where those trade-offs fit, not a likely ecosystem-wide Serde replacement.
The linked Lobsters thread showed no readable comments in the direct view, so source reactions were unavailable.
This test user is testing
THIS IS A TEST POST, please don’t follow this identity.
Good Stuff 64 - Vibe Coding and Woodwork
A podcast with me. :)
Everything you learned about SSL is deprecated - Todd Gardner - NDC Toronto 2026
Hey, that was very informative.
clice v1.0 Released: Welcome to Modern C++
Clice 1.0 is a new Clang-based C/C++ language server that isolates compilation in worker processes and supports C++20 modules with a persistent cache. The author says a worker crash leaves the rest of the server running, and describes explicit compilation contexts for headers and multiple build configurations.
The implementation itself uses C++ coroutines and modules. Its author calls the core features stable after months of alpha testing, while noting the substantial work needed to assemble the modern C++ toolchain.
HN readers discussed indexing performance and how much Clang-based tools must trade speed for accurate C++ analysis; one early user said earlier builds were promising but not stable enough for their needs.