Zig Programming Language

A Zig port of Stream VByte encoding

StreamVByte is a new integer compression technique that applies SIMD instructions (vectorization) to Google's Group Varint approach. The net result is faster than other byte-oriented compression techniques.

zigTensor is a fast, flexible machine learning library written entirely in Zig; the design is heavily inspired by the Flashlight library.

Tracks Zig mainline.

Currently target macOS.

This presentation was recorded at GOTO Chicago 2023

ORIGINAL TALK TITLE How to Build Software From Source

PRESENTER Andrew Kelley

Download slides and read the full abstract here

sekao gives his thoughts about Zig after using it for a few months. Touches on memory management, C integration and comptime.

Excerpt:

To me, one of the biggest motivators for efficient enum arrays has been compilers. One problem that keeps coming up when designing an AST is figuring out how to reduce its memory footprint. Big ASTs can incur a hefty performance penalty during compilation, because memory bandwidth and latency are a frequent bottleneck in compiler frontends. Chandler Carruth's video on the Carbon compiler has been making the rounds on language forums. In it he describes how a parsed clang AST regularly consumes 50x more memory than the original source code!

Cases supported:

• camelCase
• PascalCase
• snake_case
• CONSTANT_CASE
• kebab-case
• Header-Case
• lower case
• UPPER CASE
• Capital Case

zig-color is a library to switch between colorspaces

MIT license

From the introduction:

Welcome to Learning Zig, an introduction to the Zig programming language. This guide aims to make you comfortable with Zig. It assumes prior programming experience, though not in any particular language.

Table of contents:

• Installing Zig
• Language Overview - Part 1
• Language Overview - Part 2
• Style guide
• Pointers
• Stack Memory
• Heap Memory & Allocators
• Generics
• Coding In Zig
• Conclusion

Ziggy Pydust is a framework for writing and packaging native Python extension modules written in Zig.

Package Python extension modules written in Zig. Pytest plugin to discover and run Zig tests. Comptime argument wrapping / unwrapping for interop with native Zig types.

Documentation

API

Source Code

Bun is a fast JavaScript package manager written in Zig

Develop, test, run, and bundle JavaScript & TypeScript projects—all with Bun. Bun is an all-in-one JavaScript runtime & toolkit designed for speed, complete with a bundler, test runner, and Node.js-compatible package manager.

Website: https://bun.sh/

Project description:

Easy to use bindings for the tracy client C API.

Dependencies:

Zig 0.11.0 Tracy 0.9.2 (only for viewing the profiling session, this repository is only concerned with client matters)

Features:

• Designed to integrate well with build.zig
• Builds and statically links the tracy client - perfect for cross-compilation
• Uses Zig comptime to nullify the tracy markup when building with tracy disabled
• Provides Zig friendly bindings for:
  • Zone markup
  • Frame markup.
  • Plotting
  • Message printing

2022.1.7-zig0 marks the first official release of wwise-zig

Project description

This package implement a native Zig binding for Audiokinetic Wwise. The included C binding is designed only to be used by the Zig binding.

Release descriptoion

This is the official first release of wwise-zig, a Zig bindings for the Audiokinetic Wwise SDK.

This release supports Wwise 2022.1.7.

Nix is popular amongst Zig users and developers, and the linked article might prove useful if you're thinking about jumping into the world of reproducible environments.

From the article:

Getting into Nix & Nix flakes can be a challenge. You may have have heard of Nix’s fame for reproducibility or Nix flake’s composability, but weren’t sure where or how to start. While some folks seem to settle for a devShell when it comes to Nix, going just a bit deeper, Nix can fullfill more project architecture requirements than merely delivering tooling. In this post we will follow journey of requirements from environment setup, to building, testing, & distributing a “Hello World” Vim plugin as the guide for learning the Nix flakes’s API

Some background:

Delta-state CRDTs: indexed sequences with YATA: https://www.bartoszsypytkowski.com/yata/

An introduction to state-based CRDTs: https://www.bartoszsypytkowski.com/the-state-of-a-state-based-crdts/

Author's description:

An implementation of stackful asymmetric coroutines in Zig (and some assembly).

Allows for 3 kinds of usage: suspend/resume, yield/next (coroutine-based generators), and async/await.

Supports Mac, Linux, and Windows, x86_64 and aarch64 (x86_64 under CI on GitHub).

Planning on hooking this up with libuv or libxev soon so that I can start using async/await-like code before (stackless) async lands.

Source: Zig Discord

From the README:

Async Zig as a library using stackful asymmetric coroutines.

• Stackful: each coroutine has an explicitly allocated stack and suspends/yields preserve the entire call stack of the coroutine. An ergonomic "stackless" implementation would require language support and that's what we expect to see with Zig's async functionality.
• Asymmetric: coroutines are nested such that there is a "caller"/"callee" relationship, starting with a root coroutine per thread. The caller coroutine is the parent such that upon completion of the callee (the child coroutine), control will transfer to the caller. Intermediate yields/suspends transfer control to the last resuming coroutine.

From the ULID specification:

*Universally Unique Lexicographically Sortable Identifier UUID can be suboptimal for many use-cases because:

• It isn't the most character efficient way of encoding 128 bits of randomness
• UUID v1/v2 is impractical in many environments, as it requires access to a unique, stable MAC address
• UUID v3/v5 requires a unique seed and produces randomly distributed IDs, which can cause fragmentation in many data structures
• UUID v4 provides no other information than randomness which can cause fragmentation in many data structures*