Rust news and developer summaries

Bun has successfully migrated parts of its codebase to Rust. This transition improves memory safety, fixes existing leaks, reduces binary size, and maintains performance parity. The core architecture remains identical, with further optimizations planned before the official release. Users can test the improvements immediately via the Bun canary channel.

Mullvad uses a deterministic algorithm to assign exit IPs based on a user's WireGuard key. Due to how Rust's random number generation handles bounds, users are assigned IPs with a consistent percentile across servers. This allows for correlation attacks that can deanonymize users by linking different exit IPs to the same account with over 99% accuracy.

The Bun project is undergoing a massive rewrite from C++ to Rust, achieving 99.8% test suite compatibility on Linux. This 960,000 LOC migration aims to improve memory safety, stability, and maintainability by leveraging Rust’s borrow checker and destructors, effectively reducing manual debugging for crashes and memory leaks.

The yt-dlp project has announced the deprecation and limitation of Bun support due to security concerns and instability. Support is now restricted to Bun versions 1.2.11 through 1.3.14. The maintainers cited potential supply chain vulnerabilities in older versions and concerns regarding the project's transition from Zig to Rust.

This guide compares Go and Rust for backend development, focusing on correctness and reliability. While Go offers simplicity and fast compilation, Rust provides superior safety through its borrow checker, strong type system, and memory management. Although Rust has a steeper learning curve, it is ideal for high-stakes, performance-sensitive services that require rigorous runtime guarantees.

A developer successfully built a personal computing environment, swapping off-the-shelf tools for custom-made Rust and assembly programs. By leveraging AI-assisted development, they achieved deep customization, replacing even a long-used text editor. This project demonstrates that building bespoke software for a single user is now highly feasible and rewarding, eliminating the overhead of general-purpose design constraints.

Async Rust struggles with binary bloat, especially on embedded systems, due to complex state machine generation. Proposed optimizations include removing panic states in futures, omitting state machines for functions without await points, future inlining, and collapsing duplicate states. Implementing these in the compiler could significantly reduce binary size and improve performance across various architectures.

The Rust code encounters Undefined Behavior due to the creation of a dangling reference when using core::slice::from_raw_parts on a memory location after the owning Box has been dropped. This highlight the necessity of strict adherence to Rust's memory safety rules regarding ownership and pointer provenance when performing unsafe operations.

cuda-oxide is an experimental Rust-to-CUDA compiler enabling developers to write high-performance GPU kernels directly in idiomatic Rust. By utilizing a custom rustc codegen backend, it compiles to PTX without proprietary DSLs or foreign bindings, leveraging Rust's ownership and safety models for GPU programming while supporting async workflows.

The author optimized a Finnish dictionary, Taskusanakirja, by replacing a large SQLite database with a Finite State Transducer (FST) implemented in Rust. This transition achieved a 300x reduction in memory, compressing 40-60 million inflected word forms into just 10 MB, enabling highly efficient, portable prefix searching for agglutinative languages.

The author successfully jailbroke a 7th gen Kindle Paperwhite and implemented a Rust-based UI using the Slint framework. By cross-compiling for ARMv7 using cargo-zigbuild, and bridging Slint to the Kindle's framebuffer and touch driver via memory-mapped files and ioctl, they developed a custom backend, enabling interactive applications on the e-ink device.

A graduate student modified their graduation cap by installing WS2812B LEDs, a reed switch, and a Digispark ATtiny85 running custom Rust code. The project, triggered by tassel movement, involved complex hardware integration and manual configuration of embedded Rust crates. Despite the effort, the creator admits the final result is intended more for demonstration than actual wear.

rlisp is an experimental project that provides a LISP-like s-expression frontend for Rust. It compiles code into standard Rust while maintaining core language semantics like ownership, lifetimes, and safety. The implementation features a simplified macro system and native structural editing support without requiring complex proc-macros, offering a homogeneous syntax experience on top of the rustc compiler.

A developer has transitioned to full-time work on their open-source project, mise, and associated tools through a new company, en.dev. Facing the challenges of maintaining successful projects, they are seeking financial sustainability via individual memberships, corporate sponsorships, and consulting services to ensure the long-term growth and maintenance of their software ecosystem.

RaTeX is a Rust-based LaTeX math layout engine that provides consistent, high-quality rendering across native apps, servers, and WebAssembly. By avoiding heavy WebView dependencies and JavaScript, it offers predictable performance. It supports chemistry and unit formatting similar to KaTeX, maintaining identical output for mobile, desktop, and web environments through a shared Rust core.

A software patch by Mike Hommey addresses a crash issue on Intel Raptor Lake CPUs within the zlib-rs deflate source code. This update, tracked under Bug 1950764, implements a workaround to ensure stability for users on affected hardware.

RMUX is a high-performance, Rust-built terminal multiplexer designed for the agentic era. It offers tmux-compatible commands, a daemon-backed SDK, persistent sessions, and native Ratatui integration. Supporting Linux, macOS, and Windows, it enables developers to script, inspect, and orchestrate terminal-based workflows programmatically across different operating systems without requiring WSL.

bttf is a command-line tool written in Rust for datetime arithmetic, parsing, and formatting. It utilizes the Jiff library and ICU4X for localization. Unlike traditional date utilities, it offers advanced features like tag-based processing for arbitrary data, sequence generation, and complex time calculations, serving as both a practical utility and a testbed for the Jiff library.

Gyroflow is an advanced, cross-platform video stabilization application that uses precise motion data from gyroscopes, accelerometers, or external telemetry. It supports high-quality GPU processing, rolling shutter correction, and professional video editor plugins, offering a flexible, open-source solution for smoothing footage from action cameras, drones, and professional cinema cameras.

TRUST is an experimental, retro TUI IDE built for Rust development, modeled after classic blue-screen DOS programming environments. It allows users to edit files, navigate project structures, and execute Cargo commands like build and test. While functional, it remains a nostalgia project focused on providing a vintage aesthetic for modern Rust workflows.