Zig Programming Language

From the README:

Zeppelin is a cross-platform 2D graphics and window library in pure Zig*. It features hardware-accelerated vector graphics (through Vulkan), built-in text rendering, and a window system integration for windows and linux (wayland only). Android support is planned.

From the README:

Zigft is a small library that lets you perform function transform in Zig. Consisting of just two files, it's designed to be used in source form. Simply download the file you need from this repo, place it in your src directory, and import it into your own code.

Here's one of the examples given:

const std = @import("std");
const fn_transform = @import("./fn-transform.zig");

fn attachDebugOutput(comptime func: anytype, comptime name: []const u8) @TypeOf(func) {
    const FT = @TypeOf(func);
    const fn_info = @typeInfo(FT).@"fn";
    const ns = struct {
        inline fn call(args: std.meta.ArgsTuple(FT)) fn_info.return_type.? {
            std.debug.print("{s}: {any}\n", .{ name, args });
            return @call(.auto, func, args);
        }
    };
    return fn_transform.spreadArgs(ns.call, fn_info.calling_convention);
}

pub fn main() void {
    const ns = struct {
        fn hello(a: i32, b: i32) void {
            std.debug.print("sum = {d}\n", .{a + b});
        }
    };
    const func = attachDebugOutput(ns.hello, "hello");
    func(123, 456);
}

A 2D graphics library, written in pure Zig. CPU rendering.

This is the second of two simdjson ports for Zig, the other one being simdjzon

From the README:

Welcome to zimdjson: a high-performance JSON parser that takes advantage of SIMD vector instructions, based on the paper Parsing Gigabytes of JSON per Second.

The majority of the source code is based on the C++ implementation https://github.com/simdjson/simdjson with the addition of some fundamental features like:

• Streaming support which can handle arbitrarily large documents with O(1) of memory usage.
• An ergonomic, Serde-like deserialization interface thanks to Zig's compile-time reflection. See Reflection-based JSON.
• More efficient memory usage.

From the ingress:

This post can be considered an advanced Zig tutorial. I will be covering some of the more unique aspects of the language, but won’t be explaining the easy part. If you haven’t read the Zig Language Reference, you might start there. Additionally, we will also learn the foundational trick for implementing relational model.

You will learn a sizable chunk of Zig after this post, but this isn’t going to be an easy read, so prepare your favorite beverage and get comfy!

From the README:

You're looking at xit, a new version control system. Here be dragons, as they say. This is new and unstable software. Maybe one day it will be a worthy successor to git, but for now, only use it if you're adventurous. Here are the main features:

• git compatible
  • supports the git networking protocol for push/fetch/clone
  • read more about git compatibility
• combine snapshot-based and patch-based version control
  • merging and cherry-picking uses patches like Darcs and Pijul
  • restoring files and anything sent over the network uses snapshots like git
  • read more about snapshots vs patches
• built-in TUI
  • all functionality will be exposed via the TUI
  • for now though, it only shows log and status...baby steps!
  • read more about the TUI
• store large/binary files efficiently
  • uses a modern chunking algorithm (FastCDC) to deltify large files
  • doesn't compress binary files...it has no benefit and can even make them larger
  • read more about chunking
• universal undo
  • any change to the repo can be cleanly undone
  • this feature is still under development, so it's not available yet
  • read more about the immutable database
• clean implementation
  • uses no third-party libraries in production...all bugs are our bugs
  • can be easily used as a library in other projects
  • contains a reuseable git implementation in pure Zig
  • read more about xit's internals and using xit as a library

From the README:

A Breakout-clone written in Zig.

You can play the web build here: https://arvidsson.io/project-zball.html

Tween is a lerp/tween library written in Zig by game developer Mason Remaley*___*

The Zig compiler is moving from json to zon for certain outputs

This tool helps parse that output

From the README:

Abelha (Portuguese for "bee") is a high-performance, lightweight parser combinator library for Zig, inspired by Rust's nom. Designed for efficiency, composability, and ease of use, Abelha helps you build powerful parsers with minimal effort.

Features

• ✅ Combinator-Based Parsing – Compose small parsers into complex ones seamlessly.
• ✅ Extensible & Ergonomic – Define your own combinators for maximum flexibility.

From the README:

Similar to std.MultiArrayList() but backed by fixed size arrays with a shared runtime length.

Each field of T becomes an array with max length buffer_capacity. To access the arrays as slices use items(field) or constItems(field).

Useful when a struct of small arrays is desired with capacity that is known at compile time. Like std.BoundedArray, MultiBoundedArrays are only values and thus may be copied.

Roc's compiler is being rewritten in Zig primarily due to significantly faster compile times, which have been a major pain point in Rust.

Zig's allocator-based memory management, better tooling for static binaries, and built-in support for optimization techniques (like struct-of-arrays and bit-packing) align better with Roc’s needs.

From the README:

... a self-contained sample Zig codebase capable of building a Nintendo 64 ROM. Nothing shows up on the screen (yet), but it'll nonetheless run on real hardware (with debug output via USB on a SummerCart 64) or on low-level emulators like Ares (with debug output if the emulator supports ISViewer-based debug logging).

From the README:

Welcome to ZigROS! ZigROS is an alternative build system for ROS2 utilizing the zig tool chain. ZigROS prioritizes static, single executable builds and edge deployments. Wrapping all the core C and C++ libraries, it greatly simplifies the ROS installation and deployment process by masquerading ROS2 as a single library. Simply include ZigROS as a dependency in your build.zig.zon and start building. No messing about with your package manager, ROS dep, or docker required.

ZigROS is suitable for building applications that depend on rcl or rclcpp. This includes interface generation for c and c++. Since the main goal of this project is static builds, python at runtime is out of scope. Python at build time is still required since ROS relies heavily on empy for the code generation. See the python section later on for more detail on how python is used.

From the README:

A (partial) implementation of the Lox scripting language from the book Crafting Interpreters, in Zig.

Enough of the compiler and vm are complete to run some interesting programs.

From the README:

This library is a wrap for original MinHook library. It's uses Zig build system to statically-compile source library and uses MinHook.h header file to wrap library functions.

Great interactive blog post about the Zig comptime feature

From the README:

Simple and fast general purpose work queue. The beauty of Beanstalkd is its absolute simplicity.

beanstalkz is a Zig client to beanstalkd

Ghostty, a terminal emulator written in Zig, just hit 1.0. Here's the HN discussion: https://news.ycombinator.com/item?id=42517447

From the README:

A high-performance bleeding edge Discord library in Zig, featuring full API coverage, sharding support, and fine-tuned parsing

Sharding Support: Ideal for large bots, enabling distributed load handling. 100% API Coverage & Fully Typed: Offers complete access to Discord's API with strict typing for reliable and safe code. High Performance: Faster than whichever library you can name (WIP) Flexible Payload Parsing: Supports payload parsing through both zlib and zstd*. Proper error handling

From the README:

Commy is a small utility used to connect and monitor serial, UART or COM port devices.

Commy runs on Mac, Linux and Windows. Windows support is experimental.

Does (some of) the same things as tio, minicom, screen, miniterm.py, zcom, PuTTY, etc.

FFI and C interop and how to do it safely from Zig