Hasty Briefsbeta

All tags

rust

44 stories total

Bilingual

Claude Code uses Bun written in Rust now
2 months ago
- Jarred Sumner claimed Claude Code v2.1.181+ uses the Rust port of Bun, resulting in 10% faster startup on Linux.
- Evidence from strings command shows Bun v1.4.0 (a preview version) and 563 .rs source files embedded in Claude Code.
- The Rust version of Bun is now available as a canary release via `bun upgrade --canary`.
- A simple script can confirm the embedded Bun version by running `BUN_OPTIONS="--preload=/tmp/bun-version.ts" claude --version`.
- The commit updating Bun's version to 1.4.0 was made on May 17th, but hasn't been tagged in a stable release.
Memory Safety Absolutists
2 months ago
- The article discusses the claim that Rust is unsafe due to its 'unsafe' keyword, despite its drastically lower memory safety vulnerability density (0.2 per MLOC) compared to C/C++ (1000 per MLOC).
- Fil-C, a new technology, can make C/C++ code memory safe by using GC and InvisiCaps, but it has trade-offs like ABI incompatibility, potential slowdowns, and reliance on garbage collection.
- The author criticizes memory safety absolutists, especially Fil-C's creator and Zig's developer, who dismiss Rust as unsafe while promoting Fil-C, ignoring practical trade-offs and Rust's proven safety in real-world projects.
- A pragmatic approach is advocated: using Rust for programs that cannot adopt Fil-C (e.g., due to GC or ABI issues), and encouraging Fil-C for projects where its trade-offs are acceptable, rather than forcing a single solution.
- The author argues that memory safety absolutism should apply consistently, criticizing C/C++ and non-Fil Zig as much as Rust, and that preventing most issues in most programs is better than demanding perfection.
- Even with Fil-C turning vulnerabilities into crashes, the high crash rate from C/C++ code (1000 per MLOC) highlights that Rust's balance of safety and practicality is valuable for many use cases.
Implementing SEH in Rust and why you shouldn't do it
2 months ago
- SEH is Windows' exception handling model; x64/ARM64 use a table-based version.
- SEH is needed in Rust for safely accessing usermode memory in drivers and for continuable exceptions.
- Implementing SEH via LLVM is not feasible because Rust lacks inline LLVM support.
- Assembly approach using gas macros and __C_specific_handler works but requires careful label range management.
- Rust inline assembly can replicate SEH, but resource cleanup (Drop) is not automatically called on SEH exceptions.
- C++ with /EHa properly destructs objects during SEH; Rust's lack of this leads to resource leaks.
- Best practice: implement SEH wrappers in C++ with /EHa and call them from Rust.
Writing a Debugger from Scratch
2 months ago
- The author writes a debugger in Rust to learn the language and help others understand debugger internals.
- A debugger uses an event loop: attaches to a process, waits for debug events, and continues execution.
- On Windows, attach via DebugActiveProcess or CreateProcessW with DEBUG_ONLY_THIS_PROCESS flag.
- The event loop calls WaitForDebugEventEx to receive events and ContinueDebugEvent to resume the target.
- Debug events include CreateProcess, LoadDll, CreateThread, Exception, etc., each carrying specific data.
- The initial exception is the breakpoint from ntdll!LdrpDoDebuggerBreak triggered at process startup.
- Future posts will cover handling exceptions, breakpoints, stepping, and other advanced features.
On Strings in Rust
2 months ago
- Rust strings involve two main types: `str` (string slice) and `String` (owned string), both guaranteed to be UTF-8 encoded.
- `str` is a dynamically sized type (DST) behind a wide pointer, while `String` wraps a `Vec<u8>` and supports heap allocation and mutation.
- Deref coercion and dot operator semantics allow methods like `chars()` on `String` by automatically dereferencing to `str`.
- The `len()` method returns byte count, not character count, due to UTF-8 variable-length encoding.
- Operator overloading (e.g., `+` for concatenation) and trait implementations like `PartialEq` enable ergonomic string operations.
- In-place methods like `make_ascii_uppercase()` work on `&mut str` but cannot handle non-ASCII characters that change byte length.
- Other string types include `OsString`/`OsStr`, `CString`/`CStr`, and experimental `ByteString`/`Char` for specific use cases.
Extending Polars with Rust Expression Plugins
2 months ago
- fenic is a semantic DataFrame library using Polars as its core execution engine for AI/LLM pipelines over unstructured data.
- Standard Polars lacks needed text operations (chunking, prompt templating, jq, fuzzy matching, markdown/transcript parsing, rich type casts).
- Python UDFs are too slow, break composition, and have poor type handling for these operations.
- The solution was building nine Rust expression plugins via pyo3-polars, making them native Polars expressions.
- Plugins run in-engine over Arrow buffers, are vectorized, composable, and have declared output types.
- Output type declaration is critical and can be static, derived from input fields, or from keyword arguments.
- The elementwise flag enables parallelism and streaming; broadcasting is handled via Polars helpers.
- Zero-copy Arrow access is achieved through a custom ArrowToValue trait with recursion for nested types.
- Plugins return pl.Expr, allowing composition with native Polars operations in a single expression tree.
- The build uses maturin with a single Rust crate; plugins also export plain Python functions for validation.
Kittine, a custom language for Rust-powered web apps
2 months ago
- Kittine is a language layered on top of Rust and Leptos with far less syntax, compiling to real Rust components.
- It targets Leptos 0.7 and supports both CSR via Vite and SSR via cargo-leptos from the same source.
- No virtual DOM or virtual JS runtime; uses fine-grained reactive updates that directly update DOM nodes.
- Every language construct is compiler-verified, with real compilation tested against Leptos 0.7.
- Supports structs (litter), enums (breed), pattern matching (pounce), and traits (claw) with generic type parameters.
- Ecosystem includes a compiler, Vite plugin, SSR support, VS Code extension, formatter/linter, and package manager.
- Roadmap features a docs site, interactive playground, RSS/sitemap, and real download stats after public release.
- Installation requires building the compiler from source, then installing dependencies and running the dev server.
Meta Garbage Collection: Using OCaml's GC to GC Rust
2 months ago
- Soteria Rust, a symbolic execution tool, experienced quadratic slowdown due to its Tree Borrows aliasing model when handling loops.
- The fix leverages OCaml's garbage collector to automatically remove unreachable tree nodes, using weak references and periodic major collections.
- This change achieved linear execution time and up to 10x speedup on benchmarks, with only about 40 lines of code.
- The approach highlights the benefit of deeply integrating with the host language (OCaml) for complex memory management tasks.
Claude Code uses Bun written in Rust now
2 months 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.
Battery packs: Let's talk about crates, baby
2 months 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.
We're Building Postgres in Rust. Using the LLVM of Databases
2 months 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.
Show HN: OpenMarkdown – A Markdown editor you and your agent co-edit
2 months 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.
In Praise of Exhaustive Destructuring
2 months 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.
PgDog (YC P25) Is Hiring a Founding Software Engineer
2 months 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.
Moving a Rust WebRTC SFU to thread-per-core: 70ms → 10ms P99.99 latency
2 months 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.
Cache-Conscious Data Layout in Rust: Field Zoning, False Sharing, 128-Byte Rule
2 months 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.
Rust 1.97.0
2 months 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.
Rewriting Bun in Rust
2 months 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.
Satteri: A Markdown pipeline forged in Rust for the JavaScript world
2 months 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.
Astro 7.0
2 months 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.

first prev1next

rust

Claude Code uses Bun written in Rust now

Memory Safety Absolutists

Implementing SEH in Rust and why you shouldn't do it

Writing a Debugger from Scratch

On Strings in Rust

Extending Polars with Rust Expression Plugins

Kittine, a custom language for Rust-powered web apps

Meta Garbage Collection: Using OCaml's GC to GC Rust

Claude Code uses Bun written in Rust now

Battery packs: Let's talk about crates, baby

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

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

In Praise of Exhaustive Destructuring

PgDog (YC P25) Is Hiring a Founding Software Engineer

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

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

Rust 1.97.0

Rewriting Bun in Rust

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

Astro 7.0