xmake is a cross-platform build utility based on Lua. Features:

• Built-in caching and parallel compilation,

• Concise Lua syntax,

• Custom rules, plugins and modules,

• Support for C++20 modules and compile_commands.json,

• Support for languages outside C/C++ (e.g. Go, Rust, Zig).

Build is a massively-parallel software build system implemented on top of GNU Make, designed with the following tasks in mind:

• configuration

• building

• testing

• installation

Build has features such as:

• Position-independent makefiles.

• Non-recursive multi-makefile include-based structure.

• Leaf makefiles are full-fledged GNU makefiles, not just variable definitions.

• Complete dependency graph.

• Inter-project dependency tracking.

• Extensible language/compiler framework.

Tup is a generic build system based on a directed acyclic graphs of commands to be executed. Tup instruments your build to detect the exact dependencies of the commands, allowing you to take advantage of ideal parallelism during incremental builds, and detecting any situations where a build worked by accident.

SCons is a software construction tool. Think of SCons as an improved, cross-platform substitute for the classic Make utility with integrated functionality similar to autoconf/automake and compiler caches such as ccache. In short, SCons is an easier, more reliable and faster way to build software.

haredo is a build automator. It is an alternative to e.g. make(1) and redo(1). Features:

• Script syntax is plain shell script,

• Only one command with few extraneous rules,

• .do files are short and modular like in redo,

• Builds its dependency tree on the fly, uses no database,

• Doesn't break the build state when interrupted.

premake4 is a command line utility that reads a scripted definition of a software project and outputs Makefiles or other lower-level build files.

Maak is a command runner and control plane for your projects. It allows you to use the power of Lisp (Guile Scheme) to define your tasks, build steps, repetitive tasks or other automation.

With Maak you can easily call external shell commands and integrate with your existing scripts and tools. It is inspired by the GNU Make utility but it does away with a lot of the complexity that comes with its history.

uv is a high-performance Python package and project manager written in Rust, known for its execution speed and compatibility with existing tools.

ToyBox combines tiny versions of many common UNIX utilities into a single small executable. It provides a fairly complete environment for any small or embedded system.

BusyBox combines tiny versions of many common UNIX utilities into a single small executable. It provides a fairly complete environment for any small or embedded system.

This package provides an implementation of JSON in ANSI C as specified in RFC 8259. Features:

• Fast: can read or write gigabytes per second JSON data on modern CPUs.

• Portable: complies with ANSI C (C89) for cross-platform compatibility.

• Strict: complies with RFC 8259 JSON standard, ensuring strict number format and UTF-8 validation.

• Extendable: offers options to allow comments, trailing commas, NaN/Inf, and custom memory allocator.

• Accuracy: can accurately read and write int64, uint64, and double numbers.

• Flexible: supports unlimited JSON nesting levels, \u0000 characters, and non null-terminated strings.

• Manipulation: supports querying and modifying using JSON Pointer, JSON Patch and JSON Merge Patch.

• Developer-Friendly: easy integration with only one .h and one .c file.

QBE is a small compiler backend using an SSA-based intermediate language as input.

This manual explains the C language for use with the GNU Compiler Collection (GCC) on the GNU/Linux system and other systems. We refer to this dialect as GNU C. If you already know C, you can use this as a reference manual.

The unifdef utility selectively processes conditional C preprocessor #if and #ifdef directives. It removes from a file both the directives and the additional text that they delimit, while otherwise leaving the file alone. It can be useful for avoiding distractions when studying code that uses #ifdef heavily for portability.

Concurrency Kit (ck) provides concurrency primitives, safe memory reclamation mechanisms and non-blocking (including lock-free) data structures designed to aid in the research, design and implementation of high performance concurrent systems developed in C99+.

sfsexp is a C/C++ library to read, parse, modify, and create symbolic expressions.

Relaxed Radix Balanced Trees are an immutable vector-like data structure with good performance characteristics for concatenation and slicing.

tinydir is a header-only C wrapper for listing directory contents.

The Permuted Congruential Generator (PCG) extends the Linear Congruential Generator (LCG) with a permutation function to increase output randomness while retaining speed, simplicity, and conciseness.

The UDUNITS-2 package provides support for units of physical quantities. Its three main components are:

1. udunits2lib, a C library for units of physical quantities;

2. udunits2prog, a utility for obtaining the definition of a unit and for converting numeric values between compatible units; and

3. an extensive database of units.

This library is a C99 implementation to read TOML text documents.

This library is compatible with the v1.0.0 specification of the language.

This C library provides a schema-driven structured log data format for the ease of writing and parsing.

A simple one header solution to supporting UTF-8 strings in C and C++. The functions it provides are like those from the C header string.h, but with a utf8* prefix instead of the str* prefix.

This package provides a header-only C library, that implements several sorting algorithms. It is configured using macros and supports user-defined types.