Rust

The repository claims about 3.5x the speed of idiomatic C++ and 1.1x the best safe Rust on 16 of its own benchmarks. The README credits an AI model with compiler implementation, benchmarking and docs.

ClickBench's maintainer removed pgrust, a Rust reimplementation of Postgres, saying its entry measured "a lookup table of the benchmark, not a database." Probes with slightly altered queries were refused with errors.

pgrust's creator showed up in the thread to say the accusations are false. Commenters wanted to know why the paths were in the binary.

Cloudflare's experimental Rust port of the TypeScript compiler claims up to 8x speed and about 70% less memory than TypeScript 7.0, with the code written by frontier models in days.

A TypeScript team member says much of the speed is not language choice, and some of it is already landing in TypeScript 7.1.

Zig’s incremental path updates a debug binary in place instead of rebuilding every dependency after a small edit.

The discussion’s sharper point: semantic-analysis boundaries and language choices determine whether that shortcut stays tractable.

The source asks how the Bun rewrite is progressing; the thread answered with a more immediate story about AI doing narrowly scoped maintenance in the new codebase.

Some readers treated source-to-source rewriting as a familiar transformation. Others argued that passing integration tests is not enough evidence when an agent chose both the patch and its explanation.

The rewrite runs deep. The rendering engine is about 2.4x faster, and Astro moves to Vite 8 with the new Rolldown bundler, which the team clocks at 10-30x faster than Rollup. Several sites now build more than twice as fast as on v6.

But the thread caught the asterisks. Strict HTML compilation now errors on unclosed tags, which blocks upgrading any site that pulls in messy remote content. One developer reported builds that got slightly slower, not faster. And the engineer who wrote the new Rust compiler is in the thread, taking questions.

Each module is parsed by the ruff parser, lowered to one shared IR, and compiled to native code by Cranelift.

A reviewer of AI-written code saw 'clear signs of vibing' and bet full CPython compatibility won't land on any reasonable timeline.

The goal isn't the 46M-line artifact; it's the tool that produced it. The author's 'cilly' compiler probes the target C compiler with tiny witness programs instead of assuming anything beyond ANSI C, and can even compile over the network — so 'unsupported target' stops being a knock against Rust.

The thread found the genuinely useful uses. An ex-compiler developer gave a flat endorsement. Others pointed to easier Rust bootstrapping and a security trick: use crustc for Diverse Double-Compiling to check whether the official rustc has a backdoor. The skeptic's fair point: who trusts a beta transpiler on an exotic target?

Herdr gives each agent a real terminal, tracks its state without configuration, and exposes a Unix-socket API so agents can orchestrate their own workspaces. It detects Claude Code, Codex, Cursor, Copilot and 10+ others by process matching.

A high-karma user described replacing a dozen terminal windows of agents he could only inspect by VNC, now reachable from his phone over Tailscale. The recurring counter: 'Just use tmux no?'

LibrePods is a GPL-3.0 project that talks the proprietary AAP/AACP protocol AirPods use with Apple devices, bringing ear detection, listening-mode switching, battery status, renaming and conversational awareness to Linux and Android. Two core Rust files, aacp.rs and att.rs, were AI-translated from Kotlin.

The thread's correction: the earbuds already pair fine anywhere — this only restores Apple-exclusive extras. And one commenter said Android 17 already fixes the Bluetooth bugs that used to need root, so he'd rather fork it than pay the $5 ask.

Gossamer (v0.19.1) offers Result/Option, traits, typed channels on an M:N scheduler, no async coloring, no unsafe, no macros — memory via deterministic reference counting plus arena regions. It reads like a greatest-hits of modern language design.

The takedown was specific: dropping the last reference to a 10,000-node cyclic graph is a stall, so “pause-free” is marketing; and the compiler is written in Rust, which for a self-described systems language is the tell.

A solo dev fed the entire ~48GB Hacker News archive into a search index and built a date-histogram over 45 million posts and comments going back to 2007. Overlay any terms and the tech cycle plays out as a literal chart: lk-99's one-week spike, Stuxnet's lonely persistence, crypto handing the baton to chatgpt.

Then ClickHouse's lead developer dropped by to note he already hosts the same HN dataset as a public SQL database. And the sharpest voice warned it isn't Google Trends at all: it counts what people wrote, not what they searched.

The old parser interpreted an ANTLR grammar at runtime; the Rust rewrite is a recursive-descent parser with a Pratt expression core. It ran 70x faster on a laptop and 454x faster in production, with zero divergences across millions of shadow-mode queries.

The thread calls it the anti-vibe-coding playbook: an engineer who builds the same oracle setups says you can generate corpuses large enough to trust code you never read. A skeptic asks the question nobody answered: why not compile the grammar instead of fuzzing a code generator into agreement?

