Bilingual

Tor’s Arti 2.5.0 Released: Stable Counter Galois Onion
20 days ago
- Arti 2.5.0 released with Counter Galois Onion marked as a stable feature.
- Congestion Control is now enabled in default builds to increase speed.
- Includes fixes for two medium-severity DoS security issues.
- Ongoing development for using Arti as a relay and directory authority.
- Minimum supported Rust version increased to Rust 1.91.
- Contains bugfixes, cleanups, and improvements across the codebase.
From Julia to Rust: a differentiable tensor stack for scientific computing
20 days ago
- Transition from Julia to Rust for scientific computing due to Julia's runtime issues in large codebases.
- tenferro-rs is a Rust-native dense tensor stack supporting autodiff, einsum, FFT, and explicit CPU/CUDA backends.
- Rust's ownership and types enhance correctness at compile time, making it practical for AI-written code.
- Design separates operation families, autodiff rules, and backends into independent crates for extensibility.
- Supports both PyTorch-style eager autodiff and JAX-style traced transforms for dynamic shape computations.
- Correctness verified through finite-difference oracles, performance benchmarks, and design documentation.
Local Reasoning for Global Properties
20 days ago
- The author previously believed AI would not benefit from new programming languages, as AI can generate code in many existing languages.
- However, AI often generates good local code (e.g., functions) but struggles with global program understanding, leading to unnecessary defensive checks that can cause exponential state complexity.
- If AI's global reasoning weakness persists, programming language design may help by enforcing global properties through local reasoning, similar to Rust's data race prevention.
- Rust's ownership types and Send/Sync traits prevent data races statically, allowing local reasoning to ensure global data-race freedom without a new sublanguage.
- This demonstrates that programming languages can enforce surprising global properties (like data race freedom) with minimal burden on programmers.
- AI-generated code often includes excessive defensive checks, which are unnecessary, hurt performance, and mislead about program states, causing exponential state explosions.
- Future programming languages might incorporate features like effects systems to enforce more global properties, potentially benefiting AI code generation and human review.
- While not all global properties can be enforced, there is evidence that usable languages can provide more guarantees, changing incentives for language design in the AI era.
Curveball
16 days ago
- Curveball is a curve generator tool for Neverball, available as a web app or downloadable desktop app, written in Rust.
- It was created to generate complex curves not possible with the existing curve.c tool, which only produces circular arcs.
- Neverball levels consist of convex brushes defined by intersections of halfspaces, described using the Quake map format.
- Curveball uses the chull crate to compute convex hulls from points, simplifying brush generation from curve vertices.
- The key abstraction is extrusion: a 2D profile is copied along a path, with vertices processed via convex hull to form brushes.
- Orienting profiles along paths involves Frenet frames to handle rotation, with torsion considered to avoid issues.
- Curveball supports extrusion-based curves plus three special types: Curve Classic, Curve Slope, and Rayto, with some overlap in generation methods.
- The tool aims to streamline level creation for Neverball, allowing diverse curve shapes through profile and path combinations.
Astro 7.0
13 days ago
- Astro 7 release focuses on performance improvements, achieving 15-61% faster builds.
- Key upgrades include a Rust-based .astro compiler, Rust-powered Markdown/MDX pipeline via Sätteri, and a queue-based rendering engine.
- Integration with Vite 8 and its Rolldown bundler enhances build speeds, with no configuration changes for most projects.
- Advanced Routing introduced with src/fetch.ts for full control over Astro’s request pipeline, compatible with Hono middleware.
- Route caching is stabilized, with experimental CDN cache providers for Netlify, Vercel, and Cloudflare.
- AI enhancements include background dev server mode and JSON logging to support AI coding agents and structured logs.
- Benchmarks show significant build time reductions across various sites, with the largest gains on Markdown-heavy pages.
Satteri: A Markdown pipeline forged in Rust for the JavaScript world
13 days ago
- A Markdown pipeline built in Rust for use with JavaScript.
- Features flexible JavaScript plugins on a fast Rust Markdown/MDX engine.
- Combines the best of both worlds: speed and flexibility.
- Try it in the browser via WebAssembly (WASM) with live editing and rendering.
- Includes plugins, MDX support, and AST inspection in a full playground.
Rewriting Bun in Rust
12 days ago
- Bun has been rewritten from Zig to Rust using AI-powered coding agents, significantly reducing memory-related bugs.
- The rewrite was enabled by a comprehensive TypeScript test suite that served as a conformance benchmark for automated porting.
- Key engineering techniques included dynamic workflows, trial runs, adversarial review, and process-based fixes rather than manual code editing.
- Jarred Sumner praised Zig for Bun's initial development but chose Rust for its memory safety features like RAII and compiler checks for use-after-free errors.
- The rewrite took about 11 days of intensive AI-assisted work, with an estimated cost of $165,000 in API tokens, funded by Anthropic.
- The new Rust version has been live in Claude Code for nearly a month, improving startup speed by 10% on Linux with minimal user impact.
- The project demonstrates how advanced language models can enable ambitious, large-scale software rewrites previously considered infeasible.
Rust 1.97.0
11 days ago
- Rust 1.97.0 stable release announcement, including update instructions via rustup.
- Symbol mangling v0 enabled by default, replacing the legacy Itanium-based scheme.
- Cargo now supports denying warnings, improving CI workflows and cache efficiency.
- Linker output no longer hidden by default, revealing warnings for debugging.
- Stabilized APIs include methods for integers and NonZero types, and const context updates.
Cache-Conscious Data Layout in Rust: Field Zoning, False Sharing, 128-Byte Rule
14 days ago
- Focus on field zoning by grouping fields based on write ownership and access frequency to prevent false sharing in multi-threaded data structures.
- Use alignment and padding, such as 128-byte alignment instead of 64 bytes, to avoid adjacent-line prefetch issues and ensure hot fields are on separate cache lines.
- Employ #[repr(C)] to enforce field order and prevent compiler reordering that could undermine cache-conscious layout strategies.
- Avoid manual prefetch hints in stride-1 access patterns, as they can compete with hardware prefetchers and harm performance.
- Design ring buffer capacity deliberately to fit cache levels, considering working-set budgets and burst absorption, rather than using arbitrary round numbers.
Moving a Rust WebRTC SFU to thread-per-core: 70ms → 10ms P99.99 latency
10 days ago
- Migration of Rust WebRTC SFU from Tokio's work-stealing model to thread-per-core (TPC) architecture reduced P99.99 latency from 70ms to 10ms and increased capacity by 25%.
- TPC architecture eliminates unnecessary async channels, processing packets synchronously to avoid scheduling overhead and priority inversion, improving tail latency.
- Benchmarks show stable latency at high CPU loads, with TPC maintaining low jitter even at 80% CPU utilization, enhancing congestion control and stream quality.
PgDog (YC P25) Is Hiring a Founding Software Engineer
7 days ago
- PgDog is a startup focused on scaling PostgreSQL, used by many companies and currently hiring.
- The role involves working with Rust, Postgres, infrastructure, and distributed systems to build and ship features directly to customers.
- Ideal candidates are detail-oriented, test-driven, comfortable with production code, and balance AI use with independent thinking.
- Responsibilities include bug fixes, feature development, roadmap design, customer interaction, and recruitment.
- The work involves building a distributed database from scratch in Rust, with time split among bug fixes, new features, and infrastructure.
In Praise of Exhaustive Destructuring
8 days ago
- The author initially disliked Rust's requirement to list all fields or use '..' when destructuring structs, finding it less convenient than TypeScript or Haskell.
- They later realized that explicit struct destructuring (listing all fields without '..') enhances software safety by forcing updates when new fields are added.
- Adding a 'wind_speed' field to WeatherReading without updating a function that uses field access ('.' syntax) can lead to bugs without compiler warnings.
- Using struct destructuring in function parameters or within methods triggers a compile-time error if new fields are omitted, ensuring all fields are considered.
- This technique is particularly useful in multi-layered applications (like CRUD services) to ensure consistency when fields are added or changed.
- Observing frequently destructured field groups can indicate a need for refactoring into separate structs to improve design.
Show HN: OpenMarkdown – A Markdown editor you and your agent co-edit
5 days ago
- OpenMarkdown is a local-first, feather-light, and fast Markdown editor built for users and their agents.
- It uses a native Rust core, ensuring quick loading times and native performance.
- The editor is AI-free; instead, it runs on the user's existing agent, providing direct integration.
- Files are stored as plain .md files on the user's disk, avoiding databases and lock-in for persistence and portability.
- Agents can interact with files as a wiki, opening the correct file and navigating to specific spots upon user queries.
- Features include agent-assisted highlighting and reworking of selected text, saved directly to the disk.
- Vendor options with varying speeds and SSO support are available at different monthly prices.
- Keyboard shortcuts like Ctrl+G and Cmd+P enhance control, allowing prompt access and file navigation without menus.
- Three editing modes (live preview, plain source, clean reading) are cycled with one key, with visible, syntax-colored markers.
- The editor supports collaborative planning with agents, as shown in an example of drafting an auth revamp plan.
- It ensures file integrity by not reformatting text, provides safe defaults like moving deleted files to Trash, and avoids accounts or cloud telemetry.
- The UI is trilingual (Chinese, Japanese, English), with a CLI tool for terminal file opening, and standard Mac shortcuts are supported.
We're Building Postgres in Rust. Using the LLVM of Databases
4 days ago
- Turso is becoming the LLVM of databases, with SQLite as the first frontend and Postgres as the next.
- Turso is a modern rewrite of SQLite in Rust, featuring concurrent writes via MVCC, a rich type system, and self-updating materialized views.
- The project aims to build a Postgres-compatible database with a modern architecture, including embedded browser support and file-based operation.
- Turso uses a bytecode language (VDBE) and has demonstrated running Doom via this bytecode in a browser.
- The approach involves compiling Postgres SQL to Turso's bytecode, merging pgmicro into Turso as an official project.
- Turso is open-source with over 260 contributors, emphasizing reliability through rigorous testing methods.
- The FAQ addresses compatibility, server support, AI contributions, development pace, and extension handling via WASM.
Battery packs: Let's talk about crates, baby
4 days ago
- Battery packs are curated sets of crates around common themes to help developers choose high-quality crates without extensive research.
- Anyone can create a battery pack by publishing a crate named X-battery-pack with dependencies as recommendations.
- Battery packs include dependencies, features, templates, and structured categories (e.g., 'pick at most one' or 'pick any number').
- They aim to address challenges like crate selection for new Rust adopters and foster interoperability and maintenance funding.
- Risks include potential overcrowding of packs, but they are designed to evolve and avoid stagnation in the ecosystem.
Claude Code uses Bun written in Rust now
a day ago
- Jarred Sumner announced Claude Code v2.1.181+ uses Rust port of Bun, speeding up Linux startup by 10% with little user notice.
- Evidence found in Claude Code installation shows Bun v1.4.0 (macOS arm64), a version not yet released on GitHub as of the text's date.
- Rust version of Bun is available as a canary release, and 563 Rust source files in Claude indicate it's running in production.

Hasty Briefsbeta

#rust

Tor’s Arti 2.5.0 Released: Stable Counter Galois Onion

From Julia to Rust: a differentiable tensor stack for scientific computing

Local Reasoning for Global Properties

Curveball

Astro 7.0

Satteri: A Markdown pipeline forged in Rust for the JavaScript world

Rewriting Bun in Rust

Rust 1.97.0

Cache-Conscious Data Layout in Rust: Field Zoning, False Sharing, 128-Byte Rule

Moving a Rust WebRTC SFU to thread-per-core: 70ms → 10ms P99.99 latency

PgDog (YC P25) Is Hiring a Founding Software Engineer

In Praise of Exhaustive Destructuring

Show HN: OpenMarkdown – A Markdown editor you and your agent co-edit

We're Building Postgres in Rust. Using the LLVM of Databases

Battery packs: Let's talk about crates, baby

Claude Code uses Bun written in Rust now