The recent development of brush (Bo(u)rn(e) RUsty SHell), a POSIX- and bash-compatible shell implemented in Rust, has ignited a broader conversation within the developer community about the future direction of command-line shells. While brush itself represents another entry in the growing field of Rust-based system tools, the discussion it has sparked reveals deeper questions about balancing legacy compatibility with modern innovation.
The POSIX Compatibility Debate
One of the most prominent discussions emerging from the brush announcement centers on whether new shells should maintain POSIX compatibility or break free from these decades-old standards. Many developers are questioning if adherence to POSIX is still valuable in today's computing environment.
It's about time we move past Posix compliance for shells. Don't get me wrong, it was a fabulous thing back in the 1980s and 1990s with respect to the Unix wars. But in a twist of irony Linux won the Unix wars, and these days Posix compliance, with respect to shells, mostly holds back innovation or modernization by pegging the concept of a terminal to something from 1988.
This sentiment resonated with several commenters who pointed to Fish shell's decision to forgo POSIX compatibility in favor of a more ergonomic design. Fish, which recently underwent its own transition to Rust, has been praised for prioritizing user experience over strict adherence to legacy standards. The conversation highlights a growing divide between those who value backward compatibility and those who believe shell technology needs a more radical evolution.
Two Paths Forward: Supersets vs. Clean Breaks
The community discussion revealed two primary approaches to shell evolution. The first approach involves creating supersets of POSIX standards, as seen with Bash, Zsh, and the Oils project (with its OSH and YSH components). These shells maintain backward compatibility while adding modern features. The second approach, exemplified by Fish and PowerShell, involves making clean breaks from POSIX to enable more fundamental redesigns.
Many developers noted that these approaches aren't mutually exclusive. A common workflow mentioned by several commenters involves using a more modern, non-POSIX-compliant shell like Fish for interactive use while maintaining POSIX-compatible shells for scripting purposes. This hybrid approach allows developers to enjoy improved ergonomics during daily use without sacrificing compatibility for scripts that may need to run on various systems.
Structured Data: The Next Shell Frontier
A recurring theme in the discussions was the value of structured data handling in modern shells. Several commenters highlighted Nushell and PowerShell as examples of shells that move beyond text-based input/output to provide richer data manipulation capabilities.
Proponents of structured data in shells emphasized that having typed, structured data offers significant advantages for complex data manipulation tasks. The ability to work directly with JSON, CSV, and other formats without constant text parsing was described as an insane superpower by one enthusiast. Others pointed to the Oils project's YSH component as another approach to incorporating structured data handling while maintaining a migration path from traditional bash.
Shell Approaches Compared
| Shell | Implementation | POSIX Compatible | Structured Data | Notes |
|---|---|---|---|---|
| brush | Rust | Yes | No | New project, aims for bash compatibility |
| OSH/YSH (Oils) | Python → C++ | Yes | Yes (in YSH) | Focuses on migration path from bash |
| Fish | Rust (recently) | No | Limited | Prioritizes user experience |
| Nushell | Rust | No | Yes | Built around structured data |
| PowerShell | .NET | No | Yes | Record-based approach |
Performance and Size Considerations
Some technical concerns were raised about the implications of implementing system tools in Rust. One commenter noted the significant size difference between the traditional bash binary (1.1MB) and the brush implementation (6.9MB). Without shared libraries, this represents a considerable increase in resource requirements that could be problematic for embedded systems or other resource-constrained environments.
This observation connects to broader discussions about the tradeoffs involved in rewriting system tools in memory-safe languages like Rust. While such implementations offer improved security and often eliminate entire classes of bugs, they may come with performance or resource costs that need to be carefully weighed.
The emergence of brush and similar projects reflects the ongoing evolution of command-line interfaces in modern computing. While the shell might seem like a solved problem to casual users, these discussions reveal a vibrant ecosystem of innovation and competing philosophies about how we should interact with our computers at the command line. Whether through gradual evolution of POSIX-compatible shells or revolutionary new designs, the humble command line continues to adapt to the changing needs of developers and system administrators.
Reference: brush