Hasty Briefsbeta

All tags

#zig

111 stories total

Bilingual

Show HN: Zig Topological Sort Library for Parallel Processing
a year ago
- TopoSort is a Zig library for topological sorting of dependency graphs.
- Features include building dependency graphs, cycle detection, and parallel processing support.
- Supports different node types including integers and slices.
- Installation involves fetching the package via `zig fetch` and updating `build.zig.zon`.
- Usage includes initializing TopoSort, adding dependencies, and processing sorted nodes.
- CLI tool `toposort-cli` available for processing data files in Makefile format.
- Benchmark tests included; MIT licensed.
Zig is a general-purpose programming language
a year ago
- Zig focuses on debugging applications rather than language knowledge, with no hidden control flow, memory allocations, or preprocessor.
- Zig introduces 'Comptime' for metaprogramming, allowing compile-time function calls and type manipulation without runtime overhead.
- Zig can be used to incrementally improve C/C++/Zig codebases, acting as a zero-dependency compiler with cross-compilation support.
- The Zig Software Foundation (ZSF) is a 501(c)(3) non-profit founded in 2020 by Andrew Kelley to support Zig's development.
- ZSF offers paid work to core contributors and is sustained by donations, including corporate sponsors and GitHub sponsors.
Building Statically Linked Go Executables with CGO and Zig
a year ago
- Explains how to create a statically linked Go executable with CGO dependencies using Zig.
- Details steps to set up a Zig static library and configure build.zig for static linking.
- Provides a simple Zig function example with C ABI and corresponding C header file.
- Shows Go code that calls the Zig function and includes necessary CGO flags for static linking.
- Includes a bash command to build the Go executable with static linking.
- Verifies the static linking by checking the executable with ldd.
- Expresses appreciation for Go and Zig tools and suggests donating to the Zig Software Foundation.
Zig's new LinkedList API (it's time to learn fieldParentPtr)
a year ago
- Zig's SinglyLinkedList and DoublyLinkedList have been updated to use intrusive linked lists, which embed the node within the data structure for better performance and fewer allocations.
- The new SinglyLinkedList structure is simpler and does not directly reference the data it contains, requiring the use of @fieldParentPtr to access the parent data structure from a node.
- An example demonstrates how to use the new API, including creating users with embedded nodes, prepending them to the list, and iterating through the list to print user data.
- @fieldParentPtr is introduced as a builtin function to safely obtain the parent structure from a field pointer, leveraging the known offset of the field within the structure.
- The post discusses the trade-offs of the new API, acknowledging the complexity introduced by @fieldParentPtr but recognizing its utility in solving certain problems efficiently.
A high-throughput parser for the Zig programming language
a year ago
- A high-throughput tokenizer and parser for the Zig programming language is being developed.
- Two tokenizer implementations are provided: one using bitstrings for skipping continuation-character matching and another using vector compression for simultaneous token extents.
- Performance improvements include 2.75x faster tokenization and 2.47x less memory usage compared to the mainline implementation.
- Optimization strategies include SIMD, SWAR, reducing unpredictable branches, and perfect hash functions.
- Memory consumption is reduced by storing token lengths instead of start indices and using fewer variables.
- Future plans include fixing the UTF-8 validator, implementing the AST parser, and integrating the repository with the Zig compiler.
Zig and GPUs
a year ago
- GPU programming is evolving with modern languages like Rust and Zig, reducing reliance on C++ and vendor-specific tools.
- Zig's GPU backend supports SPIR-V for Vulkan and OpenCL, and can generate PTX for NVIDIA and AMDGCN for AMD GPUs.
- Vulkan and OpenCL differ in capabilities, with OpenCL supporting more features like Kernel and Addresses, leading to higher test pass rates in Zig.
- Challenges include managing address spaces in SPIR-V and differences in hardware-accelerated math instructions between Vulkan and OpenCL.
- Future goals include improving SPIR-V validation, increasing test pass rates, adding CUDA/HIP bindings, and expanding GPU-compatible algorithms in Zig's stdlib.
Zack: A Simple Backtesting Engine in Zig
a year ago
- Zack is a lightweight backtesting engine for trading strategies written in Zig.
- It simulates trading using historical OHLCV data, processing bar-by-bar.
- Zig offers performance, memory control, and simplicity advantages.
- The backtesting process involves initialization, event loop, and results logging.
- Core components include DataHandler, Portfolio, Strategy, and ExecutionHandler.
- The engine currently implements a simple 'Buy and Hold' strategy.
- Configuration is done via JSON files for strategy and main parameters.
- OHLCV data is expected in CSV format with specific columns.
- The project structure includes config, data, and src directories.
- Future plans include more metrics, strategies, technical indicators, and tests.
Things Zig Comptime Won't Do
a year ago
- Zig's comptime feature is designed to be restrictive and does not allow host leakage, ensuring comptime code behaves consistently across different compilation targets.
- Zig does not support dynamic source code generation (No #eval), instead relying on partial evaluation/specialization for similar outcomes.
- Unlike some languages, Zig does not support Domain-Specific Languages (DSLs) or custom syntax in comptime functions, operating strictly on Zig values.
- Zig requires all type meta programming to be specialized away, with no Runtime Type Information (RTTI), ensuring types as values only exist at compile time.
- Comptime in Zig cannot extend the API of generated types; methods cannot be added to generated types, keeping their API hand-written and predictable.
- Zig comptime does not allow any Input/Output operations, making compile-time evaluation hermetic, reproducible, safe, and cacheable, though external tools can be used for code generation.
Deus Lex Machina: releasing a new compacting Zig tokenizer
a year ago
- Alpha release of a new compacting Zig tokenizer announced.
- Currently supports AMD64 machines with AVX-512 instructions.
- Tokenizes up to 2.75x faster than the mainline implementation (1.4GB/s on a single core).
- Benchmarks show significant improvements in speed and memory usage.
- Features include SIMDized UTF-8 validation, branchless bit-manipulation, and vectorized table-lookup.
- Future plans include processing 512-byte chunks and additional optimizations.
- Instructions provided for running the benchmark on qualifying machines.
Reflecting on a Year of Gamedev in Zig
a year ago
- The author reflects on one year of game development in Zig, sharing insights applicable beyond gamedev.
- The Zig Discord community is highly responsive, solving both beginner and intermediate-level problems quickly.
- An example problem with CPU instruction sets was resolved swiftly thanks to the Zig Discord.
- Zig has built-in support for vectors, optimizing operations with SIMD instructions, but lacks built-in matrix support.
- The Zig build system is praised for being clearer and more manageable compared to CMake, Ninja, and Meson.
- The standard library in Zig is still incomplete, requiring occasional workarounds for missing features.
- Zig's compiler undergoes significant, breaking changes regularly, but updates are manageable and bring improvements.
- Compile times have improved with each release, and future updates promise even faster debug builds.
- The introduction of the --watch compile option enhances developer workflow by automatically recompiling on file changes.
- Despite some challenges, the author is positive about Zig's future and continues developing their game in the language.
OCaml Cross Compilation: An Experiment
a year ago
- OCaml cross-compilation is complex and often target-specific, with various efforts addressing different platforms like mobile, Windows, or embedded systems.
- Cross-compilation is useful for mobile/embedded systems, distributing software for other OSs, and cloud environments with different OS requirements.
- Docker simplifies cross-compilation but introduces performance overhead, which is problematic for iterative serverless development workflows.
- Three main components for OCaml cross-compilation: C cross-compiler tools, OCaml cross-compiler, and modified opam packages for the target environment.
- Zig provides a simplified C cross-compilation solution with its `zig cc` toolchain, eliminating the need for complex setup.
- An OCaml cross-compiler overlay repository for Amazon Linux 2023 (x86_64 and aarch64) uses Zig under the hood.
- Packages must be cross-compiled by rewriting opam package definitions, which is tedious and requires handling transitive dependencies.
- `packman` is a tool to automate rewriting opam packages for cross-compilation, though manual intervention is still needed for some cases.
- Future work includes refining `packman`, testing more packages, and exploring dune-based package management to avoid opam rewrites.
- Challenges remain for non-Linux targets like Windows and macOS due to assembly instructions in the OCaml compiler.
Memory Safety Features in Zig
a year ago
- Zig emphasizes memory safety while maintaining manual memory management performance.
- No hidden control flow: errors are explicit with the 'try' keyword.
- Comprehensive error handling with error union types forces developers to handle all potential errors.
- Sophisticated compile-time safety checks catch memory issues before runtime.
- Robust runtime bounds checking in safe build modes prevents buffer overflows.
- The 'defer' statement ensures resource cleanup regardless of control flow.
- Optional types prevent null pointer dereferences by making nullable references explicit.
- Multiple build modes (Debug, ReleaseSafe, ReleaseFast, ReleaseSmall) balance safety and performance.
- Sentinel-terminated arrays provide safe string handling compatible with C.
- Explicit allocators clarify memory ownership and prevent leaks.
- Comptime function evaluation enables safe metaprogramming with compile-time checks.
- Explicit pointer casting makes potentially unsafe operations visible.
- The 'errdefer' statement ensures cleanup when errors occur during complex initialization.
- Undefined behavior detection in safe builds catches issues like integer overflow and use-after-free.
- Practical example: A safe double-ended queue implementation demonstrates Zig's memory safety features.
Zig, the Ideal C Replacement Or?
a year ago
- Zig is a general-purpose systems programming language designed for robust, optimal, and reusable software.
- Zig emphasizes explicit control with 'No hidden control flow' as its motto, requiring explicit memory allocation, error handling, and control-flow constructs.
- Zig uses undefined behavior for bug prevention and performance enhancement, but critics argue this contradicts its goals of correctness and robustness.
- Zig's claim of being faster than C was debunked when benchmarks were adjusted for fair comparison.
- Zig's error handling is novel, requiring immediate handling of results, but lacks a simple way to handle all errors in one sweep.
- Zig's compile-time execution (comptime) enables polymorphism, generic types, and conditional compilation, but can be complex and implicit.
- Zig is criticized for verbosity, especially in casts and syntax changes from C, such as replacing 'for' loops with 'while' loops.
- Zig's development has been ongoing for nearly a decade with no clear 1.0 release in sight, raising concerns about feature creep.
- Zig excels in cross-platform compilation, with 'zig cc' being widely adopted as a Clang replacement for cross-compilation.
- Zig's build system (build.zig) is powerful but can be daunting for beginners.
- Zig's safety claims are questioned, as safety checks are often disabled in release builds.
- Zig is compared unfavorably to Odin, which offers more high-level conveniences, making Zig seem more painful to work with than C.
Bold : A Drop-In Replacement For Apple System Linker Written In Zig
a year ago
- Bold is a drop-in replacement for Apple's system linker ld, written fully in Zig.
- It is on par with LLVM lld linker, faster than the legacy Apple ld linker, but slower than the rewritten Apple ld linker.
- Benchmark results show bold is 2.23 times slower than the rewritten Apple ld linker but 2.38 times faster than LLVM lld linker.
- Bold can be used with clang via -fuse-ld=bold or with gcc via -B/path/to/bold.
- To build bold, you need Zig 0.14.0 and can compile it with 'zig build -Doptimize=ReleaseFast'.
- Unit and end-to-end tests can be run with 'zig build test'.
- Contributions to the repository are welcome.
How (memory) safe is Zig? (2021)
a year ago
- Zig's memory safety is often compared to C or Rust, but it doesn't match Rust's systematic prevention of memory unsafety.
- Zig introduces adhoc runtime checks (e.g., bounds checking, null pointer disallowing) but lacks composable compile-time proofs like Rust.
- Zig improves over C with features like allocator APIs for detecting use-after-free, generics, and safer defaults.
- Memory safety bugs in Zig are common, especially in complex projects, unlike Rust, which significantly reduces such issues.
- Zig's future may lie in niches like sandboxed plugins (e.g., WASM) where its small binary size and low memory usage are advantageous.
- Rust's memory safety is appealing for high-performance, secure systems, but managed languages (e.g., Java, C#) are improving in performance.
- Zig's comptime mechanism offers unique compile-time specialization possibilities, inspiring future language design innovations.
Show HN: Zli – A Batteries-Included CLI Framework for Zig
a year ago
- A blazing-fast, zero-cost CLI framework for Zig.
- Modular, ergonomic, and high-performance CLI building.
- Inspired by Cobra (Go) and clap (Rust).
- Features include fast flag parsing, type-safe support for bool, int, string, and named positional arguments.
- Auto help/version/deprecation handling with pretty help output.
- Commands and subcommands are modular and self-contained.
- Easy integration with Zig projects via build.zig.
- MIT licensed with contributions welcome.
A Pokémon battle simulation engine
a year ago
- The project is under heavy development with breaking changes in the main branch; users are advised to wait for the v0.1 release.
- A minimal, performance-optimized Pokémon battle simulation engine designed for tooling, embedded systems, and AI use cases.
- The engine is frame-accurate and bug-for-bug compatible with original game code and Pokémon Showdown simulator.
- Over 1000× faster than Pokémon Showdown in compatibility mode, extensively tested and documented.
- Not a fully featured simulator but a low-level library for advanced use cases.
- Includes engine code in Zig and reference driver code in TypeScript.
- Binaries available on GitHub releases; source code can be built with Zig compiler.
- Zig v0.11.0 recommended; performance issues with versions before 0.12.0-dev.876+aaf46187a.
- Driver code installable via npm; requires compiled Node/WASM addons.
- Supports Pokémon Showdown compatibility mode and protocol message logging.
- Provides battle structure functions for state updates and valid choices per generation.
- C API available for libpkmn; intended as foundation for bindings in other languages.
- Zig package simplifies state instantiation and logging; supports FixedRNG for deterministic outcomes.
- Known bindings available for C++ and Python.
- Includes pkmn-debug tool for decoding binary data structures and protocols.
- Development roadmap includes stages for implementing generations I-IV, with modern generations soft-blocked on decompilations.
- Out of scope features include team validation, mod support, and non-standard battle variants.
- Distributed under MIT License.
Low-Level Optimization with Zig
a year ago
- Optimization is crucial for performance, cost savings, and system simplicity.
- Low-level languages like Zig provide more intent and verbosity, aiding compiler optimizations.
- Zig's 'comptime' feature allows for compile-time code generation and optimization, enhancing performance.
- Zig's 'comptime' can generate optimized code for known compile-time values, improving runtime efficiency.
- Zig's approach to optimization and 'comptime' makes it easier to write performant and clean code.
Zig Devlog: Self-Hosted x86 Back End Is Now Default in Debug Mode
a year ago
- Zig's self-hosted x86 backend is now the default in debug mode for x86_64 targets, outperforming LLVM in compilation speed and robustness.
- A new video tutorial on the Zig build system has been released, aimed at beginners to help them understand and use the build system effectively.
- Support for FreeBSD and NetBSD cross-compilation has been added, enabling users to build binaries targeting these systems from any machine.
- The official Zig website has been updated to use Zine 0.10.0, transitioning from a build script to a standalone executable.
- The upcoming Zig 0.14.0 release is nearing completion, with many enhancements already integrated, though some features didn't make the cut.
- Improved UBSan error messages now provide clearer diagnostics for undefined behavior in C programs compiled with Zig.
- Zig's no-libc implementation now outperforms glibc in certain benchmarks, marking a significant milestone in the language's development.
- An LLDB fork with enhancements for Zig has been introduced to improve debugging support, especially for the self-hosted backends.
Filedb: Disk Based Key-Value Store Inspired by Bitcask
a year ago
- FileDB is a Zig-implementation of Bitcask, inspired by the Riak1 paper.
- It stores record metadata in a log-structured hashtable and keeps one disk file open for appending records.
- On restarts or when MAX_FILE_REACHED, the disk file is rotated, with old files kept open for reading only.
- Compaction runs periodically to combine disk files into one and update the metadata hashtable.
- Sync process syncs open disk files at configurable intervals or on every request if configured.
- Metadata allows O(1) record fetching by tracking exact file and position.
- In-memory metadata is constant size, regardless of record value size.
- High throughput is achieved via append-only mode.
- Provides functions like init, deinit, put, get, delete, list, sync, storeHashMap, and loadKeyDir.
- Includes a Redis-compatible client with demonstrated performance benchmarks.
- Benchmarks show high throughput for set and get operations.
- References to Zig programming resources are provided.

firstprev0next

About|Login

#zig

Show HN: Zig Topological Sort Library for Parallel Processing

Zig is a general-purpose programming language

Building Statically Linked Go Executables with CGO and Zig

Zig's new LinkedList API (it's time to learn fieldParentPtr)

A high-throughput parser for the Zig programming language

Zig and GPUs

Zack: A Simple Backtesting Engine in Zig

Things Zig Comptime Won't Do

Deus Lex Machina: releasing a new compacting Zig tokenizer

Reflecting on a Year of Gamedev in Zig

OCaml Cross Compilation: An Experiment

Memory Safety Features in Zig

Zig, the Ideal C Replacement Or?

Bold : A Drop-In Replacement For Apple System Linker Written In Zig

How (memory) safe is Zig? (2021)

Show HN: Zli – A Batteries-Included CLI Framework for Zig

A Pokémon battle simulation engine

Low-Level Optimization with Zig

Zig Devlog: Self-Hosted x86 Back End Is Now Default in Debug Mode

Filedb: Disk Based Key-Value Store Inspired by Bitcask