The Roc programming language team has announced plans to rewrite their compiler from Rust to Zig, sparking significant discussion in the developer community about language choices for system-level programming. This decision comes as the team prepares for Roc's first numbered release, version 0.1.0.
Compile Time Concerns Drive Change
At the heart of this transition lies a critical pain point that resonates strongly with the developer community: compilation speed. The community's response highlights how slow compile times can significantly impact developer productivity and satisfaction. As one developer noted in the discussions:
I use rust a lot but, Roc is right: compilation times are not proportional to the safety you gain. At least in my project.
Beyond Speed: Technical Considerations
The community discussion reveals that while compile times are a major factor, the decision encompasses broader technical considerations. Developers point out that Zig offers several advantages for compiler development, including better handling of static linking, more intuitive bit-level operations, and simplified memory management through explicit allocator passing. The community particularly emphasizes Zig's pragmatic approach to systems programming, positioning it as a middle ground between C's minimalism and Rust's complexity.
Key Motivations for Zig Migration:
- Faster compilation times
- Better static linking support
- More intuitive bit-level operations
- Simpler memory management model
- Direct LLVM bitcode generation
- MultiArrayList support for struct-of-arrays programming
Language Evolution Context
An interesting perspective emerging from the community discussion is how the landscape of systems programming languages has evolved. While Rust was a natural choice when the Roc compiler was first written in 2019, Zig has matured significantly since then. Developers note that this reflects a broader trend in the industry, where newer projects are increasingly considering Zig for systems programming tasks that would have defaulted to Rust just a few years ago.
Planned Compiler Changes:
- Parser rewrite to recursive descent
- New formatter with line width enforcement
- Revised name resolution system
- Enhanced documentation generation
- Updated monomorphization without Morphic
- New LLVM bitcode-based code generation
- Development backend switch to interpreter
Parser Implementation Debate
A technical point of contention in the community centers around the team's decision to move from parser combinators to recursive descent parsing. While some developers argue that parser combinators are essentially recursive descent with additional features, others support the move, citing better error handling capabilities in hand-written parsers.
The rewrite represents a significant shift in the systems programming landscape, where practical considerations like compilation speed and development ergonomics are increasingly challenging the dominance of memory safety as the primary decision factor for language choice.
Technical Notes:
- Parser combinators: A functional programming technique for building parsers by combining smaller parsing functions
- Recursive descent: A top-down parsing technique where each non-terminal in the grammar has its own parsing function
- Static linking: A process where libraries are built into the final executable, making it more portable across systems
Reference: Rewriting a Language's Compiler in Itself