Hasty Briefsbeta

All tags

zig

28 stories total

Bilingual

Show HN: I worked on a new browser for 2 years, today it passed Acid 3
2 months ago
- cwbrowser is a desktop web browser with a rendering engine built entirely from scratch in Zig, except for Google's V8 for JavaScript.
- The browser's HTML parser, CSS cascade, layout engine, and paint pipeline are all hand-written in Zig, making it lightweight and about 2x faster than Chrome in early tests.
- It achieves a perfect Acid3 score, proving its compliance with web standards.
- The project is a solo effort over two years, aiming to create a smaller, faster, and understandable browser engine.
- A public preview for macOS on Apple Silicon is forthcoming.
A GTK4 SSH-askpass in Zig
2 months ago
- - A GTK4 ssh-askpass tool implemented in Zig 0.16 to avoid X11 dependencies, unlike existing Gentoo options that pull in X11 or KDE.
- - The tool uses hand-written GTK/GLib bindings instead of `@cImport` to keep X11 headers out of the build, allowing it to work on systems with the global `-X` USE flag.
- - It supports cross-compiling for multiple Linux architectures (e.g., x86_64, aarch64, riscv64) via a stub `libgtk-4.so.1` for linking.
- - Note: The tool does not perform keyboard grabbing due to GTK4 and Wayland limitations, making the GNOME_SSH_ASKPASS_GRAB variables ineffective.
- - Usage involves setting `SSH_ASKPASS` and `SSH_ASKPASS_REQUIRE=prefer` in shell or systemd config files, enabling passphrase dialogs for SSH without a terminal.
Overengineered Calculator: Zig and QBE
2 months ago
- Crafting Interpreters and Writing An Interpreter In Go teach tokenization, parsing, and interpretation but do not cover native code generation.
- QBE is a compact compiler backend providing 70% of the performance of industrial compilers in 10% of the code, ideal for learning code generation.
- The project uses a simple grammar for arithmetic expressions to define precedence and tokenization rules.
- The tokenizer is a state machine implemented in Zig, producing tokens like numbers, operators, and parentheses.
- The parser builds an AST with binary and unary operations based on grammar rules like Sum, Product, and Unary.
- The interpreter evaluates the AST directly by recursively computing values for binary and unary operations.
- The emitter generates QBE intermediate language in static single-assignment form, mapping operations to QBE instructions.
- The compiler stages include generating QBE SSA code, using QBE to produce assembly, and then compiling with Zig to create an executable.
- QBE optimizes by constant folding when possible, but division prevents full optimization, producing explicit assembly instructions.
- The project requires QBE and Zig packages to build and run, with source code available for further development.
Tagged Union Subsets with Comptime in Zig
2 months ago
- Zig supports tagged unions with compiler-enforced exhaustive switch handling, preventing bugs when new cases are added.
- Working with a subset of a tagged union often requires a catch-all or listing all ignored cases, losing compiler safety or being verbose.
- A real-world example: Ghostty keybind actions need to separate app-wide actions from terminal-specific actions without losing exhaustiveness.
- Solution: Use Zig's comptime to generate a subset union type via a `ScopedAction(Scope)` function that filters fields based on a `scope()` function.
- The `ScopedAction` function uses `@typeInfo`, `@unionInit`, and `@Type` to reify a new union type containing only scoped actions at compile time.
- A `scoped()` method converts a full `Action` to a subset using `inline else` and comptime checks, returning null if the action is not in the target scope.
- This approach maintains compile-time safety, self-documenting function signatures, and zero runtime cost for type generation.
- Zig's comptime enables powerful type-level programming, balancing type safety with pragmatism.
Zig AstGen: AST => ZIR
2 months ago
- After building the AST, the next step in Zig compiler is generating the Zig Intermediate Representation (ZIR) using the AstGen stage.
- ZIR is an untyped intermediate representation, meaning types are not fully evaluated until later comptime analysis.
- ZIR consists of a sequence of instructions, each with a tag and data, often referencing other instructions or static values.
- AstGen introduces scope awareness, identifier resolution, and string interning, storing strings in a continuous array to free AST and source.
- ZIR instructions can embed static values, reference other instructions via index, or use tagged references for well-known primitives.
- Variable assignments in ZIR do not generate explicit instructions; instead, they are tracked via scopes that reference the value's instruction index.
- AstGen is run once per file, converting the entire AST into ZIR eagerly, and is the first stage to perform semantic validation like identifier checks.
Zig Build System Internals
2 months ago
- The Zig build system uses build.zig for configuration and the zig build CLI for execution, compiling a build binary first then executing it as a child process.
- The build binary is built from build_runner.zig in the standard library, which imports the user's build.zig as the @build package.
- The build binary is cached and only recompiled when build.zig or its imports change, avoiding recompilation on subsequent runs.
- The build binary does not embed the Zig compiler; it subprocesses to zig build-exe or other commands to compile artifacts.
- Build steps are defined declaratively in the build function using the Builder API, with dependencies and execution order handled by the build runner.
- Each step has a makeFn function pointer, dependencies, and flags to detect loops and ensure each step executes once.
- The build function supports both void and error union return types, detected via comptime introspection.
- Understanding the internals removes the 'magic' and helps users become more productive with the build system.
Integrating Zig and SwiftUI
2 months ago
- The author advocates writing business logic in a cross-platform language like Zig and using platform-specific GUI code (e.g., SwiftUI) for a native experience, avoiding non-native solutions like Electron.
- Key steps: export a C API from Zig, compile to a static library, merge dependencies with libtool, create a universal binary using lipo, and package as an XCFramework for Xcode.
- The resulting XCFramework is integrated into an Xcode project by dragging it into the Frameworks section, allowing SwiftUI code to import and use the C functions.
- The approach is standard and stable, with the author's terminal app having 94% cross-platform code in Zig/C and only 4% macOS-specific SwiftUI code.
- The author recommends Swift over Objective-C for macOS GUI development, as modern Apple integrations rely on Swift.
Zig's Incremental Compilation Internals
2 months ago
- Zig's incremental compilation detects changed functions/declarations, recompiles only those, and patches the binary for fast rebuilds.
- The feature is now viable for real-world projects and used daily by the Zig core team.
- A demo shows rebuilds taking 50-70ms after an initial 5-second build.
- Per-file processing (parse, AstGen, ZIR) is embarrassingly parallel and cached on disk.
- Semantic analysis uses a dependency graph of analysis units (types, values, bodies) to minimize re-analysis.
- Code generation (AIR to MIR) is embarrassingly parallel and functions are independent.
- Incremental linking uses a MappedFile abstraction for resizing and patchability, avoiding full relinking.
- The linker amortizes movement costs via exponential growth, making slow updates rare.
- Flush includes a reference graph traversal; optimization opportunities remain.
- Usage: run `zig build --watch -fincremental` targeting x86_64-linux; works on Zig master branch.
Zig Parser
2 months ago
- The Zig parser uses a MultiArrayList for efficient memory and cache locality, storing each struct field in separate contiguous arrays.
- AST node data is stored in three locations: the token stream (e.g., identifiers), the node list (child AST nodes), and the extra data list (additional metadata).
- The parser maintains state in a struct called Parser, which includes token arrays, node list, extra data, errors, and scratch space.
- Parsing proceeds by inspecting the current token and using conditional logic to determine expected tokens, building AST nodes incrementally.
- Variable declarations are parsed by first consuming 'const' or 'var', then expecting an identifier, optional type expression, and optional initialization expression.
- Function definitions are parsed by reserving a node index, parsing parameters, calling convention, optional return type, and then setting the node with extra data.
- The final AST structure includes the source text, tokens, nodes, extra data, and accumulated errors, ready for the next compilation stage (AstGen).
Zig Sema: ZIR => AIR
2 months ago
- Sema is the compiler stage after AstGen that produces AIR (Analyzed Intermediate Representation) from ZIR, performing both type analysis and comptime evaluation.
- AIR is fully typed, generated per-function, and consists of instructions, extra data, and a values array for comptime-known constants.
- Key data structures include Value (comptime values), Type (comptime types), and TypedValue (value paired with its exact type).
- The core function analyzeBodyInner loops over ZIR instructions, mapping each to zero or more AIR instructions using the inst_map.
- Comptime evaluation enables constant folding, type coercion, and target-specific emulation, as demonstrated in the addition and type conversion examples.
- Sema is invoked lazily per referenced declaration, supporting Zig's lazy analysis for fast compilation and minimal codegen.
- After Sema, AIR is passed to codegen backends (LLVM, WASM, etc.) for final lowering to machine code.
Unboxed: Zig
2 months 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
2 months 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
2 months 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
2 months 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
2 months 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
2 months 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
2 months 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
2 months 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
2 months 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
2 months 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.

firstprev0next

zig

Show HN: I worked on a new browser for 2 years, today it passed Acid 3

A GTK4 SSH-askpass in Zig

Overengineered Calculator: Zig and QBE

Tagged Union Subsets with Comptime in Zig

Zig AstGen: AST => ZIR

Zig Build System Internals

Integrating Zig and SwiftUI

Zig's Incremental Compilation Internals

Zig Parser

Zig Sema: ZIR => AIR

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