Bilingual

Unboxed: Zig
15 hours ago
- Zig's package manager is integrated into the compiler, uses build.zig.zon for dependency declarations with content-addressed hashes, and no central registry.
- Dependencies are pinned by exact content hash, ensuring reproducibility but requiring manual updates for transitive fixes.
- The build system is Turing-complete (build.zig), allowing arbitrary code execution at build time, which fails the Tuesday test.
- Governance is minimal: the Zig Software Foundation manages the tool but not package hosting, leaving namespace and availability to source hosts like GitHub.
- The tool's own supply chain has zero external dependencies, with networking code shipped as source for easier patching.
- Unique features include a self-generated fingerprint for package identity independent of URL, and a --fork flag for transient override without manifest changes.
256 Lines or Less: Test Case Minimization
16 hours ago
- A simple Property-Based Testing (PBT) library is implemented in just 256 lines of Zig, using a Finite Random Number Generator (FRNG) that pre-generates all random numbers and can run out of entropy.
- The FRNG provides built-in functions for generating bytes, arrays, integers, booleans, bounded integers, and slice indices, with compile-time polymorphism for flexibility.
- The library is used for simulation testing by feeding random inputs to a system under test, crashing on any inconsistency, and the finite entropy allows for automatic test case minimization via binary search to find the smallest failing input.
- The test harness spawns a separate process for the system under test, passes entropy via stdin, and uses a seed+size approach to reproduce runs.
- The search algorithm doubles the step size to find a failure, then halves to minimize the entropy size, outputting the minimal failing seed and size for debugging.
Minimal Viable Zig Error Contexts
16 hours ago
- Zig uses strongly-typed error codes for minimal error handling, leaving error reporting to the user via Diagnostics sink pattern.
- For script-like code, a middle-ground approach logs error context as key=value pairs using errdefer, reducing friction by avoiding explicit error messages and preserving try statements.
- The drawback is that error context is logged even when errors are handled, especially problematic for cancellation errors in Zig 0.16 that are meant to be handled gracefully.
Zig Tokenizer
16 hours ago
- Tokenization converts a stream of bytes into a stream of tokens, without handling semantics.
- Zig's tokenizer is part of the standard library, operates on a slice of bytes, produces one token at a time, and performs no allocations.
- The tokenizer stores the buffer, current index, and a pending invalid token; it moves the index forward one byte at a time.
- A token consists of a tag (enum with ~120 possible types) and a location (start and end indices).
- The next() function uses a state machine that looks one character at a time to determine the token, without peeking forward or backward.
- The implementation uses nested while loops and switches on state and character to build tokens like identifiers or keywords.
- The tokenizer's output is passed to the parser, which creates an abstract syntax tree.
Ghostty Devlog 001
16 hours ago
- Ghostty is a GPU-accelerated terminal emulator written in Zig, supporting macOS and Linux, with Windows support planned.
- Its tech stack includes libxev event loop, OpenGL/Metal graphics, SwiftUI/GTK/GLFW frontends, and custom font rendering via FreeType, Harfbuzz, and CoreText.
- Automatic shell integration injection (#191) enables features like complex prompt redrawing on resize, working directory reporting, and safe terminal closing without confirmation.
- A bug fix (#179) ensures that missing glyphs in a given font style first try the regular style before falling back to other fonts, preventing ugly proportional font rendering.
- Ghostty now programmatically skews regular fonts to create fake italics when a font lacks italic faces, using a 15-degree skew transformation.
Talk: Introducing Ghostty and Some Useful Zig Patterns
16 hours ago
- Ghostty is a new terminal emulator written in Zig, aiming to combine speed, feature richness, and native platform integration.
- The talk highlights Zig patterns used in Ghostty, including comptime interfaces, data tables, and type generation for zero-cost abstractions.
- Ghostty is currently in closed beta with source access, planned for free and open-source release under GPL (likely) in 2024.
- On macOS, Ghostty uses Swift for native UI (AppKit, SwiftUI), while Linux uses GTK, with the core logic in Zig.
- Key features: fast rendering (480-500 FPS in stress test), multiple font styles, splits, true color, Kitty graphics protocol, and native error messages.
- Future work includes GUI settings, iCloud sync, performance improvements, memory optimization, fuzzing, and expanding the beta program.
- The project aims to innovate terminal capabilities beyond traditional emulators, such as progress bars, drag-and-drop, and security features.
Conditionally Disabling Code with Comptime in Zig
16 hours ago
- Zig's comptime allows running standard Zig code at compile time, without side effects, for conditional compilation.
- Conditional code disabling is useful for platform-specific code, debugging, and build configuration, avoiding runtime conditionals and reducing binary size.
- Unlike C's preprocessor (separate language) and Go's file-level build tags (external build system), Zig uses normal Zig code with comptime.
- The compiler automatically evaluates comptime conditions; the `comptime` keyword is optional but can make intent explicit.
- Example: `if (comptime builtin.os.tag == .macos) { ... }` omits non-macOS code when targeting macOS.
- Comptime can mix with runtime conditions; false comptime conditions cause the compiler to skip the entire block, avoiding errors from missing libraries or types.
- Gotcha: comptime doesn't cross function boundaries by default; use `comptime` keyword before the function call or mark the function as `inline`.
- Comptime is a killer feature for cross-platform code, eliminating the need for complex build systems or external tools.
Pledging $300,000 to the Zig Software Foundation
16 hours ago
- Mitchell Hashimoto and his wife pledged $300,000 to the Zig Software Foundation.
- Hashimoto has followed Zig since 2019, contributed to the compiler, and uses Zig for his terminal project Ghostty.
- He supports independent software projects that are transformative, well-managed, and built out of passion.
- Zig is described as ambitious, innovative, practical, and has a clear path to stability and industry adoption.
- About a third of ZSF funding comes from individual donations, and a call for donations is made.
Ghostty: Reflecting on Reaching 1.0
16 hours ago
- Ghostty 1.0 is released; the author reflects on the project's journey.
- The project started as a way to learn Zig and graphics programming, not intended for public release.
- The private beta helped manage bandwidth and family time but also caused hype and frustration.
- The tech stack uses Zig for the core and platform-specific GUIs, which proved successful.
- The community formed around Ghostty is passionate about performance, design, and quality.
- Post-1.0 plans include fixing bugs and releasing a standalone libghostty for other projects.
- The author thanks the beta community, Discord moderators, and his wife for support.
We Rewrote the Ghostty GTK Application
16 hours ago
- Ghostty's GTK application was rewritten to fully embrace GObject type system from Zig, leading to better feature richness, stability, and maintainability.
- The rewrite solved memory management bugs by wrapping Zig-owned Config structures in reference-counted GObjects, simplifying configuration reload and GUI updates.
- Valgrind was used extensively to verify every change, identifying memory leaks and undefined access, especially at C API boundaries.
- Zig's own codebase had only one leak and one undefined access, both at C API boundaries, highlighting Zig's memory safety features.
- The rewrite enabled use of modern GTK UI technologies like Blueprint, allowing easier addition of GUI features such as titlebar tabs and animated bell border.
- Valgrind caught subtle issues like improper GObject WeakRef clearing, which could cause rare crashes, emphasizing the need for tooling when crossing C APIs.
- The new GTK application is now the default build from source and will be included in Ghostty 1.2 release.
Zig Builds Are Getting Faster
16 hours ago
- Zig 0.15.1 shows significant build time improvements over 0.14, as experienced by the Ghostty project.
- Build script compilation time dropped from 7 seconds to 1.7 seconds.
- Full uncached binary build time decreased from 41 seconds to 32 seconds.
- Incremental build for the Ghostty executable improved from 19 seconds to 16 seconds.
- Incremental build for libghostty-vt dropped from 2.9 seconds to 0.975 seconds, already sub-second.
- These gains are achieved despite most of Ghostty still using LLVM and incremental compilation not yet fully functional.
- The self-hosted x86_64 backend is stable enough for debug builds, and further improvements are expected soon.
Don't Trip[wire] Yourself: Testing Error Recovery in Zig
16 hours ago
- - Mitchell Hashimoto wrote Tripwire, a Zig library for injecting failures to test error recovery, which is optimized away outside tests with zero runtime cost.
- - Zig's `errdefer` runs code on block exit only when an error is returned, but testing error codepaths is difficult due to low execution frequency.
- - Tripwire allows named failure points in code, enabling tests to trigger specific errors and verify `errdefer` cleanup via tools like `std.testing.allocator` to detect leaks.
- - The library uses `comptime` to detect test builds, making checks zero-cost (no memory or machine code) in release builds.
- - Integration into Ghostty uncovered ~6 `errdefer` bugs, which were fixed with tests to prevent regression.
Zig In-Depth Overview
3 days ago
- Zig is a small, simple language with no hidden control flow, no hidden memory allocations, no preprocessor, and no macros.
- It offers four build modes (Debug, ReleaseSafe, ReleaseFast, ReleaseSmall) that can be mixed at scope granularity for performance and safety.
- Zig is faster than C due to whole compilation unit optimization, careful illegal behavior, SIMD vector types, and advanced CPU features enabled by default.
- The standard library integrates with libc but does not depend on it; Zig can produce very small static executables (e.g., 9.8 KiB for Linux).
- Zig uses optional types instead of null pointers, requiring explicit handling of null with `orelse` or `if`/`while`.
- Memory management is manual; all allocation functions accept an allocator parameter, and `defer`/`errdefer` simplify resource management.
- Errors are values that cannot be ignored, handled with `catch` or `try`, and can be exhaustively checked with `switch`.
- Zig supports compile-time code execution, reflection via `@typeInfo`, and generic data structures via functions returning types.
- C libraries can be directly imported with `@cImport` without bindings; Zig can also compile C code and export functions with the C ABI.
- Cross-compilation is a first-class feature; Zig ships libc for all supported targets, enabling cross-compilation without system files.
- Zig includes a build system and package manager with support for dependency fetching, system integration, and reproducible builds.
- Target support is tiered, and Zig is friendly to package maintainers with deterministic builds and JSON download pages.
Zig by Example
3 days ago
- Zig is a general-purpose programming language designed for robust, optimal, and reusable software.
- Official documentation is available for further learning.
- Zig by Example is a hands-on introduction using annotated example programs.
- The examples are written for version 0.16; check your version if something isn't working.
Buz – A fork of Bun using modern Zig, with sub-1s incremental builds
4 days 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.
How Our Rust-to-Zig Rewrite Is Going
12 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.
My Thoughts on the Bun Rust Rewrite
19 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.
Zig: All Package Management Functionality Moved from Compiler to Build System
24 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.

zig

Unboxed: Zig

256 Lines or Less: Test Case Minimization

Minimal Viable Zig Error Contexts

Zig Tokenizer

Ghostty Devlog 001

Talk: Introducing Ghostty and Some Useful Zig Patterns

Conditionally Disabling Code with Comptime in Zig

Pledging $300,000 to the Zig Software Foundation

Ghostty: Reflecting on Reaching 1.0

We Rewrote the Ghostty GTK Application

Zig Builds Are Getting Faster

Don't Trip[wire] Yourself: Testing Error Recovery in Zig

Zig In-Depth Overview

Zig by Example

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

How Our Rust-to-Zig Rewrite Is Going

My Thoughts on the Bun Rust Rewrite

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