Topic

Rust

Everything filed under Rust, newest first.

Showing 41–60 of 109 articles

  • Superoptimizing an FPU Emulator

    purplesyringa wanted a branch-free way to compute the lowest set bit of a float for a floating-point emulator library, and instead of hand-deriving it wrote a small superoptimizer that searched instruction sequences and found a surprisingly clever rewrite.

    Blog post · Compilers · Performance · Rust

    4 min · 974 words

  • Announcing Rust 1.99.1

    The Rust team released 1.99.1, a point release fixing regressions from 1.99.0. The post lists the notable fixes and points users at rustup update as the upgrade path.

    Changelog · Rust · Programming Languages · Open Source

    1 min · 321 words

  • rust-djinn: You Should Specify Your Code Unambiguously (and Prove That You Did)

    Simon Henniger introduces rust-djinn, arguing developers should write unambiguous specifications for their code and prove those specs hold—bridging documentation, types and verification so correctness claims are checkable rather than aspirational.

    Blog post · Rust · Programming · Software Engineering · Research

    13 min · 3,029 words

  • What agents mean for Rust (and vice versa)

    Niko Matsakis reflects on the rise of LLM coding agents from a language designer’s perspective: why Rust’s type system and safety guarantees suit agentic development, and what Rust and its tooling should change in response.

    Essay · Rust · AI Agents · Programming

    15 min · 3,336 words

  • Creusot 0.14.0

    The Creusot team announces version 0.14.0 of their formal verification tool for Rust, highlighting selected new features for contracts and proofs and pointing to the full changelog for the release.

    Changelog · Rust · Programming · Open Source · Developer Tools

    4 min · 983 words

  • Why 'externalized' proofs of cyclic trait impls does not work

    Niko Matsakis compares modular proofs, where an impl must establish its supertraits, with external proofs, where users of the impl carry that obligation, and argues that external proofs are incompatible with Rust as designed, so cyclic trait impls require a modular strategy.

    Blog post · Rust · Programming Languages

    7 min · 1,585 words

  • August in Servo: CSS Grid, text selection, and more!Plus accessibility and navigation improvements.

    The Servo project's monthly update covering Servo 0.6.0 and 417 commits landed in August: CSS Grid enabled by default, new web platform features and DOM APIs, text selection, accessibility, navigation and session-history fixes, a SpiderMonkey upgrade, embedding API changes and performance work.

    Changelog · Web Browsers · Rust · Open Source

    9 min · 2,143 words

  • Voxlocal: a minimal voice agent written in Rust

    Sam Khawase walks through building Voxlocal, a minimal local voice agent in Rust, explaining each stage of the pipeline from audio capture and Whisper speech recognition through text normalization, embeddings and retrieval, LLM tool routing and Piper speech synthesis, and measuring where the time goes.

    Tutorial · AI Agents · Rust · Speech Recognition

    13 min · 3,024 words

  • Vectorized CLZ and CTZ

    Purplesyringa shows how to compute count-leading-zeros and count-trailing-zeros with floating-point bit tricks instead of native instructions, yielding a vectorizable polyfill in Rust, and explains why the exponent manipulation works.

    Blog post · Performance · Rust · Low-level Programming

    4 min · 891 words

  • Rewriting Prime Agent in Rust

    Prime Intellect describes how Prime Agent orchestrated a swarm of over 2,000 agents across 10,000+ Prime Sandboxes and 200 billion tokens to rewrite itself from TypeScript to Rust in two weeks, covering why Rust, finite-state-machine orchestration, architecture redesign, and cold start, memory and install-size gains.

    Blog post · AI · AI Agents · Rust · Software Engineering

    9 min · 2,133 words

  • Bevy 0.20

    Thanks to 227 contributors, 817 pull requests, community reviewers, and our generous donors, we're happy to announce the Bevy 0.20 release on crates.io!

    Changelog · Open Source · Programming · Rust

    23 min · 5,381 words

  • C for Rust Programmers

    A guide to the C programming language written from the perspective of someone who learned Rust first. BD103 walks through the surprising and unexpected parts of C for Rust programmers, including booleans and headers, strings and pointer lengths, integer types like size_t, the arrow operator, and the memory safety pitfalls Rust usually prevents.

    Tutorial · Rust · Programming · Systems Programming

    9 min · 2,046 words

  • The Missing Piece in Rust Error Handling

    Rust already offers explicit control flow, errors as values and concise propagation with ?, but choosing what goes in the error half of Result forces a trade-off between precise types with boilerplate and convenient types that hide which errors can occur. The post argues error types should compose as easily as the functions that return them.

    Blog post · Rust · Programming

    7 min · 1,660 words

  • Burn 0.22.0: Faster Builds, Easier Extensions, and Smarter Autotuning

    Tracel's Burn 0.22 deep learning framework for Rust removes backend type parameters from user code, selecting execution through the device, which made rebuilds up to 15x faster in their tests. It also adds adaptive memory management, smarter autotuning, GPU graph replay, a reusable CubeCL Environment cache, LoRA and QLoRA fine-tuning, ONNX export and expanded remote compute.

    Changelog · Machine Learning · Rust · Open Source

    12 min · 2,837 words

  • tapo speaks TPAP: Third-Party Compatibility can stay off

    Mihai Dinculescu explains how v0.11.1 of tapo, his unofficial Rust and Python client for TP-Link Tapo devices, now logs in over TP-Link's TPAP protocol so users no longer need the Third-Party Compatibility switch, and covers new H200/H500 camera hub recording downloads plus plug schedules and timers.

    Blog post · Rust · Networking · Hardware · Open Source

    10 min · 2,290 words

  • mold 3.0.0

    mold 3.0.0 is the first release of the high-speed linker after its rewrite from C++ to Rust: a drop-in replacement for 2.42.1 with the same options, targets, and linking performance, bounds-checked reads on corrupted input, a Cargo-based build, and a long list of bug fixes and compatibility improvements across architectures.

    Changelog · Rust · Linkers · Open Source · Developer Tools

    5 min · 1,254 words

  • The Performance Cost of RwLock in Our Read-Heavy Workload

    A write-up of how per-item RwLock reads became expensive in a read-heavy service, how moving to lock-free structures avoided the overhead of acquiring thousands of read locks, and where a simple RwLock around a larger block still worked well. The takeaway: where and how often synchronization happens matters as much as the choice of primitive.

    Blog post · Rust · Performance · Programming

    6 min · 1,303 words

  • Property Testing with Agent Swarms

    Inanna Malick shows how to have coding agents build property-testing machinery (reference models, generators and assertions) for a repo, then turn the failures into small, reviewable fixes. Pointed at OpenAI's Codex, the public playbook found thirteen distinct correctness bugs, and runs on jj, uv, Prometheus and Babel produced merged upstream fixes.

    Tutorial · AI Agents · Testing · Rust · Open Source

    6 min · 1,325 words

  • Async Rust: Where does the scheduler live?

    Mond opens with an async Rust complaints bingo card and reading list, then argues that the real discomfort is that async Rust needs a runtime, while concurrency always requires a scheduler somewhere, and weighs Zig's approach of passing the I/O implementation as a parameter as a direction worth trying.

    Essay · Rust · Programming · Concurrency

    17 min · 3,872 words

  • TIL: Rust's derive often implies inline

    A short TIL noting that Rust’s derived trait impls commonly emit #[inline], with practical implications for Debug/Clone cost and when custom non-inlined derives can help.

    Blog post · Rust · Programming · Performance · Systems Programming

    3 min · 634 words