cryptocode

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*

Bio is an experimental Lisp dialect similar to Scheme, with an interpreter written in Zig.

Features include macros, garbage collection, error handling, an object/module facility, and a standard library.

Feel free to post questions and feedback.