Bilingual

Zig: Package Management Moved from Compiler to Build System
23 days ago
- Package management functionality moved from compiler to build system for flexibility and safety improvements.
- SPIR-V backend progress includes new builtins, execution modes, multi-threaded codegen, and object file linking.
- Redefined @bitCast semantics to use logical bit layout, improving cross-platform consistency.
- ELF linker improvements enable incremental compilation with external libraries, including LLVM and LLD.
- Build system rework separates configurer and maker processes, speeding up builds and enabling cached configurations.
- Package management workflow enhancements include local zig-pkg directory and --fork flag for dependency overrides.
- Windows std.Io bypasses kernel32.dll for direct ntdll calls, improving performance and reliability.
- Zig libc project replaces C source files with Zig wrappers, reducing code and enabling optimizations.
- New std.Io.Evented implementations (io_uring and GCD) enable experimental async I/O with fiber-based coroutines.
- Type resolution redesign improves laziness, dependency loop error messages, and incremental compilation performance.
Zig: All Package Management Functionality Moved from Compiler to Build System
21 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.
History of T
14 days ago
- T was a highly influential Lisp implementation known for its clean design and optimization.
- Developed at Yale in the early 1980s by Jonathan Rees, T was an optimizing native-code Scheme system, a radical choice at the time.
- T introduced innovative implementation techniques like efficient data representations, a depth-first garbage collector, and fine-grain interrupt handling.
- The compiler, Orbit, used CPS (continuation-passing style) as an intermediate representation and was among the most optimizing Scheme compilers for years.
- T's development led to multiple PhD dissertations and influenced later languages and compilers, including SML/NJ and Scheme 48.
- The language design featured a clean object system with integrated assignment machinery and a consistent naming scheme.
- T's legacy includes contributions to functional programming, compiler technology, and garbage collection research.
How Our Rust-to-Zig Rewrite Is Going
10 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.
56,000 lines of DOOM, in a language I made up
9 days ago
- bet is a small, real programming language designed as a contained experiment.
- It compiles to native code via LLVM, self-hosts, manages memory, and can run DOOM.
- The language uses arena allocation (called cribs) for efficient memory management in games.
- DOOM was fully ported to bet with over 56,000 lines, achieving bit-for-bit identical gameplay.
- The project was built with no prior research and gated solely by tests, without code review.
- It served as a joke, an experiment, and a learning experience, with no plans for further development.

compiler

Zig: Package Management Moved from Compiler to Build System

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

History of T

How Our Rust-to-Zig Rewrite Is Going

56,000 lines of DOOM, in a language I made up