The coupling runs deep: crates.io usernames mirror GitHub usernames, the users table carries gh_login and gh_id columns, and team ownership maps onto GitHub teams. Decoupling means rebuilding auth while the registry stays live.

An RFC to unblock multi-provider login finally merged and implementation has started. But a Cargo maintainer notes the real bottleneck isn't code, it's that nobody is paid to do the boring work.

Its trick is content-addressed lazy mounts: instead of describing each commit, you describe a whole session, and agents skip the clone entirely. The author has been building non-Git VCS since before the agent hype made it fashionable. But the launch shipped a reward gadget and zero benchmarks against Git, and at least one Git lover quietly agrees the incumbent is vulnerable anyway.

The recurring diagnosis: the bloat is architectural, not algorithmic. Bundling Chromium to ship a chat app is the problem, not your choice of data structure.

Where optimization will actually happen, per a big-tech engineer in the thread: server-side, where RAM is a line item, and mostly by 'stop doing stupid stuff', not fancy algorithms.

The pitch reads like a benchmark dream: same warnings as pylint, same bugs reproduced on purpose, and black's 26.7-hour lint run finishing in 41 seconds. It was generated by Fable, an agentic coding system, with a human mostly steering.

The thread split fast. One side called it malware-SEO with an LLM-written README and asked if the project is even legit. The other side shrugged: if it passes pylint's own tests, who cares who typed it?

Today's GitHub Trending: iroh (Rust peer-to-peer networking that dials public keys, not IP addresses), Meshery (one control plane for Kubernetes and ten service meshes), NautilusTrader (a self-hosted trading engine — Rust core, Python cockpit), and Unciv (an ad-free open-source remake of Civ V).

The catalyst is at the top: iroh shipped its first stable 1.0 on June 15, after four years and 65 pre-releases, and a maintainer dropped into the Hacker News thread to field questions. Two of the five are Rust — and not one AI agent framework in sight.

The author's claim: if a Rust function isn't marked unsafe, it's impossible to use incorrectly in a memory sense, so a memory bug there is always a soundness hole. C and C++ shift that burden to the caller, so the same class of mistake never becomes a CVE.

The thread split hard. One camp: CVE counts are so useless they ignore anyone citing them. Another, channeling Stroustrup: most of these bugs are C-style C++, and modern C++ plus hardened libraries closes the gap.

Yserver is a from-scratch X11 server in Rust — not an Xorg fork. It implements 19 extensions (Composite, DRI3, GLX, RANDR) and deliberately drops multiple screens, non-TrueColor visuals, indirect GLX and the DDX driver ABI as 'legacy baggage'.

Two objections collide: practitioners who still need X11's network transparency and multi-monitor support that Wayland abandoned, and a chorus calling the project AI 'slop' that should disclose how much was machine-generated.

Embedded veterans call it a great list of what to avoid. Application programmers call it arbitrary hobbling — and one flags the manifesto's printf-over-streams advice as a memory-safety footgun, not a simplification.

The thread's truest line cuts past both camps: everyone agrees a clean subset of C++ exists, and no two engineers agree on which one. In 2026, the unspoken third option, Rust or Zig, hangs over the whole argument.

Apple's Security team rewrote the TrueType hinting interpreter — input-driven control flow over untrusted font data — from C to Swift for the Fall 2025 releases. Result: a 13% average speedup, pixel-identical output across 27 million glyphs, and the memory-safety bug class eliminated, with only a few audited unsafe statements left at the C boundary.

Systems programmers cheered the safety-plus-speed result, but one Swift user warned the lifetime features shown off in the post crashed the compiler on trivial programs just months ago.

Production users showed up to confirm the compiler itself has quietly been working for a year — useMemo and useCallback deleted, performance up.

The sharpest critique: why freeze the Babel AST as the contract instead of going native with Oxc? The maintainers answered — Oxc isn't the only consumer.

You change only your connection string, not your app. The open-source version has 1.4M Docker pulls; the round is from Basis Set, YC and Pioneer Fund.

Simon Willison's request was the most telling product feedback: ship a plain binary, because he won't fire up Helm or Docker just to kick the tires.

Grit is 360,000+ lines built across multiple agent setups, burning ~45B tokens, passing 99.3% of Git's tests — though the author admits nobody has used it for anything real.

The flashpoint: Git is GPL, but Chacon released Grit under MIT, arguing the LLM-generated code is a new work. A GitHub co-founder, of all people, relicensing a copyleft project.

Others reject the premise outright: Git has never failed on a memory overflow, so why burn $10k to rewrite it?