Bilingual

Zig: All Package Management Functionality Moved from Compiler to Build System
20 days ago
- Package management functionality moved from compiler to build system, improving modularity and allowing patching without compiler rebuild.
- SPIR-V backend progressed with new @SpirvType builtin, execution mode via calling convention, and multi-threaded codegen.
- New @bitCast semantics defined by logical bit layout, making behavior endian-agnostic and enabling new operations like integer to vector conversion.
- ELF linker improvements enable fast incremental compilation and linking with external libraries, though DWARF debug info support is pending.
- Build system reworked to separate configurer and maker processes, significantly speeding up build times and improving caching.
- Incremental compilation now works with LLVM backend, speeding up error feedback during development.
- Type resolution redesign made compiler lazier, improved dependency loop error messages, and enhanced incremental compilation.
- io_uring and Grand Central Dispatch std.Io implementations landed, allowing easy swapping of I/O implementations.
- Package management enhancements: dependencies stored locally in zig-pkg directory and --fork flag added for easy dependency forking.
- Windows standard library now prefers native ntdll APIs over kernel32 to avoid unnecessary overhead and improve reliability.
- zig libc project replaces C source files with Zig wrappers, reducing redundancy and improving optimization.
My Thoughts on the Bun Rust Rewrite
15 days ago
- Jarred initially had 'beginner energy' which was healthy for learning but led to mediocre engineering outcomes.
- After Bun took venture capital and became a startup, Jarred's management style caused issues: poor communication, unrealistic expectations, and low empathy.
- The Zig team found Bun's codebase problematic with hacks, abuse of assertions, and reckless feature development, leading to social distance.
- The relationship between Zig and Bun deteriorated, culminating in relief when Bun was acquired by Anthropic and stopped donations.
- The Rust rewrite announcement was welcomed by the Zig team to distance themselves from Bun's engineering practices.
- The blog post about the rewrite is criticized for misrepresenting bug elimination, test suite effectiveness, and performance improvements.
- Zig's compiler performance is highlighted as efficient compared to Bun's unmentioned compilation speed post-rewrite.
- Despite criticisms, there is gratitude for Bun's donations to Zig and no personal ill will towards Jarred, but happiness that business interests are no longer intertwined.
How Our Rust-to-Zig Rewrite Is Going
8 days ago
- The Roc compiler team has rewritten 300,000 lines of Rust code into Zig, recently achieving feature parity with the original compiler.
- Key new features in the Zig-based compiler include hot code loading during development, cross-compiled binaries, and type-safe string interpolation in pattern matching with zero heap allocations.
- The rewrite was motivated by architectural challenges, especially in implementing polymorphic defunctionalization, which required a scratch rewrite rather than incremental changes.
- Zig was chosen over Rust due to faster build times, better memory control with granular allocators, ecosystem relevance for compiler needs, and more assistance with memory-unsafe code.
- Memory safety comparison shows fewer memory corruption bug reports in the Zig compiler (10) vs. Rust (21), though most were miscompilations, not compiler itself issues.
- Build times are significantly faster with Zig's incremental builds (35ms) compared to Rust's (3.4s), despite a current stable release bug delaying full benefits.
- The compiler uses zero-parse deserialization for caching, leveraging array-based data structures for I/O-bound performance, enabled by Zig's memory control.
- Zig's ecosystem, including its compiler code, provided reusable components like an LLVM bitcode serializer, aligning with Roc's unusual needs.
- Missing aspects from Rust include automatic allocation in tests, private struct fields, and better dead code detection, but Zig offers benefits like control over data layouts and error handling.
- Next steps include releasing Roc version 0.1.0 later this year, with ongoing work on documentation and bug fixes, supported by the nonprofit Roc Programming Language Foundation.
Buz – A fork of Bun using modern Zig, with sub-1s incremental builds
7 hours ago
- Buz is a work-in-progress fork of Bun, based on the last commit before its Rust rewrite, and is not ready for production.
- The project has been ported to build with the current upstream Zig, with a complete build graph in build.zig, enabling sub-1s incremental builds.
- The goal is to be a drop-in replacement for Bun with a cleaner codebase, having imported all new tests from Rust Bun and removed over 11,000 lines of dead code.
- The codebase has been rewritten and modernized, relying more on Zig's stdlib, fixing countless bugs in the process.
- The project uses a slightly patched Zig master submodule but can be built with upstream Zig at commit 2b1c663.
- Human-coded contributions are not accepted until the project is deemed sane enough, with LLMs used extensively for code generation to reduce technical debt.
- The author aims to create a maintainable drop-in replacement for Rust Bun 1.4.0 within weeks or months, focusing on idiomatic Zig and reducing slop code.

Hasty Briefsbeta

#zig

Zig: All Package Management Functionality Moved from Compiler to Build System

My Thoughts on the Bun Rust Rewrite

How Our Rust-to-Zig Rewrite Is Going

Buz – A fork of Bun using modern Zig, with sub-1s incremental builds