Rust stories from Lobsters

Mitchell Hashimoto, creator of HashiCorp tools and the Ghostty terminal, discusses his philosophy on software development. He emphasizes the value of understanding fundamentals over high-level abstractions, the importance of personal taste and vision in open-source projects, and his preference for Zig for systems programming, advocating for more holistic, user-driven software design.

The Roc language team successfully rewrote their 300,000-line Rust compiler into Zig, reaching feature parity. The transition was driven by a need for granular memory control, faster build times, and an architecture better suited to their specific language needs, such as polymorphic defunctionalization and lambda set specialization. This milestone enables advanced features like hot code loading and improved cross-compilation without sacrificing stability.

After a decade of instability, five unsuccessful stabilization attempts, and more than two years of personal work, the never type is finally stable in Rust nightly, pending release in a new nightly version. The announcement expresses relief and emptiness, and references the speaker’s “when is never” talk.

The author developed an open-source Little Snitch-inspired firewall for Linux using eBPF and Rust to improve privacy. The tool allows users to monitor and block outgoing network connections. While Linux proves more transparent than macOS, the project highlights persistent data telemetry in common apps and emphasizes user control over system dependencies.

The Zig Software Foundation reflects on its complex history with Bun, citing concerns over management practices, poor code quality, and technical debt. Ultimately, the Zig team celebrates Bun's rewrite into Rust, as it alleviates friction between project visions, distances Zig from criticized engineering habits, and clarifies community boundaries after the project's acquisition.

Bun has transitioned from a Zig-based runtime to Rust, leveraging AI-driven workflows with Anthropic’s Claude to complete the rewrite in just 11 days. The migration systematically addresses memory leaks and stability issues using Rust’s memory safety guarantees, resulting in improved performance, smaller binary sizes, and reduced memory usage while maintaining feature parity.

Firefox intends to ship JPEG XL using jxl-rs, a secure, performant Rust decoder developed by Google Research to replace a 100,000-line multithreaded C++ implementation. JPEG XL adds progressive rendering and excels at lossless compression, while AVIF generally produces smaller web-quality photos. Developers should benchmark both formats using representative images and target quality levels.

The Servo team has released v0.1.0 of the servo crate, enabling its use as a library. This milestone reflects increased confidence in the embedding API. The team also announced a new long-term support (LTS) version to assist embedders requiring stability, with regular security updates and migration support.

A developer successfully built a DIY galvanic hair electrolysis machine by designing custom circuit boards and firmware powered by an RP2040. The device automates current control to permanently remove hair follicles using controlled lye production. The project, emphasizing safety and precision, includes an ergonomic 3D-printed pen and an automated CI/CD pipeline for PCB fabrication.

A curious performance edge case exists within the Rust compiler regarding the .to_string() method on multiple nested string references. Investigation reveals that Rust implements a specialized macro, to_string_str!, which generates efficient implementations for strings and their references up to thirteen levels of depth. This macro explicitly defines implementations from str and &str up to &&&&&&&&&&&&str, allowing the compiler to use String::from(s) and memcpy for better performance. However, once the fourteenth level of reference is reached, the specialized implementation is no longer available, and the compiler falls back to the more expensive <str as core::fmt::Display>::fmt path. This behavior highlights how Rust uses macro-based specialization to optimize common patterns while maintaining hard-coded limits on complexity.

Cilly is a new Rust compiler backend that translates Rust code into C, enabling Rust development on obscure hardware or platforms that lack native LLVM or GCC support. By generating platform-specific C code through intelligent introspection, it bridges the gap for architectures like Plan9, offering a solution to the bootstrap paradox and expanding Rust's reach.

The author argues that supply-chain security in the Rust ecosystem is a shared responsibility rather than solely an issue for crates.io to solve. Despite limitations in automated sandboxing and detection, users should actively audit dependencies. Relying on community volunteers instead of corporate-funded infrastructure means users must exercise common sense and utilize available security tools like cargo-vet.