Breaking Up with Google Play: Why Conversations Is Now Free

After more than a decade selling the open-source Conversations XMPP client on Google Play, its maintainer is making it free and shifting F-Droid to the primary distribution channel. He says grants now provide enough runway to leave Play Store revenue behind; F-Droid’s APK is reproducibly built and signed with his own key.

The stated trigger is not simply the 15% store cut: the author says he could accept that fee for useful service, but repeated unexplained removals, a 14-day review delay, and no effective way to reach a human made the relationship untenable. He also warns that slow reviews can delay security updates.

HN commenters split over the trade-off. Some backed leaving the gatekeeper and praised the open distribution model; others argued app stores provide discovery, payments, and safety checks, and noted that Play income helped sustain the project for years. Several agreed that poor developer support is the sharper complaint than the fee itself.

• Hacker News discussion

Agents Refactor 300K Lines in Three Weeks, and Practitioners Ask What It Proves

CodeScene reports that coding agents refactored a 300,000-line C codebase in three weeks, using a replay-trace harness to check behavior after each change and a code-health score as an optimization signal.

The case study is an open-source decompilation of Street Fighter III: 3rd Strike, not a production commercial codebase. CodeScene reports 2,903 commits, roughly $4,000 in model tokens, and an improvement in its own Code Health metric from 5.6 to 10.0. The agents also built a 22-recipe, codebase-specific refactoring playbook. These are vendor-reported results, not an independent replication; the proprietary quality metric and the unusual test setup limit what the headline alone proves.

InfoQ reports both enthusiasm for the frame-by-frame replay check and practitioner questions about whether the work was merged and how broadly it generalizes. InfoQ has no article comment section.

ESP32-S3 cluster running a 1.58-bit (BitNet) language model

This project splits a small language model across seven ESP32-S3 boards, passing intermediate activations along a daisy-chained SPI link. The master handles tokenization, embeddings, and sampling; six nodes each run part of the transformer layers. It is an unusually concrete embedded/distributed-AI experiment, with firmware, model preparation tools, and wiring instructions in the repository.

Treat the repository’s model-size and architecture description as a project report, not an independently benchmarked result: it does not yet provide inference speed or quality measurements. In the HN discussion, readers were intrigued by the build but questioned whether distributing inference over many microcontrollers can overcome communication and memory-bandwidth costs.

• Hacker News discussion

Qt Bridge for Rust 0.3 Beta: CXX-Qt Compatibility and Soundness

Qt’s Rust bridge 0.3 beta focuses on making the FFI boundary safer and bringing the project closer to CXX-Qt. It now uses CXX-Qt’s core types, with the aim of letting both bridges coexist in one application; the update removes APIs the team could not make sound and reworks how Rust and QML object lifetimes are coordinated.

It remains an early beta, not a stable UI stack: the public API still uses Rc<RefCell<_>>, and the move to CXX-Qt increased compile times. The r/rust discussion around the bridge welcomed an official Qt path but raised runtime-borrow, licensing/relinking, and integration questions; one user reported positive experience while noting a missing QQuickImageProvider path.

• r/rust discussion

Reverse-engineering the vintage Intel 8087’s tangent algorithm: more than CORDIC

Intel’s 8087 floating-point coprocessor combined CORDIC with a rational approximation to compute tangent quickly and accurately using the hardware available in 1980. Ken Shirriff reconstructs the FPTAN path from the chip’s die and microcode: the design uses shifts and adds for most of the work, then returns a numerator and denominator rather than spending cycles on division.

The post also explains a useful design trade-off: 16 CORDIC iterations provide most of the precision, while a Padé approximation handles the small residual angle. Lobsters readers praised the reverse-engineering and connected it to software x87 transcendental implementations; one commenter cautioned that x87’s practical accuracy limits matter more than the algorithm alone.

• Lobsters discussion

Automatic Transmission: a data-privacy study of connected vehicles

A Northeastern/Consumer Reports study tested 21 U.S.-market vehicles and 30 companion apps. Researchers observed 19 vehicles contacting third parties over Wi-Fi; seven apps sent sensitive identifiers such as VINs, email addresses, phone numbers, or precise location to third parties associated with advertising and tracking. Pairing an app increased tracker exposure in the study. Vehicle traffic was encrypted, so researchers could see destinations but not packet contents; the app tests used instrumented iPhones to inspect traffic. These are measurements of this sample, not proof of what recipients later did with the data.

The authors say the research is peer reviewed and will appear at IMC ’26. In the 177-comment HN discussion, drivers described difficulty opting out or disabling telemetry, while others argued that physically disconnecting a modem may be possible on some models. Commenters also emphasized that the study cannot establish downstream sale or use of observed data, and some criticized the presentation of the project site.

• Research study and paper
• Hacker News discussion
• Northeastern’s coverage

hashify v0.3: compile-time perfect hashing, now 4 to 12 times faster than phf

The Rust hashify procedural macro now chooses among a decision tree, a small seeded table, and a minimal perfect hash based on key-set size. Its generated lookups avoid runtime allocation and unsafe; the author reports 4–13× faster lookups than phf in the tested cases, with the biggest gains on larger keyword sets.

The design is specialized for keys known at compile time: the macro searches for seeds that fit the particular set, and large tables can add noticeable compile time. Reddit commenters also noted the benchmark measures throughput with independent probes, not dependent lookup latency; the author says a direct comparison against the standalone PtrHash implementation remains unmeasured. The discussion includes useful details on how range analysis removes bounds checks and why short keys use compact comparisons.

