From the README:

An effortless command-line argument parser for Zig.

Features

• Zero allocations.
• Declaratively define your command as a plain Zig type.
• Single-function API.
• Multi-level subcommands.
• Automatic help message generation at comptime.

From the README:

• Simple to use: Minimal and customizable keymaps with vim binding support.
• Image Previews: Preview images with Kitty terminal.
• File Previews: Preview contents of files directly in the terminal.
• Configurable Options: Customize settings via an external configuration file.

From the README:

Zig currently does not have a built-in, general purpose Set data structure at this point in time. Until it does, try this!

Rationale: It may be common knowledge that a dictionary or map or hashset can be used as a set where the value is basically void. While this is true, there's a lot to think about in terms of supporting all the common set operations in a performant and correct way and there's no good reason why a common module for this can't exist. After studying the Zig stdlib, I'm hoping this implementation can fill that gap and provide some value.

From the README:

This library is a friendly refactor of TigerBeetle's flags module that adds support for:

• subcommand specific help messages; and
• short options (-k=v).

From the README:

arbor

For the future of plugin development

Goals

• Dead-simple plugin development. Write <= 100 lines of code and have a runnable blank-slate plugin.

• Ideally only require Zig as a toolchain dependency, not as a programming language. You should be able to write plugins in C/C++/whatever and easily link that code to Arbor via a C API and the Zig build system.

  • Could also have a get_zig.sh that will download latest stable Zig if you don't already have it

• Easy cross-compilation. Compile to Mac/Linux/Windows from Mac/Linux/Windows, batteries included.

• Cross-platform graphics. A simple software renderer (like Olivec), but also native graphics programming, potentially using something like sokol, or making a thin wrapper around Direct2D/CoreGraphics for cross-platform graphics abstraction, giving the programmer a simple choice with little-to-no platform-specific considerations.

• Simple, declarative UI design. Possibly with the option of using a custom CSS-like syntax (or Ziggy) to declare, arrange, and style UI widgets at runtime or compile-time, all compiling to native code--not running in some god-forsaken web browser embedded in a plugin UI 🤮

Have:

• A nice abstraction layer over plugin APIs which should lend itself nicely to extending support to other APIs

• Easy comptime parameter generation

• Basic CLAP audio plugin supporting different types of parameters, sample-accurate automation

• A janky VST2 implementation that works in Reaper and mostly works in other DAWs

• Simple, portable software rendering using Olivec and a custom text rendering function with a bitmap font

From the README:

Ly is a lightweight TUI (ncurses-like) display manager for Linux and BSD.

[...]

Ly should work with any X desktop environment, and provides basic wayland support (sway works very well, for example).

From the README:

A Zig wrapper around md4c for parsing Markdown.

Exposes a single function that puts a parser type together from comptime-known Zig functions. The generalisation to using vtables is left as an exercise to the user.

From the README:

This library provides a simple and efficient way to generate and manipulate UUIDs (Universally Unique Identifiers) in Zig.

Features

• Generate UUIDs of all versions (1, 3, 4, 5)
• Parse UUIDs from strings
• Convert UUIDs to strings, 128-bit integers, and byte-arrays
• Access to parts of UUID (time_low, time_mid, node, etc.)

The code in this video can be found here: https://codeberg.org/dude_the_builder/zig_master

From the announcement:

Regular expressions follow the PCRE syntax. This update has a full regex parser and finite-state-automaton generator that builds parsing trees at comptime. All parsing trees are stateless and have @sizeOf(T) == 0.

To use Regex, just look for the fluent.match function and provide your expression string and source string: fluent.match("[abc]\d+", str)

It’s an on going process, but it’s at a point where people can start using them and be on the lookout for more updates!

Fluent can be found on Github: https://github.com/andrewCodeDev/Fluent

From the README:

Tuile is a Text User Interface library written in Zig.

The only currently supported backend is ncurses [...]

From the README:

z2d is a 2D graphics library primarily designed around rasterizing vector primitives like lines and cubic Beziers. In other words, it's designed around supporting operations that you would see in SVG or other vector languages like PostScript or PDF.

Our drawing model is (loosely) inspired by Cairo: most operations take place through the Context, which connect Patterns (pixel/color sources) and Surfaces (drawing targets/buffers). Paths contain the vector data for filling and stroking operations. Additionally, surfaces can be interfaced with directly.