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 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.

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 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.

Steve Klabnik discusses his transition from butcher families to open source, his work on Rust and Jujutsu, and his philosophy on community management. He emphasizes building positive narratives, managing personal vs. public identity, and current experiments with Rue and AI-assisted programming, suggesting that well-structured codebases benefit both human developers and agents.

A developer successfully optimized the Gleam language's pretty printer by replacing heap-allocated Box structures with an arena-based memory allocation strategy using the typed_arena crate. This refactoring reduced formatting time by 24% and peak memory usage by 10%, demonstrating the performance benefits of minimizing heap allocations in Rust.

The author examines the limitations of current Static Site Generators (SSGs), such as Astro and Hugo, focusing on build speeds and incrementality. To achieve sub-100ms rebuilds, they propose a custom Rust-based core for performance and a Javascript interpreter for flexible logic, utilizing a Red-Green incremental algorithm to minimize redundant computations during content or code changes.

The author reflects on transitioning from Zig to Rust and back to Zig. While Rust offers stability and memory safety, concerns over its corporate-influenced governance and controversial policies regarding LLMs drove the author toward Zig’s philosophy of simplicity, performance, and craftsmanship, even acknowledging Zig's ongoing instability and manual memory management.