• Source discussion and comments

Kev: small, self-hostable Jev-like decision models

Kev packages open-weight Qwen-based models for fast decision tasks: yes/no, multiple choice, and ratings, with calibrated probabilities and model sizes from 0.8B to 27B. The repo includes training code and lets users fine-tune for their own labeled examples.

The authors’ benchmark table shows strong results on some held-out datasets, but these are project-reported evaluations—not independent validation. HN commenters liked the prospect of a local, low-latency classifier for routing and agent-control tasks; others questioned how well the models generalize and whether a general decision model beats a purpose-built classifier or a full LLM.

• Hacker News discussion

Linux is exploring BPF-loaded MIPI-DSI panel drivers

A proposal would let userspace load small eBPF programs containing initialization sequences for MIPI-DSI display panels, so OEMs could support panel substitutions without waiting years for a kernel update. The author says it already works with Raspberry Pi’s 5-inch and 7-inch Touch Display 2 panels. This is proposed work, not an upstream capability yet; userspace must load the program, so it cannot help in early boot.

Phoronix’s forum discussion was not available in the page extract, and its forums have returned HTTP 403 during this review; reactions could not be verified.

• Patch-series discussion

Introducing Clef: our open-source decision models, and new RL fine-tuning platform

Cloudflare has released Clef and Clef-Flash, vision-language decision models that return typed classifications with probabilities, alongside a reinforcement-learning fine-tuning service. The models target routing and other bounded decisions where an application needs structured output rather than open-ended text. Cloudflare reports that Clef leads its Jev Decision Index and shares an internal domain-classification latency comparison; those are vendor-reported results, not independent evaluations.

A terminology caveat: the models’ weights are Apache-licensed and downloadable, but that does not make the training data and process fully reproducible. HN commenters debated how novel the approach is relative to existing classifiers and structured-output LLMs. Early comparisons in the thread also raised questions about price and latency, while others welcomed locally runnable, image-capable alternatives.

• Hacker News discussion
• Cloudflare’s benchmark

ZuckOff | Camera glasses detector

ZuckOff scans nearby Bluetooth broadcasts for manufacturer signatures associated with camera glasses, then alerts and logs devices it detects. Its site says scanning stays on-device, with no account or server-side analytics.

That signal has real limits: some glasses may stop advertising after pairing, and a Bluetooth match neither proves that someone is recording nor rules out other cameras. HN commenters also questioned trusting a closed-source app for a privacy-sensitive job and pointed to the existing open-source Nearby Glasses alternative.

• Hacker News discussion

Linux 7.4 is set to gain a steal-time governor for virtual CPUs

IBM’s proposed scheduler work tracks time a virtual CPU spends waiting for host CPU resources, then steers tasks away from contended CPUs and backs off vCPUs to reduce costly preemption. The patch series reports gains on POWER workloads, including up to 44% on Hackbench, but also warns that pure CPU-bound workloads may regress. The v14 patches are queued for Linux 7.4; the figures are developer benchmarks, not broad independent testing.

Phoronix had no readable comments in its article extract; the linked kernel mailing-list discussion is the primary review thread.

• Kernel patch series and discussion

Qualcomm Continues Doing More For Their Open-Source Linux Graphics Drivers

Qualcomm is pushing more of its Adreno graphics support upstream across the Linux kernel and Mesa, including early work for Snapdragon X2 and updates to its Freedreno and Turnip drivers.

At XDC 2026, Rob Clark described recent enablement across Qualcomm platforms, display improvements in the MSM DRM driver, and the Adreno 800 support already in good shape. The report also notes Rusticl’s OpenCL 3.1 support and default enablement, alongside future work on GPU firmware scheduling, OpenCL shared virtual memory, and compute support for the Adreno 850’s MALU matrix core. These are ongoing upstream efforts, not a claim that all Snapdragon X2 laptop support is ready today; Qualcomm is aiming for more Linux support in 2027.

The Phoronix forum page returned HTTP 403, so I couldn’t verify reader reactions.

• Source comments

AX – Google’s Open Agentic Orchestrator

AX is an open-source control plane for running agent tasks in isolated, stateful sandboxes. Its declarative primitives cover tasks, workspaces, network policy, and model configuration; it builds on Agent Substrate for pausing and resuming workloads.

The project’s appeal is also its operational cost: the quickstart expects Kubernetes, a container registry, and an Agent Substrate API, so it is infrastructure for orchestrating fleets—not a lightweight local-agent wrapper. The site’s scale claims are project claims, not independent benchmarks. HN commenters debated whether that machinery solves a real deployment problem and how much to infer about Google’s long-term backing.

• Hacker News discussion
• GitHub repository

Rewriting an entire UI in Rust

A Git client author replaced a Tauri/React UI with Iced after running into IPC latency, Linux packaging friction, image flicker, and Windows rendering quirks. The rewrite improved the author’s frame-time test from roughly 9–10 ms to 3–6 ms and made a single-file Linux build practical—but the UI grew from 24K to 45K lines, and the 15 MB binary barely changed. These are one developer’s measurements, not a controlled comparison.

The Reddit discussion welcomed the detailed account but questioned Iced’s desktop UX maturity, accessibility, startup behavior, and binary size. The author also described custom work needed for Windows resizing and virtualized million-line diffs.

• r/rust discussion